source/compiler/aslcompile.c

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