Add setting to require hardware breakpoints.

[JDevlieghere]

Summary

When debugging read-only memory we cannot use software breakpoint. We already have support for hardware breakpoints and users can specify them with -H. However, there's no option to force hardware breakpoints even while stepping.

This patch adds a setting target.require-hardware-breakpoint that forces LLDB to always use hardware breakpoints. Because hardware breakpoints are a limited resource and therefore can fail to resolve, this patch also extends error handling in thread plans, where breakpoints are used for stepping.

[labath]

I recall something about linux on arm having a magic unmodifiable (even by ptrace) page of memory, so this could be useful there too. However, it's not clear to me how a user is going to figure out that he needs to enable this setting. Would it make sense to automatically try setting a hardware breakpoint if software breakpoint fails?

[krytarowski]

On NetBSD one has to check PaX MPROTECT property of a traced process.

Something like:

bool IsMPROTECT(pid_t pid) {
#if defined(__NetBSD__)
  int mib[3];
  int paxflags;
  size_t len = sizeof(paxflags);

  mib[0] = CTL_PROC;
  mib[1] = pid;
  mib[2] = PROC_PID_PAXFLAGS;

  if (sysctl(mib, 3, &paxflags, &len, NULL, 0) != 0)
    err(EXIT_FAILURE, "sysctl"); /* or return true */

  return !!(paxflags & CTL_PROC_PAXFLAGS_MPROTECT);
#else
  return false;
#endif
}

If IsMPROTECT is true, then we must use hardware assisted/emulated breakpoints.

[JDevlieghere]

Fix bug for thread until and add test case.

[JDevlieghere]

In D54221#1290572, @labath wrote:

I recall something about linux on arm having a magic unmodifiable (even by ptrace) page of memory, so this could be useful there too. However, it's not clear to me how a user is going to figure out that he needs to enable this setting. Would it make sense to automatically try setting a hardware breakpoint if software breakpoint fails?

My main concern would be that hardware breakpoints are a limited resource and not something we want to make transparent to the user, because it's only a matter of time before it fails. We'd also have to think about what happens to a breakpoint when one of its locations is a software bploc and the other a hardware one. I'm not against the idea but it would require some more thinking and definitely a separate patch.

[JDevlieghere]

Remove ValidatePlan implementation for ThreadPlanPython as I believe it's bogus.

[jingham]

This is pretty good, but in all the places where some plan tries to find a sub-plan to do its job, you are losing the text of the error when that job fails. So the controlling plan can't present a good error message. You need to hold onto the Status object and return that, either as the error from ValidatePlan if it happens when the plan is getting created, or in the plan's stop description so that StopInfoThreadPlan::GetDescription can print it properly.

include/lldb/Target/Thread.h

643–644

You need to change the HeaderDoc to describe the status parameter. Looks like you have to do this for all the QueueThreadPlan... functions.

include/lldb/Target/ThreadPlanBase.h

55

I don't think it is useful to pass an error in this case. The "Fundamental plan" just fields unhandled responses from other plans, and queuing it can never fail.

include/lldb/Target/ThreadPlanRunToAddress.h

66 ↗

(On Diff #173021)

Looks like you are adding this to most of the plans. Would it make sense to add it to the ThreadPlan base class? This is just an error flag, so it would stay false except is a derived plan wants to set it.

packages/Python/lldbsuite/test/functionalities/breakpoint/require_hw_breakpoints/TestRequireHWBreakpoints.py

34–44

This can all be done with:

(target, process, stepping_thread) = lldbutil.run_to_line_breakpoint(SBFileSpec("main.c"), 1)

48

Can you do this using "SBThread.StepInto" and check the error return in the case where it fails? Since we are treating the possibility of step's failing, we need to make sure that the SB API's return errors everywhere and that the errors look right. So it would be good to test that.

Ditto for the other stepping tests.

source/API/SBThread.cpp

733

Shouldn't new_plan_status get reflected in the "error" parameter passed into SBThread::StepInto?

767

Same here. If new_plan_status comes back with an error, we probably don't want to call ResumeNewPlan, and we want to report the error from queueing the plan.

818

Same comment here.

847–849

And here.

881

And here.

source/API/SBThreadPlan.cpp

155

Can you add a variant of these calls that takes an SBError &? The scripted thread plans will need to have a way to report this error when they try to queue a plan and it fails. And below as well.

source/Commands/CommandObjectThread.cpp

802

If new_plan_status.Fail is true, then you DID find a thread plan to implement the step type, it just failed to work. So it's confusing to append "Couldn't find..." in that case.

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp

169–170

You need to do something if status.Fail() == true here. IIUC, QueueThreadPlan... will return an empty sp, so you don't want to call SetPrivate on it for sure.

source/Target/StopInfo.cpp

731

Again, you should check the new_plan_status here. If it is failure, you need to get out of here, and touching the new_plan_sp is probably a bad idea.

1047–1049

The plan's description should have the failure message, since then it can have details. But if that's true you would see in the stop message:

stop reason = step out failed - couldn't set hardware breakpoint (FAILED)

I'm not sure the (FAILED) helps.

source/Target/ThreadPlanPython.cpp

49 ↗

(On Diff #173021)

Rather than remove this, set a flag to remind yourself whether ThreadPlanPython::DidPush has been called. Return true if it hasn't (because at that point you don't know whether this will succeed or not) and then do the check here if it has been.

Then whoever is queuing the plan can still usefully check ValidatePlan after Queueing it.

In general, you need to check ValidatePlan both after making the plan and after doing DidPush, which is sometimes "the second half of constructing the plan." So working ValidatePlan this way would cover both uses.

source/Target/ThreadPlanStepInRange.cpp

171

It seems like you just lose the information of why creating the sub-plan failed. In this code, it's okay if nobody could figure out a way to go somewhere useful from here, but in that case you would get no m_sub_plan_sp BUT also no error. If you get an error then we need to report the error or things will just silently fail with no explanation, which would be confusing.

244

You need to plumb a Status through here, this plan would like to know why creating a step out plan failed here.

source/Target/ThreadPlanStepInstruction.cpp

194

We need to hold onto this status and report it in the thread plan's stop description.

[JDevlieghere]

Feedback from Jim

[JDevlieghere]

Update tests to use SB API.

[labath]

In D54221#1290638, @JDevlieghere wrote:

In D54221#1290572, @labath wrote:

I recall something about linux on arm having a magic unmodifiable (even by ptrace) page of memory, so this could be useful there too. However, it's not clear to me how a user is going to figure out that he needs to enable this setting. Would it make sense to automatically try setting a hardware breakpoint if software breakpoint fails?

My main concern would be that hardware breakpoints are a limited resource and not something we want to make transparent to the user, because it's only a matter of time before it fails.

That is true, but on the other hand, you would only use hw breakpoints on those pieces of memory where you really need to instead of everywhere, which means (at least for the use case I have in mind) it be used very rarely. Of course, we would have to be careful do differentiate between reasons why setting a sw breakpoint failed (is it because the memory is RO, or some other reason like there is no memory at that address).

However, with this approach, it's still not clear to me how will the user know that he has to enable this setting? Will he get some sort of an error pointing here when the sw breakpoint fails? Or will you just enable this setting by default for targets where you know this is an issue?

[jingham]

The lldb API's parameters are ordered input first than output. Pretty much all the API's that take a Status as a parameter take it as the last parameter. So it looks weird to have the Status &error first in the QueueThreadPlan... API's. This pattern gets annoying when you have default parameters, so it's okay to put the out parameters before the default parameters (though default parameters are also not so great, so removing them is also okay...)

Other than that this looked fine.

[JDevlieghere]

Feedback Jim: move argument to the end of the list.

[jingham]

Looks good to me.

include/lldb/API/SBBreakpoint.h

public:
 
   static lldb::SBBreakpointLocation
   GetBreakpointLocationAtIndexFromEvent(const lldb::SBEvent &event,
                                         uint32_t loc_idx);
 
   static uint32_t
   GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event_sp);
 
+  bool IsHardware() const;
+
   // Can only be called from a ScriptedBreakpointResolver...
   SBError
   AddLocation(SBAddress &address);
   
 private:
   friend class SBBreakpointList;
   friend class SBBreakpointLocation;
   friend class SBBreakpointName;

include/lldb/Breakpoint/Breakpoint.h

public:
   /// breakpoint sites.
   ///
   /// @return
   ///     The number locations resolved breakpoint sites.
   //------------------------------------------------------------------
   size_t GetNumResolvedLocations() const;
 
   //------------------------------------------------------------------
+  /// Return whether this breakpoint has any resolved locations.
+  ///
+  /// @return
+  ///     True if GetNumResolvedLocations > 0
+  //------------------------------------------------------------------
+  bool HasResolvedLocations() const;
+
+  //------------------------------------------------------------------
   /// Return the number of breakpoint locations.
   ///
   /// @return
   ///     The number breakpoint locations.
   //------------------------------------------------------------------
   size_t GetNumLocations() const;
 
   //------------------------------------------------------------------

include/lldb/Target/Target.h

public:
   void SetProcessLaunchInfo(const ProcessLaunchInfo &launch_info);
 
   bool GetInjectLocalVariables(ExecutionContext *exe_ctx) const;
 
   void SetInjectLocalVariables(ExecutionContext *exe_ctx, bool b);
 
   bool GetUseModernTypeLookup() const;
 
+  void SetRequireHardwareBreakpoints(bool b);
+
+  bool GetRequireHardwareBreakpoints() const;
+
 private:
   //------------------------------------------------------------------
   // Callbacks for m_launch_info.
   //------------------------------------------------------------------
   static void Arg0ValueChangedCallback(void *target_property_ptr,
                                        OptionValue *);
   static void RunArgsValueChangedCallback(void *target_property_ptr,
                                           OptionValue *);

include/lldb/Target/Thread.h

public:
   ///    \b true if we discard the currently queued plans and replace them with
   ///    this one.
   ///    Otherwise this plan will go on the end of the plan stack.
   ///
   /// @return
   ///     A shared pointer to the newly queued thread plan, or nullptr if the
   ///     plan could not be queued.
   //------------------------------------------------------------------
-  virtual lldb::ThreadPlanSP QueueFundamentalPlan(bool abort_other_plans);
+  virtual lldb::ThreadPlanSP QueueFundamentalPlan(Status &status,
+                                                  bool abort_other_plans);
 
   //------------------------------------------------------------------
   /// Queues the plan used to step one instruction from the current PC of \a
   /// thread.
   ///
   /// @param[in] step_over
   ///    \b true if we step over calls to functions, false if we step in.
   ///
   /// @param[in] abort_other_plans
   ///    \b true if we discard the currently queued plans and replace them with
   ///    this one.
   ///    Otherwise this plan will go on the end of the plan stack.
   ///
   /// @param[in] stop_other_threads
   ///    \b true if we will stop other threads while we single step this one.
   ///
   /// @return
   ///     A shared pointer to the newly queued thread plan, or nullptr if the
   ///     plan could not be queued.
   //------------------------------------------------------------------
-  virtual lldb::ThreadPlanSP QueueThreadPlanForStepSingleInstruction(
-      bool step_over, bool abort_other_plans, bool stop_other_threads);
+  virtual lldb::ThreadPlanSP
+  QueueThreadPlanForStepSingleInstruction(Status &status, bool step_over,
+                                          bool abort_other_plans,
+                                          bool stop_other_threads);
 
   //------------------------------------------------------------------
   /// Queues the plan used to step through an address range, stepping  over
   /// function calls.
   ///
   /// @param[in] abort_other_plans
   ///    \b true if we discard the currently queued plans and replace them with
   ///    this one.
public:
   ///    out till it comes to a frame with debug info.
   ///    If eLazyBoolCalculate, we will consult the default set in the thread.
   ///
   /// @return
   ///     A shared pointer to the newly queued thread plan, or nullptr if the
   ///     plan could not be queued.
   //------------------------------------------------------------------
   virtual lldb::ThreadPlanSP QueueThreadPlanForStepOverRange(
-      bool abort_other_plans, const AddressRange &range,
+      Status &status, bool abort_other_plans, const AddressRange &range,
       const SymbolContext &addr_context, lldb::RunMode stop_other_threads,
       LazyBool step_out_avoids_code_without_debug_info = eLazyBoolCalculate);
 
   // Helper function that takes a LineEntry to step, insted of an AddressRange.
   // This may combine multiple LineEntries of the same source line number to
   // step over a longer address range in a single operation.
   virtual lldb::ThreadPlanSP QueueThreadPlanForStepOverRange(
-      bool abort_other_plans, const LineEntry &line_entry,
+      Status &status, bool abort_other_plans, const LineEntry &line_entry,
       const SymbolContext &addr_context, lldb::RunMode stop_other_threads,
       LazyBool step_out_avoids_code_without_debug_info = eLazyBoolCalculate);
 
   //------------------------------------------------------------------
   /// Queues the plan used to step through an address range, stepping into
   /// functions.
   ///
   /// @param[in] abort_other_plans
