1 /****************************************************************************** 2 * 3 * Module Name: dswexec - Dispatcher method execution callbacks; 4 * dispatch to interpreter. 5 * 6 *****************************************************************************/ 7 8 /* 9 * Copyright (C) 2000 - 2017, Intel Corp. 10 * All rights reserved. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions, and the following disclaimer, 17 * without modification. 18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 19 * substantially similar to the "NO WARRANTY" disclaimer below 20 * ("Disclaimer") and any redistribution must be conditioned upon 21 * including a substantially similar Disclaimer requirement for further 22 * binary redistribution. 23 * 3. Neither the names of the above-listed copyright holders nor the names 24 * of any contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * Alternatively, this software may be distributed under the terms of the 28 * GNU General Public License ("GPL") version 2 as published by the Free 29 * Software Foundation. 30 * 31 * NO WARRANTY 32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 42 * POSSIBILITY OF SUCH DAMAGES. 43 */ 44 45 #include <acpi/acpi.h> 46 #include "accommon.h" 47 #include "acparser.h" 48 #include "amlcode.h" 49 #include "acdispat.h" 50 #include "acinterp.h" 51 #include "acnamesp.h" 52 #include "acdebug.h" 53 54 #define _COMPONENT ACPI_DISPATCHER 55 ACPI_MODULE_NAME("dswexec") 56 57 /* 58 * Dispatch table for opcode classes 59 */ 60 static acpi_execute_op acpi_gbl_op_type_dispatch[] = { 61 acpi_ex_opcode_0A_0T_1R, 62 acpi_ex_opcode_1A_0T_0R, 63 acpi_ex_opcode_1A_0T_1R, 64 acpi_ex_opcode_1A_1T_0R, 65 acpi_ex_opcode_1A_1T_1R, 66 acpi_ex_opcode_2A_0T_0R, 67 acpi_ex_opcode_2A_0T_1R, 68 acpi_ex_opcode_2A_1T_1R, 69 acpi_ex_opcode_2A_2T_1R, 70 acpi_ex_opcode_3A_0T_0R, 71 acpi_ex_opcode_3A_1T_1R, 72 acpi_ex_opcode_6A_0T_1R 73 }; 74 75 /***************************************************************************** 76 * 77 * FUNCTION: acpi_ds_get_predicate_value 78 * 79 * PARAMETERS: walk_state - Current state of the parse tree walk 80 * result_obj - if non-zero, pop result from result stack 81 * 82 * RETURN: Status 83 * 84 * DESCRIPTION: Get the result of a predicate evaluation 85 * 86 ****************************************************************************/ 87 88 acpi_status 89 acpi_ds_get_predicate_value(struct acpi_walk_state *walk_state, 90 union acpi_operand_object *result_obj) 91 { 92 acpi_status status = AE_OK; 93 union acpi_operand_object *obj_desc; 94 union acpi_operand_object *local_obj_desc = NULL; 95 96 ACPI_FUNCTION_TRACE_PTR(ds_get_predicate_value, walk_state); 97 98 walk_state->control_state->common.state = 0; 99 100 if (result_obj) { 101 status = acpi_ds_result_pop(&obj_desc, walk_state); 102 if (ACPI_FAILURE(status)) { 103 ACPI_EXCEPTION((AE_INFO, status, 104 "Could not get result from predicate evaluation")); 105 106 return_ACPI_STATUS(status); 107 } 108 } else { 109 status = acpi_ds_create_operand(walk_state, walk_state->op, 0); 110 if (ACPI_FAILURE(status)) { 111 return_ACPI_STATUS(status); 112 } 113 114 status = 115 acpi_ex_resolve_to_value(&walk_state->operands[0], 116 walk_state); 117 if (ACPI_FAILURE(status)) { 118 return_ACPI_STATUS(status); 119 } 120 121 obj_desc = walk_state->operands[0]; 122 } 123 124 if (!obj_desc) { 125 ACPI_ERROR((AE_INFO, 126 "No predicate ObjDesc=%p State=%p", 127 obj_desc, walk_state)); 128 129 return_ACPI_STATUS(AE_AML_NO_OPERAND); 130 } 131 132 /* 133 * Result of predicate evaluation must be an Integer 134 * object. Implicitly convert the argument if necessary. 135 */ 136 status = acpi_ex_convert_to_integer(obj_desc, &local_obj_desc, 137 ACPI_STRTOUL_BASE16); 138 if (ACPI_FAILURE(status)) { 139 goto cleanup; 140 } 141 142 if (local_obj_desc->common.type != ACPI_TYPE_INTEGER) { 143 ACPI_ERROR((AE_INFO, 144 "Bad predicate (not an integer) ObjDesc=%p State=%p Type=0x%X", 145 obj_desc, walk_state, obj_desc->common.type)); 146 147 status = AE_AML_OPERAND_TYPE; 148 goto cleanup; 149 } 150 151 /* Truncate the predicate to 32-bits if necessary */ 152 153 (void)acpi_ex_truncate_for32bit_table(local_obj_desc); 154 155 /* 156 * Save the result of the predicate evaluation on 157 * the control stack 158 */ 159 if (local_obj_desc->integer.value) { 160 walk_state->control_state->common.value = TRUE; 161 } else { 162 /* 163 * Predicate is FALSE, we will just toss the 164 * rest of the package 165 */ 166 walk_state->control_state->common.value = FALSE; 167 status = AE_CTRL_FALSE; 168 } 169 170 /* Predicate can be used for an implicit return value */ 171 172 (void)acpi_ds_do_implicit_return(local_obj_desc, walk_state, TRUE); 173 174 cleanup: 175 176 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 177 "Completed a predicate eval=%X Op=%p\n", 178 walk_state->control_state->common.value, 179 walk_state->op)); 180 181 /* Break to debugger to display result */ 182 183 acpi_db_display_result_object(local_obj_desc, walk_state); 184 185 /* 186 * Delete the predicate result object (we know that 187 * we don't need it anymore) 188 */ 189 if (local_obj_desc != obj_desc) { 190 acpi_ut_remove_reference(local_obj_desc); 191 } 192 acpi_ut_remove_reference(obj_desc); 193 194 walk_state->control_state->common.state = ACPI_CONTROL_NORMAL; 195 return_ACPI_STATUS(status); 196 } 197 198 /***************************************************************************** 199 * 200 * FUNCTION: acpi_ds_exec_begin_op 201 * 202 * PARAMETERS: walk_state - Current state of the parse tree walk 203 * out_op - Where to return op if a new one is created 204 * 205 * RETURN: Status 206 * 207 * DESCRIPTION: Descending callback used during the execution of control 208 * methods. This is where most operators and operands are 209 * dispatched to the interpreter. 210 * 211 ****************************************************************************/ 212 213 acpi_status 214 acpi_ds_exec_begin_op(struct acpi_walk_state *walk_state, 215 union acpi_parse_object **out_op) 216 { 217 union acpi_parse_object *op; 218 acpi_status status = AE_OK; 219 u32 opcode_class; 220 221 ACPI_FUNCTION_TRACE_PTR(ds_exec_begin_op, walk_state); 222 223 op = walk_state->op; 224 if (!op) { 225 status = acpi_ds_load2_begin_op(walk_state, out_op); 226 if (ACPI_FAILURE(status)) { 227 goto error_exit; 228 } 229 230 op = *out_op; 231 walk_state->op = op; 232 walk_state->opcode = op->common.aml_opcode; 233 walk_state->op_info = 234 acpi_ps_get_opcode_info(op->common.aml_opcode); 235 236 if (acpi_ns_opens_scope(walk_state->op_info->object_type)) { 237 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, 238 "(%s) Popping scope for Op %p\n", 239 acpi_ut_get_type_name(walk_state-> 240 op_info-> 241 object_type), 242 op)); 243 244 status = acpi_ds_scope_stack_pop(walk_state); 245 if (ACPI_FAILURE(status)) { 246 goto error_exit; 247 } 248 } 249 } 250 251 if (op == walk_state->origin) { 252 if (out_op) { 253 *out_op = op; 254 } 255 256 return_ACPI_STATUS(AE_OK); 257 } 258 259 /* 260 * If the previous opcode was a conditional, this opcode 261 * must be the beginning of the associated predicate. 262 * Save this knowledge in the current scope descriptor 263 */ 264 if ((walk_state->control_state) && 265 (walk_state->control_state->common.state == 266 ACPI_CONTROL_CONDITIONAL_EXECUTING)) { 267 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 268 "Exec predicate Op=%p State=%p\n", 269 op, walk_state)); 270 271 walk_state->control_state->common.state = 272 ACPI_CONTROL_PREDICATE_EXECUTING; 273 274 /* Save start of predicate */ 275 276 walk_state->control_state->control.predicate_op = op; 277 } 278 279 opcode_class = walk_state->op_info->class; 280 281 /* We want to send namepaths to the load code */ 282 283 if (op->common.aml_opcode == AML_INT_NAMEPATH_OP) { 284 opcode_class = AML_CLASS_NAMED_OBJECT; 285 } 286 287 /* 288 * Handle the opcode based upon the opcode type 289 */ 290 switch (opcode_class) { 291 case AML_CLASS_CONTROL: 292 293 status = acpi_ds_exec_begin_control_op(walk_state, op); 294 break; 295 296 case AML_CLASS_NAMED_OBJECT: 297 298 if (walk_state->walk_type & ACPI_WALK_METHOD) { 299 /* 300 * Found a named object declaration during method execution; 301 * we must enter this object into the namespace. The created 302 * object is temporary and will be deleted upon completion of 303 * the execution of this method. 304 * 305 * Note 10/2010: Except for the Scope() op. This opcode does 306 * not actually create a new object, it refers to an existing 307 * object. However, for Scope(), we want to indeed open a 308 * new scope. 309 */ 310 if (op->common.aml_opcode != AML_SCOPE_OP) { 311 status = 312 acpi_ds_load2_begin_op(walk_state, NULL); 313 } else { 314 status = 315 acpi_ds_scope_stack_push(op->named.node, 316 op->named.node-> 317 type, walk_state); 318 if (ACPI_FAILURE(status)) { 319 return_ACPI_STATUS(status); 320 } 321 } 322 } 323 break; 324 325 case AML_CLASS_EXECUTE: 326 case AML_CLASS_CREATE: 327 328 break; 329 330 default: 331 332 break; 333 } 334 335 /* Nothing to do here during method execution */ 336 337 return_ACPI_STATUS(status); 338 339 error_exit: 340 status = acpi_ds_method_error(status, walk_state); 341 return_ACPI_STATUS(status); 342 } 343 344 /***************************************************************************** 345 * 346 * FUNCTION: acpi_ds_exec_end_op 347 * 348 * PARAMETERS: walk_state - Current state of the parse tree walk 349 * 350 * RETURN: Status 351 * 352 * DESCRIPTION: Ascending callback used during the execution of control 353 * methods. The only thing we really need to do here is to 354 * notice the beginning of IF, ELSE, and WHILE blocks. 355 * 356 ****************************************************************************/ 357 358 acpi_status acpi_ds_exec_end_op(struct acpi_walk_state *walk_state) 359 { 360 union acpi_parse_object *op; 361 acpi_status status = AE_OK; 362 u32 op_type; 363 u32 op_class; 364 union acpi_parse_object *next_op; 365 union acpi_parse_object *first_arg; 366 367 ACPI_FUNCTION_TRACE_PTR(ds_exec_end_op, walk_state); 368 369 op = walk_state->op; 370 op_type = walk_state->op_info->type; 371 op_class = walk_state->op_info->class; 372 373 if (op_class == AML_CLASS_UNKNOWN) { 374 ACPI_ERROR((AE_INFO, "Unknown opcode 0x%X", 375 op->common.aml_opcode)); 376 return_ACPI_STATUS(AE_NOT_IMPLEMENTED); 377 } 378 379 first_arg = op->common.value.arg; 380 381 /* Init the walk state */ 382 383 walk_state->num_operands = 0; 384 walk_state->operand_index = 0; 385 walk_state->return_desc = NULL; 386 walk_state->result_obj = NULL; 387 388 /* Call debugger for single step support (DEBUG build only) */ 389 390 status = acpi_db_single_step(walk_state, op, op_class); 391 if (ACPI_FAILURE(status)) { 392 return_ACPI_STATUS(status); 393 } 394 395 /* Decode the Opcode Class */ 396 397 switch (op_class) { 398 case AML_CLASS_ARGUMENT: /* Constants, literals, etc. */ 399 400 if (walk_state->opcode == AML_INT_NAMEPATH_OP) { 401 status = acpi_ds_evaluate_name_path(walk_state); 402 if (ACPI_FAILURE(status)) { 403 goto cleanup; 404 } 405 } 406 break; 407 408 case AML_CLASS_EXECUTE: /* Most operators with arguments */ 409 410 /* Build resolved operand stack */ 411 412 status = acpi_ds_create_operands(walk_state, first_arg); 413 if (ACPI_FAILURE(status)) { 414 goto cleanup; 415 } 416 417 /* 418 * All opcodes require operand resolution, with the only exceptions 419 * being the object_type and size_of operators. 420 */ 421 if (!(walk_state->op_info->flags & AML_NO_OPERAND_RESOLVE)) { 422 423 /* Resolve all operands */ 424 425 status = acpi_ex_resolve_operands(walk_state->opcode, 426 &(walk_state-> 427 operands 428 [walk_state-> 429 num_operands - 1]), 430 walk_state); 431 } 432 433 if (ACPI_SUCCESS(status)) { 434 /* 435 * Dispatch the request to the appropriate interpreter handler 436 * routine. There is one routine per opcode "type" based upon the 437 * number of opcode arguments and return type. 438 */ 439 status = 440 acpi_gbl_op_type_dispatch[op_type] (walk_state); 441 } else { 442 /* 443 * Treat constructs of the form "Store(LocalX,LocalX)" as noops when the 444 * Local is uninitialized. 445 */ 446 if ((status == AE_AML_UNINITIALIZED_LOCAL) && 447 (walk_state->opcode == AML_STORE_OP) && 448 (walk_state->operands[0]->common.type == 449 ACPI_TYPE_LOCAL_REFERENCE) 450 && (walk_state->operands[1]->common.type == 451 ACPI_TYPE_LOCAL_REFERENCE) 452 && (walk_state->operands[0]->reference.class == 453 walk_state->operands[1]->reference.class) 454 && (walk_state->operands[0]->reference.value == 455 walk_state->operands[1]->reference.value)) { 456 status = AE_OK; 457 } else { 458 ACPI_EXCEPTION((AE_INFO, status, 459 "While resolving operands for [%s]", 460 acpi_ps_get_opcode_name 461 (walk_state->opcode))); 462 } 463 } 464 465 /* Always delete the argument objects and clear the operand stack */ 466 467 acpi_ds_clear_operands(walk_state); 468 469 /* 470 * If a result object was returned from above, push it on the 471 * current result stack 472 */ 473 if (ACPI_SUCCESS(status) && walk_state->result_obj) { 474 status = 475 acpi_ds_result_push(walk_state->result_obj, 476 walk_state); 477 } 478 break; 479 480 default: 481 482 switch (op_type) { 483 case AML_TYPE_CONTROL: /* Type 1 opcode, IF/ELSE/WHILE/NOOP */ 484 485 /* 1 Operand, 0 external_result, 0 internal_result */ 486 487 status = acpi_ds_exec_end_control_op(walk_state, op); 488 489 break; 490 491 case AML_TYPE_METHOD_CALL: 492 /* 493 * If the method is referenced from within a package 494 * declaration, it is not a invocation of the method, just 495 * a reference to it. 496 */ 497 if ((op->asl.parent) && 498 ((op->asl.parent->asl.aml_opcode == AML_PACKAGE_OP) 499 || (op->asl.parent->asl.aml_opcode == 500 AML_VARIABLE_PACKAGE_OP))) { 501 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, 502 "Method Reference in a Package, Op=%p\n", 503 op)); 504 505 op->common.node = (struct acpi_namespace_node *) 506 op->asl.value.arg->asl.node; 507 acpi_ut_add_reference(op->asl.value.arg->asl. 508 node->object); 509 return_ACPI_STATUS(AE_OK); 510 } 511 512 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, 513 "Method invocation, Op=%p\n", op)); 514 515 /* 516 * (AML_METHODCALL) Op->Asl.Value.Arg->Asl.Node contains 517 * the method Node pointer 518 */ 519 /* next_op points to the op that holds the method name */ 520 521 next_op = first_arg; 522 523 /* next_op points to first argument op */ 524 525 next_op = next_op->common.next; 526 527 /* 528 * Get the method's arguments and put them on the operand stack 529 */ 530 status = acpi_ds_create_operands(walk_state, next_op); 531 if (ACPI_FAILURE(status)) { 532 break; 533 } 534 535 /* 536 * Since the operands will be passed to another control method, 537 * we must resolve all local references here (Local variables, 538 * arguments to *this* method, etc.) 539 */ 540 status = acpi_ds_resolve_operands(walk_state); 541 if (ACPI_FAILURE(status)) { 542 543 /* On error, clear all resolved operands */ 544 545 acpi_ds_clear_operands(walk_state); 546 break; 547 } 548 549 /* 550 * Tell the walk loop to preempt this running method and 551 * execute the new method 552 */ 553 status = AE_CTRL_TRANSFER; 554 555 /* 556 * Return now; we don't want to disturb anything, 557 * especially the operand count! 558 */ 559 return_ACPI_STATUS(status); 560 561 case AML_TYPE_CREATE_FIELD: 562 563 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 564 "Executing CreateField Buffer/Index Op=%p\n", 565 op)); 566 567 status = acpi_ds_load2_end_op(walk_state); 568 if (ACPI_FAILURE(status)) { 569 break; 570 } 571 572 status = 573 acpi_ds_eval_buffer_field_operands(walk_state, op); 574 break; 575 576 case AML_TYPE_CREATE_OBJECT: 577 578 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 579 "Executing CreateObject (Buffer/Package) Op=%p\n", 580 op)); 581 582 switch (op->common.parent->common.aml_opcode) { 583 case AML_NAME_OP: 584 /* 585 * Put the Node on the object stack (Contains the ACPI Name 586 * of this object) 587 */ 588 walk_state->operands[0] = (void *) 589 op->common.parent->common.node; 590 walk_state->num_operands = 1; 591 592 status = acpi_ds_create_node(walk_state, 593 op->common.parent-> 594 common.node, 595 op->common.parent); 596 if (ACPI_FAILURE(status)) { 597 break; 598 } 599 600 /* Fall through */ 601 /*lint -fallthrough */ 602 603 case AML_INT_EVAL_SUBTREE_OP: 604 605 status = 606 acpi_ds_eval_data_object_operands 607 (walk_state, op, 608 acpi_ns_get_attached_object(op->common. 609 parent->common. 610 node)); 611 break; 612 613 default: 614 615 status = 616 acpi_ds_eval_data_object_operands 617 (walk_state, op, NULL); 618 break; 619 } 620 621 /* 622 * If a result object was returned from above, push it on the 623 * current result stack 624 */ 625 if (walk_state->result_obj) { 626 status = 627 acpi_ds_result_push(walk_state->result_obj, 628 walk_state); 629 } 630 break; 631 632 case AML_TYPE_NAMED_FIELD: 633 case AML_TYPE_NAMED_COMPLEX: 634 case AML_TYPE_NAMED_SIMPLE: 635 case AML_TYPE_NAMED_NO_OBJ: 636 637 status = acpi_ds_load2_end_op(walk_state); 638 if (ACPI_FAILURE(status)) { 639 break; 640 } 641 642 if (op->common.aml_opcode == AML_REGION_OP) { 643 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 644 "Executing OpRegion Address/Length Op=%p\n", 645 op)); 646 647 status = 648 acpi_ds_eval_region_operands(walk_state, 649 op); 650 if (ACPI_FAILURE(status)) { 651 break; 652 } 653 } else if (op->common.aml_opcode == AML_DATA_REGION_OP) { 654 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 655 "Executing DataTableRegion Strings Op=%p\n", 656 op)); 657 658 status = 659 acpi_ds_eval_table_region_operands 660 (walk_state, op); 661 if (ACPI_FAILURE(status)) { 662 break; 663 } 664 } else if (op->common.aml_opcode == AML_BANK_FIELD_OP) { 665 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 666 "Executing BankField Op=%p\n", 667 op)); 668 669 status = 670 acpi_ds_eval_bank_field_operands(walk_state, 671 op); 672 if (ACPI_FAILURE(status)) { 673 break; 674 } 675 } 676 break; 677 678 case AML_TYPE_UNDEFINED: 679 680 ACPI_ERROR((AE_INFO, 681 "Undefined opcode type Op=%p", op)); 682 return_ACPI_STATUS(AE_NOT_IMPLEMENTED); 683 684 case AML_TYPE_BOGUS: 685 686 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, 687 "Internal opcode=%X type Op=%p\n", 688 walk_state->opcode, op)); 689 break; 690 691 default: 692 693 ACPI_ERROR((AE_INFO, 694 "Unimplemented opcode, class=0x%X " 695 "type=0x%X Opcode=0x%X Op=%p", 696 op_class, op_type, op->common.aml_opcode, 697 op)); 698 699 status = AE_NOT_IMPLEMENTED; 700 break; 701 } 702 } 703 704 /* 705 * ACPI 2.0 support for 64-bit integers: Truncate numeric 706 * result value if we are executing from a 32-bit ACPI table 707 */ 708 (void)acpi_ex_truncate_for32bit_table(walk_state->result_obj); 709 710 /* 711 * Check if we just completed the evaluation of a 712 * conditional predicate 713 */ 714 if ((ACPI_SUCCESS(status)) && 715 (walk_state->control_state) && 716 (walk_state->control_state->common.state == 717 ACPI_CONTROL_PREDICATE_EXECUTING) && 718 (walk_state->control_state->control.predicate_op == op)) { 719 status = 720 acpi_ds_get_predicate_value(walk_state, 721 walk_state->result_obj); 722 walk_state->result_obj = NULL; 723 } 724 725 cleanup: 726 727 if (walk_state->result_obj) { 728 729 /* Break to debugger to display result */ 730 731 acpi_db_display_result_object(walk_state->result_obj, 732 walk_state); 733 734 /* 735 * Delete the result op if and only if: 736 * Parent will not use the result -- such as any 737 * non-nested type2 op in a method (parent will be method) 738 */ 739 acpi_ds_delete_result_if_not_used(op, walk_state->result_obj, 740 walk_state); 741 } 742 #ifdef _UNDER_DEVELOPMENT 743 744 if (walk_state->parser_state.aml == walk_state->parser_state.aml_end) { 745 acpi_db_method_end(walk_state); 746 } 747 #endif 748 749 /* Invoke exception handler on error */ 750 751 if (ACPI_FAILURE(status)) { 752 status = acpi_ds_method_error(status, walk_state); 753 } 754 755 /* Always clear the object stack */ 756 757 walk_state->num_operands = 0; 758 return_ACPI_STATUS(status); 759 } 760