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