VirtualBox

Ignore:
Timestamp:
Jan 19, 2011 11:17:34 AM (14 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
69526
Message:

DBGF,CPUM,DBGC: Use DBGFReg in the debugger, stop accessing CPUMCTX structures directly when messing with registers.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r35346 r35625  
    729729
    730730/**
     731 * Converts a DBGC variable to a number.
     732 *
     733 * @returns VBox status code.
     734 * @param   pCmdHlp     Pointer to the command callback structure.
     735 * @param   pVar        The variable to convert.
     736 * @param   pu64Number  Where to store the number value.
     737 */
     738static DECLCALLBACK(int) dbgcHlpVarToNumber(PDBGCCMDHLP pCmdHlp, PCDBGCVAR pVar, uint64_t *pu64Number)
     739{
     740    PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
     741    NOREF(pDbgc);
     742
     743    uint64_t u64Number;
     744    switch (pVar->enmType)
     745    {
     746        case DBGCVAR_TYPE_GC_FLAT:
     747            u64Number = pVar->u.GCFlat;
     748            break;
     749        case DBGCVAR_TYPE_GC_PHYS:
     750            u64Number = pVar->u.GCPhys;
     751            break;
     752        case DBGCVAR_TYPE_HC_FLAT:
     753            u64Number = (uintptr_t)pVar->u.pvHCFlat;
     754            break;
     755        case DBGCVAR_TYPE_HC_PHYS:
     756            u64Number = (uintptr_t)pVar->u.HCPhys;
     757            break;
     758        case DBGCVAR_TYPE_NUMBER:
     759            u64Number = (uintptr_t)pVar->u.u64Number;
     760            return VINF_SUCCESS;
     761        case DBGCVAR_TYPE_HC_FAR:
     762            u64Number = (uintptr_t)pVar->u.HCFar.off;
     763            break;
     764        case DBGCVAR_TYPE_GC_FAR:
     765            u64Number = (uintptr_t)pVar->u.GCFar.off;
     766            break;
     767        case DBGCVAR_TYPE_SYMBOL:
     768        case DBGCVAR_TYPE_STRING:
     769            return VERR_PARSE_INCORRECT_ARG_TYPE; /** @todo better error code! */
     770        default:
     771            return VERR_PARSE_INCORRECT_ARG_TYPE;
     772    }
     773    *pu64Number = u64Number;
     774    return VINF_SUCCESS;
     775}
     776
     777
     778/**
    731779 * Converts a DBGC variable to a boolean.
    732780 *
    … …  
    816864
    817865/**
     866 * @interface_method_impl{DBGCCMDHLP,pfnVarConvert}
     867 */
     868static DECLCALLBACK(int) dbgcHlpVarConvert(PDBGCCMDHLP pCmdHlp, PCDBGCVAR pInVar, DBGCVARTYPE enmToType, bool fConvSyms,
     869                                           PDBGCVAR pResult)
     870{
     871    PDBGC           pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
     872    DBGCVAR const   InVar = *pInVar;    /* if pInVar == pResult  */
     873    PCDBGCVAR       pArg = &InVar;      /* lazy bird, clean up later */
     874    DBGFADDRESS     Address;
     875    int             rc;
     876
     877    Assert(pDbgc->pVM);
     878
     879    *pResult = InVar;
     880    switch (InVar.enmType)
     881    {
     882        case DBGCVAR_TYPE_GC_FLAT:
     883            switch (enmToType)
     884            {
     885                case DBGCVAR_TYPE_GC_FLAT:
     886                    return VINF_SUCCESS;
     887
     888                case DBGCVAR_TYPE_GC_FAR:
     889                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     890
     891                case DBGCVAR_TYPE_GC_PHYS:
     892                    pResult->enmType = DBGCVAR_TYPE_GC_PHYS;
     893                    rc = DBGFR3AddrToPhys(pDbgc->pVM, pDbgc->idCpu,
     894                                          DBGFR3AddrFromFlat(pDbgc->pVM, &Address, pArg->u.GCFlat),
     895                                          &pResult->u.GCPhys);
     896                    if (RT_SUCCESS(rc))
     897                        return VINF_SUCCESS;
     898                    return VERR_PARSE_CONVERSION_FAILED;
     899
     900                case DBGCVAR_TYPE_HC_FLAT:
     901                    pResult->enmType = DBGCVAR_TYPE_HC_FLAT;
     902                    rc = DBGFR3AddrToVolatileR3Ptr(pDbgc->pVM, pDbgc->idCpu,
     903                                                   DBGFR3AddrFromFlat(pDbgc->pVM, &Address, pArg->u.GCFlat),
     904                                                   false /*fReadOnly */,
     905                                                   &pResult->u.pvHCFlat);
     906                    if (RT_SUCCESS(rc))
     907                        return VINF_SUCCESS;
     908                    return VERR_PARSE_CONVERSION_FAILED;
     909
     910                case DBGCVAR_TYPE_HC_FAR:
     911                    return VERR_INVALID_PARAMETER;
     912
     913                case DBGCVAR_TYPE_HC_PHYS:
     914                    pResult->enmType = DBGCVAR_TYPE_HC_PHYS;
     915                    rc = DBGFR3AddrToHostPhys(pDbgc->pVM, pDbgc->idCpu,
     916                                              DBGFR3AddrFromFlat(pDbgc->pVM, &Address, pArg->u.GCFlat),
     917                                              &pResult->u.GCPhys);
     918                    if (RT_SUCCESS(rc))
     919                        return VINF_SUCCESS;
     920                    return VERR_PARSE_CONVERSION_FAILED;
     921
     922                case DBGCVAR_TYPE_NUMBER:
     923                    pResult->enmType     = enmToType;
     924                    pResult->u.u64Number = InVar.u.GCFlat;
     925                    return VINF_SUCCESS;
     926
     927                case DBGCVAR_TYPE_STRING:
     928                case DBGCVAR_TYPE_SYMBOL:
     929                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     930
     931                case DBGCVAR_TYPE_UNKNOWN:
     932                case DBGCVAR_TYPE_ANY:
     933                    break;
     934            }
     935            break;
     936
     937        case DBGCVAR_TYPE_GC_FAR:
     938            switch (enmToType)
     939            {
     940                case DBGCVAR_TYPE_GC_FLAT:
     941                    rc = DBGFR3AddrFromSelOff(pDbgc->pVM, pDbgc->idCpu, &Address, pArg->u.GCFar.sel, pArg->u.GCFar.off);
     942                    if (RT_SUCCESS(rc))
     943                    {
     944                        pResult->enmType  = DBGCVAR_TYPE_GC_FLAT;
     945                        pResult->u.GCFlat = Address.FlatPtr;
     946                        return VINF_SUCCESS;
     947                    }
     948                    return VERR_PARSE_CONVERSION_FAILED;
     949
     950                case DBGCVAR_TYPE_GC_FAR:
     951                    return VINF_SUCCESS;
     952
     953                case DBGCVAR_TYPE_GC_PHYS:
     954                    rc = DBGFR3AddrFromSelOff(pDbgc->pVM, pDbgc->idCpu, &Address, pArg->u.GCFar.sel, pArg->u.GCFar.off);
     955                    if (RT_SUCCESS(rc))
     956                    {
     957                        pResult->enmType = DBGCVAR_TYPE_GC_PHYS;
     958                        rc = DBGFR3AddrToPhys(pDbgc->pVM, pDbgc->idCpu, &Address, &pResult->u.GCPhys);
     959                        if (RT_SUCCESS(rc))
     960                            return VINF_SUCCESS;
     961                    }
     962                    return VERR_PARSE_CONVERSION_FAILED;
     963
     964                case DBGCVAR_TYPE_HC_FLAT:
     965                    rc = DBGFR3AddrFromSelOff(pDbgc->pVM, pDbgc->idCpu, &Address, pArg->u.GCFar.sel, pArg->u.GCFar.off);
     966                    if (RT_SUCCESS(rc))
     967                    {
     968                        pResult->enmType = DBGCVAR_TYPE_HC_FLAT;
     969                        rc = DBGFR3AddrToVolatileR3Ptr(pDbgc->pVM, pDbgc->idCpu, &Address,
     970                                                       false /*fReadOnly*/, &pResult->u.pvHCFlat);
     971                        if (RT_SUCCESS(rc))
     972                            return VINF_SUCCESS;
     973                    }
     974                    return VERR_PARSE_CONVERSION_FAILED;
     975
     976                case DBGCVAR_TYPE_HC_FAR:
     977                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     978
     979                case DBGCVAR_TYPE_HC_PHYS:
     980                    rc = DBGFR3AddrFromSelOff(pDbgc->pVM, pDbgc->idCpu, &Address, pArg->u.GCFar.sel, pArg->u.GCFar.off);
     981                    if (RT_SUCCESS(rc))
     982                    {
     983                        pResult->enmType = DBGCVAR_TYPE_HC_PHYS;
     984                        rc = DBGFR3AddrToHostPhys(pDbgc->pVM, pDbgc->idCpu, &Address, &pResult->u.GCPhys);
     985                        if (RT_SUCCESS(rc))
     986                            return VINF_SUCCESS;
     987                    }
     988                    return VERR_PARSE_CONVERSION_FAILED;
     989
     990                case DBGCVAR_TYPE_NUMBER:
     991                    pResult->enmType     = enmToType;
     992                    pResult->u.u64Number = InVar.u.GCFar.off;
     993                    return VINF_SUCCESS;
     994
     995                case DBGCVAR_TYPE_STRING:
     996                case DBGCVAR_TYPE_SYMBOL:
     997                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     998
     999                case DBGCVAR_TYPE_UNKNOWN:
     1000                case DBGCVAR_TYPE_ANY:
     1001                    break;
     1002            }
     1003            break;
     1004
     1005        case DBGCVAR_TYPE_GC_PHYS:
     1006            switch (enmToType)
     1007            {
     1008                case DBGCVAR_TYPE_GC_FLAT:
     1009                    //rc = MMR3PhysGCPhys2GCVirtEx(pDbgc->pVM, pResult->u.GCPhys, ..., &pResult->u.GCFlat); - yea, sure.
     1010                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1011
     1012                case DBGCVAR_TYPE_GC_FAR:
     1013                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1014
     1015                case DBGCVAR_TYPE_GC_PHYS:
     1016                    return VINF_SUCCESS;
     1017
     1018                case DBGCVAR_TYPE_HC_FLAT:
     1019                    pResult->enmType = DBGCVAR_TYPE_HC_FLAT;
     1020                    rc = DBGFR3AddrToVolatileR3Ptr(pDbgc->pVM, pDbgc->idCpu,
     1021                                                   DBGFR3AddrFromPhys(pDbgc->pVM, &Address, pArg->u.GCPhys),
     1022                                                   false /*fReadOnly */,
     1023                                                   &pResult->u.pvHCFlat);
     1024                    if (RT_SUCCESS(rc))
     1025                        return VINF_SUCCESS;
     1026                    return VERR_PARSE_CONVERSION_FAILED;
     1027
     1028                case DBGCVAR_TYPE_HC_FAR:
     1029                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1030
     1031                case DBGCVAR_TYPE_HC_PHYS:
     1032                    pResult->enmType = DBGCVAR_TYPE_HC_PHYS;
     1033                    rc = DBGFR3AddrToHostPhys(pDbgc->pVM, pDbgc->idCpu,
     1034                                              DBGFR3AddrFromPhys(pDbgc->pVM, &Address, pArg->u.GCPhys),
     1035                                              &pResult->u.HCPhys);
     1036                    if (RT_SUCCESS(rc))
     1037                        return VINF_SUCCESS;
     1038                    return VERR_PARSE_CONVERSION_FAILED;
     1039
     1040                case DBGCVAR_TYPE_NUMBER:
     1041                    pResult->enmType     = enmToType;
     1042                    pResult->u.u64Number = InVar.u.GCPhys;
     1043                    return VINF_SUCCESS;
     1044
     1045                case DBGCVAR_TYPE_STRING:
     1046                case DBGCVAR_TYPE_SYMBOL:
     1047                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1048
     1049                case DBGCVAR_TYPE_UNKNOWN:
     1050                case DBGCVAR_TYPE_ANY:
     1051                    break;
     1052            }
     1053            break;
     1054
     1055        case DBGCVAR_TYPE_HC_FLAT:
     1056            switch (enmToType)
     1057            {
     1058                case DBGCVAR_TYPE_GC_FLAT:
     1059                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1060
     1061                case DBGCVAR_TYPE_GC_FAR:
     1062                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1063
     1064                case DBGCVAR_TYPE_GC_PHYS:
     1065                    pResult->enmType = DBGCVAR_TYPE_GC_PHYS;
     1066                    rc = PGMR3DbgR3Ptr2GCPhys(pDbgc->pVM, pArg->u.pvHCFlat, &pResult->u.GCPhys);
     1067                    if (RT_SUCCESS(rc))
     1068                        return VINF_SUCCESS;
     1069                    /** @todo more memory types! */
     1070                    return VERR_PARSE_CONVERSION_FAILED;
     1071
     1072                case DBGCVAR_TYPE_HC_FLAT:
     1073                    return VINF_SUCCESS;
     1074
     1075                case DBGCVAR_TYPE_HC_FAR:
     1076                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1077
     1078                case DBGCVAR_TYPE_HC_PHYS:
     1079                    pResult->enmType = DBGCVAR_TYPE_HC_PHYS;
     1080                    rc = PGMR3DbgR3Ptr2HCPhys(pDbgc->pVM, pArg->u.pvHCFlat, &pResult->u.HCPhys);
     1081                    if (RT_SUCCESS(rc))
     1082                        return VINF_SUCCESS;
     1083                    /** @todo more memory types! */
     1084                    return VERR_PARSE_CONVERSION_FAILED;
     1085
     1086                case DBGCVAR_TYPE_NUMBER:
     1087                    pResult->enmType     = enmToType;
     1088                    pResult->u.u64Number = (uintptr_t)InVar.u.pvHCFlat;
     1089                    return VINF_SUCCESS;
     1090
     1091                case DBGCVAR_TYPE_STRING:
     1092                case DBGCVAR_TYPE_SYMBOL:
     1093                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1094
     1095                case DBGCVAR_TYPE_UNKNOWN:
     1096                case DBGCVAR_TYPE_ANY:
     1097                    break;
     1098            }
     1099            break;
     1100
     1101        case DBGCVAR_TYPE_HC_FAR:
     1102            switch (enmToType)
     1103            {
     1104                case DBGCVAR_TYPE_GC_FLAT:
     1105                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1106
     1107                case DBGCVAR_TYPE_GC_FAR:
     1108                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1109
     1110                case DBGCVAR_TYPE_GC_PHYS:
     1111                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1112
     1113                case DBGCVAR_TYPE_HC_FLAT:
     1114                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1115
     1116                case DBGCVAR_TYPE_HC_FAR:
     1117                    return VINF_SUCCESS;
     1118
     1119                case DBGCVAR_TYPE_HC_PHYS:
     1120                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1121
     1122                case DBGCVAR_TYPE_NUMBER:
     1123                    pResult->enmType     = enmToType;
     1124                    pResult->u.u64Number = (uintptr_t)InVar.u.HCFar.off;
     1125                    return VINF_SUCCESS;
     1126
     1127                case DBGCVAR_TYPE_STRING:
     1128                case DBGCVAR_TYPE_SYMBOL:
     1129                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1130
     1131                case DBGCVAR_TYPE_UNKNOWN:
     1132                case DBGCVAR_TYPE_ANY:
     1133                    break;
     1134            }
     1135            break;
     1136
     1137        case DBGCVAR_TYPE_HC_PHYS:
     1138            switch (enmToType)
     1139            {
     1140                case DBGCVAR_TYPE_GC_FLAT:
     1141                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1142
     1143                case DBGCVAR_TYPE_GC_FAR:
     1144                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1145
     1146                case DBGCVAR_TYPE_GC_PHYS:
     1147                    pResult->enmType = DBGCVAR_TYPE_GC_PHYS;
     1148                    rc = PGMR3DbgHCPhys2GCPhys(pDbgc->pVM, pArg->u.HCPhys, &pResult->u.GCPhys);
     1149                    if (RT_SUCCESS(rc))
     1150                        return VINF_SUCCESS;
     1151                    return VERR_PARSE_CONVERSION_FAILED;
     1152
     1153                case DBGCVAR_TYPE_HC_FLAT:
     1154                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1155
     1156                case DBGCVAR_TYPE_HC_FAR:
     1157                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1158
     1159                case DBGCVAR_TYPE_HC_PHYS:
     1160                    return VINF_SUCCESS;
     1161
     1162                case DBGCVAR_TYPE_NUMBER:
     1163                    pResult->enmType     = enmToType;
     1164                    pResult->u.u64Number = InVar.u.HCPhys;
     1165                    return VINF_SUCCESS;
     1166
     1167                case DBGCVAR_TYPE_STRING:
     1168                case DBGCVAR_TYPE_SYMBOL:
     1169                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1170
     1171                case DBGCVAR_TYPE_UNKNOWN:
     1172                case DBGCVAR_TYPE_ANY:
     1173                    break;
     1174            }
     1175            break;
     1176
     1177        case DBGCVAR_TYPE_NUMBER:
     1178            switch (enmToType)
     1179            {
     1180                case DBGCVAR_TYPE_GC_FLAT:
     1181                    pResult->enmType  = DBGCVAR_TYPE_GC_FLAT;
     1182                    pResult->u.GCFlat = (RTGCPTR)InVar.u.u64Number;
     1183                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1184
     1185                case DBGCVAR_TYPE_GC_FAR:
     1186                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1187
     1188                case DBGCVAR_TYPE_GC_PHYS:
     1189                    pResult->enmType  = DBGCVAR_TYPE_GC_PHYS;
     1190                    pResult->u.GCPhys = (RTGCPHYS)InVar.u.u64Number;
     1191                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1192
     1193                case DBGCVAR_TYPE_HC_FLAT:
     1194                    pResult->enmType    = DBGCVAR_TYPE_HC_FLAT;
     1195                    pResult->u.pvHCFlat = (void *)(uintptr_t)InVar.u.u64Number;
     1196                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1197
     1198                case DBGCVAR_TYPE_HC_FAR:
     1199                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1200
     1201                case DBGCVAR_TYPE_HC_PHYS:
     1202                    pResult->enmType  = DBGCVAR_TYPE_HC_PHYS;
     1203                    pResult->u.HCPhys = (RTHCPHYS)InVar.u.u64Number;
     1204                    return VINF_SUCCESS;
     1205
     1206                case DBGCVAR_TYPE_NUMBER:
     1207                    return VINF_SUCCESS;
     1208
     1209                case DBGCVAR_TYPE_STRING:
     1210                case DBGCVAR_TYPE_SYMBOL:
     1211                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1212
     1213                case DBGCVAR_TYPE_UNKNOWN:
     1214                case DBGCVAR_TYPE_ANY:
     1215                    break;
     1216            }
     1217            break;
     1218
     1219        case DBGCVAR_TYPE_SYMBOL:
     1220        case DBGCVAR_TYPE_STRING:
     1221            switch (enmToType)
     1222            {
     1223                case DBGCVAR_TYPE_GC_FLAT:
     1224                case DBGCVAR_TYPE_GC_FAR:
     1225                case DBGCVAR_TYPE_GC_PHYS:
     1226                case DBGCVAR_TYPE_HC_FLAT:
     1227                case DBGCVAR_TYPE_HC_FAR:
     1228                case DBGCVAR_TYPE_HC_PHYS:
     1229                case DBGCVAR_TYPE_NUMBER:
     1230                    if (fConvSyms)
     1231                        return dbgcSymbolGet(pDbgc, InVar.u.pszString, enmToType, pResult);
     1232                    return VERR_PARSE_INCORRECT_ARG_TYPE;
     1233
     1234                case DBGCVAR_TYPE_STRING:
     1235                case DBGCVAR_TYPE_SYMBOL:
     1236                    pResult->enmType = enmToType;
     1237                    return VINF_SUCCESS;
     1238
     1239                case DBGCVAR_TYPE_UNKNOWN:
     1240                case DBGCVAR_TYPE_ANY:
     1241                    break;
     1242            }
     1243            break;
     1244
     1245        case DBGCVAR_TYPE_UNKNOWN:
     1246        case DBGCVAR_TYPE_ANY:
     1247            break;
     1248    }
     1249
     1250    AssertMsgFailed(("f=%d t=%d\n", InVar.enmType, enmToType));
     1251    return VERR_INVALID_PARAMETER;
     1252}
     1253
     1254
     1255/**
    8181256 * Info helper callback wrapper - print formatted string.
    8191257 *
    … …  
    8821320    pDbgc->CmdHlp.pfnFailV              = dbgcHlpFailV;
    8831321    pDbgc->CmdHlp.pfnVarToDbgfAddr      = dbgcHlpVarToDbgfAddr;
     1322    pDbgc->CmdHlp.pfnVarToNumber        = dbgcHlpVarToNumber;
    8841323    pDbgc->CmdHlp.pfnVarToBool          = dbgcHlpVarToBool;
    8851324    pDbgc->CmdHlp.pfnVarGetRange        = dbgcHlpVarGetRange;
     1325    pDbgc->CmdHlp.pfnVarConvert         = dbgcHlpVarConvert;
    8861326    pDbgc->CmdHlp.pfnGetDbgfOutputHlp   = dbgcHlpGetDbgfOutputHlp;
    8871327}
Note: See TracChangeset for help on using the changeset viewer.

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