1 /******************************************************************************
2  *
3  * Module Name: aslcompiler.h - common include file for iASL
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2022, 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 MERCHANTABILITY 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 <string.h>
66 #include <errno.h>
67 #include <ctype.h>
68 
69 /* Compiler headers */
70 
71 #include "asldefine.h"
72 #include "asltypes.h"
73 #include "aslmessages.h"
74 #include "aslglobal.h"
75 #include "preprocess.h"
76 #include "dtcompiler.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 ACPI_STATUS
150 CmDoCompile (
151     void);
152 
153 int
154 CmDoAslMiddleAndBackEnd (
155     void);
156 
157 void
158 CmDoOutputFiles (
159     void);
160 
161 int
162 CmCleanupAndExit (
163     void);
164 
165 ACPI_STATUS
166 AslDoDisassembly (
167     void);
168 
169 
170 /*
171  * aslallocate - memory allocation
172  */
173 void *
174 UtLocalCalloc (
175     UINT32                  Size);
176 
177 void
178 UtExpandLineBuffers (
179     void);
180 
181 void
182 UtReallocLineBuffers (
183     char                    **Buffer,
184     UINT32                  OldSize,
185     UINT32                  NewSize);
186 
187 void
188 UtFreeLineBuffers (
189     void);
190 
191 
192 /*
193  * aslcache - local cache support
194  */
195 char *
196 UtLocalCacheCalloc (
197     UINT32                  Length);
198 
199 ACPI_PARSE_OBJECT *
200 UtParseOpCacheCalloc (
201     void);
202 
203 DT_SUBTABLE *
204 UtSubtableCacheCalloc (
205     void);
206 
207 DT_FIELD *
208 UtFieldCacheCalloc (
209     void);
210 
211 void
212 UtDeleteLocalCaches (
213     void);
214 
215 
216 /*
217  * aslascii - ascii support
218  */
219 ACPI_STATUS
220 FlIsFileAsciiSource (
221     char                    *Filename,
222     BOOLEAN                 DisplayErrors);
223 
224 
225 /*
226  * aslwalks - semantic analysis and parse tree walks
227  */
228 ACPI_STATUS
229 AnOtherSemanticAnalysisWalkBegin (
230     ACPI_PARSE_OBJECT       *Op,
231     UINT32                  Level,
232     void                    *Context);
233 
234 ACPI_STATUS
235 AnOtherSemanticAnalysisWalkEnd (
236     ACPI_PARSE_OBJECT       *Op,
237     UINT32                  Level,
238     void                    *Context);
239 
240 ACPI_STATUS
241 AnOperandTypecheckWalkEnd (
242     ACPI_PARSE_OBJECT       *Op,
243     UINT32                  Level,
244     void                    *Context);
245 
246 ACPI_STATUS
247 AnMethodTypingWalkEnd (
248     ACPI_PARSE_OBJECT       *Op,
249     UINT32                  Level,
250     void                    *Context);
251 
252 
253 /*
254  * aslmethod - Control method analysis walk
255  */
256 ACPI_STATUS
257 MtMethodAnalysisWalkBegin (
258     ACPI_PARSE_OBJECT       *Op,
259     UINT32                  Level,
260     void                    *Context);
261 
262 ACPI_STATUS
263 MtMethodAnalysisWalkEnd (
264     ACPI_PARSE_OBJECT       *Op,
265     UINT32                  Level,
266     void                    *Context);
267 
268 UINT32
269 MtProcessTypeOp (
270     ACPI_PARSE_OBJECT       *TypeOp);
271 
272 UINT8
273 MtProcessParameterTypeList (
274     ACPI_PARSE_OBJECT       *ParamTypeOp,
275     UINT32                  *TypeList);
276 
277 
278 /*
279  * aslbtypes - bitfield data types
280  */
281 UINT32
282 AnMapObjTypeToBtype (
283     ACPI_PARSE_OBJECT       *Op);
284 
285 UINT32
286 AnMapArgTypeToBtype (
287     UINT32                  ArgType);
288 
289 UINT32
290 AnGetBtype (
291     ACPI_PARSE_OBJECT       *Op);
292 
293 void
294 AnFormatBtype (
295     char                    *Buffer,
296     UINT32                  Btype);
297 
298 
299 /*
300  * aslanalyze - Support functions for parse tree walks
301  */
302 void
303 AnCheckId (
304     ACPI_PARSE_OBJECT       *Op,
305     ACPI_NAME               Type);
306 
307 /* Values for Type argument above */
308 
309 #define ASL_TYPE_HID        0
310 #define ASL_TYPE_CID        1
311 
312 BOOLEAN
313 AnIsInternalMethod (
314     ACPI_PARSE_OBJECT       *Op);
315 
316 UINT32
317 AnGetInternalMethodReturnType (
318     ACPI_PARSE_OBJECT       *Op);
319 
320 BOOLEAN
321 AnLastStatementIsReturn (
322     ACPI_PARSE_OBJECT       *Op);
323 
324 void
325 AnCheckMethodReturnValue (
326     ACPI_PARSE_OBJECT       *Op,
327     const ACPI_OPCODE_INFO  *OpInfo,
328     ACPI_PARSE_OBJECT       *ArgOp,
329     UINT32                  RequiredBtypes,
330     UINT32                  ThisNodeBtype);
331 
332 BOOLEAN
333 AnIsResultUsed (
334     ACPI_PARSE_OBJECT       *Op);
335 
336 void
337 ApCheckForGpeNameConflict (
338     ACPI_PARSE_OBJECT       *Op);
339 
340 void
341 ApCheckRegMethod (
342     ACPI_PARSE_OBJECT       *Op);
343 
344 BOOLEAN
345 ApFindNameInScope (
346     char                    *Name,
347     ACPI_PARSE_OBJECT       *Op);
348 
349 BOOLEAN
350 ApFindNameInDeviceTree (
351     char                    *Name,
352     ACPI_PARSE_OBJECT       *Op);
353 
354 /*
355  * aslerror - error handling/reporting
356  */
357 void
358 AslAbort (
359     void);
360 
361 void
362 AslDualParseOpError (
363     UINT8                   Level,
364     UINT16                  MainMessageId,
365     ACPI_PARSE_OBJECT       *MainOp,
366     char                    *MainMessage,
367     UINT16                  SecondMessageId,
368     ACPI_PARSE_OBJECT       *SecondOp,
369     char                    *SecondaryMessage);
370 
371 void
372 AslError (
373     UINT8                   Level,
374     UINT16                  MessageId,
375     ACPI_PARSE_OBJECT       *Op,
376     char                    *ExtraMessage);
377 
378 void
379 AslCheckExpectedExceptions (
380     void);
381 
382 ACPI_STATUS
383 AslLogExpectedException (
384     char                    *MessageIdString);
385 
386 ACPI_STATUS
387 AslElevateException (
388     char                    *MessageIdString);
389 
390 ACPI_STATUS
391 AslDisableException (
392     char                    *MessageIdString);
393 
394 BOOLEAN
395 AslIsExceptionIgnored (
396     char                    *Filename,
397     UINT32                  LineNumber,
398     UINT8                   Level,
399     UINT16                  MessageId);
400 
401 void
402 AslLogExpectedExceptionByLine (
403     char                    *MessageIdString);
404 
405 void
406 AslCoreSubsystemError (
407     ACPI_PARSE_OBJECT       *Op,
408     ACPI_STATUS             Status,
409     char                    *ExtraMessage,
410     BOOLEAN                 Abort);
411 
412 int
413 AslCompilererror(
414     const char              *s);
415 
416 void
417 AslCommonError (
418     UINT8                   Level,
419     UINT16                  MessageId,
420     UINT32                  CurrentLineNumber,
421     UINT32                  LogicalLineNumber,
422     UINT32                  LogicalByteOffset,
423     UINT32                  Column,
424     char                    *Filename,
425     char                    *ExtraMessage);
426 
427 void
428 AslCommonError2 (
429     UINT8                   Level,
430     UINT16                  MessageId,
431     UINT32                  LineNumber,
432     UINT32                  Column,
433     char                    *SourceLine,
434     char                    *Filename,
435     char                    *ExtraMessage);
436 
437 void
438 AePrintException (
439     UINT32                  FileId,
440     ASL_ERROR_MSG           *Enode,
441     char                    *Header);
442 
443 void
444 AePrintErrorLog (
445     UINT32                  FileId);
446 
447 void
448 AeClearErrorLog (
449     void);
450 
451 
452 /*
453  * asllisting - generate all "listing" type files
454  */
455 void
456 LsDoListings (
457     void);
458 
459 void
460 LsWriteNodeToAsmListing (
461     ACPI_PARSE_OBJECT       *Op);
462 
463 void
464 LsWriteNode (
465     ACPI_PARSE_OBJECT       *Op,
466     UINT32                  FileId);
467 
468 void
469 LsDumpParseTree (
470     void);
471 
472 
473 /*
474  * asllistsup - Listing file support utilities
475  */
476 void
477 LsDumpAscii (
478     UINT32                  FileId,
479     UINT32                  Count,
480     UINT8                   *Buffer);
481 
482 void
483 LsDumpAsciiInComment (
484     UINT32                  FileId,
485     UINT32                  Count,
486     UINT8                   *Buffer);
487 
488 void
489 LsCheckException (
490     UINT32                  LineNumber,
491     UINT32                  FileId);
492 
493 void
494 LsFlushListingBuffer (
495     UINT32                  FileId);
496 
497 void
498 LsWriteListingHexBytes (
499     UINT8                   *Buffer,
500     UINT32                  Length,
501     UINT32                  FileId);
502 
503 void
504 LsWriteSourceLines (
505     UINT32                  ToLineNumber,
506     UINT32                  ToLogicalLineNumber,
507     UINT32                  FileId);
508 
509 UINT32
510 LsWriteOneSourceLine (
511     UINT32                  FileId);
512 
513 void
514 LsPushNode (
515     char                    *Filename);
516 
517 ASL_LISTING_NODE *
518 LsPopNode (
519     void);
520 
521 
522 /*
523  * aslhex - generate all "hex" output files (C, ASM, ASL)
524  */
525 void
526 HxDoHexOutput (
527     void);
528 
529 
530 /*
531  * aslfold - constant folding
532  */
533 ACPI_STATUS
534 OpcAmlConstantWalk (
535     ACPI_PARSE_OBJECT       *Op,
536     UINT32                  Level,
537     void                    *Context);
538 
539 
540 /*
541  * aslmessages - exception strings
542  */
543 const char *
544 AeDecodeMessageId (
545     UINT16                  MessageId);
546 
547 const char *
548 AeDecodeExceptionLevel (
549     UINT8                   Level);
550 
551 UINT16
552 AeBuildFullExceptionCode (
553     UINT8                   Level,
554     UINT16                  MessageId);
555 
556 /*
557  * asloffset - generate C offset file for BIOS support
558  */
559 ACPI_STATUS
560 LsAmlOffsetWalk (
561     ACPI_PARSE_OBJECT       *Op,
562     UINT32                  Level,
563     void                    *Context);
564 
565 void
566 LsDoOffsetTableHeader (
567     UINT32                  FileId);
568 
569 void
570 LsDoOffsetTableFooter (
571     UINT32                  FileId);
572 
573 
574 /*
575  * aslopcodes - generate AML opcodes
576  */
577 ACPI_STATUS
578 OpcAmlOpcodeWalk (
579     ACPI_PARSE_OBJECT       *Op,
580     UINT32                  Level,
581     void                    *Context);
582 
583 ACPI_STATUS
584 OpcAmlOpcodeUpdateWalk (
585     ACPI_PARSE_OBJECT       *Op,
586     UINT32                  Level,
587     void                    *Context);
588 
589 void
590 OpcGenerateAmlOpcode (
591     ACPI_PARSE_OBJECT       *Op);
592 
593 UINT32
594 OpcSetOptimalIntegerSize (
595     ACPI_PARSE_OBJECT       *Op);
596 
597 void
598 OpcGetIntegerWidth (
599     ACPI_PARSE_OBJECT       *Op);
600 
601 
602 /*
603  * asloperands - generate AML operands for the AML opcodes
604  */
605 ACPI_PARSE_OBJECT  *
606 UtGetArg (
607     ACPI_PARSE_OBJECT       *Op,
608     UINT32                  Argn);
609 
610 void
611 OpnGenerateAmlOperands (
612     ACPI_PARSE_OBJECT       *Op);
613 
614 void
615 OpnDoPackage (
616     ACPI_PARSE_OBJECT       *Op);
617 
618 
619 /*
620  * aslopt - optimization
621  */
622 void
623 OptOptimizeNamePath (
624     ACPI_PARSE_OBJECT       *Op,
625     UINT32                  Flags,
626     ACPI_WALK_STATE         *WalkState,
627     char                    *AmlNameString,
628     ACPI_NAMESPACE_NODE     *TargetNode);
629 
630 
631 /*
632  * aslpld - ToPLD macro support
633  */
634 void
635 OpcDoPld (
636     ACPI_PARSE_OBJECT       *Op);
637 
638 
639 /*
640  * aslprintf - Printf/Fprintf macros
641  */
642 void
643 OpcDoPrintf (
644     ACPI_PARSE_OBJECT       *Op);
645 
646 void
647 OpcDoFprintf (
648     ACPI_PARSE_OBJECT       *Op);
649 
650 
651 /*
652  * aslprune - parse tree pruner
653  */
654 void
655 AslPruneParseTree (
656     UINT32                  PruneDepth,
657     UINT32                  Type);
658 
659 
660 /*
661  * aslcodegen - code generation
662  */
663 void
664 CgGenerateAmlOutput (
665     void);
666 
667 void
668 CgLocalWriteAmlData (
669     ACPI_PARSE_OBJECT       *Op,
670     void                    *Buffer,
671     UINT32                  Length);
672 
673 
674 /*
675  * aslfile
676  */
677 void
678 FlOpenFile (
679     UINT32                  FileId,
680     char                    *Filename,
681     char                    *Mode);
682 
683 
684 /*
685  * asllength - calculate/adjust AML package lengths
686  */
687 ACPI_STATUS
688 LnPackageLengthWalk (
689     ACPI_PARSE_OBJECT       *Op,
690     UINT32                  Level,
691     void                    *Context);
692 
693 ACPI_STATUS
694 LnInitLengthsWalk (
695     ACPI_PARSE_OBJECT       *Op,
696     UINT32                  Level,
697     void                    *Context);
698 
699 void
700 CgGenerateAmlLengths (
701     ACPI_PARSE_OBJECT       *Op);
702 
703 
704 /*
705  * aslmap - opcode mappings and reserved method names
706  */
707 ACPI_OBJECT_TYPE
708 AslMapNamedOpcodeToDataType (
709     UINT16                  Opcode);
710 
711 
712 /*
713  * aslpredef - ACPI predefined names support
714  */
715 BOOLEAN
716 ApCheckForPredefinedMethod (
717     ACPI_PARSE_OBJECT       *Op,
718     ASL_METHOD_INFO         *MethodInfo);
719 
720 void
721 ApCheckPredefinedReturnValue (
722     ACPI_PARSE_OBJECT       *Op,
723     ASL_METHOD_INFO         *MethodInfo);
724 
725 UINT32
726 ApCheckForPredefinedName (
727     ACPI_PARSE_OBJECT       *Op,
728     char                    *Name);
729 
730 void
731 ApCheckForPredefinedObject (
732     ACPI_PARSE_OBJECT       *Op,
733     char                    *Name);
734 
735 ACPI_STATUS
736 ApCheckObjectType (
737     const char              *PredefinedName,
738     ACPI_PARSE_OBJECT       *Op,
739     UINT32                  ExpectedBtypes,
740     UINT32                  PackageIndex);
741 
742 void
743 ApDisplayReservedNames (
744     void);
745 
746 
747 /*
748  * aslprepkg - ACPI predefined names support for packages
749  */
750 void
751 ApCheckPackage (
752     ACPI_PARSE_OBJECT           *ParentOp,
753     const ACPI_PREDEFINED_INFO  *Predefined);
754 
755 
756 /*
757  * asltransform - parse tree transformations
758  */
759 ACPI_STATUS
760 TrAmlTransformWalkBegin (
761     ACPI_PARSE_OBJECT       *Op,
762     UINT32                  Level,
763     void                    *Context);
764 
765 ACPI_STATUS
766 TrAmlTransformWalkEnd (
767     ACPI_PARSE_OBJECT       *Op,
768     UINT32                  Level,
769     void                    *Context);
770 
771 
772 /*
773  * aslexternal - External opcode support
774  */
775 ACPI_STATUS
776 ExAmlExternalWalkBegin (
777     ACPI_PARSE_OBJECT       *Op,
778     UINT32                  Level,
779     void                    *Context);
780 
781 ACPI_STATUS
782 ExAmlExternalWalkEnd (
783     ACPI_PARSE_OBJECT       *Op,
784     UINT32                  Level,
785     void                    *Context);
786 
787 void
788 ExDoExternal (
789     ACPI_PARSE_OBJECT       *Op);
790 
791 /* Values for "Visitation" parameter above */
792 
793 #define ASL_WALK_VISIT_DOWNWARD         0x01
794 #define ASL_WALK_VISIT_UPWARD           0x02
795 #define ASL_WALK_VISIT_DB_SEPARATELY    0x04
796 #define ASL_WALK_VISIT_TWICE            (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
797 
798 
799 /*
800  * aslparseop.c - Parse op create/allocate/cache
801  */
802 ACPI_PARSE_OBJECT *
803 TrCreateOp (
804     UINT32                  ParseOpcode,
805     UINT32                  NumChildren,
806     ...);
807 
808 ACPI_PARSE_OBJECT *
809 TrCreateLeafOp (
810     UINT32                  ParseOpcode);
811 
812 ACPI_PARSE_OBJECT *
813 TrCreateNullTargetOp (
814     void);
815 
816 ACPI_PARSE_OBJECT *
817 TrCreateAssignmentOp (
818     ACPI_PARSE_OBJECT       *Target,
819     ACPI_PARSE_OBJECT       *Source);
820 
821 ACPI_PARSE_OBJECT *
822 TrCreateTargetOp (
823     ACPI_PARSE_OBJECT       *OriginalOp,
824     ACPI_PARSE_OBJECT       *ParentOp);
825 
826 ACPI_PARSE_OBJECT *
827 TrCreateValuedLeafOp (
828     UINT32                  ParseOpcode,
829     UINT64                  Value);
830 
831 ACPI_PARSE_OBJECT *
832 TrCreateConstantLeafOp (
833     UINT32                  ParseOpcode);
834 
835 ACPI_PARSE_OBJECT *
836 TrAllocateOp (
837     UINT32                  ParseOpcode);
838 
839 void
840 TrPrintOpFlags (
841     UINT32                  Flags,
842     UINT32                  OutputLevel);
843 
844 
845 /*
846  * asltree.c - Parse tree management
847  */
848 void
849 TrSetOpParent (
850     ACPI_PARSE_OBJECT       *Op,
851     ACPI_PARSE_OBJECT       *ParentOp);
852 
853 ACPI_PARSE_OBJECT *
854 TrSetOpIntegerValue (
855     UINT32                  ParseOpcode,
856     ACPI_PARSE_OBJECT       *Op);
857 
858 void
859 TrSetOpEndLineNumber (
860     ACPI_PARSE_OBJECT       *Op);
861 
862 void
863 TrSetOpCurrentFilename (
864     ACPI_PARSE_OBJECT       *Op);
865 
866 void
867 TrSetOpIntegerWidth (
868     ACPI_PARSE_OBJECT       *TableSignature,
869     ACPI_PARSE_OBJECT       *Revision);
870 
871 ACPI_PARSE_OBJECT *
872 TrLinkOpChildren (
873     ACPI_PARSE_OBJECT       *Op,
874     UINT32                  NumChildren,
875     ...);
876 
877 ACPI_PARSE_OBJECT *
878 TrLinkPeerOp (
879     ACPI_PARSE_OBJECT       *Op1,
880     ACPI_PARSE_OBJECT       *Op2);
881 
882 ACPI_PARSE_OBJECT *
883 TrLinkChildOp (
884     ACPI_PARSE_OBJECT       *Op1,
885     ACPI_PARSE_OBJECT       *Op2);
886 
887 ACPI_PARSE_OBJECT *
888 TrSetOpFlags (
889     ACPI_PARSE_OBJECT       *Op,
890     UINT32                  Flags);
891 
892 ACPI_PARSE_OBJECT *
893 TrSetOpAmlLength (
894     ACPI_PARSE_OBJECT       *Op,
895     UINT32                  Length);
896 
897 ACPI_PARSE_OBJECT *
898 TrLinkPeerOps (
899     UINT32                  NumPeers,
900     ...);
901 
902 ACPI_STATUS
903 TrWalkParseTree (
904     ACPI_PARSE_OBJECT       *Op,
905     UINT32                  Visitation,
906     ASL_WALK_CALLBACK       DescendingCallback,
907     ASL_WALK_CALLBACK       AscendingCallback,
908     void                    *Context);
909 
910 
911 /*
912  * aslfiles - File I/O support
913  */
914 void
915 FlAddIncludeDirectory (
916     char                    *Dir);
917 
918 char *
919 FlMergePathnames (
920     char                    *PrefixDir,
921     char                    *FilePathname);
922 
923 void
924 FlOpenIncludeFile (
925     ACPI_PARSE_OBJECT       *Op);
926 
927 void
928 FlFileError (
929     UINT32                  FileId,
930     UINT8                   ErrorId);
931 
932 UINT32
933 FlGetFileSize (
934     UINT32                  FileId);
935 
936 ACPI_STATUS
937 FlReadFile (
938     UINT32                  FileId,
939     void                    *Buffer,
940     UINT32                  Length);
941 
942 void
943 FlWriteFile (
944     UINT32                  FileId,
945     void                    *Buffer,
946     UINT32                  Length);
947 
948 void
949 FlSeekFile (
950     UINT32                  FileId,
951     long                    Offset);
952 
953 void
954 FlSeekFileSet (
955     UINT32                  FileId,
956     long                    Offset);
957 
958 void
959 FlCloseFile (
960     UINT32                  FileId);
961 
962 ACPI_PRINTF_LIKE (2)
963 void
964 FlPrintFile (
965     UINT32                  FileId,
966     char                    *Format,
967     ...);
968 
969 void
970 FlDeleteFile (
971     UINT32                  FileId);
972 
973 void
974 FlSetLineNumber (
975     UINT32                  LineNumber);
976 
977 void
978 FlSetFilename (
979     char                    *Filename);
980 
981 ACPI_STATUS
982 FlOpenInputFile (
983     char                    *InputFilename);
984 
985 ACPI_STATUS
986 FlOpenAmlOutputFile (
987     char                    *InputFilename);
988 
989 ACPI_STATUS
990 FlOpenMiscOutputFiles (
991     char                    *InputFilename);
992 
993 ACPI_STATUS
994 FlInitOneFile (
995     char                    *InputFilename);
996 
997 ASL_FILE_SWITCH_STATUS
998 FlSwitchFileSet (
999     char                    *InputFilename);
1000 
1001 FILE *
1002 FlGetFileHandle (
1003     UINT32                  OutFileId,
1004     UINT32                  InFileId,
1005     char                    *Filename);
1006 
1007 ASL_GLOBAL_FILE_NODE *
1008 FlGetFileNode (
1009     UINT32                  FileId,
1010     char                    *Filename);
1011 
1012 ASL_GLOBAL_FILE_NODE *
1013 FlGetCurrentFileNode (
1014     void);
1015 
1016 
1017 /*
1018  * aslhwmap - hardware map summary
1019  */
1020 void
1021 MpEmitMappingInfo (
1022     void);
1023 
1024 
1025 /*
1026  * asload - load namespace in prep for cross reference
1027  */
1028 ACPI_STATUS
1029 LdLoadNamespace (
1030     ACPI_PARSE_OBJECT       *RootOp);
1031 
1032 /*
1033  * asllookup - namespace lookup functions
1034  */
1035 void
1036 LkFindUnreferencedObjects (
1037     void);
1038 
1039 
1040 /*
1041  * aslhelp - help screens
1042  */
1043 void
1044 Usage (
1045     void);
1046 
1047 void
1048 AslFilenameHelp (
1049     void);
1050 
1051 void
1052 AslDisassemblyHelp (
1053     void);
1054 
1055 
1056 /*
1057  * aslnamesp - namespace output file generation
1058  */
1059 ACPI_STATUS
1060 NsDisplayNamespace (
1061     void);
1062 
1063 void
1064 NsSetupNamespaceListing (
1065     void                    *Handle);
1066 
1067 
1068 /*
1069  * asloptions - command line processing
1070  */
1071 int
1072 AslCommandLine (
1073     int                     argc,
1074     char                    **argv);
1075 
1076 
1077 /*
1078  * aslxref - namespace cross reference
1079  */
1080 ACPI_STATUS
1081 XfCrossReferenceNamespace (
1082     void);
1083 
1084 
1085 /*
1086  * aslxrefout
1087  */
1088 void
1089 OtPrintHeaders (
1090     char                    *Message);
1091 
1092 void
1093 OtCreateXrefFile (
1094     void);
1095 
1096 void
1097 OtXrefWalkPart1 (
1098     ACPI_PARSE_OBJECT       *Op,
1099     UINT32                  Level,
1100     ASL_METHOD_INFO         *MethodInfo);
1101 
1102 
1103 /*
1104  * aslutils - common compiler utilities
1105  */
1106 ACPI_PRINTF_LIKE(2)
1107 void
1108 DbgPrint (
1109     UINT32                  Type,
1110     char                    *Format,
1111     ...);
1112 
1113 /* Type values for above */
1114 
1115 #define ASL_DEBUG_OUTPUT    0
1116 #define ASL_PARSE_OUTPUT    1
1117 #define ASL_TREE_OUTPUT     2
1118 
1119 BOOLEAN
1120 UtIsIdInteger (
1121     UINT8                   *Target);
1122 
1123 UINT8
1124 UtIsBigEndianMachine (
1125     void);
1126 
1127 BOOLEAN
1128 UtQueryForOverwrite (
1129     char                    *Pathname);
1130 
1131 void
1132 UtDumpStringOp (
1133     ACPI_PARSE_OBJECT       *Op,
1134     UINT32                  Level);
1135 
1136 void
1137 UtDumpIntegerOp (
1138     ACPI_PARSE_OBJECT       *Op,
1139     UINT32                  Level,
1140     UINT32                  IntegerLength);
1141 
1142 void
1143 UtDumpBasicOp (
1144     ACPI_PARSE_OBJECT       *Op,
1145     UINT32                  Level);
1146 
1147 ACPI_NAMESPACE_NODE *
1148 UtGetParentMethodNode (
1149     ACPI_NAMESPACE_NODE     *Node);
1150 
1151 ACPI_PARSE_OBJECT *
1152 UtGetParentMethodOp (
1153     ACPI_PARSE_OBJECT       *Op);
1154 
1155 BOOLEAN
1156 UtNodeIsDescendantOf (
1157     ACPI_NAMESPACE_NODE     *Node1,
1158     ACPI_NAMESPACE_NODE     *Node2);
1159 
1160 void
1161 UtDisplaySupportedTables (
1162     void);
1163 
1164 void
1165 UtDisplayConstantOpcodes (
1166     void);
1167 
1168 UINT8
1169 UtBeginEvent (
1170     char                    *Name);
1171 
1172 void
1173 UtEndEvent (
1174     UINT8                   Event);
1175 
1176 void
1177 UtDisplaySummary (
1178     UINT32                  FileId);
1179 
1180 void
1181 UtDisplayOneSummary (
1182     UINT32                  FileId,
1183     BOOLEAN                 DisplayErrorSummary);
1184 
1185 void
1186 UtConvertByteToHex (
1187     UINT8                   RawByte,
1188     UINT8                   *Buffer);
1189 
1190 void
1191 UtConvertByteToAsmHex (
1192     UINT8                   RawByte,
1193     UINT8                   *Buffer);
1194 
1195 char *
1196 UtGetOpName (
1197     UINT32                  ParseOpcode);
1198 
1199 void
1200 UtSetParseOpName (
1201     ACPI_PARSE_OBJECT       *Op);
1202 
1203 ACPI_STATUS
1204 UtInternalizeName (
1205     char                    *ExternalName,
1206     char                    **ConvertedName);
1207 
1208 BOOLEAN
1209 UtNameContainsAllPrefix (
1210     ACPI_PARSE_OBJECT       *Op);
1211 
1212 void
1213 UtAttachNamepathToOwner (
1214     ACPI_PARSE_OBJECT       *Op,
1215     ACPI_PARSE_OBJECT       *NameNode);
1216 
1217 ACPI_PARSE_OBJECT *
1218 UtCheckIntegerRange (
1219     ACPI_PARSE_OBJECT       *Op,
1220     UINT32                  LowValue,
1221     UINT32                  HighValue);
1222 
1223 UINT64
1224 UtDoConstant (
1225     char                    *String);
1226 
1227 char *
1228 AcpiUtStrdup (
1229     char                    *String);
1230 
1231 char *
1232 AcpiUtStrcat (
1233     char                    *String1,
1234     char                    *String2);
1235 
1236 
1237 /*
1238  * asluuid - UUID support
1239  */
1240 ACPI_STATUS
1241 AuValidateUuid (
1242     char                    *InString);
1243 
1244 ACPI_STATUS
1245 AuConvertUuidToString (
1246     char                    *UuIdBuffer,
1247     char                    *OutString);
1248 
1249 
1250 /*
1251  * aslresource - Resource template generation utilities
1252  */
1253 void
1254 RsSmallAddressCheck (
1255     UINT8                   Type,
1256     UINT32                  Minimum,
1257     UINT32                  Maximum,
1258     UINT32                  Length,
1259     UINT32                  Alignment,
1260     ACPI_PARSE_OBJECT       *MinOp,
1261     ACPI_PARSE_OBJECT       *MaxOp,
1262     ACPI_PARSE_OBJECT       *LengthOp,
1263     ACPI_PARSE_OBJECT       *AlignOp,
1264     ACPI_PARSE_OBJECT       *Op);
1265 
1266 void
1267 RsLargeAddressCheck (
1268     UINT64                  Minimum,
1269     UINT64                  Maximum,
1270     UINT64                  Length,
1271     UINT64                  Granularity,
1272     UINT8                   Flags,
1273     ACPI_PARSE_OBJECT       *MinOp,
1274     ACPI_PARSE_OBJECT       *MaxOp,
1275     ACPI_PARSE_OBJECT       *LengthOp,
1276     ACPI_PARSE_OBJECT       *GranOp,
1277     ACPI_PARSE_OBJECT       *Op);
1278 
1279 UINT16
1280 RsGetStringDataLength (
1281     ACPI_PARSE_OBJECT       *InitializerOp);
1282 
1283 ASL_RESOURCE_NODE *
1284 RsAllocateResourceNode (
1285     UINT32                  Size);
1286 
1287 void
1288 RsCreateResourceField (
1289     ACPI_PARSE_OBJECT       *Op,
1290     char                    *Name,
1291     UINT32                  ByteOffset,
1292     UINT32                  BitOffset,
1293     UINT32                  BitLength);
1294 
1295 void
1296 RsSetFlagBits (
1297     UINT8                   *Flags,
1298     ACPI_PARSE_OBJECT       *Op,
1299     UINT8                   Position,
1300     UINT8                   DefaultBit);
1301 
1302 void
1303 RsSetFlagBits16 (
1304     UINT16                  *Flags,
1305     ACPI_PARSE_OBJECT       *Op,
1306     UINT8                   Position,
1307     UINT8                   DefaultBit);
1308 
1309 ACPI_PARSE_OBJECT *
1310 RsCompleteNodeAndGetNext (
1311     ACPI_PARSE_OBJECT       *Op);
1312 
1313 void
1314 RsCheckListForDuplicates (
1315     ACPI_PARSE_OBJECT       *Op);
1316 
1317 ASL_RESOURCE_NODE *
1318 RsDoOneResourceDescriptor (
1319     ASL_RESOURCE_INFO       *Info,
1320     UINT8                   *State);
1321 
1322 /* Values for State above */
1323 
1324 #define ACPI_RSTATE_NORMAL              0
1325 #define ACPI_RSTATE_START_DEPENDENT     1
1326 #define ACPI_RSTATE_DEPENDENT_LIST      2
1327 
1328 UINT32
1329 RsLinkDescriptorChain (
1330     ASL_RESOURCE_NODE       **PreviousRnode,
1331     ASL_RESOURCE_NODE       *Rnode);
1332 
1333 void
1334 RsDoResourceTemplate (
1335     ACPI_PARSE_OBJECT       *Op);
1336 
1337 
1338 /*
1339  * aslrestype1 - Miscellaneous Small descriptors
1340  */
1341 ASL_RESOURCE_NODE *
1342 RsDoEndTagDescriptor (
1343     ASL_RESOURCE_INFO       *Info);
1344 
1345 ASL_RESOURCE_NODE *
1346 RsDoEndDependentDescriptor (
1347     ASL_RESOURCE_INFO       *Info);
1348 
1349 ASL_RESOURCE_NODE *
1350 RsDoMemory24Descriptor (
1351     ASL_RESOURCE_INFO       *Info);
1352 
1353 ASL_RESOURCE_NODE *
1354 RsDoMemory32Descriptor (
1355     ASL_RESOURCE_INFO       *Info);
1356 
1357 ASL_RESOURCE_NODE *
1358 RsDoMemory32FixedDescriptor (
1359     ASL_RESOURCE_INFO       *Info);
1360 
1361 ASL_RESOURCE_NODE *
1362 RsDoStartDependentDescriptor (
1363     ASL_RESOURCE_INFO       *Info);
1364 
1365 ASL_RESOURCE_NODE *
1366 RsDoStartDependentNoPriDescriptor (
1367     ASL_RESOURCE_INFO       *Info);
1368 
1369 ASL_RESOURCE_NODE *
1370 RsDoVendorSmallDescriptor (
1371     ASL_RESOURCE_INFO       *Info);
1372 
1373 
1374 /*
1375  * aslrestype1i - I/O-related Small descriptors
1376  */
1377 ASL_RESOURCE_NODE *
1378 RsDoDmaDescriptor (
1379     ASL_RESOURCE_INFO       *Info);
1380 
1381 ASL_RESOURCE_NODE *
1382 RsDoFixedDmaDescriptor (
1383     ASL_RESOURCE_INFO       *Info);
1384 
1385 ASL_RESOURCE_NODE *
1386 RsDoFixedIoDescriptor (
1387     ASL_RESOURCE_INFO       *Info);
1388 
1389 ASL_RESOURCE_NODE *
1390 RsDoIoDescriptor (
1391     ASL_RESOURCE_INFO       *Info);
1392 
1393 ASL_RESOURCE_NODE *
1394 RsDoIrqDescriptor (
1395     ASL_RESOURCE_INFO       *Info);
1396 
1397 ASL_RESOURCE_NODE *
1398 RsDoIrqNoFlagsDescriptor (
1399     ASL_RESOURCE_INFO       *Info);
1400 
1401 
1402 /*
1403  * aslrestype2 - Large resource descriptors
1404  */
1405 ASL_RESOURCE_NODE *
1406 RsDoInterruptDescriptor (
1407     ASL_RESOURCE_INFO       *Info);
1408 
1409 ASL_RESOURCE_NODE *
1410 RsDoVendorLargeDescriptor (
1411     ASL_RESOURCE_INFO       *Info);
1412 
1413 ASL_RESOURCE_NODE *
1414 RsDoGeneralRegisterDescriptor (
1415     ASL_RESOURCE_INFO       *Info);
1416 
1417 ASL_RESOURCE_NODE *
1418 RsDoGpioIntDescriptor (
1419     ASL_RESOURCE_INFO       *Info);
1420 
1421 ASL_RESOURCE_NODE *
1422 RsDoGpioIoDescriptor (
1423     ASL_RESOURCE_INFO       *Info);
1424 
1425 ASL_RESOURCE_NODE *
1426 RsDoI2cSerialBusDescriptor (
1427     ASL_RESOURCE_INFO       *Info);
1428 
1429 ASL_RESOURCE_NODE *
1430 RsDoSpiSerialBusDescriptor (
1431     ASL_RESOURCE_INFO       *Info);
1432 
1433 ASL_RESOURCE_NODE *
1434 RsDoUartSerialBusDescriptor (
1435     ASL_RESOURCE_INFO       *Info);
1436 
1437 ASL_RESOURCE_NODE *
1438 RsDoCsi2SerialBusDescriptor (
1439     ASL_RESOURCE_INFO       *Info);
1440 
1441 ASL_RESOURCE_NODE *
1442 RsDoPinFunctionDescriptor (
1443     ASL_RESOURCE_INFO       *Info);
1444 
1445 ASL_RESOURCE_NODE *
1446 RsDoPinConfigDescriptor (
1447     ASL_RESOURCE_INFO       *Info);
1448 
1449 ASL_RESOURCE_NODE *
1450 RsDoPinGroupDescriptor (
1451     ASL_RESOURCE_INFO       *Info);
1452 
1453 ASL_RESOURCE_NODE *
1454 RsDoPinGroupFunctionDescriptor (
1455     ASL_RESOURCE_INFO       *Info);
1456 
1457 ASL_RESOURCE_NODE *
1458 RsDoPinGroupConfigDescriptor (
1459     ASL_RESOURCE_INFO       *Info);
1460 
1461 
1462 /*
1463  * aslrestype2d - DWord address descriptors
1464  */
1465 ASL_RESOURCE_NODE *
1466 RsDoDwordIoDescriptor (
1467     ASL_RESOURCE_INFO       *Info);
1468 
1469 ASL_RESOURCE_NODE *
1470 RsDoDwordMemoryDescriptor (
1471     ASL_RESOURCE_INFO       *Info);
1472 
1473 ASL_RESOURCE_NODE *
1474 RsDoDwordSpaceDescriptor (
1475     ASL_RESOURCE_INFO       *Info);
1476 
1477 
1478 /*
1479  * aslrestype2e - Extended address descriptors
1480  */
1481 ASL_RESOURCE_NODE *
1482 RsDoExtendedIoDescriptor (
1483     ASL_RESOURCE_INFO       *Info);
1484 
1485 ASL_RESOURCE_NODE *
1486 RsDoExtendedMemoryDescriptor (
1487     ASL_RESOURCE_INFO       *Info);
1488 
1489 ASL_RESOURCE_NODE *
1490 RsDoExtendedSpaceDescriptor (
1491     ASL_RESOURCE_INFO       *Info);
1492 
1493 
1494 /*
1495  * aslrestype2q - QWord address descriptors
1496  */
1497 ASL_RESOURCE_NODE *
1498 RsDoQwordIoDescriptor (
1499     ASL_RESOURCE_INFO       *Info);
1500 
1501 ASL_RESOURCE_NODE *
1502 RsDoQwordMemoryDescriptor (
1503     ASL_RESOURCE_INFO       *Info);
1504 
1505 ASL_RESOURCE_NODE *
1506 RsDoQwordSpaceDescriptor (
1507     ASL_RESOURCE_INFO       *Info);
1508 
1509 
1510 /*
1511  * aslrestype2w - Word address descriptors
1512  */
1513 ASL_RESOURCE_NODE *
1514 RsDoWordIoDescriptor (
1515     ASL_RESOURCE_INFO       *Info);
1516 
1517 ASL_RESOURCE_NODE *
1518 RsDoWordSpaceDescriptor (
1519     ASL_RESOURCE_INFO       *Info);
1520 
1521 ASL_RESOURCE_NODE *
1522 RsDoWordBusNumberDescriptor (
1523     ASL_RESOURCE_INFO       *Info);
1524 
1525 
1526 /*
1527  * Entry to data table compiler subsystem
1528  */
1529 ACPI_STATUS
1530 DtDoCompile(
1531     void);
1532 
1533 ACPI_STATUS
1534 DtCreateTemplates (
1535     char                    **argv);
1536 
1537 
1538 /*
1539  * ASL/ASL+ converter debug
1540  */
1541 ACPI_PRINTF_LIKE (1)
1542 void
1543 CvDbgPrint (
1544     char                    *Fmt,
1545     ...);
1546 
1547 
1548 #endif /*  __ASLCOMPILER_H */
1549