contrib/llvm/tools/lldb/source/Plugins/InstrumentationRuntime/MainThreadChecker/MainThreadCheckerRuntime.cpp

   1 //===-- MainThreadCheckerRuntime.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 "MainThreadCheckerRuntime.h"
  11
  12 #include "lldb/Breakpoint/StoppointCallbackContext.h"
  13 #include "lldb/Core/Module.h"
  14 #include "lldb/Core/PluginManager.h"
  15 #include "lldb/Symbol/Symbol.h"
  16 #include "lldb/Symbol/SymbolContext.h"
  17 #include "lldb/Symbol/Variable.h"
  18 #include "lldb/Symbol/VariableList.h"
  19 #include "lldb/Target/InstrumentationRuntimeStopInfo.h"
  20 #include "lldb/Target/RegisterContext.h"
  21 #include "lldb/Target/SectionLoadList.h"
  22 #include "lldb/Target/StopInfo.h"
  23 #include "lldb/Target/Target.h"
  24 #include "lldb/Target/Thread.h"
  25 #include "lldb/Utility/RegularExpression.h"
  26 #include "Plugins/Process/Utility/HistoryThread.h"
  27
  28 using namespace lldb;
  29 using namespace lldb_private;
  30
  31 MainThreadCheckerRuntime::~MainThreadCheckerRuntime() {
  32   Deactivate();
  33 }
  34
  35 lldb::InstrumentationRuntimeSP
  36 MainThreadCheckerRuntime::CreateInstance(const lldb::ProcessSP &process_sp) {
  37   return InstrumentationRuntimeSP(new MainThreadCheckerRuntime(process_sp));
  38 }
  39
  40 void MainThreadCheckerRuntime::Initialize() {
  41   PluginManager::RegisterPlugin(
  42       GetPluginNameStatic(), "MainThreadChecker instrumentation runtime plugin.",
  43       CreateInstance, GetTypeStatic);
  44 }
  45
  46 void MainThreadCheckerRuntime::Terminate() {
  47   PluginManager::UnregisterPlugin(CreateInstance);
  48 }
  49
  50 lldb_private::ConstString MainThreadCheckerRuntime::GetPluginNameStatic() {
  51   return ConstString("MainThreadChecker");
  52 }
  53
  54 lldb::InstrumentationRuntimeType MainThreadCheckerRuntime::GetTypeStatic() {
  55   return eInstrumentationRuntimeTypeMainThreadChecker;
  56 }
  57
  58 const RegularExpression &
  59 MainThreadCheckerRuntime::GetPatternForRuntimeLibrary() {
  60   static RegularExpression regex(llvm::StringRef("libMainThreadChecker.dylib"));
  61   return regex;
  62 }
  63
  64 bool MainThreadCheckerRuntime::CheckIfRuntimeIsValid(
  65     const lldb::ModuleSP module_sp) {
  66   static ConstString test_sym("__main_thread_checker_on_report");
  67   const Symbol *symbol =
  68       module_sp->FindFirstSymbolWithNameAndType(test_sym, lldb::eSymbolTypeAny);
  69   return symbol != nullptr;
  70 }
  71
  72 StructuredData::ObjectSP
  73 MainThreadCheckerRuntime::RetrieveReportData(ExecutionContextRef exe_ctx_ref) {
  74   ProcessSP process_sp = GetProcessSP();
  75   if (!process_sp)
  76     return StructuredData::ObjectSP();
  77
  78   ThreadSP thread_sp = exe_ctx_ref.GetThreadSP();
  79   StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
  80   ModuleSP runtime_module_sp = GetRuntimeModuleSP();
  81   Target &target = process_sp->GetTarget();
  82
  83   if (!frame_sp)
  84     return StructuredData::ObjectSP();
  85
  86   RegisterContextSP regctx_sp = frame_sp->GetRegisterContext();
  87   if (!regctx_sp)
  88     return StructuredData::ObjectSP();
  89
  90   const RegisterInfo *reginfo = regctx_sp->GetRegisterInfoByName("arg1");
  91   if (!reginfo)
  92     return StructuredData::ObjectSP();
  93
  94   uint64_t apiname_ptr = regctx_sp->ReadRegisterAsUnsigned(reginfo, 0);
  95   if (!apiname_ptr)
  96     return StructuredData::ObjectSP();
  97
  98   std::string apiName = "";
  99   Status read_error;
 100   target.ReadCStringFromMemory(apiname_ptr, apiName, read_error);
 101   if (read_error.Fail())
 102     return StructuredData::ObjectSP();
 103
 104   std::string className = "";
 105   std::string selector = "";
 106   if (apiName.substr(0, 2) == "-[") {
 107     size_t spacePos = apiName.find(" ");
 108     if (spacePos != std::string::npos) {
 109       className = apiName.substr(2, spacePos - 2);
 110       selector = apiName.substr(spacePos + 1, apiName.length() - spacePos - 2);
 111     }
 112   }
 113
 114   // Gather the PCs of the user frames in the backtrace.
 115   StructuredData::Array *trace = new StructuredData::Array();
 116   auto trace_sp = StructuredData::ObjectSP(trace);
 117   StackFrameSP responsible_frame;
 118   for (unsigned I = 0; I < thread_sp->GetStackFrameCount(); ++I) {
 119     StackFrameSP frame = thread_sp->GetStackFrameAtIndex(I);
 120     Address addr = frame->GetFrameCodeAddress();
 121     if (addr.GetModule() == runtime_module_sp) // Skip PCs from the runtime.
 122       continue;
 123
 124     // The first non-runtime frame is responsible for the bug.
 125     if (!responsible_frame)
 126       responsible_frame = frame;
 127
 128     // First frame in stacktrace should point to a real PC, not return address.
 129     if (I != 0 && trace->GetSize() == 0) {
 130       addr.Slide(-1);
 131     }
 132
 133     lldb::addr_t PC = addr.GetLoadAddress(&target);
 134     trace->AddItem(StructuredData::ObjectSP(new StructuredData::Integer(PC)));
 135   }
 136
 137   auto *d = new StructuredData::Dictionary();
 138   auto dict_sp = StructuredData::ObjectSP(d);
 139   d->AddStringItem("instrumentation_class", "MainThreadChecker");
 140   d->AddStringItem("api_name", apiName);
 141   d->AddStringItem("class_name", className);
 142   d->AddStringItem("selector", selector);
 143   d->AddStringItem("description",
 144                    apiName + " must be called from main thread only");
 145   d->AddIntegerItem("tid", thread_sp->GetIndexID());
 146   d->AddItem("trace", trace_sp);
 147   return dict_sp;
 148 }
 149
 150 bool MainThreadCheckerRuntime::NotifyBreakpointHit(
 151     void *baton, StoppointCallbackContext *context, user_id_t break_id,
 152     user_id_t break_loc_id) {
 153   assert(baton && "null baton");
 154   if (!baton)
 155     return false; //< false => resume execution.
 156
 157   MainThreadCheckerRuntime *const instance =
 158       static_cast<MainThreadCheckerRuntime *>(baton);
 159
 160   ProcessSP process_sp = instance->GetProcessSP();
 161   ThreadSP thread_sp = context->exe_ctx_ref.GetThreadSP();
 162   if (!process_sp || !thread_sp ||
 163       process_sp != context->exe_ctx_ref.GetProcessSP())
 164     return false;
 165
 166   StructuredData::ObjectSP report =
 167       instance->RetrieveReportData(context->exe_ctx_ref);
 168
 169   if (report) {
 170     std::string description = report->GetAsDictionary()
 171                                 ->GetValueForKey("description")
 172                                 ->GetAsString()
 173                                 ->GetValue();
 174     thread_sp->SetStopInfo(
 175         InstrumentationRuntimeStopInfo::CreateStopReasonWithInstrumentationData(
 176             *thread_sp, description, report));
 177     return true;
 178   }
 179
 180   return false;
 181 }
 182
 183 void MainThreadCheckerRuntime::Activate() {
 184   if (IsActive())
 185     return;
 186
 187   ProcessSP process_sp = GetProcessSP();
 188   if (!process_sp)
 189     return;
 190
 191   ModuleSP runtime_module_sp = GetRuntimeModuleSP();
 192
 193   ConstString symbol_name("__main_thread_checker_on_report");
 194   const Symbol *symbol = runtime_module_sp->FindFirstSymbolWithNameAndType(
 195       symbol_name, eSymbolTypeCode);
 196
 197   if (symbol == nullptr)
 198     return;
 199
 200   if (!symbol->ValueIsAddress() || !symbol->GetAddressRef().IsValid())
 201     return;
 202
 203   Target &target = process_sp->GetTarget();
 204   addr_t symbol_address = symbol->GetAddressRef().GetOpcodeLoadAddress(&target);
 205
 206   if (symbol_address == LLDB_INVALID_ADDRESS)
 207     return;
 208
 209   Breakpoint *breakpoint =
 210       process_sp->GetTarget()
 211           .CreateBreakpoint(symbol_address, /*internal=*/true,
 212                             /*hardware=*/false)
 213           .get();
 214   breakpoint->SetCallback(MainThreadCheckerRuntime::NotifyBreakpointHit, this,
 215                           true);
 216   breakpoint->SetBreakpointKind("main-thread-checker-report");
 217   SetBreakpointID(breakpoint->GetID());
 218
 219   SetActive(true);
 220 }
 221
 222 void MainThreadCheckerRuntime::Deactivate() {
 223   SetActive(false);
 224
 225   auto BID = GetBreakpointID();
 226   if (BID == LLDB_INVALID_BREAK_ID)
 227     return;
 228
 229   if (ProcessSP process_sp = GetProcessSP()) {
 230     process_sp->GetTarget().RemoveBreakpointByID(BID);
 231     SetBreakpointID(LLDB_INVALID_BREAK_ID);
 232   }
 233 }
 234
 235 lldb::ThreadCollectionSP
 236 MainThreadCheckerRuntime::GetBacktracesFromExtendedStopInfo(
 237     StructuredData::ObjectSP info) {
 238   ThreadCollectionSP threads;
 239   threads.reset(new ThreadCollection());
 240
 241   ProcessSP process_sp = GetProcessSP();
 242
 243   if (info->GetObjectForDotSeparatedPath("instrumentation_class")
 244       ->GetStringValue() != "MainThreadChecker")
 245     return threads;
 246
 247   std::vector<lldb::addr_t> PCs;
 248   auto trace = info->GetObjectForDotSeparatedPath("trace")->GetAsArray();
 249   trace->ForEach([&PCs](StructuredData::Object *PC) -> bool {
 250     PCs.push_back(PC->GetAsInteger()->GetValue());
 251     return true;
 252   });
 253
 254   if (PCs.empty())
 255     return threads;
 256
 257   StructuredData::ObjectSP thread_id_obj =
 258       info->GetObjectForDotSeparatedPath("tid");
 259   tid_t tid = thread_id_obj ? thread_id_obj->GetIntegerValue() : 0;
 260
 261   uint32_t stop_id = 0;
 262   bool stop_id_is_valid = false;
 263   HistoryThread *history_thread =
 264       new HistoryThread(*process_sp, tid, PCs, stop_id, stop_id_is_valid);
 265   ThreadSP new_thread_sp(history_thread);
 266
 267   // Save this in the Process' ExtendedThreadList so a strong pointer
 268   // retains the object
 269   process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
 270   threads->AddThread(new_thread_sp);
 271
 272   return threads;
 273 }