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