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