LLDB mainline
DynamicRegisterInfo.cpp
Go to the documentation of this file.
1//===-- DynamicRegisterInfo.cpp -------------------------------------------===//
2//
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
6//
7//===----------------------------------------------------------------------===//
8
15#include "lldb/Utility/Log.h"
19
20using namespace lldb;
21using namespace lldb_private;
22
23std::unique_ptr<DynamicRegisterInfo>
25 const ArchSpec &arch) {
26 auto dyn_reg_info = std::make_unique<DynamicRegisterInfo>();
27 if (!dyn_reg_info)
28 return nullptr;
29
30 if (dyn_reg_info->SetRegisterInfo(dict, arch) == 0)
31 return nullptr;
32
33 return dyn_reg_info;
34}
35
37 MoveFrom(std::move(info));
38}
39
42 MoveFrom(std::move(info));
43 return *this;
44}
45
47 m_regs = std::move(info.m_regs);
48 m_sets = std::move(info.m_sets);
49 m_set_reg_nums = std::move(info.m_set_reg_nums);
50 m_set_names = std::move(info.m_set_names);
51 m_value_regs_map = std::move(info.m_value_regs_map);
52 m_invalidate_regs_map = std::move(info.m_invalidate_regs_map);
53
54 m_reg_data_byte_size = info.m_reg_data_byte_size;
55 m_finalized = info.m_finalized;
56
57 if (m_finalized) {
58 const size_t num_sets = m_sets.size();
59 for (size_t set = 0; set < num_sets; ++set)
60 m_sets[set].registers = m_set_reg_nums[set].data();
61 }
62
63 info.Clear();
64}
65
67 uint32_t index, llvm::StringRef slice_str, lldb::ByteOrder byte_order) {
68 // Slices use the following format:
69 // REGNAME[MSBIT:LSBIT]
70 // REGNAME - name of the register to grab a slice of
71 // MSBIT - the most significant bit at which the current register value
72 // starts at
73 // LSBIT - the least significant bit at which the current register value
74 // ends at
75 static llvm::Regex g_bitfield_regex(
76 "([A-Za-z_][A-Za-z0-9_]*)\\[([0-9]+):([0-9]+)\\]");
77 llvm::SmallVector<llvm::StringRef, 4> matches;
78 if (!g_bitfield_regex.match(slice_str, &matches))
79 return llvm::createStringError(
80 llvm::inconvertibleErrorCode(),
81 "failed to match against register bitfield regex (slice: %s)",
82 slice_str.str().c_str());
83
84 llvm::StringRef reg_name_str = matches[1];
85 llvm::StringRef msbit_str = matches[2];
86 llvm::StringRef lsbit_str = matches[3];
87 uint32_t msbit;
88 uint32_t lsbit;
89 if (!llvm::to_integer(msbit_str, msbit) ||
90 !llvm::to_integer(lsbit_str, lsbit))
91 return llvm::createStringError(
92 llvm::inconvertibleErrorCode(), "msbit (%s) or lsbit (%s) are invalid",
93 msbit_str.str().c_str(), lsbit_str.str().c_str());
94
95 if (msbit <= lsbit)
96 return llvm::createStringError(llvm::inconvertibleErrorCode(),
97 "msbit (%u) must be greater than lsbit (%u)",
98 msbit, lsbit);
99
100 const uint32_t msbyte = msbit / 8;
101 const uint32_t lsbyte = lsbit / 8;
102
103 const RegisterInfo *containing_reg_info = GetRegisterInfo(reg_name_str);
104 if (!containing_reg_info)
105 return llvm::createStringError(llvm::inconvertibleErrorCode(),
106 "invalid concrete register \"%s\"",
107 reg_name_str.str().c_str());
108
109 const uint32_t max_bit = containing_reg_info->byte_size * 8;
110
111 if (msbit > max_bit)
112 return llvm::createStringError(
113 llvm::inconvertibleErrorCode(),
114 "msbit (%u) must be less than the bitsize of the register \"%s\" (%u)",
115 msbit, reg_name_str.str().c_str(), max_bit);
116 if (lsbit > max_bit)
117 return llvm::createStringError(
118 llvm::inconvertibleErrorCode(),
119 "lsbit (%u) must be less than the bitsize of the register \"%s\" (%u)",
120 lsbit, reg_name_str.str().c_str(), max_bit);
121
122 m_invalidate_regs_map[containing_reg_info->kinds[eRegisterKindLLDB]]
123 .push_back(index);
124 m_value_regs_map[index].push_back(
125 containing_reg_info->kinds[eRegisterKindLLDB]);
126 m_invalidate_regs_map[index].push_back(
127 containing_reg_info->kinds[eRegisterKindLLDB]);
128
129 if (byte_order == eByteOrderLittle)
130 return containing_reg_info->byte_offset + lsbyte;
131 if (byte_order == eByteOrderBig)
132 return containing_reg_info->byte_offset + msbyte;
133 llvm_unreachable("Invalid byte order");
134}
135
137 uint32_t index, StructuredData::Array &composite_reg_list,
138 lldb::ByteOrder byte_order) {
139 const size_t num_composite_regs = composite_reg_list.GetSize();
140 if (num_composite_regs == 0)
141 return llvm::createStringError(llvm::inconvertibleErrorCode(),
142 "\"composite\" list is empty");
143
144 uint32_t composite_offset = UINT32_MAX;
145 for (uint32_t composite_idx = 0; composite_idx < num_composite_regs;
146 ++composite_idx) {
147 std::optional<llvm::StringRef> maybe_composite_reg_name =
148 composite_reg_list.GetItemAtIndexAsString(composite_idx);
149 if (!maybe_composite_reg_name)
150 return llvm::createStringError(
151 llvm::inconvertibleErrorCode(),
152 "\"composite\" list value is not a Python string at index %d",
153 composite_idx);
154
155 const RegisterInfo *composite_reg_info =
156 GetRegisterInfo(*maybe_composite_reg_name);
157 if (!composite_reg_info)
158 return llvm::createStringError(
159 llvm::inconvertibleErrorCode(),
160 "failed to find composite register by name: \"%s\"",
161 maybe_composite_reg_name->str().c_str());
162
163 composite_offset =
164 std::min(composite_offset, composite_reg_info->byte_offset);
165 m_value_regs_map[index].push_back(
166 composite_reg_info->kinds[eRegisterKindLLDB]);
167 m_invalidate_regs_map[composite_reg_info->kinds[eRegisterKindLLDB]]
168 .push_back(index);
169 m_invalidate_regs_map[index].push_back(
170 composite_reg_info->kinds[eRegisterKindLLDB]);
171 }
172
173 return composite_offset;
174}
175
177 uint32_t index, StructuredData::Dictionary &reg_info_dict,
178 lldb::ByteOrder byte_order) {
179 uint32_t byte_offset;
180 if (reg_info_dict.GetValueForKeyAsInteger("offset", byte_offset))
181 return byte_offset;
182
183 // No offset for this register, see if the register has a value
184 // expression which indicates this register is part of another register.
185 // Value expressions are things like "rax[31:0]" which state that the
186 // current register's value is in a concrete register "rax" in bits 31:0.
187 // If there is a value expression we can calculate the offset
188 llvm::StringRef slice_str;
189 if (reg_info_dict.GetValueForKeyAsString("slice", slice_str, nullptr))
190 return ByteOffsetFromSlice(index, slice_str, byte_order);
191
192 StructuredData::Array *composite_reg_list;
193 if (reg_info_dict.GetValueForKeyAsArray("composite", composite_reg_list))
194 return ByteOffsetFromComposite(index, *composite_reg_list, byte_order);
195
196 return llvm::createStringError(llvm::inconvertibleErrorCode(),
197 "insufficient data to calculate byte offset");
198}
199
200size_t
202 const ArchSpec &arch) {
203 Log *log = GetLog(LLDBLog::Object);
204 assert(!m_finalized);
205 StructuredData::Array *sets = nullptr;
206 if (dict.GetValueForKeyAsArray("sets", sets)) {
207 const uint32_t num_sets = sets->GetSize();
208 for (uint32_t i = 0; i < num_sets; ++i) {
209 std::optional<llvm::StringRef> maybe_set_name =
210 sets->GetItemAtIndexAsString(i);
211 if (maybe_set_name && !maybe_set_name->empty()) {
212 m_sets.push_back(
213 {ConstString(*maybe_set_name).AsCString(), nullptr, 0, nullptr});
214 } else {
215 Clear();
216 printf("error: register sets must have valid names\n");
217 return 0;
218 }
219 }
220 m_set_reg_nums.resize(m_sets.size());
221 }
222
223 StructuredData::Array *regs = nullptr;
224 if (!dict.GetValueForKeyAsArray("registers", regs))
225 return 0;
226
227 const ByteOrder byte_order = arch.GetByteOrder();
228
229 const uint32_t num_regs = regs->GetSize();
230 // typedef std::map<std::string, std::vector<std::string> >
231 // InvalidateNameMap;
232 // InvalidateNameMap invalidate_map;
233 for (uint32_t i = 0; i < num_regs; ++i) {
234 std::optional<StructuredData::Dictionary *> maybe_reg_info_dict =
236 if (!maybe_reg_info_dict) {
237 Clear();
238 printf("error: items in the 'registers' array must be dictionaries\n");
239 regs->DumpToStdout();
240 return 0;
241 }
242 StructuredData::Dictionary *reg_info_dict = *maybe_reg_info_dict;
243
244 // { 'name':'rcx' , 'bitsize' : 64, 'offset' : 16,
245 // 'encoding':'uint' , 'format':'hex' , 'set': 0, 'ehframe' : 2,
246 // 'dwarf' : 2, 'generic':'arg4', 'alt-name':'arg4', },
247 RegisterInfo reg_info;
248 std::vector<uint32_t> value_regs;
249 std::vector<uint32_t> invalidate_regs;
250 memset(&reg_info, 0, sizeof(reg_info));
251
252 llvm::StringRef name_val;
253 if (!reg_info_dict->GetValueForKeyAsString("name", name_val)) {
254 Clear();
255 printf("error: registers must have valid names and offsets\n");
256 reg_info_dict->DumpToStdout();
257 return 0;
258 }
259 reg_info.name = ConstString(name_val).GetCString();
260
261 llvm::StringRef alt_name_val;
262 if (reg_info_dict->GetValueForKeyAsString("alt-name", alt_name_val))
263 reg_info.alt_name = ConstString(alt_name_val).GetCString();
264 else
265 reg_info.alt_name = nullptr;
266
267 llvm::Expected<uint32_t> byte_offset =
268 ByteOffsetFromRegInfoDict(i, *reg_info_dict, byte_order);
269 if (byte_offset)
270 reg_info.byte_offset = byte_offset.get();
271 else {
272 LLDB_LOG_ERROR(log, byte_offset.takeError(),
273 "error while parsing register {1}: {0}", reg_info.name);
274 Clear();
275 reg_info_dict->DumpToStdout();
276 return 0;
277 }
278
279 uint64_t bitsize = 0;
280 if (!reg_info_dict->GetValueForKeyAsInteger("bitsize", bitsize)) {
281 Clear();
282 printf("error: invalid or missing 'bitsize' key/value pair in register "
283 "dictionary\n");
284 reg_info_dict->DumpToStdout();
285 return 0;
286 }
287
288 reg_info.byte_size = bitsize / 8;
289
290 llvm::StringRef format_str;
291 if (reg_info_dict->GetValueForKeyAsString("format", format_str, nullptr)) {
292 if (OptionArgParser::ToFormat(format_str.str().c_str(), reg_info.format,
293 nullptr)
294 .Fail()) {
295 Clear();
296 printf("error: invalid 'format' value in register dictionary\n");
297 reg_info_dict->DumpToStdout();
298 return 0;
299 }
300 } else {
301 reg_info_dict->GetValueForKeyAsInteger("format", reg_info.format,
302 eFormatHex);
303 }
304
305 llvm::StringRef encoding_str;
306 if (reg_info_dict->GetValueForKeyAsString("encoding", encoding_str))
307 reg_info.encoding = Args::StringToEncoding(encoding_str, eEncodingUint);
308 else
309 reg_info_dict->GetValueForKeyAsInteger("encoding", reg_info.encoding,
311
312 size_t set = 0;
313 if (!reg_info_dict->GetValueForKeyAsInteger("set", set) ||
314 set >= m_sets.size()) {
315 Clear();
316 printf("error: invalid 'set' value in register dictionary, valid values "
317 "are 0 - %i\n",
318 (int)set);
319 reg_info_dict->DumpToStdout();
320 return 0;
321 }
322
323 // Fill in the register numbers
324 reg_info.kinds[lldb::eRegisterKindLLDB] = i;
326 uint32_t eh_frame_regno = LLDB_INVALID_REGNUM;
327 reg_info_dict->GetValueForKeyAsInteger("gcc", eh_frame_regno,
329 if (eh_frame_regno == LLDB_INVALID_REGNUM)
330 reg_info_dict->GetValueForKeyAsInteger("ehframe", eh_frame_regno,
332 reg_info.kinds[lldb::eRegisterKindEHFrame] = eh_frame_regno;
333 reg_info_dict->GetValueForKeyAsInteger(
335 llvm::StringRef generic_str;
336 if (reg_info_dict->GetValueForKeyAsString("generic", generic_str))
339 else
340 reg_info_dict->GetValueForKeyAsInteger(
341 "generic", reg_info.kinds[lldb::eRegisterKindGeneric],
343
344 // Check if this register invalidates any other register values when it is
345 // modified
346 StructuredData::Array *invalidate_reg_list = nullptr;
347 if (reg_info_dict->GetValueForKeyAsArray("invalidate-regs",
348 invalidate_reg_list)) {
349 const size_t num_regs = invalidate_reg_list->GetSize();
350 if (num_regs > 0) {
351 for (uint32_t idx = 0; idx < num_regs; ++idx) {
352 if (auto maybe_invalidate_reg_name =
353 invalidate_reg_list->GetItemAtIndexAsString(idx)) {
354 const RegisterInfo *invalidate_reg_info =
355 GetRegisterInfo(*maybe_invalidate_reg_name);
356 if (invalidate_reg_info) {
357 m_invalidate_regs_map[i].push_back(
358 invalidate_reg_info->kinds[eRegisterKindLLDB]);
359 } else {
360 // TODO: print error invalid slice string that doesn't follow the
361 // format
362 printf("error: failed to find a 'invalidate-regs' register for "
363 "\"%s\" while parsing register \"%s\"\n",
364 maybe_invalidate_reg_name->str().c_str(), reg_info.name);
365 }
366 } else if (auto maybe_invalidate_reg_num =
367 invalidate_reg_list->GetItemAtIndexAsInteger<uint64_t>(
368 idx)) {
369 if (*maybe_invalidate_reg_num != UINT64_MAX)
370 m_invalidate_regs_map[i].push_back(*maybe_invalidate_reg_num);
371 else
372 printf("error: 'invalidate-regs' list value wasn't a valid "
373 "integer\n");
374 } else {
375 printf("error: 'invalidate-regs' list value wasn't a python string "
376 "or integer\n");
377 }
378 }
379 } else {
380 printf("error: 'invalidate-regs' contained an empty list\n");
381 }
382 }
383
384 // Calculate the register offset
385 const size_t end_reg_offset = reg_info.byte_offset + reg_info.byte_size;
386 if (m_reg_data_byte_size < end_reg_offset)
387 m_reg_data_byte_size = end_reg_offset;
388
389 m_regs.push_back(reg_info);
390 m_set_reg_nums[set].push_back(i);
391 }
392 Finalize(arch);
393 return m_regs.size();
394}
395
397 std::vector<DynamicRegisterInfo::Register> &&regs,
398 const ArchSpec &arch) {
399 assert(!m_finalized);
400
401 for (auto it : llvm::enumerate(regs)) {
402 uint32_t local_regnum = it.index();
403 const DynamicRegisterInfo::Register &reg = it.value();
404
405 assert(reg.name);
406 assert(reg.set_name);
407
408 if (!reg.value_regs.empty())
409 m_value_regs_map[local_regnum] = std::move(reg.value_regs);
410 if (!reg.invalidate_regs.empty())
411 m_invalidate_regs_map[local_regnum] = std::move(reg.invalidate_regs);
412 if (reg.value_reg_offset != 0) {
413 assert(reg.value_regs.size() == 1);
414 m_value_reg_offset_map[local_regnum] = reg.value_reg_offset;
415 }
416
417 struct RegisterInfo reg_info {
418 reg.name.AsCString(), reg.alt_name.AsCString(), reg.byte_size,
419 reg.byte_offset, reg.encoding, reg.format,
421 reg.regnum_remote, local_regnum},
422 // value_regs and invalidate_regs are filled by Finalize()
423 nullptr, nullptr, reg.flags_type
424 };
425
426 m_regs.push_back(reg_info);
427
428 uint32_t set = GetRegisterSetIndexByName(reg.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(local_regnum);
433 };
434
435 Finalize(arch);
436 return m_regs.size();
437}
438
440 if (m_finalized)
441 return;
442
443 m_finalized = true;
444 const size_t num_sets = m_sets.size();
445 for (size_t set = 0; set < num_sets; ++set) {
446 assert(m_sets.size() == m_set_reg_nums.size());
447 m_sets[set].num_registers = m_set_reg_nums[set].size();
448 m_sets[set].registers = m_set_reg_nums[set].data();
449 }
450
451 // make sure value_regs are terminated with LLDB_INVALID_REGNUM
452
453 for (reg_to_regs_map::iterator pos = m_value_regs_map.begin(),
454 end = m_value_regs_map.end();
455 pos != end; ++pos) {
456 if (pos->second.back() != LLDB_INVALID_REGNUM)
457 pos->second.push_back(LLDB_INVALID_REGNUM);
458 }
459
460 // Now update all value_regs with each register info as needed
461 const size_t num_regs = m_regs.size();
462 for (size_t i = 0; i < num_regs; ++i) {
463 if (m_value_regs_map.find(i) != m_value_regs_map.end())
464 m_regs[i].value_regs = m_value_regs_map[i].data();
465 else
466 m_regs[i].value_regs = nullptr;
467 }
468
469 // Expand all invalidation dependencies
470 for (reg_to_regs_map::iterator pos = m_invalidate_regs_map.begin(),
471 end = m_invalidate_regs_map.end();
472 pos != end; ++pos) {
473 const uint32_t reg_num = pos->first;
474
475 if (m_regs[reg_num].value_regs) {
476 reg_num_collection extra_invalid_regs;
477 for (const uint32_t invalidate_reg_num : pos->second) {
478 reg_to_regs_map::iterator invalidate_pos =
479 m_invalidate_regs_map.find(invalidate_reg_num);
480 if (invalidate_pos != m_invalidate_regs_map.end()) {
481 for (const uint32_t concrete_invalidate_reg_num :
482 invalidate_pos->second) {
483 if (concrete_invalidate_reg_num != reg_num)
484 extra_invalid_regs.push_back(concrete_invalidate_reg_num);
485 }
486 }
487 }
488 pos->second.insert(pos->second.end(), extra_invalid_regs.begin(),
489 extra_invalid_regs.end());
490 }
491 }
492
493 // sort and unique all invalidate registers and make sure each is terminated
494 // with LLDB_INVALID_REGNUM
495 for (reg_to_regs_map::iterator pos = m_invalidate_regs_map.begin(),
496 end = m_invalidate_regs_map.end();
497 pos != end; ++pos) {
498 if (pos->second.size() > 1) {
499 llvm::sort(pos->second);
500 reg_num_collection::iterator unique_end =
501 std::unique(pos->second.begin(), pos->second.end());
502 if (unique_end != pos->second.end())
503 pos->second.erase(unique_end, pos->second.end());
504 }
505 assert(!pos->second.empty());
506 if (pos->second.back() != LLDB_INVALID_REGNUM)
507 pos->second.push_back(LLDB_INVALID_REGNUM);
508 }
509
510 // Now update all invalidate_regs with each register info as needed
511 for (size_t i = 0; i < num_regs; ++i) {
512 if (m_invalidate_regs_map.find(i) != m_invalidate_regs_map.end())
513 m_regs[i].invalidate_regs = m_invalidate_regs_map[i].data();
514 else
515 m_regs[i].invalidate_regs = nullptr;
516 }
517
518 // Check if we need to automatically set the generic registers in case they
519 // weren't set
520 bool generic_regs_specified = false;
521 for (const auto &reg : m_regs) {
522 if (reg.kinds[eRegisterKindGeneric] != LLDB_INVALID_REGNUM) {
523 generic_regs_specified = true;
524 break;
525 }
526 }
527
528 if (!generic_regs_specified) {
529 switch (arch.GetMachine()) {
530 case llvm::Triple::aarch64:
531 case llvm::Triple::aarch64_32:
532 case llvm::Triple::aarch64_be:
533 for (auto &reg : m_regs) {
534 if (strcmp(reg.name, "pc") == 0)
536 else if ((strcmp(reg.name, "fp") == 0) ||
537 (strcmp(reg.name, "x29") == 0))
539 else if ((strcmp(reg.name, "lr") == 0) ||
540 (strcmp(reg.name, "x30") == 0))
542 else if ((strcmp(reg.name, "sp") == 0) ||
543 (strcmp(reg.name, "x31") == 0))
545 else if (strcmp(reg.name, "cpsr") == 0)
547 }
548 break;
549
550 case llvm::Triple::arm:
551 case llvm::Triple::armeb:
552 case llvm::Triple::thumb:
553 case llvm::Triple::thumbeb:
554 for (auto &reg : m_regs) {
555 if ((strcmp(reg.name, "pc") == 0) || (strcmp(reg.name, "r15") == 0))
557 else if ((strcmp(reg.name, "sp") == 0) ||
558 (strcmp(reg.name, "r13") == 0))
560 else if ((strcmp(reg.name, "lr") == 0) ||
561 (strcmp(reg.name, "r14") == 0))
563 else if ((strcmp(reg.name, "r7") == 0) &&
564 arch.GetTriple().getVendor() == llvm::Triple::Apple)
566 else if ((strcmp(reg.name, "r11") == 0) &&
567 arch.GetTriple().getVendor() != llvm::Triple::Apple)
569 else if (strcmp(reg.name, "fp") == 0)
571 else if (strcmp(reg.name, "cpsr") == 0)
573 }
574 break;
575
576 case llvm::Triple::x86:
577 for (auto &reg : m_regs) {
578 if ((strcmp(reg.name, "eip") == 0) || (strcmp(reg.name, "pc") == 0))
580 else if ((strcmp(reg.name, "esp") == 0) ||
581 (strcmp(reg.name, "sp") == 0))
583 else if ((strcmp(reg.name, "ebp") == 0) ||
584 (strcmp(reg.name, "fp") == 0))
586 else if ((strcmp(reg.name, "eflags") == 0) ||
587 (strcmp(reg.name, "flags") == 0))
589 }
590 break;
591
592 case llvm::Triple::x86_64:
593 for (auto &reg : m_regs) {
594 if ((strcmp(reg.name, "rip") == 0) || (strcmp(reg.name, "pc") == 0))
596 else if ((strcmp(reg.name, "rsp") == 0) ||
597 (strcmp(reg.name, "sp") == 0))
599 else if ((strcmp(reg.name, "rbp") == 0) ||
600 (strcmp(reg.name, "fp") == 0))
602 else if ((strcmp(reg.name, "rflags") == 0) ||
603 (strcmp(reg.name, "eflags") == 0) ||
604 (strcmp(reg.name, "flags") == 0))
606 }
607 break;
608
609 default:
610 break;
611 }
612 }
613
614 // At this stage call ConfigureOffsets to calculate register offsets for
615 // targets supporting dynamic offset calculation. It also calculates
616 // total byte size of register data.
618
619 // Check if register info is reconfigurable
620 // AArch64 SVE register set has configurable register sizes, as does the ZA
621 // register that SME added (the streaming state of SME reuses the SVE state).
622 if (arch.GetTriple().isAArch64()) {
623 for (const auto &reg : m_regs) {
624 if ((strcmp(reg.name, "vg") == 0) || (strcmp(reg.name, "svg") == 0)) {
625 m_is_reconfigurable = true;
626 break;
627 }
628 }
629 }
630}
631
633 // We are going to create a map between remote (eRegisterKindProcessPlugin)
634 // and local (eRegisterKindLLDB) register numbers. This map will give us
635 // remote register numbers in increasing order for offset calculation.
636 std::map<uint32_t, uint32_t> remote_to_local_regnum_map;
637 for (const auto &reg : m_regs)
638 remote_to_local_regnum_map[reg.kinds[eRegisterKindProcessPlugin]] =
639 reg.kinds[eRegisterKindLLDB];
640
641 // At this stage we manually calculate g/G packet offsets of all primary
642 // registers, only if target XML or qRegisterInfo packet did not send
643 // an offset explicitly.
644 uint32_t reg_offset = 0;
645 for (auto const &regnum_pair : remote_to_local_regnum_map) {
646 if (m_regs[regnum_pair.second].byte_offset == LLDB_INVALID_INDEX32 &&
647 m_regs[regnum_pair.second].value_regs == nullptr) {
648 m_regs[regnum_pair.second].byte_offset = reg_offset;
649
650 reg_offset = m_regs[regnum_pair.second].byte_offset +
651 m_regs[regnum_pair.second].byte_size;
652 }
653 }
654
655 // Now update all value_regs with each register info as needed
656 for (auto &reg : m_regs) {
657 if (reg.value_regs != nullptr) {
658 // Assign a valid offset to all pseudo registers that have only a single
659 // parent register in value_regs list, if not assigned by stub. Pseudo
660 // registers with value_regs list populated will share same offset as
661 // that of their corresponding parent register.
662 if (reg.byte_offset == LLDB_INVALID_INDEX32) {
663 uint32_t value_regnum = reg.value_regs[0];
664 if (value_regnum != LLDB_INVALID_INDEX32 &&
665 reg.value_regs[1] == LLDB_INVALID_INDEX32) {
666 reg.byte_offset =
667 GetRegisterInfoAtIndex(value_regnum)->byte_offset;
668 auto it = m_value_reg_offset_map.find(reg.kinds[eRegisterKindLLDB]);
669 if (it != m_value_reg_offset_map.end())
670 reg.byte_offset += it->second;
671 }
672 }
673 }
674
675 reg_offset = reg.byte_offset + reg.byte_size;
676 if (m_reg_data_byte_size < reg_offset)
677 m_reg_data_byte_size = reg_offset;
678 }
679}
680
682
683size_t DynamicRegisterInfo::GetNumRegisters() const { return m_regs.size(); }
684
685size_t DynamicRegisterInfo::GetNumRegisterSets() const { return m_sets.size(); }
686
689}
690
691const RegisterInfo *
693 if (i < m_regs.size())
694 return &m_regs[i];
695 return nullptr;
696}
697
699 uint32_t num) const {
700 uint32_t reg_index = ConvertRegisterKindToRegisterNumber(kind, num);
701 if (reg_index != LLDB_INVALID_REGNUM)
702 return &m_regs[reg_index];
703 return nullptr;
704}
705
707 if (i < m_sets.size())
708 return &m_sets[i];
709 return nullptr;
710}
711
712uint32_t
714 bool can_create) {
715 name_collection::iterator pos, end = m_set_names.end();
716 for (pos = m_set_names.begin(); pos != end; ++pos) {
717 if (*pos == set_name)
718 return std::distance(m_set_names.begin(), pos);
719 }
720
721 m_set_names.push_back(set_name);
722 m_set_reg_nums.resize(m_set_reg_nums.size() + 1);
723 RegisterSet new_set = {set_name.AsCString(), nullptr, 0, nullptr};
724 m_sets.push_back(new_set);
725 return m_sets.size() - 1;
726}
727
728uint32_t
730 uint32_t num) const {
731 reg_collection::const_iterator pos, end = m_regs.end();
732 for (pos = m_regs.begin(); pos != end; ++pos) {
733 if (pos->kinds[kind] == num)
734 return std::distance(m_regs.begin(), pos);
735 }
736
737 return LLDB_INVALID_REGNUM;
738}
739
741 m_regs.clear();
742 m_sets.clear();
743 m_set_reg_nums.clear();
744 m_set_names.clear();
745 m_value_regs_map.clear();
746 m_invalidate_regs_map.clear();
748 m_finalized = false;
749}
750
752 StreamFile s(stdout, false);
753 const size_t num_regs = m_regs.size();
754 s.Printf("%p: DynamicRegisterInfo contains %" PRIu64 " registers:\n",
755 static_cast<const void *>(this), static_cast<uint64_t>(num_regs));
756 for (size_t i = 0; i < num_regs; ++i) {
757 s.Printf("[%3" PRIu64 "] name = %-10s", (uint64_t)i, m_regs[i].name);
758 s.Printf(", size = %2u, offset = %4u, encoding = %u, format = %-10s",
759 m_regs[i].byte_size, m_regs[i].byte_offset, m_regs[i].encoding,
762 s.Printf(", process plugin = %3u",
765 s.Printf(", dwarf = %3u", m_regs[i].kinds[eRegisterKindDWARF]);
767 s.Printf(", ehframe = %3u", m_regs[i].kinds[eRegisterKindEHFrame]);
769 s.Printf(", generic = %3u", m_regs[i].kinds[eRegisterKindGeneric]);
770 if (m_regs[i].alt_name)
771 s.Printf(", alt-name = %s", m_regs[i].alt_name);
772 if (m_regs[i].value_regs) {
773 s.Printf(", value_regs = [ ");
774 for (size_t j = 0; m_regs[i].value_regs[j] != LLDB_INVALID_REGNUM; ++j) {
775 s.Printf("%s ", m_regs[m_regs[i].value_regs[j]].name);
776 }
777 s.Printf("]");
778 }
779 if (m_regs[i].invalidate_regs) {
780 s.Printf(", invalidate_regs = [ ");
781 for (size_t j = 0; m_regs[i].invalidate_regs[j] != LLDB_INVALID_REGNUM;
782 ++j) {
783 s.Printf("%s ", m_regs[m_regs[i].invalidate_regs[j]].name);
784 }
785 s.Printf("]");
786 }
787 s.EOL();
788 }
789
790 const size_t num_sets = m_sets.size();
791 s.Printf("%p: DynamicRegisterInfo contains %" PRIu64 " register sets:\n",
792 static_cast<const void *>(this), static_cast<uint64_t>(num_sets));
793 for (size_t i = 0; i < num_sets; ++i) {
794 s.Printf("set[%" PRIu64 "] name = %s, regs = [", (uint64_t)i,
795 m_sets[i].name);
796 for (size_t idx = 0; idx < m_sets[i].num_registers; ++idx) {
797 s.Printf("%s ", m_regs[m_sets[i].registers[idx]].name);
798 }
799 s.Printf("]\n");
800 }
801}
802
804DynamicRegisterInfo::GetRegisterInfo(llvm::StringRef reg_name) const {
805 for (auto &reg_info : m_regs)
806 if (reg_info.name == reg_name)
807 return &reg_info;
808 return nullptr;
809}
810
812 std::vector<DynamicRegisterInfo::Register> &regs,
813 DynamicRegisterInfo::Register new_reg_info) {
814 assert(!new_reg_info.value_regs.empty());
815 const uint32_t reg_num = regs.size();
816 regs.push_back(new_reg_info);
817
818 std::map<uint32_t, std::vector<uint32_t>> new_invalidates;
819 for (uint32_t value_reg : new_reg_info.value_regs) {
820 // copy value_regs to invalidate_regs
821 new_invalidates[reg_num].push_back(value_reg);
822
823 // copy invalidate_regs from the parent register
824 llvm::append_range(new_invalidates[reg_num],
825 regs[value_reg].invalidate_regs);
826
827 // add reverse invalidate entries
828 for (uint32_t x : new_invalidates[reg_num])
829 new_invalidates[x].push_back(reg_num);
830 }
831
832 for (const auto &x : new_invalidates)
833 llvm::append_range(regs[x.first].invalidate_regs, x.second);
834}
#define LLDB_LOG_ERROR(log, error,...)
Definition: Log.h:382
An architecture specification class.
Definition: ArchSpec.h:31
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:450
lldb::ByteOrder GetByteOrder() const
Returns the byte order for the architecture specification.
Definition: ArchSpec.cpp:738
llvm::Triple::ArchType GetMachine() const
Returns a machine family for the current architecture.
Definition: ArchSpec.cpp:683
static lldb::Encoding StringToEncoding(llvm::StringRef s, lldb::Encoding fail_value=lldb::eEncodingInvalid)
Definition: Args.cpp:421
static uint32_t StringToGenericRegister(llvm::StringRef s)
Definition: Args.cpp:431
A uniqued constant string class.
Definition: ConstString.h:40
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:188
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:216
size_t SetRegisterInfo(const lldb_private::StructuredData::Dictionary &dict, const lldb_private::ArchSpec &arch)
std::vector< uint32_t > reg_num_collection
const lldb_private::RegisterSet * GetRegisterSet(uint32_t i) const
const lldb_private::RegisterInfo * GetRegisterInfoAtIndex(uint32_t i) const
uint32_t ConvertRegisterKindToRegisterNumber(uint32_t kind, uint32_t num) const
static std::unique_ptr< DynamicRegisterInfo > Create(const StructuredData::Dictionary &dict, const ArchSpec &arch)
llvm::Expected< uint32_t > ByteOffsetFromComposite(uint32_t index, lldb_private::StructuredData::Array &composite_reg_list, lldb::ByteOrder byte_order)
void Finalize(const lldb_private::ArchSpec &arch)
void MoveFrom(DynamicRegisterInfo &&info)
llvm::Expected< uint32_t > ByteOffsetFromSlice(uint32_t index, llvm::StringRef slice_str, lldb::ByteOrder byte_order)
uint32_t GetRegisterSetIndexByName(const lldb_private::ConstString &set_name, bool can_create)
const lldb_private::RegisterInfo * GetRegisterInfo(uint32_t kind, uint32_t num) const
DynamicRegisterInfo & operator=(DynamicRegisterInfo &)=default
llvm::Expected< uint32_t > ByteOffsetFromRegInfoDict(uint32_t index, lldb_private::StructuredData::Dictionary &reg_info_dict, lldb::ByteOrder byte_order)
static const char * GetFormatAsCString(lldb::Format format)
bool Fail() const
Test for error condition.
Definition: Status.cpp:180
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:134
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:155
std::optional< IntType > GetItemAtIndexAsInteger(size_t idx) const
std::optional< Dictionary * > GetItemAtIndexAsDictionary(size_t idx) const
Retrieves the element at index idx from a StructuredData::Array if it is a Dictionary.
std::optional< llvm::StringRef > GetItemAtIndexAsString(size_t idx) const
bool GetValueForKeyAsInteger(llvm::StringRef key, IntType &result) const
bool GetValueForKeyAsString(llvm::StringRef key, llvm::StringRef &result) const
bool GetValueForKeyAsArray(llvm::StringRef key, Array *&result) const
void DumpToStdout(bool pretty_print=true) const
#define LLDB_REGNUM_GENERIC_RA
Definition: lldb-defines.h:59
#define UINT64_MAX
Definition: lldb-defines.h:23
#define LLDB_INVALID_INDEX32
Definition: lldb-defines.h:83
#define LLDB_REGNUM_GENERIC_SP
Definition: lldb-defines.h:57
#define LLDB_REGNUM_GENERIC_FLAGS
Definition: lldb-defines.h:60
#define UINT32_MAX
Definition: lldb-defines.h:19
#define LLDB_INVALID_REGNUM
Definition: lldb-defines.h:87
#define LLDB_REGNUM_GENERIC_PC
Definition: lldb-defines.h:56
#define LLDB_REGNUM_GENERIC_FP
Definition: lldb-defines.h:58
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:331
void addSupplementaryRegister(std::vector< DynamicRegisterInfo::Register > &regs, DynamicRegisterInfo::Register new_reg_info)
Definition: SBAddress.h:15
@ eEncodingUint
unsigned integer
ByteOrder
Byte ordering definitions.
@ eByteOrderLittle
@ eRegisterKindGeneric
insn ptr reg, stack ptr reg, etc not specific to any particular target
@ eRegisterKindLLDB
lldb's internal register numbers
@ eRegisterKindDWARF
the register numbers seen DWARF
@ eRegisterKindEHFrame
the register numbers seen in eh_frame
@ eRegisterKindProcessPlugin
num used by the process plugin - e.g.
static Status ToFormat(const char *s, lldb::Format &format, size_t *byte_size_ptr)
Every register is described in detail including its name, alternate name (optional),...
lldb::Encoding encoding
Encoding of the register bits.
const char * alt_name
Alternate name of this register, can be NULL.
uint32_t byte_offset
The byte offset in the register context data where this register's value is found.
uint32_t byte_size
Size in bytes of the register.
uint32_t kinds[lldb::kNumRegisterKinds]
Holds all of the various register numbers for all register kinds.
const char * name
Name of this register, can't be NULL.
lldb::Format format
Default display format.
Registers are grouped into register sets.