contrib/llvm/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

   1 //===-- SymbolFileDWARFDebugMap.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 "SymbolFileDWARFDebugMap.h"
  11
  12 #include "DWARFDebugAranges.h"
  13
  14 #include "lldb/Core/Module.h"
  15 #include "lldb/Core/ModuleList.h"
  16 #include "lldb/Core/PluginManager.h"
  17 #include "lldb/Core/RangeMap.h"
  18 #include "lldb/Core/Section.h"
  19 #include "lldb/Host/FileSystem.h"
  20 #include "lldb/Utility/RegularExpression.h"
  21 #include "lldb/Utility/Timer.h"
  22
  23 //#define DEBUG_OSO_DMAP // DO NOT CHECKIN WITH THIS NOT COMMENTED OUT
  24 #if defined(DEBUG_OSO_DMAP)
  25 #include "lldb/Core/StreamFile.h"
  26 #endif
  27
  28 #include "lldb/Symbol/CompileUnit.h"
  29 #include "lldb/Symbol/LineTable.h"
  30 #include "lldb/Symbol/ObjectFile.h"
  31 #include "lldb/Symbol/SymbolVendor.h"
  32 #include "lldb/Symbol/TypeMap.h"
  33 #include "lldb/Symbol/VariableList.h"
  34 #include "llvm/Support/ScopedPrinter.h"
  35
  36 #include "LogChannelDWARF.h"
  37 #include "SymbolFileDWARF.h"
  38
  39 using namespace lldb;
  40 using namespace lldb_private;
  41
  42 // Subclass lldb_private::Module so we can intercept the
  43 // "Module::GetObjectFile()" (so we can fixup the object file sections) and
  44 // also for "Module::GetSymbolVendor()" (so we can fixup the symbol file id.
  45
  46 const SymbolFileDWARFDebugMap::FileRangeMap &
  47 SymbolFileDWARFDebugMap::CompileUnitInfo::GetFileRangeMap(
  48     SymbolFileDWARFDebugMap *exe_symfile) {
  49   if (file_range_map_valid)
  50     return file_range_map;
  51
  52   file_range_map_valid = true;
  53
  54   Module *oso_module = exe_symfile->GetModuleByCompUnitInfo(this);
  55   if (!oso_module)
  56     return file_range_map;
  57
  58   ObjectFile *oso_objfile = oso_module->GetObjectFile();
  59   if (!oso_objfile)
  60     return file_range_map;
  61
  62   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_MAP));
  63   if (log) {
  64     ConstString object_name(oso_module->GetObjectName());
  65     log->Printf(
  66         "%p: SymbolFileDWARFDebugMap::CompileUnitInfo::GetFileRangeMap ('%s')",
  67         static_cast<void *>(this),
  68         oso_module->GetSpecificationDescription().c_str());
  69   }
  70
  71   std::vector<SymbolFileDWARFDebugMap::CompileUnitInfo *> cu_infos;
  72   if (exe_symfile->GetCompUnitInfosForModule(oso_module, cu_infos)) {
  73     for (auto comp_unit_info : cu_infos) {
  74       Symtab *exe_symtab = exe_symfile->GetObjectFile()->GetSymtab();
  75       ModuleSP oso_module_sp(oso_objfile->GetModule());
  76       Symtab *oso_symtab = oso_objfile->GetSymtab();
  77
  78       /// const uint32_t fun_resolve_flags = SymbolContext::Module |
  79       /// eSymbolContextCompUnit | eSymbolContextFunction;
  80       // SectionList *oso_sections = oso_objfile->Sections();
  81       // Now we need to make sections that map from zero based object file
  82       // addresses to where things ended up in the main executable.
  83
  84       assert(comp_unit_info->first_symbol_index != UINT32_MAX);
  85       // End index is one past the last valid symbol index
  86       const uint32_t oso_end_idx = comp_unit_info->last_symbol_index + 1;
  87       for (uint32_t idx = comp_unit_info->first_symbol_index +
  88                           2; // Skip the N_SO and N_OSO
  89            idx < oso_end_idx; ++idx) {
  90         Symbol *exe_symbol = exe_symtab->SymbolAtIndex(idx);
  91         if (exe_symbol) {
  92           if (!exe_symbol->IsDebug())
  93             continue;
  94
  95           switch (exe_symbol->GetType()) {
  96           default:
  97             break;
  98
  99           case eSymbolTypeCode: {
 100             // For each N_FUN, or function that we run into in the debug map we
 101             // make a new section that we add to the sections found in the .o
 102             // file. This new section has the file address set to what the
 103             // addresses are in the .o file, and the load address is adjusted
 104             // to match where it ended up in the final executable! We do this
 105             // before we parse any dwarf info so that when it goes get parsed
 106             // all section/offset addresses that get registered will resolve
 107             // correctly to the new addresses in the main executable.
 108
 109             // First we find the original symbol in the .o file's symbol table
 110             Symbol *oso_fun_symbol = oso_symtab->FindFirstSymbolWithNameAndType(
 111                 exe_symbol->GetMangled().GetName(lldb::eLanguageTypeUnknown,
 112                                                  Mangled::ePreferMangled),
 113                 eSymbolTypeCode, Symtab::eDebugNo, Symtab::eVisibilityAny);
 114             if (oso_fun_symbol) {
 115               // Add the inverse OSO file address to debug map entry mapping
 116               exe_symfile->AddOSOFileRange(
 117                   this, exe_symbol->GetAddressRef().GetFileAddress(),
 118                   exe_symbol->GetByteSize(),
 119                   oso_fun_symbol->GetAddressRef().GetFileAddress(),
 120                   oso_fun_symbol->GetByteSize());
 121             }
 122           } break;
 123
 124           case eSymbolTypeData: {
 125             // For each N_GSYM we remap the address for the global by making a
 126             // new section that we add to the sections found in the .o file.
 127             // This new section has the file address set to what the addresses
 128             // are in the .o file, and the load address is adjusted to match
 129             // where it ended up in the final executable! We do this before we
 130             // parse any dwarf info so that when it goes get parsed all
 131             // section/offset addresses that get registered will resolve
 132             // correctly to the new addresses in the main executable. We
 133             // initially set the section size to be 1 byte, but will need to
 134             // fix up these addresses further after all globals have been
 135             // parsed to span the gaps, or we can find the global variable
 136             // sizes from the DWARF info as we are parsing.
 137
 138             // Next we find the non-stab entry that corresponds to the N_GSYM
 139             // in the .o file
 140             Symbol *oso_gsym_symbol =
 141                 oso_symtab->FindFirstSymbolWithNameAndType(
 142                     exe_symbol->GetMangled().GetName(lldb::eLanguageTypeUnknown,
 143                                                      Mangled::ePreferMangled),
 144                     eSymbolTypeData, Symtab::eDebugNo, Symtab::eVisibilityAny);
 145             if (exe_symbol && oso_gsym_symbol && exe_symbol->ValueIsAddress() &&
 146                 oso_gsym_symbol->ValueIsAddress()) {
 147               // Add the inverse OSO file address to debug map entry mapping
 148               exe_symfile->AddOSOFileRange(
 149                   this, exe_symbol->GetAddressRef().GetFileAddress(),
 150                   exe_symbol->GetByteSize(),
 151                   oso_gsym_symbol->GetAddressRef().GetFileAddress(),
 152                   oso_gsym_symbol->GetByteSize());
 153             }
 154           } break;
 155           }
 156         }
 157       }
 158
 159       exe_symfile->FinalizeOSOFileRanges(this);
 160       // We don't need the symbols anymore for the .o files
 161       oso_objfile->ClearSymtab();
 162     }
 163   }
 164   return file_range_map;
 165 }
 166
 167 class DebugMapModule : public Module {
 168 public:
 169   DebugMapModule(const ModuleSP &exe_module_sp, uint32_t cu_idx,
 170                  const FileSpec &file_spec, const ArchSpec &arch,
 171                  const ConstString *object_name, off_t object_offset,
 172                  const llvm::sys::TimePoint<> object_mod_time)
 173       : Module(file_spec, arch, object_name, object_offset, object_mod_time),
 174         m_exe_module_wp(exe_module_sp), m_cu_idx(cu_idx) {}
 175
 176   ~DebugMapModule() override = default;
 177
 178   SymbolVendor *
 179   GetSymbolVendor(bool can_create = true,
 180                   lldb_private::Stream *feedback_strm = NULL) override {
 181     // Scope for locker
 182     if (m_symfile_ap.get() || !can_create)
 183       return m_symfile_ap.get();
 184
 185     ModuleSP exe_module_sp(m_exe_module_wp.lock());
 186     if (exe_module_sp) {
 187       // Now get the object file outside of a locking scope
 188       ObjectFile *oso_objfile = GetObjectFile();
 189       if (oso_objfile) {
 190         std::lock_guard<std::recursive_mutex> guard(m_mutex);
 191         SymbolVendor *symbol_vendor =
 192             Module::GetSymbolVendor(can_create, feedback_strm);
 193         if (symbol_vendor) {
 194           // Set a pointer to this class to set our OSO DWARF file know that
 195           // the DWARF is being used along with a debug map and that it will
 196           // have the remapped sections that we do below.
 197           SymbolFileDWARF *oso_symfile =
 198               SymbolFileDWARFDebugMap::GetSymbolFileAsSymbolFileDWARF(
 199                   symbol_vendor->GetSymbolFile());
 200
 201           if (!oso_symfile)
 202             return NULL;
 203
 204           ObjectFile *exe_objfile = exe_module_sp->GetObjectFile();
 205           SymbolVendor *exe_sym_vendor = exe_module_sp->GetSymbolVendor();
 206
 207           if (exe_objfile && exe_sym_vendor) {
 208             oso_symfile->SetDebugMapModule(exe_module_sp);
 209             // Set the ID of the symbol file DWARF to the index of the OSO
 210             // shifted left by 32 bits to provide a unique prefix for any
 211             // UserID's that get created in the symbol file.
 212             oso_symfile->SetID(((uint64_t)m_cu_idx + 1ull) << 32ull);
 213           }
 214           return symbol_vendor;
 215         }
 216       }
 217     }
 218     return NULL;
 219   }
 220
 221 protected:
 222   ModuleWP m_exe_module_wp;
 223   const uint32_t m_cu_idx;
 224 };
 225
 226 void SymbolFileDWARFDebugMap::Initialize() {
 227   PluginManager::RegisterPlugin(GetPluginNameStatic(),
 228                                 GetPluginDescriptionStatic(), CreateInstance);
 229 }
 230
 231 void SymbolFileDWARFDebugMap::Terminate() {
 232   PluginManager::UnregisterPlugin(CreateInstance);
 233 }
 234
 235 lldb_private::ConstString SymbolFileDWARFDebugMap::GetPluginNameStatic() {
 236   static ConstString g_name("dwarf-debugmap");
 237   return g_name;
 238 }
 239
 240 const char *SymbolFileDWARFDebugMap::GetPluginDescriptionStatic() {
 241   return "DWARF and DWARF3 debug symbol file reader (debug map).";
 242 }
 243
 244 SymbolFile *SymbolFileDWARFDebugMap::CreateInstance(ObjectFile *obj_file) {
 245   return new SymbolFileDWARFDebugMap(obj_file);
 246 }
 247
 248 SymbolFileDWARFDebugMap::SymbolFileDWARFDebugMap(ObjectFile *ofile)
 249     : SymbolFile(ofile), m_flags(), m_compile_unit_infos(), m_func_indexes(),
 250       m_glob_indexes(),
 251       m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate) {}
 252
 253 SymbolFileDWARFDebugMap::~SymbolFileDWARFDebugMap() {}
 254
 255 void SymbolFileDWARFDebugMap::InitializeObject() {}
 256
 257 void SymbolFileDWARFDebugMap::InitOSO() {
 258   if (m_flags.test(kHaveInitializedOSOs))
 259     return;
 260
 261   m_flags.set(kHaveInitializedOSOs);
 262
 263   // If the object file has been stripped, there is no sense in looking further
 264   // as all of the debug symbols for the debug map will not be available
 265   if (m_obj_file->IsStripped())
 266     return;
 267
 268   // Also make sure the file type is some sort of executable. Core files, debug
 269   // info files (dSYM), object files (.o files), and stub libraries all can
 270   switch (m_obj_file->GetType()) {
 271   case ObjectFile::eTypeInvalid:
 272   case ObjectFile::eTypeCoreFile:
 273   case ObjectFile::eTypeDebugInfo:
 274   case ObjectFile::eTypeObjectFile:
 275   case ObjectFile::eTypeStubLibrary:
 276   case ObjectFile::eTypeUnknown:
 277   case ObjectFile::eTypeJIT:
 278     return;
 279
 280   case ObjectFile::eTypeExecutable:
 281   case ObjectFile::eTypeDynamicLinker:
 282   case ObjectFile::eTypeSharedLibrary:
 283     break;
 284   }
 285
 286   // In order to get the abilities of this plug-in, we look at the list of
 287   // N_OSO entries (object files) from the symbol table and make sure that
 288   // these files exist and also contain valid DWARF. If we get any of that then
 289   // we return the abilities of the first N_OSO's DWARF.
 290
 291   Symtab *symtab = m_obj_file->GetSymtab();
 292   if (symtab) {
 293     Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_MAP));
 294
 295     std::vector<uint32_t> oso_indexes;
 296     // When a mach-o symbol is encoded, the n_type field is encoded in bits
 297     // 23:16, and the n_desc field is encoded in bits 15:0.
 298     //
 299     // To find all N_OSO entries that are part of the DWARF + debug map we find
 300     // only object file symbols with the flags value as follows: bits 23:16 ==
 301     // 0x66 (N_OSO) bits 15: 0 == 0x0001 (specifies this is a debug map object
 302     // file)
 303     const uint32_t k_oso_symbol_flags_value = 0x660001u;
 304
 305     const uint32_t oso_index_count =
 306         symtab->AppendSymbolIndexesWithTypeAndFlagsValue(
 307             eSymbolTypeObjectFile, k_oso_symbol_flags_value, oso_indexes);
 308
 309     if (oso_index_count > 0) {
 310       symtab->AppendSymbolIndexesWithType(eSymbolTypeCode, Symtab::eDebugYes,
 311                                           Symtab::eVisibilityAny,
 312                                           m_func_indexes);
 313       symtab->AppendSymbolIndexesWithType(eSymbolTypeData, Symtab::eDebugYes,
 314                                           Symtab::eVisibilityAny,
 315                                           m_glob_indexes);
 316
 317       symtab->SortSymbolIndexesByValue(m_func_indexes, true);
 318       symtab->SortSymbolIndexesByValue(m_glob_indexes, true);
 319
 320       for (uint32_t sym_idx : m_func_indexes) {
 321         const Symbol *symbol = symtab->SymbolAtIndex(sym_idx);
 322         lldb::addr_t file_addr = symbol->GetAddressRef().GetFileAddress();
 323         lldb::addr_t byte_size = symbol->GetByteSize();
 324         DebugMap::Entry debug_map_entry(
 325             file_addr, byte_size, OSOEntry(sym_idx, LLDB_INVALID_ADDRESS));
 326         m_debug_map.Append(debug_map_entry);
 327       }
 328       for (uint32_t sym_idx : m_glob_indexes) {
 329         const Symbol *symbol = symtab->SymbolAtIndex(sym_idx);
 330         lldb::addr_t file_addr = symbol->GetAddressRef().GetFileAddress();
 331         lldb::addr_t byte_size = symbol->GetByteSize();
 332         DebugMap::Entry debug_map_entry(
 333             file_addr, byte_size, OSOEntry(sym_idx, LLDB_INVALID_ADDRESS));
 334         m_debug_map.Append(debug_map_entry);
 335       }
 336       m_debug_map.Sort();
 337
 338       m_compile_unit_infos.resize(oso_index_count);
 339
 340       for (uint32_t i = 0; i < oso_index_count; ++i) {
 341         const uint32_t so_idx = oso_indexes[i] - 1;
 342         const uint32_t oso_idx = oso_indexes[i];
 343         const Symbol *so_symbol = symtab->SymbolAtIndex(so_idx);
 344         const Symbol *oso_symbol = symtab->SymbolAtIndex(oso_idx);
 345         if (so_symbol && oso_symbol &&
 346             so_symbol->GetType() == eSymbolTypeSourceFile &&
 347             oso_symbol->GetType() == eSymbolTypeObjectFile) {
 348           m_compile_unit_infos[i].so_file.SetFile(
 349               so_symbol->GetName().AsCString(), FileSpec::Style::native);
 350           m_compile_unit_infos[i].oso_path = oso_symbol->GetName();
 351           m_compile_unit_infos[i].oso_mod_time =
 352               llvm::sys::toTimePoint(oso_symbol->GetIntegerValue(0));
 353           uint32_t sibling_idx = so_symbol->GetSiblingIndex();
 354           // The sibling index can't be less that or equal to the current index
 355           // "i"
 356           if (sibling_idx == UINT32_MAX) {
 357             m_obj_file->GetModule()->ReportError(
 358                 "N_SO in symbol with UID %u has invalid sibling in debug map, "
 359                 "please file a bug and attach the binary listed in this error",
 360                 so_symbol->GetID());
 361           } else {
 362             const Symbol *last_symbol = symtab->SymbolAtIndex(sibling_idx - 1);
 363             m_compile_unit_infos[i].first_symbol_index = so_idx;
 364             m_compile_unit_infos[i].last_symbol_index = sibling_idx - 1;
 365             m_compile_unit_infos[i].first_symbol_id = so_symbol->GetID();
 366             m_compile_unit_infos[i].last_symbol_id = last_symbol->GetID();
 367
 368             if (log)
 369               log->Printf("Initialized OSO 0x%8.8x: file=%s", i,
 370                           oso_symbol->GetName().GetCString());
 371           }
 372         } else {
 373           if (oso_symbol == NULL)
 374             m_obj_file->GetModule()->ReportError(
 375                 "N_OSO symbol[%u] can't be found, please file a bug and attach "
 376                 "the binary listed in this error",
 377                 oso_idx);
 378           else if (so_symbol == NULL)
 379             m_obj_file->GetModule()->ReportError(
 380                 "N_SO not found for N_OSO symbol[%u], please file a bug and "
 381                 "attach the binary listed in this error",
 382                 oso_idx);
 383           else if (so_symbol->GetType() != eSymbolTypeSourceFile)
 384             m_obj_file->GetModule()->ReportError(
 385                 "N_SO has incorrect symbol type (%u) for N_OSO symbol[%u], "
 386                 "please file a bug and attach the binary listed in this error",
 387                 so_symbol->GetType(), oso_idx);
 388           else if (oso_symbol->GetType() != eSymbolTypeSourceFile)
 389             m_obj_file->GetModule()->ReportError(
 390                 "N_OSO has incorrect symbol type (%u) for N_OSO symbol[%u], "
 391                 "please file a bug and attach the binary listed in this error",
 392                 oso_symbol->GetType(), oso_idx);
 393         }
 394       }
 395     }
 396   }
 397 }
 398
 399 Module *SymbolFileDWARFDebugMap::GetModuleByOSOIndex(uint32_t oso_idx) {
 400   const uint32_t cu_count = GetNumCompileUnits();
 401   if (oso_idx < cu_count)
 402     return GetModuleByCompUnitInfo(&m_compile_unit_infos[oso_idx]);
 403   return NULL;
 404 }
 405
 406 Module *SymbolFileDWARFDebugMap::GetModuleByCompUnitInfo(
 407     CompileUnitInfo *comp_unit_info) {
 408   if (!comp_unit_info->oso_sp) {
 409     auto pos = m_oso_map.find(
 410         {comp_unit_info->oso_path, comp_unit_info->oso_mod_time});
 411     if (pos != m_oso_map.end()) {
 412       comp_unit_info->oso_sp = pos->second;
 413     } else {
 414       ObjectFile *obj_file = GetObjectFile();
 415       comp_unit_info->oso_sp.reset(new OSOInfo());
 416       m_oso_map[{comp_unit_info->oso_path, comp_unit_info->oso_mod_time}] =
 417           comp_unit_info->oso_sp;
 418       const char *oso_path = comp_unit_info->oso_path.GetCString();
 419       FileSpec oso_file(oso_path);
 420       ConstString oso_object;
 421       if (FileSystem::Instance().Exists(oso_file)) {
 422         // The modification time returned by the FS can have a higher precision
 423         // than the one from the CU.
 424         auto oso_mod_time = std::chrono::time_point_cast<std::chrono::seconds>(
 425             FileSystem::Instance().GetModificationTime(oso_file));
 426         if (oso_mod_time != comp_unit_info->oso_mod_time) {
 427           obj_file->GetModule()->ReportError(
 428               "debug map object file '%s' has changed (actual time is "
 429               "%s, debug map time is %s"
 430               ") since this executable was linked, file will be ignored",
 431               oso_file.GetPath().c_str(), llvm::to_string(oso_mod_time).c_str(),
 432               llvm::to_string(comp_unit_info->oso_mod_time).c_str());
 433           return NULL;
 434         }
 435
 436       } else {
 437         const bool must_exist = true;
 438
 439         if (!ObjectFile::SplitArchivePathWithObject(oso_path, oso_file,
 440                                                     oso_object, must_exist)) {
 441           return NULL;
 442         }
 443       }
 444       // Always create a new module for .o files. Why? Because we use the debug
 445       // map, to add new sections to each .o file and even though a .o file
 446       // might not have changed, the sections that get added to the .o file can
 447       // change.
 448       ArchSpec oso_arch;
 449       // Only adopt the architecture from the module (not the vendor or OS)
 450       // since .o files for "i386-apple-ios" will historically show up as "i386
 451       // -apple-macosx" due to the lack of a LC_VERSION_MIN_MACOSX or
 452       // LC_VERSION_MIN_IPHONEOS load command...
 453       oso_arch.SetTriple(m_obj_file->GetModule()
 454                              ->GetArchitecture()
 455                              .GetTriple()
 456                              .getArchName()
 457                              .str()
 458                              .c_str());
 459       comp_unit_info->oso_sp->module_sp.reset(new DebugMapModule(
 460           obj_file->GetModule(), GetCompUnitInfoIndex(comp_unit_info), oso_file,
 461           oso_arch, oso_object ? &oso_object : NULL, 0,
 462           oso_object ? comp_unit_info->oso_mod_time
 463                      : llvm::sys::TimePoint<>()));
 464     }
 465   }
 466   if (comp_unit_info->oso_sp)
 467     return comp_unit_info->oso_sp->module_sp.get();
 468   return NULL;
 469 }
 470
 471 bool SymbolFileDWARFDebugMap::GetFileSpecForSO(uint32_t oso_idx,
 472                                                FileSpec &file_spec) {
 473   if (oso_idx < m_compile_unit_infos.size()) {
 474     if (m_compile_unit_infos[oso_idx].so_file) {
 475       file_spec = m_compile_unit_infos[oso_idx].so_file;
 476       return true;
 477     }
 478   }
 479   return false;
 480 }
 481
 482 ObjectFile *SymbolFileDWARFDebugMap::GetObjectFileByOSOIndex(uint32_t oso_idx) {
 483   Module *oso_module = GetModuleByOSOIndex(oso_idx);
 484   if (oso_module)
 485     return oso_module->GetObjectFile();
 486   return NULL;
 487 }
 488
 489 SymbolFileDWARF *
 490 SymbolFileDWARFDebugMap::GetSymbolFile(const SymbolContext &sc) {
 491   return GetSymbolFile(*sc.comp_unit);
 492 }
 493
 494 SymbolFileDWARF *
 495 SymbolFileDWARFDebugMap::GetSymbolFile(const CompileUnit &comp_unit) {
 496   CompileUnitInfo *comp_unit_info = GetCompUnitInfo(comp_unit);
 497   if (comp_unit_info)
 498     return GetSymbolFileByCompUnitInfo(comp_unit_info);
 499   return NULL;
 500 }
 501
 502 ObjectFile *SymbolFileDWARFDebugMap::GetObjectFileByCompUnitInfo(
 503     CompileUnitInfo *comp_unit_info) {
 504   Module *oso_module = GetModuleByCompUnitInfo(comp_unit_info);
 505   if (oso_module)
 506     return oso_module->GetObjectFile();
 507   return NULL;
 508 }
 509
 510 uint32_t SymbolFileDWARFDebugMap::GetCompUnitInfoIndex(
 511     const CompileUnitInfo *comp_unit_info) {
 512   if (!m_compile_unit_infos.empty()) {
 513     const CompileUnitInfo *first_comp_unit_info = &m_compile_unit_infos.front();
 514     const CompileUnitInfo *last_comp_unit_info = &m_compile_unit_infos.back();
 515     if (first_comp_unit_info <= comp_unit_info &&
 516         comp_unit_info <= last_comp_unit_info)
 517       return comp_unit_info - first_comp_unit_info;
 518   }
 519   return UINT32_MAX;
 520 }
 521
 522 SymbolFileDWARF *
 523 SymbolFileDWARFDebugMap::GetSymbolFileByOSOIndex(uint32_t oso_idx) {
 524   unsigned size = m_compile_unit_infos.size();
 525   if (oso_idx < size)
 526     return GetSymbolFileByCompUnitInfo(&m_compile_unit_infos[oso_idx]);
 527   return NULL;
 528 }
 529
 530 SymbolFileDWARF *
 531 SymbolFileDWARFDebugMap::GetSymbolFileAsSymbolFileDWARF(SymbolFile *sym_file) {
 532   if (sym_file &&
 533       sym_file->GetPluginName() == SymbolFileDWARF::GetPluginNameStatic())
 534     return (SymbolFileDWARF *)sym_file;
 535   return NULL;
 536 }
 537
 538 SymbolFileDWARF *SymbolFileDWARFDebugMap::GetSymbolFileByCompUnitInfo(
 539     CompileUnitInfo *comp_unit_info) {
 540   Module *oso_module = GetModuleByCompUnitInfo(comp_unit_info);
 541   if (oso_module) {
 542     SymbolVendor *sym_vendor = oso_module->GetSymbolVendor();
 543     if (sym_vendor)
 544       return GetSymbolFileAsSymbolFileDWARF(sym_vendor->GetSymbolFile());
 545   }
 546   return NULL;
 547 }
 548
 549 uint32_t SymbolFileDWARFDebugMap::CalculateAbilities() {
 550   // In order to get the abilities of this plug-in, we look at the list of
 551   // N_OSO entries (object files) from the symbol table and make sure that
 552   // these files exist and also contain valid DWARF. If we get any of that then
 553   // we return the abilities of the first N_OSO's DWARF.
 554
 555   const uint32_t oso_index_count = GetNumCompileUnits();
 556   if (oso_index_count > 0) {
 557     InitOSO();
 558     if (!m_compile_unit_infos.empty()) {
 559       return SymbolFile::CompileUnits | SymbolFile::Functions |
 560              SymbolFile::Blocks | SymbolFile::GlobalVariables |
 561              SymbolFile::LocalVariables | SymbolFile::VariableTypes |
 562              SymbolFile::LineTables;
 563     }
 564   }
 565   return 0;
 566 }
 567
 568 uint32_t SymbolFileDWARFDebugMap::GetNumCompileUnits() {
 569   InitOSO();
 570   return m_compile_unit_infos.size();
 571 }
 572
 573 CompUnitSP SymbolFileDWARFDebugMap::ParseCompileUnitAtIndex(uint32_t cu_idx) {
 574   CompUnitSP comp_unit_sp;
 575   const uint32_t cu_count = GetNumCompileUnits();
 576
 577   if (cu_idx < cu_count) {
 578     Module *oso_module = GetModuleByCompUnitInfo(&m_compile_unit_infos[cu_idx]);
 579     if (oso_module) {
 580       FileSpec so_file_spec;
 581       if (GetFileSpecForSO(cu_idx, so_file_spec)) {
 582         // User zero as the ID to match the compile unit at offset zero in each
 583         // .o file since each .o file can only have one compile unit for now.
 584         lldb::user_id_t cu_id = 0;
 585         m_compile_unit_infos[cu_idx].compile_unit_sp.reset(
 586             new CompileUnit(m_obj_file->GetModule(), NULL, so_file_spec, cu_id,
 587                             eLanguageTypeUnknown, eLazyBoolCalculate));
 588
 589         if (m_compile_unit_infos[cu_idx].compile_unit_sp) {
 590           // Let our symbol vendor know about this compile unit
 591           m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(
 592               cu_idx, m_compile_unit_infos[cu_idx].compile_unit_sp);
 593         }
 594       }
 595     }
 596     comp_unit_sp = m_compile_unit_infos[cu_idx].compile_unit_sp;
 597   }
 598
 599   return comp_unit_sp;
 600 }
 601
 602 SymbolFileDWARFDebugMap::CompileUnitInfo *
 603 SymbolFileDWARFDebugMap::GetCompUnitInfo(const SymbolContext &sc) {
 604   return GetCompUnitInfo(*sc.comp_unit);
 605 }
 606
 607 SymbolFileDWARFDebugMap::CompileUnitInfo *
 608 SymbolFileDWARFDebugMap::GetCompUnitInfo(const CompileUnit &comp_unit) {
 609   const uint32_t cu_count = GetNumCompileUnits();
 610   for (uint32_t i = 0; i < cu_count; ++i) {
 611     if (comp_unit == m_compile_unit_infos[i].compile_unit_sp.get())
 612       return &m_compile_unit_infos[i];
 613   }
 614   return NULL;
 615 }
 616
 617 size_t SymbolFileDWARFDebugMap::GetCompUnitInfosForModule(
 618     const lldb_private::Module *module,
 619     std::vector<CompileUnitInfo *> &cu_infos) {
 620   const uint32_t cu_count = GetNumCompileUnits();
 621   for (uint32_t i = 0; i < cu_count; ++i) {
 622     if (module == GetModuleByCompUnitInfo(&m_compile_unit_infos[i]))
 623       cu_infos.push_back(&m_compile_unit_infos[i]);
 624   }
 625   return cu_infos.size();
 626 }
 627
 628 lldb::LanguageType
 629 SymbolFileDWARFDebugMap::ParseLanguage(CompileUnit &comp_unit) {
 630   SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
 631   if (oso_dwarf)
 632     return oso_dwarf->ParseLanguage(comp_unit);
 633   return eLanguageTypeUnknown;
 634 }
 635
 636 size_t SymbolFileDWARFDebugMap::ParseFunctions(CompileUnit &comp_unit) {
 637   SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
 638   if (oso_dwarf)
 639     return oso_dwarf->ParseFunctions(comp_unit);
 640   return 0;
 641 }
 642
 643 bool SymbolFileDWARFDebugMap::ParseLineTable(CompileUnit &comp_unit) {
 644   SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
 645   if (oso_dwarf)
 646     return oso_dwarf->ParseLineTable(comp_unit);
 647   return false;
 648 }
 649
 650 bool SymbolFileDWARFDebugMap::ParseDebugMacros(CompileUnit &comp_unit) {
 651   SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
 652   if (oso_dwarf)
 653     return oso_dwarf->ParseDebugMacros(comp_unit);
 654   return false;
 655 }
 656
 657 bool SymbolFileDWARFDebugMap::ParseSupportFiles(CompileUnit &comp_unit,
 658                                                 FileSpecList &support_files) {
 659   SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
 660   if (oso_dwarf)
 661     return oso_dwarf->ParseSupportFiles(comp_unit, support_files);
 662   return false;
 663 }
 664
 665 bool SymbolFileDWARFDebugMap::ParseIsOptimized(CompileUnit &comp_unit) {
 666   SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
 667   if (oso_dwarf)
 668     return oso_dwarf->ParseIsOptimized(comp_unit);
 669   return false;
 670 }
 671
 672 bool SymbolFileDWARFDebugMap::ParseImportedModules(
 673     const SymbolContext &sc, std::vector<ConstString> &imported_modules) {
 674   SymbolFileDWARF *oso_dwarf = GetSymbolFile(sc);
 675   if (oso_dwarf)
 676     return oso_dwarf->ParseImportedModules(sc, imported_modules);
 677   return false;
 678 }
 679
 680 size_t SymbolFileDWARFDebugMap::ParseBlocksRecursive(Function &func) {
 681   CompileUnit *comp_unit = func.GetCompileUnit();
 682   if (!comp_unit)
 683     return 0;
 684
 685   SymbolFileDWARF *oso_dwarf = GetSymbolFile(*comp_unit);
 686   if (oso_dwarf)
 687     return oso_dwarf->ParseBlocksRecursive(func);
 688   return 0;
 689 }
 690
 691 size_t SymbolFileDWARFDebugMap::ParseTypes(CompileUnit &comp_unit) {
 692   SymbolFileDWARF *oso_dwarf = GetSymbolFile(comp_unit);
 693   if (oso_dwarf)
 694     return oso_dwarf->ParseTypes(comp_unit);
 695   return 0;
 696 }
 697
 698 size_t
 699 SymbolFileDWARFDebugMap::ParseVariablesForContext(const SymbolContext &sc) {
 700   SymbolFileDWARF *oso_dwarf = GetSymbolFile(sc);
 701   if (oso_dwarf)
 702     return oso_dwarf->ParseVariablesForContext(sc);
 703   return 0;
 704 }
 705
 706 Type *SymbolFileDWARFDebugMap::ResolveTypeUID(lldb::user_id_t type_uid) {
 707   const uint64_t oso_idx = GetOSOIndexFromUserID(type_uid);
 708   SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx);
 709   if (oso_dwarf)
 710     return oso_dwarf->ResolveTypeUID(type_uid);
 711   return NULL;
 712 }
 713
 714 llvm::Optional<SymbolFile::ArrayInfo>
 715 SymbolFileDWARFDebugMap::GetDynamicArrayInfoForUID(
 716     lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
 717   const uint64_t oso_idx = GetOSOIndexFromUserID(type_uid);
 718   SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx);
 719   if (oso_dwarf)
 720     return oso_dwarf->GetDynamicArrayInfoForUID(type_uid, exe_ctx);
 721   return llvm::None;
 722 }
 723
 724 bool SymbolFileDWARFDebugMap::CompleteType(CompilerType &compiler_type) {
 725   bool success = false;
 726   if (compiler_type) {
 727     ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
 728       if (oso_dwarf->HasForwardDeclForClangType(compiler_type)) {
 729         oso_dwarf->CompleteType(compiler_type);
 730         success = true;
 731         return true;
 732       }
 733       return false;
 734     });
 735   }
 736   return success;
 737 }
 738
 739 uint32_t
 740 SymbolFileDWARFDebugMap::ResolveSymbolContext(const Address &exe_so_addr,
 741                                               SymbolContextItem resolve_scope,
 742                                               SymbolContext &sc) {
 743   uint32_t resolved_flags = 0;
 744   Symtab *symtab = m_obj_file->GetSymtab();
 745   if (symtab) {
 746     const addr_t exe_file_addr = exe_so_addr.GetFileAddress();
 747
 748     const DebugMap::Entry *debug_map_entry =
 749         m_debug_map.FindEntryThatContains(exe_file_addr);
 750     if (debug_map_entry) {
 751
 752       sc.symbol =
 753           symtab->SymbolAtIndex(debug_map_entry->data.GetExeSymbolIndex());
 754
 755       if (sc.symbol != NULL) {
 756         resolved_flags |= eSymbolContextSymbol;
 757
 758         uint32_t oso_idx = 0;
 759         CompileUnitInfo *comp_unit_info =
 760             GetCompileUnitInfoForSymbolWithID(sc.symbol->GetID(), &oso_idx);
 761         if (comp_unit_info) {
 762           comp_unit_info->GetFileRangeMap(this);
 763           Module *oso_module = GetModuleByCompUnitInfo(comp_unit_info);
 764           if (oso_module) {
 765             lldb::addr_t oso_file_addr =
 766                 exe_file_addr - debug_map_entry->GetRangeBase() +
 767                 debug_map_entry->data.GetOSOFileAddress();
 768             Address oso_so_addr;
 769             if (oso_module->ResolveFileAddress(oso_file_addr, oso_so_addr)) {
 770               resolved_flags |=
 771                   oso_module->GetSymbolVendor()->ResolveSymbolContext(
 772                       oso_so_addr, resolve_scope, sc);
 773             }
 774           }
 775         }
 776       }
 777     }
 778   }
 779   return resolved_flags;
 780 }
 781
 782 uint32_t SymbolFileDWARFDebugMap::ResolveSymbolContext(
 783     const FileSpec &file_spec, uint32_t line, bool check_inlines,
 784     SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
 785   const uint32_t initial = sc_list.GetSize();
 786   const uint32_t cu_count = GetNumCompileUnits();
 787
 788   for (uint32_t i = 0; i < cu_count; ++i) {
 789     // If we are checking for inlines, then we need to look through all compile
 790     // units no matter if "file_spec" matches.
 791     bool resolve = check_inlines;
 792
 793     if (!resolve) {
 794       FileSpec so_file_spec;
 795       if (GetFileSpecForSO(i, so_file_spec)) {
 796         // Match the full path if the incoming file_spec has a directory (not
 797         // just a basename)
 798         const bool full_match = (bool)file_spec.GetDirectory();
 799         resolve = FileSpec::Equal(file_spec, so_file_spec, full_match);
 800       }
 801     }
 802     if (resolve) {
 803       SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(i);
 804       if (oso_dwarf)
 805         oso_dwarf->ResolveSymbolContext(file_spec, line, check_inlines,
 806                                         resolve_scope, sc_list);
 807     }
 808   }
 809   return sc_list.GetSize() - initial;
 810 }
 811
 812 uint32_t SymbolFileDWARFDebugMap::PrivateFindGlobalVariables(
 813     const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
 814     const std::vector<uint32_t>
 815         &indexes, // Indexes into the symbol table that match "name"
 816     uint32_t max_matches, VariableList &variables) {
 817   const uint32_t original_size = variables.GetSize();
 818   const size_t match_count = indexes.size();
 819   for (size_t i = 0; i < match_count; ++i) {
 820     uint32_t oso_idx;
 821     CompileUnitInfo *comp_unit_info =
 822         GetCompileUnitInfoForSymbolWithIndex(indexes[i], &oso_idx);
 823     if (comp_unit_info) {
 824       SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx);
 825       if (oso_dwarf) {
 826         if (oso_dwarf->FindGlobalVariables(name, parent_decl_ctx, max_matches,
 827                                            variables))
 828           if (variables.GetSize() > max_matches)
 829             break;
 830       }
 831     }
 832   }
 833   return variables.GetSize() - original_size;
 834 }
 835
 836 uint32_t SymbolFileDWARFDebugMap::FindGlobalVariables(
 837     const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
 838     uint32_t max_matches, VariableList &variables) {
 839
 840   // Remember how many variables are in the list before we search.
 841   const uint32_t original_size = variables.GetSize();
 842
 843   uint32_t total_matches = 0;
 844
 845   ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
 846     const uint32_t oso_matches = oso_dwarf->FindGlobalVariables(
 847         name, parent_decl_ctx, max_matches, variables);
 848     if (oso_matches > 0) {
 849       total_matches += oso_matches;
 850
 851       // Are we getting all matches?
 852       if (max_matches == UINT32_MAX)
 853         return false; // Yep, continue getting everything
 854
 855       // If we have found enough matches, lets get out
 856       if (max_matches >= total_matches)
 857         return true;
 858
 859       // Update the max matches for any subsequent calls to find globals in any
 860       // other object files with DWARF
 861       max_matches -= oso_matches;
 862     }
 863
 864     return false;
 865   });
 866
 867   // Return the number of variable that were appended to the list
 868   return variables.GetSize() - original_size;
 869 }
 870
 871 uint32_t
 872 SymbolFileDWARFDebugMap::FindGlobalVariables(const RegularExpression &regex,
 873                                              uint32_t max_matches,
 874                                              VariableList &variables) {
 875   // Remember how many variables are in the list before we search.
 876   const uint32_t original_size = variables.GetSize();
 877
 878   uint32_t total_matches = 0;
 879   ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
 880     const uint32_t oso_matches =
 881         oso_dwarf->FindGlobalVariables(regex, max_matches, variables);
 882     if (oso_matches > 0) {
 883       total_matches += oso_matches;
 884
 885       // Are we getting all matches?
 886       if (max_matches == UINT32_MAX)
 887         return false; // Yep, continue getting everything
 888
 889       // If we have found enough matches, lets get out
 890       if (max_matches >= total_matches)
 891         return true;
 892
 893       // Update the max matches for any subsequent calls to find globals in any
 894       // other object files with DWARF
 895       max_matches -= oso_matches;
 896     }
 897
 898     return false;
 899   });
 900
 901   // Return the number of variable that were appended to the list
 902   return variables.GetSize() - original_size;
 903 }
 904
 905 int SymbolFileDWARFDebugMap::SymbolContainsSymbolWithIndex(
 906     uint32_t *symbol_idx_ptr, const CompileUnitInfo *comp_unit_info) {
 907   const uint32_t symbol_idx = *symbol_idx_ptr;
 908
 909   if (symbol_idx < comp_unit_info->first_symbol_index)
 910     return -1;
 911
 912   if (symbol_idx <= comp_unit_info->last_symbol_index)
 913     return 0;
 914
 915   return 1;
 916 }
 917
 918 int SymbolFileDWARFDebugMap::SymbolContainsSymbolWithID(
 919     user_id_t *symbol_idx_ptr, const CompileUnitInfo *comp_unit_info) {
 920   const user_id_t symbol_id = *symbol_idx_ptr;
 921
 922   if (symbol_id < comp_unit_info->first_symbol_id)
 923     return -1;
 924
 925   if (symbol_id <= comp_unit_info->last_symbol_id)
 926     return 0;
 927
 928   return 1;
 929 }
 930
 931 SymbolFileDWARFDebugMap::CompileUnitInfo *
 932 SymbolFileDWARFDebugMap::GetCompileUnitInfoForSymbolWithIndex(
 933     uint32_t symbol_idx, uint32_t *oso_idx_ptr) {
 934   const uint32_t oso_index_count = m_compile_unit_infos.size();
 935   CompileUnitInfo *comp_unit_info = NULL;
 936   if (oso_index_count) {
 937     comp_unit_info = (CompileUnitInfo *)bsearch(
 938         &symbol_idx, &m_compile_unit_infos[0], m_compile_unit_infos.size(),
 939         sizeof(CompileUnitInfo),
 940         (ComparisonFunction)SymbolContainsSymbolWithIndex);
 941   }
 942
 943   if (oso_idx_ptr) {
 944     if (comp_unit_info != NULL)
 945       *oso_idx_ptr = comp_unit_info - &m_compile_unit_infos[0];
 946     else
 947       *oso_idx_ptr = UINT32_MAX;
 948   }
 949   return comp_unit_info;
 950 }
 951
 952 SymbolFileDWARFDebugMap::CompileUnitInfo *
 953 SymbolFileDWARFDebugMap::GetCompileUnitInfoForSymbolWithID(
 954     user_id_t symbol_id, uint32_t *oso_idx_ptr) {
 955   const uint32_t oso_index_count = m_compile_unit_infos.size();
 956   CompileUnitInfo *comp_unit_info = NULL;
 957   if (oso_index_count) {
 958     comp_unit_info = (CompileUnitInfo *)::bsearch(
 959         &symbol_id, &m_compile_unit_infos[0], m_compile_unit_infos.size(),
 960         sizeof(CompileUnitInfo),
 961         (ComparisonFunction)SymbolContainsSymbolWithID);
 962   }
 963
 964   if (oso_idx_ptr) {
 965     if (comp_unit_info != NULL)
 966       *oso_idx_ptr = comp_unit_info - &m_compile_unit_infos[0];
 967     else
 968       *oso_idx_ptr = UINT32_MAX;
 969   }
 970   return comp_unit_info;
 971 }
 972
 973 static void RemoveFunctionsWithModuleNotEqualTo(const ModuleSP &module_sp,
 974                                                 SymbolContextList &sc_list,
 975                                                 uint32_t start_idx) {
 976   // We found functions in .o files. Not all functions in the .o files will
 977   // have made it into the final output file. The ones that did make it into
 978   // the final output file will have a section whose module matches the module
 979   // from the ObjectFile for this SymbolFile. When the modules don't match,
 980   // then we have something that was in a .o file, but doesn't map to anything
 981   // in the final executable.
 982   uint32_t i = start_idx;
 983   while (i < sc_list.GetSize()) {
 984     SymbolContext sc;
 985     sc_list.GetContextAtIndex(i, sc);
 986     if (sc.function) {
 987       const SectionSP section_sp(
 988           sc.function->GetAddressRange().GetBaseAddress().GetSection());
 989       if (section_sp->GetModule() != module_sp) {
 990         sc_list.RemoveContextAtIndex(i);
 991         continue;
 992       }
 993     }
 994     ++i;
 995   }
 996 }
 997
 998 uint32_t SymbolFileDWARFDebugMap::FindFunctions(
 999     const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
1000     FunctionNameType name_type_mask, bool include_inlines, bool append,
1001     SymbolContextList &sc_list) {
1002   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
1003   Timer scoped_timer(func_cat,
1004                      "SymbolFileDWARFDebugMap::FindFunctions (name = %s)",
1005                      name.GetCString());
1006
1007   uint32_t initial_size = 0;
1008   if (append)
1009     initial_size = sc_list.GetSize();
1010   else
1011     sc_list.Clear();
1012
1013   ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
1014     uint32_t sc_idx = sc_list.GetSize();
1015     if (oso_dwarf->FindFunctions(name, parent_decl_ctx, name_type_mask,
1016                                  include_inlines, true, sc_list)) {
1017       RemoveFunctionsWithModuleNotEqualTo(m_obj_file->GetModule(), sc_list,
1018                                           sc_idx);
1019     }
1020     return false;
1021   });
1022
1023   return sc_list.GetSize() - initial_size;
1024 }
1025
1026 uint32_t SymbolFileDWARFDebugMap::FindFunctions(const RegularExpression &regex,
1027                                                 bool include_inlines,
1028                                                 bool append,
1029                                                 SymbolContextList &sc_list) {
1030   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
1031   Timer scoped_timer(func_cat,
1032                      "SymbolFileDWARFDebugMap::FindFunctions (regex = '%s')",
1033                      regex.GetText().str().c_str());
1034
1035   uint32_t initial_size = 0;
1036   if (append)
1037     initial_size = sc_list.GetSize();
1038   else
1039     sc_list.Clear();
1040
1041   ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
1042     uint32_t sc_idx = sc_list.GetSize();
1043
1044     if (oso_dwarf->FindFunctions(regex, include_inlines, true, sc_list)) {
1045       RemoveFunctionsWithModuleNotEqualTo(m_obj_file->GetModule(), sc_list,
1046                                           sc_idx);
1047     }
1048     return false;
1049   });
1050
1051   return sc_list.GetSize() - initial_size;
1052 }
1053
1054 size_t SymbolFileDWARFDebugMap::GetTypes(SymbolContextScope *sc_scope,
1055                                          lldb::TypeClass type_mask,
1056                                          TypeList &type_list) {
1057   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
1058   Timer scoped_timer(func_cat,
1059                      "SymbolFileDWARFDebugMap::GetTypes (type_mask = 0x%8.8x)",
1060                      type_mask);
1061
1062   uint32_t initial_size = type_list.GetSize();
1063   SymbolFileDWARF *oso_dwarf = NULL;
1064   if (sc_scope) {
1065     SymbolContext sc;
1066     sc_scope->CalculateSymbolContext(&sc);
1067
1068     CompileUnitInfo *cu_info = GetCompUnitInfo(sc);
1069     if (cu_info) {
1070       oso_dwarf = GetSymbolFileByCompUnitInfo(cu_info);
1071       if (oso_dwarf)
1072         oso_dwarf->GetTypes(sc_scope, type_mask, type_list);
1073     }
1074   } else {
1075     ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
1076       oso_dwarf->GetTypes(sc_scope, type_mask, type_list);
1077       return false;
1078     });
1079   }
1080   return type_list.GetSize() - initial_size;
1081 }
1082
1083 std::vector<lldb_private::CallEdge>
1084 SymbolFileDWARFDebugMap::ParseCallEdgesInFunction(UserID func_id) {
1085   uint32_t oso_idx = GetOSOIndexFromUserID(func_id.GetID());
1086   SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx);
1087   if (oso_dwarf)
1088     return oso_dwarf->ParseCallEdgesInFunction(func_id);
1089   return {};
1090 }
1091
1092 TypeSP SymbolFileDWARFDebugMap::FindDefinitionTypeForDWARFDeclContext(
1093     const DWARFDeclContext &die_decl_ctx) {
1094   TypeSP type_sp;
1095   ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
1096     type_sp = oso_dwarf->FindDefinitionTypeForDWARFDeclContext(die_decl_ctx);
1097     return ((bool)type_sp);
1098   });
1099   return type_sp;
1100 }
1101
1102 bool SymbolFileDWARFDebugMap::Supports_DW_AT_APPLE_objc_complete_type(
1103     SymbolFileDWARF *skip_dwarf_oso) {
1104   if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolCalculate) {
1105     m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolNo;
1106     ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
1107       if (skip_dwarf_oso != oso_dwarf &&
1108           oso_dwarf->Supports_DW_AT_APPLE_objc_complete_type(NULL)) {
1109         m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes;
1110         return true;
1111       }
1112       return false;
1113     });
1114   }
1115   return m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolYes;
1116 }
1117
1118 TypeSP SymbolFileDWARFDebugMap::FindCompleteObjCDefinitionTypeForDIE(
1119     const DWARFDIE &die, const ConstString &type_name,
1120     bool must_be_implementation) {
1121   // If we have a debug map, we will have an Objective-C symbol whose name is
1122   // the type name and whose type is eSymbolTypeObjCClass. If we can find that
1123   // symbol and find its containing parent, we can locate the .o file that will
1124   // contain the implementation definition since it will be scoped inside the
1125   // N_SO and we can then locate the SymbolFileDWARF that corresponds to that
1126   // N_SO.
1127   SymbolFileDWARF *oso_dwarf = NULL;
1128   TypeSP type_sp;
1129   ObjectFile *module_objfile = m_obj_file->GetModule()->GetObjectFile();
1130   if (module_objfile) {
1131     Symtab *symtab = module_objfile->GetSymtab();
1132     if (symtab) {
1133       Symbol *objc_class_symbol = symtab->FindFirstSymbolWithNameAndType(
1134           type_name, eSymbolTypeObjCClass, Symtab::eDebugAny,
1135           Symtab::eVisibilityAny);
1136       if (objc_class_symbol) {
1137         // Get the N_SO symbol that contains the objective C class symbol as
1138         // this should be the .o file that contains the real definition...
1139         const Symbol *source_file_symbol = symtab->GetParent(objc_class_symbol);
1140
1141         if (source_file_symbol &&
1142             source_file_symbol->GetType() == eSymbolTypeSourceFile) {
1143           const uint32_t source_file_symbol_idx =
1144               symtab->GetIndexForSymbol(source_file_symbol);
1145           if (source_file_symbol_idx != UINT32_MAX) {
1146             CompileUnitInfo *compile_unit_info =
1147                 GetCompileUnitInfoForSymbolWithIndex(source_file_symbol_idx,
1148                                                      NULL);
1149             if (compile_unit_info) {
1150               oso_dwarf = GetSymbolFileByCompUnitInfo(compile_unit_info);
1151               if (oso_dwarf) {
1152                 TypeSP type_sp(oso_dwarf->FindCompleteObjCDefinitionTypeForDIE(
1153                     die, type_name, must_be_implementation));
1154                 if (type_sp) {
1155                   return type_sp;
1156                 }
1157               }
1158             }
1159           }
1160         }
1161       }
1162     }
1163   }
1164
1165   // Only search all .o files for the definition if we don't need the
1166   // implementation because otherwise, with a valid debug map we should have
1167   // the ObjC class symbol and the code above should have found it.
1168   if (!must_be_implementation) {
1169     TypeSP type_sp;
1170
1171     ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
1172       type_sp = oso_dwarf->FindCompleteObjCDefinitionTypeForDIE(
1173           die, type_name, must_be_implementation);
1174       return (bool)type_sp;
1175     });
1176
1177     return type_sp;
1178   }
1179   return TypeSP();
1180 }
1181
1182 uint32_t SymbolFileDWARFDebugMap::FindTypes(
1183     const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
1184     bool append, uint32_t max_matches,
1185     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
1186     TypeMap &types) {
1187   if (!append)
1188     types.Clear();
1189
1190   const uint32_t initial_types_size = types.GetSize();
1191
1192   ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
1193     oso_dwarf->FindTypes(name, parent_decl_ctx, append, max_matches,
1194                          searched_symbol_files, types);
1195     return types.GetSize() >= max_matches;
1196   });
1197
1198   return types.GetSize() - initial_types_size;
1199 }
1200
1201 //
1202 // uint32_t
1203 // SymbolFileDWARFDebugMap::FindTypes (const SymbolContext& sc, const
1204 // RegularExpression& regex, bool append, uint32_t max_matches, Type::Encoding
1205 // encoding, lldb::user_id_t udt_uid, TypeList& types)
1206 //{
1207 //  SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
1208 //  if (oso_dwarf)
1209 //      return oso_dwarf->FindTypes (sc, regex, append, max_matches, encoding,
1210 //      udt_uid, types);
1211 //  return 0;
1212 //}
1213
1214 CompilerDeclContext SymbolFileDWARFDebugMap::FindNamespace(
1215     const lldb_private::ConstString &name,
1216     const CompilerDeclContext *parent_decl_ctx) {
1217   CompilerDeclContext matching_namespace;
1218
1219   ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
1220     matching_namespace = oso_dwarf->FindNamespace(name, parent_decl_ctx);
1221
1222     return (bool)matching_namespace;
1223   });
1224
1225   return matching_namespace;
1226 }
1227
1228 void SymbolFileDWARFDebugMap::DumpClangAST(Stream &s) {
1229   ForEachSymbolFile([&s](SymbolFileDWARF *oso_dwarf) -> bool {
1230     oso_dwarf->DumpClangAST(s);
1231     return true;
1232   });
1233 }
1234
1235 //------------------------------------------------------------------
1236 // PluginInterface protocol
1237 //------------------------------------------------------------------
1238 lldb_private::ConstString SymbolFileDWARFDebugMap::GetPluginName() {
1239   return GetPluginNameStatic();
1240 }
1241
1242 uint32_t SymbolFileDWARFDebugMap::GetPluginVersion() { return 1; }
1243
1244 lldb::CompUnitSP
1245 SymbolFileDWARFDebugMap::GetCompileUnit(SymbolFileDWARF *oso_dwarf) {
1246   if (oso_dwarf) {
1247     const uint32_t cu_count = GetNumCompileUnits();
1248     for (uint32_t cu_idx = 0; cu_idx < cu_count; ++cu_idx) {
1249       SymbolFileDWARF *oso_symfile =
1250           GetSymbolFileByCompUnitInfo(&m_compile_unit_infos[cu_idx]);
1251       if (oso_symfile == oso_dwarf) {
1252         if (!m_compile_unit_infos[cu_idx].compile_unit_sp)
1253           m_compile_unit_infos[cu_idx].compile_unit_sp =
1254               ParseCompileUnitAtIndex(cu_idx);
1255
1256         return m_compile_unit_infos[cu_idx].compile_unit_sp;
1257       }
1258     }
1259   }
1260   llvm_unreachable("this shouldn't happen");
1261 }
1262
1263 SymbolFileDWARFDebugMap::CompileUnitInfo *
1264 SymbolFileDWARFDebugMap::GetCompileUnitInfo(SymbolFileDWARF *oso_dwarf) {
1265   if (oso_dwarf) {
1266     const uint32_t cu_count = GetNumCompileUnits();
1267     for (uint32_t cu_idx = 0; cu_idx < cu_count; ++cu_idx) {
1268       SymbolFileDWARF *oso_symfile =
1269           GetSymbolFileByCompUnitInfo(&m_compile_unit_infos[cu_idx]);
1270       if (oso_symfile == oso_dwarf) {
1271         return &m_compile_unit_infos[cu_idx];
1272       }
1273     }
1274   }
1275   return NULL;
1276 }
1277
1278 void SymbolFileDWARFDebugMap::SetCompileUnit(SymbolFileDWARF *oso_dwarf,
1279                                              const CompUnitSP &cu_sp) {
1280   if (oso_dwarf) {
1281     const uint32_t cu_count = GetNumCompileUnits();
1282     for (uint32_t cu_idx = 0; cu_idx < cu_count; ++cu_idx) {
1283       SymbolFileDWARF *oso_symfile =
1284           GetSymbolFileByCompUnitInfo(&m_compile_unit_infos[cu_idx]);
1285       if (oso_symfile == oso_dwarf) {
1286         if (m_compile_unit_infos[cu_idx].compile_unit_sp) {
1287           assert(m_compile_unit_infos[cu_idx].compile_unit_sp.get() ==
1288                  cu_sp.get());
1289         } else {
1290           m_compile_unit_infos[cu_idx].compile_unit_sp = cu_sp;
1291           m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(
1292               cu_idx, cu_sp);
1293         }
1294       }
1295     }
1296   }
1297 }
1298
1299 CompilerDeclContext
1300 SymbolFileDWARFDebugMap::GetDeclContextForUID(lldb::user_id_t type_uid) {
1301   const uint64_t oso_idx = GetOSOIndexFromUserID(type_uid);
1302   SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx);
1303   if (oso_dwarf)
1304     return oso_dwarf->GetDeclContextForUID(type_uid);
1305   return CompilerDeclContext();
1306 }
1307
1308 CompilerDeclContext
1309 SymbolFileDWARFDebugMap::GetDeclContextContainingUID(lldb::user_id_t type_uid) {
1310   const uint64_t oso_idx = GetOSOIndexFromUserID(type_uid);
1311   SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx);
1312   if (oso_dwarf)
1313     return oso_dwarf->GetDeclContextContainingUID(type_uid);
1314   return CompilerDeclContext();
1315 }
1316
1317 void SymbolFileDWARFDebugMap::ParseDeclsForContext(
1318     lldb_private::CompilerDeclContext decl_ctx) {
1319   ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
1320     oso_dwarf->ParseDeclsForContext(decl_ctx);
1321     return true; // Keep iterating
1322   });
1323 }
1324
1325 bool SymbolFileDWARFDebugMap::AddOSOFileRange(CompileUnitInfo *cu_info,
1326                                               lldb::addr_t exe_file_addr,
1327                                               lldb::addr_t exe_byte_size,
1328                                               lldb::addr_t oso_file_addr,
1329                                               lldb::addr_t oso_byte_size) {
1330   const uint32_t debug_map_idx =
1331       m_debug_map.FindEntryIndexThatContains(exe_file_addr);
1332   if (debug_map_idx != UINT32_MAX) {
1333     DebugMap::Entry *debug_map_entry =
1334         m_debug_map.FindEntryThatContains(exe_file_addr);
1335     debug_map_entry->data.SetOSOFileAddress(oso_file_addr);
1336     addr_t range_size = std::min<addr_t>(exe_byte_size, oso_byte_size);
1337     if (range_size == 0) {
1338       range_size = std::max<addr_t>(exe_byte_size, oso_byte_size);
1339       if (range_size == 0)
1340         range_size = 1;
1341     }
1342     cu_info->file_range_map.Append(
1343         FileRangeMap::Entry(oso_file_addr, range_size, exe_file_addr));
1344     return true;
1345   }
1346   return false;
1347 }
1348
1349 void SymbolFileDWARFDebugMap::FinalizeOSOFileRanges(CompileUnitInfo *cu_info) {
1350   cu_info->file_range_map.Sort();
1351 #if defined(DEBUG_OSO_DMAP)
1352   const FileRangeMap &oso_file_range_map = cu_info->GetFileRangeMap(this);
1353   const size_t n = oso_file_range_map.GetSize();
1354   printf("SymbolFileDWARFDebugMap::FinalizeOSOFileRanges (cu_info = %p) %s\n",
1355          cu_info, cu_info->oso_sp->module_sp->GetFileSpec().GetPath().c_str());
1356   for (size_t i = 0; i < n; ++i) {
1357     const FileRangeMap::Entry &entry = oso_file_range_map.GetEntryRef(i);
1358     printf("oso [0x%16.16" PRIx64 " - 0x%16.16" PRIx64
1359            ") ==> exe [0x%16.16" PRIx64 " - 0x%16.16" PRIx64 ")\n",
1360            entry.GetRangeBase(), entry.GetRangeEnd(), entry.data,
1361            entry.data + entry.GetByteSize());
1362   }
1363 #endif
1364 }
1365
1366 lldb::addr_t
1367 SymbolFileDWARFDebugMap::LinkOSOFileAddress(SymbolFileDWARF *oso_symfile,
1368                                             lldb::addr_t oso_file_addr) {
1369   CompileUnitInfo *cu_info = GetCompileUnitInfo(oso_symfile);
1370   if (cu_info) {
1371     const FileRangeMap::Entry *oso_range_entry =
1372         cu_info->GetFileRangeMap(this).FindEntryThatContains(oso_file_addr);
1373     if (oso_range_entry) {
1374       const DebugMap::Entry *debug_map_entry =
1375           m_debug_map.FindEntryThatContains(oso_range_entry->data);
1376       if (debug_map_entry) {
1377         const lldb::addr_t offset =
1378             oso_file_addr - oso_range_entry->GetRangeBase();
1379         const lldb::addr_t exe_file_addr =
1380             debug_map_entry->GetRangeBase() + offset;
1381         return exe_file_addr;
1382       }
1383     }
1384   }
1385   return LLDB_INVALID_ADDRESS;
1386 }
1387
1388 bool SymbolFileDWARFDebugMap::LinkOSOAddress(Address &addr) {
1389   // Make sure this address hasn't been fixed already
1390   Module *exe_module = GetObjectFile()->GetModule().get();
1391   Module *addr_module = addr.GetModule().get();
1392   if (addr_module == exe_module)
1393     return true; // Address is already in terms of the main executable module
1394
1395   CompileUnitInfo *cu_info = GetCompileUnitInfo(GetSymbolFileAsSymbolFileDWARF(
1396       addr_module->GetSymbolVendor()->GetSymbolFile()));
1397   if (cu_info) {
1398     const lldb::addr_t oso_file_addr = addr.GetFileAddress();
1399     const FileRangeMap::Entry *oso_range_entry =
1400         cu_info->GetFileRangeMap(this).FindEntryThatContains(oso_file_addr);
1401     if (oso_range_entry) {
1402       const DebugMap::Entry *debug_map_entry =
1403           m_debug_map.FindEntryThatContains(oso_range_entry->data);
1404       if (debug_map_entry) {
1405         const lldb::addr_t offset =
1406             oso_file_addr - oso_range_entry->GetRangeBase();
1407         const lldb::addr_t exe_file_addr =
1408             debug_map_entry->GetRangeBase() + offset;
1409         return exe_module->ResolveFileAddress(exe_file_addr, addr);
1410       }
1411     }
1412   }
1413   return true;
1414 }
1415
1416 LineTable *SymbolFileDWARFDebugMap::LinkOSOLineTable(SymbolFileDWARF *oso_dwarf,
1417                                                      LineTable *line_table) {
1418   CompileUnitInfo *cu_info = GetCompileUnitInfo(oso_dwarf);
1419   if (cu_info)
1420     return line_table->LinkLineTable(cu_info->GetFileRangeMap(this));
1421   return NULL;
1422 }
1423
1424 size_t
1425 SymbolFileDWARFDebugMap::AddOSOARanges(SymbolFileDWARF *dwarf2Data,
1426                                        DWARFDebugAranges *debug_aranges) {
1427   size_t num_line_entries_added = 0;
1428   if (debug_aranges && dwarf2Data) {
1429     CompileUnitInfo *compile_unit_info = GetCompileUnitInfo(dwarf2Data);
1430     if (compile_unit_info) {
1431       const FileRangeMap &file_range_map =
1432           compile_unit_info->GetFileRangeMap(this);
1433       for (size_t idx = 0; idx < file_range_map.GetSize(); idx++) {
1434         const FileRangeMap::Entry *entry = file_range_map.GetEntryAtIndex(idx);
1435         if (entry) {
1436           debug_aranges->AppendRange(dwarf2Data->GetID(), entry->GetRangeBase(),
1437                                      entry->GetRangeEnd());
1438           num_line_entries_added++;
1439         }
1440       }
1441     }
1442   }
1443   return num_line_entries_added;
1444 }