| blob | fb9ed5e1da89dc0d3b0c2371d65b1cd47363d65d |
1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /*******************************************************************************
3 *
4 * Module Name: dsutils - Dispatcher utilities
5 *
6 ******************************************************************************/
8 #include <acpi/acpi.h>
17 #define _COMPONENT ACPI_DISPATCHER
20 /*******************************************************************************
21 *
22 * FUNCTION: acpi_ds_clear_implicit_return
23 *
24 * PARAMETERS: walk_state - Current State
25 *
26 * RETURN: None.
27 *
28 * DESCRIPTION: Clear and remove a reference on an implicit return value. Used
29 * to delete "stale" return values (if enabled, the return value
30 * from every operator is saved at least momentarily, in case the
31 * parent method exits.)
32 *
33 ******************************************************************************/
35 {
38 /*
39 * Slack must be enabled for this feature
40 */
43 }
46 /*
47 * Delete any "stale" implicit return. However, in
48 * complex statements, the implicit return value can be
49 * bubbled up several levels.
50 */
57 }
58 }
60 /*******************************************************************************
61 *
62 * FUNCTION: acpi_ds_do_implicit_return
63 *
64 * PARAMETERS: return_desc - The return value
65 * walk_state - Current State
66 * add_reference - True if a reference should be added to the
67 * return object
68 *
69 * RETURN: TRUE if implicit return enabled, FALSE otherwise
70 *
71 * DESCRIPTION: Implements the optional "implicit return". We save the result
72 * of every ASL operator and control method invocation in case the
73 * parent method exit. Before storing a new return value, we
74 * delete the previous return value.
75 *
76 ******************************************************************************/
78 u8
81 {
84 /*
85 * Slack must be enabled for this feature, and we must
86 * have a valid return object
87 */
90 }
96 /*
97 * Delete any "stale" implicit return value first. However, in
98 * complex statements, the implicit return value can be
99 * bubbled up several levels, so we don't clear the value if it
100 * is the same as the return_desc.
101 */
105 }
107 }
109 /* Save the implicit return value, add a reference if requested */
114 }
117 }
119 /*******************************************************************************
120 *
121 * FUNCTION: acpi_ds_is_result_used
122 *
123 * PARAMETERS: op - Current Op
124 * walk_state - Current State
125 *
126 * RETURN: TRUE if result is used, FALSE otherwise
127 *
128 * DESCRIPTION: Check if a result object will be used by the parent
129 *
130 ******************************************************************************/
132 u8
135 {
140 /* Must have both an Op and a Result Object */
145 }
147 /*
148 * We know that this operator is not a
149 * Return() operator (would not come here.) The following code is the
150 * optional support for a so-called "implicit return". Some AML code
151 * assumes that the last value of the method is "implicitly" returned
152 * to the caller. Just save the last result as the return value.
153 * NOTE: this is optional because the ASL language does not actually
154 * support this behavior.
155 */
157 TRUE);
159 /*
160 * Now determine if the parent will use the result
161 *
162 * If there is no parent, or the parent is a scope_op, we are executing
163 * at the method level. An executing method typically has no parent,
164 * since each method is parsed separately. A method invoked externally
165 * via execute_control_method has a scope_op as the parent.
166 */
170 /* No parent, the return value cannot possibly be used */
175 aml_opcode)));
177 }
179 /* Get info on the parent. The root_op is AML_SCOPE */
181 parent_info =
186 }
188 /*
189 * Decide what to do with the result based on the parent. If
190 * the parent opcode will not use the result, delete the object.
191 * Otherwise leave it as is, it will be deleted when it is used
192 * as an operand later.
193 */
200 /* Never delete the return value associated with a return opcode */
206 /*
207 * If we are executing the predicate AND this is the predicate op,
208 * we will use the return value
209 */
211 ACPI_CONTROL_PREDICATE_EXECUTING) &&
213 op)) {
215 }
220 /* Ignore other control opcodes */
223 }
225 /* The general control opcode returns no result */
230 /*
231 * These opcodes allow term_arg(s) as operands and therefore
232 * the operands can be method calls. The result is used.
233 */
243 AML_VARIABLE_PACKAGE_OP)
245 AML_INT_EVAL_SUBTREE_OP)
247 AML_BANK_FIELD_OP)) {
248 /*
249 * These opcodes allow term_arg(s) as operands and therefore
250 * the operands can be method calls. The result is used.
251 */
253 }
258 /*
259 * In all other cases. the parent will actually use the return
260 * object, so keep it.
261 */
263 }
265 result_used:
274 result_not_used:
282 }
284 /*******************************************************************************
285 *
286 * FUNCTION: acpi_ds_delete_result_if_not_used
287 *
288 * PARAMETERS: op - Current parse Op
289 * result_obj - Result of the operation
290 * walk_state - Current state
291 *
292 * RETURN: Status
293 *
294 * DESCRIPTION: Used after interpretation of an opcode. If there is an internal
295 * result descriptor, check if the parent opcode will actually use
296 * this result. If not, delete the result now so that it will
297 * not become orphaned.
298 *
299 ******************************************************************************/
301 void
305 {
307 acpi_status status;
313 return_VOID;
314 }
317 return_VOID;
318 }
322 /* Must pop the result stack (obj_desc should be equal to result_obj) */
327 }
328 }
330 return_VOID;
331 }
333 /*******************************************************************************
334 *
335 * FUNCTION: acpi_ds_resolve_operands
336 *
337 * PARAMETERS: walk_state - Current walk state with operands on stack
338 *
339 * RETURN: Status
340 *
341 * DESCRIPTION: Resolve all operands to their values. Used to prepare
342 * arguments to a control method invocation (a call from one
343 * method to another.)
344 *
345 ******************************************************************************/
348 {
349 u32 i;
354 /*
355 * Attempt to resolve each of the valid operands
356 * Method arguments are passed by reference, not by value. This means
357 * that the actual objects are passed, not copies of the objects.
358 */
360 status =
362 walk_state);
365 }
366 }
369 }
371 /*******************************************************************************
372 *
373 * FUNCTION: acpi_ds_clear_operands
374 *
375 * PARAMETERS: walk_state - Current walk state with operands on stack
376 *
377 * RETURN: None
378 *
379 * DESCRIPTION: Clear all operands on the current walk state operand stack.
380 *
381 ******************************************************************************/
384 {
385 u32 i;
389 /* Remove a reference on each operand on the stack */
392 /*
393 * Remove a reference to all operands, including both
394 * "Arguments" and "Targets".
395 */
398 }
401 return_VOID;
402 }
404 /*******************************************************************************
405 *
406 * FUNCTION: acpi_ds_create_operand
407 *
408 * PARAMETERS: walk_state - Current walk state
409 * arg - Parse object for the argument
410 * arg_index - Which argument (zero based)
411 *
412 * RETURN: Status
413 *
414 * DESCRIPTION: Translate a parse tree object that is an argument to an AML
415 * opcode to the equivalent interpreter object. This may include
416 * looking up a name or entering a new name into the internal
417 * namespace.
418 *
419 ******************************************************************************/
421 acpi_status
424 {
427 u32 name_length;
430 u16 opcode;
431 acpi_interpreter_mode interpreter_mode;
436 /* A valid name must be looked up in the namespace */
442 arg));
444 /* Get the entire name string from the AML stream */
452 }
454 /* All prefixes have been handled, and the name is in name_string */
456 /*
457 * Special handling for buffer_field declarations. This is a deferred
458 * opcode that unfortunately defines the field name as the last
459 * parameter instead of the first. We get here when we are performing
460 * the deferred execution, so the actual name of the field is already
461 * in the namespace. We don't want to attempt to look it up again
462 * because we may be executing in a different scope than where the
463 * actual opcode exists.
464 */
469 obj_desc =
475 /*
476 * Differentiate between a namespace "create" operation
477 * versus a "lookup" operation (IMODE_LOAD_PASS2 vs.
478 * IMODE_EXECUTE) in order to support the creation of
479 * namespace objects during the execution of control methods.
480 */
482 op_info =
484 aml_opcode);
488 AML_INT_METHODCALL_OP)
491 AML_INT_NAMEPATH_OP)) {
493 /* Enter name into namespace if not found */
497 /* Return a failure if name not found */
500 }
502 status =
505 ACPI_NS_SEARCH_PARENT |
508 acpi_namespace_node,
510 /*
511 * The only case where we pass through (ignore) a NOT_FOUND
512 * error is for the cond_ref_of opcode.
513 */
516 AML_CONDITIONAL_REF_OF_OP) {
517 /*
518 * For the Conditional Reference op, it's OK if
519 * the name is not found; We just need a way to
520 * indicate this to the interpreter, set the
521 * object to the root
522 */
523 obj_desc =
525 acpi_operand_object,
526 acpi_gbl_root_node);
529 AML_EXTERNAL_OP) {
530 /*
531 * This opcode should never appear here. It is used only
532 * by AML disassemblers and is surrounded by an If(0)
533 * by the ASL compiler.
534 *
535 * Therefore, if we see it here, it is a serious error.
536 */
539 /*
540 * We just plain didn't find it -- which is a
541 * very serious error at this point
542 */
544 }
545 }
550 }
551 }
553 /* Free the namestring created above */
557 /* Check status from the lookup */
561 }
563 /* Put the resulting object onto the current object stack */
568 }
572 /* Check for null name case */
576 /*
577 * If the name is null, this means that this is an
578 * optional result parameter that was not specified
579 * in the original ASL. Create a Zero Constant for a
580 * placeholder. (Store to a constant is a Noop.)
581 */
588 }
590 /* Get the object type of the argument */
595 }
599 /*
600 * Use value that was already previously returned
601 * by the evaluation of this argument
602 */
605 /*
606 * Only error is underflow, and this indicates
607 * a missing or null operand!
608 */
612 }
614 /* Create an ACPI_INTERNAL_OBJECT for the argument */
616 obj_desc =
618 object_type);
621 }
623 /* Initialize the new object */
625 status =
631 }
632 }
634 /* Put the operand object on the object stack */
639 }
642 }
645 }
647 /*******************************************************************************
648 *
649 * FUNCTION: acpi_ds_create_operands
650 *
651 * PARAMETERS: walk_state - Current state
652 * first_arg - First argument of a parser argument tree
653 *
654 * RETURN: Status
655 *
656 * DESCRIPTION: Convert an operator's arguments from a parse tree format to
657 * namespace objects and place those argument object on the object
658 * stack in preparation for evaluation by the interpreter.
659 *
660 ******************************************************************************/
662 acpi_status
665 {
671 u32 i;
675 /* Get all arguments in the list */
681 }
686 /* Move on to next argument, if any */
689 arg_count++;
690 index++;
691 }
697 /* Create the interpreter arguments, in reverse order */
699 index--;
707 }
712 index--;
713 }
717 cleanup:
718 /*
719 * We must undo everything done above; meaning that we must
720 * pop everything off of the operand stack and delete those
721 * objects
722 */
727 }
729 /*****************************************************************************
730 *
731 * FUNCTION: acpi_ds_evaluate_name_path
732 *
733 * PARAMETERS: walk_state - Current state of the parse tree walk,
734 * the opcode of current operation should be
735 * AML_INT_NAMEPATH_OP
736 *
737 * RETURN: Status
738 *
739 * DESCRIPTION: Translate the -name_path- parse tree object to the equivalent
740 * interpreter object, convert it to value, if needed, duplicate
741 * it, if needed, and push it onto the current result stack.
742 *
743 ****************************************************************************/
746 {
751 u8 type;
757 /* This happens after certain exception processing */
760 }
766 /* TBD: Should we specify this feature as a bit of op_info->Flags of these opcodes? */
769 }
774 }
779 }
786 }
790 /* It was incremented by acpi_ex_resolve_to_value */
794 status =
796 walk_state);
799 }
801 /*
802 * The object either was anew created or is
803 * a Namespace node - don't decrement it.
804 */
806 }
808 /* Cleanup for name-path operand */
814 }
816 push_result:
823 /* Force to take it from stack */
826 }
828 exit:
831 }