Merge branch 'addmainunit3-altlink' into addmainunit3-altlink-sharedstmt
[lldb.git] / lldb / source / Plugins / SymbolFile / DWARF / SymbolFileDWARF.cpp
1 //===-- SymbolFileDWARF.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 "SymbolFileDWARF.h"
10
11 #include "llvm/ADT/Optional.h"
12 #include "llvm/Support/Casting.h"
13 #include "llvm/Support/Threading.h"
14
15 #include "lldb/Core/Module.h"
16 #include "lldb/Core/ModuleList.h"
17 #include "lldb/Core/ModuleSpec.h"
18 #include "lldb/Core/PluginManager.h"
19 #include "lldb/Core/Section.h"
20 #include "lldb/Core/StreamFile.h"
21 #include "lldb/Core/Value.h"
22 #include "lldb/Utility/ArchSpec.h"
23 #include "lldb/Utility/RegularExpression.h"
24 #include "lldb/Utility/Scalar.h"
25 #include "lldb/Utility/StreamString.h"
26 #include "lldb/Utility/Timer.h"
27
28 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
29 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
30
31 #include "lldb/Host/FileSystem.h"
32 #include "lldb/Host/Host.h"
33
34 #include "lldb/Interpreter/OptionValueFileSpecList.h"
35 #include "lldb/Interpreter/OptionValueProperties.h"
36
37 #include "Plugins/ExpressionParser/Clang/ClangUtil.h"
38 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
39 #include "lldb/Symbol/Block.h"
40 #include "lldb/Symbol/CompileUnit.h"
41 #include "lldb/Symbol/CompilerDecl.h"
42 #include "lldb/Symbol/CompilerDeclContext.h"
43 #include "lldb/Symbol/DebugMacros.h"
44 #include "lldb/Symbol/LineTable.h"
45 #include "lldb/Symbol/LocateSymbolFile.h"
46 #include "lldb/Symbol/ObjectFile.h"
47 #include "lldb/Symbol/SymbolFile.h"
48 #include "lldb/Symbol/TypeMap.h"
49 #include "lldb/Symbol/TypeSystem.h"
50 #include "lldb/Symbol/VariableList.h"
51
52 #include "lldb/Target/Language.h"
53 #include "lldb/Target/Target.h"
54
55 #include "AppleDWARFIndex.h"
56 #include "DWARFASTParser.h"
57 #include "DWARFASTParserClang.h"
58 #include "DWARFCompileUnit.h"
59 #include "DWARFDebugAbbrev.h"
60 #include "DWARFDebugAranges.h"
61 #include "DWARFDebugInfo.h"
62 #include "DWARFDebugMacro.h"
63 #include "DWARFDebugRanges.h"
64 #include "DWARFDeclContext.h"
65 #include "DWARFFormValue.h"
66 #include "DWARFTypeUnit.h"
67 #include "DWARFUnit.h"
68 #include "DebugNamesDWARFIndex.h"
69 #include "LogChannelDWARF.h"
70 #include "ManualDWARFIndex.h"
71 #include "SymbolFileDWARFDebugMap.h"
72 #include "SymbolFileDWARFDwo.h"
73
74 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
75 #include "llvm/Support/FileSystem.h"
76
77 #include <algorithm>
78 #include <map>
79 #include <memory>
80
81 #include <ctype.h>
82 #include <string.h>
83
84 //#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN
85
86 #ifdef ENABLE_DEBUG_PRINTF
87 #include <stdio.h>
88 #define DEBUG_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__)
89 #else
90 #define DEBUG_PRINTF(fmt, ...)
91 #endif
92
93 using namespace lldb;
94 using namespace lldb_private;
95
96 LLDB_PLUGIN_DEFINE(SymbolFileDWARF)
97
98 char SymbolFileDWARF::ID;
99
100 // static inline bool
101 // child_requires_parent_class_union_or_struct_to_be_completed (dw_tag_t tag)
102 //{
103 //    switch (tag)
104 //    {
105 //    default:
106 //        break;
107 //    case DW_TAG_subprogram:
108 //    case DW_TAG_inlined_subroutine:
109 //    case DW_TAG_class_type:
110 //    case DW_TAG_structure_type:
111 //    case DW_TAG_union_type:
112 //        return true;
113 //    }
114 //    return false;
115 //}
116 //
117
118 namespace {
119
120 #define LLDB_PROPERTIES_symbolfiledwarf
121 #include "SymbolFileDWARFProperties.inc"
122
123 enum {
124 #define LLDB_PROPERTIES_symbolfiledwarf
125 #include "SymbolFileDWARFPropertiesEnum.inc"
126 };
127
128 class PluginProperties : public Properties {
129 public:
130   static ConstString GetSettingName() {
131     return SymbolFileDWARF::GetPluginNameStatic();
132   }
133
134   PluginProperties() {
135     m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
136     m_collection_sp->Initialize(g_symbolfiledwarf_properties);
137   }
138
139   bool IgnoreFileIndexes() const {
140     return m_collection_sp->GetPropertyAtIndexAsBoolean(
141         nullptr, ePropertyIgnoreIndexes, false);
142   }
143 };
144
145 typedef std::shared_ptr<PluginProperties> SymbolFileDWARFPropertiesSP;
146
147 static const SymbolFileDWARFPropertiesSP &GetGlobalPluginProperties() {
148   static const auto g_settings_sp(std::make_shared<PluginProperties>());
149   return g_settings_sp;
150 }
151
152 } // namespace
153
154 static const llvm::DWARFDebugLine::LineTable *
155 ParseLLVMLineTable(lldb_private::DWARFContext &context,
156                    llvm::DWARFDebugLine &line, dw_offset_t line_offset,
157                    dw_offset_t unit_offset) {
158   Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
159
160   llvm::DWARFDataExtractor data = context.getOrLoadLineData().GetAsLLVM();
161   llvm::DWARFContext &ctx = context.GetAsLLVM();
162   llvm::Expected<const llvm::DWARFDebugLine::LineTable *> line_table =
163       line.getOrParseLineTable(
164           data, line_offset, ctx, nullptr, [&](llvm::Error e) {
165             LLDB_LOG_ERROR(
166                 log, std::move(e),
167                 "SymbolFileDWARF::ParseLineTable failed to parse: {0}");
168           });
169
170   if (!line_table) {
171     LLDB_LOG_ERROR(log, line_table.takeError(),
172                    "SymbolFileDWARF::ParseLineTable failed to parse: {0}");
173     return nullptr;
174   }
175   return *line_table;
176 }
177
178 static bool ParseLLVMLineTablePrologue(lldb_private::DWARFContext &context,
179                                        llvm::DWARFDebugLine::Prologue &prologue,
180                                        dw_offset_t line_offset,
181                                        dw_offset_t unit_offset) {
182   Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
183   bool success = true;
184   llvm::DWARFDataExtractor data = context.getOrLoadLineData().GetAsLLVM();
185   llvm::DWARFContext &ctx = context.GetAsLLVM();
186   uint64_t offset = line_offset;
187   llvm::Error error = prologue.parse(
188       data, &offset,
189       [&](llvm::Error e) {
190         success = false;
191         LLDB_LOG_ERROR(log, std::move(e),
192                        "SymbolFileDWARF::ParseSupportFiles failed to parse "
193                        "line table prologue: {0}");
194       },
195       ctx, nullptr);
196   if (error) {
197     LLDB_LOG_ERROR(log, std::move(error),
198                    "SymbolFileDWARF::ParseSupportFiles failed to parse line "
199                    "table prologue: {0}");
200     return false;
201   }
202   return success;
203 }
204
205 static llvm::Optional<std::string>
206 GetFileByIndex(const llvm::DWARFDebugLine::Prologue &prologue, size_t idx,
207                llvm::StringRef compile_dir, FileSpec::Style style) {
208   // Try to get an absolute path first.
209   std::string abs_path;
210   auto absolute = llvm::DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath;
211   if (prologue.getFileNameByIndex(idx, compile_dir, absolute, abs_path, style))
212     return std::move(abs_path);
213
214   // Otherwise ask for a relative path.
215   std::string rel_path;
216   auto relative = llvm::DILineInfoSpecifier::FileLineInfoKind::RawValue;
217   if (!prologue.getFileNameByIndex(idx, compile_dir, relative, rel_path, style))
218     return {};
219   return std::move(rel_path);
220 }
221
222 static FileSpecList
223 ParseSupportFilesFromPrologue(const lldb::ModuleSP &module,
224                               const llvm::DWARFDebugLine::Prologue &prologue,
225                               FileSpec::Style style,
226                               llvm::StringRef compile_dir = {}) {
227   FileSpecList support_files;
228   size_t first_file = 0;
229   if (prologue.getVersion() <= 4) {
230     // File index 0 is not valid before DWARF v5. Add a dummy entry to ensure
231     // support file list indices match those we get from the debug info and line
232     // tables.
233     support_files.Append(FileSpec());
234     first_file = 1;
235   }
236
237   const size_t number_of_files = prologue.FileNames.size();
238   for (size_t idx = first_file; idx <= number_of_files; ++idx) {
239     std::string remapped_file;
240     if (auto file_path = GetFileByIndex(prologue, idx, compile_dir, style))
241       if (!module->RemapSourceFile(llvm::StringRef(*file_path), remapped_file))
242         remapped_file = std::move(*file_path);
243
244     // Unconditionally add an entry, so the indices match up.
245     support_files.EmplaceBack(remapped_file, style);
246   }
247
248   return support_files;
249 }
250
251 void SymbolFileDWARF::Initialize() {
252   LogChannelDWARF::Initialize();
253   PluginManager::RegisterPlugin(GetPluginNameStatic(),
254                                 GetPluginDescriptionStatic(), CreateInstance,
255                                 DebuggerInitialize);
256   SymbolFileDWARFDebugMap::Initialize();
257 }
258
259 void SymbolFileDWARF::DebuggerInitialize(Debugger &debugger) {
260   if (!PluginManager::GetSettingForSymbolFilePlugin(
261           debugger, PluginProperties::GetSettingName())) {
262     const bool is_global_setting = true;
263     PluginManager::CreateSettingForSymbolFilePlugin(
264         debugger, GetGlobalPluginProperties()->GetValueProperties(),
265         ConstString("Properties for the dwarf symbol-file plug-in."),
266         is_global_setting);
267   }
268 }
269
270 void SymbolFileDWARF::Terminate() {
271   SymbolFileDWARFDebugMap::Terminate();
272   PluginManager::UnregisterPlugin(CreateInstance);
273   LogChannelDWARF::Terminate();
274 }
275
276 lldb_private::ConstString SymbolFileDWARF::GetPluginNameStatic() {
277   static ConstString g_name("dwarf");
278   return g_name;
279 }
280
281 const char *SymbolFileDWARF::GetPluginDescriptionStatic() {
282   return "DWARF and DWARF3 debug symbol file reader.";
283 }
284
285 SymbolFile *SymbolFileDWARF::CreateInstance(ObjectFileSP objfile_sp) {
286   return new SymbolFileDWARF(std::move(objfile_sp),
287                              /*dwo_section_list*/ nullptr);
288 }
289
290 TypeList &SymbolFileDWARF::GetTypeList() {
291   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
292   if (SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile())
293     return debug_map_symfile->GetTypeList();
294   return SymbolFile::GetTypeList();
295 }
296 void SymbolFileDWARF::GetTypes(DWARFUnit *main_unit, const DWARFDIE &die,
297                                dw_offset_t min_die_offset,
298                                dw_offset_t max_die_offset, uint32_t type_mask,
299                                TypeSet &type_set) {
300   if (die) {
301     const dw_offset_t die_offset = die.GetOffset();
302
303     if (die_offset >= max_die_offset)
304       return;
305
306     if (die_offset >= min_die_offset) {
307       const dw_tag_t tag = die.Tag();
308
309       bool add_type = false;
310
311       switch (tag) {
312       case DW_TAG_array_type:
313         add_type = (type_mask & eTypeClassArray) != 0;
314         break;
315       case DW_TAG_unspecified_type:
316       case DW_TAG_base_type:
317         add_type = (type_mask & eTypeClassBuiltin) != 0;
318         break;
319       case DW_TAG_class_type:
320         add_type = (type_mask & eTypeClassClass) != 0;
321         break;
322       case DW_TAG_structure_type:
323         add_type = (type_mask & eTypeClassStruct) != 0;
324         break;
325       case DW_TAG_union_type:
326         add_type = (type_mask & eTypeClassUnion) != 0;
327         break;
328       case DW_TAG_enumeration_type:
329         add_type = (type_mask & eTypeClassEnumeration) != 0;
330         break;
331       case DW_TAG_subroutine_type:
332       case DW_TAG_subprogram:
333       case DW_TAG_inlined_subroutine:
334         add_type = (type_mask & eTypeClassFunction) != 0;
335         break;
336       case DW_TAG_pointer_type:
337         add_type = (type_mask & eTypeClassPointer) != 0;
338         break;
339       case DW_TAG_rvalue_reference_type:
340       case DW_TAG_reference_type:
341         add_type = (type_mask & eTypeClassReference) != 0;
342         break;
343       case DW_TAG_typedef:
344         add_type = (type_mask & eTypeClassTypedef) != 0;
345         break;
346       case DW_TAG_ptr_to_member_type:
347         add_type = (type_mask & eTypeClassMemberPointer) != 0;
348         break;
349       default:
350         break;
351       }
352
353       if (add_type) {
354         const bool assert_not_being_parsed = true;
355         Type *type = ResolveTypeUID(main_unit, die, assert_not_being_parsed);
356         if (type)
357           type_set.insert(type);
358       }
359     }
360
361     for (DWARFDIE child_die = die.GetFirstChild(); child_die.IsValid();
362          child_die = child_die.GetSibling()) {
363       GetTypes(main_unit, child_die, min_die_offset, max_die_offset, type_mask,
364                type_set);
365     }
366   }
367 }
368
369 void SymbolFileDWARF::GetTypes(SymbolContextScope *sc_scope,
370                                TypeClass type_mask, TypeList &type_list)
371
372 {
373   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
374   TypeSet type_set;
375
376   CompileUnit *comp_unit = nullptr;
377   if (sc_scope)
378     comp_unit = sc_scope->CalculateSymbolContextCompileUnit();
379
380   const auto &get = [&](DWARFUnit *unit) {
381     if (!unit)
382       return;
383     unit = &unit->GetNonSkeletonUnit();
384     GetTypes(unit, unit->DIE(), unit->GetOffset(), unit->GetNextUnitOffset(),
385              type_mask, type_set);
386   };
387   if (comp_unit) {
388     get(GetDWARFCompileUnit(comp_unit));
389   } else {
390     DWARFDebugInfo &info = DebugInfo();
391     const size_t num_cus = info.GetNumUnits();
392     for (size_t cu_idx = 0; cu_idx < num_cus; ++cu_idx)
393       get(info.GetUnitAtIndex(cu_idx));
394   }
395
396   std::set<CompilerType> compiler_type_set;
397   for (Type *type : type_set) {
398     CompilerType compiler_type = type->GetForwardCompilerType();
399     if (compiler_type_set.find(compiler_type) == compiler_type_set.end()) {
400       compiler_type_set.insert(compiler_type);
401       type_list.Insert(type->shared_from_this());
402     }
403   }
404 }
405
406 // Gets the first parent that is a lexical block, function or inlined
407 // subroutine, or compile unit.
408 DWARFDIE
409 SymbolFileDWARF::GetParentSymbolContextDIE(const DWARFDIE &child_die) {
410   DWARFDIE die;
411   for (die = child_die.GetParent(); die; die = die.GetParent()) {
412     dw_tag_t tag = die.Tag();
413
414     switch (tag) {
415     case DW_TAG_compile_unit:
416     case DW_TAG_partial_unit:
417     case DW_TAG_subprogram:
418     case DW_TAG_inlined_subroutine:
419     case DW_TAG_lexical_block:
420       return die;
421     default:
422       break;
423     }
424   }
425   return DWARFDIE();
426 }
427
428 SymbolFileDWARF::SymbolFileDWARF(ObjectFileSP objfile_sp,
429                                  SectionList *dwo_section_list)
430     : SymbolFile(std::move(objfile_sp)),
431       UserID(0x7fffffff00000000), // Used by SymbolFileDWARFDebugMap to
432                                   // when this class parses .o files to
433                                   // contain the .o file index/ID
434       m_debug_map_module_wp(), m_debug_map_symfile(nullptr),
435       m_context(m_objfile_sp->GetModule()->GetSectionList(), dwo_section_list),
436       m_fetched_external_modules(false),
437       m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate) {}
438
439 SymbolFileDWARF::~SymbolFileDWARF() {}
440
441 static ConstString GetDWARFMachOSegmentName() {
442   static ConstString g_dwarf_section_name("__DWARF");
443   return g_dwarf_section_name;
444 }
445
446 UniqueDWARFASTTypeMap &SymbolFileDWARF::GetUniqueDWARFASTTypeMap() {
447   SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
448   if (debug_map_symfile)
449     return debug_map_symfile->GetUniqueDWARFASTTypeMap();
450   else
451     return m_unique_ast_type_map;
452 }
453
454 llvm::Expected<TypeSystem &>
455 SymbolFileDWARF::GetTypeSystemForLanguage(LanguageType language) {
456   if (SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile())
457     return debug_map_symfile->GetTypeSystemForLanguage(language);
458
459   auto type_system_or_err =
460       m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
461   if (type_system_or_err) {
462     type_system_or_err->SetSymbolFile(this);
463   }
464   return type_system_or_err;
465 }
466
467 void SymbolFileDWARF::InitializeObject() {
468   Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
469
470   if (!GetGlobalPluginProperties()->IgnoreFileIndexes()) {
471     DWARFDataExtractor apple_names, apple_namespaces, apple_types, apple_objc;
472     LoadSectionData(eSectionTypeDWARFAppleNames, apple_names);
473     LoadSectionData(eSectionTypeDWARFAppleNamespaces, apple_namespaces);
474     LoadSectionData(eSectionTypeDWARFAppleTypes, apple_types);
475     LoadSectionData(eSectionTypeDWARFAppleObjC, apple_objc);
476
477     m_index = AppleDWARFIndex::Create(
478         *GetObjectFile()->GetModule(), apple_names, apple_namespaces,
479         apple_types, apple_objc, m_context.getOrLoadStrData());
480
481     if (m_index)
482       return;
483
484     DWARFDataExtractor debug_names;
485     LoadSectionData(eSectionTypeDWARFDebugNames, debug_names);
486     if (debug_names.GetByteSize() > 0) {
487       llvm::Expected<std::unique_ptr<DebugNamesDWARFIndex>> index_or =
488           DebugNamesDWARFIndex::Create(*GetObjectFile()->GetModule(),
489                                        debug_names,
490                                        m_context.getOrLoadStrData(), *this);
491       if (index_or) {
492         m_index = std::move(*index_or);
493         return;
494       }
495       LLDB_LOG_ERROR(log, index_or.takeError(),
496                      "Unable to read .debug_names data: {0}");
497     }
498   }
499
500   m_index =
501       std::make_unique<ManualDWARFIndex>(*GetObjectFile()->GetModule(), *this);
502 }
503
504 bool SymbolFileDWARF::SupportedVersion(uint16_t version) {
505   return version >= 2 && version <= 5;
506 }
507
508 uint32_t SymbolFileDWARF::CalculateAbilities() {
509   uint32_t abilities = 0;
510   if (m_objfile_sp != nullptr) {
511     const Section *section = nullptr;
512     const SectionList *section_list = m_objfile_sp->GetSectionList();
513     if (section_list == nullptr)
514       return 0;
515
516     uint64_t debug_abbrev_file_size = 0;
517     uint64_t debug_info_file_size = 0;
518     uint64_t debug_line_file_size = 0;
519
520     section = section_list->FindSectionByName(GetDWARFMachOSegmentName()).get();
521
522     if (section)
523       section_list = &section->GetChildren();
524
525     section =
526         section_list->FindSectionByType(eSectionTypeDWARFDebugInfo, true).get();
527     if (section != nullptr) {
528       debug_info_file_size = section->GetFileSize();
529
530       section =
531           section_list->FindSectionByType(eSectionTypeDWARFDebugAbbrev, true)
532               .get();
533       if (section)
534         debug_abbrev_file_size = section->GetFileSize();
535
536       DWARFDebugAbbrev *abbrev = DebugAbbrev();
537       if (abbrev) {
538         std::set<dw_form_t> invalid_forms;
539         abbrev->GetUnsupportedForms(invalid_forms);
540         if (!invalid_forms.empty()) {
541           StreamString error;
542           error.Printf("unsupported DW_FORM value%s:",
543                        invalid_forms.size() > 1 ? "s" : "");
544           for (auto form : invalid_forms)
545             error.Printf(" %#x", form);
546           m_objfile_sp->GetModule()->ReportWarning(
547               "%s", error.GetString().str().c_str());
548           return 0;
549         }
550       }
551
552       section =
553           section_list->FindSectionByType(eSectionTypeDWARFDebugLine, true)
554               .get();
555       if (section)
556         debug_line_file_size = section->GetFileSize();
557     } else {
558       const char *symfile_dir_cstr =
559           m_objfile_sp->GetFileSpec().GetDirectory().GetCString();
560       if (symfile_dir_cstr) {
561         if (strcasestr(symfile_dir_cstr, ".dsym")) {
562           if (m_objfile_sp->GetType() == ObjectFile::eTypeDebugInfo) {
563             // We have a dSYM file that didn't have a any debug info. If the
564             // string table has a size of 1, then it was made from an
565             // executable with no debug info, or from an executable that was
566             // stripped.
567             section =
568                 section_list->FindSectionByType(eSectionTypeDWARFDebugStr, true)
569                     .get();
570             if (section && section->GetFileSize() == 1) {
571               m_objfile_sp->GetModule()->ReportWarning(
572                   "empty dSYM file detected, dSYM was created with an "
573                   "executable with no debug info.");
574             }
575           }
576         }
577       }
578     }
579
580     if (debug_abbrev_file_size > 0 && debug_info_file_size > 0)
581       abilities |= CompileUnits | Functions | Blocks | GlobalVariables |
582                    LocalVariables | VariableTypes;
583
584     if (debug_line_file_size > 0)
585       abilities |= LineTables;
586   }
587   return abilities;
588 }
589
590 void SymbolFileDWARF::LoadSectionData(lldb::SectionType sect_type,
591                                       DWARFDataExtractor &data) {
592   ModuleSP module_sp(m_objfile_sp->GetModule());
593   const SectionList *section_list = module_sp->GetSectionList();
594   if (!section_list)
595     return;
596
597   SectionSP section_sp(section_list->FindSectionByType(sect_type, true));
598   if (!section_sp)
599     return;
600
601   data.Clear();
602   m_objfile_sp->ReadSectionData(section_sp.get(), data);
603 }
604
605 DWARFDebugAbbrev *SymbolFileDWARF::DebugAbbrev() {
606   if (m_abbr)
607     return m_abbr.get();
608
609   const DWARFDataExtractor &debug_abbrev_data = m_context.getOrLoadAbbrevData();
610   if (debug_abbrev_data.GetByteSize() == 0)
611     return nullptr;
612
613   auto abbr = std::make_unique<DWARFDebugAbbrev>();
614   llvm::Error error = abbr->parse(debug_abbrev_data);
615   if (error) {
616     Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
617     LLDB_LOG_ERROR(log, std::move(error),
618                    "Unable to read .debug_abbrev section: {0}");
619     return nullptr;
620   }
621
622   m_abbr = std::move(abbr);
623   return m_abbr.get();
624 }
625
626 DWARFDebugInfo &SymbolFileDWARF::DebugInfo() {
627   llvm::call_once(m_info_once_flag, [&] {
628     LLDB_SCOPED_TIMERF("%s this = %p", LLVM_PRETTY_FUNCTION,
629                        static_cast<void *>(this));
630     m_info = std::make_unique<DWARFDebugInfo>(*this, m_context);
631   });
632   return *m_info;
633 }
634
635 DWARFCompileUnit *SymbolFileDWARF::GetDWARFCompileUnit(CompileUnit *comp_unit) {
636   if (!comp_unit)
637     return nullptr;
638
639   if (SymbolFileDWARFDwo *dwo = llvm::dyn_cast<SymbolFileDWARFDwo>(this))
640     return dwo->GetBaseSymbolFile().GetDWARFCompileUnit(comp_unit);
641
642   // The compile unit ID is the index of the DWARF unit.
643   DWARFUnit *dwarf_cu = DebugInfo().GetUnitAtIndex(comp_unit->GetID());
644   if (!dwarf_cu)
645     return nullptr;
646
647   if (dwarf_cu->GetUserData() == nullptr)
648     dwarf_cu->SetUserData(comp_unit);
649   else
650     lldbassert(dwarf_cu->GetUserData() == comp_unit);
651
652   // It must be DWARFCompileUnit when it created a CompileUnit.
653   return llvm::cast<DWARFCompileUnit>(dwarf_cu);
654 }
655
656 DWARFDebugRanges *SymbolFileDWARF::GetDebugRanges() {
657   if (!m_ranges) {
658     LLDB_SCOPED_TIMERF("%s this = %p", LLVM_PRETTY_FUNCTION,
659                        static_cast<void *>(this));
660
661     if (m_context.getOrLoadRangesData().GetByteSize() > 0)
662       m_ranges = std::make_unique<DWARFDebugRanges>();
663
664     if (m_ranges)
665       m_ranges->Extract(m_context);
666   }
667   return m_ranges.get();
668 }
669
670 /// Make an absolute path out of \p file_spec and remap it using the
671 /// module's source remapping dictionary.
672 static void MakeAbsoluteAndRemap(FileSpec &file_spec, DWARFUnit &dwarf_cu,
673                                  const ModuleSP &module_sp) {
674   if (!file_spec)
675     return;
676   // If we have a full path to the compile unit, we don't need to
677   // resolve the file.  This can be expensive e.g. when the source
678   // files are NFS mounted.
679   file_spec.MakeAbsolute(dwarf_cu.GetCompilationDirectory());
680
681   std::string remapped_file;
682   if (module_sp->RemapSourceFile(file_spec.GetPath(), remapped_file))
683     file_spec.SetFile(remapped_file, FileSpec::Style::native);
684 }
685
686 lldb::CompUnitSP SymbolFileDWARF::ParseCompileUnit(DWARFCompileUnit &dwarf_cu) {
687   CompUnitSP cu_sp;
688   CompileUnit *comp_unit = (CompileUnit *)dwarf_cu.GetUserData();
689   if (comp_unit) {
690     // We already parsed this compile unit, had out a shared pointer to it
691     cu_sp = comp_unit->shared_from_this();
692   } else {
693     if (dwarf_cu.GetOffset() == 0 && GetDebugMapSymfile()) {
694       // Let the debug map create the compile unit
695       cu_sp = m_debug_map_symfile->GetCompileUnit(this);
696       dwarf_cu.SetUserData(cu_sp.get());
697     } else {
698       ModuleSP module_sp(m_objfile_sp->GetModule());
699       if (module_sp) {
700         const DWARFBaseDIE cu_die =
701             dwarf_cu.GetNonSkeletonUnit().GetUnitDIEOnly();
702         if (cu_die) {
703           FileSpec cu_file_spec(cu_die.GetName(), dwarf_cu.GetPathStyle());
704           MakeAbsoluteAndRemap(cu_file_spec, dwarf_cu, module_sp);
705
706           LanguageType cu_language = SymbolFileDWARF::LanguageTypeFromDWARF(
707               cu_die.GetAttributeValueAsUnsigned(DW_AT_language, 0));
708
709           bool is_optimized = dwarf_cu.GetNonSkeletonUnit().GetIsOptimized();
710           BuildCuTranslationTable();
711           cu_sp = std::make_shared<CompileUnit>(
712               module_sp, &dwarf_cu, cu_file_spec,
713               *GetDWARFUnitIndex(dwarf_cu.GetID()), cu_language,
714               is_optimized ? eLazyBoolYes : eLazyBoolNo);
715
716           lldbassert(cu_sp->GetID()==*GetDWARFUnitIndex(dwarf_cu.GetID()));
717           dwarf_cu.SetUserData(cu_sp.get());
718
719           SetCompileUnitAtIndex(dwarf_cu.GetID(), cu_sp);
720         }
721       }
722     }
723   }
724   return cu_sp;
725 }
726
727 void SymbolFileDWARF::BuildCuTranslationTable() {
728   if (!m_lldb_cu_to_dwarf_unit.empty())
729     return;
730
731   DWARFDebugInfo &info = DebugInfo();
732   if (!info.ContainsTypeUnits()) {
733     // We can use a 1-to-1 mapping. No need to build a translation table.
734     return;
735   }
736   for (uint32_t i = 0, num = info.GetNumUnits(); i < num; ++i) {
737     if (auto *cu = llvm::dyn_cast<DWARFCompileUnit>(info.GetUnitAtIndex(i))) {
738       cu->SetID(m_lldb_cu_to_dwarf_unit.size());
739       m_lldb_cu_to_dwarf_unit.push_back(i);
740     }
741   }
742 }
743
744 llvm::Optional<uint32_t> SymbolFileDWARF::GetDWARFUnitIndex(uint32_t cu_idx) {
745   BuildCuTranslationTable();
746   if (m_lldb_cu_to_dwarf_unit.empty())
747     return cu_idx;
748   if (cu_idx >= m_lldb_cu_to_dwarf_unit.size())
749     return llvm::None;
750   return m_lldb_cu_to_dwarf_unit[cu_idx];
751 }
752
753 uint32_t SymbolFileDWARF::CalculateNumCompileUnits() {
754   BuildCuTranslationTable();
755   return m_lldb_cu_to_dwarf_unit.empty() ? DebugInfo().GetNumUnits()
756                                          : m_lldb_cu_to_dwarf_unit.size();
757 }
758
759 CompUnitSP SymbolFileDWARF::ParseCompileUnitAtIndex(uint32_t cu_idx) {
760   ASSERT_MODULE_LOCK(this);
761   if (llvm::Optional<uint32_t> dwarf_idx = GetDWARFUnitIndex(cu_idx)) {
762     if (auto *dwarf_cu = llvm::cast_or_null<DWARFCompileUnit>(
763             DebugInfo().GetUnitAtIndex(*dwarf_idx)))
764       return ParseCompileUnit(*dwarf_cu);
765   }
766   return {};
767 }
768
769 Function *SymbolFileDWARF::ParseFunction(CompileUnit &comp_unit,
770                                          const DWARFDIE &die) {
771   ASSERT_MODULE_LOCK(this);
772   if (!die.IsValid())
773     return nullptr;
774
775   DWARFUnit *main_unit = comp_unit.GetDWARFCompileUnit();
776
777   auto type_system_or_err = GetTypeSystemForLanguage(GetLanguage(*die.GetMainDWARFUnit(main_unit)));
778   if (auto err = type_system_or_err.takeError()) {
779     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
780                    std::move(err), "Unable to parse function");
781     return nullptr;
782   }
783   DWARFASTParser *dwarf_ast = type_system_or_err->GetDWARFParser();
784   if (!dwarf_ast)
785     return nullptr;
786
787   return dwarf_ast->ParseFunctionFromDWARF(comp_unit, die);
788 }
789
790 lldb::addr_t SymbolFileDWARF::FixupAddress(lldb::addr_t file_addr) {
791   SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
792   if (debug_map_symfile)
793     return debug_map_symfile->LinkOSOFileAddress(this, file_addr);
794   return file_addr;
795 }
796
797 bool SymbolFileDWARF::FixupAddress(Address &addr) {
798   SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
799   if (debug_map_symfile) {
800     return debug_map_symfile->LinkOSOAddress(addr);
801   }
802   // This is a normal DWARF file, no address fixups need to happen
803   return true;
804 }
805 lldb::LanguageType SymbolFileDWARF::ParseLanguage(CompileUnit &comp_unit) {
806   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
807   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
808   if (dwarf_cu)
809     return GetLanguage(*dwarf_cu);
810   else
811     return eLanguageTypeUnknown;
812 }
813
814 XcodeSDK SymbolFileDWARF::ParseXcodeSDK(CompileUnit &comp_unit) {
815   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
816   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
817   if (!dwarf_cu)
818     return {};
819   const DWARFBaseDIE cu_die = dwarf_cu->GetNonSkeletonUnit().GetUnitDIEOnly();
820   if (!cu_die)
821     return {};
822   const char *sdk = cu_die.GetAttributeValueAsString(DW_AT_APPLE_sdk, nullptr);
823   if (!sdk)
824     return {};
825   const char *sysroot =
826       cu_die.GetAttributeValueAsString(DW_AT_LLVM_sysroot, "");
827   // Register the sysroot path remapping with the module belonging to
828   // the CU as well as the one belonging to the symbol file. The two
829   // would be different if this is an OSO object and module is the
830   // corresponding debug map, in which case both should be updated.
831   ModuleSP module_sp = comp_unit.GetModule();
832   if (module_sp)
833     module_sp->RegisterXcodeSDK(sdk, sysroot);
834
835   ModuleSP local_module_sp = m_objfile_sp->GetModule();
836   if (local_module_sp && local_module_sp != module_sp)
837     local_module_sp->RegisterXcodeSDK(sdk, sysroot);
838
839   return {sdk};
840 }
841
842 size_t SymbolFileDWARF::ParseFunctions(CompileUnit &comp_unit) {
843   LLDB_SCOPED_TIMER();
844   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
845   DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
846   if (!dwarf_cu)
847     return 0;
848
849   size_t functions_added = 0;
850   dwarf_cu = &dwarf_cu->GetNonSkeletonUnit();
851   for (DWARFDebugInfoEntry &entry : dwarf_cu->dies()) {
852     if (entry.Tag() != DW_TAG_subprogram)
853       continue;
854
855     DWARFDIE die(dwarf_cu, &entry);
856     if (comp_unit.FindFunctionByUID(die.GetID(dwarf_cu)))
857       continue;
858     if (ParseFunction(comp_unit, die))
859       ++functions_added;
860   }
861   // FixupTypes();
862   return functions_added;
863 }
864
865 bool SymbolFileDWARF::ForEachExternalModule(
866     CompileUnit &comp_unit,
867     llvm::DenseSet<lldb_private::SymbolFile *> &visited_symbol_files,
868     llvm::function_ref<bool(Module &)> lambda) {
869   // Only visit each symbol file once.
870   if (!visited_symbol_files.insert(this).second)
871     return false;
872
873   UpdateExternalModuleListIfNeeded();
874   for (auto &p : m_external_type_modules) {
875     ModuleSP module = p.second;
876     if (!module)
877       continue;
878
879     // Invoke the action and potentially early-exit.
880     if (lambda(*module))
881       return true;
882
883     for (std::size_t i = 0; i < module->GetNumCompileUnits(); ++i) {
884       auto cu = module->GetCompileUnitAtIndex(i);
885       bool early_exit = cu->ForEachExternalModule(visited_symbol_files, lambda);
886       if (early_exit)
887         return true;
888     }
889   }
890   return false;
891 }
892
893 bool SymbolFileDWARF::ParseSupportFiles(CompileUnit &comp_unit,
894                                         FileSpecList &support_files) {
895   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
896   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
897   if (!dwarf_cu)
898     return false;
899
900   dw_offset_t offset = dwarf_cu->GetLineTableOffset();
901   if (offset == DW_INVALID_OFFSET)
902     return false;
903
904   llvm::DWARFDebugLine::Prologue prologue;
905   if (!ParseLLVMLineTablePrologue(m_context, prologue, offset,
906                                   dwarf_cu->GetOffset()))
907     return false;
908
909   comp_unit.SetSupportFiles(ParseSupportFilesFromPrologue(
910       comp_unit.GetModule(), prologue, dwarf_cu->GetPathStyle(),
911       dwarf_cu->GetCompilationDirectory().GetCString()));
912
913   return true;
914 }
915
916 FileSpec SymbolFileDWARF::GetFile(DWARFUnit &unit, size_t file_idx) {
917   if (auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(&unit)) {
918     if (CompileUnit *lldb_cu = GetCompUnitForDWARFCompUnit(*dwarf_cu))
919       return lldb_cu->GetSupportFiles().GetFileSpecAtIndex(file_idx);
920     return FileSpec();
921   }
922
923   return GetSharedUnitSupportFiles(unit).GetFileSpecAtIndex(file_idx);
924 }
925
926 const FileSpecList &
927 SymbolFileDWARF::GetSharedUnitSupportFiles(DWARFUnit &unit) {
928   static FileSpecList empty_list;
929
930   dw_offset_t offset = unit.GetLineTableOffset();
931   if (offset == DW_INVALID_OFFSET ||
932       offset == llvm::DenseMapInfo<dw_offset_t>::getEmptyKey() ||
933       offset == llvm::DenseMapInfo<dw_offset_t>::getTombstoneKey())
934     return empty_list;
935
936   // Many type units can share a line table, so parse the support file list
937   // once, and cache it based on the offset field.
938   auto iter_bool = m_shared_unit_support_files.try_emplace(offset);
939   FileSpecList &list = iter_bool.first->second;
940   if (iter_bool.second) {
941     uint64_t line_table_offset = offset;
942     llvm::DWARFDataExtractor data = m_context.getOrLoadLineData().GetAsLLVM();
943     llvm::DWARFContext &ctx = m_context.GetAsLLVM();
944     llvm::DWARFDebugLine::Prologue prologue;
945     auto report = [](llvm::Error error) {
946       Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
947       LLDB_LOG_ERROR(log, std::move(error),
948                      "SymbolFileDWARF::GetSharedUnitSupportFiles failed to parse "
949                      "the line table prologue");
950     };
951     llvm::Error error = prologue.parse(data, &line_table_offset, report, ctx);
952     if (error) {
953       report(std::move(error));
954     } else {
955       list = ParseSupportFilesFromPrologue(GetObjectFile()->GetModule(),
956                                            prologue, unit.GetPathStyle());
957     }
958   }
959   return list;
960 }
961
962 bool SymbolFileDWARF::ParseIsOptimized(CompileUnit &comp_unit) {
963   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
964   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
965   if (dwarf_cu)
966     return dwarf_cu->GetIsOptimized();
967   return false;
968 }
969
970 bool SymbolFileDWARF::ParseImportedModules(
971     const lldb_private::SymbolContext &sc,
972     std::vector<SourceModule> &imported_modules) {
973   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
974   SymbolFileDWARF *dwarf_check;
975   DWARFUnit *dwarf_cu = sc.GetDWARFCompileUnit(&dwarf_check);
976   lldbassert(dwarf_check == this);
977   if (!dwarf_cu)
978     return false;
979   if (!ClangModulesDeclVendor::LanguageSupportsClangModules(
980           sc.comp_unit->GetLanguage()))
981     return false;
982   UpdateExternalModuleListIfNeeded();
983
984   const DWARFDIE die = dwarf_cu->DIE();
985   if (!die)
986     return false;
987
988   for (DWARFDIE child_die = die.GetFirstChild(); child_die;
989        child_die = child_die.GetSibling()) {
990     if (child_die.Tag() != DW_TAG_imported_declaration)
991       continue;
992
993     DWARFDIE module_die = child_die.GetReferencedDIE(DW_AT_import);
994     if (module_die.Tag() != DW_TAG_module)
995       continue;
996
997     if (const char *name =
998             module_die.GetAttributeValueAsString(DW_AT_name, nullptr)) {
999       SourceModule module;
1000       module.path.push_back(ConstString(name));
1001
1002       DWARFDIE parent_die = module_die;
1003       while ((parent_die = parent_die.GetParent())) {
1004         if (parent_die.Tag() != DW_TAG_module)
1005           break;
1006         if (const char *name =
1007                 parent_die.GetAttributeValueAsString(DW_AT_name, nullptr))
1008           module.path.push_back(ConstString(name));
1009       }
1010       std::reverse(module.path.begin(), module.path.end());
1011       if (const char *include_path = module_die.GetAttributeValueAsString(
1012               DW_AT_LLVM_include_path, nullptr)) {
1013         FileSpec include_spec(include_path, dwarf_cu->GetPathStyle());
1014         MakeAbsoluteAndRemap(include_spec, *dwarf_cu, m_objfile_sp->GetModule());
1015         module.search_path = ConstString(include_spec.GetPath());
1016       }
1017       if (const char *sysroot = dwarf_cu->DIE().GetAttributeValueAsString(
1018               DW_AT_LLVM_sysroot, nullptr))
1019         module.sysroot = ConstString(sysroot);
1020       imported_modules.push_back(module);
1021     }
1022   }
1023   return true;
1024 }
1025
1026 bool SymbolFileDWARF::ParseLineTable(CompileUnit &comp_unit) {
1027   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1028   if (comp_unit.GetLineTable() != nullptr)
1029     return true;
1030
1031   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
1032   if (!dwarf_cu)
1033     return false;
1034
1035   dw_offset_t offset = dwarf_cu->GetLineTableOffset();
1036   if (offset == DW_INVALID_OFFSET)
1037     return false;
1038
1039   llvm::DWARFDebugLine line;
1040   const llvm::DWARFDebugLine::LineTable *line_table =
1041       ParseLLVMLineTable(m_context, line, offset, dwarf_cu->GetOffset());
1042
1043   if (!line_table)
1044     return false;
1045
1046   // FIXME: Rather than parsing the whole line table and then copying it over
1047   // into LLDB, we should explore using a callback to populate the line table
1048   // while we parse to reduce memory usage.
1049   std::vector<std::unique_ptr<LineSequence>> sequences;
1050   // The Sequences view contains only valid line sequences. Don't iterate over
1051   // the Rows directly.
1052   for (const llvm::DWARFDebugLine::Sequence &seq : line_table->Sequences) {
1053     std::unique_ptr<LineSequence> sequence =
1054         LineTable::CreateLineSequenceContainer();
1055     for (unsigned idx = seq.FirstRowIndex; idx < seq.LastRowIndex; ++idx) {
1056       const llvm::DWARFDebugLine::Row &row = line_table->Rows[idx];
1057       LineTable::AppendLineEntryToSequence(
1058           sequence.get(), row.Address.Address, row.Line, row.Column, row.File,
1059           row.IsStmt, row.BasicBlock, row.PrologueEnd, row.EpilogueBegin,
1060           row.EndSequence);
1061     }
1062     sequences.push_back(std::move(sequence));
1063   }
1064
1065   std::unique_ptr<LineTable> line_table_up =
1066       std::make_unique<LineTable>(&comp_unit, std::move(sequences));
1067
1068   if (SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile()) {
1069     // We have an object file that has a line table with addresses that are not
1070     // linked. We need to link the line table and convert the addresses that
1071     // are relative to the .o file into addresses for the main executable.
1072     comp_unit.SetLineTable(
1073         debug_map_symfile->LinkOSOLineTable(this, line_table_up.get()));
1074   } else {
1075     comp_unit.SetLineTable(line_table_up.release());
1076   }
1077
1078   return true;
1079 }
1080
1081 lldb_private::DebugMacrosSP
1082 SymbolFileDWARF::ParseDebugMacros(lldb::offset_t *offset) {
1083   auto iter = m_debug_macros_map.find(*offset);
1084   if (iter != m_debug_macros_map.end())
1085     return iter->second;
1086
1087   const DWARFDataExtractor &debug_macro_data = m_context.getOrLoadMacroData();
1088   if (debug_macro_data.GetByteSize() == 0)
1089     return DebugMacrosSP();
1090
1091   lldb_private::DebugMacrosSP debug_macros_sp(new lldb_private::DebugMacros());
1092   m_debug_macros_map[*offset] = debug_macros_sp;
1093
1094   const DWARFDebugMacroHeader &header =
1095       DWARFDebugMacroHeader::ParseHeader(debug_macro_data, offset);
1096   DWARFDebugMacroEntry::ReadMacroEntries(
1097       debug_macro_data, m_context.getOrLoadStrData(), header.OffsetIs64Bit(),
1098       offset, this, debug_macros_sp);
1099
1100   return debug_macros_sp;
1101 }
1102
1103 bool SymbolFileDWARF::ParseDebugMacros(CompileUnit &comp_unit) {
1104   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1105
1106   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
1107   if (dwarf_cu == nullptr)
1108     return false;
1109
1110   const DWARFBaseDIE dwarf_cu_die = dwarf_cu->GetUnitDIEOnly();
1111   if (!dwarf_cu_die)
1112     return false;
1113
1114   lldb::offset_t sect_offset =
1115       dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_macros, DW_INVALID_OFFSET);
1116   if (sect_offset == DW_INVALID_OFFSET)
1117     sect_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_GNU_macros,
1118                                                            DW_INVALID_OFFSET);
1119   if (sect_offset == DW_INVALID_OFFSET)
1120     return false;
1121
1122   comp_unit.SetDebugMacros(ParseDebugMacros(&sect_offset));
1123
1124   return true;
1125 }
1126
1127 size_t SymbolFileDWARF::ParseBlocksRecursive(
1128     lldb_private::CompileUnit &comp_unit, Block *parent_block,
1129     const DWARFDIE &orig_die, addr_t subprogram_low_pc, uint32_t depth) {
1130   size_t blocks_added = 0;
1131   DWARFDIE die = orig_die;
1132   while (die) {
1133     dw_tag_t tag = die.Tag();
1134
1135     switch (tag) {
1136     case DW_TAG_inlined_subroutine:
1137     case DW_TAG_subprogram:
1138     case DW_TAG_lexical_block: {
1139       Block *block = nullptr;
1140       if (tag == DW_TAG_subprogram) {
1141         // Skip any DW_TAG_subprogram DIEs that are inside of a normal or
1142         // inlined functions. These will be parsed on their own as separate
1143         // entities.
1144
1145         if (depth > 0)
1146           break;
1147
1148         block = parent_block;
1149       } else {
1150         DWARFCompileUnit *dwarf_cu = comp_unit.GetDWARFCompileUnit();
1151         BlockSP block_sp(new Block(die.GetID(dwarf_cu)));
1152         parent_block->AddChild(block_sp);
1153         block = block_sp.get();
1154       }
1155       DWARFRangeList ranges;
1156       const char *name = nullptr;
1157       const char *mangled_name = nullptr;
1158
1159       int decl_file = 0;
1160       int decl_line = 0;
1161       int decl_column = 0;
1162       int call_file = 0;
1163       int call_line = 0;
1164       int call_column = 0;
1165       if (die.GetDIENamesAndRanges(name, mangled_name, ranges, decl_file,
1166                                    decl_line, decl_column, call_file, call_line,
1167                                    call_column, nullptr)) {
1168         if (tag == DW_TAG_subprogram) {
1169           assert(subprogram_low_pc == LLDB_INVALID_ADDRESS);
1170           subprogram_low_pc = ranges.GetMinRangeBase(0);
1171         } else if (tag == DW_TAG_inlined_subroutine) {
1172           // We get called here for inlined subroutines in two ways. The first
1173           // time is when we are making the Function object for this inlined
1174           // concrete instance.  Since we're creating a top level block at
1175           // here, the subprogram_low_pc will be LLDB_INVALID_ADDRESS.  So we
1176           // need to adjust the containing address. The second time is when we
1177           // are parsing the blocks inside the function that contains the
1178           // inlined concrete instance.  Since these will be blocks inside the
1179           // containing "real" function the offset will be for that function.
1180           if (subprogram_low_pc == LLDB_INVALID_ADDRESS) {
1181             subprogram_low_pc = ranges.GetMinRangeBase(0);
1182           }
1183         }
1184
1185         const size_t num_ranges = ranges.GetSize();
1186         for (size_t i = 0; i < num_ranges; ++i) {
1187           const DWARFRangeList::Entry &range = ranges.GetEntryRef(i);
1188           const addr_t range_base = range.GetRangeBase();
1189           if (range_base >= subprogram_low_pc)
1190             block->AddRange(Block::Range(range_base - subprogram_low_pc,
1191                                          range.GetByteSize()));
1192           else {
1193             GetObjectFile()->GetModule()->ReportError(
1194                 "0x%8.8" PRIx64 ": adding range [0x%" PRIx64 "-0x%" PRIx64
1195                 ") which has a base that is less than the function's low PC "
1196                 "0x%" PRIx64 ". Please file a bug and attach the file at the "
1197                 "start of this error message",
1198                 block->GetID(), range_base, range.GetRangeEnd(),
1199                 subprogram_low_pc);
1200           }
1201         }
1202         block->FinalizeRanges();
1203
1204         if (tag != DW_TAG_subprogram &&
1205             (name != nullptr || mangled_name != nullptr)) {
1206           std::unique_ptr<Declaration> decl_up;
1207           if (decl_file != 0 || decl_line != 0 || decl_column != 0)
1208             decl_up = std::make_unique<Declaration>(
1209                 comp_unit.GetSupportFiles().GetFileSpecAtIndex(decl_file),
1210                 decl_line, decl_column);
1211
1212           std::unique_ptr<Declaration> call_up;
1213           if (call_file != 0 || call_line != 0 || call_column != 0)
1214             call_up = std::make_unique<Declaration>(
1215                 comp_unit.GetSupportFiles().GetFileSpecAtIndex(call_file),
1216                 call_line, call_column);
1217
1218           block->SetInlinedFunctionInfo(name, mangled_name, decl_up.get(),
1219                                         call_up.get());
1220         }
1221
1222         ++blocks_added;
1223
1224         if (die.HasChildren()) {
1225           blocks_added +=
1226               ParseBlocksRecursive(comp_unit, block, die.GetFirstChild(),
1227                                    subprogram_low_pc, depth + 1);
1228         }
1229       }
1230     } break;
1231     default:
1232       break;
1233     }
1234
1235     // Only parse siblings of the block if we are not at depth zero. A depth of
1236     // zero indicates we are currently parsing the top level DW_TAG_subprogram
1237     // DIE
1238
1239     if (depth == 0)
1240       die.Clear();
1241     else
1242       die = die.GetSibling();
1243   }
1244   return blocks_added;
1245 }
1246
1247 bool SymbolFileDWARF::ClassOrStructIsVirtual(const DWARFDIE &parent_die) {
1248   if (parent_die) {
1249     for (DWARFDIE die = parent_die.GetFirstChild(); die;
1250          die = die.GetSibling()) {
1251       dw_tag_t tag = die.Tag();
1252       bool check_virtuality = false;
1253       switch (tag) {
1254       case DW_TAG_inheritance:
1255       case DW_TAG_subprogram:
1256         check_virtuality = true;
1257         break;
1258       default:
1259         break;
1260       }
1261       if (check_virtuality) {
1262         if (die.GetAttributeValueAsUnsigned(DW_AT_virtuality, 0) != 0)
1263           return true;
1264       }
1265     }
1266   }
1267   return false;
1268 }
1269
1270 void SymbolFileDWARF::ParseDeclsForContext(CompilerDeclContext decl_ctx) {
1271   auto *type_system = decl_ctx.GetTypeSystem();
1272   if (type_system != nullptr)
1273     type_system->GetDWARFParser()->EnsureAllDIEsInDeclContextHaveBeenParsed(
1274         decl_ctx);
1275 }
1276
1277 user_id_t SymbolFileDWARF::GetUID(DWARFUnit *main_unit,
1278                                   const DWARFDIE &die) {
1279   if (!die.IsValid())
1280     return LLDB_INVALID_UID;
1281   // if (die.GetCU()->GetUnitDIEOnly().Tag() != DW_TAG_partial_unit)
1282   main_unit = nullptr;
1283   return GetUID(main_unit, die.GetDIERef(main_unit));
1284 }
1285
1286 user_id_t SymbolFileDWARF::GetUID(DWARFUnit *main_unit, DIERef ref) {
1287   if (GetDebugMapSymfile())
1288     return GetID() | ref.die_offset();
1289
1290   if (main_unit)
1291     main_unit = &main_unit->GetNonSkeletonUnit();
1292   if (ref.dwo_num().hasValue())
1293     lldbassert(main_unit == nullptr);
1294
1295 #ifndef NDEBUG
1296   DWARFDIE dwarfdie_check = GetDIE(ref);
1297   lldbassert(dwarfdie_check.IsValid());
1298   lldbassert(*dwarfdie_check.GetDIERef(main_unit) == ref);
1299 #endif
1300
1301   // WARNING: Use ref.dwo_num() as GetDwoNum() may not be valid in 'this'.
1302   static_assert(sizeof(ref.die_offset()) * 8 == 32, "");
1303   lldbassert(!ref.dwo_num().hasValue()||*ref.dwo_num()<=0x3fffffff);
1304   user_id_t retval = user_id_t(ref.dwo_num().getValueOr(0)) << 32 |
1305          ref.die_offset() |
1306          lldb::user_id_t(ref.dwo_num().hasValue()) << 62 |
1307          lldb::user_id_t(ref.section() == DIERef::Section::DebugTypes) << 63;
1308
1309 #ifndef NDEBUG
1310   DWARFUnit *main_unit_check;
1311   DWARFDIE dwarfdie_check2 = GetDIEUnlocked(retval, &main_unit_check);
1312   lldbassert(dwarfdie_check2 == dwarfdie_check);
1313 #endif
1314
1315   return retval;
1316 }
1317
1318 llvm::Optional<SymbolFileDWARF::DecodedUID>
1319 SymbolFileDWARF::DecodeUIDUnlocked(lldb::user_id_t uid) {
1320   // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API we
1321   // must make sure we use the correct DWARF file when resolving things. On
1322   // MacOSX, when using SymbolFileDWARFDebugMap, we will use multiple
1323   // SymbolFileDWARF classes, one for each .o file. We can often end up with
1324   // references to other DWARF objects and we must be ready to receive a
1325   // "lldb::user_id_t" that specifies a DIE from another SymbolFileDWARF
1326   // instance.
1327   if (SymbolFileDWARFDebugMap *debug_map = GetDebugMapSymfile()) {
1328     SymbolFileDWARF *dwarf = debug_map->GetSymbolFileByOSOIndex(
1329         debug_map->GetOSOIndexFromUserID(uid));
1330     return DecodedUID{
1331         *dwarf, {llvm::None, DIERef::Section::DebugInfo, dw_offset_t(uid)}};
1332   }
1333   dw_offset_t die_offset = uid;
1334   if (die_offset == DW_INVALID_OFFSET)
1335     return llvm::None;
1336
1337   DIERef::Section section =
1338       uid >> 63 ? DIERef::Section::DebugTypes : DIERef::Section::DebugInfo;
1339
1340   llvm::Optional<uint32_t> dwo_num;
1341   bool dwo_valid = uid >> 62 & 1;
1342   if (dwo_valid)
1343     dwo_num = uid >> 32 & 0x3fffffff;
1344
1345   return DecodedUID{*this, {dwo_num, section, die_offset}};
1346 }
1347
1348 llvm::Optional<SymbolFileDWARF::DecodedUID>
1349 SymbolFileDWARF::DecodeUID(lldb::user_id_t uid) {
1350   // This method can be called without going through the symbol vendor so we
1351   // need to lock the module.
1352   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1353
1354   return DecodeUIDUnlocked(uid);
1355 }
1356
1357 DWARFDIE
1358 SymbolFileDWARF::GetDIEUnlocked(lldb::user_id_t uid,
1359                                 DWARFUnit **main_unit_return) {
1360   llvm::Optional<DecodedUID> decoded = DecodeUIDUnlocked(uid);
1361
1362   if (decoded) {
1363     DWARFDIE die = decoded->dwarf.GetDIE(decoded->ref, main_unit_return);
1364     return die;
1365   }
1366
1367   return DWARFDIE();
1368 }
1369
1370 DWARFDIE
1371 SymbolFileDWARF::GetDIE(lldb::user_id_t uid) {
1372   // This method can be called without going through the symbol vendor so we
1373   // need to lock the module.
1374   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1375
1376   return GetDIEUnlocked(uid);
1377 }
1378
1379 CompilerDecl SymbolFileDWARF::GetDeclForUID(lldb::user_id_t type_uid) {
1380   // This method can be called without going through the symbol vendor so we
1381   // need to lock the module.
1382   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1383   // Anytime we have a lldb::user_id_t, we must get the DIE by calling
1384   // SymbolFileDWARF::GetDIE(). See comments inside the
1385   // SymbolFileDWARF::GetDIE() for details.
1386   DWARFUnit *main_unit;
1387   if (DWARFDIE die = GetDIEUnlocked(type_uid, &main_unit))
1388     return GetDecl(main_unit, die);
1389   return CompilerDecl();
1390 }
1391
1392 CompilerDeclContext
1393 SymbolFileDWARF::GetDeclContextForUID(lldb::user_id_t type_uid) {
1394   // This method can be called without going through the symbol vendor so we
1395   // need to lock the module.
1396   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1397   // Anytime we have a lldb::user_id_t, we must get the DIE by calling
1398   // SymbolFileDWARF::GetDIE(). See comments inside the
1399   // SymbolFileDWARF::GetDIE() for details.
1400   DWARFUnit *main_unit;
1401   if (DWARFDIE die = GetDIEUnlocked(type_uid, &main_unit))
1402     return GetDeclContext(main_unit, die);
1403   return CompilerDeclContext();
1404 }
1405
1406 CompilerDeclContext
1407 SymbolFileDWARF::GetDeclContextContainingUID(lldb::user_id_t type_uid) {
1408   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1409   // Anytime we have a lldb::user_id_t, we must get the DIE by calling
1410   // SymbolFileDWARF::GetDIE(). See comments inside the
1411   // SymbolFileDWARF::GetDIE() for details.
1412   DWARFUnit *main_unit;
1413   if (DWARFDIE die = GetDIEUnlocked(type_uid, &main_unit))
1414     return GetContainingDeclContext(main_unit, die);
1415   return CompilerDeclContext();
1416 }
1417
1418 Type *SymbolFileDWARF::ResolveTypeUID(lldb::user_id_t type_uid) {
1419   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1420   // Anytime we have a lldb::user_id_t, we must get the DIE by calling
1421   // SymbolFileDWARF::GetDIE(). See comments inside the
1422   // SymbolFileDWARF::GetDIE() for details.
1423   DWARFUnit *main_unit;
1424   if (DWARFDIE type_die = GetDIEUnlocked(type_uid, &main_unit))
1425     return type_die.ResolveType(main_unit);
1426   else
1427     return nullptr;
1428 }
1429
1430 llvm::Optional<SymbolFile::ArrayInfo>
1431 SymbolFileDWARF::GetDynamicArrayInfoForUID(
1432     lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
1433   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1434   if (DWARFDIE type_die = GetDIE(type_uid))
1435     return DWARFASTParser::ParseChildArrayInfo(type_die, exe_ctx);
1436   else
1437     return llvm::None;
1438 }
1439
1440 Type *SymbolFileDWARF::ResolveTypeUID(DWARFUnit *main_unit,
1441                                       const DIERef &die_ref) {
1442   return ResolveType(main_unit, GetDIE(die_ref), true);
1443 }
1444
1445 Type *SymbolFileDWARF::ResolveTypeUID(DWARFUnit *main_unit,
1446                                       const DWARFDIE &die,
1447                                       bool assert_not_being_parsed) {
1448   if (die) {
1449     Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
1450     if (log)
1451       GetObjectFile()->GetModule()->LogMessage(
1452           log, "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s'",
1453           die.GetOffset(), die.GetTagAsCString(), die.GetName());
1454
1455     // We might be coming in in the middle of a type tree (a class within a
1456     // class, an enum within a class), so parse any needed parent DIEs before
1457     // we get to this one...
1458     DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(die);
1459     if (decl_ctx_die) {
1460       if (log) {
1461         switch (decl_ctx_die.Tag()) {
1462         case DW_TAG_structure_type:
1463         case DW_TAG_union_type:
1464         case DW_TAG_class_type: {
1465           // Get the type, which could be a forward declaration
1466           if (log)
1467             GetObjectFile()->GetModule()->LogMessage(
1468                 log,
1469                 "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s' "
1470                 "resolve parent forward type for 0x%8.8x",
1471                 die.GetOffset(), die.GetTagAsCString(), die.GetName(),
1472                 decl_ctx_die.GetOffset());
1473         } break;
1474
1475         default:
1476           break;
1477         }
1478       }
1479     }
1480     return ResolveType(main_unit, die);
1481   }
1482   return nullptr;
1483 }
1484
1485 // This function is used when SymbolFileDWARFDebugMap owns a bunch of
1486 // SymbolFileDWARF objects to detect if this DWARF file is the one that can
1487 // resolve a compiler_type.
1488 bool SymbolFileDWARF::HasForwardDeclForClangType(
1489     const CompilerType &compiler_type) {
1490   CompilerType compiler_type_no_qualifiers =
1491       ClangUtil::RemoveFastQualifiers(compiler_type);
1492   if (GetForwardDeclClangTypeToDie().count(
1493           compiler_type_no_qualifiers.GetOpaqueQualType())) {
1494     return true;
1495   }
1496   TypeSystem *type_system = compiler_type.GetTypeSystem();
1497
1498   TypeSystemClang *clang_type_system =
1499       llvm::dyn_cast_or_null<TypeSystemClang>(type_system);
1500   if (!clang_type_system)
1501     return false;
1502   DWARFASTParserClang *ast_parser =
1503       static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser());
1504   return ast_parser->GetClangASTImporter().CanImport(compiler_type);
1505 }
1506
1507 bool SymbolFileDWARF::CompleteType(CompilerType &compiler_type) {
1508   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1509
1510   TypeSystemClang *clang_type_system =
1511       llvm::dyn_cast_or_null<TypeSystemClang>(compiler_type.GetTypeSystem());
1512   if (clang_type_system) {
1513     DWARFASTParserClang *ast_parser =
1514         static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser());
1515     if (ast_parser &&
1516         ast_parser->GetClangASTImporter().CanImport(compiler_type))
1517       return ast_parser->GetClangASTImporter().CompleteType(compiler_type);
1518   }
1519
1520   // We have a struct/union/class/enum that needs to be fully resolved.
1521   CompilerType compiler_type_no_qualifiers =
1522       ClangUtil::RemoveFastQualifiers(compiler_type);
1523   auto die_it = GetForwardDeclClangTypeToDie().find(
1524       compiler_type_no_qualifiers.GetOpaqueQualType());
1525   if (die_it == GetForwardDeclClangTypeToDie().end()) {
1526     // We have already resolved this type...
1527     return true;
1528   }
1529
1530   DWARFUnit *main_unit;
1531   DWARFDIE dwarf_die = GetDIEUnlocked(die_it->getSecond(), &main_unit);
1532   if (dwarf_die) {
1533     // Once we start resolving this type, remove it from the forward
1534     // declaration map in case anyone child members or other types require this
1535     // type to get resolved. The type will get resolved when all of the calls
1536     // to SymbolFileDWARF::ResolveClangOpaqueTypeDefinition are done.
1537     GetForwardDeclClangTypeToDie().erase(die_it);
1538
1539     Type *type = GetDIEToType().lookup(dwarf_die.MainCUtoDIEPair(main_unit));
1540     lldbassert(type);
1541
1542     Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO |
1543                                           DWARF_LOG_TYPE_COMPLETION));
1544     if (log)
1545       GetObjectFile()->GetModule()->LogMessageVerboseBacktrace(
1546           log, "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...",
1547           dwarf_die.GetID(nullptr), dwarf_die.GetTagAsCString(),
1548           type->GetName().AsCString());
1549     assert(compiler_type);
1550     if (DWARFASTParser *dwarf_ast = GetDWARFParser(*dwarf_die.GetMainDWARFUnit(main_unit)))
1551       return dwarf_ast->CompleteTypeFromDWARF(main_unit, dwarf_die, type, compiler_type);
1552   }
1553   return false;
1554 }
1555
1556 Type *SymbolFileDWARF::ResolveType(DWARFUnit *main_unit,
1557                                    const DWARFDIE &die,
1558                                    bool assert_not_being_parsed,
1559                                    bool resolve_function_context) {
1560   if (die) {
1561     Type *type = GetTypeForDIE(main_unit, die, resolve_function_context).get();
1562
1563     if (assert_not_being_parsed) {
1564       if (type != DIE_IS_BEING_PARSED)
1565         return type;
1566
1567       GetObjectFile()->GetModule()->ReportError(
1568           "Parsing a die that is being parsed die: 0x%8.8x: %s %s",
1569           die.GetOffset(), die.GetTagAsCString(), die.GetName());
1570
1571     } else
1572       return type;
1573   }
1574   return nullptr;
1575 }
1576
1577 CompileUnit *
1578 SymbolFileDWARF::GetCompUnitForDWARFCompUnit(DWARFCompileUnit &dwarf_cu) {
1579   if (dwarf_cu.IsDWOUnit()) {
1580     DWARFCompileUnit *non_dwo_cu =
1581         static_cast<DWARFCompileUnit *>(dwarf_cu.GetUserData());
1582     assert(non_dwo_cu);
1583     return non_dwo_cu->GetSymbolFileDWARF().GetCompUnitForDWARFCompUnit(
1584         *non_dwo_cu);
1585   }
1586   // Check if the symbol vendor already knows about this compile unit?
1587   if (dwarf_cu.GetUserData() == nullptr) {
1588     // The symbol vendor doesn't know about this compile unit, we need to parse
1589     // and add it to the symbol vendor object.
1590     return ParseCompileUnit(dwarf_cu).get();
1591   }
1592   return static_cast<CompileUnit *>(dwarf_cu.GetUserData());
1593 }
1594
1595 void SymbolFileDWARF::GetObjCMethods(
1596     ConstString class_name,
1597     llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
1598         callback) {
1599   m_index->GetObjCMethods(class_name, callback);
1600 }
1601
1602 bool SymbolFileDWARF::GetFunction(DWARFUnit *main_unit,
1603                                   const DWARFDIE &die, SymbolContext &sc) {
1604   sc.Clear(false);
1605   if (!die)
1606     return false;
1607
1608   // Check if the symbol vendor already knows about this compile unit?
1609   DWARFCompileUnit *main_cu = llvm::dyn_cast_or_null<DWARFCompileUnit>(main_unit);
1610   if (!main_cu)
1611     return false;
1612   sc.comp_unit = main_cu->GetCompUnit();
1613
1614   sc.function = sc.comp_unit->FindFunctionByUID(die.GetID(main_unit)).get();
1615   if (sc.function == nullptr)
1616     sc.function = ParseFunction(*sc.comp_unit, die);
1617   if (sc.function == nullptr)
1618     return false;
1619
1620   sc.module_sp = sc.function->CalculateSymbolContextModule();
1621   return true;
1622 }
1623
1624 lldb::ModuleSP SymbolFileDWARF::GetExternalModule(ConstString name) {
1625   UpdateExternalModuleListIfNeeded();
1626   const auto &pos = m_external_type_modules.find(name);
1627   if (pos != m_external_type_modules.end())
1628     return pos->second;
1629   else
1630     return lldb::ModuleSP();
1631 }
1632
1633 DWARFDIE
1634 SymbolFileDWARF::GetDIE(const DIERef &die_ref, DWARFUnit **main_unit_return) {
1635   if (die_ref.dwo_num()) {
1636     SymbolFileDWARF *dwarf = *die_ref.dwo_num() == 0x3fffffff
1637                                  ? m_dwp_symfile.get()
1638                                  : this->DebugInfo()
1639                                        .GetUnitAtIndex(*die_ref.dwo_num())
1640                                        ->GetDwoSymbolFile();
1641     return dwarf->DebugInfo().GetDIE(die_ref, main_unit_return);
1642   }
1643
1644   return DebugInfo().GetDIE(die_ref, main_unit_return);
1645 }
1646
1647 /// Return the DW_AT_(GNU_)dwo_name.
1648 static const char *GetDWOName(DWARFCompileUnit &dwarf_cu,
1649                               const DWARFDebugInfoEntry &cu_die) {
1650   const char *dwo_name =
1651       cu_die.GetAttributeValueAsString(&dwarf_cu, DW_AT_GNU_dwo_name, nullptr);
1652   if (!dwo_name)
1653     dwo_name =
1654         cu_die.GetAttributeValueAsString(&dwarf_cu, DW_AT_dwo_name, nullptr);
1655   return dwo_name;
1656 }
1657
1658 /// Return the DW_AT_(GNU_)dwo_id.
1659 /// FIXME: Technically 0 is a valid hash.
1660 static uint64_t GetDWOId(DWARFCompileUnit &dwarf_cu,
1661                          const DWARFDebugInfoEntry &cu_die) {
1662   uint64_t dwo_id =
1663       cu_die.GetAttributeValueAsUnsigned(&dwarf_cu, DW_AT_GNU_dwo_id, 0);
1664   if (!dwo_id)
1665     dwo_id = cu_die.GetAttributeValueAsUnsigned(&dwarf_cu, DW_AT_dwo_id, 0);
1666   return dwo_id;
1667 }
1668
1669 llvm::Optional<uint64_t> SymbolFileDWARF::GetDWOId() {
1670   if (GetNumCompileUnits() == 1) {
1671     if (auto comp_unit = GetCompileUnitAtIndex(0))
1672       if (DWARFCompileUnit *cu = GetDWARFCompileUnit(comp_unit.get()))
1673         if (DWARFDebugInfoEntry *cu_die = cu->DIE().GetDIE())
1674           if (uint64_t dwo_id = ::GetDWOId(*cu, *cu_die))
1675             return dwo_id;
1676   }
1677   return {};
1678 }
1679
1680 std::shared_ptr<SymbolFileDWARFDwo>
1681 SymbolFileDWARF::GetDwoSymbolFileForCompileUnit(
1682     DWARFUnit &unit, const DWARFDebugInfoEntry &cu_die) {
1683   // If this is a Darwin-style debug map (non-.dSYM) symbol file,
1684   // never attempt to load ELF-style DWO files since the -gmodules
1685   // support uses the same DWO machanism to specify full debug info
1686   // files for modules. This is handled in
1687   // UpdateExternalModuleListIfNeeded().
1688   if (GetDebugMapSymfile())
1689     return nullptr;
1690
1691   DWARFCompileUnit *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(&unit);
1692   // Only compile units can be split into two parts.
1693   if (!dwarf_cu)
1694     return nullptr;
1695
1696   const char *dwo_name = GetDWOName(*dwarf_cu, cu_die);
1697   if (!dwo_name)
1698     return nullptr;
1699
1700   if (std::shared_ptr<SymbolFileDWARFDwo> dwp_sp = GetDwpSymbolFile())
1701     return dwp_sp;
1702
1703   FileSpec dwo_file(dwo_name);
1704   FileSystem::Instance().Resolve(dwo_file);
1705   if (dwo_file.IsRelative()) {
1706     const char *comp_dir =
1707         cu_die.GetAttributeValueAsString(dwarf_cu, DW_AT_comp_dir, nullptr);
1708     if (!comp_dir)
1709       return nullptr;
1710
1711     dwo_file.SetFile(comp_dir, FileSpec::Style::native);
1712     FileSystem::Instance().Resolve(dwo_file);
1713     dwo_file.AppendPathComponent(dwo_name);
1714   }
1715
1716   if (!FileSystem::Instance().Exists(dwo_file))
1717     return nullptr;
1718
1719   const lldb::offset_t file_offset = 0;
1720   DataBufferSP dwo_file_data_sp;
1721   lldb::offset_t dwo_file_data_offset = 0;
1722   ObjectFileSP dwo_obj_file = ObjectFile::FindPlugin(
1723       GetObjectFile()->GetModule(), &dwo_file, file_offset,
1724       FileSystem::Instance().GetByteSize(dwo_file), dwo_file_data_sp,
1725       dwo_file_data_offset);
1726   if (dwo_obj_file == nullptr)
1727     return nullptr;
1728
1729   return std::make_shared<SymbolFileDWARFDwo>(*this, dwo_obj_file,
1730                                               dwarf_cu->GetID());
1731 }
1732
1733 void SymbolFileDWARF::UpdateExternalModuleListIfNeeded() {
1734   if (m_fetched_external_modules)
1735     return;
1736   m_fetched_external_modules = true;
1737   DWARFDebugInfo &debug_info = DebugInfo();
1738
1739   // Follow DWO skeleton unit breadcrumbs.
1740   const uint32_t num_compile_units = GetNumCompileUnits();
1741   for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
1742     auto *dwarf_cu =
1743         llvm::dyn_cast<DWARFCompileUnit>(debug_info.GetUnitAtIndex(cu_idx));
1744     if (!dwarf_cu)
1745       continue;
1746
1747     const DWARFBaseDIE die = dwarf_cu->GetUnitDIEOnly();
1748     if (!die || die.HasChildren() || !die.GetDIE())
1749       continue;
1750
1751     const char *name = die.GetAttributeValueAsString(DW_AT_name, nullptr);
1752     if (!name)
1753       continue;
1754
1755     ConstString const_name(name);
1756     ModuleSP &module_sp = m_external_type_modules[const_name];
1757     if (module_sp)
1758       continue;
1759
1760     const char *dwo_path = GetDWOName(*dwarf_cu, *die.GetDIE());
1761     if (!dwo_path)
1762       continue;
1763
1764     ModuleSpec dwo_module_spec;
1765     dwo_module_spec.GetFileSpec().SetFile(dwo_path, FileSpec::Style::native);
1766     if (dwo_module_spec.GetFileSpec().IsRelative()) {
1767       const char *comp_dir =
1768           die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr);
1769       if (comp_dir) {
1770         dwo_module_spec.GetFileSpec().SetFile(comp_dir,
1771                                               FileSpec::Style::native);
1772         FileSystem::Instance().Resolve(dwo_module_spec.GetFileSpec());
1773         dwo_module_spec.GetFileSpec().AppendPathComponent(dwo_path);
1774       }
1775     }
1776     dwo_module_spec.GetArchitecture() =
1777         m_objfile_sp->GetModule()->GetArchitecture();
1778
1779     // When LLDB loads "external" modules it looks at the presence of
1780     // DW_AT_dwo_name. However, when the already created module
1781     // (corresponding to .dwo itself) is being processed, it will see
1782     // the presence of DW_AT_dwo_name (which contains the name of dwo
1783     // file) and will try to call ModuleList::GetSharedModule
1784     // again. In some cases (i.e., for empty files) Clang 4.0
1785     // generates a *.dwo file which has DW_AT_dwo_name, but no
1786     // DW_AT_comp_dir. In this case the method
1787     // ModuleList::GetSharedModule will fail and the warning will be
1788     // printed. However, as one can notice in this case we don't
1789     // actually need to try to load the already loaded module
1790     // (corresponding to .dwo) so we simply skip it.
1791     if (m_objfile_sp->GetFileSpec().GetFileNameExtension() == ".dwo" &&
1792         llvm::StringRef(m_objfile_sp->GetFileSpec().GetPath())
1793             .endswith(dwo_module_spec.GetFileSpec().GetPath())) {
1794       continue;
1795     }
1796
1797     Status error = ModuleList::GetSharedModule(dwo_module_spec, module_sp,
1798                                                nullptr, nullptr, nullptr);
1799     if (!module_sp) {
1800       GetObjectFile()->GetModule()->ReportWarning(
1801           "0x%8.8x: unable to locate module needed for external types: "
1802           "%s\nerror: %s\nDebugging will be degraded due to missing "
1803           "types. Rebuilding the project will regenerate the needed "
1804           "module files.",
1805           die.GetOffset(), dwo_module_spec.GetFileSpec().GetPath().c_str(),
1806           error.AsCString("unknown error"));
1807       continue;
1808     }
1809
1810     // Verify the DWO hash.
1811     // FIXME: Technically "0" is a valid hash.
1812     uint64_t dwo_id = ::GetDWOId(*dwarf_cu, *die.GetDIE());
1813     if (!dwo_id)
1814       continue;
1815
1816     auto *dwo_symfile =
1817         llvm::dyn_cast_or_null<SymbolFileDWARF>(module_sp->GetSymbolFile());
1818     if (!dwo_symfile)
1819       continue;
1820     llvm::Optional<uint64_t> dwo_dwo_id = dwo_symfile->GetDWOId();
1821     if (!dwo_dwo_id)
1822       continue;
1823
1824     if (dwo_id != dwo_dwo_id) {
1825       GetObjectFile()->GetModule()->ReportWarning(
1826           "0x%8.8x: Module %s is out-of-date (hash mismatch). Type information "
1827           "from this module may be incomplete or inconsistent with the rest of "
1828           "the program. Rebuilding the project will regenerate the needed "
1829           "module files.",
1830           die.GetOffset(), dwo_module_spec.GetFileSpec().GetPath().c_str());
1831     }
1832   }
1833 }
1834
1835 SymbolFileDWARF::GlobalVariableMap &SymbolFileDWARF::GetGlobalAranges() {
1836   if (!m_global_aranges_up) {
1837     m_global_aranges_up = std::make_unique<GlobalVariableMap>();
1838
1839     ModuleSP module_sp = GetObjectFile()->GetModule();
1840     if (module_sp) {
1841       const size_t num_cus = module_sp->GetNumCompileUnits();
1842       for (size_t i = 0; i < num_cus; ++i) {
1843         CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex(i);
1844         if (cu_sp) {
1845           VariableListSP globals_sp = cu_sp->GetVariableList(true);
1846           if (globals_sp) {
1847             const size_t num_globals = globals_sp->GetSize();
1848             for (size_t g = 0; g < num_globals; ++g) {
1849               VariableSP var_sp = globals_sp->GetVariableAtIndex(g);
1850               if (var_sp && !var_sp->GetLocationIsConstantValueData()) {
1851                 const DWARFExpression &location = var_sp->LocationExpression();
1852                 Value location_result;
1853                 Status error;
1854                 if (location.Evaluate(nullptr, LLDB_INVALID_ADDRESS, nullptr,
1855                                       nullptr, location_result, &error)) {
1856                   if (location_result.GetValueType() ==
1857                       Value::eValueTypeFileAddress) {
1858                     lldb::addr_t file_addr =
1859                         location_result.GetScalar().ULongLong();
1860                     lldb::addr_t byte_size = 1;
1861                     if (var_sp->GetType())
1862                       byte_size =
1863                           var_sp->GetType()->GetByteSize(nullptr).getValueOr(0);
1864                     m_global_aranges_up->Append(GlobalVariableMap::Entry(
1865                         file_addr, byte_size, var_sp.get()));
1866                   }
1867                 }
1868               }
1869             }
1870           }
1871         }
1872       }
1873     }
1874     m_global_aranges_up->Sort();
1875   }
1876   return *m_global_aranges_up;
1877 }
1878
1879 void SymbolFileDWARF::ResolveFunctionAndBlock(lldb::addr_t file_vm_addr,
1880                                               bool lookup_block,
1881                                               SymbolContext &sc) {
1882   DWARFCompileUnit *cu = sc.GetDWARFCompileUnit();
1883   lldbassert(cu);
1884   cu = &cu->GetNonSkeletonUnit();
1885   DWARFDIE function_die = cu->LookupAddress(file_vm_addr);
1886   DWARFDIE block_die;
1887   if (function_die) {
1888     sc.function =
1889         sc.comp_unit->FindFunctionByUID(function_die.GetID(cu)).get();
1890     if (sc.function == nullptr)
1891       sc.function = ParseFunction(*sc.comp_unit, function_die);
1892
1893     if (sc.function && lookup_block)
1894       block_die = function_die.LookupDeepestBlock(file_vm_addr);
1895   }
1896
1897   if (!sc.function || ! lookup_block)
1898     return;
1899
1900   Block &block = sc.function->GetBlock(true);
1901   if (block_die)
1902     sc.block = block.FindBlockByID(block_die.GetID(cu));
1903   else
1904     sc.block = block.FindBlockByID(function_die.GetID(cu));
1905 }
1906
1907 uint32_t SymbolFileDWARF::ResolveSymbolContext(const Address &so_addr,
1908                                                SymbolContextItem resolve_scope,
1909                                                SymbolContext &sc) {
1910   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1911   LLDB_SCOPED_TIMERF("SymbolFileDWARF::"
1912                      "ResolveSymbolContext (so_addr = { "
1913                      "section = %p, offset = 0x%" PRIx64
1914                      " }, resolve_scope = 0x%8.8x)",
1915                      static_cast<void *>(so_addr.GetSection().get()),
1916                      so_addr.GetOffset(), resolve_scope);
1917   uint32_t resolved = 0;
1918   if (resolve_scope &
1919       (eSymbolContextCompUnit | eSymbolContextFunction | eSymbolContextBlock |
1920        eSymbolContextLineEntry | eSymbolContextVariable)) {
1921     lldb::addr_t file_vm_addr = so_addr.GetFileAddress();
1922
1923     DWARFDebugInfo &debug_info = DebugInfo();
1924     llvm::Expected<DWARFDebugAranges &> aranges =
1925         debug_info.GetCompileUnitAranges();
1926     if (!aranges) {
1927       Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
1928       LLDB_LOG_ERROR(log, aranges.takeError(),
1929                      "SymbolFileDWARF::ResolveSymbolContext failed to get cu "
1930                      "aranges.  {0}");
1931       return 0;
1932     }
1933
1934     const dw_offset_t cu_offset = aranges->FindAddress(file_vm_addr);
1935     if (cu_offset == DW_INVALID_OFFSET) {
1936       // Global variables are not in the compile unit address ranges. The only
1937       // way to currently find global variables is to iterate over the
1938       // .debug_pubnames or the __apple_names table and find all items in there
1939       // that point to DW_TAG_variable DIEs and then find the address that
1940       // matches.
1941       if (resolve_scope & eSymbolContextVariable) {
1942         GlobalVariableMap &map = GetGlobalAranges();
1943         const GlobalVariableMap::Entry *entry =
1944             map.FindEntryThatContains(file_vm_addr);
1945         if (entry && entry->data) {
1946           Variable *variable = entry->data;
1947           SymbolContextScope *scc = variable->GetSymbolContextScope();
1948           if (scc) {
1949             scc->CalculateSymbolContext(&sc);
1950             sc.variable = variable;
1951           }
1952           return sc.GetResolvedMask();
1953         }
1954       }
1955     } else {
1956       uint32_t cu_idx = DW_INVALID_INDEX;
1957       if (auto *dwarf_cu = llvm::dyn_cast_or_null<DWARFCompileUnit>(
1958               debug_info.GetUnitAtOffset(DIERef::Section::DebugInfo, cu_offset,
1959                                          &cu_idx))) {
1960         sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
1961         if (sc.comp_unit) {
1962           resolved |= eSymbolContextCompUnit;
1963
1964           bool force_check_line_table = false;
1965           if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock)) {
1966             ResolveFunctionAndBlock(file_vm_addr,
1967                                     resolve_scope & eSymbolContextBlock, sc);
1968             if (sc.function)
1969               resolved |= eSymbolContextFunction;
1970             else {
1971               // We might have had a compile unit that had discontiguous address
1972               // ranges where the gaps are symbols that don't have any debug
1973               // info. Discontiguous compile unit address ranges should only
1974               // happen when there aren't other functions from other compile
1975               // units in these gaps. This helps keep the size of the aranges
1976               // down.
1977               force_check_line_table = true;
1978             }
1979             if (sc.block)
1980               resolved |= eSymbolContextBlock;
1981           }
1982
1983           if ((resolve_scope & eSymbolContextLineEntry) ||
1984               force_check_line_table) {
1985             LineTable *line_table = sc.comp_unit->GetLineTable();
1986             if (line_table != nullptr) {
1987               // And address that makes it into this function should be in terms
1988               // of this debug file if there is no debug map, or it will be an
1989               // address in the .o file which needs to be fixed up to be in
1990               // terms of the debug map executable. Either way, calling
1991               // FixupAddress() will work for us.
1992               Address exe_so_addr(so_addr);
1993               if (FixupAddress(exe_so_addr)) {
1994                 if (line_table->FindLineEntryByAddress(exe_so_addr,
1995                                                        sc.line_entry)) {
1996                   resolved |= eSymbolContextLineEntry;
1997                 }
1998               }
1999             }
2000           }
2001
2002           if (force_check_line_table && !(resolved & eSymbolContextLineEntry)) {
2003             // We might have had a compile unit that had discontiguous address
2004             // ranges where the gaps are symbols that don't have any debug info.
2005             // Discontiguous compile unit address ranges should only happen when
2006             // there aren't other functions from other compile units in these
2007             // gaps. This helps keep the size of the aranges down.
2008             sc.comp_unit = nullptr;
2009             resolved &= ~eSymbolContextCompUnit;
2010           }
2011         } else {
2012           GetObjectFile()->GetModule()->ReportWarning(
2013               "0x%8.8x: compile unit %u failed to create a valid "
2014               "lldb_private::CompileUnit class.",
2015               cu_offset, cu_idx);
2016         }
2017       }
2018     }
2019   }
2020   return resolved;
2021 }
2022
2023 uint32_t SymbolFileDWARF::ResolveSymbolContext(const FileSpec &file_spec,
2024                                                uint32_t line,
2025                                                bool check_inlines,
2026                                                SymbolContextItem resolve_scope,
2027                                                SymbolContextList &sc_list) {
2028   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
2029   const uint32_t prev_size = sc_list.GetSize();
2030   if (resolve_scope & eSymbolContextCompUnit) {
2031     for (uint32_t cu_idx = 0, num_cus = GetNumCompileUnits(); cu_idx < num_cus;
2032          ++cu_idx) {
2033       CompileUnit *dc_cu = ParseCompileUnitAtIndex(cu_idx).get();
2034       if (!dc_cu)
2035         continue;
2036
2037       bool file_spec_matches_cu_file_spec =
2038           FileSpec::Match(file_spec, dc_cu->GetPrimaryFile());
2039       if (check_inlines || file_spec_matches_cu_file_spec) {
2040         SymbolContext sc(m_objfile_sp->GetModule());
2041         sc.comp_unit = dc_cu;
2042         uint32_t file_idx = UINT32_MAX;
2043
2044         // If we are looking for inline functions only and we don't find it
2045         // in the support files, we are done.
2046         if (check_inlines) {
2047           file_idx =
2048               sc.comp_unit->GetSupportFiles().FindFileIndex(1, file_spec, true);
2049           if (file_idx == UINT32_MAX)
2050             continue;
2051         }
2052
2053         if (line != 0) {
2054           LineTable *line_table = sc.comp_unit->GetLineTable();
2055
2056           if (line_table != nullptr && line != 0) {
2057             // We will have already looked up the file index if we are
2058             // searching for inline entries.
2059             if (!check_inlines)
2060               file_idx = sc.comp_unit->GetSupportFiles().FindFileIndex(
2061                   1, file_spec, true);
2062
2063             if (file_idx != UINT32_MAX) {
2064               uint32_t found_line;
2065               uint32_t line_idx = line_table->FindLineEntryIndexByFileIndex(
2066                   0, file_idx, line, false, &sc.line_entry);
2067               found_line = sc.line_entry.line;
2068
2069               while (line_idx != UINT32_MAX) {
2070                 sc.function = nullptr;
2071                 sc.block = nullptr;
2072                 if (resolve_scope &
2073                     (eSymbolContextFunction | eSymbolContextBlock)) {
2074                   const lldb::addr_t file_vm_addr =
2075                       sc.line_entry.range.GetBaseAddress().GetFileAddress();
2076                   if (file_vm_addr != LLDB_INVALID_ADDRESS) {
2077                     ResolveFunctionAndBlock(
2078                         file_vm_addr, resolve_scope & eSymbolContextBlock, sc);
2079                   }
2080                 }
2081
2082                 sc_list.Append(sc);
2083                 line_idx = line_table->FindLineEntryIndexByFileIndex(
2084                     line_idx + 1, file_idx, found_line, true, &sc.line_entry);
2085               }
2086             }
2087           } else if (file_spec_matches_cu_file_spec && !check_inlines) {
2088             // only append the context if we aren't looking for inline call
2089             // sites by file and line and if the file spec matches that of
2090             // the compile unit
2091             sc_list.Append(sc);
2092           }
2093         } else if (file_spec_matches_cu_file_spec && !check_inlines) {
2094           // only append the context if we aren't looking for inline call
2095           // sites by file and line and if the file spec matches that of
2096           // the compile unit
2097           sc_list.Append(sc);
2098         }
2099
2100         if (!check_inlines)
2101           break;
2102       }
2103     }
2104   }
2105   return sc_list.GetSize() - prev_size;
2106 }
2107
2108 void SymbolFileDWARF::PreloadSymbols() {
2109   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
2110   m_index->Preload();
2111 }
2112
2113 std::recursive_mutex &SymbolFileDWARF::GetModuleMutex() const {
2114   lldb::ModuleSP module_sp(m_debug_map_module_wp.lock());
2115   if (module_sp)
2116     return module_sp->GetMutex();
2117   return GetObjectFile()->GetModule()->GetMutex();
2118 }
2119
2120 bool SymbolFileDWARF::DeclContextMatchesThisSymbolFile(
2121     const lldb_private::CompilerDeclContext &decl_ctx) {
2122   if (!decl_ctx.IsValid()) {
2123     // Invalid namespace decl which means we aren't matching only things in
2124     // this symbol file, so return true to indicate it matches this symbol
2125     // file.
2126     return true;
2127   }
2128
2129   TypeSystem *decl_ctx_type_system = decl_ctx.GetTypeSystem();
2130   auto type_system_or_err = GetTypeSystemForLanguage(
2131       decl_ctx_type_system->GetMinimumLanguage(nullptr));
2132   if (auto err = type_system_or_err.takeError()) {
2133     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
2134                    std::move(err),
2135                    "Unable to match namespace decl using TypeSystem");
2136     return false;
2137   }
2138
2139   if (decl_ctx_type_system == &type_system_or_err.get())
2140     return true; // The type systems match, return true
2141
2142   // The namespace AST was valid, and it does not match...
2143   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
2144
2145   if (log)
2146     GetObjectFile()->GetModule()->LogMessage(
2147         log, "Valid namespace does not match symbol file");
2148
2149   return false;
2150 }
2151
2152 void SymbolFileDWARF::FindGlobalVariables(
2153     ConstString name, const CompilerDeclContext &parent_decl_ctx,
2154     uint32_t max_matches, VariableList &variables) {
2155   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
2156   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
2157
2158   if (log)
2159     GetObjectFile()->GetModule()->LogMessage(
2160         log,
2161         "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", "
2162         "parent_decl_ctx=%p, max_matches=%u, variables)",
2163         name.GetCString(), static_cast<const void *>(&parent_decl_ctx),
2164         max_matches);
2165
2166   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
2167     return;
2168
2169   // Remember how many variables are in the list before we search.
2170   const uint32_t original_size = variables.GetSize();
2171
2172   llvm::StringRef basename;
2173   llvm::StringRef context;
2174   bool name_is_mangled = (bool)Mangled(name);
2175
2176   if (!CPlusPlusLanguage::ExtractContextAndIdentifier(name.GetCString(),
2177                                                       context, basename))
2178     basename = name.GetStringRef();
2179
2180   // Loop invariant: Variables up to this index have been checked for context
2181   // matches.
2182   uint32_t pruned_idx = original_size;
2183
2184   SymbolContext sc;
2185   m_index->GetGlobalVariables(
2186       ConstString(basename), [&](DWARFUnit *main_unit, DWARFDIE die) {
2187         if (!sc.module_sp)
2188           sc.module_sp = m_objfile_sp->GetModule();
2189         assert(sc.module_sp);
2190
2191         if (die.Tag() != DW_TAG_variable)
2192           return true;
2193
2194         DWARFCompileUnit *main_cu = llvm::dyn_cast_or_null<DWARFCompileUnit>(main_unit);
2195         if (!main_cu)
2196           return false;
2197         sc.comp_unit = main_cu->GetCompUnit();
2198
2199         if (parent_decl_ctx) {
2200           if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetMainDWARFUnit(main_unit))) {
2201             CompilerDeclContext actual_parent_decl_ctx =
2202                 dwarf_ast->GetDeclContextContainingUIDFromDWARF(main_unit, die);
2203             if (!actual_parent_decl_ctx ||
2204                 actual_parent_decl_ctx != parent_decl_ctx)
2205               return true;
2206           }
2207         }
2208
2209         ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false, &variables);
2210         while (pruned_idx < variables.GetSize()) {
2211           VariableSP var_sp = variables.GetVariableAtIndex(pruned_idx);
2212           if (name_is_mangled ||
2213               var_sp->GetName().GetStringRef().contains(name.GetStringRef()))
2214             ++pruned_idx;
2215           else
2216             variables.RemoveVariableAtIndex(pruned_idx);
2217         }
2218
2219         return variables.GetSize() - original_size < max_matches;
2220       });
2221
2222   // Return the number of variable that were appended to the list
2223   const uint32_t num_matches = variables.GetSize() - original_size;
2224   if (log && num_matches > 0) {
2225     GetObjectFile()->GetModule()->LogMessage(
2226         log,
2227         "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", "
2228         "parent_decl_ctx=%p, max_matches=%u, variables) => %u",
2229         name.GetCString(), static_cast<const void *>(&parent_decl_ctx),
2230         max_matches, num_matches);
2231   }
2232 }
2233
2234 void SymbolFileDWARF::FindGlobalVariables(const RegularExpression &regex,
2235                                           uint32_t max_matches,
2236                                           VariableList &variables) {
2237   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
2238   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
2239
2240   if (log) {
2241     GetObjectFile()->GetModule()->LogMessage(
2242         log,
2243         "SymbolFileDWARF::FindGlobalVariables (regex=\"%s\", "
2244         "max_matches=%u, variables)",
2245         regex.GetText().str().c_str(), max_matches);
2246   }
2247
2248   // Remember how many variables are in the list before we search.
2249   const uint32_t original_size = variables.GetSize();
2250
2251   SymbolContext sc;
2252   m_index->GetGlobalVariables(
2253       regex, [&](DWARFUnit *main_unit, DWARFDIE die) {
2254         if (!sc.module_sp)
2255           sc.module_sp = m_objfile_sp->GetModule();
2256         assert(sc.module_sp);
2257
2258         DWARFCompileUnit *main_cu = llvm::dyn_cast_or_null<DWARFCompileUnit>(main_unit);
2259         if (!main_cu)
2260           return false;
2261         sc.comp_unit = main_cu->GetCompUnit();
2262
2263         ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false, &variables);
2264
2265         return variables.GetSize() - original_size < max_matches;
2266       });
2267 }
2268
2269 bool SymbolFileDWARF::ResolveFunction(DWARFUnit *main_unit,
2270                                       const DWARFDIE &orig_die,
2271                                       bool include_inlines,
2272                                       SymbolContextList &sc_list) {
2273   SymbolContext sc;
2274
2275   if (!orig_die)
2276     return false;
2277
2278   // If we were passed a die that is not a function, just return false...
2279   if (!(orig_die.Tag() == DW_TAG_subprogram ||
2280         (include_inlines && orig_die.Tag() == DW_TAG_inlined_subroutine)))
2281     return false;
2282
2283   DWARFDIE die = orig_die;
2284   DWARFDIE inlined_die;
2285   if (die.Tag() == DW_TAG_inlined_subroutine) {
2286     inlined_die = die;
2287
2288     while (true) {
2289       die = die.GetParent();
2290
2291       if (die) {
2292         if (die.Tag() == DW_TAG_subprogram)
2293           break;
2294       } else
2295         break;
2296     }
2297   }
2298   assert(die && die.Tag() == DW_TAG_subprogram);
2299   if (GetFunction(main_unit, die, sc)) {
2300     Address addr;
2301     // Parse all blocks if needed
2302     if (inlined_die) {
2303       Block &function_block = sc.function->GetBlock(true);
2304       sc.block = function_block.FindBlockByID(inlined_die.GetID(main_unit));
2305       if (sc.block == nullptr)
2306         sc.block = function_block.FindBlockByID(inlined_die.GetOffset());
2307       if (sc.block == nullptr || !sc.block->GetStartAddress(addr))
2308         addr.Clear();
2309     } else {
2310       sc.block = nullptr;
2311       addr = sc.function->GetAddressRange().GetBaseAddress();
2312     }
2313
2314
2315     if (auto section_sp = addr.GetSection()) {
2316       if (section_sp->GetPermissions() & ePermissionsExecutable) {
2317         sc_list.Append(sc);
2318         return true;
2319       }
2320     }
2321   }
2322
2323   return false;
2324 }
2325
2326 bool SymbolFileDWARF::DIEInDeclContext(const CompilerDeclContext &decl_ctx,
2327                                        DWARFUnit *main_unit,
2328                                        const DWARFDIE &die) {
2329   // If we have no parent decl context to match this DIE matches, and if the
2330   // parent decl context isn't valid, we aren't trying to look for any
2331   // particular decl context so any die matches.
2332   if (!decl_ctx.IsValid())
2333     return true;
2334
2335   if (die) {
2336     if (DWARFASTParser *dwarf_ast =
2337             GetDWARFParser(*die.GetMainDWARFUnit(main_unit))) {
2338       if (CompilerDeclContext actual_decl_ctx =
2339               dwarf_ast->GetDeclContextContainingUIDFromDWARF(main_unit, die))
2340         return decl_ctx.IsContainedInLookup(actual_decl_ctx);
2341     }
2342   }
2343   return false;
2344 }
2345
2346 void SymbolFileDWARF::FindFunctions(ConstString name,
2347                                     const CompilerDeclContext &parent_decl_ctx,
2348                                     FunctionNameType name_type_mask,
2349                                     bool include_inlines,
2350                                     SymbolContextList &sc_list) {
2351   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
2352   LLDB_SCOPED_TIMERF("SymbolFileDWARF::FindFunctions (name = '%s')",
2353                      name.AsCString());
2354
2355   // eFunctionNameTypeAuto should be pre-resolved by a call to
2356   // Module::LookupInfo::LookupInfo()
2357   assert((name_type_mask & eFunctionNameTypeAuto) == 0);
2358
2359   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
2360
2361   if (log) {
2362     GetObjectFile()->GetModule()->LogMessage(
2363         log,
2364         "SymbolFileDWARF::FindFunctions (name=\"%s\", name_type_mask=0x%x, sc_list)",
2365         name.GetCString(), name_type_mask);
2366   }
2367
2368   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
2369     return;
2370
2371   // If name is empty then we won't find anything.
2372   if (name.IsEmpty())
2373     return;
2374
2375   // Remember how many sc_list are in the list before we search in case we are
2376   // appending the results to a variable list.
2377
2378   const uint32_t original_size = sc_list.GetSize();
2379
2380   llvm::DenseSet<std::pair<DWARFUnit *, const DWARFDebugInfoEntry *>>
2381       resolved_dies;
2382
2383   m_index->GetFunctions(
2384       name, *this, parent_decl_ctx, name_type_mask,
2385       [&](DWARFUnit *main_unit, DWARFDIE die) {
2386         if (resolved_dies.insert(std::make_pair(main_unit, die.GetDIE()))
2387                 .second)
2388           ResolveFunction(main_unit, die, include_inlines, sc_list);
2389         return true;
2390       });
2391
2392   // Return the number of variable that were appended to the list
2393   const uint32_t num_matches = sc_list.GetSize() - original_size;
2394
2395   if (log && num_matches > 0) {
2396     GetObjectFile()->GetModule()->LogMessage(
2397         log,
2398         "SymbolFileDWARF::FindFunctions (name=\"%s\", "
2399         "name_type_mask=0x%x, include_inlines=%d, sc_list) => %u",
2400         name.GetCString(), name_type_mask, include_inlines,
2401         num_matches);
2402   }
2403 }
2404
2405 void SymbolFileDWARF::FindFunctions(const RegularExpression &regex,
2406                                     bool include_inlines,
2407                                     SymbolContextList &sc_list) {
2408   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
2409   LLDB_SCOPED_TIMERF("SymbolFileDWARF::FindFunctions (regex = '%s')",
2410                      regex.GetText().str().c_str());
2411
2412   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
2413
2414   if (log) {
2415     GetObjectFile()->GetModule()->LogMessage(
2416         log, "SymbolFileDWARF::FindFunctions (regex=\"%s\", sc_list)",
2417         regex.GetText().str().c_str());
2418   }
2419
2420   llvm::DenseSet<std::pair<DWARFUnit *, const DWARFDebugInfoEntry *>>
2421       resolved_dies;
2422   m_index->GetFunctions(regex, [&](DWARFUnit *main_unit, DWARFDIE die) {
2423     if (resolved_dies.insert(std::make_pair(main_unit, die.GetDIE())).second)
2424       ResolveFunction(main_unit, die, include_inlines, sc_list);
2425     return true;
2426   });
2427 }
2428
2429 void SymbolFileDWARF::GetMangledNamesForFunction(
2430     const std::string &scope_qualified_name,
2431     std::vector<ConstString> &mangled_names) {
2432   DWARFDebugInfo &info = DebugInfo();
2433   uint32_t num_comp_units = info.GetNumUnits();
2434   for (uint32_t i = 0; i < num_comp_units; i++) {
2435     DWARFUnit *cu = info.GetUnitAtIndex(i);
2436     if (cu == nullptr)
2437       continue;
2438
2439     SymbolFileDWARFDwo *dwo = cu->GetDwoSymbolFile();
2440     if (dwo)
2441       dwo->GetMangledNamesForFunction(scope_qualified_name, mangled_names);
2442   }
2443
2444   for (DIERef die_ref :
2445        m_function_scope_qualified_name_map.lookup(scope_qualified_name)) {
2446     DWARFDIE die = GetDIE(die_ref);
2447     mangled_names.push_back(ConstString(die.GetMangledName()));
2448   }
2449 }
2450
2451 void SymbolFileDWARF::FindTypes(
2452     ConstString name, const CompilerDeclContext &parent_decl_ctx,
2453     uint32_t max_matches,
2454     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
2455     TypeMap &types) {
2456   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
2457   // Make sure we haven't already searched this SymbolFile before.
2458   if (!searched_symbol_files.insert(this).second)
2459     return;
2460
2461   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
2462
2463   if (log) {
2464     if (parent_decl_ctx)
2465       GetObjectFile()->GetModule()->LogMessage(
2466           log,
2467           "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = "
2468           "%p (\"%s\"), max_matches=%u, type_list)",
2469           name.GetCString(), static_cast<const void *>(&parent_decl_ctx),
2470           parent_decl_ctx.GetName().AsCString("<NULL>"), max_matches);
2471     else
2472       GetObjectFile()->GetModule()->LogMessage(
2473           log,
2474           "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = "
2475           "NULL, max_matches=%u, type_list)",
2476           name.GetCString(), max_matches);
2477   }
2478
2479   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
2480     return;
2481
2482   m_index->GetTypes(name, [&](DWARFUnit *main_unit, DWARFDIE die) {
2483     if (!DIEInDeclContext(parent_decl_ctx, main_unit, die))
2484       return true; // The containing decl contexts don't match
2485
2486     Type *matching_type = ResolveType(main_unit, die, true, true);
2487     if (!matching_type)
2488       return true;
2489
2490     // We found a type pointer, now find the shared pointer form our type
2491     // list
2492     types.InsertUnique(matching_type->shared_from_this());
2493     return types.GetSize() < max_matches;
2494   });
2495
2496   // Next search through the reachable Clang modules. This only applies for
2497   // DWARF objects compiled with -gmodules that haven't been processed by
2498   // dsymutil.
2499   if (types.GetSize() < max_matches) {
2500     UpdateExternalModuleListIfNeeded();
2501
2502     for (const auto &pair : m_external_type_modules)
2503       if (ModuleSP external_module_sp = pair.second)
2504         if (SymbolFile *sym_file = external_module_sp->GetSymbolFile())
2505           sym_file->FindTypes(name, parent_decl_ctx, max_matches,
2506                               searched_symbol_files, types);
2507   }
2508
2509   if (log && types.GetSize()) {
2510     if (parent_decl_ctx) {
2511       GetObjectFile()->GetModule()->LogMessage(
2512           log,
2513           "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx "
2514           "= %p (\"%s\"), max_matches=%u, type_list) => %u",
2515           name.GetCString(), static_cast<const void *>(&parent_decl_ctx),
2516           parent_decl_ctx.GetName().AsCString("<NULL>"), max_matches,
2517           types.GetSize());
2518     } else {
2519       GetObjectFile()->GetModule()->LogMessage(
2520           log,
2521           "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx "
2522           "= NULL, max_matches=%u, type_list) => %u",
2523           name.GetCString(), max_matches, types.GetSize());
2524     }
2525   }
2526 }
2527
2528 void SymbolFileDWARF::FindTypes(
2529     llvm::ArrayRef<CompilerContext> pattern, LanguageSet languages,
2530     llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) {
2531   // Make sure we haven't already searched this SymbolFile before.
2532   if (!searched_symbol_files.insert(this).second)
2533     return;
2534
2535   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
2536   if (pattern.empty())
2537     return;
2538
2539   ConstString name = pattern.back().name;
2540
2541   if (!name)
2542     return;
2543
2544   m_index->GetTypes(name, [&](DWARFUnit *main_unit, DWARFDIE die) {
2545     if (!languages[GetLanguage(*die.GetMainDWARFUnit(main_unit))])
2546       return true;
2547
2548     llvm::SmallVector<CompilerContext, 4> die_context;
2549     die.GetDeclContext(die_context);
2550     if (!contextMatches(die_context, pattern))
2551       return true;
2552
2553     if (Type *matching_type = ResolveType(main_unit, die, true, true)) {
2554       // We found a type pointer, now find the shared pointer form our type
2555       // list.
2556       types.InsertUnique(matching_type->shared_from_this());
2557     }
2558     return true;
2559   });
2560
2561   // Next search through the reachable Clang modules. This only applies for
2562   // DWARF objects compiled with -gmodules that haven't been processed by
2563   // dsymutil.
2564   UpdateExternalModuleListIfNeeded();
2565
2566   for (const auto &pair : m_external_type_modules)
2567     if (ModuleSP external_module_sp = pair.second)
2568       external_module_sp->FindTypes(pattern, languages, searched_symbol_files,
2569                                     types);
2570 }
2571
2572 CompilerDeclContext
2573 SymbolFileDWARF::FindNamespace(ConstString name,
2574                                const CompilerDeclContext &parent_decl_ctx) {
2575   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
2576   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
2577
2578   if (log) {
2579     GetObjectFile()->GetModule()->LogMessage(
2580         log, "SymbolFileDWARF::FindNamespace (sc, name=\"%s\")",
2581         name.GetCString());
2582   }
2583
2584   CompilerDeclContext namespace_decl_ctx;
2585
2586   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
2587     return namespace_decl_ctx;
2588
2589   m_index->GetNamespaces(name, [&](DWARFUnit *main_unit, DWARFDIE die) {
2590     if (!DIEInDeclContext(parent_decl_ctx, main_unit, die))
2591       return true; // The containing decl contexts don't match
2592
2593     DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetMainDWARFUnit(main_unit));
2594     if (!dwarf_ast)
2595       return true;
2596
2597     namespace_decl_ctx =
2598         dwarf_ast->GetDeclContextForUIDFromDWARF(main_unit, die);
2599     return !namespace_decl_ctx.IsValid();
2600   });
2601
2602   if (log && namespace_decl_ctx) {
2603     GetObjectFile()->GetModule()->LogMessage(
2604         log,
2605         "SymbolFileDWARF::FindNamespace (sc, name=\"%s\") => "
2606         "CompilerDeclContext(%p/%p) \"%s\"",
2607         name.GetCString(),
2608         static_cast<const void *>(namespace_decl_ctx.GetTypeSystem()),
2609         static_cast<const void *>(namespace_decl_ctx.GetOpaqueDeclContext()),
2610         namespace_decl_ctx.GetName().AsCString("<NULL>"));
2611   }
2612
2613   return namespace_decl_ctx;
2614 }
2615
2616 TypeSP SymbolFileDWARF::GetTypeForDIE(DWARFUnit *main_unit,
2617                                       const DWARFDIE &die,
2618                                       bool resolve_function_context) {
2619   TypeSP type_sp;
2620   if (die) {
2621     Type *type_ptr = GetDIEToType().lookup(die.MainCUtoDIEPair(main_unit));
2622     if (type_ptr == nullptr) {
2623       SymbolContextScope *scope;
2624       DWARFCompileUnit *main_cu = llvm::dyn_cast_or_null<DWARFCompileUnit>(main_unit);
2625       if (main_cu)
2626         scope = main_cu->GetCompUnit();
2627       else
2628         scope = GetObjectFile()->GetModule().get();
2629       assert(scope);
2630       SymbolContext sc(scope);
2631       const DWARFDebugInfoEntry *parent_die = die.GetParent().GetDIE();
2632       while (parent_die != nullptr) {
2633         if (parent_die->Tag() == DW_TAG_subprogram)
2634           break;
2635         parent_die = parent_die->GetParent();
2636       }
2637       SymbolContext sc_backup = sc;
2638       if (resolve_function_context && parent_die != nullptr &&
2639           !GetFunction(main_unit, DWARFDIE(die.GetCU(), parent_die), sc))
2640         sc = sc_backup;
2641
2642       type_sp = ParseType(sc, die, nullptr);
2643     } else if (type_ptr != DIE_IS_BEING_PARSED) {
2644       // Grab the existing type from the master types lists
2645       type_sp = type_ptr->shared_from_this();
2646     }
2647   }
2648   return type_sp;
2649 }
2650
2651 DWARFDIE
2652 SymbolFileDWARF::GetDeclContextDIEContainingDIE(const DWARFDIE &orig_die) {
2653   if (orig_die) {
2654     DWARFDIE die = orig_die;
2655
2656     while (die) {
2657       // If this is the original DIE that we are searching for a declaration
2658       // for, then don't look in the cache as we don't want our own decl
2659       // context to be our decl context...
2660       if (orig_die != die) {
2661         switch (die.Tag()) {
2662         case DW_TAG_compile_unit:
2663         case DW_TAG_partial_unit:
2664         case DW_TAG_namespace:
2665         case DW_TAG_structure_type:
2666         case DW_TAG_union_type:
2667         case DW_TAG_class_type:
2668         case DW_TAG_lexical_block:
2669         case DW_TAG_subprogram:
2670           return die;
2671         case DW_TAG_inlined_subroutine: {
2672           DWARFDIE abs_die = die.GetReferencedDIE(DW_AT_abstract_origin);
2673           if (abs_die) {
2674             return abs_die;
2675           }
2676           break;
2677         }
2678         default:
2679           break;
2680         }
2681       }
2682
2683       DWARFDIE spec_die = die.GetReferencedDIE(DW_AT_specification);
2684       if (spec_die) {
2685         DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(spec_die);
2686         if (decl_ctx_die)
2687           return decl_ctx_die;
2688       }
2689
2690       DWARFDIE abs_die = die.GetReferencedDIE(DW_AT_abstract_origin);
2691       if (abs_die) {
2692         DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(abs_die);
2693         if (decl_ctx_die)
2694           return decl_ctx_die;
2695       }
2696
2697       die = die.GetParent();
2698     }
2699   }
2700   return DWARFDIE();
2701 }
2702
2703 Symbol *SymbolFileDWARF::GetObjCClassSymbol(ConstString objc_class_name) {
2704   Symbol *objc_class_symbol = nullptr;
2705   if (m_objfile_sp) {
2706     Symtab *symtab = m_objfile_sp->GetSymtab();
2707     if (symtab) {
2708       objc_class_symbol = symtab->FindFirstSymbolWithNameAndType(
2709           objc_class_name, eSymbolTypeObjCClass, Symtab::eDebugNo,
2710           Symtab::eVisibilityAny);
2711     }
2712   }
2713   return objc_class_symbol;
2714 }
2715
2716 // Some compilers don't emit the DW_AT_APPLE_objc_complete_type attribute. If
2717 // they don't then we can end up looking through all class types for a complete
2718 // type and never find the full definition. We need to know if this attribute
2719 // is supported, so we determine this here and cache th result. We also need to
2720 // worry about the debug map
2721 // DWARF file
2722 // if we are doing darwin DWARF in .o file debugging.
2723 bool SymbolFileDWARF::Supports_DW_AT_APPLE_objc_complete_type(DWARFUnit *cu) {
2724   if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolCalculate) {
2725     m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolNo;
2726     if (cu && cu->Supports_DW_AT_APPLE_objc_complete_type())
2727       m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes;
2728     else {
2729       DWARFDebugInfo &debug_info = DebugInfo();
2730       const uint32_t num_compile_units = GetNumCompileUnits();
2731       for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
2732         DWARFUnit *dwarf_cu = debug_info.GetUnitAtIndex(cu_idx);
2733         if (dwarf_cu != cu &&
2734             dwarf_cu->Supports_DW_AT_APPLE_objc_complete_type()) {
2735           m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes;
2736           break;
2737         }
2738       }
2739     }
2740     if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolNo &&
2741         GetDebugMapSymfile())
2742       return m_debug_map_symfile->Supports_DW_AT_APPLE_objc_complete_type(this);
2743   }
2744   return m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolYes;
2745 }
2746
2747 // This function can be used when a DIE is found that is a forward declaration
2748 // DIE and we want to try and find a type that has the complete definition.
2749 TypeSP SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE(
2750     const DWARFDIE &die, ConstString type_name, bool must_be_implementation) {
2751
2752   TypeSP type_sp;
2753
2754   if (!type_name || (must_be_implementation && !GetObjCClassSymbol(type_name)))
2755     return type_sp;
2756
2757   m_index->GetCompleteObjCClass(
2758       type_name, must_be_implementation,
2759       [&](DWARFUnit *main_unit, DWARFDIE type_die) {
2760         bool try_resolving_type = false;
2761
2762         // Don't try and resolve the DIE we are looking for with the DIE
2763         // itself!
2764         if (type_die != die) {
2765           switch (type_die.Tag()) {
2766           case DW_TAG_class_type:
2767           case DW_TAG_structure_type:
2768             try_resolving_type = true;
2769             break;
2770           default:
2771             break;
2772           }
2773         }
2774         if (!try_resolving_type)
2775           return true;
2776
2777         if (must_be_implementation &&
2778             type_die.Supports_DW_AT_APPLE_objc_complete_type())
2779           try_resolving_type = type_die.GetAttributeValueAsUnsigned(
2780               DW_AT_APPLE_objc_complete_type, 0);
2781         if (!try_resolving_type)
2782           return true;
2783
2784         Type *resolved_type = ResolveType(main_unit, type_die, false, true);
2785         if (!resolved_type || resolved_type == DIE_IS_BEING_PARSED)
2786           return true;
2787
2788         DEBUG_PRINTF(
2789             "resolved 0x%8.8" PRIx64 " from %s to 0x%8.8" PRIx64
2790             " (cu 0x%8.8" PRIx64 ")\n",
2791             die.GetID(),
2792             m_objfile_sp->GetFileSpec().GetFilename().AsCString("<Unknown>"),
2793             type_die.GetID(), type_cu->GetID());
2794
2795         if (die)
2796           GetDIEToType()[die.MainCUtoDIEPair(main_unit)] = resolved_type;
2797         type_sp = resolved_type->shared_from_this();
2798         return false;
2799       });
2800   return type_sp;
2801 }
2802
2803 // This function helps to ensure that the declaration contexts match for two
2804 // different DIEs. Often times debug information will refer to a forward
2805 // declaration of a type (the equivalent of "struct my_struct;". There will
2806 // often be a declaration of that type elsewhere that has the full definition.
2807 // When we go looking for the full type "my_struct", we will find one or more
2808 // matches in the accelerator tables and we will then need to make sure the
2809 // type was in the same declaration context as the original DIE. This function
2810 // can efficiently compare two DIEs and will return true when the declaration
2811 // context matches, and false when they don't.
2812 bool SymbolFileDWARF::DIEDeclContextsMatch(const DWARFDIE &die1,
2813                                            const DWARFDIE &die2) {
2814   if (die1 == die2)
2815     return true;
2816
2817   std::vector<DWARFDIE> decl_ctx_1;
2818   std::vector<DWARFDIE> decl_ctx_2;
2819   // The declaration DIE stack is a stack of the declaration context DIEs all
2820   // the way back to the compile unit. If a type "T" is declared inside a class
2821   // "B", and class "B" is declared inside a class "A" and class "A" is in a
2822   // namespace "lldb", and the namespace is in a compile unit, there will be a
2823   // stack of DIEs:
2824   //
2825   //   [0] DW_TAG_class_type for "B"
2826   //   [1] DW_TAG_class_type for "A"
2827   //   [2] DW_TAG_namespace  for "lldb"
2828   //   [3] DW_TAG_compile_unit or DW_TAG_partial_unit for the source file.
2829   //
2830   // We grab both contexts and make sure that everything matches all the way
2831   // back to the compiler unit.
2832
2833   // First lets grab the decl contexts for both DIEs
2834   decl_ctx_1 = die1.GetDeclContextDIEs();
2835   decl_ctx_2 = die2.GetDeclContextDIEs();
2836   // Make sure the context arrays have the same size, otherwise we are done
2837   const size_t count1 = decl_ctx_1.size();
2838   const size_t count2 = decl_ctx_2.size();
2839   if (count1 != count2)
2840     return false;
2841
2842   // Make sure the DW_TAG values match all the way back up the compile unit. If
2843   // they don't, then we are done.
2844   DWARFDIE decl_ctx_die1;
2845   DWARFDIE decl_ctx_die2;
2846   size_t i;
2847   for (i = 0; i < count1; i++) {
2848     decl_ctx_die1 = decl_ctx_1[i];
2849     decl_ctx_die2 = decl_ctx_2[i];
2850     if (decl_ctx_die1.Tag() != decl_ctx_die2.Tag())
2851       return false;
2852   }
2853 #ifndef NDEBUG
2854
2855   // Make sure the top item in the decl context die array is always
2856   // DW_TAG_compile_unit or DW_TAG_partial_unit. If it isn't then
2857   // something went wrong in the DWARFDIE::GetDeclContextDIEs()
2858   // function.
2859   dw_tag_t cu_tag = decl_ctx_1[count1 - 1].Tag();
2860   UNUSED_IF_ASSERT_DISABLED(cu_tag);
2861   assert(cu_tag == DW_TAG_compile_unit || cu_tag == DW_TAG_partial_unit);
2862
2863 #endif
2864   // Always skip the compile unit when comparing by only iterating up to "count
2865   // - 1". Here we compare the names as we go.
2866   for (i = 0; i < count1 - 1; i++) {
2867     decl_ctx_die1 = decl_ctx_1[i];
2868     decl_ctx_die2 = decl_ctx_2[i];
2869     const char *name1 = decl_ctx_die1.GetName();
2870     const char *name2 = decl_ctx_die2.GetName();
2871     // If the string was from a DW_FORM_strp, then the pointer will often be
2872     // the same!
2873     if (name1 == name2)
2874       continue;
2875
2876     // Name pointers are not equal, so only compare the strings if both are not
2877     // NULL.
2878     if (name1 && name2) {
2879       // If the strings don't compare, we are done...
2880       if (strcmp(name1, name2) != 0)
2881         return false;
2882     } else {
2883       // One name was NULL while the other wasn't
2884       return false;
2885     }
2886   }
2887   // We made it through all of the checks and the declaration contexts are
2888   // equal.
2889   return true;
2890 }
2891
2892 TypeSP SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(
2893     const DWARFDeclContext &dwarf_decl_ctx) {
2894   TypeSP type_sp;
2895
2896   const uint32_t dwarf_decl_ctx_count = dwarf_decl_ctx.GetSize();
2897   if (dwarf_decl_ctx_count > 0) {
2898     const ConstString type_name(dwarf_decl_ctx[0].name);
2899     const dw_tag_t tag = dwarf_decl_ctx[0].tag;
2900
2901     if (type_name) {
2902       Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION |
2903                                             DWARF_LOG_LOOKUPS));
2904       if (log) {
2905         GetObjectFile()->GetModule()->LogMessage(
2906             log,
2907             "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%"
2908             "s, qualified-name='%s')",
2909             DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
2910             dwarf_decl_ctx.GetQualifiedName());
2911       }
2912
2913       // Get the type system that we are looking to find a type for. We will
2914       // use this to ensure any matches we find are in a language that this
2915       // type system supports
2916       const LanguageType language = dwarf_decl_ctx.GetLanguage();
2917       TypeSystem *type_system = nullptr;
2918       if (language != eLanguageTypeUnknown) {
2919         auto type_system_or_err = GetTypeSystemForLanguage(language);
2920         if (auto err = type_system_or_err.takeError()) {
2921           LLDB_LOG_ERROR(
2922               lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
2923               std::move(err), "Cannot get TypeSystem for language {}",
2924               Language::GetNameForLanguageType(language));
2925         } else {
2926           type_system = &type_system_or_err.get();
2927         }
2928       }
2929
2930       m_index->GetTypes(dwarf_decl_ctx, [&](DWARFUnit *main_unit,
2931                                             DWARFDIE type_die) {
2932         // Make sure type_die's langauge matches the type system we are
2933         // looking for. We don't want to find a "Foo" type from Java if we
2934         // are looking for a "Foo" type for C, C++, ObjC, or ObjC++.
2935         if (type_system &&
2936             !type_system->SupportsLanguage(GetLanguage(*type_die.GetMainDWARFUnit(main_unit))))
2937           return true;
2938         bool try_resolving_type = false;
2939
2940         // Don't try and resolve the DIE we are looking for with the DIE
2941         // itself!
2942         const dw_tag_t type_tag = type_die.Tag();
2943         // Make sure the tags match
2944         if (type_tag == tag) {
2945           // The tags match, lets try resolving this type
2946           try_resolving_type = true;
2947         } else {
2948           // The tags don't match, but we need to watch our for a forward
2949           // declaration for a struct and ("struct foo") ends up being a
2950           // class ("class foo { ... };") or vice versa.
2951           switch (type_tag) {
2952           case DW_TAG_class_type:
2953             // We had a "class foo", see if we ended up with a "struct foo
2954             // { ... };"
2955             try_resolving_type = (tag == DW_TAG_structure_type);
2956             break;
2957           case DW_TAG_structure_type:
2958             // We had a "struct foo", see if we ended up with a "class foo
2959             // { ... };"
2960             try_resolving_type = (tag == DW_TAG_class_type);
2961             break;
2962           default:
2963             // Tags don't match, don't event try to resolve using this type
2964             // whose name matches....
2965             break;
2966           }
2967         }
2968
2969         if (!try_resolving_type) {
2970           if (log) {
2971             std::string qualified_name;
2972             type_die.GetQualifiedName(qualified_name);
2973             GetObjectFile()->GetModule()->LogMessage(
2974                 log,
2975                 "SymbolFileDWARF::"
2976                 "FindDefinitionTypeForDWARFDeclContext(tag=%s, "
2977                 "qualified-name='%s') ignoring die=0x%8.8x (%s)",
2978                 DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
2979                 dwarf_decl_ctx.GetQualifiedName(), type_die.GetOffset(),
2980                 qualified_name.c_str());
2981           }
2982           return true;
2983         }
2984
2985         DWARFDeclContext type_dwarf_decl_ctx = GetDWARFDeclContext(main_unit, type_die);
2986
2987         if (log) {
2988           GetObjectFile()->GetModule()->LogMessage(
2989               log,
2990               "SymbolFileDWARF::"
2991               "FindDefinitionTypeForDWARFDeclContext(tag=%s, "
2992               "qualified-name='%s') trying die=0x%8.8x (%s)",
2993               DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
2994               dwarf_decl_ctx.GetQualifiedName(), type_die.GetOffset(),
2995               type_dwarf_decl_ctx.GetQualifiedName());
2996         }
2997
2998         // Make sure the decl contexts match all the way up
2999         if (dwarf_decl_ctx != type_dwarf_decl_ctx)
3000           return true;
3001
3002         Type *resolved_type = ResolveType(main_unit, type_die, false);
3003         if (!resolved_type || resolved_type == DIE_IS_BEING_PARSED)
3004           return true;
3005
3006         type_sp = resolved_type->shared_from_this();
3007         return false;
3008       });
3009     }
3010   }
3011   return type_sp;
3012 }
3013
3014 TypeSP SymbolFileDWARF::ParseType(const SymbolContext &sc, const DWARFDIE &die,
3015                                   bool *type_is_new_ptr) {
3016   if (!die)
3017     return {};
3018
3019   DWARFUnit *main_unit = sc.GetDWARFCompileUnit();
3020   auto type_system_or_err = GetTypeSystemForLanguage(GetLanguage(*die.GetMainDWARFUnit(main_unit)));
3021   if (auto err = type_system_or_err.takeError()) {
3022     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
3023                    std::move(err), "Unable to parse type");
3024     return {};
3025   }
3026
3027   DWARFASTParser *dwarf_ast = type_system_or_err->GetDWARFParser();
3028   if (!dwarf_ast)
3029     return {};
3030
3031   TypeSP type_sp = dwarf_ast->ParseTypeFromDWARF(sc, die, type_is_new_ptr);
3032   if (type_sp) {
3033     GetTypeList().Insert(type_sp);
3034
3035     if (die.Tag() == DW_TAG_subprogram) {
3036       std::string scope_qualified_name(
3037           GetDeclContextForUID(die.GetID(main_unit))
3038               .GetScopeQualifiedName()
3039               .AsCString(""));
3040       if (scope_qualified_name.size()) {
3041         m_function_scope_qualified_name_map[scope_qualified_name].insert(
3042             *die.GetDIERef(main_unit));
3043       }
3044     }
3045   }
3046
3047   return type_sp;
3048 }
3049
3050 size_t SymbolFileDWARF::ParseTypes(const SymbolContext &sc,
3051                                    const DWARFDIE &orig_die,
3052                                    bool parse_siblings, bool parse_children) {
3053   size_t types_added = 0;
3054   DWARFDIE die = orig_die;
3055
3056   while (die) {
3057     const dw_tag_t tag = die.Tag();
3058     bool type_is_new = false;
3059
3060     Tag dwarf_tag = static_cast<Tag>(tag);
3061
3062     // TODO: Currently ParseTypeFromDWARF(...) which is called by ParseType(...)
3063     // does not handle DW_TAG_subrange_type. It is not clear if this is a bug or
3064     // not.
3065     if (isType(dwarf_tag) && tag != DW_TAG_subrange_type)
3066       ParseType(sc, die, &type_is_new);
3067
3068     if (type_is_new)
3069       ++types_added;
3070
3071     if (parse_children && die.HasChildren()) {
3072       if (die.Tag() == DW_TAG_subprogram) {
3073         DWARFUnit *main_unit = sc.GetDWARFCompileUnit();
3074         SymbolContext child_sc(sc);
3075         child_sc.function =
3076             sc.comp_unit->FindFunctionByUID(die.GetID(main_unit)).get();
3077         types_added += ParseTypes(child_sc, die.GetFirstChild(), true, true);
3078       } else
3079         types_added += ParseTypes(sc, die.GetFirstChild(), true, true);
3080     }
3081
3082     if (parse_siblings)
3083       die = die.GetSibling();
3084     else
3085       die.Clear();
3086   }
3087   return types_added;
3088 }
3089
3090 size_t SymbolFileDWARF::ParseBlocksRecursive(Function &func) {
3091   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
3092   CompileUnit *comp_unit = func.GetCompileUnit();
3093   lldbassert(comp_unit);
3094
3095   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(comp_unit);
3096   if (!dwarf_cu)
3097     return 0;
3098
3099   size_t functions_added = 0;
3100   const dw_offset_t function_die_offset = func.GetID();
3101   DWARFDIE function_die =
3102       dwarf_cu->GetNonSkeletonUnit().GetDIE(function_die_offset);
3103   if (function_die) {
3104     ParseBlocksRecursive(*comp_unit, &func.GetBlock(false), function_die,
3105                          LLDB_INVALID_ADDRESS, 0);
3106   }
3107
3108   return functions_added;
3109 }
3110
3111 size_t SymbolFileDWARF::ParseTypes(CompileUnit &comp_unit) {
3112   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
3113   size_t types_added = 0;
3114   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
3115   if (dwarf_cu) {
3116     DWARFDIE dwarf_cu_die = dwarf_cu->DIE();
3117     if (dwarf_cu_die && dwarf_cu_die.HasChildren()) {
3118       SymbolContext sc;
3119       sc.comp_unit = &comp_unit;
3120       sc.module_sp = sc.comp_unit->GetModule();
3121       types_added = ParseTypes(sc, dwarf_cu_die.GetFirstChild(), true, true);
3122     }
3123   }
3124
3125   return types_added;
3126 }
3127
3128 size_t SymbolFileDWARF::ParseVariablesForContext(const SymbolContext &sc) {
3129   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
3130   if (sc.comp_unit != nullptr) {
3131     if (sc.function) {
3132       DWARFDIE function_die = GetDIE(sc.function->GetID());
3133
3134       const dw_addr_t func_lo_pc = function_die.GetAttributeValueAsAddress(
3135           DW_AT_low_pc, LLDB_INVALID_ADDRESS);
3136       if (func_lo_pc != LLDB_INVALID_ADDRESS) {
3137         const size_t num_variables = ParseVariables(
3138             sc, function_die.GetFirstChild(), func_lo_pc, true, true);
3139
3140         // Let all blocks know they have parse all their variables
3141         sc.function->GetBlock(false).SetDidParseVariables(true, true);
3142         return num_variables;
3143       }
3144     } else if (sc.comp_unit) {
3145       DWARFUnit *main_unit = sc.GetDWARFCompileUnit();
3146       if (!main_unit)
3147         return 0;
3148       main_unit = &main_unit->GetNonSkeletonUnit();
3149
3150       uint32_t vars_added = 0;
3151       VariableListSP variables(sc.comp_unit->GetVariableList(false));
3152
3153       if (variables.get() == nullptr) {
3154         variables = std::make_shared<VariableList>();
3155         sc.comp_unit->SetVariableList(variables);
3156
3157         m_index->GetGlobalVariables(
3158             *main_unit,
3159             [&](DWARFUnit *main_unit_check, DWARFDIE die) {
3160               lldbassert(main_unit_check == main_unit || main_unit_check == nullptr);
3161               VariableSP var_sp(
3162                   ParseVariableDIE(sc, die, LLDB_INVALID_ADDRESS));
3163               if (var_sp) {
3164                 variables->AddVariableIfUnique(var_sp);
3165                 ++vars_added;
3166               }
3167               return true;
3168             });
3169       }
3170       return vars_added;
3171     }
3172   }
3173   return 0;
3174 }
3175
3176 VariableSP SymbolFileDWARF::ParseVariableDIE(const SymbolContext &sc,
3177                                              const DWARFDIE &die,
3178                                              const lldb::addr_t func_low_pc) {
3179   //  if (die.GetDWARF() != this)
3180   //    return die.GetDWARF()->ParseVariableDIE(sc, die, func_low_pc);
3181
3182   if (!die)
3183     return nullptr;
3184
3185   DWARFUnit *main_unit = sc.GetDWARFCompileUnit();
3186
3187   if (VariableSP var_sp = GetDIEToVariable()[die.MainCUtoDIEPair(main_unit)])
3188     return var_sp; // Already been parsed!
3189
3190   const dw_tag_t tag = die.Tag();
3191   ModuleSP module = GetObjectFile()->GetModule();
3192
3193   if (tag != DW_TAG_variable && tag != DW_TAG_constant &&
3194       (tag != DW_TAG_formal_parameter || !sc.function))
3195     return nullptr;
3196
3197   DWARFAttributes attributes;
3198   const size_t num_attributes = die.GetAttributes(attributes);
3199   DWARFDIE spec_die;
3200   VariableSP var_sp;
3201   const char *name = nullptr;
3202   const char *mangled = nullptr;
3203   Declaration decl;
3204   DWARFFormValue type_die_form;
3205   DWARFExpression location;
3206   bool is_external = false;
3207   bool is_artificial = false;
3208   DWARFFormValue const_value_form, location_form;
3209   Variable::RangeList scope_ranges;
3210
3211   for (size_t i = 0; i < num_attributes; ++i) {
3212     dw_attr_t attr = attributes.AttributeAtIndex(i);
3213     DWARFFormValue form_value;
3214
3215     if (!attributes.ExtractFormValueAtIndex(i, form_value))
3216       continue;
3217     switch (attr) {
3218     case DW_AT_decl_file:
3219       decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(
3220           form_value.Unsigned()));
3221       break;
3222     case DW_AT_decl_line:
3223       decl.SetLine(form_value.Unsigned());
3224       break;
3225     case DW_AT_decl_column:
3226       decl.SetColumn(form_value.Unsigned());
3227       break;
3228     case DW_AT_name:
3229       name = form_value.AsCString();
3230       break;
3231     case DW_AT_linkage_name:
3232     case DW_AT_MIPS_linkage_name:
3233       mangled = form_value.AsCString();
3234       break;
3235     case DW_AT_type:
3236       type_die_form = form_value;
3237       break;
3238     case DW_AT_external:
3239       is_external = form_value.Boolean();
3240       break;
3241     case DW_AT_const_value:
3242       const_value_form = form_value;
3243       break;
3244     case DW_AT_location:
3245       location_form = form_value;
3246       break;
3247     case DW_AT_specification:
3248       spec_die = form_value.Reference();
3249       break;
3250     case DW_AT_start_scope:
3251       // TODO: Implement this.
3252       break;
3253     case DW_AT_artificial:
3254       is_artificial = form_value.Boolean();
3255       break;
3256     case DW_AT_declaration:
3257     case DW_AT_description:
3258     case DW_AT_endianity:
3259     case DW_AT_segment:
3260     case DW_AT_visibility:
3261     default:
3262     case DW_AT_abstract_origin:
3263     case DW_AT_sibling:
3264       break;
3265     }
3266   }
3267
3268   // Prefer DW_AT_location over DW_AT_const_value. Both can be emitted e.g.
3269   // for static constexpr member variables -- DW_AT_const_value will be
3270   // present in the class declaration and DW_AT_location in the DIE defining
3271   // the member.
3272   bool location_is_const_value_data = false;
3273   bool has_explicit_location = false;
3274   bool use_type_size_for_value = false;
3275   if (location_form.IsValid()) {
3276     has_explicit_location = true;
3277     if (DWARFFormValue::IsBlockForm(location_form.Form())) {
3278       const DWARFDataExtractor &data = die.GetData();
3279
3280       uint32_t block_offset = location_form.BlockData() - data.GetDataStart();
3281       uint32_t block_length = location_form.Unsigned();
3282       location = DWARFExpression(
3283           module, DataExtractor(data, block_offset, block_length), die.GetCU());
3284     } else {
3285       DataExtractor data = die.GetCU()->GetLocationData();
3286       dw_offset_t offset = location_form.Unsigned();
3287       if (location_form.Form() == DW_FORM_loclistx)
3288         offset = die.GetCU()->GetLoclistOffset(offset).getValueOr(-1);
3289       if (data.ValidOffset(offset)) {
3290         data = DataExtractor(data, offset, data.GetByteSize() - offset);
3291         location = DWARFExpression(module, data, die.GetCU());
3292         assert(func_low_pc != LLDB_INVALID_ADDRESS);
3293         location.SetLocationListAddresses(
3294             location_form.GetUnit()->GetBaseAddress(), func_low_pc);
3295       }
3296     }
3297   } else if (const_value_form.IsValid()) {
3298     location_is_const_value_data = true;
3299     // The constant value will be either a block, a data value or a
3300     // string.
3301     const DWARFDataExtractor &debug_info_data = die.GetData();
3302     if (DWARFFormValue::IsBlockForm(const_value_form.Form())) {
3303       // Retrieve the value as a block expression.
3304       uint32_t block_offset =
3305           const_value_form.BlockData() - debug_info_data.GetDataStart();
3306       uint32_t block_length = const_value_form.Unsigned();
3307       location = DWARFExpression(
3308           module, DataExtractor(debug_info_data, block_offset, block_length),
3309           die.GetCU());
3310     } else if (DWARFFormValue::IsDataForm(const_value_form.Form())) {
3311       // Constant value size does not have to match the size of the
3312       // variable. We will fetch the size of the type after we create
3313       // it.
3314       use_type_size_for_value = true;
3315     } else if (const char *str = const_value_form.AsCString()) {
3316       uint32_t string_length = strlen(str) + 1;
3317       location = DWARFExpression(
3318           module,
3319           DataExtractor(str, string_length, die.GetCU()->GetByteOrder(),
3320                         die.GetCU()->GetAddressByteSize()),
3321           die.GetCU());
3322     }