VirtualBox

Changeset 35673 in vbox for trunk/src/VBox/Debugger


Ignore:
Timestamp:
Jan 24, 2011 10:15:44 AM (14 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
69597
Message:

Debugger Console: Some cleanups.

Location:
trunk/src/VBox/Debugger
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    r35637 r35673  
    699699
    700700/**
    701  * Converts a DBGC variable to a DBGF address structure.
    702  *
    703  * @returns VBox status code.
    704  * @param   pCmdHlp     Pointer to the command callback structure.
    705  * @param   pVar        The variable to convert.
    706  * @param   pAddress    The target address.
     701 * @interface_method_impl{DBGCCMDHLP,pfnVarToDbgfAddr}
    707702 */
    708703static DECLCALLBACK(int) dbgcHlpVarToDbgfAddr(PDBGCCMDHLP pCmdHlp, PCDBGCVAR pVar, PDBGFADDRESS pAddress)
    709704{
    710705    PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
    711     return dbgcVarToDbgfAddr(pDbgc, pVar, pAddress);
     706    AssertPtr(pVar);
     707    AssertPtr(pAddress);
     708
     709    switch (pVar->enmType)
     710    {
     711        case DBGCVAR_TYPE_GC_FLAT:
     712            DBGFR3AddrFromFlat(pDbgc->pVM, pAddress, pVar->u.GCFlat);
     713            return VINF_SUCCESS;
     714
     715        case DBGCVAR_TYPE_NUMBER:
     716            DBGFR3AddrFromFlat(pDbgc->pVM, pAddress, (RTGCUINTPTR)pVar->u.u64Number);
     717            return VINF_SUCCESS;
     718
     719        case DBGCVAR_TYPE_GC_FAR:
     720            return DBGFR3AddrFromSelOff(pDbgc->pVM, pDbgc->idCpu, pAddress, pVar->u.GCFar.sel, pVar->u.GCFar.off);
     721
     722        case DBGCVAR_TYPE_GC_PHYS:
     723            DBGFR3AddrFromPhys(pDbgc->pVM, pAddress, pVar->u.GCPhys);
     724            return VINF_SUCCESS;
     725
     726        case DBGCVAR_TYPE_STRING:
     727        case DBGCVAR_TYPE_SYMBOL:
     728        {
     729            DBGCVAR Var;
     730            int rc = DBGCCmdHlpEval(&pDbgc->CmdHlp, &Var, "%%(%DV)", pVar);
     731            if (RT_FAILURE(rc))
     732                return rc;
     733            return dbgcHlpVarToDbgfAddr(pCmdHlp, &Var, pAddress);
     734        }
     735
     736        case DBGCVAR_TYPE_HC_FLAT:
     737        case DBGCVAR_TYPE_HC_PHYS:
     738        default:
     739            return VERR_PARSE_CONVERSION_FAILED;
     740    }
     741}
     742
     743
     744/**
     745 * @interface_method_impl{DBGCCMDHLP,pfnVarFromDbgfAddr}
     746 */
     747static DECLCALLBACK(int) dbgcHlpVarFromDbgfAddr(PDBGCCMDHLP pCmdHlp, PCDBGFADDRESS pAddress, PDBGCVAR pResult)
     748{
     749    AssertPtrReturn(pAddress, VERR_INVALID_POINTER);
     750    AssertReturn(DBGFADDRESS_IS_VALID(pAddress), VERR_INVALID_PARAMETER);
     751    AssertPtrReturn(pResult,  VERR_INVALID_POINTER);
     752
     753    switch (pAddress->fFlags & DBGFADDRESS_FLAGS_TYPE_MASK)
     754    {
     755        case DBGFADDRESS_FLAGS_FAR16:
     756        case DBGFADDRESS_FLAGS_FAR32:
     757        case DBGFADDRESS_FLAGS_FAR64:
     758            DBGCVAR_INIT_GC_FAR(pResult, pAddress->Sel, pAddress->off);
     759            break;
     760
     761        case DBGFADDRESS_FLAGS_FLAT:
     762            DBGCVAR_INIT_GC_FLAT(pResult, pAddress->FlatPtr);
     763            break;
     764
     765        case DBGFADDRESS_FLAGS_PHYS:
     766            DBGCVAR_INIT_GC_PHYS(pResult, pAddress->FlatPtr);
     767            break;
     768
     769        default:
     770            DBGCVAR_INIT(pResult);
     771            AssertMsgFailedReturn(("%#x\n", pAddress->fFlags), VERR_INVALID_PARAMETER);
     772            break;
     773    }
     774
     775    return VINF_SUCCESS;
    712776}
    713777
    … …  
    12571321    pDbgc->CmdHlp.pfnFailV              = dbgcHlpFailV;
    12581322    pDbgc->CmdHlp.pfnVarToDbgfAddr      = dbgcHlpVarToDbgfAddr;
     1323    pDbgc->CmdHlp.pfnVarFromDbgfAddr    = dbgcHlpVarFromDbgfAddr;
    12591324    pDbgc->CmdHlp.pfnVarToNumber        = dbgcHlpVarToNumber;
    12601325    pDbgc->CmdHlp.pfnVarToBool          = dbgcHlpVarToBool;

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

    r35632 r35673  
    3232#include "DBGCInternal.h"
    3333
    34 
    35 
    36 //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
    37 //
    38 //
    39 //      V a r i a b l e   M a n i p u l a t i o n
    40 //
    41 //
    42 //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
    43 
    44 
    45 
    46 /** @todo move me!*/
    47 void dbgcVarInit(PDBGCVAR pVar)
    48 {
    49     if (pVar)
    50     {
    51         memset(pVar, 0, sizeof(*pVar));
    52         AssertCompile(DBGCVAR_TYPE_UNKNOWN == 0);
    53         AssertCompile(DBGCVAR_RANGE_NONE == 0);
    54     }
    55 }
    56 
    57 
    58 /** @todo move me!*/
    59 void dbgcVarSetGCFlat(PDBGCVAR pVar, RTGCPTR GCFlat)
    60 {
    61     if (pVar)
    62     {
    63         pVar->enmType  = DBGCVAR_TYPE_GC_FLAT;
    64         memset(&pVar->u, 0, sizeof(pVar->u));
    65         pVar->u.GCFlat = GCFlat;
    66         pVar->enmRangeType = DBGCVAR_RANGE_NONE;
    67         pVar->u64Range  = 0;
    68     }
    69 }
    70 
    71 
    72 /** @todo move me!*/
    73 void dbgcVarSetGCFlatByteRange(PDBGCVAR pVar, RTGCPTR GCFlat, uint64_t cb)
    74 {
    75     if (pVar)
    76     {
    77         pVar->enmType  = DBGCVAR_TYPE_GC_FLAT;
    78         memset(&pVar->u, 0, sizeof(pVar->u));
    79         pVar->u.GCFlat = GCFlat;
    80         pVar->enmRangeType = DBGCVAR_RANGE_BYTES;
    81         pVar->u64Range  = cb;
    82     }
    83 }
    84 
    85 
    86 /** @todo move me!*/
    87 void dbgcVarSetU64(PDBGCVAR pVar, uint64_t u64)
    88 {
    89     if (pVar)
    90     {
    91         pVar->enmType  = DBGCVAR_TYPE_NUMBER;
    92         memset(&pVar->u, 0, sizeof(pVar->u));
    93         pVar->u.u64Number = u64;
    94         pVar->enmRangeType = DBGCVAR_RANGE_NONE;
    95         pVar->u64Range  = 0;
    96     }
    97 }
    98 
    99 
    100 /** @todo move me!*/
    101 void dbgcVarSetVar(PDBGCVAR pVar, PCDBGCVAR pVar2)
    102 {
    103     if (pVar)
    104     {
    105         if (pVar2)
    106             *pVar = *pVar2;
    107         else
    108         {
    109             pVar->enmType = DBGCVAR_TYPE_UNKNOWN;
    110             memset(&pVar->u, 0, sizeof(pVar->u));
    111             pVar->enmRangeType = DBGCVAR_RANGE_NONE;
    112             pVar->u64Range  = 0;
    113         }
    114     }
    115 }
    116 
    117 /** @todo move me!*/
    118 void dbgcVarSetDbgfAddr(PDBGCVAR pVar, PCDBGFADDRESS pAddress)
    119 {
    120     if (pVar)
    121     {
    122         memset(&pVar->u, 0, sizeof(pVar->u));
    123 
    124         Assert(!pAddress || DBGFADDRESS_IS_VALID(pAddress));
    125         if (pAddress && DBGFADDRESS_IS_VALID(pAddress))
    126         {
    127             switch (pAddress->fFlags & DBGFADDRESS_FLAGS_TYPE_MASK)
    128             {
    129                 case DBGFADDRESS_FLAGS_FAR16:
    130                 case DBGFADDRESS_FLAGS_FAR32:
    131                 case DBGFADDRESS_FLAGS_FAR64:
    132                     pVar->enmType = DBGCVAR_TYPE_GC_FAR;
    133                     pVar->u.GCFar.off = pAddress->off;
    134                     pVar->u.GCFar.sel = pAddress->Sel;
    135                     break;
    136 
    137                 case DBGFADDRESS_FLAGS_FLAT:
    138                     pVar->enmType = DBGCVAR_TYPE_GC_FLAT;
    139                     pVar->u.GCFlat = pAddress->FlatPtr;
    140                     break;
    141 
    142                 case DBGFADDRESS_FLAGS_PHYS:
    143                     pVar->enmType = DBGCVAR_TYPE_GC_PHYS;
    144                     pVar->u.GCPhys = pAddress->FlatPtr;
    145                     break;
    146 
    147                 default:
    148                     AssertFailed();
    149                     pVar->enmType = DBGCVAR_TYPE_UNKNOWN;
    150                     break;
    151             }
    152         }
    153         else
    154             pVar->enmType = DBGCVAR_TYPE_UNKNOWN;
    155         pVar->enmRangeType = DBGCVAR_RANGE_NONE;
    156         pVar->u64Range = 0;
    157     }
    158 }
    159 
    160 
    161 /** @todo move me!*/
    162 void dbgcVarSetByteRange(PDBGCVAR pVar, uint64_t cb)
    163 {
    164     if (pVar)
    165     {
    166         pVar->enmRangeType = DBGCVAR_RANGE_BYTES;
    167         pVar->u64Range  = cb;
    168     }
    169 }
    170 
    171 
    172 /** @todo move me!*/
    173 void dbgcVarSetNoRange(PDBGCVAR pVar)
    174 {
    175     if (pVar)
    176     {
    177         pVar->enmRangeType = DBGCVAR_RANGE_NONE;
    178         pVar->u64Range  = 0;
    179     }
    180 }
    181 
    182 
    183 /**
    184  * Converts a DBGC variable to a DBGF address.
    185  *
    186  * @returns VBox status code.
    187  * @param   pDbgc       The DBGC instance.
    188  * @param   pVar        The variable.
    189  * @param   pAddress    Where to store the address.
    190  */
    191 int dbgcVarToDbgfAddr(PDBGC pDbgc, PCDBGCVAR pVar, PDBGFADDRESS pAddress)
    192 {
    193     AssertReturn(pVar, VERR_INVALID_PARAMETER);
    194     switch (pVar->enmType)
    195     {
    196         case DBGCVAR_TYPE_GC_FLAT:
    197             DBGFR3AddrFromFlat(pDbgc->pVM, pAddress, pVar->u.GCFlat);
    198             return VINF_SUCCESS;
    199 
    200         case DBGCVAR_TYPE_NUMBER:
    201             DBGFR3AddrFromFlat(pDbgc->pVM, pAddress, (RTGCUINTPTR)pVar->u.u64Number);
    202             return VINF_SUCCESS;
    203 
    204         case DBGCVAR_TYPE_GC_FAR:
    205             return DBGFR3AddrFromSelOff(pDbgc->pVM, pDbgc->idCpu, pAddress, pVar->u.GCFar.sel, pVar->u.GCFar.off);
    206 
    207         case DBGCVAR_TYPE_GC_PHYS:
    208             DBGFR3AddrFromPhys(pDbgc->pVM, pAddress, pVar->u.GCPhys);
    209             return VINF_SUCCESS;
    210 
    211         case DBGCVAR_TYPE_STRING:
    212         case DBGCVAR_TYPE_SYMBOL:
    213         {
    214             DBGCVAR Var;
    215             int rc = DBGCCmdHlpEval(&pDbgc->CmdHlp, &Var, "%%(%DV)", pVar);
    216             if (RT_FAILURE(rc))
    217                 return rc;
    218             return dbgcVarToDbgfAddr(pDbgc, &Var, pAddress);
    219         }
    220 
    221         case DBGCVAR_TYPE_HC_FLAT:
    222         case DBGCVAR_TYPE_HC_PHYS:
    223         default:
    224             return VERR_PARSE_CONVERSION_FAILED;
    225     }
    226 }
    22734
    22835

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

    r35628 r35673  
    38143814        /* report result */
    38153815        DBGCVAR VarCur;
    3816         dbgcVarInit(&VarCur);
    3817         dbgcVarSetDbgfAddr(&VarCur, &HitAddress);
     3816        rc = DBGCCmdHlpVarFromDbgfAddr(pCmdHlp, &HitAddress, &VarCur);
     3817        if (RT_FAILURE(rc))
     3818            return DBGCCmdHlpVBoxError(pCmdHlp, rc, "DBGCCmdHlpVarFromDbgfAddr\n");
    38183819        if (!pResult)
    38193820            pCmdHlp->pfnExec(pCmdHlp, "db %DV LB 10", &VarCur);
    38203821        else
    3821             dbgcVarSetDbgfAddr(pResult, &HitAddress);
     3822            DBGCVAR_ASSIGN(pResult, &VarCur);
    38223823
    38233824        /* advance */
    … …  
    39153916                                  PCDBGCVAR paPatArgs, unsigned cPatArgs, PDBGCVAR pResult)
    39163917{
    3917     dbgcVarSetGCFlat(pResult, 0);
     3918    DBGCVAR_INIT_GC_FLAT(pResult, 0);
    39183919
    39193920    /*
    … …  
    40384039{
    40394040    PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
    4040     dbgcVarSetGCFlat(pResult, 0);
     4041    DBGCVAR_INIT_GC_FLAT(pResult, 0);
    40414042
    40424043    RTDBGSYMBOL Symbol;
    … …  
    40524053
    40534054        rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "%Rptr %s\n", Symbol.Value, Symbol.szName);
    4054         dbgcVarSetGCFlatByteRange(pResult, Symbol.Value, Symbol.cb);
     4055        DBGCVAR_INIT_GC_FLAT_BYTE_RANGE(pResult, Symbol.Value, Symbol.cb);
    40554056    }
    40564057    else
    … …  
    40644065            return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "%%(%DV)\n", pArg);
    40654066
    4066         dbgcVarSetVar(pResult, &AddrVar);
     4067        DBGCVAR_ASSIGN(pResult, &AddrVar);
    40674068
    40684069        RTINTPTR    offDisp;
    … …  
    40814082        {
    40824083            rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, " LB %RGv\n", Symbol.cb + offDisp);
    4083             dbgcVarSetByteRange(pResult, Symbol.cb + offDisp);
     4084            DBGCVAR_SET_BYTE_RANGE(pResult, Symbol.cb + offDisp);
    40844085        }
    40854086        else
    40864087        {
    40874088            rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "\n");
    4088             dbgcVarSetNoRange(pResult);
     4089            DBGCVAR_ZAP_RANGE(pResult);
    40894090        }
    40904091    }
    … …  
    41064107static DECLCALLBACK(int) dbgcCmdListNear(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
    41074108{
    4108     dbgcVarSetGCFlat(pResult, 0);
     4109    DBGCVAR_INIT_GC_FLAT(pResult, 0);
    41094110    if (!cArgs)
    41104111    {

  • trunk/src/VBox/Debugger/DBGCInternal.h

    r35637 r35673  
    392392int     dbgcBpExec(PDBGC pDbgc, RTUINT iBp);
    393393
    394 void    dbgcVarInit(PDBGCVAR pVar);
    395 void    dbgcVarSetGCFlat(PDBGCVAR pVar, RTGCPTR GCFlat);
    396 void    dbgcVarSetGCFlatByteRange(PDBGCVAR pVar, RTGCPTR GCFlat, uint64_t cb);
    397 void    dbgcVarSetU64(PDBGCVAR pVar, uint64_t u64);
    398 void    dbgcVarSetVar(PDBGCVAR pVar, PCDBGCVAR pVar2);
    399 void    dbgcVarSetDbgfAddr(PDBGCVAR pVar, PCDBGFADDRESS pAddress);
    400 void    dbgcVarSetNoRange(PDBGCVAR pVar);
    401 void    dbgcVarSetByteRange(PDBGCVAR pVar, uint64_t cb);
    402 int     dbgcVarToDbgfAddr(PDBGC pDbgc, PCDBGCVAR pVar, PDBGFADDRESS pAddress);
    403 
    404394void    dbgcEvalInit(void);
    405395int     dbgcEvalSub(PDBGC pDbgc, char *pszExpr, size_t cchExpr, DBGCVARCAT enmCategory, PDBGCVAR pResult);
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