asllisting.c revision 1.1.1.2
1 2 /****************************************************************************** 3 * 4 * Module Name: asllisting - Listing file generation 5 * 6 *****************************************************************************/ 7 8 /* 9 * Copyright (C) 2000 - 2011, 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 46 #include "aslcompiler.h" 47 #include "aslcompiler.y.h" 48 #include "amlcode.h" 49 #include "acparser.h" 50 #include "acnamesp.h" 51 52 #define _COMPONENT ACPI_COMPILER 53 ACPI_MODULE_NAME ("aslisting") 54 55 /* Local prototypes */ 56 57 static void 58 LsDumpAscii ( 59 UINT32 FileId, 60 UINT32 Count, 61 UINT8 *Buffer); 62 63 static void 64 LsDumpAsciiInComment ( 65 UINT32 FileId, 66 UINT32 Count, 67 UINT8 *Buffer); 68 69 static ACPI_STATUS 70 LsAmlListingWalk ( 71 ACPI_PARSE_OBJECT *Op, 72 UINT32 Level, 73 void *Context); 74 75 static void 76 LsGenerateListing ( 77 UINT32 FileId); 78 79 static void 80 LsPushNode ( 81 char *Filename); 82 83 static ASL_LISTING_NODE * 84 LsPopNode ( 85 void); 86 87 static void 88 LsCheckException ( 89 UINT32 LineNumber, 90 UINT32 FileId); 91 92 static void 93 LsFlushListingBuffer ( 94 UINT32 FileId); 95 96 static void 97 LsWriteListingHexBytes ( 98 UINT8 *Buffer, 99 UINT32 Length, 100 UINT32 FileId); 101 102 static UINT32 103 LsWriteOneSourceLine ( 104 UINT32 FileId); 105 106 static void 107 LsFinishSourceListing ( 108 UINT32 FileId); 109 110 static void 111 LsWriteSourceLines ( 112 UINT32 ToLineNumber, 113 UINT32 ToLogicalLineNumber, 114 UINT32 FileId); 115 116 static void 117 LsWriteNodeToListing ( 118 ACPI_PARSE_OBJECT *Op, 119 UINT32 FileId); 120 121 static void 122 LsDoHexOutputC ( 123 void); 124 125 static void 126 LsDoHexOutputAsm ( 127 void); 128 129 static void 130 LsDoHexOutputAsl ( 131 void); 132 133 static ACPI_STATUS 134 LsTreeWriteWalk ( 135 ACPI_PARSE_OBJECT *Op, 136 UINT32 Level, 137 void *Context); 138 139 140 /******************************************************************************* 141 * 142 * FUNCTION: LsTreeWriteWalk 143 * 144 * PARAMETERS: ASL_WALK_CALLBACK 145 * 146 * 147 * RETURN: None. 148 * 149 * DESCRIPTION: Dump entire parse tree, for compiler debug only 150 * 151 ******************************************************************************/ 152 153 static ACPI_STATUS 154 LsTreeWriteWalk ( 155 ACPI_PARSE_OBJECT *Op, 156 UINT32 Level, 157 void *Context) 158 { 159 160 /* Debug output */ 161 162 DbgPrint (ASL_TREE_OUTPUT, 163 "%5.5d [%2d]", Op->Asl.LogicalLineNumber, Level); 164 UtPrintFormattedName (Op->Asl.ParseOpcode, Level); 165 166 167 DbgPrint (ASL_TREE_OUTPUT, "\n"); 168 return (AE_OK); 169 } 170 171 172 void 173 LsDumpParseTree ( 174 void) 175 { 176 177 if (!Gbl_DebugFlag) 178 { 179 return; 180 } 181 182 DbgPrint (ASL_TREE_OUTPUT, "\nOriginal parse tree from parser:\n\n"); 183 TrWalkParseTree (RootNode, ASL_WALK_VISIT_DOWNWARD, 184 LsTreeWriteWalk, NULL, NULL); 185 } 186 187 188 /******************************************************************************* 189 * 190 * FUNCTION: LsDumpAscii 191 * 192 * PARAMETERS: FileId - ID of current listing file 193 * Count - Number of bytes to convert 194 * Buffer - Buffer of bytes to convert 195 * 196 * RETURN: None. 197 * 198 * DESCRIPTION: Convert hex bytes to ascii 199 * 200 ******************************************************************************/ 201 202 static void 203 LsDumpAscii ( 204 UINT32 FileId, 205 UINT32 Count, 206 UINT8 *Buffer) 207 { 208 UINT8 BufChar; 209 UINT32 i; 210 211 212 FlPrintFile (FileId, " \""); 213 for (i = 0; i < Count; i++) 214 { 215 BufChar = Buffer[i]; 216 if (isprint (BufChar)) 217 { 218 FlPrintFile (FileId, "%c", BufChar); 219 } 220 else 221 { 222 /* Not a printable character, just put out a dot */ 223 224 FlPrintFile (FileId, "."); 225 } 226 } 227 FlPrintFile (FileId, "\""); 228 } 229 230 231 /******************************************************************************* 232 * 233 * FUNCTION: LsDumpAsciiInComment 234 * 235 * PARAMETERS: FileId - ID of current listing file 236 * Count - Number of bytes to convert 237 * Buffer - Buffer of bytes to convert 238 * 239 * RETURN: None. 240 * 241 * DESCRIPTION: Convert hex bytes to ascii 242 * 243 ******************************************************************************/ 244 245 static void 246 LsDumpAsciiInComment ( 247 UINT32 FileId, 248 UINT32 Count, 249 UINT8 *Buffer) 250 { 251 UINT8 BufChar = 0; 252 UINT8 LastChar; 253 UINT32 i; 254 255 256 FlPrintFile (FileId, " \""); 257 for (i = 0; i < Count; i++) 258 { 259 LastChar = BufChar; 260 BufChar = Buffer[i]; 261 262 if (isprint (BufChar)) 263 { 264 /* Handle embedded C comment sequences */ 265 266 if (((LastChar == '*') && (BufChar == '/')) || 267 ((LastChar == '/') && (BufChar == '*'))) 268 { 269 /* Insert a space to break the sequence */ 270 271 FlPrintFile (FileId, ".", BufChar); 272 } 273 274 FlPrintFile (FileId, "%c", BufChar); 275 } 276 else 277 { 278 /* Not a printable character, just put out a dot */ 279 280 FlPrintFile (FileId, "."); 281 } 282 } 283 FlPrintFile (FileId, "\""); 284 } 285 286 287 /******************************************************************************* 288 * 289 * FUNCTION: LsAmlListingWalk 290 * 291 * PARAMETERS: ASL_WALK_CALLBACK 292 * 293 * RETURN: Status 294 * 295 * DESCRIPTION: Process one node during a listing file generation. 296 * 297 ******************************************************************************/ 298 299 static ACPI_STATUS 300 LsAmlListingWalk ( 301 ACPI_PARSE_OBJECT *Op, 302 UINT32 Level, 303 void *Context) 304 { 305 UINT8 FileByte; 306 UINT32 i; 307 UINT32 FileId = (UINT32) ACPI_TO_INTEGER (Context); 308 309 310 LsWriteNodeToListing (Op, FileId); 311 312 if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DATA) 313 { 314 /* Buffer is a resource template, don't dump the data all at once */ 315 316 return (AE_OK); 317 } 318 319 /* Write the hex bytes to the listing file(s) (if requested) */ 320 321 for (i = 0; i < Op->Asl.FinalAmlLength; i++) 322 { 323 if (ACPI_FAILURE (FlReadFile (ASL_FILE_AML_OUTPUT, &FileByte, 1))) 324 { 325 FlFileError (ASL_FILE_AML_OUTPUT, ASL_MSG_READ); 326 AslAbort (); 327 } 328 LsWriteListingHexBytes (&FileByte, 1, FileId); 329 } 330 331 return (AE_OK); 332 } 333 334 335 /******************************************************************************* 336 * 337 * FUNCTION: LsGenerateListing 338 * 339 * PARAMETERS: FileId - ID of listing file 340 * 341 * RETURN: None 342 * 343 * DESCRIPTION: Generate a listing file. This can be one of the several types 344 * of "listings" supported. 345 * 346 ******************************************************************************/ 347 348 static void 349 LsGenerateListing ( 350 UINT32 FileId) 351 { 352 353 /* Start at the beginning of both the source and AML files */ 354 355 FlSeekFile (ASL_FILE_SOURCE_OUTPUT, 0); 356 FlSeekFile (ASL_FILE_AML_OUTPUT, 0); 357 Gbl_SourceLine = 0; 358 Gbl_CurrentHexColumn = 0; 359 LsPushNode (Gbl_Files[ASL_FILE_INPUT].Filename); 360 361 /* Process all parse nodes */ 362 363 TrWalkParseTree (RootNode, ASL_WALK_VISIT_DOWNWARD, LsAmlListingWalk, 364 NULL, (void *) ACPI_TO_POINTER (FileId)); 365 366 /* Final processing */ 367 368 LsFinishSourceListing (FileId); 369 } 370 371 372 /******************************************************************************* 373 * 374 * FUNCTION: LsDoListings 375 * 376 * PARAMETERS: None. 377 * 378 * RETURN: None 379 * 380 * DESCRIPTION: Generate all requested listing files. 381 * 382 ******************************************************************************/ 383 384 void 385 LsDoListings ( 386 void) 387 { 388 389 if (Gbl_C_OutputFlag) 390 { 391 LsGenerateListing (ASL_FILE_C_SOURCE_OUTPUT); 392 } 393 394 if (Gbl_ListingFlag) 395 { 396 LsGenerateListing (ASL_FILE_LISTING_OUTPUT); 397 } 398 399 if (Gbl_AsmOutputFlag) 400 { 401 LsGenerateListing (ASL_FILE_ASM_SOURCE_OUTPUT); 402 } 403 404 if (Gbl_C_IncludeOutputFlag) 405 { 406 LsGenerateListing (ASL_FILE_C_INCLUDE_OUTPUT); 407 } 408 409 if (Gbl_AsmIncludeOutputFlag) 410 { 411 LsGenerateListing (ASL_FILE_ASM_INCLUDE_OUTPUT); 412 } 413 } 414 415 416 /******************************************************************************* 417 * 418 * FUNCTION: LsPushNode 419 * 420 * PARAMETERS: Filename - Pointer to the include filename 421 * 422 * RETURN: None 423 * 424 * DESCRIPTION: Push a listing node on the listing/include file stack. This 425 * stack enables tracking of include files (infinitely nested) 426 * and resumption of the listing of the parent file when the 427 * include file is finished. 428 * 429 ******************************************************************************/ 430 431 static void 432 LsPushNode ( 433 char *Filename) 434 { 435 ASL_LISTING_NODE *Lnode; 436 437 438 /* Create a new node */ 439 440 Lnode = UtLocalCalloc (sizeof (ASL_LISTING_NODE)); 441 442 /* Initialize */ 443 444 Lnode->Filename = Filename; 445 Lnode->LineNumber = 0; 446 447 /* Link (push) */ 448 449 Lnode->Next = Gbl_ListingNode; 450 Gbl_ListingNode = Lnode; 451 } 452 453 454 /******************************************************************************* 455 * 456 * FUNCTION: LsPopNode 457 * 458 * PARAMETERS: None 459 * 460 * RETURN: List head after current head is popped off 461 * 462 * DESCRIPTION: Pop the current head of the list, free it, and return the 463 * next node on the stack (the new current node). 464 * 465 ******************************************************************************/ 466 467 static ASL_LISTING_NODE * 468 LsPopNode ( 469 void) 470 { 471 ASL_LISTING_NODE *Lnode; 472 473 474 /* Just grab the node at the head of the list */ 475 476 Lnode = Gbl_ListingNode; 477 if ((!Lnode) || 478 (!Lnode->Next)) 479 { 480 AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, NULL, 481 "Could not pop empty listing stack"); 482 return Gbl_ListingNode; 483 } 484 485 Gbl_ListingNode = Lnode->Next; 486 ACPI_FREE (Lnode); 487 488 /* New "Current" node is the new head */ 489 490 return (Gbl_ListingNode); 491 } 492 493 494 /******************************************************************************* 495 * 496 * FUNCTION: LsCheckException 497 * 498 * PARAMETERS: LineNumber - Current logical (cumulative) line # 499 * FileId - ID of output listing file 500 * 501 * RETURN: None 502 * 503 * DESCRIPTION: Check if there is an exception for this line, and if there is, 504 * put it in the listing immediately. Handles multiple errors 505 * per line. Gbl_NextError points to the next error in the 506 * sorted (by line #) list of compile errors/warnings. 507 * 508 ******************************************************************************/ 509 510 static void 511 LsCheckException ( 512 UINT32 LineNumber, 513 UINT32 FileId) 514 { 515 516 if ((!Gbl_NextError) || 517 (LineNumber < Gbl_NextError->LogicalLineNumber )) 518 { 519 return; 520 } 521 522 /* Handle multiple errors per line */ 523 524 if (FileId == ASL_FILE_LISTING_OUTPUT) 525 { 526 while (Gbl_NextError && 527 (LineNumber >= Gbl_NextError->LogicalLineNumber)) 528 { 529 AePrintException (FileId, Gbl_NextError, "\n[****iasl****]\n"); 530 531 Gbl_NextError = Gbl_NextError->Next; 532 } 533 534 FlPrintFile (FileId, "\n"); 535 } 536 } 537 538 539 /******************************************************************************* 540 * 541 * FUNCTION: LsFlushListingBuffer 542 * 543 * PARAMETERS: FileId - ID of the listing file 544 * 545 * RETURN: None 546 * 547 * DESCRIPTION: Flush out the current contents of the 16-byte hex AML code 548 * buffer. Usually called at the termination of a single line 549 * of source code or when the buffer is full. 550 * 551 ******************************************************************************/ 552 553 static void 554 LsFlushListingBuffer ( 555 UINT32 FileId) 556 { 557 UINT32 i; 558 559 560 if (Gbl_CurrentHexColumn == 0) 561 { 562 return; 563 } 564 565 /* Write the hex bytes */ 566 567 switch (FileId) 568 { 569 case ASL_FILE_LISTING_OUTPUT: 570 571 for (i = 0; i < Gbl_CurrentHexColumn; i++) 572 { 573 FlPrintFile (FileId, "%2.2X ", Gbl_AmlBuffer[i]); 574 } 575 576 for (i = 0; i < ((HEX_LISTING_LINE_SIZE - Gbl_CurrentHexColumn) * 3); i++) 577 { 578 FlWriteFile (FileId, ".", 1); 579 } 580 581 /* Write the ASCII character associated with each of the bytes */ 582 583 LsDumpAscii (FileId, Gbl_CurrentHexColumn, Gbl_AmlBuffer); 584 break; 585 586 587 case ASL_FILE_ASM_SOURCE_OUTPUT: 588 589 for (i = 0; i < Gbl_CurrentHexColumn; i++) 590 { 591 if (i > 0) 592 { 593 FlPrintFile (FileId, ","); 594 } 595 FlPrintFile (FileId, "0%2.2Xh", Gbl_AmlBuffer[i]); 596 } 597 598 for (i = 0; i < ((HEX_LISTING_LINE_SIZE - Gbl_CurrentHexColumn) * 5); i++) 599 { 600 FlWriteFile (FileId, " ", 1); 601 } 602 603 FlPrintFile (FileId, " ;%8.8X", 604 Gbl_CurrentAmlOffset - HEX_LISTING_LINE_SIZE); 605 606 /* Write the ASCII character associated with each of the bytes */ 607 608 LsDumpAscii (FileId, Gbl_CurrentHexColumn, Gbl_AmlBuffer); 609 break; 610 611 612 case ASL_FILE_C_SOURCE_OUTPUT: 613 614 for (i = 0; i < Gbl_CurrentHexColumn; i++) 615 { 616 FlPrintFile (FileId, "0x%2.2X,", Gbl_AmlBuffer[i]); 617 } 618 619 for (i = 0; i < ((HEX_LISTING_LINE_SIZE - Gbl_CurrentHexColumn) * 5); i++) 620 { 621 FlWriteFile (FileId, " ", 1); 622 } 623 624 FlPrintFile (FileId, " /* %8.8X", 625 Gbl_CurrentAmlOffset - HEX_LISTING_LINE_SIZE); 626 627 /* Write the ASCII character associated with each of the bytes */ 628 629 LsDumpAsciiInComment (FileId, Gbl_CurrentHexColumn, Gbl_AmlBuffer); 630 FlPrintFile (FileId, " */"); 631 break; 632 633 default: 634 /* No other types supported */ 635 return; 636 } 637 638 FlPrintFile (FileId, "\n"); 639 640 Gbl_CurrentHexColumn = 0; 641 Gbl_HexBytesWereWritten = TRUE; 642 } 643 644 645 /******************************************************************************* 646 * 647 * FUNCTION: LsWriteListingHexBytes 648 * 649 * PARAMETERS: Buffer - AML code buffer 650 * Length - Number of AML bytes to write 651 * FileId - ID of current listing file. 652 * 653 * RETURN: None 654 * 655 * DESCRIPTION: Write the contents of the AML buffer to the listing file via 656 * the listing buffer. The listing buffer is flushed every 16 657 * AML bytes. 658 * 659 ******************************************************************************/ 660 661 static void 662 LsWriteListingHexBytes ( 663 UINT8 *Buffer, 664 UINT32 Length, 665 UINT32 FileId) 666 { 667 UINT32 i; 668 669 670 /* Transfer all requested bytes */ 671 672 for (i = 0; i < Length; i++) 673 { 674 /* Print line header when buffer is empty */ 675 676 if (Gbl_CurrentHexColumn == 0) 677 { 678 if (Gbl_HasIncludeFiles) 679 { 680 FlPrintFile (FileId, "%*s", 10, " "); 681 } 682 683 switch (FileId) 684 { 685 case ASL_FILE_LISTING_OUTPUT: 686 687 FlPrintFile (FileId, "%8.8X....", Gbl_CurrentAmlOffset); 688 break; 689 690 case ASL_FILE_ASM_SOURCE_OUTPUT: 691 692 FlPrintFile (FileId, " db "); 693 break; 694 695 case ASL_FILE_C_SOURCE_OUTPUT: 696 697 FlPrintFile (FileId, " "); 698 break; 699 700 default: 701 /* No other types supported */ 702 return; 703 } 704 } 705 706 /* Transfer AML byte and update counts */ 707 708 Gbl_AmlBuffer[Gbl_CurrentHexColumn] = Buffer[i]; 709 710 Gbl_CurrentHexColumn++; 711 Gbl_CurrentAmlOffset++; 712 713 /* Flush buffer when it is full */ 714 715 if (Gbl_CurrentHexColumn >= HEX_LISTING_LINE_SIZE) 716 { 717 LsFlushListingBuffer (FileId); 718 } 719 } 720 } 721 722 723 /******************************************************************************* 724 * 725 * FUNCTION: LsWriteOneSourceLine 726 * 727 * PARAMETERS: FileID - ID of current listing file 728 * 729 * RETURN: FALSE on EOF (input source file), TRUE otherwise 730 * 731 * DESCRIPTION: Read one line from the input source file and echo it to the 732 * listing file, prefixed with the line number, and if the source 733 * file contains include files, prefixed with the current filename 734 * 735 ******************************************************************************/ 736 737 static UINT32 738 LsWriteOneSourceLine ( 739 UINT32 FileId) 740 { 741 UINT8 FileByte; 742 743 744 Gbl_SourceLine++; 745 Gbl_ListingNode->LineNumber++; 746 747 if (FileId == ASL_FILE_C_SOURCE_OUTPUT) 748 { 749 FlPrintFile (FileId, " *"); 750 } 751 if (FileId == ASL_FILE_ASM_SOURCE_OUTPUT) 752 { 753 FlPrintFile (FileId, "; "); 754 } 755 756 if (Gbl_HasIncludeFiles) 757 { 758 /* 759 * This file contains "include" statements, print the current 760 * filename and line number within the current file 761 */ 762 FlPrintFile (FileId, "%12s %5d....", 763 Gbl_ListingNode->Filename, Gbl_ListingNode->LineNumber); 764 } 765 else 766 { 767 /* No include files, just print the line number */ 768 769 FlPrintFile (FileId, "%8d....", Gbl_SourceLine); 770 } 771 772 /* Read one line (up to a newline or EOF) */ 773 774 while (FlReadFile (ASL_FILE_SOURCE_OUTPUT, &FileByte, 1) == AE_OK) 775 { 776 if (FileId == ASL_FILE_C_SOURCE_OUTPUT) 777 { 778 if (FileByte == '/') 779 { 780 FileByte = '*'; 781 } 782 } 783 784 FlWriteFile (FileId, &FileByte, 1); 785 if (FileByte == '\n') 786 { 787 /* 788 * Check if an error occurred on this source line during the compile. 789 * If so, we print the error message after the source line. 790 */ 791 LsCheckException (Gbl_SourceLine, FileId); 792 return (1); 793 } 794 } 795 796 /* EOF on the input file was reached */ 797 798 return (0); 799 } 800 801 802 /******************************************************************************* 803 * 804 * FUNCTION: LsFinishSourceListing 805 * 806 * PARAMETERS: FileId - ID of current listing file. 807 * 808 * RETURN: None 809 * 810 * DESCRIPTION: Cleanup routine for the listing file. Flush the hex AML 811 * listing buffer, and flush out any remaining lines in the 812 * source input file. 813 * 814 ******************************************************************************/ 815 816 static void 817 LsFinishSourceListing ( 818 UINT32 FileId) 819 { 820 821 if ((FileId == ASL_FILE_ASM_INCLUDE_OUTPUT) || 822 (FileId == ASL_FILE_C_INCLUDE_OUTPUT)) 823 { 824 return; 825 } 826 827 LsFlushListingBuffer (FileId); 828 Gbl_CurrentAmlOffset = 0; 829 830 /* Flush any remaining text in the source file */ 831 832 if (FileId == ASL_FILE_C_SOURCE_OUTPUT) 833 { 834 FlPrintFile (FileId, " /*\n"); 835 } 836 837 while (LsWriteOneSourceLine (FileId)) 838 { ; } 839 840 if (FileId == ASL_FILE_C_SOURCE_OUTPUT) 841 { 842 FlPrintFile (FileId, "\n */\n };\n"); 843 } 844 845 FlPrintFile (FileId, "\n"); 846 847 if (FileId == ASL_FILE_LISTING_OUTPUT) 848 { 849 /* Print a summary of the compile exceptions */ 850 851 FlPrintFile (FileId, "\n\nSummary of errors and warnings\n\n"); 852 AePrintErrorLog (FileId); 853 FlPrintFile (FileId, "\n\n"); 854 UtDisplaySummary (FileId); 855 FlPrintFile (FileId, "\n\n"); 856 } 857 } 858 859 860 /******************************************************************************* 861 * 862 * FUNCTION: LsWriteSourceLines 863 * 864 * PARAMETERS: ToLineNumber - 865 * ToLogicalLineNumber - Write up to this source line number 866 * FileId - ID of current listing file 867 * 868 * RETURN: None 869 * 870 * DESCRIPTION: Read then write source lines to the listing file until we have 871 * reached the specified logical (cumulative) line number. This 872 * automatically echos out comment blocks and other non-AML 873 * generating text until we get to the actual AML-generating line 874 * of ASL code specified by the logical line number. 875 * 876 ******************************************************************************/ 877 878 static void 879 LsWriteSourceLines ( 880 UINT32 ToLineNumber, 881 UINT32 ToLogicalLineNumber, 882 UINT32 FileId) 883 { 884 885 if ((FileId == ASL_FILE_ASM_INCLUDE_OUTPUT) || 886 (FileId == ASL_FILE_C_INCLUDE_OUTPUT)) 887 { 888 return; 889 } 890 891 Gbl_CurrentLine = ToLogicalLineNumber; 892 893 /* Flush any hex bytes remaining from the last opcode */ 894 895 LsFlushListingBuffer (FileId); 896 897 /* Read lines and write them as long as we are not caught up */ 898 899 if (Gbl_SourceLine < Gbl_CurrentLine) 900 { 901 /* 902 * If we just completed writing some AML hex bytes, output a linefeed 903 * to add some whitespace for readability. 904 */ 905 if (Gbl_HexBytesWereWritten) 906 { 907 FlPrintFile (FileId, "\n"); 908 Gbl_HexBytesWereWritten = FALSE; 909 } 910 911 if (FileId == ASL_FILE_C_SOURCE_OUTPUT) 912 { 913 FlPrintFile (FileId, " /*\n"); 914 } 915 916 /* Write one line at a time until we have reached the target line # */ 917 918 while ((Gbl_SourceLine < Gbl_CurrentLine) && 919 LsWriteOneSourceLine (FileId)) 920 { ; } 921 922 if (FileId == ASL_FILE_C_SOURCE_OUTPUT) 923 { 924 FlPrintFile (FileId, " */"); 925 } 926 FlPrintFile (FileId, "\n"); 927 } 928 } 929 930 931 /******************************************************************************* 932 * 933 * FUNCTION: LsWriteNodeToListing 934 * 935 * PARAMETERS: Op - Parse node to write to the listing file. 936 * FileId - ID of current listing file 937 * 938 * RETURN: None. 939 * 940 * DESCRIPTION: Write "a node" to the listing file. This means to 941 * 1) Write out all of the source text associated with the node 942 * 2) Write out all of the AML bytes associated with the node 943 * 3) Write any compiler exceptions associated with the node 944 * 945 ******************************************************************************/ 946 947 static void 948 LsWriteNodeToListing ( 949 ACPI_PARSE_OBJECT *Op, 950 UINT32 FileId) 951 { 952 const ACPI_OPCODE_INFO *OpInfo; 953 UINT32 OpClass; 954 char *Pathname; 955 UINT32 Length; 956 UINT32 i; 957 958 959 OpInfo = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode); 960 OpClass = OpInfo->Class; 961 962 /* TBD: clean this up with a single flag that says: 963 * I start a named output block 964 */ 965 if (FileId == ASL_FILE_C_SOURCE_OUTPUT) 966 { 967 switch (Op->Asl.ParseOpcode) 968 { 969 case PARSEOP_DEFINITIONBLOCK: 970 case PARSEOP_METHODCALL: 971 case PARSEOP_INCLUDE: 972 case PARSEOP_INCLUDE_END: 973 case PARSEOP_DEFAULT_ARG: 974 975 break; 976 977 default: 978 switch (OpClass) 979 { 980 case AML_CLASS_NAMED_OBJECT: 981 switch (Op->Asl.AmlOpcode) 982 { 983 case AML_SCOPE_OP: 984 case AML_ALIAS_OP: 985 break; 986 987 default: 988 if (Op->Asl.ExternalName) 989 { 990 LsFlushListingBuffer (FileId); 991 FlPrintFile (FileId, " };\n"); 992 } 993 break; 994 } 995 break; 996 997 default: 998 /* Don't care about other objects */ 999 break; 1000 } 1001 break; 1002 } 1003 } 1004 1005 /* These cases do not have a corresponding AML opcode */ 1006 1007 switch (Op->Asl.ParseOpcode) 1008 { 1009 case PARSEOP_DEFINITIONBLOCK: 1010 1011 LsWriteSourceLines (Op->Asl.EndLine, Op->Asl.EndLogicalLine, FileId); 1012 1013 /* Use the table Signature and TableId to build a unique name */ 1014 1015 if (FileId == ASL_FILE_ASM_SOURCE_OUTPUT) 1016 { 1017 FlPrintFile (FileId, 1018 "%s_%s_Header \\\n", 1019 Gbl_TableSignature, Gbl_TableId); 1020 } 1021 if (FileId == ASL_FILE_C_SOURCE_OUTPUT) 1022 { 1023 FlPrintFile (FileId, 1024 " unsigned char %s_%s_Header [] =\n {\n", 1025 Gbl_TableSignature, Gbl_TableId); 1026 } 1027 if (FileId == ASL_FILE_ASM_INCLUDE_OUTPUT) 1028 { 1029 FlPrintFile (FileId, 1030 "extrn %s_%s_Header : byte\n", 1031 Gbl_TableSignature, Gbl_TableId); 1032 } 1033 if (FileId == ASL_FILE_C_INCLUDE_OUTPUT) 1034 { 1035 FlPrintFile (FileId, 1036 "extern unsigned char %s_%s_Header [];\n", 1037 Gbl_TableSignature, Gbl_TableId); 1038 } 1039 return; 1040 1041 1042 case PARSEOP_METHODCALL: 1043 1044 LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber, 1045 FileId); 1046 return; 1047 1048 1049 case PARSEOP_INCLUDE: 1050 1051 /* Flush everything up to and including the include source line */ 1052 1053 LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber, 1054 FileId); 1055 1056 /* Create a new listing node and push it */ 1057 1058 LsPushNode (Op->Asl.Child->Asl.Value.String); 1059 return; 1060 1061 1062 case PARSEOP_INCLUDE_END: 1063 1064 /* Flush out the rest of the include file */ 1065 1066 LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber, 1067 FileId); 1068 1069 /* Pop off this listing node and go back to the parent file */ 1070 1071 (void) LsPopNode (); 1072 return; 1073 1074 1075 case PARSEOP_DEFAULT_ARG: 1076 1077 if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC) 1078 { 1079 LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.EndLogicalLine, 1080 FileId); 1081 } 1082 return; 1083 1084 1085 default: 1086 /* All other opcodes have an AML opcode */ 1087 break; 1088 } 1089 1090 /* 1091 * Otherwise, we look at the AML opcode because we can 1092 * switch on the opcode type, getting an entire class 1093 * at once 1094 */ 1095 switch (OpClass) 1096 { 1097 case AML_CLASS_ARGUMENT: /* argument type only */ 1098 case AML_CLASS_INTERNAL: 1099 1100 break; 1101 1102 1103 case AML_CLASS_NAMED_OBJECT: 1104 1105 switch (Op->Asl.AmlOpcode) 1106 { 1107 case AML_FIELD_OP: 1108 case AML_INDEX_FIELD_OP: 1109 case AML_BANK_FIELD_OP: 1110 1111 /* 1112 * For fields, we want to dump all the AML after the 1113 * entire definition 1114 */ 1115 LsWriteSourceLines (Op->Asl.EndLine, Op->Asl.EndLogicalLine, 1116 FileId); 1117 break; 1118 1119 case AML_NAME_OP: 1120 1121 if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC) 1122 { 1123 LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber, 1124 FileId); 1125 } 1126 else 1127 { 1128 /* 1129 * For fields, we want to dump all the AML after the 1130 * entire definition 1131 */ 1132 LsWriteSourceLines (Op->Asl.EndLine, Op->Asl.EndLogicalLine, 1133 FileId); 1134 } 1135 break; 1136 1137 default: 1138 LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber, 1139 FileId); 1140 break; 1141 } 1142 1143 switch (Op->Asl.AmlOpcode) 1144 { 1145 case AML_SCOPE_OP: 1146 case AML_ALIAS_OP: 1147 1148 /* These opcodes do not declare a new object, ignore them */ 1149 1150 break; 1151 1152 default: 1153 1154 /* All other named object opcodes come here */ 1155 1156 switch (FileId) 1157 { 1158 case ASL_FILE_ASM_SOURCE_OUTPUT: 1159 case ASL_FILE_C_SOURCE_OUTPUT: 1160 case ASL_FILE_ASM_INCLUDE_OUTPUT: 1161 case ASL_FILE_C_INCLUDE_OUTPUT: 1162 1163 /* 1164 * For named objects, we will create a valid symbol so that the 1165 * AML code can be referenced from C or ASM 1166 */ 1167 if (Op->Asl.ExternalName) 1168 { 1169 /* Get the full pathname associated with this node */ 1170 1171 Pathname = AcpiNsGetExternalPathname (Op->Asl.Node); 1172 Length = strlen (Pathname); 1173 if (Length >= 4) 1174 { 1175 /* Convert all dots in the path to underscores */ 1176 1177 for (i = 0; i < Length; i++) 1178 { 1179 if (Pathname[i] == '.') 1180 { 1181 Pathname[i] = '_'; 1182 } 1183 } 1184 1185 /* Create the appropriate symbol in the output file */ 1186 1187 if (FileId == ASL_FILE_ASM_SOURCE_OUTPUT) 1188 { 1189 FlPrintFile (FileId, 1190 "%s_%s_%s \\\n", 1191 Gbl_TableSignature, Gbl_TableId, &Pathname[1]); 1192 } 1193 if (FileId == ASL_FILE_C_SOURCE_OUTPUT) 1194 { 1195 FlPrintFile (FileId, 1196 " unsigned char %s_%s_%s [] =\n {\n", 1197 Gbl_TableSignature, Gbl_TableId, &Pathname[1]); 1198 } 1199 if (FileId == ASL_FILE_ASM_INCLUDE_OUTPUT) 1200 { 1201 FlPrintFile (FileId, 1202 "extrn %s_%s_%s : byte\n", 1203 Gbl_TableSignature, Gbl_TableId, &Pathname[1]); 1204 } 1205 if (FileId == ASL_FILE_C_INCLUDE_OUTPUT) 1206 { 1207 FlPrintFile (FileId, 1208 "extern unsigned char %s_%s_%s [];\n", 1209 Gbl_TableSignature, Gbl_TableId, &Pathname[1]); 1210 } 1211 } 1212 ACPI_FREE (Pathname); 1213 } 1214 break; 1215 1216 default: 1217 /* Nothing to do for listing file */ 1218 break; 1219 } 1220 } 1221 break; 1222 1223 case AML_CLASS_EXECUTE: 1224 case AML_CLASS_CREATE: 1225 default: 1226 1227 if ((Op->Asl.ParseOpcode == PARSEOP_BUFFER) && 1228 (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC)) 1229 { 1230 return; 1231 } 1232 1233 LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber, 1234 FileId); 1235 break; 1236 1237 case AML_CLASS_UNKNOWN: 1238 break; 1239 } 1240 } 1241 1242 1243 /******************************************************************************* 1244 * 1245 * FUNCTION: LsDoHexOutput 1246 * 1247 * PARAMETERS: None 1248 * 1249 * RETURN: None. 1250 * 1251 * DESCRIPTION: Create the hex output file. 1252 * 1253 ******************************************************************************/ 1254 1255 void 1256 LsDoHexOutput ( 1257 void) 1258 { 1259 1260 switch (Gbl_HexOutputFlag) 1261 { 1262 case HEX_OUTPUT_C: 1263 1264 LsDoHexOutputC (); 1265 break; 1266 1267 case HEX_OUTPUT_ASM: 1268 1269 LsDoHexOutputAsm (); 1270 break; 1271 1272 case HEX_OUTPUT_ASL: 1273 1274 LsDoHexOutputAsl (); 1275 break; 1276 1277 default: 1278 /* No other output types supported */ 1279 break; 1280 } 1281 } 1282 1283 1284 /******************************************************************************* 1285 * 1286 * FUNCTION: LsDoHexOutputC 1287 * 1288 * PARAMETERS: None 1289 * 1290 * RETURN: None. 1291 * 1292 * DESCRIPTION: Create the hex output file. This is the same data as the AML 1293 * output file, but formatted into hex/ascii bytes suitable for 1294 * inclusion into a C source file. 1295 * 1296 ******************************************************************************/ 1297 1298 static void 1299 LsDoHexOutputC ( 1300 void) 1301 { 1302 UINT8 FileData[HEX_TABLE_LINE_SIZE]; 1303 UINT32 LineLength; 1304 UINT32 Offset = 0; 1305 UINT32 AmlFileSize; 1306 UINT32 i; 1307 1308 1309 /* Get AML size, seek back to start */ 1310 1311 AmlFileSize = FlGetFileSize (ASL_FILE_AML_OUTPUT); 1312 1313 FlPrintFile (ASL_FILE_HEX_OUTPUT, " * C source code output\n"); 1314 FlPrintFile (ASL_FILE_HEX_OUTPUT, " * AML code block contains 0x%X bytes\n *\n */\n", 1315 AmlFileSize); 1316 FlPrintFile (ASL_FILE_HEX_OUTPUT, "unsigned char AmlCode[] =\n{\n"); 1317 1318 while (Offset < AmlFileSize) 1319 { 1320 /* Read enough bytes needed for one output line */ 1321 1322 LineLength = fread (FileData, 1, HEX_TABLE_LINE_SIZE, 1323 Gbl_Files[ASL_FILE_AML_OUTPUT].Handle); 1324 if (!LineLength) 1325 { 1326 break; 1327 } 1328 1329 FlPrintFile (ASL_FILE_HEX_OUTPUT, " "); 1330 1331 for (i = 0; i < LineLength; i++) 1332 { 1333 /* 1334 * Print each hex byte. 1335 * Add a comma until the very last byte of the AML file 1336 * (Some C compilers complain about a trailing comma) 1337 */ 1338 FlPrintFile (ASL_FILE_HEX_OUTPUT, "0x%2.2X", FileData[i]); 1339 if ((Offset + i + 1) < AmlFileSize) 1340 { 1341 FlPrintFile (ASL_FILE_HEX_OUTPUT, ","); 1342 } 1343 else 1344 { 1345 FlPrintFile (ASL_FILE_HEX_OUTPUT, " "); 1346 } 1347 } 1348 1349 /* Add fill spaces if needed for last line */ 1350 1351 if (LineLength < HEX_TABLE_LINE_SIZE) 1352 { 1353 FlPrintFile (ASL_FILE_HEX_OUTPUT, "%*s", 1354 5 * (HEX_TABLE_LINE_SIZE - LineLength), " "); 1355 } 1356 1357 /* Emit the offset and ascii dump for the entire line */ 1358 1359 FlPrintFile (ASL_FILE_HEX_OUTPUT, " /* %8.8X", Offset); 1360 LsDumpAsciiInComment (ASL_FILE_HEX_OUTPUT, LineLength, FileData); 1361 FlPrintFile (ASL_FILE_HEX_OUTPUT, "%*s*/\n", 1362 HEX_TABLE_LINE_SIZE - LineLength + 1, " "); 1363 1364 Offset += LineLength; 1365 } 1366 1367 FlPrintFile (ASL_FILE_HEX_OUTPUT, "};\n"); 1368 FlCloseFile (ASL_FILE_HEX_OUTPUT); 1369 } 1370 1371 1372 /******************************************************************************* 1373 * 1374 * FUNCTION: LsDoHexOutputAsl 1375 * 1376 * PARAMETERS: None 1377 * 1378 * RETURN: None. 1379 * 1380 * DESCRIPTION: Create the hex output file. This is the same data as the AML 1381 * output file, but formatted into hex/ascii bytes suitable for 1382 * inclusion into a C source file. 1383 * 1384 ******************************************************************************/ 1385 1386 static void 1387 LsDoHexOutputAsl ( 1388 void) 1389 { 1390 UINT8 FileData[HEX_TABLE_LINE_SIZE]; 1391 UINT32 LineLength; 1392 UINT32 Offset = 0; 1393 UINT32 AmlFileSize; 1394 UINT32 i; 1395 1396 1397 /* Get AML size, seek back to start */ 1398 1399 AmlFileSize = FlGetFileSize (ASL_FILE_AML_OUTPUT); 1400 1401 FlPrintFile (ASL_FILE_HEX_OUTPUT, " * ASL source code output\n"); 1402 FlPrintFile (ASL_FILE_HEX_OUTPUT, " * AML code block contains 0x%X bytes\n *\n */\n", 1403 AmlFileSize); 1404 FlPrintFile (ASL_FILE_HEX_OUTPUT, " Name (BUF1, Buffer()\n {\n"); 1405 1406 while (Offset < AmlFileSize) 1407 { 1408 /* Read enough bytes needed for one output line */ 1409 1410 LineLength = fread (FileData, 1, HEX_TABLE_LINE_SIZE, 1411 Gbl_Files[ASL_FILE_AML_OUTPUT].Handle); 1412 if (!LineLength) 1413 { 1414 break; 1415 } 1416 1417 FlPrintFile (ASL_FILE_HEX_OUTPUT, " "); 1418 1419 for (i = 0; i < LineLength; i++) 1420 { 1421 /* 1422 * Print each hex byte. 1423 * Add a comma until the very last byte of the AML file 1424 * (Some C compilers complain about a trailing comma) 1425 */ 1426 FlPrintFile (ASL_FILE_HEX_OUTPUT, "0x%2.2X", FileData[i]); 1427 if ((Offset + i + 1) < AmlFileSize) 1428 { 1429 FlPrintFile (ASL_FILE_HEX_OUTPUT, ","); 1430 } 1431 else 1432 { 1433 FlPrintFile (ASL_FILE_HEX_OUTPUT, " "); 1434 } 1435 } 1436 1437 /* Add fill spaces if needed for last line */ 1438 1439 if (LineLength < HEX_TABLE_LINE_SIZE) 1440 { 1441 FlPrintFile (ASL_FILE_HEX_OUTPUT, "%*s", 1442 5 * (HEX_TABLE_LINE_SIZE - LineLength), " "); 1443 } 1444 1445 /* Emit the offset and ascii dump for the entire line */ 1446 1447 FlPrintFile (ASL_FILE_HEX_OUTPUT, " /* %8.8X", Offset); 1448 LsDumpAsciiInComment (ASL_FILE_HEX_OUTPUT, LineLength, FileData); 1449 FlPrintFile (ASL_FILE_HEX_OUTPUT, "%*s*/\n", 1450 HEX_TABLE_LINE_SIZE - LineLength + 1, " "); 1451 1452 Offset += LineLength; 1453 } 1454 1455 FlPrintFile (ASL_FILE_HEX_OUTPUT, " })\n"); 1456 FlCloseFile (ASL_FILE_HEX_OUTPUT); 1457 } 1458 1459 1460 /******************************************************************************* 1461 * 1462 * FUNCTION: LsDoHexOutputAsm 1463 * 1464 * PARAMETERS: None 1465 * 1466 * RETURN: None. 1467 * 1468 * DESCRIPTION: Create the hex output file. This is the same data as the AML 1469 * output file, but formatted into hex/ascii bytes suitable for 1470 * inclusion into a ASM source file. 1471 * 1472 ******************************************************************************/ 1473 1474 static void 1475 LsDoHexOutputAsm ( 1476 void) 1477 { 1478 UINT8 FileData[HEX_TABLE_LINE_SIZE]; 1479 UINT32 LineLength; 1480 UINT32 Offset = 0; 1481 UINT32 AmlFileSize; 1482 UINT32 i; 1483 1484 1485 /* Get AML size, seek back to start */ 1486 1487 AmlFileSize = FlGetFileSize (ASL_FILE_AML_OUTPUT); 1488 1489 FlPrintFile (ASL_FILE_HEX_OUTPUT, "; Assembly code source output\n"); 1490 FlPrintFile (ASL_FILE_HEX_OUTPUT, "; AML code block contains 0x%X bytes\n;\n", 1491 AmlFileSize); 1492 1493 while (Offset < AmlFileSize) 1494 { 1495 /* Read enough bytes needed for one output line */ 1496 1497 LineLength = fread (FileData, 1, HEX_TABLE_LINE_SIZE, 1498 Gbl_Files[ASL_FILE_AML_OUTPUT].Handle); 1499 if (!LineLength) 1500 { 1501 break; 1502 } 1503 1504 FlPrintFile (ASL_FILE_HEX_OUTPUT, " db "); 1505 1506 for (i = 0; i < LineLength; i++) 1507 { 1508 /* 1509 * Print each hex byte. 1510 * Add a comma until the last byte of the line 1511 */ 1512 FlPrintFile (ASL_FILE_HEX_OUTPUT, "0%2.2Xh", FileData[i]); 1513 if ((i + 1) < LineLength) 1514 { 1515 FlPrintFile (ASL_FILE_HEX_OUTPUT, ","); 1516 } 1517 } 1518 1519 FlPrintFile (ASL_FILE_HEX_OUTPUT, " "); 1520 1521 /* Add fill spaces if needed for last line */ 1522 1523 if (LineLength < HEX_TABLE_LINE_SIZE) 1524 { 1525 FlPrintFile (ASL_FILE_HEX_OUTPUT, "%*s", 1526 5 * (HEX_TABLE_LINE_SIZE - LineLength), " "); 1527 } 1528 1529 /* Emit the offset and ascii dump for the entire line */ 1530 1531 FlPrintFile (ASL_FILE_HEX_OUTPUT, " ; %8.8X", Offset); 1532 LsDumpAsciiInComment (ASL_FILE_HEX_OUTPUT, LineLength, FileData); 1533 FlPrintFile (ASL_FILE_HEX_OUTPUT, "\n"); 1534 1535 Offset += LineLength; 1536 } 1537 1538 FlPrintFile (ASL_FILE_HEX_OUTPUT, "\n"); 1539 FlCloseFile (ASL_FILE_HEX_OUTPUT); 1540 } 1541 1542 1543
Indexes created Thu Oct 02 14:10:14 GMT 2025