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