vendor/lldb/lldb-trunk-r257626

12 files changed, 329 insertions, 6 deletions

diff --git a/include/lldb/Core/LoadedModuleInfoList.h b/include/lldb/Core/LoadedModuleInfoList.h
new file mode 100644
index 0000000000000..6ba5c2813ec4c
--- /dev/null
+++ b/include/lldb/Core/LoadedModuleInfoList.h
@@ -0,0 +1,152 @@
+//===-- LoadedModuleInfoList.h ----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_LoadedModuleInfoList_h_
+#define liblldb_LoadedModuleInfoList_h_
+
+// C Includes
+
+// C++ Includes
+#include <vector>
+
+// Other libraries and framework includes
+#include "lldb/lldb-private-forward.h"
+
+namespace lldb_private {
+class LoadedModuleInfoList
+{
+public:
+
+    class LoadedModuleInfo
+    {
+    public:
+
+        enum e_data_point
+        {
+            e_has_name      = 0,
+            e_has_base      ,
+            e_has_dynamic   ,
+            e_has_link_map  ,
+            e_num
+        };
+
+        LoadedModuleInfo ()
+        {
+            for (uint32_t i = 0; i < e_num; ++i)
+                m_has[i] = false;
+        };
+
+        void set_name (const std::string & name)
+        {
+            m_name = name;
+            m_has[e_has_name] = true;
+        }
+        bool get_name (std::string & out) const
+        {
+            out = m_name;
+            return m_has[e_has_name];
+        }
+
+        void set_base (const lldb::addr_t base)
+        {
+            m_base = base;
+            m_has[e_has_base] = true;
+        }
+        bool get_base (lldb::addr_t & out) const
+        {
+            out = m_base;
+            return m_has[e_has_base];
+        }
+
+        void set_base_is_offset (bool is_offset)
+        {
+            m_base_is_offset = is_offset;
+        }
+        bool get_base_is_offset(bool & out) const
+        {
+            out = m_base_is_offset;
+            return m_has[e_has_base];
+        }
+
+        void set_link_map (const lldb::addr_t addr)
+        {
+            m_link_map = addr;
+            m_has[e_has_link_map] = true;
+        }
+        bool get_link_map (lldb::addr_t & out) const
+        {
+            out = m_link_map;
+            return m_has[e_has_link_map];
+        }
+
+        void set_dynamic (const lldb::addr_t addr)
+        {
+            m_dynamic = addr;
+            m_has[e_has_dynamic] = true;
+        }
+        bool get_dynamic (lldb::addr_t & out) const
+        {
+            out = m_dynamic;
+            return m_has[e_has_dynamic];
+        }
+
+        bool has_info (e_data_point datum) const
+        {
+            assert (datum < e_num);
+            return m_has[datum];
+        }
+
+        bool
+        operator == (LoadedModuleInfo const &rhs) const
+        {
+            if (e_num != rhs.e_num)
+                return false;
+
+            for (size_t i = 0; i < e_num; ++i)
+            {
+                if (m_has[i] != rhs.m_has[i])
+                    return false;
+            }
+
+            return (m_base == rhs.m_base) &&
+                   (m_link_map == rhs.m_link_map) &&
+                   (m_dynamic == rhs.m_dynamic) &&
+                   (m_name == rhs.m_name);
+        }
+    protected:
+
+        bool m_has[e_num];
+        std::string m_name;
+        lldb::addr_t m_link_map;
+        lldb::addr_t m_base;
+        bool m_base_is_offset;
+        lldb::addr_t m_dynamic;
+    };
+
+    LoadedModuleInfoList ()
+        : m_list ()
+        , m_link_map (LLDB_INVALID_ADDRESS)
+    {}
+
+    void add (const LoadedModuleInfo & mod)
+    {
+        m_list.push_back (mod);
+    }
+
+    void clear ()
+    {
+        m_list.clear ();
+    }
+
+    std::vector<LoadedModuleInfo> m_list;
+    lldb::addr_t m_link_map;
+};
+} // namespace lldb_private
+
+#endif  // liblldb_LoadedModuleInfoList_h_
diff --git a/include/lldb/Interpreter/CommandReturnObject.h b/include/lldb/Interpreter/CommandReturnObject.h
index 424ac800d14c0..e3a1d9f657cbf 100644
--- a/include/lldb/Interpreter/CommandReturnObject.h
+++ b/include/lldb/Interpreter/CommandReturnObject.h
@@ -169,6 +169,18 @@ public:
     
     void
     SetInteractive (bool b);
+    
+    bool
+    GetAbnormalStopWasExpected() const
+    {
+        return m_abnormal_stop_was_expected;
+    }
+    
+    void
+    SetAbnormalStopWasExpected(bool signal_was_expected)
+    {
+        m_abnormal_stop_was_expected = signal_was_expected;
+    }
 
 private:
     enum 
