Home | History | Annotate | Line # | Download | only in compiler
aslcompiler.h revision 1.1.1.5 
      1 /******************************************************************************
      2  *
      3  * Module Name: aslcompiler.h - common include file for iASL
      4  *
      5  *****************************************************************************/
      6 
      7 /*
      8  * Copyright (C) 2000 - 2014, 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  * aslcodegen - code generation
    547  */
    548 void
    549 CgGenerateAmlOutput (
    550     void);
    551 
    552 
    553 /*
    554  * aslfile
    555  */
    556 void
    557 FlOpenFile (
    558     UINT32                  FileId,
    559     char                    *Filename,
    560     char                    *Mode);
    561 
    562 
    563 /*
    564  * asllength - calculate/adjust AML package lengths
    565  */
    566 ACPI_STATUS
    567 LnPackageLengthWalk (
    568     ACPI_PARSE_OBJECT       *Op,
    569     UINT32                  Level,
    570     void                    *Context);
    571 
    572 ACPI_STATUS
    573 LnInitLengthsWalk (
    574     ACPI_PARSE_OBJECT       *Op,
    575     UINT32                  Level,
    576     void                    *Context);
    577 
    578 void
    579 CgGenerateAmlLengths (
    580     ACPI_PARSE_OBJECT       *Op);
    581 
    582 
    583 /*
    584  * aslmap - opcode mappings and reserved method names
    585  */
    586 ACPI_OBJECT_TYPE
    587 AslMapNamedOpcodeToDataType (
    588     UINT16                  Opcode);
    589 
    590 
    591 /*
    592  * aslpredef - ACPI predefined names support
    593  */
    594 BOOLEAN
    595 ApCheckForPredefinedMethod (
    596     ACPI_PARSE_OBJECT       *Op,
    597     ASL_METHOD_INFO         *MethodInfo);
    598 
    599 void
    600 ApCheckPredefinedReturnValue (
    601     ACPI_PARSE_OBJECT       *Op,
    602     ASL_METHOD_INFO         *MethodInfo);
    603 
    604 UINT32
    605 ApCheckForPredefinedName (
    606     ACPI_PARSE_OBJECT       *Op,
    607     char                    *Name);
    608 
    609 void
    610 ApCheckForPredefinedObject (
    611     ACPI_PARSE_OBJECT       *Op,
    612     char                    *Name);
    613 
    614 ACPI_STATUS
    615 ApCheckObjectType (
    616     const char              *PredefinedName,
    617     ACPI_PARSE_OBJECT       *Op,
    618     UINT32                  ExpectedBtypes,
    619     UINT32                  PackageIndex);
    620 
    621 void
    622 ApDisplayReservedNames (
    623     void);
    624 
    625 
    626 /*
    627  * aslprepkg - ACPI predefined names support for packages
    628  */
    629 void
    630 ApCheckPackage (
    631     ACPI_PARSE_OBJECT           *ParentOp,
    632     const ACPI_PREDEFINED_INFO  *Predefined);
    633 
    634 
    635 /*
    636  * asltransform - parse tree transformations
    637  */
    638 ACPI_STATUS
    639 TrAmlTransformWalk (
    640     ACPI_PARSE_OBJECT       *Op,
    641     UINT32                  Level,
    642     void                    *Context);
    643 
    644 
    645 /*
    646  * asltree - parse tree support
    647  */
    648 ACPI_STATUS
    649 TrWalkParseTree (
    650     ACPI_PARSE_OBJECT       *Op,
    651     UINT32                  Visitation,
    652     ASL_WALK_CALLBACK       DescendingCallback,
    653     ASL_WALK_CALLBACK       AscendingCallback,
    654     void                    *Context);
    655 
    656 /* Values for "Visitation" parameter above */
    657 
    658 #define ASL_WALK_VISIT_DOWNWARD     0x01
    659 #define ASL_WALK_VISIT_UPWARD       0x02
    660 #define ASL_WALK_VISIT_TWICE        (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
    661 
    662 
    663 ACPI_PARSE_OBJECT *
    664 TrAllocateNode (
    665     UINT32                  ParseOpcode);
    666 
    667 void
    668 TrReleaseNode (
    669     ACPI_PARSE_OBJECT       *Op);
    670 
    671 ACPI_PARSE_OBJECT *
    672 TrUpdateNode (
    673     UINT32                  ParseOpcode,
    674     ACPI_PARSE_OBJECT       *Op);
    675 
    676 ACPI_PARSE_OBJECT *
    677 TrCreateNode (
    678     UINT32                  ParseOpcode,
    679     UINT32                  NumChildren,
    680     ...);
    681 
    682 ACPI_PARSE_OBJECT *
    683 TrCreateLeafNode (
    684     UINT32                  ParseOpcode);
    685 
    686 ACPI_PARSE_OBJECT *
    687 TrCreateValuedLeafNode (
    688     UINT32                  ParseOpcode,
    689     UINT64                  Value);
    690 
    691 ACPI_PARSE_OBJECT *
    692 TrCreateConstantLeafNode (
    693     UINT32                  ParseOpcode);
    694 
    695 ACPI_PARSE_OBJECT *
    696 TrLinkChildren (
    697     ACPI_PARSE_OBJECT       *Op,
    698     UINT32                  NumChildren,
    699     ...);
    700 
    701 void
    702 TrSetEndLineNumber (
    703     ACPI_PARSE_OBJECT       *Op);
    704 
    705 void
    706 TrWalkTree (
    707     void);
    708 
    709 ACPI_PARSE_OBJECT *
    710 TrLinkPeerNode (
    711     ACPI_PARSE_OBJECT       *Op1,
    712     ACPI_PARSE_OBJECT       *Op2);
    713 
    714 ACPI_PARSE_OBJECT *
    715 TrLinkChildNode (
    716     ACPI_PARSE_OBJECT       *Op1,
    717     ACPI_PARSE_OBJECT       *Op2);
    718 
    719 ACPI_PARSE_OBJECT *
    720 TrSetNodeFlags (
    721     ACPI_PARSE_OBJECT       *Op,
    722     UINT32                  Flags);
    723 
    724 ACPI_PARSE_OBJECT *
    725 TrSetNodeAmlLength (
    726     ACPI_PARSE_OBJECT       *Op,
    727     UINT32                  Length);
    728 
    729 ACPI_PARSE_OBJECT *
    730 TrLinkPeerNodes (
    731     UINT32                  NumPeers,
    732     ...);
    733 
    734 
    735 /*
    736  * aslfiles - File I/O support
    737  */
    738 void
    739 FlAddIncludeDirectory (
    740     char                    *Dir);
    741 
    742 char *
    743 FlMergePathnames (
    744     char                    *PrefixDir,
    745     char                    *FilePathname);
    746 
    747 void
    748 FlOpenIncludeFile (
    749     ACPI_PARSE_OBJECT       *Op);
    750 
    751 void
    752 FlFileError (
    753     UINT32                  FileId,
    754     UINT8                   ErrorId);
    755 
    756 UINT32
    757 FlGetFileSize (
    758     UINT32                  FileId);
    759 
    760 ACPI_STATUS
    761 FlReadFile (
    762     UINT32                  FileId,
    763     void                    *Buffer,
    764     UINT32                  Length);
    765 
    766 void
    767 FlWriteFile (
    768     UINT32                  FileId,
    769     void                    *Buffer,
    770     UINT32                  Length);
    771 
    772 void
    773 FlSeekFile (
    774     UINT32                  FileId,
    775     long                    Offset);
    776 
    777 void
    778 FlCloseFile (
    779     UINT32                  FileId);
    780 
    781 void
    782 FlPrintFile (
    783     UINT32                  FileId,
    784     char                    *Format,
    785     ...);
    786 
    787 void
    788 FlDeleteFile (
    789     UINT32                  FileId);
    790 
    791 void
    792 FlSetLineNumber (
    793     UINT32                  LineNumber);
    794 
    795 void
    796 FlSetFilename (
    797     char                    *Filename);
    798 
    799 ACPI_STATUS
    800 FlOpenInputFile (
    801     char                    *InputFilename);
    802 
    803 ACPI_STATUS
    804 FlOpenAmlOutputFile (
    805     char                    *InputFilename);
    806 
    807 ACPI_STATUS
    808 FlOpenMiscOutputFiles (
    809     char                    *InputFilename);
    810 
    811 /*
    812  * aslhwmap - hardware map summary
    813  */
    814 void
    815 MpEmitMappingInfo (
    816     void);
    817 
    818 
    819 /*
    820  * asload - load namespace in prep for cross reference
    821  */
    822 ACPI_STATUS
    823 LdLoadNamespace (
    824     ACPI_PARSE_OBJECT       *RootOp);
    825 
    826 
    827 /*
    828  * asllookup - namespace lookup functions
    829  */
    830 void
    831 LkFindUnreferencedObjects (
    832     void);
    833 
    834 /*
    835  * aslmain - startup
    836  */
    837 void
    838 Usage (
    839     void);
    840 
    841 void
    842 AslFilenameHelp (
    843     void);
    844 
    845 
    846 /*
    847  * aslnamesp - namespace output file generation
    848  */
    849 ACPI_STATUS
    850 NsDisplayNamespace (
    851     void);
    852 
    853 void
    854 NsSetupNamespaceListing (
    855     void                    *Handle);
    856 
    857 /*
    858  * asloptions - command line processing
    859  */
    860 int
    861 AslCommandLine (
    862     int                     argc,
    863     char                    **argv);
    864 
    865 /*
    866  * aslxref - namespace cross reference
    867  */
    868 ACPI_STATUS
    869 XfCrossReferenceNamespace (
    870     void);
    871 
    872 
    873 /*
    874  * aslutils - common compiler utilites
    875  */
    876 void
    877 DbgPrint (
    878     UINT32                  Type,
    879     char                    *Format,
    880     ...);
    881 
    882 /* Type values for above */
    883 
    884 #define ASL_DEBUG_OUTPUT    0
    885 #define ASL_PARSE_OUTPUT    1
    886 #define ASL_TREE_OUTPUT     2
    887 
    888 void
    889 UtDisplaySupportedTables (
    890     void);
    891 
    892 void
    893 UtDisplayConstantOpcodes (
    894     void);
    895 
    896 UINT8
    897 UtBeginEvent (
    898     char                    *Name);
    899 
    900 void
    901 UtEndEvent (
    902     UINT8                   Event);
    903 
    904 void *
    905 UtLocalCalloc (
    906     UINT32                  Size);
    907 
    908 void
    909 UtPrintFormattedName (
    910     UINT16                  ParseOpcode,
    911     UINT32                  Level);
    912 
    913 void
    914 UtDisplaySummary (
    915     UINT32                  FileId);
    916 
    917 void
    918 UtConvertByteToHex (
    919     UINT8                   RawByte,
    920     UINT8                   *Buffer);
    921 
    922 void
    923 UtConvertByteToAsmHex (
    924     UINT8                   RawByte,
    925     UINT8                   *Buffer);
    926 
    927 char *
    928 UtGetOpName (
    929     UINT32                  ParseOpcode);
    930 
    931 void
    932 UtSetParseOpName (
    933     ACPI_PARSE_OBJECT       *Op);
    934 
    935 char *
    936 UtStringCacheCalloc (
    937     UINT32                  Length);
    938 
    939 void
    940 UtExpandLineBuffers (
    941     void);
    942 
    943 void
    944 UtFreeLineBuffers (
    945     void);
    946 
    947 ACPI_STATUS
    948 UtInternalizeName (
    949     char                    *ExternalName,
    950     char                    **ConvertedName);
    951 
    952 void
    953 UtAttachNamepathToOwner (
    954     ACPI_PARSE_OBJECT       *Op,
    955     ACPI_PARSE_OBJECT       *NameNode);
    956 
    957 ACPI_PARSE_OBJECT *
    958 UtCheckIntegerRange (
    959     ACPI_PARSE_OBJECT       *Op,
    960     UINT32                  LowValue,
    961     UINT32                  HighValue);
    962 
    963 UINT64
    964 UtDoConstant (
    965     char                    *String);
    966 
    967 ACPI_STATUS
    968 UtStrtoul64 (
    969     char                    *String,
    970     UINT32                  Base,
    971     UINT64                  *RetInteger);
    972 
    973 
    974 /*
    975  * asluuid - UUID support
    976  */
    977 ACPI_STATUS
    978 AuValidateUuid (
    979     char                    *InString);
    980 
    981 ACPI_STATUS
    982 AuConvertUuidToString (
    983     char                    *UuIdBuffer,
    984     char                    *OutString);
    985 
    986 /*
    987  * aslresource - Resource template generation utilities
    988  */
    989 void
    990 RsSmallAddressCheck (
    991     UINT8                   Type,
    992     UINT32                  Minimum,
    993     UINT32                  Maximum,
    994     UINT32                  Length,
    995     UINT32                  Alignment,
    996     ACPI_PARSE_OBJECT       *MinOp,
    997     ACPI_PARSE_OBJECT       *MaxOp,
    998     ACPI_PARSE_OBJECT       *LengthOp,
    999     ACPI_PARSE_OBJECT       *AlignOp,
   1000     ACPI_PARSE_OBJECT       *Op);
   1001 
   1002 void
   1003 RsLargeAddressCheck (
   1004     UINT64                  Minimum,
   1005     UINT64                  Maximum,
   1006     UINT64                  Length,
   1007     UINT64                  Granularity,
   1008     UINT8                   Flags,
   1009     ACPI_PARSE_OBJECT       *MinOp,
   1010     ACPI_PARSE_OBJECT       *MaxOp,
   1011     ACPI_PARSE_OBJECT       *LengthOp,
   1012     ACPI_PARSE_OBJECT       *GranOp,
   1013     ACPI_PARSE_OBJECT       *Op);
   1014 
   1015 UINT16
   1016 RsGetStringDataLength (
   1017     ACPI_PARSE_OBJECT       *InitializerOp);
   1018 
   1019 ASL_RESOURCE_NODE *
   1020 RsAllocateResourceNode (
   1021     UINT32                  Size);
   1022 
   1023 void
   1024 RsCreateResourceField (
   1025     ACPI_PARSE_OBJECT       *Op,
   1026     char                    *Name,
   1027     UINT32                  ByteOffset,
   1028     UINT32                  BitOffset,
   1029     UINT32                  BitLength);
   1030 
   1031 void
   1032 RsSetFlagBits (
   1033     UINT8                   *Flags,
   1034     ACPI_PARSE_OBJECT       *Op,
   1035     UINT8                   Position,
   1036     UINT8                   DefaultBit);
   1037 
   1038 void
   1039 RsSetFlagBits16 (
   1040     UINT16                  *Flags,
   1041     ACPI_PARSE_OBJECT       *Op,
   1042     UINT8                   Position,
   1043     UINT8                   DefaultBit);
   1044 
   1045 ACPI_PARSE_OBJECT *
   1046 RsCompleteNodeAndGetNext (
   1047     ACPI_PARSE_OBJECT       *Op);
   1048 
   1049 void
   1050 RsCheckListForDuplicates (
   1051     ACPI_PARSE_OBJECT       *Op);
   1052 
   1053 ASL_RESOURCE_NODE *
   1054 RsDoOneResourceDescriptor (
   1055     ASL_RESOURCE_INFO       *Info,
   1056     UINT8                   *State);
   1057 
   1058 /* Values for State above */
   1059 
   1060 #define ACPI_RSTATE_NORMAL              0
   1061 #define ACPI_RSTATE_START_DEPENDENT     1
   1062 #define ACPI_RSTATE_DEPENDENT_LIST      2
   1063 
   1064 UINT32
   1065 RsLinkDescriptorChain (
   1066     ASL_RESOURCE_NODE       **PreviousRnode,
   1067     ASL_RESOURCE_NODE       *Rnode);
   1068 
   1069 void
   1070 RsDoResourceTemplate (
   1071     ACPI_PARSE_OBJECT       *Op);
   1072 
   1073 
   1074 /*
   1075  * aslrestype1 - Miscellaneous Small descriptors
   1076  */
   1077 ASL_RESOURCE_NODE *
   1078 RsDoEndTagDescriptor (
   1079     ASL_RESOURCE_INFO       *Info);
   1080 
   1081 ASL_RESOURCE_NODE *
   1082 RsDoEndDependentDescriptor (
   1083     ASL_RESOURCE_INFO       *Info);
   1084 
   1085 ASL_RESOURCE_NODE *
   1086 RsDoMemory24Descriptor (
   1087     ASL_RESOURCE_INFO       *Info);
   1088 
   1089 ASL_RESOURCE_NODE *
   1090 RsDoMemory32Descriptor (
   1091     ASL_RESOURCE_INFO       *Info);
   1092 
   1093 ASL_RESOURCE_NODE *
   1094 RsDoMemory32FixedDescriptor (
   1095     ASL_RESOURCE_INFO       *Info);
   1096 
   1097 ASL_RESOURCE_NODE *
   1098 RsDoStartDependentDescriptor (
   1099     ASL_RESOURCE_INFO       *Info);
   1100 
   1101 ASL_RESOURCE_NODE *
   1102 RsDoStartDependentNoPriDescriptor (
   1103     ASL_RESOURCE_INFO       *Info);
   1104 
   1105 ASL_RESOURCE_NODE *
   1106 RsDoVendorSmallDescriptor (
   1107     ASL_RESOURCE_INFO       *Info);
   1108 
   1109 
   1110 /*
   1111  * aslrestype1i - I/O-related Small descriptors
   1112  */
   1113 ASL_RESOURCE_NODE *
   1114 RsDoDmaDescriptor (
   1115     ASL_RESOURCE_INFO       *Info);
   1116 
   1117 ASL_RESOURCE_NODE *
   1118 RsDoFixedDmaDescriptor (
   1119     ASL_RESOURCE_INFO       *Info);
   1120 
   1121 ASL_RESOURCE_NODE *
   1122 RsDoFixedIoDescriptor (
   1123     ASL_RESOURCE_INFO       *Info);
   1124 
   1125 ASL_RESOURCE_NODE *
   1126 RsDoIoDescriptor (
   1127     ASL_RESOURCE_INFO       *Info);
   1128 
   1129 ASL_RESOURCE_NODE *
   1130 RsDoIrqDescriptor (
   1131     ASL_RESOURCE_INFO       *Info);
   1132 
   1133 ASL_RESOURCE_NODE *
   1134 RsDoIrqNoFlagsDescriptor (
   1135     ASL_RESOURCE_INFO       *Info);
   1136 
   1137 
   1138 /*
   1139  * aslrestype2 - Large resource descriptors
   1140  */
   1141 ASL_RESOURCE_NODE *
   1142 RsDoInterruptDescriptor (
   1143     ASL_RESOURCE_INFO       *Info);
   1144 
   1145 ASL_RESOURCE_NODE *
   1146 RsDoVendorLargeDescriptor (
   1147     ASL_RESOURCE_INFO       *Info);
   1148 
   1149 ASL_RESOURCE_NODE *
   1150 RsDoGeneralRegisterDescriptor (
   1151     ASL_RESOURCE_INFO       *Info);
   1152 
   1153 ASL_RESOURCE_NODE *
   1154 RsDoGpioIntDescriptor (
   1155     ASL_RESOURCE_INFO       *Info);
   1156 
   1157 ASL_RESOURCE_NODE *
   1158 RsDoGpioIoDescriptor (
   1159     ASL_RESOURCE_INFO       *Info);
   1160 
   1161 ASL_RESOURCE_NODE *
   1162 RsDoI2cSerialBusDescriptor (
   1163     ASL_RESOURCE_INFO       *Info);
   1164 
   1165 ASL_RESOURCE_NODE *
   1166 RsDoSpiSerialBusDescriptor (
   1167     ASL_RESOURCE_INFO       *Info);
   1168 
   1169 ASL_RESOURCE_NODE *
   1170 RsDoUartSerialBusDescriptor (
   1171     ASL_RESOURCE_INFO       *Info);
   1172 
   1173 /*
   1174  * aslrestype2d - DWord address descriptors
   1175  */
   1176 ASL_RESOURCE_NODE *
   1177 RsDoDwordIoDescriptor (
   1178     ASL_RESOURCE_INFO       *Info);
   1179 
   1180 ASL_RESOURCE_NODE *
   1181 RsDoDwordMemoryDescriptor (
   1182     ASL_RESOURCE_INFO       *Info);
   1183 
   1184 ASL_RESOURCE_NODE *
   1185 RsDoDwordSpaceDescriptor (
   1186     ASL_RESOURCE_INFO       *Info);
   1187 
   1188 
   1189 /*
   1190  * aslrestype2e - Extended address descriptors
   1191  */
   1192 ASL_RESOURCE_NODE *
   1193 RsDoExtendedIoDescriptor (
   1194     ASL_RESOURCE_INFO       *Info);
   1195 
   1196 ASL_RESOURCE_NODE *
   1197 RsDoExtendedMemoryDescriptor (
   1198     ASL_RESOURCE_INFO       *Info);
   1199 
   1200 ASL_RESOURCE_NODE *
   1201 RsDoExtendedSpaceDescriptor (
   1202     ASL_RESOURCE_INFO       *Info);
   1203 
   1204 
   1205 /*
   1206  * aslrestype2q - QWord address descriptors
   1207  */
   1208 ASL_RESOURCE_NODE *
   1209 RsDoQwordIoDescriptor (
   1210     ASL_RESOURCE_INFO       *Info);
   1211 
   1212 ASL_RESOURCE_NODE *
   1213 RsDoQwordMemoryDescriptor (
   1214     ASL_RESOURCE_INFO       *Info);
   1215 
   1216 ASL_RESOURCE_NODE *
   1217 RsDoQwordSpaceDescriptor (
   1218     ASL_RESOURCE_INFO       *Info);
   1219 
   1220 
   1221 /*
   1222  * aslrestype2w - Word address descriptors
   1223  */
   1224 ASL_RESOURCE_NODE *
   1225 RsDoWordIoDescriptor (
   1226     ASL_RESOURCE_INFO       *Info);
   1227 
   1228 ASL_RESOURCE_NODE *
   1229 RsDoWordSpaceDescriptor (
   1230     ASL_RESOURCE_INFO       *Info);
   1231 
   1232 ASL_RESOURCE_NODE *
   1233 RsDoWordBusNumberDescriptor (
   1234     ASL_RESOURCE_INFO       *Info);
   1235 
   1236 
   1237 /*
   1238  * Entry to data table compiler subsystem
   1239  */
   1240 ACPI_STATUS
   1241 DtDoCompile(
   1242     void);
   1243 
   1244 ACPI_STATUS
   1245 DtCreateTemplates (
   1246     char                    *Signature);
   1247 
   1248 #endif /*  __ASLCOMPILER_H */
   1249