Index: /trunk/include/VBox/vmm/dbgf.h =================================================================== --- /trunk/include/VBox/vmm/dbgf.h (revision 35549) +++ /trunk/include/VBox/vmm/dbgf.h (revision 35550) @@ -1449,7 +1449,7 @@ /*VMMR3DECL(int) DBGFR3RegNmQueryLrd( PVM pVM, VMCPUID idDefCpu, const char *pszReg, long double *plrd);*/ VMMR3DECL(int) DBGFR3RegNmQueryXdtr(PVM pVM, VMCPUID idDefCpu, const char *pszReg, uint64_t *pu64Base, uint16_t *pu16Limit); -VMMR3DECL(int) DBGFR3RegNmQueryBatch(PVM pVM,VMCPUID idDefCpu, DBGFREGENTRYNM paRegs, size_t cRegs); +VMMR3DECL(int) DBGFR3RegNmQueryBatch(PVM pVM,VMCPUID idDefCpu, PDBGFREGENTRYNM paRegs, size_t cRegs); VMMR3DECL(int) DBGFR3RegNmQueryAllCount(PVM pVM, size_t *pcRegs); -VMMR3DECL(int) DBGFR3RegNmQueryAll( PVM pVM, DBGFREGENTRYNM paRegs, size_t cRegs); +VMMR3DECL(int) DBGFR3RegNmQueryAll( PVM pVM, PDBGFREGENTRYNM paRegs, size_t cRegs); VMMR3DECL(int) DBGFR3RegNmPrintf( PVM pVM, VMCPUID idDefCpu, char pszBuf, size_t cbBuf, const char *pszFormat, ...); VMMR3DECL(int) DBGFR3RegNmPrintfV( PVM pVM, VMCPUID idDefCpu, char pszBuf, size_t cbBuf, const char *pszFormat, ...); @@ -1461,5 +1461,5 @@ VMMR3DECL(int) DBGFR3RegNmSetU128( PVM pVM, VMCPUID idDefCpu, const char *pszReg, RTUINT128U u128); VMMR3DECL(int) DBGFR3RegNmSetLrd( PVM pVM, VMCPUID idDefCpu, const char *pszReg, long double lrd); -VMMR3DECL(int) DBGFR3RegNmSetBatch( PVM pVM, VMCPUID idDefCpu, DBGFREGENTRYNM paRegs, size_t cRegs); +VMMR3DECL(int) DBGFR3RegNmSetBatch( PVM pVM, VMCPUID idDefCpu, PCDBGFREGENTRYNM paRegs, size_t cRegs); /** @todo add enumeration methods. */ Index: /trunk/src/VBox/Frontends/VBoxManage/VBoxManageDebugVM.cpp =================================================================== --- /trunk/src/VBox/Frontends/VBoxManage/VBoxManageDebugVM.cpp (revision 35549) +++ /trunk/src/VBox/Frontends/VBoxManage/VBoxManageDebugVM.cpp (revision 35550) @@ -85,6 +85,14 @@ Assert(aBstrNames.size() == aBstrValues.size()); + size_t cchMaxName = 8; for (size_t i = 0; i < aBstrNames.size(); i++) - RTPrintf("%ls = %ls\n", aBstrNames[i], aBstrValues[i]); + { + size_t cchName = RTUtf16Len(aBstrNames[i]); + if (cchName > cchMaxName) + cchMaxName = cchName; + } + + for (size_t i = 0; i < aBstrNames.size(); i++) + RTPrintf("%-*ls = %ls\n", cchMaxName, aBstrNames[i], aBstrValues[i]); } else Index: /trunk/src/VBox/Main/src-client/MachineDebuggerImpl.cpp =================================================================== --- /trunk/src/VBox/Main/src-client/MachineDebuggerImpl.cpp (revision 35549) +++ /trunk/src/VBox/Main/src-client/MachineDebuggerImpl.cpp (revision 35550) @@ -1232,37 +1232,50 @@ * Real work. */ - /** @todo query all registers. */ - DBGFREGENTRY aRegs[DBGFREG_ALL_COUNT]; - int vrc = DBGFR3RegCpuQueryAll(ptrVM.raw(), a_idCpu, aRegs, RT_ELEMENTS(aRegs)); + size_t cRegs; + int vrc = DBGFR3RegNmQueryAllCount(ptrVM.raw(), &cRegs); if (RT_SUCCESS(vrc)) { - try + PDBGFREGENTRYNM paRegs = (PDBGFREGENTRYNM)RTMemAllocZ(sizeof(paRegs[0]) * cRegs); + if (paRegs) { - com::SafeArray abstrNames(RT_ELEMENTS(aRegs)); - com::SafeArray abstrValues(RT_ELEMENTS(aRegs)); - - for (uint32_t iReg = 0; iReg < RT_ELEMENTS(aRegs); iReg++) + vrc = DBGFR3RegNmQueryAll(ptrVM.raw(), paRegs, cRegs); + if (RT_SUCCESS(vrc)) { - char szHex[128]; - Bstr bstrValue; - - hrc = formatRegisterValue(&bstrValue, &aRegs[iReg].Val, aRegs[iReg].enmType); - AssertComRC(hrc); - bstrValue.detachTo(&abstrValues[iReg]); - - Bstr bstrName(DBGFR3RegCpuName(ptrVM.raw(), aRegs[iReg].enmReg, DBGFREGVALTYPE_INVALID)); - bstrName.detachTo(&abstrNames[iReg]); + try + { + com::SafeArray abstrNames(cRegs); + com::SafeArray abstrValues(cRegs); + + for (uint32_t iReg = 0; iReg < cRegs; iReg++) + { + char szHex[128]; + Bstr bstrValue; + + hrc = formatRegisterValue(&bstrValue, &paRegs[iReg].Val, paRegs[iReg].enmType); + AssertComRC(hrc); + bstrValue.detachTo(&abstrValues[iReg]); + + Bstr bstrName(paRegs[iReg].pszName); + bstrName.detachTo(&abstrNames[iReg]); + } + + abstrNames.detachTo(ComSafeArrayOutArg(a_bstrNames)); + abstrValues.detachTo(ComSafeArrayOutArg(a_bstrValues)); + } + catch (std::bad_alloc) + { + hrc = E_OUTOFMEMORY; + } } - - abstrValues.detachTo(ComSafeArrayOutArg(a_bstrNames)); - abstrValues.detachTo(ComSafeArrayOutArg(a_bstrValues)); + else + hrc = setError(E_FAIL, tr("DBGFR3RegNmQueryAll failed with %Rrc"), vrc); + + RTMemFree(paRegs); } - catch (std::bad_alloc) - { + else hrc = E_OUTOFMEMORY; - } } else - hrc = setError(E_FAIL, tr("DBGFR3RegQueryAll failed with %Rrc"), vrc); + hrc = setError(E_FAIL, tr("DBGFR3RegNmQueryAllCount failed with %Rrc"), vrc); } } Index: /trunk/src/VBox/VMM/VMMR3/DBGFReg.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMR3/DBGFReg.cpp (revision 35549) +++ /trunk/src/VBox/VMM/VMMR3/DBGFReg.cpp (revision 35550) @@ -113,5 +113,8 @@ uint32_t cDescs; - /** Array of lookup records. */ + /** Array of lookup records. + * The first part of the array runs parallel to paDescs, the rest are + * covering for aliases and bitfield variations. It's done this way to + * simplify the query all operations. */ struct DBGFREGLOOKUP *paLookupRecs; /** The number of lookup records. */ @@ -317,5 +320,5 @@ /* - * Initialize the lookup records. + * Initialize the lookup records. See DBGFREGSET::paLookupRecs. */ char szName[DBGF_REG_MAX_NAME * 3 + 16]; @@ -324,27 +327,34 @@ *pszReg++ = '.'; + /* Array parallel to the descriptors. */ int rc = VINF_SUCCESS; PDBGFREGLOOKUP pLookupRec = &pRegSet->paLookupRecs[0]; for (iDesc = 0; paRegisters[iDesc].pszName != NULL && RT_SUCCESS(rc); iDesc++) { - PCDBGFREGALIAS pCurAlias = NULL; + strcpy(pszReg, paRegisters[iDesc].pszName); + pLookupRec->Core.pszString = MMR3HeapStrDup(pVM, MM_TAG_DBGF_REG, szName); + if (!pLookupRec->Core.pszString) + rc = VERR_NO_STR_MEMORY; + pLookupRec->pSet = pRegSet; + pLookupRec->pDesc = &paRegisters[iDesc]; + pLookupRec->pAlias = NULL; + pLookupRec->pSubField = NULL; + pLookupRec++; + } + + /* Aliases and sub-fields. */ + for (iDesc = 0; paRegisters[iDesc].pszName != NULL && RT_SUCCESS(rc); iDesc++) + { + PCDBGFREGALIAS pCurAlias = NULL; /* first time we add sub-fields for the real name. */ PCDBGFREGALIAS pNextAlias = paRegisters[iDesc].paAliases; const char *pszRegName = paRegisters[iDesc].pszName; while (RT_SUCCESS(rc)) { - size_t cchReg = strlen(pszRegName); - memcpy(pszReg, pszRegName, cchReg + 1); - pLookupRec->Core.pszString = MMR3HeapStrDup(pVM, MM_TAG_DBGF_REG, szName); - if (!pLookupRec->Core.pszString) - rc = VERR_NO_STR_MEMORY; - pLookupRec->pSet = pRegSet; - pLookupRec->pDesc = &paRegisters[iDesc]; - pLookupRec->pAlias = pCurAlias; - pLookupRec->pSubField = NULL; - pLookupRec++; - + /* Add sub-field records. */ PCDBGFREGSUBFIELD paSubFields = paRegisters[iDesc].paSubFields; if (paSubFields) { + size_t cchReg = strlen(pszRegName); + memcpy(pszReg, pszRegName, cchReg); char *pszSub = &pszReg[cchReg]; *pszSub++ = '.'; @@ -363,5 +373,5 @@ } - /* next */ + /* Advance to the next alias. */ pCurAlias = pNextAlias++; if (!pCurAlias) @@ -370,4 +380,15 @@ if (!pszRegName) break; + + /* The alias record. */ + strcpy(pszReg, pszRegName); + pLookupRec->Core.pszString = MMR3HeapStrDup(pVM, MM_TAG_DBGF_REG, szName); + if (!pLookupRec->Core.pszString) + rc = VERR_NO_STR_MEMORY; + pLookupRec->pSet = pRegSet; + pLookupRec->pDesc = &paRegisters[iDesc]; + pLookupRec->pAlias = pCurAlias; + pLookupRec->pSubField = NULL; + pLookupRec++; } } @@ -385,7 +406,11 @@ if (fInserted) { + pVM->dbgf.s.cRegs += pRegSet->cDescs; if (enmType == DBGFREGSETTYPE_CPU) + { + if (pRegSet->cDescs > DBGFREG_ALL_COUNT) + pVM->dbgf.s.cRegs -= pRegSet->cDescs - DBGFREG_ALL_COUNT; pVM->aCpus[iInstance].dbgf.s.pRegSet = pRegSet; - pVM->dbgf.s.cRegs += pRegSet->cDescs; + } PDBGFREGLOOKUP paLookupRecs = pRegSet->paLookupRecs; @@ -1274,6 +1299,6 @@ * Optional. */ -static DECLCALLBACK(int) dbgfR3RegNmQueryWorker(PVM pVM, VMCPUID idDefCpu, const char *pszReg, DBGFREGVALTYPE enmType, - PDBGFREGVAL pValue, PDBGFREGVALTYPE penmType) +static int dbgfR3RegNmQueryWorker(PVM pVM, VMCPUID idDefCpu, const char *pszReg, DBGFREGVALTYPE enmType, + PDBGFREGVAL pValue, PDBGFREGVALTYPE penmType) { /* @@ -1566,8 +1591,153 @@ } - -VMMR3DECL(int) DBGFR3RegNmQueryAll(PVM pVM, DBGFREGENTRYNM paRegs, size_t cRegs) -{ - return VERR_NOT_IMPLEMENTED; +/** + * Argument packet from DBGFR3RegNmQueryAll to dbgfR3RegNmQueryAllWorker. + */ +typedef struct DBGFR3REGNMQUERYALLARGS +{ + /** The output register array. */ + PDBGFREGENTRYNM paRegs; + /** The number of entries in the output array. */ + size_t cRegs; + /** The current register number when enumerating the string space. */ + size_t iReg; +} DBGFR3REGNMQUERYALLARGS; +/** Pointer to a dbgfR3RegNmQueryAllWorker argument packet. */ +typedef DBGFR3REGNMQUERYALLARGS *PDBGFR3REGNMQUERYALLARGS; + + +/** + * Pad register entries. + * + * @param paRegs The output array. + * @param cRegs The size of the output array. + * @param iReg The first register to pad. + * @param cRegsToPad The number of registers to pad. + */ +static void dbgfR3RegNmQueryAllPadEntries(PDBGFREGENTRYNM paRegs, size_t cRegs, size_t iReg, size_t cRegsToPad) +{ + if (iReg < cRegs) + { + size_t iEndReg = iReg + cRegsToPad; + if (iEndReg > cRegs) + iEndReg = cRegs; + while (iReg < iEndReg) + { + paRegs[iReg].pszName = NULL; + paRegs[iReg].enmType = DBGFREGVALTYPE_END; + dbgfR3RegValClear(&paRegs[iReg].Val); + iReg++; + } + } +} + + +/** + * Query all registers in a set. + * + * @param pSet The set. + * @param cRegsToQuery The number of registers to query. + * @param paRegs The output array. + * @param cRegs The size of the output array. + */ +static void dbgfR3RegNmQueryAllInSet(PCDBGFREGSET pSet, size_t cRegsToQuery, PDBGFREGENTRYNM paRegs, size_t cRegs) +{ + int rc = VINF_SUCCESS; + + if (cRegsToQuery > pSet->cDescs) + cRegsToQuery = pSet->cDescs; + if (cRegsToQuery > cRegs) + cRegsToQuery = cRegs; + + for (size_t iReg = 0; iReg < cRegsToQuery; iReg++) + { + paRegs[iReg].enmType = pSet->paDescs[iReg].enmType; + paRegs[iReg].pszName = pSet->paLookupRecs[iReg].Core.pszString; + dbgfR3RegValClear(&paRegs[iReg].Val); + int rc2 = pSet->paDescs[iReg].pfnGet(pSet->uUserArg.pv, &pSet->paDescs[iReg], &paRegs[iReg].Val); + AssertRCSuccess(rc2); + if (RT_FAILURE(rc2)) + dbgfR3RegValClear(&paRegs[iReg].Val); + } +} + + +/** + * @callback_method_impl{FNRTSTRSPACECALLBACK, Worker used by + * dbgfR3RegNmQueryAllWorker} + */ +static DECLCALLBACK(int) dbgfR3RegNmQueryAllEnum(PRTSTRSPACECORE pStr, void *pvUser) +{ + PCDBGFREGSET pSet = (PCDBGFREGSET)pStr; + if (pSet->enmType != DBGFREGSETTYPE_CPU) + { + PDBGFR3REGNMQUERYALLARGS pArgs = (PDBGFR3REGNMQUERYALLARGS)pvUser; + if (pArgs->iReg < pArgs->cRegs) + dbgfR3RegNmQueryAllInSet(pSet, pSet->cDescs, &pArgs->paRegs[pArgs->iReg], pArgs->cRegs - pArgs->iReg); + pArgs->iReg += pSet->cDescs; + } + + return 0; +} + + +/** + * @callback_method_impl{FNVMMEMTRENDEZVOUS, Worker used by DBGFR3RegNmQueryAll} + */ +static DECLCALLBACK(VBOXSTRICTRC) dbgfR3RegNmQueryAllWorker(PVM pVM, PVMCPU pVCpu, void *pvUser) +{ + PDBGFR3REGNMQUERYALLARGS pArgs = (PDBGFR3REGNMQUERYALLARGS)pvUser; + PDBGFREGENTRYNM paRegs = pArgs->paRegs; + size_t const cRegs = pArgs->cRegs; + + /* + * My CPU registers. + */ + size_t iCpuReg = pVCpu->idCpu * DBGFREG_ALL_COUNT; + if (pVCpu->dbgf.s.pRegSet) + { + if (iCpuReg < cRegs) + dbgfR3RegNmQueryAllInSet(pVCpu->dbgf.s.pRegSet, DBGFREG_ALL_COUNT, &paRegs[iCpuReg], cRegs - iCpuReg); + } + else + dbgfR3RegNmQueryAllPadEntries(paRegs, cRegs, iCpuReg, DBGFREG_ALL_COUNT); + + /* + * The primary CPU does all the other registers. + */ + if (pVCpu->idCpu == 0) + { + pArgs->iReg = pVM->cCpus * DBGFREG_ALL_COUNT; + RTStrSpaceEnumerate(&pVM->dbgf.s.RegSetSpace, dbgfR3RegNmQueryAllEnum, pArgs); + dbgfR3RegNmQueryAllPadEntries(paRegs, cRegs, pArgs->iReg, cRegs); + } + + return VINF_SUCCESS; /* Ignore errors. */ +} + + +/** + * Queries all register. + * + * @returns VBox status code. + * @param pVM The VM handle. + * @param paRegs The output register value array. The register + * name string is read only and shall not be freed + * or modified. + * @param cRegs The number of entries in @a paRegs. The + * correct size can be obtained by calling + * DBGFR3RegNmQueryAllCount. + */ +VMMR3DECL(int) DBGFR3RegNmQueryAll(PVM pVM, PDBGFREGENTRYNM paRegs, size_t cRegs) +{ + VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE); + AssertPtrReturn(paRegs, VERR_INVALID_POINTER); + AssertReturn(cRegs > 0, VERR_OUT_OF_RANGE); + + DBGFR3REGNMQUERYALLARGS Args; + Args.paRegs = paRegs; + Args.cRegs = cRegs; + + return VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ALL_AT_ONCE, dbgfR3RegNmQueryAllWorker, &Args); } Index: /trunk/src/VBox/VMM/include/DBGFInternal.h =================================================================== --- /trunk/src/VBox/VMM/include/DBGFInternal.h (revision 35549) +++ /trunk/src/VBox/VMM/include/DBGFInternal.h (revision 35550) @@ -279,5 +279,6 @@ /** String space holding the register sets. (Protected by hRegDbLock.) */ R3PTRTYPE(RTSTRSPACE) RegSetSpace; - /** The number of registers (aliases and sub-fields not counted). */ + /** The number of registers (aliases, sub-fields and the special CPU + * register aliases (eg AH) are not counted). */ uint32_t cRegs; /** For early initialization by . */