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