Changeset 108230 in vbox for trunk/src/VBox

Timestamp:

Feb 14, 2025 8:49:02 PM (3 months ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

167551

Message:

Runtime/RTAcpi*: Updates and fixes, RTIasl can now mostly generate identical AML code for vbox.dsl, apart from a single optimization where iasl can fold certain operations on constants into an integer, like ShiftLeft(One,1) for instance, bugref:10733

Location:

trunk/src/VBox/Runtime

Files:

• common/acpi/acpi-ast.cpp (modified) (8 diffs)
• common/acpi/acpi-compiler.cpp (modified) (16 diffs)
• common/acpi/acpi-ns.cpp (modified) (11 diffs)
• common/acpi/acpi.cpp (modified) (5 diffs)
• include/internal/acpi.h (modified) (7 diffs)

trunk/src/VBox/Runtime/common/acpi/acpi-ast.cpp

@@ -69 +69 @@
 *********************************************************************************************************************************/
 
-DECLHIDDEN(PRTACPIASTNODE) rtAcpiAstNodeAlloc(RTACPIASTNODEOP enmOp, uint32_t fFlags, uint8_t cArgs)
+DECLHIDDEN(PRTACPIASTNODE) rtAcpiAstNodeAlloc(PCRTACPINSROOT pNs, RTACPIASTNODEOP enmOp, uint32_t fFlags, uint8_t cArgs)
 {
     PRTACPIASTNODE pAstNd = (PRTACPIASTNODE)RTMemAllocZ(RT_UOFFSETOF_DYN(RTACPIASTNODE, aArgs[cArgs]));
     if (pAstNd)
     {
-        pAstNd->enmOp  = enmOp;
-        pAstNd->fFlags = fFlags;
-        pAstNd->cArgs  = cArgs;
+        pAstNd->pNsEntry = rtAcpiNsGetCurrent(pNs);
+        pAstNd->enmOp    = enmOp;
+        pAstNd->fFlags   = fFlags;
+        pAstNd->cArgs    = cArgs;
         RTListInit(&pAstNd->LstScopeNodes);
     }
@@ -179 +180 @@
 
         *pu64 = pNsEntry->offBits;
+        return VINF_SUCCESS;
     }
 
@@ -203 +205 @@
 {
     int rc = VINF_SUCCESS;
+    char szNameString[_1K];
 
     switch (pAstNd->enmOp)
@@ -208 +211 @@
         case kAcpiAstNodeOp_Identifier:
         {
-            rc = RTAcpiTblNameStringAppend(hAcpiTbl, pAstNd->pszIde);
+            rc = rtAcpiNsAbsoluteNameStringToRelative(pNsRoot, pAstNd->pNsEntry, pAstNd->pszIde, &szNameString[0], sizeof(szNameString));
+            AssertRC(rc);
+
+            rc = RTAcpiTblNameStringAppend(hAcpiTbl, szNameString);
             if (RT_SUCCESS(rc))
             {
@@ -232 +238 @@
                             && pAstNd->aArgs[0].enmType == kAcpiAstArgType_NameString,
                             rc = VERR_INTERNAL_ERROR);
-            rc = RTAcpiTblScopeStart(hAcpiTbl, pAstNd->aArgs[0].u.pszNameString);
+            rc = rtAcpiNsCompressNameString(pNsRoot, pAstNd->pNsEntry, pAstNd->aArgs[0].u.pszNameString,
+                                            &szNameString[0], sizeof(szNameString));
+            AssertRC(rc);
+
+            rc = RTAcpiTblScopeStart(hAcpiTbl, szNameString);
             if (RT_SUCCESS(rc))
             {
@@ -272 +282 @@
                             && pAstNd->aArgs[3].enmType == kAcpiAstArgType_U8,
                             rc = VERR_INTERNAL_ERROR);
-            rc = RTAcpiTblMethodStart(hAcpiTbl, pAstNd->aArgs[0].u.pszNameString,
+            rc = rtAcpiNsCompressNameString(pNsRoot, pAstNd->pNsEntry, pAstNd->aArgs[0].u.pszNameString,
+                                            &szNameString[0], sizeof(szNameString));
+            AssertRC(rc);
+
+            rc = RTAcpiTblMethodStart(hAcpiTbl, szNameString,
                                       pAstNd->aArgs[1].u.u8,
                                       pAstNd->aArgs[2].u.f ? RTACPI_METHOD_F_SERIALIZED : RTACPI_METHOD_F_NOT_SERIALIZED,
@@ -466 +480 @@
                             && pAstNd->aArgs[3].enmType == kAcpiAstArgType_FieldUpdate,
                             rc = VERR_INTERNAL_ERROR);
-
-            rc = RTAcpiTblFieldAppend(hAcpiTbl, pAstNd->aArgs[0].u.pszNameString, pAstNd->aArgs[1].u.enmFieldAcc,
+            rc = rtAcpiNsAbsoluteNameStringToRelative(pNsRoot, pAstNd->pNsEntry, pAstNd->aArgs[0].u.pszNameString, &szNameString[0], sizeof(szNameString));
+            AssertRC(rc);
+
+            rc = RTAcpiTblFieldAppend(hAcpiTbl, szNameString, pAstNd->aArgs[1].u.enmFieldAcc,
                                       pAstNd->aArgs[2].u.f, pAstNd->aArgs[3].u.enmFieldUpdate, pAstNd->Fields.paFields,
                                       pAstNd->Fields.cFields);
@@ -811 +827 @@
             {
                 /* Try to resolve to an integer. */
-                uint64_t offBits = 0;
-                rc = rtAcpiAstNodeEvaluateToInteger(pAstNd->aArgs[1].u.pAstNd, pNsRoot, &offBits);
-                if (RT_SUCCESS(rc))
-                    rc = RTAcpiTblIntegerAppend(hAcpiTbl, pAstNd->enmOp == kAcpiAstNodeOp_CreateBitField ? offBits : offBits / 8);
+                uint64_t off = 0;
+                if (pAstNd->aArgs[1].u.pAstNd->enmOp == kAcpiAstNodeOp_Number)
+                    off = pAstNd->aArgs[1].u.pAstNd->u64;
+                else
+                {
+                    rc = rtAcpiAstNodeEvaluateToInteger(pAstNd->aArgs[1].u.pAstNd, pNsRoot, &off);
+                    off = pAstNd->enmOp == kAcpiAstNodeOp_CreateBitField ? off : off / 8;
+                }
+                if (RT_SUCCESS(rc))
+                    rc = RTAcpiTblIntegerAppend(hAcpiTbl, off);
                 else
                     rc = rtAcpiAstDumpToTbl(pAstNd->aArgs[1].u.pAstNd, pNsRoot, hAcpiTbl);

trunk/src/VBox/Runtime/common/acpi/acpi-compiler.cpp

@@ -1189 +1189 @@
 
 
-static int rtAcpiTblParseFieldUnitList(PRTACPIASLCU pThis, PRTACPIASTNODE pAstNd)
+static int rtAcpiTblParseFieldUnitList(PRTACPIASLCU pThis, const char *pszFieldName, PRTACPIASTNODE pAstNd)
 {
     RTACPIFIELDENTRY aFieldEntries[128]; RT_ZERO(aFieldEntries); /** @todo Allow dynamic allocation? */
     uint32_t cFields = 0;
 
+    uint32_t offBits = 0;
     for (;;)
     {
@@ -1216 +1217 @@
             RTACPIASL_PARSE_NATURAL(offBytes);
             aFieldEntries[cFields].pszName = NULL;
-            aFieldEntries[cFields].cBits   = offBytes * 8;
+            aFieldEntries[cFields].cBits   = (offBytes * 8) - offBits;
             RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_CLOSE_BRACKET, ')');
         }
@@ -1227 +1228 @@
             aFieldEntries[cFields].pszName = pszName;
             aFieldEntries[cFields].cBits   = cBits;
+
+            rc = rtAcpiNsAddEntryRsrcField(pThis->pNs, pszName, offBits, cBits);
+            if (RT_FAILURE(rc))
+                return RTErrInfoSetF(pThis->pErrInfo, rc, "Failed to add '%s.%s' to namespace", pszFieldName, pszName);
+
         }
 
+        offBits += aFieldEntries[cFields].cBits;
         cFields++;
 
@@ -1337 +1344 @@
     /* Parse the field unit list. */
     RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_OPEN_CURLY_BRACKET, '{');
-    return rtAcpiTblParseFieldUnitList(pThis, pAstNd);
+    return rtAcpiTblParseFieldUnitList(pThis, pszNameString, pAstNd);
 }
 
@@ -1531 +1538 @@
         static const RTACPIRSRCNSENTRY s_aRsrcNs[] =
         {
-            { NULL, 0,  0 }
+            { "_INT", 1 * 8, 16 },
+            { NULL,       0,  0 }
         };
         rc = rtAcpiTblParseResourceNsCreateEntries(pThis, hAcpiRes, pAstNd, "IRQNoFlags", pszName, &s_aRsrcNs[0]);
@@ -1674 +1682 @@
     {
         case RTACPIASLTERMINAL_KEYWORD_TRANSFER_8:    enmTransferType = kAcpiResDmaTransferType_8Bit;       break;
-        case RTACPIASLTERMINAL_KEYWORD_TRANSFER_16:   enmTransferType = kAcpiResDmaTransferType_8Bit_16Bit; break;
-        case RTACPIASLTERMINAL_KEYWORD_TRANSFER_8_16: enmTransferType = kAcpiResDmaTransferType_16Bit;      break;
+        case RTACPIASLTERMINAL_KEYWORD_TRANSFER_16:   enmTransferType = kAcpiResDmaTransferType_16Bit;      break;
+        case RTACPIASLTERMINAL_KEYWORD_TRANSFER_8_16: enmTransferType = kAcpiResDmaTransferType_8Bit_16Bit; break;
         default:
             AssertReleaseFailed();
@@ -1908 +1916 @@
             { "_TTP",  5 * 8 + 5,  1 },
             { "_GRA",  6 * 8,     32 },
-            { "_MIN", 12 * 8,     32 },
-            { "_MAX", 16 * 8,     32 },
-            { "_TRA", 24 * 8,     32 },
-            { "_LEN", 32 * 8,     32 },
+            { "_MIN", 10 * 8,     32 },
+            { "_MAX", 14 * 8,     32 },
+            { "_TRA", 18 * 8,     32 },
+            { "_LEN", 22 * 8,     32 },
             { NULL,        0,      0 }
         };
@@ -2400 +2408 @@
     /* kAcpiAstNodeOp_StringLiteral           */  RTACPI_ASL_KEYWORD_DEFINE_INVALID,
     /* kAcpiAstNodeOp_Number                  */  RTACPI_ASL_KEYWORD_DEFINE_INVALID,
-    /* kAcpiAstNodeOp_Scope                   */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("Scope",                  RTACPI_AST_NODE_F_NEW_SCOPE | RTACPI_AST_NODE_F_NS_ENTRY,   kAcpiAstArgType_NameString),
+    /* kAcpiAstNodeOp_Scope                   */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("Scope",                  RTACPI_AST_NODE_F_NEW_SCOPE | RTACPI_AST_NODE_F_NS_SWITCH,  kAcpiAstArgType_NameString),
     /* kAcpiAstNodeOp_Processor               */  {
                                                       "Processor", NULL, 2, 2, RTACPI_AST_NODE_F_NEW_SCOPE | RTACPI_AST_NODE_F_NS_ENTRY,
@@ -2417 +2425 @@
                                                   },
     /* kAcpiAstNodeOp_External                */  RTACPI_ASL_KEYWORD_DEFINE_INVALID, /* Special handling. */
-    /* kAcpiAstNodeOp_Method                  */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "Method",                 rtAcpiTblAslParseMethod,   1, 3, RTACPI_AST_NODE_F_NEW_SCOPE),
+    /* kAcpiAstNodeOp_Method                  */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "Method",                 rtAcpiTblAslParseMethod,   1, 3, RTACPI_AST_NODE_F_NEW_SCOPE | RTACPI_AST_NODE_F_NS_ENTRY),
     /* kAcpiAstNodeOp_Device                  */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("Device",                 RTACPI_AST_NODE_F_NEW_SCOPE | RTACPI_AST_NODE_F_NS_ENTRY,   kAcpiAstArgType_NameString),
     /* kAcpiAstNodeOp_If                      */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("If",                     RTACPI_AST_NODE_F_NEW_SCOPE,                                kAcpiAstArgType_AstNode),
@@ -2613 +2621 @@
 
     PCRTACPIASLKEYWORD pAslKeyword = &g_aAslOps[enmOp];
-    PRTACPIASTNODE pAstNd = rtAcpiAstNodeAlloc(enmOp, pAslKeyword->fFlags, pAslKeyword->cArgsReq + pAslKeyword->cArgsOpt);
+    PRTACPIASTNODE pAstNd = rtAcpiAstNodeAlloc(pThis->pNs, enmOp, pAslKeyword->fFlags, pAslKeyword->cArgsReq + pAslKeyword->cArgsOpt);
     if (!pAstNd)
         return RTErrInfoSetF(pThis->pErrInfo, VERR_NO_MEMORY, "Failed to allocate ACPI AST node when processing keyword '%s'", pAslKeyword->pszOpc);
@@ -2636 +2644 @@
             if (RT_FAILURE(rc))
                 return rc;
-
-            if (i == 0 && (pAslKeyword->fFlags & RTACPI_AST_NODE_F_NS_ENTRY))
-            {
-                /*
-                 * Create a new namespace entry, we currently assume that the first argument is a namestring
-                 * which gives the path.
-                 */
-                AssertReturn(pAstNd->aArgs[0].enmType == kAcpiAstArgType_NameString, VERR_NOT_SUPPORTED);
-
-                rc = rtAcpiNsAddEntryAstNode(pThis->pNs, pAstNd->aArgs[0].u.pszNameString, pAstNd, true /*fSwitchTo*/);
-                if (RT_FAILURE(rc))
-                    return rc;
-            }
 
             /* There must be a "," between required arguments, not counting the last required argument because it can be closed with ")". */
@@ -2698 +2693 @@
         /* Now there must be a closing ) */
         RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_CLOSE_BRACKET, ')');
