[InstrumentationRuntime] Refactor the API (Part 1/N) (NFCI)

[vsk]

Summary

Adapters for instrumentation runtimes have to do two basic things:

1. Load a runtime library.
2. Install breakpoints in that library.

This logic is duplicated in the adapters for asan and tsan. Factor it
out and document bits of it to make it easier to add new adapters.

I tested this with check-lldb, and double-checked
testcases/functionalities/{a,t}san.

[kubamracek]

LGTM

lldb/trunk/include/lldb/Target/InstrumentationRuntime.h

 
 // C Includes
 // C++ Includes
 #include <vector>
 #include <map>
 
 // Other libraries and framework includes
 // Project includes
+#include "lldb/lldb-forward.h"
 #include "lldb/lldb-private.h"
 #include "lldb/lldb-types.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/StructuredData.h"
 
 namespace lldb_private {
     
 typedef std::map<lldb::InstrumentationRuntimeType, lldb::InstrumentationRuntimeSP> InstrumentationRuntimeCollection;
     
 class InstrumentationRuntime :
     public std::enable_shared_from_this<InstrumentationRuntime>,
     public PluginInterface
 {
+    /// The instrumented process.
+    lldb::ProcessWP m_process_wp;
+
+    /// The module containing the instrumentation runtime.
+    lldb::ModuleSP m_runtime_module;
+
+    /// The breakpoint in the instrumentation runtime.
+    lldb::user_id_t m_breakpoint_id;
+
+    /// Indicates whether or not breakpoints have been registered in the instrumentation runtime.
+    bool m_is_active;
+
+protected:
+    InstrumentationRuntime(const lldb::ProcessSP &process_sp)
+        : m_process_wp(), m_runtime_module(), m_breakpoint_id(0), m_is_active(false)
+    {
+        if (process_sp)
+            m_process_wp = process_sp;
+    }
+
+    lldb::ProcessSP
+    GetProcessSP()
+    {
+        return m_process_wp.lock();
+    }
+
+    lldb::ModuleSP
+    GetRuntimeModuleSP()
+    {
+        return m_runtime_module;
+    }
+
+    void
+    SetRuntimeModuleSP(lldb::ModuleSP module_sp)
+    {
+        m_runtime_module = module_sp;
+    }
+
+    lldb::user_id_t
+    GetBreakpointID() const
+    {
+        return m_breakpoint_id;
+    }
+
+    void
+    SetBreakpointID(lldb::user_id_t ID)
+    {
+        m_breakpoint_id = ID;
+    }
+
+    void
+    SetActive(bool IsActive)
+    {
+        m_is_active = IsActive;
+    }
+
 public:
     
     static void
     ModulesDidLoad(lldb_private::ModuleList &module_list, Process *process, InstrumentationRuntimeCollection &runtimes);
-    
+    /// Look for the instrumentation runtime in \p module_list. Register and activate the runtime if this hasn't already
+    /// been done.
     virtual void
-    ModulesDidLoad(lldb_private::ModuleList &module_list);
-    
-    virtual bool
-    IsActive();
+    ModulesDidLoad(lldb_private::ModuleList &module_list) = 0;
+    bool
+    IsActive() const
+    {
+        return m_is_active;
+    }
 
     virtual lldb::ThreadCollectionSP
     GetBacktracesFromExtendedStopInfo(StructuredData::ObjectSP info);
     
 };
     
 } // namespace lldb_private
 
 #endif  // liblldb_InstrumentationRuntime_h_

lldb/trunk/source/Plugins/InstrumentationRuntime/AddressSanitizer/AddressSanitizerRuntime.h

public:
     GetPluginVersion() override
     {
         return 1;
     }
     
     void
     ModulesDidLoad(lldb_private::ModuleList &module_list) override;
     
-    bool
-    IsActive() override;
-    
 private:
-    AddressSanitizerRuntime(const lldb::ProcessSP &process_sp);
-
-    lldb::ProcessSP
-    GetProcessSP ()
-    {
-        return m_process_wp.lock();
-    }
+    AddressSanitizerRuntime(const lldb::ProcessSP &process_sp) : lldb_private::InstrumentationRuntime(process_sp) {}
 
     void
     Activate();
     
     void
     Deactivate();
     
     static bool
     NotifyBreakpointHit(void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
     
     StructuredData::ObjectSP
     RetrieveReportData();
     
     std::string
     FormatDescription(StructuredData::ObjectSP report);
-    
-    bool m_is_active;
-    lldb::ModuleSP m_runtime_module;
-    lldb::ProcessWP m_process_wp;
-    lldb::user_id_t m_breakpoint_id;
 };
     
 } // namespace lldb_private
 
 #endif // liblldb_AddressSanitizerRuntime_h_

