[lldb] Make BreakpointResolver hold weak_ptr instead of raw pointer to breakpoint

[tatyana-krasnukha]

Summary

This prevents calling Breakpoint::shared_from_this of an object that is not owned by any shared_ptr.

The patch is a consequence of D74556

[jingham]

I wonder if it wouldn't be better to assert in GetBreakpoint. Except when you are making the resolver, you should never have a breakpoint resolver without a valid breakpoint. And there's no point in calling GetBreakpoint when you know you haven't set it yet. You assert after most of the calls to GetBreakpoint, but not all. Of the ones you don't, I think most of them should be.

Were there any places you found where it was legit to ask for the Breakpoint for a resolver and not have one?

Other than that LGTM.

[tatyana-krasnukha]

Moved assertion into GetBreakpoint().

Were there any places you found where it was legit to ask for the Breakpoint for a resolver and not have one?

I didn't find any, however, it seems to be possible in theory as BreakpointResolver is allowed to be constructed with nullptr instead of breakpoint (it is expected to call SetBreakpoint later).

[tatyana-krasnukha]

Just realized that BreakpointResolverScripted::CreateImplementationIfNeeded should work when m_breakpoint == nullptr.
GetBreakpoint with assertion is not suitable here, so I pass the breakpoint as a parameter.

[tatyana-krasnukha]

@jingham Is it Ok with you?

[jingham]

You mean for BreakpointResolverScripted::CreateImplementationIfNeeded? Passing in the BreakpointSP is fine.

lldb/include/lldb/Breakpoint/BreakpointResolver.h

public:
   /// The breakpoint resolver need to have a breakpoint for "ResolveBreakpoint
   /// to make sense.  It can be constructed without a breakpoint, but you have
   /// to call SetBreakpoint before ResolveBreakpoint.
   ///
   /// \param[in] bkpt
   ///   The breakpoint that owns this resolver.
   /// \param[in] resolverType
   ///   The concrete breakpoint resolver type for this breakpoint.
