/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | //===-- JITLoaderGDB.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 "JITLoaderGDB.h" |
10 | | #include "Plugins/ObjectFile/Mach-O/ObjectFileMachO.h" |
11 | | #include "lldb/Breakpoint/Breakpoint.h" |
12 | | #include "lldb/Core/Module.h" |
13 | | #include "lldb/Core/ModuleSpec.h" |
14 | | #include "lldb/Core/PluginManager.h" |
15 | | #include "lldb/Core/Section.h" |
16 | | #include "lldb/Interpreter/OptionValueProperties.h" |
17 | | #include "lldb/Symbol/ObjectFile.h" |
18 | | #include "lldb/Symbol/Symbol.h" |
19 | | #include "lldb/Symbol/SymbolContext.h" |
20 | | #include "lldb/Symbol/SymbolVendor.h" |
21 | | #include "lldb/Target/Process.h" |
22 | | #include "lldb/Target/SectionLoadList.h" |
23 | | #include "lldb/Target/Target.h" |
24 | | #include "lldb/Utility/DataBufferHeap.h" |
25 | | #include "lldb/Utility/LLDBAssert.h" |
26 | | #include "lldb/Utility/LLDBLog.h" |
27 | | #include "lldb/Utility/Log.h" |
28 | | #include "lldb/Utility/StreamString.h" |
29 | | #include "llvm/Support/MathExtras.h" |
30 | | |
31 | | #include <memory> |
32 | | |
33 | | using namespace lldb; |
34 | | using namespace lldb_private; |
35 | | |
36 | | LLDB_PLUGIN_DEFINE(JITLoaderGDB) |
37 | | |
38 | | // Debug Interface Structures |
39 | | enum jit_actions_t { JIT_NOACTION = 0, JIT_REGISTER_FN, JIT_UNREGISTER_FN }; |
40 | | |
41 | | template <typename ptr_t> struct jit_code_entry { |
42 | | ptr_t next_entry; // pointer |
43 | | ptr_t prev_entry; // pointer |
44 | | ptr_t symfile_addr; // pointer |
45 | | uint64_t symfile_size; |
46 | | }; |
47 | | |
48 | | template <typename ptr_t> struct jit_descriptor { |
49 | | uint32_t version; |
50 | | uint32_t action_flag; // Values are jit_action_t |
51 | | ptr_t relevant_entry; // pointer |
52 | | ptr_t first_entry; // pointer |
53 | | }; |
54 | | |
55 | | namespace { |
56 | | enum EnableJITLoaderGDB { |
57 | | eEnableJITLoaderGDBDefault, |
58 | | eEnableJITLoaderGDBOn, |
59 | | eEnableJITLoaderGDBOff, |
60 | | }; |
61 | | |
62 | | static constexpr OptionEnumValueElement g_enable_jit_loader_gdb_enumerators[] = |
63 | | { |
64 | | { |
65 | | eEnableJITLoaderGDBDefault, |
66 | | "default", |
67 | | "Enable JIT compilation interface for all platforms except macOS", |
68 | | }, |
69 | | { |
70 | | eEnableJITLoaderGDBOn, |
71 | | "on", |
72 | | "Enable JIT compilation interface", |
73 | | }, |
74 | | { |
75 | | eEnableJITLoaderGDBOff, |
76 | | "off", |
77 | | "Disable JIT compilation interface", |
78 | | }, |
79 | | }; |
80 | | |
81 | | #define LLDB_PROPERTIES_jitloadergdb |
82 | | #include "JITLoaderGDBProperties.inc" |
83 | | |
84 | | enum { |
85 | | #define LLDB_PROPERTIES_jitloadergdb |
86 | | #include "JITLoaderGDBPropertiesEnum.inc" |
87 | | ePropertyEnableJITBreakpoint |
88 | | }; |
89 | | |
90 | | class PluginProperties : public Properties { |
91 | | public: |
92 | 9.99k | static llvm::StringRef GetSettingName() { |
93 | 9.99k | return JITLoaderGDB::GetPluginNameStatic(); |
94 | 9.99k | } |
95 | | |
96 | 3.90k | PluginProperties() { |
97 | 3.90k | m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName()); |
98 | 3.90k | m_collection_sp->Initialize(g_jitloadergdb_properties); |
99 | 3.90k | } |
100 | | |
101 | 2.34k | EnableJITLoaderGDB GetEnable() const { |
102 | 2.34k | return GetPropertyAtIndexAs<EnableJITLoaderGDB>( |
103 | 2.34k | ePropertyEnable, |
104 | 2.34k | static_cast<EnableJITLoaderGDB>( |
105 | 2.34k | g_jitloadergdb_properties[ePropertyEnable].default_uint_value)); |
106 | 2.34k | } |
107 | | }; |
108 | | } // namespace |
109 | | |
110 | 8.43k | static PluginProperties &GetGlobalPluginProperties() { |
111 | 8.43k | static PluginProperties g_settings; |
112 | 8.43k | return g_settings; |
113 | 8.43k | } |
114 | | |
115 | | template <typename ptr_t> |
116 | | static bool ReadJITEntry(const addr_t from_addr, Process *process, |
117 | 3 | jit_code_entry<ptr_t> *entry) { |
118 | 3 | lldbassert(from_addr % sizeof(ptr_t) == 0); |
119 | | |
120 | 3 | ArchSpec::Core core = process->GetTarget().GetArchitecture().GetCore(); |
121 | 3 | bool i386_target = ArchSpec::kCore_x86_32_first <= core && |
122 | 3 | core <= ArchSpec::kCore_x86_32_last; |
123 | 3 | uint8_t uint64_align_bytes = i386_target ? 40 : 8; |
124 | 3 | const size_t data_byte_size = |
125 | 3 | llvm::alignTo(sizeof(ptr_t) * 3, uint64_align_bytes) + sizeof(uint64_t); |
126 | | |
127 | 3 | Status error; |
128 | 3 | DataBufferHeap data(data_byte_size, 0); |
129 | 3 | size_t bytes_read = process->ReadMemory(from_addr, data.GetBytes(), |
130 | 3 | data.GetByteSize(), error); |
131 | 3 | if (bytes_read != data_byte_size || !error.Success()) |
132 | 0 | return false; |
133 | | |
134 | 3 | DataExtractor extractor(data.GetBytes(), data.GetByteSize(), |
135 | 3 | process->GetByteOrder(), sizeof(ptr_t)); |
136 | 3 | lldb::offset_t offset = 0; |
137 | 3 | entry->next_entry = extractor.GetAddress(&offset); |
138 | 3 | entry->prev_entry = extractor.GetAddress(&offset); |
139 | 3 | entry->symfile_addr = extractor.GetAddress(&offset); |
140 | 3 | offset = llvm::alignTo(offset, uint64_align_bytes); |
141 | 3 | entry->symfile_size = extractor.GetU64(&offset); |
142 | | |
143 | 3 | return true; |
144 | 3 | } JITLoaderGDB.cpp:bool ReadJITEntry<unsigned long long>(unsigned long long, lldb_private::Process*, jit_code_entry<unsigned long long>*) Line | Count | Source | 117 | 3 | jit_code_entry<ptr_t> *entry) { | 118 | 3 | lldbassert(from_addr % sizeof(ptr_t) == 0); | 119 | | | 120 | 3 | ArchSpec::Core core = process->GetTarget().GetArchitecture().GetCore(); | 121 | 3 | bool i386_target = ArchSpec::kCore_x86_32_first <= core && | 122 | 3 | core <= ArchSpec::kCore_x86_32_last; | 123 | 3 | uint8_t uint64_align_bytes = i386_target ? 40 : 8; | 124 | 3 | const size_t data_byte_size = | 125 | 3 | llvm::alignTo(sizeof(ptr_t) * 3, uint64_align_bytes) + sizeof(uint64_t); | 126 | | | 127 | 3 | Status error; | 128 | 3 | DataBufferHeap data(data_byte_size, 0); | 129 | 3 | size_t bytes_read = process->ReadMemory(from_addr, data.GetBytes(), | 130 | 3 | data.GetByteSize(), error); | 131 | 3 | if (bytes_read != data_byte_size || !error.Success()) | 132 | 0 | return false; | 133 | | | 134 | 3 | DataExtractor extractor(data.GetBytes(), data.GetByteSize(), | 135 | 3 | process->GetByteOrder(), sizeof(ptr_t)); | 136 | 3 | lldb::offset_t offset = 0; | 137 | 3 | entry->next_entry = extractor.GetAddress(&offset); | 138 | 3 | entry->prev_entry = extractor.GetAddress(&offset); | 139 | 3 | entry->symfile_addr = extractor.GetAddress(&offset); | 140 | 3 | offset = llvm::alignTo(offset, uint64_align_bytes); | 141 | 3 | entry->symfile_size = extractor.GetU64(&offset); | 142 | | | 143 | 3 | return true; | 144 | 3 | } |
Unexecuted instantiation: JITLoaderGDB.cpp:bool ReadJITEntry<unsigned int>(unsigned long long, lldb_private::Process*, jit_code_entry<unsigned int>*) |
145 | | |
146 | | JITLoaderGDB::JITLoaderGDB(lldb_private::Process *process) |
147 | 174 | : JITLoader(process), m_jit_objects(), |
148 | 174 | m_jit_break_id(LLDB_INVALID_BREAK_ID), |
149 | 174 | m_jit_descriptor_addr(LLDB_INVALID_ADDRESS) {} |
150 | | |
151 | 174 | JITLoaderGDB::~JITLoaderGDB() { |
152 | 174 | if (LLDB_BREAK_ID_IS_VALID(m_jit_break_id)) |
153 | 5 | m_process->GetTarget().RemoveBreakpointByID(m_jit_break_id); |
154 | 174 | } |
155 | | |
156 | 6.09k | void JITLoaderGDB::DebuggerInitialize(Debugger &debugger) { |
157 | 6.09k | if (!PluginManager::GetSettingForJITLoaderPlugin( |
158 | 6.09k | debugger, PluginProperties::GetSettingName())) { |
159 | 6.09k | const bool is_global_setting = true; |
160 | 6.09k | PluginManager::CreateSettingForJITLoaderPlugin( |
161 | 6.09k | debugger, GetGlobalPluginProperties().GetValueProperties(), |
162 | 6.09k | "Properties for the JIT LoaderGDB plug-in.", is_global_setting); |
163 | 6.09k | } |
164 | 6.09k | } |
165 | | |
166 | 172 | void JITLoaderGDB::DidAttach() { |
167 | 172 | Target &target = m_process->GetTarget(); |
168 | 172 | ModuleList &module_list = target.GetImages(); |
169 | 172 | SetJITBreakpoint(module_list); |
170 | 172 | } |
171 | | |
172 | 2 | void JITLoaderGDB::DidLaunch() { |
173 | 2 | Target &target = m_process->GetTarget(); |
174 | 2 | ModuleList &module_list = target.GetImages(); |
175 | 2 | SetJITBreakpoint(module_list); |
176 | 2 | } |
177 | | |
178 | 96 | void JITLoaderGDB::ModulesDidLoad(ModuleList &module_list) { |
179 | 96 | if (!DidSetJITBreakpoint() && m_process->IsAlive()85 ) |
180 | 85 | SetJITBreakpoint(module_list); |
181 | 96 | } |
182 | | |
183 | | // Setup the JIT Breakpoint |
184 | 259 | void JITLoaderGDB::SetJITBreakpoint(lldb_private::ModuleList &module_list) { |
185 | 259 | if (DidSetJITBreakpoint()) |
186 | 5 | return; |
187 | | |
188 | 254 | Log *log = GetLog(LLDBLog::JITLoader); |
189 | 254 | LLDB_LOGF(log, "JITLoaderGDB::%s looking for JIT register hook", |
190 | 254 | __FUNCTION__); |
191 | | |
192 | 254 | addr_t jit_addr = GetSymbolAddress( |
193 | 254 | module_list, ConstString("__jit_debug_register_code"), eSymbolTypeCode); |
194 | 254 | if (jit_addr == LLDB_INVALID_ADDRESS) |
195 | 249 | return; |
196 | | |
197 | 5 | m_jit_descriptor_addr = GetSymbolAddress( |
198 | 5 | module_list, ConstString("__jit_debug_descriptor"), eSymbolTypeData); |
199 | 5 | if (m_jit_descriptor_addr == LLDB_INVALID_ADDRESS) { |
200 | 0 | LLDB_LOGF(log, "JITLoaderGDB::%s failed to find JIT descriptor address", |
201 | 0 | __FUNCTION__); |
202 | 0 | return; |
203 | 0 | } |
204 | | |
205 | 5 | LLDB_LOGF(log, "JITLoaderGDB::%s setting JIT breakpoint", __FUNCTION__); |
206 | | |
207 | 5 | Breakpoint *bp = |
208 | 5 | m_process->GetTarget().CreateBreakpoint(jit_addr, true, false).get(); |
209 | 5 | bp->SetCallback(JITDebugBreakpointHit, this, true); |
210 | 5 | bp->SetBreakpointKind("jit-debug-register"); |
211 | 5 | m_jit_break_id = bp->GetID(); |
212 | | |
213 | 5 | ReadJITDescriptor(true); |
214 | 5 | } |
215 | | |
216 | | bool JITLoaderGDB::JITDebugBreakpointHit(void *baton, |
217 | | StoppointCallbackContext *context, |
218 | | user_id_t break_id, |
219 | 3 | user_id_t break_loc_id) { |
220 | 3 | Log *log = GetLog(LLDBLog::JITLoader); |
221 | 3 | LLDB_LOGF(log, "JITLoaderGDB::%s hit JIT breakpoint", __FUNCTION__); |
222 | 3 | JITLoaderGDB *instance = static_cast<JITLoaderGDB *>(baton); |
223 | 3 | return instance->ReadJITDescriptor(false); |
224 | 3 | } |
225 | | |
226 | | static void updateSectionLoadAddress(const SectionList §ion_list, |
227 | | Target &target, uint64_t symbolfile_addr, |
228 | | uint64_t symbolfile_size, |
229 | | uint64_t &vmaddrheuristic, |
230 | 0 | uint64_t &min_addr, uint64_t &max_addr) { |
231 | 0 | const uint32_t num_sections = section_list.GetSize(); |
232 | 0 | for (uint32_t i = 0; i < num_sections; ++i) { |
233 | 0 | SectionSP section_sp(section_list.GetSectionAtIndex(i)); |
234 | 0 | if (section_sp) { |
235 | 0 | if (section_sp->IsFake()) { |
236 | 0 | uint64_t lower = (uint64_t)-1; |
237 | 0 | uint64_t upper = 0; |
238 | 0 | updateSectionLoadAddress(section_sp->GetChildren(), target, |
239 | 0 | symbolfile_addr, symbolfile_size, |
240 | 0 | vmaddrheuristic, lower, upper); |
241 | 0 | if (lower < min_addr) |
242 | 0 | min_addr = lower; |
243 | 0 | if (upper > max_addr) |
244 | 0 | max_addr = upper; |
245 | 0 | const lldb::addr_t slide_amount = lower - section_sp->GetFileAddress(); |
246 | 0 | section_sp->Slide(slide_amount, false); |
247 | 0 | section_sp->GetChildren().Slide(-slide_amount, false); |
248 | 0 | section_sp->SetByteSize(upper - lower); |
249 | 0 | } else { |
250 | 0 | vmaddrheuristic += 2 << section_sp->GetLog2Align(); |
251 | 0 | uint64_t lower; |
252 | 0 | if (section_sp->GetFileAddress() > vmaddrheuristic) |
253 | 0 | lower = section_sp->GetFileAddress(); |
254 | 0 | else { |
255 | 0 | lower = symbolfile_addr + section_sp->GetFileOffset(); |
256 | 0 | section_sp->SetFileAddress(symbolfile_addr + |
257 | 0 | section_sp->GetFileOffset()); |
258 | 0 | } |
259 | 0 | target.SetSectionLoadAddress(section_sp, lower, true); |
260 | 0 | uint64_t upper = lower + section_sp->GetByteSize(); |
261 | 0 | if (lower < min_addr) |
262 | 0 | min_addr = lower; |
263 | 0 | if (upper > max_addr) |
264 | 0 | max_addr = upper; |
265 | | // This is an upper bound, but a good enough heuristic |
266 | 0 | vmaddrheuristic += section_sp->GetByteSize(); |
267 | 0 | } |
268 | 0 | } |
269 | 0 | } |
270 | 0 | } |
271 | | |
272 | 8 | bool JITLoaderGDB::ReadJITDescriptor(bool all_entries) { |
273 | 8 | if (m_process->GetTarget().GetArchitecture().GetAddressByteSize() == 8) |
274 | 8 | return ReadJITDescriptorImpl<uint64_t>(all_entries); |
275 | 0 | else |
276 | 0 | return ReadJITDescriptorImpl<uint32_t>(all_entries); |
277 | 8 | } |
278 | | |
279 | | template <typename ptr_t> |
280 | 8 | bool JITLoaderGDB::ReadJITDescriptorImpl(bool all_entries) { |
281 | 8 | if (m_jit_descriptor_addr == LLDB_INVALID_ADDRESS) |
282 | 0 | return false; |
283 | | |
284 | 8 | Log *log = GetLog(LLDBLog::JITLoader); |
285 | 8 | Target &target = m_process->GetTarget(); |
286 | 8 | ModuleList &module_list = target.GetImages(); |
287 | | |
288 | 8 | jit_descriptor<ptr_t> jit_desc; |
289 | 8 | const size_t jit_desc_size = sizeof(jit_desc); |
290 | 8 | Status error; |
291 | 8 | size_t bytes_read = m_process->ReadMemory(m_jit_descriptor_addr, &jit_desc, |
292 | 8 | jit_desc_size, error); |
293 | 8 | if (bytes_read != jit_desc_size || !error.Success()) { |
294 | 0 | LLDB_LOGF(log, "JITLoaderGDB::%s failed to read JIT descriptor", |
295 | 0 | __FUNCTION__); |
296 | 0 | return false; |
297 | 0 | } |
298 | | |
299 | 8 | jit_actions_t jit_action = (jit_actions_t)jit_desc.action_flag; |
300 | 8 | addr_t jit_relevant_entry = (addr_t)jit_desc.relevant_entry; |
301 | 8 | if (all_entries) { |
302 | 5 | jit_action = JIT_REGISTER_FN; |
303 | 5 | jit_relevant_entry = (addr_t)jit_desc.first_entry; |
304 | 5 | } |
305 | | |
306 | 11 | while (jit_relevant_entry != 0) { |
307 | 3 | jit_code_entry<ptr_t> jit_entry; |
308 | 3 | if (!ReadJITEntry(jit_relevant_entry, m_process, &jit_entry)) { |
309 | 0 | LLDB_LOGF(log, "JITLoaderGDB::%s failed to read JIT entry at 0x%" PRIx64, |
310 | 0 | __FUNCTION__, jit_relevant_entry); |
311 | 0 | return false; |
312 | 0 | } |
313 | | |
314 | 3 | const addr_t &symbolfile_addr = (addr_t)jit_entry.symfile_addr; |
315 | 3 | const size_t &symbolfile_size = (size_t)jit_entry.symfile_size; |
316 | 3 | ModuleSP module_sp; |
317 | | |
318 | 3 | if (jit_action == JIT_REGISTER_FN) { |
319 | 3 | LLDB_LOGF(log, |
320 | 3 | "JITLoaderGDB::%s registering JIT entry at 0x%" PRIx64 |
321 | 3 | " (%" PRIu64 " bytes)", |
322 | 3 | __FUNCTION__, symbolfile_addr, (uint64_t)symbolfile_size); |
323 | | |
324 | 3 | char jit_name[64]; |
325 | 3 | snprintf(jit_name, 64, "JIT(0x%" PRIx64 ")", symbolfile_addr); |
326 | 3 | module_sp = m_process->ReadModuleFromMemory( |
327 | 3 | FileSpec(jit_name), symbolfile_addr, symbolfile_size); |
328 | | |
329 | 3 | if (module_sp && module_sp->GetObjectFile()) { |
330 | | // Object formats (like ELF) have no representation for a JIT type. |
331 | | // We will get it wrong, if we deduce it from the header. |
332 | 3 | module_sp->GetObjectFile()->SetType(ObjectFile::eTypeJIT); |
333 | | |
334 | | // load the symbol table right away |
335 | 3 | module_sp->GetObjectFile()->GetSymtab(); |
336 | | |
337 | 3 | m_jit_objects.insert(std::make_pair(symbolfile_addr, module_sp)); |
338 | 3 | if (auto image_object_file = |
339 | 3 | llvm::dyn_cast<ObjectFileMachO>(module_sp->GetObjectFile())) { |
340 | 0 | const SectionList *section_list = image_object_file->GetSectionList(); |
341 | 0 | if (section_list) { |
342 | 0 | uint64_t vmaddrheuristic = 0; |
343 | 0 | uint64_t lower = (uint64_t)-1; |
344 | 0 | uint64_t upper = 0; |
345 | 0 | updateSectionLoadAddress(*section_list, target, symbolfile_addr, |
346 | 0 | symbolfile_size, vmaddrheuristic, lower, |
347 | 0 | upper); |
348 | 0 | } |
349 | 3 | } else { |
350 | 3 | bool changed = false; |
351 | 3 | module_sp->SetLoadAddress(target, 0, true, changed); |
352 | 3 | } |
353 | | |
354 | 3 | module_list.AppendIfNeeded(module_sp); |
355 | | |
356 | 3 | ModuleList module_list; |
357 | 3 | module_list.Append(module_sp); |
358 | 3 | target.ModulesDidLoad(module_list); |
359 | 3 | } else { |
360 | 0 | LLDB_LOGF(log, |
361 | 0 | "JITLoaderGDB::%s failed to load module for " |
362 | 0 | "JIT entry at 0x%" PRIx64, |
363 | 0 | __FUNCTION__, symbolfile_addr); |
364 | 0 | } |
365 | 3 | } else if (0 jit_action == JIT_UNREGISTER_FN0 ) { |
366 | 0 | LLDB_LOGF(log, "JITLoaderGDB::%s unregistering JIT entry at 0x%" PRIx64, |
367 | 0 | __FUNCTION__, symbolfile_addr); |
368 | |
|
369 | 0 | JITObjectMap::iterator it = m_jit_objects.find(symbolfile_addr); |
370 | 0 | if (it != m_jit_objects.end()) { |
371 | 0 | module_sp = it->second; |
372 | 0 | ObjectFile *image_object_file = module_sp->GetObjectFile(); |
373 | 0 | if (image_object_file) { |
374 | 0 | const SectionList *section_list = image_object_file->GetSectionList(); |
375 | 0 | if (section_list) { |
376 | 0 | const uint32_t num_sections = section_list->GetSize(); |
377 | 0 | for (uint32_t i = 0; i < num_sections; ++i) { |
378 | 0 | SectionSP section_sp(section_list->GetSectionAtIndex(i)); |
379 | 0 | if (section_sp) { |
380 | 0 | target.GetSectionLoadList().SetSectionUnloaded(section_sp); |
381 | 0 | } |
382 | 0 | } |
383 | 0 | } |
384 | 0 | } |
385 | 0 | module_list.Remove(module_sp); |
386 | 0 | m_jit_objects.erase(it); |
387 | 0 | } |
388 | 0 | } else if (jit_action == JIT_NOACTION) { |
389 | | // Nothing to do |
390 | 0 | } else { |
391 | 0 | assert(false && "Unknown jit action"); |
392 | 0 | } |
393 | | |
394 | 3 | if (all_entries) |
395 | 0 | jit_relevant_entry = (addr_t)jit_entry.next_entry; |
396 | 3 | else |
397 | 3 | jit_relevant_entry = 0; |
398 | 3 | } |
399 | | |
400 | 8 | return false; // Continue Running. |
401 | 8 | } bool JITLoaderGDB::ReadJITDescriptorImpl<unsigned long long>(bool) Line | Count | Source | 280 | 8 | bool JITLoaderGDB::ReadJITDescriptorImpl(bool all_entries) { | 281 | 8 | if (m_jit_descriptor_addr == LLDB_INVALID_ADDRESS) | 282 | 0 | return false; | 283 | | | 284 | 8 | Log *log = GetLog(LLDBLog::JITLoader); | 285 | 8 | Target &target = m_process->GetTarget(); | 286 | 8 | ModuleList &module_list = target.GetImages(); | 287 | | | 288 | 8 | jit_descriptor<ptr_t> jit_desc; | 289 | 8 | const size_t jit_desc_size = sizeof(jit_desc); | 290 | 8 | Status error; | 291 | 8 | size_t bytes_read = m_process->ReadMemory(m_jit_descriptor_addr, &jit_desc, | 292 | 8 | jit_desc_size, error); | 293 | 8 | if (bytes_read != jit_desc_size || !error.Success()) { | 294 | 0 | LLDB_LOGF(log, "JITLoaderGDB::%s failed to read JIT descriptor", | 295 | 0 | __FUNCTION__); | 296 | 0 | return false; | 297 | 0 | } | 298 | | | 299 | 8 | jit_actions_t jit_action = (jit_actions_t)jit_desc.action_flag; | 300 | 8 | addr_t jit_relevant_entry = (addr_t)jit_desc.relevant_entry; | 301 | 8 | if (all_entries) { | 302 | 5 | jit_action = JIT_REGISTER_FN; | 303 | 5 | jit_relevant_entry = (addr_t)jit_desc.first_entry; | 304 | 5 | } | 305 | | | 306 | 11 | while (jit_relevant_entry != 0) { | 307 | 3 | jit_code_entry<ptr_t> jit_entry; | 308 | 3 | if (!ReadJITEntry(jit_relevant_entry, m_process, &jit_entry)) { | 309 | 0 | LLDB_LOGF(log, "JITLoaderGDB::%s failed to read JIT entry at 0x%" PRIx64, | 310 | 0 | __FUNCTION__, jit_relevant_entry); | 311 | 0 | return false; | 312 | 0 | } | 313 | | | 314 | 3 | const addr_t &symbolfile_addr = (addr_t)jit_entry.symfile_addr; | 315 | 3 | const size_t &symbolfile_size = (size_t)jit_entry.symfile_size; | 316 | 3 | ModuleSP module_sp; | 317 | | | 318 | 3 | if (jit_action == JIT_REGISTER_FN) { | 319 | 3 | LLDB_LOGF(log, | 320 | 3 | "JITLoaderGDB::%s registering JIT entry at 0x%" PRIx64 | 321 | 3 | " (%" PRIu64 " bytes)", | 322 | 3 | __FUNCTION__, symbolfile_addr, (uint64_t)symbolfile_size); | 323 | | | 324 | 3 | char jit_name[64]; | 325 | 3 | snprintf(jit_name, 64, "JIT(0x%" PRIx64 ")", symbolfile_addr); | 326 | 3 | module_sp = m_process->ReadModuleFromMemory( | 327 | 3 | FileSpec(jit_name), symbolfile_addr, symbolfile_size); | 328 | | | 329 | 3 | if (module_sp && module_sp->GetObjectFile()) { | 330 | | // Object formats (like ELF) have no representation for a JIT type. | 331 | | // We will get it wrong, if we deduce it from the header. | 332 | 3 | module_sp->GetObjectFile()->SetType(ObjectFile::eTypeJIT); | 333 | | | 334 | | // load the symbol table right away | 335 | 3 | module_sp->GetObjectFile()->GetSymtab(); | 336 | | | 337 | 3 | m_jit_objects.insert(std::make_pair(symbolfile_addr, module_sp)); | 338 | 3 | if (auto image_object_file = | 339 | 3 | llvm::dyn_cast<ObjectFileMachO>(module_sp->GetObjectFile())) { | 340 | 0 | const SectionList *section_list = image_object_file->GetSectionList(); | 341 | 0 | if (section_list) { | 342 | 0 | uint64_t vmaddrheuristic = 0; | 343 | 0 | uint64_t lower = (uint64_t)-1; | 344 | 0 | uint64_t upper = 0; | 345 | 0 | updateSectionLoadAddress(*section_list, target, symbolfile_addr, | 346 | 0 | symbolfile_size, vmaddrheuristic, lower, | 347 | 0 | upper); | 348 | 0 | } | 349 | 3 | } else { | 350 | 3 | bool changed = false; | 351 | 3 | module_sp->SetLoadAddress(target, 0, true, changed); | 352 | 3 | } | 353 | | | 354 | 3 | module_list.AppendIfNeeded(module_sp); | 355 | | | 356 | 3 | ModuleList module_list; | 357 | 3 | module_list.Append(module_sp); | 358 | 3 | target.ModulesDidLoad(module_list); | 359 | 3 | } else { | 360 | 0 | LLDB_LOGF(log, | 361 | 0 | "JITLoaderGDB::%s failed to load module for " | 362 | 0 | "JIT entry at 0x%" PRIx64, | 363 | 0 | __FUNCTION__, symbolfile_addr); | 364 | 0 | } | 365 | 3 | } else if (0 jit_action == JIT_UNREGISTER_FN0 ) { | 366 | 0 | LLDB_LOGF(log, "JITLoaderGDB::%s unregistering JIT entry at 0x%" PRIx64, | 367 | 0 | __FUNCTION__, symbolfile_addr); | 368 | |
| 369 | 0 | JITObjectMap::iterator it = m_jit_objects.find(symbolfile_addr); | 370 | 0 | if (it != m_jit_objects.end()) { | 371 | 0 | module_sp = it->second; | 372 | 0 | ObjectFile *image_object_file = module_sp->GetObjectFile(); | 373 | 0 | if (image_object_file) { | 374 | 0 | const SectionList *section_list = image_object_file->GetSectionList(); | 375 | 0 | if (section_list) { | 376 | 0 | const uint32_t num_sections = section_list->GetSize(); | 377 | 0 | for (uint32_t i = 0; i < num_sections; ++i) { | 378 | 0 | SectionSP section_sp(section_list->GetSectionAtIndex(i)); | 379 | 0 | if (section_sp) { | 380 | 0 | target.GetSectionLoadList().SetSectionUnloaded(section_sp); | 381 | 0 | } | 382 | 0 | } | 383 | 0 | } | 384 | 0 | } | 385 | 0 | module_list.Remove(module_sp); | 386 | 0 | m_jit_objects.erase(it); | 387 | 0 | } | 388 | 0 | } else if (jit_action == JIT_NOACTION) { | 389 | | // Nothing to do | 390 | 0 | } else { | 391 | 0 | assert(false && "Unknown jit action"); | 392 | 0 | } | 393 | | | 394 | 3 | if (all_entries) | 395 | 0 | jit_relevant_entry = (addr_t)jit_entry.next_entry; | 396 | 3 | else | 397 | 3 | jit_relevant_entry = 0; | 398 | 3 | } | 399 | | | 400 | 8 | return false; // Continue Running. | 401 | 8 | } |
Unexecuted instantiation: bool JITLoaderGDB::ReadJITDescriptorImpl<unsigned int>(bool) |
402 | | |
403 | | // PluginInterface protocol |
404 | 2.34k | JITLoaderSP JITLoaderGDB::CreateInstance(Process *process, bool force) { |
405 | 2.34k | JITLoaderSP jit_loader_sp; |
406 | 2.34k | bool enable; |
407 | 2.34k | switch (GetGlobalPluginProperties().GetEnable()) { |
408 | 5 | case EnableJITLoaderGDB::eEnableJITLoaderGDBOn: |
409 | 5 | enable = true; |
410 | 5 | break; |
411 | 2 | case EnableJITLoaderGDB::eEnableJITLoaderGDBOff: |
412 | 2 | enable = false; |
413 | 2 | break; |
414 | 2.33k | case EnableJITLoaderGDB::eEnableJITLoaderGDBDefault: |
415 | 2.33k | ArchSpec arch(process->GetTarget().GetArchitecture()); |
416 | 2.33k | enable = arch.GetTriple().getVendor() != llvm::Triple::Apple; |
417 | 2.33k | break; |
418 | 2.34k | } |
419 | 2.34k | if (enable) |
420 | 174 | jit_loader_sp = std::make_shared<JITLoaderGDB>(process); |
421 | 2.34k | return jit_loader_sp; |
422 | 2.34k | } |
423 | | |
424 | 3.95k | llvm::StringRef JITLoaderGDB::GetPluginDescriptionStatic() { |
425 | 3.95k | return "JIT loader plug-in that watches for JIT events using the GDB " |
426 | 3.95k | "interface."; |
427 | 3.95k | } |
428 | | |
429 | 3.95k | void JITLoaderGDB::Initialize() { |
430 | 3.95k | PluginManager::RegisterPlugin(GetPluginNameStatic(), |
431 | 3.95k | GetPluginDescriptionStatic(), CreateInstance, |
432 | 3.95k | DebuggerInitialize); |
433 | 3.95k | } |
434 | | |
435 | 3.94k | void JITLoaderGDB::Terminate() { |
436 | 3.94k | PluginManager::UnregisterPlugin(CreateInstance); |
437 | 3.94k | } |
438 | | |
439 | 355 | bool JITLoaderGDB::DidSetJITBreakpoint() const { |
440 | 355 | return LLDB_BREAK_ID_IS_VALID(m_jit_break_id); |
441 | 355 | } |
442 | | |
443 | | addr_t JITLoaderGDB::GetSymbolAddress(ModuleList &module_list, |
444 | | ConstString name, |
445 | 259 | SymbolType symbol_type) const { |
446 | 259 | SymbolContextList target_symbols; |
447 | 259 | Target &target = m_process->GetTarget(); |
448 | | |
449 | 259 | module_list.FindSymbolsWithNameAndType(name, symbol_type, target_symbols); |
450 | 259 | if (target_symbols.IsEmpty()) |
451 | 249 | return LLDB_INVALID_ADDRESS; |
452 | | |
453 | 10 | SymbolContext sym_ctx; |
454 | 10 | target_symbols.GetContextAtIndex(0, sym_ctx); |
455 | | |
456 | 10 | const Address jit_descriptor_addr = sym_ctx.symbol->GetAddress(); |
457 | 10 | if (!jit_descriptor_addr.IsValid()) |
458 | 0 | return LLDB_INVALID_ADDRESS; |
459 | | |
460 | 10 | const addr_t jit_addr = jit_descriptor_addr.GetLoadAddress(&target); |
461 | 10 | return jit_addr; |
462 | 10 | } |