sys/contrib/dev/acpica/components/disassembler/dmwalk.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: dmwalk - AML disassembly tree walk
   4  *
   5  ******************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2017, Intel Corp.
  12  * All rights reserved.
  13  *
  14  * 2. License
  15  *
  16  * 2.1. This is your license from Intel Corp. under its intellectual property
  17  * rights. You may have additional license terms from the party that provided
  18  * you this software, covering your right to use that party's intellectual
  19  * property rights.
  20  *
  21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22  * copy of the source code appearing in this file ("Covered Code") an
  23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25  * make derivatives, distribute, use and display any portion of the Covered
  26  * Code in any form, with the right to sublicense such rights; and
  27  *
  28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29  * license (with the right to sublicense), under only those claims of Intel
  30  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31  * offer to sell, and import the Covered Code and derivative works thereof
  32  * solely to the minimum extent necessary to exercise the above copyright
  33  * license, and in no event shall the patent license extend to any additions
  34  * to or modifications of the Original Intel Code. No other license or right
  35  * is granted directly or by implication, estoppel or otherwise;
  36  *
  37  * The above copyright and patent license is granted only if the following
  38  * conditions are met:
  39  *
  40  * 3. Conditions
  41  *
  42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43  * Redistribution of source code of any substantial portion of the Covered
  44  * Code or modification with rights to further distribute source must include
  45  * the above Copyright Notice, the above License, this list of Conditions,
  46  * and the following Disclaimer and Export Compliance provision. In addition,
  47  * Licensee must cause all Covered Code to which Licensee contributes to
  48  * contain a file documenting the changes Licensee made to create that Covered
  49  * Code and the date of any change. Licensee must include in that file the
  50  * documentation of any changes made by any predecessor Licensee. Licensee
  51  * must include a prominent statement that the modification is derived,
  52  * directly or indirectly, from Original Intel Code.
  53  *
  54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55  * Redistribution of source code of any substantial portion of the Covered
  56  * Code or modification without rights to further distribute source must
  57  * include the following Disclaimer and Export Compliance provision in the
  58  * documentation and/or other materials provided with distribution. In
  59  * addition, Licensee may not authorize further sublicense of source of any
  60  * portion of the Covered Code, and must include terms to the effect that the
  61  * license from Licensee to its licensee is limited to the intellectual
  62  * property embodied in the software Licensee provides to its licensee, and
  63  * not to intellectual property embodied in modifications its licensee may
  64  * make.
  65  *
  66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67  * substantial portion of the Covered Code or modification must reproduce the
  68  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69  * provision in the documentation and/or other materials provided with the
  70  * distribution.
  71  *
  72  * 3.4. Intel retains all right, title, and interest in and to the Original
  73  * Intel Code.
  74  *
  75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77  * other dealings in products derived from or relating to the Covered Code
  78  * without prior written authorization from Intel.
  79  *
  80  * 4. Disclaimer and Export Compliance
  81  *
  82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
  85  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
  86  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.
  89  *
  90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
  96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97  * LIMITED REMEDY.
  98  *
  99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 100  * software or system incorporating such software without first obtaining any
 101  * required license or other approval from the U. S. Department of Commerce or
 102  * any other agency or department of the United States Government. In the
 103  * event Licensee exports any such software from the United States or
 104  * re-exports any such software from a foreign destination, Licensee shall
 105  * ensure that the distribution and export/re-export of the software is in
 106  * compliance with all laws, regulations, orders, or other restrictions of the
 107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 108  * any of its subsidiaries will export/re-export any technical data, process,
 109  * software, or service, directly or indirectly, to any country for which the
 110  * United States government or any agency thereof requires an export license,
 111  * other governmental approval, or letter of assurance, without first obtaining
 112  * such license, approval or letter.
 113  *
 114  *****************************************************************************
 115  *
 116  * Alternatively, you may choose to be licensed under the terms of the
 117  * following license:
 118  *
 119  * Redistribution and use in source and binary forms, with or without
 120  * modification, are permitted provided that the following conditions
 121  * are met:
 122  * 1. Redistributions of source code must retain the above copyright
 123  *    notice, this list of conditions, and the following disclaimer,
 124  *    without modification.
 125  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 126  *    substantially similar to the "NO WARRANTY" disclaimer below
 127  *    ("Disclaimer") and any redistribution must be conditioned upon
 128  *    including a substantially similar Disclaimer requirement for further
 129  *    binary redistribution.
 130  * 3. Neither the names of the above-listed copyright holders nor the names
 131  *    of any contributors may be used to endorse or promote products derived
 132  *    from this software without specific prior written permission.
 133  *
 134  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 135  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 136  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 137  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 138  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 139  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 140  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 141  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 142  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 143  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 144  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 145  *
 146  * Alternatively, you may choose to be licensed under the terms of the
 147  * GNU General Public License ("GPL") version 2 as published by the Free
 148  * Software Foundation.
 149  *
 150  *****************************************************************************/
 151
 152 #include <contrib/dev/acpica/include/acpi.h>
 153 #include <contrib/dev/acpica/include/accommon.h>
 154 #include <contrib/dev/acpica/include/acparser.h>
 155 #include <contrib/dev/acpica/include/amlcode.h>
 156 #include <contrib/dev/acpica/include/acdebug.h>
 157 #include <contrib/dev/acpica/include/acconvert.h>
 158
 159
 160 #define _COMPONENT          ACPI_CA_DEBUGGER
 161         ACPI_MODULE_NAME    ("dmwalk")
 162
 163
 164 #define DB_FULL_OP_INFO     "[%4.4s] @%5.5X #%4.4X:  "
 165
 166 /* Stub for non-compiler code */
 167
 168 #ifndef ACPI_ASL_COMPILER
 169 void
 170 AcpiDmEmitExternals (
 171     void)
 172 {
 173     return;
 174 }
 175
 176 void
 177 AcpiDmEmitExternal (
 178     ACPI_PARSE_OBJECT       *NameOp,
 179     ACPI_PARSE_OBJECT       *TypeOp)
 180 {
 181     return;
 182 }
 183 #endif
 184
 185 /* Local prototypes */
 186
 187 static ACPI_STATUS
 188 AcpiDmDescendingOp (
 189     ACPI_PARSE_OBJECT       *Op,
 190     UINT32                  Level,
 191     void                    *Context);
 192
 193 static ACPI_STATUS
 194 AcpiDmAscendingOp (
 195     ACPI_PARSE_OBJECT       *Op,
 196     UINT32                  Level,
 197     void                    *Context);
 198
 199
 200 /*******************************************************************************
 201  *
 202  * FUNCTION:    AcpiDmDisassemble
 203  *
 204  * PARAMETERS:  WalkState       - Current state
 205  *              Origin          - Starting object
 206  *              NumOpcodes      - Max number of opcodes to be displayed
 207  *
 208  * RETURN:      None
 209  *
 210  * DESCRIPTION: Disassemble parser object and its children. This is the
 211  *              main entry point of the disassembler.
 212  *
 213  ******************************************************************************/
 214
 215 void
 216 AcpiDmDisassemble (
 217     ACPI_WALK_STATE         *WalkState,
 218     ACPI_PARSE_OBJECT       *Origin,
 219     UINT32                  NumOpcodes)
 220 {
 221     ACPI_PARSE_OBJECT       *Op = Origin;
 222     ACPI_OP_WALK_INFO       Info;
 223
 224
 225     if (!Op)
 226     {
 227         return;
 228     }
 229
 230     memset (&Info, 0, sizeof (ACPI_OP_WALK_INFO));
 231     Info.WalkState = WalkState;
 232     Info.StartAml = Op->Common.Aml - sizeof (ACPI_TABLE_HEADER);
 233     Info.AmlOffset = Op->Common.Aml - Info.StartAml;
 234
 235     AcpiDmWalkParseTree (Op, AcpiDmDescendingOp, AcpiDmAscendingOp, &Info);
 236     return;
 237 }
 238
 239
 240 /*******************************************************************************
 241  *
 242  * FUNCTION:    AcpiDmWalkParseTree
 243  *
 244  * PARAMETERS:  Op                      - Root Op object
 245  *              DescendingCallback      - Called during tree descent
 246  *              AscendingCallback       - Called during tree ascent
 247  *              Context                 - To be passed to the callbacks
 248  *
 249  * RETURN:      Status from callback(s)
 250  *
 251  * DESCRIPTION: Walk the entire parse tree.
 252  *
 253  ******************************************************************************/
 254
 255 void
 256 AcpiDmWalkParseTree (
 257     ACPI_PARSE_OBJECT       *Op,
 258     ASL_WALK_CALLBACK       DescendingCallback,
 259     ASL_WALK_CALLBACK       AscendingCallback,
 260     void                    *Context)
 261 {
 262     BOOLEAN                 NodePreviouslyVisited;
 263     ACPI_PARSE_OBJECT       *StartOp = Op;
 264     ACPI_STATUS             Status;
 265     ACPI_PARSE_OBJECT       *Next;
 266     ACPI_OP_WALK_INFO       *Info = Context;
 267
 268
 269     Info->Level = 0;
 270     NodePreviouslyVisited = FALSE;
 271
 272     while (Op)
 273     {
 274         if (NodePreviouslyVisited)
 275         {
 276             if (AscendingCallback)
 277             {
 278                 Status = AscendingCallback (Op, Info->Level, Context);
 279                 if (ACPI_FAILURE (Status))
 280                 {
 281                     return;
 282                 }
 283             }
 284         }
 285         else
 286         {
 287             /* Let the callback process the node */
 288
 289             Status = DescendingCallback (Op, Info->Level, Context);
 290             if (ACPI_SUCCESS (Status))
 291             {
 292                 /* Visit children first, once */
 293
 294                 Next = AcpiPsGetArg (Op, 0);
 295                 if (Next)
 296                 {
 297                     Info->Level++;
 298                     Op = Next;
 299                     continue;
 300                 }
 301             }
 302             else if (Status != AE_CTRL_DEPTH)
 303             {
 304                 /* Exit immediately on any error */
 305
 306                 return;
 307             }
 308         }
 309
 310         /* Terminate walk at start op */
 311
 312         if (Op == StartOp)
 313         {
 314             break;
 315         }
 316
 317         /* No more children, re-visit this node */
 318
 319         if (!NodePreviouslyVisited)
 320         {
 321             NodePreviouslyVisited = TRUE;
 322             continue;
 323         }
 324
 325         /* No more children, visit peers */
 326
 327         if (Op->Common.Next)
 328         {
 329             Op = Op->Common.Next;
 330             NodePreviouslyVisited = FALSE;
 331         }
 332         else
 333         {
 334             /* No peers, re-visit parent */
 335
 336             if (Info->Level != 0 )
 337             {
 338                 Info->Level--;
 339             }
 340
 341             Op = Op->Common.Parent;
 342             NodePreviouslyVisited = TRUE;
 343         }
 344     }
 345
 346     /* If we get here, the walk completed with no errors */
 347
 348     return;
 349 }
 350
 351
 352 /*******************************************************************************
 353  *
 354  * FUNCTION:    AcpiDmBlockType
 355  *
 356  * PARAMETERS:  Op              - Object to be examined
 357  *
 358  * RETURN:      BlockType - not a block, parens, braces, or even both.
 359  *
 360  * DESCRIPTION: Type of block for this op (parens or braces)
 361  *
 362  ******************************************************************************/
 363
 364 UINT32
 365 AcpiDmBlockType (
 366     ACPI_PARSE_OBJECT       *Op)
 367 {
 368     const ACPI_OPCODE_INFO  *OpInfo;
 369
 370
 371     if (!Op)
 372     {
 373         return (BLOCK_NONE);
 374     }
 375
 376     switch (Op->Common.AmlOpcode)
 377     {
 378     case AML_ELSE_OP:
 379
 380         return (BLOCK_BRACE);
 381
 382     case AML_METHOD_OP:
 383     case AML_DEVICE_OP:
 384     case AML_SCOPE_OP:
 385     case AML_PROCESSOR_OP:
 386     case AML_POWER_RESOURCE_OP:
 387     case AML_THERMAL_ZONE_OP:
 388     case AML_IF_OP:
 389     case AML_WHILE_OP:
 390     case AML_FIELD_OP:
 391     case AML_INDEX_FIELD_OP:
 392     case AML_BANK_FIELD_OP:
 393
 394         return (BLOCK_PAREN | BLOCK_BRACE);
 395
 396     case AML_BUFFER_OP:
 397
 398         if ((Op->Common.DisasmOpcode == ACPI_DASM_UNICODE) ||
 399             (Op->Common.DisasmOpcode == ACPI_DASM_UUID) ||
 400             (Op->Common.DisasmOpcode == ACPI_DASM_PLD_METHOD))
 401         {
 402             return (BLOCK_NONE);
 403         }
 404
 405         /*lint -fallthrough */
 406
 407     case AML_PACKAGE_OP:
 408     case AML_VARIABLE_PACKAGE_OP:
 409
 410         return (BLOCK_PAREN | BLOCK_BRACE);
 411
 412     case AML_EVENT_OP:
 413
 414         return (BLOCK_PAREN);
 415
 416     case AML_INT_METHODCALL_OP:
 417
 418         if (Op->Common.Parent &&
 419             ((Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
 420              (Op->Common.Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP)))
 421         {
 422             /* This is a reference to a method, not an invocation */
 423
 424             return (BLOCK_NONE);
 425         }
 426
 427         /*lint -fallthrough */
 428
 429     default:
 430
 431         OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
 432         if (OpInfo->Flags & AML_HAS_ARGS)
 433         {
 434             return (BLOCK_PAREN);
 435         }
 436
 437         return (BLOCK_NONE);
 438     }
 439 }
 440
 441
 442 /*******************************************************************************
 443  *
 444  * FUNCTION:    AcpiDmListType
 445  *
 446  * PARAMETERS:  Op              - Object to be examined
 447  *
 448  * RETURN:      ListType - has commas or not.
 449  *
 450  * DESCRIPTION: Type of block for this op (parens or braces)
 451  *
 452  ******************************************************************************/
 453
 454 UINT32
 455 AcpiDmListType (
 456     ACPI_PARSE_OBJECT       *Op)
 457 {
 458     const ACPI_OPCODE_INFO  *OpInfo;
 459
 460
 461     if (!Op)
 462     {
 463         return (BLOCK_NONE);
 464     }
 465
 466     switch (Op->Common.AmlOpcode)
 467     {
 468
 469     case AML_ELSE_OP:
 470     case AML_METHOD_OP:
 471     case AML_DEVICE_OP:
 472     case AML_SCOPE_OP:
 473     case AML_POWER_RESOURCE_OP:
 474     case AML_PROCESSOR_OP:
 475     case AML_THERMAL_ZONE_OP:
 476     case AML_IF_OP:
 477     case AML_WHILE_OP:
 478     case AML_FIELD_OP:
 479     case AML_INDEX_FIELD_OP:
 480     case AML_BANK_FIELD_OP:
 481
 482         return (BLOCK_NONE);
 483
 484     case AML_BUFFER_OP:
 485     case AML_PACKAGE_OP:
 486     case AML_VARIABLE_PACKAGE_OP:
 487
 488         return (BLOCK_COMMA_LIST);
 489
 490     default:
 491
 492         OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
 493         if (OpInfo->Flags & AML_HAS_ARGS)
 494         {
 495             return (BLOCK_COMMA_LIST);
 496         }
 497
 498         return (BLOCK_NONE);
 499     }
 500 }
 501
 502
 503 /*******************************************************************************
 504  *
 505  * FUNCTION:    AcpiDmDescendingOp
 506  *
 507  * PARAMETERS:  ASL_WALK_CALLBACK
 508  *
 509  * RETURN:      Status
 510  *
 511  * DESCRIPTION: First visitation of a parse object during tree descent.
 512  *              Decode opcode name and begin parameter list(s), if any.
 513  *
 514  ******************************************************************************/
 515
 516 static ACPI_STATUS
 517 AcpiDmDescendingOp (
 518     ACPI_PARSE_OBJECT       *Op,
 519     UINT32                  Level,
 520     void                    *Context)
 521 {
 522     ACPI_OP_WALK_INFO       *Info = Context;
 523     const ACPI_OPCODE_INFO  *OpInfo;
 524     UINT32                  Name;
 525     ACPI_PARSE_OBJECT       *NextOp;
 526     ACPI_PARSE_OBJECT       *NextOp2;
 527     UINT32                  AmlOffset;
 528
 529
 530     /* Determine which file this parse node is contained in. */
 531
 532     if (Gbl_CaptureComments)
 533     {
 534         ASL_CV_LABEL_FILENODE (Op);
 535
 536         if (Level != 0 && ASL_CV_FILE_HAS_SWITCHED (Op))
 537         {
 538             ASL_CV_SWITCH_FILES (Level, Op);
 539         }
 540
 541         /* If this parse node has regular comments, print them here. */
 542
 543         ASL_CV_PRINT_ONE_COMMENT (Op, AML_COMMENT_STANDARD, NULL, Level);
 544     }
 545
 546     OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
 547
 548     /* Listing support to dump the AML code after the ASL statement */
 549
 550     if (AcpiGbl_DmOpt_Listing)
 551     {
 552         /* We only care about these classes of objects */
 553
 554         if ((OpInfo->Class == AML_CLASS_NAMED_OBJECT) ||
 555             (OpInfo->Class == AML_CLASS_CONTROL) ||
 556             (OpInfo->Class == AML_CLASS_CREATE) ||
 557             ((OpInfo->Class == AML_CLASS_EXECUTE) && (!Op->Common.Next)))
 558         {
 559             if (AcpiGbl_DmOpt_Listing && Info->PreviousAml)
 560             {
 561                 /* Dump the AML byte code for the previous Op */
 562
 563                 if (Op->Common.Aml > Info->PreviousAml)
 564                 {
 565                     AcpiOsPrintf ("\n");
 566                     AcpiUtDumpBuffer (
 567                         (Info->StartAml + Info->AmlOffset),
 568                         (Op->Common.Aml - Info->PreviousAml),
 569                         DB_BYTE_DISPLAY, Info->AmlOffset);
 570                     AcpiOsPrintf ("\n");
 571                 }
 572
 573                 Info->AmlOffset = (Op->Common.Aml - Info->StartAml);
 574             }
 575
 576             Info->PreviousAml = Op->Common.Aml;
 577         }
 578     }
 579
 580     if (Op->Common.DisasmFlags & ACPI_PARSEOP_IGNORE)
 581     {
 582         /* Ignore this op -- it was handled elsewhere */
 583
 584         return (AE_CTRL_DEPTH);
 585     }
 586
 587     if (AcpiDmIsTempName(Op))
 588     {
 589         /* Ignore compiler generated temporary names */
 590
 591         return (AE_CTRL_DEPTH);
 592     }
 593
 594     if (Op->Common.DisasmOpcode == ACPI_DASM_IGNORE_SINGLE)
 595     {
 596         /* Ignore this op, but not it's children */
 597
 598         return (AE_OK);
 599     }
 600
 601     if (Op->Common.AmlOpcode == AML_IF_OP)
 602     {
 603         NextOp = AcpiPsGetDepthNext (NULL, Op);
 604         if (NextOp)
 605         {
 606             NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMETER_LIST;
 607
 608             /* Don't emit the actual embedded externals unless asked */
 609
 610             if (!AcpiGbl_DmEmitExternalOpcodes)
 611             {
 612                 /*
 613                  * A Zero predicate indicates the possibility of one or more
 614                  * External() opcodes within the If() block.
 615                  */
 616                 if (NextOp->Common.AmlOpcode == AML_ZERO_OP)
 617                 {
 618                     NextOp2 = NextOp->Common.Next;
 619
 620                     if (NextOp2 &&
 621                         (NextOp2->Common.AmlOpcode == AML_EXTERNAL_OP))
 622                     {
 623                         /* Ignore the If 0 block and all children */
 624
 625                         Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
 626                         return (AE_CTRL_DEPTH);
 627                     }
 628                 }
 629             }
 630         }
 631     }
 632
 633     /* Level 0 is at the Definition Block level */
 634
 635     if (Level == 0)
 636     {
 637         /* In verbose mode, print the AML offset, opcode and depth count */
 638
 639         if (Info->WalkState)
 640         {
 641             AmlOffset = (UINT32) ACPI_PTR_DIFF (Op->Common.Aml,
 642                 Info->WalkState->ParserState.AmlStart);
 643             if (AcpiGbl_DmOpt_Verbose)
 644             {
 645                 AcpiOsPrintf (DB_FULL_OP_INFO,
 646                     (Info->WalkState->MethodNode ?
 647                         Info->WalkState->MethodNode->Name.Ascii : "   "),
 648                     AmlOffset, (UINT32) Op->Common.AmlOpcode);
 649             }
 650         }
 651
 652         if (Op->Common.AmlOpcode == AML_SCOPE_OP)
 653         {
 654             /* This is the beginning of the Definition Block */
 655
 656             AcpiOsPrintf ("{\n");
 657
 658             /* Emit all External() declarations here */
 659
 660             if (!AcpiGbl_DmEmitExternalOpcodes)
 661             {
 662                 AcpiDmEmitExternals ();
 663             }
 664
 665             return (AE_OK);
 666         }
 667     }
 668     else if ((AcpiDmBlockType (Op->Common.Parent) & BLOCK_BRACE) &&
 669          (!(Op->Common.DisasmFlags & ACPI_PARSEOP_PARAMETER_LIST)) &&
 670          (!(Op->Common.DisasmFlags & ACPI_PARSEOP_ELSEIF)) &&
 671          (Op->Common.AmlOpcode != AML_INT_BYTELIST_OP))
 672     {
 673         /*
 674          * This is a first-level element of a term list,
 675          * indent a new line
 676          */
 677         switch (Op->Common.AmlOpcode)
 678         {
 679         case AML_NOOP_OP:
 680             /*
 681              * Optionally just ignore this opcode. Some tables use
 682              * NoOp opcodes for "padding" out packages that the BIOS
 683              * changes dynamically. This can leave hundreds or
 684              * thousands of NoOp opcodes that if disassembled,
 685              * cannot be compiled because they are syntactically
 686              * incorrect.
 687              */
 688             if (AcpiGbl_IgnoreNoopOperator)
 689             {
 690                 Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
 691                 return (AE_OK);
 692             }
 693
 694             /* Fallthrough */
 695
 696         default:
 697
 698             AcpiDmIndent (Level);
 699             break;
 700         }
 701
 702         Info->LastLevel = Level;
 703         Info->Count = 0;
 704     }
 705
 706     /*
 707      * This is an inexpensive mechanism to try and keep lines from getting
 708      * too long. When the limit is hit, start a new line at the previous
 709      * indent plus one. A better but more expensive mechanism would be to
 710      * keep track of the current column.
 711      */
 712     Info->Count++;
 713     if (Info->Count /* +Info->LastLevel */ > 12)
 714     {
 715         Info->Count = 0;
 716         AcpiOsPrintf ("\n");
 717         AcpiDmIndent (Info->LastLevel + 1);
 718     }
 719
 720     /* If ASL+ is enabled, check for a C-style operator */
 721
 722     if (AcpiDmCheckForSymbolicOpcode (Op, Info))
 723     {
 724         return (AE_OK);
 725     }
 726
 727     /* Print the opcode name */
 728
 729     AcpiDmDisassembleOneOp (NULL, Info, Op);
 730
 731     if ((Op->Common.DisasmOpcode == ACPI_DASM_LNOT_PREFIX) ||
 732         (Op->Common.AmlOpcode == AML_INT_CONNECTION_OP))
 733     {
 734         return (AE_OK);
 735     }
 736
 737     if ((Op->Common.AmlOpcode == AML_NAME_OP) ||
 738         (Op->Common.AmlOpcode == AML_RETURN_OP))
 739     {
 740         Info->Level--;
 741     }
 742
 743     if (Op->Common.AmlOpcode == AML_EXTERNAL_OP)
 744     {
 745         Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
 746         return (AE_CTRL_DEPTH);
 747     }
 748
 749     /* Start the opcode argument list if necessary */
 750
 751     if ((OpInfo->Flags & AML_HAS_ARGS) ||
 752         (Op->Common.AmlOpcode == AML_EVENT_OP))
 753     {
 754         /* This opcode has an argument list */
 755
 756         if (AcpiDmBlockType (Op) & BLOCK_PAREN)
 757         {
 758             AcpiOsPrintf (" (");
 759             if (!(AcpiDmBlockType (Op) & BLOCK_BRACE))
 760             {
 761                 ASL_CV_PRINT_ONE_COMMENT (Op, AMLCOMMENT_INLINE, " ", 0);
 762             }
 763         }
 764
 765         /* If this is a named opcode, print the associated name value */
 766
 767         if (OpInfo->Flags & AML_NAMED)
 768         {
 769             switch (Op->Common.AmlOpcode)
 770             {
 771             case AML_ALIAS_OP:
 772
 773                 NextOp = AcpiPsGetDepthNext (NULL, Op);
 774                 NextOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
 775                 AcpiDmNamestring (NextOp->Common.Value.Name);
 776                 AcpiOsPrintf (", ");
 777
 778                 /*lint -fallthrough */
 779
 780             default:
 781
 782                 Name = AcpiPsGetName (Op);
 783                 if (Op->Named.Path)
 784                 {
 785                     AcpiDmNamestring ((char *) Op->Named.Path);
 786                 }
 787                 else
 788                 {
 789                     AcpiDmDumpName (Name);
 790                 }
 791
 792                 if (Op->Common.AmlOpcode != AML_INT_NAMEDFIELD_OP)
 793                 {
 794                     if (AcpiGbl_DmOpt_Verbose)
 795                     {
 796                         (void) AcpiPsDisplayObjectPathname (NULL, Op);
 797                     }
 798                 }
 799                 break;
 800             }
 801
 802             switch (Op->Common.AmlOpcode)
 803             {
 804             case AML_METHOD_OP:
 805
 806                 AcpiDmMethodFlags (Op);
 807                 ASL_CV_CLOSE_PAREN (Op, Level);
 808
 809                 /* Emit description comment for Method() with a predefined ACPI name */
 810
 811                 AcpiDmPredefinedDescription (Op);
 812                 break;
 813
 814             case AML_NAME_OP:
 815
 816                 /* Check for _HID and related EISAID() */
 817
 818                 AcpiDmCheckForHardwareId (Op);
 819                 AcpiOsPrintf (", ");
 820                 ASL_CV_PRINT_ONE_COMMENT (Op, AML_NAMECOMMENT, NULL, 0);
 821                 break;
 822
 823             case AML_REGION_OP:
 824
 825                 AcpiDmRegionFlags (Op);
 826                 break;
 827
 828             case AML_POWER_RESOURCE_OP:
 829
 830                 /* Mark the next two Ops as part of the parameter list */
 831
 832                 AcpiOsPrintf (", ");
 833                 NextOp = AcpiPsGetDepthNext (NULL, Op);
 834                 NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMETER_LIST;
 835
 836                 NextOp = NextOp->Common.Next;
 837                 NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMETER_LIST;
 838                 return (AE_OK);
 839
 840             case AML_PROCESSOR_OP:
 841
 842                 /* Mark the next three Ops as part of the parameter list */
 843
 844                 AcpiOsPrintf (", ");
 845                 NextOp = AcpiPsGetDepthNext (NULL, Op);
 846                 NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMETER_LIST;
 847
 848                 NextOp = NextOp->Common.Next;
 849                 NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMETER_LIST;
 850
 851                 NextOp = NextOp->Common.Next;
 852                 NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMETER_LIST;
 853                 return (AE_OK);
 854
 855             case AML_MUTEX_OP:
 856             case AML_DATA_REGION_OP:
 857
 858                 AcpiOsPrintf (", ");
 859                 return (AE_OK);
 860
 861             case AML_EVENT_OP:
 862             case AML_ALIAS_OP:
 863
 864                 return (AE_OK);
 865
 866             case AML_SCOPE_OP:
 867             case AML_DEVICE_OP:
 868             case AML_THERMAL_ZONE_OP:
 869
 870                 ASL_CV_CLOSE_PAREN (Op, Level);
 871                 break;
 872
 873             default:
 874
 875                 AcpiOsPrintf ("*** Unhandled named opcode %X\n",
 876                     Op->Common.AmlOpcode);
 877                 break;
 878             }
 879         }
 880
 881         else switch (Op->Common.AmlOpcode)
 882         {
 883         case AML_FIELD_OP:
 884         case AML_BANK_FIELD_OP:
 885         case AML_INDEX_FIELD_OP:
 886
 887             Info->BitOffset = 0;
 888
 889             /* Name of the parent OperationRegion */
 890
 891             NextOp = AcpiPsGetDepthNext (NULL, Op);
 892             AcpiDmNamestring (NextOp->Common.Value.Name);
 893             AcpiOsPrintf (", ");
 894             NextOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
 895
 896             switch (Op->Common.AmlOpcode)
 897             {
 898             case AML_BANK_FIELD_OP:
 899
 900                 /* Namestring - Bank Name */
 901
 902                 NextOp = AcpiPsGetDepthNext (NULL, NextOp);
 903                 AcpiDmNamestring (NextOp->Common.Value.Name);
 904                 NextOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
 905                 AcpiOsPrintf (", ");
 906
 907                 /*
 908                  * Bank Value. This is a TermArg in the middle of the parameter
 909                  * list, must handle it here.
 910                  *
 911                  * Disassemble the TermArg parse tree. ACPI_PARSEOP_PARAMETER_LIST
 912                  * eliminates newline in the output.
 913                  */
 914                 NextOp = NextOp->Common.Next;
 915
 916                 Info->Flags = ACPI_PARSEOP_PARAMETER_LIST;
 917                 AcpiDmWalkParseTree (NextOp, AcpiDmDescendingOp,
 918                     AcpiDmAscendingOp, Info);
 919                 Info->Flags = 0;
 920                 Info->Level = Level;
 921
 922                 NextOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
 923                 AcpiOsPrintf (", ");
 924                 break;
 925
 926             case AML_INDEX_FIELD_OP:
 927
 928                 /* Namestring - Data Name */
 929
 930                 NextOp = AcpiPsGetDepthNext (NULL, NextOp);
 931                 AcpiDmNamestring (NextOp->Common.Value.Name);
 932                 AcpiOsPrintf (", ");
 933                 NextOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
 934                 break;
 935
 936             default:
 937
 938                 break;
 939             }
 940
 941             AcpiDmFieldFlags (NextOp);
 942             break;
 943
 944         case AML_BUFFER_OP:
 945
 946             /* The next op is the size parameter */
 947
 948             NextOp = AcpiPsGetDepthNext (NULL, Op);
 949             if (!NextOp)
 950             {
 951                 /* Single-step support */
 952
 953                 return (AE_OK);
 954             }
 955
 956             if (Op->Common.DisasmOpcode == ACPI_DASM_RESOURCE)
 957             {
 958                 /*
 959                  * We have a resource list. Don't need to output
 960                  * the buffer size Op. Open up a new block
 961                  */
 962                 NextOp->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE;
 963                 NextOp = NextOp->Common.Next;
 964                 ASL_CV_CLOSE_PAREN (Op, Level);
 965
 966                 /* Emit description comment for Name() with a predefined ACPI name */
 967
 968                 AcpiDmPredefinedDescription (Op->Asl.Parent);
 969
 970                 AcpiOsPrintf ("\n");
 971                 AcpiDmIndent (Info->Level);
 972                 AcpiOsPrintf ("{\n");
 973                 return (AE_OK);
 974             }
 975
 976             /* Normal Buffer, mark size as in the parameter list */
 977
 978             NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMETER_LIST;
 979             return (AE_OK);
 980
 981         case AML_IF_OP:
 982         case AML_VARIABLE_PACKAGE_OP:
 983         case AML_WHILE_OP:
 984
 985             /* The next op is the size or predicate parameter */
 986
 987             NextOp = AcpiPsGetDepthNext (NULL, Op);
 988             if (NextOp)
 989             {
 990                 NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMETER_LIST;
 991             }
 992             return (AE_OK);
 993
 994         case AML_PACKAGE_OP:
 995
 996             /* The next op is the size parameter */
 997
 998             NextOp = AcpiPsGetDepthNext (NULL, Op);
 999             if (NextOp)
1000             {
1001                 NextOp->Common.DisasmFlags |= ACPI_PARSEOP_PARAMETER_LIST;
1002             }
1003             return (AE_OK);
1004
1005         case AML_MATCH_OP:
1006
1007             AcpiDmMatchOp (Op);
1008             break;
1009
1010         default:
1011
1012             break;
1013         }
1014
1015         if (AcpiDmBlockType (Op) & BLOCK_BRACE)
1016         {
1017             AcpiOsPrintf ("\n");
1018             AcpiDmIndent (Level);
1019             AcpiOsPrintf ("{\n");
1020         }
1021     }
1022
1023     return (AE_OK);
1024 }
1025
1026
1027 /*******************************************************************************
1028  *
1029  * FUNCTION:    AcpiDmAscendingOp
1030  *
1031  * PARAMETERS:  ASL_WALK_CALLBACK
1032  *
1033  * RETURN:      Status
1034  *
1035  * DESCRIPTION: Second visitation of a parse object, during ascent of parse
1036  *              tree. Close out any parameter lists and complete the opcode.
1037  *
1038  ******************************************************************************/
1039
1040 static ACPI_STATUS
1041 AcpiDmAscendingOp (
1042     ACPI_PARSE_OBJECT       *Op,
1043     UINT32                  Level,
1044     void                    *Context)
1045 {
1046     ACPI_OP_WALK_INFO       *Info = Context;
1047     ACPI_PARSE_OBJECT       *ParentOp;
1048
1049
1050     /* Point the Op's filename pointer to the proper file */
1051
1052     if (Gbl_CaptureComments)
1053     {
1054         ASL_CV_LABEL_FILENODE (Op);
1055
1056         /* Switch the output of these files if necessary */
1057
1058         if (ASL_CV_FILE_HAS_SWITCHED (Op))
1059         {
1060             ASL_CV_SWITCH_FILES (Level, Op);
1061         }
1062     }
1063
1064     if (Op->Common.DisasmFlags & ACPI_PARSEOP_IGNORE ||
1065         Op->Common.DisasmOpcode == ACPI_DASM_IGNORE_SINGLE)
1066     {
1067         /* Ignore this op -- it was handled elsewhere */
1068
1069         return (AE_OK);
1070     }
1071
1072     if ((Level == 0) && (Op->Common.AmlOpcode == AML_SCOPE_OP))
1073     {
1074         /* Indicates the end of the current descriptor block (table) */
1075
1076         ASL_CV_CLOSE_BRACE (Op, Level);
1077
1078         /* Print any comments that are at the end of the file here */
1079
1080         if (Gbl_CaptureComments && AcpiGbl_LastListHead)
1081         {
1082             AcpiOsPrintf ("\n");
1083             ASL_CV_PRINT_ONE_COMMENT_LIST (AcpiGbl_LastListHead, 0);
1084         }
1085         AcpiOsPrintf ("\n\n");
1086
1087         return (AE_OK);
1088     }
1089
1090     switch (AcpiDmBlockType (Op))
1091     {
1092     case BLOCK_PAREN:
1093
1094         /* Completed an op that has arguments, add closing paren if needed */
1095
1096         AcpiDmCloseOperator (Op);
1097
1098         if (Op->Common.AmlOpcode == AML_NAME_OP)
1099         {
1100             /* Emit description comment for Name() with a predefined ACPI name */
1101
1102             AcpiDmPredefinedDescription (Op);
1103         }
1104         else
1105         {
1106             /* For Create* operators, attempt to emit resource tag description */
1107
1108             AcpiDmFieldPredefinedDescription (Op);
1109         }
1110
1111         /* Decode Notify() values */
1112
1113         if (Op->Common.AmlOpcode == AML_NOTIFY_OP)
1114         {
1115             AcpiDmNotifyDescription (Op);
1116         }
1117
1118         AcpiDmDisplayTargetPathname (Op);
1119
1120         /* Could be a nested operator, check if comma required */
1121
1122         if (!AcpiDmCommaIfListMember (Op))
1123         {
1124             if ((AcpiDmBlockType (Op->Common.Parent) & BLOCK_BRACE) &&
1125                  (!(Op->Common.DisasmFlags & ACPI_PARSEOP_PARAMETER_LIST)) &&
1126                  (Op->Common.AmlOpcode != AML_INT_BYTELIST_OP))
1127             {
1128                 /*
1129                  * This is a first-level element of a term list
1130                  * start a new line
1131                  */
1132                 if (!(Info->Flags & ACPI_PARSEOP_PARAMETER_LIST))
1133                 {
1134                     AcpiOsPrintf ("\n");
1135                 }
1136             }
1137         }
1138         break;
1139
1140     case BLOCK_BRACE:
1141     case (BLOCK_BRACE | BLOCK_PAREN):
1142
1143         /* Completed an op that has a term list, add closing brace */
1144
1145         if (Op->Common.DisasmFlags & ACPI_PARSEOP_EMPTY_TERMLIST)
1146         {
1147             ASL_CV_CLOSE_BRACE (Op, Level);
1148         }
1149         else
1150         {
1151             AcpiDmIndent (Level);
1152             ASL_CV_CLOSE_BRACE (Op, Level);
1153         }
1154
1155         AcpiDmCommaIfListMember (Op);
1156
1157         if (AcpiDmBlockType (Op->Common.Parent) != BLOCK_PAREN)
1158         {
1159             AcpiOsPrintf ("\n");
1160             if (!(Op->Common.DisasmFlags & ACPI_PARSEOP_EMPTY_TERMLIST))
1161             {
1162                 if ((Op->Common.AmlOpcode == AML_IF_OP)  &&
1163                     (Op->Common.Next) &&
1164                     (Op->Common.Next->Common.AmlOpcode == AML_ELSE_OP))
1165                 {
1166                     break;
1167                 }
1168
1169                 if ((AcpiDmBlockType (Op->Common.Parent) & BLOCK_BRACE) &&
1170                     (!Op->Common.Next))
1171                 {
1172                     break;
1173                 }
1174                 AcpiOsPrintf ("\n");
1175             }
1176         }
1177         break;
1178
1179     case BLOCK_NONE:
1180     default:
1181
1182         /* Could be a nested operator, check if comma required */
1183
1184         if (!AcpiDmCommaIfListMember (Op))
1185         {
1186             if ((AcpiDmBlockType (Op->Common.Parent) & BLOCK_BRACE) &&
1187                  (!(Op->Common.DisasmFlags & ACPI_PARSEOP_PARAMETER_LIST)) &&
1188                  (Op->Common.AmlOpcode != AML_INT_BYTELIST_OP))
1189             {
1190                 /*
1191                  * This is a first-level element of a term list
1192                  * start a new line
1193                  */
1194                 AcpiOsPrintf ("\n");
1195             }
1196         }
1197         else if (Op->Common.Parent)
1198         {
1199             switch (Op->Common.Parent->Common.AmlOpcode)
1200             {
1201             case AML_PACKAGE_OP:
1202             case AML_VARIABLE_PACKAGE_OP:
1203
1204                 if (!(Op->Common.DisasmFlags & ACPI_PARSEOP_PARAMETER_LIST))
1205                 {
1206                     AcpiOsPrintf ("\n");
1207                 }
1208                 break;
1209
1210             default:
1211
1212                 break;
1213             }
1214         }
1215         break;
1216     }
1217
1218     if (Op->Common.DisasmFlags & ACPI_PARSEOP_PARAMETER_LIST)
1219     {
1220         if ((Op->Common.Next) &&
1221             (Op->Common.Next->Common.DisasmFlags & ACPI_PARSEOP_PARAMETER_LIST))
1222         {
1223             return (AE_OK);
1224         }
1225
1226         /*
1227          * The parent Op is guaranteed to be valid because of the flag
1228          * ACPI_PARSEOP_PARAMETER_LIST -- which means that this op is part of
1229          * a parameter list and thus has a valid parent.
1230          */
1231         ParentOp = Op->Common.Parent;
1232
1233         /*
1234          * Just completed a parameter node for something like "Buffer (param)".
1235          * Close the paren and open up the term list block with a brace.
1236          *
1237          * Switch predicates don't have a Next node but require a closing paren
1238          * and opening brace.
1239          */
1240         if (Op->Common.Next || Op->Common.DisasmOpcode == ACPI_DASM_SWITCH_PREDICATE)
1241         {
1242             ASL_CV_CLOSE_PAREN (Op, Level);
1243
1244             /*
1245              * Emit a description comment for a Name() operator that is a
1246              * predefined ACPI name. Must check the grandparent.
1247              */
1248             ParentOp = ParentOp->Common.Parent;
1249             if (ParentOp &&
1250                 (ParentOp->Asl.AmlOpcode == AML_NAME_OP))
1251             {
1252                 AcpiDmPredefinedDescription (ParentOp);
1253             }
1254
1255             /* Correct the indentation level for Switch and Case predicates */
1256
1257             if (Op->Common.DisasmOpcode == ACPI_DASM_SWITCH_PREDICATE)
1258             {
1259                 --Level;
1260             }
1261
1262             AcpiOsPrintf ("\n");
1263             AcpiDmIndent (Level - 1);
1264             AcpiOsPrintf ("{\n");
1265         }
1266         else
1267         {
1268             ParentOp->Common.DisasmFlags |= ACPI_PARSEOP_EMPTY_TERMLIST;
1269             ASL_CV_CLOSE_PAREN (Op, Level);
1270             AcpiOsPrintf ("{");
1271         }
1272     }
1273
1274     if ((Op->Common.AmlOpcode == AML_NAME_OP) ||
1275         (Op->Common.AmlOpcode == AML_RETURN_OP))
1276     {
1277         Info->Level++;
1278     }
1279
1280     /*
1281      * For ASL+, check for and emit a C-style symbol. If valid, the
1282      * symbol string has been deferred until after the first operand
1283      */
1284     if (AcpiGbl_CstyleDisassembly)
1285     {
1286         if (Op->Asl.OperatorSymbol)
1287         {
1288             AcpiOsPrintf ("%s", Op->Asl.OperatorSymbol);
1289             Op->Asl.OperatorSymbol = NULL;
1290         }
1291     }
1292
1293     return (AE_OK);
1294 }