@@ -182,7 +194,13 @@ private:
     
     lldb::ReturnStatus m_status;
     bool m_did_change_process_state;
-    bool m_interactive; // If true, then the input handle from the debugger will be hooked up
+    bool m_interactive;          // If true, then the input handle from the debugger will be hooked up
+    bool m_abnormal_stop_was_expected;  // This is to support eHandleCommandFlagStopOnCrash vrs. attach.
+                                        // The attach command often ends up with the process stopped due to a signal.
+                                        // Normally that would mean stop on crash should halt batch execution, but we
+                                        // obviously don't want that for attach.  Using this flag, the attach command
+                                        // (and anything else for which this is relevant) can say that the signal is
+                                        // expected, and batch command execution can continue.
 };
 
 } // namespace lldb_private
diff --git a/include/lldb/Symbol/ClangASTContext.h b/include/lldb/Symbol/ClangASTContext.h
index 0314ce060e38e..bd3a113e6cc50 100644
--- a/include/lldb/Symbol/ClangASTContext.h
+++ b/include/lldb/Symbol/ClangASTContext.h
@@ -573,6 +573,9 @@ public:
     ConstString
     DeclContextGetName (void *opaque_decl_ctx) override;
 
+    ConstString
+    DeclContextGetScopeQualifiedName (void *opaque_decl_ctx) override;
+
     bool
     DeclContextIsClassMethod (void *opaque_decl_ctx,
                               lldb::LanguageType *language_ptr,
diff --git a/include/lldb/Symbol/CompilerDeclContext.h b/include/lldb/Symbol/CompilerDeclContext.h
index 70399b2dbb371..9135b44323b55 100644
--- a/include/lldb/Symbol/CompilerDeclContext.h
+++ b/include/lldb/Symbol/CompilerDeclContext.h
@@ -128,6 +128,9 @@ public:
     ConstString
     GetName () const;
 
+    ConstString
+    GetScopeQualifiedName() const;
+
     bool
     IsStructUnionOrClass () const;
 
diff --git a/include/lldb/Symbol/GoASTContext.h b/include/lldb/Symbol/GoASTContext.h
index 3de98da59958e..09d79bacc585d 100644
--- a/include/lldb/Symbol/GoASTContext.h
+++ b/include/lldb/Symbol/GoASTContext.h
@@ -112,6 +112,12 @@ class GoASTContext : public TypeSystem
         return ConstString();
     }
 
+    ConstString
+    DeclContextGetScopeQualifiedName(void *opaque_decl_ctx) override
+    {
+        return ConstString();
+    }
+
     bool
     DeclContextIsClassMethod(void *opaque_decl_ctx, lldb::LanguageType *language_ptr, bool *is_instance_method_ptr,
                              ConstString *language_object_name_ptr) override
diff --git a/include/lldb/Symbol/SymbolFile.h b/include/lldb/Symbol/SymbolFile.h
index e27b32d01f688..fe74ad4f933e3 100644
--- a/include/lldb/Symbol/SymbolFile.h
+++ b/include/lldb/Symbol/SymbolFile.h
@@ -144,6 +144,7 @@ public:
     virtual uint32_t        FindTypes (const SymbolContext& sc, const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, TypeMap& types);
     virtual size_t          FindTypes (const std::vector<CompilerContext> &context, bool append, TypeMap& types);
 
