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