source/Plugins/Process/Utility/DynamicRegisterInfo.cpp

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