xref: /freebsd/contrib/llvm-project/lldb/source/Host/common/NativeProcessProtocol.cpp (revision 7877fdebeeb35fad1cbbafce22598b1bdf97c786)
1 //===-- NativeProcessProtocol.cpp -----------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "lldb/Host/common/NativeProcessProtocol.h"
10 #include "lldb/Host/Host.h"
11 #include "lldb/Host/common/NativeBreakpointList.h"
12 #include "lldb/Host/common/NativeRegisterContext.h"
13 #include "lldb/Host/common/NativeThreadProtocol.h"
14 #include "lldb/Utility/LLDBAssert.h"
15 #include "lldb/Utility/Log.h"
16 #include "lldb/Utility/State.h"
17 #include "lldb/lldb-enumerations.h"
18 
19 #include "llvm/Support/Process.h"
20 
21 using namespace lldb;
22 using namespace lldb_private;
23 
24 // NativeProcessProtocol Members
25 
26 NativeProcessProtocol::NativeProcessProtocol(lldb::pid_t pid, int terminal_fd,
27                                              NativeDelegate &delegate)
28     : m_pid(pid), m_terminal_fd(terminal_fd) {
29   bool registered = RegisterNativeDelegate(delegate);
30   assert(registered);
31   (void)registered;
32 }
33 
34 lldb_private::Status NativeProcessProtocol::Interrupt() {
35   Status error;
36 #if !defined(SIGSTOP)
37   error.SetErrorString("local host does not support signaling");
38   return error;
39 #else
40   return Signal(SIGSTOP);
41 #endif
42 }
43 
44 Status NativeProcessProtocol::IgnoreSignals(llvm::ArrayRef<int> signals) {
45   m_signals_to_ignore.clear();
46   m_signals_to_ignore.insert(signals.begin(), signals.end());
47   return Status();
48 }
49 
50 lldb_private::Status
51 NativeProcessProtocol::GetMemoryRegionInfo(lldb::addr_t load_addr,
52                                            MemoryRegionInfo &range_info) {
53   // Default: not implemented.
54   return Status("not implemented");
55 }
56 
57 llvm::Optional<WaitStatus> NativeProcessProtocol::GetExitStatus() {
58   if (m_state == lldb::eStateExited)
59     return m_exit_status;
60 
61   return llvm::None;
62 }
63 
64 bool NativeProcessProtocol::SetExitStatus(WaitStatus status,
65                                           bool bNotifyStateChange) {
66   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
67   LLDB_LOG(log, "status = {0}, notify = {1}", status, bNotifyStateChange);
68 
69   // Exit status already set
70   if (m_state == lldb::eStateExited) {
71     if (m_exit_status)
72       LLDB_LOG(log, "exit status already set to {0}", *m_exit_status);
73     else
74       LLDB_LOG(log, "state is exited, but status not set");
75     return false;
76   }
77 
78   m_state = lldb::eStateExited;
79   m_exit_status = status;
80 
81   if (bNotifyStateChange)
82     SynchronouslyNotifyProcessStateChanged(lldb::eStateExited);
83 
84   return true;
85 }
86 
87 NativeThreadProtocol *NativeProcessProtocol::GetThreadAtIndex(uint32_t idx) {
88   std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
89   if (idx < m_threads.size())
90     return m_threads[idx].get();
91   return nullptr;
92 }
93 
94 NativeThreadProtocol *
95 NativeProcessProtocol::GetThreadByIDUnlocked(lldb::tid_t tid) {
96   for (const auto &thread : m_threads) {
97     if (thread->GetID() == tid)
98       return thread.get();
99   }
100   return nullptr;
101 }
102 
103 NativeThreadProtocol *NativeProcessProtocol::GetThreadByID(lldb::tid_t tid) {
104   std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
105   return GetThreadByIDUnlocked(tid);
106 }
107 
108 bool NativeProcessProtocol::IsAlive() const {
109   return m_state != eStateDetached && m_state != eStateExited &&
110          m_state != eStateInvalid && m_state != eStateUnloaded;
111 }
112 
113 const NativeWatchpointList::WatchpointMap &
114 NativeProcessProtocol::GetWatchpointMap() const {
115   return m_watchpoint_list.GetWatchpointMap();
116 }
117 
118 llvm::Optional<std::pair<uint32_t, uint32_t>>
119 NativeProcessProtocol::GetHardwareDebugSupportInfo() const {
120   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
121 
122   // get any thread
123   NativeThreadProtocol *thread(
124       const_cast<NativeProcessProtocol *>(this)->GetThreadAtIndex(0));
125   if (!thread) {
126     LLDB_LOG(log, "failed to find a thread to grab a NativeRegisterContext!");
127     return llvm::None;
128   }
129 
130   NativeRegisterContext &reg_ctx = thread->GetRegisterContext();
131   return std::make_pair(reg_ctx.NumSupportedHardwareBreakpoints(),
132                         reg_ctx.NumSupportedHardwareWatchpoints());
133 }
134 
135 Status NativeProcessProtocol::SetWatchpoint(lldb::addr_t addr, size_t size,
136                                             uint32_t watch_flags,
137                                             bool hardware) {
138   // This default implementation assumes setting the watchpoint for the process
139   // will require setting the watchpoint for each of the threads.  Furthermore,
140   // it will track watchpoints set for the process and will add them to each
141   // thread that is attached to via the (FIXME implement) OnThreadAttached ()
142   // method.
143 
144   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
145 
146   // Update the thread list
147   UpdateThreads();
148 
149   // Keep track of the threads we successfully set the watchpoint for.  If one
150   // of the thread watchpoint setting operations fails, back off and remove the
151   // watchpoint for all the threads that were successfully set so we get back
152   // to a consistent state.
153   std::vector<NativeThreadProtocol *> watchpoint_established_threads;
154 
155   // Tell each thread to set a watchpoint.  In the event that hardware
156   // watchpoints are requested but the SetWatchpoint fails, try to set a
157   // software watchpoint as a fallback.  It's conceivable that if there are
158   // more threads than hardware watchpoints available, some of the threads will
159   // fail to set hardware watchpoints while software ones may be available.
160   std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
161   for (const auto &thread : m_threads) {
162     assert(thread && "thread list should not have a NULL thread!");
163 
164     Status thread_error =
165         thread->SetWatchpoint(addr, size, watch_flags, hardware);
166     if (thread_error.Fail() && hardware) {
167       // Try software watchpoints since we failed on hardware watchpoint
168       // setting and we may have just run out of hardware watchpoints.
169       thread_error = thread->SetWatchpoint(addr, size, watch_flags, false);
170       if (thread_error.Success())
171         LLDB_LOG(log,
172                  "hardware watchpoint requested but software watchpoint set");
173     }
174 
175     if (thread_error.Success()) {
176       // Remember that we set this watchpoint successfully in case we need to
177       // clear it later.
178       watchpoint_established_threads.push_back(thread.get());
179     } else {
180       // Unset the watchpoint for each thread we successfully set so that we
181       // get back to a consistent state of "not set" for the watchpoint.
182       for (auto unwatch_thread_sp : watchpoint_established_threads) {
183         Status remove_error = unwatch_thread_sp->RemoveWatchpoint(addr);
184         if (remove_error.Fail())
185           LLDB_LOG(log, "RemoveWatchpoint failed for pid={0}, tid={1}: {2}",
186                    GetID(), unwatch_thread_sp->GetID(), remove_error);
187       }
188 
189       return thread_error;
190     }
191   }
192   return m_watchpoint_list.Add(addr, size, watch_flags, hardware);
193 }
194 
195 Status NativeProcessProtocol::RemoveWatchpoint(lldb::addr_t addr) {
196   // Update the thread list
197   UpdateThreads();
198 
199   Status overall_error;
200 
201   std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
202   for (const auto &thread : m_threads) {
203     assert(thread && "thread list should not have a NULL thread!");
204 
205     const Status thread_error = thread->RemoveWatchpoint(addr);
206     if (thread_error.Fail()) {
207       // Keep track of the first thread error if any threads fail. We want to
208       // try to remove the watchpoint from every thread, though, even if one or
209       // more have errors.
210       if (!overall_error.Fail())
211         overall_error = thread_error;
212     }
213   }
214   const Status error = m_watchpoint_list.Remove(addr);
215   return overall_error.Fail() ? overall_error : error;
216 }
217 
218 const HardwareBreakpointMap &
219 NativeProcessProtocol::GetHardwareBreakpointMap() const {
220   return m_hw_breakpoints_map;
221 }
222 
223 Status NativeProcessProtocol::SetHardwareBreakpoint(lldb::addr_t addr,
224                                                     size_t size) {
225   // This default implementation assumes setting a hardware breakpoint for this
226   // process will require setting same hardware breakpoint for each of its
227   // existing threads. New thread will do the same once created.
228   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
229 
230   // Update the thread list
231   UpdateThreads();
232 
233   // Exit here if target does not have required hardware breakpoint capability.
234   auto hw_debug_cap = GetHardwareDebugSupportInfo();
235 
236   if (hw_debug_cap == llvm::None || hw_debug_cap->first == 0 ||
237       hw_debug_cap->first <= m_hw_breakpoints_map.size())
238     return Status("Target does not have required no of hardware breakpoints");
239 
240   // Vector below stores all thread pointer for which we have we successfully
241   // set this hardware breakpoint. If any of the current process threads fails
242   // to set this hardware breakpoint then roll back and remove this breakpoint
243   // for all the threads that had already set it successfully.
244   std::vector<NativeThreadProtocol *> breakpoint_established_threads;
245 
246   // Request to set a hardware breakpoint for each of current process threads.
247   std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
248   for (const auto &thread : m_threads) {
249     assert(thread && "thread list should not have a NULL thread!");
250 
251     Status thread_error = thread->SetHardwareBreakpoint(addr, size);
252     if (thread_error.Success()) {
253       // Remember that we set this breakpoint successfully in case we need to
254       // clear it later.
255       breakpoint_established_threads.push_back(thread.get());
256     } else {
257       // Unset the breakpoint for each thread we successfully set so that we
258       // get back to a consistent state of "not set" for this hardware
259       // breakpoint.
260       for (auto rollback_thread_sp : breakpoint_established_threads) {
261         Status remove_error =
262             rollback_thread_sp->RemoveHardwareBreakpoint(addr);
263         if (remove_error.Fail())
264           LLDB_LOG(log,
265                    "RemoveHardwareBreakpoint failed for pid={0}, tid={1}: {2}",
266                    GetID(), rollback_thread_sp->GetID(), remove_error);
267       }
268 
269       return thread_error;
270     }
271   }
272 
273   // Register new hardware breakpoint into hardware breakpoints map of current
274   // process.
275   m_hw_breakpoints_map[addr] = {addr, size};
276 
277   return Status();
278 }
279 
280 Status NativeProcessProtocol::RemoveHardwareBreakpoint(lldb::addr_t addr) {
281   // Update the thread list
282   UpdateThreads();
283 
284   Status error;
285 
286   std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
287   for (const auto &thread : m_threads) {
288     assert(thread && "thread list should not have a NULL thread!");
289     error = thread->RemoveHardwareBreakpoint(addr);
290   }
291 
292   // Also remove from hardware breakpoint map of current process.
293   m_hw_breakpoints_map.erase(addr);
294 
295   return error;
296 }
297 
298 bool NativeProcessProtocol::RegisterNativeDelegate(
299     NativeDelegate &native_delegate) {
300   std::lock_guard<std::recursive_mutex> guard(m_delegates_mutex);
301   if (std::find(m_delegates.begin(), m_delegates.end(), &native_delegate) !=
302       m_delegates.end())
303     return false;
304 
305   m_delegates.push_back(&native_delegate);
306   native_delegate.InitializeDelegate(this);
307   return true;
308 }
309 
310 bool NativeProcessProtocol::UnregisterNativeDelegate(
311     NativeDelegate &native_delegate) {
312   std::lock_guard<std::recursive_mutex> guard(m_delegates_mutex);
313 
314   const auto initial_size = m_delegates.size();
315   m_delegates.erase(
316       remove(m_delegates.begin(), m_delegates.end(), &native_delegate),
317       m_delegates.end());
318 
319   // We removed the delegate if the count of delegates shrank after removing
320   // all copies of the given native_delegate from the vector.
321   return m_delegates.size() < initial_size;
322 }
323 
324 void NativeProcessProtocol::SynchronouslyNotifyProcessStateChanged(
325     lldb::StateType state) {
326   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
327 
328   std::lock_guard<std::recursive_mutex> guard(m_delegates_mutex);
329   for (auto native_delegate : m_delegates)
330     native_delegate->ProcessStateChanged(this, state);
331 
332   if (log) {
333     if (!m_delegates.empty()) {
334       LLDB_LOGF(log,
335                 "NativeProcessProtocol::%s: sent state notification [%s] "
336                 "from process %" PRIu64,
337                 __FUNCTION__, lldb_private::StateAsCString(state), GetID());
338     } else {
339       LLDB_LOGF(log,
340                 "NativeProcessProtocol::%s: would send state notification "
341                 "[%s] from process %" PRIu64 ", but no delegates",
342                 __FUNCTION__, lldb_private::StateAsCString(state), GetID());
343     }
344   }
345 }
346 
347 void NativeProcessProtocol::NotifyDidExec() {
348   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
349   LLDB_LOGF(log, "NativeProcessProtocol::%s - preparing to call delegates",
350             __FUNCTION__);
351 
352   {
353     std::lock_guard<std::recursive_mutex> guard(m_delegates_mutex);
354     for (auto native_delegate : m_delegates)
355       native_delegate->DidExec(this);
356   }
357 }
358 
359 Status NativeProcessProtocol::SetSoftwareBreakpoint(lldb::addr_t addr,
360                                                     uint32_t size_hint) {
361   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
362   LLDB_LOG(log, "addr = {0:x}, size_hint = {1}", addr, size_hint);
363 
364   auto it = m_software_breakpoints.find(addr);
365   if (it != m_software_breakpoints.end()) {
366     ++it->second.ref_count;
367     return Status();
368   }
369   auto expected_bkpt = EnableSoftwareBreakpoint(addr, size_hint);
370   if (!expected_bkpt)
371     return Status(expected_bkpt.takeError());
372 
373   m_software_breakpoints.emplace(addr, std::move(*expected_bkpt));
374   return Status();
375 }
376 
377 Status NativeProcessProtocol::RemoveSoftwareBreakpoint(lldb::addr_t addr) {
378   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
379   LLDB_LOG(log, "addr = {0:x}", addr);
380   auto it = m_software_breakpoints.find(addr);
381   if (it == m_software_breakpoints.end())
382     return Status("Breakpoint not found.");
383   assert(it->second.ref_count > 0);
384   if (--it->second.ref_count > 0)
385     return Status();
386 
387   // This is the last reference. Let's remove the breakpoint.
388   Status error;
389 
390   // Clear a software breakpoint instruction
391   llvm::SmallVector<uint8_t, 4> curr_break_op(
392       it->second.breakpoint_opcodes.size(), 0);
393 
394   // Read the breakpoint opcode
395   size_t bytes_read = 0;
396   error =
397       ReadMemory(addr, curr_break_op.data(), curr_break_op.size(), bytes_read);
398   if (error.Fail() || bytes_read < curr_break_op.size()) {
399     return Status("addr=0x%" PRIx64
400                   ": tried to read %zu bytes but only read %zu",
401                   addr, curr_break_op.size(), bytes_read);
402   }
403   const auto &saved = it->second.saved_opcodes;
404   // Make sure the breakpoint opcode exists at this address
405   if (makeArrayRef(curr_break_op) != it->second.breakpoint_opcodes) {
406     if (curr_break_op != it->second.saved_opcodes)
407       return Status("Original breakpoint trap is no longer in memory.");
408     LLDB_LOG(log,
409              "Saved opcodes ({0:@[x]}) have already been restored at {1:x}.",
410              llvm::make_range(saved.begin(), saved.end()), addr);
411   } else {
412     // We found a valid breakpoint opcode at this address, now restore the
413     // saved opcode.
414     size_t bytes_written = 0;
415     error = WriteMemory(addr, saved.data(), saved.size(), bytes_written);
416     if (error.Fail() || bytes_written < saved.size()) {
417       return Status("addr=0x%" PRIx64
418                     ": tried to write %zu bytes but only wrote %zu",
419                     addr, saved.size(), bytes_written);
420     }
421 
422     // Verify that our original opcode made it back to the inferior
423     llvm::SmallVector<uint8_t, 4> verify_opcode(saved.size(), 0);
424     size_t verify_bytes_read = 0;
425     error = ReadMemory(addr, verify_opcode.data(), verify_opcode.size(),
426                        verify_bytes_read);
427     if (error.Fail() || verify_bytes_read < verify_opcode.size()) {
428       return Status("addr=0x%" PRIx64
429                     ": tried to read %zu verification bytes but only read %zu",
430                     addr, verify_opcode.size(), verify_bytes_read);
431     }
432     if (verify_opcode != saved)
433       LLDB_LOG(log, "Restoring bytes at {0:x}: {1:@[x]}", addr,
434                llvm::make_range(saved.begin(), saved.end()));
435   }
436 
437   m_software_breakpoints.erase(it);
438   return Status();
439 }
440 
441 llvm::Expected<NativeProcessProtocol::SoftwareBreakpoint>
442 NativeProcessProtocol::EnableSoftwareBreakpoint(lldb::addr_t addr,
443                                                 uint32_t size_hint) {
444   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
445 
446   auto expected_trap = GetSoftwareBreakpointTrapOpcode(size_hint);
447   if (!expected_trap)
448     return expected_trap.takeError();
449 
450   llvm::SmallVector<uint8_t, 4> saved_opcode_bytes(expected_trap->size(), 0);
451   // Save the original opcodes by reading them so we can restore later.
452   size_t bytes_read = 0;
453   Status error = ReadMemory(addr, saved_opcode_bytes.data(),
454                             saved_opcode_bytes.size(), bytes_read);
455   if (error.Fail())
456     return error.ToError();
457 
458   // Ensure we read as many bytes as we expected.
459   if (bytes_read != saved_opcode_bytes.size()) {
460     return llvm::createStringError(
461         llvm::inconvertibleErrorCode(),
462         "Failed to read memory while attempting to set breakpoint: attempted "
463         "to read {0} bytes but only read {1}.",
464         saved_opcode_bytes.size(), bytes_read);
465   }
466 
467   LLDB_LOG(
468       log, "Overwriting bytes at {0:x}: {1:@[x]}", addr,
469       llvm::make_range(saved_opcode_bytes.begin(), saved_opcode_bytes.end()));
470 
471   // Write a software breakpoint in place of the original opcode.
472   size_t bytes_written = 0;
473   error = WriteMemory(addr, expected_trap->data(), expected_trap->size(),
474                       bytes_written);
475   if (error.Fail())
476     return error.ToError();
477 
478   // Ensure we wrote as many bytes as we expected.
479   if (bytes_written != expected_trap->size()) {
480     return llvm::createStringError(
481         llvm::inconvertibleErrorCode(),
482         "Failed write memory while attempting to set "
483         "breakpoint: attempted to write {0} bytes but only wrote {1}",
484         expected_trap->size(), bytes_written);
485   }
486 
487   llvm::SmallVector<uint8_t, 4> verify_bp_opcode_bytes(expected_trap->size(),
488                                                        0);
489   size_t verify_bytes_read = 0;
490   error = ReadMemory(addr, verify_bp_opcode_bytes.data(),
491                      verify_bp_opcode_bytes.size(), verify_bytes_read);
492   if (error.Fail())
493     return error.ToError();
494 
495   // Ensure we read as many verification bytes as we expected.
496   if (verify_bytes_read != verify_bp_opcode_bytes.size()) {
497     return llvm::createStringError(
498         llvm::inconvertibleErrorCode(),
499         "Failed to read memory while "
500         "attempting to verify breakpoint: attempted to read {0} bytes "
501         "but only read {1}",
502         verify_bp_opcode_bytes.size(), verify_bytes_read);
503   }
504 
505   if (llvm::makeArrayRef(verify_bp_opcode_bytes.data(), verify_bytes_read) !=
506       *expected_trap) {
507     return llvm::createStringError(
508         llvm::inconvertibleErrorCode(),
509         "Verification of software breakpoint "
510         "writing failed - trap opcodes not successfully read back "
511         "after writing when setting breakpoint at {0:x}",
512         addr);
513   }
514 
515   LLDB_LOG(log, "addr = {0:x}: SUCCESS", addr);
516   return SoftwareBreakpoint{1, saved_opcode_bytes, *expected_trap};
517 }
518 
519 llvm::Expected<llvm::ArrayRef<uint8_t>>
520 NativeProcessProtocol::GetSoftwareBreakpointTrapOpcode(size_t size_hint) {
521   static const uint8_t g_aarch64_opcode[] = {0x00, 0x00, 0x20, 0xd4};
522   static const uint8_t g_i386_opcode[] = {0xCC};
523   static const uint8_t g_mips64_opcode[] = {0x00, 0x00, 0x00, 0x0d};
524   static const uint8_t g_mips64el_opcode[] = {0x0d, 0x00, 0x00, 0x00};
525   static const uint8_t g_s390x_opcode[] = {0x00, 0x01};
526   static const uint8_t g_ppc64le_opcode[] = {0x08, 0x00, 0xe0, 0x7f}; // trap
527 
528   switch (GetArchitecture().GetMachine()) {
529   case llvm::Triple::aarch64:
530   case llvm::Triple::aarch64_32:
531     return llvm::makeArrayRef(g_aarch64_opcode);
532 
533   case llvm::Triple::x86:
534   case llvm::Triple::x86_64:
535     return llvm::makeArrayRef(g_i386_opcode);
536 
537   case llvm::Triple::mips:
538   case llvm::Triple::mips64:
539     return llvm::makeArrayRef(g_mips64_opcode);
540 
541   case llvm::Triple::mipsel:
542   case llvm::Triple::mips64el:
543     return llvm::makeArrayRef(g_mips64el_opcode);
544 
545   case llvm::Triple::systemz:
546     return llvm::makeArrayRef(g_s390x_opcode);
547 
548   case llvm::Triple::ppc64le:
549     return llvm::makeArrayRef(g_ppc64le_opcode);
550 
551   default:
552     return llvm::createStringError(llvm::inconvertibleErrorCode(),
553                                    "CPU type not supported!");
554   }
555 }
556 
557 size_t NativeProcessProtocol::GetSoftwareBreakpointPCOffset() {
558   switch (GetArchitecture().GetMachine()) {
559   case llvm::Triple::x86:
560   case llvm::Triple::x86_64:
561   case llvm::Triple::systemz:
562     // These architectures report increment the PC after breakpoint is hit.
563     return cantFail(GetSoftwareBreakpointTrapOpcode(0)).size();
564 
565   case llvm::Triple::arm:
566   case llvm::Triple::aarch64:
567   case llvm::Triple::aarch64_32:
568   case llvm::Triple::mips64:
569   case llvm::Triple::mips64el:
570   case llvm::Triple::mips:
571   case llvm::Triple::mipsel:
572   case llvm::Triple::ppc64le:
573     // On these architectures the PC doesn't get updated for breakpoint hits.
574     return 0;
575 
576   default:
577     llvm_unreachable("CPU type not supported!");
578   }
579 }
580 
581 void NativeProcessProtocol::FixupBreakpointPCAsNeeded(
582     NativeThreadProtocol &thread) {
583   Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS);
584 
585   Status error;
586 
587   // Find out the size of a breakpoint (might depend on where we are in the
588   // code).
589   NativeRegisterContext &context = thread.GetRegisterContext();
590 
591   uint32_t breakpoint_size = GetSoftwareBreakpointPCOffset();
592   LLDB_LOG(log, "breakpoint size: {0}", breakpoint_size);
593   if (breakpoint_size == 0)
594     return;
595 
596   // First try probing for a breakpoint at a software breakpoint location: PC -
597   // breakpoint size.
598   const lldb::addr_t initial_pc_addr = context.GetPCfromBreakpointLocation();
599   lldb::addr_t breakpoint_addr = initial_pc_addr;
600   // Do not allow breakpoint probe to wrap around.
601   if (breakpoint_addr >= breakpoint_size)
602     breakpoint_addr -= breakpoint_size;
603 
604   if (m_software_breakpoints.count(breakpoint_addr) == 0) {
605     // We didn't find one at a software probe location.  Nothing to do.
606     LLDB_LOG(log,
607              "pid {0} no lldb software breakpoint found at current pc with "
608              "adjustment: {1}",
609              GetID(), breakpoint_addr);
610     return;
611   }
612 
613   //
614   // We have a software breakpoint and need to adjust the PC.
615   //
616 
617   // Change the program counter.
618   LLDB_LOG(log, "pid {0} tid {1}: changing PC from {2:x} to {3:x}", GetID(),
619            thread.GetID(), initial_pc_addr, breakpoint_addr);
620 
621   error = context.SetPC(breakpoint_addr);
622   if (error.Fail()) {
623     // This can happen in case the process was killed between the time we read
624     // the PC and when we are updating it. There's nothing better to do than to
625     // swallow the error.
626     LLDB_LOG(log, "pid {0} tid {1}: failed to set PC: {2}", GetID(),
627              thread.GetID(), error);
628   }
629 }
630 
631 Status NativeProcessProtocol::RemoveBreakpoint(lldb::addr_t addr,
632                                                bool hardware) {
633   if (hardware)
634     return RemoveHardwareBreakpoint(addr);
635   else
636     return RemoveSoftwareBreakpoint(addr);
637 }
638 
639 Status NativeProcessProtocol::ReadMemoryWithoutTrap(lldb::addr_t addr,
640                                                     void *buf, size_t size,
641                                                     size_t &bytes_read) {
642   Status error = ReadMemory(addr, buf, size, bytes_read);
643   if (error.Fail())
644     return error;
645 
646   auto data =
647       llvm::makeMutableArrayRef(static_cast<uint8_t *>(buf), bytes_read);
648   for (const auto &pair : m_software_breakpoints) {
649     lldb::addr_t bp_addr = pair.first;
650     auto saved_opcodes = makeArrayRef(pair.second.saved_opcodes);
651 
652     if (bp_addr + saved_opcodes.size() < addr || addr + bytes_read <= bp_addr)
653       continue; // Breakpoint not in range, ignore
654 
655     if (bp_addr < addr) {
656       saved_opcodes = saved_opcodes.drop_front(addr - bp_addr);
657       bp_addr = addr;
658     }
659     auto bp_data = data.drop_front(bp_addr - addr);
660     std::copy_n(saved_opcodes.begin(),
661                 std::min(saved_opcodes.size(), bp_data.size()),
662                 bp_data.begin());
663   }
664   return Status();
665 }
666 
667 llvm::Expected<llvm::StringRef>
668 NativeProcessProtocol::ReadCStringFromMemory(lldb::addr_t addr, char *buffer,
669                                              size_t max_size,
670                                              size_t &total_bytes_read) {
671   static const size_t cache_line_size =
672       llvm::sys::Process::getPageSizeEstimate();
673   size_t bytes_read = 0;
674   size_t bytes_left = max_size;
675   addr_t curr_addr = addr;
676   size_t string_size;
677   char *curr_buffer = buffer;
678   total_bytes_read = 0;
679   Status status;
680 
681   while (bytes_left > 0 && status.Success()) {
682     addr_t cache_line_bytes_left =
683         cache_line_size - (curr_addr % cache_line_size);
684     addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left);
685     status = ReadMemory(curr_addr, static_cast<void *>(curr_buffer),
686                         bytes_to_read, bytes_read);
687 
688     if (bytes_read == 0)
689       break;
690 
691     void *str_end = std::memchr(curr_buffer, '\0', bytes_read);
692     if (str_end != nullptr) {
693       total_bytes_read =
694           static_cast<size_t>((static_cast<char *>(str_end) - buffer + 1));
695       status.Clear();
696       break;
697     }
698 
699     total_bytes_read += bytes_read;
700     curr_buffer += bytes_read;
701     curr_addr += bytes_read;
702     bytes_left -= bytes_read;
703   }
704 
705   string_size = total_bytes_read - 1;
706 
707   // Make sure we return a null terminated string.
708   if (bytes_left == 0 && max_size > 0 && buffer[max_size - 1] != '\0') {
709     buffer[max_size - 1] = '\0';
710     total_bytes_read--;
711   }
712 
713   if (!status.Success())
714     return status.ToError();
715 
716   return llvm::StringRef(buffer, string_size);
717 }
718 
719 lldb::StateType NativeProcessProtocol::GetState() const {
720   std::lock_guard<std::recursive_mutex> guard(m_state_mutex);
721   return m_state;
722 }
723 
724 void NativeProcessProtocol::SetState(lldb::StateType state,
725                                      bool notify_delegates) {
726   std::lock_guard<std::recursive_mutex> guard(m_state_mutex);
727 
728   if (state == m_state)
729     return;
730 
731   m_state = state;
732 
733   if (StateIsStoppedState(state, false)) {
734     ++m_stop_id;
735 
736     // Give process a chance to do any stop id bump processing, such as
737     // clearing cached data that is invalidated each time the process runs.
738     // Note if/when we support some threads running, we'll end up needing to
739     // manage this per thread and per process.
740     DoStopIDBumped(m_stop_id);
741   }
742 
743   // Optionally notify delegates of the state change.
744   if (notify_delegates)
745     SynchronouslyNotifyProcessStateChanged(state);
746 }
747 
748 uint32_t NativeProcessProtocol::GetStopID() const {
749   std::lock_guard<std::recursive_mutex> guard(m_state_mutex);
750   return m_stop_id;
751 }
752 
753 void NativeProcessProtocol::DoStopIDBumped(uint32_t /* newBumpId */) {
754   // Default implementation does nothing.
755 }
756 
757 NativeProcessProtocol::Factory::~Factory() = default;
758