Add =shlibs-added/=shlibs-removed notifications (MI)

[ki.stfu]

Summary

This patch adds =shlibs-added/=shlibs-removed notifications in lldb-mi. In more detail:

1. Add Target::ModulesDidLoad/ModulesDidUnload notifications
2. Improve Target::TargetEventData:
   1. Refactoring
   2. Move it back to include/lldb/Target/Target.h
   3. Add Target::{GetModuleListFromEvent,GetModuleList}; Add Target::m_module_list
3. Add SBModule::{GetSymbolVendorMainFileSpec,GetObjectFileHeaderAddress}
4. Add SBTarget::{EventIsTaretEvent,GetTargetFromEvent,GetNumModulesFromEvent,GetModuleAtIndexFromEvent}

All tests pass on OS X.

[clayborg]

Overall looks good, just a few things to fix. See inlined comments.

include/lldb/API/SBModule.h

332–333

Rename this to GetSymbolFileSpec(). The public API doesn't need to know anything about symbol vendors.

include/lldb/Target/Target.h

498–547

Leave this in the Target.cpp and add static accessors to Target.h and Target.cpp much like the ones in SBTarget

source/API/SBModule.cpp

689

Rename to GetSymbolFileSpec()

source/API/SBTarget.cpp

136

Make static functions in Target.h/cpp so we don't expose the TargetEventData class to anyone.

142

Make static functions in Target.h/cpp so we don't expose the TargetEventData class to anyone.

148

Make static functions in Target.h/cpp so we don't expose the TargetEventData class to anyone.

155

Make static functions in Target.h/cpp so we don't expose the TargetEventData class to anyone.

[ki.stfu]

I have a question.

source/API/SBTarget.cpp

136

Why you want to hide it in cpp file? It was done similarly to ThreadEventData/ProcessEventData/BreakpointEventData.

[ki.stfu]

Rename SBModule::GetSymbolVendorMainFileSpec to GetSymbolFileSpec

[clayborg]

Ok, I thought I remembers the ProcessEventData being in Process.cpp. So it seems consistent to put it in the header file.

Looks good.

[abidh]

I have some questions about this patch.

Gdb uses library-loaded to notify about the shared libraries. Why are you not using it?
Where can I get the documentation about the fields of shlibs-added?
This event is also being generated in case of main executable file. GDB only generates it for shared library. Is this intended behaviour.

[ki.stfu]

In D8201#138864, @abidh wrote:

I have some questions about this patch.

Gdb uses library-loaded to notify about the shared libraries. Why are you not using it?
Where can I get the documentation about the fields of shlibs-added?
This event is also being generated in case of main executable file. GDB only generates it for shared library. Is this intended behaviour.

I looked how it works in GDB, and I have seen =shlibs-added/=shlibs-removed format. For example:

100=shlibs-added,shlib-info={num="2",name="nb-test",kind="-",dyld-addr="0x100000000",reason="exec",requested-state="Y",state="Y",path="/Users/bpontarelli/dev/inversoft/cleanspeak/cleanspeak-domain/projects/nb-test/dist/Debug/GNU-MacOSX/nb-test",description="/Users/bpontarelli/dev/inversoft/cleanspeak/cleanspeak-domain/projects/nb-test/dist/Debug/GNU-MacOSX/nb-test",loaded_addr="",slide="0x0",prefix=""}
100=shlibs-added,shlib-info={num="3",name="libgtest.0.0.0.dylib",kind="-",dyld-addr="0x1000f4000",reason="dyld",requested-state="Y",state="Y",path="/usr/local/lib/libgtest.0.0.0.dylib",description="/usr/local/lib/libgtest.0.0.0.dylib",loaded_addr="0x1000f4000",slide="-0xfffffffefff0c000",prefix=""}
100=shlibs-added,shlib-info={num="4",name="libmysqlclient.15.dylib",kind="-",dyld-addr="0x100152000",reason="dyld",requested-state="Y",state="Y",path="/usr/local/mysql-5.0.51b-osx10.5-x86_64/lib/libmysqlclient.15.dylib",description="/usr/local/mysql-5.0.51b-osx10.5-x86_64/lib/libmysqlclient.15.dylib",loaded_addr="0x100152000",slide="-0xfffffffeffeae000",prefix=""}
100=shlibs-added,shlib-info={num="5",name="libstdc++.6.0.4.dylib",kind="-",dyld-addr="0x7fff81e61000",reason="dyld",requested-state="Y",state="Y",path="/usr/lib/libstdc++.6.0.4.dylib",description="/usr/lib/libstdc++.6.0.4.dylib",loaded_addr="0x7fff81e61000",slide="-0xffff80007e19f000",prefix=""}
100=shlibs-added,shlib-info={num="6",name="libgcc_s.1.dylib",kind="-",dyld-addr="0x7fff80ef3000",reason="dyld",requested-state="Y",state="Y",path="/usr/lib/libgcc_s.1.dylib",description="/usr/lib/libgcc_s.1.dylib",loaded_addr="0x7fff80ef3000",slide="-0xffff80007f10d000",prefix=""}
100=shlibs-added,shlib-info={num="7",name="libSystem.B.dylib",kind="-",dyld-addr="0x7fff81728000",reason="dyld",requested-state="Y",state="Y",path="/usr/lib/libSystem.B.dylib",description="/usr/lib/libSystem.B.dylib",loaded_addr="0x7fff81728000",slide="-0xffff80007e8d8000",prefix="",commpage-objpath="/usr/lib/libSystem.B.dylib[LC_SEGMENT.__DATA.__commpage]"}
100=shlibs-added,shlib-info={num="8",name="libmathCommon.A.dylib",kind="-",dyld-addr="0x7fff824a4000",reason="dyld",requested-state="Y",state="Y",path="/usr/lib/system/libmathCommon.A.dylib",description="/usr/lib/system/libmathCommon.A.dylib",loaded_addr="0x7fff824a4000",slide="-0xffff80007db5c000",prefix=""}

