1 /*******************************************************************************
3 * Module Name: dsutils - Dispatcher utilities
5 ******************************************************************************/
8 * Copyright (C) 2000 - 2015, Intel Corp.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
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.
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/acdispat.h>
49 #include <contrib/dev/acpica/include/acinterp.h>
50 #include <contrib/dev/acpica/include/acnamesp.h>
51 #include <contrib/dev/acpica/include/acdebug.h>
53 #define _COMPONENT ACPI_DISPATCHER
54 ACPI_MODULE_NAME ("dsutils")
57 /*******************************************************************************
59 * FUNCTION: AcpiDsClearImplicitReturn
61 * PARAMETERS: WalkState - Current State
65 * DESCRIPTION: Clear and remove a reference on an implicit return value. Used
66 * to delete "stale" return values (if enabled, the return value
67 * from every operator is saved at least momentarily, in case the
68 * parent method exits.)
70 ******************************************************************************/
73 AcpiDsClearImplicitReturn (
74 ACPI_WALK_STATE *WalkState)
76 ACPI_FUNCTION_NAME (DsClearImplicitReturn);
80 * Slack must be enabled for this feature
82 if (!AcpiGbl_EnableInterpreterSlack)
87 if (WalkState->ImplicitReturnObj)
90 * Delete any "stale" implicit return. However, in
91 * complex statements, the implicit return value can be
92 * bubbled up several levels.
94 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
95 "Removing reference on stale implicit return obj %p\n",
96 WalkState->ImplicitReturnObj));
98 AcpiUtRemoveReference (WalkState->ImplicitReturnObj);
99 WalkState->ImplicitReturnObj = NULL;
104 #ifndef ACPI_NO_METHOD_EXECUTION
105 /*******************************************************************************
107 * FUNCTION: AcpiDsDoImplicitReturn
109 * PARAMETERS: ReturnDesc - The return value
110 * WalkState - Current State
111 * AddReference - True if a reference should be added to the
114 * RETURN: TRUE if implicit return enabled, FALSE otherwise
116 * DESCRIPTION: Implements the optional "implicit return". We save the result
117 * of every ASL operator and control method invocation in case the
118 * parent method exit. Before storing a new return value, we
119 * delete the previous return value.
121 ******************************************************************************/
124 AcpiDsDoImplicitReturn (
125 ACPI_OPERAND_OBJECT *ReturnDesc,
126 ACPI_WALK_STATE *WalkState,
127 BOOLEAN AddReference)
129 ACPI_FUNCTION_NAME (DsDoImplicitReturn);
133 * Slack must be enabled for this feature, and we must
134 * have a valid return object
136 if ((!AcpiGbl_EnableInterpreterSlack) ||
142 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
143 "Result %p will be implicitly returned; Prev=%p\n",
145 WalkState->ImplicitReturnObj));
148 * Delete any "stale" implicit return value first. However, in
149 * complex statements, the implicit return value can be
150 * bubbled up several levels, so we don't clear the value if it
151 * is the same as the ReturnDesc.
153 if (WalkState->ImplicitReturnObj)
155 if (WalkState->ImplicitReturnObj == ReturnDesc)
159 AcpiDsClearImplicitReturn (WalkState);
162 /* Save the implicit return value, add a reference if requested */
164 WalkState->ImplicitReturnObj = ReturnDesc;
167 AcpiUtAddReference (ReturnDesc);
174 /*******************************************************************************
176 * FUNCTION: AcpiDsIsResultUsed
178 * PARAMETERS: Op - Current Op
179 * WalkState - Current State
181 * RETURN: TRUE if result is used, FALSE otherwise
183 * DESCRIPTION: Check if a result object will be used by the parent
185 ******************************************************************************/
189 ACPI_PARSE_OBJECT *Op,
190 ACPI_WALK_STATE *WalkState)
192 const ACPI_OPCODE_INFO *ParentInfo;
194 ACPI_FUNCTION_TRACE_PTR (DsIsResultUsed, Op);
197 /* Must have both an Op and a Result Object */
201 ACPI_ERROR ((AE_INFO, "Null Op"));
206 * We know that this operator is not a
207 * Return() operator (would not come here.) The following code is the
208 * optional support for a so-called "implicit return". Some AML code
209 * assumes that the last value of the method is "implicitly" returned
210 * to the caller. Just save the last result as the return value.
211 * NOTE: this is optional because the ASL language does not actually
212 * support this behavior.
214 (void) AcpiDsDoImplicitReturn (WalkState->ResultObj, WalkState, TRUE);
217 * Now determine if the parent will use the result
219 * If there is no parent, or the parent is a ScopeOp, we are executing
220 * at the method level. An executing method typically has no parent,
221 * since each method is parsed separately. A method invoked externally
222 * via ExecuteControlMethod has a ScopeOp as the parent.
224 if ((!Op->Common.Parent) ||
225 (Op->Common.Parent->Common.AmlOpcode == AML_SCOPE_OP))
227 /* No parent, the return value cannot possibly be used */
229 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
230 "At Method level, result of [%s] not used\n",
231 AcpiPsGetOpcodeName (Op->Common.AmlOpcode)));
232 return_UINT8 (FALSE);
235 /* Get info on the parent. The RootOp is AML_SCOPE */
237 ParentInfo = AcpiPsGetOpcodeInfo (Op->Common.Parent->Common.AmlOpcode);
238 if (ParentInfo->Class == AML_CLASS_UNKNOWN)
240 ACPI_ERROR ((AE_INFO,
241 "Unknown parent opcode Op=%p", Op));
242 return_UINT8 (FALSE);
246 * Decide what to do with the result based on the parent. If
247 * the parent opcode will not use the result, delete the object.
248 * Otherwise leave it as is, it will be deleted when it is used
249 * as an operand later.
251 switch (ParentInfo->Class)
253 case AML_CLASS_CONTROL:
255 switch (Op->Common.Parent->Common.AmlOpcode)
259 /* Never delete the return value associated with a return opcode */
266 * If we are executing the predicate AND this is the predicate op,
267 * we will use the return value
269 if ((WalkState->ControlState->Common.State == ACPI_CONTROL_PREDICATE_EXECUTING) &&
270 (WalkState->ControlState->Control.PredicateOp == Op))
278 /* Ignore other control opcodes */
283 /* The general control opcode returns no result */
287 case AML_CLASS_CREATE:
289 * These opcodes allow TermArg(s) as operands and therefore
290 * the operands can be method calls. The result is used.
294 case AML_CLASS_NAMED_OBJECT:
296 if ((Op->Common.Parent->Common.AmlOpcode == AML_REGION_OP) ||
297 (Op->Common.Parent->Common.AmlOpcode == AML_DATA_REGION_OP) ||
298 (Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
299 (Op->Common.Parent->Common.AmlOpcode == AML_VAR_PACKAGE_OP) ||
300 (Op->Common.Parent->Common.AmlOpcode == AML_BUFFER_OP) ||
301 (Op->Common.Parent->Common.AmlOpcode == AML_INT_EVAL_SUBTREE_OP) ||
302 (Op->Common.Parent->Common.AmlOpcode == AML_BANK_FIELD_OP))
305 * These opcodes allow TermArg(s) as operands and therefore
306 * the operands can be method calls. The result is used.
315 * In all other cases. the parent will actually use the return
316 * object, so keep it.
323 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
324 "Result of [%s] used by Parent [%s] Op=%p\n",
325 AcpiPsGetOpcodeName (Op->Common.AmlOpcode),
326 AcpiPsGetOpcodeName (Op->Common.Parent->Common.AmlOpcode), Op));
332 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
333 "Result of [%s] not used by Parent [%s] Op=%p\n",
334 AcpiPsGetOpcodeName (Op->Common.AmlOpcode),
335 AcpiPsGetOpcodeName (Op->Common.Parent->Common.AmlOpcode), Op));
337 return_UINT8 (FALSE);
341 /*******************************************************************************
343 * FUNCTION: AcpiDsDeleteResultIfNotUsed
345 * PARAMETERS: Op - Current parse Op
346 * ResultObj - Result of the operation
347 * WalkState - Current state
351 * DESCRIPTION: Used after interpretation of an opcode. If there is an internal
352 * result descriptor, check if the parent opcode will actually use
353 * this result. If not, delete the result now so that it will
354 * not become orphaned.
356 ******************************************************************************/
359 AcpiDsDeleteResultIfNotUsed (
360 ACPI_PARSE_OBJECT *Op,
361 ACPI_OPERAND_OBJECT *ResultObj,
362 ACPI_WALK_STATE *WalkState)
364 ACPI_OPERAND_OBJECT *ObjDesc;
368 ACPI_FUNCTION_TRACE_PTR (DsDeleteResultIfNotUsed, ResultObj);
373 ACPI_ERROR ((AE_INFO, "Null Op"));
382 if (!AcpiDsIsResultUsed (Op, WalkState))
384 /* Must pop the result stack (ObjDesc should be equal to ResultObj) */
386 Status = AcpiDsResultPop (&ObjDesc, WalkState);
387 if (ACPI_SUCCESS (Status))
389 AcpiUtRemoveReference (ResultObj);
397 /*******************************************************************************
399 * FUNCTION: AcpiDsResolveOperands
401 * PARAMETERS: WalkState - Current walk state with operands on stack
405 * DESCRIPTION: Resolve all operands to their values. Used to prepare
406 * arguments to a control method invocation (a call from one
407 * method to another.)
409 ******************************************************************************/
412 AcpiDsResolveOperands (
413 ACPI_WALK_STATE *WalkState)
416 ACPI_STATUS Status = AE_OK;
419 ACPI_FUNCTION_TRACE_PTR (DsResolveOperands, WalkState);
423 * Attempt to resolve each of the valid operands
424 * Method arguments are passed by reference, not by value. This means
425 * that the actual objects are passed, not copies of the objects.
427 for (i = 0; i < WalkState->NumOperands; i++)
429 Status = AcpiExResolveToValue (&WalkState->Operands[i], WalkState);
430 if (ACPI_FAILURE (Status))
436 return_ACPI_STATUS (Status);
440 /*******************************************************************************
442 * FUNCTION: AcpiDsClearOperands
444 * PARAMETERS: WalkState - Current walk state with operands on stack
448 * DESCRIPTION: Clear all operands on the current walk state operand stack.
450 ******************************************************************************/
453 AcpiDsClearOperands (
454 ACPI_WALK_STATE *WalkState)
459 ACPI_FUNCTION_TRACE_PTR (DsClearOperands, WalkState);
462 /* Remove a reference on each operand on the stack */
464 for (i = 0; i < WalkState->NumOperands; i++)
467 * Remove a reference to all operands, including both
468 * "Arguments" and "Targets".
470 AcpiUtRemoveReference (WalkState->Operands[i]);
471 WalkState->Operands[i] = NULL;
474 WalkState->NumOperands = 0;
480 /*******************************************************************************
482 * FUNCTION: AcpiDsCreateOperand
484 * PARAMETERS: WalkState - Current walk state
485 * Arg - Parse object for the argument
486 * ArgIndex - Which argument (zero based)
490 * DESCRIPTION: Translate a parse tree object that is an argument to an AML
491 * opcode to the equivalent interpreter object. This may include
492 * looking up a name or entering a new name into the internal
495 ******************************************************************************/
498 AcpiDsCreateOperand (
499 ACPI_WALK_STATE *WalkState,
500 ACPI_PARSE_OBJECT *Arg,
503 ACPI_STATUS Status = AE_OK;
506 ACPI_OPERAND_OBJECT *ObjDesc;
507 ACPI_PARSE_OBJECT *ParentOp;
509 ACPI_INTERPRETER_MODE InterpreterMode;
510 const ACPI_OPCODE_INFO *OpInfo;
513 ACPI_FUNCTION_TRACE_PTR (DsCreateOperand, Arg);
516 /* A valid name must be looked up in the namespace */
518 if ((Arg->Common.AmlOpcode == AML_INT_NAMEPATH_OP) &&
519 (Arg->Common.Value.String) &&
520 !(Arg->Common.Flags & ACPI_PARSEOP_IN_STACK))
522 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Getting a name: Arg=%p\n", Arg));
524 /* Get the entire name string from the AML stream */
526 Status = AcpiExGetNameString (ACPI_TYPE_ANY, Arg->Common.Value.Buffer,
527 &NameString, &NameLength);
529 if (ACPI_FAILURE (Status))
531 return_ACPI_STATUS (Status);
534 /* All prefixes have been handled, and the name is in NameString */
537 * Special handling for BufferField declarations. This is a deferred
538 * opcode that unfortunately defines the field name as the last
539 * parameter instead of the first. We get here when we are performing
540 * the deferred execution, so the actual name of the field is already
541 * in the namespace. We don't want to attempt to look it up again
542 * because we may be executing in a different scope than where the
543 * actual opcode exists.
545 if ((WalkState->DeferredNode) &&
546 (WalkState->DeferredNode->Type == ACPI_TYPE_BUFFER_FIELD) &&
547 (ArgIndex == (UINT32) ((WalkState->Opcode == AML_CREATE_FIELD_OP) ? 3 : 2)))
549 ObjDesc = ACPI_CAST_PTR (
550 ACPI_OPERAND_OBJECT, WalkState->DeferredNode);
553 else /* All other opcodes */
556 * Differentiate between a namespace "create" operation
557 * versus a "lookup" operation (IMODE_LOAD_PASS2 vs.
558 * IMODE_EXECUTE) in order to support the creation of
559 * namespace objects during the execution of control methods.
561 ParentOp = Arg->Common.Parent;
562 OpInfo = AcpiPsGetOpcodeInfo (ParentOp->Common.AmlOpcode);
563 if ((OpInfo->Flags & AML_NSNODE) &&
564 (ParentOp->Common.AmlOpcode != AML_INT_METHODCALL_OP) &&
565 (ParentOp->Common.AmlOpcode != AML_REGION_OP) &&
566 (ParentOp->Common.AmlOpcode != AML_INT_NAMEPATH_OP))
568 /* Enter name into namespace if not found */
570 InterpreterMode = ACPI_IMODE_LOAD_PASS2;
574 /* Return a failure if name not found */
576 InterpreterMode = ACPI_IMODE_EXECUTE;
579 Status = AcpiNsLookup (WalkState->ScopeInfo, NameString,
580 ACPI_TYPE_ANY, InterpreterMode,
581 ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE,
583 ACPI_CAST_INDIRECT_PTR (ACPI_NAMESPACE_NODE, &ObjDesc));
585 * The only case where we pass through (ignore) a NOT_FOUND
586 * error is for the CondRefOf opcode.
588 if (Status == AE_NOT_FOUND)
590 if (ParentOp->Common.AmlOpcode == AML_COND_REF_OF_OP)
593 * For the Conditional Reference op, it's OK if
594 * the name is not found; We just need a way to
595 * indicate this to the interpreter, set the
598 ObjDesc = ACPI_CAST_PTR (
599 ACPI_OPERAND_OBJECT, AcpiGbl_RootNode);
605 * We just plain didn't find it -- which is a
606 * very serious error at this point
608 Status = AE_AML_NAME_NOT_FOUND;
612 if (ACPI_FAILURE (Status))
614 ACPI_ERROR_NAMESPACE (NameString, Status);
618 /* Free the namestring created above */
620 ACPI_FREE (NameString);
622 /* Check status from the lookup */
624 if (ACPI_FAILURE (Status))
626 return_ACPI_STATUS (Status);
629 /* Put the resulting object onto the current object stack */
631 Status = AcpiDsObjStackPush (ObjDesc, WalkState);
632 if (ACPI_FAILURE (Status))
634 return_ACPI_STATUS (Status);
636 ACPI_DEBUGGER_EXEC (AcpiDbDisplayArgumentObject (ObjDesc, WalkState));
640 /* Check for null name case */
642 if ((Arg->Common.AmlOpcode == AML_INT_NAMEPATH_OP) &&
643 !(Arg->Common.Flags & ACPI_PARSEOP_IN_STACK))
646 * If the name is null, this means that this is an
647 * optional result parameter that was not specified
648 * in the original ASL. Create a Zero Constant for a
649 * placeholder. (Store to a constant is a Noop.)
651 Opcode = AML_ZERO_OP; /* Has no arguments! */
653 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
654 "Null namepath: Arg=%p\n", Arg));
658 Opcode = Arg->Common.AmlOpcode;
661 /* Get the object type of the argument */
663 OpInfo = AcpiPsGetOpcodeInfo (Opcode);
664 if (OpInfo->ObjectType == ACPI_TYPE_INVALID)
666 return_ACPI_STATUS (AE_NOT_IMPLEMENTED);
669 if ((OpInfo->Flags & AML_HAS_RETVAL) || (Arg->Common.Flags & ACPI_PARSEOP_IN_STACK))
671 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
672 "Argument previously created, already stacked\n"));
674 ACPI_DEBUGGER_EXEC (AcpiDbDisplayArgumentObject (
675 WalkState->Operands [WalkState->NumOperands - 1], WalkState));
678 * Use value that was already previously returned
679 * by the evaluation of this argument
681 Status = AcpiDsResultPop (&ObjDesc, WalkState);
682 if (ACPI_FAILURE (Status))
685 * Only error is underflow, and this indicates
686 * a missing or null operand!
688 ACPI_EXCEPTION ((AE_INFO, Status,
689 "Missing or null operand"));
690 return_ACPI_STATUS (Status);
695 /* Create an ACPI_INTERNAL_OBJECT for the argument */
697 ObjDesc = AcpiUtCreateInternalObject (OpInfo->ObjectType);
700 return_ACPI_STATUS (AE_NO_MEMORY);
703 /* Initialize the new object */
705 Status = AcpiDsInitObjectFromOp (
706 WalkState, Arg, Opcode, &ObjDesc);
707 if (ACPI_FAILURE (Status))
709 AcpiUtDeleteObjectDesc (ObjDesc);
710 return_ACPI_STATUS (Status);
714 /* Put the operand object on the object stack */
716 Status = AcpiDsObjStackPush (ObjDesc, WalkState);
717 if (ACPI_FAILURE (Status))
719 return_ACPI_STATUS (Status);
722 ACPI_DEBUGGER_EXEC (AcpiDbDisplayArgumentObject (ObjDesc, WalkState));
725 return_ACPI_STATUS (AE_OK);
729 /*******************************************************************************
731 * FUNCTION: AcpiDsCreateOperands
733 * PARAMETERS: WalkState - Current state
734 * FirstArg - First argument of a parser argument tree
738 * DESCRIPTION: Convert an operator's arguments from a parse tree format to
739 * namespace objects and place those argument object on the object
740 * stack in preparation for evaluation by the interpreter.
742 ******************************************************************************/
745 AcpiDsCreateOperands (
746 ACPI_WALK_STATE *WalkState,
747 ACPI_PARSE_OBJECT *FirstArg)
749 ACPI_STATUS Status = AE_OK;
750 ACPI_PARSE_OBJECT *Arg;
751 ACPI_PARSE_OBJECT *Arguments[ACPI_OBJ_NUM_OPERANDS];
753 UINT32 Index = WalkState->NumOperands;
757 ACPI_FUNCTION_TRACE_PTR (DsCreateOperands, FirstArg);
760 /* Get all arguments in the list */
765 if (Index >= ACPI_OBJ_NUM_OPERANDS)
767 return_ACPI_STATUS (AE_BAD_DATA);
770 Arguments[Index] = Arg;
771 WalkState->Operands [Index] = NULL;
773 /* Move on to next argument, if any */
775 Arg = Arg->Common.Next;
780 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
781 "NumOperands %d, ArgCount %d, Index %d\n",
782 WalkState->NumOperands, ArgCount, Index));
784 /* Create the interpreter arguments, in reverse order */
787 for (i = 0; i < ArgCount; i++)
789 Arg = Arguments[Index];
790 WalkState->OperandIndex = (UINT8) Index;
792 Status = AcpiDsCreateOperand (WalkState, Arg, Index);
793 if (ACPI_FAILURE (Status))
798 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
799 "Created Arg #%u (%p) %u args total\n",
800 Index, Arg, ArgCount));
804 return_ACPI_STATUS (Status);
809 * We must undo everything done above; meaning that we must
810 * pop everything off of the operand stack and delete those
813 AcpiDsObjStackPopAndDelete (ArgCount, WalkState);
815 ACPI_EXCEPTION ((AE_INFO, Status, "While creating Arg %u", Index));
816 return_ACPI_STATUS (Status);
820 /*****************************************************************************
822 * FUNCTION: AcpiDsEvaluateNamePath
824 * PARAMETERS: WalkState - Current state of the parse tree walk,
825 * the opcode of current operation should be
826 * AML_INT_NAMEPATH_OP
830 * DESCRIPTION: Translate the -NamePath- parse tree object to the equivalent
831 * interpreter object, convert it to value, if needed, duplicate
832 * it, if needed, and push it onto the current result stack.
834 ****************************************************************************/
837 AcpiDsEvaluateNamePath (
838 ACPI_WALK_STATE *WalkState)
840 ACPI_STATUS Status = AE_OK;
841 ACPI_PARSE_OBJECT *Op = WalkState->Op;
842 ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0];
843 ACPI_OPERAND_OBJECT *NewObjDesc;
847 ACPI_FUNCTION_TRACE_PTR (DsEvaluateNamePath, WalkState);
850 if (!Op->Common.Parent)
852 /* This happens after certain exception processing */
857 if ((Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
858 (Op->Common.Parent->Common.AmlOpcode == AML_VAR_PACKAGE_OP) ||
859 (Op->Common.Parent->Common.AmlOpcode == AML_REF_OF_OP))
861 /* TBD: Should we specify this feature as a bit of OpInfo->Flags of these opcodes? */
866 Status = AcpiDsCreateOperand (WalkState, Op, 0);
867 if (ACPI_FAILURE (Status))
872 if (Op->Common.Flags & ACPI_PARSEOP_TARGET)
874 NewObjDesc = *Operand;
878 Type = (*Operand)->Common.Type;
880 Status = AcpiExResolveToValue (Operand, WalkState);
881 if (ACPI_FAILURE (Status))
886 if (Type == ACPI_TYPE_INTEGER)
888 /* It was incremented by AcpiExResolveToValue */
890 AcpiUtRemoveReference (*Operand);
892 Status = AcpiUtCopyIobjectToIobject (*Operand, &NewObjDesc, WalkState);
893 if (ACPI_FAILURE (Status))
901 * The object either was anew created or is
902 * a Namespace node - don't decrement it.
904 NewObjDesc = *Operand;
907 /* Cleanup for name-path operand */
909 Status = AcpiDsObjStackPop (1, WalkState);
910 if (ACPI_FAILURE (Status))
912 WalkState->ResultObj = NewObjDesc;
918 WalkState->ResultObj = NewObjDesc;
920 Status = AcpiDsResultPush (WalkState->ResultObj, WalkState);
921 if (ACPI_SUCCESS (Status))
923 /* Force to take it from stack */
925 Op->Common.Flags |= ACPI_PARSEOP_IN_STACK;
930 return_ACPI_STATUS (Status);