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> 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 36 DynamicRegisterInfo::DynamicRegisterInfo(DynamicRegisterInfo &&info) { 37 MoveFrom(std::move(info)); 38 } 39 40 DynamicRegisterInfo & 41 DynamicRegisterInfo::operator=(DynamicRegisterInfo &&info) { 42 MoveFrom(std::move(info)); 43 return *this; 44 } 45 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 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 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 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 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 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 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 (auto it = m_value_regs_map.find(i); it != m_value_regs_map.end()) 464 m_regs[i].value_regs = it->second.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 (auto it = m_invalidate_regs_map.find(i); 513 it != m_invalidate_regs_map.end()) 514 m_regs[i].invalidate_regs = it->second.data(); 515 else 516 m_regs[i].invalidate_regs = nullptr; 517 } 518 519 // Check if we need to automatically set the generic registers in case they 520 // weren't set 521 bool generic_regs_specified = false; 522 for (const auto ® : m_regs) { 523 if (reg.kinds[eRegisterKindGeneric] != LLDB_INVALID_REGNUM) { 524 generic_regs_specified = true; 525 break; 526 } 527 } 528 529 if (!generic_regs_specified) { 530 switch (arch.GetMachine()) { 531 case llvm::Triple::aarch64: 532 case llvm::Triple::aarch64_32: 533 case llvm::Triple::aarch64_be: 534 for (auto ® : m_regs) { 535 if (strcmp(reg.name, "pc") == 0) 536 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC; 537 else if ((strcmp(reg.name, "fp") == 0) || 538 (strcmp(reg.name, "x29") == 0)) 539 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP; 540 else if ((strcmp(reg.name, "lr") == 0) || 541 (strcmp(reg.name, "x30") == 0)) 542 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_RA; 543 else if ((strcmp(reg.name, "sp") == 0) || 544 (strcmp(reg.name, "x31") == 0)) 545 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP; 546 else if (strcmp(reg.name, "cpsr") == 0) 547 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS; 548 } 549 break; 550 551 case llvm::Triple::arm: 552 case llvm::Triple::armeb: 553 case llvm::Triple::thumb: 554 case llvm::Triple::thumbeb: 555 for (auto ® : m_regs) { 556 if ((strcmp(reg.name, "pc") == 0) || (strcmp(reg.name, "r15") == 0)) 557 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC; 558 else if ((strcmp(reg.name, "sp") == 0) || 559 (strcmp(reg.name, "r13") == 0)) 560 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP; 561 else if ((strcmp(reg.name, "lr") == 0) || 562 (strcmp(reg.name, "r14") == 0)) 563 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_RA; 564 else if ((strcmp(reg.name, "r7") == 0) && 565 arch.GetTriple().getVendor() == llvm::Triple::Apple) 566 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP; 567 else if ((strcmp(reg.name, "r11") == 0) && 568 arch.GetTriple().getVendor() != llvm::Triple::Apple) 569 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP; 570 else if (strcmp(reg.name, "fp") == 0) 571 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP; 572 else if (strcmp(reg.name, "cpsr") == 0) 573 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS; 574 } 575 break; 576 577 case llvm::Triple::x86: 578 for (auto ® : m_regs) { 579 if ((strcmp(reg.name, "eip") == 0) || (strcmp(reg.name, "pc") == 0)) 580 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC; 581 else if ((strcmp(reg.name, "esp") == 0) || 582 (strcmp(reg.name, "sp") == 0)) 583 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP; 584 else if ((strcmp(reg.name, "ebp") == 0) || 585 (strcmp(reg.name, "fp") == 0)) 586 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP; 587 else if ((strcmp(reg.name, "eflags") == 0) || 588 (strcmp(reg.name, "flags") == 0)) 589 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS; 590 } 591 break; 592 593 case llvm::Triple::x86_64: 594 for (auto ® : m_regs) { 595 if ((strcmp(reg.name, "rip") == 0) || (strcmp(reg.name, "pc") == 0)) 596 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC; 597 else if ((strcmp(reg.name, "rsp") == 0) || 598 (strcmp(reg.name, "sp") == 0)) 599 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP; 600 else if ((strcmp(reg.name, "rbp") == 0) || 601 (strcmp(reg.name, "fp") == 0)) 602 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP; 603 else if ((strcmp(reg.name, "rflags") == 0) || 604 (strcmp(reg.name, "eflags") == 0) || 605 (strcmp(reg.name, "flags") == 0)) 606 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS; 607 } 608 break; 609 610 default: 611 break; 612 } 613 } 614 615 // At this stage call ConfigureOffsets to calculate register offsets for 616 // targets supporting dynamic offset calculation. It also calculates 617 // total byte size of register data. 618 ConfigureOffsets(); 619 620 // Check if register info is reconfigurable 621 // AArch64 SVE register set has configurable register sizes, as does the ZA 622 // register that SME added (the streaming state of SME reuses the SVE state). 623 if (arch.GetTriple().isAArch64()) { 624 for (const auto ® : m_regs) { 625 if ((strcmp(reg.name, "vg") == 0) || (strcmp(reg.name, "svg") == 0)) { 626 m_is_reconfigurable = true; 627 break; 628 } 629 } 630 } 631 } 632 633 void DynamicRegisterInfo::ConfigureOffsets() { 634 // We are going to create a map between remote (eRegisterKindProcessPlugin) 635 // and local (eRegisterKindLLDB) register numbers. This map will give us 636 // remote register numbers in increasing order for offset calculation. 637 std::map<uint32_t, uint32_t> remote_to_local_regnum_map; 638 for (const auto ® : m_regs) 639 remote_to_local_regnum_map[reg.kinds[eRegisterKindProcessPlugin]] = 640 reg.kinds[eRegisterKindLLDB]; 641 642 // At this stage we manually calculate g/G packet offsets of all primary 643 // registers, only if target XML or qRegisterInfo packet did not send 644 // an offset explicitly. 645 uint32_t reg_offset = 0; 646 for (auto const ®num_pair : remote_to_local_regnum_map) { 647 if (m_regs[regnum_pair.second].byte_offset == LLDB_INVALID_INDEX32 && 648 m_regs[regnum_pair.second].value_regs == nullptr) { 649 m_regs[regnum_pair.second].byte_offset = reg_offset; 650 651 reg_offset = m_regs[regnum_pair.second].byte_offset + 652 m_regs[regnum_pair.second].byte_size; 653 } 654 } 655 656 // Now update all value_regs with each register info as needed 657 for (auto ® : m_regs) { 658 if (reg.value_regs != nullptr) { 659 // Assign a valid offset to all pseudo registers that have only a single 660 // parent register in value_regs list, if not assigned by stub. Pseudo 661 // registers with value_regs list populated will share same offset as 662 // that of their corresponding parent register. 663 if (reg.byte_offset == LLDB_INVALID_INDEX32) { 664 uint32_t value_regnum = reg.value_regs[0]; 665 if (value_regnum != LLDB_INVALID_INDEX32 && 666 reg.value_regs[1] == LLDB_INVALID_INDEX32) { 667 reg.byte_offset = 668 GetRegisterInfoAtIndex(value_regnum)->byte_offset; 669 auto it = m_value_reg_offset_map.find(reg.kinds[eRegisterKindLLDB]); 670 if (it != m_value_reg_offset_map.end()) 671 reg.byte_offset += it->second; 672 } 673 } 674 } 675 676 reg_offset = reg.byte_offset + reg.byte_size; 677 if (m_reg_data_byte_size < reg_offset) 678 m_reg_data_byte_size = reg_offset; 679 } 680 } 681 682 bool DynamicRegisterInfo::IsReconfigurable() { return m_is_reconfigurable; } 683 684 size_t DynamicRegisterInfo::GetNumRegisters() const { return m_regs.size(); } 685 686 size_t DynamicRegisterInfo::GetNumRegisterSets() const { return m_sets.size(); } 687 688 size_t DynamicRegisterInfo::GetRegisterDataByteSize() const { 689 return m_reg_data_byte_size; 690 } 691 692 const RegisterInfo * 693 DynamicRegisterInfo::GetRegisterInfoAtIndex(uint32_t i) const { 694 if (i < m_regs.size()) 695 return &m_regs[i]; 696 return nullptr; 697 } 698 699 const RegisterInfo *DynamicRegisterInfo::GetRegisterInfo(uint32_t kind, 700 uint32_t num) const { 701 uint32_t reg_index = ConvertRegisterKindToRegisterNumber(kind, num); 702 if (reg_index != LLDB_INVALID_REGNUM) 703 return &m_regs[reg_index]; 704 return nullptr; 705 } 706 707 const RegisterSet *DynamicRegisterInfo::GetRegisterSet(uint32_t i) const { 708 if (i < m_sets.size()) 709 return &m_sets[i]; 710 return nullptr; 711 } 712 713 uint32_t 714 DynamicRegisterInfo::GetRegisterSetIndexByName(const ConstString &set_name, 715 bool can_create) { 716 name_collection::iterator pos, end = m_set_names.end(); 717 for (pos = m_set_names.begin(); pos != end; ++pos) { 718 if (*pos == set_name) 719 return std::distance(m_set_names.begin(), pos); 720 } 721 722 m_set_names.push_back(set_name); 723 m_set_reg_nums.resize(m_set_reg_nums.size() + 1); 724 RegisterSet new_set = {set_name.AsCString(), nullptr, 0, nullptr}; 725 m_sets.push_back(new_set); 726 return m_sets.size() - 1; 727 } 728 729 uint32_t 730 DynamicRegisterInfo::ConvertRegisterKindToRegisterNumber(uint32_t kind, 731 uint32_t num) const { 732 reg_collection::const_iterator pos, end = m_regs.end(); 733 for (pos = m_regs.begin(); pos != end; ++pos) { 734 if (pos->kinds[kind] == num) 735 return std::distance(m_regs.begin(), pos); 736 } 737 738 return LLDB_INVALID_REGNUM; 739 } 740 741 void DynamicRegisterInfo::Clear() { 742 m_regs.clear(); 743 m_sets.clear(); 744 m_set_reg_nums.clear(); 745 m_set_names.clear(); 746 m_value_regs_map.clear(); 747 m_invalidate_regs_map.clear(); 748 m_reg_data_byte_size = 0; 749 m_finalized = false; 750 } 751 752 void DynamicRegisterInfo::Dump() const { 753 StreamFile s(stdout, false); 754 const size_t num_regs = m_regs.size(); 755 s.Printf("%p: DynamicRegisterInfo contains %" PRIu64 " registers:\n", 756 static_cast<const void *>(this), static_cast<uint64_t>(num_regs)); 757 for (size_t i = 0; i < num_regs; ++i) { 758 s.Printf("[%3" PRIu64 "] name = %-10s", (uint64_t)i, m_regs[i].name); 759 s.Printf(", size = %2u, offset = %4u, encoding = %u, format = %-10s", 760 m_regs[i].byte_size, m_regs[i].byte_offset, m_regs[i].encoding, 761 FormatManager::GetFormatAsCString(m_regs[i].format)); 762 if (m_regs[i].kinds[eRegisterKindProcessPlugin] != LLDB_INVALID_REGNUM) 763 s.Printf(", process plugin = %3u", 764 m_regs[i].kinds[eRegisterKindProcessPlugin]); 765 if (m_regs[i].kinds[eRegisterKindDWARF] != LLDB_INVALID_REGNUM) 766 s.Printf(", dwarf = %3u", m_regs[i].kinds[eRegisterKindDWARF]); 767 if (m_regs[i].kinds[eRegisterKindEHFrame] != LLDB_INVALID_REGNUM) 768 s.Printf(", ehframe = %3u", m_regs[i].kinds[eRegisterKindEHFrame]); 769 if (m_regs[i].kinds[eRegisterKindGeneric] != LLDB_INVALID_REGNUM) 770 s.Printf(", generic = %3u", m_regs[i].kinds[eRegisterKindGeneric]); 771 if (m_regs[i].alt_name) 772 s.Printf(", alt-name = %s", m_regs[i].alt_name); 773 if (m_regs[i].value_regs) { 774 s.Printf(", value_regs = [ "); 775 for (size_t j = 0; m_regs[i].value_regs[j] != LLDB_INVALID_REGNUM; ++j) { 776 s.Printf("%s ", m_regs[m_regs[i].value_regs[j]].name); 777 } 778 s.Printf("]"); 779 } 780 if (m_regs[i].invalidate_regs) { 781 s.Printf(", invalidate_regs = [ "); 782 for (size_t j = 0; m_regs[i].invalidate_regs[j] != LLDB_INVALID_REGNUM; 783 ++j) { 784 s.Printf("%s ", m_regs[m_regs[i].invalidate_regs[j]].name); 785 } 786 s.Printf("]"); 787 } 788 s.EOL(); 789 } 790 791 const size_t num_sets = m_sets.size(); 792 s.Printf("%p: DynamicRegisterInfo contains %" PRIu64 " register sets:\n", 793 static_cast<const void *>(this), static_cast<uint64_t>(num_sets)); 794 for (size_t i = 0; i < num_sets; ++i) { 795 s.Printf("set[%" PRIu64 "] name = %s, regs = [", (uint64_t)i, 796 m_sets[i].name); 797 for (size_t idx = 0; idx < m_sets[i].num_registers; ++idx) { 798 s.Printf("%s ", m_regs[m_sets[i].registers[idx]].name); 799 } 800 s.Printf("]\n"); 801 } 802 } 803 804 const lldb_private::RegisterInfo * 805 DynamicRegisterInfo::GetRegisterInfo(llvm::StringRef reg_name) const { 806 for (auto ®_info : m_regs) 807 if (reg_info.name == reg_name) 808 return ®_info; 809 return nullptr; 810 } 811 812 void lldb_private::addSupplementaryRegister( 813 std::vector<DynamicRegisterInfo::Register> ®s, 814 DynamicRegisterInfo::Register new_reg_info) { 815 assert(!new_reg_info.value_regs.empty()); 816 const uint32_t reg_num = regs.size(); 817 regs.push_back(new_reg_info); 818 819 std::map<uint32_t, std::vector<uint32_t>> new_invalidates; 820 for (uint32_t value_reg : new_reg_info.value_regs) { 821 // copy value_regs to invalidate_regs 822 new_invalidates[reg_num].push_back(value_reg); 823 824 // copy invalidate_regs from the parent register 825 llvm::append_range(new_invalidates[reg_num], 826 regs[value_reg].invalidate_regs); 827 828 // add reverse invalidate entries 829 for (uint32_t x : new_invalidates[reg_num]) 830 new_invalidates[x].push_back(reg_num); 831 } 832 833 for (const auto &x : new_invalidates) 834 llvm::append_range(regs[x.first].invalidate_regs, x.second); 835 } 836