Original link: https://bugzilla-attachments-169842.netbeans.org/bugzilla/attachment.cgi?id=85852

[abidh]

That probably was in Apple fork of gdb. @jasonmolenda may know the history. There is no such event in current gdb.

As you will see on the link below, "library-loaded" event is used.
https://sourceware.org/gdb/onlinedocs/gdb/GDB_002fMI-Async-Records.html

I will dig more deeper to see how this is being used but it seems to me that you either have to use the "library-loaded" event or use this code for OSX only.

[jingham]

The Apple gdb implementation of the MI and the FSF version are different in quite a few respects.

The MI was added by Cygnus long ago for an project that died stillborn, and so its original form was never used for a real IDE. After that it languished for a while till we started using it for ProjectBuilder not quite so long ago. We added/changed many things to make it work IRL, but that was on a NeXT based fork of gdb that was pretty different from the then current FSF gdb, so these changes were not submitted back. Then when the FSF community revived the MI for Eclipse & the Emacs MI mode etc. they needed to make similar additions/modifications but since that was done independently the choices made were slightly different.

Did anybody outside ProjectBuilder use Apple's version of the MI interfaces? Unless there are important clients for that flavor, it seems like it would be better to use the FSF versions where they differ.

Jim

[jingham]

If you are on a system using ASLR you also might want to know where the main executable loaded, so it seems useful to send it for the main executable. shlibs-added is a little funny, for instance on OS X gdb used to read all the directly linked libraries when the main executable was loaded, so they weren't really "added". To that end we also had a shlibs-updated to say "you already knew about this but it either changed (binary changed) or its load addresses changed.

Jim

[jasonmolenda]

fwiw, I agree with Jim. The Apple gdb-mi style is a historical oddity at this point - Project Builder/Xcode were the only IDEs that interoperated with it as far as I know, and Xcode dropped MI support a few years ago altogether. There are many cases where we solved a problem in our MI one way, then it was either modified in the process of upstreaming the feature, or it was implemented independently by the FSF gdb folks as they completed the MI support for Eclipse. So there are lots of little divergences in the newer features that have been added to MI.

Eclipse may even have some old bitrotted support for the Apple variant of MI.

For lldb's MI support, it would be better to follow the current FSF gdb MI's style so we can interoperate with IDEs like Eclipse or emacs GUD mode seamlessly.

include/lldb/API/SBEvent.h

public:
     GetDescription (lldb::SBStream &description) const;
 
 protected:
     friend class SBListener;
     friend class SBBroadcaster;
     friend class SBBreakpoint;
     friend class SBDebugger;
     friend class SBProcess;
+    friend class SBTarget;
     friend class SBThread;
     friend class SBWatchpoint;
 
     lldb::EventSP &
     GetSP () const;
 
     void
     reset (lldb::EventSP &event_sp);

include/lldb/API/SBModule.h

public:
     ///     This function always returns the number of version numbers
     ///     that this object file has regardless of the number of
     ///     version numbers that were copied into \a versions. 
     //------------------------------------------------------------------
     uint32_t
     GetVersion (uint32_t *versions, 
                 uint32_t num_versions);
 
+    //------------------------------------------------------------------
+    /// Get accessor for the symbol file specification.
+    ///
+    /// When debugging an object file an additional debug information can
+    /// be provided in separate file. Therefore if you debugging something
+    /// like '/usr/lib/liba.dylib' then debug information can be located
+    /// in folder like '/usr/lib/liba.dylib.dSYM/'.
+    ///
+    /// @return
+    ///     A const reference to the file specification object.
+    //------------------------------------------------------------------
+    lldb::SBFileSpec
+    GetSymbolVendorMainFileSpec() const;
+
+    lldb::SBAddress
+    GetObjectFileHeaderAddress() const;
+
 private:
     friend class SBAddress;
     friend class SBFrame;
     friend class SBSection;
     friend class SBSymbolContext;
     friend class SBTarget;
 
     explicit SBModule (const lldb::ModuleSP& module_sp);

include/lldb/API/SBTarget.h

public:
 
     //------------------------------------------------------------------
     // Destructor
     //------------------------------------------------------------------
     ~SBTarget();
 
     bool
     IsValid() const;
