1 //===-- Module.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 "lldb/Core/Module.h"
10
11 #include "lldb/Core/AddressRange.h"
12 #include "lldb/Core/AddressResolverFileLine.h"
13 #include "lldb/Core/Debugger.h"
14 #include "lldb/Core/FileSpecList.h"
15 #include "lldb/Core/Mangled.h"
16 #include "lldb/Core/ModuleSpec.h"
17 #include "lldb/Core/SearchFilter.h"
18 #include "lldb/Core/Section.h"
19 #include "lldb/Host/FileSystem.h"
20 #include "lldb/Host/Host.h"
21 #include "lldb/Host/HostInfo.h"
22 #include "lldb/Interpreter/CommandInterpreter.h"
23 #include "lldb/Interpreter/ScriptInterpreter.h"
24 #include "lldb/Symbol/CompileUnit.h"
25 #include "lldb/Symbol/Function.h"
26 #include "lldb/Symbol/ObjectFile.h"
27 #include "lldb/Symbol/Symbol.h"
28 #include "lldb/Symbol/SymbolContext.h"
29 #include "lldb/Symbol/SymbolFile.h"
30 #include "lldb/Symbol/SymbolVendor.h"
31 #include "lldb/Symbol/Symtab.h"
32 #include "lldb/Symbol/Type.h"
33 #include "lldb/Symbol/TypeList.h"
34 #include "lldb/Symbol/TypeMap.h"
35 #include "lldb/Symbol/TypeSystem.h"
36 #include "lldb/Target/Language.h"
37 #include "lldb/Target/Process.h"
38 #include "lldb/Target/Target.h"
39 #include "lldb/Utility/DataBufferHeap.h"
40 #include "lldb/Utility/LLDBAssert.h"
41 #include "lldb/Utility/Log.h"
42 #include "lldb/Utility/Logging.h"
43 #include "lldb/Utility/RegularExpression.h"
44 #include "lldb/Utility/Status.h"
45 #include "lldb/Utility/Stream.h"
46 #include "lldb/Utility/StreamString.h"
47 #include "lldb/Utility/Timer.h"
48
49 #if defined(_WIN32)
50 #include "lldb/Host/windows/PosixApi.h"
51 #endif
52
53 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
54 #include "Plugins/Language/ObjC/ObjCLanguage.h"
55
56 #include "llvm/ADT/STLExtras.h"
57 #include "llvm/Support/Compiler.h"
58 #include "llvm/Support/FileSystem.h"
59 #include "llvm/Support/Signals.h"
60 #include "llvm/Support/raw_ostream.h"
61
62 #include <assert.h>
63 #include <cstdint>
64 #include <inttypes.h>
65 #include <map>
66 #include <stdarg.h>
67 #include <string.h>
68 #include <type_traits>
69 #include <utility>
70
71 namespace lldb_private {
72 class CompilerDeclContext;
73 }
74 namespace lldb_private {
75 class VariableList;
76 }
77
78 using namespace lldb;
79 using namespace lldb_private;
80
81 // Shared pointers to modules track module lifetimes in targets and in the
82 // global module, but this collection will track all module objects that are
83 // still alive
84 typedef std::vector<Module *> ModuleCollection;
85
GetModuleCollection()86 static ModuleCollection &GetModuleCollection() {
87 // This module collection needs to live past any module, so we could either
88 // make it a shared pointer in each module or just leak is. Since it is only
89 // an empty vector by the time all the modules have gone away, we just leak
90 // it for now. If we decide this is a big problem we can introduce a
91 // Finalize method that will tear everything down in a predictable order.
92
93 static ModuleCollection *g_module_collection = nullptr;
94 if (g_module_collection == nullptr)
95 g_module_collection = new ModuleCollection();
96
97 return *g_module_collection;
98 }
99
GetAllocationModuleCollectionMutex()100 std::recursive_mutex &Module::GetAllocationModuleCollectionMutex() {
101 // NOTE: The mutex below must be leaked since the global module list in
102 // the ModuleList class will get torn at some point, and we can't know if it
103 // will tear itself down before the "g_module_collection_mutex" below will.
104 // So we leak a Mutex object below to safeguard against that
105
106 static std::recursive_mutex *g_module_collection_mutex = nullptr;
107 if (g_module_collection_mutex == nullptr)
108 g_module_collection_mutex = new std::recursive_mutex; // NOTE: known leak
109 return *g_module_collection_mutex;
110 }
111
GetNumberAllocatedModules()112 size_t Module::GetNumberAllocatedModules() {
113 std::lock_guard<std::recursive_mutex> guard(
114 GetAllocationModuleCollectionMutex());
115 return GetModuleCollection().size();
116 }
117
GetAllocatedModuleAtIndex(size_t idx)118 Module *Module::GetAllocatedModuleAtIndex(size_t idx) {
119 std::lock_guard<std::recursive_mutex> guard(
120 GetAllocationModuleCollectionMutex());
121 ModuleCollection &modules = GetModuleCollection();
122 if (idx < modules.size())
123 return modules[idx];
124 return nullptr;
125 }
126
Module(const ModuleSpec & module_spec)127 Module::Module(const ModuleSpec &module_spec)
128 : m_object_offset(0), m_file_has_changed(false),
129 m_first_file_changed_log(false) {
130 // Scope for locker below...
131 {
132 std::lock_guard<std::recursive_mutex> guard(
133 GetAllocationModuleCollectionMutex());
134 GetModuleCollection().push_back(this);
135 }
136
137 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_OBJECT |
138 LIBLLDB_LOG_MODULES));
139 if (log != nullptr)
140 LLDB_LOGF(log, "%p Module::Module((%s) '%s%s%s%s')",
141 static_cast<void *>(this),
142 module_spec.GetArchitecture().GetArchitectureName(),
143 module_spec.GetFileSpec().GetPath().c_str(),
144 module_spec.GetObjectName().IsEmpty() ? "" : "(",
145 module_spec.GetObjectName().IsEmpty()
146 ? ""
147 : module_spec.GetObjectName().AsCString(""),
148 module_spec.GetObjectName().IsEmpty() ? "" : ")");
149
150 auto data_sp = module_spec.GetData();
151 lldb::offset_t file_size = 0;
152 if (data_sp)
153 file_size = data_sp->GetByteSize();
154
155 // First extract all module specifications from the file using the local file
156 // path. If there are no specifications, then don't fill anything in
157 ModuleSpecList modules_specs;
158 if (ObjectFile::GetModuleSpecifications(
159 module_spec.GetFileSpec(), 0, file_size, modules_specs, data_sp) == 0)
160 return;
161
162 // Now make sure that one of the module specifications matches what we just
163 // extract. We might have a module specification that specifies a file
164 // "/usr/lib/dyld" with UUID XXX, but we might have a local version of
165 // "/usr/lib/dyld" that has
166 // UUID YYY and we don't want those to match. If they don't match, just don't
167 // fill any ivars in so we don't accidentally grab the wrong file later since
168 // they don't match...
169 ModuleSpec matching_module_spec;
170 if (!modules_specs.FindMatchingModuleSpec(module_spec,
171 matching_module_spec)) {
172 if (log) {
173 LLDB_LOGF(log, "Found local object file but the specs didn't match");
174 }
175 return;
176 }
177
178 // Set m_data_sp if it was initially provided in the ModuleSpec. Note that
179 // we cannot use the data_sp variable here, because it will have been
180 // modified by GetModuleSpecifications().
181 if (auto module_spec_data_sp = module_spec.GetData()) {
182 m_data_sp = module_spec_data_sp;
183 m_mod_time = {};
184 } else {
185 if (module_spec.GetFileSpec())
186 m_mod_time =
187 FileSystem::Instance().GetModificationTime(module_spec.GetFileSpec());
188 else if (matching_module_spec.GetFileSpec())
189 m_mod_time = FileSystem::Instance().GetModificationTime(
190 matching_module_spec.GetFileSpec());
191 }
192
193 // Copy the architecture from the actual spec if we got one back, else use
194 // the one that was specified
195 if (matching_module_spec.GetArchitecture().IsValid())
196 m_arch = matching_module_spec.GetArchitecture();
197 else if (module_spec.GetArchitecture().IsValid())
198 m_arch = module_spec.GetArchitecture();
199
200 // Copy the file spec over and use the specified one (if there was one) so we
201 // don't use a path that might have gotten resolved a path in
202 // 'matching_module_spec'
203 if (module_spec.GetFileSpec())
204 m_file = module_spec.GetFileSpec();
205 else if (matching_module_spec.GetFileSpec())
206 m_file = matching_module_spec.GetFileSpec();
207
208 // Copy the platform file spec over
209 if (module_spec.GetPlatformFileSpec())
210 m_platform_file = module_spec.GetPlatformFileSpec();
211 else if (matching_module_spec.GetPlatformFileSpec())
212 m_platform_file = matching_module_spec.GetPlatformFileSpec();
213
214 // Copy the symbol file spec over
215 if (module_spec.GetSymbolFileSpec())
216 m_symfile_spec = module_spec.GetSymbolFileSpec();
217 else if (matching_module_spec.GetSymbolFileSpec())
218 m_symfile_spec = matching_module_spec.GetSymbolFileSpec();
219
220 // Copy the object name over
221 if (matching_module_spec.GetObjectName())
222 m_object_name = matching_module_spec.GetObjectName();
223 else
224 m_object_name = module_spec.GetObjectName();
225
226 // Always trust the object offset (file offset) and object modification time
227 // (for mod time in a BSD static archive) of from the matching module
228 // specification
229 m_object_offset = matching_module_spec.GetObjectOffset();
230 m_object_mod_time = matching_module_spec.GetObjectModificationTime();
231 }
232
Module(const FileSpec & file_spec,const ArchSpec & arch,const ConstString * object_name,lldb::offset_t object_offset,const llvm::sys::TimePoint<> & object_mod_time)233 Module::Module(const FileSpec &file_spec, const ArchSpec &arch,
234 const ConstString *object_name, lldb::offset_t object_offset,
235 const llvm::sys::TimePoint<> &object_mod_time)
236 : m_mod_time(FileSystem::Instance().GetModificationTime(file_spec)), m_arch(arch),
237 m_file(file_spec), m_object_offset(object_offset),
238 m_object_mod_time(object_mod_time), m_file_has_changed(false),
239 m_first_file_changed_log(false) {
240 // Scope for locker below...
241 {
242 std::lock_guard<std::recursive_mutex> guard(
243 GetAllocationModuleCollectionMutex());
244 GetModuleCollection().push_back(this);
245 }
246
247 if (object_name)
248 m_object_name = *object_name;
249
250 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_OBJECT |
251 LIBLLDB_LOG_MODULES));
252 if (log != nullptr)
253 LLDB_LOGF(log, "%p Module::Module((%s) '%s%s%s%s')",
254 static_cast<void *>(this), m_arch.GetArchitectureName(),
255 m_file.GetPath().c_str(), m_object_name.IsEmpty() ? "" : "(",
256 m_object_name.IsEmpty() ? "" : m_object_name.AsCString(""),
257 m_object_name.IsEmpty() ? "" : ")");
258 }
259
Module()260 Module::Module()
261 : m_object_offset(0), m_file_has_changed(false),
262 m_first_file_changed_log(false) {
263 std::lock_guard<std::recursive_mutex> guard(
264 GetAllocationModuleCollectionMutex());
265 GetModuleCollection().push_back(this);
266 }
267
~Module()268 Module::~Module() {
269 // Lock our module down while we tear everything down to make sure we don't
270 // get any access to the module while it is being destroyed
271 std::lock_guard<std::recursive_mutex> guard(m_mutex);
272 // Scope for locker below...
273 {
274 std::lock_guard<std::recursive_mutex> guard(
275 GetAllocationModuleCollectionMutex());
276 ModuleCollection &modules = GetModuleCollection();
277 ModuleCollection::iterator end = modules.end();
278 ModuleCollection::iterator pos = std::find(modules.begin(), end, this);
279 assert(pos != end);
280 modules.erase(pos);
281 }
282 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_OBJECT |
283 LIBLLDB_LOG_MODULES));
284 if (log != nullptr)
285 LLDB_LOGF(log, "%p Module::~Module((%s) '%s%s%s%s')",
286 static_cast<void *>(this), m_arch.GetArchitectureName(),
287 m_file.GetPath().c_str(), m_object_name.IsEmpty() ? "" : "(",
288 m_object_name.IsEmpty() ? "" : m_object_name.AsCString(""),
289 m_object_name.IsEmpty() ? "" : ")");
290 // Release any auto pointers before we start tearing down our member
291 // variables since the object file and symbol files might need to make
292 // function calls back into this module object. The ordering is important
293 // here because symbol files can require the module object file. So we tear
294 // down the symbol file first, then the object file.
295 m_sections_up.reset();
296 m_symfile_up.reset();
297 m_objfile_sp.reset();
298 }
299
GetMemoryObjectFile(const lldb::ProcessSP & process_sp,lldb::addr_t header_addr,Status & error,size_t size_to_read)300 ObjectFile *Module::GetMemoryObjectFile(const lldb::ProcessSP &process_sp,
301 lldb::addr_t header_addr, Status &error,
302 size_t size_to_read) {
303 if (m_objfile_sp) {
304 error.SetErrorString("object file already exists");
305 } else {
306 std::lock_guard<std::recursive_mutex> guard(m_mutex);
307 if (process_sp) {
308 m_did_load_objfile = true;
309 auto data_up = std::make_unique<DataBufferHeap>(size_to_read, 0);
310 Status readmem_error;
311 const size_t bytes_read =
312 process_sp->ReadMemory(header_addr, data_up->GetBytes(),
313 data_up->GetByteSize(), readmem_error);
314 if (bytes_read < size_to_read)
315 data_up->SetByteSize(bytes_read);
316 if (data_up->GetByteSize() > 0) {
317 DataBufferSP data_sp(data_up.release());
318 m_objfile_sp = ObjectFile::FindPlugin(shared_from_this(), process_sp,
319 header_addr, data_sp);
320 if (m_objfile_sp) {
321 StreamString s;
322 s.Printf("0x%16.16" PRIx64, header_addr);
323 m_object_name.SetString(s.GetString());
324
325 // Once we get the object file, update our module with the object
326 // file's architecture since it might differ in vendor/os if some
327 // parts were unknown.
328 m_arch = m_objfile_sp->GetArchitecture();
329
330 // Augment the arch with the target's information in case
331 // we are unable to extract the os/environment from memory.
332 m_arch.MergeFrom(process_sp->GetTarget().GetArchitecture());
333 } else {
334 error.SetErrorString("unable to find suitable object file plug-in");
335 }
336 } else {
337 error.SetErrorStringWithFormat("unable to read header from memory: %s",
338 readmem_error.AsCString());
339 }
340 } else {
341 error.SetErrorString("invalid process");
342 }
343 }
344 return m_objfile_sp.get();
345 }
346
GetUUID()347 const lldb_private::UUID &Module::GetUUID() {
348 if (!m_did_set_uuid.load()) {
349 std::lock_guard<std::recursive_mutex> guard(m_mutex);
350 if (!m_did_set_uuid.load()) {
351 ObjectFile *obj_file = GetObjectFile();
352
353 if (obj_file != nullptr) {
354 m_uuid = obj_file->GetUUID();
355 m_did_set_uuid = true;
356 }
357 }
358 }
359 return m_uuid;
360 }
361
SetUUID(const lldb_private::UUID & uuid)362 void Module::SetUUID(const lldb_private::UUID &uuid) {
363 std::lock_guard<std::recursive_mutex> guard(m_mutex);
364 if (!m_did_set_uuid) {
365 m_uuid = uuid;
366 m_did_set_uuid = true;
367 } else {
368 lldbassert(0 && "Attempting to overwrite the existing module UUID");
369 }
370 }
371
372 llvm::Expected<TypeSystem &>
GetTypeSystemForLanguage(LanguageType language)373 Module::GetTypeSystemForLanguage(LanguageType language) {
374 return m_type_system_map.GetTypeSystemForLanguage(language, this, true);
375 }
376
ParseAllDebugSymbols()377 void Module::ParseAllDebugSymbols() {
378 std::lock_guard<std::recursive_mutex> guard(m_mutex);
379 size_t num_comp_units = GetNumCompileUnits();
380 if (num_comp_units == 0)
381 return;
382
383 SymbolFile *symbols = GetSymbolFile();
384
385 for (size_t cu_idx = 0; cu_idx < num_comp_units; cu_idx++) {
386 SymbolContext sc;
387 sc.module_sp = shared_from_this();
388 sc.comp_unit = symbols->GetCompileUnitAtIndex(cu_idx).get();
389 if (!sc.comp_unit)
390 continue;
391
392 symbols->ParseVariablesForContext(sc);
393
394 symbols->ParseFunctions(*sc.comp_unit);
395
396 sc.comp_unit->ForeachFunction([&sc, &symbols](const FunctionSP &f) {
397 symbols->ParseBlocksRecursive(*f);
398
399 // Parse the variables for this function and all its blocks
400 sc.function = f.get();
401 symbols->ParseVariablesForContext(sc);
402 return false;
403 });
404
405 // Parse all types for this compile unit
406 symbols->ParseTypes(*sc.comp_unit);
407 }
408 }
409
CalculateSymbolContext(SymbolContext * sc)410 void Module::CalculateSymbolContext(SymbolContext *sc) {
411 sc->module_sp = shared_from_this();
412 }
413
CalculateSymbolContextModule()414 ModuleSP Module::CalculateSymbolContextModule() { return shared_from_this(); }
415
DumpSymbolContext(Stream * s)416 void Module::DumpSymbolContext(Stream *s) {
417 s->Printf(", Module{%p}", static_cast<void *>(this));
418 }
419
GetNumCompileUnits()420 size_t Module::GetNumCompileUnits() {
421 std::lock_guard<std::recursive_mutex> guard(m_mutex);
422 LLDB_SCOPED_TIMERF("Module::GetNumCompileUnits (module = %p)",
423 static_cast<void *>(this));
424 if (SymbolFile *symbols = GetSymbolFile())
425 return symbols->GetNumCompileUnits();
426 return 0;
427 }
428
GetCompileUnitAtIndex(size_t index)429 CompUnitSP Module::GetCompileUnitAtIndex(size_t index) {
430 std::lock_guard<std::recursive_mutex> guard(m_mutex);
431 size_t num_comp_units = GetNumCompileUnits();
432 CompUnitSP cu_sp;
433
434 if (index < num_comp_units) {
435 if (SymbolFile *symbols = GetSymbolFile())
436 cu_sp = symbols->GetCompileUnitAtIndex(index);
437 }
438 return cu_sp;
439 }
440
ResolveFileAddress(lldb::addr_t vm_addr,Address & so_addr)441 bool Module::ResolveFileAddress(lldb::addr_t vm_addr, Address &so_addr) {
442 std::lock_guard<std::recursive_mutex> guard(m_mutex);
443 LLDB_SCOPED_TIMERF("Module::ResolveFileAddress (vm_addr = 0x%" PRIx64 ")",
444 vm_addr);
445 SectionList *section_list = GetSectionList();
446 if (section_list)
447 return so_addr.ResolveAddressUsingFileSections(vm_addr, section_list);
448 return false;
449 }
450
ResolveSymbolContextForAddress(const Address & so_addr,lldb::SymbolContextItem resolve_scope,SymbolContext & sc,bool resolve_tail_call_address)451 uint32_t Module::ResolveSymbolContextForAddress(
452 const Address &so_addr, lldb::SymbolContextItem resolve_scope,
453 SymbolContext &sc, bool resolve_tail_call_address) {
454 std::lock_guard<std::recursive_mutex> guard(m_mutex);
455 uint32_t resolved_flags = 0;
456
457 // Clear the result symbol context in case we don't find anything, but don't
458 // clear the target
459 sc.Clear(false);
460
461 // Get the section from the section/offset address.
462 SectionSP section_sp(so_addr.GetSection());
463
464 // Make sure the section matches this module before we try and match anything
465 if (section_sp && section_sp->GetModule().get() == this) {
466 // If the section offset based address resolved itself, then this is the
467 // right module.
468 sc.module_sp = shared_from_this();
469 resolved_flags |= eSymbolContextModule;
470
471 SymbolFile *symfile = GetSymbolFile();
472 if (!symfile)
473 return resolved_flags;
474
475 // Resolve the compile unit, function, block, line table or line entry if
476 // requested.
477 if (resolve_scope & eSymbolContextCompUnit ||
478 resolve_scope & eSymbolContextFunction ||
479 resolve_scope & eSymbolContextBlock ||
480 resolve_scope & eSymbolContextLineEntry ||
481 resolve_scope & eSymbolContextVariable) {
482 resolved_flags |=
483 symfile->ResolveSymbolContext(so_addr, resolve_scope, sc);
484 }
485
486 // Resolve the symbol if requested, but don't re-look it up if we've
487 // already found it.
488 if (resolve_scope & eSymbolContextSymbol &&
489 !(resolved_flags & eSymbolContextSymbol)) {
490 Symtab *symtab = symfile->GetSymtab();
491 if (symtab && so_addr.IsSectionOffset()) {
492 Symbol *matching_symbol = nullptr;
493
494 symtab->ForEachSymbolContainingFileAddress(
495 so_addr.GetFileAddress(),
496 [&matching_symbol](Symbol *symbol) -> bool {
497 if (symbol->GetType() != eSymbolTypeInvalid) {
498 matching_symbol = symbol;
499 return false; // Stop iterating
500 }
501 return true; // Keep iterating
502 });
503 sc.symbol = matching_symbol;
504 if (!sc.symbol && resolve_scope & eSymbolContextFunction &&
505 !(resolved_flags & eSymbolContextFunction)) {
506 bool verify_unique = false; // No need to check again since
507 // ResolveSymbolContext failed to find a
508 // symbol at this address.
509 if (ObjectFile *obj_file = sc.module_sp->GetObjectFile())
510 sc.symbol =
511 obj_file->ResolveSymbolForAddress(so_addr, verify_unique);
512 }
513
514 if (sc.symbol) {
515 if (sc.symbol->IsSynthetic()) {
516 // We have a synthetic symbol so lets check if the object file from
517 // the symbol file in the symbol vendor is different than the
518 // object file for the module, and if so search its symbol table to
519 // see if we can come up with a better symbol. For example dSYM
520 // files on MacOSX have an unstripped symbol table inside of them.
521 ObjectFile *symtab_objfile = symtab->GetObjectFile();
522 if (symtab_objfile && symtab_objfile->IsStripped()) {
523 ObjectFile *symfile_objfile = symfile->GetObjectFile();
524 if (symfile_objfile != symtab_objfile) {
525 Symtab *symfile_symtab = symfile_objfile->GetSymtab();
526 if (symfile_symtab) {
527 Symbol *symbol =
528 symfile_symtab->FindSymbolContainingFileAddress(
529 so_addr.GetFileAddress());
530 if (symbol && !symbol->IsSynthetic()) {
531 sc.symbol = symbol;
532 }
533 }
534 }
535 }
536 }
537 resolved_flags |= eSymbolContextSymbol;
538 }
539 }
540 }
541
542 // For function symbols, so_addr may be off by one. This is a convention
543 // consistent with FDE row indices in eh_frame sections, but requires extra
544 // logic here to permit symbol lookup for disassembly and unwind.
545 if (resolve_scope & eSymbolContextSymbol &&
546 !(resolved_flags & eSymbolContextSymbol) && resolve_tail_call_address &&
547 so_addr.IsSectionOffset()) {
548 Address previous_addr = so_addr;
549 previous_addr.Slide(-1);
550
551 bool do_resolve_tail_call_address = false; // prevent recursion
552 const uint32_t flags = ResolveSymbolContextForAddress(
553 previous_addr, resolve_scope, sc, do_resolve_tail_call_address);
554 if (flags & eSymbolContextSymbol) {
555 AddressRange addr_range;
556 if (sc.GetAddressRange(eSymbolContextFunction | eSymbolContextSymbol, 0,
557 false, addr_range)) {
558 if (addr_range.GetBaseAddress().GetSection() ==
559 so_addr.GetSection()) {
560 // If the requested address is one past the address range of a
561 // function (i.e. a tail call), or the decremented address is the
562 // start of a function (i.e. some forms of trampoline), indicate
563 // that the symbol has been resolved.
564 if (so_addr.GetOffset() ==
565 addr_range.GetBaseAddress().GetOffset() ||
566 so_addr.GetOffset() ==
567 addr_range.GetBaseAddress().GetOffset() +
568 addr_range.GetByteSize()) {
569 resolved_flags |= flags;
570 }
571 } else {
572 sc.symbol =
573 nullptr; // Don't trust the symbol if the sections didn't match.
574 }
575 }
576 }
577 }
578 }
579 return resolved_flags;
580 }
581
ResolveSymbolContextForFilePath(const char * file_path,uint32_t line,bool check_inlines,lldb::SymbolContextItem resolve_scope,SymbolContextList & sc_list)582 uint32_t Module::ResolveSymbolContextForFilePath(
583 const char *file_path, uint32_t line, bool check_inlines,
584 lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
585 FileSpec file_spec(file_path);
586 return ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines,
587 resolve_scope, sc_list);
588 }
589
ResolveSymbolContextsForFileSpec(const FileSpec & file_spec,uint32_t line,bool check_inlines,lldb::SymbolContextItem resolve_scope,SymbolContextList & sc_list)590 uint32_t Module::ResolveSymbolContextsForFileSpec(
591 const FileSpec &file_spec, uint32_t line, bool check_inlines,
592 lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
593 std::lock_guard<std::recursive_mutex> guard(m_mutex);
594 LLDB_SCOPED_TIMERF("Module::ResolveSymbolContextForFilePath (%s:%u, "
595 "check_inlines = %s, resolve_scope = 0x%8.8x)",
596 file_spec.GetPath().c_str(), line,
597 check_inlines ? "yes" : "no", resolve_scope);
598
599 const uint32_t initial_count = sc_list.GetSize();
600
601 if (SymbolFile *symbols = GetSymbolFile())
602 symbols->ResolveSymbolContext(file_spec, line, check_inlines, resolve_scope,
603 sc_list);
604
605 return sc_list.GetSize() - initial_count;
606 }
607
FindGlobalVariables(ConstString name,const CompilerDeclContext & parent_decl_ctx,size_t max_matches,VariableList & variables)608 void Module::FindGlobalVariables(ConstString name,
609 const CompilerDeclContext &parent_decl_ctx,
610 size_t max_matches, VariableList &variables) {
611 if (SymbolFile *symbols = GetSymbolFile())
612 symbols->FindGlobalVariables(name, parent_decl_ctx, max_matches, variables);
613 }
614
FindGlobalVariables(const RegularExpression & regex,size_t max_matches,VariableList & variables)615 void Module::FindGlobalVariables(const RegularExpression ®ex,
616 size_t max_matches, VariableList &variables) {
617 SymbolFile *symbols = GetSymbolFile();
618 if (symbols)
619 symbols->FindGlobalVariables(regex, max_matches, variables);
620 }
621
FindCompileUnits(const FileSpec & path,SymbolContextList & sc_list)622 void Module::FindCompileUnits(const FileSpec &path,
623 SymbolContextList &sc_list) {
624 const size_t num_compile_units = GetNumCompileUnits();
625 SymbolContext sc;
626 sc.module_sp = shared_from_this();
627 for (size_t i = 0; i < num_compile_units; ++i) {
628 sc.comp_unit = GetCompileUnitAtIndex(i).get();
629 if (sc.comp_unit) {
630 if (FileSpec::Match(path, sc.comp_unit->GetPrimaryFile()))
631 sc_list.Append(sc);
632 }
633 }
634 }
635
LookupInfo(ConstString name,FunctionNameType name_type_mask,LanguageType language)636 Module::LookupInfo::LookupInfo(ConstString name,
637 FunctionNameType name_type_mask,
638 LanguageType language)
639 : m_name(name), m_lookup_name(), m_language(language),
640 m_name_type_mask(eFunctionNameTypeNone),
641 m_match_name_after_lookup(false) {
642 const char *name_cstr = name.GetCString();
643 llvm::StringRef basename;
644 llvm::StringRef context;
645
646 if (name_type_mask & eFunctionNameTypeAuto) {
647 if (CPlusPlusLanguage::IsCPPMangledName(name_cstr))
648 m_name_type_mask = eFunctionNameTypeFull;
649 else if ((language == eLanguageTypeUnknown ||
650 Language::LanguageIsObjC(language)) &&
651 ObjCLanguage::IsPossibleObjCMethodName(name_cstr))
652 m_name_type_mask = eFunctionNameTypeFull;
653 else if (Language::LanguageIsC(language)) {
654 m_name_type_mask = eFunctionNameTypeFull;
655 } else {
656 if ((language == eLanguageTypeUnknown ||
657 Language::LanguageIsObjC(language)) &&
658 ObjCLanguage::IsPossibleObjCSelector(name_cstr))
659 m_name_type_mask |= eFunctionNameTypeSelector;
660
661 CPlusPlusLanguage::MethodName cpp_method(name);
662 basename = cpp_method.GetBasename();
663 if (basename.empty()) {
664 if (CPlusPlusLanguage::ExtractContextAndIdentifier(name_cstr, context,
665 basename))
666 m_name_type_mask |= (eFunctionNameTypeMethod | eFunctionNameTypeBase);
667 else
668 m_name_type_mask |= eFunctionNameTypeFull;
669 } else {
670 m_name_type_mask |= (eFunctionNameTypeMethod | eFunctionNameTypeBase);
671 }
672 }
673 } else {
674 m_name_type_mask = name_type_mask;
675 if (name_type_mask & eFunctionNameTypeMethod ||
676 name_type_mask & eFunctionNameTypeBase) {
677 // If they've asked for a CPP method or function name and it can't be
678 // that, we don't even need to search for CPP methods or names.
679 CPlusPlusLanguage::MethodName cpp_method(name);
680 if (cpp_method.IsValid()) {
681 basename = cpp_method.GetBasename();
682
683 if (!cpp_method.GetQualifiers().empty()) {
684 // There is a "const" or other qualifier following the end of the
685 // function parens, this can't be a eFunctionNameTypeBase
686 m_name_type_mask &= ~(eFunctionNameTypeBase);
687 if (m_name_type_mask == eFunctionNameTypeNone)
688 return;
689 }
690 } else {
691 // If the CPP method parser didn't manage to chop this up, try to fill
692 // in the base name if we can. If a::b::c is passed in, we need to just
693 // look up "c", and then we'll filter the result later.
694 CPlusPlusLanguage::ExtractContextAndIdentifier(name_cstr, context,
695 basename);
696 }
697 }
698
699 if (name_type_mask & eFunctionNameTypeSelector) {
700 if (!ObjCLanguage::IsPossibleObjCSelector(name_cstr)) {
701 m_name_type_mask &= ~(eFunctionNameTypeSelector);
702 if (m_name_type_mask == eFunctionNameTypeNone)
703 return;
704 }
705 }
706
707 // Still try and get a basename in case someone specifies a name type mask
708 // of eFunctionNameTypeFull and a name like "A::func"
709 if (basename.empty()) {
710 if (name_type_mask & eFunctionNameTypeFull &&
711 !CPlusPlusLanguage::IsCPPMangledName(name_cstr)) {
712 CPlusPlusLanguage::MethodName cpp_method(name);
713 basename = cpp_method.GetBasename();
714 if (basename.empty())
715 CPlusPlusLanguage::ExtractContextAndIdentifier(name_cstr, context,
716 basename);
717 }
718 }
719 }
720
721 if (!basename.empty()) {
722 // The name supplied was a partial C++ path like "a::count". In this case
723 // we want to do a lookup on the basename "count" and then make sure any
724 // matching results contain "a::count" so that it would match "b::a::count"
725 // and "a::count". This is why we set "match_name_after_lookup" to true
726 m_lookup_name.SetString(basename);
727 m_match_name_after_lookup = true;
728 } else {
729 // The name is already correct, just use the exact name as supplied, and we
730 // won't need to check if any matches contain "name"
731 m_lookup_name = name;
732 m_match_name_after_lookup = false;
733 }
734 }
735
Prune(SymbolContextList & sc_list,size_t start_idx) const736 void Module::LookupInfo::Prune(SymbolContextList &sc_list,
737 size_t start_idx) const {
738 if (m_match_name_after_lookup && m_name) {
739 SymbolContext sc;
740 size_t i = start_idx;
741 while (i < sc_list.GetSize()) {
742 if (!sc_list.GetContextAtIndex(i, sc))
743 break;
744 ConstString full_name(sc.GetFunctionName());
745 if (full_name &&
746 ::strstr(full_name.GetCString(), m_name.GetCString()) == nullptr) {
747 sc_list.RemoveContextAtIndex(i);
748 } else {
749 ++i;
750 }
751 }
752 }
753
754 // If we have only full name matches we might have tried to set breakpoint on
755 // "func" and specified eFunctionNameTypeFull, but we might have found
756 // "a::func()", "a::b::func()", "c::func()", "func()" and "func". Only
757 // "func()" and "func" should end up matching.
758 if (m_name_type_mask == eFunctionNameTypeFull) {
759 SymbolContext sc;
760 size_t i = start_idx;
761 while (i < sc_list.GetSize()) {
762 if (!sc_list.GetContextAtIndex(i, sc))
763 break;
764 // Make sure the mangled and demangled names don't match before we try to
765 // pull anything out
766 ConstString mangled_name(sc.GetFunctionName(Mangled::ePreferMangled));
767 ConstString full_name(sc.GetFunctionName());
768 if (mangled_name != m_name && full_name != m_name)
769 {
770 CPlusPlusLanguage::MethodName cpp_method(full_name);
771 if (cpp_method.IsValid()) {
772 if (cpp_method.GetContext().empty()) {
773 if (cpp_method.GetBasename().compare(m_name.GetStringRef()) != 0) {
774 sc_list.RemoveContextAtIndex(i);
775 continue;
776 }
777 } else {
778 std::string qualified_name;
779 llvm::StringRef anon_prefix("(anonymous namespace)");
780 if (cpp_method.GetContext() == anon_prefix)
781 qualified_name = cpp_method.GetBasename().str();
782 else
783 qualified_name = cpp_method.GetScopeQualifiedName();
784 if (qualified_name != m_name.GetCString()) {
785 sc_list.RemoveContextAtIndex(i);
786 continue;
787 }
788 }
789 }
790 }
791 ++i;
792 }
793 }
794 }
795
FindFunctions(ConstString name,const CompilerDeclContext & parent_decl_ctx,FunctionNameType name_type_mask,bool include_symbols,bool include_inlines,SymbolContextList & sc_list)796 void Module::FindFunctions(ConstString name,
797 const CompilerDeclContext &parent_decl_ctx,
798 FunctionNameType name_type_mask,
799 bool include_symbols, bool include_inlines,
800 SymbolContextList &sc_list) {
801 const size_t old_size = sc_list.GetSize();
802
803 // Find all the functions (not symbols, but debug information functions...
804 SymbolFile *symbols = GetSymbolFile();
805
806 if (name_type_mask & eFunctionNameTypeAuto) {
807 LookupInfo lookup_info(name, name_type_mask, eLanguageTypeUnknown);
808
809 if (symbols) {
810 symbols->FindFunctions(lookup_info.GetLookupName(), parent_decl_ctx,
811 lookup_info.GetNameTypeMask(), include_inlines,
812 sc_list);
813
814 // Now check our symbol table for symbols that are code symbols if
815 // requested
816 if (include_symbols) {
817 Symtab *symtab = symbols->GetSymtab();
818 if (symtab)
819 symtab->FindFunctionSymbols(lookup_info.GetLookupName(),
820 lookup_info.GetNameTypeMask(), sc_list);
821 }
822 }
823
824 const size_t new_size = sc_list.GetSize();
825
826 if (old_size < new_size)
827 lookup_info.Prune(sc_list, old_size);
828 } else {
829 if (symbols) {
830 symbols->FindFunctions(name, parent_decl_ctx, name_type_mask,
831 include_inlines, sc_list);
832
833 // Now check our symbol table for symbols that are code symbols if
834 // requested
835 if (include_symbols) {
836 Symtab *symtab = symbols->GetSymtab();
837 if (symtab)
838 symtab->FindFunctionSymbols(name, name_type_mask, sc_list);
839 }
840 }
841 }
842 }
843
FindFunctions(const RegularExpression & regex,bool include_symbols,bool include_inlines,SymbolContextList & sc_list)844 void Module::FindFunctions(const RegularExpression ®ex, bool include_symbols,
845 bool include_inlines,
846 SymbolContextList &sc_list) {
847 const size_t start_size = sc_list.GetSize();
848
849 if (SymbolFile *symbols = GetSymbolFile()) {
850 symbols->FindFunctions(regex, include_inlines, sc_list);
851
852 // Now check our symbol table for symbols that are code symbols if
853 // requested
854 if (include_symbols) {
855 Symtab *symtab = symbols->GetSymtab();
856 if (symtab) {
857 std::vector<uint32_t> symbol_indexes;
858 symtab->AppendSymbolIndexesMatchingRegExAndType(
859 regex, eSymbolTypeAny, Symtab::eDebugAny, Symtab::eVisibilityAny,
860 symbol_indexes);
861 const size_t num_matches = symbol_indexes.size();
862 if (num_matches) {
863 SymbolContext sc(this);
864 const size_t end_functions_added_index = sc_list.GetSize();
865 size_t num_functions_added_to_sc_list =
866 end_functions_added_index - start_size;
867 if (num_functions_added_to_sc_list == 0) {
868 // No functions were added, just symbols, so we can just append
869 // them
870 for (size_t i = 0; i < num_matches; ++i) {
871 sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]);
872 SymbolType sym_type = sc.symbol->GetType();
873 if (sc.symbol && (sym_type == eSymbolTypeCode ||
874 sym_type == eSymbolTypeResolver))
875 sc_list.Append(sc);
876 }
877 } else {
878 typedef std::map<lldb::addr_t, uint32_t> FileAddrToIndexMap;
879 FileAddrToIndexMap file_addr_to_index;
880 for (size_t i = start_size; i < end_functions_added_index; ++i) {
881 const SymbolContext &sc = sc_list[i];
882 if (sc.block)
883 continue;
884 file_addr_to_index[sc.function->GetAddressRange()
885 .GetBaseAddress()
886 .GetFileAddress()] = i;
887 }
888
889 FileAddrToIndexMap::const_iterator end = file_addr_to_index.end();
890 // Functions were added so we need to merge symbols into any
891 // existing function symbol contexts
892 for (size_t i = start_size; i < num_matches; ++i) {
893 sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]);
894 SymbolType sym_type = sc.symbol->GetType();
895 if (sc.symbol && sc.symbol->ValueIsAddress() &&
896 (sym_type == eSymbolTypeCode ||
897 sym_type == eSymbolTypeResolver)) {
898 FileAddrToIndexMap::const_iterator pos =
899 file_addr_to_index.find(
900 sc.symbol->GetAddressRef().GetFileAddress());
901 if (pos == end)
902 sc_list.Append(sc);
903 else
904 sc_list[pos->second].symbol = sc.symbol;
905 }
906 }
907 }
908 }
909 }
910 }
911 }
912 }
913
FindAddressesForLine(const lldb::TargetSP target_sp,const FileSpec & file,uint32_t line,Function * function,std::vector<Address> & output_local,std::vector<Address> & output_extern)914 void Module::FindAddressesForLine(const lldb::TargetSP target_sp,
915 const FileSpec &file, uint32_t line,
916 Function *function,
917 std::vector<Address> &output_local,
918 std::vector<Address> &output_extern) {
919 SearchFilterByModule filter(target_sp, m_file);
920 AddressResolverFileLine resolver(file, line, true);
921 resolver.ResolveAddress(filter);
922
923 for (size_t n = 0; n < resolver.GetNumberOfAddresses(); n++) {
924 Address addr = resolver.GetAddressRangeAtIndex(n).GetBaseAddress();
925 Function *f = addr.CalculateSymbolContextFunction();
926 if (f && f == function)
927 output_local.push_back(addr);
928 else
929 output_extern.push_back(addr);
930 }
931 }
932
FindTypes_Impl(ConstString name,const CompilerDeclContext & parent_decl_ctx,size_t max_matches,llvm::DenseSet<lldb_private::SymbolFile * > & searched_symbol_files,TypeMap & types)933 void Module::FindTypes_Impl(
934 ConstString name, const CompilerDeclContext &parent_decl_ctx,
935 size_t max_matches,
936 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
937 TypeMap &types) {
938 LLDB_SCOPED_TIMER();
939 if (SymbolFile *symbols = GetSymbolFile())
940 symbols->FindTypes(name, parent_decl_ctx, max_matches,
941 searched_symbol_files, types);
942 }
943
FindTypesInNamespace(ConstString type_name,const CompilerDeclContext & parent_decl_ctx,size_t max_matches,TypeList & type_list)944 void Module::FindTypesInNamespace(ConstString type_name,
945 const CompilerDeclContext &parent_decl_ctx,
946 size_t max_matches, TypeList &type_list) {
947 TypeMap types_map;
948 llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
949 FindTypes_Impl(type_name, parent_decl_ctx, max_matches, searched_symbol_files,
950 types_map);
951 if (types_map.GetSize()) {
952 SymbolContext sc;
953 sc.module_sp = shared_from_this();
954 sc.SortTypeList(types_map, type_list);
955 }
956 }
957
FindFirstType(const SymbolContext & sc,ConstString name,bool exact_match)958 lldb::TypeSP Module::FindFirstType(const SymbolContext &sc,
959 ConstString name, bool exact_match) {
960 TypeList type_list;
961 llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
962 FindTypes(name, exact_match, 1, searched_symbol_files, type_list);
963 if (type_list.GetSize())
964 return type_list.GetTypeAtIndex(0);
965 return TypeSP();
966 }
967
FindTypes(ConstString name,bool exact_match,size_t max_matches,llvm::DenseSet<lldb_private::SymbolFile * > & searched_symbol_files,TypeList & types)968 void Module::FindTypes(
969 ConstString name, bool exact_match, size_t max_matches,
970 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
971 TypeList &types) {
972 const char *type_name_cstr = name.GetCString();
973 llvm::StringRef type_scope;
974 llvm::StringRef type_basename;
975 TypeClass type_class = eTypeClassAny;
976 TypeMap typesmap;
977
978 if (Type::GetTypeScopeAndBasename(type_name_cstr, type_scope, type_basename,
979 type_class)) {
980 // Check if "name" starts with "::" which means the qualified type starts
981 // from the root namespace and implies and exact match. The typenames we
982 // get back from clang do not start with "::" so we need to strip this off
983 // in order to get the qualified names to match
984 exact_match = type_scope.consume_front("::");
985
986 ConstString type_basename_const_str(type_basename);
987 FindTypes_Impl(type_basename_const_str, CompilerDeclContext(), max_matches,
988 searched_symbol_files, typesmap);
989 if (typesmap.GetSize())
990 typesmap.RemoveMismatchedTypes(std::string(type_scope),
991 std::string(type_basename), type_class,
992 exact_match);
993 } else {
994 // The type is not in a namespace/class scope, just search for it by
995 // basename
996 if (type_class != eTypeClassAny && !type_basename.empty()) {
997 // The "type_name_cstr" will have been modified if we have a valid type
998 // class prefix (like "struct", "class", "union", "typedef" etc).
999 FindTypes_Impl(ConstString(type_basename), CompilerDeclContext(),
1000 UINT_MAX, searched_symbol_files, typesmap);
1001 typesmap.RemoveMismatchedTypes(std::string(type_scope),
1002 std::string(type_basename), type_class,
1003 exact_match);
1004 } else {
1005 FindTypes_Impl(name, CompilerDeclContext(), UINT_MAX,
1006 searched_symbol_files, typesmap);
1007 if (exact_match) {
1008 std::string name_str(name.AsCString(""));
1009 typesmap.RemoveMismatchedTypes(std::string(type_scope), name_str,
1010 type_class, exact_match);
1011 }
1012 }
1013 }
1014 if (typesmap.GetSize()) {
1015 SymbolContext sc;
1016 sc.module_sp = shared_from_this();
1017 sc.SortTypeList(typesmap, types);
1018 }
1019 }
1020
FindTypes(llvm::ArrayRef<CompilerContext> pattern,LanguageSet languages,llvm::DenseSet<lldb_private::SymbolFile * > & searched_symbol_files,TypeMap & types)1021 void Module::FindTypes(
1022 llvm::ArrayRef<CompilerContext> pattern, LanguageSet languages,
1023 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
1024 TypeMap &types) {
1025 LLDB_SCOPED_TIMER();
1026 if (SymbolFile *symbols = GetSymbolFile())
1027 symbols->FindTypes(pattern, languages, searched_symbol_files, types);
1028 }
1029
GetSymbolFile(bool can_create,Stream * feedback_strm)1030 SymbolFile *Module::GetSymbolFile(bool can_create, Stream *feedback_strm) {
1031 if (!m_did_load_symfile.load()) {
1032 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1033 if (!m_did_load_symfile.load() && can_create) {
1034 ObjectFile *obj_file = GetObjectFile();
1035 if (obj_file != nullptr) {
1036 LLDB_SCOPED_TIMER();
1037 m_symfile_up.reset(
1038 SymbolVendor::FindPlugin(shared_from_this(), feedback_strm));
1039 m_did_load_symfile = true;
1040 }
1041 }
1042 }
1043 return m_symfile_up ? m_symfile_up->GetSymbolFile() : nullptr;
1044 }
1045
GetSymtab()1046 Symtab *Module::GetSymtab() {
1047 if (SymbolFile *symbols = GetSymbolFile())
1048 return symbols->GetSymtab();
1049 return nullptr;
1050 }
1051
SetFileSpecAndObjectName(const FileSpec & file,ConstString object_name)1052 void Module::SetFileSpecAndObjectName(const FileSpec &file,
1053 ConstString object_name) {
1054 // Container objects whose paths do not specify a file directly can call this
1055 // function to correct the file and object names.
1056 m_file = file;
1057 m_mod_time = FileSystem::Instance().GetModificationTime(file);
1058 m_object_name = object_name;
1059 }
1060
GetArchitecture() const1061 const ArchSpec &Module::GetArchitecture() const { return m_arch; }
1062
GetSpecificationDescription() const1063 std::string Module::GetSpecificationDescription() const {
1064 std::string spec(GetFileSpec().GetPath());
1065 if (m_object_name) {
1066 spec += '(';
1067 spec += m_object_name.GetCString();
1068 spec += ')';
1069 }
1070 return spec;
1071 }
1072
GetDescription(llvm::raw_ostream & s,lldb::DescriptionLevel level)1073 void Module::GetDescription(llvm::raw_ostream &s,
1074 lldb::DescriptionLevel level) {
1075 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1076
1077 if (level >= eDescriptionLevelFull) {
1078 if (m_arch.IsValid())
1079 s << llvm::formatv("({0}) ", m_arch.GetArchitectureName());
1080 }
1081
1082 if (level == eDescriptionLevelBrief) {
1083 const char *filename = m_file.GetFilename().GetCString();
1084 if (filename)
1085 s << filename;
1086 } else {
1087 char path[PATH_MAX];
1088 if (m_file.GetPath(path, sizeof(path)))
1089 s << path;
1090 }
1091
1092 const char *object_name = m_object_name.GetCString();
1093 if (object_name)
1094 s << llvm::formatv("({0})", object_name);
1095 }
1096
ReportError(const char * format,...)1097 void Module::ReportError(const char *format, ...) {
1098 if (format && format[0]) {
1099 StreamString strm;
1100 strm.PutCString("error: ");
1101 GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelBrief);
1102 strm.PutChar(' ');
1103 va_list args;
1104 va_start(args, format);
1105 strm.PrintfVarArg(format, args);
1106 va_end(args);
1107
1108 const int format_len = strlen(format);
1109 if (format_len > 0) {
1110 const char last_char = format[format_len - 1];
1111 if (last_char != '\n' && last_char != '\r')
1112 strm.EOL();
1113 }
1114 Host::SystemLog(Host::eSystemLogError, "%s", strm.GetData());
1115 }
1116 }
1117
FileHasChanged() const1118 bool Module::FileHasChanged() const {
1119 // We have provided the DataBuffer for this module to avoid accessing the
1120 // filesystem. We never want to reload those files.
1121 if (m_data_sp)
1122 return false;
1123 if (!m_file_has_changed)
1124 m_file_has_changed =
1125 (FileSystem::Instance().GetModificationTime(m_file) != m_mod_time);
1126 return m_file_has_changed;
1127 }
1128
ReportErrorIfModifyDetected(const char * format,...)1129 void Module::ReportErrorIfModifyDetected(const char *format, ...) {
1130 if (!m_first_file_changed_log) {
1131 if (FileHasChanged()) {
1132 m_first_file_changed_log = true;
1133 if (format) {
1134 StreamString strm;
1135 strm.PutCString("error: the object file ");
1136 GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelFull);
1137 strm.PutCString(" has been modified\n");
1138
1139 va_list args;
1140 va_start(args, format);
1141 strm.PrintfVarArg(format, args);
1142 va_end(args);
1143
1144 const int format_len = strlen(format);
1145 if (format_len > 0) {
1146 const char last_char = format[format_len - 1];
1147 if (last_char != '\n' && last_char != '\r')
1148 strm.EOL();
1149 }
1150 strm.PutCString("The debug session should be aborted as the original "
1151 "debug information has been overwritten.\n");
1152 Host::SystemLog(Host::eSystemLogError, "%s", strm.GetData());
1153 }
1154 }
1155 }
1156 }
1157
ReportWarning(const char * format,...)1158 void Module::ReportWarning(const char *format, ...) {
1159 if (format && format[0]) {
1160 StreamString strm;
1161 strm.PutCString("warning: ");
1162 GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelFull);
1163 strm.PutChar(' ');
1164
1165 va_list args;
1166 va_start(args, format);
1167 strm.PrintfVarArg(format, args);
1168 va_end(args);
1169
1170 const int format_len = strlen(format);
1171 if (format_len > 0) {
1172 const char last_char = format[format_len - 1];
1173 if (last_char != '\n' && last_char != '\r')
1174 strm.EOL();
1175 }
1176 Host::SystemLog(Host::eSystemLogWarning, "%s", strm.GetData());
1177 }
1178 }
1179
LogMessage(Log * log,const char * format,...)1180 void Module::LogMessage(Log *log, const char *format, ...) {
1181 if (log != nullptr) {
1182 StreamString log_message;
1183 GetDescription(log_message.AsRawOstream(), lldb::eDescriptionLevelFull);
1184 log_message.PutCString(": ");
1185 va_list args;
1186 va_start(args, format);
1187 log_message.PrintfVarArg(format, args);
1188 va_end(args);
1189 log->PutCString(log_message.GetData());
1190 }
1191 }
1192
LogMessageVerboseBacktrace(Log * log,const char * format,...)1193 void Module::LogMessageVerboseBacktrace(Log *log, const char *format, ...) {
1194 if (log != nullptr) {
1195 StreamString log_message;
1196 GetDescription(log_message.AsRawOstream(), lldb::eDescriptionLevelFull);
1197 log_message.PutCString(": ");
1198 va_list args;
1199 va_start(args, format);
1200 log_message.PrintfVarArg(format, args);
1201 va_end(args);
1202 if (log->GetVerbose()) {
1203 std::string back_trace;
1204 llvm::raw_string_ostream stream(back_trace);
1205 llvm::sys::PrintStackTrace(stream);
1206 log_message.PutCString(back_trace);
1207 }
1208 log->PutCString(log_message.GetData());
1209 }
1210 }
1211
Dump(Stream * s)1212 void Module::Dump(Stream *s) {
1213 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1214 // s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
1215 s->Indent();
1216 s->Printf("Module %s%s%s%s\n", m_file.GetPath().c_str(),
1217 m_object_name ? "(" : "",
1218 m_object_name ? m_object_name.GetCString() : "",
1219 m_object_name ? ")" : "");
1220
1221 s->IndentMore();
1222
1223 ObjectFile *objfile = GetObjectFile();
1224 if (objfile)
1225 objfile->Dump(s);
1226
1227 if (SymbolFile *symbols = GetSymbolFile())
1228 symbols->Dump(*s);
1229
1230 s->IndentLess();
1231 }
1232
GetObjectName() const1233 ConstString Module::GetObjectName() const { return m_object_name; }
1234
GetObjectFile()1235 ObjectFile *Module::GetObjectFile() {
1236 if (!m_did_load_objfile.load()) {
1237 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1238 if (!m_did_load_objfile.load()) {
1239 LLDB_SCOPED_TIMERF("Module::GetObjectFile () module = %s",
1240 GetFileSpec().GetFilename().AsCString(""));
1241 lldb::offset_t data_offset = 0;
1242 lldb::offset_t file_size = 0;
1243
1244 if (m_data_sp)
1245 file_size = m_data_sp->GetByteSize();
1246 else if (m_file)
1247 file_size = FileSystem::Instance().GetByteSize(m_file);
1248
1249 if (file_size > m_object_offset) {
1250 m_did_load_objfile = true;
1251 // FindPlugin will modify its data_sp argument. Do not let it
1252 // modify our m_data_sp member.
1253 auto data_sp = m_data_sp;
1254 m_objfile_sp = ObjectFile::FindPlugin(
1255 shared_from_this(), &m_file, m_object_offset,
1256 file_size - m_object_offset, data_sp, data_offset);
1257 if (m_objfile_sp) {
1258 // Once we get the object file, update our module with the object
1259 // file's architecture since it might differ in vendor/os if some
1260 // parts were unknown. But since the matching arch might already be
1261 // more specific than the generic COFF architecture, only merge in
1262 // those values that overwrite unspecified unknown values.
1263 m_arch.MergeFrom(m_objfile_sp->GetArchitecture());
1264 } else {
1265 ReportError("failed to load objfile for %s",
1266 GetFileSpec().GetPath().c_str());
1267 }
1268 }
1269 }
1270 }
1271 return m_objfile_sp.get();
1272 }
1273
GetSectionList()1274 SectionList *Module::GetSectionList() {
1275 // Populate m_sections_up with sections from objfile.
1276 if (!m_sections_up) {
1277 ObjectFile *obj_file = GetObjectFile();
1278 if (obj_file != nullptr)
1279 obj_file->CreateSections(*GetUnifiedSectionList());
1280 }
1281 return m_sections_up.get();
1282 }
1283
SectionFileAddressesChanged()1284 void Module::SectionFileAddressesChanged() {
1285 ObjectFile *obj_file = GetObjectFile();
1286 if (obj_file)
1287 obj_file->SectionFileAddressesChanged();
1288 if (SymbolFile *symbols = GetSymbolFile())
1289 symbols->SectionFileAddressesChanged();
1290 }
1291
GetUnwindTable()1292 UnwindTable &Module::GetUnwindTable() {
1293 if (!m_unwind_table)
1294 m_unwind_table.emplace(*this);
1295 return *m_unwind_table;
1296 }
1297
GetUnifiedSectionList()1298 SectionList *Module::GetUnifiedSectionList() {
1299 if (!m_sections_up)
1300 m_sections_up = std::make_unique<SectionList>();
1301 return m_sections_up.get();
1302 }
1303
FindFirstSymbolWithNameAndType(ConstString name,SymbolType symbol_type)1304 const Symbol *Module::FindFirstSymbolWithNameAndType(ConstString name,
1305 SymbolType symbol_type) {
1306 LLDB_SCOPED_TIMERF(
1307 "Module::FindFirstSymbolWithNameAndType (name = %s, type = %i)",
1308 name.AsCString(), symbol_type);
1309 if (Symtab *symtab = GetSymtab())
1310 return symtab->FindFirstSymbolWithNameAndType(
1311 name, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny);
1312 return nullptr;
1313 }
SymbolIndicesToSymbolContextList(Symtab * symtab,std::vector<uint32_t> & symbol_indexes,SymbolContextList & sc_list)1314 void Module::SymbolIndicesToSymbolContextList(
1315 Symtab *symtab, std::vector<uint32_t> &symbol_indexes,
1316 SymbolContextList &sc_list) {
1317 // No need to protect this call using m_mutex all other method calls are
1318 // already thread safe.
1319
1320 size_t num_indices = symbol_indexes.size();
1321 if (num_indices > 0) {
1322 SymbolContext sc;
1323 CalculateSymbolContext(&sc);
1324 for (size_t i = 0; i < num_indices; i++) {
1325 sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]);
1326 if (sc.symbol)
1327 sc_list.Append(sc);
1328 }
1329 }
1330 }
1331
FindFunctionSymbols(ConstString name,uint32_t name_type_mask,SymbolContextList & sc_list)1332 void Module::FindFunctionSymbols(ConstString name,
1333 uint32_t name_type_mask,
1334 SymbolContextList &sc_list) {
1335 LLDB_SCOPED_TIMERF("Module::FindSymbolsFunctions (name = %s, mask = 0x%8.8x)",
1336 name.AsCString(), name_type_mask);
1337 if (Symtab *symtab = GetSymtab())
1338 symtab->FindFunctionSymbols(name, name_type_mask, sc_list);
1339 }
1340
FindSymbolsWithNameAndType(ConstString name,SymbolType symbol_type,SymbolContextList & sc_list)1341 void Module::FindSymbolsWithNameAndType(ConstString name,
1342 SymbolType symbol_type,
1343 SymbolContextList &sc_list) {
1344 // No need to protect this call using m_mutex all other method calls are
1345 // already thread safe.
1346 LLDB_SCOPED_TIMERF(
1347 "Module::FindSymbolsWithNameAndType (name = %s, type = %i)",
1348 name.AsCString(), symbol_type);
1349 if (Symtab *symtab = GetSymtab()) {
1350 std::vector<uint32_t> symbol_indexes;
1351 symtab->FindAllSymbolsWithNameAndType(name, symbol_type, symbol_indexes);
1352 SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list);
1353 }
1354 }
1355
FindSymbolsMatchingRegExAndType(const RegularExpression & regex,SymbolType symbol_type,SymbolContextList & sc_list)1356 void Module::FindSymbolsMatchingRegExAndType(const RegularExpression ®ex,
1357 SymbolType symbol_type,
1358 SymbolContextList &sc_list) {
1359 // No need to protect this call using m_mutex all other method calls are
1360 // already thread safe.
1361 LLDB_SCOPED_TIMERF(
1362 "Module::FindSymbolsMatchingRegExAndType (regex = %s, type = %i)",
1363 regex.GetText().str().c_str(), symbol_type);
1364 if (Symtab *symtab = GetSymtab()) {
1365 std::vector<uint32_t> symbol_indexes;
1366 symtab->FindAllSymbolsMatchingRexExAndType(
1367 regex, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny,
1368 symbol_indexes);
1369 SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list);
1370 }
1371 }
1372
PreloadSymbols()1373 void Module::PreloadSymbols() {
1374 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1375 SymbolFile *sym_file = GetSymbolFile();
1376 if (!sym_file)
1377 return;
1378
1379 // Prime the symbol file first, since it adds symbols to the symbol table.
1380 sym_file->PreloadSymbols();
1381
1382 // Now we can prime the symbol table.
1383 if (Symtab *symtab = sym_file->GetSymtab())
1384 symtab->PreloadSymbols();
1385 }
1386
SetSymbolFileFileSpec(const FileSpec & file)1387 void Module::SetSymbolFileFileSpec(const FileSpec &file) {
1388 if (!FileSystem::Instance().Exists(file))
1389 return;
1390 if (m_symfile_up) {
1391 // Remove any sections in the unified section list that come from the
1392 // current symbol vendor.
1393 SectionList *section_list = GetSectionList();
1394 SymbolFile *symbol_file = GetSymbolFile();
1395 if (section_list && symbol_file) {
1396 ObjectFile *obj_file = symbol_file->GetObjectFile();
1397 // Make sure we have an object file and that the symbol vendor's objfile
1398 // isn't the same as the module's objfile before we remove any sections
1399 // for it...
1400 if (obj_file) {
1401 // Check to make sure we aren't trying to specify the file we already
1402 // have
1403 if (obj_file->GetFileSpec() == file) {
1404 // We are being told to add the exact same file that we already have
1405 // we don't have to do anything.
1406 return;
1407 }
1408
1409 // Cleare the current symtab as we are going to replace it with a new
1410 // one
1411 obj_file->ClearSymtab();
1412
1413 // Clear the unwind table too, as that may also be affected by the
1414 // symbol file information.
1415 m_unwind_table.reset();
1416
1417 // The symbol file might be a directory bundle ("/tmp/a.out.dSYM")
1418 // instead of a full path to the symbol file within the bundle
1419 // ("/tmp/a.out.dSYM/Contents/Resources/DWARF/a.out"). So we need to
1420 // check this
1421
1422 if (FileSystem::Instance().IsDirectory(file)) {
1423 std::string new_path(file.GetPath());
1424 std::string old_path(obj_file->GetFileSpec().GetPath());
1425 if (llvm::StringRef(old_path).startswith(new_path)) {
1426 // We specified the same bundle as the symbol file that we already
1427 // have
1428 return;
1429 }
1430 }
1431
1432 if (obj_file != m_objfile_sp.get()) {
1433 size_t num_sections = section_list->GetNumSections(0);
1434 for (size_t idx = num_sections; idx > 0; --idx) {
1435 lldb::SectionSP section_sp(
1436 section_list->GetSectionAtIndex(idx - 1));
1437 if (section_sp->GetObjectFile() == obj_file) {
1438 section_list->DeleteSection(idx - 1);
1439 }
1440 }
1441 }
1442 }
1443 }
1444 // Keep all old symbol files around in case there are any lingering type
1445 // references in any SBValue objects that might have been handed out.
1446 m_old_symfiles.push_back(std::move(m_symfile_up));
1447 }
1448 m_symfile_spec = file;
1449 m_symfile_up.reset();
1450 m_did_load_symfile = false;
1451 }
1452
IsExecutable()1453 bool Module::IsExecutable() {
1454 if (GetObjectFile() == nullptr)
1455 return false;
1456 else
1457 return GetObjectFile()->IsExecutable();
1458 }
1459
IsLoadedInTarget(Target * target)1460 bool Module::IsLoadedInTarget(Target *target) {
1461 ObjectFile *obj_file = GetObjectFile();
1462 if (obj_file) {
1463 SectionList *sections = GetSectionList();
1464 if (sections != nullptr) {
1465 size_t num_sections = sections->GetSize();
1466 for (size_t sect_idx = 0; sect_idx < num_sections; sect_idx++) {
1467 SectionSP section_sp = sections->GetSectionAtIndex(sect_idx);
1468 if (section_sp->GetLoadBaseAddress(target) != LLDB_INVALID_ADDRESS) {
1469 return true;
1470 }
1471 }
1472 }
1473 }
1474 return false;
1475 }
1476
LoadScriptingResourceInTarget(Target * target,Status & error,Stream * feedback_stream)1477 bool Module::LoadScriptingResourceInTarget(Target *target, Status &error,
1478 Stream *feedback_stream) {
1479 if (!target) {
1480 error.SetErrorString("invalid destination Target");
1481 return false;
1482 }
1483
1484 LoadScriptFromSymFile should_load =
1485 target->TargetProperties::GetLoadScriptFromSymbolFile();
1486
1487 if (should_load == eLoadScriptFromSymFileFalse)
1488 return false;
1489
1490 Debugger &debugger = target->GetDebugger();
1491 const ScriptLanguage script_language = debugger.GetScriptLanguage();
1492 if (script_language != eScriptLanguageNone) {
1493
1494 PlatformSP platform_sp(target->GetPlatform());
1495
1496 if (!platform_sp) {
1497 error.SetErrorString("invalid Platform");
1498 return false;
1499 }
1500
1501 FileSpecList file_specs = platform_sp->LocateExecutableScriptingResources(
1502 target, *this, feedback_stream);
1503
1504 const uint32_t num_specs = file_specs.GetSize();
1505 if (num_specs) {
1506 ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter();
1507 if (script_interpreter) {
1508 for (uint32_t i = 0; i < num_specs; ++i) {
1509 FileSpec scripting_fspec(file_specs.GetFileSpecAtIndex(i));
1510 if (scripting_fspec &&
1511 FileSystem::Instance().Exists(scripting_fspec)) {
1512 if (should_load == eLoadScriptFromSymFileWarn) {
1513 if (feedback_stream)
1514 feedback_stream->Printf(
1515 "warning: '%s' contains a debug script. To run this script "
1516 "in "
1517 "this debug session:\n\n command script import "
1518 "\"%s\"\n\n"
1519 "To run all discovered debug scripts in this session:\n\n"
1520 " settings set target.load-script-from-symbol-file "
1521 "true\n",
1522 GetFileSpec().GetFileNameStrippingExtension().GetCString(),
1523 scripting_fspec.GetPath().c_str());
1524 return false;
1525 }
1526 StreamString scripting_stream;
1527 scripting_fspec.Dump(scripting_stream.AsRawOstream());
1528 const bool init_lldb_globals = false;
1529 bool did_load = script_interpreter->LoadScriptingModule(
1530 scripting_stream.GetData(), init_lldb_globals, error);
1531 if (!did_load)
1532 return false;
1533 }
1534 }
1535 } else {
1536 error.SetErrorString("invalid ScriptInterpreter");
1537 return false;
1538 }
1539 }
1540 }
1541 return true;
1542 }
1543
SetArchitecture(const ArchSpec & new_arch)1544 bool Module::SetArchitecture(const ArchSpec &new_arch) {
1545 if (!m_arch.IsValid()) {
1546 m_arch = new_arch;
1547 return true;
1548 }
1549 return m_arch.IsCompatibleMatch(new_arch);
1550 }
1551
SetLoadAddress(Target & target,lldb::addr_t value,bool value_is_offset,bool & changed)1552 bool Module::SetLoadAddress(Target &target, lldb::addr_t value,
1553 bool value_is_offset, bool &changed) {
1554 ObjectFile *object_file = GetObjectFile();
1555 if (object_file != nullptr) {
1556 changed = object_file->SetLoadAddress(target, value, value_is_offset);
1557 return true;
1558 } else {
1559 changed = false;
1560 }
1561 return false;
1562 }
1563
MatchesModuleSpec(const ModuleSpec & module_ref)1564 bool Module::MatchesModuleSpec(const ModuleSpec &module_ref) {
1565 const UUID &uuid = module_ref.GetUUID();
1566
1567 if (uuid.IsValid()) {
1568 // If the UUID matches, then nothing more needs to match...
1569 return (uuid == GetUUID());
1570 }
1571
1572 const FileSpec &file_spec = module_ref.GetFileSpec();
1573 if (!FileSpec::Match(file_spec, m_file) &&
1574 !FileSpec::Match(file_spec, m_platform_file))
1575 return false;
1576
1577 const FileSpec &platform_file_spec = module_ref.GetPlatformFileSpec();
1578 if (!FileSpec::Match(platform_file_spec, GetPlatformFileSpec()))
1579 return false;
1580
1581 const ArchSpec &arch = module_ref.GetArchitecture();
1582 if (arch.IsValid()) {
1583 if (!m_arch.IsCompatibleMatch(arch))
1584 return false;
1585 }
1586
1587 ConstString object_name = module_ref.GetObjectName();
1588 if (object_name) {
1589 if (object_name != GetObjectName())
1590 return false;
1591 }
1592 return true;
1593 }
1594
FindSourceFile(const FileSpec & orig_spec,FileSpec & new_spec) const1595 bool Module::FindSourceFile(const FileSpec &orig_spec,
1596 FileSpec &new_spec) const {
1597 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1598 return m_source_mappings.FindFile(orig_spec, new_spec);
1599 }
1600
RemapSourceFile(llvm::StringRef path,std::string & new_path) const1601 bool Module::RemapSourceFile(llvm::StringRef path,
1602 std::string &new_path) const {
1603 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1604 return m_source_mappings.RemapPath(path, new_path);
1605 }
1606
RegisterXcodeSDK(llvm::StringRef sdk_name,llvm::StringRef sysroot)1607 void Module::RegisterXcodeSDK(llvm::StringRef sdk_name, llvm::StringRef sysroot) {
1608 XcodeSDK sdk(sdk_name.str());
1609 ConstString sdk_path(HostInfo::GetXcodeSDKPath(sdk));
1610 if (!sdk_path)
1611 return;
1612 // If the SDK changed for a previously registered source path, update it.
1613 // This could happend with -fdebug-prefix-map, otherwise it's unlikely.
1614 ConstString sysroot_cs(sysroot);
1615 if (!m_source_mappings.Replace(sysroot_cs, sdk_path, true))
1616 // In the general case, however, append it to the list.
1617 m_source_mappings.Append(sysroot_cs, sdk_path, false);
1618 }
1619
MergeArchitecture(const ArchSpec & arch_spec)1620 bool Module::MergeArchitecture(const ArchSpec &arch_spec) {
1621 if (!arch_spec.IsValid())
1622 return false;
1623 LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT | LIBLLDB_LOG_MODULES),
1624 "module has arch %s, merging/replacing with arch %s",
1625 m_arch.GetTriple().getTriple().c_str(),
1626 arch_spec.GetTriple().getTriple().c_str());
1627 if (!m_arch.IsCompatibleMatch(arch_spec)) {
1628 // The new architecture is different, we just need to replace it.
1629 return SetArchitecture(arch_spec);
1630 }
1631
1632 // Merge bits from arch_spec into "merged_arch" and set our architecture.
1633 ArchSpec merged_arch(m_arch);
1634 merged_arch.MergeFrom(arch_spec);
1635 // SetArchitecture() is a no-op if m_arch is already valid.
1636 m_arch = ArchSpec();
1637 return SetArchitecture(merged_arch);
1638 }
1639
GetVersion()1640 llvm::VersionTuple Module::GetVersion() {
1641 if (ObjectFile *obj_file = GetObjectFile())
1642 return obj_file->GetVersion();
1643 return llvm::VersionTuple();
1644 }
1645
GetIsDynamicLinkEditor()1646 bool Module::GetIsDynamicLinkEditor() {
1647 ObjectFile *obj_file = GetObjectFile();
1648
1649 if (obj_file)
1650 return obj_file->GetIsDynamicLinkEditor();
1651
1652 return false;
1653 }
1654