VirtualBox

Changeset 103847 in vbox for trunk/src/VBox/VMM/VMMAll


Ignore:
Timestamp:
Mar 14, 2024 11:29:54 AM (11 months ago)
Author:
vboxsync
Message:

Move iemTbFlagsToString() to be accessible to both callers, bugref:9898

Location:
trunk/src/VBox/VMM/VMMAll
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/VMMAll/IEMAllN8veRecompiler.cpp

    r103839 r103847  
    84958495
    84968496
    8497 /**
    8498  * Formats TB flags (IEM_F_XXX and IEMTB_F_XXX) to string.
    8499  * @returns pszBuf.
    8500  * @param   fFlags  The flags.
    8501  * @param   pszBuf  The output buffer.
    8502  * @param   cbBuf   The output buffer size.  At least 32 bytes.
    8503  */
    8504 DECLHIDDEN(const char *) iemTbFlagsToString(uint32_t fFlags, char *pszBuf, size_t cbBuf) RT_NOEXCEPT
    8505 {
    8506     Assert(cbBuf >= 32);
    8507     static RTSTRTUPLE const s_aModes[] =
    8508     {
    8509         /* [00] = */ { RT_STR_TUPLE("16BIT") },
    8510         /* [01] = */ { RT_STR_TUPLE("32BIT") },
    8511         /* [02] = */ { RT_STR_TUPLE("!2!") },
    8512         /* [03] = */ { RT_STR_TUPLE("!3!") },
    8513         /* [04] = */ { RT_STR_TUPLE("16BIT_PRE_386") },
    8514         /* [05] = */ { RT_STR_TUPLE("32BIT_FLAT") },
    8515         /* [06] = */ { RT_STR_TUPLE("!6!") },
    8516         /* [07] = */ { RT_STR_TUPLE("!7!") },
    8517         /* [08] = */ { RT_STR_TUPLE("16BIT_PROT") },
    8518         /* [09] = */ { RT_STR_TUPLE("32BIT_PROT") },
    8519         /* [0a] = */ { RT_STR_TUPLE("64BIT") },
    8520         /* [0b] = */ { RT_STR_TUPLE("!b!") },
    8521         /* [0c] = */ { RT_STR_TUPLE("16BIT_PROT_PRE_386") },
    8522         /* [0d] = */ { RT_STR_TUPLE("32BIT_PROT_FLAT") },
    8523         /* [0e] = */ { RT_STR_TUPLE("!e!") },
    8524         /* [0f] = */ { RT_STR_TUPLE("!f!") },
    8525         /* [10] = */ { RT_STR_TUPLE("!10!") },
    8526         /* [11] = */ { RT_STR_TUPLE("!11!") },
    8527         /* [12] = */ { RT_STR_TUPLE("!12!") },
    8528         /* [13] = */ { RT_STR_TUPLE("!13!") },
    8529         /* [14] = */ { RT_STR_TUPLE("!14!") },
    8530         /* [15] = */ { RT_STR_TUPLE("!15!") },
    8531         /* [16] = */ { RT_STR_TUPLE("!16!") },
    8532         /* [17] = */ { RT_STR_TUPLE("!17!") },
    8533         /* [18] = */ { RT_STR_TUPLE("16BIT_PROT_V86") },
    8534         /* [19] = */ { RT_STR_TUPLE("32BIT_PROT_V86") },
    8535         /* [1a] = */ { RT_STR_TUPLE("!1a!") },
    8536         /* [1b] = */ { RT_STR_TUPLE("!1b!") },
    8537         /* [1c] = */ { RT_STR_TUPLE("!1c!") },
    8538         /* [1d] = */ { RT_STR_TUPLE("!1d!") },
    8539         /* [1e] = */ { RT_STR_TUPLE("!1e!") },
    8540         /* [1f] = */ { RT_STR_TUPLE("!1f!") },
    8541     };
    8542     AssertCompile(RT_ELEMENTS(s_aModes) == IEM_F_MODE_MASK + 1);
    8543     memcpy(pszBuf, s_aModes[fFlags & IEM_F_MODE_MASK].psz, s_aModes[fFlags & IEM_F_MODE_MASK].cch);
    8544     size_t off = s_aModes[fFlags & IEM_F_MODE_MASK].cch;
    8545 
    8546     pszBuf[off++] = ' ';
    8547     pszBuf[off++] = 'C';
    8548     pszBuf[off++] = 'P';
    8549     pszBuf[off++] = 'L';
    8550     pszBuf[off++] = '0' + ((fFlags >> IEM_F_X86_CPL_SHIFT) & IEM_F_X86_CPL_SMASK);
    8551     Assert(off < 32);
    8552 
    8553     fFlags &= ~(IEM_F_MODE_MASK | IEM_F_X86_CPL_SMASK);
    8554 
    8555     static struct { const char *pszName; uint32_t cchName; uint32_t fFlag; } const s_aFlags[] =
    8556     {
    8557         { RT_STR_TUPLE("BYPASS_HANDLERS"),      IEM_F_BYPASS_HANDLERS    },
    8558         { RT_STR_TUPLE("PENDING_BRK_INSTR"),    IEM_F_PENDING_BRK_INSTR  },
    8559         { RT_STR_TUPLE("PENDING_BRK_DATA"),     IEM_F_PENDING_BRK_DATA   },
    8560         { RT_STR_TUPLE("PENDING_BRK_X86_IO"),   IEM_F_PENDING_BRK_X86_IO },
    8561         { RT_STR_TUPLE("X86_DISREGARD_LOCK"),   IEM_F_X86_DISREGARD_LOCK },
    8562         { RT_STR_TUPLE("X86_CTX_VMX"),          IEM_F_X86_CTX_VMX        },
    8563         { RT_STR_TUPLE("X86_CTX_SVM"),          IEM_F_X86_CTX_SVM        },
    8564         { RT_STR_TUPLE("X86_CTX_IN_GUEST"),     IEM_F_X86_CTX_IN_GUEST   },
    8565         { RT_STR_TUPLE("X86_CTX_SMM"),          IEM_F_X86_CTX_SMM        },
    8566         { RT_STR_TUPLE("INHIBIT_SHADOW"),       IEMTB_F_INHIBIT_SHADOW   },
    8567         { RT_STR_TUPLE("INHIBIT_NMI"),          IEMTB_F_INHIBIT_NMI      },
    8568         { RT_STR_TUPLE("CS_LIM_CHECKS"),        IEMTB_F_CS_LIM_CHECKS    },
    8569         { RT_STR_TUPLE("TYPE_THREADED"),        IEMTB_F_TYPE_THREADED    },
    8570         { RT_STR_TUPLE("TYPE_NATIVE"),          IEMTB_F_TYPE_NATIVE      },
    8571     };
    8572     if (fFlags)
    8573         for (unsigned i = 0; i < RT_ELEMENTS(s_aFlags); i++)
    8574             if (s_aFlags[i].fFlag & fFlags)
    8575             {
    8576                 AssertReturnStmt(off + 1 + s_aFlags[i].cchName + 1 <= cbBuf, pszBuf[off] = '\0', pszBuf);
    8577                 pszBuf[off++] = ' ';
    8578                 memcpy(&pszBuf[off], s_aFlags[i].pszName, s_aFlags[i].cchName);
    8579                 off += s_aFlags[i].cchName;
    8580                 fFlags &= ~s_aFlags[i].fFlag;
    8581                 if (!fFlags)
    8582                     break;
    8583             }
    8584     pszBuf[off] = '\0';
    8585 
    8586     return pszBuf;
    8587 }
    8588 
    8589 
    85908497DECLHIDDEN(void) iemNativeDisassembleTb(PCIEMTB pTb, PCDBGFINFOHLP pHlp) RT_NOEXCEPT
    85918498{

  • trunk/src/VBox/VMM/VMMAll/IEMAllThrdRecompiler.cpp

    r103828 r103847  
    12771277*   Threaded Recompiler Core                                                                                                     *
    12781278*********************************************************************************************************************************/
     1279/**
     1280 * Formats TB flags (IEM_F_XXX and IEMTB_F_XXX) to string.
     1281 * @returns pszBuf.
     1282 * @param   fFlags  The flags.
     1283 * @param   pszBuf  The output buffer.
     1284 * @param   cbBuf   The output buffer size.  At least 32 bytes.
     1285 */
     1286DECLEXPORT(const char *) iemTbFlagsToString(uint32_t fFlags, char *pszBuf, size_t cbBuf) RT_NOEXCEPT
     1287{
     1288    Assert(cbBuf >= 32);
     1289    static RTSTRTUPLE const s_aModes[] =
     1290    {
     1291        /* [00] = */ { RT_STR_TUPLE("16BIT") },
     1292        /* [01] = */ { RT_STR_TUPLE("32BIT") },
     1293        /* [02] = */ { RT_STR_TUPLE("!2!") },
     1294        /* [03] = */ { RT_STR_TUPLE("!3!") },
     1295        /* [04] = */ { RT_STR_TUPLE("16BIT_PRE_386") },
     1296        /* [05] = */ { RT_STR_TUPLE("32BIT_FLAT") },
     1297        /* [06] = */ { RT_STR_TUPLE("!6!") },
     1298        /* [07] = */ { RT_STR_TUPLE("!7!") },
     1299        /* [08] = */ { RT_STR_TUPLE("16BIT_PROT") },
     1300        /* [09] = */ { RT_STR_TUPLE("32BIT_PROT") },
     1301        /* [0a] = */ { RT_STR_TUPLE("64BIT") },
     1302        /* [0b] = */ { RT_STR_TUPLE("!b!") },
     1303        /* [0c] = */ { RT_STR_TUPLE("16BIT_PROT_PRE_386") },
     1304        /* [0d] = */ { RT_STR_TUPLE("32BIT_PROT_FLAT") },
     1305        /* [0e] = */ { RT_STR_TUPLE("!e!") },
     1306        /* [0f] = */ { RT_STR_TUPLE("!f!") },
     1307        /* [10] = */ { RT_STR_TUPLE("!10!") },
     1308        /* [11] = */ { RT_STR_TUPLE("!11!") },
     1309        /* [12] = */ { RT_STR_TUPLE("!12!") },
     1310        /* [13] = */ { RT_STR_TUPLE("!13!") },
     1311        /* [14] = */ { RT_STR_TUPLE("!14!") },
     1312        /* [15] = */ { RT_STR_TUPLE("!15!") },
     1313        /* [16] = */ { RT_STR_TUPLE("!16!") },
     1314        /* [17] = */ { RT_STR_TUPLE("!17!") },
     1315        /* [18] = */ { RT_STR_TUPLE("16BIT_PROT_V86") },
     1316        /* [19] = */ { RT_STR_TUPLE("32BIT_PROT_V86") },
     1317        /* [1a] = */ { RT_STR_TUPLE("!1a!") },
     1318        /* [1b] = */ { RT_STR_TUPLE("!1b!") },
     1319        /* [1c] = */ { RT_STR_TUPLE("!1c!") },
     1320        /* [1d] = */ { RT_STR_TUPLE("!1d!") },
     1321        /* [1e] = */ { RT_STR_TUPLE("!1e!") },
     1322        /* [1f] = */ { RT_STR_TUPLE("!1f!") },
     1323    };
     1324    AssertCompile(RT_ELEMENTS(s_aModes) == IEM_F_MODE_MASK + 1);
     1325    memcpy(pszBuf, s_aModes[fFlags & IEM_F_MODE_MASK].psz, s_aModes[fFlags & IEM_F_MODE_MASK].cch);
     1326    size_t off = s_aModes[fFlags & IEM_F_MODE_MASK].cch;
     1327
     1328    pszBuf[off++] = ' ';
     1329    pszBuf[off++] = 'C';
     1330    pszBuf[off++] = 'P';
     1331    pszBuf[off++] = 'L';
     1332    pszBuf[off++] = '0' + ((fFlags >> IEM_F_X86_CPL_SHIFT) & IEM_F_X86_CPL_SMASK);
     1333    Assert(off < 32);
     1334
     1335    fFlags &= ~(IEM_F_MODE_MASK | IEM_F_X86_CPL_SMASK);
     1336
     1337    static struct { const char *pszName; uint32_t cchName; uint32_t fFlag; } const s_aFlags[] =
     1338    {
     1339        { RT_STR_TUPLE("BYPASS_HANDLERS"),      IEM_F_BYPASS_HANDLERS    },
     1340        { RT_STR_TUPLE("PENDING_BRK_INSTR"),    IEM_F_PENDING_BRK_INSTR  },
     1341        { RT_STR_TUPLE("PENDING_BRK_DATA"),     IEM_F_PENDING_BRK_DATA   },
     1342        { RT_STR_TUPLE("PENDING_BRK_X86_IO"),   IEM_F_PENDING_BRK_X86_IO },
     1343        { RT_STR_TUPLE("X86_DISREGARD_LOCK"),   IEM_F_X86_DISREGARD_LOCK },
     1344        { RT_STR_TUPLE("X86_CTX_VMX"),          IEM_F_X86_CTX_VMX        },
     1345        { RT_STR_TUPLE("X86_CTX_SVM"),          IEM_F_X86_CTX_SVM        },
     1346        { RT_STR_TUPLE("X86_CTX_IN_GUEST"),     IEM_F_X86_CTX_IN_GUEST   },
     1347        { RT_STR_TUPLE("X86_CTX_SMM"),          IEM_F_X86_CTX_SMM        },
     1348        { RT_STR_TUPLE("INHIBIT_SHADOW"),       IEMTB_F_INHIBIT_SHADOW   },
     1349        { RT_STR_TUPLE("INHIBIT_NMI"),          IEMTB_F_INHIBIT_NMI      },
     1350        { RT_STR_TUPLE("CS_LIM_CHECKS"),        IEMTB_F_CS_LIM_CHECKS    },
     1351        { RT_STR_TUPLE("TYPE_THREADED"),        IEMTB_F_TYPE_THREADED    },
     1352        { RT_STR_TUPLE("TYPE_NATIVE"),          IEMTB_F_TYPE_NATIVE      },
     1353    };
     1354    if (fFlags)
     1355        for (unsigned i = 0; i < RT_ELEMENTS(s_aFlags); i++)
     1356            if (s_aFlags[i].fFlag & fFlags)
     1357            {
     1358                AssertReturnStmt(off + 1 + s_aFlags[i].cchName + 1 <= cbBuf, pszBuf[off] = '\0', pszBuf);
     1359                pszBuf[off++] = ' ';
     1360                memcpy(&pszBuf[off], s_aFlags[i].pszName, s_aFlags[i].cchName);
     1361                off += s_aFlags[i].cchName;
     1362                fFlags &= ~s_aFlags[i].fFlag;
     1363                if (!fFlags)
     1364                    break;
     1365            }
     1366    pszBuf[off] = '\0';
     1367
     1368    return pszBuf;
     1369}
     1370
    12791371
    12801372/** @callback_method_impl{FNDISREADBYTES, Dummy.} */
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