debuggercommon/registers/registercontroller_x86.cpp

0001 /*
0002     SPDX-FileCopyrightText: 2013 Vlas Puhov <vlas.puhov@mail.ru>
0003
0004     SPDX-License-Identifier: GPL-2.0-or-later
0005 */
0006
0007 #include "registercontroller_x86.h"
0008 #include "debuglog.h"
0009
0010 #include <KLocalizedString>
0011
0012 using namespace KDevMI;
0013
0014 QVector<QStringList> RegisterControllerGeneral_x86::m_registerNames;
0015 FlagRegister RegisterControllerGeneral_x86::m_eflags;
0016
0017 void RegisterControllerGeneral_x86::updateValuesForRegisters(RegistersGroup* registers) const
0018 {
0019     qCDebug(DEBUGGERCOMMON) << "Updating values for registers: " << registers->groupName.name();
0020     if (registers->groupName == enumToGroupName(Flags)) {
0021         updateFlagValues(registers, m_eflags);
0022     } else {
0023         IRegisterController::updateValuesForRegisters(registers);
0024     }
0025 }
0026
0027 RegistersGroup RegisterControllerGeneral_x86::registersFromGroup(const GroupsName& group) const
0028 {
0029     RegistersGroup registers;
0030
0031     registers.groupName = group;
0032     registers.format = m_formatsModes[group.index()].formats.first();
0033     const auto registerNames = registerNamesForGroup(group);
0034     registers.registers.reserve(registerNames.size());
0035     for (const auto& name : registerNames) {
0036         registers.registers.append(Register(name, QString()));
0037     }
0038
0039     updateValuesForRegisters(&registers);
0040
0041     return registers;
0042 }
0043
0044 QVector<GroupsName> RegisterControllerGeneral_x86::namesOfRegisterGroups() const
0045 {
0046     static const QVector<GroupsName> registerGroups =  QVector<GroupsName>{
0047         enumToGroupName(General),
0048         enumToGroupName(Flags),
0049         enumToGroupName(FPU),
0050         enumToGroupName(XMM),
0051         enumToGroupName(Segment),
0052     };
0053
0054     return registerGroups;
0055 }
0056
0057 void RegisterControllerGeneral_x86::setRegisterValueForGroup(const GroupsName& group, const Register& reg)
0058 {
0059     if (group == enumToGroupName(General)) {
0060         setGeneralRegister(reg, group);
0061     } else if (group == enumToGroupName(Flags)) {
0062         setFlagRegister(reg, m_eflags);
0063     } else if (group == enumToGroupName(FPU)) {
0064         setFPURegister(reg);
0065     } else if (group == enumToGroupName(XMM)) {
0066         setXMMRegister(reg);
0067     } else if (group == enumToGroupName(Segment)) {
0068         setSegmentRegister(reg);
0069     }
0070 }
0071
0072 void RegisterControllerGeneral_x86::setFPURegister(const Register& reg)
0073 {
0074     setGeneralRegister(reg, enumToGroupName(FPU));
0075 }
0076
0077 void RegisterControllerGeneral_x86::setXMMRegister(const Register& reg)
0078 {
0079     setStructuredRegister(reg, enumToGroupName(XMM));
0080 }
0081
0082 void RegisterControllerGeneral_x86::setSegmentRegister(const Register& reg)
0083 {
0084     setGeneralRegister(reg, enumToGroupName(Segment));
0085 }
0086
0087 void RegisterControllerGeneral_x86::updateRegisters(const GroupsName& group)
0088 {
0089     if (!m_registerNamesInitialized) {
0090         if (initializeRegisters()) {
0091             m_registerNamesInitialized = true;
0092         }
0093     }
0094
0095     IRegisterController::updateRegisters(group);
0096 }
0097
0098 GroupsName RegisterControllerGeneral_x86::enumToGroupName(X86RegisterGroups group) const
0099 {
0100     static const GroupsName groups[LAST_REGISTER] = { createGroupName(i18n("General"), General), createGroupName(i18n("Flags"), Flags, flag, m_eflags.registerName), createGroupName(i18n("FPU"), FPU, floatPoint), createGroupName(i18n("XMM"), XMM, structured), createGroupName(i18n("Segment"), Segment)};
0101
0102     return groups[group];
0103 }
0104
0105 RegisterController_x86::RegisterController_x86(MIDebugSession* debugSession, QObject* parent)
0106     : RegisterControllerGeneral_x86(debugSession, parent)
0107 {
0108     initRegisterNames();
0109 }
0110
0111 RegisterController_x86_64::RegisterController_x86_64(MIDebugSession* debugSession, QObject* parent)
0112     : RegisterControllerGeneral_x86(debugSession, parent)
0113 {
0114     initRegisterNames();
0115 }
0116
0117 RegisterControllerGeneral_x86::RegisterControllerGeneral_x86(MIDebugSession* debugSession, QObject* parent)
0118     : IRegisterController(debugSession, parent)
0119 {
0120     if (m_registerNames.isEmpty()) {
0121         const int registerCount = static_cast<int>(LAST_REGISTER);
0122         m_registerNames.resize(registerCount);
0123         initRegisterNames();
0124     }
0125
0126     m_formatsModes.resize(namesOfRegisterGroups().size());
0127
0128     m_formatsModes[XMM].formats = {Binary, Decimal, Hexadecimal, Octal, Unsigned};
0129     m_formatsModes[XMM].modes = {v4_float, v2_double, v4_int32, v2_int64};
0130
0131     m_formatsModes[Flags].formats.append(Raw);
0132     m_formatsModes[Flags].modes.append(natural);
0133
0134     m_formatsModes[FPU].formats.append(Decimal);
0135     m_formatsModes[FPU].modes.append(natural);
0136
0137     m_formatsModes[General].modes.append(natural);
0138     m_formatsModes[General].formats.append(Raw);
0139     m_formatsModes[General].formats << m_formatsModes[XMM].formats;
0140
0141     m_formatsModes[Segment] = m_formatsModes[General];
0142 }
0143
0144 void RegisterControllerGeneral_x86::initRegisterNames()
0145 {
0146     for (int i = 0; i < 8; i++) {
0147         m_registerNames[FPU] << (QLatin1String("st") + QString::number(i));
0148     }
0149
0150     m_registerNames[Flags] = QStringList{
0151         QStringLiteral("C"),
0152         QStringLiteral("P"),
0153         QStringLiteral("A"),
0154         QStringLiteral("Z"),
0155         QStringLiteral("S"),
0156         QStringLiteral("T"),
0157         QStringLiteral("D"),
0158         QStringLiteral("O")
0159     };
0160
0161     m_registerNames[Segment] = QStringList{
0162         QStringLiteral("cs"),
0163         QStringLiteral("ss"),
0164         QStringLiteral("ds"),
0165         QStringLiteral("es"),
0166         QStringLiteral("fs"),
0167         QStringLiteral("gs"),
0168     };
0169
0170     m_eflags.flags = m_registerNames[Flags];
0171     m_eflags.bits = QStringList{
0172         QStringLiteral("0"),
0173         QStringLiteral("2"),
0174         QStringLiteral("4"),
0175         QStringLiteral("6"),
0176         QStringLiteral("7"),
0177         QStringLiteral("8"),
0178         QStringLiteral("10"),
0179         QStringLiteral("11"),
0180     };
0181     m_eflags.registerName = QStringLiteral("eflags");
0182     m_eflags.groupName = enumToGroupName(Flags);
0183 }
0184
0185 void RegisterController_x86::initRegisterNames()
0186 {
0187     m_registerNames[General] = QStringList{
0188         QStringLiteral("eax"),
0189         QStringLiteral("ebx"),
0190         QStringLiteral("ecx"),
0191         QStringLiteral("edx"),
0192         QStringLiteral("esi"),
0193         QStringLiteral("edi"),
0194         QStringLiteral("ebp"),
0195         QStringLiteral("esp"),
0196         QStringLiteral("eip")
0197     };
0198
0199     m_registerNames[XMM].clear();
0200     for (int i = 0; i < 8; i++) {
0201         m_registerNames[XMM] << (QLatin1String("xmm") + QString::number(i));
0202     }
0203 }
0204
0205 void RegisterController_x86_64::initRegisterNames()
0206 {
0207     m_registerNames[General] = QStringList{
0208         QStringLiteral("rax"),
0209         QStringLiteral("rbx"),
0210         QStringLiteral("rcx"),
0211         QStringLiteral("rdx"),
0212         QStringLiteral("rsi"),
0213         QStringLiteral("rdi"),
0214         QStringLiteral("rbp"),
0215         QStringLiteral("rsp"),
0216         QStringLiteral("r8"),
0217         QStringLiteral("r9"),
0218         QStringLiteral("r10"),
0219         QStringLiteral("r11"),
0220         QStringLiteral("r12"),
0221         QStringLiteral("r13"),
0222         QStringLiteral("r14"),
0223         QStringLiteral("r15"),
0224         QStringLiteral("rip")
0225     };
0226
0227     m_registerNames[XMM].clear();
0228     for (int i = 0; i < 16; i++) {
0229         m_registerNames[XMM] << (QLatin1String("xmm") + QString::number(i));
0230     }
0231 }
0232
0233 QStringList RegisterControllerGeneral_x86::registerNamesForGroup(const GroupsName& group) const
0234 {
0235     for (int i = 0; i < static_cast<int>(LAST_REGISTER); i++) {
0236         if (group == enumToGroupName(static_cast<X86RegisterGroups>(i))) {
0237             return m_registerNames[i];
0238         }
0239     }
0240
0241     return QStringList();
0242 }
0243
0244 #include "moc_registercontroller_x86.cpp"