MFC: r284583, r285797, r285799, r287168, r298714, r298720, r298838,

r300879 Merge ACPICA up to 20160527. Requested by: mav
author: jkim <jkim@FreeBSD.org> 2016-09-30 22:40:58 +0000
committer: jkim <jkim@FreeBSD.org> 2016-09-30 22:40:58 +0000
commit: dba8c0a565199df70a86f6a036d00c92f0c7675f (patch)
tree: cf4924274c6e92898c01efb3c8ba31b34f0630f2 /sys/contrib/dev/acpica/compiler/aslxref.c
parent: 0f41551ef9dde560d9d191d7190af02904dbf611 (diff)
download: FreeBSD-src-dba8c0a565199df70a86f6a036d00c92f0c7675f.zip
FreeBSD-src-dba8c0a565199df70a86f6a036d00c92f0c7675f.tar.gz
1 files changed, 348 insertions, 172 deletions
diff --git a/sys/contrib/dev/acpica/compiler/aslxref.c b/sys/contrib/dev/acpica/compiler/aslxref.c
index cda7ccf..b09572e 100644
--- a/sys/contrib/dev/acpica/compiler/aslxref.c
+++ b/sys/contrib/dev/acpica/compiler/aslxref.c
@@ -5,7 +5,7 @@
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2015, Intel Corp.
+ * Copyright (C) 2000 - 2016, Intel Corp.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -66,6 +66,10 @@ XfNamespaceLocateEnd (
     UINT32                  Level,
     void                    *Context);
 
+static ACPI_PARSE_OBJECT *
+XfGetParentMethod (
+    ACPI_PARSE_OBJECT       *Op);
+
 static BOOLEAN
 XfObjectExists (
     char                    *Name);
