lldb/source/Plugins/InstrumentationRuntime/UBSan/InstrumentationRuntimeUBSan.cpp

   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/Expression/UserExpression.h"
  18 #include "lldb/Host/StreamFile.h"
  19 #include "lldb/Interpreter/CommandReturnObject.h"
  20 #include "lldb/Symbol/Symbol.h"
  21 #include "lldb/Symbol/SymbolContext.h"
  22 #include "lldb/Symbol/Variable.h"
  23 #include "lldb/Symbol/VariableList.h"
  24 #include "lldb/Target/InstrumentationRuntimeStopInfo.h"
  25 #include "lldb/Target/SectionLoadList.h"
  26 #include "lldb/Target/StopInfo.h"
  27 #include "lldb/Target/Target.h"
  28 #include "lldb/Target/Thread.h"
  29 #include "lldb/Utility/RegularExpression.h"
  30 #include "lldb/Utility/Stream.h"
  31 #include "lldb/ValueObject/ValueObject.h"
  32 #include <cctype>
  33
  34 #include <memory>
  35
  36 using namespace lldb;
  37 using namespace lldb_private;
  38
  39 LLDB_PLUGIN_DEFINE(InstrumentationRuntimeUBSan)
  40
  41 InstrumentationRuntimeUBSan::~InstrumentationRuntimeUBSan() { Deactivate(); }
  42
  43 lldb::InstrumentationRuntimeSP
  44 InstrumentationRuntimeUBSan::CreateInstance(const lldb::ProcessSP &process_sp) {
  45   return InstrumentationRuntimeSP(new InstrumentationRuntimeUBSan(process_sp));
  46 }
  47
  48 void InstrumentationRuntimeUBSan::Initialize() {
  49   PluginManager::RegisterPlugin(
  50       GetPluginNameStatic(),
  51       "UndefinedBehaviorSanitizer instrumentation runtime plugin.",
  52       CreateInstance, GetTypeStatic);
  53 }
  54
  55 void InstrumentationRuntimeUBSan::Terminate() {
  56   PluginManager::UnregisterPlugin(CreateInstance);
  57 }
  58
  59 lldb::InstrumentationRuntimeType InstrumentationRuntimeUBSan::GetTypeStatic() {
  60   return eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer;
  61 }
  62
  63 static const char *ub_sanitizer_retrieve_report_data_prefix = R"(
  64 extern "C" {
  65 void
  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
  72 static const char *ub_sanitizer_retrieve_report_data_command = R"(
  73 struct {
  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);
  84 t;
  85 )";
  86
  87 static 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
  94 static 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
 104 StructuredData::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   frame_sp->CalculateExecutionContext(exe_ctx);
 134   ExpressionResults result = UserExpression::Evaluate(
 135       exe_ctx, options, ub_sanitizer_retrieve_report_data_command, "",
 136       main_value);
 137   if (result != eExpressionCompleted) {
 138     StreamString ss;
 139     ss << "cannot evaluate UndefinedBehaviorSanitizer expression:\n";
 140     if (main_value)
 141       ss << main_value->GetError().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
 182 static 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
 200 bool 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
 232 const RegularExpression &
 233 InstrumentationRuntimeUBSan::GetPatternForRuntimeLibrary() {
 234   static RegularExpression regex(llvm::StringRef("libclang_rt\\.(a|t|ub)san_"));
 235   return regex;
 236 }
 237
 238 bool 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.
 247 void 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
 287 void 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
 300 lldb::ThreadCollectionSP
 301 InstrumentationRuntimeUBSan::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   lldb::tid_t tid =
 325       thread_id_obj ? thread_id_obj->GetUnsignedIntegerValue() : 0;
 326
 327   // We gather symbolication addresses above, so no need for HistoryThread to
 328   // try to infer the call addresses.
 329   bool pcs_are_call_addresses = true;
 330   ThreadSP new_thread_sp = std::make_shared<HistoryThread>(
 331       *process_sp, tid, PCs, pcs_are_call_addresses);
 332   std::string stop_reason_description = GetStopReasonDescription(info);
 333   new_thread_sp->SetName(stop_reason_description.c_str());
 334
 335   // Save this in the Process' ExtendedThreadList so a strong pointer retains
 336   // the object
 337   process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
 338   threads->AddThread(new_thread_sp);
 339
 340   return threads;
 341 }