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