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