Quest Cross Reference 0.1.0/​kernel/​drivers/​acpica/​dsutils.c	Source navigation Diff markup Identifier search General search
	Version: 0.1.0 experimental Revert   Change

Warning, cross-references for /kernel/drivers/acpica/dsutils.c need to be fixed.

 /*******************************************************************************
  *
  * Module Name: dsutils - Dispatcher utilities
  *
  ******************************************************************************/
 
 /******************************************************************************
  *
  * 1. Copyright Notice
  *
  * Some or all of this work - Copyright (c) 1999 - 2009, Intel Corp.
  * All rights reserved.
  *
  * 2. License
  *
  * 2.1. This is your license from Intel Corp. under its intellectual property
  * rights.  You may have additional license terms from the party that provided
  * you this software, covering your right to use that party's intellectual
  * property rights.
  *
  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  * copy of the source code appearing in this file ("Covered Code") an
  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  * base code distributed originally by Intel ("Original Intel Code") to copy,
  * make derivatives, distribute, use and display any portion of the Covered
  * Code in any form, with the right to sublicense such rights; and
  *
  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  * license (with the right to sublicense), under only those claims of Intel
  * patents that are infringed by the Original Intel Code, to make, use, sell,
  * offer to sell, and import the Covered Code and derivative works thereof
  * solely to the minimum extent necessary to exercise the above copyright
  * license, and in no event shall the patent license extend to any additions
  * to or modifications of the Original Intel Code.  No other license or right
  * is granted directly or by implication, estoppel or otherwise;
  *
  * The above copyright and patent license is granted only if the following
  * conditions are met:
  *
  * 3. Conditions
  *
  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  * Redistribution of source code of any substantial portion of the Covered
  * Code or modification with rights to further distribute source must include
  * the above Copyright Notice, the above License, this list of Conditions,
  * and the following Disclaimer and Export Compliance provision.  In addition,
  * Licensee must cause all Covered Code to which Licensee contributes to
  * contain a file documenting the changes Licensee made to create that Covered
  * Code and the date of any change.  Licensee must include in that file the
  * documentation of any changes made by any predecessor Licensee.  Licensee
  * must include a prominent statement that the modification is derived,
  * directly or indirectly, from Original Intel Code.
  *
  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  * Redistribution of source code of any substantial portion of the Covered
  * Code or modification without rights to further distribute source must
  * include the following Disclaimer and Export Compliance provision in the
  * documentation and/or other materials provided with distribution.  In
  * addition, Licensee may not authorize further sublicense of source of any
  * portion of the Covered Code, and must include terms to the effect that the
  * license from Licensee to its licensee is limited to the intellectual
  * property embodied in the software Licensee provides to its licensee, and
  * not to intellectual property embodied in modifications its licensee may
  * make.
  *
  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  * substantial portion of the Covered Code or modification must reproduce the
  * above Copyright Notice, and the following Disclaimer and Export Compliance
  * provision in the documentation and/or other materials provided with the
  * distribution.
  *
  * 3.4. Intel retains all right, title, and interest in and to the Original
  * Intel Code.
  *
  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  * Intel shall be used in advertising or otherwise to promote the sale, use or
  * other dealings in products derived from or relating to the Covered Code
  * without prior written authorization from Intel.
  *
  * 4. Disclaimer and Export Compliance
  *
  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  * PARTICULAR PURPOSE.
  *
  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  * LIMITED REMEDY.
  *
  * 4.3. Licensee shall not export, either directly or indirectly, any of this
  * software or system incorporating such software without first obtaining any
  * required license or other approval from the U. S. Department of Commerce or
  * any other agency or department of the United States Government.  In the
  * event Licensee exports any such software from the United States or
  * re-exports any such software from a foreign destination, Licensee shall
  * ensure that the distribution and export/re-export of the software is in
  * compliance with all laws, regulations, orders, or other restrictions of the
  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
  * any of its subsidiaries will export/re-export any technical data, process,
  * software, or service, directly or indirectly, to any country for which the
  * United States government or any agency thereof requires an export license,
  * other governmental approval, or letter of assurance, without first obtaining
  * such license, approval or letter.
  *
  *****************************************************************************/
 
 #define __DSUTILS_C__
 
 #include "acpi.h"
 #include "accommon.h"
 #include "acparser.h"
 #include "amlcode.h"
 #include "acdispat.h"
 #include "acinterp.h"
 #include "acnamesp.h"
 #include "acdebug.h"
 
 #define _COMPONENT          ACPI_DISPATCHER
         ACPI_MODULE_NAME    ("dsutils")
 
 
 /*******************************************************************************
  *
  * FUNCTION:    AcpiDsClearImplicitReturn
  *
  * PARAMETERS:  WalkState           - Current State
  *
  * RETURN:      None.
  *
  * DESCRIPTION: Clear and remove a reference on an implicit return value.  Used
  *              to delete "stale" return values (if enabled, the return value
  *              from every operator is saved at least momentarily, in case the
  *              parent method exits.)
  *
  ******************************************************************************/
 
 void
 AcpiDsClearImplicitReturn (
     ACPI_WALK_STATE         *WalkState)
 {
     ACPI_FUNCTION_NAME (DsClearImplicitReturn);
 
 
     /*
      * Slack must be enabled for this feature
      */
     if (!AcpiGbl_EnableInterpreterSlack)
     {
         return;
     }
 
     if (WalkState->ImplicitReturnObj)
     {
         /*
          * Delete any "stale" implicit return. However, in
          * complex statements, the implicit return value can be
          * bubbled up several levels.
          */
         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
             "Removing reference on stale implicit return obj %p\n",
             WalkState->ImplicitReturnObj));
 
         AcpiUtRemoveReference (WalkState->ImplicitReturnObj);
         WalkState->ImplicitReturnObj = NULL;
     }
 }
 
 
 #ifndef ACPI_NO_METHOD_EXECUTION
 /*******************************************************************************
  *
  * FUNCTION:    AcpiDsDoImplicitReturn
  *
  * PARAMETERS:  ReturnDesc          - The return value
  *              WalkState           - Current State
  *              AddReference        - True if a reference should be added to the
  *                                    return object
  *
  * RETURN:      TRUE if implicit return enabled, FALSE otherwise
  *
  * DESCRIPTION: Implements the optional "implicit return".  We save the result
  *              of every ASL operator and control method invocation in case the
  *              parent method exit.  Before storing a new return value, we
  *              delete the previous return value.
  *
  ******************************************************************************/
 
 BOOLEAN
 AcpiDsDoImplicitReturn (
     ACPI_OPERAND_OBJECT     *ReturnDesc,
     ACPI_WALK_STATE         *WalkState,
     BOOLEAN                 AddReference)
 {
     ACPI_FUNCTION_NAME (DsDoImplicitReturn);
 
 
     /*
      * Slack must be enabled for this feature, and we must
      * have a valid return object
      */
     if ((!AcpiGbl_EnableInterpreterSlack) ||
         (!ReturnDesc))
     {
         return (FALSE);
     }
 
     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
             "Result %p will be implicitly returned; Prev=%p\n",
             ReturnDesc,
             WalkState->ImplicitReturnObj));
 
     /*
      * Delete any "stale" implicit return value first. However, in
      * complex statements, the implicit return value can be
      * bubbled up several levels, so we don't clear the value if it
      * is the same as the ReturnDesc.
      */
     if (WalkState->ImplicitReturnObj)
     {
         if (WalkState->ImplicitReturnObj == ReturnDesc)
         {
             return (TRUE);
         }
         AcpiDsClearImplicitReturn (WalkState);
     }
 
     /* Save the implicit return value, add a reference if requested */
 
     WalkState->ImplicitReturnObj = ReturnDesc;
     if (AddReference)
     {
         AcpiUtAddReference (ReturnDesc);
     }
 
     return (TRUE);
 }
 
 
 /*******************************************************************************
  *
  * FUNCTION:    AcpiDsIsResultUsed
  *
  * PARAMETERS:  Op                  - Current Op
  *              WalkState           - Current State
  *
  * RETURN:      TRUE if result is used, FALSE otherwise
  *
  * DESCRIPTION: Check if a result object will be used by the parent
  *
  ******************************************************************************/
 
 BOOLEAN
 AcpiDsIsResultUsed (
     ACPI_PARSE_OBJECT       *Op,
     ACPI_WALK_STATE         *WalkState)
 {
     const ACPI_OPCODE_INFO  *ParentInfo;
 
     ACPI_FUNCTION_TRACE_PTR (DsIsResultUsed, Op);
 
 
     /* Must have both an Op and a Result Object */
 
     if (!Op)
     {
         ACPI_ERROR ((AE_INFO, "Null Op"));
         return_UINT8 (TRUE);
     }
 
     /*
      * We know that this operator is not a
      * Return() operator (would not come here.) The following code is the
      * optional support for a so-called "implicit return". Some AML code
      * assumes that the last value of the method is "implicitly" returned
      * to the caller. Just save the last result as the return value.
      * NOTE: this is optional because the ASL language does not actually
      * support this behavior.
      */
     (void) AcpiDsDoImplicitReturn (WalkState->ResultObj, WalkState, TRUE);
 
     /*
      * Now determine if the parent will use the result
      *
      * If there is no parent, or the parent is a ScopeOp, we are executing
      * at the method level. An executing method typically has no parent,
      * since each method is parsed separately.  A method invoked externally
      * via ExecuteControlMethod has a ScopeOp as the parent.
      */
     if ((!Op->Common.Parent) ||
         (Op->Common.Parent->Common.AmlOpcode == AML_SCOPE_OP))
     {
         /* No parent, the return value cannot possibly be used */
 
         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
             "At Method level, result of [%s] not used\n",
             AcpiPsGetOpcodeName (Op->Common.AmlOpcode)));
         return_UINT8 (FALSE);
     }
 
     /* Get info on the parent. The RootOp is AML_SCOPE */
 
     ParentInfo = AcpiPsGetOpcodeInfo (Op->Common.Parent->Common.AmlOpcode);
     if (ParentInfo->Class == AML_CLASS_UNKNOWN)
     {
         ACPI_ERROR ((AE_INFO,
             "Unknown parent opcode Op=%p", Op));
         return_UINT8 (FALSE);
     }
 
     /*
      * Decide what to do with the result based on the parent.  If
      * the parent opcode will not use the result, delete the object.
      * Otherwise leave it as is, it will be deleted when it is used
      * as an operand later.
      */
     switch (ParentInfo->Class)
     {
     case AML_CLASS_CONTROL:
 
         switch (Op->Common.Parent->Common.AmlOpcode)
         {
         case AML_RETURN_OP:
 
             /* Never delete the return value associated with a return opcode */
 
             goto ResultUsed;
 
         case AML_IF_OP:
         case AML_WHILE_OP:
 
             /*
              * If we are executing the predicate AND this is the predicate op,
              * we will use the return value
              */
             if ((WalkState->ControlState->Common.State == ACPI_CONTROL_PREDICATE_EXECUTING) &&
                 (WalkState->ControlState->Control.PredicateOp == Op))
             {
                 goto ResultUsed;
             }
             break;
 
         default:
             /* Ignore other control opcodes */
             break;
         }
 
         /* The general control opcode returns no result */
 
         goto ResultNotUsed;
 
 
     case AML_CLASS_CREATE:
 
         /*
          * These opcodes allow TermArg(s) as operands and therefore
          * the operands can be method calls.  The result is used.
          */
         goto ResultUsed;
 
 
     case AML_CLASS_NAMED_OBJECT:
 
         if ((Op->Common.Parent->Common.AmlOpcode == AML_REGION_OP)       ||
             (Op->Common.Parent->Common.AmlOpcode == AML_DATA_REGION_OP)  ||
             (Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP)      ||
             (Op->Common.Parent->Common.AmlOpcode == AML_VAR_PACKAGE_OP)  ||
             (Op->Common.Parent->Common.AmlOpcode == AML_BUFFER_OP)       ||
             (Op->Common.Parent->Common.AmlOpcode == AML_INT_EVAL_SUBTREE_OP) ||
             (Op->Common.Parent->Common.AmlOpcode == AML_BANK_FIELD_OP))
         {
             /*
              * These opcodes allow TermArg(s) as operands and therefore
              * the operands can be method calls.  The result is used.
              */
             goto ResultUsed;
         }
 
         goto ResultNotUsed;
 
 
     default:
 
         /*
          * In all other cases. the parent will actually use the return
          * object, so keep it.
          */
         goto ResultUsed;
     }
 
 
 ResultUsed:
     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
         "Result of [%s] used by Parent [%s] Op=%p\n",
         AcpiPsGetOpcodeName (Op->Common.AmlOpcode),
         AcpiPsGetOpcodeName (Op->Common.Parent->Common.AmlOpcode), Op));
 
     return_UINT8 (TRUE);
 
 
 ResultNotUsed:
     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
         "Result of [%s] not used by Parent [%s] Op=%p\n",
         AcpiPsGetOpcodeName (Op->Common.AmlOpcode),
         AcpiPsGetOpcodeName (Op->Common.Parent->Common.AmlOpcode), Op));
 
     return_UINT8 (FALSE);
 }
 
 
 /*******************************************************************************
  *
  * FUNCTION:    AcpiDsDeleteResultIfNotUsed
  *
  * PARAMETERS:  Op              - Current parse Op
  *              ResultObj       - Result of the operation
  *              WalkState       - Current state
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Used after interpretation of an opcode.  If there is an internal
  *              result descriptor, check if the parent opcode will actually use
  *              this result.  If not, delete the result now so that it will
  *              not become orphaned.
  *
  ******************************************************************************/
 
 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;
 }
 
 
 /*******************************************************************************
  *
  * FUNCTION:    AcpiDsResolveOperands
  *
  * PARAMETERS:  WalkState           - Current walk state with operands on stack
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Resolve all operands to their values.  Used to prepare
  *              arguments to a control method invocation (a call from one
  *              method to another.)
  *
  ******************************************************************************/
 
 ACPI_STATUS
 AcpiDsResolveOperands (
     ACPI_WALK_STATE         *WalkState)
 {
     UINT32                  i;
     ACPI_STATUS             Status = AE_OK;
 
 
     ACPI_FUNCTION_TRACE_PTR (DsResolveOperands, WalkState);
 
 
     /*
      * Attempt to resolve each of the valid operands
      * Method arguments are passed by reference, not by value.  This means
      * that the actual objects are passed, not copies of the objects.
      */
     for (i = 0; i < WalkState->NumOperands; i++)
     {
         Status = AcpiExResolveToValue (&WalkState->Operands[i], WalkState);
         if (ACPI_FAILURE (Status))
         {
             break;
         }
     }
 
     return_ACPI_STATUS (Status);
 }
 
 
 /*******************************************************************************
  *
  * FUNCTION:    AcpiDsClearOperands
  *
  * PARAMETERS:  WalkState           - Current walk state with operands on stack
  *
  * RETURN:      None
  *
  * DESCRIPTION: Clear all operands on the current walk state operand stack.
  *
  ******************************************************************************/
 
 void
 AcpiDsClearOperands (
     ACPI_WALK_STATE         *WalkState)
 {
     UINT32                  i;
 
 
     ACPI_FUNCTION_TRACE_PTR (DsClearOperands, WalkState);
 
 
     /* Remove a reference on each operand on the stack */
 
     for (i = 0; i < WalkState->NumOperands; i++)
     {
         /*
          * Remove a reference to all operands, including both
          * "Arguments" and "Targets".
          */
         AcpiUtRemoveReference (WalkState->Operands[i]);
         WalkState->Operands[i] = NULL;
     }
 
     WalkState->NumOperands = 0;
     return_VOID;
 }
 #endif
 
 
 /*******************************************************************************
  *
  * FUNCTION:    AcpiDsCreateOperand
  *
  * PARAMETERS:  WalkState       - Current walk state
  *              Arg             - Parse object for the argument
  *              ArgIndex        - Which argument (zero based)
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Translate a parse tree object that is an argument to an AML
  *              opcode to the equivalent interpreter object.  This may include
  *              looking up a name or entering a new name into the internal
  *              namespace.
  *
  ******************************************************************************/
 
 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);
 }
 
 
 /*******************************************************************************
  *
  * FUNCTION:    AcpiDsCreateOperands
  *
  * PARAMETERS:  WalkState           - Current state
  *              FirstArg            - First argument of a parser argument tree
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Convert an operator's arguments from a parse tree format to
  *              namespace objects and place those argument object on the object
  *              stack in preparation for evaluation by the interpreter.
  *
  ******************************************************************************/
 
 ACPI_STATUS
 AcpiDsCreateOperands (
     ACPI_WALK_STATE         *WalkState,
     ACPI_PARSE_OBJECT       *FirstArg)
 {
     ACPI_STATUS             Status = AE_OK;
     ACPI_PARSE_OBJECT       *Arg;
     ACPI_PARSE_OBJECT       *Arguments[ACPI_OBJ_NUM_OPERANDS];
     UINT32                  ArgCount = 0;
     UINT32                  Index = WalkState->NumOperands;
     UINT32                  i;
 
 
     ACPI_FUNCTION_TRACE_PTR (DsCreateOperands, FirstArg);
 
 
     /* Get all arguments in the list */
 
     Arg = FirstArg;
     while (Arg)
     {
         if (Index >= ACPI_OBJ_NUM_OPERANDS)
         {
             return_ACPI_STATUS (AE_BAD_DATA);
         }
 
         Arguments[Index] = Arg;
         WalkState->Operands [Index] = NULL;
 
         /* Move on to next argument, if any */
 
         Arg = Arg->Common.Next;
         ArgCount++;
         Index++;
     }
 
     Index--;
 
     /* It is the appropriate order to get objects from the Result stack */
 
     for (i = 0; i < ArgCount; i++)
     {
         Arg = Arguments[Index];
 
         /* Force the filling of the operand stack in inverse order */
 
         WalkState->OperandIndex = (UINT8) Index;
 
         Status = AcpiDsCreateOperand (WalkState, Arg, Index);
         if (ACPI_FAILURE (Status))
         {
             goto Cleanup;
         }
 
         Index--;
 
         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Arg #%d (%p) done, Arg1=%p\n",
             Index, Arg, FirstArg));
     }
 
     return_ACPI_STATUS (Status);
 
 
 Cleanup:
     /*
      * We must undo everything done above; meaning that we must
      * pop everything off of the operand stack and delete those
      * objects
      */
     AcpiDsObjStackPopAndDelete (ArgCount, WalkState);
 
     ACPI_EXCEPTION ((AE_INFO, Status, "While creating Arg %d", Index));
     return_ACPI_STATUS (Status);
 }
 
 
 /*****************************************************************************
  *
  * FUNCTION:    AcpiDsEvaluateNamePath
  *
  * PARAMETERS:  WalkState       - Current state of the parse tree walk,
  *                                the opcode of current operation should be
  *                                AML_INT_NAMEPATH_OP
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Translate the -NamePath- parse tree object to the equivalent
  *              interpreter object, convert it to value, if needed, duplicate
  *              it, if needed, and push it onto the current result stack.
  *
  ****************************************************************************/
 
 ACPI_STATUS
 AcpiDsEvaluateNamePath (
     ACPI_WALK_STATE         *WalkState)
 {
     ACPI_STATUS             Status = AE_OK;
     ACPI_PARSE_OBJECT       *Op = WalkState->Op;
     ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
     ACPI_OPERAND_OBJECT     *NewObjDesc;
     UINT8                   Type;
 
 
     ACPI_FUNCTION_TRACE_PTR (DsEvaluateNamePath, WalkState);
 
 
     if (!Op->Common.Parent)
     {
         /* This happens after certain exception processing */
 
         goto Exit;
     }
 
     if ((Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
         (Op->Common.Parent->Common.AmlOpcode == AML_VAR_PACKAGE_OP) ||
         (Op->Common.Parent->Common.AmlOpcode == AML_REF_OF_OP))
     {
         /* TBD: Should we specify this feature as a bit of OpInfo->Flags of these opcodes? */
 
         goto Exit;
     }
 
     Status = AcpiDsCreateOperand (WalkState, Op, 0);
     if (ACPI_FAILURE (Status))
     {
         goto Exit;
     }
 
     if (Op->Common.Flags & ACPI_PARSEOP_TARGET)
     {
         NewObjDesc = *Operand;
         goto PushResult;
     }
 
     Type = (*Operand)->Common.Type;
 
     Status = AcpiExResolveToValue (Operand, WalkState);
     if (ACPI_FAILURE (Status))
     {
         goto Exit;
     }
 
     if (Type == ACPI_TYPE_INTEGER)
     {
         /* It was incremented by AcpiExResolveToValue */
 
         AcpiUtRemoveReference (*Operand);
 
         Status = AcpiUtCopyIobjectToIobject (*Operand, &NewObjDesc, WalkState);
         if (ACPI_FAILURE (Status))
         {
             goto Exit;
         }
     }
     else
     {
         /*
          * The object either was anew created or is
          * a Namespace node - don't decrement it.
          */
         NewObjDesc = *Operand;
     }
 
     /* Cleanup for name-path operand */
 
     Status = AcpiDsObjStackPop (1, WalkState);
     if (ACPI_FAILURE (Status))
     {
         WalkState->ResultObj = NewObjDesc;
         goto Exit;
     }
 
 PushResult:
 
     WalkState->ResultObj = NewObjDesc;
 
     Status = AcpiDsResultPush (WalkState->ResultObj, WalkState);
     if (ACPI_SUCCESS (Status))
     {
         /* Force to take it from stack */
 
         Op->Common.Flags |= ACPI_PARSEOP_IN_STACK;
     }
 
 Exit:
 
     return_ACPI_STATUS (Status);
 }