xref: /freebsd/sys/contrib/dev/acpica/compiler/aslcompile.c (revision 13ea0450a9c8742119d36f3bf8f47accdce46e54)
1 /******************************************************************************
2  *
3  * Module Name: aslcompile - top level compile module
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 #include <contrib/dev/acpica/compiler/aslcompiler.h>
153 #include <contrib/dev/acpica/include/acnamesp.h>
154 
155 #include <stdio.h>
156 #include <time.h>
157 #include <contrib/dev/acpica/include/acapps.h>
158 
159 #define _COMPONENT          ACPI_COMPILER
160         ACPI_MODULE_NAME    ("aslcompile")
161 
162 /*
163  * Main parser entry
164  * External is here in case the parser emits the same external in the
165  * generated header. (Newer versions of Bison)
166  */
167 int
168 AslCompilerparse(
169     void);
170 
171 /* Local prototypes */
172 
173 static void
174 CmFlushSourceCode (
175     void);
176 
177 static void
178 CmDumpAllEvents (
179     void);
180 
181 
182 /*******************************************************************************
183  *
184  * FUNCTION:    CmDoCompile
185  *
186  * PARAMETERS:  None
187  *
188  * RETURN:      Status (0 = OK)
189  *
190  * DESCRIPTION: This procedure performs the entire compile
191  *
192  ******************************************************************************/
193 
194 int
195 CmDoCompile (
196     void)
197 {
198     ACPI_STATUS             Status;
199     UINT8                   FullCompile;
200     UINT8                   Event;
201 
202 
203     FullCompile = UtBeginEvent ("*** Total Compile time ***");
204     Event = UtBeginEvent ("Open input and output files");
205     UtEndEvent (Event);
206 
207     Event = UtBeginEvent ("Preprocess input file");
208     if (AslGbl_PreprocessFlag)
209     {
210         /* Enter compiler name as a #define */
211 
212         PrAddDefine (ASL_DEFINE, "", FALSE);
213 
214         /* Preprocessor */
215 
216         PrDoPreprocess ();
217         AslGbl_CurrentLineNumber = 1;
218         AslGbl_LogicalLineNumber = 1;
219 
220         if (AslGbl_PreprocessOnly)
221         {
222             UtEndEvent (Event);
223             CmCleanupAndExit ();
224             return (0);
225         }
226     }
227     UtEndEvent (Event);
228 
229 
230     /* Build the parse tree */
231 
232     Event = UtBeginEvent ("Parse source code and build parse tree");
233     AslCompilerparse();
234     UtEndEvent (Event);
235 
236     /* Check for parser-detected syntax errors */
237 
238     if (AslGbl_SyntaxError)
239     {
240         fprintf (stderr,
241             "Compiler aborting due to parser-detected syntax error(s)\n");
242         LsDumpParseTree ();
243         goto ErrorExit;
244     }
245 
246     /* Did the parse tree get successfully constructed? */
247 
248     if (!AslGbl_ParseTreeRoot)
249     {
250         /*
251          * If there are no errors, then we have some sort of
252          * internal problem.
253          */
254         AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL,
255             NULL, "- Could not resolve parse tree root node");
256 
257         goto ErrorExit;
258     }
259 
260     /* Flush out any remaining source after parse tree is complete */
261 
262     Event = UtBeginEvent ("Flush source input");
263     CmFlushSourceCode ();
264 
265     /* Prune the parse tree if requested (debug purposes only) */
266 
267     if (AslGbl_PruneParseTree)
268     {
269         AslPruneParseTree (AslGbl_PruneDepth, AslGbl_PruneType);
270     }
271 
272     /* Optional parse tree dump, compiler debug output only */
273 
274     LsDumpParseTree ();
275 
276     OpcGetIntegerWidth (AslGbl_ParseTreeRoot->Asl.Child);
277     UtEndEvent (Event);
278 
279     /* Pre-process parse tree for any operator transforms */
280 
281     Event = UtBeginEvent ("Parse tree transforms");
282     DbgPrint (ASL_DEBUG_OUTPUT, "\nParse tree transforms\n\n");
283     TrWalkParseTree (AslGbl_ParseTreeRoot, ASL_WALK_VISIT_TWICE,
284         TrAmlTransformWalkBegin, TrAmlTransformWalkEnd, NULL);
285     UtEndEvent (Event);
286 
287     /* Generate AML opcodes corresponding to the parse tokens */
288 
289     Event = UtBeginEvent ("Generate AML opcodes");
290     DbgPrint (ASL_DEBUG_OUTPUT, "Generating AML opcodes\n\n");
291     TrWalkParseTree (AslGbl_ParseTreeRoot, ASL_WALK_VISIT_UPWARD, NULL,
292         OpcAmlOpcodeWalk, NULL);
293     UtEndEvent (Event);
294 
295     /*
296      * Now that the input is parsed, we can open the AML output file.
297      * Note: by default, the name of this file comes from the table
298      * descriptor within the input file.
299      */
300     Event = UtBeginEvent ("Open AML output file");
301     Status = FlOpenAmlOutputFile (AslGbl_OutputFilenamePrefix);
302     UtEndEvent (Event);
303     if (ACPI_FAILURE (Status))
304     {
305         AePrintErrorLog (ASL_FILE_STDERR);
306         return (-1);
307     }
308 
309     /* Interpret and generate all compile-time constants */
310 
311     Event = UtBeginEvent ("Constant folding via AML interpreter");
312     DbgPrint (ASL_DEBUG_OUTPUT,
313         "Interpreting compile-time constant expressions\n\n");
314 
315     if (AslGbl_FoldConstants)
316     {
317         TrWalkParseTree (AslGbl_ParseTreeRoot, ASL_WALK_VISIT_UPWARD,
318             NULL, OpcAmlConstantWalk, NULL);
319     }
320     else
321     {
322         DbgPrint (ASL_PARSE_OUTPUT, "    Optional folding disabled\n");
323     }
324     UtEndEvent (Event);
325 
326     /* Update AML opcodes if necessary, after constant folding */
327 
328     Event = UtBeginEvent ("Updating AML opcodes after constant folding");
329     DbgPrint (ASL_DEBUG_OUTPUT,
330         "Updating AML opcodes after constant folding\n\n");
331     TrWalkParseTree (AslGbl_ParseTreeRoot, ASL_WALK_VISIT_UPWARD,
332         NULL, OpcAmlOpcodeUpdateWalk, NULL);
333     UtEndEvent (Event);
334 
335     /* Calculate all AML package lengths */
336 
337     Event = UtBeginEvent ("Generate AML package lengths");
338     DbgPrint (ASL_DEBUG_OUTPUT, "Generating Package lengths\n\n");
339     TrWalkParseTree (AslGbl_ParseTreeRoot, ASL_WALK_VISIT_UPWARD, NULL,
340         LnPackageLengthWalk, NULL);
341     UtEndEvent (Event);
342 
343     if (AslGbl_ParseOnlyFlag)
344     {
345         AePrintErrorLog (ASL_FILE_STDERR);
346         UtDisplaySummary (ASL_FILE_STDERR);
347         if (AslGbl_DebugFlag)
348         {
349             /* Print error summary to the stdout also */
350 
351             AePrintErrorLog (ASL_FILE_STDOUT);
352             UtDisplaySummary (ASL_FILE_STDOUT);
353         }
354         UtEndEvent (FullCompile);
355         return (0);
356     }
357 
358     /*
359      * Create an internal namespace and use it as a symbol table
360      */
361 
362     /* Namespace loading */
363 
364     Event = UtBeginEvent ("Create ACPI Namespace");
365     DbgPrint (ASL_DEBUG_OUTPUT, "Creating ACPI Namespace\n\n");
366     Status = LdLoadNamespace (AslGbl_ParseTreeRoot);
367     UtEndEvent (Event);
368     if (ACPI_FAILURE (Status))
369     {
370         goto ErrorExit;
371     }
372 
373     /* Namespace cross-reference */
374 
375     AslGbl_NamespaceEvent = UtBeginEvent (
376         "Cross reference parse tree and Namespace");
377     DbgPrint (ASL_DEBUG_OUTPUT, "Cross referencing namespace\n\n");
378     Status = XfCrossReferenceNamespace ();
379     if (ACPI_FAILURE (Status))
380     {
381         goto ErrorExit;
382     }
383 
384     /* Namespace - Check for non-referenced objects */
385 
386     LkFindUnreferencedObjects ();
387     UtEndEvent (AslGbl_NamespaceEvent);
388 
389     /* Resolve External Declarations */
390 
391     Event = UtBeginEvent ("Resolve all Externals");
392     DbgPrint (ASL_DEBUG_OUTPUT, "\nResolve Externals\n\n");
393 
394     if (AslGbl_DoExternalsInPlace)
395     {
396         TrWalkParseTree (AslGbl_ParseTreeRoot, ASL_WALK_VISIT_DOWNWARD,
397             ExAmlExternalWalkBegin, NULL, NULL);
398     }
399     else
400     {
401         TrWalkParseTree (AslGbl_ParseTreeRoot, ASL_WALK_VISIT_TWICE,
402             ExAmlExternalWalkBegin, ExAmlExternalWalkEnd, NULL);
403     }
404     UtEndEvent (Event);
405 
406     /*
407      * Semantic analysis. This can happen only after the
408      * namespace has been loaded and cross-referenced.
409      *
410      * part one - check control methods
411      */
412     Event = UtBeginEvent ("Analyze control method return types");
413     AslGbl_AnalysisWalkInfo.MethodStack = NULL;
414 
415     DbgPrint (ASL_DEBUG_OUTPUT, "Semantic analysis - Method analysis\n\n");
416 
417     if (AslGbl_CrossReferenceOutput)
418     {
419         OtPrintHeaders ("Part 1: Object Reference Map "
420             "(Object references from within each control method)");
421     }
422 
423     TrWalkParseTree (AslGbl_ParseTreeRoot, ASL_WALK_VISIT_TWICE,
424         MtMethodAnalysisWalkBegin,
425         MtMethodAnalysisWalkEnd, &AslGbl_AnalysisWalkInfo);
426     UtEndEvent (Event);
427 
428     /* Generate the object cross-reference file if requested */
429 
430     Event = UtBeginEvent ("Generate cross-reference file");
431     OtCreateXrefFile ();
432     UtEndEvent (Event);
433 
434     /* Semantic error checking part two - typing of method returns */
435 
436     Event = UtBeginEvent ("Determine object types returned by methods");
437     DbgPrint (ASL_DEBUG_OUTPUT, "Semantic analysis - Method typing\n\n");
438     TrWalkParseTree (AslGbl_ParseTreeRoot, ASL_WALK_VISIT_UPWARD,
439         NULL, AnMethodTypingWalkEnd, NULL);
440     UtEndEvent (Event);
441 
442     /* Semantic error checking part three - operand type checking */
443 
444     Event = UtBeginEvent ("Analyze AML operand types");
445     DbgPrint (ASL_DEBUG_OUTPUT,
446         "Semantic analysis - Operand type checking\n\n");
447     if (AslGbl_DoTypechecking)
448     {
449         TrWalkParseTree (AslGbl_ParseTreeRoot, ASL_WALK_VISIT_UPWARD,
450             NULL, AnOperandTypecheckWalkEnd, &AslGbl_AnalysisWalkInfo);
451     }
452     UtEndEvent (Event);
453 
454     /* Semantic error checking part four - other miscellaneous checks */
455 
456     Event = UtBeginEvent ("Miscellaneous analysis");
457     DbgPrint (ASL_DEBUG_OUTPUT, "Semantic analysis - miscellaneous\n\n");
458     TrWalkParseTree (AslGbl_ParseTreeRoot, ASL_WALK_VISIT_DOWNWARD,
459         AnOtherSemanticAnalysisWalkBegin,
460         NULL, &AslGbl_AnalysisWalkInfo);
461     UtEndEvent (Event);
462 
463     /*
464      * ASL-/ASL+ converter: Gbl_ParseTreeRoot->CommentList contains the
465      * very last comment of a given ASL file because it's the last constructed
466      * node during compilation. We take the very last comment and save it in a
467      * global for it to be used by the disassembler.
468      */
469     if (AcpiGbl_CaptureComments)
470     {
471         AcpiGbl_LastListHead = AslGbl_ParseTreeRoot->Asl.CommentList;
472         AslGbl_ParseTreeRoot->Asl.CommentList = NULL;
473     }
474 
475     /* Calculate all AML package lengths */
476 
477     Event = UtBeginEvent ("Finish AML package length generation");
478     DbgPrint (ASL_DEBUG_OUTPUT, "Generating Package lengths\n\n");
479     TrWalkParseTree (AslGbl_ParseTreeRoot, ASL_WALK_VISIT_UPWARD, NULL,
480         LnInitLengthsWalk, NULL);
481     TrWalkParseTree (AslGbl_ParseTreeRoot, ASL_WALK_VISIT_UPWARD, NULL,
482         LnPackageLengthWalk, NULL);
483     UtEndEvent (Event);
484 
485     /* Code generation - emit the AML */
486 
487     Event = UtBeginEvent ("Generate AML code and write output files");
488     DbgPrint (ASL_DEBUG_OUTPUT, "Writing AML byte code\n\n");
489     CgGenerateAmlOutput ();
490     UtEndEvent (Event);
491 
492     Event = UtBeginEvent ("Write optional output files");
493     CmDoOutputFiles ();
494     UtEndEvent (Event);
495 
496     UtEndEvent (FullCompile);
497     AslCheckExpectedExceptions ();
498     CmCleanupAndExit ();
499     return (0);
500 
501 ErrorExit:
502     UtEndEvent (FullCompile);
503     CmCleanupAndExit ();
504     return (-1);
505 }
506 
507 
508 /*******************************************************************************
509  *
510  * FUNCTION:    AslCompilerSignon
511  *
512  * PARAMETERS:  FileId      - ID of the output file
513  *
514  * RETURN:      None
515  *
516  * DESCRIPTION: Display compiler signon
517  *
518  ******************************************************************************/
519 
520 void
521 AslCompilerSignon (
522     UINT32                  FileId)
523 {
524     char                    *Prefix = "";
525     char                    *UtilityName;
526 
527 
528     /* Set line prefix depending on the destination file type */
529 
530     switch (FileId)
531     {
532     case ASL_FILE_ASM_SOURCE_OUTPUT:
533     case ASL_FILE_ASM_INCLUDE_OUTPUT:
534 
535         Prefix = "; ";
536         break;
537 
538     case ASL_FILE_HEX_OUTPUT:
539 
540         if (AslGbl_HexOutputFlag == HEX_OUTPUT_ASM)
541         {
542             Prefix = "; ";
543         }
544         else if ((AslGbl_HexOutputFlag == HEX_OUTPUT_C) ||
545                  (AslGbl_HexOutputFlag == HEX_OUTPUT_ASL))
546         {
547             FlPrintFile (ASL_FILE_HEX_OUTPUT, "/*\n");
548             Prefix = " * ";
549         }
550         break;
551 
552     case ASL_FILE_C_SOURCE_OUTPUT:
553     case ASL_FILE_C_OFFSET_OUTPUT:
554     case ASL_FILE_C_INCLUDE_OUTPUT:
555 
556         Prefix = " * ";
557         break;
558 
559     default:
560 
561         /* No other output types supported */
562 
563         break;
564     }
565 
566     /* Running compiler or disassembler? */
567 
568     if (AcpiGbl_DisasmFlag)
569     {
570         UtilityName = AML_DISASSEMBLER_NAME;
571     }
572     else
573     {
574         UtilityName = ASL_COMPILER_NAME;
575     }
576 
577     /* Compiler signon with copyright */
578 
579     FlPrintFile (FileId, "%s\n", Prefix);
580     FlPrintFile (FileId, ACPI_COMMON_HEADER (UtilityName, Prefix));
581 }
582 
583 
584 /*******************************************************************************
585  *
586  * FUNCTION:    AslCompilerFileHeader
587  *
588  * PARAMETERS:  FileId      - ID of the output file
589  *
590  * RETURN:      None
591  *
592  * DESCRIPTION: Header used at the beginning of output files
593  *
594  ******************************************************************************/
595 
596 void
597 AslCompilerFileHeader (
598     UINT32                  FileId)
599 {
600     struct tm               *NewTime;
601     time_t                  Aclock;
602     char                    *Prefix = "";
603 
604 
605     /* Set line prefix depending on the destination file type */
606 
607     switch (FileId)
608     {
609     case ASL_FILE_ASM_SOURCE_OUTPUT:
610     case ASL_FILE_ASM_INCLUDE_OUTPUT:
611 
612         Prefix = "; ";
613         break;
614 
615     case ASL_FILE_HEX_OUTPUT:
616 
617         if (AslGbl_HexOutputFlag == HEX_OUTPUT_ASM)
618         {
619             Prefix = "; ";
620         }
621         else if ((AslGbl_HexOutputFlag == HEX_OUTPUT_C) ||
622                  (AslGbl_HexOutputFlag == HEX_OUTPUT_ASL))
623         {
624             Prefix = " * ";
625         }
626         break;
627 
628     case ASL_FILE_C_SOURCE_OUTPUT:
629     case ASL_FILE_C_OFFSET_OUTPUT:
630     case ASL_FILE_C_INCLUDE_OUTPUT:
631 
632         Prefix = " * ";
633         break;
634 
635     default:
636 
637         /* No other output types supported */
638 
639         break;
640     }
641 
642     /* Compilation header with timestamp */
643 
644     (void) time (&Aclock);
645     NewTime = localtime (&Aclock);
646 
647     FlPrintFile (FileId,
648         "%sCompilation of \"%s\" - %s%s\n",
649         Prefix, AslGbl_Files[ASL_FILE_INPUT].Filename, asctime (NewTime),
650         Prefix);
651 
652     switch (FileId)
653     {
654     case ASL_FILE_C_SOURCE_OUTPUT:
655     case ASL_FILE_C_OFFSET_OUTPUT:
656     case ASL_FILE_C_INCLUDE_OUTPUT:
657 
658         FlPrintFile (FileId, " */\n");
659         break;
660 
661     default:
662 
663         /* Nothing to do for other output types */
664 
665         break;
666     }
667 }
668 
669 
670 /*******************************************************************************
671  *
672  * FUNCTION:    CmFlushSourceCode
673  *
674  * PARAMETERS:  None
675  *
676  * RETURN:      None
677  *
678  * DESCRIPTION: Read in any remaining source code after the parse tree
679  *              has been constructed.
680  *
681  ******************************************************************************/
682 
683 static void
684 CmFlushSourceCode (
685     void)
686 {
687     char                    Buffer;
688 
689 
690     while (FlReadFile (ASL_FILE_INPUT, &Buffer, 1) != AE_ERROR)
691     {
692         AslInsertLineBuffer ((int) Buffer);
693     }
694 
695     AslResetCurrentLineBuffer ();
696 }
697 
698 
699 /*******************************************************************************
700  *
701  * FUNCTION:    CmDoOutputFiles
702  *
703  * PARAMETERS:  None
704  *
705  * RETURN:      None.
706  *
707  * DESCRIPTION: Create all "listing" type files
708  *
709  ******************************************************************************/
710 
711 void
712 CmDoOutputFiles (
713     void)
714 {
715 
716     /* Create listings and hex files */
717 
718     LsDoListings ();
719     HxDoHexOutput ();
720 
721     /* Dump the namespace to the .nsp file if requested */
722 
723     (void) NsDisplayNamespace ();
724 
725     /* Dump the device mapping file */
726 
727     MpEmitMappingInfo ();
728 }
729 
730 
731 /*******************************************************************************
732  *
733  * FUNCTION:    CmDumpAllEvents
734  *
735  * PARAMETERS:  None
736  *
737  * RETURN:      None.
738  *
739  * DESCRIPTION: Dump all compiler events
740  *
741  ******************************************************************************/
742 
743 static void
744 CmDumpAllEvents (
745     void)
746 {
747     ASL_EVENT_INFO          *Event;
748     UINT32                  Delta;
749     UINT32                  MicroSeconds;
750     UINT32                  MilliSeconds;
751     UINT32                  i;
752 
753 
754     Event = AslGbl_Events;
755 
756     DbgPrint (ASL_DEBUG_OUTPUT, "\n\nElapsed time for major events\n\n");
757     if (AslGbl_CompileTimesFlag)
758     {
759         printf ("\nElapsed time for major events\n\n");
760     }
761 
762     for (i = 0; i < AslGbl_NextEvent; i++)
763     {
764         if (Event->Valid)
765         {
766             /* Delta will be in 100-nanosecond units */
767 
768             Delta = (UINT32) (Event->EndTime - Event->StartTime);
769 
770             MicroSeconds = Delta / ACPI_100NSEC_PER_USEC;
771             MilliSeconds = Delta / ACPI_100NSEC_PER_MSEC;
772 
773             /* Round milliseconds up */
774 
775             if ((MicroSeconds - (MilliSeconds * ACPI_USEC_PER_MSEC)) >= 500)
776             {
777                 MilliSeconds++;
778             }
779 
780             DbgPrint (ASL_DEBUG_OUTPUT, "%8u usec %8u msec - %s\n",
781                 MicroSeconds, MilliSeconds, Event->EventName);
782 
783             if (AslGbl_CompileTimesFlag)
784             {
785                 printf ("%8u usec %8u msec - %s\n",
786                     MicroSeconds, MilliSeconds, Event->EventName);
787             }
788         }
789 
790         Event++;
791     }
792 }
793 
794 
795 /*******************************************************************************
796  *
797  * FUNCTION:    CmCleanupAndExit
798  *
799  * PARAMETERS:  None
800  *
801  * RETURN:      None.
802  *
803  * DESCRIPTION: Close all open files and exit the compiler
804  *
805  ******************************************************************************/
806 
807 void
808 CmCleanupAndExit (
809     void)
810 {
811     UINT32                  i;
812     BOOLEAN                 DeleteAmlFile = FALSE;
813 
814 
815     AePrintErrorLog (ASL_FILE_STDERR);
816     if (AslGbl_DebugFlag)
817     {
818         /* Print error summary to stdout also */
819 
820         AePrintErrorLog (ASL_FILE_STDOUT);
821     }
822 
823     /* Emit compile times if enabled */
824 
825     CmDumpAllEvents ();
826 
827     if (AslGbl_CompileTimesFlag)
828     {
829         printf ("\nMiscellaneous compile statistics\n\n");
830         printf ("%11u : %s\n", AslGbl_TotalParseNodes, "Parse nodes");
831         printf ("%11u : %s\n", AslGbl_NsLookupCount, "Namespace searches");
832         printf ("%11u : %s\n", AslGbl_TotalNamedObjects, "Named objects");
833         printf ("%11u : %s\n", AslGbl_TotalMethods, "Control methods");
834         printf ("%11u : %s\n", AslGbl_TotalAllocations, "Memory Allocations");
835         printf ("%11u : %s\n", AslGbl_TotalAllocated, "Total allocated memory");
836         printf ("%11u : %s\n", AslGbl_TotalFolds, "Constant subtrees folded");
837         printf ("\n");
838     }
839 
840     if (AslGbl_NsLookupCount)
841     {
842         DbgPrint (ASL_DEBUG_OUTPUT,
843             "\n\nMiscellaneous compile statistics\n\n");
844 
845         DbgPrint (ASL_DEBUG_OUTPUT,
846             "%32s : %u\n", "Total Namespace searches",
847             AslGbl_NsLookupCount);
848 
849         DbgPrint (ASL_DEBUG_OUTPUT,
850             "%32s : %u usec\n", "Time per search", ((UINT32)
851             (AslGbl_Events[AslGbl_NamespaceEvent].EndTime -
852                 AslGbl_Events[AslGbl_NamespaceEvent].StartTime) / 10) /
853                 AslGbl_NsLookupCount);
854     }
855 
856     if (AslGbl_ExceptionCount[ASL_ERROR] > ASL_MAX_ERROR_COUNT)
857     {
858         printf ("\nMaximum error count (%d) exceeded\n",
859             ASL_MAX_ERROR_COUNT);
860     }
861 
862     UtDisplaySummary (ASL_FILE_STDOUT);
863 
864     /*
865      * We will delete the AML file if there are errors and the
866      * force AML output option has not been used.
867      */
868     if ((AslGbl_ExceptionCount[ASL_ERROR] > 0) &&
869         (!AslGbl_IgnoreErrors) &&
870         AslGbl_Files[ASL_FILE_AML_OUTPUT].Handle)
871     {
872         DeleteAmlFile = TRUE;
873     }
874 
875     /* Close all open files */
876 
877     /*
878      * Take care with the preprocessor file (.pre), it might be the same
879      * as the "input" file, depending on where the compiler has terminated
880      * or aborted. Prevent attempt to close the same file twice in
881      * loop below.
882      */
883     if (AslGbl_Files[ASL_FILE_PREPROCESSOR].Handle ==
884         AslGbl_Files[ASL_FILE_INPUT].Handle)
885     {
886         AslGbl_Files[ASL_FILE_PREPROCESSOR].Handle = NULL;
887     }
888 
889     /* Close the standard I/O files */
890 
891     for (i = ASL_FILE_INPUT; i < ASL_MAX_FILE_TYPE; i++)
892     {
893         FlCloseFile (i);
894     }
895 
896     /* Delete AML file if there are errors */
897 
898     if (DeleteAmlFile)
899     {
900         FlDeleteFile (ASL_FILE_AML_OUTPUT);
901     }
902 
903     /* Delete the preprocessor temp file unless full debug was specified */
904 
905     if (AslGbl_PreprocessFlag && !AslGbl_KeepPreprocessorTempFile)
906     {
907         FlDeleteFile (ASL_FILE_PREPROCESSOR);
908     }
909 
910     /*
911      * Delete intermediate ("combined") source file (if -ls flag not set)
912      * This file is created during normal ASL/AML compiles. It is not
913      * created by the data table compiler.
914      *
915      * If the -ls flag is set, then the .SRC file should not be deleted.
916      * In this case, Gbl_SourceOutputFlag is set to TRUE.
917      *
918      * Note: Handles are cleared by FlCloseFile above, so we look at the
919      * filename instead, to determine if the .SRC file was actually
920      * created.
921      */
922     if (!AslGbl_SourceOutputFlag)
923     {
924         FlDeleteFile (ASL_FILE_SOURCE_OUTPUT);
925     }
926 
927     /* Final cleanup after compiling one file */
928 
929     if (!AslGbl_DoAslConversion)
930     {
931         UtDeleteLocalCaches ();
932     }
933 }
934