Index: lldb/include/lldb/lldb-private-types.h =================================================================== --- lldb/include/lldb/lldb-private-types.h +++ lldb/include/lldb/lldb-private-types.h @@ -52,7 +52,8 @@ /// not null, all registers in this list will be read first, at which point /// the value for this register will be valid. For example, the value list /// for ah would be eax (x86) or rax (x64). Register numbers are - /// of eRegisterKindProcessPlugin. + /// of eRegisterKindProcessPlugin. If multiple registers are listed, the final + /// value will be the concatenation of them. uint32_t *value_regs; /// List of registers (terminated with LLDB_INVALID_REGNUM). If this value is /// not null, all registers in this list will be invalidated when the value of Index: lldb/source/Plugins/Process/Utility/DynamicRegisterInfo.cpp =================================================================== --- lldb/source/Plugins/Process/Utility/DynamicRegisterInfo.cpp +++ lldb/source/Plugins/Process/Utility/DynamicRegisterInfo.cpp @@ -442,19 +442,10 @@ m_sets[set].registers = m_set_reg_nums[set].data(); } - // sort and unique all value registers and make sure each is terminated with - // LLDB_INVALID_REGNUM - + // Make sure all value elements are terminated with LLDB_INVALID_REGNUM for (reg_to_regs_map::iterator pos = m_value_regs_map.begin(), end = m_value_regs_map.end(); pos != end; ++pos) { - if (pos->second.size() > 1) { - llvm::sort(pos->second.begin(), pos->second.end()); - reg_num_collection::iterator unique_end = - std::unique(pos->second.begin(), pos->second.end()); - if (unique_end != pos->second.end()) - pos->second.erase(unique_end, pos->second.end()); - } assert(!pos->second.empty()); if (pos->second.back() != LLDB_INVALID_REGNUM) pos->second.push_back(LLDB_INVALID_REGNUM); @@ -657,12 +648,14 @@ // Now update all value_regs with each register info as needed for (auto ® : m_regs) { if (reg.value_regs != nullptr) { - // Assign a valid offset to all pseudo registers if not assigned by stub. - // Pseudo registers with value_regs list populated will share same offset - // as that of their corresponding primary register in value_regs list. + // Assign a valid offset to all pseudo registers that have only a single + // parent register in value_regs list, if not assigned by stub. Pseudo + // registers with value_regs list populated will share same offset as + // that of their corresponding parent register. if (reg.byte_offset == LLDB_INVALID_INDEX32) { uint32_t value_regnum = reg.value_regs[0]; - if (value_regnum != LLDB_INVALID_INDEX32) + if (value_regnum != LLDB_INVALID_INDEX32 && + reg.value_regs[1] == LLDB_INVALID_INDEX32) reg.byte_offset = GetRegisterInfoAtIndex(remote_to_local_regnum_map[value_regnum]) ->byte_offset; Index: lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp =================================================================== --- lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp +++ lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp @@ -94,10 +94,34 @@ const uint32_t reg = reg_info->kinds[eRegisterKindLLDB]; if (m_reg_valid[reg] == false) return false; - const bool partial_data_ok = false; - Status error(value.SetValueFromData( - reg_info, m_reg_data, reg_info->byte_offset, partial_data_ok)); - return error.Success(); + if (reg_info->value_regs && + reg_info->value_regs[0] != LLDB_INVALID_REGNUM && + reg_info->value_regs[1] != LLDB_INVALID_REGNUM) { + std::vector combined_data; + uint32_t offset = 0; + for (int i = 0; reg_info->value_regs[i] != LLDB_INVALID_REGNUM; i++) { + const RegisterInfo *parent_reg = GetRegisterInfo( + eRegisterKindProcessPlugin, reg_info->value_regs[i]); + if (!parent_reg) + return false; + combined_data.resize(offset + parent_reg->byte_size); + if (m_reg_data.CopyData(parent_reg->byte_offset, parent_reg->byte_size, + combined_data.data() + offset) != + parent_reg->byte_size) + return false; + offset += parent_reg->byte_size; + } + + Status error; + return value.SetFromMemoryData( + reg_info, combined_data.data(), combined_data.size(), + m_reg_data.GetByteOrder(), error) == combined_data.size(); + } else { + const bool partial_data_ok = false; + Status error(value.SetValueFromData( + reg_info, m_reg_data, reg_info->byte_offset, partial_data_ok)); + return error.Success(); + } } return false; } @@ -284,8 +308,38 @@ bool GDBRemoteRegisterContext::WriteRegister(const RegisterInfo *reg_info, const RegisterValue &value) { DataExtractor data; - if (value.GetData(data)) - return WriteRegisterBytes(reg_info, data, 0); + if (value.GetData(data)) { + if (reg_info->value_regs && + reg_info->value_regs[0] != LLDB_INVALID_REGNUM && + reg_info->value_regs[1] != LLDB_INVALID_REGNUM) { + uint32_t combined_size = 0; + for (int i = 0; reg_info->value_regs[i] != LLDB_INVALID_REGNUM; i++) { + const RegisterInfo *parent_reg = GetRegisterInfo( + eRegisterKindProcessPlugin, reg_info->value_regs[i]); + if (!parent_reg) + return false; + combined_size += parent_reg->byte_size; + } + + if (data.GetByteSize() < combined_size) + return false; + + uint32_t offset = 0; + for (int i = 0; reg_info->value_regs[i] != LLDB_INVALID_REGNUM; i++) { + const RegisterInfo *parent_reg = GetRegisterInfo( + eRegisterKindProcessPlugin, reg_info->value_regs[i]); + assert(parent_reg); + + DataExtractor parent_data{data, offset, parent_reg->byte_size}; + if (!WriteRegisterBytes(parent_reg, parent_data, 0)) + return false; + offset += parent_reg->byte_size; + } + assert(offset == combined_size); + return true; + } else + return WriteRegisterBytes(reg_info, data, 0); + } return false; } Index: lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext_x86_64.cpp =================================================================== --- lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext_x86_64.cpp +++ lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext_x86_64.cpp @@ -74,6 +74,34 @@ {"st7", "mm7"}, }}; +struct YMMReg { + const char *name; + const char *xmmreg; + const char *ymmhreg; + + // extra storage used for pointers + uint32_t value_regs[3]; +}; + +static std::array ymm_regs = {{ + {"ymm0", "xmm0", "ymm0h"}, + {"ymm1", "xmm1", "ymm1h"}, + {"ymm2", "xmm2", "ymm2h"}, + {"ymm3", "xmm3", "ymm3h"}, + {"ymm4", "xmm4", "ymm4h"}, + {"ymm5", "xmm5", "ymm5h"}, + {"ymm6", "xmm6", "ymm6h"}, + {"ymm7", "xmm7", "ymm7h"}, + {"ymm8", "xmm8", "ymm8h"}, + {"ymm9", "xmm9", "ymm9h"}, + {"ymm10", "xmm10", "ymm10h"}, + {"ymm11", "xmm11", "ymm11h"}, + {"ymm12", "xmm12", "ymm12h"}, + {"ymm13", "xmm13", "ymm13h"}, + {"ymm14", "xmm14", "ymm14h"}, + {"ymm15", "xmm15", "ymm15h"}, +}}; + void GDBRemoteDynamicRegisterInfo::PreFinalize_x86_64() { uint32_t max_regnum = 0; uint32_t next_regindex = m_regs.size(); @@ -163,6 +191,37 @@ name.SetCString(new_reg.name); AddRegister(new_reg, name, alt_name, group); } + + for (YMMReg &ymmreg : ymm_regs) { + const RegisterInfo *xmmreg = GetRegisterInfo(ymmreg.xmmreg); + const RegisterInfo *ymmhreg = GetRegisterInfo(ymmreg.ymmhreg); + if (!xmmreg || !ymmhreg) + continue; + assert(xmmreg->byte_size == 16); + assert(ymmhreg->byte_size == 16); + + if (GetRegisterInfo(ymmreg.name)) + continue; + + ymmreg.value_regs[0] = xmmreg->kinds[eRegisterKindProcessPlugin]; + ymmreg.value_regs[1] = ymmhreg->kinds[eRegisterKindProcessPlugin]; + ymmreg.value_regs[2] = LLDB_INVALID_REGNUM; + + struct RegisterInfo new_reg { + ymmreg.name, nullptr, 32, LLDB_INVALID_INDEX32, eEncodingVector, + eFormatVectorOfUInt8, + { + LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, + ++max_regnum, next_regindex++, + }, + ymmreg.value_regs, nullptr, nullptr, 0 + }; + + ConstString name; + ConstString alt_name; + name.SetCString(new_reg.name); + AddRegister(new_reg, name, alt_name, group); + } } void GDBRemoteDynamicRegisterInfo::PostFinalize_x86_64() { Index: lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp =================================================================== --- lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp +++ lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp @@ -4529,7 +4529,9 @@ reg_info.format = eFormatFloat; reg_info.encoding = eEncodingIEEE754; } else if (llvm::StringRef(gdb_type).startswith("vec") || - gdb_type == "i387_ext") { + gdb_type == "i387_ext" || gdb_type == "uint128") { + // lldb doesn't handle 128-bit uints correctly (for ymm*h), so treat + // them as vector (similarly to xmm/ymm) reg_info.format = eFormatVectorOfUInt8; reg_info.encoding = eEncodingVector; } Index: lldb/test/API/functionalities/gdb_remote_client/TestGDBServerTargetXML.py =================================================================== --- lldb/test/API/functionalities/gdb_remote_client/TestGDBServerTargetXML.py +++ lldb/test/API/functionalities/gdb_remote_client/TestGDBServerTargetXML.py @@ -33,6 +33,11 @@ "a1a2a3a4a5a6a7a8a9aaabacadaeafb0", # xmm2..xmm15 ] + [ "00000000", # mxcsr + ] + [ + "b1b2b3b4b5b6b7b8b9babbbcbdbebfc0", # ymm0h + "c1c2c3c4c5c6c7c8c9cacbcccdcecfd0", # ymm1h + ] + 14 * [ + "d1d2d3d4d5d6d7d8d9dadbdcdddedfe0", # ymm2h..ymm15h ] class MyResponder(MockGDBServerResponder): @@ -82,6 +87,24 @@ + + + + + + + + + + + + + + + + + + """, False else: return None, False @@ -163,6 +186,22 @@ ["xmm1 = {0x91 0x92 0x93 0x94 0x95 0x96 0x97 0x98 " "0x99 0x9a 0x9b 0x9c 0x9d 0x9e 0x9f 0xa0}"]) + # test recombining ymmX + self.match("register read ymm0h", + ["ymm0h = {0xb1 0xb2 0xb3 0xb4 0xb5 0xb6 0xb7 0xb8 " + "0xb9 0xba 0xbb 0xbc 0xbd 0xbe 0xbf 0xc0}"]) + self.match("register read ymm0", + ["ymm0 = {0x81 0x82 0x83 0x84 0x85 0x86 0x87 0x88 0x89 0x8a " + "0x8b 0x8c 0x8d 0x8e 0x8f 0x90 0xb1 0xb2 0xb3 0xb4 0xb5 " + "0xb6 0xb7 0xb8 0xb9 0xba 0xbb 0xbc 0xbd 0xbe 0xbf 0xc0}"]) + self.match("register read ymm1h", + ["ymm1h = {0xc1 0xc2 0xc3 0xc4 0xc5 0xc6 0xc7 0xc8 " + "0xc9 0xca 0xcb 0xcc 0xcd 0xce 0xcf 0xd0}"]) + self.match("register read ymm1", + ["ymm1 = {0x91 0x92 0x93 0x94 0x95 0x96 0x97 0x98 0x99 0x9a " + "0x9b 0x9c 0x9d 0x9e 0x9f 0xa0 0xc1 0xc2 0xc3 0xc4 0xc5 " + "0xc6 0xc7 0xc8 0xc9 0xca 0xcb 0xcc 0xcd 0xce 0xcf 0xd0}"]) + # test writing into pseudo-registers self.runCmd("register write ecx 0xfffefdfc") reg_data[0] = "fcfdfeff05060708" @@ -203,3 +242,33 @@ self.assertPacketLogContains(["G" + "".join(reg_data)]) self.match("register read st0", ["st0 = {0xf8 0xf9 0xfa 0xfb 0xfc 0xfd 0xfe 0xff 0x09 0x0a}"]) + + self.runCmd("register write xmm0 \"{0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 " + "0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1 0xf0}\"") + reg_data[18] = "fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0" + self.assertPacketLogContains(["G" + "".join(reg_data)]) + self.match("register read ymm0", + ["ymm0 = {0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 " + "0xf5 0xf4 0xf3 0xf2 0xf1 0xf0 0xb1 0xb2 0xb3 0xb4 0xb5 " + "0xb6 0xb7 0xb8 0xb9 0xba 0xbb 0xbc 0xbd 0xbe 0xbf 0xc0}"]) + + self.runCmd("register write ymm0h \"{0xef 0xee 0xed 0xec 0xeb 0xea 0xe9 " + "0xe8 0xe7 0xe6 0xe5 0xe4 0xe3 0xe2 0xe1 0xe0}\"") + reg_data[35] = "efeeedecebeae9e8e7e6e5e4e3e2e1e0" + self.assertPacketLogContains(["G" + "".join(reg_data)]) + self.match("register read ymm0", + ["ymm0 = {0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 " + "0xf5 0xf4 0xf3 0xf2 0xf1 0xf0 0xef 0xee 0xed 0xec 0xeb " + "0xea 0xe9 0xe8 0xe7 0xe6 0xe5 0xe4 0xe3 0xe2 0xe1 0xe0}"]) + + self.runCmd("register write ymm0 \"{0xd0 0xd1 0xd2 0xd3 0xd4 0xd5 0xd6 " + "0xd7 0xd8 0xd9 0xda 0xdb 0xdc 0xdd 0xde 0xdf 0xe0 0xe1 " + "0xe2 0xe3 0xe4 0xe5 0xe6 0xe7 0xe8 0xe9 0xea 0xeb 0xec " + "0xed 0xee 0xef}\"") + reg_data[18] = "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf" + reg_data[35] = "e0e1e2e3e4e5e6e7e8e9eaebecedeeef" + self.assertPacketLogContains(["G" + "".join(reg_data)]) + self.match("register read ymm0", + ["ymm0 = {0xd0 0xd1 0xd2 0xd3 0xd4 0xd5 0xd6 0xd7 0xd8 0xd9 " + "0xda 0xdb 0xdc 0xdd 0xde 0xdf 0xe0 0xe1 0xe2 0xe3 0xe4 " + "0xe5 0xe6 0xe7 0xe8 0xe9 0xea 0xeb 0xec 0xed 0xee 0xef}"])