+    virtual void            GetMangledNamesForFunction(const std::string &scope_qualified_name, std::vector<ConstString> &mangled_names);
 //  virtual uint32_t        FindTypes (const SymbolContext& sc, const RegularExpression& regex, bool append, uint32_t max_matches, TypeList& types) = 0;
     virtual TypeList *      GetTypeList ();
     virtual size_t          GetTypes (lldb_private::SymbolContextScope *sc_scope,
diff --git a/include/lldb/Symbol/TypeSystem.h b/include/lldb/Symbol/TypeSystem.h
index d367bcdc0b14f..9b43b9dec37bf 100644
--- a/include/lldb/Symbol/TypeSystem.h
+++ b/include/lldb/Symbol/TypeSystem.h
@@ -151,6 +151,9 @@ public:
     virtual ConstString
     DeclContextGetName (void *opaque_decl_ctx) = 0;
 
+    virtual ConstString
+    DeclContextGetScopeQualifiedName (void *opaque_decl_ctx) = 0;
+
     virtual bool
     DeclContextIsClassMethod (void *opaque_decl_ctx,
                               lldb::LanguageType *language_ptr,
diff --git a/include/lldb/Target/CPPLanguageRuntime.h b/include/lldb/Target/CPPLanguageRuntime.h
index ac537d0ad1e50..788f4e60a493b 100644
--- a/include/lldb/Target/CPPLanguageRuntime.h
+++ b/include/lldb/Target/CPPLanguageRuntime.h
@@ -42,9 +42,6 @@ public:
     bool
     GetObjectDescription(Stream &str, Value &value, ExecutionContextScope *exe_scope) override;
     
-    virtual size_t
-    GetAlternateManglings(const ConstString &mangled, std::vector<ConstString> &alternates) = 0;
-
 protected:
 
     //------------------------------------------------------------------
diff --git a/include/lldb/Target/Process.h b/include/lldb/Target/Process.h
index 2e063c5bbcccd..6bb7a3d783deb 100644
--- a/include/lldb/Target/Process.h
+++ b/include/lldb/Target/Process.h
@@ -30,6 +30,7 @@
 #include "lldb/Core/Communication.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Event.h"
+#include "lldb/Core/LoadedModuleInfoList.h"
 #include "lldb/Core/ThreadSafeValue.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/StructuredData.h"
@@ -1152,6 +1153,12 @@ public:
         return 0;
     }
 
+    virtual size_t
+    LoadModules (LoadedModuleInfoList &)
+    {
+       return 0;
+    }
+
 protected:
     virtual JITLoaderList &
     GetJITLoaders ();
@@ -3149,6 +3156,34 @@ public:
     void
     ResetImageToken(size_t token);
 
+    //------------------------------------------------------------------
+    /// Find the next branch instruction to set a breakpoint on
+    ///
+    /// When instruction stepping through a source line, instead of 
+    /// stepping through each instruction, we can put a breakpoint on
+    /// the next branch instruction (within the range of instructions
+    /// we are stepping through) and continue the process to there,
+    /// yielding significant performance benefits over instruction
+    /// stepping.  
+    ///
+    /// @param[in] default_stop_addr
+    ///     The address of the instruction where lldb would put a 
+    ///     breakpoint normally.
+    ///
+    /// @param[in] range_bounds
+    ///     The range which the breakpoint must be contained within.
+    ///     Typically a source line.
+    ///
+    /// @return
+    ///     The address of the next branch instruction, or the end of
+    ///     the range provided in range_bounds.  If there are any
+    ///     problems with the disassembly or getting the instructions,
+    ///     the original default_stop_addr will be returned.
+    //------------------------------------------------------------------
+    Address
+    AdvanceAddressToNextBranchInstruction (Address default_stop_addr, 
+                                           AddressRange range_bounds);
+
 protected:
     void
     SetState (lldb::EventSP &event_sp);
diff --git a/include/lldb/Target/SystemRuntime.h b/include/lldb/Target/SystemRuntime.h
index 54fde88c8d12d..cefd724004502 100644
--- a/include/lldb/Target/SystemRuntime.h
+++ b/include/lldb/Target/SystemRuntime.h
@@ -275,6 +275,23 @@ public:
         return LLDB_INVALID_ADDRESS;
     }
 
+
+    //------------------------------------------------------------------
+    /// Retrieve the Queue kind for the queue at a thread's dispatch_qaddr.
+    ///
+    /// Retrieve the Queue kind - either eQueueKindSerial or 
+    /// eQueueKindConcurrent, indicating that this queue processes work
+    /// items serially or concurrently.
+    ///
+    /// @return
+    ///     The Queue kind, if it could be read, else eQueueKindUnknown.
+    //------------------------------------------------------------------
+    virtual lldb::QueueKind
+    GetQueueKind (lldb::addr_t dispatch_qaddr)
+    {
+        return lldb::eQueueKindUnknown;
+    }
+
     //------------------------------------------------------------------
     /// Get the pending work items for a libdispatch Queue
     ///
diff --git a/include/lldb/Target/Thread.h b/include/lldb/Target/Thread.h
index 7aff77bd16f4a..ba73e0b49da88 100644
--- a/include/lldb/Target/Thread.h
+++ b/include/lldb/Target/Thread.h
@@ -367,6 +367,35 @@ public:
     }
 
     //------------------------------------------------------------------
+    /// Whether this thread can be associated with a libdispatch queue
+    /// 
+    /// The Thread may know if it is associated with a libdispatch queue,
+    /// it may know definitively that it is NOT associated with a libdispatch
+    /// queue, or it may be unknown whether it is associated with a libdispatch
+    /// queue.  
+    ///
+    /// @return
+    ///     eLazyBoolNo if this thread is definitely not associated with a
+    ///     libdispatch queue (e.g. on a non-Darwin system where GCD aka 
+    ///     libdispatch is not available).
+    ///
+    ///     eLazyBoolYes this thread is associated with a libdispatch queue.
+    ///
+    ///     eLazyBoolCalculate this thread may be associated with a libdispatch 
+    ///     queue but the thread doesn't know one way or the other.
+    //------------------------------------------------------------------
+    virtual lldb_private::LazyBool
+    GetAssociatedWithLibdispatchQueue ()
+    {
+        return eLazyBoolNo;
+    }
+
+    virtual void
+    SetAssociatedWithLibdispatchQueue (lldb_private::LazyBool associated_with_libdispatch_queue)
+    {
+    }
+
+    //------------------------------------------------------------------
     /// Retrieve the Queue ID for the queue currently using this Thread
     ///
     /// If this Thread is doing work on behalf of a libdispatch/GCD queue,
