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 - 2015, 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  * aslprintf - Printf/Fprintf macros
 547  */
 548 void
 549 OpcDoPrintf (
 550     ACPI_PARSE_OBJECT       *Op);
 551
 552 void
 553 OpcDoFprintf (
 554     ACPI_PARSE_OBJECT       *Op);
 555
 556
 557 /*
 558  * aslprune - parse tree pruner
 559  */
 560 void
 561 AslPruneParseTree (
 562     UINT32                  PruneDepth,
 563     UINT32                  Type);
 564
 565
 566 /*
 567  * aslcodegen - code generation
 568  */
 569 void
 570 CgGenerateAmlOutput (
 571     void);
 572
 573
 574 /*
 575  * aslfile
 576  */
 577 void
 578 FlOpenFile (
 579     UINT32                  FileId,
 580     char                    *Filename,
 581     char                    *Mode);
 582
 583
 584 /*
 585  * asllength - calculate/adjust AML package lengths
 586  */
 587 ACPI_STATUS
 588 LnPackageLengthWalk (
 589     ACPI_PARSE_OBJECT       *Op,
 590     UINT32                  Level,
 591     void                    *Context);
 592
 593 ACPI_STATUS
 594 LnInitLengthsWalk (
 595     ACPI_PARSE_OBJECT       *Op,
 596     UINT32                  Level,
 597     void                    *Context);
 598
 599 void
 600 CgGenerateAmlLengths (
 601     ACPI_PARSE_OBJECT       *Op);
 602
 603
 604 /*
 605  * aslmap - opcode mappings and reserved method names
 606  */
 607 ACPI_OBJECT_TYPE
 608 AslMapNamedOpcodeToDataType (
 609     UINT16                  Opcode);
 610
 611
 612 /*
 613  * aslpredef - ACPI predefined names support
 614  */
 615 BOOLEAN
 616 ApCheckForPredefinedMethod (
 617     ACPI_PARSE_OBJECT       *Op,
 618     ASL_METHOD_INFO         *MethodInfo);
 619
 620 void
 621 ApCheckPredefinedReturnValue (
 622     ACPI_PARSE_OBJECT       *Op,
 623     ASL_METHOD_INFO         *MethodInfo);
 624
 625 UINT32
 626 ApCheckForPredefinedName (
 627     ACPI_PARSE_OBJECT       *Op,
 628     char                    *Name);
 629
 630 void
 631 ApCheckForPredefinedObject (
 632     ACPI_PARSE_OBJECT       *Op,
 633     char                    *Name);
 634
 635 ACPI_STATUS
 636 ApCheckObjectType (
 637     const char              *PredefinedName,
 638     ACPI_PARSE_OBJECT       *Op,
 639     UINT32                  ExpectedBtypes,
 640     UINT32                  PackageIndex);
 641
 642 void
 643 ApDisplayReservedNames (
 644     void);
 645
 646
 647 /*
 648  * aslprepkg - ACPI predefined names support for packages
 649  */
 650 void
 651 ApCheckPackage (
 652     ACPI_PARSE_OBJECT           *ParentOp,
 653     const ACPI_PREDEFINED_INFO  *Predefined);
 654
 655
 656 /*
 657  * asltransform - parse tree transformations
 658  */
 659 ACPI_STATUS
 660 TrAmlTransformWalk (
 661     ACPI_PARSE_OBJECT       *Op,
 662     UINT32                  Level,
 663     void                    *Context);
 664
 665
 666 /*
 667  * asltree - parse tree support
 668  */
 669 ACPI_STATUS
 670 TrWalkParseTree (
 671     ACPI_PARSE_OBJECT       *Op,
 672     UINT32                  Visitation,
 673     ASL_WALK_CALLBACK       DescendingCallback,
 674     ASL_WALK_CALLBACK       AscendingCallback,
 675     void                    *Context);
 676
 677 /* Values for "Visitation" parameter above */
 678
 679 #define ASL_WALK_VISIT_DOWNWARD     0x01
 680 #define ASL_WALK_VISIT_UPWARD       0x02
 681 #define ASL_WALK_VISIT_TWICE        (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
 682
 683
 684 ACPI_PARSE_OBJECT *
 685 TrAllocateNode (
 686     UINT32                  ParseOpcode);
 687
 688 void
 689 TrReleaseNode (
 690     ACPI_PARSE_OBJECT       *Op);
 691
 692 ACPI_PARSE_OBJECT *
 693 TrUpdateNode (
 694     UINT32                  ParseOpcode,
 695     ACPI_PARSE_OBJECT       *Op);
 696
 697 ACPI_PARSE_OBJECT *
 698 TrCreateNode (
 699     UINT32                  ParseOpcode,
 700     UINT32                  NumChildren,
 701     ...);
 702
 703 ACPI_PARSE_OBJECT *
 704 TrCreateLeafNode (
 705     UINT32                  ParseOpcode);
 706
 707 ACPI_PARSE_OBJECT *
 708 TrCreateAssignmentNode (
 709     ACPI_PARSE_OBJECT       *Target,
 710     ACPI_PARSE_OBJECT       *Source);
 711
 712 ACPI_PARSE_OBJECT *
 713 TrCreateTargetOperand (
 714     ACPI_PARSE_OBJECT       *OriginalOp,
 715     ACPI_PARSE_OBJECT       *ParentOp);
 716
 717 ACPI_PARSE_OBJECT *
 718 TrCreateValuedLeafNode (
 719     UINT32                  ParseOpcode,
 720     UINT64                  Value);
 721
 722 ACPI_PARSE_OBJECT *
 723 TrCreateConstantLeafNode (
 724     UINT32                  ParseOpcode);
 725
 726 ACPI_PARSE_OBJECT *
 727 TrLinkChildren (
 728     ACPI_PARSE_OBJECT       *Op,
 729     UINT32                  NumChildren,
 730     ...);
 731
 732 void
 733 TrSetEndLineNumber (
 734     ACPI_PARSE_OBJECT       *Op);
 735
 736 void
 737 TrWalkTree (
 738     void);
 739
 740 ACPI_PARSE_OBJECT *
 741 TrLinkPeerNode (
 742     ACPI_PARSE_OBJECT       *Op1,
 743     ACPI_PARSE_OBJECT       *Op2);
 744
 745 ACPI_PARSE_OBJECT *
 746 TrLinkChildNode (
 747     ACPI_PARSE_OBJECT       *Op1,
 748     ACPI_PARSE_OBJECT       *Op2);
 749
 750 ACPI_PARSE_OBJECT *
 751 TrSetNodeFlags (
 752     ACPI_PARSE_OBJECT       *Op,
 753     UINT32                  Flags);
 754
 755 ACPI_PARSE_OBJECT *
 756 TrSetNodeAmlLength (
 757     ACPI_PARSE_OBJECT       *Op,
 758     UINT32                  Length);
 759
 760 ACPI_PARSE_OBJECT *
 761 TrLinkPeerNodes (
 762     UINT32                  NumPeers,
 763     ...);
 764
 765
 766 /*
 767  * aslfiles - File I/O support
 768  */
 769 void
 770 FlAddIncludeDirectory (
 771     char                    *Dir);
 772
 773 char *
 774 FlMergePathnames (
 775     char                    *PrefixDir,
 776     char                    *FilePathname);
 777
 778 void
 779 FlOpenIncludeFile (
 780     ACPI_PARSE_OBJECT       *Op);
 781
 782 void
 783 FlFileError (
 784     UINT32                  FileId,
 785     UINT8                   ErrorId);
 786
 787 UINT32
 788 FlGetFileSize (
 789     UINT32                  FileId);
 790
 791 ACPI_STATUS
 792 FlReadFile (
 793     UINT32                  FileId,
 794     void                    *Buffer,
 795     UINT32                  Length);
 796
 797 void
 798 FlWriteFile (
 799     UINT32                  FileId,
 800     void                    *Buffer,
 801     UINT32                  Length);
 802
 803 void
 804 FlSeekFile (
 805     UINT32                  FileId,
 806     long                    Offset);
 807
 808 void
 809 FlCloseFile (
 810     UINT32                  FileId);
 811
 812 void
 813 FlPrintFile (
 814     UINT32                  FileId,
 815     char                    *Format,
 816     ...);
 817
 818 void
 819 FlDeleteFile (
 820     UINT32                  FileId);
 821
 822 void
 823 FlSetLineNumber (
 824     UINT32                  LineNumber);
 825
 826 void
 827 FlSetFilename (
 828     char                    *Filename);
 829
 830 ACPI_STATUS
 831 FlOpenInputFile (
 832     char                    *InputFilename);
 833
 834 ACPI_STATUS
 835 FlOpenAmlOutputFile (
 836     char                    *InputFilename);
 837
 838 ACPI_STATUS
 839 FlOpenMiscOutputFiles (
 840     char                    *InputFilename);
 841
 842 /*
 843  * aslhwmap - hardware map summary
 844  */
 845 void
 846 MpEmitMappingInfo (
 847     void);
 848
 849
 850 /*
 851  * asload - load namespace in prep for cross reference
 852  */
 853 ACPI_STATUS
 854 LdLoadNamespace (
 855     ACPI_PARSE_OBJECT       *RootOp);
 856
 857
 858 /*
 859  * asllookup - namespace lookup functions
 860  */
 861 void
 862 LkFindUnreferencedObjects (
 863     void);
 864
 865 /*
 866  * aslmain - startup
 867  */
 868 void
 869 Usage (
 870     void);
 871
 872 void
 873 AslFilenameHelp (
 874     void);
 875
 876
 877 /*
 878  * aslnamesp - namespace output file generation
 879  */
 880 ACPI_STATUS
 881 NsDisplayNamespace (
 882     void);
 883
 884 void
 885 NsSetupNamespaceListing (
 886     void                    *Handle);
 887
 888 /*
 889  * asloptions - command line processing
 890  */
 891 int
 892 AslCommandLine (
 893     int                     argc,
 894     char                    **argv);
 895
 896 /*
 897  * aslxref - namespace cross reference
 898  */
 899 ACPI_STATUS
 900 XfCrossReferenceNamespace (
 901     void);
 902
 903
 904 /*
 905  * aslutils - common compiler utilites
 906  */
 907 void
 908 DbgPrint (
 909     UINT32                  Type,
 910     char                    *Format,
 911     ...);
 912
 913 /* Type values for above */
 914
 915 #define ASL_DEBUG_OUTPUT    0
 916 #define ASL_PARSE_OUTPUT    1
 917 #define ASL_TREE_OUTPUT     2
 918
 919 void
 920 UtDisplaySupportedTables (
 921     void);
 922
 923 void
 924 UtDisplayConstantOpcodes (
 925     void);
 926
 927 UINT8
 928 UtBeginEvent (
 929     char                    *Name);
 930
 931 void
 932 UtEndEvent (
 933     UINT8                   Event);
 934
 935 void *
 936 UtLocalCalloc (
 937     UINT32                  Size);
 938
 939 void
 940 UtPrintFormattedName (
 941     UINT16                  ParseOpcode,
 942     UINT32                  Level);
 943
 944 void
 945 UtDisplaySummary (
 946     UINT32                  FileId);
 947
 948 void
 949 UtConvertByteToHex (
 950     UINT8                   RawByte,
 951     UINT8                   *Buffer);
 952
 953 void
 954 UtConvertByteToAsmHex (
 955     UINT8                   RawByte,
 956     UINT8                   *Buffer);
 957
 958 char *
 959 UtGetOpName (
 960     UINT32                  ParseOpcode);
 961
 962 void
 963 UtSetParseOpName (
 964     ACPI_PARSE_OBJECT       *Op);
 965
 966 char *
 967 UtStringCacheCalloc (
 968     UINT32                  Length);
 969
 970 void
 971 UtExpandLineBuffers (
 972     void);
 973
 974 void
 975 UtFreeLineBuffers (
 976     void);
 977
 978 ACPI_STATUS
 979 UtInternalizeName (
 980     char                    *ExternalName,
 981     char                    **ConvertedName);
 982
 983 void
 984 UtAttachNamepathToOwner (
 985     ACPI_PARSE_OBJECT       *Op,
 986     ACPI_PARSE_OBJECT       *NameNode);
 987
 988 ACPI_PARSE_OBJECT *
 989 UtCheckIntegerRange (
 990     ACPI_PARSE_OBJECT       *Op,
 991     UINT32                  LowValue,
 992     UINT32                  HighValue);
 993
 994 UINT64
 995 UtDoConstant (
 996     char                    *String);
 997
 998 ACPI_STATUS
 999 UtStrtoul64 (
1000     char                    *String,
1001     UINT32                  Base,
1002     UINT64                  *RetInteger);
1003
1004
1005 /*
1006  * asluuid - UUID support
1007  */
1008 ACPI_STATUS
1009 AuValidateUuid (
1010     char                    *InString);
1011
1012 ACPI_STATUS
1013 AuConvertUuidToString (
1014     char                    *UuIdBuffer,
1015     char                    *OutString);
1016
1017 /*
1018  * aslresource - Resource template generation utilities
1019  */
1020 void
1021 RsSmallAddressCheck (
1022     UINT8                   Type,
1023     UINT32                  Minimum,
1024     UINT32                  Maximum,
1025     UINT32                  Length,
1026     UINT32                  Alignment,
1027     ACPI_PARSE_OBJECT       *MinOp,
1028     ACPI_PARSE_OBJECT       *MaxOp,
1029     ACPI_PARSE_OBJECT       *LengthOp,
1030     ACPI_PARSE_OBJECT       *AlignOp,
1031     ACPI_PARSE_OBJECT       *Op);
1032
1033 void
1034 RsLargeAddressCheck (
1035     UINT64                  Minimum,
1036     UINT64                  Maximum,
1037     UINT64                  Length,
1038     UINT64                  Granularity,
1039     UINT8                   Flags,
1040     ACPI_PARSE_OBJECT       *MinOp,
1041     ACPI_PARSE_OBJECT       *MaxOp,
1042     ACPI_PARSE_OBJECT       *LengthOp,
1043     ACPI_PARSE_OBJECT       *GranOp,
1044     ACPI_PARSE_OBJECT       *Op);
1045
1046 UINT16
1047 RsGetStringDataLength (
1048     ACPI_PARSE_OBJECT       *InitializerOp);
1049
1050 ASL_RESOURCE_NODE *
1051 RsAllocateResourceNode (
1052     UINT32                  Size);
1053
1054 void
1055 RsCreateResourceField (
1056     ACPI_PARSE_OBJECT       *Op,
1057     char                    *Name,
1058     UINT32                  ByteOffset,
1059     UINT32                  BitOffset,
1060     UINT32                  BitLength);
1061
1062 void
1063 RsSetFlagBits (
1064     UINT8                   *Flags,
1065     ACPI_PARSE_OBJECT       *Op,
1066     UINT8                   Position,
1067     UINT8                   DefaultBit);
1068
1069 void
1070 RsSetFlagBits16 (
1071     UINT16                  *Flags,
1072     ACPI_PARSE_OBJECT       *Op,
1073     UINT8                   Position,
1074     UINT8                   DefaultBit);
1075
1076 ACPI_PARSE_OBJECT *
1077 RsCompleteNodeAndGetNext (
1078     ACPI_PARSE_OBJECT       *Op);
1079
1080 void
1081 RsCheckListForDuplicates (
1082     ACPI_PARSE_OBJECT       *Op);
1083
1084 ASL_RESOURCE_NODE *
1085 RsDoOneResourceDescriptor (
1086     ASL_RESOURCE_INFO       *Info,
1087     UINT8                   *State);
1088
1089 /* Values for State above */
1090
1091 #define ACPI_RSTATE_NORMAL              0
1092 #define ACPI_RSTATE_START_DEPENDENT     1
1093 #define ACPI_RSTATE_DEPENDENT_LIST      2
1094
1095 UINT32
1096 RsLinkDescriptorChain (
1097     ASL_RESOURCE_NODE       **PreviousRnode,
1098     ASL_RESOURCE_NODE       *Rnode);
1099
1100 void
1101 RsDoResourceTemplate (
1102     ACPI_PARSE_OBJECT       *Op);
1103
1104
1105 /*
1106  * aslrestype1 - Miscellaneous Small descriptors
1107  */
1108 ASL_RESOURCE_NODE *
1109 RsDoEndTagDescriptor (
1110     ASL_RESOURCE_INFO       *Info);
1111
1112 ASL_RESOURCE_NODE *
1113 RsDoEndDependentDescriptor (
1114     ASL_RESOURCE_INFO       *Info);
1115
1116 ASL_RESOURCE_NODE *
1117 RsDoMemory24Descriptor (
1118     ASL_RESOURCE_INFO       *Info);
1119
1120 ASL_RESOURCE_NODE *
1121 RsDoMemory32Descriptor (
1122     ASL_RESOURCE_INFO       *Info);
1123
1124 ASL_RESOURCE_NODE *
1125 RsDoMemory32FixedDescriptor (
1126     ASL_RESOURCE_INFO       *Info);
1127
1128 ASL_RESOURCE_NODE *
1129 RsDoStartDependentDescriptor (
1130     ASL_RESOURCE_INFO       *Info);
1131
1132 ASL_RESOURCE_NODE *
1133 RsDoStartDependentNoPriDescriptor (
1134     ASL_RESOURCE_INFO       *Info);
1135
1136 ASL_RESOURCE_NODE *
1137 RsDoVendorSmallDescriptor (
1138     ASL_RESOURCE_INFO       *Info);
1139
1140
1141 /*
1142  * aslrestype1i - I/O-related Small descriptors
1143  */
1144 ASL_RESOURCE_NODE *
1145 RsDoDmaDescriptor (
1146     ASL_RESOURCE_INFO       *Info);
1147
1148 ASL_RESOURCE_NODE *
1149 RsDoFixedDmaDescriptor (
1150     ASL_RESOURCE_INFO       *Info);
1151
1152 ASL_RESOURCE_NODE *
1153 RsDoFixedIoDescriptor (
1154     ASL_RESOURCE_INFO       *Info);
1155
1156 ASL_RESOURCE_NODE *
1157 RsDoIoDescriptor (
1158     ASL_RESOURCE_INFO       *Info);
1159
1160 ASL_RESOURCE_NODE *
1161 RsDoIrqDescriptor (
1162     ASL_RESOURCE_INFO       *Info);
1163
1164 ASL_RESOURCE_NODE *
1165 RsDoIrqNoFlagsDescriptor (
1166     ASL_RESOURCE_INFO       *Info);
1167
1168
1169 /*
1170  * aslrestype2 - Large resource descriptors
1171  */
1172 ASL_RESOURCE_NODE *
1173 RsDoInterruptDescriptor (
1174     ASL_RESOURCE_INFO       *Info);
1175
1176 ASL_RESOURCE_NODE *
1177 RsDoVendorLargeDescriptor (
1178     ASL_RESOURCE_INFO       *Info);
1179
1180 ASL_RESOURCE_NODE *
1181 RsDoGeneralRegisterDescriptor (
1182     ASL_RESOURCE_INFO       *Info);
1183
1184 ASL_RESOURCE_NODE *
1185 RsDoGpioIntDescriptor (
1186     ASL_RESOURCE_INFO       *Info);
1187
1188 ASL_RESOURCE_NODE *
1189 RsDoGpioIoDescriptor (
1190     ASL_RESOURCE_INFO       *Info);
1191
1192 ASL_RESOURCE_NODE *
1193 RsDoI2cSerialBusDescriptor (
1194     ASL_RESOURCE_INFO       *Info);
1195
1196 ASL_RESOURCE_NODE *
1197 RsDoSpiSerialBusDescriptor (
1198     ASL_RESOURCE_INFO       *Info);
1199
1200 ASL_RESOURCE_NODE *
1201 RsDoUartSerialBusDescriptor (
1202     ASL_RESOURCE_INFO       *Info);
1203
1204 /*
1205  * aslrestype2d - DWord address descriptors
1206  */
1207 ASL_RESOURCE_NODE *
1208 RsDoDwordIoDescriptor (
1209     ASL_RESOURCE_INFO       *Info);
1210
1211 ASL_RESOURCE_NODE *
1212 RsDoDwordMemoryDescriptor (
1213     ASL_RESOURCE_INFO       *Info);
1214
1215 ASL_RESOURCE_NODE *
1216 RsDoDwordSpaceDescriptor (
1217     ASL_RESOURCE_INFO       *Info);
1218
1219
1220 /*
1221  * aslrestype2e - Extended address descriptors
1222  */
1223 ASL_RESOURCE_NODE *
1224 RsDoExtendedIoDescriptor (
1225     ASL_RESOURCE_INFO       *Info);
1226
1227 ASL_RESOURCE_NODE *
1228 RsDoExtendedMemoryDescriptor (
1229     ASL_RESOURCE_INFO       *Info);
1230
1231 ASL_RESOURCE_NODE *
1232 RsDoExtendedSpaceDescriptor (
1233     ASL_RESOURCE_INFO       *Info);
1234
1235
1236 /*
1237  * aslrestype2q - QWord address descriptors
1238  */
1239 ASL_RESOURCE_NODE *
1240 RsDoQwordIoDescriptor (
1241     ASL_RESOURCE_INFO       *Info);
1242
1243 ASL_RESOURCE_NODE *
1244 RsDoQwordMemoryDescriptor (
1245     ASL_RESOURCE_INFO       *Info);
1246
1247 ASL_RESOURCE_NODE *
1248 RsDoQwordSpaceDescriptor (
1249     ASL_RESOURCE_INFO       *Info);
1250
1251
1252 /*
1253  * aslrestype2w - Word address descriptors
1254  */
1255 ASL_RESOURCE_NODE *
1256 RsDoWordIoDescriptor (
1257     ASL_RESOURCE_INFO       *Info);
1258
1259 ASL_RESOURCE_NODE *
1260 RsDoWordSpaceDescriptor (
1261     ASL_RESOURCE_INFO       *Info);
1262
1263 ASL_RESOURCE_NODE *
1264 RsDoWordBusNumberDescriptor (
1265     ASL_RESOURCE_INFO       *Info);
1266
1267
1268 /*
1269  * Entry to data table compiler subsystem
1270  */
1271 ACPI_STATUS
1272 DtDoCompile(
1273     void);
1274
1275 ACPI_STATUS
1276 DtCreateTemplates (
1277     char                    *Signature);
1278
1279 #endif /*  __ASLCOMPILER_H */