1 /******************************************************************************
2 *
3 * Module Name: aslcodegen - AML code generation
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2014, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
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.
25 *
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.
29 *
30 * NO WARRANTY
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.
42 */
43
44
45 #include "aslcompiler.h"
46 #include "aslcompiler.y.h"
47 #include "amlcode.h"
48
49 #define _COMPONENT ACPI_COMPILER
50 ACPI_MODULE_NAME ("aslcodegen")
51
52 /* Local prototypes */
53
54 static ACPI_STATUS
55 CgAmlWriteWalk (
56 ACPI_PARSE_OBJECT *Op,
57 UINT32 Level,
58 void *Context);
59
60 static void
61 CgLocalWriteAmlData (
62 ACPI_PARSE_OBJECT *Op,
63 void *Buffer,
64 UINT32 Length);
65
66 static void
67 CgWriteAmlOpcode (
68 ACPI_PARSE_OBJECT *Op);
69
70 static void
71 CgWriteTableHeader (
72 ACPI_PARSE_OBJECT *Op);
73
74 static void
75 CgCloseTable (
76 void);
77
78 static void
79 CgWriteNode (
80 ACPI_PARSE_OBJECT *Op);
81
82
83 /*******************************************************************************
84 *
85 * FUNCTION: CgGenerateAmlOutput
86 *
87 * PARAMETERS: None.
88 *
89 * RETURN: None
90 *
91 * DESCRIPTION: Generate AML code. Currently generates the listing file
92 * simultaneously.
93 *
94 ******************************************************************************/
95
96 void
97 CgGenerateAmlOutput (
98 void)
99 {
100
101 DbgPrint (ASL_DEBUG_OUTPUT, "\nWriting AML\n\n");
102
103 /* Generate the AML output file */
104
105 FlSeekFile (ASL_FILE_SOURCE_OUTPUT, 0);
106 Gbl_SourceLine = 0;
107 Gbl_NextError = Gbl_ErrorLog;
108
109 TrWalkParseTree (RootNode, ASL_WALK_VISIT_DOWNWARD,
110 CgAmlWriteWalk, NULL, NULL);
111 CgCloseTable ();
112 }
113
114
115 /*******************************************************************************
116 *
117 * FUNCTION: CgAmlWriteWalk
118 *
119 * PARAMETERS: ASL_WALK_CALLBACK
120 *
121 * RETURN: Status
122 *
123 * DESCRIPTION: Parse tree walk to generate the AML code.
124 *
125 ******************************************************************************/
126
127 static ACPI_STATUS
128 CgAmlWriteWalk (
129 ACPI_PARSE_OBJECT *Op,
130 UINT32 Level,
131 void *Context)
132 {
133
134 /*
135 * Print header at level 0. Alignment assumes 32-bit pointers
136 */
137 if (!Level)
138 {
139 DbgPrint (ASL_TREE_OUTPUT,
140 "Final parse tree used for AML output:\n");
141 DbgPrint (ASL_TREE_OUTPUT,
142 "%*s Value P_Op A_Op OpLen PByts Len SubLen PSubLen OpPtr Child Parent Flags AcTyp Final Col L\n",
143 76, " ");
144 }
145
146 /* Debug output */
147
148 DbgPrint (ASL_TREE_OUTPUT,
149 "%5.5d [%2d]", Op->Asl.LogicalLineNumber, Level);
150 UtPrintFormattedName (Op->Asl.ParseOpcode, Level);
151
152 if (Op->Asl.ParseOpcode == PARSEOP_NAMESEG ||
153 Op->Asl.ParseOpcode == PARSEOP_NAMESTRING ||
154 Op->Asl.ParseOpcode == PARSEOP_METHODCALL)
155 {
156 DbgPrint (ASL_TREE_OUTPUT,
157 "%10.32s ", Op->Asl.ExternalName);
158 }
159 else
160 {
161 DbgPrint (ASL_TREE_OUTPUT, " ");
162 }
163
164 DbgPrint (ASL_TREE_OUTPUT,
165 "%08X %04X %04X %01X %04X %04X %04X %04X %08X %08X %08X %08X %08X %04X %02d %02d\n",
166 /* 1 */ (UINT32) Op->Asl.Value.Integer,
167 /* 2 */ Op->Asl.ParseOpcode,
168 /* 3 */ Op->Asl.AmlOpcode,
169 /* 4 */ Op->Asl.AmlOpcodeLength,
170 /* 5 */ Op->Asl.AmlPkgLenBytes,
171 /* 6 */ Op->Asl.AmlLength,
172 /* 7 */ Op->Asl.AmlSubtreeLength,
173 /* 8 */ Op->Asl.Parent ? Op->Asl.Parent->Asl.AmlSubtreeLength : 0,
174 /* 9 */ Op,
175 /* 10 */ Op->Asl.Child,
176 /* 11 */ Op->Asl.Parent,
177 /* 12 */ Op->Asl.CompileFlags,
178 /* 13 */ Op->Asl.AcpiBtype,
179 /* 14 */ Op->Asl.FinalAmlLength,
180 /* 15 */ Op->Asl.Column,
181 /* 16 */ Op->Asl.LineNumber);
182
183 /* Generate the AML for this node */
184
185 CgWriteNode (Op);
186 return (AE_OK);
187 }
188
189
190 /*******************************************************************************
191 *
192 * FUNCTION: CgLocalWriteAmlData
193 *
194 * PARAMETERS: Op - Current parse op
195 * Buffer - Buffer to write
196 * Length - Size of data in buffer
197 *
198 * RETURN: None
199 *
200 * DESCRIPTION: Write a buffer of AML data to the AML output file.
201 *
202 ******************************************************************************/
203
204 static void
205 CgLocalWriteAmlData (
206 ACPI_PARSE_OBJECT *Op,
207 void *Buffer,
208 UINT32 Length)
209 {
210
211 /* Write the raw data to the AML file */
212
213 FlWriteFile (ASL_FILE_AML_OUTPUT, Buffer, Length);
214
215 /* Update the final AML length for this node (used for listings) */
216
217 if (Op)
218 {
219 Op->Asl.FinalAmlLength += Length;
220 }
221 }
222
223
224 /*******************************************************************************
225 *
226 * FUNCTION: CgWriteAmlOpcode
227 *
228 * PARAMETERS: Op - Parse node with an AML opcode
229 *
230 * RETURN: None.
231 *
232 * DESCRIPTION: Write the AML opcode corresponding to a parse node.
233 *
234 ******************************************************************************/
235
236 static void
237 CgWriteAmlOpcode (
238 ACPI_PARSE_OBJECT *Op)
239 {
240 UINT8 PkgLenFirstByte;
241 UINT32 i;
242 union {
243 UINT16 Opcode;
244 UINT8 OpcodeBytes[2];
245 } Aml;
246 union {
247 UINT32 Len;
248 UINT8 LenBytes[4];
249 } PkgLen;
250
251
252 /* We expect some DEFAULT_ARGs, just ignore them */
253
254 if (Op->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
255 {
256 return;
257 }
258
259 switch (Op->Asl.AmlOpcode)
260 {
261 case AML_UNASSIGNED_OPCODE:
262
263 /* These opcodes should not get here */
264
265 printf ("Found a node with an unassigned AML opcode\n");
266 FlPrintFile (ASL_FILE_STDERR, "Found a node with an unassigned AML opcode\n");
267 return;
268
269 case AML_INT_RESERVEDFIELD_OP:
270
271 /* Special opcodes for within a field definition */
272
273 Aml.Opcode = AML_FIELD_OFFSET_OP;
274 break;
275
276 case AML_INT_ACCESSFIELD_OP:
277
278 Aml.Opcode = AML_FIELD_ACCESS_OP;
279 break;
280
281 case AML_INT_CONNECTION_OP:
282
283 Aml.Opcode = AML_FIELD_CONNECTION_OP;
284 break;
285
286 default:
287
288 Aml.Opcode = Op->Asl.AmlOpcode;
289 break;
290 }
291
292
293 switch (Aml.Opcode)
294 {
295 case AML_PACKAGE_LENGTH:
296
297 /* Value is the length to be encoded (Used in field definitions) */
298
299 PkgLen.Len = (UINT32) Op->Asl.Value.Integer;
300 break;
301
302 default:
303
304 /* Check for two-byte opcode */
305
306 if (Aml.Opcode > 0x00FF)
307 {
308 /* Write the high byte first */
309
310 CgLocalWriteAmlData (Op, &Aml.OpcodeBytes[1], 1);
311 }
312
313 CgLocalWriteAmlData (Op, &Aml.OpcodeBytes[0], 1);
314
315 /* Subtreelength doesn't include length of package length bytes */
316
317 PkgLen.Len = Op->Asl.AmlSubtreeLength + Op->Asl.AmlPkgLenBytes;
318 break;
319 }
320
321 /* Does this opcode have an associated "PackageLength" field? */
322
323 if (Op->Asl.CompileFlags & NODE_AML_PACKAGE)
324 {
325 if (Op->Asl.AmlPkgLenBytes == 1)
326 {
327 /* Simplest case -- no bytes to follow, just write the count */
328
329 CgLocalWriteAmlData (Op, &PkgLen.LenBytes[0], 1);
330 }
331 else if (Op->Asl.AmlPkgLenBytes != 0)
332 {
333 /*
334 * Encode the "bytes to follow" in the first byte, top two bits.
335 * The low-order nybble of the length is in the bottom 4 bits
336 */
337 PkgLenFirstByte = (UINT8)
338 (((UINT32) (Op->Asl.AmlPkgLenBytes - 1) << 6) |
339 (PkgLen.LenBytes[0] & 0x0F));
340
341 CgLocalWriteAmlData (Op, &PkgLenFirstByte, 1);
342
343 /*
344 * Shift the length over by the 4 bits we just stuffed
345 * in the first byte
346 */
347 PkgLen.Len >>= 4;
348
349 /* Now we can write the remaining bytes - either 1, 2, or 3 bytes */
350
351 for (i = 0; i < (UINT32) (Op->Asl.AmlPkgLenBytes - 1); i++)
352 {
353 CgLocalWriteAmlData (Op, &PkgLen.LenBytes[i], 1);
354 }
355 }
356 }
357
358 switch (Aml.Opcode)
359 {
360 case AML_BYTE_OP:
361
362 CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 1);
363 break;
364
365 case AML_WORD_OP:
366
367 CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 2);
368 break;
369
370 case AML_DWORD_OP:
371
372 CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 4);
373 break;
374
375 case AML_QWORD_OP:
376
377 CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 8);
378 break;
379
380 case AML_STRING_OP:
381
382 CgLocalWriteAmlData (Op, Op->Asl.Value.String, Op->Asl.AmlLength);
383 break;
384
385 default:
386
387 /* All data opcodes must appear above */
388
389 break;
390 }
391 }
392
393
394 /*******************************************************************************
395 *
396 * FUNCTION: CgWriteTableHeader
397 *
398 * PARAMETERS: Op - The DEFINITIONBLOCK node
399 *
400 * RETURN: None
401 *
402 * DESCRIPTION: Write a table header corresponding to the DEFINITIONBLOCK
403 *
404 ******************************************************************************/
405
406 static void
407 CgWriteTableHeader (
408 ACPI_PARSE_OBJECT *Op)
409 {
410 ACPI_PARSE_OBJECT *Child;
411
412
413 /* AML filename */
414
415 Child = Op->Asl.Child;
416
417 /* Signature */
418
419 Child = Child->Asl.Next;
420 strncpy (TableHeader.Signature, Child->Asl.Value.String, 4);
421
422 /* Revision */
423
424 Child = Child->Asl.Next;
425 TableHeader.Revision = (UINT8) Child->Asl.Value.Integer;
426
427 /* Command-line Revision override */
428
429 if (Gbl_RevisionOverride)
430 {
431 TableHeader.Revision = Gbl_RevisionOverride;
432 }
433
434 /* OEMID */
435
436 Child = Child->Asl.Next;
437 strncpy (TableHeader.OemId, Child->Asl.Value.String, 6);
438
439 /* OEM TableID */
440
441 Child = Child->Asl.Next;
442 strncpy (TableHeader.OemTableId, Child->Asl.Value.String, 8);
443
444 /* OEM Revision */
445
446 Child = Child->Asl.Next;
447 TableHeader.OemRevision = (UINT32) Child->Asl.Value.Integer;
448
449 /* Compiler ID */
450
451 ACPI_MOVE_NAME (TableHeader.AslCompilerId, ASL_CREATOR_ID);
452
453 /* Compiler version */
454
455 TableHeader.AslCompilerRevision = ASL_REVISION;
456
457 /* Table length. Checksum zero for now, will rewrite later */
458
459 TableHeader.Length = Gbl_TableLength;
460 TableHeader.Checksum = 0;
461
462 CgLocalWriteAmlData (Op, &TableHeader, sizeof (ACPI_TABLE_HEADER));
463 }
464
465
466 /*******************************************************************************
467 *
468 * FUNCTION: CgCloseTable
469 *
470 * PARAMETERS: None.
471 *
472 * RETURN: None.
473 *
474 * DESCRIPTION: Complete the ACPI table by calculating the checksum and
475 * re-writing the header.
476 *
477 ******************************************************************************/
478
479 static void
480 CgCloseTable (
481 void)
482 {
483 signed char Sum;
484 UINT8 FileByte;
485
486
487 FlSeekFile (ASL_FILE_AML_OUTPUT, 0);
488 Sum = 0;
489
490 /* Calculate the checksum over the entire file */
491
492 while (FlReadFile (ASL_FILE_AML_OUTPUT, &FileByte, 1) == AE_OK)
493 {
494 Sum = (signed char) (Sum + FileByte);
495 }
496
497 /* Re-write the table header with the checksum */
498
499 TableHeader.Checksum = (UINT8) (0 - Sum);
500
501 FlSeekFile (ASL_FILE_AML_OUTPUT, 0);
502 CgLocalWriteAmlData (NULL, &TableHeader, sizeof (ACPI_TABLE_HEADER));
503 }
504
505
506 /*******************************************************************************
507 *
508 * FUNCTION: CgWriteNode
509 *
510 * PARAMETERS: Op - Parse node to write.
511 *
512 * RETURN: None.
513 *
514 * DESCRIPTION: Write the AML that corresponds to a parse node.
515 *
516 ******************************************************************************/
517
518 static void
519 CgWriteNode (
520 ACPI_PARSE_OBJECT *Op)
521 {
522 ASL_RESOURCE_NODE *Rnode;
523
524
525 /* Always check for DEFAULT_ARG and other "Noop" nodes */
526 /* TBD: this may not be the best place for this check */
527
528 if ((Op->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) ||
529 (Op->Asl.ParseOpcode == PARSEOP_EXTERNAL) ||
530 (Op->Asl.ParseOpcode == PARSEOP_INCLUDE) ||
531 (Op->Asl.ParseOpcode == PARSEOP_INCLUDE_END))
532 {
533 return;
534 }
535
536 Op->Asl.FinalAmlLength = 0;
537
538 switch (Op->Asl.AmlOpcode)
539 {
540 case AML_RAW_DATA_BYTE:
541 case AML_RAW_DATA_WORD:
542 case AML_RAW_DATA_DWORD:
543 case AML_RAW_DATA_QWORD:
544
545 CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, Op->Asl.AmlLength);
546 return;
547
548
549 case AML_RAW_DATA_BUFFER:
550
551 CgLocalWriteAmlData (Op, Op->Asl.Value.Buffer, Op->Asl.AmlLength);
552 return;
553
554
555 case AML_RAW_DATA_CHAIN:
556
557 Rnode = ACPI_CAST_PTR (ASL_RESOURCE_NODE, Op->Asl.Value.Buffer);
558 while (Rnode)
559 {
560 CgLocalWriteAmlData (Op, Rnode->Buffer, Rnode->BufferLength);
561 Rnode = Rnode->Next;
562 }
563 return;
564
565 default:
566
567 /* Internal data opcodes must all appear above */
568
569 break;
570 }
571
572 switch (Op->Asl.ParseOpcode)
573 {
574 case PARSEOP_DEFAULT_ARG:
575
576 break;
577
578 case PARSEOP_DEFINITIONBLOCK:
579
580 CgWriteTableHeader (Op);
581 break;
582
583 case PARSEOP_NAMESEG:
584 case PARSEOP_NAMESTRING:
585 case PARSEOP_METHODCALL:
586
587 CgLocalWriteAmlData (Op, Op->Asl.Value.String, Op->Asl.AmlLength);
588 break;
589
590 default:
591
592 CgWriteAmlOpcode (Op);
593 break;
594 }
595 }