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 TrAmlTransformWalkBegin (
 656     ACPI_PARSE_OBJECT       *Op,
 657     UINT32                  Level,
 658     void                    *Context);
 659
 660 ACPI_STATUS
 661 TrAmlTransformWalkEnd (
 662     ACPI_PARSE_OBJECT       *Op,
 663     UINT32                  Level,
 664     void                    *Context);
 665
 666
 667 /*
 668  * asltree - parse tree support
 669  */
 670 ACPI_STATUS
 671 TrWalkParseTree (
 672     ACPI_PARSE_OBJECT       *Op,
 673     UINT32                  Visitation,
 674     ASL_WALK_CALLBACK       DescendingCallback,
 675     ASL_WALK_CALLBACK       AscendingCallback,
 676     void                    *Context);
 677
 678 /*
 679  * aslexternal - External opcode support
 680  */
 681 ACPI_STATUS
 682 ExAmlExternalWalkBegin (
 683     ACPI_PARSE_OBJECT       *Op,
 684     UINT32                  Level,
 685     void                    *Context);
 686
 687 ACPI_STATUS
 688 ExAmlExternalWalkEnd (
 689     ACPI_PARSE_OBJECT       *Op,
 690     UINT32                  Level,
 691     void                    *Context);
 692
 693 void
 694 ExDoExternal (
 695     ACPI_PARSE_OBJECT       *Op);
 696
 697 /* Values for "Visitation" parameter above */
 698
 699 #define ASL_WALK_VISIT_DOWNWARD     0x01
 700 #define ASL_WALK_VISIT_UPWARD       0x02
 701 #define ASL_WALK_VISIT_TWICE        (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
 702
 703
 704 ACPI_PARSE_OBJECT *
 705 TrAllocateNode (
 706     UINT32                  ParseOpcode);
 707
 708 void
 709 TrPrintNodeCompileFlags (
 710     UINT32                  Flags);
 711
 712 void
 713 TrReleaseNode (
 714     ACPI_PARSE_OBJECT       *Op);
 715
 716 ACPI_PARSE_OBJECT *
 717 TrUpdateNode (
 718     UINT32                  ParseOpcode,
 719     ACPI_PARSE_OBJECT       *Op);
 720
 721 ACPI_PARSE_OBJECT *
 722 TrCreateNode (
 723     UINT32                  ParseOpcode,
 724     UINT32                  NumChildren,
 725     ...);
 726
 727 ACPI_PARSE_OBJECT *
 728 TrCreateLeafNode (
 729     UINT32                  ParseOpcode);
 730
 731 ACPI_PARSE_OBJECT *
 732 TrCreateNullTarget (
 733     void);
 734
 735 ACPI_PARSE_OBJECT *
 736 TrCreateAssignmentNode (
 737     ACPI_PARSE_OBJECT       *Target,
 738     ACPI_PARSE_OBJECT       *Source);
 739
 740 ACPI_PARSE_OBJECT *
 741 TrCreateTargetOperand (
 742     ACPI_PARSE_OBJECT       *OriginalOp,
 743     ACPI_PARSE_OBJECT       *ParentOp);
 744
 745 ACPI_PARSE_OBJECT *
 746 TrCreateValuedLeafNode (
 747     UINT32                  ParseOpcode,
 748     UINT64                  Value);
 749
 750 ACPI_PARSE_OBJECT *
 751 TrCreateConstantLeafNode (
 752     UINT32                  ParseOpcode);
 753
 754 ACPI_PARSE_OBJECT *
 755 TrLinkChildren (
 756     ACPI_PARSE_OBJECT       *Op,
 757     UINT32                  NumChildren,
 758     ...);
 759
 760 void
 761 TrSetEndLineNumber (
 762     ACPI_PARSE_OBJECT       *Op);
 763
 764 void
 765 TrSetCurrentFilename (
 766     ACPI_PARSE_OBJECT       *Op);
 767
 768 void
 769 TrWalkTree (
 770     void);
 771
 772 ACPI_PARSE_OBJECT *
 773 TrLinkPeerNode (
 774     ACPI_PARSE_OBJECT       *Op1,
 775     ACPI_PARSE_OBJECT       *Op2);
 776
 777 ACPI_PARSE_OBJECT *
 778 TrLinkChildNode (
 779     ACPI_PARSE_OBJECT       *Op1,
 780     ACPI_PARSE_OBJECT       *Op2);
 781
 782 ACPI_PARSE_OBJECT *
 783 TrSetNodeFlags (
 784     ACPI_PARSE_OBJECT       *Op,
 785     UINT32                  Flags);
 786
 787 ACPI_PARSE_OBJECT *
 788 TrSetNodeAmlLength (
 789     ACPI_PARSE_OBJECT       *Op,
 790     UINT32                  Length);
 791
 792 ACPI_PARSE_OBJECT *
 793 TrLinkPeerNodes (
 794     UINT32                  NumPeers,
 795     ...);
 796
 797
 798 /*
 799  * aslfiles - File I/O support
 800  */
 801 void
 802 FlAddIncludeDirectory (
 803     char                    *Dir);
 804
 805 char *
 806 FlMergePathnames (
 807     char                    *PrefixDir,
 808     char                    *FilePathname);
 809
 810 void
 811 FlOpenIncludeFile (
 812     ACPI_PARSE_OBJECT       *Op);
 813
 814 void
 815 FlFileError (
 816     UINT32                  FileId,
 817     UINT8                   ErrorId);
 818
 819 UINT32
 820 FlGetFileSize (
 821     UINT32                  FileId);
 822
 823 ACPI_STATUS
 824 FlReadFile (
 825     UINT32                  FileId,
 826     void                    *Buffer,
 827     UINT32                  Length);
 828
 829 void
 830 FlWriteFile (
 831     UINT32                  FileId,
 832     void                    *Buffer,
 833     UINT32                  Length);
 834
 835 void
 836 FlSeekFile (
 837     UINT32                  FileId,
 838     long                    Offset);
 839
 840 void
 841 FlCloseFile (
 842     UINT32                  FileId);
 843
 844 void
 845 FlPrintFile (
 846     UINT32                  FileId,
 847     char                    *Format,
 848     ...);
 849
 850 void
 851 FlDeleteFile (
 852     UINT32                  FileId);
 853
 854 void
 855 FlSetLineNumber (
 856     UINT32                  LineNumber);
 857
 858 void
 859 FlSetFilename (
 860     char                    *Filename);
 861
 862 ACPI_STATUS
 863 FlOpenInputFile (
 864     char                    *InputFilename);
 865
 866 ACPI_STATUS
 867 FlOpenAmlOutputFile (
 868     char                    *InputFilename);
 869
 870 ACPI_STATUS
 871 FlOpenMiscOutputFiles (
 872     char                    *InputFilename);
 873
 874 /*
 875  * aslhwmap - hardware map summary
 876  */
 877 void
 878 MpEmitMappingInfo (
 879     void);
 880
 881
 882 /*
 883  * asload - load namespace in prep for cross reference
 884  */
 885 ACPI_STATUS
 886 LdLoadNamespace (
 887     ACPI_PARSE_OBJECT       *RootOp);
 888
 889
 890 /*
 891  * asllookup - namespace lookup functions
 892  */
 893 void
 894 LkFindUnreferencedObjects (
 895     void);
 896
 897 /*
 898  * aslmain - startup
 899  */
 900 void
 901 Usage (
 902     void);
 903
 904 void
 905 AslFilenameHelp (
 906     void);
 907
 908
 909 /*
 910  * aslnamesp - namespace output file generation
 911  */
 912 ACPI_STATUS
 913 NsDisplayNamespace (
 914     void);
 915
 916 void
 917 NsSetupNamespaceListing (
 918     void                    *Handle);
 919
 920 /*
 921  * asloptions - command line processing
 922  */
 923 int
 924 AslCommandLine (
 925     int                     argc,
 926     char                    **argv);
 927
 928 /*
 929  * aslxref - namespace cross reference
 930  */
 931 ACPI_STATUS
 932 XfCrossReferenceNamespace (
 933     void);
 934
 935
 936 /*
 937  * aslxrefout
 938  */
 939 void
 940 OtPrintHeaders (
 941     char                    *Message);
 942
 943 void
 944 OtCreateXrefFile (
 945     void);
 946
 947 void
 948 OtXrefWalkPart1 (
 949     ACPI_PARSE_OBJECT       *Op,
 950     UINT32                  Level,
 951     ASL_METHOD_INFO         *MethodInfo);
 952
 953
 954 /*
 955  * aslutils - common compiler utilites
 956  */
 957 void
 958 DbgPrint (
 959     UINT32                  Type,
 960     char                    *Format,
 961     ...);
 962
 963 /* Type values for above */
 964
 965 #define ASL_DEBUG_OUTPUT    0
 966 #define ASL_PARSE_OUTPUT    1
 967 #define ASL_TREE_OUTPUT     2
 968
 969 UINT8
 970 UtIsBigEndianMachine (
 971     void);
 972
 973 BOOLEAN
 974 UtQueryForOverwrite (
 975     char                    *Pathname);
 976
 977 void
 978 UtDumpStringOp (
 979     ACPI_PARSE_OBJECT       *Op,
 980     UINT32                  Level);
 981
 982 void
 983 UtDumpIntegerOp (
 984     ACPI_PARSE_OBJECT       *Op,
 985     UINT32                  Level,
 986     UINT32                  IntegerLength);
 987
 988 void
 989 UtDumpBasicOp (
 990     ACPI_PARSE_OBJECT       *Op,
 991     UINT32                  Level);
 992
 993 void
 994 UtDisplaySupportedTables (
 995     void);
 996
 997 void
 998 UtDisplayConstantOpcodes (
 999     void);