-    
+    static bool
+    EventIsTargetEvent (const lldb::SBEvent &event);
+
+    static lldb::SBTarget
+    GetTargetFromEvent (const lldb::SBEvent &event);
+    
+    static uint32_t
+    GetNumModulesFromEvent (const lldb::SBEvent &event);
+
+    static lldb::SBModule
+    GetModuleAtIndexFromEvent (const uint32_t idx, const lldb::SBEvent &event);
+
     static const char *
     GetBroadcasterClassName ();
 
     lldb::SBProcess
     GetProcess ();
 
     //------------------------------------------------------------------
     /// Return the platform object associated with the target.

include/lldb/Target/Target.h

public:
     // These two functions fill out the Broadcaster interface:
     
     static ConstString &GetStaticBroadcasterClass ();
 
     virtual ConstString &GetBroadcasterClass() const
     {
         return GetStaticBroadcasterClass();
     }
-    
+    // This event data class is for use by the TargetList to broadcast new target notifications.
+    class TargetEventData : public EventData
+    {
+    public:
+        TargetEventData (const lldb::TargetSP &target_sp);
+
+        TargetEventData (const lldb::TargetSP &target_sp, const ModuleList &module_list);
+
+        virtual
+        ~TargetEventData();
+
+        static const ConstString &
+        GetFlavorString ();
+
+        virtual const ConstString &
+        GetFlavor () const
+        {
+            return TargetEventData::GetFlavorString ();
+        }
+
+        virtual void
+        Dump (Stream *s) const;
+
+        static const TargetEventData *
+        GetEventDataFromEvent (const Event *event_ptr);
+
+        static lldb::TargetSP
+        GetTargetFromEvent (const Event *event_ptr);
+
+        static ModuleList
+        GetModuleListFromEvent (const Event *event_ptr);
+
+        const lldb::TargetSP &
+        GetTarget() const
+        {
+            return m_target_sp;
+        }
+
+        const ModuleList &
+        GetModuleList() const
+        {
+            return m_module_list;
+        }
+
+    private:
+        lldb::TargetSP m_target_sp;
+        ModuleList     m_module_list;
+
+        DISALLOW_COPY_AND_ASSIGN (TargetEventData);
+    };
+    
     static void
     SettingsInitialize ();
 
     static void
     SettingsTerminate ();
 
     static FileSpecList
     GetDefaultExecutableSearchPaths ();

source/API/SBModule.cpp

else
         {
             for (uint32_t i=0; i<num_versions; ++i)
                 versions[i] = UINT32_MAX;
         }
         return 0;
     }
 }
 
+lldb::SBFileSpec
+SBModule::GetSymbolVendorMainFileSpec() const
+{
+    lldb::SBFileSpec sb_file_spec;
+    ModuleSP module_sp(GetSP());
+    if (module_sp)
+    {
+        SymbolVendor *symbol_vendor_ptr = module_sp->GetSymbolVendor();
+        if (symbol_vendor_ptr)
+            sb_file_spec.SetFileSpec(symbol_vendor_ptr->GetMainFileSpec());
+    }
+    return sb_file_spec;
+}
+
+lldb::SBAddress
+SBModule::GetObjectFileHeaderAddress() const
+{
+    lldb::SBAddress sb_addr;
+    ModuleSP module_sp (GetSP ());
+    if (module_sp)
+    {
+        ObjectFile *objfile_ptr = module_sp->GetObjectFile();
+        if (objfile_ptr)
+            sb_addr.ref() = objfile_ptr->GetHeaderAddress();
+    }
+    return sb_addr;
+}

source/API/SBTarget.cpp

 //===-- SBTarget.cpp --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/lldb-python.h"
 
 #include "lldb/API/SBTarget.h"
 
 #include "lldb/lldb-public.h"
 
-#include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBBreakpoint.h"
+#include "lldb/API/SBDebugger.h"
+#include "lldb/API/SBEvent.h"
 #include "lldb/API/SBExpressionOptions.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/API/SBModule.h"
 #include "lldb/API/SBModuleSpec.h"
 #include "lldb/API/SBSourceManager.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStream.h"

 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 SBTarget::~SBTarget()
 {
 }
 
+bool
+SBTarget::EventIsTargetEvent (const SBEvent &event)
+{
+    return Target::TargetEventData::GetEventDataFromEvent(event.get()) != NULL;
+}
+
+SBTarget
+SBTarget::GetTargetFromEvent (const SBEvent &event)
+{
+    return Target::TargetEventData::GetTargetFromEvent (event.get());
+}
+
+uint32_t
+SBTarget::GetNumModulesFromEvent (const SBEvent &event)
+{
+    const ModuleList module_list = Target::TargetEventData::GetModuleListFromEvent (event.get());
+    return module_list.GetSize();
+}
+
+SBModule
+SBTarget::GetModuleAtIndexFromEvent (const uint32_t idx, const SBEvent &event)
+{
+    const ModuleList module_list = Target::TargetEventData::GetModuleListFromEvent (event.get());
+    return SBModule(module_list.GetModuleAtIndex(idx));
+}
+
 const char *
 SBTarget::GetBroadcasterClassName ()
 {
     return Target::GetStaticBroadcasterClass().AsCString();
 }
 
 bool
 SBTarget::IsValid () const

