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

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