VirtualBox

vbox的更動 64555 路徑 trunk/src/VBox/Debugger


忽略:
時間撮記:
2016-11-4 上午10:49:15 (8 年 以前)
作者:
vboxsync
訊息:

Debugger/CodeView: Add a variant of ucfg called ucfgc which colors the graph edges according to the branch style (works only when connected via telnet using a terminal supporting ansi escape sequences)

檔案:
修改 1 筆資料

圖例:

未更動
新增
刪除

  • trunk/src/VBox/Debugger/DBGCEmulateCodeView.cpp

    r64501 r64555  
    426426    { "uv86",       0,        1,        &g_aArgUnassemble[0],RT_ELEMENTS(g_aArgUnassemble), 0,       dbgcCmdUnassemble,  "[addr]",               "Unassemble 16-bit code with v8086/real mode addressing." },
    427427    { "ucfg",       0,        1,        &g_aArgUnassembleCfg[0], RT_ELEMENTS(g_aArgUnassembleCfg), 0, dbgcCmdUnassembleCfg,  "[addr]",               "Unassemble creating a control flow graph." },
     428    { "ucfgc",      0,        1,        &g_aArgUnassembleCfg[0], RT_ELEMENTS(g_aArgUnassembleCfg), 0, dbgcCmdUnassembleCfg,  "[addr]",               "Unassemble creating a control flow graph with colors." },
    428429};
    429430
    … …  
    13781379
    13791380/**
    1380  * @callback_method_impl{FNDBGFR3CFGDUMP}
    1381  */
    1382 static DECLCALLBACK(int) dbgcCmdUnassembleCfgDump(const char *psz, void *pvUser)
     1381 * @callback_method_impl{FNDGCSCREENBLIT}
     1382 */
     1383static DECLCALLBACK(int) dbgcCmdUnassembleCfgBlit(const char *psz, void *pvUser)
    13831384{
    13841385    PDBGCCMDHLP pCmdHlp = (PDBGCCMDHLP)pvUser;
    1385     return DBGCCmdHlpPrintf(pCmdHlp, "%s\n", psz);
     1386    return DBGCCmdHlpPrintf(pCmdHlp, "%s", psz);
     1387}
     1388
     1389
     1390/**
     1391 * Checks whether both addresses are equal.
     1392 *
     1393 * @returns true if both addresses point to the same location, false otherwise.
     1394 * @param   pAddr1              First address.
     1395 * @param   pAddr2              Second address.
     1396 */
     1397static bool dbgcCmdUnassembleCfgAddrEqual(PDBGFADDRESS pAddr1, PDBGFADDRESS pAddr2)
     1398{
     1399    return    pAddr1->Sel == pAddr2->Sel
     1400           && pAddr1->off == pAddr2->off;
     1401}
     1402
     1403
     1404/**
     1405 * Checks whether the first given address is lower than the second one.
     1406 *
     1407 * @returns true if both addresses point to the same location, false otherwise.
     1408 * @param   pAddr1              First address.
     1409 * @param   pAddr2              Second address.
     1410 */
     1411static bool dbgcCmdUnassembleCfgAddrLower(PDBGFADDRESS pAddr1, PDBGFADDRESS pAddr2)
     1412{
     1413    return    pAddr1->Sel == pAddr2->Sel
     1414           && pAddr1->off < pAddr2->off;
     1415}
     1416
     1417
     1418/**
     1419 * Calculates the size required for the given basic block including the
     1420 * border and spacing on the edges.
     1421 *
     1422 * @returns nothing.
     1423 * @param   hCfgBb              The basic block handle.
     1424 * @param   pDumpBb             The dumper state to fill in for the basic block.
     1425 */
     1426static void dbgcCmdUnassembleCfgDumpCalcBbSize(DBGFCFGBB hCfgBb, PDBGCCFGBBDUMP pDumpBb)
     1427{
     1428    uint32_t fFlags = DBGFR3CfgBbGetFlags(hCfgBb);
     1429    uint32_t cInstr = DBGFR3CfgBbGetInstrCount(hCfgBb);
     1430
     1431    pDumpBb->hCfgBb = hCfgBb;
     1432    pDumpBb->cchHeight = cInstr + 4; /* Include spacing and border top and bottom. */
     1433    pDumpBb->cchWidth = 0;
     1434    DBGFR3CfgBbGetStartAddress(hCfgBb, &pDumpBb->AddrStart);
     1435
     1436    DBGFCFGBBENDTYPE enmType = DBGFR3CfgBbGetType(hCfgBb);
     1437    if (   enmType == DBGFCFGBBENDTYPE_COND
     1438        || enmType == DBGFCFGBBENDTYPE_UNCOND_JMP)
     1439        DBGFR3CfgBbGetBranchAddress(hCfgBb, &pDumpBb->AddrTarget);
     1440
     1441    if (fFlags & DBGF_CFG_BB_F_INCOMPLETE_ERR)
     1442    {
     1443        const char *pszErr = NULL;
     1444        DBGFR3CfgBbQueryError(hCfgBb, &pszErr);
     1445        if (pszErr)
     1446        {
     1447            pDumpBb->cchHeight++;
     1448            pDumpBb->cchWidth = RT_MAX(pDumpBb->cchWidth, (uint32_t)strlen(pszErr));
     1449        }
     1450    }
     1451    for (unsigned i = 0; i < cInstr; i++)
     1452    {
     1453        const char *pszInstr = NULL;
     1454        int rc = DBGFR3CfgBbQueryInstr(hCfgBb, i, NULL, NULL, &pszInstr);
     1455        AssertRC(rc);
     1456        pDumpBb->cchWidth = RT_MAX(pDumpBb->cchWidth, (uint32_t)strlen(pszInstr));
     1457    }
     1458    pDumpBb->cchWidth += 4; /* Include spacing and border left and right. */
     1459}
     1460
     1461
     1462/**
     1463 * Dumps a top or bottom boundary line.
     1464 *
     1465 * @returns nothing.
     1466 * @param   hScreen             The screen to draw to.
     1467 * @param   uStartX             Where to start drawing the boundary.
     1468 * @param   uStartY             Y coordinate.
     1469 * @param   cchWidth            Width of the boundary.
     1470 * @param   enmColor            The color to use for drawing.
     1471 */
     1472static void dbgcCmdUnassembleCfgDumpBbBoundary(DBGCSCREEN hScreen, uint32_t uStartX, uint32_t uStartY, uint32_t cchWidth,
     1473                                               DBGCSCREENCOLOR enmColor)
     1474{
     1475    dbgcScreenAsciiDrawCharacter(hScreen, uStartX, uStartY, '+', enmColor);
     1476    dbgcScreenAsciiDrawLineHorizontal(hScreen, uStartX + 1, uStartX + 1 + cchWidth - 2,
     1477                                      uStartY, '-', enmColor);
     1478    dbgcScreenAsciiDrawCharacter(hScreen, uStartX + cchWidth - 1, uStartY, '+', enmColor);
     1479}
     1480
     1481
     1482/**
     1483 * Dumps a spacing line between the top or bottom boundary and the actual disassembly.
     1484 *
     1485 * @returns nothing.
     1486 * @param   hScreen             The screen to draw to.
     1487 * @param   uStartX             Where to start drawing the spacing.
     1488 * @param   uStartY             Y coordinate.
     1489 * @param   cchWidth            Width of the spacing.
     1490 * @param   enmColor            The color to use for drawing.
     1491 */
     1492static void dbgcCmdUnassembleCfgDumpBbSpacing(DBGCSCREEN hScreen, uint32_t uStartX, uint32_t uStartY, uint32_t cchWidth,
     1493                                              DBGCSCREENCOLOR enmColor)
     1494{
     1495    dbgcScreenAsciiDrawCharacter(hScreen, uStartX, uStartY, '|', enmColor);
     1496    dbgcScreenAsciiDrawLineHorizontal(hScreen, uStartX + 1, uStartX + 1 + cchWidth - 2,
     1497                                      uStartY, ' ', enmColor);
     1498    dbgcScreenAsciiDrawCharacter(hScreen, uStartX + cchWidth - 1, uStartY, '|', enmColor);
     1499}
     1500
     1501
     1502/**
     1503 * Writes a given text to the screen.
     1504 *
     1505 * @returns nothing.
     1506 * @param   hScreen             The screen to draw to.
     1507 * @param   uStartX             Where to start drawing the line.
     1508 * @param   uStartY             Y coordinate.
     1509 * @param   cchWidth            Maximum width of the text.
     1510 * @param   pszText             The text to write.
     1511 * @param   enmColor            The color to use for drawing.
     1512 */
     1513static void dbgcCmdUnassembleCfgDumpBbText(DBGCSCREEN hScreen, uint32_t uStartX, uint32_t uStartY,
     1514                                           uint32_t cchWidth, const char *pszText, DBGCSCREENCOLOR enmColor)
     1515{
     1516    dbgcScreenAsciiDrawCharacter(hScreen, uStartX, uStartY, '|', enmColor);
     1517    dbgcScreenAsciiDrawCharacter(hScreen, uStartX + 1, uStartY, ' ', enmColor);
     1518    dbgcScreenAsciiDrawString(hScreen, uStartX + 2, uStartY, pszText, enmColor);
     1519    dbgcScreenAsciiDrawCharacter(hScreen, uStartX + cchWidth - 1, uStartY, '|', enmColor);
     1520}
     1521
     1522
     1523/**
     1524 * Dumps one basic block using the dumper callback.
     1525 *
     1526 * @returns nothing.
     1527 * @param   pDumpBb             The basic block dump state to dump.
     1528 * @param   hScreen             The screen to draw to.
     1529 */
     1530static void dbgcCmdUnassembleCfgDumpBb(PDBGCCFGBBDUMP pDumpBb, DBGCSCREEN hScreen)
     1531{
     1532    uint32_t uStartY = pDumpBb->uStartY;
     1533    bool fError = RT_BOOL(DBGFR3CfgBbGetFlags(pDumpBb->hCfgBb) & DBGF_CFG_BB_F_INCOMPLETE_ERR);
     1534    DBGCSCREENCOLOR enmColor = fError ? DBGCSCREENCOLOR_RED_BRIGHT : DBGCSCREENCOLOR_DEFAULT;
     1535
     1536    dbgcCmdUnassembleCfgDumpBbBoundary(hScreen, pDumpBb->uStartX, uStartY, pDumpBb->cchWidth, enmColor);
     1537    uStartY++;
     1538    dbgcCmdUnassembleCfgDumpBbSpacing(hScreen, pDumpBb->uStartX, uStartY, pDumpBb->cchWidth, enmColor);
     1539    uStartY++;
     1540
     1541    uint32_t cInstr = DBGFR3CfgBbGetInstrCount(pDumpBb->hCfgBb);
     1542    for (unsigned i = 0; i < cInstr; i++)
     1543    {
     1544        const char *pszInstr = NULL;
     1545        DBGFR3CfgBbQueryInstr(pDumpBb->hCfgBb, i, NULL, NULL, &pszInstr);
     1546        dbgcCmdUnassembleCfgDumpBbText(hScreen, pDumpBb->uStartX, uStartY + i,
     1547                                       pDumpBb->cchWidth, pszInstr, DBGCSCREENCOLOR_DEFAULT);
     1548    }
     1549    uStartY += cInstr;
     1550
     1551    if (fError)
     1552    {
     1553        const char *pszErr = NULL;
     1554        DBGFR3CfgBbQueryError(pDumpBb->hCfgBb, &pszErr);
     1555        if (pszErr)
     1556            dbgcCmdUnassembleCfgDumpBbText(hScreen, pDumpBb->uStartX, uStartY,
     1557                                           pDumpBb->cchWidth, pszErr, enmColor);
     1558        uStartY++;
     1559    }
     1560
     1561    dbgcCmdUnassembleCfgDumpBbSpacing(hScreen, pDumpBb->uStartX, uStartY, pDumpBb->cchWidth, enmColor);
     1562    uStartY++;
     1563    dbgcCmdUnassembleCfgDumpBbBoundary(hScreen, pDumpBb->uStartX, uStartY, pDumpBb->cchWidth, enmColor);
     1564    uStartY++;
     1565}
     1566
     1567
     1568/**
     1569 * Dumps the given control flow graph to the output.
     1570 *
     1571 * @returns VBox status code.
     1572 * @param   hCfg                The control flow graph handle.
     1573 * @param   fUseColor           Flag whether the output should be colorized.
     1574 * @param   pCmdHlp             The command helper callback table.
     1575 */
     1576static int dbgcCmdUnassembleCfgDump(DBGFCFG hCfg, bool fUseColor, PDBGCCMDHLP pCmdHlp)
     1577{
     1578    DBGFCFGIT hCfgIt;
     1579    int rc = DBGFR3CfgItCreate(hCfg, DBGFCFGITORDER_BY_ADDR_LOWEST_FIRST, &hCfgIt);
     1580    if (RT_SUCCESS(rc))
     1581    {
     1582        uint32_t cBbs = DBGFR3CfgGetBbCount(hCfg);
     1583        PDBGCCFGBBDUMP paDumpBb = (PDBGCCFGBBDUMP)RTMemTmpAllocZ(cBbs * sizeof(DBGCCFGBBDUMP));
     1584        if (paDumpBb)
     1585        {
     1586            /* Calculate the sizes of each basic block first. */
     1587            DBGFCFGBB hCfgBb = DBGFR3CfgItNext(hCfgIt);
     1588            uint32_t idxDumpBb = 0;
     1589            while (hCfgBb)
     1590            {
     1591                dbgcCmdUnassembleCfgDumpCalcBbSize(hCfgBb, &paDumpBb[idxDumpBb]);
     1592                idxDumpBb++;
     1593                hCfgBb = DBGFR3CfgItNext(hCfgIt);
     1594            }
     1595
     1596            /* Calculate the ASCII screen dimensions and create one. */
     1597            uint32_t cchWidth = 0;
     1598            uint32_t cchLeftExtra = 5;
     1599            uint32_t cchRightExtra = 5;
     1600            uint32_t cchHeight = 0;
     1601            for (unsigned i = 0; i < cBbs; i++)
     1602            {
     1603                PDBGCCFGBBDUMP pDumpBb = &paDumpBb[i];
     1604                cchWidth = RT_MAX(cchWidth, pDumpBb->cchWidth);
     1605                cchHeight += pDumpBb->cchHeight;
     1606
     1607                /* Incomplete blocks don't have a successor. */
     1608                if (DBGFR3CfgBbGetFlags(pDumpBb->hCfgBb) & DBGF_CFG_BB_F_INCOMPLETE_ERR)
     1609                    continue;
     1610
     1611                switch (DBGFR3CfgBbGetType(pDumpBb->hCfgBb))
     1612                {
     1613                    case DBGFCFGBBENDTYPE_EXIT:
     1614                    case DBGFCFGBBENDTYPE_LAST_DISASSEMBLED:
     1615                        break;
     1616                    case DBGFCFGBBENDTYPE_UNCOND_JMP:
     1617                        if (   dbgcCmdUnassembleCfgAddrLower(&pDumpBb->AddrTarget, &pDumpBb->AddrStart)
     1618                            || dbgcCmdUnassembleCfgAddrEqual(&pDumpBb->AddrTarget, &pDumpBb->AddrStart))
     1619                            cchLeftExtra++;
     1620                        else
     1621                            cchRightExtra++;
     1622                        break;
     1623                    case DBGFCFGBBENDTYPE_UNCOND:
     1624                        cchHeight += 2; /* For the arrow down to the next basic block. */
     1625                        break;
     1626                    case DBGFCFGBBENDTYPE_COND:
     1627                        cchHeight += 2; /* For the arrow down to the next basic block. */
     1628                        if (   dbgcCmdUnassembleCfgAddrLower(&pDumpBb->AddrTarget, &pDumpBb->AddrStart)
     1629                            || dbgcCmdUnassembleCfgAddrEqual(&pDumpBb->AddrTarget, &pDumpBb->AddrStart))
     1630                            cchLeftExtra++;
     1631                        else
     1632                            cchRightExtra++;
     1633                        break;
     1634                    default:
     1635                        AssertFailed();
     1636                }
     1637            }
     1638
     1639            cchWidth += 2;
     1640
     1641            DBGCSCREEN hScreen = NULL;
     1642            rc = dbgcScreenAsciiCreate(&hScreen, cchWidth + cchLeftExtra + cchRightExtra, cchHeight);
     1643            if (RT_SUCCESS(rc))
     1644            {
     1645                uint32_t uY = 0;
     1646
     1647                /* Dump the basic blocks and connections to the immediate successor. */
     1648                for (unsigned i = 0; i < cBbs; i++)
     1649                {
     1650                    paDumpBb[i].uStartX = cchLeftExtra + (cchWidth - paDumpBb[i].cchWidth) / 2;
     1651                    paDumpBb[i].uStartY = uY;
     1652                    dbgcCmdUnassembleCfgDumpBb(&paDumpBb[i], hScreen);
     1653                    uY += paDumpBb[i].cchHeight;
     1654
     1655                    /* Incomplete blocks don't have a successor. */
     1656                    if (DBGFR3CfgBbGetFlags(paDumpBb[i].hCfgBb) & DBGF_CFG_BB_F_INCOMPLETE_ERR)
     1657                        continue;
     1658
     1659                    switch (DBGFR3CfgBbGetType(paDumpBb[i].hCfgBb))
     1660                    {
     1661                        case DBGFCFGBBENDTYPE_EXIT:
     1662                        case DBGFCFGBBENDTYPE_LAST_DISASSEMBLED:
     1663                        case DBGFCFGBBENDTYPE_UNCOND_JMP:
     1664                            break;
     1665                        case DBGFCFGBBENDTYPE_UNCOND:
     1666                            /* Draw the arrow down to the next block. */
     1667                            dbgcScreenAsciiDrawCharacter(hScreen, cchLeftExtra + cchWidth / 2, uY,
     1668                                                         '|', DBGCSCREENCOLOR_BLUE_BRIGHT);
     1669                            uY++;
     1670                            dbgcScreenAsciiDrawCharacter(hScreen, cchLeftExtra + cchWidth / 2, uY,
     1671                                                         'V', DBGCSCREENCOLOR_BLUE_BRIGHT);
     1672                            uY++;
     1673                            break;
     1674                        case DBGFCFGBBENDTYPE_COND:
     1675                            /* Draw the arrow down to the next block. */
     1676                            dbgcScreenAsciiDrawCharacter(hScreen, cchLeftExtra + cchWidth / 2, uY,
     1677                                                         '|', DBGCSCREENCOLOR_RED_BRIGHT);
     1678                            uY++;
     1679                            dbgcScreenAsciiDrawCharacter(hScreen, cchLeftExtra + cchWidth / 2, uY,
     1680                                                         'V', DBGCSCREENCOLOR_RED_BRIGHT);
     1681                            uY++;
     1682                            break;
     1683                        default:
     1684                            AssertFailed();
     1685                    }
     1686                }
     1687
     1688                /* Last pass, connect all remaining branches. */
     1689                uint32_t uBackConns = 0;
     1690                uint32_t uFwdConns = 0;
     1691                for (unsigned i = 0; i < cBbs; i++)
     1692                {
     1693                    PDBGCCFGBBDUMP pDumpBb = &paDumpBb[i];
     1694
     1695                    /* Incomplete blocks don't have a successor. */
     1696                    if (DBGFR3CfgBbGetFlags(pDumpBb->hCfgBb) & DBGF_CFG_BB_F_INCOMPLETE_ERR)
     1697                        continue;
     1698
     1699                    switch (DBGFR3CfgBbGetType(pDumpBb->hCfgBb))
     1700                    {
     1701                        case DBGFCFGBBENDTYPE_EXIT:
     1702                        case DBGFCFGBBENDTYPE_LAST_DISASSEMBLED:
     1703                        case DBGFCFGBBENDTYPE_UNCOND:
     1704                            break;
     1705                        case DBGFCFGBBENDTYPE_COND:
     1706                        case DBGFCFGBBENDTYPE_UNCOND_JMP:
     1707                        {
     1708                            /* Find the target first to get the coordinates. */
     1709                            PDBGCCFGBBDUMP pDumpBbTgt = NULL;
     1710                            for (idxDumpBb = 0; idxDumpBb < cBbs; idxDumpBb++)
     1711                            {
     1712                                pDumpBbTgt = &paDumpBb[idxDumpBb];
     1713                                if (dbgcCmdUnassembleCfgAddrEqual(&pDumpBb->AddrTarget, &pDumpBbTgt->AddrStart))
     1714                                    break;
     1715                            }
     1716
     1717                            /*
     1718                             * Use the right side for targets with higher addresses,
     1719                             * left when jumping backwards.
     1720                             */
     1721                            if (   dbgcCmdUnassembleCfgAddrLower(&pDumpBb->AddrTarget, &pDumpBb->AddrStart)
     1722                                || dbgcCmdUnassembleCfgAddrEqual(&pDumpBb->AddrTarget, &pDumpBb->AddrStart))
     1723                            {
     1724                                /* Going backwards. */
     1725                                uint32_t uXVerLine = /*cchLeftExtra - 1 -*/ uBackConns + 1;
     1726                                uint32_t uYHorLine = pDumpBb->uStartY + pDumpBb->cchHeight - 1 - 2;
     1727                                uBackConns++;
     1728
     1729                                /* Draw the arrow pointing to the target block. */
     1730                                dbgcScreenAsciiDrawCharacter(hScreen, pDumpBbTgt->uStartX - 1, pDumpBbTgt->uStartY,
     1731                                                             '>', DBGCSCREENCOLOR_GREEN_BRIGHT);
     1732                                /* Draw the horizontal line. */
     1733                                dbgcScreenAsciiDrawLineHorizontal(hScreen, uXVerLine + 1, pDumpBbTgt->uStartX - 2,
     1734                                                                  pDumpBbTgt->uStartY, '-', DBGCSCREENCOLOR_GREEN_BRIGHT);
     1735                                dbgcScreenAsciiDrawCharacter(hScreen, uXVerLine, pDumpBbTgt->uStartY, '+',
     1736                                                             DBGCSCREENCOLOR_GREEN_BRIGHT);
     1737                                /* Draw the vertical line down to the source block. */
     1738                                dbgcScreenAsciiDrawLineVertical(hScreen, uXVerLine, pDumpBbTgt->uStartY + 1, uYHorLine - 1,
     1739                                                                '|', DBGCSCREENCOLOR_GREEN_BRIGHT);
     1740                                dbgcScreenAsciiDrawCharacter(hScreen, uXVerLine, uYHorLine, '+', DBGCSCREENCOLOR_GREEN_BRIGHT);
     1741                                /* Draw the horizontal connection between the source block and vertical part. */
     1742                                dbgcScreenAsciiDrawLineHorizontal(hScreen, uXVerLine + 1, pDumpBb->uStartX - 1,
     1743                                                                  uYHorLine, '-', DBGCSCREENCOLOR_GREEN_BRIGHT);
     1744
     1745                            }
     1746                            else
     1747                            {
     1748                                /* Going forward. */
     1749                                uint32_t uXVerLine = cchWidth + cchLeftExtra + (cchRightExtra - uFwdConns) - 1;
     1750                                uint32_t uYHorLine = pDumpBb->uStartY + pDumpBb->cchHeight - 1 - 2;
     1751                                uFwdConns++;
     1752
     1753                                /* Draw the horizontal line. */
     1754                                dbgcScreenAsciiDrawLineHorizontal(hScreen, pDumpBb->uStartX + pDumpBb->cchWidth,
     1755                                                                  uXVerLine - 1, uYHorLine, '-', DBGCSCREENCOLOR_GREEN_BRIGHT);
     1756                                dbgcScreenAsciiDrawCharacter(hScreen, uXVerLine, uYHorLine, '+', DBGCSCREENCOLOR_GREEN_BRIGHT);
     1757                                /* Draw the vertical line down to the target block. */
     1758                                dbgcScreenAsciiDrawLineVertical(hScreen, uXVerLine, uYHorLine + 1, pDumpBbTgt->uStartY - 1,
     1759                                                                '|', DBGCSCREENCOLOR_GREEN_BRIGHT);
     1760                                /* Draw the horizontal connection between the target block and vertical part. */
     1761                                dbgcScreenAsciiDrawLineHorizontal(hScreen, pDumpBbTgt->uStartX + pDumpBbTgt->cchWidth,
     1762                                                                  uXVerLine, pDumpBbTgt->uStartY, '-', DBGCSCREENCOLOR_GREEN_BRIGHT);
     1763                                dbgcScreenAsciiDrawCharacter(hScreen, uXVerLine, pDumpBbTgt->uStartY, '+',
     1764                                                             DBGCSCREENCOLOR_GREEN_BRIGHT);
     1765                                /* Draw the arrow pointing to the target block. */
     1766                                dbgcScreenAsciiDrawCharacter(hScreen, pDumpBbTgt->uStartX + pDumpBbTgt->cchWidth,
     1767                                                             pDumpBbTgt->uStartY, '<', DBGCSCREENCOLOR_GREEN_BRIGHT);
     1768                            }
     1769                            break;
     1770                        }
     1771                        default:
     1772                            AssertFailed();
     1773                    }
     1774                }
     1775
     1776                rc = dbgcScreenAsciiBlit(hScreen, dbgcCmdUnassembleCfgBlit, pCmdHlp, fUseColor);
     1777                dbgcScreenAsciiDestroy(hScreen);
     1778            }
     1779
     1780            for (unsigned i = 0; i < cBbs; i++)
     1781                DBGFR3CfgBbRelease(paDumpBb[i].hCfgBb);
     1782            RTMemTmpFree(paDumpBb);
     1783        }
     1784        else
     1785            rc = VERR_NO_MEMORY;
     1786
     1787        DBGFR3CfgItDestroy(hCfgIt);
     1788    }
     1789
     1790    return rc;
    13861791}
    13871792
    … …  
    14081813     */
    14091814    unsigned fFlags =  DBGF_DISAS_FLAGS_UNPATCHED_BYTES | DBGF_DISAS_FLAGS_ANNOTATE_PATCHED;
     1815    bool fUseColor = false;
    14101816    switch (pCmd->pszCmd[4])
    14111817    {
    … …  
    14161822        case '1':   fFlags |= DBGF_DISAS_FLAGS_16BIT_MODE;      break;
    14171823        case 'v':   fFlags |= DBGF_DISAS_FLAGS_16BIT_REAL_MODE; break;
     1824        case 'c':   fUseColor = true; break;
    14181825    }
    14191826
    … …  
    15301937    {
    15311938        /* Dump the graph. */
    1532         rc = DBGFR3CfgDump(hCfg, dbgcCmdUnassembleCfgDump, pCmdHlp);
     1939        rc = dbgcCmdUnassembleCfgDump(hCfg, fUseColor, pCmdHlp);
    15331940        DBGFR3CfgRelease(hCfg);
    15341941    }
注意: 瀏覽 TracChangeset 來幫助您使用更動檢視器

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