source/Target/Target.cpp

 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadSpec.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-namespace {
-// This event data class is for use by the TargetList to broadcast new target notifications.
-class TargetEventData : public EventData
-{
-public:
-    TargetEventData(const lldb::TargetSP &new_target_sp)
-        : EventData()
-        , m_target_sp(new_target_sp)
-    {
-    }
-        
-    virtual ~TargetEventData()
-    {
-    }
-
-    static const ConstString &
-    GetFlavorString()
-    {
-        static ConstString g_flavor("Target::TargetEventData");
-        return g_flavor;
-    }
-
-    virtual const ConstString &
-    GetFlavor() const
-    {
-        return GetFlavorString();
-    }
-
-    lldb::TargetSP &
-    GetTarget()
-    {
-        return m_target_sp;
-    }
-
-    virtual void
-    Dump(Stream *s) const
-    {
-    }
-
-    static const lldb::TargetSP
-    GetTargetFromEvent(const lldb::EventSP &event_sp)
-    {
-        TargetSP target_sp;
-
-        const TargetEventData *data = GetEventDataFromEvent (event_sp.get());
-        if (data)
-            target_sp = data->m_target_sp;
-
-        return target_sp;
-    }
-        
-    static const TargetEventData *
-    GetEventDataFromEvent(const Event *event_ptr)
-    {
-        if (event_ptr)
-        {
-            const EventData *event_data = event_ptr->GetData();
-            if (event_data && event_data->GetFlavor() == TargetEventData::GetFlavorString())
-                return static_cast <const TargetEventData *> (event_ptr->GetData());
-        }
-        return nullptr;
-    }
-
-private:
-    lldb::TargetSP m_target_sp;
-
-    DISALLOW_COPY_AND_ASSIGN (TargetEventData);
-};
-}
-
 ConstString &
 Target::GetStaticBroadcasterClass ()
 {
     static ConstString class_name ("lldb.target");
     return class_name;
 }
 
 //----------------------------------------------------------------------

 {
     if (m_valid && module_list.GetSize())
     {
         m_breakpoint_list.UpdateBreakpoints (module_list, true, false);
         if (m_process_sp)
         {
             m_process_sp->ModulesDidLoad (module_list);
         }
-        // TODO: make event data that packages up the module_list
-        BroadcastEvent (eBroadcastBitModulesLoaded, NULL);
+        BroadcastEvent (eBroadcastBitModulesLoaded, new TargetEventData (this->shared_from_this(), module_list));
     }
 }
 
 void
 Target::SymbolsDidLoad (ModuleList &module_list)
 {
     if (m_valid && module_list.GetSize())
     {
         if (m_process_sp)
         {
             LanguageRuntime* runtime = m_process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
             if (runtime)
             {
                 ObjCLanguageRuntime *objc_runtime = (ObjCLanguageRuntime*)runtime;
                 objc_runtime->SymbolsDidLoad(module_list);
             }
         }
         
         m_breakpoint_list.UpdateBreakpoints (module_list, true, false);
-        BroadcastEvent(eBroadcastBitSymbolsLoaded, NULL);
+        BroadcastEvent (eBroadcastBitSymbolsLoaded, new TargetEventData (this->shared_from_this(), module_list));
     }
 }
 
 void
 Target::ModulesDidUnload (ModuleList &module_list, bool delete_locations)
 {
     if (m_valid && module_list.GetSize())
     {
         UnloadModuleSections (module_list);
         m_breakpoint_list.UpdateBreakpoints (module_list, false, delete_locations);
-        // TODO: make event data that packages up the module_list
-        BroadcastEvent (eBroadcastBitModulesUnloaded, NULL);
+        BroadcastEvent (eBroadcastBitModulesUnloaded, new TargetEventData (this->shared_from_this(), module_list));
     }
 }
 
 bool
 Target::ModuleIsExcludedForUnconstrainedSearches (const FileSpec &module_file_spec)
 {
     if (GetBreakpointsConsultPlatformAvoidList())
     {

 TargetProperties::DisableSTDIOValueChangedCallback(void *target_property_ptr, OptionValue *)
 {
     TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
     if (this_->GetDisableSTDIO())
         this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDisableSTDIO);
     else
         this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDisableSTDIO);
 }
