1//===-- InstrumentationRuntimeUBSan.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 "InstrumentationRuntimeUBSan.h"
10
11#include "Plugins/Process/Utility/HistoryThread.h"
12#include "lldb/Breakpoint/StoppointCallbackContext.h"
13#include "lldb/Core/Debugger.h"
14#include "lldb/Core/Module.h"
15#include "lldb/Core/PluginInterface.h"
16#include "lldb/Core/PluginManager.h"
17#include "lldb/Core/ValueObject.h"
18#include "lldb/Expression/UserExpression.h"
19#include "lldb/Host/StreamFile.h"
20#include "lldb/Interpreter/CommandReturnObject.h"
21#include "lldb/Symbol/Symbol.h"
22#include "lldb/Symbol/SymbolContext.h"
23#include "lldb/Symbol/Variable.h"
24#include "lldb/Symbol/VariableList.h"
25#include "lldb/Target/InstrumentationRuntimeStopInfo.h"
26#include "lldb/Target/SectionLoadList.h"
27#include "lldb/Target/StopInfo.h"
28#include "lldb/Target/Target.h"
29#include "lldb/Target/Thread.h"
30#include "lldb/Utility/RegularExpression.h"
31#include "lldb/Utility/Stream.h"
32#include <cctype>
33
34#include <memory>
35
36using namespace lldb;
37using namespace lldb_private;
38
39LLDB_PLUGIN_DEFINE(InstrumentationRuntimeUBSan)
40
41InstrumentationRuntimeUBSan::~InstrumentationRuntimeUBSan() { Deactivate(); }
42
43lldb::InstrumentationRuntimeSP
44InstrumentationRuntimeUBSan::CreateInstance(const lldb::ProcessSP &process_sp) {
45  return InstrumentationRuntimeSP(new InstrumentationRuntimeUBSan(process_sp));
46}
47
48void InstrumentationRuntimeUBSan::Initialize() {
49  PluginManager::RegisterPlugin(
50      GetPluginNameStatic(),
51      "UndefinedBehaviorSanitizer instrumentation runtime plugin.",
52      CreateInstance, GetTypeStatic);
53}
54
55void InstrumentationRuntimeUBSan::Terminate() {
56  PluginManager::UnregisterPlugin(CreateInstance);
57}
58
59lldb::InstrumentationRuntimeType InstrumentationRuntimeUBSan::GetTypeStatic() {
60  return eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer;
61}
62
63static const char *ub_sanitizer_retrieve_report_data_prefix = R"(
64extern "C" {
65void
66__ubsan_get_current_report_data(const char **OutIssueKind,
67    const char **OutMessage, const char **OutFilename, unsigned *OutLine,
68    unsigned *OutCol, char **OutMemoryAddr);
69}
70)";
71
72static const char *ub_sanitizer_retrieve_report_data_command = R"(
73struct {
74  const char *issue_kind;
75  const char *message;
76  const char *filename;
77  unsigned line;
78  unsigned col;
79  char *memory_addr;
80} t;
81
82__ubsan_get_current_report_data(&t.issue_kind, &t.message, &t.filename, &t.line,
83                                &t.col, &t.memory_addr);
84t;
85)";
86
87static addr_t RetrieveUnsigned(ValueObjectSP return_value_sp,
88                               ProcessSP process_sp,
89                               const std::string &expression_path) {
90  return return_value_sp->GetValueForExpressionPath(expression_path.c_str())
91      ->GetValueAsUnsigned(0);
92}
93
94static std::string RetrieveString(ValueObjectSP return_value_sp,
95                                  ProcessSP process_sp,
96                                  const std::string &expression_path) {
97  addr_t ptr = RetrieveUnsigned(return_value_sp, process_sp, expression_path);
98  std::string str;
99  Status error;
100  process_sp->ReadCStringFromMemory(ptr, str, error);
101  return str;
102}
103
104StructuredData::ObjectSP InstrumentationRuntimeUBSan::RetrieveReportData(
105    ExecutionContextRef exe_ctx_ref) {
106  ProcessSP process_sp = GetProcessSP();
107  if (!process_sp)
108    return StructuredData::ObjectSP();
109
110  ThreadSP thread_sp = exe_ctx_ref.GetThreadSP();
111  StackFrameSP frame_sp =
112      thread_sp->GetSelectedFrame(DoNoSelectMostRelevantFrame);
113  ModuleSP runtime_module_sp = GetRuntimeModuleSP();
114  Target &target = process_sp->GetTarget();
115
116  if (!frame_sp)
117    return StructuredData::ObjectSP();
118
119  StreamFileSP Stream = target.GetDebugger().GetOutputStreamSP();
120
121  EvaluateExpressionOptions options;
122  options.SetUnwindOnError(true);
123  options.SetTryAllThreads(true);
124  options.SetStopOthers(true);
125  options.SetIgnoreBreakpoints(true);
126  options.SetTimeout(process_sp->GetUtilityExpressionTimeout());
127  options.SetPrefix(ub_sanitizer_retrieve_report_data_prefix);
128  options.SetAutoApplyFixIts(false);
129  options.SetLanguage(eLanguageTypeObjC_plus_plus);
130
131  ValueObjectSP main_value;
132  ExecutionContext exe_ctx;
133  Status eval_error;
134  frame_sp->CalculateExecutionContext(exe_ctx);
135  ExpressionResults result = UserExpression::Evaluate(
136      exe_ctx, options, ub_sanitizer_retrieve_report_data_command, "",
137      main_value, eval_error);
138  if (result != eExpressionCompleted) {
139    StreamString ss;
140    ss << "cannot evaluate UndefinedBehaviorSanitizer expression:\n";
141    ss << eval_error.AsCString();
142    Debugger::ReportWarning(ss.GetString().str(),
143                            process_sp->GetTarget().GetDebugger().GetID());
144    return StructuredData::ObjectSP();
145  }
146
147  // Gather the PCs of the user frames in the backtrace.
148  StructuredData::Array *trace = new StructuredData::Array();
149  auto trace_sp = StructuredData::ObjectSP(trace);
150  for (unsigned I = 0; I < thread_sp->GetStackFrameCount(); ++I) {
151    const Address FCA = thread_sp->GetStackFrameAtIndex(I)
152                            ->GetFrameCodeAddressForSymbolication();
153    if (FCA.GetModule() == runtime_module_sp) // Skip PCs from the runtime.
154      continue;
155
156    lldb::addr_t PC = FCA.GetLoadAddress(&target);
157    trace->AddIntegerItem(PC);
158  }
159
160  std::string IssueKind = RetrieveString(main_value, process_sp, ".issue_kind");
161  std::string ErrMessage = RetrieveString(main_value, process_sp, ".message");
162  std::string Filename = RetrieveString(main_value, process_sp, ".filename");
163  unsigned Line = RetrieveUnsigned(main_value, process_sp, ".line");
164  unsigned Col = RetrieveUnsigned(main_value, process_sp, ".col");
165  uintptr_t MemoryAddr =
166      RetrieveUnsigned(main_value, process_sp, ".memory_addr");
167
168  auto *d = new StructuredData::Dictionary();
169  auto dict_sp = StructuredData::ObjectSP(d);
170  d->AddStringItem("instrumentation_class", "UndefinedBehaviorSanitizer");
171  d->AddStringItem("description", IssueKind);
172  d->AddStringItem("summary", ErrMessage);
173  d->AddStringItem("filename", Filename);
174  d->AddIntegerItem("line", Line);
175  d->AddIntegerItem("col", Col);
176  d->AddIntegerItem("memory_address", MemoryAddr);
177  d->AddIntegerItem("tid", thread_sp->GetID());
178  d->AddItem("trace", trace_sp);
179  return dict_sp;
180}
181
182static std::string GetStopReasonDescription(StructuredData::ObjectSP report) {
183  llvm::StringRef stop_reason_description_ref;
184  report->GetAsDictionary()->GetValueForKeyAsString(
185      "description", stop_reason_description_ref);
186  std::string stop_reason_description =
187      std::string(stop_reason_description_ref);
188
189  if (!stop_reason_description.size()) {
190    stop_reason_description = "Undefined behavior detected";
191  } else {
192    stop_reason_description[0] = toupper(stop_reason_description[0]);
193    for (unsigned I = 1; I < stop_reason_description.size(); ++I)
194      if (stop_reason_description[I] == '-')
195        stop_reason_description[I] = ' ';
196  }
197  return stop_reason_description;
198}
199
200bool InstrumentationRuntimeUBSan::NotifyBreakpointHit(
201    void *baton, StoppointCallbackContext *context, user_id_t break_id,
202    user_id_t break_loc_id) {
203  assert(baton && "null baton");
204  if (!baton)
205    return false; ///< false => resume execution.
206
207  InstrumentationRuntimeUBSan *const instance =
208      static_cast<InstrumentationRuntimeUBSan *>(baton);
209
210  ProcessSP process_sp = instance->GetProcessSP();
211  ThreadSP thread_sp = context->exe_ctx_ref.GetThreadSP();
212  if (!process_sp || !thread_sp ||
213      process_sp != context->exe_ctx_ref.GetProcessSP())
214    return false;
215
216  if (process_sp->GetModIDRef().IsLastResumeForUserExpression())
217    return false;
218
219  StructuredData::ObjectSP report =
220      instance->RetrieveReportData(context->exe_ctx_ref);
221
222  if (report) {
223    thread_sp->SetStopInfo(
224        InstrumentationRuntimeStopInfo::CreateStopReasonWithInstrumentationData(
225            *thread_sp, GetStopReasonDescription(report), report));
226    return true;
227  }
228
229  return false;
230}
231
232const RegularExpression &
233InstrumentationRuntimeUBSan::GetPatternForRuntimeLibrary() {
234  static RegularExpression regex(llvm::StringRef("libclang_rt\\.(a|t|ub)san_"));
235  return regex;
236}
237
238bool InstrumentationRuntimeUBSan::CheckIfRuntimeIsValid(
239    const lldb::ModuleSP module_sp) {
240  static ConstString ubsan_test_sym("__ubsan_on_report");
241  const Symbol *symbol = module_sp->FindFirstSymbolWithNameAndType(
242      ubsan_test_sym, lldb::eSymbolTypeAny);
243  return symbol != nullptr;
244}
245
246// FIXME: Factor out all the logic we have in common with the {a,t}san plugins.
247void InstrumentationRuntimeUBSan::Activate() {
248  if (IsActive())
249    return;
250
251  ProcessSP process_sp = GetProcessSP();
252  if (!process_sp)
253    return;
254
255  ModuleSP runtime_module_sp = GetRuntimeModuleSP();
256
257  ConstString symbol_name("__ubsan_on_report");
258  const Symbol *symbol = runtime_module_sp->FindFirstSymbolWithNameAndType(
259      symbol_name, eSymbolTypeCode);
260
261  if (symbol == nullptr)
262    return;
263
264  if (!symbol->ValueIsAddress() || !symbol->GetAddressRef().IsValid())
265    return;
266
267  Target &target = process_sp->GetTarget();
268  addr_t symbol_address = symbol->GetAddressRef().GetOpcodeLoadAddress(&target);
269
270  if (symbol_address == LLDB_INVALID_ADDRESS)
271    return;
272
273  Breakpoint *breakpoint =
274      process_sp->GetTarget()
275          .CreateBreakpoint(symbol_address, /*internal=*/true,
276                            /*hardware=*/false)
277          .get();
278  const bool sync = false;
279  breakpoint->SetCallback(InstrumentationRuntimeUBSan::NotifyBreakpointHit,
280                          this, sync);
281  breakpoint->SetBreakpointKind("undefined-behavior-sanitizer-report");
282  SetBreakpointID(breakpoint->GetID());
283
284  SetActive(true);
285}
286
287void InstrumentationRuntimeUBSan::Deactivate() {
288  SetActive(false);
289
290  auto BID = GetBreakpointID();
291  if (BID == LLDB_INVALID_BREAK_ID)
292    return;
293
294  if (ProcessSP process_sp = GetProcessSP()) {
295    process_sp->GetTarget().RemoveBreakpointByID(BID);
296    SetBreakpointID(LLDB_INVALID_BREAK_ID);
297  }
298}
299
300lldb::ThreadCollectionSP
301InstrumentationRuntimeUBSan::GetBacktracesFromExtendedStopInfo(
302    StructuredData::ObjectSP info) {
303  ThreadCollectionSP threads;
304  threads = std::make_shared<ThreadCollection>();
305
306  ProcessSP process_sp = GetProcessSP();
307
308  if (info->GetObjectForDotSeparatedPath("instrumentation_class")
309          ->GetStringValue() != "UndefinedBehaviorSanitizer")
310    return threads;
311
312  std::vector<lldb::addr_t> PCs;
313  auto trace = info->GetObjectForDotSeparatedPath("trace")->GetAsArray();
314  trace->ForEach([&PCs](StructuredData::Object *PC) -> bool {
315    PCs.push_back(PC->GetUnsignedIntegerValue());
316    return true;
317  });
318
319  if (PCs.empty())
320    return threads;
321
322  StructuredData::ObjectSP thread_id_obj =
323      info->GetObjectForDotSeparatedPath("tid");
324  tid_t tid = thread_id_obj ? thread_id_obj->GetUnsignedIntegerValue() : 0;
325
326  // We gather symbolication addresses above, so no need for HistoryThread to
327  // try to infer the call addresses.
328  bool pcs_are_call_addresses = true;
329  ThreadSP new_thread_sp = std::make_shared<HistoryThread>(
330      *process_sp, tid, PCs, pcs_are_call_addresses);
331  std::string stop_reason_description = GetStopReasonDescription(info);
332  new_thread_sp->SetName(stop_reason_description.c_str());
333
334  // Save this in the Process' ExtendedThreadList so a strong pointer retains
335  // the object
336  process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
337  threads->AddThread(new_thread_sp);
338
339  return threads;
340}
341