[lldb] ASan history threads SB API

[kubamracek]

Summary

This patch depends on http://reviews.llvm.org/D4596.

As a continuation of the previous patch that adds a MemoryHistory plugin and implementation for ASan-provided malloc/free stack traces, this patch exposes this into the SB API. In short, these two new methods are added into SBValue:

• uint32_t SBValue::GetNumMemoryHistoryThreads ();
• SBThread SBValue::GetMemoryHistoryThreadAtIndex (uint32_t idx);

This corresponds to how we provide objects for which we don't have containers (SBFrame and GetNumFrames + GetFrameAtIndex). Note that exposing ThreadList into a generic SBThreadList container would not be straightforward, because currently ThreadList is not a generic container of threads, but instead holds functionality tied to a process and can currently only be used to hold all threads in a process.

[jasonmolenda]

This looks fine to me - but Jim/Enrico/Greg may want to comment.

One thing I'd change is that you document the SBValue::GetNumMemoryHistoryThreads and SBValue::GetMemoryHistoryThreadAtIndex in include/lldb/API/SBValue.h but not in scripts/Python/interface/SBValue.i. The generated documentation for the SB APIs are all based on the .i file comments -- e.g. when you do "script help (lldb.SBValue)" in lldb, that stuff all comes out of the SBValue.i header.

include/lldb/API/SBValue.h

     //------------------------------------------------------------------
     lldb::ValueObjectSP
     GetSP () const;
+    
+    //------------------------------------------------------------------
+    /// Returns the number of memory history threads (i.e. recorded malloc/free stack
+    /// traces) associated with this value object. The list of history threads is
+    /// cached, so the MemoryHistory plugin is queried only once for an SBValue.
+    ///
+    /// @return
+    ///     The number of associated history threads for this SBValue.
+    //------------------------------------------------------------------
+    uint32_t
+    GetNumMemoryHistoryThreads ();
+    
+    //------------------------------------------------------------------
+    /// Retrieves the memory history thread by its index.
+    ///
+    /// @return
+    ///     An SBThread for the history thread with the specified index or an invalid
+    ///     SBThread object if the index is out of bounds.
+    //------------------------------------------------------------------
+    lldb::SBThread
+    GetMemoryHistoryThreadAtIndex (uint32_t idx);
 
 protected:
     friend class SBBlock;

scripts/Python/interface/SBValue.i

     ) GetExpressionPath;
     bool
     GetExpressionPath (lldb::SBStream &description, bool qualify_cxx_base_classes);
+
+    uint32_t
+    GetNumMemoryHistoryThreads ();
+
+    lldb::SBThread
+    GetMemoryHistoryThreadAtIndex (uint32_t idx);
     
     %pythoncode %{
         def __get_dynamic__ (self):

source/API/SBValue.cpp

 #include "lldb/Symbol/Variable.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/MemoryHistory.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"

 using namespace lldb;
 using namespace lldb_private;
 
+typedef std::shared_ptr<HistoryThreads> HistoryThreadsSP;
+
 class ValueImpl
 {
 public:

     m_valobj_sp(in_valobj_sp),
     m_use_dynamic(use_dynamic),
     m_use_synthetic(use_synthetic),
-    m_name (name)
+    m_name (name),
+    m_history_threads()
     {
         if (!m_name.IsEmpty() && m_valobj_sp)
             m_valobj_sp->SetName(m_name);

     m_valobj_sp(rhs.m_valobj_sp),
     m_use_dynamic(rhs.m_use_dynamic),
     m_use_synthetic(rhs.m_use_synthetic),
-    m_name (rhs.m_name)
+    m_name (rhs.m_name),
+    m_history_threads()
     {
     }
 

             m_use_dynamic = rhs.m_use_dynamic;
             m_use_synthetic = rhs.m_use_synthetic;
             m_name = rhs.m_name;
+            m_history_threads = rhs.m_history_threads;
         }
         return *this;
     }

         else
             return StackFrameSP();
     }
+    
+    HistoryThreadsSP
+    GetHistoryThreads()
+    {
+        if (! m_history_threads)
+        {
+            m_history_threads.reset(new HistoryThreads());
+            
+            if (! m_valobj_sp) {
+                return m_history_threads;
+            }
+            
+            ProcessSP process_sp = m_valobj_sp->GetProcessSP();
+            if (! process_sp.get()) {
+                return m_history_threads;
+            }
+            
+            const MemoryHistorySP &memory_history = MemoryHistory::FindPlugin(process_sp);
+            
+            if (! memory_history.get()) {
+                return m_history_threads;
+            }
 
+            addr_t pointer_value = m_valobj_sp->GetPointerValue();
+            m_history_threads.reset(new HistoryThreads(memory_history->GetHistoryThreads(pointer_value)));
+        }
+    
+        return m_history_threads;
+    }
+
 private:
     lldb::ValueObjectSP m_valobj_sp;
     lldb::DynamicValueType m_use_dynamic;
     bool m_use_synthetic;
     ConstString m_name;
+    HistoryThreadsSP m_history_threads;
 };
 
 class ValueLocker

         sb_watchpoint = Dereference().Watch (resolve_location, read, write, error);
     return sb_watchpoint;
 }
+
+uint32_t
+SBValue::GetNumMemoryHistoryThreads ()
+{
+    if (! IsValid())
+        return 0;
+    HistoryThreadsSP history_threads = m_opaque_sp->GetHistoryThreads();
+    if (! history_threads.get())
+        return 0;
+    
+    return history_threads->size();
+}
+
+lldb::SBThread
+SBValue::GetMemoryHistoryThreadAtIndex (uint32_t idx)
+{
+    if (! IsValid())
+        return SBThread();
+    HistoryThreadsSP history_threads = m_opaque_sp->GetHistoryThreads();
+    if (! history_threads.get())
+        return SBThread();
+    if (idx >= history_threads->size())
+        return SBThread();
+    
+    return (*history_threads)[idx];
+}

test/functionalities/asan/TestAsan.py

                 'Memory allocated at', 'a.out`f1', 'main.c:%d' % self.line_malloc,
                 'Memory deallocated at', 'a.out`f2', 'main.c:%d' % self.line_free])
 
+        # do the same using SB API
+        process = self.dbg.GetSelectedTarget().process
+        val = process.GetSelectedThread().GetSelectedFrame().EvaluateExpression("pointer")
+        self.assertEqual(val.GetNumMemoryHistoryThreads(), 2)
+        
+        history_thread = val.GetMemoryHistoryThreadAtIndex(0)
+        self.assertTrue(history_thread.num_frames >= 2)
+        self.assertEqual(history_thread.frames[1].GetLineEntry().GetFileSpec().GetFilename(), "main.c")
+        self.assertEqual(history_thread.frames[1].GetLineEntry().GetLine(), self.line_malloc)
+        
+        history_thread = val.GetMemoryHistoryThreadAtIndex(1)
+        self.assertTrue(history_thread.num_frames >= 2)
+        self.assertEqual(history_thread.frames[1].GetLineEntry().GetFileSpec().GetFilename(), "main.c")
+        self.assertEqual(history_thread.frames[1].GetLineEntry().GetLine(), self.line_free)
+
+        # now let's break when an ASan report occurs and try the API then
         self.runCmd("breakpoint set -n __asan_report_error")
 
         self.runCmd("continue")