+
+//----------------------------------------------------------------------
+// Target::TargetEventData
+//----------------------------------------------------------------------
+
+Target::TargetEventData::TargetEventData (const lldb::TargetSP &target_sp) :
+    EventData (),
+    m_target_sp (target_sp),
+    m_module_list ()
+{
+}
+
+Target::TargetEventData::TargetEventData (const lldb::TargetSP &target_sp, const ModuleList &module_list) :
+    EventData (),
+    m_target_sp (target_sp),
+    m_module_list (module_list)
+{
+}
+
+Target::TargetEventData::~TargetEventData()
+{
+}
+
+const ConstString &
+Target::TargetEventData::GetFlavorString ()
+{
+    static ConstString g_flavor ("Target::TargetEventData");
+    return g_flavor;
+}
+
+void
+Target::TargetEventData::Dump (Stream *s) const
+{
+}
+
+const Target::TargetEventData *
+Target::TargetEventData::GetEventDataFromEvent (const Event *event_ptr)
+{
+    if (event_ptr)
+    {
+        const EventData *event_data = event_ptr->GetData();
+        if (event_data && event_data->GetFlavor() == TargetEventData::GetFlavorString())
+            return static_cast <const TargetEventData *> (event_ptr->GetData());
+    }
+    return NULL;
+}
+
+TargetSP
+Target::TargetEventData::GetTargetFromEvent (const Event *event_ptr)
+{
+    TargetSP target_sp;
+    const TargetEventData *event_data = GetEventDataFromEvent (event_ptr);
+    if (event_data)
+        target_sp = event_data->m_target_sp;
+    return target_sp;
+}
+
+ModuleList
+Target::TargetEventData::GetModuleListFromEvent (const Event *event_ptr)
+{
+    ModuleList module_list;
+    const TargetEventData *event_data = GetEventDataFromEvent (event_ptr);
+    if (event_data)
+        module_list = event_data->m_module_list;
+    return module_list;
+}

tools/lldb-mi/MICmnLLDBDebugger.cpp

CMICmnLLDBDebugger::InitSBListener(void)
     m_lldbListener = m_lldbDebugger.GetListener();
     if (!m_lldbListener.IsValid())
     {
         SetErrorDescription(MIRSRC(IDS_LLDBDEBUGGER_ERR_INVALIDLISTENER));
         return MIstatus::failure;
     }
 
     const CMIUtilString strDbgId("CMICmnLLDBDebugger1");
-    MIuint eventMask = lldb::SBTarget::eBroadcastBitBreakpointChanged;
+    MIuint eventMask = lldb::SBTarget::eBroadcastBitBreakpointChanged | lldb::SBTarget::eBroadcastBitModulesLoaded |
+                       lldb::SBTarget::eBroadcastBitModulesUnloaded | lldb::SBTarget::eBroadcastBitWatchpointChanged |
+                       lldb::SBTarget::eBroadcastBitSymbolsLoaded;
     bool bOk = RegisterForEvent(strDbgId, CMIUtilString(lldb::SBTarget::GetBroadcasterClassName()), eventMask);
 
     eventMask = lldb::SBThread::eBroadcastBitStackChanged;
     bOk = bOk && RegisterForEvent(strDbgId, CMIUtilString(lldb::SBThread::GetBroadcasterClassName()), eventMask);
 
     eventMask = lldb::SBProcess::eBroadcastBitStateChanged | lldb::SBProcess::eBroadcastBitInterrupt |
                 lldb::SBProcess::eBroadcastBitSTDOUT | lldb::SBProcess::eBroadcastBitSTDERR | lldb::SBProcess::eBroadcastBitProfileData;
     bOk = bOk && RegisterForEvent(strDbgId, CMIUtilString(lldb::SBProcess::GetBroadcasterClassName()), eventMask);

tools/lldb-mi/MICmnLLDBDebuggerHandleEvents.h

 //
 // Copyright:   None.
 //--
 
 #pragma once
 
 // In-house headers:
 #include "MICmnBase.h"
+#include "MICmnMIValueList.h"
 #include "MICmnMIValueTuple.h"
 #include "MIUtilSingletonBase.h"
 
 // Declarations:
 class CMICmnLLDBDebugSessionInfo;
 class CMICmnMIResultRecord;
 class CMICmnStreamStdout;
 class CMICmnMIOutOfBandRecord;
private:
     bool ChkForStateChanges(void);
     bool GetProcessStdout(void);
     bool GetProcessStderr(void);
     bool HandleEventSBBreakPoint(const lldb::SBEvent &vEvent);
     bool HandleEventSBBreakpointCmn(const lldb::SBEvent &vEvent);
     bool HandleEventSBBreakpointAdded(const lldb::SBEvent &vEvent);
     bool HandleEventSBBreakpointLocationsAdded(const lldb::SBEvent &vEvent);
     bool HandleEventSBProcess(const lldb::SBEvent &vEvent);
+    bool HandleEventSBTarget(const lldb::SBEvent &vEvent);
     bool HandleEventSBThread(const lldb::SBEvent &vEvent);
     bool HandleEventSBThreadBitStackChanged(const lldb::SBEvent &vEvent);
     bool HandleEventSBThreadSuspended(const lldb::SBEvent &vEvent);
     bool HandleEventSBCommandInterpreter(const lldb::SBEvent &vEvent);
     bool HandleProcessEventBroadcastBitStateChanged(const lldb::SBEvent &vEvent);
     bool HandleProcessEventStateRunning(void);
     bool HandleProcessEventStateExited(void);
     bool HandleProcessEventStateStopped(bool &vwrbShouldBrk);
     bool HandleProcessEventStopReasonTrace(void);
     bool HandleProcessEventStopReasonBreakpoint(void);
     bool HandleProcessEventStopSignal(bool &vwrbShouldBrk);
     bool HandleProcessEventStopException(void);
     bool HandleProcessEventStateSuspended(const lldb::SBEvent &vEvent);
