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