Renamed Target::GetSharedModule to AddModule, allow for ModulesDidLoad to be delayed when batch adding Modules

[jasonmolenda]

Summary

I'm addressing a perf issue where DynamicLoaderDarwin has been notified that a batch of solibs have been loaded. It adds them to the target one-by-one with Target::GetSharedModule(), and then calls Target::ModulesDidLoad() to give breakpoints a chance to evaluate for new locations, etc. One of the things we do on ModulesDidLoad is call ProcessGDBRemote::ModulesDidLoad which will send the qSymbol packet to the gdb remote serial protocol stub if it indicates it wants to know a symbol address. Currently, because Target::GetSharedModule() calls ModulesDidLoad, we will send the qSymbol packet many times - an app with hundreds of solibs are not unusual.

This patch renames Target::GetSharedModule to Target::AddModule() which better reflects what it actually does -- given a ModuleSpec set of criteria, it finds that binary on the local system and adds it to the Target, if it isn't already present. This method name has confused all of us at one point or another. As DynamicLoaderWindowsDYLD notes,

// Confusingly, there is no Target::AddSharedModule.  Instead, calling
// GetSharedModule() with a new module will add it to the module list and
// return a corresponding ModuleSP.

It adds a flag to Target::AddModule to suppress notification of the new Module (i.e. don't call ModulesDidLoad) - if the caller does this, the caller must call Target::ModulesDidLoad before resuming execution. I added a description of the method in Target.h to make this clear.

I also had to add flag to ModuleList::Append and ModuleList::AppendIfNeeded. I made these have default values because many uses of this are in a loop creating a standalone ModuleList, and forcing all of them to specify the notify boolean was nonintuitive for those users. When a ModuleList is a part of the Target, it has notifier callback functions, but when it is a standalone object, it doesn't.

I'm trying to think of how to test this -- but the problem I'm directly trying to address, the qSymbol packet being sent for every solib, instead of the # of groups of solib's that are loaded, is something we don't track today. I'll continue to think about it.

rdar://problem/48293064

[clayborg]

include/lldb/Target/Target.h

535

Pavel had questions about this error. If we specify an error when we call this, is there a way to get a valid module shared pointer back and still get an error? Maybe this should be one of the llvm::ErrorOr return types?

source/Commands/CommandObjectTarget.cpp

399–400

Remove all "const bool notify = true; "statements and Inline with comment?

ModuleSP module_sp = target_sp->AddModule(main_module_spec, 
                                          true /*notify*/);

This would apply everywhere in this patch if so.

[jasonmolenda]

Thanks for looking the patch over.

include/lldb/Target/Target.h

535

There's only a handful of AddModule callers that pass in a Status object - the Windows ones, the CommandObjectTarget command, and the Minidump. I'll look through the Platform GetSharedModules implementations tomorrow to see who might put useful things in the error object, but in general either AddModule finds a binary that matches the ModuleSpec, and returns a shared pointer to it, or finds nothing and returns an empty shared pointer. The error object may have a message from a Platform indicating why the search failed ("could not find any SDK directories" or something) but I suspect this optional Status arg isn't doing anything.

source/Commands/CommandObjectTarget.cpp

399–400

Can do. I don't have a preference.

[labath]

Thank you for taking the time to rename this function. I think this has been long overdue. However, I believe that the name AddModule might cause confusion coming from the other direction, as now one may think that it unconditionally adds a new module to the target (which also isn't true, as it will just reuse the existing one if it's already there). Maybe something like GetOrCreateModule would be better (and also in line with how llvm names these kinds of things)?

As for testing, doesn't this cause a eBroadcastBitModulesLoaded event to be sent through some SB API. You could subscribe to that and check that it comes only ~once, and contains the right modules. This won't test exactly the thing you're interested in, but it might be close enough.

[jasonmolenda]

OK looked things over a bit.

I think there's a case for adopting llvm::ErrorOr here, and elsewhere across, but today the only place we're using that return type is when the error is encoded in a std::error_code (aka fancy errno). We should have an ErrorOr that uses a Status object to contain the error, I think that's possible? I've seen people use their own objects to return errors with llvm::Expected. In any event, I think a change like this is a little out of scope for what I'm doing in this patch right now.

After spending time looking at all the error handling codepaths related to AddOrCreateModule, if we simply fail to find a binary we return an empty ModuleSP and the platform may set a Status with an error string (e.g. PlatformPOSIX will say no such file) if that's non-nullptr. Or there may be a genuine error - a Target that doesn't have a Platform, we found a binary but it is an explicitly disallowed type (e.g. eTypeStubLibrary, a long-obsolete binary format on Darwin), we can return an error message explaining that to the caller if the Status ptr is non-nullptr.

The important wrinkle with AddOrCreateModule is that most of the callers are deep inside lldb internal mechanisms -- the DynamicLoaders. And for most of those, we're going to handle file-not-found in custom ways, we're not going to relay the error messages. For instance, the user-process DynamicLoaderDarwin, when it fails to find a file, it will call Process::ReadModuleFromMemory(). If the kernel debugging DynamicLoaderDarwinKernel fails to load a kext (a solib), it accumulates a list of kexts that it could not find, and at the end it will present a sorted list of them. These callers have no interest in the returned error message.

On the other hand, a caller like CommandObjectTarget, which is directly driven by user interaction, we must print the error message ("file not found" and such).

So in this particularly API, because only some callers want the error strings, leaving this as an optional argument seems reasonable. An llvm::ErrorOr which returns a ModuleSP or a Status would be a fine - and only the callers that want to print the error message would retrieve the Status object, the others would do their normal behavior when couldn't get the ModuleSP.

[jasonmolenda]

Remove const bool notify's. Rename method to Target::GetOrCreateModule. Refine the method headerdoc a bit.

[labath]

To me, the greatest advantage in using Expected<T> (ErrorOr<T> is the old way of doing things; I wouldn't use that in new code) is greater clarity in what are the possible results of the function. If the function returns the object and the error in two pieces, then this leaves place for uncertainties like "but what is the state of the T object if the function returned an error", or "if the T is invalid (null), can I assume the error object will indicate failure too", etc. Using Expected<T> removes all of these, because if the function returns an error, there is no T object to speak of and vice-versa. (Ok, if T = std::shared_ptr<U>, then this still leaves the possibility of the function returning "success", but with an empty pointer; however, that's still a much smaller problem space).

Whether the caller is able to do something with that error is not that important here. If he doesn't want it, he can always explicitly ignore it (or maybe log it?). So, I would say that changing this function to use Expected<T> is definitely a good thing, but it doesn't have to happen in this patch.

BTW, if you have a Status object, you can convert it to an Expected<T> (via llvm::Error) by calling ToError on it. Also, you don't have to define your own error type if you just want to return some string. StringError (llvm::createStringError) should suffice for that.

[jasonmolenda]

Thanks Pavel, I'll convert this to use Expected<> while I'm working on it. I'm writing a test case right now, and looking at how DynamicPluginDarwin works more closely for adding & removing binaries, e.g. there's also no way to batch remove libraries and have a group broadcast notification be sent. There was also a bug in my original patch for calling LoadScriptingResourceForModule() to find a python resource file in a dSYM bundle - it is currently called from Target::ModuleUpdated when a binary is added to the target's ModuleList, but I'm suppressing that call with this change, so I need to move that over to ModulesDidLoad.

[labath]

In D60172#1455767, @jasonmolenda wrote:

Thanks Pavel, I'll convert this to use Expected<> while I'm working on it. I'm writing a test case right now, and looking at how DynamicPluginDarwin works more closely for adding & removing binaries, e.g. there's also no way to batch remove libraries and have a group broadcast notification be sent. There was also a bug in my original patch for calling LoadScriptingResourceForModule() to find a python resource file in a dSYM bundle - it is currently called from Target::ModuleUpdated when a binary is added to the target's ModuleList, but I'm suppressing that call with this change, so I need to move that over to ModulesDidLoad.

Sounds good to me.

[jasonmolenda]

Added a testcase, TestModuleLoadedNotifys.

Renamed the pure virtual notifier methods in ModuleList to add 'Notify' at the start of their names, updated the names in subclass Target as well. Added a NotifyModulesRemoved and changed ModuleList::Remove(ModuleList&) so that it removes all of the modules one-by-one from the collection and then calls NotifyModulesRemoved() so they are broadcast as a group. I renamed the methods to make it clearer in Target that these are subclass implementations.

Changed Target::SetExecutableModule() so that it will load all dependent libraries without notifying, and send a group notification about all of them once they've been added.

Moved the call to LoadScriptingResourceForModule from Target::NotifyModuleAdded to Target::ModulesDidLoad so DynamicLoader plugins can call ModulesDidLoad with the full list of libraries and still get scripting files loaded.

I tried changing Target::GetOrCreateModule to return Expected<ModuleSP> but I wasn't thrilled with the double-dereference of the returned value when I started updating callers. It wasn't horrible, but it looked messy. I should go back and try again but my first shot at a few of them didn't look great.

I want to hand-test the scripting resource loading a bit on Monday but this is probably about what I'm doing for now. At this point, DynamicLoaderDarwin sends batched notifications on the CreateTarget() binary dependent binaries. It sends a batched notification when we start a real process and throw away all those binaries. It sends out batched notifications when we load the binaries back in via dyld notifications.

include/lldb/Core/ModuleList.h

 /// shared pointers to Module objects.
 //----------------------------------------------------------------------
 class ModuleList {
 public:
   class Notifier {
   public:
     virtual ~Notifier() = default;
 
-    virtual void ModuleAdded(const ModuleList &module_list,
+    virtual void NotifyModuleAdded(const ModuleList &module_list,
                                    const lldb::ModuleSP &module_sp) = 0;
-    virtual void ModuleRemoved(const ModuleList &module_list,
+    virtual void NotifyModuleRemoved(const ModuleList &module_list,
                                      const lldb::ModuleSP &module_sp) = 0;
-    virtual void ModuleUpdated(const ModuleList &module_list,
+    virtual void NotifyModuleUpdated(const ModuleList &module_list,
                                      const lldb::ModuleSP &old_module_sp,
                                      const lldb::ModuleSP &new_module_sp) = 0;
-    virtual void WillClearList(const ModuleList &module_list) = 0;
+    virtual void NotifyWillClearList(const ModuleList &module_list) = 0;
+
+    virtual void NotifyModulesRemoved(lldb_private::ModuleList &module_list) = 0;
   };
 
   //------------------------------------------------------------------
   /// Default constructor.
   ///
   /// Creates an empty list of Module objects.
   //------------------------------------------------------------------
   ModuleList();
public:
   /// \return
   ///     A const reference to this object.
   //------------------------------------------------------------------
   const ModuleList &operator=(const ModuleList &rhs);
 
   //------------------------------------------------------------------
   /// Append a module to the module list.
   ///
-  /// Appends the module to the collection.
-  ///
   /// \param[in] module_sp
   ///     A shared pointer to a module to add to this collection.
+  ///
+  /// \param[in] notify
+  ///     If true, and a notifier function is set, the notifier function
+  ///     will be called.  Defaults to true.
+  ///
+  ///     When this ModuleList is the Target's ModuleList, the notifier 
+  ///     function is Target::ModulesDidLoad -- the call to 
+  ///     ModulesDidLoad may be deferred when adding multiple Modules 
+  ///     to the Target, but it must be called at the end, 
+  ///     before resuming execution.
   //------------------------------------------------------------------
-  void Append(const lldb::ModuleSP &module_sp);
+  void Append(const lldb::ModuleSP &module_sp, bool notify = true);
 
   //------------------------------------------------------------------
   /// Append a module to the module list and remove any equivalent modules.
   /// Equivalent modules are ones whose file, platform file and architecture
   /// matches.
   ///
   /// Replaces the module to the collection.
   ///
   /// \param[in] module_sp
   ///     A shared pointer to a module to replace in this collection.
   //------------------------------------------------------------------
   void ReplaceEquivalent(const lldb::ModuleSP &module_sp);
 
-  bool AppendIfNeeded(const lldb::ModuleSP &module_sp);
+  //------------------------------------------------------------------
+  /// Append a module to the module list, if it is not already there.
+  ///
+  /// \param[in] module_sp
+  ///
+  /// \param[in] notify
+  ///     If true, and a notifier function is set, the notifier function
+  ///     will be called.  Defaults to true.
+  ///
+  ///     When this ModuleList is the Target's ModuleList, the notifier 
+  ///     function is Target::ModulesDidLoad -- the call to 
+  ///     ModulesDidLoad may be deferred when adding multiple Modules 
+  ///     to the Target, but it must be called at the end, 
+  ///     before resuming execution.
+  //------------------------------------------------------------------
+  bool AppendIfNeeded(const lldb::ModuleSP &module_sp, bool notify = true);
 
   void Append(const ModuleList &module_list);
 
   bool AppendIfNeeded(const ModuleList &module_list);
 
   bool ReplaceModule(const lldb::ModuleSP &old_module_sp,
                      const lldb::ModuleSP &new_module_sp);
 
public:
   /// \param[out] output_extern
   ///     All matching addresses not within 'function'
   void FindAddressesForLine(const lldb::TargetSP target_sp,
                             const FileSpec &file, uint32_t line,
                             Function *function,
                             std::vector<Address> &output_local,
                             std::vector<Address> &output_extern);
 
-  bool Remove(const lldb::ModuleSP &module_sp);
+  //------------------------------------------------------------------
+  /// Remove a module from the module list.
+  ///
+  /// \param[in] module_sp
+  ///     A shared pointer to a module to remove from this collection.
+  ///
+  /// \param[in] notify
+  ///     If true, and a notifier function is set, the notifier function
+  ///     will be called.  Defaults to true.
+  ///
+  ///     When this ModuleList is the Target's ModuleList, the notifier 
+  ///     function is Target::ModulesDidUnload -- the call to 
+  ///     ModulesDidUnload may be deferred when removing multiple Modules 
+  ///     from the Target, but it must be called at the end, 
+  ///     before resuming execution.
+  //------------------------------------------------------------------
+  bool Remove(const lldb::ModuleSP &module_sp, bool notify = true);
 
   size_t Remove(ModuleList &module_list);
 
   bool RemoveIfOrphaned(const Module *module_ptr);
 
   size_t RemoveOrphans(bool mandatory);
 
   bool ResolveFileAddress(lldb::addr_t vm_addr, Address &so_addr) const;

include/lldb/Target/Target.h

public:
   static FileSpecList GetDefaultDebugFileSearchPaths();
 
   static FileSpecList GetDefaultClangModuleSearchPaths();
 
   static ArchSpec GetDefaultArchitecture();
 
   static void SetDefaultArchitecture(const ArchSpec &arch);
 
-  lldb::ModuleSP GetSharedModule(const ModuleSpec &module_spec,
+  //------------------------------------------------------------------
+  /// Find a binary on the system and return its Module, 
+  /// or return an existing Module that is already in the Target.
+  ///
+  /// Given a ModuleSpec, find a binary satisifying that specification,
+  /// or identify a matching Module already present in the Target,
+  /// and return a shared pointer to it.
+  ///
+  /// \param[in] module_spec
+  ///     The criteria that must be matched for the binary being loaded.
+  ///     e.g. UUID, architecture, file path.
+  ///
+  /// \param[in] notify
+  ///     If notify is true, and the Module is new to this Target, 
+  ///     Target::ModulesDidLoad will be called.  
+  ///     If notify is false, it is assumed that the caller is adding 
+  ///     multiple Modules and will call ModulesDidLoad with the 
+  ///     full list at the end.
+  ///     ModulesDidLoad must be called when a Module/Modules have
+  ///     been added to the target, one way or the other.
+  ///
+  /// \param[out] error_ptr
+  ///     Optional argument, pointing to a Status object to fill in 
+  ///     with any results / messages while attempting to find/load
+  ///     this binary.  Many callers will be internal functions that
+  ///     will handle / summarize the failures in a custom way and
+  ///     don't use these messages.
+  ///
+  /// \return 
+  ///     An empty ModuleSP will be returned if no matching file
+  ///     was found.  If error_ptr was non-nullptr, an error message
+  ///     will likely be provided.
+  //------------------------------------------------------------------
+  lldb::ModuleSP GetOrCreateModule(const ModuleSpec &module_spec,
+                                   bool notify,
                                    Status *error_ptr = nullptr);
 
   //----------------------------------------------------------------------
   // Settings accessors
   //----------------------------------------------------------------------
 
   static const lldb::TargetPropertiesSP &GetGlobalProperties();
 
   std::recursive_mutex &GetAPIMutex() { return m_mutex; }
void ApplyNameToBreakpoints(BreakpointName &bp_name);
 
   void SetREPL(lldb::LanguageType language, lldb::REPLSP repl_sp);
 
 protected:
   //------------------------------------------------------------------
   /// Implementing of ModuleList::Notifier.
   //------------------------------------------------------------------
 
-  void ModuleAdded(const ModuleList &module_list,
+  void NotifyModuleAdded(const ModuleList &module_list,
                          const lldb::ModuleSP &module_sp) override;
 
-  void ModuleRemoved(const ModuleList &module_list,
+  void NotifyModuleRemoved(const ModuleList &module_list,
                          const lldb::ModuleSP &module_sp) override;
 
-  void ModuleUpdated(const ModuleList &module_list,
+  void NotifyModuleUpdated(const ModuleList &module_list,
                            const lldb::ModuleSP &old_module_sp,
                            const lldb::ModuleSP &new_module_sp) override;
-  void WillClearList(const ModuleList &module_list) override;
+
+  void NotifyWillClearList(const ModuleList &module_list) override;
+
+  void NotifyModulesRemoved(lldb_private::ModuleList &module_list) override;
 
   class Arch {
   public:
     explicit Arch(const ArchSpec &spec);
     const Arch &operator=(const ArchSpec &spec);
 
     const ArchSpec &GetSpec() const { return m_spec; }
     Architecture *GetPlugin() const { return m_plugin_up.get(); }

packages/Python/lldbsuite/test/functionalities/target-new-solib-notifications/Makefile

+LEVEL = ../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/functionalities/target-new-solib-notifications/TestModuleLoadedNotifys.py

+"""
+Test how many times newly loaded binaries are notified;
+they should be delivered in batches instead of one-by-one.
+"""
+
+from __future__ import print_function
+
+
+import os
+import time
+import re
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class ModuleLoadedNotifysTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
+
+    # DyanmicLoaderDarwin should batch up notifications about
+    # newly added/removed libraries.  Other DynamicLoaders may
+    # not be written this way.
+    @skipUnlessDarwin
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line number to break inside main().
+        self.line = line_number('main.cpp', '// breakpoint')
+
+    def test_launch_notifications(self):
+        """Test that lldb broadcasts newly loaded libraries in batches."""
+        self.build()
+        exe = self.getBuildArtifact("a.out")
+        self.dbg.SetAsync(False)
+
+        listener = self.dbg.GetListener()
+        listener.StartListeningForEventClass(
+            self.dbg,
+            lldb.SBTarget.GetBroadcasterClassName(),
+            lldb.SBTarget.eBroadcastBitModulesLoaded | lldb.SBTarget.eBroadcastBitModulesUnloaded)
+
+        # Create a target by the debugger.
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        # break on main
+        breakpoint = target.BreakpointCreateByName('main', 'a.out')
+
+        event = lldb.SBEvent()
+        # CreateTarget() generated modules-loaded events; consume them & toss
+        while listener.GetNextEvent(event):
+            True
+
+        error = lldb.SBError()
+        process = target.Launch(listener,
+                                None,      # argv
+                                None,      # envp
+                                None,      # stdin_path
+                                None,      # stdout_path
+                                None,      # stderr_path
+                                None,      # working directory
+                                0,         # launch flags
+                                False,     # Stop at entry
+                                error)     # error
+
+        self.assertTrue(
+            process.GetState() == lldb.eStateStopped,
+            PROCESS_STOPPED)
+
+        total_solibs_added = 0
+        total_solibs_removed = 0
+        total_modules_added_events = 0
+        total_modules_removed_events = 0
+        while listener.GetNextEvent(event):
+            if lldb.SBTarget.EventIsTargetEvent(event):
+                if event.GetType() == lldb.SBTarget.eBroadcastBitModulesLoaded:
+                    solib_count = lldb.SBTarget.GetNumModulesFromEvent(event)
+                    total_modules_added_events += 1
+                    total_solibs_added += solib_count
+                    if self.TraceOn():
+                        # print all of the binaries that have been added
+                        added_files = []
+                        i = 0
+                        while i < solib_count:
+                            module = lldb.SBTarget.GetModuleAtIndexFromEvent(i, event)
+                            added_files.append(module.GetFileSpec().GetFilename())
+                            i = i + 1
+                        print("Loaded files: %s" % (', '.join(added_files)))
+
+                if event.GetType() == lldb.SBTarget.eBroadcastBitModulesUnloaded:
+                    solib_count = lldb.SBTarget.GetNumModulesFromEvent(event)
+                    total_modules_removed_events += 1
+                    total_solibs_removed += solib_count
+                    if self.TraceOn():
+                        # print all of the binaries that have been removed
+                        removed_files = []
+                        i = 0
+                        while i < solib_count:
+                            module = lldb.SBTarget.GetModuleAtIndexFromEvent(i, event)
+                            removed_files.append(module.GetFileSpec().GetFilename())
+                            i = i + 1
+                        print("Unloaded files: %s" % (', '.join(removed_files)))
+        
+
+        # This is testing that we get back a small number of events with the loaded 
+        # binaries in batches.  Check that we got back more than 1 solib per event.  
+        # In practice on Darwin today, we get back two events for a do-nothing c 
+        # program: a.out and dyld, and then all the rest of the system libraries.
+
+        avg_solibs_added_per_event = int(float(total_solibs_added) / float(total_modules_added_events))
+        self.assertGreater(avg_solibs_added_per_event, 1)

packages/Python/lldbsuite/test/functionalities/target-new-solib-notifications/main.cpp

+#include <stdio.h>
+int main ()
+{
+  puts("running"); // breakpoint here
+  return 0;
+}

source/API/SBTarget.cpp

if (triple)
       module_spec.GetArchitecture() = Platform::GetAugmentedArchSpec(
           target_sp->GetPlatform().get(), triple);
     else
       module_spec.GetArchitecture() = target_sp->GetArchitecture();
 
     if (symfile)
       module_spec.GetSymbolFileSpec().SetFile(symfile, FileSpec::Style::native);
 
-    sb_module.SetSP(target_sp->GetSharedModule(module_spec));
+    sb_module.SetSP(target_sp->GetOrCreateModule(module_spec, true /* notify */));
   }
   return LLDB_RECORD_RESULT(sb_module);
 }
 
 lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) {
   LLDB_RECORD_METHOD(lldb::SBModule, SBTarget, AddModule,
                      (const lldb::SBModuleSpec &), module_spec);
 
   lldb::SBModule sb_module;
   TargetSP target_sp(GetSP());
   if (target_sp)
-    sb_module.SetSP(target_sp->GetSharedModule(*module_spec.m_opaque_up));
+    sb_module.SetSP(target_sp->GetOrCreateModule(*module_spec.m_opaque_up, 
+                                                 true /* notify */));
   return LLDB_RECORD_RESULT(sb_module);
 }
 
 bool SBTarget::AddModule(lldb::SBModule &module) {
   LLDB_RECORD_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &), module);
 
   TargetSP target_sp(GetSP());
   if (target_sp) {

source/Commands/CommandObjectTarget.cpp

if (argc == 1 || core_file || remote_file) {
               module_sp->SetPlatformFileSpec(remote_file);
             }
           }
         }
 
         debugger.GetTargetList().SetSelectedTarget(target_sp.get());
         if (must_set_platform_path) {
           ModuleSpec main_module_spec(file_spec);
-          ModuleSP module_sp = target_sp->GetSharedModule(main_module_spec);
+          ModuleSP module_sp = target_sp->GetOrCreateModule(main_module_spec,
+                                                          true /* notify */);
           if (module_sp)
             module_sp->SetPlatformFileSpec(remote_file);
         }
         if (core_file) {
           char core_path[PATH_MAX];
           core_file.GetPath(core_path, sizeof(core_path));
           if (FileSystem::Instance().Exists(core_file)) {
             if (!FileSystem::Instance().Readable(core_file)) {
               result.AppendMessageWithFormat(
if (target == nullptr) {
           // We are given a UUID only, go locate the file
           ModuleSpec module_spec;
           module_spec.GetUUID() =
               m_uuid_option_group.GetOptionValue().GetCurrentValue();
           if (m_symbol_file.GetOptionValue().OptionWasSet())
             module_spec.GetSymbolFileSpec() =
                 m_symbol_file.GetOptionValue().GetCurrentValue();
           if (Symbols::DownloadObjectAndSymbolFile(module_spec)) {
-            ModuleSP module_sp(target->GetSharedModule(module_spec));
+            ModuleSP module_sp(target->GetOrCreateModule(module_spec,
+                                                 true /* notify */));
             if (module_sp) {
               result.SetStatus(eReturnStatusSuccessFinishResult);
               return true;
             } else {
               StreamString strm;
               module_spec.GetUUID().Dump(&strm);
               if (module_spec.GetFileSpec()) {
                 if (module_spec.GetSymbolFileSpec()) {
if (target == nullptr) {
               module_spec.GetUUID() =
                   m_uuid_option_group.GetOptionValue().GetCurrentValue();
             if (m_symbol_file.GetOptionValue().OptionWasSet())
               module_spec.GetSymbolFileSpec() =
                   m_symbol_file.GetOptionValue().GetCurrentValue();
             if (!module_spec.GetArchitecture().IsValid())
               module_spec.GetArchitecture() = target->GetArchitecture();
             Status error;
-            ModuleSP module_sp(target->GetSharedModule(module_spec, &error));
+            ModuleSP module_sp(target->GetOrCreateModule(module_spec, 
+                                            true /* notify */, &error));
             if (!module_sp) {
               const char *error_cstr = error.AsCString();
               if (error_cstr)
                 result.AppendError(error_cstr);
               else
                 result.AppendErrorWithFormat("unsupported module: %s",
                                              entry.c_str());
               result.SetStatus(eReturnStatusFailed);

source/Core/DynamicLoader.cpp

if (FileSystem::Instance().Exists(executable->GetFileSpec())) {
           executable->GetUUID().IsValid()) {
         if (module_sp->GetUUID() != executable->GetUUID())
           executable.reset();
       } else if (executable->FileHasChanged()) {
         executable.reset();
       }
 
       if (!executable) {
-        executable = target.GetSharedModule(module_spec);
+        executable = target.GetOrCreateModule(module_spec, true /* notify */);
         if (executable.get() != target.GetExecutableModulePointer()) {
           // Don't load dependent images since we are in dyld where we will
           // know and find out about all images that are loaded
           target.SetExecutableModule(executable, eLoadDependentsNo);
         }
       }
     }
   }
ModuleSP DynamicLoader::LoadModuleAtAddress(const FileSpec &file,
   ModuleSP module_sp;
 
   if ((module_sp = modules.FindFirstModule(module_spec))) {
     UpdateLoadedSections(module_sp, link_map_addr, base_addr,
                          base_addr_is_offset);
     return module_sp;
   }
 
-  if ((module_sp = target.GetSharedModule(module_spec))) {
+  if ((module_sp = target.GetOrCreateModule(module_spec, 
+                                            true /* notify */))) {
     UpdateLoadedSections(module_sp, link_map_addr, base_addr,
                          base_addr_is_offset);
     return module_sp;
   }
 
   bool check_alternative_file_name = true;
   if (base_addr_is_offset) {
     // Try to fetch the load address of the file from the process as we need
if (error.Success() && memory_info.GetMapped() &&
       ModuleSpec new_module_spec(FileSpec(memory_info.GetName().AsCString()),
                                  target.GetArchitecture());
 
       if ((module_sp = modules.FindFirstModule(new_module_spec))) {
         UpdateLoadedSections(module_sp, link_map_addr, base_addr, false);
         return module_sp;
       }
 
-      if ((module_sp = target.GetSharedModule(new_module_spec))) {
+      if ((module_sp = target.GetOrCreateModule(new_module_spec, 
+                                                true /* notify */))) {
         UpdateLoadedSections(module_sp, link_map_addr, base_addr, false);
         return module_sp;
       }
     }
   }
 
   if ((module_sp = m_process->ReadModuleFromMemory(file, base_addr))) {
     UpdateLoadedSections(module_sp, link_map_addr, base_addr, false);

source/Core/ModuleList.cpp

 
 ModuleList::~ModuleList() = default;
 
 void ModuleList::AppendImpl(const ModuleSP &module_sp, bool use_notifier) {
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     m_modules.push_back(module_sp);
     if (use_notifier && m_notifier)
-      m_notifier->ModuleAdded(*this, module_sp);
+      m_notifier->NotifyModuleAdded(*this, module_sp);
   }
 }
 
-void ModuleList::Append(const ModuleSP &module_sp) { AppendImpl(module_sp); }
+void ModuleList::Append(const ModuleSP &module_sp, bool notify) { 
+  AppendImpl(module_sp, notify); 
+}
 
 void ModuleList::ReplaceEquivalent(const ModuleSP &module_sp) {
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 
     // First remove any equivalent modules. Equivalent modules are modules
     // whose path, platform path and architecture match.
     ModuleSpec equivalent_module_spec(module_sp->GetFileSpec(),
while (idx < m_modules.size()) {
       else
         ++idx;
     }
     // Now add the new module to the list
     Append(module_sp);
   }
 }
 
-bool ModuleList::AppendIfNeeded(const ModuleSP &module_sp) {
+bool ModuleList::AppendIfNeeded(const ModuleSP &module_sp, bool notify) {
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::iterator pos, end = m_modules.end();
     for (pos = m_modules.begin(); pos != end; ++pos) {
       if (pos->get() == module_sp.get())
         return false; // Already in the list
     }
     // Only push module_sp on the list if it wasn't already in there.
-    Append(module_sp);
+    Append(module_sp, notify);
     return true;
   }
   return false;
 }
 
 void ModuleList::Append(const ModuleList &module_list) {
   for (auto pos : module_list.m_modules)
     Append(pos);

 bool ModuleList::RemoveImpl(const ModuleSP &module_sp, bool use_notifier) {
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::iterator pos, end = m_modules.end();
     for (pos = m_modules.begin(); pos != end; ++pos) {
       if (pos->get() == module_sp.get()) {
         m_modules.erase(pos);
         if (use_notifier && m_notifier)
-          m_notifier->ModuleRemoved(*this, module_sp);
+          m_notifier->NotifyModuleRemoved(*this, module_sp);
         return true;
       }
     }
   }
   return false;
 }
 
 ModuleList::collection::iterator
 ModuleList::RemoveImpl(ModuleList::collection::iterator pos,
                        bool use_notifier) {
   ModuleSP module_sp(*pos);
   collection::iterator retval = m_modules.erase(pos);
   if (use_notifier && m_notifier)
-    m_notifier->ModuleRemoved(*this, module_sp);
+    m_notifier->NotifyModuleRemoved(*this, module_sp);
   return retval;
 }
 
-bool ModuleList::Remove(const ModuleSP &module_sp) {
-  return RemoveImpl(module_sp);
+bool ModuleList::Remove(const ModuleSP &module_sp, bool notify) {
+  return RemoveImpl(module_sp, notify);
 }
 
 bool ModuleList::ReplaceModule(const lldb::ModuleSP &old_module_sp,
                                const lldb::ModuleSP &new_module_sp) {
   if (!RemoveImpl(old_module_sp, false))
     return false;
   AppendImpl(new_module_sp, false);
   if (m_notifier)
-    m_notifier->ModuleUpdated(*this, old_module_sp, new_module_sp);
+    m_notifier->NotifyModuleUpdated(*this, old_module_sp, new_module_sp);
   return true;
 }
 
 bool ModuleList::RemoveIfOrphaned(const Module *module_ptr) {
   if (module_ptr) {
     std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::iterator pos, end = m_modules.end();
     for (pos = m_modules.begin(); pos != end; ++pos) {
size_t ModuleList::RemoveOrphans(bool mandatory) {
   return remove_count;
 }
 
 size_t ModuleList::Remove(ModuleList &module_list) {
   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
   size_t num_removed = 0;
   collection::iterator pos, end = module_list.m_modules.end();
   for (pos = module_list.m_modules.begin(); pos != end; ++pos) {
-    if (Remove(*pos))
+    if (Remove(*pos, false /* notify */))
       ++num_removed;
   }
+  if (m_notifier)
+    m_notifier->NotifyModulesRemoved(module_list);
   return num_removed;
 }
 
 void ModuleList::Clear() { ClearImpl(); }
 
 void ModuleList::Destroy() { ClearImpl(); }
 
 void ModuleList::ClearImpl(bool use_notifier) {
   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
   if (use_notifier && m_notifier)
-    m_notifier->WillClearList(*this);
+    m_notifier->NotifyWillClearList(*this);
   m_modules.clear();
 }
 
 Module *ModuleList::GetModulePointerAtIndex(size_t idx) const {
   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
   return GetModulePointerAtIndexUnlocked(idx);
 }
 

source/Expression/FunctionCaller.cpp

if (m_parser->GetGenerateDebugInfo()) {
     lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule());
 
     if (jit_module_sp) {
       ConstString const_func_name(FunctionName());
       FileSpec jit_file;
       jit_file.GetFilename() = const_func_name;
       jit_module_sp->SetFileSpecAndObjectName(jit_file, ConstString());
       m_jit_module_wp = jit_module_sp;
-      process->GetTarget().GetImages().Append(jit_module_sp);
+      process->GetTarget().GetImages().Append(jit_module_sp, 
+                                              true /* notify */);
     }
   }
   if (process && m_jit_start_addr)
     m_jit_process_wp = process->shared_from_this();
 
   m_JITted = true;
 
   return true;

source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

if (!m_module_sp && m_uuid.IsValid()) {
       }
 
       // Ask the Target to find this file on the local system, if possible.
       // This will search in the list of currently-loaded files, look in the
       // standard search paths on the system, and on a Mac it will try calling
       // the DebugSymbols framework with the UUID to find the binary via its
       // search methods.
       if (!m_module_sp) {
-        m_module_sp = target.GetSharedModule(module_spec);
+        m_module_sp = target.GetOrCreateModule(module_spec, true /* notify */);
       }
 
       if (IsKernel() && !m_module_sp) {
         Stream *s = target.GetDebugger().GetOutputFile().get();
         if (s) {
           s->Printf("WARNING: Unable to locate kernel binary on the debugger "
                     "system.\n");
         }

source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp

if (module_sp->GetUUID() != executable->GetUUID())
       executable.reset();
   } else if (executable->FileHasChanged())
     executable.reset();
 
   if (executable.get())
     return executable;
 
   // TODO: What case is this code used?
-  executable = target.GetSharedModule(module_spec);
+  executable = target.GetOrCreateModule(module_spec, true /* notify */);
   if (executable.get() != target.GetExecutableModulePointer()) {
     // Don't load dependent images since we are in dyld where we will know and
     // find out about all images that are loaded
     target.SetExecutableModule(executable, eLoadDependentsNo);
   }
 
   return executable;
 }

source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

if (module_sp && !module_spec.GetUUID().IsValid() &&
     // modification time of the file on disk
     if (module_sp->GetModificationTime() !=
         FileSystem::Instance().GetModificationTime(module_sp->GetFileSpec()))
       module_sp.reset();
   }
 
   if (!module_sp) {
     if (can_create) {
-      module_sp = target.GetSharedModule(module_spec);
+      // We'll call Target::ModulesDidLoad after all the modules have been
+      // added to the target, don't let it be called for every one.
+      module_sp = target.GetOrCreateModule(module_spec, false /* notify */);
       if (!module_sp || module_sp->GetObjectFile() == NULL)
         module_sp = m_process->ReadModuleFromMemory(image_info.file_spec,
                                                     image_info.address);
 
       if (did_create_ptr)
         *did_create_ptr = (bool)module_sp;
     }
   }
if (image_module_sp) {
                                    image_infos[idx].GetArchitecture());
             module_spec.GetObjectName() = commpage_dbstr;
             ModuleSP commpage_image_module_sp(
                 target_images.FindFirstModule(module_spec));
             if (!commpage_image_module_sp) {
               module_spec.SetObjectOffset(objfile->GetFileOffset() +
                                           commpage_section->GetFileOffset());
               module_spec.SetObjectSize(objfile->GetByteSize());
-              commpage_image_module_sp = target.GetSharedModule(module_spec);
+              commpage_image_module_sp = target.GetOrCreateModule(module_spec, 
+                                                               true /* notify */);
               if (!commpage_image_module_sp ||
                   commpage_image_module_sp->GetObjectFile() == NULL) {
                 commpage_image_module_sp = m_process->ReadModuleFromMemory(
                     image_infos[idx].file_spec, image_infos[idx].address);
                 // Always load a memory image right away in the target in case
                 // we end up trying to read the symbol table from memory... The
                 // __LINKEDIT will need to be mapped so we can figure out where
                 // the symbol table bits are...

source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

if (status.Fail() || info.GetMapped() != MemoryRegionInfo::eYes ||
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
     LLDB_LOG(log, "Failed to get interpreter region info: {0}", status);
     return nullptr;
   }
 
   FileSpec file(info.GetName().GetCString());
   ModuleSpec module_spec(file, target.GetArchitecture());
 
-  if (ModuleSP module_sp = target.GetSharedModule(module_spec)) {
+  if (ModuleSP module_sp = target.GetOrCreateModule(module_spec, 
+                                                    true /* notify */)) {
     UpdateLoadedSections(module_sp, LLDB_INVALID_ADDRESS, m_interpreter_base,
                          false);
     return module_sp;
   }
   return nullptr;
 }
 
 void DynamicLoaderPOSIXDYLD::LoadAllCurrentModules() {

source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp

 }
 
 void DynamicLoaderWindowsDYLD::OnLoadModule(lldb::ModuleSP module_sp,
                                             const ModuleSpec module_spec,
                                             lldb::addr_t module_addr) {
 
   // Resolve the module unless we already have one.
   if (!module_sp) {
-    // Confusingly, there is no Target::AddSharedModule.  Instead, calling
-    // GetSharedModule() with a new module will add it to the module list and
-    // return a corresponding ModuleSP.
     Status error;
-    module_sp = m_process->GetTarget().GetSharedModule(module_spec, &error);
+    module_sp = m_process->GetTarget().GetOrCreateModule(module_spec, 
+                                             true /* notify */, &error);
     if (error.Fail())
       return;
   }
 
   m_loaded_modules[module_sp] = module_addr;
   UpdateLoadedSectionsCommon(module_sp, module_addr, false);
   ModuleList module_list;
   module_list.Append(module_sp);

source/Plugins/Process/Windows/Common/ProcessWindows.cpp

if (!module) {
     if (file_name.empty()) {
       return;
     }
 
     FileSpec executable_file(file_name);
     FileSystem::Instance().Resolve(executable_file);
     ModuleSpec module_spec(executable_file);
     Status error;
-    module = GetTarget().GetSharedModule(module_spec, &error);
+    module = GetTarget().GetOrCreateModule(module_spec, 
+                                           true /* notify */, &error);
     if (!module) {
       return;
     }
 
     GetTarget().SetExecutableModule(module, eLoadDependentsNo);
   }
 
   if (auto dyld = GetDynamicLoader())

source/Plugins/Process/elf-core/ProcessElfCore.cpp

Status ProcessElfCore::DoLoadCore() {
   if (!exe_module_sp) {
     // The first entry in the NT_FILE might be our executable
     if (!m_nt_file_entries.empty()) {
       ModuleSpec exe_module_spec;
       exe_module_spec.GetArchitecture() = arch;
       exe_module_spec.GetFileSpec().SetFile(
           m_nt_file_entries[0].path.GetCString(), FileSpec::Style::native);
       if (exe_module_spec.GetFileSpec()) {
-        exe_module_sp = GetTarget().GetSharedModule(exe_module_spec);
+        exe_module_sp = GetTarget().GetOrCreateModule(exe_module_spec, 
+                                                      true /* notify */);
         if (exe_module_sp)
           GetTarget().SetExecutableModule(exe_module_sp, eLoadDependentsNo);
       }
     }
   }
   return error;
 }
 

source/Plugins/Process/minidump/ProcessMinidump.cpp

for (auto module : filtered_modules) {
     const auto uuid = m_minidump_parser->GetModuleUUID(module);
     auto file_spec = FileSpec(name.getValue(), GetArchitecture().GetTriple());
     FileSystem::Instance().Resolve(file_spec);
     ModuleSpec module_spec(file_spec, uuid);
     module_spec.GetArchitecture() = GetArchitecture();
     Status error;
     // Try and find a module with a full UUID that matches. This function will
     // add the module to the target if it finds one.
-    lldb::ModuleSP module_sp = GetTarget().GetSharedModule(module_spec, &error);
+    lldb::ModuleSP module_sp = GetTarget().GetOrCreateModule(module_spec, 
+                                                     true /* notify */, &error);
     if (!module_sp) {
       // Try and find a module without specifying the UUID and only looking for
       // the file given a basename. We then will look for a partial UUID match
       // if we find any matches. This function will add the module to the
       // target if it finds one, so we need to remove the module from the target
       // if the UUID doesn't match during our manual UUID verification. This
       // allows the "target.exec-search-paths" setting to specify one or more
       // directories that contain executables that can be searched for matches.
       ModuleSpec basename_module_spec(module_spec);
       basename_module_spec.GetUUID().Clear();
       basename_module_spec.GetFileSpec().GetDirectory().Clear();
-      module_sp = GetTarget().GetSharedModule(basename_module_spec, &error);
+      module_sp = GetTarget().GetOrCreateModule(basename_module_spec, 
+                                                     true /* notify */, &error);
       if (module_sp) {
         // We consider the module to be a match if the minidump UUID is a
         // prefix of the actual UUID, or if either of the UUIDs are empty.
         const auto dmp_bytes = uuid.GetBytes();
         const auto mod_bytes = module_sp->GetUUID().GetBytes();
         const bool match = dmp_bytes.empty() || mod_bytes.empty() ||
             mod_bytes.take_front(dmp_bytes.size()) == dmp_bytes;
         if (!match) {
if (!module_sp) {
       if (log) {
         log->Printf("Unable to locate the matching object file, creating a "
                     "placeholder module for: %s",
                     name.getValue().c_str());
       }
 
       module_sp = Module::CreateModuleFromObjectFile<PlaceholderObjectFile>(
           module_spec, module->base_of_image, module->size_of_image);
-      GetTarget().GetImages().Append(module_sp);
+      GetTarget().GetImages().Append(module_sp, true /* notify */);
     }
 
     bool load_addr_changed = false;
     module_sp->SetLoadAddress(GetTarget(), module->base_of_image, false,
                               load_addr_changed);
   }
 }
 

source/Target/Target.cpp

void Target::SetExecutableModule(ModuleSP &executable_sp,
   ClearModules(false);
 
   if (executable_sp) {
     static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
     Timer scoped_timer(func_cat,
                        "Target::SetExecutableModule (executable = '%s')",
                        executable_sp->GetFileSpec().GetPath().c_str());
 
-    m_images.Append(executable_sp); // The first image is our executable file
+    const bool notify = true;
+    m_images.Append(executable_sp, notify); // The first image is our executable file
 
     // If we haven't set an architecture yet, reset our architecture based on
     // what we found in the executable module.
     if (!m_arch.GetSpec().IsValid()) {
       m_arch = executable_sp->GetArchitecture();
       LLDB_LOG(log,
                "setting architecture to {0} ({1}) based on executable file",
                m_arch.GetSpec().GetArchitectureName(),
case eLoadDependentsYes:
       load_dependents = true;
       break;
     case eLoadDependentsNo:
       load_dependents = false;
       break;
     }
 
     if (executable_objfile && load_dependents) {
+      ModuleList added_modules;
       executable_objfile->GetDependentModules(dependent_files);
       for (uint32_t i = 0; i < dependent_files.GetSize(); i++) {
         FileSpec dependent_file_spec(
             dependent_files.GetFileSpecPointerAtIndex(i));
         FileSpec platform_dependent_file_spec;
         if (m_platform_sp)
           m_platform_sp->GetFileWithUUID(dependent_file_spec, nullptr,
                                          platform_dependent_file_spec);
         else
           platform_dependent_file_spec = dependent_file_spec;
 
         ModuleSpec module_spec(platform_dependent_file_spec, m_arch.GetSpec());
-        ModuleSP image_module_sp(GetSharedModule(module_spec));
+        ModuleSP image_module_sp(GetOrCreateModule(module_spec, 
+                                 false /* notify */));
         if (image_module_sp) {
+          added_modules.AppendIfNeeded (image_module_sp, false);
           ObjectFile *objfile = image_module_sp->GetObjectFile();
           if (objfile)
             objfile->GetDependentModules(dependent_files);
         }
       }
+      ModulesDidLoad(added_modules);
     }
   }
 }
 
 bool Target::SetArchitecture(const ArchSpec &arch_spec, bool set_platform) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_TARGET));
   bool missing_local_arch = !m_arch.GetSpec().IsValid();
   bool replace_local_arch = true;
if (arch_spec.IsValid()) {
     } else {
       // The new architecture is different, we just need to replace it
       return SetArchitecture(arch_spec);
     }
   }
   return false;
 }
 
-void Target::WillClearList(const ModuleList &module_list) {}
+void Target::NotifyWillClearList(const ModuleList &module_list) {}
 
-void Target::ModuleAdded(const ModuleList &module_list,
+void Target::NotifyModuleAdded(const ModuleList &module_list,
                          const ModuleSP &module_sp) {
   // A module is being added to this target for the first time
   if (m_valid) {
     ModuleList my_module_list;
     my_module_list.Append(module_sp);
-    LoadScriptingResourceForModule(module_sp, this);
     ModulesDidLoad(my_module_list);
   }
 }
 
-void Target::ModuleRemoved(const ModuleList &module_list,
+void Target::NotifyModuleRemoved(const ModuleList &module_list,
                            const ModuleSP &module_sp) {
   // A module is being removed from this target.
   if (m_valid) {
     ModuleList my_module_list;
     my_module_list.Append(module_sp);
     ModulesDidUnload(my_module_list, false);
   }
 }
 
-void Target::ModuleUpdated(const ModuleList &module_list,
+void Target::NotifyModuleUpdated(const ModuleList &module_list,
                            const ModuleSP &old_module_sp,
                            const ModuleSP &new_module_sp) {
   // A module is replacing an already added module
   if (m_valid) {
     m_breakpoint_list.UpdateBreakpointsWhenModuleIsReplaced(old_module_sp,
                                                             new_module_sp);
     m_internal_breakpoint_list.UpdateBreakpointsWhenModuleIsReplaced(
         old_module_sp, new_module_sp);
   }
 }
 
+void Target::NotifyModulesRemoved(lldb_private::ModuleList &module_list) {
+  ModulesDidUnload (module_list, false);
+}
+
+
 void Target::ModulesDidLoad(ModuleList &module_list) {
   if (m_valid && module_list.GetSize()) {
+
+    const ModuleList &modules = GetImages();
+    const size_t num_images = modules.GetSize();
+    for (size_t idx = 0; idx < num_images; ++idx) {
+      ModuleSP module_sp(modules.GetModuleAtIndex(idx));
+      LoadScriptingResourceForModule(module_sp, this);
+    }
     m_breakpoint_list.UpdateBreakpoints(module_list, true, false);
     m_internal_breakpoint_list.UpdateBreakpoints(module_list, true, false);
     if (m_process_sp) {
       m_process_sp->ModulesDidLoad(module_list);
     }
     BroadcastEvent(eBroadcastBitModulesLoaded,
                    new TargetEventData(this->shared_from_this(), module_list));
   }
if (pointer_vm_addr != LLDB_INVALID_ADDRESS) {
       if (!pointer_addr.IsValid())
         pointer_addr.SetOffset(pointer_vm_addr);
       return true;
     }
   }
   return false;
 }
 
-ModuleSP Target::GetSharedModule(const ModuleSpec &module_spec,
+ModuleSP Target::GetOrCreateModule(const ModuleSpec &module_spec, bool notify,
                                    Status *error_ptr) {
   ModuleSP module_sp;
 
   Status error;
 
   // First see if we already have this module in our module list.  If we do,
   // then we're done, we don't need to consult the shared modules list.  But
   // only do this if we are passed a UUID.
 
if (module_sp) {
 
         if (old_module_sp &&
             m_images.GetIndexForModule(old_module_sp.get()) !=
                 LLDB_INVALID_INDEX32) {
           m_images.ReplaceModule(old_module_sp, module_sp);
           Module *old_module_ptr = old_module_sp.get();
           old_module_sp.reset();
           ModuleList::RemoveSharedModuleIfOrphaned(old_module_ptr);
-        } else
-          m_images.Append(module_sp);
+        } else {
+          m_images.Append(module_sp, notify);
+        }
       } else
         module_sp.reset();
     }
   }
   if (error_ptr)
     *error_ptr = error;
   return module_sp;
 }