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

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