lldb/trunk/source/Plugins/InstrumentationRuntime/AddressSanitizer/AddressSanitizerRuntime.cpp

 }
 
 lldb::InstrumentationRuntimeType
 AddressSanitizerRuntime::GetTypeStatic()
 {
     return eInstrumentationRuntimeTypeAddressSanitizer;
 }
 
-AddressSanitizerRuntime::AddressSanitizerRuntime(const ProcessSP &process_sp) :
-    m_is_active(false),
-    m_runtime_module(),
-    m_process_wp(),
-    m_breakpoint_id(0)
-{
-    if (process_sp)
-        m_process_wp = process_sp;
-}
-
 AddressSanitizerRuntime::~AddressSanitizerRuntime()
 {
     Deactivate();
 }
 
 bool ModuleContainsASanRuntime(Module * module)
 {
     const Symbol* symbol = module->FindFirstSymbolWithNameAndType(
             ConstString("__asan_get_alloc_stack"),
             lldb::eSymbolTypeAny);
 
     return symbol != nullptr;
 }
 
 void
 AddressSanitizerRuntime::ModulesDidLoad(lldb_private::ModuleList &module_list)
 {
     if (IsActive())
         return;
     
-    if (m_runtime_module) {
+    if (GetRuntimeModuleSP()) {
         Activate();
         return;
     }
 
     std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
     const size_t num_modules = module_list.GetSize();
     for (size_t i = 0; i < num_modules; ++i)
     {
         Module *module_pointer = module_list.GetModulePointerAtIndexUnlocked(i);
         const FileSpec & file_spec = module_pointer->GetFileSpec();
         if (! file_spec)
             continue;
         
         static RegularExpression g_asan_runtime_regex("libclang_rt.asan_(.*)_dynamic\\.dylib");
         if (g_asan_runtime_regex.Execute (file_spec.GetFilename().GetCString()) || module_pointer->IsExecutable())
         {
             if (ModuleContainsASanRuntime(module_pointer))
             {
-                m_runtime_module = module_pointer->shared_from_this();
+                SetRuntimeModuleSP(module_pointer->shared_from_this());
                 Activate();
                 return;
             }
         }
     }
 }
 
-bool
-AddressSanitizerRuntime::IsActive()
-{
-    return m_is_active;
-}
-
 #define RETRIEVE_REPORT_DATA_FUNCTION_TIMEOUT_USEC 2*1000*1000
 const char *
 address_sanitizer_retrieve_report_data_prefix = R"(
 extern "C"
 {
 int __asan_report_present();
 void *__asan_get_report_pc();
 void *__asan_get_report_bp();
AddressSanitizerRuntime::NotifyBreakpointHit(void *baton, StoppointCallbackContext *context, user_id_t break_id, user_id_t break_loc_id)
     }
     else
         return false;   // Let target run
 }
 
 void
 AddressSanitizerRuntime::Activate()
 {
-    if (m_is_active)
+    if (IsActive())
         return;
 
     ProcessSP process_sp = GetProcessSP();
     if (!process_sp)
         return;
 
     ConstString symbol_name ("__asan::AsanDie()");
-    const Symbol *symbol = m_runtime_module->FindFirstSymbolWithNameAndType (symbol_name, eSymbolTypeCode);
+    const Symbol *symbol = GetRuntimeModuleSP()->FindFirstSymbolWithNameAndType (symbol_name, eSymbolTypeCode);
     
     if (symbol == NULL)
         return;
     
     if (!symbol->ValueIsAddress() || !symbol->GetAddressRef().IsValid())
         return;
     
     Target &target = process_sp->GetTarget();
     addr_t symbol_address = symbol->GetAddressRef().GetOpcodeLoadAddress(&target);
     
     if (symbol_address == LLDB_INVALID_ADDRESS)
         return;
     
     bool internal = true;
     bool hardware = false;
     Breakpoint *breakpoint = process_sp->GetTarget().CreateBreakpoint(symbol_address, internal, hardware).get();
     breakpoint->SetCallback (AddressSanitizerRuntime::NotifyBreakpointHit, this, true);
     breakpoint->SetBreakpointKind ("address-sanitizer-report");
-    m_breakpoint_id = breakpoint->GetID();
+    SetBreakpointID(breakpoint->GetID());
     
     StreamFileSP stream_sp (process_sp->GetTarget().GetDebugger().GetOutputFile());
     if (stream_sp)
     {
             stream_sp->Printf ("AddressSanitizer debugger support is active. Memory error breakpoint has been installed and you can now use the 'memory history' command.\n");
     }
 
-    m_is_active = true;
+    SetActive(true);
 }
 
 void
 AddressSanitizerRuntime::Deactivate()
 {
-    if (m_breakpoint_id != LLDB_INVALID_BREAK_ID)
+    if (GetBreakpointID() != LLDB_INVALID_BREAK_ID)
     {
         ProcessSP process_sp = GetProcessSP();
         if (process_sp)
         {
-            process_sp->GetTarget().RemoveBreakpointByID(m_breakpoint_id);
-            m_breakpoint_id = LLDB_INVALID_BREAK_ID;
+            process_sp->GetTarget().RemoveBreakpointByID(GetBreakpointID());
+            SetBreakpointID(LLDB_INVALID_BREAK_ID);
         }
     }
-    m_is_active = false;
+    SetActive(false);
 }