@@ -129,8 +133,6 @@ XfCrossReferenceNamespace (
     ACPI_WALK_STATE         *WalkState;
 
 
-    DbgPrint (ASL_DEBUG_OUTPUT, "\nCross referencing namespace\n\n");
-
     /*
      * Create a new walk state for use when looking up names
      * within the namespace (Passed as context to the callbacks)
@@ -143,8 +145,8 @@ XfCrossReferenceNamespace (
 
     /* Walk the entire parse tree */
 
-    TrWalkParseTree (RootNode, ASL_WALK_VISIT_TWICE, XfNamespaceLocateBegin,
-                        XfNamespaceLocateEnd, WalkState);
+    TrWalkParseTree (Gbl_ParseTreeRoot, ASL_WALK_VISIT_TWICE,
+        XfNamespaceLocateBegin, XfNamespaceLocateEnd, WalkState);
 
     ACPI_FREE (WalkState);
     return (AE_OK);
@@ -173,8 +175,8 @@ XfObjectExists (
     /* Walk entire namespace from the supplied root */
 
     Status = AcpiNsWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
-                ACPI_UINT32_MAX, FALSE, XfCompareOneNamespaceObject, NULL,
-                Name, NULL);
+        ACPI_UINT32_MAX, FALSE, XfCompareOneNamespaceObject, NULL,
+        Name, NULL);
     if (Status == AE_CTRL_TRUE)
     {
         /* At least one instance of the name was found */
@@ -280,59 +282,16 @@ XfCheckFieldRange (
 }
 
 
-#ifdef __UNDER_DEVELOPMENT
-/*******************************************************************************
- *
- * FUNCTION:    XfIsObjectParental
- *
- * PARAMETERS:  ChildOp                 - Op to be checked
- *              PossibleParentOp        - Determine if this op is in the family
- *
- * RETURN:      TRUE if ChildOp is a descendent of PossibleParentOp
- *
- * DESCRIPTION: Determine if an Op is a descendent of another Op. Used to
- *              detect if a method is declared within another method.
- *
- ******************************************************************************/
-
-static BOOLEAN
-XfIsObjectParental (
-    ACPI_PARSE_OBJECT       *ChildOp,
-    ACPI_PARSE_OBJECT       *PossibleParentOp)
-{
-    ACPI_PARSE_OBJECT       *ParentOp;
-
-
-    /* Search upwards through the tree for possible parent */
-
-    ParentOp = ChildOp;
-    while (ParentOp)
-    {
-        if (ParentOp == PossibleParentOp)
-        {
-            return (TRUE);
-        }
-
-        ParentOp = ParentOp->Asl.Parent;
-    }
-
-    return (FALSE);
-}
-
-
 /*******************************************************************************
  *
  * FUNCTION:    XfGetParentMethod
  *
- * PARAMETERS:  Op                      - Op to be checked
+ * PARAMETERS:  Op                      - Parse Op to be checked
  *
- * RETURN:      Op for parent method. NULL if object is not within a method.
- *
- * DESCRIPTION: Determine if an object is within a control method. Used to
- *              implement special rules for named references from within a
- *              control method.
+ * RETURN:      Control method Op if found. NULL otherwise
  *
- * NOTE: It would be better to have the parser set a flag in the Op if possible.
+ * DESCRIPTION: Find the control method parent of a parse op. Returns NULL if
+ *              the input Op is not within a control method.
  *
  ******************************************************************************/
 
@@ -340,120 +299,22 @@ static ACPI_PARSE_OBJECT *
 XfGetParentMethod (
     ACPI_PARSE_OBJECT       *Op)
 {
-    ACPI_PARSE_OBJECT       *ParentOp;
-
-
-    if (!Op)
-    {
-        return (NULL);
-    }
-
-    if (Op->Asl.ParseOpcode == PARSEOP_METHOD)
-    {
-        return (NULL);
-    }
-
-    /* Walk upwards through the parse tree, up to the root if necessary */
-
-    ParentOp = Op;
-    while (ParentOp)
-    {
-        if (ParentOp->Asl.ParseOpcode == PARSEOP_METHOD)
-        {
-            return (ParentOp);
-        }
-
-        ParentOp = ParentOp->Asl.Parent;
-    }
-
-    /* Object is not within a method */
-
-    return (NULL);
-}
-
-
-/*******************************************************************************
- *
- * FUNCTION:    XfCheckIllegalReference
- *
- * PARAMETERS:  Op                      - Op referring to the target
- *              TargetNode              - Target of the reference
- *
- * RETURN:      None. Emits error message for an illegal reference
- *
- * DESCRIPTION: Determine if a named reference is legal. A "named" reference
- *              is something like: Store(ABCD, ...), where ABCD is an AML
- *              Nameseg or Namepath.
- *
- * NOTE: Caller must ensure that the name Op is in fact a reference, and not
- *       an actual name declaration (creation of a named object).
- *
- ******************************************************************************/
-
-static void
-XfCheckIllegalReference (
-    ACPI_PARSE_OBJECT       *Op,
-    ACPI_NAMESPACE_NODE     *TargetNode)
-{
-    ACPI_PARSE_OBJECT       *MethodOp1;
-    ACPI_PARSE_OBJECT       *MethodOp2;
-    ACPI_PARSE_OBJECT       *TargetOp;
-
-
-    /*
-     * Check for an illegal reference to a named object:
-     *
-     * 1) References from one control method to another, non-parent
-     *    method are not allowed, they will fail at runtime.
-     *
-     * 2) Forward references within a control method are not allowed.
-     *    AML interpreters use a one-pass parse of control methods
-     *    so these forward references will fail at runtime.
-     */
-    TargetOp = TargetNode->Op;
-
-    MethodOp1 = XfGetParentMethod (Op);
-    MethodOp2 = XfGetParentMethod (TargetOp);
-
-    /* Are both objects within control method(s)? */
-
-    if (!MethodOp1 || !MethodOp2)
-    {
-        return;
-    }
+    ACPI_PARSE_OBJECT       *NextOp;
 
-    /* Objects not in the same method? */
 
-    if (MethodOp1 != MethodOp2)
+    NextOp = Op->Asl.Parent;
+    while (NextOp)
     {
-        /*
-         * 1) Cross-method named reference
-         *
-         * This is OK if and only if the target reference is within in a
-         * method that is a parent of current method
-         */
-        if (!XfIsObjectParental (MethodOp1, MethodOp2))
+        if (NextOp->Asl.AmlOpcode == AML_METHOD_OP)
         {
-            AslError (ASL_ERROR, ASL_MSG_ILLEGAL_METHOD_REF, Op,
-                Op->Asl.ExternalName);
+            return (NextOp);
         }
-    }
 
-    /*
-     * 2) Both reference and target are in the same method. Check if this is
-     * an (illegal) forward reference by examining the exact source code
-     * location of each (the referenced object and the object declaration).
-     * This is a bit nasty, yet effective.
-     */
-    else if (Op->Asl.LogicalByteOffset < TargetOp->Asl.LogicalByteOffset)
-    {
-        AslError (ASL_ERROR, ASL_MSG_ILLEGAL_FORWARD_REF, Op,
-            Op->Asl.ExternalName);
+        NextOp = NextOp->Asl.Parent;
     }
 
+    return (NULL); /* No parent method found */
 }
-#endif
-
 
 /*******************************************************************************
  *
@@ -496,10 +357,67 @@ XfNamespaceLocateBegin (
     UINT8                   Message = 0;
     const ACPI_OPCODE_INFO  *OpInfo;
     UINT32                  Flags;
+    ASL_METHOD_LOCAL        *MethodLocals = NULL;
+    ASL_METHOD_LOCAL        *MethodArgs = NULL;
+    int                     RegisterNumber;
+    UINT32                  i;
 
 
     ACPI_FUNCTION_TRACE_PTR (XfNamespaceLocateBegin, Op);
 
+
+    if ((Op->Asl.AmlOpcode == AML_METHOD_OP) && Op->Asl.Node)
+    {
+        Node = Op->Asl.Node;
+
+        /* Support for method LocalX/ArgX analysis */
+
+        if (!Node->MethodLocals)
+        {
+            /* Create local/arg info blocks */
+
+            MethodLocals = UtLocalCalloc (
+                sizeof (ASL_METHOD_LOCAL) * ACPI_METHOD_NUM_LOCALS);
+            Node->MethodLocals = MethodLocals;
+
+            MethodArgs = UtLocalCalloc (
+                sizeof (ASL_METHOD_LOCAL) * ACPI_METHOD_NUM_ARGS);
+            Node->MethodArgs = MethodArgs;
+
+            /*
+             * Get the method argument count
+             * First, get the name node
+             */
+            NextOp = Op->Asl.Child;
+
+            /* Get the NumArguments node */
+
+            NextOp = NextOp->Asl.Next;
+            Node->ArgCount = (UINT8)
+                (((UINT8) NextOp->Asl.Value.Integer) & 0x07);
+
+            /* We will track all posible ArgXs */
+
+            for (i = 0; i < ACPI_METHOD_NUM_ARGS; i++)
+            {
+                if (i < Node->ArgCount)
+                {
+                    /* Real Args are always "initialized" */
+
+                    MethodArgs[i].Flags = ASL_ARG_INITIALIZED;
+                }
+                else
+                {
+                    /* Other ArgXs can be used as locals */
+
+                    MethodArgs[i].Flags = ASL_ARG_IS_LOCAL;
+                }
+
+                MethodArgs[i].Op = Op;
+            }
+        }
+    }
+
     /*
      * If this node is the actual declaration of a name
      * [such as the XXXX name in "Method (XXXX)"],
@@ -512,10 +430,88 @@ XfNamespaceLocateBegin (
         return_ACPI_STATUS (AE_OK);
     }
 
-    /* We are only interested in opcodes that have an associated name */
-
     OpInfo = AcpiPsGetOpcodeInfo (Op->Asl.AmlOpcode);
 
