1 /****************************************************************************** 2 * 3 * Module Name: exresop - AML Interpreter operand/object resolution 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2013, 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 #define __EXRESOP_C__ 45 46 #include <contrib/dev/acpica/include/acpi.h> 47 #include <contrib/dev/acpica/include/accommon.h> 48 #include <contrib/dev/acpica/include/amlcode.h> 49 #include <contrib/dev/acpica/include/acparser.h> 50 #include <contrib/dev/acpica/include/acinterp.h> 51 #include <contrib/dev/acpica/include/acnamesp.h> 52 53 54 #define _COMPONENT ACPI_EXECUTER 55 ACPI_MODULE_NAME ("exresop") 56 57 /* Local prototypes */ 58 59 static ACPI_STATUS 60 AcpiExCheckObjectType ( 61 ACPI_OBJECT_TYPE TypeNeeded, 62 ACPI_OBJECT_TYPE ThisType, 63 void *Object); 64 65 66 /******************************************************************************* 67 * 68 * FUNCTION: AcpiExCheckObjectType 69 * 70 * PARAMETERS: TypeNeeded Object type needed 71 * ThisType Actual object type 72 * Object Object pointer 73 * 74 * RETURN: Status 75 * 76 * DESCRIPTION: Check required type against actual type 77 * 78 ******************************************************************************/ 79 80 static ACPI_STATUS 81 AcpiExCheckObjectType ( 82 ACPI_OBJECT_TYPE TypeNeeded, 83 ACPI_OBJECT_TYPE ThisType, 84 void *Object) 85 { 86 ACPI_FUNCTION_ENTRY (); 87 88 89 if (TypeNeeded == ACPI_TYPE_ANY) 90 { 91 /* All types OK, so we don't perform any typechecks */ 92 93 return (AE_OK); 94 } 95 96 if (TypeNeeded == ACPI_TYPE_LOCAL_REFERENCE) 97 { 98 /* 99 * Allow the AML "Constant" opcodes (Zero, One, etc.) to be reference 100 * objects and thus allow them to be targets. (As per the ACPI 101 * specification, a store to a constant is a noop.) 102 */ 103 if ((ThisType == ACPI_TYPE_INTEGER) && 104 (((ACPI_OPERAND_OBJECT *) Object)->Common.Flags & AOPOBJ_AML_CONSTANT)) 105 { 106 return (AE_OK); 107 } 108 } 109 110 if (TypeNeeded != ThisType) 111 { 112 ACPI_ERROR ((AE_INFO, 113 "Needed type [%s], found [%s] %p", 114 AcpiUtGetTypeName (TypeNeeded), 115 AcpiUtGetTypeName (ThisType), Object)); 116 117 return (AE_AML_OPERAND_TYPE); 118 } 119 120 return (AE_OK); 121 } 122 123 124 /******************************************************************************* 125 * 126 * FUNCTION: AcpiExResolveOperands 127 * 128 * PARAMETERS: Opcode - Opcode being interpreted 129 * StackPtr - Pointer to the operand stack to be 130 * resolved 131 * WalkState - Current state 132 * 133 * RETURN: Status 134 * 135 * DESCRIPTION: Convert multiple input operands to the types required by the 136 * target operator. 137 * 138 * Each 5-bit group in ArgTypes represents one required 139 * operand and indicates the required Type. The corresponding operand 140 * will be converted to the required type if possible, otherwise we 141 * abort with an exception. 142 * 143 ******************************************************************************/ 144 145 ACPI_STATUS 146 AcpiExResolveOperands ( 147 UINT16 Opcode, 148 ACPI_OPERAND_OBJECT **StackPtr, 149 ACPI_WALK_STATE *WalkState) 150 { 151 ACPI_OPERAND_OBJECT *ObjDesc; 152 ACPI_STATUS Status = AE_OK; 153 UINT8 ObjectType; 154 UINT32 ArgTypes; 155 const ACPI_OPCODE_INFO *OpInfo; 156 UINT32 ThisArgType; 157 ACPI_OBJECT_TYPE TypeNeeded; 158 UINT16 TargetOp = 0; 159 160 161 ACPI_FUNCTION_TRACE_U32 (ExResolveOperands, Opcode); 162 163 164 OpInfo = AcpiPsGetOpcodeInfo (Opcode); 165 if (OpInfo->Class == AML_CLASS_UNKNOWN) 166 { 167 return_ACPI_STATUS (AE_AML_BAD_OPCODE); 168 } 169 170 ArgTypes = OpInfo->RuntimeArgs; 171 if (ArgTypes == ARGI_INVALID_OPCODE) 172 { 173 ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X", 174 Opcode)); 175 176 return_ACPI_STATUS (AE_AML_INTERNAL); 177 } 178 179 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 180 "Opcode %X [%s] RequiredOperandTypes=%8.8X\n", 181 Opcode, OpInfo->Name, ArgTypes)); 182 183 /* 184 * Normal exit is with (ArgTypes == 0) at end of argument list. 185 * Function will return an exception from within the loop upon 186 * finding an entry which is not (or cannot be converted 187 * to) the required type; if stack underflows; or upon 188 * finding a NULL stack entry (which should not happen). 189 */ 190 while (GET_CURRENT_ARG_TYPE (ArgTypes)) 191 { 192 if (!StackPtr || !*StackPtr) 193 { 194 ACPI_ERROR ((AE_INFO, "Null stack entry at %p", 195 StackPtr)); 196 197 return_ACPI_STATUS (AE_AML_INTERNAL); 198 } 199 200 /* Extract useful items */ 201 202 ObjDesc = *StackPtr; 203 204 /* Decode the descriptor type */ 205 206 switch (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc)) 207 { 208 case ACPI_DESC_TYPE_NAMED: 209 210 /* Namespace Node */ 211 212 ObjectType = ((ACPI_NAMESPACE_NODE *) ObjDesc)->Type; 213 214 /* 215 * Resolve an alias object. The construction of these objects 216 * guarantees that there is only one level of alias indirection; 217 * thus, the attached object is always the aliased namespace node 218 */ 219 if (ObjectType == ACPI_TYPE_LOCAL_ALIAS) 220 { 221 ObjDesc = AcpiNsGetAttachedObject ((ACPI_NAMESPACE_NODE *) ObjDesc); 222 *StackPtr = ObjDesc; 223 ObjectType = ((ACPI_NAMESPACE_NODE *) ObjDesc)->Type; 224 } 225 break; 226 227 case ACPI_DESC_TYPE_OPERAND: 228 229 /* ACPI internal object */ 230 231 ObjectType = ObjDesc->Common.Type; 232 233 /* Check for bad ACPI_OBJECT_TYPE */ 234 235 if (!AcpiUtValidObjectType (ObjectType)) 236 { 237 ACPI_ERROR ((AE_INFO, 238 "Bad operand object type [0x%X]", ObjectType)); 239 240 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 241 } 242 243 if (ObjectType == (UINT8) ACPI_TYPE_LOCAL_REFERENCE) 244 { 245 /* Validate the Reference */ 246 247 switch (ObjDesc->Reference.Class) 248 { 249 case ACPI_REFCLASS_DEBUG: 250 251 TargetOp = AML_DEBUG_OP; 252 253 /*lint -fallthrough */ 254 255 case ACPI_REFCLASS_ARG: 256 case ACPI_REFCLASS_LOCAL: 257 case ACPI_REFCLASS_INDEX: 258 case ACPI_REFCLASS_REFOF: 259 case ACPI_REFCLASS_TABLE: /* DdbHandle from LOAD_OP or LOAD_TABLE_OP */ 260 case ACPI_REFCLASS_NAME: /* Reference to a named object */ 261 262 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 263 "Operand is a Reference, Class [%s] %2.2X\n", 264 AcpiUtGetReferenceName (ObjDesc), 265 ObjDesc->Reference.Class)); 266 break; 267 268 default: 269 270 ACPI_ERROR ((AE_INFO, 271 "Unknown Reference Class 0x%2.2X in %p", 272 ObjDesc->Reference.Class, ObjDesc)); 273 274 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 275 } 276 } 277 break; 278 279 default: 280 281 /* Invalid descriptor */ 282 283 ACPI_ERROR ((AE_INFO, "Invalid descriptor %p [%s]", 284 ObjDesc, AcpiUtGetDescriptorName (ObjDesc))); 285 286 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 287 } 288 289 /* Get one argument type, point to the next */ 290 291 ThisArgType = GET_CURRENT_ARG_TYPE (ArgTypes); 292 INCREMENT_ARG_LIST (ArgTypes); 293 294 /* 295 * Handle cases where the object does not need to be 296 * resolved to a value 297 */ 298 switch (ThisArgType) 299 { 300 case ARGI_REF_OR_STRING: /* Can be a String or Reference */ 301 302 if ((ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_OPERAND) && 303 (ObjDesc->Common.Type == ACPI_TYPE_STRING)) 304 { 305 /* 306 * String found - the string references a named object and 307 * must be resolved to a node 308 */ 309 goto NextOperand; 310 } 311 312 /* 313 * Else not a string - fall through to the normal Reference 314 * case below 315 */ 316 /*lint -fallthrough */ 317 318 case ARGI_REFERENCE: /* References: */ 319 case ARGI_INTEGER_REF: 320 case ARGI_OBJECT_REF: 321 case ARGI_DEVICE_REF: 322 case ARGI_TARGETREF: /* Allows implicit conversion rules before store */ 323 case ARGI_FIXED_TARGET: /* No implicit conversion before store to target */ 324 case ARGI_SIMPLE_TARGET: /* Name, Local, or Arg - no implicit conversion */ 325 /* 326 * Need an operand of type ACPI_TYPE_LOCAL_REFERENCE 327 * A Namespace Node is OK as-is 328 */ 329 if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_NAMED) 330 { 331 goto NextOperand; 332 } 333 334 Status = AcpiExCheckObjectType (ACPI_TYPE_LOCAL_REFERENCE, 335 ObjectType, ObjDesc); 336 if (ACPI_FAILURE (Status)) 337 { 338 return_ACPI_STATUS (Status); 339 } 340 goto NextOperand; 341 342 case ARGI_DATAREFOBJ: /* Store operator only */ 343 /* 344 * We don't want to resolve IndexOp reference objects during 345 * a store because this would be an implicit DeRefOf operation. 346 * Instead, we just want to store the reference object. 347 * -- All others must be resolved below. 348 */ 349 if ((Opcode == AML_STORE_OP) && 350 ((*StackPtr)->Common.Type == ACPI_TYPE_LOCAL_REFERENCE) && 351 ((*StackPtr)->Reference.Class == ACPI_REFCLASS_INDEX)) 352 { 353 goto NextOperand; 354 } 355 break; 356 357 default: 358 359 /* All cases covered above */ 360 361 break; 362 } 363 364 /* 365 * Resolve this object to a value 366 */ 367 Status = AcpiExResolveToValue (StackPtr, WalkState); 368 if (ACPI_FAILURE (Status)) 369 { 370 return_ACPI_STATUS (Status); 371 } 372 373 /* Get the resolved object */ 374 375 ObjDesc = *StackPtr; 376 377 /* 378 * Check the resulting object (value) type 379 */ 380 switch (ThisArgType) 381 { 382 /* 383 * For the simple cases, only one type of resolved object 384 * is allowed 385 */ 386 case ARGI_MUTEX: 387 388 /* Need an operand of type ACPI_TYPE_MUTEX */ 389 390 TypeNeeded = ACPI_TYPE_MUTEX; 391 break; 392 393 case ARGI_EVENT: 394 395 /* Need an operand of type ACPI_TYPE_EVENT */ 396 397 TypeNeeded = ACPI_TYPE_EVENT; 398 break; 399 400 case ARGI_PACKAGE: /* Package */ 401 402 /* Need an operand of type ACPI_TYPE_PACKAGE */ 403 404 TypeNeeded = ACPI_TYPE_PACKAGE; 405 break; 406 407 case ARGI_ANYTYPE: 408 409 /* Any operand type will do */ 410 411 TypeNeeded = ACPI_TYPE_ANY; 412 break; 413 414 case ARGI_DDBHANDLE: 415 416 /* Need an operand of type ACPI_TYPE_DDB_HANDLE */ 417 418 TypeNeeded = ACPI_TYPE_LOCAL_REFERENCE; 419 break; 420 421 422 /* 423 * The more complex cases allow multiple resolved object types 424 */ 425 case ARGI_INTEGER: 426 427 /* 428 * Need an operand of type ACPI_TYPE_INTEGER, 429 * But we can implicitly convert from a STRING or BUFFER 430 * Aka - "Implicit Source Operand Conversion" 431 */ 432 Status = AcpiExConvertToInteger (ObjDesc, StackPtr, 16); 433 if (ACPI_FAILURE (Status)) 434 { 435 if (Status == AE_TYPE) 436 { 437 ACPI_ERROR ((AE_INFO, 438 "Needed [Integer/String/Buffer], found [%s] %p", 439 AcpiUtGetObjectTypeName (ObjDesc), ObjDesc)); 440 441 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 442 } 443 444 return_ACPI_STATUS (Status); 445 } 446 447 if (ObjDesc != *StackPtr) 448 { 449 AcpiUtRemoveReference (ObjDesc); 450 } 451 goto NextOperand; 452 453 case ARGI_BUFFER: 454 /* 455 * Need an operand of type ACPI_TYPE_BUFFER, 456 * But we can implicitly convert from a STRING or INTEGER 457 * Aka - "Implicit Source Operand Conversion" 458 */ 459 Status = AcpiExConvertToBuffer (ObjDesc, StackPtr); 460 if (ACPI_FAILURE (Status)) 461 { 462 if (Status == AE_TYPE) 463 { 464 ACPI_ERROR ((AE_INFO, 465 "Needed [Integer/String/Buffer], found [%s] %p", 466 AcpiUtGetObjectTypeName (ObjDesc), ObjDesc)); 467 468 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 469 } 470 471 return_ACPI_STATUS (Status); 472 } 473 474 if (ObjDesc != *StackPtr) 475 { 476 AcpiUtRemoveReference (ObjDesc); 477 } 478 goto NextOperand; 479 480 case ARGI_STRING: 481 /* 482 * Need an operand of type ACPI_TYPE_STRING, 483 * But we can implicitly convert from a BUFFER or INTEGER 484 * Aka - "Implicit Source Operand Conversion" 485 */ 486 Status = AcpiExConvertToString (ObjDesc, StackPtr, 487 ACPI_IMPLICIT_CONVERT_HEX); 488 if (ACPI_FAILURE (Status)) 489 { 490 if (Status == AE_TYPE) 491 { 492 ACPI_ERROR ((AE_INFO, 493 "Needed [Integer/String/Buffer], found [%s] %p", 494 AcpiUtGetObjectTypeName (ObjDesc), ObjDesc)); 495 496 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 497 } 498 499 return_ACPI_STATUS (Status); 500 } 501 502 if (ObjDesc != *StackPtr) 503 { 504 AcpiUtRemoveReference (ObjDesc); 505 } 506 goto NextOperand; 507 508 case ARGI_COMPUTEDATA: 509 510 /* Need an operand of type INTEGER, STRING or BUFFER */ 511 512 switch (ObjDesc->Common.Type) 513 { 514 case ACPI_TYPE_INTEGER: 515 case ACPI_TYPE_STRING: 516 case ACPI_TYPE_BUFFER: 517 518 /* Valid operand */ 519 break; 520 521 default: 522 ACPI_ERROR ((AE_INFO, 523 "Needed [Integer/String/Buffer], found [%s] %p", 524 AcpiUtGetObjectTypeName (ObjDesc), ObjDesc)); 525 526 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 527 } 528 goto NextOperand; 529 530 case ARGI_BUFFER_OR_STRING: 531 532 /* Need an operand of type STRING or BUFFER */ 533 534 switch (ObjDesc->Common.Type) 535 { 536 case ACPI_TYPE_STRING: 537 case ACPI_TYPE_BUFFER: 538 539 /* Valid operand */ 540 break; 541 542 case ACPI_TYPE_INTEGER: 543 544 /* Highest priority conversion is to type Buffer */ 545 546 Status = AcpiExConvertToBuffer (ObjDesc, StackPtr); 547 if (ACPI_FAILURE (Status)) 548 { 549 return_ACPI_STATUS (Status); 550 } 551 552 if (ObjDesc != *StackPtr) 553 { 554 AcpiUtRemoveReference (ObjDesc); 555 } 556 break; 557 558 default: 559 ACPI_ERROR ((AE_INFO, 560 "Needed [Integer/String/Buffer], found [%s] %p", 561 AcpiUtGetObjectTypeName (ObjDesc), ObjDesc)); 562 563 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 564 } 565 goto NextOperand; 566 567 case ARGI_DATAOBJECT: 568 /* 569 * ARGI_DATAOBJECT is only used by the SizeOf operator. 570 * Need a buffer, string, package, or RefOf reference. 571 * 572 * The only reference allowed here is a direct reference to 573 * a namespace node. 574 */ 575 switch (ObjDesc->Common.Type) 576 { 577 case ACPI_TYPE_PACKAGE: 578 case ACPI_TYPE_STRING: 579 case ACPI_TYPE_BUFFER: 580 case ACPI_TYPE_LOCAL_REFERENCE: 581 582 /* Valid operand */ 583 break; 584 585 default: 586 587 ACPI_ERROR ((AE_INFO, 588 "Needed [Buffer/String/Package/Reference], found [%s] %p", 589 AcpiUtGetObjectTypeName (ObjDesc), ObjDesc)); 590 591 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 592 } 593 goto NextOperand; 594 595 case ARGI_COMPLEXOBJ: 596 597 /* Need a buffer or package or (ACPI 2.0) String */ 598 599 switch (ObjDesc->Common.Type) 600 { 601 case ACPI_TYPE_PACKAGE: 602 case ACPI_TYPE_STRING: 603 case ACPI_TYPE_BUFFER: 604 605 /* Valid operand */ 606 break; 607 608 default: 609 610 ACPI_ERROR ((AE_INFO, 611 "Needed [Buffer/String/Package], found [%s] %p", 612 AcpiUtGetObjectTypeName (ObjDesc), ObjDesc)); 613 614 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 615 } 616 goto NextOperand; 617 618 case ARGI_REGION_OR_BUFFER: /* Used by Load() only */ 619 620 /* Need an operand of type REGION or a BUFFER (which could be a resolved region field) */ 621 622 switch (ObjDesc->Common.Type) 623 { 624 case ACPI_TYPE_BUFFER: 625 case ACPI_TYPE_REGION: 626 627 /* Valid operand */ 628 break; 629 630 default: 631 632 ACPI_ERROR ((AE_INFO, 633 "Needed [Region/Buffer], found [%s] %p", 634 AcpiUtGetObjectTypeName (ObjDesc), ObjDesc)); 635 636 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 637 } 638 goto NextOperand; 639 640 case ARGI_DATAREFOBJ: 641 642 /* Used by the Store() operator only */ 643 644 switch (ObjDesc->Common.Type) 645 { 646 case ACPI_TYPE_INTEGER: 647 case ACPI_TYPE_PACKAGE: 648 case ACPI_TYPE_STRING: 649 case ACPI_TYPE_BUFFER: 650 case ACPI_TYPE_BUFFER_FIELD: 651 case ACPI_TYPE_LOCAL_REFERENCE: 652 case ACPI_TYPE_LOCAL_REGION_FIELD: 653 case ACPI_TYPE_LOCAL_BANK_FIELD: 654 case ACPI_TYPE_LOCAL_INDEX_FIELD: 655 case ACPI_TYPE_DDB_HANDLE: 656 657 /* Valid operand */ 658 break; 659 660 default: 661 662 if (AcpiGbl_EnableInterpreterSlack) 663 { 664 /* 665 * Enable original behavior of Store(), allowing any and all 666 * objects as the source operand. The ACPI spec does not 667 * allow this, however. 668 */ 669 break; 670 } 671 672 if (TargetOp == AML_DEBUG_OP) 673 { 674 /* Allow store of any object to the Debug object */ 675 676 break; 677 } 678 679 ACPI_ERROR ((AE_INFO, 680 "Needed Integer/Buffer/String/Package/Ref/Ddb], found [%s] %p", 681 AcpiUtGetObjectTypeName (ObjDesc), ObjDesc)); 682 683 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 684 } 685 goto NextOperand; 686 687 default: 688 689 /* Unknown type */ 690 691 ACPI_ERROR ((AE_INFO, 692 "Internal - Unknown ARGI (required operand) type 0x%X", 693 ThisArgType)); 694 695 return_ACPI_STATUS (AE_BAD_PARAMETER); 696 } 697 698 /* 699 * Make sure that the original object was resolved to the 700 * required object type (Simple cases only). 701 */ 702 Status = AcpiExCheckObjectType (TypeNeeded, 703 (*StackPtr)->Common.Type, *StackPtr); 704 if (ACPI_FAILURE (Status)) 705 { 706 return_ACPI_STATUS (Status); 707 } 708 709 NextOperand: 710 /* 711 * If more operands needed, decrement StackPtr to point 712 * to next operand on stack 713 */ 714 if (GET_CURRENT_ARG_TYPE (ArgTypes)) 715 { 716 StackPtr--; 717 } 718 } 719 720 ACPI_DUMP_OPERANDS (WalkState->Operands, 721 AcpiPsGetOpcodeName (Opcode), WalkState->NumOperands); 722 723 return_ACPI_STATUS (Status); 724 } 725