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