xref: /freebsd/sys/contrib/dev/acpica/compiler/aslcompiler.h (revision fa50a3552d1e759e1bb65e54cb0b7e863bcf54d5)
1 /******************************************************************************
2  *
3  * Module Name: aslcompiler.h - common include file for iASL
4  *
5  *****************************************************************************/
6 
7 /******************************************************************************
8  *
9  * 1. Copyright Notice
10  *
11  * Some or all of this work - Copyright (c) 1999 - 2019, Intel Corp.
12  * All rights reserved.
13  *
14  * 2. License
15  *
16  * 2.1. This is your license from Intel Corp. under its intellectual property
17  * rights. You may have additional license terms from the party that provided
18  * you this software, covering your right to use that party's intellectual
19  * property rights.
20  *
21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22  * copy of the source code appearing in this file ("Covered Code") an
23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24  * base code distributed originally by Intel ("Original Intel Code") to copy,
25  * make derivatives, distribute, use and display any portion of the Covered
26  * Code in any form, with the right to sublicense such rights; and
27  *
28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29  * license (with the right to sublicense), under only those claims of Intel
30  * patents that are infringed by the Original Intel Code, to make, use, sell,
31  * offer to sell, and import the Covered Code and derivative works thereof
32  * solely to the minimum extent necessary to exercise the above copyright
33  * license, and in no event shall the patent license extend to any additions
34  * to or modifications of the Original Intel Code. No other license or right
35  * is granted directly or by implication, estoppel or otherwise;
36  *
37  * The above copyright and patent license is granted only if the following
38  * conditions are met:
39  *
40  * 3. Conditions
41  *
42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43  * Redistribution of source code of any substantial portion of the Covered
44  * Code or modification with rights to further distribute source must include
45  * the above Copyright Notice, the above License, this list of Conditions,
46  * and the following Disclaimer and Export Compliance provision. In addition,
47  * Licensee must cause all Covered Code to which Licensee contributes to
48  * contain a file documenting the changes Licensee made to create that Covered
49  * Code and the date of any change. Licensee must include in that file the
50  * documentation of any changes made by any predecessor Licensee. Licensee
51  * must include a prominent statement that the modification is derived,
52  * directly or indirectly, from Original Intel Code.
53  *
54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55  * Redistribution of source code of any substantial portion of the Covered
56  * Code or modification without rights to further distribute source must
57  * include the following Disclaimer and Export Compliance provision in the
58  * documentation and/or other materials provided with distribution. In
59  * addition, Licensee may not authorize further sublicense of source of any
60  * portion of the Covered Code, and must include terms to the effect that the
61  * license from Licensee to its licensee is limited to the intellectual
62  * property embodied in the software Licensee provides to its licensee, and
63  * not to intellectual property embodied in modifications its licensee may
64  * make.
65  *
66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
67  * substantial portion of the Covered Code or modification must reproduce the
68  * above Copyright Notice, and the following Disclaimer and Export Compliance
69  * provision in the documentation and/or other materials provided with the
70  * distribution.
71  *
72  * 3.4. Intel retains all right, title, and interest in and to the Original
73  * Intel Code.
74  *
75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76  * Intel shall be used in advertising or otherwise to promote the sale, use or
77  * other dealings in products derived from or relating to the Covered Code
78  * without prior written authorization from Intel.
79  *
80  * 4. Disclaimer and Export Compliance
81  *
82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88  * PARTICULAR PURPOSE.
89  *
90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97  * LIMITED REMEDY.
98  *
99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
100  * software or system incorporating such software without first obtaining any
101  * required license or other approval from the U. S. Department of Commerce or
102  * any other agency or department of the United States Government. In the
103  * event Licensee exports any such software from the United States or
104  * re-exports any such software from a foreign destination, Licensee shall
105  * ensure that the distribution and export/re-export of the software is in
106  * compliance with all laws, regulations, orders, or other restrictions of the
107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108  * any of its subsidiaries will export/re-export any technical data, process,
109  * software, or service, directly or indirectly, to any country for which the
110  * United States government or any agency thereof requires an export license,
111  * other governmental approval, or letter of assurance, without first obtaining
112  * such license, approval or letter.
113  *
114  *****************************************************************************
115  *
116  * Alternatively, you may choose to be licensed under the terms of the
117  * following license:
118  *
119  * Redistribution and use in source and binary forms, with or without
120  * modification, are permitted provided that the following conditions
121  * are met:
122  * 1. Redistributions of source code must retain the above copyright
123  *    notice, this list of conditions, and the following disclaimer,
124  *    without modification.
125  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126  *    substantially similar to the "NO WARRANTY" disclaimer below
127  *    ("Disclaimer") and any redistribution must be conditioned upon
128  *    including a substantially similar Disclaimer requirement for further
129  *    binary redistribution.
130  * 3. Neither the names of the above-listed copyright holders nor the names
131  *    of any contributors may be used to endorse or promote products derived
132  *    from this software without specific prior written permission.
133  *
134  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145  *
146  * Alternatively, you may choose to be licensed under the terms of the
147  * GNU General Public License ("GPL") version 2 as published by the Free
148  * Software Foundation.
149  *
150  *****************************************************************************/
151 
152 #ifndef __ASLCOMPILER_H
153 #define __ASLCOMPILER_H
154 
155 #include <contrib/dev/acpica/include/acpi.h>
156 #include <contrib/dev/acpica/include/accommon.h>
157 #include <contrib/dev/acpica/include/amlresrc.h>
158 #include <contrib/dev/acpica/include/acdebug.h>
159 
160 /* Microsoft-specific */
161 
162 #if (defined WIN32 || defined WIN64)
163 
164 /* warn : used #pragma pack */
165 #pragma warning(disable:4103)
166 
167 /* warn : named type definition in parentheses */
168 #pragma warning(disable:4115)
169 #endif
170 
171 #include <stdio.h>
172 #include <stdlib.h>
173 #include <string.h>
174 #include <errno.h>
175 #include <ctype.h>
176 
177 /* Compiler headers */
178 
179 #include <contrib/dev/acpica/compiler/asldefine.h>
180 #include <contrib/dev/acpica/compiler/asltypes.h>
181 #include <contrib/dev/acpica/compiler/aslmessages.h>
182 #include <contrib/dev/acpica/compiler/aslglobal.h>
183 #include <contrib/dev/acpica/compiler/preprocess.h>
184 #include <contrib/dev/acpica/compiler/dtcompiler.h>
185 
186 
187 /*******************************************************************************
188  *
189  * Compiler prototypes
190  *
191  ******************************************************************************/
192 
193 /*
194  * Main ASL parser - generated from flex/bison, lex/yacc, etc.
195  */
196 ACPI_PARSE_OBJECT *
197 AslDoError (
198     void);
199 
200 int
201 AslCompilerlex(
202     void);
203 
204 void
205 AslResetCurrentLineBuffer (
206     void);
207 
208 void
209 AslInsertLineBuffer (
210     int                     SourceChar);
211 
212 int
213 AslPopInputFileStack (
214     void);
215 
216 void
217 AslPushInputFileStack (
218     FILE                    *InputFile,
219     char                    *Filename);
220 
221 void
222 AslParserCleanup (
223     void);
224 
225 
226 /*
227  * aslstartup - entered from main()
228  */
229 void
230 AslInitializeGlobals (
231     void);
232 
233 typedef
234 ACPI_STATUS (*ASL_PATHNAME_CALLBACK) (
235     char *);
236 
237 ACPI_STATUS
238 AslDoOneFile (
239     char                    *Filename);
240 
241 ACPI_STATUS
242 AslCheckForErrorExit (
243     void);
244 
245 
246 /*
247  * aslcompile - compile mainline
248  */
249 void
250 AslCompilerSignon (
251     UINT32                  FileId);
252 
253 void
254 AslCompilerFileHeader (
255     UINT32                  FileId);
256 
257 int
258 CmDoCompile (
259     void);
260 
261 void
262 CmDoOutputFiles (
263     void);
264 
265 void
266 CmCleanupAndExit (
267     void);
268 
269 
270 /*
271  * aslallocate - memory allocation
272  */
273 void *
274 UtLocalCalloc (
275     UINT32                  Size);
276 
277 void
278 UtExpandLineBuffers (
279     void);
280 
281 void
282 UtReallocLineBuffers (
283     char                    **Buffer,
284     UINT32                  OldSize,
285     UINT32                  NewSize);
286 
287 void
288 UtFreeLineBuffers (
289     void);
290 
291 
292 /*
293  * aslcache - local cache support
294  */
295 char *
296 UtLocalCacheCalloc (
297     UINT32                  Length);
298 
299 ACPI_PARSE_OBJECT *
300 UtParseOpCacheCalloc (
301     void);
302 
303 DT_SUBTABLE *
304 UtSubtableCacheCalloc (
305     void);
306 
307 DT_FIELD *
308 UtFieldCacheCalloc (
309     void);
310 
311 void
312 UtDeleteLocalCaches (
313     void);
314 
315 
316 /*
317  * aslascii - ascii support
318  */
319 ACPI_STATUS
320 FlIsFileAsciiSource (
321     char                    *Filename,
322     BOOLEAN                 DisplayErrors);
323 
324 
325 /*
326  * aslwalks - semantic analysis and parse tree walks
327  */
328 ACPI_STATUS
329 AnOtherSemanticAnalysisWalkBegin (
330     ACPI_PARSE_OBJECT       *Op,
331     UINT32                  Level,
332     void                    *Context);
333 
334 ACPI_STATUS
335 AnOtherSemanticAnalysisWalkEnd (
336     ACPI_PARSE_OBJECT       *Op,
337     UINT32                  Level,
338     void                    *Context);
339 
340 ACPI_STATUS
341 AnOperandTypecheckWalkEnd (
342     ACPI_PARSE_OBJECT       *Op,
343     UINT32                  Level,
344     void                    *Context);
345 
346 ACPI_STATUS
347 AnMethodTypingWalkEnd (
348     ACPI_PARSE_OBJECT       *Op,
349     UINT32                  Level,
350     void                    *Context);
351 
352 
353 /*
354  * aslmethod - Control method analysis walk
355  */
356 ACPI_STATUS
357 MtMethodAnalysisWalkBegin (
358     ACPI_PARSE_OBJECT       *Op,
359     UINT32                  Level,
360     void                    *Context);
361 
362 ACPI_STATUS
363 MtMethodAnalysisWalkEnd (
364     ACPI_PARSE_OBJECT       *Op,
365     UINT32                  Level,
366     void                    *Context);
367 
368 
369 /*
370  * aslbtypes - bitfield data types
371  */
372 UINT32
373 AnMapObjTypeToBtype (
374     ACPI_PARSE_OBJECT       *Op);
375 
376 UINT32
377 AnMapArgTypeToBtype (
378     UINT32                  ArgType);
379 
380 UINT32
381 AnGetBtype (
382     ACPI_PARSE_OBJECT       *Op);
383 
384 void
385 AnFormatBtype (
386     char                    *Buffer,
387     UINT32                  Btype);
388 
389 
390 /*
391  * aslanalyze - Support functions for parse tree walks
392  */
393 void
394 AnCheckId (
395     ACPI_PARSE_OBJECT       *Op,
396     ACPI_NAME               Type);
397 
398 /* Values for Type argument above */
399 
400 #define ASL_TYPE_HID        0
401 #define ASL_TYPE_CID        1
402 
403 BOOLEAN
404 AnIsInternalMethod (
405     ACPI_PARSE_OBJECT       *Op);
406 
407 UINT32
408 AnGetInternalMethodReturnType (
409     ACPI_PARSE_OBJECT       *Op);
410 
411 BOOLEAN
412 AnLastStatementIsReturn (
413     ACPI_PARSE_OBJECT       *Op);
414 
415 void
416 AnCheckMethodReturnValue (
417     ACPI_PARSE_OBJECT       *Op,
418     const ACPI_OPCODE_INFO  *OpInfo,
419     ACPI_PARSE_OBJECT       *ArgOp,
420     UINT32                  RequiredBtypes,
421     UINT32                  ThisNodeBtype);
422 
423 BOOLEAN
424 AnIsResultUsed (
425     ACPI_PARSE_OBJECT       *Op);
426 
427 void
428 ApCheckForGpeNameConflict (
429     ACPI_PARSE_OBJECT       *Op);
430 
431 void
432 ApCheckRegMethod (
433     ACPI_PARSE_OBJECT       *Op);
434 
435 BOOLEAN
436 ApFindNameInScope (
437     char                    *Name,
438     ACPI_PARSE_OBJECT       *Op);
439 
440 BOOLEAN
441 ApFindNameInDeviceTree (
442     char                    *Name,
443     ACPI_PARSE_OBJECT       *Op);
444 
445 /*
446  * aslerror - error handling/reporting
447  */
448 void
449 AslAbort (
450     void);
451 
452 void
453 AslDualParseOpError (
454     UINT8                   Level,
455     UINT16                  MainMessageId,
456     ACPI_PARSE_OBJECT       *MainOp,
457     char                    *MainMessage,
458     UINT16                  SecondMessageId,
459     ACPI_PARSE_OBJECT       *SecondOp,
460     char                    *SecondaryMessage);
461 
462 void
463 AslError (
464     UINT8                   Level,
465     UINT16                  MessageId,
466     ACPI_PARSE_OBJECT       *Op,
467     char                    *ExtraMessage);
468 
469 void
470 AslCheckExpectedExceptions (
471     void);
472 
473 ACPI_STATUS
474 AslExpectException (
475     char                    *MessageIdString);
476 
477 ACPI_STATUS
478 AslElevateException (
479     char                    *MessageIdString);
480 
481 ACPI_STATUS
482 AslDisableException (
483     char                    *MessageIdString);
484 
485 BOOLEAN
486 AslIsExceptionIgnored (
487     UINT8                   Level,
488     UINT16                  MessageId);
489 
490 void
491 AslCoreSubsystemError (
492     ACPI_PARSE_OBJECT       *Op,
493     ACPI_STATUS             Status,
494     char                    *ExtraMessage,
495     BOOLEAN                 Abort);
496 
497 int
498 AslCompilererror(
499     const char              *s);
500 
501 void
502 AslCommonError (
503     UINT8                   Level,
504     UINT16                  MessageId,
505     UINT32                  CurrentLineNumber,
506     UINT32                  LogicalLineNumber,
507     UINT32                  LogicalByteOffset,
508     UINT32                  Column,
509     char                    *Filename,
510     char                    *ExtraMessage);
511 
512 void
513 AslCommonError2 (
514     UINT8                   Level,
515     UINT16                  MessageId,
516     UINT32                  LineNumber,
517     UINT32                  Column,
518     char                    *SourceLine,
519     char                    *Filename,
520     char                    *ExtraMessage);
521 
522 void
523 AePrintException (
524     UINT32                  FileId,
525     ASL_ERROR_MSG           *Enode,
526     char                    *Header);
527 
528 void
529 AePrintErrorLog (
530     UINT32                  FileId);
531 
532 void
533 AeClearErrorLog (
534     void);
535 
536 
537 /*
538  * asllisting - generate all "listing" type files
539  */
540 void
541 LsDoListings (
542     void);
543 
544 void
545 LsWriteNodeToAsmListing (
546     ACPI_PARSE_OBJECT       *Op);
547 
548 void
549 LsWriteNode (
550     ACPI_PARSE_OBJECT       *Op,
551     UINT32                  FileId);
552 
553 void
554 LsDumpParseTree (
555     void);
556 
557 
558 /*
559  * asllistsup - Listing file support utilities
560  */
561 void
562 LsDumpAscii (
563     UINT32                  FileId,
564     UINT32                  Count,
565     UINT8                   *Buffer);
566 
567 void
568 LsDumpAsciiInComment (
569     UINT32                  FileId,
570     UINT32                  Count,
571     UINT8                   *Buffer);
572 
573 void
574 LsCheckException (
575     UINT32                  LineNumber,
576     UINT32                  FileId);
577 
578 void
579 LsFlushListingBuffer (
580     UINT32                  FileId);
581 
582 void
583 LsWriteListingHexBytes (
584     UINT8                   *Buffer,
585     UINT32                  Length,
586     UINT32                  FileId);
587 
588 void
589 LsWriteSourceLines (
590     UINT32                  ToLineNumber,
591     UINT32                  ToLogicalLineNumber,
592     UINT32                  FileId);
593 
594 UINT32
595 LsWriteOneSourceLine (
596     UINT32                  FileId);
597 
598 void
599 LsPushNode (
600     char                    *Filename);
601 
602 ASL_LISTING_NODE *
603 LsPopNode (
604     void);
605 
606 
607 /*
608  * aslhex - generate all "hex" output files (C, ASM, ASL)
609  */
610 void
611 HxDoHexOutput (
612     void);
613 
614 
615 /*
616  * aslfold - constant folding
617  */
618 ACPI_STATUS
619 OpcAmlConstantWalk (
620     ACPI_PARSE_OBJECT       *Op,
621     UINT32                  Level,
622     void                    *Context);
623 
624 
625 /*
626  * aslmessages - exception strings
627  */
628 const char *
629 AeDecodeMessageId (
630     UINT16                  MessageId);
631 
632 const char *
633 AeDecodeExceptionLevel (
634     UINT8                   Level);
635 
636 UINT16
637 AeBuildFullExceptionCode (
638     UINT8                   Level,
639     UINT16                  MessageId);
640 
641 /*
642  * asloffset - generate C offset file for BIOS support
643  */
644 ACPI_STATUS
645 LsAmlOffsetWalk (
646     ACPI_PARSE_OBJECT       *Op,
647     UINT32                  Level,
648     void                    *Context);
649 
650 void
651 LsDoOffsetTableHeader (
652     UINT32                  FileId);
653 
654 void
655 LsDoOffsetTableFooter (
656     UINT32                  FileId);
657 
658 
659 /*
660  * aslopcodes - generate AML opcodes
661  */
662 ACPI_STATUS
663 OpcAmlOpcodeWalk (
664     ACPI_PARSE_OBJECT       *Op,
665     UINT32                  Level,
666     void                    *Context);
667 
668 ACPI_STATUS
669 OpcAmlOpcodeUpdateWalk (
670     ACPI_PARSE_OBJECT       *Op,
671     UINT32                  Level,
672     void                    *Context);
673 
674 void
675 OpcGenerateAmlOpcode (
676     ACPI_PARSE_OBJECT       *Op);
677 
678 UINT32
679 OpcSetOptimalIntegerSize (
680     ACPI_PARSE_OBJECT       *Op);
681 
682 void
683 OpcGetIntegerWidth (
684     ACPI_PARSE_OBJECT       *Op);
685 
686 
687 /*
688  * asloperands - generate AML operands for the AML opcodes
689  */
690 ACPI_PARSE_OBJECT  *
691 UtGetArg (
692     ACPI_PARSE_OBJECT       *Op,
693     UINT32                  Argn);
694 
695 void
696 OpnGenerateAmlOperands (
697     ACPI_PARSE_OBJECT       *Op);
698 
699 void
700 OpnDoPackage (
701     ACPI_PARSE_OBJECT       *Op);
702 
703 
704 /*
705  * aslopt - optmization
706  */
707 void
708 OptOptimizeNamePath (
709     ACPI_PARSE_OBJECT       *Op,
710     UINT32                  Flags,
711     ACPI_WALK_STATE         *WalkState,
712     char                    *AmlNameString,
713     ACPI_NAMESPACE_NODE     *TargetNode);
714 
715 
716 /*
717  * aslpld - ToPLD macro support
718  */
719 void
720 OpcDoPld (
721     ACPI_PARSE_OBJECT       *Op);
722 
723 
724 /*
725  * aslprintf - Printf/Fprintf macros
726  */
727 void
728 OpcDoPrintf (
729     ACPI_PARSE_OBJECT       *Op);
730 
731 void
732 OpcDoFprintf (
733     ACPI_PARSE_OBJECT       *Op);
734 
735 
736 /*
737  * aslprune - parse tree pruner
738  */
739 void
740 AslPruneParseTree (
741     UINT32                  PruneDepth,
742     UINT32                  Type);
743 
744 
745 /*
746  * aslcodegen - code generation
747  */
748 void
749 CgGenerateAmlOutput (
750     void);
751 
752 void
753 CgLocalWriteAmlData (
754     ACPI_PARSE_OBJECT       *Op,
755     void                    *Buffer,
756     UINT32                  Length);
757 
758 
759 /*
760  * aslfile
761  */
762 void
763 FlOpenFile (
764     UINT32                  FileId,
765     char                    *Filename,
766     char                    *Mode);
767 
768 
769 /*
770  * asllength - calculate/adjust AML package lengths
771  */
772 ACPI_STATUS
773 LnPackageLengthWalk (
774     ACPI_PARSE_OBJECT       *Op,
775     UINT32                  Level,
776     void                    *Context);
777 
778 ACPI_STATUS
779 LnInitLengthsWalk (
780     ACPI_PARSE_OBJECT       *Op,
781     UINT32                  Level,
782     void                    *Context);
783 
784 void
785 CgGenerateAmlLengths (
786     ACPI_PARSE_OBJECT       *Op);
787 
788 
789 /*
790  * aslmap - opcode mappings and reserved method names
791  */
792 ACPI_OBJECT_TYPE
793 AslMapNamedOpcodeToDataType (
794     UINT16                  Opcode);
795 
796 
797 /*
798  * aslpredef - ACPI predefined names support
799  */
800 BOOLEAN
801 ApCheckForPredefinedMethod (
802     ACPI_PARSE_OBJECT       *Op,
803     ASL_METHOD_INFO         *MethodInfo);
804 
805 void
806 ApCheckPredefinedReturnValue (
807     ACPI_PARSE_OBJECT       *Op,
808     ASL_METHOD_INFO         *MethodInfo);
809 
810 UINT32
811 ApCheckForPredefinedName (
812     ACPI_PARSE_OBJECT       *Op,
813     char                    *Name);
814 
815 void
816 ApCheckForPredefinedObject (
817     ACPI_PARSE_OBJECT       *Op,
818     char                    *Name);
819 
820 ACPI_STATUS
821 ApCheckObjectType (
822     const char              *PredefinedName,
823     ACPI_PARSE_OBJECT       *Op,
824     UINT32                  ExpectedBtypes,
825     UINT32                  PackageIndex);
826 
827 void
828 ApDisplayReservedNames (
829     void);
830 
831 
832 /*
833  * aslprepkg - ACPI predefined names support for packages
834  */
835 void
836 ApCheckPackage (
837     ACPI_PARSE_OBJECT           *ParentOp,
838     const ACPI_PREDEFINED_INFO  *Predefined);
839 
840 
841 /*
842  * asltransform - parse tree transformations
843  */
844 ACPI_STATUS
845 TrAmlTransformWalkBegin (
846     ACPI_PARSE_OBJECT       *Op,
847     UINT32                  Level,
848     void                    *Context);
849 
850 ACPI_STATUS
851 TrAmlTransformWalkEnd (
852     ACPI_PARSE_OBJECT       *Op,
853     UINT32                  Level,
854     void                    *Context);
855 
856 
857 /*
858  * aslexternal - External opcode support
859  */
860 ACPI_STATUS
861 ExAmlExternalWalkBegin (
862     ACPI_PARSE_OBJECT       *Op,
863     UINT32                  Level,
864     void                    *Context);
865 
866 ACPI_STATUS
867 ExAmlExternalWalkEnd (
868     ACPI_PARSE_OBJECT       *Op,
869     UINT32                  Level,
870     void                    *Context);
871 
872 void
873 ExDoExternal (
874     ACPI_PARSE_OBJECT       *Op);
875 
876 /* Values for "Visitation" parameter above */
877 
878 #define ASL_WALK_VISIT_DOWNWARD     0x01
879 #define ASL_WALK_VISIT_UPWARD       0x02
880 #define ASL_WALK_VISIT_TWICE        (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
881 
882 
883 /*
884  * aslparseop.c - Parse op create/allocate/cache
885  */
886 ACPI_PARSE_OBJECT *
887 TrCreateOp (
888     UINT32                  ParseOpcode,
889     UINT32                  NumChildren,
890     ...);
891 
892 ACPI_PARSE_OBJECT *
893 TrCreateLeafOp (
894     UINT32                  ParseOpcode);
895 
896 ACPI_PARSE_OBJECT *
897 TrCreateNullTargetOp (
898     void);
899 
900 ACPI_PARSE_OBJECT *
901 TrCreateAssignmentOp (
902     ACPI_PARSE_OBJECT       *Target,
903     ACPI_PARSE_OBJECT       *Source);
904 
905 ACPI_PARSE_OBJECT *
906 TrCreateTargetOp (
907     ACPI_PARSE_OBJECT       *OriginalOp,
908     ACPI_PARSE_OBJECT       *ParentOp);
909 
910 ACPI_PARSE_OBJECT *
911 TrCreateValuedLeafOp (
912     UINT32                  ParseOpcode,
913     UINT64                  Value);
914 
915 ACPI_PARSE_OBJECT *
916 TrCreateConstantLeafOp (
917     UINT32                  ParseOpcode);
918 
919 ACPI_PARSE_OBJECT *
920 TrAllocateOp (
921     UINT32                  ParseOpcode);
922 
923 void
924 TrPrintOpFlags (
925     UINT32                  Flags,
926     UINT32                  OutputLevel);
927 
928 
929 /*
930  * asltree.c - Parse tree management
931  */
932 void
933 TrSetOpParent (
934     ACPI_PARSE_OBJECT       *Op,
935     ACPI_PARSE_OBJECT       *ParentOp);
936 
937 ACPI_PARSE_OBJECT *
938 TrSetOpIntegerValue (
939     UINT32                  ParseOpcode,
940     ACPI_PARSE_OBJECT       *Op);
941 
942 void
943 TrSetOpEndLineNumber (
944     ACPI_PARSE_OBJECT       *Op);
945 
946 void
947 TrSetOpCurrentFilename (
948     ACPI_PARSE_OBJECT       *Op);
949 
950 void
951 TrSetOpIntegerWidth (
952     ACPI_PARSE_OBJECT       *TableSignature,
953     ACPI_PARSE_OBJECT       *Revision);
954 
955 ACPI_PARSE_OBJECT *
956 TrLinkOpChildren (
957     ACPI_PARSE_OBJECT       *Op,
958     UINT32                  NumChildren,
959     ...);
960 
961 ACPI_PARSE_OBJECT *
962 TrLinkPeerOp (
963     ACPI_PARSE_OBJECT       *Op1,
964     ACPI_PARSE_OBJECT       *Op2);
965 
966 ACPI_PARSE_OBJECT *
967 TrLinkChildOp (
968     ACPI_PARSE_OBJECT       *Op1,
969     ACPI_PARSE_OBJECT       *Op2);
970 
971 ACPI_PARSE_OBJECT *
972 TrSetOpFlags (
973     ACPI_PARSE_OBJECT       *Op,
974     UINT32                  Flags);
975 
976 ACPI_PARSE_OBJECT *
977 TrSetOpAmlLength (
978     ACPI_PARSE_OBJECT       *Op,
979     UINT32                  Length);
980 
981 ACPI_PARSE_OBJECT *
982 TrLinkPeerOps (
983     UINT32                  NumPeers,
984     ...);
985 
986 ACPI_STATUS
987 TrWalkParseTree (
988     ACPI_PARSE_OBJECT       *Op,
989     UINT32                  Visitation,
990     ASL_WALK_CALLBACK       DescendingCallback,
991     ASL_WALK_CALLBACK       AscendingCallback,
992     void                    *Context);
993 
994 
995 /*
996  * aslfiles - File I/O support
997  */
998 void
999 FlAddIncludeDirectory (
1000     char                    *Dir);
1001 
1002 char *
1003 FlMergePathnames (
1004     char                    *PrefixDir,
1005     char                    *FilePathname);
1006 
1007 void
1008 FlOpenIncludeFile (
1009     ACPI_PARSE_OBJECT       *Op);
1010 
1011 void
1012 FlFileError (
1013     UINT32                  FileId,
1014     UINT8                   ErrorId);
1015 
1016 UINT32
1017 FlGetFileSize (
1018     UINT32                  FileId);
1019 
1020 ACPI_STATUS
1021 FlReadFile (
1022     UINT32                  FileId,
1023     void                    *Buffer,
1024     UINT32                  Length);
1025 
1026 void
1027 FlWriteFile (
1028     UINT32                  FileId,
1029     void                    *Buffer,
1030     UINT32                  Length);
1031 
1032 void
1033 FlSeekFile (
1034     UINT32                  FileId,
1035     long                    Offset);
1036 
1037 void
1038 FlCloseFile (
1039     UINT32                  FileId);
1040 
1041 void
1042 FlPrintFile (
1043     UINT32                  FileId,
1044     char                    *Format,
1045     ...);
1046 
1047 void
1048 FlDeleteFile (
1049     UINT32                  FileId);
1050 
1051 void
1052 FlSetLineNumber (
1053     UINT32                  LineNumber);
1054 
1055 void
1056 FlSetFilename (
1057     char                    *Filename);
1058 
1059 ACPI_STATUS
1060 FlOpenInputFile (
1061     char                    *InputFilename);
1062 
1063 ACPI_STATUS
1064 FlOpenAmlOutputFile (
1065     char                    *InputFilename);
1066 
1067 ACPI_STATUS
1068 FlOpenMiscOutputFiles (
1069     char                    *InputFilename);
1070 
1071 /*
1072  * aslhwmap - hardware map summary
1073  */
1074 void
1075 MpEmitMappingInfo (
1076     void);
1077 
1078 
1079 /*
1080  * asload - load namespace in prep for cross reference
1081  */
1082 ACPI_STATUS
1083 LdLoadNamespace (
1084     ACPI_PARSE_OBJECT       *RootOp);
1085 
1086 
1087 /*
1088  * asllookup - namespace lookup functions
1089  */
1090 void
1091 LkFindUnreferencedObjects (
1092     void);
1093 
1094 /*
1095  * aslhelp - help screens
1096  */
1097 void
1098 Usage (
1099     void);
1100 
1101 void
1102 AslFilenameHelp (
1103     void);
1104 
1105 void
1106 AslDisassemblyHelp (
1107     void);
1108 
1109 
1110 /*
1111  * aslnamesp - namespace output file generation
1112  */
1113 ACPI_STATUS
1114 NsDisplayNamespace (
1115     void);
1116 
1117 void
1118 NsSetupNamespaceListing (
1119     void                    *Handle);
1120 
1121 /*
1122  * asloptions - command line processing
1123  */
1124 int
1125 AslCommandLine (
1126     int                     argc,
1127     char                    **argv);
1128 
1129 /*
1130  * aslxref - namespace cross reference
1131  */
1132 ACPI_STATUS
1133 XfCrossReferenceNamespace (
1134     void);
1135 
1136 
1137 /*
1138  * aslxrefout
1139  */
1140 void
1141 OtPrintHeaders (
1142     char                    *Message);
1143 
1144 void
1145 OtCreateXrefFile (
1146     void);
1147 
1148 void
1149 OtXrefWalkPart1 (
1150     ACPI_PARSE_OBJECT       *Op,
1151     UINT32                  Level,
1152     ASL_METHOD_INFO         *MethodInfo);
1153 
1154 
1155 /*
1156  * aslutils - common compiler utilites
1157  */
1158 void
1159 DbgPrint (
1160     UINT32                  Type,
1161     char                    *Format,
1162     ...);
1163 
1164 /* Type values for above */
1165 
1166 #define ASL_DEBUG_OUTPUT    0
1167 #define ASL_PARSE_OUTPUT    1
1168 #define ASL_TREE_OUTPUT     2
1169 
1170 UINT8
1171 UtIsBigEndianMachine (
1172     void);
1173 
1174 BOOLEAN
1175 UtQueryForOverwrite (
1176     char                    *Pathname);
1177 
1178 void
1179 UtDumpStringOp (
1180     ACPI_PARSE_OBJECT       *Op,
1181     UINT32                  Level);
1182 
1183 void
1184 UtDumpIntegerOp (
1185     ACPI_PARSE_OBJECT       *Op,
1186     UINT32                  Level,
1187     UINT32                  IntegerLength);
1188 
1189 void
1190 UtDumpBasicOp (
1191     ACPI_PARSE_OBJECT       *Op,
1192     UINT32                  Level);
1193 
1194 void *
1195 UtGetParentMethod (
1196     ACPI_NAMESPACE_NODE     *Node);
1197 
1198 BOOLEAN
1199 UtNodeIsDescendantOf (
1200     ACPI_NAMESPACE_NODE     *Node1,
1201     ACPI_NAMESPACE_NODE     *Node2);
1202 
1203 void
1204 UtDisplaySupportedTables (
1205     void);
1206 
1207 void
1208 UtDisplayConstantOpcodes (
1209     void);
1210 
1211 UINT8
1212 UtBeginEvent (
1213     char                    *Name);
1214 
1215 void
1216 UtEndEvent (
1217     UINT8                   Event);
1218 
1219 void
1220 UtDisplaySummary (
1221     UINT32                  FileId);
1222 
1223 void
1224 UtConvertByteToHex (
1225     UINT8                   RawByte,
1226     UINT8                   *Buffer);
1227 
1228 void
1229 UtConvertByteToAsmHex (
1230     UINT8                   RawByte,
1231     UINT8                   *Buffer);
1232 
1233 char *
1234 UtGetOpName (
1235     UINT32                  ParseOpcode);
1236 
1237 void
1238 UtSetParseOpName (
1239     ACPI_PARSE_OBJECT       *Op);
1240 
1241 ACPI_STATUS
1242 UtInternalizeName (
1243     char                    *ExternalName,
1244     char                    **ConvertedName);
1245 
1246 void
1247 UtAttachNamepathToOwner (
1248     ACPI_PARSE_OBJECT       *Op,
1249     ACPI_PARSE_OBJECT       *NameNode);
1250 
1251 ACPI_PARSE_OBJECT *
1252 UtCheckIntegerRange (
1253     ACPI_PARSE_OBJECT       *Op,
1254     UINT32                  LowValue,
1255     UINT32                  HighValue);
1256 
1257 UINT64
1258 UtDoConstant (
1259     char                    *String);
1260 
1261 
1262 /*
1263  * asluuid - UUID support
1264  */
1265 ACPI_STATUS
1266 AuValidateUuid (
1267     char                    *InString);
1268 
1269 ACPI_STATUS
1270 AuConvertUuidToString (
1271     char                    *UuIdBuffer,
1272     char                    *OutString);
1273 
1274 /*
1275  * aslresource - Resource template generation utilities
1276  */
1277 void
1278 RsSmallAddressCheck (
1279     UINT8                   Type,
1280     UINT32                  Minimum,
1281     UINT32                  Maximum,
1282     UINT32                  Length,
1283     UINT32                  Alignment,
1284     ACPI_PARSE_OBJECT       *MinOp,
1285     ACPI_PARSE_OBJECT       *MaxOp,
1286     ACPI_PARSE_OBJECT       *LengthOp,
1287     ACPI_PARSE_OBJECT       *AlignOp,
1288     ACPI_PARSE_OBJECT       *Op);
1289 
1290 void
1291 RsLargeAddressCheck (
1292     UINT64                  Minimum,
1293     UINT64                  Maximum,
1294     UINT64                  Length,
1295     UINT64                  Granularity,
1296     UINT8                   Flags,
1297     ACPI_PARSE_OBJECT       *MinOp,
1298     ACPI_PARSE_OBJECT       *MaxOp,
1299     ACPI_PARSE_OBJECT       *LengthOp,
1300     ACPI_PARSE_OBJECT       *GranOp,
1301     ACPI_PARSE_OBJECT       *Op);
1302 
1303 UINT16
1304 RsGetStringDataLength (
1305     ACPI_PARSE_OBJECT       *InitializerOp);
1306 
1307 ASL_RESOURCE_NODE *
1308 RsAllocateResourceNode (
1309     UINT32                  Size);
1310 
1311 void
1312 RsCreateResourceField (
1313     ACPI_PARSE_OBJECT       *Op,
1314     char                    *Name,
1315     UINT32                  ByteOffset,
1316     UINT32                  BitOffset,
1317     UINT32                  BitLength);
1318 
1319 void
1320 RsSetFlagBits (
1321     UINT8                   *Flags,
1322     ACPI_PARSE_OBJECT       *Op,
1323     UINT8                   Position,
1324     UINT8                   DefaultBit);
1325 
1326 void
1327 RsSetFlagBits16 (
1328     UINT16                  *Flags,
1329     ACPI_PARSE_OBJECT       *Op,
1330     UINT8                   Position,
1331     UINT8                   DefaultBit);
1332 
1333 ACPI_PARSE_OBJECT *
1334 RsCompleteNodeAndGetNext (
1335     ACPI_PARSE_OBJECT       *Op);
1336 
1337 void
1338 RsCheckListForDuplicates (
1339     ACPI_PARSE_OBJECT       *Op);
1340 
1341 ASL_RESOURCE_NODE *
1342 RsDoOneResourceDescriptor (
1343     ASL_RESOURCE_INFO       *Info,
1344     UINT8                   *State);
1345 
1346 /* Values for State above */
1347 
1348 #define ACPI_RSTATE_NORMAL              0
1349 #define ACPI_RSTATE_START_DEPENDENT     1
1350 #define ACPI_RSTATE_DEPENDENT_LIST      2
1351 
1352 UINT32
1353 RsLinkDescriptorChain (
1354     ASL_RESOURCE_NODE       **PreviousRnode,
1355     ASL_RESOURCE_NODE       *Rnode);
1356 
1357 void
1358 RsDoResourceTemplate (
1359     ACPI_PARSE_OBJECT       *Op);
1360 
1361 
1362 /*
1363  * aslrestype1 - Miscellaneous Small descriptors
1364  */
1365 ASL_RESOURCE_NODE *
1366 RsDoEndTagDescriptor (
1367     ASL_RESOURCE_INFO       *Info);
1368 
1369 ASL_RESOURCE_NODE *
1370 RsDoEndDependentDescriptor (
1371     ASL_RESOURCE_INFO       *Info);
1372 
1373 ASL_RESOURCE_NODE *
1374 RsDoMemory24Descriptor (
1375     ASL_RESOURCE_INFO       *Info);
1376 
1377 ASL_RESOURCE_NODE *
1378 RsDoMemory32Descriptor (
1379     ASL_RESOURCE_INFO       *Info);
1380 
1381 ASL_RESOURCE_NODE *
1382 RsDoMemory32FixedDescriptor (
1383     ASL_RESOURCE_INFO       *Info);
1384 
1385 ASL_RESOURCE_NODE *
1386 RsDoStartDependentDescriptor (
1387     ASL_RESOURCE_INFO       *Info);
1388 
1389 ASL_RESOURCE_NODE *
1390 RsDoStartDependentNoPriDescriptor (
1391     ASL_RESOURCE_INFO       *Info);
1392 
1393 ASL_RESOURCE_NODE *
1394 RsDoVendorSmallDescriptor (
1395     ASL_RESOURCE_INFO       *Info);
1396 
1397 
1398 /*
1399  * aslrestype1i - I/O-related Small descriptors
1400  */
1401 ASL_RESOURCE_NODE *
1402 RsDoDmaDescriptor (
1403     ASL_RESOURCE_INFO       *Info);
1404 
1405 ASL_RESOURCE_NODE *
1406 RsDoFixedDmaDescriptor (
1407     ASL_RESOURCE_INFO       *Info);
1408 
1409 ASL_RESOURCE_NODE *
1410 RsDoFixedIoDescriptor (
1411     ASL_RESOURCE_INFO       *Info);
1412 
1413 ASL_RESOURCE_NODE *
1414 RsDoIoDescriptor (
1415     ASL_RESOURCE_INFO       *Info);
1416 
1417 ASL_RESOURCE_NODE *
1418 RsDoIrqDescriptor (
1419     ASL_RESOURCE_INFO       *Info);
1420 
1421 ASL_RESOURCE_NODE *
1422 RsDoIrqNoFlagsDescriptor (
1423     ASL_RESOURCE_INFO       *Info);
1424 
1425 
1426 /*
1427  * aslrestype2 - Large resource descriptors
1428  */
1429 ASL_RESOURCE_NODE *
1430 RsDoInterruptDescriptor (
1431     ASL_RESOURCE_INFO       *Info);
1432 
1433 ASL_RESOURCE_NODE *
1434 RsDoVendorLargeDescriptor (
1435     ASL_RESOURCE_INFO       *Info);
1436 
1437 ASL_RESOURCE_NODE *
1438 RsDoGeneralRegisterDescriptor (
1439     ASL_RESOURCE_INFO       *Info);
1440 
1441 ASL_RESOURCE_NODE *
1442 RsDoGpioIntDescriptor (
1443     ASL_RESOURCE_INFO       *Info);
1444 
1445 ASL_RESOURCE_NODE *
1446 RsDoGpioIoDescriptor (
1447     ASL_RESOURCE_INFO       *Info);
1448 
1449 ASL_RESOURCE_NODE *
1450 RsDoI2cSerialBusDescriptor (
1451     ASL_RESOURCE_INFO       *Info);
1452 
1453 ASL_RESOURCE_NODE *
1454 RsDoSpiSerialBusDescriptor (
1455     ASL_RESOURCE_INFO       *Info);
1456 
1457 ASL_RESOURCE_NODE *
1458 RsDoUartSerialBusDescriptor (
1459     ASL_RESOURCE_INFO       *Info);
1460 
1461 ASL_RESOURCE_NODE *
1462 RsDoPinFunctionDescriptor (
1463     ASL_RESOURCE_INFO       *Info);
1464 
1465 ASL_RESOURCE_NODE *
1466 RsDoPinConfigDescriptor (
1467     ASL_RESOURCE_INFO       *Info);
1468 
1469 ASL_RESOURCE_NODE *
1470 RsDoPinGroupDescriptor (
1471     ASL_RESOURCE_INFO       *Info);
1472 
1473 ASL_RESOURCE_NODE *
1474 RsDoPinGroupFunctionDescriptor (
1475     ASL_RESOURCE_INFO       *Info);
1476 
1477 ASL_RESOURCE_NODE *
1478 RsDoPinGroupConfigDescriptor (
1479     ASL_RESOURCE_INFO       *Info);
1480 
1481 /*
1482  * aslrestype2d - DWord address descriptors
1483  */
1484 ASL_RESOURCE_NODE *
1485 RsDoDwordIoDescriptor (
1486     ASL_RESOURCE_INFO       *Info);
1487 
1488 ASL_RESOURCE_NODE *
1489 RsDoDwordMemoryDescriptor (
1490     ASL_RESOURCE_INFO       *Info);
1491 
1492 ASL_RESOURCE_NODE *
1493 RsDoDwordSpaceDescriptor (
1494     ASL_RESOURCE_INFO       *Info);
1495 
1496 
1497 /*
1498  * aslrestype2e - Extended address descriptors
1499  */
1500 ASL_RESOURCE_NODE *
1501 RsDoExtendedIoDescriptor (
1502     ASL_RESOURCE_INFO       *Info);
1503 
1504 ASL_RESOURCE_NODE *
1505 RsDoExtendedMemoryDescriptor (
1506     ASL_RESOURCE_INFO       *Info);
1507 
1508 ASL_RESOURCE_NODE *
1509 RsDoExtendedSpaceDescriptor (
1510     ASL_RESOURCE_INFO       *Info);
1511 
1512 
1513 /*
1514  * aslrestype2q - QWord address descriptors
1515  */
1516 ASL_RESOURCE_NODE *
1517 RsDoQwordIoDescriptor (
1518     ASL_RESOURCE_INFO       *Info);
1519 
1520 ASL_RESOURCE_NODE *
1521 RsDoQwordMemoryDescriptor (
1522     ASL_RESOURCE_INFO       *Info);
1523 
1524 ASL_RESOURCE_NODE *
1525 RsDoQwordSpaceDescriptor (
1526     ASL_RESOURCE_INFO       *Info);
1527 
1528 
1529 /*
1530  * aslrestype2w - Word address descriptors
1531  */
1532 ASL_RESOURCE_NODE *
1533 RsDoWordIoDescriptor (
1534     ASL_RESOURCE_INFO       *Info);
1535 
1536 ASL_RESOURCE_NODE *
1537 RsDoWordSpaceDescriptor (
1538     ASL_RESOURCE_INFO       *Info);
1539 
1540 ASL_RESOURCE_NODE *
1541 RsDoWordBusNumberDescriptor (
1542     ASL_RESOURCE_INFO       *Info);
1543 
1544 
1545 /*
1546  * Entry to data table compiler subsystem
1547  */
1548 ACPI_STATUS
1549 DtDoCompile(
1550     void);
1551 
1552 ACPI_STATUS
1553 DtCreateTemplates (
1554     char                    **argv);
1555 
1556 
1557 /*
1558  * ASL/ASL+ converter debug
1559  */
1560 void
1561 CvDbgPrint (
1562     char                    *Fmt,
1563     ...);
1564 
1565 
1566 #endif /*  __ASLCOMPILER_H */
1567