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/Core/StreamFile.h" 11 #include "lldb/DataFormatters/FormatManager.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 ConstString composite_reg_name; 148 if (!composite_reg_list.GetItemAtIndexAsString(composite_idx, 149 composite_reg_name, nullptr)) 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(composite_reg_name.GetStringRef()); 157 if (!composite_reg_info) 158 return llvm::createStringError( 159 llvm::inconvertibleErrorCode(), 160 "failed to find composite register by name: \"%s\"", 161 composite_reg_name.GetCString()); 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 ConstString set_name; 210 if (sets->GetItemAtIndexAsString(i, set_name) && !set_name.IsEmpty()) { 211 m_sets.push_back({set_name.AsCString(), nullptr, 0, nullptr}); 212 } else { 213 Clear(); 214 printf("error: register sets must have valid names\n"); 215 return 0; 216 } 217 } 218 m_set_reg_nums.resize(m_sets.size()); 219 } 220 221 StructuredData::Array *regs = nullptr; 222 if (!dict.GetValueForKeyAsArray("registers", regs)) 223 return 0; 224 225 const ByteOrder byte_order = arch.GetByteOrder(); 226 227 const uint32_t num_regs = regs->GetSize(); 228 // typedef std::map<std::string, std::vector<std::string> > 229 // InvalidateNameMap; 230 // InvalidateNameMap invalidate_map; 231 for (uint32_t i = 0; i < num_regs; ++i) { 232 StructuredData::Dictionary *reg_info_dict = nullptr; 233 if (!regs->GetItemAtIndexAsDictionary(i, reg_info_dict)) { 234 Clear(); 235 printf("error: items in the 'registers' array must be dictionaries\n"); 236 regs->DumpToStdout(); 237 return 0; 238 } 239 240 // { 'name':'rcx' , 'bitsize' : 64, 'offset' : 16, 241 // 'encoding':'uint' , 'format':'hex' , 'set': 0, 'ehframe' : 2, 242 // 'dwarf' : 2, 'generic':'arg4', 'alt-name':'arg4', }, 243 RegisterInfo reg_info; 244 std::vector<uint32_t> value_regs; 245 std::vector<uint32_t> invalidate_regs; 246 memset(®_info, 0, sizeof(reg_info)); 247 248 llvm::StringRef name_val; 249 if (!reg_info_dict->GetValueForKeyAsString("name", name_val)) { 250 Clear(); 251 printf("error: registers must have valid names and offsets\n"); 252 reg_info_dict->DumpToStdout(); 253 return 0; 254 } 255 reg_info.name = ConstString(name_val).GetCString(); 256 257 llvm::StringRef alt_name_val; 258 if (reg_info_dict->GetValueForKeyAsString("alt-name", alt_name_val)) 259 reg_info.alt_name = ConstString(alt_name_val).GetCString(); 260 else 261 reg_info.alt_name = nullptr; 262 263 llvm::Expected<uint32_t> byte_offset = 264 ByteOffsetFromRegInfoDict(i, *reg_info_dict, byte_order); 265 if (byte_offset) 266 reg_info.byte_offset = byte_offset.get(); 267 else { 268 LLDB_LOG_ERROR(log, byte_offset.takeError(), 269 "error while parsing register {1}: {0}", reg_info.name); 270 Clear(); 271 reg_info_dict->DumpToStdout(); 272 return 0; 273 } 274 275 uint64_t bitsize = 0; 276 if (!reg_info_dict->GetValueForKeyAsInteger("bitsize", bitsize)) { 277 Clear(); 278 printf("error: invalid or missing 'bitsize' key/value pair in register " 279 "dictionary\n"); 280 reg_info_dict->DumpToStdout(); 281 return 0; 282 } 283 284 reg_info.byte_size = bitsize / 8; 285 286 llvm::StringRef format_str; 287 if (reg_info_dict->GetValueForKeyAsString("format", format_str, nullptr)) { 288 if (OptionArgParser::ToFormat(format_str.str().c_str(), reg_info.format, 289 nullptr) 290 .Fail()) { 291 Clear(); 292 printf("error: invalid 'format' value in register dictionary\n"); 293 reg_info_dict->DumpToStdout(); 294 return 0; 295 } 296 } else { 297 reg_info_dict->GetValueForKeyAsInteger("format", reg_info.format, 298 eFormatHex); 299 } 300 301 llvm::StringRef encoding_str; 302 if (reg_info_dict->GetValueForKeyAsString("encoding", encoding_str)) 303 reg_info.encoding = Args::StringToEncoding(encoding_str, eEncodingUint); 304 else 305 reg_info_dict->GetValueForKeyAsInteger("encoding", reg_info.encoding, 306 eEncodingUint); 307 308 size_t set = 0; 309 if (!reg_info_dict->GetValueForKeyAsInteger("set", set) || 310 set >= m_sets.size()) { 311 Clear(); 312 printf("error: invalid 'set' value in register dictionary, valid values " 313 "are 0 - %i\n", 314 (int)set); 315 reg_info_dict->DumpToStdout(); 316 return 0; 317 } 318 319 // Fill in the register numbers 320 reg_info.kinds[lldb::eRegisterKindLLDB] = i; 321 reg_info.kinds[lldb::eRegisterKindProcessPlugin] = i; 322 uint32_t eh_frame_regno = LLDB_INVALID_REGNUM; 323 reg_info_dict->GetValueForKeyAsInteger("gcc", eh_frame_regno, 324 LLDB_INVALID_REGNUM); 325 if (eh_frame_regno == LLDB_INVALID_REGNUM) 326 reg_info_dict->GetValueForKeyAsInteger("ehframe", eh_frame_regno, 327 LLDB_INVALID_REGNUM); 328 reg_info.kinds[lldb::eRegisterKindEHFrame] = eh_frame_regno; 329 reg_info_dict->GetValueForKeyAsInteger( 330 "dwarf", reg_info.kinds[lldb::eRegisterKindDWARF], LLDB_INVALID_REGNUM); 331 llvm::StringRef generic_str; 332 if (reg_info_dict->GetValueForKeyAsString("generic", generic_str)) 333 reg_info.kinds[lldb::eRegisterKindGeneric] = 334 Args::StringToGenericRegister(generic_str); 335 else 336 reg_info_dict->GetValueForKeyAsInteger( 337 "generic", reg_info.kinds[lldb::eRegisterKindGeneric], 338 LLDB_INVALID_REGNUM); 339 340 // Check if this register invalidates any other register values when it is 341 // modified 342 StructuredData::Array *invalidate_reg_list = nullptr; 343 if (reg_info_dict->GetValueForKeyAsArray("invalidate-regs", 344 invalidate_reg_list)) { 345 const size_t num_regs = invalidate_reg_list->GetSize(); 346 if (num_regs > 0) { 347 for (uint32_t idx = 0; idx < num_regs; ++idx) { 348 ConstString invalidate_reg_name; 349 uint64_t invalidate_reg_num; 350 if (invalidate_reg_list->GetItemAtIndexAsString( 351 idx, invalidate_reg_name)) { 352 const RegisterInfo *invalidate_reg_info = 353 GetRegisterInfo(invalidate_reg_name.GetStringRef()); 354 if (invalidate_reg_info) { 355 m_invalidate_regs_map[i].push_back( 356 invalidate_reg_info->kinds[eRegisterKindLLDB]); 357 } else { 358 // TODO: print error invalid slice string that doesn't follow the 359 // format 360 printf("error: failed to find a 'invalidate-regs' register for " 361 "\"%s\" while parsing register \"%s\"\n", 362 invalidate_reg_name.GetCString(), reg_info.name); 363 } 364 } else if (invalidate_reg_list->GetItemAtIndexAsInteger( 365 idx, invalidate_reg_num)) { 366 if (invalidate_reg_num != UINT64_MAX) 367 m_invalidate_regs_map[i].push_back(invalidate_reg_num); 368 else 369 printf("error: 'invalidate-regs' list value wasn't a valid " 370 "integer\n"); 371 } else { 372 printf("error: 'invalidate-regs' list value wasn't a python string " 373 "or integer\n"); 374 } 375 } 376 } else { 377 printf("error: 'invalidate-regs' contained an empty list\n"); 378 } 379 } 380 381 // Calculate the register offset 382 const size_t end_reg_offset = reg_info.byte_offset + reg_info.byte_size; 383 if (m_reg_data_byte_size < end_reg_offset) 384 m_reg_data_byte_size = end_reg_offset; 385 386 m_regs.push_back(reg_info); 387 m_set_reg_nums[set].push_back(i); 388 } 389 Finalize(arch); 390 return m_regs.size(); 391 } 392 393 size_t DynamicRegisterInfo::SetRegisterInfo( 394 std::vector<DynamicRegisterInfo::Register> &®s, 395 const ArchSpec &arch) { 396 assert(!m_finalized); 397 398 for (auto it : llvm::enumerate(regs)) { 399 uint32_t local_regnum = it.index(); 400 const DynamicRegisterInfo::Register ® = it.value(); 401 402 assert(reg.name); 403 assert(reg.set_name); 404 405 if (!reg.value_regs.empty()) 406 m_value_regs_map[local_regnum] = std::move(reg.value_regs); 407 if (!reg.invalidate_regs.empty()) 408 m_invalidate_regs_map[local_regnum] = std::move(reg.invalidate_regs); 409 if (reg.value_reg_offset != 0) { 410 assert(reg.value_regs.size() == 1); 411 m_value_reg_offset_map[local_regnum] = reg.value_reg_offset; 412 } 413 414 struct RegisterInfo reg_info { 415 reg.name.AsCString(), reg.alt_name.AsCString(), reg.byte_size, 416 reg.byte_offset, reg.encoding, reg.format, 417 {reg.regnum_ehframe, reg.regnum_dwarf, reg.regnum_generic, 418 reg.regnum_remote, local_regnum}, 419 // value_regs and invalidate_regs are filled by Finalize() 420 nullptr, nullptr, reg.flags_type 421 }; 422 423 m_regs.push_back(reg_info); 424 425 uint32_t set = GetRegisterSetIndexByName(reg.set_name, true); 426 assert(set < m_sets.size()); 427 assert(set < m_set_reg_nums.size()); 428 assert(set < m_set_names.size()); 429 m_set_reg_nums[set].push_back(local_regnum); 430 }; 431 432 Finalize(arch); 433 return m_regs.size(); 434 } 435 436 void DynamicRegisterInfo::Finalize(const ArchSpec &arch) { 437 if (m_finalized) 438 return; 439 440 m_finalized = true; 441 const size_t num_sets = m_sets.size(); 442 for (size_t set = 0; set < num_sets; ++set) { 443 assert(m_sets.size() == m_set_reg_nums.size()); 444 m_sets[set].num_registers = m_set_reg_nums[set].size(); 445 m_sets[set].registers = m_set_reg_nums[set].data(); 446 } 447 448 // make sure value_regs are terminated with LLDB_INVALID_REGNUM 449 450 for (reg_to_regs_map::iterator pos = m_value_regs_map.begin(), 451 end = m_value_regs_map.end(); 452 pos != end; ++pos) { 453 if (pos->second.back() != LLDB_INVALID_REGNUM) 454 pos->second.push_back(LLDB_INVALID_REGNUM); 455 } 456 457 // Now update all value_regs with each register info as needed 458 const size_t num_regs = m_regs.size(); 459 for (size_t i = 0; i < num_regs; ++i) { 460 if (m_value_regs_map.find(i) != m_value_regs_map.end()) 461 m_regs[i].value_regs = m_value_regs_map[i].data(); 462 else 463 m_regs[i].value_regs = nullptr; 464 } 465 466 // Expand all invalidation dependencies 467 for (reg_to_regs_map::iterator pos = m_invalidate_regs_map.begin(), 468 end = m_invalidate_regs_map.end(); 469 pos != end; ++pos) { 470 const uint32_t reg_num = pos->first; 471 472 if (m_regs[reg_num].value_regs) { 473 reg_num_collection extra_invalid_regs; 474 for (const uint32_t invalidate_reg_num : pos->second) { 475 reg_to_regs_map::iterator invalidate_pos = 476 m_invalidate_regs_map.find(invalidate_reg_num); 477 if (invalidate_pos != m_invalidate_regs_map.end()) { 478 for (const uint32_t concrete_invalidate_reg_num : 479 invalidate_pos->second) { 480 if (concrete_invalidate_reg_num != reg_num) 481 extra_invalid_regs.push_back(concrete_invalidate_reg_num); 482 } 483 } 484 } 485 pos->second.insert(pos->second.end(), extra_invalid_regs.begin(), 486 extra_invalid_regs.end()); 487 } 488 } 489 490 // sort and unique all invalidate registers and make sure each is terminated 491 // with LLDB_INVALID_REGNUM 492 for (reg_to_regs_map::iterator pos = m_invalidate_regs_map.begin(), 493 end = m_invalidate_regs_map.end(); 494 pos != end; ++pos) { 495 if (pos->second.size() > 1) { 496 llvm::sort(pos->second); 497 reg_num_collection::iterator unique_end = 498 std::unique(pos->second.begin(), pos->second.end()); 499 if (unique_end != pos->second.end()) 500 pos->second.erase(unique_end, pos->second.end()); 501 } 502 assert(!pos->second.empty()); 503 if (pos->second.back() != LLDB_INVALID_REGNUM) 504 pos->second.push_back(LLDB_INVALID_REGNUM); 505 } 506 507 // Now update all invalidate_regs with each register info as needed 508 for (size_t i = 0; i < num_regs; ++i) { 509 if (m_invalidate_regs_map.find(i) != m_invalidate_regs_map.end()) 510 m_regs[i].invalidate_regs = m_invalidate_regs_map[i].data(); 511 else 512 m_regs[i].invalidate_regs = nullptr; 513 } 514 515 // Check if we need to automatically set the generic registers in case they 516 // weren't set 517 bool generic_regs_specified = false; 518 for (const auto ® : m_regs) { 519 if (reg.kinds[eRegisterKindGeneric] != LLDB_INVALID_REGNUM) { 520 generic_regs_specified = true; 521 break; 522 } 523 } 524 525 if (!generic_regs_specified) { 526 switch (arch.GetMachine()) { 527 case llvm::Triple::aarch64: 528 case llvm::Triple::aarch64_32: 529 case llvm::Triple::aarch64_be: 530 for (auto ® : m_regs) { 531 if (strcmp(reg.name, "pc") == 0) 532 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC; 533 else if ((strcmp(reg.name, "fp") == 0) || 534 (strcmp(reg.name, "x29") == 0)) 535 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP; 536 else if ((strcmp(reg.name, "lr") == 0) || 537 (strcmp(reg.name, "x30") == 0)) 538 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_RA; 539 else if ((strcmp(reg.name, "sp") == 0) || 540 (strcmp(reg.name, "x31") == 0)) 541 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP; 542 else if (strcmp(reg.name, "cpsr") == 0) 543 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS; 544 } 545 break; 546 547 case llvm::Triple::arm: 548 case llvm::Triple::armeb: 549 case llvm::Triple::thumb: 550 case llvm::Triple::thumbeb: 551 for (auto ® : m_regs) { 552 if ((strcmp(reg.name, "pc") == 0) || (strcmp(reg.name, "r15") == 0)) 553 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC; 554 else if ((strcmp(reg.name, "sp") == 0) || 555 (strcmp(reg.name, "r13") == 0)) 556 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP; 557 else if ((strcmp(reg.name, "lr") == 0) || 558 (strcmp(reg.name, "r14") == 0)) 559 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_RA; 560 else if ((strcmp(reg.name, "r7") == 0) && 561 arch.GetTriple().getVendor() == llvm::Triple::Apple) 562 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP; 563 else if ((strcmp(reg.name, "r11") == 0) && 564 arch.GetTriple().getVendor() != llvm::Triple::Apple) 565 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP; 566 else if (strcmp(reg.name, "fp") == 0) 567 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP; 568 else if (strcmp(reg.name, "cpsr") == 0) 569 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS; 570 } 571 break; 572 573 case llvm::Triple::x86: 574 for (auto ® : m_regs) { 575 if ((strcmp(reg.name, "eip") == 0) || (strcmp(reg.name, "pc") == 0)) 576 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC; 577 else if ((strcmp(reg.name, "esp") == 0) || 578 (strcmp(reg.name, "sp") == 0)) 579 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP; 580 else if ((strcmp(reg.name, "ebp") == 0) || 581 (strcmp(reg.name, "fp") == 0)) 582 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP; 583 else if ((strcmp(reg.name, "eflags") == 0) || 584 (strcmp(reg.name, "flags") == 0)) 585 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS; 586 } 587 break; 588 589 case llvm::Triple::x86_64: 590 for (auto ® : m_regs) { 591 if ((strcmp(reg.name, "rip") == 0) || (strcmp(reg.name, "pc") == 0)) 592 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC; 593 else if ((strcmp(reg.name, "rsp") == 0) || 594 (strcmp(reg.name, "sp") == 0)) 595 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP; 596 else if ((strcmp(reg.name, "rbp") == 0) || 597 (strcmp(reg.name, "fp") == 0)) 598 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP; 599 else if ((strcmp(reg.name, "rflags") == 0) || 600 (strcmp(reg.name, "eflags") == 0) || 601 (strcmp(reg.name, "flags") == 0)) 602 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS; 603 } 604 break; 605 606 default: 607 break; 608 } 609 } 610 611 // At this stage call ConfigureOffsets to calculate register offsets for 612 // targets supporting dynamic offset calculation. It also calculates 613 // total byte size of register data. 614 ConfigureOffsets(); 615 616 // Check if register info is reconfigurable 617 // AArch64 SVE register set has configurable register sizes 618 if (arch.GetTriple().isAArch64()) { 619 for (const auto ® : m_regs) { 620 if (strcmp(reg.name, "vg") == 0) { 621 m_is_reconfigurable = true; 622 break; 623 } 624 } 625 } 626 } 627 628 void DynamicRegisterInfo::ConfigureOffsets() { 629 // We are going to create a map between remote (eRegisterKindProcessPlugin) 630 // and local (eRegisterKindLLDB) register numbers. This map will give us 631 // remote register numbers in increasing order for offset calculation. 632 std::map<uint32_t, uint32_t> remote_to_local_regnum_map; 633 for (const auto ® : m_regs) 634 remote_to_local_regnum_map[reg.kinds[eRegisterKindProcessPlugin]] = 635 reg.kinds[eRegisterKindLLDB]; 636 637 // At this stage we manually calculate g/G packet offsets of all primary 638 // registers, only if target XML or qRegisterInfo packet did not send 639 // an offset explicitly. 640 uint32_t reg_offset = 0; 641 for (auto const ®num_pair : remote_to_local_regnum_map) { 642 if (m_regs[regnum_pair.second].byte_offset == LLDB_INVALID_INDEX32 && 643 m_regs[regnum_pair.second].value_regs == nullptr) { 644 m_regs[regnum_pair.second].byte_offset = reg_offset; 645 646 reg_offset = m_regs[regnum_pair.second].byte_offset + 647 m_regs[regnum_pair.second].byte_size; 648 } 649 } 650 651 // Now update all value_regs with each register info as needed 652 for (auto ® : m_regs) { 653 if (reg.value_regs != nullptr) { 654 // Assign a valid offset to all pseudo registers that have only a single 655 // parent register in value_regs list, if not assigned by stub. Pseudo 656 // registers with value_regs list populated will share same offset as 657 // that of their corresponding parent register. 658 if (reg.byte_offset == LLDB_INVALID_INDEX32) { 659 uint32_t value_regnum = reg.value_regs[0]; 660 if (value_regnum != LLDB_INVALID_INDEX32 && 661 reg.value_regs[1] == LLDB_INVALID_INDEX32) { 662 reg.byte_offset = 663 GetRegisterInfoAtIndex(value_regnum)->byte_offset; 664 auto it = m_value_reg_offset_map.find(reg.kinds[eRegisterKindLLDB]); 665 if (it != m_value_reg_offset_map.end()) 666 reg.byte_offset += it->second; 667 } 668 } 669 } 670 671 reg_offset = reg.byte_offset + reg.byte_size; 672 if (m_reg_data_byte_size < reg_offset) 673 m_reg_data_byte_size = reg_offset; 674 } 675 } 676 677 bool DynamicRegisterInfo::IsReconfigurable() { return m_is_reconfigurable; } 678 679 size_t DynamicRegisterInfo::GetNumRegisters() const { return m_regs.size(); } 680 681 size_t DynamicRegisterInfo::GetNumRegisterSets() const { return m_sets.size(); } 682 683 size_t DynamicRegisterInfo::GetRegisterDataByteSize() const { 684 return m_reg_data_byte_size; 685 } 686 687 const RegisterInfo * 688 DynamicRegisterInfo::GetRegisterInfoAtIndex(uint32_t i) const { 689 if (i < m_regs.size()) 690 return &m_regs[i]; 691 return nullptr; 692 } 693 694 const RegisterInfo *DynamicRegisterInfo::GetRegisterInfo(uint32_t kind, 695 uint32_t num) const { 696 uint32_t reg_index = ConvertRegisterKindToRegisterNumber(kind, num); 697 if (reg_index != LLDB_INVALID_REGNUM) 698 return &m_regs[reg_index]; 699 return nullptr; 700 } 701 702 const RegisterSet *DynamicRegisterInfo::GetRegisterSet(uint32_t i) const { 703 if (i < m_sets.size()) 704 return &m_sets[i]; 705 return nullptr; 706 } 707 708 uint32_t 709 DynamicRegisterInfo::GetRegisterSetIndexByName(const ConstString &set_name, 710 bool can_create) { 711 name_collection::iterator pos, end = m_set_names.end(); 712 for (pos = m_set_names.begin(); pos != end; ++pos) { 713 if (*pos == set_name) 714 return std::distance(m_set_names.begin(), pos); 715 } 716 717 m_set_names.push_back(set_name); 718 m_set_reg_nums.resize(m_set_reg_nums.size() + 1); 719 RegisterSet new_set = {set_name.AsCString(), nullptr, 0, nullptr}; 720 m_sets.push_back(new_set); 721 return m_sets.size() - 1; 722 } 723 724 uint32_t 725 DynamicRegisterInfo::ConvertRegisterKindToRegisterNumber(uint32_t kind, 726 uint32_t num) const { 727 reg_collection::const_iterator pos, end = m_regs.end(); 728 for (pos = m_regs.begin(); pos != end; ++pos) { 729 if (pos->kinds[kind] == num) 730 return std::distance(m_regs.begin(), pos); 731 } 732 733 return LLDB_INVALID_REGNUM; 734 } 735 736 void DynamicRegisterInfo::Clear() { 737 m_regs.clear(); 738 m_sets.clear(); 739 m_set_reg_nums.clear(); 740 m_set_names.clear(); 741 m_value_regs_map.clear(); 742 m_invalidate_regs_map.clear(); 743 m_reg_data_byte_size = 0; 744 m_finalized = false; 745 } 746 747 void DynamicRegisterInfo::Dump() const { 748 StreamFile s(stdout, false); 749 const size_t num_regs = m_regs.size(); 750 s.Printf("%p: DynamicRegisterInfo contains %" PRIu64 " registers:\n", 751 static_cast<const void *>(this), static_cast<uint64_t>(num_regs)); 752 for (size_t i = 0; i < num_regs; ++i) { 753 s.Printf("[%3" PRIu64 "] name = %-10s", (uint64_t)i, m_regs[i].name); 754 s.Printf(", size = %2u, offset = %4u, encoding = %u, format = %-10s", 755 m_regs[i].byte_size, m_regs[i].byte_offset, m_regs[i].encoding, 756 FormatManager::GetFormatAsCString(m_regs[i].format)); 757 if (m_regs[i].kinds[eRegisterKindProcessPlugin] != LLDB_INVALID_REGNUM) 758 s.Printf(", process plugin = %3u", 759 m_regs[i].kinds[eRegisterKindProcessPlugin]); 760 if (m_regs[i].kinds[eRegisterKindDWARF] != LLDB_INVALID_REGNUM) 761 s.Printf(", dwarf = %3u", m_regs[i].kinds[eRegisterKindDWARF]); 762 if (m_regs[i].kinds[eRegisterKindEHFrame] != LLDB_INVALID_REGNUM) 763 s.Printf(", ehframe = %3u", m_regs[i].kinds[eRegisterKindEHFrame]); 764 if (m_regs[i].kinds[eRegisterKindGeneric] != LLDB_INVALID_REGNUM) 765 s.Printf(", generic = %3u", m_regs[i].kinds[eRegisterKindGeneric]); 766 if (m_regs[i].alt_name) 767 s.Printf(", alt-name = %s", m_regs[i].alt_name); 768 if (m_regs[i].value_regs) { 769 s.Printf(", value_regs = [ "); 770 for (size_t j = 0; m_regs[i].value_regs[j] != LLDB_INVALID_REGNUM; ++j) { 771 s.Printf("%s ", m_regs[m_regs[i].value_regs[j]].name); 772 } 773 s.Printf("]"); 774 } 775 if (m_regs[i].invalidate_regs) { 776 s.Printf(", invalidate_regs = [ "); 777 for (size_t j = 0; m_regs[i].invalidate_regs[j] != LLDB_INVALID_REGNUM; 778 ++j) { 779 s.Printf("%s ", m_regs[m_regs[i].invalidate_regs[j]].name); 780 } 781 s.Printf("]"); 782 } 783 s.EOL(); 784 } 785 786 const size_t num_sets = m_sets.size(); 787 s.Printf("%p: DynamicRegisterInfo contains %" PRIu64 " register sets:\n", 788 static_cast<const void *>(this), static_cast<uint64_t>(num_sets)); 789 for (size_t i = 0; i < num_sets; ++i) { 790 s.Printf("set[%" PRIu64 "] name = %s, regs = [", (uint64_t)i, 791 m_sets[i].name); 792 for (size_t idx = 0; idx < m_sets[i].num_registers; ++idx) { 793 s.Printf("%s ", m_regs[m_sets[i].registers[idx]].name); 794 } 795 s.Printf("]\n"); 796 } 797 } 798 799 const lldb_private::RegisterInfo * 800 DynamicRegisterInfo::GetRegisterInfo(llvm::StringRef reg_name) const { 801 for (auto ®_info : m_regs) 802 if (reg_info.name == reg_name) 803 return ®_info; 804 return nullptr; 805 } 806 807 void lldb_private::addSupplementaryRegister( 808 std::vector<DynamicRegisterInfo::Register> ®s, 809 DynamicRegisterInfo::Register new_reg_info) { 810 assert(!new_reg_info.value_regs.empty()); 811 const uint32_t reg_num = regs.size(); 812 regs.push_back(new_reg_info); 813 814 std::map<uint32_t, std::vector<uint32_t>> new_invalidates; 815 for (uint32_t value_reg : new_reg_info.value_regs) { 816 // copy value_regs to invalidate_regs 817 new_invalidates[reg_num].push_back(value_reg); 818 819 // copy invalidate_regs from the parent register 820 llvm::append_range(new_invalidates[reg_num], 821 regs[value_reg].invalidate_regs); 822 823 // add reverse invalidate entries 824 for (uint32_t x : new_invalidates[reg_num]) 825 new_invalidates[x].push_back(reg_num); 826 } 827 828 for (const auto &x : new_invalidates) 829 llvm::append_range(regs[x.first].invalidate_regs, x.second); 830 } 831