static ACPI_STATUS
AcpiPsCreateOp (
ACPI_WALK_STATE *WalkState,
UINT8 *AmlOpStart,
ACPI_PARSE_OBJECT **NewOp)
{
ACPI_STATUS Status = AE_OK;
ACPI_PARSE_OBJECT *Op;
ACPI_PARSE_OBJECT *NamedOp = NULL;
ACPI_PARSE_OBJECT *ParentScope;
UINT8 ArgumentCount;
const ACPI_OPCODE_INFO *OpInfo;
ACPI_FUNCTION_TRACE_PTR (PsCreateOp, WalkState);
Status = AcpiPsGetAmlOpcode (WalkState);
if (Status == AE_CTRL_PARSE_CONTINUE)
{
return_ACPI_STATUS (AE_CTRL_PARSE_CONTINUE);
}
/* Create Op structure and append to parent's argument list */
WalkState->OpInfo = AcpiPsGetOpcodeInfo (WalkState->Opcode);
Op = AcpiPsAllocOp (WalkState->Opcode);
if (!Op)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
if (WalkState->OpInfo->Flags & AML_NAMED)
{
Status = AcpiPsBuildNamedOp (WalkState, AmlOpStart, Op, &NamedOp);
AcpiPsFreeOp (Op);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
*NewOp = NamedOp;
return_ACPI_STATUS (AE_OK);
}
/* Not a named opcode, just allocate Op and append to parent */
if (WalkState->OpInfo->Flags & AML_CREATE)
{
/*
* Backup to beginning of CreateXXXfield declaration
* BodyLength is unknown until we parse the body
*/
Op->Named.Data = AmlOpStart;
Op->Named.Length = 0;
}
if (WalkState->Opcode == AML_BANK_FIELD_OP)
{
/*
* Backup to beginning of BankField declaration
* BodyLength is unknown until we parse the body
*/
Op->Named.Data = AmlOpStart;
Op->Named.Length = 0;
}
ParentScope = AcpiPsGetParentScope (&(WalkState->ParserState));
AcpiPsAppendArg (ParentScope, Op);
if (ParentScope)
{
OpInfo = AcpiPsGetOpcodeInfo (ParentScope->Common.AmlOpcode);
if (OpInfo->Flags & AML_HAS_TARGET)
{
ArgumentCount = AcpiPsGetArgumentCount (OpInfo->Type);
if (ParentScope->Common.ArgListLength > ArgumentCount)
{
Op->Common.Flags |= ACPI_PARSEOP_TARGET;
}
}
else if (ParentScope->Common.AmlOpcode == AML_INCREMENT_OP)
{
Op->Common.Flags |= ACPI_PARSEOP_TARGET;
}
}
if (WalkState->DescendingCallback != NULL)
{
/*
* Find the object. This will either insert the object into
* the namespace or simply look it up
*/
WalkState->Op = *NewOp = Op;
Status = WalkState->DescendingCallback (WalkState, &Op);
Status = AcpiPsNextParseState (WalkState, Op, Status);
if (Status == AE_CTRL_PENDING)
{
Status = AE_CTRL_PARSE_PENDING;
}
}
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiPsParseLoop (
ACPI_WALK_STATE *WalkState)
{
ACPI_STATUS Status = AE_OK;
ACPI_PARSE_OBJECT *Op = NULL; /* current op */
ACPI_PARSE_STATE *ParserState;
UINT8 *AmlOpStart = NULL;
ACPI_FUNCTION_TRACE_PTR (PsParseLoop, WalkState);
if (WalkState->DescendingCallback == NULL)
{
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
ParserState = &WalkState->ParserState;
WalkState->ArgTypes = 0;
#if (!defined (ACPI_NO_METHOD_EXECUTION) && !defined (ACPI_CONSTANT_EVAL_ONLY))
if (WalkState->WalkType & ACPI_WALK_METHOD_RESTART)
{
/* We are restarting a preempted control method */
if (AcpiPsHasCompletedScope (ParserState))
{
/*
* We must check if a predicate to an IF or WHILE statement
* was just completed
*/
if ((ParserState->Scope->ParseScope.Op) &&
((ParserState->Scope->ParseScope.Op->Common.AmlOpcode == AML_IF_OP) ||
(ParserState->Scope->ParseScope.Op->Common.AmlOpcode == AML_WHILE_OP)) &&
(WalkState->ControlState) &&
(WalkState->ControlState->Common.State ==
ACPI_CONTROL_PREDICATE_EXECUTING))
{
/*
* A predicate was just completed, get the value of the
* predicate and branch based on that value
*/
WalkState->Op = NULL;
Status = AcpiDsGetPredicateValue (WalkState, ACPI_TO_POINTER (TRUE));
if (ACPI_FAILURE (Status) &&
((Status & AE_CODE_MASK) != AE_CODE_CONTROL))
{
if (Status == AE_AML_NO_RETURN_VALUE)
{
ACPI_EXCEPTION ((AE_INFO, Status,
"Invoked method did not return a value"));
}
ACPI_EXCEPTION ((AE_INFO, Status, "GetPredicate Failed"));
return_ACPI_STATUS (Status);
}
Status = AcpiPsNextParseState (WalkState, Op, Status);
}
AcpiPsPopScope (ParserState, &Op,
&WalkState->ArgTypes, &WalkState->ArgCount);
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped scope, Op=%p\n", Op));
}
else if (WalkState->PrevOp)
{
/* We were in the middle of an op */
Op = WalkState->PrevOp;
WalkState->ArgTypes = WalkState->PrevArgTypes;
}
}
#endif
/* Iterative parsing loop, while there is more AML to process: */
while ((ParserState->Aml < ParserState->AmlEnd) || (Op))
{
AmlOpStart = ParserState->Aml;
if (!Op)
{
Status = AcpiPsCreateOp (WalkState, AmlOpStart, &Op);
if (ACPI_FAILURE (Status))
{
if (Status == AE_CTRL_PARSE_CONTINUE)
{
continue;
}
if (Status == AE_CTRL_PARSE_PENDING)
{
Status = AE_OK;
}
Status = AcpiPsCompleteOp (WalkState, &Op, Status);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
continue;
}
Op->Common.AmlOffset = WalkState->AmlOffset;
if (WalkState->OpInfo)
{
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Opcode %4.4X [%s] Op %p Aml %p AmlOffset %5.5X\n",
(UINT32) Op->Common.AmlOpcode, WalkState->OpInfo->Name,
Op, ParserState->Aml, Op->Common.AmlOffset));
}
}
/*
* Start ArgCount at zero because we don't know if there are
* any args yet
*/
WalkState->ArgCount = 0;
/* Are there any arguments that must be processed? */
if (WalkState->ArgTypes)
{
/* Get arguments */
Status = AcpiPsGetArguments (WalkState, AmlOpStart, Op);
if (ACPI_FAILURE (Status))
{
Status = AcpiPsCompleteOp (WalkState, &Op, Status);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
continue;
}
}
/* Check for arguments that need to be processed */
if (WalkState->ArgCount)
{
/*
* There are arguments (complex ones), push Op and
* prepare for argument
*/
Status = AcpiPsPushScope (ParserState, Op,
WalkState->ArgTypes, WalkState->ArgCount);
if (ACPI_FAILURE (Status))
{
Status = AcpiPsCompleteOp (WalkState, &Op, Status);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
continue;
}
Op = NULL;
continue;
}
/*
* All arguments have been processed -- Op is complete,
* prepare for next
*/
WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
if (WalkState->OpInfo->Flags & AML_NAMED)
{
if (AcpiGbl_Depth)
{
AcpiGbl_Depth--;
}
if (Op->Common.AmlOpcode == AML_REGION_OP ||
Op->Common.AmlOpcode == AML_DATA_REGION_OP)
{
/*
* Skip parsing of control method or opregion body,
* because we don't have enough info in the first pass
* to parse them correctly.
*
* Completed parsing an OpRegion declaration, we now
* know the length.
*/
Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
}
}
if (WalkState->OpInfo->Flags & AML_CREATE)
{
/*
* Backup to beginning of CreateXXXfield declaration (1 for
* Opcode)
*
* BodyLength is unknown until we parse the body
*/
Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
}
if (Op->Common.AmlOpcode == AML_BANK_FIELD_OP)
{
/*
* Backup to beginning of BankField declaration
*
* BodyLength is unknown until we parse the body
*/
Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
}
/* This op complete, notify the dispatcher */
if (WalkState->AscendingCallback != NULL)
{
WalkState->Op = Op;
WalkState->Opcode = Op->Common.AmlOpcode;
Status = WalkState->AscendingCallback (WalkState);
Status = AcpiPsNextParseState (WalkState, Op, Status);
if (Status == AE_CTRL_PENDING)
{
Status = AE_OK;
}
}
Status = AcpiPsCompleteOp (WalkState, &Op, Status);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
} /* while ParserState->Aml */
Status = AcpiPsCompleteFinalOp (WalkState, Op, Status);
return_ACPI_STATUS (Status);
}
static ACPI_STATUS
AcpiPsBuildNamedOp (
ACPI_WALK_STATE *WalkState,
UINT8 *AmlOpStart,
ACPI_PARSE_OBJECT *UnnamedOp,
ACPI_PARSE_OBJECT **Op)
{
ACPI_STATUS Status = AE_OK;
ACPI_PARSE_OBJECT *Arg = NULL;
ACPI_FUNCTION_TRACE_PTR (PsBuildNamedOp, WalkState);
UnnamedOp->Common.Value.Arg = NULL;
UnnamedOp->Common.ArgListLength = 0;
UnnamedOp->Common.AmlOpcode = WalkState->Opcode;
/*
* Get and append arguments until we find the node that contains
* the name (the type ARGP_NAME).
*/
while (GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) &&
(GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) != ARGP_NAME))
{
Status = AcpiPsGetNextArg (WalkState, &(WalkState->ParserState),
GET_CURRENT_ARG_TYPE (WalkState->ArgTypes), &Arg);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
AcpiPsAppendArg (UnnamedOp, Arg);
INCREMENT_ARG_LIST (WalkState->ArgTypes);
}
/*
* Make sure that we found a NAME and didn't run out of arguments
*/
if (!GET_CURRENT_ARG_TYPE (WalkState->ArgTypes))
{
return_ACPI_STATUS (AE_AML_NO_OPERAND);
}
/* We know that this arg is a name, move to next arg */
INCREMENT_ARG_LIST (WalkState->ArgTypes);
/*
* Find the object. This will either insert the object into
* the namespace or simply look it up
*/
WalkState->Op = NULL;
Status = WalkState->DescendingCallback (WalkState, Op);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status, "During name lookup/catalog"));
return_ACPI_STATUS (Status);
}
if (!*Op)
{
return_ACPI_STATUS (AE_CTRL_PARSE_CONTINUE);
}
Status = AcpiPsNextParseState (WalkState, *Op, Status);
if (ACPI_FAILURE (Status))
{
if (Status == AE_CTRL_PENDING)
{
return_ACPI_STATUS (AE_CTRL_PARSE_PENDING);
}
return_ACPI_STATUS (Status);
}
AcpiPsAppendArg (*Op, UnnamedOp->Common.Value.Arg);
AcpiGbl_Depth++;
if ((*Op)->Common.AmlOpcode == AML_REGION_OP ||
(*Op)->Common.AmlOpcode == AML_DATA_REGION_OP)
{
/*
* Defer final parsing of an OperationRegion body, because we don't
* have enough info in the first pass to parse it correctly (i.e.,
* there may be method calls within the TermArg elements of the body.)
*
* However, we must continue parsing because the opregion is not a
* standalone package -- we don't know where the end is at this point.
*
* (Length is unknown until parse of the body complete)
*/
(*Op)->Named.Data = AmlOpStart;
(*Op)->Named.Length = 0;
}
return_ACPI_STATUS (AE_OK);
}
ACPI_STATUS
AcpiPsCompleteFinalOp (
ACPI_WALK_STATE *WalkState,
ACPI_PARSE_OBJECT *Op,
ACPI_STATUS Status)
{
ACPI_STATUS Status2;
ACPI_FUNCTION_TRACE_PTR (PsCompleteFinalOp, WalkState);
/*
* Complete the last Op (if not completed), and clear the scope stack.
* It is easily possible to end an AML "package" with an unbounded number
* of open scopes (such as when several ASL blocks are closed with
* sequential closing braces). We want to terminate each one cleanly.
*/
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "AML package complete at Op %p\n", Op));
do
{
if (Op)
{
if (WalkState->AscendingCallback != NULL)
{
WalkState->Op = Op;
WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
WalkState->Opcode = Op->Common.AmlOpcode;
Status = WalkState->AscendingCallback (WalkState);
Status = AcpiPsNextParseState (WalkState, Op, Status);
if (Status == AE_CTRL_PENDING)
{
Status = AcpiPsCompleteOp (WalkState, &Op, AE_OK);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
if (Status == AE_CTRL_TERMINATE)
{
Status = AE_OK;
/* Clean up */
do
{
if (Op)
{
Status2 = AcpiPsCompleteThisOp (WalkState, Op);
if (ACPI_FAILURE (Status2))
{
return_ACPI_STATUS (Status2);
}
}
AcpiPsPopScope (&(WalkState->ParserState), &Op,
&WalkState->ArgTypes, &WalkState->ArgCount);
} while (Op);
return_ACPI_STATUS (Status);
}
else if (ACPI_FAILURE (Status))
{
/* First error is most important */
(void) AcpiPsCompleteThisOp (WalkState, Op);
return_ACPI_STATUS (Status);
}
}
Status2 = AcpiPsCompleteThisOp (WalkState, Op);
if (ACPI_FAILURE (Status2))
{
return_ACPI_STATUS (Status2);
}
}
AcpiPsPopScope (&(WalkState->ParserState), &Op, &WalkState->ArgTypes,
&WalkState->ArgCount);
} while (Op);
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiPsCompleteOp (
ACPI_WALK_STATE *WalkState,
ACPI_PARSE_OBJECT **Op,
ACPI_STATUS Status)
{
ACPI_STATUS Status2;
ACPI_FUNCTION_TRACE_PTR (PsCompleteOp, WalkState);
/*
* Finished one argument of the containing scope
*/
WalkState->ParserState.Scope->ParseScope.ArgCount--;
/* Close this Op (will result in parse subtree deletion) */
Status2 = AcpiPsCompleteThisOp (WalkState, *Op);
if (ACPI_FAILURE (Status2))
{
return_ACPI_STATUS (Status2);
}
*Op = NULL;
switch (Status)
{
case AE_OK:
break;
case AE_CTRL_TRANSFER:
/* We are about to transfer to a called method */
WalkState->PrevOp = NULL;
WalkState->PrevArgTypes = WalkState->ArgTypes;
return_ACPI_STATUS (Status);
case AE_CTRL_END:
AcpiPsPopScope (&(WalkState->ParserState), Op,
&WalkState->ArgTypes, &WalkState->ArgCount);
if (*Op)
{
WalkState->Op = *Op;
WalkState->OpInfo = AcpiPsGetOpcodeInfo ((*Op)->Common.AmlOpcode);
WalkState->Opcode = (*Op)->Common.AmlOpcode;
Status = WalkState->AscendingCallback (WalkState);
Status = AcpiPsNextParseState (WalkState, *Op, Status);
Status2 = AcpiPsCompleteThisOp (WalkState, *Op);
if (ACPI_FAILURE (Status2))
{
return_ACPI_STATUS (Status2);
}
}
Status = AE_OK;
break;
case AE_CTRL_BREAK:
case AE_CTRL_CONTINUE:
/* Pop off scopes until we find the While */
while (!(*Op) || ((*Op)->Common.AmlOpcode != AML_WHILE_OP))
{
AcpiPsPopScope (&(WalkState->ParserState), Op,
&WalkState->ArgTypes, &WalkState->ArgCount);
}
/* Close this iteration of the While loop */
WalkState->Op = *Op;
WalkState->OpInfo = AcpiPsGetOpcodeInfo ((*Op)->Common.AmlOpcode);
WalkState->Opcode = (*Op)->Common.AmlOpcode;
Status = WalkState->AscendingCallback (WalkState);
Status = AcpiPsNextParseState (WalkState, *Op, Status);
Status2 = AcpiPsCompleteThisOp (WalkState, *Op);
if (ACPI_FAILURE (Status2))
{
return_ACPI_STATUS (Status2);
}
Status = AE_OK;
break;
case AE_CTRL_TERMINATE:
/* Clean up */
do
{
if (*Op)
{
Status2 = AcpiPsCompleteThisOp (WalkState, *Op);
if (ACPI_FAILURE (Status2))
{
return_ACPI_STATUS (Status2);
}
AcpiUtDeleteGenericState (
AcpiUtPopGenericState (&WalkState->ControlState));
}
AcpiPsPopScope (&(WalkState->ParserState), Op,
&WalkState->ArgTypes, &WalkState->ArgCount);
} while (*Op);
return_ACPI_STATUS (AE_OK);
default: /* All other non-AE_OK status */
do
{
if (*Op)
{
Status2 = AcpiPsCompleteThisOp (WalkState, *Op);
if (ACPI_FAILURE (Status2))
{
return_ACPI_STATUS (Status2);
}
}
AcpiPsPopScope (&(WalkState->ParserState), Op,
&WalkState->ArgTypes, &WalkState->ArgCount);
} while (*Op);
#if 0
/*
* TBD: Cleanup parse ops on error
*/
if (*Op == NULL)
{
AcpiPsPopScope (ParserState, Op,
&WalkState->ArgTypes, &WalkState->ArgCount);
}
#endif
WalkState->PrevOp = NULL;
WalkState->PrevArgTypes = WalkState->ArgTypes;
return_ACPI_STATUS (Status);
}
/* This scope complete? */
if (AcpiPsHasCompletedScope (&(WalkState->ParserState)))
{
AcpiPsPopScope (&(WalkState->ParserState), Op,
&WalkState->ArgTypes, &WalkState->ArgCount);
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped scope, Op=%p\n", *Op));
}
else
{
*Op = NULL;
}
return_ACPI_STATUS (AE_OK);
}
ACPI_STATUS
AcpiPsParseLoop (
ACPI_WALK_STATE *WalkState)
{
ACPI_STATUS Status = AE_OK;
ACPI_PARSE_OBJECT *Op = NULL; /* current op */
const ACPI_OPCODE_INFO *OpInfo;
ACPI_PARSE_OBJECT *Arg = NULL;
ACPI_PARSE2_OBJECT *DeferredOp;
UINT32 ArgCount; /* push for fixed or var args */
UINT32 ArgTypes = 0;
UINT32 AmlOffset;
UINT16 Opcode;
ACPI_PARSE_OBJECT PreOp;
ACPI_PARSE_STATE *ParserState;
UINT8 *AmlOpStart;
FUNCTION_TRACE_PTR ("PsParseLoop", WalkState);
ParserState = WalkState->ParserState;
#ifndef PARSER_ONLY
if (WalkState->WalkType & WALK_METHOD_RESTART)
{
/* We are restarting a preempted control method */
if (AcpiPsHasCompletedScope (ParserState))
{
/*
* We must check if a predicate to an IF or WHILE statement
* was just completed
*/
if ((ParserState->Scope->ParseScope.Op) &&
((ParserState->Scope->ParseScope.Op->Opcode == AML_IF_OP) ||
(ParserState->Scope->ParseScope.Op->Opcode == AML_WHILE_OP)) &&
(WalkState->ControlState) &&
(WalkState->ControlState->Common.State ==
CONTROL_PREDICATE_EXECUTING))
{
/*
* A predicate was just completed, get the value of the
* predicate and branch based on that value
*/
Status = AcpiDsGetPredicateValue (WalkState, NULL, TRUE);
if (ACPI_FAILURE (Status) &&
((Status & AE_CODE_MASK) != AE_CODE_CONTROL))
{
if (Status == AE_AML_NO_RETURN_VALUE)
{
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Invoked method did not return a value, %s\n",
AcpiFormatException (Status)));
}
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "GetPredicate Failed, %s\n",
AcpiFormatException (Status)));
return_ACPI_STATUS (Status);
}
Status = AcpiPsNextParseState (WalkState, Op, Status);
}
AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount);
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped scope, Op=%p\n", Op));
}
else if (WalkState->PrevOp)
{
/* We were in the middle of an op */
Op = WalkState->PrevOp;
ArgTypes = WalkState->PrevArgTypes;
}
}
#endif
/*
* Iterative parsing loop, while there is more aml to process:
*/
while ((ParserState->Aml < ParserState->AmlEnd) || (Op))
{
if (!Op)
{
/* Get the next opcode from the AML stream */
AmlOpStart = ParserState->Aml;
AmlOffset = ParserState->Aml - ParserState->AmlStart;
Opcode = AcpiPsPeekOpcode (ParserState);
/*
* First cut to determine what we have found:
* 1) A valid AML opcode
* 2) A name string
* 3) An unknown/invalid opcode
*/
OpInfo = AcpiPsGetOpcodeInfo (Opcode);
switch (ACPI_GET_OP_TYPE (OpInfo))
{
case ACPI_OP_TYPE_OPCODE:
/* Found opcode info, this is a normal opcode */
ParserState->Aml += AcpiPsGetOpcodeSize (Opcode);
ArgTypes = OpInfo->ParseArgs;
break;
case ACPI_OP_TYPE_ASCII:
case ACPI_OP_TYPE_PREFIX:
/*
* Starts with a valid prefix or ASCII char, this is a name
* string. Convert the bare name string to a namepath.
*/
Opcode = AML_INT_NAMEPATH_OP;
ArgTypes = ARGP_NAMESTRING;
break;
case ACPI_OP_TYPE_UNKNOWN:
/* The opcode is unrecognized. Just skip unknown opcodes */
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Found unknown opcode %lX at AML offset %X, ignoring\n",
Opcode, AmlOffset));
DUMP_BUFFER (ParserState->Aml, 128);
/* Assume one-byte bad opcode */
ParserState->Aml++;
continue;
}
/* Create Op structure and append to parent's argument list */
if (OpInfo->Flags & AML_NAMED)
{
PreOp.Value.Arg = NULL;
PreOp.Opcode = Opcode;
while (GET_CURRENT_ARG_TYPE (ArgTypes) != ARGP_NAME)
{
Arg = AcpiPsGetNextArg (ParserState,
GET_CURRENT_ARG_TYPE (ArgTypes),
&ArgCount);
AcpiPsAppendArg (&PreOp, Arg);
INCREMENT_ARG_LIST (ArgTypes);
}
/* We know that this arg is a name, move to next arg */
INCREMENT_ARG_LIST (ArgTypes);
if (WalkState->DescendingCallback != NULL)
{
/*
* Find the object. This will either insert the object into
* the namespace or simply look it up
*/
Status = WalkState->DescendingCallback (Opcode, NULL, WalkState, &Op);
if (Op == NULL)
{
continue;
}
Status = AcpiPsNextParseState (WalkState, Op, Status);
if (Status == AE_CTRL_PENDING)
{
Status = AE_OK;
goto CloseThisOp;
}
if (ACPI_FAILURE (Status))
{
goto CloseThisOp;
}
}
AcpiPsAppendArg (Op, PreOp.Value.Arg);
AcpiGbl_Depth++;
if (Op->Opcode == AML_REGION_OP)
{
DeferredOp = (ACPI_PARSE2_OBJECT *) Op;
/*
* Defer final parsing of an OperationRegion body,
* because we don't have enough info in the first pass
* to parse it correctly (i.e., there may be method
* calls within the TermArg elements of the body.
*
* However, we must continue parsing because
* the opregion is not a standalone package --
* we don't know where the end is at this point.
*
* (Length is unknown until parse of the body complete)
*/
DeferredOp->Data = AmlOpStart;
DeferredOp->Length = 0;
}
}
else
{
/* Not a named opcode, just allocate Op and append to parent */
OpInfo = AcpiPsGetOpcodeInfo (Opcode);
Op = AcpiPsAllocOp (Opcode);
if (!Op)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
if (OpInfo->Flags & AML_CREATE)
{
/*
* Backup to beginning of CreateXXXfield declaration
* BodyLength is unknown until we parse the body
*/
DeferredOp = (ACPI_PARSE2_OBJECT *) Op;
DeferredOp->Data = AmlOpStart;
DeferredOp->Length = 0;
}
AcpiPsAppendArg (AcpiPsGetParentScope (ParserState), Op);
if ((WalkState->DescendingCallback != NULL))
{
/*
* Find the object. This will either insert the object into
* the namespace or simply look it up
*/
Status = WalkState->DescendingCallback (Opcode, Op, WalkState, &Op);
Status = AcpiPsNextParseState (WalkState, Op, Status);
if (Status == AE_CTRL_PENDING)
{
Status = AE_OK;
goto CloseThisOp;
}
if (ACPI_FAILURE (Status))
{
goto CloseThisOp;
}
}
}
Op->AmlOffset = AmlOffset;
if (OpInfo)
{
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Op=%p Opcode=%4.4lX Aml %p Oft=%5.5lX\n",
Op, Op->Opcode, ParserState->Aml, Op->AmlOffset));
}
}
/* Start ArgCount at zero because we don't know if there are any args yet */
ArgCount = 0;
if (ArgTypes) /* Are there any arguments that must be processed? */
{
/* get arguments */
switch (Op->Opcode)
{
case AML_BYTE_OP: /* AML_BYTEDATA_ARG */
case AML_WORD_OP: /* AML_WORDDATA_ARG */
case AML_DWORD_OP: /* AML_DWORDATA_ARG */
case AML_QWORD_OP: /* AML_QWORDATA_ARG */
case AML_STRING_OP: /* AML_ASCIICHARLIST_ARG */
/* fill in constant or string argument directly */
AcpiPsGetNextSimpleArg (ParserState,
GET_CURRENT_ARG_TYPE (ArgTypes), Op);
break;
case AML_INT_NAMEPATH_OP: /* AML_NAMESTRING_ARG */
AcpiPsGetNextNamepath (ParserState, Op, &ArgCount, 1);
ArgTypes = 0;
break;
default:
/* Op is not a constant or string, append each argument */
while (GET_CURRENT_ARG_TYPE (ArgTypes) && !ArgCount)
{
AmlOffset = ParserState->Aml - ParserState->AmlStart;
Arg = AcpiPsGetNextArg (ParserState,
GET_CURRENT_ARG_TYPE (ArgTypes),
&ArgCount);
if (Arg)
{
Arg->AmlOffset = AmlOffset;
AcpiPsAppendArg (Op, Arg);
}
INCREMENT_ARG_LIST (ArgTypes);
}
/* For a method, save the length and address of the body */
if (Op->Opcode == AML_METHOD_OP)
{
DeferredOp = (ACPI_PARSE2_OBJECT *) Op;
/*
* Skip parsing of control method or opregion body,
* because we don't have enough info in the first pass
* to parse them correctly.
*/
DeferredOp->Data = ParserState->Aml;
DeferredOp->Length = (UINT32) (ParserState->PkgEnd -
ParserState->Aml);
/*
* Skip body of method. For OpRegions, we must continue
* parsing because the opregion is not a standalone
* package (We don't know where the end is).
*/
ParserState->Aml = ParserState->PkgEnd;
ArgCount = 0;
}
break;
}
}
/*
* Zero ArgCount means that all arguments for this op have been processed
*/
if (!ArgCount)
{
/* completed Op, prepare for next */
OpInfo = AcpiPsGetOpcodeInfo (Op->Opcode);
if (OpInfo->Flags & AML_NAMED)
{
if (AcpiGbl_Depth)
{
AcpiGbl_Depth--;
}
if (Op->Opcode == AML_REGION_OP)
{
DeferredOp = (ACPI_PARSE2_OBJECT *) Op;
/*
* Skip parsing of control method or opregion body,
* because we don't have enough info in the first pass
* to parse them correctly.
*
* Completed parsing an OpRegion declaration, we now
* know the length.
*/
DeferredOp->Length = (UINT32) (ParserState->Aml -
DeferredOp->Data);
}
}
if (OpInfo->Flags & AML_CREATE)
{
/*
* Backup to beginning of CreateXXXfield declaration (1 for
* Opcode)
*
* BodyLength is unknown until we parse the body
*/
DeferredOp = (ACPI_PARSE2_OBJECT *) Op;
DeferredOp->Length = (UINT32) (ParserState->Aml -
DeferredOp->Data);
}
/* This op complete, notify the dispatcher */
if (WalkState->AscendingCallback != NULL)
{
Status = WalkState->AscendingCallback (WalkState, Op);
Status = AcpiPsNextParseState (WalkState, Op, Status);
if (Status == AE_CTRL_PENDING)
{
Status = AE_OK;
goto CloseThisOp;
}
}
CloseThisOp:
/*
* Finished one argument of the containing scope
*/
ParserState->Scope->ParseScope.ArgCount--;
/* Close this Op (may result in parse subtree deletion) */
if (AcpiPsCompleteThisOp (WalkState, Op))
{
Op = NULL;
}
switch (Status)
{
case AE_OK:
break;
case AE_CTRL_TRANSFER:
/*
* We are about to transfer to a called method.
*/
WalkState->PrevOp = Op;
WalkState->PrevArgTypes = ArgTypes;
return_ACPI_STATUS (Status);
break;
case AE_CTRL_END:
AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount);
Status = WalkState->AscendingCallback (WalkState, Op);
Status = AcpiPsNextParseState (WalkState, Op, Status);
AcpiPsCompleteThisOp (WalkState, Op);
Op = NULL;
Status = AE_OK;
break;
case AE_CTRL_TERMINATE:
Status = AE_OK;
/* Clean up */
do
{
if (Op)
{
AcpiPsCompleteThisOp (WalkState, Op);
}
AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount);
} while (Op);
return_ACPI_STATUS (Status);
break;
default: /* All other non-AE_OK status */
if (Op == NULL)
{
AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount);
}
WalkState->PrevOp = Op;
WalkState->PrevArgTypes = ArgTypes;
/*
* TEMP:
*/
return_ACPI_STATUS (Status);
break;
}
/* This scope complete? */
if (AcpiPsHasCompletedScope (ParserState))
{
AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount);
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped scope, Op=%p\n", Op));
}
else
{
Op = NULL;
}
}
/* ArgCount is non-zero */
else
{
/* complex argument, push Op and prepare for argument */
AcpiPsPushScope (ParserState, Op, ArgTypes, ArgCount);
Op = NULL;
}
} /* while ParserState->Aml */
/*
* Complete the last Op (if not completed), and clear the scope stack.
* It is easily possible to end an AML "package" with an unbounded number
* of open scopes (such as when several AML blocks are closed with
* sequential closing braces). We want to terminate each one cleanly.
*/
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Package complete at Op %p\n", Op));
do
{
if (Op)
{
if (WalkState->AscendingCallback != NULL)
{
Status = WalkState->AscendingCallback (WalkState, Op);
Status = AcpiPsNextParseState (WalkState, Op, Status);
if (Status == AE_CTRL_PENDING)
{
Status = AE_OK;
goto CloseThisOp;
}
if (Status == AE_CTRL_TERMINATE)
{
Status = AE_OK;
/* Clean up */
do
{
if (Op)
{
AcpiPsCompleteThisOp (WalkState, Op);
}
AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount);
} while (Op);
return_ACPI_STATUS (Status);
}
else if (ACPI_FAILURE (Status))
{
AcpiPsCompleteThisOp (WalkState, Op);
return_ACPI_STATUS (Status);
}
}
AcpiPsCompleteThisOp (WalkState, Op);
}
AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount);
} while (Op);
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiPsParseLoop (
ACPI_WALK_STATE *WalkState)
{
ACPI_STATUS Status = AE_OK;
ACPI_PARSE_OBJECT *Op = NULL; /* current op */
ACPI_PARSE_STATE *ParserState;
UINT8 *AmlOpStart = NULL;
ACPI_FUNCTION_TRACE_PTR (PsParseLoop, WalkState);
if (WalkState->DescendingCallback == NULL)
{
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
ParserState = &WalkState->ParserState;
WalkState->ArgTypes = 0;
#if (!defined (ACPI_NO_METHOD_EXECUTION) && !defined (ACPI_CONSTANT_EVAL_ONLY))
if (WalkState->WalkType & ACPI_WALK_METHOD_RESTART)
{
/* We are restarting a preempted control method */
if (AcpiPsHasCompletedScope (ParserState))
{
/*
* We must check if a predicate to an IF or WHILE statement
* was just completed
*/
if ((ParserState->Scope->ParseScope.Op) &&
((ParserState->Scope->ParseScope.Op->Common.AmlOpcode == AML_IF_OP) ||
(ParserState->Scope->ParseScope.Op->Common.AmlOpcode == AML_WHILE_OP)) &&
(WalkState->ControlState) &&
(WalkState->ControlState->Common.State ==
ACPI_CONTROL_PREDICATE_EXECUTING))
{
/*
* A predicate was just completed, get the value of the
* predicate and branch based on that value
*/
WalkState->Op = NULL;
Status = AcpiDsGetPredicateValue (WalkState, ACPI_TO_POINTER (TRUE));
if (ACPI_FAILURE (Status) &&
((Status & AE_CODE_MASK) != AE_CODE_CONTROL))
{
if (Status == AE_AML_NO_RETURN_VALUE)
{
ACPI_EXCEPTION ((AE_INFO, Status,
"Invoked method did not return a value"));
}
ACPI_EXCEPTION ((AE_INFO, Status, "GetPredicate Failed"));
return_ACPI_STATUS (Status);
}
Status = AcpiPsNextParseState (WalkState, Op, Status);
}
AcpiPsPopScope (ParserState, &Op,
&WalkState->ArgTypes, &WalkState->ArgCount);
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped scope, Op=%p\n", Op));
}
else if (WalkState->PrevOp)
{
/* We were in the middle of an op */
Op = WalkState->PrevOp;
WalkState->ArgTypes = WalkState->PrevArgTypes;
}
}
#endif
/* Iterative parsing loop, while there is more AML to process: */
while ((ParserState->Aml < ParserState->AmlEnd) || (Op))
{
ASL_CV_CAPTURE_COMMENTS (WalkState);
AmlOpStart = ParserState->Aml;
if (!Op)
{
Status = AcpiPsCreateOp (WalkState, AmlOpStart, &Op);
if (ACPI_FAILURE (Status))
{
/*
* ACPI_PARSE_MODULE_LEVEL means that we are loading a table by
* executing it as a control method. However, if we encounter
* an error while loading the table, we need to keep trying to
* load the table rather than aborting the table load. Set the
* status to AE_OK to proceed with the table load.
*/
if ((WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL) &&
Status == AE_ALREADY_EXISTS)
{
Status = AE_OK;
}
if (Status == AE_CTRL_PARSE_CONTINUE)
{
continue;
}
if (Status == AE_CTRL_PARSE_PENDING)
{
Status = AE_OK;
}
if (Status == AE_CTRL_TERMINATE)
{
return_ACPI_STATUS (Status);
}
Status = AcpiPsCompleteOp (WalkState, &Op, Status);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
if (AcpiNsOpensScope (
AcpiPsGetOpcodeInfo (WalkState->Opcode)->ObjectType))
{
/*
* If the scope/device op fails to parse, skip the body of
* the scope op because the parse failure indicates that
* the device may not exist.
*/
ACPI_ERROR ((AE_INFO, "Skip parsing opcode %s",
AcpiPsGetOpcodeName (WalkState->Opcode)));
WalkState->ParserState.Aml = WalkState->Aml + 1;
WalkState->ParserState.Aml =
AcpiPsGetNextPackageEnd(&WalkState->ParserState);
WalkState->Aml = WalkState->ParserState.Aml;
}
continue;
}
AcpiExStartTraceOpcode (Op, WalkState);
}
/*
* Start ArgCount at zero because we don't know if there are
* any args yet
*/
WalkState->ArgCount = 0;
switch (Op->Common.AmlOpcode)
{
case AML_BYTE_OP:
case AML_WORD_OP:
case AML_DWORD_OP:
case AML_QWORD_OP:
break;
default:
ASL_CV_CAPTURE_COMMENTS (WalkState);
break;
}
/* Are there any arguments that must be processed? */
if (WalkState->ArgTypes)
{
/* Get arguments */
Status = AcpiPsGetArguments (WalkState, AmlOpStart, Op);
if (ACPI_FAILURE (Status))
{
Status = AcpiPsCompleteOp (WalkState, &Op, Status);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
if ((WalkState->ControlState) &&
((WalkState->ControlState->Control.Opcode == AML_IF_OP) ||
(WalkState->ControlState->Control.Opcode == AML_WHILE_OP)))
{
/*
* If the if/while op fails to parse, we will skip parsing
* the body of the op.
*/
ParserState->Aml =
WalkState->ControlState->Control.AmlPredicateStart + 1;
ParserState->Aml =
AcpiPsGetNextPackageEnd (ParserState);
WalkState->Aml = ParserState->Aml;
ACPI_ERROR ((AE_INFO, "Skipping While/If block"));
if (*WalkState->Aml == AML_ELSE_OP)
{
ACPI_ERROR ((AE_INFO, "Skipping Else block"));
WalkState->ParserState.Aml = WalkState->Aml + 1;
WalkState->ParserState.Aml =
AcpiPsGetNextPackageEnd (ParserState);
WalkState->Aml = ParserState->Aml;
}
ACPI_FREE(AcpiUtPopGenericState (&WalkState->ControlState));
}
Op = NULL;
continue;
}
}
/* Check for arguments that need to be processed */
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Parseloop: argument count: %8.8X\n", WalkState->ArgCount));
if (WalkState->ArgCount)
{
/*
* There are arguments (complex ones), push Op and
* prepare for argument
*/
Status = AcpiPsPushScope (ParserState, Op,
WalkState->ArgTypes, WalkState->ArgCount);
if (ACPI_FAILURE (Status))
{
Status = AcpiPsCompleteOp (WalkState, &Op, Status);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
continue;
}
Op = NULL;
continue;
}
/*
* All arguments have been processed -- Op is complete,
* prepare for next
*/
WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
if (WalkState->OpInfo->Flags & AML_NAMED)
{
if (Op->Common.AmlOpcode == AML_REGION_OP ||
Op->Common.AmlOpcode == AML_DATA_REGION_OP)
{
/*
* Skip parsing of control method or opregion body,
* because we don't have enough info in the first pass
* to parse them correctly.
*
* Completed parsing an OpRegion declaration, we now
* know the length.
*/
Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
}
}
if (WalkState->OpInfo->Flags & AML_CREATE)
{
/*
* Backup to beginning of CreateXXXfield declaration (1 for
* Opcode)
*
* BodyLength is unknown until we parse the body
*/
Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
}
if (Op->Common.AmlOpcode == AML_BANK_FIELD_OP)
{
/*
* Backup to beginning of BankField declaration
*
* BodyLength is unknown until we parse the body
*/
Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
}
/* This op complete, notify the dispatcher */
if (WalkState->AscendingCallback != NULL)
{
WalkState->Op = Op;
WalkState->Opcode = Op->Common.AmlOpcode;
Status = WalkState->AscendingCallback (WalkState);
Status = AcpiPsNextParseState (WalkState, Op, Status);
if (Status == AE_CTRL_PENDING)
{
Status = AE_OK;
}
else if ((WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL) &&
(ACPI_AML_EXCEPTION(Status) || Status == AE_ALREADY_EXISTS ||
Status == AE_NOT_FOUND))
{
/*
* ACPI_PARSE_MODULE_LEVEL flag means that we are currently
* loading a table by executing it as a control method.
* However, if we encounter an error while loading the table,
* we need to keep trying to load the table rather than
* aborting the table load (setting the status to AE_OK
* continues the table load). If we get a failure at this
* point, it means that the dispatcher got an error while
* trying to execute the Op.
*/
Status = AE_OK;
}
}
Status = AcpiPsCompleteOp (WalkState, &Op, Status);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
} /* while ParserState->Aml */
Status = AcpiPsCompleteFinalOp (WalkState, Op, Status);
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiPsCreateOp (
ACPI_WALK_STATE *WalkState,
UINT8 *AmlOpStart,
ACPI_PARSE_OBJECT **NewOp)
{
ACPI_STATUS Status = AE_OK;
ACPI_PARSE_OBJECT *Op;
ACPI_PARSE_OBJECT *NamedOp = NULL;
ACPI_PARSE_OBJECT *ParentScope;
UINT8 ArgumentCount;
const ACPI_OPCODE_INFO *OpInfo;
ACPI_FUNCTION_TRACE_PTR (PsCreateOp, WalkState);
Status = AcpiPsGetAmlOpcode (WalkState);
if (Status == AE_CTRL_PARSE_CONTINUE)
{
return_ACPI_STATUS (AE_CTRL_PARSE_CONTINUE);
}
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Create Op structure and append to parent's argument list */
WalkState->OpInfo = AcpiPsGetOpcodeInfo (WalkState->Opcode);
Op = AcpiPsAllocOp (WalkState->Opcode, AmlOpStart);
if (!Op)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
if (WalkState->OpInfo->Flags & AML_NAMED)
{
Status = AcpiPsBuildNamedOp (WalkState, AmlOpStart, Op, &NamedOp);
AcpiPsFreeOp (Op);
#ifdef ACPI_ASL_COMPILER
if (AcpiGbl_DisasmFlag && WalkState->Opcode == AML_EXTERNAL_OP &&
Status == AE_NOT_FOUND)
{
/*
* If parsing of AML_EXTERNAL_OP's name path fails, then skip
* past this opcode and keep parsing. This is a much better
* alternative than to abort the entire disassembler. At this
* point, the ParserState is at the end of the namepath of the
* external declaration opcode. Setting WalkState->Aml to
* WalkState->ParserState.Aml + 2 moves increments the
* WalkState->Aml past the object type and the paramcount of the
* external opcode.
*/
WalkState->Aml = WalkState->ParserState.Aml + 2;
WalkState->ParserState.Aml = WalkState->Aml;
return_ACPI_STATUS (AE_CTRL_PARSE_CONTINUE);
}
#endif
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
*NewOp = NamedOp;
return_ACPI_STATUS (AE_OK);
}
/* Not a named opcode, just allocate Op and append to parent */
if (WalkState->OpInfo->Flags & AML_CREATE)
{
/*
* Backup to beginning of CreateXXXfield declaration
* BodyLength is unknown until we parse the body
*/
Op->Named.Data = AmlOpStart;
Op->Named.Length = 0;
}
if (WalkState->Opcode == AML_BANK_FIELD_OP)
{
/*
* Backup to beginning of BankField declaration
* BodyLength is unknown until we parse the body
*/
Op->Named.Data = AmlOpStart;
Op->Named.Length = 0;
}
ParentScope = AcpiPsGetParentScope (&(WalkState->ParserState));
AcpiPsAppendArg (ParentScope, Op);
if (ParentScope)
{
OpInfo = AcpiPsGetOpcodeInfo (ParentScope->Common.AmlOpcode);
if (OpInfo->Flags & AML_HAS_TARGET)
{
ArgumentCount = AcpiPsGetArgumentCount (OpInfo->Type);
if (ParentScope->Common.ArgListLength > ArgumentCount)
{
Op->Common.Flags |= ACPI_PARSEOP_TARGET;
}
}
/*
* Special case for both Increment() and Decrement(), where
* the lone argument is both a source and a target.
*/
else if ((ParentScope->Common.AmlOpcode == AML_INCREMENT_OP) ||
(ParentScope->Common.AmlOpcode == AML_DECREMENT_OP))
{
Op->Common.Flags |= ACPI_PARSEOP_TARGET;
}
}
if (WalkState->DescendingCallback != NULL)
{
/*
* Find the object. This will either insert the object into
* the namespace or simply look it up
*/
WalkState->Op = *NewOp = Op;
Status = WalkState->DescendingCallback (WalkState, &Op);
Status = AcpiPsNextParseState (WalkState, Op, Status);
if (Status == AE_CTRL_PENDING)
{
Status = AE_CTRL_PARSE_PENDING;
}
}
return_ACPI_STATUS (Status);
}
