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

[vsk]

Summary

Factor out some common logic used to find the runtime library in a list
of modules.

Depends on D23043.

[kubamracek]

LGTM. While you’re at it, could you also reformat with clang-format? I noticed that the files inconsistently use curly braces on same line or new line.

[vsk]

Thanks for the review!

Normally I'd be happy to commit some clang-format changes as a follow-up, but the lldb team is planning on doing a project-wide clang-format commit in early September. Maybe it would be best to wait for that?

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

protected:
     }
 
     void
     SetActive(bool IsActive)
     {
         m_is_active = IsActive;
     }
 
+    /// Return a regular expression which can be used to identify a valid version of the runtime library.
+    virtual const RegularExpression &
+    GetPatternForRuntimeLibrary() = 0;
+
+    /// Check whether \p module_sp corresponds to a valid runtime library.
+    virtual bool
+    CheckIfRuntimeIsValid(const lldb::ModuleSP module_sp) = 0;
+
+    /// Register a breakpoint in the runtime library and perform any other necessary initialization. The runtime library
+    /// is guaranteed to be loaded.
+    virtual void
+    Activate() = 0;
+
 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) = 0;
+    void
+    ModulesDidLoad(lldb_private::ModuleList &module_list);
 
     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:
     GetType() { return GetTypeStatic(); }
     
     uint32_t
     GetPluginVersion() override
     {
         return 1;
     }
     
-    void
-    ModulesDidLoad(lldb_private::ModuleList &module_list) override;
-    
 private:
     AddressSanitizerRuntime(const lldb::ProcessSP &process_sp) : lldb_private::InstrumentationRuntime(process_sp) {}
 
+    const RegularExpression &
+    GetPatternForRuntimeLibrary() override;
+
+    bool
+    CheckIfRuntimeIsValid(const lldb::ModuleSP module_sp) override;
+
     void
-    Activate();
-    
+    Activate() override;
     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);
 };
     
 } // namespace lldb_private
 
 #endif // liblldb_AddressSanitizerRuntime_h_

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

 //===-- AddressSanitizerRuntime.cpp -----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "AddressSanitizerRuntime.h"
 
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
-#include "lldb/Core/ModuleList.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Expression/UserExpression.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
AddressSanitizerRuntime::GetTypeStatic()
     return eInstrumentationRuntimeTypeAddressSanitizer;
 }
 
 AddressSanitizerRuntime::~AddressSanitizerRuntime()
 {
     Deactivate();
 }
 
-bool ModuleContainsASanRuntime(Module * module)
+const RegularExpression &
+AddressSanitizerRuntime::GetPatternForRuntimeLibrary()
 {
-    const Symbol* symbol = module->FindFirstSymbolWithNameAndType(
-            ConstString("__asan_get_alloc_stack"),
-            lldb::eSymbolTypeAny);
-
-    return symbol != nullptr;
+    // FIXME: This shouldn't include the "dylib" suffix.
+    static RegularExpression regex("libclang_rt.asan_(.*)_dynamic\\.dylib");
+    return regex;
 }
 
-void
-AddressSanitizerRuntime::ModulesDidLoad(lldb_private::ModuleList &module_list)
+bool
+AddressSanitizerRuntime::CheckIfRuntimeIsValid(const lldb::ModuleSP module_sp)
 {
-    if (IsActive())
-        return;
-    
-    if (GetRuntimeModuleSP()) {
-        Activate();
-        return;
-    }
+    const Symbol *symbol =
+        module_sp->FindFirstSymbolWithNameAndType(ConstString("__asan_get_alloc_stack"), lldb::eSymbolTypeAny);
 
-    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))
-            {
-                SetRuntimeModuleSP(module_pointer->shared_from_this());
-                Activate();
-                return;
-            }
-        }
-    }
+    return symbol != nullptr;
 }
 
 #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();

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

public:
     GetType() { return GetTypeStatic(); }
     
     uint32_t
     GetPluginVersion() override
     {
         return 1;
     }
     
-    void
-    ModulesDidLoad(lldb_private::ModuleList &module_list) override;
-    
     lldb::ThreadCollectionSP
     GetBacktracesFromExtendedStopInfo(StructuredData::ObjectSP info) override;
     
 private:
     ThreadSanitizerRuntime(const lldb::ProcessSP &process_sp) : lldb_private::InstrumentationRuntime(process_sp) {}
 
+    const RegularExpression &
+    GetPatternForRuntimeLibrary() override;
+
+    bool
+    CheckIfRuntimeIsValid(const lldb::ModuleSP module_sp) override;
+
     void