+    /* Check method LocalX variables */
+
+    if (OpInfo->Type == AML_TYPE_LOCAL_VARIABLE)
+    {
+        /* Find parent method Op */
+
+        NextOp = XfGetParentMethod (Op);
+        if (!NextOp)
+        {
+            return_ACPI_STATUS (AE_OK);
+        }
+
+        /* Get method node */
+
+        Node = NextOp->Asl.Node;
+
+        RegisterNumber = Op->Asl.AmlOpcode & 0x0007; /* 0x60 through 0x67 */
+        MethodLocals = Node->MethodLocals;
+
+        if (Op->Asl.CompileFlags & NODE_IS_TARGET)
+        {
+            /* Local is being initialized */
+
+            MethodLocals[RegisterNumber].Flags |= ASL_LOCAL_INITIALIZED;
+            MethodLocals[RegisterNumber].Op = Op;
+
+            return_ACPI_STATUS (AE_OK);
+        }
+
+        /* Mark this Local as referenced */
+
+        MethodLocals[RegisterNumber].Flags |= ASL_LOCAL_REFERENCED;
+        MethodLocals[RegisterNumber].Op = Op;
+
+        return_ACPI_STATUS (AE_OK);
+    }
+
+    /* Check method ArgX variables */
+
+    if (OpInfo->Type == AML_TYPE_METHOD_ARGUMENT)
+    {
+        /* Find parent method Op */
+
+        NextOp = XfGetParentMethod (Op);
+        if (!NextOp)
+        {
+            return_ACPI_STATUS (AE_OK);
+        }
+
+        /* Get method node */
+
+        Node = NextOp->Asl.Node;
+
+        /* Get Arg # */
+
+        RegisterNumber = Op->Asl.AmlOpcode - AML_ARG0; /* 0x68 through 0x6F */
+        MethodArgs = Node->MethodArgs;
+
+        if (Op->Asl.CompileFlags & NODE_IS_TARGET)
+        {
+            /* Arg is being initialized */
+
+            MethodArgs[RegisterNumber].Flags |= ASL_ARG_INITIALIZED;
+            MethodArgs[RegisterNumber].Op = Op;
+
+            return_ACPI_STATUS (AE_OK);
+        }
+
+        /* Mark this Arg as referenced */
+
+        MethodArgs[RegisterNumber].Flags |= ASL_ARG_REFERENCED;
+        MethodArgs[RegisterNumber].Op = Op;
+
+        return_ACPI_STATUS (AE_OK);
+    }
+
+    /*
+     * After method ArgX and LocalX, we are only interested in opcodes
+     * that have an associated name
+     */
     if ((!(OpInfo->Flags & AML_NAMED)) &&
         (!(OpInfo->Flags & AML_CREATE)) &&
         (Op->Asl.ParseOpcode != PARSEOP_NAMESTRING) &&
@@ -577,6 +573,7 @@ XfNamespaceLocateBegin (
         {
             NextOp = NextOp->Asl.Next;
         }
+
         Path = NextOp->Asl.Value.String;
     }
     else
@@ -598,7 +595,7 @@ XfNamespaceLocateBegin (
     Gbl_NsLookupCount++;
 
     Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
-                ACPI_IMODE_EXECUTE, Flags, WalkState, &(Node));
+        ACPI_IMODE_EXECUTE, Flags, WalkState, &(Node));
     if (ACPI_FAILURE (Status))
     {
         if (Status == AE_NOT_FOUND)
@@ -780,7 +777,8 @@ XfNamespaceLocateBegin (
 
             if (Message)
             {
-                sprintf (MsgBuffer, "Size mismatch, Tag: %u bit%s, Field: %u bit%s",
+                sprintf (MsgBuffer,
+                    "Size mismatch, Tag: %u bit%s, Field: %u bit%s",
                     TagBitLength, (TagBitLength > 1) ? "s" : "",
                     FieldBitLength, (FieldBitLength > 1) ? "s" : "");
 
@@ -849,7 +847,7 @@ XfNamespaceLocateBegin (
         if (Node->Type != ACPI_TYPE_METHOD)
         {
             sprintf (MsgBuffer, "%s is a %s",
-                    Op->Asl.ExternalName, AcpiUtGetTypeName (Node->Type));
+                Op->Asl.ExternalName, AcpiUtGetTypeName (Node->Type));
 
             AslError (ASL_ERROR, ASL_MSG_NOT_METHOD, Op, MsgBuffer);
             return_ACPI_STATUS (AE_OK);
@@ -872,7 +870,7 @@ XfNamespaceLocateBegin (
         UtSetParseOpName (Op);
 
         PassedArgs = 0;
-        NextOp     = Op->Asl.Child;
+        NextOp = Op->Asl.Child;
 
         while (NextOp)
         {
@@ -880,7 +878,8 @@ XfNamespaceLocateBegin (
             NextOp = NextOp->Asl.Next;
         }
 
-        if (Node->Value != ASL_EXTERNAL_METHOD)
+        if (Node->Value != ASL_EXTERNAL_METHOD &&
+            Op->Asl.Parent->Asl.ParseOpcode != PARSEOP_EXTERNAL)
         {
             /*
              * Check the parsed arguments with the number expected by the
@@ -978,7 +977,8 @@ XfNamespaceLocateBegin (
             case ACPI_ADR_SPACE_CMOS:
             case ACPI_ADR_SPACE_GPIO:
 
-                if ((UINT8) Op->Asl.Parent->Asl.Value.Integer != AML_FIELD_ACCESS_BYTE)
+                if ((UINT8) Op->Asl.Parent->Asl.Value.Integer !=
+                    AML_FIELD_ACCESS_BYTE)
                 {
                     AslError (ASL_ERROR, ASL_MSG_REGION_BYTE_ACCESS, Op, NULL);
                 }
@@ -988,7 +988,8 @@ XfNamespaceLocateBegin (
             case ACPI_ADR_SPACE_IPMI:
             case ACPI_ADR_SPACE_GSBUS:
 
-                if ((UINT8) Op->Asl.Parent->Asl.Value.Integer != AML_FIELD_ACCESS_BUFFER)
+                if ((UINT8) Op->Asl.Parent->Asl.Value.Integer !=
+                    AML_FIELD_ACCESS_BUFFER)
                 {
                     AslError (ASL_ERROR, ASL_MSG_REGION_BUFFER_ACCESS, Op, NULL);
                 }
@@ -1016,10 +1017,10 @@ XfNamespaceLocateBegin (
             if (Op->Asl.Parent->Asl.ExtraValue && Op->Asl.Child)
             {
                 XfCheckFieldRange (Op,
-                            Op->Asl.Parent->Asl.ExtraValue,
-                            Op->Asl.ExtraValue,
-                            (UINT32) Op->Asl.Child->Asl.Value.Integer,
-                            Op->Asl.Child->Asl.ExtraValue);
+                    Op->Asl.Parent->Asl.ExtraValue,
+                    Op->Asl.ExtraValue,
+                    (UINT32) Op->Asl.Child->Asl.Value.Integer,
+                    Op->Asl.Child->Asl.ExtraValue);
             }
         }
     }
@@ -1094,3 +1095,178 @@ XfNamespaceLocateEnd (
 
     return_ACPI_STATUS (AE_OK);
 }
+
+
+#ifdef __UNDER_DEVELOPMENT
+/*******************************************************************************
+ *
+ * FUNCTION:    XfIsObjectParental
+ *
+ * PARAMETERS:  ChildOp                 - Op to be checked
+ *              PossibleParentOp        - Determine if this op is in the family
+ *
+ * RETURN:      TRUE if ChildOp is a descendent of PossibleParentOp
+ *
+ * DESCRIPTION: Determine if an Op is a descendent of another Op. Used to
+ *              detect if a method is declared within another method.
+ *
+ ******************************************************************************/
+
+static BOOLEAN
+XfIsObjectParental (
+    ACPI_PARSE_OBJECT       *ChildOp,
+    ACPI_PARSE_OBJECT       *PossibleParentOp)
+{
+    ACPI_PARSE_OBJECT       *ParentOp;
+
+
+    /* Search upwards through the tree for possible parent */
+
+    ParentOp = ChildOp;
+    while (ParentOp)
+    {
+        if (ParentOp == PossibleParentOp)
+        {
+            return (TRUE);
+        }
+
+        ParentOp = ParentOp->Asl.Parent;
+    }
+
+    return (FALSE);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    XfGetParentMethod
+ *
+ * PARAMETERS:  Op                      - Op to be checked
+ *
+ * RETURN:      Op for parent method. NULL if object is not within a method.
+ *
+ * DESCRIPTION: Determine if an object is within a control method. Used to
+ *              implement special rules for named references from within a
+ *              control method.
+ *
+ * NOTE: It would be better to have the parser set a flag in the Op if possible.
+ *
+ ******************************************************************************/
+
+static ACPI_PARSE_OBJECT *
+XfGetParentMethod (
+    ACPI_PARSE_OBJECT       *Op)
+{
+    ACPI_PARSE_OBJECT       *ParentOp;
+
+
+    if (!Op)
+    {
+        return (NULL);
+    }
+
+    if (Op->Asl.ParseOpcode == PARSEOP_METHOD)
+    {
+        return (NULL);
+    }
+
+    /* Walk upwards through the parse tree, up to the root if necessary */
+
+    ParentOp = Op;
+    while (ParentOp)
+    {
+        if (ParentOp->Asl.ParseOpcode == PARSEOP_METHOD)
+        {
+            return (ParentOp);
+        }
+
+        ParentOp = ParentOp->Asl.Parent;
+    }
+
+    /* Object is not within a method */
+
+    return (NULL);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    XfCheckIllegalReference
+ *
+ * PARAMETERS:  Op                      - Op referring to the target
+ *              TargetNode              - Target of the reference
+ *
+ * RETURN:      None. Emits error message for an illegal reference
+ *
+ * DESCRIPTION: Determine if a named reference is legal. A "named" reference
+ *              is something like: Store(ABCD, ...), where ABCD is an AML
+ *              Nameseg or Namepath.
+ *
+ * NOTE: Caller must ensure that the name Op is in fact a reference, and not
+ *       an actual name declaration (creation of a named object).
+ *
+ ******************************************************************************/
+
+static void
+XfCheckIllegalReference (
+    ACPI_PARSE_OBJECT       *Op,
+    ACPI_NAMESPACE_NODE     *TargetNode)
+{
+    ACPI_PARSE_OBJECT       *MethodOp1;
+    ACPI_PARSE_OBJECT       *MethodOp2;
+    ACPI_PARSE_OBJECT       *TargetOp;
+
+
+    /*
+     * Check for an illegal reference to a named object:
+     *
+     * 1) References from one control method to another, non-parent
+     *    method are not allowed, they will fail at runtime.
+     *
+     * 2) Forward references within a control method are not allowed.
+     *    AML interpreters use a one-pass parse of control methods
+     *    so these forward references will fail at runtime.
+     */
+    TargetOp = TargetNode->Op;
+
+    MethodOp1 = XfGetParentMethod (Op);
+    MethodOp2 = XfGetParentMethod (TargetOp);
+
+    /* Are both objects within control method(s)? */
+
+    if (!MethodOp1 || !MethodOp2)
+    {
+        return;
+    }
+
+    /* Objects not in the same method? */
+
+    if (MethodOp1 != MethodOp2)
+    {
+        /*
+         * 1) Cross-method named reference
+         *
+         * This is OK if and only if the target reference is within in a
+         * method that is a parent of current method
+         */
+        if (!XfIsObjectParental (MethodOp1, MethodOp2))
+        {
+            AslError (ASL_ERROR, ASL_MSG_ILLEGAL_METHOD_REF, Op,
+                Op->Asl.ExternalName);
+        }
+    }
+
+    /*
+     * 2) Both reference and target are in the same method. Check if this is
+     * an (illegal) forward reference by examining the exact source code
+     * location of each (the referenced object and the object declaration).
+     * This is a bit nasty, yet effective.
+     */
+    else if (Op->Asl.LogicalByteOffset < TargetOp->Asl.LogicalByteOffset)
+    {
+        AslError (ASL_ERROR, ASL_MSG_ILLEGAL_FORWARD_REF, Op,
+            Op->Asl.ExternalName);
+    }
+
+}
+#endif
author	jkim <jkim@FreeBSD.org>	2016-09-30 22:40:58 +0000
committer	jkim <jkim@FreeBSD.org>	2016-09-30 22:40:58 +0000
commit	dba8c0a565199df70a86f6a036d00c92f0c7675f (patch)
tree	cf4924274c6e92898c01efb3c8ba31b34f0630f2 /sys/contrib/dev/acpica/compiler/aslxref.c
parent	0f41551ef9dde560d9d191d7190af02904dbf611 (diff)
download	FreeBSD-src-dba8c0a565199df70a86f6a036d00c92f0c7675f.zip FreeBSD-src-dba8c0a565199df70a86f6a036d00c92f0c7675f.tar.gz