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