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