x64dbg/x64dbg
x64dbg
/
x64dbg
1
0
Fork 0
Code Releases 5 Activity

Move XMM formatting to StringUtils

This commit is contained in:
torusrxxx 2020-05-25 18:33:35 +08:00 committed by Duncan Ogilvie
parent fd4d691928
commit bd381d72c6
5 changed files with 193 additions and 278 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
src/gui/Src/Gui/CPUInfoBox.cpp
View File

@ -92,35 +92,42 @@ void CPUInfoBox::clear()
setInfoLine(3, "");
}
static QString formatSSEOperand(QVector<unsigned char> data, uint8_t vectorType)
static QString formatSSEOperand(const QVector<char> & data, uint8_t vectorType)
{
QString hex;
bool isXMMdecoded = false;
switch(vectorType)
{
case Zydis::VETFloat32:
if(data.size() == 16)
if(data.size() == 32)
{
hex = "%1 %2 %3 %4";
hex = hex.arg(((const float*)data.data())[0]).arg(((const float*)data.data())[1]).arg(((const float*)data.data())[2]).arg(((const float*)data.data())[3]);
hex = composeRegTextYMM(data.constData(), 1);
}
else if(data.size() == 16)
{
hex = composeRegTextXMM(data.constData(), 1);
isXMMdecoded = true;
}
else if(data.size() == 4)
{
hex = QString::number(((const float*)data.data())[0]);
hex = QString::number(((const float*)data.constData())[0]);
isXMMdecoded = true;
}
break;
case Zydis::VETFloat64:
if(data.size() == 16)
if(data.size() == 32)
{
hex = "%1 %2";
hex = hex.arg(((const double*)data.data())[0]).arg(((const double*)data.data())[1]);
hex = composeRegTextYMM(data.constData(), 2);
isXMMdecoded = true;
}
else if(data.size() == 16)
{
hex = composeRegTextXMM(data.constData(), 2);
isXMMdecoded = true;
}
else if(data.size() == 8)
{
hex = QString::number(((const double*)data.data())[0]);
hex = QString::number(((const double*)data.constData())[0]);
isXMMdecoded = true;
}
break;
@ -263,7 +270,7 @@ void CPUInfoBox::disasmSelectionChanged(dsint parVA)
else
{
//TODO: properly support XMM constants
QVector<unsigned char> data;
QVector<char> data;
data.resize(basicinfo.memory.size);
memset(data.data(), 0, data.size());
if(DbgMemRead(arg.value, data.data(), data.size()))

276
src/gui/Src/Gui/RegistersView.cpp
View File

@ -686,47 +686,6 @@ RegistersView::RegistersView(CPUWidget* parent) : QScrollArea(parent), mVScrollO
{
setWindowTitle("Registers");
mChangeViewButton = NULL;
connect(Bridge::getBridge(), SIGNAL(close()), this, SLOT(onClose()));
switch(ConfigUint("Gui", "SIMDRegistersDisplayMode"))
{
default:
case 0:
wSIMDRegDispMode = SIMD_REG_DISP_HEX;
break;
case 1:
wSIMDRegDispMode = SIMD_REG_DISP_FLOAT;
break;
case 2:
wSIMDRegDispMode = SIMD_REG_DISP_DOUBLE;
break;
case 3:
wSIMDRegDispMode = SIMD_REG_DISP_WORD_SIGNED;
break;
case 4:
wSIMDRegDispMode = SIMD_REG_DISP_DWORD_SIGNED;
break;
case 5:
wSIMDRegDispMode = SIMD_REG_DISP_QWORD_SIGNED;
break;
case 6:
wSIMDRegDispMode = SIMD_REG_DISP_WORD_UNSIGNED;
break;
case 7:
wSIMDRegDispMode = SIMD_REG_DISP_DWORD_UNSIGNED;
break;
case 8:
wSIMDRegDispMode = SIMD_REG_DISP_QWORD_UNSIGNED;
break;
case 9:
wSIMDRegDispMode = SIMD_REG_DISP_WORD_HEX;
break;
case 10:
wSIMDRegDispMode = SIMD_REG_DISP_DWORD_HEX;
break;
case 11:
wSIMDRegDispMode = SIMD_REG_DISP_QWORD_HEX;
break;
}
mFpuMode = 0;
// precreate ContextMenu Actions
@ -771,18 +730,18 @@ RegistersView::RegistersView(CPUWidget* parent) : QScrollArea(parent), mVScrollO
SIMDHWord = new QAction(tr("Hexadecimal Word"), mSwitchSIMDDispMode);
SIMDHDWord = new QAction(tr("Hexadecimal DWord"), mSwitchSIMDDispMode);
SIMDHQWord = new QAction(tr("Hexadecimal QWord"), mSwitchSIMDDispMode);
SIMDHex->setData(QVariant(SIMD_REG_DISP_HEX));
SIMDFloat->setData(QVariant(SIMD_REG_DISP_FLOAT));
SIMDDouble->setData(QVariant(SIMD_REG_DISP_DOUBLE));
SIMDSWord->setData(QVariant(SIMD_REG_DISP_WORD_SIGNED));
SIMDUWord->setData(QVariant(SIMD_REG_DISP_WORD_UNSIGNED));
SIMDHWord->setData(QVariant(SIMD_REG_DISP_WORD_HEX));
SIMDSDWord->setData(QVariant(SIMD_REG_DISP_DWORD_SIGNED));
SIMDUDWord->setData(QVariant(SIMD_REG_DISP_DWORD_UNSIGNED));
SIMDHDWord->setData(QVariant(SIMD_REG_DISP_DWORD_HEX));
SIMDSQWord->setData(QVariant(SIMD_REG_DISP_QWORD_SIGNED));
SIMDUQWord->setData(QVariant(SIMD_REG_DISP_QWORD_UNSIGNED));
SIMDHQWord->setData(QVariant(SIMD_REG_DISP_QWORD_HEX));
SIMDHex->setData(QVariant(0));
SIMDFloat->setData(QVariant(1));
SIMDDouble->setData(QVariant(2));
SIMDSWord->setData(QVariant(3));
SIMDUWord->setData(QVariant(6));
SIMDHWord->setData(QVariant(9));
SIMDSDWord->setData(QVariant(4));
SIMDUDWord->setData(QVariant(7));
SIMDHDWord->setData(QVariant(10));
SIMDSQWord->setData(QVariant(5));
SIMDUQWord->setData(QVariant(8));
SIMDHQWord->setData(QVariant(11));
mDisplaySTX->setData(QVariant(0));
mDisplayx87rX->setData(QVariant(1));
mDisplayMMX->setData(QVariant(2));
@ -1371,51 +1330,6 @@ RegistersView::~RegistersView()
{
}
void RegistersView::onClose()
{
duint cfg = 0;
switch(wSIMDRegDispMode)
{
case SIMD_REG_DISP_HEX:
cfg = 0;
break;
case SIMD_REG_DISP_FLOAT:
cfg = 1;
break;
case SIMD_REG_DISP_DOUBLE:
cfg = 2;
break;
case SIMD_REG_DISP_WORD_SIGNED:
cfg = 3;
break;
case SIMD_REG_DISP_DWORD_SIGNED:
cfg = 4;
break;
case SIMD_REG_DISP_QWORD_SIGNED:
cfg = 5;
break;
case SIMD_REG_DISP_WORD_UNSIGNED:
cfg = 6;
break;
case SIMD_REG_DISP_DWORD_UNSIGNED:
cfg = 7;
break;
case SIMD_REG_DISP_QWORD_UNSIGNED:
cfg = 8;
break;
case SIMD_REG_DISP_WORD_HEX:
cfg = 9;
break;
case SIMD_REG_DISP_DWORD_HEX:
cfg = 10;
break;
case SIMD_REG_DISP_QWORD_HEX:
cfg = 11;
break;
}
Config()->setUint("Gui", "SIMDRegistersDisplayMode", cfg);
}
void RegistersView::fontsUpdatedSlot()
{
auto font = ConfigFont("Registers");
@ -1885,133 +1799,6 @@ QString RegistersView::getRegisterLabel(REGISTER_NAME register_selected)
return std::move(newText);
}
static QString fillValue(const char* value, int valsize = 2, bool bFpuRegistersLittleEndian = false)
{
if(bFpuRegistersLittleEndian)
return QString(QByteArray(value, valsize).toHex()).toUpper();
else // Big Endian
return QString(ByteReverse(QByteArray(value, valsize)).toHex()).toUpper();
}
static QString composeRegTextXMM(const char* value, RegistersView::SIMD_REG_DISP_MODE wSIMDRegDispMode, bool bFpuRegistersLittleEndian)
{
QString valueText;
switch(wSIMDRegDispMode)
{
default:
case RegistersView::SIMD_REG_DISP_HEX:
{
valueText = fillValue(value, 16, bFpuRegistersLittleEndian);
}
break;
case RegistersView::SIMD_REG_DISP_DOUBLE:
{
const double* dbl_values = reinterpret_cast<const double*>(value);
if(bFpuRegistersLittleEndian)
valueText = ToDoubleString(&dbl_values[0]) + ' ' + ToDoubleString(&dbl_values[1]);
else // Big Endian
valueText = ToDoubleString(&dbl_values[1]) + ' ' + ToDoubleString(&dbl_values[0]);
}
break;
case RegistersView::SIMD_REG_DISP_FLOAT:
{
const float* flt_values = reinterpret_cast<const float*>(value);
if(bFpuRegistersLittleEndian)
valueText = ToFloatString(&flt_values[0]) + ' ' + ToFloatString(&flt_values[1]) + ' '
+ ToFloatString(&flt_values[2]) + ' ' + ToFloatString(&flt_values[3]);
else // Big Endian
valueText = ToFloatString(&flt_values[3]) + ' ' + ToFloatString(&flt_values[2]) + ' '
+ ToFloatString(&flt_values[1]) + ' ' + ToFloatString(&flt_values[0]);
}
break;
case RegistersView::SIMD_REG_DISP_WORD_HEX:
{
if(bFpuRegistersLittleEndian)
valueText = fillValue(value) + ' ' + fillValue(value + 1 * 2) + ' ' + fillValue(value + 2 * 2) + ' ' + fillValue(value + 3 * 2)
+ ' ' + fillValue(value + 4 * 2) + ' ' + fillValue(value + 5 * 2) + ' ' + fillValue(value + 6 * 2) + ' ' + fillValue(value + 7 * 2);
else // Big Endian
valueText = fillValue(value + 7 * 2) + ' ' + fillValue(value + 6 * 2) + ' ' + fillValue(value + 5 * 2) + ' ' + fillValue(value + 4 * 2)
+ ' ' + fillValue(value + 3 * 2) + ' ' + fillValue(value + 2 * 2) + ' ' + fillValue(value + 1 * 2) + ' ' + fillValue(value);
}
break;
case RegistersView::SIMD_REG_DISP_WORD_SIGNED:
{
const short* sword_values = reinterpret_cast<const short*>(value);
if(bFpuRegistersLittleEndian)
valueText = QString::number(sword_values[0]) + ' ' + QString::number(sword_values[1]) + ' ' + QString::number(sword_values[2]) + ' ' + QString::number(sword_values[3])
+ ' ' + QString::number(sword_values[4]) + ' ' + QString::number(sword_values[5]) + ' ' + QString::number(sword_values[6]) + ' ' + QString::number(sword_values[7]);
else // Big Endian
valueText = QString::number(sword_values[7]) + ' ' + QString::number(sword_values[6]) + ' ' + QString::number(sword_values[5]) + ' ' + QString::number(sword_values[4])
+ ' ' + QString::number(sword_values[3]) + ' ' + QString::number(sword_values[2]) + ' ' + QString::number(sword_values[1]) + ' ' + QString::number(sword_values[0]);
}
break;
case RegistersView::SIMD_REG_DISP_WORD_UNSIGNED:
{
const unsigned short* uword_values = reinterpret_cast<const unsigned short*>(value);
if(bFpuRegistersLittleEndian)
valueText = QString::number(uword_values[0]) + ' ' + QString::number(uword_values[1]) + ' ' + QString::number(uword_values[2]) + ' ' + QString::number(uword_values[3])
+ ' ' + QString::number(uword_values[4]) + ' ' + QString::number(uword_values[5]) + ' ' + QString::number(uword_values[6]) + ' ' + QString::number(uword_values[7]);
else // Big Endian
valueText = QString::number(uword_values[7]) + ' ' + QString::number(uword_values[6]) + ' ' + QString::number(uword_values[5]) + ' ' + QString::number(uword_values[4])
+ ' ' + QString::number(uword_values[3]) + ' ' + QString::number(uword_values[2]) + ' ' + QString::number(uword_values[1]) + ' ' + QString::number(uword_values[0]);
}
break;
case RegistersView::SIMD_REG_DISP_DWORD_HEX:
{
if(bFpuRegistersLittleEndian)
valueText = fillValue(value, 4) + ' ' + fillValue(value + 1 * 4, 4) + ' ' + fillValue(value + 2 * 4, 4) + ' ' + fillValue(value + 3 * 4, 4);
else // Big Endian
valueText = fillValue(value + 3 * 4, 4) + ' ' + fillValue(value + 2 * 4, 4) + ' ' + fillValue(value + 1 * 4, 4) + ' ' + fillValue(value, 4);
}
break;
case RegistersView::SIMD_REG_DISP_DWORD_SIGNED:
{
const int* sdword_values = reinterpret_cast<const int*>(value);
if(bFpuRegistersLittleEndian)
valueText = QString::number(sdword_values[0]) + ' ' + QString::number(sdword_values[1]) + ' ' + QString::number(sdword_values[2]) + ' ' + QString::number(sdword_values[3]);
else // Big Endian
valueText = QString::number(sdword_values[3]) + ' ' + QString::number(sdword_values[2]) + ' ' + QString::number(sdword_values[1]) + ' ' + QString::number(sdword_values[0]);
}
break;
case RegistersView::SIMD_REG_DISP_DWORD_UNSIGNED:
{
const unsigned int* udword_values = reinterpret_cast<const unsigned int*>(value);
if(bFpuRegistersLittleEndian)
valueText = QString::number(udword_values[0]) + ' ' + QString::number(udword_values[1]) + ' ' + QString::number(udword_values[2]) + ' ' + QString::number(udword_values[3]);
else // Big Endian
valueText = QString::number(udword_values[3]) + ' ' + QString::number(udword_values[2]) + ' ' + QString::number(udword_values[1]) + ' ' + QString::number(udword_values[0]);
}
break;
case RegistersView::SIMD_REG_DISP_QWORD_HEX:
{
if(bFpuRegistersLittleEndian)
valueText = fillValue(value, 8) + ' ' + fillValue(value + 8, 8);
else // Big Endian
valueText = fillValue(value + 8, 8) + ' ' + fillValue(value, 8);
}
break;
case RegistersView::SIMD_REG_DISP_QWORD_SIGNED:
{
const long long* sqword_values = reinterpret_cast<const long long*>(value);
if(bFpuRegistersLittleEndian)
valueText = QString::number(sqword_values[0]) + ' ' + QString::number(sqword_values[1]);
else // Big Endian
valueText = QString::number(sqword_values[1]) + ' ' + QString::number(sqword_values[0]);
}
break;
case RegistersView::SIMD_REG_DISP_QWORD_UNSIGNED:
{
const unsigned long long* uqword_values = reinterpret_cast<const unsigned long long*>(value);
if(bFpuRegistersLittleEndian)
valueText = QString::number(uqword_values[0]) + ' ' + QString::number(uqword_values[1]);
else // Big Endian
valueText = QString::number(uqword_values[1]) + ' ' + QString::number(uqword_values[0]);
}
break;
}
return std::move(valueText);
}
/**
* @brief RegistersView::GetRegStringValueFromValue Get the textual representation of the register value.
* @param reg The name of the register
@ -2095,16 +1882,9 @@ QString RegistersView::GetRegStringValueFromValue(REGISTER_NAME reg, const char*
if(size != 0)
{
if(mFPUXMM.contains(reg))
valueText = composeRegTextXMM(value, wSIMDRegDispMode, bFpuRegistersLittleEndian);
valueText = GetDataTypeString(value, size, enc_xmmword);
else if(mFPUYMM.contains(reg))
{
if(wSIMDRegDispMode == SIMD_REG_DISP_HEX)
valueText = fillValue(value, size, bFpuRegistersLittleEndian);
else if(bFpuRegistersLittleEndian)
valueText = composeRegTextXMM(value, wSIMDRegDispMode, bFpuRegistersLittleEndian) + ' ' + composeRegTextXMM(value + 16, wSIMDRegDispMode, bFpuRegistersLittleEndian);
else
valueText = composeRegTextXMM(value + 16, wSIMDRegDispMode, bFpuRegistersLittleEndian) + ' ' + composeRegTextXMM(value, wSIMDRegDispMode, bFpuRegistersLittleEndian);
}
valueText = GetDataTypeString(value, size, enc_ymmword);
else
valueText = fillValue(value, size, bFpuRegistersLittleEndian);
}
@ -3150,42 +2930,42 @@ void RegistersView::displayCustomContextMenuSlot(QPoint pos)
QMenu wMenu(this);
QMenu* followInDumpNMenu = nullptr;
const QAction* selectedAction = nullptr;
switch(wSIMDRegDispMode)
switch(ConfigUint("Gui", "SIMDRegistersDisplayMode"))
{
case SIMD_REG_DISP_HEX:
case 0:
selectedAction = SIMDHex;
break;
case SIMD_REG_DISP_FLOAT:
case 1:
selectedAction = SIMDFloat;
break;
case SIMD_REG_DISP_DOUBLE:
case 2:
selectedAction = SIMDDouble;
break;
case SIMD_REG_DISP_WORD_SIGNED:
case 3:
selectedAction = SIMDSWord;
break;
case SIMD_REG_DISP_WORD_UNSIGNED:
case 6:
selectedAction = SIMDUWord;
break;
case SIMD_REG_DISP_WORD_HEX:
case 9:
selectedAction = SIMDHWord;
break;
case SIMD_REG_DISP_DWORD_SIGNED:
case 4:
selectedAction = SIMDSDWord;
break;
case SIMD_REG_DISP_DWORD_UNSIGNED:
case 7:
selectedAction = SIMDUDWord;
break;
case SIMD_REG_DISP_DWORD_HEX:
case 10:
selectedAction = SIMDHDWord;
break;
case SIMD_REG_DISP_QWORD_SIGNED:
case 5:
selectedAction = SIMDSQWord;
break;
case SIMD_REG_DISP_QWORD_UNSIGNED:
case 8:
selectedAction = SIMDUQWord;
break;
case SIMD_REG_DISP_QWORD_HEX:
case 11:
selectedAction = SIMDHQWord;
break;
}
@ -3779,7 +3559,7 @@ void RegistersView::setRegisters(REGDUMP* reg)
void RegistersView::onSIMDMode()
{
wSIMDRegDispMode = (SIMD_REG_DISP_MODE)(dynamic_cast<QAction*>(sender())->data().toInt());
Config()->setUint("Gui", "SIMDRegistersDisplayMode", dynamic_cast<QAction*>(sender())->data().toInt());
emit refresh();
}

18
src/gui/Src/Gui/RegistersView.h
View File

@ -72,22 +72,6 @@ public:
UNKNOWN
};
enum SIMD_REG_DISP_MODE : int
{
SIMD_REG_DISP_HEX,
SIMD_REG_DISP_FLOAT,
SIMD_REG_DISP_DOUBLE,
SIMD_REG_DISP_WORD_SIGNED,
SIMD_REG_DISP_DWORD_SIGNED,
SIMD_REG_DISP_QWORD_SIGNED,
SIMD_REG_DISP_WORD_UNSIGNED,
SIMD_REG_DISP_DWORD_UNSIGNED,
SIMD_REG_DISP_QWORD_UNSIGNED,
SIMD_REG_DISP_WORD_HEX,
SIMD_REG_DISP_DWORD_HEX,
SIMD_REG_DISP_QWORD_HEX
};
// contains viewport position of register
struct Register_Position
{
@ -214,7 +198,6 @@ protected slots:
// switch SIMD display modes
void onSIMDMode();
void onFpuMode();
void onClose();
QString getRegisterLabel(REGISTER_NAME);
int CompareRegisters(const REGISTER_NAME reg_name, REGDUMP* regdump1, REGDUMP* regdump2);
SIZE_T GetSizeRegister(const REGISTER_NAME reg_name);
@ -283,7 +266,6 @@ private:
// font measures (TODO: create a class that calculates all thos values)
unsigned int mRowHeight, mCharWidth;
// SIMD registers display mode
SIMD_REG_DISP_MODE wSIMDRegDispMode;
char mFpuMode; //0 = order by ST(X), 1 = order by x87rX, 2 = MMX registers
// context menu actions
QMenu* mSwitchSIMDDispMode;

146
src/gui/Src/Utils/StringUtil.cpp
View File

@ -3,6 +3,7 @@
#include "StringUtil.h"
#include "MiscUtil.h"
#include "ldconvert.h"
#include "Configuration.h"
QString ToLongDoubleString(const void* buffer)
{
@ -40,6 +41,145 @@ QString EscapeCh(QChar ch)
}
}
QString fillValue(const char* value, int valsize, bool bFpuRegistersLittleEndian)
{
if(bFpuRegistersLittleEndian)
return QString(QByteArray(value, valsize).toHex()).toUpper();
else // Big Endian
return QString(ByteReverse(QByteArray(value, valsize)).toHex()).toUpper();
}
QString composeRegTextXMM(const char* value, int mode)
{
bool bFpuRegistersLittleEndian = ConfigBool("Gui", "FpuRegistersLittleEndian");
QString valueText;
switch(mode)
{
default:
case 0:
{
valueText = fillValue(value, 16, bFpuRegistersLittleEndian);
}
break;
case 2:
{
const double* dbl_values = reinterpret_cast<const double*>(value);
if(bFpuRegistersLittleEndian)
valueText = ToDoubleString(&dbl_values[0]) + ' ' + ToDoubleString(&dbl_values[1]);
else // Big Endian
valueText = ToDoubleString(&dbl_values[1]) + ' ' + ToDoubleString(&dbl_values[0]);
}
break;
case 1:
{
const float* flt_values = reinterpret_cast<const float*>(value);
if(bFpuRegistersLittleEndian)
valueText = ToFloatString(&flt_values[0]) + ' ' + ToFloatString(&flt_values[1]) + ' '
+ ToFloatString(&flt_values[2]) + ' ' + ToFloatString(&flt_values[3]);
else // Big Endian
valueText = ToFloatString(&flt_values[3]) + ' ' + ToFloatString(&flt_values[2]) + ' '
+ ToFloatString(&flt_values[1]) + ' ' + ToFloatString(&flt_values[0]);
}
break;
case 9:
{
if(bFpuRegistersLittleEndian)
valueText = fillValue(value) + ' ' + fillValue(value + 1 * 2) + ' ' + fillValue(value + 2 * 2) + ' ' + fillValue(value + 3 * 2)
+ ' ' + fillValue(value + 4 * 2) + ' ' + fillValue(value + 5 * 2) + ' ' + fillValue(value + 6 * 2) + ' ' + fillValue(value + 7 * 2);
else // Big Endian
valueText = fillValue(value + 7 * 2) + ' ' + fillValue(value + 6 * 2) + ' ' + fillValue(value + 5 * 2) + ' ' + fillValue(value + 4 * 2)
+ ' ' + fillValue(value + 3 * 2) + ' ' + fillValue(value + 2 * 2) + ' ' + fillValue(value + 1 * 2) + ' ' + fillValue(value);
}
break;
case 3:
{
const short* sword_values = reinterpret_cast<const short*>(value);
if(bFpuRegistersLittleEndian)
valueText = QString::number(sword_values[0]) + ' ' + QString::number(sword_values[1]) + ' ' + QString::number(sword_values[2]) + ' ' + QString::number(sword_values[3])
+ ' ' + QString::number(sword_values[4]) + ' ' + QString::number(sword_values[5]) + ' ' + QString::number(sword_values[6]) + ' ' + QString::number(sword_values[7]);
else // Big Endian
valueText = QString::number(sword_values[7]) + ' ' + QString::number(sword_values[6]) + ' ' + QString::number(sword_values[5]) + ' ' + QString::number(sword_values[4])
+ ' ' + QString::number(sword_values[3]) + ' ' + QString::number(sword_values[2]) + ' ' + QString::number(sword_values[1]) + ' ' + QString::number(sword_values[0]);
}
break;
case 6:
{
const unsigned short* uword_values = reinterpret_cast<const unsigned short*>(value);
if(bFpuRegistersLittleEndian)
valueText = QString::number(uword_values[0]) + ' ' + QString::number(uword_values[1]) + ' ' + QString::number(uword_values[2]) + ' ' + QString::number(uword_values[3])
+ ' ' + QString::number(uword_values[4]) + ' ' + QString::number(uword_values[5]) + ' ' + QString::number(uword_values[6]) + ' ' + QString::number(uword_values[7]);
else // Big Endian
valueText = QString::number(uword_values[7]) + ' ' + QString::number(uword_values[6]) + ' ' + QString::number(uword_values[5]) + ' ' + QString::number(uword_values[4])
+ ' ' + QString::number(uword_values[3]) + ' ' + QString::number(uword_values[2]) + ' ' + QString::number(uword_values[1]) + ' ' + QString::number(uword_values[0]);
}
break;
case 10:
{
if(bFpuRegistersLittleEndian)
valueText = fillValue(value, 4) + ' ' + fillValue(value + 1 * 4, 4) + ' ' + fillValue(value + 2 * 4, 4) + ' ' + fillValue(value + 3 * 4, 4);
else // Big Endian
valueText = fillValue(value + 3 * 4, 4) + ' ' + fillValue(value + 2 * 4, 4) + ' ' + fillValue(value + 1 * 4, 4) + ' ' + fillValue(value, 4);
}
break;
case 4:
{
const int* sdword_values = reinterpret_cast<const int*>(value);
if(bFpuRegistersLittleEndian)
valueText = QString::number(sdword_values[0]) + ' ' + QString::number(sdword_values[1]) + ' ' + QString::number(sdword_values[2]) + ' ' + QString::number(sdword_values[3]);
else // Big Endian
valueText = QString::number(sdword_values[3]) + ' ' + QString::number(sdword_values[2]) + ' ' + QString::number(sdword_values[1]) + ' ' + QString::number(sdword_values[0]);
}
break;
case 7:
{
const unsigned int* udword_values = reinterpret_cast<const unsigned int*>(value);
if(bFpuRegistersLittleEndian)
valueText = QString::number(udword_values[0]) + ' ' + QString::number(udword_values[1]) + ' ' + QString::number(udword_values[2]) + ' ' + QString::number(udword_values[3]);
else // Big Endian
valueText = QString::number(udword_values[3]) + ' ' + QString::number(udword_values[2]) + ' ' + QString::number(udword_values[1]) + ' ' + QString::number(udword_values[0]);
}
break;
case 11:
{
if(bFpuRegistersLittleEndian)
valueText = fillValue(value, 8) + ' ' + fillValue(value + 8, 8);
else // Big Endian
valueText = fillValue(value + 8, 8) + ' ' + fillValue(value, 8);
}
break;
case 5:
{
const long long* sqword_values = reinterpret_cast<const long long*>(value);
if(bFpuRegistersLittleEndian)
valueText = QString::number(sqword_values[0]) + ' ' + QString::number(sqword_values[1]);
else // Big Endian
valueText = QString::number(sqword_values[1]) + ' ' + QString::number(sqword_values[0]);
}
break;
case 8:
{
const unsigned long long* uqword_values = reinterpret_cast<const unsigned long long*>(value);
if(bFpuRegistersLittleEndian)
valueText = QString::number(uqword_values[0]) + ' ' + QString::number(uqword_values[1]);
else // Big Endian
valueText = QString::number(uqword_values[1]) + ' ' + QString::number(uqword_values[0]);
}
break;
}
return valueText;
}
QString composeRegTextYMM(const char* value, int mode)
{
bool bFpuRegistersLittleEndian = ConfigBool("Gui", "FpuRegistersLittleEndian");
if(ConfigUint("Gui", "SIMDRegistersDisplayMode") == 0)
return fillValue(value, 32, bFpuRegistersLittleEndian);
else if(bFpuRegistersLittleEndian)
return composeRegTextXMM(value, mode) + ' ' + composeRegTextXMM(value + 16, mode);
else
return composeRegTextXMM(value + 16, mode) + ' ' + composeRegTextXMM(value, mode);
}
QString GetDataTypeString(const void* buffer, duint size, ENCODETYPE type)
{
switch(type)
@ -59,9 +199,11 @@ QString GetDataTypeString(const void* buffer, duint size, ENCODETYPE type)
case enc_oword:
return QString(ByteReverse(QByteArray((const char*)buffer, 16)).toHex());
case enc_mmword:
case enc_xmmword:
case enc_ymmword:
return QString(QByteArray((const char*)buffer, size).toHex());
case enc_xmmword:
return composeRegTextXMM((const char*)buffer, ConfigUint("Gui", "SIMDRegistersDisplayMode"));
case enc_ymmword:
return composeRegTextYMM((const char*)buffer, ConfigUint("Gui", "SIMDRegistersDisplayMode"));
case enc_real4:
return ToFloatString(buffer);
case enc_real8:

4
src/gui/Src/Utils/StringUtil.h
View File

@ -100,6 +100,10 @@ QString ToLongDoubleString(const void* buffer);
QString ToDateString(const QDate & date);
QString fillValue(const char* value, int valsize = 2, bool bFpuRegistersLittleEndian = false);
QString composeRegTextXMM(const char* value, int mode);
QString composeRegTextYMM(const char* value, int mode);
QString GetDataTypeString(const void* buffer, duint size, ENCODETYPE type);
inline QDate GetCompileDate()