sys/contrib/dev/acpica/source/compiler/asllisting.c

   1 /******************************************************************************
   2  *
   3  * Module Name: asllisting - Listing file generation
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2018, Intel Corp.
  12  * All rights reserved.
  13  *
  14  * 2. License
  15  *
  16  * 2.1. This is your license from Intel Corp. under its intellectual property
  17  * rights. You may have additional license terms from the party that provided
  18  * you this software, covering your right to use that party's intellectual
  19  * property rights.
  20  *
  21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22  * copy of the source code appearing in this file ("Covered Code") an
  23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25  * make derivatives, distribute, use and display any portion of the Covered
  26  * Code in any form, with the right to sublicense such rights; and
  27  *
  28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29  * license (with the right to sublicense), under only those claims of Intel
  30  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31  * offer to sell, and import the Covered Code and derivative works thereof
  32  * solely to the minimum extent necessary to exercise the above copyright
  33  * license, and in no event shall the patent license extend to any additions
  34  * to or modifications of the Original Intel Code. No other license or right
  35  * is granted directly or by implication, estoppel or otherwise;
  36  *
  37  * The above copyright and patent license is granted only if the following
  38  * conditions are met:
  39  *
  40  * 3. Conditions
  41  *
  42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43  * Redistribution of source code of any substantial portion of the Covered
  44  * Code or modification with rights to further distribute source must include
  45  * the above Copyright Notice, the above License, this list of Conditions,
  46  * and the following Disclaimer and Export Compliance provision. In addition,
  47  * Licensee must cause all Covered Code to which Licensee contributes to
  48  * contain a file documenting the changes Licensee made to create that Covered
  49  * Code and the date of any change. Licensee must include in that file the
  50  * documentation of any changes made by any predecessor Licensee. Licensee
  51  * must include a prominent statement that the modification is derived,
  52  * directly or indirectly, from Original Intel Code.
  53  *
  54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55  * Redistribution of source code of any substantial portion of the Covered
  56  * Code or modification without rights to further distribute source must
  57  * include the following Disclaimer and Export Compliance provision in the
  58  * documentation and/or other materials provided with distribution. In
  59  * addition, Licensee may not authorize further sublicense of source of any
  60  * portion of the Covered Code, and must include terms to the effect that the
  61  * license from Licensee to its licensee is limited to the intellectual
  62  * property embodied in the software Licensee provides to its licensee, and
  63  * not to intellectual property embodied in modifications its licensee may
  64  * make.
  65  *
  66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67  * substantial portion of the Covered Code or modification must reproduce the
  68  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69  * provision in the documentation and/or other materials provided with the
  70  * distribution.
  71  *
  72  * 3.4. Intel retains all right, title, and interest in and to the Original
  73  * Intel Code.
  74  *
  75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77  * other dealings in products derived from or relating to the Covered Code
  78  * without prior written authorization from Intel.
  79  *
  80  * 4. Disclaimer and Export Compliance
  81  *
  82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
  85  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
  86  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.
  89  *
  90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
  96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97  * LIMITED REMEDY.
  98  *
  99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 100  * software or system incorporating such software without first obtaining any
 101  * required license or other approval from the U. S. Department of Commerce or
 102  * any other agency or department of the United States Government. In the
 103  * event Licensee exports any such software from the United States or
 104  * re-exports any such software from a foreign destination, Licensee shall
 105  * ensure that the distribution and export/re-export of the software is in
 106  * compliance with all laws, regulations, orders, or other restrictions of the
 107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 108  * any of its subsidiaries will export/re-export any technical data, process,
 109  * software, or service, directly or indirectly, to any country for which the
 110  * United States government or any agency thereof requires an export license,
 111  * other governmental approval, or letter of assurance, without first obtaining
 112  * such license, approval or letter.
 113  *
 114  *****************************************************************************
 115  *
 116  * Alternatively, you may choose to be licensed under the terms of the
 117  * following license:
 118  *
 119  * Redistribution and use in source and binary forms, with or without
 120  * modification, are permitted provided that the following conditions
 121  * are met:
 122  * 1. Redistributions of source code must retain the above copyright
 123  *    notice, this list of conditions, and the following disclaimer,
 124  *    without modification.
 125  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 126  *    substantially similar to the "NO WARRANTY" disclaimer below
 127  *    ("Disclaimer") and any redistribution must be conditioned upon
 128  *    including a substantially similar Disclaimer requirement for further
 129  *    binary redistribution.
 130  * 3. Neither the names of the above-listed copyright holders nor the names
 131  *    of any contributors may be used to endorse or promote products derived
 132  *    from this software without specific prior written permission.
 133  *
 134  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 135  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 136  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 137  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 138  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 139  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 140  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 141  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 142  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 143  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 144  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 145  *
 146  * Alternatively, you may choose to be licensed under the terms of the
 147  * GNU General Public License ("GPL") version 2 as published by the Free
 148  * Software Foundation.
 149  *
 150  *****************************************************************************/
 151
 152 #include "aslcompiler.h"
 153 #include "aslcompiler.y.h"
 154 #include "amlcode.h"
 155 #include "acparser.h"
 156 #include "acnamesp.h"
 157
 158
 159 #define _COMPONENT          ACPI_COMPILER
 160         ACPI_MODULE_NAME    ("asllisting")
 161
 162
 163 /* Local prototypes */
 164
 165 static void
 166 LsGenerateListing (
 167     UINT32                  FileId);
 168
 169 static ACPI_STATUS
 170 LsAmlListingWalk (
 171     ACPI_PARSE_OBJECT       *Op,
 172     UINT32                  Level,
 173     void                    *Context);
 174
 175 static ACPI_STATUS
 176 LsTreeWriteWalk (
 177     ACPI_PARSE_OBJECT       *Op,
 178     UINT32                  Level,
 179     void                    *Context);
 180
 181 static void
 182 LsWriteNodeToListing (
 183     ACPI_PARSE_OBJECT       *Op,
 184     UINT32                  FileId);
 185
 186 static void
 187 LsFinishSourceListing (
 188     UINT32                  FileId);
 189
 190
 191 /*******************************************************************************
 192  *
 193  * FUNCTION:    LsDoListings
 194  *
 195  * PARAMETERS:  None. Examines the various output file global flags.
 196  *
 197  * RETURN:      None
 198  *
 199  * DESCRIPTION: Generate all requested listing files.
 200  *
 201  ******************************************************************************/
 202
 203 void
 204 LsDoListings (
 205     void)
 206 {
 207
 208     if (Gbl_C_OutputFlag)
 209     {
 210         LsGenerateListing (ASL_FILE_C_SOURCE_OUTPUT);
 211     }
 212
 213     if (Gbl_ListingFlag)
 214     {
 215         LsGenerateListing (ASL_FILE_LISTING_OUTPUT);
 216     }
 217
 218     if (Gbl_AsmOutputFlag)
 219     {
 220         LsGenerateListing (ASL_FILE_ASM_SOURCE_OUTPUT);
 221     }
 222
 223     if (Gbl_C_IncludeOutputFlag)
 224     {
 225         LsGenerateListing (ASL_FILE_C_INCLUDE_OUTPUT);
 226     }
 227
 228     if (Gbl_AsmIncludeOutputFlag)
 229     {
 230         LsGenerateListing (ASL_FILE_ASM_INCLUDE_OUTPUT);
 231     }
 232
 233     if (Gbl_C_OffsetTableFlag)
 234     {
 235         LsGenerateListing (ASL_FILE_C_OFFSET_OUTPUT);
 236     }
 237 }
 238
 239
 240 /*******************************************************************************
 241  *
 242  * FUNCTION:    LsGenerateListing
 243  *
 244  * PARAMETERS:  FileId      - ID of listing file
 245  *
 246  * RETURN:      None
 247  *
 248  * DESCRIPTION: Generate a listing file. This can be one of the several types
 249  *              of "listings" supported.
 250  *
 251  ******************************************************************************/
 252
 253 static void
 254 LsGenerateListing (
 255     UINT32                  FileId)
 256 {
 257
 258     /* Start at the beginning of both the source and AML files */
 259
 260     FlSeekFile (ASL_FILE_SOURCE_OUTPUT, 0);
 261     FlSeekFile (ASL_FILE_AML_OUTPUT, 0);
 262     Gbl_SourceLine = 0;
 263     Gbl_CurrentHexColumn = 0;
 264     LsPushNode (Gbl_Files[ASL_FILE_INPUT].Filename);
 265
 266     if (FileId == ASL_FILE_C_OFFSET_OUTPUT)
 267     {
 268         Gbl_CurrentAmlOffset = 0;
 269
 270         /* Offset table file has a special header and footer */
 271
 272         LsDoOffsetTableHeader (FileId);
 273
 274         TrWalkParseTree (Gbl_ParseTreeRoot, ASL_WALK_VISIT_DOWNWARD,
 275             LsAmlOffsetWalk, NULL, (void *) ACPI_TO_POINTER (FileId));
 276         LsDoOffsetTableFooter (FileId);
 277         return;
 278     }
 279
 280     /* Process all parse nodes */
 281
 282     TrWalkParseTree (Gbl_ParseTreeRoot, ASL_WALK_VISIT_DOWNWARD,
 283         LsAmlListingWalk, NULL, (void *) ACPI_TO_POINTER (FileId));
 284
 285     /* Final processing */
 286
 287     LsFinishSourceListing (FileId);
 288 }
 289
 290
 291 /*******************************************************************************
 292  *
 293  * FUNCTION:    LsAmlListingWalk
 294  *
 295  * PARAMETERS:  ASL_WALK_CALLBACK
 296  *
 297  * RETURN:      Status
 298  *
 299  * DESCRIPTION: Process one node during a listing file generation.
 300  *
 301  ******************************************************************************/
 302
 303 static ACPI_STATUS
 304 LsAmlListingWalk (
 305     ACPI_PARSE_OBJECT       *Op,
 306     UINT32                  Level,
 307     void                    *Context)
 308 {
 309     UINT8                   FileByte;
 310     UINT32                  i;
 311     UINT32                  FileId = (UINT32) ACPI_TO_INTEGER (Context);
 312
 313
 314     LsWriteNodeToListing (Op, FileId);
 315
 316     if (Op->Asl.CompileFlags & OP_IS_RESOURCE_DATA)
 317     {
 318         /* Buffer is a resource template, don't dump the data all at once */
 319
 320         return (AE_OK);
 321     }
 322
 323     if ((FileId == ASL_FILE_ASM_INCLUDE_OUTPUT) ||
 324         (FileId == ASL_FILE_C_INCLUDE_OUTPUT))
 325     {
 326         return (AE_OK);
 327     }
 328
 329     /* Write the hex bytes to the listing file(s) (if requested) */
 330
 331     for (i = 0; i < Op->Asl.FinalAmlLength; i++)
 332     {
 333         if (ACPI_FAILURE (FlReadFile (ASL_FILE_AML_OUTPUT, &FileByte, 1)))
 334         {
 335             FlFileError (ASL_FILE_AML_OUTPUT, ASL_MSG_READ);
 336             AslAbort ();
 337         }
 338
 339         LsWriteListingHexBytes (&FileByte, 1, FileId);
 340     }
 341
 342     return (AE_OK);
 343 }
 344
 345
 346 /*******************************************************************************
 347  *
 348  * FUNCTION:    LsDumpParseTree, LsTreeWriteWalk
 349  *
 350  * PARAMETERS:  None
 351  *
 352  * RETURN:      None
 353  *
 354  * DESCRIPTION: Dump entire parse tree, for compiler debug only
 355  *
 356  ******************************************************************************/
 357
 358 void
 359 LsDumpParseTree (
 360     void)
 361 {
 362
 363     if (!Gbl_DebugFlag)
 364     {
 365         return;
 366     }
 367
 368     DbgPrint (ASL_TREE_OUTPUT, "\nOriginal parse tree from parser:\n\n");
 369     DbgPrint (ASL_TREE_OUTPUT, ASL_PARSE_TREE_HEADER1);
 370
 371     TrWalkParseTree (Gbl_ParseTreeRoot, ASL_WALK_VISIT_DOWNWARD,
 372         LsTreeWriteWalk, NULL, NULL);
 373
 374     DbgPrint (ASL_TREE_OUTPUT, ASL_PARSE_TREE_HEADER1);
 375 }
 376
 377
 378 static ACPI_STATUS
 379 LsTreeWriteWalk (
 380     ACPI_PARSE_OBJECT       *Op,
 381     UINT32                  Level,
 382     void                    *Context)
 383 {
 384
 385     /* Dump ParseOp name and possible value */
 386
 387     switch (Op->Asl.ParseOpcode)
 388     {
 389         case PARSEOP_NAMESEG:
 390         case PARSEOP_NAMESTRING:
 391         case PARSEOP_METHODCALL:
 392         case PARSEOP_STRING_LITERAL:
 393
 394         UtDumpStringOp (Op, Level);
 395         break;
 396
 397     case PARSEOP_BYTECONST:
 398
 399         UtDumpIntegerOp (Op, Level, 2);
 400         break;
 401
 402     case PARSEOP_WORDCONST:
 403     case PARSEOP_PACKAGE_LENGTH:
 404
 405         UtDumpIntegerOp (Op, Level, 4);
 406         break;
 407
 408     case PARSEOP_DWORDCONST:
 409     case PARSEOP_EISAID:
 410
 411         UtDumpIntegerOp (Op, Level, 8);
 412         break;
 413
 414     case PARSEOP_QWORDCONST:
 415     case PARSEOP_INTEGER:
 416     case PARSEOP_ONE:
 417     case PARSEOP_ZERO:
 418     case PARSEOP_ONES:
 419
 420         UtDumpIntegerOp (Op, Level, 16);
 421         break;
 422
 423     case PARSEOP_INCLUDE:
 424
 425         DbgPrint (ASL_TREE_OUTPUT,
 426             "Open: %s\n", Op->Asl.Value.String);
 427         return (AE_OK);
 428
 429     case PARSEOP_INCLUDE_END:
 430
 431         DbgPrint (ASL_TREE_OUTPUT,
 432             "Close: %s\n", Op->Asl.Filename);
 433         return (AE_OK);
 434
 435     default:
 436
 437         UtDumpBasicOp (Op, Level);
 438         break;
 439     }
 440
 441     /* Dump the remaining data */
 442
 443     DbgPrint (ASL_TREE_OUTPUT, ASL_PARSE_TREE_DEBUG1,
 444         Op->Asl.ParseOpcode, Op->Asl.CompileFlags,
 445         Op->Asl.LineNumber, Op->Asl.EndLine,
 446         Op->Asl.LogicalLineNumber, Op->Asl.EndLogicalLine);
 447
 448     TrPrintOpFlags (Op->Asl.CompileFlags, ASL_TREE_OUTPUT);
 449     DbgPrint (ASL_TREE_OUTPUT, "\n");
 450     return (AE_OK);
 451 }
 452
 453
 454 /*******************************************************************************
 455  *
 456  * FUNCTION:    LsWriteNodeToListing
 457  *
 458  * PARAMETERS:  Op              - Parse node to write to the listing file.
 459  *              FileId          - ID of current listing file
 460  *
 461  * RETURN:      None.
 462  *
 463  * DESCRIPTION: Write "a node" to the listing file. This means to
 464  *              1) Write out all of the source text associated with the node
 465  *              2) Write out all of the AML bytes associated with the node
 466  *              3) Write any compiler exceptions associated with the node
 467  *
 468  ******************************************************************************/
 469
 470 static void
 471 LsWriteNodeToListing (
 472     ACPI_PARSE_OBJECT       *Op,
 473     UINT32                  FileId)
 474 {
 475     const ACPI_OPCODE_INFO  *OpInfo;
 476     UINT32                  OpClass;
 477     char                    *Pathname;
 478     UINT32                  Length;
 479     UINT32                  i;
 480
 481
 482     OpInfo  = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
 483     OpClass = OpInfo->Class;
 484
 485     /* TBD: clean this up with a single flag that says:
 486      * I start a named output block
 487      */
 488     if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
 489     {
 490         switch (Op->Asl.ParseOpcode)
 491         {
 492         case PARSEOP_DEFINITION_BLOCK:
 493         case PARSEOP_METHODCALL:
 494         case PARSEOP_INCLUDE:
 495         case PARSEOP_INCLUDE_END:
 496         case PARSEOP_DEFAULT_ARG:
 497
 498             break;
 499
 500         default:
 501
 502             switch (OpClass)
 503             {
 504             case AML_CLASS_NAMED_OBJECT:
 505
 506                 switch (Op->Asl.AmlOpcode)
 507                 {
 508                 case AML_SCOPE_OP:
 509                 case AML_ALIAS_OP:
 510
 511                     break;
 512
 513                 default:
 514
 515                     if (Op->Asl.ExternalName)
 516                     {
 517                         LsFlushListingBuffer (FileId);
 518                         FlPrintFile (FileId, "    };\n");
 519                     }
 520                     break;
 521                 }
 522                 break;
 523
 524             default:
 525
 526                 /* Don't care about other objects */
 527
 528                 break;
 529             }
 530             break;
 531         }
 532     }
 533
 534     /* These cases do not have a corresponding AML opcode */
 535
 536     switch (Op->Asl.ParseOpcode)
 537     {
 538     case PARSEOP_DEFINITION_BLOCK:
 539
 540         /* Always start a definition block at AML offset zero */
 541
 542         Gbl_CurrentAmlOffset = 0;
 543         LsWriteSourceLines (Op->Asl.EndLine, Op->Asl.EndLogicalLine, FileId);
 544
 545         /* Use the table Signature and TableId to build a unique name */
 546
 547         switch (FileId)
 548         {
 549         case ASL_FILE_ASM_SOURCE_OUTPUT:
 550
 551             FlPrintFile (FileId,
 552                 "%s_%s_Header \\\n",
 553                 Gbl_TableSignature, Gbl_TableId);
 554             break;
 555
 556         case ASL_FILE_C_SOURCE_OUTPUT:
 557
 558             FlPrintFile (FileId,
 559                 "    unsigned char    %s_%s_Header [] =\n    {\n",
 560                 Gbl_TableSignature, Gbl_TableId);
 561             break;
 562
 563         case ASL_FILE_ASM_INCLUDE_OUTPUT:
 564
 565             FlPrintFile (FileId,
 566                 "extrn %s_%s_Header : byte\n",
 567                 Gbl_TableSignature, Gbl_TableId);
 568             break;
 569
 570         case ASL_FILE_C_INCLUDE_OUTPUT:
 571
 572             FlPrintFile (FileId,
 573                 "extern unsigned char    %s_%s_Header [];\n",
 574                 Gbl_TableSignature, Gbl_TableId);
 575             break;
 576
 577         default:
 578             break;
 579         }
 580
 581         return;
 582
 583
 584     case PARSEOP_METHODCALL:
 585
 586         LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
 587             FileId);
 588         return;
 589
 590
 591     case PARSEOP_INCLUDE:
 592
 593         /* Flush everything up to and including the include source line */
 594
 595         LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
 596             FileId);
 597
 598         /* Create a new listing node and push it */
 599
 600         LsPushNode (Op->Asl.Value.String);
 601         return;
 602
 603
 604     case PARSEOP_INCLUDE_END:
 605
 606         /* Flush out the rest of the include file */
 607
 608         LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
 609             FileId);
 610
 611         /* Pop off this listing node and go back to the parent file */
 612
 613         (void) LsPopNode ();
 614         return;
 615
 616
 617     case PARSEOP_DEFAULT_ARG:
 618
 619         if (Op->Asl.CompileFlags & OP_IS_RESOURCE_DESC)
 620         {
 621             LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.EndLogicalLine,
 622                 FileId);
 623         }
 624         return;
 625
 626
 627     default:
 628
 629         /* All other opcodes have an AML opcode */
 630
 631         break;
 632     }
 633
 634     /*
 635      * Otherwise, we look at the AML opcode because we can
 636      * switch on the opcode type, getting an entire class
 637      * at once
 638      */
 639     switch (OpClass)
 640     {
 641     case AML_CLASS_ARGUMENT:       /* argument type only */
 642     case AML_CLASS_INTERNAL:
 643
 644         break;
 645
 646     case AML_CLASS_NAMED_OBJECT:
 647
 648         switch (Op->Asl.AmlOpcode)
 649         {
 650         case AML_FIELD_OP:
 651         case AML_INDEX_FIELD_OP:
 652         case AML_BANK_FIELD_OP:
 653             /*
 654              * For fields, we want to dump all the AML after the
 655              * entire definition
 656              */
 657             LsWriteSourceLines (Op->Asl.EndLine, Op->Asl.EndLogicalLine,
 658                 FileId);
 659             break;
 660
 661         case AML_NAME_OP:
 662
 663             if (Op->Asl.CompileFlags & OP_IS_RESOURCE_DESC)
 664             {
 665                 LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
 666                     FileId);
 667             }
 668             else
 669             {
 670                 /*
 671                  * For fields, we want to dump all the AML after the
 672                  * entire definition
 673                  */
 674                 LsWriteSourceLines (Op->Asl.EndLine, Op->Asl.EndLogicalLine,
 675                     FileId);
 676             }
 677             break;
 678
 679         default:
 680
 681             LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
 682                 FileId);
 683             break;
 684         }
 685
 686         switch (Op->Asl.AmlOpcode)
 687         {
 688         case AML_SCOPE_OP:
 689         case AML_ALIAS_OP:
 690
 691             /* These opcodes do not declare a new object, ignore them */
 692
 693             break;
 694
 695         default:
 696
 697             /* All other named object opcodes come here */
 698
 699             switch (FileId)
 700             {
 701             case ASL_FILE_ASM_SOURCE_OUTPUT:
 702             case ASL_FILE_C_SOURCE_OUTPUT:
 703             case ASL_FILE_ASM_INCLUDE_OUTPUT:
 704             case ASL_FILE_C_INCLUDE_OUTPUT:
 705                 /*
 706                  * For named objects, we will create a valid symbol so that the
 707                  * AML code can be referenced from C or ASM
 708                  */
 709                 if (Op->Asl.ExternalName)
 710                 {
 711                     /* Get the full pathname associated with this node */
 712
 713                     Pathname = AcpiNsGetExternalPathname (Op->Asl.Node);
 714                     Length = strlen (Pathname);
 715                     if (Length >= 4)
 716                     {
 717                         /* Convert all dots in the path to underscores */
 718
 719                         for (i = 0; i < Length; i++)
 720                         {
 721                             if (Pathname[i] == '.')
 722                             {
 723                                 Pathname[i] = '_';
 724                             }
 725                         }
 726
 727                         /* Create the appropriate symbol in the output file */
 728
 729                         switch (FileId)
 730                         {
 731                         case ASL_FILE_ASM_SOURCE_OUTPUT:
 732
 733                             FlPrintFile (FileId,
 734                                 "%s_%s_%s  \\\n",
 735                                 Gbl_TableSignature, Gbl_TableId, &Pathname[1]);
 736                             break;
 737
 738                         case ASL_FILE_C_SOURCE_OUTPUT:
 739
 740                             FlPrintFile (FileId,
 741                                 "    unsigned char    %s_%s_%s [] =\n    {\n",
 742                                 Gbl_TableSignature, Gbl_TableId, &Pathname[1]);
 743                             break;
 744
 745                         case ASL_FILE_ASM_INCLUDE_OUTPUT:
 746
 747                             FlPrintFile (FileId,
 748                                 "extrn %s_%s_%s : byte\n",
 749                                 Gbl_TableSignature, Gbl_TableId, &Pathname[1]);
 750                             break;
 751
 752                         case ASL_FILE_C_INCLUDE_OUTPUT:
 753
 754                             FlPrintFile (FileId,
 755                                 "extern unsigned char    %s_%s_%s [];\n",
 756                                 Gbl_TableSignature, Gbl_TableId, &Pathname[1]);
 757                             break;
 758
 759                         default:
 760                             break;
 761                         }
 762                     }
 763
 764                     ACPI_FREE (Pathname);
 765                 }
 766                 break;
 767
 768             default:
 769
 770                 /* Nothing to do for listing file */
 771
 772                 break;
 773             }
 774         }
 775         break;
 776
 777     case AML_CLASS_EXECUTE:
 778     case AML_CLASS_CREATE:
 779     default:
 780
 781         if ((Op->Asl.ParseOpcode == PARSEOP_BUFFER) &&
 782             (Op->Asl.CompileFlags & OP_IS_RESOURCE_DESC))
 783         {
 784             return;
 785         }
 786
 787         LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
 788             FileId);
 789         break;
 790
 791     case AML_CLASS_UNKNOWN:
 792
 793         break;
 794     }
 795 }
 796
 797
 798 /*******************************************************************************
 799  *
 800  * FUNCTION:    LsFinishSourceListing
 801  *
 802  * PARAMETERS:  FileId          - ID of current listing file.
 803  *
 804  * RETURN:      None
 805  *
 806  * DESCRIPTION: Cleanup routine for the listing file. Flush the hex AML
 807  *              listing buffer, and flush out any remaining lines in the
 808  *              source input file.
 809  *
 810  ******************************************************************************/
 811
 812 static void
 813 LsFinishSourceListing (
 814     UINT32                  FileId)
 815 {
 816
 817     if ((FileId == ASL_FILE_ASM_INCLUDE_OUTPUT) ||
 818         (FileId == ASL_FILE_C_INCLUDE_OUTPUT))
 819     {
 820         return;
 821     }
 822
 823     LsFlushListingBuffer (FileId);
 824     Gbl_CurrentAmlOffset = 0;
 825
 826     /* Flush any remaining text in the source file */
 827
 828     if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
 829     {
 830         FlPrintFile (FileId, "    /*\n");
 831     }
 832
 833     while (LsWriteOneSourceLine (FileId))
 834     { ; }
 835
 836     if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
 837     {
 838         FlPrintFile (FileId, "\n     */\n    };\n");
 839     }
 840
 841     FlPrintFile (FileId, "\n");
 842
 843     if (FileId == ASL_FILE_LISTING_OUTPUT)
 844     {
 845         /* Print a summary of the compile exceptions */
 846
 847         FlPrintFile (FileId, "\n\nSummary of errors and warnings\n\n");
 848         AePrintErrorLog (FileId);
 849         FlPrintFile (FileId, "\n");
 850         UtDisplaySummary (FileId);
 851         FlPrintFile (FileId, "\n");
 852     }
 853 }