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