+
+        if (pAslKeyword->fFlags & RTACPI_AST_NODE_F_NS_ENTRY)
+        {
+            /*
+             * Create a new namespace entry, we currently assume that the first argument is a namestring
+             * which gives the path.
+             */
+            AssertReturn(pAstNd->aArgs[0].enmType == kAcpiAstArgType_NameString, VERR_NOT_SUPPORTED);
+
+            rc = rtAcpiNsAddEntryAstNode(pThis->pNs, pAstNd->aArgs[0].u.pszNameString, pAstNd, RT_BOOL(pAslKeyword->fFlags & RTACPI_AST_NODE_F_NEW_SCOPE) /*fSwitchTo*/);
+            if (RT_FAILURE(rc))
+                return rc;
+        }
+        else if (pAslKeyword->fFlags & RTACPI_AST_NODE_F_NS_SWITCH)
+        {
+            AssertReturn(pAstNd->aArgs[0].enmType == kAcpiAstArgType_NameString, VERR_NOT_SUPPORTED);
+            Assert(pAslKeyword->fFlags & RTACPI_AST_NODE_F_NEW_SCOPE);
+
+            rc = rtAcpiNsSwitchTo(pThis->pNs, pAstNd->aArgs[0].u.pszNameString);
+            if (RT_FAILURE(rc))
+                return rc;
+        }
+
     }
 
