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 "aslcompiler.h"
153 #include "acnamesp.h"
154 
155 #include <stdio.h>
156 #include <time.h>
157 #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     CmCleanupAndExit ();
498     return (0);
499 
500 ErrorExit:
501     UtEndEvent (FullCompile);
502     CmCleanupAndExit ();
503     return (-1);
504 }
505 
506 
507 /*******************************************************************************
508  *
509  * FUNCTION:    AslCompilerSignon
510  *
511  * PARAMETERS:  FileId      - ID of the output file
512  *
513  * RETURN:      None
514  *
515  * DESCRIPTION: Display compiler signon
516  *
517  ******************************************************************************/
518 
519 void
520 AslCompilerSignon (
521     UINT32                  FileId)
522 {
523     char                    *Prefix = "";
524     char                    *UtilityName;
525 
526 
527     /* Set line prefix depending on the destination file type */
528 
529     switch (FileId)
530     {
531     case ASL_FILE_ASM_SOURCE_OUTPUT:
532     case ASL_FILE_ASM_INCLUDE_OUTPUT:
533 
534         Prefix = "; ";
535         break;
536 
537     case ASL_FILE_HEX_OUTPUT:
538 
539         if (AslGbl_HexOutputFlag == HEX_OUTPUT_ASM)
540         {
541             Prefix = "; ";
542         }
543         else if ((AslGbl_HexOutputFlag == HEX_OUTPUT_C) ||
544                  (AslGbl_HexOutputFlag == HEX_OUTPUT_ASL))
545         {
546             FlPrintFile (ASL_FILE_HEX_OUTPUT, "/*\n");
547             Prefix = " * ";
548         }
549         break;
550 
551     case ASL_FILE_C_SOURCE_OUTPUT:
552     case ASL_FILE_C_OFFSET_OUTPUT:
553     case ASL_FILE_C_INCLUDE_OUTPUT:
554 
555         Prefix = " * ";
556         break;
557 
558     default:
559 
560         /* No other output types supported */
561 
562         break;
563     }
564 
565     /* Running compiler or disassembler? */
566 
567     if (AcpiGbl_DisasmFlag)
568     {
569         UtilityName = AML_DISASSEMBLER_NAME;
570     }
571     else
572     {
573         UtilityName = ASL_COMPILER_NAME;
574     }
575 
576     /* Compiler signon with copyright */
577 
578     FlPrintFile (FileId, "%s\n", Prefix);
579     FlPrintFile (FileId, ACPI_COMMON_HEADER (UtilityName, Prefix));
580 }
581 
582 
583 /*******************************************************************************
584  *
585  * FUNCTION:    AslCompilerFileHeader
586  *
587  * PARAMETERS:  FileId      - ID of the output file
588  *
589  * RETURN:      None
590  *
591  * DESCRIPTION: Header used at the beginning of output files
592  *
593  ******************************************************************************/
594 
595 void
596 AslCompilerFileHeader (
597     UINT32                  FileId)
598 {
599     struct tm               *NewTime;
600     time_t                  Aclock;
601     char                    *Prefix = "";
602 
603 
604     /* Set line prefix depending on the destination file type */
605 
606     switch (FileId)
607     {
608     case ASL_FILE_ASM_SOURCE_OUTPUT:
609     case ASL_FILE_ASM_INCLUDE_OUTPUT:
610 
611         Prefix = "; ";
612         break;
613 
614     case ASL_FILE_HEX_OUTPUT:
615 
616         if (AslGbl_HexOutputFlag == HEX_OUTPUT_ASM)
617         {
618             Prefix = "; ";
619         }
620         else if ((AslGbl_HexOutputFlag == HEX_OUTPUT_C) ||
621                  (AslGbl_HexOutputFlag == HEX_OUTPUT_ASL))
622         {
623             Prefix = " * ";
624         }
625         break;
626 
627     case ASL_FILE_C_SOURCE_OUTPUT:
628     case ASL_FILE_C_OFFSET_OUTPUT:
629     case ASL_FILE_C_INCLUDE_OUTPUT:
630 
631         Prefix = " * ";
632         break;
633 
634     default:
635 
636         /* No other output types supported */
637 
638         break;
639     }
640 
641     /* Compilation header with timestamp */
642 
643     (void) time (&Aclock);
644     NewTime = localtime (&Aclock);
645 
646     FlPrintFile (FileId,
647         "%sCompilation of \"%s\" - %s%s\n",
648         Prefix, AslGbl_Files[ASL_FILE_INPUT].Filename, asctime (NewTime),
649         Prefix);
650 
651     switch (FileId)
652     {
653     case ASL_FILE_C_SOURCE_OUTPUT:
654     case ASL_FILE_C_OFFSET_OUTPUT:
655     case ASL_FILE_C_INCLUDE_OUTPUT:
656 
657         FlPrintFile (FileId, " */\n");
658         break;
659 
660     default:
661 
662         /* Nothing to do for other output types */
663 
664         break;
665     }
666 }
667 
668 
669 /*******************************************************************************
670  *
671  * FUNCTION:    CmFlushSourceCode
672  *
673  * PARAMETERS:  None
674  *
675  * RETURN:      None
676  *
677  * DESCRIPTION: Read in any remaining source code after the parse tree
678  *              has been constructed.
679  *
680  ******************************************************************************/
681 
682 static void
683 CmFlushSourceCode (
684     void)
685 {
686     char                    Buffer;
687 
688 
689     while (FlReadFile (ASL_FILE_INPUT, &Buffer, 1) != AE_ERROR)
690     {
691         AslInsertLineBuffer ((int) Buffer);
692     }
693 
694     AslResetCurrentLineBuffer ();
695 }
696 
697 
698 /*******************************************************************************
699  *
700  * FUNCTION:    CmDoOutputFiles
701  *
702  * PARAMETERS:  None
703  *
704  * RETURN:      None.
705  *
706  * DESCRIPTION: Create all "listing" type files
707  *
708  ******************************************************************************/
709 
710 void
711 CmDoOutputFiles (
712     void)
713 {
714 
715     /* Create listings and hex files */
716 
717     LsDoListings ();
718     HxDoHexOutput ();
719 
720     /* Dump the namespace to the .nsp file if requested */
721 
722     (void) NsDisplayNamespace ();
723 
724     /* Dump the device mapping file */
725 
726     MpEmitMappingInfo ();
727 }
728 
729 
730 /*******************************************************************************
731  *
732  * FUNCTION:    CmDumpAllEvents
733  *
734  * PARAMETERS:  None
735  *
736  * RETURN:      None.
737  *
738  * DESCRIPTION: Dump all compiler events
739  *
740  ******************************************************************************/
741 
742 static void
743 CmDumpAllEvents (
744     void)
745 {
746     ASL_EVENT_INFO          *Event;
747     UINT32                  Delta;
748     UINT32                  MicroSeconds;
749     UINT32                  MilliSeconds;
750     UINT32                  i;
751 
752 
753     Event = AslGbl_Events;
754 
755     DbgPrint (ASL_DEBUG_OUTPUT, "\n\nElapsed time for major events\n\n");
756     if (AslGbl_CompileTimesFlag)
757     {
758         printf ("\nElapsed time for major events\n\n");
759     }
760 
761     for (i = 0; i < AslGbl_NextEvent; i++)
762     {
763         if (Event->Valid)
764         {
765             /* Delta will be in 100-nanosecond units */
766 
767             Delta = (UINT32) (Event->EndTime - Event->StartTime);
768 
769             MicroSeconds = Delta / ACPI_100NSEC_PER_USEC;
770             MilliSeconds = Delta / ACPI_100NSEC_PER_MSEC;
771 
772             /* Round milliseconds up */
773 
774             if ((MicroSeconds - (MilliSeconds * ACPI_USEC_PER_MSEC)) >= 500)
775             {
776                 MilliSeconds++;
777             }
778 
779             DbgPrint (ASL_DEBUG_OUTPUT, "%8u usec %8u msec - %s\n",
780                 MicroSeconds, MilliSeconds, Event->EventName);
781 
782             if (AslGbl_CompileTimesFlag)
783             {
784                 printf ("%8u usec %8u msec - %s\n",
785                     MicroSeconds, MilliSeconds, Event->EventName);
786             }
787         }
788 
789         Event++;
790     }
791 }
792 
793 
794 /*******************************************************************************
795  *
796  * FUNCTION:    CmCleanupAndExit
797  *
798  * PARAMETERS:  None
799  *
800  * RETURN:      None.
801  *
802  * DESCRIPTION: Close all open files and exit the compiler
803  *
804  ******************************************************************************/
805 
806 void
807 CmCleanupAndExit (
808     void)
809 {
810     UINT32                  i;
811     BOOLEAN                 DeleteAmlFile = FALSE;
812 
813 
814     AslCheckExpectedExceptions ();
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