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