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