1 //===-- SymbolFileDWARF.cpp ------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "SymbolFileDWARF.h"
12 // Other libraries and framework includes
13 #include "llvm/Support/Casting.h"
15 #include "lldb/Core/ArchSpec.h"
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/RegularExpression.h"
21 #include "lldb/Core/Scalar.h"
22 #include "lldb/Core/Section.h"
23 #include "lldb/Core/StreamFile.h"
24 #include "lldb/Core/StreamString.h"
25 #include "lldb/Core/Timer.h"
26 #include "lldb/Core/Value.h"
28 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
30 #include "lldb/Host/FileSystem.h"
31 #include "lldb/Host/Host.h"
33 #include "lldb/Interpreter/OptionValueFileSpecList.h"
34 #include "lldb/Interpreter/OptionValueProperties.h"
36 #include "lldb/Symbol/Block.h"
37 #include "lldb/Symbol/ClangASTContext.h"
38 #include "lldb/Symbol/ClangUtil.h"
39 #include "lldb/Symbol/CompileUnit.h"
40 #include "lldb/Symbol/CompilerDecl.h"
41 #include "lldb/Symbol/CompilerDeclContext.h"
42 #include "lldb/Symbol/DebugMacros.h"
43 #include "lldb/Symbol/LineTable.h"
44 #include "lldb/Symbol/ObjectFile.h"
45 #include "lldb/Symbol/SymbolVendor.h"
46 #include "lldb/Symbol/TypeMap.h"
47 #include "lldb/Symbol/TypeSystem.h"
48 #include "lldb/Symbol/VariableList.h"
50 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
51 #include "Plugins/Language/ObjC/ObjCLanguage.h"
53 #include "lldb/Target/Language.h"
55 #include "lldb/Utility/TaskPool.h"
57 #include "DWARFASTParser.h"
58 #include "DWARFASTParserClang.h"
59 #include "DWARFCompileUnit.h"
60 #include "DWARFDIECollection.h"
61 #include "DWARFDebugAbbrev.h"
62 #include "DWARFDebugAranges.h"
63 #include "DWARFDebugInfo.h"
64 #include "DWARFDebugLine.h"
65 #include "DWARFDebugMacro.h"
66 #include "DWARFDebugPubnames.h"
67 #include "DWARFDebugRanges.h"
68 #include "DWARFDeclContext.h"
69 #include "DWARFFormValue.h"
70 #include "LogChannelDWARF.h"
71 #include "SymbolFileDWARFDebugMap.h"
72 #include "SymbolFileDWARFDwo.h"
79 //#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN
81 #ifdef ENABLE_DEBUG_PRINTF
83 #define DEBUG_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__)
85 #define DEBUG_PRINTF(fmt, ...)
89 using namespace lldb_private;
92 //child_requires_parent_class_union_or_struct_to_be_completed (dw_tag_t tag)
98 // case DW_TAG_subprogram:
99 // case DW_TAG_inlined_subroutine:
100 // case DW_TAG_class_type:
101 // case DW_TAG_structure_type:
102 // case DW_TAG_union_type:
114 { "comp-dir-symlink-paths" , OptionValue::eTypeFileSpecList, true, 0 , nullptr, nullptr, "If the DW_AT_comp_dir matches any of these paths the symbolic links will be resolved at DWARF parse time." },
115 { nullptr , OptionValue::eTypeInvalid , false, 0, nullptr, nullptr, nullptr }
120 ePropertySymLinkPaths
124 class PluginProperties : public Properties
130 return SymbolFileDWARF::GetPluginNameStatic();
135 m_collection_sp.reset (new OptionValueProperties(GetSettingName()));
136 m_collection_sp->Initialize(g_properties);
142 OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr, true, ePropertySymLinkPaths);
143 assert(option_value);
144 return option_value->GetCurrentValue();
149 typedef std::shared_ptr<PluginProperties> SymbolFileDWARFPropertiesSP;
151 static const SymbolFileDWARFPropertiesSP&
152 GetGlobalPluginProperties()
154 static const auto g_settings_sp(std::make_shared<PluginProperties>());
155 return g_settings_sp;
158 } // anonymous namespace end
162 removeHostnameFromPathname(const char* path_from_dwarf)
164 if (!path_from_dwarf || !path_from_dwarf[0])
166 return path_from_dwarf;
169 const char *colon_pos = strchr(path_from_dwarf, ':');
170 if (nullptr == colon_pos)
172 return path_from_dwarf;
175 const char *slash_pos = strchr(path_from_dwarf, '/');
176 if (slash_pos && (slash_pos < colon_pos))
178 return path_from_dwarf;
181 // check whether we have a windows path, and so the first character
182 // is a drive-letter not a hostname.
184 colon_pos == path_from_dwarf + 1 &&
185 isalpha(*path_from_dwarf) &&
186 strlen(path_from_dwarf) > 2 &&
187 '\\' == path_from_dwarf[2])
189 return path_from_dwarf;
192 return colon_pos + 1;
196 resolveCompDir(const char* path_from_dwarf)
198 if (!path_from_dwarf)
201 // DWARF2/3 suggests the form hostname:pathname for compilation directory.
202 // Remove the host part if present.
203 const char* local_path = removeHostnameFromPathname(path_from_dwarf);
207 bool is_symlink = false;
208 FileSpec local_path_spec(local_path, false);
209 const auto& file_specs = GetGlobalPluginProperties()->GetSymLinkPaths();
210 for (size_t i = 0; i < file_specs.GetSize() && !is_symlink; ++i)
211 is_symlink = FileSpec::Equal(file_specs.GetFileSpecAtIndex(i), local_path_spec, true);
216 if (!local_path_spec.IsSymbolicLink())
219 FileSpec resolved_local_path_spec;
220 const auto error = FileSystem::Readlink(local_path_spec, resolved_local_path_spec);
222 return resolved_local_path_spec.GetCString();
229 SymbolFileDWARF::Initialize()
231 LogChannelDWARF::Initialize();
232 PluginManager::RegisterPlugin (GetPluginNameStatic(),
233 GetPluginDescriptionStatic(),
239 SymbolFileDWARF::DebuggerInitialize(Debugger &debugger)
241 if (!PluginManager::GetSettingForSymbolFilePlugin(debugger, PluginProperties::GetSettingName()))
243 const bool is_global_setting = true;
244 PluginManager::CreateSettingForSymbolFilePlugin(debugger,
245 GetGlobalPluginProperties()->GetValueProperties(),
246 ConstString ("Properties for the dwarf symbol-file plug-in."),
252 SymbolFileDWARF::Terminate()
254 PluginManager::UnregisterPlugin (CreateInstance);
255 LogChannelDWARF::Initialize();
259 lldb_private::ConstString
260 SymbolFileDWARF::GetPluginNameStatic()
262 static ConstString g_name("dwarf");
267 SymbolFileDWARF::GetPluginDescriptionStatic()
269 return "DWARF and DWARF3 debug symbol file reader.";
274 SymbolFileDWARF::CreateInstance (ObjectFile* obj_file)
276 return new SymbolFileDWARF(obj_file);
280 SymbolFileDWARF::GetTypeList ()
282 SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
283 if (debug_map_symfile)
284 return debug_map_symfile->GetTypeList();
286 return m_obj_file->GetModule()->GetTypeList();
290 SymbolFileDWARF::GetTypes (const DWARFDIE &die,
291 dw_offset_t min_die_offset,
292 dw_offset_t max_die_offset,
298 const dw_offset_t die_offset = die.GetOffset();
300 if (die_offset >= max_die_offset)
303 if (die_offset >= min_die_offset)
305 const dw_tag_t tag = die.Tag();
307 bool add_type = false;
311 case DW_TAG_array_type: add_type = (type_mask & eTypeClassArray ) != 0; break;
312 case DW_TAG_unspecified_type:
313 case DW_TAG_base_type: add_type = (type_mask & eTypeClassBuiltin ) != 0; break;
314 case DW_TAG_class_type: add_type = (type_mask & eTypeClassClass ) != 0; break;
315 case DW_TAG_structure_type: add_type = (type_mask & eTypeClassStruct ) != 0; break;
316 case DW_TAG_union_type: add_type = (type_mask & eTypeClassUnion ) != 0; break;
317 case DW_TAG_enumeration_type: add_type = (type_mask & eTypeClassEnumeration ) != 0; break;
318 case DW_TAG_subroutine_type:
319 case DW_TAG_subprogram:
320 case DW_TAG_inlined_subroutine: add_type = (type_mask & eTypeClassFunction ) != 0; break;
321 case DW_TAG_pointer_type: add_type = (type_mask & eTypeClassPointer ) != 0; break;
322 case DW_TAG_rvalue_reference_type:
323 case DW_TAG_reference_type: add_type = (type_mask & eTypeClassReference ) != 0; break;
324 case DW_TAG_typedef: add_type = (type_mask & eTypeClassTypedef ) != 0; break;
325 case DW_TAG_ptr_to_member_type: add_type = (type_mask & eTypeClassMemberPointer ) != 0; break;
330 const bool assert_not_being_parsed = true;
331 Type *type = ResolveTypeUID (die, assert_not_being_parsed);
334 if (type_set.find(type) == type_set.end())
335 type_set.insert(type);
340 for (DWARFDIE child_die = die.GetFirstChild();
342 child_die = child_die.GetSibling())
344 GetTypes (child_die, min_die_offset, max_die_offset, type_mask, type_set);
350 SymbolFileDWARF::GetTypes (SymbolContextScope *sc_scope,
357 CompileUnit *comp_unit = NULL;
358 DWARFCompileUnit* dwarf_cu = NULL;
360 comp_unit = sc_scope->CalculateSymbolContextCompileUnit();
364 dwarf_cu = GetDWARFCompileUnit(comp_unit);
367 GetTypes (dwarf_cu->DIE(),
368 dwarf_cu->GetOffset(),
369 dwarf_cu->GetNextCompileUnitOffset(),
375 DWARFDebugInfo* info = DebugInfo();
378 const size_t num_cus = info->GetNumCompileUnits();
379 for (size_t cu_idx=0; cu_idx<num_cus; ++cu_idx)
381 dwarf_cu = info->GetCompileUnitAtIndex(cu_idx);
384 GetTypes (dwarf_cu->DIE(),
394 std::set<CompilerType> compiler_type_set;
395 size_t num_types_added = 0;
396 for (Type *type : type_set)
398 CompilerType compiler_type = type->GetForwardCompilerType ();
399 if (compiler_type_set.find(compiler_type) == compiler_type_set.end())
401 compiler_type_set.insert(compiler_type);
402 type_list.Insert (type->shared_from_this());
406 return num_types_added;
410 //----------------------------------------------------------------------
411 // Gets the first parent that is a lexical block, function or inlined
412 // subroutine, or compile unit.
413 //----------------------------------------------------------------------
415 SymbolFileDWARF::GetParentSymbolContextDIE(const DWARFDIE &child_die)
418 for (die = child_die.GetParent(); die; die = die.GetParent())
420 dw_tag_t tag = die.Tag();
424 case DW_TAG_compile_unit:
425 case DW_TAG_subprogram:
426 case DW_TAG_inlined_subroutine:
427 case DW_TAG_lexical_block:
435 SymbolFileDWARF::SymbolFileDWARF(ObjectFile* objfile) :
436 SymbolFile (objfile),
437 UserID (0), // Used by SymbolFileDWARFDebugMap to when this class parses .o files to contain the .o file index/ID
438 m_debug_map_module_wp (),
439 m_debug_map_symfile (NULL),
440 m_data_debug_abbrev (),
441 m_data_debug_aranges (),
442 m_data_debug_frame (),
443 m_data_debug_info (),
444 m_data_debug_line (),
445 m_data_debug_macro (),
447 m_data_debug_ranges (),
449 m_data_apple_names (),
450 m_data_apple_types (),
451 m_data_apple_namespaces (),
457 m_apple_namespaces_ap (),
459 m_function_basename_index(),
460 m_function_fullname_index(),
461 m_function_method_index(),
462 m_function_selector_index(),
463 m_objc_class_selectors_index(),
468 m_using_apple_tables (false),
469 m_fetched_external_modules (false),
470 m_supports_DW_AT_APPLE_objc_complete_type (eLazyBoolCalculate),
472 m_unique_ast_type_map ()
476 SymbolFileDWARF::~SymbolFileDWARF()
480 static const ConstString &
481 GetDWARFMachOSegmentName ()
483 static ConstString g_dwarf_section_name ("__DWARF");
484 return g_dwarf_section_name;
487 UniqueDWARFASTTypeMap &
488 SymbolFileDWARF::GetUniqueDWARFASTTypeMap ()
490 SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
491 if (debug_map_symfile)
492 return debug_map_symfile->GetUniqueDWARFASTTypeMap ();
494 return m_unique_ast_type_map;
498 SymbolFileDWARF::GetTypeSystemForLanguage (LanguageType language)
500 SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
501 TypeSystem *type_system;
502 if (debug_map_symfile)
504 type_system = debug_map_symfile->GetTypeSystemForLanguage(language);
508 type_system = m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
510 type_system->SetSymbolFile(this);
516 SymbolFileDWARF::InitializeObject()
518 ModuleSP module_sp (m_obj_file->GetModule());
521 const SectionList *section_list = module_sp->GetSectionList();
522 const Section* section = section_list->FindSectionByName(GetDWARFMachOSegmentName ()).get();
524 // Memory map the DWARF mach-o segment so we have everything mmap'ed
525 // to keep our heap memory usage down.
527 m_obj_file->MemoryMapSectionData(section, m_dwarf_data);
530 get_apple_names_data();
531 if (m_data_apple_names.m_data.GetByteSize() > 0)
533 m_apple_names_ap.reset (new DWARFMappedHash::MemoryTable (m_data_apple_names.m_data,
534 get_debug_str_data(),
536 if (m_apple_names_ap->IsValid())
537 m_using_apple_tables = true;
539 m_apple_names_ap.reset();
541 get_apple_types_data();
542 if (m_data_apple_types.m_data.GetByteSize() > 0)
544 m_apple_types_ap.reset (new DWARFMappedHash::MemoryTable (m_data_apple_types.m_data,
545 get_debug_str_data(),
547 if (m_apple_types_ap->IsValid())
548 m_using_apple_tables = true;
550 m_apple_types_ap.reset();
553 get_apple_namespaces_data();
554 if (m_data_apple_namespaces.m_data.GetByteSize() > 0)
556 m_apple_namespaces_ap.reset (new DWARFMappedHash::MemoryTable (m_data_apple_namespaces.m_data,
557 get_debug_str_data(),
558 ".apple_namespaces"));
559 if (m_apple_namespaces_ap->IsValid())
560 m_using_apple_tables = true;
562 m_apple_namespaces_ap.reset();
565 get_apple_objc_data();
566 if (m_data_apple_objc.m_data.GetByteSize() > 0)
568 m_apple_objc_ap.reset (new DWARFMappedHash::MemoryTable (m_data_apple_objc.m_data,
569 get_debug_str_data(),
571 if (m_apple_objc_ap->IsValid())
572 m_using_apple_tables = true;
574 m_apple_objc_ap.reset();
579 SymbolFileDWARF::SupportedVersion(uint16_t version)
581 return version == 2 || version == 3 || version == 4;
585 SymbolFileDWARF::CalculateAbilities ()
587 uint32_t abilities = 0;
588 if (m_obj_file != NULL)
590 const Section* section = NULL;
591 const SectionList *section_list = m_obj_file->GetSectionList();
592 if (section_list == NULL)
595 uint64_t debug_abbrev_file_size = 0;
596 uint64_t debug_info_file_size = 0;
597 uint64_t debug_line_file_size = 0;
599 section = section_list->FindSectionByName(GetDWARFMachOSegmentName ()).get();
602 section_list = §ion->GetChildren ();
604 section = section_list->FindSectionByType (eSectionTypeDWARFDebugInfo, true).get();
607 debug_info_file_size = section->GetFileSize();
609 section = section_list->FindSectionByType (eSectionTypeDWARFDebugAbbrev, true).get();
611 debug_abbrev_file_size = section->GetFileSize();
613 section = section_list->FindSectionByType (eSectionTypeDWARFDebugLine, true).get();
615 debug_line_file_size = section->GetFileSize();
619 const char *symfile_dir_cstr = m_obj_file->GetFileSpec().GetDirectory().GetCString();
620 if (symfile_dir_cstr)
622 if (strcasestr(symfile_dir_cstr, ".dsym"))
624 if (m_obj_file->GetType() == ObjectFile::eTypeDebugInfo)
626 // We have a dSYM file that didn't have a any debug info.
627 // If the string table has a size of 1, then it was made from
628 // an executable with no debug info, or from an executable that
630 section = section_list->FindSectionByType (eSectionTypeDWARFDebugStr, true).get();
631 if (section && section->GetFileSize() == 1)
633 m_obj_file->GetModule()->ReportWarning ("empty dSYM file detected, dSYM was created with an executable with no debug info.");
640 if (debug_abbrev_file_size > 0 && debug_info_file_size > 0)
641 abilities |= CompileUnits | Functions | Blocks | GlobalVariables | LocalVariables | VariableTypes;
643 if (debug_line_file_size > 0)
644 abilities |= LineTables;
649 const DWARFDataExtractor&
650 SymbolFileDWARF::GetCachedSectionData (lldb::SectionType sect_type, DWARFDataSegment& data_segment)
652 std::call_once(data_segment.m_flag,
653 &SymbolFileDWARF::LoadSectionData,
656 std::ref(data_segment.m_data));
657 return data_segment.m_data;
661 SymbolFileDWARF::LoadSectionData (lldb::SectionType sect_type, DWARFDataExtractor& data)
663 ModuleSP module_sp (m_obj_file->GetModule());
664 const SectionList *section_list = module_sp->GetSectionList();
667 SectionSP section_sp (section_list->FindSectionByType(sect_type, true));
670 // See if we memory mapped the DWARF segment?
671 if (m_dwarf_data.GetByteSize())
673 data.SetData(m_dwarf_data, section_sp->GetOffset(), section_sp->GetFileSize());
677 if (m_obj_file->ReadSectionData(section_sp.get(), data) == 0)
684 const DWARFDataExtractor&
685 SymbolFileDWARF::get_debug_abbrev_data()
687 return GetCachedSectionData (eSectionTypeDWARFDebugAbbrev, m_data_debug_abbrev);
690 const DWARFDataExtractor&
691 SymbolFileDWARF::get_debug_addr_data()
693 return GetCachedSectionData (eSectionTypeDWARFDebugAddr, m_data_debug_addr);
696 const DWARFDataExtractor&
697 SymbolFileDWARF::get_debug_aranges_data()
699 return GetCachedSectionData (eSectionTypeDWARFDebugAranges, m_data_debug_aranges);
702 const DWARFDataExtractor&
703 SymbolFileDWARF::get_debug_frame_data()
705 return GetCachedSectionData (eSectionTypeDWARFDebugFrame, m_data_debug_frame);
708 const DWARFDataExtractor&
709 SymbolFileDWARF::get_debug_info_data()
711 return GetCachedSectionData (eSectionTypeDWARFDebugInfo, m_data_debug_info);
714 const DWARFDataExtractor&
715 SymbolFileDWARF::get_debug_line_data()
717 return GetCachedSectionData (eSectionTypeDWARFDebugLine, m_data_debug_line);
720 const DWARFDataExtractor&
721 SymbolFileDWARF::get_debug_macro_data()
723 return GetCachedSectionData (eSectionTypeDWARFDebugMacro, m_data_debug_macro);
726 const DWARFDataExtractor&
727 SymbolFileDWARF::get_debug_loc_data()
729 return GetCachedSectionData (eSectionTypeDWARFDebugLoc, m_data_debug_loc);
732 const DWARFDataExtractor&
733 SymbolFileDWARF::get_debug_ranges_data()
735 return GetCachedSectionData (eSectionTypeDWARFDebugRanges, m_data_debug_ranges);
738 const DWARFDataExtractor&
739 SymbolFileDWARF::get_debug_str_data()
741 return GetCachedSectionData (eSectionTypeDWARFDebugStr, m_data_debug_str);
744 const DWARFDataExtractor&
745 SymbolFileDWARF::get_debug_str_offsets_data()
747 return GetCachedSectionData (eSectionTypeDWARFDebugStrOffsets, m_data_debug_str_offsets);
750 const DWARFDataExtractor&
751 SymbolFileDWARF::get_apple_names_data()
753 return GetCachedSectionData (eSectionTypeDWARFAppleNames, m_data_apple_names);
756 const DWARFDataExtractor&
757 SymbolFileDWARF::get_apple_types_data()
759 return GetCachedSectionData (eSectionTypeDWARFAppleTypes, m_data_apple_types);
762 const DWARFDataExtractor&
763 SymbolFileDWARF::get_apple_namespaces_data()
765 return GetCachedSectionData (eSectionTypeDWARFAppleNamespaces, m_data_apple_namespaces);
768 const DWARFDataExtractor&
769 SymbolFileDWARF::get_apple_objc_data()
771 return GetCachedSectionData (eSectionTypeDWARFAppleObjC, m_data_apple_objc);
776 SymbolFileDWARF::DebugAbbrev()
778 if (m_abbr.get() == NULL)
780 const DWARFDataExtractor &debug_abbrev_data = get_debug_abbrev_data();
781 if (debug_abbrev_data.GetByteSize() > 0)
783 m_abbr.reset(new DWARFDebugAbbrev());
785 m_abbr->Parse(debug_abbrev_data);
791 const DWARFDebugAbbrev*
792 SymbolFileDWARF::DebugAbbrev() const
799 SymbolFileDWARF::DebugInfo()
801 if (m_info.get() == NULL)
803 Timer scoped_timer(__PRETTY_FUNCTION__, "%s this = %p",
804 __PRETTY_FUNCTION__, static_cast<void*>(this));
805 if (get_debug_info_data().GetByteSize() > 0)
807 m_info.reset(new DWARFDebugInfo());
810 m_info->SetDwarfData(this);
817 const DWARFDebugInfo*
818 SymbolFileDWARF::DebugInfo() const
824 SymbolFileDWARF::GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit)
829 DWARFDebugInfo* info = DebugInfo();
832 // Just a normal DWARF file whose user ID for the compile unit is
833 // the DWARF offset itself
835 DWARFCompileUnit *dwarf_cu = info->GetCompileUnit((dw_offset_t)comp_unit->GetID());
836 if (dwarf_cu && dwarf_cu->GetUserData() == NULL)
837 dwarf_cu->SetUserData(comp_unit);
845 SymbolFileDWARF::DebugRanges()
847 if (m_ranges.get() == NULL)
849 Timer scoped_timer(__PRETTY_FUNCTION__, "%s this = %p",
850 __PRETTY_FUNCTION__, static_cast<void*>(this));
851 if (get_debug_ranges_data().GetByteSize() > 0)
853 m_ranges.reset(new DWARFDebugRanges());
855 m_ranges->Extract(this);
858 return m_ranges.get();
861 const DWARFDebugRanges*
862 SymbolFileDWARF::DebugRanges() const
864 return m_ranges.get();
868 SymbolFileDWARF::ParseCompileUnit (DWARFCompileUnit* dwarf_cu, uint32_t cu_idx)
873 CompileUnit *comp_unit = (CompileUnit*)dwarf_cu->GetUserData();
876 // We already parsed this compile unit, had out a shared pointer to it
877 cu_sp = comp_unit->shared_from_this();
881 if (dwarf_cu->GetSymbolFileDWARF() != this)
883 return dwarf_cu->GetSymbolFileDWARF()->ParseCompileUnit(dwarf_cu, cu_idx);
885 else if (dwarf_cu->GetOffset() == 0 && GetDebugMapSymfile ())
887 // Let the debug map create the compile unit
888 cu_sp = m_debug_map_symfile->GetCompileUnit(this);
889 dwarf_cu->SetUserData(cu_sp.get());
893 ModuleSP module_sp (m_obj_file->GetModule());
896 const DWARFDIE cu_die = dwarf_cu->GetCompileUnitDIEOnly ();
899 FileSpec cu_file_spec{cu_die.GetName(), false};
902 // If we have a full path to the compile unit, we don't need to resolve
903 // the file. This can be expensive e.g. when the source files are NFS mounted.
904 if (cu_file_spec.IsRelative())
906 const char *cu_comp_dir{cu_die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr)};
907 cu_file_spec.PrependPathComponent(resolveCompDir(cu_comp_dir));
910 std::string remapped_file;
911 if (module_sp->RemapSourceFile(cu_file_spec.GetCString(), remapped_file))
912 cu_file_spec.SetFile(remapped_file, false);
915 LanguageType cu_language = DWARFCompileUnit::LanguageTypeFromDWARF(cu_die.GetAttributeValueAsUnsigned(DW_AT_language, 0));
917 bool is_optimized = dwarf_cu->GetIsOptimized ();
918 cu_sp.reset(new CompileUnit(module_sp, dwarf_cu, cu_file_spec, dwarf_cu->GetID(), cu_language,
919 is_optimized ? eLazyBoolYes : eLazyBoolNo));
922 // If we just created a compile unit with an invalid file spec, try and get the
923 // first entry in the supports files from the line table as that should be the
927 cu_file_spec = cu_sp->GetSupportFiles().GetFileSpecAtIndex(1);
930 (FileSpec &)(*cu_sp) = cu_file_spec;
931 // Also fix the invalid file spec which was copied from the compile unit.
932 cu_sp->GetSupportFiles().Replace(0, cu_file_spec);
936 dwarf_cu->SetUserData(cu_sp.get());
938 // Figure out the compile unit index if we weren't given one
939 if (cu_idx == UINT32_MAX)
940 DebugInfo()->GetCompileUnit(dwarf_cu->GetOffset(), &cu_idx);
942 m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(cu_idx, cu_sp);
953 SymbolFileDWARF::GetNumCompileUnits()
955 DWARFDebugInfo* info = DebugInfo();
957 return info->GetNumCompileUnits();
962 SymbolFileDWARF::ParseCompileUnitAtIndex(uint32_t cu_idx)
965 DWARFDebugInfo* info = DebugInfo();
968 DWARFCompileUnit* dwarf_cu = info->GetCompileUnitAtIndex(cu_idx);
970 cu_sp = ParseCompileUnit(dwarf_cu, cu_idx);
976 SymbolFileDWARF::ParseCompileUnitFunction (const SymbolContext& sc, const DWARFDIE &die)
980 TypeSystem *type_system = GetTypeSystemForLanguage(die.GetCU()->GetLanguageType());
984 DWARFASTParser *dwarf_ast = type_system->GetDWARFParser();
986 return dwarf_ast->ParseFunctionFromDWARF(sc, die);
993 SymbolFileDWARF::FixupAddress (Address &addr)
995 SymbolFileDWARFDebugMap * debug_map_symfile = GetDebugMapSymfile();
996 if (debug_map_symfile)
998 return debug_map_symfile->LinkOSOAddress(addr);
1000 // This is a normal DWARF file, no address fixups need to happen
1004 SymbolFileDWARF::ParseCompileUnitLanguage (const SymbolContext& sc)
1006 assert (sc.comp_unit);
1007 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
1009 return dwarf_cu->GetLanguageType();
1011 return eLanguageTypeUnknown;
1015 SymbolFileDWARF::ParseCompileUnitFunctions(const SymbolContext &sc)
1017 assert (sc.comp_unit);
1018 size_t functions_added = 0;
1019 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
1022 DWARFDIECollection function_dies;
1023 const size_t num_functions = dwarf_cu->AppendDIEsWithTag (DW_TAG_subprogram, function_dies);
1025 for (func_idx = 0; func_idx < num_functions; ++func_idx)
1027 DWARFDIE die = function_dies.GetDIEAtIndex(func_idx);
1028 if (sc.comp_unit->FindFunctionByUID (die.GetID()).get() == NULL)
1030 if (ParseCompileUnitFunction(sc, die))
1036 return functions_added;
1040 SymbolFileDWARF::ParseCompileUnitSupportFiles (const SymbolContext& sc, FileSpecList& support_files)
1042 assert (sc.comp_unit);
1043 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
1046 const DWARFDIE cu_die = dwarf_cu->GetCompileUnitDIEOnly();
1050 const char * cu_comp_dir = resolveCompDir(cu_die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr));
1051 const dw_offset_t stmt_list = cu_die.GetAttributeValueAsUnsigned(DW_AT_stmt_list, DW_INVALID_OFFSET);
1052 if (stmt_list != DW_INVALID_OFFSET)
1054 // All file indexes in DWARF are one based and a file of index zero is
1055 // supposed to be the compile unit itself.
1056 support_files.Append (*sc.comp_unit);
1057 return DWARFDebugLine::ParseSupportFiles(sc.comp_unit->GetModule(),
1058 get_debug_line_data(),
1069 SymbolFileDWARF::ParseCompileUnitIsOptimized(const lldb_private::SymbolContext &sc)
1071 DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
1073 return dwarf_cu->GetIsOptimized();
1078 SymbolFileDWARF::ParseImportedModules(const lldb_private::SymbolContext &sc,
1079 std::vector<lldb_private::ConstString> &imported_modules)
1081 assert (sc.comp_unit);
1082 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
1085 if (ClangModulesDeclVendor::LanguageSupportsClangModules(sc.comp_unit->GetLanguage()))
1087 UpdateExternalModuleListIfNeeded();
1091 const DWARFDIE die = dwarf_cu->GetCompileUnitDIEOnly();
1095 for (DWARFDIE child_die = die.GetFirstChild();
1097 child_die = child_die.GetSibling())
1099 if (child_die.Tag() == DW_TAG_imported_declaration)
1101 if (DWARFDIE module_die = child_die.GetReferencedDIE(DW_AT_import))
1103 if (module_die.Tag() == DW_TAG_module)
1105 if (const char *name = module_die.GetAttributeValueAsString(DW_AT_name, nullptr))
1107 ConstString const_name(name);
1108 imported_modules.push_back(const_name);
1118 for (const auto &pair : m_external_type_modules)
1120 imported_modules.push_back(pair.first);
1128 struct ParseDWARFLineTableCallbackInfo
1130 LineTable* line_table;
1131 std::unique_ptr<LineSequence> sequence_ap;
1132 lldb::addr_t addr_mask;
1135 //----------------------------------------------------------------------
1136 // ParseStatementTableCallback
1137 //----------------------------------------------------------------------
1139 ParseDWARFLineTableCallback(dw_offset_t offset, const DWARFDebugLine::State& state, void* userData)
1141 if (state.row == DWARFDebugLine::State::StartParsingLineTable)
1143 // Just started parsing the line table
1145 else if (state.row == DWARFDebugLine::State::DoneParsingLineTable)
1147 // Done parsing line table, nothing to do for the cleanup
1151 ParseDWARFLineTableCallbackInfo* info = (ParseDWARFLineTableCallbackInfo*)userData;
1152 LineTable* line_table = info->line_table;
1154 // If this is our first time here, we need to create a
1155 // sequence container.
1156 if (!info->sequence_ap.get())
1158 info->sequence_ap.reset(line_table->CreateLineSequenceContainer());
1159 assert(info->sequence_ap.get());
1161 line_table->AppendLineEntryToSequence (info->sequence_ap.get(),
1162 state.address & info->addr_mask,
1169 state.epilogue_begin,
1170 state.end_sequence);
1171 if (state.end_sequence)
1173 // First, put the current sequence into the line table.
1174 line_table->InsertSequence(info->sequence_ap.get());
1175 // Then, empty it to prepare for the next sequence.
1176 info->sequence_ap->Clear();
1182 SymbolFileDWARF::ParseCompileUnitLineTable (const SymbolContext &sc)
1184 assert (sc.comp_unit);
1185 if (sc.comp_unit->GetLineTable() != NULL)
1188 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
1191 const DWARFDIE dwarf_cu_die = dwarf_cu->GetCompileUnitDIEOnly();
1194 const dw_offset_t cu_line_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_stmt_list, DW_INVALID_OFFSET);
1195 if (cu_line_offset != DW_INVALID_OFFSET)
1197 std::unique_ptr<LineTable> line_table_ap(new LineTable(sc.comp_unit));
1198 if (line_table_ap.get())
1200 ParseDWARFLineTableCallbackInfo info;
1201 info.line_table = line_table_ap.get();
1205 * The SymbolContext may not have a valid target, thus we may not be able
1206 * to call Address::GetOpcodeLoadAddress() which would clear the bit #0
1207 * for MIPS. Use ArchSpec to clear the bit #0.
1210 GetObjectFile()->GetArchitecture(arch);
1211 switch (arch.GetMachine())
1213 case llvm::Triple::mips:
1214 case llvm::Triple::mipsel:
1215 case llvm::Triple::mips64:
1216 case llvm::Triple::mips64el:
1217 info.addr_mask = ~((lldb::addr_t)1);
1220 info.addr_mask = ~((lldb::addr_t)0);
1224 lldb::offset_t offset = cu_line_offset;
1225 DWARFDebugLine::ParseStatementTable(get_debug_line_data(), &offset, ParseDWARFLineTableCallback, &info);
1226 SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
1227 if (debug_map_symfile)
1229 // We have an object file that has a line table with addresses
1230 // that are not linked. We need to link the line table and convert
1231 // the addresses that are relative to the .o file into addresses
1232 // for the main executable.
1233 sc.comp_unit->SetLineTable (debug_map_symfile->LinkOSOLineTable (this, line_table_ap.get()));
1237 sc.comp_unit->SetLineTable(line_table_ap.release());
1247 lldb_private::DebugMacrosSP
1248 SymbolFileDWARF::ParseDebugMacros(lldb::offset_t *offset)
1250 auto iter = m_debug_macros_map.find(*offset);
1251 if (iter != m_debug_macros_map.end())
1252 return iter->second;
1254 const DWARFDataExtractor &debug_macro_data = get_debug_macro_data();
1255 if (debug_macro_data.GetByteSize() == 0)
1256 return DebugMacrosSP();
1258 lldb_private::DebugMacrosSP debug_macros_sp(new lldb_private::DebugMacros());
1259 m_debug_macros_map[*offset] = debug_macros_sp;
1261 const DWARFDebugMacroHeader &header = DWARFDebugMacroHeader::ParseHeader(debug_macro_data, offset);
1262 DWARFDebugMacroEntry::ReadMacroEntries(
1263 debug_macro_data, get_debug_str_data(), header.OffsetIs64Bit(), offset, this, debug_macros_sp);
1265 return debug_macros_sp;
1269 SymbolFileDWARF::ParseCompileUnitDebugMacros(const SymbolContext& sc)
1271 assert (sc.comp_unit);
1273 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
1274 if (dwarf_cu == nullptr)
1277 const DWARFDIE dwarf_cu_die = dwarf_cu->GetCompileUnitDIEOnly();
1281 lldb::offset_t sect_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_macros, DW_INVALID_OFFSET);
1282 if (sect_offset == DW_INVALID_OFFSET)
1283 sect_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_GNU_macros, DW_INVALID_OFFSET);
1284 if (sect_offset == DW_INVALID_OFFSET)
1287 sc.comp_unit->SetDebugMacros(ParseDebugMacros(§_offset));
1293 SymbolFileDWARF::ParseFunctionBlocks (const SymbolContext& sc,
1294 Block *parent_block,
1295 const DWARFDIE &orig_die,
1296 addr_t subprogram_low_pc,
1299 size_t blocks_added = 0;
1300 DWARFDIE die = orig_die;
1303 dw_tag_t tag = die.Tag();
1307 case DW_TAG_inlined_subroutine:
1308 case DW_TAG_subprogram:
1309 case DW_TAG_lexical_block:
1311 Block *block = NULL;
1312 if (tag == DW_TAG_subprogram)
1314 // Skip any DW_TAG_subprogram DIEs that are inside
1315 // of a normal or inlined functions. These will be
1316 // parsed on their own as separate entities.
1321 block = parent_block;
1325 BlockSP block_sp(new Block (die.GetID()));
1326 parent_block->AddChild(block_sp);
1327 block = block_sp.get();
1329 DWARFRangeList ranges;
1330 const char *name = NULL;
1331 const char *mangled_name = NULL;
1335 int decl_column = 0;
1338 int call_column = 0;
1339 if (die.GetDIENamesAndRanges (name,
1342 decl_file, decl_line, decl_column,
1343 call_file, call_line, call_column, nullptr))
1345 if (tag == DW_TAG_subprogram)
1347 assert (subprogram_low_pc == LLDB_INVALID_ADDRESS);
1348 subprogram_low_pc = ranges.GetMinRangeBase(0);
1350 else if (tag == DW_TAG_inlined_subroutine)
1352 // We get called here for inlined subroutines in two ways.
1353 // The first time is when we are making the Function object
1354 // for this inlined concrete instance. Since we're creating a top level block at
1355 // here, the subprogram_low_pc will be LLDB_INVALID_ADDRESS. So we need to
1356 // adjust the containing address.
1357 // The second time is when we are parsing the blocks inside the function that contains
1358 // the inlined concrete instance. Since these will be blocks inside the containing "real"
1359 // function the offset will be for that function.
1360 if (subprogram_low_pc == LLDB_INVALID_ADDRESS)
1362 subprogram_low_pc = ranges.GetMinRangeBase(0);
1366 const size_t num_ranges = ranges.GetSize();
1367 for (size_t i = 0; i<num_ranges; ++i)
1369 const DWARFRangeList::Entry &range = ranges.GetEntryRef (i);
1370 const addr_t range_base = range.GetRangeBase();
1371 if (range_base >= subprogram_low_pc)
1372 block->AddRange(Block::Range (range_base - subprogram_low_pc, range.GetByteSize()));
1375 GetObjectFile()->GetModule()->ReportError ("0x%8.8" PRIx64 ": adding range [0x%" PRIx64 "-0x%" PRIx64 ") which has a base that is less than the function's low PC 0x%" PRIx64 ". Please file a bug and attach the file at the start of this error message",
1378 range.GetRangeEnd(),
1382 block->FinalizeRanges ();
1384 if (tag != DW_TAG_subprogram && (name != NULL || mangled_name != NULL))
1386 std::unique_ptr<Declaration> decl_ap;
1387 if (decl_file != 0 || decl_line != 0 || decl_column != 0)
1388 decl_ap.reset(new Declaration(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(decl_file),
1389 decl_line, decl_column));
1391 std::unique_ptr<Declaration> call_ap;
1392 if (call_file != 0 || call_line != 0 || call_column != 0)
1393 call_ap.reset(new Declaration(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(call_file),
1394 call_line, call_column));
1396 block->SetInlinedFunctionInfo (name, mangled_name, decl_ap.get(), call_ap.get());
1401 if (die.HasChildren())
1403 blocks_added += ParseFunctionBlocks (sc,
1405 die.GetFirstChild(),
1416 // Only parse siblings of the block if we are not at depth zero. A depth
1417 // of zero indicates we are currently parsing the top level
1418 // DW_TAG_subprogram DIE
1423 die = die.GetSibling();
1425 return blocks_added;
1429 SymbolFileDWARF::ClassOrStructIsVirtual (const DWARFDIE &parent_die)
1433 for (DWARFDIE die = parent_die.GetFirstChild(); die; die = die.GetSibling())
1435 dw_tag_t tag = die.Tag();
1436 bool check_virtuality = false;
1439 case DW_TAG_inheritance:
1440 case DW_TAG_subprogram:
1441 check_virtuality = true;
1446 if (check_virtuality)
1448 if (die.GetAttributeValueAsUnsigned(DW_AT_virtuality, 0) != 0)
1457 SymbolFileDWARF::ParseDeclsForContext (CompilerDeclContext decl_ctx)
1459 TypeSystem *type_system = decl_ctx.GetTypeSystem();
1460 DWARFASTParser *ast_parser = type_system->GetDWARFParser();
1461 std::vector<DWARFDIE> decl_ctx_die_list = ast_parser->GetDIEForDeclContext(decl_ctx);
1463 for (DWARFDIE decl_ctx_die : decl_ctx_die_list)
1464 for (DWARFDIE decl = decl_ctx_die.GetFirstChild(); decl; decl = decl.GetSibling())
1465 ast_parser->GetDeclForUIDFromDWARF(decl);
1469 SymbolFileDWARF::GetDWARFForUID (lldb::user_id_t uid)
1471 // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API
1472 // we must make sure we use the correct DWARF file when resolving things.
1473 // On MacOSX, when using SymbolFileDWARFDebugMap, we will use multiple
1474 // SymbolFileDWARF classes, one for each .o file. We can often end up
1475 // with references to other DWARF objects and we must be ready to receive
1476 // a "lldb::user_id_t" that specifies a DIE from another SymbolFileDWARF
1478 SymbolFileDWARFDebugMap *debug_map = GetDebugMapSymfile();
1480 return debug_map->GetSymbolFileByOSOIndex(debug_map->GetOSOIndexFromUserID(uid));
1485 SymbolFileDWARF::GetDIEFromUID (lldb::user_id_t uid)
1487 // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API
1488 // we must make sure we use the correct DWARF file when resolving things.
1489 // On MacOSX, when using SymbolFileDWARFDebugMap, we will use multiple
1490 // SymbolFileDWARF classes, one for each .o file. We can often end up
1491 // with references to other DWARF objects and we must be ready to receive
1492 // a "lldb::user_id_t" that specifies a DIE from another SymbolFileDWARF
1494 SymbolFileDWARF *dwarf = GetDWARFForUID(uid);
1496 return dwarf->GetDIE(DIERef(uid, dwarf));
1501 SymbolFileDWARF::GetDeclForUID (lldb::user_id_t type_uid)
1503 // Anytime we have a lldb::user_id_t, we must get the DIE by
1504 // calling SymbolFileDWARF::GetDIEFromUID(). See comments inside
1505 // the SymbolFileDWARF::GetDIEFromUID() for details.
1506 DWARFDIE die = GetDIEFromUID(type_uid);
1508 return die.GetDecl();
1509 return CompilerDecl();
1513 SymbolFileDWARF::GetDeclContextForUID (lldb::user_id_t type_uid)
1515 // Anytime we have a lldb::user_id_t, we must get the DIE by
1516 // calling SymbolFileDWARF::GetDIEFromUID(). See comments inside
1517 // the SymbolFileDWARF::GetDIEFromUID() for details.
1518 DWARFDIE die = GetDIEFromUID(type_uid);
1520 return die.GetDeclContext();
1521 return CompilerDeclContext();
1525 SymbolFileDWARF::GetDeclContextContainingUID (lldb::user_id_t type_uid)
1527 // Anytime we have a lldb::user_id_t, we must get the DIE by
1528 // calling SymbolFileDWARF::GetDIEFromUID(). See comments inside
1529 // the SymbolFileDWARF::GetDIEFromUID() for details.
1530 DWARFDIE die = GetDIEFromUID(type_uid);
1532 return die.GetContainingDeclContext();
1533 return CompilerDeclContext();
1538 SymbolFileDWARF::ResolveTypeUID (lldb::user_id_t type_uid)
1540 // Anytime we have a lldb::user_id_t, we must get the DIE by
1541 // calling SymbolFileDWARF::GetDIEFromUID(). See comments inside
1542 // the SymbolFileDWARF::GetDIEFromUID() for details.
1543 DWARFDIE type_die = GetDIEFromUID(type_uid);
1545 return type_die.ResolveType();
1551 SymbolFileDWARF::ResolveTypeUID (const DIERef &die_ref)
1553 return ResolveType (GetDIE(die_ref), true);
1557 SymbolFileDWARF::ResolveTypeUID (const DWARFDIE &die, bool assert_not_being_parsed)
1561 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
1563 GetObjectFile()->GetModule()->LogMessage (log,
1564 "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s'",
1566 die.GetTagAsCString(),
1569 // We might be coming in in the middle of a type tree (a class
1570 // withing a class, an enum within a class), so parse any needed
1571 // parent DIEs before we get to this one...
1572 DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE (die);
1577 switch (decl_ctx_die.Tag())
1579 case DW_TAG_structure_type:
1580 case DW_TAG_union_type:
1581 case DW_TAG_class_type:
1583 // Get the type, which could be a forward declaration
1585 GetObjectFile()->GetModule()->LogMessage (log,
1586 "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s' resolve parent forward type for 0x%8.8x",
1588 die.GetTagAsCString(),
1590 decl_ctx_die.GetOffset());
1599 return ResolveType (die);
1604 // This function is used when SymbolFileDWARFDebugMap owns a bunch of
1605 // SymbolFileDWARF objects to detect if this DWARF file is the one that
1606 // can resolve a compiler_type.
1608 SymbolFileDWARF::HasForwardDeclForClangType (const CompilerType &compiler_type)
1610 CompilerType compiler_type_no_qualifiers = ClangUtil::RemoveFastQualifiers(compiler_type);
1611 if (GetForwardDeclClangTypeToDie().count (compiler_type_no_qualifiers.GetOpaqueQualType()))
1615 TypeSystem *type_system = compiler_type.GetTypeSystem();
1617 ClangASTContext *clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(type_system);
1618 if (!clang_type_system)
1620 DWARFASTParserClang *ast_parser = static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser());
1621 return ast_parser->GetClangASTImporter().CanImport(compiler_type);
1626 SymbolFileDWARF::CompleteType (CompilerType &compiler_type)
1628 std::lock_guard<std::recursive_mutex> guard(GetObjectFile()->GetModule()->GetMutex());
1630 ClangASTContext *clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(compiler_type.GetTypeSystem());
1631 if (clang_type_system)
1633 DWARFASTParserClang *ast_parser = static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser());
1634 if (ast_parser && ast_parser->GetClangASTImporter().CanImport(compiler_type))
1635 return ast_parser->GetClangASTImporter().CompleteType(compiler_type);
1638 // We have a struct/union/class/enum that needs to be fully resolved.
1639 CompilerType compiler_type_no_qualifiers = ClangUtil::RemoveFastQualifiers(compiler_type);
1640 auto die_it = GetForwardDeclClangTypeToDie().find (compiler_type_no_qualifiers.GetOpaqueQualType());
1641 if (die_it == GetForwardDeclClangTypeToDie().end())
1643 // We have already resolved this type...
1647 DWARFDIE dwarf_die = GetDIE(die_it->getSecond());
1650 // Once we start resolving this type, remove it from the forward declaration
1651 // map in case anyone child members or other types require this type to get resolved.
1652 // The type will get resolved when all of the calls to SymbolFileDWARF::ResolveClangOpaqueTypeDefinition
1654 GetForwardDeclClangTypeToDie().erase (die_it);
1656 Type *type = GetDIEToType().lookup (dwarf_die.GetDIE());
1658 Log *log (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO|DWARF_LOG_TYPE_COMPLETION));
1660 GetObjectFile()->GetModule()->LogMessageVerboseBacktrace (log,
1661 "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...",
1663 dwarf_die.GetTagAsCString(),
1664 type->GetName().AsCString());
1665 assert (compiler_type);
1666 DWARFASTParser *dwarf_ast = dwarf_die.GetDWARFParser();
1668 return dwarf_ast->CompleteTypeFromDWARF (dwarf_die, type, compiler_type);
1674 SymbolFileDWARF::ResolveType (const DWARFDIE &die, bool assert_not_being_parsed, bool resolve_function_context)
1678 Type *type = GetTypeForDIE (die, resolve_function_context).get();
1680 if (assert_not_being_parsed)
1682 if (type != DIE_IS_BEING_PARSED)
1685 GetObjectFile()->GetModule()->ReportError ("Parsing a die that is being parsed die: 0x%8.8x: %s %s",
1687 die.GetTagAsCString(),
1698 SymbolFileDWARF::GetCompUnitForDWARFCompUnit (DWARFCompileUnit* dwarf_cu, uint32_t cu_idx)
1700 // Check if the symbol vendor already knows about this compile unit?
1701 if (dwarf_cu->GetUserData() == NULL)
1703 // The symbol vendor doesn't know about this compile unit, we
1704 // need to parse and add it to the symbol vendor object.
1705 return ParseCompileUnit(dwarf_cu, cu_idx).get();
1707 return (CompileUnit*)dwarf_cu->GetUserData();
1711 SymbolFileDWARF::GetObjCMethodDIEOffsets (ConstString class_name, DIEArray &method_die_offsets)
1713 method_die_offsets.clear();
1714 if (m_using_apple_tables)
1716 if (m_apple_objc_ap.get())
1717 m_apple_objc_ap->FindByName(class_name.GetCString(), method_die_offsets);
1724 m_objc_class_selectors_index.Find (class_name, method_die_offsets);
1726 return method_die_offsets.size();
1730 SymbolFileDWARF::GetFunction (const DWARFDIE &die, SymbolContext& sc)
1736 // Check if the symbol vendor already knows about this compile unit?
1737 sc.comp_unit = GetCompUnitForDWARFCompUnit(die.GetCU(), UINT32_MAX);
1739 sc.function = sc.comp_unit->FindFunctionByUID (die.GetID()).get();
1740 if (sc.function == NULL)
1741 sc.function = ParseCompileUnitFunction(sc, die);
1745 sc.module_sp = sc.function->CalculateSymbolContextModule();
1754 SymbolFileDWARF::GetDWOModule (ConstString name)
1756 UpdateExternalModuleListIfNeeded();
1757 const auto &pos = m_external_type_modules.find(name);
1758 if (pos != m_external_type_modules.end())
1761 return lldb::ModuleSP();
1765 SymbolFileDWARF::GetDIE (const DIERef &die_ref)
1767 DWARFDebugInfo * debug_info = DebugInfo();
1769 return debug_info->GetDIE(die_ref);
1775 std::unique_ptr<SymbolFileDWARFDwo>
1776 SymbolFileDWARF::GetDwoSymbolFileForCompileUnit(DWARFCompileUnit &dwarf_cu, const DWARFDebugInfoEntry &cu_die)
1778 // If we are using a dSYM file, we never want the standard DWO files since
1779 // the -gmodule support uses the same DWO machanism to specify full debug
1780 // info files for modules.
1781 if (GetDebugMapSymfile())
1784 const char *dwo_name = cu_die.GetAttributeValueAsString(this, &dwarf_cu, DW_AT_GNU_dwo_name, nullptr);
1788 FileSpec dwo_file(dwo_name, true);
1789 if (dwo_file.IsRelative())
1791 const char *comp_dir = cu_die.GetAttributeValueAsString(this, &dwarf_cu, DW_AT_comp_dir, nullptr);
1795 dwo_file.SetFile(comp_dir, true);
1796 dwo_file.AppendPathComponent(dwo_name);
1799 if (!dwo_file.Exists())
1802 const lldb::offset_t file_offset = 0;
1803 DataBufferSP dwo_file_data_sp;
1804 lldb::offset_t dwo_file_data_offset = 0;
1805 ObjectFileSP dwo_obj_file = ObjectFile::FindPlugin(GetObjectFile()->GetModule(), &dwo_file, file_offset,
1806 dwo_file.GetByteSize(), dwo_file_data_sp, dwo_file_data_offset);
1807 if (dwo_obj_file == nullptr)
1810 return llvm::make_unique<SymbolFileDWARFDwo>(dwo_obj_file, &dwarf_cu);
1814 SymbolFileDWARF::UpdateExternalModuleListIfNeeded()
1816 if (m_fetched_external_modules)
1818 m_fetched_external_modules = true;
1820 DWARFDebugInfo * debug_info = DebugInfo();
1822 const uint32_t num_compile_units = GetNumCompileUnits();
1823 for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx)
1825 DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
1827 const DWARFDIE die = dwarf_cu->GetCompileUnitDIEOnly();
1828 if (die && die.HasChildren() == false)
1830 const char *name = die.GetAttributeValueAsString(DW_AT_name, nullptr);
1834 ConstString const_name(name);
1835 if (m_external_type_modules.find(const_name) == m_external_type_modules.end())
1838 const char *dwo_path = die.GetAttributeValueAsString(DW_AT_GNU_dwo_name, nullptr);
1841 ModuleSpec dwo_module_spec;
1842 dwo_module_spec.GetFileSpec().SetFile(dwo_path, false);
1843 if (dwo_module_spec.GetFileSpec().IsRelative())
1845 const char *comp_dir = die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr);
1848 dwo_module_spec.GetFileSpec().SetFile(comp_dir, true);
1849 dwo_module_spec.GetFileSpec().AppendPathComponent(dwo_path);
1852 dwo_module_spec.GetArchitecture() = m_obj_file->GetModule()->GetArchitecture();
1853 //printf ("Loading dwo = '%s'\n", dwo_path);
1854 Error error = ModuleList::GetSharedModule (dwo_module_spec, module_sp, NULL, NULL, NULL);
1857 GetObjectFile()->GetModule()->ReportWarning ("0x%8.8x: unable to locate module needed for external types: %s\nerror: %s\nDebugging will be degraded due to missing types. Rebuilding your project will regenerate the needed module files.",
1859 dwo_module_spec.GetFileSpec().GetPath().c_str(),
1860 error.AsCString("unknown error"));
1863 m_external_type_modules[const_name] = module_sp;
1870 SymbolFileDWARF::GlobalVariableMap &
1871 SymbolFileDWARF::GetGlobalAranges()
1873 if (!m_global_aranges_ap)
1875 m_global_aranges_ap.reset (new GlobalVariableMap());
1877 ModuleSP module_sp = GetObjectFile()->GetModule();
1880 const size_t num_cus = module_sp->GetNumCompileUnits();
1881 for (size_t i = 0; i < num_cus; ++i)
1883 CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex(i);
1886 VariableListSP globals_sp = cu_sp->GetVariableList(true);
1889 const size_t num_globals = globals_sp->GetSize();
1890 for (size_t g = 0; g < num_globals; ++g)
1892 VariableSP var_sp = globals_sp->GetVariableAtIndex(g);
1893 if (var_sp && !var_sp->GetLocationIsConstantValueData())
1895 const DWARFExpression &location = var_sp->LocationExpression();
1896 Value location_result;
1898 if (location.Evaluate(nullptr, nullptr, nullptr, LLDB_INVALID_ADDRESS, nullptr, nullptr, location_result, &error))
1900 if (location_result.GetValueType() == Value::eValueTypeFileAddress)
1902 lldb::addr_t file_addr = location_result.GetScalar().ULongLong();
1903 lldb::addr_t byte_size = 1;
1904 if (var_sp->GetType())
1905 byte_size = var_sp->GetType()->GetByteSize();
1906 m_global_aranges_ap->Append(GlobalVariableMap::Entry(file_addr, byte_size, var_sp.get()));
1915 m_global_aranges_ap->Sort();
1917 return *m_global_aranges_ap;
1922 SymbolFileDWARF::ResolveSymbolContext (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc)
1924 Timer scoped_timer(__PRETTY_FUNCTION__,
1925 "SymbolFileDWARF::ResolveSymbolContext (so_addr = { section = %p, offset = 0x%" PRIx64 " }, resolve_scope = 0x%8.8x)",
1926 static_cast<void*>(so_addr.GetSection().get()),
1927 so_addr.GetOffset(), resolve_scope);
1928 uint32_t resolved = 0;
1929 if (resolve_scope & ( eSymbolContextCompUnit |
1930 eSymbolContextFunction |
1931 eSymbolContextBlock |
1932 eSymbolContextLineEntry |
1933 eSymbolContextVariable ))
1935 lldb::addr_t file_vm_addr = so_addr.GetFileAddress();
1937 DWARFDebugInfo* debug_info = DebugInfo();
1940 const dw_offset_t cu_offset = debug_info->GetCompileUnitAranges().FindAddress(file_vm_addr);
1941 if (cu_offset == DW_INVALID_OFFSET)
1943 // Global variables are not in the compile unit address ranges. The only way to
1944 // currently find global variables is to iterate over the .debug_pubnames or the
1945 // __apple_names table and find all items in there that point to DW_TAG_variable
1946 // DIEs and then find the address that matches.
1947 if (resolve_scope & eSymbolContextVariable)
1949 GlobalVariableMap &map = GetGlobalAranges();
1950 const GlobalVariableMap::Entry *entry = map.FindEntryThatContains(file_vm_addr);
1951 if (entry && entry->data)
1953 Variable *variable = entry->data;
1954 SymbolContextScope *scc = variable->GetSymbolContextScope();
1957 scc->CalculateSymbolContext(&sc);
1958 sc.variable = variable;
1960 return sc.GetResolvedMask();
1966 uint32_t cu_idx = DW_INVALID_INDEX;
1967 DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnit(cu_offset, &cu_idx);
1970 sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx);
1973 resolved |= eSymbolContextCompUnit;
1975 bool force_check_line_table = false;
1976 if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock))
1978 DWARFDIE function_die = dwarf_cu->LookupAddress(file_vm_addr);
1982 sc.function = sc.comp_unit->FindFunctionByUID (function_die.GetID()).get();
1983 if (sc.function == NULL)
1984 sc.function = ParseCompileUnitFunction(sc, function_die);
1986 if (sc.function && (resolve_scope & eSymbolContextBlock))
1987 block_die = function_die.LookupDeepestBlock(file_vm_addr);
1991 // We might have had a compile unit that had discontiguous
1992 // address ranges where the gaps are symbols that don't have
1993 // any debug info. Discontiguous compile unit address ranges
1994 // should only happen when there aren't other functions from
1995 // other compile units in these gaps. This helps keep the size
1996 // of the aranges down.
1997 force_check_line_table = true;
2000 if (sc.function != NULL)
2002 resolved |= eSymbolContextFunction;
2004 if (resolve_scope & eSymbolContextBlock)
2006 Block& block = sc.function->GetBlock (true);
2009 sc.block = block.FindBlockByID (block_die.GetID());
2011 sc.block = block.FindBlockByID (function_die.GetID());
2013 resolved |= eSymbolContextBlock;
2018 if ((resolve_scope & eSymbolContextLineEntry) || force_check_line_table)
2020 LineTable *line_table = sc.comp_unit->GetLineTable();
2021 if (line_table != NULL)
2023 // And address that makes it into this function should be in terms
2024 // of this debug file if there is no debug map, or it will be an
2025 // address in the .o file which needs to be fixed up to be in terms
2026 // of the debug map executable. Either way, calling FixupAddress()
2027 // will work for us.
2028 Address exe_so_addr (so_addr);
2029 if (FixupAddress(exe_so_addr))
2031 if (line_table->FindLineEntryByAddress (exe_so_addr, sc.line_entry))
2033 resolved |= eSymbolContextLineEntry;
2039 if (force_check_line_table && !(resolved & eSymbolContextLineEntry))
2041 // We might have had a compile unit that had discontiguous
2042 // address ranges where the gaps are symbols that don't have
2043 // any debug info. Discontiguous compile unit address ranges
2044 // should only happen when there aren't other functions from
2045 // other compile units in these gaps. This helps keep the size
2046 // of the aranges down.
2047 sc.comp_unit = NULL;
2048 resolved &= ~eSymbolContextCompUnit;
2053 GetObjectFile()->GetModule()->ReportWarning ("0x%8.8x: compile unit %u failed to create a valid lldb_private::CompileUnit class.",
2067 SymbolFileDWARF::ResolveSymbolContext(const FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list)
2069 const uint32_t prev_size = sc_list.GetSize();
2070 if (resolve_scope & eSymbolContextCompUnit)
2072 DWARFDebugInfo* debug_info = DebugInfo();
2076 DWARFCompileUnit* dwarf_cu = NULL;
2078 for (cu_idx = 0; (dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx)) != NULL; ++cu_idx)
2080 CompileUnit *dc_cu = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx);
2081 const bool full_match = (bool)file_spec.GetDirectory();
2082 bool file_spec_matches_cu_file_spec = dc_cu != NULL && FileSpec::Equal(file_spec, *dc_cu, full_match);
2083 if (check_inlines || file_spec_matches_cu_file_spec)
2085 SymbolContext sc (m_obj_file->GetModule());
2086 sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx);
2089 uint32_t file_idx = UINT32_MAX;
2091 // If we are looking for inline functions only and we don't
2092 // find it in the support files, we are done.
2095 file_idx = sc.comp_unit->GetSupportFiles().FindFileIndex (1, file_spec, true);
2096 if (file_idx == UINT32_MAX)
2102 LineTable *line_table = sc.comp_unit->GetLineTable();
2104 if (line_table != NULL && line != 0)
2106 // We will have already looked up the file index if
2107 // we are searching for inline entries.
2109 file_idx = sc.comp_unit->GetSupportFiles().FindFileIndex (1, file_spec, true);
2111 if (file_idx != UINT32_MAX)
2113 uint32_t found_line;
2114 uint32_t line_idx = line_table->FindLineEntryIndexByFileIndex (0, file_idx, line, false, &sc.line_entry);
2115 found_line = sc.line_entry.line;
2117 while (line_idx != UINT32_MAX)
2121 if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock))
2123 const lldb::addr_t file_vm_addr = sc.line_entry.range.GetBaseAddress().GetFileAddress();
2124 if (file_vm_addr != LLDB_INVALID_ADDRESS)
2126 DWARFDIE function_die = dwarf_cu->LookupAddress(file_vm_addr);
2130 sc.function = sc.comp_unit->FindFunctionByUID (function_die.GetID()).get();
2131 if (sc.function == NULL)
2132 sc.function = ParseCompileUnitFunction(sc, function_die);
2134 if (sc.function && (resolve_scope & eSymbolContextBlock))
2135 block_die = function_die.LookupDeepestBlock(file_vm_addr);
2138 if (sc.function != NULL)
2140 Block& block = sc.function->GetBlock (true);
2143 sc.block = block.FindBlockByID (block_die.GetID());
2144 else if (function_die)
2145 sc.block = block.FindBlockByID (function_die.GetID());
2151 line_idx = line_table->FindLineEntryIndexByFileIndex (line_idx + 1, file_idx, found_line, true, &sc.line_entry);
2155 else if (file_spec_matches_cu_file_spec && !check_inlines)
2157 // only append the context if we aren't looking for inline call sites
2158 // by file and line and if the file spec matches that of the compile unit
2162 else if (file_spec_matches_cu_file_spec && !check_inlines)
2164 // only append the context if we aren't looking for inline call sites
2165 // by file and line and if the file spec matches that of the compile unit
2176 return sc_list.GetSize() - prev_size;
2180 SymbolFileDWARF::Index ()
2185 Timer scoped_timer (__PRETTY_FUNCTION__,
2186 "SymbolFileDWARF::Index (%s)",
2187 GetObjectFile()->GetFileSpec().GetFilename().AsCString("<Unknown>"));
2189 DWARFDebugInfo* debug_info = DebugInfo();
2192 const uint32_t num_compile_units = GetNumCompileUnits();
2193 if (num_compile_units == 0)
2196 std::vector<NameToDIE> function_basename_index(num_compile_units);
2197 std::vector<NameToDIE> function_fullname_index(num_compile_units);
2198 std::vector<NameToDIE> function_method_index(num_compile_units);
2199 std::vector<NameToDIE> function_selector_index(num_compile_units);
2200 std::vector<NameToDIE> objc_class_selectors_index(num_compile_units);
2201 std::vector<NameToDIE> global_index(num_compile_units);
2202 std::vector<NameToDIE> type_index(num_compile_units);
2203 std::vector<NameToDIE> namespace_index(num_compile_units);
2205 std::vector<bool> clear_cu_dies(num_compile_units, false);
2206 auto parser_fn = [this,
2208 &function_basename_index,
2209 &function_fullname_index,
2210 &function_method_index,
2211 &function_selector_index,
2212 &objc_class_selectors_index,
2215 &namespace_index](uint32_t cu_idx)
2217 DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
2220 dwarf_cu->Index(function_basename_index[cu_idx],
2221 function_fullname_index[cu_idx],
2222 function_method_index[cu_idx],
2223 function_selector_index[cu_idx],
2224 objc_class_selectors_index[cu_idx],
2225 global_index[cu_idx],
2227 namespace_index[cu_idx]);
2232 auto extract_fn = [this,
2234 num_compile_units](uint32_t cu_idx)
2236 DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
2239 // dwarf_cu->ExtractDIEsIfNeeded(false) will return zero if the
2240 // DIEs for a compile unit have already been parsed.
2241 return std::make_pair(cu_idx, dwarf_cu->ExtractDIEsIfNeeded(false) > 1);
2243 return std::make_pair(cu_idx, false);
2246 // Create a task runner that extracts dies for each DWARF compile unit in a separate thread
2247 TaskRunner<std::pair<uint32_t, bool>> task_runner_extract;
2248 for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx)
2249 task_runner_extract.AddTask(extract_fn, cu_idx);
2251 //----------------------------------------------------------------------
2252 // First figure out which compile units didn't have their DIEs already
2253 // parsed and remember this. If no DIEs were parsed prior to this index
2254 // function call, we are going to want to clear the CU dies after we
2255 // are done indexing to make sure we don't pull in all DWARF dies, but
2256 // we need to wait until all compile units have been indexed in case
2257 // a DIE in one compile unit refers to another and the indexes accesses
2259 //----------------------------------------------------------------------
2262 auto f = task_runner_extract.WaitForNextCompletedTask();
2267 std::tie(cu_idx, clear) = f.get();
2268 clear_cu_dies[cu_idx] = clear;
2271 // Now create a task runner that can index each DWARF compile unit in a separate
2272 // thread so we can index quickly.
2274 TaskRunner<uint32_t> task_runner;
2275 for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx)
2276 task_runner.AddTask(parser_fn, cu_idx);
2280 std::future<uint32_t> f = task_runner.WaitForNextCompletedTask();
2283 uint32_t cu_idx = f.get();
2285 m_function_basename_index.Append(function_basename_index[cu_idx]);
2286 m_function_fullname_index.Append(function_fullname_index[cu_idx]);
2287 m_function_method_index.Append(function_method_index[cu_idx]);
2288 m_function_selector_index.Append(function_selector_index[cu_idx]);
2289 m_objc_class_selectors_index.Append(objc_class_selectors_index[cu_idx]);
2290 m_global_index.Append(global_index[cu_idx]);
2291 m_type_index.Append(type_index[cu_idx]);
2292 m_namespace_index.Append(namespace_index[cu_idx]);
2296 [&]() { m_function_basename_index.Finalize(); },
2297 [&]() { m_function_fullname_index.Finalize(); },
2298 [&]() { m_function_method_index.Finalize(); },
2299 [&]() { m_function_selector_index.Finalize(); },
2300 [&]() { m_objc_class_selectors_index.Finalize(); },
2301 [&]() { m_global_index.Finalize(); },
2302 [&]() { m_type_index.Finalize(); },
2303 [&]() { m_namespace_index.Finalize(); });
2305 //----------------------------------------------------------------------
2306 // Keep memory down by clearing DIEs for any compile units if indexing
2307 // caused us to load the compile unit's DIEs.
2308 //----------------------------------------------------------------------
2309 for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx)
2311 if (clear_cu_dies[cu_idx])
2312 debug_info->GetCompileUnitAtIndex(cu_idx)->ClearDIEs(true);
2315 #if defined (ENABLE_DEBUG_PRINTF)
2316 StreamFile s(stdout, false);
2317 s.Printf ("DWARF index for '%s':",
2318 GetObjectFile()->GetFileSpec().GetPath().c_str());
2319 s.Printf("\nFunction basenames:\n"); m_function_basename_index.Dump (&s);
2320 s.Printf("\nFunction fullnames:\n"); m_function_fullname_index.Dump (&s);
2321 s.Printf("\nFunction methods:\n"); m_function_method_index.Dump (&s);
2322 s.Printf("\nFunction selectors:\n"); m_function_selector_index.Dump (&s);
2323 s.Printf("\nObjective C class selectors:\n"); m_objc_class_selectors_index.Dump (&s);
2324 s.Printf("\nGlobals and statics:\n"); m_global_index.Dump (&s);
2325 s.Printf("\nTypes:\n"); m_type_index.Dump (&s);
2326 s.Printf("\nNamespaces:\n") m_namespace_index.Dump (&s);
2332 SymbolFileDWARF::DeclContextMatchesThisSymbolFile (const lldb_private::CompilerDeclContext *decl_ctx)
2334 if (decl_ctx == nullptr || !decl_ctx->IsValid())
2336 // Invalid namespace decl which means we aren't matching only things
2337 // in this symbol file, so return true to indicate it matches this
2342 TypeSystem *decl_ctx_type_system = decl_ctx->GetTypeSystem();
2343 TypeSystem *type_system = GetTypeSystemForLanguage(decl_ctx_type_system->GetMinimumLanguage(nullptr));
2344 if (decl_ctx_type_system == type_system)
2345 return true; // The type systems match, return true
2347 // The namespace AST was valid, and it does not match...
2348 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
2351 GetObjectFile()->GetModule()->LogMessage(log, "Valid namespace does not match symbol file");
2357 SymbolFileDWARF::FindGlobalVariables (const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, VariableList& variables)
2359 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
2362 GetObjectFile()->GetModule()->LogMessage (log,
2363 "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", parent_decl_ctx=%p, append=%u, max_matches=%u, variables)",
2365 static_cast<const void*>(parent_decl_ctx),
2366 append, max_matches);
2368 if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
2371 DWARFDebugInfo* info = DebugInfo();
2375 // If we aren't appending the results to this list, then clear the list
2379 // Remember how many variables are in the list before we search in case
2380 // we are appending the results to a variable list.
2381 const uint32_t original_size = variables.GetSize();
2383 DIEArray die_offsets;
2385 if (m_using_apple_tables)
2387 if (m_apple_names_ap.get())
2389 const char *name_cstr = name.GetCString();
2390 llvm::StringRef basename;
2391 llvm::StringRef context;
2393 if (!CPlusPlusLanguage::ExtractContextAndIdentifier(name_cstr, context, basename))
2394 basename = name_cstr;
2396 m_apple_names_ap->FindByName (basename.data(), die_offsets);
2401 // Index the DWARF if we haven't already
2405 m_global_index.Find (name, die_offsets);
2408 const size_t num_die_matches = die_offsets.size();
2409 if (num_die_matches)
2412 sc.module_sp = m_obj_file->GetModule();
2413 assert (sc.module_sp);
2416 for (size_t i=0; i<num_die_matches && !done; ++i)
2418 const DIERef& die_ref = die_offsets[i];
2419 DWARFDIE die = GetDIE (die_ref);
2426 case DW_TAG_subprogram:
2427 case DW_TAG_inlined_subroutine:
2428 case DW_TAG_try_block:
2429 case DW_TAG_catch_block:
2432 case DW_TAG_variable:
2434 sc.comp_unit = GetCompUnitForDWARFCompUnit(die.GetCU(), UINT32_MAX);
2436 if (parent_decl_ctx)
2438 DWARFASTParser *dwarf_ast = die.GetDWARFParser();
2441 CompilerDeclContext actual_parent_decl_ctx = dwarf_ast->GetDeclContextContainingUIDFromDWARF (die);
2442 if (!actual_parent_decl_ctx || actual_parent_decl_ctx != *parent_decl_ctx)
2447 ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false, &variables);
2449 if (variables.GetSize() - original_size >= max_matches)
2457 if (m_using_apple_tables)
2459 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')\n",
2460 die_ref.die_offset, name.GetCString());
2466 // Return the number of variable that were appended to the list
2467 const uint32_t num_matches = variables.GetSize() - original_size;
2468 if (log && num_matches > 0)
2470 GetObjectFile()->GetModule()->LogMessage (log,
2471 "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", parent_decl_ctx=%p, append=%u, max_matches=%u, variables) => %u",
2473 static_cast<const void*>(parent_decl_ctx),
2474 append, max_matches,
2481 SymbolFileDWARF::FindGlobalVariables(const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variables)
2483 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
2487 GetObjectFile()->GetModule()->LogMessage (log,
2488 "SymbolFileDWARF::FindGlobalVariables (regex=\"%s\", append=%u, max_matches=%u, variables)",
2489 regex.GetText(), append,
2493 DWARFDebugInfo* info = DebugInfo();
2497 // If we aren't appending the results to this list, then clear the list
2501 // Remember how many variables are in the list before we search in case
2502 // we are appending the results to a variable list.
2503 const uint32_t original_size = variables.GetSize();
2505 DIEArray die_offsets;
2507 if (m_using_apple_tables)
2509 if (m_apple_names_ap.get())
2511 DWARFMappedHash::DIEInfoArray hash_data_array;
2512 if (m_apple_names_ap->AppendAllDIEsThatMatchingRegex (regex, hash_data_array))
2513 DWARFMappedHash::ExtractDIEArray (hash_data_array, die_offsets);
2518 // Index the DWARF if we haven't already
2522 m_global_index.Find (regex, die_offsets);
2526 sc.module_sp = m_obj_file->GetModule();
2527 assert (sc.module_sp);
2529 const size_t num_matches = die_offsets.size();
2532 for (size_t i=0; i<num_matches; ++i)
2534 const DIERef& die_ref = die_offsets[i];
2535 DWARFDIE die = GetDIE (die_ref);
2539 sc.comp_unit = GetCompUnitForDWARFCompUnit(die.GetCU(), UINT32_MAX);
2541 ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false, &variables);
2543 if (variables.GetSize() - original_size >= max_matches)
2548 if (m_using_apple_tables)
2550 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for regex '%s')\n",
2551 die_ref.die_offset, regex.GetText());
2557 // Return the number of variable that were appended to the list
2558 return variables.GetSize() - original_size;
2563 SymbolFileDWARF::ResolveFunction (const DIERef& die_ref,
2564 bool include_inlines,
2565 SymbolContextList& sc_list)
2567 DWARFDIE die = DebugInfo()->GetDIE (die_ref);
2568 return ResolveFunction (die, include_inlines, sc_list);
2573 SymbolFileDWARF::ResolveFunction (const DWARFDIE &orig_die,
2574 bool include_inlines,
2575 SymbolContextList& sc_list)
2582 // If we were passed a die that is not a function, just return false...
2583 if (!(orig_die.Tag() == DW_TAG_subprogram || (include_inlines && orig_die.Tag() == DW_TAG_inlined_subroutine)))
2586 DWARFDIE die = orig_die;
2587 DWARFDIE inlined_die;
2588 if (die.Tag() == DW_TAG_inlined_subroutine)
2594 die = die.GetParent();
2598 if (die.Tag() == DW_TAG_subprogram)
2605 assert (die && die.Tag() == DW_TAG_subprogram);
2606 if (GetFunction (die, sc))
2609 // Parse all blocks if needed
2612 Block &function_block = sc.function->GetBlock (true);
2613 sc.block = function_block.FindBlockByID (inlined_die.GetID());
2614 if (sc.block == NULL)
2615 sc.block = function_block.FindBlockByID (inlined_die.GetOffset());
2616 if (sc.block == NULL || sc.block->GetStartAddress (addr) == false)
2622 addr = sc.function->GetAddressRange().GetBaseAddress();
2636 SymbolFileDWARF::FindFunctions (const ConstString &name,
2637 const NameToDIE &name_to_die,
2638 bool include_inlines,
2639 SymbolContextList& sc_list)
2641 DIEArray die_offsets;
2642 if (name_to_die.Find (name, die_offsets))
2644 ParseFunctions (die_offsets, include_inlines, sc_list);
2650 SymbolFileDWARF::FindFunctions (const RegularExpression ®ex,
2651 const NameToDIE &name_to_die,
2652 bool include_inlines,
2653 SymbolContextList& sc_list)
2655 DIEArray die_offsets;
2656 if (name_to_die.Find (regex, die_offsets))
2658 ParseFunctions (die_offsets, include_inlines, sc_list);
2664 SymbolFileDWARF::FindFunctions (const RegularExpression ®ex,
2665 const DWARFMappedHash::MemoryTable &memory_table,
2666 bool include_inlines,
2667 SymbolContextList& sc_list)
2669 DIEArray die_offsets;
2670 DWARFMappedHash::DIEInfoArray hash_data_array;
2671 if (memory_table.AppendAllDIEsThatMatchingRegex (regex, hash_data_array))
2673 DWARFMappedHash::ExtractDIEArray (hash_data_array, die_offsets);
2674 ParseFunctions (die_offsets, include_inlines, sc_list);
2679 SymbolFileDWARF::ParseFunctions (const DIEArray &die_offsets,
2680 bool include_inlines,
2681 SymbolContextList& sc_list)
2683 const size_t num_matches = die_offsets.size();
2686 for (size_t i=0; i<num_matches; ++i)
2687 ResolveFunction (die_offsets[i], include_inlines, sc_list);
2692 SymbolFileDWARF::DIEInDeclContext (const CompilerDeclContext *decl_ctx,
2693 const DWARFDIE &die)
2695 // If we have no parent decl context to match this DIE matches, and if the parent
2696 // decl context isn't valid, we aren't trying to look for any particular decl
2697 // context so any die matches.
2698 if (decl_ctx == nullptr || !decl_ctx->IsValid())
2703 DWARFASTParser *dwarf_ast = die.GetDWARFParser();
2706 CompilerDeclContext actual_decl_ctx = dwarf_ast->GetDeclContextContainingUIDFromDWARF (die);
2707 if (actual_decl_ctx)
2708 return actual_decl_ctx == *decl_ctx;
2715 SymbolFileDWARF::FindFunctions (const ConstString &name,
2716 const CompilerDeclContext *parent_decl_ctx,
2717 uint32_t name_type_mask,
2718 bool include_inlines,
2720 SymbolContextList& sc_list)
2722 Timer scoped_timer (__PRETTY_FUNCTION__,
2723 "SymbolFileDWARF::FindFunctions (name = '%s')",
2726 // eFunctionNameTypeAuto should be pre-resolved by a call to Module::PrepareForFunctionNameLookup()
2727 assert ((name_type_mask & eFunctionNameTypeAuto) == 0);
2729 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
2733 GetObjectFile()->GetModule()->LogMessage (log,
2734 "SymbolFileDWARF::FindFunctions (name=\"%s\", name_type_mask=0x%x, append=%u, sc_list)",
2740 // If we aren't appending the results to this list, then clear the list
2744 if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
2747 // If name is empty then we won't find anything.
2751 // Remember how many sc_list are in the list before we search in case
2752 // we are appending the results to a variable list.
2754 const char *name_cstr = name.GetCString();
2756 const uint32_t original_size = sc_list.GetSize();
2758 DWARFDebugInfo* info = DebugInfo();
2762 std::set<const DWARFDebugInfoEntry *> resolved_dies;
2763 if (m_using_apple_tables)
2765 if (m_apple_names_ap.get())
2768 DIEArray die_offsets;
2770 uint32_t num_matches = 0;
2772 if (name_type_mask & eFunctionNameTypeFull)
2774 // If they asked for the full name, match what they typed. At some point we may
2775 // want to canonicalize this (strip double spaces, etc. For now, we just add all the
2776 // dies that we find by exact match.
2777 num_matches = m_apple_names_ap->FindByName (name_cstr, die_offsets);
2778 for (uint32_t i = 0; i < num_matches; i++)
2780 const DIERef& die_ref = die_offsets[i];
2781 DWARFDIE die = info->GetDIE (die_ref);
2784 if (!DIEInDeclContext(parent_decl_ctx, die))
2785 continue; // The containing decl contexts don't match
2787 if (resolved_dies.find(die.GetDIE()) == resolved_dies.end())
2789 if (ResolveFunction (die, include_inlines, sc_list))
2790 resolved_dies.insert(die.GetDIE());
2795 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')",
2796 die_ref.die_offset, name_cstr);
2801 if (name_type_mask & eFunctionNameTypeSelector)
2803 if (parent_decl_ctx && parent_decl_ctx->IsValid())
2804 return 0; // no selectors in namespaces
2806 num_matches = m_apple_names_ap->FindByName (name_cstr, die_offsets);
2807 // Now make sure these are actually ObjC methods. In this case we can simply look up the name,
2808 // and if it is an ObjC method name, we're good.
2810 for (uint32_t i = 0; i < num_matches; i++)
2812 const DIERef& die_ref = die_offsets[i];
2813 DWARFDIE die = info->GetDIE (die_ref);
2816 const char *die_name = die.GetName();
2817 if (ObjCLanguage::IsPossibleObjCMethodName(die_name))
2819 if (resolved_dies.find(die.GetDIE()) == resolved_dies.end())
2821 if (ResolveFunction (die, include_inlines, sc_list))
2822 resolved_dies.insert(die.GetDIE());
2828 GetObjectFile()->GetModule()->ReportError ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')",
2829 die_ref.die_offset, name_cstr);
2832 die_offsets.clear();
2835 if (((name_type_mask & eFunctionNameTypeMethod) && !parent_decl_ctx) || name_type_mask & eFunctionNameTypeBase)
2837 // The apple_names table stores just the "base name" of C++ methods in the table. So we have to
2838 // extract the base name, look that up, and if there is any other information in the name we were
2839 // passed in we have to post-filter based on that.
2841 // FIXME: Arrange the logic above so that we don't calculate the base name twice:
2842 num_matches = m_apple_names_ap->FindByName (name_cstr, die_offsets);
2844 for (uint32_t i = 0; i < num_matches; i++)
2846 const DIERef& die_ref = die_offsets[i];
2847 DWARFDIE die = info->GetDIE (die_ref);
2850 if (!DIEInDeclContext(parent_decl_ctx, die))
2851 continue; // The containing decl contexts don't match
2854 // If we get to here, the die is good, and we should add it:
2855 if (resolved_dies.find(die.GetDIE()) == resolved_dies.end() && ResolveFunction (die, include_inlines, sc_list))
2857 bool keep_die = true;
2858 if ((name_type_mask & (eFunctionNameTypeBase|eFunctionNameTypeMethod)) != (eFunctionNameTypeBase|eFunctionNameTypeMethod))
2860 // We are looking for either basenames or methods, so we need to
2861 // trim out the ones we won't want by looking at the type
2863 if (sc_list.GetLastContext(sc))
2867 // We have an inlined function
2869 else if (sc.function)
2871 Type *type = sc.function->GetType();
2875 CompilerDeclContext decl_ctx = GetDeclContextContainingUID (type->GetID());
2876 if (decl_ctx.IsStructUnionOrClass())
2878 if (name_type_mask & eFunctionNameTypeBase)
2880 sc_list.RemoveContextAtIndex(sc_list.GetSize()-1);
2886 if (name_type_mask & eFunctionNameTypeMethod)
2888 sc_list.RemoveContextAtIndex(sc_list.GetSize()-1);
2895 GetObjectFile()->GetModule()->ReportWarning ("function at die offset 0x%8.8x had no function type",
2896 die_ref.die_offset);
2902 resolved_dies.insert(die.GetDIE());
2907 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')",
2908 die_ref.die_offset, name_cstr);
2911 die_offsets.clear();
2918 // Index the DWARF if we haven't already
2922 if (name_type_mask & eFunctionNameTypeFull)
2924 FindFunctions (name, m_function_fullname_index, include_inlines, sc_list);
2926 // FIXME Temporary workaround for global/anonymous namespace
2927 // functions debugging FreeBSD and Linux binaries.
2928 // If we didn't find any functions in the global namespace try
2929 // looking in the basename index but ignore any returned
2930 // functions that have a namespace but keep functions which
2931 // have an anonymous namespace
2932 // TODO: The arch in the object file isn't correct for MSVC
2933 // binaries on windows, we should find a way to make it
2934 // correct and handle those symbols as well.
2935 if (sc_list.GetSize() == original_size)
2938 if (!parent_decl_ctx &&
2939 GetObjectFile()->GetArchitecture(arch) &&
2940 (arch.GetTriple().isOSFreeBSD() || arch.GetTriple().isOSLinux() ||
2941 arch.GetMachine() == llvm::Triple::hexagon))
2943 SymbolContextList temp_sc_list;
2944 FindFunctions (name, m_function_basename_index, include_inlines, temp_sc_list);
2946 for (uint32_t i = 0; i < temp_sc_list.GetSize(); i++)
2948 if (temp_sc_list.GetContextAtIndex(i, sc))
2950 ConstString mangled_name = sc.GetFunctionName(Mangled::ePreferMangled);
2951 ConstString demangled_name = sc.GetFunctionName(Mangled::ePreferDemangled);
2952 // Mangled names on Linux and FreeBSD are of the form:
2953 // _ZN18function_namespace13function_nameEv.
2954 if (strncmp(mangled_name.GetCString(), "_ZN", 3) ||
2955 !strncmp(demangled_name.GetCString(), "(anonymous namespace)", 21))
2964 DIEArray die_offsets;
2965 if (name_type_mask & eFunctionNameTypeBase)
2967 uint32_t num_base = m_function_basename_index.Find(name, die_offsets);
2968 for (uint32_t i = 0; i < num_base; i++)
2970 DWARFDIE die = info->GetDIE (die_offsets[i]);
2973 if (!DIEInDeclContext(parent_decl_ctx, die))
2974 continue; // The containing decl contexts don't match
2976 // If we get to here, the die is good, and we should add it:
2977 if (resolved_dies.find(die.GetDIE()) == resolved_dies.end())
2979 if (ResolveFunction (die, include_inlines, sc_list))
2980 resolved_dies.insert(die.GetDIE());
2984 die_offsets.clear();
2987 if (name_type_mask & eFunctionNameTypeMethod)
2989 if (parent_decl_ctx && parent_decl_ctx->IsValid())
2990 return 0; // no methods in namespaces
2992 uint32_t num_base = m_function_method_index.Find(name, die_offsets);
2994 for (uint32_t i = 0; i < num_base; i++)
2996 DWARFDIE die = info->GetDIE (die_offsets[i]);
2999 // If we get to here, the die is good, and we should add it:
3000 if (resolved_dies.find(die.GetDIE()) == resolved_dies.end())
3002 if (ResolveFunction (die, include_inlines, sc_list))
3003 resolved_dies.insert(die.GetDIE());
3008 die_offsets.clear();
3011 if ((name_type_mask & eFunctionNameTypeSelector) && (!parent_decl_ctx || !parent_decl_ctx->IsValid()))
3013 FindFunctions (name, m_function_selector_index, include_inlines, sc_list);
3018 // Return the number of variable that were appended to the list
3019 const uint32_t num_matches = sc_list.GetSize() - original_size;
3021 if (log && num_matches > 0)
3023 GetObjectFile()->GetModule()->LogMessage (log,
3024 "SymbolFileDWARF::FindFunctions (name=\"%s\", name_type_mask=0x%x, include_inlines=%d, append=%u, sc_list) => %u",
3035 SymbolFileDWARF::FindFunctions(const RegularExpression& regex, bool include_inlines, bool append, SymbolContextList& sc_list)
3037 Timer scoped_timer (__PRETTY_FUNCTION__,
3038 "SymbolFileDWARF::FindFunctions (regex = '%s')",
3041 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
3045 GetObjectFile()->GetModule()->LogMessage (log,
3046 "SymbolFileDWARF::FindFunctions (regex=\"%s\", append=%u, sc_list)",
3052 // If we aren't appending the results to this list, then clear the list
3056 // Remember how many sc_list are in the list before we search in case
3057 // we are appending the results to a variable list.
3058 uint32_t original_size = sc_list.GetSize();
3060 if (m_using_apple_tables)
3062 if (m_apple_names_ap.get())
3063 FindFunctions (regex, *m_apple_names_ap, include_inlines, sc_list);
3067 // Index the DWARF if we haven't already
3071 FindFunctions (regex, m_function_basename_index, include_inlines, sc_list);
3073 FindFunctions (regex, m_function_fullname_index, include_inlines, sc_list);
3076 // Return the number of variable that were appended to the list
3077 return sc_list.GetSize() - original_size;
3081 SymbolFileDWARF::GetMangledNamesForFunction (const std::string &scope_qualified_name,
3082 std::vector<ConstString> &mangled_names)
3084 DWARFDebugInfo* info = DebugInfo();
3085 uint32_t num_comp_units = 0;
3087 num_comp_units = info->GetNumCompileUnits();
3089 for (uint32_t i = 0; i < num_comp_units; i++)
3091 DWARFCompileUnit *cu = info->GetCompileUnitAtIndex(i);
3095 SymbolFileDWARFDwo *dwo = cu->GetDwoSymbolFile();
3097 dwo->GetMangledNamesForFunction(scope_qualified_name, mangled_names);
3100 NameToOffsetMap::iterator iter = m_function_scope_qualified_name_map.find(scope_qualified_name);
3101 if (iter == m_function_scope_qualified_name_map.end())
3104 DIERefSetSP set_sp = (*iter).second;
3105 std::set<DIERef>::iterator set_iter;
3106 for (set_iter = set_sp->begin(); set_iter != set_sp->end(); set_iter++)
3108 DWARFDIE die = DebugInfo()->GetDIE (*set_iter);
3109 mangled_names.push_back(ConstString(die.GetMangledName()));
3115 SymbolFileDWARF::FindTypes (const SymbolContext& sc,
3116 const ConstString &name,
3117 const CompilerDeclContext *parent_decl_ctx,
3119 uint32_t max_matches,
3120 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
3123 // If we aren't appending the results to this list, then clear the list
3127 // Make sure we haven't already searched this SymbolFile before...
3128 if (searched_symbol_files.count(this))
3131 searched_symbol_files.insert(this);
3133 DWARFDebugInfo* info = DebugInfo();
3137 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
3141 if (parent_decl_ctx)
3142 GetObjectFile()->GetModule()->LogMessage (log,
3143 "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = %p (\"%s\"), append=%u, max_matches=%u, type_list)",
3145 static_cast<const void*>(parent_decl_ctx),
3146 parent_decl_ctx->GetName().AsCString("<NULL>"),
3147 append, max_matches);
3149 GetObjectFile()->GetModule()->LogMessage (log,
3150 "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = NULL, append=%u, max_matches=%u, type_list)",
3151 name.GetCString(), append,
3155 if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
3158 DIEArray die_offsets;
3160 if (m_using_apple_tables)
3162 if (m_apple_types_ap.get())
3164 const char *name_cstr = name.GetCString();
3165 m_apple_types_ap->FindByName (name_cstr, die_offsets);
3173 m_type_index.Find (name, die_offsets);
3176 const size_t num_die_matches = die_offsets.size();
3178 if (num_die_matches)
3180 const uint32_t initial_types_size = types.GetSize();
3181 for (size_t i=0; i<num_die_matches; ++i)
3183 const DIERef& die_ref = die_offsets[i];
3184 DWARFDIE die = GetDIE (die_ref);
3188 if (!DIEInDeclContext(parent_decl_ctx, die))
3189 continue; // The containing decl contexts don't match
3191 Type *matching_type = ResolveType (die, true, true);
3194 // We found a type pointer, now find the shared pointer form our type list
3195 types.InsertUnique (matching_type->shared_from_this());
3196 if (types.GetSize() >= max_matches)
3202 if (m_using_apple_tables)
3204 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n",
3205 die_ref.die_offset, name.GetCString());
3210 const uint32_t num_matches = types.GetSize() - initial_types_size;
3211 if (log && num_matches)
3213 if (parent_decl_ctx)
3215 GetObjectFile()->GetModule()->LogMessage (log,
3216 "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = %p (\"%s\"), append=%u, max_matches=%u, type_list) => %u",
3218 static_cast<const void*>(parent_decl_ctx),
3219 parent_decl_ctx->GetName().AsCString("<NULL>"),
3220 append, max_matches,
3225 GetObjectFile()->GetModule()->LogMessage (log,
3226 "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = NULL, append=%u, max_matches=%u, type_list) => %u",
3228 append, max_matches,
3236 UpdateExternalModuleListIfNeeded();
3238 for (const auto &pair : m_external_type_modules)
3240 ModuleSP external_module_sp = pair.second;
3241 if (external_module_sp)
3243 SymbolVendor *sym_vendor = external_module_sp->GetSymbolVendor();
3246 const uint32_t num_external_matches = sym_vendor->FindTypes (sc,
3251 searched_symbol_files,
3253 if (num_external_matches)
3254 return num_external_matches;
3265 SymbolFileDWARF::FindTypes (const std::vector<CompilerContext> &context,
3272 if (context.empty())
3275 DIEArray die_offsets;
3277 ConstString name = context.back().name;
3282 if (m_using_apple_tables)
3284 if (m_apple_types_ap.get())
3286 const char *name_cstr = name.GetCString();
3287 m_apple_types_ap->FindByName (name_cstr, die_offsets);
3295 m_type_index.Find (name, die_offsets);
3298 const size_t num_die_matches = die_offsets.size();
3300 if (num_die_matches)
3302 size_t num_matches = 0;
3303 for (size_t i=0; i<num_die_matches; ++i)
3305 const DIERef& die_ref = die_offsets[i];
3306 DWARFDIE die = GetDIE (die_ref);
3310 std::vector<CompilerContext> die_context;
3311 die.GetDWOContext(die_context);
3312 if (die_context != context)
3315 Type *matching_type = ResolveType (die, true, true);
3318 // We found a type pointer, now find the shared pointer form our type list
3319 types.InsertUnique (matching_type->shared_from_this());
3325 if (m_using_apple_tables)
3327 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n",
3328 die_ref.die_offset, name.GetCString());
3340 SymbolFileDWARF::FindNamespace (const SymbolContext& sc,
3341 const ConstString &name,
3342 const CompilerDeclContext *parent_decl_ctx)
3344 Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
3348 GetObjectFile()->GetModule()->LogMessage (log,
3349 "SymbolFileDWARF::FindNamespace (sc, name=\"%s\")",
3353 CompilerDeclContext namespace_decl_ctx;
3355 if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
3356 return namespace_decl_ctx;
3359 DWARFDebugInfo* info = DebugInfo();
3362 DIEArray die_offsets;
3364 // Index if we already haven't to make sure the compile units
3365 // get indexed and make their global DIE index list
3366 if (m_using_apple_tables)
3368 if (m_apple_namespaces_ap.get())
3370 const char *name_cstr = name.GetCString();
3371 m_apple_namespaces_ap->FindByName (name_cstr, die_offsets);
3379 m_namespace_index.Find (name, die_offsets);
3382 const size_t num_matches = die_offsets.size();
3385 for (size_t i=0; i<num_matches; ++i)
3387 const DIERef& die_ref = die_offsets[i];
3388 DWARFDIE die = GetDIE (die_ref);
3392 if (!DIEInDeclContext (parent_decl_ctx, die))
3393 continue; // The containing decl contexts don't match
3395 DWARFASTParser *dwarf_ast = die.GetDWARFParser();
3398 namespace_decl_ctx = dwarf_ast->GetDeclContextForUIDFromDWARF (die);
3399 if (namespace_decl_ctx)
3405 if (m_using_apple_tables)
3407 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_namespaces accelerator table had bad die 0x%8.8x for '%s')\n",
3408 die_ref.die_offset, name.GetCString());
3415 if (log && namespace_decl_ctx)
3417 GetObjectFile()->GetModule()->LogMessage (log,
3418 "SymbolFileDWARF::FindNamespace (sc, name=\"%s\") => CompilerDeclContext(%p/%p) \"%s\"",
3420 static_cast<const void*>(namespace_decl_ctx.GetTypeSystem()),
3421 static_cast<const void*>(namespace_decl_ctx.GetOpaqueDeclContext()),
3422 namespace_decl_ctx.GetName().AsCString("<NULL>"));
3425 return namespace_decl_ctx;
3429 SymbolFileDWARF::GetTypeForDIE (const DWARFDIE &die, bool resolve_function_context)
3434 Type *type_ptr = GetDIEToType().lookup (die.GetDIE());
3435 if (type_ptr == NULL)
3437 CompileUnit* lldb_cu = GetCompUnitForDWARFCompUnit(die.GetCU());
3439 SymbolContext sc(lldb_cu);
3440 const DWARFDebugInfoEntry* parent_die = die.GetParent().GetDIE();
3441 while (parent_die != nullptr)
3443 if (parent_die->Tag() == DW_TAG_subprogram)
3445 parent_die = parent_die->GetParent();
3447 SymbolContext sc_backup = sc;
3448 if (resolve_function_context && parent_die != nullptr && !GetFunction(DWARFDIE(die.GetCU(),parent_die), sc))
3451 type_sp = ParseType(sc, die, NULL);
3453 else if (type_ptr != DIE_IS_BEING_PARSED)
3455 // Grab the existing type from the master types lists
3456 type_sp = type_ptr->shared_from_this();
3465 SymbolFileDWARF::GetDeclContextDIEContainingDIE (const DWARFDIE &orig_die)
3469 DWARFDIE die = orig_die;
3473 // If this is the original DIE that we are searching for a declaration
3474 // for, then don't look in the cache as we don't want our own decl
3475 // context to be our decl context...
3476 if (orig_die != die)
3480 case DW_TAG_compile_unit:
3481 case DW_TAG_namespace:
3482 case DW_TAG_structure_type:
3483 case DW_TAG_union_type:
3484 case DW_TAG_class_type:
3485 case DW_TAG_lexical_block:
3486 case DW_TAG_subprogram:
3494 DWARFDIE spec_die = die.GetReferencedDIE(DW_AT_specification);
3497 DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(spec_die);
3499 return decl_ctx_die;
3502 DWARFDIE abs_die = die.GetReferencedDIE(DW_AT_abstract_origin);
3505 DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(abs_die);
3507 return decl_ctx_die;
3510 die = die.GetParent();
3518 SymbolFileDWARF::GetObjCClassSymbol (const ConstString &objc_class_name)
3520 Symbol *objc_class_symbol = NULL;
3523 Symtab *symtab = m_obj_file->GetSymtab ();
3526 objc_class_symbol = symtab->FindFirstSymbolWithNameAndType (objc_class_name,
3527 eSymbolTypeObjCClass,
3529 Symtab::eVisibilityAny);
3532 return objc_class_symbol;
3535 // Some compilers don't emit the DW_AT_APPLE_objc_complete_type attribute. If they don't
3536 // then we can end up looking through all class types for a complete type and never find
3537 // the full definition. We need to know if this attribute is supported, so we determine
3538 // this here and cache th result. We also need to worry about the debug map DWARF file
3539 // if we are doing darwin DWARF in .o file debugging.
3541 SymbolFileDWARF::Supports_DW_AT_APPLE_objc_complete_type (DWARFCompileUnit *cu)
3543 if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolCalculate)
3545 m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolNo;
3546 if (cu && cu->Supports_DW_AT_APPLE_objc_complete_type())
3547 m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes;
3550 DWARFDebugInfo* debug_info = DebugInfo();
3551 const uint32_t num_compile_units = GetNumCompileUnits();
3552 for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx)
3554 DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
3555 if (dwarf_cu != cu && dwarf_cu->Supports_DW_AT_APPLE_objc_complete_type())
3557 m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes;
3562 if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolNo && GetDebugMapSymfile ())
3563 return m_debug_map_symfile->Supports_DW_AT_APPLE_objc_complete_type (this);
3565 return m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolYes;
3568 // This function can be used when a DIE is found that is a forward declaration
3569 // DIE and we want to try and find a type that has the complete definition.
3571 SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE (const DWARFDIE &die,
3572 const ConstString &type_name,
3573 bool must_be_implementation)
3578 if (!type_name || (must_be_implementation && !GetObjCClassSymbol (type_name)))
3581 DIEArray die_offsets;
3583 if (m_using_apple_tables)
3585 if (m_apple_types_ap.get())
3587 const char *name_cstr = type_name.GetCString();
3588 m_apple_types_ap->FindCompleteObjCClassByName (name_cstr, die_offsets, must_be_implementation);
3596 m_type_index.Find (type_name, die_offsets);
3599 const size_t num_matches = die_offsets.size();
3603 for (size_t i=0; i<num_matches; ++i)
3605 const DIERef& die_ref = die_offsets[i];
3606 DWARFDIE type_die = GetDIE (die_ref);
3610 bool try_resolving_type = false;
3612 // Don't try and resolve the DIE we are looking for with the DIE itself!
3613 if (type_die != die)
3615 switch (type_die.Tag())
3617 case DW_TAG_class_type:
3618 case DW_TAG_structure_type:
3619 try_resolving_type = true;
3626 if (try_resolving_type)
3628 if (must_be_implementation && type_die.Supports_DW_AT_APPLE_objc_complete_type())
3629 try_resolving_type = type_die.GetAttributeValueAsUnsigned (DW_AT_APPLE_objc_complete_type, 0);
3631 if (try_resolving_type)
3633 Type *resolved_type = ResolveType (type_die, false, true);
3634 if (resolved_type && resolved_type != DIE_IS_BEING_PARSED)
3636 DEBUG_PRINTF ("resolved 0x%8.8" PRIx64 " from %s to 0x%8.8" PRIx64 " (cu 0x%8.8" PRIx64 ")\n",
3638 m_obj_file->GetFileSpec().GetFilename().AsCString("<Unknown>"),
3643 GetDIEToType()[die.GetDIE()] = resolved_type;
3644 type_sp = resolved_type->shared_from_this();
3652 if (m_using_apple_tables)
3654 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n",
3655 die_ref.die_offset, type_name.GetCString());
3665 //----------------------------------------------------------------------
3666 // This function helps to ensure that the declaration contexts match for
3667 // two different DIEs. Often times debug information will refer to a
3668 // forward declaration of a type (the equivalent of "struct my_struct;".
3669 // There will often be a declaration of that type elsewhere that has the
3670 // full definition. When we go looking for the full type "my_struct", we
3671 // will find one or more matches in the accelerator tables and we will
3672 // then need to make sure the type was in the same declaration context
3673 // as the original DIE. This function can efficiently compare two DIEs
3674 // and will return true when the declaration context matches, and false
3676 //----------------------------------------------------------------------
3678 SymbolFileDWARF::DIEDeclContextsMatch (const DWARFDIE &die1,
3679 const DWARFDIE &die2)
3684 DWARFDIECollection decl_ctx_1;
3685 DWARFDIECollection decl_ctx_2;
3686 //The declaration DIE stack is a stack of the declaration context
3687 // DIEs all the way back to the compile unit. If a type "T" is
3688 // declared inside a class "B", and class "B" is declared inside
3689 // a class "A" and class "A" is in a namespace "lldb", and the
3690 // namespace is in a compile unit, there will be a stack of DIEs:
3692 // [0] DW_TAG_class_type for "B"
3693 // [1] DW_TAG_class_type for "A"
3694 // [2] DW_TAG_namespace for "lldb"
3695 // [3] DW_TAG_compile_unit for the source file.
3697 // We grab both contexts and make sure that everything matches
3698 // all the way back to the compiler unit.
3700 // First lets grab the decl contexts for both DIEs
3701 die1.GetDeclContextDIEs (decl_ctx_1);
3702 die2.GetDeclContextDIEs (decl_ctx_2);
3703 // Make sure the context arrays have the same size, otherwise
3705 const size_t count1 = decl_ctx_1.Size();
3706 const size_t count2 = decl_ctx_2.Size();
3707 if (count1 != count2)
3710 // Make sure the DW_TAG values match all the way back up the
3711 // compile unit. If they don't, then we are done.
3712 DWARFDIE decl_ctx_die1;
3713 DWARFDIE decl_ctx_die2;
3715 for (i=0; i<count1; i++)
3717 decl_ctx_die1 = decl_ctx_1.GetDIEAtIndex (i);
3718 decl_ctx_die2 = decl_ctx_2.GetDIEAtIndex (i);
3719 if (decl_ctx_die1.Tag() != decl_ctx_die2.Tag())
3722 #if defined LLDB_CONFIGURATION_DEBUG
3724 // Make sure the top item in the decl context die array is always
3725 // DW_TAG_compile_unit. If it isn't then something went wrong in
3726 // the DWARFDIE::GetDeclContextDIEs() function...
3727 assert (decl_ctx_1.GetDIEAtIndex (count1 - 1).Tag() == DW_TAG_compile_unit);
3730 // Always skip the compile unit when comparing by only iterating up to
3731 // "count - 1". Here we compare the names as we go.
3732 for (i=0; i<count1 - 1; i++)
3734 decl_ctx_die1 = decl_ctx_1.GetDIEAtIndex (i);
3735 decl_ctx_die2 = decl_ctx_2.GetDIEAtIndex (i);
3736 const char *name1 = decl_ctx_die1.GetName();
3737 const char *name2 = decl_ctx_die2.GetName();
3738 // If the string was from a DW_FORM_strp, then the pointer will often
3743 // Name pointers are not equal, so only compare the strings
3744 // if both are not NULL.
3747 // If the strings don't compare, we are done...
3748 if (strcmp(name1, name2) != 0)
3753 // One name was NULL while the other wasn't
3757 // We made it through all of the checks and the declaration contexts
3764 SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext (const DWARFDeclContext &dwarf_decl_ctx)
3768 const uint32_t dwarf_decl_ctx_count = dwarf_decl_ctx.GetSize();
3769 if (dwarf_decl_ctx_count > 0)
3771 const ConstString type_name(dwarf_decl_ctx[0].name);
3772 const dw_tag_t tag = dwarf_decl_ctx[0].tag;
3776 Log *log (LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION|DWARF_LOG_LOOKUPS));
3779 GetObjectFile()->GetModule()->LogMessage (log,
3780 "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%s, qualified-name='%s')",
3781 DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
3782 dwarf_decl_ctx.GetQualifiedName());
3785 DIEArray die_offsets;
3787 if (m_using_apple_tables)
3789 if (m_apple_types_ap.get())
3791 const bool has_tag = m_apple_types_ap->GetHeader().header_data.ContainsAtom (DWARFMappedHash::eAtomTypeTag);
3792 const bool has_qualified_name_hash = m_apple_types_ap->GetHeader().header_data.ContainsAtom (DWARFMappedHash::eAtomTypeQualNameHash);
3793 if (has_tag && has_qualified_name_hash)
3795 const char *qualified_name = dwarf_decl_ctx.GetQualifiedName();
3796 const uint32_t qualified_name_hash = MappedHash::HashStringUsingDJB (qualified_name);
3798 GetObjectFile()->GetModule()->LogMessage (log,"FindByNameAndTagAndQualifiedNameHash()");
3799 m_apple_types_ap->FindByNameAndTagAndQualifiedNameHash (type_name.GetCString(), tag, qualified_name_hash, die_offsets);
3804 GetObjectFile()->GetModule()->LogMessage (log,"FindByNameAndTag()");
3805 m_apple_types_ap->FindByNameAndTag (type_name.GetCString(), tag, die_offsets);
3809 m_apple_types_ap->FindByName (type_name.GetCString(), die_offsets);
3818 m_type_index.Find (type_name, die_offsets);
3821 const size_t num_matches = die_offsets.size();
3823 // Get the type system that we are looking to find a type for. We will use this
3824 // to ensure any matches we find are in a language that this type system supports
3825 const LanguageType language = dwarf_decl_ctx.GetLanguage();
3826 TypeSystem *type_system = (language == eLanguageTypeUnknown) ? nullptr : GetTypeSystemForLanguage(language);
3830 for (size_t i=0; i<num_matches; ++i)
3832 const DIERef& die_ref = die_offsets[i];
3833 DWARFDIE type_die = GetDIE (die_ref);
3837 // Make sure type_die's langauge matches the type system we are looking for.
3838 // We don't want to find a "Foo" type from Java if we are looking for a "Foo"
3839 // type for C, C++, ObjC, or ObjC++.
3840 if (type_system && !type_system->SupportsLanguage(type_die.GetLanguage()))
3842 bool try_resolving_type = false;
3844 // Don't try and resolve the DIE we are looking for with the DIE itself!
3845 const dw_tag_t type_tag = type_die.Tag();
3846 // Make sure the tags match
3847 if (type_tag == tag)
3849 // The tags match, lets try resolving this type
3850 try_resolving_type = true;
3854 // The tags don't match, but we need to watch our for a
3855 // forward declaration for a struct and ("struct foo")
3856 // ends up being a class ("class foo { ... };") or
3860 case DW_TAG_class_type:
3861 // We had a "class foo", see if we ended up with a "struct foo { ... };"
3862 try_resolving_type = (tag == DW_TAG_structure_type);
3864 case DW_TAG_structure_type:
3865 // We had a "struct foo", see if we ended up with a "class foo { ... };"
3866 try_resolving_type = (tag == DW_TAG_class_type);
3869 // Tags don't match, don't event try to resolve
3870 // using this type whose name matches....
3875 if (try_resolving_type)
3877 DWARFDeclContext type_dwarf_decl_ctx;
3878 type_die.GetDWARFDeclContext (type_dwarf_decl_ctx);
3882 GetObjectFile()->GetModule()->LogMessage (log,
3883 "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%s, qualified-name='%s') trying die=0x%8.8x (%s)",
3884 DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
3885 dwarf_decl_ctx.GetQualifiedName(),
3886 type_die.GetOffset(),
3887 type_dwarf_decl_ctx.GetQualifiedName());
3890 // Make sure the decl contexts match all the way up
3891 if (dwarf_decl_ctx == type_dwarf_decl_ctx)
3893 Type *resolved_type = ResolveType (type_die, false);
3894 if (resolved_type && resolved_type != DIE_IS_BEING_PARSED)
3896 type_sp = resolved_type->shared_from_this();
3905 std::string qualified_name;
3906 type_die.GetQualifiedName(qualified_name);
3907 GetObjectFile()->GetModule()->LogMessage (log,
3908 "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%s, qualified-name='%s') ignoring die=0x%8.8x (%s)",
3909 DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
3910 dwarf_decl_ctx.GetQualifiedName(),
3911 type_die.GetOffset(),
3912 qualified_name.c_str());
3918 if (m_using_apple_tables)
3920 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n",
3921 die_ref.die_offset, type_name.GetCString());
3933 SymbolFileDWARF::ParseType (const SymbolContext& sc, const DWARFDIE &die, bool *type_is_new_ptr)
3939 TypeSystem *type_system = GetTypeSystemForLanguage(die.GetCU()->GetLanguageType());
3943 DWARFASTParser *dwarf_ast = type_system->GetDWARFParser();
3946 Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
3947 type_sp = dwarf_ast->ParseTypeFromDWARF (sc, die, log, type_is_new_ptr);
3950 TypeList* type_list = GetTypeList();
3952 type_list->Insert(type_sp);
3954 if (die.Tag() == DW_TAG_subprogram)
3956 DIERef die_ref = die.GetDIERef();
3957 std::string scope_qualified_name(GetDeclContextForUID(die.GetID()).GetScopeQualifiedName().AsCString(""));
3958 if (scope_qualified_name.size())
3960 NameToOffsetMap::iterator iter = m_function_scope_qualified_name_map.find(scope_qualified_name);
3961 if (iter != m_function_scope_qualified_name_map.end())
3962 (*iter).second->insert(die_ref);
3965 DIERefSetSP new_set(new std::set<DIERef>);
3966 new_set->insert(die_ref);
3967 m_function_scope_qualified_name_map.emplace(std::make_pair(scope_qualified_name, new_set));
3980 SymbolFileDWARF::ParseTypes
3982 const SymbolContext& sc,
3983 const DWARFDIE &orig_die,
3984 bool parse_siblings,
3988 size_t types_added = 0;
3989 DWARFDIE die = orig_die;
3992 bool type_is_new = false;
3993 if (ParseType(sc, die, &type_is_new).get())
3999 if (parse_children && die.HasChildren())
4001 if (die.Tag() == DW_TAG_subprogram)
4003 SymbolContext child_sc(sc);
4004 child_sc.function = sc.comp_unit->FindFunctionByUID(die.GetID()).get();
4005 types_added += ParseTypes(child_sc, die.GetFirstChild(), true, true);
4008 types_added += ParseTypes(sc, die.GetFirstChild(), true, true);
4012 die = die.GetSibling();
4021 SymbolFileDWARF::ParseFunctionBlocks (const SymbolContext &sc)
4023 assert(sc.comp_unit && sc.function);
4024 size_t functions_added = 0;
4025 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
4028 const dw_offset_t function_die_offset = sc.function->GetID();
4029 DWARFDIE function_die = dwarf_cu->GetDIE (function_die_offset);
4032 ParseFunctionBlocks(sc, &sc.function->GetBlock (false), function_die, LLDB_INVALID_ADDRESS, 0);
4036 return functions_added;
4041 SymbolFileDWARF::ParseTypes (const SymbolContext &sc)
4043 // At least a compile unit must be valid
4044 assert(sc.comp_unit);
4045 size_t types_added = 0;
4046 DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
4051 dw_offset_t function_die_offset = sc.function->GetID();
4052 DWARFDIE func_die = dwarf_cu->GetDIE(function_die_offset);
4053 if (func_die && func_die.HasChildren())
4055 types_added = ParseTypes(sc, func_die.GetFirstChild(), true, true);
4060 DWARFDIE dwarf_cu_die = dwarf_cu->DIE();
4061 if (dwarf_cu_die && dwarf_cu_die.HasChildren())
4063 types_added = ParseTypes(sc, dwarf_cu_die.GetFirstChild(), true, true);
4072 SymbolFileDWARF::ParseVariablesForContext (const SymbolContext& sc)
4074 if (sc.comp_unit != NULL)
4076 DWARFDebugInfo* info = DebugInfo();
4082 DWARFDIE function_die = info->GetDIE(DIERef(sc.function->GetID(), this));
4084 const dw_addr_t func_lo_pc = function_die.GetAttributeValueAsAddress (DW_AT_low_pc, LLDB_INVALID_ADDRESS);
4085 if (func_lo_pc != LLDB_INVALID_ADDRESS)
4087 const size_t num_variables = ParseVariables(sc, function_die.GetFirstChild(), func_lo_pc, true, true);
4089 // Let all blocks know they have parse all their variables
4090 sc.function->GetBlock (false).SetDidParseVariables (true, true);
4091 return num_variables;
4094 else if (sc.comp_unit)
4096 DWARFCompileUnit* dwarf_cu = info->GetCompileUnit(sc.comp_unit->GetID());
4098 if (dwarf_cu == NULL)
4101 uint32_t vars_added = 0;
4102 VariableListSP variables (sc.comp_unit->GetVariableList(false));
4104 if (variables.get() == NULL)
4106 variables.reset(new VariableList());
4107 sc.comp_unit->SetVariableList(variables);
4109 DIEArray die_offsets;
4110 if (m_using_apple_tables)
4112 if (m_apple_names_ap.get())
4114 DWARFMappedHash::DIEInfoArray hash_data_array;
4115 if (m_apple_names_ap->AppendAllDIEsInRange (dwarf_cu->GetOffset(),
4116 dwarf_cu->GetNextCompileUnitOffset(),
4119 DWARFMappedHash::ExtractDIEArray (hash_data_array, die_offsets);
4125 // Index if we already haven't to make sure the compile units
4126 // get indexed and make their global DIE index list
4130 m_global_index.FindAllEntriesForCompileUnit (dwarf_cu->GetOffset(),
4134 const size_t num_matches = die_offsets.size();
4137 for (size_t i=0; i<num_matches; ++i)
4139 const DIERef& die_ref = die_offsets[i];
4140 DWARFDIE die = GetDIE (die_ref);
4143 VariableSP var_sp (ParseVariableDIE(sc, die, LLDB_INVALID_ADDRESS));
4146 variables->AddVariableIfUnique (var_sp);
4152 if (m_using_apple_tables)
4154 GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x)\n", die_ref.die_offset);
4168 SymbolFileDWARF::ParseVariableDIE
4170 const SymbolContext& sc,
4171 const DWARFDIE &die,
4172 const lldb::addr_t func_low_pc
4175 if (die.GetDWARF() != this)
4176 return die.GetDWARF()->ParseVariableDIE(sc, die, func_low_pc);
4182 var_sp = GetDIEToVariable()[die.GetDIE()];
4184 return var_sp; // Already been parsed!
4186 const dw_tag_t tag = die.Tag();
4187 ModuleSP module = GetObjectFile()->GetModule();
4189 if ((tag == DW_TAG_variable) ||
4190 (tag == DW_TAG_constant) ||
4191 (tag == DW_TAG_formal_parameter && sc.function))
4193 DWARFAttributes attributes;
4194 const size_t num_attributes = die.GetAttributes(attributes);
4196 if (num_attributes > 0)
4198 const char *name = NULL;
4199 const char *mangled = NULL;
4202 DWARFFormValue type_die_form;
4203 DWARFExpression location(die.GetCU());
4204 bool is_external = false;
4205 bool is_artificial = false;
4206 bool location_is_const_value_data = false;
4207 bool has_explicit_location = false;
4208 DWARFFormValue const_value;
4209 Variable::RangeList scope_ranges;
4210 //AccessType accessibility = eAccessNone;
4212 for (i=0; i<num_attributes; ++i)
4214 dw_attr_t attr = attributes.AttributeAtIndex(i);
4215 DWARFFormValue form_value;
4217 if (attributes.ExtractFormValueAtIndex(i, form_value))
4221 case DW_AT_decl_file: decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
4222 case DW_AT_decl_line: decl.SetLine(form_value.Unsigned()); break;
4223 case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
4224 case DW_AT_name: name = form_value.AsCString(); break;
4225 case DW_AT_linkage_name:
4226 case DW_AT_MIPS_linkage_name: mangled = form_value.AsCString(); break;
4227 case DW_AT_type: type_die_form = form_value; break;
4228 case DW_AT_external: is_external = form_value.Boolean(); break;
4229 case DW_AT_const_value:
4230 // If we have already found a DW_AT_location attribute, ignore this attribute.
4231 if (!has_explicit_location)
4233 location_is_const_value_data = true;
4234 // The constant value will be either a block, a data value or a string.
4235 const DWARFDataExtractor& debug_info_data = get_debug_info_data();
4236 if (DWARFFormValue::IsBlockForm(form_value.Form()))
4238 // Retrieve the value as a block expression.
4239 uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart();
4240 uint32_t block_length = form_value.Unsigned();
4241 location.CopyOpcodeData(module, debug_info_data, block_offset, block_length);
4243 else if (DWARFFormValue::IsDataForm(form_value.Form()))
4245 // Retrieve the value as a data expression.
4246 DWARFFormValue::FixedFormSizes fixed_form_sizes =
4247 DWARFFormValue::GetFixedFormSizesForAddressSize (
4248 attributes.CompileUnitAtIndex(i)->GetAddressByteSize(),
4249 attributes.CompileUnitAtIndex(i)->IsDWARF64());
4250 uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
4251 uint32_t data_length = fixed_form_sizes.GetSize(form_value.Form());
4252 if (data_length == 0)
4254 const uint8_t *data_pointer = form_value.BlockData();
4257 form_value.Unsigned();
4259 else if (DWARFFormValue::IsDataForm(form_value.Form()))
4261 // we need to get the byte size of the type later after we create the variable
4262 const_value = form_value;
4266 location.CopyOpcodeData(module, debug_info_data, data_offset, data_length);
4270 // Retrieve the value as a string expression.
4271 if (form_value.Form() == DW_FORM_strp)
4273 DWARFFormValue::FixedFormSizes fixed_form_sizes =
4274 DWARFFormValue::GetFixedFormSizesForAddressSize (
4275 attributes.CompileUnitAtIndex(i)->GetAddressByteSize(),
4276 attributes.CompileUnitAtIndex(i)->IsDWARF64());
4277 uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
4278 uint32_t data_length = fixed_form_sizes.GetSize(form_value.Form());
4279 location.CopyOpcodeData(module, debug_info_data, data_offset, data_length);
4283 const char *str = form_value.AsCString();
4284 uint32_t string_offset = str - (const char *)debug_info_data.GetDataStart();
4285 uint32_t string_length = strlen(str) + 1;
4286 location.CopyOpcodeData(module, debug_info_data, string_offset, string_length);
4291 case DW_AT_location:
4293 location_is_const_value_data = false;
4294 has_explicit_location = true;
4295 if (form_value.BlockData())
4297 const DWARFDataExtractor& debug_info_data = get_debug_info_data();
4299 uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart();
4300 uint32_t block_length = form_value.Unsigned();
4301 location.CopyOpcodeData(module, get_debug_info_data(), block_offset, block_length);
4305 const DWARFDataExtractor& debug_loc_data = get_debug_loc_data();
4306 const dw_offset_t debug_loc_offset = form_value.Unsigned();
4308 size_t loc_list_length = DWARFExpression::LocationListSize(die.GetCU(), debug_loc_data, debug_loc_offset);
4309 if (loc_list_length > 0)
4311 location.CopyOpcodeData(module, debug_loc_data, debug_loc_offset, loc_list_length);
4312 assert (func_low_pc != LLDB_INVALID_ADDRESS);
4313 location.SetLocationListSlide (func_low_pc - attributes.CompileUnitAtIndex(i)->GetBaseAddress());
4318 case DW_AT_specification:
4319 spec_die = GetDIE(DIERef(form_value));
4321 case DW_AT_start_scope:
4323 if (form_value.Form() == DW_FORM_sec_offset)
4325 DWARFRangeList dwarf_scope_ranges;
4326 const DWARFDebugRanges* debug_ranges = DebugRanges();
4327 debug_ranges->FindRanges(form_value.Unsigned(), dwarf_scope_ranges);
4329 // All DW_AT_start_scope are relative to the base address of the
4330 // compile unit. We add the compile unit base address to make
4331 // sure all the addresses are properly fixed up.
4332 for (size_t i = 0, count = dwarf_scope_ranges.GetSize(); i < count; ++i)
4334 const DWARFRangeList::Entry& range = dwarf_scope_ranges.GetEntryRef(i);
4335 scope_ranges.Append(range.GetRangeBase() + die.GetCU()->GetBaseAddress(),
4336 range.GetByteSize());
4341 // TODO: Handle the case when DW_AT_start_scope have form constant. The
4342 // dwarf spec is a bit ambiguous about what is the expected behavior in
4343 // case the enclosing block have a non coninious address range and the
4344 // DW_AT_start_scope entry have a form constant.
4345 GetObjectFile()->GetModule()->ReportWarning ("0x%8.8" PRIx64 ": DW_AT_start_scope has unsupported form type (0x%x)\n",
4350 scope_ranges.Sort();
4351 scope_ranges.CombineConsecutiveRanges();
4354 case DW_AT_artificial: is_artificial = form_value.Boolean(); break;
4355 case DW_AT_accessibility: break; //accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); break;
4356 case DW_AT_declaration:
4357 case DW_AT_description:
4358 case DW_AT_endianity:
4360 case DW_AT_visibility:
4362 case DW_AT_abstract_origin:
4369 const DWARFDIE parent_context_die = GetDeclContextDIEContainingDIE(die);
4370 const dw_tag_t parent_tag = die.GetParent().Tag();
4371 bool is_static_member = parent_tag == DW_TAG_compile_unit && (parent_context_die.Tag() == DW_TAG_class_type || parent_context_die.Tag() == DW_TAG_structure_type);
4373 ValueType scope = eValueTypeInvalid;
4375 const DWARFDIE sc_parent_die = GetParentSymbolContextDIE(die);
4376 SymbolContextScope * symbol_context_scope = NULL;
4380 // LLDB relies on the mangled name (DW_TAG_linkage_name or DW_AT_MIPS_linkage_name) to
4381 // generate fully qualified names of global variables with commands like "frame var j".
4382 // For example, if j were an int variable holding a value 4 and declared in a namespace
4383 // B which in turn is contained in a namespace A, the command "frame var j" returns
4384 // "(int) A::B::j = 4". If the compiler does not emit a linkage name, we should be able
4385 // to generate a fully qualified name from the declaration context.
4386 if (parent_tag == DW_TAG_compile_unit &&
4387 Language::LanguageIsCPlusPlus(die.GetLanguage()))
4389 DWARFDeclContext decl_ctx;
4391 die.GetDWARFDeclContext(decl_ctx);
4392 mangled = decl_ctx.GetQualifiedNameAsConstString().GetCString();
4396 // DWARF doesn't specify if a DW_TAG_variable is a local, global
4397 // or static variable, so we have to do a little digging by
4398 // looking at the location of a variable to see if it contains
4399 // a DW_OP_addr opcode _somewhere_ in the definition. I say
4400 // somewhere because clang likes to combine small global variables
4401 // into the same symbol and have locations like:
4402 // DW_OP_addr(0x1000), DW_OP_constu(2), DW_OP_plus
4403 // So if we don't have a DW_TAG_formal_parameter, we can look at
4404 // the location to see if it contains a DW_OP_addr opcode, and
4405 // then we can correctly classify our variables.
4406 if (tag == DW_TAG_formal_parameter)
4407 scope = eValueTypeVariableArgument;
4410 bool op_error = false;
4411 // Check if the location has a DW_OP_addr with any address value...
4412 lldb::addr_t location_DW_OP_addr = LLDB_INVALID_ADDRESS;
4413 if (!location_is_const_value_data)
4415 location_DW_OP_addr = location.GetLocation_DW_OP_addr (0, op_error);
4419 location.DumpLocationForAddress (&strm, eDescriptionLevelFull, 0, 0, NULL);
4420 GetObjectFile()->GetModule()->ReportError ("0x%8.8x: %s has an invalid location: %s", die.GetOffset(), die.GetTagAsCString(), strm.GetString().c_str());
4423 SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
4425 if (location_DW_OP_addr != LLDB_INVALID_ADDRESS)
4428 scope = eValueTypeVariableGlobal;
4430 scope = eValueTypeVariableStatic;
4432 if (debug_map_symfile)
4434 // When leaving the DWARF in the .o files on darwin,
4435 // when we have a global variable that wasn't initialized,
4436 // the .o file might not have allocated a virtual
4437 // address for the global variable. In this case it will
4438 // have created a symbol for the global variable
4439 // that is undefined/data and external and the value will
4440 // be the byte size of the variable. When we do the
4441 // address map in SymbolFileDWARFDebugMap we rely on
4442 // having an address, we need to do some magic here
4443 // so we can get the correct address for our global
4444 // variable. The address for all of these entries
4445 // will be zero, and there will be an undefined symbol
4446 // in this object file, and the executable will have
4447 // a matching symbol with a good address. So here we
4448 // dig up the correct address and replace it in the
4449 // location for the variable, and set the variable's
4450 // symbol context scope to be that of the main executable
4451 // so the file address will resolve correctly.
4452 bool linked_oso_file_addr = false;
4453 if (is_external && location_DW_OP_addr == 0)
4455 // we have a possible uninitialized extern global
4456 ConstString const_name(mangled ? mangled : name);
4457 ObjectFile *debug_map_objfile = debug_map_symfile->GetObjectFile();
4458 if (debug_map_objfile)
4460 Symtab *debug_map_symtab = debug_map_objfile->GetSymtab();
4461 if (debug_map_symtab)
4463 Symbol *exe_symbol = debug_map_symtab->FindFirstSymbolWithNameAndType (const_name,
4466 Symtab::eVisibilityExtern);
4469 if (exe_symbol->ValueIsAddress())
4471 const addr_t exe_file_addr = exe_symbol->GetAddressRef().GetFileAddress();
4472 if (exe_file_addr != LLDB_INVALID_ADDRESS)
4474 if (location.Update_DW_OP_addr (exe_file_addr))
4476 linked_oso_file_addr = true;
4477 symbol_context_scope = exe_symbol;
4486 if (!linked_oso_file_addr)
4488 // The DW_OP_addr is not zero, but it contains a .o file address which
4489 // needs to be linked up correctly.
4490 const lldb::addr_t exe_file_addr = debug_map_symfile->LinkOSOFileAddress(this, location_DW_OP_addr);
4491 if (exe_file_addr != LLDB_INVALID_ADDRESS)
4493 // Update the file address for this variable
4494 location.Update_DW_OP_addr (exe_file_addr);
4498 // Variable didn't make it into the final executable
4506 if (location_is_const_value_data)
4507 scope = eValueTypeVariableStatic;
4510 scope = eValueTypeVariableLocal;
4511 if (debug_map_symfile)
4513 // We need to check for TLS addresses that we need to fixup
4514 if (location.ContainsThreadLocalStorage())
4516 location.LinkThreadLocalStorage(
4517 debug_map_symfile->GetObjectFile()->GetModule(),
4518 [this, debug_map_symfile](lldb::addr_t unlinked_file_addr) -> lldb::addr_t {
4519 return debug_map_symfile->LinkOSOFileAddress(this, unlinked_file_addr);
4521 scope = eValueTypeVariableThreadLocal;
4528 if (symbol_context_scope == NULL)
4532 case DW_TAG_subprogram:
4533 case DW_TAG_inlined_subroutine:
4534 case DW_TAG_lexical_block:
4537 symbol_context_scope = sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID());
4538 if (symbol_context_scope == NULL)
4539 symbol_context_scope = sc.function;
4544 symbol_context_scope = sc.comp_unit;
4549 if (symbol_context_scope)
4551 SymbolFileTypeSP type_sp(new SymbolFileType(*this, DIERef(type_die_form).GetUID(this)));
4553 if (const_value.Form() && type_sp && type_sp->GetType())
4554 location.CopyOpcodeData(const_value.Unsigned(), type_sp->GetType()->GetByteSize(), die.GetCU()->GetAddressByteSize());
4556 var_sp.reset (new Variable (die.GetID(),
4561 symbol_context_scope,
4569 var_sp->SetLocationIsConstantValueData (location_is_const_value_data);
4573 // Not ready to parse this variable yet. It might be a global
4574 // or static variable that is in a function scope and the function
4575 // in the symbol context wasn't filled in yet
4579 // Cache var_sp even if NULL (the variable was just a specification or
4580 // was missing vital information to be able to be displayed in the debugger
4581 // (missing location due to optimization, etc)) so we don't re-parse
4582 // this DIE over and over later...
4583 GetDIEToVariable()[die.GetDIE()] = var_sp;
4585 GetDIEToVariable()[spec_die.GetDIE()] = var_sp;
4592 SymbolFileDWARF::FindBlockContainingSpecification (const DIERef& func_die_ref,
4593 dw_offset_t spec_block_die_offset)
4595 // Give the concrete function die specified by "func_die_offset", find the
4596 // concrete block whose DW_AT_specification or DW_AT_abstract_origin points
4597 // to "spec_block_die_offset"
4598 return FindBlockContainingSpecification (DebugInfo()->GetDIE (func_die_ref), spec_block_die_offset);
4603 SymbolFileDWARF::FindBlockContainingSpecification(const DWARFDIE &die,
4604 dw_offset_t spec_block_die_offset)
4610 case DW_TAG_subprogram:
4611 case DW_TAG_inlined_subroutine:
4612 case DW_TAG_lexical_block:
4614 if (die.GetAttributeValueAsReference (DW_AT_specification, DW_INVALID_OFFSET) == spec_block_die_offset)
4617 if (die.GetAttributeValueAsReference (DW_AT_abstract_origin, DW_INVALID_OFFSET) == spec_block_die_offset)
4623 // Give the concrete function die specified by "func_die_offset", find the
4624 // concrete block whose DW_AT_specification or DW_AT_abstract_origin points
4625 // to "spec_block_die_offset"
4626 for (DWARFDIE child_die = die.GetFirstChild(); child_die; child_die = child_die.GetSibling())
4628 DWARFDIE result_die = FindBlockContainingSpecification (child_die, spec_block_die_offset);
4638 SymbolFileDWARF::ParseVariables (const SymbolContext& sc,
4639 const DWARFDIE &orig_die,
4640 const lldb::addr_t func_low_pc,
4641 bool parse_siblings,
4642 bool parse_children,
4643 VariableList* cc_variable_list)
4648 VariableListSP variable_list_sp;
4650 size_t vars_added = 0;
4651 DWARFDIE die = orig_die;
4654 dw_tag_t tag = die.Tag();
4656 // Check to see if we have already parsed this variable or constant?
4657 VariableSP var_sp = GetDIEToVariable()[die.GetDIE()];
4660 if (cc_variable_list)
4661 cc_variable_list->AddVariableIfUnique (var_sp);
4665 // We haven't already parsed it, lets do that now.
4666 if ((tag == DW_TAG_variable) ||
4667 (tag == DW_TAG_constant) ||
4668 (tag == DW_TAG_formal_parameter && sc.function))
4670 if (variable_list_sp.get() == NULL)
4672 DWARFDIE sc_parent_die = GetParentSymbolContextDIE(orig_die);
4673 dw_tag_t parent_tag = sc_parent_die.Tag();
4676 case DW_TAG_compile_unit:
4677 if (sc.comp_unit != NULL)
4679 variable_list_sp = sc.comp_unit->GetVariableList(false);
4680 if (variable_list_sp.get() == NULL)
4682 variable_list_sp.reset(new VariableList());
4683 sc.comp_unit->SetVariableList(variable_list_sp);
4688 GetObjectFile()->GetModule()->ReportError ("parent 0x%8.8" PRIx64 " %s with no valid compile unit in symbol context for 0x%8.8" PRIx64 " %s.\n",
4689 sc_parent_die.GetID(),
4690 sc_parent_die.GetTagAsCString(),
4692 orig_die.GetTagAsCString());
4696 case DW_TAG_subprogram:
4697 case DW_TAG_inlined_subroutine:
4698 case DW_TAG_lexical_block:
4699 if (sc.function != NULL)
4701 // Check to see if we already have parsed the variables for the given scope
4703 Block *block = sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID());
4706 // This must be a specification or abstract origin with
4707 // a concrete block counterpart in the current function. We need
4708 // to find the concrete block so we can correctly add the
4710 const DWARFDIE concrete_block_die = FindBlockContainingSpecification (DIERef(sc.function->GetID(), this),
4711 sc_parent_die.GetOffset());
4712 if (concrete_block_die)
4713 block = sc.function->GetBlock(true).FindBlockByID(concrete_block_die.GetID());
4718 const bool can_create = false;
4719 variable_list_sp = block->GetBlockVariableList (can_create);
4720 if (variable_list_sp.get() == NULL)
4722 variable_list_sp.reset(new VariableList());
4723 block->SetVariableList(variable_list_sp);
4730 GetObjectFile()->GetModule()->ReportError ("didn't find appropriate parent DIE for variable list for 0x%8.8" PRIx64 " %s.\n",
4732 orig_die.GetTagAsCString());
4737 if (variable_list_sp)
4739 VariableSP var_sp (ParseVariableDIE(sc, die, func_low_pc));
4742 variable_list_sp->AddVariableIfUnique (var_sp);
4743 if (cc_variable_list)
4744 cc_variable_list->AddVariableIfUnique (var_sp);
4751 bool skip_children = (sc.function == NULL && tag == DW_TAG_subprogram);
4753 if (!skip_children && parse_children && die.HasChildren())
4755 vars_added += ParseVariables(sc, die.GetFirstChild(), func_low_pc, true, true, cc_variable_list);
4759 die = die.GetSibling();
4766 //------------------------------------------------------------------
4767 // PluginInterface protocol
4768 //------------------------------------------------------------------
4770 SymbolFileDWARF::GetPluginName()
4772 return GetPluginNameStatic();
4776 SymbolFileDWARF::GetPluginVersion()
4782 SymbolFileDWARF::DumpIndexes ()
4784 StreamFile s(stdout, false);
4786 s.Printf ("DWARF index for (%s) '%s':",
4787 GetObjectFile()->GetModule()->GetArchitecture().GetArchitectureName(),
4788 GetObjectFile()->GetFileSpec().GetPath().c_str());
4789 s.Printf("\nFunction basenames:\n"); m_function_basename_index.Dump (&s);
4790 s.Printf("\nFunction fullnames:\n"); m_function_fullname_index.Dump (&s);
4791 s.Printf("\nFunction methods:\n"); m_function_method_index.Dump (&s);
4792 s.Printf("\nFunction selectors:\n"); m_function_selector_index.Dump (&s);
4793 s.Printf("\nObjective C class selectors:\n"); m_objc_class_selectors_index.Dump (&s);
4794 s.Printf("\nGlobals and statics:\n"); m_global_index.Dump (&s);
4795 s.Printf("\nTypes:\n"); m_type_index.Dump (&s);
4796 s.Printf("\nNamespaces:\n"); m_namespace_index.Dump (&s);
4800 SymbolFileDWARFDebugMap *
4801 SymbolFileDWARF::GetDebugMapSymfile()
4803 if (m_debug_map_symfile == NULL && !m_debug_map_module_wp.expired())
4805 lldb::ModuleSP module_sp (m_debug_map_module_wp.lock());
4808 SymbolVendor *sym_vendor = module_sp->GetSymbolVendor();
4810 m_debug_map_symfile = (SymbolFileDWARFDebugMap *)sym_vendor->GetSymbolFile();
4813 return m_debug_map_symfile;
4816 DWARFExpression::LocationListFormat
4817 SymbolFileDWARF::GetLocationListFormat() const
4819 return DWARFExpression::RegularLocationList;