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	if (m_unwind_table)
1013	m_unwind_table->Update();
1014	}
1015	}
1016	}
1017	return m_symfile_up ? m_symfile_up->GetSymbolFile() : nullptr;
1018	}
1019
1020	Symtab *Module::GetSymtab() {
1021	if (SymbolFile *symbols = GetSymbolFile())
1022	return symbols->GetSymtab();
1023	return nullptr;
1024	}
1025
1026	void Module::SetFileSpecAndObjectName(const FileSpec &file,
1027	ConstString object_name) {
1028	// Container objects whose paths do not specify a file directly can call this
1029	// function to correct the file and object names.
1030	m_file = file;
1031	m_mod_time = FileSystem::Instance().GetModificationTime(file_spec: file);
1032	m_object_name = object_name;
1033	}
1034
1035	const ArchSpec &Module::GetArchitecture() const { return m_arch; }
1036
1037	std::string Module::GetSpecificationDescription() const {
1038	std::string spec(GetFileSpec().GetPath());
1039	if (m_object_name) {
1040	spec += '(';
1041	spec += m_object_name.GetCString();
1042	spec += ')';
1043	}
1044	return spec;
1045	}
1046
1047	void Module::GetDescription(llvm::raw_ostream &s,
1048	lldb::DescriptionLevel level) {
1049	if (level >= eDescriptionLevelFull) {
1050	if (m_arch.IsValid())
1051	s << llvm::formatv(Fmt: "({0}) ", Vals: m_arch.GetArchitectureName());
1052	}
1053
1054	if (level == eDescriptionLevelBrief) {
1055	const char *filename = m_file.GetFilename().GetCString();
1056	if (filename)
1057	s << filename;
1058	} else {
1059	char path[PATH_MAX];
1060	if (m_file.GetPath(path, max_path_length: sizeof(path)))
1061	s << path;
1062	}
1063
1064	const char *object_name = m_object_name.GetCString();
1065	if (object_name)
1066	s << llvm::formatv(Fmt: "({0})", Vals&: object_name);
1067	}
1068
1069	bool Module::FileHasChanged() const {
1070	// We have provided the DataBuffer for this module to avoid accessing the
1071	// filesystem. We never want to reload those files.
1072	if (m_data_sp)
1073	return false;
1074	if (!m_file_has_changed)
1075	m_file_has_changed =
1076	(FileSystem::Instance().GetModificationTime(file_spec: m_file) != m_mod_time);
1077	return m_file_has_changed;
1078	}
1079
1080	void Module::ReportWarningOptimization(
1081	std::optional<lldb::user_id_t> debugger_id) {
1082	ConstString file_name = GetFileSpec().GetFilename();
1083	if (file_name.IsEmpty())
1084	return;
1085
1086	StreamString ss;
1087	ss << file_name
1088	<< " was compiled with optimization - stepping may behave "
1089	"oddly; variables may not be available.";
1090	Debugger::ReportWarning(message: std::string(ss.GetString()), debugger_id,
1091	once: &m_optimization_warning);
1092	}
1093
1094	void Module::ReportWarningUnsupportedLanguage(
1095	LanguageType language, std::optional<lldb::user_id_t> debugger_id) {
1096	StreamString ss;
1097	ss << "This version of LLDB has no plugin for the language \""
1098	<< Language::GetNameForLanguageType(language)
1099	<< "\". "
1100	"Inspection of frame variables will be limited.";
1101	Debugger::ReportWarning(message: std::string(ss.GetString()), debugger_id,
1102	once: &m_language_warning);
1103	}
1104
1105	void Module::ReportErrorIfModifyDetected(
1106	const llvm::formatv_object_base &payload) {
1107	if (!m_first_file_changed_log) {
1108	if (FileHasChanged()) {
1109	m_first_file_changed_log = true;
1110	StreamString strm;
1111	strm.PutCString(cstr: "the object file ");
1112	GetDescription(s&: strm.AsRawOstream(), level: lldb::eDescriptionLevelFull);
1113	strm.PutCString(cstr: " has been modified\n");
1114	strm.PutCString(cstr: payload.str());
1115	strm.PutCString(cstr: "The debug session should be aborted as the original "
1116	"debug information has been overwritten.");
1117	Debugger::ReportError(message: std::string(strm.GetString()));
1118	}
1119	}
1120	}
1121
1122	void Module::ReportError(const llvm::formatv_object_base &payload) {
1123	StreamString strm;
1124	GetDescription(s&: strm.AsRawOstream(), level: lldb::eDescriptionLevelBrief);
1125	strm.PutChar(ch: ' ');
1126	strm.PutCString(cstr: payload.str());
1127	Debugger::ReportError(message: strm.GetString().str());
1128	}
1129
1130	void Module::ReportWarning(const llvm::formatv_object_base &payload) {
1131	StreamString strm;
1132	GetDescription(s&: strm.AsRawOstream(), level: lldb::eDescriptionLevelFull);
1133	strm.PutChar(ch: ' ');
1134	strm.PutCString(cstr: payload.str());
1135	Debugger::ReportWarning(message: std::string(strm.GetString()));
1136	}
1137
1138	void Module::LogMessage(Log *log, const llvm::formatv_object_base &payload) {
1139	StreamString log_message;
1140	GetDescription(s&: log_message.AsRawOstream(), level: lldb::eDescriptionLevelFull);
1141	log_message.PutCString(cstr: ": ");
1142	log_message.PutCString(cstr: payload.str());
1143	log->PutCString(cstr: log_message.GetData());
1144	}
1145
1146	void Module::LogMessageVerboseBacktrace(
1147	Log *log, const llvm::formatv_object_base &payload) {
1148	StreamString log_message;
1149	GetDescription(s&: log_message.AsRawOstream(), level: lldb::eDescriptionLevelFull);
1150	log_message.PutCString(cstr: ": ");
1151	log_message.PutCString(cstr: payload.str());
1152	if (log->GetVerbose()) {
1153	std::string back_trace;
1154	llvm::raw_string_ostream stream(back_trace);
1155	llvm::sys::PrintStackTrace(OS&: stream);
1156	log_message.PutCString(cstr: back_trace);
1157	}
1158	log->PutCString(cstr: log_message.GetData());
1159	}
1160
1161	void Module::Dump(Stream *s) {
1162	std::lock_guard<std::recursive_mutex> guard(m_mutex);
1163	// s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
1164	s->Indent();
1165	s->Printf(format: "Module %s%s%s%s\n", m_file.GetPath().c_str(),
1166	m_object_name ? "(" : "",
1167	m_object_name ? m_object_name.GetCString() : "",
1168	m_object_name ? ")" : "");
1169
1170	s->IndentMore();
1171
1172	ObjectFile *objfile = GetObjectFile();
1173	if (objfile)
1174	objfile->Dump(s);
1175
1176	if (SymbolFile *symbols = GetSymbolFile())
1177	symbols->Dump(s&: *s);
1178
1179	s->IndentLess();
1180	}
1181
1182	ConstString Module::GetObjectName() const { return m_object_name; }
1183
1184	ObjectFile *Module::GetObjectFile() {
1185	if (!m_did_load_objfile.load()) {
1186	std::lock_guard<std::recursive_mutex> guard(m_mutex);
1187	if (!m_did_load_objfile.load()) {
1188	LLDB_SCOPED_TIMERF("Module::GetObjectFile () module = %s",
1189	GetFileSpec().GetFilename().AsCString(""));
1190	lldb::offset_t data_offset = 0;
1191	lldb::offset_t file_size = 0;
1192
1193	if (m_data_sp)
1194	file_size = m_data_sp->GetByteSize();
1195	else if (m_file)
1196	file_size = FileSystem::Instance().GetByteSize(file_spec: m_file);
1197
1198	if (file_size > m_object_offset) {
1199	m_did_load_objfile = true;
1200	// FindPlugin will modify its data_sp argument. Do not let it
1201	// modify our m_data_sp member.
1202	auto data_sp = m_data_sp;
1203	m_objfile_sp = ObjectFile::FindPlugin(
1204	module_sp: shared_from_this(), file_spec: &m_file, file_offset: m_object_offset,
1205	file_size: file_size - m_object_offset, data_sp, data_offset);
1206	if (m_objfile_sp) {
1207	// Once we get the object file, update our module with the object
1208	// file's architecture since it might differ in vendor/os if some
1209	// parts were unknown. But since the matching arch might already be
1210	// more specific than the generic COFF architecture, only merge in
1211	// those values that overwrite unspecified unknown values.
1212	m_arch.MergeFrom(other: m_objfile_sp->GetArchitecture());
1213	} else {
1214	ReportError(format: "failed to load objfile for {0}\nDebugging will be "
1215	"degraded for this module.",
1216	args: GetFileSpec().GetPath().c_str());
1217	}
1218	}
1219	}
1220	}
1221	return m_objfile_sp.get();
1222	}
1223
1224	SectionList *Module::GetSectionList() {
1225	// Populate m_sections_up with sections from objfile.
1226	if (!m_sections_up) {
1227	ObjectFile *obj_file = GetObjectFile();
1228	if (obj_file != nullptr)
1229	obj_file->CreateSections(unified_section_list&: *GetUnifiedSectionList());
1230	}
1231	return m_sections_up.get();
1232	}
1233
1234	void Module::SectionFileAddressesChanged() {
1235	ObjectFile *obj_file = GetObjectFile();
1236	if (obj_file)
1237	obj_file->SectionFileAddressesChanged();
1238	if (SymbolFile *symbols = GetSymbolFile())
1239	symbols->SectionFileAddressesChanged();
1240	}
1241
1242	UnwindTable &Module::GetUnwindTable() {
1243	if (!m_unwind_table) {
1244	if (!m_symfile_spec)
1245	SymbolLocator::DownloadSymbolFileAsync(uuid: GetUUID());
1246	m_unwind_table.emplace(args&: *this);
1247	}
1248	return *m_unwind_table;
1249	}
1250
1251	SectionList *Module::GetUnifiedSectionList() {
1252	if (!m_sections_up)
1253	m_sections_up = std::make_unique<SectionList>();
1254	return m_sections_up.get();
1255	}
1256
1257	const Symbol *Module::FindFirstSymbolWithNameAndType(ConstString name,
1258	SymbolType symbol_type) {
1259	LLDB_SCOPED_TIMERF(
1260	"Module::FindFirstSymbolWithNameAndType (name = %s, type = %i)",
1261	name.AsCString(), symbol_type);
1262	if (Symtab *symtab = GetSymtab())
1263	return symtab->FindFirstSymbolWithNameAndType(
1264	name, symbol_type, symbol_debug_type: Symtab::eDebugAny, symbol_visibility: Symtab::eVisibilityAny);
1265	return nullptr;
1266	}
1267	void Module::SymbolIndicesToSymbolContextList(
1268	Symtab *symtab, std::vector<uint32_t> &symbol_indexes,
1269	SymbolContextList &sc_list) {
1270	// No need to protect this call using m_mutex all other method calls are
1271	// already thread safe.
1272
1273	size_t num_indices = symbol_indexes.size();
1274	if (num_indices > 0) {
1275	SymbolContext sc;
1276	CalculateSymbolContext(sc: &sc);
1277	for (size_t i = 0; i < num_indices; i++) {
1278	sc.symbol = symtab->SymbolAtIndex(idx: symbol_indexes[i]);
1279	if (sc.symbol)
1280	sc_list.Append(sc);
1281	}
1282	}
1283	}
1284
1285	void Module::FindFunctionSymbols(ConstString name, uint32_t name_type_mask,
1286	SymbolContextList &sc_list) {
1287	LLDB_SCOPED_TIMERF("Module::FindSymbolsFunctions (name = %s, mask = 0x%8.8x)",
1288	name.AsCString(), name_type_mask);
1289	if (Symtab *symtab = GetSymtab())
1290	symtab->FindFunctionSymbols(name, name_type_mask, sc_list);
1291	}
1292
1293	void Module::FindSymbolsWithNameAndType(ConstString name,
1294	SymbolType symbol_type,
1295	SymbolContextList &sc_list) {
1296	// No need to protect this call using m_mutex all other method calls are
1297	// already thread safe.
1298	if (Symtab *symtab = GetSymtab()) {
1299	std::vector<uint32_t> symbol_indexes;
1300	symtab->FindAllSymbolsWithNameAndType(name, symbol_type, symbol_indexes);
1301	SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list);
1302	}
1303	}
1304
1305	void Module::FindSymbolsMatchingRegExAndType(
1306	const RegularExpression &regex, SymbolType symbol_type,
1307	SymbolContextList &sc_list, Mangled::NamePreference mangling_preference) {
1308	// No need to protect this call using m_mutex all other method calls are
1309	// already thread safe.
1310	LLDB_SCOPED_TIMERF(
1311	"Module::FindSymbolsMatchingRegExAndType (regex = %s, type = %i)",
1312	regex.GetText().str().c_str(), symbol_type);
1313	if (Symtab *symtab = GetSymtab()) {
1314	std::vector<uint32_t> symbol_indexes;
1315	symtab->FindAllSymbolsMatchingRexExAndType(
1316	regex, symbol_type, symbol_debug_type: Symtab::eDebugAny, symbol_visibility: Symtab::eVisibilityAny,
1317	symbol_indexes, name_preference: mangling_preference);
1318	SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list);
1319	}
1320	}
1321
1322	void Module::PreloadSymbols() {
1323	std::lock_guard<std::recursive_mutex> guard(m_mutex);
1324	SymbolFile *sym_file = GetSymbolFile();
1325	if (!sym_file)
1326	return;
1327
1328	// Load the object file symbol table and any symbols from the SymbolFile that
1329	// get appended using SymbolFile::AddSymbols(...).
1330	if (Symtab *symtab = sym_file->GetSymtab())
1331	symtab->PreloadSymbols();
1332
1333	// Now let the symbol file preload its data and the symbol table will be
1334	// available without needing to take the module lock.
1335	sym_file->PreloadSymbols();
1336	}
1337
1338	void Module::SetSymbolFileFileSpec(const FileSpec &file) {
1339	if (!FileSystem::Instance().Exists(file_spec: file))
1340	return;
1341	if (m_symfile_up) {
1342	// Remove any sections in the unified section list that come from the
1343	// current symbol vendor.
1344	SectionList *section_list = GetSectionList();
1345	SymbolFile *symbol_file = GetSymbolFile();
1346	if (section_list && symbol_file) {
1347	ObjectFile *obj_file = symbol_file->GetObjectFile();
1348	// Make sure we have an object file and that the symbol vendor's objfile
1349	// isn't the same as the module's objfile before we remove any sections
1350	// for it...
1351	if (obj_file) {
1352	// Check to make sure we aren't trying to specify the file we already
1353	// have
1354	if (obj_file->GetFileSpec() == file) {
1355	// We are being told to add the exact same file that we already have
1356	// we don't have to do anything.
1357	return;
1358	}
1359
1360	// Cleare the current symtab as we are going to replace it with a new
1361	// one
1362	obj_file->ClearSymtab();
1363
1364	// The symbol file might be a directory bundle ("/tmp/a.out.dSYM")
1365	// instead of a full path to the symbol file within the bundle
1366	// ("/tmp/a.out.dSYM/Contents/Resources/DWARF/a.out"). So we need to
1367	// check this
1368	if (FileSystem::Instance().IsDirectory(file_spec: file)) {
1369	std::string new_path(file.GetPath());
1370	std::string old_path(obj_file->GetFileSpec().GetPath());
1371	if (llvm::StringRef(old_path).starts_with(Prefix: new_path)) {
1372	// We specified the same bundle as the symbol file that we already
1373	// have
1374	return;
1375	}
1376	}
1377
1378	if (obj_file != m_objfile_sp.get()) {
1379	size_t num_sections = section_list->GetNumSections(depth: 0);
1380	for (size_t idx = num_sections; idx > 0; --idx) {
1381	lldb::SectionSP section_sp(
1382	section_list->GetSectionAtIndex(idx: idx - 1));
1383	if (section_sp->GetObjectFile() == obj_file) {
1384	section_list->DeleteSection(idx: idx - 1);
1385	}
1386	}
1387	}
1388	}
1389	}
1390	// Keep all old symbol files around in case there are any lingering type
1391	// references in any SBValue objects that might have been handed out.
1392	m_old_symfiles.push_back(x: std::move(m_symfile_up));
1393	}
1394	m_symfile_spec = file;
1395	m_symfile_up.reset();
1396	m_did_load_symfile = false;
1397	}
1398
1399	bool Module::IsExecutable() {
1400	if (GetObjectFile() == nullptr)
1401	return false;
1402	else
1403	return GetObjectFile()->IsExecutable();
1404	}
1405
1406	bool Module::IsLoadedInTarget(Target *target) {
1407	ObjectFile *obj_file = GetObjectFile();
1408	if (obj_file) {
1409	SectionList *sections = GetSectionList();
1410	if (sections != nullptr) {
1411	size_t num_sections = sections->GetSize();
1412	for (size_t sect_idx = 0; sect_idx < num_sections; sect_idx++) {
1413	SectionSP section_sp = sections->GetSectionAtIndex(idx: sect_idx);
1414	if (section_sp->GetLoadBaseAddress(target) != LLDB_INVALID_ADDRESS) {
1415	return true;
1416	}
1417	}
1418	}
1419	}
1420	return false;
1421	}
1422
1423	bool Module::LoadScriptingResourceInTarget(Target *target, Status &error,
1424	Stream &feedback_stream) {
1425	if (!target) {
1426	error.SetErrorString("invalid destination Target");
1427	return false;
1428	}
1429
1430	LoadScriptFromSymFile should_load =
1431	target->TargetProperties::GetLoadScriptFromSymbolFile();
1432
1433	if (should_load == eLoadScriptFromSymFileFalse)
1434	return false;
1435
1436	Debugger &debugger = target->GetDebugger();
1437	const ScriptLanguage script_language = debugger.GetScriptLanguage();
1438	if (script_language != eScriptLanguageNone) {
1439
1440	PlatformSP platform_sp(target->GetPlatform());
1441
1442	if (!platform_sp) {
1443	error.SetErrorString("invalid Platform");
1444	return false;
1445	}
1446
1447	FileSpecList file_specs = platform_sp->LocateExecutableScriptingResources(
1448	target, module&: *this, feedback_stream);
1449
1450	const uint32_t num_specs = file_specs.GetSize();
1451	if (num_specs) {
1452	ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter();
1453	if (script_interpreter) {
1454	for (uint32_t i = 0; i < num_specs; ++i) {
1455	FileSpec scripting_fspec(file_specs.GetFileSpecAtIndex(idx: i));
1456	if (scripting_fspec &&
1457	FileSystem::Instance().Exists(file_spec: scripting_fspec)) {
1458	if (should_load == eLoadScriptFromSymFileWarn) {
1459	feedback_stream.Printf(
1460	format: "warning: '%s' contains a debug script. To run this script "
1461	"in "
1462	"this debug session:\n\n command script import "
1463	"\"%s\"\n\n"
1464	"To run all discovered debug scripts in this session:\n\n"
1465	" settings set target.load-script-from-symbol-file "
1466	"true\n",
1467	GetFileSpec().GetFileNameStrippingExtension().GetCString(),
1468	scripting_fspec.GetPath().c_str());
1469	return false;
1470	}
1471	StreamString scripting_stream;
1472	scripting_fspec.Dump(s&: scripting_stream.AsRawOstream());
1473	LoadScriptOptions options;
1474	bool did_load = script_interpreter->LoadScriptingModule(
1475	filename: scripting_stream.GetData(), options, error);
1476	if (!did_load)
1477	return false;
1478	}
1479	}
1480	} else {
1481	error.SetErrorString("invalid ScriptInterpreter");
1482	return false;
1483	}
1484	}
1485	}
1486	return true;
1487	}
1488
1489	bool Module::SetArchitecture(const ArchSpec &new_arch) {
1490	if (!m_arch.IsValid()) {
1491	m_arch = new_arch;
1492	return true;
1493	}
1494	return m_arch.IsCompatibleMatch(rhs: new_arch);
1495	}
1496
1497	bool Module::SetLoadAddress(Target &target, lldb::addr_t value,
1498	bool value_is_offset, bool &changed) {
1499	ObjectFile *object_file = GetObjectFile();
1500	if (object_file != nullptr) {
1501	changed = object_file->SetLoadAddress(target, value, value_is_offset);
1502	return true;
1503	} else {
1504	changed = false;
1505	}
1506	return false;
1507	}
1508
1509	bool Module::MatchesModuleSpec(const ModuleSpec &module_ref) {
1510	const UUID &uuid = module_ref.GetUUID();
1511
1512	if (uuid.IsValid()) {
1513	// If the UUID matches, then nothing more needs to match...
1514	return (uuid == GetUUID());
1515	}
1516
1517	const FileSpec &file_spec = module_ref.GetFileSpec();
1518	if (!FileSpec::Match(pattern: file_spec, file: m_file) &&
1519	!FileSpec::Match(pattern: file_spec, file: m_platform_file))
1520	return false;
1521
1522	const FileSpec &platform_file_spec = module_ref.GetPlatformFileSpec();
1523	if (!FileSpec::Match(pattern: platform_file_spec, file: GetPlatformFileSpec()))
1524	return false;
1525
1526	const ArchSpec &arch = module_ref.GetArchitecture();
1527	if (arch.IsValid()) {
1528	if (!m_arch.IsCompatibleMatch(rhs: arch))
1529	return false;
1530	}
1531
1532	ConstString object_name = module_ref.GetObjectName();
1533	if (object_name) {
1534	if (object_name != GetObjectName())
1535	return false;
1536	}
1537	return true;
1538	}
1539
1540	bool Module::FindSourceFile(const FileSpec &orig_spec,
1541	FileSpec &new_spec) const {
1542	std::lock_guard<std::recursive_mutex> guard(m_mutex);
1543	if (auto remapped = m_source_mappings.FindFile(orig_spec)) {
1544	new_spec = *remapped;
1545	return true;
1546	}
1547	return false;
1548	}
1549
1550	std::optional<std::string> Module::RemapSourceFile(llvm::StringRef path) const {
1551	std::lock_guard<std::recursive_mutex> guard(m_mutex);
1552	if (auto remapped = m_source_mappings.RemapPath(path))
1553	return remapped->GetPath();
1554	return {};
1555	}
1556
1557	void Module::RegisterXcodeSDK(llvm::StringRef sdk_name,
1558	llvm::StringRef sysroot) {
1559	auto sdk_path_or_err =
1560	HostInfo::GetSDKRoot(options: HostInfo::SDKOptions{.XcodeSDKSelection: sdk_name.str()});
1561
1562	if (!sdk_path_or_err) {
1563	Debugger::ReportError(message: "Error while searching for Xcode SDK: " +
1564	toString(E: sdk_path_or_err.takeError()));
1565	return;
1566	}
1567
1568	auto sdk_path = *sdk_path_or_err;
1569	if (sdk_path.empty())
1570	return;
1571	// If the SDK changed for a previously registered source path, update it.
1572	// This could happend with -fdebug-prefix-map, otherwise it's unlikely.
1573	if (!m_source_mappings.Replace(path: sysroot, replacement: sdk_path, notify: true))
1574	// In the general case, however, append it to the list.
1575	m_source_mappings.Append(path: sysroot, replacement: sdk_path, notify: false);
1576	}
1577
1578	bool Module::MergeArchitecture(const ArchSpec &arch_spec) {
1579	if (!arch_spec.IsValid())
1580	return false;
1581	LLDB_LOGF(GetLog(LLDBLog::Object | LLDBLog::Modules),
1582	"module has arch %s, merging/replacing with arch %s",
1583	m_arch.GetTriple().getTriple().c_str(),
1584	arch_spec.GetTriple().getTriple().c_str());
1585	if (!m_arch.IsCompatibleMatch(rhs: arch_spec)) {
1586	// The new architecture is different, we just need to replace it.
1587	return SetArchitecture(arch_spec);
1588	}
1589
1590	// Merge bits from arch_spec into "merged_arch" and set our architecture.
1591	ArchSpec merged_arch(m_arch);
1592	merged_arch.MergeFrom(other: arch_spec);
1593	// SetArchitecture() is a no-op if m_arch is already valid.
1594	m_arch = ArchSpec();
1595	return SetArchitecture(merged_arch);
1596	}
1597
1598	llvm::VersionTuple Module::GetVersion() {
1599	if (ObjectFile *obj_file = GetObjectFile())
1600	return obj_file->GetVersion();
1601	return llvm::VersionTuple();
1602	}
1603
1604	bool Module::GetIsDynamicLinkEditor() {
1605	ObjectFile *obj_file = GetObjectFile();
1606
1607	if (obj_file)
1608	return obj_file->GetIsDynamicLinkEditor();
1609
1610	return false;
1611	}
1612
1613	uint32_t Module::Hash() {
1614	std::string identifier;
1615	llvm::raw_string_ostream id_strm(identifier);
1616	id_strm << m_arch.GetTriple().str() << '-' << m_file.GetPath();
1617	if (m_object_name)
1618	id_strm << '(' << m_object_name << ')';
1619	if (m_object_offset > 0)
1620	id_strm << m_object_offset;
1621	const auto mtime = llvm::sys::toTimeT(TP: m_object_mod_time);
1622	if (mtime > 0)
1623	id_strm << mtime;
1624	return llvm::djbHash(Buffer: id_strm.str());
1625	}
1626
1627	std::string Module::GetCacheKey() {
1628	std::string key;
1629	llvm::raw_string_ostream strm(key);
1630	strm << m_arch.GetTriple().str() << '-' << m_file.GetFilename();
1631	if (m_object_name)
1632	strm << '(' << m_object_name << ')';
1633	strm << '-' << llvm::format_hex(N: Hash(), Width: 10);
1634	return strm.str();
1635	}
1636
1637	DataFileCache *Module::GetIndexCache() {
1638	if (!ModuleList::GetGlobalModuleListProperties().GetEnableLLDBIndexCache())
1639	return nullptr;
1640	// NOTE: intentional leak so we don't crash if global destructor chain gets
1641	// called as other threads still use the result of this function
1642	static DataFileCache *g_data_file_cache =
1643	new DataFileCache(ModuleList::GetGlobalModuleListProperties()
1644	.GetLLDBIndexCachePath()
1645	.GetPath());
1646	return g_data_file_cache;
1647	}
1648