-    Activate();
+    Activate() override;
     
     void
     Deactivate();
     
     static bool
     NotifyBreakpointHit(void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
     
     StructuredData::ObjectSP

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

 //===-- ThreadSanitizerRuntime.cpp ------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ThreadSanitizerRuntime.h"
 
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
-#include "lldb/Core/ModuleList.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Expression/UserExpression.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
ThreadSanitizerRuntime::GetTypeStatic()
     return eInstrumentationRuntimeTypeThreadSanitizer;
 }
 
 ThreadSanitizerRuntime::~ThreadSanitizerRuntime()
 {
     Deactivate();
 }
 
-static bool
-ModuleContainsTSanRuntime(ModuleSP module_sp)
-{
-    static ConstString g_tsan_get_current_report("__tsan_get_current_report");
-    const Symbol* symbol = module_sp->FindFirstSymbolWithNameAndType(g_tsan_get_current_report, lldb::eSymbolTypeAny);
-    return symbol != nullptr;
-}
-
-void
-ThreadSanitizerRuntime::ModulesDidLoad(lldb_private::ModuleList &module_list)
-{
-    if (IsActive())
-        return;
-    
-    if (GetRuntimeModuleSP()) {
-        Activate();
-        return;
-    }
-    
-    module_list.ForEach ([this](const lldb::ModuleSP module_sp) -> bool
-    {
-        const FileSpec & file_spec = module_sp->GetFileSpec();
-        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))
-            {
-                SetRuntimeModuleSP(module_sp);
-                Activate();
-                return false; // Stop iterating
-            }
-        }
-
-        return true; // Keep iterating through modules
-    });
-}
-
 #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,
if (process_sp && process_sp == context->exe_ctx_ref.GetProcessSP())
             stream_sp->Printf ("ThreadSanitizer report breakpoint hit. Use 'thread info -s' to get extended information about the report.\n");
         }
         return true;    // Return true to stop the target
     }
     else
         return false;   // Let target run
 }
 
+const RegularExpression &
+ThreadSanitizerRuntime::GetPatternForRuntimeLibrary() {
+  static RegularExpression regex("libclang_rt.tsan_");
+  return regex;
+}
+
+bool
+ThreadSanitizerRuntime::CheckIfRuntimeIsValid(const lldb::ModuleSP module_sp)
+{
+    static ConstString g_tsan_get_current_report("__tsan_get_current_report");
+    const Symbol *symbol = module_sp->FindFirstSymbolWithNameAndType(g_tsan_get_current_report, lldb::eSymbolTypeAny);
+    return symbol != nullptr;
+}
+
 void
 ThreadSanitizerRuntime::Activate()
 {
     if (IsActive())
         return;
     
     ProcessSP process_sp = GetProcessSP();
     if (!process_sp)
if (GetBreakpointID() != LLDB_INVALID_BREAK_ID)
         if (process_sp)
         {
             process_sp->GetTarget().RemoveBreakpointByID(GetBreakpointID());
             SetBreakpointID(LLDB_INVALID_BREAK_ID);
         }
     }
     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();
         int thread_id = o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
         bool is_write = o->GetObjectForDotSeparatedPath("is_write")->GetBooleanValue();

lldb/trunk/source/Target/InstrumentationRuntime.cpp

 //===-- InstrumentationRuntime.cpp ------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Target/Process.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/ModuleList.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Core/RegularExpression.h"
 #include "lldb/Target/InstrumentationRuntime.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void
 InstrumentationRuntime::ModulesDidLoad(lldb_private::ModuleList &module_list, lldb_private::Process *process, InstrumentationRuntimeCollection &runtimes)
 {
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)
+{
+    if (IsActive())
+        return;
+
+    if (GetRuntimeModuleSP())
+    {
+        Activate();
+        return;
+    }
+
+    module_list.ForEach([this](const lldb::ModuleSP module_sp) -> bool {
+        const FileSpec &file_spec = module_sp->GetFileSpec();
+        if (!file_spec)
+            return true; // Keep iterating.
+
+        const RegularExpression &runtime_regex = GetPatternForRuntimeLibrary();
+        if (runtime_regex.Execute(file_spec.GetFilename().GetCString()) || module_sp->IsExecutable())
+        {
+            if (CheckIfRuntimeIsValid(module_sp))
+            {
+                SetRuntimeModuleSP(module_sp);
+                Activate();
+                return false; // Stop iterating, we're done.
+            }
+        }
+
+        return true;
+    });
+}
+
 lldb::ThreadCollectionSP
 InstrumentationRuntime::GetBacktracesFromExtendedStopInfo(StructuredData::ObjectSP info)
 {
     return ThreadCollectionSP(new ThreadCollection());
 }