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

   1 //===-- SymbolFileDWARF.cpp ------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "SymbolFileDWARF.h"
  11
  12 // Other libraries and framework includes
  13 #include "llvm/Support/Casting.h"
  14 #include "llvm/Support/Threading.h"
  15
  16 #include "lldb/Core/Module.h"
  17 #include "lldb/Core/ModuleList.h"
  18 #include "lldb/Core/ModuleSpec.h"
  19 #include "lldb/Core/PluginManager.h"
  20 #include "lldb/Core/Scalar.h"
  21 #include "lldb/Core/Section.h"
  22 #include "lldb/Core/StreamFile.h"
  23 #include "lldb/Core/Value.h"
  24 #include "lldb/Utility/ArchSpec.h"
  25 #include "lldb/Utility/RegularExpression.h"
  26 #include "lldb/Utility/StreamString.h"
  27 #include "lldb/Utility/Timer.h"
  28
  29 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
  30
  31 #include "lldb/Host/FileSystem.h"
  32 #include "lldb/Host/Host.h"
  33 #include "lldb/Host/Symbols.h"
  34
  35 #include "lldb/Interpreter/OptionValueFileSpecList.h"
  36 #include "lldb/Interpreter/OptionValueProperties.h"
  37
  38 #include "lldb/Symbol/Block.h"
  39 #include "lldb/Symbol/ClangASTContext.h"
  40 #include "lldb/Symbol/ClangUtil.h"
  41 #include "lldb/Symbol/CompileUnit.h"
  42 #include "lldb/Symbol/CompilerDecl.h"
  43 #include "lldb/Symbol/CompilerDeclContext.h"
  44 #include "lldb/Symbol/DebugMacros.h"
  45 #include "lldb/Symbol/LineTable.h"
  46 #include "lldb/Symbol/ObjectFile.h"
  47 #include "lldb/Symbol/SymbolVendor.h"
  48 #include "lldb/Symbol/TypeMap.h"
  49 #include "lldb/Symbol/TypeSystem.h"
  50 #include "lldb/Symbol/VariableList.h"
  51
  52 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
  53 #include "Plugins/Language/ObjC/ObjCLanguage.h"
  54
  55 #include "lldb/Target/Language.h"
  56
  57 #include "lldb/Host/TaskPool.h"
  58
  59 #include "DWARFASTParser.h"
  60 #include "DWARFASTParserClang.h"
  61 #include "DWARFCompileUnit.h"
  62 #include "DWARFDIECollection.h"
  63 #include "DWARFDebugAbbrev.h"
  64 #include "DWARFDebugAranges.h"
  65 #include "DWARFDebugInfo.h"
  66 #include "DWARFDebugLine.h"
  67 #include "DWARFDebugMacro.h"
  68 #include "DWARFDebugPubnames.h"
  69 #include "DWARFDebugRanges.h"
  70 #include "DWARFDeclContext.h"
  71 #include "DWARFFormValue.h"
  72 #include "LogChannelDWARF.h"
  73 #include "SymbolFileDWARFDebugMap.h"
  74 #include "SymbolFileDWARFDwo.h"
  75 #include "SymbolFileDWARFDwp.h"
  76
  77 #include "llvm/Support/FileSystem.h"
  78
  79 #include <map>
  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 // static inline bool
  97 // child_requires_parent_class_union_or_struct_to_be_completed (dw_tag_t tag)
  98 //{
  99 //    switch (tag)
 100 //    {
 101 //    default:
 102 //        break;
 103 //    case DW_TAG_subprogram:
 104 //    case DW_TAG_inlined_subroutine:
 105 //    case DW_TAG_class_type:
 106 //    case DW_TAG_structure_type:
 107 //    case DW_TAG_union_type:
 108 //        return true;
 109 //    }
 110 //    return false;
 111 //}
 112 //
 113
 114 namespace {
 115
 116 PropertyDefinition g_properties[] = {
 117     {"comp-dir-symlink-paths", OptionValue::eTypeFileSpecList, true, 0, nullptr,
 118      nullptr, "If the DW_AT_comp_dir matches any of these paths the symbolic "
 119               "links will be resolved at DWARF parse time."},
 120     {nullptr, OptionValue::eTypeInvalid, false, 0, nullptr, nullptr, nullptr}};
 121
 122 enum { ePropertySymLinkPaths };
 123
 124 class PluginProperties : public Properties {
 125 public:
 126   static ConstString GetSettingName() {
 127     return SymbolFileDWARF::GetPluginNameStatic();
 128   }
 129
 130   PluginProperties() {
 131     m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
 132     m_collection_sp->Initialize(g_properties);
 133   }
 134
 135   FileSpecList &GetSymLinkPaths() {
 136     OptionValueFileSpecList *option_value =
 137         m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(
 138             nullptr, true, ePropertySymLinkPaths);
 139     assert(option_value);
 140     return option_value->GetCurrentValue();
 141   }
 142 };
 143
 144 typedef std::shared_ptr<PluginProperties> SymbolFileDWARFPropertiesSP;
 145
 146 static const SymbolFileDWARFPropertiesSP &GetGlobalPluginProperties() {
 147   static const auto g_settings_sp(std::make_shared<PluginProperties>());
 148   return g_settings_sp;
 149 }
 150
 151 } // anonymous namespace end
 152
 153 static const char *removeHostnameFromPathname(const char *path_from_dwarf) {
 154   if (!path_from_dwarf || !path_from_dwarf[0]) {
 155     return path_from_dwarf;
 156   }
 157
 158   const char *colon_pos = strchr(path_from_dwarf, ':');
 159   if (nullptr == colon_pos) {
 160     return path_from_dwarf;
 161   }
 162
 163   const char *slash_pos = strchr(path_from_dwarf, '/');
 164   if (slash_pos && (slash_pos < colon_pos)) {
 165     return path_from_dwarf;
 166   }
 167
 168   // check whether we have a windows path, and so the first character
 169   // is a drive-letter not a hostname.
 170   if (colon_pos == path_from_dwarf + 1 && isalpha(*path_from_dwarf) &&
 171       strlen(path_from_dwarf) > 2 && '\\' == path_from_dwarf[2]) {
 172     return path_from_dwarf;
 173   }
 174
 175   return colon_pos + 1;
 176 }
 177
 178 static const char *resolveCompDir(const char *path_from_dwarf) {
 179   if (!path_from_dwarf)
 180     return nullptr;
 181
 182   // DWARF2/3 suggests the form hostname:pathname for compilation directory.
 183   // Remove the host part if present.
 184   const char *local_path = removeHostnameFromPathname(path_from_dwarf);
 185   if (!local_path)
 186     return nullptr;
 187
 188   bool is_symlink = false;
 189   FileSpec local_path_spec(local_path, false);
 190   const auto &file_specs = GetGlobalPluginProperties()->GetSymLinkPaths();
 191   for (size_t i = 0; i < file_specs.GetSize() && !is_symlink; ++i)
 192     is_symlink = FileSpec::Equal(file_specs.GetFileSpecAtIndex(i),
 193                                  local_path_spec, true);
 194
 195   if (!is_symlink)
 196     return local_path;
 197
 198   namespace fs = llvm::sys::fs;
 199   if (fs::get_file_type(local_path_spec.GetPath(), false) !=
 200       fs::file_type::symlink_file)
 201     return local_path;
 202
 203   FileSpec resolved_local_path_spec;
 204   const auto error =
 205       FileSystem::Readlink(local_path_spec, resolved_local_path_spec);
 206   if (error.Success())
 207     return resolved_local_path_spec.GetCString();
 208
 209   return nullptr;
 210 }
 211
 212 DWARFCompileUnit *SymbolFileDWARF::GetBaseCompileUnit() {
 213   return nullptr;
 214 }
 215
 216 void SymbolFileDWARF::Initialize() {
 217   LogChannelDWARF::Initialize();
 218   PluginManager::RegisterPlugin(GetPluginNameStatic(),
 219                                 GetPluginDescriptionStatic(), CreateInstance,
 220                                 DebuggerInitialize);
 221 }
 222
 223 void SymbolFileDWARF::DebuggerInitialize(Debugger &debugger) {
 224   if (!PluginManager::GetSettingForSymbolFilePlugin(
 225           debugger, PluginProperties::GetSettingName())) {
 226     const bool is_global_setting = true;
 227     PluginManager::CreateSettingForSymbolFilePlugin(
 228         debugger, GetGlobalPluginProperties()->GetValueProperties(),
 229         ConstString("Properties for the dwarf symbol-file plug-in."),
 230         is_global_setting);
 231   }
 232 }
 233
 234 void SymbolFileDWARF::Terminate() {
 235   PluginManager::UnregisterPlugin(CreateInstance);
 236   LogChannelDWARF::Terminate();
 237 }
 238
 239 lldb_private::ConstString SymbolFileDWARF::GetPluginNameStatic() {
 240   static ConstString g_name("dwarf");
 241   return g_name;
 242 }
 243
 244 const char *SymbolFileDWARF::GetPluginDescriptionStatic() {
 245   return "DWARF and DWARF3 debug symbol file reader.";
 246 }
 247
 248 SymbolFile *SymbolFileDWARF::CreateInstance(ObjectFile *obj_file) {
 249   return new SymbolFileDWARF(obj_file);
 250 }
 251
 252 TypeList *SymbolFileDWARF::GetTypeList() {
 253   SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
 254   if (debug_map_symfile)
 255     return debug_map_symfile->GetTypeList();
 256   else
 257     return m_obj_file->GetModule()->GetTypeList();
 258 }
 259 void SymbolFileDWARF::GetTypes(const DWARFDIE &die, dw_offset_t min_die_offset,
 260                                dw_offset_t max_die_offset, uint32_t type_mask,
 261                                TypeSet &type_set) {
 262   if (die) {
 263     const dw_offset_t die_offset = die.GetOffset();
 264
 265     if (die_offset >= max_die_offset)
 266       return;
 267
 268     if (die_offset >= min_die_offset) {
 269       const dw_tag_t tag = die.Tag();
 270
 271       bool add_type = false;
 272
 273       switch (tag) {
 274       case DW_TAG_array_type:
 275         add_type = (type_mask & eTypeClassArray) != 0;
 276         break;
 277       case DW_TAG_unspecified_type:
 278       case DW_TAG_base_type:
 279         add_type = (type_mask & eTypeClassBuiltin) != 0;
 280         break;
 281       case DW_TAG_class_type:
 282         add_type = (type_mask & eTypeClassClass) != 0;
 283         break;
 284       case DW_TAG_structure_type:
 285         add_type = (type_mask & eTypeClassStruct) != 0;
 286         break;
 287       case DW_TAG_union_type:
 288         add_type = (type_mask & eTypeClassUnion) != 0;
 289         break;
 290       case DW_TAG_enumeration_type:
 291         add_type = (type_mask & eTypeClassEnumeration) != 0;
 292         break;
 293       case DW_TAG_subroutine_type:
 294       case DW_TAG_subprogram:
 295       case DW_TAG_inlined_subroutine:
 296         add_type = (type_mask & eTypeClassFunction) != 0;
 297         break;
 298       case DW_TAG_pointer_type:
 299         add_type = (type_mask & eTypeClassPointer) != 0;
 300         break;
 301       case DW_TAG_rvalue_reference_type:
 302       case DW_TAG_reference_type:
 303         add_type = (type_mask & eTypeClassReference) != 0;
 304         break;
 305       case DW_TAG_typedef:
 306         add_type = (type_mask & eTypeClassTypedef) != 0;
 307         break;
 308       case DW_TAG_ptr_to_member_type:
 309         add_type = (type_mask & eTypeClassMemberPointer) != 0;
 310         break;
 311       }
 312
 313       if (add_type) {
 314         const bool assert_not_being_parsed = true;
 315         Type *type = ResolveTypeUID(die, assert_not_being_parsed);
 316         if (type) {
 317           if (type_set.find(type) == type_set.end())
 318             type_set.insert(type);
 319         }
 320       }
 321     }
 322
 323     for (DWARFDIE child_die = die.GetFirstChild(); child_die.IsValid();
 324          child_die = child_die.GetSibling()) {
 325       GetTypes(child_die, min_die_offset, max_die_offset, type_mask, type_set);
 326     }
 327   }
 328 }
 329
 330 size_t SymbolFileDWARF::GetTypes(SymbolContextScope *sc_scope,
 331                                  uint32_t type_mask, TypeList &type_list)
 332
 333 {
 334   TypeSet type_set;
 335
 336   CompileUnit *comp_unit = NULL;
 337   DWARFCompileUnit *dwarf_cu = NULL;
 338   if (sc_scope)
 339     comp_unit = sc_scope->CalculateSymbolContextCompileUnit();
 340
 341   if (comp_unit) {
 342     dwarf_cu = GetDWARFCompileUnit(comp_unit);
 343     if (dwarf_cu == 0)
 344       return 0;
 345     GetTypes(dwarf_cu->DIE(), dwarf_cu->GetOffset(),
 346              dwarf_cu->GetNextCompileUnitOffset(), type_mask, type_set);
 347   } else {
 348     DWARFDebugInfo *info = DebugInfo();
 349     if (info) {
 350       const size_t num_cus = info->GetNumCompileUnits();
 351       for (size_t cu_idx = 0; cu_idx < num_cus; ++cu_idx) {
 352         dwarf_cu = info->GetCompileUnitAtIndex(cu_idx);
 353         if (dwarf_cu) {
 354           GetTypes(dwarf_cu->DIE(), 0, UINT32_MAX, type_mask, type_set);
 355         }
 356       }
 357     }
 358   }
 359
 360   std::set<CompilerType> compiler_type_set;
 361   size_t num_types_added = 0;
 362   for (Type *type : type_set) {
 363     CompilerType compiler_type = type->GetForwardCompilerType();
 364     if (compiler_type_set.find(compiler_type) == compiler_type_set.end()) {
 365       compiler_type_set.insert(compiler_type);
 366       type_list.Insert(type->shared_from_this());
 367       ++num_types_added;
 368     }
 369   }
 370   return num_types_added;
 371 }
 372
 373 //----------------------------------------------------------------------
 374 // Gets the first parent that is a lexical block, function or inlined
 375 // subroutine, or compile unit.
 376 //----------------------------------------------------------------------
 377 DWARFDIE
 378 SymbolFileDWARF::GetParentSymbolContextDIE(const DWARFDIE &child_die) {
 379   DWARFDIE die;
 380   for (die = child_die.GetParent(); die; die = die.GetParent()) {
 381     dw_tag_t tag = die.Tag();
 382
 383     switch (tag) {
 384     case DW_TAG_compile_unit:
 385     case DW_TAG_subprogram:
 386     case DW_TAG_inlined_subroutine:
 387     case DW_TAG_lexical_block:
 388       return die;
 389     }
 390   }
 391   return DWARFDIE();
 392 }
 393
 394 SymbolFileDWARF::SymbolFileDWARF(ObjectFile *objfile)
 395     : SymbolFile(objfile), UserID(0), // Used by SymbolFileDWARFDebugMap to when
 396                                       // this class parses .o files to contain
 397                                       // the .o file index/ID
 398       m_debug_map_module_wp(), m_debug_map_symfile(NULL), m_data_debug_abbrev(),
 399       m_data_debug_aranges(), m_data_debug_frame(), m_data_debug_info(),
 400       m_data_debug_line(), m_data_debug_macro(), m_data_debug_loc(),
 401       m_data_debug_ranges(), m_data_debug_str(), m_data_apple_names(),
 402       m_data_apple_types(), m_data_apple_namespaces(), m_abbr(), m_info(),
 403       m_line(), m_apple_names_ap(), m_apple_types_ap(), m_apple_namespaces_ap(),
 404       m_apple_objc_ap(), m_function_basename_index(),
 405       m_function_fullname_index(), m_function_method_index(),
 406       m_function_selector_index(), m_objc_class_selectors_index(),
 407       m_global_index(), m_type_index(), m_namespace_index(), m_indexed(false),
 408       m_using_apple_tables(false), m_fetched_external_modules(false),
 409       m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate), m_ranges(),
 410       m_unique_ast_type_map() {}
 411
 412 SymbolFileDWARF::~SymbolFileDWARF() {}
 413
 414 static const ConstString &GetDWARFMachOSegmentName() {
 415   static ConstString g_dwarf_section_name("__DWARF");
 416   return g_dwarf_section_name;
 417 }
 418
 419 UniqueDWARFASTTypeMap &SymbolFileDWARF::GetUniqueDWARFASTTypeMap() {
 420   SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
 421   if (debug_map_symfile)
 422     return debug_map_symfile->GetUniqueDWARFASTTypeMap();
 423   else
 424     return m_unique_ast_type_map;
 425 }
 426
 427 TypeSystem *SymbolFileDWARF::GetTypeSystemForLanguage(LanguageType language) {
 428   SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
 429   TypeSystem *type_system;
 430   if (debug_map_symfile) {
 431     type_system = debug_map_symfile->GetTypeSystemForLanguage(language);
 432   } else {
 433     type_system = m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
 434     if (type_system)
 435       type_system->SetSymbolFile(this);
 436   }
 437   return type_system;
 438 }
 439
 440 void SymbolFileDWARF::InitializeObject() {
 441   ModuleSP module_sp(m_obj_file->GetModule());
 442   if (module_sp) {
 443     const SectionList *section_list = module_sp->GetSectionList();
 444     Section *section =
 445         section_list->FindSectionByName(GetDWARFMachOSegmentName()).get();
 446
 447     if (section)
 448       m_obj_file->ReadSectionData(section, m_dwarf_data);
 449   }
 450
 451   get_apple_names_data();
 452   if (m_data_apple_names.m_data.GetByteSize() > 0) {
 453     m_apple_names_ap.reset(new DWARFMappedHash::MemoryTable(
 454         m_data_apple_names.m_data, get_debug_str_data(), ".apple_names"));
 455     if (m_apple_names_ap->IsValid())
 456       m_using_apple_tables = true;
 457     else
 458       m_apple_names_ap.reset();
 459   }
 460   get_apple_types_data();
 461   if (m_data_apple_types.m_data.GetByteSize() > 0) {
 462     m_apple_types_ap.reset(new DWARFMappedHash::MemoryTable(
 463         m_data_apple_types.m_data, get_debug_str_data(), ".apple_types"));
 464     if (m_apple_types_ap->IsValid())
 465       m_using_apple_tables = true;
 466     else
 467       m_apple_types_ap.reset();
 468   }
 469
 470   get_apple_namespaces_data();
 471   if (m_data_apple_namespaces.m_data.GetByteSize() > 0) {
 472     m_apple_namespaces_ap.reset(new DWARFMappedHash::MemoryTable(
 473         m_data_apple_namespaces.m_data, get_debug_str_data(),
 474         ".apple_namespaces"));
 475     if (m_apple_namespaces_ap->IsValid())
 476       m_using_apple_tables = true;
 477     else
 478       m_apple_namespaces_ap.reset();
 479   }
 480
 481   get_apple_objc_data();
 482   if (m_data_apple_objc.m_data.GetByteSize() > 0) {
 483     m_apple_objc_ap.reset(new DWARFMappedHash::MemoryTable(
 484         m_data_apple_objc.m_data, get_debug_str_data(), ".apple_objc"));
 485     if (m_apple_objc_ap->IsValid())
 486       m_using_apple_tables = true;
 487     else
 488       m_apple_objc_ap.reset();
 489   }
 490 }
 491
 492 bool SymbolFileDWARF::SupportedVersion(uint16_t version) {
 493   return version == 2 || version == 3 || version == 4;
 494 }
 495
 496 uint32_t SymbolFileDWARF::CalculateAbilities() {
 497   uint32_t abilities = 0;
 498   if (m_obj_file != NULL) {
 499     const Section *section = NULL;
 500     const SectionList *section_list = m_obj_file->GetSectionList();
 501     if (section_list == NULL)
 502       return 0;
 503
 504     // On non Apple platforms we might have .debug_types debug info that
 505     // is created by using "-fdebug-types-section". LLDB currently will try
 506     // to load this debug info, but it causes crashes during debugging when
 507     // types are missing since it doesn't know how to parse the info in
 508     // the .debug_types type units. This causes all complex debug info
 509     // types to be unresolved. Because this causes LLDB to crash and since
 510     // it really doesn't provide a solid debuggiung experience, we should
 511     // disable trying to debug this kind of DWARF until support gets
 512     // added or deprecated.
 513     if (section_list->FindSectionByName(ConstString(".debug_types"))) {
 514       m_obj_file->GetModule()->ReportWarning(
 515         "lldb doesn’t support .debug_types debug info");
 516       return 0;
 517     }
 518
 519     uint64_t debug_abbrev_file_size = 0;
 520     uint64_t debug_info_file_size = 0;
 521     uint64_t debug_line_file_size = 0;
 522
 523     section = section_list->FindSectionByName(GetDWARFMachOSegmentName()).get();
 524
 525     if (section)
 526       section_list = &section->GetChildren();
 527
 528     section =
 529         section_list->FindSectionByType(eSectionTypeDWARFDebugInfo, true).get();
 530     if (section != NULL) {
 531       debug_info_file_size = section->GetFileSize();
 532
 533       section =
 534           section_list->FindSectionByType(eSectionTypeDWARFDebugAbbrev, true)
 535               .get();
 536       if (section)
 537         debug_abbrev_file_size = section->GetFileSize();
 538
 539       DWARFDebugAbbrev *abbrev = DebugAbbrev();
 540       if (abbrev) {
 541         std::set<dw_form_t> invalid_forms;
 542         abbrev->GetUnsupportedForms(invalid_forms);
 543         if (!invalid_forms.empty()) {
 544           StreamString error;
 545           error.Printf("unsupported DW_FORM value%s:", invalid_forms.size() > 1 ? "s" : "");
 546           for (auto form : invalid_forms)
 547             error.Printf(" %#x", form);
 548           m_obj_file->GetModule()->ReportWarning("%s", error.GetString().str().c_str());
 549           return 0;
 550         }
 551       }
 552
 553       section =
 554           section_list->FindSectionByType(eSectionTypeDWARFDebugLine, true)
 555               .get();
 556       if (section)
 557         debug_line_file_size = section->GetFileSize();
 558     } else {
 559       const char *symfile_dir_cstr =
 560           m_obj_file->GetFileSpec().GetDirectory().GetCString();
 561       if (symfile_dir_cstr) {
 562         if (strcasestr(symfile_dir_cstr, ".dsym")) {
 563           if (m_obj_file->GetType() == ObjectFile::eTypeDebugInfo) {
 564             // We have a dSYM file that didn't have a any debug info.
 565             // If the string table has a size of 1, then it was made from
 566             // an executable with no debug info, or from an executable that
 567             // was stripped.
 568             section =
 569                 section_list->FindSectionByType(eSectionTypeDWARFDebugStr, true)
 570                     .get();
 571             if (section && section->GetFileSize() == 1) {
 572               m_obj_file->GetModule()->ReportWarning(
 573                   "empty dSYM file detected, dSYM was created with an "
 574                   "executable with no debug info.");
 575             }
 576           }
 577         }
 578       }
 579     }
 580
 581     if (debug_abbrev_file_size > 0 && debug_info_file_size > 0)
 582       abilities |= CompileUnits | Functions | Blocks | GlobalVariables |
 583                    LocalVariables | VariableTypes;
 584
 585     if (debug_line_file_size > 0)
 586       abilities |= LineTables;
 587   }
 588   return abilities;
 589 }
 590
 591 const DWARFDataExtractor &
 592 SymbolFileDWARF::GetCachedSectionData(lldb::SectionType sect_type,
 593                                       DWARFDataSegment &data_segment) {
 594   llvm::call_once(data_segment.m_flag, [this, sect_type, &data_segment] {
 595     this->LoadSectionData(sect_type, std::ref(data_segment.m_data));
 596   });
 597   return data_segment.m_data;
 598 }
 599
 600 void SymbolFileDWARF::LoadSectionData(lldb::SectionType sect_type,
 601                                       DWARFDataExtractor &data) {
 602   ModuleSP module_sp(m_obj_file->GetModule());
 603   const SectionList *section_list = module_sp->GetSectionList();
 604   if (section_list) {
 605     SectionSP section_sp(section_list->FindSectionByType(sect_type, true));
 606     if (section_sp) {
 607       // See if we memory mapped the DWARF segment?
 608       if (m_dwarf_data.GetByteSize()) {
 609         data.SetData(m_dwarf_data, section_sp->GetOffset(),
 610                      section_sp->GetFileSize());
 611       } else {
 612         if (m_obj_file->ReadSectionData(section_sp.get(), data) == 0)
 613           data.Clear();
 614       }
 615     }
 616   }
 617 }
 618
 619 const DWARFDataExtractor &SymbolFileDWARF::get_debug_abbrev_data() {
 620   return GetCachedSectionData(eSectionTypeDWARFDebugAbbrev,
 621                               m_data_debug_abbrev);
 622 }
 623
 624 const DWARFDataExtractor &SymbolFileDWARF::get_debug_addr_data() {
 625   return GetCachedSectionData(eSectionTypeDWARFDebugAddr, m_data_debug_addr);
 626 }
 627
 628 const DWARFDataExtractor &SymbolFileDWARF::get_debug_aranges_data() {
 629   return GetCachedSectionData(eSectionTypeDWARFDebugAranges,
 630                               m_data_debug_aranges);
 631 }
 632
 633 const DWARFDataExtractor &SymbolFileDWARF::get_debug_frame_data() {
 634   return GetCachedSectionData(eSectionTypeDWARFDebugFrame, m_data_debug_frame);
 635 }
 636
 637 const DWARFDataExtractor &SymbolFileDWARF::get_debug_info_data() {
 638   return GetCachedSectionData(eSectionTypeDWARFDebugInfo, m_data_debug_info);
 639 }
 640
 641 const DWARFDataExtractor &SymbolFileDWARF::get_debug_line_data() {
 642   return GetCachedSectionData(eSectionTypeDWARFDebugLine, m_data_debug_line);
 643 }
 644
 645 const DWARFDataExtractor &SymbolFileDWARF::get_debug_macro_data() {
 646   return GetCachedSectionData(eSectionTypeDWARFDebugMacro, m_data_debug_macro);
 647 }
 648
 649 const DWARFDataExtractor &SymbolFileDWARF::get_debug_loc_data() {
 650   return GetCachedSectionData(eSectionTypeDWARFDebugLoc, m_data_debug_loc);
 651 }
 652
 653 const DWARFDataExtractor &SymbolFileDWARF::get_debug_ranges_data() {
 654   return GetCachedSectionData(eSectionTypeDWARFDebugRanges,
 655                               m_data_debug_ranges);
 656 }
 657
 658 const DWARFDataExtractor &SymbolFileDWARF::get_debug_str_data() {
 659   return GetCachedSectionData(eSectionTypeDWARFDebugStr, m_data_debug_str);
 660 }
 661
 662 const DWARFDataExtractor &SymbolFileDWARF::get_debug_str_offsets_data() {
 663   return GetCachedSectionData(eSectionTypeDWARFDebugStrOffsets,
 664                               m_data_debug_str_offsets);
 665 }
 666
 667 const DWARFDataExtractor &SymbolFileDWARF::get_apple_names_data() {
 668   return GetCachedSectionData(eSectionTypeDWARFAppleNames, m_data_apple_names);
 669 }
 670
 671 const DWARFDataExtractor &SymbolFileDWARF::get_apple_types_data() {
 672   return GetCachedSectionData(eSectionTypeDWARFAppleTypes, m_data_apple_types);
 673 }
 674
 675 const DWARFDataExtractor &SymbolFileDWARF::get_apple_namespaces_data() {
 676   return GetCachedSectionData(eSectionTypeDWARFAppleNamespaces,
 677                               m_data_apple_namespaces);
 678 }
 679
 680 const DWARFDataExtractor &SymbolFileDWARF::get_apple_objc_data() {
 681   return GetCachedSectionData(eSectionTypeDWARFAppleObjC, m_data_apple_objc);
 682 }
 683
 684 DWARFDebugAbbrev *SymbolFileDWARF::DebugAbbrev() {
 685   if (m_abbr.get() == NULL) {
 686     const DWARFDataExtractor &debug_abbrev_data = get_debug_abbrev_data();
 687     if (debug_abbrev_data.GetByteSize() > 0) {
 688       m_abbr.reset(new DWARFDebugAbbrev());
 689       if (m_abbr.get())
 690         m_abbr->Parse(debug_abbrev_data);
 691     }
 692   }
 693   return m_abbr.get();
 694 }
 695
 696 const DWARFDebugAbbrev *SymbolFileDWARF::DebugAbbrev() const {
 697   return m_abbr.get();
 698 }
 699
 700 DWARFDebugInfo *SymbolFileDWARF::DebugInfo() {
 701   if (m_info.get() == NULL) {
 702     static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
 703     Timer scoped_timer(func_cat, "%s this = %p", LLVM_PRETTY_FUNCTION,
 704                        static_cast<void *>(this));
 705     if (get_debug_info_data().GetByteSize() > 0) {
 706       m_info.reset(new DWARFDebugInfo());
 707       if (m_info.get()) {
 708         m_info->SetDwarfData(this);
 709       }
 710     }
 711   }
 712   return m_info.get();
 713 }
 714
 715 const DWARFDebugInfo *SymbolFileDWARF::DebugInfo() const {
 716   return m_info.get();
 717 }
 718
 719 DWARFCompileUnit *
 720 SymbolFileDWARF::GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit) {
 721   if (!comp_unit)
 722     return nullptr;
 723
 724   DWARFDebugInfo *info = DebugInfo();
 725   if (info) {
 726     // Just a normal DWARF file whose user ID for the compile unit is
 727     // the DWARF offset itself
 728
 729     DWARFCompileUnit *dwarf_cu =
 730         info->GetCompileUnit((dw_offset_t)comp_unit->GetID());
 731     if (dwarf_cu && dwarf_cu->GetUserData() == NULL)
 732       dwarf_cu->SetUserData(comp_unit);
 733     return dwarf_cu;
 734   }
 735   return NULL;
 736 }
 737
 738 DWARFDebugRanges *SymbolFileDWARF::DebugRanges() {
 739   if (m_ranges.get() == NULL) {
 740     static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
 741     Timer scoped_timer(func_cat, "%s this = %p", LLVM_PRETTY_FUNCTION,
 742                        static_cast<void *>(this));
 743     if (get_debug_ranges_data().GetByteSize() > 0) {
 744       m_ranges.reset(new DWARFDebugRanges());
 745       if (m_ranges.get())
 746         m_ranges->Extract(this);
 747     }
 748   }
 749   return m_ranges.get();
 750 }
 751
 752 const DWARFDebugRanges *SymbolFileDWARF::DebugRanges() const {
 753   return m_ranges.get();
 754 }
 755
 756 lldb::CompUnitSP SymbolFileDWARF::ParseCompileUnit(DWARFCompileUnit *dwarf_cu,
 757                                                    uint32_t cu_idx) {
 758   CompUnitSP cu_sp;
 759   if (dwarf_cu) {
 760     CompileUnit *comp_unit = (CompileUnit *)dwarf_cu->GetUserData();
 761     if (comp_unit) {
 762       // We already parsed this compile unit, had out a shared pointer to it
 763       cu_sp = comp_unit->shared_from_this();
 764     } else {
 765       if (dwarf_cu->GetSymbolFileDWARF() != this) {
 766         return dwarf_cu->GetSymbolFileDWARF()->ParseCompileUnit(dwarf_cu,
 767                                                                 cu_idx);
 768       } else if (dwarf_cu->GetOffset() == 0 && GetDebugMapSymfile()) {
 769         // Let the debug map create the compile unit
 770         cu_sp = m_debug_map_symfile->GetCompileUnit(this);
 771         dwarf_cu->SetUserData(cu_sp.get());
 772       } else {
 773         ModuleSP module_sp(m_obj_file->GetModule());
 774         if (module_sp) {
 775           const DWARFDIE cu_die = dwarf_cu->GetCompileUnitDIEOnly();
 776           if (cu_die) {
 777             FileSpec cu_file_spec{cu_die.GetName(), false};
 778             if (cu_file_spec) {
 779               // If we have a full path to the compile unit, we don't need to
 780               // resolve
 781               // the file.  This can be expensive e.g. when the source files are
 782               // NFS mounted.
 783               if (cu_file_spec.IsRelative()) {
 784                 const char *cu_comp_dir{
 785                     cu_die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr)};
 786                 cu_file_spec.PrependPathComponent(resolveCompDir(cu_comp_dir));
 787               }
 788
 789               std::string remapped_file;
 790               if (module_sp->RemapSourceFile(cu_file_spec.GetPath(),
 791                                              remapped_file))
 792                 cu_file_spec.SetFile(remapped_file, false);
 793             }
 794
 795             LanguageType cu_language = DWARFCompileUnit::LanguageTypeFromDWARF(
 796                 cu_die.GetAttributeValueAsUnsigned(DW_AT_language, 0));
 797
 798             bool is_optimized = dwarf_cu->GetIsOptimized();
 799             cu_sp.reset(new CompileUnit(
 800                 module_sp, dwarf_cu, cu_file_spec, dwarf_cu->GetID(),
 801                 cu_language, is_optimized ? eLazyBoolYes : eLazyBoolNo));
 802             if (cu_sp) {
 803               // If we just created a compile unit with an invalid file spec,
 804               // try and get the
 805               // first entry in the supports files from the line table as that
 806               // should be the
 807               // compile unit.
 808               if (!cu_file_spec) {
 809                 cu_file_spec = cu_sp->GetSupportFiles().GetFileSpecAtIndex(1);
 810                 if (cu_file_spec) {
 811                   (FileSpec &)(*cu_sp) = cu_file_spec;
 812                   // Also fix the invalid file spec which was copied from the
 813                   // compile unit.
 814                   cu_sp->GetSupportFiles().Replace(0, cu_file_spec);
 815                 }
 816               }
 817
 818               dwarf_cu->SetUserData(cu_sp.get());
 819
 820               // Figure out the compile unit index if we weren't given one
 821               if (cu_idx == UINT32_MAX)
 822                 DebugInfo()->GetCompileUnit(dwarf_cu->GetOffset(), &cu_idx);
 823
 824               m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(
 825                   cu_idx, cu_sp);
 826             }
 827           }
 828         }
 829       }
 830     }
 831   }
 832   return cu_sp;
 833 }
 834
 835 uint32_t SymbolFileDWARF::GetNumCompileUnits() {
 836   DWARFDebugInfo *info = DebugInfo();
 837   if (info)
 838     return info->GetNumCompileUnits();
 839   return 0;
 840 }
 841
 842 CompUnitSP SymbolFileDWARF::ParseCompileUnitAtIndex(uint32_t cu_idx) {
 843   CompUnitSP cu_sp;
 844   DWARFDebugInfo *info = DebugInfo();
 845   if (info) {
 846     DWARFCompileUnit *dwarf_cu = info->GetCompileUnitAtIndex(cu_idx);
 847     if (dwarf_cu)
 848       cu_sp = ParseCompileUnit(dwarf_cu, cu_idx);
 849   }
 850   return cu_sp;
 851 }
 852
 853 Function *SymbolFileDWARF::ParseCompileUnitFunction(const SymbolContext &sc,
 854                                                     const DWARFDIE &die) {
 855   if (die.IsValid()) {
 856     TypeSystem *type_system =
 857         GetTypeSystemForLanguage(die.GetCU()->GetLanguageType());
 858
 859     if (type_system) {
 860       DWARFASTParser *dwarf_ast = type_system->GetDWARFParser();
 861       if (dwarf_ast)
 862         return dwarf_ast->ParseFunctionFromDWARF(sc, die);
 863     }
 864   }
 865   return nullptr;
 866 }
 867
 868 bool SymbolFileDWARF::FixupAddress(Address &addr) {
 869   SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
 870   if (debug_map_symfile) {
 871     return debug_map_symfile->LinkOSOAddress(addr);
 872   }
 873   // This is a normal DWARF file, no address fixups need to happen
 874   return true;
 875 }
 876 lldb::LanguageType
 877 SymbolFileDWARF::ParseCompileUnitLanguage(const SymbolContext &sc) {
 878   assert(sc.comp_unit);
 879   DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
 880   if (dwarf_cu)
 881     return dwarf_cu->GetLanguageType();
 882   else
 883     return eLanguageTypeUnknown;
 884 }
 885
 886 size_t SymbolFileDWARF::ParseCompileUnitFunctions(const SymbolContext &sc) {
 887   assert(sc.comp_unit);
 888   size_t functions_added = 0;
 889   DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
 890   if (dwarf_cu) {
 891     DWARFDIECollection function_dies;
 892     const size_t num_functions =
 893         dwarf_cu->AppendDIEsWithTag(DW_TAG_subprogram, function_dies);
 894     size_t func_idx;
 895     for (func_idx = 0; func_idx < num_functions; ++func_idx) {
 896       DWARFDIE die = function_dies.GetDIEAtIndex(func_idx);
 897       if (sc.comp_unit->FindFunctionByUID(die.GetID()).get() == NULL) {
 898         if (ParseCompileUnitFunction(sc, die))
 899           ++functions_added;
 900       }
 901     }
 902     // FixupTypes();
 903   }
 904   return functions_added;
 905 }
 906
 907 bool SymbolFileDWARF::ParseCompileUnitSupportFiles(
 908     const SymbolContext &sc, FileSpecList &support_files) {
 909   assert(sc.comp_unit);
 910   DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
 911   if (dwarf_cu) {
 912     const DWARFDIE cu_die = dwarf_cu->GetCompileUnitDIEOnly();
 913
 914     if (cu_die) {
 915       const char *cu_comp_dir = resolveCompDir(
 916           cu_die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr));
 917       const dw_offset_t stmt_list = cu_die.GetAttributeValueAsUnsigned(
 918           DW_AT_stmt_list, DW_INVALID_OFFSET);
 919       if (stmt_list != DW_INVALID_OFFSET) {
 920         // All file indexes in DWARF are one based and a file of index zero is
 921         // supposed to be the compile unit itself.
 922         support_files.Append(*sc.comp_unit);
 923         return DWARFDebugLine::ParseSupportFiles(
 924             sc.comp_unit->GetModule(), get_debug_line_data(), cu_comp_dir,
 925             stmt_list, support_files);
 926       }
 927     }
 928   }
 929   return false;
 930 }
 931
 932 bool SymbolFileDWARF::ParseCompileUnitIsOptimized(
 933     const lldb_private::SymbolContext &sc) {
 934   DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
 935   if (dwarf_cu)
 936     return dwarf_cu->GetIsOptimized();
 937   return false;
 938 }
 939
 940 bool SymbolFileDWARF::ParseImportedModules(
 941     const lldb_private::SymbolContext &sc,
 942     std::vector<lldb_private::ConstString> &imported_modules) {
 943   assert(sc.comp_unit);
 944   DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
 945   if (dwarf_cu) {
 946     if (ClangModulesDeclVendor::LanguageSupportsClangModules(
 947             sc.comp_unit->GetLanguage())) {
 948       UpdateExternalModuleListIfNeeded();
 949
 950       if (sc.comp_unit) {
 951         const DWARFDIE die = dwarf_cu->GetCompileUnitDIEOnly();
 952
 953         if (die) {
 954           for (DWARFDIE child_die = die.GetFirstChild(); child_die;
 955                child_die = child_die.GetSibling()) {
 956             if (child_die.Tag() == DW_TAG_imported_declaration) {
 957               if (DWARFDIE module_die =
 958                       child_die.GetReferencedDIE(DW_AT_import)) {
 959                 if (module_die.Tag() == DW_TAG_module) {
 960                   if (const char *name = module_die.GetAttributeValueAsString(
 961                           DW_AT_name, nullptr)) {
 962                     ConstString const_name(name);
 963                     imported_modules.push_back(const_name);
 964                   }
 965                 }
 966               }
 967             }
 968           }
 969         }
 970       } else {
 971         for (const auto &pair : m_external_type_modules) {
 972           imported_modules.push_back(pair.first);
 973         }
 974       }
 975     }
 976   }
 977   return false;
 978 }
 979
 980 struct ParseDWARFLineTableCallbackInfo {
 981   LineTable *line_table;
 982   std::unique_ptr<LineSequence> sequence_ap;
 983   lldb::addr_t addr_mask;
 984 };
 985
 986 //----------------------------------------------------------------------
 987 // ParseStatementTableCallback
 988 //----------------------------------------------------------------------
 989 static void ParseDWARFLineTableCallback(dw_offset_t offset,
 990                                         const DWARFDebugLine::State &state,
 991                                         void *userData) {
 992   if (state.row == DWARFDebugLine::State::StartParsingLineTable) {
 993     // Just started parsing the line table
 994   } else if (state.row == DWARFDebugLine::State::DoneParsingLineTable) {
 995     // Done parsing line table, nothing to do for the cleanup
 996   } else {
 997     ParseDWARFLineTableCallbackInfo *info =
 998         (ParseDWARFLineTableCallbackInfo *)userData;
 999     LineTable *line_table = info->line_table;
1000
1001     // If this is our first time here, we need to create a
1002     // sequence container.
1003     if (!info->sequence_ap.get()) {
1004       info->sequence_ap.reset(line_table->CreateLineSequenceContainer());
1005       assert(info->sequence_ap.get());
1006     }
1007     line_table->AppendLineEntryToSequence(
1008         info->sequence_ap.get(), state.address & info->addr_mask, state.line,
1009         state.column, state.file, state.is_stmt, state.basic_block,
1010         state.prologue_end, state.epilogue_begin, state.end_sequence);
1011     if (state.end_sequence) {
1012       // First, put the current sequence into the line table.
1013       line_table->InsertSequence(info->sequence_ap.get());
1014       // Then, empty it to prepare for the next sequence.
1015       info->sequence_ap->Clear();
1016     }
1017   }
1018 }
1019
1020 bool SymbolFileDWARF::ParseCompileUnitLineTable(const SymbolContext &sc) {
1021   assert(sc.comp_unit);
1022   if (sc.comp_unit->GetLineTable() != NULL)
1023     return true;
1024
1025   DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
1026   if (dwarf_cu) {
1027     const DWARFDIE dwarf_cu_die = dwarf_cu->GetCompileUnitDIEOnly();
1028     if (dwarf_cu_die) {
1029       const dw_offset_t cu_line_offset =
1030           dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_stmt_list,
1031                                                    DW_INVALID_OFFSET);
1032       if (cu_line_offset != DW_INVALID_OFFSET) {
1033         std::unique_ptr<LineTable> line_table_ap(new LineTable(sc.comp_unit));
1034         if (line_table_ap.get()) {
1035           ParseDWARFLineTableCallbackInfo info;
1036           info.line_table = line_table_ap.get();
1037
1038           /*
1039            * MIPS:
1040            * The SymbolContext may not have a valid target, thus we may not be
1041            * able
1042            * to call Address::GetOpcodeLoadAddress() which would clear the bit
1043            * #0
1044            * for MIPS. Use ArchSpec to clear the bit #0.
1045           */
1046           ArchSpec arch;
1047           GetObjectFile()->GetArchitecture(arch);
1048           switch (arch.GetMachine()) {
1049           case llvm::Triple::mips:
1050           case llvm::Triple::mipsel:
1051           case llvm::Triple::mips64:
1052           case llvm::Triple::mips64el:
1053             info.addr_mask = ~((lldb::addr_t)1);
1054             break;
1055           default:
1056             info.addr_mask = ~((lldb::addr_t)0);
1057             break;
1058           }
1059
1060           lldb::offset_t offset = cu_line_offset;
1061           DWARFDebugLine::ParseStatementTable(get_debug_line_data(), &offset,
1062                                               ParseDWARFLineTableCallback,
1063                                               &info);
1064           SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
1065           if (debug_map_symfile) {
1066             // We have an object file that has a line table with addresses
1067             // that are not linked. We need to link the line table and convert
1068             // the addresses that are relative to the .o file into addresses
1069             // for the main executable.
1070             sc.comp_unit->SetLineTable(
1071                 debug_map_symfile->LinkOSOLineTable(this, line_table_ap.get()));
1072           } else {
1073             sc.comp_unit->SetLineTable(line_table_ap.release());
1074             return true;
1075           }
1076         }
1077       }
1078     }
1079   }
1080   return false;
1081 }
1082
1083 lldb_private::DebugMacrosSP
1084 SymbolFileDWARF::ParseDebugMacros(lldb::offset_t *offset) {
1085   auto iter = m_debug_macros_map.find(*offset);
1086   if (iter != m_debug_macros_map.end())
1087     return iter->second;
1088
1089   const DWARFDataExtractor &debug_macro_data = get_debug_macro_data();
1090   if (debug_macro_data.GetByteSize() == 0)
1091     return DebugMacrosSP();
1092
1093   lldb_private::DebugMacrosSP debug_macros_sp(new lldb_private::DebugMacros());
1094   m_debug_macros_map[*offset] = debug_macros_sp;
1095
1096   const DWARFDebugMacroHeader &header =
1097       DWARFDebugMacroHeader::ParseHeader(debug_macro_data, offset);
1098   DWARFDebugMacroEntry::ReadMacroEntries(debug_macro_data, get_debug_str_data(),
1099                                          header.OffsetIs64Bit(), offset, this,
1100                                          debug_macros_sp);
1101
1102   return debug_macros_sp;
1103 }
1104
1105 bool SymbolFileDWARF::ParseCompileUnitDebugMacros(const SymbolContext &sc) {
1106   assert(sc.comp_unit);
1107
1108   DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
1109   if (dwarf_cu == nullptr)
1110     return false;
1111
1112   const DWARFDIE dwarf_cu_die = dwarf_cu->GetCompileUnitDIEOnly();
1113   if (!dwarf_cu_die)
1114     return false;
1115
1116   lldb::offset_t sect_offset =
1117       dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_macros, DW_INVALID_OFFSET);
1118   if (sect_offset == DW_INVALID_OFFSET)
1119     sect_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_GNU_macros,
1120                                                            DW_INVALID_OFFSET);
1121   if (sect_offset == DW_INVALID_OFFSET)
1122     return false;
1123
1124   sc.comp_unit->SetDebugMacros(ParseDebugMacros(&sect_offset));
1125
1126   return true;
1127 }
1128
1129 size_t SymbolFileDWARF::ParseFunctionBlocks(const SymbolContext &sc,
1130                                             Block *parent_block,
1131                                             const DWARFDIE &orig_die,
1132                                             addr_t subprogram_low_pc,
1133                                             uint32_t depth) {
1134   size_t blocks_added = 0;
1135   DWARFDIE die = orig_die;
1136   while (die) {
1137     dw_tag_t tag = die.Tag();
1138
1139     switch (tag) {
1140     case DW_TAG_inlined_subroutine:
1141     case DW_TAG_subprogram:
1142     case DW_TAG_lexical_block: {
1143       Block *block = NULL;
1144       if (tag == DW_TAG_subprogram) {
1145         // Skip any DW_TAG_subprogram DIEs that are inside
1146         // of a normal or inlined functions. These will be
1147         // parsed on their own as separate entities.
1148
1149         if (depth > 0)
1150           break;
1151
1152         block = parent_block;
1153       } else {
1154         BlockSP block_sp(new Block(die.GetID()));
1155         parent_block->AddChild(block_sp);
1156         block = block_sp.get();
1157       }
1158       DWARFRangeList ranges;
1159       const char *name = NULL;
1160       const char *mangled_name = NULL;
1161
1162       int decl_file = 0;
1163       int decl_line = 0;
1164       int decl_column = 0;
1165       int call_file = 0;
1166       int call_line = 0;
1167       int call_column = 0;
1168       if (die.GetDIENamesAndRanges(name, mangled_name, ranges, decl_file,
1169                                    decl_line, decl_column, call_file, call_line,
1170                                    call_column, nullptr)) {
1171         if (tag == DW_TAG_subprogram) {
1172           assert(subprogram_low_pc == LLDB_INVALID_ADDRESS);
1173           subprogram_low_pc = ranges.GetMinRangeBase(0);
1174         } else if (tag == DW_TAG_inlined_subroutine) {
1175           // We get called here for inlined subroutines in two ways.
1176           // The first time is when we are making the Function object
1177           // for this inlined concrete instance.  Since we're creating a top
1178           // level block at
1179           // here, the subprogram_low_pc will be LLDB_INVALID_ADDRESS.  So we
1180           // need to
1181           // adjust the containing address.
1182           // The second time is when we are parsing the blocks inside the
1183           // function that contains
1184           // the inlined concrete instance.  Since these will be blocks inside
1185           // the containing "real"
1186           // function the offset will be for that function.
1187           if (subprogram_low_pc == LLDB_INVALID_ADDRESS) {
1188             subprogram_low_pc = ranges.GetMinRangeBase(0);
1189           }
1190         }
1191
1192         const size_t num_ranges = ranges.GetSize();
1193         for (size_t i = 0; i < num_ranges; ++i) {
1194           const DWARFRangeList::Entry &range = ranges.GetEntryRef(i);
1195           const addr_t range_base = range.GetRangeBase();
1196           if (range_base >= subprogram_low_pc)
1197             block->AddRange(Block::Range(range_base - subprogram_low_pc,
1198                                          range.GetByteSize()));
1199           else {
1200             GetObjectFile()->GetModule()->ReportError(
1201                 "0x%8.8" PRIx64 ": adding range [0x%" PRIx64 "-0x%" PRIx64
1202                 ") which has a base that is less than the function's low PC "
1203                 "0x%" PRIx64 ". Please file a bug and attach the file at the "
1204                              "start of this error message",
1205                 block->GetID(), range_base, range.GetRangeEnd(),
1206                 subprogram_low_pc);
1207           }
1208         }
1209         block->FinalizeRanges();
1210
1211         if (tag != DW_TAG_subprogram &&
1212             (name != NULL || mangled_name != NULL)) {
1213           std::unique_ptr<Declaration> decl_ap;
1214           if (decl_file != 0 || decl_line != 0 || decl_column != 0)
1215             decl_ap.reset(new Declaration(
1216                 sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(decl_file),
1217                 decl_line, decl_column));
1218
1219           std::unique_ptr<Declaration> call_ap;
1220           if (call_file != 0 || call_line != 0 || call_column != 0)
1221             call_ap.reset(new Declaration(
1222                 sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(call_file),
1223                 call_line, call_column));
1224
1225           block->SetInlinedFunctionInfo(name, mangled_name, decl_ap.get(),
1226                                         call_ap.get());
1227         }
1228
1229         ++blocks_added;
1230
1231         if (die.HasChildren()) {
1232           blocks_added += ParseFunctionBlocks(sc, block, die.GetFirstChild(),
1233                                               subprogram_low_pc, depth + 1);
1234         }
1235       }
1236     } break;
1237     default:
1238       break;
1239     }
1240
1241     // Only parse siblings of the block if we are not at depth zero. A depth
1242     // of zero indicates we are currently parsing the top level
1243     // DW_TAG_subprogram DIE
1244
1245     if (depth == 0)
1246       die.Clear();
1247     else
1248       die = die.GetSibling();
1249   }
1250   return blocks_added;
1251 }
1252
1253 bool SymbolFileDWARF::ClassOrStructIsVirtual(const DWARFDIE &parent_die) {
1254   if (parent_die) {
1255     for (DWARFDIE die = parent_die.GetFirstChild(); die;
1256          die = die.GetSibling()) {
1257       dw_tag_t tag = die.Tag();
1258       bool check_virtuality = false;
1259       switch (tag) {
1260       case DW_TAG_inheritance:
1261       case DW_TAG_subprogram:
1262         check_virtuality = true;
1263         break;
1264       default:
1265         break;
1266       }
1267       if (check_virtuality) {
1268         if (die.GetAttributeValueAsUnsigned(DW_AT_virtuality, 0) != 0)
1269           return true;
1270       }
1271     }
1272   }
1273   return false;
1274 }
1275
1276 void SymbolFileDWARF::ParseDeclsForContext(CompilerDeclContext decl_ctx) {
1277   TypeSystem *type_system = decl_ctx.GetTypeSystem();
1278   DWARFASTParser *ast_parser = type_system->GetDWARFParser();
1279   std::vector<DWARFDIE> decl_ctx_die_list =
1280       ast_parser->GetDIEForDeclContext(decl_ctx);
1281
1282   for (DWARFDIE decl_ctx_die : decl_ctx_die_list)
1283     for (DWARFDIE decl = decl_ctx_die.GetFirstChild(); decl;
1284          decl = decl.GetSibling())
1285       ast_parser->GetDeclForUIDFromDWARF(decl);
1286 }
1287
1288 SymbolFileDWARF *SymbolFileDWARF::GetDWARFForUID(lldb::user_id_t uid) {
1289   // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API
1290   // we must make sure we use the correct DWARF file when resolving things.
1291   // On MacOSX, when using SymbolFileDWARFDebugMap, we will use multiple
1292   // SymbolFileDWARF classes, one for each .o file. We can often end up
1293   // with references to other DWARF objects and we must be ready to receive
1294   // a "lldb::user_id_t" that specifies a DIE from another SymbolFileDWARF
1295   // instance.
1296   SymbolFileDWARFDebugMap *debug_map = GetDebugMapSymfile();
1297   if (debug_map)
1298     return debug_map->GetSymbolFileByOSOIndex(
1299         debug_map->GetOSOIndexFromUserID(uid));
1300   return this;
1301 }
1302
1303 DWARFDIE
1304 SymbolFileDWARF::GetDIEFromUID(lldb::user_id_t uid) {
1305   // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API
1306   // we must make sure we use the correct DWARF file when resolving things.
1307   // On MacOSX, when using SymbolFileDWARFDebugMap, we will use multiple
1308   // SymbolFileDWARF classes, one for each .o file. We can often end up
1309   // with references to other DWARF objects and we must be ready to receive
1310   // a "lldb::user_id_t" that specifies a DIE from another SymbolFileDWARF
1311   // instance.
1312   SymbolFileDWARF *dwarf = GetDWARFForUID(uid);
1313   if (dwarf)
1314     return dwarf->GetDIE(DIERef(uid, dwarf));
1315   return DWARFDIE();
1316 }
1317
1318 CompilerDecl SymbolFileDWARF::GetDeclForUID(lldb::user_id_t type_uid) {
1319   // Anytime we have a lldb::user_id_t, we must get the DIE by
1320   // calling SymbolFileDWARF::GetDIEFromUID(). See comments inside
1321   // the SymbolFileDWARF::GetDIEFromUID() for details.
1322   DWARFDIE die = GetDIEFromUID(type_uid);
1323   if (die)
1324     return die.GetDecl();
1325   return CompilerDecl();
1326 }
1327
1328 CompilerDeclContext
1329 SymbolFileDWARF::GetDeclContextForUID(lldb::user_id_t type_uid) {
1330   // Anytime we have a lldb::user_id_t, we must get the DIE by
1331   // calling SymbolFileDWARF::GetDIEFromUID(). See comments inside
1332   // the SymbolFileDWARF::GetDIEFromUID() for details.
1333   DWARFDIE die = GetDIEFromUID(type_uid);
1334   if (die)
1335     return die.GetDeclContext();
1336   return CompilerDeclContext();
1337 }
1338
1339 CompilerDeclContext
1340 SymbolFileDWARF::GetDeclContextContainingUID(lldb::user_id_t type_uid) {
1341   // Anytime we have a lldb::user_id_t, we must get the DIE by
1342   // calling SymbolFileDWARF::GetDIEFromUID(). See comments inside
1343   // the SymbolFileDWARF::GetDIEFromUID() for details.
1344   DWARFDIE die = GetDIEFromUID(type_uid);
1345   if (die)
1346     return die.GetContainingDeclContext();
1347   return CompilerDeclContext();
1348 }
1349
1350 Type *SymbolFileDWARF::ResolveTypeUID(lldb::user_id_t type_uid) {
1351   // Anytime we have a lldb::user_id_t, we must get the DIE by
1352   // calling SymbolFileDWARF::GetDIEFromUID(). See comments inside
1353   // the SymbolFileDWARF::GetDIEFromUID() for details.
1354   DWARFDIE type_die = GetDIEFromUID(type_uid);
1355   if (type_die)
1356     return type_die.ResolveType();
1357   else
1358     return nullptr;
1359 }
1360
1361 Type *SymbolFileDWARF::ResolveTypeUID(const DIERef &die_ref) {
1362   return ResolveType(GetDIE(die_ref), true);
1363 }
1364
1365 Type *SymbolFileDWARF::ResolveTypeUID(const DWARFDIE &die,
1366                                       bool assert_not_being_parsed) {
1367   if (die) {
1368     Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
1369     if (log)
1370       GetObjectFile()->GetModule()->LogMessage(
1371           log, "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s'",
1372           die.GetOffset(), die.GetTagAsCString(), die.GetName());
1373
1374     // We might be coming in in the middle of a type tree (a class
1375     // within a class, an enum within a class), so parse any needed
1376     // parent DIEs before we get to this one...
1377     DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(die);
1378     if (decl_ctx_die) {
1379       if (log) {
1380         switch (decl_ctx_die.Tag()) {
1381         case DW_TAG_structure_type:
1382         case DW_TAG_union_type:
1383         case DW_TAG_class_type: {
1384           // Get the type, which could be a forward declaration
1385           if (log)
1386             GetObjectFile()->GetModule()->LogMessage(
1387                 log, "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s' "
1388                      "resolve parent forward type for 0x%8.8x",
1389                 die.GetOffset(), die.GetTagAsCString(), die.GetName(),
1390                 decl_ctx_die.GetOffset());
1391         } break;
1392
1393         default:
1394           break;
1395         }
1396       }
1397     }
1398     return ResolveType(die);
1399   }
1400   return NULL;
1401 }
1402
1403 // This function is used when SymbolFileDWARFDebugMap owns a bunch of
1404 // SymbolFileDWARF objects to detect if this DWARF file is the one that
1405 // can resolve a compiler_type.
1406 bool SymbolFileDWARF::HasForwardDeclForClangType(
1407     const CompilerType &compiler_type) {
1408   CompilerType compiler_type_no_qualifiers =
1409       ClangUtil::RemoveFastQualifiers(compiler_type);
1410   if (GetForwardDeclClangTypeToDie().count(
1411           compiler_type_no_qualifiers.GetOpaqueQualType())) {
1412     return true;
1413   }
1414   TypeSystem *type_system = compiler_type.GetTypeSystem();
1415
1416   ClangASTContext *clang_type_system =
1417       llvm::dyn_cast_or_null<ClangASTContext>(type_system);
1418   if (!clang_type_system)
1419     return false;
1420   DWARFASTParserClang *ast_parser =
1421       static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser());
1422   return ast_parser->GetClangASTImporter().CanImport(compiler_type);
1423 }
1424
1425 bool SymbolFileDWARF::CompleteType(CompilerType &compiler_type) {
1426   std::lock_guard<std::recursive_mutex> guard(
1427       GetObjectFile()->GetModule()->GetMutex());
1428
1429   ClangASTContext *clang_type_system =
1430       llvm::dyn_cast_or_null<ClangASTContext>(compiler_type.GetTypeSystem());
1431   if (clang_type_system) {
1432     DWARFASTParserClang *ast_parser =
1433         static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser());
1434     if (ast_parser &&
1435         ast_parser->GetClangASTImporter().CanImport(compiler_type))
1436       return ast_parser->GetClangASTImporter().CompleteType(compiler_type);
1437   }
1438
1439   // We have a struct/union/class/enum that needs to be fully resolved.
1440   CompilerType compiler_type_no_qualifiers =
1441       ClangUtil::RemoveFastQualifiers(compiler_type);
1442   auto die_it = GetForwardDeclClangTypeToDie().find(
1443       compiler_type_no_qualifiers.GetOpaqueQualType());
1444   if (die_it == GetForwardDeclClangTypeToDie().end()) {
1445     // We have already resolved this type...
1446     return true;
1447   }
1448
1449   DWARFDIE dwarf_die = GetDIE(die_it->getSecond());
1450   if (dwarf_die) {
1451     // Once we start resolving this type, remove it from the forward declaration
1452     // map in case anyone child members or other types require this type to get
1453     // resolved.
1454     // The type will get resolved when all of the calls to
1455     // SymbolFileDWARF::ResolveClangOpaqueTypeDefinition
1456     // are done.
1457     GetForwardDeclClangTypeToDie().erase(die_it);
1458
1459     Type *type = GetDIEToType().lookup(dwarf_die.GetDIE());
1460
1461     Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO |
1462                                           DWARF_LOG_TYPE_COMPLETION));
1463     if (log)
1464       GetObjectFile()->GetModule()->LogMessageVerboseBacktrace(
1465           log, "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...",
1466           dwarf_die.GetID(), dwarf_die.GetTagAsCString(),
1467           type->GetName().AsCString());
1468     assert(compiler_type);
1469     DWARFASTParser *dwarf_ast = dwarf_die.GetDWARFParser();
1470     if (dwarf_ast)
1471       return dwarf_ast->CompleteTypeFromDWARF(dwarf_die, type, compiler_type);
1472   }
1473   return false;
1474 }
1475
1476 Type *SymbolFileDWARF::ResolveType(const DWARFDIE &die,
1477                                    bool assert_not_being_parsed,
1478                                    bool resolve_function_context) {
1479   if (die) {
1480     Type *type = GetTypeForDIE(die, resolve_function_context).get();
1481
1482     if (assert_not_being_parsed) {
1483       if (type != DIE_IS_BEING_PARSED)
1484         return type;
1485
1486       GetObjectFile()->GetModule()->ReportError(
1487           "Parsing a die that is being parsed die: 0x%8.8x: %s %s",
1488           die.GetOffset(), die.GetTagAsCString(), die.GetName());
1489
1490     } else
1491       return type;
1492   }
1493   return nullptr;
1494 }
1495
1496 CompileUnit *
1497 SymbolFileDWARF::GetCompUnitForDWARFCompUnit(DWARFCompileUnit *dwarf_cu,
1498                                              uint32_t cu_idx) {
1499   // Check if the symbol vendor already knows about this compile unit?
1500   if (dwarf_cu->GetUserData() == NULL) {
1501     // The symbol vendor doesn't know about this compile unit, we
1502     // need to parse and add it to the symbol vendor object.
1503     return ParseCompileUnit(dwarf_cu, cu_idx).get();
1504   }
1505   return (CompileUnit *)dwarf_cu->GetUserData();
1506 }
1507
1508 size_t SymbolFileDWARF::GetObjCMethodDIEOffsets(ConstString class_name,
1509                                                 DIEArray &method_die_offsets) {
1510   method_die_offsets.clear();
1511   if (m_using_apple_tables) {
1512     if (m_apple_objc_ap.get())
1513       m_apple_objc_ap->FindByName(class_name.GetCString(), method_die_offsets);
1514   } else {
1515     if (!m_indexed)
1516       Index();
1517
1518     m_objc_class_selectors_index.Find(class_name, method_die_offsets);
1519   }
1520   return method_die_offsets.size();
1521 }
1522
1523 bool SymbolFileDWARF::GetFunction(const DWARFDIE &die, SymbolContext &sc) {
1524   sc.Clear(false);
1525
1526   if (die) {
1527     // Check if the symbol vendor already knows about this compile unit?
1528     sc.comp_unit = GetCompUnitForDWARFCompUnit(die.GetCU(), UINT32_MAX);
1529
1530     sc.function = sc.comp_unit->FindFunctionByUID(die.GetID()).get();
1531     if (sc.function == NULL)
1532       sc.function = ParseCompileUnitFunction(sc, die);
1533
1534     if (sc.function) {
1535       sc.module_sp = sc.function->CalculateSymbolContextModule();
1536       return true;
1537     }
1538   }
1539
1540   return false;
1541 }
1542
1543 lldb::ModuleSP SymbolFileDWARF::GetDWOModule(ConstString name) {
1544   UpdateExternalModuleListIfNeeded();
1545   const auto &pos = m_external_type_modules.find(name);
1546   if (pos != m_external_type_modules.end())
1547     return pos->second;
1548   else
1549     return lldb::ModuleSP();
1550 }
1551
1552 DWARFDIE
1553 SymbolFileDWARF::GetDIE(const DIERef &die_ref) {
1554   DWARFDebugInfo *debug_info = DebugInfo();
1555   if (debug_info)
1556     return debug_info->GetDIE(die_ref);
1557   else
1558     return DWARFDIE();
1559 }
1560
1561 std::unique_ptr<SymbolFileDWARFDwo>
1562 SymbolFileDWARF::GetDwoSymbolFileForCompileUnit(
1563     DWARFCompileUnit &dwarf_cu, const DWARFDebugInfoEntry &cu_die) {
1564   // If we are using a dSYM file, we never want the standard DWO files since
1565   // the -gmodule support uses the same DWO machanism to specify full debug
1566   // info files for modules.
1567   if (GetDebugMapSymfile())
1568     return nullptr;
1569
1570   const char *dwo_name = cu_die.GetAttributeValueAsString(
1571       this, &dwarf_cu, DW_AT_GNU_dwo_name, nullptr);
1572   if (!dwo_name)
1573     return nullptr;
1574
1575   SymbolFileDWARFDwp *dwp_symfile = GetDwpSymbolFile();
1576   if (dwp_symfile) {
1577     uint64_t dwo_id = cu_die.GetAttributeValueAsUnsigned(this, &dwarf_cu,
1578                                                          DW_AT_GNU_dwo_id, 0);
1579     std::unique_ptr<SymbolFileDWARFDwo> dwo_symfile =
1580         dwp_symfile->GetSymbolFileForDwoId(&dwarf_cu, dwo_id);
1581     if (dwo_symfile)
1582       return dwo_symfile;
1583   }
1584
1585   FileSpec dwo_file(dwo_name, true);
1586   if (dwo_file.IsRelative()) {
1587     const char *comp_dir = cu_die.GetAttributeValueAsString(
1588         this, &dwarf_cu, DW_AT_comp_dir, nullptr);
1589     if (!comp_dir)
1590       return nullptr;
1591
1592     dwo_file.SetFile(comp_dir, true);
1593     dwo_file.AppendPathComponent(dwo_name);
1594   }
1595
1596   if (!dwo_file.Exists())
1597     return nullptr;
1598
1599   const lldb::offset_t file_offset = 0;
1600   DataBufferSP dwo_file_data_sp;
1601   lldb::offset_t dwo_file_data_offset = 0;
1602   ObjectFileSP dwo_obj_file = ObjectFile::FindPlugin(
1603       GetObjectFile()->GetModule(), &dwo_file, file_offset,
1604       dwo_file.GetByteSize(), dwo_file_data_sp, dwo_file_data_offset);
1605   if (dwo_obj_file == nullptr)
1606     return nullptr;
1607
1608   return llvm::make_unique<SymbolFileDWARFDwo>(dwo_obj_file, &dwarf_cu);
1609 }
1610
1611 void SymbolFileDWARF::UpdateExternalModuleListIfNeeded() {
1612   if (m_fetched_external_modules)
1613     return;
1614   m_fetched_external_modules = true;
1615
1616   DWARFDebugInfo *debug_info = DebugInfo();
1617
1618   const uint32_t num_compile_units = GetNumCompileUnits();
1619   for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
1620     DWARFCompileUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
1621
1622     const DWARFDIE die = dwarf_cu->GetCompileUnitDIEOnly();
1623     if (die && die.HasChildren() == false) {
1624       const char *name = die.GetAttributeValueAsString(DW_AT_name, nullptr);
1625
1626       if (name) {
1627         ConstString const_name(name);
1628         if (m_external_type_modules.find(const_name) ==
1629             m_external_type_modules.end()) {
1630           ModuleSP module_sp;
1631           const char *dwo_path =
1632               die.GetAttributeValueAsString(DW_AT_GNU_dwo_name, nullptr);
1633           if (dwo_path) {
1634             ModuleSpec dwo_module_spec;
1635             dwo_module_spec.GetFileSpec().SetFile(dwo_path, false);
1636             if (dwo_module_spec.GetFileSpec().IsRelative()) {
1637               const char *comp_dir =
1638                   die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr);
1639               if (comp_dir) {
1640                 dwo_module_spec.GetFileSpec().SetFile(comp_dir, true);
1641                 dwo_module_spec.GetFileSpec().AppendPathComponent(dwo_path);
1642               }
1643             }
1644             dwo_module_spec.GetArchitecture() =
1645                 m_obj_file->GetModule()->GetArchitecture();
1646
1647             // When LLDB loads "external" modules it looks at the
1648             // presence of DW_AT_GNU_dwo_name.
1649             // However, when the already created module
1650             // (corresponding to .dwo itself) is being processed,
1651             // it will see the presence of DW_AT_GNU_dwo_name
1652             // (which contains the name of dwo file) and
1653             // will try to call ModuleList::GetSharedModule again.
1654             // In some cases (i.e. for empty files) Clang 4.0
1655             // generates a *.dwo file which has DW_AT_GNU_dwo_name,
1656             // but no DW_AT_comp_dir. In this case the method
1657             // ModuleList::GetSharedModule will fail and
1658             // the warning will be printed. However, as one can notice
1659             // in this case we don't actually need to try to load the already
1660             // loaded module (corresponding to .dwo) so we simply skip it.
1661             if (m_obj_file->GetFileSpec()
1662                         .GetFileNameExtension()
1663                         .GetStringRef() == "dwo" &&
1664                 llvm::StringRef(m_obj_file->GetFileSpec().GetPath())
1665                     .endswith(dwo_module_spec.GetFileSpec().GetPath())) {
1666               continue;
1667             }
1668
1669             Status error = ModuleList::GetSharedModule(
1670                 dwo_module_spec, module_sp, NULL, NULL, NULL);
1671             if (!module_sp) {
1672               GetObjectFile()->GetModule()->ReportWarning(
1673                   "0x%8.8x: unable to locate module needed for external types: "
1674                   "%s\nerror: %s\nDebugging will be degraded due to missing "
1675                   "types. Rebuilding your project will regenerate the needed "
1676                   "module files.",
1677                   die.GetOffset(),
1678                   dwo_module_spec.GetFileSpec().GetPath().c_str(),
1679                   error.AsCString("unknown error"));
1680             }
1681           }
1682           m_external_type_modules[const_name] = module_sp;
1683         }
1684       }
1685     }
1686   }
1687 }
1688
1689 SymbolFileDWARF::GlobalVariableMap &SymbolFileDWARF::GetGlobalAranges() {
1690   if (!m_global_aranges_ap) {
1691     m_global_aranges_ap.reset(new GlobalVariableMap());
1692
1693     ModuleSP module_sp = GetObjectFile()->GetModule();
1694     if (module_sp) {
1695       const size_t num_cus = module_sp->GetNumCompileUnits();
1696       for (size_t i = 0; i < num_cus; ++i) {
1697         CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex(i);
1698         if (cu_sp) {
1699           VariableListSP globals_sp = cu_sp->GetVariableList(true);
1700           if (globals_sp) {
1701             const size_t num_globals = globals_sp->GetSize();
1702             for (size_t g = 0; g < num_globals; ++g) {
1703               VariableSP var_sp = globals_sp->GetVariableAtIndex(g);
1704               if (var_sp && !var_sp->GetLocationIsConstantValueData()) {
1705                 const DWARFExpression &location = var_sp->LocationExpression();
1706                 Value location_result;
1707                 Status error;
1708                 if (location.Evaluate(nullptr, LLDB_INVALID_ADDRESS, nullptr,
1709                                       nullptr, location_result, &error)) {
1710                   if (location_result.GetValueType() ==
1711                       Value::eValueTypeFileAddress) {
1712                     lldb::addr_t file_addr =
1713                         location_result.GetScalar().ULongLong();
1714                     lldb::addr_t byte_size = 1;
1715                     if (var_sp->GetType())
1716                       byte_size = var_sp->GetType()->GetByteSize();
1717                     m_global_aranges_ap->Append(GlobalVariableMap::Entry(
1718                         file_addr, byte_size, var_sp.get()));
1719                   }
1720                 }
1721               }
1722             }
1723           }
1724         }
1725       }
1726     }
1727     m_global_aranges_ap->Sort();
1728   }
1729   return *m_global_aranges_ap;
1730 }
1731
1732 uint32_t SymbolFileDWARF::ResolveSymbolContext(const Address &so_addr,
1733                                                uint32_t resolve_scope,
1734                                                SymbolContext &sc) {
1735   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
1736   Timer scoped_timer(func_cat,
1737                      "SymbolFileDWARF::"
1738                      "ResolveSymbolContext (so_addr = { "
1739                      "section = %p, offset = 0x%" PRIx64
1740                      " }, resolve_scope = 0x%8.8x)",
1741                      static_cast<void *>(so_addr.GetSection().get()),
1742                      so_addr.GetOffset(), resolve_scope);
1743   uint32_t resolved = 0;
1744   if (resolve_scope &
1745       (eSymbolContextCompUnit | eSymbolContextFunction | eSymbolContextBlock |
1746        eSymbolContextLineEntry | eSymbolContextVariable)) {
1747     lldb::addr_t file_vm_addr = so_addr.GetFileAddress();
1748
1749     DWARFDebugInfo *debug_info = DebugInfo();
1750     if (debug_info) {
1751       const dw_offset_t cu_offset =
1752           debug_info->GetCompileUnitAranges().FindAddress(file_vm_addr);
1753       if (cu_offset == DW_INVALID_OFFSET) {
1754         // Global variables are not in the compile unit address ranges. The only
1755         // way to
1756         // currently find global variables is to iterate over the
1757         // .debug_pubnames or the
1758         // __apple_names table and find all items in there that point to
1759         // DW_TAG_variable
1760         // DIEs and then find the address that matches.
1761         if (resolve_scope & eSymbolContextVariable) {
1762           GlobalVariableMap &map = GetGlobalAranges();
1763           const GlobalVariableMap::Entry *entry =
1764               map.FindEntryThatContains(file_vm_addr);
1765           if (entry && entry->data) {
1766             Variable *variable = entry->data;
1767             SymbolContextScope *scc = variable->GetSymbolContextScope();
1768             if (scc) {
1769               scc->CalculateSymbolContext(&sc);
1770               sc.variable = variable;
1771             }
1772             return sc.GetResolvedMask();
1773           }
1774         }
1775       } else {
1776         uint32_t cu_idx = DW_INVALID_INDEX;
1777         DWARFCompileUnit *dwarf_cu =
1778             debug_info->GetCompileUnit(cu_offset, &cu_idx);
1779         if (dwarf_cu) {
1780           sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx);
1781           if (sc.comp_unit) {
1782             resolved |= eSymbolContextCompUnit;
1783
1784             bool force_check_line_table = false;
1785             if (resolve_scope &
1786                 (eSymbolContextFunction | eSymbolContextBlock)) {
1787               DWARFDIE function_die = dwarf_cu->LookupAddress(file_vm_addr);
1788               DWARFDIE block_die;
1789               if (function_die) {
1790                 sc.function =
1791                     sc.comp_unit->FindFunctionByUID(function_die.GetID()).get();
1792                 if (sc.function == NULL)
1793                   sc.function = ParseCompileUnitFunction(sc, function_die);
1794
1795                 if (sc.function && (resolve_scope & eSymbolContextBlock))
1796                   block_die = function_die.LookupDeepestBlock(file_vm_addr);
1797               } else {
1798                 // We might have had a compile unit that had discontiguous
1799                 // address ranges where the gaps are symbols that don't have
1800                 // any debug info. Discontiguous compile unit address ranges
1801                 // should only happen when there aren't other functions from
1802                 // other compile units in these gaps. This helps keep the size
1803                 // of the aranges down.
1804                 force_check_line_table = true;
1805               }
1806
1807               if (sc.function != NULL) {
1808                 resolved |= eSymbolContextFunction;
1809
1810                 if (resolve_scope & eSymbolContextBlock) {
1811                   Block &block = sc.function->GetBlock(true);
1812
1813                   if (block_die)
1814                     sc.block = block.FindBlockByID(block_die.GetID());
1815                   else
1816                     sc.block = block.FindBlockByID(function_die.GetID());
1817                   if (sc.block)
1818                     resolved |= eSymbolContextBlock;
1819                 }
1820               }
1821             }
1822
1823             if ((resolve_scope & eSymbolContextLineEntry) ||
1824                 force_check_line_table) {
1825               LineTable *line_table = sc.comp_unit->GetLineTable();
1826               if (line_table != NULL) {
1827                 // And address that makes it into this function should be in
1828                 // terms
1829                 // of this debug file if there is no debug map, or it will be an
1830                 // address in the .o file which needs to be fixed up to be in
1831                 // terms
1832                 // of the debug map executable. Either way, calling
1833                 // FixupAddress()
1834                 // will work for us.
1835                 Address exe_so_addr(so_addr);
1836                 if (FixupAddress(exe_so_addr)) {
1837                   if (line_table->FindLineEntryByAddress(exe_so_addr,
1838                                                          sc.line_entry)) {
1839                     resolved |= eSymbolContextLineEntry;
1840                   }
1841                 }
1842               }
1843             }
1844
1845             if (force_check_line_table &&
1846                 !(resolved & eSymbolContextLineEntry)) {
1847               // We might have had a compile unit that had discontiguous
1848               // address ranges where the gaps are symbols that don't have
1849               // any debug info. Discontiguous compile unit address ranges
1850               // should only happen when there aren't other functions from
1851               // other compile units in these gaps. This helps keep the size
1852               // of the aranges down.
1853               sc.comp_unit = NULL;
1854               resolved &= ~eSymbolContextCompUnit;
1855             }
1856           } else {
1857             GetObjectFile()->GetModule()->ReportWarning(
1858                 "0x%8.8x: compile unit %u failed to create a valid "
1859                 "lldb_private::CompileUnit class.",
1860                 cu_offset, cu_idx);
1861           }
1862         }
1863       }
1864     }
1865   }
1866   return resolved;
1867 }
1868
1869 uint32_t SymbolFileDWARF::ResolveSymbolContext(const FileSpec &file_spec,
1870                                                uint32_t line,
1871                                                bool check_inlines,
1872                                                uint32_t resolve_scope,
1873                                                SymbolContextList &sc_list) {
1874   const uint32_t prev_size = sc_list.GetSize();
1875   if (resolve_scope & eSymbolContextCompUnit) {
1876     DWARFDebugInfo *debug_info = DebugInfo();
1877     if (debug_info) {
1878       uint32_t cu_idx;
1879       DWARFCompileUnit *dwarf_cu = NULL;
1880
1881       for (cu_idx = 0;
1882            (dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx)) != NULL;
1883            ++cu_idx) {
1884         CompileUnit *dc_cu = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx);
1885         const bool full_match = (bool)file_spec.GetDirectory();
1886         bool file_spec_matches_cu_file_spec =
1887             dc_cu != NULL && FileSpec::Equal(file_spec, *dc_cu, full_match);
1888         if (check_inlines || file_spec_matches_cu_file_spec) {
1889           SymbolContext sc(m_obj_file->GetModule());
1890           sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx);
1891           if (sc.comp_unit) {
1892             uint32_t file_idx = UINT32_MAX;
1893
1894             // If we are looking for inline functions only and we don't
1895             // find it in the support files, we are done.
1896             if (check_inlines) {
1897               file_idx = sc.comp_unit->GetSupportFiles().FindFileIndex(
1898                   1, file_spec, true);
1899               if (file_idx == UINT32_MAX)
1900                 continue;
1901             }
1902
1903             if (line != 0) {
1904               LineTable *line_table = sc.comp_unit->GetLineTable();
1905
1906               if (line_table != NULL && line != 0) {
1907                 // We will have already looked up the file index if
1908                 // we are searching for inline entries.
1909                 if (!check_inlines)
1910                   file_idx = sc.comp_unit->GetSupportFiles().FindFileIndex(
1911                       1, file_spec, true);
1912
1913                 if (file_idx != UINT32_MAX) {
1914                   uint32_t found_line;
1915                   uint32_t line_idx = line_table->FindLineEntryIndexByFileIndex(
1916                       0, file_idx, line, false, &sc.line_entry);
1917                   found_line = sc.line_entry.line;
1918
1919                   while (line_idx != UINT32_MAX) {
1920                     sc.function = NULL;
1921                     sc.block = NULL;
1922                     if (resolve_scope &
1923                         (eSymbolContextFunction | eSymbolContextBlock)) {
1924                       const lldb::addr_t file_vm_addr =
1925                           sc.line_entry.range.GetBaseAddress().GetFileAddress();
1926                       if (file_vm_addr != LLDB_INVALID_ADDRESS) {
1927                         DWARFDIE function_die =
1928                             dwarf_cu->LookupAddress(file_vm_addr);
1929                         DWARFDIE block_die;
1930                         if (function_die) {
1931                           sc.function =
1932                               sc.comp_unit
1933                                   ->FindFunctionByUID(function_die.GetID())
1934                                   .get();
1935                           if (sc.function == NULL)
1936                             sc.function =
1937                                 ParseCompileUnitFunction(sc, function_die);
1938
1939                           if (sc.function &&
1940                               (resolve_scope & eSymbolContextBlock))
1941                             block_die =
1942                                 function_die.LookupDeepestBlock(file_vm_addr);
1943                         }
1944
1945                         if (sc.function != NULL) {
1946                           Block &block = sc.function->GetBlock(true);
1947
1948                           if (block_die)
1949                             sc.block = block.FindBlockByID(block_die.GetID());
1950                           else if (function_die)
1951                             sc.block =
1952                                 block.FindBlockByID(function_die.GetID());
1953                         }
1954                       }
1955                     }
1956
1957                     sc_list.Append(sc);
1958                     line_idx = line_table->FindLineEntryIndexByFileIndex(
1959                         line_idx + 1, file_idx, found_line, true,
1960                         &sc.line_entry);
1961                   }
1962                 }
1963               } else if (file_spec_matches_cu_file_spec && !check_inlines) {
1964                 // only append the context if we aren't looking for inline call
1965                 // sites
1966                 // by file and line and if the file spec matches that of the
1967                 // compile unit
1968                 sc_list.Append(sc);
1969               }
1970             } else if (file_spec_matches_cu_file_spec && !check_inlines) {
1971               // only append the context if we aren't looking for inline call
1972               // sites
1973               // by file and line and if the file spec matches that of the
1974               // compile unit
1975               sc_list.Append(sc);
1976             }
1977
1978             if (!check_inlines)
1979               break;
1980           }
1981         }
1982       }
1983     }
1984   }
1985   return sc_list.GetSize() - prev_size;
1986 }
1987
1988 void SymbolFileDWARF::PreloadSymbols() {
1989   std::lock_guard<std::recursive_mutex> guard(
1990       GetObjectFile()->GetModule()->GetMutex());
1991   Index();
1992 }
1993
1994 void SymbolFileDWARF::Index() {
1995   if (m_indexed)
1996     return;
1997   m_indexed = true;
1998   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
1999   Timer scoped_timer(
2000       func_cat, "SymbolFileDWARF::Index (%s)",
2001       GetObjectFile()->GetFileSpec().GetFilename().AsCString("<Unknown>"));
2002
2003   DWARFDebugInfo *debug_info = DebugInfo();
2004   if (debug_info) {
2005     const uint32_t num_compile_units = GetNumCompileUnits();
2006     if (num_compile_units == 0)
2007       return;
2008
2009     std::vector<NameToDIE> function_basename_index(num_compile_units);
2010     std::vector<NameToDIE> function_fullname_index(num_compile_units);
2011     std::vector<NameToDIE> function_method_index(num_compile_units);
2012     std::vector<NameToDIE> function_selector_index(num_compile_units);
2013     std::vector<NameToDIE> objc_class_selectors_index(num_compile_units);
2014     std::vector<NameToDIE> global_index(num_compile_units);
2015     std::vector<NameToDIE> type_index(num_compile_units);
2016     std::vector<NameToDIE> namespace_index(num_compile_units);
2017
2018     // std::vector<bool> might be implemented using bit test-and-set, so use
2019     // uint8_t instead.
2020     std::vector<uint8_t> clear_cu_dies(num_compile_units, false);
2021     auto parser_fn = [debug_info, &function_basename_index,
2022                       &function_fullname_index, &function_method_index,
2023                       &function_selector_index, &objc_class_selectors_index,
2024                       &global_index, &type_index,
2025                       &namespace_index](size_t cu_idx) {
2026       DWARFCompileUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
2027       if (dwarf_cu) {
2028         dwarf_cu->Index(
2029             function_basename_index[cu_idx], function_fullname_index[cu_idx],
2030             function_method_index[cu_idx], function_selector_index[cu_idx],
2031             objc_class_selectors_index[cu_idx], global_index[cu_idx],
2032             type_index[cu_idx], namespace_index[cu_idx]);
2033       }
2034     };
2035
2036     auto extract_fn = [debug_info, &clear_cu_dies](size_t cu_idx) {
2037       DWARFCompileUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
2038       if (dwarf_cu) {
2039         // dwarf_cu->ExtractDIEsIfNeeded(false) will return zero if the
2040         // DIEs for a compile unit have already been parsed.
2041         if (dwarf_cu->ExtractDIEsIfNeeded(false) > 1)
2042           clear_cu_dies[cu_idx] = true;
2043       }
2044     };
2045
2046     // Create a task runner that extracts dies for each DWARF compile unit in a
2047     // separate thread
2048     //----------------------------------------------------------------------
2049     // First figure out which compile units didn't have their DIEs already
2050     // parsed and remember this.  If no DIEs were parsed prior to this index
2051     // function call, we are going to want to clear the CU dies after we
2052     // are done indexing to make sure we don't pull in all DWARF dies, but
2053     // we need to wait until all compile units have been indexed in case
2054     // a DIE in one compile unit refers to another and the indexes accesses
2055     // those DIEs.
2056     //----------------------------------------------------------------------
2057     TaskMapOverInt(0, num_compile_units, extract_fn);
2058
2059     // Now create a task runner that can index each DWARF compile unit in a
2060     // separate
2061     // thread so we can index quickly.
2062
2063     TaskMapOverInt(0, num_compile_units, parser_fn);
2064
2065     auto finalize_fn = [](NameToDIE &index, std::vector<NameToDIE> &srcs) {
2066       for (auto &src : srcs)
2067         index.Append(src);
2068       index.Finalize();
2069     };
2070
2071     TaskPool::RunTasks(
2072         [&]() {
2073           finalize_fn(m_function_basename_index, function_basename_index);
2074         },
2075         [&]() {
2076           finalize_fn(m_function_fullname_index, function_fullname_index);
2077         },
2078         [&]() { finalize_fn(m_function_method_index, function_method_index); },
2079         [&]() {
2080           finalize_fn(m_function_selector_index, function_selector_index);
2081         },
2082         [&]() {
2083           finalize_fn(m_objc_class_selectors_index, objc_class_selectors_index);
2084         },
2085         [&]() { finalize_fn(m_global_index, global_index); },
2086         [&]() { finalize_fn(m_type_index, type_index); },
2087         [&]() { finalize_fn(m_namespace_index, namespace_index); });
2088
2089     //----------------------------------------------------------------------
2090     // Keep memory down by clearing DIEs for any compile units if indexing
2091     // caused us to load the compile unit's DIEs.
2092     //----------------------------------------------------------------------
2093     for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
2094       if (clear_cu_dies[cu_idx])
2095         debug_info->GetCompileUnitAtIndex(cu_idx)->ClearDIEs(true);
2096     }
2097
2098 #if defined(ENABLE_DEBUG_PRINTF)
2099     StreamFile s(stdout, false);
2100     s.Printf("DWARF index for '%s':",
2101              GetObjectFile()->GetFileSpec().GetPath().c_str());
2102     s.Printf("\nFunction basenames:\n");
2103     m_function_basename_index.Dump(&s);
2104     s.Printf("\nFunction fullnames:\n");
2105     m_function_fullname_index.Dump(&s);
2106     s.Printf("\nFunction methods:\n");
2107     m_function_method_index.Dump(&s);
2108     s.Printf("\nFunction selectors:\n");
2109     m_function_selector_index.Dump(&s);
2110     s.Printf("\nObjective C class selectors:\n");
2111     m_objc_class_selectors_index.Dump(&s);
2112     s.Printf("\nGlobals and statics:\n");
2113     m_global_index.Dump(&s);
2114     s.Printf("\nTypes:\n");
2115     m_type_index.Dump(&s);
2116     s.Printf("\nNamespaces:\n");
2117     m_namespace_index.Dump(&s);
2118 #endif
2119   }
2120 }
2121
2122 bool SymbolFileDWARF::DeclContextMatchesThisSymbolFile(
2123     const lldb_private::CompilerDeclContext *decl_ctx) {
2124   if (decl_ctx == nullptr || !decl_ctx->IsValid()) {
2125     // Invalid namespace decl which means we aren't matching only things
2126     // in this symbol file, so return true to indicate it matches this
2127     // symbol file.
2128     return true;
2129   }
2130
2131   TypeSystem *decl_ctx_type_system = decl_ctx->GetTypeSystem();
2132   TypeSystem *type_system = GetTypeSystemForLanguage(
2133       decl_ctx_type_system->GetMinimumLanguage(nullptr));
2134   if (decl_ctx_type_system == type_system)
2135     return true; // The type systems match, return true
2136
2137   // The namespace AST was valid, and it does not match...
2138   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
2139
2140   if (log)
2141     GetObjectFile()->GetModule()->LogMessage(
2142         log, "Valid namespace does not match symbol file");
2143
2144   return false;
2145 }
2146
2147 uint32_t SymbolFileDWARF::FindGlobalVariables(
2148     const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
2149     bool append, uint32_t max_matches, VariableList &variables) {
2150   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
2151
2152   if (log)
2153     GetObjectFile()->GetModule()->LogMessage(
2154         log, "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", "
2155              "parent_decl_ctx=%p, append=%u, max_matches=%u, variables)",
2156         name.GetCString(), static_cast<const void *>(parent_decl_ctx), append,
2157         max_matches);
2158
2159   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
2160     return 0;
2161
2162   DWARFDebugInfo *info = DebugInfo();
2163   if (info == NULL)
2164     return 0;
2165
2166   // If we aren't appending the results to this list, then clear the list
2167   if (!append)
2168     variables.Clear();
2169
2170   // Remember how many variables are in the list before we search in case
2171   // we are appending the results to a variable list.
2172   const uint32_t original_size = variables.GetSize();
2173
2174   DIEArray die_offsets;
2175
2176   if (m_using_apple_tables) {
2177     if (m_apple_names_ap.get()) {
2178       const char *name_cstr = name.GetCString();
2179       llvm::StringRef basename;
2180       llvm::StringRef context;
2181
2182       if (!CPlusPlusLanguage::ExtractContextAndIdentifier(name_cstr, context,
2183                                                           basename))
2184         basename = name_cstr;
2185
2186       m_apple_names_ap->FindByName(basename.data(), die_offsets);
2187     }
2188   } else {
2189     // Index the DWARF if we haven't already
2190     if (!m_indexed)
2191       Index();
2192
2193     m_global_index.Find(name, die_offsets);
2194   }
2195
2196   const size_t num_die_matches = die_offsets.size();
2197   if (num_die_matches) {
2198     SymbolContext sc;
2199     sc.module_sp = m_obj_file->GetModule();
2200     assert(sc.module_sp);
2201
2202     bool done = false;
2203     for (size_t i = 0; i < num_die_matches && !done; ++i) {
2204       const DIERef &die_ref = die_offsets[i];
2205       DWARFDIE die = GetDIE(die_ref);
2206
2207       if (die) {
2208         switch (die.Tag()) {
2209         default:
2210         case DW_TAG_subprogram:
2211         case DW_TAG_inlined_subroutine:
2212         case DW_TAG_try_block:
2213         case DW_TAG_catch_block:
2214           break;
2215
2216         case DW_TAG_variable: {
2217           sc.comp_unit = GetCompUnitForDWARFCompUnit(die.GetCU(), UINT32_MAX);
2218
2219           if (parent_decl_ctx) {
2220             DWARFASTParser *dwarf_ast = die.GetDWARFParser();
2221             if (dwarf_ast) {
2222               CompilerDeclContext actual_parent_decl_ctx =
2223                   dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
2224               if (!actual_parent_decl_ctx ||
2225                   actual_parent_decl_ctx != *parent_decl_ctx)
2226                 continue;
2227             }
2228           }
2229
2230           ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false,
2231                          &variables);
2232
2233           if (variables.GetSize() - original_size >= max_matches)
2234             done = true;
2235         } break;
2236         }
2237       } else {
2238         if (m_using_apple_tables) {
2239           GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
2240               "the DWARF debug information has been modified (.apple_names "
2241               "accelerator table had bad die 0x%8.8x for '%s')\n",
2242               die_ref.die_offset, name.GetCString());
2243         }
2244       }
2245     }
2246   }
2247
2248   // Return the number of variable that were appended to the list
2249   const uint32_t num_matches = variables.GetSize() - original_size;
2250   if (log && num_matches > 0) {
2251     GetObjectFile()->GetModule()->LogMessage(
2252         log, "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", "
2253              "parent_decl_ctx=%p, append=%u, max_matches=%u, variables) => %u",
2254         name.GetCString(), static_cast<const void *>(parent_decl_ctx), append,
2255         max_matches, num_matches);
2256   }
2257   return num_matches;
2258 }
2259
2260 uint32_t SymbolFileDWARF::FindGlobalVariables(const RegularExpression &regex,
2261                                               bool append, uint32_t max_matches,
2262                                               VariableList &variables) {
2263   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
2264
2265   if (log) {
2266     GetObjectFile()->GetModule()->LogMessage(
2267         log, "SymbolFileDWARF::FindGlobalVariables (regex=\"%s\", append=%u, "
2268              "max_matches=%u, variables)",
2269         regex.GetText().str().c_str(), append, max_matches);
2270   }
2271
2272   DWARFDebugInfo *info = DebugInfo();
2273   if (info == NULL)
2274     return 0;
2275
2276   // If we aren't appending the results to this list, then clear the list
2277   if (!append)
2278     variables.Clear();
2279
2280   // Remember how many variables are in the list before we search in case
2281   // we are appending the results to a variable list.
2282   const uint32_t original_size = variables.GetSize();
2283
2284   DIEArray die_offsets;
2285
2286   if (m_using_apple_tables) {
2287     if (m_apple_names_ap.get()) {
2288       DWARFMappedHash::DIEInfoArray hash_data_array;
2289       if (m_apple_names_ap->AppendAllDIEsThatMatchingRegex(regex,
2290                                                            hash_data_array))
2291         DWARFMappedHash::ExtractDIEArray(hash_data_array, die_offsets);
2292     }
2293   } else {
2294     // Index the DWARF if we haven't already
2295     if (!m_indexed)
2296       Index();
2297
2298     m_global_index.Find(regex, die_offsets);
2299   }
2300
2301   SymbolContext sc;
2302   sc.module_sp = m_obj_file->GetModule();
2303   assert(sc.module_sp);
2304
2305   const size_t num_matches = die_offsets.size();
2306   if (num_matches) {
2307     for (size_t i = 0; i < num_matches; ++i) {
2308       const DIERef &die_ref = die_offsets[i];
2309       DWARFDIE die = GetDIE(die_ref);
2310
2311       if (die) {
2312         sc.comp_unit = GetCompUnitForDWARFCompUnit(die.GetCU(), UINT32_MAX);
2313
2314         ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false, &variables);
2315
2316         if (variables.GetSize() - original_size >= max_matches)
2317           break;
2318       } else {
2319         if (m_using_apple_tables) {
2320           GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
2321               "the DWARF debug information has been modified (.apple_names "
2322               "accelerator table had bad die 0x%8.8x for regex '%s')\n",
2323               die_ref.die_offset, regex.GetText().str().c_str());
2324         }
2325       }
2326     }
2327   }
2328
2329   // Return the number of variable that were appended to the list
2330   return variables.GetSize() - original_size;
2331 }
2332
2333 bool SymbolFileDWARF::ResolveFunction(const DIERef &die_ref,
2334                                       bool include_inlines,
2335                                       SymbolContextList &sc_list) {
2336   DWARFDIE die = DebugInfo()->GetDIE(die_ref);
2337   return ResolveFunction(die, include_inlines, sc_list);
2338 }
2339
2340 bool SymbolFileDWARF::ResolveFunction(const DWARFDIE &orig_die,
2341                                       bool include_inlines,
2342                                       SymbolContextList &sc_list) {
2343   SymbolContext sc;
2344
2345   if (!orig_die)
2346     return false;
2347
2348   // If we were passed a die that is not a function, just return false...
2349   if (!(orig_die.Tag() == DW_TAG_subprogram ||
2350         (include_inlines && orig_die.Tag() == DW_TAG_inlined_subroutine)))
2351     return false;
2352
2353   DWARFDIE die = orig_die;
2354   DWARFDIE inlined_die;
2355   if (die.Tag() == DW_TAG_inlined_subroutine) {
2356     inlined_die = die;
2357
2358     while (1) {
2359       die = die.GetParent();
2360
2361       if (die) {
2362         if (die.Tag() == DW_TAG_subprogram)
2363           break;
2364       } else
2365         break;
2366     }
2367   }
2368   assert(die && die.Tag() == DW_TAG_subprogram);
2369   if (GetFunction(die, sc)) {
2370     Address addr;
2371     // Parse all blocks if needed
2372     if (inlined_die) {
2373       Block &function_block = sc.function->GetBlock(true);
2374       sc.block = function_block.FindBlockByID(inlined_die.GetID());
2375       if (sc.block == NULL)
2376         sc.block = function_block.FindBlockByID(inlined_die.GetOffset());
2377       if (sc.block == NULL || sc.block->GetStartAddress(addr) == false)
2378         addr.Clear();
2379     } else {
2380       sc.block = NULL;
2381       addr = sc.function->GetAddressRange().GetBaseAddress();
2382     }
2383
2384     if (addr.IsValid()) {
2385       sc_list.Append(sc);
2386       return true;
2387     }
2388   }
2389
2390   return false;
2391 }
2392
2393 void SymbolFileDWARF::FindFunctions(const ConstString &name,
2394                                     const NameToDIE &name_to_die,
2395                                     bool include_inlines,
2396                                     SymbolContextList &sc_list) {
2397   DIEArray die_offsets;
2398   if (name_to_die.Find(name, die_offsets)) {
2399     ParseFunctions(die_offsets, include_inlines, sc_list);
2400   }
2401 }
2402
2403 void SymbolFileDWARF::FindFunctions(const RegularExpression &regex,
2404                                     const NameToDIE &name_to_die,
2405                                     bool include_inlines,
2406                                     SymbolContextList &sc_list) {
2407   DIEArray die_offsets;
2408   if (name_to_die.Find(regex, die_offsets)) {
2409     ParseFunctions(die_offsets, include_inlines, sc_list);
2410   }
2411 }
2412
2413 void SymbolFileDWARF::FindFunctions(
2414     const RegularExpression &regex,
2415     const DWARFMappedHash::MemoryTable &memory_table, bool include_inlines,
2416     SymbolContextList &sc_list) {
2417   DIEArray die_offsets;
2418   DWARFMappedHash::DIEInfoArray hash_data_array;
2419   if (memory_table.AppendAllDIEsThatMatchingRegex(regex, hash_data_array)) {
2420     DWARFMappedHash::ExtractDIEArray(hash_data_array, die_offsets);
2421     ParseFunctions(die_offsets, include_inlines, sc_list);
2422   }
2423 }
2424
2425 void SymbolFileDWARF::ParseFunctions(const DIEArray &die_offsets,
2426                                      bool include_inlines,
2427                                      SymbolContextList &sc_list) {
2428   const size_t num_matches = die_offsets.size();
2429   if (num_matches) {
2430     for (size_t i = 0; i < num_matches; ++i)
2431       ResolveFunction(die_offsets[i], include_inlines, sc_list);
2432   }
2433 }
2434
2435 bool SymbolFileDWARF::DIEInDeclContext(const CompilerDeclContext *decl_ctx,
2436                                        const DWARFDIE &die) {
2437   // If we have no parent decl context to match this DIE matches, and if the
2438   // parent
2439   // decl context isn't valid, we aren't trying to look for any particular decl
2440   // context so any die matches.
2441   if (decl_ctx == nullptr || !decl_ctx->IsValid())
2442     return true;
2443
2444   if (die) {
2445     DWARFASTParser *dwarf_ast = die.GetDWARFParser();
2446     if (dwarf_ast) {
2447       CompilerDeclContext actual_decl_ctx =
2448           dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
2449       if (actual_decl_ctx)
2450         return actual_decl_ctx == *decl_ctx;
2451     }
2452   }
2453   return false;
2454 }
2455
2456 uint32_t
2457 SymbolFileDWARF::FindFunctions(const ConstString &name,
2458                                const CompilerDeclContext *parent_decl_ctx,
2459                                uint32_t name_type_mask, bool include_inlines,
2460                                bool append, SymbolContextList &sc_list) {
2461   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
2462   Timer scoped_timer(func_cat, "SymbolFileDWARF::FindFunctions (name = '%s')",
2463                      name.AsCString());
2464
2465   // eFunctionNameTypeAuto should be pre-resolved by a call to
2466   // Module::LookupInfo::LookupInfo()
2467   assert((name_type_mask & eFunctionNameTypeAuto) == 0);
2468
2469   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
2470
2471   if (log) {
2472     GetObjectFile()->GetModule()->LogMessage(
2473         log, "SymbolFileDWARF::FindFunctions (name=\"%s\", "
2474              "name_type_mask=0x%x, append=%u, sc_list)",
2475         name.GetCString(), name_type_mask, append);
2476   }
2477
2478   // If we aren't appending the results to this list, then clear the list
2479   if (!append)
2480     sc_list.Clear();
2481
2482   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
2483     return 0;
2484
2485   // If name is empty then we won't find anything.
2486   if (name.IsEmpty())
2487     return 0;
2488
2489   // Remember how many sc_list are in the list before we search in case
2490   // we are appending the results to a variable list.
2491
2492   const char *name_cstr = name.GetCString();
2493
2494   const uint32_t original_size = sc_list.GetSize();
2495
2496   DWARFDebugInfo *info = DebugInfo();
2497   if (info == NULL)
2498     return 0;
2499
2500   std::set<const DWARFDebugInfoEntry *> resolved_dies;
2501   if (m_using_apple_tables) {
2502     if (m_apple_names_ap.get()) {
2503
2504       DIEArray die_offsets;
2505
2506       uint32_t num_matches = 0;
2507
2508       if (name_type_mask & eFunctionNameTypeFull) {
2509         // If they asked for the full name, match what they typed.  At some
2510         // point we may
2511         // want to canonicalize this (strip double spaces, etc.  For now, we
2512         // just add all the
2513         // dies that we find by exact match.
2514         num_matches = m_apple_names_ap->FindByName(name_cstr, die_offsets);
2515         for (uint32_t i = 0; i < num_matches; i++) {
2516           const DIERef &die_ref = die_offsets[i];
2517           DWARFDIE die = info->GetDIE(die_ref);
2518           if (die) {
2519             if (!DIEInDeclContext(parent_decl_ctx, die))
2520               continue; // The containing decl contexts don't match
2521
2522             if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) {
2523               if (ResolveFunction(die, include_inlines, sc_list))
2524                 resolved_dies.insert(die.GetDIE());
2525             }
2526           } else {
2527             GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
2528                 "the DWARF debug information has been modified (.apple_names "
2529                 "accelerator table had bad die 0x%8.8x for '%s')",
2530                 die_ref.die_offset, name_cstr);
2531           }
2532         }
2533       }
2534
2535       if (name_type_mask & eFunctionNameTypeSelector) {
2536         if (parent_decl_ctx && parent_decl_ctx->IsValid())
2537           return 0; // no selectors in namespaces
2538
2539         num_matches = m_apple_names_ap->FindByName(name_cstr, die_offsets);
2540         // Now make sure these are actually ObjC methods.  In this case we can
2541         // simply look up the name,
2542         // and if it is an ObjC method name, we're good.
2543
2544         for (uint32_t i = 0; i < num_matches; i++) {
2545           const DIERef &die_ref = die_offsets[i];
2546           DWARFDIE die = info->GetDIE(die_ref);
2547           if (die) {
2548             const char *die_name = die.GetName();
2549             if (ObjCLanguage::IsPossibleObjCMethodName(die_name)) {
2550               if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) {
2551                 if (ResolveFunction(die, include_inlines, sc_list))
2552                   resolved_dies.insert(die.GetDIE());
2553               }
2554             }
2555           } else {
2556             GetObjectFile()->GetModule()->ReportError(
2557                 "the DWARF debug information has been modified (.apple_names "
2558                 "accelerator table had bad die 0x%8.8x for '%s')",
2559                 die_ref.die_offset, name_cstr);
2560           }
2561         }
2562         die_offsets.clear();
2563       }
2564
2565       if (((name_type_mask & eFunctionNameTypeMethod) && !parent_decl_ctx) ||
2566           name_type_mask & eFunctionNameTypeBase) {
2567         // The apple_names table stores just the "base name" of C++ methods in
2568         // the table.  So we have to
2569         // extract the base name, look that up, and if there is any other
2570         // information in the name we were
2571         // passed in we have to post-filter based on that.
2572
2573         // FIXME: Arrange the logic above so that we don't calculate the base
2574         // name twice:
2575         num_matches = m_apple_names_ap->FindByName(name_cstr, die_offsets);
2576
2577         for (uint32_t i = 0; i < num_matches; i++) {
2578           const DIERef &die_ref = die_offsets[i];
2579           DWARFDIE die = info->GetDIE(die_ref);
2580           if (die) {
2581             if (!DIEInDeclContext(parent_decl_ctx, die))
2582               continue; // The containing decl contexts don't match
2583
2584             // If we get to here, the die is good, and we should add it:
2585             if (resolved_dies.find(die.GetDIE()) == resolved_dies.end() &&
2586                 ResolveFunction(die, include_inlines, sc_list)) {
2587               bool keep_die = true;
2588               if ((name_type_mask &
2589                    (eFunctionNameTypeBase | eFunctionNameTypeMethod)) !=
2590                   (eFunctionNameTypeBase | eFunctionNameTypeMethod)) {
2591                 // We are looking for either basenames or methods, so we need to
2592                 // trim out the ones we won't want by looking at the type
2593                 SymbolContext sc;
2594                 if (sc_list.GetLastContext(sc)) {
2595                   if (sc.block) {
2596                     // We have an inlined function
2597                   } else if (sc.function) {
2598                     Type *type = sc.function->GetType();
2599
2600                     if (type) {
2601                       CompilerDeclContext decl_ctx =
2602                           GetDeclContextContainingUID(type->GetID());
2603                       if (decl_ctx.IsStructUnionOrClass()) {
2604                         if (name_type_mask & eFunctionNameTypeBase) {
2605                           sc_list.RemoveContextAtIndex(sc_list.GetSize() - 1);
2606                           keep_die = false;
2607                         }
2608                       } else {
2609                         if (name_type_mask & eFunctionNameTypeMethod) {
2610                           sc_list.RemoveContextAtIndex(sc_list.GetSize() - 1);
2611                           keep_die = false;
2612                         }
2613                       }
2614                     } else {
2615                       GetObjectFile()->GetModule()->ReportWarning(
2616                           "function at die offset 0x%8.8x had no function type",
2617                           die_ref.die_offset);
2618                     }
2619                   }
2620                 }
2621               }
2622               if (keep_die)
2623                 resolved_dies.insert(die.GetDIE());
2624             }
2625           } else {
2626             GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
2627                 "the DWARF debug information has been modified (.apple_names "
2628                 "accelerator table had bad die 0x%8.8x for '%s')",
2629                 die_ref.die_offset, name_cstr);
2630           }
2631         }
2632         die_offsets.clear();
2633       }
2634     }
2635   } else {
2636
2637     // Index the DWARF if we haven't already
2638     if (!m_indexed)
2639       Index();
2640
2641     if (name_type_mask & eFunctionNameTypeFull) {
2642       FindFunctions(name, m_function_fullname_index, include_inlines, sc_list);
2643
2644       // FIXME Temporary workaround for global/anonymous namespace
2645       // functions debugging FreeBSD and Linux binaries.
2646       // If we didn't find any functions in the global namespace try
2647       // looking in the basename index but ignore any returned
2648       // functions that have a namespace but keep functions which
2649       // have an anonymous namespace
2650       // TODO: The arch in the object file isn't correct for MSVC
2651       // binaries on windows, we should find a way to make it
2652       // correct and handle those symbols as well.
2653       if (sc_list.GetSize() == original_size) {
2654         ArchSpec arch;
2655         if (!parent_decl_ctx && GetObjectFile()->GetArchitecture(arch) &&
2656             arch.GetTriple().isOSBinFormatELF()) {
2657           SymbolContextList temp_sc_list;
2658           FindFunctions(name, m_function_basename_index, include_inlines,
2659                         temp_sc_list);
2660           SymbolContext sc;
2661           for (uint32_t i = 0; i < temp_sc_list.GetSize(); i++) {
2662             if (temp_sc_list.GetContextAtIndex(i, sc)) {
2663               ConstString mangled_name =
2664                   sc.GetFunctionName(Mangled::ePreferMangled);
2665               ConstString demangled_name =
2666                   sc.GetFunctionName(Mangled::ePreferDemangled);
2667               // Mangled names on Linux and FreeBSD are of the form:
2668               // _ZN18function_namespace13function_nameEv.
2669               if (strncmp(mangled_name.GetCString(), "_ZN", 3) ||
2670                   !strncmp(demangled_name.GetCString(), "(anonymous namespace)",
2671                            21)) {
2672                 sc_list.Append(sc);
2673               }
2674             }
2675           }
2676         }
2677       }
2678     }
2679     DIEArray die_offsets;
2680     if (name_type_mask & eFunctionNameTypeBase) {
2681       uint32_t num_base = m_function_basename_index.Find(name, die_offsets);
2682       for (uint32_t i = 0; i < num_base; i++) {
2683         DWARFDIE die = info->GetDIE(die_offsets[i]);
2684         if (die) {
2685           if (!DIEInDeclContext(parent_decl_ctx, die))
2686             continue; // The containing decl contexts don't match
2687
2688           // If we get to here, the die is good, and we should add it:
2689           if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) {
2690             if (ResolveFunction(die, include_inlines, sc_list))
2691               resolved_dies.insert(die.GetDIE());
2692           }
2693         }
2694       }
2695       die_offsets.clear();
2696     }
2697
2698     if (name_type_mask & eFunctionNameTypeMethod) {
2699       if (parent_decl_ctx && parent_decl_ctx->IsValid())
2700         return 0; // no methods in namespaces
2701
2702       uint32_t num_base = m_function_method_index.Find(name, die_offsets);
2703       {
2704         for (uint32_t i = 0; i < num_base; i++) {
2705           DWARFDIE die = info->GetDIE(die_offsets[i]);
2706           if (die) {
2707             // If we get to here, the die is good, and we should add it:
2708             if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) {
2709               if (ResolveFunction(die, include_inlines, sc_list))
2710                 resolved_dies.insert(die.GetDIE());
2711             }
2712           }
2713         }
2714       }
2715       die_offsets.clear();
2716     }
2717
2718     if ((name_type_mask & eFunctionNameTypeSelector) &&
2719         (!parent_decl_ctx || !parent_decl_ctx->IsValid())) {
2720       FindFunctions(name, m_function_selector_index, include_inlines, sc_list);
2721     }
2722   }
2723
2724   // Return the number of variable that were appended to the list
2725   const uint32_t num_matches = sc_list.GetSize() - original_size;
2726
2727   if (log && num_matches > 0) {
2728     GetObjectFile()->GetModule()->LogMessage(
2729         log, "SymbolFileDWARF::FindFunctions (name=\"%s\", "
2730              "name_type_mask=0x%x, include_inlines=%d, append=%u, sc_list) => "
2731              "%u",
2732         name.GetCString(), name_type_mask, include_inlines, append,
2733         num_matches);
2734   }
2735   return num_matches;
2736 }
2737
2738 uint32_t SymbolFileDWARF::FindFunctions(const RegularExpression &regex,
2739                                         bool include_inlines, bool append,
2740                                         SymbolContextList &sc_list) {
2741   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
2742   Timer scoped_timer(func_cat, "SymbolFileDWARF::FindFunctions (regex = '%s')",
2743                      regex.GetText().str().c_str());
2744
2745   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
2746
2747   if (log) {
2748     GetObjectFile()->GetModule()->LogMessage(
2749         log,
2750         "SymbolFileDWARF::FindFunctions (regex=\"%s\", append=%u, sc_list)",
2751         regex.GetText().str().c_str(), append);
2752   }
2753
2754   // If we aren't appending the results to this list, then clear the list
2755   if (!append)
2756     sc_list.Clear();
2757
2758   // Remember how many sc_list are in the list before we search in case
2759   // we are appending the results to a variable list.
2760   uint32_t original_size = sc_list.GetSize();
2761
2762   if (m_using_apple_tables) {
2763     if (m_apple_names_ap.get())
2764       FindFunctions(regex, *m_apple_names_ap, include_inlines, sc_list);
2765   } else {
2766     // Index the DWARF if we haven't already
2767     if (!m_indexed)
2768       Index();
2769
2770     FindFunctions(regex, m_function_basename_index, include_inlines, sc_list);
2771
2772     FindFunctions(regex, m_function_fullname_index, include_inlines, sc_list);
2773   }
2774
2775   // Return the number of variable that were appended to the list
2776   return sc_list.GetSize() - original_size;
2777 }
2778
2779 void SymbolFileDWARF::GetMangledNamesForFunction(
2780     const std::string &scope_qualified_name,
2781     std::vector<ConstString> &mangled_names) {
2782   DWARFDebugInfo *info = DebugInfo();
2783   uint32_t num_comp_units = 0;
2784   if (info)
2785     num_comp_units = info->GetNumCompileUnits();
2786
2787   for (uint32_t i = 0; i < num_comp_units; i++) {
2788     DWARFCompileUnit *cu = info->GetCompileUnitAtIndex(i);
2789     if (cu == nullptr)
2790       continue;
2791
2792     SymbolFileDWARFDwo *dwo = cu->GetDwoSymbolFile();
2793     if (dwo)
2794       dwo->GetMangledNamesForFunction(scope_qualified_name, mangled_names);
2795   }
2796
2797   NameToOffsetMap::iterator iter =
2798       m_function_scope_qualified_name_map.find(scope_qualified_name);
2799   if (iter == m_function_scope_qualified_name_map.end())
2800     return;
2801
2802   DIERefSetSP set_sp = (*iter).second;
2803   std::set<DIERef>::iterator set_iter;
2804   for (set_iter = set_sp->begin(); set_iter != set_sp->end(); set_iter++) {
2805     DWARFDIE die = DebugInfo()->GetDIE(*set_iter);
2806     mangled_names.push_back(ConstString(die.GetMangledName()));
2807   }
2808 }
2809
2810 uint32_t SymbolFileDWARF::FindTypes(
2811     const SymbolContext &sc, const ConstString &name,
2812     const CompilerDeclContext *parent_decl_ctx, bool append,
2813     uint32_t max_matches,
2814     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
2815     TypeMap &types) {
2816   // If we aren't appending the results to this list, then clear the list
2817   if (!append)
2818     types.Clear();
2819
2820   // Make sure we haven't already searched this SymbolFile before...
2821   if (searched_symbol_files.count(this))
2822     return 0;
2823   else
2824     searched_symbol_files.insert(this);
2825
2826   DWARFDebugInfo *info = DebugInfo();
2827   if (info == NULL)
2828     return 0;
2829
2830   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
2831
2832   if (log) {
2833     if (parent_decl_ctx)
2834       GetObjectFile()->GetModule()->LogMessage(
2835           log, "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = "
2836                "%p (\"%s\"), append=%u, max_matches=%u, type_list)",
2837           name.GetCString(), static_cast<const void *>(parent_decl_ctx),
2838           parent_decl_ctx->GetName().AsCString("<NULL>"), append, max_matches);
2839     else
2840       GetObjectFile()->GetModule()->LogMessage(
2841           log, "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = "
2842                "NULL, append=%u, max_matches=%u, type_list)",
2843           name.GetCString(), append, max_matches);
2844   }
2845
2846   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
2847     return 0;
2848
2849   DIEArray die_offsets;
2850
2851   if (m_using_apple_tables) {
2852     if (m_apple_types_ap.get()) {
2853       const char *name_cstr = name.GetCString();
2854       m_apple_types_ap->FindByName(name_cstr, die_offsets);
2855     }
2856   } else {
2857     if (!m_indexed)
2858       Index();
2859
2860     m_type_index.Find(name, die_offsets);
2861   }
2862
2863   const size_t num_die_matches = die_offsets.size();
2864
2865   if (num_die_matches) {
2866     const uint32_t initial_types_size = types.GetSize();
2867     for (size_t i = 0; i < num_die_matches; ++i) {
2868       const DIERef &die_ref = die_offsets[i];
2869       DWARFDIE die = GetDIE(die_ref);
2870
2871       if (die) {
2872         if (!DIEInDeclContext(parent_decl_ctx, die))
2873           continue; // The containing decl contexts don't match
2874
2875         Type *matching_type = ResolveType(die, true, true);
2876         if (matching_type) {
2877           // We found a type pointer, now find the shared pointer form our type
2878           // list
2879           types.InsertUnique(matching_type->shared_from_this());
2880           if (types.GetSize() >= max_matches)
2881             break;
2882         }
2883       } else {
2884         if (m_using_apple_tables) {
2885           GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
2886               "the DWARF debug information has been modified (.apple_types "
2887               "accelerator table had bad die 0x%8.8x for '%s')\n",
2888               die_ref.die_offset, name.GetCString());
2889         }
2890       }
2891     }
2892     const uint32_t num_matches = types.GetSize() - initial_types_size;
2893     if (log && num_matches) {
2894       if (parent_decl_ctx) {
2895         GetObjectFile()->GetModule()->LogMessage(
2896             log, "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx "
2897                  "= %p (\"%s\"), append=%u, max_matches=%u, type_list) => %u",
2898             name.GetCString(), static_cast<const void *>(parent_decl_ctx),
2899             parent_decl_ctx->GetName().AsCString("<NULL>"), append, max_matches,
2900             num_matches);
2901       } else {
2902         GetObjectFile()->GetModule()->LogMessage(
2903             log, "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx "
2904                  "= NULL, append=%u, max_matches=%u, type_list) => %u",
2905             name.GetCString(), append, max_matches, num_matches);
2906       }
2907     }
2908     return num_matches;
2909   } else {
2910     UpdateExternalModuleListIfNeeded();
2911
2912     for (const auto &pair : m_external_type_modules) {
2913       ModuleSP external_module_sp = pair.second;
2914       if (external_module_sp) {
2915         SymbolVendor *sym_vendor = external_module_sp->GetSymbolVendor();
2916         if (sym_vendor) {
2917           const uint32_t num_external_matches =
2918               sym_vendor->FindTypes(sc, name, parent_decl_ctx, append,
2919                                     max_matches, searched_symbol_files, types);
2920           if (num_external_matches)
2921             return num_external_matches;
2922         }
2923       }
2924     }
2925   }
2926
2927   return 0;
2928 }
2929
2930 size_t SymbolFileDWARF::FindTypes(const std::vector<CompilerContext> &context,
2931                                   bool append, TypeMap &types) {
2932   if (!append)
2933     types.Clear();
2934
2935   if (context.empty())
2936     return 0;
2937
2938   DIEArray die_offsets;
2939
2940   ConstString name = context.back().name;
2941
2942   if (!name)
2943     return 0;
2944
2945   if (m_using_apple_tables) {
2946     if (m_apple_types_ap.get()) {
2947       const char *name_cstr = name.GetCString();
2948       m_apple_types_ap->FindByName(name_cstr, die_offsets);
2949     }
2950   } else {
2951     if (!m_indexed)
2952       Index();
2953
2954     m_type_index.Find(name, die_offsets);
2955   }
2956
2957   const size_t num_die_matches = die_offsets.size();
2958
2959   if (num_die_matches) {
2960     size_t num_matches = 0;
2961     for (size_t i = 0; i < num_die_matches; ++i) {
2962       const DIERef &die_ref = die_offsets[i];
2963       DWARFDIE die = GetDIE(die_ref);
2964
2965       if (die) {
2966         std::vector<CompilerContext> die_context;
2967         die.GetDWOContext(die_context);
2968         if (die_context != context)
2969           continue;
2970
2971         Type *matching_type = ResolveType(die, true, true);
2972         if (matching_type) {
2973           // We found a type pointer, now find the shared pointer form our type
2974           // list
2975           types.InsertUnique(matching_type->shared_from_this());
2976           ++num_matches;
2977         }
2978       } else {
2979         if (m_using_apple_tables) {
2980           GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
2981               "the DWARF debug information has been modified (.apple_types "
2982               "accelerator table had bad die 0x%8.8x for '%s')\n",
2983               die_ref.die_offset, name.GetCString());
2984         }
2985       }
2986     }
2987     return num_matches;
2988   }
2989   return 0;
2990 }
2991
2992 CompilerDeclContext
2993 SymbolFileDWARF::FindNamespace(const SymbolContext &sc, const ConstString &name,
2994                                const CompilerDeclContext *parent_decl_ctx) {
2995   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
2996
2997   if (log) {
2998     GetObjectFile()->GetModule()->LogMessage(
2999         log, "SymbolFileDWARF::FindNamespace (sc, name=\"%s\")",
3000         name.GetCString());
3001   }
3002
3003   CompilerDeclContext namespace_decl_ctx;
3004
3005   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
3006     return namespace_decl_ctx;
3007
3008   DWARFDebugInfo *info = DebugInfo();
3009   if (info) {
3010     DIEArray die_offsets;
3011
3012     // Index if we already haven't to make sure the compile units
3013     // get indexed and make their global DIE index list
3014     if (m_using_apple_tables) {
3015       if (m_apple_namespaces_ap.get()) {
3016         const char *name_cstr = name.GetCString();
3017         m_apple_namespaces_ap->FindByName(name_cstr, die_offsets);
3018       }
3019     } else {
3020       if (!m_indexed)
3021         Index();
3022
3023       m_namespace_index.Find(name, die_offsets);
3024     }
3025
3026     const size_t num_matches = die_offsets.size();
3027     if (num_matches) {
3028       for (size_t i = 0; i < num_matches; ++i) {
3029         const DIERef &die_ref = die_offsets[i];
3030         DWARFDIE die = GetDIE(die_ref);
3031
3032         if (die) {
3033           if (!DIEInDeclContext(parent_decl_ctx, die))
3034             continue; // The containing decl contexts don't match
3035
3036           DWARFASTParser *dwarf_ast = die.GetDWARFParser();
3037           if (dwarf_ast) {
3038             namespace_decl_ctx = dwarf_ast->GetDeclContextForUIDFromDWARF(die);
3039             if (namespace_decl_ctx)
3040               break;
3041           }
3042         } else {
3043           if (m_using_apple_tables) {
3044             GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
3045                 "the DWARF debug information has been modified "
3046                 "(.apple_namespaces accelerator table had bad die 0x%8.8x for "
3047                 "'%s')\n",
3048                 die_ref.die_offset, name.GetCString());
3049           }
3050         }
3051       }
3052     }
3053   }
3054   if (log && namespace_decl_ctx) {
3055     GetObjectFile()->GetModule()->LogMessage(
3056         log, "SymbolFileDWARF::FindNamespace (sc, name=\"%s\") => "
3057              "CompilerDeclContext(%p/%p) \"%s\"",
3058         name.GetCString(),
3059         static_cast<const void *>(namespace_decl_ctx.GetTypeSystem()),
3060         static_cast<const void *>(namespace_decl_ctx.GetOpaqueDeclContext()),
3061         namespace_decl_ctx.GetName().AsCString("<NULL>"));
3062   }
3063
3064   return namespace_decl_ctx;
3065 }
3066
3067 TypeSP SymbolFileDWARF::GetTypeForDIE(const DWARFDIE &die,
3068                                       bool resolve_function_context) {
3069   TypeSP type_sp;
3070   if (die) {
3071     Type *type_ptr = GetDIEToType().lookup(die.GetDIE());
3072     if (type_ptr == NULL) {
3073       CompileUnit *lldb_cu = GetCompUnitForDWARFCompUnit(die.GetCU());
3074       assert(lldb_cu);
3075       SymbolContext sc(lldb_cu);
3076       const DWARFDebugInfoEntry *parent_die = die.GetParent().GetDIE();
3077       while (parent_die != nullptr) {
3078         if (parent_die->Tag() == DW_TAG_subprogram)
3079           break;
3080         parent_die = parent_die->GetParent();
3081       }
3082       SymbolContext sc_backup = sc;
3083       if (resolve_function_context && parent_die != nullptr &&
3084           !GetFunction(DWARFDIE(die.GetCU(), parent_die), sc))
3085         sc = sc_backup;
3086
3087       type_sp = ParseType(sc, die, NULL);
3088     } else if (type_ptr != DIE_IS_BEING_PARSED) {
3089       // Grab the existing type from the master types lists
3090       type_sp = type_ptr->shared_from_this();
3091     }
3092   }
3093   return type_sp;
3094 }
3095
3096 DWARFDIE
3097 SymbolFileDWARF::GetDeclContextDIEContainingDIE(const DWARFDIE &orig_die) {
3098   if (orig_die) {
3099     DWARFDIE die = orig_die;
3100
3101     while (die) {
3102       // If this is the original DIE that we are searching for a declaration
3103       // for, then don't look in the cache as we don't want our own decl
3104       // context to be our decl context...
3105       if (orig_die != die) {
3106         switch (die.Tag()) {
3107         case DW_TAG_compile_unit:
3108         case DW_TAG_namespace:
3109         case DW_TAG_structure_type:
3110         case DW_TAG_union_type:
3111         case DW_TAG_class_type:
3112         case DW_TAG_lexical_block:
3113         case DW_TAG_subprogram:
3114           return die;
3115         case DW_TAG_inlined_subroutine: {
3116           DWARFDIE abs_die = die.GetReferencedDIE(DW_AT_abstract_origin);
3117           if (abs_die) {
3118             return abs_die;
3119           }
3120           break;
3121         }
3122         default:
3123           break;
3124         }
3125       }
3126
3127       DWARFDIE spec_die = die.GetReferencedDIE(DW_AT_specification);
3128       if (spec_die) {
3129         DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(spec_die);
3130         if (decl_ctx_die)
3131           return decl_ctx_die;
3132       }
3133
3134       DWARFDIE abs_die = die.GetReferencedDIE(DW_AT_abstract_origin);
3135       if (abs_die) {
3136         DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(abs_die);
3137         if (decl_ctx_die)
3138           return decl_ctx_die;
3139       }
3140
3141       die = die.GetParent();
3142     }
3143   }
3144   return DWARFDIE();
3145 }
3146
3147 Symbol *
3148 SymbolFileDWARF::GetObjCClassSymbol(const ConstString &objc_class_name) {
3149   Symbol *objc_class_symbol = NULL;
3150   if (m_obj_file) {
3151     Symtab *symtab = m_obj_file->GetSymtab();
3152     if (symtab) {
3153       objc_class_symbol = symtab->FindFirstSymbolWithNameAndType(
3154           objc_class_name, eSymbolTypeObjCClass, Symtab::eDebugNo,
3155           Symtab::eVisibilityAny);
3156     }
3157   }
3158   return objc_class_symbol;
3159 }
3160
3161 // Some compilers don't emit the DW_AT_APPLE_objc_complete_type attribute. If
3162 // they don't
3163 // then we can end up looking through all class types for a complete type and
3164 // never find
3165 // the full definition. We need to know if this attribute is supported, so we
3166 // determine
3167 // this here and cache th result. We also need to worry about the debug map
3168 // DWARF file
3169 // if we are doing darwin DWARF in .o file debugging.
3170 bool SymbolFileDWARF::Supports_DW_AT_APPLE_objc_complete_type(
3171     DWARFCompileUnit *cu) {
3172   if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolCalculate) {
3173     m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolNo;
3174     if (cu && cu->Supports_DW_AT_APPLE_objc_complete_type())
3175       m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes;
3176     else {
3177       DWARFDebugInfo *debug_info = DebugInfo();
3178       const uint32_t num_compile_units = GetNumCompileUnits();
3179       for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
3180         DWARFCompileUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
3181         if (dwarf_cu != cu &&
3182             dwarf_cu->Supports_DW_AT_APPLE_objc_complete_type()) {
3183           m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes;
3184           break;
3185         }
3186       }
3187     }
3188     if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolNo &&
3189         GetDebugMapSymfile())
3190       return m_debug_map_symfile->Supports_DW_AT_APPLE_objc_complete_type(this);
3191   }
3192   return m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolYes;
3193 }
3194
3195 // This function can be used when a DIE is found that is a forward declaration
3196 // DIE and we want to try and find a type that has the complete definition.
3197 TypeSP SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE(
3198     const DWARFDIE &die, const ConstString &type_name,
3199     bool must_be_implementation) {
3200
3201   TypeSP type_sp;
3202
3203   if (!type_name || (must_be_implementation && !GetObjCClassSymbol(type_name)))
3204     return type_sp;
3205
3206   DIEArray die_offsets;
3207
3208   if (m_using_apple_tables) {
3209     if (m_apple_types_ap.get()) {
3210       const char *name_cstr = type_name.GetCString();
3211       m_apple_types_ap->FindCompleteObjCClassByName(name_cstr, die_offsets,
3212                                                     must_be_implementation);
3213     }
3214   } else {
3215     if (!m_indexed)
3216       Index();
3217
3218     m_type_index.Find(type_name, die_offsets);
3219   }
3220
3221   const size_t num_matches = die_offsets.size();
3222
3223   if (num_matches) {
3224     for (size_t i = 0; i < num_matches; ++i) {
3225       const DIERef &die_ref = die_offsets[i];
3226       DWARFDIE type_die = GetDIE(die_ref);
3227
3228       if (type_die) {
3229         bool try_resolving_type = false;
3230
3231         // Don't try and resolve the DIE we are looking for with the DIE itself!
3232         if (type_die != die) {
3233           switch (type_die.Tag()) {
3234           case DW_TAG_class_type:
3235           case DW_TAG_structure_type:
3236             try_resolving_type = true;
3237             break;
3238           default:
3239             break;
3240           }
3241         }
3242
3243         if (try_resolving_type) {
3244           if (must_be_implementation &&
3245               type_die.Supports_DW_AT_APPLE_objc_complete_type())
3246             try_resolving_type = type_die.GetAttributeValueAsUnsigned(
3247                 DW_AT_APPLE_objc_complete_type, 0);
3248
3249           if (try_resolving_type) {
3250             Type *resolved_type = ResolveType(type_die, false, true);
3251             if (resolved_type && resolved_type != DIE_IS_BEING_PARSED) {
3252               DEBUG_PRINTF("resolved 0x%8.8" PRIx64 " from %s to 0x%8.8" PRIx64
3253                            " (cu 0x%8.8" PRIx64 ")\n",
3254                            die.GetID(),
3255                            m_obj_file->GetFileSpec().GetFilename().AsCString(
3256                                "<Unknown>"),
3257                            type_die.GetID(), type_cu->GetID());
3258
3259               if (die)
3260                 GetDIEToType()[die.GetDIE()] = resolved_type;
3261               type_sp = resolved_type->shared_from_this();
3262               break;
3263             }
3264           }
3265         }
3266       } else {
3267         if (m_using_apple_tables) {
3268           GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
3269               "the DWARF debug information has been modified (.apple_types "
3270               "accelerator table had bad die 0x%8.8x for '%s')\n",
3271               die_ref.die_offset, type_name.GetCString());
3272         }
3273       }
3274     }
3275   }
3276   return type_sp;
3277 }
3278
3279 //----------------------------------------------------------------------
3280 // This function helps to ensure that the declaration contexts match for
3281 // two different DIEs. Often times debug information will refer to a
3282 // forward declaration of a type (the equivalent of "struct my_struct;".
3283 // There will often be a declaration of that type elsewhere that has the
3284 // full definition. When we go looking for the full type "my_struct", we
3285 // will find one or more matches in the accelerator tables and we will
3286 // then need to make sure the type was in the same declaration context
3287 // as the original DIE. This function can efficiently compare two DIEs
3288 // and will return true when the declaration context matches, and false
3289 // when they don't.
3290 //----------------------------------------------------------------------
3291 bool SymbolFileDWARF::DIEDeclContextsMatch(const DWARFDIE &die1,
3292                                            const DWARFDIE &die2) {
3293   if (die1 == die2)
3294     return true;
3295
3296   DWARFDIECollection decl_ctx_1;
3297   DWARFDIECollection decl_ctx_2;
3298   // The declaration DIE stack is a stack of the declaration context
3299   // DIEs all the way back to the compile unit. If a type "T" is
3300   // declared inside a class "B", and class "B" is declared inside
3301   // a class "A" and class "A" is in a namespace "lldb", and the
3302   // namespace is in a compile unit, there will be a stack of DIEs:
3303   //
3304   //   [0] DW_TAG_class_type for "B"
3305   //   [1] DW_TAG_class_type for "A"
3306   //   [2] DW_TAG_namespace  for "lldb"
3307   //   [3] DW_TAG_compile_unit for the source file.
3308   //
3309   // We grab both contexts and make sure that everything matches
3310   // all the way back to the compiler unit.
3311
3312   // First lets grab the decl contexts for both DIEs
3313   die1.GetDeclContextDIEs(decl_ctx_1);
3314   die2.GetDeclContextDIEs(decl_ctx_2);
3315   // Make sure the context arrays have the same size, otherwise
3316   // we are done
3317   const size_t count1 = decl_ctx_1.Size();
3318   const size_t count2 = decl_ctx_2.Size();
3319   if (count1 != count2)
3320     return false;
3321
3322   // Make sure the DW_TAG values match all the way back up the
3323   // compile unit. If they don't, then we are done.
3324   DWARFDIE decl_ctx_die1;
3325   DWARFDIE decl_ctx_die2;
3326   size_t i;
3327   for (i = 0; i < count1; i++) {
3328     decl_ctx_die1 = decl_ctx_1.GetDIEAtIndex(i);
3329     decl_ctx_die2 = decl_ctx_2.GetDIEAtIndex(i);
3330     if (decl_ctx_die1.Tag() != decl_ctx_die2.Tag())
3331       return false;
3332   }
3333 #if defined LLDB_CONFIGURATION_DEBUG
3334
3335   // Make sure the top item in the decl context die array is always
3336   // DW_TAG_compile_unit. If it isn't then something went wrong in
3337   // the DWARFDIE::GetDeclContextDIEs() function...
3338   assert(decl_ctx_1.GetDIEAtIndex(count1 - 1).Tag() == DW_TAG_compile_unit);
3339
3340 #endif
3341   // Always skip the compile unit when comparing by only iterating up to
3342   // "count - 1". Here we compare the names as we go.
3343   for (i = 0; i < count1 - 1; i++) {
3344     decl_ctx_die1 = decl_ctx_1.GetDIEAtIndex(i);
3345     decl_ctx_die2 = decl_ctx_2.GetDIEAtIndex(i);
3346     const char *name1 = decl_ctx_die1.GetName();
3347     const char *name2 = decl_ctx_die2.GetName();
3348     // If the string was from a DW_FORM_strp, then the pointer will often
3349     // be the same!
3350     if (name1 == name2)
3351       continue;
3352
3353     // Name pointers are not equal, so only compare the strings
3354     // if both are not NULL.
3355     if (name1 && name2) {
3356       // If the strings don't compare, we are done...
3357       if (strcmp(name1, name2) != 0)
3358         return false;
3359     } else {
3360       // One name was NULL while the other wasn't
3361       return false;
3362     }
3363   }
3364   // We made it through all of the checks and the declaration contexts
3365   // are equal.
3366   return true;
3367 }
3368
3369 TypeSP SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(
3370     const DWARFDeclContext &dwarf_decl_ctx) {
3371   TypeSP type_sp;
3372
3373   const uint32_t dwarf_decl_ctx_count = dwarf_decl_ctx.GetSize();
3374   if (dwarf_decl_ctx_count > 0) {
3375     const ConstString type_name(dwarf_decl_ctx[0].name);
3376     const dw_tag_t tag = dwarf_decl_ctx[0].tag;
3377
3378     if (type_name) {
3379       Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION |
3380                                             DWARF_LOG_LOOKUPS));
3381       if (log) {
3382         GetObjectFile()->GetModule()->LogMessage(
3383             log, "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%"
3384                  "s, qualified-name='%s')",
3385             DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
3386             dwarf_decl_ctx.GetQualifiedName());
3387       }
3388
3389       DIEArray die_offsets;
3390
3391       if (m_using_apple_tables) {
3392         if (m_apple_types_ap.get()) {
3393           const bool has_tag =
3394               m_apple_types_ap->GetHeader().header_data.ContainsAtom(
3395                   DWARFMappedHash::eAtomTypeTag);
3396           const bool has_qualified_name_hash =
3397               m_apple_types_ap->GetHeader().header_data.ContainsAtom(
3398                   DWARFMappedHash::eAtomTypeQualNameHash);
3399           if (has_tag && has_qualified_name_hash) {
3400             const char *qualified_name = dwarf_decl_ctx.GetQualifiedName();
3401             const uint32_t qualified_name_hash =
3402                 MappedHash::HashStringUsingDJB(qualified_name);
3403             if (log)
3404               GetObjectFile()->GetModule()->LogMessage(
3405                   log, "FindByNameAndTagAndQualifiedNameHash()");
3406             m_apple_types_ap->FindByNameAndTagAndQualifiedNameHash(
3407                 type_name.GetCString(), tag, qualified_name_hash, die_offsets);
3408           } else if (has_tag) {
3409             if (log)
3410               GetObjectFile()->GetModule()->LogMessage(log,
3411                                                        "FindByNameAndTag()");
3412             m_apple_types_ap->FindByNameAndTag(type_name.GetCString(), tag,
3413                                                die_offsets);
3414           } else {
3415             m_apple_types_ap->FindByName(type_name.GetCString(), die_offsets);
3416           }
3417         }
3418       } else {
3419         if (!m_indexed)
3420           Index();
3421
3422         m_type_index.Find(type_name, die_offsets);
3423       }
3424
3425       const size_t num_matches = die_offsets.size();
3426
3427       // Get the type system that we are looking to find a type for. We will use
3428       // this
3429       // to ensure any matches we find are in a language that this type system
3430       // supports
3431       const LanguageType language = dwarf_decl_ctx.GetLanguage();
3432       TypeSystem *type_system = (language == eLanguageTypeUnknown)
3433                                     ? nullptr
3434                                     : GetTypeSystemForLanguage(language);
3435
3436       if (num_matches) {
3437         for (size_t i = 0; i < num_matches; ++i) {
3438           const DIERef &die_ref = die_offsets[i];
3439           DWARFDIE type_die = GetDIE(die_ref);
3440
3441           if (type_die) {
3442             // Make sure type_die's langauge matches the type system we are
3443             // looking for.
3444             // We don't want to find a "Foo" type from Java if we are looking
3445             // for a "Foo"
3446             // type for C, C++, ObjC, or ObjC++.
3447             if (type_system &&
3448                 !type_system->SupportsLanguage(type_die.GetLanguage()))
3449               continue;
3450             bool try_resolving_type = false;
3451
3452             // Don't try and resolve the DIE we are looking for with the DIE
3453             // itself!
3454             const dw_tag_t type_tag = type_die.Tag();
3455             // Make sure the tags match
3456             if (type_tag == tag) {
3457               // The tags match, lets try resolving this type
3458               try_resolving_type = true;
3459             } else {
3460               // The tags don't match, but we need to watch our for a
3461               // forward declaration for a struct and ("struct foo")
3462               // ends up being a class ("class foo { ... };") or
3463               // vice versa.
3464               switch (type_tag) {
3465               case DW_TAG_class_type:
3466                 // We had a "class foo", see if we ended up with a "struct foo {
3467                 // ... };"
3468                 try_resolving_type = (tag == DW_TAG_structure_type);
3469                 break;
3470               case DW_TAG_structure_type:
3471                 // We had a "struct foo", see if we ended up with a "class foo {
3472                 // ... };"
3473                 try_resolving_type = (tag == DW_TAG_class_type);
3474                 break;
3475               default:
3476                 // Tags don't match, don't event try to resolve
3477                 // using this type whose name matches....
3478                 break;
3479               }
3480             }
3481
3482             if (try_resolving_type) {
3483               DWARFDeclContext type_dwarf_decl_ctx;
3484               type_die.GetDWARFDeclContext(type_dwarf_decl_ctx);
3485
3486               if (log) {
3487                 GetObjectFile()->GetModule()->LogMessage(
3488                     log, "SymbolFileDWARF::"
3489                          "FindDefinitionTypeForDWARFDeclContext(tag=%s, "
3490                          "qualified-name='%s') trying die=0x%8.8x (%s)",
3491                     DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
3492                     dwarf_decl_ctx.GetQualifiedName(), type_die.GetOffset(),
3493                     type_dwarf_decl_ctx.GetQualifiedName());
3494               }
3495
3496               // Make sure the decl contexts match all the way up
3497               if (dwarf_decl_ctx == type_dwarf_decl_ctx) {
3498                 Type *resolved_type = ResolveType(type_die, false);
3499                 if (resolved_type && resolved_type != DIE_IS_BEING_PARSED) {
3500                   type_sp = resolved_type->shared_from_this();
3501                   break;
3502                 }
3503               }
3504             } else {
3505               if (log) {
3506                 std::string qualified_name;
3507                 type_die.GetQualifiedName(qualified_name);
3508                 GetObjectFile()->GetModule()->LogMessage(
3509                     log, "SymbolFileDWARF::"
3510                          "FindDefinitionTypeForDWARFDeclContext(tag=%s, "
3511                          "qualified-name='%s') ignoring die=0x%8.8x (%s)",
3512                     DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
3513                     dwarf_decl_ctx.GetQualifiedName(), type_die.GetOffset(),
3514                     qualified_name.c_str());
3515               }
3516             }
3517           } else {
3518             if (m_using_apple_tables) {
3519               GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
3520                   "the DWARF debug information has been modified (.apple_types "
3521                   "accelerator table had bad die 0x%8.8x for '%s')\n",
3522                   die_ref.die_offset, type_name.GetCString());
3523             }
3524           }
3525         }
3526       }
3527     }
3528   }
3529   return type_sp;
3530 }
3531
3532 TypeSP SymbolFileDWARF::ParseType(const SymbolContext &sc, const DWARFDIE &die,
3533                                   bool *type_is_new_ptr) {
3534   TypeSP type_sp;
3535
3536   if (die) {
3537     TypeSystem *type_system =
3538         GetTypeSystemForLanguage(die.GetCU()->GetLanguageType());
3539
3540     if (type_system) {
3541       DWARFASTParser *dwarf_ast = type_system->GetDWARFParser();
3542       if (dwarf_ast) {
3543         Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
3544         type_sp = dwarf_ast->ParseTypeFromDWARF(sc, die, log, type_is_new_ptr);
3545         if (type_sp) {
3546           TypeList *type_list = GetTypeList();
3547           if (type_list)
3548             type_list->Insert(type_sp);
3549
3550           if (die.Tag() == DW_TAG_subprogram) {
3551             DIERef die_ref = die.GetDIERef();
3552             std::string scope_qualified_name(GetDeclContextForUID(die.GetID())
3553                                                  .GetScopeQualifiedName()
3554                                                  .AsCString(""));
3555             if (scope_qualified_name.size()) {
3556               NameToOffsetMap::iterator iter =
3557                   m_function_scope_qualified_name_map.find(
3558                       scope_qualified_name);
3559               if (iter != m_function_scope_qualified_name_map.end())
3560                 (*iter).second->insert(die_ref);
3561               else {
3562                 DIERefSetSP new_set(new std::set<DIERef>);
3563                 new_set->insert(die_ref);
3564                 m_function_scope_qualified_name_map.emplace(
3565                     std::make_pair(scope_qualified_name, new_set));
3566               }
3567             }
3568           }
3569         }
3570       }
3571     }
3572   }
3573
3574   return type_sp;
3575 }
3576
3577 size_t SymbolFileDWARF::ParseTypes(const SymbolContext &sc,
3578                                    const DWARFDIE &orig_die,
3579                                    bool parse_siblings, bool parse_children) {
3580   size_t types_added = 0;
3581   DWARFDIE die = orig_die;
3582   while (die) {
3583     bool type_is_new = false;
3584     if (ParseType(sc, die, &type_is_new).get()) {
3585       if (type_is_new)
3586         ++types_added;
3587     }
3588
3589     if (parse_children && die.HasChildren()) {
3590       if (die.Tag() == DW_TAG_subprogram) {
3591         SymbolContext child_sc(sc);
3592         child_sc.function = sc.comp_unit->FindFunctionByUID(die.GetID()).get();
3593         types_added += ParseTypes(child_sc, die.GetFirstChild(), true, true);
3594       } else
3595         types_added += ParseTypes(sc, die.GetFirstChild(), true, true);
3596     }
3597
3598     if (parse_siblings)
3599       die = die.GetSibling();
3600     else
3601       die.Clear();
3602   }
3603   return types_added;
3604 }
3605
3606 size_t SymbolFileDWARF::ParseFunctionBlocks(const SymbolContext &sc) {
3607   assert(sc.comp_unit && sc.function);
3608   size_t functions_added = 0;
3609   DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
3610   if (dwarf_cu) {
3611     const dw_offset_t function_die_offset = sc.function->GetID();
3612     DWARFDIE function_die = dwarf_cu->GetDIE(function_die_offset);
3613     if (function_die) {
3614       ParseFunctionBlocks(sc, &sc.function->GetBlock(false), function_die,
3615                           LLDB_INVALID_ADDRESS, 0);
3616     }
3617   }
3618
3619   return functions_added;
3620 }
3621
3622 size_t SymbolFileDWARF::ParseTypes(const SymbolContext &sc) {
3623   // At least a compile unit must be valid
3624   assert(sc.comp_unit);
3625   size_t types_added = 0;
3626   DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
3627   if (dwarf_cu) {
3628     if (sc.function) {
3629       dw_offset_t function_die_offset = sc.function->GetID();
3630       DWARFDIE func_die = dwarf_cu->GetDIE(function_die_offset);
3631       if (func_die && func_die.HasChildren()) {
3632         types_added = ParseTypes(sc, func_die.GetFirstChild(), true, true);
3633       }
3634     } else {
3635       DWARFDIE dwarf_cu_die = dwarf_cu->DIE();
3636       if (dwarf_cu_die && dwarf_cu_die.HasChildren()) {
3637         types_added = ParseTypes(sc, dwarf_cu_die.GetFirstChild(), true, true);
3638       }
3639     }
3640   }
3641
3642   return types_added;
3643 }
3644
3645 size_t SymbolFileDWARF::ParseVariablesForContext(const SymbolContext &sc) {
3646   if (sc.comp_unit != NULL) {
3647     DWARFDebugInfo *info = DebugInfo();
3648     if (info == NULL)
3649       return 0;
3650
3651     if (sc.function) {
3652       DWARFDIE function_die = info->GetDIE(DIERef(sc.function->GetID(), this));
3653
3654       const dw_addr_t func_lo_pc = function_die.GetAttributeValueAsAddress(
3655           DW_AT_low_pc, LLDB_INVALID_ADDRESS);
3656       if (func_lo_pc != LLDB_INVALID_ADDRESS) {
3657         const size_t num_variables = ParseVariables(
3658             sc, function_die.GetFirstChild(), func_lo_pc, true, true);
3659
3660         // Let all blocks know they have parse all their variables
3661         sc.function->GetBlock(false).SetDidParseVariables(true, true);
3662         return num_variables;
3663       }
3664     } else if (sc.comp_unit) {
3665       DWARFCompileUnit *dwarf_cu = info->GetCompileUnit(sc.comp_unit->GetID());
3666
3667       if (dwarf_cu == NULL)
3668         return 0;
3669
3670       uint32_t vars_added = 0;
3671       VariableListSP variables(sc.comp_unit->GetVariableList(false));
3672
3673       if (variables.get() == NULL) {
3674         variables.reset(new VariableList());
3675         sc.comp_unit->SetVariableList(variables);
3676
3677         DIEArray die_offsets;
3678         if (m_using_apple_tables) {
3679           if (m_apple_names_ap.get()) {
3680             DWARFMappedHash::DIEInfoArray hash_data_array;
3681             if (m_apple_names_ap->AppendAllDIEsInRange(
3682                     dwarf_cu->GetOffset(), dwarf_cu->GetNextCompileUnitOffset(),
3683                     hash_data_array)) {
3684               DWARFMappedHash::ExtractDIEArray(hash_data_array, die_offsets);
3685             }
3686           }
3687         } else {
3688           // Index if we already haven't to make sure the compile units
3689           // get indexed and make their global DIE index list
3690           if (!m_indexed)
3691             Index();
3692
3693           m_global_index.FindAllEntriesForCompileUnit(dwarf_cu->GetOffset(),
3694                                                       die_offsets);
3695         }
3696
3697         const size_t num_matches = die_offsets.size();
3698         if (num_matches) {
3699           for (size_t i = 0; i < num_matches; ++i) {
3700             const DIERef &die_ref = die_offsets[i];
3701             DWARFDIE die = GetDIE(die_ref);
3702             if (die) {
3703               VariableSP var_sp(
3704                   ParseVariableDIE(sc, die, LLDB_INVALID_ADDRESS));
3705               if (var_sp) {
3706                 variables->AddVariableIfUnique(var_sp);
3707                 ++vars_added;
3708               }
3709             } else {
3710               if (m_using_apple_tables) {
3711                 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
3712                     "the DWARF debug information has been modified "
3713                     "(.apple_names accelerator table had bad die 0x%8.8x)\n",
3714                     die_ref.die_offset);
3715               }
3716             }
3717           }
3718         }
3719       }
3720       return vars_added;
3721     }
3722   }
3723   return 0;
3724 }
3725
3726 VariableSP SymbolFileDWARF::ParseVariableDIE(const SymbolContext &sc,
3727                                              const DWARFDIE &die,
3728                                              const lldb::addr_t func_low_pc) {
3729   if (die.GetDWARF() != this)
3730     return die.GetDWARF()->ParseVariableDIE(sc, die, func_low_pc);
3731
3732   VariableSP var_sp;
3733   if (!die)
3734     return var_sp;
3735
3736   var_sp = GetDIEToVariable()[die.GetDIE()];
3737   if (var_sp)
3738     return var_sp; // Already been parsed!
3739
3740   const dw_tag_t tag = die.Tag();
3741   ModuleSP module = GetObjectFile()->GetModule();
3742
3743   if ((tag == DW_TAG_variable) || (tag == DW_TAG_constant) ||
3744       (tag == DW_TAG_formal_parameter && sc.function)) {
3745     DWARFAttributes attributes;
3746     const size_t num_attributes = die.GetAttributes(attributes);
3747     DWARFDIE spec_die;
3748     if (num_attributes > 0) {
3749       const char *name = NULL;
3750       const char *mangled = NULL;
3751       Declaration decl;
3752       uint32_t i;
3753       DWARFFormValue type_die_form;
3754       DWARFExpression location(die.GetCU());
3755       bool is_external = false;
3756       bool is_artificial = false;
3757       bool location_is_const_value_data = false;
3758       bool has_explicit_location = false;
3759       DWARFFormValue const_value;
3760       Variable::RangeList scope_ranges;
3761       // AccessType accessibility = eAccessNone;
3762
3763       for (i = 0; i < num_attributes; ++i) {
3764         dw_attr_t attr = attributes.AttributeAtIndex(i);
3765         DWARFFormValue form_value;
3766
3767         if (attributes.ExtractFormValueAtIndex(i, form_value)) {
3768           switch (attr) {
3769           case DW_AT_decl_file:
3770             decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(
3771                 form_value.Unsigned()));
3772             break;
3773           case DW_AT_decl_line:
3774             decl.SetLine(form_value.Unsigned());
3775             break;
3776           case DW_AT_decl_column:
3777             decl.SetColumn(form_value.Unsigned());
3778             break;
3779           case DW_AT_name:
3780             name = form_value.AsCString();
3781             break;
3782           case DW_AT_linkage_name:
3783           case DW_AT_MIPS_linkage_name:
3784             mangled = form_value.AsCString();
3785             break;
3786           case DW_AT_type:
3787             type_die_form = form_value;
3788             break;
3789           case DW_AT_external:
3790             is_external = form_value.Boolean();
3791             break;
3792           case DW_AT_const_value:
3793             // If we have already found a DW_AT_location attribute, ignore this
3794             // attribute.
3795             if (!has_explicit_location) {
3796               location_is_const_value_data = true;
3797               // The constant value will be either a block, a data value or a
3798               // string.
3799               const DWARFDataExtractor &debug_info_data = get_debug_info_data();
3800               if (DWARFFormValue::IsBlockForm(form_value.Form())) {
3801                 // Retrieve the value as a block expression.
3802                 uint32_t block_offset =
3803                     form_value.BlockData() - debug_info_data.GetDataStart();
3804                 uint32_t block_length = form_value.Unsigned();
3805                 location.CopyOpcodeData(module, debug_info_data, block_offset,
3806                                         block_length);
3807               } else if (DWARFFormValue::IsDataForm(form_value.Form())) {
3808                 // Retrieve the value as a data expression.
3809                 DWARFFormValue::FixedFormSizes fixed_form_sizes =
3810                     DWARFFormValue::GetFixedFormSizesForAddressSize(
3811                         attributes.CompileUnitAtIndex(i)->GetAddressByteSize(),
3812                         attributes.CompileUnitAtIndex(i)->IsDWARF64());
3813                 uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
3814                 uint32_t data_length =
3815                     fixed_form_sizes.GetSize(form_value.Form());
3816                 if (data_length == 0) {
3817                   const uint8_t *data_pointer = form_value.BlockData();
3818                   if (data_pointer) {
3819                     form_value.Unsigned();
3820                   } else if (DWARFFormValue::IsDataForm(form_value.Form())) {
3821                     // we need to get the byte size of the type later after we
3822                     // create the variable
3823                     const_value = form_value;
3824                   }
3825                 } else
3826                   location.CopyOpcodeData(module, debug_info_data, data_offset,
3827                                           data_length);
3828               } else {
3829                 // Retrieve the value as a string expression.
3830                 if (form_value.Form() == DW_FORM_strp) {
3831                   DWARFFormValue::FixedFormSizes fixed_form_sizes =
3832                       DWARFFormValue::GetFixedFormSizesForAddressSize(
3833                           attributes.CompileUnitAtIndex(i)
3834                               ->GetAddressByteSize(),
3835                           attributes.CompileUnitAtIndex(i)->IsDWARF64());
3836                   uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
3837                   uint32_t data_length =
3838                       fixed_form_sizes.GetSize(form_value.Form());
3839                   location.CopyOpcodeData(module, debug_info_data, data_offset,
3840                                           data_length);
3841                 } else {
3842                   const char *str = form_value.AsCString();
3843                   uint32_t string_offset =
3844                       str - (const char *)debug_info_data.GetDataStart();
3845                   uint32_t string_length = strlen(str) + 1;
3846                   location.CopyOpcodeData(module, debug_info_data,
3847                                           string_offset, string_length);
3848                 }
3849               }
3850             }
3851             break;
3852           case DW_AT_location: {
3853             location_is_const_value_data = false;
3854             has_explicit_location = true;
3855             if (DWARFFormValue::IsBlockForm(form_value.Form())) {
3856               const DWARFDataExtractor &debug_info_data = get_debug_info_data();
3857
3858               uint32_t block_offset =
3859                   form_value.BlockData() - debug_info_data.GetDataStart();
3860               uint32_t block_length = form_value.Unsigned();
3861               location.CopyOpcodeData(module, get_debug_info_data(),
3862                                       block_offset, block_length);
3863             } else {
3864               const DWARFDataExtractor &debug_loc_data = get_debug_loc_data();
3865               const dw_offset_t debug_loc_offset = form_value.Unsigned();
3866
3867               size_t loc_list_length = DWARFExpression::LocationListSize(
3868                   die.GetCU(), debug_loc_data, debug_loc_offset);
3869               if (loc_list_length > 0) {
3870                 location.CopyOpcodeData(module, debug_loc_data,
3871                                         debug_loc_offset, loc_list_length);
3872                 assert(func_low_pc != LLDB_INVALID_ADDRESS);
3873                 location.SetLocationListSlide(
3874                     func_low_pc -
3875                     attributes.CompileUnitAtIndex(i)->GetBaseAddress());
3876               }
3877             }
3878           } break;
3879           case DW_AT_specification:
3880             spec_die = GetDIE(DIERef(form_value));
3881             break;
3882           case DW_AT_start_scope: {
3883             if (form_value.Form() == DW_FORM_sec_offset) {
3884               DWARFRangeList dwarf_scope_ranges;
3885               const DWARFDebugRanges *debug_ranges = DebugRanges();
3886               debug_ranges->FindRanges(die.GetCU()->GetRangesBase(),
3887                                        form_value.Unsigned(),
3888                                        dwarf_scope_ranges);
3889
3890               // All DW_AT_start_scope are relative to the base address of the
3891               // compile unit. We add the compile unit base address to make
3892               // sure all the addresses are properly fixed up.
3893               for (size_t i = 0, count = dwarf_scope_ranges.GetSize();
3894                    i < count; ++i) {
3895                 const DWARFRangeList::Entry &range =
3896                     dwarf_scope_ranges.GetEntryRef(i);
3897                 scope_ranges.Append(range.GetRangeBase() +
3898                                         die.GetCU()->GetBaseAddress(),
3899                                     range.GetByteSize());
3900               }
3901             } else {
3902               // TODO: Handle the case when DW_AT_start_scope have form
3903               // constant. The
3904               // dwarf spec is a bit ambiguous about what is the expected
3905               // behavior in
3906               // case the enclosing block have a non coninious address range and
3907               // the
3908               // DW_AT_start_scope entry have a form constant.
3909               GetObjectFile()->GetModule()->ReportWarning(
3910                   "0x%8.8" PRIx64
3911                   ": DW_AT_start_scope has unsupported form type (0x%x)\n",
3912                   die.GetID(), form_value.Form());
3913             }
3914
3915             scope_ranges.Sort();
3916             scope_ranges.CombineConsecutiveRanges();
3917           } break;
3918           case DW_AT_artificial:
3919             is_artificial = form_value.Boolean();
3920             break;
3921           case DW_AT_accessibility:
3922             break; // accessibility =
3923                    // DW_ACCESS_to_AccessType(form_value.Unsigned()); break;
3924           case DW_AT_declaration:
3925           case DW_AT_description:
3926           case DW_AT_endianity:
3927           case DW_AT_segment:
3928           case DW_AT_visibility:
3929           default:
3930           case DW_AT_abstract_origin:
3931           case DW_AT_sibling:
3932             break;
3933           }
3934         }
3935       }
3936
3937       const DWARFDIE parent_context_die = GetDeclContextDIEContainingDIE(die);
3938       const dw_tag_t parent_tag = die.GetParent().Tag();
3939       bool is_static_member =
3940           parent_tag == DW_TAG_compile_unit &&
3941           (parent_context_die.Tag() == DW_TAG_class_type ||
3942            parent_context_die.Tag() == DW_TAG_structure_type);
3943
3944       ValueType scope = eValueTypeInvalid;
3945
3946       const DWARFDIE sc_parent_die = GetParentSymbolContextDIE(die);
3947       SymbolContextScope *symbol_context_scope = NULL;
3948
3949       bool has_explicit_mangled = mangled != nullptr;
3950       if (!mangled) {
3951         // LLDB relies on the mangled name (DW_TAG_linkage_name or
3952         // DW_AT_MIPS_linkage_name) to
3953         // generate fully qualified names of global variables with commands like
3954         // "frame var j".
3955         // For example, if j were an int variable holding a value 4 and declared
3956         // in a namespace
3957         // B which in turn is contained in a namespace A, the command "frame var
3958         // j" returns
3959         // "(int) A::B::j = 4". If the compiler does not emit a linkage name, we
3960         // should be able
3961         // to generate a fully qualified name from the declaration context.
3962         if (parent_tag == DW_TAG_compile_unit &&
3963             Language::LanguageIsCPlusPlus(die.GetLanguage())) {
3964           DWARFDeclContext decl_ctx;
3965
3966           die.GetDWARFDeclContext(decl_ctx);
3967           mangled = decl_ctx.GetQualifiedNameAsConstString().GetCString();
3968         }
3969       }
3970
3971       if (tag == DW_TAG_formal_parameter)
3972         scope = eValueTypeVariableArgument;
3973       else {
3974         // DWARF doesn't specify if a DW_TAG_variable is a local, global
3975         // or static variable, so we have to do a little digging:
3976         // 1) DW_AT_linkage_name implies static lifetime (but may be missing)
3977         // 2) An empty DW_AT_location is an (optimized-out) static lifetime var.
3978         // 3) DW_AT_location containing a DW_OP_addr implies static lifetime.
3979         // Clang likes to combine small global variables into the same symbol
3980         // with locations like: DW_OP_addr(0x1000), DW_OP_constu(2), DW_OP_plus
3981         // so we need to look through the whole expression.
3982         bool is_static_lifetime =
3983             has_explicit_mangled ||
3984             (has_explicit_location && !location.IsValid());
3985         // Check if the location has a DW_OP_addr with any address value...
3986         lldb::addr_t location_DW_OP_addr = LLDB_INVALID_ADDRESS;
3987         if (!location_is_const_value_data) {
3988           bool op_error = false;
3989           location_DW_OP_addr = location.GetLocation_DW_OP_addr(0, op_error);
3990           if (op_error) {
3991             StreamString strm;
3992             location.DumpLocationForAddress(&strm, eDescriptionLevelFull, 0, 0,
3993                                             NULL);
3994             GetObjectFile()->GetModule()->ReportError(
3995                 "0x%8.8x: %s has an invalid location: %s", die.GetOffset(),
3996                 die.GetTagAsCString(), strm.GetData());
3997           }
3998           if (location_DW_OP_addr != LLDB_INVALID_ADDRESS)
3999             is_static_lifetime = true;
4000         }
4001         SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
4002
4003         if (is_static_lifetime) {
4004           if (is_external)
4005             scope = eValueTypeVariableGlobal;
4006           else
4007             scope = eValueTypeVariableStatic;
4008
4009           if (debug_map_symfile) {
4010             // When leaving the DWARF in the .o files on darwin,
4011             // when we have a global variable that wasn't initialized,
4012             // the .o file might not have allocated a virtual
4013             // address for the global variable. In this case it will
4014             // have created a symbol for the global variable
4015             // that is undefined/data and external and the value will
4016             // be the byte size of the variable. When we do the
4017             // address map in SymbolFileDWARFDebugMap we rely on
4018             // having an address, we need to do some magic here
4019             // so we can get the correct address for our global
4020             // variable. The address for all of these entries
4021             // will be zero, and there will be an undefined symbol
4022             // in this object file, and the executable will have
4023             // a matching symbol with a good address. So here we
4024             // dig up the correct address and replace it in the
4025             // location for the variable, and set the variable's
4026             // symbol context scope to be that of the main executable
4027             // so the file address will resolve correctly.
4028             bool linked_oso_file_addr = false;
4029             if (is_external && location_DW_OP_addr == 0) {
4030               // we have a possible uninitialized extern global
4031               ConstString const_name(mangled ? mangled : name);
4032               ObjectFile *debug_map_objfile =
4033                   debug_map_symfile->GetObjectFile();
4034               if (debug_map_objfile) {
4035                 Symtab *debug_map_symtab = debug_map_objfile->GetSymtab();
4036                 if (debug_map_symtab) {
4037                   Symbol *exe_symbol =
4038                       debug_map_symtab->FindFirstSymbolWithNameAndType(
4039                           const_name, eSymbolTypeData, Symtab::eDebugYes,
4040                           Symtab::eVisibilityExtern);
4041                   if (exe_symbol) {
4042                     if (exe_symbol->ValueIsAddress()) {
4043                       const addr_t exe_file_addr =
4044                           exe_symbol->GetAddressRef().GetFileAddress();
4045                       if (exe_file_addr != LLDB_INVALID_ADDRESS) {
4046                         if (location.Update_DW_OP_addr(exe_file_addr)) {
4047                           linked_oso_file_addr = true;
4048                           symbol_context_scope = exe_symbol;
4049                         }
4050                       }
4051                     }
4052                   }
4053                 }
4054               }
4055             }
4056
4057             if (!linked_oso_file_addr) {
4058               // The DW_OP_addr is not zero, but it contains a .o file address
4059               // which
4060               // needs to be linked up correctly.
4061               const lldb::addr_t exe_file_addr =
4062                   debug_map_symfile->LinkOSOFileAddress(this,
4063                                                         location_DW_OP_addr);
4064               if (exe_file_addr != LLDB_INVALID_ADDRESS) {
4065                 // Update the file address for this variable
4066                 location.Update_DW_OP_addr(exe_file_addr);
4067               } else {
4068                 // Variable didn't make it into the final executable
4069                 return var_sp;
4070               }
4071             }
4072           }
4073         } else {
4074           if (location_is_const_value_data)
4075             scope = eValueTypeVariableStatic;
4076           else {
4077             scope = eValueTypeVariableLocal;
4078             if (debug_map_symfile) {
4079               // We need to check for TLS addresses that we need to fixup
4080               if (location.ContainsThreadLocalStorage()) {
4081                 location.LinkThreadLocalStorage(
4082                     debug_map_symfile->GetObjectFile()->GetModule(),
4083                     [this, debug_map_symfile](
4084                         lldb::addr_t unlinked_file_addr) -> lldb::addr_t {
4085                       return debug_map_symfile->LinkOSOFileAddress(
4086                           this, unlinked_file_addr);
4087                     });
4088                 scope = eValueTypeVariableThreadLocal;
4089               }
4090             }
4091           }
4092         }
4093       }
4094
4095       if (symbol_context_scope == NULL) {
4096         switch (parent_tag) {
4097         case DW_TAG_subprogram:
4098         case DW_TAG_inlined_subroutine:
4099         case DW_TAG_lexical_block:
4100           if (sc.function) {
4101             symbol_context_scope = sc.function->GetBlock(true).FindBlockByID(
4102                 sc_parent_die.GetID());
4103             if (symbol_context_scope == NULL)
4104               symbol_context_scope = sc.function;
4105           }
4106           break;
4107
4108         default:
4109           symbol_context_scope = sc.comp_unit;
4110           break;
4111         }
4112       }
4113
4114       if (symbol_context_scope) {
4115         SymbolFileTypeSP type_sp(
4116             new SymbolFileType(*this, DIERef(type_die_form).GetUID(this)));
4117
4118         if (const_value.Form() && type_sp && type_sp->GetType())
4119           location.CopyOpcodeData(const_value.Unsigned(),
4120                                   type_sp->GetType()->GetByteSize(),
4121                                   die.GetCU()->GetAddressByteSize());
4122
4123         var_sp.reset(new Variable(die.GetID(), name, mangled, type_sp, scope,
4124                                   symbol_context_scope, scope_ranges, &decl,
4125                                   location, is_external, is_artificial,
4126                                   is_static_member));
4127
4128         var_sp->SetLocationIsConstantValueData(location_is_const_value_data);
4129       } else {
4130         // Not ready to parse this variable yet. It might be a global
4131         // or static variable that is in a function scope and the function
4132         // in the symbol context wasn't filled in yet
4133         return var_sp;
4134       }
4135     }
4136     // Cache var_sp even if NULL (the variable was just a specification or
4137     // was missing vital information to be able to be displayed in the debugger
4138     // (missing location due to optimization, etc)) so we don't re-parse
4139     // this DIE over and over later...
4140     GetDIEToVariable()[die.GetDIE()] = var_sp;
4141     if (spec_die)
4142       GetDIEToVariable()[spec_die.GetDIE()] = var_sp;
4143   }
4144   return var_sp;
4145 }
4146
4147 DWARFDIE
4148 SymbolFileDWARF::FindBlockContainingSpecification(
4149     const DIERef &func_die_ref, dw_offset_t spec_block_die_offset) {
4150   // Give the concrete function die specified by "func_die_offset", find the
4151   // concrete block whose DW_AT_specification or DW_AT_abstract_origin points
4152   // to "spec_block_die_offset"
4153   return FindBlockContainingSpecification(DebugInfo()->GetDIE(func_die_ref),
4154                                           spec_block_die_offset);
4155 }
4156
4157 DWARFDIE
4158 SymbolFileDWARF::FindBlockContainingSpecification(
4159     const DWARFDIE &die, dw_offset_t spec_block_die_offset) {
4160   if (die) {
4161     switch (die.Tag()) {
4162     case DW_TAG_subprogram:
4163     case DW_TAG_inlined_subroutine:
4164     case DW_TAG_lexical_block: {
4165       if (die.GetAttributeValueAsReference(
4166               DW_AT_specification, DW_INVALID_OFFSET) == spec_block_die_offset)
4167         return die;
4168
4169       if (die.GetAttributeValueAsReference(DW_AT_abstract_origin,
4170                                            DW_INVALID_OFFSET) ==
4171           spec_block_die_offset)
4172         return die;
4173     } break;
4174     }
4175
4176     // Give the concrete function die specified by "func_die_offset", find the
4177     // concrete block whose DW_AT_specification or DW_AT_abstract_origin points
4178     // to "spec_block_die_offset"
4179     for (DWARFDIE child_die = die.GetFirstChild(); child_die;
4180          child_die = child_die.GetSibling()) {
4181       DWARFDIE result_die =
4182           FindBlockContainingSpecification(child_die, spec_block_die_offset);
4183       if (result_die)
4184         return result_die;
4185     }
4186   }
4187
4188   return DWARFDIE();
4189 }
4190
4191 size_t SymbolFileDWARF::ParseVariables(const SymbolContext &sc,
4192                                        const DWARFDIE &orig_die,
4193                                        const lldb::addr_t func_low_pc,
4194                                        bool parse_siblings, bool parse_children,
4195                                        VariableList *cc_variable_list) {
4196   if (!orig_die)
4197     return 0;
4198
4199   VariableListSP variable_list_sp;
4200
4201   size_t vars_added = 0;
4202   DWARFDIE die = orig_die;
4203   while (die) {
4204     dw_tag_t tag = die.Tag();
4205
4206     // Check to see if we have already parsed this variable or constant?
4207     VariableSP var_sp = GetDIEToVariable()[die.GetDIE()];
4208     if (var_sp) {
4209       if (cc_variable_list)
4210         cc_variable_list->AddVariableIfUnique(var_sp);
4211     } else {
4212       // We haven't already parsed it, lets do that now.
4213       if ((tag == DW_TAG_variable) || (tag == DW_TAG_constant) ||
4214           (tag == DW_TAG_formal_parameter && sc.function)) {
4215         if (variable_list_sp.get() == NULL) {
4216           DWARFDIE sc_parent_die = GetParentSymbolContextDIE(orig_die);
4217           dw_tag_t parent_tag = sc_parent_die.Tag();
4218           switch (parent_tag) {
4219           case DW_TAG_compile_unit:
4220             if (sc.comp_unit != NULL) {
4221               variable_list_sp = sc.comp_unit->GetVariableList(false);
4222               if (variable_list_sp.get() == NULL) {
4223                 variable_list_sp.reset(new VariableList());
4224                 sc.comp_unit->SetVariableList(variable_list_sp);
4225               }
4226             } else {
4227               GetObjectFile()->GetModule()->ReportError(
4228                   "parent 0x%8.8" PRIx64 " %s with no valid compile unit in "
4229                                          "symbol context for 0x%8.8" PRIx64
4230                   " %s.\n",
4231                   sc_parent_die.GetID(), sc_parent_die.GetTagAsCString(),
4232                   orig_die.GetID(), orig_die.GetTagAsCString());
4233             }
4234             break;
4235
4236           case DW_TAG_subprogram:
4237           case DW_TAG_inlined_subroutine:
4238           case DW_TAG_lexical_block:
4239             if (sc.function != NULL) {
4240               // Check to see if we already have parsed the variables for the
4241               // given scope
4242
4243               Block *block = sc.function->GetBlock(true).FindBlockByID(
4244                   sc_parent_die.GetID());
4245               if (block == NULL) {
4246                 // This must be a specification or abstract origin with
4247                 // a concrete block counterpart in the current function. We need
4248                 // to find the concrete block so we can correctly add the
4249                 // variable to it
4250                 const DWARFDIE concrete_block_die =
4251                     FindBlockContainingSpecification(
4252                         DIERef(sc.function->GetID(), this),
4253                         sc_parent_die.GetOffset());
4254                 if (concrete_block_die)
4255                   block = sc.function->GetBlock(true).FindBlockByID(
4256                       concrete_block_die.GetID());
4257               }
4258
4259               if (block != NULL) {
4260                 const bool can_create = false;
4261                 variable_list_sp = block->GetBlockVariableList(can_create);
4262                 if (variable_list_sp.get() == NULL) {
4263                   variable_list_sp.reset(new VariableList());
4264                   block->SetVariableList(variable_list_sp);
4265                 }
4266               }
4267             }
4268             break;
4269
4270           default:
4271             GetObjectFile()->GetModule()->ReportError(
4272                 "didn't find appropriate parent DIE for variable list for "
4273                 "0x%8.8" PRIx64 " %s.\n",
4274                 orig_die.GetID(), orig_die.GetTagAsCString());
4275             break;
4276           }
4277         }
4278
4279         if (variable_list_sp) {
4280           VariableSP var_sp(ParseVariableDIE(sc, die, func_low_pc));
4281           if (var_sp) {
4282             variable_list_sp->AddVariableIfUnique(var_sp);
4283             if (cc_variable_list)
4284               cc_variable_list->AddVariableIfUnique(var_sp);
4285             ++vars_added;
4286           }
4287         }
4288       }
4289     }
4290
4291     bool skip_children = (sc.function == NULL && tag == DW_TAG_subprogram);
4292
4293     if (!skip_children && parse_children && die.HasChildren()) {
4294       vars_added += ParseVariables(sc, die.GetFirstChild(), func_low_pc, true,
4295                                    true, cc_variable_list);
4296     }
4297
4298     if (parse_siblings)
4299       die = die.GetSibling();
4300     else
4301       die.Clear();
4302   }
4303   return vars_added;
4304 }
4305
4306 //------------------------------------------------------------------
4307 // PluginInterface protocol
4308 //------------------------------------------------------------------
4309 ConstString SymbolFileDWARF::GetPluginName() { return GetPluginNameStatic(); }
4310
4311 uint32_t SymbolFileDWARF::GetPluginVersion() { return 1; }
4312
4313 void SymbolFileDWARF::DumpIndexes() {
4314   StreamFile s(stdout, false);
4315
4316   s.Printf(
4317       "DWARF index for (%s) '%s':",
4318       GetObjectFile()->GetModule()->GetArchitecture().GetArchitectureName(),
4319       GetObjectFile()->GetFileSpec().GetPath().c_str());
4320   s.Printf("\nFunction basenames:\n");
4321   m_function_basename_index.Dump(&s);
4322   s.Printf("\nFunction fullnames:\n");
4323   m_function_fullname_index.Dump(&s);
4324   s.Printf("\nFunction methods:\n");
4325   m_function_method_index.Dump(&s);
4326   s.Printf("\nFunction selectors:\n");
4327   m_function_selector_index.Dump(&s);
4328   s.Printf("\nObjective C class selectors:\n");
4329   m_objc_class_selectors_index.Dump(&s);
4330   s.Printf("\nGlobals and statics:\n");
4331   m_global_index.Dump(&s);
4332   s.Printf("\nTypes:\n");
4333   m_type_index.Dump(&s);
4334   s.Printf("\nNamespaces:\n");
4335   m_namespace_index.Dump(&s);
4336 }
4337
4338 SymbolFileDWARFDebugMap *SymbolFileDWARF::GetDebugMapSymfile() {
4339   if (m_debug_map_symfile == NULL && !m_debug_map_module_wp.expired()) {
4340     lldb::ModuleSP module_sp(m_debug_map_module_wp.lock());
4341     if (module_sp) {
4342       SymbolVendor *sym_vendor = module_sp->GetSymbolVendor();
4343       if (sym_vendor)
4344         m_debug_map_symfile =
4345             (SymbolFileDWARFDebugMap *)sym_vendor->GetSymbolFile();
4346     }
4347   }
4348   return m_debug_map_symfile;
4349 }
4350
4351 DWARFExpression::LocationListFormat
4352 SymbolFileDWARF::GetLocationListFormat() const {
4353   return DWARFExpression::RegularLocationList;
4354 }
4355
4356 SymbolFileDWARFDwp *SymbolFileDWARF::GetDwpSymbolFile() {
4357   llvm::call_once(m_dwp_symfile_once_flag, [this]() {
4358     ModuleSpec module_spec;
4359     module_spec.GetFileSpec() = m_obj_file->GetFileSpec();
4360     module_spec.GetSymbolFileSpec() =
4361         FileSpec(m_obj_file->GetFileSpec().GetPath() + ".dwp", false);
4362     FileSpec dwp_filespec = Symbols::LocateExecutableSymbolFile(module_spec);
4363     if (dwp_filespec.Exists()) {
4364       m_dwp_symfile = SymbolFileDWARFDwp::Create(GetObjectFile()->GetModule(),
4365                                                  dwp_filespec);
4366     }
4367   });
4368   return m_dwp_symfile.get();
4369 }