1000
1001 UINT8
1002 UtBeginEvent (
1003     char                    *Name);
1004
1005 void
1006 UtEndEvent (
1007     UINT8                   Event);
1008
1009 void *
1010 UtLocalCalloc (
1011     UINT32                  Size);
1012
1013 void
1014 UtDisplaySummary (
1015     UINT32                  FileId);
1016
1017 void
1018 UtConvertByteToHex (
1019     UINT8                   RawByte,
1020     UINT8                   *Buffer);
1021
1022 void
1023 UtConvertByteToAsmHex (
1024     UINT8                   RawByte,
1025     UINT8                   *Buffer);
1026
1027 char *
1028 UtGetOpName (
1029     UINT32                  ParseOpcode);
1030
1031 void
1032 UtSetParseOpName (
1033     ACPI_PARSE_OBJECT       *Op);
1034
1035 char *
1036 UtStringCacheCalloc (
1037     UINT32                  Length);
1038
1039 void
1040 UtExpandLineBuffers (
1041     void);
1042
1043 void
1044 UtFreeLineBuffers (
1045     void);
1046
1047 ACPI_STATUS
1048 UtInternalizeName (
1049     char                    *ExternalName,
1050     char                    **ConvertedName);
1051
1052 void
1053 UtAttachNamepathToOwner (
1054     ACPI_PARSE_OBJECT       *Op,
1055     ACPI_PARSE_OBJECT       *NameNode);
1056
1057 ACPI_PARSE_OBJECT *
1058 UtCheckIntegerRange (
1059     ACPI_PARSE_OBJECT       *Op,
1060     UINT32                  LowValue,
1061     UINT32                  HighValue);
1062
1063 UINT64
1064 UtDoConstant (
1065     char                    *String);
1066
1067
1068 /*
1069  * asluuid - UUID support
1070  */
1071 ACPI_STATUS
1072 AuValidateUuid (
1073     char                    *InString);
1074
1075 ACPI_STATUS
1076 AuConvertUuidToString (
1077     char                    *UuIdBuffer,
1078     char                    *OutString);
1079
1080 /*
1081  * aslresource - Resource template generation utilities
1082  */
1083 void
1084 RsSmallAddressCheck (
1085     UINT8                   Type,
1086     UINT32                  Minimum,
1087     UINT32                  Maximum,
1088     UINT32                  Length,
1089     UINT32                  Alignment,
1090     ACPI_PARSE_OBJECT       *MinOp,
1091     ACPI_PARSE_OBJECT       *MaxOp,
1092     ACPI_PARSE_OBJECT       *LengthOp,
1093     ACPI_PARSE_OBJECT       *AlignOp,
1094     ACPI_PARSE_OBJECT       *Op);
1095
1096 void
1097 RsLargeAddressCheck (
1098     UINT64                  Minimum,
1099     UINT64                  Maximum,
1100     UINT64                  Length,
1101     UINT64                  Granularity,
1102     UINT8                   Flags,
1103     ACPI_PARSE_OBJECT       *MinOp,
1104     ACPI_PARSE_OBJECT       *MaxOp,
1105     ACPI_PARSE_OBJECT       *LengthOp,
1106     ACPI_PARSE_OBJECT       *GranOp,
1107     ACPI_PARSE_OBJECT       *Op);
1108
1109 UINT16
1110 RsGetStringDataLength (
1111     ACPI_PARSE_OBJECT       *InitializerOp);
1112
1113 ASL_RESOURCE_NODE *
1114 RsAllocateResourceNode (
1115     UINT32                  Size);
1116
1117 void
1118 RsCreateResourceField (
1119     ACPI_PARSE_OBJECT       *Op,
1120     char                    *Name,
1121     UINT32                  ByteOffset,
1122     UINT32                  BitOffset,
1123     UINT32                  BitLength);
1124
1125 void
1126 RsSetFlagBits (
1127     UINT8                   *Flags,
1128     ACPI_PARSE_OBJECT       *Op,
1129     UINT8                   Position,
1130     UINT8                   DefaultBit);
1131
1132 void
1133 RsSetFlagBits16 (
1134     UINT16                  *Flags,
1135     ACPI_PARSE_OBJECT       *Op,
1136     UINT8                   Position,
1137     UINT8                   DefaultBit);
1138
1139 ACPI_PARSE_OBJECT *
1140 RsCompleteNodeAndGetNext (
1141     ACPI_PARSE_OBJECT       *Op);
1142
1143 void
1144 RsCheckListForDuplicates (
1145     ACPI_PARSE_OBJECT       *Op);
1146
1147 ASL_RESOURCE_NODE *
1148 RsDoOneResourceDescriptor (
1149     ASL_RESOURCE_INFO       *Info,
1150     UINT8                   *State);
1151
1152 /* Values for State above */
1153
1154 #define ACPI_RSTATE_NORMAL              0
1155 #define ACPI_RSTATE_START_DEPENDENT     1
1156 #define ACPI_RSTATE_DEPENDENT_LIST      2
1157
1158 UINT32
1159 RsLinkDescriptorChain (
1160     ASL_RESOURCE_NODE       **PreviousRnode,
1161     ASL_RESOURCE_NODE       *Rnode);
1162
1163 void
1164 RsDoResourceTemplate (
1165     ACPI_PARSE_OBJECT       *Op);
1166
1167
1168 /*
1169  * aslrestype1 - Miscellaneous Small descriptors
1170  */
1171 ASL_RESOURCE_NODE *
1172 RsDoEndTagDescriptor (
1173     ASL_RESOURCE_INFO       *Info);
1174
1175 ASL_RESOURCE_NODE *
1176 RsDoEndDependentDescriptor (
1177     ASL_RESOURCE_INFO       *Info);
1178
1179 ASL_RESOURCE_NODE *
1180 RsDoMemory24Descriptor (
1181     ASL_RESOURCE_INFO       *Info);
1182
1183 ASL_RESOURCE_NODE *
1184 RsDoMemory32Descriptor (
1185     ASL_RESOURCE_INFO       *Info);
1186
1187 ASL_RESOURCE_NODE *
1188 RsDoMemory32FixedDescriptor (
1189     ASL_RESOURCE_INFO       *Info);
1190
1191 ASL_RESOURCE_NODE *
1192 RsDoStartDependentDescriptor (
1193     ASL_RESOURCE_INFO       *Info);
1194
1195 ASL_RESOURCE_NODE *
1196 RsDoStartDependentNoPriDescriptor (
1197     ASL_RESOURCE_INFO       *Info);
1198
1199 ASL_RESOURCE_NODE *
1200 RsDoVendorSmallDescriptor (
1201     ASL_RESOURCE_INFO       *Info);
1202
1203
1204 /*
1205  * aslrestype1i - I/O-related Small descriptors
1206  */
1207 ASL_RESOURCE_NODE *
1208 RsDoDmaDescriptor (
1209     ASL_RESOURCE_INFO       *Info);
1210
1211 ASL_RESOURCE_NODE *
1212 RsDoFixedDmaDescriptor (
1213     ASL_RESOURCE_INFO       *Info);
1214
1215 ASL_RESOURCE_NODE *
1216 RsDoFixedIoDescriptor (
1217     ASL_RESOURCE_INFO       *Info);
1218
1219 ASL_RESOURCE_NODE *
1220 RsDoIoDescriptor (
1221     ASL_RESOURCE_INFO       *Info);
1222
1223 ASL_RESOURCE_NODE *
1224 RsDoIrqDescriptor (
1225     ASL_RESOURCE_INFO       *Info);
1226
1227 ASL_RESOURCE_NODE *
1228 RsDoIrqNoFlagsDescriptor (
1229     ASL_RESOURCE_INFO       *Info);
1230
1231
1232 /*
1233  * aslrestype2 - Large resource descriptors
1234  */
1235 ASL_RESOURCE_NODE *
1236 RsDoInterruptDescriptor (
1237     ASL_RESOURCE_INFO       *Info);
1238
1239 ASL_RESOURCE_NODE *
1240 RsDoVendorLargeDescriptor (
1241     ASL_RESOURCE_INFO       *Info);
1242
1243 ASL_RESOURCE_NODE *
1244 RsDoGeneralRegisterDescriptor (
1245     ASL_RESOURCE_INFO       *Info);
1246
1247 ASL_RESOURCE_NODE *
1248 RsDoGpioIntDescriptor (
1249     ASL_RESOURCE_INFO       *Info);
1250
1251 ASL_RESOURCE_NODE *
1252 RsDoGpioIoDescriptor (
1253     ASL_RESOURCE_INFO       *Info);
1254
1255 ASL_RESOURCE_NODE *
1256 RsDoI2cSerialBusDescriptor (
1257     ASL_RESOURCE_INFO       *Info);
1258
1259 ASL_RESOURCE_NODE *
1260 RsDoSpiSerialBusDescriptor (
1261     ASL_RESOURCE_INFO       *Info);
1262
1263 ASL_RESOURCE_NODE *
1264 RsDoUartSerialBusDescriptor (
1265     ASL_RESOURCE_INFO       *Info);
1266
1267 /*
1268  * aslrestype2d - DWord address descriptors
1269  */
1270 ASL_RESOURCE_NODE *
1271 RsDoDwordIoDescriptor (
1272     ASL_RESOURCE_INFO       *Info);
1273
1274 ASL_RESOURCE_NODE *
1275 RsDoDwordMemoryDescriptor (
1276     ASL_RESOURCE_INFO       *Info);
1277
1278 ASL_RESOURCE_NODE *
1279 RsDoDwordSpaceDescriptor (
1280     ASL_RESOURCE_INFO       *Info);
1281
1282
1283 /*
1284  * aslrestype2e - Extended address descriptors
1285  */
1286 ASL_RESOURCE_NODE *
1287 RsDoExtendedIoDescriptor (
1288     ASL_RESOURCE_INFO       *Info);
1289
1290 ASL_RESOURCE_NODE *
1291 RsDoExtendedMemoryDescriptor (
1292     ASL_RESOURCE_INFO       *Info);
1293
1294 ASL_RESOURCE_NODE *
1295 RsDoExtendedSpaceDescriptor (
1296     ASL_RESOURCE_INFO       *Info);
1297
1298
1299 /*
1300  * aslrestype2q - QWord address descriptors
1301  */
1302 ASL_RESOURCE_NODE *
1303 RsDoQwordIoDescriptor (
1304     ASL_RESOURCE_INFO       *Info);
1305
1306 ASL_RESOURCE_NODE *
1307 RsDoQwordMemoryDescriptor (
1308     ASL_RESOURCE_INFO       *Info);
1309
1310 ASL_RESOURCE_NODE *
1311 RsDoQwordSpaceDescriptor (
1312     ASL_RESOURCE_INFO       *Info);
1313
1314
1315 /*
1316  * aslrestype2w - Word address descriptors
1317  */
1318 ASL_RESOURCE_NODE *
1319 RsDoWordIoDescriptor (
1320     ASL_RESOURCE_INFO       *Info);
1321
1322 ASL_RESOURCE_NODE *
1323 RsDoWordSpaceDescriptor (
1324     ASL_RESOURCE_INFO       *Info);
1325
1326 ASL_RESOURCE_NODE *
1327 RsDoWordBusNumberDescriptor (
1328     ASL_RESOURCE_INFO       *Info);
1329
1330
1331 /*
1332  * Entry to data table compiler subsystem
1333  */
1334 ACPI_STATUS
1335 DtDoCompile(
1336     void);
1337
1338 ACPI_STATUS
1339 DtCreateTemplates (
1340     char                    **argv);
1341
1342 #endif /*  __ASLCOMPILER_H */