public:
   ///    out till it comes to a frame with debug info.
   ///    If eLazyBoolCalculate, it will consult the default set in the thread.
   ///
   /// @return
   ///     A shared pointer to the newly queued thread plan, or nullptr if the
   ///     plan could not be queued.
   //------------------------------------------------------------------
   virtual lldb::ThreadPlanSP QueueThreadPlanForStepInRange(
-      bool abort_other_plans, const AddressRange &range,
+      Status &status, bool abort_other_plans, const AddressRange &range,
       const SymbolContext &addr_context, const char *step_in_target,
       lldb::RunMode stop_other_threads,
       LazyBool step_in_avoids_code_without_debug_info = eLazyBoolCalculate,
       LazyBool step_out_avoids_code_without_debug_info = eLazyBoolCalculate);
 
   // Helper function that takes a LineEntry to step, insted of an AddressRange.
   // This may combine multiple LineEntries of the same source line number to
   // step over a longer address range in a single operation.
   virtual lldb::ThreadPlanSP QueueThreadPlanForStepInRange(
-      bool abort_other_plans, const LineEntry &line_entry,
+      Status &status, bool abort_other_plans, const LineEntry &line_entry,
       const SymbolContext &addr_context, const char *step_in_target,
       lldb::RunMode stop_other_threads,
       LazyBool step_in_avoids_code_without_debug_info = eLazyBoolCalculate,
       LazyBool step_out_avoids_code_without_debug_info = eLazyBoolCalculate);
 
   //------------------------------------------------------------------
   /// Queue the plan used to step out of the function at the current PC of
   /// \a thread.
public:
   ///    out till it comes to a frame with debug info.
   ///    If eLazyBoolCalculate, it will consult the default set in the thread.
   ///
   /// @return
   ///     A shared pointer to the newly queued thread plan, or nullptr if the
   ///     plan could not be queued.
   //------------------------------------------------------------------
   virtual lldb::ThreadPlanSP QueueThreadPlanForStepOut(
-      bool abort_other_plans, SymbolContext *addr_context, bool first_insn,
-      bool stop_other_threads,
+      Status &status, bool abort_other_plans, SymbolContext *addr_context,
+      bool first_insn, bool stop_other_threads,
       Vote stop_vote, // = eVoteYes,
       Vote run_vote,  // = eVoteNoOpinion);
       uint32_t frame_idx,
       LazyBool step_out_avoids_code_without_debug_info = eLazyBoolCalculate);
 
   //------------------------------------------------------------------
   /// Queue the plan used to step out of the function at the current PC of
   /// a thread.  This version does not consult the should stop here callback,
public:
   ///    registers which are overwritten
   ///    before the next branch instruction.
   ///
   /// @return
   ///     A shared pointer to the newly queued thread plan, or nullptr if the
   ///     plan could not be queued.
   //------------------------------------------------------------------
   virtual lldb::ThreadPlanSP QueueThreadPlanForStepOutNoShouldStop(
-      bool abort_other_plans, SymbolContext *addr_context, bool first_insn,
-      bool stop_other_threads,
+      Status &status, bool abort_other_plans, SymbolContext *addr_context,
+      bool first_insn, bool stop_other_threads,
       Vote stop_vote, // = eVoteYes,
       Vote run_vote,  // = eVoteNoOpinion);
       uint32_t frame_idx, bool continue_to_next_branch = false);
 
   //------------------------------------------------------------------
   /// Gets the plan used to step through the code that steps from a function
   /// call site at the current PC into the actual function call.
   ///
public:
   /// @param[in] stop_other_threads
   ///    \b true if we will stop other threads while we single step this one.
   ///
   /// @return
   ///     A shared pointer to the newly queued thread plan, or nullptr if the
   ///     plan could not be queued.
   //------------------------------------------------------------------
   virtual lldb::ThreadPlanSP
-  QueueThreadPlanForStepThrough(StackID &return_stack_id,
+  QueueThreadPlanForStepThrough(Status &status, StackID &return_stack_id,
                                 bool abort_other_plans,
                                 bool stop_other_threads);
 
   //------------------------------------------------------------------
   /// Gets the plan used to continue from the current PC.
   /// This is a simple plan, mostly useful as a backstop when you are continuing
   /// for some particular purpose.
   ///
   /// @param[in] abort_other_plans
   ///    \b true if we discard the currently queued plans and replace them with
   ///    this one.
   ///    Otherwise this plan will go on the end of the plan stack.
   ///
   /// @param[in] target_addr
   ///    The address to which we're running.
   ///
   /// @param[in] stop_other_threads
   ///    \b true if we will stop other threads while we single step this one.
   ///
   /// @return
   ///     A shared pointer to the newly queued thread plan, or nullptr if the
   ///     plan could not be queued.
   //------------------------------------------------------------------
   virtual lldb::ThreadPlanSP
-  QueueThreadPlanForRunToAddress(bool abort_other_plans, Address &target_addr,
-                                 bool stop_other_threads);
+  QueueThreadPlanForRunToAddress(Status &status, bool abort_other_plans,
+                                 Address &target_addr, bool stop_other_threads);
 
   virtual lldb::ThreadPlanSP
-  QueueThreadPlanForStepUntil(bool abort_other_plans,
+  QueueThreadPlanForStepUntil(Status &status, bool abort_other_plans,
                               lldb::addr_t *address_list, size_t num_addresses,
                               bool stop_others, uint32_t frame_idx);
 
   virtual lldb::ThreadPlanSP
-  QueueThreadPlanForStepScripted(bool abort_other_plans, const char *class_name,
+  QueueThreadPlanForStepScripted(Status &status, bool abort_other_plans,
+                                 const char *class_name,
                                  bool stop_other_threads);
 
   //------------------------------------------------------------------
   // Thread Plan accessors:
   //------------------------------------------------------------------
 
   //------------------------------------------------------------------
   /// Gets the plan which will execute next on the plan stack.
public:
   /// @param[in] abort_other_plans
   ///    \b true if we discard the currently queued plans and replace them with
   ///    this one.
   ///    Otherwise this plan will go on the end of the plan stack.
   ///
   /// @return
   ///     A pointer to the last completed plan.
   //------------------------------------------------------------------
-  void QueueThreadPlan(lldb::ThreadPlanSP &plan_sp, bool abort_other_plans);
+  Status QueueThreadPlan(lldb::ThreadPlanSP &plan_sp, bool abort_other_plans);
 
   //------------------------------------------------------------------
   /// Discards the plans queued on the plan stack of the current thread.  This
   /// is
   /// arbitrated by the "Master" ThreadPlans, using the "OkayToDiscard" call.
   //  But if \a force is true, all thread plans are discarded.
   //------------------------------------------------------------------
   void DiscardThreadPlans(bool force);

include/lldb/Target/ThreadPlanBase.h

 
 protected:
   bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;
   bool DoPlanExplainsStop(Event *event_ptr) override;
   ThreadPlanBase(Thread &thread);
 
 private:
   friend lldb::ThreadPlanSP
-  Thread::QueueFundamentalPlan(bool abort_other_plans);
+  Thread::QueueFundamentalPlan(Status &status, bool abort_other_plans);
 
   DISALLOW_COPY_AND_ASSIGN(ThreadPlanBase);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ThreadPlanFundamental_h_

include/lldb/Target/ThreadPlanStepInRange.h

ThreadPlanShouldStopHere::ThreadPlanShouldStopHereCallbacks callbacks(
         ThreadPlanStepInRange::DefaultShouldStopHereCallback, nullptr);
     SetShouldStopHereCallbacks(&callbacks, nullptr);
   }
 
   bool FrameMatchesAvoidCriteria();
 
 private:
   friend lldb::ThreadPlanSP Thread::QueueThreadPlanForStepOverRange(
-      bool abort_other_plans, const AddressRange &range,
+      Status &status, bool abort_other_plans, const AddressRange &range,
       const SymbolContext &addr_context, lldb::RunMode stop_others,
       LazyBool avoid_code_without_debug_info);
   friend lldb::ThreadPlanSP Thread::QueueThreadPlanForStepInRange(
-      bool abort_other_plans, const AddressRange &range,
+      Status &status, bool abort_other_plans, const AddressRange &range,
       const SymbolContext &addr_context, const char *step_in_target,
       lldb::RunMode stop_others,
       LazyBool step_in_avoids_code_without_debug_info,
       LazyBool step_out_avoids_code_without_debug_info);
 
   void SetupAvoidNoDebug(LazyBool step_in_avoids_code_without_debug_info,
                          LazyBool step_out_avoids_code_without_debug_info);
   // Need an appropriate marker for the current stack so we can tell step out

include/lldb/Target/ThreadPlanStepInstruction.h

 
 protected:
   bool DoPlanExplainsStop(Event *event_ptr) override;
 
   void SetUpState();
 
 private:
   friend lldb::ThreadPlanSP Thread::QueueThreadPlanForStepSingleInstruction(
-      bool step_over, bool abort_other_plans, bool stop_other_threads);
+      Status &status, bool step_over, bool abort_other_plans,
+      bool stop_other_threads);
 
   lldb::addr_t m_instruction_addr;
   bool m_stop_other_threads;
   bool m_step_over;
   // These two are used only for the step over case.
   bool m_start_has_symbol;
   StackID m_stack_id;
   StackID m_parent_frame_id;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepInstruction);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ThreadPlanStepInstruction_h_

include/lldb/Target/ThreadPlanStepOut.h

lldb::ThreadPlanSP m_step_through_inline_plan_sp; // This plan then steps past
                                                     // the inlined frame(s).
   lldb::ThreadPlanSP m_step_out_further_plan_sp; // This plan keeps stepping out
                                                  // if ShouldStopHere told us
                                                  // to.
   Function *m_immediate_step_from_function;
   std::vector<lldb::StackFrameSP> m_stepped_past_frames;
   lldb::ValueObjectSP m_return_valobj_sp;
   bool m_calculate_return_value;
+  bool m_could_not_resolve_hw_bp;
 
   friend lldb::ThreadPlanSP Thread::QueueThreadPlanForStepOut(
-      bool abort_other_plans, SymbolContext *addr_context, bool first_insn,
-      bool stop_others, Vote stop_vote, Vote run_vote, uint32_t frame_idx,
-      LazyBool step_out_avoids_code_without_debug_info);
+      Status &status, bool abort_other_plans, SymbolContext *addr_context,
+      bool first_insn, bool stop_others, Vote stop_vote, Vote run_vote,
+      uint32_t frame_idx, LazyBool step_out_avoids_code_without_debug_info);
 
   void SetupAvoidNoDebug(LazyBool step_out_avoids_code_without_debug_info);
   // Need an appropriate marker for the current stack so we can tell step out
   // from step in.
 
   void CalculateReturnValue();
 
   DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepOut);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ThreadPlanStepOut_h_

include/lldb/Target/ThreadPlanStepRange.h

protected:
   bool m_no_more_plans;   // Need this one so we can tell if we stepped into a
                           // call,
                           // but can't continue, in which case we are done.
   bool m_first_run_event; // We want to broadcast only one running event, our
                           // first.
   lldb::BreakpointSP m_next_branch_bp_sp;
   bool m_use_fast_step;
   bool m_given_ranges_only;
+  bool m_could_not_resolve_hw_bp;
 
 private:
   std::vector<lldb::DisassemblerSP> m_instruction_ranges;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepRange);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ThreadPlanStepRange_h_

include/lldb/Target/ThreadPlanStepThrough.h

protected:
   ThreadPlanStepThrough(Thread &thread, StackID &return_stack_id,
                         bool stop_others);
 
   void LookForPlanToStepThroughFromCurrentPC();
 
   bool HitOurBackstopBreakpoint();
 
 private:
-  friend lldb::ThreadPlanSP
-
-  Thread::QueueThreadPlanForStepThrough(StackID &return_stack_id,
-                                        bool abort_other_plans,
-                                        bool stop_others);
+  friend lldb::ThreadPlanSP Thread::QueueThreadPlanForStepThrough(
+      Status &status, StackID &return_stack_id, bool abort_other_plans,
 
   void ClearBackstopBreakpoint();
 
   lldb::ThreadPlanSP m_sub_plan_sp;
   lldb::addr_t m_start_address;
   lldb::break_id_t m_backstop_bkpt_id;
   lldb::addr_t m_backstop_addr;
   StackID m_return_stack_id;
   bool m_stop_others;
+  bool m_could_not_resolve_hw_bp;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepThrough);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ThreadPlanStepThrough_h_

include/lldb/Target/ThreadPlanStepUntil.h

private:
   bool m_stepped_out;
   bool m_should_stop;
   bool m_ran_analyze;
   bool m_explains_stop;
 
   typedef std::map<lldb::addr_t, lldb::break_id_t> until_collection;
   until_collection m_until_points;
   bool m_stop_others;