+    bool HandleTargetEventBroadcastBitModulesLoaded(const lldb::SBEvent &vEvent);
+    bool HandleTargetEventBroadcastBitModulesUnloaded(const lldb::SBEvent &vEvent);
+    bool MiHelpGetModuleInfo(const lldb::SBModule &vModule, const MIuint nModuleNum,
+                             CMICmnMIValueList &vwrMiValueList);
     bool MiHelpGetCurrentThreadFrame(CMICmnMIValueTuple &vwrMiValueTuple);
     bool MiResultRecordToStdout(const CMICmnMIResultRecord &vrMiResultRecord);
     bool MiOutOfBandRecordToStdout(const CMICmnMIOutOfBandRecord &vrMiResultRecord);
     bool MiStoppedAtBreakPoint(const MIuint64 vBrkPtId, const lldb::SBBreakpoint &vBrkPt);
     bool TextToStdout(const CMIUtilString &vrTxt);
     bool TextToStderr(const CMIUtilString &vrTxt);
     bool UpdateSelectedThread(void);
 

tools/lldb-mi/MICmnLLDBDebuggerHandleEvents.cpp

 // Environment: Compilers:  Visual C++ 12.
 //                          gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
 //              Libraries:  See MIReadmetxt.
 //
 // Copyright:   None.
 //--
 
 // Third party headers:
+#include "lldb/API/SBAddress.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBStream.h"
+#include "lldb/API/SBTarget.h"
 #include "lldb/API/SBThread.h"
 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBUnixSignals.h"
 #ifdef _WIN32
 #include <io.h> // For the ::_access()
 #else
 #include <unistd.h> // For the ::access()
else if (lldb::SBBreakpoint::EventIsBreakpointEvent(vEvent))
         vrbHandledEvent = true;
         bOk = HandleEventSBBreakPoint(vEvent);
     }
     else if (lldb::SBThread::EventIsThreadEvent(vEvent))
     {
         vrbHandledEvent = true;
         bOk = HandleEventSBThread(vEvent);
     }
+    else if (lldb::SBTarget::EventIsTargetEvent(vEvent))
+    {
+        vrbHandledEvent = true;
+        bOk = HandleEventSBTarget(vEvent);
+    }
 
     return bOk;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Handle a LLDB SBProcess event.
 // Type:    Method.
 // Args:    vEvent          - (R) An LLDB broadcast event.
if (!thread.IsValid())
         return MIstatus::success;
 
     lldb::SBStream streamOut;
     const bool bOk = thread.GetStatus(streamOut);
     return bOk && TextToStdout(streamOut.GetData());
 }
 
 //++ ------------------------------------------------------------------------------------
