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  * aslmain - startup
 915  */
 916 void
 917 Usage (
 918     void);
 919
 920 void
 921 AslFilenameHelp (
 922     void);
 923
 924
 925 /*
 926  * aslnamesp - namespace output file generation
 927  */
 928 ACPI_STATUS
 929 NsDisplayNamespace (
 930     void);
 931
 932 void
 933 NsSetupNamespaceListing (
 934     void                    *Handle);
 935
 936 /*
 937  * asloptions - command line processing
 938  */
 939 int
 940 AslCommandLine (
 941     int                     argc,
 942     char                    **argv);
 943
 944 /*
 945  * aslxref - namespace cross reference
 946  */
 947 ACPI_STATUS
 948 XfCrossReferenceNamespace (
 949     void);
 950
 951
 952 /*
 953  * aslxrefout
 954  */
 955 void
 956 OtPrintHeaders (
 957     char                    *Message);
 958
 959 void
 960 OtCreateXrefFile (
 961     void);
 962
 963 void
 964 OtXrefWalkPart1 (
 965     ACPI_PARSE_OBJECT       *Op,
 966     UINT32                  Level,
 967     ASL_METHOD_INFO         *MethodInfo);
 968
 969
 970 /*
 971  * aslutils - common compiler utilites
 972  */
 973 void
 974 DbgPrint (
 975     UINT32                  Type,
 976     char                    *Format,
 977     ...);
 978
 979 /* Type values for above */
 980
 981 #define ASL_DEBUG_OUTPUT    0
 982 #define ASL_PARSE_OUTPUT    1
 983 #define ASL_TREE_OUTPUT     2
 984
 985 UINT8
 986 UtIsBigEndianMachine (
 987     void);
 988
 989 BOOLEAN
 990 UtQueryForOverwrite (
 991     char                    *Pathname);
 992
 993 void
 994 UtDumpStringOp (
 995     ACPI_PARSE_OBJECT       *Op,
 996     UINT32                  Level);
 997
 998 void
 999 UtDumpIntegerOp (
1000     ACPI_PARSE_OBJECT       *Op,
1001     UINT32                  Level,
1002     UINT32                  IntegerLength);
1003
1004 void
1005 UtDumpBasicOp (
1006     ACPI_PARSE_OBJECT       *Op,
1007     UINT32                  Level);
1008
1009 void
1010 UtDisplaySupportedTables (
1011     void);
1012
1013 void
1014 UtDisplayConstantOpcodes (
1015     void);
1016
1017 UINT8
1018 UtBeginEvent (
1019     char                    *Name);
1020
1021 void
1022 UtEndEvent (
1023     UINT8                   Event);
1024
1025 void *
1026 UtLocalCalloc (
1027     UINT32                  Size);
1028
1029 void
1030 UtDisplaySummary (
1031     UINT32                  FileId);
1032
1033 void
1034 UtConvertByteToHex (
1035     UINT8                   RawByte,
1036     UINT8                   *Buffer);
1037
1038 void
1039 UtConvertByteToAsmHex (
1040     UINT8                   RawByte,
1041     UINT8                   *Buffer);
1042
1043 char *
1044 UtGetOpName (
1045     UINT32                  ParseOpcode);
1046
1047 void
1048 UtSetParseOpName (
1049     ACPI_PARSE_OBJECT       *Op);
1050
1051 char *
1052 UtStringCacheCalloc (
1053     UINT32                  Length);
1054
1055 void
1056 UtExpandLineBuffers (
1057     void);
1058
1059 void
1060 UtFreeLineBuffers (
1061     void);
1062
1063 ACPI_STATUS
1064 UtInternalizeName (
1065     char                    *ExternalName,
1066     char                    **ConvertedName);
1067
1068 void
1069 UtAttachNamepathToOwner (
1070     ACPI_PARSE_OBJECT       *Op,
1071     ACPI_PARSE_OBJECT       *NameNode);
1072
1073 ACPI_PARSE_OBJECT *
1074 UtCheckIntegerRange (
1075     ACPI_PARSE_OBJECT       *Op,
1076     UINT32                  LowValue,
1077     UINT32                  HighValue);
1078
1079 UINT64
1080 UtDoConstant (
1081     char                    *String);
1082
1083
1084 /*
1085  * asluuid - UUID support
1086  */
1087 ACPI_STATUS
1088 AuValidateUuid (
1089     char                    *InString);
1090
1091 ACPI_STATUS
1092 AuConvertUuidToString (
1093     char                    *UuIdBuffer,
1094     char                    *OutString);
1095
1096 /*
1097  * aslresource - Resource template generation utilities
1098  */
1099 void
1100 RsSmallAddressCheck (
1101     UINT8                   Type,
1102     UINT32                  Minimum,
1103     UINT32                  Maximum,
1104     UINT32                  Length,
1105     UINT32                  Alignment,
1106     ACPI_PARSE_OBJECT       *MinOp,
1107     ACPI_PARSE_OBJECT       *MaxOp,
1108     ACPI_PARSE_OBJECT       *LengthOp,
1109     ACPI_PARSE_OBJECT       *AlignOp,
1110     ACPI_PARSE_OBJECT       *Op);
1111
1112 void
1113 RsLargeAddressCheck (
1114     UINT64                  Minimum,
1115     UINT64                  Maximum,
1116     UINT64                  Length,
1117     UINT64                  Granularity,
1118     UINT8                   Flags,
1119     ACPI_PARSE_OBJECT       *MinOp,
1120     ACPI_PARSE_OBJECT       *MaxOp,
1121     ACPI_PARSE_OBJECT       *LengthOp,
1122     ACPI_PARSE_OBJECT       *GranOp,
1123     ACPI_PARSE_OBJECT       *Op);
1124
1125 UINT16
1126 RsGetStringDataLength (
1127     ACPI_PARSE_OBJECT       *InitializerOp);
1128
1129 ASL_RESOURCE_NODE *
1130 RsAllocateResourceNode (
1131     UINT32                  Size);
1132
1133 void
1134 RsCreateResourceField (
1135     ACPI_PARSE_OBJECT       *Op,
1136     char                    *Name,
1137     UINT32                  ByteOffset,
1138     UINT32                  BitOffset,
1139     UINT32                  BitLength);
1140
1141 void
1142 RsSetFlagBits (
1143     UINT8                   *Flags,
1144     ACPI_PARSE_OBJECT       *Op,
1145     UINT8                   Position,
1146     UINT8                   DefaultBit);
1147
1148 void
1149 RsSetFlagBits16 (
1150     UINT16                  *Flags,
1151     ACPI_PARSE_OBJECT       *Op,
1152     UINT8                   Position,
1153     UINT8                   DefaultBit);
1154
1155 ACPI_PARSE_OBJECT *
1156 RsCompleteNodeAndGetNext (
1157     ACPI_PARSE_OBJECT       *Op);
1158
1159 void
1160 RsCheckListForDuplicates (
1161     ACPI_PARSE_OBJECT       *Op);
1162
1163 ASL_RESOURCE_NODE *
1164 RsDoOneResourceDescriptor (
1165     ASL_RESOURCE_INFO       *Info,
1166     UINT8                   *State);
1167
1168 /* Values for State above */
1169
1170 #define ACPI_RSTATE_NORMAL              0
1171 #define ACPI_RSTATE_START_DEPENDENT     1
1172 #define ACPI_RSTATE_DEPENDENT_LIST      2
1173
1174 UINT32
1175 RsLinkDescriptorChain (
1176     ASL_RESOURCE_NODE       **PreviousRnode,
1177     ASL_RESOURCE_NODE       *Rnode);
1178
1179 void
1180 RsDoResourceTemplate (
1181     ACPI_PARSE_OBJECT       *Op);
1182
1183
1184 /*
1185  * aslrestype1 - Miscellaneous Small descriptors
1186  */
1187 ASL_RESOURCE_NODE *
1188 RsDoEndTagDescriptor (
1189     ASL_RESOURCE_INFO       *Info);
1190
1191 ASL_RESOURCE_NODE *
1192 RsDoEndDependentDescriptor (
1193     ASL_RESOURCE_INFO       *Info);
1194
1195 ASL_RESOURCE_NODE *
1196 RsDoMemory24Descriptor (
1197     ASL_RESOURCE_INFO       *Info);
1198
1199 ASL_RESOURCE_NODE *
1200 RsDoMemory32Descriptor (
1201     ASL_RESOURCE_INFO       *Info);
1202
1203 ASL_RESOURCE_NODE *
1204 RsDoMemory32FixedDescriptor (
1205     ASL_RESOURCE_INFO       *Info);
1206
1207 ASL_RESOURCE_NODE *
1208 RsDoStartDependentDescriptor (
1209     ASL_RESOURCE_INFO       *Info);
1210
1211 ASL_RESOURCE_NODE *
1212 RsDoStartDependentNoPriDescriptor (
1213     ASL_RESOURCE_INFO       *Info);
1214
1215 ASL_RESOURCE_NODE *
1216 RsDoVendorSmallDescriptor (
1217     ASL_RESOURCE_INFO       *Info);
1218
1219
1220 /*
1221  * aslrestype1i - I/O-related Small descriptors
1222  */
1223 ASL_RESOURCE_NODE *
1224 RsDoDmaDescriptor (
1225     ASL_RESOURCE_INFO       *Info);
1226
1227 ASL_RESOURCE_NODE *
1228 RsDoFixedDmaDescriptor (
1229     ASL_RESOURCE_INFO       *Info);
1230
1231 ASL_RESOURCE_NODE *
1232 RsDoFixedIoDescriptor (
1233     ASL_RESOURCE_INFO       *Info);
1234
1235 ASL_RESOURCE_NODE *
1236 RsDoIoDescriptor (
1237     ASL_RESOURCE_INFO       *Info);
1238
1239 ASL_RESOURCE_NODE *
1240 RsDoIrqDescriptor (
1241     ASL_RESOURCE_INFO       *Info);
1242
1243 ASL_RESOURCE_NODE *
1244 RsDoIrqNoFlagsDescriptor (
1245     ASL_RESOURCE_INFO       *Info);
1246
1247
1248 /*
1249  * aslrestype2 - Large resource descriptors
1250  */
1251 ASL_RESOURCE_NODE *
1252 RsDoInterruptDescriptor (
1253     ASL_RESOURCE_INFO       *Info);
1254
1255 ASL_RESOURCE_NODE *
1256 RsDoVendorLargeDescriptor (
1257     ASL_RESOURCE_INFO       *Info);
1258
1259 ASL_RESOURCE_NODE *
1260 RsDoGeneralRegisterDescriptor (
1261     ASL_RESOURCE_INFO       *Info);
1262
1263 ASL_RESOURCE_NODE *
1264 RsDoGpioIntDescriptor (
1265     ASL_RESOURCE_INFO       *Info);
1266
1267 ASL_RESOURCE_NODE *
1268 RsDoGpioIoDescriptor (
1269     ASL_RESOURCE_INFO       *Info);
1270
1271 ASL_RESOURCE_NODE *
1272 RsDoI2cSerialBusDescriptor (
1273     ASL_RESOURCE_INFO       *Info);
1274
1275 ASL_RESOURCE_NODE *
1276 RsDoSpiSerialBusDescriptor (
1277     ASL_RESOURCE_INFO       *Info);
1278
1279 ASL_RESOURCE_NODE *
1280 RsDoUartSerialBusDescriptor (
1281     ASL_RESOURCE_INFO       *Info);
1282
1283 /*
1284  * aslrestype2d - DWord address descriptors
1285  */
1286 ASL_RESOURCE_NODE *
1287 RsDoDwordIoDescriptor (
1288     ASL_RESOURCE_INFO       *Info);
1289
1290 ASL_RESOURCE_NODE *
1291 RsDoDwordMemoryDescriptor (
1292     ASL_RESOURCE_INFO       *Info);
1293
1294 ASL_RESOURCE_NODE *
1295 RsDoDwordSpaceDescriptor (
1296     ASL_RESOURCE_INFO       *Info);
1297
1298
1299 /*
1300  * aslrestype2e - Extended address descriptors
1301  */
1302 ASL_RESOURCE_NODE *
1303 RsDoExtendedIoDescriptor (
1304     ASL_RESOURCE_INFO       *Info);
1305
1306 ASL_RESOURCE_NODE *
1307 RsDoExtendedMemoryDescriptor (
1308     ASL_RESOURCE_INFO       *Info);
1309
1310 ASL_RESOURCE_NODE *
1311 RsDoExtendedSpaceDescriptor (
1312     ASL_RESOURCE_INFO       *Info);
1313
1314
1315 /*
1316  * aslrestype2q - QWord address descriptors
1317  */
1318 ASL_RESOURCE_NODE *
1319 RsDoQwordIoDescriptor (
1320     ASL_RESOURCE_INFO       *Info);
1321
1322 ASL_RESOURCE_NODE *
1323 RsDoQwordMemoryDescriptor (
1324     ASL_RESOURCE_INFO       *Info);
1325
1326 ASL_RESOURCE_NODE *
1327 RsDoQwordSpaceDescriptor (
1328     ASL_RESOURCE_INFO       *Info);
1329
1330
1331 /*
1332  * aslrestype2w - Word address descriptors
1333  */
1334 ASL_RESOURCE_NODE *
1335 RsDoWordIoDescriptor (
1336     ASL_RESOURCE_INFO       *Info);
1337
1338 ASL_RESOURCE_NODE *
1339 RsDoWordSpaceDescriptor (
1340     ASL_RESOURCE_INFO       *Info);
1341
1342 ASL_RESOURCE_NODE *
1343 RsDoWordBusNumberDescriptor (
1344     ASL_RESOURCE_INFO       *Info);
1345
1346
1347 /*
1348  * Entry to data table compiler subsystem
1349  */
1350 ACPI_STATUS
1351 DtDoCompile(
1352     void);
1353
1354 ACPI_STATUS
1355 DtCreateTemplates (
1356     char                    **argv);
1357
1358 #endif /*  __ASLCOMPILER_H */