contrib/llvm/tools/lldb/source/Plugins/Process/FreeBSD/FreeBSDThread.cpp

   1 //===-- FreeBSDThread.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 <errno.h>
  11 #include <pthread.h>
  12 #include <pthread_np.h>
  13 #include <stdlib.h>
  14 #include <sys/sysctl.h>
  15 #include <sys/types.h>
  16 #include <sys/user.h>
  17
  18 #include "lldb/Target/UnixSignals.h"
  19 #include "lldb/Utility/State.h"
  20
  21 #include "FreeBSDThread.h"
  22 #include "POSIXStopInfo.h"
  23 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
  24 #include "Plugins/Process/Utility/RegisterContextFreeBSD_i386.h"
  25 #include "Plugins/Process/Utility/RegisterContextFreeBSD_mips64.h"
  26 #include "Plugins/Process/Utility/RegisterContextFreeBSD_powerpc.h"
  27 #include "Plugins/Process/Utility/RegisterContextFreeBSD_x86_64.h"
  28 #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm.h"
  29 #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h"
  30 #include "Plugins/Process/Utility/UnwindLLDB.h"
  31 #include "ProcessFreeBSD.h"
  32 #include "ProcessMonitor.h"
  33 #include "RegisterContextPOSIXProcessMonitor_arm.h"
  34 #include "RegisterContextPOSIXProcessMonitor_arm64.h"
  35 #include "RegisterContextPOSIXProcessMonitor_mips64.h"
  36 #include "RegisterContextPOSIXProcessMonitor_powerpc.h"
  37 #include "RegisterContextPOSIXProcessMonitor_x86.h"
  38 #include "lldb/Breakpoint/BreakpointLocation.h"
  39 #include "lldb/Breakpoint/Watchpoint.h"
  40 #include "lldb/Core/Debugger.h"
  41 #include "lldb/Host/Host.h"
  42 #include "lldb/Host/HostInfo.h"
  43 #include "lldb/Host/HostNativeThread.h"
  44 #include "lldb/Target/Process.h"
  45 #include "lldb/Target/StopInfo.h"
  46 #include "lldb/Target/Target.h"
  47 #include "lldb/Target/ThreadSpec.h"
  48 #include "lldb/Utility/State.h"
  49 #include "llvm/ADT/SmallString.h"
  50
  51 using namespace lldb;
  52 using namespace lldb_private;
  53
  54 FreeBSDThread::FreeBSDThread(Process &process, lldb::tid_t tid)
  55     : Thread(process, tid), m_frame_ap(), m_breakpoint(),
  56       m_thread_name_valid(false), m_thread_name(), m_posix_thread(nullptr) {
  57   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
  58   LLDB_LOGV(log, "tid = {0}", tid);
  59
  60   // Set the current watchpoints for this thread.
  61   Target &target = GetProcess()->GetTarget();
  62   const WatchpointList &wp_list = target.GetWatchpointList();
  63   size_t wp_size = wp_list.GetSize();
  64
  65   for (uint32_t wp_idx = 0; wp_idx < wp_size; wp_idx++) {
  66     lldb::WatchpointSP wp = wp_list.GetByIndex(wp_idx);
  67     if (wp.get() && wp->IsEnabled()) {
  68       // This watchpoint as been enabled; obviously this "new" thread has been
  69       // created since that watchpoint was enabled.  Since the
  70       // POSIXBreakpointProtocol has yet to be initialized, its
  71       // m_watchpoints_initialized member will be FALSE.  Attempting to read
  72       // the debug status register to determine if a watchpoint has been hit
  73       // would result in the zeroing of that register. Since the active debug
  74       // registers would have been cloned when this thread was created, simply
  75       // force the m_watchpoints_initized member to TRUE and avoid resetting
  76       // dr6 and dr7.
  77       GetPOSIXBreakpointProtocol()->ForceWatchpointsInitialized();
  78     }
  79   }
  80 }
  81
  82 FreeBSDThread::~FreeBSDThread() { DestroyThread(); }
  83
  84 ProcessMonitor &FreeBSDThread::GetMonitor() {
  85   ProcessSP base = GetProcess();
  86   ProcessFreeBSD &process = static_cast<ProcessFreeBSD &>(*base);
  87   return process.GetMonitor();
  88 }
  89
  90 void FreeBSDThread::RefreshStateAfterStop() {
  91   // Invalidate all registers in our register context. We don't set "force" to
  92   // true because the stop reply packet might have had some register values
  93   // that were expedited and these will already be copied into the register
  94   // context by the time this function gets called. The KDPRegisterContext
  95   // class has been made smart enough to detect when it needs to invalidate
  96   // which registers are valid by putting hooks in the register read and
  97   // register supply functions where they check the process stop ID and do the
  98   // right thing. if (StateIsStoppedState(GetState())
  99   {
 100     const bool force = false;
 101     GetRegisterContext()->InvalidateIfNeeded(force);
 102   }
 103 }
 104
 105 const char *FreeBSDThread::GetInfo() { return nullptr; }
 106
 107 void FreeBSDThread::SetName(const char *name) {
 108   m_thread_name_valid = (name && name[0]);
 109   if (m_thread_name_valid)
 110     m_thread_name.assign(name);
 111   else
 112     m_thread_name.clear();
 113 }
 114
 115 const char *FreeBSDThread::GetName() {
 116   if (!m_thread_name_valid) {
 117     m_thread_name.clear();
 118     int pid = GetProcess()->GetID();
 119
 120     struct kinfo_proc *kp = nullptr, *nkp;
 121     size_t len = 0;
 122     int error;
 123     int ctl[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID | KERN_PROC_INC_THREAD,
 124                   pid};
 125
 126     while (1) {
 127       error = sysctl(ctl, 4, kp, &len, nullptr, 0);
 128       if (kp == nullptr || (error != 0 && errno == ENOMEM)) {
 129         // Add extra space in case threads are added before next call.
 130         len += sizeof(*kp) + len / 10;
 131         nkp = (struct kinfo_proc *)realloc(kp, len);
 132         if (nkp == nullptr) {
 133           free(kp);
 134           return nullptr;
 135         }
 136         kp = nkp;
 137         continue;
 138       }
 139       if (error != 0)
 140         len = 0;
 141       break;
 142     }
 143
 144     for (size_t i = 0; i < len / sizeof(*kp); i++) {
 145       if (kp[i].ki_tid == (lwpid_t)GetID()) {
 146         m_thread_name.append(kp[i].ki_tdname,
 147                              kp[i].ki_tdname + strlen(kp[i].ki_tdname));
 148         break;
 149       }
 150     }
 151     free(kp);
 152     m_thread_name_valid = true;
 153   }
 154
 155   if (m_thread_name.empty())
 156     return nullptr;
 157   return m_thread_name.c_str();
 158 }
 159
 160 lldb::RegisterContextSP FreeBSDThread::GetRegisterContext() {
 161   if (!m_reg_context_sp) {
 162     m_posix_thread = nullptr;
 163
 164     RegisterInfoInterface *reg_interface = nullptr;
 165     const ArchSpec &target_arch = GetProcess()->GetTarget().GetArchitecture();
 166
 167     switch (target_arch.GetMachine()) {
 168     case llvm::Triple::aarch64:
 169       reg_interface = new RegisterInfoPOSIX_arm64(target_arch);
 170       break;
 171     case llvm::Triple::arm:
 172       reg_interface = new RegisterInfoPOSIX_arm(target_arch);
 173       break;
 174     case llvm::Triple::ppc:
 175 #ifndef __powerpc64__
 176       reg_interface = new RegisterContextFreeBSD_powerpc32(target_arch);
 177       break;
 178 #endif
 179     case llvm::Triple::ppc64:
 180       reg_interface = new RegisterContextFreeBSD_powerpc64(target_arch);
 181       break;
 182     case llvm::Triple::mips64:
 183       reg_interface = new RegisterContextFreeBSD_mips64(target_arch);
 184       break;
 185     case llvm::Triple::x86:
 186       reg_interface = new RegisterContextFreeBSD_i386(target_arch);
 187       break;
 188     case llvm::Triple::x86_64:
 189       reg_interface = new RegisterContextFreeBSD_x86_64(target_arch);
 190       break;
 191     default:
 192       llvm_unreachable("CPU not supported");
 193     }
 194
 195     switch (target_arch.GetMachine()) {
 196     case llvm::Triple::aarch64: {
 197       RegisterContextPOSIXProcessMonitor_arm64 *reg_ctx =
 198           new RegisterContextPOSIXProcessMonitor_arm64(*this, 0, reg_interface);
 199       m_posix_thread = reg_ctx;
 200       m_reg_context_sp.reset(reg_ctx);
 201       break;
 202     }
 203     case llvm::Triple::arm: {
 204       RegisterContextPOSIXProcessMonitor_arm *reg_ctx =
 205           new RegisterContextPOSIXProcessMonitor_arm(*this, 0, reg_interface);
 206       m_posix_thread = reg_ctx;
 207       m_reg_context_sp.reset(reg_ctx);
 208       break;
 209     }
 210     case llvm::Triple::mips64: {
 211       RegisterContextPOSIXProcessMonitor_mips64 *reg_ctx =
 212           new RegisterContextPOSIXProcessMonitor_mips64(*this, 0,
 213                                                         reg_interface);
 214       m_posix_thread = reg_ctx;
 215       m_reg_context_sp.reset(reg_ctx);
 216       break;
 217     }
 218     case llvm::Triple::ppc:
 219     case llvm::Triple::ppc64: {
 220       RegisterContextPOSIXProcessMonitor_powerpc *reg_ctx =
 221           new RegisterContextPOSIXProcessMonitor_powerpc(*this, 0,
 222                                                          reg_interface);
 223       m_posix_thread = reg_ctx;
 224       m_reg_context_sp.reset(reg_ctx);
 225       break;
 226     }
 227     case llvm::Triple::x86:
 228     case llvm::Triple::x86_64: {
 229       RegisterContextPOSIXProcessMonitor_x86_64 *reg_ctx =
 230           new RegisterContextPOSIXProcessMonitor_x86_64(*this, 0,
 231                                                         reg_interface);
 232       m_posix_thread = reg_ctx;
 233       m_reg_context_sp.reset(reg_ctx);
 234       break;
 235     }
 236     default:
 237       break;
 238     }
 239   }
 240   return m_reg_context_sp;
 241 }
 242
 243 lldb::RegisterContextSP
 244 FreeBSDThread::CreateRegisterContextForFrame(lldb_private::StackFrame *frame) {
 245   lldb::RegisterContextSP reg_ctx_sp;
 246   uint32_t concrete_frame_idx = 0;
 247
 248   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
 249   LLDB_LOGV(log, "called");
 250
 251   if (frame)
 252     concrete_frame_idx = frame->GetConcreteFrameIndex();
 253
 254   if (concrete_frame_idx == 0)
 255     reg_ctx_sp = GetRegisterContext();
 256   else {
 257     assert(GetUnwinder());
 258     reg_ctx_sp = GetUnwinder()->CreateRegisterContextForFrame(frame);
 259   }
 260
 261   return reg_ctx_sp;
 262 }
 263
 264 lldb::addr_t FreeBSDThread::GetThreadPointer() {
 265   ProcessMonitor &monitor = GetMonitor();
 266   addr_t addr;
 267   if (monitor.ReadThreadPointer(GetID(), addr))
 268     return addr;
 269   else
 270     return LLDB_INVALID_ADDRESS;
 271 }
 272
 273 bool FreeBSDThread::CalculateStopInfo() {
 274   SetStopInfo(m_stop_info_sp);
 275   return true;
 276 }
 277
 278 Unwind *FreeBSDThread::GetUnwinder() {
 279   if (!m_unwinder_ap)
 280     m_unwinder_ap.reset(new UnwindLLDB(*this));
 281
 282   return m_unwinder_ap.get();
 283 }
 284
 285 void FreeBSDThread::DidStop() {
 286   // Don't set the thread state to stopped unless we really stopped.
 287 }
 288
 289 void FreeBSDThread::WillResume(lldb::StateType resume_state) {
 290   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
 291   if (log)
 292     log->Printf("tid %" PRIu64 " resume_state = %s", GetID(),
 293                 lldb_private::StateAsCString(resume_state));
 294   ProcessSP process_sp(GetProcess());
 295   ProcessFreeBSD *process = static_cast<ProcessFreeBSD *>(process_sp.get());
 296   int signo = GetResumeSignal();
 297   bool signo_valid = process->GetUnixSignals()->SignalIsValid(signo);
 298
 299   switch (resume_state) {
 300   case eStateSuspended:
 301   case eStateStopped:
 302     process->m_suspend_tids.push_back(GetID());
 303     break;
 304   case eStateRunning:
 305     process->m_run_tids.push_back(GetID());
 306     if (signo_valid)
 307       process->m_resume_signo = signo;
 308     break;
 309   case eStateStepping:
 310     process->m_step_tids.push_back(GetID());
 311     if (signo_valid)
 312       process->m_resume_signo = signo;
 313     break;
 314   default:
 315     break;
 316   }
 317 }
 318
 319 bool FreeBSDThread::Resume() {
 320   lldb::StateType resume_state = GetResumeState();
 321   ProcessMonitor &monitor = GetMonitor();
 322   bool status;
 323
 324   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
 325   if (log)
 326     log->Printf("FreeBSDThread::%s (), resume_state = %s", __FUNCTION__,
 327                 StateAsCString(resume_state));
 328
 329   switch (resume_state) {
 330   default:
 331     assert(false && "Unexpected state for resume!");
 332     status = false;
 333     break;
 334
 335   case lldb::eStateRunning:
 336     SetState(resume_state);
 337     status = monitor.Resume(GetID(), GetResumeSignal());
 338     break;
 339
 340   case lldb::eStateStepping:
 341     SetState(resume_state);
 342     status = monitor.SingleStep(GetID(), GetResumeSignal());
 343     break;
 344   case lldb::eStateStopped:
 345   case lldb::eStateSuspended:
 346     status = true;
 347     break;
 348   }
 349
 350   return status;
 351 }
 352
 353 void FreeBSDThread::Notify(const ProcessMessage &message) {
 354   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
 355   if (log)
 356     log->Printf("FreeBSDThread::%s () message kind = '%s' for tid %" PRIu64,
 357                 __FUNCTION__, message.PrintKind(), GetID());
 358
 359   switch (message.GetKind()) {
 360   default:
 361     assert(false && "Unexpected message kind!");
 362     break;
 363
 364   case ProcessMessage::eExitMessage:
 365     // Nothing to be done.
 366     break;
 367
 368   case ProcessMessage::eLimboMessage:
 369     LimboNotify(message);
 370     break;
 371
 372   case ProcessMessage::eCrashMessage:
 373   case ProcessMessage::eSignalMessage:
 374     SignalNotify(message);
 375     break;
 376
 377   case ProcessMessage::eSignalDeliveredMessage:
 378     SignalDeliveredNotify(message);
 379     break;
 380
 381   case ProcessMessage::eTraceMessage:
 382     TraceNotify(message);
 383     break;
 384
 385   case ProcessMessage::eBreakpointMessage:
 386     BreakNotify(message);
 387     break;
 388
 389   case ProcessMessage::eWatchpointMessage:
 390     WatchNotify(message);
 391     break;
 392
 393   case ProcessMessage::eExecMessage:
 394     ExecNotify(message);
 395     break;
 396   }
 397 }
 398
 399 bool FreeBSDThread::EnableHardwareWatchpoint(Watchpoint *wp) {
 400   bool wp_set = false;
 401   if (wp) {
 402     addr_t wp_addr = wp->GetLoadAddress();
 403     size_t wp_size = wp->GetByteSize();
 404     bool wp_read = wp->WatchpointRead();
 405     bool wp_write = wp->WatchpointWrite();
 406     uint32_t wp_hw_index = wp->GetHardwareIndex();
 407     POSIXBreakpointProtocol *reg_ctx = GetPOSIXBreakpointProtocol();
 408     if (reg_ctx)
 409       wp_set = reg_ctx->SetHardwareWatchpointWithIndex(
 410           wp_addr, wp_size, wp_read, wp_write, wp_hw_index);
 411   }
 412   return wp_set;
 413 }
 414
 415 bool FreeBSDThread::DisableHardwareWatchpoint(Watchpoint *wp) {
 416   bool result = false;
 417   if (wp) {
 418     lldb::RegisterContextSP reg_ctx_sp = GetRegisterContext();
 419     if (reg_ctx_sp.get())
 420       result = reg_ctx_sp->ClearHardwareWatchpoint(wp->GetHardwareIndex());
 421   }
 422   return result;
 423 }
 424
 425 uint32_t FreeBSDThread::NumSupportedHardwareWatchpoints() {
 426   lldb::RegisterContextSP reg_ctx_sp = GetRegisterContext();
 427   if (reg_ctx_sp.get())
 428     return reg_ctx_sp->NumSupportedHardwareWatchpoints();
 429   return 0;
 430 }
 431
 432 uint32_t FreeBSDThread::FindVacantWatchpointIndex() {
 433   uint32_t hw_index = LLDB_INVALID_INDEX32;
 434   uint32_t num_hw_wps = NumSupportedHardwareWatchpoints();
 435   uint32_t wp_idx;
 436   POSIXBreakpointProtocol *reg_ctx = GetPOSIXBreakpointProtocol();
 437   if (reg_ctx) {
 438     for (wp_idx = 0; wp_idx < num_hw_wps; wp_idx++) {
 439       if (reg_ctx->IsWatchpointVacant(wp_idx)) {
 440         hw_index = wp_idx;
 441         break;
 442       }
 443     }
 444   }
 445   return hw_index;
 446 }
 447
 448 void FreeBSDThread::BreakNotify(const ProcessMessage &message) {
 449   bool status;
 450   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
 451
 452   assert(GetRegisterContext());
 453   status = GetPOSIXBreakpointProtocol()->UpdateAfterBreakpoint();
 454   assert(status && "Breakpoint update failed!");
 455
 456   // With our register state restored, resolve the breakpoint object
 457   // corresponding to our current PC.
 458   assert(GetRegisterContext());
 459   lldb::addr_t pc = GetRegisterContext()->GetPC();
 460   if (log)
 461     log->Printf("FreeBSDThread::%s () PC=0x%8.8" PRIx64, __FUNCTION__, pc);
 462   lldb::BreakpointSiteSP bp_site(
 463       GetProcess()->GetBreakpointSiteList().FindByAddress(pc));
 464
 465   // If the breakpoint is for this thread, then we'll report the hit, but if it
 466   // is for another thread, we create a stop reason with should_stop=false.  If
 467   // there is no breakpoint location, then report an invalid stop reason. We
 468   // don't need to worry about stepping over the breakpoint here, that will be
 469   // taken care of when the thread resumes and notices that there's a
 470   // breakpoint under the pc.
 471   if (bp_site) {
 472     lldb::break_id_t bp_id = bp_site->GetID();
 473     // If we have an operating system plug-in, we might have set a thread
 474     // specific breakpoint using the operating system thread ID, so we can't
 475     // make any assumptions about the thread ID so we must always report the
 476     // breakpoint regardless of the thread.
 477     if (bp_site->ValidForThisThread(this) ||
 478         GetProcess()->GetOperatingSystem() != nullptr)
 479       SetStopInfo(StopInfo::CreateStopReasonWithBreakpointSiteID(*this, bp_id));
 480     else {
 481       const bool should_stop = false;
 482       SetStopInfo(StopInfo::CreateStopReasonWithBreakpointSiteID(*this, bp_id,
 483                                                                  should_stop));
 484     }
 485   } else
 486     SetStopInfo(StopInfoSP());
 487 }
 488
 489 void FreeBSDThread::WatchNotify(const ProcessMessage &message) {
 490   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
 491
 492   lldb::addr_t halt_addr = message.GetHWAddress();
 493   if (log)
 494     log->Printf(
 495         "FreeBSDThread::%s () Hardware Watchpoint Address = 0x%8.8" PRIx64,
 496         __FUNCTION__, halt_addr);
 497
 498   POSIXBreakpointProtocol *reg_ctx = GetPOSIXBreakpointProtocol();
 499   if (reg_ctx) {
 500     uint32_t num_hw_wps = reg_ctx->NumSupportedHardwareWatchpoints();
 501     uint32_t wp_idx;
 502     for (wp_idx = 0; wp_idx < num_hw_wps; wp_idx++) {
 503       if (reg_ctx->IsWatchpointHit(wp_idx)) {
 504         // Clear the watchpoint hit here
 505         reg_ctx->ClearWatchpointHits();
 506         break;
 507       }
 508     }
 509
 510     if (wp_idx == num_hw_wps)
 511       return;
 512
 513     Target &target = GetProcess()->GetTarget();
 514     lldb::addr_t wp_monitor_addr = reg_ctx->GetWatchpointAddress(wp_idx);
 515     const WatchpointList &wp_list = target.GetWatchpointList();
 516     lldb::WatchpointSP wp_sp = wp_list.FindByAddress(wp_monitor_addr);
 517
 518     assert(wp_sp.get() && "No watchpoint found");
 519     SetStopInfo(
 520         StopInfo::CreateStopReasonWithWatchpointID(*this, wp_sp->GetID()));
 521   }
 522 }
 523
 524 void FreeBSDThread::TraceNotify(const ProcessMessage &message) {
 525   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
 526
 527   // Try to resolve the breakpoint object corresponding to the current PC.
 528   assert(GetRegisterContext());
 529   lldb::addr_t pc = GetRegisterContext()->GetPC();
 530   if (log)
 531     log->Printf("FreeBSDThread::%s () PC=0x%8.8" PRIx64, __FUNCTION__, pc);
 532   lldb::BreakpointSiteSP bp_site(
 533       GetProcess()->GetBreakpointSiteList().FindByAddress(pc));
 534
 535   // If the current pc is a breakpoint site then set the StopInfo to
 536   // Breakpoint. Otherwise, set the StopInfo to Watchpoint or Trace. If we have
 537   // an operating system plug-in, we might have set a thread specific
 538   // breakpoint using the operating system thread ID, so we can't make any
 539   // assumptions about the thread ID so we must always report the breakpoint
 540   // regardless of the thread.
 541   if (bp_site && (bp_site->ValidForThisThread(this) ||
 542                   GetProcess()->GetOperatingSystem() != nullptr))
 543     SetStopInfo(StopInfo::CreateStopReasonWithBreakpointSiteID(
 544         *this, bp_site->GetID()));
 545   else {
 546     POSIXBreakpointProtocol *reg_ctx = GetPOSIXBreakpointProtocol();
 547     if (reg_ctx) {
 548       uint32_t num_hw_wps = reg_ctx->NumSupportedHardwareWatchpoints();
 549       uint32_t wp_idx;
 550       for (wp_idx = 0; wp_idx < num_hw_wps; wp_idx++) {
 551         if (reg_ctx->IsWatchpointHit(wp_idx)) {
 552           WatchNotify(message);
 553           return;
 554         }
 555       }
 556     }
 557     SetStopInfo(StopInfo::CreateStopReasonToTrace(*this));
 558   }
 559 }
 560
 561 void FreeBSDThread::LimboNotify(const ProcessMessage &message) {
 562   SetStopInfo(lldb::StopInfoSP(new POSIXLimboStopInfo(*this)));
 563 }
 564
 565 void FreeBSDThread::SignalNotify(const ProcessMessage &message) {
 566   int signo = message.GetSignal();
 567   if (message.GetKind() == ProcessMessage::eCrashMessage) {
 568     std::string stop_description = GetCrashReasonString(
 569         message.GetCrashReason(), message.GetFaultAddress());
 570     SetStopInfo(StopInfo::CreateStopReasonWithSignal(
 571         *this, signo, stop_description.c_str()));
 572   } else {
 573     SetStopInfo(StopInfo::CreateStopReasonWithSignal(*this, signo));
 574   }
 575 }
 576
 577 void FreeBSDThread::SignalDeliveredNotify(const ProcessMessage &message) {
 578   int signo = message.GetSignal();
 579   SetStopInfo(StopInfo::CreateStopReasonWithSignal(*this, signo));
 580 }
 581
 582 unsigned FreeBSDThread::GetRegisterIndexFromOffset(unsigned offset) {
 583   unsigned reg = LLDB_INVALID_REGNUM;
 584   ArchSpec arch = HostInfo::GetArchitecture();
 585
 586   switch (arch.GetMachine()) {
 587   default:
 588     llvm_unreachable("CPU type not supported!");
 589     break;
 590
 591   case llvm::Triple::aarch64:
 592   case llvm::Triple::arm:
 593   case llvm::Triple::mips64:
 594   case llvm::Triple::ppc:
 595   case llvm::Triple::ppc64:
 596   case llvm::Triple::x86:
 597   case llvm::Triple::x86_64: {
 598     POSIXBreakpointProtocol *reg_ctx = GetPOSIXBreakpointProtocol();
 599     reg = reg_ctx->GetRegisterIndexFromOffset(offset);
 600   } break;
 601   }
 602   return reg;
 603 }
 604
 605 void FreeBSDThread::ExecNotify(const ProcessMessage &message) {
 606   SetStopInfo(StopInfo::CreateStopReasonWithExec(*this));
 607 }
 608
 609 const char *FreeBSDThread::GetRegisterName(unsigned reg) {
 610   const char *name = nullptr;
 611   ArchSpec arch = HostInfo::GetArchitecture();
 612
 613   switch (arch.GetMachine()) {
 614   default:
 615     assert(false && "CPU type not supported!");
 616     break;
 617
 618   case llvm::Triple::aarch64:
 619   case llvm::Triple::arm:
 620   case llvm::Triple::mips64:
 621   case llvm::Triple::ppc:
 622   case llvm::Triple::ppc64:
 623   case llvm::Triple::x86:
 624   case llvm::Triple::x86_64:
 625     name = GetRegisterContext()->GetRegisterName(reg);
 626     break;
 627   }
 628   return name;
 629 }
 630
 631 const char *FreeBSDThread::GetRegisterNameFromOffset(unsigned offset) {
 632   return GetRegisterName(GetRegisterIndexFromOffset(offset));
 633 }