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