lldb/trunk/source/Plugins/InstrumentationRuntime/ThreadSanitizer/ThreadSanitizerRuntime.h

 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/InstrumentationRuntime.h"
-#include "lldb/Target/Process.h"
 #include "lldb/Core/StructuredData.h"
 
 namespace lldb_private {
     
 class ThreadSanitizerRuntime : public lldb_private::InstrumentationRuntime
 {
 public:
     ~ThreadSanitizerRuntime() override;
public:
     GetPluginVersion() override
     {
         return 1;
     }
     
     void
     ModulesDidLoad(lldb_private::ModuleList &module_list) override;
     
-    bool
-    IsActive() override;
-    
     lldb::ThreadCollectionSP
     GetBacktracesFromExtendedStopInfo(StructuredData::ObjectSP info) override;
     
 private:
-    ThreadSanitizerRuntime(const lldb::ProcessSP &process_sp);
-    
-    lldb::ProcessSP
-    GetProcessSP ()
-    {
-        return m_process_wp.lock();
-    }
-
-    lldb::ModuleSP
-    GetRuntimeModuleSP ()
-    {
-        return m_runtime_module_wp.lock();
-    }
+    ThreadSanitizerRuntime(const lldb::ProcessSP &process_sp) : lldb_private::InstrumentationRuntime(process_sp) {}
 
     void
     Activate();
     
     void
     Deactivate();
     
     static bool
private:
     lldb::addr_t
     GetMainRacyAddress(StructuredData::ObjectSP report);
     
     std::string
     GetLocationDescription(StructuredData::ObjectSP report, lldb::addr_t &global_addr, std::string &global_name, std::string &filename, uint32_t &line);
     
     lldb::addr_t
     GetFirstNonInternalFramePc(StructuredData::ObjectSP trace);
-    
-    bool m_is_active;
-    lldb::ModuleWP m_runtime_module_wp;
-    lldb::ProcessWP m_process_wp;
-    lldb::user_id_t m_breakpoint_id;
 };
     
 } // namespace lldb_private
 
 #endif // liblldb_ThreadSanitizerRuntime_h_

lldb/trunk/source/Plugins/InstrumentationRuntime/ThreadSanitizer/ThreadSanitizerRuntime.cpp

 }
 
 lldb::InstrumentationRuntimeType
 ThreadSanitizerRuntime::GetTypeStatic()
 {
     return eInstrumentationRuntimeTypeThreadSanitizer;
 }
 
-ThreadSanitizerRuntime::ThreadSanitizerRuntime(const ProcessSP &process_sp) :
-m_is_active(false),
-m_runtime_module_wp(),
-m_process_wp(),
-m_breakpoint_id(0)
-{
-    if (process_sp)
-        m_process_wp = process_sp;
-}
-
 ThreadSanitizerRuntime::~ThreadSanitizerRuntime()
 {
     Deactivate();
 }
 
 static bool
 ModuleContainsTSanRuntime(ModuleSP module_sp)
 {
module_list.ForEach ([this](const lldb::ModuleSP module_sp) -> bool
         if (! file_spec)
             return true; // Keep iterating through modules
         
         llvm::StringRef module_basename(file_spec.GetFilename().GetStringRef());
         if (module_sp->IsExecutable() || module_basename.startswith("libclang_rt.tsan_"))
         {
             if (ModuleContainsTSanRuntime(module_sp))
             {
-                m_runtime_module_wp = module_sp;
+                SetRuntimeModuleSP(module_sp);
                 Activate();
                 return false; // Stop iterating
             }
         }
 
         return true; // Keep iterating through modules
     });
 }
 
