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