1 //===-- DynamicRegisterInfo.cpp ----------------------------*- C++ -*-===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 #include "DynamicRegisterInfo.h"
11 #include "lldb/Core/StreamFile.h"
12 #include "lldb/DataFormatters/FormatManager.h"
13 #include "lldb/Host/StringConvert.h"
14 #include "lldb/Interpreter/OptionArgParser.h"
15 #include "lldb/Utility/ArchSpec.h"
16 #include "lldb/Utility/RegularExpression.h"
17 #include "lldb/Utility/StringExtractor.h"
18 #include "lldb/Utility/StructuredData.h"
21 using namespace lldb_private;
23 DynamicRegisterInfo::DynamicRegisterInfo(
24 const lldb_private::StructuredData::Dictionary &dict,
25 const lldb_private::ArchSpec &arch) {
26 SetRegisterInfo(dict, arch);
29 DynamicRegisterInfo::DynamicRegisterInfo(DynamicRegisterInfo &&info) {
30 MoveFrom(std::move(info));
34 DynamicRegisterInfo::operator=(DynamicRegisterInfo &&info) {
35 MoveFrom(std::move(info));
39 void DynamicRegisterInfo::MoveFrom(DynamicRegisterInfo &&info) {
40 m_regs = std::move(info.m_regs);
41 m_sets = std::move(info.m_sets);
42 m_set_reg_nums = std::move(info.m_set_reg_nums);
43 m_set_names = std::move(info.m_set_names);
44 m_value_regs_map = std::move(info.m_value_regs_map);
45 m_invalidate_regs_map = std::move(info.m_invalidate_regs_map);
46 m_dynamic_reg_size_map = std::move(info.m_dynamic_reg_size_map);
48 m_reg_data_byte_size = info.m_reg_data_byte_size;
49 m_finalized = info.m_finalized;
52 const size_t num_sets = m_sets.size();
53 for (size_t set = 0; set < num_sets; ++set)
54 m_sets[set].registers = m_set_reg_nums[set].data();
61 DynamicRegisterInfo::SetRegisterInfo(const StructuredData::Dictionary &dict,
62 const ArchSpec &arch) {
64 StructuredData::Array *sets = nullptr;
65 if (dict.GetValueForKeyAsArray("sets", sets)) {
66 const uint32_t num_sets = sets->GetSize();
67 for (uint32_t i = 0; i < num_sets; ++i) {
69 if (sets->GetItemAtIndexAsString(i, set_name) && !set_name.IsEmpty()) {
70 m_sets.push_back({set_name.AsCString(), nullptr, 0, nullptr});
73 printf("error: register sets must have valid names\n");
77 m_set_reg_nums.resize(m_sets.size());
80 StructuredData::Array *regs = nullptr;
81 if (!dict.GetValueForKeyAsArray("registers", regs))
84 const uint32_t num_regs = regs->GetSize();
85 // typedef std::map<std::string, std::vector<std::string> >
87 // InvalidateNameMap invalidate_map;
88 for (uint32_t i = 0; i < num_regs; ++i) {
89 StructuredData::Dictionary *reg_info_dict = nullptr;
90 if (!regs->GetItemAtIndexAsDictionary(i, reg_info_dict)) {
92 printf("error: items in the 'registers' array must be dictionaries\n");
97 // { 'name':'rcx' , 'bitsize' : 64, 'offset' : 16,
98 // 'encoding':'uint' , 'format':'hex' , 'set': 0, 'ehframe' : 2,
99 // 'dwarf' : 2, 'generic':'arg4', 'alt-name':'arg4', },
100 RegisterInfo reg_info;
101 std::vector<uint32_t> value_regs;
102 std::vector<uint32_t> invalidate_regs;
103 memset(®_info, 0, sizeof(reg_info));
105 ConstString name_val;
106 ConstString alt_name_val;
107 if (!reg_info_dict->GetValueForKeyAsString("name", name_val, nullptr)) {
109 printf("error: registers must have valid names and offsets\n");
110 reg_info_dict->DumpToStdout();
113 reg_info.name = name_val.GetCString();
114 reg_info_dict->GetValueForKeyAsString("alt-name", alt_name_val, nullptr);
115 reg_info.alt_name = alt_name_val.GetCString();
117 reg_info_dict->GetValueForKeyAsInteger("offset", reg_info.byte_offset,
120 const ByteOrder byte_order = arch.GetByteOrder();
122 if (reg_info.byte_offset == UINT32_MAX) {
123 // No offset for this register, see if the register has a value
124 // expression which indicates this register is part of another register.
125 // Value expressions are things like "rax[31:0]" which state that the
126 // current register's value is in a concrete register "rax" in bits 31:0.
127 // If there is a value expression we can calculate the offset
128 bool success = false;
129 llvm::StringRef slice_str;
130 if (reg_info_dict->GetValueForKeyAsString("slice", slice_str, nullptr)) {
131 // Slices use the following format:
132 // REGNAME[MSBIT:LSBIT]
133 // REGNAME - name of the register to grab a slice of
134 // MSBIT - the most significant bit at which the current register value
136 // LSBIT - the least significant bit at which the current register value
138 static RegularExpression g_bitfield_regex(
139 llvm::StringRef("([A-Za-z_][A-Za-z0-9_]*)\\[([0-9]+):([0-9]+)\\]"));
140 llvm::SmallVector<llvm::StringRef, 4> matches;
141 if (g_bitfield_regex.Execute(slice_str, &matches)) {
142 std::string reg_name_str = matches[1].str();
143 std::string msbit_str = matches[2].str();
144 std::string lsbit_str = matches[3].str();
145 const uint32_t msbit =
146 StringConvert::ToUInt32(msbit_str.c_str(), UINT32_MAX);
147 const uint32_t lsbit =
148 StringConvert::ToUInt32(lsbit_str.c_str(), UINT32_MAX);
149 if (msbit != UINT32_MAX && lsbit != UINT32_MAX) {
151 const uint32_t msbyte = msbit / 8;
152 const uint32_t lsbyte = lsbit / 8;
154 ConstString containing_reg_name(reg_name_str);
156 const RegisterInfo *containing_reg_info =
157 GetRegisterInfo(containing_reg_name);
158 if (containing_reg_info) {
159 const uint32_t max_bit = containing_reg_info->byte_size * 8;
160 if (msbit < max_bit && lsbit < max_bit) {
161 m_invalidate_regs_map[containing_reg_info
162 ->kinds[eRegisterKindLLDB]]
164 m_value_regs_map[i].push_back(
165 containing_reg_info->kinds[eRegisterKindLLDB]);
166 m_invalidate_regs_map[i].push_back(
167 containing_reg_info->kinds[eRegisterKindLLDB]);
169 if (byte_order == eByteOrderLittle) {
171 reg_info.byte_offset =
172 containing_reg_info->byte_offset + lsbyte;
173 } else if (byte_order == eByteOrderBig) {
175 reg_info.byte_offset =
176 containing_reg_info->byte_offset + msbyte;
178 llvm_unreachable("Invalid byte order");
182 printf("error: msbit (%u) must be less than the bitsize "
183 "of the register (%u)\n",
186 printf("error: lsbit (%u) must be less than the bitsize "
187 "of the register (%u)\n",
191 printf("error: invalid concrete register \"%s\"\n",
192 containing_reg_name.GetCString());
195 printf("error: msbit (%u) must be greater than lsbit (%u)\n",
199 printf("error: msbit (%u) and lsbit (%u) must be valid\n", msbit,
203 // TODO: print error invalid slice string that doesn't follow the
205 printf("error: failed to match against register bitfield regex\n");
208 StructuredData::Array *composite_reg_list = nullptr;
209 if (reg_info_dict->GetValueForKeyAsArray("composite",
210 composite_reg_list)) {
211 const size_t num_composite_regs = composite_reg_list->GetSize();
212 if (num_composite_regs > 0) {
213 uint32_t composite_offset = UINT32_MAX;
214 for (uint32_t composite_idx = 0; composite_idx < num_composite_regs;
216 ConstString composite_reg_name;
217 if (composite_reg_list->GetItemAtIndexAsString(
218 composite_idx, composite_reg_name, nullptr)) {
219 const RegisterInfo *composite_reg_info =
220 GetRegisterInfo(composite_reg_name);
221 if (composite_reg_info) {
222 composite_offset = std::min(composite_offset,
223 composite_reg_info->byte_offset);
224 m_value_regs_map[i].push_back(
225 composite_reg_info->kinds[eRegisterKindLLDB]);
226 m_invalidate_regs_map[composite_reg_info
227 ->kinds[eRegisterKindLLDB]]
229 m_invalidate_regs_map[i].push_back(
230 composite_reg_info->kinds[eRegisterKindLLDB]);
232 // TODO: print error invalid slice string that doesn't follow
234 printf("error: failed to find composite register by name: "
236 composite_reg_name.GetCString());
240 "error: 'composite' list value wasn't a python string\n");
243 if (composite_offset != UINT32_MAX) {
244 reg_info.byte_offset = composite_offset;
245 success = m_value_regs_map.find(i) != m_value_regs_map.end();
247 printf("error: 'composite' registers must specify at least one "
251 printf("error: 'composite' list was empty\n");
258 reg_info_dict->DumpToStdout();
264 if (!reg_info_dict->GetValueForKeyAsInteger("bitsize", bitsize)) {
266 printf("error: invalid or missing 'bitsize' key/value pair in register "
268 reg_info_dict->DumpToStdout();
272 reg_info.byte_size = bitsize / 8;
274 llvm::StringRef dwarf_opcode_string;
275 if (reg_info_dict->GetValueForKeyAsString("dynamic_size_dwarf_expr_bytes",
276 dwarf_opcode_string)) {
277 reg_info.dynamic_size_dwarf_len = dwarf_opcode_string.size() / 2;
278 assert(reg_info.dynamic_size_dwarf_len > 0);
280 std::vector<uint8_t> dwarf_opcode_bytes(reg_info.dynamic_size_dwarf_len);
282 StringExtractor opcode_extractor(dwarf_opcode_string);
283 uint32_t ret_val = opcode_extractor.GetHexBytesAvail(dwarf_opcode_bytes);
284 UNUSED_IF_ASSERT_DISABLED(ret_val);
285 assert(ret_val == reg_info.dynamic_size_dwarf_len);
287 for (j = 0; j < reg_info.dynamic_size_dwarf_len; ++j)
288 m_dynamic_reg_size_map[i].push_back(dwarf_opcode_bytes[j]);
290 reg_info.dynamic_size_dwarf_expr_bytes = m_dynamic_reg_size_map[i].data();
293 llvm::StringRef format_str;
294 if (reg_info_dict->GetValueForKeyAsString("format", format_str, nullptr)) {
295 if (OptionArgParser::ToFormat(format_str.str().c_str(), reg_info.format,
299 printf("error: invalid 'format' value in register dictionary\n");
300 reg_info_dict->DumpToStdout();
304 reg_info_dict->GetValueForKeyAsInteger("format", reg_info.format,
308 llvm::StringRef encoding_str;
309 if (reg_info_dict->GetValueForKeyAsString("encoding", encoding_str))
310 reg_info.encoding = Args::StringToEncoding(encoding_str, eEncodingUint);
312 reg_info_dict->GetValueForKeyAsInteger("encoding", reg_info.encoding,
316 if (!reg_info_dict->GetValueForKeyAsInteger<size_t>("set", set, -1) ||
317 set >= m_sets.size()) {
319 printf("error: invalid 'set' value in register dictionary, valid values "
322 reg_info_dict->DumpToStdout();
326 // Fill in the register numbers
327 reg_info.kinds[lldb::eRegisterKindLLDB] = i;
328 reg_info.kinds[lldb::eRegisterKindProcessPlugin] = i;
329 uint32_t eh_frame_regno = LLDB_INVALID_REGNUM;
330 reg_info_dict->GetValueForKeyAsInteger("gcc", eh_frame_regno,
331 LLDB_INVALID_REGNUM);
332 if (eh_frame_regno == LLDB_INVALID_REGNUM)
333 reg_info_dict->GetValueForKeyAsInteger("ehframe", eh_frame_regno,
334 LLDB_INVALID_REGNUM);
335 reg_info.kinds[lldb::eRegisterKindEHFrame] = eh_frame_regno;
336 reg_info_dict->GetValueForKeyAsInteger(
337 "dwarf", reg_info.kinds[lldb::eRegisterKindDWARF], LLDB_INVALID_REGNUM);
338 llvm::StringRef generic_str;
339 if (reg_info_dict->GetValueForKeyAsString("generic", generic_str))
340 reg_info.kinds[lldb::eRegisterKindGeneric] =
341 Args::StringToGenericRegister(generic_str);
343 reg_info_dict->GetValueForKeyAsInteger(
344 "generic", reg_info.kinds[lldb::eRegisterKindGeneric],
345 LLDB_INVALID_REGNUM);
347 // Check if this register invalidates any other register values when it is
349 StructuredData::Array *invalidate_reg_list = nullptr;
350 if (reg_info_dict->GetValueForKeyAsArray("invalidate-regs",
351 invalidate_reg_list)) {
352 const size_t num_regs = invalidate_reg_list->GetSize();
354 for (uint32_t idx = 0; idx < num_regs; ++idx) {
355 ConstString invalidate_reg_name;
356 uint64_t invalidate_reg_num;
357 if (invalidate_reg_list->GetItemAtIndexAsString(
358 idx, invalidate_reg_name)) {
359 const RegisterInfo *invalidate_reg_info =
360 GetRegisterInfo(invalidate_reg_name);
361 if (invalidate_reg_info) {
362 m_invalidate_regs_map[i].push_back(
363 invalidate_reg_info->kinds[eRegisterKindLLDB]);
365 // TODO: print error invalid slice string that doesn't follow the
367 printf("error: failed to find a 'invalidate-regs' register for "
368 "\"%s\" while parsing register \"%s\"\n",
369 invalidate_reg_name.GetCString(), reg_info.name);
371 } else if (invalidate_reg_list->GetItemAtIndexAsInteger(
372 idx, invalidate_reg_num)) {
373 if (invalidate_reg_num != UINT64_MAX)
374 m_invalidate_regs_map[i].push_back(invalidate_reg_num);
376 printf("error: 'invalidate-regs' list value wasn't a valid "
379 printf("error: 'invalidate-regs' list value wasn't a python string "
384 printf("error: 'invalidate-regs' contained an empty list\n");
388 // Calculate the register offset
389 const size_t end_reg_offset = reg_info.byte_offset + reg_info.byte_size;
390 if (m_reg_data_byte_size < end_reg_offset)
391 m_reg_data_byte_size = end_reg_offset;
393 m_regs.push_back(reg_info);
394 m_set_reg_nums[set].push_back(i);
397 return m_regs.size();
400 void DynamicRegisterInfo::AddRegister(RegisterInfo ®_info,
401 ConstString ®_name,
402 ConstString ®_alt_name,
403 ConstString &set_name) {
404 assert(!m_finalized);
405 const uint32_t reg_num = m_regs.size();
406 reg_info.name = reg_name.AsCString();
407 assert(reg_info.name);
408 reg_info.alt_name = reg_alt_name.AsCString(nullptr);
410 if (reg_info.value_regs) {
411 for (i = 0; reg_info.value_regs[i] != LLDB_INVALID_REGNUM; ++i)
412 m_value_regs_map[reg_num].push_back(reg_info.value_regs[i]);
414 if (reg_info.invalidate_regs) {
415 for (i = 0; reg_info.invalidate_regs[i] != LLDB_INVALID_REGNUM; ++i)
416 m_invalidate_regs_map[reg_num].push_back(reg_info.invalidate_regs[i]);
418 if (reg_info.dynamic_size_dwarf_expr_bytes) {
419 for (i = 0; i < reg_info.dynamic_size_dwarf_len; ++i)
420 m_dynamic_reg_size_map[reg_num].push_back(
421 reg_info.dynamic_size_dwarf_expr_bytes[i]);
423 reg_info.dynamic_size_dwarf_expr_bytes =
424 m_dynamic_reg_size_map[reg_num].data();
427 m_regs.push_back(reg_info);
428 uint32_t set = GetRegisterSetIndexByName(set_name, true);
429 assert(set < m_sets.size());
430 assert(set < m_set_reg_nums.size());
431 assert(set < m_set_names.size());
432 m_set_reg_nums[set].push_back(reg_num);
433 size_t end_reg_offset = reg_info.byte_offset + reg_info.byte_size;
434 if (m_reg_data_byte_size < end_reg_offset)
435 m_reg_data_byte_size = end_reg_offset;
438 void DynamicRegisterInfo::Finalize(const ArchSpec &arch) {
443 const size_t num_sets = m_sets.size();
444 for (size_t set = 0; set < num_sets; ++set) {
445 assert(m_sets.size() == m_set_reg_nums.size());
446 m_sets[set].num_registers = m_set_reg_nums[set].size();
447 m_sets[set].registers = m_set_reg_nums[set].data();
450 // sort and unique all value registers and make sure each is terminated with
451 // LLDB_INVALID_REGNUM
453 for (reg_to_regs_map::iterator pos = m_value_regs_map.begin(),
454 end = m_value_regs_map.end();
456 if (pos->second.size() > 1) {
457 llvm::sort(pos->second.begin(), pos->second.end());
458 reg_num_collection::iterator unique_end =
459 std::unique(pos->second.begin(), pos->second.end());
460 if (unique_end != pos->second.end())
461 pos->second.erase(unique_end, pos->second.end());
463 assert(!pos->second.empty());
464 if (pos->second.back() != LLDB_INVALID_REGNUM)
465 pos->second.push_back(LLDB_INVALID_REGNUM);
468 // Now update all value_regs with each register info as needed
469 const size_t num_regs = m_regs.size();
470 for (size_t i = 0; i < num_regs; ++i) {
471 if (m_value_regs_map.find(i) != m_value_regs_map.end())
472 m_regs[i].value_regs = m_value_regs_map[i].data();
474 m_regs[i].value_regs = nullptr;
477 // Expand all invalidation dependencies
478 for (reg_to_regs_map::iterator pos = m_invalidate_regs_map.begin(),
479 end = m_invalidate_regs_map.end();
481 const uint32_t reg_num = pos->first;
483 if (m_regs[reg_num].value_regs) {
484 reg_num_collection extra_invalid_regs;
485 for (const uint32_t invalidate_reg_num : pos->second) {
486 reg_to_regs_map::iterator invalidate_pos =
487 m_invalidate_regs_map.find(invalidate_reg_num);
488 if (invalidate_pos != m_invalidate_regs_map.end()) {
489 for (const uint32_t concrete_invalidate_reg_num :
490 invalidate_pos->second) {
491 if (concrete_invalidate_reg_num != reg_num)
492 extra_invalid_regs.push_back(concrete_invalidate_reg_num);
496 pos->second.insert(pos->second.end(), extra_invalid_regs.begin(),
497 extra_invalid_regs.end());
501 // sort and unique all invalidate registers and make sure each is terminated
502 // with LLDB_INVALID_REGNUM
503 for (reg_to_regs_map::iterator pos = m_invalidate_regs_map.begin(),
504 end = m_invalidate_regs_map.end();
506 if (pos->second.size() > 1) {
507 llvm::sort(pos->second.begin(), pos->second.end());
508 reg_num_collection::iterator unique_end =
509 std::unique(pos->second.begin(), pos->second.end());
510 if (unique_end != pos->second.end())
511 pos->second.erase(unique_end, pos->second.end());
513 assert(!pos->second.empty());
514 if (pos->second.back() != LLDB_INVALID_REGNUM)
515 pos->second.push_back(LLDB_INVALID_REGNUM);
518 // Now update all invalidate_regs with each register info as needed
519 for (size_t i = 0; i < num_regs; ++i) {
520 if (m_invalidate_regs_map.find(i) != m_invalidate_regs_map.end())
521 m_regs[i].invalidate_regs = m_invalidate_regs_map[i].data();
523 m_regs[i].invalidate_regs = nullptr;
526 // Check if we need to automatically set the generic registers in case they
528 bool generic_regs_specified = false;
529 for (const auto ® : m_regs) {
530 if (reg.kinds[eRegisterKindGeneric] != LLDB_INVALID_REGNUM) {
531 generic_regs_specified = true;
536 if (!generic_regs_specified) {
537 switch (arch.GetMachine()) {
538 case llvm::Triple::aarch64:
539 case llvm::Triple::aarch64_32:
540 case llvm::Triple::aarch64_be:
541 for (auto ® : m_regs) {
542 if (strcmp(reg.name, "pc") == 0)
543 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC;
544 else if ((strcmp(reg.name, "fp") == 0) ||
545 (strcmp(reg.name, "x29") == 0))
546 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
547 else if ((strcmp(reg.name, "lr") == 0) ||
548 (strcmp(reg.name, "x30") == 0))
549 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_RA;
550 else if ((strcmp(reg.name, "sp") == 0) ||
551 (strcmp(reg.name, "x31") == 0))
552 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP;
553 else if (strcmp(reg.name, "cpsr") == 0)
554 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS;
558 case llvm::Triple::arm:
559 case llvm::Triple::armeb:
560 case llvm::Triple::thumb:
561 case llvm::Triple::thumbeb:
562 for (auto ® : m_regs) {
563 if ((strcmp(reg.name, "pc") == 0) || (strcmp(reg.name, "r15") == 0))
564 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC;
565 else if ((strcmp(reg.name, "sp") == 0) ||
566 (strcmp(reg.name, "r13") == 0))
567 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP;
568 else if ((strcmp(reg.name, "lr") == 0) ||
569 (strcmp(reg.name, "r14") == 0))
570 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_RA;
571 else if ((strcmp(reg.name, "r7") == 0) &&
572 arch.GetTriple().getVendor() == llvm::Triple::Apple)
573 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
574 else if ((strcmp(reg.name, "r11") == 0) &&
575 arch.GetTriple().getVendor() != llvm::Triple::Apple)
576 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
577 else if (strcmp(reg.name, "fp") == 0)
578 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
579 else if (strcmp(reg.name, "cpsr") == 0)
580 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS;
584 case llvm::Triple::x86:
585 for (auto ® : m_regs) {
586 if ((strcmp(reg.name, "eip") == 0) || (strcmp(reg.name, "pc") == 0))
587 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC;
588 else if ((strcmp(reg.name, "esp") == 0) ||
589 (strcmp(reg.name, "sp") == 0))
590 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP;
591 else if ((strcmp(reg.name, "ebp") == 0) ||
592 (strcmp(reg.name, "fp") == 0))
593 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
594 else if ((strcmp(reg.name, "eflags") == 0) ||
595 (strcmp(reg.name, "flags") == 0))
596 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS;
600 case llvm::Triple::x86_64:
601 for (auto ® : m_regs) {
602 if ((strcmp(reg.name, "rip") == 0) || (strcmp(reg.name, "pc") == 0))
603 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC;
604 else if ((strcmp(reg.name, "rsp") == 0) ||
605 (strcmp(reg.name, "sp") == 0))
606 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP;
607 else if ((strcmp(reg.name, "rbp") == 0) ||
608 (strcmp(reg.name, "fp") == 0))
609 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
610 else if ((strcmp(reg.name, "rflags") == 0) ||
611 (strcmp(reg.name, "flags") == 0))
612 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS;
622 size_t DynamicRegisterInfo::GetNumRegisters() const { return m_regs.size(); }
624 size_t DynamicRegisterInfo::GetNumRegisterSets() const { return m_sets.size(); }
626 size_t DynamicRegisterInfo::GetRegisterDataByteSize() const {
627 return m_reg_data_byte_size;
631 DynamicRegisterInfo::GetRegisterInfoAtIndex(uint32_t i) const {
632 if (i < m_regs.size())
637 RegisterInfo *DynamicRegisterInfo::GetRegisterInfoAtIndex(uint32_t i) {
638 if (i < m_regs.size())
643 const RegisterSet *DynamicRegisterInfo::GetRegisterSet(uint32_t i) const {
644 if (i < m_sets.size())
649 uint32_t DynamicRegisterInfo::GetRegisterSetIndexByName(ConstString &set_name,
651 name_collection::iterator pos, end = m_set_names.end();
652 for (pos = m_set_names.begin(); pos != end; ++pos) {
653 if (*pos == set_name)
654 return std::distance(m_set_names.begin(), pos);
657 m_set_names.push_back(set_name);
658 m_set_reg_nums.resize(m_set_reg_nums.size() + 1);
659 RegisterSet new_set = {set_name.AsCString(), nullptr, 0, nullptr};
660 m_sets.push_back(new_set);
661 return m_sets.size() - 1;
665 DynamicRegisterInfo::ConvertRegisterKindToRegisterNumber(uint32_t kind,
666 uint32_t num) const {
667 reg_collection::const_iterator pos, end = m_regs.end();
668 for (pos = m_regs.begin(); pos != end; ++pos) {
669 if (pos->kinds[kind] == num)
670 return std::distance(m_regs.begin(), pos);
673 return LLDB_INVALID_REGNUM;
676 void DynamicRegisterInfo::Clear() {
679 m_set_reg_nums.clear();
681 m_value_regs_map.clear();
682 m_invalidate_regs_map.clear();
683 m_dynamic_reg_size_map.clear();
684 m_reg_data_byte_size = 0;
688 void DynamicRegisterInfo::Dump() const {
689 StreamFile s(stdout, false);
690 const size_t num_regs = m_regs.size();
691 s.Printf("%p: DynamicRegisterInfo contains %" PRIu64 " registers:\n",
692 static_cast<const void *>(this), static_cast<uint64_t>(num_regs));
693 for (size_t i = 0; i < num_regs; ++i) {
694 s.Printf("[%3" PRIu64 "] name = %-10s", (uint64_t)i, m_regs[i].name);
695 s.Printf(", size = %2u, offset = %4u, encoding = %u, format = %-10s",
696 m_regs[i].byte_size, m_regs[i].byte_offset, m_regs[i].encoding,
697 FormatManager::GetFormatAsCString(m_regs[i].format));
698 if (m_regs[i].kinds[eRegisterKindProcessPlugin] != LLDB_INVALID_REGNUM)
699 s.Printf(", process plugin = %3u",
700 m_regs[i].kinds[eRegisterKindProcessPlugin]);
701 if (m_regs[i].kinds[eRegisterKindDWARF] != LLDB_INVALID_REGNUM)
702 s.Printf(", dwarf = %3u", m_regs[i].kinds[eRegisterKindDWARF]);
703 if (m_regs[i].kinds[eRegisterKindEHFrame] != LLDB_INVALID_REGNUM)
704 s.Printf(", ehframe = %3u", m_regs[i].kinds[eRegisterKindEHFrame]);
705 if (m_regs[i].kinds[eRegisterKindGeneric] != LLDB_INVALID_REGNUM)
706 s.Printf(", generic = %3u", m_regs[i].kinds[eRegisterKindGeneric]);
707 if (m_regs[i].alt_name)
708 s.Printf(", alt-name = %s", m_regs[i].alt_name);
709 if (m_regs[i].value_regs) {
710 s.Printf(", value_regs = [ ");
711 for (size_t j = 0; m_regs[i].value_regs[j] != LLDB_INVALID_REGNUM; ++j) {
712 s.Printf("%s ", m_regs[m_regs[i].value_regs[j]].name);
716 if (m_regs[i].invalidate_regs) {
717 s.Printf(", invalidate_regs = [ ");
718 for (size_t j = 0; m_regs[i].invalidate_regs[j] != LLDB_INVALID_REGNUM;
720 s.Printf("%s ", m_regs[m_regs[i].invalidate_regs[j]].name);
727 const size_t num_sets = m_sets.size();
728 s.Printf("%p: DynamicRegisterInfo contains %" PRIu64 " register sets:\n",
729 static_cast<const void *>(this), static_cast<uint64_t>(num_sets));
730 for (size_t i = 0; i < num_sets; ++i) {
731 s.Printf("set[%" PRIu64 "] name = %s, regs = [", (uint64_t)i,
733 for (size_t idx = 0; idx < m_sets[i].num_registers; ++idx) {
734 s.Printf("%s ", m_regs[m_sets[i].registers[idx]].name);
740 const lldb_private::RegisterInfo *DynamicRegisterInfo::GetRegisterInfo(
741 lldb_private::ConstString reg_name) const {
742 for (auto ®_info : m_regs) {
743 // We can use pointer comparison since we used a ConstString to set the
744 // "name" member in AddRegister()
745 if (reg_info.name == reg_name.GetCString()) {