@@ -414,6 +443,29 @@ public:
     }
 
     //------------------------------------------------------------------
+    /// Retrieve the Queue kind for the queue currently using this Thread
+    ///
+    /// If this Thread is doing work on behalf of a libdispatch/GCD queue,
+    /// retrieve the Queue kind - either eQueueKindSerial or 
+    /// eQueueKindConcurrent, indicating that this queue processes work
+    /// items serially or concurrently.
+    ///
+    /// @return
+    ///     The Queue kind, if the Thread subclass implements this, else
+    ///     eQueueKindUnknown.
+    //------------------------------------------------------------------
+    virtual lldb::QueueKind
+    GetQueueKind ()
+    {
+        return lldb::eQueueKindUnknown;
+    }
+
+    virtual void
+    SetQueueKind (lldb::QueueKind kind)
+    {
+    }
+
+    //------------------------------------------------------------------
     /// Retrieve the Queue for this thread, if any.
     ///
     /// @return
@@ -451,6 +503,30 @@ public:
         return LLDB_INVALID_ADDRESS;
     }
 
+    virtual void
+    SetQueueLibdispatchQueueAddress (lldb::addr_t dispatch_queue_t)
+    {
+    }
+
+    //------------------------------------------------------------------
+    /// Whether this Thread already has all the Queue information cached or not
+    ///
+    /// A Thread may be associated with a libdispatch work Queue at a given
+    /// public stop event.  If so, the thread can satisify requests like
+    /// GetQueueLibdispatchQueueAddress, GetQueueKind, GetQueueName, and GetQueueID
+    /// either from information from the remote debug stub when it is initially
+    /// created, or it can query the SystemRuntime for that information.
+    ///
+    /// This method allows the SystemRuntime to discover if a thread has this
+    /// information already, instead of calling the thread to get the information
+    /// and having the thread call the SystemRuntime again.
+    //------------------------------------------------------------------
+    virtual bool
+    ThreadHasQueueInformation () const
+    {
+        return false;
+    }
+
     virtual uint32_t
     GetStackFrameCount()
     {
@@ -888,6 +964,16 @@ public:
     /// @param[in] run_vote
     ///    See standard meanings for the stop & run votes in ThreadPlan.h.
     ///
+    /// @param[in] continue_to_next_branch
+    ///    Normally this will enqueue a plan that will put a breakpoint on the return address and continue
+    ///    to there.  If continue_to_next_branch is true, this is an operation not involving the user -- 
+    ///    e.g. stepping "next" in a source line and we instruction stepped into another function -- 
+    ///    so instead of putting a breakpoint on the return address, advance the breakpoint to the 
+    ///    end of the source line that is doing the call, or until the next flow control instruction.
+    ///    If the return value from the function call is to be retrieved / displayed to the user, you must stop
+    ///    on the return address.  The return value may be stored in volatile registers which are overwritten
+    ///    before the next branch instruction.
+    ///
     /// @return
     ///     A shared pointer to the newly queued thread plan, or nullptr if the plan could not be queued.
     //------------------------------------------------------------------
@@ -898,7 +984,8 @@ public:
                                            bool stop_other_threads,
                                            Vote stop_vote, // = eVoteYes,
                                            Vote run_vote, // = eVoteNoOpinion);
-                                           uint32_t frame_idx);
+                                           uint32_t frame_idx,
+                                           bool continue_to_next_branch = false);
 
     //------------------------------------------------------------------
     /// Gets the plan used to step through the code that steps from a function
diff --git a/include/lldb/Target/ThreadPlanStepOut.h b/include/lldb/Target/ThreadPlanStepOut.h
index ac5696357e9bd..ccf829f636df3 100644
--- a/include/lldb/Target/ThreadPlanStepOut.h
+++ b/include/lldb/Target/ThreadPlanStepOut.h
@@ -31,7 +31,8 @@ public:
                        Vote stop_vote,
                        Vote run_vote,
                        uint32_t frame_idx,
-                       LazyBool step_out_avoids_code_without_debug_info);
+                       LazyBool step_out_avoids_code_without_debug_info,
+                       bool continue_to_next_branch = false);
 
     ~ThreadPlanStepOut() override;