contrib/llvm/tools/lldb/source/Core/Module.cpp

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