LLDB  mainline
MemoryHistoryASan.cpp
Go to the documentation of this file.
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 
12 
14 #include "lldb/Core/Debugger.h"
15 #include "lldb/Core/Module.h"
18 #include "lldb/Core/ValueObject.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 
28 using namespace lldb;
29 using namespace lldb_private;
30 
32 
33 MemoryHistorySP MemoryHistoryASan::CreateInstance(const ProcessSP &process_sp) {
34  if (!process_sp.get())
35  return nullptr;
36 
37  Target &target = process_sp->GetTarget();
38 
39  for (ModuleSP module_sp : target.GetImages().Modules()) {
40  const Symbol *symbol = module_sp->FindFirstSymbolWithNameAndType(
41  ConstString("__asan_get_alloc_stack"), lldb::eSymbolTypeAny);
42 
43  if (symbol != nullptr)
44  return MemoryHistorySP(new MemoryHistoryASan(process_sp));
45  }
46 
47  return MemoryHistorySP();
48 }
49 
50 void MemoryHistoryASan::Initialize() {
51  PluginManager::RegisterPlugin(
52  GetPluginNameStatic(), "ASan memory history provider.", CreateInstance);
53 }
54 
55 void MemoryHistoryASan::Terminate() {
56  PluginManager::UnregisterPlugin(CreateInstance);
57 }
58 
59 ConstString MemoryHistoryASan::GetPluginNameStatic() {
60  static ConstString g_name("asan");
61  return g_name;
62 }
63 
64 MemoryHistoryASan::MemoryHistoryASan(const ProcessSP &process_sp) {
65  if (process_sp)
66  m_process_wp = process_sp;
67 }
68 
70  extern "C"
71  {
72  size_t __asan_get_alloc_stack(void *addr, void **trace, size_t size, int *thread_id);
73  size_t __asan_get_free_stack(void *addr, void **trace, size_t size, int *thread_id);
74  }
75 
76  struct data {
77  void *alloc_trace[256];
78  size_t alloc_count;
79  int alloc_tid;
80 
81  void *free_trace[256];
82  size_t free_count;
83  int free_tid;
84  };
85 )";
86 
88  R"(
89  data t;
90 
91  t.alloc_count = __asan_get_alloc_stack((void *)0x%)" PRIx64
92  R"(, t.alloc_trace, 256, &t.alloc_tid);
93  t.free_count = __asan_get_free_stack((void *)0x%)" PRIx64
94  R"(, t.free_trace, 256, &t.free_tid);
95 
96  t;
97 )";
98 
99 static void CreateHistoryThreadFromValueObject(ProcessSP process_sp,
100  ValueObjectSP return_value_sp,
101  const char *type,
102  const char *thread_name,
103  HistoryThreads &result) {
104  std::string count_path = "." + std::string(type) + "_count";
105  std::string tid_path = "." + std::string(type) + "_tid";
106  std::string trace_path = "." + std::string(type) + "_trace";
107 
108  ValueObjectSP count_sp =
109  return_value_sp->GetValueForExpressionPath(count_path.c_str());
110  ValueObjectSP tid_sp =
111  return_value_sp->GetValueForExpressionPath(tid_path.c_str());
112 
113  if (!count_sp || !tid_sp)
114  return;
115 
116  int count = count_sp->GetValueAsUnsigned(0);
117  tid_t tid = tid_sp->GetValueAsUnsigned(0) + 1;
118 
119  if (count <= 0)
120  return;
121 
122  ValueObjectSP trace_sp =
123  return_value_sp->GetValueForExpressionPath(trace_path.c_str());
124 
125  if (!trace_sp)
126  return;
127 
128  std::vector<lldb::addr_t> pcs;
129  for (int i = 0; i < count; i++) {
130  addr_t pc = trace_sp->GetChildAtIndex(i, true)->GetValueAsUnsigned(0);
131  if (pc == 0 || pc == 1 || pc == LLDB_INVALID_ADDRESS)
132  continue;
133  pcs.push_back(pc);
134  }
135 
136  // The ASAN runtime already massages the return addresses into call
137  // addresses, we don't want LLDB's unwinder to try to locate the previous
138  // instruction again as this might lead to us reporting a different line.
139  bool pcs_are_call_addresses = true;
140  HistoryThread *history_thread =
141  new HistoryThread(*process_sp, tid, pcs, pcs_are_call_addresses);
142  ThreadSP new_thread_sp(history_thread);
143  std::ostringstream thread_name_with_number;
144  thread_name_with_number << thread_name << " Thread " << tid;
145  history_thread->SetThreadName(thread_name_with_number.str().c_str());
146  // Save this in the Process' ExtendedThreadList so a strong pointer retains
147  // the object
148  process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
149  result.push_back(new_thread_sp);
150 }
151 
152 HistoryThreads MemoryHistoryASan::GetHistoryThreads(lldb::addr_t address) {
153  HistoryThreads result;
154 
155  ProcessSP process_sp = m_process_wp.lock();
156  if (!process_sp)
157  return result;
158 
159  ThreadSP thread_sp =
160  process_sp->GetThreadList().GetExpressionExecutionThread();
161  if (!thread_sp)
162  return result;
163 
164  StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
165  if (!frame_sp)
166  return result;
167 
168  ExecutionContext exe_ctx(frame_sp);
169  ValueObjectSP return_value_sp;
170  StreamString expr;
171  Status eval_error;
172  expr.Printf(memory_history_asan_command_format, address, address);
173 
175  options.SetUnwindOnError(true);
176  options.SetTryAllThreads(true);
177  options.SetStopOthers(true);
178  options.SetIgnoreBreakpoints(true);
179  options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
181  options.SetAutoApplyFixIts(false);
183 
184  ExpressionResults expr_result = UserExpression::Evaluate(
185  exe_ctx, options, expr.GetString(), "", return_value_sp, eval_error);
186  if (expr_result != eExpressionCompleted) {
187  process_sp->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(
188  "Warning: Cannot evaluate AddressSanitizer expression:\n%s\n",
189  eval_error.AsCString());
190  return result;
191  }
192 
193  if (!return_value_sp)
194  return result;
195 
196  CreateHistoryThreadFromValueObject(process_sp, return_value_sp, "free",
197  "Memory deallocated by", result);
198  CreateHistoryThreadFromValueObject(process_sp, return_value_sp, "alloc",
199  "Memory allocated by", result);
200 
201  return result;
202 }
MemoryHistory.h
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
lldb_private::ModuleList::Modules
ModuleIterable Modules() const
Definition: ModuleList.h:482
lldb_private::EvaluateExpressionOptions::SetTimeout
void SetTimeout(const Timeout< std::micro > &timeout)
Definition: Target.h:326
lldb_private::EvaluateExpressionOptions::SetLanguage
void SetLanguage(lldb::LanguageType language)
Definition: Target.h:286
lldb_private::Symbol
Definition: Symbol.h:20
lldb::ExpressionResults
ExpressionResults
The results of expression evaluation.
Definition: lldb-enumerations.h:270
Module.h
lldb_private::EvaluateExpressionOptions
Definition: Target.h:258
MemoryHistoryASan.h
lldb_private::HistoryThread
Definition: HistoryThread.h:33
UserExpression.h
HistoryThread.h
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
pc
@ pc
Definition: CompactUnwindInfo.cpp:1250
Debugger.h
lldb_private::Target
Definition: Target.h:450
CreateHistoryThreadFromValueObject
static void CreateHistoryThreadFromValueObject(ProcessSP process_sp, ValueObjectSP return_value_sp, const char *type, const char *thread_name, HistoryThreads &result)
Definition: MemoryHistoryASan.cpp:99
lldb_private::Target::GetImages
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:924
lldb_private::StreamString::GetString
llvm::StringRef GetString() const
Definition: StreamString.cpp:51
lldb_private::HistoryThread::SetThreadName
void SetThreadName(const char *name)
Definition: HistoryThread.h:70
Target.h
lldb::eSymbolTypeAny
@ eSymbolTypeAny
Definition: lldb-enumerations.h:613
memory_history_asan_command_prefix
const char * memory_history_asan_command_prefix
Definition: MemoryHistoryASan.cpp:69
lldb::eExpressionCompleted
@ eExpressionCompleted
Definition: lldb-enumerations.h:271
lldb_private::ConstString
Definition: ConstString.h:40
lldb_private::StreamString
Definition: StreamString.h:23
lldb_private::EvaluateExpressionOptions::SetTryAllThreads
void SetTryAllThreads(bool try_others=true)
Definition: Target.h:338
PluginInterface.h
ThreadList.h
lldb_private::MemoryHistoryASan
Definition: MemoryHistoryASan.h:19
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
lldb_private::EvaluateExpressionOptions::SetUnwindOnError
void SetUnwindOnError(bool unwind=false)
Definition: Target.h:305
Thread.h
lldb::eLanguageTypeObjC_plus_plus
@ eLanguageTypeObjC_plus_plus
Objective-C++.
Definition: lldb-enumerations.h:454
ValueObject.h
lldb-private.h
lldb_private::EvaluateExpressionOptions::SetIgnoreBreakpoints
void SetIgnoreBreakpoints(bool ignore=false)
Definition: Target.h:309
lldb_private::Status
Definition: Status.h:44
memory_history_asan_command_format
const char * memory_history_asan_command_format
Definition: MemoryHistoryASan.cpp:87
PluginManager.h
LLDB_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:86
lldb_private::Stream::Printf
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::HistoryThreads
std::vector< lldb::ThreadSP > HistoryThreads
Definition: MemoryHistory.h:21
LLDB_PLUGIN_DEFINE
#define LLDB_PLUGIN_DEFINE(PluginName)
Definition: PluginManager.h:31
lldb_private::EvaluateExpressionOptions::SetStopOthers
void SetStopOthers(bool stop_others=true)
Definition: Target.h:342
lldb_private::EvaluateExpressionOptions::SetPrefix
void SetPrefix(const char *prefix)
Definition: Target.h:294
lldb
Definition: SBAddress.h:15
ExecutionContext.h
lldb::tid_t
uint64_t tid_t
Definition: lldb-types.h:86
lldb_private::Status::AsCString
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:131
lldb_private::EvaluateExpressionOptions::SetAutoApplyFixIts
void SetAutoApplyFixIts(bool b)
Definition: Target.h:401