Changeset 107036 in vbox

Timestamp:

Nov 19, 2024 10:05:28 AM (3 months ago)

Author:

vboxsync

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

165985

Message:

Runtime/RTAcpi*: Add new methods for adding if else statements, binary operands and referencing arguments, locals and appending UUIDs, bugref:10733

Location:

trunk

Files:

• include/iprt/acpi.h (modified) (1 diff)
• include/iprt/mangling.h (modified) (3 diffs)
• src/VBox/Runtime/common/misc/acpi.cpp (modified) (2 diffs)

trunk/include/iprt/acpi.h

@@ -333 +333 @@
  */
 RTDECL(int) RTAcpiTblStmtSimpleAppend(RTACPITBL hAcpiTbl, RTACPISTMT enmStmt);
+
+
+/**
+ * Starts a new If statement operation.
+ *
+ * @returns IPRT status code.
+ * @param   hAcpiTbl            The ACPI table handle.
+ */
+RTDECL(int) RTAcpiTblIfStart(RTACPITBL hAcpiTbl);
+
+
+/**
+ * Finalizes the current If statement operation.
+ *
+ * @returns IPRT status code.
+ * @param   hAcpiTbl            The ACPI table handle.
+ */
+RTDECL(int) RTAcpiTblIfFinalize(RTACPITBL hAcpiTbl);
+
+
+/**
+ * Starts a new Else operation (only valid if currently inside an If oepration).
+ *
+ * @returns IPRT status code.
+ * @param   hAcpiTbl            The ACPI table handle.
+ */
+RTDECL(int) RTAcpiTblElseStart(RTACPITBL hAcpiTbl);
+
+
+/**
+ * Finalizes the current Else statement operation.
+ *
+ * @returns IPRT status code.
+ * @param   hAcpiTbl            The ACPI table handle.
+ */
+RTDECL(int) RTAcpiTblElseFinalize(RTACPITBL hAcpiTbl);
+
+
+/**
+ * List of binary operations.
+ */
+typedef enum RTACPIBINARYOP
+{
+    /** Invalid binary operation. */
+    kAcpiBinaryOp_Invalid = 0,
+    /** LAnd(Operand, Operand). */
+    kAcpiBinaryOp_LAnd,
+    /** LEqual(Operand, Operand). */
+    kAcpiBinaryOp_LEqual,
+    /** LGreater(Operand, Operand). */
+    kAcpiBinaryOp_LGreater,
+    /** LGreaterEqual(Operand, Operand). */
+    kAcpiBinaryOp_LGreaterEqual,
+    /** LLess(Operand, Operand). */
+    kAcpiBinaryOp_LLess,
+    /** LLessEqual(Operand, Operand). */
+    kAcpiBinaryOp_LLessEqual,
+    /** LNotEqual(Operand, Operand). */
+    kAcpiBinaryOp_LNotEqual
+} RTACPIBINARYOP;
+
+
+/**
+ * Appends the given binary operand.
+ *
+ * @returns IPRT status code.
+ * @param   hAcpiTbl            The ACPI table handle.
+ * @param   enmBinaryOp         The binary operation to append.
+ */
+RTDECL(int) RTAcpiTblBinaryOpAppend(RTACPITBL hAcpiTbl, RTACPIBINARYOP enmBinaryOp);
+
+
+/**
+ * Appends the given Arg<idArg> operand.
+ *
+ * @returns IPRT status code.
+ * @param   hAcpiTbl            The ACPI table handle.
+ * @param   idArg               The argument ID to append [0..6].
+ */
+RTDECL(int) RTAcpiTblArgOpAppend(RTACPITBL hAcpiTbl, uint8_t idArg);
+
+
+/**
+ * Appends the given Local<idLocal> operand.
+ *
+ * @returns IPRT status code.
+ * @param   hAcpiTbl            The ACPI table handle.
+ * @param   idLocal             The local ID to append [0..7].
+ */
+RTDECL(int) RTAcpiTblLocalOpAppend(RTACPITBL hAcpiTbl, uint8_t idLocal);
+
+
+/**
+ * Appends the given UUID as a buffer object.
+ *
+ * @returns IPRT status code.
+ * @param   hAcpiTbl            The ACPI table handle.
+ * @param   pUuid               The UUID to append.
+ */
+RTDECL(int) RTAcpiTblUuidAppend(RTACPITBL hAcpiTbl, PCRTUUID pUuid);
+
+
+/**
+ * Appends the given UUID string as a UUID buffer object.
+ *
+ * @returns IPRT status code.
+ * @param   hAcpiTbl            The ACPI table handle.
+ * @param   pszUuid             The UUID string to append as a buffer.
+ */
+RTDECL(int) RTAcpiTblUuidAppendFromStr(RTACPITBL hAcpiTbl, const char *pszUuid);
 
 

