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

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