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 void
 111 ThreadGDBRemote::WillResume (StateType resume_state)
 112 {
 113     int signo = GetResumeSignal();
 114     const lldb::user_id_t tid = GetProtocolID();
 115     Log *log(lldb_private::GetLogIfAnyCategoriesSet (GDBR_LOG_THREAD));
 116     if (log)
 117         log->Printf ("Resuming thread: %4.4" PRIx64 " with state: %s.", tid, StateAsCString(resume_state));
 118
 119     ProcessSP process_sp (GetProcess());
 120     if (process_sp)
 121     {
 122         ProcessGDBRemote *gdb_process = static_cast<ProcessGDBRemote *>(process_sp.get());
 123         switch (resume_state)
 124         {
 125         case eStateSuspended:
 126         case eStateStopped:
 127             // Don't append anything for threads that should stay stopped.
 128             break;
 129
 130         case eStateRunning:
 131             if (gdb_process->GetUnixSignals().SignalIsValid (signo))
 132                 gdb_process->m_continue_C_tids.push_back(std::make_pair(tid, signo));
 133             else
 134                 gdb_process->m_continue_c_tids.push_back(tid);
 135             break;
 136
 137         case eStateStepping:
 138             if (gdb_process->GetUnixSignals().SignalIsValid (signo))
 139                 gdb_process->m_continue_S_tids.push_back(std::make_pair(tid, signo));
 140             else
 141                 gdb_process->m_continue_s_tids.push_back(tid);
 142             break;
 143
 144         default:
 145             break;
 146         }
 147     }
 148 }
 149
 150 void
 151 ThreadGDBRemote::RefreshStateAfterStop()
 152 {
 153     // Invalidate all registers in our register context. We don't set "force" to
 154     // true because the stop reply packet might have had some register values
 155     // that were expedited and these will already be copied into the register
 156     // context by the time this function gets called. The GDBRemoteRegisterContext
 157     // class has been made smart enough to detect when it needs to invalidate
 158     // which registers are valid by putting hooks in the register read and
 159     // register supply functions where they check the process stop ID and do
 160     // the right thing.
 161     const bool force = false;
 162     GetRegisterContext()->InvalidateIfNeeded (force);
 163 }
 164
 165 bool
 166 ThreadGDBRemote::ThreadIDIsValid (lldb::tid_t thread)
 167 {
 168     return thread != 0;
 169 }
 170
 171 void
 172 ThreadGDBRemote::Dump(Log *log, uint32_t index)
 173 {
 174 }
 175
 176
 177 bool
 178 ThreadGDBRemote::ShouldStop (bool &step_more)
 179 {
 180     return true;
 181 }
 182 lldb::RegisterContextSP
 183 ThreadGDBRemote::GetRegisterContext ()
 184 {
 185     if (m_reg_context_sp.get() == NULL)
 186         m_reg_context_sp = CreateRegisterContextForFrame (NULL);
 187     return m_reg_context_sp;
 188 }
 189
 190 lldb::RegisterContextSP
 191 ThreadGDBRemote::CreateRegisterContextForFrame (StackFrame *frame)
 192 {
 193     lldb::RegisterContextSP reg_ctx_sp;
 194     uint32_t concrete_frame_idx = 0;
 195
 196     if (frame)
 197         concrete_frame_idx = frame->GetConcreteFrameIndex ();
 198
 199
 200     if (concrete_frame_idx == 0)
 201     {
 202         ProcessSP process_sp (GetProcess());
 203         if (process_sp)
 204         {
 205             ProcessGDBRemote *gdb_process = static_cast<ProcessGDBRemote *>(process_sp.get());
 206             // read_all_registers_at_once will be true if 'p' packet is not supported.
 207             bool read_all_registers_at_once = !gdb_process->GetGDBRemote().GetpPacketSupported (GetID());
 208             reg_ctx_sp.reset (new GDBRemoteRegisterContext (*this, concrete_frame_idx, gdb_process->m_register_info, read_all_registers_at_once));
 209         }
 210     }
 211     else
 212     {
 213         Unwind *unwinder = GetUnwinder ();
 214         if (unwinder)
 215             reg_ctx_sp = unwinder->CreateRegisterContextForFrame (frame);
 216     }
 217     return reg_ctx_sp;
 218 }
 219
 220 bool
 221 ThreadGDBRemote::PrivateSetRegisterValue (uint32_t reg, StringExtractor &response)
 222 {
 223     GDBRemoteRegisterContext *gdb_reg_ctx = static_cast<GDBRemoteRegisterContext *>(GetRegisterContext ().get());
 224     assert (gdb_reg_ctx);
 225     return gdb_reg_ctx->PrivateSetRegisterValue (reg, response);
 226 }
 227
 228 bool
 229 ThreadGDBRemote::CalculateStopInfo ()
 230 {
 231     ProcessSP process_sp (GetProcess());
 232     if (process_sp)
 233     {
 234         StringExtractorGDBRemote stop_packet;
 235         ProcessGDBRemote *gdb_process = static_cast<ProcessGDBRemote *>(process_sp.get());
 236         if (gdb_process->GetGDBRemote().GetThreadStopInfo(GetProtocolID(), stop_packet))
 237             return gdb_process->SetThreadStopInfo (stop_packet) == eStateStopped;
 238     }
 239     return false;
 240 }
 241
 242