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