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 258 /* Match the name in the info table */ 259 260 for (Info = AslPredefinedInfo; Info->Name; Info++) 261 { 262 if (ACPI_COMPARE_NAME (Tag, Info->Name)) 263 { 264 AcpiOsPrintf (" // %4.4s: %s", Tag, 265 ACPI_CAST_PTR (char, Info->Description)); 266 return; 267 } 268 } 269 270 #endif 271 return; 272 } 273 274 275 /******************************************************************************* 276 * 277 * FUNCTION: AcpiDmMethodFlags 278 * 279 * PARAMETERS: Op - Method Object to be examined 280 * 281 * RETURN: None 282 * 283 * DESCRIPTION: Decode control method flags 284 * 285 ******************************************************************************/ 286 287 void 288 AcpiDmMethodFlags ( 289 ACPI_PARSE_OBJECT *Op) 290 { 291 UINT32 Flags; 292 UINT32 Args; 293 294 295 /* The next Op contains the flags */ 296 297 Op = AcpiPsGetDepthNext (NULL, Op); 298 Flags = (UINT8) Op->Common.Value.Integer; 299 Args = Flags & 0x07; 300 301 /* Mark the Op as completed */ 302 303 Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE; 304 305 /* 1) Method argument count */ 306 307 AcpiOsPrintf (", %u, ", Args); 308 309 /* 2) Serialize rule */ 310 311 if (!(Flags & 0x08)) 312 { 313 AcpiOsPrintf ("Not"); 314 } 315 316 AcpiOsPrintf ("Serialized"); 317 318 /* 3) SyncLevel */ 319 320 if (Flags & 0xF0) 321 { 322 AcpiOsPrintf (", %u", Flags >> 4); 323 } 324 } 325 326 327 /******************************************************************************* 328 * 329 * FUNCTION: AcpiDmFieldFlags 330 * 331 * PARAMETERS: Op - Field Object to be examined 332 * 333 * RETURN: None 334 * 335 * DESCRIPTION: Decode Field definition flags 336 * 337 ******************************************************************************/ 338 339 void 340 AcpiDmFieldFlags ( 341 ACPI_PARSE_OBJECT *Op) 342 { 343 UINT32 Flags; 344 345 346 Op = Op->Common.Next; 347 Flags = (UINT8) Op->Common.Value.Integer; 348 349 /* Mark the Op as completed */ 350 351 Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE; 352 353 AcpiOsPrintf ("%s, ", AcpiGbl_AccessTypes [Flags & 0x07]); 354 AcpiOsPrintf ("%s, ", AcpiGbl_LockRule [(Flags & 0x10) >> 4]); 355 AcpiOsPrintf ("%s)", AcpiGbl_UpdateRules [(Flags & 0x60) >> 5]); 356 } 357 358 359 /******************************************************************************* 360 * 361 * FUNCTION: AcpiDmAddressSpace 362 * 363 * PARAMETERS: SpaceId - ID to be translated 364 * 365 * RETURN: None 366 * 367 * DESCRIPTION: Decode a SpaceId to an AddressSpaceKeyword 368 * 369 ******************************************************************************/ 370 371 void 372 AcpiDmAddressSpace ( 373 UINT8 SpaceId) 374 { 375 376 if (SpaceId >= ACPI_NUM_PREDEFINED_REGIONS) 377 { 378 if (SpaceId == 0x7F) 379 { 380 AcpiOsPrintf ("FFixedHW, "); 381 } 382 else 383 { 384 AcpiOsPrintf ("0x%.2X, ", SpaceId); 385 } 386 } 387 else 388 { 389 AcpiOsPrintf ("%s, ", AcpiGbl_RegionTypes [SpaceId]); 390 } 391 } 392 393 394 /******************************************************************************* 395 * 396 * FUNCTION: AcpiDmRegionFlags 397 * 398 * PARAMETERS: Op - Object to be examined 399 * 400 * RETURN: None 401 * 402 * DESCRIPTION: Decode OperationRegion flags 403 * 404 ******************************************************************************/ 405 406 void 407 AcpiDmRegionFlags ( 408 ACPI_PARSE_OBJECT *Op) 409 { 410 411 412 /* The next Op contains the SpaceId */ 413 414 Op = AcpiPsGetDepthNext (NULL, Op); 415 416 /* Mark the Op as completed */ 417 418 Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE; 419 420 AcpiOsPrintf (", "); 421 AcpiDmAddressSpace ((UINT8) Op->Common.Value.Integer); 422 } 423 424 425 /******************************************************************************* 426 * 427 * FUNCTION: AcpiDmMatchOp 428 * 429 * PARAMETERS: Op - Match Object to be examined 430 * 431 * RETURN: None 432 * 433 * DESCRIPTION: Decode Match opcode operands 434 * 435 ******************************************************************************/ 436 437 void 438 AcpiDmMatchOp ( 439 ACPI_PARSE_OBJECT *Op) 440 { 441 ACPI_PARSE_OBJECT *NextOp; 442 443 444 NextOp = AcpiPsGetDepthNext (NULL, Op); 445 NextOp = NextOp->Common.Next; 446 447 if (!NextOp) 448 { 449 /* Handle partial tree during single-step */ 450 451 return; 452 } 453 454 /* Mark the two nodes that contain the encoding for the match keywords */ 455 456 NextOp->Common.DisasmOpcode = ACPI_DASM_MATCHOP; 457 458 NextOp = NextOp->Common.Next; 459 NextOp = NextOp->Common.Next; 460 NextOp->Common.DisasmOpcode = ACPI_DASM_MATCHOP; 461 } 462 463 464 /******************************************************************************* 465 * 466 * FUNCTION: AcpiDmMatchKeyword 467 * 468 * PARAMETERS: Op - Match Object to be examined 469 * 470 * RETURN: None 471 * 472 * DESCRIPTION: Decode Match opcode operands 473 * 474 ******************************************************************************/ 475 476 static void 477 AcpiDmMatchKeyword ( 478 ACPI_PARSE_OBJECT *Op) 479 { 480 481 482 if (((UINT32) Op->Common.Value.Integer) > ACPI_MAX_MATCH_OPCODE) 483 { 484 AcpiOsPrintf ("/* Unknown Match Keyword encoding */"); 485 } 486 else 487 { 488 AcpiOsPrintf ("%s", ACPI_CAST_PTR (char, 489 AcpiGbl_MatchOps[(ACPI_SIZE) Op->Common.Value.Integer])); 490 } 491 } 492 493 494 /******************************************************************************* 495 * 496 * FUNCTION: AcpiDmDisassembleOneOp 497 * 498 * PARAMETERS: WalkState - Current walk info 499 * Info - Parse tree walk info 500 * Op - Op that is to be printed 501 * 502 * RETURN: None 503 * 504 * DESCRIPTION: Disassemble a single AML opcode 505 * 506 ******************************************************************************/ 507 508 void 509 AcpiDmDisassembleOneOp ( 510 ACPI_WALK_STATE *WalkState, 511 ACPI_OP_WALK_INFO *Info, 512 ACPI_PARSE_OBJECT *Op) 513 { 514 const ACPI_OPCODE_INFO *OpInfo = NULL; 515 UINT32 Offset; 516 UINT32 Length; 517 ACPI_PARSE_OBJECT *Child; 518 ACPI_STATUS Status; 519 UINT8 *Aml; 520 521 522 if (!Op) 523 { 524 AcpiOsPrintf ("<NULL OP PTR>"); 525 return; 526 } 527 528 switch (Op->Common.DisasmOpcode) 529 { 530 case ACPI_DASM_MATCHOP: 531 532 AcpiDmMatchKeyword (Op); 533 return; 534 535 case ACPI_DASM_LNOT_SUFFIX: 536 switch (Op->Common.AmlOpcode) 537 { 538 case AML_LEQUAL_OP: 539 AcpiOsPrintf ("LNotEqual"); 540 break; 541 542 case AML_LGREATER_OP: 543 AcpiOsPrintf ("LLessEqual"); 544 break; 545 546 case AML_LLESS_OP: 547 AcpiOsPrintf ("LGreaterEqual"); 548 break; 549 550 default: 551 break; 552 } 553 Op->Common.DisasmOpcode = 0; 554 Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE; 555 return; 556 557 default: 558 break; 559 } 560 561 562 OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode); 563 564 /* The op and arguments */ 565 566 switch (Op->Common.AmlOpcode) 567 { 568 case AML_LNOT_OP: 569 570 Child = Op->Common.Value.Arg; 571 if ((Child->Common.AmlOpcode == AML_LEQUAL_OP) || 572 (Child->Common.AmlOpcode == AML_LGREATER_OP) || 573 (Child->Common.AmlOpcode == AML_LLESS_OP)) 574 { 575 Child->Common.DisasmOpcode = ACPI_DASM_LNOT_SUFFIX; 576 Op->Common.DisasmOpcode = ACPI_DASM_LNOT_PREFIX; 577 } 578 else 579 { 580 AcpiOsPrintf ("%s", OpInfo->Name); 581 } 582 break; 583 584 case AML_BYTE_OP: 585 586 AcpiOsPrintf ("0x%2.2X", (UINT32) Op->Common.Value.Integer); 587 break; 588 589 590 case AML_WORD_OP: 591 592 if (Op->Common.DisasmOpcode == ACPI_DASM_EISAID) 593 { 594 AcpiDmEisaId ((UINT32) Op->Common.Value.Integer); 595 } 596 else 597 { 598 AcpiOsPrintf ("0x%4.4X", (UINT32) Op->Common.Value.Integer); 599 } 600 break; 601 602 603 case AML_DWORD_OP: 604 605 if (Op->Common.DisasmOpcode == ACPI_DASM_EISAID) 606 { 607 AcpiDmEisaId ((UINT32) Op->Common.Value.Integer); 608 } 609 else 610 { 611 AcpiOsPrintf ("0x%8.8X", (UINT32) Op->Common.Value.Integer); 612 } 613 break; 614 615 616 case AML_QWORD_OP: 617 618 AcpiOsPrintf ("0x%8.8X%8.8X", 619 ACPI_FORMAT_UINT64 (Op->Common.Value.Integer)); 620 break; 621 622 623 case AML_STRING_OP: 624 625 AcpiUtPrintString (Op->Common.Value.String, ACPI_UINT8_MAX); 626 break; 627 628 629 case AML_BUFFER_OP: 630 631 /* 632 * Determine the type of buffer. We can have one of the following: 633 * 634 * 1) ResourceTemplate containing Resource Descriptors. 635 * 2) Unicode String buffer 636 * 3) ASCII String buffer 637 * 4) Raw data buffer (if none of the above) 638 * 639 * Since there are no special AML opcodes to differentiate these 640 * types of buffers, we have to closely look at the data in the 641 * buffer to determine the type. 642 */ 643 if (!AcpiGbl_NoResourceDisassembly) 644 { 645 Status = AcpiDmIsResourceTemplate (Op); 646 if (ACPI_SUCCESS (Status)) 647 { 648 Op->Common.DisasmOpcode = ACPI_DASM_RESOURCE; 649 AcpiOsPrintf ("ResourceTemplate"); 650 break; 651 } 652 else if (Status == AE_AML_NO_RESOURCE_END_TAG) 653 { 654 AcpiOsPrintf ("/**** Is ResourceTemplate, but EndTag not at buffer end ****/ "); 655 } 656 } 657 658 if (AcpiDmIsUnicodeBuffer (Op)) 659 { 660 Op->Common.DisasmOpcode = ACPI_DASM_UNICODE; 661 AcpiOsPrintf ("Unicode ("); 662 } 663 else if (AcpiDmIsStringBuffer (Op)) 664 { 665 Op->Common.DisasmOpcode = ACPI_DASM_STRING; 666 AcpiOsPrintf ("Buffer"); 667 } 668 else if (AcpiDmIsPldBuffer (Op)) 669 { 670 Op->Common.DisasmOpcode = ACPI_DASM_PLD_METHOD; 671 AcpiOsPrintf ("Buffer"); 672 } 673 else 674 { 675 Op->Common.DisasmOpcode = ACPI_DASM_BUFFER; 676 AcpiOsPrintf ("Buffer"); 677 } 678 break; 679 680 681 case AML_INT_STATICSTRING_OP: 682 683 if (Op->Common.Value.String) 684 { 685 AcpiOsPrintf ("%s", Op->Common.Value.String); 686 } 687 else 688 { 689 AcpiOsPrintf ("\"<NULL STATIC STRING PTR>\""); 690 } 691 break; 692 693 694 case AML_INT_NAMEPATH_OP: 695 696 AcpiDmNamestring (Op->Common.Value.Name); 697 break; 698 699 700 case AML_INT_NAMEDFIELD_OP: 701 702 Length = AcpiDmDumpName (Op->Named.Name); 703 AcpiOsPrintf (",%*.s %u", (unsigned) (5 - Length), " ", 704 (UINT32) Op->Common.Value.Integer); 705 AcpiDmCommaIfFieldMember (Op); 706 707 Info->BitOffset += (UINT32) Op->Common.Value.Integer; 708 break; 709 710 711 case AML_INT_RESERVEDFIELD_OP: 712 713 /* Offset() -- Must account for previous offsets */ 714 715 Offset = (UINT32) Op->Common.Value.Integer; 716 Info->BitOffset += Offset; 717 718 if (Info->BitOffset % 8 == 0) 719 { 720 AcpiOsPrintf ("Offset (0x%.2X)", ACPI_DIV_8 (Info->BitOffset)); 721 } 722 else 723 { 724 AcpiOsPrintf (" , %u", Offset); 725 } 726 727 AcpiDmCommaIfFieldMember (Op); 728 break; 729 730 731 case AML_INT_ACCESSFIELD_OP: 732 case AML_INT_EXTACCESSFIELD_OP: 733 734 AcpiOsPrintf ("AccessAs (%s, ", 735 AcpiGbl_AccessTypes [(UINT32) (Op->Common.Value.Integer & 0x7)]); 736 737 AcpiDmDecodeAttribute ((UINT8) (Op->Common.Value.Integer >> 8)); 738 739 if (Op->Common.AmlOpcode == AML_INT_EXTACCESSFIELD_OP) 740 { 741 AcpiOsPrintf (" (0x%2.2X)", (unsigned) ((Op->Common.Value.Integer >> 16) & 0xFF)); 742 } 743 744 AcpiOsPrintf (")"); 745 AcpiDmCommaIfFieldMember (Op); 746 break; 747 748 749 case AML_INT_CONNECTION_OP: 750 751 /* 752 * Two types of Connection() - one with a buffer object, the 753 * other with a namestring that points to a buffer object. 754 */ 755 AcpiOsPrintf ("Connection ("); 756 Child = Op->Common.Value.Arg; 757 758 if (Child->Common.AmlOpcode == AML_INT_BYTELIST_OP) 759 { 760 AcpiOsPrintf ("\n"); 761 762 Aml = Child->Named.Data; 763 Length = (UINT32) Child->Common.Value.Integer; 764 765 Info->Level += 1; 766 Op->Common.DisasmOpcode = ACPI_DASM_RESOURCE; 767 AcpiDmResourceTemplate (Info, Op->Common.Parent, Aml, Length); 768 769 Info->Level -= 1; 770 AcpiDmIndent (Info->Level); 771 } 772 else 773 { 774 AcpiDmNamestring (Child->Common.Value.Name); 775 } 776 777 AcpiOsPrintf (")"); 778 AcpiDmCommaIfFieldMember (Op); 779 AcpiOsPrintf ("\n"); 780 781 Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE; /* for now, ignore in AcpiDmAscendingOp */ 782 Child->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE; 783 break; 784 785 case AML_INT_BYTELIST_OP: 786 787 AcpiDmByteList (Info, Op); 788 break; 789 790 791 case AML_INT_METHODCALL_OP: 792 793 Op = AcpiPsGetDepthNext (NULL, Op); 794 Op->Common.DisasmFlags |= ACPI_PARSEOP_IGNORE; 795 796 AcpiDmNamestring (Op->Common.Value.Name); 797 break; 798 799 800 default: 801 802 /* Just get the opcode name and print it */ 803 804 AcpiOsPrintf ("%s", OpInfo->Name); 805 806 807 #ifdef ACPI_DEBUGGER 808 809 if ((Op->Common.AmlOpcode == AML_INT_RETURN_VALUE_OP) && 810 (WalkState) && 811 (WalkState->Results) && 812 (WalkState->ResultCount)) 813 { 814 AcpiDmDecodeInternalObject ( 815 WalkState->Results->Results.ObjDesc [ 816 (WalkState->ResultCount - 1) % 817 ACPI_RESULTS_FRAME_OBJ_NUM]); 818 } 819 #endif 820 821 break; 822 } 823 } 824 825 #endif /* ACPI_DISASSEMBLER */ 826