xref: /freebsd/sys/contrib/dev/acpica/compiler/asllisting.c (revision cc426dd31990b8b50b210efc450e404596548ca1)
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 <contrib/dev/acpica/compiler/aslcompiler.h>
153 #include "aslcompiler.y.h"
154 #include <contrib/dev/acpica/include/amlcode.h>
155 #include <contrib/dev/acpica/include/acparser.h>
156 #include <contrib/dev/acpica/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 (AslGbl_C_OutputFlag)
209     {
210         LsGenerateListing (ASL_FILE_C_SOURCE_OUTPUT);
211     }
212 
213     if (AslGbl_ListingFlag)
214     {
215         LsGenerateListing (ASL_FILE_LISTING_OUTPUT);
216     }
217 
218     if (AslGbl_AsmOutputFlag)
219     {
220         LsGenerateListing (ASL_FILE_ASM_SOURCE_OUTPUT);
221     }
222 
223     if (AslGbl_C_IncludeOutputFlag)
224     {
225         LsGenerateListing (ASL_FILE_C_INCLUDE_OUTPUT);
226     }
227 
228     if (AslGbl_AsmIncludeOutputFlag)
229     {
230         LsGenerateListing (ASL_FILE_ASM_INCLUDE_OUTPUT);
231     }
232 
233     if (AslGbl_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     AslGbl_SourceLine = 0;
263     AslGbl_CurrentHexColumn = 0;
264     LsPushNode (AslGbl_Files[ASL_FILE_INPUT].Filename);
265 
266     if (FileId == ASL_FILE_C_OFFSET_OUTPUT)
267     {
268         AslGbl_CurrentAmlOffset = 0;
269 
270         /* Offset table file has a special header and footer */
271 
272         LsDoOffsetTableHeader (FileId);
273 
274         TrWalkParseTree (AslGbl_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 (AslGbl_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 (!AslGbl_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 (AslGbl_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         AslGbl_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                 AslGbl_TableSignature, AslGbl_TableId);
554             break;
555 
556         case ASL_FILE_C_SOURCE_OUTPUT:
557 
558             FlPrintFile (FileId,
559                 "    unsigned char    %s_%s_Header [] =\n    {\n",
560                 AslGbl_TableSignature, AslGbl_TableId);
561             break;
562 
563         case ASL_FILE_ASM_INCLUDE_OUTPUT:
564 
565             FlPrintFile (FileId,
566                 "extrn %s_%s_Header : byte\n",
567                 AslGbl_TableSignature, AslGbl_TableId);
568             break;
569 
570         case ASL_FILE_C_INCLUDE_OUTPUT:
571 
572             FlPrintFile (FileId,
573                 "extern unsigned char    %s_%s_Header [];\n",
574                 AslGbl_TableSignature, AslGbl_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                                 AslGbl_TableSignature, AslGbl_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                                 AslGbl_TableSignature, AslGbl_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                                 AslGbl_TableSignature, AslGbl_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                                 AslGbl_TableSignature, AslGbl_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     AslGbl_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 }
854