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