ThreadGDBRemote.cpp revision 296417 
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
31using namespace lldb;
32using namespace lldb_private;
33using namespace lldb_private::process_gdb_remote;
34
35//----------------------------------------------------------------------
36// Thread Registers
37//----------------------------------------------------------------------
38
39ThreadGDBRemote::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
55ThreadGDBRemote::~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
65const char *
66ThreadGDBRemote::GetName ()
67{
68    if (m_thread_name.empty())
69        return NULL;
70    return m_thread_name.c_str();
71}
72
73void
74ThreadGDBRemote::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
83void
84ThreadGDBRemote::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
94const char *
95ThreadGDBRemote::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
130QueueKind
131ThreadGDBRemote::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
159queue_id_t
160ThreadGDBRemote::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
186QueueSP
187ThreadGDBRemote::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
202addr_t
203ThreadGDBRemote::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
223void
224ThreadGDBRemote::SetQueueLibdispatchQueueAddress (lldb::addr_t dispatch_queue_t)
225{
226    m_dispatch_queue_t = dispatch_queue_t;
227}
228
229bool
230ThreadGDBRemote::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
243LazyBool
244ThreadGDBRemote::GetAssociatedWithLibdispatchQueue ()
245{
246    return m_associated_with_libdispatch_queue;
247}
248
249void
250ThreadGDBRemote::SetAssociatedWithLibdispatchQueue (LazyBool associated_with_libdispatch_queue)
251{
252    m_associated_with_libdispatch_queue = associated_with_libdispatch_queue;
253}
254
255StructuredData::ObjectSP
256ThreadGDBRemote::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
272void
273ThreadGDBRemote::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
312void
313ThreadGDBRemote::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
327bool
328ThreadGDBRemote::ThreadIDIsValid (lldb::tid_t thread)
329{
330    return thread != 0;
331}
332
333void
334ThreadGDBRemote::Dump(Log *log, uint32_t index)
335{
336}
337
338
339bool
340ThreadGDBRemote::ShouldStop (bool &step_more)
341{
342    return true;
343}
344lldb::RegisterContextSP
345ThreadGDBRemote::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
352lldb::RegisterContextSP
353ThreadGDBRemote::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
382bool
383ThreadGDBRemote::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
390bool
391ThreadGDBRemote::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
398bool
399ThreadGDBRemote::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
408