Merge ACPICA 20100304.

8 files changed, 756 insertions, 601 deletions

diff --git a/sys/contrib/dev/acpica/compiler/aslanalyze.c b/sys/contrib/dev/acpica/compiler/aslanalyze.c
index 46a6db0..c3070f0 100644
--- a/sys/contrib/dev/acpica/compiler/aslanalyze.c
+++ b/sys/contrib/dev/acpica/compiler/aslanalyze.c
@@ -143,16 +143,6 @@ AnGetBtype (
     ACPI_PARSE_OBJECT       *Op);
 
 static UINT32
-AnCheckForReservedName (
-    ACPI_PARSE_OBJECT       *Op,
-    char                    *Name);
-
-static void
-AnCheckForReservedMethod (
-    ACPI_PARSE_OBJECT       *Op,
-    ASL_METHOD_INFO         *MethodInfo);
-
-static UINT32
 AnMapObjTypeToBtype (
     ACPI_PARSE_OBJECT       *Op);
 
@@ -598,219 +588,6 @@ AnGetBtype (
 
 /*******************************************************************************
  *
- * FUNCTION:    AnCheckForReservedName
- *
- * PARAMETERS:  Op              - A parse node
- *              Name            - NameSeg to check
- *
- * RETURN:      None
- *
- * DESCRIPTION: Check a NameSeg against the reserved list.
- *
- ******************************************************************************/
-
-static UINT32
-AnCheckForReservedName (
-    ACPI_PARSE_OBJECT       *Op,
-    char                    *Name)
-{
-    UINT32                  i;
-
-
-    if (Name[0] == 0)
-    {
-        AcpiOsPrintf ("Found a null name, external = %s\n",
-            Op->Asl.ExternalName);
-    }
-
-    /* All reserved names are prefixed with a single underscore */
-
-    if (Name[0] != '_')
-    {
-        return (ACPI_NOT_RESERVED_NAME);
-    }
-
-    /* Check for a standard reserved method name */
-
-    for (i = 0; ReservedMethods[i].Name; i++)
-    {
-        if (ACPI_COMPARE_NAME (Name, ReservedMethods[i].Name))
-        {
-            if (ReservedMethods[i].Flags & ASL_RSVD_SCOPE)
-            {
-                AslError (ASL_ERROR, ASL_MSG_RESERVED_WORD, Op,
-                    Op->Asl.ExternalName);
-                return (ACPI_PREDEFINED_NAME);
-            }
-            else if (ReservedMethods[i].Flags & ASL_RSVD_RESOURCE_NAME)
-            {
-                AslError (ASL_ERROR, ASL_MSG_RESERVED_WORD, Op,
-                    Op->Asl.ExternalName);
-                return (ACPI_PREDEFINED_NAME);
-            }
-
-            /* Return index into reserved array */
-
-            return i;
-        }
-    }
-
-    /*
-     * Now check for the "special" reserved names --
-     * GPE:  _Lxx
-     * GPE:  _Exx
-     * EC:   _Qxx
-     */
-    if ((Name[1] == 'L') ||
-        (Name[1] == 'E') ||
-        (Name[1] == 'Q'))
-    {
-        /* The next two characters must be hex digits */
-
-        if ((isxdigit ((int) Name[2])) &&
-            (isxdigit ((int) Name[3])))
-        {
-            return (ACPI_EVENT_RESERVED_NAME);
-        }
-    }
-
-
-    /* Check for the names reserved for the compiler itself: _T_x */
-
-    else if ((Op->Asl.ExternalName[1] == 'T') &&
-             (Op->Asl.ExternalName[2] == '_'))
-    {
-        /* Ignore if actually emitted by the compiler */
-
-        if (Op->Asl.CompileFlags & NODE_COMPILER_EMITTED)
-        {
-            return (ACPI_NOT_RESERVED_NAME);
-        }
-
-        /*
-         * Was not actually emitted by the compiler. This is a special case,
-         * however. If the ASL code being compiled was the result of a
-         * dissasembly, it may possibly contain valid compiler-emitted names
-         * of the form "_T_x". We don't want to issue an error or even a
-         * warning and force the user to manually change the names. So, we
-         * will issue a remark instead.
-         */
-        AslError (ASL_REMARK, ASL_MSG_COMPILER_RESERVED, Op, Op->Asl.ExternalName);
-        return (ACPI_COMPILER_RESERVED_NAME);
-    }
-
-    /*
-     * The name didn't match any of the known reserved names. Flag it as a
-     * warning, since the entire namespace starting with an underscore is
-     * reserved by the ACPI spec.
-     */
-    AslError (ASL_WARNING, ASL_MSG_UNKNOWN_RESERVED_NAME, Op,
-        Op->Asl.ExternalName);
-
-    return (ACPI_NOT_RESERVED_NAME);
-}
-
-
-/*******************************************************************************
- *
- * FUNCTION:    AnCheckForReservedMethod
- *
- * PARAMETERS:  Op              - A parse node of type "METHOD".
- *              MethodInfo      - Saved info about this method
- *
- * RETURN:      None
- *
- * DESCRIPTION: If method is a reserved name, check that the number of arguments
- *              and the return type (returns a value or not) is correct.
- *
- ******************************************************************************/
-
-static void
-AnCheckForReservedMethod (
-    ACPI_PARSE_OBJECT       *Op,
-    ASL_METHOD_INFO         *MethodInfo)
-{
-    UINT32                  Index;
-    UINT32                  RequiredArgsCurrent;
-    UINT32                  RequiredArgsOld;
-
-
-    /* Check for a match against the reserved name list */
-
-    Index = AnCheckForReservedName (Op, Op->Asl.NameSeg);
-
-    switch (Index)
-    {
-    case ACPI_NOT_RESERVED_NAME:
-    case ACPI_PREDEFINED_NAME:
-    case ACPI_COMPILER_RESERVED_NAME:
-
-        /* Just return, nothing to do */
-        break;
-
-
-    case ACPI_EVENT_RESERVED_NAME:
-
-        Gbl_ReservedMethods++;
-
-        /* NumArguments must be zero for all _Lxx, _Exx, and _Qxx methods */
-
-        if (MethodInfo->NumArguments != 0)
-        {
-            sprintf (MsgBuffer, "%s requires %d",
-                        Op->Asl.ExternalName, 0);
-
-            AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_HI, Op, MsgBuffer);
-        }
-        break;
-
-
-    default:
-
-        Gbl_ReservedMethods++;
-
-        /*
-         * Matched a reserved method name
-         *
-         * Validate the ASL-defined argument count. Allow two different legal
-         * arg counts.
-         */
-        RequiredArgsCurrent = ReservedMethods[Index].NumArguments & 0x0F;
-        RequiredArgsOld = ReservedMethods[Index].NumArguments >> 4;
-
-        if ((MethodInfo->NumArguments != RequiredArgsCurrent) &&
-            (MethodInfo->NumArguments != RequiredArgsOld))
-        {
-            sprintf (MsgBuffer, "%s requires %d",
-                        ReservedMethods[Index].Name,
-                        RequiredArgsCurrent);
-
-            if (MethodInfo->NumArguments > RequiredArgsCurrent)
-            {
-                AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_HI, Op,
-                    MsgBuffer);
-            }
-            else
-            {
-                AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_LO, Op,
-                    MsgBuffer);
-            }
-        }
-
-        if (MethodInfo->NumReturnNoValue &&
-            ReservedMethods[Index].Flags & ASL_RSVD_RETURN_VALUE)
-        {
-            sprintf (MsgBuffer, "%s", ReservedMethods[Index].Name);
-
-            AslError (ASL_WARNING, ASL_MSG_RESERVED_RETURN_VALUE, Op, MsgBuffer);
-        }
-        break;
-    }
-}
-
-
-/*******************************************************************************
- *
  * FUNCTION:    AnMapObjTypeToBtype
  *
  * PARAMETERS:  Op              - A parse node
@@ -1187,7 +964,7 @@ AnMethodAnalysisWalkBegin (
          * The first operand is a name to be created in the namespace.
          * Check against the reserved list.
          */
