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