VirtualBox

Changeset 108095 in vbox


Ignore:
Timestamp:
Feb 6, 2025 10:49:06 AM (2 weeks ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
167393
Message:

Runtime/RTAcpi*: Implement SizeOf, While, Increment, Decrement, CondRefOf and IndexField terms, bugref:10733

Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/iprt/acpi.h

    r108089 r108095  
    480480    kAcpiStmt_DerefOf,
    481481    /** Store(SuperName, TermArg => Integer) statement. */
    482     kAcpiStmt_Notify
     482    kAcpiStmt_Notify,
     483    /** SizeOf(SuperName) statement. */
     484    kAcpiStmt_SizeOf,
     485    /** Increment(TermArg) statement. */
     486    kAcpiStmt_Increment,
     487    /** Decrement(TermArg) statement. */
     488    kAcpiStmt_Decrement,
     489    /** CondRefOf(TermArg, Target) statement. */
     490    kAcpiStmt_CondRefOf,
    483491} RTACPISTMT;
    484492
    … …  
    528536 */
    529537RTDECL(int) RTAcpiTblElseFinalize(RTACPITBL hAcpiTbl);
     538
     539
     540/**
     541 * Starts a new While statement operation.
     542 *
     543 * @returns IPRT status code.
     544 * @param   hAcpiTbl            The ACPI table handle.
     545 */
     546RTDECL(int) RTAcpiTblWhileStart(RTACPITBL hAcpiTbl);
     547
     548
     549/**
     550 * Finalizes the current While statement operation.
     551 *
     552 * @returns IPRT status code.
     553 * @param   hAcpiTbl            The ACPI table handle.
     554 */
     555RTDECL(int) RTAcpiTblWhileFinalize(RTACPITBL hAcpiTbl);
    530556
    531557

  • trunk/include/iprt/mangling.h

    r108087 r108095  
    434434# define RTAcpiTblUuidAppend                            RT_MANGLER(RTAcpiTblUuidAppend)
    435435# define RTAcpiTblUuidAppendFromStr                     RT_MANGLER(RTAcpiTblUuidAppendFromStr)
     436# define RTAcpiTblWhileFinalize                         RT_MANGLER(RTAcpiTblWhileFinalize)
     437# define RTAcpiTblWhileStart                            RT_MANGLER(RTAcpiTblWhileStart)
    436438# define RTArchValToString                              RT_MANGLER(RTArchValToString)
    437439# define RTAssertAreQuiet                               RT_MANGLER(RTAssertAreQuiet)

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

    r108088 r108095  
    332332            break;
    333333        }
     334        case kAcpiAstNodeOp_While:
     335        {
     336            AssertBreakStmt(   pAstNd->cArgs == 1
     337                            && pAstNd->aArgs[0].enmType == kAcpiAstArgType_AstNode,
     338                            rc = VERR_INTERNAL_ERROR);
     339            rc = RTAcpiTblWhileStart(hAcpiTbl);
     340            if (RT_SUCCESS(rc))
     341            {
     342                /* Predicate. */
     343                rc = rtAcpiAstDumpToTbl(pAstNd->aArgs[0].u.pAstNd, hAcpiTbl);
     344                if (RT_SUCCESS(rc))
     345                {
     346                    /* Walk all the other AST nodes. */
     347                    rc = rtAcpiAstDumpAstList(&pAstNd->LstScopeNodes, hAcpiTbl);
     348                    if (RT_SUCCESS(rc))
     349                        rc = RTAcpiTblWhileFinalize(hAcpiTbl);
     350                }
     351            }
     352            break;
     353        }
    334354        case kAcpiAstNodeOp_LAnd:
    335355        case kAcpiAstNodeOp_LEqual:
    … …  
    591611        }
    592612        case kAcpiAstNodeOp_DerefOf:
     613        case kAcpiAstNodeOp_SizeOf:
     614        case kAcpiAstNodeOp_Increment:
     615        case kAcpiAstNodeOp_Decrement:
    593616        {
    594617            AssertBreakStmt(   pAstNd->cArgs == 1
    595618                            && pAstNd->aArgs[0].enmType == kAcpiAstArgType_AstNode,
    596619                            rc = VERR_INTERNAL_ERROR);
    597             rc = RTAcpiTblStmtSimpleAppend(hAcpiTbl, kAcpiStmt_DerefOf);
     620
     621            RTACPISTMT enmStmt;
     622            switch (pAstNd->enmOp)
     623            {
     624                case kAcpiAstNodeOp_DerefOf:   enmStmt = kAcpiStmt_DerefOf;   break;
     625                case kAcpiAstNodeOp_SizeOf:    enmStmt = kAcpiStmt_SizeOf;    break;
     626                case kAcpiAstNodeOp_Increment: enmStmt = kAcpiStmt_Increment; break;
     627                case kAcpiAstNodeOp_Decrement: enmStmt = kAcpiStmt_Decrement; break;
     628                default:
     629                    AssertReleaseFailed(); /* Impossible */
     630                    return VERR_INTERNAL_ERROR;
     631            }
     632
     633
     634            rc = RTAcpiTblStmtSimpleAppend(hAcpiTbl, enmStmt);
    598635            if (RT_SUCCESS(rc))
    599636                rc = rtAcpiAstDumpToTbl(pAstNd->aArgs[0].u.pAstNd, hAcpiTbl);
    … …  
    618655        }
    619656        case kAcpiAstNodeOp_Not:
     657        case kAcpiAstNodeOp_CondRefOf:
    620658        {
    621659            AssertBreakStmt(   pAstNd->cArgs == 2
    … …  
    623661                            && pAstNd->aArgs[1].enmType == kAcpiAstArgType_AstNode,
    624662                            rc = VERR_INTERNAL_ERROR);
    625             rc = RTAcpiTblStmtSimpleAppend(hAcpiTbl, kAcpiStmt_Store);
     663            rc = RTAcpiTblStmtSimpleAppend(hAcpiTbl,
     664                                             pAstNd->enmOp == kAcpiAstNodeOp_Not
     665                                           ? kAcpiStmt_Not
     666                                           : kAcpiStmt_CondRefOf);
    626667            if (RT_SUCCESS(rc))
    627668                rc = rtAcpiAstDumpToTbl(pAstNd->aArgs[0].u.pAstNd, hAcpiTbl);

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

    r108088 r108095  
    290290    { RT_STR_TUPLE("NOT"),                      RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_Not                               },
    291291    { RT_STR_TUPLE("NOTIFY"),                   RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_Notify                            },
     292    { RT_STR_TUPLE("SIZEOF"),                   RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_SizeOf                            },
     293    { RT_STR_TUPLE("WHILE"),                    RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_While                             },
     294    { RT_STR_TUPLE("INCREMENT"),                RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_Increment                         },
     295    { RT_STR_TUPLE("DECREMENT"),                RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_Decrement                         },
     296    { RT_STR_TUPLE("CONDREFOF"),                RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_CondRefOf                         },
     297    { RT_STR_TUPLE("INDEXFIELD"),               RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_IndexField                        },
    292298
    293299    /* Keywords not in the operation parser table. */
    … …  
    10691075
    10701076
    1071 static DECLCALLBACK(int) rtAcpiTblAslParseField(PRTACPIASLCU pThis, PCRTACPIASLKEYWORD pKeyword, PRTACPIASTNODE pAstNd)
     1077static DECLCALLBACK(int) rtAcpiTblAslParseFieldOrIndexField(PRTACPIASLCU pThis, PCRTACPIASLKEYWORD pKeyword, PRTACPIASTNODE pAstNd)
    10721078{
    10731079    RT_NOREF(pKeyword);
    10741080
    10751081    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_OPEN_BRACKET, '(');
     1082
     1083    uint8_t idxArg = 0;
     1084
     1085    if (pKeyword->cArgsReq == 5)
     1086    {
     1087        /* This is an IndexField. */
     1088
     1089        /* Namestring is required. */
     1090        RTACPIASL_PARSE_NAME_STRING(pszNameString);
     1091        pAstNd->aArgs[idxArg].enmType         = kAcpiAstArgType_NameString;
     1092        pAstNd->aArgs[idxArg].u.pszNameString = pszNameString;
     1093        idxArg++;
     1094
     1095        RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1096    }
     1097    else /* Field */
     1098        Assert(pKeyword->cArgsReq == 4);
    10761099
    10771100    /* Namestring is required. */
    10781101    RTACPIASL_PARSE_NAME_STRING(pszNameString);
    1079     pAstNd->aArgs[0].enmType         = kAcpiAstArgType_NameString;
    1080     pAstNd->aArgs[0].u.pszNameString = pszNameString;
     1102    pAstNd->aArgs[idxArg].enmType         = kAcpiAstArgType_NameString;
     1103    pAstNd->aArgs[idxArg].u.pszNameString = pszNameString;
     1104    idxArg++;
    10811105
    10821106    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
    … …  
    10841108    /* Must have an access type defined. */
    10851109    RTACPIASL_PARSE_KEYWORD_LIST(enmAccessType, g_aenmAccessTypeKeywords);
    1086     pAstNd->aArgs[1].enmType = kAcpiAstArgType_FieldAcc;
     1110    pAstNd->aArgs[idxArg].enmType = kAcpiAstArgType_FieldAcc;
    10871111    switch (enmAccessType)
    10881112    {
    1089         case RTACPIASLTERMINAL_KEYWORD_ANY_ACC:    pAstNd->aArgs[1].u.enmFieldAcc = kAcpiFieldAcc_Any;    break;
    1090         case RTACPIASLTERMINAL_KEYWORD_BYTE_ACC:   pAstNd->aArgs[1].u.enmFieldAcc = kAcpiFieldAcc_Byte;   break;
    1091         case RTACPIASLTERMINAL_KEYWORD_WORD_ACC:   pAstNd->aArgs[1].u.enmFieldAcc = kAcpiFieldAcc_Word;   break;
    1092         case RTACPIASLTERMINAL_KEYWORD_DWORD_ACC:  pAstNd->aArgs[1].u.enmFieldAcc = kAcpiFieldAcc_DWord;  break;
    1093         case RTACPIASLTERMINAL_KEYWORD_QWORD_ACC:  pAstNd->aArgs[1].u.enmFieldAcc = kAcpiFieldAcc_QWord;  break;
    1094         case RTACPIASLTERMINAL_KEYWORD_BUFFER_ACC: pAstNd->aArgs[1].u.enmFieldAcc = kAcpiFieldAcc_Buffer; break;
     1113        case RTACPIASLTERMINAL_KEYWORD_ANY_ACC:    pAstNd->aArgs[idxArg].u.enmFieldAcc = kAcpiFieldAcc_Any;    break;
     1114        case RTACPIASLTERMINAL_KEYWORD_BYTE_ACC:   pAstNd->aArgs[idxArg].u.enmFieldAcc = kAcpiFieldAcc_Byte;   break;
     1115        case RTACPIASLTERMINAL_KEYWORD_WORD_ACC:   pAstNd->aArgs[idxArg].u.enmFieldAcc = kAcpiFieldAcc_Word;   break;
     1116        case RTACPIASLTERMINAL_KEYWORD_DWORD_ACC:  pAstNd->aArgs[idxArg].u.enmFieldAcc = kAcpiFieldAcc_DWord;  break;
     1117        case RTACPIASLTERMINAL_KEYWORD_QWORD_ACC:  pAstNd->aArgs[idxArg].u.enmFieldAcc = kAcpiFieldAcc_QWord;  break;
     1118        case RTACPIASLTERMINAL_KEYWORD_BUFFER_ACC: pAstNd->aArgs[idxArg].u.enmFieldAcc = kAcpiFieldAcc_Buffer; break;
    10951119        default:
    10961120            AssertFailedReturn(VERR_INTERNAL_ERROR);
    10971121    }
     1122    idxArg++;
    10981123
    10991124    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
    … …  
    11011126    /* Must have a lock rule defined. */
    11021127    RTACPIASL_PARSE_KEYWORD_LIST(enmLockRule, g_aenmLockRuleKeywords);
    1103     pAstNd->aArgs[2].enmType = kAcpiAstArgType_Bool;
     1128    pAstNd->aArgs[idxArg].enmType = kAcpiAstArgType_Bool;
    11041129    switch (enmLockRule)
    11051130    {
    1106         case RTACPIASLTERMINAL_KEYWORD_LOCK:    pAstNd->aArgs[2].u.f = true;  break;
    1107         case RTACPIASLTERMINAL_KEYWORD_NO_LOCK: pAstNd->aArgs[2].u.f = false; break;
     1131        case RTACPIASLTERMINAL_KEYWORD_LOCK:    pAstNd->aArgs[idxArg].u.f = true;  break;
     1132        case RTACPIASLTERMINAL_KEYWORD_NO_LOCK: pAstNd->aArgs[idxArg].u.f = false; break;
    11081133        default:
    11091134            AssertFailedReturn(VERR_INTERNAL_ERROR);
    11101135    }
     1136    idxArg++;
    11111137
    11121138    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
    … …  
    11141140    /* Must have an update rule defined. */
    11151141    RTACPIASL_PARSE_KEYWORD_LIST(enmUpdateRule, g_aenmUpdateRuleKeywords);
    1116     pAstNd->aArgs[3].enmType = kAcpiAstArgType_FieldUpdate;
     1142    pAstNd->aArgs[idxArg].enmType = kAcpiAstArgType_FieldUpdate;
    11171143    switch (enmUpdateRule)
    11181144    {
    1119         case RTACPIASLTERMINAL_KEYWORD_PRESERVE:        pAstNd->aArgs[3].u.enmFieldUpdate = kAcpiFieldUpdate_Preserve;      break;
    1120         case RTACPIASLTERMINAL_KEYWORD_WRITE_AS_ONES:   pAstNd->aArgs[3].u.enmFieldUpdate = kAcpiFieldUpdate_WriteAsOnes;   break;
    1121         case RTACPIASLTERMINAL_KEYWORD_WRITE_AS_ZEROES: pAstNd->aArgs[3].u.enmFieldUpdate = kAcpiFieldUpdate_WriteAsZeroes; break;
     1145        case RTACPIASLTERMINAL_KEYWORD_PRESERVE:        pAstNd->aArgs[idxArg].u.enmFieldUpdate = kAcpiFieldUpdate_Preserve;      break;
     1146        case RTACPIASLTERMINAL_KEYWORD_WRITE_AS_ONES:   pAstNd->aArgs[idxArg].u.enmFieldUpdate = kAcpiFieldUpdate_WriteAsOnes;   break;
     1147        case RTACPIASLTERMINAL_KEYWORD_WRITE_AS_ZEROES: pAstNd->aArgs[idxArg].u.enmFieldUpdate = kAcpiFieldUpdate_WriteAsZeroes; break;
    11221148        default:
    11231149            AssertFailedReturn(VERR_INTERNAL_ERROR);
    11241150    }
     1151    idxArg++;
    11251152
    11261153    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_CLOSE_BRACKET, ')');
    … …  
    14491476    /* kAcpiAstNodeOp_LLess             */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("LLess",            RTACPI_AST_NODE_F_DEFAULT,   kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    14501477    /* kAcpiAstNodeOp_LLessEqual        */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("LLessEqual",       RTACPI_AST_NODE_F_DEFAULT,   kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1451     /* kAcpiAstNodeOp_LNot              */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("LNot",             RTACPI_AST_NODE_F_DEFAULT,   kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     1478    /* kAcpiAstNodeOp_LNot              */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("LNot",             RTACPI_AST_NODE_F_DEFAULT,  kAcpiAstArgType_AstNode),
    14521479    /* kAcpiAstNodeOp_LNotEqual         */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("LNotEqual",        RTACPI_AST_NODE_F_DEFAULT,   kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    14531480    /* kAcpiAstNodeOp_Zero              */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Zero",             RTACPI_AST_NODE_F_DEFAULT),
    … …  
    14571484    /* kAcpiAstNodeOp_Unicode           */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("Unicode",          RTACPI_AST_NODE_F_DEFAULT,   kAcpiAstArgType_AstNode), /* Actually only String allowed here */
    14581485    /* kAcpiAstNodeOp_OperationRegion   */  RTACPI_ASL_KEYWORD_DEFINE_4REQ_0OPT("OperationRegion",  RTACPI_AST_NODE_F_DEFAULT,   kAcpiAstArgType_NameString, kAcpiAstArgType_RegionSpace, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1459     /* kAcpiAstNodeOp_Field             */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "Field",            rtAcpiTblAslParseField,  4, 0, RTACPI_AST_NODE_F_DEFAULT),
     1486    /* kAcpiAstNodeOp_Field             */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "Field",            rtAcpiTblAslParseFieldOrIndexField, 4, 0, RTACPI_AST_NODE_F_DEFAULT),
    14601487    /* kAcpiAstNodeOp_Name              */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("Name",             RTACPI_AST_NODE_F_DEFAULT,   kAcpiAstArgType_NameString, kAcpiAstArgType_AstNode),
    14611488    /* kAcpiAstNodeOp_ResourceTemplate  */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "ResourceTemplate", rtAcpiTblAslParseResourceTemplate,  0, 0, RTACPI_AST_NODE_F_DEFAULT),
    … …  
    14921519    /* kAcpiAstNodeOp_Not               */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_1OPT("Not",              RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    14931520    /* kAcpiAstNodeOp_Notify            */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("Notify",           RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1494 
     1521    /* kAcpiAstNodeOp_SizeOf            */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("SizeOf",           RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode),
     1522    /* kAcpiAstNodeOp_While             */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("While",            RTACPI_AST_NODE_F_NEW_SCOPE,  kAcpiAstArgType_AstNode),
     1523    /* kAcpiAstNodeOp_Increment         */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("Increment",        RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode),
     1524    /* kAcpiAstNodeOp_Decrement         */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("Decrement",        RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode),
     1525    /* kAcpiAstNodeOp_CondRefOf         */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_1OPT("CondRefOf",        RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     1526    /* kAcpiAstNodeOp_IndexField        */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "IndexField",       rtAcpiTblAslParseFieldOrIndexField, 5, 0, RTACPI_AST_NODE_F_DEFAULT),
    14951527};
    14961528

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

    r108091 r108095  
    10771077
    10781078    uint8_t bOp;
     1079    bool fExtOp = false;
    10791080    switch (enmStmt)
    10801081    {
    … …  
    10951096        case kAcpiStmt_DerefOf:    bOp = ACPI_AML_BYTE_CODE_OP_DEREF_OF;    break;
    10961097        case kAcpiStmt_Notify:     bOp = ACPI_AML_BYTE_CODE_OP_NOTIFY;      break;
     1098        case kAcpiStmt_SizeOf:     bOp = ACPI_AML_BYTE_CODE_OP_SIZE_OF;     break;
     1099        case kAcpiStmt_Increment:  bOp = ACPI_AML_BYTE_CODE_OP_INCREMENT;   break;
     1100        case kAcpiStmt_Decrement:  bOp = ACPI_AML_BYTE_CODE_OP_INCREMENT;   break;
     1101        case kAcpiStmt_CondRefOf:  bOp = ACPI_AML_BYTE_CODE_EXT_OP_COND_REF_OF; fExtOp = true; break;
    10971102        default:
    10981103            AssertFailedReturn(VERR_INVALID_PARAMETER);
    10991104    }
     1105    if (fExtOp)
     1106        rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_PREFIX_EXT_OP);
    11001107    rtAcpiTblAppendByte(pThis, bOp);
    11011108    return pThis->rcErr;
    … …  
    11381145
    11391146    return rtAcpiTblPkgFinish(pThis, ACPI_AML_BYTE_CODE_OP_ELSE);
     1147}
     1148
     1149
     1150RTDECL(int) RTAcpiTblWhileStart(RTACPITBL hAcpiTbl)
     1151{
     1152    PRTACPITBLINT pThis = hAcpiTbl;
     1153    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     1154
     1155    rtAcpiTblPkgStart(pThis, ACPI_AML_BYTE_CODE_OP_WHILE);
     1156    return pThis->rcErr;
     1157}
     1158
     1159
     1160RTDECL(int) RTAcpiTblWhileFinalize(RTACPITBL hAcpiTbl)
     1161{
     1162    PRTACPITBLINT pThis = hAcpiTbl;
     1163    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     1164
     1165    return rtAcpiTblPkgFinish(pThis, ACPI_AML_BYTE_CODE_OP_WHILE);
    11401166}
    11411167

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

    r108088 r108095  
    166166    kAcpiAstNodeOp_Not,
    167167    kAcpiAstNodeOp_Notify,
     168    kAcpiAstNodeOp_SizeOf,
     169    kAcpiAstNodeOp_While,
     170    kAcpiAstNodeOp_Increment,
     171    kAcpiAstNodeOp_Decrement,
     172    kAcpiAstNodeOp_CondRefOf,
     173    kAcpiAstNodeOp_IndexField,
    168174    kAcpiAstNodeOp_32Bit_Hack = 0x7fffffff
    169175} RTACPIASTNODEOP;
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette