[Target] Decouple ObjCLanguageRuntime from LanguageRuntime

[xiaobai]

Summary

ObjCLanguageRuntime was being pulled into LanguageRuntime because of
Breakpoint Preconditions. If we move BreakpointPrecondition out of Breakpoint,
we can extend the LanguageRuntime plugin interface so that LanguageRuntimes
can give us a BreakpointPrecondition for exceptions.

[JDevlieghere]

Have you considered making just AddExceptionPrecondition virtual? Wouldn't that solve the problem too, without the code duplication of making CreateExceptionBreakpoint virtual? Also, I think it's totally reasonable to hoist BreakpointPrecondition out of Breakpoint. After having had to deal with the nuisance of not being able to forward declare nested classes, I try to avoid them in general.

[xiaobai]

In D63181#1539291, @JDevlieghere wrote:

Have you considered making just AddExceptionPrecondition virtual? Wouldn't that solve the problem too, without the code duplication of making CreateExceptionBreakpoint virtual?

I don't believe so. As I understand it, you might not have a process yet when you call LanguageRuntime::CreateExceptionBreakpoint from Target, so you won't have an instance of LanguageRuntime. You could create an instance of a LanguageRuntime object with a nullptr process just to invoke it as an instance method, but that seems like the wrong choice to me. All this combined has led me to believe that AddExceptionPrecondition needs to get a callback to a static function from PluginManager.

Also, I think it's totally reasonable to hoist BreakpointPrecondition out of Breakpoint. After having had to deal with the nuisance of not being able to forward declare nested classes, I try to avoid them in general.

Yeah, I was kinda iffy on this, but if you (and possibly others) think this is reasonable, I might go with this option. The only thing that would change is the callback would return a BreakpointPreconditionSP instead of void, and AddExceptionPrecondition would be the one to modify the breakpoint. I don't think the core idea would change much but the implementation might be slightly nicer. Let me know if you prefer that.

[labath]

Moving BreakpointPrecondition to a forward-declarable place sounds good to me.

source/Target/ObjCLanguageRuntime.cpp

379 ↗

