arch/all-pc/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 - 2013, 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
 279 /*
 280  * aslerror - error handling/reporting
 281  */
 282 void
 283 AslError (
 284     UINT8                   Level,
 285     UINT8                   MessageId,
 286     ACPI_PARSE_OBJECT       *Op,
 287     char                    *ExtraMessage);
 288
 289 ACPI_STATUS
 290 AslDisableException (
 291     char                    *MessageIdString);
 292
 293 BOOLEAN
 294 AslIsExceptionDisabled (
 295     UINT8                   Level,
 296     UINT8                   MessageId);
 297
 298 void
 299 AslCoreSubsystemError (
 300     ACPI_PARSE_OBJECT       *Op,
 301     ACPI_STATUS             Status,
 302     char                    *ExtraMessage,
 303     BOOLEAN                 Abort);
 304
 305 int
 306 AslCompilererror(
 307     const char              *s);
 308
 309 void
 310 AslCommonError (
 311     UINT8                   Level,
 312     UINT8                   MessageId,
 313     UINT32                  CurrentLineNumber,
 314     UINT32                  LogicalLineNumber,
 315     UINT32                  LogicalByteOffset,
 316     UINT32                  Column,
 317     char                    *Filename,
 318     char                    *ExtraMessage);
 319
 320 void
 321 AslCommonError2 (
 322     UINT8                   Level,
 323     UINT8                   MessageId,
 324     UINT32                  LineNumber,
 325     UINT32                  Column,
 326     char                    *SourceLine,
 327     char                    *Filename,
 328     char                    *ExtraMessage);
 329
 330 void
 331 AePrintException (
 332     UINT32                  FileId,
 333     ASL_ERROR_MSG           *Enode,
 334     char                    *Header);
 335
 336 void
 337 AePrintErrorLog (
 338     UINT32                  FileId);
 339
 340 void
 341 AeClearErrorLog (
 342     void);
 343
 344 ACPI_PHYSICAL_ADDRESS
 345 AeLocalGetRootPointer (
 346     void);
 347
 348
 349 /*
 350  * asllisting - generate all "listing" type files
 351  */
 352 void
 353 LsDoListings (
 354     void);
 355
 356 void
 357 LsWriteNodeToAsmListing (
 358     ACPI_PARSE_OBJECT       *Op);
 359
 360 void
 361 LsWriteNode (
 362     ACPI_PARSE_OBJECT       *Op,
 363     UINT32                  FileId);
 364
 365 void
 366 LsDumpParseTree (
 367     void);
 368
 369
 370 /*
 371  * asllistsup - Listing file support utilities
 372  */
 373 void
 374 LsDumpAscii (
 375     UINT32                  FileId,
 376     UINT32                  Count,
 377     UINT8                   *Buffer);
 378
 379 void
 380 LsDumpAsciiInComment (
 381     UINT32                  FileId,
 382     UINT32                  Count,
 383     UINT8                   *Buffer);
 384
 385 void
 386 LsCheckException (
 387     UINT32                  LineNumber,
 388     UINT32                  FileId);
 389
 390 void
 391 LsFlushListingBuffer (
 392     UINT32                  FileId);
 393
 394 void
 395 LsWriteListingHexBytes (
 396     UINT8                   *Buffer,
 397     UINT32                  Length,
 398     UINT32                  FileId);
 399
 400 void
 401 LsWriteSourceLines (
 402     UINT32                  ToLineNumber,
 403     UINT32                  ToLogicalLineNumber,
 404     UINT32                  FileId);
 405
 406 UINT32
 407 LsWriteOneSourceLine (
 408     UINT32                  FileId);
 409
 410 void
 411 LsPushNode (
 412     char                    *Filename);
 413
 414 ASL_LISTING_NODE *
 415 LsPopNode (
 416     void);
 417
 418
 419 /*
 420  * aslhex - generate all "hex" output files (C, ASM, ASL)
 421  */
 422 void
 423 HxDoHexOutput (
 424     void);
 425
 426
 427 /*
 428  * aslfold - constant folding
 429  */
 430 ACPI_STATUS
 431 OpcAmlConstantWalk (
 432     ACPI_PARSE_OBJECT       *Op,
 433     UINT32                  Level,
 434     void                    *Context);
 435
 436
 437 /*
 438  * asloffset - generate C offset file for BIOS support
 439  */
 440 ACPI_STATUS
 441 LsAmlOffsetWalk (
 442     ACPI_PARSE_OBJECT       *Op,
 443     UINT32                  Level,
 444     void                    *Context);
 445
 446 void
 447 LsDoOffsetTableHeader (
 448     UINT32                  FileId);
 449
 450 void
 451 LsDoOffsetTableFooter (
 452     UINT32                  FileId);
 453
 454
 455 /*
 456  * aslopcodes - generate AML opcodes
 457  */
 458 ACPI_STATUS
 459 OpcAmlOpcodeWalk (
 460     ACPI_PARSE_OBJECT       *Op,
 461     UINT32                  Level,
 462     void                    *Context);
 463
 464 ACPI_STATUS
 465 OpcAmlOpcodeUpdateWalk (
 466     ACPI_PARSE_OBJECT       *Op,
 467     UINT32                  Level,
 468     void                    *Context);
 469
 470 void
 471 OpcGenerateAmlOpcode (
 472     ACPI_PARSE_OBJECT       *Op);
 473
 474 UINT32
 475 OpcSetOptimalIntegerSize (
 476     ACPI_PARSE_OBJECT       *Op);
 477
 478 void
 479 OpcGetIntegerWidth (
 480     ACPI_PARSE_OBJECT       *Op);
 481
 482
 483 /*
 484  * asloperands - generate AML operands for the AML opcodes
 485  */
 486 ACPI_PARSE_OBJECT  *
 487 UtGetArg (
 488     ACPI_PARSE_OBJECT       *Op,
 489     UINT32                  Argn);
 490
 491 void
 492 OpnGenerateAmlOperands (
 493     ACPI_PARSE_OBJECT       *Op);
 494
 495 void
 496 OpnDoPackage (
 497     ACPI_PARSE_OBJECT       *Op);
 498
 499
 500 /*
 501  * aslopt - optmization
 502  */
 503 void
 504 OptOptimizeNamePath (
 505     ACPI_PARSE_OBJECT       *Op,
 506     UINT32                  Flags,
 507     ACPI_WALK_STATE         *WalkState,
 508     char                    *AmlNameString,
 509     ACPI_NAMESPACE_NODE     *TargetNode);
 510
 511
 512 /*
 513  * aslcodegen - code generation
 514  */
 515 void
 516 CgGenerateAmlOutput (
 517     void);
 518
 519
 520 /*
 521  * aslfile
 522  */
 523 void
 524 FlOpenFile (
 525     UINT32                  FileId,
 526     char                    *Filename,
 527     char                    *Mode);
 528
 529
 530 /*
 531  * asllength - calculate/adjust AML package lengths
 532  */
 533 ACPI_STATUS
 534 LnPackageLengthWalk (
 535     ACPI_PARSE_OBJECT       *Op,
 536     UINT32                  Level,
 537     void                    *Context);
 538
 539 ACPI_STATUS
 540 LnInitLengthsWalk (
 541     ACPI_PARSE_OBJECT       *Op,
 542     UINT32                  Level,
 543     void                    *Context);
 544
 545 void
 546 CgGenerateAmlLengths (
 547     ACPI_PARSE_OBJECT       *Op);
 548
 549
 550 /*
 551  * aslmap - opcode mappings and reserved method names
 552  */
 553 ACPI_OBJECT_TYPE
 554 AslMapNamedOpcodeToDataType (
 555     UINT16                  Opcode);
 556
 557
 558 /*
 559  * aslpredef - ACPI predefined names support
 560  */
 561 BOOLEAN
 562 ApCheckForPredefinedMethod (
 563     ACPI_PARSE_OBJECT       *Op,
 564     ASL_METHOD_INFO         *MethodInfo);
 565
 566 void
 567 ApCheckPredefinedReturnValue (
 568     ACPI_PARSE_OBJECT       *Op,
 569     ASL_METHOD_INFO         *MethodInfo);
 570
 571 UINT32
 572 ApCheckForPredefinedName (
 573     ACPI_PARSE_OBJECT       *Op,
 574     char                    *Name);
 575
 576 void
 577 ApCheckForPredefinedObject (
 578     ACPI_PARSE_OBJECT       *Op,
 579     char                    *Name);
 580
 581 ACPI_STATUS
 582 ApCheckObjectType (
 583     const char              *PredefinedName,
 584     ACPI_PARSE_OBJECT       *Op,
 585     UINT32                  ExpectedBtypes,
 586     UINT32                  PackageIndex);
 587
 588 void
 589 ApDisplayReservedNames (
 590     void);
 591
 592
 593 /*
 594  * aslprepkg - ACPI predefined names support for packages
 595  */
 596 void
 597 ApCheckPackage (
 598     ACPI_PARSE_OBJECT           *ParentOp,
 599     const ACPI_PREDEFINED_INFO  *Predefined);
 600
 601
 602 /*
 603  * asltransform - parse tree transformations
 604  */
 605 ACPI_STATUS
 606 TrAmlTransformWalk (
 607     ACPI_PARSE_OBJECT       *Op,
 608     UINT32                  Level,
 609     void                    *Context);
 610
 611
 612 /*
 613  * asltree - parse tree support
 614  */
 615 ACPI_STATUS
 616 TrWalkParseTree (
 617     ACPI_PARSE_OBJECT       *Op,
 618     UINT32                  Visitation,
 619     ASL_WALK_CALLBACK       DescendingCallback,
 620     ASL_WALK_CALLBACK       AscendingCallback,
 621     void                    *Context);
 622
 623 /* Values for "Visitation" parameter above */
 624
 625 #define ASL_WALK_VISIT_DOWNWARD     0x01
 626 #define ASL_WALK_VISIT_UPWARD       0x02
 627 #define ASL_WALK_VISIT_TWICE        (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
 628
 629
 630 ACPI_PARSE_OBJECT *
 631 TrAllocateNode (
 632     UINT32                  ParseOpcode);
 633
 634 void
 635 TrReleaseNode (
 636     ACPI_PARSE_OBJECT       *Op);
 637
 638 ACPI_PARSE_OBJECT *
 639 TrUpdateNode (
 640     UINT32                  ParseOpcode,
 641     ACPI_PARSE_OBJECT       *Op);
 642
 643 ACPI_PARSE_OBJECT *
 644 TrCreateNode (
 645     UINT32                  ParseOpcode,
 646     UINT32                  NumChildren,
 647     ...);
 648
 649 ACPI_PARSE_OBJECT *
 650 TrCreateLeafNode (
 651     UINT32                  ParseOpcode);
 652
 653 ACPI_PARSE_OBJECT *
 654 TrCreateValuedLeafNode (
 655     UINT32                  ParseOpcode,
 656     UINT64                  Value);
 657
 658 ACPI_PARSE_OBJECT *
 659 TrCreateConstantLeafNode (
 660     UINT32                  ParseOpcode);
 661
 662 ACPI_PARSE_OBJECT *
 663 TrLinkChildren (
 664     ACPI_PARSE_OBJECT       *Op,
 665     UINT32                  NumChildren,
 666     ...);
 667
 668 void
 669 TrSetEndLineNumber (
 670     ACPI_PARSE_OBJECT       *Op);
 671
 672 void
 673 TrWalkTree (
 674     void);
 675
 676 ACPI_PARSE_OBJECT *
 677 TrLinkPeerNode (
 678     ACPI_PARSE_OBJECT       *Op1,
 679     ACPI_PARSE_OBJECT       *Op2);
 680
 681 ACPI_PARSE_OBJECT *
 682 TrLinkChildNode (
 683     ACPI_PARSE_OBJECT       *Op1,
 684     ACPI_PARSE_OBJECT       *Op2);
 685
 686 ACPI_PARSE_OBJECT *
 687 TrSetNodeFlags (
 688     ACPI_PARSE_OBJECT       *Op,
 689     UINT32                  Flags);
 690
 691 ACPI_PARSE_OBJECT *
 692 TrSetNodeAmlLength (
 693     ACPI_PARSE_OBJECT       *Op,
 694     UINT32                  Length);
 695
 696 ACPI_PARSE_OBJECT *
 697 TrLinkPeerNodes (
 698     UINT32                  NumPeers,
 699     ...);
 700
 701
 702 /*
 703  * aslfiles - File I/O support
 704  */
 705 void
 706 AslAbort (
 707     void);
 708
 709 void
 710 FlAddIncludeDirectory (
 711     char                    *Dir);
 712
 713 char *
 714 FlMergePathnames (
 715     char                    *PrefixDir,
 716     char                    *FilePathname);
 717
 718 void
 719 FlOpenIncludeFile (
 720     ACPI_PARSE_OBJECT       *Op);
 721
 722 void
 723 FlFileError (
 724     UINT32                  FileId,
 725     UINT8                   ErrorId);
 726
 727 UINT32
 728 FlGetFileSize (
 729     UINT32                  FileId);
 730
 731 ACPI_STATUS
 732 FlReadFile (
 733     UINT32                  FileId,
 734     void                    *Buffer,
 735     UINT32                  Length);
 736
 737 void
 738 FlWriteFile (
 739     UINT32                  FileId,
 740     void                    *Buffer,
 741     UINT32                  Length);
 742
 743 void
 744 FlSeekFile (
 745     UINT32                  FileId,
 746     long                    Offset);
 747
 748 void
 749 FlCloseFile (
 750     UINT32                  FileId);
 751
 752 void
 753 FlPrintFile (
 754     UINT32                  FileId,
 755     char                    *Format,
 756     ...);
 757
 758 void
 759 FlDeleteFile (
 760     UINT32                  FileId);
 761
 762 void
 763 FlSetLineNumber (
 764     UINT32                  LineNumber);
 765
 766 void
 767 FlSetFilename (
 768     char                    *Filename);
 769
 770 ACPI_STATUS
 771 FlOpenInputFile (
 772     char                    *InputFilename);
 773
 774 ACPI_STATUS
 775 FlOpenAmlOutputFile (
 776     char                    *InputFilename);
 777
 778 ACPI_STATUS
 779 FlOpenMiscOutputFiles (
 780     char                    *InputFilename);
 781
 782
 783 /*
 784  * asload - load namespace in prep for cross reference
 785  */
 786 ACPI_STATUS
 787 LdLoadNamespace (
 788     ACPI_PARSE_OBJECT       *RootOp);
 789
 790
 791 /*
 792  * asllookup - namespace lookup functions
 793  */
 794 void
 795 LkFindUnreferencedObjects (
 796     void);
 797
 798 /*
 799  * aslmain - startup
 800  */
 801 void
 802 Usage (
 803     void);
 804
 805 void
 806 AslFilenameHelp (
 807     void);
 808
 809
 810 /*
 811  * aslnamesp - namespace output file generation
 812  */
 813 ACPI_STATUS
 814 NsDisplayNamespace (
 815     void);
 816
 817 void
 818 NsSetupNamespaceListing (
 819     void                    *Handle);
 820
 821 /*
 822  * asloptions - command line processing
 823  */
 824 int
 825 AslCommandLine (
 826     int                     argc,
 827     char                    **argv);
 828
 829 /*
 830  * aslxref - namespace cross reference
 831  */
 832 ACPI_STATUS
 833 XfCrossReferenceNamespace (
 834     void);
 835
 836
 837 /*
 838  * aslutils - common compiler utilites
 839  */
 840 void
 841 DbgPrint (
 842     UINT32                  Type,
 843     char                    *Format,
 844     ...);
 845
 846 /* Type values for above */
 847
 848 #define ASL_DEBUG_OUTPUT    0
 849 #define ASL_PARSE_OUTPUT    1
 850 #define ASL_TREE_OUTPUT     2
 851
 852 void
 853 UtDisplaySupportedTables (
 854     void);
 855
 856 void
 857 UtDisplayConstantOpcodes (
 858     void);
 859
 860 UINT8
 861 UtBeginEvent (
 862     char                    *Name);
 863
 864 void
 865 UtEndEvent (
 866     UINT8                   Event);
 867
 868 void *
 869 UtLocalCalloc (
 870     UINT32                  Size);
 871
 872 void
 873 UtPrintFormattedName (
 874     UINT16                  ParseOpcode,
 875     UINT32                  Level);
 876
 877 void
 878 UtDisplaySummary (
 879     UINT32                  FileId);
 880
 881 UINT8
 882 UtHexCharToValue (
 883     int                     HexChar);
 884
 885 void
 886 UtConvertByteToHex (
 887     UINT8                   RawByte,
 888     UINT8                   *Buffer);
 889
 890 void
 891 UtConvertByteToAsmHex (
 892     UINT8                   RawByte,
 893     UINT8                   *Buffer);
 894
 895 char *
 896 UtGetOpName (
 897     UINT32                  ParseOpcode);
 898
 899 void
 900 UtSetParseOpName (
 901     ACPI_PARSE_OBJECT       *Op);
 902
 903 char *
 904 UtGetStringBuffer (
 905     UINT32                  Length);
 906
 907 void
 908 UtExpandLineBuffers (
 909     void);
 910
 911 ACPI_STATUS
 912 UtInternalizeName (
 913     char                    *ExternalName,
 914     char                    **ConvertedName);
 915
 916 void
 917 UtAttachNamepathToOwner (
 918     ACPI_PARSE_OBJECT       *Op,
 919     ACPI_PARSE_OBJECT       *NameNode);
 920
 921 ACPI_PARSE_OBJECT *
 922 UtCheckIntegerRange (
 923     ACPI_PARSE_OBJECT       *Op,
 924     UINT32                  LowValue,
 925     UINT32                  HighValue);
 926
 927 UINT64
 928 UtDoConstant (
 929     char                    *String);
 930
 931 ACPI_STATUS
 932 UtStrtoul64 (
 933     char                    *String,
 934     UINT32                  Base,
 935     UINT64                  *RetInteger);
 936
 937
 938 /*
 939  * asluuid - UUID support
 940  */
 941 ACPI_STATUS
 942 AuValidateUuid (
 943     char                    *InString);
 944
 945 ACPI_STATUS
 946 AuConvertStringToUuid (
 947     char                    *InString,
 948     char                    *UuIdBuffer);
 949
 950 ACPI_STATUS
 951 AuConvertUuidToString (
 952     char                    *UuIdBuffer,
 953     char                    *OutString);
 954
 955 /*
 956  * aslresource - Resource template generation utilities
 957  */
 958 void
 959 RsSmallAddressCheck (
 960     UINT8                   Type,
 961     UINT32                  Minimum,
 962     UINT32                  Maximum,
 963     UINT32                  Length,
 964     UINT32                  Alignment,
 965     ACPI_PARSE_OBJECT       *MinOp,
 966     ACPI_PARSE_OBJECT       *MaxOp,
 967     ACPI_PARSE_OBJECT       *LengthOp,
 968     ACPI_PARSE_OBJECT       *AlignOp,
 969     ACPI_PARSE_OBJECT       *Op);
 970
 971 void
 972 RsLargeAddressCheck (
 973     UINT64                  Minimum,
 974     UINT64                  Maximum,
 975     UINT64                  Length,
 976     UINT64                  Granularity,
 977     UINT8                   Flags,
 978     ACPI_PARSE_OBJECT       *MinOp,
 979     ACPI_PARSE_OBJECT       *MaxOp,
 980     ACPI_PARSE_OBJECT       *LengthOp,
 981     ACPI_PARSE_OBJECT       *GranOp,
 982     ACPI_PARSE_OBJECT       *Op);
 983
 984 UINT16
 985 RsGetStringDataLength (
 986     ACPI_PARSE_OBJECT       *InitializerOp);
 987
 988 ASL_RESOURCE_NODE *
 989 RsAllocateResourceNode (
 990     UINT32                  Size);
 991
 992 void
 993 RsCreateResourceField (
 994     ACPI_PARSE_OBJECT       *Op,
 995     char                    *Name,
 996     UINT32                  ByteOffset,
 997     UINT32                  BitOffset,
 998     UINT32                  BitLength);
 999
