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