+  bool m_could_not_resolve_hw_bp;
 
   void Clear();
 
   friend lldb::ThreadPlanSP Thread::QueueThreadPlanForStepUntil(
-      bool abort_other_plans, lldb::addr_t *address_list, size_t num_addresses,
-      bool stop_others, uint32_t frame_idx);
+      Status &status, bool abort_other_plans, lldb::addr_t *address_list,
+      size_t num_addresses, bool stop_others, uint32_t frame_idx);
 
   // Need an appropriate marker for the current stack so we can tell step out
   // from step in.
 
   DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepUntil);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ThreadPlanStepUntil_h_

packages/Python/lldbsuite/test/functionalities/breakpoint/require_hw_breakpoints/Makefile

+LEVEL = ../../../make
+
+C_SOURCES := main.c
+
+ifneq (,$(findstring icc,$(CC)))
+    CFLAGS += -debug inline-debug-info
+endif
+
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/functionalities/breakpoint/require_hw_breakpoints/TestRequireHWBreakpoints.py

+"""
+Test require hardware breakpoints.
+"""
+
+from __future__ import print_function
+
+import os
+import time
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class BreakpointLocationsTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test_breakpoint(self):
+        """Test regular breakpoints when hardware breakpoints are required."""
+        self.build()
+        exe = self.getBuildArtifact("a.out")
+        target = self.dbg.CreateTarget(exe)
+
+        self.runCmd("settings set target.require-hardware-breakpoint true")
+
+        breakpoint = target.BreakpointCreateByLocation("main.c", 1)
+        self.assertTrue(breakpoint.IsHardware())
+
+    def test_step_range(self):
+        """Test stepping when hardware breakpoints are required."""
+        self.build()
+        exe = self.getBuildArtifact("a.out")
+        target = self.dbg.CreateTarget(exe)
+
+        breakpoint = target.BreakpointCreateByLocation("main.c", 1)
+
+        self.runCmd("run")
+
+        stepping_thread = lldbutil.get_one_thread_stopped_at_breakpoint(
+            target.GetProcess(), breakpoint)
+        self.assertTrue(stepping_thread.IsValid(),
+                        "We stopped at the right breakpoint")
+
+        self.runCmd("settings set target.require-hardware-breakpoint true")
+
+        self.expect("thread step-in")
+        self.expect("thread step-in", error=True)
+
+    def test_step_out(self):
+        """Test stepping out when hardware breakpoints are required."""
+        self.build()
+        exe = self.getBuildArtifact("a.out")
+        target = self.dbg.CreateTarget(exe)
+
+        breakpoint = target.BreakpointCreateByLocation("main.c", 1)
+
+        self.runCmd("run")
+
+        stepping_thread = lldbutil.get_one_thread_stopped_at_breakpoint(
+            target.GetProcess(), breakpoint)
+        self.assertTrue(stepping_thread.IsValid(),
+                        "We stopped at the right breakpoint")
+
+        self.runCmd("settings set target.require-hardware-breakpoint true")
+
+        self.expect("thread step-out", error=True)
+
+    def test_step_over(self):
+        """Test stepping over when hardware breakpoints are required."""
+        self.build()
+        exe = self.getBuildArtifact("a.out")
+        target = self.dbg.CreateTarget(exe)
+
+        breakpoint = target.BreakpointCreateByLocation("main.c", 7)
+
+        self.runCmd("run")
+
+        stepping_thread = lldbutil.get_one_thread_stopped_at_breakpoint(
+            target.GetProcess(), breakpoint)
+        self.assertTrue(stepping_thread.IsValid(),
+                        "We stopped at the right breakpoint")
+
+        self.runCmd("settings set target.require-hardware-breakpoint true")
+
+        # Step over doesn't fail immediately but fails later on.
+        self.expect("thread step-over")
+        self.expect("process status", substrs=['stop reason = step over (FAILED)'])

packages/Python/lldbsuite/test/functionalities/breakpoint/require_hw_breakpoints/main.c

+int break_on_me() {
+  int i = 10;
+  i++;
+  return i;
+}
+
+int main() {
+  return break_on_me();
+}

scripts/interface/SBBreakpoint.i

public:
     GetBreakpointFromEvent (const lldb::SBEvent& event);
     
     static lldb::SBBreakpointLocation
     GetBreakpointLocationAtIndexFromEvent (const lldb::SBEvent& event, uint32_t loc_idx);
     
     static uint32_t
     GetNumBreakpointLocationsFromEvent (const lldb::SBEvent &event_sp);
     
+    bool
+    IsHardware ();
+
     %pythoncode %{
         
         class locations_access(object):
             '''A helper object that will lazily hand out locations for a breakpoint when supplied an index.'''
             def __init__(self, sbbreakpoint):
                 self.sbbreakpoint = sbbreakpoint
         
             def __len__(self):

source/API/SBBreakpoint.cpp

SBBreakpoint::GetNumBreakpointLocationsFromEvent(const lldb::SBEvent &event) {
   uint32_t num_locations = 0;
   if (event.IsValid())
     num_locations =
         (Breakpoint::BreakpointEventData::GetNumBreakpointLocationsFromEvent(
             event.GetSP()));
   return num_locations;
 }
 
+bool SBBreakpoint::IsHardware() const {
+  BreakpointSP bkpt_sp = GetSP();
+  if (bkpt_sp)
+    return bkpt_sp->IsHardware();
+  return false;
+}
+
 BreakpointSP SBBreakpoint::GetSP() const { return m_opaque_wp.lock(); }
 
 // This is simple collection of breakpoint id's and their target.
 class SBBreakpointListImpl {
 public:
   SBBreakpointListImpl(lldb::TargetSP target_sp) : m_target_wp() {
     if (target_sp && target_sp->IsValid())
       m_target_wp = target_sp;

source/API/SBThread.cpp

if (!exe_ctx.HasThreadScope()) {
     error.SetErrorString("this SBThread object is invalid");
     return;
   }
 
   Thread *thread = exe_ctx.GetThreadPtr();
   bool abort_other_plans = false;
   StackFrameSP frame_sp(thread->GetStackFrameAtIndex(0));
 
+  Status new_plan_status;
   ThreadPlanSP new_plan_sp;
   if (frame_sp) {
     if (frame_sp->HasDebugInformation()) {
       const LazyBool avoid_no_debug = eLazyBoolCalculate;
       SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything));
       new_plan_sp = thread->QueueThreadPlanForStepOverRange(
-          abort_other_plans, sc.line_entry, sc, stop_other_threads,
-          avoid_no_debug);
+          new_plan_status, abort_other_plans, sc.line_entry, sc,
+          stop_other_threads, avoid_no_debug);
     } else {
       new_plan_sp = thread->QueueThreadPlanForStepSingleInstruction(
-          true, abort_other_plans, stop_other_threads);
+          new_plan_status, true, abort_other_plans, stop_other_threads);
     }
   }
   error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
 }
 
 void SBThread::StepInto(lldb::RunMode stop_other_threads) {
   StepInto(NULL, stop_other_threads);
 }
if (!exe_ctx.HasThreadScope()) {
     return;
   }
 
   bool abort_other_plans = false;
 
   Thread *thread = exe_ctx.GetThreadPtr();
   StackFrameSP frame_sp(thread->GetStackFrameAtIndex(0));
   ThreadPlanSP new_plan_sp;
+  Status new_plan_status;
 
   if (frame_sp && frame_sp->HasDebugInformation()) {
     SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything));
     AddressRange range;
     if (end_line == LLDB_INVALID_LINE_NUMBER)
       range = sc.line_entry.range;
     else {
       if (!sc.GetAddressRangeFromHereToEndLine(end_line, range, error.ref()))
         return;
     }
 
     const LazyBool step_out_avoids_code_without_debug_info =
         eLazyBoolCalculate;
     const LazyBool step_in_avoids_code_without_debug_info =
         eLazyBoolCalculate;
     new_plan_sp = thread->QueueThreadPlanForStepInRange(
-        abort_other_plans, range, sc, target_name, stop_other_threads,
-        step_in_avoids_code_without_debug_info,
+        new_plan_status, abort_other_plans, range, sc, target_name,
+        stop_other_threads, step_in_avoids_code_without_debug_info,
         step_out_avoids_code_without_debug_info);
   } else {
     new_plan_sp = thread->QueueThreadPlanForStepSingleInstruction(
-        false, abort_other_plans, stop_other_threads);
+        new_plan_status, false, abort_other_plans, stop_other_threads);
   }
   error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
 }
 
 void SBThread::StepOut() {
   SBError error; // Ignored
   StepOut(error);
 }
void SBThread::StepOut(SBError &error) {
   }
 
   bool abort_other_plans = false;
   bool stop_other_threads = false;
 
   Thread *thread = exe_ctx.GetThreadPtr();
 
   const LazyBool avoid_no_debug = eLazyBoolCalculate;
+  Status new_plan_status;
   ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepOut(
-      abort_other_plans, NULL, false, stop_other_threads, eVoteYes,
-      eVoteNoOpinion, 0, avoid_no_debug));
+      new_plan_status, abort_other_plans, NULL, false, stop_other_threads,
+      eVoteYes, eVoteNoOpinion, 0, avoid_no_debug));
 
   error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
 }
 
 void SBThread::StepOutOfFrame(SBFrame &sb_frame) {
   SBError error; // Ignored
   StepOutOfFrame(sb_frame, error);
 }
if (sb_frame.GetThread().GetThreadID() != thread->GetID()) {
     log->Printf("SBThread(%p)::StepOutOfFrame passed a frame from another "
                 "thread (0x%" PRIx64 " vrs. 0x%" PRIx64 ", returning.",
                 static_cast<void *>(exe_ctx.GetThreadPtr()),
                 sb_frame.GetThread().GetThreadID(), thread->GetID());
     error.SetErrorString("passed a frame from another thread");
     return;
   }
 
+  Status new_plan_status;
   ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepOut(
-      abort_other_plans, NULL, false, stop_other_threads, eVoteYes,
-      eVoteNoOpinion, frame_sp->GetFrameIndex()));
+      new_plan_status, abort_other_plans, NULL, false, stop_other_threads,
+      eVoteYes, eVoteNoOpinion, frame_sp->GetFrameIndex()));
 
   error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
 }
 
 void SBThread::StepInstruction(bool step_over) {
   SBError error; // Ignored
   StepInstruction(step_over, error);
 }
log->Printf("SBThread(%p)::StepInstruction (step_over=%i)",
                 static_cast<void *>(exe_ctx.GetThreadPtr()), step_over);
 
   if (!exe_ctx.HasThreadScope()) {
     error.SetErrorString("this SBThread object is invalid");
     return;
   }
 
   Thread *thread = exe_ctx.GetThreadPtr();
-  ThreadPlanSP new_plan_sp(
-      thread->QueueThreadPlanForStepSingleInstruction(step_over, true, true));
+  Status new_plan_status;
+  ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepSingleInstruction(
+      new_plan_status, step_over, true, true));
 
   error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
 }
 
 void SBThread::RunToAddress(lldb::addr_t addr) {
   SBError error; // Ignored
   RunToAddress(addr, error);
 }
void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) {
 
   bool abort_other_plans = false;
   bool stop_other_threads = true;
 
   Address target_addr(addr);
 
   Thread *thread = exe_ctx.GetThreadPtr();
 
+  Status new_plan_status;
   ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForRunToAddress(
-      abort_other_plans, target_addr, stop_other_threads));
+      new_plan_status, abort_other_plans, target_addr, stop_other_threads));
 
   error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
 }
 
 SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
                                 lldb::SBFileSpec &sb_file_spec, uint32_t line) {
   SBError sb_error;
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (exe_ctx.HasThreadScope()) {
     if (step_over_until_addrs.empty()) {
       if (all_in_function) {
         step_file_spec.GetPath(path, sizeof(path));
         sb_error.SetErrorStringWithFormat("No line entries for %s:%u", path,
                                           line);
       } else
         sb_error.SetErrorString("step until target not in current function");
     } else {
+      Status new_plan_status;
       ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepUntil(
-          abort_other_plans, &step_over_until_addrs[0],
+          new_plan_status, abort_other_plans, &step_over_until_addrs[0],
           step_over_until_addrs.size(), stop_other_threads,
           frame_sp->GetFrameIndex()));
 
       sb_error = ResumeNewPlan(exe_ctx, new_plan_sp.get());
     }
   } else {
     sb_error.SetErrorString("this SBThread object is invalid");
   }
SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
   }
 
   if (!exe_ctx.HasThreadScope()) {
     sb_error.SetErrorString("this SBThread object is invalid");
     return sb_error;
   }
 
   Thread *thread = exe_ctx.GetThreadPtr();
