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