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