1 /******************************************************************************
2 *
3 * Module Name: aslopcode - AML opcode 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 ("aslopcodes")
51
52
53 /* Local prototypes */
54
55 static void
56 OpcDoAccessAs (
57 ACPI_PARSE_OBJECT *Op);
58
59 static void
60 OpcDoConnection (
61 ACPI_PARSE_OBJECT *Op);
62
63 static void
64 OpcDoUnicode (
65 ACPI_PARSE_OBJECT *Op);
66
67 static void
68 OpcDoEisaId (
69 ACPI_PARSE_OBJECT *Op);
70
71 static void
72 OpcDoUuId (
73 ACPI_PARSE_OBJECT *Op);
74
75
76 /*******************************************************************************
77 *
78 * FUNCTION: OpcAmlOpcodeUpdateWalk
79 *
80 * PARAMETERS: ASL_WALK_CALLBACK
81 *
82 * RETURN: Status
83 *
84 * DESCRIPTION: Opcode update walk, ascending callback
85 *
86 ******************************************************************************/
87
88 ACPI_STATUS
89 OpcAmlOpcodeUpdateWalk (
90 ACPI_PARSE_OBJECT *Op,
91 UINT32 Level,
92 void *Context)
93 {
94
95 /*
96 * Handle the Package() case where the actual opcode cannot be determined
97 * until the PackageLength operand has been folded and minimized.
98 * (PackageOp versus VarPackageOp)
99 *
100 * This is (as of ACPI 3.0) the only case where the AML opcode can change
101 * based upon the value of a parameter.
102 *
103 * The parser always inserts a VarPackage opcode, which can possibly be
104 * optimized to a Package opcode.
105 */
106 if (Op->Asl.ParseOpcode == PARSEOP_VAR_PACKAGE)
107 {
108 OpnDoPackage (Op);
109 }
110
111 return (AE_OK);
112 }
113
114
115 /*******************************************************************************
116 *
117 * FUNCTION: OpcAmlOpcodeWalk
118 *
119 * PARAMETERS: ASL_WALK_CALLBACK
120 *
121 * RETURN: Status
122 *
123 * DESCRIPTION: Parse tree walk to generate both the AML opcodes and the AML
124 * operands.
125 *
126 ******************************************************************************/
127
128 ACPI_STATUS
129 OpcAmlOpcodeWalk (
130 ACPI_PARSE_OBJECT *Op,
131 UINT32 Level,
132 void *Context)
133 {
134
135 TotalParseNodes++;
136
137 OpcGenerateAmlOpcode (Op);
138 OpnGenerateAmlOperands (Op);
139 return (AE_OK);
140 }
141
142
143 /*******************************************************************************
144 *
145 * FUNCTION: OpcGetIntegerWidth
146 *
147 * PARAMETERS: Op - DEFINITION BLOCK op
148 *
149 * RETURN: none
150 *
151 * DESCRIPTION: Extract integer width from the table revision
152 *
153 ******************************************************************************/
154
155 void
156 OpcGetIntegerWidth (
157 ACPI_PARSE_OBJECT *Op)
158 {
159 ACPI_PARSE_OBJECT *Child;
160
161
162 if (!Op)
163 {
164 return;
165 }
166
167 if (Gbl_RevisionOverride)
168 {
169 AcpiUtSetIntegerWidth (Gbl_RevisionOverride);
170 }
171 else
172 {
173 Child = Op->Asl.Child;
174 Child = Child->Asl.Next;
175 Child = Child->Asl.Next;
176
177 /* Use the revision to set the integer width */
178
179 AcpiUtSetIntegerWidth ((UINT8) Child->Asl.Value.Integer);
180 }
181 }
182
183
184 /*******************************************************************************
185 *
186 * FUNCTION: OpcSetOptimalIntegerSize
187 *
188 * PARAMETERS: Op - A parse tree node
189 *
190 * RETURN: Integer width, in bytes. Also sets the node AML opcode to the
191 * optimal integer AML prefix opcode.
192 *
193 * DESCRIPTION: Determine the optimal AML encoding of an integer. All leading
194 * zeros can be truncated to squeeze the integer into the
195 * minimal number of AML bytes.
196 *
197 ******************************************************************************/
198
199 UINT32
200 OpcSetOptimalIntegerSize (
201 ACPI_PARSE_OBJECT *Op)
202 {
203
204 #if 0
205 /*
206 * TBD: - we don't want to optimize integers in the block header, but the
207 * code below does not work correctly.
208 */
209 if (Op->Asl.Parent &&
210 Op->Asl.Parent->Asl.Parent &&
211 (Op->Asl.Parent->Asl.Parent->Asl.ParseOpcode == PARSEOP_DEFINITIONBLOCK))
212 {
213 return (0);
214 }
215 #endif
216
217 /*
218 * Check for the special AML integers first - Zero, One, Ones.
219 * These are single-byte opcodes that are the smallest possible
220 * representation of an integer.
221 *
222 * This optimization is optional.
223 */
224 if (Gbl_IntegerOptimizationFlag)
225 {
226 switch (Op->Asl.Value.Integer)
227 {
228 case 0:
229
230 Op->Asl.AmlOpcode = AML_ZERO_OP;
231 AslError (ASL_OPTIMIZATION, ASL_MSG_INTEGER_OPTIMIZATION,
232 Op, "Zero");
233 return (1);
234
235 case 1:
236
237 Op->Asl.AmlOpcode = AML_ONE_OP;
238 AslError (ASL_OPTIMIZATION, ASL_MSG_INTEGER_OPTIMIZATION,
239 Op, "One");
240 return (1);
241
242 case ACPI_UINT32_MAX:
243
244 /* Check for table integer width (32 or 64) */
245
246 if (AcpiGbl_IntegerByteWidth == 4)
247 {
248 Op->Asl.AmlOpcode = AML_ONES_OP;
249 AslError (ASL_OPTIMIZATION, ASL_MSG_INTEGER_OPTIMIZATION,
250 Op, "Ones");
251 return (1);
252 }
253 break;
254
255 case ACPI_UINT64_MAX:
256
257 /* Check for table integer width (32 or 64) */
258
259 if (AcpiGbl_IntegerByteWidth == 8)
260 {
261 Op->Asl.AmlOpcode = AML_ONES_OP;
262 AslError (ASL_OPTIMIZATION, ASL_MSG_INTEGER_OPTIMIZATION,
263 Op, "Ones");
264 return (1);
265 }
266 break;
267
268 default:
269
270 break;
271 }
272 }
273
274 /* Find the best fit using the various AML integer prefixes */
275
276 if (Op->Asl.Value.Integer <= ACPI_UINT8_MAX)
277 {
278 Op->Asl.AmlOpcode = AML_BYTE_OP;
279 return (1);
280 }
281 if (Op->Asl.Value.Integer <= ACPI_UINT16_MAX)
282 {
283 Op->Asl.AmlOpcode = AML_WORD_OP;
284 return (2);
285 }
286 if (Op->Asl.Value.Integer <= ACPI_UINT32_MAX)
287 {
288 Op->Asl.AmlOpcode = AML_DWORD_OP;
289 return (4);
290 }
291 else
292 {
293 if (AcpiGbl_IntegerByteWidth == 4)
294 {
295 AslError (ASL_WARNING, ASL_MSG_INTEGER_LENGTH,
296 Op, NULL);
297
298 if (!Gbl_IgnoreErrors)
299 {
300 /* Truncate the integer to 32-bit */
301 Op->Asl.AmlOpcode = AML_DWORD_OP;
302 return (4);
303 }
304 }
305
306 Op->Asl.AmlOpcode = AML_QWORD_OP;
307 return (8);
308 }
309 }
310
311
312 /*******************************************************************************
313 *
314 * FUNCTION: OpcDoAccessAs
315 *
316 * PARAMETERS: Op - Parse node
317 *
318 * RETURN: None
319 *
320 * DESCRIPTION: Implement the ACCESS_AS ASL keyword.
321 *
322 ******************************************************************************/
323
324 static void
325 OpcDoAccessAs (
326 ACPI_PARSE_OBJECT *Op)
327 {
328 ACPI_PARSE_OBJECT *TypeOp;
329 ACPI_PARSE_OBJECT *AttribOp;
330 ACPI_PARSE_OBJECT *LengthOp;
331 UINT8 Attribute;
332
333
334 Op->Asl.AmlOpcodeLength = 1;
335 TypeOp = Op->Asl.Child;
336
337 /* First child is the access type */
338
339 TypeOp->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
340 TypeOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
341
342 /* Second child is the optional access attribute */
343
344 AttribOp = TypeOp->Asl.Next;
345 if (AttribOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
346 {
347 AttribOp->Asl.Value.Integer = 0;
348 }
349 AttribOp->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
350 AttribOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
351
352 /* Only a few AccessAttributes support AccessLength */
353
354 Attribute = (UINT8) AttribOp->Asl.Value.Integer;
355 if ((Attribute != AML_FIELD_ATTRIB_MULTIBYTE) &&
356 (Attribute != AML_FIELD_ATTRIB_RAW_BYTES) &&
357 (Attribute != AML_FIELD_ATTRIB_RAW_PROCESS))
358 {
359 return;
360 }
361
362 Op->Asl.AmlOpcode = AML_FIELD_EXT_ACCESS_OP;
363
364 /*
365 * Child of Attributes is the AccessLength (required for Multibyte,
366 * RawBytes, RawProcess.)
367 */
368 LengthOp = AttribOp->Asl.Child;
369 if (!LengthOp)
370 {
371 return;
372 }
373
374 /* TBD: probably can remove */
375
376 if (LengthOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
377 {
378 LengthOp->Asl.Value.Integer = 16;
379 }
380
381 LengthOp->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
382 LengthOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
383 }
384
385
386 /*******************************************************************************
387 *
388 * FUNCTION: OpcDoConnection
389 *
390 * PARAMETERS: Op - Parse node
391 *
392 * RETURN: None
393 *
394 * DESCRIPTION: Implement the Connection ASL keyword.
395 *
396 ******************************************************************************/
397
398 static void
399 OpcDoConnection (
400 ACPI_PARSE_OBJECT *Op)
401 {
402 ASL_RESOURCE_NODE *Rnode;
403 ACPI_PARSE_OBJECT *BufferOp;
404 ACPI_PARSE_OBJECT *BufferLengthOp;
405 ACPI_PARSE_OBJECT *BufferDataOp;
406 UINT8 State;
407
408
409 Op->Asl.AmlOpcodeLength = 1;
410
411 if (Op->Asl.Child->Asl.AmlOpcode == AML_INT_NAMEPATH_OP)
412 {
413 return;
414 }
415
416 BufferOp = Op->Asl.Child;
417 BufferLengthOp = BufferOp->Asl.Child;
418 BufferDataOp = BufferLengthOp->Asl.Next;
419
420 State = ACPI_RSTATE_NORMAL;
421 Rnode = RsDoOneResourceDescriptor (BufferDataOp->Asl.Next, 0, &State);
422 if (!Rnode)
423 {
424 return; /* error */
425 }
426
427 /*
428 * Transform the nodes into the following
429 *
430 * Op -> AML_BUFFER_OP
431 * First Child -> BufferLength
432 * Second Child -> Descriptor Buffer (raw byte data)
433 */
434 BufferOp->Asl.ParseOpcode = PARSEOP_BUFFER;
435 BufferOp->Asl.AmlOpcode = AML_BUFFER_OP;
436 BufferOp->Asl.CompileFlags = NODE_AML_PACKAGE | NODE_IS_RESOURCE_DESC;
437 UtSetParseOpName (BufferOp);
438
439 BufferLengthOp->Asl.ParseOpcode = PARSEOP_INTEGER;
440 BufferLengthOp->Asl.Value.Integer = Rnode->BufferLength;
441 (void) OpcSetOptimalIntegerSize (BufferLengthOp);
442 UtSetParseOpName (BufferLengthOp);
443
444 BufferDataOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
445 BufferDataOp->Asl.AmlOpcode = AML_RAW_DATA_CHAIN;
446 BufferDataOp->Asl.AmlOpcodeLength = 0;
447 BufferDataOp->Asl.AmlLength = Rnode->BufferLength;
448 BufferDataOp->Asl.Value.Buffer = (UINT8 *) Rnode;
449 UtSetParseOpName (BufferDataOp);
450 }
451
452
453 /*******************************************************************************
454 *
455 * FUNCTION: OpcDoUnicode
456 *
457 * PARAMETERS: Op - Parse node
458 *
459 * RETURN: None
460 *
461 * DESCRIPTION: Implement the UNICODE ASL "macro". Convert the input string
462 * to a unicode buffer. There is no Unicode AML opcode.
463 *
464 * Note: The Unicode string is 16 bits per character, no leading signature,
465 * with a 16-bit terminating NULL.
466 *
467 ******************************************************************************/
468
469 static void
470 OpcDoUnicode (
471 ACPI_PARSE_OBJECT *Op)
472 {
473 ACPI_PARSE_OBJECT *InitializerOp;
474 UINT32 Length;
475 UINT32 Count;
476 UINT32 i;
477 UINT8 *AsciiString;
478 UINT16 *UnicodeString;
479 ACPI_PARSE_OBJECT *BufferLengthOp;
480
481
482 /* Change op into a buffer object */
483
484 Op->Asl.CompileFlags &= ~NODE_COMPILE_TIME_CONST;
485 Op->Asl.ParseOpcode = PARSEOP_BUFFER;
486 UtSetParseOpName (Op);
487
488 /* Buffer Length is first, followed by the string */
489
490 BufferLengthOp = Op->Asl.Child;
491 InitializerOp = BufferLengthOp->Asl.Next;
492
493 AsciiString = (UINT8 *) InitializerOp->Asl.Value.String;
494
495 /* Create a new buffer for the Unicode string */
496
497 Count = strlen (InitializerOp->Asl.Value.String) + 1;
498 Length = Count * sizeof (UINT16);
499 UnicodeString = UtLocalCalloc (Length);
500
501 /* Convert to Unicode string (including null terminator) */
502
503 for (i = 0; i < Count; i++)
504 {
505 UnicodeString[i] = (UINT16) AsciiString[i];
506 }
507
508 /*
509 * Just set the buffer size node to be the buffer length, regardless
510 * of whether it was previously an integer or a default_arg placeholder
511 */
512 BufferLengthOp->Asl.ParseOpcode = PARSEOP_INTEGER;
513 BufferLengthOp->Asl.AmlOpcode = AML_DWORD_OP;
514 BufferLengthOp->Asl.Value.Integer = Length;
515 UtSetParseOpName (BufferLengthOp);
516
517 (void) OpcSetOptimalIntegerSize (BufferLengthOp);
518
519 /* The Unicode string is a raw data buffer */
520
521 InitializerOp->Asl.Value.Buffer = (UINT8 *) UnicodeString;
522 InitializerOp->Asl.AmlOpcode = AML_RAW_DATA_BUFFER;
523 InitializerOp->Asl.AmlLength = Length;
524 InitializerOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
525 InitializerOp->Asl.Child = NULL;
526 UtSetParseOpName (InitializerOp);
527 }
528
529
530 /*******************************************************************************
531 *
532 * FUNCTION: OpcDoEisaId
533 *
534 * PARAMETERS: Op - Parse node
535 *
536 * RETURN: None
537 *
538 * DESCRIPTION: Convert a string EISA ID to numeric representation. See the
539 * Pnp BIOS Specification for details. Here is an excerpt:
540 *
541 * A seven character ASCII representation of the product
542 * identifier compressed into a 32-bit identifier. The seven
543 * character ID consists of a three character manufacturer code,
544 * a three character hexadecimal product identifier, and a one
545 * character hexadecimal revision number. The manufacturer code
546 * is a 3 uppercase character code that is compressed into 3 5-bit
547 * values as follows:
548 * 1) Find hex ASCII value for each letter
549 * 2) Subtract 40h from each ASCII value
550 * 3) Retain 5 least significant bits for each letter by
551 * discarding upper 3 bits because they are always 0.
552 * 4) Compressed code = concatenate 0 and the 3 5-bit values
553 *
554 * The format of the compressed product identifier is as follows:
555 * Byte 0: Bit 7 - Reserved (0)
556 * Bits 6-2: - 1st character of compressed mfg code
557 * Bits 1-0 - Upper 2 bits of 2nd character of mfg code
558 * Byte 1: Bits 7-5 - Lower 3 bits of 2nd character of mfg code
559 * Bits 4-0 - 3rd character of mfg code
560 * Byte 2: Bits 7-4 - 1st hex digit of product number
561 * Bits 3-0 - 2nd hex digit of product number
562 * Byte 3: Bits 7-4 - 3st hex digit of product number
563 * Bits 3-0 - Hex digit of the revision number
564 *
565 ******************************************************************************/
566
567 static void
568 OpcDoEisaId (
569 ACPI_PARSE_OBJECT *Op)
570 {
571 UINT32 EisaId = 0;
572 UINT32 BigEndianId;
573 char *InString;
574 ACPI_STATUS Status = AE_OK;
575 UINT32 i;
576
577
578 InString = (char *) Op->Asl.Value.String;
579
580 /*
581 * The EISAID string must be exactly 7 characters and of the form
582 * "UUUXXXX" -- 3 uppercase letters and 4 hex digits (e.g., "PNP0001")
583 */
584 if (ACPI_STRLEN (InString) != 7)
585 {
586 Status = AE_BAD_PARAMETER;
587 }
588 else
589 {
590 /* Check all 7 characters for correct format */
591
592 for (i = 0; i < 7; i++)
593 {
594 /* First 3 characters must be uppercase letters */
595
596 if (i < 3)
597 {
598 if (!isupper ((int) InString[i]))
599 {
600 Status = AE_BAD_PARAMETER;
601 }
602 }
603
604 /* Last 4 characters must be hex digits */
605
606 else if (!isxdigit ((int) InString[i]))
607 {
608 Status = AE_BAD_PARAMETER;
609 }
610 }
611 }
612
613 if (ACPI_FAILURE (Status))
614 {
615 AslError (ASL_ERROR, ASL_MSG_INVALID_EISAID, Op, Op->Asl.Value.String);
616 }
617 else
618 {
619 /* Create ID big-endian first (bits are contiguous) */
620
621 BigEndianId =
622 (UINT32) ((UINT8) (InString[0] - 0x40)) << 26 |
623 (UINT32) ((UINT8) (InString[1] - 0x40)) << 21 |
624 (UINT32) ((UINT8) (InString[2] - 0x40)) << 16 |
625
626 (UtHexCharToValue (InString[3])) << 12 |
627 (UtHexCharToValue (InString[4])) << 8 |
628 (UtHexCharToValue (InString[5])) << 4 |
629 UtHexCharToValue (InString[6]);
630
631 /* Swap to little-endian to get final ID (see function header) */
632
633 EisaId = AcpiUtDwordByteSwap (BigEndianId);
634 }
635
636 /*
637 * Morph the Op into an integer, regardless of whether there
638 * was an error in the EISAID string
639 */
640 Op->Asl.Value.Integer = EisaId;
641
642 Op->Asl.CompileFlags &= ~NODE_COMPILE_TIME_CONST;
643 Op->Asl.ParseOpcode = PARSEOP_INTEGER;
644 (void) OpcSetOptimalIntegerSize (Op);
645
646 /* Op is now an integer */
647
648 UtSetParseOpName (Op);
649 }
650
651
652 /*******************************************************************************
653 *
654 * FUNCTION: OpcDoUuId
655 *
656 * PARAMETERS: Op - Parse node
657 *
658 * RETURN: None
659 *
660 * DESCRIPTION: Convert UUID string to 16-byte buffer
661 *
662 ******************************************************************************/
663
664 static void
665 OpcDoUuId (
666 ACPI_PARSE_OBJECT *Op)
667 {
668 char *InString;
669 char *Buffer;
670 ACPI_STATUS Status = AE_OK;
671 ACPI_PARSE_OBJECT *NewOp;
672
673
674 InString = (char *) Op->Asl.Value.String;
675 Buffer = UtLocalCalloc (16);
676
677 Status = AuValidateUuid (InString);
678 if (ACPI_FAILURE (Status))
679 {
680 AslError (ASL_ERROR, ASL_MSG_INVALID_UUID, Op, Op->Asl.Value.String);
681 }
682 else
683 {
684 (void) AuConvertStringToUuid (InString, Buffer);
685 }
686
687 /* Change Op to a Buffer */
688
689 Op->Asl.ParseOpcode = PARSEOP_BUFFER;
690 Op->Common.AmlOpcode = AML_BUFFER_OP;
691
692 /* Disable further optimization */
693
694 Op->Asl.CompileFlags &= ~NODE_COMPILE_TIME_CONST;
695 UtSetParseOpName (Op);
696
697 /* Child node is the buffer length */
698
699 NewOp = TrAllocateNode (PARSEOP_INTEGER);
700
701 NewOp->Asl.AmlOpcode = AML_BYTE_OP;
702 NewOp->Asl.Value.Integer = 16;
703 NewOp->Asl.Parent = Op;
704
705 Op->Asl.Child = NewOp;
706 Op = NewOp;
707
708 /* Peer to the child is the raw buffer data */
709
710 NewOp = TrAllocateNode (PARSEOP_RAW_DATA);
711 NewOp->Asl.AmlOpcode = AML_RAW_DATA_BUFFER;
712 NewOp->Asl.AmlLength = 16;
713 NewOp->Asl.Value.String = (char *) Buffer;
714 NewOp->Asl.Parent = Op->Asl.Parent;
715
716 Op->Asl.Next = NewOp;
717 }
718
719
720 /*******************************************************************************
721 *
722 * FUNCTION: OpcGenerateAmlOpcode
723 *
724 * PARAMETERS: Op - Parse node
725 *
726 * RETURN: None
727 *
728 * DESCRIPTION: Generate the AML opcode associated with the node and its
729 * parse (lex/flex) keyword opcode. Essentially implements
730 * a mapping between the parse opcodes and the actual AML opcodes.
731 *
732 ******************************************************************************/
733
734 void
735 OpcGenerateAmlOpcode (
736 ACPI_PARSE_OBJECT *Op)
737 {
738
739 UINT16 Index;
740
741
742 Index = (UINT16) (Op->Asl.ParseOpcode - ASL_PARSE_OPCODE_BASE);
743
744 Op->Asl.AmlOpcode = AslKeywordMapping[Index].AmlOpcode;
745 Op->Asl.AcpiBtype = AslKeywordMapping[Index].AcpiBtype;
746 Op->Asl.CompileFlags |= AslKeywordMapping[Index].Flags;
747
748 if (!Op->Asl.Value.Integer)
749 {
750 Op->Asl.Value.Integer = AslKeywordMapping[Index].Value;
751 }
752
753 /* Special handling for some opcodes */
754
755 switch (Op->Asl.ParseOpcode)
756 {
757 case PARSEOP_INTEGER:
758 /*
759 * Set the opcode based on the size of the integer
760 */
761 (void) OpcSetOptimalIntegerSize (Op);
762 break;
763
764 case PARSEOP_OFFSET:
765
766 Op->Asl.AmlOpcodeLength = 1;
767 break;
768
769 case PARSEOP_ACCESSAS:
770
771 OpcDoAccessAs (Op);
772 break;
773
774 case PARSEOP_CONNECTION:
775
776 OpcDoConnection (Op);
777 break;
778
779 case PARSEOP_EISAID:
780
781 OpcDoEisaId (Op);
782 break;
783
784 case PARSEOP_TOUUID:
785
786 OpcDoUuId (Op);
787 break;
788
789 case PARSEOP_UNICODE:
790
791 OpcDoUnicode (Op);
792 break;
793
794 case PARSEOP_INCLUDE:
795
796 Op->Asl.Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
797 Gbl_HasIncludeFiles = TRUE;
798 break;
799
800 case PARSEOP_EXTERNAL:
801
802 Op->Asl.Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
803 Op->Asl.Child->Asl.Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
804 break;
805
806 case PARSEOP_TIMER:
807
808 if (AcpiGbl_IntegerBitWidth == 32)
809 {
810 AslError (ASL_REMARK, ASL_MSG_TRUNCATION, Op, NULL);
811 }
812 break;
813
814 default:
815
816 /* Nothing to do for other opcodes */
817
818 break;
819 }
820
821 return;
822 }