trunk/include/iprt/mangling.h

@@ -388 +388 @@
 # define RTAcpiResourceReset                            RT_MANGLER(RTAcpiResourceReset)
 # define RTAcpiResourceSeal                             RT_MANGLER(RTAcpiResourceSeal)
+# define RTAcpiTblArgOpAppend                           RT_MANGLER(RTAcpiTblArgOpAppend)
+# define RTAcpiTblBinaryOpAppend                        RT_MANGLER(RTAcpiTblBinaryOpAppend)
 # define RTAcpiTblBufferAppend                          RT_MANGLER(RTAcpiTblBufferAppend)
 # define RTAcpiTblCreate                                RT_MANGLER(RTAcpiTblCreate)
@@ -397 +399 @@
 # define RTAcpiTblDumpToFile                            RT_MANGLER(RTAcpiTblDumpToFile)
 # define RTAcpiTblDumpToVfsIoStrm                       RT_MANGLER(RTAcpiTblDumpToVfsIoStrm)
+# define RTAcpiTblElseFinalize                          RT_MANGLER(RTAcpiTblElseFinalize)
+# define RTAcpiTblElseStart                             RT_MANGLER(RTAcpiTblElseStart)
 # define RTAcpiTblFinalize                              RT_MANGLER(RTAcpiTblFinalize)
 # define RTAcpiTblGetSize                               RT_MANGLER(RTAcpiTblGetSize)
 # define RTAcpiTblHdrChecksumGenerate                   RT_MANGLER(RTAcpiTblHdrChecksumGenerate)
+# define RTAcpiTblIfFinalize                            RT_MANGLER(RTAcpiTblIfFinalize)
+# define RTAcpiTblIfStart                               RT_MANGLER(RTAcpiTblIfStart)
 # define RTAcpiTblIntegerAppend                         RT_MANGLER(RTAcpiTblIntegerAppend)
+# define RTAcpiTblLocalOpAppend                         RT_MANGLER(RTAcpiTblLocalOpAppend)
 # define RTAcpiTblMethodStart                           RT_MANGLER(RTAcpiTblMethodStart)
 # define RTAcpiTblMethodFinalize                        RT_MANGLER(RTAcpiTblMethodFinalize)
@@ -411 +418 @@
 # define RTAcpiTblStmtSimpleAppend                      RT_MANGLER(RTAcpiTblStmtSimpleAppend)
 # define RTAcpiTblStringAppend                          RT_MANGLER(RTAcpiTblStringAppend)
+# define RTAcpiTblUuidAppend                            RT_MANGLER(RTAcpiTblUuidAppend)
+# define RTAcpiTblUuidAppendFromStr                     RT_MANGLER(RTAcpiTblUuidAppendFromStr)
 # define RTAssertAreQuiet                               RT_MANGLER(RTAssertAreQuiet)
 # define RTAssertMayPanic                               RT_MANGLER(RTAssertMayPanic)

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

@@ -45 +45 @@
 #include <iprt/mem.h>
 #include <iprt/string.h>
+#include <iprt/uuid.h>
 
 #include <iprt/formats/acpi-aml.h>
