1 /******************************************************************************
3 * Module Name: aslcodegen - AML code generation
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2016, Intel Corp.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
44 #include "aslcompiler.h"
45 #include "aslcompiler.y.h"
48 #define _COMPONENT ACPI_COMPILER
49 ACPI_MODULE_NAME ("aslcodegen")
51 /* Local prototypes */
55 ACPI_PARSE_OBJECT
*Op
,
61 ACPI_PARSE_OBJECT
*Op
,
67 ACPI_PARSE_OBJECT
*Op
);
71 ACPI_PARSE_OBJECT
*Op
);
79 ACPI_PARSE_OBJECT
*Op
);
82 /*******************************************************************************
84 * FUNCTION: CgGenerateAmlOutput
90 * DESCRIPTION: Generate AML code. Currently generates the listing file
93 ******************************************************************************/
100 /* Generate the AML output file */
102 FlSeekFile (ASL_FILE_SOURCE_OUTPUT
, 0);
104 Gbl_NextError
= Gbl_ErrorLog
;
106 TrWalkParseTree (Gbl_ParseTreeRoot
, ASL_WALK_VISIT_DOWNWARD
,
107 CgAmlWriteWalk
, NULL
, NULL
);
109 DbgPrint (ASL_TREE_OUTPUT
, ASL_PARSE_TREE_HEADER2
);
114 /*******************************************************************************
116 * FUNCTION: CgAmlWriteWalk
118 * PARAMETERS: ASL_WALK_CALLBACK
122 * DESCRIPTION: Parse tree walk to generate the AML code.
124 ******************************************************************************/
128 ACPI_PARSE_OBJECT
*Op
,
133 /* Generate the AML for this node */
142 /* Print header at level 0. Alignment assumes 32-bit pointers */
146 DbgPrint (ASL_TREE_OUTPUT
,
147 "\nFinal parse tree used for AML output:\n");
148 DbgPrint (ASL_TREE_OUTPUT
, ASL_PARSE_TREE_HEADER2
);
151 /* Dump ParseOp name and possible value */
153 switch (Op
->Asl
.ParseOpcode
)
155 case PARSEOP_NAMESEG
:
156 case PARSEOP_NAMESTRING
:
157 case PARSEOP_METHODCALL
:
158 case PARSEOP_STRING_LITERAL
:
160 UtDumpStringOp (Op
, Level
);
165 UtDumpBasicOp (Op
, Level
);
169 DbgPrint (ASL_TREE_OUTPUT
, ASL_PARSE_TREE_DEBUG2
,
170 /* 1 */ (UINT32
) Op
->Asl
.Value
.Integer
,
171 /* 2 */ Op
->Asl
.ParseOpcode
,
172 /* 3 */ Op
->Asl
.AmlOpcode
,
173 /* 4 */ Op
->Asl
.AmlOpcodeLength
,
174 /* 5 */ Op
->Asl
.AmlPkgLenBytes
,
175 /* 6 */ Op
->Asl
.AmlLength
,
176 /* 7 */ Op
->Asl
.AmlSubtreeLength
,
177 /* 8 */ Op
->Asl
.Parent
? Op
->Asl
.Parent
->Asl
.AmlSubtreeLength
: 0,
179 /* 10 */ Op
->Asl
.Parent
,
180 /* 11 */ Op
->Asl
.Child
,
181 /* 12 */ Op
->Asl
.Next
,
182 /* 13 */ Op
->Asl
.CompileFlags
,
183 /* 14 */ Op
->Asl
.AcpiBtype
,
184 /* 15 */ Op
->Asl
.FinalAmlLength
,
185 /* 16 */ Op
->Asl
.Column
,
186 /* 17 */ Op
->Asl
.LineNumber
,
187 /* 18 */ Op
->Asl
.EndLine
,
188 /* 19 */ Op
->Asl
.LogicalLineNumber
,
189 /* 20 */ Op
->Asl
.EndLogicalLine
);
195 /*******************************************************************************
197 * FUNCTION: CgLocalWriteAmlData
199 * PARAMETERS: Op - Current parse op
200 * Buffer - Buffer to write
201 * Length - Size of data in buffer
205 * DESCRIPTION: Write a buffer of AML data to the AML output file.
207 ******************************************************************************/
210 CgLocalWriteAmlData (
211 ACPI_PARSE_OBJECT
*Op
,
216 /* Write the raw data to the AML file */
218 FlWriteFile (ASL_FILE_AML_OUTPUT
, Buffer
, Length
);
220 /* Update the final AML length for this node (used for listings) */
224 Op
->Asl
.FinalAmlLength
+= Length
;
229 /*******************************************************************************
231 * FUNCTION: CgWriteAmlOpcode
233 * PARAMETERS: Op - Parse node with an AML opcode
237 * DESCRIPTION: Write the AML opcode corresponding to a parse node.
239 ******************************************************************************/
243 ACPI_PARSE_OBJECT
*Op
)
245 UINT8 PkgLenFirstByte
;
249 UINT8 OpcodeBytes
[2];
257 /* We expect some DEFAULT_ARGs, just ignore them */
259 if (Op
->Asl
.ParseOpcode
== PARSEOP_DEFAULT_ARG
)
264 switch (Op
->Asl
.AmlOpcode
)
266 case AML_UNASSIGNED_OPCODE
:
268 /* These opcodes should not get here */
270 printf ("Found a node with an unassigned AML opcode\n");
271 FlPrintFile (ASL_FILE_STDERR
,
272 "Found a node with an unassigned AML opcode\n");
275 case AML_INT_RESERVEDFIELD_OP
:
277 /* Special opcodes for within a field definition */
279 Aml
.Opcode
= AML_FIELD_OFFSET_OP
;
282 case AML_INT_ACCESSFIELD_OP
:
284 Aml
.Opcode
= AML_FIELD_ACCESS_OP
;
287 case AML_INT_CONNECTION_OP
:
289 Aml
.Opcode
= AML_FIELD_CONNECTION_OP
;
294 Aml
.Opcode
= Op
->Asl
.AmlOpcode
;
301 case AML_PACKAGE_LENGTH
:
303 /* Value is the length to be encoded (Used in field definitions) */
305 PkgLen
.Len
= (UINT32
) Op
->Asl
.Value
.Integer
;
310 /* Check for two-byte opcode */
312 if (Aml
.Opcode
> 0x00FF)
314 /* Write the high byte first */
316 CgLocalWriteAmlData (Op
, &Aml
.OpcodeBytes
[1], 1);
319 CgLocalWriteAmlData (Op
, &Aml
.OpcodeBytes
[0], 1);
321 /* Subtreelength doesn't include length of package length bytes */
323 PkgLen
.Len
= Op
->Asl
.AmlSubtreeLength
+ Op
->Asl
.AmlPkgLenBytes
;
327 /* Does this opcode have an associated "PackageLength" field? */
329 if (Op
->Asl
.CompileFlags
& NODE_AML_PACKAGE
)
331 if (Op
->Asl
.AmlPkgLenBytes
== 1)
333 /* Simplest case -- no bytes to follow, just write the count */
335 CgLocalWriteAmlData (Op
, &PkgLen
.LenBytes
[0], 1);
337 else if (Op
->Asl
.AmlPkgLenBytes
!= 0)
340 * Encode the "bytes to follow" in the first byte, top two bits.
341 * The low-order nybble of the length is in the bottom 4 bits
343 PkgLenFirstByte
= (UINT8
)
344 (((UINT32
) (Op
->Asl
.AmlPkgLenBytes
- 1) << 6) |
345 (PkgLen
.LenBytes
[0] & 0x0F));
347 CgLocalWriteAmlData (Op
, &PkgLenFirstByte
, 1);
350 * Shift the length over by the 4 bits we just stuffed
356 * Now we can write the remaining bytes -
357 * either 1, 2, or 3 bytes
359 for (i
= 0; i
< (UINT32
) (Op
->Asl
.AmlPkgLenBytes
- 1); i
++)
361 CgLocalWriteAmlData (Op
, &PkgLen
.LenBytes
[i
], 1);
370 CgLocalWriteAmlData (Op
, &Op
->Asl
.Value
.Integer
, 1);
375 CgLocalWriteAmlData (Op
, &Op
->Asl
.Value
.Integer
, 2);
380 CgLocalWriteAmlData (Op
, &Op
->Asl
.Value
.Integer
, 4);
385 CgLocalWriteAmlData (Op
, &Op
->Asl
.Value
.Integer
, 8);
390 CgLocalWriteAmlData (Op
, Op
->Asl
.Value
.String
, Op
->Asl
.AmlLength
);
395 /* All data opcodes must appear above */
402 /*******************************************************************************
404 * FUNCTION: CgWriteTableHeader
406 * PARAMETERS: Op - The DEFINITIONBLOCK node
410 * DESCRIPTION: Write a table header corresponding to the DEFINITIONBLOCK
412 ******************************************************************************/
416 ACPI_PARSE_OBJECT
*Op
)
418 ACPI_PARSE_OBJECT
*Child
;
423 Child
= Op
->Asl
.Child
;
427 Child
= Child
->Asl
.Next
;
428 strncpy (TableHeader
.Signature
, Child
->Asl
.Value
.String
, 4);
432 Child
= Child
->Asl
.Next
;
433 TableHeader
.Revision
= (UINT8
) Child
->Asl
.Value
.Integer
;
435 /* Command-line Revision override */
437 if (Gbl_RevisionOverride
)
439 TableHeader
.Revision
= Gbl_RevisionOverride
;
444 Child
= Child
->Asl
.Next
;
445 strncpy (TableHeader
.OemId
, Child
->Asl
.Value
.String
, 6);
449 Child
= Child
->Asl
.Next
;
450 strncpy (TableHeader
.OemTableId
, Child
->Asl
.Value
.String
, 8);
454 Child
= Child
->Asl
.Next
;
455 TableHeader
.OemRevision
= (UINT32
) Child
->Asl
.Value
.Integer
;
459 ACPI_MOVE_NAME (TableHeader
.AslCompilerId
, ASL_CREATOR_ID
);
461 /* Compiler version */
463 TableHeader
.AslCompilerRevision
= ACPI_CA_VERSION
;
465 /* Table length. Checksum zero for now, will rewrite later */
467 TableHeader
.Length
= sizeof (ACPI_TABLE_HEADER
) +
468 Op
->Asl
.AmlSubtreeLength
;
469 TableHeader
.Checksum
= 0;
471 Op
->Asl
.FinalAmlOffset
= ftell (Gbl_Files
[ASL_FILE_AML_OUTPUT
].Handle
);
473 /* Write entire header and clear the table header global */
475 CgLocalWriteAmlData (Op
, &TableHeader
, sizeof (ACPI_TABLE_HEADER
));
476 memset (&TableHeader
, 0, sizeof (ACPI_TABLE_HEADER
));
480 /*******************************************************************************
482 * FUNCTION: CgUpdateHeader
484 * PARAMETERS: Op - Op for the Definition Block
488 * DESCRIPTION: Complete the ACPI table by calculating the checksum and
489 * re-writing the header for the input definition block
491 ******************************************************************************/
495 ACPI_PARSE_OBJECT
*Op
)
504 /* Calculate the checksum over the entire definition block */
507 Length
= sizeof (ACPI_TABLE_HEADER
) + Op
->Asl
.AmlSubtreeLength
;
508 FlSeekFile (ASL_FILE_AML_OUTPUT
, Op
->Asl
.FinalAmlOffset
);
510 for (i
= 0; i
< Length
; i
++)
512 if (FlReadFile (ASL_FILE_AML_OUTPUT
, &FileByte
, 1) != AE_OK
)
514 printf ("EOF while reading checksum bytes\n");
518 Sum
= (signed char) (Sum
+ FileByte
);
521 Checksum
= (UINT8
) (0 - Sum
);
523 /* Re-write the the checksum byte */
525 FlSeekFile (ASL_FILE_AML_OUTPUT
, Op
->Asl
.FinalAmlOffset
+
526 ACPI_OFFSET (ACPI_TABLE_HEADER
, Checksum
));
528 FlWriteFile (ASL_FILE_AML_OUTPUT
, &Checksum
, 1);
532 /*******************************************************************************
534 * FUNCTION: CgCloseTable
540 * DESCRIPTION: Complete the ACPI table by calculating the checksum and
541 * re-writing each table header. This allows support for
542 * multiple definition blocks in a single source file.
544 ******************************************************************************/
550 ACPI_PARSE_OBJECT
*Op
;
553 /* Process all definition blocks */
555 Op
= Gbl_ParseTreeRoot
->Asl
.Child
;
564 /*******************************************************************************
566 * FUNCTION: CgWriteNode
568 * PARAMETERS: Op - Parse node to write.
572 * DESCRIPTION: Write the AML that corresponds to a parse node.
574 ******************************************************************************/
578 ACPI_PARSE_OBJECT
*Op
)
580 ASL_RESOURCE_NODE
*Rnode
;
583 /* Always check for DEFAULT_ARG and other "Noop" nodes */
584 /* TBD: this may not be the best place for this check */
586 if ((Op
->Asl
.ParseOpcode
== PARSEOP_DEFAULT_ARG
) ||
587 (Op
->Asl
.ParseOpcode
== PARSEOP_INCLUDE
) ||
588 (Op
->Asl
.ParseOpcode
== PARSEOP_INCLUDE_END
))
593 if ((Op
->Asl
.ParseOpcode
== PARSEOP_EXTERNAL
) &&
594 Gbl_DoExternals
== FALSE
)
599 Op
->Asl
.FinalAmlLength
= 0;
601 switch (Op
->Asl
.AmlOpcode
)
603 case AML_RAW_DATA_BYTE
:
604 case AML_RAW_DATA_WORD
:
605 case AML_RAW_DATA_DWORD
:
606 case AML_RAW_DATA_QWORD
:
608 CgLocalWriteAmlData (Op
, &Op
->Asl
.Value
.Integer
, Op
->Asl
.AmlLength
);
612 case AML_RAW_DATA_BUFFER
:
614 CgLocalWriteAmlData (Op
, Op
->Asl
.Value
.Buffer
, Op
->Asl
.AmlLength
);
618 case AML_RAW_DATA_CHAIN
:
620 Rnode
= ACPI_CAST_PTR (ASL_RESOURCE_NODE
, Op
->Asl
.Value
.Buffer
);
623 CgLocalWriteAmlData (Op
, Rnode
->Buffer
, Rnode
->BufferLength
);
630 /* Internal data opcodes must all appear above */
635 switch (Op
->Asl
.ParseOpcode
)
637 case PARSEOP_DEFAULT_ARG
:
641 case PARSEOP_DEFINITION_BLOCK
:
643 CgWriteTableHeader (Op
);
646 case PARSEOP_NAMESEG
:
647 case PARSEOP_NAMESTRING
:
648 case PARSEOP_METHODCALL
:
650 CgLocalWriteAmlData (Op
, Op
->Asl
.Value
.String
, Op
->Asl
.AmlLength
);
655 CgWriteAmlOpcode (Op
);