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