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 - 2023, 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
LsDoListings(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
LsGenerateListing(UINT32 FileId)254 LsGenerateListing (
255 UINT32 FileId)
256 {
257 UINT32 WalkMode = ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_DB_SEPARATELY;
258
259 /* Start at the beginning of both the source and AML files */
260
261 FlSeekFile (ASL_FILE_SOURCE_OUTPUT, 0);
262 FlSeekFile (ASL_FILE_AML_OUTPUT, 0);
263 AslGbl_SourceLine = 0;
264 AslGbl_CurrentHexColumn = 0;
265 LsPushNode (AslGbl_Files[ASL_FILE_INPUT].Filename);
266
267 if (FileId == ASL_FILE_C_OFFSET_OUTPUT)
268 {
269 AslGbl_CurrentAmlOffset = 0;
270
271 /* Offset table file has a special header and footer */
272
273 LsDoOffsetTableHeader (FileId);
274
275 TrWalkParseTree (AslGbl_CurrentDB, WalkMode,
276 LsAmlOffsetWalk, NULL, (void *) ACPI_TO_POINTER (FileId));
277 LsDoOffsetTableFooter (FileId);
278 return;
279 }
280
281 /* Process all parse nodes */
282
283 TrWalkParseTree (AslGbl_CurrentDB, WalkMode,
284 LsAmlListingWalk, NULL, (void *) ACPI_TO_POINTER (FileId));
285
286 /* Final processing */
287
288 LsFinishSourceListing (FileId);
289 }
290
291
292 /*******************************************************************************
293 *
294 * FUNCTION: LsAmlListingWalk
295 *
296 * PARAMETERS: ASL_WALK_CALLBACK
297 *
298 * RETURN: Status
299 *
300 * DESCRIPTION: Process one node during a listing file generation.
301 *
302 ******************************************************************************/
303
304 static ACPI_STATUS
LsAmlListingWalk(ACPI_PARSE_OBJECT * Op,UINT32 Level,void * Context)305 LsAmlListingWalk (
306 ACPI_PARSE_OBJECT *Op,
307 UINT32 Level,
308 void *Context)
309 {
310 UINT8 FileByte;
311 UINT32 i;
312 UINT32 FileId = (UINT32) ACPI_TO_INTEGER (Context);
313
314
315 LsWriteNodeToListing (Op, FileId);
316
317 if (Op->Asl.CompileFlags & OP_IS_RESOURCE_DATA)
318 {
319 /* Buffer is a resource template, don't dump the data all at once */
320
321 return (AE_OK);
322 }
323
324 if ((FileId == ASL_FILE_ASM_INCLUDE_OUTPUT) ||
325 (FileId == ASL_FILE_C_INCLUDE_OUTPUT))
326 {
327 return (AE_OK);
328 }
329
330 /* Write the hex bytes to the listing file(s) (if requested) */
331
332 for (i = 0; i < Op->Asl.FinalAmlLength; i++)
333 {
334 if (ACPI_FAILURE (FlReadFile (ASL_FILE_AML_OUTPUT, &FileByte, 1)))
335 {
336 FlFileError (ASL_FILE_AML_OUTPUT, ASL_MSG_READ);
337 AslAbort ();
338 }
339
340 LsWriteListingHexBytes (&FileByte, 1, FileId);
341 }
342
343 return (AE_OK);
344 }
345
346
347 /*******************************************************************************
348 *
349 * FUNCTION: LsDumpParseTree, LsTreeWriteWalk
350 *
351 * PARAMETERS: None
352 *
353 * RETURN: None
354 *
355 * DESCRIPTION: Dump entire parse tree, for compiler debug only
356 *
357 ******************************************************************************/
358
359 void
LsDumpParseTree(void)360 LsDumpParseTree (
361 void)
362 {
363
364 if (!AslGbl_DebugFlag)
365 {
366 return;
367 }
368
369 DbgPrint (ASL_TREE_OUTPUT, "\nOriginal parse tree from parser:\n\n");
370 DbgPrint (ASL_TREE_OUTPUT, ASL_PARSE_TREE_HEADER1);
371
372 TrWalkParseTree (AslGbl_ParseTreeRoot, ASL_WALK_VISIT_DOWNWARD,
373 LsTreeWriteWalk, NULL, NULL);
374
375 DbgPrint (ASL_TREE_OUTPUT, ASL_PARSE_TREE_HEADER1);
376 }
377
378
379 static ACPI_STATUS
LsTreeWriteWalk(ACPI_PARSE_OBJECT * Op,UINT32 Level,void * Context)380 LsTreeWriteWalk (
381 ACPI_PARSE_OBJECT *Op,
382 UINT32 Level,
383 void *Context)
384 {
385
386 /* Dump ParseOp name and possible value */
387
388 switch (Op->Asl.ParseOpcode)
389 {
390 case PARSEOP_NAMESEG:
391 case PARSEOP_NAMESTRING:
392 case PARSEOP_METHODCALL:
393 case PARSEOP_STRING_LITERAL:
394
395 UtDumpStringOp (Op, Level);
396 break;
397
398 case PARSEOP_BYTECONST:
399
400 UtDumpIntegerOp (Op, Level, 2);
401 break;
402
403 case PARSEOP_WORDCONST:
404 case PARSEOP_PACKAGE_LENGTH:
405
406 UtDumpIntegerOp (Op, Level, 4);
407 break;
408
409 case PARSEOP_DWORDCONST:
410 case PARSEOP_EISAID:
411
412 UtDumpIntegerOp (Op, Level, 8);
413 break;
414
415 case PARSEOP_QWORDCONST:
416 case PARSEOP_INTEGER:
417 case PARSEOP_ONE:
418 case PARSEOP_ZERO:
419 case PARSEOP_ONES:
420
421 UtDumpIntegerOp (Op, Level, 16);
422 break;
423
424 case PARSEOP_INCLUDE:
425
426 DbgPrint (ASL_TREE_OUTPUT,
427 "Open: %s\n", Op->Asl.Value.String);
428 return (AE_OK);
429
430 case PARSEOP_INCLUDE_END:
431
432 DbgPrint (ASL_TREE_OUTPUT,
433 "Close: %s\n", Op->Asl.Filename);
434 return (AE_OK);
435
436 default:
437
438 UtDumpBasicOp (Op, Level);
439 break;
440 }
441
442 /* Dump the remaining data */
443
444 DbgPrint (ASL_TREE_OUTPUT, ASL_PARSE_TREE_DEBUG1,
445 Op->Asl.ParseOpcode, Op->Asl.CompileFlags,
446 Op->Asl.LineNumber, Op->Asl.EndLine,
447 Op->Asl.LogicalLineNumber, Op->Asl.EndLogicalLine);
448
449 TrPrintOpFlags (Op->Asl.CompileFlags, ASL_TREE_OUTPUT);
450 DbgPrint (ASL_TREE_OUTPUT, "\n");
451 return (AE_OK);
452 }
453
454
455 /*******************************************************************************
456 *
457 * FUNCTION: LsWriteNodeToListing
458 *
459 * PARAMETERS: Op - Parse node to write to the listing file.
460 * FileId - ID of current listing file
461 *
462 * RETURN: None.
463 *
464 * DESCRIPTION: Write "a node" to the listing file. This means to
465 * 1) Write out all of the source text associated with the node
466 * 2) Write out all of the AML bytes associated with the node
467 * 3) Write any compiler exceptions associated with the node
468 *
469 ******************************************************************************/
470
471 static void
LsWriteNodeToListing(ACPI_PARSE_OBJECT * Op,UINT32 FileId)472 LsWriteNodeToListing (
473 ACPI_PARSE_OBJECT *Op,
474 UINT32 FileId)
475 {
476 const ACPI_OPCODE_INFO *OpInfo;
477 UINT32 OpClass;
478 char *Pathname;
479 UINT32 Length;
480 UINT32 i;
481
482
483 OpInfo = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
484 OpClass = OpInfo->Class;
485
486 /* TBD: clean this up with a single flag that says:
487 * I start a named output block
488 */
489 if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
490 {
491 switch (Op->Asl.ParseOpcode)
492 {
493 case PARSEOP_DEFINITION_BLOCK:
494 case PARSEOP_METHODCALL:
495 case PARSEOP_INCLUDE:
496 case PARSEOP_INCLUDE_END:
497 case PARSEOP_DEFAULT_ARG:
498
499 break;
500
501 default:
502
503 switch (OpClass)
504 {
505 case AML_CLASS_NAMED_OBJECT:
506
507 switch (Op->Asl.AmlOpcode)
508 {
509 case AML_SCOPE_OP:
510 case AML_ALIAS_OP:
511
512 break;
513
514 default:
515
516 if (Op->Asl.ExternalName)
517 {
518 LsFlushListingBuffer (FileId);
519 FlPrintFile (FileId, " };\n");
520 }
521 break;
522 }
523 break;
524
525 default:
526
527 /* Don't care about other objects */
528
529 break;
530 }
531 break;
532 }
533 }
534
535 /* These cases do not have a corresponding AML opcode */
536
537 switch (Op->Asl.ParseOpcode)
538 {
539 case PARSEOP_DEFINITION_BLOCK:
540
541 /* Always start a definition block at AML offset zero */
542
543 AslGbl_CurrentAmlOffset = 0;
544 LsWriteSourceLines (Op->Asl.EndLine, Op->Asl.EndLogicalLine, FileId);
545
546 /* Use the table Signature and TableId to build a unique name */
547
548 switch (FileId)
549 {
550 case ASL_FILE_ASM_SOURCE_OUTPUT:
551
552 FlPrintFile (FileId,
553 "%s_%s_Header \\\n",
554 AslGbl_TableSignature, AslGbl_TableId);
555 break;
556
557 case ASL_FILE_C_SOURCE_OUTPUT:
558
559 FlPrintFile (FileId,
560 " unsigned char %s_%s_Header [] =\n {\n",
561 AslGbl_TableSignature, AslGbl_TableId);
562 break;
563
564 case ASL_FILE_ASM_INCLUDE_OUTPUT:
565
566 FlPrintFile (FileId,
567 "extrn %s_%s_Header : byte\n",
568 AslGbl_TableSignature, AslGbl_TableId);
569 break;
570
571 case ASL_FILE_C_INCLUDE_OUTPUT:
572
573 FlPrintFile (FileId,
574 "extern unsigned char %s_%s_Header [];\n",
575 AslGbl_TableSignature, AslGbl_TableId);
576 break;
577
578 default:
579 break;
580 }
581
582 return;
583
584
585 case PARSEOP_METHODCALL:
586
587 LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
588 FileId);
589 return;
590
591
592 case PARSEOP_INCLUDE:
593
594 /* Flush everything up to and including the include source line */
595
596 LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
597 FileId);
598
599 /* Create a new listing node and push it */
600
601 LsPushNode (Op->Asl.Value.String);
602 return;
603
604
605 case PARSEOP_INCLUDE_END:
606
607 /* Flush out the rest of the include file */
608
609 LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
610 FileId);
611
612 /* Pop off this listing node and go back to the parent file */
613
614 (void) LsPopNode ();
615 return;
616
617
618 case PARSEOP_DEFAULT_ARG:
619
620 if (Op->Asl.CompileFlags & OP_IS_RESOURCE_DESC)
621 {
622 LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.EndLogicalLine,
623 FileId);
624 }
625 return;
626
627
628 default:
629
630 /* All other opcodes have an AML opcode */
631
632 break;
633 }
634
635 /*
636 * Otherwise, we look at the AML opcode because we can
637 * switch on the opcode type, getting an entire class
638 * at once
639 */
640 switch (OpClass)
641 {
642 case AML_CLASS_ARGUMENT: /* argument type only */
643 case AML_CLASS_INTERNAL:
644
645 break;
646
647 case AML_CLASS_NAMED_OBJECT:
648
649 switch (Op->Asl.AmlOpcode)
650 {
651 case AML_FIELD_OP:
652 case AML_INDEX_FIELD_OP:
653 case AML_BANK_FIELD_OP:
654 /*
655 * For fields, we want to dump all the AML after the
656 * entire definition
657 */
658 LsWriteSourceLines (Op->Asl.EndLine, Op->Asl.EndLogicalLine,
659 FileId);
660 break;
661
662 case AML_NAME_OP:
663
664 if (Op->Asl.CompileFlags & OP_IS_RESOURCE_DESC)
665 {
666 LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
667 FileId);
668 }
669 else
670 {
671 /*
672 * For fields, we want to dump all the AML after the
673 * entire definition
674 */
675 LsWriteSourceLines (Op->Asl.EndLine, Op->Asl.EndLogicalLine,
676 FileId);
677 }
678 break;
679
680 default:
681
682 LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
683 FileId);
684 break;
685 }
686
687 switch (Op->Asl.AmlOpcode)
688 {
689 case AML_SCOPE_OP:
690 case AML_ALIAS_OP:
691
692 /* These opcodes do not declare a new object, ignore them */
693
694 break;
695
696 default:
697
698 /* All other named object opcodes come here */
699
700 switch (FileId)
701 {
702 case ASL_FILE_ASM_SOURCE_OUTPUT:
703 case ASL_FILE_C_SOURCE_OUTPUT:
704 case ASL_FILE_ASM_INCLUDE_OUTPUT:
705 case ASL_FILE_C_INCLUDE_OUTPUT:
706 /*
707 * For named objects, we will create a valid symbol so that the
708 * AML code can be referenced from C or ASM
709 */
710 if (Op->Asl.ExternalName)
711 {
712 /* Get the full pathname associated with this node */
713
714 Pathname = AcpiNsGetExternalPathname (Op->Asl.Node);
715 Length = strlen (Pathname);
716 if (Length >= 4)
717 {
718 /* Convert all dots in the path to underscores */
719
720 for (i = 0; i < Length; i++)
721 {
722 if (Pathname[i] == '.')
723 {
724 Pathname[i] = '_';
725 }
726 }
727
728 /* Create the appropriate symbol in the output file */
729
730 switch (FileId)
731 {
732 case ASL_FILE_ASM_SOURCE_OUTPUT:
733
734 FlPrintFile (FileId,
735 "%s_%s_%s \\\n",
736 AslGbl_TableSignature, AslGbl_TableId, &Pathname[1]);
737 break;
738
739 case ASL_FILE_C_SOURCE_OUTPUT:
740
741 FlPrintFile (FileId,
742 " unsigned char %s_%s_%s [] =\n {\n",
743 AslGbl_TableSignature, AslGbl_TableId, &Pathname[1]);
744 break;
745
746 case ASL_FILE_ASM_INCLUDE_OUTPUT:
747
748 FlPrintFile (FileId,
749 "extrn %s_%s_%s : byte\n",
750 AslGbl_TableSignature, AslGbl_TableId, &Pathname[1]);
751 break;
752
753 case ASL_FILE_C_INCLUDE_OUTPUT:
754
755 FlPrintFile (FileId,
756 "extern unsigned char %s_%s_%s [];\n",
757 AslGbl_TableSignature, AslGbl_TableId, &Pathname[1]);
758 break;
759
760 default:
761 break;
762 }
763 }
764
765 ACPI_FREE (Pathname);
766 }
767 break;
768
769 default:
770
771 /* Nothing to do for listing file */
772
773 break;
774 }
775 }
776 break;
777
778 case AML_CLASS_EXECUTE:
779 case AML_CLASS_CREATE:
780 default:
781
782 if ((Op->Asl.ParseOpcode == PARSEOP_BUFFER) &&
783 (Op->Asl.CompileFlags & OP_IS_RESOURCE_DESC))
784 {
785 return;
786 }
787
788 LsWriteSourceLines (Op->Asl.LineNumber, Op->Asl.LogicalLineNumber,
789 FileId);
790 break;
791
792 case AML_CLASS_UNKNOWN:
793
794 break;
795 }
796 }
797
798
799 /*******************************************************************************
800 *
801 * FUNCTION: LsFinishSourceListing
802 *
803 * PARAMETERS: FileId - ID of current listing file.
804 *
805 * RETURN: None
806 *
807 * DESCRIPTION: Cleanup routine for the listing file. Flush the hex AML
808 * listing buffer, and flush out any remaining lines in the
809 * source input file.
810 *
811 ******************************************************************************/
812
813 static void
LsFinishSourceListing(UINT32 FileId)814 LsFinishSourceListing (
815 UINT32 FileId)
816 {
817
818 if ((FileId == ASL_FILE_ASM_INCLUDE_OUTPUT) ||
819 (FileId == ASL_FILE_C_INCLUDE_OUTPUT))
820 {
821 return;
822 }
823
824 LsFlushListingBuffer (FileId);
825 AslGbl_CurrentAmlOffset = 0;
826
827 /* Flush any remaining text in the source file */
828
829 if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
830 {
831 FlPrintFile (FileId, " /*\n");
832 }
833
834 while (LsWriteOneSourceLine (FileId))
835 { ; }
836
837 if (FileId == ASL_FILE_C_SOURCE_OUTPUT)
838 {
839 FlPrintFile (FileId, "\n */\n };\n");
840 }
841
842 FlPrintFile (FileId, "\n");
843
844 if (FileId == ASL_FILE_LISTING_OUTPUT)
845 {
846 /* Print a summary of the compile exceptions */
847
848 FlPrintFile (FileId, "\n\nSummary of errors and warnings\n\n");
849 AePrintErrorLog (FileId);
850 FlPrintFile (FileId, "\n");
851 UtDisplayOneSummary (FileId, TRUE);
852 FlPrintFile (FileId, "\n");
853 }
854 }
855
