1 //===-- ProcessFreeBSD.cpp ----------------------------------------*- C++
2 //-*-===//
3 //
4 //                     The LLVM Compiler Infrastructure
5 //
6 // This file is distributed under the University of Illinois Open Source
7 // License. See LICENSE.TXT for details.
8 //
9 //===----------------------------------------------------------------------===//
10 
11 // C Includes
12 #include <errno.h>
13 
14 // C++ Includes
15 #include <mutex>
16 
17 // Other libraries and framework includes
18 #include "lldb/Core/PluginManager.h"
19 #include "lldb/Core/State.h"
20 #include "lldb/Host/Host.h"
21 #include "lldb/Symbol/ObjectFile.h"
22 #include "lldb/Target/DynamicLoader.h"
23 #include "lldb/Target/Target.h"
24 
25 #include "FreeBSDThread.h"
26 #include "Plugins/Process/Utility/FreeBSDSignals.h"
27 #include "Plugins/Process/Utility/InferiorCallPOSIX.h"
28 #include "ProcessFreeBSD.h"
29 #include "ProcessMonitor.h"
30 #include "ProcessPOSIXLog.h"
31 
32 // Other libraries and framework includes
33 #include "lldb/Breakpoint/BreakpointLocation.h"
34 #include "lldb/Breakpoint/Watchpoint.h"
35 #include "lldb/Core/Module.h"
36 #include "lldb/Core/ModuleSpec.h"
37 #include "lldb/Core/PluginManager.h"
38 #include "lldb/Core/State.h"
39 #include "lldb/Host/FileSpec.h"
40 #include "lldb/Host/Host.h"
41 #include "lldb/Symbol/ObjectFile.h"
42 #include "lldb/Target/DynamicLoader.h"
43 #include "lldb/Target/Platform.h"
44 #include "lldb/Target/Target.h"
45 
46 #include "lldb/Host/posix/Fcntl.h"
47 
48 using namespace lldb;
49 using namespace lldb_private;
50 
51 namespace {
52 UnixSignalsSP &GetFreeBSDSignals() {
53   static UnixSignalsSP s_freebsd_signals_sp(new FreeBSDSignals());
54   return s_freebsd_signals_sp;
55 }
56 }
57 
58 //------------------------------------------------------------------------------
59 // Static functions.
60 
61 lldb::ProcessSP
62 ProcessFreeBSD::CreateInstance(lldb::TargetSP target_sp,
63                                lldb::ListenerSP listener_sp,
64                                const FileSpec *crash_file_path) {
65   lldb::ProcessSP process_sp;
66   if (crash_file_path == NULL)
67     process_sp.reset(
68         new ProcessFreeBSD(target_sp, listener_sp, GetFreeBSDSignals()));
69   return process_sp;
70 }
71 
72 void ProcessFreeBSD::Initialize() {
73   static std::once_flag g_once_flag;
74 
75   std::call_once(g_once_flag, []() {
76     PluginManager::RegisterPlugin(GetPluginNameStatic(),
77                                   GetPluginDescriptionStatic(), CreateInstance);
78     ProcessPOSIXLog::Initialize(GetPluginNameStatic());
79   });
80 }
81 
82 lldb_private::ConstString ProcessFreeBSD::GetPluginNameStatic() {
83   static ConstString g_name("freebsd");
84   return g_name;
85 }
86 
87 const char *ProcessFreeBSD::GetPluginDescriptionStatic() {
88   return "Process plugin for FreeBSD";
89 }
90 
91 //------------------------------------------------------------------------------
92 // ProcessInterface protocol.
93 
94 lldb_private::ConstString ProcessFreeBSD::GetPluginName() {
95   return GetPluginNameStatic();
96 }
97 
98 uint32_t ProcessFreeBSD::GetPluginVersion() { return 1; }
99 
100 void ProcessFreeBSD::Terminate() {}
101 
102 Error ProcessFreeBSD::DoDetach(bool keep_stopped) {
103   Error error;
104   if (keep_stopped) {
105     error.SetErrorString("Detaching with keep_stopped true is not currently "
106                          "supported on FreeBSD.");
107     return error;
108   }
109 
110   error = m_monitor->Detach(GetID());
111 
112   if (error.Success())
113     SetPrivateState(eStateDetached);
114 
115   return error;
116 }
117 
118 Error ProcessFreeBSD::DoResume() {
119   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
120 
121   SetPrivateState(eStateRunning);
122 
123   std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
124   bool do_step = false;
125 
126   for (tid_collection::const_iterator t_pos = m_run_tids.begin(),
127                                       t_end = m_run_tids.end();
128        t_pos != t_end; ++t_pos) {
129     m_monitor->ThreadSuspend(*t_pos, false);
130   }
131   for (tid_collection::const_iterator t_pos = m_step_tids.begin(),
132                                       t_end = m_step_tids.end();
133        t_pos != t_end; ++t_pos) {
134     m_monitor->ThreadSuspend(*t_pos, false);
135     do_step = true;
136   }
137   for (tid_collection::const_iterator t_pos = m_suspend_tids.begin(),
138                                       t_end = m_suspend_tids.end();
139        t_pos != t_end; ++t_pos) {
140     m_monitor->ThreadSuspend(*t_pos, true);
141     // XXX Cannot PT_CONTINUE properly with suspended threads.
142     do_step = true;
143   }
144 
145   if (log)
146     log->Printf("process %" PRIu64 " resuming (%s)", GetID(),
147                 do_step ? "step" : "continue");
148   if (do_step)
149     m_monitor->SingleStep(GetID(), m_resume_signo);
150   else
151     m_monitor->Resume(GetID(), m_resume_signo);
152 
153   return Error();
154 }
155 
156 bool ProcessFreeBSD::UpdateThreadList(ThreadList &old_thread_list,
157                                       ThreadList &new_thread_list) {
158   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
159   if (log)
160     log->Printf("ProcessFreeBSD::%s (pid = %" PRIu64 ")", __FUNCTION__,
161                 GetID());
162 
163   std::vector<lldb::pid_t> tds;
164   if (!GetMonitor().GetCurrentThreadIDs(tds)) {
165     return false;
166   }
167 
168   ThreadList old_thread_list_copy(old_thread_list);
169   for (size_t i = 0; i < tds.size(); ++i) {
170     tid_t tid = tds[i];
171     ThreadSP thread_sp(old_thread_list_copy.RemoveThreadByID(tid, false));
172     if (!thread_sp) {
173       thread_sp.reset(new FreeBSDThread(*this, tid));
174       if (log)
175         log->Printf("ProcessFreeBSD::%s new tid = %" PRIu64, __FUNCTION__, tid);
176     } else {
177       if (log)
178         log->Printf("ProcessFreeBSD::%s existing tid = %" PRIu64, __FUNCTION__,
179                     tid);
180     }
181     new_thread_list.AddThread(thread_sp);
182   }
183   for (size_t i = 0; i < old_thread_list_copy.GetSize(false); ++i) {
184     ThreadSP old_thread_sp(old_thread_list_copy.GetThreadAtIndex(i, false));
185     if (old_thread_sp) {
186       if (log)
187         log->Printf("ProcessFreeBSD::%s remove tid", __FUNCTION__);
188     }
189   }
190 
191   return true;
192 }
193 
194 Error ProcessFreeBSD::WillResume() {
195   m_resume_signo = 0;
196   m_suspend_tids.clear();
197   m_run_tids.clear();
198   m_step_tids.clear();
199   return Process::WillResume();
200 }
201 
202 void ProcessFreeBSD::SendMessage(const ProcessMessage &message) {
203   std::lock_guard<std::recursive_mutex> guard(m_message_mutex);
204 
205   switch (message.GetKind()) {
206   case ProcessMessage::eInvalidMessage:
207     return;
208 
209   case ProcessMessage::eAttachMessage:
210     SetPrivateState(eStateStopped);
211     return;
212 
213   case ProcessMessage::eLimboMessage:
214   case ProcessMessage::eExitMessage:
215     SetExitStatus(message.GetExitStatus(), NULL);
216     break;
217 
218   case ProcessMessage::eSignalMessage:
219   case ProcessMessage::eSignalDeliveredMessage:
220   case ProcessMessage::eBreakpointMessage:
221   case ProcessMessage::eTraceMessage:
222   case ProcessMessage::eWatchpointMessage:
223   case ProcessMessage::eCrashMessage:
224     SetPrivateState(eStateStopped);
225     break;
226 
227   case ProcessMessage::eNewThreadMessage:
228     llvm_unreachable("eNewThreadMessage unexpected on FreeBSD");
229     break;
230 
231   case ProcessMessage::eExecMessage:
232     SetPrivateState(eStateStopped);
233     break;
234   }
235 
236   m_message_queue.push(message);
237 }
238 
239 //------------------------------------------------------------------------------
240 // Constructors and destructors.
241 
242 ProcessFreeBSD::ProcessFreeBSD(lldb::TargetSP target_sp,
243                                lldb::ListenerSP listener_sp,
244                                UnixSignalsSP &unix_signals_sp)
245     : Process(target_sp, listener_sp, unix_signals_sp),
246       m_byte_order(endian::InlHostByteOrder()), m_monitor(NULL), m_module(NULL),
247       m_message_mutex(), m_exit_now(false), m_seen_initial_stop(),
248       m_resume_signo(0) {
249   // FIXME: Putting this code in the ctor and saving the byte order in a
250   // member variable is a hack to avoid const qual issues in GetByteOrder.
251   lldb::ModuleSP module = GetTarget().GetExecutableModule();
252   if (module && module->GetObjectFile())
253     m_byte_order = module->GetObjectFile()->GetByteOrder();
254 }
255 
256 ProcessFreeBSD::~ProcessFreeBSD() { delete m_monitor; }
257 
258 //------------------------------------------------------------------------------
259 // Process protocol.
260 void ProcessFreeBSD::Finalize() {
261   Process::Finalize();
262 
263   if (m_monitor)
264     m_monitor->StopMonitor();
265 }
266 
267 bool ProcessFreeBSD::CanDebug(lldb::TargetSP target_sp,
268                               bool plugin_specified_by_name) {
269   // For now we are just making sure the file exists for a given module
270   ModuleSP exe_module_sp(target_sp->GetExecutableModule());
271   if (exe_module_sp.get())
272     return exe_module_sp->GetFileSpec().Exists();
273   // If there is no executable module, we return true since we might be
274   // preparing to attach.
275   return true;
276 }
277 
278 Error ProcessFreeBSD::DoAttachToProcessWithID(
279     lldb::pid_t pid, const ProcessAttachInfo &attach_info) {
280   Error error;
281   assert(m_monitor == NULL);
282 
283   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
284   if (log && log->GetMask().Test(POSIX_LOG_VERBOSE))
285     log->Printf("ProcessFreeBSD::%s(pid = %" PRIi64 ")", __FUNCTION__, GetID());
286 
287   m_monitor = new ProcessMonitor(this, pid, error);
288 
289   if (!error.Success())
290     return error;
291 
292   PlatformSP platform_sp(GetTarget().GetPlatform());
293   assert(platform_sp.get());
294   if (!platform_sp)
295     return error; // FIXME: Detatch?
296 
297   // Find out what we can about this process
298   ProcessInstanceInfo process_info;
299   platform_sp->GetProcessInfo(pid, process_info);
300 
301   // Resolve the executable module
302   ModuleSP exe_module_sp;
303   FileSpecList executable_search_paths(
304       Target::GetDefaultExecutableSearchPaths());
305   ModuleSpec exe_module_spec(process_info.GetExecutableFile(),
306                              GetTarget().GetArchitecture());
307   error = platform_sp->ResolveExecutable(
308       exe_module_spec, exe_module_sp,
309       executable_search_paths.GetSize() ? &executable_search_paths : NULL);
310   if (!error.Success())
311     return error;
312 
313   // Fix the target architecture if necessary
314   const ArchSpec &module_arch = exe_module_sp->GetArchitecture();
315   if (module_arch.IsValid() &&
316       !GetTarget().GetArchitecture().IsExactMatch(module_arch))
317     GetTarget().SetArchitecture(module_arch);
318 
319   // Initialize the target module list
320   GetTarget().SetExecutableModule(exe_module_sp, true);
321 
322   SetSTDIOFileDescriptor(m_monitor->GetTerminalFD());
323 
324   SetID(pid);
325 
326   return error;
327 }
328 
329 Error ProcessFreeBSD::WillLaunch(Module *module) {
330   Error error;
331   return error;
332 }
333 
334 FileSpec
335 ProcessFreeBSD::GetFileSpec(const lldb_private::FileAction *file_action,
336                             const FileSpec &default_file_spec,
337                             const FileSpec &dbg_pts_file_spec) {
338   FileSpec file_spec{};
339 
340   if (file_action && file_action->GetAction() == FileAction::eFileActionOpen) {
341     file_spec = file_action->GetFileSpec();
342     // By default the stdio paths passed in will be pseudo-terminal
343     // (/dev/pts). If so, convert to using a different default path
344     // instead to redirect I/O to the debugger console. This should
345     // also handle user overrides to /dev/null or a different file.
346     if (!file_spec || file_spec == dbg_pts_file_spec)
347       file_spec = default_file_spec;
348   }
349   return file_spec;
350 }
351 
352 Error ProcessFreeBSD::DoLaunch(Module *module, ProcessLaunchInfo &launch_info) {
353   Error error;
354   assert(m_monitor == NULL);
355 
356   FileSpec working_dir = launch_info.GetWorkingDirectory();
357   if (working_dir &&
358       (!working_dir.ResolvePath() ||
359        working_dir.GetFileType() != FileSpec::eFileTypeDirectory)) {
360     error.SetErrorStringWithFormat("No such file or directory: %s",
361                                    working_dir.GetCString());
362     return error;
363   }
364 
365   SetPrivateState(eStateLaunching);
366 
367   const lldb_private::FileAction *file_action;
368 
369   // Default of empty will mean to use existing open file descriptors
370   FileSpec stdin_file_spec{};
371   FileSpec stdout_file_spec{};
372   FileSpec stderr_file_spec{};
373 
374   const FileSpec dbg_pts_file_spec{launch_info.GetPTY().GetSlaveName(NULL, 0),
375                                    false};
376 
377   file_action = launch_info.GetFileActionForFD(STDIN_FILENO);
378   stdin_file_spec =
379       GetFileSpec(file_action, stdin_file_spec, dbg_pts_file_spec);
380 
381   file_action = launch_info.GetFileActionForFD(STDOUT_FILENO);
382   stdout_file_spec =
383       GetFileSpec(file_action, stdout_file_spec, dbg_pts_file_spec);
384 
385   file_action = launch_info.GetFileActionForFD(STDERR_FILENO);
386   stderr_file_spec =
387       GetFileSpec(file_action, stderr_file_spec, dbg_pts_file_spec);
388 
389   m_monitor = new ProcessMonitor(
390       this, module, launch_info.GetArguments().GetConstArgumentVector(),
391       launch_info.GetEnvironmentEntries().GetConstArgumentVector(),
392       stdin_file_spec, stdout_file_spec, stderr_file_spec, working_dir,
393       launch_info, error);
394 
395   m_module = module;
396 
397   if (!error.Success())
398     return error;
399 
400   int terminal = m_monitor->GetTerminalFD();
401   if (terminal >= 0) {
402 // The reader thread will close the file descriptor when done, so we pass it a
403 // copy.
404 #ifdef F_DUPFD_CLOEXEC
405     int stdio = fcntl(terminal, F_DUPFD_CLOEXEC, 0);
406     if (stdio == -1) {
407       error.SetErrorToErrno();
408       return error;
409     }
410 #else
411     // Special case when F_DUPFD_CLOEXEC does not exist (Debian kFreeBSD)
412     int stdio = fcntl(terminal, F_DUPFD, 0);
413     if (stdio == -1) {
414       error.SetErrorToErrno();
415       return error;
416     }
417     stdio = fcntl(terminal, F_SETFD, FD_CLOEXEC);
418     if (stdio == -1) {
419       error.SetErrorToErrno();
420       return error;
421     }
422 #endif
423     SetSTDIOFileDescriptor(stdio);
424   }
425 
426   SetID(m_monitor->GetPID());
427   return error;
428 }
429 
430 void ProcessFreeBSD::DidLaunch() {}
431 
432 addr_t ProcessFreeBSD::GetImageInfoAddress() {
433   Target *target = &GetTarget();
434   ObjectFile *obj_file = target->GetExecutableModule()->GetObjectFile();
435   Address addr = obj_file->GetImageInfoAddress(target);
436 
437   if (addr.IsValid())
438     return addr.GetLoadAddress(target);
439   return LLDB_INVALID_ADDRESS;
440 }
441 
442 Error ProcessFreeBSD::DoHalt(bool &caused_stop) {
443   Error error;
444 
445   if (IsStopped()) {
446     caused_stop = false;
447   } else if (kill(GetID(), SIGSTOP)) {
448     caused_stop = false;
449     error.SetErrorToErrno();
450   } else {
451     caused_stop = true;
452   }
453   return error;
454 }
455 
456 Error ProcessFreeBSD::DoSignal(int signal) {
457   Error error;
458 
459   if (kill(GetID(), signal))
460     error.SetErrorToErrno();
461 
462   return error;
463 }
464 
465 Error ProcessFreeBSD::DoDestroy() {
466   Error error;
467 
468   if (!HasExited()) {
469     assert(m_monitor);
470     m_exit_now = true;
471     if (GetID() == LLDB_INVALID_PROCESS_ID) {
472       error.SetErrorString("invalid process id");
473       return error;
474     }
475     if (!m_monitor->Kill()) {
476       error.SetErrorToErrno();
477       return error;
478     }
479 
480     SetPrivateState(eStateExited);
481   }
482 
483   return error;
484 }
485 
486 void ProcessFreeBSD::DoDidExec() {
487   Target *target = &GetTarget();
488   if (target) {
489     PlatformSP platform_sp(target->GetPlatform());
490     assert(platform_sp.get());
491     if (platform_sp) {
492       ProcessInstanceInfo process_info;
493       platform_sp->GetProcessInfo(GetID(), process_info);
494       ModuleSP exe_module_sp;
495       ModuleSpec exe_module_spec(process_info.GetExecutableFile(),
496                                  target->GetArchitecture());
497       FileSpecList executable_search_paths(
498           Target::GetDefaultExecutableSearchPaths());
499       Error error = platform_sp->ResolveExecutable(
500           exe_module_spec, exe_module_sp,
501           executable_search_paths.GetSize() ? &executable_search_paths : NULL);
502       if (!error.Success())
503         return;
504       target->SetExecutableModule(exe_module_sp, true);
505     }
506   }
507 }
508 
509 bool ProcessFreeBSD::AddThreadForInitialStopIfNeeded(lldb::tid_t stop_tid) {
510   bool added_to_set = false;
511   ThreadStopSet::iterator it = m_seen_initial_stop.find(stop_tid);
512   if (it == m_seen_initial_stop.end()) {
513     m_seen_initial_stop.insert(stop_tid);
514     added_to_set = true;
515   }
516   return added_to_set;
517 }
518 
519 bool ProcessFreeBSD::WaitingForInitialStop(lldb::tid_t stop_tid) {
520   return (m_seen_initial_stop.find(stop_tid) == m_seen_initial_stop.end());
521 }
522 
523 FreeBSDThread *
524 ProcessFreeBSD::CreateNewFreeBSDThread(lldb_private::Process &process,
525                                        lldb::tid_t tid) {
526   return new FreeBSDThread(process, tid);
527 }
528 
529 void ProcessFreeBSD::RefreshStateAfterStop() {
530   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
531   if (log && log->GetMask().Test(POSIX_LOG_VERBOSE))
532     log->Printf("ProcessFreeBSD::%s(), message_queue size = %d", __FUNCTION__,
533                 (int)m_message_queue.size());
534 
535   std::lock_guard<std::recursive_mutex> guard(m_message_mutex);
536 
537   // This method used to only handle one message.  Changing it to loop allows
538   // it to handle the case where we hit a breakpoint while handling a different
539   // breakpoint.
540   while (!m_message_queue.empty()) {
541     ProcessMessage &message = m_message_queue.front();
542 
543     // Resolve the thread this message corresponds to and pass it along.
544     lldb::tid_t tid = message.GetTID();
545     if (log)
546       log->Printf(
547           "ProcessFreeBSD::%s(), message_queue size = %d, pid = %" PRIi64,
548           __FUNCTION__, (int)m_message_queue.size(), tid);
549 
550     m_thread_list.RefreshStateAfterStop();
551 
552     FreeBSDThread *thread = static_cast<FreeBSDThread *>(
553         GetThreadList().FindThreadByID(tid, false).get());
554     if (thread)
555       thread->Notify(message);
556 
557     if (message.GetKind() == ProcessMessage::eExitMessage) {
558       // FIXME: We should tell the user about this, but the limbo message is
559       // probably better for that.
560       if (log)
561         log->Printf("ProcessFreeBSD::%s() removing thread, tid = %" PRIi64,
562                     __FUNCTION__, tid);
563 
564       std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
565 
566       ThreadSP thread_sp = m_thread_list.RemoveThreadByID(tid, false);
567       thread_sp.reset();
568       m_seen_initial_stop.erase(tid);
569     }
570 
571     m_message_queue.pop();
572   }
573 }
574 
575 bool ProcessFreeBSD::IsAlive() {
576   StateType state = GetPrivateState();
577   return state != eStateDetached && state != eStateExited &&
578          state != eStateInvalid && state != eStateUnloaded;
579 }
580 
581 size_t ProcessFreeBSD::DoReadMemory(addr_t vm_addr, void *buf, size_t size,
582                                     Error &error) {
583   assert(m_monitor);
584   return m_monitor->ReadMemory(vm_addr, buf, size, error);
585 }
586 
587 size_t ProcessFreeBSD::DoWriteMemory(addr_t vm_addr, const void *buf,
588                                      size_t size, Error &error) {
589   assert(m_monitor);
590   return m_monitor->WriteMemory(vm_addr, buf, size, error);
591 }
592 
593 addr_t ProcessFreeBSD::DoAllocateMemory(size_t size, uint32_t permissions,
594                                         Error &error) {
595   addr_t allocated_addr = LLDB_INVALID_ADDRESS;
596 
597   unsigned prot = 0;
598   if (permissions & lldb::ePermissionsReadable)
599     prot |= eMmapProtRead;
600   if (permissions & lldb::ePermissionsWritable)
601     prot |= eMmapProtWrite;
602   if (permissions & lldb::ePermissionsExecutable)
603     prot |= eMmapProtExec;
604 
605   if (InferiorCallMmap(this, allocated_addr, 0, size, prot,
606                        eMmapFlagsAnon | eMmapFlagsPrivate, -1, 0)) {
607     m_addr_to_mmap_size[allocated_addr] = size;
608     error.Clear();
609   } else {
610     allocated_addr = LLDB_INVALID_ADDRESS;
611     error.SetErrorStringWithFormat(
612         "unable to allocate %zu bytes of memory with permissions %s", size,
613         GetPermissionsAsCString(permissions));
614   }
615 
616   return allocated_addr;
617 }
618 
619 Error ProcessFreeBSD::DoDeallocateMemory(lldb::addr_t addr) {
620   Error error;
621   MMapMap::iterator pos = m_addr_to_mmap_size.find(addr);
622   if (pos != m_addr_to_mmap_size.end() &&
623       InferiorCallMunmap(this, addr, pos->second))
624     m_addr_to_mmap_size.erase(pos);
625   else
626     error.SetErrorStringWithFormat("unable to deallocate memory at 0x%" PRIx64,
627                                    addr);
628 
629   return error;
630 }
631 
632 size_t
633 ProcessFreeBSD::GetSoftwareBreakpointTrapOpcode(BreakpointSite *bp_site) {
634   static const uint8_t g_aarch64_opcode[] = {0x00, 0x00, 0x20, 0xD4};
635   static const uint8_t g_i386_opcode[] = {0xCC};
636 
637   ArchSpec arch = GetTarget().GetArchitecture();
638   const uint8_t *opcode = NULL;
639   size_t opcode_size = 0;
640 
641   switch (arch.GetMachine()) {
642   default:
643     assert(false && "CPU type not supported!");
644     break;
645 
646   case llvm::Triple::arm: {
647     // The ARM reference recommends the use of 0xe7fddefe and 0xdefe
648     // but the linux kernel does otherwise.
649     static const uint8_t g_arm_breakpoint_opcode[] = {0xf0, 0x01, 0xf0, 0xe7};
650     static const uint8_t g_thumb_breakpoint_opcode[] = {0x01, 0xde};
651 
652     lldb::BreakpointLocationSP bp_loc_sp(bp_site->GetOwnerAtIndex(0));
653     AddressClass addr_class = eAddressClassUnknown;
654 
655     if (bp_loc_sp)
656       addr_class = bp_loc_sp->GetAddress().GetAddressClass();
657 
658     if (addr_class == eAddressClassCodeAlternateISA ||
659         (addr_class == eAddressClassUnknown &&
660          bp_loc_sp->GetAddress().GetOffset() & 1)) {
661       opcode = g_thumb_breakpoint_opcode;
662       opcode_size = sizeof(g_thumb_breakpoint_opcode);
663     } else {
664       opcode = g_arm_breakpoint_opcode;
665       opcode_size = sizeof(g_arm_breakpoint_opcode);
666     }
667   } break;
668   case llvm::Triple::aarch64:
669     opcode = g_aarch64_opcode;
670     opcode_size = sizeof(g_aarch64_opcode);
671     break;
672 
673   case llvm::Triple::x86:
674   case llvm::Triple::x86_64:
675     opcode = g_i386_opcode;
676     opcode_size = sizeof(g_i386_opcode);
677     break;
678   }
679 
680   bp_site->SetTrapOpcode(opcode, opcode_size);
681   return opcode_size;
682 }
683 
684 Error ProcessFreeBSD::EnableBreakpointSite(BreakpointSite *bp_site) {
685   return EnableSoftwareBreakpoint(bp_site);
686 }
687 
688 Error ProcessFreeBSD::DisableBreakpointSite(BreakpointSite *bp_site) {
689   return DisableSoftwareBreakpoint(bp_site);
690 }
691 
692 Error ProcessFreeBSD::EnableWatchpoint(Watchpoint *wp, bool notify) {
693   Error error;
694   if (wp) {
695     user_id_t watchID = wp->GetID();
696     addr_t addr = wp->GetLoadAddress();
697     Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
698     if (log)
699       log->Printf("ProcessFreeBSD::EnableWatchpoint(watchID = %" PRIu64 ")",
700                   watchID);
701     if (wp->IsEnabled()) {
702       if (log)
703         log->Printf("ProcessFreeBSD::EnableWatchpoint(watchID = %" PRIu64
704                     ") addr = 0x%8.8" PRIx64 ": watchpoint already enabled.",
705                     watchID, (uint64_t)addr);
706       return error;
707     }
708 
709     // Try to find a vacant watchpoint slot in the inferiors' main thread
710     uint32_t wp_hw_index = LLDB_INVALID_INDEX32;
711     std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
712     FreeBSDThread *thread = static_cast<FreeBSDThread *>(
713         m_thread_list.GetThreadAtIndex(0, false).get());
714 
715     if (thread)
716       wp_hw_index = thread->FindVacantWatchpointIndex();
717 
718     if (wp_hw_index == LLDB_INVALID_INDEX32) {
719       error.SetErrorString("Setting hardware watchpoint failed.");
720     } else {
721       wp->SetHardwareIndex(wp_hw_index);
722       bool wp_enabled = true;
723       uint32_t thread_count = m_thread_list.GetSize(false);
724       for (uint32_t i = 0; i < thread_count; ++i) {
725         thread = static_cast<FreeBSDThread *>(
726             m_thread_list.GetThreadAtIndex(i, false).get());
727         if (thread)
728           wp_enabled &= thread->EnableHardwareWatchpoint(wp);
729         else
730           wp_enabled = false;
731       }
732       if (wp_enabled) {
733         wp->SetEnabled(true, notify);
734         return error;
735       } else {
736         // Watchpoint enabling failed on at least one
737         // of the threads so roll back all of them
738         DisableWatchpoint(wp, false);
739         error.SetErrorString("Setting hardware watchpoint failed");
740       }
741     }
742   } else
743     error.SetErrorString("Watchpoint argument was NULL.");
744   return error;
745 }
746 
747 Error ProcessFreeBSD::DisableWatchpoint(Watchpoint *wp, bool notify) {
748   Error error;
749   if (wp) {
750     user_id_t watchID = wp->GetID();
751     addr_t addr = wp->GetLoadAddress();
752     Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
753     if (log)
754       log->Printf("ProcessFreeBSD::DisableWatchpoint(watchID = %" PRIu64 ")",
755                   watchID);
756     if (!wp->IsEnabled()) {
757       if (log)
758         log->Printf("ProcessFreeBSD::DisableWatchpoint(watchID = %" PRIu64
759                     ") addr = 0x%8.8" PRIx64 ": watchpoint already disabled.",
760                     watchID, (uint64_t)addr);
761       // This is needed (for now) to keep watchpoints disabled correctly
762       wp->SetEnabled(false, notify);
763       return error;
764     }
765 
766     if (wp->IsHardware()) {
767       bool wp_disabled = true;
768       std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
769       uint32_t thread_count = m_thread_list.GetSize(false);
770       for (uint32_t i = 0; i < thread_count; ++i) {
771         FreeBSDThread *thread = static_cast<FreeBSDThread *>(
772             m_thread_list.GetThreadAtIndex(i, false).get());
773         if (thread)
774           wp_disabled &= thread->DisableHardwareWatchpoint(wp);
775         else
776           wp_disabled = false;
777       }
778       if (wp_disabled) {
779         wp->SetHardwareIndex(LLDB_INVALID_INDEX32);
780         wp->SetEnabled(false, notify);
781         return error;
782       } else
783         error.SetErrorString("Disabling hardware watchpoint failed");
784     }
785   } else
786     error.SetErrorString("Watchpoint argument was NULL.");
787   return error;
788 }
789 
790 Error ProcessFreeBSD::GetWatchpointSupportInfo(uint32_t &num) {
791   Error error;
792   std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
793   FreeBSDThread *thread = static_cast<FreeBSDThread *>(
794       m_thread_list.GetThreadAtIndex(0, false).get());
795   if (thread)
796     num = thread->NumSupportedHardwareWatchpoints();
797   else
798     error.SetErrorString("Process does not exist.");
799   return error;
800 }
801 
802 Error ProcessFreeBSD::GetWatchpointSupportInfo(uint32_t &num, bool &after) {
803   Error error = GetWatchpointSupportInfo(num);
804   // Watchpoints trigger and halt the inferior after
805   // the corresponding instruction has been executed.
806   after = true;
807   return error;
808 }
809 
810 uint32_t ProcessFreeBSD::UpdateThreadListIfNeeded() {
811   std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
812   // Do not allow recursive updates.
813   return m_thread_list.GetSize(false);
814 }
815 
816 #if 0
817 bool
818 ProcessFreeBSD::UpdateThreadList(ThreadList &old_thread_list, ThreadList &new_thread_list)
819 {
820     Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_THREAD));
821     if (log && log->GetMask().Test(POSIX_LOG_VERBOSE))
822         log->Printf ("ProcessFreeBSD::%s() (pid = %" PRIi64 ")", __FUNCTION__, GetID());
823 
824     bool has_updated = false;
825     // Update the process thread list with this new thread.
826     // FIXME: We should be using tid, not pid.
827     assert(m_monitor);
828     ThreadSP thread_sp (old_thread_list.FindThreadByID (GetID(), false));
829     if (!thread_sp) {
830         thread_sp.reset(CreateNewFreeBSDThread(*this, GetID()));
831         has_updated = true;
832     }
833 
834     if (log && log->GetMask().Test(POSIX_LOG_VERBOSE))
835         log->Printf ("ProcessFreeBSD::%s() updated pid = %" PRIi64, __FUNCTION__, GetID());
836     new_thread_list.AddThread(thread_sp);
837 
838     return has_updated; // the list has been updated
839 }
840 #endif
841 
842 ByteOrder ProcessFreeBSD::GetByteOrder() const {
843   // FIXME: We should be able to extract this value directly.  See comment in
844   // ProcessFreeBSD().
845   return m_byte_order;
846 }
847 
848 size_t ProcessFreeBSD::PutSTDIN(const char *buf, size_t len, Error &error) {
849   ssize_t status;
850   if ((status = write(m_monitor->GetTerminalFD(), buf, len)) < 0) {
851     error.SetErrorToErrno();
852     return 0;
853   }
854   return status;
855 }
856 
857 //------------------------------------------------------------------------------
858 // Utility functions.
859 
860 bool ProcessFreeBSD::HasExited() {
861   switch (GetPrivateState()) {
862   default:
863     break;
864 
865   case eStateDetached:
866   case eStateExited:
867     return true;
868   }
869 
870   return false;
871 }
872 
873 bool ProcessFreeBSD::IsStopped() {
874   switch (GetPrivateState()) {
875   default:
876     break;
877 
878   case eStateStopped:
879   case eStateCrashed:
880   case eStateSuspended:
881     return true;
882   }
883 
884   return false;
885 }
886 
887 bool ProcessFreeBSD::IsAThreadRunning() {
888   bool is_running = false;
889   std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
890   uint32_t thread_count = m_thread_list.GetSize(false);
891   for (uint32_t i = 0; i < thread_count; ++i) {
892     FreeBSDThread *thread = static_cast<FreeBSDThread *>(
893         m_thread_list.GetThreadAtIndex(i, false).get());
894     StateType thread_state = thread->GetState();
895     if (thread_state == eStateRunning || thread_state == eStateStepping) {
896       is_running = true;
897       break;
898     }
899   }
900   return is_running;
901 }
902 
903 const DataBufferSP ProcessFreeBSD::GetAuxvData() {
904   // If we're the local platform, we can ask the host for auxv data.
905   PlatformSP platform_sp = GetTarget().GetPlatform();
906   if (platform_sp && platform_sp->IsHost())
907     return lldb_private::Host::GetAuxvData(this);
908 
909   // Somewhat unexpected - the process is not running locally or we don't have a
910   // platform.
911   assert(
912       false &&
913       "no platform or not the host - how did we get here with ProcessFreeBSD?");
914   return DataBufferSP();
915 }
916