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