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/UnixSignals.h"
  25 #include "lldb/Target/Unwind.h"
  26
  27 #include "ProcessGDBRemote.h"
  28 #include "ProcessGDBRemoteLog.h"
  29 #include "Utility/StringExtractorGDBRemote.h"
  30
  31 using namespace lldb;
  32 using namespace lldb_private;
  33 using namespace lldb_private::process_gdb_remote;
  34
  35 //----------------------------------------------------------------------
  36 // Thread Registers
  37 //----------------------------------------------------------------------
  38
  39 ThreadGDBRemote::ThreadGDBRemote (Process &process, lldb::tid_t tid) :
  40     Thread(process, tid),
  41     m_thread_name (),
  42     m_dispatch_queue_name (),
  43     m_thread_dispatch_qaddr (LLDB_INVALID_ADDRESS),
  44     m_dispatch_queue_t (LLDB_INVALID_ADDRESS),
  45     m_queue_kind (eQueueKindUnknown),
  46     m_queue_serial_number (LLDB_INVALID_QUEUE_ID),
  47     m_associated_with_libdispatch_queue (eLazyBoolCalculate)
  48 {
  49     ProcessGDBRemoteLog::LogIf(GDBR_LOG_THREAD, "%p: ThreadGDBRemote::ThreadGDBRemote (pid = %i, tid = 0x%4.4x)",
  50                                this,
  51                                process.GetID(),
  52                                GetID());
  53 }
  54
  55 ThreadGDBRemote::~ThreadGDBRemote ()
  56 {
  57     ProcessSP process_sp(GetProcess());
  58     ProcessGDBRemoteLog::LogIf(GDBR_LOG_THREAD, "%p: ThreadGDBRemote::~ThreadGDBRemote (pid = %i, tid = 0x%4.4x)",
  59                                this,
  60                                process_sp ? process_sp->GetID() : LLDB_INVALID_PROCESS_ID,
  61                                GetID());
  62     DestroyThread();
  63 }
  64
  65 const char *
  66 ThreadGDBRemote::GetName ()
  67 {
  68     if (m_thread_name.empty())
  69         return NULL;
  70     return m_thread_name.c_str();
  71 }
  72
  73 void
  74 ThreadGDBRemote::ClearQueueInfo ()
  75 {
  76     m_dispatch_queue_name.clear();
  77     m_queue_kind = eQueueKindUnknown;
  78     m_queue_serial_number = 0;
  79     m_dispatch_queue_t = LLDB_INVALID_ADDRESS;
  80     m_associated_with_libdispatch_queue = eLazyBoolCalculate;
  81 }
  82
  83 void
  84 ThreadGDBRemote::SetQueueInfo (std::string &&queue_name, QueueKind queue_kind, uint64_t queue_serial, addr_t dispatch_queue_t, LazyBool associated_with_libdispatch_queue)
  85 {
  86     m_dispatch_queue_name = queue_name;
  87     m_queue_kind = queue_kind;
  88     m_queue_serial_number = queue_serial;
  89     m_dispatch_queue_t = dispatch_queue_t;
  90     m_associated_with_libdispatch_queue = associated_with_libdispatch_queue;
  91 }
  92
  93
  94 const char *
  95 ThreadGDBRemote::GetQueueName ()
  96 {
  97     // If our cached queue info is valid, then someone called ThreadGDBRemote::SetQueueInfo(...)
  98     // with valid information that was gleaned from the stop reply packet. In this case we trust
  99     // that the info is valid in m_dispatch_queue_name without refetching it
 100     if (CachedQueueInfoIsValid())
 101     {
 102         if (m_dispatch_queue_name.empty())
 103             return nullptr;
 104         else
 105             return m_dispatch_queue_name.c_str();
 106     }
 107     // Always re-fetch the dispatch queue name since it can change
 108
 109     if (m_associated_with_libdispatch_queue == eLazyBoolNo)
 110         return nullptr;
 111
 112     if (m_thread_dispatch_qaddr != 0 && m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS)
 113     {
 114         ProcessSP process_sp (GetProcess());
 115         if (process_sp)
 116         {
 117             SystemRuntime *runtime = process_sp->GetSystemRuntime ();
 118             if (runtime)
 119                 m_dispatch_queue_name = runtime->GetQueueNameFromThreadQAddress (m_thread_dispatch_qaddr);
 120             else
 121                 m_dispatch_queue_name.clear();
 122
 123             if (!m_dispatch_queue_name.empty())
 124                 return m_dispatch_queue_name.c_str();
 125         }
 126     }
 127     return NULL;
 128 }
 129
 130 QueueKind
 131 ThreadGDBRemote::GetQueueKind ()
 132 {
 133     // If our cached queue info is valid, then someone called ThreadGDBRemote::SetQueueInfo(...)
 134     // with valid information that was gleaned from the stop reply packet. In this case we trust
 135     // that the info is valid in m_dispatch_queue_name without refetching it
 136     if (CachedQueueInfoIsValid())
 137     {
 138         return m_queue_kind;
 139     }
 140
 141     if (m_associated_with_libdispatch_queue == eLazyBoolNo)
 142         return eQueueKindUnknown;
 143
 144     if (m_thread_dispatch_qaddr != 0 && m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS)
 145     {
 146         ProcessSP process_sp (GetProcess());
 147         if (process_sp)
 148         {
 149             SystemRuntime *runtime = process_sp->GetSystemRuntime ();
 150             if (runtime)
 151                 m_queue_kind = runtime->GetQueueKind (m_thread_dispatch_qaddr);
 152             return m_queue_kind;
 153         }
 154     }
 155     return eQueueKindUnknown;
 156 }
 157
 158
 159 queue_id_t
 160 ThreadGDBRemote::GetQueueID ()
 161 {
 162     // If our cached queue info is valid, then someone called ThreadGDBRemote::SetQueueInfo(...)
 163     // with valid information that was gleaned from the stop reply packet. In this case we trust
 164     // that the info is valid in m_dispatch_queue_name without refetching it
 165     if (CachedQueueInfoIsValid())
 166         return m_queue_serial_number;
 167
 168     if (m_associated_with_libdispatch_queue == eLazyBoolNo)
 169         return LLDB_INVALID_QUEUE_ID;
 170
 171     if (m_thread_dispatch_qaddr != 0 && m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS)
 172     {
 173         ProcessSP process_sp (GetProcess());
 174         if (process_sp)
 175         {
 176             SystemRuntime *runtime = process_sp->GetSystemRuntime ();
 177             if (runtime)
 178             {
 179                 return runtime->GetQueueIDFromThreadQAddress (m_thread_dispatch_qaddr);
 180             }
 181         }
 182     }
 183     return LLDB_INVALID_QUEUE_ID;
 184 }
 185
 186 QueueSP
 187 ThreadGDBRemote::GetQueue ()
 188 {
 189     queue_id_t queue_id = GetQueueID();
 190     QueueSP queue;
 191     if (queue_id != LLDB_INVALID_QUEUE_ID)
 192     {
 193         ProcessSP process_sp (GetProcess());
 194         if (process_sp)
 195         {
 196             queue = process_sp->GetQueueList().FindQueueByID (queue_id);
 197         }
 198     }
 199     return queue;
 200 }
 201
 202 addr_t
 203 ThreadGDBRemote::GetQueueLibdispatchQueueAddress ()
 204 {
 205     if (m_dispatch_queue_t == LLDB_INVALID_ADDRESS)
 206     {
 207         if (m_thread_dispatch_qaddr != 0 && m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS)
 208         {
 209             ProcessSP process_sp (GetProcess());
 210             if (process_sp)
 211             {
 212                 SystemRuntime *runtime = process_sp->GetSystemRuntime ();
 213                 if (runtime)
 214                 {
 215                     m_dispatch_queue_t = runtime->GetLibdispatchQueueAddressFromThreadQAddress (m_thread_dispatch_qaddr);
 216                 }
 217             }
 218         }
 219     }
 220     return m_dispatch_queue_t;
 221 }
 222
 223 void
 224 ThreadGDBRemote::SetQueueLibdispatchQueueAddress (lldb::addr_t dispatch_queue_t)
 225 {
 226     m_dispatch_queue_t = dispatch_queue_t;
 227 }
 228
 229 bool
 230 ThreadGDBRemote::ThreadHasQueueInformation () const
 231 {
 232     if (m_thread_dispatch_qaddr != 0
 233         && m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS
 234         && m_dispatch_queue_t != LLDB_INVALID_ADDRESS
 235         && m_queue_kind != eQueueKindUnknown
 236         && m_queue_serial_number != 0)
 237     {
 238         return true;
 239     }
 240     return false;
 241 }
 242
 243 LazyBool
 244 ThreadGDBRemote::GetAssociatedWithLibdispatchQueue ()
 245 {
 246     return m_associated_with_libdispatch_queue;
 247 }
 248
 249 void
 250 ThreadGDBRemote::SetAssociatedWithLibdispatchQueue (LazyBool associated_with_libdispatch_queue)
 251 {
 252     m_associated_with_libdispatch_queue = associated_with_libdispatch_queue;
 253 }
 254
 255 StructuredData::ObjectSP
 256 ThreadGDBRemote::FetchThreadExtendedInfo ()
 257 {
 258     StructuredData::ObjectSP object_sp;
 259     const lldb::user_id_t tid = GetProtocolID();
 260     Log *log(GetLogIfAnyCategoriesSet (GDBR_LOG_THREAD));
 261     if (log)
 262         log->Printf ("Fetching extended information for thread %4.4" PRIx64, tid);
 263     ProcessSP process_sp (GetProcess());
 264     if (process_sp)
 265     {
 266         ProcessGDBRemote *gdb_process = static_cast<ProcessGDBRemote *>(process_sp.get());
 267         object_sp = gdb_process->GetExtendedInfoForThread (tid);
 268     }
 269     return object_sp;
 270 }
 271
 272 void
 273 ThreadGDBRemote::WillResume (StateType resume_state)
 274 {
 275     int signo = GetResumeSignal();
 276     const lldb::user_id_t tid = GetProtocolID();
 277     Log *log(GetLogIfAnyCategoriesSet (GDBR_LOG_THREAD));
 278     if (log)
 279         log->Printf ("Resuming thread: %4.4" PRIx64 " with state: %s.", tid, StateAsCString(resume_state));
 280
 281     ProcessSP process_sp (GetProcess());
 282     if (process_sp)
 283     {
 284         ProcessGDBRemote *gdb_process = static_cast<ProcessGDBRemote *>(process_sp.get());
 285         switch (resume_state)
 286         {
 287         case eStateSuspended:
 288         case eStateStopped:
 289             // Don't append anything for threads that should stay stopped.
 290             break;
 291
 292         case eStateRunning:
 293             if (gdb_process->GetUnixSignals()->SignalIsValid(signo))
 294                 gdb_process->m_continue_C_tids.push_back(std::make_pair(tid, signo));
 295             else
 296                 gdb_process->m_continue_c_tids.push_back(tid);
 297             break;
 298
 299         case eStateStepping:
 300             if (gdb_process->GetUnixSignals()->SignalIsValid(signo))
 301                 gdb_process->m_continue_S_tids.push_back(std::make_pair(tid, signo));
 302             else
 303                 gdb_process->m_continue_s_tids.push_back(tid);
 304             break;
 305
 306         default:
 307             break;
 308         }
 309     }
 310 }
 311
 312 void
 313 ThreadGDBRemote::RefreshStateAfterStop()
 314 {
 315     // Invalidate all registers in our register context. We don't set "force" to
 316     // true because the stop reply packet might have had some register values
 317     // that were expedited and these will already be copied into the register
 318     // context by the time this function gets called. The GDBRemoteRegisterContext
 319     // class has been made smart enough to detect when it needs to invalidate
 320     // which registers are valid by putting hooks in the register read and
 321     // register supply functions where they check the process stop ID and do
 322     // the right thing.
 323     const bool force = false;
 324     GetRegisterContext()->InvalidateIfNeeded (force);
 325 }
 326
 327 bool
 328 ThreadGDBRemote::ThreadIDIsValid (lldb::tid_t thread)
 329 {
 330     return thread != 0;
 331 }
 332
 333 void
 334 ThreadGDBRemote::Dump(Log *log, uint32_t index)
 335 {
 336 }
 337
 338
 339 bool
 340 ThreadGDBRemote::ShouldStop (bool &step_more)
 341 {
 342     return true;
 343 }
 344 lldb::RegisterContextSP
 345 ThreadGDBRemote::GetRegisterContext ()
 346 {
 347     if (m_reg_context_sp.get() == NULL)
 348         m_reg_context_sp = CreateRegisterContextForFrame (NULL);
 349     return m_reg_context_sp;
 350 }
 351
 352 lldb::RegisterContextSP
 353 ThreadGDBRemote::CreateRegisterContextForFrame (StackFrame *frame)
 354 {
 355     lldb::RegisterContextSP reg_ctx_sp;
 356     uint32_t concrete_frame_idx = 0;
 357
 358     if (frame)
 359         concrete_frame_idx = frame->GetConcreteFrameIndex ();
 360
 361
 362     if (concrete_frame_idx == 0)
 363     {
 364         ProcessSP process_sp (GetProcess());
 365         if (process_sp)
 366         {
 367             ProcessGDBRemote *gdb_process = static_cast<ProcessGDBRemote *>(process_sp.get());
 368             // read_all_registers_at_once will be true if 'p' packet is not supported.
 369             bool read_all_registers_at_once = !gdb_process->GetGDBRemote().GetpPacketSupported (GetID());
 370             reg_ctx_sp.reset (new GDBRemoteRegisterContext (*this, concrete_frame_idx, gdb_process->m_register_info, read_all_registers_at_once));
 371         }
 372     }
 373     else
 374     {
 375         Unwind *unwinder = GetUnwinder ();
 376         if (unwinder)
 377             reg_ctx_sp = unwinder->CreateRegisterContextForFrame (frame);
 378     }
 379     return reg_ctx_sp;
 380 }
 381
 382 bool
 383 ThreadGDBRemote::PrivateSetRegisterValue (uint32_t reg, StringExtractor &response)
 384 {
 385     GDBRemoteRegisterContext *gdb_reg_ctx = static_cast<GDBRemoteRegisterContext *>(GetRegisterContext ().get());
 386     assert (gdb_reg_ctx);
 387     return gdb_reg_ctx->PrivateSetRegisterValue (reg, response);
 388 }
 389
 390 bool
 391 ThreadGDBRemote::PrivateSetRegisterValue (uint32_t reg, uint64_t regval)
 392 {
 393     GDBRemoteRegisterContext *gdb_reg_ctx = static_cast<GDBRemoteRegisterContext *>(GetRegisterContext ().get());
 394     assert (gdb_reg_ctx);
 395     return gdb_reg_ctx->PrivateSetRegisterValue (reg, regval);
 396 }
 397
 398 bool
 399 ThreadGDBRemote::CalculateStopInfo ()
 400 {
 401     ProcessSP process_sp (GetProcess());
 402     if (process_sp)
 403         return static_cast<ProcessGDBRemote *>(process_sp.get())->CalculateThreadStopInfo(this);
 404     return false;
 405 }
 406
 407