-bool
-ThreadSanitizerRuntime::IsActive()
-{
-    return m_is_active;
-}
-
 #define RETRIEVE_REPORT_DATA_FUNCTION_TIMEOUT_USEC 2*1000*1000
 
 const char *
 thread_sanitizer_retrieve_report_data_prefix = R"(
 extern "C"
 {
     void *__tsan_get_current_report();
     int __tsan_get_report_data(void *report, const char **description, int *count,
ThreadSanitizerRuntime::NotifyBreakpointHit(void *baton, StoppointCallbackContext *context, user_id_t break_id, user_id_t break_loc_id)
     }
     else
         return false;   // Let target run
 }
 
 void
 ThreadSanitizerRuntime::Activate()
 {
-    if (m_is_active)
+    if (IsActive())
         return;
     
     ProcessSP process_sp = GetProcessSP();
     if (!process_sp)
         return;
     
     ConstString symbol_name ("__tsan_on_report");
     const Symbol *symbol = GetRuntimeModuleSP()->FindFirstSymbolWithNameAndType (symbol_name, eSymbolTypeCode);
ThreadSanitizerRuntime::Activate()
     if (symbol_address == LLDB_INVALID_ADDRESS)
         return;
     
     bool internal = true;
     bool hardware = false;
     Breakpoint *breakpoint = process_sp->GetTarget().CreateBreakpoint(symbol_address, internal, hardware).get();
     breakpoint->SetCallback (ThreadSanitizerRuntime::NotifyBreakpointHit, this, true);
     breakpoint->SetBreakpointKind ("thread-sanitizer-report");
-    m_breakpoint_id = breakpoint->GetID();
+    SetBreakpointID(breakpoint->GetID());
     
     StreamFileSP stream_sp (process_sp->GetTarget().GetDebugger().GetOutputFile());
     if (stream_sp)
     {
         stream_sp->Printf ("ThreadSanitizer debugger support is active.\n");
     }
     
-    m_is_active = true;
+    SetActive(true);
 }
 
 void
 ThreadSanitizerRuntime::Deactivate()
 {
-    if (m_breakpoint_id != LLDB_INVALID_BREAK_ID)
+    if (GetBreakpointID() != LLDB_INVALID_BREAK_ID)
     {
         ProcessSP process_sp = GetProcessSP();
         if (process_sp)
         {
-            process_sp->GetTarget().RemoveBreakpointByID(m_breakpoint_id);
-            m_breakpoint_id = LLDB_INVALID_BREAK_ID;
+            process_sp->GetTarget().RemoveBreakpointByID(GetBreakpointID());
+            SetBreakpointID(LLDB_INVALID_BREAK_ID);
         }
     }
-    m_is_active = false;
+    SetActive(false);
 }
 
 static std::string
 GenerateThreadName(const std::string &path, StructuredData::Object *o, StructuredData::ObjectSP main_info) {
     std::string result = "additional information";
     
     if (path == "mops") {
         int size = o->GetObjectForDotSeparatedPath("size")->GetIntegerValue();

lldb/trunk/source/Target/InstrumentationRuntime.cpp

for (uint32_t idx = 0; ; ++idx)
         InstrumentationRuntimeCollection::iterator pos;
         pos = runtimes.find (type);
         if (pos == runtimes.end()) {
             runtimes[type] = create_callback(process->shared_from_this());
         }
     }
 }
 
-void
-InstrumentationRuntime::ModulesDidLoad(lldb_private::ModuleList &module_list)
-{
-}
-
-bool
-InstrumentationRuntime::IsActive()
-{
-    return false;
-}
-
 lldb::ThreadCollectionSP
 InstrumentationRuntime::GetBacktracesFromExtendedStopInfo(StructuredData::ObjectSP info)
 {
     return ThreadCollectionSP(new ThreadCollection());
 }