-  ThreadPlanSP thread_plan_sp =
-      thread->QueueThreadPlanForStepScripted(false, script_class_name, false);
+  Status thread_plan_status;
+  ThreadPlanSP thread_plan_sp = thread->QueueThreadPlanForStepScripted(
+      thread_plan_status, false, script_class_name, false);
 
   if (!thread_plan_sp) {
     sb_error.SetErrorStringWithFormat(
         "Error queueing thread plan for class: %s", script_class_name);
     return sb_error;
   }
 
   if (!resume_immediately) {

source/API/SBThreadPlan.cpp

if (m_opaque_sp) {
     Address *start_address = sb_start_address.get();
     if (!start_address) {
       return SBThreadPlan();
     }
 
     AddressRange range(*start_address, size);
     SymbolContext sc;
     start_address->CalculateSymbolContext(&sc);
+    Status plan_status;
     return SBThreadPlan(
         m_opaque_sp->GetThread().QueueThreadPlanForStepOverRange(
-            false, range, sc, eAllThreads));
+            plan_status, false, range, sc, eAllThreads));
   } else {
     return SBThreadPlan();
   }
 }
 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address,
                                             lldb::addr_t size) {
   if (m_opaque_sp) {
     Address *start_address = sb_start_address.get();
     if (!start_address) {
       return SBThreadPlan();
     }
 
     AddressRange range(*start_address, size);
     SymbolContext sc;
     start_address->CalculateSymbolContext(&sc);
+    Status plan_status;
     return SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepInRange(
-        false, range, sc, NULL, eAllThreads));
+        plan_status, false, range, sc, NULL, eAllThreads));
   } else {
     return SBThreadPlan();
   }
 }
 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
                                         bool first_insn) {
   if (m_opaque_sp) {
     SymbolContext sc;
+    Status status;
     sc = m_opaque_sp->GetThread().GetStackFrameAtIndex(0)->GetSymbolContext(
         lldb::eSymbolContextEverything);
     return SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepOut(
-        false, &sc, first_insn, false, eVoteYes, eVoteNoOpinion,
+        status, false, &sc, first_insn, false, eVoteYes, eVoteNoOpinion,
         frame_idx_to_step_to));
   } else {
     return SBThreadPlan();
   }
 }
 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address) {
   if (m_opaque_sp) {
     Address *address = sb_address.get();
     if (!address)
       return SBThreadPlan();
 
+    Status status;
     return SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForRunToAddress(
-        false, *address, false));
+        status, false, *address, false));
   } else {
     return SBThreadPlan();
   }
 }
 
 SBThreadPlan
 SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name) {
   if (m_opaque_sp) {
+    Status status;
     return SBThreadPlan(m_opaque_sp->GetThread().QueueThreadPlanForStepScripted(
-        false, script_class_name, false));
+        status, false, script_class_name, false));
   } else {
     return SBThreadPlan();
   }
 }

source/Breakpoint/Breakpoint.cpp

 void Breakpoint::Dump(Stream *) {}
 
 size_t Breakpoint::GetNumResolvedLocations() const {
   // Return the number of breakpoints that are actually resolved and set down
   // in the inferior process.
   return m_locations.GetNumResolvedLocations();
 }
 
+bool Breakpoint::HasResolvedLocations() const {
+  return GetNumResolvedLocations() > 0;
+}
+
 size_t Breakpoint::GetNumLocations() const { return m_locations.GetSize(); }
 
 bool Breakpoint::AddName(llvm::StringRef new_name) {
   m_name_list.insert(new_name.str().c_str());
   return true;
 }
 
 void Breakpoint::GetDescription(Stream *s, lldb::DescriptionLevel level,

source/Commands/CommandObjectThread.cpp

if (m_options.m_run_mode == eAllThreads)
       bool_stop_other_threads = false;
     else if (m_options.m_run_mode == eOnlyDuringStepping)
       bool_stop_other_threads =
           (m_step_type != eStepTypeOut && m_step_type != eStepTypeScripted);
     else
       bool_stop_other_threads = true;
 
     ThreadPlanSP new_plan_sp;
+    Status new_plan_status;
 
     if (m_step_type == eStepTypeInto) {
       StackFrame *frame = thread->GetStackFrameAtIndex(0).get();
       assert(frame != nullptr);
 
       if (frame->HasDebugInformation()) {
         AddressRange range;
         SymbolContext sc = frame->GetSymbolContext(eSymbolContextEverything);
if (m_step_type == eStepTypeInto) {
           lldb::addr_t range_length =
               block_range.GetByteSize() - pc_offset_in_block;
           range = AddressRange(pc_address, range_length);
         } else {
           range = sc.line_entry.range;
         }
 
         new_plan_sp = thread->QueueThreadPlanForStepInRange(
-            abort_other_plans, range,
+            new_plan_status, abort_other_plans, range,
             frame->GetSymbolContext(eSymbolContextEverything),
             m_options.m_step_in_target.c_str(), stop_other_threads,
             m_options.m_step_in_avoid_no_debug,
             m_options.m_step_out_avoid_no_debug);
 
         if (new_plan_sp && !m_options.m_avoid_regexp.empty()) {
           ThreadPlanStepInRange *step_in_range_plan =
               static_cast<ThreadPlanStepInRange *>(new_plan_sp.get());
           step_in_range_plan->SetAvoidRegexp(m_options.m_avoid_regexp.c_str());
         }
       } else
         new_plan_sp = thread->QueueThreadPlanForStepSingleInstruction(
-            false, abort_other_plans, bool_stop_other_threads);
+            new_plan_status, false, abort_other_plans, bool_stop_other_threads);
     } else if (m_step_type == eStepTypeOver) {
       StackFrame *frame = thread->GetStackFrameAtIndex(0).get();
 
       if (frame->HasDebugInformation())
         new_plan_sp = thread->QueueThreadPlanForStepOverRange(
-            abort_other_plans,
+            new_plan_status, abort_other_plans,
             frame->GetSymbolContext(eSymbolContextEverything).line_entry,
             frame->GetSymbolContext(eSymbolContextEverything),
             stop_other_threads, m_options.m_step_out_avoid_no_debug);
       else
         new_plan_sp = thread->QueueThreadPlanForStepSingleInstruction(
-            true, abort_other_plans, bool_stop_other_threads);
+            new_plan_status, true, abort_other_plans, bool_stop_other_threads);
     } else if (m_step_type == eStepTypeTrace) {
       new_plan_sp = thread->QueueThreadPlanForStepSingleInstruction(
-          false, abort_other_plans, bool_stop_other_threads);
+          new_plan_status, false, abort_other_plans, bool_stop_other_threads);
     } else if (m_step_type == eStepTypeTraceOver) {
       new_plan_sp = thread->QueueThreadPlanForStepSingleInstruction(
-          true, abort_other_plans, bool_stop_other_threads);
+          new_plan_status, true, abort_other_plans, bool_stop_other_threads);
     } else if (m_step_type == eStepTypeOut) {
       new_plan_sp = thread->QueueThreadPlanForStepOut(
-          abort_other_plans, nullptr, false, bool_stop_other_threads, eVoteYes,
-          eVoteNoOpinion, thread->GetSelectedFrameIndex(),
-          m_options.m_step_out_avoid_no_debug);
+          new_plan_status, abort_other_plans, nullptr, false,
+          bool_stop_other_threads, eVoteYes, eVoteNoOpinion,
+          thread->GetSelectedFrameIndex(), m_options.m_step_out_avoid_no_debug);
     } else if (m_step_type == eStepTypeScripted) {
       new_plan_sp = thread->QueueThreadPlanForStepScripted(
-          abort_other_plans, m_options.m_class_name.c_str(),
+          new_plan_status, abort_other_plans, m_options.m_class_name.c_str(),
           bool_stop_other_threads);
     } else {
       result.AppendError("step type is not supported");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     // If we got a new plan, then set it to be a master plan (User level Plans
if (new_plan_sp) {
 
         process->GetThreadList().SetSelectedThreadByID(thread->GetID());
         result.SetDidChangeProcessState(true);
         result.SetStatus(eReturnStatusSuccessFinishNoResult);
       } else {
         result.SetStatus(eReturnStatusSuccessContinuingNoResult);
       }
     } else {
+      result.SetError(new_plan_status);
       result.AppendError("Couldn't find thread plan to implement step type.");
       result.SetStatus(eReturnStatusFailed);
     }
     return result.Succeeded();
   }
 
 protected:
   StepType m_step_type;
if (process == nullptr) {
         result.AppendErrorWithFormat(
             "Frame index %u is out of range for thread %u.\n",
             m_options.m_frame_idx, m_options.m_thread_idx);
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
 
       ThreadPlanSP new_plan_sp;
+      Status new_plan_status;
 
       if (frame->HasDebugInformation()) {
         // Finally we got here...  Translate the given line number to a bunch
         // of addresses:
         SymbolContext sc(frame->GetSymbolContext(eSymbolContextCompUnit));
         LineTable *line_table = nullptr;
         if (sc.comp_unit)
           line_table = sc.comp_unit->GetLineTable();
if (process == nullptr) {
             result.AppendErrorWithFormat(
                 "Until target outside of the current function.\n");
 
           result.SetStatus(eReturnStatusFailed);
           return false;
         }
 
         new_plan_sp = thread->QueueThreadPlanForStepUntil(
-            abort_other_plans, &address_list.front(), address_list.size(),
-            m_options.m_stop_others, m_options.m_frame_idx);
+            new_plan_status, abort_other_plans, &address_list.front(),
+            address_list.size(), m_options.m_stop_others,
+            m_options.m_frame_idx);
         // User level plans should be master plans so they can be interrupted
         // (e.g. by hitting a breakpoint) and other plans executed by the user
         // (stepping around the breakpoint) and then a "continue" will resume
         // the original plan.
         new_plan_sp->SetIsMasterPlan(true);
         new_plan_sp->SetOkayToDiscard(false);
       } else {
+        result.SetError(new_plan_status);
         result.AppendErrorWithFormat(
             "Frame index %u of thread %u has no debug information.\n",
             m_options.m_frame_idx, m_options.m_thread_idx);
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
 
       process->GetThreadList().SetSelectedThreadByID(m_options.m_thread_idx);

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp

if (m_trampoline_handler->AddrIsMsgForward(target_addr)) {
       if (log)
         log->Printf(
             "Implementation lookup returned msgForward function: 0x%" PRIx64
             ", stopping.",
             target_addr);
 
       SymbolContext sc = m_thread.GetStackFrameAtIndex(0)->GetSymbolContext(
           eSymbolContextEverything);
+      Status status;
       const bool abort_other_plans = false;
       const bool first_insn = true;
       const uint32_t frame_idx = 0;
       m_run_to_sp = m_thread.QueueThreadPlanForStepOutNoShouldStop(
-          abort_other_plans, &sc, first_insn, m_stop_others, eVoteNoOpinion,
-          eVoteNoOpinion, frame_idx);
+          status, abort_other_plans, &sc, first_insn, m_stop_others,
+          eVoteNoOpinion, eVoteNoOpinion, frame_idx);
       m_run_to_sp->SetPrivate(true);
       return false;
     }
 
     if (log)
       log->Printf("Running to ObjC method implementation: 0x%" PRIx64,
                   target_addr);
 

source/Target/Process.cpp

