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