VirtualBox

Changeset 35627 in vbox


Ignore:
Timestamp:
Jan 19, 2011 1:22:02 PM (14 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
69531
Message:

Debugger Console: cleaning up...

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

Legend:

Unmodified
Added
Removed

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

    r35626 r35627  
    11631163                case DBGCVAR_TYPE_NUMBER:
    11641164                    if (fConvSyms)
    1165                         return dbgcSymbolGet(pDbgc, InVar.u.pszString, enmToType, pResult);
     1165                    {
     1166                        rc = dbgcSymbolGet(pDbgc, InVar.u.pszString, enmToType, pResult);
     1167                        if (RT_SUCCESS(rc))
     1168                        {
     1169                            if (InVar.enmRangeType != DBGCVAR_RANGE_NONE)
     1170                            {
     1171                                pResult->enmRangeType = InVar.enmRangeType;
     1172                                pResult->u64Range     = InVar.u64Range;
     1173                            }
     1174                            return VINF_SUCCESS;
     1175                        }
     1176                    }
    11661177                    return VERR_PARSE_INCORRECT_ARG_TYPE;
    11671178

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

    r35626 r35627  
    471471     * Parse sanity.
    472472     */
    473     if (pArg->enmType != DBGCVAR_TYPE_STRING)
     473    if (   pArg->enmType != DBGCVAR_TYPE_STRING
     474        && pArg->enmType != DBGCVAR_TYPE_SYMBOL)
    474475        return VERR_PARSE_INCORRECT_ARG_TYPE;
    475476
    … …  
    482483    if (RT_SUCCESS(rc))
    483484    {
    484         rc = VERR_INTERNAL_ERROR_5;
    485485        switch (enmType)
    486486        {
    … …  
    522522                break;
    523523        }
     524        rc = VERR_INTERNAL_ERROR_5;
    524525    }
    525526    return rc;
    … …  
    540541{
    541542    LogFlow(("dbgcOpAddrFlat\n"));
    542     int     rc;
    543     *pResult = *pArg;
    544 
    545     switch (pArg->enmType)
    546     {
    547         case DBGCVAR_TYPE_GC_FLAT:
    548             return VINF_SUCCESS;
    549 
    550         case DBGCVAR_TYPE_GC_FAR:
    551         {
    552             Assert(pDbgc->pVM);
    553             DBGFADDRESS Address;
    554             rc = DBGFR3AddrFromSelOff(pDbgc->pVM, pDbgc->idCpu, &Address, pArg->u.GCFar.sel, pArg->u.GCFar.off);
    555             if (RT_SUCCESS(rc))
    556             {
    557                 pResult->enmType = DBGCVAR_TYPE_GC_FLAT;
    558                 pResult->u.GCFlat = Address.FlatPtr;
    559                 return VINF_SUCCESS;
    560             }
    561             return VERR_PARSE_CONVERSION_FAILED;
    562         }
    563 
    564         case DBGCVAR_TYPE_GC_PHYS:
    565             //rc = MMR3PhysGCPhys2GCVirtEx(pDbgc->pVM, pResult->u.GCPhys, ..., &pResult->u.GCFlat); - yea, sure.
    566             return VERR_PARSE_INCORRECT_ARG_TYPE;
    567 
    568         case DBGCVAR_TYPE_HC_FLAT:
    569             return VINF_SUCCESS;
    570 
    571         case DBGCVAR_TYPE_HC_PHYS:
    572             Assert(pDbgc->pVM);
    573             pResult->enmType        = DBGCVAR_TYPE_HC_FLAT;
    574             rc = MMR3HCPhys2HCVirt(pDbgc->pVM, pResult->u.HCPhys, &pResult->u.pvHCFlat);
    575             if (RT_SUCCESS(rc))
    576                 return VINF_SUCCESS;
    577             return VERR_PARSE_CONVERSION_FAILED;
    578 
    579         case DBGCVAR_TYPE_NUMBER:
    580             pResult->enmType    = DBGCVAR_TYPE_GC_FLAT;
    581             pResult->u.GCFlat   = (RTGCPTR)pResult->u.u64Number;
    582             return VINF_SUCCESS;
    583 
    584         case DBGCVAR_TYPE_STRING:
    585             return dbgcSymbolGet(pDbgc, pArg->u.pszString, DBGCVAR_TYPE_GC_FLAT, pResult);
    586 
    587         case DBGCVAR_TYPE_UNKNOWN:
    588         default:
    589             return VERR_PARSE_INCORRECT_ARG_TYPE;
    590     }
     543    DBGCVARTYPE enmType = DBGCVAR_ISHCPOINTER(pArg->enmType) ? DBGCVAR_TYPE_HC_FLAT : DBGCVAR_TYPE_GC_FLAT;
     544    return DBGCCmdHlpConvert(&pDbgc->CmdHlp, pArg, enmType, true /*fConvSyms*/, pResult);
    591545}
    592546
    … …  
    605559{
    606560    LogFlow(("dbgcOpAddrPhys\n"));
    607     int         rc;
    608     DBGFADDRESS Address;
    609 
    610     *pResult = *pArg;
    611     switch (pArg->enmType)
    612     {
    613         case DBGCVAR_TYPE_GC_FLAT:
    614             Assert(pDbgc->pVM);
    615             pResult->enmType = DBGCVAR_TYPE_GC_PHYS;
    616             rc = DBGFR3AddrToPhys(pDbgc->pVM, pDbgc->idCpu,
    617                                   DBGFR3AddrFromFlat(pDbgc->pVM, &Address, pArg->u.GCFlat),
    618                                   &pResult->u.GCPhys);
    619             if (RT_SUCCESS(rc))
    620                 return VINF_SUCCESS;
    621             return VERR_PARSE_CONVERSION_FAILED;
    622 
    623         case DBGCVAR_TYPE_GC_FAR:
    624             Assert(pDbgc->pVM);
    625             rc = DBGFR3AddrFromSelOff(pDbgc->pVM, pDbgc->idCpu, &Address, pArg->u.GCFar.sel, pArg->u.GCFar.off);
    626             if (RT_SUCCESS(rc))
    627             {
    628                 pResult->enmType = DBGCVAR_TYPE_GC_PHYS;
    629                 rc = DBGFR3AddrToPhys(pDbgc->pVM, pDbgc->idCpu, &Address, &pResult->u.GCPhys);
    630                 if (RT_SUCCESS(rc))
    631                     return VINF_SUCCESS;
    632             }
    633             return VERR_PARSE_CONVERSION_FAILED;
    634 
    635         case DBGCVAR_TYPE_GC_PHYS:
    636             return VINF_SUCCESS;
    637 
    638         case DBGCVAR_TYPE_HC_FLAT:
    639             Assert(pDbgc->pVM);
    640             pResult->enmType = DBGCVAR_TYPE_GC_PHYS;
    641             rc = PGMR3DbgR3Ptr2GCPhys(pDbgc->pVM, pArg->u.pvHCFlat, &pResult->u.GCPhys);
    642             if (RT_SUCCESS(rc))
    643                 return VINF_SUCCESS;
    644             /** @todo more memory types! */
    645             return VERR_PARSE_CONVERSION_FAILED;
    646 
    647         case DBGCVAR_TYPE_HC_PHYS:
    648             return VINF_SUCCESS;
    649 
    650         case DBGCVAR_TYPE_NUMBER:
    651             pResult->enmType    = DBGCVAR_TYPE_GC_PHYS;
    652             pResult->u.GCPhys   = (RTGCPHYS)pResult->u.u64Number;
    653             return VINF_SUCCESS;
    654 
    655         case DBGCVAR_TYPE_STRING:
    656             return dbgcSymbolGet(pDbgc, pArg->u.pszString, DBGCVAR_TYPE_GC_PHYS, pResult);
    657 
    658         case DBGCVAR_TYPE_UNKNOWN:
    659         default:
    660             return VERR_PARSE_INCORRECT_ARG_TYPE;
    661     }
    662     return VINF_SUCCESS;
     561    DBGCVARTYPE enmType = DBGCVAR_ISHCPOINTER(pArg->enmType) ? DBGCVAR_TYPE_HC_PHYS : DBGCVAR_TYPE_GC_PHYS;
     562    return DBGCCmdHlpConvert(&pDbgc->CmdHlp, pArg, enmType, true /*fConvSyms*/, pResult);
    663563}
    664564
    … …  
    677577{
    678578    LogFlow(("dbgcOpAddrPhys\n"));
    679     DBGFADDRESS Address;
    680     int         rc;
    681 
    682     *pResult = *pArg;
    683     switch (pArg->enmType)
    684     {
    685         case DBGCVAR_TYPE_GC_FLAT:
    686             Assert(pDbgc->pVM);
    687             pResult->enmType = DBGCVAR_TYPE_HC_PHYS;
    688             rc = DBGFR3AddrToHostPhys(pDbgc->pVM, pDbgc->idCpu,
    689                                       DBGFR3AddrFromFlat(pDbgc->pVM, &Address, pArg->u.GCFlat),
    690                                       &pResult->u.GCPhys);
    691             if (RT_SUCCESS(rc))
    692                 return VINF_SUCCESS;
    693             return VERR_PARSE_CONVERSION_FAILED;
    694 
    695         case DBGCVAR_TYPE_GC_FAR:
    696         {
    697             Assert(pDbgc->pVM);
    698             rc = DBGFR3AddrFromSelOff(pDbgc->pVM, pDbgc->idCpu, &Address, pArg->u.GCFar.sel, pArg->u.GCFar.off);
    699             if (RT_SUCCESS(rc))
    700             {
    701                 pResult->enmType = DBGCVAR_TYPE_HC_PHYS;
    702                 rc = DBGFR3AddrToHostPhys(pDbgc->pVM, pDbgc->idCpu, &Address, &pResult->u.GCPhys);
    703                 if (RT_SUCCESS(rc))
    704                     return VINF_SUCCESS;
    705             }
    706             return VERR_PARSE_CONVERSION_FAILED;
    707         }
    708 
    709         case DBGCVAR_TYPE_GC_PHYS:
    710             Assert(pDbgc->pVM);
    711             pResult->enmType = DBGCVAR_TYPE_HC_PHYS;
    712             rc = DBGFR3AddrToHostPhys(pDbgc->pVM, pDbgc->idCpu,
    713                                       DBGFR3AddrFromPhys(pDbgc->pVM, &Address, pArg->u.GCPhys),
    714                                       &pResult->u.GCPhys);
    715             if (RT_SUCCESS(rc))
    716                 return VINF_SUCCESS;
    717             return VERR_PARSE_CONVERSION_FAILED;
    718 
    719         case DBGCVAR_TYPE_HC_FLAT:
    720             Assert(pDbgc->pVM);
    721             pResult->enmType = DBGCVAR_TYPE_HC_PHYS;
    722             rc = PGMR3DbgR3Ptr2HCPhys(pDbgc->pVM, pArg->u.pvHCFlat, &pResult->u.HCPhys);
    723             if (RT_SUCCESS(rc))
    724                 return VINF_SUCCESS;
    725             /** @todo more memory types! */
    726             return VERR_PARSE_CONVERSION_FAILED;
    727 
    728         case DBGCVAR_TYPE_HC_PHYS:
    729             return VINF_SUCCESS;
    730 
    731         case DBGCVAR_TYPE_NUMBER:
    732             pResult->enmType    = DBGCVAR_TYPE_HC_PHYS;
    733             pResult->u.HCPhys   = (RTGCPHYS)pResult->u.u64Number;
    734             return VINF_SUCCESS;
    735 
    736         case DBGCVAR_TYPE_STRING:
    737             return dbgcSymbolGet(pDbgc, pArg->u.pszString, DBGCVAR_TYPE_HC_PHYS, pResult);
    738 
    739         case DBGCVAR_TYPE_UNKNOWN:
    740         default:
    741             return VERR_PARSE_INCORRECT_ARG_TYPE;
    742     }
    743     return VINF_SUCCESS;
     579    return DBGCCmdHlpConvert(&pDbgc->CmdHlp, pArg, DBGCVAR_TYPE_HC_PHYS, true /*fConvSyms*/, pResult);
    744580}
    745581
    … …  
    758594{
    759595    LogFlow(("dbgcOpAddrHost\n"));
    760     int             rc;
    761     DBGFADDRESS     Address;
    762 
    763     *pResult = *pArg;
    764     switch (pArg->enmType)
    765     {
    766         case DBGCVAR_TYPE_GC_FLAT:
    767             Assert(pDbgc->pVM);
    768             pResult->enmType = DBGCVAR_TYPE_HC_FLAT;
    769             rc = DBGFR3AddrToVolatileR3Ptr(pDbgc->pVM, pDbgc->idCpu,
    770                                            DBGFR3AddrFromFlat(pDbgc->pVM, &Address, pArg->u.GCFlat),
    771                                            false /*fReadOnly */,
    772                                            &pResult->u.pvHCFlat);
    773             if (RT_SUCCESS(rc))
    774                 return VINF_SUCCESS;
    775             return VERR_PARSE_CONVERSION_FAILED;
    776 
    777         case DBGCVAR_TYPE_GC_FAR:
    778             Assert(pDbgc->pVM);
    779             rc = DBGFR3AddrFromSelOff(pDbgc->pVM, pDbgc->idCpu, &Address, pArg->u.GCFar.sel, pArg->u.GCFar.off);
    780             if (RT_SUCCESS(rc))
    781             {
    782                 pResult->enmType = DBGCVAR_TYPE_HC_FLAT;
    783                 rc = DBGFR3AddrToVolatileR3Ptr(pDbgc->pVM, pDbgc->idCpu, &Address,
    784                                                false /*fReadOnly*/, &pResult->u.pvHCFlat);
    785                 if (RT_SUCCESS(rc))
    786                     return VINF_SUCCESS;
    787             }
    788             return VERR_PARSE_CONVERSION_FAILED;
    789 
    790         case DBGCVAR_TYPE_GC_PHYS:
    791             Assert(pDbgc->pVM);
    792             pResult->enmType = DBGCVAR_TYPE_HC_FLAT;
    793             rc = DBGFR3AddrToVolatileR3Ptr(pDbgc->pVM, pDbgc->idCpu,
    794                                            DBGFR3AddrFromPhys(pDbgc->pVM, &Address, pArg->u.GCPhys),
    795                                            false /*fReadOnly */,
    796                                            &pResult->u.pvHCFlat);
    797             if (RT_SUCCESS(rc))
    798                 return VINF_SUCCESS;
    799             return VERR_PARSE_CONVERSION_FAILED;
    800 
    801         case DBGCVAR_TYPE_HC_FLAT:
    802             return VINF_SUCCESS;
    803 
    804         case DBGCVAR_TYPE_HC_PHYS:
    805             /** @todo !*/
    806             return VERR_PARSE_CONVERSION_FAILED;
    807 
    808         case DBGCVAR_TYPE_NUMBER:
    809             pResult->enmType    = DBGCVAR_TYPE_HC_FLAT;
    810             pResult->u.pvHCFlat = (void *)(uintptr_t)pResult->u.u64Number;
    811             return VINF_SUCCESS;
    812 
    813         case DBGCVAR_TYPE_STRING:
    814             return dbgcSymbolGet(pDbgc, pArg->u.pszString, DBGCVAR_TYPE_HC_FLAT, pResult);
    815 
    816         case DBGCVAR_TYPE_UNKNOWN:
    817         default:
    818             return VERR_PARSE_INCORRECT_ARG_TYPE;
    819     }
     596    return DBGCCmdHlpConvert(&pDbgc->CmdHlp, pArg, DBGCVAR_TYPE_HC_FLAT, true /*fConvSyms*/, pResult);
    820597}
    821598

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

    r35626 r35627  
    202202 * @param   pDbgc       The debug console instance.
    203203 * @param   pszSymbol   The symbol name.
    204  * @param   enmType     The result type.
     204 * @param   enmType     The result type.  Specifying DBGCVAR_TYPE_GC_FAR may
     205 *                      cause failure, avoid it.
    205206 * @param   pResult     Where to store the result.
    206207 */
    … …  
    279280         * Default return is a flat gc address.
    280281         */
    281         memset(pResult, 0,  sizeof(*pResult));
    282         pResult->enmRangeType = Symbol.cb ? DBGCVAR_RANGE_BYTES : DBGCVAR_RANGE_NONE;
    283         pResult->u64Range     = Symbol.cb;
    284         pResult->enmType      = DBGCVAR_TYPE_GC_FLAT;
    285         pResult->u.GCFlat     = Symbol.Value;
    286         DBGCVAR VarTmp;
     282        DBGCVAR_INIT_GC_FLAT(pResult, Symbol.Value);
     283        if (Symbol.cb)
     284            DBGCVAR_SET_RANGE(pResult, DBGCVAR_RANGE_BYTES, Symbol.cb);
     285
    287286        switch (enmType)
    288287        {
    289288            /* nothing to do. */
    290289            case DBGCVAR_TYPE_GC_FLAT:
    291             case DBGCVAR_TYPE_GC_FAR:
    292290            case DBGCVAR_TYPE_ANY:
    293291                return VINF_SUCCESS;
     292
     293            /* impossible at the moment. */
     294            case DBGCVAR_TYPE_GC_FAR:
     295                return VERR_PARSE_CONVERSION_FAILED;
    294296
    295297            /* simply make it numeric. */
    … …  
    300302
    301303            /* cast it. */
    302 
    303304            case DBGCVAR_TYPE_GC_PHYS:
    304                 VarTmp = *pResult;
    305                 return dbgcOpAddrPhys(pDbgc, &VarTmp, pResult);
    306 
    307305            case DBGCVAR_TYPE_HC_FLAT:
    308                 VarTmp = *pResult;
    309                 return dbgcOpAddrHost(pDbgc, &VarTmp, pResult);
    310 
    311306            case DBGCVAR_TYPE_HC_PHYS:
    312                 VarTmp = *pResult;
    313                 return dbgcOpAddrHostPhys(pDbgc, &VarTmp, pResult);
     307                return DBGCCmdHlpConvert(&pDbgc->CmdHlp, pResult, enmType, false /*fConvSyms*/, pResult);
    314308
    315309            default:
    … …  
    14201414static int dbgcProcessCommands(PDBGC pDbgc, bool fNoExecute)
    14211415{
     1416    /** @todo Replace this with a sh/ksh/csh/rexx like toplevel language that
     1417     *        allows doing function, loops, if, cases, and such. */
    14221418    int rc = 0;
    14231419    while (pDbgc->cInputLines)
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