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/Core/ArchSpec.h"
  14 #include "lldb/Core/DataExtractor.h"
  15 #include "lldb/Core/StreamString.h"
  16 #include "lldb/Core/State.h"
  17 #include "lldb/Target/Process.h"
  18 #include "lldb/Target/RegisterContext.h"
  19 #include "lldb/Target/StopInfo.h"
  20 #include "lldb/Target/Target.h"
  21 #include "lldb/Target/Unwind.h"
  22 #include "lldb/Breakpoint/Watchpoint.h"
  23
  24 #include "ProcessGDBRemote.h"
  25 #include "ProcessGDBRemoteLog.h"
  26 #include "Utility/StringExtractorGDBRemote.h"
  27
  28 using namespace lldb;
  29 using namespace lldb_private;
  30
  31 //----------------------------------------------------------------------
  32 // Thread Registers
  33 //----------------------------------------------------------------------
  34
  35 ThreadGDBRemote::ThreadGDBRemote (Process &process, lldb::tid_t tid) :
  36     Thread(process, tid),
  37     m_thread_name (),
  38     m_dispatch_queue_name (),
  39     m_thread_dispatch_qaddr (LLDB_INVALID_ADDRESS)
  40 {
  41     ProcessGDBRemoteLog::LogIf(GDBR_LOG_THREAD, "%p: ThreadGDBRemote::ThreadGDBRemote (pid = %i, tid = 0x%4.4x)",
  42                                this,
  43                                process.GetID(),
  44                                GetID());
  45 }
  46
  47 ThreadGDBRemote::~ThreadGDBRemote ()
  48 {
  49     ProcessSP process_sp(GetProcess());
  50     ProcessGDBRemoteLog::LogIf(GDBR_LOG_THREAD, "%p: ThreadGDBRemote::~ThreadGDBRemote (pid = %i, tid = 0x%4.4x)",
  51                                this,
  52                                process_sp ? process_sp->GetID() : LLDB_INVALID_PROCESS_ID,
  53                                GetID());
  54     DestroyThread();
  55 }
  56
  57 const char *
  58 ThreadGDBRemote::GetName ()
  59 {
  60     if (m_thread_name.empty())
  61         return NULL;
  62     return m_thread_name.c_str();
  63 }
  64
  65
  66 const char *
  67 ThreadGDBRemote::GetQueueName ()
  68 {
  69     // Always re-fetch the dispatch queue name since it can change
  70
  71     if (m_thread_dispatch_qaddr != 0 || m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS)
  72     {
  73         ProcessSP process_sp (GetProcess());
  74         if (process_sp)
  75         {
  76             ProcessGDBRemote *gdb_process = static_cast<ProcessGDBRemote *>(process_sp.get());
  77             return gdb_process->GetDispatchQueueNameForThread (m_thread_dispatch_qaddr, m_dispatch_queue_name);
  78         }
  79     }
  80     return NULL;
  81 }
  82
  83 void
  84 ThreadGDBRemote::WillResume (StateType resume_state)
  85 {
  86     int signo = GetResumeSignal();
  87     const lldb::user_id_t tid = GetProtocolID();
  88     Log *log(lldb_private::GetLogIfAnyCategoriesSet (GDBR_LOG_THREAD));
  89     if (log)
  90         log->Printf ("Resuming thread: %4.4" PRIx64 " with state: %s.", tid, StateAsCString(resume_state));
  91
  92     ProcessSP process_sp (GetProcess());
  93     if (process_sp)
  94     {
  95         ProcessGDBRemote *gdb_process = static_cast<ProcessGDBRemote *>(process_sp.get());
  96         switch (resume_state)
  97         {
  98         case eStateSuspended:
  99         case eStateStopped:
 100             // Don't append anything for threads that should stay stopped.
 101             break;
 102
 103         case eStateRunning:
 104             if (gdb_process->GetUnixSignals().SignalIsValid (signo))
 105                 gdb_process->m_continue_C_tids.push_back(std::make_pair(tid, signo));
 106             else
 107                 gdb_process->m_continue_c_tids.push_back(tid);
 108             break;
 109
 110         case eStateStepping:
 111             if (gdb_process->GetUnixSignals().SignalIsValid (signo))
 112                 gdb_process->m_continue_S_tids.push_back(std::make_pair(tid, signo));
 113             else
 114                 gdb_process->m_continue_s_tids.push_back(tid);
 115             break;
 116
 117         default:
 118             break;
 119         }
 120     }
 121 }
 122
 123 void
 124 ThreadGDBRemote::RefreshStateAfterStop()
 125 {
 126     // Invalidate all registers in our register context. We don't set "force" to
 127     // true because the stop reply packet might have had some register values
 128     // that were expedited and these will already be copied into the register
 129     // context by the time this function gets called. The GDBRemoteRegisterContext
 130     // class has been made smart enough to detect when it needs to invalidate
 131     // which registers are valid by putting hooks in the register read and
 132     // register supply functions where they check the process stop ID and do
 133     // the right thing.
 134     const bool force = false;
 135     GetRegisterContext()->InvalidateIfNeeded (force);
 136 }
 137
 138 bool
 139 ThreadGDBRemote::ThreadIDIsValid (lldb::tid_t thread)
 140 {
 141     return thread != 0;
 142 }
 143
 144 void
 145 ThreadGDBRemote::Dump(Log *log, uint32_t index)
 146 {
 147 }
 148
 149
 150 bool
 151 ThreadGDBRemote::ShouldStop (bool &step_more)
 152 {
 153     return true;
 154 }
 155 lldb::RegisterContextSP
 156 ThreadGDBRemote::GetRegisterContext ()
 157 {
 158     if (m_reg_context_sp.get() == NULL)
 159         m_reg_context_sp = CreateRegisterContextForFrame (NULL);
 160     return m_reg_context_sp;
 161 }
 162
 163 lldb::RegisterContextSP
 164 ThreadGDBRemote::CreateRegisterContextForFrame (StackFrame *frame)
 165 {
 166     lldb::RegisterContextSP reg_ctx_sp;
 167     const bool read_all_registers_at_once = false;
 168     uint32_t concrete_frame_idx = 0;
 169
 170     if (frame)
 171         concrete_frame_idx = frame->GetConcreteFrameIndex ();
 172
 173
 174     if (concrete_frame_idx == 0)
 175     {
 176         ProcessSP process_sp (GetProcess());
 177         if (process_sp)
 178         {
 179             ProcessGDBRemote *gdb_process = static_cast<ProcessGDBRemote *>(process_sp.get());
 180             reg_ctx_sp.reset (new GDBRemoteRegisterContext (*this, concrete_frame_idx, gdb_process->m_register_info, read_all_registers_at_once));
 181         }
 182     }
 183     else
 184     {
 185         Unwind *unwinder = GetUnwinder ();
 186         if (unwinder)
 187             reg_ctx_sp = unwinder->CreateRegisterContextForFrame (frame);
 188     }
 189     return reg_ctx_sp;
 190 }
 191
 192 bool
 193 ThreadGDBRemote::PrivateSetRegisterValue (uint32_t reg, StringExtractor &response)
 194 {
 195     GDBRemoteRegisterContext *gdb_reg_ctx = static_cast<GDBRemoteRegisterContext *>(GetRegisterContext ().get());
 196     assert (gdb_reg_ctx);
 197     return gdb_reg_ctx->PrivateSetRegisterValue (reg, response);
 198 }
 199
 200 bool
 201 ThreadGDBRemote::CalculateStopInfo ()
 202 {
 203     ProcessSP process_sp (GetProcess());
 204     if (process_sp)
 205     {
 206         StringExtractorGDBRemote stop_packet;
 207         ProcessGDBRemote *gdb_process = static_cast<ProcessGDBRemote *>(process_sp.get());
 208         if (gdb_process->GetGDBRemote().GetThreadStopInfo(GetProtocolID(), stop_packet))
 209             return gdb_process->SetThreadStopInfo (stop_packet) == eStateStopped;
 210     }
 211     return false;
 212 }
 213
 214