+// Details: Handle a LLDB SBTarget event.
+// Type:    Method.
+// Args:    vEvent  - (R) An LLDB broadcast event.
+// Return:  MIstatus::success - Functional succeeded.
+//          MIstatus::failure - Functional failed.
+// Throws:  None.
+//--
+bool
+CMICmnLLDBDebuggerHandleEvents::HandleEventSBTarget(const lldb::SBEvent &vEvent)
+{
+    if (!ChkForStateChanges())
+        return MIstatus::failure;
+
+    bool bOk = MIstatus::success;
+    const MIchar *pEventType = "";
+    const MIuint nEventType = vEvent.GetType();
+    switch (nEventType)
+    {
+        case lldb::SBTarget::eBroadcastBitBreakpointChanged:
+            pEventType = "eBroadcastBitBreakpointChanged";
+            break;
+        case lldb::SBTarget::eBroadcastBitModulesLoaded:
+            pEventType = "eBroadcastBitModulesLoaded";
+            bOk = HandleTargetEventBroadcastBitModulesLoaded(vEvent);
+            break;
+        case lldb::SBTarget::eBroadcastBitModulesUnloaded:
+            pEventType = "eBroadcastBitModulesUnloaded";
+            bOk = HandleTargetEventBroadcastBitModulesUnloaded(vEvent);
+            break;
+        case lldb::SBTarget::eBroadcastBitWatchpointChanged:
+            pEventType = "eBroadcastBitWatchpointChanged";
+            break;
+        case lldb::SBTarget::eBroadcastBitSymbolsLoaded:
+            pEventType = "eBroadcastBitSymbolsLoaded";
+            break;
+        default:
+        {
+            const CMIUtilString msg(CMIUtilString::Format(MIRSRC(IDS_LLDBOUTOFBAND_ERR_UNKNOWN_EVENT), "SBTarget", (MIuint)nEventType));
+            SetErrorDescription(msg);
+            return MIstatus::failure;
+        }
+    }
+    m_pLog->WriteLog(CMIUtilString::Format("##### An SBTarget event occurred: %s", pEventType));
+
+    return bOk;
+}
+
+//++ ------------------------------------------------------------------------------------
+// Details: Print to stdout "=shlibs-added,shlib-info=[key=\"value\"...]"
+// Type:    Method.
+// Args:    None.
+// Return:  MIstatus::success - Functional succeeded.
+//          MIstatus::failure - Functional failed.
+// Throws:  None.
+//--
+bool
+CMICmnLLDBDebuggerHandleEvents::HandleTargetEventBroadcastBitModulesLoaded(const lldb::SBEvent &vEvent)
+{
+    static MIuint s_nModulesLoadedNumber(0);
+    const MIuint nSize(lldb::SBTarget::GetNumModulesFromEvent(vEvent));
+    bool bOk = MIstatus::success;
+    for (MIuint nIndex(0); bOk && (nIndex < nSize); ++nIndex)
+    {
+        const lldb::SBModule sbModule = lldb::SBTarget::GetModuleAtIndexFromEvent(nIndex, vEvent);
+        CMICmnMIValueList miValueList(true);
+        bOk = MiHelpGetModuleInfo(sbModule, ++s_nModulesLoadedNumber, miValueList);
+        const CMICmnMIValueResult miValueResult("shlib-info", miValueList);
+        const CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_TargetModulesLoaded, miValueResult);
+        bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord);
+    }
+
+    return bOk;
+}
+
+//++ ------------------------------------------------------------------------------------
+// Details: Print to stdout "=shlibs-removed,shlib-info=[key=\"value\"...]"
+// Type:    Method.
+// Args:    None.
+// Return:  MIstatus::success - Functional succeeded.
+//          MIstatus::failure - Functional failed.
+// Throws:  None.
+//--
+bool
+CMICmnLLDBDebuggerHandleEvents::HandleTargetEventBroadcastBitModulesUnloaded(const lldb::SBEvent &vEvent)
+{
+    static MIuint s_nModulesUnloadedNumber(0);
+    const MIuint nSize(lldb::SBTarget::GetNumModulesFromEvent(vEvent));
+    bool bOk = MIstatus::success;
+    for (MIuint nIndex(0); bOk && (nIndex < nSize); ++nIndex)
+    {
+        const lldb::SBModule sbModule = lldb::SBTarget::GetModuleAtIndexFromEvent(nIndex, vEvent);
+        CMICmnMIValueList miValueList(true);
+        bOk = MiHelpGetModuleInfo(sbModule, ++s_nModulesUnloadedNumber, miValueList);
+        const CMICmnMIValueResult miValueResult("shlib-info", miValueList);
+        const CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_TargetModulesUnloaded, miValueResult);
+        bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord);
+    }
+
+    return bOk;
+}
+
+//++ ------------------------------------------------------------------------------------
+// Details: Build module information for shlib-info "[num=\"%ld\",name=\"%s\",dyld-addr=\"%#lx\",reason=\"dyld\",path=\"%s\",loaded_addr=\"%#lx\",dsym-objpath=\"%s\"]"
+// Type:    Method.
+// Args:    vwrMiValueList    - (W) MI value list object.
+// Return:  MIstatus::success - Functional succeeded.
+//          MIstatus::failure - Functional failed.
+// Throws:  None.
+//--
+bool
+CMICmnLLDBDebuggerHandleEvents::MiHelpGetModuleInfo(const lldb::SBModule &vModule, const MIuint nModuleNum,
+                                                    CMICmnMIValueList &vwrMiValueList)
+{
+    bool bOk = MIstatus::success;
+
+    // Build "num" field
+    const CMIUtilString strNum(CMIUtilString::Format("%ld", nModuleNum));
+    const CMICmnMIValueConst miValueConst(strNum);
+    const CMICmnMIValueResult miValueResult("num", miValueConst);
+    bOk = bOk && vwrMiValueList.Add(miValueResult);
+    // Build "name" field
+    const CMICmnMIValueConst miValueConst2(vModule.GetPlatformFileSpec().GetFilename());
+    const CMICmnMIValueResult miValueResult2("name", miValueConst2);
+    bOk = bOk && vwrMiValueList.Add(miValueResult2);
+    // Build "dyld-addr" field
+    const lldb::SBAddress sbAddress(vModule.GetObjectFileHeaderAddress());
+    const CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
+    const lldb::addr_t nLoadAddress(sbAddress.GetLoadAddress(rSessionInfo.GetTarget()));
+    const CMIUtilString strDyldAddr(CMIUtilString::Format("%#lx", nLoadAddress));
+    const CMICmnMIValueConst miValueConst3(nLoadAddress != LLDB_INVALID_ADDRESS ? strDyldAddr : "-");
+    const CMICmnMIValueResult miValueResult3("dyld-addr", miValueConst3);
+    bOk = bOk && vwrMiValueList.Add(miValueResult3);
+    // Build "reason" field
+    const CMICmnMIValueConst miValueConst4("dyld");
+    const CMICmnMIValueResult miValueResult4("reason", miValueConst4);
+    bOk = bOk && vwrMiValueList.Add(miValueResult4);
+    // Build "path" field
+    char path[PATH_MAX];
+    vModule.GetPlatformFileSpec().GetPath(path, sizeof(path));
+    const CMIUtilString strPlatformPath(path);
+    const CMICmnMIValueConst miValueConst5(strPlatformPath);
+    const CMICmnMIValueResult miValueResult5("path", miValueConst5);
+    bOk = bOk && vwrMiValueList.Add(miValueResult5);
+    // Build "loaded_addr" field
+    const CMIUtilString strLoadedAddr(CMIUtilString::Format("%#lx", nLoadAddress));
+    const CMICmnMIValueConst miValueConst6(nLoadAddress != LLDB_INVALID_ADDRESS ? strDyldAddr : "-");
+    const CMICmnMIValueResult miValueResult6("loaded_addr", miValueConst6);
+    bOk = bOk && vwrMiValueList.Add(miValueResult6);
+    // Build "dsym-objpath" field
+    vModule.GetSymbolVendorMainFileSpec().GetPath(path, sizeof(path));
+    const CMIUtilString strSymbolFilePath(path);
+    if (!CMIUtilString::Compare(strPlatformPath, strSymbolFilePath))
+    {
+        const CMICmnMIValueConst miValueConst7(strSymbolFilePath);
+        const CMICmnMIValueResult miValueResult7("dsym-objpath", miValueConst7);
+        bOk = bOk && vwrMiValueList.Add(miValueResult7);
+    }
+
+    return bOk;
+}
+
+//++ ------------------------------------------------------------------------------------
 // Details: Handle a LLDB SBCommandInterpreter event.
 // Type:    Method.
 // Args:    vEvent  - (R) An LLDB command interpreter event.
 // Return:  MIstatus::success - Functionality succeeded.
 //          MIstatus::failure - Functionality failed.
 // Throws:  None.
 //--
 bool

