void
AcpiDsDeleteResultIfNotUsed (
ACPI_PARSE_OBJECT *Op,
ACPI_OPERAND_OBJECT *ResultObj,
ACPI_WALK_STATE *WalkState)
{
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_STATUS Status;
ACPI_FUNCTION_TRACE_PTR (DsDeleteResultIfNotUsed, ResultObj);
if (!Op)
{
ACPI_ERROR ((AE_INFO, "Null Op"));
return_VOID;
}
if (!ResultObj)
{
return_VOID;
}
if (!AcpiDsIsResultUsed (Op, WalkState))
{
/* Must pop the result stack (ObjDesc should be equal to ResultObj) */
Status = AcpiDsResultPop (&ObjDesc, WalkState);
if (ACPI_SUCCESS (Status))
{
AcpiUtRemoveReference (ResultObj);
}
}
return_VOID;
}
ACPI_STATUS
AcpiDsCreateOperand (
ACPI_WALK_STATE *WalkState,
ACPI_PARSE_OBJECT *Arg,
UINT32 ArgIndex)
{
ACPI_STATUS Status = AE_OK;
char *NameString;
UINT32 NameLength;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_PARSE_OBJECT *ParentOp;
UINT16 Opcode;
ACPI_INTERPRETER_MODE InterpreterMode;
const ACPI_OPCODE_INFO *OpInfo;
ACPI_FUNCTION_TRACE_PTR (DsCreateOperand, Arg);
/* A valid name must be looked up in the namespace */
if ((Arg->Common.AmlOpcode == AML_INT_NAMEPATH_OP) &&
(Arg->Common.Value.String) &&
!(Arg->Common.Flags & ACPI_PARSEOP_IN_STACK))
{
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Getting a name: Arg=%p\n", Arg));
/* Get the entire name string from the AML stream */
Status = AcpiExGetNameString (ACPI_TYPE_ANY, Arg->Common.Value.Buffer,
&NameString, &NameLength);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* All prefixes have been handled, and the name is in NameString */
/*
* Special handling for BufferField declarations. This is a deferred
* opcode that unfortunately defines the field name as the last
* parameter instead of the first. We get here when we are performing
* the deferred execution, so the actual name of the field is already
* in the namespace. We don't want to attempt to look it up again
* because we may be executing in a different scope than where the
* actual opcode exists.
*/
if ((WalkState->DeferredNode) &&
(WalkState->DeferredNode->Type == ACPI_TYPE_BUFFER_FIELD) &&
(ArgIndex == (UINT32) ((WalkState->Opcode == AML_CREATE_FIELD_OP) ? 3 : 2)))
{
ObjDesc = ACPI_CAST_PTR (
ACPI_OPERAND_OBJECT, WalkState->DeferredNode);
Status = AE_OK;
}
else /* All other opcodes */
{
/*
* Differentiate between a namespace "create" operation
* versus a "lookup" operation (IMODE_LOAD_PASS2 vs.
* IMODE_EXECUTE) in order to support the creation of
* namespace objects during the execution of control methods.
*/
ParentOp = Arg->Common.Parent;
OpInfo = AcpiPsGetOpcodeInfo (ParentOp->Common.AmlOpcode);
if ((OpInfo->Flags & AML_NSNODE) &&
(ParentOp->Common.AmlOpcode != AML_INT_METHODCALL_OP) &&
(ParentOp->Common.AmlOpcode != AML_REGION_OP) &&
(ParentOp->Common.AmlOpcode != AML_INT_NAMEPATH_OP))
{
/* Enter name into namespace if not found */
InterpreterMode = ACPI_IMODE_LOAD_PASS2;
}
else
{
/* Return a failure if name not found */
InterpreterMode = ACPI_IMODE_EXECUTE;
}
Status = AcpiNsLookup (WalkState->ScopeInfo, NameString,
ACPI_TYPE_ANY, InterpreterMode,
ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE,
WalkState,
ACPI_CAST_INDIRECT_PTR (ACPI_NAMESPACE_NODE, &ObjDesc));
/*
* The only case where we pass through (ignore) a NOT_FOUND
* error is for the CondRefOf opcode.
*/
if (Status == AE_NOT_FOUND)
{
if (ParentOp->Common.AmlOpcode == AML_COND_REF_OF_OP)
{
/*
* For the Conditional Reference op, it's OK if
* the name is not found; We just need a way to
* indicate this to the interpreter, set the
* object to the root
*/
ObjDesc = ACPI_CAST_PTR (
ACPI_OPERAND_OBJECT, AcpiGbl_RootNode);
Status = AE_OK;
}
else
{
/*
* We just plain didn't find it -- which is a
* very serious error at this point
*/
Status = AE_AML_NAME_NOT_FOUND;
}
}
if (ACPI_FAILURE (Status))
{
ACPI_ERROR_NAMESPACE (NameString, Status);
}
}
/* Free the namestring created above */
ACPI_FREE (NameString);
/* Check status from the lookup */
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Put the resulting object onto the current object stack */
Status = AcpiDsObjStackPush (ObjDesc, WalkState);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
ACPI_DEBUGGER_EXEC (AcpiDbDisplayArgumentObject (ObjDesc, WalkState));
}
else
{
/* Check for null name case */
if ((Arg->Common.AmlOpcode == AML_INT_NAMEPATH_OP) &&
!(Arg->Common.Flags & ACPI_PARSEOP_IN_STACK))
{
/*
* If the name is null, this means that this is an
* optional result parameter that was not specified
* in the original ASL. Create a Zero Constant for a
* placeholder. (Store to a constant is a Noop.)
*/
Opcode = AML_ZERO_OP; /* Has no arguments! */
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"Null namepath: Arg=%p\n", Arg));
}
else
{
Opcode = Arg->Common.AmlOpcode;
}
/* Get the object type of the argument */
OpInfo = AcpiPsGetOpcodeInfo (Opcode);
if (OpInfo->ObjectType == ACPI_TYPE_INVALID)
{
return_ACPI_STATUS (AE_NOT_IMPLEMENTED);
}
if ((OpInfo->Flags & AML_HAS_RETVAL) || (Arg->Common.Flags & ACPI_PARSEOP_IN_STACK))
{
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"Argument previously created, already stacked\n"));
ACPI_DEBUGGER_EXEC (AcpiDbDisplayArgumentObject (
WalkState->Operands [WalkState->NumOperands - 1], WalkState));
/*
* Use value that was already previously returned
* by the evaluation of this argument
*/
Status = AcpiDsResultPop (&ObjDesc, WalkState);
if (ACPI_FAILURE (Status))
{
/*
* Only error is underflow, and this indicates
* a missing or null operand!
*/
ACPI_EXCEPTION ((AE_INFO, Status,
"Missing or null operand"));
return_ACPI_STATUS (Status);
}
}
else
{
/* Create an ACPI_INTERNAL_OBJECT for the argument */
ObjDesc = AcpiUtCreateInternalObject (OpInfo->ObjectType);
if (!ObjDesc)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
/* Initialize the new object */
Status = AcpiDsInitObjectFromOp (
WalkState, Arg, Opcode, &ObjDesc);
if (ACPI_FAILURE (Status))
{
AcpiUtDeleteObjectDesc (ObjDesc);
return_ACPI_STATUS (Status);
}
}
/* Put the operand object on the object stack */
Status = AcpiDsObjStackPush (ObjDesc, WalkState);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
ACPI_DEBUGGER_EXEC (AcpiDbDisplayArgumentObject (ObjDesc, WalkState));
}
return_ACPI_STATUS (AE_OK);
}
ACPI_STATUS
OpcAmlConstantWalk (
ACPI_PARSE_OBJECT *Op,
UINT32 Level,
void *Context)
{
ACPI_WALK_STATE *WalkState;
ACPI_STATUS Status = AE_OK;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_PARSE_OBJECT *RootOp;
ACPI_PARSE_OBJECT *OriginalParentOp;
UINT8 WalkType;
/*
* Only interested in subtrees that could possibly contain
* expressions that can be evaluated at this time
*/
if ((!(Op->Asl.CompileFlags & NODE_COMPILE_TIME_CONST)) ||
(Op->Asl.CompileFlags & NODE_IS_TARGET))
{
return (AE_OK);
}
/* Set the walk type based on the reduction used for this op */
if (Op->Asl.CompileFlags & NODE_IS_TERM_ARG)
{
/* Op is a TermArg, constant folding is merely optional */
if (!Gbl_FoldConstants)
{
return (AE_CTRL_DEPTH);
}
WalkType = ACPI_WALK_CONST_OPTIONAL;
}
else
{
/* Op is a DataObject, the expression MUST reduced to a constant */
WalkType = ACPI_WALK_CONST_REQUIRED;
}
/* Create a new walk state */
WalkState = AcpiDsCreateWalkState (0, NULL, NULL, NULL);
if (!WalkState)
{
return AE_NO_MEMORY;
}
WalkState->NextOp = NULL;
WalkState->Params = NULL;
WalkState->WalkType = WalkType;
WalkState->CallerReturnDesc = &ObjDesc;
/*
* Examine the entire subtree -- all nodes must be constants
* or type 3/4/5 opcodes
*/
Status = TrWalkParseTree (Op, ASL_WALK_VISIT_DOWNWARD,
OpcAmlCheckForConstant, NULL, WalkState);
/*
* Did we find an entire subtree that contains all constants and type 3/4/5
* opcodes? (Only AE_OK or AE_TYPE returned from above)
*/
if (Status == AE_TYPE)
{
/* Subtree cannot be reduced to a constant */
if (WalkState->WalkType == ACPI_WALK_CONST_OPTIONAL)
{
AcpiDsDeleteWalkState (WalkState);
return (AE_OK);
}
/* Don't descend any further, and use a default "constant" value */
Status = AE_CTRL_DEPTH;
}
else
{
/* Subtree can be reduced */
/* Allocate a new temporary root for this subtree */
RootOp = TrAllocateNode (PARSEOP_INTEGER);
if (!RootOp)
{
return (AE_NO_MEMORY);
}
RootOp->Common.AmlOpcode = AML_INT_EVAL_SUBTREE_OP;
OriginalParentOp = Op->Common.Parent;
Op->Common.Parent = RootOp;
/* Hand off the subtree to the AML interpreter */
Status = TrWalkParseTree (Op, ASL_WALK_VISIT_TWICE,
OpcAmlEvaluationWalk1, OpcAmlEvaluationWalk2, WalkState);
Op->Common.Parent = OriginalParentOp;
/* TBD: we really *should* release the RootOp node */
if (ACPI_SUCCESS (Status))
{
TotalFolds++;
/* Get the final result */
Status = AcpiDsResultPop (&ObjDesc, WalkState);
}
/* Check for error from the ACPICA core */
if (ACPI_FAILURE (Status))
{
AslCoreSubsystemError (Op, Status,
"Failure during constant evaluation", FALSE);
}
}
if (ACPI_FAILURE (Status))
{
/* We could not resolve the subtree for some reason */
AslError (ASL_ERROR, ASL_MSG_CONSTANT_EVALUATION, Op,
Op->Asl.ParseOpName);
/* Set the subtree value to ZERO anyway. Eliminates further errors */
OpcUpdateIntegerNode (Op, 0);
}
else
{
AslError (ASL_OPTIMIZATION, ASL_MSG_CONSTANT_FOLDED, Op,
Op->Asl.ParseOpName);
/*
* Because we know we executed type 3/4/5 opcodes above, we know that
* the result must be either an Integer, String, or Buffer.
*/
switch (ObjDesc->Common.Type)
{
case ACPI_TYPE_INTEGER:
OpcUpdateIntegerNode (Op, ObjDesc->Integer.Value);
DbgPrint (ASL_PARSE_OUTPUT,
"Constant expression reduced to (%s) %8.8X%8.8X\n",
Op->Asl.ParseOpName,
ACPI_FORMAT_UINT64 (Op->Common.Value.Integer));
break;
case ACPI_TYPE_STRING:
Op->Asl.ParseOpcode = PARSEOP_STRING_LITERAL;
Op->Common.AmlOpcode = AML_STRING_OP;
Op->Asl.AmlLength = ACPI_STRLEN (ObjDesc->String.Pointer) + 1;
Op->Common.Value.String = ObjDesc->String.Pointer;
DbgPrint (ASL_PARSE_OUTPUT,
"Constant expression reduced to (STRING) %s\n",
Op->Common.Value.String);
break;
case ACPI_TYPE_BUFFER:
Op->Asl.ParseOpcode = PARSEOP_BUFFER;
Op->Common.AmlOpcode = AML_BUFFER_OP;
Op->Asl.CompileFlags = NODE_AML_PACKAGE;
UtSetParseOpName (Op);
/* Child node is the buffer length */
RootOp = TrAllocateNode (PARSEOP_INTEGER);
RootOp->Asl.AmlOpcode = AML_DWORD_OP;
RootOp->Asl.Value.Integer = ObjDesc->Buffer.Length;
RootOp->Asl.Parent = Op;
(void) OpcSetOptimalIntegerSize (RootOp);
Op->Asl.Child = RootOp;
Op = RootOp;
UtSetParseOpName (Op);
/* Peer to the child is the raw buffer data */
RootOp = TrAllocateNode (PARSEOP_RAW_DATA);
RootOp->Asl.AmlOpcode = AML_RAW_DATA_BUFFER;
RootOp->Asl.AmlLength = ObjDesc->Buffer.Length;
RootOp->Asl.Value.String = (char *) ObjDesc->Buffer.Pointer;
RootOp->Asl.Parent = Op->Asl.Parent;
Op->Asl.Next = RootOp;
Op = RootOp;
DbgPrint (ASL_PARSE_OUTPUT,
"Constant expression reduced to (BUFFER) length %X\n",
ObjDesc->Buffer.Length);
break;
default:
printf ("Unsupported return type: %s\n",
AcpiUtGetObjectTypeName (ObjDesc));
break;
}
}
UtSetParseOpName (Op);
Op->Asl.Child = NULL;
AcpiDsDeleteWalkState (WalkState);
return (AE_CTRL_DEPTH);
}
ACPI_STATUS
AcpiDsGetPredicateValue (
ACPI_WALK_STATE *WalkState,
ACPI_OPERAND_OBJECT *ResultObj)
{
ACPI_STATUS Status = AE_OK;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_OPERAND_OBJECT *LocalObjDesc = NULL;
ACPI_FUNCTION_TRACE_PTR (DsGetPredicateValue, WalkState);
WalkState->ControlState->Common.State = 0;
if (ResultObj)
{
Status = AcpiDsResultPop (&ObjDesc, WalkState);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status,
"Could not get result from predicate evaluation"));
return_ACPI_STATUS (Status);
}
}
else
{
Status = AcpiDsCreateOperand (WalkState, WalkState->Op, 0);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
Status = AcpiExResolveToValue (&WalkState->Operands [0], WalkState);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
ObjDesc = WalkState->Operands [0];
}
if (!ObjDesc)
{
ACPI_ERROR ((AE_INFO,
"No predicate ObjDesc=%p State=%p",
ObjDesc, WalkState));
return_ACPI_STATUS (AE_AML_NO_OPERAND);
}
/*
* Result of predicate evaluation must be an Integer
* object. Implicitly convert the argument if necessary.
*/
Status = AcpiExConvertToInteger (ObjDesc, &LocalObjDesc, 16);
if (ACPI_FAILURE (Status))
{
goto Cleanup;
}
if (LocalObjDesc->Common.Type != ACPI_TYPE_INTEGER)
{
ACPI_ERROR ((AE_INFO,
"Bad predicate (not an integer) ObjDesc=%p State=%p Type=0x%X",
ObjDesc, WalkState, ObjDesc->Common.Type));
Status = AE_AML_OPERAND_TYPE;
goto Cleanup;
}
/* Truncate the predicate to 32-bits if necessary */
(void) AcpiExTruncateFor32bitTable (LocalObjDesc);
/*
* Save the result of the predicate evaluation on
* the control stack
*/
if (LocalObjDesc->Integer.Value)
{
WalkState->ControlState->Common.Value = TRUE;
}
else
{
/*
* Predicate is FALSE, we will just toss the
* rest of the package
*/
WalkState->ControlState->Common.Value = FALSE;
Status = AE_CTRL_FALSE;
}
/* Predicate can be used for an implicit return value */
(void) AcpiDsDoImplicitReturn (LocalObjDesc, WalkState, TRUE);
Cleanup:
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"Completed a predicate eval=%X Op=%p\n",
WalkState->ControlState->Common.Value, WalkState->Op));
/* Break to debugger to display result */
AcpiDbDisplayResultObject (LocalObjDesc, WalkState);
/*
* Delete the predicate result object (we know that
* we don't need it anymore)
*/
if (LocalObjDesc != ObjDesc)
{
AcpiUtRemoveReference (LocalObjDesc);
}
AcpiUtRemoveReference (ObjDesc);
WalkState->ControlState->Common.State = ACPI_CONTROL_NORMAL;
return_ACPI_STATUS (Status);
}
static ACPI_STATUS
TrTransformToStoreOp (
ACPI_PARSE_OBJECT *Op,
ACPI_WALK_STATE *WalkState)
{
ACPI_PARSE_OBJECT *OriginalTarget;
ACPI_PARSE_OBJECT *NewTarget;
ACPI_PARSE_OBJECT *Child1;
ACPI_PARSE_OBJECT *Child2;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_PARSE_OBJECT *NewParent;
ACPI_PARSE_OBJECT *OriginalParent;
ACPI_STATUS Status;
/* Extract the operands */
Child1 = Op->Asl.Child;
Child2 = Child1->Asl.Next;
/*
* Special case for DIVIDE -- it has two targets. The first
* is for the remainder and if present, we will not attempt
* to reduce the expression.
*/
if (Op->Asl.ParseOpcode == PARSEOP_DIVIDE)
{
Child2 = Child2->Asl.Next;
if (Child2->Asl.ParseOpcode != PARSEOP_ZERO)
{
DbgPrint (ASL_PARSE_OUTPUT,
"Cannot reduce DIVIDE - has two targets\n\n");
return (AE_OK);
}
}
DbgPrint (ASL_PARSE_OUTPUT,
"Reduction/Transform to StoreOp: Store(%s, %s)\n",
Child1->Asl.ParseOpName, Child2->Asl.ParseOpName);
/*
* Create a NULL (zero) target so that we can use the
* interpreter to evaluate the expression.
*/
NewTarget = TrCreateNullTarget ();
NewTarget->Common.AmlOpcode = AML_INT_NAMEPATH_OP;
/* Handle one-operand cases (NOT, TOBCD, etc.) */
if (!Child2->Asl.Next)
{
Child2 = Child1;
}
/* Link in new NULL target as the last operand */
OriginalTarget = Child2->Asl.Next;
Child2->Asl.Next = NewTarget;
NewTarget->Asl.Parent = OriginalTarget->Asl.Parent;
NewParent = TrAllocateNode (PARSEOP_INTEGER);
NewParent->Common.AmlOpcode = AML_INT_EVAL_SUBTREE_OP;
OriginalParent = Op->Common.Parent;
Op->Common.Parent = NewParent;
/* Hand off the subtree to the AML interpreter */
WalkState->CallerReturnDesc = &ObjDesc;
Status = TrWalkParseTree (Op, ASL_WALK_VISIT_TWICE,
OpcAmlEvaluationWalk1, OpcAmlEvaluationWalk2, WalkState);
if (ACPI_FAILURE (Status))
{
DbgPrint (ASL_PARSE_OUTPUT,
"Constant Subtree evaluation(3), %s\n",
AcpiFormatException (Status));
goto EvalError;
}
/* Get the final result */
Status = AcpiDsResultPop (&ObjDesc, WalkState);
if (ACPI_FAILURE (Status))
{
DbgPrint (ASL_PARSE_OUTPUT,
"Constant Subtree evaluation(4), %s\n",
AcpiFormatException (Status));
goto EvalError;
}
/* Truncate any subtree expressions, they have been evaluated */
Child1->Asl.Child = NULL;
/* Folded constant is in ObjDesc, store into Child1 */
TrInstallReducedConstant (Child1, ObjDesc);
/* Convert operator to STORE */
Op->Asl.ParseOpcode = PARSEOP_STORE;
Op->Asl.AmlOpcode = AML_STORE_OP;
UtSetParseOpName (Op);
Op->Common.Parent = OriginalParent;
/* First child is the folded constant */
/* Second child will be the target */
Child1->Asl.Next = OriginalTarget;
return (AE_OK);
EvalError:
/* Restore original links */
Op->Common.Parent = OriginalParent;
Child2->Asl.Next = OriginalTarget;
return (Status);
}
static ACPI_STATUS
TrSimpleConstantReduction (
ACPI_PARSE_OBJECT *Op,
ACPI_WALK_STATE *WalkState)
{
ACPI_PARSE_OBJECT *RootOp;
ACPI_PARSE_OBJECT *OriginalParentOp;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_STATUS Status;
DbgPrint (ASL_PARSE_OUTPUT,
"Simple subtree constant reduction, operator to constant\n");
/* Allocate a new temporary root for this subtree */
RootOp = TrAllocateNode (PARSEOP_INTEGER);
if (!RootOp)
{
return (AE_NO_MEMORY);
}
RootOp->Common.AmlOpcode = AML_INT_EVAL_SUBTREE_OP;
OriginalParentOp = Op->Common.Parent;
Op->Common.Parent = RootOp;
/* Hand off the subtree to the AML interpreter */
WalkState->CallerReturnDesc = &ObjDesc;
Status = TrWalkParseTree (Op, ASL_WALK_VISIT_TWICE,
OpcAmlEvaluationWalk1, OpcAmlEvaluationWalk2, WalkState);
/* Restore original parse tree */
Op->Common.Parent = OriginalParentOp;
if (ACPI_FAILURE (Status))
{
DbgPrint (ASL_PARSE_OUTPUT,
"Constant Subtree evaluation(1), %s\n",
AcpiFormatException (Status));
return (Status);
}
/* Get the final result */
Status = AcpiDsResultPop (&ObjDesc, WalkState);
if (ACPI_FAILURE (Status))
{
DbgPrint (ASL_PARSE_OUTPUT,
"Constant Subtree evaluation(2), %s\n",
AcpiFormatException (Status));
return (Status);
}
/* Disconnect any existing children, install new constant */
Op->Asl.Child = NULL;
TrInstallReducedConstant (Op, ObjDesc);
UtSetParseOpName (Op);
return (AE_OK);
}