if (bp_site_sp) {
       bp_site_sp.reset(new BreakpointSite(&m_breakpoint_site_list, owner,
                                           load_addr, use_hardware));
       if (bp_site_sp) {
         Status error = EnableBreakpointSite(bp_site_sp.get());
         if (error.Success()) {
           owner->SetBreakpointSite(bp_site_sp);
           return m_breakpoint_site_list.Add(bp_site_sp);
         } else {
-          if (show_error) {
+          if (show_error || use_hardware) {
             // Report error for setting breakpoint...
             GetTarget().GetDebugger().GetErrorFile()->Printf(
                 "warning: failed to set breakpoint site at 0x%" PRIx64
                 " for breakpoint %i.%i: %s\n",
                 load_addr, owner->GetBreakpoint().GetID(), owner->GetID(),
                 error.AsCString() ? error.AsCString() : "unknown error");
           }
         }

source/Target/StopInfo.cpp

if (thread_sp) {
                 // disable. Since Watchpoint::SetEnabled will clear the watch
                 // index. This will fix TestWatchpointIter failure
                 Watchpoint *wp = wp_sp.get();
                 uint32_t watch_index = wp->GetHardwareIndex();
                 process_sp->DisableWatchpoint(wp, false);
                 StopInfoSP stored_stop_info_sp = thread_sp->GetStopInfo();
                 assert(stored_stop_info_sp.get() == this);
 
+                Status new_plan_status;
                 ThreadPlanSP new_plan_sp(
                     thread_sp->QueueThreadPlanForStepSingleInstruction(
-                        false,  // step-over
-                        false,  // abort_other_plans
-                        true)); // stop_other_threads
+                        new_plan_status,
+                        false, // step-over
+                        false, // abort_other_plans
+                        true   // stop_other_threads
+                        ));
                 new_plan_sp->SetIsMasterPlan(true);
                 new_plan_sp->SetOkayToDiscard(false);
                 new_plan_sp->SetPrivate(true);
                 process_sp->GetThreadList().SetSelectedThreadByID(
                     thread_sp->GetID());
                 process_sp->ResumeSynchronous(nullptr);
                 process_sp->GetThreadList().SetSelectedThreadByID(
                     thread_sp->GetID());
                 thread_sp->SetStopInfo(stored_stop_info_sp);
public:
 
   ~StopInfoThreadPlan() override = default;
 
   StopReason GetStopReason() const override { return eStopReasonPlanComplete; }
 
   const char *GetDescription() override {
     if (m_description.empty()) {
       StreamString strm;
       m_plan_sp->GetDescription(&strm, eDescriptionLevelBrief);
+      if (!m_plan_sp->PlanSucceeded())
+        strm << " (FAILED)";
       m_description = strm.GetString();
     }
     return m_description.c_str();
   }
 
   ValueObjectSP GetReturnValueObject() { return m_return_valobj_sp; }
 
   ExpressionVariableSP GetExpressionVariable() {

source/Target/Target.cpp

 
 
 BreakpointSP Target::CreateBreakpoint(SearchFilterSP &filter_sp,
                                       BreakpointResolverSP &resolver_sp,
                                       bool internal, bool request_hardware,
                                       bool resolve_indirect_symbols) {
   BreakpointSP bp_sp;
   if (filter_sp && resolver_sp) {
-    bp_sp.reset(new Breakpoint(*this, filter_sp, resolver_sp, request_hardware,
+    const bool hardware = request_hardware || GetRequireHardwareBreakpoints();
+    bp_sp.reset(new Breakpoint(*this, filter_sp, resolver_sp, hardware,
                                resolve_indirect_symbols));
     resolver_sp->SetBreakpoint(bp_sp.get());
     AddBreakpoint(bp_sp, internal);
   }
   return bp_sp;
 }
 
 void Target::AddBreakpoint(lldb::BreakpointSP bp_sp, bool internal) {
void Target::StopHook::GetDescription(Stream *s,
   }
   s->SetIndentLevel(indent_level);
 }
 
 //--------------------------------------------------------------
 // class TargetProperties
 //--------------------------------------------------------------
 
+// clang-format off
 static constexpr OptionEnumValueElement g_dynamic_value_types[] = {
     {eNoDynamicValues, "no-dynamic-values",
      "Don't calculate the dynamic type of values"},
     {eDynamicCanRunTarget, "run-target", "Calculate the dynamic type of values "
                                          "even if you have to run the target."},
     {eDynamicDontRunTarget, "no-run-target",
      "Calculate the dynamic type of values, but don't run the target."} };
 
static constexpr PropertyDefinition g_properties[] = {
     {"trap-handler-names", OptionValue::eTypeArray, true,
      OptionValue::eTypeString, nullptr, {},
      "A list of trap handler function names, e.g. a common Unix user process "
      "one is _sigtramp."},
     {"display-runtime-support-values", OptionValue::eTypeBoolean, false, false,
      nullptr, {}, "If true, LLDB will show variables that are meant to "
                   "support the operation of a language's runtime support."},
     {"non-stop-mode", OptionValue::eTypeBoolean, false, 0, nullptr, {},
-     "Disable lock-step debugging, instead control threads independently."}};
+     "Disable lock-step debugging, instead control threads independently."},
+    {"require-hardware-breakpoint", OptionValue::eTypeBoolean, false, 0,
+     nullptr, {}, "Require all breakpoints to be hardware breakpoints."}};
+// clang-format on
 
 enum {
   ePropertyDefaultArch,
   ePropertyMoveToNearestCode,
   ePropertyLanguage,
   ePropertyExprPrefix,
   ePropertyPreferDynamic,
   ePropertyEnableSynthetic,
enum {
   ePropertyUseFastStepping,
   ePropertyLoadScriptFromSymbolFile,
   ePropertyLoadCWDlldbinitFile,
   ePropertyMemoryModuleLoadLevel,
   ePropertyDisplayExpressionsInCrashlogs,
   ePropertyTrapHandlerNames,
   ePropertyDisplayRuntimeSupportValues,
   ePropertyNonStopModeEnabled,
-  ePropertyExperimental
+  ePropertyRequireHardwareBreakpoints,
+  ePropertyExperimental,
 };
 
 class TargetOptionValueProperties : public OptionValueProperties {
 public:
   TargetOptionValueProperties(const ConstString &name)
       : OptionValueProperties(name), m_target(nullptr), m_got_host_env(false) {}
 
   // This constructor is used when creating TargetOptionValueProperties when it
void TargetProperties::SetProcessLaunchInfo(
   if (error_file_action) {
     SetStandardErrorPath(error_file_action->GetPath());
   }
   SetDetachOnError(launch_info.GetFlags().Test(lldb::eLaunchFlagDetachOnError));
   SetDisableASLR(launch_info.GetFlags().Test(lldb::eLaunchFlagDisableASLR));
   SetDisableSTDIO(launch_info.GetFlags().Test(lldb::eLaunchFlagDisableSTDIO));
 }
 
+bool TargetProperties::GetRequireHardwareBreakpoints() const {
+  const uint32_t idx = ePropertyRequireHardwareBreakpoints;
+  return m_collection_sp->GetPropertyAtIndexAsBoolean(
+      nullptr, idx, g_properties[idx].default_uint_value != 0);
+}
+
+void TargetProperties::SetRequireHardwareBreakpoints(bool b) {
+  const uint32_t idx = ePropertyRequireHardwareBreakpoints;
+  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
+}
+
 void TargetProperties::Arg0ValueChangedCallback(void *target_property_ptr,
                                                 OptionValue *) {
   TargetProperties *this_ =
       reinterpret_cast<TargetProperties *>(target_property_ptr);
   this_->m_launch_info.SetArg0(this_->GetArg0());
 }
 
 void TargetProperties::RunArgsValueChangedCallback(void *target_property_ptr,

source/Target/Thread.cpp

: ThreadProperties(false), UserID(tid),
       m_override_should_notify(eLazyBoolCalculate),
       m_extended_info_fetched(false), m_extended_info() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
   if (log)
     log->Printf("%p Thread::Thread(tid = 0x%4.4" PRIx64 ")",
                 static_cast<void *>(this), GetID());
 
   CheckInWithManager();
-  QueueFundamentalPlan(true);
+
+  Status status;
+  QueueFundamentalPlan(status, true);
 }
 
 Thread::~Thread() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
   if (log)
     log->Printf("%p Thread::~Thread(tid = 0x%4.4" PRIx64 ")",
                 static_cast<void *>(this), GetID());
   /// If you hit this assert, it means your derived class forgot to call
lldb::StopInfoSP Thread::GetStopInfo() {
   // not trace) - preset value - completed plan stop info - new value with plan
   // from completed plan stack - m_stop_info_sp (trace stop reason is OK now) -
   // ask GetPrivateStopInfo to set stop info
 
   bool have_valid_stop_info = m_stop_info_sp &&
       m_stop_info_sp ->IsValid() &&
       m_stop_info_stop_id == stop_id;
   bool have_valid_completed_plan = completed_plan_sp && completed_plan_sp->PlanSucceeded();
+  bool plan_failed = completed_plan_sp && !completed_plan_sp->PlanSucceeded();
   bool plan_overrides_trace =
     have_valid_stop_info && have_valid_completed_plan
     && (m_stop_info_sp->GetStopReason() == eStopReasonTrace);
 
-  if (have_valid_stop_info && !plan_overrides_trace) {
+  if (have_valid_stop_info && !plan_overrides_trace && !plan_failed) {
     return m_stop_info_sp;
-  } else if (have_valid_completed_plan) {
+  } else if (completed_plan_sp) {
     return StopInfo::CreateStopReasonWithPlan(
         completed_plan_sp, GetReturnValueObject(), GetExpressionVariable());
   } else {
     GetPrivateStopInfo();
     return m_stop_info_sp;
   }
 }
 
ThreadPlan *Thread::GetPreviousPlan(ThreadPlan *current_plan) {
   stack_size = m_plan_stack.size();
   for (int i = stack_size - 1; i > 0; i--) {
     if (current_plan == m_plan_stack[i].get())
       return m_plan_stack[i - 1].get();
   }
   return nullptr;
 }
 
-void Thread::QueueThreadPlan(ThreadPlanSP &thread_plan_sp,
+Status Thread::QueueThreadPlan(ThreadPlanSP &thread_plan_sp,
                                bool abort_other_plans) {
+  Status status;
+  StreamString s;
+  if (!thread_plan_sp->ValidatePlan(&s)) {
+    DiscardThreadPlansUpToPlan(thread_plan_sp);
+    thread_plan_sp.reset();
+    status.SetErrorString(s.GetString());
+    return status;
+  }
+
   if (abort_other_plans)
     DiscardThreadPlans(true);
 
   PushPlan(thread_plan_sp);
+
+  // This seems a little funny, but I don't want to have to split up the
+  // constructor and the DidPush in the scripted plan, that seems annoying.
+  // That means the constructor has to be in DidPush. So I have to validate the
+  // plan AFTER pushing it, and then take it off again...
+  if (!thread_plan_sp->ValidatePlan(&s)) {
+    DiscardThreadPlansUpToPlan(thread_plan_sp);
+    thread_plan_sp.reset();
+    status.SetErrorString(s.GetString());
+    return status;
+  }
+
+  return status;
 }
 
 void Thread::EnableTracer(bool value, bool single_stepping) {
   int stack_size = m_plan_stack.size();
   for (int i = 0; i < stack_size; i++) {
     if (m_plan_stack[i]->GetThreadPlanTracer()) {
       m_plan_stack[i]->GetThreadPlanTracer()->EnableTracing(value);
       m_plan_stack[i]->GetThreadPlanTracer()->EnableSingleStep(single_stepping);
if (m_plan_stack[i]->GetKind() == ThreadPlan::eKindCallFunction) {
       DiscardThreadPlansUpToPlan(m_plan_stack[i].get());
       return error;
     }
   }
   error.SetErrorString("No expressions currently active on this thread");
   return error;
 }
 
-ThreadPlanSP Thread::QueueFundamentalPlan(bool abort_other_plans) {
+ThreadPlanSP Thread::QueueFundamentalPlan(Status &status,
+                                          bool abort_other_plans) {
   ThreadPlanSP thread_plan_sp(new ThreadPlanBase(*this));
-  QueueThreadPlan(thread_plan_sp, abort_other_plans);
+  status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
   return thread_plan_sp;
 }
 
-ThreadPlanSP Thread::QueueThreadPlanForStepSingleInstruction(
-    bool step_over, bool abort_other_plans, bool stop_other_threads) {
+ThreadPlanSP
+Thread::QueueThreadPlanForStepSingleInstruction(Status &status, bool step_over,
+                                                bool abort_other_plans,
+                                                bool stop_other_threads) {
   ThreadPlanSP thread_plan_sp(new ThreadPlanStepInstruction(
       *this, step_over, stop_other_threads, eVoteNoOpinion, eVoteNoOpinion));
-  QueueThreadPlan(thread_plan_sp, abort_other_plans);
+  status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
   return thread_plan_sp;
 }
 
 ThreadPlanSP Thread::QueueThreadPlanForStepOverRange(
-    bool abort_other_plans, const AddressRange &range,
+    Status &status, bool abort_other_plans, const AddressRange &range,
     const SymbolContext &addr_context, lldb::RunMode stop_other_threads,
     LazyBool step_out_avoids_code_withoug_debug_info) {
   ThreadPlanSP thread_plan_sp;
   thread_plan_sp.reset(new ThreadPlanStepOverRange(
       *this, range, addr_context, stop_other_threads,
       step_out_avoids_code_withoug_debug_info));
 
-  QueueThreadPlan(thread_plan_sp, abort_other_plans);
+  status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
   return thread_plan_sp;
 }
 
 // Call the QueueThreadPlanForStepOverRange method which takes an address
 // range.
 ThreadPlanSP Thread::QueueThreadPlanForStepOverRange(
-    bool abort_other_plans, const LineEntry &line_entry,
+    Status &status, bool abort_other_plans, const LineEntry &line_entry,
     const SymbolContext &addr_context, lldb::RunMode stop_other_threads,
     LazyBool step_out_avoids_code_withoug_debug_info) {
   return QueueThreadPlanForStepOverRange(
-      abort_other_plans, line_entry.GetSameLineContiguousAddressRange(),
+      status, abort_other_plans, line_entry.GetSameLineContiguousAddressRange(),
       addr_context, stop_other_threads,
       step_out_avoids_code_withoug_debug_info);
 }
 
 ThreadPlanSP Thread::QueueThreadPlanForStepInRange(
-    bool abort_other_plans, const AddressRange &range,
+    Status &status, bool abort_other_plans, const AddressRange &range,
     const SymbolContext &addr_context, const char *step_in_target,
     lldb::RunMode stop_other_threads,
     LazyBool step_in_avoids_code_without_debug_info,
     LazyBool step_out_avoids_code_without_debug_info) {
   ThreadPlanSP thread_plan_sp(
       new ThreadPlanStepInRange(*this, range, addr_context, stop_other_threads,
                                 step_in_avoids_code_without_debug_info,
                                 step_out_avoids_code_without_debug_info));
   ThreadPlanStepInRange *plan =
       static_cast<ThreadPlanStepInRange *>(thread_plan_sp.get());
 
   if (step_in_target)
     plan->SetStepInTarget(step_in_target);
 
-  QueueThreadPlan(thread_plan_sp, abort_other_plans);
+  status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
   return thread_plan_sp;
 }
 
 // Call the QueueThreadPlanForStepInRange method which takes an address range.
 ThreadPlanSP Thread::QueueThreadPlanForStepInRange(
-    bool abort_other_plans, const LineEntry &line_entry,
+    Status &status, bool abort_other_plans, const LineEntry &line_entry,
     const SymbolContext &addr_context, const char *step_in_target,
     lldb::RunMode stop_other_threads,
     LazyBool step_in_avoids_code_without_debug_info,
     LazyBool step_out_avoids_code_without_debug_info) {
   return QueueThreadPlanForStepInRange(
-      abort_other_plans, line_entry.GetSameLineContiguousAddressRange(),
+      status, abort_other_plans, line_entry.GetSameLineContiguousAddressRange(),
       addr_context, step_in_target, stop_other_threads,
       step_in_avoids_code_without_debug_info,
       step_out_avoids_code_without_debug_info);
 }
 
 ThreadPlanSP Thread::QueueThreadPlanForStepOut(
-    bool abort_other_plans, SymbolContext *addr_context, bool first_insn,
-    bool stop_other_threads, Vote stop_vote, Vote run_vote, uint32_t frame_idx,
-    LazyBool step_out_avoids_code_without_debug_info) {
+    Status &status, bool abort_other_plans, SymbolContext *addr_context,
+    bool first_insn, bool stop_other_threads, Vote stop_vote, Vote run_vote,
+    uint32_t frame_idx, LazyBool step_out_avoids_code_without_debug_info) {
   ThreadPlanSP thread_plan_sp(new ThreadPlanStepOut(
       *this, addr_context, first_insn, stop_other_threads, stop_vote, run_vote,
       frame_idx, step_out_avoids_code_without_debug_info));
 
-  if (thread_plan_sp->ValidatePlan(nullptr)) {
-    QueueThreadPlan(thread_plan_sp, abort_other_plans);
-    return thread_plan_sp;
-  } else {
-    return ThreadPlanSP();
-  }
+  status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
 }
 
 ThreadPlanSP Thread::QueueThreadPlanForStepOutNoShouldStop(
-    bool abort_other_plans, SymbolContext *addr_context, bool first_insn,
-    bool stop_other_threads, Vote stop_vote, Vote run_vote, uint32_t frame_idx,
-    bool continue_to_next_branch) {
+    Status &status, bool abort_other_plans, SymbolContext *addr_context,
+    bool first_insn, bool stop_other_threads, Vote stop_vote, Vote run_vote,
+    uint32_t frame_idx, bool continue_to_next_branch) {
   const bool calculate_return_value =
       false; // No need to calculate the return value here.
   ThreadPlanSP thread_plan_sp(new ThreadPlanStepOut(
       *this, addr_context, first_insn, stop_other_threads, stop_vote, run_vote,
       frame_idx, eLazyBoolNo, continue_to_next_branch, calculate_return_value));
 
   ThreadPlanStepOut *new_plan =
       static_cast<ThreadPlanStepOut *>(thread_plan_sp.get());
   new_plan->ClearShouldStopHereCallbacks();
 
-  if (thread_plan_sp->ValidatePlan(nullptr)) {
-    QueueThreadPlan(thread_plan_sp, abort_other_plans);
-    return thread_plan_sp;
-  } else {
-    return ThreadPlanSP();
-  }
+  status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
 }
 
-ThreadPlanSP Thread::QueueThreadPlanForStepThrough(StackID &return_stack_id,
+ThreadPlanSP Thread::QueueThreadPlanForStepThrough(Status &status,
+                                                   StackID &return_stack_id,
                                                    bool abort_other_plans,
                                                    bool stop_other_threads) {
   ThreadPlanSP thread_plan_sp(
       new ThreadPlanStepThrough(*this, return_stack_id, stop_other_threads));
   if (!thread_plan_sp || !thread_plan_sp->ValidatePlan(nullptr))
     return ThreadPlanSP();
 
-  QueueThreadPlan(thread_plan_sp, abort_other_plans);
+  status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
   return thread_plan_sp;
 }
 
-ThreadPlanSP Thread::QueueThreadPlanForRunToAddress(bool abort_other_plans,
+ThreadPlanSP Thread::QueueThreadPlanForRunToAddress(Status &status,
+                                                    bool abort_other_plans,
                                                     Address &target_addr,
                                                     bool stop_other_threads) {
   ThreadPlanSP thread_plan_sp(
       new ThreadPlanRunToAddress(*this, target_addr, stop_other_threads));
-  QueueThreadPlan(thread_plan_sp, abort_other_plans);
+
+  status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
   return thread_plan_sp;
 }
 
-ThreadPlanSP Thread::QueueThreadPlanForStepUntil(bool abort_other_plans,
-                                                 lldb::addr_t *address_list,
-                                                 size_t num_addresses,
-                                                 bool stop_other_threads,
-                                                 uint32_t frame_idx) {
+ThreadPlanSP Thread::QueueThreadPlanForStepUntil(
+    Status &status, bool abort_other_plans, lldb::addr_t *address_list,
+    size_t num_addresses, bool stop_other_threads, uint32_t frame_idx) {
   ThreadPlanSP thread_plan_sp(new ThreadPlanStepUntil(
       *this, address_list, num_addresses, stop_other_threads, frame_idx));
-  QueueThreadPlan(thread_plan_sp, abort_other_plans);
+
+  status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
   return thread_plan_sp;
 }
 
-lldb::ThreadPlanSP Thread::QueueThreadPlanForStepScripted(
-    bool abort_other_plans, const char *class_name, bool stop_other_threads) {
+lldb::ThreadPlanSP
+Thread::QueueThreadPlanForStepScripted(Status &status, bool abort_other_plans,
+                                       const char *class_name,
+                                       bool stop_other_threads) {
   ThreadPlanSP thread_plan_sp(new ThreadPlanPython(*this, class_name));
-  QueueThreadPlan(thread_plan_sp, abort_other_plans);
-  // This seems a little funny, but I don't want to have to split up the
-  // constructor and the DidPush in the scripted plan, that seems annoying.
-  // That means the constructor has to be in DidPush. So I have to validate the
-  // plan AFTER pushing it, and then take it off again...
-  if (!thread_plan_sp->ValidatePlan(nullptr)) {
-    DiscardThreadPlansUpToPlan(thread_plan_sp);
-    return ThreadPlanSP();
-  } else
-    return thread_plan_sp;
+
+  status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
 }
 
 uint32_t Thread::GetIndexID() const { return m_index_id; }
 
 static void PrintPlanElement(Stream *s, const ThreadPlanSP &plan,
                              lldb::DescriptionLevel desc_level,
                              int32_t elem_idx) {
   s->IndentMore();
if (StateIsStoppedState(process->GetState(), true)) {
     StackFrameSP frame_sp = GetStackFrameAtIndex(0);
     ThreadPlanSP new_plan_sp;
     const lldb::RunMode run_mode = eOnlyThisThread;
     const bool abort_other_plans = false;
 
     if (source_step && frame_sp && frame_sp->HasDebugInformation()) {
       SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything));
       new_plan_sp = QueueThreadPlanForStepInRange(
-          abort_other_plans, sc.line_entry, sc, nullptr, run_mode,
+          error, abort_other_plans, sc.line_entry, sc, nullptr, run_mode,
           step_in_avoids_code_without_debug_info,
           step_out_avoids_code_without_debug_info);
     } else {
       new_plan_sp = QueueThreadPlanForStepSingleInstruction(
-          false, abort_other_plans, run_mode);
+          error, false, abort_other_plans, run_mode);
     }
 
     new_plan_sp->SetIsMasterPlan(true);
     new_plan_sp->SetOkayToDiscard(false);
 
     // Why do we need to set the current thread by ID here???
     process->GetThreadList().SetSelectedThreadByID(GetID());
     error = process->Resume();
if (StateIsStoppedState(process->GetState(), true)) {
     ThreadPlanSP new_plan_sp;
 
     const lldb::RunMode run_mode = eOnlyThisThread;
     const bool abort_other_plans = false;
 
     if (source_step && frame_sp && frame_sp->HasDebugInformation()) {
       SymbolContext sc(frame_sp->GetSymbolContext(eSymbolContextEverything));
       new_plan_sp = QueueThreadPlanForStepOverRange(
-          abort_other_plans, sc.line_entry, sc, run_mode,
+          error, abort_other_plans, sc.line_entry, sc, run_mode,
           step_out_avoids_code_without_debug_info);
     } else {
       new_plan_sp = QueueThreadPlanForStepSingleInstruction(
-          true, abort_other_plans, run_mode);
+          error, true, abort_other_plans, run_mode);
     }
 
     new_plan_sp->SetIsMasterPlan(true);
     new_plan_sp->SetOkayToDiscard(false);
 
     // Why do we need to set the current thread by ID here???
     process->GetThreadList().SetSelectedThreadByID(GetID());
     error = process->Resume();
   } else {
     error.SetErrorString("process not stopped");
   }
   return error;
 }
 
 Status Thread::StepOut() {
   Status error;
   Process *process = GetProcess().get();
   if (StateIsStoppedState(process->GetState(), true)) {
     const bool first_instruction = false;
     const bool stop_other_threads = false;
     const bool abort_other_plans = false;
 
     ThreadPlanSP new_plan_sp(QueueThreadPlanForStepOut(
-        abort_other_plans, nullptr, first_instruction, stop_other_threads,
-        eVoteYes, eVoteNoOpinion, 0));
+        error, abort_other_plans, nullptr, first_instruction,
+        stop_other_threads, eVoteYes, eVoteNoOpinion, 0));
 
     new_plan_sp->SetIsMasterPlan(true);
     new_plan_sp->SetOkayToDiscard(false);
 
     // Why do we need to set the current thread by ID here???
     process->GetThreadList().SetSelectedThreadByID(GetID());
     error = process->Resume();
   } else {
     error.SetErrorString("process not stopped");
   }
   return error;
 }

source/Target/ThreadPlanCallOnFunctionExit.cpp

ThreadPlanCallOnFunctionExit::ThreadPlanCallOnFunctionExit(
   SetIsMasterPlan(false);
 }
 
 void ThreadPlanCallOnFunctionExit::DidPush() {
   // We now want to queue the "step out" thread plan so it executes and
   // completes.
 
   // Set stop vote to eVoteNo.
+  Status status;
   m_step_out_threadplan_sp = GetThread().QueueThreadPlanForStepOut(
+      status,
       false,             // abort other plans
       nullptr,           // addr_context
       true,              // first instruction
       true,              // stop other threads
       eVoteNo,           // do not say "we're stopping"
       eVoteNoOpinion,    // don't care about
                          // run state broadcasting
       0,                 // frame_idx
       eLazyBoolCalculate // avoid code w/o debinfo
-      );
 }
 
 // -------------------------------------------------------------------------
 // ThreadPlan API
 // -------------------------------------------------------------------------
 
 void ThreadPlanCallOnFunctionExit::GetDescription(
     Stream *s, lldb::DescriptionLevel level) {

source/Target/ThreadPlanShouldStopHere.cpp

bool ThreadPlanShouldStopHere::DefaultShouldStopHereCallback(
   return should_stop_here;
 }
 
 ThreadPlanSP ThreadPlanShouldStopHere::DefaultStepFromHereCallback(
     ThreadPlan *current_plan, Flags &flags, FrameComparison operation,
     void *baton) {
   const bool stop_others = false;
   const size_t frame_index = 0;
+  Status return_plan_status;
   ThreadPlanSP return_plan_sp;
   // If we are stepping through code at line number 0, then we need to step
   // over this range.  Otherwise we will step out.
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 
   StackFrame *frame = current_plan->GetThread().GetStackFrameAtIndex(0).get();
   if (!frame)
     return return_plan_sp;
if (sc.symbol && sc.symbol->ValueIsAddress()) {
       }
     }
     if (!just_step_out) {
       if (log)
         log->Printf("ThreadPlanShouldStopHere::DefaultStepFromHereCallback "
                     "Queueing StepInRange plan to step through line 0 code.");
 
       return_plan_sp = current_plan->GetThread().QueueThreadPlanForStepInRange(
-          false, range, sc, NULL, eOnlyDuringStepping, eLazyBoolCalculate,
-          eLazyBoolNo);
+          return_plan_status, false, range, sc, NULL, eOnlyDuringStepping,
+          eLazyBoolCalculate, eLazyBoolNo);
     }
   }
 
   if (!return_plan_sp)
     return_plan_sp =
         current_plan->GetThread().QueueThreadPlanForStepOutNoShouldStop(
-            false, nullptr, true, stop_others, eVoteNo, eVoteNoOpinion,
-            frame_index, true);
+            return_plan_status, false, nullptr, true, stop_others, eVoteNo,
+            eVoteNoOpinion, frame_index, true);
   return return_plan_sp;
 }
 
 ThreadPlanSP ThreadPlanShouldStopHere::QueueStepOutFromHerePlan(
     lldb_private::Flags &flags, lldb::FrameComparison operation) {
   ThreadPlanSP return_plan_sp;
   if (m_callbacks.step_from_here_callback) {
     return_plan_sp =

source/Target/ThreadPlanStepInRange.cpp

bool ThreadPlanStepInRange::ShouldStop(Event *event_ptr) {
 
   if (m_virtual_step) {
     // If we've just completed a virtual step, all we need to do is check for a
     // ShouldStopHere plan, and otherwise we're done.
     // FIXME - This can be both a step in and a step out.  Probably should
     // record which in the m_virtual_step.
     m_sub_plan_sp = CheckShouldStopHereAndQueueStepOut(eFrameCompareYounger);
   } else {
+    Status sub_plan_status;
     // Stepping through should be done running other threads in general, since
     // we're setting a breakpoint and continuing.  So only stop others if we
     // are explicitly told to do so.
 
     bool stop_others = (m_stop_others == lldb::eOnlyThisThread);
 
     FrameComparison frame_order = CompareCurrentFrameToStartFrame();
 
     if (frame_order == eFrameCompareOlder ||
         frame_order == eFrameCompareSameParent) {
       // If we're in an older frame then we should stop.
       //
       // A caveat to this is if we think the frame is older but we're actually
       // in a trampoline.
       // I'm going to make the assumption that you wouldn't RETURN to a
       // trampoline.  So if we are in a trampoline we think the frame is older
       // because the trampoline confused the backtracer.
-      m_sub_plan_sp = m_thread.QueueThreadPlanForStepThrough(m_stack_id, false,
-                                                             stop_others);
+      m_sub_plan_sp = m_thread.QueueThreadPlanForStepThrough(
+          sub_plan_status, m_stack_id, false, stop_others);
       if (!m_sub_plan_sp) {
         // Otherwise check the ShouldStopHere for step out:
         m_sub_plan_sp = CheckShouldStopHereAndQueueStepOut(frame_order);
         if (log) {
           if (m_sub_plan_sp)
             log->Printf("ShouldStopHere found plan to step out of this frame.");
           else
             log->Printf("ShouldStopHere no plan to step out of this frame.");
if (m_virtual_step) {
 
     // If we get to this point, we're not going to use a previously set "next
     // branch" breakpoint, so delete it:
     ClearNextBranchBreakpoint();
 
     // We may have set the plan up above in the FrameIsOlder section:
 
     if (!m_sub_plan_sp)
-      m_sub_plan_sp = m_thread.QueueThreadPlanForStepThrough(m_stack_id, false,
-                                                             stop_others);
+      m_sub_plan_sp = m_thread.QueueThreadPlanForStepThrough(
+          sub_plan_status, m_stack_id, false, stop_others);
 
     if (log) {
       if (m_sub_plan_sp)
         log->Printf("Found a step through plan: %s", m_sub_plan_sp->GetName());
       else
         log->Printf("No step through plan found.");
     }
 
     // If not, give the "should_stop" callback a chance to push a plan to get
     // us out of here. But only do that if we actually have stepped in.
     if (!m_sub_plan_sp && frame_order == eFrameCompareYounger)
       m_sub_plan_sp = CheckShouldStopHereAndQueueStepOut(frame_order);
 
     // If we've stepped in and we are going to stop here, check to see if we
     // were asked to run past the prologue, and if so do that.
 
     if (!m_sub_plan_sp && frame_order == eFrameCompareYounger &&
         m_step_past_prologue) {
       lldb::StackFrameSP curr_frame = m_thread.GetStackFrameAtIndex(0);
       if (curr_frame) {
if (!m_sub_plan_sp && frame_order == eFrameCompareYounger &&
 
         if (bytes_to_skip != 0) {
           func_start_address.Slide(bytes_to_skip);
           log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP);
           if (log)
             log->Printf("Pushing past prologue ");
 
           m_sub_plan_sp = m_thread.QueueThreadPlanForRunToAddress(
-              false, func_start_address, true);
+              sub_plan_status, false, func_start_address, true);
         }
       }
     }
   }
 
   if (!m_sub_plan_sp) {
     m_no_more_plans = true;
     SetPlanComplete();

source/Target/ThreadPlanStepInstruction.cpp

if (cur_frame_zero_id == m_stack_id || m_stack_id < cur_frame_zero_id) {
                                        ->GetArchitecture()
                                        .GetAddressByteSize());
             log->Printf("%s.", s.GetData());
           }
 
           // StepInstruction should probably have the tri-state RunMode, but
           // for now it is safer to run others.
           const bool stop_others = false;
+          Status status;
           m_thread.QueueThreadPlanForStepOutNoShouldStop(
-              false, nullptr, true, stop_others, eVoteNo, eVoteNoOpinion, 0);
+              status, false, nullptr, true, stop_others, eVoteNo,
+              eVoteNoOpinion, 0);
           return false;
         } else {
           if (log) {
             log->PutCString(
                 "The stack id we are stepping in changed, but our parent frame "
                 "did not when stepping from code with no symbols.  "
                 "We are probably just confused about where we are, stopping.");
           }

source/Target/ThreadPlanStepOut.cpp

ThreadPlanStepOut::ThreadPlanStepOut(
     LazyBool step_out_avoids_code_without_debug_info,
     bool continue_to_next_branch, bool gather_return_value)
     : ThreadPlan(ThreadPlan::eKindStepOut, "Step out", thread, stop_vote,
                  run_vote),
       ThreadPlanShouldStopHere(this), m_step_from_insn(LLDB_INVALID_ADDRESS),
       m_return_bp_id(LLDB_INVALID_BREAK_ID),
       m_return_addr(LLDB_INVALID_ADDRESS), m_stop_others(stop_others),
       m_immediate_step_from_function(nullptr),
-      m_calculate_return_value(gather_return_value) {
+      m_calculate_return_value(gather_return_value),
+      m_could_not_resolve_hw_bp(false) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
   SetFlagsToDefault();
   SetupAvoidNoDebug(step_out_avoids_code_without_debug_info);
 
   m_step_from_insn = m_thread.GetRegisterContext()->GetPC(0);
 
   uint32_t return_frame_index = frame_idx + 1;
   StackFrameSP return_frame_sp(
m_return_addr =
         return_address.GetLoadAddress(&m_thread.GetProcess()->GetTarget());
 
     if (m_return_addr == LLDB_INVALID_ADDRESS)
       return;
 
     Breakpoint *return_bp = m_thread.CalculateTarget()
                                 ->CreateBreakpoint(m_return_addr, true, false)
                                 .get();
+
     if (return_bp != nullptr) {
+      if (return_bp->IsHardware() && !return_bp->HasResolvedLocations())
+        m_could_not_resolve_hw_bp = true;
       return_bp->SetThreadID(m_thread.GetID());
       m_return_bp_id = return_bp->GetID();
       return_bp->SetBreakpointKind("step-out");
     }
 
     if (immediate_return_from_sp) {
       const SymbolContext &sc =
           immediate_return_from_sp->GetSymbolContext(eSymbolContextFunction);
void ThreadPlanStepOut::GetDescription(Stream *s,
   }
 }
 
 bool ThreadPlanStepOut::ValidatePlan(Stream *error) {
   if (m_step_out_to_inline_plan_sp)
     return m_step_out_to_inline_plan_sp->ValidatePlan(error);
   else if (m_step_through_inline_plan_sp)
     return m_step_through_inline_plan_sp->ValidatePlan(error);
-  else if (m_return_bp_id == LLDB_INVALID_BREAK_ID) {
+  else if (m_could_not_resolve_hw_bp) {
+    if (error)
+      error->PutCString(
+          "Could not create hardware breakpoint for thread plan.");
+    return false;
+  } else if (m_return_bp_id == LLDB_INVALID_BREAK_ID) {
     if (error)
       error->PutCString("Could not create return address breakpoint.");
     return false;
   } else
     return true;
 }
 
 bool ThreadPlanStepOut::DoPlanExplainsStop(Event *event_ptr) {

source/Target/ThreadPlanStepOverRange.cpp

if (log) {
     log->Printf("ThreadPlanStepOverRange reached %s.", s.GetData());
   }
 
   // If we're out of the range but in the same frame or in our caller's frame
   // then we should stop. When stepping out we only stop others if we are
   // forcing running one thread.
   bool stop_others = (m_stop_others == lldb::eOnlyThisThread);
   ThreadPlanSP new_plan_sp;
+  Status new_plan_status;
   FrameComparison frame_order = CompareCurrentFrameToStartFrame();
 
   if (frame_order == eFrameCompareOlder) {
     // If we're in an older frame then we should stop.
     //
     // A caveat to this is if we think the frame is older but we're actually in
     // a trampoline.
     // I'm going to make the assumption that you wouldn't RETURN to a
     // trampoline.  So if we are in a trampoline we think the frame is older
     // because the trampoline confused the backtracer. As below, we step
     // through first, and then try to figure out how to get back out again.
 
-    new_plan_sp =
-        m_thread.QueueThreadPlanForStepThrough(m_stack_id, false, stop_others);
+    new_plan_sp = m_thread.QueueThreadPlanForStepThrough(
+        new_plan_status, m_stack_id, false, stop_others);
 
     if (new_plan_sp && log)
       log->Printf(
           "Thought I stepped out, but in fact arrived at a trampoline.");
   } else if (frame_order == eFrameCompareYounger) {
     // Make sure we really are in a new frame.  Do that by unwinding and seeing
     // if the start function really is our start function...
     for (uint32_t i = 1;; ++i) {
       StackFrameSP older_frame_sp = m_thread.GetStackFrameAtIndex(i);
       if (!older_frame_sp) {
         // We can't unwind the next frame we should just get out of here &
         // stop...
         break;
       }
 
       const SymbolContext &older_context =
           older_frame_sp->GetSymbolContext(eSymbolContextEverything);
       if (IsEquivalentContext(older_context)) {
         new_plan_sp = m_thread.QueueThreadPlanForStepOutNoShouldStop(
-            false, nullptr, true, stop_others, eVoteNo, eVoteNoOpinion, 0,
-            true);
+            new_plan_status, false, nullptr, true, stop_others, eVoteNo,
+            eVoteNoOpinion, 0, true);
         break;
       } else {
-        new_plan_sp = m_thread.QueueThreadPlanForStepThrough(m_stack_id, false,
-                                                             stop_others);
+        new_plan_sp = m_thread.QueueThreadPlanForStepThrough(
+            new_plan_status, m_stack_id, false, stop_others);
         // If we found a way through, then we should stop recursing.
         if (new_plan_sp)
           break;
       }
     }
   } else {
     // If we're still in the range, keep going.
     if (InRange()) {
       SetNextBranchBreakpoint();
       return false;
     }
 
     if (!InSymbol()) {
       // This one is a little tricky.  Sometimes we may be in a stub or
       // something similar, in which case we need to get out of there.  But if
       // we are in a stub then it's likely going to be hard to get out from
       // here.  It is probably easiest to step into the stub, and then it will
       // be straight-forward to step out.
-      new_plan_sp = m_thread.QueueThreadPlanForStepThrough(m_stack_id, false,
-                                                           stop_others);
+      new_plan_sp = m_thread.QueueThreadPlanForStepThrough(
+          new_plan_status, m_stack_id, false, stop_others);
     } else {
       // The current clang (at least through 424) doesn't always get the
       // address range for the DW_TAG_inlined_subroutines right, so that when
       // you leave the inlined range the line table says you are still in the
       // source file of the inlining function.  This is bad, because now you
       // are missing the stack frame for the function containing the inlining,
       // and if you sensibly do "finish" to get out of this function you will
       // instead exit the containing function. To work around this, we check
if (!InSymbol()) {
                                                 ->GetRegisterContext()
                                                 ->GetPC();
                       AddressRange step_range(
                           cur_pc,
                           next_line_address.GetLoadAddress(&GetTarget()) -
                               cur_pc);
 
                       new_plan_sp = m_thread.QueueThreadPlanForStepOverRange(
-                          abort_other_plans, step_range, sc,
+                          new_plan_status, abort_other_plans, step_range, sc,
                           stop_other_threads);
                       break;
                     }
                     look_ahead_step++;
                   }
                 }
               }
             }
else {
     // Any new plan will be an implementation plan, so mark it private:
     new_plan_sp->SetPrivate(true);
     m_no_more_plans = false;
   }
 
   if (!new_plan_sp) {
     // For efficiencies sake, we know we're done here so we don't have to do
     // this calculation again in MischiefManaged.
-    SetPlanComplete();
+    SetPlanComplete(new_plan_status.Success());
     return true;
   } else
     return false;
 }
 
 bool ThreadPlanStepOverRange::DoPlanExplainsStop(Event *event_ptr) {
   // For crashes, breakpoint hits, signals, etc, let the base plan (or some
   // plan above us) handle the stop.  That way the user can see the stop, step

source/Target/ThreadPlanStepRange.cpp

ThreadPlanStepRange::ThreadPlanStepRange(ThreadPlanKind kind, const char *name,
                                          const AddressRange &range,
                                          const SymbolContext &addr_context,
                                          lldb::RunMode stop_others,
                                          bool given_ranges_only)
     : ThreadPlan(kind, name, thread, eVoteNoOpinion, eVoteNoOpinion),
       m_addr_context(addr_context), m_address_ranges(),
       m_stop_others(stop_others), m_stack_id(), m_parent_stack_id(),
       m_no_more_plans(false), m_first_run_event(true), m_use_fast_step(false),
-      m_given_ranges_only(given_ranges_only) {
+      m_given_ranges_only(given_ranges_only), m_could_not_resolve_hw_bp(false) {
   m_use_fast_step = GetTarget().GetUseFastStepping();
   AddRange(range);
   m_stack_id = m_thread.GetStackFrameAtIndex(0)->GetStackID();
   StackFrameSP parent_stack = m_thread.GetStackFrameAtIndex(1);
   if (parent_stack)
     m_parent_stack_id = parent_stack->GetStackID();
 }
 
 ThreadPlanStepRange::~ThreadPlanStepRange() { ClearNextBranchBreakpoint(); }
 
 void ThreadPlanStepRange::DidPush() {
   // See if we can find a "next range" breakpoint:
   SetNextBranchBreakpoint();
 }
 
-bool ThreadPlanStepRange::ValidatePlan(Stream *error) { return true; }
+bool ThreadPlanStepRange::ValidatePlan(Stream *error) {
+  if (m_could_not_resolve_hw_bp) {
+    if (error)
+      error->PutCString(
+          "Could not create hardware breakpoint for thread plan.");
+    return false;
+  }
+  return true;
+}
 
 Vote ThreadPlanStepRange::ShouldReportStop(Event *event_ptr) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 
   const Vote vote = IsPlanComplete() ? eVoteYes : eVoteNo;
   if (log)
     log->Printf("ThreadPlanStepRange::ShouldReportStop() returning vote %i\n",
                 vote);

 void ThreadPlanStepRange::ClearNextBranchBreakpoint() {
   if (m_next_branch_bp_sp) {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
     if (log)
       log->Printf("Removing next branch breakpoint: %d.",
                   m_next_branch_bp_sp->GetID());
     GetTarget().RemoveBreakpointByID(m_next_branch_bp_sp->GetID());
     m_next_branch_bp_sp.reset();
+    m_could_not_resolve_hw_bp = false;
   }
 }
 
 bool ThreadPlanStepRange::SetNextBranchBreakpoint() {
   if (m_next_branch_bp_sp)
     return true;
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
if (branch_index == UINT32_MAX) {
           instructions->GetInstructionAtIndex(branch_index)->GetAddress();
     }
 
     if (run_to_address.IsValid()) {
       const bool is_internal = true;
       m_next_branch_bp_sp =
           GetTarget().CreateBreakpoint(run_to_address, is_internal, false);
       if (m_next_branch_bp_sp) {
+
+        if (m_next_branch_bp_sp->IsHardware() &&
+            !m_next_branch_bp_sp->HasResolvedLocations())
+          m_could_not_resolve_hw_bp = true;
+
         if (log) {
           lldb::break_id_t bp_site_id = LLDB_INVALID_BREAK_ID;
           BreakpointLocationSP bp_loc =
               m_next_branch_bp_sp->GetLocationAtIndex(0);
           if (bp_loc) {
             BreakpointSiteSP bp_site = bp_loc->GetBreakpointSite();
             if (bp_site) {
               bp_site_id = bp_site->GetID();
             }
           }
           log->Printf("ThreadPlanStepRange::SetNextBranchBreakpoint - Setting "
                       "breakpoint %d (site %d) to run to address 0x%" PRIx64,
                       m_next_branch_bp_sp->GetID(), bp_site_id,
                       run_to_address.GetLoadAddress(
                           &m_thread.GetProcess()->GetTarget()));
         }
+
         m_next_branch_bp_sp->SetThreadID(m_thread.GetID());
         m_next_branch_bp_sp->SetBreakpointKind("next-branch-location");
+
         return true;
       } else
         return false;
     }
   }
   return false;
 }
 

source/Target/ThreadPlanStepThrough.cpp

 ThreadPlanStepThrough::ThreadPlanStepThrough(Thread &thread,
                                              StackID &m_stack_id,
                                              bool stop_others)
     : ThreadPlan(ThreadPlan::eKindStepThrough,
                  "Step through trampolines and prologues", thread,
                  eVoteNoOpinion, eVoteNoOpinion),
       m_start_address(0), m_backstop_bkpt_id(LLDB_INVALID_BREAK_ID),
       m_backstop_addr(LLDB_INVALID_ADDRESS), m_return_stack_id(m_stack_id),
-      m_stop_others(stop_others) {
+      m_stop_others(stop_others), m_could_not_resolve_hw_bp(false) {
   LookForPlanToStepThroughFromCurrentPC();
 
   // If we don't get a valid step through plan, don't bother to set up a
   // backstop.
   if (m_sub_plan_sp) {
     m_start_address = GetThread().GetRegisterContext()->GetPC(0);
 
     // We are going to return back to the concrete frame 1, we might pass by
     // some inlined code that we're in the middle of by doing this, but it's
     // easier than trying to figure out where the inlined code might return to.
 
     StackFrameSP return_frame_sp = m_thread.GetFrameWithStackID(m_stack_id);
 
     if (return_frame_sp) {
       m_backstop_addr = return_frame_sp->GetFrameCodeAddress().GetLoadAddress(
           m_thread.CalculateTarget().get());
       Breakpoint *return_bp =
           m_thread.GetProcess()
               ->GetTarget()
               .CreateBreakpoint(m_backstop_addr, true, false)
               .get();
+
       if (return_bp != nullptr) {
+        if (return_bp->IsHardware() && !return_bp->HasResolvedLocations())
+          m_could_not_resolve_hw_bp = true;
         return_bp->SetThreadID(m_thread.GetID());
         m_backstop_bkpt_id = return_bp->GetID();
         return_bp->SetBreakpointKind("step-through-backstop");
       }
       Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
       if (log) {
         log->Printf("Setting backstop breakpoint %d at address: 0x%" PRIx64,
                     m_backstop_bkpt_id, m_backstop_addr);
if (m_backstop_bkpt_id != LLDB_INVALID_BREAK_ID) {
                 m_backstop_bkpt_id);
       s->Address(m_backstop_addr, sizeof(addr_t));
     } else
       s->PutCString(" unable to set a backstop breakpoint.");
   }
 }
 
 bool ThreadPlanStepThrough::ValidatePlan(Stream *error) {
+  if (m_could_not_resolve_hw_bp) {
+    if (error)
+      error->PutCString(
+          "Could not create hardware breakpoint for thread plan.");
+    return false;
+  } else if (m_backstop_bkpt_id == LLDB_INVALID_BREAK_ID) {
+    if (error)
+      error->PutCString("Could not create backstop breakpoint.");
+    return false;
+  }
   return m_sub_plan_sp.get() != nullptr;
 }
 
 bool ThreadPlanStepThrough::DoPlanExplainsStop(Event *event_ptr) {
   // If we have a sub-plan, it will have been asked first if we explain the
   // stop, and we won't get asked.  The only time we would be the one directly
   // asked this question is if we hit our backstop breakpoint.
 

 }
 
 bool ThreadPlanStepThrough::WillStop() { return true; }
 
 void ThreadPlanStepThrough::ClearBackstopBreakpoint() {
   if (m_backstop_bkpt_id != LLDB_INVALID_BREAK_ID) {
     m_thread.GetProcess()->GetTarget().RemoveBreakpointByID(m_backstop_bkpt_id);
     m_backstop_bkpt_id = LLDB_INVALID_BREAK_ID;
+    m_could_not_resolve_hw_bp = false;
   }
 }
 
 bool ThreadPlanStepThrough::MischiefManaged() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
 
   if (!IsPlanComplete()) {
     return false;

source/Target/ThreadPlanStepUntil.cpp

ThreadPlanStepUntil::ThreadPlanStepUntil(Thread &thread,
                                          size_t num_addresses, bool stop_others,
                                          uint32_t frame_idx)
     : ThreadPlan(ThreadPlan::eKindStepUntil, "Step until", thread,
                  eVoteNoOpinion, eVoteNoOpinion),
       m_step_from_insn(LLDB_INVALID_ADDRESS),
       m_return_bp_id(LLDB_INVALID_BREAK_ID),
       m_return_addr(LLDB_INVALID_ADDRESS), m_stepped_out(false),
       m_should_stop(false), m_ran_analyze(false), m_explains_stop(false),
-      m_until_points(), m_stop_others(stop_others) {
+      m_until_points(), m_stop_others(stop_others),
+      m_could_not_resolve_hw_bp(false) {
   // Stash away our "until" addresses:
   TargetSP target_sp(m_thread.CalculateTarget());
 
   StackFrameSP frame_sp(m_thread.GetStackFrameAtIndex(frame_idx));
   if (frame_sp) {
     m_step_from_insn = frame_sp->GetStackID().GetPC();
     lldb::user_id_t thread_id = m_thread.GetID();
 
     // Find the return address and set a breakpoint there:
     // FIXME - can we do this more securely if we know first_insn?
 
     StackFrameSP return_frame_sp(m_thread.GetStackFrameAtIndex(frame_idx + 1));
     if (return_frame_sp) {
       // TODO: add inline functionality
       m_return_addr = return_frame_sp->GetStackID().GetPC();
       Breakpoint *return_bp =
           target_sp->CreateBreakpoint(m_return_addr, true, false).get();
+
       if (return_bp != nullptr) {
+        if (return_bp->IsHardware() && !return_bp->HasResolvedLocations())
+          m_could_not_resolve_hw_bp = true;
         return_bp->SetThreadID(thread_id);
         m_return_bp_id = return_bp->GetID();
         return_bp->SetBreakpointKind("until-return-backstop");
       }
     }
 
     m_stack_id = frame_sp->GetStackID();
 
if (target_sp) {
     }
 
     until_collection::iterator pos, end = m_until_points.end();
     for (pos = m_until_points.begin(); pos != end; pos++) {
       target_sp->RemoveBreakpointByID((*pos).second);
     }
   }
   m_until_points.clear();
+  m_could_not_resolve_hw_bp = false;
 }
 
 void ThreadPlanStepUntil::GetDescription(Stream *s,
                                          lldb::DescriptionLevel level) {
   if (level == lldb::eDescriptionLevelBrief) {
     s->Printf("step until");
     if (m_stepped_out)
       s->Printf(" - stepped out");
else {
       }
     }
     s->Printf(" stepped out address is 0x%" PRIx64 ".",
               (uint64_t)m_return_addr);
   }
 }
 
 bool ThreadPlanStepUntil::ValidatePlan(Stream *error) {
-  if (m_return_bp_id == LLDB_INVALID_BREAK_ID)
+  if (m_could_not_resolve_hw_bp) {
+    if (error)
+      error->PutCString(
+          "Could not create hardware breakpoint for thread plan.");
     return false;
-  else {
+  } else if (m_return_bp_id == LLDB_INVALID_BREAK_ID) {
+    if (error)
+      error->PutCString("Could not create return breakpoint.");
+    return false;
+  } else {
     until_collection::iterator pos, end = m_until_points.end();
     for (pos = m_until_points.begin(); pos != end; pos++) {
       if (!LLDB_BREAK_ID_IS_VALID((*pos).second))
         return false;
     }
     return true;
   }
 }