acpi_status
acpi_ps_build_named_op(struct acpi_walk_state *walk_state,
u8 *aml_op_start,
union acpi_parse_object *unnamed_op,
union acpi_parse_object **op)
{
acpi_status status = AE_OK;
union acpi_parse_object *arg = NULL;
ACPI_FUNCTION_TRACE_PTR(ps_build_named_op, walk_state);
unnamed_op->common.value.arg = NULL;
unnamed_op->common.arg_list_length = 0;
unnamed_op->common.aml_opcode = walk_state->opcode;
/*
* Get and append arguments until we find the node that contains
* the name (the type ARGP_NAME).
*/
while (GET_CURRENT_ARG_TYPE(walk_state->arg_types) &&
(GET_CURRENT_ARG_TYPE(walk_state->arg_types) != ARGP_NAME)) {
ASL_CV_CAPTURE_COMMENTS(walk_state);
status =
acpi_ps_get_next_arg(walk_state,
&(walk_state->parser_state),
GET_CURRENT_ARG_TYPE(walk_state->
arg_types), &arg);
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
acpi_ps_append_arg(unnamed_op, arg);
INCREMENT_ARG_LIST(walk_state->arg_types);
}
/* are there any inline comments associated with the name_seg?? If so, save this. */
ASL_CV_CAPTURE_COMMENTS(walk_state);
#ifdef ACPI_ASL_COMPILER
if (acpi_gbl_current_inline_comment != NULL) {
unnamed_op->common.name_comment =
acpi_gbl_current_inline_comment;
acpi_gbl_current_inline_comment = NULL;
}
#endif
/*
* Make sure that we found a NAME and didn't run out of arguments
*/
if (!GET_CURRENT_ARG_TYPE(walk_state->arg_types)) {
return_ACPI_STATUS(AE_AML_NO_OPERAND);
}
/* We know that this arg is a name, move to next arg */
INCREMENT_ARG_LIST(walk_state->arg_types);
/*
* Find the object. This will either insert the object into
* the namespace or simply look it up
*/
walk_state->op = NULL;
status = walk_state->descending_callback(walk_state, op);
if (ACPI_FAILURE(status)) {
if (status != AE_CTRL_TERMINATE) {
ACPI_EXCEPTION((AE_INFO, status,
"During name lookup/catalog"));
}
return_ACPI_STATUS(status);
}
if (!*op) {
return_ACPI_STATUS(AE_CTRL_PARSE_CONTINUE);
}
status = acpi_ps_next_parse_state(walk_state, *op, status);
if (ACPI_FAILURE(status)) {
if (status == AE_CTRL_PENDING) {
status = AE_CTRL_PARSE_PENDING;
}
return_ACPI_STATUS(status);
}
acpi_ps_append_arg(*op, unnamed_op->common.value.arg);
#ifdef ACPI_ASL_COMPILER
/* save any comments that might be associated with unnamed_op. */
(*op)->common.inline_comment = unnamed_op->common.inline_comment;
(*op)->common.end_node_comment = unnamed_op->common.end_node_comment;
(*op)->common.close_brace_comment =
unnamed_op->common.close_brace_comment;
(*op)->common.name_comment = unnamed_op->common.name_comment;
(*op)->common.comment_list = unnamed_op->common.comment_list;
(*op)->common.end_blk_comment = unnamed_op->common.end_blk_comment;
(*op)->common.cv_filename = unnamed_op->common.cv_filename;
(*op)->common.cv_parent_filename =
unnamed_op->common.cv_parent_filename;
(*op)->named.aml = unnamed_op->common.aml;
unnamed_op->common.inline_comment = NULL;
unnamed_op->common.end_node_comment = NULL;
unnamed_op->common.close_brace_comment = NULL;
unnamed_op->common.name_comment = NULL;
unnamed_op->common.comment_list = NULL;
unnamed_op->common.end_blk_comment = NULL;
#endif
if ((*op)->common.aml_opcode == AML_REGION_OP ||
(*op)->common.aml_opcode == AML_DATA_REGION_OP) {
/*
* Defer final parsing of an operation_region 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 term_arg 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 = aml_op_start;
(*op)->named.length = 0;
}
return_ACPI_STATUS(AE_OK);
}
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))
{
ASL_CV_CAPTURE_COMMENTS (WalkState);
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);
}
/* are there any inline comments associated with the NameSeg?? If so, save this. */
ASL_CV_CAPTURE_COMMENTS (WalkState);
#ifdef ACPI_ASL_COMPILER
if (AcpiGbl_CurrentInlineComment != NULL)
{
UnnamedOp->Common.NameComment = AcpiGbl_CurrentInlineComment;
AcpiGbl_CurrentInlineComment = NULL;
}
#endif
/*
* 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))
{
if (Status != AE_CTRL_TERMINATE)
{
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)
{
Status = AE_CTRL_PARSE_PENDING;
}
return_ACPI_STATUS (Status);
}
AcpiPsAppendArg (*Op, UnnamedOp->Common.Value.Arg);
#ifdef ACPI_ASL_COMPILER
/* save any comments that might be associated with UnnamedOp. */
(*Op)->Common.InlineComment = UnnamedOp->Common.InlineComment;
(*Op)->Common.EndNodeComment = UnnamedOp->Common.EndNodeComment;
(*Op)->Common.CloseBraceComment = UnnamedOp->Common.CloseBraceComment;
(*Op)->Common.NameComment = UnnamedOp->Common.NameComment;
(*Op)->Common.CommentList = UnnamedOp->Common.CommentList;
(*Op)->Common.EndBlkComment = UnnamedOp->Common.EndBlkComment;
(*Op)->Common.CvFilename = UnnamedOp->Common.CvFilename;
(*Op)->Common.CvParentFilename = UnnamedOp->Common.CvParentFilename;
(*Op)->Named.Aml = UnnamedOp->Common.Aml;
UnnamedOp->Common.InlineComment = NULL;
UnnamedOp->Common.EndNodeComment = NULL;
UnnamedOp->Common.CloseBraceComment = NULL;
UnnamedOp->Common.NameComment = NULL;
UnnamedOp->Common.CommentList = NULL;
UnnamedOp->Common.EndBlkComment = NULL;
#endif
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);
}
static ACPI_STATUS
AcpiPsGetArguments (
ACPI_WALK_STATE *WalkState,
UINT8 *AmlOpStart,
ACPI_PARSE_OBJECT *Op)
{
ACPI_STATUS Status = AE_OK;
ACPI_PARSE_OBJECT *Arg = NULL;
const ACPI_OPCODE_INFO *OpInfo;
ACPI_FUNCTION_TRACE_PTR (PsGetArguments, WalkState);
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Get arguments for opcode [%s]\n", Op->Common.AmlOpName));
switch (Op->Common.AmlOpcode)
{
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 (&(WalkState->ParserState),
GET_CURRENT_ARG_TYPE (WalkState->ArgTypes), Op);
break;
case AML_INT_NAMEPATH_OP: /* AML_NAMESTRING_ARG */
Status = AcpiPsGetNextNamepath (WalkState,
&(WalkState->ParserState), Op, ACPI_POSSIBLE_METHOD_CALL);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
WalkState->ArgTypes = 0;
break;
default:
/*
* Op is not a constant or string, append each argument to the Op
*/
while (GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) &&
!WalkState->ArgCount)
{
WalkState->Aml = WalkState->ParserState.Aml;
switch (Op->Common.AmlOpcode)
{
case AML_METHOD_OP:
case AML_BUFFER_OP:
case AML_PACKAGE_OP:
case AML_VARIABLE_PACKAGE_OP:
case AML_WHILE_OP:
break;
default:
ASL_CV_CAPTURE_COMMENTS (WalkState);
break;
}
Status = AcpiPsGetNextArg (WalkState, &(WalkState->ParserState),
GET_CURRENT_ARG_TYPE (WalkState->ArgTypes), &Arg);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
if (Arg)
{
AcpiPsAppendArg (Op, Arg);
}
INCREMENT_ARG_LIST (WalkState->ArgTypes);
}
/*
* Handle executable code at "module-level". This refers to
* executable opcodes that appear outside of any control method.
*/
if ((WalkState->PassNumber <= ACPI_IMODE_LOAD_PASS2) &&
((WalkState->ParseFlags & ACPI_PARSE_DISASSEMBLE) == 0))
{
/*
* We want to skip If/Else/While constructs during Pass1 because we
* want to actually conditionally execute the code during Pass2.
*
* Except for disassembly, where we always want to walk the
* If/Else/While packages
*/
switch (Op->Common.AmlOpcode)
{
case AML_IF_OP:
case AML_ELSE_OP:
case AML_WHILE_OP:
/*
* Currently supported module-level opcodes are:
* IF/ELSE/WHILE. These appear to be the most common,
* and easiest to support since they open an AML
* package.
*/
if (WalkState->PassNumber == ACPI_IMODE_LOAD_PASS1)
{
AcpiPsLinkModuleCode (Op->Common.Parent, AmlOpStart,
(UINT32) (WalkState->ParserState.PkgEnd - AmlOpStart),
WalkState->OwnerId);
}
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Pass1: Skipping an If/Else/While body\n"));
/* Skip body of if/else/while in pass 1 */
WalkState->ParserState.Aml = WalkState->ParserState.PkgEnd;
WalkState->ArgCount = 0;
break;
default:
/*
* Check for an unsupported executable opcode at module
* level. We must be in PASS1, the parent must be a SCOPE,
* The opcode class must be EXECUTE, and the opcode must
* not be an argument to another opcode.
*/
if ((WalkState->PassNumber == ACPI_IMODE_LOAD_PASS1) &&
(Op->Common.Parent->Common.AmlOpcode == AML_SCOPE_OP))
{
OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
if ((OpInfo->Class == AML_CLASS_EXECUTE) &&
(!Arg))
{
ACPI_WARNING ((AE_INFO,
"Unsupported module-level executable opcode "
"0x%.2X at table offset 0x%.4X",
Op->Common.AmlOpcode,
(UINT32) (ACPI_PTR_DIFF (AmlOpStart,
WalkState->ParserState.AmlStart) +
sizeof (ACPI_TABLE_HEADER))));
}
}
break;
}
}
/* Special processing for certain opcodes */
switch (Op->Common.AmlOpcode)
{
case AML_METHOD_OP:
/*
* Skip parsing of control method because we don't have enough
* info in the first pass to parse it correctly.
*
* Save the length and address of the body
*/
Op->Named.Data = WalkState->ParserState.Aml;
Op->Named.Length = (UINT32)
(WalkState->ParserState.PkgEnd - WalkState->ParserState.Aml);
/* Skip body of method */
WalkState->ParserState.Aml = WalkState->ParserState.PkgEnd;
WalkState->ArgCount = 0;
break;
case AML_BUFFER_OP:
case AML_PACKAGE_OP:
case AML_VARIABLE_PACKAGE_OP:
if ((Op->Common.Parent) &&
(Op->Common.Parent->Common.AmlOpcode == AML_NAME_OP) &&
(WalkState->PassNumber <= ACPI_IMODE_LOAD_PASS2))
{
/*
* Skip parsing of Buffers and Packages because we don't have
* enough info in the first pass to parse them correctly.
*/
Op->Named.Data = AmlOpStart;
Op->Named.Length = (UINT32)
(WalkState->ParserState.PkgEnd - AmlOpStart);
/* Skip body */
WalkState->ParserState.Aml = WalkState->ParserState.PkgEnd;
WalkState->ArgCount = 0;
}
break;
case AML_WHILE_OP:
if (WalkState->ControlState)
{
WalkState->ControlState->Control.PackageEnd =
WalkState->ParserState.PkgEnd;
}
break;
default:
/* No action for all other opcodes */
break;
}
break;
}
return_ACPI_STATUS (AE_OK);
}
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))
{
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);
}
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);
}
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 (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);
}
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);
}
