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
9 #include "lldb/Target/DynamicRegisterInfo.h"
10 #include "lldb/DataFormatters/FormatManager.h"
11 #include "lldb/Host/StreamFile.h"
12 #include "lldb/Interpreter/OptionArgParser.h"
13 #include "lldb/Utility/ArchSpec.h"
14 #include "lldb/Utility/LLDBLog.h"
15 #include "lldb/Utility/Log.h"
16 #include "lldb/Utility/RegularExpression.h"
17 #include "lldb/Utility/StringExtractor.h"
18 #include "lldb/Utility/StructuredData.h"
19
20 using namespace lldb;
21 using namespace lldb_private;
22
23 std::unique_ptr<DynamicRegisterInfo>
Create(const StructuredData::Dictionary & dict,const ArchSpec & arch)24 DynamicRegisterInfo::Create(const StructuredData::Dictionary &dict,
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
DynamicRegisterInfo(DynamicRegisterInfo && info)36 DynamicRegisterInfo::DynamicRegisterInfo(DynamicRegisterInfo &&info) {
37 MoveFrom(std::move(info));
38 }
39
40 DynamicRegisterInfo &
operator =(DynamicRegisterInfo && info)41 DynamicRegisterInfo::operator=(DynamicRegisterInfo &&info) {
42 MoveFrom(std::move(info));
43 return *this;
44 }
45
MoveFrom(DynamicRegisterInfo && info)46 void DynamicRegisterInfo::MoveFrom(DynamicRegisterInfo &&info) {
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
ByteOffsetFromSlice(uint32_t index,llvm::StringRef slice_str,lldb::ByteOrder byte_order)66 llvm::Expected<uint32_t> DynamicRegisterInfo::ByteOffsetFromSlice(
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
ByteOffsetFromComposite(uint32_t index,StructuredData::Array & composite_reg_list,lldb::ByteOrder byte_order)136 llvm::Expected<uint32_t> DynamicRegisterInfo::ByteOffsetFromComposite(
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
ByteOffsetFromRegInfoDict(uint32_t index,StructuredData::Dictionary & reg_info_dict,lldb::ByteOrder byte_order)176 llvm::Expected<uint32_t> DynamicRegisterInfo::ByteOffsetFromRegInfoDict(
177 uint32_t index, StructuredData::Dictionary ®_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
200 size_t
SetRegisterInfo(const StructuredData::Dictionary & dict,const ArchSpec & arch)201 DynamicRegisterInfo::SetRegisterInfo(const StructuredData::Dictionary &dict,
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 =
235 regs->GetItemAtIndexAsDictionary(i);
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(®_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,
310 eEncodingUint);
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;
325 reg_info.kinds[lldb::eRegisterKindProcessPlugin] = i;
326 uint32_t eh_frame_regno = LLDB_INVALID_REGNUM;
327 reg_info_dict->GetValueForKeyAsInteger("gcc", eh_frame_regno,
328 LLDB_INVALID_REGNUM);
329 if (eh_frame_regno == LLDB_INVALID_REGNUM)
330 reg_info_dict->GetValueForKeyAsInteger("ehframe", eh_frame_regno,
331 LLDB_INVALID_REGNUM);
332 reg_info.kinds[lldb::eRegisterKindEHFrame] = eh_frame_regno;
333 reg_info_dict->GetValueForKeyAsInteger(
334 "dwarf", reg_info.kinds[lldb::eRegisterKindDWARF], LLDB_INVALID_REGNUM);
335 llvm::StringRef generic_str;
336 if (reg_info_dict->GetValueForKeyAsString("generic", generic_str))
337 reg_info.kinds[lldb::eRegisterKindGeneric] =
338 Args::StringToGenericRegister(generic_str);
339 else
340 reg_info_dict->GetValueForKeyAsInteger(
341 "generic", reg_info.kinds[lldb::eRegisterKindGeneric],
342 LLDB_INVALID_REGNUM);
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
SetRegisterInfo(std::vector<DynamicRegisterInfo::Register> && regs,const ArchSpec & arch)396 size_t DynamicRegisterInfo::SetRegisterInfo(
397 std::vector<DynamicRegisterInfo::Register> &®s,
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 ® = 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,
420 {reg.regnum_ehframe, reg.regnum_dwarf, reg.regnum_generic,
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
Finalize(const ArchSpec & arch)439 void DynamicRegisterInfo::Finalize(const ArchSpec &arch) {
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 ® : 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 ® : m_regs) {
534 if (strcmp(reg.name, "pc") == 0)
535 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC;
536 else if ((strcmp(reg.name, "fp") == 0) ||
537 (strcmp(reg.name, "x29") == 0))
538 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
539 else if ((strcmp(reg.name, "lr") == 0) ||
540 (strcmp(reg.name, "x30") == 0))
541 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_RA;
542 else if ((strcmp(reg.name, "sp") == 0) ||
543 (strcmp(reg.name, "x31") == 0))
544 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP;
545 else if (strcmp(reg.name, "cpsr") == 0)
546 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS;
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 ® : m_regs) {
555 if ((strcmp(reg.name, "pc") == 0) || (strcmp(reg.name, "r15") == 0))
556 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC;
557 else if ((strcmp(reg.name, "sp") == 0) ||
558 (strcmp(reg.name, "r13") == 0))
559 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP;
560 else if ((strcmp(reg.name, "lr") == 0) ||
561 (strcmp(reg.name, "r14") == 0))
562 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_RA;
563 else if ((strcmp(reg.name, "r7") == 0) &&
564 arch.GetTriple().getVendor() == llvm::Triple::Apple)
565 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
566 else if ((strcmp(reg.name, "r11") == 0) &&
567 arch.GetTriple().getVendor() != llvm::Triple::Apple)
568 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
569 else if (strcmp(reg.name, "fp") == 0)
570 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
571 else if (strcmp(reg.name, "cpsr") == 0)
572 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS;
573 }
574 break;
575
576 case llvm::Triple::x86:
577 for (auto ® : m_regs) {
578 if ((strcmp(reg.name, "eip") == 0) || (strcmp(reg.name, "pc") == 0))
579 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC;
580 else if ((strcmp(reg.name, "esp") == 0) ||
581 (strcmp(reg.name, "sp") == 0))
582 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP;
583 else if ((strcmp(reg.name, "ebp") == 0) ||
584 (strcmp(reg.name, "fp") == 0))
585 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
586 else if ((strcmp(reg.name, "eflags") == 0) ||
587 (strcmp(reg.name, "flags") == 0))
588 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS;
589 }
590 break;
591
592 case llvm::Triple::x86_64:
593 for (auto ® : m_regs) {
594 if ((strcmp(reg.name, "rip") == 0) || (strcmp(reg.name, "pc") == 0))
595 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC;
596 else if ((strcmp(reg.name, "rsp") == 0) ||
597 (strcmp(reg.name, "sp") == 0))
598 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP;
599 else if ((strcmp(reg.name, "rbp") == 0) ||
600 (strcmp(reg.name, "fp") == 0))
601 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
602 else if ((strcmp(reg.name, "rflags") == 0) ||
603 (strcmp(reg.name, "eflags") == 0) ||
604 (strcmp(reg.name, "flags") == 0))
605 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS;
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.
617 ConfigureOffsets();
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 ® : 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
ConfigureOffsets()632 void DynamicRegisterInfo::ConfigureOffsets() {
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 ® : 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 ®num_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 ® : 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
IsReconfigurable()681 bool DynamicRegisterInfo::IsReconfigurable() { return m_is_reconfigurable; }
682
GetNumRegisters() const683 size_t DynamicRegisterInfo::GetNumRegisters() const { return m_regs.size(); }
684
GetNumRegisterSets() const685 size_t DynamicRegisterInfo::GetNumRegisterSets() const { return m_sets.size(); }
686
GetRegisterDataByteSize() const687 size_t DynamicRegisterInfo::GetRegisterDataByteSize() const {
688 return m_reg_data_byte_size;
689 }
690
691 const RegisterInfo *
GetRegisterInfoAtIndex(uint32_t i) const692 DynamicRegisterInfo::GetRegisterInfoAtIndex(uint32_t i) const {
693 if (i < m_regs.size())
694 return &m_regs[i];
695 return nullptr;
696 }
697
GetRegisterInfo(uint32_t kind,uint32_t num) const698 const RegisterInfo *DynamicRegisterInfo::GetRegisterInfo(uint32_t kind,
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
GetRegisterSet(uint32_t i) const706 const RegisterSet *DynamicRegisterInfo::GetRegisterSet(uint32_t i) const {
707 if (i < m_sets.size())
708 return &m_sets[i];
709 return nullptr;
710 }
711
712 uint32_t
GetRegisterSetIndexByName(const ConstString & set_name,bool can_create)713 DynamicRegisterInfo::GetRegisterSetIndexByName(const ConstString &set_name,
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
728 uint32_t
ConvertRegisterKindToRegisterNumber(uint32_t kind,uint32_t num) const729 DynamicRegisterInfo::ConvertRegisterKindToRegisterNumber(uint32_t kind,
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
Clear()740 void DynamicRegisterInfo::Clear() {
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();
747 m_reg_data_byte_size = 0;
748 m_finalized = false;
749 }
750
Dump() const751 void DynamicRegisterInfo::Dump() const {
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,
760 FormatManager::GetFormatAsCString(m_regs[i].format));
761 if (m_regs[i].kinds[eRegisterKindProcessPlugin] != LLDB_INVALID_REGNUM)
762 s.Printf(", process plugin = %3u",
763 m_regs[i].kinds[eRegisterKindProcessPlugin]);
764 if (m_regs[i].kinds[eRegisterKindDWARF] != LLDB_INVALID_REGNUM)
765 s.Printf(", dwarf = %3u", m_regs[i].kinds[eRegisterKindDWARF]);
766 if (m_regs[i].kinds[eRegisterKindEHFrame] != LLDB_INVALID_REGNUM)
767 s.Printf(", ehframe = %3u", m_regs[i].kinds[eRegisterKindEHFrame]);
768 if (m_regs[i].kinds[eRegisterKindGeneric] != LLDB_INVALID_REGNUM)
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
803 const lldb_private::RegisterInfo *
GetRegisterInfo(llvm::StringRef reg_name) const804 DynamicRegisterInfo::GetRegisterInfo(llvm::StringRef reg_name) const {
805 for (auto ®_info : m_regs)
806 if (reg_info.name == reg_name)
807 return ®_info;
808 return nullptr;
809 }
810
addSupplementaryRegister(std::vector<DynamicRegisterInfo::Register> & regs,DynamicRegisterInfo::Register new_reg_info)811 void lldb_private::addSupplementaryRegister(
812 std::vector<DynamicRegisterInfo::Register> ®s,
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 }
835