Home | History | Annotate | Line # | Download | only in compiler
aslcompiler.h revision 1.6 
      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 <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 
   1035 UtDisplaySummary (
   1036     UINT32                  FileId);
   1037 
   1038 void
   1039 UtConvertByteToHex (
   1040     UINT8                   RawByte,
   1041     UINT8                   *Buffer);
   1042 
   1043 void
   1044 UtConvertByteToAsmHex (
   1045     UINT8                   RawByte,
   1046     UINT8                   *Buffer);
   1047 
   1048 char *
   1049 UtGetOpName (
   1050     UINT32                  ParseOpcode);
   1051 
   1052 void
   1053 UtSetParseOpName (
   1054     ACPI_PARSE_OBJECT       *Op);
   1055 
   1056 char *
   1057 UtStringCacheCalloc (
   1058     UINT32                  Length);
   1059 
   1060 void
   1061 UtExpandLineBuffers (
   1062     void);
   1063 
   1064 void
   1065 UtFreeLineBuffers (
   1066     void);
   1067 
   1068 ACPI_STATUS
   1069 UtInternalizeName (
   1070     char                    *ExternalName,
   1071     char                    **ConvertedName);
   1072 
   1073 void
   1074 UtAttachNamepathToOwner (
   1075     ACPI_PARSE_OBJECT       *Op,
   1076     ACPI_PARSE_OBJECT       *NameNode);
   1077 
   1078 ACPI_PARSE_OBJECT *
   1079 UtCheckIntegerRange (
   1080     ACPI_PARSE_OBJECT       *Op,
   1081     UINT32                  LowValue,
   1082     UINT32                  HighValue);
   1083 
   1084 UINT64
   1085 UtDoConstant (
   1086     char                    *String);
   1087 
   1088 
   1089 /*
   1090  * asluuid - UUID support
   1091  */
   1092 ACPI_STATUS
   1093 AuValidateUuid (
   1094     char                    *InString);
   1095 
   1096 ACPI_STATUS
   1097 AuConvertUuidToString (
   1098     char                    *UuIdBuffer,
   1099     char                    *OutString);
   1100 
   1101 /*
   1102  * aslresource - Resource template generation utilities
   1103  */
   1104 void
   1105 RsSmallAddressCheck (
   1106     UINT8                   Type,
   1107     UINT32                  Minimum,
   1108     UINT32                  Maximum,
   1109     UINT32                  Length,
   1110     UINT32                  Alignment,
   1111     ACPI_PARSE_OBJECT       *MinOp,
   1112     ACPI_PARSE_OBJECT       *MaxOp,
   1113     ACPI_PARSE_OBJECT       *LengthOp,
   1114     ACPI_PARSE_OBJECT       *AlignOp,
   1115     ACPI_PARSE_OBJECT       *Op);
   1116 
   1117 void
   1118 RsLargeAddressCheck (
   1119     UINT64                  Minimum,
   1120     UINT64                  Maximum,
   1121     UINT64                  Length,
   1122     UINT64                  Granularity,
   1123     UINT8                   Flags,
   1124     ACPI_PARSE_OBJECT       *MinOp,
   1125     ACPI_PARSE_OBJECT       *MaxOp,
   1126     ACPI_PARSE_OBJECT       *LengthOp,
   1127     ACPI_PARSE_OBJECT       *GranOp,
   1128     ACPI_PARSE_OBJECT       *Op);
   1129 
   1130 UINT16
   1131 RsGetStringDataLength (
   1132     ACPI_PARSE_OBJECT       *InitializerOp);
   1133 
   1134 ASL_RESOURCE_NODE *
   1135 RsAllocateResourceNode (
   1136     UINT32                  Size);
   1137 
   1138 void
   1139 RsCreateResourceField (
   1140     ACPI_PARSE_OBJECT       *Op,
   1141     char                    *Name,
   1142     UINT32                  ByteOffset,
   1143     UINT32                  BitOffset,
   1144     UINT32                  BitLength);
   1145 
   1146 void
   1147 RsSetFlagBits (
   1148     UINT8                   *Flags,
   1149     ACPI_PARSE_OBJECT       *Op,
   1150     UINT8                   Position,
   1151     UINT8                   DefaultBit);
   1152 
   1153 void
   1154 RsSetFlagBits16 (
   1155     UINT16                  *Flags,
   1156     ACPI_PARSE_OBJECT       *Op,
   1157     UINT8                   Position,
   1158     UINT8                   DefaultBit);
   1159 
   1160 ACPI_PARSE_OBJECT *
   1161 RsCompleteNodeAndGetNext (
   1162     ACPI_PARSE_OBJECT       *Op);
   1163 
   1164 void
   1165 RsCheckListForDuplicates (
   1166     ACPI_PARSE_OBJECT       *Op);
   1167 
   1168 ASL_RESOURCE_NODE *
   1169 RsDoOneResourceDescriptor (
   1170     ASL_RESOURCE_INFO       *Info,
   1171     UINT8                   *State);
   1172 
   1173 /* Values for State above */
   1174 
   1175 #define ACPI_RSTATE_NORMAL              0
   1176 #define ACPI_RSTATE_START_DEPENDENT     1
   1177 #define ACPI_RSTATE_DEPENDENT_LIST      2
   1178 
   1179 UINT32
   1180 RsLinkDescriptorChain (
   1181     ASL_RESOURCE_NODE       **PreviousRnode,
   1182     ASL_RESOURCE_NODE       *Rnode);
   1183 
   1184 void
   1185 RsDoResourceTemplate (
   1186     ACPI_PARSE_OBJECT       *Op);
   1187 
   1188 
   1189 /*
   1190  * aslrestype1 - Miscellaneous Small descriptors
   1191  */
   1192 ASL_RESOURCE_NODE *
   1193 RsDoEndTagDescriptor (
   1194     ASL_RESOURCE_INFO       *Info);
   1195 
   1196 ASL_RESOURCE_NODE *
   1197 RsDoEndDependentDescriptor (
   1198     ASL_RESOURCE_INFO       *Info);
   1199 
   1200 ASL_RESOURCE_NODE *
   1201 RsDoMemory24Descriptor (
   1202     ASL_RESOURCE_INFO       *Info);
   1203 
   1204 ASL_RESOURCE_NODE *
   1205 RsDoMemory32Descriptor (
   1206     ASL_RESOURCE_INFO       *Info);
   1207 
   1208 ASL_RESOURCE_NODE *
   1209 RsDoMemory32FixedDescriptor (
   1210     ASL_RESOURCE_INFO       *Info);
   1211 
   1212 ASL_RESOURCE_NODE *
   1213 RsDoStartDependentDescriptor (
   1214     ASL_RESOURCE_INFO       *Info);
   1215 
   1216 ASL_RESOURCE_NODE *
   1217 RsDoStartDependentNoPriDescriptor (
   1218     ASL_RESOURCE_INFO       *Info);
   1219 
   1220 ASL_RESOURCE_NODE *
   1221 RsDoVendorSmallDescriptor (
   1222     ASL_RESOURCE_INFO       *Info);
   1223 
   1224 
   1225 /*
   1226  * aslrestype1i - I/O-related Small descriptors
   1227  */
   1228 ASL_RESOURCE_NODE *
   1229 RsDoDmaDescriptor (
   1230     ASL_RESOURCE_INFO       *Info);
   1231 
   1232 ASL_RESOURCE_NODE *
   1233 RsDoFixedDmaDescriptor (
   1234     ASL_RESOURCE_INFO       *Info);
   1235 
   1236 ASL_RESOURCE_NODE *
   1237 RsDoFixedIoDescriptor (
   1238     ASL_RESOURCE_INFO       *Info);
   1239 
   1240 ASL_RESOURCE_NODE *
   1241 RsDoIoDescriptor (
   1242     ASL_RESOURCE_INFO       *Info);
   1243 
   1244 ASL_RESOURCE_NODE *
   1245 RsDoIrqDescriptor (
   1246     ASL_RESOURCE_INFO       *Info);
   1247 
   1248 ASL_RESOURCE_NODE *
   1249 RsDoIrqNoFlagsDescriptor (
   1250     ASL_RESOURCE_INFO       *Info);
   1251 
   1252 
   1253 /*
   1254  * aslrestype2 - Large resource descriptors
   1255  */
   1256 ASL_RESOURCE_NODE *
   1257 RsDoInterruptDescriptor (
   1258     ASL_RESOURCE_INFO       *Info);
   1259 
   1260 ASL_RESOURCE_NODE *
   1261 RsDoVendorLargeDescriptor (
   1262     ASL_RESOURCE_INFO       *Info);
   1263 
   1264 ASL_RESOURCE_NODE *
   1265 RsDoGeneralRegisterDescriptor (
   1266     ASL_RESOURCE_INFO       *Info);
   1267 
   1268 ASL_RESOURCE_NODE *
   1269 RsDoGpioIntDescriptor (
   1270     ASL_RESOURCE_INFO       *Info);
   1271 
   1272 ASL_RESOURCE_NODE *
   1273 RsDoGpioIoDescriptor (
   1274     ASL_RESOURCE_INFO       *Info);
   1275 
   1276 ASL_RESOURCE_NODE *
   1277 RsDoI2cSerialBusDescriptor (
   1278     ASL_RESOURCE_INFO       *Info);
   1279 
   1280 ASL_RESOURCE_NODE *
   1281 RsDoSpiSerialBusDescriptor (
   1282     ASL_RESOURCE_INFO       *Info);
   1283 
   1284 ASL_RESOURCE_NODE *
   1285 RsDoUartSerialBusDescriptor (
   1286     ASL_RESOURCE_INFO       *Info);
   1287 
   1288 /*
   1289  * aslrestype2d - DWord address descriptors
   1290  */
   1291 ASL_RESOURCE_NODE *
   1292 RsDoDwordIoDescriptor (
   1293     ASL_RESOURCE_INFO       *Info);
   1294 
   1295 ASL_RESOURCE_NODE *
   1296 RsDoDwordMemoryDescriptor (
   1297     ASL_RESOURCE_INFO       *Info);
   1298 
   1299 ASL_RESOURCE_NODE *
   1300 RsDoDwordSpaceDescriptor (
   1301     ASL_RESOURCE_INFO       *Info);
   1302 
   1303 
   1304 /*
   1305  * aslrestype2e - Extended address descriptors
   1306  */
   1307 ASL_RESOURCE_NODE *
   1308 RsDoExtendedIoDescriptor (
   1309     ASL_RESOURCE_INFO       *Info);
   1310 
   1311 ASL_RESOURCE_NODE *
   1312 RsDoExtendedMemoryDescriptor (
   1313     ASL_RESOURCE_INFO       *Info);
   1314 
   1315 ASL_RESOURCE_NODE *
   1316 RsDoExtendedSpaceDescriptor (
   1317     ASL_RESOURCE_INFO       *Info);
   1318 
   1319 
   1320 /*
   1321  * aslrestype2q - QWord address descriptors
   1322  */
   1323 ASL_RESOURCE_NODE *
   1324 RsDoQwordIoDescriptor (
   1325     ASL_RESOURCE_INFO       *Info);
   1326 
   1327 ASL_RESOURCE_NODE *
   1328 RsDoQwordMemoryDescriptor (
   1329     ASL_RESOURCE_INFO       *Info);
   1330 
   1331 ASL_RESOURCE_NODE *
   1332 RsDoQwordSpaceDescriptor (
   1333     ASL_RESOURCE_INFO       *Info);
   1334 
   1335 
   1336 /*
   1337  * aslrestype2w - Word address descriptors
   1338  */
   1339 ASL_RESOURCE_NODE *
   1340 RsDoWordIoDescriptor (
   1341     ASL_RESOURCE_INFO       *Info);
   1342 
   1343 ASL_RESOURCE_NODE *
   1344 RsDoWordSpaceDescriptor (
   1345     ASL_RESOURCE_INFO       *Info);
   1346 
   1347 ASL_RESOURCE_NODE *
   1348 RsDoWordBusNumberDescriptor (
   1349     ASL_RESOURCE_INFO       *Info);
   1350 
   1351 
   1352 /*
   1353  * Entry to data table compiler subsystem
   1354  */
   1355 ACPI_STATUS
   1356 DtDoCompile(
   1357     void);
   1358 
   1359 ACPI_STATUS
   1360 DtCreateTemplates (
   1361     char                    **argv);
   1362 
   1363 #endif /*  __ASLCOMPILER_H */
   1364