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