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