(On Diff #204212)

Shouldn't you be checking the language here or something. Given that you're iterating over all plugins, won't this set the precondition unconditionally (:P) on all exception breakpoints?

384 ↗

(On Diff #204212)

new doesn't fail

[xiaobai]

In D63181#1539620, @labath wrote:

Moving BreakpointPrecondition to a forward-declarable place sounds good to me.

Alright, so I think I'll go ahead and change this patch to make that happen. Thanks for your input! :)

source/Target/ObjCLanguageRuntime.cpp

379 ↗

(On Diff #204212)

It will! For some reason I added a language paramter but forgot to use it. Thanks for pointing that out.

[xiaobai]

Implement suggestion
Address feedback

[jingham]

In D63181#1539292, @xiaobai wrote:

In D63181#1539291, @JDevlieghere wrote:

Have you considered making just AddExceptionPrecondition virtual? Wouldn't that solve the problem too, without the code duplication of making CreateExceptionBreakpoint virtual?

I don't believe so. As I understand it, you might not have a process yet when you call LanguageRuntime::CreateExceptionBreakpoint from Target, so you won't have an instance of LanguageRuntime. You could create an instance of a LanguageRuntime object with a nullptr process just to invoke it as an instance method, but that seems like the wrong choice to me. All this combined has led me to believe that AddExceptionPrecondition needs to get a callback to a static function from PluginManager.

That's right. The reason that this is necessary is that there were MacOS versions for a while where both the ObjC V1 and ObjC V2 runtimes were available on the same system. And since you could have a C main executable that loaded ObjC code after it was launched, you couldn't a priori tell what ObjC runtime was going to be in force till you saw the runtime actually get loaded. Since you could set an ObjC throw breakpoint, then run the process, we have to delay everything about choosing the actual exception breakpoint and its associated behaviors till after the process was launched.

That's also why setting exception breakpoints is a little contorted as well.

In the fullness of time we should get an lldb that could debug more than one version of swift in a single lldb, putting us back in this situation again. So I think we should maintain this bit of complexity.

Also, I think it's totally reasonable to hoist BreakpointPrecondition out of Breakpoint. After having had to deal with the nuisance of not being able to forward declare nested classes, I try to avoid them in general.

Yeah, I was kinda iffy on this, but if you (and possibly others) think this is reasonable, I might go with this option. The only thing that would change is the callback would return a BreakpointPreconditionSP instead of void, and AddExceptionPrecondition would be the one to modify the breakpoint. I don't think the core idea would change much but the implementation might be slightly nicer. Let me know if you prefer that.

[jingham]

This looks fine to me.

lldb/include/lldb/Breakpoint/Breakpoint.h

public:
   private:
     lldb::BreakpointEventType m_breakpoint_event;
     lldb::BreakpointSP m_new_breakpoint_sp;
     BreakpointLocationCollection m_locations;
 
     DISALLOW_COPY_AND_ASSIGN(BreakpointEventData);
   };
 
-  class BreakpointPrecondition {
-  public:
-    virtual ~BreakpointPrecondition() = default;
-
-    virtual bool EvaluatePrecondition(StoppointCallbackContext &context);
-
-    virtual Status ConfigurePrecondition(Args &options);
-
-    virtual void GetDescription(Stream &stream, lldb::DescriptionLevel level);
-  };
-
-  typedef std::shared_ptr<BreakpointPrecondition> BreakpointPreconditionSP;
-
   // Saving & restoring breakpoints:
   static lldb::BreakpointSP CreateFromStructuredData(
       Target &target, StructuredData::ObjectSP &data_object_sp, Status &error);
 
   static bool
   SerializedBreakpointMatchesNames(StructuredData::ObjectSP &bkpt_object_sp,
                                    std::vector<std::string> &names);
 
public:
   ///
   /// Used to define fancy breakpoints that can do dynamic hit detection
   /// without taking up the condition slot - which really belongs to the user
   /// anyway...
   ///
   /// The Precondition should not continue the target, it should return true
   /// if the condition says to stop and false otherwise.
   ///
-  void SetPrecondition(BreakpointPreconditionSP precondition_sp) {
+  void SetPrecondition(lldb::BreakpointPreconditionSP precondition_sp) {
     m_precondition_sp = precondition_sp;
   }
 
   bool EvaluatePrecondition(StoppointCallbackContext &context);
 
-  BreakpointPreconditionSP GetPrecondition() { return m_precondition_sp; }
-  
+  lldb::BreakpointPreconditionSP GetPrecondition() { return m_precondition_sp; }
   // Produces the OR'ed values for all the names assigned to this breakpoint.
   const BreakpointName::Permissions &GetPermissions() const { 
       return m_permissions; 
   }
 
   BreakpointName::Permissions &GetPermissions() { 
       return m_permissions; 
   }
private:
   std::unordered_set<std::string> m_name_list; // If not empty, this is the name
                                                // of this breakpoint (many
                                                // breakpoints can share the same
                                                // name.)
   lldb::SearchFilterSP
       m_filter_sp; // The filter that constrains the breakpoint's domain.
   lldb::BreakpointResolverSP
       m_resolver_sp; // The resolver that defines this breakpoint.
-  BreakpointPreconditionSP m_precondition_sp; // The precondition is a
-                                              // breakpoint-level hit filter
-                                              // that can be used
+  lldb::BreakpointPreconditionSP m_precondition_sp; // The precondition is a
+                                                    // breakpoint-level hit
+                                                    // filter that can be used
   // to skip certain breakpoint hits.  For instance, exception breakpoints use
   // this to limit the stop to certain exception classes, while leaving the
   // condition & callback free for user specification.
   std::unique_ptr<BreakpointOptions>
       m_options_up; // Settable breakpoint options
   BreakpointLocationList
       m_locations; // The list of locations currently found for this breakpoint.
   std::string m_kind_description;

lldb/include/lldb/Breakpoint/BreakpointPrecondition.h

+//===-- BreakpointPrecondition.h --------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_BreakpointPrecondition_h_
+#define liblldb_BreakpointPrecondition_h_
+
+#include "lldb/lldb-enumerations.h"
+
+namespace lldb_private {
+
+class Args;
+class Status;
+class StoppointCallbackContext;
+class Stream;
+
+class BreakpointPrecondition {
+public:
+  virtual ~BreakpointPrecondition() = default;
+  virtual bool EvaluatePrecondition(StoppointCallbackContext &context);
+  virtual Status ConfigurePrecondition(Args &args);
+  virtual void GetDescription(Stream &stream, lldb::DescriptionLevel level);
+};
+} // namespace lldb_private
+
+#endif

lldb/include/lldb/Core/PluginManager.h

public:
   static bool UnregisterPlugin(LanguageCreateInstance create_callback);
 
   static LanguageCreateInstance GetLanguageCreateCallbackAtIndex(uint32_t idx);
 
   static LanguageCreateInstance
   GetLanguageCreateCallbackForPluginName(ConstString name);
 
   // LanguageRuntime
-  static bool
-  RegisterPlugin(ConstString name, const char *description,
-                 LanguageRuntimeCreateInstance create_callback,
-                 LanguageRuntimeGetCommandObject command_callback = nullptr);
+  static bool RegisterPlugin(
+      ConstString name, const char *description,
+      LanguageRuntimeGetCommandObject command_callback = nullptr,
+      LanguageRuntimeGetExceptionPrecondition precondition_callback = nullptr);
 
   static bool UnregisterPlugin(LanguageRuntimeCreateInstance create_callback);
 
   static LanguageRuntimeCreateInstance
   GetLanguageRuntimeCreateCallbackAtIndex(uint32_t idx);
 
   static LanguageRuntimeGetCommandObject
   GetLanguageRuntimeGetCommandObjectAtIndex(uint32_t idx);
 
+  static LanguageRuntimeGetExceptionPrecondition
+  GetLanguageRuntimeGetExceptionPreconditionAtIndex(uint32_t idx);
+
   static LanguageRuntimeCreateInstance
   GetLanguageRuntimeCreateCallbackForPluginName(ConstString name);
 
   // SystemRuntime
   static bool RegisterPlugin(ConstString name, const char *description,
                              SystemRuntimeCreateInstance create_callback);
 
   static bool UnregisterPlugin(SystemRuntimeCreateInstance create_callback);

lldb/include/lldb/Target/LanguageRuntime.h

virtual bool ExceptionBreakpointsExplainStop(lldb::StopInfoSP stop_reason) {
     return false;
   }
 
   static lldb::BreakpointSP
   CreateExceptionBreakpoint(Target &target, lldb::LanguageType language,
                             bool catch_bp, bool throw_bp,
                             bool is_internal = false);
 
-  static Breakpoint::BreakpointPreconditionSP
-  CreateExceptionPrecondition(lldb::LanguageType language, bool catch_bp,
-                              bool throw_bp);
+  static lldb::BreakpointPreconditionSP
+  GetExceptionPrecondition(lldb::LanguageType language, bool throw_bp);
 
   virtual lldb::ValueObjectSP GetExceptionObjectForThread(
       lldb::ThreadSP thread_sp) {
     return lldb::ValueObjectSP();
   }
 
   virtual lldb::ThreadSP GetBacktraceThreadFromException(
       lldb::ValueObjectSP thread_sp) {

lldb/include/lldb/Target/ObjCLanguageRuntime.h

 
 #include <functional>
 #include <map>
 #include <memory>
 #include <unordered_set>
 
 #include "llvm/Support/Casting.h"
 
+#include "lldb/Breakpoint/BreakpointPrecondition.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/ThreadSafeDenseMap.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/DeclVendor.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/lldb-private.h"
 
public:
 
     virtual CompilerType RealizeType(clang::ASTContext &ast_ctx,
                                      const char *name, bool for_expression) = 0;
 
   protected:
     std::unique_ptr<ClangASTContext> m_scratch_ast_ctx_up;
   };
 
-  class ObjCExceptionPrecondition : public Breakpoint::BreakpointPrecondition {
+  class ObjCExceptionPrecondition : public BreakpointPrecondition {
   public:
     ObjCExceptionPrecondition();
 
     ~ObjCExceptionPrecondition() override = default;
 
     bool EvaluatePrecondition(StoppointCallbackContext &context) override;
     void GetDescription(Stream &stream, lldb::DescriptionLevel level) override;
     Status ConfigurePrecondition(Args &args) override;
 
   protected:
     void AddClassName(const char *class_name);
 
   private:
     std::unordered_set<std::string> m_class_names;
   };
 
+  static lldb::BreakpointPreconditionSP
+  GetBreakpointExceptionPrecondition(lldb::LanguageType language,
+                                     bool throw_bp);
+
   class TaggedPointerVendor {
   public:
     virtual ~TaggedPointerVendor() = default;
 
     virtual bool IsPossibleTaggedPointer(lldb::addr_t ptr) = 0;
 
     virtual ObjCLanguageRuntime::ClassDescriptorSP
     GetClassDescriptor(lldb::addr_t ptr) = 0;

lldb/include/lldb/lldb-forward.h

 class BreakpointIDList;
 class BreakpointList;
 class BreakpointLocation;
 class BreakpointLocationCollection;
 class BreakpointLocationList;
 class BreakpointName;
 class BreakpointOptionGroup;
 class BreakpointOptions;
+class BreakpointPrecondition;
 class BreakpointResolver;
 class BreakpointSite;
 class BreakpointSiteList;
 class BroadcastEventSpec;
 class Broadcaster;
 class BroadcasterManager;
 class ClangASTContext;
 class ClangASTImporter;

 typedef std::shared_ptr<lldb_private::Baton> BatonSP;
 typedef std::shared_ptr<lldb_private::Block> BlockSP;
 typedef std::shared_ptr<lldb_private::Breakpoint> BreakpointSP;
 typedef std::weak_ptr<lldb_private::Breakpoint> BreakpointWP;
 typedef std::shared_ptr<lldb_private::BreakpointSite> BreakpointSiteSP;
 typedef std::weak_ptr<lldb_private::BreakpointSite> BreakpointSiteWP;
 typedef std::shared_ptr<lldb_private::BreakpointLocation> BreakpointLocationSP;
 typedef std::weak_ptr<lldb_private::BreakpointLocation> BreakpointLocationWP;
+typedef std::shared_ptr<lldb_private::BreakpointPrecondition> BreakpointPreconditionSP;
 typedef std::shared_ptr<lldb_private::BreakpointResolver> BreakpointResolverSP;
 typedef std::shared_ptr<lldb_private::Broadcaster> BroadcasterSP;
 typedef std::shared_ptr<lldb_private::BroadcasterManager> BroadcasterManagerSP;
 typedef std::weak_ptr<lldb_private::BroadcasterManager> BroadcasterManagerWP;
 typedef std::unique_ptr<lldb_private::ClangASTContext> ClangASTContextUP;
 typedef std::shared_ptr<lldb_private::ClangASTImporter> ClangASTImporterSP;
 typedef std::unique_ptr<lldb_private::ClangModulesDeclVendor>
     ClangModulesDeclVendorUP;

lldb/include/lldb/lldb-private-interfaces.h

typedef EmulateInstruction *(*EmulateInstructionCreateInstance)(
     const ArchSpec &arch, InstructionType inst_type);
 typedef OperatingSystem *(*OperatingSystemCreateInstance)(Process *process,
                                                           bool force);
 typedef Language *(*LanguageCreateInstance)(lldb::LanguageType language);
 typedef LanguageRuntime *(*LanguageRuntimeCreateInstance)(
     Process *process, lldb::LanguageType language);
 typedef lldb::CommandObjectSP (*LanguageRuntimeGetCommandObject)(
     CommandInterpreter &interpreter);
+typedef lldb::BreakpointPreconditionSP (
+    *LanguageRuntimeGetExceptionPrecondition)(lldb::LanguageType language,
+                                              bool throw_bp);
 typedef lldb::StructuredDataPluginSP (*StructuredDataPluginCreateInstance)(
     Process &process);
 typedef Status (*StructuredDataFilterLaunchInfo)(ProcessLaunchInfo &launch_info,
                                                  Target *target);
 typedef SystemRuntime *(*SystemRuntimeCreateInstance)(Process *process);
 typedef lldb::PlatformSP (*PlatformCreateInstance)(bool force,
                                                    const ArchSpec *arch);
 typedef lldb::ProcessSP (*ProcessCreateInstance)(

lldb/source/Breakpoint/Breakpoint.cpp

 //===-- Breakpoint.cpp ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Casting.h"
 
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/BreakpointLocationCollection.h"
+#include "lldb/Breakpoint/BreakpointPrecondition.h"
 #include "lldb/Breakpoint/BreakpointResolver.h"
 #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/SearchFilter.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Target/SectionLoadList.h"

 
 bool Breakpoint::EvaluatePrecondition(StoppointCallbackContext &context) {
   if (!m_precondition_sp)
     return true;
 
   return m_precondition_sp->EvaluatePrecondition(context);
 }
 
-bool Breakpoint::BreakpointPrecondition::EvaluatePrecondition(
-    StoppointCallbackContext &context) {
-  return true;
-}
-
-void Breakpoint::BreakpointPrecondition::GetDescription(
-    Stream &stream, lldb::DescriptionLevel level) {}
-
-Status
-Breakpoint::BreakpointPrecondition::ConfigurePrecondition(Args &options) {
-  Status error;
-  error.SetErrorString("Base breakpoint precondition has no options.");
-  return error;
-}
-
 void Breakpoint::SendBreakpointChangedEvent(
     lldb::BreakpointEventType eventKind) {
   if (!m_being_created && !IsInternal() &&
       GetTarget().EventTypeHasListeners(
           Target::eBroadcastBitBreakpointChanged)) {
     BreakpointEventData *data =
         new Breakpoint::BreakpointEventData(eventKind, shared_from_this());
 

lldb/source/Breakpoint/BreakpointPrecondition.cpp

+//===-- BreakpointPrecondition.cpp ------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Breakpoint/BreakpointPrecondition.h"
+#include "lldb/Utility/Status.h"
+
+using namespace lldb_private;
+
+bool BreakpointPrecondition::EvaluatePrecondition(
+    StoppointCallbackContext &context) {
+  return false;
+}
+
+void BreakpointPrecondition::GetDescription(Stream &stream,
+                                            lldb::DescriptionLevel level) {}
+
+Status BreakpointPrecondition::ConfigurePrecondition(Args &args) {
+  Status error;
+  error.SetErrorString("Base breakpoint precondition has no options.");
+  return error;
+}

lldb/source/Breakpoint/CMakeLists.txt

 add_lldb_library(lldbBreakpoint
   Breakpoint.cpp
   BreakpointID.cpp
   BreakpointIDList.cpp
   BreakpointList.cpp
   BreakpointLocation.cpp
   BreakpointLocationCollection.cpp
   BreakpointLocationList.cpp
   BreakpointName.cpp
   BreakpointOptions.cpp
+  BreakpointPrecondition.cpp
   BreakpointResolver.cpp
   BreakpointResolverAddress.cpp
   BreakpointResolverFileLine.cpp
   BreakpointResolverFileRegex.cpp
   BreakpointResolverName.cpp
   BreakpointResolverScripted.cpp
   BreakpointSite.cpp
   BreakpointSiteList.cpp

lldb/source/Core/PluginManager.cpp

 
 struct LanguageRuntimeInstance {
   LanguageRuntimeInstance() : name(), description(), create_callback(nullptr) {}
 
   ConstString name;
   std::string description;
   LanguageRuntimeCreateInstance create_callback;
   LanguageRuntimeGetCommandObject command_callback;
+  LanguageRuntimeGetExceptionPrecondition precondition_callback;
 };
 
 typedef std::vector<LanguageRuntimeInstance> LanguageRuntimeInstances;
 
 static std::recursive_mutex &GetLanguageRuntimeMutex() {
   static std::recursive_mutex g_instances_mutex;
   return g_instances_mutex;
 }
 
 static LanguageRuntimeInstances &GetLanguageRuntimeInstances() {
   static LanguageRuntimeInstances g_instances;
   return g_instances;
 }
 
 bool PluginManager::RegisterPlugin(
     ConstString name, const char *description,
     LanguageRuntimeCreateInstance create_callback,
-    LanguageRuntimeGetCommandObject command_callback) {
+    LanguageRuntimeGetCommandObject command_callback,
+    LanguageRuntimeGetExceptionPrecondition precondition_callback) {
   if (create_callback) {
     LanguageRuntimeInstance instance;
     assert((bool)name);
     instance.name = name;
     if (description && description[0])
       instance.description = description;
     instance.create_callback = create_callback;
     instance.command_callback = command_callback;
+    instance.precondition_callback = precondition_callback;
     std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
     GetLanguageRuntimeInstances().push_back(instance);
   }
   return false;
 }
 
 bool PluginManager::UnregisterPlugin(
     LanguageRuntimeCreateInstance create_callback) {

 PluginManager::GetLanguageRuntimeGetCommandObjectAtIndex(uint32_t idx) {
   std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
   LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances();
   if (idx < instances.size())
     return instances[idx].command_callback;
   return nullptr;
 }
 
+LanguageRuntimeGetExceptionPrecondition
+PluginManager::GetLanguageRuntimeGetExceptionPreconditionAtIndex(uint32_t idx) {
+  std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
+  LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances();
+  if (idx < instances.size())
+    return instances[idx].precondition_callback;
+  return nullptr;
+}
+
 LanguageRuntimeCreateInstance
 PluginManager::GetLanguageRuntimeCreateCallbackForPluginName(
     ConstString name) {
   if (name) {
     std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
     LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances();
 
     LanguageRuntimeInstances::iterator pos, end = instances.end();

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

else
       return nullptr;
   } else
     return nullptr;
 }
 
 void AppleObjCRuntimeV1::Initialize() {
   PluginManager::RegisterPlugin(
       GetPluginNameStatic(), "Apple Objective-C Language Runtime - Version 1",
-      CreateInstance);
+      CreateInstance,
+      /*command_callback = */ nullptr, GetBreakpointExceptionPrecondition);
 }
 
 void AppleObjCRuntimeV1::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }
 
 lldb_private::ConstString AppleObjCRuntimeV1::GetPluginNameStatic() {
   static ConstString g_name("apple-objc-v1");

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

 };
 
 void AppleObjCRuntimeV2::Initialize() {
   PluginManager::RegisterPlugin(
       GetPluginNameStatic(), "Apple Objective-C Language Runtime - Version 2",
       CreateInstance,
       [](CommandInterpreter &interpreter) -> lldb::CommandObjectSP {
         return CommandObjectSP(new CommandObjectMultiwordObjC(interpreter));
-      });
+      },
+      GetBreakpointExceptionPrecondition);
 }
 
 void AppleObjCRuntimeV2::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }
 
 lldb_private::ConstString AppleObjCRuntimeV2::GetPluginNameStatic() {
   static ConstString g_name("apple-objc-v2");

lldb/source/Target/LanguageRuntime.cpp

 //===-- LanguageRuntime.cpp -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/SearchFilter.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Target/Language.h"
-#include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 char LanguageRuntime::ID = 0;
 
 ExceptionSearchFilter::ExceptionSearchFilter(const lldb::TargetSP &target_sp,
LanguageRuntime *LanguageRuntime::FindPlugin(Process *process,
 
   return nullptr;
 }
 
 LanguageRuntime::LanguageRuntime(Process *process) : m_process(process) {}
 
 LanguageRuntime::~LanguageRuntime() = default;
 
-Breakpoint::BreakpointPreconditionSP
-LanguageRuntime::CreateExceptionPrecondition(lldb::LanguageType language,
-                                             bool catch_bp, bool throw_bp) {
-  switch (language) {
-  case eLanguageTypeObjC:
-    if (throw_bp)
-      return Breakpoint::BreakpointPreconditionSP(
-          new ObjCLanguageRuntime::ObjCExceptionPrecondition());
-    break;
-  default:
-    break;
+BreakpointPreconditionSP
+LanguageRuntime::GetExceptionPrecondition(LanguageType language,
+                                          bool throw_bp) {
+  LanguageRuntimeCreateInstance create_callback;
+  for (uint32_t idx = 0;
+       (create_callback =
+            PluginManager::GetLanguageRuntimeCreateCallbackAtIndex(idx)) !=
+       nullptr;
+       idx++) {
+    if (auto precondition_callback =
+            PluginManager::GetLanguageRuntimeGetExceptionPreconditionAtIndex(
+                idx)) {
+      if (BreakpointPreconditionSP precond =
+              precondition_callback(language, throw_bp))
+        return precond;
+    }
   }
-  return Breakpoint::BreakpointPreconditionSP();
+  return BreakpointPreconditionSP();
 }
 
 BreakpointSP LanguageRuntime::CreateExceptionBreakpoint(
     Target &target, lldb::LanguageType language, bool catch_bp, bool throw_bp,
     bool is_internal) {
   BreakpointResolverSP resolver_sp(
       new ExceptionBreakpointResolver(language, catch_bp, throw_bp));
   SearchFilterSP filter_sp(
       new ExceptionSearchFilter(target.shared_from_this(), language));
   bool hardware = false;
   bool resolve_indirect_functions = false;
   BreakpointSP exc_breakpt_sp(
       target.CreateBreakpoint(filter_sp, resolver_sp, is_internal, hardware,
                               resolve_indirect_functions));
   if (exc_breakpt_sp) {
-    Breakpoint::BreakpointPreconditionSP precondition_sp =
-        CreateExceptionPrecondition(language, catch_bp, throw_bp);
-    if (precondition_sp)
-      exc_breakpt_sp->SetPrecondition(precondition_sp);
+    if (auto precond = GetExceptionPrecondition(language, throw_bp))
+      exc_breakpt_sp->SetPrecondition(precond);
 
     if (is_internal)
       exc_breakpt_sp->SetBreakpointKind("exception");
   }
 
   return exc_breakpt_sp;
 }
 
if (LanguageRuntimeGetCommandObject command_callback =
         // and cached because we may create multiple debuggers and need one
         // instance of the command each - the implementing function is meant to
         // create a new instance of the command each time it is invoked.
         parent->LoadSubCommand(command->GetCommandName().str().c_str(), command);
       }
     }
   }
 }
-

lldb/source/Target/ObjCLanguageRuntime.cpp

bool ObjCLanguageRuntime::GetTypeBitSize(const CompilerType &compiler_type,
 
   size = 8 * (max_offset + sizeof_max);
   if (found)
     m_type_size_cache.Insert(opaque_ptr, size);
 
   return found;
 }
 
+lldb::BreakpointPreconditionSP
+ObjCLanguageRuntime::GetBreakpointExceptionPrecondition(LanguageType language,
+                                                        bool throw_bp) {
+  if (language != eLanguageTypeObjC)
+    return lldb::BreakpointPreconditionSP();
+  if (!throw_bp)
+    return lldb::BreakpointPreconditionSP();
+  BreakpointPreconditionSP precondition_sp(
+      new ObjCLanguageRuntime::ObjCExceptionPrecondition());
+  return precondition_sp;
+}
+
 // Exception breakpoint Precondition class for ObjC:
 void ObjCLanguageRuntime::ObjCExceptionPrecondition::AddClassName(
     const char *class_name) {
   m_class_names.insert(class_name);
 }
 
 ObjCLanguageRuntime::ObjCExceptionPrecondition::ObjCExceptionPrecondition() {}
 

lldb/source/Target/Target.cpp

 //===-- Target.cpp ----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/Target.h"
 #include "Plugins/ExpressionParser/Clang/ClangASTSource.h"
 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
 #include "lldb/Breakpoint/BreakpointIDList.h"
+#include "lldb/Breakpoint/BreakpointPrecondition.h"
 #include "lldb/Breakpoint/BreakpointResolver.h"
 #include "lldb/Breakpoint/BreakpointResolverAddress.h"
 #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
 #include "lldb/Breakpoint/BreakpointResolverFileRegex.h"
 #include "lldb/Breakpoint/BreakpointResolverName.h"
 #include "lldb/Breakpoint/BreakpointResolverScripted.h"
 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Core/Debugger.h"

 
 lldb::BreakpointSP
 Target::CreateExceptionBreakpoint(enum lldb::LanguageType language,
                                   bool catch_bp, bool throw_bp, bool internal,
                                   Args *additional_args, Status *error) {
   BreakpointSP exc_bkpt_sp = LanguageRuntime::CreateExceptionBreakpoint(
       *this, language, catch_bp, throw_bp, internal);
   if (exc_bkpt_sp && additional_args) {
-    Breakpoint::BreakpointPreconditionSP precondition_sp =
-        exc_bkpt_sp->GetPrecondition();
+    BreakpointPreconditionSP precondition_sp = exc_bkpt_sp->GetPrecondition();
     if (precondition_sp && additional_args) {
       if (error)
         *error = precondition_sp->ConfigurePrecondition(*additional_args);
       else
         precondition_sp->ConfigurePrecondition(*additional_args);
     }
   }
   return exc_bkpt_sp;