• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1  //===-- POSIXThread.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  #include "lldb/lldb-python.h"
11  
12  // C Includes
13  #include <errno.h>
14  
15  // C++ Includes
16  // Other libraries and framework includes
17  // Project includes
18  #include "lldb/Breakpoint/Watchpoint.h"
19  #include "lldb/Breakpoint/BreakpointLocation.h"
20  #include "lldb/Core/Debugger.h"
21  #include "lldb/Core/State.h"
22  #include "lldb/Host/Host.h"
23  #include "lldb/Target/Process.h"
24  #include "lldb/Target/StopInfo.h"
25  #include "lldb/Target/Target.h"
26  #include "lldb/Target/ThreadSpec.h"
27  #include "POSIXStopInfo.h"
28  #include "POSIXThread.h"
29  #include "ProcessPOSIX.h"
30  #include "ProcessPOSIXLog.h"
31  #include "ProcessMonitor.h"
32  #include "RegisterContext_i386.h"
33  #include "RegisterContext_x86_64.h"
34  #include "RegisterContextPOSIX.h"
35  #include "RegisterContextLinux_x86_64.h"
36  #include "RegisterContextFreeBSD_x86_64.h"
37  
38  #include "UnwindLLDB.h"
39  
40  using namespace lldb;
41  using namespace lldb_private;
42  
43  
POSIXThread(Process & process,lldb::tid_t tid)44  POSIXThread::POSIXThread(Process &process, lldb::tid_t tid)
45      : Thread(process, tid),
46        m_frame_ap (),
47        m_breakpoint (),
48        m_thread_name_valid (false),
49        m_thread_name ()
50  {
51      Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_THREAD));
52      if (log && log->GetMask().Test(POSIX_LOG_VERBOSE))
53          log->Printf ("POSIXThread::%s (tid = %" PRIi64 ")", __FUNCTION__, tid);
54  
55      // Set the current watchpoints for this thread.
56      Target &target = GetProcess()->GetTarget();
57      const WatchpointList &wp_list = target.GetWatchpointList();
58      size_t wp_size = wp_list.GetSize();
59  
60      for (uint32_t wp_idx = 0; wp_idx < wp_size; wp_idx++)
61      {
62          lldb::WatchpointSP wp = wp_list.GetByIndex(wp_idx);
63          if (wp.get() && wp->IsEnabled())
64          {
65              assert(EnableHardwareWatchpoint(wp.get()));
66          }
67      }
68  }
69  
~POSIXThread()70  POSIXThread::~POSIXThread()
71  {
72      DestroyThread();
73  }
74  
75  ProcessMonitor &
GetMonitor()76  POSIXThread::GetMonitor()
77  {
78      ProcessSP base = GetProcess();
79      ProcessPOSIX &process = static_cast<ProcessPOSIX&>(*base);
80      return process.GetMonitor();
81  }
82  
83  void
RefreshStateAfterStop()84  POSIXThread::RefreshStateAfterStop()
85  {
86      // Invalidate all registers in our register context. We don't set "force" to
87      // true because the stop reply packet might have had some register values
88      // that were expedited and these will already be copied into the register
89      // context by the time this function gets called. The KDPRegisterContext
90      // class has been made smart enough to detect when it needs to invalidate
91      // which registers are valid by putting hooks in the register read and
92      // register supply functions where they check the process stop ID and do
93      // the right thing.
94      //if (StateIsStoppedState(GetState())
95      {
96          const bool force = false;
97          GetRegisterContext()->InvalidateIfNeeded (force);
98      }
99      // FIXME: This should probably happen somewhere else.
100      SetResumeState(eStateRunning);
101      Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_THREAD));
102      if (log)
103          log->Printf ("POSIXThread::%s (tid = %" PRIi64 ") setting thread resume state to running", __FUNCTION__, GetID());
104  }
105  
106  const char *
GetInfo()107  POSIXThread::GetInfo()
108  {
109      return NULL;
110  }
111  
112  void
SetName(const char * name)113  POSIXThread::SetName (const char *name)
114  {
115      m_thread_name_valid = (name && name[0]);
116      if (m_thread_name_valid)
117          m_thread_name.assign (name);
118      else
119          m_thread_name.clear();
120  }
121  
122  const char *
GetName()123  POSIXThread::GetName ()
124  {
125      if (!m_thread_name_valid)
126      {
127          SetName(Host::GetThreadName(GetProcess()->GetID(), GetID()).c_str());
128          m_thread_name_valid = true;
129      }
130  
131      if (m_thread_name.empty())
132          return NULL;
133      return m_thread_name.c_str();
134  }
135  
136  lldb::RegisterContextSP
GetRegisterContext()137  POSIXThread::GetRegisterContext()
138  {
139      if (!m_reg_context_sp)
140      {
141          ArchSpec arch = Host::GetArchitecture();
142  
143          switch (arch.GetCore())
144          {
145          default:
146              assert(false && "CPU type not supported!");
147              break;
148  
149          case ArchSpec::eCore_x86_32_i386:
150          case ArchSpec::eCore_x86_32_i486:
151          case ArchSpec::eCore_x86_32_i486sx:
152              m_reg_context_sp.reset(new RegisterContext_i386(*this, 0));
153              break;
154  
155          case ArchSpec::eCore_x86_64_x86_64:
156              switch (arch.GetTriple().getOS())
157              {
158                  case llvm::Triple::FreeBSD:
159                      m_reg_context_sp.reset(new RegisterContextFreeBSD_x86_64(*this, 0));
160                      break;
161                  case llvm::Triple::Linux:
162                      m_reg_context_sp.reset(new RegisterContextLinux_x86_64(*this, 0));
163                      break;
164                  default:
165                      assert(false && "OS not supported");
166                      break;
167              }
168              break;
169          }
170      }
171      return m_reg_context_sp;
172  }
173  
174  lldb::RegisterContextSP
CreateRegisterContextForFrame(lldb_private::StackFrame * frame)175  POSIXThread::CreateRegisterContextForFrame(lldb_private::StackFrame *frame)
176  {
177      lldb::RegisterContextSP reg_ctx_sp;
178      uint32_t concrete_frame_idx = 0;
179  
180      Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_THREAD));
181      if (log && log->GetMask().Test(POSIX_LOG_VERBOSE))
182          log->Printf ("POSIXThread::%s ()", __FUNCTION__);
183  
184      if (frame)
185          concrete_frame_idx = frame->GetConcreteFrameIndex();
186  
187      if (concrete_frame_idx == 0)
188          reg_ctx_sp = GetRegisterContext();
189      else
190      {
191          assert(GetUnwinder());
192          reg_ctx_sp = GetUnwinder()->CreateRegisterContextForFrame(frame);
193      }
194  
195      return reg_ctx_sp;
196  }
197  
198  bool
CalculateStopInfo()199  POSIXThread::CalculateStopInfo()
200  {
201      SetStopInfo (m_stop_info_sp);
202      return true;
203  }
204  
205  Unwind *
GetUnwinder()206  POSIXThread::GetUnwinder()
207  {
208      if (m_unwinder_ap.get() == NULL)
209          m_unwinder_ap.reset(new UnwindLLDB(*this));
210  
211      return m_unwinder_ap.get();
212  }
213  
214  void
WillResume(lldb::StateType resume_state)215  POSIXThread::WillResume(lldb::StateType resume_state)
216  {
217      Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_THREAD));
218      if (log)
219          log->Printf ("POSIXThread::%s (tid = %" PRIi64 ") setting thread resume state to %s", __FUNCTION__, GetID(), StateAsCString(resume_state));
220      // TODO: the line below shouldn't really be done, but
221      // the POSIXThread might rely on this so I will leave this in for now
222      SetResumeState(resume_state);
223  }
224  
225  void
DidStop()226  POSIXThread::DidStop()
227  {
228      // Don't set the thread state to stopped unless we really stopped.
229  }
230  
231  bool
Resume()232  POSIXThread::Resume()
233  {
234      lldb::StateType resume_state = GetResumeState();
235      ProcessMonitor &monitor = GetMonitor();
236      bool status;
237  
238      Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_THREAD));
239      if (log)
240          log->Printf ("POSIXThread::%s (), resume_state = %s", __FUNCTION__,
241                           StateAsCString(resume_state));
242  
243      switch (resume_state)
244      {
245      default:
246          assert(false && "Unexpected state for resume!");
247          status = false;
248          break;
249  
250      case lldb::eStateRunning:
251          SetState(resume_state);
252          status = monitor.Resume(GetID(), GetResumeSignal());
253          break;
254  
255      case lldb::eStateStepping:
256          SetState(resume_state);
257          status = monitor.SingleStep(GetID(), GetResumeSignal());
258          break;
259      case lldb::eStateStopped:
260      case lldb::eStateSuspended:
261          status = true;
262          break;
263      }
264  
265      return status;
266  }
267  
268  void
Notify(const ProcessMessage & message)269  POSIXThread::Notify(const ProcessMessage &message)
270  {
271      Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_THREAD));
272      if (log)
273          log->Printf ("POSIXThread::%s () message kind = '%s' for tid %" PRIu64,
274                       __FUNCTION__, message.PrintKind(), GetID());
275  
276      switch (message.GetKind())
277      {
278      default:
279          assert(false && "Unexpected message kind!");
280          break;
281  
282      case ProcessMessage::eExitMessage:
283          // Nothing to be done.
284          break;
285  
286      case ProcessMessage::eLimboMessage:
287          LimboNotify(message);
288          break;
289  
290      case ProcessMessage::eSignalMessage:
291          SignalNotify(message);
292          break;
293  
294      case ProcessMessage::eSignalDeliveredMessage:
295          SignalDeliveredNotify(message);
296          break;
297  
298      case ProcessMessage::eTraceMessage:
299          TraceNotify(message);
300          break;
301  
302      case ProcessMessage::eBreakpointMessage:
303          BreakNotify(message);
304          break;
305  
306      case ProcessMessage::eWatchpointMessage:
307          WatchNotify(message);
308          break;
309  
310      case ProcessMessage::eCrashMessage:
311          CrashNotify(message);
312          break;
313  
314      case ProcessMessage::eNewThreadMessage:
315          ThreadNotify(message);
316          break;
317      }
318  }
319  
320  bool
EnableHardwareWatchpoint(Watchpoint * wp)321  POSIXThread::EnableHardwareWatchpoint(Watchpoint *wp)
322  {
323      bool wp_set = false;
324      if (wp)
325      {
326          addr_t wp_addr = wp->GetLoadAddress();
327          size_t wp_size = wp->GetByteSize();
328          bool wp_read = wp->WatchpointRead();
329          bool wp_write = wp->WatchpointWrite();
330          uint32_t wp_hw_index = wp->GetHardwareIndex();
331          RegisterContextPOSIX* reg_ctx = GetRegisterContextPOSIX();
332          if (reg_ctx)
333              wp_set = reg_ctx->SetHardwareWatchpointWithIndex(wp_addr, wp_size,
334                                                               wp_read, wp_write,
335                                                               wp_hw_index);
336      }
337      return wp_set;
338  }
339  
340  bool
DisableHardwareWatchpoint(Watchpoint * wp)341  POSIXThread::DisableHardwareWatchpoint(Watchpoint *wp)
342  {
343      bool result = false;
344      if (wp)
345      {
346          lldb::RegisterContextSP reg_ctx_sp = GetRegisterContext();
347          if (reg_ctx_sp.get())
348              result = reg_ctx_sp->ClearHardwareWatchpoint(wp->GetHardwareIndex());
349      }
350      return result;
351  }
352  
353  uint32_t
NumSupportedHardwareWatchpoints()354  POSIXThread::NumSupportedHardwareWatchpoints()
355  {
356      lldb::RegisterContextSP reg_ctx_sp = GetRegisterContext();
357      if (reg_ctx_sp.get())
358          return reg_ctx_sp->NumSupportedHardwareWatchpoints();
359      return 0;
360  }
361  
362  uint32_t
FindVacantWatchpointIndex()363  POSIXThread::FindVacantWatchpointIndex()
364  {
365      uint32_t hw_index = LLDB_INVALID_INDEX32;
366      uint32_t num_hw_wps = NumSupportedHardwareWatchpoints();
367      uint32_t wp_idx;
368      RegisterContextPOSIX* reg_ctx = GetRegisterContextPOSIX();
369      if (reg_ctx)
370      {
371          for (wp_idx = 0; wp_idx < num_hw_wps; wp_idx++)
372          {
373              if (reg_ctx->IsWatchpointVacant(wp_idx))
374              {
375                  hw_index = wp_idx;
376                  break;
377              }
378          }
379      }
380      return hw_index;
381  }
382  
383  void
BreakNotify(const ProcessMessage & message)384  POSIXThread::BreakNotify(const ProcessMessage &message)
385  {
386      bool status;
387      Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_THREAD));
388  
389      assert(GetRegisterContext());
390      status = GetRegisterContextPOSIX()->UpdateAfterBreakpoint();
391      assert(status && "Breakpoint update failed!");
392  
393      // With our register state restored, resolve the breakpoint object
394      // corresponding to our current PC.
395      assert(GetRegisterContext());
396      lldb::addr_t pc = GetRegisterContext()->GetPC();
397      if (log)
398          log->Printf ("POSIXThread::%s () PC=0x%8.8" PRIx64, __FUNCTION__, pc);
399      lldb::BreakpointSiteSP bp_site(GetProcess()->GetBreakpointSiteList().FindByAddress(pc));
400  
401      // If the breakpoint is for this thread, then we'll report the hit, but if it is for another thread,
402      // we can just report no reason.  We don't need to worry about stepping over the breakpoint here, that
403      // will be taken care of when the thread resumes and notices that there's a breakpoint under the pc.
404      if (bp_site && bp_site->ValidForThisThread(this))
405      {
406          lldb::break_id_t bp_id = bp_site->GetID();
407          if (GetProcess()->GetThreadList().SetSelectedThreadByID(GetID()))
408              SetStopInfo (StopInfo::CreateStopReasonWithBreakpointSiteID(*this, bp_id));
409          else
410              assert(false && "Invalid thread ID during BreakNotify.");
411      }
412      else
413      {
414          const ThreadSpec *spec = bp_site ?
415              bp_site->GetOwnerAtIndex(0)->GetOptionsNoCreate()->GetThreadSpecNoCreate() : 0;
416  
417          if (spec && spec->TIDMatches(*this))
418              assert(false && "BreakpointSite is invalid for the current ThreadSpec.");
419          else
420          {
421              if (!m_stop_info_sp) {
422                  StopInfoSP invalid_stop_info_sp;
423                  SetStopInfo (invalid_stop_info_sp);
424              }
425          }
426      }
427  }
428  
429  void
WatchNotify(const ProcessMessage & message)430  POSIXThread::WatchNotify(const ProcessMessage &message)
431  {
432      Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_THREAD));
433  
434      lldb::addr_t halt_addr = message.GetHWAddress();
435      if (log)
436          log->Printf ("POSIXThread::%s () Hardware Watchpoint Address = 0x%8.8"
437                       PRIx64, __FUNCTION__, halt_addr);
438  
439      RegisterContextPOSIX* reg_ctx = GetRegisterContextPOSIX();
440      if (reg_ctx)
441      {
442          uint32_t num_hw_wps = reg_ctx->NumSupportedHardwareWatchpoints();
443          uint32_t wp_idx;
444          for (wp_idx = 0; wp_idx < num_hw_wps; wp_idx++)
445          {
446              if (reg_ctx->IsWatchpointHit(wp_idx))
447              {
448                  // Clear the watchpoint hit here
449                  reg_ctx->ClearWatchpointHits();
450                  break;
451              }
452          }
453  
454          if (wp_idx == num_hw_wps)
455              return;
456  
457          Target &target = GetProcess()->GetTarget();
458          lldb::addr_t wp_monitor_addr = reg_ctx->GetWatchpointAddress(wp_idx);
459          const WatchpointList &wp_list = target.GetWatchpointList();
460          lldb::WatchpointSP wp_sp = wp_list.FindByAddress(wp_monitor_addr);
461  
462          assert(wp_sp.get() && "No watchpoint found");
463          SetStopInfo (StopInfo::CreateStopReasonWithWatchpointID(*this,
464                                                                  wp_sp->GetID()));
465      }
466  }
467  
468  void
TraceNotify(const ProcessMessage & message)469  POSIXThread::TraceNotify(const ProcessMessage &message)
470  {
471      SetStopInfo (StopInfo::CreateStopReasonToTrace(*this));
472  }
473  
474  void
LimboNotify(const ProcessMessage & message)475  POSIXThread::LimboNotify(const ProcessMessage &message)
476  {
477      SetStopInfo (lldb::StopInfoSP(new POSIXLimboStopInfo(*this)));
478  }
479  
480  void
SignalNotify(const ProcessMessage & message)481  POSIXThread::SignalNotify(const ProcessMessage &message)
482  {
483      int signo = message.GetSignal();
484  
485      SetStopInfo (StopInfo::CreateStopReasonWithSignal(*this, signo));
486      SetResumeSignal(signo);
487  }
488  
489  void
SignalDeliveredNotify(const ProcessMessage & message)490  POSIXThread::SignalDeliveredNotify(const ProcessMessage &message)
491  {
492      int signo = message.GetSignal();
493  
494      SetStopInfo (StopInfo::CreateStopReasonWithSignal(*this, signo));
495      SetResumeSignal(signo);
496  }
497  
498  void
CrashNotify(const ProcessMessage & message)499  POSIXThread::CrashNotify(const ProcessMessage &message)
500  {
501      // FIXME: Update stop reason as per bugzilla 14598
502      int signo = message.GetSignal();
503  
504      assert(message.GetKind() == ProcessMessage::eCrashMessage);
505  
506      Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_THREAD));
507      if (log)
508          log->Printf ("POSIXThread::%s () signo = %i, reason = '%s'",
509                       __FUNCTION__, signo, message.PrintCrashReason());
510  
511      SetStopInfo (lldb::StopInfoSP(new POSIXCrashStopInfo(*this, signo,
512                                                           message.GetCrashReason(),
513                                                           message.GetFaultAddress())));
514      SetResumeSignal(signo);
515  }
516  
517  void
ThreadNotify(const ProcessMessage & message)518  POSIXThread::ThreadNotify(const ProcessMessage &message)
519  {
520      SetStopInfo (lldb::StopInfoSP(new POSIXNewThreadStopInfo(*this)));
521  }
522  
523  unsigned
GetRegisterIndexFromOffset(unsigned offset)524  POSIXThread::GetRegisterIndexFromOffset(unsigned offset)
525  {
526      unsigned reg = LLDB_INVALID_REGNUM;
527      ArchSpec arch = Host::GetArchitecture();
528  
529      switch (arch.GetCore())
530      {
531      default:
532          llvm_unreachable("CPU type not supported!");
533          break;
534  
535      case ArchSpec::eCore_x86_32_i386:
536      case ArchSpec::eCore_x86_32_i486:
537      case ArchSpec::eCore_x86_32_i486sx:
538      case ArchSpec::eCore_x86_64_x86_64:
539          {
540              RegisterContextSP base = GetRegisterContext();
541              if (base) {
542                  RegisterContextPOSIX &context = static_cast<RegisterContextPOSIX &>(*base);
543                  reg = context.GetRegisterIndexFromOffset(offset);
544              }
545          }
546          break;
547      }
548      return reg;
549  }
550  
551  const char *
GetRegisterName(unsigned reg)552  POSIXThread::GetRegisterName(unsigned reg)
553  {
554      const char * name = nullptr;
555      ArchSpec arch = Host::GetArchitecture();
556  
557      switch (arch.GetCore())
558      {
559      default:
560          assert(false && "CPU type not supported!");
561          break;
562  
563      case ArchSpec::eCore_x86_32_i386:
564      case ArchSpec::eCore_x86_32_i486:
565      case ArchSpec::eCore_x86_32_i486sx:
566      case ArchSpec::eCore_x86_64_x86_64:
567          name = GetRegisterContext()->GetRegisterName(reg);
568          break;
569      }
570      return name;
571  }
572  
573  const char *
GetRegisterNameFromOffset(unsigned offset)574  POSIXThread::GetRegisterNameFromOffset(unsigned offset)
575  {
576      return GetRegisterName(GetRegisterIndexFromOffset(offset));
577  }
578  
579