-        i = AnCheckForReservedName (Op, Op->Asl.NameSeg);
+        i = ApCheckForPredefinedName (Op, Op->Asl.NameSeg);
         if (i < ACPI_VALID_RESERVED_NAME_MAX)
         {
             AslError (ASL_ERROR, ASL_MSG_RESERVED_USE, Op, Op->Asl.ExternalName);
@@ -1197,51 +974,29 @@ AnMethodAnalysisWalkBegin (
 
     case PARSEOP_NAME:
 
-        i = AnCheckForReservedName (Op, Op->Asl.NameSeg);
-        if (i < ACPI_VALID_RESERVED_NAME_MAX)
+        /* Typecheck any predefined names statically defined with Name() */
+
+        ApCheckForPredefinedObject (Op, Op->Asl.NameSeg);
+
+        /* Special typechecking for _HID */
+
+        if (!ACPI_STRCMP (METHOD_NAME__HID, Op->Asl.NameSeg))
         {
-            if (ReservedMethods[i].NumArguments > 0)
+            Next = Op->Asl.Child->Asl.Next;
+            if (Next->Asl.ParseOpcode == PARSEOP_STRING_LITERAL)
             {
                 /*
-                 * This reserved name must be a control method because
-                 * it must have arguments
+                 * _HID is a string, all characters must be alphanumeric.
+                 * One of the things we want to catch here is the use of
+                 * a leading asterisk in the string.
                  */
-                AslError (ASL_ERROR, ASL_MSG_RESERVED_METHOD, Op,
-                    "with arguments");
-            }
-
-            /* Typechecking for _HID */
-
-            else if (!ACPI_STRCMP (METHOD_NAME__HID, ReservedMethods[i].Name))
-            {
-                /* Examine the second operand to typecheck it */
-
-                Next = Op->Asl.Child->Asl.Next;
-
-                if ((Next->Asl.ParseOpcode != PARSEOP_INTEGER) &&
-                    (Next->Asl.ParseOpcode != PARSEOP_STRING_LITERAL))
-                {
-                    /* _HID must be a string or an integer */
-
-                    AslError (ASL_ERROR, ASL_MSG_RESERVED_OPERAND_TYPE, Next,
-                        "String or Integer");
-                }
-
-                if (Next->Asl.ParseOpcode == PARSEOP_STRING_LITERAL)
+                for (i = 0; Next->Asl.Value.String[i]; i++)
                 {
-                    /*
-                     * _HID is a string, all characters must be alphanumeric.
-                     * One of the things we want to catch here is the use of
-                     * a leading asterisk in the string.
-                     */
-                    for (i = 0; Next->Asl.Value.String[i]; i++)
+                    if (!isalnum ((int) Next->Asl.Value.String[i]))
                     {
-                        if (!isalnum ((int) Next->Asl.Value.String[i]))
-                        {
-                            AslError (ASL_ERROR, ASL_MSG_ALPHANUMERIC_STRING,
-                                Next, Next->Asl.Value.String);
-                            break;
-                        }
+                        AslError (ASL_ERROR, ASL_MSG_ALPHANUMERIC_STRING,
+                            Next, Next->Asl.Value.String);
+                        break;
                     }
                 }
             }
@@ -1394,7 +1149,7 @@ AnMethodAnalysisWalkEnd (
          * Check predefined method names for correct return behavior
          * and correct number of arguments
          */
-        AnCheckForReservedMethod (Op, MethodInfo);
+        ApCheckForPredefinedMethod (Op, MethodInfo);
         ACPI_FREE (MethodInfo);
         break;
 
diff --git a/sys/contrib/dev/acpica/compiler/aslcompiler.h b/sys/contrib/dev/acpica/compiler/aslcompiler.h
index 16b5f72..554b0a3 100644
--- a/sys/contrib/dev/acpica/compiler/aslcompiler.h
+++ b/sys/contrib/dev/acpica/compiler/aslcompiler.h
@@ -452,8 +452,27 @@ ACPI_OBJECT_TYPE
 AslMapNamedOpcodeToDataType (
     UINT16                  Opcode);
 
+
+/*
+ * aslpredef - ACPI predefined names support
+ */
+void
+ApCheckForPredefinedMethod (
+    ACPI_PARSE_OBJECT       *Op,
+    ASL_METHOD_INFO         *MethodInfo);
+
+UINT32
+ApCheckForPredefinedName (
+    ACPI_PARSE_OBJECT       *Op,
+    char                    *Name);
+
+void
+ApCheckForPredefinedObject (
+    ACPI_PARSE_OBJECT       *Op,
+    char                    *Name);
+
 void
-MpDisplayReservedNames (
+ApDisplayReservedNames (
     void);
 
 
diff --git a/sys/contrib/dev/acpica/compiler/aslglobal.h b/sys/contrib/dev/acpica/compiler/aslglobal.h
index 69fcf84..01ab931 100644
--- a/sys/contrib/dev/acpica/compiler/aslglobal.h
+++ b/sys/contrib/dev/acpica/compiler/aslglobal.h
@@ -261,7 +261,6 @@ ASL_EXTERN FILE                     *AcpiGbl_DebugFile; /* Placeholder for oswin
 
 ASL_EXTERN ASL_ANALYSIS_WALK_INFO   AnalysisWalkInfo;
 ASL_EXTERN ACPI_TABLE_HEADER        TableHeader;
-extern const ASL_RESERVED_INFO      ReservedMethods[];
 
 /* Event timing */
 
diff --git a/sys/contrib/dev/acpica/compiler/aslmain.c b/sys/contrib/dev/acpica/compiler/aslmain.c
index 9b9e956..e8b0c45 100644
--- a/sys/contrib/dev/acpica/compiler/aslmain.c
+++ b/sys/contrib/dev/acpica/compiler/aslmain.c
@@ -570,7 +570,7 @@ AslDoOptions (
         case 'r':
             /* reserved names */
 
-            MpDisplayReservedNames ();
+            ApDisplayReservedNames ();
             exit (0);
 
         default:
diff --git a/sys/contrib/dev/acpica/compiler/aslmap.c b/sys/contrib/dev/acpica/compiler/aslmap.c
index be43b22..4027a62 100644
--- a/sys/contrib/dev/acpica/compiler/aslmap.c
+++ b/sys/contrib/dev/acpica/compiler/aslmap.c
@@ -114,7 +114,6 @@
  *
  *****************************************************************************/
 
-
 #include <contrib/dev/acpica/compiler/aslcompiler.h>
 #include <contrib/dev/acpica/include/amlcode.h>
 #include <contrib/dev/acpica/include/acparser.h>
@@ -171,322 +170,6 @@ AslMapNamedOpcodeToDataType (
 
 /*******************************************************************************
  *
- * FUNCTION:    MpDisplayReservedNames
- *
- * PARAMETERS:  None
- *
- * RETURN:      None
- *
- * DESCRIPTION: Print the table above
- *
- ******************************************************************************/
-
-void
-MpDisplayReservedNames (
-    void)
-{
-    UINT32              i;
-
-    printf ("Reserved name information\n\n");
-
-    for (i = 0; ReservedMethods[i].Name; i++)
-    {
-        printf ("%s    ", ReservedMethods[i].Name);
-
-        if (ReservedMethods[i].Flags & ASL_RSVD_SCOPE)
-        {
-            printf ("Reserved scope name\n");
-        }
-        else if (ReservedMethods[i].Flags & ASL_RSVD_RESOURCE_NAME)
-        {
-            printf ("Resource data type reserved field name\n");
-        }
-        else
-        {
-            printf ("Method with %d arguments, ",
-                ReservedMethods[i].NumArguments & 0x0F);
-
-            if (ReservedMethods[i].Flags & ASL_RSVD_RETURN_VALUE)
-            {
-                printf ("must return a value\n");
-            }
-            else
-            {
-                printf ("no return value\n");
-            }
-        }
-    }
-}
-
-
-/*******************************************************************************
- *
- * DATA STRUCTURE:  ReservedMethods
- *
- * DESCRIPTION:     Contains all reserved methods and names as defined in the
- *                  ACPI specification.  Used during the analysis phase to
- *                  ensure that reserved methods have the required number of
- *                  arguments and the proper return type.
- *
- * Each entry in the table contains the following items:
- *
- * Name         - The ACPI reserved name
- * Args         - Number of arguments to the method
- * Flags        - Whether this method must return a value or not. Or if the
- *                name is a resource descriptor label.
- *
- ******************************************************************************/
-
-const ASL_RESERVED_INFO         ReservedMethods[] = {
-    {"_AC0",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_AC1",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_AC2",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_AC3",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_AC4",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_AC5",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_AC6",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_AC7",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_AC8",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_AC9",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_ADR",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_AL0",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_AL1",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_AL2",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_AL3",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_AL4",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_AL5",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_AL6",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_AL7",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_AL8",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_AL9",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_ALC",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_ALI",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_ALN",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_ALP",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_ALR",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_ALT",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_ART",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_ASI",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_ASZ",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_BAS",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_BBN",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_BCL",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_BCM",     1,      0},
-    {"_BCT",     1,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_BDN",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_BFS",     1,      0},
-    {"_BIF",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_BIX",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_BLT",     3,      0},                        /* Acpi 3.0 */
-    {"_BM_",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_BMA",     1,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_BMC",     1,      0},                        /* Acpi 3.0 */
-    {"_BMD",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_BMS",     1,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_BQC",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_BST",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_BTM",     1,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_BTP",     1,      0},
-    {"_CBA",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_CDM",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_CID",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_CRS",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_CRT",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_CSD",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_CST",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_DCK",     1,      ASL_RSVD_RETURN_VALUE},
-    {"_DCS",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_DDC",     1,      ASL_RSVD_RETURN_VALUE},
-    {"_DDN",     0,      0},
-    {"_DEC",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_DGS",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_DIS",     0,      0},
-    {"_DMA",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_DOD",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_DOS",     1,      0},
-    {"_DSM",     4,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_DSS",     1,      0},
-    {"_DSW",     3,      0},                        /* Acpi 3.0 */
-    {"_DTI",     1,      0},                        /* Acpi 4.0 */
-    {"_EC_",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_EDL",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_EJ0",     1,      0},
-    {"_EJ1",     1,      0},
-    {"_EJ2",     1,      0},
-    {"_EJ3",     1,      0},
-    {"_EJ4",     1,      0},
-    {"_EJD",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_ERR",     3,      ASL_RSVD_RETURN_VALUE},
-    {"_FDE",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_FDI",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_FDM",     1,      0},
-    {"_FIF",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_FIX",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_FPS",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_FSL",     1,      0},                        /* Acpi 4.0 */
-    {"_FST",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_GAI",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_GHL",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_GL_",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_GLK",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_GPD",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_GPE",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_GRA",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_GSB",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_GTF",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_GTM",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_GTS",     1,      0},
-    {"_HE_",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_HID",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_HOT",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_HPP",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_HPX",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_IFT",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_INI",     0,      0},
-    {"_INT",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_IRC",     0,      0},
-    {"_LCK",     1,      0},
-    {"_LEN",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_LID",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_LL_",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_MAF",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_MAT",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_MAX",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_MBM",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_MEM",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_MIF",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_MIN",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_MLS",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_MSG",     1,      0},
-    {"_MSM",     4,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_MTP",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_NTT",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_OFF",     0,      0},
-    {"_ON_",     0,      0},
-    {"_OS_",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_OSC",     4,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_OSI",     1,      ASL_RSVD_RETURN_VALUE},
-    {"_OST",     3,      0},                        /* Acpi 3.0 */
-    {"_PAI",     1,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_PCL",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_PCT",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_PDC",     1,      0},
-    {"_PDL",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_PIC",     1,      0},
-    {"_PIF",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_PLD",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_PMC",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_PMD",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_PMM",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_PPC",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_PPE",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_PR0",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_PR1",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_PR2",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_PR3",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_PRL",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_PRS",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_PRT",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_PRW",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_PS0",     0,      0},
-    {"_PS1",     0,      0},
-    {"_PS2",     0,      0},
-    {"_PS3",     0,      0},
-    {"_PSC",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_PSD",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_PSL",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_PSR",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_PSS",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_PSV",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_PSW",     1,      0},
-    {"_PTC",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_PTP",     2,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_PTS",     1,      0},
-    {"_PUR",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_PXM",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_RBO",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_RBW",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_REG",     2,      0},
-    {"_REV",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_RMV",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_RNG",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_ROM",     2,      ASL_RSVD_RETURN_VALUE},
-    {"_RT_",     0,      ASL_RSVD_RESOURCE_NAME},   /* Acpi 3.0 */
-    {"_RTV",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_RW_",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_S0_",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_S1_",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_S2_",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_S3_",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_S4_",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_S5_",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_S1D",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_S2D",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_S3D",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_S4D",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_S0W",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_S1W",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_S2W",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_S3W",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_S4W",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_SB_",     0,      ASL_RSVD_SCOPE},
-    {"_SBS",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_SCP",     0x13,   0},                        /* Acpi 1.0 - one arg; Acpi 3.0 - three args */
-    {"_SDD",     1,      0},                        /* Acpi 3.0 */
-    {"_SEG",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_SHL",     1,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_SHR",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_SI_",     0,      ASL_RSVD_SCOPE},
-    {"_SIZ",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_SLI",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_SPD",     1,      ASL_RSVD_RETURN_VALUE},
-    {"_SRS",     1,      0},
-    {"_SRV",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_SST",     1,      0},
-    {"_STA",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_STM",     3,      0},
-    {"_STP",     2,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_STR",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_STV",     2,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_SUN",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_SWS",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_TC1",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_TC2",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_TDL",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0b */
-    {"_TIP",     1,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_TIV",     1,      ASL_RSVD_RETURN_VALUE},    /* Acpi 4.0 */
-    {"_TMP",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_TPC",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_TPT",     1,      0},                        /* Acpi 3.0 */
-    {"_TRA",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_TRS",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_TRT",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_TSD",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_TSF",     0,      ASL_RSVD_RESOURCE_NAME},   /* Acpi 3.0 */
-    {"_TSP",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_TSS",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_TST",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_TTP",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_TTS",     1,      0},                        /* Acpi 3.0 */
-    {"_TYP",     0,      ASL_RSVD_RESOURCE_NAME},
-    {"_TZ_",     0,      ASL_RSVD_SCOPE},
-    {"_TZD",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_TZM",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_TZP",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_UID",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_UPC",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_UPD",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_UPP",     0,      ASL_RSVD_RETURN_VALUE},    /* Acpi 3.0 */
-    {"_VPO",     0,      ASL_RSVD_RETURN_VALUE},
-    {"_WAK",     1,      ASL_RSVD_RETURN_VALUE},
-    {"_WDG",     0,      ASL_RSVD_RETURN_VALUE},    /* MS Extension */
-    {"_WED",     1,      ASL_RSVD_RETURN_VALUE},    /* MS Extension */
-    {NULL,       0,      0},
-};
-
-
-/*******************************************************************************
- *
  * DATA STRUCTURE:  AslKeywordMapping
  *
  * DESCRIPTION:     Maps the ParseOpcode to the actual AML opcode.  The parse
diff --git a/sys/contrib/dev/acpica/compiler/aslpredef.c b/sys/contrib/dev/acpica/compiler/aslpredef.c
new file mode 100644
index 0000000..97ed3ca
--- /dev/null
+++ b/sys/contrib/dev/acpica/compiler/aslpredef.c
@@ -0,0 +1,706 @@
+/******************************************************************************
+ *
+ * Module Name: aslpredef - support for ACPI predefined names
+ *
+ *****************************************************************************/
+
+/******************************************************************************
+ *
+ * 1. Copyright Notice
+ *
+ * Some or all of this work - Copyright (c) 1999 - 2010, 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 ACPI_CREATE_PREDEFINED_TABLE
+
+#include <contrib/dev/acpica/compiler/aslcompiler.h>
+#include "aslcompiler.y.h"
+#include <contrib/dev/acpica/include/amlcode.h>
+#include <contrib/dev/acpica/include/acparser.h>
+#include <contrib/dev/acpica/include/acpredef.h>
+
+
+#define _COMPONENT          ACPI_COMPILER
+        ACPI_MODULE_NAME    ("aslpredef")
+
+
+/* Local prototypes */
+
+static UINT32
+ApCheckForSpecialName (
+    ACPI_PARSE_OBJECT       *Op,
+    char                    *Name);
+
+static void
+ApCheckObjectType (
+    ACPI_PARSE_OBJECT       *Op,
+    UINT32                  ExpectedBtypes);
+
+static void
+ApGetExpectedTypes (
+    char                    *Buffer,
+    UINT32                  ExpectedBtypes);
+
+
+/*
+ * Names for the types that can be returned by the predefined objects.
+ * Used for warning messages. Must be in the same order as the ACPI_RTYPEs
+ */
+static const char   *AcpiRtypeNames[] =
+{
+    "/Integer",
+    "/String",
+    "/Buffer",
+    "/Package",
+    "/Reference",
+};
+
+/*
+ * Predefined names for use in Resource Descriptors. These names do not
+ * appear in the global Predefined Name table (since these names never
+ * appear in actual AML byte code, only in the original ASL)
+ */
+static const ACPI_PREDEFINED_INFO      ResourceNames[] = {
+    {{"_ALN",     0,      0}},
+    {{"_ASI",     0,      0}},
+    {{"_ASZ",     0,      0}},
+    {{"_ATT",     0,      0}},
+    {{"_BAS",     0,      0}},
+    {{"_BM_",     0,      0}},
+    {{"_DEC",     0,      0}},
+    {{"_GRA",     0,      0}},
+    {{"_HE_",     0,      0}},
+    {{"_INT",     0,      0}},
+    {{"_LEN",     0,      0}},
+    {{"_LL_",     0,      0}},
+    {{"_MAF",     0,      0}},
+    {{"_MAX",     0,      0}},
+    {{"_MEM",     0,      0}},
+    {{"_MIF",     0,      0}},
+    {{"_MIN",     0,      0}},
+    {{"_MTP",     0,      0}},
+    {{"_RBO",     0,      0}},
+    {{"_RBW",     0,      0}},
+    {{"_RNG",     0,      0}},
+    {{"_RT_",     0,      0}},  /* Acpi 3.0 */
+    {{"_RW_",     0,      0}},
+    {{"_SHR",     0,      0}},
+    {{"_SIZ",     0,      0}},
+    {{"_TRA",     0,      0}},
+    {{"_TRS",     0,      0}},
+    {{"_TSF",     0,      0}},  /* Acpi 3.0 */
+    {{"_TTP",     0,      0}},
+    {{"_TYP",     0,      0}},
+    {{{0,0,0,0},  0,      0}}   /* Table terminator */
+};
+
+static const ACPI_PREDEFINED_INFO      ScopeNames[] = {
+    {{"_SB_",     0,      0}},
+    {{"_SI_",     0,      0}},
+    {{"_TZ_",     0,      0}},
+    {{{0,0,0,0},  0,      0}}   /* Table terminator */
+};
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    ApCheckForPredefinedMethod
+ *
+ * PARAMETERS:  Op              - A parse node of type "METHOD".
+ *              MethodInfo      - Saved info about this method
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: If method is a predefined name, check that the number of
+ *              arguments and the return type (returns a value or not)
+ *              is correct.
+ *
+ ******************************************************************************/
+
+void
+ApCheckForPredefinedMethod (
+    ACPI_PARSE_OBJECT       *Op,
+    ASL_METHOD_INFO         *MethodInfo)
+{
+    UINT32                  Index;
+    UINT32                  RequiredArgsCurrent;
+    UINT32                  RequiredArgsOld;
+
+
+    /* Check for a match against the predefined name list */
+
+    Index = ApCheckForPredefinedName (Op, Op->Asl.NameSeg);
+
+    switch (Index)
+    {
+    case ACPI_NOT_RESERVED_NAME:        /* No underscore or _Txx or _xxx name not matched */
+    case ACPI_PREDEFINED_NAME:          /* Resource Name or reserved scope name */
+    case ACPI_COMPILER_RESERVED_NAME:   /* A _Txx that was not emitted by compiler */
+
+        /* Just return, nothing to do */
+        break;
+
+
+    case ACPI_EVENT_RESERVED_NAME:      /* _Lxx, _Exx, and _Qxx methods */
+
+        Gbl_ReservedMethods++;
+
+        /* NumArguments must be zero for all _Lxx, _Exx, and _Qxx methods */
+
+        if (MethodInfo->NumArguments != 0)
+        {
+            sprintf (MsgBuffer, "%s requires %d", Op->Asl.ExternalName, 0);
+
+            AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_HI, Op,
+                MsgBuffer);
+        }
+        break;
+
+
+    default:
+        /*
+         * Matched a predefined method name
+         *
+         * Validate the ASL-defined argument count. Allow two different legal
+         * arg counts.
+         */
+        Gbl_ReservedMethods++;
+
+        RequiredArgsCurrent = PredefinedNames[Index].Info.ParamCount & 0x0F;
+        RequiredArgsOld = PredefinedNames[Index].Info.ParamCount >> 4;
+
+        if ((MethodInfo->NumArguments != RequiredArgsCurrent) &&
+            (MethodInfo->NumArguments != RequiredArgsOld))
+        {
+            sprintf (MsgBuffer, "%4.4s requires %d",
+                PredefinedNames[Index].Info.Name, RequiredArgsCurrent);
+
+            if (MethodInfo->NumArguments > RequiredArgsCurrent)
+            {
+                AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_HI, Op,
+                    MsgBuffer);
+            }
+            else
+            {
+                AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_LO, Op,
+                    MsgBuffer);
+            }
+        }
+
+        /*
+         * Check if method returns no value, but the predefined name is
+         * required to return a value
+         */
+        if (MethodInfo->NumReturnNoValue &&
+            PredefinedNames[Index].Info.ExpectedBtypes)
+        {
+            sprintf (MsgBuffer, "%4.4s", PredefinedNames[Index].Info.Name);
+
+            AslError (ASL_WARNING, ASL_MSG_RESERVED_RETURN_VALUE, Op,
+                MsgBuffer);
+        }
+        break;
+    }
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    ApCheckForPredefinedObject
+ *
+ * PARAMETERS:  Op              - A parse node
+ *              Name            - The ACPI name to be checked
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Check for a predefined name for a static object (created via
+ *              the ASL Name operator). If it is a predefined ACPI name, ensure
+ *              that the name does not require any arguments (which would
+ *              require a control method implemenation of the name), and that
+ *              the type of the object is one of the expected types for the
+ *              predefined name.
+ *
+ ******************************************************************************/
+
+void
+ApCheckForPredefinedObject (
+    ACPI_PARSE_OBJECT       *Op,
+    char                    *Name)
+{
+    UINT32                  Index;
+
+
+    /*
+     * Check for a real predefined name -- not a resource descriptor name
+     * or a predefined scope name
+     */
+    Index = ApCheckForPredefinedName (Op, Name);
+    if (Index > ACPI_VALID_RESERVED_NAME_MAX)
+    {
+        return;
+    }
+
+    /*
+     * We found a matching predefind name.
+     * Check if this predefined name requires input arguments
+     */
+    if (PredefinedNames[Index].Info.ParamCount > 0)
+    {
+        /*
+         * This predefined name must always be defined as a control
+         * method because it is required to have input arguments.
+         */
+        AslError (ASL_ERROR, ASL_MSG_RESERVED_METHOD, Op,
+            "with arguments");
+    }
+
+    /* Typecheck the actual object, it is the next argument */
+
+    ApCheckObjectType (Op->Asl.Child->Asl.Next,
+        PredefinedNames[Index].Info.ExpectedBtypes);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    ApCheckForPredefinedName
+ *
+ * PARAMETERS:  Op              - A parse node
+ *              Name            - NameSeg to check
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Check a NameSeg against the reserved list.
+ *
+ ******************************************************************************/
+
+UINT32
+ApCheckForPredefinedName (
+    ACPI_PARSE_OBJECT       *Op,
+    char                    *Name)
+{
+    UINT32                  i;
+
+
+    if (Name[0] == 0)
+    {
+        AcpiOsPrintf ("Found a null name, external = %s\n",
+            Op->Asl.ExternalName);
+    }
+
+    /* All reserved names are prefixed with a single underscore */
+
+    if (Name[0] != '_')
+    {
+        return (ACPI_NOT_RESERVED_NAME);
+    }
+
+    /* Check for a standard predefined method name */
+
+    for (i = 0; PredefinedNames[i].Info.Name[0]; i++)
+    {
+        if (ACPI_COMPARE_NAME (Name, PredefinedNames[i].Info.Name))
+        {
+            /* Return index into predefined array */
+            return (i);
+        }
+    }
+
+    /* Check for resource names and predefined scope names */
+
+    for (i = 0; ResourceNames[i].Info.Name[0]; i++)
+    {
+        if (ACPI_COMPARE_NAME (Name, ResourceNames[i].Info.Name))
+        {
+            return (ACPI_PREDEFINED_NAME);
+        }
+    }
+
+    for (i = 0; ScopeNames[i].Info.Name[0]; i++)
+    {
+        if (ACPI_COMPARE_NAME (Name, ScopeNames[i].Info.Name))
+        {
+            return (ACPI_PREDEFINED_NAME);
+        }
+    }
+
+    /* Check for _Lxx, _Exx, _Qxx, _T_x. Warning if unknown predefined name */
+
+    return (ApCheckForSpecialName (Op, Name));
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    ApCheckForSpecialName
+ *
+ * PARAMETERS:  Op              - A parse node
+ *              Name            - NameSeg to check
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Check for the "special" predefined names - 
+ *              _Lxx, _Exx, _Qxx, and _T_x
+ *
+ ******************************************************************************/
+
+static UINT32
+ApCheckForSpecialName (
+    ACPI_PARSE_OBJECT       *Op,
+    char                    *Name)
+{
+
+    /*
+     * Check for the "special" predefined names. We know the first char is an
+     * underscore already.
+     *   GPE:  _Lxx
+     *   GPE:  _Exx
+     *   EC:   _Qxx
+     */
+    if ((Name[1] == 'L') ||
+        (Name[1] == 'E') ||
+        (Name[1] == 'Q'))
+    {
+        /* The next two characters must be hex digits */
+
+        if ((isxdigit ((int) Name[2])) &&
+            (isxdigit ((int) Name[3])))
+        {
+            return (ACPI_EVENT_RESERVED_NAME);
+        }
+    }
+
+    /* Check for the names reserved for the compiler itself: _T_x */
+
+    else if ((Op->Asl.ExternalName[1] == 'T') &&
+             (Op->Asl.ExternalName[2] == '_'))
+    {
+        /* Ignore if actually emitted by the compiler */
+
+        if (Op->Asl.CompileFlags & NODE_COMPILER_EMITTED)
+        {
+            return (ACPI_NOT_RESERVED_NAME);
+        }
+
+        /*
+         * Was not actually emitted by the compiler. This is a special case,
+         * however. If the ASL code being compiled was the result of a
+         * dissasembly, it may possibly contain valid compiler-emitted names
+         * of the form "_T_x". We don't want to issue an error or even a
+         * warning and force the user to manually change the names. So, we
+         * will issue a remark instead.
+         */
+        AslError (ASL_REMARK, ASL_MSG_COMPILER_RESERVED, Op, Op->Asl.ExternalName);
+        return (ACPI_COMPILER_RESERVED_NAME);
+    }
+
+    /*
+     * The name didn't match any of the known predefined names. Flag it as a
+     * warning, since the entire namespace starting with an underscore is
+     * reserved by the ACPI spec.
+     */
+    AslError (ASL_WARNING, ASL_MSG_UNKNOWN_RESERVED_NAME, Op,
+        Op->Asl.ExternalName);
+
+    return (ACPI_NOT_RESERVED_NAME);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    ApCheckObjectType
+ *
+ * PARAMETERS:  Op              - A parse node
+ *              ExpectedBtypes  - Bitmap of expected return type(s)
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Check if the object type is one of the types that is expected
+ *              by the predefined name. Only a limited number of object types
+ *              can be returned by the predefined names.
+ *
+ ******************************************************************************/
+
+static void
+ApCheckObjectType (
+    ACPI_PARSE_OBJECT       *Op,
+    UINT32                  ExpectedBtypes)
+{
+    UINT32                  ReturnBtype;
+    char                    TypeBuffer[48]; /* Room for 5 types */
+
+
+    switch (Op->Asl.ParseOpcode)
+    {
+    case PARSEOP_INTEGER:
+        ReturnBtype = ACPI_RTYPE_INTEGER;
+        break;
+
+    case PARSEOP_BUFFER:
+        ReturnBtype = ACPI_RTYPE_BUFFER;
+        break;
+
+    case PARSEOP_STRING_LITERAL:
+        ReturnBtype = ACPI_RTYPE_STRING;
+        break;
+
+    case PARSEOP_PACKAGE:
+        ReturnBtype = ACPI_RTYPE_PACKAGE;
+        break;
+
+    default:
+        /* Not one of the supported object types */
+        
+        goto TypeErrorExit;
+    }
+
+    /* Is the object one of the expected types? */
+
+    if (ReturnBtype & ExpectedBtypes)
+    {
+        return;
+    }
+
+
+TypeErrorExit:
+
+    /* Format the expected types and emit an error message */
+
+    ApGetExpectedTypes (TypeBuffer, ExpectedBtypes);
+
+    AslError (ASL_ERROR, ASL_MSG_RESERVED_OPERAND_TYPE, Op,
+        TypeBuffer);
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    ApDisplayReservedNames
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Dump information about the ACPI predefined names and predefined
+ *              resource descriptor names.
+ *
+ ******************************************************************************/
+
+void
+ApDisplayReservedNames (
+    void)
+{
+    const ACPI_PREDEFINED_INFO  *ThisName;
+    char                        TypeBuffer[48]; /* Room for 5 types */
+    UINT32                      Count;
+
+
+    /*
+     * Predefined names/methods
+     */
+    printf ("\nPredefined Name Information\n\n");
+
+    Count = 0;
+    ThisName = PredefinedNames;
+    while (ThisName->Info.Name[0])
+    {
+        printf ("%4.4s    Requires %d arguments, ",
+            ThisName->Info.Name, ThisName->Info.ParamCount & 0x0F);
+
+        if (ThisName->Info.ExpectedBtypes)
+        {
+            ApGetExpectedTypes (TypeBuffer, ThisName->Info.ExpectedBtypes);
+            printf ("Must return: %s\n", TypeBuffer);
+        }
+        else
+        {
+            printf ("No return value\n");
+        }
+
+        /*
+         * Skip next entry in the table if this name returns a Package
+         * (next entry contains the package info)
+         */
+        if (ThisName->Info.ExpectedBtypes & ACPI_RTYPE_PACKAGE)
+        {
+            ThisName++;
+        }
+
+        Count++;
+        ThisName++;
+    }
+
+    printf ("%u Predefined Names are recognized\n", Count);
+
+    /*
+     * Resource Descriptor names
+     */
+    printf ("\nResource Descriptor Predefined Names\n\n");
+
+    Count = 0;
+    ThisName = ResourceNames;
+    while (ThisName->Info.Name[0])
+    {
+        printf ("%4.4s    Resource Descriptor\n", ThisName->Info.Name);
+        Count++;
+        ThisName++;
+    }
+
+    printf ("%u Resource Descriptor Names are recognized\n", Count);
+
+    /*
+     * Predefined scope names
+     */
+    printf ("\nPredefined Scope Names\n\n");
+
+    ThisName = ScopeNames;
+    while (ThisName->Info.Name[0])
+    {
+        printf ("%4.4s    Scope\n", ThisName->Info.Name);
+        ThisName++;
+    }
+}
+
+
+/*******************************************************************************
+ *
+ * FUNCTION:    ApGetExpectedTypes
+ *
+ * PARAMETERS:  Buffer              - Where the formatted string is returned
+ *              ExpectedBTypes      - Bitfield of expected data types
+ *
+ * RETURN:      None, formatted string
+ *
+ * DESCRIPTION: Format the expected object types into a printable string.
+ *
+ ******************************************************************************/
+
+static void
+ApGetExpectedTypes (
+    char                        *Buffer,
+    UINT32                      ExpectedBtypes)
+{
+    UINT32                      ThisRtype;
+    UINT32                      i;
+    UINT32                      j;
+
+
+    j = 1;
+    Buffer[0] = 0;
+    ThisRtype = ACPI_RTYPE_INTEGER;
+
+    for (i = 0; i < ACPI_NUM_RTYPES; i++)
+    {
+        /* If one of the expected types, concatenate the name of this type */
+
+        if (ExpectedBtypes & ThisRtype)
+        {
+            ACPI_STRCAT (Buffer, &AcpiRtypeNames[i][j]);
+            j = 0;              /* Use name separator from now on */
+        }
+        ThisRtype <<= 1;    /* Next Rtype */
+    }
+}
+
diff --git a/sys/contrib/dev/acpica/compiler/aslstubs.c b/sys/contrib/dev/acpica/compiler/aslstubs.c
index ebc0a7d..dc1598f 100644
--- a/sys/contrib/dev/acpica/compiler/aslstubs.c
+++ b/sys/contrib/dev/acpica/compiler/aslstubs.c
@@ -250,6 +250,15 @@ AcpiEvCheckForWakeOnlyGpe (
     return (AE_OK);
 }
 
+void
+AcpiExDoDebugObject (
+    ACPI_OPERAND_OBJECT     *SourceDesc,
+    UINT32                  Level,
+    UINT32                  Index)
+{
+    return;
+}
+
 ACPI_STATUS
 AcpiExReadDataFromField (
     ACPI_WALK_STATE         *WalkState,
@@ -276,7 +285,6 @@ AcpiExLoadTableOp (
     return (AE_SUPPORT);
 }
 
-
 ACPI_STATUS
 AcpiExUnloadTable (
     ACPI_OPERAND_OBJECT     *DdbHandle)
diff --git a/sys/contrib/dev/acpica/compiler/asltypes.h b/sys/contrib/dev/acpica/compiler/asltypes.h
index 9e1d426..6edf987 100644
--- a/sys/contrib/dev/acpica/compiler/asltypes.h
+++ b/sys/contrib/dev/acpica/compiler/asltypes.h
@@ -188,21 +188,6 @@ typedef struct asl_mapping_entry
 } ASL_MAPPING_ENTRY;
 
 
-/* An entry in the Reserved Name information table */
-
-#define ASL_RSVD_RETURN_VALUE   0x01
-#define ASL_RSVD_RESOURCE_NAME  0x02
-#define ASL_RSVD_SCOPE          0x04
-
-typedef struct asl_reserved_info
-{
-    char                        *Name;
-    UINT8                       NumArguments;
-    UINT8                       Flags;
-
-} ASL_RESERVED_INFO;
-
-
 /* Parse tree walk info structure */
 
 typedef struct asl_walk_info
@@ -522,7 +507,7 @@ char                        *AslMessages [] = {
 /*    ASL_MSG_RESERVED_ARG_COUNT_HI */      "Reserved method has too many arguments",
 /*    ASL_MSG_RESERVED_ARG_COUNT_LO */      "Reserved method has too few arguments",
 /*    ASL_MSG_RESERVED_METHOD */            "Reserved name must be a control method",
-/*    ASL_MSG_RESERVED_OPERAND_TYPE */      "Invalid operand type for reserved name, must be",
+/*    ASL_MSG_RESERVED_OPERAND_TYPE */      "Invalid object type for reserved name, must be",
 /*    ASL_MSG_RESERVED_RETURN_VALUE */      "Reserved method must return a value",
 /*    ASL_MSG_RESERVED_USE */               "Invalid use of reserved name",
 /*    ASL_MSG_RESERVED_WORD */              "Use of reserved name",