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

   1 /******************************************************************************
   2  *
   3  * Module Name: aslstartup - Compiler startup routines, called from main
   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/include/actables.h>
  46 #include <contrib/dev/acpica/include/acdisasm.h>
  47 #include <contrib/dev/acpica/include/acapps.h>
  48
  49 #define _COMPONENT          ACPI_COMPILER
  50         ACPI_MODULE_NAME    ("aslstartup")
  51
  52
  53 /* Local prototypes */
  54
  55 static UINT8
  56 AslDetectSourceFileType (
  57     ASL_FILE_INFO           *Info);
  58
  59 static ACPI_STATUS
  60 AslDoDisassembly (
  61     void);
  62
  63
  64 /* Globals */
  65
  66 static BOOLEAN          AslToFile = TRUE;
  67
  68
  69 /*******************************************************************************
  70  *
  71  * FUNCTION:    AslInitializeGlobals
  72  *
  73  * PARAMETERS:  None
  74  *
  75  * RETURN:      None
  76  *
  77  * DESCRIPTION: Re-initialize globals needed to restart the compiler. This
  78  *              allows multiple files to be disassembled and/or compiled.
  79  *
  80  ******************************************************************************/
  81
  82 void
  83 AslInitializeGlobals (
  84     void)
  85 {
  86     UINT32                  i;
  87
  88
  89     /* Init compiler globals */
  90
  91     Gbl_SyntaxError = 0;
  92     Gbl_CurrentColumn = 0;
  93     Gbl_CurrentLineNumber = 1;
  94     Gbl_LogicalLineNumber = 1;
  95     Gbl_CurrentLineOffset = 0;
  96     Gbl_InputFieldCount = 0;
  97     Gbl_InputByteCount = 0;
  98     Gbl_NsLookupCount = 0;
  99     Gbl_LineBufPtr = Gbl_CurrentLineBuffer;
 100
 101     Gbl_ErrorLog = NULL;
 102     Gbl_NextError = NULL;
 103     Gbl_Signature = NULL;
 104     Gbl_FileType = 0;
 105
 106     TotalExecutableOpcodes = 0;
 107     TotalNamedObjects = 0;
 108     TotalKeywords = 0;
 109     TotalParseNodes = 0;
 110     TotalMethods = 0;
 111     TotalAllocations = 0;
 112     TotalAllocated = 0;
 113     TotalFolds = 0;
 114
 115     AslGbl_NextEvent = 0;
 116     for (i = 0; i < ASL_NUM_REPORT_LEVELS; i++)
 117     {
 118         Gbl_ExceptionCount[i] = 0;
 119     }
 120
 121     for (i = ASL_FILE_INPUT; i <= ASL_MAX_FILE_TYPE; i++)
 122     {
 123         Gbl_Files[i].Handle = NULL;
 124         Gbl_Files[i].Filename = NULL;
 125     }
 126 }
 127
 128
 129 /*******************************************************************************
 130  *
 131  * FUNCTION:    AslDetectSourceFileType
 132  *
 133  * PARAMETERS:  Info            - Name/Handle for the file (must be open)
 134  *
 135  * RETURN:      File Type
 136  *
 137  * DESCRIPTION: Determine the type of the input file. Either binary (contains
 138  *              non-ASCII characters), ASL file, or an ACPI Data Table file.
 139  *
 140  ******************************************************************************/
 141
 142 static UINT8
 143 AslDetectSourceFileType (
 144     ASL_FILE_INFO           *Info)
 145 {
 146     char                    *FileChar;
 147     UINT8                   Type;
 148     ACPI_STATUS             Status;
 149
 150
 151     /* Check for a valid binary ACPI table */
 152
 153     Status = FlCheckForAcpiTable (Info->Handle);
 154     if (ACPI_SUCCESS (Status))
 155     {
 156         Type = ASL_INPUT_TYPE_ACPI_TABLE;
 157         goto Cleanup;
 158     }
 159
 160     /* Check for 100% ASCII source file (comments are ignored) */
 161
 162     Status = FlCheckForAscii (Info->Filename, TRUE);
 163     if (ACPI_FAILURE (Status))
 164     {
 165         printf ("Invalid characters in input file - %s\n", Info->Filename);
 166
 167         if (!Gbl_IgnoreErrors)
 168         {
 169             Type = ASL_INPUT_TYPE_BINARY;
 170             goto Cleanup;
 171         }
 172     }
 173
 174     /*
 175      * File is ASCII. Determine if this is an ASL file or an ACPI data
 176      * table file.
 177      */
 178     while (fgets (Gbl_CurrentLineBuffer, Gbl_LineBufferSize, Info->Handle))
 179     {
 180         /* Uppercase the buffer for caseless compare */
 181
 182         FileChar = Gbl_CurrentLineBuffer;
 183         while (*FileChar)
 184         {
 185             *FileChar = (char) toupper ((int) *FileChar);
 186             FileChar++;
 187         }
 188
 189         /* Presence of "DefinitionBlock" indicates actual ASL code */
 190
 191         if (strstr (Gbl_CurrentLineBuffer, "DEFINITIONBLOCK"))
 192         {
 193             /* Appears to be an ASL file */
 194
 195             Type = ASL_INPUT_TYPE_ASCII_ASL;
 196             goto Cleanup;
 197         }
 198     }
 199
 200     /* Not an ASL source file, default to a data table source file */
 201
 202     Type = ASL_INPUT_TYPE_ASCII_DATA;
 203
 204 Cleanup:
 205
 206     /* Must seek back to the start of the file */
 207
 208     fseek (Info->Handle, 0, SEEK_SET);
 209     return (Type);
 210 }
 211
 212
 213 /*******************************************************************************
 214  *
 215  * FUNCTION:    AslDoDisassembly
 216  *
 217  * PARAMETERS:  None
 218  *
 219  * RETURN:      Status
 220  *
 221  * DESCRIPTION: Initiate AML file disassembly. Uses ACPICA subsystem to build
 222  *              namespace.
 223  *
 224  ******************************************************************************/
 225
 226 static ACPI_STATUS
 227 AslDoDisassembly (
 228     void)
 229 {
 230     ACPI_STATUS             Status;
 231
 232
 233     /* ACPICA subsystem initialization */
 234
 235     Status = AdInitialize ();
 236     if (ACPI_FAILURE (Status))
 237     {
 238         return (Status);
 239     }
 240
 241     Status = AcpiAllocateRootTable (4);
 242     if (ACPI_FAILURE (Status))
 243     {
 244         AcpiOsPrintf ("Could not initialize ACPI Table Manager, %s\n",
 245             AcpiFormatException (Status));
 246         return (Status);
 247     }
 248
 249     /* This is where the disassembly happens */
 250
 251     AcpiGbl_DbOpt_Disasm = TRUE;
 252     Status = AdAmlDisassemble (AslToFile,
 253         Gbl_Files[ASL_FILE_INPUT].Filename, Gbl_OutputFilenamePrefix,
 254         &Gbl_Files[ASL_FILE_INPUT].Filename);
 255     if (ACPI_FAILURE (Status))
 256     {
 257         return (Status);
 258     }
 259
 260     /* Check if any control methods were unresolved */
 261
 262     AcpiDmUnresolvedWarning (0);
 263
 264 #if 0
 265     /* TBD: Handle additional output files for disassembler */
 266
 267     Status = FlOpenMiscOutputFiles (Gbl_OutputFilenamePrefix);
 268     NsDisplayNamespace ();
 269 #endif
 270
 271     /* Shutdown compiler and ACPICA subsystem */
 272
 273     AeClearErrorLog ();
 274     (void) AcpiTerminate ();
 275
 276     /*
 277      * Gbl_Files[ASL_FILE_INPUT].Filename was replaced with the
 278      * .DSL disassembly file, which can now be compiled if requested
 279      */
 280     if (Gbl_DoCompile)
 281     {
 282         AcpiOsPrintf ("\nCompiling \"%s\"\n",
 283             Gbl_Files[ASL_FILE_INPUT].Filename);
 284         return (AE_CTRL_CONTINUE);
 285     }
 286
 287     /* No need to free the filename string */
 288
 289     Gbl_Files[ASL_FILE_INPUT].Filename = NULL;
 290
 291     CmDeleteCaches ();
 292     return (AE_OK);
 293 }
 294
 295
 296 /*******************************************************************************
 297  *
 298  * FUNCTION:    AslDoOneFile
 299  *
 300  * PARAMETERS:  Filename        - Name of the file
 301  *
 302  * RETURN:      Status
 303  *
 304  * DESCRIPTION: Process a single file - either disassemble, compile, or both
 305  *
 306  ******************************************************************************/
 307
 308 ACPI_STATUS
 309 AslDoOneFile (
 310     char                    *Filename)
 311 {
 312     ACPI_STATUS             Status;
 313
 314
 315     /* Re-initialize "some" compiler/preprocessor globals */
 316
 317     AslInitializeGlobals ();
 318     PrInitializeGlobals ();
 319
 320     /*
 321      * Extract the directory path. This path is used for possible include
 322      * files and the optional AML filename embedded in the input file
 323      * DefinitionBlock declaration.
 324      */
 325     Status = FlSplitInputPathname (Filename, &Gbl_DirectoryPath, NULL);
 326     if (ACPI_FAILURE (Status))
 327     {
 328         return (Status);
 329     }
 330
 331     /* Take a copy of the input filename, convert any backslashes */
 332
 333     Gbl_Files[ASL_FILE_INPUT].Filename =
 334         UtStringCacheCalloc (strlen (Filename) + 1);
 335
 336     strcpy (Gbl_Files[ASL_FILE_INPUT].Filename, Filename);
 337     UtConvertBackslashes (Gbl_Files[ASL_FILE_INPUT].Filename);
 338
 339     /*
 340      * AML Disassembly (Optional)
 341      */
 342     if (Gbl_DisasmFlag)
 343     {
 344         Status = AslDoDisassembly ();
 345         if (Status != AE_CTRL_CONTINUE)
 346         {
 347             return (Status);
 348         }
 349     }
 350
 351     /*
 352      * Open the input file. Here, this should be an ASCII source file,
 353      * either an ASL file or a Data Table file
 354      */
 355     Status = FlOpenInputFile (Gbl_Files[ASL_FILE_INPUT].Filename);
 356     if (ACPI_FAILURE (Status))
 357     {
 358         AePrintErrorLog (ASL_FILE_STDERR);
 359         return (AE_ERROR);
 360     }
 361
 362     Gbl_OriginalInputFileSize = FlGetFileSize (ASL_FILE_INPUT);
 363
 364     /* Determine input file type */
 365
 366     Gbl_FileType = AslDetectSourceFileType (&Gbl_Files[ASL_FILE_INPUT]);
 367     if (Gbl_FileType == ASL_INPUT_TYPE_BINARY)
 368     {
 369         return (AE_ERROR);
 370     }
 371
 372     /*
 373      * If -p not specified, we will use the input filename as the
 374      * output filename prefix
 375      */
 376     if (Gbl_UseDefaultAmlFilename)
 377     {
 378         Gbl_OutputFilenamePrefix = Gbl_Files[ASL_FILE_INPUT].Filename;
 379     }
 380
 381     /* Open the optional output files (listings, etc.) */
 382
 383     Status = FlOpenMiscOutputFiles (Gbl_OutputFilenamePrefix);
 384     if (ACPI_FAILURE (Status))
 385     {
 386         AePrintErrorLog (ASL_FILE_STDERR);
 387         return (AE_ERROR);
 388     }
 389
 390     /*
 391      * Compilation of ASL source versus DataTable source uses different
 392      * compiler subsystems
 393      */
 394     switch (Gbl_FileType)
 395     {
 396     /*
 397      * Data Table Compilation
 398      */
 399     case ASL_INPUT_TYPE_ASCII_DATA:
 400
 401         Status = DtDoCompile ();
 402         if (ACPI_FAILURE (Status))
 403         {
 404             return (Status);
 405         }
 406
 407         if (Gbl_Signature)
 408         {
 409             Gbl_Signature = NULL;
 410         }
 411
 412         /* Check if any errors occurred during compile */
 413
 414         Status = AslCheckForErrorExit ();
 415         if (ACPI_FAILURE (Status))
 416         {
 417             return (Status);
 418         }
 419
 420         /* Cleanup (for next source file) and exit */
 421
 422         AeClearErrorLog ();
 423         PrTerminatePreprocessor ();
 424         return (Status);
 425
 426     /*
 427      * ASL Compilation
 428      */
 429     case ASL_INPUT_TYPE_ASCII_ASL:
 430
 431         /* ACPICA subsystem initialization */
 432
 433         Status = AdInitialize ();
 434         if (ACPI_FAILURE (Status))
 435         {
 436             return (Status);
 437         }
 438
 439         (void) CmDoCompile ();
 440         (void) AcpiTerminate ();
 441
 442         /* Check if any errors occurred during compile */
 443
 444         Status = AslCheckForErrorExit ();
 445         if (ACPI_FAILURE (Status))
 446         {
 447             return (Status);
 448         }
 449
 450         /* Cleanup (for next source file) and exit */
 451
 452         AeClearErrorLog ();
 453         PrTerminatePreprocessor ();
 454         return (AE_OK);
 455
 456     /*
 457      * Binary ACPI table was auto-detected, disassemble it
 458      */
 459     case ASL_INPUT_TYPE_ACPI_TABLE:
 460
 461         /* We have what appears to be an ACPI table, disassemble it */
 462
 463         FlCloseFile (ASL_FILE_INPUT);
 464         Gbl_DoCompile = FALSE;
 465         Gbl_DisasmFlag = TRUE;
 466         Status = AslDoDisassembly ();
 467         return (Status);
 468
 469     /* Unknown binary table */
 470
 471     case ASL_INPUT_TYPE_BINARY:
 472
 473         AePrintErrorLog (ASL_FILE_STDERR);
 474         return (AE_ERROR);
 475
 476     default:
 477
 478         printf ("Unknown file type %X\n", Gbl_FileType);
 479         return (AE_ERROR);
 480     }
 481 }
 482
 483
 484 /*******************************************************************************
 485  *
 486  * FUNCTION:    AslCheckForErrorExit
 487  *
 488  * PARAMETERS:  None. Examines global exception count array
 489  *
 490  * RETURN:      Status
 491  *
 492  * DESCRIPTION: Determine if compiler should abort with error status
 493  *
 494  ******************************************************************************/
 495
 496 ACPI_STATUS
 497 AslCheckForErrorExit (
 498     void)
 499 {
 500
 501     /*
 502      * Return non-zero exit code if there have been errors, unless the
 503      * global ignore error flag has been set
 504      */
 505     if (!Gbl_IgnoreErrors)
 506     {
 507         if (Gbl_ExceptionCount[ASL_ERROR] > 0)
 508         {
 509             return (AE_ERROR);
 510         }
 511
 512         /* Optionally treat warnings as errors */
 513
 514         if (Gbl_WarningsAsErrors)
 515         {
 516             if ((Gbl_ExceptionCount[ASL_WARNING] > 0)  ||
 517                 (Gbl_ExceptionCount[ASL_WARNING2] > 0) ||
 518                 (Gbl_ExceptionCount[ASL_WARNING3] > 0))
 519             {
 520                 return (AE_ERROR);
 521             }
 522         }
 523     }
 524
 525     return (AE_OK);
 526 }