sys/contrib/dev/acpica/compiler/aslcompile.c

   1 /******************************************************************************
   2  *
   3  * Module Name: aslcompile - top level compile module
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2015, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44 #include <contrib/dev/acpica/compiler/aslcompiler.h>
  45 #include <contrib/dev/acpica/compiler/dtcompiler.h>
  46 #include <contrib/dev/acpica/include/acnamesp.h>
  47
  48 #include <stdio.h>
  49 #include <time.h>
  50 #include <contrib/dev/acpica/include/acapps.h>
  51
  52 #define _COMPONENT          ACPI_COMPILER
  53         ACPI_MODULE_NAME    ("aslcompile")
  54
  55 /*
  56  * Main parser entry
  57  * External is here in case the parser emits the same external in the
  58  * generated header. (Newer versions of Bison)
  59  */
  60 int
  61 AslCompilerparse(
  62     void);
  63
  64 /* Local prototypes */
  65
  66 static void
  67 CmFlushSourceCode (
  68     void);
  69
  70 static void
  71 CmDumpAllEvents (
  72     void);
  73
  74
  75 /*******************************************************************************
  76  *
  77  * FUNCTION:    CmDoCompile
  78  *
  79  * PARAMETERS:  None
  80  *
  81  * RETURN:      Status (0 = OK)
  82  *
  83  * DESCRIPTION: This procedure performs the entire compile
  84  *
  85  ******************************************************************************/
  86
  87 int
  88 CmDoCompile (
  89     void)
  90 {
  91     ACPI_STATUS             Status;
  92     UINT8                   FullCompile;
  93     UINT8                   Event;
  94
  95
  96     FullCompile = UtBeginEvent ("*** Total Compile time ***");
  97     Event = UtBeginEvent ("Open input and output files");
  98     UtEndEvent (Event);
  99
 100     Event = UtBeginEvent ("Preprocess input file");
 101     if (Gbl_PreprocessFlag)
 102     {
 103         /* Preprocessor */
 104
 105         PrDoPreprocess ();
 106         if (Gbl_PreprocessOnly)
 107         {
 108             UtEndEvent (Event);
 109             CmCleanupAndExit ();
 110             return (0);
 111         }
 112     }
 113     UtEndEvent (Event);
 114
 115     /* Build the parse tree */
 116
 117     Event = UtBeginEvent ("Parse source code and build parse tree");
 118     AslCompilerparse();
 119     UtEndEvent (Event);
 120
 121     /* Check for parser-detected syntax errors */
 122
 123     if (Gbl_SyntaxError)
 124     {
 125         fprintf (stderr, "Compiler aborting due to parser-detected syntax error(s)\n");
 126         LsDumpParseTree ();
 127         goto ErrorExit;
 128     }
 129
 130     /* Did the parse tree get successfully constructed? */
 131
 132     if (!RootNode)
 133     {
 134         /*
 135          * If there are no errors, then we have some sort of
 136          * internal problem.
 137          */
 138         AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL,
 139             NULL, "- Could not resolve parse tree root node");
 140
 141         goto ErrorExit;
 142     }
 143
 144     /* Flush out any remaining source after parse tree is complete */
 145
 146     Event = UtBeginEvent ("Flush source input");
 147     CmFlushSourceCode ();
 148
 149     /* Prune the parse tree if requested (debug purposes only) */
 150
 151     if (Gbl_PruneParseTree)
 152     {
 153         AslPruneParseTree (Gbl_PruneDepth, Gbl_PruneType);
 154     }
 155
 156     /* Optional parse tree dump, compiler debug output only */
 157
 158     LsDumpParseTree ();
 159
 160     OpcGetIntegerWidth (RootNode);
 161     UtEndEvent (Event);
 162
 163     /* Pre-process parse tree for any operator transforms */
 164
 165     Event = UtBeginEvent ("Parse tree transforms");
 166     DbgPrint (ASL_DEBUG_OUTPUT, "\nParse tree transforms\n\n");
 167     TrWalkParseTree (RootNode, ASL_WALK_VISIT_DOWNWARD,
 168         TrAmlTransformWalk, NULL, NULL);
 169     UtEndEvent (Event);
 170
 171     /* Generate AML opcodes corresponding to the parse tokens */
 172
 173     Event = UtBeginEvent ("Generate AML opcodes");
 174     DbgPrint (ASL_DEBUG_OUTPUT, "\nGenerating AML opcodes\n\n");
 175     TrWalkParseTree (RootNode, ASL_WALK_VISIT_UPWARD, NULL,
 176         OpcAmlOpcodeWalk, NULL);
 177     UtEndEvent (Event);
 178
 179     /*
 180      * Now that the input is parsed, we can open the AML output file.
 181      * Note: by default, the name of this file comes from the table descriptor
 182      * within the input file.
 183      */
 184     Event = UtBeginEvent ("Open AML output file");
 185     Status = FlOpenAmlOutputFile (Gbl_OutputFilenamePrefix);
 186     UtEndEvent (Event);
 187     if (ACPI_FAILURE (Status))
 188     {
 189         AePrintErrorLog (ASL_FILE_STDERR);
 190         return (-1);
 191     }
 192
 193     /* Interpret and generate all compile-time constants */
 194
 195     Event = UtBeginEvent ("Constant folding via AML interpreter");
 196     DbgPrint (ASL_DEBUG_OUTPUT,
 197         "\nInterpreting compile-time constant expressions\n\n");
 198
 199     if (Gbl_FoldConstants)
 200     {
 201         TrWalkParseTree (RootNode, ASL_WALK_VISIT_DOWNWARD,
 202             OpcAmlConstantWalk, NULL, NULL);
 203     }
 204     else
 205     {
 206         DbgPrint (ASL_PARSE_OUTPUT, "    Optional folding disabled\n");
 207     }
 208     UtEndEvent (Event);
 209
 210     /* Update AML opcodes if necessary, after constant folding */
 211
 212     Event = UtBeginEvent ("Updating AML opcodes after constant folding");
 213     DbgPrint (ASL_DEBUG_OUTPUT,
 214         "\nUpdating AML opcodes after constant folding\n\n");
 215     TrWalkParseTree (RootNode, ASL_WALK_VISIT_UPWARD,
 216         NULL, OpcAmlOpcodeUpdateWalk, NULL);
 217     UtEndEvent (Event);
 218
 219     /* Calculate all AML package lengths */
 220
 221     Event = UtBeginEvent ("Generate AML package lengths");
 222     DbgPrint (ASL_DEBUG_OUTPUT, "\nGenerating Package lengths\n\n");
 223     TrWalkParseTree (RootNode, ASL_WALK_VISIT_UPWARD, NULL,
 224         LnPackageLengthWalk, NULL);
 225     UtEndEvent (Event);
 226
 227     if (Gbl_ParseOnlyFlag)
 228     {
 229         AePrintErrorLog (ASL_FILE_STDERR);
 230         UtDisplaySummary (ASL_FILE_STDERR);
 231         if (Gbl_DebugFlag)
 232         {
 233             /* Print error summary to the stdout also */
 234
 235             AePrintErrorLog (ASL_FILE_STDOUT);
 236             UtDisplaySummary (ASL_FILE_STDOUT);
 237         }
 238         UtEndEvent (FullCompile);
 239         return (0);
 240     }
 241
 242     /*
 243      * Create an internal namespace and use it as a symbol table
 244      */
 245
 246     /* Namespace loading */
 247
 248     Event = UtBeginEvent ("Create ACPI Namespace");
 249     Status = LdLoadNamespace (RootNode);
 250     UtEndEvent (Event);
 251     if (ACPI_FAILURE (Status))
 252     {
 253         goto ErrorExit;
 254     }
 255
 256     /* Namespace cross-reference */
 257
 258     AslGbl_NamespaceEvent = UtBeginEvent ("Cross reference parse tree and Namespace");
 259     Status = XfCrossReferenceNamespace ();
 260     if (ACPI_FAILURE (Status))
 261     {
 262         goto ErrorExit;
 263     }
 264
 265     /* Namespace - Check for non-referenced objects */
 266
 267     LkFindUnreferencedObjects ();
 268     UtEndEvent (AslGbl_NamespaceEvent);
 269
 270     /*
 271      * Semantic analysis. This can happen only after the
 272      * namespace has been loaded and cross-referenced.
 273      *
 274      * part one - check control methods
 275      */
 276     Event = UtBeginEvent ("Analyze control method return types");
 277     AnalysisWalkInfo.MethodStack = NULL;
 278
 279     DbgPrint (ASL_DEBUG_OUTPUT, "\nSemantic analysis - Method analysis\n\n");
 280     TrWalkParseTree (RootNode, ASL_WALK_VISIT_TWICE,
 281         MtMethodAnalysisWalkBegin,
 282         MtMethodAnalysisWalkEnd, &AnalysisWalkInfo);
 283     UtEndEvent (Event);
 284
 285     /* Semantic error checking part two - typing of method returns */
 286
 287     Event = UtBeginEvent ("Determine object types returned by methods");
 288     DbgPrint (ASL_DEBUG_OUTPUT, "\nSemantic analysis - Method typing\n\n");
 289     TrWalkParseTree (RootNode, ASL_WALK_VISIT_UPWARD,
 290         NULL, AnMethodTypingWalkEnd, NULL);
 291     UtEndEvent (Event);
 292
 293     /* Semantic error checking part three - operand type checking */
 294
 295     Event = UtBeginEvent ("Analyze AML operand types");
 296     DbgPrint (ASL_DEBUG_OUTPUT, "\nSemantic analysis - Operand type checking\n\n");
 297     TrWalkParseTree (RootNode, ASL_WALK_VISIT_UPWARD,
 298         NULL, AnOperandTypecheckWalkEnd, &AnalysisWalkInfo);
 299     UtEndEvent (Event);
 300
 301     /* Semantic error checking part four - other miscellaneous checks */
 302
 303     Event = UtBeginEvent ("Miscellaneous analysis");
 304     DbgPrint (ASL_DEBUG_OUTPUT, "\nSemantic analysis - miscellaneous\n\n");
 305     TrWalkParseTree (RootNode, ASL_WALK_VISIT_DOWNWARD,
 306         AnOtherSemanticAnalysisWalkBegin,
 307         NULL, &AnalysisWalkInfo);
 308     UtEndEvent (Event);
 309
 310     /* Calculate all AML package lengths */
 311
 312     Event = UtBeginEvent ("Finish AML package length generation");
 313     DbgPrint (ASL_DEBUG_OUTPUT, "\nGenerating Package lengths\n\n");
 314     TrWalkParseTree (RootNode, ASL_WALK_VISIT_UPWARD, NULL,
 315         LnInitLengthsWalk, NULL);
 316     TrWalkParseTree (RootNode, ASL_WALK_VISIT_UPWARD, NULL,
 317         LnPackageLengthWalk, NULL);
 318     UtEndEvent (Event);
 319
 320     /* Code generation - emit the AML */
 321
 322     Event = UtBeginEvent ("Generate AML code and write output files");
 323     CgGenerateAmlOutput ();
 324     UtEndEvent (Event);
 325
 326     Event = UtBeginEvent ("Write optional output files");
 327     CmDoOutputFiles ();
 328     UtEndEvent (Event);
 329
 330     UtEndEvent (FullCompile);
 331     CmCleanupAndExit ();
 332     return (0);
 333
 334 ErrorExit:
 335     UtEndEvent (FullCompile);
 336     CmCleanupAndExit ();
 337     return (-1);
 338 }
 339
 340
 341 /*******************************************************************************
 342  *
 343  * FUNCTION:    AslCompilerSignon
 344  *
 345  * PARAMETERS:  FileId      - ID of the output file
 346  *
 347  * RETURN:      None
 348  *
 349  * DESCRIPTION: Display compiler signon
 350  *
 351  ******************************************************************************/
 352
 353 void
 354 AslCompilerSignon (
 355     UINT32                  FileId)
 356 {
 357     char                    *Prefix = "";
 358     char                    *UtilityName;
 359
 360
 361     /* Set line prefix depending on the destination file type */
 362
 363     switch (FileId)
 364     {
 365     case ASL_FILE_ASM_SOURCE_OUTPUT:
 366     case ASL_FILE_ASM_INCLUDE_OUTPUT:
 367
 368         Prefix = "; ";
 369         break;
 370
 371     case ASL_FILE_HEX_OUTPUT:
 372
 373         if (Gbl_HexOutputFlag == HEX_OUTPUT_ASM)
 374         {
 375             Prefix = "; ";
 376         }
 377         else if ((Gbl_HexOutputFlag == HEX_OUTPUT_C) ||
 378                  (Gbl_HexOutputFlag == HEX_OUTPUT_ASL))
 379         {
 380             FlPrintFile (ASL_FILE_HEX_OUTPUT, "/*\n");
 381             Prefix = " * ";
 382         }
 383         break;
 384
 385     case ASL_FILE_C_SOURCE_OUTPUT:
 386     case ASL_FILE_C_OFFSET_OUTPUT:
 387     case ASL_FILE_C_INCLUDE_OUTPUT:
 388
 389         Prefix = " * ";
 390         break;
 391
 392     default:
 393
 394         /* No other output types supported */
 395
 396         break;
 397     }
 398
 399     /* Running compiler or disassembler? */
 400
 401     if (Gbl_DisasmFlag)
 402     {
 403         UtilityName = AML_DISASSEMBLER_NAME;
 404     }
 405     else
 406     {
 407         UtilityName = ASL_COMPILER_NAME;
 408     }
 409
 410     /* Compiler signon with copyright */
 411
 412     FlPrintFile (FileId, "%s\n", Prefix);
 413     FlPrintFile (FileId, ACPI_COMMON_HEADER (UtilityName, Prefix));
 414 }
 415
 416
 417 /*******************************************************************************
 418  *
 419  * FUNCTION:    AslCompilerFileHeader
 420  *
 421  * PARAMETERS:  FileId      - ID of the output file
 422  *
 423  * RETURN:      None
 424  *
 425  * DESCRIPTION: Header used at the beginning of output files
 426  *
 427  ******************************************************************************/
 428
 429 void
 430 AslCompilerFileHeader (
 431     UINT32                  FileId)
 432 {
 433     struct tm               *NewTime;
 434     time_t                  Aclock;
 435     char                    *Prefix = "";
 436
 437
 438     /* Set line prefix depending on the destination file type */
 439
 440     switch (FileId)
 441     {
 442     case ASL_FILE_ASM_SOURCE_OUTPUT:
 443     case ASL_FILE_ASM_INCLUDE_OUTPUT:
 444
 445         Prefix = "; ";
 446         break;
 447
 448     case ASL_FILE_HEX_OUTPUT:
 449
 450         if (Gbl_HexOutputFlag == HEX_OUTPUT_ASM)
 451         {
 452             Prefix = "; ";
 453         }
 454         else if ((Gbl_HexOutputFlag == HEX_OUTPUT_C) ||
 455                  (Gbl_HexOutputFlag == HEX_OUTPUT_ASL))
 456         {
 457             Prefix = " * ";
 458         }
 459         break;
 460
 461     case ASL_FILE_C_SOURCE_OUTPUT:
 462     case ASL_FILE_C_OFFSET_OUTPUT:
 463     case ASL_FILE_C_INCLUDE_OUTPUT:
 464
 465         Prefix = " * ";
 466         break;
 467
 468     default:
 469
 470         /* No other output types supported */
 471
 472         break;
 473     }
 474
 475     /* Compilation header with timestamp */
 476
 477     (void) time (&Aclock);
 478     NewTime = localtime (&Aclock);
 479
 480     FlPrintFile (FileId,
 481         "%sCompilation of \"%s\" - %s%s\n",
 482         Prefix, Gbl_Files[ASL_FILE_INPUT].Filename, asctime (NewTime),
 483         Prefix);
 484
 485     switch (FileId)
 486     {
 487     case ASL_FILE_C_SOURCE_OUTPUT:
 488     case ASL_FILE_C_OFFSET_OUTPUT:
 489     case ASL_FILE_C_INCLUDE_OUTPUT:
 490
 491         FlPrintFile (FileId, " */\n");
 492         break;
 493
 494     default:
 495
 496         /* Nothing to do for other output types */
 497
 498         break;
 499     }
 500 }
 501
 502
 503 /*******************************************************************************
 504  *
 505  * FUNCTION:    CmFlushSourceCode
 506  *
 507  * PARAMETERS:  None
 508  *
 509  * RETURN:      None
 510  *
 511  * DESCRIPTION: Read in any remaining source code after the parse tree
 512  *              has been constructed.
 513  *
 514  ******************************************************************************/
 515
 516 static void
 517 CmFlushSourceCode (
 518     void)
 519 {
 520     char                    Buffer;
 521
 522
 523     while (FlReadFile (ASL_FILE_INPUT, &Buffer, 1) != AE_ERROR)
 524     {
 525         AslInsertLineBuffer ((int) Buffer);
 526     }
 527
 528     AslResetCurrentLineBuffer ();
 529 }
 530
 531
 532 /*******************************************************************************
 533  *
 534  * FUNCTION:    CmDoOutputFiles
 535  *
 536  * PARAMETERS:  None
 537  *
 538  * RETURN:      None.
 539  *
 540  * DESCRIPTION: Create all "listing" type files
 541  *
 542  ******************************************************************************/
 543
 544 void
 545 CmDoOutputFiles (
 546     void)
 547 {
 548
 549     /* Create listings and hex files */
 550
 551     LsDoListings ();
 552     HxDoHexOutput ();
 553
 554     /* Dump the namespace to the .nsp file if requested */
 555
 556     (void) NsDisplayNamespace ();
 557
 558     /* Dump the device mapping file */
 559
 560     MpEmitMappingInfo ();
 561 }
 562
 563
 564 /*******************************************************************************
 565  *
 566  * FUNCTION:    CmDumpAllEvents
 567  *
 568  * PARAMETERS:  None
 569  *
 570  * RETURN:      None.
 571  *
 572  * DESCRIPTION: Dump all compiler events
 573  *
 574  ******************************************************************************/
 575
 576 static void
 577 CmDumpAllEvents (
 578     void)
 579 {
 580     ASL_EVENT_INFO          *Event;
 581     UINT32                  Delta;
 582     UINT32                  USec;
 583     UINT32                  MSec;
 584     UINT32                  i;
 585
 586
 587     Event = AslGbl_Events;
 588
 589     DbgPrint (ASL_DEBUG_OUTPUT, "\n\nElapsed time for major events\n\n");
 590     if (Gbl_CompileTimesFlag)
 591     {
 592         printf ("\nElapsed time for major events\n\n");
 593     }
 594
 595     for (i = 0; i < AslGbl_NextEvent; i++)
 596     {
 597         if (Event->Valid)
 598         {
 599             /* Delta will be in 100-nanosecond units */
 600
 601             Delta = (UINT32) (Event->EndTime - Event->StartTime);
 602
 603             USec = Delta / ACPI_100NSEC_PER_USEC;
 604             MSec = Delta / ACPI_100NSEC_PER_MSEC;
 605
 606             /* Round milliseconds up */
 607
 608             if ((USec - (MSec * ACPI_USEC_PER_MSEC)) >= 500)
 609             {
 610                 MSec++;
 611             }
 612
 613             DbgPrint (ASL_DEBUG_OUTPUT, "%8u usec %8u msec - %s\n",
 614                 USec, MSec, Event->EventName);
 615
 616             if (Gbl_CompileTimesFlag)
 617             {
 618                 printf ("%8u usec %8u msec - %s\n",
 619                     USec, MSec, Event->EventName);
 620             }
 621         }
 622
 623         Event++;
 624     }
 625 }
 626
 627
 628 /*******************************************************************************
 629  *
 630  * FUNCTION:    CmCleanupAndExit
 631  *
 632  * PARAMETERS:  None
 633  *
 634  * RETURN:      None.
 635  *
 636  * DESCRIPTION: Close all open files and exit the compiler
 637  *
 638  ******************************************************************************/
 639
 640 void
 641 CmCleanupAndExit (
 642     void)
 643 {
 644     UINT32                  i;
 645     BOOLEAN                 DeleteAmlFile = FALSE;
 646
 647
 648     AePrintErrorLog (ASL_FILE_STDERR);
 649     if (Gbl_DebugFlag)
 650     {
 651         /* Print error summary to stdout also */
 652
 653         AePrintErrorLog (ASL_FILE_STDOUT);
 654     }
 655
 656     /* Emit compile times if enabled */
 657
 658     CmDumpAllEvents ();
 659
 660     if (Gbl_CompileTimesFlag)
 661     {
 662         printf ("\nMiscellaneous compile statistics\n\n");
 663         printf ("%11u : %s\n", TotalParseNodes, "Parse nodes");
 664         printf ("%11u : %s\n", Gbl_NsLookupCount, "Namespace searches");
 665         printf ("%11u : %s\n", TotalNamedObjects, "Named objects");
 666         printf ("%11u : %s\n", TotalMethods, "Control methods");
 667         printf ("%11u : %s\n", TotalAllocations, "Memory Allocations");
 668         printf ("%11u : %s\n", TotalAllocated, "Total allocated memory");
 669         printf ("%11u : %s\n", TotalFolds, "Constant subtrees folded");
 670         printf ("\n");
 671     }
 672
 673     if (Gbl_NsLookupCount)
 674     {
 675         DbgPrint (ASL_DEBUG_OUTPUT,
 676             "\n\nMiscellaneous compile statistics\n\n");
 677
 678         DbgPrint (ASL_DEBUG_OUTPUT,
 679             "%32s : %u\n", "Total Namespace searches",
 680             Gbl_NsLookupCount);
 681
 682         DbgPrint (ASL_DEBUG_OUTPUT,
 683             "%32s : %u usec\n", "Time per search", ((UINT32)
 684             (AslGbl_Events[AslGbl_NamespaceEvent].EndTime -
 685                 AslGbl_Events[AslGbl_NamespaceEvent].StartTime) / 10) /
 686                 Gbl_NsLookupCount);
 687     }
 688
 689     if (Gbl_ExceptionCount[ASL_ERROR] > ASL_MAX_ERROR_COUNT)
 690     {
 691         printf ("\nMaximum error count (%u) exceeded\n",
 692             ASL_MAX_ERROR_COUNT);
 693     }
 694
 695     UtDisplaySummary (ASL_FILE_STDOUT);
 696
 697     /*
 698      * We will delete the AML file if there are errors and the
 699      * force AML output option has not been used.
 700      */
 701     if ((Gbl_ExceptionCount[ASL_ERROR] > 0) &&
 702         (!Gbl_IgnoreErrors) &&
 703         Gbl_Files[ASL_FILE_AML_OUTPUT].Handle)
 704     {
 705         DeleteAmlFile = TRUE;
 706     }
 707
 708     /* Close all open files */
 709
 710     /*
 711      * Take care with the preprocessor file (.i), it might be the same
 712      * as the "input" file, depending on where the compiler has terminated
 713      * or aborted. Prevent attempt to close the same file twice in
 714      * loop below.
 715      */
 716     if (Gbl_Files[ASL_FILE_PREPROCESSOR].Handle ==
 717         Gbl_Files[ASL_FILE_INPUT].Handle)
 718     {
 719         Gbl_Files[ASL_FILE_PREPROCESSOR].Handle = NULL;
 720     }
 721
 722     /* Close the standard I/O files */
 723
 724     for (i = ASL_FILE_INPUT; i < ASL_MAX_FILE_TYPE; i++)
 725     {
 726         FlCloseFile (i);
 727     }
 728
 729     /* Delete AML file if there are errors */
 730
 731     if (DeleteAmlFile)
 732     {
 733         FlDeleteFile (ASL_FILE_AML_OUTPUT);
 734     }
 735
 736     /* Delete the preprocessor output file (.i) unless -li flag is set */
 737
 738     if (!Gbl_PreprocessorOutputFlag &&
 739         Gbl_PreprocessFlag)
 740     {
 741         FlDeleteFile (ASL_FILE_PREPROCESSOR);
 742     }
 743
 744     /*
 745      * Delete intermediate ("combined") source file (if -ls flag not set)
 746      * This file is created during normal ASL/AML compiles. It is not
 747      * created by the data table compiler.
 748      *
 749      * If the -ls flag is set, then the .SRC file should not be deleted.
 750      * In this case, Gbl_SourceOutputFlag is set to TRUE.
 751      *
 752      * Note: Handles are cleared by FlCloseFile above, so we look at the
 753      * filename instead, to determine if the .SRC file was actually
 754      * created.
 755      *
 756      * TBD: SourceOutput should be .TMP, then rename if we want to keep it?
 757      */
 758     if (!Gbl_SourceOutputFlag)
 759     {
 760         FlDeleteFile (ASL_FILE_SOURCE_OUTPUT);
 761     }
 762
 763     /* Final cleanup after compiling one file */
 764
 765     CmDeleteCaches ();
 766 }
 767
 768
 769 /*******************************************************************************
 770  *
 771  * FUNCTION:    CmDeleteCaches
 772  *
 773  * PARAMETERS:  None
 774  *
 775  * RETURN:      None
 776  *
 777  * DESCRIPTION: Delete all local cache buffer blocks
 778  *
 779  ******************************************************************************/
 780
 781 void
 782 CmDeleteCaches (
 783     void)
 784 {
 785     UINT32                  BufferCount;
 786     ASL_CACHE_INFO          *Next;
 787
 788
 789     /* Parse Op cache */
 790
 791     BufferCount = 0;
 792     while (Gbl_ParseOpCacheList)
 793     {
 794         Next = Gbl_ParseOpCacheList->Next;
 795         ACPI_FREE (Gbl_ParseOpCacheList);
 796         Gbl_ParseOpCacheList = Next;
 797         BufferCount++;
 798     }
 799
 800     DbgPrint (ASL_DEBUG_OUTPUT,
 801         "%u ParseOps, Buffer size: %u ops (%u bytes), %u Buffers\n",
 802         Gbl_ParseOpCount, ASL_PARSEOP_CACHE_SIZE,
 803         (sizeof (ACPI_PARSE_OBJECT) * ASL_PARSEOP_CACHE_SIZE), BufferCount);
 804
 805     Gbl_ParseOpCount = 0;
 806     Gbl_ParseOpCacheNext = NULL;
 807     Gbl_ParseOpCacheLast = NULL;
 808     RootNode = NULL;
 809
 810     /* Generic string cache */
 811
 812     BufferCount = 0;
 813     while (Gbl_StringCacheList)
 814     {
 815         Next = Gbl_StringCacheList->Next;
 816         ACPI_FREE (Gbl_StringCacheList);
 817         Gbl_StringCacheList = Next;
 818         BufferCount++;
 819     }
 820
 821     DbgPrint (ASL_DEBUG_OUTPUT,
 822         "%u Strings (%u bytes), Buffer size: %u bytes, %u Buffers\n",
 823         Gbl_StringCount, Gbl_StringSize, ASL_STRING_CACHE_SIZE, BufferCount);
 824
 825     Gbl_StringSize = 0;
 826     Gbl_StringCount = 0;
 827     Gbl_StringCacheNext = NULL;
 828     Gbl_StringCacheLast = NULL;
 829 }