1 //===-- DynamicRegisterInfo.cpp ----------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "DynamicRegisterInfo.h"
14 // Other libraries and framework includes
16 #include "lldb/Core/ArchSpec.h"
17 #include "lldb/Core/RegularExpression.h"
18 #include "lldb/Core/StreamFile.h"
19 #include "lldb/Core/StructuredData.h"
20 #include "lldb/DataFormatters/FormatManager.h"
21 #include "lldb/Host/StringConvert.h"
22 #include "lldb/Utility/StringExtractor.h"
25 using namespace lldb_private;
27 DynamicRegisterInfo::DynamicRegisterInfo()
28 : m_regs(), m_sets(), m_set_reg_nums(), m_set_names(), m_value_regs_map(),
29 m_invalidate_regs_map(), m_dynamic_reg_size_map(),
30 m_reg_data_byte_size(0), m_finalized(false) {}
32 DynamicRegisterInfo::DynamicRegisterInfo(
33 const lldb_private::StructuredData::Dictionary &dict,
34 const lldb_private::ArchSpec &arch)
35 : m_regs(), m_sets(), m_set_reg_nums(), m_set_names(), m_value_regs_map(),
36 m_invalidate_regs_map(), m_dynamic_reg_size_map(),
37 m_reg_data_byte_size(0), m_finalized(false) {
38 SetRegisterInfo(dict, arch);
41 DynamicRegisterInfo::~DynamicRegisterInfo() {}
44 DynamicRegisterInfo::SetRegisterInfo(const StructuredData::Dictionary &dict,
45 const ArchSpec &arch) {
47 StructuredData::Array *sets = nullptr;
48 if (dict.GetValueForKeyAsArray("sets", sets)) {
49 const uint32_t num_sets = sets->GetSize();
50 for (uint32_t i = 0; i < num_sets; ++i) {
51 std::string set_name_str;
53 if (sets->GetItemAtIndexAsString(i, set_name_str))
54 set_name.SetCString(set_name_str.c_str());
56 RegisterSet new_set = {set_name.AsCString(), NULL, 0, NULL};
57 m_sets.push_back(new_set);
60 printf("error: register sets must have valid names\n");
64 m_set_reg_nums.resize(m_sets.size());
66 StructuredData::Array *regs = nullptr;
67 if (!dict.GetValueForKeyAsArray("registers", regs))
70 const uint32_t num_regs = regs->GetSize();
71 // typedef std::map<std::string, std::vector<std::string> >
73 // InvalidateNameMap invalidate_map;
74 for (uint32_t i = 0; i < num_regs; ++i) {
75 StructuredData::Dictionary *reg_info_dict = nullptr;
76 if (!regs->GetItemAtIndexAsDictionary(i, reg_info_dict)) {
78 printf("error: items in the 'registers' array must be dictionaries\n");
83 // { 'name':'rcx' , 'bitsize' : 64, 'offset' : 16, 'encoding':'uint'
84 // , 'format':'hex' , 'set': 0, 'ehframe' : 2,
85 // 'dwarf' : 2, 'generic':'arg4', 'alt-name':'arg4', },
86 RegisterInfo reg_info;
87 std::vector<uint32_t> value_regs;
88 std::vector<uint32_t> invalidate_regs;
89 memset(®_info, 0, sizeof(reg_info));
92 ConstString alt_name_val;
93 if (!reg_info_dict->GetValueForKeyAsString("name", name_val, nullptr)) {
95 printf("error: registers must have valid names and offsets\n");
96 reg_info_dict->DumpToStdout();
99 reg_info.name = name_val.GetCString();
100 reg_info_dict->GetValueForKeyAsString("alt-name", alt_name_val, nullptr);
101 reg_info.alt_name = alt_name_val.GetCString();
103 reg_info_dict->GetValueForKeyAsInteger("offset", reg_info.byte_offset,
106 const ByteOrder byte_order = arch.GetByteOrder();
108 if (reg_info.byte_offset == UINT32_MAX) {
109 // No offset for this register, see if the register has a value expression
110 // which indicates this register is part of another register. Value
112 // are things like "rax[31:0]" which state that the current register's
114 // is in a concrete register "rax" in bits 31:0. If there is a value
116 // we can calculate the offset
117 bool success = false;
118 std::string slice_str;
119 if (reg_info_dict->GetValueForKeyAsString("slice", slice_str, nullptr)) {
120 // Slices use the following format:
121 // REGNAME[MSBIT:LSBIT]
122 // REGNAME - name of the register to grab a slice of
123 // MSBIT - the most significant bit at which the current register value
125 // LSBIT - the least significant bit at which the current register value
127 static RegularExpression g_bitfield_regex(
128 llvm::StringRef("([A-Za-z_][A-Za-z0-9_]*)\\[([0-9]+):([0-9]+)\\]"));
129 RegularExpression::Match regex_match(3);
130 if (g_bitfield_regex.Execute(slice_str, ®ex_match)) {
131 llvm::StringRef reg_name_str;
132 std::string msbit_str;
133 std::string lsbit_str;
134 if (regex_match.GetMatchAtIndex(slice_str.c_str(), 1, reg_name_str) &&
135 regex_match.GetMatchAtIndex(slice_str.c_str(), 2, msbit_str) &&
136 regex_match.GetMatchAtIndex(slice_str.c_str(), 3, lsbit_str)) {
137 const uint32_t msbit =
138 StringConvert::ToUInt32(msbit_str.c_str(), UINT32_MAX);
139 const uint32_t lsbit =
140 StringConvert::ToUInt32(lsbit_str.c_str(), UINT32_MAX);
141 if (msbit != UINT32_MAX && lsbit != UINT32_MAX) {
143 const uint32_t msbyte = msbit / 8;
144 const uint32_t lsbyte = lsbit / 8;
146 ConstString containing_reg_name(reg_name_str);
148 RegisterInfo *containing_reg_info =
149 GetRegisterInfo(containing_reg_name);
150 if (containing_reg_info) {
151 const uint32_t max_bit = containing_reg_info->byte_size * 8;
152 if (msbit < max_bit && lsbit < max_bit) {
153 m_invalidate_regs_map[containing_reg_info
154 ->kinds[eRegisterKindLLDB]]
156 m_value_regs_map[i].push_back(
157 containing_reg_info->kinds[eRegisterKindLLDB]);
158 m_invalidate_regs_map[i].push_back(
159 containing_reg_info->kinds[eRegisterKindLLDB]);
161 if (byte_order == eByteOrderLittle) {
163 reg_info.byte_offset =
164 containing_reg_info->byte_offset + lsbyte;
165 } else if (byte_order == eByteOrderBig) {
167 reg_info.byte_offset =
168 containing_reg_info->byte_offset + msbyte;
170 assert(!"Invalid byte order");
174 printf("error: msbit (%u) must be less than the bitsize "
175 "of the register (%u)\n",
178 printf("error: lsbit (%u) must be less than the bitsize "
179 "of the register (%u)\n",
183 printf("error: invalid concrete register \"%s\"\n",
184 containing_reg_name.GetCString());
187 printf("error: msbit (%u) must be greater than lsbit (%u)\n",
191 printf("error: msbit (%u) and lsbit (%u) must be valid\n", msbit,
195 // TODO: print error invalid slice string that doesn't follow the
197 printf("error: failed to extract regex matches for parsing the "
198 "register bitfield regex\n");
201 // TODO: print error invalid slice string that doesn't follow the
203 printf("error: failed to match against register bitfield regex\n");
206 StructuredData::Array *composite_reg_list = nullptr;
207 if (reg_info_dict->GetValueForKeyAsArray("composite",
208 composite_reg_list)) {
209 const size_t num_composite_regs = composite_reg_list->GetSize();
210 if (num_composite_regs > 0) {
211 uint32_t composite_offset = UINT32_MAX;
212 for (uint32_t composite_idx = 0; composite_idx < num_composite_regs;
214 ConstString composite_reg_name;
215 if (composite_reg_list->GetItemAtIndexAsString(
216 composite_idx, composite_reg_name, nullptr)) {
217 RegisterInfo *composite_reg_info =
218 GetRegisterInfo(composite_reg_name);
219 if (composite_reg_info) {
220 composite_offset = std::min(composite_offset,
221 composite_reg_info->byte_offset);
222 m_value_regs_map[i].push_back(
223 composite_reg_info->kinds[eRegisterKindLLDB]);
224 m_invalidate_regs_map[composite_reg_info
225 ->kinds[eRegisterKindLLDB]]
227 m_invalidate_regs_map[i].push_back(
228 composite_reg_info->kinds[eRegisterKindLLDB]);
230 // TODO: print error invalid slice string that doesn't follow
232 printf("error: failed to find composite register by name: "
234 composite_reg_name.GetCString());
238 "error: 'composite' list value wasn't a python string\n");
241 if (composite_offset != UINT32_MAX) {
242 reg_info.byte_offset = composite_offset;
243 success = m_value_regs_map.find(i) != m_value_regs_map.end();
245 printf("error: 'composite' registers must specify at least one "
249 printf("error: 'composite' list was empty\n");
256 reg_info_dict->DumpToStdout();
262 if (!reg_info_dict->GetValueForKeyAsInteger("bitsize", bitsize)) {
264 printf("error: invalid or missing 'bitsize' key/value pair in register "
266 reg_info_dict->DumpToStdout();
270 reg_info.byte_size = bitsize / 8;
272 std::string dwarf_opcode_string;
273 if (reg_info_dict->GetValueForKeyAsString("dynamic_size_dwarf_expr_bytes",
274 dwarf_opcode_string)) {
275 reg_info.dynamic_size_dwarf_len = dwarf_opcode_string.length() / 2;
276 assert(reg_info.dynamic_size_dwarf_len > 0);
278 std::vector<uint8_t> dwarf_opcode_bytes(reg_info.dynamic_size_dwarf_len);
280 StringExtractor opcode_extractor;
281 // Swap "dwarf_opcode_string" over into "opcode_extractor"
282 opcode_extractor.GetStringRef().swap(dwarf_opcode_string);
283 uint32_t ret_val = opcode_extractor.GetHexBytesAvail(dwarf_opcode_bytes);
284 assert(ret_val == reg_info.dynamic_size_dwarf_len);
286 for (j = 0; j < reg_info.dynamic_size_dwarf_len; ++j)
287 m_dynamic_reg_size_map[i].push_back(dwarf_opcode_bytes[j]);
289 reg_info.dynamic_size_dwarf_expr_bytes = m_dynamic_reg_size_map[i].data();
292 std::string format_str;
293 if (reg_info_dict->GetValueForKeyAsString("format", format_str, nullptr)) {
294 if (Args::StringToFormat(format_str.c_str(), reg_info.format, NULL)
297 printf("error: invalid 'format' value in register dictionary\n");
298 reg_info_dict->DumpToStdout();
302 reg_info_dict->GetValueForKeyAsInteger("format", reg_info.format,
306 std::string encoding_str;
307 if (reg_info_dict->GetValueForKeyAsString("encoding", encoding_str))
308 reg_info.encoding = Args::StringToEncoding(encoding_str, eEncodingUint);
310 reg_info_dict->GetValueForKeyAsInteger("encoding", reg_info.encoding,
314 if (!reg_info_dict->GetValueForKeyAsInteger<size_t>("set", set, -1) ||
315 set >= m_sets.size()) {
317 printf("error: invalid 'set' value in register dictionary, valid values "
320 reg_info_dict->DumpToStdout();
324 // Fill in the register numbers
325 reg_info.kinds[lldb::eRegisterKindLLDB] = i;
326 reg_info.kinds[lldb::eRegisterKindProcessPlugin] = i;
327 uint32_t eh_frame_regno = LLDB_INVALID_REGNUM;
328 reg_info_dict->GetValueForKeyAsInteger("gcc", eh_frame_regno,
329 LLDB_INVALID_REGNUM);
330 if (eh_frame_regno == LLDB_INVALID_REGNUM)
331 reg_info_dict->GetValueForKeyAsInteger("ehframe", eh_frame_regno,
332 LLDB_INVALID_REGNUM);
333 reg_info.kinds[lldb::eRegisterKindEHFrame] = eh_frame_regno;
334 reg_info_dict->GetValueForKeyAsInteger(
335 "dwarf", reg_info.kinds[lldb::eRegisterKindDWARF], LLDB_INVALID_REGNUM);
336 std::string generic_str;
337 if (reg_info_dict->GetValueForKeyAsString("generic", generic_str))
338 reg_info.kinds[lldb::eRegisterKindGeneric] =
339 Args::StringToGenericRegister(generic_str);
341 reg_info_dict->GetValueForKeyAsInteger(
342 "generic", reg_info.kinds[lldb::eRegisterKindGeneric],
343 LLDB_INVALID_REGNUM);
345 // Check if this register invalidates any other register values when it is
347 StructuredData::Array *invalidate_reg_list = nullptr;
348 if (reg_info_dict->GetValueForKeyAsArray("invalidate-regs",
349 invalidate_reg_list)) {
350 const size_t num_regs = invalidate_reg_list->GetSize();
352 for (uint32_t idx = 0; idx < num_regs; ++idx) {
353 ConstString invalidate_reg_name;
354 uint64_t invalidate_reg_num;
355 if (invalidate_reg_list->GetItemAtIndexAsString(
356 idx, invalidate_reg_name)) {
357 RegisterInfo *invalidate_reg_info =
358 GetRegisterInfo(invalidate_reg_name);
359 if (invalidate_reg_info) {
360 m_invalidate_regs_map[i].push_back(
361 invalidate_reg_info->kinds[eRegisterKindLLDB]);
363 // TODO: print error invalid slice string that doesn't follow the
365 printf("error: failed to find a 'invalidate-regs' register for "
366 "\"%s\" while parsing register \"%s\"\n",
367 invalidate_reg_name.GetCString(), reg_info.name);
369 } else if (invalidate_reg_list->GetItemAtIndexAsInteger(
370 idx, invalidate_reg_num)) {
371 if (invalidate_reg_num != UINT64_MAX)
372 m_invalidate_regs_map[i].push_back(invalidate_reg_num);
374 printf("error: 'invalidate-regs' list value wasn't a valid "
377 printf("error: 'invalidate-regs' list value wasn't a python string "
382 printf("error: 'invalidate-regs' contained an empty list\n");
386 // Calculate the register offset
387 const size_t end_reg_offset = reg_info.byte_offset + reg_info.byte_size;
388 if (m_reg_data_byte_size < end_reg_offset)
389 m_reg_data_byte_size = end_reg_offset;
391 m_regs.push_back(reg_info);
392 m_set_reg_nums[set].push_back(i);
395 return m_regs.size();
398 void DynamicRegisterInfo::AddRegister(RegisterInfo ®_info,
399 ConstString ®_name,
400 ConstString ®_alt_name,
401 ConstString &set_name) {
402 assert(!m_finalized);
403 const uint32_t reg_num = m_regs.size();
404 reg_info.name = reg_name.AsCString();
405 assert(reg_info.name);
406 reg_info.alt_name = reg_alt_name.AsCString(NULL);
408 if (reg_info.value_regs) {
409 for (i = 0; reg_info.value_regs[i] != LLDB_INVALID_REGNUM; ++i)
410 m_value_regs_map[reg_num].push_back(reg_info.value_regs[i]);
412 if (reg_info.invalidate_regs) {
413 for (i = 0; reg_info.invalidate_regs[i] != LLDB_INVALID_REGNUM; ++i)
414 m_invalidate_regs_map[reg_num].push_back(reg_info.invalidate_regs[i]);
416 if (reg_info.dynamic_size_dwarf_expr_bytes) {
417 for (i = 0; i < reg_info.dynamic_size_dwarf_len; ++i)
418 m_dynamic_reg_size_map[reg_num].push_back(
419 reg_info.dynamic_size_dwarf_expr_bytes[i]);
421 reg_info.dynamic_size_dwarf_expr_bytes =
422 m_dynamic_reg_size_map[reg_num].data();
425 m_regs.push_back(reg_info);
426 uint32_t set = GetRegisterSetIndexByName(set_name, true);
427 assert(set < m_sets.size());
428 assert(set < m_set_reg_nums.size());
429 assert(set < m_set_names.size());
430 m_set_reg_nums[set].push_back(reg_num);
431 size_t end_reg_offset = reg_info.byte_offset + reg_info.byte_size;
432 if (m_reg_data_byte_size < end_reg_offset)
433 m_reg_data_byte_size = end_reg_offset;
436 void DynamicRegisterInfo::Finalize(const ArchSpec &arch) {
441 const size_t num_sets = m_sets.size();
442 for (size_t set = 0; set < num_sets; ++set) {
443 assert(m_sets.size() == m_set_reg_nums.size());
444 m_sets[set].num_registers = m_set_reg_nums[set].size();
445 m_sets[set].registers = &m_set_reg_nums[set][0];
448 // sort and unique all value registers and make sure each is terminated with
449 // LLDB_INVALID_REGNUM
451 for (reg_to_regs_map::iterator pos = m_value_regs_map.begin(),
452 end = m_value_regs_map.end();
454 if (pos->second.size() > 1) {
455 std::sort(pos->second.begin(), pos->second.end());
456 reg_num_collection::iterator unique_end =
457 std::unique(pos->second.begin(), pos->second.end());
458 if (unique_end != pos->second.end())
459 pos->second.erase(unique_end, pos->second.end());
461 assert(!pos->second.empty());
462 if (pos->second.back() != LLDB_INVALID_REGNUM)
463 pos->second.push_back(LLDB_INVALID_REGNUM);
466 // Now update all value_regs with each register info as needed
467 const size_t num_regs = m_regs.size();
468 for (size_t i = 0; i < num_regs; ++i) {
469 if (m_value_regs_map.find(i) != m_value_regs_map.end())
470 m_regs[i].value_regs = m_value_regs_map[i].data();
472 m_regs[i].value_regs = NULL;
475 // Expand all invalidation dependencies
476 for (reg_to_regs_map::iterator pos = m_invalidate_regs_map.begin(),
477 end = m_invalidate_regs_map.end();
479 const uint32_t reg_num = pos->first;
481 if (m_regs[reg_num].value_regs) {
482 reg_num_collection extra_invalid_regs;
483 for (const uint32_t invalidate_reg_num : pos->second) {
484 reg_to_regs_map::iterator invalidate_pos =
485 m_invalidate_regs_map.find(invalidate_reg_num);
486 if (invalidate_pos != m_invalidate_regs_map.end()) {
487 for (const uint32_t concrete_invalidate_reg_num :
488 invalidate_pos->second) {
489 if (concrete_invalidate_reg_num != reg_num)
490 extra_invalid_regs.push_back(concrete_invalidate_reg_num);
494 pos->second.insert(pos->second.end(), extra_invalid_regs.begin(),
495 extra_invalid_regs.end());
499 // sort and unique all invalidate registers and make sure each is terminated
501 // LLDB_INVALID_REGNUM
502 for (reg_to_regs_map::iterator pos = m_invalidate_regs_map.begin(),
503 end = m_invalidate_regs_map.end();
505 if (pos->second.size() > 1) {
506 std::sort(pos->second.begin(), pos->second.end());
507 reg_num_collection::iterator unique_end =
508 std::unique(pos->second.begin(), pos->second.end());
509 if (unique_end != pos->second.end())
510 pos->second.erase(unique_end, pos->second.end());
512 assert(!pos->second.empty());
513 if (pos->second.back() != LLDB_INVALID_REGNUM)
514 pos->second.push_back(LLDB_INVALID_REGNUM);
517 // Now update all invalidate_regs with each register info as needed
518 for (size_t i = 0; i < num_regs; ++i) {
519 if (m_invalidate_regs_map.find(i) != m_invalidate_regs_map.end())
520 m_regs[i].invalidate_regs = m_invalidate_regs_map[i].data();
522 m_regs[i].invalidate_regs = NULL;
525 // Check if we need to automatically set the generic registers in case
527 bool generic_regs_specified = false;
528 for (const auto ® : m_regs) {
529 if (reg.kinds[eRegisterKindGeneric] != LLDB_INVALID_REGNUM) {
530 generic_regs_specified = true;
535 if (!generic_regs_specified) {
536 switch (arch.GetMachine()) {
537 case llvm::Triple::aarch64:
538 case llvm::Triple::aarch64_be:
539 for (auto ® : m_regs) {
540 if (strcmp(reg.name, "pc") == 0)
541 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC;
542 else if ((strcmp(reg.name, "fp") == 0) ||
543 (strcmp(reg.name, "x29") == 0))
544 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
545 else if ((strcmp(reg.name, "lr") == 0) ||
546 (strcmp(reg.name, "x30") == 0))
547 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_RA;
548 else if ((strcmp(reg.name, "sp") == 0) ||
549 (strcmp(reg.name, "x31") == 0))
550 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP;
551 else if (strcmp(reg.name, "cpsr") == 0)
552 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS;
556 case llvm::Triple::arm:
557 case llvm::Triple::armeb:
558 case llvm::Triple::thumb:
559 case llvm::Triple::thumbeb:
560 for (auto ® : m_regs) {
561 if ((strcmp(reg.name, "pc") == 0) || (strcmp(reg.name, "r15") == 0))
562 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC;
563 else if ((strcmp(reg.name, "sp") == 0) ||
564 (strcmp(reg.name, "r13") == 0))
565 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP;
566 else if ((strcmp(reg.name, "lr") == 0) ||
567 (strcmp(reg.name, "r14") == 0))
568 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_RA;
569 else if ((strcmp(reg.name, "r7") == 0) &&
570 arch.GetTriple().getVendor() == llvm::Triple::Apple)
571 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
572 else if ((strcmp(reg.name, "r11") == 0) &&
573 arch.GetTriple().getVendor() != llvm::Triple::Apple)
574 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
575 else if (strcmp(reg.name, "fp") == 0)
576 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
577 else if (strcmp(reg.name, "cpsr") == 0)
578 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS;
582 case llvm::Triple::x86:
583 for (auto ® : m_regs) {
584 if ((strcmp(reg.name, "eip") == 0) || (strcmp(reg.name, "pc") == 0))
585 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC;
586 else if ((strcmp(reg.name, "esp") == 0) ||
587 (strcmp(reg.name, "sp") == 0))
588 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP;
589 else if ((strcmp(reg.name, "ebp") == 0) ||
590 (strcmp(reg.name, "fp") == 0))
591 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
592 else if ((strcmp(reg.name, "eflags") == 0) ||
593 (strcmp(reg.name, "flags") == 0))
594 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS;
598 case llvm::Triple::x86_64:
599 for (auto ® : m_regs) {
600 if ((strcmp(reg.name, "rip") == 0) || (strcmp(reg.name, "pc") == 0))
601 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC;
602 else if ((strcmp(reg.name, "rsp") == 0) ||
603 (strcmp(reg.name, "sp") == 0))
604 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP;
605 else if ((strcmp(reg.name, "rbp") == 0) ||
606 (strcmp(reg.name, "fp") == 0))
607 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
608 else if ((strcmp(reg.name, "rflags") == 0) ||
609 (strcmp(reg.name, "flags") == 0))
610 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS;
620 size_t DynamicRegisterInfo::GetNumRegisters() const { return m_regs.size(); }
622 size_t DynamicRegisterInfo::GetNumRegisterSets() const { return m_sets.size(); }
624 size_t DynamicRegisterInfo::GetRegisterDataByteSize() const {
625 return m_reg_data_byte_size;
629 DynamicRegisterInfo::GetRegisterInfoAtIndex(uint32_t i) const {
630 if (i < m_regs.size())
635 RegisterInfo *DynamicRegisterInfo::GetRegisterInfoAtIndex(uint32_t i) {
636 if (i < m_regs.size())
641 const RegisterSet *DynamicRegisterInfo::GetRegisterSet(uint32_t i) const {
642 if (i < m_sets.size())
647 uint32_t DynamicRegisterInfo::GetRegisterSetIndexByName(ConstString &set_name,
649 name_collection::iterator pos, end = m_set_names.end();
650 for (pos = m_set_names.begin(); pos != end; ++pos) {
651 if (*pos == set_name)
652 return std::distance(m_set_names.begin(), pos);
655 m_set_names.push_back(set_name);
656 m_set_reg_nums.resize(m_set_reg_nums.size() + 1);
657 RegisterSet new_set = {set_name.AsCString(), NULL, 0, NULL};
658 m_sets.push_back(new_set);
659 return m_sets.size() - 1;
663 DynamicRegisterInfo::ConvertRegisterKindToRegisterNumber(uint32_t kind,
664 uint32_t num) const {
665 reg_collection::const_iterator pos, end = m_regs.end();
666 for (pos = m_regs.begin(); pos != end; ++pos) {
667 if (pos->kinds[kind] == num)
668 return std::distance(m_regs.begin(), pos);
671 return LLDB_INVALID_REGNUM;
674 void DynamicRegisterInfo::Clear() {
677 m_set_reg_nums.clear();
679 m_value_regs_map.clear();
680 m_invalidate_regs_map.clear();
681 m_dynamic_reg_size_map.clear();
682 m_reg_data_byte_size = 0;
686 void DynamicRegisterInfo::Dump() const {
687 StreamFile s(stdout, false);
688 const size_t num_regs = m_regs.size();
689 s.Printf("%p: DynamicRegisterInfo contains %" PRIu64 " registers:\n",
690 static_cast<const void *>(this), static_cast<uint64_t>(num_regs));
691 for (size_t i = 0; i < num_regs; ++i) {
692 s.Printf("[%3" PRIu64 "] name = %-10s", (uint64_t)i, m_regs[i].name);
693 s.Printf(", size = %2u, offset = %4u, encoding = %u, format = %-10s",
694 m_regs[i].byte_size, m_regs[i].byte_offset, m_regs[i].encoding,
695 FormatManager::GetFormatAsCString(m_regs[i].format));
696 if (m_regs[i].kinds[eRegisterKindProcessPlugin] != LLDB_INVALID_REGNUM)
697 s.Printf(", process plugin = %3u",
698 m_regs[i].kinds[eRegisterKindProcessPlugin]);
699 if (m_regs[i].kinds[eRegisterKindDWARF] != LLDB_INVALID_REGNUM)
700 s.Printf(", dwarf = %3u", m_regs[i].kinds[eRegisterKindDWARF]);
701 if (m_regs[i].kinds[eRegisterKindEHFrame] != LLDB_INVALID_REGNUM)
702 s.Printf(", ehframe = %3u", m_regs[i].kinds[eRegisterKindEHFrame]);
703 if (m_regs[i].kinds[eRegisterKindGeneric] != LLDB_INVALID_REGNUM)
704 s.Printf(", generic = %3u", m_regs[i].kinds[eRegisterKindGeneric]);
705 if (m_regs[i].alt_name)
706 s.Printf(", alt-name = %s", m_regs[i].alt_name);
707 if (m_regs[i].value_regs) {
708 s.Printf(", value_regs = [ ");
709 for (size_t j = 0; m_regs[i].value_regs[j] != LLDB_INVALID_REGNUM; ++j) {
710 s.Printf("%s ", m_regs[m_regs[i].value_regs[j]].name);
714 if (m_regs[i].invalidate_regs) {
715 s.Printf(", invalidate_regs = [ ");
716 for (size_t j = 0; m_regs[i].invalidate_regs[j] != LLDB_INVALID_REGNUM;
718 s.Printf("%s ", m_regs[m_regs[i].invalidate_regs[j]].name);
725 const size_t num_sets = m_sets.size();
726 s.Printf("%p: DynamicRegisterInfo contains %" PRIu64 " register sets:\n",
727 static_cast<const void *>(this), static_cast<uint64_t>(num_sets));
728 for (size_t i = 0; i < num_sets; ++i) {
729 s.Printf("set[%" PRIu64 "] name = %s, regs = [", (uint64_t)i,
731 for (size_t idx = 0; idx < m_sets[i].num_registers; ++idx) {
732 s.Printf("%s ", m_regs[m_sets[i].registers[idx]].name);
738 lldb_private::RegisterInfo *DynamicRegisterInfo::GetRegisterInfo(
739 const lldb_private::ConstString ®_name) {
740 for (auto ®_info : m_regs) {
741 // We can use pointer comparison since we used a ConstString to set
742 // the "name" member in AddRegister()
743 if (reg_info.name == reg_name.GetCString()) {