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