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