-  BreakpointResolver(Breakpoint *bkpt, unsigned char resolverType,
+  BreakpointResolver(const lldb::BreakpointSP &bkpt,
+                     unsigned char resolverType,
                      lldb::addr_t offset = 0);
 
   /// The Destructor is virtual, all significant breakpoint resolvers derive
   /// from this class.
   ~BreakpointResolver() override;
 
   /// This sets the breakpoint for this resolver.
   ///
   /// \param[in] bkpt
   ///   The breakpoint that owns this resolver.
-  void SetBreakpoint(Breakpoint *bkpt);
+  void SetBreakpoint(const lldb::BreakpointSP &bkpt);
+
+  /// This gets the breakpoint for this resolver.
+  lldb::BreakpointSP GetBreakpoint() const {
+    auto breakpoint_sp = m_breakpoint.expired() ? lldb::BreakpointSP() :
+                                                  m_breakpoint.lock();
+    assert(breakpoint_sp);
+    return breakpoint_sp;
+  }
 
   /// This updates the offset for this breakpoint.  All the locations
   /// currently set for this breakpoint will have their offset adjusted when
   /// this is called.
   ///
   /// \param[in] offset
   ///   The offset to add to all locations.
   void SetOffset(lldb::addr_t offset);
 
-  /// This updates the offset for this breakpoint.  All the locations
-  /// currently set for this breakpoint will have their offset adjusted when
-  /// this is called.
-  ///
-  /// \param[in] offset
-  ///   The offset to add to all locations.
+  /// This gets the offset for this breakpoint.
   lldb::addr_t GetOffset() const { return m_offset; }
 
   /// In response to this method the resolver scans all the modules in the
   /// breakpoint's target, and adds any new locations it finds.
   ///
   /// \param[in] filter
   ///   The filter that will manage the search for this resolver.
   virtual void ResolveBreakpoint(SearchFilter &filter);
public:
 
   const char *GetResolverName() { return ResolverTyToName(GetResolverTy()); }
 
   static const char *ResolverTyToName(enum ResolverTy);
 
   static ResolverTy NameToResolverTy(llvm::StringRef name);
 
   virtual lldb::BreakpointResolverSP
-  CopyForBreakpoint(Breakpoint &breakpoint) = 0;
+  CopyForBreakpoint(lldb::BreakpointSP &breakpoint) = 0;
 
 protected:
   // Used for serializing resolver options:
   // The options in this enum and the strings in the g_option_names must be
   // kept in sync.
   enum class OptionNames : uint32_t {
     AddressOffset = 0,
     ExactMatch,
void SetSCMatchesByLine(SearchFilter &filter, SymbolContextList &sc_list,
                           bool skip_prologue, llvm::StringRef log_ident,
                           uint32_t line = 0, uint32_t column = 0);
   void SetSCMatchesByLine(SearchFilter &, SymbolContextList &, bool,
                           const char *) = delete;
 
   lldb::BreakpointLocationSP AddLocation(Address loc_addr,
                                          bool *new_location = nullptr);
 
-  Breakpoint *m_breakpoint; // This is the breakpoint we add locations to.
-  lldb::addr_t m_offset;    // A random offset the user asked us to add to any
-                            // breakpoints we set.
-
 private:
   /// Helper for \p SetSCMatchesByLine.
   void AddLocation(SearchFilter &filter, const SymbolContext &sc,
                    bool skip_prologue, llvm::StringRef log_ident);
 
+  lldb::BreakpointWP m_breakpoint; // This is the breakpoint we add locations to.
+  lldb::addr_t m_offset;    // A random offset the user asked us to add to any
+                            // breakpoints we set.
+
   // Subclass identifier (for llvm isa/dyn_cast)
   const unsigned char SubclassID;
   DISALLOW_COPY_AND_ASSIGN(BreakpointResolver);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_BreakpointResolver_h_

lldb/include/lldb/Breakpoint/BreakpointResolverAddress.h

 
 /// \class BreakpointResolverAddress BreakpointResolverAddress.h
 /// "lldb/Breakpoint/BreakpointResolverAddress.h" This class sets breakpoints
 /// on a given Address.  This breakpoint only takes once, and then it won't
 /// attempt to reset itself.
 
 class BreakpointResolverAddress : public BreakpointResolver {
 public:
-  BreakpointResolverAddress(Breakpoint *bkpt, const Address &addr);
+  BreakpointResolverAddress(const lldb::BreakpointSP &bkpt,
+                            const Address &addr);
 
-  BreakpointResolverAddress(Breakpoint *bkpt, const Address &addr,
+  BreakpointResolverAddress(const lldb::BreakpointSP &bkpt,
+                            const Address &addr,
                             const FileSpec &module_spec);
 
-  ~BreakpointResolverAddress() override;
+  ~BreakpointResolverAddress() override = default;
 
   static BreakpointResolver *
-  CreateFromStructuredData(Breakpoint *bkpt,
+  CreateFromStructuredData(const lldb::BreakpointSP &bkpt,
                            const StructuredData::Dictionary &options_dict,
                            Status &error);
 
   StructuredData::ObjectSP SerializeToStructuredData() override;
 
   void ResolveBreakpoint(SearchFilter &filter) override;
 
   void ResolveBreakpointInModules(SearchFilter &filter,
public:
   void Dump(Stream *s) const override;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const BreakpointResolverAddress *) { return true; }
   static inline bool classof(const BreakpointResolver *V) {
     return V->getResolverID() == BreakpointResolver::AddressResolver;
   }
 
-  lldb::BreakpointResolverSP CopyForBreakpoint(Breakpoint &breakpoint) override;
+  lldb::BreakpointResolverSP
+  CopyForBreakpoint(lldb::BreakpointSP &breakpoint) override;
 
 protected:
-  Address
-      m_addr; // The address - may be Section Offset or may be just an offset
+  Address m_addr;               // The address - may be Section Offset or
+                                // may be just an offset
   lldb::addr_t m_resolved_addr; // The current value of the resolved load
                                 // address for this breakpoint,
   FileSpec m_module_filespec;   // If this filespec is Valid, and m_addr is an
                                 // offset, then it will be converted
   // to a Section+Offset address in this module, whenever that module gets
   // around to being loaded.
 private:
   DISALLOW_COPY_AND_ASSIGN(BreakpointResolverAddress);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_BreakpointResolverAddress_h_

lldb/include/lldb/Breakpoint/BreakpointResolverFileLine.h

 
 /// \class BreakpointResolverFileLine BreakpointResolverFileLine.h
 /// "lldb/Breakpoint/BreakpointResolverFileLine.h" This class sets breakpoints
 /// by file and line.  Optionally, it will look for inlined instances of the
 /// file and line specification.
 
 class BreakpointResolverFileLine : public BreakpointResolver {
 public:
-  BreakpointResolverFileLine(Breakpoint *bkpt, const FileSpec &resolver,
+  BreakpointResolverFileLine(const lldb::BreakpointSP &bkpt,
+                             const FileSpec &resolver,
                              uint32_t line_no, uint32_t column,
                              lldb::addr_t m_offset, bool check_inlines,
                              bool skip_prologue, bool exact_match);
 
   static BreakpointResolver *
-  CreateFromStructuredData(Breakpoint *bkpt,
+  CreateFromStructuredData(const lldb::BreakpointSP &bkpt,
                            const StructuredData::Dictionary &data_dict,
                            Status &error);
 
   StructuredData::ObjectSP SerializeToStructuredData() override;
 
-  ~BreakpointResolverFileLine() override;
+  ~BreakpointResolverFileLine() override = default;
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                           SymbolContext &context,
                                           Address *addr) override;
 
   lldb::SearchDepth GetDepth() override;
 
   void GetDescription(Stream *s) override;
 
   void Dump(Stream *s) const override;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const BreakpointResolverFileLine *) {
     return true;
   }
   static inline bool classof(const BreakpointResolver *V) {
     return V->getResolverID() == BreakpointResolver::FileLineResolver;
   }
 
-  lldb::BreakpointResolverSP CopyForBreakpoint(Breakpoint &breakpoint) override;
+  lldb::BreakpointResolverSP
+  CopyForBreakpoint(lldb::BreakpointSP &breakpoint) override;
 
 protected:
   void FilterContexts(SymbolContextList &sc_list, bool is_relative);
 
   friend class Breakpoint;
   FileSpec m_file_spec;   ///< This is the file spec we are looking for.
   uint32_t m_line_number; ///< This is the line number that we are looking for.
   uint32_t m_column;      ///< This is the column that we are looking for.

lldb/include/lldb/Breakpoint/BreakpointResolverFileRegex.h

 /// \class BreakpointResolverFileRegex BreakpointResolverFileRegex.h
 /// "lldb/Breakpoint/BreakpointResolverFileRegex.h" This class sets
 /// breakpoints by file and line.  Optionally, it will look for inlined
 /// instances of the file and line specification.
 
 class BreakpointResolverFileRegex : public BreakpointResolver {
 public:
   BreakpointResolverFileRegex(
-      Breakpoint *bkpt, RegularExpression regex,
+      const lldb::BreakpointSP &bkpt, RegularExpression regex,
       const std::unordered_set<std::string> &func_name_set, bool exact_match);
 
   static BreakpointResolver *
-  CreateFromStructuredData(Breakpoint *bkpt,
+  CreateFromStructuredData(const lldb::BreakpointSP &bkpt,
                            const StructuredData::Dictionary &options_dict,
                            Status &error);
 
   StructuredData::ObjectSP SerializeToStructuredData() override;
 
-  ~BreakpointResolverFileRegex() override;
+  ~BreakpointResolverFileRegex() override = default;
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                           SymbolContext &context,
                                           Address *addr) override;
 
   lldb::SearchDepth GetDepth() override;
 
   void GetDescription(Stream *s) override;
 
   void Dump(Stream *s) const override;
 
   void AddFunctionName(const char *func_name);
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const BreakpointResolverFileRegex *) {
     return true;
   }
   static inline bool classof(const BreakpointResolver *V) {
     return V->getResolverID() == BreakpointResolver::FileRegexResolver;
   }
 
-  lldb::BreakpointResolverSP CopyForBreakpoint(Breakpoint &breakpoint) override;
+  lldb::BreakpointResolverSP
+  CopyForBreakpoint(lldb::BreakpointSP &breakpoint) override;
 
 protected:
   friend class Breakpoint;
   RegularExpression
       m_regex;        // This is the line expression that we are looking for.
   bool m_exact_match; // If true, then if the source we match is in a comment,
                       // we won't set a location there.
   std::unordered_set<std::string> m_function_names; // Limit the search to

lldb/include/lldb/Breakpoint/BreakpointResolverName.h

 namespace lldb_private {
 
 /// \class BreakpointResolverName BreakpointResolverName.h
 /// "lldb/Breakpoint/BreakpointResolverName.h" This class sets breakpoints on
 /// a given function name, either by exact match or by regular expression.
 
 class BreakpointResolverName : public BreakpointResolver {
 public:
-  BreakpointResolverName(Breakpoint *bkpt, const char *name,
+  BreakpointResolverName(const lldb::BreakpointSP &bkpt, const char *name,
                          lldb::FunctionNameType name_type_mask,
                          lldb::LanguageType language,
                          Breakpoint::MatchType type, lldb::addr_t offset,
                          bool skip_prologue);
 
   // This one takes an array of names.  It is always MatchType = Exact.
-  BreakpointResolverName(Breakpoint *bkpt, const char *names[],
+  BreakpointResolverName(const lldb::BreakpointSP &bkpt, const char *names[],
                          size_t num_names,
                          lldb::FunctionNameType name_type_mask,
                          lldb::LanguageType language, lldb::addr_t offset,
                          bool skip_prologue);
 
   // This one takes a C++ array of names.  It is always MatchType = Exact.
-  BreakpointResolverName(Breakpoint *bkpt, std::vector<std::string> names,
+  BreakpointResolverName(const lldb::BreakpointSP &bkpt,
+                         std::vector<std::string> names,
                          lldb::FunctionNameType name_type_mask,
                          lldb::LanguageType language, lldb::addr_t offset,
                          bool skip_prologue);
 
   // Creates a function breakpoint by regular expression.  Takes over control
   // of the lifespan of func_regex.
-  BreakpointResolverName(Breakpoint *bkpt, RegularExpression func_regex,
+  BreakpointResolverName(const lldb::BreakpointSP &bkpt,
+                         RegularExpression func_regex,
                          lldb::LanguageType language, lldb::addr_t offset,
                          bool skip_prologue);
 
   static BreakpointResolver *
-  CreateFromStructuredData(Breakpoint *bkpt,
+  CreateFromStructuredData(const lldb::BreakpointSP &bkpt,
                            const StructuredData::Dictionary &data_dict,
                            Status &error);
 
   StructuredData::ObjectSP SerializeToStructuredData() override;
 
-  ~BreakpointResolverName() override;
+  ~BreakpointResolverName() override = default;
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                           SymbolContext &context,
                                           Address *addr) override;
 
   lldb::SearchDepth GetDepth() override;
 
   void GetDescription(Stream *s) override;
 
   void Dump(Stream *s) const override;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const BreakpointResolverName *) { return true; }
   static inline bool classof(const BreakpointResolver *V) {
     return V->getResolverID() == BreakpointResolver::NameResolver;
   }
 
-  lldb::BreakpointResolverSP CopyForBreakpoint(Breakpoint &breakpoint) override;
+  lldb::BreakpointResolverSP
+  CopyForBreakpoint(lldb::BreakpointSP &breakpoint) override;
 
 protected:
   BreakpointResolverName(const BreakpointResolverName &rhs);
 
   std::vector<Module::LookupInfo> m_lookups;
   ConstString m_class_name;
   RegularExpression m_regex;
   Breakpoint::MatchType m_match_type;

lldb/include/lldb/Breakpoint/BreakpointResolverScripted.h

 
 /// \class BreakpointResolverScripted BreakpointResolverScripted.h
 /// "lldb/Breakpoint/BreakpointResolverScripted.h" This class sets breakpoints
 /// on a given Address.  This breakpoint only takes once, and then it won't
 /// attempt to reset itself.
 
 class BreakpointResolverScripted : public BreakpointResolver {
 public:
-  BreakpointResolverScripted(Breakpoint *bkpt,
+  BreakpointResolverScripted(const lldb::BreakpointSP &bkpt,
                              const llvm::StringRef class_name,
                              lldb::SearchDepth depth,
                              StructuredDataImpl *args_data);
 
-  ~BreakpointResolverScripted() override;
+  ~BreakpointResolverScripted() override = default;
 
   static BreakpointResolver *
-  CreateFromStructuredData(Breakpoint *bkpt,
+  CreateFromStructuredData(const lldb::BreakpointSP &bkpt,
                            const StructuredData::Dictionary &options_dict,
                            Status &error);
 
   StructuredData::ObjectSP SerializeToStructuredData() override;
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                           SymbolContext &context,
                                           Address *addr) override;
 
   lldb::SearchDepth GetDepth() override;
 
   void GetDescription(Stream *s) override;
 
   void Dump(Stream *s) const override;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const BreakpointResolverScripted *) { return true; }
   static inline bool classof(const BreakpointResolver *V) {
     return V->getResolverID() == BreakpointResolver::PythonResolver;
   }
 
-  lldb::BreakpointResolverSP CopyForBreakpoint(Breakpoint &breakpoint) override;
+  lldb::BreakpointResolverSP
+  CopyForBreakpoint(lldb::BreakpointSP &breakpoint) override;
 
 protected:
   void NotifyBreakpointSet() override;
 private:
   void CreateImplementationIfNeeded();
   ScriptInterpreter *GetScriptInterpreter();
   
   std::string m_class_name;

lldb/include/lldb/Target/LanguageRuntime.h

public:
 
   Process *GetProcess() { return m_process; }
 
   Target &GetTargetRef() { return m_process->GetTarget(); }
 
   virtual DeclVendor *GetDeclVendor() { return nullptr; }
 
   virtual lldb::BreakpointResolverSP
-  CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp, bool throw_bp) = 0;
+  CreateExceptionResolver(const lldb::BreakpointSP &bkpt,
+                          bool catch_bp, bool throw_bp) = 0;
 
   virtual lldb::SearchFilterSP CreateExceptionSearchFilter() {
     return m_process->GetTarget().GetSearchFilterForModule(nullptr);
   }
 
   virtual bool GetTypeBitSize(const CompilerType &compiler_type,
                               uint64_t &size) {
     return false;

lldb/source/Breakpoint/Breakpoint.cpp

 
 // Destructor
 Breakpoint::~Breakpoint() = default;
 
 BreakpointSP Breakpoint::CopyFromBreakpoint(Target& new_target,
     const Breakpoint& bp_to_copy_from) {
   BreakpointSP bp(new Breakpoint(new_target, bp_to_copy_from));
   // Now go through and copy the filter & resolver:
-  bp->m_resolver_sp = bp_to_copy_from.m_resolver_sp->CopyForBreakpoint(*bp);
+  bp->m_resolver_sp = bp_to_copy_from.m_resolver_sp->CopyForBreakpoint(bp);
   bp->m_filter_sp = bp_to_copy_from.m_filter_sp->CopyForBreakpoint(*bp);
   return bp;
 }
 
 // Serialization
 StructuredData::ObjectSP Breakpoint::SerializeToStructuredData() {
   // Serialize the resolver:
   StructuredData::DictionarySP breakpoint_dict_sp(

lldb/source/Breakpoint/BreakpointResolver.cpp

 BreakpointResolver::NameToResolverTy(llvm::StringRef name) {
   for (size_t i = 0; i < LastKnownResolverType; i++) {
     if (name == g_ty_to_name[i])
       return (ResolverTy)i;
   }
   return UnknownResolver;
 }
 
-BreakpointResolver::BreakpointResolver(Breakpoint *bkpt,
+BreakpointResolver::BreakpointResolver(const BreakpointSP &bkpt,
                                        const unsigned char resolverTy,
                                        lldb::addr_t offset)
     : m_breakpoint(bkpt), m_offset(offset), SubclassID(resolverTy) {}
 
 BreakpointResolver::~BreakpointResolver() {}
 
 BreakpointResolverSP BreakpointResolver::CreateFromStructuredData(
     const StructuredData::Dictionary &resolver_dict, Status &error) {
StructuredData::DictionarySP BreakpointResolver::WrapOptionsDict(
   type_dict_sp->AddItem(GetSerializationSubclassOptionsKey(), options_dict_sp);
 
   // Add the m_offset to the dictionary:
   options_dict_sp->AddIntegerItem(GetKey(OptionNames::Offset), m_offset);
 
   return type_dict_sp;
 }
 
-void BreakpointResolver::SetBreakpoint(Breakpoint *bkpt) {
+void BreakpointResolver::SetBreakpoint(const BreakpointSP &bkpt) {
+  assert(bkpt);
   m_breakpoint = bkpt;
   NotifyBreakpointSet();
 }
 
 void BreakpointResolver::ResolveBreakpointInModules(SearchFilter &filter,
                                                     ModuleList &modules) {
   filter.SearchInModuleList(*this, modules);
 }
if (prologue_addr.IsValid() && (line_start == prologue_addr)) {
           skipped_prologue = true;
           line_start = prologue_addr;
         }
       }
     }
   }
 
   BreakpointLocationSP bp_loc_sp(AddLocation(line_start));
-  if (log && bp_loc_sp && !m_breakpoint->IsInternal()) {
+  if (log && bp_loc_sp && !GetBreakpoint()->IsInternal()) {
     StreamString s;
     bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
     LLDB_LOGF(log, "Added location (skipped prologue: %s): %s \n",
               skipped_prologue ? "yes" : "no", s.GetData());
   }
 }
 
 BreakpointLocationSP BreakpointResolver::AddLocation(Address loc_addr,
                                                      bool *new_location) {
   loc_addr.Slide(m_offset);
-  return m_breakpoint->AddLocation(loc_addr, new_location);
+  return GetBreakpoint()->AddLocation(loc_addr, new_location);
 }
 
 void BreakpointResolver::SetOffset(lldb::addr_t offset) {
   // There may already be an offset, so we are actually adjusting location
   // addresses by the difference.
   // lldb::addr_t slide = offset - m_offset;
   // FIXME: We should go fix up all the already set locations for the new
   // slide.
 
   m_offset = offset;
 }

lldb/source/Breakpoint/BreakpointResolverAddress.cpp

 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // BreakpointResolverAddress:
 BreakpointResolverAddress::BreakpointResolverAddress(
-    Breakpoint *bkpt, const Address &addr, const FileSpec &module_spec)
+    const BreakpointSP &bkpt, const Address &addr, const FileSpec &module_spec)
     : BreakpointResolver(bkpt, BreakpointResolver::AddressResolver),
       m_addr(addr), m_resolved_addr(LLDB_INVALID_ADDRESS),
       m_module_filespec(module_spec) {}
 
-BreakpointResolverAddress::BreakpointResolverAddress(Breakpoint *bkpt,
+BreakpointResolverAddress::BreakpointResolverAddress(const BreakpointSP &bkpt,
                                                      const Address &addr)
     : BreakpointResolver(bkpt, BreakpointResolver::AddressResolver),
       m_addr(addr), m_resolved_addr(LLDB_INVALID_ADDRESS), m_module_filespec() {
 }
 
-BreakpointResolverAddress::~BreakpointResolverAddress() {}
-
 BreakpointResolver *BreakpointResolverAddress::CreateFromStructuredData(
-    Breakpoint *bkpt, const StructuredData::Dictionary &options_dict,
+    const BreakpointSP &bkpt, const StructuredData::Dictionary &options_dict,
     Status &error) {
   llvm::StringRef module_name;
   lldb::addr_t addr_offset;
   FileSpec module_filespec;
   bool success;
 
   success = options_dict.GetValueForKeyAsInteger(
       GetKey(OptionNames::AddressOffset), addr_offset);

 void BreakpointResolverAddress::ResolveBreakpoint(SearchFilter &filter) {
   // If the address is not section relative, then we should not try to re-
   // resolve it, it is just some random address and we wouldn't know what to do
   // on reload.  But if it is section relative, we need to re-resolve it since
   // the section it's in may have shifted on re-run.
   bool re_resolve = false;
   if (m_addr.GetSection() || m_module_filespec)
     re_resolve = true;
-  else if (m_breakpoint->GetNumLocations() == 0)
+  else if (GetBreakpoint()->GetNumLocations() == 0)
     re_resolve = true;
 
   if (re_resolve)
     BreakpointResolver::ResolveBreakpoint(filter);
 }
 
 void BreakpointResolverAddress::ResolveBreakpointInModules(
     SearchFilter &filter, ModuleList &modules) {
   // See comment in ResolveBreakpoint.
   bool re_resolve = false;
   if (m_addr.GetSection())
     re_resolve = true;
-  else if (m_breakpoint->GetNumLocations() == 0)
+  else if (GetBreakpoint()->GetNumLocations() == 0)
     re_resolve = true;
 
   if (re_resolve)
     BreakpointResolver::ResolveBreakpointInModules(filter, modules);
 }
 
 Searcher::CallbackReturn BreakpointResolverAddress::SearchCallback(
     SearchFilter &filter, SymbolContext &context, Address *addr) {
-  assert(m_breakpoint != nullptr);
+  BreakpointSP breakpoint_sp = GetBreakpoint();
+  Breakpoint &breakpoint = *breakpoint_sp;
 
   if (filter.AddressPasses(m_addr)) {
-    if (m_breakpoint->GetNumLocations() == 0) {
+    if (breakpoint.GetNumLocations() == 0) {
       // If the address is just an offset, and we're given a module, see if we
       // can find the appropriate module loaded in the binary, and fix up
       // m_addr to use that.
       if (!m_addr.IsSectionOffset() && m_module_filespec) {
-        Target &target = m_breakpoint->GetTarget();
+        Target &target = breakpoint.GetTarget();
         ModuleSpec module_spec(m_module_filespec);
         ModuleSP module_sp = target.GetImages().FindFirstModule(module_spec);
         if (module_sp) {
           Address tmp_address;
           if (module_sp->ResolveFileAddress(m_addr.GetOffset(), tmp_address))
             m_addr = tmp_address;
         }
       }
 
-      m_resolved_addr = m_addr.GetLoadAddress(&m_breakpoint->GetTarget());
+      m_resolved_addr = m_addr.GetLoadAddress(&breakpoint.GetTarget());
       BreakpointLocationSP bp_loc_sp(AddLocation(m_addr));
-      if (bp_loc_sp && !m_breakpoint->IsInternal()) {
+      if (bp_loc_sp && !breakpoint.IsInternal()) {
         StreamString s;
         bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
         Log *log(
             lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
         LLDB_LOGF(log, "Added location: %s\n", s.GetData());
       }
     } else {
-      BreakpointLocationSP loc_sp = m_breakpoint->GetLocationAtIndex(0);
+      BreakpointLocationSP loc_sp = breakpoint.GetLocationAtIndex(0);
       lldb::addr_t cur_load_location =
-          m_addr.GetLoadAddress(&m_breakpoint->GetTarget());
+          m_addr.GetLoadAddress(&breakpoint.GetTarget());
       if (cur_load_location != m_resolved_addr) {
         m_resolved_addr = cur_load_location;
         loc_sp->ClearBreakpointSite();
         loc_sp->ResolveBreakpointSite();
       }
     }
   }
   return Searcher::eCallbackReturnStop;
 }
 
 lldb::SearchDepth BreakpointResolverAddress::GetDepth() {
   return lldb::eSearchDepthTarget;
 }
 
 void BreakpointResolverAddress::GetDescription(Stream *s) {
   s->PutCString("address = ");
-  m_addr.Dump(s, m_breakpoint->GetTarget().GetProcessSP().get(),
+  m_addr.Dump(s, GetBreakpoint()->GetTarget().GetProcessSP().get(),
               Address::DumpStyleModuleWithFileAddress,
               Address::DumpStyleLoadAddress);
 }
 
 void BreakpointResolverAddress::Dump(Stream *s) const {}
 
 lldb::BreakpointResolverSP
-BreakpointResolverAddress::CopyForBreakpoint(Breakpoint &breakpoint) {
+BreakpointResolverAddress::CopyForBreakpoint(BreakpointSP &breakpoint) {
   lldb::BreakpointResolverSP ret_sp(
-      new BreakpointResolverAddress(&breakpoint, m_addr));
+      new BreakpointResolverAddress(breakpoint, m_addr));
   return ret_sp;
 }

lldb/source/Breakpoint/BreakpointResolverFileLine.cpp

 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // BreakpointResolverFileLine:
 BreakpointResolverFileLine::BreakpointResolverFileLine(
-    Breakpoint *bkpt, const FileSpec &file_spec, uint32_t line_no,
+    const BreakpointSP &bkpt, const FileSpec &file_spec, uint32_t line_no,
     uint32_t column, lldb::addr_t offset, bool check_inlines,
     bool skip_prologue, bool exact_match)
     : BreakpointResolver(bkpt, BreakpointResolver::FileLineResolver, offset),
       m_file_spec(file_spec), m_line_number(line_no), m_column(column),
       m_inlines(check_inlines), m_skip_prologue(skip_prologue),
       m_exact_match(exact_match) {}
 
-BreakpointResolverFileLine::~BreakpointResolverFileLine() {}
-
 BreakpointResolver *BreakpointResolverFileLine::CreateFromStructuredData(
-    Breakpoint *bkpt, const StructuredData::Dictionary &options_dict,
+    const BreakpointSP &bkpt, const StructuredData::Dictionary &options_dict,
     Status &error) {
   llvm::StringRef filename;
   uint32_t line_no;
   uint32_t column;
   bool check_inlines;
   bool skip_prologue;
   bool exact_match;
   bool success;
for(uint32_t i = 0; i < sc_list.GetSize(); ++i) {
     }
   }
 }
 
 Searcher::CallbackReturn BreakpointResolverFileLine::SearchCallback(
     SearchFilter &filter, SymbolContext &context, Address *addr) {
   SymbolContextList sc_list;
 
-  assert(m_breakpoint != nullptr);
-
   // There is a tricky bit here.  You can have two compilation units that
   // #include the same file, and in one of them the function at m_line_number
   // is used (and so code and a line entry for it is generated) but in the
   // other it isn't.  If we considered the CU's independently, then in the
   // second inclusion, we'd move the breakpoint to the next function that
   // actually generated code in the header file.  That would end up being
   // confusing.  So instead, we do the CU iterations by hand here, then scan
   // through the complete list of matches, and figure out the closest line
void BreakpointResolverFileLine::GetDescription(Stream *s) {
   if (m_column)
     s->Printf("column = %u, ", m_column);
   s->Printf("exact_match = %d", m_exact_match);
 }
 
 void BreakpointResolverFileLine::Dump(Stream *s) const {}
 
 lldb::BreakpointResolverSP
-BreakpointResolverFileLine::CopyForBreakpoint(Breakpoint &breakpoint) {
+BreakpointResolverFileLine::CopyForBreakpoint(BreakpointSP &breakpoint) {
   lldb::BreakpointResolverSP ret_sp(new BreakpointResolverFileLine(
-      &breakpoint, m_file_spec, m_line_number, m_column, m_offset, m_inlines,
+      breakpoint, m_file_spec, m_line_number, m_column, GetOffset(), m_inlines,
       m_skip_prologue, m_exact_match));
 
   return ret_sp;
 }

lldb/source/Breakpoint/BreakpointResolverFileRegex.cpp

 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // BreakpointResolverFileRegex:
 BreakpointResolverFileRegex::BreakpointResolverFileRegex(
-    Breakpoint *bkpt, RegularExpression regex,
+    const lldb::BreakpointSP &bkpt, RegularExpression regex,
     const std::unordered_set<std::string> &func_names, bool exact_match)
     : BreakpointResolver(bkpt, BreakpointResolver::FileRegexResolver),
       m_regex(std::move(regex)), m_exact_match(exact_match),
       m_function_names(func_names) {}
 
-BreakpointResolverFileRegex::~BreakpointResolverFileRegex() {}
-
 BreakpointResolver *BreakpointResolverFileRegex::CreateFromStructuredData(
-    Breakpoint *bkpt, const StructuredData::Dictionary &options_dict,
+    const lldb::BreakpointSP &bkpt, const StructuredData::Dictionary &options_dict,
     Status &error) {
   bool success;
 
   llvm::StringRef regex_string;
   success = options_dict.GetValueForKeyAsString(
       GetKey(OptionNames::RegexString), regex_string);
   if (!success) {
     error.SetErrorString("BRFR::CFSD: Couldn't find regex entry.");
BreakpointResolverFileRegex::SerializeToStructuredData() {
   }
 
   return WrapOptionsDict(options_dict_sp);
 }
 
 Searcher::CallbackReturn BreakpointResolverFileRegex::SearchCallback(
     SearchFilter &filter, SymbolContext &context, Address *addr) {
 
-  assert(m_breakpoint != nullptr);
   if (!context.target_sp)
     return eCallbackReturnContinue;
 
   CompileUnit *cu = context.comp_unit;
   FileSpec cu_file_spec = cu->GetPrimaryFile();
   std::vector<uint32_t> line_matches;
   context.target_sp->GetSourceManager().FindLinesMatchingRegex(
       cu_file_spec, m_regex, 1, UINT32_MAX, line_matches);
if (!m_function_names.empty()) {
       }
     }
 
     const bool skip_prologue = true;
 
     BreakpointResolver::SetSCMatchesByLine(filter, sc_list, skip_prologue,
                                            m_regex.GetText());
   }
-  assert(m_breakpoint != nullptr);
 
   return Searcher::eCallbackReturnContinue;
 }
 
 lldb::SearchDepth BreakpointResolverFileRegex::GetDepth() {
   return lldb::eSearchDepthCompUnit;
 }
 
 void BreakpointResolverFileRegex::GetDescription(Stream *s) {
   s->Printf("source regex = \"%s\", exact_match = %d",
             m_regex.GetText().str().c_str(), m_exact_match);
 }
 
 void BreakpointResolverFileRegex::Dump(Stream *s) const {}
 
 lldb::BreakpointResolverSP
-BreakpointResolverFileRegex::CopyForBreakpoint(Breakpoint &breakpoint) {
+BreakpointResolverFileRegex::CopyForBreakpoint(BreakpointSP &breakpoint) {
   lldb::BreakpointResolverSP ret_sp(new BreakpointResolverFileRegex(
-      &breakpoint, m_regex, m_function_names, m_exact_match));
+      breakpoint, m_regex, m_function_names, m_exact_match));
   return ret_sp;
 }
 
 void BreakpointResolverFileRegex::AddFunctionName(const char *func_name) {
   m_function_names.insert(func_name);
 }

lldb/source/Breakpoint/BreakpointResolverName.cpp

 #include "lldb/Target/Target.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-BreakpointResolverName::BreakpointResolverName(
-    Breakpoint *bkpt, const char *name_cstr, FunctionNameType name_type_mask,
+BreakpointResolverName::BreakpointResolverName(const BreakpointSP &bkpt,
+    const char *name_cstr, FunctionNameType name_type_mask,
     LanguageType language, Breakpoint::MatchType type, lldb::addr_t offset,
     bool skip_prologue)
     : BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset),
       m_class_name(), m_regex(), m_match_type(type), m_language(language),
       m_skip_prologue(skip_prologue) {
   if (m_match_type == Breakpoint::Regexp) {
     m_regex = RegularExpression(llvm::StringRef::withNullAsEmpty(name_cstr));
     if (!m_regex.IsValid()) {
       Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
 
       if (log)
         log->Warning("function name regexp: \"%s\" did not compile.",
                      name_cstr);
     }
   } else {
     AddNameLookup(ConstString(name_cstr), name_type_mask);
   }
 }
 
 BreakpointResolverName::BreakpointResolverName(
-    Breakpoint *bkpt, const char *names[], size_t num_names,
+    const BreakpointSP &bkpt, const char *names[], size_t num_names,
     FunctionNameType name_type_mask, LanguageType language, lldb::addr_t offset,
     bool skip_prologue)
     : BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset),
       m_match_type(Breakpoint::Exact), m_language(language),
       m_skip_prologue(skip_prologue) {
   for (size_t i = 0; i < num_names; i++) {
     AddNameLookup(ConstString(names[i]), name_type_mask);
   }
 }
 
-BreakpointResolverName::BreakpointResolverName(Breakpoint *bkpt,
+BreakpointResolverName::BreakpointResolverName(const BreakpointSP &bkpt,
                                                std::vector<std::string> names,
                                                FunctionNameType name_type_mask,
                                                LanguageType language,
                                                lldb::addr_t offset,
                                                bool skip_prologue)
     : BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset),
       m_match_type(Breakpoint::Exact), m_language(language),
       m_skip_prologue(skip_prologue) {
   for (const std::string &name : names) {
     AddNameLookup(ConstString(name.c_str(), name.size()), name_type_mask);
   }
 }
 
-BreakpointResolverName::BreakpointResolverName(Breakpoint *bkpt,
+BreakpointResolverName::BreakpointResolverName(const BreakpointSP &bkpt,
                                                RegularExpression func_regex,
                                                lldb::LanguageType language,
                                                lldb::addr_t offset,
                                                bool skip_prologue)
     : BreakpointResolver(bkpt, BreakpointResolver::NameResolver, offset),
       m_class_name(nullptr), m_regex(std::move(func_regex)),
       m_match_type(Breakpoint::Regexp), m_language(language),
       m_skip_prologue(skip_prologue) {}
 
-BreakpointResolverName::~BreakpointResolverName() = default;
-
 BreakpointResolverName::BreakpointResolverName(
     const BreakpointResolverName &rhs)
-    : BreakpointResolver(rhs.m_breakpoint, BreakpointResolver::NameResolver,
-                         rhs.m_offset),
+    : BreakpointResolver(rhs.GetBreakpoint(), BreakpointResolver::NameResolver,
+                         rhs.GetOffset()),
       m_lookups(rhs.m_lookups), m_class_name(rhs.m_class_name),
       m_regex(rhs.m_regex), m_match_type(rhs.m_match_type),
       m_language(rhs.m_language), m_skip_prologue(rhs.m_skip_prologue) {}
 
 BreakpointResolver *BreakpointResolverName::CreateFromStructuredData(
-    Breakpoint *bkpt, const StructuredData::Dictionary &options_dict,
+    const BreakpointSP &bkpt, const StructuredData::Dictionary &options_dict,
     Status &error) {
   LanguageType language = eLanguageTypeUnknown;
   llvm::StringRef language_name;
   bool success = options_dict.GetValueForKeyAsString(
       GetKey(OptionNames::LanguageName), language_name);
   if (success) {
     language = Language::GetLanguageTypeFromString(language_name);
     if (language == eLanguageTypeUnknown) {

 BreakpointResolverName::SearchCallback(SearchFilter &filter,
                                        SymbolContext &context, Address *addr) {
   SymbolContextList func_list;
   // SymbolContextList sym_list;
 
   uint32_t i;
   bool new_location;
   Address break_addr;
-  assert(m_breakpoint != nullptr);
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
 
   if (m_class_name) {
     if (log)
       log->Warning("Class/method function specification not supported yet.\n");
     return Searcher::eCallbackReturnStop;
   }
+
   bool filter_by_cu =
       (filter.GetFilterRequiredItems() & eSymbolContextCompUnit) != 0;
   bool filter_by_language = (m_language != eLanguageTypeUnknown);
   const bool include_symbols = !filter_by_cu;
   const bool include_inlines = true;
 
   switch (m_match_type) {
   case Breakpoint::Exact:
for (size_t idx = 0; idx < num_functions; idx++) {
       if (remove_it) {
         func_list.RemoveContextAtIndex(idx);
         num_functions--;
         idx--;
       }
     }
   }
 
+  BreakpointSP breakpoint_sp = GetBreakpoint();
+  Breakpoint &breakpoint = *breakpoint_sp;
+
   // Remove any duplicates between the function list and the symbol list
   SymbolContext sc;
   if (func_list.GetSize()) {
     for (i = 0; i < func_list.GetSize(); i++) {
       if (func_list.GetContextAtIndex(i, sc)) {
         bool is_reexported = false;
 
         if (sc.block && sc.block->GetInlinedFunctionInfo()) {
           if (!sc.block->GetStartAddress(break_addr))
             break_addr.Clear();
         } else if (sc.function) {
           break_addr = sc.function->GetAddressRange().GetBaseAddress();
           if (m_skip_prologue && break_addr.IsValid()) {
             const uint32_t prologue_byte_size =
                 sc.function->GetPrologueByteSize();
             if (prologue_byte_size)
               break_addr.SetOffset(break_addr.GetOffset() + prologue_byte_size);
           }
         } else if (sc.symbol) {
           if (sc.symbol->GetType() == eSymbolTypeReExported) {
             const Symbol *actual_symbol =
-                sc.symbol->ResolveReExportedSymbol(m_breakpoint->GetTarget());
+                sc.symbol->ResolveReExportedSymbol(breakpoint.GetTarget());
             if (actual_symbol) {
               is_reexported = true;
               break_addr = actual_symbol->GetAddress();
             }
           } else {
             break_addr = sc.symbol->GetAddress();
           }
 
           if (m_skip_prologue && break_addr.IsValid()) {
             const uint32_t prologue_byte_size =
                 sc.symbol->GetPrologueByteSize();
             if (prologue_byte_size)
               break_addr.SetOffset(break_addr.GetOffset() + prologue_byte_size);
             else {
               const Architecture *arch =
-                  m_breakpoint->GetTarget().GetArchitecturePlugin();
+                  breakpoint.GetTarget().GetArchitecturePlugin();
               if (arch)
                 arch->AdjustBreakpointAddress(*sc.symbol, break_addr);
             }
           }
         }
 
         if (break_addr.IsValid()) {
           if (filter.AddressPasses(break_addr)) {
             BreakpointLocationSP bp_loc_sp(
                 AddLocation(break_addr, &new_location));
             bp_loc_sp->SetIsReExported(is_reexported);
-            if (bp_loc_sp && new_location && !m_breakpoint->IsInternal()) {
+            if (bp_loc_sp && new_location && !breakpoint.IsInternal()) {
               if (log) {
                 StreamString s;
                 bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
                 LLDB_LOGF(log, "Added location: %s\n", s.GetData());
               }
             }
           }
         }
void BreakpointResolverName::GetDescription(Stream *s) {
   if (m_language != eLanguageTypeUnknown) {
     s->Printf(", language = %s", Language::GetNameForLanguageType(m_language));
   }
 }
 
 void BreakpointResolverName::Dump(Stream *s) const {}
 
 lldb::BreakpointResolverSP
-BreakpointResolverName::CopyForBreakpoint(Breakpoint &breakpoint) {
+BreakpointResolverName::CopyForBreakpoint(BreakpointSP &breakpoint) {
   lldb::BreakpointResolverSP ret_sp(new BreakpointResolverName(*this));
-  ret_sp->SetBreakpoint(&breakpoint);
+  ret_sp->SetBreakpoint(breakpoint);
   return ret_sp;
 }

lldb/source/Breakpoint/BreakpointResolverScripted.cpp

 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // BreakpointResolverScripted:
 BreakpointResolverScripted::BreakpointResolverScripted(
-    Breakpoint *bkpt, const llvm::StringRef class_name, lldb::SearchDepth depth,
-    StructuredDataImpl *args_data)
+    const BreakpointSP &bkpt, const llvm::StringRef class_name,
+    lldb::SearchDepth depth, StructuredDataImpl *args_data)
     : BreakpointResolver(bkpt, BreakpointResolver::PythonResolver),
       m_class_name(std::string(class_name)), m_depth(depth),
       m_args_ptr(args_data) {
   CreateImplementationIfNeeded();
 }
 
 void BreakpointResolverScripted::CreateImplementationIfNeeded() {
   if (m_implementation_sp)
     return;
-  
   if (m_class_name.empty())
     return;
-  
-  if (m_breakpoint) {
-    TargetSP target_sp = m_breakpoint->GetTargetSP();
-    ScriptInterpreter *script_interp = target_sp->GetDebugger()
-                                                .GetScriptInterpreter();
-    if (!script_interp)
-      return;
-    lldb::BreakpointSP bkpt_sp(m_breakpoint->shared_from_this());
-    m_implementation_sp = script_interp->CreateScriptedBreakpointResolver(
-        m_class_name.c_str(), m_args_ptr, bkpt_sp);
-  }
+  BreakpointSP breakpoint_sp = GetBreakpoint();
+
+  TargetSP target_sp = breakpoint_sp->GetTargetSP();
+
+      m_class_name.c_str(), m_args_ptr, breakpoint_sp);
 }
 
 void BreakpointResolverScripted::NotifyBreakpointSet() {
   CreateImplementationIfNeeded();
 }
 
-BreakpointResolverScripted::~BreakpointResolverScripted() {}
-
 BreakpointResolver *
 BreakpointResolverScripted::CreateFromStructuredData(
-    Breakpoint *bkpt, const StructuredData::Dictionary &options_dict,
+    const BreakpointSP &bkpt, const StructuredData::Dictionary &options_dict,
     Status &error) {
   llvm::StringRef class_name;
   bool success;
   
   success = options_dict.GetValueForKeyAsString(
       GetKey(OptionNames::PythonClassName), class_name);
   if (!success) {
     error.SetErrorString("BRFL::CFSD: Couldn't find class name entry.");
BreakpointResolverScripted::SerializeToStructuredData() {
   if (m_args_ptr->IsValid())
       options_dict_sp->AddItem(GetKey(OptionNames::ScriptArgs),
           m_args_ptr->GetObjectSP());
 
   return WrapOptionsDict(options_dict_sp);
 }
 
 ScriptInterpreter *BreakpointResolverScripted::GetScriptInterpreter() {
-  return m_breakpoint->GetTarget().GetDebugger().GetScriptInterpreter();
+  return GetBreakpoint()->GetTarget().GetDebugger().GetScriptInterpreter();
 }
 
 Searcher::CallbackReturn BreakpointResolverScripted::SearchCallback(
     SearchFilter &filter, SymbolContext &context, Address *addr) {
-  assert(m_breakpoint != nullptr);
   bool should_continue = true;
   if (!m_implementation_sp)
     return Searcher::eCallbackReturnStop;
-  
   ScriptInterpreter *interp = GetScriptInterpreter();
   should_continue = interp->ScriptedBreakpointResolverSearchCallback(
       m_implementation_sp,
       &context);
   if (should_continue)
     return Searcher::eCallbackReturnContinue;
   else
     return Searcher::eCallbackReturnStop;
 }
 
 lldb::SearchDepth
 BreakpointResolverScripted::GetDepth() {
-  assert(m_breakpoint != nullptr);
   lldb::SearchDepth depth = lldb::eSearchDepthModule;
   if (m_implementation_sp) {
     ScriptInterpreter *interp = GetScriptInterpreter();
     depth = interp->ScriptedBreakpointResolverSearchDepth(
         m_implementation_sp);
   }
   return depth;
 }
if (!short_help.empty())
     s->PutCString(short_help.c_str());
   else
     s->Printf("python class = %s", m_class_name.c_str());
 }
 
 void BreakpointResolverScripted::Dump(Stream *s) const {}
 
 lldb::BreakpointResolverSP
-BreakpointResolverScripted::CopyForBreakpoint(Breakpoint &breakpoint) {
+BreakpointResolverScripted::CopyForBreakpoint(BreakpointSP &breakpoint) {
   // FIXME: Have to make a copy of the arguments from the m_args_ptr and then
   // pass that to the new resolver.
   lldb::BreakpointResolverSP ret_sp(
-      new BreakpointResolverScripted(&breakpoint, m_class_name, m_depth, 
+      new BreakpointResolverScripted(breakpoint, m_class_name, m_depth, 
                                      nullptr));
   return ret_sp;
 }

lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h

public:
   void SetExceptionBreakpoints() override;
 
   void ClearExceptionBreakpoints() override;
 
   bool ExceptionBreakpointsAreSet() override;
 
   bool ExceptionBreakpointsExplainStop(lldb::StopInfoSP stop_reason) override;
 
-  lldb::BreakpointResolverSP CreateExceptionResolver(Breakpoint *bkpt,
-                                                     bool catch_bp,
-                                                     bool throw_bp) override;
+  lldb::BreakpointResolverSP
+  CreateExceptionResolver(const lldb::BreakpointSP &bkpt,
+                          bool catch_bp, bool throw_bp) override;
 
   lldb::SearchFilterSP CreateExceptionSearchFilter() override;
   
   lldb::ValueObjectSP GetExceptionObjectForThread(
       lldb::ThreadSP thread_sp) override;
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
 protected:
-  lldb::BreakpointResolverSP CreateExceptionResolver(Breakpoint *bkpt,
-                                                     bool catch_bp,
-                                                     bool throw_bp,
-                                                     bool for_expressions);
+  lldb::BreakpointResolverSP
+  CreateExceptionResolver(const lldb::BreakpointSP &bkpt,
+                          bool catch_bp, bool throw_bp, bool for_expressions);
 
   lldb::BreakpointSP CreateExceptionBreakpoint(bool catch_bp, bool throw_bp,
                                                bool for_expressions,
                                                bool is_internal);
 
 private:
   typedef std::map<lldb_private::Address, TypeAndOrName> DynamicTypeCache;
 

lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp

 // PluginInterface protocol
 lldb_private::ConstString ItaniumABILanguageRuntime::GetPluginName() {
   return GetPluginNameStatic();
 }
 
 uint32_t ItaniumABILanguageRuntime::GetPluginVersion() { return 1; }
 
 BreakpointResolverSP ItaniumABILanguageRuntime::CreateExceptionResolver(
-    Breakpoint *bkpt, bool catch_bp, bool throw_bp) {
+    const BreakpointSP &bkpt, bool catch_bp, bool throw_bp) {
   return CreateExceptionResolver(bkpt, catch_bp, throw_bp, false);
 }
 
 BreakpointResolverSP ItaniumABILanguageRuntime::CreateExceptionResolver(
-    Breakpoint *bkpt, bool catch_bp, bool throw_bp, bool for_expressions) {
+    const BreakpointSP &bkpt, bool catch_bp, bool throw_bp,
+    bool for_expressions) {
   // One complication here is that most users DON'T want to stop at
   // __cxa_allocate_expression, but until we can do anything better with
   // predicting unwinding the expression parser does.  So we have two forms of
   // the exception breakpoints, one for expressions that leaves out
   // __cxa_allocate_exception, and one that includes it. The
   // SetExceptionBreakpoints does the latter, the CreateExceptionBreakpoint in
   // the runtime the former.
   static const char *g_catch_name = "__cxa_begin_catch";

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h

ObjCRuntimeVersions GetRuntimeVersion() const override {
     return ObjCRuntimeVersions::eAppleObjC_V1;
   }
 
   void UpdateISAToDescriptorMapIfNeeded() override;
 
   DeclVendor *GetDeclVendor() override;
 
 protected:
-  lldb::BreakpointResolverSP CreateExceptionResolver(Breakpoint *bkpt,
-                                                     bool catch_bp,
-                                                     bool throw_bp) override;
+  lldb::BreakpointResolverSP
+  CreateExceptionResolver(const lldb::BreakpointSP &bkpt,
+                          bool catch_bp, bool throw_bp) override;
 
   class HashTableSignature {
   public:
     HashTableSignature()
         : m_count(0), m_num_buckets(0), m_buckets_ptr(LLDB_INVALID_ADDRESS) {}
 
     bool NeedsUpdate(uint32_t count, uint32_t num_buckets,
                      lldb::addr_t buckets_ptr) {

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp

 // PluginInterface protocol
 ConstString AppleObjCRuntimeV1::GetPluginName() {
   return GetPluginNameStatic();
 }
 
 uint32_t AppleObjCRuntimeV1::GetPluginVersion() { return 1; }
 
 BreakpointResolverSP
-AppleObjCRuntimeV1::CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp,
-                                            bool throw_bp) {
+AppleObjCRuntimeV1::CreateExceptionResolver(const BreakpointSP &bkpt,
+                                            bool catch_bp, bool throw_bp) {
   BreakpointResolverSP resolver_sp;
 
   if (throw_bp)
     resolver_sp = std::make_shared<BreakpointResolverName>(
         bkpt, std::get<1>(GetExceptionThrowLocation()).AsCString(),
         eFunctionNameTypeBase, eLanguageTypeUnknown, Breakpoint::Exact, 0,
         eLazyBoolNo);
   // FIXME: don't do catch yet.

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h

public:
   static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSAtom = 2;
   static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSNumber = 3;
   static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSDateTS = 4;
   static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSManagedObject =
       5;
   static const ObjCLanguageRuntime::ObjCISA g_objc_Tagged_ISA_NSDate = 6;
 
 protected:
-  lldb::BreakpointResolverSP CreateExceptionResolver(Breakpoint *bkpt,
-                                                     bool catch_bp,
-                                                     bool throw_bp) override;
+  lldb::BreakpointResolverSP
+  CreateExceptionResolver(const lldb::BreakpointSP &bkpt,
+                          bool catch_bp, bool throw_bp) override;
 
 private:
   class HashTableSignature {
   public:
     HashTableSignature();
 
     bool NeedsUpdate(Process *process, AppleObjCRuntimeV2 *runtime,
                      RemoteNXMapTable &hash_table);

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

 // PluginInterface protocol
 lldb_private::ConstString AppleObjCRuntimeV2::GetPluginName() {
   return GetPluginNameStatic();
 }
 
 uint32_t AppleObjCRuntimeV2::GetPluginVersion() { return 1; }
 
 BreakpointResolverSP
-AppleObjCRuntimeV2::CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp,
-                                            bool throw_bp) {
+AppleObjCRuntimeV2::CreateExceptionResolver(const BreakpointSP &bkpt,
+                                            bool catch_bp, bool throw_bp) {
   BreakpointResolverSP resolver_sp;
 
   if (throw_bp)
     resolver_sp = std::make_shared<BreakpointResolverName>(
         bkpt, std::get<1>(GetExceptionThrowLocation()).AsCString(),
         eFunctionNameTypeBase, eLanguageTypeUnknown, Breakpoint::Exact, 0,
         eLazyBoolNo);
   // FIXME: We don't do catch breakpoints for ObjC yet.

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h

struct RSCoordinate {
   }
 };
 
 // Breakpoint Resolvers decide where a breakpoint is placed, so having our own
 // allows us to limit the search scope to RS kernel modules. As well as check
 // for .expand kernels as a fallback.
 class RSBreakpointResolver : public BreakpointResolver {
 public:
-  RSBreakpointResolver(Breakpoint *bp, ConstString name)
+  RSBreakpointResolver(const lldb::BreakpointSP &bp, ConstString name)
       : BreakpointResolver(bp, BreakpointResolver::NameResolver),
         m_kernel_name(name) {}
 
   void GetDescription(Stream *strm) override {
     if (strm)
       strm->Printf("RenderScript kernel breakpoint for '%s'",
                    m_kernel_name.AsCString());
   }
 
   void Dump(Stream *s) const override {}
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                           SymbolContext &context,
                                           Address *addr) override;
 
   lldb::SearchDepth GetDepth() override { return lldb::eSearchDepthModule; }
 
   lldb::BreakpointResolverSP
-  CopyForBreakpoint(Breakpoint &breakpoint) override {
+  CopyForBreakpoint(lldb::BreakpointSP &breakpoint) override {
     lldb::BreakpointResolverSP ret_sp(
-        new RSBreakpointResolver(&breakpoint, m_kernel_name));
+        new RSBreakpointResolver(breakpoint, m_kernel_name));
     return ret_sp;
   }
 
 protected:
   ConstString m_kernel_name;
 };
 
 class RSReduceBreakpointResolver : public BreakpointResolver {
 public:
   enum ReduceKernelTypeFlags {
     eKernelTypeAll = ~(0),
     eKernelTypeNone = 0,
     eKernelTypeAccum = (1 << 0),
     eKernelTypeInit = (1 << 1),
     eKernelTypeComb = (1 << 2),
     eKernelTypeOutC = (1 << 3),
     eKernelTypeHalter = (1 << 4)
   };
 
   RSReduceBreakpointResolver(
-      Breakpoint *breakpoint, ConstString reduce_name,
+      const lldb::BreakpointSP &breakpoint, ConstString reduce_name,
       std::vector<lldb_renderscript::RSModuleDescriptorSP> *rs_modules,
       int kernel_types = eKernelTypeAll)
       : BreakpointResolver(breakpoint, BreakpointResolver::NameResolver),
         m_reduce_name(reduce_name), m_rsmodules(rs_modules),
         m_kernel_types(kernel_types) {
     // The reduce breakpoint resolver handles adding breakpoints for named
     // reductions.
     // Breakpoints will be resolved for all constituent kernels in the named
public:
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                           SymbolContext &context,
                                           Address *addr) override;
 
   lldb::SearchDepth GetDepth() override { return lldb::eSearchDepthModule; }
 
   lldb::BreakpointResolverSP
-  CopyForBreakpoint(Breakpoint &breakpoint) override {
+  CopyForBreakpoint(lldb::BreakpointSP &breakpoint) override {
     lldb::BreakpointResolverSP ret_sp(new RSReduceBreakpointResolver(
-        &breakpoint, m_reduce_name, m_rsmodules, m_kernel_types));
+        breakpoint, m_reduce_name, m_rsmodules, m_kernel_types));
     return ret_sp;
   }
 
 private:
   ConstString m_reduce_name; // The name of the reduction
   std::vector<lldb_renderscript::RSModuleDescriptorSP> *m_rsmodules;
   int m_kernel_types;
 };
struct RSScriptGroupDescriptor {
   ConstString m_name;
   std::vector<Kernel> m_kernels;
 };
 
 typedef std::vector<RSScriptGroupDescriptorSP> RSScriptGroupList;
 
 class RSScriptGroupBreakpointResolver : public BreakpointResolver {
 public:
-  RSScriptGroupBreakpointResolver(Breakpoint *bp, ConstString name,
+  RSScriptGroupBreakpointResolver(const lldb::BreakpointSP &bp,
+                                  ConstString name,
                                   const RSScriptGroupList &groups,
                                   bool stop_on_all)
       : BreakpointResolver(bp, BreakpointResolver::NameResolver),
         m_group_name(name), m_script_groups(groups),
         m_stop_on_all(stop_on_all) {}
 
   void GetDescription(Stream *strm) override {
     if (strm)
       strm->Printf("RenderScript ScriptGroup breakpoint for '%s'",
                    m_group_name.AsCString());
   }
 
   void Dump(Stream *s) const override {}
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                           SymbolContext &context,
                                           Address *addr) override;
 
   lldb::SearchDepth GetDepth() override { return lldb::eSearchDepthModule; }
 
   lldb::BreakpointResolverSP
-  CopyForBreakpoint(Breakpoint &breakpoint) override {
+  CopyForBreakpoint(lldb::BreakpointSP &breakpoint) override {
     lldb::BreakpointResolverSP ret_sp(new RSScriptGroupBreakpointResolver(
-        &breakpoint, m_group_name, m_script_groups, m_stop_on_all));
+        breakpoint, m_group_name, m_script_groups, m_stop_on_all));
     return ret_sp;
   }
 
 protected:
   const RSScriptGroupDescriptorSP
   FindScriptGroup(ConstString name) const {
     for (auto sg : m_script_groups) {
       if (ConstString::Compare(sg->m_name, name) == 0)
bool GetDynamicTypeAndAddress(ValueObject &in_value,
                                 Address &address,
                                 Value::ValueType &value_type) override;
 
   TypeAndOrName FixUpDynamicType(const TypeAndOrName &type_and_or_name,
                                  ValueObject &static_value) override;
 
   bool CouldHaveDynamicValue(ValueObject &in_value) override;
 
-  lldb::BreakpointResolverSP CreateExceptionResolver(Breakpoint *bp,
-                                                     bool catch_bp,
-                                                     bool throw_bp) override;
+  lldb::BreakpointResolverSP
+  CreateExceptionResolver(const lldb::BreakpointSP &bp,
+                          bool catch_bp, bool throw_bp) override;
 
   bool LoadModule(const lldb::ModuleSP &module_sp);
 
   void DumpModules(Stream &strm) const;
 
   void DumpContexts(Stream &strm) const;
 
   void DumpKernels(Stream &strm) const;

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

 
 // Callback with a module to search for matching symbols. We first check that
 // the module contains RS kernels. Then look for a symbol which matches our
 // kernel name. The breakpoint address is finally set using the address of this
 // symbol.
 Searcher::CallbackReturn
 RSBreakpointResolver::SearchCallback(SearchFilter &filter,
                                      SymbolContext &context, Address *) {
+  BreakpointSP breakpoint_sp = GetBreakpoint();
+  assert(breakpoint_sp);
+
   ModuleSP module = context.module_sp;
 
   if (!module || !IsRenderScriptScriptModule(module))
     return Searcher::eCallbackReturnContinue;
 
   // Attempt to set a breakpoint on the kernel name symbol within the module
   // library. If it's not found, it's likely debug info is unavailable - try to
   // set a breakpoint on <name>.expand.
   const Symbol *kernel_sym =
       module->FindFirstSymbolWithNameAndType(m_kernel_name, eSymbolTypeCode);
   if (!kernel_sym) {
     std::string kernel_name_expanded(m_kernel_name.AsCString());
     kernel_name_expanded.append(".expand");
     kernel_sym = module->FindFirstSymbolWithNameAndType(
         ConstString(kernel_name_expanded.c_str()), eSymbolTypeCode);
   }
 
   if (kernel_sym) {
     Address bp_addr = kernel_sym->GetAddress();
     if (filter.AddressPasses(bp_addr))
-      m_breakpoint->AddLocation(bp_addr);
+      breakpoint_sp->AddLocation(bp_addr);
   }
 
   return Searcher::eCallbackReturnContinue;
 }
 
 Searcher::CallbackReturn
 RSReduceBreakpointResolver::SearchCallback(lldb_private::SearchFilter &filter,
                                            lldb_private::SymbolContext &context,
                                            Address *) {
+  BreakpointSP breakpoint_sp = GetBreakpoint();
+  assert(breakpoint_sp);
+
   // We need to have access to the list of reductions currently parsed, as
   // reduce names don't actually exist as symbols in a module. They are only
   // identifiable by parsing the .rs.info packet, or finding the expand symbol.
   // We therefore need access to the list of parsed rs modules to properly
   // resolve reduction names.
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
   ModuleSP module = context.module_sp;
 
for (const auto &reduction : module_desc->m_reductions) {
           continue;
 
         auto address = symbol->GetAddress();
         if (filter.AddressPasses(address)) {
           bool new_bp;
           if (!SkipPrologue(module, address)) {
             LLDB_LOGF(log, "%s: Error trying to skip prologue", __FUNCTION__);
           }
-          m_breakpoint->AddLocation(address, &new_bp);
+          breakpoint_sp->AddLocation(address, &new_bp);
           LLDB_LOGF(log, "%s: %s reduction breakpoint on %s in %s",
                     __FUNCTION__, new_bp ? "new" : "existing",
                     kernel_name.GetCString(),
                     address.GetModule()->GetFileSpec().GetCString());
         }
       }
     }
   }
   return eCallbackReturnContinue;
 }
 
 Searcher::CallbackReturn RSScriptGroupBreakpointResolver::SearchCallback(
     SearchFilter &filter, SymbolContext &context, Address *addr) {
 
-  if (!m_breakpoint)
+  BreakpointSP breakpoint_sp = GetBreakpoint();
+  if (!breakpoint_sp)
     return eCallbackReturnContinue;
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
   ModuleSP &module = context.module_sp;
 
   if (!module || !IsRenderScriptScriptModule(module))
     return Searcher::eCallbackReturnContinue;
 
   std::vector<std::string> names;
-  m_breakpoint->GetNames(names);
+  Breakpoint& breakpoint = *breakpoint_sp;
+  breakpoint.GetNames(names);
   if (names.empty())
     return eCallbackReturnContinue;
 
   for (auto &name : names) {
     const RSScriptGroupDescriptorSP sg = FindScriptGroup(ConstString(name));
     if (!sg) {
       LLDB_LOGF(log, "%s: could not find script group for %s", __FUNCTION__,
                 name.c_str());
for (const RSScriptGroupDescriptor::Kernel &k : sg->m_kernels) {
       }
 
       auto address = sym->GetAddress();
       if (!SkipPrologue(module, address)) {
         LLDB_LOGF(log, "%s: Error trying to skip prologue", __FUNCTION__);
       }
 
       bool new_bp;
-      m_breakpoint->AddLocation(address, &new_bp);
+      breakpoint.AddLocation(address, &new_bp);
 
       LLDB_LOGF(log, "%s: Placed %sbreakpoint on %s", __FUNCTION__,
                 new_bp ? "new " : "", k.m_name.AsCString());
 
       // exit after placing the first breakpoint if we do not intend to stop on
       // all kernels making up this script group
       if (!m_stop_on_all)
         break;
RenderScriptRuntime::FixUpDynamicType(const TypeAndOrName &type_and_or_name,
   return type_and_or_name;
 }
 
 bool RenderScriptRuntime::CouldHaveDynamicValue(ValueObject &in_value) {
   return false;
 }
 
 lldb::BreakpointResolverSP
-RenderScriptRuntime::CreateExceptionResolver(Breakpoint *bp, bool catch_bp,
-                                             bool throw_bp) {
+RenderScriptRuntime::CreateExceptionResolver(const lldb::BreakpointSP &bp,
+                                             bool catch_bp, bool throw_bp) {
   BreakpointResolverSP resolver_sp;
   return resolver_sp;
 }
 
 const RenderScriptRuntime::HookDefn RenderScriptRuntime::s_runtimeHookDefns[] =
     {
         // rsdScript
         {"rsdScriptInit", "_Z13rsdScriptInitPKN7android12renderscript7ContextEP"

lldb/source/Target/LanguageRuntime.cpp

public:
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const BreakpointResolverName *) { return true; }
   static inline bool classof(const BreakpointResolver *V) {
     return V->getResolverID() == BreakpointResolver::ExceptionResolver;
   }
 
 protected:
-  BreakpointResolverSP CopyForBreakpoint(Breakpoint &breakpoint) override {
+  BreakpointResolverSP CopyForBreakpoint(BreakpointSP &breakpoint) override {
     BreakpointResolverSP ret_sp(
         new ExceptionBreakpointResolver(m_language, m_catch_bp, m_throw_bp));
-    ret_sp->SetBreakpoint(&breakpoint);
+    ret_sp->SetBreakpoint(breakpoint);
     return ret_sp;
   }
 
   bool SetActualResolver() {
-    ProcessSP process_sp;
-    if (m_breakpoint) {
-      process_sp = m_breakpoint->GetTarget().GetProcessSP();
+    BreakpointSP breakpoint_sp = GetBreakpoint();
+    if (breakpoint_sp) {
+      ProcessSP process_sp = breakpoint_sp->GetTarget().GetProcessSP();
       if (process_sp) {
         bool refreash_resolver = !m_actual_resolver_sp;
         if (m_language_runtime == nullptr) {
           m_language_runtime = process_sp->GetLanguageRuntime(m_language);
           refreash_resolver = true;
         } else {
           LanguageRuntime *language_runtime =
               process_sp->GetLanguageRuntime(m_language);
           if (m_language_runtime != language_runtime) {
             m_language_runtime = language_runtime;
             refreash_resolver = true;
           }
         }
 
         if (refreash_resolver && m_language_runtime) {
           m_actual_resolver_sp = m_language_runtime->CreateExceptionResolver(
-              m_breakpoint, m_catch_bp, m_throw_bp);
+              breakpoint_sp, m_catch_bp, m_throw_bp);
         }
       } else {
         m_actual_resolver_sp.reset();
         m_language_runtime = nullptr;
       }
     } else {
       m_actual_resolver_sp.reset();
       m_language_runtime = nullptr;

lldb/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) {
     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());
+    resolver_sp->SetBreakpoint(bp_sp);
     AddBreakpoint(bp_sp, internal);
   }
   return bp_sp;
 }
 
 void Target::AddBreakpoint(lldb::BreakpointSP bp_sp, bool internal) {
   if (!bp_sp)
     return;