Home | History | Annotate | Line # | Download | only in compiler
aslcompiler.h revision 1.4 
      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 UtLocalFree (
    952     void		    *Allocated,
    953     UINT32                  Size);
    954 
    955 void
    956 UtPrintFormattedName (
    957     UINT16                  ParseOpcode,
    958     UINT32                  Level);
    959 
    960 void
    961 UtDisplaySummary (
    962     UINT32                  FileId);
    963 
    964 void
    965 UtConvertByteToHex (
    966     UINT8                   RawByte,
    967     UINT8                   *Buffer);
    968 
    969 void
    970 UtConvertByteToAsmHex (
    971     UINT8                   RawByte,
    972     UINT8                   *Buffer);
    973 
    974 char *
    975 UtGetOpName (
    976     UINT32                  ParseOpcode);
    977 
    978 void
    979 UtSetParseOpName (
    980     ACPI_PARSE_OBJECT       *Op);
    981 
    982 char *
    983 UtStringCacheCalloc (
    984     UINT32                  Length);
    985 
    986 void
    987 UtExpandLineBuffers (
    988     void);
    989 
    990 void
    991 UtFreeLineBuffers (
    992     void);
    993 
    994 ACPI_STATUS
    995 UtInternalizeName (
    996     char                    *ExternalName,
    997     char                    **ConvertedName);
    998 
    999 void
   1000 UtAttachNamepathToOwner (
   1001     ACPI_PARSE_OBJECT       *Op,
   1002     ACPI_PARSE_OBJECT       *NameNode);
   1003 
   1004 ACPI_PARSE_OBJECT *
   1005 UtCheckIntegerRange (
   1006     ACPI_PARSE_OBJECT       *Op,
   1007     UINT32                  LowValue,
   1008     UINT32                  HighValue);
   1009 
   1010 UINT64
   1011 UtDoConstant (
   1012     char                    *String);
   1013 
   1014 ACPI_STATUS
   1015 stroul64 (
   1016     char                    *String,
   1017     UINT32                  Base,
   1018     UINT64                  *RetInteger);
   1019 
   1020 
   1021 /*
   1022  * asluuid - UUID support
   1023  */
   1024 ACPI_STATUS
   1025 AuValidateUuid (
   1026     char                    *InString);
   1027 
   1028 ACPI_STATUS
   1029 AuConvertUuidToString (
   1030     char                    *UuIdBuffer,
   1031     char                    *OutString);
   1032 
   1033 /*
   1034  * aslresource - Resource template generation utilities
   1035  */
   1036 void
   1037 RsSmallAddressCheck (
   1038     UINT8                   Type,
   1039     UINT32                  Minimum,
   1040     UINT32                  Maximum,
   1041     UINT32                  Length,
   1042     UINT32                  Alignment,
   1043     ACPI_PARSE_OBJECT       *MinOp,
   1044     ACPI_PARSE_OBJECT       *MaxOp,
   1045     ACPI_PARSE_OBJECT       *LengthOp,
   1046     ACPI_PARSE_OBJECT       *AlignOp,
   1047     ACPI_PARSE_OBJECT       *Op);
   1048 
   1049 void
   1050 RsLargeAddressCheck (
   1051     UINT64                  Minimum,
   1052     UINT64                  Maximum,
   1053     UINT64                  Length,
   1054     UINT64                  Granularity,
   1055     UINT8                   Flags,
   1056     ACPI_PARSE_OBJECT       *MinOp,
   1057     ACPI_PARSE_OBJECT       *MaxOp,
   1058     ACPI_PARSE_OBJECT       *LengthOp,
   1059     ACPI_PARSE_OBJECT       *GranOp,
   1060     ACPI_PARSE_OBJECT       *Op);
   1061 
   1062 UINT16
   1063 RsGetStringDataLength (
   1064     ACPI_PARSE_OBJECT       *InitializerOp);
   1065 
   1066 ASL_RESOURCE_NODE *
   1067 RsAllocateResourceNode (
   1068     UINT32                  Size);
   1069 
   1070 void
   1071 RsCreateResourceField (
   1072     ACPI_PARSE_OBJECT       *Op,
   1073     char                    *Name,
   1074     UINT32                  ByteOffset,
   1075     UINT32                  BitOffset,
   1076     UINT32                  BitLength);
   1077 
   1078 void
   1079 RsSetFlagBits (
   1080     UINT8                   *Flags,
   1081     ACPI_PARSE_OBJECT       *Op,
   1082     UINT8                   Position,
   1083     UINT8                   DefaultBit);
   1084 
   1085 void
   1086 RsSetFlagBits16 (
   1087     UINT16                  *Flags,
   1088     ACPI_PARSE_OBJECT       *Op,
   1089     UINT8                   Position,
   1090     UINT8                   DefaultBit);
   1091 
   1092 ACPI_PARSE_OBJECT *
   1093 RsCompleteNodeAndGetNext (
   1094     ACPI_PARSE_OBJECT       *Op);
   1095 
   1096 void
   1097 RsCheckListForDuplicates (
   1098     ACPI_PARSE_OBJECT       *Op);
   1099 
   1100 ASL_RESOURCE_NODE *
   1101 RsDoOneResourceDescriptor (
   1102     ASL_RESOURCE_INFO       *Info,
   1103     UINT8                   *State);
   1104 
   1105 /* Values for State above */
   1106 
   1107 #define ACPI_RSTATE_NORMAL              0
   1108 #define ACPI_RSTATE_START_DEPENDENT     1
   1109 #define ACPI_RSTATE_DEPENDENT_LIST      2
   1110 
   1111 UINT32
   1112 RsLinkDescriptorChain (
   1113     ASL_RESOURCE_NODE       **PreviousRnode,
   1114     ASL_RESOURCE_NODE       *Rnode);
   1115 
   1116 void
   1117 RsDoResourceTemplate (
   1118     ACPI_PARSE_OBJECT       *Op);
   1119 
   1120 
   1121 /*
   1122  * aslrestype1 - Miscellaneous Small descriptors
   1123  */
   1124 ASL_RESOURCE_NODE *
   1125 RsDoEndTagDescriptor (
   1126     ASL_RESOURCE_INFO       *Info);
   1127 
   1128 ASL_RESOURCE_NODE *
   1129 RsDoEndDependentDescriptor (
   1130     ASL_RESOURCE_INFO       *Info);
   1131 
   1132 ASL_RESOURCE_NODE *
   1133 RsDoMemory24Descriptor (
   1134     ASL_RESOURCE_INFO       *Info);
   1135 
   1136 ASL_RESOURCE_NODE *
   1137 RsDoMemory32Descriptor (
   1138     ASL_RESOURCE_INFO       *Info);
   1139 
   1140 ASL_RESOURCE_NODE *
   1141 RsDoMemory32FixedDescriptor (
   1142     ASL_RESOURCE_INFO       *Info);
   1143 
   1144 ASL_RESOURCE_NODE *
   1145 RsDoStartDependentDescriptor (
   1146     ASL_RESOURCE_INFO       *Info);
   1147 
   1148 ASL_RESOURCE_NODE *
   1149 RsDoStartDependentNoPriDescriptor (
   1150     ASL_RESOURCE_INFO       *Info);
   1151 
   1152 ASL_RESOURCE_NODE *
   1153 RsDoVendorSmallDescriptor (
   1154     ASL_RESOURCE_INFO       *Info);
   1155 
   1156 
   1157 /*
   1158  * aslrestype1i - I/O-related Small descriptors
   1159  */
   1160 ASL_RESOURCE_NODE *
   1161 RsDoDmaDescriptor (
   1162     ASL_RESOURCE_INFO       *Info);
   1163 
   1164 ASL_RESOURCE_NODE *
   1165 RsDoFixedDmaDescriptor (
   1166     ASL_RESOURCE_INFO       *Info);
   1167 
   1168 ASL_RESOURCE_NODE *
   1169 RsDoFixedIoDescriptor (
   1170     ASL_RESOURCE_INFO       *Info);
   1171 
   1172 ASL_RESOURCE_NODE *
   1173 RsDoIoDescriptor (
   1174     ASL_RESOURCE_INFO       *Info);
   1175 
   1176 ASL_RESOURCE_NODE *
   1177 RsDoIrqDescriptor (
   1178     ASL_RESOURCE_INFO       *Info);
   1179 
   1180 ASL_RESOURCE_NODE *
   1181 RsDoIrqNoFlagsDescriptor (
   1182     ASL_RESOURCE_INFO       *Info);
   1183 
   1184 
   1185 /*
   1186  * aslrestype2 - Large resource descriptors
   1187  */
   1188 ASL_RESOURCE_NODE *
   1189 RsDoInterruptDescriptor (
   1190     ASL_RESOURCE_INFO       *Info);
   1191 
   1192 ASL_RESOURCE_NODE *
   1193 RsDoVendorLargeDescriptor (
   1194     ASL_RESOURCE_INFO       *Info);
   1195 
   1196 ASL_RESOURCE_NODE *
   1197 RsDoGeneralRegisterDescriptor (
   1198     ASL_RESOURCE_INFO       *Info);
   1199 
   1200 ASL_RESOURCE_NODE *
   1201 RsDoGpioIntDescriptor (
   1202     ASL_RESOURCE_INFO       *Info);
   1203 
   1204 ASL_RESOURCE_NODE *
   1205 RsDoGpioIoDescriptor (
   1206     ASL_RESOURCE_INFO       *Info);
   1207 
   1208 ASL_RESOURCE_NODE *
   1209 RsDoI2cSerialBusDescriptor (
   1210     ASL_RESOURCE_INFO       *Info);
   1211 
   1212 ASL_RESOURCE_NODE *
   1213 RsDoSpiSerialBusDescriptor (
   1214     ASL_RESOURCE_INFO       *Info);
   1215 
   1216 ASL_RESOURCE_NODE *
   1217 RsDoUartSerialBusDescriptor (
   1218     ASL_RESOURCE_INFO       *Info);
   1219 
   1220 /*
   1221  * aslrestype2d - DWord address descriptors
   1222  */
   1223 ASL_RESOURCE_NODE *
   1224 RsDoDwordIoDescriptor (
   1225     ASL_RESOURCE_INFO       *Info);
   1226 
   1227 ASL_RESOURCE_NODE *
   1228 RsDoDwordMemoryDescriptor (
   1229     ASL_RESOURCE_INFO       *Info);
   1230 
   1231 ASL_RESOURCE_NODE *
   1232 RsDoDwordSpaceDescriptor (
   1233     ASL_RESOURCE_INFO       *Info);
   1234 
   1235 
   1236 /*
   1237  * aslrestype2e - Extended address descriptors
   1238  */
   1239 ASL_RESOURCE_NODE *
   1240 RsDoExtendedIoDescriptor (
   1241     ASL_RESOURCE_INFO       *Info);
   1242 
   1243 ASL_RESOURCE_NODE *
   1244 RsDoExtendedMemoryDescriptor (
   1245     ASL_RESOURCE_INFO       *Info);
   1246 
   1247 ASL_RESOURCE_NODE *
   1248 RsDoExtendedSpaceDescriptor (
   1249     ASL_RESOURCE_INFO       *Info);
   1250 
   1251 
   1252 /*
   1253  * aslrestype2q - QWord address descriptors
   1254  */
   1255 ASL_RESOURCE_NODE *
   1256 RsDoQwordIoDescriptor (
   1257     ASL_RESOURCE_INFO       *Info);
   1258 
   1259 ASL_RESOURCE_NODE *
   1260 RsDoQwordMemoryDescriptor (
   1261     ASL_RESOURCE_INFO       *Info);
   1262 
   1263 ASL_RESOURCE_NODE *
   1264 RsDoQwordSpaceDescriptor (
   1265     ASL_RESOURCE_INFO       *Info);
   1266 
   1267 
   1268 /*
   1269  * aslrestype2w - Word address descriptors
   1270  */
   1271 ASL_RESOURCE_NODE *
   1272 RsDoWordIoDescriptor (
   1273     ASL_RESOURCE_INFO       *Info);
   1274 
   1275 ASL_RESOURCE_NODE *
   1276 RsDoWordSpaceDescriptor (
   1277     ASL_RESOURCE_INFO       *Info);
   1278 
   1279 ASL_RESOURCE_NODE *
   1280 RsDoWordBusNumberDescriptor (
   1281     ASL_RESOURCE_INFO       *Info);
   1282 
   1283 
   1284 /*
   1285  * Entry to data table compiler subsystem
   1286  */
   1287 ACPI_STATUS
   1288 DtDoCompile(
   1289     void);
   1290 
   1291 ACPI_STATUS
   1292 DtCreateTemplates (
   1293     char                    **argv);
   1294 
   1295 #endif /*  __ASLCOMPILER_H */
   1296