1 | //===-- ScriptedThread.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 "ScriptedThread.h" |
10 | |
11 | #include "Plugins/Process/Utility/RegisterContextThreadMemory.h" |
12 | #include "Plugins/Process/Utility/StopInfoMachException.h" |
13 | #include "lldb/Target/OperatingSystem.h" |
14 | #include "lldb/Target/Process.h" |
15 | #include "lldb/Target/RegisterContext.h" |
16 | #include "lldb/Target/StopInfo.h" |
17 | #include "lldb/Target/Unwind.h" |
18 | #include "lldb/Utility/DataBufferHeap.h" |
19 | #include "lldb/Utility/LLDBLog.h" |
20 | #include <memory> |
21 | #include <optional> |
22 | |
23 | using namespace lldb; |
24 | using namespace lldb_private; |
25 | |
26 | void ScriptedThread::CheckInterpreterAndScriptObject() const { |
27 | lldbassert(m_script_object_sp && "Invalid Script Object." ); |
28 | lldbassert(GetInterface() && "Invalid Scripted Thread Interface." ); |
29 | } |
30 | |
31 | llvm::Expected<std::shared_ptr<ScriptedThread>> |
32 | ScriptedThread::Create(ScriptedProcess &process, |
33 | StructuredData::Generic *script_object) { |
34 | if (!process.IsValid()) |
35 | return llvm::createStringError(EC: llvm::inconvertibleErrorCode(), |
36 | S: "Invalid scripted process." ); |
37 | |
38 | process.CheckScriptedInterface(); |
39 | |
40 | auto scripted_thread_interface = |
41 | process.GetInterface().CreateScriptedThreadInterface(); |
42 | if (!scripted_thread_interface) |
43 | return llvm::createStringError( |
44 | EC: llvm::inconvertibleErrorCode(), |
45 | S: "Failed to create scripted thread interface." ); |
46 | |
47 | llvm::StringRef thread_class_name; |
48 | if (!script_object) { |
49 | std::optional<std::string> class_name = |
50 | process.GetInterface().GetScriptedThreadPluginName(); |
51 | if (!class_name || class_name->empty()) |
52 | return llvm::createStringError( |
53 | EC: llvm::inconvertibleErrorCode(), |
54 | S: "Failed to get scripted thread class name." ); |
55 | thread_class_name = *class_name; |
56 | } |
57 | |
58 | ExecutionContext exe_ctx(process); |
59 | auto obj_or_err = scripted_thread_interface->CreatePluginObject( |
60 | class_name: thread_class_name, exe_ctx, args_sp: process.m_scripted_metadata.GetArgsSP(), |
61 | script_obj: script_object); |
62 | |
63 | if (!obj_or_err) { |
64 | llvm::consumeError(Err: obj_or_err.takeError()); |
65 | return llvm::createStringError(EC: llvm::inconvertibleErrorCode(), |
66 | S: "Failed to create script object." ); |
67 | } |
68 | |
69 | StructuredData::GenericSP owned_script_object_sp = *obj_or_err; |
70 | |
71 | if (!owned_script_object_sp->IsValid()) |
72 | return llvm::createStringError(EC: llvm::inconvertibleErrorCode(), |
73 | S: "Created script object is invalid." ); |
74 | |
75 | lldb::tid_t tid = scripted_thread_interface->GetThreadID(); |
76 | |
77 | return std::make_shared<ScriptedThread>(args&: process, args&: scripted_thread_interface, |
78 | args&: tid, args&: owned_script_object_sp); |
79 | } |
80 | |
81 | ScriptedThread::ScriptedThread(ScriptedProcess &process, |
82 | ScriptedThreadInterfaceSP interface_sp, |
83 | lldb::tid_t tid, |
84 | StructuredData::GenericSP script_object_sp) |
85 | : Thread(process, tid), m_scripted_process(process), |
86 | m_scripted_thread_interface_sp(interface_sp), |
87 | m_script_object_sp(script_object_sp) {} |
88 | |
89 | ScriptedThread::~ScriptedThread() { DestroyThread(); } |
90 | |
91 | const char *ScriptedThread::GetName() { |
92 | CheckInterpreterAndScriptObject(); |
93 | std::optional<std::string> thread_name = GetInterface()->GetName(); |
94 | if (!thread_name) |
95 | return nullptr; |
96 | return ConstString(thread_name->c_str()).AsCString(); |
97 | } |
98 | |
99 | const char *ScriptedThread::GetQueueName() { |
100 | CheckInterpreterAndScriptObject(); |
101 | std::optional<std::string> queue_name = GetInterface()->GetQueue(); |
102 | if (!queue_name) |
103 | return nullptr; |
104 | return ConstString(queue_name->c_str()).AsCString(); |
105 | } |
106 | |
107 | void ScriptedThread::WillResume(StateType resume_state) {} |
108 | |
109 | void ScriptedThread::ClearStackFrames() { Thread::ClearStackFrames(); } |
110 | |
111 | RegisterContextSP ScriptedThread::GetRegisterContext() { |
112 | if (!m_reg_context_sp) |
113 | m_reg_context_sp = CreateRegisterContextForFrame(frame: nullptr); |
114 | return m_reg_context_sp; |
115 | } |
116 | |
117 | RegisterContextSP |
118 | ScriptedThread::CreateRegisterContextForFrame(StackFrame *frame) { |
119 | const uint32_t concrete_frame_idx = |
120 | frame ? frame->GetConcreteFrameIndex() : 0; |
121 | |
122 | if (concrete_frame_idx) |
123 | return GetUnwinder().CreateRegisterContextForFrame(frame); |
124 | |
125 | lldb::RegisterContextSP reg_ctx_sp; |
126 | Status error; |
127 | |
128 | std::optional<std::string> reg_data = GetInterface()->GetRegisterContext(); |
129 | if (!reg_data) |
130 | return ScriptedInterface::ErrorWithMessage<lldb::RegisterContextSP>( |
131 | LLVM_PRETTY_FUNCTION, error_msg: "Failed to get scripted thread registers data." , |
132 | error, log_category: LLDBLog::Thread); |
133 | |
134 | DataBufferSP data_sp( |
135 | std::make_shared<DataBufferHeap>(args: reg_data->c_str(), args: reg_data->size())); |
136 | |
137 | if (!data_sp->GetByteSize()) |
138 | return ScriptedInterface::ErrorWithMessage<lldb::RegisterContextSP>( |
139 | LLVM_PRETTY_FUNCTION, error_msg: "Failed to copy raw registers data." , error, |
140 | log_category: LLDBLog::Thread); |
141 | |
142 | std::shared_ptr<RegisterContextMemory> reg_ctx_memory = |
143 | std::make_shared<RegisterContextMemory>( |
144 | args&: *this, args: 0, args&: *GetDynamicRegisterInfo(), LLDB_INVALID_ADDRESS); |
145 | if (!reg_ctx_memory) |
146 | return ScriptedInterface::ErrorWithMessage<lldb::RegisterContextSP>( |
147 | LLVM_PRETTY_FUNCTION, error_msg: "Failed to create a register context." , error, |
148 | log_category: LLDBLog::Thread); |
149 | |
150 | reg_ctx_memory->SetAllRegisterData(data_sp); |
151 | m_reg_context_sp = reg_ctx_memory; |
152 | |
153 | return m_reg_context_sp; |
154 | } |
155 | |
156 | bool ScriptedThread::LoadArtificialStackFrames() { |
157 | StructuredData::ArraySP arr_sp = GetInterface()->GetStackFrames(); |
158 | |
159 | Status error; |
160 | if (!arr_sp) |
161 | return ScriptedInterface::ErrorWithMessage<bool>( |
162 | LLVM_PRETTY_FUNCTION, error_msg: "Failed to get scripted thread stackframes." , |
163 | error, log_category: LLDBLog::Thread); |
164 | |
165 | size_t arr_size = arr_sp->GetSize(); |
166 | if (arr_size > std::numeric_limits<uint32_t>::max()) |
167 | return ScriptedInterface::ErrorWithMessage<bool>( |
168 | LLVM_PRETTY_FUNCTION, |
169 | error_msg: llvm::Twine( |
170 | "StackFrame array size (" + llvm::Twine(arr_size) + |
171 | llvm::Twine( |
172 | ") is greater than maximum authorized for a StackFrameList." )) |
173 | .str(), |
174 | error, log_category: LLDBLog::Thread); |
175 | |
176 | StackFrameListSP frames = GetStackFrameList(); |
177 | |
178 | for (size_t idx = 0; idx < arr_size; idx++) { |
179 | std::optional<StructuredData::Dictionary *> maybe_dict = |
180 | arr_sp->GetItemAtIndexAsDictionary(idx); |
181 | if (!maybe_dict) |
182 | return ScriptedInterface::ErrorWithMessage<bool>( |
183 | LLVM_PRETTY_FUNCTION, |
184 | error_msg: llvm::Twine( |
185 | "Couldn't get artificial stackframe dictionary at index (" + |
186 | llvm::Twine(idx) + llvm::Twine(") from stackframe array." )) |
187 | .str(), |
188 | error, log_category: LLDBLog::Thread); |
189 | StructuredData::Dictionary *dict = *maybe_dict; |
190 | |
191 | lldb::addr_t pc; |
192 | if (!dict->GetValueForKeyAsInteger(key: "pc" , result&: pc)) |
193 | return ScriptedInterface::ErrorWithMessage<bool>( |
194 | LLVM_PRETTY_FUNCTION, |
195 | error_msg: "Couldn't find value for key 'pc' in stackframe dictionary." , error, |
196 | log_category: LLDBLog::Thread); |
197 | |
198 | Address symbol_addr; |
199 | symbol_addr.SetLoadAddress(load_addr: pc, target: &this->GetProcess()->GetTarget()); |
200 | |
201 | lldb::addr_t cfa = LLDB_INVALID_ADDRESS; |
202 | bool cfa_is_valid = false; |
203 | const bool behaves_like_zeroth_frame = false; |
204 | SymbolContext sc; |
205 | symbol_addr.CalculateSymbolContext(sc: &sc); |
206 | |
207 | StackFrameSP synth_frame_sp = std::make_shared<StackFrame>( |
208 | args: this->shared_from_this(), args&: idx, args&: idx, args&: cfa, args&: cfa_is_valid, args&: pc, |
209 | args: StackFrame::Kind::Artificial, args: behaves_like_zeroth_frame, args: &sc); |
210 | |
211 | if (!frames->SetFrameAtIndex(idx: static_cast<uint32_t>(idx), frame_sp&: synth_frame_sp)) |
212 | return ScriptedInterface::ErrorWithMessage<bool>( |
213 | LLVM_PRETTY_FUNCTION, |
214 | error_msg: llvm::Twine("Couldn't add frame (" + llvm::Twine(idx) + |
215 | llvm::Twine(") to ScriptedThread StackFrameList." )) |
216 | .str(), |
217 | error, log_category: LLDBLog::Thread); |
218 | } |
219 | |
220 | return true; |
221 | } |
222 | |
223 | bool ScriptedThread::CalculateStopInfo() { |
224 | StructuredData::DictionarySP dict_sp = GetInterface()->GetStopReason(); |
225 | |
226 | Status error; |
227 | if (!dict_sp) |
228 | return ScriptedInterface::ErrorWithMessage<bool>( |
229 | LLVM_PRETTY_FUNCTION, error_msg: "Failed to get scripted thread stop info." , error, |
230 | log_category: LLDBLog::Thread); |
231 | |
232 | // If we're at a BreakpointSite, mark that we stopped there and |
233 | // need to hit the breakpoint when we resume. This will be cleared |
234 | // if we CreateStopReasonWithBreakpointSiteID. |
235 | if (RegisterContextSP reg_ctx_sp = GetRegisterContext()) { |
236 | addr_t pc = reg_ctx_sp->GetPC(); |
237 | if (BreakpointSiteSP bp_site_sp = |
238 | GetProcess()->GetBreakpointSiteList().FindByAddress(addr: pc)) |
239 | if (bp_site_sp->IsEnabled()) |
240 | SetThreadStoppedAtUnexecutedBP(pc); |
241 | } |
242 | |
243 | lldb::StopInfoSP stop_info_sp; |
244 | lldb::StopReason stop_reason_type; |
245 | |
246 | if (!dict_sp->GetValueForKeyAsInteger(key: "type" , result&: stop_reason_type)) |
247 | return ScriptedInterface::ErrorWithMessage<bool>( |
248 | LLVM_PRETTY_FUNCTION, |
249 | error_msg: "Couldn't find value for key 'type' in stop reason dictionary." , error, |
250 | log_category: LLDBLog::Thread); |
251 | |
252 | StructuredData::Dictionary *data_dict; |
253 | if (!dict_sp->GetValueForKeyAsDictionary(key: "data" , result&: data_dict)) |
254 | return ScriptedInterface::ErrorWithMessage<bool>( |
255 | LLVM_PRETTY_FUNCTION, |
256 | error_msg: "Couldn't find value for key 'data' in stop reason dictionary." , error, |
257 | log_category: LLDBLog::Thread); |
258 | |
259 | switch (stop_reason_type) { |
260 | case lldb::eStopReasonNone: |
261 | return true; |
262 | case lldb::eStopReasonBreakpoint: { |
263 | lldb::break_id_t break_id; |
264 | data_dict->GetValueForKeyAsInteger(key: "break_id" , result&: break_id, |
265 | LLDB_INVALID_BREAK_ID); |
266 | stop_info_sp = |
267 | StopInfo::CreateStopReasonWithBreakpointSiteID(thread&: *this, break_id); |
268 | } break; |
269 | case lldb::eStopReasonSignal: { |
270 | uint32_t signal; |
271 | llvm::StringRef description; |
272 | if (!data_dict->GetValueForKeyAsInteger(key: "signal" , result&: signal)) { |
273 | signal = LLDB_INVALID_SIGNAL_NUMBER; |
274 | return false; |
275 | } |
276 | data_dict->GetValueForKeyAsString(key: "desc" , result&: description); |
277 | stop_info_sp = |
278 | StopInfo::CreateStopReasonWithSignal(thread&: *this, signo: signal, description: description.data()); |
279 | } break; |
280 | case lldb::eStopReasonTrace: { |
281 | stop_info_sp = StopInfo::CreateStopReasonToTrace(thread&: *this); |
282 | } break; |
283 | case lldb::eStopReasonException: { |
284 | #if defined(__APPLE__) |
285 | StructuredData::Dictionary *mach_exception; |
286 | if (data_dict->GetValueForKeyAsDictionary("mach_exception" , |
287 | mach_exception)) { |
288 | llvm::StringRef value; |
289 | mach_exception->GetValueForKeyAsString("type" , value); |
290 | auto exc_type = |
291 | StopInfoMachException::MachException::ExceptionCode(value.data()); |
292 | |
293 | if (!exc_type) |
294 | return false; |
295 | |
296 | uint32_t exc_data_size = 0; |
297 | llvm::SmallVector<uint64_t, 3> raw_codes; |
298 | |
299 | StructuredData::Array *exc_rawcodes; |
300 | mach_exception->GetValueForKeyAsArray("rawCodes" , exc_rawcodes); |
301 | if (exc_rawcodes) { |
302 | auto fetch_data = [&raw_codes](StructuredData::Object *obj) { |
303 | if (!obj) |
304 | return false; |
305 | raw_codes.push_back(obj->GetUnsignedIntegerValue()); |
306 | return true; |
307 | }; |
308 | |
309 | exc_rawcodes->ForEach(fetch_data); |
310 | exc_data_size = raw_codes.size(); |
311 | } |
312 | |
313 | stop_info_sp = StopInfoMachException::CreateStopReasonWithMachException( |
314 | *this, *exc_type, exc_data_size, |
315 | exc_data_size >= 1 ? raw_codes[0] : 0, |
316 | exc_data_size >= 2 ? raw_codes[1] : 0, |
317 | exc_data_size >= 3 ? raw_codes[2] : 0); |
318 | |
319 | break; |
320 | } |
321 | #endif |
322 | stop_info_sp = |
323 | StopInfo::CreateStopReasonWithException(thread&: *this, description: "EXC_BAD_ACCESS" ); |
324 | } break; |
325 | default: |
326 | return ScriptedInterface::ErrorWithMessage<bool>( |
327 | LLVM_PRETTY_FUNCTION, |
328 | error_msg: llvm::Twine("Unsupported stop reason type (" + |
329 | llvm::Twine(stop_reason_type) + llvm::Twine(")." )) |
330 | .str(), |
331 | error, log_category: LLDBLog::Thread); |
332 | } |
333 | |
334 | if (!stop_info_sp) |
335 | return false; |
336 | |
337 | SetStopInfo(stop_info_sp); |
338 | return true; |
339 | } |
340 | |
341 | void ScriptedThread::RefreshStateAfterStop() { |
342 | GetRegisterContext()->InvalidateIfNeeded(/*force=*/false); |
343 | LoadArtificialStackFrames(); |
344 | } |
345 | |
346 | lldb::ScriptedThreadInterfaceSP ScriptedThread::GetInterface() const { |
347 | return m_scripted_thread_interface_sp; |
348 | } |
349 | |
350 | std::shared_ptr<DynamicRegisterInfo> ScriptedThread::GetDynamicRegisterInfo() { |
351 | CheckInterpreterAndScriptObject(); |
352 | |
353 | if (!m_register_info_sp) { |
354 | StructuredData::DictionarySP reg_info = GetInterface()->GetRegisterInfo(); |
355 | |
356 | Status error; |
357 | if (!reg_info) |
358 | return ScriptedInterface::ErrorWithMessage< |
359 | std::shared_ptr<DynamicRegisterInfo>>( |
360 | LLVM_PRETTY_FUNCTION, error_msg: "Failed to get scripted thread registers info." , |
361 | error, log_category: LLDBLog::Thread); |
362 | |
363 | m_register_info_sp = DynamicRegisterInfo::Create( |
364 | dict: *reg_info, arch: m_scripted_process.GetTarget().GetArchitecture()); |
365 | } |
366 | |
367 | return m_register_info_sp; |
368 | } |
369 | |
370 | StructuredData::ObjectSP ScriptedThread::FetchThreadExtendedInfo() { |
371 | CheckInterpreterAndScriptObject(); |
372 | |
373 | Status error; |
374 | StructuredData::ArraySP extended_info_sp = GetInterface()->GetExtendedInfo(); |
375 | |
376 | if (!extended_info_sp || !extended_info_sp->GetSize()) |
377 | return ScriptedInterface::ErrorWithMessage<StructuredData::ObjectSP>( |
378 | LLVM_PRETTY_FUNCTION, error_msg: "No extended information found" , error); |
379 | |
380 | return extended_info_sp; |
381 | } |
382 | |