Home | History | Annotate | Line # | Download | only in compiler
aslcompiler.h revision 1.10.2.2 
      1 /******************************************************************************
      2  *
      3  * Module Name: aslcompiler.h - common include file for iASL
      4  *
      5  *****************************************************************************/
      6 
      7 /*
      8  * Copyright (C) 2000 - 2018, Intel Corp.
      9  * All rights reserved.
     10  *
     11  * Redistribution and use in source and binary forms, with or without
     12  * modification, are permitted provided that the following conditions
     13  * are met:
     14  * 1. Redistributions of source code must retain the above copyright
     15  *    notice, this list of conditions, and the following disclaimer,
     16  *    without modification.
     17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
     18  *    substantially similar to the "NO WARRANTY" disclaimer below
     19  *    ("Disclaimer") and any redistribution must be conditioned upon
     20  *    including a substantially similar Disclaimer requirement for further
     21  *    binary redistribution.
     22  * 3. Neither the names of the above-listed copyright holders nor the names
     23  *    of any contributors may be used to endorse or promote products derived
     24  *    from this software without specific prior written permission.
     25  *
     26  * Alternatively, this software may be distributed under the terms of the
     27  * GNU General Public License ("GPL") version 2 as published by the Free
     28  * Software Foundation.
     29  *
     30  * NO WARRANTY
     31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
     34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
     39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
     40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     41  * POSSIBILITY OF SUCH DAMAGES.
     42  */
     43 
     44 #ifndef __ASLCOMPILER_H
     45 #define __ASLCOMPILER_H
     46 
     47 #include "acpi.h"
     48 #include "accommon.h"
     49 #include "amlresrc.h"
     50 #include "acdebug.h"
     51 
     52 /* Microsoft-specific */
     53 
     54 #if (defined WIN32 || defined WIN64)
     55 
     56 /* warn : used #pragma pack */
     57 #pragma warning(disable:4103)
     58 
     59 /* warn : named type definition in parentheses */
     60 #pragma warning(disable:4115)
     61 #endif
     62 
     63 #include <stdio.h>
     64 #include <stdlib.h>
     65 #include <string.h>
     66 #include <errno.h>
     67 #include <ctype.h>
     68 
     69 /* Compiler headers */
     70 
     71 #include "asldefine.h"
     72 #include "asltypes.h"
     73 #include "aslmessages.h"
     74 #include "aslglobal.h"
     75 #include "preprocess.h"
     76 #include "dtcompiler.h"
     77 
     78 
     79 /*******************************************************************************
     80  *
     81  * Compiler prototypes
     82  *
     83  ******************************************************************************/
     84 
     85 /*
     86  * Main ASL parser - generated from flex/bison, lex/yacc, etc.
     87  */
     88 ACPI_PARSE_OBJECT *
     89 AslDoError (
     90     void);
     91 
     92 int
     93 AslCompilerlex(
     94     void);
     95 
     96 void
     97 AslResetCurrentLineBuffer (
     98     void);
     99 
    100 void
    101 AslInsertLineBuffer (
    102     int                     SourceChar);
    103 
    104 int
    105 AslPopInputFileStack (
    106     void);
    107 
    108 void
    109 AslPushInputFileStack (
    110     FILE                    *InputFile,
    111     char                    *Filename);
    112 
    113 void
    114 AslParserCleanup (
    115     void);
    116 
    117 
    118 /*
    119  * aslstartup - entered from main()
    120  */
    121 void
    122 AslInitializeGlobals (
    123     void);
    124 
    125 typedef
    126 ACPI_STATUS (*ASL_PATHNAME_CALLBACK) (
    127     char *);
    128 
    129 ACPI_STATUS
    130 AslDoOneFile (
    131     char                    *Filename);
    132 
    133 ACPI_STATUS
    134 AslCheckForErrorExit (
    135     void);
    136 
    137 
    138 /*
    139  * aslcompile - compile mainline
    140  */
    141 void
    142 AslCompilerSignon (
    143     UINT32                  FileId);
    144 
    145 void
    146 AslCompilerFileHeader (
    147     UINT32                  FileId);
    148 
    149 int
    150 CmDoCompile (
    151     void);
    152 
    153 void
    154 CmDoOutputFiles (
    155     void);
    156 
    157 void
    158 CmCleanupAndExit (
    159     void);
    160 
    161 
    162 /*
    163  * aslallocate - memory allocation
    164  */
    165 void *
    166 UtLocalCalloc (
    167     UINT32                  Size);
    168 
    169 void
    170 UtExpandLineBuffers (
    171     void);
    172 
    173 void
    174 UtReallocLineBuffers (
    175     char                    **Buffer,
    176     UINT32                  OldSize,
    177     UINT32                  NewSize);
    178 
    179 void
    180 UtFreeLineBuffers (
    181     void);
    182 
    183 
    184 /*
    185  * aslcache - local cache support
    186  */
    187 char *
    188 UtLocalCacheCalloc (
    189     UINT32                  Length);
    190 
    191 ACPI_PARSE_OBJECT *
    192 UtParseOpCacheCalloc (
    193     void);
    194 
    195 DT_SUBTABLE *
    196 UtSubtableCacheCalloc (
    197     void);
    198 
    199 DT_FIELD *
    200 UtFieldCacheCalloc (
    201     void);
    202 
    203 void
    204 UtDeleteLocalCaches (
    205     void);
    206 
    207 
    208 /*
    209  * aslascii - ascii support
    210  */
    211 ACPI_STATUS
    212 FlIsFileAsciiSource (
    213     char                    *Filename,
    214     BOOLEAN                 DisplayErrors);
    215 
    216 
    217 /*
    218  * aslwalks - semantic analysis and parse tree walks
    219  */
    220 ACPI_STATUS
    221 AnOtherSemanticAnalysisWalkBegin (
    222     ACPI_PARSE_OBJECT       *Op,
    223     UINT32                  Level,
    224     void                    *Context);
    225 
    226 ACPI_STATUS
    227 AnOtherSemanticAnalysisWalkEnd (
    228     ACPI_PARSE_OBJECT       *Op,
    229     UINT32                  Level,
    230     void                    *Context);
    231 
    232 ACPI_STATUS
    233 AnOperandTypecheckWalkEnd (
    234     ACPI_PARSE_OBJECT       *Op,
    235     UINT32                  Level,
    236     void                    *Context);
    237 
    238 ACPI_STATUS
    239 AnMethodTypingWalkEnd (
    240     ACPI_PARSE_OBJECT       *Op,
    241     UINT32                  Level,
    242     void                    *Context);
    243 
    244 
    245 /*
    246  * aslmethod - Control method analysis walk
    247  */
    248 ACPI_STATUS
    249 MtMethodAnalysisWalkBegin (
    250     ACPI_PARSE_OBJECT       *Op,
    251     UINT32                  Level,
    252     void                    *Context);
    253 
    254 ACPI_STATUS
    255 MtMethodAnalysisWalkEnd (
    256     ACPI_PARSE_OBJECT       *Op,
    257     UINT32                  Level,
    258     void                    *Context);
    259 
    260 
    261 /*
    262  * aslbtypes - bitfield data types
    263  */
    264 UINT32
    265 AnMapObjTypeToBtype (
    266     ACPI_PARSE_OBJECT       *Op);
    267 
    268 UINT32
    269 AnMapArgTypeToBtype (
    270     UINT32                  ArgType);
    271 
    272 UINT32
    273 AnGetBtype (
    274     ACPI_PARSE_OBJECT       *Op);
    275 
    276 void
    277 AnFormatBtype (
    278     char                    *Buffer,
    279     UINT32                  Btype);
    280 
    281 
    282 /*
    283  * aslanalyze - Support functions for parse tree walks
    284  */
    285 void
    286 AnCheckId (
    287     ACPI_PARSE_OBJECT       *Op,
    288     ACPI_NAME               Type);
    289 
    290 /* Values for Type argument above */
    291 
    292 #define ASL_TYPE_HID        0
    293 #define ASL_TYPE_CID        1
    294 
    295 BOOLEAN
    296 AnIsInternalMethod (
    297     ACPI_PARSE_OBJECT       *Op);
    298 
    299 UINT32
    300 AnGetInternalMethodReturnType (
    301     ACPI_PARSE_OBJECT       *Op);
    302 
    303 BOOLEAN
    304 AnLastStatementIsReturn (
    305     ACPI_PARSE_OBJECT       *Op);
    306 
    307 void
    308 AnCheckMethodReturnValue (
    309     ACPI_PARSE_OBJECT       *Op,
    310     const ACPI_OPCODE_INFO  *OpInfo,
    311     ACPI_PARSE_OBJECT       *ArgOp,
    312     UINT32                  RequiredBtypes,
    313     UINT32                  ThisNodeBtype);
    314 
    315 BOOLEAN
    316 AnIsResultUsed (
    317     ACPI_PARSE_OBJECT       *Op);
    318 
    319 void
    320 ApCheckForGpeNameConflict (
    321     ACPI_PARSE_OBJECT       *Op);
    322 
    323 void
    324 ApCheckRegMethod (
    325     ACPI_PARSE_OBJECT       *Op);
    326 
    327 BOOLEAN
    328 ApFindNameInScope (
    329     char                    *Name,
    330     ACPI_PARSE_OBJECT       *Op);
    331 
    332 BOOLEAN
    333 ApFindNameInDeviceTree (
    334     char                    *Name,
    335     ACPI_PARSE_OBJECT       *Op);
    336 
    337 /*
    338  * aslerror - error handling/reporting
    339  */
    340 void
    341 AslAbort (
    342     void);
    343 
    344 void
    345 AslDualParseOpError (
    346     UINT8                   Level,
    347     UINT16                  MainMessageId,
    348     ACPI_PARSE_OBJECT       *MainOp,
    349     char                    *MainMessage,
    350     UINT16                  SecondMessageId,
    351     ACPI_PARSE_OBJECT       *SecondOp,
    352     char                    *SecondaryMessage);
    353 
    354 void
    355 AslError (
    356     UINT8                   Level,
    357     UINT16                  MessageId,
    358     ACPI_PARSE_OBJECT       *Op,
    359     char                    *ExtraMessage);
    360 
    361 void
    362 AslCheckExpectedExceptions (
    363     void);
    364 
    365 ACPI_STATUS
    366 AslExpectException (
    367     char                    *MessageIdString);
    368 
    369 ACPI_STATUS
    370 AslDisableException (
    371     char                    *MessageIdString);
    372 
    373 BOOLEAN
    374 AslIsExceptionIgnored (
    375     UINT8                   Level,
    376     UINT16                  MessageId);
    377 
    378 void
    379 AslCoreSubsystemError (
    380     ACPI_PARSE_OBJECT       *Op,
    381     ACPI_STATUS             Status,
    382     char                    *ExtraMessage,
    383     BOOLEAN                 Abort);
    384 
    385 int
    386 AslCompilererror(
    387     const char              *s);
    388 
    389 void
    390 AslCommonError (
    391     UINT8                   Level,
    392     UINT16                  MessageId,
    393     UINT32                  CurrentLineNumber,
    394     UINT32                  LogicalLineNumber,
    395     UINT32                  LogicalByteOffset,
    396     UINT32                  Column,
    397     char                    *Filename,
    398     char                    *ExtraMessage);
    399 
    400 void
    401 AslCommonError2 (
    402     UINT8                   Level,
    403     UINT16                  MessageId,
    404     UINT32                  LineNumber,
    405     UINT32                  Column,
    406     char                    *SourceLine,
    407     char                    *Filename,
    408     char                    *ExtraMessage);
    409 
    410 void
    411 AePrintException (
    412     UINT32                  FileId,
    413     ASL_ERROR_MSG           *Enode,
    414     char                    *Header);
    415 
    416 void
    417 AePrintErrorLog (
    418     UINT32                  FileId);
    419 
    420 void
    421 AeClearErrorLog (
    422     void);
    423 
    424 
    425 /*
    426  * asllisting - generate all "listing" type files
    427  */
    428 void
    429 LsDoListings (
    430     void);
    431 
    432 void
    433 LsWriteNodeToAsmListing (
    434     ACPI_PARSE_OBJECT       *Op);
    435 
    436 void
    437 LsWriteNode (
    438     ACPI_PARSE_OBJECT       *Op,
    439     UINT32                  FileId);
    440 
    441 void
    442 LsDumpParseTree (
    443     void);
    444 
    445 
    446 /*
    447  * asllistsup - Listing file support utilities
    448  */
    449 void
    450 LsDumpAscii (
    451     UINT32                  FileId,
    452     UINT32                  Count,
    453     UINT8                   *Buffer);
    454 
    455 void
    456 LsDumpAsciiInComment (
    457     UINT32                  FileId,
    458     UINT32                  Count,
    459     UINT8                   *Buffer);
    460 
    461 void
    462 LsCheckException (
    463     UINT32                  LineNumber,
    464     UINT32                  FileId);
    465 
    466 void
    467 LsFlushListingBuffer (
    468     UINT32                  FileId);
    469 
    470 void
    471 LsWriteListingHexBytes (
    472     UINT8                   *Buffer,
    473     UINT32                  Length,
    474     UINT32                  FileId);
    475 
    476 void
    477 LsWriteSourceLines (
    478     UINT32                  ToLineNumber,
    479     UINT32                  ToLogicalLineNumber,
    480     UINT32                  FileId);
    481 
    482 UINT32
    483 LsWriteOneSourceLine (
    484     UINT32                  FileId);
    485 
    486 void
    487 LsPushNode (
    488     char                    *Filename);
    489 
    490 ASL_LISTING_NODE *
    491 LsPopNode (
    492     void);
    493 
    494 
    495 /*
    496  * aslhex - generate all "hex" output files (C, ASM, ASL)
    497  */
    498 void
    499 HxDoHexOutput (
    500     void);
    501 
    502 
    503 /*
    504  * aslfold - constant folding
    505  */
    506 ACPI_STATUS
    507 OpcAmlConstantWalk (
    508     ACPI_PARSE_OBJECT       *Op,
    509     UINT32                  Level,
    510     void                    *Context);
    511 
    512 
    513 /*
    514  * aslmessages - exception strings
    515  */
    516 const char *
    517 AeDecodeMessageId (
    518     UINT16                  MessageId);
    519 
    520 const char *
    521 AeDecodeExceptionLevel (
    522     UINT8                   Level);
    523 
    524 UINT16
    525 AeBuildFullExceptionCode (
    526     UINT8                   Level,
    527     UINT16                  MessageId);
    528 
    529 /*
    530  * asloffset - generate C offset file for BIOS support
    531  */
    532 ACPI_STATUS
    533 LsAmlOffsetWalk (
    534     ACPI_PARSE_OBJECT       *Op,
    535     UINT32                  Level,
    536     void                    *Context);
    537 
    538 void
    539 LsDoOffsetTableHeader (
    540     UINT32                  FileId);
    541 
    542 void
    543 LsDoOffsetTableFooter (
    544     UINT32                  FileId);
    545 
    546 
    547 /*
    548  * aslopcodes - generate AML opcodes
    549  */
    550 ACPI_STATUS
    551 OpcAmlOpcodeWalk (
    552     ACPI_PARSE_OBJECT       *Op,
    553     UINT32                  Level,
    554     void                    *Context);
    555 
    556 ACPI_STATUS
    557 OpcAmlOpcodeUpdateWalk (
    558     ACPI_PARSE_OBJECT       *Op,
    559     UINT32                  Level,
    560     void                    *Context);
    561 
    562 void
    563 OpcGenerateAmlOpcode (
    564     ACPI_PARSE_OBJECT       *Op);
    565 
    566 UINT32
    567 OpcSetOptimalIntegerSize (
    568     ACPI_PARSE_OBJECT       *Op);
    569 
    570 void
    571 OpcGetIntegerWidth (
    572     ACPI_PARSE_OBJECT       *Op);
    573 
    574 
    575 /*
    576  * asloperands - generate AML operands for the AML opcodes
    577  */
    578 ACPI_PARSE_OBJECT  *
    579 UtGetArg (
    580     ACPI_PARSE_OBJECT       *Op,
    581     UINT32                  Argn);
    582 
    583 void
    584 OpnGenerateAmlOperands (
    585     ACPI_PARSE_OBJECT       *Op);
    586 
    587 void
    588 OpnDoPackage (
    589     ACPI_PARSE_OBJECT       *Op);
    590 
    591 
    592 /*
    593  * aslopt - optmization
    594  */
    595 void
    596 OptOptimizeNamePath (
    597     ACPI_PARSE_OBJECT       *Op,
    598     UINT32                  Flags,
    599     ACPI_WALK_STATE         *WalkState,
    600     char                    *AmlNameString,
    601     ACPI_NAMESPACE_NODE     *TargetNode);
    602 
    603 
    604 /*
    605  * aslpld - ToPLD macro support
    606  */
    607 void
    608 OpcDoPld (
    609     ACPI_PARSE_OBJECT       *Op);
    610 
    611 
    612 /*
    613  * aslprintf - Printf/Fprintf macros
    614  */
    615 void
    616 OpcDoPrintf (
    617     ACPI_PARSE_OBJECT       *Op);
    618 
    619 void
    620 OpcDoFprintf (
    621     ACPI_PARSE_OBJECT       *Op);
    622 
    623 
    624 /*
    625  * aslprune - parse tree pruner
    626  */
    627 void
    628 AslPruneParseTree (
    629     UINT32                  PruneDepth,
    630     UINT32                  Type);
    631 
    632 
    633 /*
    634  * aslcodegen - code generation
    635  */
    636 void
    637 CgGenerateAmlOutput (
    638     void);
    639 
    640 void
    641 CgLocalWriteAmlData (
    642     ACPI_PARSE_OBJECT       *Op,
    643     void                    *Buffer,
    644     UINT32                  Length);
    645 
    646 
    647 /*
    648  * aslfile
    649  */
    650 void
    651 FlOpenFile (
    652     UINT32                  FileId,
    653     char                    *Filename,
    654     char                    *Mode);
    655 
    656 
    657 /*
    658  * asllength - calculate/adjust AML package lengths
    659  */
    660 ACPI_STATUS
    661 LnPackageLengthWalk (
    662     ACPI_PARSE_OBJECT       *Op,
    663     UINT32                  Level,
    664     void                    *Context);
    665 
    666 ACPI_STATUS
    667 LnInitLengthsWalk (
    668     ACPI_PARSE_OBJECT       *Op,
    669     UINT32                  Level,
    670     void                    *Context);
    671 
    672 void
    673 CgGenerateAmlLengths (
    674     ACPI_PARSE_OBJECT       *Op);
    675 
    676 
    677 /*
    678  * aslmap - opcode mappings and reserved method names
    679  */
    680 ACPI_OBJECT_TYPE
    681 AslMapNamedOpcodeToDataType (
    682     UINT16                  Opcode);
    683 
    684 
    685 /*
    686  * aslpredef - ACPI predefined names support
    687  */
    688 BOOLEAN
    689 ApCheckForPredefinedMethod (
    690     ACPI_PARSE_OBJECT       *Op,
    691     ASL_METHOD_INFO         *MethodInfo);
    692 
    693 void
    694 ApCheckPredefinedReturnValue (
    695     ACPI_PARSE_OBJECT       *Op,
    696     ASL_METHOD_INFO         *MethodInfo);
    697 
    698 UINT32
    699 ApCheckForPredefinedName (
    700     ACPI_PARSE_OBJECT       *Op,
    701     char                    *Name);
    702 
    703 void
    704 ApCheckForPredefinedObject (
    705     ACPI_PARSE_OBJECT       *Op,
    706     char                    *Name);
    707 
    708 ACPI_STATUS
    709 ApCheckObjectType (
    710     const char              *PredefinedName,
    711     ACPI_PARSE_OBJECT       *Op,
    712     UINT32                  ExpectedBtypes,
    713     UINT32                  PackageIndex);
    714 
    715 void
    716 ApDisplayReservedNames (
    717     void);
    718 
    719 
    720 /*
    721  * aslprepkg - ACPI predefined names support for packages
    722  */
    723 void
    724 ApCheckPackage (
    725     ACPI_PARSE_OBJECT           *ParentOp,
    726     const ACPI_PREDEFINED_INFO  *Predefined);
    727 
    728 
    729 /*
    730  * asltransform - parse tree transformations
    731  */
    732 ACPI_STATUS
    733 TrAmlTransformWalkBegin (
    734     ACPI_PARSE_OBJECT       *Op,
    735     UINT32                  Level,
    736     void                    *Context);
    737 
    738 ACPI_STATUS
    739 TrAmlTransformWalkEnd (
    740     ACPI_PARSE_OBJECT       *Op,
    741     UINT32                  Level,
    742     void                    *Context);
    743 
    744 
    745 /*
    746  * aslexternal - External opcode support
    747  */
    748 ACPI_STATUS
    749 ExAmlExternalWalkBegin (
    750     ACPI_PARSE_OBJECT       *Op,
    751     UINT32                  Level,
    752     void                    *Context);
    753 
    754 ACPI_STATUS
    755 ExAmlExternalWalkEnd (
    756     ACPI_PARSE_OBJECT       *Op,
    757     UINT32                  Level,
    758     void                    *Context);
    759 
    760 void
    761 ExDoExternal (
    762     ACPI_PARSE_OBJECT       *Op);
    763 
    764 /* Values for "Visitation" parameter above */
    765 
    766 #define ASL_WALK_VISIT_DOWNWARD     0x01
    767 #define ASL_WALK_VISIT_UPWARD       0x02
    768 #define ASL_WALK_VISIT_TWICE        (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
    769 
    770 
    771 /*
    772  * aslparseop.c - Parse op create/allocate/cache
    773  */
    774 ACPI_PARSE_OBJECT *
    775 TrCreateOp (
    776     UINT32                  ParseOpcode,
    777     UINT32                  NumChildren,
    778     ...);
    779 
    780 ACPI_PARSE_OBJECT *
    781 TrCreateLeafOp (
    782     UINT32                  ParseOpcode);
    783 
    784 ACPI_PARSE_OBJECT *
    785 TrCreateNullTargetOp (
    786     void);
    787 
    788 ACPI_PARSE_OBJECT *
    789 TrCreateAssignmentOp (
    790     ACPI_PARSE_OBJECT       *Target,
    791     ACPI_PARSE_OBJECT       *Source);
    792 
    793 ACPI_PARSE_OBJECT *
    794 TrCreateTargetOp (
    795     ACPI_PARSE_OBJECT       *OriginalOp,
    796     ACPI_PARSE_OBJECT       *ParentOp);
    797 
    798 ACPI_PARSE_OBJECT *
    799 TrCreateValuedLeafOp (
    800     UINT32                  ParseOpcode,
    801     UINT64                  Value);
    802 
    803 ACPI_PARSE_OBJECT *
    804 TrCreateConstantLeafOp (
    805     UINT32                  ParseOpcode);
    806 
    807 ACPI_PARSE_OBJECT *
    808 TrAllocateOp (
    809     UINT32                  ParseOpcode);
    810 
    811 void
    812 TrPrintOpFlags (
    813     UINT32                  Flags,
    814     UINT32                  OutputLevel);
    815 
    816 
    817 /*
    818  * asltree.c - Parse tree management
    819  */
    820 void
    821 TrSetOpParent (
    822     ACPI_PARSE_OBJECT       *Op,
    823     ACPI_PARSE_OBJECT       *ParentOp);
    824 
    825 ACPI_PARSE_OBJECT *
    826 TrSetOpIntegerValue (
    827     UINT32                  ParseOpcode,
    828     ACPI_PARSE_OBJECT       *Op);
    829 
    830 void
    831 TrSetOpEndLineNumber (
    832     ACPI_PARSE_OBJECT       *Op);
    833 
    834 void
    835 TrSetOpCurrentFilename (
    836     ACPI_PARSE_OBJECT       *Op);
    837 
    838 void
    839 TrSetOpIntegerWidth (
    840     ACPI_PARSE_OBJECT       *TableSignature,
    841     ACPI_PARSE_OBJECT       *Revision);
    842 
    843 ACPI_PARSE_OBJECT *
    844 TrLinkOpChildren (
    845     ACPI_PARSE_OBJECT       *Op,
    846     UINT32                  NumChildren,
    847     ...);
    848 
    849 ACPI_PARSE_OBJECT *
    850 TrLinkPeerOp (
    851     ACPI_PARSE_OBJECT       *Op1,
    852     ACPI_PARSE_OBJECT       *Op2);
    853 
    854 ACPI_PARSE_OBJECT *
    855 TrLinkChildOp (
    856     ACPI_PARSE_OBJECT       *Op1,
    857     ACPI_PARSE_OBJECT       *Op2);
    858 
    859 ACPI_PARSE_OBJECT *
    860 TrSetOpFlags (
    861     ACPI_PARSE_OBJECT       *Op,
    862     UINT32                  Flags);
    863 
    864 ACPI_PARSE_OBJECT *
    865 TrSetOpAmlLength (
    866     ACPI_PARSE_OBJECT       *Op,
    867     UINT32                  Length);
    868 
    869 ACPI_PARSE_OBJECT *
    870 TrLinkPeerOps (
    871     UINT32                  NumPeers,
    872     ...);
    873 
    874 ACPI_STATUS
    875 TrWalkParseTree (
    876     ACPI_PARSE_OBJECT       *Op,
    877     UINT32                  Visitation,
    878     ASL_WALK_CALLBACK       DescendingCallback,
    879     ASL_WALK_CALLBACK       AscendingCallback,
    880     void                    *Context);
    881 
    882 
    883 /*
    884  * aslfiles - File I/O support
    885  */
    886 void
    887 FlAddIncludeDirectory (
    888     char                    *Dir);
    889 
    890 char *
    891 FlMergePathnames (
    892     char                    *PrefixDir,
    893     char                    *FilePathname);
    894 
    895 void
    896 FlOpenIncludeFile (
    897     ACPI_PARSE_OBJECT       *Op);
    898 
    899 void
    900 FlFileError (
    901     UINT32                  FileId,
    902     UINT8                   ErrorId);
    903 
    904 UINT32
    905 FlGetFileSize (
    906     UINT32                  FileId);
    907 
    908 ACPI_STATUS
    909 FlReadFile (
    910     UINT32                  FileId,
    911     void                    *Buffer,
    912     UINT32                  Length);
    913 
    914 void
    915 FlWriteFile (
    916     UINT32                  FileId,
    917     void                    *Buffer,
    918     UINT32                  Length);
    919 
    920 void
    921 FlSeekFile (
    922     UINT32                  FileId,
    923     long                    Offset);
    924 
    925 void
    926 FlCloseFile (
    927     UINT32                  FileId);
    928 
    929 void
    930 FlPrintFile (
    931     UINT32                  FileId,
    932     char                    *Format,
    933     ...);
    934 
    935 void
    936 FlDeleteFile (
    937     UINT32                  FileId);
    938 
    939 void
    940 FlSetLineNumber (
    941     UINT32                  LineNumber);
    942 
    943 void
    944 FlSetFilename (
    945     char                    *Filename);
    946 
    947 ACPI_STATUS
    948 FlOpenInputFile (
    949     char                    *InputFilename);
    950 
    951 ACPI_STATUS
    952 FlOpenAmlOutputFile (
    953     char                    *InputFilename);
    954 
    955 ACPI_STATUS
    956 FlOpenMiscOutputFiles (
    957     char                    *InputFilename);
    958 
    959 /*
    960  * aslhwmap - hardware map summary
    961  */
    962 void
    963 MpEmitMappingInfo (
    964     void);
    965 
    966 
    967 /*
    968  * asload - load namespace in prep for cross reference
    969  */
    970 ACPI_STATUS
    971 LdLoadNamespace (
    972     ACPI_PARSE_OBJECT       *RootOp);
    973 
    974 
    975 /*
    976  * asllookup - namespace lookup functions
    977  */
    978 void
    979 LkFindUnreferencedObjects (
    980     void);
    981 
    982 /*
    983  * aslhelp - help screens
    984  */
    985 void
    986 Usage (
    987     void);
    988 
    989 void
    990 AslFilenameHelp (
    991     void);
    992 
    993 void
    994 AslDisassemblyHelp (
    995     void);
    996 
    997 
    998 /*
    999  * aslnamesp - namespace output file generation
   1000  */
   1001 ACPI_STATUS
   1002 NsDisplayNamespace (
   1003     void);
   1004 
   1005 void
   1006 NsSetupNamespaceListing (
   1007     void                    *Handle);
   1008 
   1009 /*
   1010  * asloptions - command line processing
   1011  */
   1012 int
   1013 AslCommandLine (
   1014     int                     argc,
   1015     char                    **argv);
   1016 
   1017 /*
   1018  * aslxref - namespace cross reference
   1019  */
   1020 ACPI_STATUS
   1021 XfCrossReferenceNamespace (
   1022     void);
   1023 
   1024 
   1025 /*
   1026  * aslxrefout
   1027  */
   1028 void
   1029 OtPrintHeaders (
   1030     char                    *Message);
   1031 
   1032 void
   1033 OtCreateXrefFile (
   1034     void);
   1035 
   1036 void
   1037 OtXrefWalkPart1 (
   1038     ACPI_PARSE_OBJECT       *Op,
   1039     UINT32                  Level,
   1040     ASL_METHOD_INFO         *MethodInfo);
   1041 
   1042 
   1043 /*
   1044  * aslutils - common compiler utilites
   1045  */
   1046 void
   1047 DbgPrint (
   1048     UINT32                  Type,
   1049     char                    *Format,
   1050     ...);
   1051 
   1052 /* Type values for above */
   1053 
   1054 #define ASL_DEBUG_OUTPUT    0
   1055 #define ASL_PARSE_OUTPUT    1
   1056 #define ASL_TREE_OUTPUT     2
   1057 
   1058 UINT8
   1059 UtIsBigEndianMachine (
   1060     void);
   1061 
   1062 BOOLEAN
   1063 UtQueryForOverwrite (
   1064     char                    *Pathname);
   1065 
   1066 void
   1067 UtDumpStringOp (
   1068     ACPI_PARSE_OBJECT       *Op,
   1069     UINT32                  Level);
   1070 
   1071 void
   1072 UtDumpIntegerOp (
   1073     ACPI_PARSE_OBJECT       *Op,
   1074     UINT32                  Level,
   1075     UINT32                  IntegerLength);
   1076 
   1077 void
   1078 UtDumpBasicOp (
   1079     ACPI_PARSE_OBJECT       *Op,
   1080     UINT32                  Level);
   1081 
   1082 void *
   1083 UtGetParentMethod (
   1084     ACPI_NAMESPACE_NODE     *Node);
   1085 
   1086 BOOLEAN
   1087 UtNodeIsDescendantOf (
   1088     ACPI_NAMESPACE_NODE     *Node1,
   1089     ACPI_NAMESPACE_NODE     *Node2);
   1090 
   1091 void
   1092 UtDisplaySupportedTables (
   1093     void);
   1094 
   1095 void
   1096 UtDisplayConstantOpcodes (
   1097     void);
   1098 
   1099 UINT8
   1100 UtBeginEvent (
   1101     char                    *Name);
   1102 
   1103 void
   1104 UtEndEvent (
   1105     UINT8                   Event);
   1106 
   1107 void
   1108 
   1109 UtDisplaySummary (
   1110     UINT32                  FileId);
   1111 
   1112 void
   1113 UtConvertByteToHex (
   1114     UINT8                   RawByte,
   1115     UINT8                   *Buffer);
   1116 
   1117 void
   1118 UtConvertByteToAsmHex (
   1119     UINT8                   RawByte,
   1120     UINT8                   *Buffer);
   1121 
   1122 char *
   1123 UtGetOpName (
   1124     UINT32                  ParseOpcode);
   1125 
   1126 void
   1127 UtSetParseOpName (
   1128     ACPI_PARSE_OBJECT       *Op);
   1129 
   1130 ACPI_STATUS
   1131 UtInternalizeName (
   1132     char                    *ExternalName,
   1133     char                    **ConvertedName);
   1134 
   1135 void
   1136 UtAttachNamepathToOwner (
   1137     ACPI_PARSE_OBJECT       *Op,
   1138     ACPI_PARSE_OBJECT       *NameNode);
   1139 
   1140 ACPI_PARSE_OBJECT *
   1141 UtCheckIntegerRange (
   1142     ACPI_PARSE_OBJECT       *Op,
   1143     UINT32                  LowValue,
   1144     UINT32                  HighValue);
   1145 
   1146 UINT64
   1147 UtDoConstant (
   1148     char                    *String);
   1149 
   1150 
   1151 /*
   1152  * asluuid - UUID support
   1153  */
   1154 ACPI_STATUS
   1155 AuValidateUuid (
   1156     char                    *InString);
   1157 
   1158 ACPI_STATUS
   1159 AuConvertUuidToString (
   1160     char                    *UuIdBuffer,
   1161     char                    *OutString);
   1162 
   1163 /*
   1164  * aslresource - Resource template generation utilities
   1165  */
   1166 void
   1167 RsSmallAddressCheck (
   1168     UINT8                   Type,
   1169     UINT32                  Minimum,
   1170     UINT32                  Maximum,
   1171     UINT32                  Length,
   1172     UINT32                  Alignment,
   1173     ACPI_PARSE_OBJECT       *MinOp,
   1174     ACPI_PARSE_OBJECT       *MaxOp,
   1175     ACPI_PARSE_OBJECT       *LengthOp,
   1176     ACPI_PARSE_OBJECT       *AlignOp,
   1177     ACPI_PARSE_OBJECT       *Op);
   1178 
   1179 void
   1180 RsLargeAddressCheck (
   1181     UINT64                  Minimum,
   1182     UINT64                  Maximum,
   1183     UINT64                  Length,
   1184     UINT64                  Granularity,
   1185     UINT8                   Flags,
   1186     ACPI_PARSE_OBJECT       *MinOp,
   1187     ACPI_PARSE_OBJECT       *MaxOp,
   1188     ACPI_PARSE_OBJECT       *LengthOp,
   1189     ACPI_PARSE_OBJECT       *GranOp,
   1190     ACPI_PARSE_OBJECT       *Op);
   1191 
   1192 UINT16
   1193 RsGetStringDataLength (
   1194     ACPI_PARSE_OBJECT       *InitializerOp);
   1195 
   1196 ASL_RESOURCE_NODE *
   1197 RsAllocateResourceNode (
   1198     UINT32                  Size);
   1199 
   1200 void
   1201 RsCreateResourceField (
   1202     ACPI_PARSE_OBJECT       *Op,
   1203     char                    *Name,
   1204     UINT32                  ByteOffset,
   1205     UINT32                  BitOffset,
   1206     UINT32                  BitLength);
   1207 
   1208 void
   1209 RsSetFlagBits (
   1210     UINT8                   *Flags,
   1211     ACPI_PARSE_OBJECT       *Op,
   1212     UINT8                   Position,
   1213     UINT8                   DefaultBit);
   1214 
   1215 void
   1216 RsSetFlagBits16 (
   1217     UINT16                  *Flags,
   1218     ACPI_PARSE_OBJECT       *Op,
   1219     UINT8                   Position,
   1220     UINT8                   DefaultBit);
   1221 
   1222 ACPI_PARSE_OBJECT *
   1223 RsCompleteNodeAndGetNext (
   1224     ACPI_PARSE_OBJECT       *Op);
   1225 
   1226 void
   1227 RsCheckListForDuplicates (
   1228     ACPI_PARSE_OBJECT       *Op);
   1229 
   1230 ASL_RESOURCE_NODE *
   1231 RsDoOneResourceDescriptor (
   1232     ASL_RESOURCE_INFO       *Info,
   1233     UINT8                   *State);
   1234 
   1235 /* Values for State above */
   1236 
   1237 #define ACPI_RSTATE_NORMAL              0
   1238 #define ACPI_RSTATE_START_DEPENDENT     1
   1239 #define ACPI_RSTATE_DEPENDENT_LIST      2
   1240 
   1241 UINT32
   1242 RsLinkDescriptorChain (
   1243     ASL_RESOURCE_NODE       **PreviousRnode,
   1244     ASL_RESOURCE_NODE       *Rnode);
   1245 
   1246 void
   1247 RsDoResourceTemplate (
   1248     ACPI_PARSE_OBJECT       *Op);
   1249 
   1250 
   1251 /*
   1252  * aslrestype1 - Miscellaneous Small descriptors
   1253  */
   1254 ASL_RESOURCE_NODE *
   1255 RsDoEndTagDescriptor (
   1256     ASL_RESOURCE_INFO       *Info);
   1257 
   1258 ASL_RESOURCE_NODE *
   1259 RsDoEndDependentDescriptor (
   1260     ASL_RESOURCE_INFO       *Info);
   1261 
   1262 ASL_RESOURCE_NODE *
   1263 RsDoMemory24Descriptor (
   1264     ASL_RESOURCE_INFO       *Info);
   1265 
   1266 ASL_RESOURCE_NODE *
   1267 RsDoMemory32Descriptor (
   1268     ASL_RESOURCE_INFO       *Info);
   1269 
   1270 ASL_RESOURCE_NODE *
   1271 RsDoMemory32FixedDescriptor (
   1272     ASL_RESOURCE_INFO       *Info);
   1273 
   1274 ASL_RESOURCE_NODE *
   1275 RsDoStartDependentDescriptor (
   1276     ASL_RESOURCE_INFO       *Info);
   1277 
   1278 ASL_RESOURCE_NODE *
   1279 RsDoStartDependentNoPriDescriptor (
   1280     ASL_RESOURCE_INFO       *Info);
   1281 
   1282 ASL_RESOURCE_NODE *
   1283 RsDoVendorSmallDescriptor (
   1284     ASL_RESOURCE_INFO       *Info);
   1285 
   1286 
   1287 /*
   1288  * aslrestype1i - I/O-related Small descriptors
   1289  */
   1290 ASL_RESOURCE_NODE *
   1291 RsDoDmaDescriptor (
   1292     ASL_RESOURCE_INFO       *Info);
   1293 
   1294 ASL_RESOURCE_NODE *
   1295 RsDoFixedDmaDescriptor (
   1296     ASL_RESOURCE_INFO       *Info);
   1297 
   1298 ASL_RESOURCE_NODE *
   1299 RsDoFixedIoDescriptor (
   1300     ASL_RESOURCE_INFO       *Info);
   1301 
   1302 ASL_RESOURCE_NODE *
   1303 RsDoIoDescriptor (
   1304     ASL_RESOURCE_INFO       *Info);
   1305 
   1306 ASL_RESOURCE_NODE *
   1307 RsDoIrqDescriptor (
   1308     ASL_RESOURCE_INFO       *Info);
   1309 
   1310 ASL_RESOURCE_NODE *
   1311 RsDoIrqNoFlagsDescriptor (
   1312     ASL_RESOURCE_INFO       *Info);
   1313 
   1314 
   1315 /*
   1316  * aslrestype2 - Large resource descriptors
   1317  */
   1318 ASL_RESOURCE_NODE *
   1319 RsDoInterruptDescriptor (
   1320     ASL_RESOURCE_INFO       *Info);
   1321 
   1322 ASL_RESOURCE_NODE *
   1323 RsDoVendorLargeDescriptor (
   1324     ASL_RESOURCE_INFO       *Info);
   1325 
   1326 ASL_RESOURCE_NODE *
   1327 RsDoGeneralRegisterDescriptor (
   1328     ASL_RESOURCE_INFO       *Info);
   1329 
   1330 ASL_RESOURCE_NODE *
   1331 RsDoGpioIntDescriptor (
   1332     ASL_RESOURCE_INFO       *Info);
   1333 
   1334 ASL_RESOURCE_NODE *
   1335 RsDoGpioIoDescriptor (
   1336     ASL_RESOURCE_INFO       *Info);
   1337 
   1338 ASL_RESOURCE_NODE *
   1339 RsDoI2cSerialBusDescriptor (
   1340     ASL_RESOURCE_INFO       *Info);
   1341 
   1342 ASL_RESOURCE_NODE *
   1343 RsDoSpiSerialBusDescriptor (
   1344     ASL_RESOURCE_INFO       *Info);
   1345 
   1346 ASL_RESOURCE_NODE *
   1347 RsDoUartSerialBusDescriptor (
   1348     ASL_RESOURCE_INFO       *Info);
   1349 
   1350 ASL_RESOURCE_NODE *
   1351 RsDoPinFunctionDescriptor (
   1352     ASL_RESOURCE_INFO       *Info);
   1353 
   1354 ASL_RESOURCE_NODE *
   1355 RsDoPinConfigDescriptor (
   1356     ASL_RESOURCE_INFO       *Info);
   1357 
   1358 ASL_RESOURCE_NODE *
   1359 RsDoPinGroupDescriptor (
   1360     ASL_RESOURCE_INFO       *Info);
   1361 
   1362 ASL_RESOURCE_NODE *
   1363 RsDoPinGroupFunctionDescriptor (
   1364     ASL_RESOURCE_INFO       *Info);
   1365 
   1366 ASL_RESOURCE_NODE *
   1367 RsDoPinGroupConfigDescriptor (
   1368     ASL_RESOURCE_INFO       *Info);
   1369 
   1370 /*
   1371  * aslrestype2d - DWord address descriptors
   1372  */
   1373 ASL_RESOURCE_NODE *
   1374 RsDoDwordIoDescriptor (
   1375     ASL_RESOURCE_INFO       *Info);
   1376 
   1377 ASL_RESOURCE_NODE *
   1378 RsDoDwordMemoryDescriptor (
   1379     ASL_RESOURCE_INFO       *Info);
   1380 
   1381 ASL_RESOURCE_NODE *
   1382 RsDoDwordSpaceDescriptor (
   1383     ASL_RESOURCE_INFO       *Info);
   1384 
   1385 
   1386 /*
   1387  * aslrestype2e - Extended address descriptors
   1388  */
   1389 ASL_RESOURCE_NODE *
   1390 RsDoExtendedIoDescriptor (
   1391     ASL_RESOURCE_INFO       *Info);
   1392 
   1393 ASL_RESOURCE_NODE *
   1394 RsDoExtendedMemoryDescriptor (
   1395     ASL_RESOURCE_INFO       *Info);
   1396 
   1397 ASL_RESOURCE_NODE *
   1398 RsDoExtendedSpaceDescriptor (
   1399     ASL_RESOURCE_INFO       *Info);
   1400 
   1401 
   1402 /*
   1403  * aslrestype2q - QWord address descriptors
   1404  */
   1405 ASL_RESOURCE_NODE *
   1406 RsDoQwordIoDescriptor (
   1407     ASL_RESOURCE_INFO       *Info);
   1408 
   1409 ASL_RESOURCE_NODE *
   1410 RsDoQwordMemoryDescriptor (
   1411     ASL_RESOURCE_INFO       *Info);
   1412 
   1413 ASL_RESOURCE_NODE *
   1414 RsDoQwordSpaceDescriptor (
   1415     ASL_RESOURCE_INFO       *Info);
   1416 
   1417 
   1418 /*
   1419  * aslrestype2w - Word address descriptors
   1420  */
   1421 ASL_RESOURCE_NODE *
   1422 RsDoWordIoDescriptor (
   1423     ASL_RESOURCE_INFO       *Info);
   1424 
   1425 ASL_RESOURCE_NODE *
   1426 RsDoWordSpaceDescriptor (
   1427     ASL_RESOURCE_INFO       *Info);
   1428 
   1429 ASL_RESOURCE_NODE *
   1430 RsDoWordBusNumberDescriptor (
   1431     ASL_RESOURCE_INFO       *Info);
   1432 
   1433 
   1434 /*
   1435  * Entry to data table compiler subsystem
   1436  */
   1437 ACPI_STATUS
   1438 DtDoCompile(
   1439     void);
   1440 
   1441 ACPI_STATUS
   1442 DtCreateTemplates (
   1443     char                    **argv);
   1444 
   1445 
   1446 /*
   1447  * ASL/ASL+ converter debug
   1448  */
   1449 void
   1450 CvDbgPrint (
   1451     char                    *Fmt,
   1452     ...);
   1453 
   1454 
   1455 #endif /*  __ASLCOMPILER_H */
   1456