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