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