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
77namespace lldb_private {
78class CompilerDeclContext;
79}
80namespace lldb_private {
81class VariableList;
82}
83
84using namespace lldb;
85using 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
90typedef std::vector<Module *> ModuleCollection;
91
92static 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
106std::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
118size_t Module::GetNumberAllocatedModules() {
119  std::lock_guard<std::recursive_mutex> guard(
120      GetAllocationModuleCollectionMutex());
121  return GetModuleCollection().size();
122}
123
124Module *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
133Module::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(this);
140  }
141
142  Log *log(GetLog(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          module_spec.GetFileSpec(), 0, file_size, 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                                            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(module_spec.GetFileSpec());
190    else if (matching_module_spec.GetFileSpec())
191      m_mod_time = FileSystem::Instance().GetModificationTime(
192          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
235Module::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(this);
247  }
248
249  Log *log(GetLog(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
257Module::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(this);
261}
262
263Module::~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(modules.begin(), end, this);
274    assert(pos != end);
275    modules.erase(pos);
276  }
277  Log *log(GetLog(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
293ObjectFile *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>(size_to_read, 0);
304      Status readmem_error;
305      const size_t bytes_read =
306          process_sp->ReadMemory(header_addr, data_sp->GetBytes(),
307                                 data_sp->GetByteSize(), 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(shared_from_this(), process_sp,
312                                              header_addr, data_sp);
313        if (m_objfile_sp) {
314          StreamString s;
315          s.Printf("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(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
340const 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
355void 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
365llvm::Expected<TypeSystemSP>
366Module::GetTypeSystemForLanguage(LanguageType language) {
367  return m_type_system_map.GetTypeSystemForLanguage(language, this, true);
368}
369
370void Module::ForEachTypeSystem(
371    llvm::function_ref<bool(lldb::TypeSystemSP)> callback) {
372  m_type_system_map.ForEach(callback);
373}
374
375void Module::ParseAllDebugSymbols() {
376  std::lock_guard<std::recursive_mutex> guard(m_mutex);
377  size_t num_comp_units = GetNumCompileUnits();
378  if (num_comp_units == 0)
379    return;
380
381  SymbolFile *symbols = GetSymbolFile();
382
383  for (size_t cu_idx = 0; cu_idx < num_comp_units; cu_idx++) {
384    SymbolContext sc;
385    sc.module_sp = shared_from_this();
386    sc.comp_unit = symbols->GetCompileUnitAtIndex(cu_idx).get();
387    if (!sc.comp_unit)
388      continue;
389
390    symbols->ParseVariablesForContext(sc);
391
392    symbols->ParseFunctions(*sc.comp_unit);
393
394    sc.comp_unit->ForeachFunction([&sc, &symbols](const FunctionSP &f) {
395      symbols->ParseBlocksRecursive(*f);
396
397      // Parse the variables for this function and all its blocks
398      sc.function = f.get();
399      symbols->ParseVariablesForContext(sc);
400      return false;
401    });
402
403    // Parse all types for this compile unit
404    symbols->ParseTypes(*sc.comp_unit);
405  }
406}
407
408void Module::CalculateSymbolContext(SymbolContext *sc) {
409  sc->module_sp = shared_from_this();
410}
411
412ModuleSP Module::CalculateSymbolContextModule() { return shared_from_this(); }
413
414void Module::DumpSymbolContext(Stream *s) {
415  s->Printf(", Module{%p}", static_cast<void *>(this));
416}
417
418size_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
425CompUnitSP 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(index);
433  }
434  return cu_sp;
435}
436
437bool 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(vm_addr, section_list);
442  return false;
443}
444
445uint32_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(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            so_addr.GetFileAddress(),
491            [&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                          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(-1);
545
546      bool do_resolve_tail_call_address = false; // prevent recursion
547      const uint32_t flags = ResolveSymbolContextForAddress(
548          previous_addr, resolve_scope, sc, do_resolve_tail_call_address);
549      if (flags & eSymbolContextSymbol) {
550        AddressRange addr_range;
551        if (sc.GetAddressRange(eSymbolContextFunction | eSymbolContextSymbol, 0,
552                               false, 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
576uint32_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
584uint32_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(location_spec, resolve_scope, sc_list);
601  }
602
603  return sc_list.GetSize() - initial_count;
604}
605
606void 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
613void 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
620void 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(i).get();
627    if (sc.comp_unit) {
628      if (FileSpec::Match(path, sc.comp_unit->GetPrimaryFile()))
629        sc_list.Append(sc);
630    }
631  }
632}
633
634Module::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_cstr))
644      m_name_type_mask = eFunctionNameTypeFull;
645    else if ((language == eLanguageTypeUnknown ||
646              Language::LanguageIsObjC(language)) &&
647             ObjCLanguage::IsPossibleObjCMethodName(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_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_cstr, context,
661                                                           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_cstr, context,
691                                                       basename);
692      }
693    }
694
695    if (name_type_mask & eFunctionNameTypeSelector) {
696      if (!ObjCLanguage::IsPossibleObjCSelector(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_cstr)) {
708        CPlusPlusLanguage::MethodName cpp_method(name);
709        basename = cpp_method.GetBasename();
710        if (basename.empty())
711          CPlusPlusLanguage::ExtractContextAndIdentifier(name_cstr, context,
712                                                         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
732bool 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(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_type))
759    return language->DemangledNameContainsPath(m_name, demangled_function_name);
760
761  llvm::StringRef function_name_ref = demangled_function_name;
762  return function_name_ref.contains(m_name);
763}
764
765void 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(i, sc))
772        break;
773
774      bool keep_it =
775          NameMatchesLookupInfo(sc.GetFunctionName(), sc.GetLanguage());
776      if (keep_it)
777        ++i;
778      else
779        sc_list.RemoveContextAtIndex(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(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(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(m_name) != 0) {
802              sc_list.RemoveContextAtIndex(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(i);
814              continue;
815            }
816          }
817        }
818      }
819      ++i;
820    }
821  }
822}
823
824void 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                           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(lookup_info.GetLookupName(),
837                                    lookup_info.GetNameTypeMask(), sc_list);
838      }
839    }
840  }
841}
842
843void 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, old_size);
855  }
856}
857
858void 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, CompilerDeclContext(), name_type_mask, options,
868                unfiltered);
869  // Filter by context.
870  for (auto &sc : unfiltered)
871    if (sc.function && compiler_ctx.equals(sc.function->GetCompilerContext()))
872      sc_list.Append(sc);
873}
874
875void 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, 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, eSymbolTypeAny, Symtab::eDebugAny, Symtab::eVisibilityAny,
891            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(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(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                        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
945void 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(n).GetBaseAddress();
961    Function *f = addr.CalculateSymbolContextFunction();
962    if (f && f == function)
963      output_local.push_back(addr);
964    else
965      output_extern.push_back(addr);
966  }
967}
968
969void Module::FindTypes(const TypeQuery &query, TypeResults &results) {
970  if (SymbolFile *symbols = GetSymbolFile())
971    symbols->FindTypes(query, results);
972}
973
974static Debugger::DebuggerList
975DebuggersOwningModuleRequestingInterruption(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(debugger_sp);
988  }
989  return interruptors;
990}
991
992SymbolFile *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(*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            SymbolVendor::FindPlugin(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
1018Symtab *Module::GetSymtab() {
1019  if (SymbolFile *symbols = GetSymbolFile())
1020    return symbols->GetSymtab();
1021  return nullptr;
1022}
1023
1024void 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);
1030  m_object_name = object_name;
1031}
1032
1033const ArchSpec &Module::GetArchitecture() const { return m_arch; }
1034
1035std::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
1045void Module::GetDescription(llvm::raw_ostream &s,
1046                            lldb::DescriptionLevel level) {
1047  if (level >= eDescriptionLevelFull) {
1048    if (m_arch.IsValid())
1049      s << llvm::formatv("({0}) ", 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, sizeof(path)))
1059      s << path;
1060  }
1061
1062  const char *object_name = m_object_name.GetCString();
1063  if (object_name)
1064    s << llvm::formatv("({0})", object_name);
1065}
1066
1067bool 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(m_file) != m_mod_time);
1075  return m_file_has_changed;
1076}
1077
1078void 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(std::string(ss.GetString()), debugger_id,
1089                          &m_optimization_warning);
1090}
1091
1092void 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(std::string(ss.GetString()), debugger_id,
1100                          &m_language_warning);
1101}
1102
1103void 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("the object file ");
1110      GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelFull);
1111      strm.PutCString(" has been modified\n");
1112      strm.PutCString(payload.str());
1113      strm.PutCString("The debug session should be aborted as the original "
1114                      "debug information has been overwritten.");
1115      Debugger::ReportError(std::string(strm.GetString()));
1116    }
1117  }
1118}
1119
1120void Module::ReportError(const llvm::formatv_object_base &payload) {
1121  StreamString strm;
1122  GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelBrief);
1123  strm.PutChar(' ');
1124  strm.PutCString(payload.str());
1125  Debugger::ReportError(strm.GetString().str());
1126}
1127
1128void Module::ReportWarning(const llvm::formatv_object_base &payload) {
1129  StreamString strm;
1130  GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelFull);
1131  strm.PutChar(' ');
1132  strm.PutCString(payload.str());
1133  Debugger::ReportWarning(std::string(strm.GetString()));
1134}
1135
1136void Module::LogMessage(Log *log, const llvm::formatv_object_base &payload) {
1137  StreamString log_message;
1138  GetDescription(log_message.AsRawOstream(), lldb::eDescriptionLevelFull);
1139  log_message.PutCString(": ");
1140  log_message.PutCString(payload.str());
1141  log->PutCString(log_message.GetData());
1142}
1143
1144void Module::LogMessageVerboseBacktrace(
1145    Log *log, const llvm::formatv_object_base &payload) {
1146  StreamString log_message;
1147  GetDescription(log_message.AsRawOstream(), lldb::eDescriptionLevelFull);
1148  log_message.PutCString(": ");
1149  log_message.PutCString(payload.str());
1150  if (log->GetVerbose()) {
1151    std::string back_trace;
1152    llvm::raw_string_ostream stream(back_trace);
1153    llvm::sys::PrintStackTrace(stream);
1154    log_message.PutCString(back_trace);
1155  }
1156  log->PutCString(log_message.GetData());
1157}
1158
1159void 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("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);
1176
1177  s->IndentLess();
1178}
1179
1180ConstString Module::GetObjectName() const { return m_object_name; }
1181
1182ObjectFile *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(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            shared_from_this(), &m_file, m_object_offset,
1203            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(m_objfile_sp->GetArchitecture());
1211        } else {
1212          ReportError("failed to load objfile for {0}\nDebugging will be "
1213                      "degraded for this module.",
1214                      GetFileSpec().GetPath().c_str());
1215        }
1216      }
1217    }
1218  }
1219  return m_objfile_sp.get();
1220}
1221
1222SectionList *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(*GetUnifiedSectionList());
1228  }
1229  return m_sections_up.get();
1230}
1231
1232void 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
1240UnwindTable &Module::GetUnwindTable() {
1241  if (!m_unwind_table) {
1242    m_unwind_table.emplace(*this);
1243    if (!m_symfile_spec)
1244      SymbolLocator::DownloadSymbolFileAsync(GetUUID());
1245  }
1246  return *m_unwind_table;
1247}
1248
1249SectionList *Module::GetUnifiedSectionList() {
1250  if (!m_sections_up)
1251    m_sections_up = std::make_unique<SectionList>();
1252  return m_sections_up.get();
1253}
1254
1255const 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, Symtab::eDebugAny, Symtab::eVisibilityAny);
1263  return nullptr;
1264}
1265void 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);
1275    for (size_t i = 0; i < num_indices; i++) {
1276      sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]);
1277      if (sc.symbol)
1278        sc_list.Append(sc);
1279    }
1280  }
1281}
1282
1283void 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
1291void 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
1303void 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, Symtab::eDebugAny, Symtab::eVisibilityAny,
1315        symbol_indexes, mangling_preference);
1316    SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list);
1317  }
1318}
1319
1320void 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
1336void Module::SetSymbolFileFileSpec(const FileSpec &file) {
1337  if (!FileSystem::Instance().Exists(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)) {
1372          std::string new_path(file.GetPath());
1373          std::string old_path(obj_file->GetFileSpec().GetPath());
1374          if (llvm::StringRef(old_path).starts_with(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(0);
1383          for (size_t idx = num_sections; idx > 0; --idx) {
1384            lldb::SectionSP section_sp(
1385                section_list->GetSectionAtIndex(idx - 1));
1386            if (section_sp->GetObjectFile() == obj_file) {
1387              section_list->DeleteSection(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(std::move(m_symfile_up));
1396  }
1397  m_symfile_spec = file;
1398  m_symfile_up.reset();
1399  m_did_load_symfile = false;
1400}
1401
1402bool Module::IsExecutable() {
1403  if (GetObjectFile() == nullptr)
1404    return false;
1405  else
1406    return GetObjectFile()->IsExecutable();
1407}
1408
1409bool 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(sect_idx);
1417        if (section_sp->GetLoadBaseAddress(target) != LLDB_INVALID_ADDRESS) {
1418          return true;
1419        }
1420      }
1421    }
1422  }
1423  return false;
1424}
1425
1426bool 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, *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(i));
1459          if (scripting_fspec &&
1460              FileSystem::Instance().Exists(scripting_fspec)) {
1461            if (should_load == eLoadScriptFromSymFileWarn) {
1462              feedback_stream.Printf(
1463                  "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(scripting_stream.AsRawOstream());
1476            LoadScriptOptions options;
1477            bool did_load = script_interpreter->LoadScriptingModule(
1478                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
1492bool 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(new_arch);
1498}
1499
1500bool 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
1512bool 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(file_spec, m_file) &&
1522      !FileSpec::Match(file_spec, m_platform_file))
1523    return false;
1524
1525  const FileSpec &platform_file_spec = module_ref.GetPlatformFileSpec();
1526  if (!FileSpec::Match(platform_file_spec, GetPlatformFileSpec()))
1527    return false;
1528
1529  const ArchSpec &arch = module_ref.GetArchitecture();
1530  if (arch.IsValid()) {
1531    if (!m_arch.IsCompatibleMatch(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
1543bool 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
1553std::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
1560void Module::RegisterXcodeSDK(llvm::StringRef sdk_name,
1561                              llvm::StringRef sysroot) {
1562  auto sdk_path_or_err =
1563      HostInfo::GetSDKRoot(HostInfo::SDKOptions{sdk_name.str()});
1564
1565  if (!sdk_path_or_err) {
1566    Debugger::ReportError("Error while searching for Xcode SDK: " +
1567                          toString(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(sysroot, sdk_path, true))
1577    // In the general case, however, append it to the list.
1578    m_source_mappings.Append(sysroot, sdk_path, false);
1579}
1580
1581bool 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(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(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
1601llvm::VersionTuple Module::GetVersion() {
1602  if (ObjectFile *obj_file = GetObjectFile())
1603    return obj_file->GetVersion();
1604  return llvm::VersionTuple();
1605}
1606
1607bool Module::GetIsDynamicLinkEditor() {
1608  ObjectFile *obj_file = GetObjectFile();
1609
1610  if (obj_file)
1611    return obj_file->GetIsDynamicLinkEditor();
1612
1613  return false;
1614}
1615
1616uint32_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(m_object_mod_time);
1625  if (mtime > 0)
1626    id_strm << mtime;
1627  return llvm::djbHash(id_strm.str());
1628}
1629
1630std::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(Hash(), 10);
1637  return strm.str();
1638}
1639
1640DataFileCache *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