@@ -809 +810 @@
 
 
+RTDECL(int) RTAcpiTblIfStart(RTACPITBL hAcpiTbl)
+{
+    PRTACPITBLINT pThis = hAcpiTbl;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+
+    rtAcpiTblPkgStart(pThis, ACPI_AML_BYTE_CODE_OP_IF);
+    return pThis->rcErr;
+}
+
+
+RTDECL(int) RTAcpiTblIfFinalize(RTACPITBL hAcpiTbl)
+{
+    PRTACPITBLINT pThis = hAcpiTbl;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+
+    return rtAcpiTblPkgFinish(pThis, ACPI_AML_BYTE_CODE_OP_IF);
+}
+
+
+RTDECL(int) RTAcpiTblElseStart(RTACPITBL hAcpiTbl)
+{
+    PRTACPITBLINT pThis = hAcpiTbl;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+
+    /* Makes only sense inside an IfOp package. */
+    AssertReturn(pThis->paPkgStack[pThis->idxPkgStackElem].bOp == ACPI_AML_BYTE_CODE_OP_IF, VERR_INVALID_STATE);
+
+    rtAcpiTblPkgStartExt(pThis, ACPI_AML_BYTE_CODE_OP_ELSE);
+    return pThis->rcErr;
+}
+
+
+RTDECL(int) RTAcpiTblElseFinalize(RTACPITBL hAcpiTbl)
+{
+    PRTACPITBLINT pThis = hAcpiTbl;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+
+    return rtAcpiTblPkgFinish(pThis, ACPI_AML_BYTE_CODE_OP_ELSE);
+}
+
+
+RTDECL(int) RTAcpiTblBinaryOpAppend(RTACPITBL hAcpiTbl, RTACPIBINARYOP enmBinaryOp)
+{
+    PRTACPITBLINT pThis = hAcpiTbl;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+
+    uint8_t bOp;
+    switch (enmBinaryOp)
+    {
+        case kAcpiBinaryOp_LAnd:            bOp = ACPI_AML_BYTE_CODE_OP_LAND;     break;
+        case kAcpiBinaryOp_LEqual:          bOp = ACPI_AML_BYTE_CODE_OP_LEQUAL;   break;
+        case kAcpiBinaryOp_LGreater:        bOp = ACPI_AML_BYTE_CODE_OP_LGREATER; break;
+        case kAcpiBinaryOp_LLess:           bOp = ACPI_AML_BYTE_CODE_OP_LLESS;    break;
+        case kAcpiBinaryOp_LGreaterEqual:
+        case kAcpiBinaryOp_LLessEqual:    
+        case kAcpiBinaryOp_LNotEqual:
+            bOp = ACPI_AML_BYTE_CODE_OP_LNOT;
+            break;
+        default:
+            AssertFailedReturn(VERR_INVALID_PARAMETER);
+    }
+    rtAcpiTblAppendByte(pThis, bOp);
+    switch (enmBinaryOp)
+    {
+        case kAcpiBinaryOp_LGreaterEqual:   bOp = ACPI_AML_BYTE_CODE_OP_LLESS;    break;
+        case kAcpiBinaryOp_LLessEqual:      bOp = ACPI_AML_BYTE_CODE_OP_LGREATER; break;
+        case kAcpiBinaryOp_LNotEqual:       bOp = ACPI_AML_BYTE_CODE_OP_LEQUAL;   break;
+        default:
+            bOp = 0x00;
+    }
+    if (bOp != 0x00)
+        rtAcpiTblAppendByte(pThis, bOp);
+    return pThis->rcErr;
+}
+
+
+RTDECL(int) RTAcpiTblArgOpAppend(RTACPITBL hAcpiTbl, uint8_t idArg)
+{
+    PRTACPITBLINT pThis = hAcpiTbl;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(idArg <= 6, VERR_INVALID_PARAMETER);
+
+    rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_OP_ARG_0 + idArg);
+    return pThis->rcErr;
+}
+
+
+RTDECL(int) RTAcpiTblLocalOpAppend(RTACPITBL hAcpiTbl, uint8_t idLocal)
+{
+    PRTACPITBLINT pThis = hAcpiTbl;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+    AssertReturn(idLocal <= 7, VERR_INVALID_PARAMETER);
+
+    rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_OP_LOCAL_0 + idLocal);
+    return pThis->rcErr;
+}
+
+
+RTDECL(int) RTAcpiTblUuidAppend(RTACPITBL hAcpiTbl, PCRTUUID pUuid)
+{
+    /* UUIDs are stored as a buffer object. */
+    /** @todo Needs conversion on big endian machines. */
+    return RTAcpiTblBufferAppend(hAcpiTbl, &pUuid->au8[0], sizeof(*pUuid));
+}
+
+
+RTDECL(int) RTAcpiTblUuidAppendFromStr(RTACPITBL hAcpiTbl, const char *pszUuid)
+{
+    PRTACPITBLINT pThis = hAcpiTbl;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+
+    RTUUID Uuid;
+    pThis->rcErr = RTUuidFromStr(&Uuid, pszUuid);
+    if (RT_SUCCESS(pThis->rcErr))
+        return RTAcpiTblUuidAppend(pThis, &Uuid);
+
+    return pThis->rcErr;
+}
+
+
 /**
  * Ensures there is at least the given amount of space in the given ACPI resource.