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

   1 //===-- ThreadGDBRemote.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
  11 #include "ThreadGDBRemote.h"
  12
  13 #include "lldb/Breakpoint/Watchpoint.h"
  14 #include "lldb/Core/ArchSpec.h"
  15 #include "lldb/Core/DataExtractor.h"
  16 #include "lldb/Core/State.h"
  17 #include "lldb/Core/StreamString.h"
  18 #include "lldb/Target/Platform.h"
  19 #include "lldb/Target/Process.h"
  20 #include "lldb/Target/RegisterContext.h"
  21 #include "lldb/Target/StopInfo.h"
  22 #include "lldb/Target/SystemRuntime.h"
  23 #include "lldb/Target/Target.h"
  24 #include "lldb/Target/Unwind.h"
  25
  26 #include "ProcessGDBRemote.h"
  27 #include "ProcessGDBRemoteLog.h"
  28 #include "Utility/StringExtractorGDBRemote.h"
  29
  30 using namespace lldb;
  31 using namespace lldb_private;
  32
  33 //----------------------------------------------------------------------
  34 // Thread Registers
  35 //----------------------------------------------------------------------
  36
  37 ThreadGDBRemote::ThreadGDBRemote (Process &process, lldb::tid_t tid) :
  38     Thread(process, tid),
  39     m_thread_name (),
  40     m_dispatch_queue_name (),
  41     m_thread_dispatch_qaddr (LLDB_INVALID_ADDRESS)
  42 {
  43     ProcessGDBRemoteLog::LogIf(GDBR_LOG_THREAD, "%p: ThreadGDBRemote::ThreadGDBRemote (pid = %i, tid = 0x%4.4x)",
  44                                this,
  45                                process.GetID(),
  46                                GetID());
  47 }
  48
  49 ThreadGDBRemote::~ThreadGDBRemote ()
  50 {
  51     ProcessSP process_sp(GetProcess());
  52     ProcessGDBRemoteLog::LogIf(GDBR_LOG_THREAD, "%p: ThreadGDBRemote::~ThreadGDBRemote (pid = %i, tid = 0x%4.4x)",
  53                                this,
  54                                process_sp ? process_sp->GetID() : LLDB_INVALID_PROCESS_ID,
  55                                GetID());
  56     DestroyThread();
  57 }
  58
  59 const char *
  60 ThreadGDBRemote::GetName ()
  61 {
  62     if (m_thread_name.empty())
  63         return NULL;
  64     return m_thread_name.c_str();
  65 }
  66
  67
  68 const char *
  69 ThreadGDBRemote::GetQueueName ()
  70 {
  71     // Always re-fetch the dispatch queue name since it can change
  72
  73     if (m_thread_dispatch_qaddr != 0 || m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS)
  74     {
  75         ProcessSP process_sp (GetProcess());
  76         if (process_sp)
  77         {
  78             SystemRuntime *runtime = process_sp->GetSystemRuntime ();
  79             if (runtime)
  80             {
  81                 m_dispatch_queue_name = runtime->GetQueueNameFromThreadQAddress (m_thread_dispatch_qaddr);
  82             }
  83             if (m_dispatch_queue_name.length() > 0)
  84             {
  85                 return m_dispatch_queue_name.c_str();
  86             }
  87         }
  88     }
  89     return NULL;
  90 }
  91
  92 queue_id_t
  93 ThreadGDBRemote::GetQueueID ()
  94 {
  95     if (m_thread_dispatch_qaddr != 0 || m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS)
  96     {
  97         ProcessSP process_sp (GetProcess());
  98         if (process_sp)
  99         {
 100             SystemRuntime *runtime = process_sp->GetSystemRuntime ();
 101             if (runtime)
 102             {
 103                 return runtime->GetQueueIDFromThreadQAddress (m_thread_dispatch_qaddr);
 104             }
 105         }
 106     }
 107     return LLDB_INVALID_QUEUE_ID;
 108 }
 109
 110 QueueSP
 111 ThreadGDBRemote::GetQueue ()
 112 {
 113     queue_id_t queue_id = GetQueueID();
 114     QueueSP queue;
 115     if (queue_id != LLDB_INVALID_QUEUE_ID)
 116     {
 117         ProcessSP process_sp (GetProcess());
 118         if (process_sp)
 119         {
 120             queue = process_sp->GetQueueList().FindQueueByID (queue_id);
 121         }
 122     }
 123     return queue;
 124 }
 125
 126 addr_t
 127 ThreadGDBRemote::GetQueueLibdispatchQueueAddress ()
 128 {
 129     addr_t dispatch_queue_t_addr = LLDB_INVALID_ADDRESS;
 130     if (m_thread_dispatch_qaddr != 0 || m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS)
 131     {
 132         ProcessSP process_sp (GetProcess());
 133         if (process_sp)
 134         {
 135             SystemRuntime *runtime = process_sp->GetSystemRuntime ();
 136             if (runtime)
 137             {
 138                 dispatch_queue_t_addr = runtime->GetLibdispatchQueueAddressFromThreadQAddress (m_thread_dispatch_qaddr);
 139             }
 140         }
 141     }
 142     return dispatch_queue_t_addr;
 143 }
 144
 145 StructuredData::ObjectSP
 146 ThreadGDBRemote::FetchThreadExtendedInfo ()
 147 {
 148     StructuredData::ObjectSP object_sp;
 149     const lldb::user_id_t tid = GetProtocolID();
 150     Log *log(lldb_private::GetLogIfAnyCategoriesSet (GDBR_LOG_THREAD));
 151     if (log)
 152         log->Printf ("Fetching extended information for thread %4.4" PRIx64, tid);
 153     ProcessSP process_sp (GetProcess());
 154     if (process_sp)
 155     {
 156         ProcessGDBRemote *gdb_process = static_cast<ProcessGDBRemote *>(process_sp.get());
 157         object_sp = gdb_process->GetExtendedInfoForThread (tid);
 158     }
 159     return object_sp;
 160 }
 161
 162 void
 163 ThreadGDBRemote::WillResume (StateType resume_state)
 164 {
 165     int signo = GetResumeSignal();
 166     const lldb::user_id_t tid = GetProtocolID();
 167     Log *log(lldb_private::GetLogIfAnyCategoriesSet (GDBR_LOG_THREAD));
 168     if (log)
 169         log->Printf ("Resuming thread: %4.4" PRIx64 " with state: %s.", tid, StateAsCString(resume_state));
 170
 171     ProcessSP process_sp (GetProcess());
 172     if (process_sp)
 173     {
 174         ProcessGDBRemote *gdb_process = static_cast<ProcessGDBRemote *>(process_sp.get());
 175         switch (resume_state)
 176         {
 177         case eStateSuspended:
 178         case eStateStopped:
 179             // Don't append anything for threads that should stay stopped.
 180             break;
 181
 182         case eStateRunning:
 183             if (gdb_process->GetUnixSignals().SignalIsValid (signo))
 184                 gdb_process->m_continue_C_tids.push_back(std::make_pair(tid, signo));
 185             else
 186                 gdb_process->m_continue_c_tids.push_back(tid);
 187             break;
 188
 189         case eStateStepping:
 190             if (gdb_process->GetUnixSignals().SignalIsValid (signo))
 191                 gdb_process->m_continue_S_tids.push_back(std::make_pair(tid, signo));
 192             else
 193                 gdb_process->m_continue_s_tids.push_back(tid);
 194             break;
 195
 196         default:
 197             break;
 198         }
 199     }
 200 }
 201
 202 void
 203 ThreadGDBRemote::RefreshStateAfterStop()
 204 {
 205     // Invalidate all registers in our register context. We don't set "force" to
 206     // true because the stop reply packet might have had some register values
 207     // that were expedited and these will already be copied into the register
 208     // context by the time this function gets called. The GDBRemoteRegisterContext
 209     // class has been made smart enough to detect when it needs to invalidate
 210     // which registers are valid by putting hooks in the register read and
 211     // register supply functions where they check the process stop ID and do
 212     // the right thing.
 213     const bool force = false;
 214     GetRegisterContext()->InvalidateIfNeeded (force);
 215 }
 216
 217 bool
 218 ThreadGDBRemote::ThreadIDIsValid (lldb::tid_t thread)
 219 {
 220     return thread != 0;
 221 }
 222
 223 void
 224 ThreadGDBRemote::Dump(Log *log, uint32_t index)
 225 {
 226 }
 227
 228
 229 bool
 230 ThreadGDBRemote::ShouldStop (bool &step_more)
 231 {
 232     return true;
 233 }
 234 lldb::RegisterContextSP
 235 ThreadGDBRemote::GetRegisterContext ()
 236 {
 237     if (m_reg_context_sp.get() == NULL)
 238         m_reg_context_sp = CreateRegisterContextForFrame (NULL);
 239     return m_reg_context_sp;
 240 }
 241
 242 lldb::RegisterContextSP
 243 ThreadGDBRemote::CreateRegisterContextForFrame (StackFrame *frame)
 244 {
 245     lldb::RegisterContextSP reg_ctx_sp;
 246     uint32_t concrete_frame_idx = 0;
 247
 248     if (frame)
 249         concrete_frame_idx = frame->GetConcreteFrameIndex ();
 250
 251
 252     if (concrete_frame_idx == 0)
 253     {
 254         ProcessSP process_sp (GetProcess());
 255         if (process_sp)
 256         {
 257             ProcessGDBRemote *gdb_process = static_cast<ProcessGDBRemote *>(process_sp.get());
 258             // read_all_registers_at_once will be true if 'p' packet is not supported.
 259             bool read_all_registers_at_once = !gdb_process->GetGDBRemote().GetpPacketSupported (GetID());
 260             reg_ctx_sp.reset (new GDBRemoteRegisterContext (*this, concrete_frame_idx, gdb_process->m_register_info, read_all_registers_at_once));
 261         }
 262     }
 263     else
 264     {
 265         Unwind *unwinder = GetUnwinder ();
 266         if (unwinder)
 267             reg_ctx_sp = unwinder->CreateRegisterContextForFrame (frame);
 268     }
 269     return reg_ctx_sp;
 270 }
 271
 272 bool
 273 ThreadGDBRemote::PrivateSetRegisterValue (uint32_t reg, StringExtractor &response)
 274 {
 275     GDBRemoteRegisterContext *gdb_reg_ctx = static_cast<GDBRemoteRegisterContext *>(GetRegisterContext ().get());
 276     assert (gdb_reg_ctx);
 277     return gdb_reg_ctx->PrivateSetRegisterValue (reg, response);
 278 }
 279
 280 bool
 281 ThreadGDBRemote::CalculateStopInfo ()
 282 {
 283     ProcessSP process_sp (GetProcess());
 284     if (process_sp)
 285     {
 286         StringExtractorGDBRemote stop_packet;
 287         ProcessGDBRemote *gdb_process = static_cast<ProcessGDBRemote *>(process_sp.get());
 288         if (gdb_process->GetGDBRemote().GetThreadStopInfo(GetProtocolID(), stop_packet))
 289             return gdb_process->SetThreadStopInfo (stop_packet) == eStateStopped;
 290     }
 291     return false;
 292 }
 293
 294