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