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