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