source/Plugins/MemoryHistory/asan/MemoryHistoryASan.cpp

   1 //===-- MemoryHistoryASan.cpp -----------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "MemoryHistoryASan.h"
  11
  12 #include "lldb/Target/MemoryHistory.h"
  13
  14 #include "lldb/lldb-private.h"
  15 #include "lldb/Core/Debugger.h"
  16 #include "lldb/Core/PluginInterface.h"
  17 #include "lldb/Core/PluginManager.h"
  18 #include "lldb/Expression/UserExpression.h"
  19 #include "lldb/Target/ThreadList.h"
  20 #include "lldb/Target/ExecutionContext.h"
  21 #include "lldb/Target/Target.h"
  22 #include "lldb/Target/Thread.h"
  23 #include "lldb/Core/Module.h"
  24 #include "Plugins/Process/Utility/HistoryThread.h"
  25 #include "lldb/Core/ValueObject.h"
  26
  27 #include <sstream>
  28
  29 using namespace lldb;
  30 using namespace lldb_private;
  31
  32 MemoryHistorySP
  33 MemoryHistoryASan::CreateInstance (const ProcessSP &process_sp)
  34 {
  35     if (!process_sp.get())
  36         return NULL;
  37
  38     Target & target = process_sp->GetTarget();
  39
  40     const ModuleList &target_modules = target.GetImages();
  41     std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
  42     const size_t num_modules = target_modules.GetSize();
  43     for (size_t i = 0; i < num_modules; ++i)
  44     {
  45         Module *module_pointer = target_modules.GetModulePointerAtIndexUnlocked(i);
  46
  47         const Symbol* symbol = module_pointer->FindFirstSymbolWithNameAndType(
  48                 ConstString("__asan_get_alloc_stack"),
  49                 lldb::eSymbolTypeAny);
  50
  51         if (symbol != nullptr)
  52             return MemoryHistorySP(new MemoryHistoryASan(process_sp));
  53     }
  54
  55     return MemoryHistorySP();
  56 }
  57
  58 void
  59 MemoryHistoryASan::Initialize()
  60 {
  61     PluginManager::RegisterPlugin (GetPluginNameStatic(),
  62                                    "ASan memory history provider.",
  63                                    CreateInstance);
  64 }
  65
  66 void
  67 MemoryHistoryASan::Terminate()
  68 {
  69     PluginManager::UnregisterPlugin (CreateInstance);
  70 }
  71
  72
  73 ConstString
  74 MemoryHistoryASan::GetPluginNameStatic()
  75 {
  76     static ConstString g_name("asan");
  77     return g_name;
  78 }
  79
  80 MemoryHistoryASan::MemoryHistoryASan(const ProcessSP &process_sp)
  81 {
  82     if (process_sp)
  83         m_process_wp = process_sp;
  84 }
  85
  86 const char *
  87 memory_history_asan_command_prefix = R"(
  88     extern "C"
  89     {
  90         size_t __asan_get_alloc_stack(void *addr, void **trace, size_t size, int *thread_id);
  91         size_t __asan_get_free_stack(void *addr, void **trace, size_t size, int *thread_id);
  92     }
  93
  94     struct data {
  95         void *alloc_trace[256];
  96         size_t alloc_count;
  97         int alloc_tid;
  98
  99         void *free_trace[256];
 100         size_t free_count;
 101         int free_tid;
 102     };
 103 )";
 104
 105 const char *
 106 memory_history_asan_command_format = R"(
 107     data t;
 108
 109     t.alloc_count = __asan_get_alloc_stack((void *)0x%)" PRIx64 R"(, t.alloc_trace, 256, &t.alloc_tid);
 110     t.free_count = __asan_get_free_stack((void *)0x%)" PRIx64 R"(, t.free_trace, 256, &t.free_tid);
 111
 112     t;
 113 )";
 114
 115 static void CreateHistoryThreadFromValueObject(ProcessSP process_sp, ValueObjectSP return_value_sp, const char *type, const char *thread_name, HistoryThreads & result)
 116 {
 117     std::string count_path = "." + std::string(type) + "_count";
 118     std::string tid_path = "." + std::string(type) + "_tid";
 119     std::string trace_path = "." + std::string(type) + "_trace";
 120
 121     ValueObjectSP count_sp = return_value_sp->GetValueForExpressionPath(count_path.c_str());
 122     ValueObjectSP tid_sp = return_value_sp->GetValueForExpressionPath(tid_path.c_str());
 123
 124     if (!count_sp || !tid_sp)
 125         return;
 126
 127     int count = count_sp->GetValueAsUnsigned(0);
 128     tid_t tid = tid_sp->GetValueAsUnsigned(0) + 1;
 129
 130     if (count <= 0)
 131         return;
 132
 133     ValueObjectSP trace_sp = return_value_sp->GetValueForExpressionPath(trace_path.c_str());
 134
 135     if (!trace_sp)
 136         return;
 137
 138     std::vector<lldb::addr_t> pcs;
 139     for (int i = 0; i < count; i++)
 140     {
 141         addr_t pc = trace_sp->GetChildAtIndex(i, true)->GetValueAsUnsigned(0);
 142         if (pc == 0 || pc == 1 || pc == LLDB_INVALID_ADDRESS)
 143             continue;
 144         pcs.push_back(pc);
 145     }
 146
 147     HistoryThread *history_thread = new HistoryThread(*process_sp, tid, pcs, 0, false);
 148     ThreadSP new_thread_sp(history_thread);
 149     std::ostringstream thread_name_with_number;
 150     thread_name_with_number << thread_name << " Thread " << tid;
 151     history_thread->SetThreadName(thread_name_with_number.str().c_str());
 152     // Save this in the Process' ExtendedThreadList so a strong pointer retains the object
 153     process_sp->GetExtendedThreadList().AddThread (new_thread_sp);
 154     result.push_back(new_thread_sp);
 155 }
 156
 157 #define GET_STACK_FUNCTION_TIMEOUT_USEC 2*1000*1000
 158
 159 HistoryThreads
 160 MemoryHistoryASan::GetHistoryThreads(lldb::addr_t address)
 161 {
 162     HistoryThreads result;
 163
 164     ProcessSP process_sp = m_process_wp.lock();
 165     if (! process_sp)
 166         return result;
 167
 168     ThreadSP thread_sp = process_sp->GetThreadList().GetExpressionExecutionThread();
 169     if (!thread_sp)
 170         return result;
 171
 172     StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
 173     if (!frame_sp)
 174         return result;
 175
 176     ExecutionContext exe_ctx (frame_sp);
 177     ValueObjectSP return_value_sp;
 178     StreamString expr;
 179     Error eval_error;
 180     expr.Printf(memory_history_asan_command_format, address, address);
 181
 182     EvaluateExpressionOptions options;
 183     options.SetUnwindOnError(true);
 184     options.SetTryAllThreads(true);
 185     options.SetStopOthers(true);
 186     options.SetIgnoreBreakpoints(true);
 187     options.SetTimeoutUsec(GET_STACK_FUNCTION_TIMEOUT_USEC);
 188     options.SetPrefix(memory_history_asan_command_prefix);
 189     options.SetAutoApplyFixIts(false);
 190     options.SetLanguage(eLanguageTypeObjC_plus_plus);
 191
 192     ExpressionResults expr_result = UserExpression::Evaluate (exe_ctx,
 193                                       options,
 194                                       expr.GetData(),
 195                                       "",
 196                                       return_value_sp,
 197                                       eval_error);
 198     if (expr_result != eExpressionCompleted) {
 199         process_sp->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf("Warning: Cannot evaluate AddressSanitizer expression:\n%s\n", eval_error.AsCString());
 200         return result;
 201     }
 202
 203     if (!return_value_sp)
 204         return result;
 205
 206     CreateHistoryThreadFromValueObject(process_sp, return_value_sp, "free", "Memory deallocated by", result);
 207     CreateHistoryThreadFromValueObject(process_sp, return_value_sp, "alloc", "Memory allocated by", result);
 208
 209     return result;
 210 }