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