1 /******************************************************************************
3 * Module Name: aslcodegen - AML code generation
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2017, 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);