LLDB mainline
InstrumentationRuntimeMainThreadChecker.cpp
Go to the documentation of this file.
1//===-- InstrumentationRuntimeMainThreadChecker.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
10
13#include "lldb/Core/Module.h"
15#include "lldb/Symbol/Symbol.h"
23#include "lldb/Target/Target.h"
24#include "lldb/Target/Thread.h"
26
27#include <memory>
28
29using namespace lldb;
30using namespace lldb_private;
31
33
36 Deactivate();
37}
38
39lldb::InstrumentationRuntimeSP
41 const lldb::ProcessSP &process_sp) {
42 return InstrumentationRuntimeSP(
44}
45
49 "MainThreadChecker instrumentation runtime plugin.", CreateInstance,
51}
52
55}
56
60}
61
64 static RegularExpression regex(llvm::StringRef("libMainThreadChecker.dylib"));
65 return regex;
66}
67
69 const lldb::ModuleSP module_sp) {
70 static ConstString test_sym("__main_thread_checker_on_report");
71 const Symbol *symbol =
72 module_sp->FindFirstSymbolWithNameAndType(test_sym, lldb::eSymbolTypeAny);
73 return symbol != nullptr;
74}
75
78 ExecutionContextRef exe_ctx_ref) {
79 ProcessSP process_sp = GetProcessSP();
80 if (!process_sp)
82
83 ThreadSP thread_sp = exe_ctx_ref.GetThreadSP();
84 StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
85 ModuleSP runtime_module_sp = GetRuntimeModuleSP();
86 Target &target = process_sp->GetTarget();
87
88 if (!frame_sp)
90
91 RegisterContextSP regctx_sp = frame_sp->GetRegisterContext();
92 if (!regctx_sp)
94
95 const RegisterInfo *reginfo = regctx_sp->GetRegisterInfoByName("arg1");
96 if (!reginfo)
98
99 uint64_t apiname_ptr = regctx_sp->ReadRegisterAsUnsigned(reginfo, 0);
100 if (!apiname_ptr)
102
103 std::string apiName;
104 Status read_error;
105 target.ReadCStringFromMemory(apiname_ptr, apiName, read_error);
106 if (read_error.Fail())
108
109 std::string className;
110 std::string selector;
111 if (apiName.substr(0, 2) == "-[") {
112 size_t spacePos = apiName.find(' ');
113 if (spacePos != std::string::npos) {
114 className = apiName.substr(2, spacePos - 2);
115 selector = apiName.substr(spacePos + 1, apiName.length() - spacePos - 2);
116 }
117 }
118
119 // Gather the PCs of the user frames in the backtrace.
121 auto trace_sp = StructuredData::ObjectSP(trace);
122 StackFrameSP responsible_frame;
123 for (unsigned I = 0; I < thread_sp->GetStackFrameCount(); ++I) {
124 StackFrameSP frame = thread_sp->GetStackFrameAtIndex(I);
125 Address addr = frame->GetFrameCodeAddressForSymbolication();
126 if (addr.GetModule() == runtime_module_sp) // Skip PCs from the runtime.
127 continue;
128
129 // The first non-runtime frame is responsible for the bug.
130 if (!responsible_frame)
131 responsible_frame = frame;
132
133 lldb::addr_t PC = addr.GetLoadAddress(&target);
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 used from main thread only");
145 d->AddIntegerItem("tid", thread_sp->GetIndexID());
146 d->AddItem("trace", trace_sp);
147 return dict_sp;
148}
149
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
158 static_cast<InstrumentationRuntimeMainThreadChecker *>(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 if (process_sp->GetModIDRef().IsLastResumeForUserExpression())
167 return false;
168
170 instance->RetrieveReportData(context->exe_ctx_ref);
171
172 if (report) {
173 std::string description = std::string(report->GetAsDictionary()
174 ->GetValueForKey("description")
175 ->GetAsString()
176 ->GetValue());
177 thread_sp->SetStopInfo(
179 *thread_sp, description, report));
180 return true;
181 }
182
183 return false;
184}
185
187 if (IsActive())
188 return;
189
190 ProcessSP process_sp = GetProcessSP();
191 if (!process_sp)
192 return;
193
194 ModuleSP runtime_module_sp = GetRuntimeModuleSP();
195
196 ConstString symbol_name("__main_thread_checker_on_report");
197 const Symbol *symbol = runtime_module_sp->FindFirstSymbolWithNameAndType(
198 symbol_name, eSymbolTypeCode);
199
200 if (symbol == nullptr)
201 return;
202
203 if (!symbol->ValueIsAddress() || !symbol->GetAddressRef().IsValid())
204 return;
205
206 Target &target = process_sp->GetTarget();
207 addr_t symbol_address = symbol->GetAddressRef().GetOpcodeLoadAddress(&target);
208
209 if (symbol_address == LLDB_INVALID_ADDRESS)
210 return;
211
212 Breakpoint *breakpoint =
213 process_sp->GetTarget()
214 .CreateBreakpoint(symbol_address, /*internal=*/true,
215 /*hardware=*/false)
216 .get();
217 const bool sync = false;
218 breakpoint->SetCallback(
220 breakpoint->SetBreakpointKind("main-thread-checker-report");
221 SetBreakpointID(breakpoint->GetID());
222
223 SetActive(true);
224}
225
227 SetActive(false);
228
229 auto BID = GetBreakpointID();
230 if (BID == LLDB_INVALID_BREAK_ID)
231 return;
232
233 if (ProcessSP process_sp = GetProcessSP()) {
234 process_sp->GetTarget().RemoveBreakpointByID(BID);
236 }
237}
238
239lldb::ThreadCollectionSP
242 ThreadCollectionSP threads;
243 threads = std::make_shared<ThreadCollection>();
244
245 ProcessSP process_sp = GetProcessSP();
246
247 if (info->GetObjectForDotSeparatedPath("instrumentation_class")
248 ->GetStringValue() != "MainThreadChecker")
249 return threads;
250
251 std::vector<lldb::addr_t> PCs;
252 auto trace = info->GetObjectForDotSeparatedPath("trace")->GetAsArray();
253 trace->ForEach([&PCs](StructuredData::Object *PC) -> bool {
254 PCs.push_back(PC->GetAsInteger()->GetValue());
255 return true;
256 });
257
258 if (PCs.empty())
259 return threads;
260
261 StructuredData::ObjectSP thread_id_obj =
262 info->GetObjectForDotSeparatedPath("tid");
263 tid_t tid = thread_id_obj ? thread_id_obj->GetIntegerValue() : 0;
264
265 // We gather symbolication addresses above, so no need for HistoryThread to
266 // try to infer the call addresses.
267 bool pcs_are_call_addresses = true;
268 ThreadSP new_thread_sp = std::make_shared<HistoryThread>(
269 *process_sp, tid, PCs, pcs_are_call_addresses);
270
271 // Save this in the Process' ExtendedThreadList so a strong pointer retains
272 // the object
273 process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
274 threads->AddThread(new_thread_sp);
275
276 return threads;
277}
#define LLDB_PLUGIN_DEFINE(PluginName)
Definition: PluginManager.h:31
A section + offset based address class.
Definition: Address.h:59
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:311
lldb::addr_t GetOpcodeLoadAddress(Target *target, AddressClass addr_class=AddressClass::eInvalid) const
Get the load address as an opcode load address.
Definition: Address.cpp:368
lldb::ModuleSP GetModule() const
Get accessor for the module for this address.
Definition: Address.cpp:283
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:345
General Outline: A breakpoint has four main parts, a filter, a resolver, the list of breakpoint locat...
Definition: Breakpoint.h:81
void SetBreakpointKind(const char *kind)
Set the "kind" description for a breakpoint.
Definition: Breakpoint.h:453
Target & GetTarget()
Accessor for the breakpoint Target.
Definition: Breakpoint.h:464
void SetCallback(BreakpointHitCallback callback, void *baton, bool is_synchronous=false)
Set the callback action invoked when the breakpoint is hit.
Definition: Breakpoint.cpp:418
A uniqued constant string class.
Definition: ConstString.h:39
Execution context objects refer to objects in the execution of the program that is being debugged.
lldb::ThreadSP GetThreadSP() const
Get accessor that creates a strong reference from the weak thread reference contained in this object.
lldb::ProcessSP GetProcessSP() const
Get accessor that creates a strong reference from the weak process reference contained in this object...
lldb::ThreadCollectionSP GetBacktracesFromExtendedStopInfo(StructuredData::ObjectSP info) override
void Activate() override
Register a breakpoint in the runtime library and perform any other necessary initialization.
static lldb::InstrumentationRuntimeSP CreateInstance(const lldb::ProcessSP &process_sp)
StructuredData::ObjectSP RetrieveReportData(ExecutionContextRef exe_ctx_ref)
static bool NotifyBreakpointHit(void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id, lldb::user_id_t break_loc_id)
const RegularExpression & GetPatternForRuntimeLibrary() override
Return a regular expression which can be used to identify a valid version of the runtime library.
bool CheckIfRuntimeIsValid(const lldb::ModuleSP module_sp) override
Check whether module_sp corresponds to a valid runtime library.
static lldb::StopInfoSP CreateStopReasonWithInstrumentationData(Thread &thread, std::string description, StructuredData::ObjectSP additional_data)
static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, ABICreateInstance create_callback)
static bool UnregisterPlugin(ABICreateInstance create_callback)
An error handling class.
Definition: Status.h:44
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
General Outline: When we hit a breakpoint we need to package up whatever information is needed to eva...
lldb::break_id_t GetID() const
Definition: Stoppoint.cpp:22
void AddItem(const ObjectSP &item)
std::shared_ptr< Object > ObjectSP
bool ValueIsAddress() const
Definition: Symbol.cpp:167
Address & GetAddressRef()
Definition: Symbol.h:71
size_t ReadCStringFromMemory(const Address &addr, std::string &out_str, Status &error, bool force_live_memory=false)
Definition: Target.cpp:1901
lldb::BreakpointSP CreateBreakpoint(const FileSpecList *containingModules, const FileSpec &file, uint32_t line_no, uint32_t column, lldb::addr_t offset, LazyBool check_inlines, LazyBool skip_prologue, bool internal, bool request_hardware, LazyBool move_to_nearest_code)
Definition: Target.cpp:352
#define LLDB_INVALID_BREAK_ID
Definition: lldb-defines.h:37
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:74
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Definition: SBAddress.h:15
InstrumentationRuntimeType
@ eInstrumentationRuntimeTypeMainThreadChecker
uint64_t user_id_t
Definition: lldb-types.h:80
uint64_t addr_t
Definition: lldb-types.h:79
uint64_t tid_t
Definition: lldb-types.h:82