dmopcode.c revision 250838 
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
57static void
58AcpiDmMatchKeyword (
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
75void
76AcpiDmPredefinedDescription (
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
214void
215AcpiDmFieldPredefinedDescription (
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
297void
298AcpiDmMethodFlags (
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
349void
350AcpiDmFieldFlags (
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
381void
382AcpiDmAddressSpace (
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
416void
417AcpiDmRegionFlags (
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
447void
448AcpiDmMatchOp (
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
486static void
487AcpiDmMatchKeyword (
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
518void
519AcpiDmDisassembleOneOp (
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_UINT8_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 */
826