1 /******************************************************************************* 2 * 3 * Module Name: dmopcode - AML disassembler, specific AML opcodes 4 * 5 ******************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2012, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 #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/acnamesp.h> 50 51 #ifdef ACPI_DISASSEMBLER 52 53 #define _COMPONENT ACPI_CA_DEBUGGER 54 ACPI_MODULE_NAME ("dmopcode") 55 56 /* Local prototypes */ 57 58 static void 59 AcpiDmMatchKeyword ( 60 ACPI_PARSE_OBJECT *Op); 61 62 63 /******************************************************************************* 64 * 65 * FUNCTION: AcpiDmPredefinedDescription 66 * 67 * PARAMETERS: Op - Name() parse object 68 * 69 * RETURN: None 70 * 71 * DESCRIPTION: Emit a description comment for a predefined ACPI name. 72 * Used for iASL compiler only. 73 * 74 ******************************************************************************/ 75 76 void 77 AcpiDmPredefinedDescription ( 78 ACPI_PARSE_OBJECT *Op) 79 { 80 #ifdef ACPI_ASL_COMPILER 81 const AH_PREDEFINED_NAME *Info; 82 char *NameString; 83 int LastCharIsDigit; 84 int LastCharsAreHex; 85 86 87 if (!Op) 88 { 89 return; 90 } 91 92 /* Ensure that the comment field is emitted only once */ 93 94 if (Op->Common.DisasmFlags & ACPI_PARSEOP_PREDEF_CHECKED) 95 { 96 return; 97 } 98 Op->Common.DisasmFlags |= ACPI_PARSEOP_PREDEF_CHECKED; 99 100 /* Predefined name must start with an underscore */ 101 102 NameString = ACPI_CAST_PTR (char, &Op->Named.Name); 103 if (NameString[0] != '_') 104 { 105 return; 106 } 107 108 /* 109 * Check for the special ACPI names: 110 * _ACd, _ALd, _EJd, _Exx, _Lxx, _Qxx, _Wxx, _T_a 111 * (where d=decimal_digit, x=hex_digit, a=anything) 112 * 113 * Convert these to the generic name for table lookup. 114 * Note: NameString is guaranteed to be upper case here. 115 */ 116 LastCharIsDigit = 117 (ACPI_IS_DIGIT (NameString[3])); /* d */ 118 LastCharsAreHex = 119 (ACPI_IS_XDIGIT (NameString[2]) && /* xx */ 120 ACPI_IS_XDIGIT (NameString[3])); 121 122 switch (NameString[1]) 123 { 124 case 'A': 125 if ((NameString[2] == 'C') && (LastCharIsDigit)) 126 { 127 NameString = "_ACx"; 128 } 129 else if ((NameString[2] == 'L') && (LastCharIsDigit)) 130 { 131 NameString = "_ALx"; 132 } 133 break; 134 135 case 'E': 136 if ((NameString[2] == 'J') && (LastCharIsDigit)) 137 { 138 NameString = "_EJx"; 139 } 140 else if (LastCharsAreHex) 141 { 142 NameString = "_Exx"; 143 } 144 break; 145 146 case 'L': 147 if (LastCharsAreHex) 148 { 149 NameString = "_Lxx"; 150 } 151 break; 152 153 case 'Q': 154 if (LastCharsAreHex) 155 { 156 NameString = "_Qxx"; 157 } 158 break; 159 160 case 'T': 161 if (NameString[2] == '_') 162 { 163 NameString = "_T_x"; 164 } 165 break; 166 167 case 'W': 168 if (LastCharsAreHex) 169 { 170 NameString = "_Wxx"; 171 } 172 break; 173 174 default: 175 break; 176 } 177 178 /* Match the name in the info table */ 179 180 for (Info = AslPredefinedInfo; Info->Name; Info++) 181 { 182 if (ACPI_COMPARE_NAME (NameString, Info->Name)) 183 { 184 AcpiOsPrintf (" // %4.4s: %s", 185 NameString, ACPI_CAST_PTR (char, Info->Description)); 186 return; 187 } 188 } 189 190 #endif 191 return; 192 } 193 194 195 /******************************************************************************* 196 * 197 * FUNCTION: AcpiDmFieldPredefinedDescription 198 * 199 * PARAMETERS: Op - Parse object 200 * 201 * RETURN: None 202 * 203 * DESCRIPTION: Emit a description comment for a resource descriptor tag 204 * (which is a predefined ACPI name.) Used for iASL compiler only. 205 * 206 ******************************************************************************/ 207 208 void 209 AcpiDmFieldPredefinedDescription ( 210 ACPI_PARSE_OBJECT *Op) 211 { 212 #ifdef ACPI_ASL_COMPILER 213 ACPI_PARSE_OBJECT *IndexOp; 214 char *Tag; 215 const ACPI_OPCODE_INFO *OpInfo; 216 const AH_PREDEFINED_NAME *Info; 217 218 219 if (!Op) 220 { 221 return; 222 } 223 224 /* Ensure that the comment field is emitted only once */ 225 226 if (Op->Common.DisasmFlags & ACPI_PARSEOP_PREDEF_CHECKED) 227 { 228 return; 229 } 230 Op->Common.DisasmFlags |= ACPI_PARSEOP_PREDEF_CHECKED; 231 232 /* 233 * Op must be one of the Create* operators: CreateField, CreateBitField, 234 * CreateByteField, CreateWordField, CreateDwordField, CreateQwordField 235 */ 236 OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode); 237 if (!(OpInfo->Flags & AML_CREATE)) 238 { 239 return; 240 } 241 242 /* Second argument is the Index argument */ 243 244 IndexOp = Op->Common.Value.Arg; 245 IndexOp = IndexOp->Common.Next; 246 247 /* Index argument must be a namepath */ 248 249 if (IndexOp->Common.AmlOpcode != AML_INT_NAMEPATH_OP) 250 { 251 return; 252 } 253 254 /* Major cheat: We previously put the Tag ptr in the Node field */ 255 256 Tag = ACPI_CAST_PTR (char, IndexOp->Common.Node); 257 if (!Tag) 258 { 259 return; 260 } 261 262 /* Match the name in the info table */ 263 264 for (Info = AslPredefinedInfo; Info->Name; Info++) 265 { 266 if (ACPI_COMPARE_NAME (Tag, Info->Name)) 267 { 268 AcpiOsPrintf (" // %4.4s: %s", Tag, 269 ACPI_CAST_PTR (char, Info->Description)); 270 return; 271 } 272 } 273 274 #endif 275 return; 276 } 277 278 279 /******************************************************************************* 280 * 281 * FUNCTION: AcpiDmMethodFlags 282 * 283 * PARAMETERS: Op - Method Object to be examined 284 * 285 * RETURN: None 286 * 287 * DESCRIPTION: Decode control method flags 288 * 289 ******************************************************************************/ 290 291 void 292 AcpiDmMethodFlags ( 293 ACPI_PARSE_OBJECT *Op) 294 { 295 UINT32 Flags; 296 UINT32 Args; 297 298 299 /* The next Op contains the flags */ 300 301 Op = AcpiPsGetDepthNext (NULL, Op); 302 Flags = (UINT8) Op->Common.Value.Integer; 303 Args = Flags & 0x07; 304 305 /* Mark the Op as completed */ 306 307 Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE; 308 309 /* 1) Method argument count */ 310 311 AcpiOsPrintf (", %u, ", Args); 312 313 /* 2) Serialize rule */ 314 315 if (!(Flags & 0x08)) 316 { 317 AcpiOsPrintf ("Not"); 318 } 319 320 AcpiOsPrintf ("Serialized"); 321 322 /* 3) SyncLevel */ 323 324 if (Flags & 0xF0) 325 { 326 AcpiOsPrintf (", %u", Flags >> 4); 327 } 328 } 329 330 331 /******************************************************************************* 332 * 333 * FUNCTION: AcpiDmFieldFlags 334 * 335 * PARAMETERS: Op - Field Object to be examined 336 * 337 * RETURN: None 338 * 339 * DESCRIPTION: Decode Field definition flags 340 * 341 ******************************************************************************/ 342 343 void 344 AcpiDmFieldFlags ( 345 ACPI_PARSE_OBJECT *Op) 346 { 347 UINT32 Flags; 348 349 350 Op = Op->Common.Next; 351 Flags = (UINT8) Op->Common.Value.Integer; 352 353 /* Mark the Op as completed */ 354 355 Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE; 356 357 AcpiOsPrintf ("%s, ", AcpiGbl_AccessTypes [Flags & 0x07]); 358 AcpiOsPrintf ("%s, ", AcpiGbl_LockRule [(Flags & 0x10) >> 4]); 359 AcpiOsPrintf ("%s)", AcpiGbl_UpdateRules [(Flags & 0x60) >> 5]); 360 } 361 362 363 /******************************************************************************* 364 * 365 * FUNCTION: AcpiDmAddressSpace 366 * 367 * PARAMETERS: SpaceId - ID to be translated 368 * 369 * RETURN: None 370 * 371 * DESCRIPTION: Decode a SpaceId to an AddressSpaceKeyword 372 * 373 ******************************************************************************/ 374 375 void 376 AcpiDmAddressSpace ( 377 UINT8 SpaceId) 378 { 379 380 if (SpaceId >= ACPI_NUM_PREDEFINED_REGIONS) 381 { 382 if (SpaceId == 0x7F) 383 { 384 AcpiOsPrintf ("FFixedHW, "); 385 } 386 else 387 { 388 AcpiOsPrintf ("0x%.2X, ", SpaceId); 389 } 390 } 391 else 392 { 393 AcpiOsPrintf ("%s, ", AcpiGbl_RegionTypes [SpaceId]); 394 } 395 } 396 397 398 /******************************************************************************* 399 * 400 * FUNCTION: AcpiDmRegionFlags 401 * 402 * PARAMETERS: Op - Object to be examined 403 * 404 * RETURN: None 405 * 406 * DESCRIPTION: Decode OperationRegion flags 407 * 408 ******************************************************************************/ 409 410 void 411 AcpiDmRegionFlags ( 412 ACPI_PARSE_OBJECT *Op) 413 { 414 415 416 /* The next Op contains the SpaceId */ 417 418 Op = AcpiPsGetDepthNext (NULL, Op); 419 420 /* Mark the Op as completed */ 421 422 Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE; 423 424 AcpiOsPrintf (", "); 425 AcpiDmAddressSpace ((UINT8) Op->Common.Value.Integer); 426 } 427 428 429 /******************************************************************************* 430 * 431 * FUNCTION: AcpiDmMatchOp 432 * 433 * PARAMETERS: Op - Match Object to be examined 434 * 435 * RETURN: None 436 * 437 * DESCRIPTION: Decode Match opcode operands 438 * 439 ******************************************************************************/ 440 441 void 442 AcpiDmMatchOp ( 443 ACPI_PARSE_OBJECT *Op) 444 { 445 ACPI_PARSE_OBJECT *NextOp; 446 447 448 NextOp = AcpiPsGetDepthNext (NULL, Op); 449 NextOp = NextOp->Common.Next; 450 451 if (!NextOp) 452 { 453 /* Handle partial tree during single-step */ 454 455 return; 456 } 457 458 /* Mark the two nodes that contain the encoding for the match keywords */ 459 460 NextOp->Common.DisasmOpcode = ACPI_DASM_MATCHOP; 461 462 NextOp = NextOp->Common.Next; 463 NextOp = NextOp->Common.Next; 464 NextOp->Common.DisasmOpcode = ACPI_DASM_MATCHOP; 465 } 466 467 468 /******************************************************************************* 469 * 470 * FUNCTION: AcpiDmMatchKeyword 471 * 472 * PARAMETERS: Op - Match Object to be examined 473 * 474 * RETURN: None 475 * 476 * DESCRIPTION: Decode Match opcode operands 477 * 478 ******************************************************************************/ 479 480 static void 481 AcpiDmMatchKeyword ( 482 ACPI_PARSE_OBJECT *Op) 483 { 484 485 486 if (((UINT32) Op->Common.Value.Integer) > ACPI_MAX_MATCH_OPCODE) 487 { 488 AcpiOsPrintf ("/* Unknown Match Keyword encoding */"); 489 } 490 else 491 { 492 AcpiOsPrintf ("%s", ACPI_CAST_PTR (char, 493 AcpiGbl_MatchOps[(ACPI_SIZE) Op->Common.Value.Integer])); 494 } 495 } 496 497 498 /******************************************************************************* 499 * 500 * FUNCTION: AcpiDmDisassembleOneOp 501 * 502 * PARAMETERS: WalkState - Current walk info 503 * Info - Parse tree walk info 504 * Op - Op that is to be printed 505 * 506 * RETURN: None 507 * 508 * DESCRIPTION: Disassemble a single AML opcode 509 * 510 ******************************************************************************/ 511 512 void 513 AcpiDmDisassembleOneOp ( 514 ACPI_WALK_STATE *WalkState, 515 ACPI_OP_WALK_INFO *Info, 516 ACPI_PARSE_OBJECT *Op) 517 { 518 const ACPI_OPCODE_INFO *OpInfo = NULL; 519 UINT32 Offset; 520 UINT32 Length; 521 ACPI_PARSE_OBJECT *Child; 522 ACPI_STATUS Status; 523 UINT8 *Aml; 524 525 526 if (!Op) 527 { 528 AcpiOsPrintf ("<NULL OP PTR>"); 529 return; 530 } 531 532 switch (Op->Common.DisasmOpcode) 533 { 534 case ACPI_DASM_MATCHOP: 535 536 AcpiDmMatchKeyword (Op); 537 return; 538 539 case ACPI_DASM_LNOT_SUFFIX: 540 switch (Op->Common.AmlOpcode) 541 { 542 case AML_LEQUAL_OP: 543 AcpiOsPrintf ("LNotEqual"); 544 break; 545 546 case AML_LGREATER_OP: 547 AcpiOsPrintf ("LLessEqual"); 548 break; 549 550 case AML_LLESS_OP: 551 AcpiOsPrintf ("LGreaterEqual"); 552 break; 553 554 default: 555 break; 556 } 557 Op->Common.DisasmOpcode = 0; 558 Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE; 559 return; 560 561 default: 562 break; 563 } 564 565 566 OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode); 567 568 /* The op and arguments */ 569 570 switch (Op->Common.AmlOpcode) 571 { 572 case AML_LNOT_OP: 573 574 Child = Op->Common.Value.Arg; 575 if ((Child->Common.AmlOpcode == AML_LEQUAL_OP) || 576 (Child->Common.AmlOpcode == AML_LGREATER_OP) || 577 (Child->Common.AmlOpcode == AML_LLESS_OP)) 578 { 579 Child->Common.DisasmOpcode = ACPI_DASM_LNOT_SUFFIX; 580 Op->Common.DisasmOpcode = ACPI_DASM_LNOT_PREFIX; 581 } 582 else 583 { 584 AcpiOsPrintf ("%s", OpInfo->Name); 585 } 586 break; 587 588 case AML_BYTE_OP: 589 590 AcpiOsPrintf ("0x%2.2X", (UINT32) Op->Common.Value.Integer); 591 break; 592 593 594 case AML_WORD_OP: 595 596 if (Op->Common.DisasmOpcode == ACPI_DASM_EISAID) 597 { 598 AcpiDmEisaId ((UINT32) Op->Common.Value.Integer); 599 } 600 else 601 { 602 AcpiOsPrintf ("0x%4.4X", (UINT32) Op->Common.Value.Integer); 603 } 604 break; 605 606 607 case AML_DWORD_OP: 608 609 if (Op->Common.DisasmOpcode == ACPI_DASM_EISAID) 610 { 611 AcpiDmEisaId ((UINT32) Op->Common.Value.Integer); 612 } 613 else 614 { 615 AcpiOsPrintf ("0x%8.8X", (UINT32) Op->Common.Value.Integer); 616 } 617 break; 618 619 620 case AML_QWORD_OP: 621 622 AcpiOsPrintf ("0x%8.8X%8.8X", 623 ACPI_FORMAT_UINT64 (Op->Common.Value.Integer)); 624 break; 625 626 627 case AML_STRING_OP: 628 629 AcpiUtPrintString (Op->Common.Value.String, ACPI_UINT8_MAX); 630 break; 631 632 633 case AML_BUFFER_OP: 634 635 /* 636 * Determine the type of buffer. We can have one of the following: 637 * 638 * 1) ResourceTemplate containing Resource Descriptors. 639 * 2) Unicode String buffer 640 * 3) ASCII String buffer 641 * 4) Raw data buffer (if none of the above) 642 * 643 * Since there are no special AML opcodes to differentiate these 644 * types of buffers, we have to closely look at the data in the 645 * buffer to determine the type. 646 */ 647 if (!AcpiGbl_NoResourceDisassembly) 648 { 649 Status = AcpiDmIsResourceTemplate (Op); 650 if (ACPI_SUCCESS (Status)) 651 { 652 Op->Common.DisasmOpcode = ACPI_DASM_RESOURCE; 653 AcpiOsPrintf ("ResourceTemplate"); 654 break; 655 } 656 else if (Status == AE_AML_NO_RESOURCE_END_TAG) 657 { 658 AcpiOsPrintf ("/**** Is ResourceTemplate, but EndTag not at buffer end ****/ "); 659 } 660 } 661 662 if (AcpiDmIsUnicodeBuffer (Op)) 663 { 664 Op->Common.DisasmOpcode = ACPI_DASM_UNICODE; 665 AcpiOsPrintf ("Unicode ("); 666 } 667 else if (AcpiDmIsStringBuffer (Op)) 668 { 669 Op->Common.DisasmOpcode = ACPI_DASM_STRING; 670 AcpiOsPrintf ("Buffer"); 671 } 672 else if (AcpiDmIsPldBuffer (Op)) 673 { 674 Op->Common.DisasmOpcode = ACPI_DASM_PLD_METHOD; 675 AcpiOsPrintf ("Buffer"); 676 } 677 else 678 { 679 Op->Common.DisasmOpcode = ACPI_DASM_BUFFER; 680 AcpiOsPrintf ("Buffer"); 681 } 682 break; 683 684 685 case AML_INT_STATICSTRING_OP: 686 687 if (Op->Common.Value.String) 688 { 689 AcpiOsPrintf ("%s", Op->Common.Value.String); 690 } 691 else 692 { 693 AcpiOsPrintf ("\"<NULL STATIC STRING PTR>\""); 694 } 695 break; 696 697 698 case AML_INT_NAMEPATH_OP: 699 700 AcpiDmNamestring (Op->Common.Value.Name); 701 break; 702 703 704 case AML_INT_NAMEDFIELD_OP: 705 706 Length = AcpiDmDumpName (Op->Named.Name); 707 AcpiOsPrintf (",%*.s %u", (unsigned) (5 - Length), " ", 708 (UINT32) Op->Common.Value.Integer); 709 AcpiDmCommaIfFieldMember (Op); 710 711 Info->BitOffset += (UINT32) Op->Common.Value.Integer; 712 break; 713 714 715 case AML_INT_RESERVEDFIELD_OP: 716 717 /* Offset() -- Must account for previous offsets */ 718 719 Offset = (UINT32) Op->Common.Value.Integer; 720 Info->BitOffset += Offset; 721 722 if (Info->BitOffset % 8 == 0) 723 { 724 AcpiOsPrintf ("Offset (0x%.2X)", ACPI_DIV_8 (Info->BitOffset)); 725 } 726 else 727 { 728 AcpiOsPrintf (" , %u", Offset); 729 } 730 731 AcpiDmCommaIfFieldMember (Op); 732 break; 733 734 735 case AML_INT_ACCESSFIELD_OP: 736 case AML_INT_EXTACCESSFIELD_OP: 737 738 AcpiOsPrintf ("AccessAs (%s, ", 739 AcpiGbl_AccessTypes [(UINT32) (Op->Common.Value.Integer & 0x7)]); 740 741 AcpiDmDecodeAttribute ((UINT8) (Op->Common.Value.Integer >> 8)); 742 743 if (Op->Common.AmlOpcode == AML_INT_EXTACCESSFIELD_OP) 744 { 745 AcpiOsPrintf (" (0x%2.2X)", (unsigned) ((Op->Common.Value.Integer >> 16) & 0xFF)); 746 } 747 748 AcpiOsPrintf (")"); 749 AcpiDmCommaIfFieldMember (Op); 750 break; 751 752 753 case AML_INT_CONNECTION_OP: 754 755 /* 756 * Two types of Connection() - one with a buffer object, the 757 * other with a namestring that points to a buffer object. 758 */ 759 AcpiOsPrintf ("Connection ("); 760 Child = Op->Common.Value.Arg; 761 762 if (Child->Common.AmlOpcode == AML_INT_BYTELIST_OP) 763 { 764 AcpiOsPrintf ("\n"); 765 766 Aml = Child->Named.Data; 767 Length = (UINT32) Child->Common.Value.Integer; 768 769 Info->Level += 1; 770 Op->Common.DisasmOpcode = ACPI_DASM_RESOURCE; 771 AcpiDmResourceTemplate (Info, Op->Common.Parent, Aml, Length); 772 773 Info->Level -= 1; 774 AcpiDmIndent (Info->Level); 775 } 776 else 777 { 778 AcpiDmNamestring (Child->Common.Value.Name); 779 } 780 781 AcpiOsPrintf (")"); 782 AcpiDmCommaIfFieldMember (Op); 783 AcpiOsPrintf ("\n"); 784 785 Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE; /* for now, ignore in AcpiDmAscendingOp */ 786 Child->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE; 787 break; 788 789 case AML_INT_BYTELIST_OP: 790 791 AcpiDmByteList (Info, Op); 792 break; 793 794 795 case AML_INT_METHODCALL_OP: 796 797 Op = AcpiPsGetDepthNext (NULL, Op); 798 Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE; 799 800 AcpiDmNamestring (Op->Common.Value.Name); 801 break; 802 803 804 default: 805 806 /* Just get the opcode name and print it */ 807 808 AcpiOsPrintf ("%s", OpInfo->Name); 809 810 811 #ifdef ACPI_DEBUGGER 812 813 if ((Op->Common.AmlOpcode == AML_INT_RETURN_VALUE_OP) && 814 (WalkState) && 815 (WalkState->Results) && 816 (WalkState->ResultCount)) 817 { 818 AcpiDmDecodeInternalObject ( 819 WalkState->Results->Results.ObjDesc [ 820 (WalkState->ResultCount - 1) % 821 ACPI_RESULTS_FRAME_OBJ_NUM]); 822 } 823 #endif 824 825 break; 826 } 827 } 828 829 #endif /* ACPI_DISASSEMBLER */ 830