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