sys/contrib/dev/acpica/source/compiler/aslcompiler.h

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