tools/lldb-mi/MICmnMIOutOfBandRecord.h

enum OutOfBand_e
         eOutOfBand_Thread,
         eOutOfBand_ThreadGroupAdded,
         eOutOfBand_ThreadGroupExited,
         eOutOfBand_ThreadGroupRemoved,
         eOutOfBand_ThreadGroupStarted,
         eOutOfBand_ThreadCreated,
         eOutOfBand_ThreadExited,
         eOutOfBand_ThreadSelected,
+        eOutOfBand_TargetModulesLoaded,
+        eOutOfBand_TargetModulesUnloaded,
         eOutOfBand_count // Always the last one
     };
 
     // Typedefs:
   public:
     typedef std::map<OutOfBand_e, CMIUtilString> MapOutOfBandToOutOfBandText_t;
     typedef std::map<OutOfBand_e, CMIUtilString> MapOutOfBandToToken_t;
 

tools/lldb-mi/MICmnMIOutOfBandRecord.cpp

CMICmnMIOutOfBandRecord::MapOutOfBandToOutOfBandText_t ms_MapOutOfBandToOutOfBandText = {
     {CMICmnMIOutOfBandRecord::eOutOfBand_BreakPointModified, "breakpoint-modified"},
     {CMICmnMIOutOfBandRecord::eOutOfBand_Thread, ""}, // "" Meant to be empty
     {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupAdded, "thread-group-added"},
     {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupExited, "thread-group-exited"},
     {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupRemoved, "thread-group-removed"},
     {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupStarted, "thread-group-started"},
     {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadCreated, "thread-created"},
     {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadExited, "thread-exited"},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadSelected, "thread-selected"}};
+    {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadSelected, "thread-selected"},
+    {CMICmnMIOutOfBandRecord::eOutOfBand_TargetModulesLoaded, "shlibs-added"},
+    {CMICmnMIOutOfBandRecord::eOutOfBand_TargetModulesUnloaded, "shlibs-removed"}};
 CMICmnMIOutOfBandRecord::MapOutOfBandToOutOfBandText_t ms_constMapAsyncRecordTextToToken = {
     {CMICmnMIOutOfBandRecord::eOutOfBand_Running, "*"},
     {CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, "*"},
     {CMICmnMIOutOfBandRecord::eOutOfBand_BreakPointCreated, "="},
     {CMICmnMIOutOfBandRecord::eOutOfBand_BreakPointModified, "="},
     {CMICmnMIOutOfBandRecord::eOutOfBand_Thread, "@"},
     {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupAdded, "="},
     {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupExited, "="},
     {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupRemoved, "="},
     {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupStarted, "="},
     {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadCreated, "="},
     {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadExited, "="},
-    {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadSelected, "="}};
+    {CMICmnMIOutOfBandRecord::eOutOfBand_ThreadSelected, "="},
+    {CMICmnMIOutOfBandRecord::eOutOfBand_TargetModulesLoaded, "="},
+    {CMICmnMIOutOfBandRecord::eOutOfBand_TargetModulesUnloaded, "="}};
 
 //++ ------------------------------------------------------------------------------------
 // Details: CMICmnMIOutOfBandRecord constructor.
 // Type:    Method.
 // Args:    None.
 // Return:  None.
 // Throws:  None.
 //--