@@ -2707 +2725 @@
         if (RT_SUCCESS(rc))
             RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_CLOSE_CURLY_BRACKET, '}');
-    }
-
-    if (pAslKeyword->fFlags & RTACPI_AST_NODE_F_NS_ENTRY)
-        rtAcpiNsPop(pThis->pNs);
+
+        if (pAslKeyword->fFlags & (RTACPI_AST_NODE_F_NS_ENTRY | RTACPI_AST_NODE_F_NS_SWITCH))
+            rtAcpiNsPop(pThis->pNs);
+    }
 
     return rc;
@@ -2761 +2779 @@
     }
 
-    PRTACPIASTNODE pAstNd = rtAcpiAstNodeAlloc(kAcpiAstNodeOp_Identifier, RTACPI_AST_NODE_F_DEFAULT, cArgs);
+    PRTACPIASTNODE pAstNd = rtAcpiAstNodeAlloc(pThis->pNs, kAcpiAstNodeOp_Identifier, RTACPI_AST_NODE_F_DEFAULT, cArgs);
     if (!pAstNd)
         return RTErrInfoSetF(pThis->pErrInfo, VERR_NO_MEMORY, "Failed to allocate ACPI AST node when processing identifier '%s'", pszIde);
@@ -2826 +2844 @@
     else if (pTok->enmType == RTSCRIPTLEXTOKTYPE_STRINGLIT)
     {
-        pAstNd = rtAcpiAstNodeAlloc(kAcpiAstNodeOp_StringLiteral, RTACPI_AST_NODE_F_DEFAULT, 0);
+        pAstNd = rtAcpiAstNodeAlloc(pThis->pNs, kAcpiAstNodeOp_StringLiteral, RTACPI_AST_NODE_F_DEFAULT, 0);
         if (!pAstNd)
             return RTErrInfoSetF(pThis->pErrInfo, VERR_NO_MEMORY, "Failed to allocate ACPI AST node when processing identifier '%s'",
@@ -2837 +2855 @@
     {
         Assert(pTok->Type.Number.enmType == RTSCRIPTLEXTOKNUMTYPE_NATURAL);
-        pAstNd = rtAcpiAstNodeAlloc(kAcpiAstNodeOp_Number, RTACPI_AST_NODE_F_DEFAULT, 0);
+        pAstNd = rtAcpiAstNodeAlloc(pThis->pNs, kAcpiAstNodeOp_Number, RTACPI_AST_NODE_F_DEFAULT, 0);
         if (!pAstNd)
             return RTErrInfoSetF(pThis->pErrInfo, VERR_NO_MEMORY, "Failed to allocate ACPI AST node when processing number '%#RX64'",

trunk/src/VBox/Runtime/common/acpi/acpi-ns.cpp

@@ -41 +41 @@
 #define LOG_GROUP RTLOGGROUP_ACPI
 #include <iprt/assert.h>
-#include <iprt/errcore.h>
+#include <iprt/err.h>
 #include <iprt/list.h>
 #include <iprt/mem.h>
@@ -77 +77 @@
     }
     RTMemFree(pNsEntry);
+}
+
+
+static PRTACPINSENTRY rtAcpiNsLookupWorkerSingleNameSeg(PCRTACPINSENTRY pNsEntry, const char *pszNameSeg)
+{
+    do
+    {
+        PRTACPINSENTRY pIt;
+        RTListForEach(&pNsEntry->LstNsEntries, pIt, RTACPINSENTRY, NdNs)
+        {
+            if (!memcmp(&pIt->achNameSeg[0], pszNameSeg, sizeof(pIt->achNameSeg)))
+                return pIt;
+        }
+
+        pNsEntry = pNsEntry->pParent;
+    } while (pNsEntry);
+
+    return NULL;
 }
 
@@ -117 +135 @@
     }
     else
+    {
         pNsEntry = pNsRoot->aNsStack[pNsRoot->idxNsStack];
+
+        /* For single name segments there is a special search rule which searches recursively upwards in the namespace. */
+        if (pszNameString[4] == '\0')
+        {
+            if (fExcludeLast)
+            {
+                AssertPtr(ppszNameSegLast);
+                *ppszNameSegLast = pszNameString;
+                return pNsEntry;
+            }
+            else
+                return rtAcpiNsLookupWorkerSingleNameSeg(pNsEntry, pszNameString);
+        }
+    }
 
     /* This ASSUMES the namestring has always full 4 character name segments and is well formed. */
@@ -157 +190 @@
 
 /**
+ * Looks up a name string under the specified entry.
+ *
+ * @returns Pointer to the namespace entry or NULL if not found.
+ * @param   pNsEntry            The namespace entry to start searching at.
+ * @param   pszNameString       The name string to look for.
+ */
+static PCRTACPINSENTRY rtAcpiNsLookupSubTree(PCRTACPINSENTRY pNsEntry, const char *pszNameString)
+{
+    /* This ASSUMES the namestring has always full 4 character name segments and is well formed. */
+    do
+    {
+        Assert(pszNameString[0] != '\0' && pszNameString[1] != '\0' && pszNameString[2] != '\0' && pszNameString[3] != '\0');
+
+        PCRTACPINSENTRY pIt;
+        bool fFound = false;
+        RTListForEach(&pNsEntry->LstNsEntries, pIt, RTACPINSENTRY, NdNs)
+        {
+            if (!memcmp(&pIt->achNameSeg[0], pszNameString, sizeof(pIt->achNameSeg)))
+            {
+                pNsEntry = pIt;
+                fFound = true;
+                break;
+            }
+        }
+
+        /* The name path is invalid. */
+        if (!fFound)
+            return NULL;
+
+        pszNameString += 4;
+    } while (*pszNameString++ == '.');
+
+    return pNsEntry;
+}
+
+
+/**
  * Adds a new entry in the given namespace under the given path.
  *
@@ -163 +233 @@
  * @param   pszNameString       The namestring to add.
  * @param   fSwitchTo           Flag whether to switch to the new entry.
+ * @param   fIgnoreExisting     Flag whether to ignore any existing entry in the namespace parents.
  * @param   ppNsEntry           Where to store the pointer to the created entry on success.
  */
-static int rtAcpiNsAddEntryWorker(PRTACPINSROOT pNsRoot, const char *pszNameString, bool fSwitchTo, PRTACPINSENTRY *ppNsEntry)
+static int rtAcpiNsAddEntryWorker(PRTACPINSROOT pNsRoot, const char *pszNameString, bool fSwitchTo, bool fIgnoreExisting, PRTACPINSENTRY *ppNsEntry)
 {
     AssertReturn(   !fSwitchTo
                  || pNsRoot->idxNsStack < RT_ELEMENTS(pNsRoot->aNsStack),
                  VERR_INVALID_STATE);
+
+    /* Does it exist already? */
+    if (!fIgnoreExisting)
+    {
+        PRTACPINSENTRY pNsEntry = rtAcpiNsLookupWorker(pNsRoot, pszNameString, false /*fExcludeLast*/, NULL);
+        if (pNsEntry)
+        {
+            *ppNsEntry = pNsEntry;
+            if (fSwitchTo)
+                pNsRoot->aNsStack[++pNsRoot->idxNsStack] = pNsEntry;
+            return VERR_ALREADY_EXISTS;
+        }
+    }
 
     int rc;
@@ -209 +293 @@
         pNsRoot->idxNsStack        = 0;
         pNsRoot->aNsStack[pNsRoot->idxNsStack] = &pNsRoot->RootEntry;
+        /* Create the default scopes. */
+        int rc = rtAcpiNsAddEntryAstNode(pNsRoot, "\\_SB_", NULL /*pAstNd*/, false /*fSwitchTo*/);
+        if (RT_SUCCESS(rc))
+            rc = rtAcpiNsAddEntryAstNode(pNsRoot, "\\_PR_", NULL /*pAstNd*/, false /*fSwitchTo*/);
+        if (RT_SUCCESS(rc))
+            rc = rtAcpiNsAddEntryAstNode(pNsRoot, "\\_GPE", NULL /*pAstNd*/, false /*fSwitchTo*/);
+        if (RT_SUCCESS(rc))
+            rc = rtAcpiNsAddEntryAstNode(pNsRoot, "\\_SI_", NULL /*pAstNd*/, false /*fSwitchTo*/);
+        if (RT_SUCCESS(rc))
+            rc = rtAcpiNsAddEntryAstNode(pNsRoot, "\\_TZ_", NULL /*pAstNd*/, false /*fSwitchTo*/);
+        Assert(RT_SUCCESS(rc) || rc == VERR_NO_MEMORY);
+        if (RT_FAILURE(rc))
+        {
+            RTMemFree(pNsRoot);
+            pNsRoot = NULL;
+        }
     }
     return pNsRoot;
@@ -226 +326 @@
 
 
+DECLHIDDEN(int) rtAcpiNsSwitchTo(PRTACPINSROOT pNsRoot, const char *pszNameString)
+{
+    PRTACPINSENTRY pNsEntry = rtAcpiNsLookup(pNsRoot, pszNameString);
+    if (!pNsEntry)
+        return VERR_NOT_FOUND;
+
+    pNsRoot->aNsStack[++pNsRoot->idxNsStack] = pNsEntry;
+    return VINF_SUCCESS;
+}
+
+
 DECLHIDDEN(int) rtAcpiNsAddEntryAstNode(PRTACPINSROOT pNsRoot, const char *pszNameString, PCRTACPIASTNODE pAstNd, bool fSwitchTo)
 {
     PRTACPINSENTRY pNsEntry = NULL;
-    int rc = rtAcpiNsAddEntryWorker(pNsRoot, pszNameString, fSwitchTo, &pNsEntry);
+    int rc = rtAcpiNsAddEntryWorker(pNsRoot, pszNameString, fSwitchTo, false /*fIgnoreExisting*/, &pNsEntry);
+    if (rc == VERR_ALREADY_EXISTS)
+        rc = VINF_SUCCESS;
     if (RT_SUCCESS(rc))
     {
@@ -243 +356 @@
 {
     PRTACPINSENTRY pNsEntry = NULL;
-    int rc = rtAcpiNsAddEntryWorker(pNsRoot, pszNameString, false /*fSwitchTo*/, &pNsEntry);
+    int rc = rtAcpiNsAddEntryWorker(pNsRoot, pszNameString, false /*fSwitchTo*/, true /*fIgnoreExisting*/, &pNsEntry);
     if (RT_SUCCESS(rc))
     {
@@ -259 +372 @@
 {
     PRTACPINSENTRY pNsEntry = NULL;
-    int rc = rtAcpiNsAddEntryWorker(pNsRoot, pszNameString, false /*fSwitchTo*/, &pNsEntry);
+    int rc = rtAcpiNsAddEntryWorker(pNsRoot, pszNameString, false /*fSwitchTo*/, false /*fIgnoreExisting*/, &pNsEntry);
     if (RT_SUCCESS(rc))
     {
@@ -350 +463 @@
 
 
+DECLHIDDEN(int) rtAcpiNsCompressNameString(PCRTACPINSROOT pNsRoot, PCRTACPINSENTRY pNsEntry, const char *pszNameString, char *pszNameStringComp, size_t cchNameStringComp)
+{
+    size_t cchNameString = strlen(pszNameString);
+    if (cchNameString > cchNameStringComp)
+        return VERR_BUFFER_OVERFLOW;
+
+    if (   *pszNameString != '\\'
+        || pNsEntry != rtAcpiNsGetCurrent(pNsRoot))
+    {
+        memcpy(pszNameStringComp, pszNameString, cchNameString + 1);
+        return VINF_SUCCESS;
+    }
+
+    /* Try to remove as many components as possible. */
+    uint32_t cEntries = 0;
+    PCRTACPINSENTRY aNsEntries[255]; /* Maximum amount of name segments possible. */
+    do
+    {
+        aNsEntries[cEntries++] = pNsEntry;
+        pNsEntry = pNsEntry->pParent;
+    } while (pNsEntry);
+
+    Assert(cEntries > 0); /* Should have at least the root entry. */
+
+    /* Remove the \ specifier. */
+    pszNameString++;
+    cchNameString--;
+    uint32_t idxEntry = 1;
+    while (idxEntry < cEntries)
+    {
+        pNsEntry = aNsEntries[idxEntry++];
+        if (memcmp(pszNameString, &pNsEntry->achNameSeg[0], sizeof(pNsEntry->achNameSeg)))
+            break;
+
+        Assert(pszNameString[4] == '.');
+        pszNameString += 5;
+        cchNameString -= 5;
+    }
+
+    /* The remaining string is what we end up with. */
+    memcpy(pszNameStringComp, pszNameString, cchNameString + 1);
+    return VINF_SUCCESS;
+}
+
+
+DECLHIDDEN(int) rtAcpiNsAbsoluteNameStringToRelative(PRTACPINSROOT pNsRoot, PCRTACPINSENTRY pNsEntrySrc, const char *pszNameStringDst, char *pszNameStringRel, size_t cchNameStringRel)
+{
+    size_t cchNameStringDst = strlen(pszNameStringDst);
+    if (cchNameStringDst > cchNameStringRel)
+        return VERR_BUFFER_OVERFLOW;
+
+    /* Init with the default. */
+    memcpy(pszNameStringRel, pszNameStringDst, cchNameStringDst + 1);
+    if (*pszNameStringDst != '\\')
+        return VINF_SUCCESS;
+
+    PCRTACPINSENTRY pNsDst = rtAcpiNsLookup(pNsRoot, pszNameStringDst);
+    AssertReturn(pNsDst, VERR_NOT_FOUND);
+
+    uint32_t cEntriesSrc = 0;
+    PCRTACPINSENTRY aNsEntriesSrc[255]; /* Maximum amount of name segments possible. */
+    do
+    {
+        aNsEntriesSrc[cEntriesSrc++] = pNsEntrySrc;
+        pNsEntrySrc = pNsEntrySrc->pParent;
+    } while (pNsEntrySrc);
+
+    uint32_t cEntriesDst = 0;
+    PCRTACPINSENTRY aNsEntriesDst[255]; /* Maximum amount of name segments possible. */
+    do
+    {
+        aNsEntriesDst[cEntriesDst++] = pNsDst;
+        pNsDst = pNsDst->pParent;
+    } while (pNsDst);
+
+    Assert(cEntriesSrc > 0 && cEntriesDst > 0); /* Should have at least the root entry. */
+    uint32_t idxEntrySrc = cEntriesSrc;
+    idxEntrySrc--;
+    cEntriesDst--;
+    Assert(aNsEntriesSrc[idxEntrySrc] == aNsEntriesDst[cEntriesDst]);
+
+    /* Remove the \ specifier. */
+    size_t cchNameStringNew = cchNameStringDst;
+    pszNameStringDst++;
+    cchNameStringNew--;
+
+    /* Find the first different path entry. */
+    while (   idxEntrySrc
+           && cEntriesDst)
+    {
+        if (   aNsEntriesSrc[--idxEntrySrc] != aNsEntriesDst[--cEntriesDst]
+            || pszNameStringDst[4] == '\0')
+            break;
+
+        Assert(pszNameStringDst[4] == '.');
+        pszNameStringDst += 5;
+        cchNameStringNew -= 5;
+    }
+
+    /*
+     * Calculate how many parent prefixes we need to add.
+     * If the remaining name path is just a segment it must be a
+     * direct parent of the source and can be written as a simple name segment
+     * due to the default search rules.
+     */
+    uint32_t cParentPrefixes =   (   rtAcpiNsLookupSubTree(aNsEntriesSrc[idxEntrySrc], pszNameStringDst)
+                                  || pszNameStringDst[4] == '\0')
+                               ? 0
+                               : idxEntrySrc + 1;
+    /* Only overwrite with our result if it is shorter. */
+    if (cParentPrefixes + cchNameStringNew < cchNameStringDst)
+    {
+        for (uint32_t i = 0; i < cParentPrefixes; i++)
+            pszNameStringRel[i] = '^';
+        memcpy(&pszNameStringRel[cParentPrefixes], pszNameStringDst, cchNameStringNew + 1);
+    }
+    return VINF_SUCCESS;
+}
+
+
 DECLHIDDEN(int) rtAcpiNsPop(PRTACPINSROOT pNsRoot)
 {
@@ -358 +591 @@
 
 
-DECLHIDDEN(PCRTACPINSENTRY) rtAcpiNsLookup(PRTACPINSROOT pNsRoot, const char *pszNameString)
+DECLHIDDEN(PRTACPINSENTRY) rtAcpiNsLookup(PRTACPINSROOT pNsRoot, const char *pszNameString)
 {
     return rtAcpiNsLookupWorker(pNsRoot, pszNameString, false /*fExcludeLast*/, NULL /*ppszNameSegLast*/);
 }
+
+
+DECLHIDDEN(PCRTACPINSENTRY) rtAcpiNsGetCurrent(PCRTACPINSROOT pNsRoot)
+{
+    return pNsRoot->aNsStack[pNsRoot->idxNsStack];
+}

trunk/src/VBox/Runtime/common/acpi/acpi.cpp

@@ -1191 +1191 @@
         case kAcpiStmt_SizeOf:     bOp = ACPI_AML_BYTE_CODE_OP_SIZE_OF;     break;
         case kAcpiStmt_Increment:  bOp = ACPI_AML_BYTE_CODE_OP_INCREMENT;   break;
-        case kAcpiStmt_Decrement:  bOp = ACPI_AML_BYTE_CODE_OP_INCREMENT;   break;
+        case kAcpiStmt_Decrement:  bOp = ACPI_AML_BYTE_CODE_OP_DECREMENT;   break;
         case kAcpiStmt_CondRefOf:  bOp = ACPI_AML_BYTE_CODE_EXT_OP_COND_REF_OF; fExtOp = true; break;
         case kAcpiStmt_LNot:       bOp = ACPI_AML_BYTE_CODE_OP_LNOT;        break;
@@ -1349 +1349 @@
 
 
-DECLINLINE(uint8_t) rtAcpiTblHexCharToByte(char ch)
+DECLINLINE(uint32_t) rtAcpiTblHexCharToByte(char ch)
 {
     ch = RT_C_TO_LOWER(ch);
-    return RT_C_IS_DIGIT(ch) ? ch - '0' : ch - 'a';
+    return RT_C_IS_DIGIT(ch) ? ch - '0' : 10 + ch - 'a';
 }
 
@@ -1371 +1371 @@
                  VERR_INVALID_PARAMETER);
 
-    uint8_t bMfgCode0 = pszEisaId[0] - 0x40;
-    uint8_t bMfgCode1 = pszEisaId[1] - 0x40;
-    uint8_t bMfgCode2 = pszEisaId[2] - 0x40;
-
-    uint8_t abDword[4] = { 0 };
-    abDword[0] = (bMfgCode0 << 2) | (bMfgCode1 >> 3);
-    abDword[1] = (bMfgCode1 << 5) | bMfgCode2;
-    abDword[2] = (rtAcpiTblHexCharToByte(pszEisaId[3]) << 4) | rtAcpiTblHexCharToByte(pszEisaId[4]);
-    abDword[3] = (rtAcpiTblHexCharToByte(pszEisaId[5]) << 4) | rtAcpiTblHexCharToByte(pszEisaId[6]);
-    rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_PREFIX_DWORD);
-    rtAcpiTblAppendData(pThis, &abDword[0], sizeof(abDword));
-    return pThis->rcErr;
+    uint32_t bMfgCode0 = (pszEisaId[0] - 0x40) & 0x1f;
+    uint32_t bMfgCode1 = (pszEisaId[1] - 0x40) & 0x1f;
+    uint32_t bMfgCode2 = (pszEisaId[2] - 0x40) & 0x1f;
+
+    uint32_t u32 =   ((bMfgCode0 << 2) | ((bMfgCode1 >> 3) & 0x3))
+                   | (((bMfgCode1 & 0x7) << 5) | bMfgCode2) << 8
+                   | ((rtAcpiTblHexCharToByte(pszEisaId[3]) << 4) | rtAcpiTblHexCharToByte(pszEisaId[4])) << 16
+                   | ((rtAcpiTblHexCharToByte(pszEisaId[5]) << 4) | rtAcpiTblHexCharToByte(pszEisaId[6])) << 24;
+    return RTAcpiTblIntegerAppend(hAcpiTbl, u32);
 }
 
@@ -1769 +1766 @@
 
     *pb++ = ACPI_RSRCS_TAG_END;
-#if 1
+#if 0
     /*
      * Generate checksum, we could just write 0 here which will be treated as checksum operation succeeded,
@@ -2268 +2265 @@
 
     bool fDefaultCfg = fEdgeTriggered && !fActiveLow && !fShared && !fWakeCapable;
-    uint8_t *pb = rtAcpiResBufEnsureSpace(pThis, 2 + (fDefaultCfg ? 0 : 1));
+    uint8_t *pb = rtAcpiResBufEnsureSpace(pThis, 3 + (fDefaultCfg ? 0 : 1));
     if (!pb)
         return VERR_NO_MEMORY;

trunk/src/VBox/Runtime/include/internal/acpi.h

@@ -50 +50 @@
 /** Pointer to a const ACPI AST node. */
 typedef const struct RTACPIASTNODE *PCRTACPIASTNODE;
+/** Pointer to an ACPI namespace entry. */
+typedef struct RTACPINSENTRY *PRTACPINSENTRY;
+
+
+/**
+ * External declaration.
+ */
+typedef struct RTACPIASLEXTERNAL
+{
+    /** List node for the list of externals. */
+    RTLISTNODE              NdExternal;
+    /** The object type. */
+    RTACPIOBJTYPE           enmObjType;
+    /** For methods this will hold the argument count. */
+    uint32_t                cArgs;
+    /** The name as parsed from the source file. */
+    const char              *pszName;
+    /** Size of the full name path in characters excluding the terminating zero. */
+    size_t                  cchNamePath;
+    /** The name path - variable in size. */
+    char                    szNamePath[1];
+} RTACPIASLEXTERNAL;
+/** Pointer to an external declaration. */
+typedef RTACPIASLEXTERNAL *PRTACPIASLEXTERNAL;
+/** Pointer to a const external declaration. */
+typedef const RTACPIASLEXTERNAL *PCRTACPIASLEXTERNAL;
+
+
+/**
+ * An ACPI namespace entry.
+ */
+typedef struct RTACPINSENTRY
+{
+    /** Node for the namespace list. */
+    RTLISTNODE              NdNs;
+    /** Pointer to the parent in the namespace, NULL if this is the root. */
+    PRTACPINSENTRY          pParent;
+    /** The name segment identifying the entry. */
+    char                    achNameSeg[4];
+    /** Flag whether this points to an AST node or an external. */
+    bool                    fAstNd;
+    /** Type dependent data. */
+    union
+    {
+        /** The AST node associated with this namespace entry. */
+        PCRTACPIASTNODE     pAstNd;
+        /** Pointer to the external declaration. */
+        PCRTACPIASLEXTERNAL pExternal;
+    };
+    /** Bit offset for resource fields. */
+    uint32_t                offBits;
+    /** Bit count for resource fields. */
+    uint32_t                cBits;
+    /** List of namespace entries below this entry. */
+    RTLISTANCHOR            LstNsEntries;
+} RTACPINSENTRY;
+/** Pointer to a const ACPI namespace entry. */
+typedef const RTACPINSENTRY *PCRTACPINSENTRY;
+
 
 /**
@@ -199 +258 @@
     /** List node. */
     RTLISTNODE              NdAst;
+    /** The owning namespace entry. */
+    PCRTACPINSENTRY         pNsEntry;
     /** The AML op defining the node. */
     RTACPIASTNODEOP         enmOp;
@@ -238 +299 @@
 /** The AST node has an associated namespace entry. */
 #define RTACPI_AST_NODE_F_NS_ENTRY      RT_BIT_32(1)
-
-
-/**
- * External declaration.
- */
-typedef struct RTACPIASLEXTERNAL
-{
-    /** List node for the list of externals. */
-    RTLISTNODE              NdExternal;
-    /** The object type. */
-    RTACPIOBJTYPE           enmObjType;
-    /** For methods this will hold the argument count. */
-    uint32_t                cArgs;
-    /** The name as parsed from the source file. */
-    const char              *pszName;
-    /** Size of the full name path in characters excluding the terminating zero. */
-    size_t                  cchNamePath;
-    /** The name path - variable in size. */
-    char                    szNamePath[1];
-} RTACPIASLEXTERNAL;
-/** Pointer to an external declaration. */
-typedef RTACPIASLEXTERNAL *PRTACPIASLEXTERNAL;
-/** Pointer to a const external declaration. */
-typedef const RTACPIASLEXTERNAL *PCRTACPIASLEXTERNAL;
-
-
-
-/** Pointer to an ACPI namespace entry. */
-typedef struct RTACPINSENTRY *PRTACPINSENTRY;
-
-
-/**
- * An ACPI namespace entry.
- */
-typedef struct RTACPINSENTRY
-{
-    /** Node for the namespace list. */
-    RTLISTNODE              NdNs;
-    /** Pointer to the parent in the namespace, NULL if this is the root. */
-    PRTACPINSENTRY          pParent;
-    /** The name segment identifying the entry. */
-    char                    achNameSeg[4];
-    /** Flag whether this points to an AST node or an external. */
-    bool                    fAstNd;
-    /** Type dependent data. */
-    union
-    {
-        /** The AST node associated with this namespace entry. */
-        PCRTACPIASTNODE     pAstNd;
-        /** Pointer to the external declaration. */
-        PCRTACPIASLEXTERNAL pExternal;
-    };
-    /** Bit offset for resource fields. */
-    uint32_t                offBits;
-    /** Bit count for resource fields. */
-    uint32_t                cBits;
-    /** List of namespace entries below this entry. */
-    RTLISTANCHOR            LstNsEntries;
-} RTACPINSENTRY;
-/** Pointer to a const ACPI namespace entry. */
-typedef const RTACPINSENTRY *PCRTACPINSENTRY;
+/** The AST node switches the namespace (only Scope). */
+#define RTACPI_AST_NODE_F_NS_SWITCH     RT_BIT_32(2)
 
 
@@ -324 +326 @@
  *
  * @returns Pointer to the new ACPI AST node or NULL if out of memory.
+ * @param   pNs                 The namespace this AST node will be part of.
  * @param   enmOp               The operation of the AST node.
  * @param   fFlags              Flags for this node.
  * @param   cArgs               Number of arguments to allocate.
  */
-DECLHIDDEN(PRTACPIASTNODE) rtAcpiAstNodeAlloc(RTACPIASTNODEOP enmOp, uint32_t fFlags, uint8_t cArgs);
+DECLHIDDEN(PRTACPIASTNODE) rtAcpiAstNodeAlloc(PCRTACPINSROOT pNs, RTACPIASTNODEOP enmOp, uint32_t fFlags, uint8_t cArgs);
 
 
@@ -367 +370 @@
  */
 DECLHIDDEN(void) rtAcpiNsDestroy(PRTACPINSROOT pNsRoot);
+
+
+/**
+ * Switches to the given existing namespace.
+ *
+ * @returns IPRT status code.
+ * @param   pNsRoot             The namespace root.
+ * @param   pszNameString       The namespace to switch to.
+ */
+DECLHIDDEN(int) rtAcpiNsSwitchTo(PRTACPINSROOT pNsRoot, const char *pszNameString);
 
 
@@ -420 +433 @@
 
 /**
+ * Tries to compress the given name string to a shorter representation.
+ *
+ * @returns IPRT status code.
+ * @param   pNsRoot             The namespace root.
+ * @param   pNsEntry            The namespace entry the namestring belongs to.
+ * @param   pszNameString       The name string to try to compress.
+ * @param   pszNameStringComp   Where to store the result.
+ * @param   cchNameStringComp   Size of the buffer in characters.
+ *
+ * @note This will only try to compress absolute name paths by converting it to a relative one
+ *       (\SEG1 -> SEG1 for example if the current scope is \) Otherwise the string is just copied as is.
+ */
+DECLHIDDEN(int) rtAcpiNsCompressNameString(PCRTACPINSROOT pNsRoot, PCRTACPINSENTRY pNsEntry, const char *pszNameString, char *pszNameStringComp, size_t cchNameStringComp);
+
+
+/**
+ * Tries to convert an absolute namestring to a relative one from the given namespace.
+ *
+ * @returns IPRT status code.
+ * @param   pNsRoot             The namespace root.
+ * @param   pNsEntrySrc         The source namespace.
+ * @param   pszNameStringDst    The destination name string to try to convert.
+ * @param   pszNameStringRel    Where to store the result.
+ * @param   cchNameStringRel    Size of the buffer in characters.
+ *
+ * @note This will only try to resolve absolute name paths. Others are just copied as is.
+ */
+DECLHIDDEN(int) rtAcpiNsAbsoluteNameStringToRelative(PRTACPINSROOT pNsRoot, PCRTACPINSENTRY pNsEntrySrc,
+                                                     const char *pszNameStringDst,
+                                                     char *pszNameStringRel, size_t cchNameStringRel);
+
+
+/**
  * Pops the current name space entry from the stack and returns to the previous one.
  *
@@ -435 +481 @@
  * @param   pszNameString       The ACPI NameString (either segment or path) to lookup.
  */
-DECLHIDDEN(PCRTACPINSENTRY) rtAcpiNsLookup(PRTACPINSROOT pNsRoot, const char *pszNameString);
+DECLHIDDEN(PRTACPINSENTRY) rtAcpiNsLookup(PRTACPINSROOT pNsRoot, const char *pszNameString);
+
+
+/**
+ * Returns the current namespace entry being active.
+ *
+ * @returns Pointer to the current namespace entry.
+ * @param   pNsRoot             The namespace root.
+ */
+DECLHIDDEN(PCRTACPINSENTRY) rtAcpiNsGetCurrent(PCRTACPINSROOT pNsRoot);