1 /*******************************************************************************
2 *
3 * Module Name: dmopcode - AML disassembler, specific AML opcodes
4 *
5 ******************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2013, 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 #include "acpi.h"
45 #include "accommon.h"
46 #include "acparser.h"
47 #include "amlcode.h"
48 #include "acdisasm.h"
49
50 #ifdef ACPI_DISASSEMBLER
51
52 #define _COMPONENT ACPI_CA_DEBUGGER
53 ACPI_MODULE_NAME ("dmopcode")
54
55 /* Local prototypes */
56
57 static void
58 AcpiDmMatchKeyword (
59 ACPI_PARSE_OBJECT *Op);
60
61
62 /*******************************************************************************
63 *
64 * FUNCTION: AcpiDmPredefinedDescription
65 *
66 * PARAMETERS: Op - Name() parse object
67 *
68 * RETURN: None
69 *
70 * DESCRIPTION: Emit a description comment for a predefined ACPI name.
71 * Used for iASL compiler only.
72 *
73 ******************************************************************************/
74
75 void
76 AcpiDmPredefinedDescription (
77 ACPI_PARSE_OBJECT *Op)
78 {
79 #ifdef ACPI_ASL_COMPILER
80 const AH_PREDEFINED_NAME *Info;
81 char *NameString;
82 int LastCharIsDigit;
83 int LastCharsAreHex;
84
85
86 if (!Op)
87 {
88 return;
89 }
90
91 /* Ensure that the comment field is emitted only once */
92
93 if (Op->Common.DisasmFlags & ACPI_PARSEOP_PREDEF_CHECKED)
94 {
95 return;
96 }
97 Op->Common.DisasmFlags |= ACPI_PARSEOP_PREDEF_CHECKED;
98
99 /* Predefined name must start with an underscore */
100
101 NameString = ACPI_CAST_PTR (char, &Op->Named.Name);
102 if (NameString[0] != '_')
103 {
104 return;
105 }
106
107 /*
108 * Check for the special ACPI names:
109 * _ACd, _ALd, _EJd, _Exx, _Lxx, _Qxx, _Wxx, _T_a
110 * (where d=decimal_digit, x=hex_digit, a=anything)
111 *
112 * Convert these to the generic name for table lookup.
113 * Note: NameString is guaranteed to be upper case here.
114 */
115 LastCharIsDigit =
116 (ACPI_IS_DIGIT (NameString[3])); /* d */
117 LastCharsAreHex =
118 (ACPI_IS_XDIGIT (NameString[2]) && /* xx */
119 ACPI_IS_XDIGIT (NameString[3]));
120
121 switch (NameString[1])
122 {
123 case 'A':
124
125 if ((NameString[2] == 'C') && (LastCharIsDigit))
126 {
127 NameString = "_ACx";
128 }
129 else if ((NameString[2] == 'L') && (LastCharIsDigit))
130 {
131 NameString = "_ALx";
132 }
133 break;
134
135 case 'E':
136
137 if ((NameString[2] == 'J') && (LastCharIsDigit))
138 {
139 NameString = "_EJx";
140 }
141 else if (LastCharsAreHex)
142 {
143 NameString = "_Exx";
144 }
145 break;
146
147 case 'L':
148
149 if (LastCharsAreHex)
150 {
151 NameString = "_Lxx";
152 }
153 break;
154
155 case 'Q':
156
157 if (LastCharsAreHex)
158 {
159 NameString = "_Qxx";
160 }
161 break;
162
163 case 'T':
164
165 if (NameString[2] == '_')
166 {
167 NameString = "_T_x";
168 }
169 break;
170
171 case 'W':
172
173 if (LastCharsAreHex)
174 {
175 NameString = "_Wxx";
176 }
177 break;
178
179 default:
180
181 break;
182 }
183
184 /* Match the name in the info table */
185
186 for (Info = AslPredefinedInfo; Info->Name; Info++)
187 {
188 if (ACPI_COMPARE_NAME (NameString, Info->Name))
189 {
190 AcpiOsPrintf (" // %4.4s: %s",
191 NameString, ACPI_CAST_PTR (char, Info->Description));
192 return;
193 }
194 }
195
196 #endif
197 return;
198 }
199
200
201 /*******************************************************************************
202 *
203 * FUNCTION: AcpiDmFieldPredefinedDescription
204 *
205 * PARAMETERS: Op - Parse object
206 *
207 * RETURN: None
208 *
209 * DESCRIPTION: Emit a description comment for a resource descriptor tag
210 * (which is a predefined ACPI name.) Used for iASL compiler only.
211 *
212 ******************************************************************************/
213
214 void
215 AcpiDmFieldPredefinedDescription (
216 ACPI_PARSE_OBJECT *Op)
217 {
218 #ifdef ACPI_ASL_COMPILER
219 ACPI_PARSE_OBJECT *IndexOp;
220 char *Tag;
221 const ACPI_OPCODE_INFO *OpInfo;
222 const AH_PREDEFINED_NAME *Info;
223
224
225 if (!Op)
226 {
227 return;
228 }
229
230 /* Ensure that the comment field is emitted only once */
231
232 if (Op->Common.DisasmFlags & ACPI_PARSEOP_PREDEF_CHECKED)
233 {
234 return;
235 }
236 Op->Common.DisasmFlags |= ACPI_PARSEOP_PREDEF_CHECKED;
237
238 /*
239 * Op must be one of the Create* operators: CreateField, CreateBitField,
240 * CreateByteField, CreateWordField, CreateDwordField, CreateQwordField
241 */
242 OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
243 if (!(OpInfo->Flags & AML_CREATE))
244 {
245 return;
246 }
247
248 /* Second argument is the Index argument */
249
250 IndexOp = Op->Common.Value.Arg;
251 IndexOp = IndexOp->Common.Next;
252
253 /* Index argument must be a namepath */
254
255 if (IndexOp->Common.AmlOpcode != AML_INT_NAMEPATH_OP)
256 {
257 return;
258 }
259
260 /* Major cheat: We previously put the Tag ptr in the Node field */
261
262 Tag = ACPI_CAST_PTR (char, IndexOp->Common.Node);
263 if (!Tag)
264 {
265 return;
266 }
267
268 /* Match the name in the info table */
269
270 for (Info = AslPredefinedInfo; Info->Name; Info++)
271 {
272 if (ACPI_COMPARE_NAME (Tag, Info->Name))
273 {
274 AcpiOsPrintf (" // %4.4s: %s", Tag,
275 ACPI_CAST_PTR (char, Info->Description));
276 return;
277 }
278 }
279
280 #endif
281 return;
282 }
283
284
285 /*******************************************************************************
286 *
287 * FUNCTION: AcpiDmMethodFlags
288 *
289 * PARAMETERS: Op - Method Object to be examined
290 *
291 * RETURN: None
292 *
293 * DESCRIPTION: Decode control method flags
294 *
295 ******************************************************************************/
296
297 void
298 AcpiDmMethodFlags (
299 ACPI_PARSE_OBJECT *Op)
300 {
301 UINT32 Flags;
302 UINT32 Args;
303
304
305 /* The next Op contains the flags */
306
307 Op = AcpiPsGetDepthNext (NULL, Op);
308 Flags = (UINT8) Op->Common.Value.Integer;
309 Args = Flags & 0x07;
310
311 /* Mark the Op as completed */
312
313 Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
314
315 /* 1) Method argument count */
316
317 AcpiOsPrintf (", %u, ", Args);
318
319 /* 2) Serialize rule */
320
321 if (!(Flags & 0x08))
322 {
323 AcpiOsPrintf ("Not");
324 }
325
326 AcpiOsPrintf ("Serialized");
327
328 /* 3) SyncLevel */
329
330 if (Flags & 0xF0)
331 {
332 AcpiOsPrintf (", %u", Flags >> 4);
333 }
334 }
335
336
337 /*******************************************************************************
338 *
339 * FUNCTION: AcpiDmFieldFlags
340 *
341 * PARAMETERS: Op - Field Object to be examined
342 *
343 * RETURN: None
344 *
345 * DESCRIPTION: Decode Field definition flags
346 *
347 ******************************************************************************/
348
349 void
350 AcpiDmFieldFlags (
351 ACPI_PARSE_OBJECT *Op)
352 {
353 UINT32 Flags;
354
355
356 Op = Op->Common.Next;
357 Flags = (UINT8) Op->Common.Value.Integer;
358
359 /* Mark the Op as completed */
360
361 Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
362
363 AcpiOsPrintf ("%s, ", AcpiGbl_AccessTypes [Flags & 0x07]);
364 AcpiOsPrintf ("%s, ", AcpiGbl_LockRule [(Flags & 0x10) >> 4]);
365 AcpiOsPrintf ("%s)", AcpiGbl_UpdateRules [(Flags & 0x60) >> 5]);
366 }
367
368
369 /*******************************************************************************
370 *
371 * FUNCTION: AcpiDmAddressSpace
372 *
373 * PARAMETERS: SpaceId - ID to be translated
374 *
375 * RETURN: None
376 *
377 * DESCRIPTION: Decode a SpaceId to an AddressSpaceKeyword
378 *
379 ******************************************************************************/
380
381 void
382 AcpiDmAddressSpace (
383 UINT8 SpaceId)
384 {
385
386 if (SpaceId >= ACPI_NUM_PREDEFINED_REGIONS)
387 {
388 if (SpaceId == 0x7F)
389 {
390 AcpiOsPrintf ("FFixedHW, ");
391 }
392 else
393 {
394 AcpiOsPrintf ("0x%.2X, ", SpaceId);
395 }
396 }
397 else
398 {
399 AcpiOsPrintf ("%s, ", AcpiGbl_RegionTypes [SpaceId]);
400 }
401 }
402
403
404 /*******************************************************************************
405 *
406 * FUNCTION: AcpiDmRegionFlags
407 *
408 * PARAMETERS: Op - Object to be examined
409 *
410 * RETURN: None
411 *
412 * DESCRIPTION: Decode OperationRegion flags
413 *
414 ******************************************************************************/
415
416 void
417 AcpiDmRegionFlags (
418 ACPI_PARSE_OBJECT *Op)
419 {
420
421
422 /* The next Op contains the SpaceId */
423
424 Op = AcpiPsGetDepthNext (NULL, Op);
425
426 /* Mark the Op as completed */
427
428 Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
429
430 AcpiOsPrintf (", ");
431 AcpiDmAddressSpace ((UINT8) Op->Common.Value.Integer);
432 }
433
434
435 /*******************************************************************************
436 *
437 * FUNCTION: AcpiDmMatchOp
438 *
439 * PARAMETERS: Op - Match Object to be examined
440 *
441 * RETURN: None
442 *
443 * DESCRIPTION: Decode Match opcode operands
444 *
445 ******************************************************************************/
446
447 void
448 AcpiDmMatchOp (
449 ACPI_PARSE_OBJECT *Op)
450 {
451 ACPI_PARSE_OBJECT *NextOp;
452
453
454 NextOp = AcpiPsGetDepthNext (NULL, Op);
455 NextOp = NextOp->Common.Next;
456
457 if (!NextOp)
458 {
459 /* Handle partial tree during single-step */
460
461 return;
462 }
463
464 /* Mark the two nodes that contain the encoding for the match keywords */
465
466 NextOp->Common.DisasmOpcode = ACPI_DASM_MATCHOP;
467
468 NextOp = NextOp->Common.Next;
469 NextOp = NextOp->Common.Next;
470 NextOp->Common.DisasmOpcode = ACPI_DASM_MATCHOP;
471 }
472
473
474 /*******************************************************************************
475 *
476 * FUNCTION: AcpiDmMatchKeyword
477 *
478 * PARAMETERS: Op - Match Object to be examined
479 *
480 * RETURN: None
481 *
482 * DESCRIPTION: Decode Match opcode operands
483 *
484 ******************************************************************************/
485
486 static void
487 AcpiDmMatchKeyword (
488 ACPI_PARSE_OBJECT *Op)
489 {
490
491
492 if (((UINT32) Op->Common.Value.Integer) > ACPI_MAX_MATCH_OPCODE)
493 {
494 AcpiOsPrintf ("/* Unknown Match Keyword encoding */");
495 }
496 else
497 {
498 AcpiOsPrintf ("%s", ACPI_CAST_PTR (char,
499 AcpiGbl_MatchOps[(ACPI_SIZE) Op->Common.Value.Integer]));
500 }
501 }
502
503
504 /*******************************************************************************
505 *
506 * FUNCTION: AcpiDmDisassembleOneOp
507 *
508 * PARAMETERS: WalkState - Current walk info
509 * Info - Parse tree walk info
510 * Op - Op that is to be printed
511 *
512 * RETURN: None
513 *
514 * DESCRIPTION: Disassemble a single AML opcode
515 *
516 ******************************************************************************/
517
518 void
519 AcpiDmDisassembleOneOp (
520 ACPI_WALK_STATE *WalkState,
521 ACPI_OP_WALK_INFO *Info,
522 ACPI_PARSE_OBJECT *Op)
523 {
524 const ACPI_OPCODE_INFO *OpInfo = NULL;
525 UINT32 Offset;
526 UINT32 Length;
527 ACPI_PARSE_OBJECT *Child;
528 ACPI_STATUS Status;
529 UINT8 *Aml;
530
531
532 if (!Op)
533 {
534 AcpiOsPrintf ("<NULL OP PTR>");
535 return;
536 }
537
538 switch (Op->Common.DisasmOpcode)
539 {
540 case ACPI_DASM_MATCHOP:
541
542 AcpiDmMatchKeyword (Op);
543 return;
544
545 case ACPI_DASM_LNOT_SUFFIX:
546
547 switch (Op->Common.AmlOpcode)
548 {
549 case AML_LEQUAL_OP:
550
551 AcpiOsPrintf ("LNotEqual");
552 break;
553
554 case AML_LGREATER_OP:
555
556 AcpiOsPrintf ("LLessEqual");
557 break;
558
559 case AML_LLESS_OP:
560
561 AcpiOsPrintf ("LGreaterEqual");
562 break;
563
564 default:
565
566 break;
567 }
568 Op->Common.DisasmOpcode = 0;
569 Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
570 return;
571
572 default:
573 break;
574 }
575
576
577 OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
578
579 /* The op and arguments */
580
581 switch (Op->Common.AmlOpcode)
582 {
583 case AML_LNOT_OP:
584
585 Child = Op->Common.Value.Arg;
586 if ((Child->Common.AmlOpcode == AML_LEQUAL_OP) ||
587 (Child->Common.AmlOpcode == AML_LGREATER_OP) ||
588 (Child->Common.AmlOpcode == AML_LLESS_OP))
589 {
590 Child->Common.DisasmOpcode = ACPI_DASM_LNOT_SUFFIX;
591 Op->Common.DisasmOpcode = ACPI_DASM_LNOT_PREFIX;
592 }
593 else
594 {
595 AcpiOsPrintf ("%s", OpInfo->Name);
596 }
597 break;
598
599 case AML_BYTE_OP:
600
601 AcpiOsPrintf ("0x%2.2X", (UINT32) Op->Common.Value.Integer);
602 break;
603
604 case AML_WORD_OP:
605
606 if (Op->Common.DisasmOpcode == ACPI_DASM_EISAID)
607 {
608 AcpiDmEisaId ((UINT32) Op->Common.Value.Integer);
609 }
610 else
611 {
612 AcpiOsPrintf ("0x%4.4X", (UINT32) Op->Common.Value.Integer);
613 }
614 break;
615
616 case AML_DWORD_OP:
617
618 if (Op->Common.DisasmOpcode == ACPI_DASM_EISAID)
619 {
620 AcpiDmEisaId ((UINT32) Op->Common.Value.Integer);
621 }
622 else
623 {
624 AcpiOsPrintf ("0x%8.8X", (UINT32) Op->Common.Value.Integer);
625 }
626 break;
627
628 case AML_QWORD_OP:
629
630 AcpiOsPrintf ("0x%8.8X%8.8X",
631 ACPI_FORMAT_UINT64 (Op->Common.Value.Integer));
632 break;
633
634 case AML_STRING_OP:
635
636 AcpiUtPrintString (Op->Common.Value.String, ACPI_UINT16_MAX);
637 break;
638
639 case AML_BUFFER_OP:
640 /*
641 * Determine the type of buffer. We can have one of the following:
642 *
643 * 1) ResourceTemplate containing Resource Descriptors.
644 * 2) Unicode String buffer
645 * 3) ASCII String buffer
646 * 4) Raw data buffer (if none of the above)
647 *
648 * Since there are no special AML opcodes to differentiate these
649 * types of buffers, we have to closely look at the data in the
650 * buffer to determine the type.
651 */
652 if (!AcpiGbl_NoResourceDisassembly)
653 {
654 Status = AcpiDmIsResourceTemplate (WalkState, Op);
655 if (ACPI_SUCCESS (Status))
656 {
657 Op->Common.DisasmOpcode = ACPI_DASM_RESOURCE;
658 AcpiOsPrintf ("ResourceTemplate");
659 break;
660 }
661 else if (Status == AE_AML_NO_RESOURCE_END_TAG)
662 {
663 AcpiOsPrintf ("/**** Is ResourceTemplate, but EndTag not at buffer end ****/ ");
664 }
665 }
666
667 if (AcpiDmIsUnicodeBuffer (Op))
668 {
669 Op->Common.DisasmOpcode = ACPI_DASM_UNICODE;
670 AcpiOsPrintf ("Unicode (");
671 }
672 else if (AcpiDmIsStringBuffer (Op))
673 {
674 Op->Common.DisasmOpcode = ACPI_DASM_STRING;
675 AcpiOsPrintf ("Buffer");
676 }
677 else if (AcpiDmIsPldBuffer (Op))
678 {
679 Op->Common.DisasmOpcode = ACPI_DASM_PLD_METHOD;
680 AcpiOsPrintf ("Buffer");
681 }
682 else
683 {
684 Op->Common.DisasmOpcode = ACPI_DASM_BUFFER;
685 AcpiOsPrintf ("Buffer");
686 }
687 break;
688
689 case AML_INT_STATICSTRING_OP:
690
691 if (Op->Common.Value.String)
692 {
693 AcpiOsPrintf ("%s", Op->Common.Value.String);
694 }
695 else
696 {
697 AcpiOsPrintf ("\"<NULL STATIC STRING PTR>\"");
698 }
699 break;
700
701 case AML_INT_NAMEPATH_OP:
702
703 AcpiDmNamestring (Op->Common.Value.Name);
704 break;
705
706 case AML_INT_NAMEDFIELD_OP:
707
708 Length = AcpiDmDumpName (Op->Named.Name);
709 AcpiOsPrintf (",%*.s %u", (unsigned) (5 - Length), " ",
710 (UINT32) Op->Common.Value.Integer);
711 AcpiDmCommaIfFieldMember (Op);
712
713 Info->BitOffset += (UINT32) Op->Common.Value.Integer;
714 break;
715
716 case AML_INT_RESERVEDFIELD_OP:
717
718 /* Offset() -- Must account for previous offsets */
719
720 Offset = (UINT32) Op->Common.Value.Integer;
721 Info->BitOffset += Offset;
722
723 if (Info->BitOffset % 8 == 0)
724 {
725 AcpiOsPrintf ("Offset (0x%.2X)", ACPI_DIV_8 (Info->BitOffset));
726 }
727 else
728 {
729 AcpiOsPrintf (" , %u", Offset);
730 }
731
732 AcpiDmCommaIfFieldMember (Op);
733 break;
734
735 case AML_INT_ACCESSFIELD_OP:
736 case AML_INT_EXTACCESSFIELD_OP:
737
738 AcpiOsPrintf ("AccessAs (%s, ",
739 AcpiGbl_AccessTypes [(UINT32) (Op->Common.Value.Integer & 0x7)]);
740
741 AcpiDmDecodeAttribute ((UINT8) (Op->Common.Value.Integer >> 8));
742
743 if (Op->Common.AmlOpcode == AML_INT_EXTACCESSFIELD_OP)
744 {
745 AcpiOsPrintf (" (0x%2.2X)", (unsigned) ((Op->Common.Value.Integer >> 16) & 0xFF));
746 }
747
748 AcpiOsPrintf (")");
749 AcpiDmCommaIfFieldMember (Op);
750 break;
751
752 case AML_INT_CONNECTION_OP:
753 /*
754 * Two types of Connection() - one with a buffer object, the
755 * other with a namestring that points to a buffer object.
756 */
757 AcpiOsPrintf ("Connection (");
758 Child = Op->Common.Value.Arg;
759
760 if (Child->Common.AmlOpcode == AML_INT_BYTELIST_OP)
761 {
762 AcpiOsPrintf ("\n");
763
764 Aml = Child->Named.Data;
765 Length = (UINT32) Child->Common.Value.Integer;
766
767 Info->Level += 1;
768 Op->Common.DisasmOpcode = ACPI_DASM_RESOURCE;
769 AcpiDmResourceTemplate (Info, Op->Common.Parent, Aml, Length);
770
771 Info->Level -= 1;
772 AcpiDmIndent (Info->Level);
773 }
774 else
775 {
776 AcpiDmNamestring (Child->Common.Value.Name);
777 }
778
779 AcpiOsPrintf (")");
780 AcpiDmCommaIfFieldMember (Op);
781 AcpiOsPrintf ("\n");
782
783 Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE; /* for now, ignore in AcpiDmAscendingOp */
784 Child->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
785 break;
786
787 case AML_INT_BYTELIST_OP:
788
789 AcpiDmByteList (Info, Op);
790 break;
791
792 case AML_INT_METHODCALL_OP:
793
794 Op = AcpiPsGetDepthNext (NULL, Op);
795 Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
796
797 AcpiDmNamestring (Op->Common.Value.Name);
798 break;
799
800 default:
801
802 /* Just get the opcode name and print it */
803
804 AcpiOsPrintf ("%s", OpInfo->Name);
805
806
807 #ifdef ACPI_DEBUGGER
808
809 if ((Op->Common.AmlOpcode == AML_INT_RETURN_VALUE_OP) &&
810 (WalkState) &&
811 (WalkState->Results) &&
812 (WalkState->ResultCount))
813 {
814 AcpiDmDecodeInternalObject (
815 WalkState->Results->Results.ObjDesc [
816 (WalkState->ResultCount - 1) %
817 ACPI_RESULTS_FRAME_OBJ_NUM]);
818 }
819 #endif
820
821 break;
822 }
823 }
824
825 #endif /* ACPI_DISASSEMBLER */