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