contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp

   1 //===-- GDBRemoteRegisterContext.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 "GDBRemoteRegisterContext.h"
  11
  12 // C Includes
  13 // C++ Includes
  14 // Other libraries and framework includes
  15 #include "lldb/Core/DataBufferHeap.h"
  16 #include "lldb/Core/DataExtractor.h"
  17 #include "lldb/Core/RegisterValue.h"
  18 #include "lldb/Core/Scalar.h"
  19 #include "lldb/Core/StreamString.h"
  20 #ifndef LLDB_DISABLE_PYTHON
  21 #include "lldb/Interpreter/PythonDataObjects.h"
  22 #endif
  23 #include "lldb/Target/ExecutionContext.h"
  24 #include "lldb/Utility/Utils.h"
  25 // Project includes
  26 #include "Utility/StringExtractorGDBRemote.h"
  27 #include "ProcessGDBRemote.h"
  28 #include "ProcessGDBRemoteLog.h"
  29 #include "ThreadGDBRemote.h"
  30 #include "Utility/ARM_GCC_Registers.h"
  31 #include "Utility/ARM_DWARF_Registers.h"
  32
  33 using namespace lldb;
  34 using namespace lldb_private;
  35
  36 //----------------------------------------------------------------------
  37 // GDBRemoteRegisterContext constructor
  38 //----------------------------------------------------------------------
  39 GDBRemoteRegisterContext::GDBRemoteRegisterContext
  40 (
  41     ThreadGDBRemote &thread,
  42     uint32_t concrete_frame_idx,
  43     GDBRemoteDynamicRegisterInfo &reg_info,
  44     bool read_all_at_once
  45 ) :
  46     RegisterContext (thread, concrete_frame_idx),
  47     m_reg_info (reg_info),
  48     m_reg_valid (),
  49     m_reg_data (),
  50     m_read_all_at_once (read_all_at_once)
  51 {
  52     // Resize our vector of bools to contain one bool for every register.
  53     // We will use these boolean values to know when a register value
  54     // is valid in m_reg_data.
  55     m_reg_valid.resize (reg_info.GetNumRegisters());
  56
  57     // Make a heap based buffer that is big enough to store all registers
  58     DataBufferSP reg_data_sp(new DataBufferHeap (reg_info.GetRegisterDataByteSize(), 0));
  59     m_reg_data.SetData (reg_data_sp);
  60     m_reg_data.SetByteOrder(thread.GetProcess()->GetByteOrder());
  61 }
  62
  63 //----------------------------------------------------------------------
  64 // Destructor
  65 //----------------------------------------------------------------------
  66 GDBRemoteRegisterContext::~GDBRemoteRegisterContext()
  67 {
  68 }
  69
  70 void
  71 GDBRemoteRegisterContext::InvalidateAllRegisters ()
  72 {
  73     SetAllRegisterValid (false);
  74 }
  75
  76 void
  77 GDBRemoteRegisterContext::SetAllRegisterValid (bool b)
  78 {
  79     std::vector<bool>::iterator pos, end = m_reg_valid.end();
  80     for (pos = m_reg_valid.begin(); pos != end; ++pos)
  81         *pos = b;
  82 }
  83
  84 size_t
  85 GDBRemoteRegisterContext::GetRegisterCount ()
  86 {
  87     return m_reg_info.GetNumRegisters ();
  88 }
  89
  90 const RegisterInfo *
  91 GDBRemoteRegisterContext::GetRegisterInfoAtIndex (size_t reg)
  92 {
  93     return m_reg_info.GetRegisterInfoAtIndex (reg);
  94 }
  95
  96 size_t
  97 GDBRemoteRegisterContext::GetRegisterSetCount ()
  98 {
  99     return m_reg_info.GetNumRegisterSets ();
 100 }
 101
 102
 103
 104 const RegisterSet *
 105 GDBRemoteRegisterContext::GetRegisterSet (size_t reg_set)
 106 {
 107     return m_reg_info.GetRegisterSet (reg_set);
 108 }
 109
 110
 111
 112 bool
 113 GDBRemoteRegisterContext::ReadRegister (const RegisterInfo *reg_info, RegisterValue &value)
 114 {
 115     // Read the register
 116     if (ReadRegisterBytes (reg_info, m_reg_data))
 117     {
 118         const bool partial_data_ok = false;
 119         Error error (value.SetValueFromData(reg_info, m_reg_data, reg_info->byte_offset, partial_data_ok));
 120         return error.Success();
 121     }
 122     return false;
 123 }
 124
 125 bool
 126 GDBRemoteRegisterContext::PrivateSetRegisterValue (uint32_t reg, StringExtractor &response)
 127 {
 128     const RegisterInfo *reg_info = GetRegisterInfoAtIndex (reg);
 129     if (reg_info == NULL)
 130         return false;
 131
 132     // Invalidate if needed
 133     InvalidateIfNeeded(false);
 134
 135     const uint32_t reg_byte_size = reg_info->byte_size;
 136     const size_t bytes_copied = response.GetHexBytes (const_cast<uint8_t*>(m_reg_data.PeekData(reg_info->byte_offset, reg_byte_size)), reg_byte_size, '\xcc');
 137     bool success = bytes_copied == reg_byte_size;
 138     if (success)
 139     {
 140         SetRegisterIsValid(reg, true);
 141     }
 142     else if (bytes_copied > 0)
 143     {
 144         // Only set register is valid to false if we copied some bytes, else
 145         // leave it as it was.
 146         SetRegisterIsValid(reg, false);
 147     }
 148     return success;
 149 }
 150
 151 // Helper function for GDBRemoteRegisterContext::ReadRegisterBytes().
 152 bool
 153 GDBRemoteRegisterContext::GetPrimordialRegister(const lldb_private::RegisterInfo *reg_info,
 154                                                 GDBRemoteCommunicationClient &gdb_comm)
 155 {
 156     char packet[64];
 157     StringExtractorGDBRemote response;
 158     int packet_len = 0;
 159     const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
 160     if (gdb_comm.GetThreadSuffixSupported())
 161         packet_len = ::snprintf (packet, sizeof(packet), "p%x;thread:%4.4" PRIx64 ";", reg, m_thread.GetProtocolID());
 162     else
 163         packet_len = ::snprintf (packet, sizeof(packet), "p%x", reg);
 164     assert (packet_len < ((int)sizeof(packet) - 1));
 165     if (gdb_comm.SendPacketAndWaitForResponse(packet, response, false))
 166         return PrivateSetRegisterValue (reg, response);
 167
 168     return false;
 169 }
 170 bool
 171 GDBRemoteRegisterContext::ReadRegisterBytes (const RegisterInfo *reg_info, DataExtractor &data)
 172 {
 173     ExecutionContext exe_ctx (CalculateThread());
 174
 175     Process *process = exe_ctx.GetProcessPtr();
 176     Thread *thread = exe_ctx.GetThreadPtr();
 177     if (process == NULL || thread == NULL)
 178         return false;
 179
 180     GDBRemoteCommunicationClient &gdb_comm (((ProcessGDBRemote *)process)->GetGDBRemote());
 181
 182     InvalidateIfNeeded(false);
 183
 184     const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
 185
 186     if (!GetRegisterIsValid(reg))
 187     {
 188         Mutex::Locker locker;
 189         if (gdb_comm.GetSequenceMutex (locker, "Didn't get sequence mutex for read register."))
 190         {
 191             const bool thread_suffix_supported = gdb_comm.GetThreadSuffixSupported();
 192             ProcessSP process_sp (m_thread.GetProcess());
 193             if (thread_suffix_supported || static_cast<ProcessGDBRemote *>(process_sp.get())->GetGDBRemote().SetCurrentThread(m_thread.GetProtocolID()))
 194             {
 195                 char packet[64];
 196                 StringExtractorGDBRemote response;
 197                 int packet_len = 0;
 198                 if (m_read_all_at_once)
 199                 {
 200                     // Get all registers in one packet
 201                     if (thread_suffix_supported)
 202                         packet_len = ::snprintf (packet, sizeof(packet), "g;thread:%4.4" PRIx64 ";", m_thread.GetProtocolID());
 203                     else
 204                         packet_len = ::snprintf (packet, sizeof(packet), "g");
 205                     assert (packet_len < ((int)sizeof(packet) - 1));
 206                     if (gdb_comm.SendPacketAndWaitForResponse(packet, response, false))
 207                     {
 208                         if (response.IsNormalResponse())
 209                             if (response.GetHexBytes ((void *)m_reg_data.GetDataStart(), m_reg_data.GetByteSize(), '\xcc') == m_reg_data.GetByteSize())
 210                                 SetAllRegisterValid (true);
 211                     }
 212                 }
 213                 else if (reg_info->value_regs)
 214                 {
 215                     // Process this composite register request by delegating to the constituent
 216                     // primordial registers.
 217
 218                     // Index of the primordial register.
 219                     bool success = true;
 220                     for (uint32_t idx = 0; success; ++idx)
 221                     {
 222                         const uint32_t prim_reg = reg_info->value_regs[idx];
 223                         if (prim_reg == LLDB_INVALID_REGNUM)
 224                             break;
 225                         // We have a valid primordial regsiter as our constituent.
 226                         // Grab the corresponding register info.
 227                         const RegisterInfo *prim_reg_info = GetRegisterInfoAtIndex(prim_reg);
 228                         if (prim_reg_info == NULL)
 229                             success = false;
 230                         else
 231                         {
 232                             // Read the containing register if it hasn't already been read
 233                             if (!GetRegisterIsValid(prim_reg))
 234                                 success = GetPrimordialRegister(prim_reg_info, gdb_comm);
 235                         }
 236                     }
 237
 238                     if (success)
 239                     {
 240                         // If we reach this point, all primordial register requests have succeeded.
 241                         // Validate this composite register.
 242                         SetRegisterIsValid (reg_info, true);
 243                     }
 244                 }
 245                 else
 246                 {
 247                     // Get each register individually
 248                     GetPrimordialRegister(reg_info, gdb_comm);
 249                 }
 250             }
 251         }
 252         else
 253         {
 254 #if LLDB_CONFIGURATION_DEBUG
 255             StreamString strm;
 256             gdb_comm.DumpHistory(strm);
 257             Host::SetCrashDescription (strm.GetData());
 258             assert (!"Didn't get sequence mutex for read register.");
 259 #else
 260             Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet (GDBR_LOG_THREAD | GDBR_LOG_PACKETS));
 261             if (log)
 262             {
 263                 if (log->GetVerbose())
 264                 {
 265                     StreamString strm;
 266                     gdb_comm.DumpHistory(strm);
 267                     log->Printf("error: failed to get packet sequence mutex, not sending read register for \"%s\":\n%s", reg_info->name, strm.GetData());
 268                 }
 269                 else
 270                 {
 271                     log->Printf("error: failed to get packet sequence mutex, not sending read register for \"%s\"", reg_info->name);
 272                 }
 273             }
 274 #endif
 275         }
 276
 277         // Make sure we got a valid register value after reading it
 278         if (!GetRegisterIsValid(reg))
 279             return false;
 280     }
 281
 282     if (&data != &m_reg_data)
 283     {
 284         // If we aren't extracting into our own buffer (which
 285         // only happens when this function is called from
 286         // ReadRegisterValue(uint32_t, Scalar&)) then
 287         // we transfer bytes from our buffer into the data
 288         // buffer that was passed in
 289         data.SetByteOrder (m_reg_data.GetByteOrder());
 290         data.SetData (m_reg_data, reg_info->byte_offset, reg_info->byte_size);
 291     }
 292     return true;
 293 }
 294
 295 bool
 296 GDBRemoteRegisterContext::WriteRegister (const RegisterInfo *reg_info,
 297                                          const RegisterValue &value)
 298 {
 299     DataExtractor data;
 300     if (value.GetData (data))
 301         return WriteRegisterBytes (reg_info, data, 0);
 302     return false;
 303 }
 304
 305 // Helper function for GDBRemoteRegisterContext::WriteRegisterBytes().
 306 bool
 307 GDBRemoteRegisterContext::SetPrimordialRegister(const lldb_private::RegisterInfo *reg_info,
 308                                                 GDBRemoteCommunicationClient &gdb_comm)
 309 {
 310     StreamString packet;
 311     StringExtractorGDBRemote response;
 312     const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
 313     packet.Printf ("P%x=", reg);
 314     packet.PutBytesAsRawHex8 (m_reg_data.PeekData(reg_info->byte_offset, reg_info->byte_size),
 315                               reg_info->byte_size,
 316                               lldb::endian::InlHostByteOrder(),
 317                               lldb::endian::InlHostByteOrder());
 318
 319     if (gdb_comm.GetThreadSuffixSupported())
 320         packet.Printf (";thread:%4.4" PRIx64 ";", m_thread.GetProtocolID());
 321
 322     // Invalidate just this register
 323     SetRegisterIsValid(reg, false);
 324     if (gdb_comm.SendPacketAndWaitForResponse(packet.GetString().c_str(),
 325                                               packet.GetString().size(),
 326                                               response,
 327                                               false))
 328     {
 329         if (response.IsOKResponse())
 330             return true;
 331     }
 332     return false;
 333 }
 334
 335 void
 336 GDBRemoteRegisterContext::SyncThreadState(Process *process)
 337 {
 338     // NB.  We assume our caller has locked the sequence mutex.
 339
 340     GDBRemoteCommunicationClient &gdb_comm (((ProcessGDBRemote *) process)->GetGDBRemote());
 341     if (!gdb_comm.GetSyncThreadStateSupported())
 342         return;
 343
 344     StreamString packet;
 345     StringExtractorGDBRemote response;
 346     packet.Printf ("QSyncThreadState:%4.4" PRIx64 ";", m_thread.GetProtocolID());
 347     if (gdb_comm.SendPacketAndWaitForResponse(packet.GetString().c_str(),
 348                                               packet.GetString().size(),
 349                                               response,
 350                                               false))
 351     {
 352         if (response.IsOKResponse())
 353             InvalidateAllRegisters();
 354     }
 355 }
 356
 357 bool
 358 GDBRemoteRegisterContext::WriteRegisterBytes (const lldb_private::RegisterInfo *reg_info, DataExtractor &data, uint32_t data_offset)
 359 {
 360     ExecutionContext exe_ctx (CalculateThread());
 361
 362     Process *process = exe_ctx.GetProcessPtr();
 363     Thread *thread = exe_ctx.GetThreadPtr();
 364     if (process == NULL || thread == NULL)
 365         return false;
 366
 367     GDBRemoteCommunicationClient &gdb_comm (((ProcessGDBRemote *)process)->GetGDBRemote());
 368 // FIXME: This check isn't right because IsRunning checks the Public state, but this
 369 // is work you need to do - for instance in ShouldStop & friends - before the public
 370 // state has been changed.
 371 //    if (gdb_comm.IsRunning())
 372 //        return false;
 373
 374     // Grab a pointer to where we are going to put this register
 375     uint8_t *dst = const_cast<uint8_t*>(m_reg_data.PeekData(reg_info->byte_offset, reg_info->byte_size));
 376
 377     if (dst == NULL)
 378         return false;
 379
 380
 381     if (data.CopyByteOrderedData (data_offset,                  // src offset
 382                                   reg_info->byte_size,          // src length
 383                                   dst,                          // dst
 384                                   reg_info->byte_size,          // dst length
 385                                   m_reg_data.GetByteOrder()))   // dst byte order
 386     {
 387         Mutex::Locker locker;
 388         if (gdb_comm.GetSequenceMutex (locker, "Didn't get sequence mutex for write register."))
 389         {
 390             const bool thread_suffix_supported = gdb_comm.GetThreadSuffixSupported();
 391             ProcessSP process_sp (m_thread.GetProcess());
 392             if (thread_suffix_supported || static_cast<ProcessGDBRemote *>(process_sp.get())->GetGDBRemote().SetCurrentThread(m_thread.GetProtocolID()))
 393             {
 394                 StreamString packet;
 395                 StringExtractorGDBRemote response;
 396
 397                 if (m_read_all_at_once)
 398                 {
 399                     // Set all registers in one packet
 400                     packet.PutChar ('G');
 401                     packet.PutBytesAsRawHex8 (m_reg_data.GetDataStart(),
 402                                               m_reg_data.GetByteSize(),
 403                                               lldb::endian::InlHostByteOrder(),
 404                                               lldb::endian::InlHostByteOrder());
 405
 406                     if (thread_suffix_supported)
 407                         packet.Printf (";thread:%4.4" PRIx64 ";", m_thread.GetProtocolID());
 408
 409                     // Invalidate all register values
 410                     InvalidateIfNeeded (true);
 411
 412                     if (gdb_comm.SendPacketAndWaitForResponse(packet.GetString().c_str(),
 413                                                               packet.GetString().size(),
 414                                                               response,
 415                                                               false))
 416                     {
 417                         SetAllRegisterValid (false);
 418                         if (response.IsOKResponse())
 419                         {
 420                             return true;
 421                         }
 422                     }
 423                 }
 424                 else
 425                 {
 426                     bool success = true;
 427
 428                     if (reg_info->value_regs)
 429                     {
 430                         // This register is part of another register. In this case we read the actual
 431                         // register data for any "value_regs", and once all that data is read, we will
 432                         // have enough data in our register context bytes for the value of this register
 433
 434                         // Invalidate this composite register first.
 435
 436                         for (uint32_t idx = 0; success; ++idx)
 437                         {
 438                             const uint32_t reg = reg_info->value_regs[idx];
 439                             if (reg == LLDB_INVALID_REGNUM)
 440                                 break;
 441                             // We have a valid primordial regsiter as our constituent.
 442                             // Grab the corresponding register info.
 443                             const RegisterInfo *value_reg_info = GetRegisterInfoAtIndex(reg);
 444                             if (value_reg_info == NULL)
 445                                 success = false;
 446                             else
 447                                 success = SetPrimordialRegister(value_reg_info, gdb_comm);
 448                         }
 449                     }
 450                     else
 451                     {
 452                         // This is an actual register, write it
 453                         success = SetPrimordialRegister(reg_info, gdb_comm);
 454                     }
 455
 456                     // Check if writing this register will invalidate any other register values?
 457                     // If so, invalidate them
 458                     if (reg_info->invalidate_regs)
 459                     {
 460                         for (uint32_t idx = 0, reg = reg_info->invalidate_regs[0];
 461                              reg != LLDB_INVALID_REGNUM;
 462                              reg = reg_info->invalidate_regs[++idx])
 463                         {
 464                             SetRegisterIsValid(reg, false);
 465                         }
 466                     }
 467
 468                     return success;
 469                 }
 470             }
 471         }
 472         else
 473         {
 474             Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet (GDBR_LOG_THREAD | GDBR_LOG_PACKETS));
 475             if (log)
 476             {
 477                 if (log->GetVerbose())
 478                 {
 479                     StreamString strm;
 480                     gdb_comm.DumpHistory(strm);
 481                     log->Printf("error: failed to get packet sequence mutex, not sending write register for \"%s\":\n%s", reg_info->name, strm.GetData());
 482                 }
 483                 else
 484                     log->Printf("error: failed to get packet sequence mutex, not sending write register for \"%s\"", reg_info->name);
 485             }
 486         }
 487     }
 488     return false;
 489 }
 490
 491
 492 bool
 493 GDBRemoteRegisterContext::ReadAllRegisterValues (lldb::DataBufferSP &data_sp)
 494 {
 495     ExecutionContext exe_ctx (CalculateThread());
 496
 497     Process *process = exe_ctx.GetProcessPtr();
 498     Thread *thread = exe_ctx.GetThreadPtr();
 499     if (process == NULL || thread == NULL)
 500         return false;
 501
 502     GDBRemoteCommunicationClient &gdb_comm (((ProcessGDBRemote *)process)->GetGDBRemote());
 503
 504     StringExtractorGDBRemote response;
 505
 506     Mutex::Locker locker;
 507     if (gdb_comm.GetSequenceMutex (locker, "Didn't get sequence mutex for read all registers."))
 508     {
 509         SyncThreadState(process);
 510
 511         char packet[32];
 512         const bool thread_suffix_supported = gdb_comm.GetThreadSuffixSupported();
 513         ProcessSP process_sp (m_thread.GetProcess());
 514         if (thread_suffix_supported || static_cast<ProcessGDBRemote *>(process_sp.get())->GetGDBRemote().SetCurrentThread(m_thread.GetProtocolID()))
 515         {
 516             int packet_len = 0;
 517             if (thread_suffix_supported)
 518                 packet_len = ::snprintf (packet, sizeof(packet), "g;thread:%4.4" PRIx64, m_thread.GetProtocolID());
 519             else
 520                 packet_len = ::snprintf (packet, sizeof(packet), "g");
 521             assert (packet_len < ((int)sizeof(packet) - 1));
 522
 523             if (gdb_comm.SendPacketAndWaitForResponse(packet, packet_len, response, false))
 524             {
 525                 if (response.IsErrorResponse())
 526                     return false;
 527
 528                 std::string &response_str = response.GetStringRef();
 529                 if (isxdigit(response_str[0]))
 530                 {
 531                     response_str.insert(0, 1, 'G');
 532                     if (thread_suffix_supported)
 533                     {
 534                         char thread_id_cstr[64];
 535                         ::snprintf (thread_id_cstr, sizeof(thread_id_cstr), ";thread:%4.4" PRIx64 ";", m_thread.GetProtocolID());
 536                         response_str.append (thread_id_cstr);
 537                     }
 538                     data_sp.reset (new DataBufferHeap (response_str.c_str(), response_str.size()));
 539                     return true;
 540                 }
 541             }
 542         }
 543     }
 544     else
 545     {
 546         Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet (GDBR_LOG_THREAD | GDBR_LOG_PACKETS));
 547         if (log)
 548         {
 549             if (log->GetVerbose())
 550             {
 551                 StreamString strm;
 552                 gdb_comm.DumpHistory(strm);
 553                 log->Printf("error: failed to get packet sequence mutex, not sending read all registers:\n%s", strm.GetData());
 554             }
 555             else
 556                 log->Printf("error: failed to get packet sequence mutex, not sending read all registers");
 557         }
 558     }
 559
 560     data_sp.reset();
 561     return false;
 562 }
 563
 564 bool
 565 GDBRemoteRegisterContext::WriteAllRegisterValues (const lldb::DataBufferSP &data_sp)
 566 {
 567     if (!data_sp || data_sp->GetBytes() == NULL || data_sp->GetByteSize() == 0)
 568         return false;
 569
 570     ExecutionContext exe_ctx (CalculateThread());
 571
 572     Process *process = exe_ctx.GetProcessPtr();
 573     Thread *thread = exe_ctx.GetThreadPtr();
 574     if (process == NULL || thread == NULL)
 575         return false;
 576
 577     GDBRemoteCommunicationClient &gdb_comm (((ProcessGDBRemote *)process)->GetGDBRemote());
 578
 579     StringExtractorGDBRemote response;
 580     Mutex::Locker locker;
 581     if (gdb_comm.GetSequenceMutex (locker, "Didn't get sequence mutex for write all registers."))
 582     {
 583         const bool thread_suffix_supported = gdb_comm.GetThreadSuffixSupported();
 584         ProcessSP process_sp (m_thread.GetProcess());
 585         if (thread_suffix_supported || static_cast<ProcessGDBRemote *>(process_sp.get())->GetGDBRemote().SetCurrentThread(m_thread.GetProtocolID()))
 586         {
 587             // The data_sp contains the entire G response packet including the
 588             // G, and if the thread suffix is supported, it has the thread suffix
 589             // as well.
 590             const char *G_packet = (const char *)data_sp->GetBytes();
 591             size_t G_packet_len = data_sp->GetByteSize();
 592             if (gdb_comm.SendPacketAndWaitForResponse (G_packet,
 593                                                        G_packet_len,
 594                                                        response,
 595                                                        false))
 596             {
 597                 if (response.IsOKResponse())
 598                     return true;
 599                 else if (response.IsErrorResponse())
 600                 {
 601                     uint32_t num_restored = 0;
 602                     // We need to manually go through all of the registers and
 603                     // restore them manually
 604
 605                     response.GetStringRef().assign (G_packet, G_packet_len);
 606                     response.SetFilePos(1); // Skip the leading 'G'
 607                     DataBufferHeap buffer (m_reg_data.GetByteSize(), 0);
 608                     DataExtractor restore_data (buffer.GetBytes(),
 609                                                 buffer.GetByteSize(),
 610                                                 m_reg_data.GetByteOrder(),
 611                                                 m_reg_data.GetAddressByteSize());
 612
 613                     const uint32_t bytes_extracted = response.GetHexBytes ((void *)restore_data.GetDataStart(),
 614                                                                            restore_data.GetByteSize(),
 615                                                                            '\xcc');
 616
 617                     if (bytes_extracted < restore_data.GetByteSize())
 618                         restore_data.SetData(restore_data.GetDataStart(), bytes_extracted, m_reg_data.GetByteOrder());
 619
 620                     //ReadRegisterBytes (const RegisterInfo *reg_info, RegisterValue &value, DataExtractor &data)
 621                     const RegisterInfo *reg_info;
 622                     // We have to march the offset of each register along in the
 623                     // buffer to make sure we get the right offset.
 624                     uint32_t reg_byte_offset = 0;
 625                     for (uint32_t reg_idx=0; (reg_info = GetRegisterInfoAtIndex (reg_idx)) != NULL; ++reg_idx, reg_byte_offset += reg_info->byte_size)
 626                     {
 627                         const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
 628
 629                         // Skip composite registers.
 630                         if (reg_info->value_regs)
 631                             continue;
 632
 633                         // Only write down the registers that need to be written
 634                         // if we are going to be doing registers individually.
 635                         bool write_reg = true;
 636                         const uint32_t reg_byte_size = reg_info->byte_size;
 637
 638                         const char *restore_src = (const char *)restore_data.PeekData(reg_byte_offset, reg_byte_size);
 639                         if (restore_src)
 640                         {
 641                             if (GetRegisterIsValid(reg))
 642                             {
 643                                 const char *current_src = (const char *)m_reg_data.PeekData(reg_byte_offset, reg_byte_size);
 644                                 if (current_src)
 645                                     write_reg = memcmp (current_src, restore_src, reg_byte_size) != 0;
 646                             }
 647
 648                             if (write_reg)
 649                             {
 650                                 StreamString packet;
 651                                 packet.Printf ("P%x=", reg);
 652                                 packet.PutBytesAsRawHex8 (restore_src,
 653                                                           reg_byte_size,
 654                                                           lldb::endian::InlHostByteOrder(),
 655                                                           lldb::endian::InlHostByteOrder());
 656
 657                                 if (thread_suffix_supported)
 658                                     packet.Printf (";thread:%4.4" PRIx64 ";", m_thread.GetProtocolID());
 659
 660                                 SetRegisterIsValid(reg, false);
 661                                 if (gdb_comm.SendPacketAndWaitForResponse(packet.GetString().c_str(),
 662                                                                           packet.GetString().size(),
 663                                                                           response,
 664                                                                           false))
 665                                 {
 666                                     if (response.IsOKResponse())
 667                                         ++num_restored;
 668                                 }
 669                             }
 670                         }
 671                     }
 672                     return num_restored > 0;
 673                 }
 674             }
 675         }
 676     }
 677     else
 678     {
 679         Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet (GDBR_LOG_THREAD | GDBR_LOG_PACKETS));
 680         if (log)
 681         {
 682             if (log->GetVerbose())
 683             {
 684                 StreamString strm;
 685                 gdb_comm.DumpHistory(strm);
 686                 log->Printf("error: failed to get packet sequence mutex, not sending write all registers:\n%s", strm.GetData());
 687             }
 688             else
 689                 log->Printf("error: failed to get packet sequence mutex, not sending write all registers");
 690         }
 691     }
 692     return false;
 693 }
 694
 695
 696 uint32_t
 697 GDBRemoteRegisterContext::ConvertRegisterKindToRegisterNumber (uint32_t kind, uint32_t num)
 698 {
 699     return m_reg_info.ConvertRegisterKindToRegisterNumber (kind, num);
 700 }
 701
 702
 703 void
 704 GDBRemoteDynamicRegisterInfo::HardcodeARMRegisters(bool from_scratch)
 705 {
 706     // For Advanced SIMD and VFP register mapping.
 707     static uint32_t g_d0_regs[] =  { 26, 27, LLDB_INVALID_REGNUM }; // (s0, s1)
 708     static uint32_t g_d1_regs[] =  { 28, 29, LLDB_INVALID_REGNUM }; // (s2, s3)
 709     static uint32_t g_d2_regs[] =  { 30, 31, LLDB_INVALID_REGNUM }; // (s4, s5)
 710     static uint32_t g_d3_regs[] =  { 32, 33, LLDB_INVALID_REGNUM }; // (s6, s7)
 711     static uint32_t g_d4_regs[] =  { 34, 35, LLDB_INVALID_REGNUM }; // (s8, s9)
 712     static uint32_t g_d5_regs[] =  { 36, 37, LLDB_INVALID_REGNUM }; // (s10, s11)
 713     static uint32_t g_d6_regs[] =  { 38, 39, LLDB_INVALID_REGNUM }; // (s12, s13)
 714     static uint32_t g_d7_regs[] =  { 40, 41, LLDB_INVALID_REGNUM }; // (s14, s15)
 715     static uint32_t g_d8_regs[] =  { 42, 43, LLDB_INVALID_REGNUM }; // (s16, s17)
 716     static uint32_t g_d9_regs[] =  { 44, 45, LLDB_INVALID_REGNUM }; // (s18, s19)
 717     static uint32_t g_d10_regs[] = { 46, 47, LLDB_INVALID_REGNUM }; // (s20, s21)
 718     static uint32_t g_d11_regs[] = { 48, 49, LLDB_INVALID_REGNUM }; // (s22, s23)
 719     static uint32_t g_d12_regs[] = { 50, 51, LLDB_INVALID_REGNUM }; // (s24, s25)
 720     static uint32_t g_d13_regs[] = { 52, 53, LLDB_INVALID_REGNUM }; // (s26, s27)
 721     static uint32_t g_d14_regs[] = { 54, 55, LLDB_INVALID_REGNUM }; // (s28, s29)
 722     static uint32_t g_d15_regs[] = { 56, 57, LLDB_INVALID_REGNUM }; // (s30, s31)
 723     static uint32_t g_q0_regs[] =  { 26, 27, 28, 29, LLDB_INVALID_REGNUM }; // (d0, d1) -> (s0, s1, s2, s3)
 724     static uint32_t g_q1_regs[] =  { 30, 31, 32, 33, LLDB_INVALID_REGNUM }; // (d2, d3) -> (s4, s5, s6, s7)
 725     static uint32_t g_q2_regs[] =  { 34, 35, 36, 37, LLDB_INVALID_REGNUM }; // (d4, d5) -> (s8, s9, s10, s11)
 726     static uint32_t g_q3_regs[] =  { 38, 39, 40, 41, LLDB_INVALID_REGNUM }; // (d6, d7) -> (s12, s13, s14, s15)
 727     static uint32_t g_q4_regs[] =  { 42, 43, 44, 45, LLDB_INVALID_REGNUM }; // (d8, d9) -> (s16, s17, s18, s19)
 728     static uint32_t g_q5_regs[] =  { 46, 47, 48, 49, LLDB_INVALID_REGNUM }; // (d10, d11) -> (s20, s21, s22, s23)
 729     static uint32_t g_q6_regs[] =  { 50, 51, 52, 53, LLDB_INVALID_REGNUM }; // (d12, d13) -> (s24, s25, s26, s27)
 730     static uint32_t g_q7_regs[] =  { 54, 55, 56, 57, LLDB_INVALID_REGNUM }; // (d14, d15) -> (s28, s29, s30, s31)
 731     static uint32_t g_q8_regs[] =  { 59, 60, LLDB_INVALID_REGNUM }; // (d16, d17)
 732     static uint32_t g_q9_regs[] =  { 61, 62, LLDB_INVALID_REGNUM }; // (d18, d19)
 733     static uint32_t g_q10_regs[] = { 63, 64, LLDB_INVALID_REGNUM }; // (d20, d21)
 734     static uint32_t g_q11_regs[] = { 65, 66, LLDB_INVALID_REGNUM }; // (d22, d23)
 735     static uint32_t g_q12_regs[] = { 67, 68, LLDB_INVALID_REGNUM }; // (d24, d25)
 736     static uint32_t g_q13_regs[] = { 69, 70, LLDB_INVALID_REGNUM }; // (d26, d27)
 737     static uint32_t g_q14_regs[] = { 71, 72, LLDB_INVALID_REGNUM }; // (d28, d29)
 738     static uint32_t g_q15_regs[] = { 73, 74, LLDB_INVALID_REGNUM }; // (d30, d31)
 739
 740     // This is our array of composite registers, with each element coming from the above register mappings.
 741     static uint32_t *g_composites[] = {
 742         g_d0_regs, g_d1_regs,  g_d2_regs,  g_d3_regs,  g_d4_regs,  g_d5_regs,  g_d6_regs,  g_d7_regs,
 743         g_d8_regs, g_d9_regs, g_d10_regs, g_d11_regs, g_d12_regs, g_d13_regs, g_d14_regs, g_d15_regs,
 744         g_q0_regs, g_q1_regs,  g_q2_regs,  g_q3_regs,  g_q4_regs,  g_q5_regs,  g_q6_regs,  g_q7_regs,
 745         g_q8_regs, g_q9_regs, g_q10_regs, g_q11_regs, g_q12_regs, g_q13_regs, g_q14_regs, g_q15_regs
 746     };
 747
 748     static RegisterInfo g_register_infos[] = {
 749 //   NAME    ALT    SZ  OFF  ENCODING          FORMAT          COMPILER             DWARF                GENERIC                 GDB    LLDB      VALUE REGS    INVALIDATE REGS
 750 //   ======  ====== === ===  =============     ============    ===================  ===================  ======================  ===    ====      ==========    ===============
 751     { "r0", "arg1",   4,   0, eEncodingUint,    eFormatHex,   { gcc_r0,              dwarf_r0,            LLDB_REGNUM_GENERIC_ARG1,0,      0 },        NULL,              NULL},
 752     { "r1", "arg2",   4,   0, eEncodingUint,    eFormatHex,   { gcc_r1,              dwarf_r1,            LLDB_REGNUM_GENERIC_ARG2,1,      1 },        NULL,              NULL},
 753     { "r2", "arg3",   4,   0, eEncodingUint,    eFormatHex,   { gcc_r2,              dwarf_r2,            LLDB_REGNUM_GENERIC_ARG3,2,      2 },        NULL,              NULL},
 754     { "r3", "arg4",   4,   0, eEncodingUint,    eFormatHex,   { gcc_r3,              dwarf_r3,            LLDB_REGNUM_GENERIC_ARG4,3,      3 },        NULL,              NULL},
 755     { "r4",   NULL,   4,   0, eEncodingUint,    eFormatHex,   { gcc_r4,              dwarf_r4,            LLDB_INVALID_REGNUM,     4,      4 },        NULL,              NULL},
 756     { "r5",   NULL,   4,   0, eEncodingUint,    eFormatHex,   { gcc_r5,              dwarf_r5,            LLDB_INVALID_REGNUM,     5,      5 },        NULL,              NULL},
 757     { "r6",   NULL,   4,   0, eEncodingUint,    eFormatHex,   { gcc_r6,              dwarf_r6,            LLDB_INVALID_REGNUM,     6,      6 },        NULL,              NULL},
 758     { "r7",   "fp",   4,   0, eEncodingUint,    eFormatHex,   { gcc_r7,              dwarf_r7,            LLDB_REGNUM_GENERIC_FP,  7,      7 },        NULL,              NULL},
 759     { "r8",   NULL,   4,   0, eEncodingUint,    eFormatHex,   { gcc_r8,              dwarf_r8,            LLDB_INVALID_REGNUM,     8,      8 },        NULL,              NULL},
 760     { "r9",   NULL,   4,   0, eEncodingUint,    eFormatHex,   { gcc_r9,              dwarf_r9,            LLDB_INVALID_REGNUM,     9,      9 },        NULL,              NULL},
 761     { "r10",  NULL,   4,   0, eEncodingUint,    eFormatHex,   { gcc_r10,             dwarf_r10,           LLDB_INVALID_REGNUM,    10,     10 },        NULL,              NULL},
 762     { "r11",  NULL,   4,   0, eEncodingUint,    eFormatHex,   { gcc_r11,             dwarf_r11,           LLDB_INVALID_REGNUM,    11,     11 },        NULL,              NULL},
 763     { "r12",  NULL,   4,   0, eEncodingUint,    eFormatHex,   { gcc_r12,             dwarf_r12,           LLDB_INVALID_REGNUM,    12,     12 },        NULL,              NULL},
 764     { "sp",   "r13",  4,   0, eEncodingUint,    eFormatHex,   { gcc_sp,              dwarf_sp,            LLDB_REGNUM_GENERIC_SP, 13,     13 },        NULL,              NULL},
 765     { "lr",   "r14",  4,   0, eEncodingUint,    eFormatHex,   { gcc_lr,              dwarf_lr,            LLDB_REGNUM_GENERIC_RA, 14,     14 },        NULL,              NULL},
 766     { "pc",   "r15",  4,   0, eEncodingUint,    eFormatHex,   { gcc_pc,              dwarf_pc,            LLDB_REGNUM_GENERIC_PC, 15,     15 },        NULL,              NULL},
 767     { "f0",   NULL,  12,   0, eEncodingUint,    eFormatHex,   { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,    16,     16 },        NULL,              NULL},
 768     { "f1",   NULL,  12,   0, eEncodingUint,    eFormatHex,   { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,    17,     17 },        NULL,              NULL},
 769     { "f2",   NULL,  12,   0, eEncodingUint,    eFormatHex,   { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,    18,     18 },        NULL,              NULL},
 770     { "f3",   NULL,  12,   0, eEncodingUint,    eFormatHex,   { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,    19,     19 },        NULL,              NULL},
 771     { "f4",   NULL,  12,   0, eEncodingUint,    eFormatHex,   { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,    20,     20 },        NULL,              NULL},
 772     { "f5",   NULL,  12,   0, eEncodingUint,    eFormatHex,   { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,    21,     21 },        NULL,              NULL},
 773     { "f6",   NULL,  12,   0, eEncodingUint,    eFormatHex,   { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,    22,     22 },        NULL,              NULL},
 774     { "f7",   NULL,  12,   0, eEncodingUint,    eFormatHex,   { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,    23,     23 },        NULL,              NULL},
 775     { "fps",  NULL,   4,   0, eEncodingUint,    eFormatHex,   { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,    24,     24 },        NULL,              NULL},
 776     { "cpsr","flags", 4,   0, eEncodingUint,    eFormatHex,   { gcc_cpsr,            dwarf_cpsr,          LLDB_INVALID_REGNUM,    25,     25 },        NULL,              NULL},
 777     { "s0",   NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s0,            LLDB_INVALID_REGNUM,    26,     26 },        NULL,              NULL},
 778     { "s1",   NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s1,            LLDB_INVALID_REGNUM,    27,     27 },        NULL,              NULL},
 779     { "s2",   NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s2,            LLDB_INVALID_REGNUM,    28,     28 },        NULL,              NULL},
 780     { "s3",   NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s3,            LLDB_INVALID_REGNUM,    29,     29 },        NULL,              NULL},
 781     { "s4",   NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s4,            LLDB_INVALID_REGNUM,    30,     30 },        NULL,              NULL},
 782     { "s5",   NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s5,            LLDB_INVALID_REGNUM,    31,     31 },        NULL,              NULL},
 783     { "s6",   NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s6,            LLDB_INVALID_REGNUM,    32,     32 },        NULL,              NULL},
 784     { "s7",   NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s7,            LLDB_INVALID_REGNUM,    33,     33 },        NULL,              NULL},
 785     { "s8",   NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s8,            LLDB_INVALID_REGNUM,    34,     34 },        NULL,              NULL},
 786     { "s9",   NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s9,            LLDB_INVALID_REGNUM,    35,     35 },        NULL,              NULL},
 787     { "s10",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s10,           LLDB_INVALID_REGNUM,    36,     36 },        NULL,              NULL},
 788     { "s11",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s11,           LLDB_INVALID_REGNUM,    37,     37 },        NULL,              NULL},
 789     { "s12",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s12,           LLDB_INVALID_REGNUM,    38,     38 },        NULL,              NULL},
 790     { "s13",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s13,           LLDB_INVALID_REGNUM,    39,     39 },        NULL,              NULL},
 791     { "s14",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s14,           LLDB_INVALID_REGNUM,    40,     40 },        NULL,              NULL},
 792     { "s15",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s15,           LLDB_INVALID_REGNUM,    41,     41 },        NULL,              NULL},
 793     { "s16",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s16,           LLDB_INVALID_REGNUM,    42,     42 },        NULL,              NULL},
 794     { "s17",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s17,           LLDB_INVALID_REGNUM,    43,     43 },        NULL,              NULL},
 795     { "s18",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s18,           LLDB_INVALID_REGNUM,    44,     44 },        NULL,              NULL},
 796     { "s19",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s19,           LLDB_INVALID_REGNUM,    45,     45 },        NULL,              NULL},
 797     { "s20",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s20,           LLDB_INVALID_REGNUM,    46,     46 },        NULL,              NULL},
 798     { "s21",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s21,           LLDB_INVALID_REGNUM,    47,     47 },        NULL,              NULL},
 799     { "s22",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s22,           LLDB_INVALID_REGNUM,    48,     48 },        NULL,              NULL},
 800     { "s23",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s23,           LLDB_INVALID_REGNUM,    49,     49 },        NULL,              NULL},
 801     { "s24",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s24,           LLDB_INVALID_REGNUM,    50,     50 },        NULL,              NULL},
 802     { "s25",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s25,           LLDB_INVALID_REGNUM,    51,     51 },        NULL,              NULL},
 803     { "s26",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s26,           LLDB_INVALID_REGNUM,    52,     52 },        NULL,              NULL},
 804     { "s27",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s27,           LLDB_INVALID_REGNUM,    53,     53 },        NULL,              NULL},
 805     { "s28",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s28,           LLDB_INVALID_REGNUM,    54,     54 },        NULL,              NULL},
 806     { "s29",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s29,           LLDB_INVALID_REGNUM,    55,     55 },        NULL,              NULL},
 807     { "s30",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s30,           LLDB_INVALID_REGNUM,    56,     56 },        NULL,              NULL},
 808     { "s31",  NULL,   4,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_s31,           LLDB_INVALID_REGNUM,    57,     57 },        NULL,              NULL},
 809     { "fpscr",NULL,   4,   0, eEncodingUint,    eFormatHex,   { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,    58,     58 },        NULL,              NULL},
 810     { "d16",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d16,           LLDB_INVALID_REGNUM,    59,     59 },        NULL,              NULL},
 811     { "d17",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d17,           LLDB_INVALID_REGNUM,    60,     60 },        NULL,              NULL},
 812     { "d18",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d18,           LLDB_INVALID_REGNUM,    61,     61 },        NULL,              NULL},
 813     { "d19",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d19,           LLDB_INVALID_REGNUM,    62,     62 },        NULL,              NULL},
 814     { "d20",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d20,           LLDB_INVALID_REGNUM,    63,     63 },        NULL,              NULL},
 815     { "d21",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d21,           LLDB_INVALID_REGNUM,    64,     64 },        NULL,              NULL},
 816     { "d22",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d22,           LLDB_INVALID_REGNUM,    65,     65 },        NULL,              NULL},
 817     { "d23",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d23,           LLDB_INVALID_REGNUM,    66,     66 },        NULL,              NULL},
 818     { "d24",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d24,           LLDB_INVALID_REGNUM,    67,     67 },        NULL,              NULL},
 819     { "d25",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d25,           LLDB_INVALID_REGNUM,    68,     68 },        NULL,              NULL},
 820     { "d26",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d26,           LLDB_INVALID_REGNUM,    69,     69 },        NULL,              NULL},
 821     { "d27",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d27,           LLDB_INVALID_REGNUM,    70,     70 },        NULL,              NULL},
 822     { "d28",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d28,           LLDB_INVALID_REGNUM,    71,     71 },        NULL,              NULL},
 823     { "d29",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d29,           LLDB_INVALID_REGNUM,    72,     72 },        NULL,              NULL},
 824     { "d30",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d30,           LLDB_INVALID_REGNUM,    73,     73 },        NULL,              NULL},
 825     { "d31",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d31,           LLDB_INVALID_REGNUM,    74,     74 },        NULL,              NULL},
 826     { "d0",   NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d0,            LLDB_INVALID_REGNUM,    75,     75 },   g_d0_regs,              NULL},
 827     { "d1",   NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d1,            LLDB_INVALID_REGNUM,    76,     76 },   g_d1_regs,              NULL},
 828     { "d2",   NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d2,            LLDB_INVALID_REGNUM,    77,     77 },   g_d2_regs,              NULL},
 829     { "d3",   NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d3,            LLDB_INVALID_REGNUM,    78,     78 },   g_d3_regs,              NULL},
 830     { "d4",   NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d4,            LLDB_INVALID_REGNUM,    79,     79 },   g_d4_regs,              NULL},
 831     { "d5",   NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d5,            LLDB_INVALID_REGNUM,    80,     80 },   g_d5_regs,              NULL},
 832     { "d6",   NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d6,            LLDB_INVALID_REGNUM,    81,     81 },   g_d6_regs,              NULL},
 833     { "d7",   NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d7,            LLDB_INVALID_REGNUM,    82,     82 },   g_d7_regs,              NULL},
 834     { "d8",   NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d8,            LLDB_INVALID_REGNUM,    83,     83 },   g_d8_regs,              NULL},
 835     { "d9",   NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d9,            LLDB_INVALID_REGNUM,    84,     84 },   g_d9_regs,              NULL},
 836     { "d10",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d10,           LLDB_INVALID_REGNUM,    85,     85 },  g_d10_regs,              NULL},
 837     { "d11",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d11,           LLDB_INVALID_REGNUM,    86,     86 },  g_d11_regs,              NULL},
 838     { "d12",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d12,           LLDB_INVALID_REGNUM,    87,     87 },  g_d12_regs,              NULL},
 839     { "d13",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d13,           LLDB_INVALID_REGNUM,    88,     88 },  g_d13_regs,              NULL},
 840     { "d14",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d14,           LLDB_INVALID_REGNUM,    89,     89 },  g_d14_regs,              NULL},
 841     { "d15",  NULL,   8,   0, eEncodingIEEE754, eFormatFloat, { LLDB_INVALID_REGNUM, dwarf_d15,           LLDB_INVALID_REGNUM,    90,     90 },  g_d15_regs,              NULL},
 842     { "q0",   NULL,   16,  0, eEncodingVector,  eFormatVectorOfUInt8, { LLDB_INVALID_REGNUM, dwarf_q0,    LLDB_INVALID_REGNUM,    91,     91 },   g_q0_regs,              NULL},
 843     { "q1",   NULL,   16,  0, eEncodingVector,  eFormatVectorOfUInt8, { LLDB_INVALID_REGNUM, dwarf_q1,    LLDB_INVALID_REGNUM,    92,     92 },   g_q1_regs,              NULL},
 844     { "q2",   NULL,   16,  0, eEncodingVector,  eFormatVectorOfUInt8, { LLDB_INVALID_REGNUM, dwarf_q2,    LLDB_INVALID_REGNUM,    93,     93 },   g_q2_regs,              NULL},
 845     { "q3",   NULL,   16,  0, eEncodingVector,  eFormatVectorOfUInt8, { LLDB_INVALID_REGNUM, dwarf_q3,    LLDB_INVALID_REGNUM,    94,     94 },   g_q3_regs,              NULL},
 846     { "q4",   NULL,   16,  0, eEncodingVector,  eFormatVectorOfUInt8, { LLDB_INVALID_REGNUM, dwarf_q4,    LLDB_INVALID_REGNUM,    95,     95 },   g_q4_regs,              NULL},
 847     { "q5",   NULL,   16,  0, eEncodingVector,  eFormatVectorOfUInt8, { LLDB_INVALID_REGNUM, dwarf_q5,    LLDB_INVALID_REGNUM,    96,     96 },   g_q5_regs,              NULL},
 848     { "q6",   NULL,   16,  0, eEncodingVector,  eFormatVectorOfUInt8, { LLDB_INVALID_REGNUM, dwarf_q6,    LLDB_INVALID_REGNUM,    97,     97 },   g_q6_regs,              NULL},
 849     { "q7",   NULL,   16,  0, eEncodingVector,  eFormatVectorOfUInt8, { LLDB_INVALID_REGNUM, dwarf_q7,    LLDB_INVALID_REGNUM,    98,     98 },   g_q7_regs,              NULL},
 850     { "q8",   NULL,   16,  0, eEncodingVector,  eFormatVectorOfUInt8, { LLDB_INVALID_REGNUM, dwarf_q8,    LLDB_INVALID_REGNUM,    99,     99 },   g_q8_regs,              NULL},
 851     { "q9",   NULL,   16,  0, eEncodingVector,  eFormatVectorOfUInt8, { LLDB_INVALID_REGNUM, dwarf_q9,    LLDB_INVALID_REGNUM,   100,    100 },   g_q9_regs,              NULL},
 852     { "q10",  NULL,   16,  0, eEncodingVector,  eFormatVectorOfUInt8, { LLDB_INVALID_REGNUM, dwarf_q10,   LLDB_INVALID_REGNUM,   101,    101 },  g_q10_regs,              NULL},
 853     { "q11",  NULL,   16,  0, eEncodingVector,  eFormatVectorOfUInt8, { LLDB_INVALID_REGNUM, dwarf_q11,   LLDB_INVALID_REGNUM,   102,    102 },  g_q11_regs,              NULL},
 854     { "q12",  NULL,   16,  0, eEncodingVector,  eFormatVectorOfUInt8, { LLDB_INVALID_REGNUM, dwarf_q12,   LLDB_INVALID_REGNUM,   103,    103 },  g_q12_regs,              NULL},
 855     { "q13",  NULL,   16,  0, eEncodingVector,  eFormatVectorOfUInt8, { LLDB_INVALID_REGNUM, dwarf_q13,   LLDB_INVALID_REGNUM,   104,    104 },  g_q13_regs,              NULL},
 856     { "q14",  NULL,   16,  0, eEncodingVector,  eFormatVectorOfUInt8, { LLDB_INVALID_REGNUM, dwarf_q14,   LLDB_INVALID_REGNUM,   105,    105 },  g_q14_regs,              NULL},
 857     { "q15",  NULL,   16,  0, eEncodingVector,  eFormatVectorOfUInt8, { LLDB_INVALID_REGNUM, dwarf_q15,   LLDB_INVALID_REGNUM,   106,    106 },  g_q15_regs,              NULL}
 858     };
 859
 860     static const uint32_t num_registers = llvm::array_lengthof(g_register_infos);
 861     static ConstString gpr_reg_set ("General Purpose Registers");
 862     static ConstString sfp_reg_set ("Software Floating Point Registers");
 863     static ConstString vfp_reg_set ("Floating Point Registers");
 864     size_t i;
 865     if (from_scratch)
 866     {
 867         // Calculate the offsets of the registers
 868         // Note that the layout of the "composite" registers (d0-d15 and q0-q15) which comes after the
 869         // "primordial" registers is important.  This enables us to calculate the offset of the composite
 870         // register by using the offset of its first primordial register.  For example, to calculate the
 871         // offset of q0, use s0's offset.
 872         if (g_register_infos[2].byte_offset == 0)
 873         {
 874             uint32_t byte_offset = 0;
 875             for (i=0; i<num_registers; ++i)
 876             {
 877                 // For primordial registers, increment the byte_offset by the byte_size to arrive at the
 878                 // byte_offset for the next register.  Otherwise, we have a composite register whose
 879                 // offset can be calculated by consulting the offset of its first primordial register.
 880                 if (!g_register_infos[i].value_regs)
 881                 {
 882                     g_register_infos[i].byte_offset = byte_offset;
 883                     byte_offset += g_register_infos[i].byte_size;
 884                 }
 885                 else
 886                 {
 887                     const uint32_t first_primordial_reg = g_register_infos[i].value_regs[0];
 888                     g_register_infos[i].byte_offset = g_register_infos[first_primordial_reg].byte_offset;
 889                 }
 890             }
 891         }
 892         for (i=0; i<num_registers; ++i)
 893         {
 894             ConstString name;
 895             ConstString alt_name;
 896             if (g_register_infos[i].name && g_register_infos[i].name[0])
 897                 name.SetCString(g_register_infos[i].name);
 898             if (g_register_infos[i].alt_name && g_register_infos[i].alt_name[0])
 899                 alt_name.SetCString(g_register_infos[i].alt_name);
 900
 901             if (i <= 15 || i == 25)
 902                 AddRegister (g_register_infos[i], name, alt_name, gpr_reg_set);
 903             else if (i <= 24)
 904                 AddRegister (g_register_infos[i], name, alt_name, sfp_reg_set);
 905             else
 906                 AddRegister (g_register_infos[i], name, alt_name, vfp_reg_set);
 907         }
 908     }
 909     else
 910     {
 911         // Add composite registers to our primordial registers, then.
 912         const size_t num_composites = llvm::array_lengthof(g_composites);
 913         const size_t num_dynamic_regs = GetNumRegisters();
 914         const size_t num_common_regs = num_registers - num_composites;
 915         RegisterInfo *g_comp_register_infos = g_register_infos + num_common_regs;
 916
 917         // First we need to validate that all registers that we already have match the non composite regs.
 918         // If so, then we can add the registers, else we need to bail
 919         bool match = true;
 920         if (num_dynamic_regs == num_common_regs)
 921         {
 922             for (i=0; match && i<num_dynamic_regs; ++i)
 923             {
 924                 // Make sure all register names match
 925                 if (m_regs[i].name && g_register_infos[i].name)
 926                 {
 927                     if (strcmp(m_regs[i].name, g_register_infos[i].name))
 928                     {
 929                         match = false;
 930                         break;
 931                     }
 932                 }
 933
 934                 // Make sure all register byte sizes match
 935                 if (m_regs[i].byte_size != g_register_infos[i].byte_size)
 936                 {
 937                     match = false;
 938                     break;
 939                 }
 940             }
 941         }
 942         else
 943         {
 944             // Wrong number of registers.
 945             match = false;
 946         }
 947         // If "match" is true, then we can add extra registers.
 948         if (match)
 949         {
 950             for (i=0; i<num_composites; ++i)
 951             {
 952                 ConstString name;
 953                 ConstString alt_name;
 954                 const uint32_t first_primordial_reg = g_comp_register_infos[i].value_regs[0];
 955                 const char *reg_name = g_register_infos[first_primordial_reg].name;
 956                 if (reg_name && reg_name[0])
 957                 {
 958                     for (uint32_t j = 0; j < num_dynamic_regs; ++j)
 959                     {
 960                         const RegisterInfo *reg_info = GetRegisterInfoAtIndex(j);
 961                         // Find a matching primordial register info entry.
 962                         if (reg_info && reg_info->name && ::strcasecmp(reg_info->name, reg_name) == 0)
 963                         {
 964                             // The name matches the existing primordial entry.
 965                             // Find and assign the offset, and then add this composite register entry.
 966                             g_comp_register_infos[i].byte_offset = reg_info->byte_offset;
 967                             name.SetCString(g_comp_register_infos[i].name);
 968                             AddRegister(g_comp_register_infos[i], name, alt_name, vfp_reg_set);
 969                         }
 970                     }
 971                 }
 972             }
 973         }
 974     }
 975 }