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 <cassert>
63 #include <cinttypes>
64 #include <cstdarg>
65 #include <cstdint>
66 #include <cstring>
67 #include <map>
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() : m_file_has_changed(false), m_first_file_changed_log(false) {
261 std::lock_guard<std::recursive_mutex> guard(
262 GetAllocationModuleCollectionMutex());
263 GetModuleCollection().push_back(this);
264 }
265
~Module()266 Module::~Module() {
267 // Lock our module down while we tear everything down to make sure we don't
268 // get any access to the module while it is being destroyed
269 std::lock_guard<std::recursive_mutex> guard(m_mutex);
270 // Scope for locker below...
271 {
272 std::lock_guard<std::recursive_mutex> guard(
273 GetAllocationModuleCollectionMutex());
274 ModuleCollection &modules = GetModuleCollection();
275 ModuleCollection::iterator end = modules.end();
276 ModuleCollection::iterator pos = std::find(modules.begin(), end, this);
277 assert(pos != end);
278 modules.erase(pos);
279 }
280 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_OBJECT |
281 LIBLLDB_LOG_MODULES));
282 if (log != nullptr)
283 LLDB_LOGF(log, "%p Module::~Module((%s) '%s%s%s%s')",
284 static_cast<void *>(this), m_arch.GetArchitectureName(),
285 m_file.GetPath().c_str(), m_object_name.IsEmpty() ? "" : "(",
286 m_object_name.IsEmpty() ? "" : m_object_name.AsCString(""),
287 m_object_name.IsEmpty() ? "" : ")");
288 // Release any auto pointers before we start tearing down our member
289 // variables since the object file and symbol files might need to make
290 // function calls back into this module object. The ordering is important
291 // here because symbol files can require the module object file. So we tear
292 // down the symbol file first, then the object file.
293 m_sections_up.reset();
294 m_symfile_up.reset();
295 m_objfile_sp.reset();
296 }
297
GetMemoryObjectFile(const lldb::ProcessSP & process_sp,lldb::addr_t header_addr,Status & error,size_t size_to_read)298 ObjectFile *Module::GetMemoryObjectFile(const lldb::ProcessSP &process_sp,
299 lldb::addr_t header_addr, Status &error,
300 size_t size_to_read) {
301 if (m_objfile_sp) {
302 error.SetErrorString("object file already exists");
303 } else {
304 std::lock_guard<std::recursive_mutex> guard(m_mutex);
305 if (process_sp) {
306 m_did_load_objfile = true;
307 auto data_up = std::make_unique<DataBufferHeap>(size_to_read, 0);
308 Status readmem_error;
309 const size_t bytes_read =
310 process_sp->ReadMemory(header_addr, data_up->GetBytes(),
311 data_up->GetByteSize(), readmem_error);
312 if (bytes_read < size_to_read)
313 data_up->SetByteSize(bytes_read);
314 if (data_up->GetByteSize() > 0) {
315 DataBufferSP data_sp(data_up.release());
316 m_objfile_sp = ObjectFile::FindPlugin(shared_from_this(), process_sp,
317 header_addr, data_sp);
318 if (m_objfile_sp) {
319 StreamString s;
320 s.Printf("0x%16.16" PRIx64, header_addr);
321 m_object_name.SetString(s.GetString());
322
323 // Once we get the object file, update our module with the object
324 // file's architecture since it might differ in vendor/os if some
325 // parts were unknown.
326 m_arch = m_objfile_sp->GetArchitecture();
327
328 // Augment the arch with the target's information in case
329 // we are unable to extract the os/environment from memory.
330 m_arch.MergeFrom(process_sp->GetTarget().GetArchitecture());
331 } else {
332 error.SetErrorString("unable to find suitable object file plug-in");
333 }
334 } else {
335 error.SetErrorStringWithFormat("unable to read header from memory: %s",
336 readmem_error.AsCString());
337 }
338 } else {
339 error.SetErrorString("invalid process");
340 }
341 }
342 return m_objfile_sp.get();
343 }
344
GetUUID()345 const lldb_private::UUID &Module::GetUUID() {
346 if (!m_did_set_uuid.load()) {
347 std::lock_guard<std::recursive_mutex> guard(m_mutex);
348 if (!m_did_set_uuid.load()) {
349 ObjectFile *obj_file = GetObjectFile();
350
351 if (obj_file != nullptr) {
352 m_uuid = obj_file->GetUUID();
353 m_did_set_uuid = true;
354 }
355 }
356 }
357 return m_uuid;
358 }
359
SetUUID(const lldb_private::UUID & uuid)360 void Module::SetUUID(const lldb_private::UUID &uuid) {
361 std::lock_guard<std::recursive_mutex> guard(m_mutex);
362 if (!m_did_set_uuid) {
363 m_uuid = uuid;
364 m_did_set_uuid = true;
365 } else {
366 lldbassert(0 && "Attempting to overwrite the existing module UUID");
367 }
368 }
369
370 llvm::Expected<TypeSystem &>
GetTypeSystemForLanguage(LanguageType language)371 Module::GetTypeSystemForLanguage(LanguageType language) {
372 return m_type_system_map.GetTypeSystemForLanguage(language, this, true);
373 }
374
ParseAllDebugSymbols()375 void Module::ParseAllDebugSymbols() {
376 std::lock_guard<std::recursive_mutex> guard(m_mutex);
377 size_t num_comp_units = GetNumCompileUnits();
378 if (num_comp_units == 0)
379 return;
380
381 SymbolFile *symbols = GetSymbolFile();
382
383 for (size_t cu_idx = 0; cu_idx < num_comp_units; cu_idx++) {
384 SymbolContext sc;
385 sc.module_sp = shared_from_this();
386 sc.comp_unit = symbols->GetCompileUnitAtIndex(cu_idx).get();
387 if (!sc.comp_unit)
388 continue;
389
390 symbols->ParseVariablesForContext(sc);
391
392 symbols->ParseFunctions(*sc.comp_unit);
393
394 sc.comp_unit->ForeachFunction([&sc, &symbols](const FunctionSP &f) {
395 symbols->ParseBlocksRecursive(*f);
396
397 // Parse the variables for this function and all its blocks
398 sc.function = f.get();
399 symbols->ParseVariablesForContext(sc);
400 return false;
401 });
402
403 // Parse all types for this compile unit
404 symbols->ParseTypes(*sc.comp_unit);
405 }
406 }
407
CalculateSymbolContext(SymbolContext * sc)408 void Module::CalculateSymbolContext(SymbolContext *sc) {
409 sc->module_sp = shared_from_this();
410 }
411
CalculateSymbolContextModule()412 ModuleSP Module::CalculateSymbolContextModule() { return shared_from_this(); }
413
DumpSymbolContext(Stream * s)414 void Module::DumpSymbolContext(Stream *s) {
415 s->Printf(", Module{%p}", static_cast<void *>(this));
416 }
417
GetNumCompileUnits()418 size_t Module::GetNumCompileUnits() {
419 std::lock_guard<std::recursive_mutex> guard(m_mutex);
420 LLDB_SCOPED_TIMERF("Module::GetNumCompileUnits (module = %p)",
421 static_cast<void *>(this));
422 if (SymbolFile *symbols = GetSymbolFile())
423 return symbols->GetNumCompileUnits();
424 return 0;
425 }
426
GetCompileUnitAtIndex(size_t index)427 CompUnitSP Module::GetCompileUnitAtIndex(size_t index) {
428 std::lock_guard<std::recursive_mutex> guard(m_mutex);
429 size_t num_comp_units = GetNumCompileUnits();
430 CompUnitSP cu_sp;
431
432 if (index < num_comp_units) {
433 if (SymbolFile *symbols = GetSymbolFile())
434 cu_sp = symbols->GetCompileUnitAtIndex(index);
435 }
436 return cu_sp;
437 }
438
ResolveFileAddress(lldb::addr_t vm_addr,Address & so_addr)439 bool Module::ResolveFileAddress(lldb::addr_t vm_addr, Address &so_addr) {
440 std::lock_guard<std::recursive_mutex> guard(m_mutex);
441 SectionList *section_list = GetSectionList();
442 if (section_list)
443 return so_addr.ResolveAddressUsingFileSections(vm_addr, section_list);
444 return false;
445 }
446
ResolveSymbolContextForAddress(const Address & so_addr,lldb::SymbolContextItem resolve_scope,SymbolContext & sc,bool resolve_tail_call_address)447 uint32_t Module::ResolveSymbolContextForAddress(
448 const Address &so_addr, lldb::SymbolContextItem resolve_scope,
449 SymbolContext &sc, bool resolve_tail_call_address) {
450 std::lock_guard<std::recursive_mutex> guard(m_mutex);
451 uint32_t resolved_flags = 0;
452
453 // Clear the result symbol context in case we don't find anything, but don't
454 // clear the target
455 sc.Clear(false);
456
457 // Get the section from the section/offset address.
458 SectionSP section_sp(so_addr.GetSection());
459
460 // Make sure the section matches this module before we try and match anything
461 if (section_sp && section_sp->GetModule().get() == this) {
462 // If the section offset based address resolved itself, then this is the
463 // right module.
464 sc.module_sp = shared_from_this();
465 resolved_flags |= eSymbolContextModule;
466
467 SymbolFile *symfile = GetSymbolFile();
468 if (!symfile)
469 return resolved_flags;
470
471 // Resolve the compile unit, function, block, line table or line entry if
472 // requested.
473 if (resolve_scope & eSymbolContextCompUnit ||
474 resolve_scope & eSymbolContextFunction ||
475 resolve_scope & eSymbolContextBlock ||
476 resolve_scope & eSymbolContextLineEntry ||
477 resolve_scope & eSymbolContextVariable) {
478 resolved_flags |=
479 symfile->ResolveSymbolContext(so_addr, resolve_scope, sc);
480 }
481
482 // Resolve the symbol if requested, but don't re-look it up if we've
483 // already found it.
484 if (resolve_scope & eSymbolContextSymbol &&
485 !(resolved_flags & eSymbolContextSymbol)) {
486 Symtab *symtab = symfile->GetSymtab();
487 if (symtab && so_addr.IsSectionOffset()) {
488 Symbol *matching_symbol = nullptr;
489
490 symtab->ForEachSymbolContainingFileAddress(
491 so_addr.GetFileAddress(),
492 [&matching_symbol](Symbol *symbol) -> bool {
493 if (symbol->GetType() != eSymbolTypeInvalid) {
494 matching_symbol = symbol;
495 return false; // Stop iterating
496 }
497 return true; // Keep iterating
498 });
499 sc.symbol = matching_symbol;
500 if (!sc.symbol && resolve_scope & eSymbolContextFunction &&
501 !(resolved_flags & eSymbolContextFunction)) {
502 bool verify_unique = false; // No need to check again since
503 // ResolveSymbolContext failed to find a
504 // symbol at this address.
505 if (ObjectFile *obj_file = sc.module_sp->GetObjectFile())
506 sc.symbol =
507 obj_file->ResolveSymbolForAddress(so_addr, verify_unique);
508 }
509
510 if (sc.symbol) {
511 if (sc.symbol->IsSynthetic()) {
512 // We have a synthetic symbol so lets check if the object file from
513 // the symbol file in the symbol vendor is different than the
514 // object file for the module, and if so search its symbol table to
515 // see if we can come up with a better symbol. For example dSYM
516 // files on MacOSX have an unstripped symbol table inside of them.
517 ObjectFile *symtab_objfile = symtab->GetObjectFile();
518 if (symtab_objfile && symtab_objfile->IsStripped()) {
519 ObjectFile *symfile_objfile = symfile->GetObjectFile();
520 if (symfile_objfile != symtab_objfile) {
521 Symtab *symfile_symtab = symfile_objfile->GetSymtab();
522 if (symfile_symtab) {
523 Symbol *symbol =
524 symfile_symtab->FindSymbolContainingFileAddress(
525 so_addr.GetFileAddress());
526 if (symbol && !symbol->IsSynthetic()) {
527 sc.symbol = symbol;
528 }
529 }
530 }
531 }
532 }
533 resolved_flags |= eSymbolContextSymbol;
534 }
535 }
536 }
537
538 // For function symbols, so_addr may be off by one. This is a convention
539 // consistent with FDE row indices in eh_frame sections, but requires extra
540 // logic here to permit symbol lookup for disassembly and unwind.
541 if (resolve_scope & eSymbolContextSymbol &&
542 !(resolved_flags & eSymbolContextSymbol) && resolve_tail_call_address &&
543 so_addr.IsSectionOffset()) {
544 Address previous_addr = so_addr;
545 previous_addr.Slide(-1);
546
547 bool do_resolve_tail_call_address = false; // prevent recursion
548 const uint32_t flags = ResolveSymbolContextForAddress(
549 previous_addr, resolve_scope, sc, do_resolve_tail_call_address);
550 if (flags & eSymbolContextSymbol) {
551 AddressRange addr_range;
552 if (sc.GetAddressRange(eSymbolContextFunction | eSymbolContextSymbol, 0,
553 false, addr_range)) {
554 if (addr_range.GetBaseAddress().GetSection() ==
555 so_addr.GetSection()) {
556 // If the requested address is one past the address range of a
557 // function (i.e. a tail call), or the decremented address is the
558 // start of a function (i.e. some forms of trampoline), indicate
559 // that the symbol has been resolved.
560 if (so_addr.GetOffset() ==
561 addr_range.GetBaseAddress().GetOffset() ||
562 so_addr.GetOffset() ==
563 addr_range.GetBaseAddress().GetOffset() +
564 addr_range.GetByteSize()) {
565 resolved_flags |= flags;
566 }
567 } else {
568 sc.symbol =
569 nullptr; // Don't trust the symbol if the sections didn't match.
570 }
571 }
572 }
573 }
574 }
575 return resolved_flags;
576 }
577
ResolveSymbolContextForFilePath(const char * file_path,uint32_t line,bool check_inlines,lldb::SymbolContextItem resolve_scope,SymbolContextList & sc_list)578 uint32_t Module::ResolveSymbolContextForFilePath(
579 const char *file_path, uint32_t line, bool check_inlines,
580 lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
581 FileSpec file_spec(file_path);
582 return ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines,
583 resolve_scope, sc_list);
584 }
585
ResolveSymbolContextsForFileSpec(const FileSpec & file_spec,uint32_t line,bool check_inlines,lldb::SymbolContextItem resolve_scope,SymbolContextList & sc_list)586 uint32_t Module::ResolveSymbolContextsForFileSpec(
587 const FileSpec &file_spec, uint32_t line, bool check_inlines,
588 lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
589 std::lock_guard<std::recursive_mutex> guard(m_mutex);
590 LLDB_SCOPED_TIMERF("Module::ResolveSymbolContextForFilePath (%s:%u, "
591 "check_inlines = %s, resolve_scope = 0x%8.8x)",
592 file_spec.GetPath().c_str(), line,
593 check_inlines ? "yes" : "no", resolve_scope);
594
595 const uint32_t initial_count = sc_list.GetSize();
596
597 if (SymbolFile *symbols = GetSymbolFile()) {
598 // TODO: Handle SourceLocationSpec column information
599 SourceLocationSpec location_spec(file_spec, line, /*column=*/llvm::None,
600 check_inlines, /*exact_match=*/false);
601
602 symbols->ResolveSymbolContext(location_spec, resolve_scope, sc_list);
603 }
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,const ModuleFunctionSearchOptions & options,SymbolContextList & sc_list)796 void Module::FindFunctions(ConstString name,
797 const CompilerDeclContext &parent_decl_ctx,
798 FunctionNameType name_type_mask,
799 const ModuleFunctionSearchOptions &options,
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(),
812 options.include_inlines, sc_list);
813
814 // Now check our symbol table for symbols that are code symbols if
815 // requested
816 if (options.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 options.include_inlines, sc_list);
832
833 // Now check our symbol table for symbols that are code symbols if
834 // requested
835 if (options.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,const ModuleFunctionSearchOptions & options,SymbolContextList & sc_list)844 void Module::FindFunctions(const RegularExpression ®ex,
845 const ModuleFunctionSearchOptions &options,
846 SymbolContextList &sc_list) {
847 const size_t start_size = sc_list.GetSize();
848
849 if (SymbolFile *symbols = GetSymbolFile()) {
850 symbols->FindFunctions(regex, options.include_inlines, sc_list);
851
852 // Now check our symbol table for symbols that are code symbols if
853 // requested
854 if (options.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
921 // TODO: Handle SourceLocationSpec column information
922 SourceLocationSpec location_spec(file, line, /*column=*/llvm::None,
923 /*check_inlines=*/true,
924 /*exact_match=*/false);
925 AddressResolverFileLine resolver(location_spec);
926 resolver.ResolveAddress(filter);
927
928 for (size_t n = 0; n < resolver.GetNumberOfAddresses(); n++) {
929 Address addr = resolver.GetAddressRangeAtIndex(n).GetBaseAddress();
930 Function *f = addr.CalculateSymbolContextFunction();
931 if (f && f == function)
932 output_local.push_back(addr);
933 else
934 output_extern.push_back(addr);
935 }
936 }
937
FindTypes_Impl(ConstString name,const CompilerDeclContext & parent_decl_ctx,size_t max_matches,llvm::DenseSet<lldb_private::SymbolFile * > & searched_symbol_files,TypeMap & types)938 void Module::FindTypes_Impl(
939 ConstString name, const CompilerDeclContext &parent_decl_ctx,
940 size_t max_matches,
941 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
942 TypeMap &types) {
943 LLDB_SCOPED_TIMER();
944 if (SymbolFile *symbols = GetSymbolFile())
945 symbols->FindTypes(name, parent_decl_ctx, max_matches,
946 searched_symbol_files, types);
947 }
948
FindTypesInNamespace(ConstString type_name,const CompilerDeclContext & parent_decl_ctx,size_t max_matches,TypeList & type_list)949 void Module::FindTypesInNamespace(ConstString type_name,
950 const CompilerDeclContext &parent_decl_ctx,
951 size_t max_matches, TypeList &type_list) {
952 TypeMap types_map;
953 llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
954 FindTypes_Impl(type_name, parent_decl_ctx, max_matches, searched_symbol_files,
955 types_map);
956 if (types_map.GetSize()) {
957 SymbolContext sc;
958 sc.module_sp = shared_from_this();
959 sc.SortTypeList(types_map, type_list);
960 }
961 }
962
FindFirstType(const SymbolContext & sc,ConstString name,bool exact_match)963 lldb::TypeSP Module::FindFirstType(const SymbolContext &sc,
964 ConstString name, bool exact_match) {
965 TypeList type_list;
966 llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
967 FindTypes(name, exact_match, 1, searched_symbol_files, type_list);
968 if (type_list.GetSize())
969 return type_list.GetTypeAtIndex(0);
970 return TypeSP();
971 }
972
FindTypes(ConstString name,bool exact_match,size_t max_matches,llvm::DenseSet<lldb_private::SymbolFile * > & searched_symbol_files,TypeList & types)973 void Module::FindTypes(
974 ConstString name, bool exact_match, size_t max_matches,
975 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
976 TypeList &types) {
977 const char *type_name_cstr = name.GetCString();
978 llvm::StringRef type_scope;
979 llvm::StringRef type_basename;
980 TypeClass type_class = eTypeClassAny;
981 TypeMap typesmap;
982
983 if (Type::GetTypeScopeAndBasename(type_name_cstr, type_scope, type_basename,
984 type_class)) {
985 // Check if "name" starts with "::" which means the qualified type starts
986 // from the root namespace and implies and exact match. The typenames we
987 // get back from clang do not start with "::" so we need to strip this off
988 // in order to get the qualified names to match
989 exact_match = type_scope.consume_front("::");
990
991 ConstString type_basename_const_str(type_basename);
992 FindTypes_Impl(type_basename_const_str, CompilerDeclContext(), max_matches,
993 searched_symbol_files, typesmap);
994 if (typesmap.GetSize())
995 typesmap.RemoveMismatchedTypes(std::string(type_scope),
996 std::string(type_basename), type_class,
997 exact_match);
998 } else {
999 // The type is not in a namespace/class scope, just search for it by
1000 // basename
1001 if (type_class != eTypeClassAny && !type_basename.empty()) {
1002 // The "type_name_cstr" will have been modified if we have a valid type
1003 // class prefix (like "struct", "class", "union", "typedef" etc).
1004 FindTypes_Impl(ConstString(type_basename), CompilerDeclContext(),
1005 UINT_MAX, searched_symbol_files, typesmap);
1006 typesmap.RemoveMismatchedTypes(std::string(type_scope),
1007 std::string(type_basename), type_class,
1008 exact_match);
1009 } else {
1010 FindTypes_Impl(name, CompilerDeclContext(), UINT_MAX,
1011 searched_symbol_files, typesmap);
1012 if (exact_match) {
1013 std::string name_str(name.AsCString(""));
1014 typesmap.RemoveMismatchedTypes(std::string(type_scope), name_str,
1015 type_class, exact_match);
1016 }
1017 }
1018 }
1019 if (typesmap.GetSize()) {
1020 SymbolContext sc;
1021 sc.module_sp = shared_from_this();
1022 sc.SortTypeList(typesmap, types);
1023 }
1024 }
1025
FindTypes(llvm::ArrayRef<CompilerContext> pattern,LanguageSet languages,llvm::DenseSet<lldb_private::SymbolFile * > & searched_symbol_files,TypeMap & types)1026 void Module::FindTypes(
1027 llvm::ArrayRef<CompilerContext> pattern, LanguageSet languages,
1028 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
1029 TypeMap &types) {
1030 LLDB_SCOPED_TIMER();
1031 if (SymbolFile *symbols = GetSymbolFile())
1032 symbols->FindTypes(pattern, languages, searched_symbol_files, types);
1033 }
1034
GetSymbolFile(bool can_create,Stream * feedback_strm)1035 SymbolFile *Module::GetSymbolFile(bool can_create, Stream *feedback_strm) {
1036 if (!m_did_load_symfile.load()) {
1037 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1038 if (!m_did_load_symfile.load() && can_create) {
1039 ObjectFile *obj_file = GetObjectFile();
1040 if (obj_file != nullptr) {
1041 LLDB_SCOPED_TIMER();
1042 m_symfile_up.reset(
1043 SymbolVendor::FindPlugin(shared_from_this(), feedback_strm));
1044 m_did_load_symfile = true;
1045 }
1046 }
1047 }
1048 return m_symfile_up ? m_symfile_up->GetSymbolFile() : nullptr;
1049 }
1050
GetSymtab()1051 Symtab *Module::GetSymtab() {
1052 if (SymbolFile *symbols = GetSymbolFile())
1053 return symbols->GetSymtab();
1054 return nullptr;
1055 }
1056
SetFileSpecAndObjectName(const FileSpec & file,ConstString object_name)1057 void Module::SetFileSpecAndObjectName(const FileSpec &file,
1058 ConstString object_name) {
1059 // Container objects whose paths do not specify a file directly can call this
1060 // function to correct the file and object names.
1061 m_file = file;
1062 m_mod_time = FileSystem::Instance().GetModificationTime(file);
1063 m_object_name = object_name;
1064 }
1065
GetArchitecture() const1066 const ArchSpec &Module::GetArchitecture() const { return m_arch; }
1067
GetSpecificationDescription() const1068 std::string Module::GetSpecificationDescription() const {
1069 std::string spec(GetFileSpec().GetPath());
1070 if (m_object_name) {
1071 spec += '(';
1072 spec += m_object_name.GetCString();
1073 spec += ')';
1074 }
1075 return spec;
1076 }
1077
GetDescription(llvm::raw_ostream & s,lldb::DescriptionLevel level)1078 void Module::GetDescription(llvm::raw_ostream &s,
1079 lldb::DescriptionLevel level) {
1080 if (level >= eDescriptionLevelFull) {
1081 if (m_arch.IsValid())
1082 s << llvm::formatv("({0}) ", m_arch.GetArchitectureName());
1083 }
1084
1085 if (level == eDescriptionLevelBrief) {
1086 const char *filename = m_file.GetFilename().GetCString();
1087 if (filename)
1088 s << filename;
1089 } else {
1090 char path[PATH_MAX];
1091 if (m_file.GetPath(path, sizeof(path)))
1092 s << path;
1093 }
1094
1095 const char *object_name = m_object_name.GetCString();
1096 if (object_name)
1097 s << llvm::formatv("({0})", object_name);
1098 }
1099
ReportError(const char * format,...)1100 void Module::ReportError(const char *format, ...) {
1101 if (format && format[0]) {
1102 StreamString strm;
1103 strm.PutCString("error: ");
1104 GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelBrief);
1105 strm.PutChar(' ');
1106 va_list args;
1107 va_start(args, format);
1108 strm.PrintfVarArg(format, args);
1109 va_end(args);
1110
1111 const int format_len = strlen(format);
1112 if (format_len > 0) {
1113 const char last_char = format[format_len - 1];
1114 if (last_char != '\n' && last_char != '\r')
1115 strm.EOL();
1116 }
1117 Host::SystemLog(Host::eSystemLogError, "%s", strm.GetData());
1118 }
1119 }
1120
FileHasChanged() const1121 bool Module::FileHasChanged() const {
1122 // We have provided the DataBuffer for this module to avoid accessing the
1123 // filesystem. We never want to reload those files.
1124 if (m_data_sp)
1125 return false;
1126 if (!m_file_has_changed)
1127 m_file_has_changed =
1128 (FileSystem::Instance().GetModificationTime(m_file) != m_mod_time);
1129 return m_file_has_changed;
1130 }
1131
ReportErrorIfModifyDetected(const char * format,...)1132 void Module::ReportErrorIfModifyDetected(const char *format, ...) {
1133 if (!m_first_file_changed_log) {
1134 if (FileHasChanged()) {
1135 m_first_file_changed_log = true;
1136 if (format) {
1137 StreamString strm;
1138 strm.PutCString("error: the object file ");
1139 GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelFull);
1140 strm.PutCString(" has been modified\n");
1141
1142 va_list args;
1143 va_start(args, format);
1144 strm.PrintfVarArg(format, args);
1145 va_end(args);
1146
1147 const int format_len = strlen(format);
1148 if (format_len > 0) {
1149 const char last_char = format[format_len - 1];
1150 if (last_char != '\n' && last_char != '\r')
1151 strm.EOL();
1152 }
1153 strm.PutCString("The debug session should be aborted as the original "
1154 "debug information has been overwritten.\n");
1155 Host::SystemLog(Host::eSystemLogError, "%s", strm.GetData());
1156 }
1157 }
1158 }
1159 }
1160
ReportWarning(const char * format,...)1161 void Module::ReportWarning(const char *format, ...) {
1162 if (format && format[0]) {
1163 StreamString strm;
1164 strm.PutCString("warning: ");
1165 GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelFull);
1166 strm.PutChar(' ');
1167
1168 va_list args;
1169 va_start(args, format);
1170 strm.PrintfVarArg(format, args);
1171 va_end(args);
1172
1173 const int format_len = strlen(format);
1174 if (format_len > 0) {
1175 const char last_char = format[format_len - 1];
1176 if (last_char != '\n' && last_char != '\r')
1177 strm.EOL();
1178 }
1179 Host::SystemLog(Host::eSystemLogWarning, "%s", strm.GetData());
1180 }
1181 }
1182
LogMessage(Log * log,const char * format,...)1183 void Module::LogMessage(Log *log, const char *format, ...) {
1184 if (log != nullptr) {
1185 StreamString log_message;
1186 GetDescription(log_message.AsRawOstream(), lldb::eDescriptionLevelFull);
1187 log_message.PutCString(": ");
1188 va_list args;
1189 va_start(args, format);
1190 log_message.PrintfVarArg(format, args);
1191 va_end(args);
1192 log->PutCString(log_message.GetData());
1193 }
1194 }
1195
LogMessageVerboseBacktrace(Log * log,const char * format,...)1196 void Module::LogMessageVerboseBacktrace(Log *log, const char *format, ...) {
1197 if (log != nullptr) {
1198 StreamString log_message;
1199 GetDescription(log_message.AsRawOstream(), lldb::eDescriptionLevelFull);
1200 log_message.PutCString(": ");
1201 va_list args;
1202 va_start(args, format);
1203 log_message.PrintfVarArg(format, args);
1204 va_end(args);
1205 if (log->GetVerbose()) {
1206 std::string back_trace;
1207 llvm::raw_string_ostream stream(back_trace);
1208 llvm::sys::PrintStackTrace(stream);
1209 log_message.PutCString(back_trace);
1210 }
1211 log->PutCString(log_message.GetData());
1212 }
1213 }
1214
Dump(Stream * s)1215 void Module::Dump(Stream *s) {
1216 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1217 // s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
1218 s->Indent();
1219 s->Printf("Module %s%s%s%s\n", m_file.GetPath().c_str(),
1220 m_object_name ? "(" : "",
1221 m_object_name ? m_object_name.GetCString() : "",
1222 m_object_name ? ")" : "");
1223
1224 s->IndentMore();
1225
1226 ObjectFile *objfile = GetObjectFile();
1227 if (objfile)
1228 objfile->Dump(s);
1229
1230 if (SymbolFile *symbols = GetSymbolFile())
1231 symbols->Dump(*s);
1232
1233 s->IndentLess();
1234 }
1235
GetObjectName() const1236 ConstString Module::GetObjectName() const { return m_object_name; }
1237
GetObjectFile()1238 ObjectFile *Module::GetObjectFile() {
1239 if (!m_did_load_objfile.load()) {
1240 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1241 if (!m_did_load_objfile.load()) {
1242 LLDB_SCOPED_TIMERF("Module::GetObjectFile () module = %s",
1243 GetFileSpec().GetFilename().AsCString(""));
1244 lldb::offset_t data_offset = 0;
1245 lldb::offset_t file_size = 0;
1246
1247 if (m_data_sp)
1248 file_size = m_data_sp->GetByteSize();
1249 else if (m_file)
1250 file_size = FileSystem::Instance().GetByteSize(m_file);
1251
1252 if (file_size > m_object_offset) {
1253 m_did_load_objfile = true;
1254 // FindPlugin will modify its data_sp argument. Do not let it
1255 // modify our m_data_sp member.
1256 auto data_sp = m_data_sp;
1257 m_objfile_sp = ObjectFile::FindPlugin(
1258 shared_from_this(), &m_file, m_object_offset,
1259 file_size - m_object_offset, data_sp, data_offset);
1260 if (m_objfile_sp) {
1261 // Once we get the object file, update our module with the object
1262 // file's architecture since it might differ in vendor/os if some
1263 // parts were unknown. But since the matching arch might already be
1264 // more specific than the generic COFF architecture, only merge in
1265 // those values that overwrite unspecified unknown values.
1266 m_arch.MergeFrom(m_objfile_sp->GetArchitecture());
1267 } else {
1268 ReportError("failed to load objfile for %s",
1269 GetFileSpec().GetPath().c_str());
1270 }
1271 }
1272 }
1273 }
1274 return m_objfile_sp.get();
1275 }
1276
GetSectionList()1277 SectionList *Module::GetSectionList() {
1278 // Populate m_sections_up with sections from objfile.
1279 if (!m_sections_up) {
1280 ObjectFile *obj_file = GetObjectFile();
1281 if (obj_file != nullptr)
1282 obj_file->CreateSections(*GetUnifiedSectionList());
1283 }
1284 return m_sections_up.get();
1285 }
1286
SectionFileAddressesChanged()1287 void Module::SectionFileAddressesChanged() {
1288 ObjectFile *obj_file = GetObjectFile();
1289 if (obj_file)
1290 obj_file->SectionFileAddressesChanged();
1291 if (SymbolFile *symbols = GetSymbolFile())
1292 symbols->SectionFileAddressesChanged();
1293 }
1294
GetUnwindTable()1295 UnwindTable &Module::GetUnwindTable() {
1296 if (!m_unwind_table)
1297 m_unwind_table.emplace(*this);
1298 return *m_unwind_table;
1299 }
1300
GetUnifiedSectionList()1301 SectionList *Module::GetUnifiedSectionList() {
1302 if (!m_sections_up)
1303 m_sections_up = std::make_unique<SectionList>();
1304 return m_sections_up.get();
1305 }
1306
FindFirstSymbolWithNameAndType(ConstString name,SymbolType symbol_type)1307 const Symbol *Module::FindFirstSymbolWithNameAndType(ConstString name,
1308 SymbolType symbol_type) {
1309 LLDB_SCOPED_TIMERF(
1310 "Module::FindFirstSymbolWithNameAndType (name = %s, type = %i)",
1311 name.AsCString(), symbol_type);
1312 if (Symtab *symtab = GetSymtab())
1313 return symtab->FindFirstSymbolWithNameAndType(
1314 name, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny);
1315 return nullptr;
1316 }
SymbolIndicesToSymbolContextList(Symtab * symtab,std::vector<uint32_t> & symbol_indexes,SymbolContextList & sc_list)1317 void Module::SymbolIndicesToSymbolContextList(
1318 Symtab *symtab, std::vector<uint32_t> &symbol_indexes,
1319 SymbolContextList &sc_list) {
1320 // No need to protect this call using m_mutex all other method calls are
1321 // already thread safe.
1322
1323 size_t num_indices = symbol_indexes.size();
1324 if (num_indices > 0) {
1325 SymbolContext sc;
1326 CalculateSymbolContext(&sc);
1327 for (size_t i = 0; i < num_indices; i++) {
1328 sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]);
1329 if (sc.symbol)
1330 sc_list.Append(sc);
1331 }
1332 }
1333 }
1334
FindFunctionSymbols(ConstString name,uint32_t name_type_mask,SymbolContextList & sc_list)1335 void Module::FindFunctionSymbols(ConstString name,
1336 uint32_t name_type_mask,
1337 SymbolContextList &sc_list) {
1338 LLDB_SCOPED_TIMERF("Module::FindSymbolsFunctions (name = %s, mask = 0x%8.8x)",
1339 name.AsCString(), name_type_mask);
1340 if (Symtab *symtab = GetSymtab())
1341 symtab->FindFunctionSymbols(name, name_type_mask, sc_list);
1342 }
1343
FindSymbolsWithNameAndType(ConstString name,SymbolType symbol_type,SymbolContextList & sc_list)1344 void Module::FindSymbolsWithNameAndType(ConstString name,
1345 SymbolType symbol_type,
1346 SymbolContextList &sc_list) {
1347 // No need to protect this call using m_mutex all other method calls are
1348 // already thread safe.
1349 LLDB_SCOPED_TIMERF(
1350 "Module::FindSymbolsWithNameAndType (name = %s, type = %i)",
1351 name.AsCString(), symbol_type);
1352 if (Symtab *symtab = GetSymtab()) {
1353 std::vector<uint32_t> symbol_indexes;
1354 symtab->FindAllSymbolsWithNameAndType(name, symbol_type, symbol_indexes);
1355 SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list);
1356 }
1357 }
1358
FindSymbolsMatchingRegExAndType(const RegularExpression & regex,SymbolType symbol_type,SymbolContextList & sc_list)1359 void Module::FindSymbolsMatchingRegExAndType(const RegularExpression ®ex,
1360 SymbolType symbol_type,
1361 SymbolContextList &sc_list) {
1362 // No need to protect this call using m_mutex all other method calls are
1363 // already thread safe.
1364 LLDB_SCOPED_TIMERF(
1365 "Module::FindSymbolsMatchingRegExAndType (regex = %s, type = %i)",
1366 regex.GetText().str().c_str(), symbol_type);
1367 if (Symtab *symtab = GetSymtab()) {
1368 std::vector<uint32_t> symbol_indexes;
1369 symtab->FindAllSymbolsMatchingRexExAndType(
1370 regex, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny,
1371 symbol_indexes);
1372 SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list);
1373 }
1374 }
1375
PreloadSymbols()1376 void Module::PreloadSymbols() {
1377 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1378 SymbolFile *sym_file = GetSymbolFile();
1379 if (!sym_file)
1380 return;
1381
1382 // Prime the symbol file first, since it adds symbols to the symbol table.
1383 sym_file->PreloadSymbols();
1384
1385 // Now we can prime the symbol table.
1386 if (Symtab *symtab = sym_file->GetSymtab())
1387 symtab->PreloadSymbols();
1388 }
1389
SetSymbolFileFileSpec(const FileSpec & file)1390 void Module::SetSymbolFileFileSpec(const FileSpec &file) {
1391 if (!FileSystem::Instance().Exists(file))
1392 return;
1393 if (m_symfile_up) {
1394 // Remove any sections in the unified section list that come from the
1395 // current symbol vendor.
1396 SectionList *section_list = GetSectionList();
1397 SymbolFile *symbol_file = GetSymbolFile();
1398 if (section_list && symbol_file) {
1399 ObjectFile *obj_file = symbol_file->GetObjectFile();
1400 // Make sure we have an object file and that the symbol vendor's objfile
1401 // isn't the same as the module's objfile before we remove any sections
1402 // for it...
1403 if (obj_file) {
1404 // Check to make sure we aren't trying to specify the file we already
1405 // have
1406 if (obj_file->GetFileSpec() == file) {
1407 // We are being told to add the exact same file that we already have
1408 // we don't have to do anything.
1409 return;
1410 }
1411
1412 // Cleare the current symtab as we are going to replace it with a new
1413 // one
1414 obj_file->ClearSymtab();
1415
1416 // Clear the unwind table too, as that may also be affected by the
1417 // symbol file information.
1418 m_unwind_table.reset();
1419
1420 // The symbol file might be a directory bundle ("/tmp/a.out.dSYM")
1421 // instead of a full path to the symbol file within the bundle
1422 // ("/tmp/a.out.dSYM/Contents/Resources/DWARF/a.out"). So we need to
1423 // check this
1424
1425 if (FileSystem::Instance().IsDirectory(file)) {
1426 std::string new_path(file.GetPath());
1427 std::string old_path(obj_file->GetFileSpec().GetPath());
1428 if (llvm::StringRef(old_path).startswith(new_path)) {
1429 // We specified the same bundle as the symbol file that we already
1430 // have
1431 return;
1432 }
1433 }
1434
1435 if (obj_file != m_objfile_sp.get()) {
1436 size_t num_sections = section_list->GetNumSections(0);
1437 for (size_t idx = num_sections; idx > 0; --idx) {
1438 lldb::SectionSP section_sp(
1439 section_list->GetSectionAtIndex(idx - 1));
1440 if (section_sp->GetObjectFile() == obj_file) {
1441 section_list->DeleteSection(idx - 1);
1442 }
1443 }
1444 }
1445 }
1446 }
1447 // Keep all old symbol files around in case there are any lingering type
1448 // references in any SBValue objects that might have been handed out.
1449 m_old_symfiles.push_back(std::move(m_symfile_up));
1450 }
1451 m_symfile_spec = file;
1452 m_symfile_up.reset();
1453 m_did_load_symfile = false;
1454 }
1455
IsExecutable()1456 bool Module::IsExecutable() {
1457 if (GetObjectFile() == nullptr)
1458 return false;
1459 else
1460 return GetObjectFile()->IsExecutable();
1461 }
1462
IsLoadedInTarget(Target * target)1463 bool Module::IsLoadedInTarget(Target *target) {
1464 ObjectFile *obj_file = GetObjectFile();
1465 if (obj_file) {
1466 SectionList *sections = GetSectionList();
1467 if (sections != nullptr) {
1468 size_t num_sections = sections->GetSize();
1469 for (size_t sect_idx = 0; sect_idx < num_sections; sect_idx++) {
1470 SectionSP section_sp = sections->GetSectionAtIndex(sect_idx);
1471 if (section_sp->GetLoadBaseAddress(target) != LLDB_INVALID_ADDRESS) {
1472 return true;
1473 }
1474 }
1475 }
1476 }
1477 return false;
1478 }
1479
LoadScriptingResourceInTarget(Target * target,Status & error,Stream * feedback_stream)1480 bool Module::LoadScriptingResourceInTarget(Target *target, Status &error,
1481 Stream *feedback_stream) {
1482 if (!target) {
1483 error.SetErrorString("invalid destination Target");
1484 return false;
1485 }
1486
1487 LoadScriptFromSymFile should_load =
1488 target->TargetProperties::GetLoadScriptFromSymbolFile();
1489
1490 if (should_load == eLoadScriptFromSymFileFalse)
1491 return false;
1492
1493 Debugger &debugger = target->GetDebugger();
1494 const ScriptLanguage script_language = debugger.GetScriptLanguage();
1495 if (script_language != eScriptLanguageNone) {
1496
1497 PlatformSP platform_sp(target->GetPlatform());
1498
1499 if (!platform_sp) {
1500 error.SetErrorString("invalid Platform");
1501 return false;
1502 }
1503
1504 FileSpecList file_specs = platform_sp->LocateExecutableScriptingResources(
1505 target, *this, feedback_stream);
1506
1507 const uint32_t num_specs = file_specs.GetSize();
1508 if (num_specs) {
1509 ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter();
1510 if (script_interpreter) {
1511 for (uint32_t i = 0; i < num_specs; ++i) {
1512 FileSpec scripting_fspec(file_specs.GetFileSpecAtIndex(i));
1513 if (scripting_fspec &&
1514 FileSystem::Instance().Exists(scripting_fspec)) {
1515 if (should_load == eLoadScriptFromSymFileWarn) {
1516 if (feedback_stream)
1517 feedback_stream->Printf(
1518 "warning: '%s' contains a debug script. To run this script "
1519 "in "
1520 "this debug session:\n\n command script import "
1521 "\"%s\"\n\n"
1522 "To run all discovered debug scripts in this session:\n\n"
1523 " settings set target.load-script-from-symbol-file "
1524 "true\n",
1525 GetFileSpec().GetFileNameStrippingExtension().GetCString(),
1526 scripting_fspec.GetPath().c_str());
1527 return false;
1528 }
1529 StreamString scripting_stream;
1530 scripting_fspec.Dump(scripting_stream.AsRawOstream());
1531 LoadScriptOptions options;
1532 bool did_load = script_interpreter->LoadScriptingModule(
1533 scripting_stream.GetData(), options, error);
1534 if (!did_load)
1535 return false;
1536 }
1537 }
1538 } else {
1539 error.SetErrorString("invalid ScriptInterpreter");
1540 return false;
1541 }
1542 }
1543 }
1544 return true;
1545 }
1546
SetArchitecture(const ArchSpec & new_arch)1547 bool Module::SetArchitecture(const ArchSpec &new_arch) {
1548 if (!m_arch.IsValid()) {
1549 m_arch = new_arch;
1550 return true;
1551 }
1552 return m_arch.IsCompatibleMatch(new_arch);
1553 }
1554
SetLoadAddress(Target & target,lldb::addr_t value,bool value_is_offset,bool & changed)1555 bool Module::SetLoadAddress(Target &target, lldb::addr_t value,
1556 bool value_is_offset, bool &changed) {
1557 ObjectFile *object_file = GetObjectFile();
1558 if (object_file != nullptr) {
1559 changed = object_file->SetLoadAddress(target, value, value_is_offset);
1560 return true;
1561 } else {
1562 changed = false;
1563 }
1564 return false;
1565 }
1566
MatchesModuleSpec(const ModuleSpec & module_ref)1567 bool Module::MatchesModuleSpec(const ModuleSpec &module_ref) {
1568 const UUID &uuid = module_ref.GetUUID();
1569
1570 if (uuid.IsValid()) {
1571 // If the UUID matches, then nothing more needs to match...
1572 return (uuid == GetUUID());
1573 }
1574
1575 const FileSpec &file_spec = module_ref.GetFileSpec();
1576 if (!FileSpec::Match(file_spec, m_file) &&
1577 !FileSpec::Match(file_spec, m_platform_file))
1578 return false;
1579
1580 const FileSpec &platform_file_spec = module_ref.GetPlatformFileSpec();
1581 if (!FileSpec::Match(platform_file_spec, GetPlatformFileSpec()))
1582 return false;
1583
1584 const ArchSpec &arch = module_ref.GetArchitecture();
1585 if (arch.IsValid()) {
1586 if (!m_arch.IsCompatibleMatch(arch))
1587 return false;
1588 }
1589
1590 ConstString object_name = module_ref.GetObjectName();
1591 if (object_name) {
1592 if (object_name != GetObjectName())
1593 return false;
1594 }
1595 return true;
1596 }
1597
FindSourceFile(const FileSpec & orig_spec,FileSpec & new_spec) const1598 bool Module::FindSourceFile(const FileSpec &orig_spec,
1599 FileSpec &new_spec) const {
1600 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1601 if (auto remapped = m_source_mappings.FindFile(orig_spec)) {
1602 new_spec = *remapped;
1603 return true;
1604 }
1605 return false;
1606 }
1607
RemapSourceFile(llvm::StringRef path) const1608 llvm::Optional<std::string> Module::RemapSourceFile(llvm::StringRef path) const {
1609 std::lock_guard<std::recursive_mutex> guard(m_mutex);
1610 if (auto remapped = m_source_mappings.RemapPath(path))
1611 return remapped->GetPath();
1612 return {};
1613 }
1614
RegisterXcodeSDK(llvm::StringRef sdk_name,llvm::StringRef sysroot)1615 void Module::RegisterXcodeSDK(llvm::StringRef sdk_name, llvm::StringRef sysroot) {
1616 XcodeSDK sdk(sdk_name.str());
1617 ConstString sdk_path(HostInfo::GetXcodeSDKPath(sdk));
1618 if (!sdk_path)
1619 return;
1620 // If the SDK changed for a previously registered source path, update it.
1621 // This could happend with -fdebug-prefix-map, otherwise it's unlikely.
1622 ConstString sysroot_cs(sysroot);
1623 if (!m_source_mappings.Replace(sysroot_cs, sdk_path, true))
1624 // In the general case, however, append it to the list.
1625 m_source_mappings.Append(sysroot_cs, sdk_path, false);
1626 }
1627
MergeArchitecture(const ArchSpec & arch_spec)1628 bool Module::MergeArchitecture(const ArchSpec &arch_spec) {
1629 if (!arch_spec.IsValid())
1630 return false;
1631 LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT | LIBLLDB_LOG_MODULES),
1632 "module has arch %s, merging/replacing with arch %s",
1633 m_arch.GetTriple().getTriple().c_str(),
1634 arch_spec.GetTriple().getTriple().c_str());
1635 if (!m_arch.IsCompatibleMatch(arch_spec)) {
1636 // The new architecture is different, we just need to replace it.
1637 return SetArchitecture(arch_spec);
1638 }
1639
1640 // Merge bits from arch_spec into "merged_arch" and set our architecture.
1641 ArchSpec merged_arch(m_arch);
1642 merged_arch.MergeFrom(arch_spec);
1643 // SetArchitecture() is a no-op if m_arch is already valid.
1644 m_arch = ArchSpec();
1645 return SetArchitecture(merged_arch);
1646 }
1647
GetVersion()1648 llvm::VersionTuple Module::GetVersion() {
1649 if (ObjectFile *obj_file = GetObjectFile())
1650 return obj_file->GetVersion();
1651 return llvm::VersionTuple();
1652 }
1653
GetIsDynamicLinkEditor()1654 bool Module::GetIsDynamicLinkEditor() {
1655 ObjectFile *obj_file = GetObjectFile();
1656
1657 if (obj_file)
1658 return obj_file->GetIsDynamicLinkEditor();
1659
1660 return false;
1661 }
1662