Home | History | Annotate | Line # | Download | only in compiler
aslcompiler.h revision 1.10.2.3 
      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 AslElevateException (
    371     char                    *MessageIdString);
    372 
    373 ACPI_STATUS
    374 AslDisableException (
    375     char                    *MessageIdString);
    376 
    377 BOOLEAN
    378 AslIsExceptionIgnored (
    379     UINT8                   Level,
    380     UINT16                  MessageId);
    381 
    382 void
    383 AslCoreSubsystemError (
    384     ACPI_PARSE_OBJECT       *Op,
    385     ACPI_STATUS             Status,
    386     char                    *ExtraMessage,
    387     BOOLEAN                 Abort);
    388 
    389 int
    390 AslCompilererror(
    391     const char              *s);
    392 
    393 void
    394 AslCommonError (
    395     UINT8                   Level,
    396     UINT16                  MessageId,
    397     UINT32                  CurrentLineNumber,
    398     UINT32                  LogicalLineNumber,
    399     UINT32                  LogicalByteOffset,
    400     UINT32                  Column,
    401     char                    *Filename,
    402     char                    *ExtraMessage);
    403 
    404 void
    405 AslCommonError2 (
    406     UINT8                   Level,
    407     UINT16                  MessageId,
    408     UINT32                  LineNumber,
    409     UINT32                  Column,
    410     char                    *SourceLine,
    411     char                    *Filename,
    412     char                    *ExtraMessage);
    413 
    414 void
    415 AePrintException (
    416     UINT32                  FileId,
    417     ASL_ERROR_MSG           *Enode,
    418     char                    *Header);
    419 
    420 void
    421 AePrintErrorLog (
    422     UINT32                  FileId);
    423 
    424 void
    425 AeClearErrorLog (
    426     void);
    427 
    428 
    429 /*
    430  * asllisting - generate all "listing" type files
    431  */
    432 void
    433 LsDoListings (
    434     void);
    435 
    436 void
    437 LsWriteNodeToAsmListing (
    438     ACPI_PARSE_OBJECT       *Op);
    439 
    440 void
    441 LsWriteNode (
    442     ACPI_PARSE_OBJECT       *Op,
    443     UINT32                  FileId);
    444 
    445 void
    446 LsDumpParseTree (
    447     void);
    448 
    449 
    450 /*
    451  * asllistsup - Listing file support utilities
    452  */
    453 void
    454 LsDumpAscii (
    455     UINT32                  FileId,
    456     UINT32                  Count,
    457     UINT8                   *Buffer);
    458 
    459 void
    460 LsDumpAsciiInComment (
    461     UINT32                  FileId,
    462     UINT32                  Count,
    463     UINT8                   *Buffer);
    464 
    465 void
    466 LsCheckException (
    467     UINT32                  LineNumber,
    468     UINT32                  FileId);
    469 
    470 void
    471 LsFlushListingBuffer (
    472     UINT32                  FileId);
    473 
    474 void
    475 LsWriteListingHexBytes (
    476     UINT8                   *Buffer,
    477     UINT32                  Length,
    478     UINT32                  FileId);
    479 
    480 void
    481 LsWriteSourceLines (
    482     UINT32                  ToLineNumber,
    483     UINT32                  ToLogicalLineNumber,
    484     UINT32                  FileId);
    485 
    486 UINT32
    487 LsWriteOneSourceLine (
    488     UINT32                  FileId);
    489 
    490 void
    491 LsPushNode (
    492     char                    *Filename);
    493 
    494 ASL_LISTING_NODE *
    495 LsPopNode (
    496     void);
    497 
    498 
    499 /*
    500  * aslhex - generate all "hex" output files (C, ASM, ASL)
    501  */
    502 void
    503 HxDoHexOutput (
    504     void);
    505 
    506 
    507 /*
    508  * aslfold - constant folding
    509  */
    510 ACPI_STATUS
    511 OpcAmlConstantWalk (
    512     ACPI_PARSE_OBJECT       *Op,
    513     UINT32                  Level,
    514     void                    *Context);
    515 
    516 
    517 /*
    518  * aslmessages - exception strings
    519  */
    520 const char *
    521 AeDecodeMessageId (
    522     UINT16                  MessageId);
    523 
    524 const char *
    525 AeDecodeExceptionLevel (
    526     UINT8                   Level);
    527 
    528 UINT16
    529 AeBuildFullExceptionCode (
    530     UINT8                   Level,
    531     UINT16                  MessageId);
    532 
    533 /*
    534  * asloffset - generate C offset file for BIOS support
    535  */
    536 ACPI_STATUS
    537 LsAmlOffsetWalk (
    538     ACPI_PARSE_OBJECT       *Op,
    539     UINT32                  Level,
    540     void                    *Context);
    541 
    542 void
    543 LsDoOffsetTableHeader (
    544     UINT32                  FileId);
    545 
    546 void
    547 LsDoOffsetTableFooter (
    548     UINT32                  FileId);
    549 
    550 
    551 /*
    552  * aslopcodes - generate AML opcodes
    553  */
    554 ACPI_STATUS
    555 OpcAmlOpcodeWalk (
    556     ACPI_PARSE_OBJECT       *Op,
    557     UINT32                  Level,
    558     void                    *Context);
    559 
    560 ACPI_STATUS
    561 OpcAmlOpcodeUpdateWalk (
    562     ACPI_PARSE_OBJECT       *Op,
    563     UINT32                  Level,
    564     void                    *Context);
    565 
    566 void
    567 OpcGenerateAmlOpcode (
    568     ACPI_PARSE_OBJECT       *Op);
    569 
    570 UINT32
    571 OpcSetOptimalIntegerSize (
    572     ACPI_PARSE_OBJECT       *Op);
    573 
    574 void
    575 OpcGetIntegerWidth (
    576     ACPI_PARSE_OBJECT       *Op);
    577 
    578 
    579 /*
    580  * asloperands - generate AML operands for the AML opcodes
    581  */
    582 ACPI_PARSE_OBJECT  *
    583 UtGetArg (
    584     ACPI_PARSE_OBJECT       *Op,
    585     UINT32                  Argn);
    586 
    587 void
    588 OpnGenerateAmlOperands (
    589     ACPI_PARSE_OBJECT       *Op);
    590 
    591 void
    592 OpnDoPackage (
    593     ACPI_PARSE_OBJECT       *Op);
    594 
    595 
    596 /*
    597  * aslopt - optmization
    598  */
    599 void
    600 OptOptimizeNamePath (
    601     ACPI_PARSE_OBJECT       *Op,
    602     UINT32                  Flags,
    603     ACPI_WALK_STATE         *WalkState,
    604     char                    *AmlNameString,
    605     ACPI_NAMESPACE_NODE     *TargetNode);
    606 
    607 
    608 /*
    609  * aslpld - ToPLD macro support
    610  */
    611 void
    612 OpcDoPld (
    613     ACPI_PARSE_OBJECT       *Op);
    614 
    615 
    616 /*
    617  * aslprintf - Printf/Fprintf macros
    618  */
    619 void
    620 OpcDoPrintf (
    621     ACPI_PARSE_OBJECT       *Op);
    622 
    623 void
    624 OpcDoFprintf (
    625     ACPI_PARSE_OBJECT       *Op);
    626 
    627 
    628 /*
    629  * aslprune - parse tree pruner
    630  */
    631 void
    632 AslPruneParseTree (
    633     UINT32                  PruneDepth,
    634     UINT32                  Type);
    635 
    636 
    637 /*
    638  * aslcodegen - code generation
    639  */
    640 void
    641 CgGenerateAmlOutput (
    642     void);
    643 
    644 void
    645 CgLocalWriteAmlData (
    646     ACPI_PARSE_OBJECT       *Op,
    647     void                    *Buffer,
    648     UINT32                  Length);
    649 
    650 
    651 /*
    652  * aslfile
    653  */
    654 void
    655 FlOpenFile (
    656     UINT32                  FileId,
    657     char                    *Filename,
    658     char                    *Mode);
    659 
    660 
    661 /*
    662  * asllength - calculate/adjust AML package lengths
    663  */
    664 ACPI_STATUS
    665 LnPackageLengthWalk (
    666     ACPI_PARSE_OBJECT       *Op,
    667     UINT32                  Level,
    668     void                    *Context);
    669 
    670 ACPI_STATUS
    671 LnInitLengthsWalk (
    672     ACPI_PARSE_OBJECT       *Op,
    673     UINT32                  Level,
    674     void                    *Context);
    675 
    676 void
    677 CgGenerateAmlLengths (
    678     ACPI_PARSE_OBJECT       *Op);
    679 
    680 
    681 /*
    682  * aslmap - opcode mappings and reserved method names
    683  */
    684 ACPI_OBJECT_TYPE
    685 AslMapNamedOpcodeToDataType (
    686     UINT16                  Opcode);
    687 
    688 
    689 /*
    690  * aslpredef - ACPI predefined names support
    691  */
    692 BOOLEAN
    693 ApCheckForPredefinedMethod (
    694     ACPI_PARSE_OBJECT       *Op,
    695     ASL_METHOD_INFO         *MethodInfo);
    696 
    697 void
    698 ApCheckPredefinedReturnValue (
    699     ACPI_PARSE_OBJECT       *Op,
    700     ASL_METHOD_INFO         *MethodInfo);
    701 
    702 UINT32
    703 ApCheckForPredefinedName (
    704     ACPI_PARSE_OBJECT       *Op,
    705     char                    *Name);
    706 
    707 void
    708 ApCheckForPredefinedObject (
    709     ACPI_PARSE_OBJECT       *Op,
    710     char                    *Name);
    711 
    712 ACPI_STATUS
    713 ApCheckObjectType (
    714     const char              *PredefinedName,
    715     ACPI_PARSE_OBJECT       *Op,
    716     UINT32                  ExpectedBtypes,
    717     UINT32                  PackageIndex);
    718 
    719 void
    720 ApDisplayReservedNames (
    721     void);
    722 
    723 
    724 /*
    725  * aslprepkg - ACPI predefined names support for packages
    726  */
    727 void
    728 ApCheckPackage (
    729     ACPI_PARSE_OBJECT           *ParentOp,
    730     const ACPI_PREDEFINED_INFO  *Predefined);
    731 
    732 
    733 /*
    734  * asltransform - parse tree transformations
    735  */
    736 ACPI_STATUS
    737 TrAmlTransformWalkBegin (
    738     ACPI_PARSE_OBJECT       *Op,
    739     UINT32                  Level,
    740     void                    *Context);
    741 
    742 ACPI_STATUS
    743 TrAmlTransformWalkEnd (
    744     ACPI_PARSE_OBJECT       *Op,
    745     UINT32                  Level,
    746     void                    *Context);
    747 
    748 
    749 /*
    750  * aslexternal - External opcode support
    751  */
    752 ACPI_STATUS
    753 ExAmlExternalWalkBegin (
    754     ACPI_PARSE_OBJECT       *Op,
    755     UINT32                  Level,
    756     void                    *Context);
    757 
    758 ACPI_STATUS
    759 ExAmlExternalWalkEnd (
    760     ACPI_PARSE_OBJECT       *Op,
    761     UINT32                  Level,
    762     void                    *Context);
    763 
    764 void
    765 ExDoExternal (
    766     ACPI_PARSE_OBJECT       *Op);
    767 
    768 /* Values for "Visitation" parameter above */
    769 
    770 #define ASL_WALK_VISIT_DOWNWARD     0x01
    771 #define ASL_WALK_VISIT_UPWARD       0x02
    772 #define ASL_WALK_VISIT_TWICE        (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
    773 
    774 
    775 /*
    776  * aslparseop.c - Parse op create/allocate/cache
    777  */
    778 ACPI_PARSE_OBJECT *
    779 TrCreateOp (
    780     UINT32                  ParseOpcode,
    781     UINT32                  NumChildren,
    782     ...);
    783 
    784 ACPI_PARSE_OBJECT *
    785 TrCreateLeafOp (
    786     UINT32                  ParseOpcode);
    787 
    788 ACPI_PARSE_OBJECT *
    789 TrCreateNullTargetOp (
    790     void);
    791 
    792 ACPI_PARSE_OBJECT *
    793 TrCreateAssignmentOp (
    794     ACPI_PARSE_OBJECT       *Target,
    795     ACPI_PARSE_OBJECT       *Source);
    796 
    797 ACPI_PARSE_OBJECT *
    798 TrCreateTargetOp (
    799     ACPI_PARSE_OBJECT       *OriginalOp,
    800     ACPI_PARSE_OBJECT       *ParentOp);
    801 
    802 ACPI_PARSE_OBJECT *
    803 TrCreateValuedLeafOp (
    804     UINT32                  ParseOpcode,
    805     UINT64                  Value);
    806 
    807 ACPI_PARSE_OBJECT *
    808 TrCreateConstantLeafOp (
    809     UINT32                  ParseOpcode);
    810 
    811 ACPI_PARSE_OBJECT *
    812 TrAllocateOp (
    813     UINT32                  ParseOpcode);
    814 
    815 void
    816 TrPrintOpFlags (
    817     UINT32                  Flags,
    818     UINT32                  OutputLevel);
    819 
    820 
    821 /*
    822  * asltree.c - Parse tree management
    823  */
    824 void
    825 TrSetOpParent (
    826     ACPI_PARSE_OBJECT       *Op,
    827     ACPI_PARSE_OBJECT       *ParentOp);
    828 
    829 ACPI_PARSE_OBJECT *
    830 TrSetOpIntegerValue (
    831     UINT32                  ParseOpcode,
    832     ACPI_PARSE_OBJECT       *Op);
    833 
    834 void
    835 TrSetOpEndLineNumber (
    836     ACPI_PARSE_OBJECT       *Op);
    837 
    838 void
    839 TrSetOpCurrentFilename (
    840     ACPI_PARSE_OBJECT       *Op);
    841 
    842 void
    843 TrSetOpIntegerWidth (
    844     ACPI_PARSE_OBJECT       *TableSignature,
    845     ACPI_PARSE_OBJECT       *Revision);
    846 
    847 ACPI_PARSE_OBJECT *
    848 TrLinkOpChildren (
    849     ACPI_PARSE_OBJECT       *Op,
    850     UINT32                  NumChildren,
    851     ...);
    852 
    853 ACPI_PARSE_OBJECT *
    854 TrLinkPeerOp (
    855     ACPI_PARSE_OBJECT       *Op1,
    856     ACPI_PARSE_OBJECT       *Op2);
    857 
    858 ACPI_PARSE_OBJECT *
    859 TrLinkChildOp (
    860     ACPI_PARSE_OBJECT       *Op1,
    861     ACPI_PARSE_OBJECT       *Op2);
    862 
    863 ACPI_PARSE_OBJECT *
    864 TrSetOpFlags (
    865     ACPI_PARSE_OBJECT       *Op,
    866     UINT32                  Flags);
    867 
    868 ACPI_PARSE_OBJECT *
    869 TrSetOpAmlLength (
    870     ACPI_PARSE_OBJECT       *Op,
    871     UINT32                  Length);
    872 
    873 ACPI_PARSE_OBJECT *
    874 TrLinkPeerOps (
    875     UINT32                  NumPeers,
    876     ...);
    877 
    878 ACPI_STATUS
    879 TrWalkParseTree (
    880     ACPI_PARSE_OBJECT       *Op,
    881     UINT32                  Visitation,
    882     ASL_WALK_CALLBACK       DescendingCallback,
    883     ASL_WALK_CALLBACK       AscendingCallback,
    884     void                    *Context);
    885 
    886 
    887 /*
    888  * aslfiles - File I/O support
    889  */
    890 void
    891 FlAddIncludeDirectory (
    892     char                    *Dir);
    893 
    894 char *
    895 FlMergePathnames (
    896     char                    *PrefixDir,
    897     char                    *FilePathname);
    898 
    899 void
    900 FlOpenIncludeFile (
    901     ACPI_PARSE_OBJECT       *Op);
    902 
    903 void
    904 FlFileError (
    905     UINT32                  FileId,
    906     UINT8                   ErrorId);
    907 
    908 UINT32
    909 FlGetFileSize (
    910     UINT32                  FileId);
    911 
    912 ACPI_STATUS
    913 FlReadFile (
    914     UINT32                  FileId,
    915     void                    *Buffer,
    916     UINT32                  Length);
    917 
    918 void
    919 FlWriteFile (
    920     UINT32                  FileId,
    921     void                    *Buffer,
    922     UINT32                  Length);
    923 
    924 void
    925 FlSeekFile (
    926     UINT32                  FileId,
    927     long                    Offset);
    928 
    929 void
    930 FlCloseFile (
    931     UINT32                  FileId);
    932 
    933 void
    934 FlPrintFile (
    935     UINT32                  FileId,
    936     char                    *Format,
    937     ...);
    938 
    939 void
    940 FlDeleteFile (
    941     UINT32                  FileId);
    942 
    943 void
    944 FlSetLineNumber (
    945     UINT32                  LineNumber);
    946 
    947 void
    948 FlSetFilename (
    949     char                    *Filename);
    950 
    951 ACPI_STATUS
    952 FlOpenInputFile (
    953     char                    *InputFilename);
    954 
    955 ACPI_STATUS
    956 FlOpenAmlOutputFile (
    957     char                    *InputFilename);
    958 
    959 ACPI_STATUS
    960 FlOpenMiscOutputFiles (
    961     char                    *InputFilename);
    962 
    963 /*
    964  * aslhwmap - hardware map summary
    965  */
    966 void
    967 MpEmitMappingInfo (
    968     void);
    969 
    970 
    971 /*
    972  * asload - load namespace in prep for cross reference
    973  */
    974 ACPI_STATUS
    975 LdLoadNamespace (
    976     ACPI_PARSE_OBJECT       *RootOp);
    977 
    978 
    979 /*
    980  * asllookup - namespace lookup functions
    981  */
    982 void
    983 LkFindUnreferencedObjects (
    984     void);
    985 
    986 /*
    987  * aslhelp - help screens
    988  */
    989 void
    990 Usage (
    991     void);
    992 
    993 void
    994 AslFilenameHelp (
    995     void);
    996 
    997 void
    998 AslDisassemblyHelp (
    999     void);
   1000 
   1001 
   1002 /*
   1003  * aslnamesp - namespace output file generation
   1004  */
   1005 ACPI_STATUS
   1006 NsDisplayNamespace (
   1007     void);
   1008 
   1009 void
   1010 NsSetupNamespaceListing (
   1011     void                    *Handle);
   1012 
   1013 /*
   1014  * asloptions - command line processing
   1015  */
   1016 int
   1017 AslCommandLine (
   1018     int                     argc,
   1019     char                    **argv);
   1020 
   1021 /*
   1022  * aslxref - namespace cross reference
   1023  */
   1024 ACPI_STATUS
   1025 XfCrossReferenceNamespace (
   1026     void);
   1027 
   1028 
   1029 /*
   1030  * aslxrefout
   1031  */
   1032 void
   1033 OtPrintHeaders (
   1034     char                    *Message);
   1035 
   1036 void
   1037 OtCreateXrefFile (
   1038     void);
   1039 
   1040 void
   1041 OtXrefWalkPart1 (
   1042     ACPI_PARSE_OBJECT       *Op,
   1043     UINT32                  Level,
   1044     ASL_METHOD_INFO         *MethodInfo);
   1045 
   1046 
   1047 /*
   1048  * aslutils - common compiler utilites
   1049  */
   1050 void
   1051 DbgPrint (
   1052     UINT32                  Type,
   1053     char                    *Format,
   1054     ...);
   1055 
   1056 /* Type values for above */
   1057 
   1058 #define ASL_DEBUG_OUTPUT    0
   1059 #define ASL_PARSE_OUTPUT    1
   1060 #define ASL_TREE_OUTPUT     2
   1061 
   1062 UINT8
   1063 UtIsBigEndianMachine (
   1064     void);
   1065 
   1066 BOOLEAN
   1067 UtQueryForOverwrite (
   1068     char                    *Pathname);
   1069 
   1070 void
   1071 UtDumpStringOp (
   1072     ACPI_PARSE_OBJECT       *Op,
   1073     UINT32                  Level);
   1074 
   1075 void
   1076 UtDumpIntegerOp (
   1077     ACPI_PARSE_OBJECT       *Op,
   1078     UINT32                  Level,
   1079     UINT32                  IntegerLength);
   1080 
   1081 void
   1082 UtDumpBasicOp (
   1083     ACPI_PARSE_OBJECT       *Op,
   1084     UINT32                  Level);
   1085 
   1086 void *
   1087 UtGetParentMethod (
   1088     ACPI_NAMESPACE_NODE     *Node);
   1089 
   1090 BOOLEAN
   1091 UtNodeIsDescendantOf (
   1092     ACPI_NAMESPACE_NODE     *Node1,
   1093     ACPI_NAMESPACE_NODE     *Node2);
   1094 
   1095 void
   1096 UtDisplaySupportedTables (
   1097     void);
   1098 
   1099 void
   1100 UtDisplayConstantOpcodes (
   1101     void);
   1102 
   1103 UINT8
   1104 UtBeginEvent (
   1105     char                    *Name);
   1106 
   1107 void
   1108 UtEndEvent (
   1109     UINT8                   Event);
   1110 
   1111 void
   1112 
   1113 UtDisplaySummary (
   1114     UINT32                  FileId);
   1115 
   1116 void
   1117 UtConvertByteToHex (
   1118     UINT8                   RawByte,
   1119     UINT8                   *Buffer);
   1120 
   1121 void
   1122 UtConvertByteToAsmHex (
   1123     UINT8                   RawByte,
   1124     UINT8                   *Buffer);
   1125 
   1126 char *
   1127 UtGetOpName (
   1128     UINT32                  ParseOpcode);
   1129 
   1130 void
   1131 UtSetParseOpName (
   1132     ACPI_PARSE_OBJECT       *Op);
   1133 
   1134 ACPI_STATUS
   1135 UtInternalizeName (
   1136     char                    *ExternalName,
   1137     char                    **ConvertedName);
   1138 
   1139 void
   1140 UtAttachNamepathToOwner (
   1141     ACPI_PARSE_OBJECT       *Op,
   1142     ACPI_PARSE_OBJECT       *NameNode);
   1143 
   1144 ACPI_PARSE_OBJECT *
   1145 UtCheckIntegerRange (
   1146     ACPI_PARSE_OBJECT       *Op,
   1147     UINT32                  LowValue,
   1148     UINT32                  HighValue);
   1149 
   1150 UINT64
   1151 UtDoConstant (
   1152     char                    *String);
   1153 
   1154 
   1155 /*
   1156  * asluuid - UUID support
   1157  */
   1158 ACPI_STATUS
   1159 AuValidateUuid (
   1160     char                    *InString);
   1161 
   1162 ACPI_STATUS
   1163 AuConvertUuidToString (
   1164     char                    *UuIdBuffer,
   1165     char                    *OutString);
   1166 
   1167 /*
   1168  * aslresource - Resource template generation utilities
   1169  */
   1170 void
   1171 RsSmallAddressCheck (
   1172     UINT8                   Type,
   1173     UINT32                  Minimum,
   1174     UINT32                  Maximum,
   1175     UINT32                  Length,
   1176     UINT32                  Alignment,
   1177     ACPI_PARSE_OBJECT       *MinOp,
   1178     ACPI_PARSE_OBJECT       *MaxOp,
   1179     ACPI_PARSE_OBJECT       *LengthOp,
   1180     ACPI_PARSE_OBJECT       *AlignOp,
   1181     ACPI_PARSE_OBJECT       *Op);
   1182 
   1183 void
   1184 RsLargeAddressCheck (
   1185     UINT64                  Minimum,
   1186     UINT64                  Maximum,
   1187     UINT64                  Length,
   1188     UINT64                  Granularity,
   1189     UINT8                   Flags,
   1190     ACPI_PARSE_OBJECT       *MinOp,
   1191     ACPI_PARSE_OBJECT       *MaxOp,
   1192     ACPI_PARSE_OBJECT       *LengthOp,
   1193     ACPI_PARSE_OBJECT       *GranOp,
   1194     ACPI_PARSE_OBJECT       *Op);
   1195 
   1196 UINT16
   1197 RsGetStringDataLength (
   1198     ACPI_PARSE_OBJECT       *InitializerOp);
   1199 
   1200 ASL_RESOURCE_NODE *
   1201 RsAllocateResourceNode (
   1202     UINT32                  Size);
   1203 
   1204 void
   1205 RsCreateResourceField (
   1206     ACPI_PARSE_OBJECT       *Op,
   1207     char                    *Name,
   1208     UINT32                  ByteOffset,
   1209     UINT32                  BitOffset,
   1210     UINT32                  BitLength);
   1211 
   1212 void
   1213 RsSetFlagBits (
   1214     UINT8                   *Flags,
   1215     ACPI_PARSE_OBJECT       *Op,
   1216     UINT8                   Position,
   1217     UINT8                   DefaultBit);
   1218 
   1219 void
   1220 RsSetFlagBits16 (
   1221     UINT16                  *Flags,
   1222     ACPI_PARSE_OBJECT       *Op,
   1223     UINT8                   Position,
   1224     UINT8                   DefaultBit);
   1225 
   1226 ACPI_PARSE_OBJECT *
   1227 RsCompleteNodeAndGetNext (
   1228     ACPI_PARSE_OBJECT       *Op);
   1229 
   1230 void
   1231 RsCheckListForDuplicates (
   1232     ACPI_PARSE_OBJECT       *Op);
   1233 
   1234 ASL_RESOURCE_NODE *
   1235 RsDoOneResourceDescriptor (
   1236     ASL_RESOURCE_INFO       *Info,
   1237     UINT8                   *State);
   1238 
   1239 /* Values for State above */
   1240 
   1241 #define ACPI_RSTATE_NORMAL              0
   1242 #define ACPI_RSTATE_START_DEPENDENT     1
   1243 #define ACPI_RSTATE_DEPENDENT_LIST      2
   1244 
   1245 UINT32
   1246 RsLinkDescriptorChain (
   1247     ASL_RESOURCE_NODE       **PreviousRnode,
   1248     ASL_RESOURCE_NODE       *Rnode);
   1249 
   1250 void
   1251 RsDoResourceTemplate (
   1252     ACPI_PARSE_OBJECT       *Op);
   1253 
   1254 
   1255 /*
   1256  * aslrestype1 - Miscellaneous Small descriptors
   1257  */
   1258 ASL_RESOURCE_NODE *
   1259 RsDoEndTagDescriptor (
   1260     ASL_RESOURCE_INFO       *Info);
   1261 
   1262 ASL_RESOURCE_NODE *
   1263 RsDoEndDependentDescriptor (
   1264     ASL_RESOURCE_INFO       *Info);
   1265 
   1266 ASL_RESOURCE_NODE *
   1267 RsDoMemory24Descriptor (
   1268     ASL_RESOURCE_INFO       *Info);
   1269 
   1270 ASL_RESOURCE_NODE *
   1271 RsDoMemory32Descriptor (
   1272     ASL_RESOURCE_INFO       *Info);
   1273 
   1274 ASL_RESOURCE_NODE *
   1275 RsDoMemory32FixedDescriptor (
   1276     ASL_RESOURCE_INFO       *Info);
   1277 
   1278 ASL_RESOURCE_NODE *
   1279 RsDoStartDependentDescriptor (
   1280     ASL_RESOURCE_INFO       *Info);
   1281 
   1282 ASL_RESOURCE_NODE *
   1283 RsDoStartDependentNoPriDescriptor (
   1284     ASL_RESOURCE_INFO       *Info);
   1285 
   1286 ASL_RESOURCE_NODE *
   1287 RsDoVendorSmallDescriptor (
   1288     ASL_RESOURCE_INFO       *Info);
   1289 
   1290 
   1291 /*
   1292  * aslrestype1i - I/O-related Small descriptors
   1293  */
   1294 ASL_RESOURCE_NODE *
   1295 RsDoDmaDescriptor (
   1296     ASL_RESOURCE_INFO       *Info);
   1297 
   1298 ASL_RESOURCE_NODE *
   1299 RsDoFixedDmaDescriptor (
   1300     ASL_RESOURCE_INFO       *Info);
   1301 
   1302 ASL_RESOURCE_NODE *
   1303 RsDoFixedIoDescriptor (
   1304     ASL_RESOURCE_INFO       *Info);
   1305 
   1306 ASL_RESOURCE_NODE *
   1307 RsDoIoDescriptor (
   1308     ASL_RESOURCE_INFO       *Info);
   1309 
   1310 ASL_RESOURCE_NODE *
   1311 RsDoIrqDescriptor (
   1312     ASL_RESOURCE_INFO       *Info);
   1313 
   1314 ASL_RESOURCE_NODE *
   1315 RsDoIrqNoFlagsDescriptor (
   1316     ASL_RESOURCE_INFO       *Info);
   1317 
   1318 
   1319 /*
   1320  * aslrestype2 - Large resource descriptors
   1321  */
   1322 ASL_RESOURCE_NODE *
   1323 RsDoInterruptDescriptor (
   1324     ASL_RESOURCE_INFO       *Info);
   1325 
   1326 ASL_RESOURCE_NODE *
   1327 RsDoVendorLargeDescriptor (
   1328     ASL_RESOURCE_INFO       *Info);
   1329 
   1330 ASL_RESOURCE_NODE *
   1331 RsDoGeneralRegisterDescriptor (
   1332     ASL_RESOURCE_INFO       *Info);
   1333 
   1334 ASL_RESOURCE_NODE *
   1335 RsDoGpioIntDescriptor (
   1336     ASL_RESOURCE_INFO       *Info);
   1337 
   1338 ASL_RESOURCE_NODE *
   1339 RsDoGpioIoDescriptor (
   1340     ASL_RESOURCE_INFO       *Info);
   1341 
   1342 ASL_RESOURCE_NODE *
   1343 RsDoI2cSerialBusDescriptor (
   1344     ASL_RESOURCE_INFO       *Info);
   1345 
   1346 ASL_RESOURCE_NODE *
   1347 RsDoSpiSerialBusDescriptor (
   1348     ASL_RESOURCE_INFO       *Info);
   1349 
   1350 ASL_RESOURCE_NODE *
   1351 RsDoUartSerialBusDescriptor (
   1352     ASL_RESOURCE_INFO       *Info);
   1353 
   1354 ASL_RESOURCE_NODE *
   1355 RsDoPinFunctionDescriptor (
   1356     ASL_RESOURCE_INFO       *Info);
   1357 
   1358 ASL_RESOURCE_NODE *
   1359 RsDoPinConfigDescriptor (
   1360     ASL_RESOURCE_INFO       *Info);
   1361 
   1362 ASL_RESOURCE_NODE *
   1363 RsDoPinGroupDescriptor (
   1364     ASL_RESOURCE_INFO       *Info);
   1365 
   1366 ASL_RESOURCE_NODE *
   1367 RsDoPinGroupFunctionDescriptor (
   1368     ASL_RESOURCE_INFO       *Info);
   1369 
   1370 ASL_RESOURCE_NODE *
   1371 RsDoPinGroupConfigDescriptor (
   1372     ASL_RESOURCE_INFO       *Info);
   1373 
   1374 /*
   1375  * aslrestype2d - DWord address descriptors
   1376  */
   1377 ASL_RESOURCE_NODE *
   1378 RsDoDwordIoDescriptor (
   1379     ASL_RESOURCE_INFO       *Info);
   1380 
   1381 ASL_RESOURCE_NODE *
   1382 RsDoDwordMemoryDescriptor (
   1383     ASL_RESOURCE_INFO       *Info);
   1384 
   1385 ASL_RESOURCE_NODE *
   1386 RsDoDwordSpaceDescriptor (
   1387     ASL_RESOURCE_INFO       *Info);
   1388 
   1389 
   1390 /*
   1391  * aslrestype2e - Extended address descriptors
   1392  */
   1393 ASL_RESOURCE_NODE *
   1394 RsDoExtendedIoDescriptor (
   1395     ASL_RESOURCE_INFO       *Info);
   1396 
   1397 ASL_RESOURCE_NODE *
   1398 RsDoExtendedMemoryDescriptor (
   1399     ASL_RESOURCE_INFO       *Info);
   1400 
   1401 ASL_RESOURCE_NODE *
   1402 RsDoExtendedSpaceDescriptor (
   1403     ASL_RESOURCE_INFO       *Info);
   1404 
   1405 
   1406 /*
   1407  * aslrestype2q - QWord address descriptors
   1408  */
   1409 ASL_RESOURCE_NODE *
   1410 RsDoQwordIoDescriptor (
   1411     ASL_RESOURCE_INFO       *Info);
   1412 
   1413 ASL_RESOURCE_NODE *
   1414 RsDoQwordMemoryDescriptor (
   1415     ASL_RESOURCE_INFO       *Info);
   1416 
   1417 ASL_RESOURCE_NODE *
   1418 RsDoQwordSpaceDescriptor (
   1419     ASL_RESOURCE_INFO       *Info);
   1420 
   1421 
   1422 /*
   1423  * aslrestype2w - Word address descriptors
   1424  */
   1425 ASL_RESOURCE_NODE *
   1426 RsDoWordIoDescriptor (
   1427     ASL_RESOURCE_INFO       *Info);
   1428 
   1429 ASL_RESOURCE_NODE *
   1430 RsDoWordSpaceDescriptor (
   1431     ASL_RESOURCE_INFO       *Info);
   1432 
   1433 ASL_RESOURCE_NODE *
   1434 RsDoWordBusNumberDescriptor (
   1435     ASL_RESOURCE_INFO       *Info);
   1436 
   1437 
   1438 /*
   1439  * Entry to data table compiler subsystem
   1440  */
   1441 ACPI_STATUS
   1442 DtDoCompile(
   1443     void);
   1444 
   1445 ACPI_STATUS
   1446 DtCreateTemplates (
   1447     char                    **argv);
   1448 
   1449 
   1450 /*
   1451  * ASL/ASL+ converter debug
   1452  */
   1453 void
   1454 CvDbgPrint (
   1455     char                    *Fmt,
   1456     ...);
   1457 
   1458 
   1459 #endif /*  __ASLCOMPILER_H */
   1460