Index: source/Plugins/Process/Utility/DynamicRegisterInfo.h =================================================================== --- source/Plugins/Process/Utility/DynamicRegisterInfo.h +++ source/Plugins/Process/Utility/DynamicRegisterInfo.h @@ -23,13 +23,25 @@ class DynamicRegisterInfo { public: - DynamicRegisterInfo(); + DynamicRegisterInfo() = default; DynamicRegisterInfo(const lldb_private::StructuredData::Dictionary &dict, const lldb_private::ArchSpec &arch); - virtual ~DynamicRegisterInfo(); + virtual ~DynamicRegisterInfo() = default; + DynamicRegisterInfo(DynamicRegisterInfo &) = delete; + void operator=(DynamicRegisterInfo &) = delete; + + DynamicRegisterInfo(DynamicRegisterInfo &&info) + : m_data(std::move(info.m_data)) { UpdatePointers(); } + + DynamicRegisterInfo &operator=(DynamicRegisterInfo &&info) { + m_data = std::move(info.m_data); + UpdatePointers(); + return *this; + } + size_t SetRegisterInfo(const lldb_private::StructuredData::Dictionary &dict, const lldb_private::ArchSpec &arch); @@ -75,19 +87,26 @@ typedef std::vector dwarf_opcode; typedef std::map dynamic_reg_size_map; - lldb_private::RegisterInfo * - GetRegisterInfo(const lldb_private::ConstString ®_name); + const lldb_private::RegisterInfo * + GetRegisterInfo(const lldb_private::ConstString ®_name) const; - reg_collection m_regs; - set_collection m_sets; - set_reg_num_collection m_set_reg_nums; - name_collection m_set_names; - reg_to_regs_map m_value_regs_map; - reg_to_regs_map m_invalidate_regs_map; - dynamic_reg_size_map m_dynamic_reg_size_map; - size_t m_reg_data_byte_size; // The number of bytes required to store all - // registers - bool m_finalized; + void UpdatePointers() { + const size_t num_sets = m_data.sets.size(); + for (size_t set = 0; set < num_sets; ++set) + m_data.sets[set].registers = m_data.set_reg_nums[set].data(); + } + + struct Data { + reg_collection regs; + set_collection sets; + set_reg_num_collection set_reg_nums; + name_collection set_names; + reg_to_regs_map value_regs_map; + reg_to_regs_map invalidate_regs_map; + dynamic_reg_size_map dynamic_reg_size_map; + size_t reg_data_byte_size = 0u; // The number of bytes required to store + // all registers + bool finalized = false; + } m_data; }; - #endif // lldb_DynamicRegisterInfo_h_ Index: source/Plugins/Process/Utility/DynamicRegisterInfo.cpp =================================================================== --- source/Plugins/Process/Utility/DynamicRegisterInfo.cpp +++ source/Plugins/Process/Utility/DynamicRegisterInfo.cpp @@ -21,40 +21,31 @@ using namespace lldb; using namespace lldb_private; -DynamicRegisterInfo::DynamicRegisterInfo() - : m_regs(), m_sets(), m_set_reg_nums(), m_set_names(), m_value_regs_map(), - m_invalidate_regs_map(), m_dynamic_reg_size_map(), - m_reg_data_byte_size(0), m_finalized(false) {} - DynamicRegisterInfo::DynamicRegisterInfo( const lldb_private::StructuredData::Dictionary &dict, const lldb_private::ArchSpec &arch) - : m_regs(), m_sets(), m_set_reg_nums(), m_set_names(), m_value_regs_map(), - m_invalidate_regs_map(), m_dynamic_reg_size_map(), - m_reg_data_byte_size(0), m_finalized(false) { + : DynamicRegisterInfo() { SetRegisterInfo(dict, arch); } -DynamicRegisterInfo::~DynamicRegisterInfo() {} - size_t DynamicRegisterInfo::SetRegisterInfo(const StructuredData::Dictionary &dict, const ArchSpec &arch) { - assert(!m_finalized); + assert(!m_data.finalized); StructuredData::Array *sets = nullptr; if (dict.GetValueForKeyAsArray("sets", sets)) { const uint32_t num_sets = sets->GetSize(); for (uint32_t i = 0; i < num_sets; ++i) { ConstString set_name; if (sets->GetItemAtIndexAsString(i, set_name) && !set_name.IsEmpty()) { - m_sets.push_back({ set_name.AsCString(), NULL, 0, NULL }); + m_data.sets.push_back({ set_name.AsCString(), NULL, 0, NULL }); } else { Clear(); printf("error: register sets must have valid names\n"); return 0; } } - m_set_reg_nums.resize(m_sets.size()); + m_data.set_reg_nums.resize(m_data.sets.size()); } StructuredData::Array *regs = nullptr; @@ -136,17 +127,17 @@ ConstString containing_reg_name(reg_name_str); - RegisterInfo *containing_reg_info = + const RegisterInfo *containing_reg_info = GetRegisterInfo(containing_reg_name); if (containing_reg_info) { const uint32_t max_bit = containing_reg_info->byte_size * 8; if (msbit < max_bit && lsbit < max_bit) { - m_invalidate_regs_map[containing_reg_info + m_data.invalidate_regs_map[containing_reg_info ->kinds[eRegisterKindLLDB]] .push_back(i); - m_value_regs_map[i].push_back( + m_data.value_regs_map[i].push_back( containing_reg_info->kinds[eRegisterKindLLDB]); - m_invalidate_regs_map[i].push_back( + m_data.invalidate_regs_map[i].push_back( containing_reg_info->kinds[eRegisterKindLLDB]); if (byte_order == eByteOrderLittle) { @@ -205,17 +196,17 @@ ConstString composite_reg_name; if (composite_reg_list->GetItemAtIndexAsString( composite_idx, composite_reg_name, nullptr)) { - RegisterInfo *composite_reg_info = + const RegisterInfo *composite_reg_info = GetRegisterInfo(composite_reg_name); if (composite_reg_info) { composite_offset = std::min(composite_offset, composite_reg_info->byte_offset); - m_value_regs_map[i].push_back( + m_data.value_regs_map[i].push_back( composite_reg_info->kinds[eRegisterKindLLDB]); - m_invalidate_regs_map[composite_reg_info + m_data.invalidate_regs_map[composite_reg_info ->kinds[eRegisterKindLLDB]] .push_back(i); - m_invalidate_regs_map[i].push_back( + m_data.invalidate_regs_map[i].push_back( composite_reg_info->kinds[eRegisterKindLLDB]); } else { // TODO: print error invalid slice string that doesn't follow @@ -231,7 +222,7 @@ } if (composite_offset != UINT32_MAX) { reg_info.byte_offset = composite_offset; - success = m_value_regs_map.find(i) != m_value_regs_map.end(); + success = m_data.value_regs_map.find(i) != m_data.value_regs_map.end(); } else { printf("error: 'composite' registers must specify at least one " "real register\n"); @@ -274,9 +265,9 @@ assert(ret_val == reg_info.dynamic_size_dwarf_len); for (j = 0; j < reg_info.dynamic_size_dwarf_len; ++j) - m_dynamic_reg_size_map[i].push_back(dwarf_opcode_bytes[j]); + m_data.dynamic_reg_size_map[i].push_back(dwarf_opcode_bytes[j]); - reg_info.dynamic_size_dwarf_expr_bytes = m_dynamic_reg_size_map[i].data(); + reg_info.dynamic_size_dwarf_expr_bytes = m_data.dynamic_reg_size_map[i].data(); } llvm::StringRef format_str; @@ -303,7 +294,7 @@ size_t set = 0; if (!reg_info_dict->GetValueForKeyAsInteger("set", set, -1) || - set >= m_sets.size()) { + set >= m_data.sets.size()) { Clear(); printf("error: invalid 'set' value in register dictionary, valid values " "are 0 - %i\n", @@ -345,10 +336,10 @@ uint64_t invalidate_reg_num; if (invalidate_reg_list->GetItemAtIndexAsString( idx, invalidate_reg_name)) { - RegisterInfo *invalidate_reg_info = + const RegisterInfo *invalidate_reg_info = GetRegisterInfo(invalidate_reg_name); if (invalidate_reg_info) { - m_invalidate_regs_map[i].push_back( + m_data.invalidate_regs_map[i].push_back( invalidate_reg_info->kinds[eRegisterKindLLDB]); } else { // TODO: print error invalid slice string that doesn't follow the @@ -360,7 +351,7 @@ } else if (invalidate_reg_list->GetItemAtIndexAsInteger( idx, invalidate_reg_num)) { if (invalidate_reg_num != UINT64_MAX) - m_invalidate_regs_map[i].push_back(invalidate_reg_num); + m_data.invalidate_regs_map[i].push_back(invalidate_reg_num); else printf("error: 'invalidate-regs' list value wasn't a valid " "integer\n"); @@ -376,71 +367,71 @@ // Calculate the register offset const size_t end_reg_offset = reg_info.byte_offset + reg_info.byte_size; - if (m_reg_data_byte_size < end_reg_offset) - m_reg_data_byte_size = end_reg_offset; + if (m_data.reg_data_byte_size < end_reg_offset) + m_data.reg_data_byte_size = end_reg_offset; - m_regs.push_back(reg_info); - m_set_reg_nums[set].push_back(i); + m_data.regs.push_back(reg_info); + m_data.set_reg_nums[set].push_back(i); } Finalize(arch); - return m_regs.size(); + return m_data.regs.size(); } void DynamicRegisterInfo::AddRegister(RegisterInfo ®_info, ConstString ®_name, ConstString ®_alt_name, ConstString &set_name) { - assert(!m_finalized); - const uint32_t reg_num = m_regs.size(); + assert(!m_data.finalized); + const uint32_t reg_num = m_data.regs.size(); reg_info.name = reg_name.AsCString(); assert(reg_info.name); reg_info.alt_name = reg_alt_name.AsCString(NULL); uint32_t i; if (reg_info.value_regs) { for (i = 0; reg_info.value_regs[i] != LLDB_INVALID_REGNUM; ++i) - m_value_regs_map[reg_num].push_back(reg_info.value_regs[i]); + m_data.value_regs_map[reg_num].push_back(reg_info.value_regs[i]); } if (reg_info.invalidate_regs) { for (i = 0; reg_info.invalidate_regs[i] != LLDB_INVALID_REGNUM; ++i) - m_invalidate_regs_map[reg_num].push_back(reg_info.invalidate_regs[i]); + m_data.invalidate_regs_map[reg_num].push_back(reg_info.invalidate_regs[i]); } if (reg_info.dynamic_size_dwarf_expr_bytes) { for (i = 0; i < reg_info.dynamic_size_dwarf_len; ++i) - m_dynamic_reg_size_map[reg_num].push_back( + m_data.dynamic_reg_size_map[reg_num].push_back( reg_info.dynamic_size_dwarf_expr_bytes[i]); reg_info.dynamic_size_dwarf_expr_bytes = - m_dynamic_reg_size_map[reg_num].data(); + m_data.dynamic_reg_size_map[reg_num].data(); } - m_regs.push_back(reg_info); + m_data.regs.push_back(reg_info); uint32_t set = GetRegisterSetIndexByName(set_name, true); - assert(set < m_sets.size()); - assert(set < m_set_reg_nums.size()); - assert(set < m_set_names.size()); - m_set_reg_nums[set].push_back(reg_num); + assert(set < m_data.sets.size()); + assert(set < m_data.set_reg_nums.size()); + assert(set < m_data.set_names.size()); + m_data.set_reg_nums[set].push_back(reg_num); size_t end_reg_offset = reg_info.byte_offset + reg_info.byte_size; - if (m_reg_data_byte_size < end_reg_offset) - m_reg_data_byte_size = end_reg_offset; + if (m_data.reg_data_byte_size < end_reg_offset) + m_data.reg_data_byte_size = end_reg_offset; } void DynamicRegisterInfo::Finalize(const ArchSpec &arch) { - if (m_finalized) + if (m_data.finalized) return; - m_finalized = true; - const size_t num_sets = m_sets.size(); + m_data.finalized = true; + const size_t num_sets = m_data.sets.size(); for (size_t set = 0; set < num_sets; ++set) { - assert(m_sets.size() == m_set_reg_nums.size()); - m_sets[set].num_registers = m_set_reg_nums[set].size(); - m_sets[set].registers = m_set_reg_nums[set].data(); + assert(m_data.sets.size() == m_data.set_reg_nums.size()); + m_data.sets[set].num_registers = m_data.set_reg_nums[set].size(); + m_data.sets[set].registers = m_data.set_reg_nums[set].data(); } // sort and unique all value registers and make sure each is terminated with // LLDB_INVALID_REGNUM - for (reg_to_regs_map::iterator pos = m_value_regs_map.begin(), - end = m_value_regs_map.end(); + for (reg_to_regs_map::iterator pos = m_data.value_regs_map.begin(), + end = m_data.value_regs_map.end(); pos != end; ++pos) { if (pos->second.size() > 1) { std::sort(pos->second.begin(), pos->second.end()); @@ -455,26 +446,26 @@ } // Now update all value_regs with each register info as needed - const size_t num_regs = m_regs.size(); + const size_t num_regs = m_data.regs.size(); for (size_t i = 0; i < num_regs; ++i) { - if (m_value_regs_map.find(i) != m_value_regs_map.end()) - m_regs[i].value_regs = m_value_regs_map[i].data(); + if (m_data.value_regs_map.find(i) != m_data.value_regs_map.end()) + m_data.regs[i].value_regs = m_data.value_regs_map[i].data(); else - m_regs[i].value_regs = NULL; + m_data.regs[i].value_regs = NULL; } // Expand all invalidation dependencies - for (reg_to_regs_map::iterator pos = m_invalidate_regs_map.begin(), - end = m_invalidate_regs_map.end(); + for (reg_to_regs_map::iterator pos = m_data.invalidate_regs_map.begin(), + end = m_data.invalidate_regs_map.end(); pos != end; ++pos) { const uint32_t reg_num = pos->first; - if (m_regs[reg_num].value_regs) { + if (m_data.regs[reg_num].value_regs) { reg_num_collection extra_invalid_regs; for (const uint32_t invalidate_reg_num : pos->second) { reg_to_regs_map::iterator invalidate_pos = - m_invalidate_regs_map.find(invalidate_reg_num); - if (invalidate_pos != m_invalidate_regs_map.end()) { + m_data.invalidate_regs_map.find(invalidate_reg_num); + if (invalidate_pos != m_data.invalidate_regs_map.end()) { for (const uint32_t concrete_invalidate_reg_num : invalidate_pos->second) { if (concrete_invalidate_reg_num != reg_num) @@ -489,8 +480,8 @@ // sort and unique all invalidate registers and make sure each is terminated // with LLDB_INVALID_REGNUM - for (reg_to_regs_map::iterator pos = m_invalidate_regs_map.begin(), - end = m_invalidate_regs_map.end(); + for (reg_to_regs_map::iterator pos = m_data.invalidate_regs_map.begin(), + end = m_data.invalidate_regs_map.end(); pos != end; ++pos) { if (pos->second.size() > 1) { std::sort(pos->second.begin(), pos->second.end()); @@ -506,16 +497,16 @@ // Now update all invalidate_regs with each register info as needed for (size_t i = 0; i < num_regs; ++i) { - if (m_invalidate_regs_map.find(i) != m_invalidate_regs_map.end()) - m_regs[i].invalidate_regs = m_invalidate_regs_map[i].data(); + if (m_data.invalidate_regs_map.find(i) != m_data.invalidate_regs_map.end()) + m_data.regs[i].invalidate_regs = m_data.invalidate_regs_map[i].data(); else - m_regs[i].invalidate_regs = NULL; + m_data.regs[i].invalidate_regs = NULL; } // Check if we need to automatically set the generic registers in case they // weren't set bool generic_regs_specified = false; - for (const auto ® : m_regs) { + for (const auto ® : m_data.regs) { if (reg.kinds[eRegisterKindGeneric] != LLDB_INVALID_REGNUM) { generic_regs_specified = true; break; @@ -526,7 +517,7 @@ switch (arch.GetMachine()) { case llvm::Triple::aarch64: case llvm::Triple::aarch64_be: - for (auto ® : m_regs) { + for (auto ® : m_data.regs) { if (strcmp(reg.name, "pc") == 0) reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC; else if ((strcmp(reg.name, "fp") == 0) || @@ -547,7 +538,7 @@ case llvm::Triple::armeb: case llvm::Triple::thumb: case llvm::Triple::thumbeb: - for (auto ® : m_regs) { + for (auto ® : m_data.regs) { if ((strcmp(reg.name, "pc") == 0) || (strcmp(reg.name, "r15") == 0)) reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC; else if ((strcmp(reg.name, "sp") == 0) || @@ -570,7 +561,7 @@ break; case llvm::Triple::x86: - for (auto ® : m_regs) { + for (auto ® : m_data.regs) { if ((strcmp(reg.name, "eip") == 0) || (strcmp(reg.name, "pc") == 0)) reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC; else if ((strcmp(reg.name, "esp") == 0) || @@ -586,7 +577,7 @@ break; case llvm::Triple::x86_64: - for (auto ® : m_regs) { + for (auto ® : m_data.regs) { if ((strcmp(reg.name, "rip") == 0) || (strcmp(reg.name, "pc") == 0)) reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC; else if ((strcmp(reg.name, "rsp") == 0) || @@ -607,127 +598,127 @@ } } -size_t DynamicRegisterInfo::GetNumRegisters() const { return m_regs.size(); } +size_t DynamicRegisterInfo::GetNumRegisters() const { return m_data.regs.size(); } -size_t DynamicRegisterInfo::GetNumRegisterSets() const { return m_sets.size(); } +size_t DynamicRegisterInfo::GetNumRegisterSets() const { return m_data.sets.size(); } size_t DynamicRegisterInfo::GetRegisterDataByteSize() const { - return m_reg_data_byte_size; + return m_data.reg_data_byte_size; } const RegisterInfo * DynamicRegisterInfo::GetRegisterInfoAtIndex(uint32_t i) const { - if (i < m_regs.size()) - return &m_regs[i]; + if (i < m_data.regs.size()) + return &m_data.regs[i]; return NULL; } RegisterInfo *DynamicRegisterInfo::GetRegisterInfoAtIndex(uint32_t i) { - if (i < m_regs.size()) - return &m_regs[i]; + if (i < m_data.regs.size()) + return &m_data.regs[i]; return NULL; } const RegisterSet *DynamicRegisterInfo::GetRegisterSet(uint32_t i) const { - if (i < m_sets.size()) - return &m_sets[i]; + if (i < m_data.sets.size()) + return &m_data.sets[i]; return NULL; } uint32_t DynamicRegisterInfo::GetRegisterSetIndexByName(ConstString &set_name, bool can_create) { - name_collection::iterator pos, end = m_set_names.end(); - for (pos = m_set_names.begin(); pos != end; ++pos) { + name_collection::iterator pos, end = m_data.set_names.end(); + for (pos = m_data.set_names.begin(); pos != end; ++pos) { if (*pos == set_name) - return std::distance(m_set_names.begin(), pos); + return std::distance(m_data.set_names.begin(), pos); } - m_set_names.push_back(set_name); - m_set_reg_nums.resize(m_set_reg_nums.size() + 1); + m_data.set_names.push_back(set_name); + m_data.set_reg_nums.resize(m_data.set_reg_nums.size() + 1); RegisterSet new_set = {set_name.AsCString(), NULL, 0, NULL}; - m_sets.push_back(new_set); - return m_sets.size() - 1; + m_data.sets.push_back(new_set); + return m_data.sets.size() - 1; } uint32_t DynamicRegisterInfo::ConvertRegisterKindToRegisterNumber(uint32_t kind, uint32_t num) const { - reg_collection::const_iterator pos, end = m_regs.end(); - for (pos = m_regs.begin(); pos != end; ++pos) { + reg_collection::const_iterator pos, end = m_data.regs.end(); + for (pos = m_data.regs.begin(); pos != end; ++pos) { if (pos->kinds[kind] == num) - return std::distance(m_regs.begin(), pos); + return std::distance(m_data.regs.begin(), pos); } return LLDB_INVALID_REGNUM; } void DynamicRegisterInfo::Clear() { - m_regs.clear(); - m_sets.clear(); - m_set_reg_nums.clear(); - m_set_names.clear(); - m_value_regs_map.clear(); - m_invalidate_regs_map.clear(); - m_dynamic_reg_size_map.clear(); - m_reg_data_byte_size = 0; - m_finalized = false; + m_data.regs.clear(); + m_data.sets.clear(); + m_data.set_reg_nums.clear(); + m_data.set_names.clear(); + m_data.value_regs_map.clear(); + m_data.invalidate_regs_map.clear(); + m_data.dynamic_reg_size_map.clear(); + m_data.reg_data_byte_size = 0; + m_data.finalized = false; } void DynamicRegisterInfo::Dump() const { StreamFile s(stdout, false); - const size_t num_regs = m_regs.size(); + const size_t num_regs = m_data.regs.size(); s.Printf("%p: DynamicRegisterInfo contains %" PRIu64 " registers:\n", static_cast(this), static_cast(num_regs)); for (size_t i = 0; i < num_regs; ++i) { - s.Printf("[%3" PRIu64 "] name = %-10s", (uint64_t)i, m_regs[i].name); + s.Printf("[%3" PRIu64 "] name = %-10s", (uint64_t)i, m_data.regs[i].name); s.Printf(", size = %2u, offset = %4u, encoding = %u, format = %-10s", - m_regs[i].byte_size, m_regs[i].byte_offset, m_regs[i].encoding, - FormatManager::GetFormatAsCString(m_regs[i].format)); - if (m_regs[i].kinds[eRegisterKindProcessPlugin] != LLDB_INVALID_REGNUM) + m_data.regs[i].byte_size, m_data.regs[i].byte_offset, m_data.regs[i].encoding, + FormatManager::GetFormatAsCString(m_data.regs[i].format)); + if (m_data.regs[i].kinds[eRegisterKindProcessPlugin] != LLDB_INVALID_REGNUM) s.Printf(", process plugin = %3u", - m_regs[i].kinds[eRegisterKindProcessPlugin]); - if (m_regs[i].kinds[eRegisterKindDWARF] != LLDB_INVALID_REGNUM) - s.Printf(", dwarf = %3u", m_regs[i].kinds[eRegisterKindDWARF]); - if (m_regs[i].kinds[eRegisterKindEHFrame] != LLDB_INVALID_REGNUM) - s.Printf(", ehframe = %3u", m_regs[i].kinds[eRegisterKindEHFrame]); - if (m_regs[i].kinds[eRegisterKindGeneric] != LLDB_INVALID_REGNUM) - s.Printf(", generic = %3u", m_regs[i].kinds[eRegisterKindGeneric]); - if (m_regs[i].alt_name) - s.Printf(", alt-name = %s", m_regs[i].alt_name); - if (m_regs[i].value_regs) { + m_data.regs[i].kinds[eRegisterKindProcessPlugin]); + if (m_data.regs[i].kinds[eRegisterKindDWARF] != LLDB_INVALID_REGNUM) + s.Printf(", dwarf = %3u", m_data.regs[i].kinds[eRegisterKindDWARF]); + if (m_data.regs[i].kinds[eRegisterKindEHFrame] != LLDB_INVALID_REGNUM) + s.Printf(", ehframe = %3u", m_data.regs[i].kinds[eRegisterKindEHFrame]); + if (m_data.regs[i].kinds[eRegisterKindGeneric] != LLDB_INVALID_REGNUM) + s.Printf(", generic = %3u", m_data.regs[i].kinds[eRegisterKindGeneric]); + if (m_data.regs[i].alt_name) + s.Printf(", alt-name = %s", m_data.regs[i].alt_name); + if (m_data.regs[i].value_regs) { s.Printf(", value_regs = [ "); - for (size_t j = 0; m_regs[i].value_regs[j] != LLDB_INVALID_REGNUM; ++j) { - s.Printf("%s ", m_regs[m_regs[i].value_regs[j]].name); + for (size_t j = 0; m_data.regs[i].value_regs[j] != LLDB_INVALID_REGNUM; ++j) { + s.Printf("%s ", m_data.regs[m_data.regs[i].value_regs[j]].name); } s.Printf("]"); } - if (m_regs[i].invalidate_regs) { + if (m_data.regs[i].invalidate_regs) { s.Printf(", invalidate_regs = [ "); - for (size_t j = 0; m_regs[i].invalidate_regs[j] != LLDB_INVALID_REGNUM; + for (size_t j = 0; m_data.regs[i].invalidate_regs[j] != LLDB_INVALID_REGNUM; ++j) { - s.Printf("%s ", m_regs[m_regs[i].invalidate_regs[j]].name); + s.Printf("%s ", m_data.regs[m_data.regs[i].invalidate_regs[j]].name); } s.Printf("]"); } s.EOL(); } - const size_t num_sets = m_sets.size(); + const size_t num_sets = m_data.sets.size(); s.Printf("%p: DynamicRegisterInfo contains %" PRIu64 " register sets:\n", static_cast(this), static_cast(num_sets)); for (size_t i = 0; i < num_sets; ++i) { s.Printf("set[%" PRIu64 "] name = %s, regs = [", (uint64_t)i, - m_sets[i].name); - for (size_t idx = 0; idx < m_sets[i].num_registers; ++idx) { - s.Printf("%s ", m_regs[m_sets[i].registers[idx]].name); + m_data.sets[i].name); + for (size_t idx = 0; idx < m_data.sets[i].num_registers; ++idx) { + s.Printf("%s ", m_data.regs[m_data.sets[i].registers[idx]].name); } s.Printf("]\n"); } } -lldb_private::RegisterInfo *DynamicRegisterInfo::GetRegisterInfo( - const lldb_private::ConstString ®_name) { - for (auto ®_info : m_regs) { +const lldb_private::RegisterInfo *DynamicRegisterInfo::GetRegisterInfo( + const lldb_private::ConstString ®_name) const { + for (auto ®_info : m_data.regs) { // We can use pointer comparison since we used a ConstString to set the // "name" member in AddRegister() if (reg_info.name == reg_name.GetCString()) { Index: source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp =================================================================== --- source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp +++ source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp @@ -914,15 +914,15 @@ if (num_dynamic_regs == num_common_regs) { for (i = 0; match && i < num_dynamic_regs; ++i) { // Make sure all register names match - if (m_regs[i].name && g_register_infos[i].name) { - if (strcmp(m_regs[i].name, g_register_infos[i].name)) { + if (m_data.regs[i].name && g_register_infos[i].name) { + if (strcmp(m_data.regs[i].name, g_register_infos[i].name)) { match = false; break; } } // Make sure all register byte sizes match - if (m_regs[i].byte_size != g_register_infos[i].byte_size) { + if (m_data.regs[i].byte_size != g_register_infos[i].byte_size) { match = false; break; }