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