dmwalk.c revision 250838 
1/*******************************************************************************
2 *
3 * Module Name: dmwalk - AML disassembly tree walk
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
45#include <contrib/dev/acpica/include/acpi.h>
46#include <contrib/dev/acpica/include/accommon.h>
47#include <contrib/dev/acpica/include/acparser.h>
48#include <contrib/dev/acpica/include/amlcode.h>
49#include <contrib/dev/acpica/include/acdisasm.h>
50#include <contrib/dev/acpica/include/acdebug.h>
51
52
53#ifdef ACPI_DISASSEMBLER
54
55#define _COMPONENT          ACPI_CA_DEBUGGER
56        ACPI_MODULE_NAME    ("dmwalk")
57
58
59#define DB_FULL_OP_INFO     "[%4.4s] @%5.5X #%4.4X:  "
60
61/* Stub for non-compiler code */
62
63#ifndef ACPI_ASL_COMPILER
64void
65AcpiDmEmitExternals (
66    void)
67{
68    return;
69}
70#endif
71
72/* Local prototypes */
73
74static ACPI_STATUS
75AcpiDmDescendingOp (
76    ACPI_PARSE_OBJECT       *Op,
77    UINT32                  Level,
78    void                    *Context);
79
80static ACPI_STATUS
81AcpiDmAscendingOp (
82    ACPI_PARSE_OBJECT       *Op,
83    UINT32                  Level,
84    void                    *Context);
85
86static UINT32
87AcpiDmBlockType (
88    ACPI_PARSE_OBJECT       *Op);
89
90
91/*******************************************************************************
92 *
93 * FUNCTION:    AcpiDmDisassemble
94 *
95 * PARAMETERS:  WalkState       - Current state
96 *              Origin          - Starting object
97 *              NumOpcodes      - Max number of opcodes to be displayed
98 *
99 * RETURN:      None
100 *
101 * DESCRIPTION: Disassemble parser object and its children. This is the
102 *              main entry point of the disassembler.
103 *
104 ******************************************************************************/
105
106void
107AcpiDmDisassemble (
108    ACPI_WALK_STATE         *WalkState,
109    ACPI_PARSE_OBJECT       *Origin,
110    UINT32                  NumOpcodes)
111{
112    ACPI_PARSE_OBJECT       *Op = Origin;
113    ACPI_OP_WALK_INFO       Info;
114
115
116    if (!Op)
117    {
118        return;
119    }
120
121    Info.Flags = 0;
122    Info.Level = 0;
123    Info.Count = 0;
124    Info.WalkState = WalkState;
125    AcpiDmWalkParseTree (Op, AcpiDmDescendingOp, AcpiDmAscendingOp, &Info);
126    return;
127}
128
129
130/*******************************************************************************
131 *
132 * FUNCTION:    AcpiDmWalkParseTree
133 *
134 * PARAMETERS:  Op                      - Root Op object
135 *              DescendingCallback      - Called during tree descent
136 *              AscendingCallback       - Called during tree ascent
137 *              Context                 - To be passed to the callbacks
138 *
139 * RETURN:      Status from callback(s)
140 *
141 * DESCRIPTION: Walk the entire parse tree.
142 *
143 ******************************************************************************/
144
145void
146AcpiDmWalkParseTree (
147    ACPI_PARSE_OBJECT       *Op,
148    ASL_WALK_CALLBACK       DescendingCallback,
149    ASL_WALK_CALLBACK       AscendingCallback,
150    void                    *Context)
151{
152    BOOLEAN                 NodePreviouslyVisited;
153    ACPI_PARSE_OBJECT       *StartOp = Op;
154    ACPI_STATUS             Status;
155    ACPI_PARSE_OBJECT       *Next;
156    ACPI_OP_WALK_INFO       *Info = Context;
157
158
159    Info->Level = 0;
160    NodePreviouslyVisited = FALSE;
161
162    while (Op)
163    {
164        if (NodePreviouslyVisited)
165        {
166            if (AscendingCallback)
167            {
168                Status = AscendingCallback (Op, Info->Level, Context);
169                if (ACPI_FAILURE (Status))
170                {
171                    return;
172                }
173            }
174        }
175        else
176        {
177            /* Let the callback process the node */
178
179            Status = DescendingCallback (Op, Info->Level, Context);
180            if (ACPI_SUCCESS (Status))
181            {
182                /* Visit children first, once */
183
184                Next = AcpiPsGetArg (Op, 0);
185                if (Next)
186                {
187                    Info->Level++;
188                    Op = Next;
189                    continue;
190                }
191            }
192            else if (Status != AE_CTRL_DEPTH)
193            {
194                /* Exit immediately on any error */
195
196                return;
197            }
198        }
199
200        /* Terminate walk at start op */
201
202        if (Op == StartOp)
203        {
204            break;
205        }
206
207        /* No more children, re-visit this node */
208
209        if (!NodePreviouslyVisited)
210        {
211            NodePreviouslyVisited = TRUE;
212            continue;
213        }
214
215        /* No more children, visit peers */
216
217        if (Op->Common.Next)
218        {
219            Op = Op->Common.Next;
220            NodePreviouslyVisited = FALSE;
221        }
222        else
223        {
224            /* No peers, re-visit parent */
225
226            if (Info->Level != 0 )
227            {
228                Info->Level--;
229            }
230
231            Op = Op->Common.Parent;
232            NodePreviouslyVisited = TRUE;
233        }
234    }
235
236    /* If we get here, the walk completed with no errors */
237
238    return;
239}
240
241
242/*******************************************************************************
243 *
244 * FUNCTION:    AcpiDmBlockType
245 *
246 * PARAMETERS:  Op              - Object to be examined
247 *
248 * RETURN:      BlockType - not a block, parens, braces, or even both.
249 *
250 * DESCRIPTION: Type of block for this op (parens or braces)
251 *
252 ******************************************************************************/
253
254static UINT32
255AcpiDmBlockType (
256    ACPI_PARSE_OBJECT       *Op)
257{
258    const ACPI_OPCODE_INFO  *OpInfo;
259
260
261    if (!Op)
262    {
263        return (BLOCK_NONE);
264    }
265
266    switch (Op->Common.AmlOpcode)
267    {
268    case AML_ELSE_OP:
269
270        return (BLOCK_BRACE);
271
272    case AML_METHOD_OP:
273    case AML_DEVICE_OP:
274    case AML_SCOPE_OP:
275    case AML_PROCESSOR_OP:
276    case AML_POWER_RES_OP:
277    case AML_THERMAL_ZONE_OP:
278    case AML_IF_OP:
279    case AML_WHILE_OP:
280    case AML_FIELD_OP:
281    case AML_INDEX_FIELD_OP:
282    case AML_BANK_FIELD_OP:
283
284        return (BLOCK_PAREN | BLOCK_BRACE);
285
286    case AML_BUFFER_OP:
287
288        if (Op->Common.DisasmOpcode == ACPI_DASM_UNICODE)
289        {
290            return (BLOCK_NONE);
291        }
292
293        /*lint -fallthrough */
294
295    case AML_PACKAGE_OP:
296    case AML_VAR_PACKAGE_OP:
297
298        return (BLOCK_PAREN | BLOCK_BRACE);
299
300    case AML_EVENT_OP:
301
302        return (BLOCK_PAREN);
303
304    default:
305
306        OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
307        if (OpInfo->Flags & AML_HAS_ARGS)
308        {
309            return (BLOCK_PAREN);
310        }
311
312        return (BLOCK_NONE);
313    }
314}
315
316
317/*******************************************************************************
318 *
319 * FUNCTION:    AcpiDmListType
320 *
321 * PARAMETERS:  Op              - Object to be examined
322 *
323 * RETURN:      ListType - has commas or not.
324 *
325 * DESCRIPTION: Type of block for this op (parens or braces)
326 *
327 ******************************************************************************/
328
329UINT32
330AcpiDmListType (
331    ACPI_PARSE_OBJECT       *Op)
332{
333    const ACPI_OPCODE_INFO  *OpInfo;
334
335
336    if (!Op)
337    {
338        return (BLOCK_NONE);
339    }
340
341    switch (Op->Common.AmlOpcode)
342    {
343
344    case AML_ELSE_OP:
345    case AML_METHOD_OP:
346    case AML_DEVICE_OP:
347    case AML_SCOPE_OP:
348    case AML_POWER_RES_OP:
349    case AML_PROCESSOR_OP:
350    case AML_THERMAL_ZONE_OP:
351    case AML_IF_OP:
352    case AML_WHILE_OP:
353    case AML_FIELD_OP:
354    case AML_INDEX_FIELD_OP:
355    case AML_BANK_FIELD_OP:
356
357        return (BLOCK_NONE);
358
359    case AML_BUFFER_OP:
360    case AML_PACKAGE_OP:
361    case AML_VAR_PACKAGE_OP:
362
363        return (BLOCK_COMMA_LIST);
364
365    default:
366
367        OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
368        if (OpInfo->Flags & AML_HAS_ARGS)
369        {
370            return (BLOCK_COMMA_LIST);
371        }
372
373        return (BLOCK_NONE);
374    }
375}
376
377
378/*******************************************************************************
379 *
380 * FUNCTION:    AcpiDmDescendingOp
381 *
382 * PARAMETERS:  ASL_WALK_CALLBACK
383 *
384 * RETURN:      Status
385 *
386 * DESCRIPTION: First visitation of a parse object during tree descent.
387 *              Decode opcode name and begin parameter list(s), if any.
388 *
389 ******************************************************************************/
390
391static ACPI_STATUS
392AcpiDmDescendingOp (
393    ACPI_PARSE_OBJECT       *Op,
394    UINT32                  Level,
395    void                    *Context)
396{
397    ACPI_OP_WALK_INFO       *Info = Context;
398    const ACPI_OPCODE_INFO  *OpInfo;
399    UINT32                  Name;
400    ACPI_PARSE_OBJECT       *NextOp;
401
402
403    if (Op->Common.DisasmFlags & ACPI_PARSEOP_IGNORE)
404    {
405        /* Ignore this op -- it was handled elsewhere */
406
407        return (AE_CTRL_DEPTH);
408    }
409
410    /* Level 0 is at the Definition Block level */
411
412    if (Level == 0)
413    {
414        /* In verbose mode, print the AML offset, opcode and depth count */
415
416        if (Info->WalkState)
417        {
418            VERBOSE_PRINT ((DB_FULL_OP_INFO,
419                (Info->WalkState->MethodNode ?
420                    Info->WalkState->MethodNode->Name.Ascii : "   "),
421                Op->Common.AmlOffset, (UINT32) Op->Common.AmlOpcode));
422        }
423
424        if (Op->Common.AmlOpcode == AML_SCOPE_OP)
425        {
426            /* This is the beginning of the Definition Block */
427
428            AcpiOsPrintf ("{\n");
429
430            /* Emit all External() declarations here */
431
432            AcpiDmEmitExternals ();
433            return (AE_OK);
434        }
435    }
436    else if ((AcpiDmBlockType (Op->Common.Parent) & BLOCK_BRACE) &&
437             (!(Op->Common.DisasmFlags & ACPI_PARSEOP_PARAMLIST)) &&
438             (Op->Common.AmlOpcode != AML_INT_BYTELIST_OP))
439    {
440            /*
441             * This is a first-level element of a term list,
442             * indent a new line
443             */
444            switch (Op->Common.AmlOpcode)
445            {
446            case AML_NOOP_OP:
447                /*
448                 * Optionally just ignore this opcode. Some tables use
449                 * NoOp opcodes for "padding" out packages that the BIOS
450                 * changes dynamically. This can leave hundreds or
451                 * thousands of NoOp opcodes that if disassembled,
452                 * cannot be compiled because they are syntactically
453                 * incorrect.
454                 */
455                if (AcpiGbl_IgnoreNoopOperator)
456                {
457                    Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
458                    return (AE_OK);
459                }
460
461                /* Fallthrough */
462
463            default:
464
465                AcpiDmIndent (Level);
466                break;
467            }
468
469            Info->LastLevel = Level;
470            Info->Count = 0;
471    }
472
473    /*
474     * This is an inexpensive mechanism to try and keep lines from getting
475     * too long. When the limit is hit, start a new line at the previous
476     * indent plus one. A better but more expensive mechanism would be to
477     * keep track of the current column.
478     */
479    Info->Count++;
480    if (Info->Count /* +Info->LastLevel */ > 10)
481    {
482        Info->Count = 0;
483        AcpiOsPrintf ("\n");
484        AcpiDmIndent (Info->LastLevel + 1);
485    }
486
487    /* Print the opcode name */
488
489    AcpiDmDisassembleOneOp (NULL, Info, Op);
490
491    if ((Op->Common.DisasmOpcode == ACPI_DASM_LNOT_PREFIX) ||
492        (Op->Common.AmlOpcode == AML_INT_CONNECTION_OP))
493    {
494        return (AE_OK);
495    }
496
497    if ((Op->Common.AmlOpcode == AML_NAME_OP) ||
498        (Op->Common.AmlOpcode == AML_RETURN_OP))
499    {
500        Info->Level--;
501    }
502
503    /* Start the opcode argument list if necessary */
504
505    OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
506
507    if ((OpInfo->Flags & AML_HAS_ARGS) ||
508        (Op->Common.AmlOpcode == AML_EVENT_OP))
509    {
510        /* This opcode has an argument list */
511
512        if (AcpiDmBlockType (Op) & BLOCK_PAREN)
513        {
514            AcpiOsPrintf (" (");
515        }
516
517        /* If this is a named opcode, print the associated name value */
518
519        if (OpInfo->Flags & AML_NAMED)
520        {
521            switch (Op->Common.AmlOpcode)
522            {
523            case AML_ALIAS_OP:
524
525                NextOp = AcpiPsGetDepthNext (NULL, Op);
526                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
527                AcpiDmNamestring (NextOp->Common.Value.Name);
528                AcpiOsPrintf (", ");
529
530                /*lint -fallthrough */
531
532            default:
533
534                Name = AcpiPsGetName (Op);
535                if (Op->Named.Path)
536                {
537                    AcpiDmNamestring ((char *) Op->Named.Path);
538                }
539                else
540                {
541                    AcpiDmDumpName (Name);
542                }
543
544                if (Op->Common.AmlOpcode != AML_INT_NAMEDFIELD_OP)
545                {
546                    if (AcpiGbl_DbOpt_verbose)
547                    {
548                        (void) AcpiPsDisplayObjectPathname (NULL, Op);
549                    }
550                }
551                break;
552            }
553
554            switch (Op->Common.AmlOpcode)
555            {
556            case AML_METHOD_OP:
557
558                AcpiDmMethodFlags (Op);
559                AcpiOsPrintf (")");
560
561                /* Emit description comment for Method() with a predefined ACPI name */
562
563                AcpiDmPredefinedDescription (Op);
564                break;
565
566
567            case AML_NAME_OP:
568
569                /* Check for _HID and related EISAID() */
570
571                AcpiDmIsEisaId (Op);
572                AcpiOsPrintf (", ");
573                break;
574
575
576            case AML_REGION_OP:
577
578                AcpiDmRegionFlags (Op);
579                break;
580
581
582            case AML_POWER_RES_OP:
583
584                /* Mark the next two Ops as part of the parameter list */
585
586                AcpiOsPrintf (", ");
587                NextOp = AcpiPsGetDepthNext (NULL, Op);
588                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMLIST;
589
590                NextOp = NextOp->Common.Next;
591                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMLIST;
592                return (AE_OK);
593
594
595            case AML_PROCESSOR_OP:
596
597                /* Mark the next three Ops as part of the parameter list */
598
599                AcpiOsPrintf (", ");
600                NextOp = AcpiPsGetDepthNext (NULL, Op);
601                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMLIST;
602
603                NextOp = NextOp->Common.Next;
604                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMLIST;
605
606                NextOp = NextOp->Common.Next;
607                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMLIST;
608                return (AE_OK);
609
610
611            case AML_MUTEX_OP:
612            case AML_DATA_REGION_OP:
613
614                AcpiOsPrintf (", ");
615                return (AE_OK);
616
617
618            case AML_EVENT_OP:
619            case AML_ALIAS_OP:
620
621                return (AE_OK);
622
623
624            case AML_SCOPE_OP:
625            case AML_DEVICE_OP:
626            case AML_THERMAL_ZONE_OP:
627
628                AcpiOsPrintf (")");
629                break;
630
631
632            default:
633
634                AcpiOsPrintf ("*** Unhandled named opcode %X\n",
635                    Op->Common.AmlOpcode);
636                break;
637            }
638        }
639
640        else switch (Op->Common.AmlOpcode)
641        {
642        case AML_FIELD_OP:
643        case AML_BANK_FIELD_OP:
644        case AML_INDEX_FIELD_OP:
645
646            Info->BitOffset = 0;
647
648            /* Name of the parent OperationRegion */
649
650            NextOp = AcpiPsGetDepthNext (NULL, Op);
651            AcpiDmNamestring (NextOp->Common.Value.Name);
652            AcpiOsPrintf (", ");
653            NextOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
654
655            switch (Op->Common.AmlOpcode)
656            {
657            case AML_BANK_FIELD_OP:
658
659                /* Namestring - Bank Name */
660
661                NextOp = AcpiPsGetDepthNext (NULL, NextOp);
662                AcpiDmNamestring (NextOp->Common.Value.Name);
663                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
664                AcpiOsPrintf (", ");
665
666                /*
667                 * Bank Value. This is a TermArg in the middle of the parameter
668                 * list, must handle it here.
669                 *
670                 * Disassemble the TermArg parse tree. ACPI_PARSEOP_PARAMLIST
671                 * eliminates newline in the output.
672                 */
673                NextOp = NextOp->Common.Next;
674
675                Info->Flags = ACPI_PARSEOP_PARAMLIST;
676                AcpiDmWalkParseTree (NextOp, AcpiDmDescendingOp,
677                    AcpiDmAscendingOp, Info);
678                Info->Flags = 0;
679                Info->Level = Level;
680
681                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
682                AcpiOsPrintf (", ");
683                break;
684
685            case AML_INDEX_FIELD_OP:
686
687                /* Namestring - Data Name */
688
689                NextOp = AcpiPsGetDepthNext (NULL, NextOp);
690                AcpiDmNamestring (NextOp->Common.Value.Name);
691                AcpiOsPrintf (", ");
692                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
693                break;
694
695            default:
696
697                break;
698            }
699
700            AcpiDmFieldFlags (NextOp);
701            break;
702
703        case AML_BUFFER_OP:
704
705            /* The next op is the size parameter */
706
707            NextOp = AcpiPsGetDepthNext (NULL, Op);
708            if (!NextOp)
709            {
710                /* Single-step support */
711
712                return (AE_OK);
713            }
714
715            if (Op->Common.DisasmOpcode == ACPI_DASM_RESOURCE)
716            {
717                /*
718                 * We have a resource list. Don't need to output
719                 * the buffer size Op. Open up a new block
720                 */
721                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
722                NextOp = NextOp->Common.Next;
723                AcpiOsPrintf (")");
724
725                /* Emit description comment for Name() with a predefined ACPI name */
726
727                AcpiDmPredefinedDescription (Op->Asl.Parent);
728
729                AcpiOsPrintf ("\n");
730                AcpiDmIndent (Info->Level);
731                AcpiOsPrintf ("{\n");
732                return (AE_OK);
733            }
734
735            /* Normal Buffer, mark size as in the parameter list */
736
737            NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMLIST;
738            return (AE_OK);
739
740        case AML_VAR_PACKAGE_OP:
741        case AML_IF_OP:
742        case AML_WHILE_OP:
743
744            /* The next op is the size or predicate parameter */
745
746            NextOp = AcpiPsGetDepthNext (NULL, Op);
747            if (NextOp)
748            {
749                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMLIST;
750            }
751            return (AE_OK);
752
753        case AML_PACKAGE_OP:
754
755            /* The next op is the size parameter */
756
757            NextOp = AcpiPsGetDepthNext (NULL, Op);
758            if (NextOp)
759            {
760                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMLIST;
761            }
762            return (AE_OK);
763
764        case AML_MATCH_OP:
765
766            AcpiDmMatchOp (Op);
767            break;
768
769        default:
770
771            break;
772        }
773
774        if (AcpiDmBlockType (Op) & BLOCK_BRACE)
775        {
776            AcpiOsPrintf ("\n");
777            AcpiDmIndent (Level);
778            AcpiOsPrintf ("{\n");
779        }
780    }
781
782    return (AE_OK);
783}
784
785
786/*******************************************************************************
787 *
788 * FUNCTION:    AcpiDmAscendingOp
789 *
790 * PARAMETERS:  ASL_WALK_CALLBACK
791 *
792 * RETURN:      Status
793 *
794 * DESCRIPTION: Second visitation of a parse object, during ascent of parse
795 *              tree. Close out any parameter lists and complete the opcode.
796 *
797 ******************************************************************************/
798
799static ACPI_STATUS
800AcpiDmAscendingOp (
801    ACPI_PARSE_OBJECT       *Op,
802    UINT32                  Level,
803    void                    *Context)
804{
805    ACPI_OP_WALK_INFO       *Info = Context;
806    ACPI_PARSE_OBJECT       *ParentOp;
807
808
809    if (Op->Common.DisasmFlags & ACPI_PARSEOP_IGNORE)
810    {
811        /* Ignore this op -- it was handled elsewhere */
812
813        return (AE_OK);
814    }
815
816    if ((Level == 0) && (Op->Common.AmlOpcode == AML_SCOPE_OP))
817    {
818        /* Indicates the end of the current descriptor block (table) */
819
820        AcpiOsPrintf ("}\n\n");
821        return (AE_OK);
822    }
823
824    switch (AcpiDmBlockType (Op))
825    {
826    case BLOCK_PAREN:
827
828        /* Completed an op that has arguments, add closing paren */
829
830        AcpiOsPrintf (")");
831
832        if (Op->Common.AmlOpcode == AML_NAME_OP)
833        {
834            /* Emit description comment for Name() with a predefined ACPI name */
835
836            AcpiDmPredefinedDescription (Op);
837        }
838        else
839        {
840            /* For Create* operators, attempt to emit resource tag description */
841
842            AcpiDmFieldPredefinedDescription (Op);
843        }
844
845        /* Could be a nested operator, check if comma required */
846
847        if (!AcpiDmCommaIfListMember (Op))
848        {
849            if ((AcpiDmBlockType (Op->Common.Parent) & BLOCK_BRACE) &&
850                     (!(Op->Common.DisasmFlags & ACPI_PARSEOP_PARAMLIST)) &&
851                     (Op->Common.AmlOpcode != AML_INT_BYTELIST_OP))
852            {
853                /*
854                 * This is a first-level element of a term list
855                 * start a new line
856                 */
857                if (!(Info->Flags & ACPI_PARSEOP_PARAMLIST))
858                {
859                    AcpiOsPrintf ("\n");
860                }
861            }
862        }
863        break;
864
865    case BLOCK_BRACE:
866    case (BLOCK_BRACE | BLOCK_PAREN):
867
868        /* Completed an op that has a term list, add closing brace */
869
870        if (Op->Common.DisasmFlags & ACPI_PARSEOP_EMPTY_TERMLIST)
871        {
872            AcpiOsPrintf ("}");
873        }
874        else
875        {
876            AcpiDmIndent (Level);
877            AcpiOsPrintf ("}");
878        }
879
880        AcpiDmCommaIfListMember (Op);
881
882        if (AcpiDmBlockType (Op->Common.Parent) != BLOCK_PAREN)
883        {
884            AcpiOsPrintf ("\n");
885            if (!(Op->Common.DisasmFlags & ACPI_PARSEOP_EMPTY_TERMLIST))
886            {
887                if ((Op->Common.AmlOpcode == AML_IF_OP)  &&
888                    (Op->Common.Next) &&
889                    (Op->Common.Next->Common.AmlOpcode == AML_ELSE_OP))
890                {
891                    break;
892                }
893
894                if ((AcpiDmBlockType (Op->Common.Parent) & BLOCK_BRACE) &&
895                    (!Op->Common.Next))
896                {
897                    break;
898                }
899                AcpiOsPrintf ("\n");
900            }
901        }
902        break;
903
904    case BLOCK_NONE:
905    default:
906
907        /* Could be a nested operator, check if comma required */
908
909        if (!AcpiDmCommaIfListMember (Op))
910        {
911            if ((AcpiDmBlockType (Op->Common.Parent) & BLOCK_BRACE) &&
912                     (!(Op->Common.DisasmFlags & ACPI_PARSEOP_PARAMLIST)) &&
913                     (Op->Common.AmlOpcode != AML_INT_BYTELIST_OP))
914            {
915                /*
916                 * This is a first-level element of a term list
917                 * start a new line
918                 */
919                AcpiOsPrintf ("\n");
920            }
921        }
922        else if (Op->Common.Parent)
923        {
924            switch (Op->Common.Parent->Common.AmlOpcode)
925            {
926            case AML_PACKAGE_OP:
927            case AML_VAR_PACKAGE_OP:
928
929                if (!(Op->Common.DisasmFlags & ACPI_PARSEOP_PARAMLIST))
930                {
931                    AcpiOsPrintf ("\n");
932                }
933                break;
934
935            default:
936
937                break;
938            }
939        }
940        break;
941    }
942
943    if (Op->Common.DisasmFlags & ACPI_PARSEOP_PARAMLIST)
944    {
945        if ((Op->Common.Next) &&
946            (Op->Common.Next->Common.DisasmFlags & ACPI_PARSEOP_PARAMLIST))
947        {
948            return (AE_OK);
949        }
950
951        /*
952         * Just completed a parameter node for something like "Buffer (param)".
953         * Close the paren and open up the term list block with a brace
954         */
955        if (Op->Common.Next)
956        {
957            AcpiOsPrintf (")");
958
959            /* Emit description comment for Name() with a predefined ACPI name */
960
961            ParentOp = Op->Common.Parent;
962            if (ParentOp)
963            {
964                ParentOp = ParentOp->Common.Parent;
965                if (ParentOp && ParentOp->Asl.AmlOpcode == AML_NAME_OP)
966                {
967                    AcpiDmPredefinedDescription (ParentOp);
968                }
969            }
970            AcpiOsPrintf ("\n");
971            AcpiDmIndent (Level - 1);
972            AcpiOsPrintf ("{\n");
973        }
974        else
975        {
976            Op->Common.Parent->Common.DisasmFlags |=
977                                    ACPI_PARSEOP_EMPTY_TERMLIST;
978            AcpiOsPrintf (") {");
979        }
980    }
981
982    if ((Op->Common.AmlOpcode == AML_NAME_OP) ||
983        (Op->Common.AmlOpcode == AML_RETURN_OP))
984    {
985        Info->Level++;
986    }
987    return (AE_OK);
988}
989
990
991#endif  /* ACPI_DISASSEMBLER */
992