1000 void
1001 RsSetFlagBits (
1002     UINT8                   *Flags,
1003     ACPI_PARSE_OBJECT       *Op,
1004     UINT8                   Position,
1005     UINT8                   DefaultBit);
1006
1007 void
1008 RsSetFlagBits16 (
1009     UINT16                  *Flags,
1010     ACPI_PARSE_OBJECT       *Op,
1011     UINT8                   Position,
1012     UINT8                   DefaultBit);
1013
1014 ACPI_PARSE_OBJECT *
1015 RsCompleteNodeAndGetNext (
1016     ACPI_PARSE_OBJECT       *Op);
1017
1018 void
1019 RsCheckListForDuplicates (
1020     ACPI_PARSE_OBJECT       *Op);
1021
1022 ASL_RESOURCE_NODE *
1023 RsDoOneResourceDescriptor (
1024     ACPI_PARSE_OBJECT       *DescriptorTypeOp,
1025     UINT32                  CurrentByteOffset,
1026     UINT8                   *State);
1027
1028 /* Values for State above */
1029
1030 #define ACPI_RSTATE_NORMAL              0
1031 #define ACPI_RSTATE_START_DEPENDENT     1
1032 #define ACPI_RSTATE_DEPENDENT_LIST      2
1033
1034 UINT32
1035 RsLinkDescriptorChain (
1036     ASL_RESOURCE_NODE       **PreviousRnode,
1037     ASL_RESOURCE_NODE       *Rnode);
1038
1039 void
1040 RsDoResourceTemplate (
1041     ACPI_PARSE_OBJECT       *Op);
1042
1043
1044 /*
1045  * aslrestype1 - Miscellaneous Small descriptors
1046  */
1047 ASL_RESOURCE_NODE *
1048 RsDoEndTagDescriptor (
1049     ACPI_PARSE_OBJECT       *Op,
1050     UINT32                  CurrentByteOffset);
1051
1052 ASL_RESOURCE_NODE *
1053 RsDoEndDependentDescriptor (
1054     ACPI_PARSE_OBJECT       *Op,
1055     UINT32                  CurrentByteOffset);
1056
1057 ASL_RESOURCE_NODE *
1058 RsDoMemory24Descriptor (
1059     ACPI_PARSE_OBJECT       *Op,
1060     UINT32                  CurrentByteOffset);
1061
1062 ASL_RESOURCE_NODE *
1063 RsDoMemory32Descriptor (
1064     ACPI_PARSE_OBJECT       *Op,
1065     UINT32                  CurrentByteOffset);
1066
1067 ASL_RESOURCE_NODE *
1068 RsDoMemory32FixedDescriptor (
1069     ACPI_PARSE_OBJECT       *Op,
1070     UINT32                  CurrentByteOffset);
1071
1072 ASL_RESOURCE_NODE *
1073 RsDoStartDependentDescriptor (
1074     ACPI_PARSE_OBJECT       *Op,
1075     UINT32                  CurrentByteOffset);
1076
1077 ASL_RESOURCE_NODE *
1078 RsDoStartDependentNoPriDescriptor (
1079     ACPI_PARSE_OBJECT       *Op,
1080     UINT32                  CurrentByteOffset);
1081
1082 ASL_RESOURCE_NODE *
1083 RsDoVendorSmallDescriptor (
1084     ACPI_PARSE_OBJECT       *Op,
1085     UINT32                  CurrentByteOffset);
1086
1087
1088 /*
1089  * aslrestype1i - I/O-related Small descriptors
1090  */
1091 ASL_RESOURCE_NODE *
1092 RsDoDmaDescriptor (
1093     ACPI_PARSE_OBJECT       *Op,
1094     UINT32                  CurrentByteOffset);
1095
1096 ASL_RESOURCE_NODE *
1097 RsDoFixedDmaDescriptor (
1098     ACPI_PARSE_OBJECT       *Op,
1099     UINT32                  CurrentByteOffset);
1100
1101 ASL_RESOURCE_NODE *
1102 RsDoFixedIoDescriptor (
1103     ACPI_PARSE_OBJECT       *Op,
1104     UINT32                  CurrentByteOffset);
1105
1106 ASL_RESOURCE_NODE *
1107 RsDoIoDescriptor (
1108     ACPI_PARSE_OBJECT       *Op,
1109     UINT32                  CurrentByteOffset);
1110
1111 ASL_RESOURCE_NODE *
1112 RsDoIrqDescriptor (
1113     ACPI_PARSE_OBJECT       *Op,
1114     UINT32                  CurrentByteOffset);
1115
1116 ASL_RESOURCE_NODE *
1117 RsDoIrqNoFlagsDescriptor (
1118     ACPI_PARSE_OBJECT       *Op,
1119     UINT32                  CurrentByteOffset);
1120
1121
1122 /*
1123  * aslrestype2 - Large resource descriptors
1124  */
1125 ASL_RESOURCE_NODE *
1126 RsDoInterruptDescriptor (
1127     ACPI_PARSE_OBJECT       *Op,
1128     UINT32                  CurrentByteOffset);
1129
1130 ASL_RESOURCE_NODE *
1131 RsDoVendorLargeDescriptor (
1132     ACPI_PARSE_OBJECT       *Op,
1133     UINT32                  CurrentByteOffset);
1134
1135 ASL_RESOURCE_NODE *
1136 RsDoGeneralRegisterDescriptor (
1137     ACPI_PARSE_OBJECT       *Op,
1138     UINT32                  CurrentByteOffset);
1139
1140 ASL_RESOURCE_NODE *
1141 RsDoGpioIntDescriptor (
1142     ACPI_PARSE_OBJECT       *Op,
1143     UINT32                  CurrentByteOffset);
1144
1145 ASL_RESOURCE_NODE *
1146 RsDoGpioIoDescriptor (
1147     ACPI_PARSE_OBJECT       *Op,
1148     UINT32                  CurrentByteOffset);
1149
1150 ASL_RESOURCE_NODE *
1151 RsDoI2cSerialBusDescriptor (
1152     ACPI_PARSE_OBJECT       *Op,
1153     UINT32                  CurrentByteOffset);
1154
1155 ASL_RESOURCE_NODE *
1156 RsDoSpiSerialBusDescriptor (
1157     ACPI_PARSE_OBJECT       *Op,
1158     UINT32                  CurrentByteOffset);
1159
1160 ASL_RESOURCE_NODE *
1161 RsDoUartSerialBusDescriptor (
1162     ACPI_PARSE_OBJECT       *Op,
1163     UINT32                  CurrentByteOffset);
1164
1165 /*
1166  * aslrestype2d - DWord address descriptors
1167  */
1168 ASL_RESOURCE_NODE *
1169 RsDoDwordIoDescriptor (
1170     ACPI_PARSE_OBJECT       *Op,
1171     UINT32                  CurrentByteOffset);
1172
1173 ASL_RESOURCE_NODE *
1174 RsDoDwordMemoryDescriptor (
1175     ACPI_PARSE_OBJECT       *Op,
1176     UINT32                  CurrentByteOffset);
1177
1178 ASL_RESOURCE_NODE *
1179 RsDoDwordSpaceDescriptor (
1180     ACPI_PARSE_OBJECT       *Op,
1181     UINT32                  CurrentByteOffset);
1182
1183
1184 /*
1185  * aslrestype2e - Extended address descriptors
1186  */
1187 ASL_RESOURCE_NODE *
1188 RsDoExtendedIoDescriptor (
1189     ACPI_PARSE_OBJECT       *Op,
1190     UINT32                  CurrentByteOffset);
1191
1192 ASL_RESOURCE_NODE *
1193 RsDoExtendedMemoryDescriptor (
1194     ACPI_PARSE_OBJECT       *Op,
1195     UINT32                  CurrentByteOffset);
1196
1197 ASL_RESOURCE_NODE *
1198 RsDoExtendedSpaceDescriptor (
1199     ACPI_PARSE_OBJECT       *Op,
1200     UINT32                  CurrentByteOffset);
1201
1202
1203 /*
1204  * aslrestype2q - QWord address descriptors
1205  */
1206 ASL_RESOURCE_NODE *
1207 RsDoQwordIoDescriptor (
1208     ACPI_PARSE_OBJECT       *Op,
1209     UINT32                  CurrentByteOffset);
1210
1211 ASL_RESOURCE_NODE *
1212 RsDoQwordMemoryDescriptor (
1213     ACPI_PARSE_OBJECT       *Op,
1214     UINT32                  CurrentByteOffset);
1215
1216 ASL_RESOURCE_NODE *
1217 RsDoQwordSpaceDescriptor (
1218     ACPI_PARSE_OBJECT       *Op,
1219     UINT32                  CurrentByteOffset);
1220
1221
1222 /*
1223  * aslrestype2w - Word address descriptors
1224  */
1225 ASL_RESOURCE_NODE *
1226 RsDoWordIoDescriptor (
1227     ACPI_PARSE_OBJECT       *Op,
1228     UINT32                  CurrentByteOffset);
1229
1230 ASL_RESOURCE_NODE *
1231 RsDoWordSpaceDescriptor (
1232     ACPI_PARSE_OBJECT       *Op,
1233     UINT32                  CurrentByteOffset);
1234
1235 ASL_RESOURCE_NODE *
1236 RsDoWordBusNumberDescriptor (
1237     ACPI_PARSE_OBJECT       *Op,
1238     UINT32                  CurrentByteOffset);
1239
1240 /*
1241  * Entry to data table compiler subsystem
1242  */
1243 ACPI_STATUS
1244 DtDoCompile(
1245     void);
1246
1247 ACPI_STATUS
1248 DtCreateTemplates (
1249     char                    *Signature);
1250
1251 #endif /*  __ASLCOMPILER_H */