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(), 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 std::string set_name_str; 52 ConstString set_name; 53 if (sets->GetItemAtIndexAsString(i, set_name_str)) 54 set_name.SetCString(set_name_str.c_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 std::string 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.c_str(), 1, reg_name_str) && 135 regex_match.GetMatchAtIndex(slice_str.c_str(), 2, msbit_str) && 136 regex_match.GetMatchAtIndex(slice_str.c_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 std::string 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.length() / 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; 281 // Swap "dwarf_opcode_string" over into "opcode_extractor" 282 opcode_extractor.GetStringRef().swap(dwarf_opcode_string); 283 uint32_t ret_val = opcode_extractor.GetHexBytesAvail(dwarf_opcode_bytes); 284 assert(ret_val == reg_info.dynamic_size_dwarf_len); 285 286 for (j = 0; j < reg_info.dynamic_size_dwarf_len; ++j) 287 m_dynamic_reg_size_map[i].push_back(dwarf_opcode_bytes[j]); 288 289 reg_info.dynamic_size_dwarf_expr_bytes = m_dynamic_reg_size_map[i].data(); 290 } 291 292 std::string format_str; 293 if (reg_info_dict->GetValueForKeyAsString("format", format_str, nullptr)) { 294 if (Args::StringToFormat(format_str.c_str(), reg_info.format, NULL) 295 .Fail()) { 296 Clear(); 297 printf("error: invalid 'format' value in register dictionary\n"); 298 reg_info_dict->DumpToStdout(); 299 return 0; 300 } 301 } else { 302 reg_info_dict->GetValueForKeyAsInteger("format", reg_info.format, 303 eFormatHex); 304 } 305 306 std::string encoding_str; 307 if (reg_info_dict->GetValueForKeyAsString("encoding", encoding_str)) 308 reg_info.encoding = Args::StringToEncoding(encoding_str, eEncodingUint); 309 else 310 reg_info_dict->GetValueForKeyAsInteger("encoding", reg_info.encoding, 311 eEncodingUint); 312 313 size_t set = 0; 314 if (!reg_info_dict->GetValueForKeyAsInteger<size_t>("set", set, -1) || 315 set >= m_sets.size()) { 316 Clear(); 317 printf("error: invalid 'set' value in register dictionary, valid values " 318 "are 0 - %i\n", 319 (int)set); 320 reg_info_dict->DumpToStdout(); 321 return 0; 322 } 323 324 // Fill in the register numbers 325 reg_info.kinds[lldb::eRegisterKindLLDB] = i; 326 reg_info.kinds[lldb::eRegisterKindProcessPlugin] = i; 327 uint32_t eh_frame_regno = LLDB_INVALID_REGNUM; 328 reg_info_dict->GetValueForKeyAsInteger("gcc", eh_frame_regno, 329 LLDB_INVALID_REGNUM); 330 if (eh_frame_regno == LLDB_INVALID_REGNUM) 331 reg_info_dict->GetValueForKeyAsInteger("ehframe", eh_frame_regno, 332 LLDB_INVALID_REGNUM); 333 reg_info.kinds[lldb::eRegisterKindEHFrame] = eh_frame_regno; 334 reg_info_dict->GetValueForKeyAsInteger( 335 "dwarf", reg_info.kinds[lldb::eRegisterKindDWARF], LLDB_INVALID_REGNUM); 336 std::string generic_str; 337 if (reg_info_dict->GetValueForKeyAsString("generic", generic_str)) 338 reg_info.kinds[lldb::eRegisterKindGeneric] = 339 Args::StringToGenericRegister(generic_str); 340 else 341 reg_info_dict->GetValueForKeyAsInteger( 342 "generic", reg_info.kinds[lldb::eRegisterKindGeneric], 343 LLDB_INVALID_REGNUM); 344 345 // Check if this register invalidates any other register values when it is 346 // modified 347 StructuredData::Array *invalidate_reg_list = nullptr; 348 if (reg_info_dict->GetValueForKeyAsArray("invalidate-regs", 349 invalidate_reg_list)) { 350 const size_t num_regs = invalidate_reg_list->GetSize(); 351 if (num_regs > 0) { 352 for (uint32_t idx = 0; idx < num_regs; ++idx) { 353 ConstString invalidate_reg_name; 354 uint64_t invalidate_reg_num; 355 if (invalidate_reg_list->GetItemAtIndexAsString( 356 idx, invalidate_reg_name)) { 357 RegisterInfo *invalidate_reg_info = 358 GetRegisterInfo(invalidate_reg_name); 359 if (invalidate_reg_info) { 360 m_invalidate_regs_map[i].push_back( 361 invalidate_reg_info->kinds[eRegisterKindLLDB]); 362 } else { 363 // TODO: print error invalid slice string that doesn't follow the 364 // format 365 printf("error: failed to find a 'invalidate-regs' register for " 366 "\"%s\" while parsing register \"%s\"\n", 367 invalidate_reg_name.GetCString(), reg_info.name); 368 } 369 } else if (invalidate_reg_list->GetItemAtIndexAsInteger( 370 idx, invalidate_reg_num)) { 371 if (invalidate_reg_num != UINT64_MAX) 372 m_invalidate_regs_map[i].push_back(invalidate_reg_num); 373 else 374 printf("error: 'invalidate-regs' list value wasn't a valid " 375 "integer\n"); 376 } else { 377 printf("error: 'invalidate-regs' list value wasn't a python string " 378 "or integer\n"); 379 } 380 } 381 } else { 382 printf("error: 'invalidate-regs' contained an empty list\n"); 383 } 384 } 385 386 // Calculate the register offset 387 const size_t end_reg_offset = reg_info.byte_offset + reg_info.byte_size; 388 if (m_reg_data_byte_size < end_reg_offset) 389 m_reg_data_byte_size = end_reg_offset; 390 391 m_regs.push_back(reg_info); 392 m_set_reg_nums[set].push_back(i); 393 } 394 Finalize(arch); 395 return m_regs.size(); 396 } 397 398 void DynamicRegisterInfo::AddRegister(RegisterInfo ®_info, 399 ConstString ®_name, 400 ConstString ®_alt_name, 401 ConstString &set_name) { 402 assert(!m_finalized); 403 const uint32_t reg_num = m_regs.size(); 404 reg_info.name = reg_name.AsCString(); 405 assert(reg_info.name); 406 reg_info.alt_name = reg_alt_name.AsCString(NULL); 407 uint32_t i; 408 if (reg_info.value_regs) { 409 for (i = 0; reg_info.value_regs[i] != LLDB_INVALID_REGNUM; ++i) 410 m_value_regs_map[reg_num].push_back(reg_info.value_regs[i]); 411 } 412 if (reg_info.invalidate_regs) { 413 for (i = 0; reg_info.invalidate_regs[i] != LLDB_INVALID_REGNUM; ++i) 414 m_invalidate_regs_map[reg_num].push_back(reg_info.invalidate_regs[i]); 415 } 416 if (reg_info.dynamic_size_dwarf_expr_bytes) { 417 for (i = 0; i < reg_info.dynamic_size_dwarf_len; ++i) 418 m_dynamic_reg_size_map[reg_num].push_back( 419 reg_info.dynamic_size_dwarf_expr_bytes[i]); 420 421 reg_info.dynamic_size_dwarf_expr_bytes = 422 m_dynamic_reg_size_map[reg_num].data(); 423 } 424 425 m_regs.push_back(reg_info); 426 uint32_t set = GetRegisterSetIndexByName(set_name, true); 427 assert(set < m_sets.size()); 428 assert(set < m_set_reg_nums.size()); 429 assert(set < m_set_names.size()); 430 m_set_reg_nums[set].push_back(reg_num); 431 size_t end_reg_offset = reg_info.byte_offset + reg_info.byte_size; 432 if (m_reg_data_byte_size < end_reg_offset) 433 m_reg_data_byte_size = end_reg_offset; 434 } 435 436 void DynamicRegisterInfo::Finalize(const ArchSpec &arch) { 437 if (m_finalized) 438 return; 439 440 m_finalized = true; 441 const size_t num_sets = m_sets.size(); 442 for (size_t set = 0; set < num_sets; ++set) { 443 assert(m_sets.size() == m_set_reg_nums.size()); 444 m_sets[set].num_registers = m_set_reg_nums[set].size(); 445 m_sets[set].registers = &m_set_reg_nums[set][0]; 446 } 447 448 // sort and unique all value registers and make sure each is terminated with 449 // LLDB_INVALID_REGNUM 450 451 for (reg_to_regs_map::iterator pos = m_value_regs_map.begin(), 452 end = m_value_regs_map.end(); 453 pos != end; ++pos) { 454 if (pos->second.size() > 1) { 455 std::sort(pos->second.begin(), pos->second.end()); 456 reg_num_collection::iterator unique_end = 457 std::unique(pos->second.begin(), pos->second.end()); 458 if (unique_end != pos->second.end()) 459 pos->second.erase(unique_end, pos->second.end()); 460 } 461 assert(!pos->second.empty()); 462 if (pos->second.back() != LLDB_INVALID_REGNUM) 463 pos->second.push_back(LLDB_INVALID_REGNUM); 464 } 465 466 // Now update all value_regs with each register info as needed 467 const size_t num_regs = m_regs.size(); 468 for (size_t i = 0; i < num_regs; ++i) { 469 if (m_value_regs_map.find(i) != m_value_regs_map.end()) 470 m_regs[i].value_regs = m_value_regs_map[i].data(); 471 else 472 m_regs[i].value_regs = NULL; 473 } 474 475 // Expand all invalidation dependencies 476 for (reg_to_regs_map::iterator pos = m_invalidate_regs_map.begin(), 477 end = m_invalidate_regs_map.end(); 478 pos != end; ++pos) { 479 const uint32_t reg_num = pos->first; 480 481 if (m_regs[reg_num].value_regs) { 482 reg_num_collection extra_invalid_regs; 483 for (const uint32_t invalidate_reg_num : pos->second) { 484 reg_to_regs_map::iterator invalidate_pos = 485 m_invalidate_regs_map.find(invalidate_reg_num); 486 if (invalidate_pos != m_invalidate_regs_map.end()) { 487 for (const uint32_t concrete_invalidate_reg_num : 488 invalidate_pos->second) { 489 if (concrete_invalidate_reg_num != reg_num) 490 extra_invalid_regs.push_back(concrete_invalidate_reg_num); 491 } 492 } 493 } 494 pos->second.insert(pos->second.end(), extra_invalid_regs.begin(), 495 extra_invalid_regs.end()); 496 } 497 } 498 499 // sort and unique all invalidate registers and make sure each is terminated 500 // with 501 // LLDB_INVALID_REGNUM 502 for (reg_to_regs_map::iterator pos = m_invalidate_regs_map.begin(), 503 end = m_invalidate_regs_map.end(); 504 pos != end; ++pos) { 505 if (pos->second.size() > 1) { 506 std::sort(pos->second.begin(), pos->second.end()); 507 reg_num_collection::iterator unique_end = 508 std::unique(pos->second.begin(), pos->second.end()); 509 if (unique_end != pos->second.end()) 510 pos->second.erase(unique_end, pos->second.end()); 511 } 512 assert(!pos->second.empty()); 513 if (pos->second.back() != LLDB_INVALID_REGNUM) 514 pos->second.push_back(LLDB_INVALID_REGNUM); 515 } 516 517 // Now update all invalidate_regs with each register info as needed 518 for (size_t i = 0; i < num_regs; ++i) { 519 if (m_invalidate_regs_map.find(i) != m_invalidate_regs_map.end()) 520 m_regs[i].invalidate_regs = m_invalidate_regs_map[i].data(); 521 else 522 m_regs[i].invalidate_regs = NULL; 523 } 524 525 // Check if we need to automatically set the generic registers in case 526 // they weren't set 527 bool generic_regs_specified = false; 528 for (const auto ® : m_regs) { 529 if (reg.kinds[eRegisterKindGeneric] != LLDB_INVALID_REGNUM) { 530 generic_regs_specified = true; 531 break; 532 } 533 } 534 535 if (!generic_regs_specified) { 536 switch (arch.GetMachine()) { 537 case llvm::Triple::aarch64: 538 case llvm::Triple::aarch64_be: 539 for (auto ® : m_regs) { 540 if (strcmp(reg.name, "pc") == 0) 541 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC; 542 else if ((strcmp(reg.name, "fp") == 0) || 543 (strcmp(reg.name, "x29") == 0)) 544 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP; 545 else if ((strcmp(reg.name, "lr") == 0) || 546 (strcmp(reg.name, "x30") == 0)) 547 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_RA; 548 else if ((strcmp(reg.name, "sp") == 0) || 549 (strcmp(reg.name, "x31") == 0)) 550 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP; 551 else if (strcmp(reg.name, "cpsr") == 0) 552 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS; 553 } 554 break; 555 556 case llvm::Triple::arm: 557 case llvm::Triple::armeb: 558 case llvm::Triple::thumb: 559 case llvm::Triple::thumbeb: 560 for (auto ® : m_regs) { 561 if ((strcmp(reg.name, "pc") == 0) || (strcmp(reg.name, "r15") == 0)) 562 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC; 563 else if ((strcmp(reg.name, "sp") == 0) || 564 (strcmp(reg.name, "r13") == 0)) 565 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP; 566 else if ((strcmp(reg.name, "lr") == 0) || 567 (strcmp(reg.name, "r14") == 0)) 568 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_RA; 569 else if ((strcmp(reg.name, "r7") == 0) && 570 arch.GetTriple().getVendor() == llvm::Triple::Apple) 571 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP; 572 else if ((strcmp(reg.name, "r11") == 0) && 573 arch.GetTriple().getVendor() != llvm::Triple::Apple) 574 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP; 575 else if (strcmp(reg.name, "fp") == 0) 576 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP; 577 else if (strcmp(reg.name, "cpsr") == 0) 578 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS; 579 } 580 break; 581 582 case llvm::Triple::x86: 583 for (auto ® : m_regs) { 584 if ((strcmp(reg.name, "eip") == 0) || (strcmp(reg.name, "pc") == 0)) 585 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC; 586 else if ((strcmp(reg.name, "esp") == 0) || 587 (strcmp(reg.name, "sp") == 0)) 588 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP; 589 else if ((strcmp(reg.name, "ebp") == 0) || 590 (strcmp(reg.name, "fp") == 0)) 591 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP; 592 else if ((strcmp(reg.name, "eflags") == 0) || 593 (strcmp(reg.name, "flags") == 0)) 594 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS; 595 } 596 break; 597 598 case llvm::Triple::x86_64: 599 for (auto ® : m_regs) { 600 if ((strcmp(reg.name, "rip") == 0) || (strcmp(reg.name, "pc") == 0)) 601 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC; 602 else if ((strcmp(reg.name, "rsp") == 0) || 603 (strcmp(reg.name, "sp") == 0)) 604 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP; 605 else if ((strcmp(reg.name, "rbp") == 0) || 606 (strcmp(reg.name, "fp") == 0)) 607 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP; 608 else if ((strcmp(reg.name, "rflags") == 0) || 609 (strcmp(reg.name, "flags") == 0)) 610 reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS; 611 } 612 break; 613 614 default: 615 break; 616 } 617 } 618 } 619 620 size_t DynamicRegisterInfo::GetNumRegisters() const { return m_regs.size(); } 621 622 size_t DynamicRegisterInfo::GetNumRegisterSets() const { return m_sets.size(); } 623 624 size_t DynamicRegisterInfo::GetRegisterDataByteSize() const { 625 return m_reg_data_byte_size; 626 } 627 628 const RegisterInfo * 629 DynamicRegisterInfo::GetRegisterInfoAtIndex(uint32_t i) const { 630 if (i < m_regs.size()) 631 return &m_regs[i]; 632 return NULL; 633 } 634 635 RegisterInfo *DynamicRegisterInfo::GetRegisterInfoAtIndex(uint32_t i) { 636 if (i < m_regs.size()) 637 return &m_regs[i]; 638 return NULL; 639 } 640 641 const RegisterSet *DynamicRegisterInfo::GetRegisterSet(uint32_t i) const { 642 if (i < m_sets.size()) 643 return &m_sets[i]; 644 return NULL; 645 } 646 647 uint32_t DynamicRegisterInfo::GetRegisterSetIndexByName(ConstString &set_name, 648 bool can_create) { 649 name_collection::iterator pos, end = m_set_names.end(); 650 for (pos = m_set_names.begin(); pos != end; ++pos) { 651 if (*pos == set_name) 652 return std::distance(m_set_names.begin(), pos); 653 } 654 655 m_set_names.push_back(set_name); 656 m_set_reg_nums.resize(m_set_reg_nums.size() + 1); 657 RegisterSet new_set = {set_name.AsCString(), NULL, 0, NULL}; 658 m_sets.push_back(new_set); 659 return m_sets.size() - 1; 660 } 661 662 uint32_t 663 DynamicRegisterInfo::ConvertRegisterKindToRegisterNumber(uint32_t kind, 664 uint32_t num) const { 665 reg_collection::const_iterator pos, end = m_regs.end(); 666 for (pos = m_regs.begin(); pos != end; ++pos) { 667 if (pos->kinds[kind] == num) 668 return std::distance(m_regs.begin(), pos); 669 } 670 671 return LLDB_INVALID_REGNUM; 672 } 673 674 void DynamicRegisterInfo::Clear() { 675 m_regs.clear(); 676 m_sets.clear(); 677 m_set_reg_nums.clear(); 678 m_set_names.clear(); 679 m_value_regs_map.clear(); 680 m_invalidate_regs_map.clear(); 681 m_dynamic_reg_size_map.clear(); 682 m_reg_data_byte_size = 0; 683 m_finalized = false; 684 } 685 686 void DynamicRegisterInfo::Dump() const { 687 StreamFile s(stdout, false); 688 const size_t num_regs = m_regs.size(); 689 s.Printf("%p: DynamicRegisterInfo contains %" PRIu64 " registers:\n", 690 static_cast<const void *>(this), static_cast<uint64_t>(num_regs)); 691 for (size_t i = 0; i < num_regs; ++i) { 692 s.Printf("[%3" PRIu64 "] name = %-10s", (uint64_t)i, m_regs[i].name); 693 s.Printf(", size = %2u, offset = %4u, encoding = %u, format = %-10s", 694 m_regs[i].byte_size, m_regs[i].byte_offset, m_regs[i].encoding, 695 FormatManager::GetFormatAsCString(m_regs[i].format)); 696 if (m_regs[i].kinds[eRegisterKindProcessPlugin] != LLDB_INVALID_REGNUM) 697 s.Printf(", process plugin = %3u", 698 m_regs[i].kinds[eRegisterKindProcessPlugin]); 699 if (m_regs[i].kinds[eRegisterKindDWARF] != LLDB_INVALID_REGNUM) 700 s.Printf(", dwarf = %3u", m_regs[i].kinds[eRegisterKindDWARF]); 701 if (m_regs[i].kinds[eRegisterKindEHFrame] != LLDB_INVALID_REGNUM) 702 s.Printf(", ehframe = %3u", m_regs[i].kinds[eRegisterKindEHFrame]); 703 if (m_regs[i].kinds[eRegisterKindGeneric] != LLDB_INVALID_REGNUM) 704 s.Printf(", generic = %3u", m_regs[i].kinds[eRegisterKindGeneric]); 705 if (m_regs[i].alt_name) 706 s.Printf(", alt-name = %s", m_regs[i].alt_name); 707 if (m_regs[i].value_regs) { 708 s.Printf(", value_regs = [ "); 709 for (size_t j = 0; m_regs[i].value_regs[j] != LLDB_INVALID_REGNUM; ++j) { 710 s.Printf("%s ", m_regs[m_regs[i].value_regs[j]].name); 711 } 712 s.Printf("]"); 713 } 714 if (m_regs[i].invalidate_regs) { 715 s.Printf(", invalidate_regs = [ "); 716 for (size_t j = 0; m_regs[i].invalidate_regs[j] != LLDB_INVALID_REGNUM; 717 ++j) { 718 s.Printf("%s ", m_regs[m_regs[i].invalidate_regs[j]].name); 719 } 720 s.Printf("]"); 721 } 722 s.EOL(); 723 } 724 725 const size_t num_sets = m_sets.size(); 726 s.Printf("%p: DynamicRegisterInfo contains %" PRIu64 " register sets:\n", 727 static_cast<const void *>(this), static_cast<uint64_t>(num_sets)); 728 for (size_t i = 0; i < num_sets; ++i) { 729 s.Printf("set[%" PRIu64 "] name = %s, regs = [", (uint64_t)i, 730 m_sets[i].name); 731 for (size_t idx = 0; idx < m_sets[i].num_registers; ++idx) { 732 s.Printf("%s ", m_regs[m_sets[i].registers[idx]].name); 733 } 734 s.Printf("]\n"); 735 } 736 } 737 738 lldb_private::RegisterInfo *DynamicRegisterInfo::GetRegisterInfo( 739 const lldb_private::ConstString ®_name) { 740 for (auto ®_info : m_regs) { 741 // We can use pointer comparison since we used a ConstString to set 742 // the "name" member in AddRegister() 743 if (reg_info.name == reg_name.GetCString()) { 744 return ®_info; 745 } 746 } 747 return NULL; 748 } 749