dmwalk.c revision 241973 
1/*******************************************************************************
2 *
3 * Module Name: dmwalk - AML disassembly tree walk
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
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            AcpiDmIndent (Level);
445            Info->LastLevel = Level;
446            Info->Count = 0;
447    }
448
449    /*
450     * This is an inexpensive mechanism to try and keep lines from getting
451     * too long. When the limit is hit, start a new line at the previous
452     * indent plus one. A better but more expensive mechanism would be to
453     * keep track of the current column.
454     */
455    Info->Count++;
456    if (Info->Count /* +Info->LastLevel */ > 10)
457    {
458        Info->Count = 0;
459        AcpiOsPrintf ("\n");
460        AcpiDmIndent (Info->LastLevel + 1);
461    }
462
463    /* Print the opcode name */
464
465    AcpiDmDisassembleOneOp (NULL, Info, Op);
466
467    if ((Op->Common.DisasmOpcode == ACPI_DASM_LNOT_PREFIX) ||
468        (Op->Common.AmlOpcode == AML_INT_CONNECTION_OP))
469    {
470        return (AE_OK);
471    }
472
473    if ((Op->Common.AmlOpcode == AML_NAME_OP) ||
474        (Op->Common.AmlOpcode == AML_RETURN_OP))
475    {
476        Info->Level--;
477    }
478
479    /* Start the opcode argument list if necessary */
480
481    OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
482
483    if ((OpInfo->Flags & AML_HAS_ARGS) ||
484        (Op->Common.AmlOpcode == AML_EVENT_OP))
485    {
486        /* This opcode has an argument list */
487
488        if (AcpiDmBlockType (Op) & BLOCK_PAREN)
489        {
490            AcpiOsPrintf (" (");
491        }
492
493        /* If this is a named opcode, print the associated name value */
494
495        if (OpInfo->Flags & AML_NAMED)
496        {
497            switch (Op->Common.AmlOpcode)
498            {
499            case AML_ALIAS_OP:
500
501                NextOp = AcpiPsGetDepthNext (NULL, Op);
502                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
503                AcpiDmNamestring (NextOp->Common.Value.Name);
504                AcpiOsPrintf (", ");
505
506                /*lint -fallthrough */
507
508            default:
509
510                Name = AcpiPsGetName (Op);
511                if (Op->Named.Path)
512                {
513                    AcpiDmNamestring ((char *) Op->Named.Path);
514                }
515                else
516                {
517                    AcpiDmDumpName (Name);
518                }
519
520                if (Op->Common.AmlOpcode != AML_INT_NAMEDFIELD_OP)
521                {
522                    if (AcpiGbl_DbOpt_verbose)
523                    {
524                        (void) AcpiPsDisplayObjectPathname (NULL, Op);
525                    }
526                }
527                break;
528            }
529
530            switch (Op->Common.AmlOpcode)
531            {
532            case AML_METHOD_OP:
533
534                AcpiDmMethodFlags (Op);
535                AcpiOsPrintf (")");
536
537                /* Emit description comment for Method() with a predefined ACPI name */
538
539                AcpiDmPredefinedDescription (Op);
540                break;
541
542
543            case AML_NAME_OP:
544
545                /* Check for _HID and related EISAID() */
546
547                AcpiDmIsEisaId (Op);
548                AcpiOsPrintf (", ");
549                break;
550
551
552            case AML_REGION_OP:
553
554                AcpiDmRegionFlags (Op);
555                break;
556
557
558            case AML_POWER_RES_OP:
559
560                /* Mark the next two Ops as part of the parameter list */
561
562                AcpiOsPrintf (", ");
563                NextOp = AcpiPsGetDepthNext (NULL, Op);
564                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMLIST;
565
566                NextOp = NextOp->Common.Next;
567                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMLIST;
568                return (AE_OK);
569
570
571            case AML_PROCESSOR_OP:
572
573                /* Mark the next three Ops as part of the parameter list */
574
575                AcpiOsPrintf (", ");
576                NextOp = AcpiPsGetDepthNext (NULL, Op);
577                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMLIST;
578
579                NextOp = NextOp->Common.Next;
580                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMLIST;
581
582                NextOp = NextOp->Common.Next;
583                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMLIST;
584                return (AE_OK);
585
586
587            case AML_MUTEX_OP:
588            case AML_DATA_REGION_OP:
589
590                AcpiOsPrintf (", ");
591                return (AE_OK);
592
593
594            case AML_EVENT_OP:
595            case AML_ALIAS_OP:
596
597                return (AE_OK);
598
599
600            case AML_SCOPE_OP:
601            case AML_DEVICE_OP:
602            case AML_THERMAL_ZONE_OP:
603
604                AcpiOsPrintf (")");
605                break;
606
607
608            default:
609
610                AcpiOsPrintf ("*** Unhandled named opcode %X\n",
611                    Op->Common.AmlOpcode);
612                break;
613            }
614        }
615
616        else switch (Op->Common.AmlOpcode)
617        {
618        case AML_FIELD_OP:
619        case AML_BANK_FIELD_OP:
620        case AML_INDEX_FIELD_OP:
621
622            Info->BitOffset = 0;
623
624            /* Name of the parent OperationRegion */
625
626            NextOp = AcpiPsGetDepthNext (NULL, Op);
627            AcpiDmNamestring (NextOp->Common.Value.Name);
628            AcpiOsPrintf (", ");
629            NextOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
630
631            switch (Op->Common.AmlOpcode)
632            {
633            case AML_BANK_FIELD_OP:
634
635                /* Namestring - Bank Name */
636
637                NextOp = AcpiPsGetDepthNext (NULL, NextOp);
638                AcpiDmNamestring (NextOp->Common.Value.Name);
639                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
640                AcpiOsPrintf (", ");
641
642                /*
643                 * Bank Value. This is a TermArg in the middle of the parameter
644                 * list, must handle it here.
645                 *
646                 * Disassemble the TermArg parse tree. ACPI_PARSEOP_PARAMLIST
647                 * eliminates newline in the output.
648                 */
649                NextOp = NextOp->Common.Next;
650
651                Info->Flags = ACPI_PARSEOP_PARAMLIST;
652                AcpiDmWalkParseTree (NextOp, AcpiDmDescendingOp,
653                    AcpiDmAscendingOp, Info);
654                Info->Flags = 0;
655                Info->Level = Level;
656
657                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
658                AcpiOsPrintf (", ");
659                break;
660
661            case AML_INDEX_FIELD_OP:
662
663                /* Namestring - Data Name */
664
665                NextOp = AcpiPsGetDepthNext (NULL, NextOp);
666                AcpiDmNamestring (NextOp->Common.Value.Name);
667                AcpiOsPrintf (", ");
668                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
669                break;
670
671            default:
672
673                break;
674            }
675
676            AcpiDmFieldFlags (NextOp);
677            break;
678
679
680        case AML_BUFFER_OP:
681
682            /* The next op is the size parameter */
683
684            NextOp = AcpiPsGetDepthNext (NULL, Op);
685            if (!NextOp)
686            {
687                /* Single-step support */
688
689                return (AE_OK);
690            }
691
692            if (Op->Common.DisasmOpcode == ACPI_DASM_RESOURCE)
693            {
694                /*
695                 * We have a resource list. Don't need to output
696                 * the buffer size Op. Open up a new block
697                 */
698                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
699                NextOp = NextOp->Common.Next;
700                AcpiOsPrintf (")");
701
702                /* Emit description comment for Name() with a predefined ACPI name */
703
704                AcpiDmPredefinedDescription (Op->Asl.Parent);
705
706                AcpiOsPrintf ("\n");
707                AcpiDmIndent (Info->Level);
708                AcpiOsPrintf ("{\n");
709                return (AE_OK);
710            }
711
712            /* Normal Buffer, mark size as in the parameter list */
713
714            NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMLIST;
715            return (AE_OK);
716
717
718        case AML_VAR_PACKAGE_OP:
719        case AML_IF_OP:
720        case AML_WHILE_OP:
721
722            /* The next op is the size or predicate parameter */
723
724            NextOp = AcpiPsGetDepthNext (NULL, Op);
725            if (NextOp)
726            {
727                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMLIST;
728            }
729            return (AE_OK);
730
731
732        case AML_PACKAGE_OP:
733
734            /* The next op is the size parameter */
735
736            NextOp = AcpiPsGetDepthNext (NULL, Op);
737            if (NextOp)
738            {
739                NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMLIST;
740            }
741            return (AE_OK);
742
743
744        case AML_MATCH_OP:
745
746            AcpiDmMatchOp (Op);
747            break;
748
749
750        default:
751
752            break;
753        }
754
755        if (AcpiDmBlockType (Op) & BLOCK_BRACE)
756        {
757            AcpiOsPrintf ("\n");
758            AcpiDmIndent (Level);
759            AcpiOsPrintf ("{\n");
760        }
761    }
762
763    return (AE_OK);
764}
765
766
767/*******************************************************************************
768 *
769 * FUNCTION:    AcpiDmAscendingOp
770 *
771 * PARAMETERS:  ASL_WALK_CALLBACK
772 *
773 * RETURN:      Status
774 *
775 * DESCRIPTION: Second visitation of a parse object, during ascent of parse
776 *              tree. Close out any parameter lists and complete the opcode.
777 *
778 ******************************************************************************/
779
780static ACPI_STATUS
781AcpiDmAscendingOp (
782    ACPI_PARSE_OBJECT       *Op,
783    UINT32                  Level,
784    void                    *Context)
785{
786    ACPI_OP_WALK_INFO       *Info = Context;
787    ACPI_PARSE_OBJECT       *ParentOp;
788
789
790    if (Op->Common.DisasmFlags & ACPI_PARSEOP_IGNORE)
791    {
792        /* Ignore this op -- it was handled elsewhere */
793
794        return (AE_OK);
795    }
796
797    if ((Level == 0) && (Op->Common.AmlOpcode == AML_SCOPE_OP))
798    {
799        /* Indicates the end of the current descriptor block (table) */
800
801        AcpiOsPrintf ("}\n\n");
802        return (AE_OK);
803    }
804
805    switch (AcpiDmBlockType (Op))
806    {
807    case BLOCK_PAREN:
808
809        /* Completed an op that has arguments, add closing paren */
810
811        AcpiOsPrintf (")");
812
813        if (Op->Common.AmlOpcode == AML_NAME_OP)
814        {
815            /* Emit description comment for Name() with a predefined ACPI name */
816
817            AcpiDmPredefinedDescription (Op);
818        }
819        else
820        {
821            /* For Create* operators, attempt to emit resource tag description */
822
823            AcpiDmFieldPredefinedDescription (Op);
824        }
825
826        /* Could be a nested operator, check if comma required */
827
828        if (!AcpiDmCommaIfListMember (Op))
829        {
830            if ((AcpiDmBlockType (Op->Common.Parent) & BLOCK_BRACE) &&
831                     (!(Op->Common.DisasmFlags & ACPI_PARSEOP_PARAMLIST)) &&
832                     (Op->Common.AmlOpcode != AML_INT_BYTELIST_OP))
833            {
834                /*
835                 * This is a first-level element of a term list
836                 * start a new line
837                 */
838                if (!(Info->Flags & ACPI_PARSEOP_PARAMLIST))
839                {
840                    AcpiOsPrintf ("\n");
841                }
842            }
843        }
844        break;
845
846
847    case BLOCK_BRACE:
848    case (BLOCK_BRACE | BLOCK_PAREN):
849
850        /* Completed an op that has a term list, add closing brace */
851
852        if (Op->Common.DisasmFlags & ACPI_PARSEOP_EMPTY_TERMLIST)
853        {
854            AcpiOsPrintf ("}");
855        }
856        else
857        {
858            AcpiDmIndent (Level);
859            AcpiOsPrintf ("}");
860        }
861
862        AcpiDmCommaIfListMember (Op);
863
864        if (AcpiDmBlockType (Op->Common.Parent) != BLOCK_PAREN)
865        {
866            AcpiOsPrintf ("\n");
867            if (!(Op->Common.DisasmFlags & ACPI_PARSEOP_EMPTY_TERMLIST))
868            {
869                if ((Op->Common.AmlOpcode == AML_IF_OP)  &&
870                    (Op->Common.Next) &&
871                    (Op->Common.Next->Common.AmlOpcode == AML_ELSE_OP))
872                {
873                    break;
874                }
875
876                if ((AcpiDmBlockType (Op->Common.Parent) & BLOCK_BRACE) &&
877                    (!Op->Common.Next))
878                {
879                    break;
880                }
881                AcpiOsPrintf ("\n");
882            }
883        }
884        break;
885
886
887    case BLOCK_NONE:
888    default:
889
890        /* Could be a nested operator, check if comma required */
891
892        if (!AcpiDmCommaIfListMember (Op))
893        {
894            if ((AcpiDmBlockType (Op->Common.Parent) & BLOCK_BRACE) &&
895                     (!(Op->Common.DisasmFlags & ACPI_PARSEOP_PARAMLIST)) &&
896                     (Op->Common.AmlOpcode != AML_INT_BYTELIST_OP))
897            {
898                /*
899                 * This is a first-level element of a term list
900                 * start a new line
901                 */
902                AcpiOsPrintf ("\n");
903            }
904        }
905        else if (Op->Common.Parent)
906        {
907            switch (Op->Common.Parent->Common.AmlOpcode)
908            {
909            case AML_PACKAGE_OP:
910            case AML_VAR_PACKAGE_OP:
911
912                if (!(Op->Common.DisasmFlags & ACPI_PARSEOP_PARAMLIST))
913                {
914                    AcpiOsPrintf ("\n");
915                }
916                break;
917
918            default:
919
920                break;
921            }
922        }
923        break;
924    }
925
926    if (Op->Common.DisasmFlags & ACPI_PARSEOP_PARAMLIST)
927    {
928        if ((Op->Common.Next) &&
929            (Op->Common.Next->Common.DisasmFlags & ACPI_PARSEOP_PARAMLIST))
930        {
931            return (AE_OK);
932        }
933
934        /*
935         * Just completed a parameter node for something like "Buffer (param)".
936         * Close the paren and open up the term list block with a brace
937         */
938        if (Op->Common.Next)
939        {
940            AcpiOsPrintf (")");
941
942            /* Emit description comment for Name() with a predefined ACPI name */
943
944            ParentOp = Op->Common.Parent;
945            if (ParentOp)
946            {
947                ParentOp = ParentOp->Common.Parent;
948                if (ParentOp && ParentOp->Asl.AmlOpcode == AML_NAME_OP)
949                {
950                    AcpiDmPredefinedDescription (ParentOp);
951                }
952            }
953            AcpiOsPrintf ("\n");
954            AcpiDmIndent (Level - 1);
955            AcpiOsPrintf ("{\n");
956        }
957        else
958        {
959            Op->Common.Parent->Common.DisasmFlags |=
960                                    ACPI_PARSEOP_EMPTY_TERMLIST;
961            AcpiOsPrintf (") {");
962        }
963    }
964
965    if ((Op->Common.AmlOpcode == AML_NAME_OP) ||
966        (Op->Common.AmlOpcode == AML_RETURN_OP))
967    {
968        Info->Level++;
969    }
970    return (AE_OK);
971}
972
973
974#endif  /* ACPI_DISASSEMBLER */
975