LLDB  mainline
SymbolFileDWARF.cpp
Go to the documentation of this file.
1 //===-- SymbolFileDWARF.cpp -----------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "SymbolFileDWARF.h"
10 
11 #include "llvm/ADT/Optional.h"
12 #include "llvm/Support/Casting.h"
13 #include "llvm/Support/Threading.h"
14 
15 #include "lldb/Core/Module.h"
16 #include "lldb/Core/ModuleList.h"
17 #include "lldb/Core/ModuleSpec.h"
19 #include "lldb/Core/Progress.h"
20 #include "lldb/Core/Section.h"
21 #include "lldb/Core/StreamFile.h"
22 #include "lldb/Core/Value.h"
23 #include "lldb/Utility/ArchSpec.h"
24 #include "lldb/Utility/LLDBLog.h"
26 #include "lldb/Utility/Scalar.h"
28 #include "lldb/Utility/Timer.h"
29 
32 
33 #include "lldb/Host/FileSystem.h"
34 #include "lldb/Host/Host.h"
35 
38 
42 #include "lldb/Symbol/Block.h"
47 #include "lldb/Symbol/LineTable.h"
49 #include "lldb/Symbol/ObjectFile.h"
50 #include "lldb/Symbol/SymbolFile.h"
51 #include "lldb/Symbol/TypeMap.h"
52 #include "lldb/Symbol/TypeSystem.h"
54 
55 #include "lldb/Target/Language.h"
56 #include "lldb/Target/Target.h"
57 
58 #include "AppleDWARFIndex.h"
59 #include "DWARFASTParser.h"
60 #include "DWARFASTParserClang.h"
61 #include "DWARFCompileUnit.h"
62 #include "DWARFDebugAbbrev.h"
63 #include "DWARFDebugAranges.h"
64 #include "DWARFDebugInfo.h"
65 #include "DWARFDebugMacro.h"
66 #include "DWARFDebugRanges.h"
67 #include "DWARFDeclContext.h"
68 #include "DWARFFormValue.h"
69 #include "DWARFTypeUnit.h"
70 #include "DWARFUnit.h"
71 #include "DebugNamesDWARFIndex.h"
72 #include "LogChannelDWARF.h"
73 #include "ManualDWARFIndex.h"
75 #include "SymbolFileDWARFDwo.h"
76 
77 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
78 #include "llvm/Support/FileSystem.h"
79 #include "llvm/Support/FormatVariadic.h"
80 
81 #include <algorithm>
82 #include <map>
83 #include <memory>
84 
85 #include <cctype>
86 #include <cstring>
87 
88 //#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN
89 
90 #ifdef ENABLE_DEBUG_PRINTF
91 #include <cstdio>
92 #define DEBUG_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__)
93 #else
94 #define DEBUG_PRINTF(fmt, ...)
95 #endif
96 
97 using namespace lldb;
98 using namespace lldb_private;
99 using namespace lldb_private::dwarf;
100 
102 
104 
105 namespace {
106 
107 #define LLDB_PROPERTIES_symbolfiledwarf
108 #include "SymbolFileDWARFProperties.inc"
109 
110 enum {
111 #define LLDB_PROPERTIES_symbolfiledwarf
112 #include "SymbolFileDWARFPropertiesEnum.inc"
113 };
114 
115 class PluginProperties : public Properties {
116 public:
117  static ConstString GetSettingName() {
119  }
120 
121  PluginProperties() {
122  m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
123  m_collection_sp->Initialize(g_symbolfiledwarf_properties);
124  }
125 
126  bool IgnoreFileIndexes() const {
127  return m_collection_sp->GetPropertyAtIndexAsBoolean(
128  nullptr, ePropertyIgnoreIndexes, false);
129  }
130 };
131 
132 static PluginProperties &GetGlobalPluginProperties() {
133  static PluginProperties g_settings;
134  return g_settings;
135 }
136 
137 } // namespace
138 
139 static const llvm::DWARFDebugLine::LineTable *
141  llvm::DWARFDebugLine &line, dw_offset_t line_offset,
142  dw_offset_t unit_offset) {
143  Log *log = GetLog(DWARFLog::DebugInfo);
144 
145  llvm::DWARFDataExtractor data = context.getOrLoadLineData().GetAsLLVM();
146  llvm::DWARFContext &ctx = context.GetAsLLVM();
147  llvm::Expected<const llvm::DWARFDebugLine::LineTable *> line_table =
148  line.getOrParseLineTable(
149  data, line_offset, ctx, nullptr, [&](llvm::Error e) {
151  log, std::move(e),
152  "SymbolFileDWARF::ParseLineTable failed to parse: {0}");
153  });
154 
155  if (!line_table) {
156  LLDB_LOG_ERROR(log, line_table.takeError(),
157  "SymbolFileDWARF::ParseLineTable failed to parse: {0}");
158  return nullptr;
159  }
160  return *line_table;
161 }
162 
164  llvm::DWARFDebugLine::Prologue &prologue,
165  dw_offset_t line_offset,
166  dw_offset_t unit_offset) {
167  Log *log = GetLog(DWARFLog::DebugInfo);
168  bool success = true;
169  llvm::DWARFDataExtractor data = context.getOrLoadLineData().GetAsLLVM();
170  llvm::DWARFContext &ctx = context.GetAsLLVM();
171  uint64_t offset = line_offset;
172  llvm::Error error = prologue.parse(
173  data, &offset,
174  [&](llvm::Error e) {
175  success = false;
176  LLDB_LOG_ERROR(log, std::move(e),
177  "SymbolFileDWARF::ParseSupportFiles failed to parse "
178  "line table prologue: {0}");
179  },
180  ctx, nullptr);
181  if (error) {
182  LLDB_LOG_ERROR(log, std::move(error),
183  "SymbolFileDWARF::ParseSupportFiles failed to parse line "
184  "table prologue: {0}");
185  return false;
186  }
187  return success;
188 }
189 
190 static llvm::Optional<std::string>
191 GetFileByIndex(const llvm::DWARFDebugLine::Prologue &prologue, size_t idx,
192  llvm::StringRef compile_dir, FileSpec::Style style) {
193  // Try to get an absolute path first.
194  std::string abs_path;
195  auto absolute = llvm::DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath;
196  if (prologue.getFileNameByIndex(idx, compile_dir, absolute, abs_path, style))
197  return std::move(abs_path);
198 
199  // Otherwise ask for a relative path.
200  std::string rel_path;
201  auto relative = llvm::DILineInfoSpecifier::FileLineInfoKind::RawValue;
202  if (!prologue.getFileNameByIndex(idx, compile_dir, relative, rel_path, style))
203  return {};
204  return std::move(rel_path);
205 }
206 
207 static FileSpecList
208 ParseSupportFilesFromPrologue(const lldb::ModuleSP &module,
209  const llvm::DWARFDebugLine::Prologue &prologue,
210  FileSpec::Style style,
211  llvm::StringRef compile_dir = {}) {
212  FileSpecList support_files;
213  size_t first_file = 0;
214  if (prologue.getVersion() <= 4) {
215  // File index 0 is not valid before DWARF v5. Add a dummy entry to ensure
216  // support file list indices match those we get from the debug info and line
217  // tables.
218  support_files.Append(FileSpec());
219  first_file = 1;
220  }
221 
222  const size_t number_of_files = prologue.FileNames.size();
223  for (size_t idx = first_file; idx <= number_of_files; ++idx) {
224  std::string remapped_file;
225  if (auto file_path = GetFileByIndex(prologue, idx, compile_dir, style)) {
226  if (auto remapped = module->RemapSourceFile(llvm::StringRef(*file_path)))
227  remapped_file = *remapped;
228  else
229  remapped_file = std::move(*file_path);
230  }
231 
232  // Unconditionally add an entry, so the indices match up.
233  support_files.EmplaceBack(remapped_file, style);
234  }
235 
236  return support_files;
237 }
238 
240  LogChannelDWARF::Initialize();
241  PluginManager::RegisterPlugin(GetPluginNameStatic(),
242  GetPluginDescriptionStatic(), CreateInstance,
243  DebuggerInitialize);
245 }
246 
248  if (!PluginManager::GetSettingForSymbolFilePlugin(
249  debugger, PluginProperties::GetSettingName())) {
250  const bool is_global_setting = true;
251  PluginManager::CreateSettingForSymbolFilePlugin(
252  debugger, GetGlobalPluginProperties().GetValueProperties(),
253  ConstString("Properties for the dwarf symbol-file plug-in."),
254  is_global_setting);
255  }
256 }
257 
260  PluginManager::UnregisterPlugin(CreateInstance);
261  LogChannelDWARF::Terminate();
262 }
263 
265  return "DWARF and DWARF3 debug symbol file reader.";
266 }
267 
268 SymbolFile *SymbolFileDWARF::CreateInstance(ObjectFileSP objfile_sp) {
269  return new SymbolFileDWARF(std::move(objfile_sp),
270  /*dwo_section_list*/ nullptr);
271 }
272 
274  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
275  if (SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile())
276  return debug_map_symfile->GetTypeList();
277  return SymbolFileCommon::GetTypeList();
278 }
279 void SymbolFileDWARF::GetTypes(const DWARFDIE &die, dw_offset_t min_die_offset,
280  dw_offset_t max_die_offset, uint32_t type_mask,
281  TypeSet &type_set) {
282  if (die) {
283  const dw_offset_t die_offset = die.GetOffset();
284 
285  if (die_offset >= max_die_offset)
286  return;
287 
288  if (die_offset >= min_die_offset) {
289  const dw_tag_t tag = die.Tag();
290 
291  bool add_type = false;
292 
293  switch (tag) {
294  case DW_TAG_array_type:
295  add_type = (type_mask & eTypeClassArray) != 0;
296  break;
297  case DW_TAG_unspecified_type:
298  case DW_TAG_base_type:
299  add_type = (type_mask & eTypeClassBuiltin) != 0;
300  break;
301  case DW_TAG_class_type:
302  add_type = (type_mask & eTypeClassClass) != 0;
303  break;
304  case DW_TAG_structure_type:
305  add_type = (type_mask & eTypeClassStruct) != 0;
306  break;
307  case DW_TAG_union_type:
308  add_type = (type_mask & eTypeClassUnion) != 0;
309  break;
310  case DW_TAG_enumeration_type:
311  add_type = (type_mask & eTypeClassEnumeration) != 0;
312  break;
313  case DW_TAG_subroutine_type:
314  case DW_TAG_subprogram:
315  case DW_TAG_inlined_subroutine:
316  add_type = (type_mask & eTypeClassFunction) != 0;
317  break;
318  case DW_TAG_pointer_type:
319  add_type = (type_mask & eTypeClassPointer) != 0;
320  break;
321  case DW_TAG_rvalue_reference_type:
322  case DW_TAG_reference_type:
323  add_type = (type_mask & eTypeClassReference) != 0;
324  break;
325  case DW_TAG_typedef:
326  add_type = (type_mask & eTypeClassTypedef) != 0;
327  break;
328  case DW_TAG_ptr_to_member_type:
329  add_type = (type_mask & eTypeClassMemberPointer) != 0;
330  break;
331  default:
332  break;
333  }
334 
335  if (add_type) {
336  const bool assert_not_being_parsed = true;
337  Type *type = ResolveTypeUID(die, assert_not_being_parsed);
338  if (type)
339  type_set.insert(type);
340  }
341  }
342 
343  for (DWARFDIE child_die : die.children()) {
344  GetTypes(child_die, min_die_offset, max_die_offset, type_mask, type_set);
345  }
346  }
347 }
348 
350  TypeClass type_mask, TypeList &type_list)
351 
352 {
353  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
354  TypeSet type_set;
355 
356  CompileUnit *comp_unit = nullptr;
357  if (sc_scope)
358  comp_unit = sc_scope->CalculateSymbolContextCompileUnit();
359 
360  const auto &get = [&](DWARFUnit *unit) {
361  if (!unit)
362  return;
363  unit = &unit->GetNonSkeletonUnit();
364  GetTypes(unit->DIE(), unit->GetOffset(), unit->GetNextUnitOffset(),
365  type_mask, type_set);
366  };
367  if (comp_unit) {
368  get(GetDWARFCompileUnit(comp_unit));
369  } else {
370  DWARFDebugInfo &info = DebugInfo();
371  const size_t num_cus = info.GetNumUnits();
372  for (size_t cu_idx = 0; cu_idx < num_cus; ++cu_idx)
373  get(info.GetUnitAtIndex(cu_idx));
374  }
375 
376  std::set<CompilerType> compiler_type_set;
377  for (Type *type : type_set) {
378  CompilerType compiler_type = type->GetForwardCompilerType();
379  if (compiler_type_set.find(compiler_type) == compiler_type_set.end()) {
380  compiler_type_set.insert(compiler_type);
381  type_list.Insert(type->shared_from_this());
382  }
383  }
384 }
385 
386 // Gets the first parent that is a lexical block, function or inlined
387 // subroutine, or compile unit.
388 DWARFDIE
390  DWARFDIE die;
391  for (die = child_die.GetParent(); die; die = die.GetParent()) {
392  dw_tag_t tag = die.Tag();
393 
394  switch (tag) {
395  case DW_TAG_compile_unit:
396  case DW_TAG_partial_unit:
397  case DW_TAG_subprogram:
398  case DW_TAG_inlined_subroutine:
399  case DW_TAG_lexical_block:
400  return die;
401  default:
402  break;
403  }
404  }
405  return DWARFDIE();
406 }
407 
408 SymbolFileDWARF::SymbolFileDWARF(ObjectFileSP objfile_sp,
409  SectionList *dwo_section_list)
410  : SymbolFileCommon(std::move(objfile_sp)),
411  UserID(0x7fffffff00000000), // Used by SymbolFileDWARFDebugMap to
412  // when this class parses .o files to
413  // contain the .o file index/ID
414  m_debug_map_module_wp(), m_debug_map_symfile(nullptr),
415  m_context(m_objfile_sp->GetModule()->GetSectionList(), dwo_section_list),
416  m_fetched_external_modules(false),
417  m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate) {}
418 
420 
422  static ConstString g_dwarf_section_name("__DWARF");
423  return g_dwarf_section_name;
424 }
425 
427  SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
428  if (debug_map_symfile)
429  return debug_map_symfile->GetUniqueDWARFASTTypeMap();
430  else
431  return m_unique_ast_type_map;
432 }
433 
434 llvm::Expected<TypeSystem &>
436  if (SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile())
437  return debug_map_symfile->GetTypeSystemForLanguage(language);
438 
439  auto type_system_or_err =
440  m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
441  if (type_system_or_err) {
442  type_system_or_err->SetSymbolFile(this);
443  }
444  return type_system_or_err;
445 }
446 
448  Log *log = GetLog(DWARFLog::DebugInfo);
449 
451 
452  if (!GetGlobalPluginProperties().IgnoreFileIndexes()) {
453  StreamString module_desc;
454  GetObjectFile()->GetModule()->GetDescription(module_desc.AsRawOstream(),
456  DWARFDataExtractor apple_names, apple_namespaces, apple_types, apple_objc;
461 
462  if (apple_names.GetByteSize() > 0 || apple_namespaces.GetByteSize() > 0 ||
463  apple_types.GetByteSize() > 0 || apple_objc.GetByteSize() > 0) {
464  Progress progress(llvm::formatv("Loading Apple DWARF index for {0}",
465  module_desc.GetData()));
466  m_index = AppleDWARFIndex::Create(
467  *GetObjectFile()->GetModule(), apple_names, apple_namespaces,
468  apple_types, apple_objc, m_context.getOrLoadStrData());
469 
470  if (m_index)
471  return;
472  }
473 
474  DWARFDataExtractor debug_names;
476  if (debug_names.GetByteSize() > 0) {
477  Progress progress(
478  llvm::formatv("Loading DWARF5 index for {0}", module_desc.GetData()));
479  llvm::Expected<std::unique_ptr<DebugNamesDWARFIndex>> index_or =
480  DebugNamesDWARFIndex::Create(*GetObjectFile()->GetModule(),
481  debug_names,
482  m_context.getOrLoadStrData(), *this);
483  if (index_or) {
484  m_index = std::move(*index_or);
485  return;
486  }
487  LLDB_LOG_ERROR(log, index_or.takeError(),
488  "Unable to read .debug_names data: {0}");
489  }
490  }
491 
492  m_index =
493  std::make_unique<ManualDWARFIndex>(*GetObjectFile()->GetModule(), *this);
494 }
495 
498  *m_objfile_sp->GetModule()->GetSectionList());
501 }
502 
504  const lldb_private::SectionList &section_list) {
505  for (SectionSP section_sp : section_list) {
506  if (section_sp->GetChildren().GetSize() > 0) {
507  InitializeFirstCodeAddressRecursive(section_sp->GetChildren());
508  } else if (section_sp->GetType() == eSectionTypeCode) {
510  std::min(m_first_code_address, section_sp->GetFileAddress());
511  }
512  }
513 }
514 
516  return version >= 2 && version <= 5;
517 }
518 
520  uint32_t abilities = 0;
521  if (m_objfile_sp != nullptr) {
522  const Section *section = nullptr;
523  const SectionList *section_list = m_objfile_sp->GetSectionList();
524  if (section_list == nullptr)
525  return 0;
526 
527  uint64_t debug_abbrev_file_size = 0;
528  uint64_t debug_info_file_size = 0;
529  uint64_t debug_line_file_size = 0;
530 
531  section = section_list->FindSectionByName(GetDWARFMachOSegmentName()).get();
532 
533  if (section)
534  section_list = &section->GetChildren();
535 
536  section =
537  section_list->FindSectionByType(eSectionTypeDWARFDebugInfo, true).get();
538  if (section != nullptr) {
539  debug_info_file_size = section->GetFileSize();
540 
541  section =
543  .get();
544  if (section)
545  debug_abbrev_file_size = section->GetFileSize();
546 
547  DWARFDebugAbbrev *abbrev = DebugAbbrev();
548  if (abbrev) {
549  std::set<dw_form_t> invalid_forms;
550  abbrev->GetUnsupportedForms(invalid_forms);
551  if (!invalid_forms.empty()) {
553  error.Printf("unsupported DW_FORM value%s:",
554  invalid_forms.size() > 1 ? "s" : "");
555  for (auto form : invalid_forms)
556  error.Printf(" %#x", form);
557  m_objfile_sp->GetModule()->ReportWarning(
558  "%s", error.GetString().str().c_str());
559  return 0;
560  }
561  }
562 
563  section =
564  section_list->FindSectionByType(eSectionTypeDWARFDebugLine, true)
565  .get();
566  if (section)
567  debug_line_file_size = section->GetFileSize();
568  } else {
569  llvm::StringRef symfile_dir =
570  m_objfile_sp->GetFileSpec().GetDirectory().GetStringRef();
571  if (symfile_dir.contains_insensitive(".dsym")) {
572  if (m_objfile_sp->GetType() == ObjectFile::eTypeDebugInfo) {
573  // We have a dSYM file that didn't have a any debug info. If the
574  // string table has a size of 1, then it was made from an
575  // executable with no debug info, or from an executable that was
576  // stripped.
577  section =
578  section_list->FindSectionByType(eSectionTypeDWARFDebugStr, true)
579  .get();
580  if (section && section->GetFileSize() == 1) {
581  m_objfile_sp->GetModule()->ReportWarning(
582  "empty dSYM file detected, dSYM was created with an "
583  "executable with no debug info.");
584  }
585  }
586  }
587  }
588 
589  if (debug_abbrev_file_size > 0 && debug_info_file_size > 0)
590  abilities |= CompileUnits | Functions | Blocks | GlobalVariables |
592 
593  if (debug_line_file_size > 0)
594  abilities |= LineTables;
595  }
596  return abilities;
597 }
598 
600  DWARFDataExtractor &data) {
601  ModuleSP module_sp(m_objfile_sp->GetModule());
602  const SectionList *section_list = module_sp->GetSectionList();
603  if (!section_list)
604  return;
605 
606  SectionSP section_sp(section_list->FindSectionByType(sect_type, true));
607  if (!section_sp)
608  return;
609 
610  data.Clear();
611  m_objfile_sp->ReadSectionData(section_sp.get(), data);
612 }
613 
615  if (m_abbr)
616  return m_abbr.get();
617 
618  const DWARFDataExtractor &debug_abbrev_data = m_context.getOrLoadAbbrevData();
619  if (debug_abbrev_data.GetByteSize() == 0)
620  return nullptr;
621 
622  auto abbr = std::make_unique<DWARFDebugAbbrev>();
623  llvm::Error error = abbr->parse(debug_abbrev_data);
624  if (error) {
625  Log *log = GetLog(DWARFLog::DebugInfo);
626  LLDB_LOG_ERROR(log, std::move(error),
627  "Unable to read .debug_abbrev section: {0}");
628  return nullptr;
629  }
630 
631  m_abbr = std::move(abbr);
632  return m_abbr.get();
633 }
634 
636  llvm::call_once(m_info_once_flag, [&] {
637  LLDB_SCOPED_TIMERF("%s this = %p", LLVM_PRETTY_FUNCTION,
638  static_cast<void *>(this));
639  m_info = std::make_unique<DWARFDebugInfo>(*this, m_context);
640  });
641  return *m_info;
642 }
643 
645  if (!comp_unit)
646  return nullptr;
647 
648  // The compile unit ID is the index of the DWARF unit.
649  DWARFUnit *dwarf_cu = DebugInfo().GetUnitAtIndex(comp_unit->GetID());
650  if (dwarf_cu && dwarf_cu->GetUserData() == nullptr)
651  dwarf_cu->SetUserData(comp_unit);
652 
653  // It must be DWARFCompileUnit when it created a CompileUnit.
654  return llvm::cast_or_null<DWARFCompileUnit>(dwarf_cu);
655 }
656 
658  if (!m_ranges) {
659  LLDB_SCOPED_TIMERF("%s this = %p", LLVM_PRETTY_FUNCTION,
660  static_cast<void *>(this));
661 
663  m_ranges = std::make_unique<DWARFDebugRanges>();
664 
665  if (m_ranges)
666  m_ranges->Extract(m_context);
667  }
668  return m_ranges.get();
669 }
670 
671 /// Make an absolute path out of \p file_spec and remap it using the
672 /// module's source remapping dictionary.
673 static void MakeAbsoluteAndRemap(FileSpec &file_spec, DWARFUnit &dwarf_cu,
674  const ModuleSP &module_sp) {
675  if (!file_spec)
676  return;
677  // If we have a full path to the compile unit, we don't need to
678  // resolve the file. This can be expensive e.g. when the source
679  // files are NFS mounted.
680  file_spec.MakeAbsolute(dwarf_cu.GetCompilationDirectory());
681 
682  if (auto remapped_file = module_sp->RemapSourceFile(file_spec.GetPath()))
683  file_spec.SetFile(*remapped_file, FileSpec::Style::native);
684 }
685 
686 /// Return the DW_AT_(GNU_)dwo_name.
687 static const char *GetDWOName(DWARFCompileUnit &dwarf_cu,
688  const DWARFDebugInfoEntry &cu_die) {
689  const char *dwo_name =
690  cu_die.GetAttributeValueAsString(&dwarf_cu, DW_AT_GNU_dwo_name, nullptr);
691  if (!dwo_name)
692  dwo_name =
693  cu_die.GetAttributeValueAsString(&dwarf_cu, DW_AT_dwo_name, nullptr);
694  return dwo_name;
695 }
696 
698  CompUnitSP cu_sp;
699  CompileUnit *comp_unit = (CompileUnit *)dwarf_cu.GetUserData();
700  if (comp_unit) {
701  // We already parsed this compile unit, had out a shared pointer to it
702  cu_sp = comp_unit->shared_from_this();
703  } else {
704  if (dwarf_cu.GetOffset() == 0 && GetDebugMapSymfile()) {
705  // Let the debug map create the compile unit
706  cu_sp = m_debug_map_symfile->GetCompileUnit(this);
707  dwarf_cu.SetUserData(cu_sp.get());
708  } else {
709  ModuleSP module_sp(m_objfile_sp->GetModule());
710  if (module_sp) {
711  auto initialize_cu = [&](const FileSpec &file_spec,
712  LanguageType cu_language) {
714  cu_sp = std::make_shared<CompileUnit>(
715  module_sp, &dwarf_cu, file_spec,
716  *GetDWARFUnitIndex(dwarf_cu.GetID()), cu_language,
718 
719  dwarf_cu.SetUserData(cu_sp.get());
720 
721  SetCompileUnitAtIndex(dwarf_cu.GetID(), cu_sp);
722  };
723 
724  auto lazy_initialize_cu = [&]() {
725  // If the version is < 5, we can't do lazy initialization.
726  if (dwarf_cu.GetVersion() < 5)
727  return false;
728 
729  // If there is no DWO, there is no reason to initialize
730  // lazily; we will do eager initialization in that case.
731  if (GetDebugMapSymfile())
732  return false;
733  const DWARFBaseDIE cu_die = dwarf_cu.GetUnitDIEOnly();
734  if (!cu_die)
735  return false;
736  if (!GetDWOName(dwarf_cu, *cu_die.GetDIE()))
737  return false;
738 
739  // With DWARFv5 we can assume that the first support
740  // file is also the name of the compile unit. This
741  // allows us to avoid loading the non-skeleton unit,
742  // which may be in a separate DWO file.
743  FileSpecList support_files;
744  if (!ParseSupportFiles(dwarf_cu, module_sp, support_files))
745  return false;
746  if (support_files.GetSize() == 0)
747  return false;
748 
749  initialize_cu(support_files.GetFileSpecAtIndex(0),
751  cu_sp->SetSupportFiles(std::move(support_files));
752  return true;
753  };
754 
755  if (!lazy_initialize_cu()) {
756  // Eagerly initialize compile unit
757  const DWARFBaseDIE cu_die =
758  dwarf_cu.GetNonSkeletonUnit().GetUnitDIEOnly();
759  if (cu_die) {
761  dwarf_cu.GetDWARFLanguageType());
762 
763  FileSpec cu_file_spec(cu_die.GetName(), dwarf_cu.GetPathStyle());
764 
765  // Path needs to be remapped in this case. In the support files
766  // case ParseSupportFiles takes care of the remapping.
767  MakeAbsoluteAndRemap(cu_file_spec, dwarf_cu, module_sp);
768 
769  initialize_cu(cu_file_spec, cu_language);
770  }
771  }
772  }
773  }
774  }
775  return cu_sp;
776 }
777 
779  if (!m_lldb_cu_to_dwarf_unit.empty())
780  return;
781 
782  DWARFDebugInfo &info = DebugInfo();
783  if (!info.ContainsTypeUnits()) {
784  // We can use a 1-to-1 mapping. No need to build a translation table.
785  return;
786  }
787  for (uint32_t i = 0, num = info.GetNumUnits(); i < num; ++i) {
788  if (auto *cu = llvm::dyn_cast<DWARFCompileUnit>(info.GetUnitAtIndex(i))) {
789  cu->SetID(m_lldb_cu_to_dwarf_unit.size());
790  m_lldb_cu_to_dwarf_unit.push_back(i);
791  }
792  }
793 }
794 
795 llvm::Optional<uint32_t> SymbolFileDWARF::GetDWARFUnitIndex(uint32_t cu_idx) {
797  if (m_lldb_cu_to_dwarf_unit.empty())
798  return cu_idx;
799  if (cu_idx >= m_lldb_cu_to_dwarf_unit.size())
800  return llvm::None;
801  return m_lldb_cu_to_dwarf_unit[cu_idx];
802 }
803 
806  return m_lldb_cu_to_dwarf_unit.empty() ? DebugInfo().GetNumUnits()
807  : m_lldb_cu_to_dwarf_unit.size();
808 }
809 
811  ASSERT_MODULE_LOCK(this);
812  if (llvm::Optional<uint32_t> dwarf_idx = GetDWARFUnitIndex(cu_idx)) {
813  if (auto *dwarf_cu = llvm::cast_or_null<DWARFCompileUnit>(
814  DebugInfo().GetUnitAtIndex(*dwarf_idx)))
815  return ParseCompileUnit(*dwarf_cu);
816  }
817  return {};
818 }
819 
821  const DWARFDIE &die) {
822  ASSERT_MODULE_LOCK(this);
823  if (!die.IsValid())
824  return nullptr;
825 
826  auto type_system_or_err = GetTypeSystemForLanguage(GetLanguage(*die.GetCU()));
827  if (auto err = type_system_or_err.takeError()) {
828  LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
829  "Unable to parse function");
830  return nullptr;
831  }
832  DWARFASTParser *dwarf_ast = type_system_or_err->GetDWARFParser();
833  if (!dwarf_ast)
834  return nullptr;
835 
836  DWARFRangeList ranges;
837  if (die.GetDIE()->GetAttributeAddressRanges(die.GetCU(), ranges,
838  /*check_hi_lo_pc=*/true) == 0)
839  return nullptr;
840 
841  // Union of all ranges in the function DIE (if the function is
842  // discontiguous)
843  lldb::addr_t lowest_func_addr = ranges.GetMinRangeBase(0);
844  lldb::addr_t highest_func_addr = ranges.GetMaxRangeEnd(0);
845  if (lowest_func_addr == LLDB_INVALID_ADDRESS ||
846  lowest_func_addr >= highest_func_addr ||
847  lowest_func_addr < m_first_code_address)
848  return nullptr;
849 
850  ModuleSP module_sp(die.GetModule());
851  AddressRange func_range;
853  lowest_func_addr, module_sp->GetSectionList());
854  if (!func_range.GetBaseAddress().IsValid())
855  return nullptr;
856 
857  func_range.SetByteSize(highest_func_addr - lowest_func_addr);
858  if (!FixupAddress(func_range.GetBaseAddress()))
859  return nullptr;
860 
861  return dwarf_ast->ParseFunctionFromDWARF(comp_unit, die, func_range);
862 }
863 
865  SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
866  if (debug_map_symfile)
867  return debug_map_symfile->LinkOSOFileAddress(this, file_addr);
868  return file_addr;
869 }
870 
872  SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
873  if (debug_map_symfile) {
874  return debug_map_symfile->LinkOSOAddress(addr);
875  }
876  // This is a normal DWARF file, no address fixups need to happen
877  return true;
878 }
880  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
881  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
882  if (dwarf_cu)
883  return GetLanguage(dwarf_cu->GetNonSkeletonUnit());
884  else
885  return eLanguageTypeUnknown;
886 }
887 
889  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
890  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
891  if (!dwarf_cu)
892  return {};
893  const DWARFBaseDIE cu_die = dwarf_cu->GetNonSkeletonUnit().GetUnitDIEOnly();
894  if (!cu_die)
895  return {};
896  const char *sdk = cu_die.GetAttributeValueAsString(DW_AT_APPLE_sdk, nullptr);
897  if (!sdk)
898  return {};
899  const char *sysroot =
900  cu_die.GetAttributeValueAsString(DW_AT_LLVM_sysroot, "");
901  // Register the sysroot path remapping with the module belonging to
902  // the CU as well as the one belonging to the symbol file. The two
903  // would be different if this is an OSO object and module is the
904  // corresponding debug map, in which case both should be updated.
905  ModuleSP module_sp = comp_unit.GetModule();
906  if (module_sp)
907  module_sp->RegisterXcodeSDK(sdk, sysroot);
908 
909  ModuleSP local_module_sp = m_objfile_sp->GetModule();
910  if (local_module_sp && local_module_sp != module_sp)
911  local_module_sp->RegisterXcodeSDK(sdk, sysroot);
912 
913  return {sdk};
914 }
915 
918  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
919  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
920  if (!dwarf_cu)
921  return 0;
922 
923  size_t functions_added = 0;
924  dwarf_cu = &dwarf_cu->GetNonSkeletonUnit();
925  for (DWARFDebugInfoEntry &entry : dwarf_cu->dies()) {
926  if (entry.Tag() != DW_TAG_subprogram)
927  continue;
928 
929  DWARFDIE die(dwarf_cu, &entry);
930  if (comp_unit.FindFunctionByUID(die.GetID()))
931  continue;
932  if (ParseFunction(comp_unit, die))
933  ++functions_added;
934  }
935  // FixupTypes();
936  return functions_added;
937 }
938 
940  CompileUnit &comp_unit,
941  llvm::DenseSet<lldb_private::SymbolFile *> &visited_symbol_files,
942  llvm::function_ref<bool(Module &)> lambda) {
943  // Only visit each symbol file once.
944  if (!visited_symbol_files.insert(this).second)
945  return false;
946 
948  for (auto &p : m_external_type_modules) {
949  ModuleSP module = p.second;
950  if (!module)
951  continue;
952 
953  // Invoke the action and potentially early-exit.
954  if (lambda(*module))
955  return true;
956 
957  for (std::size_t i = 0; i < module->GetNumCompileUnits(); ++i) {
958  auto cu = module->GetCompileUnitAtIndex(i);
959  bool early_exit = cu->ForEachExternalModule(visited_symbol_files, lambda);
960  if (early_exit)
961  return true;
962  }
963  }
964  return false;
965 }
966 
968  FileSpecList &support_files) {
969  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
970  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
971  if (!dwarf_cu)
972  return false;
973 
974  if (!ParseSupportFiles(*dwarf_cu, comp_unit.GetModule(), support_files))
975  return false;
976 
977  comp_unit.SetSupportFiles(support_files);
978  return true;
979 }
980 
982  const ModuleSP &module,
983  FileSpecList &support_files) {
984 
985  dw_offset_t offset = dwarf_cu.GetLineTableOffset();
986  if (offset == DW_INVALID_OFFSET)
987  return false;
988 
990  llvm::DWARFDebugLine::Prologue prologue;
991  if (!ParseLLVMLineTablePrologue(m_context, prologue, offset,
992  dwarf_cu.GetOffset()))
993  return false;
994 
995  support_files = ParseSupportFilesFromPrologue(
996  module, prologue, dwarf_cu.GetPathStyle(),
997  dwarf_cu.GetCompilationDirectory().GetCString());
998 
999  return true;
1000 }
1001 
1003  if (auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(&unit)) {
1004  if (CompileUnit *lldb_cu = GetCompUnitForDWARFCompUnit(*dwarf_cu))
1005  return lldb_cu->GetSupportFiles().GetFileSpecAtIndex(file_idx);
1006  return FileSpec();
1007  }
1008 
1009  auto &tu = llvm::cast<DWARFTypeUnit>(unit);
1010  return GetTypeUnitSupportFiles(tu).GetFileSpecAtIndex(file_idx);
1011 }
1012 
1013 const FileSpecList &
1015  static FileSpecList empty_list;
1016 
1017  dw_offset_t offset = tu.GetLineTableOffset();
1018  if (offset == DW_INVALID_OFFSET ||
1019  offset == llvm::DenseMapInfo<dw_offset_t>::getEmptyKey() ||
1020  offset == llvm::DenseMapInfo<dw_offset_t>::getTombstoneKey())
1021  return empty_list;
1022 
1023  // Many type units can share a line table, so parse the support file list
1024  // once, and cache it based on the offset field.
1025  auto iter_bool = m_type_unit_support_files.try_emplace(offset);
1026  FileSpecList &list = iter_bool.first->second;
1027  if (iter_bool.second) {
1028  uint64_t line_table_offset = offset;
1029  llvm::DWARFDataExtractor data = m_context.getOrLoadLineData().GetAsLLVM();
1030  llvm::DWARFContext &ctx = m_context.GetAsLLVM();
1031  llvm::DWARFDebugLine::Prologue prologue;
1032  auto report = [](llvm::Error error) {
1033  Log *log = GetLog(DWARFLog::DebugInfo);
1034  LLDB_LOG_ERROR(log, std::move(error),
1035  "SymbolFileDWARF::GetTypeUnitSupportFiles failed to parse "
1036  "the line table prologue");
1037  };
1039  llvm::Error error = prologue.parse(data, &line_table_offset, report, ctx);
1040  if (error) {
1041  report(std::move(error));
1042  } else {
1044  prologue, tu.GetPathStyle());
1045  }
1046  }
1047  return list;
1048 }
1049 
1051  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1052  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
1053  if (dwarf_cu)
1054  return dwarf_cu->GetNonSkeletonUnit().GetIsOptimized();
1055  return false;
1056 }
1057 
1059  const lldb_private::SymbolContext &sc,
1060  std::vector<SourceModule> &imported_modules) {
1061  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1062  assert(sc.comp_unit);
1063  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
1064  if (!dwarf_cu)
1065  return false;
1066  if (!ClangModulesDeclVendor::LanguageSupportsClangModules(
1067  sc.comp_unit->GetLanguage()))
1068  return false;
1070 
1071  const DWARFDIE die = dwarf_cu->DIE();
1072  if (!die)
1073  return false;
1074 
1075  for (DWARFDIE child_die : die.children()) {
1076  if (child_die.Tag() != DW_TAG_imported_declaration)
1077  continue;
1078 
1079  DWARFDIE module_die = child_die.GetReferencedDIE(DW_AT_import);
1080  if (module_die.Tag() != DW_TAG_module)
1081  continue;
1082 
1083  if (const char *name =
1084  module_die.GetAttributeValueAsString(DW_AT_name, nullptr)) {
1085  SourceModule module;
1086  module.path.push_back(ConstString(name));
1087 
1088  DWARFDIE parent_die = module_die;
1089  while ((parent_die = parent_die.GetParent())) {
1090  if (parent_die.Tag() != DW_TAG_module)
1091  break;
1092  if (const char *name =
1093  parent_die.GetAttributeValueAsString(DW_AT_name, nullptr))
1094  module.path.push_back(ConstString(name));
1095  }
1096  std::reverse(module.path.begin(), module.path.end());
1097  if (const char *include_path = module_die.GetAttributeValueAsString(
1098  DW_AT_LLVM_include_path, nullptr)) {
1099  FileSpec include_spec(include_path, dwarf_cu->GetPathStyle());
1100  MakeAbsoluteAndRemap(include_spec, *dwarf_cu,
1101  m_objfile_sp->GetModule());
1102  module.search_path = ConstString(include_spec.GetPath());
1103  }
1104  if (const char *sysroot = dwarf_cu->DIE().GetAttributeValueAsString(
1105  DW_AT_LLVM_sysroot, nullptr))
1106  module.sysroot = ConstString(sysroot);
1107  imported_modules.push_back(module);
1108  }
1109  }
1110  return true;
1111 }
1112 
1114  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1115  if (comp_unit.GetLineTable() != nullptr)
1116  return true;
1117 
1118  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
1119  if (!dwarf_cu)
1120  return false;
1121 
1122  dw_offset_t offset = dwarf_cu->GetLineTableOffset();
1123  if (offset == DW_INVALID_OFFSET)
1124  return false;
1125 
1127  llvm::DWARFDebugLine line;
1128  const llvm::DWARFDebugLine::LineTable *line_table =
1129  ParseLLVMLineTable(m_context, line, offset, dwarf_cu->GetOffset());
1130 
1131  if (!line_table)
1132  return false;
1133 
1134  // FIXME: Rather than parsing the whole line table and then copying it over
1135  // into LLDB, we should explore using a callback to populate the line table
1136  // while we parse to reduce memory usage.
1137  std::vector<std::unique_ptr<LineSequence>> sequences;
1138  // The Sequences view contains only valid line sequences. Don't iterate over
1139  // the Rows directly.
1140  for (const llvm::DWARFDebugLine::Sequence &seq : line_table->Sequences) {
1141  // Ignore line sequences that do not start after the first code address.
1142  // All addresses generated in a sequence are incremental so we only need
1143  // to check the first one of the sequence. Check the comment at the
1144  // m_first_code_address declaration for more details on this.
1145  if (seq.LowPC < m_first_code_address)
1146  continue;
1147  std::unique_ptr<LineSequence> sequence =
1148  LineTable::CreateLineSequenceContainer();
1149  for (unsigned idx = seq.FirstRowIndex; idx < seq.LastRowIndex; ++idx) {
1150  const llvm::DWARFDebugLine::Row &row = line_table->Rows[idx];
1151  LineTable::AppendLineEntryToSequence(
1152  sequence.get(), row.Address.Address, row.Line, row.Column, row.File,
1153  row.IsStmt, row.BasicBlock, row.PrologueEnd, row.EpilogueBegin,
1154  row.EndSequence);
1155  }
1156  sequences.push_back(std::move(sequence));
1157  }
1158 
1159  std::unique_ptr<LineTable> line_table_up =
1160  std::make_unique<LineTable>(&comp_unit, std::move(sequences));
1161 
1162  if (SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile()) {
1163  // We have an object file that has a line table with addresses that are not
1164  // linked. We need to link the line table and convert the addresses that
1165  // are relative to the .o file into addresses for the main executable.
1166  comp_unit.SetLineTable(
1167  debug_map_symfile->LinkOSOLineTable(this, line_table_up.get()));
1168  } else {
1169  comp_unit.SetLineTable(line_table_up.release());
1170  }
1171 
1172  return true;
1173 }
1174 
1177  auto iter = m_debug_macros_map.find(*offset);
1178  if (iter != m_debug_macros_map.end())
1179  return iter->second;
1180 
1182  const DWARFDataExtractor &debug_macro_data = m_context.getOrLoadMacroData();
1183  if (debug_macro_data.GetByteSize() == 0)
1184  return DebugMacrosSP();
1185 
1187  m_debug_macros_map[*offset] = debug_macros_sp;
1188 
1189  const DWARFDebugMacroHeader &header =
1190  DWARFDebugMacroHeader::ParseHeader(debug_macro_data, offset);
1192  debug_macro_data, m_context.getOrLoadStrData(), header.OffsetIs64Bit(),
1193  offset, this, debug_macros_sp);
1194 
1195  return debug_macros_sp;
1196 }
1197 
1199  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1200 
1201  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
1202  if (dwarf_cu == nullptr)
1203  return false;
1204 
1205  const DWARFBaseDIE dwarf_cu_die = dwarf_cu->GetUnitDIEOnly();
1206  if (!dwarf_cu_die)
1207  return false;
1208 
1209  lldb::offset_t sect_offset =
1210  dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_macros, DW_INVALID_OFFSET);
1211  if (sect_offset == DW_INVALID_OFFSET)
1212  sect_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_GNU_macros,
1214  if (sect_offset == DW_INVALID_OFFSET)
1215  return false;
1216 
1217  comp_unit.SetDebugMacros(ParseDebugMacros(&sect_offset));
1218 
1219  return true;
1220 }
1221 
1223  lldb_private::CompileUnit &comp_unit, Block *parent_block,
1224  const DWARFDIE &orig_die, addr_t subprogram_low_pc, uint32_t depth) {
1225  size_t blocks_added = 0;
1226  DWARFDIE die = orig_die;
1227  while (die) {
1228  dw_tag_t tag = die.Tag();
1229 
1230  switch (tag) {
1231  case DW_TAG_inlined_subroutine:
1232  case DW_TAG_subprogram:
1233  case DW_TAG_lexical_block: {
1234  Block *block = nullptr;
1235  if (tag == DW_TAG_subprogram) {
1236  // Skip any DW_TAG_subprogram DIEs that are inside of a normal or
1237  // inlined functions. These will be parsed on their own as separate
1238  // entities.
1239 
1240  if (depth > 0)
1241  break;
1242 
1243  block = parent_block;
1244  } else {
1245  BlockSP block_sp(new Block(die.GetID()));
1246  parent_block->AddChild(block_sp);
1247  block = block_sp.get();
1248  }
1249  DWARFRangeList ranges;
1250  const char *name = nullptr;
1251  const char *mangled_name = nullptr;
1252 
1253  int decl_file = 0;
1254  int decl_line = 0;
1255  int decl_column = 0;
1256  int call_file = 0;
1257  int call_line = 0;
1258  int call_column = 0;
1259  if (die.GetDIENamesAndRanges(name, mangled_name, ranges, decl_file,
1260  decl_line, decl_column, call_file, call_line,
1261  call_column, nullptr)) {
1262  if (tag == DW_TAG_subprogram) {
1263  assert(subprogram_low_pc == LLDB_INVALID_ADDRESS);
1264  subprogram_low_pc = ranges.GetMinRangeBase(0);
1265  } else if (tag == DW_TAG_inlined_subroutine) {
1266  // We get called here for inlined subroutines in two ways. The first
1267  // time is when we are making the Function object for this inlined
1268  // concrete instance. Since we're creating a top level block at
1269  // here, the subprogram_low_pc will be LLDB_INVALID_ADDRESS. So we
1270  // need to adjust the containing address. The second time is when we
1271  // are parsing the blocks inside the function that contains the
1272  // inlined concrete instance. Since these will be blocks inside the
1273  // containing "real" function the offset will be for that function.
1274  if (subprogram_low_pc == LLDB_INVALID_ADDRESS) {
1275  subprogram_low_pc = ranges.GetMinRangeBase(0);
1276  }
1277  }
1278 
1279  const size_t num_ranges = ranges.GetSize();
1280  for (size_t i = 0; i < num_ranges; ++i) {
1281  const DWARFRangeList::Entry &range = ranges.GetEntryRef(i);
1282  const addr_t range_base = range.GetRangeBase();
1283  if (range_base >= subprogram_low_pc)
1284  block->AddRange(Block::Range(range_base - subprogram_low_pc,
1285  range.GetByteSize()));
1286  else {
1287  GetObjectFile()->GetModule()->ReportError(
1288  "0x%8.8" PRIx64 ": adding range [0x%" PRIx64 "-0x%" PRIx64
1289  ") which has a base that is less than the function's low PC "
1290  "0x%" PRIx64 ". Please file a bug and attach the file at the "
1291  "start of this error message",
1292  block->GetID(), range_base, range.GetRangeEnd(),
1293  subprogram_low_pc);
1294  }
1295  }
1296  block->FinalizeRanges();
1297 
1298  if (tag != DW_TAG_subprogram &&
1299  (name != nullptr || mangled_name != nullptr)) {
1300  std::unique_ptr<Declaration> decl_up;
1301  if (decl_file != 0 || decl_line != 0 || decl_column != 0)
1302  decl_up = std::make_unique<Declaration>(
1303  comp_unit.GetSupportFiles().GetFileSpecAtIndex(decl_file),
1304  decl_line, decl_column);
1305 
1306  std::unique_ptr<Declaration> call_up;
1307  if (call_file != 0 || call_line != 0 || call_column != 0)
1308  call_up = std::make_unique<Declaration>(
1309  comp_unit.GetSupportFiles().GetFileSpecAtIndex(call_file),
1310  call_line, call_column);
1311 
1312  block->SetInlinedFunctionInfo(name, mangled_name, decl_up.get(),
1313  call_up.get());
1314  }
1315 
1316  ++blocks_added;
1317 
1318  if (die.HasChildren()) {
1319  blocks_added +=
1320  ParseBlocksRecursive(comp_unit, block, die.GetFirstChild(),
1321  subprogram_low_pc, depth + 1);
1322  }
1323  }
1324  } break;
1325  default:
1326  break;
1327  }
1328 
1329  // Only parse siblings of the block if we are not at depth zero. A depth of
1330  // zero indicates we are currently parsing the top level DW_TAG_subprogram
1331  // DIE
1332 
1333  if (depth == 0)
1334  die.Clear();
1335  else
1336  die = die.GetSibling();
1337  }
1338  return blocks_added;
1339 }
1340 
1342  if (parent_die) {
1343  for (DWARFDIE die : parent_die.children()) {
1344  dw_tag_t tag = die.Tag();
1345  bool check_virtuality = false;
1346  switch (tag) {
1347  case DW_TAG_inheritance:
1348  case DW_TAG_subprogram:
1349  check_virtuality = true;
1350  break;
1351  default:
1352  break;
1353  }
1354  if (check_virtuality) {
1355  if (die.GetAttributeValueAsUnsigned(DW_AT_virtuality, 0) != 0)
1356  return true;
1357  }
1358  }
1359  }
1360  return false;
1361 }
1362 
1364  auto *type_system = decl_ctx.GetTypeSystem();
1365  if (type_system != nullptr)
1367  decl_ctx);
1368 }
1369 
1371  if (GetDebugMapSymfile())
1372  return GetID() | ref.die_offset();
1373 
1374  lldbassert(GetDwoNum().value_or(0) <= 0x3fffffff);
1375  return user_id_t(GetDwoNum().value_or(0)) << 32 | ref.die_offset() |
1376  lldb::user_id_t(GetDwoNum().has_value()) << 62 |
1377  lldb::user_id_t(ref.section() == DIERef::Section::DebugTypes) << 63;
1378 }
1379 
1380 llvm::Optional<SymbolFileDWARF::DecodedUID>
1382  // This method can be called without going through the symbol vendor so we
1383  // need to lock the module.
1384  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1385  // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API we
1386  // must make sure we use the correct DWARF file when resolving things. On
1387  // MacOSX, when using SymbolFileDWARFDebugMap, we will use multiple
1388  // SymbolFileDWARF classes, one for each .o file. We can often end up with
1389  // references to other DWARF objects and we must be ready to receive a
1390  // "lldb::user_id_t" that specifies a DIE from another SymbolFileDWARF
1391  // instance.
1392  if (SymbolFileDWARFDebugMap *debug_map = GetDebugMapSymfile()) {
1393  SymbolFileDWARF *dwarf = debug_map->GetSymbolFileByOSOIndex(
1394  debug_map->GetOSOIndexFromUserID(uid));
1395  return DecodedUID{
1396  *dwarf, {llvm::None, DIERef::Section::DebugInfo, dw_offset_t(uid)}};
1397  }
1398  dw_offset_t die_offset = uid;
1399  if (die_offset == DW_INVALID_OFFSET)
1400  return llvm::None;
1401 
1402  DIERef::Section section =
1403  uid >> 63 ? DIERef::Section::DebugTypes : DIERef::Section::DebugInfo;
1404 
1405  llvm::Optional<uint32_t> dwo_num;
1406  bool dwo_valid = uid >> 62 & 1;
1407  if (dwo_valid)
1408  dwo_num = uid >> 32 & 0x3fffffff;
1409 
1410  return DecodedUID{*this, {dwo_num, section, die_offset}};
1411 }
1412 
1413 DWARFDIE
1415  // This method can be called without going through the symbol vendor so we
1416  // need to lock the module.
1417  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1418 
1419  llvm::Optional<DecodedUID> decoded = DecodeUID(uid);
1420 
1421  if (decoded)
1422  return decoded->dwarf.GetDIE(decoded->ref);
1423 
1424  return DWARFDIE();
1425 }
1426 
1428  // This method can be called without going through the symbol vendor so we
1429  // need to lock the module.
1430  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1431  // Anytime we have a lldb::user_id_t, we must get the DIE by calling
1432  // SymbolFileDWARF::GetDIE(). See comments inside the
1433  // SymbolFileDWARF::GetDIE() for details.
1434  if (DWARFDIE die = GetDIE(type_uid))
1435  return GetDecl(die);
1436  return CompilerDecl();
1437 }
1438 
1441  // This method can be called without going through the symbol vendor so we
1442  // need to lock the module.
1443  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1444  // Anytime we have a lldb::user_id_t, we must get the DIE by calling
1445  // SymbolFileDWARF::GetDIE(). See comments inside the
1446  // SymbolFileDWARF::GetDIE() for details.
1447  if (DWARFDIE die = GetDIE(type_uid))
1448  return GetDeclContext(die);
1449  return CompilerDeclContext();
1450 }
1451 
1454  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1455  // Anytime we have a lldb::user_id_t, we must get the DIE by calling
1456  // SymbolFileDWARF::GetDIE(). See comments inside the
1457  // SymbolFileDWARF::GetDIE() for details.
1458  if (DWARFDIE die = GetDIE(type_uid))
1459  return GetContainingDeclContext(die);
1460  return CompilerDeclContext();
1461 }
1462 
1464  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1465  // Anytime we have a lldb::user_id_t, we must get the DIE by calling
1466  // SymbolFileDWARF::GetDIE(). See comments inside the
1467  // SymbolFileDWARF::GetDIE() for details.
1468  if (DWARFDIE type_die = GetDIE(type_uid))
1469  return type_die.ResolveType();
1470  else
1471  return nullptr;
1472 }
1473 
1474 llvm::Optional<SymbolFile::ArrayInfo>
1476  lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
1477  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1478  if (DWARFDIE type_die = GetDIE(type_uid))
1479  return DWARFASTParser::ParseChildArrayInfo(type_die, exe_ctx);
1480  else
1481  return llvm::None;
1482 }
1483 
1485  return ResolveType(GetDIE(die_ref), true);
1486 }
1487 
1489  bool assert_not_being_parsed) {
1490  if (die) {
1491  Log *log = GetLog(DWARFLog::DebugInfo);
1492  if (log)
1493  GetObjectFile()->GetModule()->LogMessage(
1494  log, "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s'",
1495  die.GetOffset(), die.GetTagAsCString(), die.GetName());
1496 
1497  // We might be coming in in the middle of a type tree (a class within a
1498  // class, an enum within a class), so parse any needed parent DIEs before
1499  // we get to this one...
1500  DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(die);
1501  if (decl_ctx_die) {
1502  if (log) {
1503  switch (decl_ctx_die.Tag()) {
1504  case DW_TAG_structure_type:
1505  case DW_TAG_union_type:
1506  case DW_TAG_class_type: {
1507  // Get the type, which could be a forward declaration
1508  if (log)
1509  GetObjectFile()->GetModule()->LogMessage(
1510  log,
1511  "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s' "
1512  "resolve parent forward type for 0x%8.8x",
1513  die.GetOffset(), die.GetTagAsCString(), die.GetName(),
1514  decl_ctx_die.GetOffset());
1515  } break;
1516 
1517  default:
1518  break;
1519  }
1520  }
1521  }
1522  return ResolveType(die);
1523  }
1524  return nullptr;
1525 }
1526 
1527 // This function is used when SymbolFileDWARFDebugMap owns a bunch of
1528 // SymbolFileDWARF objects to detect if this DWARF file is the one that can
1529 // resolve a compiler_type.
1531  const CompilerType &compiler_type) {
1532  CompilerType compiler_type_no_qualifiers =
1533  ClangUtil::RemoveFastQualifiers(compiler_type);
1534  if (GetForwardDeclClangTypeToDie().count(
1535  compiler_type_no_qualifiers.GetOpaqueQualType())) {
1536  return true;
1537  }
1538  TypeSystem *type_system = compiler_type.GetTypeSystem();
1539 
1540  TypeSystemClang *clang_type_system =
1541  llvm::dyn_cast_or_null<TypeSystemClang>(type_system);
1542  if (!clang_type_system)
1543  return false;
1544  DWARFASTParserClang *ast_parser =
1545  static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser());
1546  return ast_parser->GetClangASTImporter().CanImport(compiler_type);
1547 }
1548 
1550  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1551 
1552  TypeSystemClang *clang_type_system =
1553  llvm::dyn_cast_or_null<TypeSystemClang>(compiler_type.GetTypeSystem());
1554  if (clang_type_system) {
1555  DWARFASTParserClang *ast_parser =
1556  static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser());
1557  if (ast_parser &&
1558  ast_parser->GetClangASTImporter().CanImport(compiler_type))
1559  return ast_parser->GetClangASTImporter().CompleteType(compiler_type);
1560  }
1561 
1562  // We have a struct/union/class/enum that needs to be fully resolved.
1563  CompilerType compiler_type_no_qualifiers =
1564  ClangUtil::RemoveFastQualifiers(compiler_type);
1565  auto die_it = GetForwardDeclClangTypeToDie().find(
1566  compiler_type_no_qualifiers.GetOpaqueQualType());
1567  if (die_it == GetForwardDeclClangTypeToDie().end()) {
1568  // We have already resolved this type...
1569  return true;
1570  }
1571 
1572  DWARFDIE dwarf_die = GetDIE(die_it->getSecond());
1573  if (dwarf_die) {
1574  // Once we start resolving this type, remove it from the forward
1575  // declaration map in case anyone child members or other types require this
1576  // type to get resolved. The type will get resolved when all of the calls
1577  // to SymbolFileDWARF::ResolveClangOpaqueTypeDefinition are done.
1578  GetForwardDeclClangTypeToDie().erase(die_it);
1579 
1580  Type *type = GetDIEToType().lookup(dwarf_die.GetDIE());
1581 
1582  Log *log = GetLog(DWARFLog::DebugInfo | DWARFLog::TypeCompletion);
1583  if (log)
1584  GetObjectFile()->GetModule()->LogMessageVerboseBacktrace(
1585  log, "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...",
1586  dwarf_die.GetID(), dwarf_die.GetTagAsCString(),
1587  type->GetName().AsCString());
1588  assert(compiler_type);
1589  if (DWARFASTParser *dwarf_ast = GetDWARFParser(*dwarf_die.GetCU()))
1590  return dwarf_ast->CompleteTypeFromDWARF(dwarf_die, type, compiler_type);
1591  }
1592  return false;
1593 }
1594 
1596  bool assert_not_being_parsed,
1597  bool resolve_function_context) {
1598  if (die) {
1599  Type *type = GetTypeForDIE(die, resolve_function_context).get();
1600 
1601  if (assert_not_being_parsed) {
1602  if (type != DIE_IS_BEING_PARSED)
1603  return type;
1604 
1605  GetObjectFile()->GetModule()->ReportError(
1606  "Parsing a die that is being parsed die: 0x%8.8x: %s %s",
1607  die.GetOffset(), die.GetTagAsCString(), die.GetName());
1608 
1609  } else
1610  return type;
1611  }
1612  return nullptr;
1613 }
1614 
1615 CompileUnit *
1617  if (dwarf_cu.IsDWOUnit()) {
1618  DWARFCompileUnit *non_dwo_cu =
1619  static_cast<DWARFCompileUnit *>(dwarf_cu.GetUserData());
1620  assert(non_dwo_cu);
1621  return non_dwo_cu->GetSymbolFileDWARF().GetCompUnitForDWARFCompUnit(
1622  *non_dwo_cu);
1623  }
1624  // Check if the symbol vendor already knows about this compile unit?
1625  if (dwarf_cu.GetUserData() == nullptr) {
1626  // The symbol vendor doesn't know about this compile unit, we need to parse
1627  // and add it to the symbol vendor object.
1628  return ParseCompileUnit(dwarf_cu).get();
1629  }
1630  return static_cast<CompileUnit *>(dwarf_cu.GetUserData());
1631 }
1632 
1634  ConstString class_name, llvm::function_ref<bool(DWARFDIE die)> callback) {
1635  m_index->GetObjCMethods(class_name, callback);
1636 }
1637 
1639  sc.Clear(false);
1640 
1641  if (die && llvm::isa<DWARFCompileUnit>(die.GetCU())) {
1642  // Check if the symbol vendor already knows about this compile unit?
1643  sc.comp_unit =
1644  GetCompUnitForDWARFCompUnit(llvm::cast<DWARFCompileUnit>(*die.GetCU()));
1645 
1646  sc.function = sc.comp_unit->FindFunctionByUID(die.GetID()).get();
1647  if (sc.function == nullptr)
1648  sc.function = ParseFunction(*sc.comp_unit, die);
1649 
1650  if (sc.function) {
1652  return true;
1653  }
1654  }
1655 
1656  return false;
1657 }
1658 
1661  const auto &pos = m_external_type_modules.find(name);
1662  if (pos != m_external_type_modules.end())
1663  return pos->second;
1664  else
1665  return lldb::ModuleSP();
1666 }
1667 
1668 DWARFDIE
1670  if (die_ref.dwo_num()) {
1671  SymbolFileDWARF *dwarf = *die_ref.dwo_num() == 0x3fffffff
1672  ? m_dwp_symfile.get()
1673  : this->DebugInfo()
1674  .GetUnitAtIndex(*die_ref.dwo_num())
1675  ->GetDwoSymbolFile();
1676  return dwarf->DebugInfo().GetDIE(die_ref);
1677  }
1678 
1679  return DebugInfo().GetDIE(die_ref);
1680 }
1681 
1682 /// Return the DW_AT_(GNU_)dwo_id.
1683 /// FIXME: Technically 0 is a valid hash.
1684 static uint64_t GetDWOId(DWARFCompileUnit &dwarf_cu,
1685  const DWARFDebugInfoEntry &cu_die) {
1686  uint64_t dwo_id =
1687  cu_die.GetAttributeValueAsUnsigned(&dwarf_cu, DW_AT_GNU_dwo_id, 0);
1688  if (!dwo_id)
1689  dwo_id = cu_die.GetAttributeValueAsUnsigned(&dwarf_cu, DW_AT_dwo_id, 0);
1690  return dwo_id;
1691 }
1692 
1693 llvm::Optional<uint64_t> SymbolFileDWARF::GetDWOId() {
1694  if (GetNumCompileUnits() == 1) {
1695  if (auto comp_unit = GetCompileUnitAtIndex(0))
1696  if (DWARFCompileUnit *cu = GetDWARFCompileUnit(comp_unit.get()))
1697  if (DWARFDebugInfoEntry *cu_die = cu->DIE().GetDIE())
1698  if (uint64_t dwo_id = ::GetDWOId(*cu, *cu_die))
1699  return dwo_id;
1700  }
1701  return {};
1702 }
1703 
1704 std::shared_ptr<SymbolFileDWARFDwo>
1706  DWARFUnit &unit, const DWARFDebugInfoEntry &cu_die) {
1707  // If this is a Darwin-style debug map (non-.dSYM) symbol file,
1708  // never attempt to load ELF-style DWO files since the -gmodules
1709  // support uses the same DWO mechanism to specify full debug info
1710  // files for modules. This is handled in
1711  // UpdateExternalModuleListIfNeeded().
1712  if (GetDebugMapSymfile())
1713  return nullptr;
1714 
1715  DWARFCompileUnit *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(&unit);
1716  // Only compile units can be split into two parts.
1717  if (!dwarf_cu)
1718  return nullptr;
1719 
1720  const char *dwo_name = GetDWOName(*dwarf_cu, cu_die);
1721  if (!dwo_name)
1722  return nullptr;
1723 
1724  if (std::shared_ptr<SymbolFileDWARFDwo> dwp_sp = GetDwpSymbolFile())
1725  return dwp_sp;
1726 
1727  FileSpec dwo_file(dwo_name);
1728  FileSystem::Instance().Resolve(dwo_file);
1729  if (dwo_file.IsRelative()) {
1730  const char *comp_dir =
1731  cu_die.GetAttributeValueAsString(dwarf_cu, DW_AT_comp_dir, nullptr);
1732  if (!comp_dir)
1733  return nullptr;
1734 
1735  dwo_file.SetFile(comp_dir, FileSpec::Style::native);
1736  if (dwo_file.IsRelative()) {
1737  // if DW_AT_comp_dir is relative, it should be relative to the location
1738  // of the executable, not to the location from which the debugger was
1739  // launched.
1740  dwo_file.PrependPathComponent(
1741  m_objfile_sp->GetFileSpec().GetDirectory().GetStringRef());
1742  }
1743  FileSystem::Instance().Resolve(dwo_file);
1744  dwo_file.AppendPathComponent(dwo_name);
1745  }
1746 
1747  if (!FileSystem::Instance().Exists(dwo_file)) {
1748  if (m_dwo_warning_issued.test_and_set(std::memory_order_relaxed) == false) {
1749  GetObjectFile()->GetModule()->ReportWarning(
1750  "unable to locate separate debug file (dwo, dwp). Debugging will be "
1751  "degraded.");
1752  }
1753  return nullptr;
1754  }
1755 
1756  const lldb::offset_t file_offset = 0;
1757  DataBufferSP dwo_file_data_sp;
1758  lldb::offset_t dwo_file_data_offset = 0;
1759  ObjectFileSP dwo_obj_file = ObjectFile::FindPlugin(
1760  GetObjectFile()->GetModule(), &dwo_file, file_offset,
1761  FileSystem::Instance().GetByteSize(dwo_file), dwo_file_data_sp,
1762  dwo_file_data_offset);
1763  if (dwo_obj_file == nullptr)
1764  return nullptr;
1765 
1766  return std::make_shared<SymbolFileDWARFDwo>(*this, dwo_obj_file,
1767  dwarf_cu->GetID());
1768 }
1769 
1772  return;
1774  DWARFDebugInfo &debug_info = DebugInfo();
1775 
1776  // Follow DWO skeleton unit breadcrumbs.
1777  const uint32_t num_compile_units = GetNumCompileUnits();
1778  for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
1779  auto *dwarf_cu =
1780  llvm::dyn_cast<DWARFCompileUnit>(debug_info.GetUnitAtIndex(cu_idx));
1781  if (!dwarf_cu)
1782  continue;
1783 
1784  const DWARFBaseDIE die = dwarf_cu->GetUnitDIEOnly();
1785  if (!die || die.HasChildren() || !die.GetDIE())
1786  continue;
1787 
1788  const char *name = die.GetAttributeValueAsString(DW_AT_name, nullptr);
1789  if (!name)
1790  continue;
1791 
1792  ConstString const_name(name);
1793  ModuleSP &module_sp = m_external_type_modules[const_name];
1794  if (module_sp)
1795  continue;
1796 
1797  const char *dwo_path = GetDWOName(*dwarf_cu, *die.GetDIE());
1798  if (!dwo_path)
1799  continue;
1800 
1801  ModuleSpec dwo_module_spec;
1802  dwo_module_spec.GetFileSpec().SetFile(dwo_path, FileSpec::Style::native);
1803  if (dwo_module_spec.GetFileSpec().IsRelative()) {
1804  const char *comp_dir =
1805  die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr);
1806  if (comp_dir) {
1807  dwo_module_spec.GetFileSpec().SetFile(comp_dir,
1808  FileSpec::Style::native);
1809  FileSystem::Instance().Resolve(dwo_module_spec.GetFileSpec());
1810  dwo_module_spec.GetFileSpec().AppendPathComponent(dwo_path);
1811  }
1812  }
1813  dwo_module_spec.GetArchitecture() =
1814  m_objfile_sp->GetModule()->GetArchitecture();
1815 
1816  // When LLDB loads "external" modules it looks at the presence of
1817  // DW_AT_dwo_name. However, when the already created module
1818  // (corresponding to .dwo itself) is being processed, it will see
1819  // the presence of DW_AT_dwo_name (which contains the name of dwo
1820  // file) and will try to call ModuleList::GetSharedModule
1821  // again. In some cases (i.e., for empty files) Clang 4.0
1822  // generates a *.dwo file which has DW_AT_dwo_name, but no
1823  // DW_AT_comp_dir. In this case the method
1824  // ModuleList::GetSharedModule will fail and the warning will be
1825  // printed. However, as one can notice in this case we don't
1826  // actually need to try to load the already loaded module
1827  // (corresponding to .dwo) so we simply skip it.
1828  if (m_objfile_sp->GetFileSpec().GetFileNameExtension() == ".dwo" &&
1829  llvm::StringRef(m_objfile_sp->GetFileSpec().GetPath())
1830  .endswith(dwo_module_spec.GetFileSpec().GetPath())) {
1831  continue;
1832  }
1833 
1834  Status error = ModuleList::GetSharedModule(dwo_module_spec, module_sp,
1835  nullptr, nullptr, nullptr);
1836  if (!module_sp) {
1837  GetObjectFile()->GetModule()->ReportWarning(
1838  "0x%8.8x: unable to locate module needed for external types: "
1839  "%s\nerror: %s\nDebugging will be degraded due to missing "
1840  "types. Rebuilding the project will regenerate the needed "
1841  "module files.",
1842  die.GetOffset(), dwo_module_spec.GetFileSpec().GetPath().c_str(),
1843  error.AsCString("unknown error"));
1844  continue;
1845  }
1846 
1847  // Verify the DWO hash.
1848  // FIXME: Technically "0" is a valid hash.
1849  uint64_t dwo_id = ::GetDWOId(*dwarf_cu, *die.GetDIE());
1850  if (!dwo_id)
1851  continue;
1852 
1853  auto *dwo_symfile =
1854  llvm::dyn_cast_or_null<SymbolFileDWARF>(module_sp->GetSymbolFile());
1855  if (!dwo_symfile)
1856  continue;
1857  llvm::Optional<uint64_t> dwo_dwo_id = dwo_symfile->GetDWOId();
1858  if (!dwo_dwo_id)
1859  continue;
1860 
1861  if (dwo_id != dwo_dwo_id) {
1862  GetObjectFile()->GetModule()->ReportWarning(
1863  "0x%8.8x: Module %s is out-of-date (hash mismatch). Type information "
1864  "from this module may be incomplete or inconsistent with the rest of "
1865  "the program. Rebuilding the project will regenerate the needed "
1866  "module files.",
1867  die.GetOffset(), dwo_module_spec.GetFileSpec().GetPath().c_str());
1868  }
1869  }
1870 }
1871 
1873  if (!m_global_aranges_up) {
1874  m_global_aranges_up = std::make_unique<GlobalVariableMap>();
1875 
1876  ModuleSP module_sp = GetObjectFile()->GetModule();
1877  if (module_sp) {
1878  const size_t num_cus = module_sp->GetNumCompileUnits();
1879  for (size_t i = 0; i < num_cus; ++i) {
1880  CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex(i);
1881  if (cu_sp) {
1882  VariableListSP globals_sp = cu_sp->GetVariableList(true);
1883  if (globals_sp) {
1884  const size_t num_globals = globals_sp->GetSize();
1885  for (size_t g = 0; g < num_globals; ++g) {
1886  VariableSP var_sp = globals_sp->GetVariableAtIndex(g);
1887  if (var_sp && !var_sp->GetLocationIsConstantValueData()) {
1888  const DWARFExpression &location = var_sp->LocationExpression();
1889  Value location_result;
1890  Status error;
1891  if (location.Evaluate(nullptr, LLDB_INVALID_ADDRESS, nullptr,
1892  nullptr, location_result, &error)) {
1893  if (location_result.GetValueType() ==
1894  Value::ValueType::FileAddress) {
1895  lldb::addr_t file_addr =
1896  location_result.GetScalar().ULongLong();
1897  lldb::addr_t byte_size = 1;
1898  if (var_sp->GetType())
1899  byte_size =
1900  var_sp->GetType()->GetByteSize(nullptr).value_or(0);
1902  file_addr, byte_size, var_sp.get()));
1903  }
1904  }
1905  }
1906  }
1907  }
1908  }
1909  }
1910  }
1911  m_global_aranges_up->Sort();
1912  }
1913  return *m_global_aranges_up;
1914 }
1915 
1917  bool lookup_block,
1918  SymbolContext &sc) {
1919  assert(sc.comp_unit);
1920  DWARFCompileUnit &cu =
1922  DWARFDIE function_die = cu.LookupAddress(file_vm_addr);
1923  DWARFDIE block_die;
1924  if (function_die) {
1925  sc.function = sc.comp_unit->FindFunctionByUID(function_die.GetID()).get();
1926  if (sc.function == nullptr)
1927  sc.function = ParseFunction(*sc.comp_unit, function_die);
1928 
1929  if (sc.function && lookup_block)
1930  block_die = function_die.LookupDeepestBlock(file_vm_addr);
1931  }
1932 
1933  if (!sc.function || !lookup_block)
1934  return;
1935 
1936  Block &block = sc.function->GetBlock(true);
1937  if (block_die)
1938  sc.block = block.FindBlockByID(block_die.GetID());
1939  else
1940  sc.block = block.FindBlockByID(function_die.GetID());
1941 }
1942 
1944  SymbolContextItem resolve_scope,
1945  SymbolContext &sc) {
1946  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
1947  LLDB_SCOPED_TIMERF("SymbolFileDWARF::"
1948  "ResolveSymbolContext (so_addr = { "
1949  "section = %p, offset = 0x%" PRIx64
1950  " }, resolve_scope = 0x%8.8x)",
1951  static_cast<void *>(so_addr.GetSection().get()),
1952  so_addr.GetOffset(), resolve_scope);
1953  uint32_t resolved = 0;
1954  if (resolve_scope &
1955  (eSymbolContextCompUnit | eSymbolContextFunction | eSymbolContextBlock |
1956  eSymbolContextLineEntry | eSymbolContextVariable)) {
1957  lldb::addr_t file_vm_addr = so_addr.GetFileAddress();
1958 
1959  DWARFDebugInfo &debug_info = DebugInfo();
1960  const DWARFDebugAranges &aranges = debug_info.GetCompileUnitAranges();
1961  const dw_offset_t cu_offset = aranges.FindAddress(file_vm_addr);
1962  if (cu_offset == DW_INVALID_OFFSET) {
1963  // Global variables are not in the compile unit address ranges. The only
1964  // way to currently find global variables is to iterate over the
1965  // .debug_pubnames or the __apple_names table and find all items in there
1966  // that point to DW_TAG_variable DIEs and then find the address that
1967  // matches.
1968  if (resolve_scope & eSymbolContextVariable) {
1970  const GlobalVariableMap::Entry *entry =
1971  map.FindEntryThatContains(file_vm_addr);
1972  if (entry && entry->data) {
1973  Variable *variable = entry->data;
1974  SymbolContextScope *scc = variable->GetSymbolContextScope();
1975  if (scc) {
1976  scc->CalculateSymbolContext(&sc);
1977  sc.variable = variable;
1978  }
1979  return sc.GetResolvedMask();
1980  }
1981  }
1982  } else {
1983  uint32_t cu_idx = DW_INVALID_INDEX;
1984  if (auto *dwarf_cu = llvm::dyn_cast_or_null<DWARFCompileUnit>(
1985  debug_info.GetUnitAtOffset(DIERef::Section::DebugInfo, cu_offset,
1986  &cu_idx))) {
1987  sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
1988  if (sc.comp_unit) {
1989  resolved |= eSymbolContextCompUnit;
1990 
1991  bool force_check_line_table = false;
1992  if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock)) {
1993  ResolveFunctionAndBlock(file_vm_addr,
1994  resolve_scope & eSymbolContextBlock, sc);
1995  if (sc.function)
1996  resolved |= eSymbolContextFunction;
1997  else {
1998  // We might have had a compile unit that had discontiguous address
1999  // ranges where the gaps are symbols that don't have any debug
2000  // info. Discontiguous compile unit address ranges should only
2001  // happen when there aren't other functions from other compile
2002  // units in these gaps. This helps keep the size of the aranges
2003  // down.
2004  force_check_line_table = true;
2005  }
2006  if (sc.block)
2007  resolved |= eSymbolContextBlock;
2008  }
2009 
2010  if ((resolve_scope & eSymbolContextLineEntry) ||
2011  force_check_line_table) {
2012  LineTable *line_table = sc.comp_unit->GetLineTable();
2013  if (line_table != nullptr) {
2014  // And address that makes it into this function should be in terms
2015  // of this debug file if there is no debug map, or it will be an
2016  // address in the .o file which needs to be fixed up to be in
2017  // terms of the debug map executable. Either way, calling
2018  // FixupAddress() will work for us.
2019  Address exe_so_addr(so_addr);
2020  if (FixupAddress(exe_so_addr)) {
2021  if (line_table->FindLineEntryByAddress(exe_so_addr,
2022  sc.line_entry)) {
2023  resolved |= eSymbolContextLineEntry;
2024  }
2025  }
2026  }
2027  }
2028 
2029  if (force_check_line_table && !(resolved & eSymbolContextLineEntry)) {
2030  // We might have had a compile unit that had discontiguous address
2031  // ranges where the gaps are symbols that don't have any debug info.
2032  // Discontiguous compile unit address ranges should only happen when
2033  // there aren't other functions from other compile units in these
2034  // gaps. This helps keep the size of the aranges down.
2035  sc.comp_unit = nullptr;
2036  resolved &= ~eSymbolContextCompUnit;
2037  }
2038  } else {
2039  GetObjectFile()->GetModule()->ReportWarning(
2040  "0x%8.8x: compile unit %u failed to create a valid "
2041  "lldb_private::CompileUnit class.",
2042  cu_offset, cu_idx);
2043  }
2044  }
2045  }
2046  }
2047  return resolved;
2048 }
2049 
2051  const SourceLocationSpec &src_location_spec,
2052  SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
2053  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
2054  const bool check_inlines = src_location_spec.GetCheckInlines();
2055  const uint32_t prev_size = sc_list.GetSize();
2056  if (resolve_scope & eSymbolContextCompUnit) {
2057  for (uint32_t cu_idx = 0, num_cus = GetNumCompileUnits(); cu_idx < num_cus;
2058  ++cu_idx) {
2059  CompileUnit *dc_cu = ParseCompileUnitAtIndex(cu_idx).get();
2060  if (!dc_cu)
2061  continue;
2062 
2063  bool file_spec_matches_cu_file_spec = FileSpec::Match(
2064  src_location_spec.GetFileSpec(), dc_cu->GetPrimaryFile());
2065  if (check_inlines || file_spec_matches_cu_file_spec) {
2066  dc_cu->ResolveSymbolContext(src_location_spec, resolve_scope, sc_list);
2067  if (!check_inlines)
2068  break;
2069  }
2070  }
2071  }
2072  return sc_list.GetSize() - prev_size;
2073 }
2074 
2076  // Get the symbol table for the symbol file prior to taking the module lock
2077  // so that it is available without needing to take the module lock. The DWARF
2078  // indexing might end up needing to relocate items when DWARF sections are
2079  // loaded as they might end up getting the section contents which can call
2080  // ObjectFileELF::RelocateSection() which in turn will ask for the symbol
2081  // table and can cause deadlocks.
2082  GetSymtab();
2083  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
2084  m_index->Preload();
2085 }
2086 
2087 std::recursive_mutex &SymbolFileDWARF::GetModuleMutex() const {
2088  lldb::ModuleSP module_sp(m_debug_map_module_wp.lock());
2089  if (module_sp)
2090  return module_sp->GetMutex();
2091  return GetObjectFile()->GetModule()->GetMutex();
2092 }
2093 
2095  const lldb_private::CompilerDeclContext &decl_ctx) {
2096  if (!decl_ctx.IsValid()) {
2097  // Invalid namespace decl which means we aren't matching only things in
2098  // this symbol file, so return true to indicate it matches this symbol
2099  // file.
2100  return true;
2101  }
2102 
2103  TypeSystem *decl_ctx_type_system = decl_ctx.GetTypeSystem();
2104  auto type_system_or_err = GetTypeSystemForLanguage(
2105  decl_ctx_type_system->GetMinimumLanguage(nullptr));
2106  if (auto err = type_system_or_err.takeError()) {
2107  LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
2108  "Unable to match namespace decl using TypeSystem");
2109  return false;
2110  }
2111 
2112  if (decl_ctx_type_system == &type_system_or_err.get())
2113  return true; // The type systems match, return true
2114 
2115  // The namespace AST was valid, and it does not match...
2116  Log *log = GetLog(DWARFLog::Lookups);
2117 
2118  if (log)
2119  GetObjectFile()->GetModule()->LogMessage(
2120  log, "Valid namespace does not match symbol file");
2121 
2122  return false;
2123 }
2124 
2126  ConstString name, const CompilerDeclContext &parent_decl_ctx,
2127  uint32_t max_matches, VariableList &variables) {
2128  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
2129  Log *log = GetLog(DWARFLog::Lookups);
2130 
2131  if (log)
2132  GetObjectFile()->GetModule()->LogMessage(
2133  log,
2134  "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", "
2135  "parent_decl_ctx=%p, max_matches=%u, variables)",
2136  name.GetCString(), static_cast<const void *>(&parent_decl_ctx),
2137  max_matches);
2138 
2139  if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
2140  return;
2141 
2142  // Remember how many variables are in the list before we search.
2143  const uint32_t original_size = variables.GetSize();
2144 
2145  llvm::StringRef basename;
2146  llvm::StringRef context;
2147  bool name_is_mangled = Mangled::GetManglingScheme(name.GetStringRef()) !=
2148  Mangled::eManglingSchemeNone;
2149 
2150  if (!CPlusPlusLanguage::ExtractContextAndIdentifier(name.GetCString(),
2151  context, basename))
2152  basename = name.GetStringRef();
2153 
2154  // Loop invariant: Variables up to this index have been checked for context
2155  // matches.
2156  uint32_t pruned_idx = original_size;
2157 
2158  SymbolContext sc;
2159  m_index->GetGlobalVariables(ConstString(basename), [&](DWARFDIE die) {
2160  if (!sc.module_sp)
2161  sc.module_sp = m_objfile_sp->GetModule();
2162  assert(sc.module_sp);
2163 
2164  if (die.Tag() != DW_TAG_variable)
2165  return true;
2166 
2167  auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU());
2168  if (!dwarf_cu)
2169  return true;
2170  sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
2171 
2172  if (parent_decl_ctx) {
2173  if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU())) {
2174  CompilerDeclContext actual_parent_decl_ctx =
2175  dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
2176  if (!actual_parent_decl_ctx ||
2177  actual_parent_decl_ctx != parent_decl_ctx)
2178  return true;
2179  }
2180  }
2181 
2182  ParseAndAppendGlobalVariable(sc, die, variables);
2183  while (pruned_idx < variables.GetSize()) {
2184  VariableSP var_sp = variables.GetVariableAtIndex(pruned_idx);
2185  if (name_is_mangled ||
2186  var_sp->GetName().GetStringRef().contains(name.GetStringRef()))
2187  ++pruned_idx;
2188  else
2189  variables.RemoveVariableAtIndex(pruned_idx);
2190  }
2191 
2192  return variables.GetSize() - original_size < max_matches;
2193  });
2194 
2195  // Return the number of variable that were appended to the list
2196  const uint32_t num_matches = variables.GetSize() - original_size;
2197  if (log && num_matches > 0) {
2198  GetObjectFile()->GetModule()->LogMessage(
2199  log,
2200  "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", "
2201  "parent_decl_ctx=%p, max_matches=%u, variables) => %u",
2202  name.GetCString(), static_cast<const void *>(&parent_decl_ctx),
2203  max_matches, num_matches);
2204  }
2205 }
2206 
2208  uint32_t max_matches,
2209  VariableList &variables) {
2210  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
2211  Log *log = GetLog(DWARFLog::Lookups);
2212 
2213  if (log) {
2214  GetObjectFile()->GetModule()->LogMessage(
2215  log,
2216  "SymbolFileDWARF::FindGlobalVariables (regex=\"%s\", "
2217  "max_matches=%u, variables)",
2218  regex.GetText().str().c_str(), max_matches);
2219  }
2220 
2221  // Remember how many variables are in the list before we search.
2222  const uint32_t original_size = variables.GetSize();
2223 
2224  SymbolContext sc;
2225  m_index->GetGlobalVariables(regex, [&](DWARFDIE die) {
2226  if (!sc.module_sp)
2227  sc.module_sp = m_objfile_sp->GetModule();
2228  assert(sc.module_sp);
2229 
2230  DWARFCompileUnit *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU());
2231  if (!dwarf_cu)
2232  return true;
2233  sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
2234 
2235  ParseAndAppendGlobalVariable(sc, die, variables);
2236 
2237  return variables.GetSize() - original_size < max_matches;
2238  });
2239 }
2240 
2242  bool include_inlines,
2243  SymbolContextList &sc_list) {
2244  SymbolContext sc;
2245 
2246  if (!orig_die)
2247  return false;
2248 
2249  // If we were passed a die that is not a function, just return false...
2250  if (!(orig_die.Tag() == DW_TAG_subprogram ||
2251  (include_inlines && orig_die.Tag() == DW_TAG_inlined_subroutine)))
2252  return false;
2253 
2254  DWARFDIE die = orig_die;
2255  DWARFDIE inlined_die;
2256  if (die.Tag() == DW_TAG_inlined_subroutine) {
2257  inlined_die = die;
2258 
2259  while (true) {
2260  die = die.GetParent();
2261 
2262  if (die) {
2263  if (die.Tag() == DW_TAG_subprogram)
2264  break;
2265  } else
2266  break;
2267  }
2268  }
2269  assert(die && die.Tag() == DW_TAG_subprogram);
2270  if (GetFunction(die, sc)) {
2271  Address addr;
2272  // Parse all blocks if needed
2273  if (inlined_die) {
2274  Block &function_block = sc.function->GetBlock(true);
2275  sc.block = function_block.FindBlockByID(inlined_die.GetID());
2276  if (sc.block == nullptr)
2277  sc.block = function_block.FindBlockByID(inlined_die.GetOffset());
2278  if (sc.block == nullptr || !sc.block->GetStartAddress(addr))
2279  addr.Clear();
2280  } else {
2281  sc.block = nullptr;
2282  addr = sc.function->GetAddressRange().GetBaseAddress();
2283  }
2284 
2285  sc_list.Append(sc);
2286  return true;
2287  }
2288 
2289  return false;
2290 }
2291 
2293  const DWARFDIE &die) {
2294  // If we have no parent decl context to match this DIE matches, and if the
2295  // parent decl context isn't valid, we aren't trying to look for any
2296  // particular decl context so any die matches.
2297  if (!decl_ctx.IsValid())
2298  return true;
2299 
2300  if (die) {
2301  if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU())) {
2302  if (CompilerDeclContext actual_decl_ctx =
2303  dwarf_ast->GetDeclContextContainingUIDFromDWARF(die))
2304  return decl_ctx.IsContainedInLookup(actual_decl_ctx);
2305  }
2306  }
2307  return false;
2308 }
2309 
2311  const CompilerDeclContext &parent_decl_ctx,
2312  FunctionNameType name_type_mask,
2313  bool include_inlines,
2314  SymbolContextList &sc_list) {
2315  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
2316  LLDB_SCOPED_TIMERF("SymbolFileDWARF::FindFunctions (name = '%s')",
2317  name.AsCString());
2318 
2319  // eFunctionNameTypeAuto should be pre-resolved by a call to
2320  // Module::LookupInfo::LookupInfo()
2321  assert((name_type_mask & eFunctionNameTypeAuto) == 0);
2322 
2323  Log *log = GetLog(DWARFLog::Lookups);
2324 
2325  if (log) {
2326  GetObjectFile()->GetModule()->LogMessage(
2327  log,
2328  "SymbolFileDWARF::FindFunctions (name=\"%s\", name_type_mask=0x%x, "
2329  "sc_list)",
2330  name.GetCString(), name_type_mask);
2331  }
2332 
2333  if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
2334  return;
2335 
2336  // If name is empty then we won't find anything.
2337  if (name.IsEmpty())
2338  return;
2339 
2340  // Remember how many sc_list are in the list before we search in case we are
2341  // appending the results to a variable list.
2342 
2343  const uint32_t original_size = sc_list.GetSize();
2344 
2345  llvm::DenseSet<const DWARFDebugInfoEntry *> resolved_dies;
2346 
2347  m_index->GetFunctions(name, *this, parent_decl_ctx, name_type_mask,
2348  [&](DWARFDIE die) {
2349  if (resolved_dies.insert(die.GetDIE()).second)
2350  ResolveFunction(die, include_inlines, sc_list);
2351  return true;
2352  });
2353 
2354  // Return the number of variable that were appended to the list
2355  const uint32_t num_matches = sc_list.GetSize() - original_size;
2356 
2357  if (log && num_matches > 0) {
2358  GetObjectFile()->GetModule()->LogMessage(
2359  log,
2360  "SymbolFileDWARF::FindFunctions (name=\"%s\", "
2361  "name_type_mask=0x%x, include_inlines=%d, sc_list) => %u",
2362  name.GetCString(), name_type_mask, include_inlines, num_matches);
2363  }
2364 }
2365 
2367  bool include_inlines,
2368  SymbolContextList &sc_list) {
2369  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
2370  LLDB_SCOPED_TIMERF("SymbolFileDWARF::FindFunctions (regex = '%s')",
2371  regex.GetText().str().c_str());
2372 
2373  Log *log = GetLog(DWARFLog::Lookups);
2374 
2375  if (log) {
2376  GetObjectFile()->GetModule()->LogMessage(
2377  log, "SymbolFileDWARF::FindFunctions (regex=\"%s\", sc_list)",
2378  regex.GetText().str().c_str());
2379  }
2380 
2381  llvm::DenseSet<const DWARFDebugInfoEntry *> resolved_dies;
2382  m_index->GetFunctions(regex, [&](DWARFDIE die) {
2383  if (resolved_dies.insert(die.GetDIE()).second)
2384  ResolveFunction(die, include_inlines, sc_list);
2385  return true;
2386  });
2387 }
2388 
2390  const std::string &scope_qualified_name,
2391  std::vector<ConstString> &mangled_names) {
2392  DWARFDebugInfo &info = DebugInfo();
2393  uint32_t num_comp_units = info.GetNumUnits();
2394  for (uint32_t i = 0; i < num_comp_units; i++) {
2395  DWARFUnit *cu = info.GetUnitAtIndex(i);
2396  if (cu == nullptr)
2397  continue;
2398 
2399  SymbolFileDWARFDwo *dwo = cu->GetDwoSymbolFile();
2400  if (dwo)
2401  dwo->GetMangledNamesForFunction(scope_qualified_name, mangled_names);
2402  }
2403 
2404  for (DIERef die_ref :
2405  m_function_scope_qualified_name_map.lookup(scope_qualified_name)) {
2406  DWARFDIE die = GetDIE(die_ref);
2407  mangled_names.push_back(ConstString(die.GetMangledName()));
2408  }
2409 }
2410 
2412  ConstString name, const CompilerDeclContext &parent_decl_ctx,
2413  uint32_t max_matches,
2414  llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
2415  TypeMap &types) {
2416  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
2417  // Make sure we haven't already searched this SymbolFile before.
2418  if (!searched_symbol_files.insert(this).second)
2419  return;
2420 
2421  Log *log = GetLog(DWARFLog::Lookups);
2422 
2423  if (log) {
2424  if (parent_decl_ctx)
2425  GetObjectFile()->GetModule()->LogMessage(
2426  log,
2427  "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = "
2428  "%p (\"%s\"), max_matches=%u, type_list)",
2429  name.GetCString(), static_cast<const void *>(&parent_decl_ctx),
2430  parent_decl_ctx.GetName().AsCString("<NULL>"), max_matches);
2431  else
2432  GetObjectFile()->GetModule()->LogMessage(
2433  log,
2434  "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = "
2435  "NULL, max_matches=%u, type_list)",
2436  name.GetCString(), max_matches);
2437  }
2438 
2439  if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
2440  return;
2441 
2442  m_index->GetTypes(name, [&](DWARFDIE die) {
2443  if (!DIEInDeclContext(parent_decl_ctx, die))
2444  return true; // The containing decl contexts don't match
2445 
2446  Type *matching_type = ResolveType(die, true, true);
2447  if (!matching_type)
2448  return true;
2449 
2450  // We found a type pointer, now find the shared pointer form our type
2451  // list
2452  types.InsertUnique(matching_type->shared_from_this());
2453  return types.GetSize() < max_matches;
2454  });
2455 
2456  // Next search through the reachable Clang modules. This only applies for
2457  // DWARF objects compiled with -gmodules that haven't been processed by
2458  // dsymutil.
2459  if (types.GetSize() < max_matches) {
2461 
2462  for (const auto &pair : m_external_type_modules)
2463  if (ModuleSP external_module_sp = pair.second)
2464  if (SymbolFile *sym_file = external_module_sp->GetSymbolFile())
2465  sym_file->FindTypes(name, parent_decl_ctx, max_matches,
2466  searched_symbol_files, types);
2467  }
2468 
2469  if (log && types.GetSize()) {
2470  if (parent_decl_ctx) {
2471  GetObjectFile()->GetModule()->LogMessage(
2472  log,
2473  "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx "
2474  "= %p (\"%s\"), max_matches=%u, type_list) => %u",
2475  name.GetCString(), static_cast<const void *>(&parent_decl_ctx),
2476  parent_decl_ctx.GetName().AsCString("<NULL>"), max_matches,
2477  types.GetSize());
2478  } else {
2479  GetObjectFile()->GetModule()->LogMessage(
2480  log,
2481  "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx "
2482  "= NULL, max_matches=%u, type_list) => %u",
2483  name.GetCString(), max_matches, types.GetSize());
2484  }
2485  }
2486 }
2487 
2489  llvm::ArrayRef<CompilerContext> pattern, LanguageSet languages,
2490  llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) {
2491  // Make sure we haven't already searched this SymbolFile before.
2492  if (!searched_symbol_files.insert(this).second)
2493  return;
2494 
2495  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
2496  if (pattern.empty())
2497  return;
2498 
2499  ConstString name = pattern.back().name;
2500 
2501  if (!name)
2502  return;
2503 
2504  m_index->GetTypes(name, [&](DWARFDIE die) {
2505  if (!languages[GetLanguageFamily(*die.GetCU())])
2506  return true;
2507 
2508  llvm::SmallVector<CompilerContext, 4> die_context;
2509  die.GetDeclContext(die_context);
2510  if (!contextMatches(die_context, pattern))
2511  return true;
2512 
2513  if (Type *matching_type = ResolveType(die, true, true)) {
2514  // We found a type pointer, now find the shared pointer form our type
2515  // list.
2516  types.InsertUnique(matching_type->shared_from_this());
2517  }
2518  return true;
2519  });
2520 
2521  // Next search through the reachable Clang modules. This only applies for
2522  // DWARF objects compiled with -gmodules that haven't been processed by
2523  // dsymutil.
2525 
2526  for (const auto &pair : m_external_type_modules)
2527  if (ModuleSP external_module_sp = pair.second)
2528  external_module_sp->FindTypes(pattern, languages, searched_symbol_files,
2529  types);
2530 }
2531 
2534  const CompilerDeclContext &parent_decl_ctx) {
2535  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
2536  Log *log = GetLog(DWARFLog::Lookups);
2537 
2538  if (log) {
2539  GetObjectFile()->GetModule()->LogMessage(
2540  log, "SymbolFileDWARF::FindNamespace (sc, name=\"%s\")",
2541  name.GetCString());
2542  }
2543 
2544  CompilerDeclContext namespace_decl_ctx;
2545 
2546  if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
2547  return namespace_decl_ctx;
2548 
2549  m_index->GetNamespaces(name, [&](DWARFDIE die) {
2550  if (!DIEInDeclContext(parent_decl_ctx, die))
2551  return true; // The containing decl contexts don't match
2552 
2553  DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU());
2554  if (!dwarf_ast)
2555  return true;
2556 
2557  namespace_decl_ctx = dwarf_ast->GetDeclContextForUIDFromDWARF(die);
2558  return !namespace_decl_ctx.IsValid();
2559  });
2560 
2561  if (log && namespace_decl_ctx) {
2562  GetObjectFile()->GetModule()->LogMessage(
2563  log,
2564  "SymbolFileDWARF::FindNamespace (sc, name=\"%s\") => "
2565  "CompilerDeclContext(%p/%p) \"%s\"",
2566  name.GetCString(),
2567  static_cast<const void *>(namespace_decl_ctx.GetTypeSystem()),
2568  static_cast<const void *>(namespace_decl_ctx.GetOpaqueDeclContext()),
2569  namespace_decl_ctx.GetName().AsCString("<NULL>"));
2570  }
2571 
2572  return namespace_decl_ctx;
2573 }
2574 
2576  bool resolve_function_context) {
2577  TypeSP type_sp;
2578  if (die) {
2579  Type *type_ptr = GetDIEToType().lookup(die.GetDIE());
2580  if (type_ptr == nullptr) {
2581  SymbolContextScope *scope;
2582  if (auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU()))
2583  scope = GetCompUnitForDWARFCompUnit(*dwarf_cu);
2584  else
2585  scope = GetObjectFile()->GetModule().get();
2586  assert(scope);
2587  SymbolContext sc(scope);
2588  const DWARFDebugInfoEntry *parent_die = die.GetParent().GetDIE();
2589  while (parent_die != nullptr) {
2590  if (parent_die->Tag() == DW_TAG_subprogram)
2591  break;
2592  parent_die = parent_die->GetParent();
2593  }
2594  SymbolContext sc_backup = sc;
2595  if (resolve_function_context && parent_die != nullptr &&
2596  !GetFunction(DWARFDIE(die.GetCU(), parent_die), sc))
2597  sc = sc_backup;
2598 
2599  type_sp = ParseType(sc, die, nullptr);
2600  } else if (type_ptr != DIE_IS_BEING_PARSED) {
2601  // Get the original shared pointer for this type
2602  type_sp = type_ptr->shared_from_this();
2603  }
2604  }
2605  return type_sp;
2606 }
2607 
2608 DWARFDIE
2610  if (orig_die) {
2611  DWARFDIE die = orig_die;
2612 
2613  while (die) {
2614  // If this is the original DIE that we are searching for a declaration
2615  // for, then don't look in the cache as we don't want our own decl
2616  // context to be our decl context...
2617  if (orig_die != die) {
2618  switch (die.Tag()) {
2619  case DW_TAG_compile_unit:
2620  case DW_TAG_partial_unit:
2621  case DW_TAG_namespace:
2622  case DW_TAG_structure_type:
2623  case DW_TAG_union_type:
2624  case DW_TAG_class_type:
2625  case DW_TAG_lexical_block:
2626  case DW_TAG_subprogram:
2627  return die;
2628  case DW_TAG_inlined_subroutine: {
2629  DWARFDIE abs_die = die.GetReferencedDIE(DW_AT_abstract_origin);
2630  if (abs_die) {
2631  return abs_die;
2632  }
2633  break;
2634  }
2635  default:
2636  break;
2637  }
2638  }
2639 
2640  DWARFDIE spec_die = die.GetReferencedDIE(DW_AT_specification);
2641  if (spec_die) {
2642  DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(spec_die);
2643  if (decl_ctx_die)
2644  return decl_ctx_die;
2645  }
2646 
2647  DWARFDIE abs_die = die.GetReferencedDIE(DW_AT_abstract_origin);
2648  if (abs_die) {
2649  DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(abs_die);
2650  if (decl_ctx_die)
2651  return decl_ctx_die;
2652  }
2653 
2654  die = die.GetParent();
2655  }
2656  }
2657  return DWARFDIE();
2658 }
2659 
2661  Symbol *objc_class_symbol = nullptr;
2662  if (m_objfile_sp) {
2663  Symtab *symtab = m_objfile_sp->GetSymtab();
2664  if (symtab) {
2665  objc_class_symbol = symtab->FindFirstSymbolWithNameAndType(
2666  objc_class_name, eSymbolTypeObjCClass, Symtab::eDebugNo,
2667  Symtab::eVisibilityAny);
2668  }
2669  }
2670  return objc_class_symbol;
2671 }
2672 
2673 // Some compilers don't emit the DW_AT_APPLE_objc_complete_type attribute. If
2674 // they don't then we can end up looking through all class types for a complete
2675 // type and never find the full definition. We need to know if this attribute
2676 // is supported, so we determine this here and cache th result. We also need to
2677 // worry about the debug map
2678 // DWARF file
2679 // if we are doing darwin DWARF in .o file debugging.
2685  else {
2686  DWARFDebugInfo &debug_info = DebugInfo();
2687  const uint32_t num_compile_units = GetNumCompileUnits();
2688  for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
2689  DWARFUnit *dwarf_cu = debug_info.GetUnitAtIndex(cu_idx);
2690  if (dwarf_cu != cu &&
2693  break;
2694  }
2695  }
2696  }
2700  }
2702 }
2703 
2704 // This function can be used when a DIE is found that is a forward declaration
2705 // DIE and we want to try and find a type that has the complete definition.
2707  const DWARFDIE &die, ConstString type_name, bool must_be_implementation) {
2708 
2709  TypeSP type_sp;
2710 
2711  if (!type_name || (must_be_implementation && !GetObjCClassSymbol(type_name)))
2712  return type_sp;
2713 
2714  m_index->GetCompleteObjCClass(
2715  type_name, must_be_implementation, [&](DWARFDIE type_die) {
2716  bool try_resolving_type = false;
2717 
2718  // Don't try and resolve the DIE we are looking for with the DIE
2719  // itself!
2720  if (type_die != die) {
2721  switch (type_die.Tag()) {
2722  case DW_TAG_class_type:
2723  case DW_TAG_structure_type:
2724  try_resolving_type = true;
2725  break;
2726  default:
2727  break;
2728  }
2729  }
2730  if (!try_resolving_type)
2731  return true;
2732 
2733  if (must_be_implementation &&
2735  try_resolving_type = type_die.GetAttributeValueAsUnsigned(
2736  DW_AT_APPLE_objc_complete_type, 0);
2737  if (!try_resolving_type)
2738  return true;
2739 
2740  Type *resolved_type = ResolveType(type_die, false, true);
2741  if (!resolved_type || resolved_type == DIE_IS_BEING_PARSED)
2742  return true;
2743 
2744  DEBUG_PRINTF(
2745  "resolved 0x%8.8" PRIx64 " from %s to 0x%8.8" PRIx64
2746  " (cu 0x%8.8" PRIx64 ")\n",
2747  die.GetID(),
2748  m_objfile_sp->GetFileSpec().GetFilename().AsCString("<Unknown>"),
2749  type_die.GetID(), type_cu->GetID());
2750 
2751  if (die)
2752  GetDIEToType()[die.GetDIE()] = resolved_type;
2753  type_sp = resolved_type->shared_from_this();
2754  return false;
2755  });
2756  return type_sp;
2757 }
2758 
2759 // This function helps to ensure that the declaration contexts match for two
2760 // different DIEs. Often times debug information will refer to a forward
2761 // declaration of a type (the equivalent of "struct my_struct;". There will
2762 // often be a declaration of that type elsewhere that has the full definition.
2763 // When we go looking for the full type "my_struct", we will find one or more
2764 // matches in the accelerator tables and we will then need to make sure the
2765 // type was in the same declaration context as the original DIE. This function
2766 // can efficiently compare two DIEs and will return true when the declaration
2767 // context matches, and false when they don't.
2769  const DWARFDIE &die2) {
2770  if (die1 == die2)
2771  return true;
2772 
2773  std::vector<DWARFDIE> decl_ctx_1;
2774  std::vector<DWARFDIE> decl_ctx_2;
2775  // The declaration DIE stack is a stack of the declaration context DIEs all
2776  // the way back to the compile unit. If a type "T" is declared inside a class
2777  // "B", and class "B" is declared inside a class "A" and class "A" is in a
2778  // namespace "lldb", and the namespace is in a compile unit, there will be a
2779  // stack of DIEs:
2780  //
2781  // [0] DW_TAG_class_type for "B"
2782  // [1] DW_TAG_class_type for "A"
2783  // [2] DW_TAG_namespace for "lldb"
2784  // [3] DW_TAG_compile_unit or DW_TAG_partial_unit for the source file.
2785  //
2786  // We grab both contexts and make sure that everything matches all the way
2787  // back to the compiler unit.
2788 
2789  // First lets grab the decl contexts for both DIEs
2790  decl_ctx_1 = die1.GetDeclContextDIEs();
2791  decl_ctx_2 = die2.GetDeclContextDIEs();
2792  // Make sure the context arrays have the same size, otherwise we are done
2793  const size_t count1 = decl_ctx_1.size();
2794  const size_t count2 = decl_ctx_2.size();
2795  if (count1 != count2)
2796  return false;
2797 
2798  // Make sure the DW_TAG values match all the way back up the compile unit. If
2799  // they don't, then we are done.
2800  DWARFDIE decl_ctx_die1;
2801  DWARFDIE decl_ctx_die2;
2802  size_t i;
2803  for (i = 0; i < count1; i++) {
2804  decl_ctx_die1 = decl_ctx_1[i];
2805  decl_ctx_die2 = decl_ctx_2[i];
2806  if (decl_ctx_die1.Tag() != decl_ctx_die2.Tag())
2807  return false;
2808  }
2809 #ifndef NDEBUG
2810 
2811  // Make sure the top item in the decl context die array is always
2812  // DW_TAG_compile_unit or DW_TAG_partial_unit. If it isn't then
2813  // something went wrong in the DWARFDIE::GetDeclContextDIEs()
2814  // function.
2815  dw_tag_t cu_tag = decl_ctx_1[count1 - 1].Tag();
2816  UNUSED_IF_ASSERT_DISABLED(cu_tag);
2817  assert(cu_tag == DW_TAG_compile_unit || cu_tag == DW_TAG_partial_unit);
2818 
2819 #endif
2820  // Always skip the compile unit when comparing by only iterating up to "count
2821  // - 1". Here we compare the names as we go.
2822  for (i = 0; i < count1 - 1; i++) {
2823  decl_ctx_die1 = decl_ctx_1[i];
2824  decl_ctx_die2 = decl_ctx_2[i];
2825  const char *name1 = decl_ctx_die1.GetName();
2826  const char *name2 = decl_ctx_die2.GetName();
2827  // If the string was from a DW_FORM_strp, then the pointer will often be
2828  // the same!
2829  if (name1 == name2)
2830  continue;
2831 
2832  // Name pointers are not equal, so only compare the strings if both are not
2833  // NULL.
2834  if (name1 && name2) {
2835  // If the strings don't compare, we are done...
2836  if (strcmp(name1, name2) != 0)
2837  return false;
2838  } else {
2839  // One name was NULL while the other wasn't
2840  return false;
2841  }
2842  }
2843  // We made it through all of the checks and the declaration contexts are
2844  // equal.
2845  return true;
2846 }
2847 
2849  const DWARFDeclContext &dwarf_decl_ctx) {
2850  TypeSP type_sp;
2851 
2852  const uint32_t dwarf_decl_ctx_count = dwarf_decl_ctx.GetSize();
2853  if (dwarf_decl_ctx_count > 0) {
2854  const ConstString type_name(dwarf_decl_ctx[0].name);
2855  const dw_tag_t tag = dwarf_decl_ctx[0].tag;
2856 
2857  if (type_name) {
2858  Log *log = GetLog(DWARFLog::TypeCompletion | DWARFLog::Lookups);
2859  if (log) {
2860  GetObjectFile()->GetModule()->LogMessage(
2861  log,
2862  "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%"
2863  "s, qualified-name='%s')",
2864  DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
2865  dwarf_decl_ctx.GetQualifiedName());
2866  }
2867 
2868  // Get the type system that we are looking to find a type for. We will
2869  // use this to ensure any matches we find are in a language that this
2870  // type system supports
2871  const LanguageType language = dwarf_decl_ctx.GetLanguage();
2872  TypeSystem *type_system = nullptr;
2873  if (language != eLanguageTypeUnknown) {
2874  auto type_system_or_err = GetTypeSystemForLanguage(language);
2875  if (auto err = type_system_or_err.takeError()) {
2876  LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
2877  "Cannot get TypeSystem for language {}",
2878  Language::GetNameForLanguageType(language));
2879  } else {
2880  type_system = &type_system_or_err.get();
2881  }
2882  }
2883 
2884  m_index->GetTypes(dwarf_decl_ctx, [&](DWARFDIE type_die) {
2885  // Make sure type_die's language matches the type system we are
2886  // looking for. We don't want to find a "Foo" type from Java if we
2887  // are looking for a "Foo" type for C, C++, ObjC, or ObjC++.
2888  if (type_system &&
2889  !type_system->SupportsLanguage(GetLanguage(*type_die.GetCU())))
2890  return true;
2891  bool try_resolving_type = false;
2892 
2893  // Don't try and resolve the DIE we are looking for with the DIE
2894  // itself!
2895  const dw_tag_t type_tag = type_die.Tag();
2896  // Make sure the tags match
2897  if (type_tag == tag) {
2898  // The tags match, lets try resolving this type
2899  try_resolving_type = true;
2900  } else {
2901  // The tags don't match, but we need to watch our for a forward
2902  // declaration for a struct and ("struct foo") ends up being a
2903  // class ("class foo { ... };") or vice versa.
2904  switch (type_tag) {
2905  case DW_TAG_class_type:
2906  // We had a "class foo", see if we ended up with a "struct foo
2907  // { ... };"
2908  try_resolving_type = (tag == DW_TAG_structure_type);
2909  break;
2910  case DW_TAG_structure_type:
2911  // We had a "struct foo", see if we ended up with a "class foo
2912  // { ... };"
2913  try_resolving_type = (tag == DW_TAG_class_type);
2914  break;
2915  default:
2916  // Tags don't match, don't event try to resolve using this type
2917  // whose name matches....
2918  break;
2919  }
2920  }
2921 
2922  if (!try_resolving_type) {
2923  if (log) {
2924  std::string qualified_name;
2925  type_die.GetQualifiedName(qualified_name);
2926  GetObjectFile()->GetModule()->LogMessage(
2927  log,
2928  "SymbolFileDWARF::"
2929  "FindDefinitionTypeForDWARFDeclContext(tag=%s, "
2930  "qualified-name='%s') ignoring die=0x%8.8x (%s)",
2931  DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
2932  dwarf_decl_ctx.GetQualifiedName(), type_die.GetOffset(),
2933  qualified_name.c_str());
2934  }
2935  return true;
2936  }
2937 
2938  DWARFDeclContext type_dwarf_decl_ctx = GetDWARFDeclContext(type_die);
2939 
2940  if (log) {
2941  GetObjectFile()->GetModule()->LogMessage(
2942  log,
2943  "SymbolFileDWARF::"
2944  "FindDefinitionTypeForDWARFDeclContext(tag=%s, "
2945  "qualified-name='%s') trying die=0x%8.8x (%s)",
2946  DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
2947  dwarf_decl_ctx.GetQualifiedName(), type_die.GetOffset(),
2948  type_dwarf_decl_ctx.GetQualifiedName());
2949  }
2950 
2951  // Make sure the decl contexts match all the way up
2952  if (dwarf_decl_ctx != type_dwarf_decl_ctx)
2953  return true;
2954 
2955  Type *resolved_type = ResolveType(type_die, false);
2956  if (!resolved_type || resolved_type == DIE_IS_BEING_PARSED)
2957  return true;
2958 
2959  type_sp = resolved_type->shared_from_this();
2960  return false;
2961  });
2962  }
2963  }
2964  return type_sp;
2965 }
2966 
2968  bool *type_is_new_ptr) {
2969  if (!die)
2970  return {};
2971 
2972  auto type_system_or_err = GetTypeSystemForLanguage(GetLanguage(*die.GetCU()));
2973  if (auto err = type_system_or_err.takeError()) {
2974  LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
2975  "Unable to parse type");
2976  return {};
2977  }
2978 
2979  DWARFASTParser *dwarf_ast = type_system_or_err->GetDWARFParser();
2980  if (!dwarf_ast)
2981  return {};
2982 
2983  TypeSP type_sp = dwarf_ast->ParseTypeFromDWARF(sc, die, type_is_new_ptr);
2984  if (type_sp) {
2985  GetTypeList().Insert(type_sp);
2986 
2987  if (die.Tag() == DW_TAG_subprogram) {
2988  std::string scope_qualified_name(GetDeclContextForUID(die.GetID())
2990  .AsCString(""));
2991  if (scope_qualified_name.size()) {
2992  m_function_scope_qualified_name_map[scope_qualified_name].insert(
2993  *die.GetDIERef());
2994  }
2995  }
2996  }
2997 
2998  return type_sp;
2999 }
3000 
3002  const DWARFDIE &orig_die,
3003  bool parse_siblings, bool parse_children) {
3004  size_t types_added = 0;
3005  DWARFDIE die = orig_die;
3006 
3007  while (die) {
3008  const dw_tag_t tag = die.Tag();
3009  bool type_is_new = false;
3010 
3011  Tag dwarf_tag = static_cast<Tag>(tag);
3012 
3013  // TODO: Currently ParseTypeFromDWARF(...) which is called by ParseType(...)
3014  // does not handle DW_TAG_subrange_type. It is not clear if this is a bug or
3015  // not.
3016  if (isType(dwarf_tag) && tag != DW_TAG_subrange_type)
3017  ParseType(sc, die, &type_is_new);
3018 
3019  if (type_is_new)
3020  ++types_added;
3021 
3022  if (parse_children && die.HasChildren()) {
3023  if (die.Tag() == DW_TAG_subprogram) {
3024  SymbolContext child_sc(sc);
3025  child_sc.function = sc.comp_unit->FindFunctionByUID(die.GetID()).get();
3026  types_added += ParseTypes(child_sc, die.GetFirstChild(), true, true);
3027  } else
3028  types_added += ParseTypes(sc, die.GetFirstChild(), true, true);
3029  }
3030 
3031  if (parse_siblings)
3032  die = die.GetSibling();
3033  else
3034  die.Clear();
3035  }
3036  return types_added;
3037 }
3038 
3040  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
3041  CompileUnit *comp_unit = func.GetCompileUnit();
3042  lldbassert(comp_unit);
3043 
3044  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(comp_unit);
3045  if (!dwarf_cu)
3046  return 0;
3047 
3048  size_t functions_added = 0;
3049  const dw_offset_t function_die_offset = func.GetID();
3050  DWARFDIE function_die =
3051  dwarf_cu->GetNonSkeletonUnit().GetDIE(function_die_offset);
3052  if (function_die) {
3053  ParseBlocksRecursive(*comp_unit, &func.GetBlock(false), function_die,
3055  }
3056 
3057  return functions_added;
3058 }
3059 
3061  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
3062  size_t types_added = 0;
3063  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
3064  if (dwarf_cu) {
3065  DWARFDIE dwarf_cu_die = dwarf_cu->DIE();
3066  if (dwarf_cu_die && dwarf_cu_die.HasChildren()) {
3067  SymbolContext sc;
3068  sc.comp_unit = &comp_unit;
3069  types_added = ParseTypes(sc, dwarf_cu_die.GetFirstChild(), true, true);
3070  }
3071  }
3072 
3073  return types_added;
3074 }
3075 
3077  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
3078  if (sc.comp_unit != nullptr) {
3079  if (sc.function) {
3080  DWARFDIE function_die = GetDIE(sc.function->GetID());
3081 
3082  dw_addr_t func_lo_pc = LLDB_INVALID_ADDRESS;
3083  DWARFRangeList ranges;
3084  if (function_die.GetDIE()->GetAttributeAddressRanges(
3085  function_die.GetCU(), ranges,
3086  /*check_hi_lo_pc=*/true))
3087  func_lo_pc = ranges.GetMinRangeBase(0);
3088  if (func_lo_pc != LLDB_INVALID_ADDRESS) {
3089  const size_t num_variables =
3090  ParseVariablesInFunctionContext(sc, function_die, func_lo_pc);
3091 
3092  // Let all blocks know they have parse all their variables
3093  sc.function->GetBlock(false).SetDidParseVariables(true, true);
3094  return num_variables;
3095  }
3096  } else if (sc.comp_unit) {
3097  DWARFUnit *dwarf_cu = DebugInfo().GetUnitAtIndex(sc.comp_unit->GetID());
3098 
3099  if (dwarf_cu == nullptr)
3100  return 0;
3101 
3102  uint32_t vars_added = 0;
3103  VariableListSP variables(sc.comp_unit->GetVariableList(false));
3104 
3105  if (variables.get() == nullptr) {
3106  variables = std::make_shared<VariableList>();
3107  sc.comp_unit->SetVariableList(variables);
3108 
3109  m_index->GetGlobalVariables(*dwarf_cu, [&](DWARFDIE die) {
3110  VariableSP var_sp(ParseVariableDIECached(sc, die));
3111  if (var_sp) {
3112  variables->AddVariableIfUnique(var_sp);
3113  ++vars_added;
3114  }
3115  return true;
3116  });
3117  }
3118  return vars_added;
3119  }
3120  }
3121  return 0;
3122 }
3123 
3125  const DWARFDIE &die) {
3126  if (!die)
3127  return nullptr;
3128 
3129  DIEToVariableSP &die_to_variable = die.GetDWARF()->GetDIEToVariable();
3130 
3131  VariableSP var_sp = die_to_variable[die.GetDIE()];
3132  if (var_sp)
3133  return var_sp;
3134 
3135  var_sp = ParseVariableDIE(sc, die, LLDB_INVALID_ADDRESS);
3136  if (var_sp) {
3137  die_to_variable[die.GetDIE()] = var_sp;
3138  if (DWARFDIE spec_die = die.GetReferencedDIE(DW_AT_specification))
3139  die_to_variable[spec_die.GetDIE()] = var_sp;
3140  }
3141  return var_sp;
3142 }
3143 
3145  const DWARFDIE &die,
3146  const lldb::addr_t func_low_pc) {
3147  if (die.GetDWARF() != this)
3148  return die.GetDWARF()->ParseVariableDIE(sc, die, func_low_pc);
3149 
3150  if (!die)
3151  return nullptr;
3152 
3153  const dw_tag_t tag = die.Tag();
3154  ModuleSP module = GetObjectFile()->GetModule();
3155 
3156  if (tag != DW_TAG_variable && tag != DW_TAG_constant &&
3157  (tag != DW_TAG_formal_parameter || !sc.function))
3158  return nullptr;
3159 
3160  DWARFAttributes attributes;
3161  const size_t num_attributes = die.GetAttributes(attributes);
3162  const char *name = nullptr;
3163  const char *mangled = nullptr;
3164  Declaration decl;
3165  DWARFFormValue type_die_form;
3166  DWARFExpression location;
3167  bool is_external = false;
3168  bool is_artificial = false;
3169  DWARFFormValue const_value_form, location_form;
3170  Variable::RangeList scope_ranges;
3171 
3172  for (size_t i = 0; i < num_attributes; ++i) {
3173  dw_attr_t attr = attributes.AttributeAtIndex(i);
3174  DWARFFormValue form_value;
3175 
3176  if (!attributes.ExtractFormValueAtIndex(i, form_value))
3177  continue;
3178  switch (attr) {
3179  case DW_AT_decl_file:
3180  decl.SetFile(
3181  attributes.CompileUnitAtIndex(i)->GetFile(form_value.Unsigned()));
3182  break;
3183  case DW_AT_decl_line:
3184  decl.SetLine(form_value.Unsigned());
3185  break;
3186  case DW_AT_decl_column:
3187  decl.SetColumn(form_value.Unsigned());
3188  break;
3189  case DW_AT_name:
3190  name = form_value.AsCString();
3191  break;
3192  case DW_AT_linkage_name:
3193  case DW_AT_MIPS_linkage_name:
3194  mangled = form_value.AsCString();
3195  break;
3196  case DW_AT_type:
3197  type_die_form = form_value;
3198  break;
3199  case DW_AT_external:
3200  is_external = form_value.Boolean();
3201  break;
3202  case DW_AT_const_value:
3203  const_value_form = form_value;
3204  break;
3205  case DW_AT_location:
3206  location_form = form_value;
3207  break;
3208  case DW_AT_start_scope:
3209  // TODO: Implement this.
3210  break;
3211  case DW_AT_artificial:
3212  is_artificial = form_value.Boolean();
3213  break;
3214  case DW_AT_declaration:
3215  case DW_AT_description:
3216  case DW_AT_endianity:
3217  case DW_AT_segment:
3218  case DW_AT_specification:
3219  case DW_AT_visibility:
3220  default:
3221  case DW_AT_abstract_origin:
3222  case DW_AT_sibling:
3223  break;
3224  }
3225  }
3226 
3227  // Prefer DW_AT_location over DW_AT_const_value. Both can be emitted e.g.
3228  // for static constexpr member variables -- DW_AT_const_value will be
3229  // present in the class declaration and DW_AT_location in the DIE defining
3230  // the member.
3231  bool location_is_const_value_data = false;
3232  bool has_explicit_location = false;
3233  bool use_type_size_for_value = false;
3234  if (location_form.IsValid()) {
3235  has_explicit_location = true;
3236  if (DWARFFormValue::IsBlockForm(location_form.Form())) {
3237  const DWARFDataExtractor &data = die.GetData();
3238 
3239  uint32_t block_offset = location_form.BlockData() - data.GetDataStart();
3240  uint32_t block_length = location_form.Unsigned();
3241  location = DWARFExpression(
3242  module, DataExtractor(data, block_offset, block_length), die.GetCU());
3243  } else {
3244  DataExtractor data = die.GetCU()->GetLocationData();
3245  dw_offset_t offset = location_form.Unsigned();
3246  if (location_form.Form() == DW_FORM_loclistx)
3247  offset = die.GetCU()->GetLoclistOffset(offset).value_or(-1);
3248  if (data.ValidOffset(offset)) {
3249  data = DataExtractor(data, offset, data.GetByteSize() - offset);
3250  location = DWARFExpression(module, data, die.GetCU());
3251  assert(func_low_pc != LLDB_INVALID_ADDRESS);
3252  location.SetLocationListAddresses(
3253  location_form.GetUnit()->GetBaseAddress(), func_low_pc);
3254  }
3255  }
3256  } else if (const_value_form.IsValid()) {
3257  location_is_const_value_data = true;
3258  // The constant value will be either a block, a data value or a
3259  // string.
3260  const DWARFDataExtractor &debug_info_data = die.GetData();
3261  if (DWARFFormValue::IsBlockForm(const_value_form.Form())) {
3262  // Retrieve the value as a block expression.
3263  uint32_t block_offset =
3264  const_value_form.BlockData() - debug_info_data.GetDataStart();
3265  uint32_t block_length = const_value_form.Unsigned();
3266  location = DWARFExpression(
3267  module, DataExtractor(debug_info_data, block_offset, block_length),
3268  die.GetCU());
3269  } else if (DWARFFormValue::IsDataForm(const_value_form.Form())) {
3270  // Constant value size does not have to match the size of the
3271  // variable. We will fetch the size of the type after we create
3272  // it.
3273  use_type_size_for_value = true;
3274  } else if (const char *str = const_value_form.AsCString()) {
3275  uint32_t string_length = strlen(str) + 1;
3276  location = DWARFExpression(
3277  module,
3278  DataExtractor(str, string_length, die.GetCU()->GetByteOrder(),
3279  die.GetCU()->GetAddressByteSize()),
3280  die.GetCU());
3281  }
3282  }
3283 
3284  const DWARFDIE parent_context_die = GetDeclContextDIEContainingDIE(die);
3285  const DWARFDIE sc_parent_die = GetParentSymbolContextDIE(die);
3286  const dw_tag_t parent_tag = sc_parent_die.Tag();
3287  bool is_static_member = (parent_tag == DW_TAG_compile_unit ||
3288  parent_tag == DW_TAG_partial_unit) &&
3289  (parent_context_die.Tag() == DW_TAG_class_type ||
3290  parent_context_die.Tag() == DW_TAG_structure_type);
3291 
3292  ValueType scope = eValueTypeInvalid;
3293  SymbolContextScope *symbol_context_scope = nullptr;
3294 
3295  bool has_explicit_mangled = mangled != nullptr;
3296  if (!mangled) {
3297  // LLDB relies on the mangled name (DW_TAG_linkage_name or
3298  // DW_AT_MIPS_linkage_name) to generate fully qualified names
3299  // of global variables with commands like "frame var j". For
3300  // example, if j were an int variable holding a value 4 and
3301  // declared in a namespace B which in turn is contained in a
3302  // namespace A, the command "frame var j" returns
3303  // "(int) A::B::j = 4".
3304  // If the compiler does not emit a linkage name, we should be
3305  // able to generate a fully qualified name from the
3306  // declaration context.
3307  if ((parent_tag == DW_TAG_compile_unit ||
3308  parent_tag == DW_TAG_partial_unit) &&
3309  Language::LanguageIsCPlusPlus(GetLanguage(*die.GetCU())))
3310  mangled =
3312  }
3313 
3314  if (tag == DW_TAG_formal_parameter)
3316  else {
3317  // DWARF doesn't specify if a DW_TAG_variable is a local, global
3318  // or static variable, so we have to do a little digging:
3319  // 1) DW_AT_linkage_name implies static lifetime (but may be missing)
3320  // 2) An empty DW_AT_location is an (optimized-out) static lifetime var.
3321  // 3) DW_AT_location containing a DW_OP_addr implies static lifetime.
3322  // Clang likes to combine small global variables into the same symbol
3323  // with locations like: DW_OP_addr(0x1000), DW_OP_constu(2), DW_OP_plus
3324  // so we need to look through the whole expression.
3325  bool is_static_lifetime =
3326  has_explicit_mangled || (has_explicit_location && !location.IsValid());
3327  // Check if the location has a DW_OP_addr with any address value...
3328  lldb::addr_t location_DW_OP_addr = LLDB_INVALID_ADDRESS;
3329  if (!location_is_const_value_data) {
3330  bool op_error = false;
3331  location_DW_OP_addr = location.GetLocation_DW_OP_addr(0, op_error);
3332  if (op_error) {
3333  StreamString strm;
3334  location.DumpLocationForAddress(&strm, eDescriptionLevelFull, 0, 0,
3335  nullptr);
3336  GetObjectFile()->GetModule()->ReportError(
3337  "0x%8.8x: %s has an invalid location: %s", die.GetOffset(),
3338  die.GetTagAsCString(), strm.GetData());
3339  }
3340  if (location_DW_OP_addr != LLDB_INVALID_ADDRESS)
3341  is_static_lifetime = true;
3342  }
3343  SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
3344  if (debug_map_symfile)
3345  // Set the module of the expression to the linked module
3346  // instead of the object file so the relocated address can be
3347  // found there.
3348  location.SetModule(debug_map_symfile->GetObjectFile()->GetModule());
3349 
3350  if (is_static_lifetime) {
3351  if (is_external)
3352  scope = eValueTypeVariableGlobal;
3353  else
3354  scope = eValueTypeVariableStatic;
3355 
3356  if (debug_map_symfile) {
3357  // When leaving the DWARF in the .o files on darwin, when we have a
3358  // global variable that wasn't initialized, the .o file might not
3359  // have allocated a virtual address for the global variable. In
3360  // this case it will have created a symbol for the global variable
3361  // that is undefined/data and external and the value will be the
3362  // byte size of the variable. When we do the address map in
3363  // SymbolFileDWARFDebugMap we rely on having an address, we need to
3364  // do some magic here so we can get the correct address for our
3365  // global variable. The address for all of these entries will be
3366  // zero, and there will be an undefined symbol in this object file,
3367  // and the executable will have a matching symbol with a good
3368  // address. So here we dig up the correct address and replace it in
3369  // the location for the variable, and set the variable's symbol
3370  // context scope to be that of the main executable so the file
3371  // address will resolve correctly.
3372  bool linked_oso_file_addr = false;
3373  if (is_external && location_DW_OP_addr == 0) {
3374  // we have a possible uninitialized extern global
3375  ConstString const_name(mangled ? mangled : name);
3376  ObjectFile *debug_map_objfile = debug_map_symfile->GetObjectFile();
3377  if (debug_map_objfile) {
3378  Symtab *debug_map_symtab = debug_map_objfile->GetSymtab();
3379  if (debug_map_symtab) {
3380  Symbol *exe_symbol =
3381  debug_map_symtab->FindFirstSymbolWithNameAndType(
3382  const_name, eSymbolTypeData, Symtab::eDebugYes,
3383  Symtab::eVisibilityExtern);
3384  if (exe_symbol) {
3385  if (exe_symbol->ValueIsAddress()) {
3386  const addr_t exe_file_addr =
3387  exe_symbol->GetAddressRef().GetFileAddress();
3388  if (exe_file_addr != LLDB_INVALID_ADDRESS) {
3389  if (location.Update_DW_OP_addr(exe_file_addr)) {
3390  linked_oso_file_addr = true;
3391  symbol_context_scope = exe_symbol;
3392  }
3393  }
3394  }
3395  }
3396  }
3397  }
3398  }
3399 
3400  if (!linked_oso_file_addr) {
3401  // The DW_OP_addr is not zero, but it contains a .o file address
3402  // which needs to be linked up correctly.
3403  const lldb::addr_t exe_file_addr =
3404  debug_map_symfile->LinkOSOFileAddress(this, location_DW_OP_addr);
3405  if (exe_file_addr != LLDB_INVALID_ADDRESS) {
3406  // Update the file address for this variable
3407  location.Update_DW_OP_addr(exe_file_addr);
3408  } else {
3409  // Variable didn't make it into the final executable
3410  return nullptr;
3411  }
3412  }
3413  }
3414  } else {
3415  if (location_is_const_value_data &&
3416  die.GetDIE()->IsGlobalOrStaticScopeVariable())
3417  scope = eValueTypeVariableStatic;
3418  else {
3419  scope = eValueTypeVariableLocal;
3420  if (debug_map_symfile) {
3421  // We need to check for TLS addresses that we need to fixup
3422  if (location.ContainsThreadLocalStorage()) {
3423  location.LinkThreadLocalStorage(
3424  debug_map_symfile->GetObjectFile()->GetModule(),
3425  [this, debug_map_symfile](
3426  lldb::addr_t unlinked_file_addr) -> lldb::addr_t {
3427  return debug_map_symfile->LinkOSOFileAddress(
3428  this, unlinked_file_addr);
3429  });
3431  }
3432  }
3433  }
3434  }
3435  }
3436 
3437  if (symbol_context_scope == nullptr) {
3438  switch (parent_tag) {
3439  case DW_TAG_subprogram:
3440  case DW_TAG_inlined_subroutine:
3441  case DW_TAG_lexical_block:
3442  if (sc.function) {
3443  symbol_context_scope =
3444  sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID());
3445  if (symbol_context_scope == nullptr)
3446  symbol_context_scope = sc.function;
3447  }
3448  break;
3449 
3450  default:
3451  symbol_context_scope = sc.comp_unit;
3452  break;
3453  }
3454  }
3455 
3456  if (!symbol_context_scope) {
3457  // Not ready to parse this variable yet. It might be a global or static
3458  // variable that is in a function scope and the function in the symbol
3459  // context wasn't filled in yet
3460  return nullptr;
3461  }
3462 
3463  auto type_sp = std::make_shared<SymbolFileType>(
3464  *this, GetUID(type_die_form.Reference()));
3465 
3466  if (use_type_size_for_value && type_sp->GetType())
3467  location.UpdateValue(const_value_form.Unsigned(),
3468  type_sp->GetType()->GetByteSize(nullptr).value_or(0),
3469  die.GetCU()->GetAddressByteSize());
3470 
3471  return std::make_shared<Variable>(
3472  die.GetID(), name, mangled, type_sp, scope, symbol_context_scope,
3473  scope_ranges, &decl, location, is_external, is_artificial,
3474  location_is_const_value_data, is_static_member);
3475 }
3476 
3477 DWARFDIE
3479  const DIERef &func_die_ref, dw_offset_t spec_block_die_offset) {
3480  // Give the concrete function die specified by "func_die_offset", find the
3481  // concrete block whose DW_AT_specification or DW_AT_abstract_origin points
3482  // to "spec_block_die_offset"
3483  return FindBlockContainingSpecification(DebugInfo().GetDIE(func_die_ref),
3484  spec_block_die_offset);
3485 }
3486 
3487 DWARFDIE
3489  const DWARFDIE &die, dw_offset_t spec_block_die_offset) {
3490  if (die) {
3491  switch (die.Tag()) {
3492  case DW_TAG_subprogram:
3493  case DW_TAG_inlined_subroutine:
3494  case DW_TAG_lexical_block: {
3495  if (die.GetReferencedDIE(DW_AT_specification).GetOffset() ==
3496  spec_block_die_offset)
3497  return die;
3498 
3499  if (die.GetReferencedDIE(DW_AT_abstract_origin).GetOffset() ==
3500  spec_block_die_offset)
3501  return die;
3502  } break;
3503  default:
3504  break;
3505  }
3506 
3507  // Give the concrete function die specified by "func_die_offset", find the
3508  // concrete block whose DW_AT_specification or DW_AT_abstract_origin points
3509  // to "spec_block_die_offset"
3510  for (DWARFDIE child_die : die.children()) {
3511  DWARFDIE result_die =
3512  FindBlockContainingSpecification(child_die, spec_block_die_offset);
3513  if (result_die)
3514  return result_die;
3515  }
3516  }
3517 
3518  return DWARFDIE();
3519 }
3520 
3522  const SymbolContext &sc, const DWARFDIE &die,
3523  VariableList &cc_variable_list) {
3524  if (!die)
3525  return;
3526 
3527  dw_tag_t tag = die.Tag();
3528  if (tag != DW_TAG_variable && tag != DW_TAG_constant)
3529  return;
3530 
3531  // Check to see if we have already parsed this variable or constant?
3532  VariableSP var_sp = GetDIEToVariable()[die.GetDIE()];
3533  if (var_sp) {
3534  cc_variable_list.AddVariableIfUnique(var_sp);
3535  return;
3536  }
3537 
3538  // We haven't parsed the variable yet, lets do that now. Also, let us include
3539  // the variable in the relevant compilation unit's variable list, if it
3540  // exists.
3541  VariableListSP variable_list_sp;
3542  DWARFDIE sc_parent_die = GetParentSymbolContextDIE(die);
3543  dw_tag_t parent_tag = sc_parent_die.Tag();
3544  switch (parent_tag) {
3545  case DW_TAG_compile_unit:
3546  case DW_TAG_partial_unit:
3547  if (sc.comp_unit != nullptr) {
3548  variable_list_sp = sc.comp_unit->GetVariableList(false);
3549  } else {
3550  GetObjectFile()->GetModule()->ReportError(
3551  "parent 0x%8.8" PRIx64 " %s with no valid compile unit in "
3552  "symbol context for 0x%8.8" PRIx64 " %s.\n",
3553  sc_parent_die.GetID(), sc_parent_die.GetTagAsCString(), die.GetID(),
3554  die.GetTagAsCString());
3555  return;
3556  }
3557  break;
3558 
3559  default:
3560  GetObjectFile()->GetModule()->ReportError(
3561  "didn't find appropriate parent DIE for variable list for "
3562  "0x%8.8" PRIx64 " %s.\n",
3563  die.GetID(), die.GetTagAsCString());
3564  return;
3565  }
3566 
3567  var_sp = ParseVariableDIECached(sc, die);
3568  if (!var_sp)
3569  return;
3570 
3571  cc_variable_list.AddVariableIfUnique(var_sp);
3572  if (variable_list_sp)
3573  variable_list_sp->AddVariableIfUnique(var_sp);
3574 }
3575 
3576 DIEArray
3578  DIEArray &&variable_dies) {
3579  // DW_TAG_inline_subroutine objects may omit DW_TAG_formal_parameter in
3580  // instances of the function when they are unused (i.e., the parameter's
3581  // location list would be empty). The current DW_TAG_inline_subroutine may
3582  // refer to another DW_TAG_subprogram that might actually have the definitions
3583  // of the parameters and we need to include these so they show up in the
3584  // variables for this function (for example, in a stack trace). Let us try to
3585  // find the abstract subprogram that might contain the parameter definitions
3586  // and merge with the concrete parameters.
3587 
3588  // Nothing to merge if the block is not an inlined function.
3589  if (block_die.Tag() != DW_TAG_inlined_subroutine) {
3590  return std::move(variable_dies);
3591  }
3592 
3593  // Nothing to merge if the block does not have abstract parameters.
3594  DWARFDIE abs_die = block_die.GetReferencedDIE(DW_AT_abstract_origin);
3595  if (!abs_die || abs_die.Tag() != DW_TAG_subprogram ||
3596  !abs_die.HasChildren()) {
3597  return std::move(variable_dies);
3598  }
3599 
3600  // For each abstract parameter, if we have its concrete counterpart, insert
3601  // it. Otherwise, insert the abstract parameter.
3602  DIEArray::iterator concrete_it = variable_dies.begin();
3603  DWARFDIE abstract_child = abs_die.GetFirstChild();
3604  DIEArray merged;
3605  bool did_merge_abstract = false;
3606  for (; abstract_child; abstract_child = abstract_child.GetSibling()) {
3607  if (abstract_child.Tag() == DW_TAG_formal_parameter) {
3608  if (concrete_it == variable_dies.end() ||
3609  GetDIE(*concrete_it).Tag() != DW_TAG_formal_parameter) {
3610  // We arrived at the end of the concrete parameter list, so all
3611  // the remaining abstract parameters must have been omitted.
3612  // Let us insert them to the merged list here.
3613  merged.push_back(*abstract_child.GetDIERef());
3614  did_merge_abstract = true;
3615  continue;
3616  }
3617 
3618  DWARFDIE origin_of_concrete =
3619  GetDIE(*concrete_it).GetReferencedDIE(DW_AT_abstract_origin);
3620  if (origin_of_concrete == abstract_child) {
3621  // The current abstract parameter is the origin of the current
3622  // concrete parameter, just push the concrete parameter.
3623  merged.push_back(*concrete_it);
3624  ++concrete_it;
3625  } else {
3626  // Otherwise, the parameter must have been omitted from the concrete
3627  // function, so insert the abstract one.
3628  merged.push_back(*abstract_child.GetDIERef());
3629  did_merge_abstract = true;
3630  }
3631  }
3632  }
3633 
3634  // Shortcut if no merging happened.
3635  if (!did_merge_abstract)
3636  return std::move(variable_dies);
3637 
3638  // We inserted all the abstract parameters (or their concrete counterparts).
3639  // Let us insert all the remaining concrete variables to the merged list.
3640  // During the insertion, let us check there are no remaining concrete
3641  // formal parameters. If that's the case, then just bailout from the merge -
3642  // the variable list is malformed.
3643  for (; concrete_it != variable_dies.end(); ++concrete_it) {
3644  if (GetDIE(*concrete_it).Tag() == DW_TAG_formal_parameter) {
3645  return std::move(variable_dies);
3646  }
3647  merged.push_back(*concrete_it);
3648  }
3649  return merged;
3650 }
3651 
3653  const SymbolContext &sc, const DWARFDIE &die,
3654  const lldb::addr_t func_low_pc) {
3655  if (!die || !sc.function)
3656  return 0;
3657 
3658  DIEArray dummy_block_variables; // The recursive call should not add anything
3659  // to this vector because |die| should be a
3660  // subprogram, so all variables will be added
3661  // to the subprogram's list.
3662  return ParseVariablesInFunctionContextRecursive(sc, die, func_low_pc,
3663  dummy_block_variables);
3664 }
3665 
3666 // This method parses all the variables in the blocks in the subtree of |die|,
3667 // and inserts them to the variable list for all the nested blocks.
3668 // The uninserted variables for the current block are accumulated in
3669 // |accumulator|.
3671  const lldb_private::SymbolContext &sc, const DWARFDIE &die,
3672  lldb::addr_t func_low_pc, DIEArray &accumulator) {
3673  size_t vars_added = 0;
3674  dw_tag_t tag = die.Tag();
3675 
3676  if ((tag == DW_TAG_variable) || (tag == DW_TAG_constant) ||
3677  (tag == DW_TAG_formal_parameter)) {
3678  accumulator.push_back(*die.GetDIERef());
3679  }
3680 
3681  switch (tag) {
3682  case DW_TAG_subprogram:
3683  case DW_TAG_inlined_subroutine:
3684  case DW_TAG_lexical_block: {
3685  // If we start a new block, compute a new block variable list and recurse.
3686  Block *block =
3687  sc.function->GetBlock(/*can_create=*/true).FindBlockByID(die.GetID());
3688  if (block == nullptr) {
3689  // This must be a specification or abstract origin with a
3690  // concrete block counterpart in the current function. We need
3691  // to find the concrete block so we can correctly add the
3692  // variable to it.
3693  const DWARFDIE concrete_block_die = FindBlockContainingSpecification(
3694  GetDIE(sc.function->GetID()), die.GetOffset());
3695  if (concrete_block_die)
3696  block = sc.function->GetBlock(/*can_create=*/true)
3697  .FindBlockByID(concrete_block_die.GetID());
3698  }
3699 
3700  if (block == nullptr)
3701  return 0;
3702 
3703  const bool can_create = false;
3704  VariableListSP block_variable_list_sp =
3705  block->GetBlockVariableList(can_create);
3706  if (block_variable_list_sp.get() == nullptr) {
3707  block_variable_list_sp = std::make_shared<VariableList>();
3708  block->SetVariableList(block_variable_list_sp);
3709  }
3710 
3711  DIEArray block_variables;
3712  for (DWARFDIE child = die.GetFirstChild(); child;
3713  child = child.GetSibling()) {
3715  sc, child, func_low_pc, block_variables);
3716  }
3717  block_variables =
3718  MergeBlockAbstractParameters(die, std::move(block_variables));
3719  vars_added += PopulateBlockVariableList(*block_variable_list_sp, sc,
3720  block_variables, func_low_pc);
3721  break;
3722  }
3723 
3724  default:
3725  // Recurse to children with the same variable accumulator.
3726  for (DWARFDIE child = die.GetFirstChild(); child;
3727  child = child.GetSibling()) {
3729  sc, child, func_low_pc, accumulator);
3730  }
3731  break;
3732  }
3733 
3734  return vars_added;
3735 }
3736 
3738  VariableList &variable_list, const lldb_private::SymbolContext &sc,
3739  llvm::ArrayRef<DIERef> variable_dies, lldb::addr_t func_low_pc) {
3740  // Parse the variable DIEs and insert them to the list.
3741  for (auto &die : variable_dies) {
3742  if (VariableSP var_sp = ParseVariableDIE(sc, GetDIE(die), func_low_pc)) {
3743  variable_list.AddVariableIfUnique(var_sp);
3744  }
3745  }
3746  return variable_dies.size();
3747 }
3748 
3749 /// Collect call site parameters in a DW_TAG_call_site DIE.
3751 CollectCallSiteParameters(ModuleSP module, DWARFDIE call_site_die) {
3752  CallSiteParameterArray parameters;
3753  for (DWARFDIE child : call_site_die.children()) {
3754  if (child.Tag() != DW_TAG_call_site_parameter &&
3755  child.Tag() != DW_TAG_GNU_call_site_parameter)
3756  continue;
3757 
3758  llvm::Optional<DWARFExpression> LocationInCallee;
3759  llvm::Optional<DWARFExpression> LocationInCaller;
3760 
3761  DWARFAttributes attributes;
3762  const size_t num_attributes = child.GetAttributes(attributes);
3763 
3764  // Parse the location at index \p attr_index within this call site parameter
3765  // DIE, or return None on failure.
3766  auto parse_simple_location =
3767  [&](int attr_index) -> llvm::Optional<DWARFExpression> {
3768  DWARFFormValue form_value;
3769  if (!attributes.ExtractFormValueAtIndex(attr_index, form_value))
3770  return {};
3771  if (!DWARFFormValue::IsBlockForm(form_value.Form()))
3772  return {};
3773  auto data = child.GetData();
3774  uint32_t block_offset = form_value.BlockData() - data.GetDataStart();
3775  uint32_t block_length = form_value.Unsigned();
3776  return DWARFExpression(module,
3777  DataExtractor(data, block_offset, block_length),
3778  child.GetCU());
3779  };
3780 
3781  for (size_t i = 0; i < num_attributes; ++i) {
3782  dw_attr_t attr = attributes.AttributeAtIndex(i);
3783  if (attr == DW_AT_location)
3784  LocationInCallee = parse_simple_location(i);
3785  if (attr == DW_AT_call_value || attr == DW_AT_GNU_call_site_value)
3786  LocationInCaller = parse_simple_location(i);
3787  }
3788 
3789  if (LocationInCallee && LocationInCaller) {
3790  CallSiteParameter param = {*LocationInCallee, *LocationInCaller};
3791  parameters.push_back(param);
3792  }
3793  }
3794  return parameters;
3795 }
3796 
3797 /// Collect call graph edges present in a function DIE.
3798 std::vector<std::unique_ptr<lldb_private::CallEdge>>
3799 SymbolFileDWARF::CollectCallEdges(ModuleSP module, DWARFDIE function_die) {
3800  // Check if the function has a supported call site-related attribute.
3801  // TODO: In the future it may be worthwhile to support call_all_source_calls.
3802  bool has_call_edges =
3803  function_die.GetAttributeValueAsUnsigned(DW_AT_call_all_calls, 0) ||
3804  function_die.GetAttributeValueAsUnsigned(DW_AT_GNU_all_call_sites, 0);
3805  if (!has_call_edges)
3806  return {};
3807 
3808  Log *log = GetLog(LLDBLog::Step);
3809  LLDB_LOG(log, "CollectCallEdges: Found call site info in {0}",
3810  function_die.GetPubname());
3811 
3812  // Scan the DIE for TAG_call_site entries.
3813  // TODO: A recursive scan of all blocks in the subprogram is needed in order
3814  // to be DWARF5-compliant. This may need to be done lazily to be performant.
3815  // For now, assume that all entries are nested directly under the subprogram
3816  // (this is the kind of DWARF LLVM produces) and parse them eagerly.
3817  std::vector<std::unique_ptr<CallEdge>> call_edges;
3818  for (DWARFDIE child : function_die.children()) {
3819  if (child.Tag() != DW_TAG_call_site && child.Tag() != DW_TAG_GNU_call_site)
3820  continue;
3821 
3822  llvm::Optional<DWARFDIE> call_origin;
3823  llvm::Optional<DWARFExpression> call_target;
3824  addr_t return_pc = LLDB_INVALID_ADDRESS;
3825  addr_t call_inst_pc = LLDB_INVALID_ADDRESS;
3826  addr_t low_pc = LLDB_INVALID_ADDRESS;
3827  bool tail_call = false;
3828 
3829  // Second DW_AT_low_pc may come from DW_TAG_subprogram referenced by
3830  // DW_TAG_GNU_call_site's DW_AT_abstract_origin overwriting our 'low_pc'.
3831  // So do not inherit attributes from DW_AT_abstract_origin.
3832  DWARFAttributes attributes;
3833  const size_t num_attributes =
3834  child.GetAttributes(attributes, DWARFDIE::Recurse::no);
3835  for (size_t i = 0; i < num_attributes; ++i) {
3836  DWARFFormValue form_value;
3837  if (!attributes.ExtractFormValueAtIndex(i, form_value)) {
3838  LLDB_LOG(log, "CollectCallEdges: Could not extract TAG_call_site form");
3839  break;
3840  }
3841 
3842  dw_attr_t attr = attributes.AttributeAtIndex(i);
3843 
3844  if (attr == DW_AT_call_tail_call || attr == DW_AT_GNU_tail_call)
3845  tail_call = form_value.Boolean();
3846 
3847  // Extract DW_AT_call_origin (the call target's DIE).
3848  if (attr == DW_AT_call_origin || attr == DW_AT_abstract_origin) {
3849  call_origin = form_value.Reference();
3850  if (!call_origin->IsValid()) {
3851  LLDB_LOG(log, "CollectCallEdges: Invalid call origin in {0}",
3852  function_die.GetPubname());
3853  break;
3854  }
3855  }
3856 
3857  if (attr == DW_AT_low_pc)
3858  low_pc = form_value.Address();
3859 
3860  // Extract DW_AT_call_return_pc (the PC the call returns to) if it's
3861  // available. It should only ever be unavailable for tail call edges, in
3862  // which case use LLDB_INVALID_ADDRESS.
3863  if (attr == DW_AT_call_return_pc)
3864  return_pc = form_value.Address();
3865 
3866  // Extract DW_AT_call_pc (the PC at the call/branch instruction). It
3867  // should only ever be unavailable for non-tail calls, in which case use
3868  // LLDB_INVALID_ADDRESS.
3869  if (attr == DW_AT_call_pc)
3870  call_inst_pc = form_value.Address();
3871 
3872  // Extract DW_AT_call_target (the location of the address of the indirect
3873  // call).
3874  if (attr == DW_AT_call_target || attr == DW_AT_GNU_call_site_target) {
3875  if (!DWARFFormValue::IsBlockForm(form_value.Form())) {
3876  LLDB_LOG(log,
3877  "CollectCallEdges: AT_call_target does not have block form");
3878  break;
3879  }
3880 
3881  auto data = child.GetData();
3882  uint32_t block_offset = form_value.BlockData() - data.GetDataStart();
3883  uint32_t block_length = form_value.Unsigned();
3884  call_target = DWARFExpression(
3885  module, DataExtractor(data, block_offset, block_length),
3886  child.GetCU());
3887  }
3888  }
3889  if (!call_origin && !call_target) {
3890  LLDB_LOG(log, "CollectCallEdges: call site without any call target");
3891  continue;
3892  }
3893 
3894  addr_t caller_address;
3895  CallEdge::AddrType caller_address_type;
3896  if (return_pc != LLDB_INVALID_ADDRESS) {
3897  caller_address = return_pc;
3898  caller_address_type = CallEdge::AddrType::AfterCall;
3899  } else if (low_pc != LLDB_INVALID_ADDRESS) {
3900  caller_address = low_pc;
3901  caller_address_type = CallEdge::AddrType::AfterCall;
3902  } else if (call_inst_pc != LLDB_INVALID_ADDRESS) {
3903  caller_address = call_inst_pc;
3904  caller_address_type = CallEdge::AddrType::Call;
3905  } else {
3906  LLDB_LOG(log, "CollectCallEdges: No caller address");
3907  continue;
3908  }
3909  // Adjust any PC forms. It needs to be fixed up if the main executable
3910  // contains a debug map (i.e. pointers to object files), because we need a
3911  // file address relative to the executable's text section.
3912  caller_address = FixupAddress(caller_address);
3913 
3914  // Extract call site parameters.
3915  CallSiteParameterArray parameters =
3916  CollectCallSiteParameters(module, child);
3917 
3918  std::unique_ptr<CallEdge> edge;
3919  if (call_origin) {
3920  LLDB_LOG(log,
3921  "CollectCallEdges: Found call origin: {0} (retn-PC: {1:x}) "
3922  "(call-PC: {2:x})",
3923  call_origin->GetPubname(), return_pc, call_inst_pc);
3924  edge = std::make_unique<DirectCallEdge>(
3925  call_origin->GetMangledName(), caller_address_type, caller_address,
3926  tail_call, std::move(parameters));
3927  } else {
3928  if (log) {
3929  StreamString call_target_desc;
3930  call_target->GetDescription(&call_target_desc, eDescriptionLevelBrief,
3931  nullptr);
3932  LLDB_LOG(log, "CollectCallEdges: Found indirect call target: {0}",
3933  call_target_desc.GetString());
3934  }
3935  edge = std::make_unique<IndirectCallEdge>(
3936  *call_target, caller_address_type, caller_address, tail_call,
3937  std::move(parameters));
3938  }
3939 
3940  if (log && parameters.size()) {
3941  for (const CallSiteParameter &param : parameters) {
3942  StreamString callee_loc_desc, caller_loc_desc;
3943  param.LocationInCallee.GetDescription(&callee_loc_desc,
3944  eDescriptionLevelBrief, nullptr);
3945  param.LocationInCaller.GetDescription(&caller_loc_desc,
3946  eDescriptionLevelBrief, nullptr);
3947  LLDB_LOG(log, "CollectCallEdges: \tparam: {0} => {1}",
3948  callee_loc_desc.GetString(), caller_loc_desc.GetString());
3949  }
3950  }
3951 
3952  call_edges.push_back(std::move(edge));
3953  }
3954  return call_edges;
3955 }
3956 
3957 std::vector<std::unique_ptr<lldb_private::CallEdge>>
3959  // ParseCallEdgesInFunction must be called at the behest of an exclusively
3960  // locked lldb::Function instance. Storage for parsed call edges is owned by
3961  // the lldb::Function instance: locking at the SymbolFile level would be too
3962  // late, because the act of storing results from ParseCallEdgesInFunction
3963  // would be racy.
3964  DWARFDIE func_die = GetDIE(func_id.GetID());
3965  if (func_die.IsValid())
3966  return CollectCallEdges(GetObjectFile()->GetModule(), func_die);
3967  return {};
3968 }
3969 
3971  SymbolFileCommon::Dump(s);
3972  m_index->Dump(s);
3973 }
3974 
3977  if (!ts_or_err)
3978  return;
3980  llvm::dyn_cast_or_null<TypeSystemClang>(&ts_or_err.get());
3981  if (!clang)
3982  return;
3983  clang->Dump(s.AsRawOstream());
3984 }
3985 
3987  if (m_debug_map_symfile == nullptr) {
3988  lldb::ModuleSP module_sp(m_debug_map_module_wp.lock());
3989  if (module_sp) {
3990  m_debug_map_symfile = llvm::cast<SymbolFileDWARFDebugMap>(
3991  module_sp->GetSymbolFile()->GetBackingSymbolFile());
3992  }
3993  }
3994  return m_debug_map_symfile;
3995 }
3996 
3997 const std::shared_ptr<SymbolFileDWARFDwo> &SymbolFileDWARF::GetDwpSymbolFile() {
3998  llvm::call_once(m_dwp_symfile_once_flag, [this]() {
3999  ModuleSpec module_spec;
4000  module_spec.GetFileSpec() = m_objfile_sp->GetFileSpec();
4001  module_spec.GetSymbolFileSpec() =
4002  FileSpec(m_objfile_sp->GetModule()->GetFileSpec().GetPath() + ".dwp");
4003 
4004  FileSpecList search_paths = Target::GetDefaultDebugFileSearchPaths();
4005  FileSpec dwp_filespec =
4006  Symbols::LocateExecutableSymbolFile(module_spec, search_paths);
4007  if (FileSystem::Instance().Exists(dwp_filespec)) {
4008  DataBufferSP dwp_file_data_sp;
4009  lldb::offset_t dwp_file_data_offset = 0;
4010  ObjectFileSP dwp_obj_file = ObjectFile::FindPlugin(
4011  GetObjectFile()->GetModule(), &dwp_filespec, 0,
4012  FileSystem::Instance().GetByteSize(dwp_filespec), dwp_file_data_sp,
4013  dwp_file_data_offset);
4014  if (!dwp_obj_file)
4015  return;
4016  m_dwp_symfile =
4017  std::make_shared<SymbolFileDWARFDwo>(*this, dwp_obj_file, 0x3fffffff);
4018  }
4019  });
4020  return m_dwp_symfile;
4021 }
4022 
4023 llvm::Expected<TypeSystem &> SymbolFileDWARF::GetTypeSystem(DWARFUnit &unit) {
4025 }
4026 
4028  auto type_system_or_err = GetTypeSystem(unit);
4029  if (auto err = type_system_or_err.takeError()) {
4030  LLDB_LOG_ERROR(GetLog(LLDBLog::Symbols), std::move(err),
4031  "Unable to get DWARFASTParser");
4032  return nullptr;
4033  }
4034  return type_system_or_err->GetDWARFParser();
4035 }
4036 
4038  if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU()))
4039  return dwarf_ast->GetDeclForUIDFromDWARF(die);
4040  return CompilerDecl();
4041 }
4042 
4044  if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU()))
4045  return dwarf_ast->GetDeclContextForUIDFromDWARF(die);
4046  return CompilerDeclContext();
4047 }
4048 
4051  if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU()))
4052  return dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
4053  return CompilerDeclContext();
4054 }
4055 
4057  if (!die.IsValid())
4058  return {};
4059  DWARFDeclContext dwarf_decl_ctx =
4060  die.GetDIE()->GetDWARFDeclContext(die.GetCU());
4061  dwarf_decl_ctx.SetLanguage(GetLanguage(*die.GetCU()));
4062  return dwarf_decl_ctx;
4063 }
4064 
4066  // Note: user languages between lo_user and hi_user must be handled
4067  // explicitly here.
4068  switch (val) {
4069  case DW_LANG_Mips_Assembler:
4071  case DW_LANG_GOOGLE_RenderScript:
4073  default:
4074  return static_cast<LanguageType>(val);
4075  }
4076 }
4077 
4080 }
4081 
4083  auto lang = (llvm::dwarf::SourceLanguage)unit.GetDWARFLanguageType();
4084  if (llvm::dwarf::isCPlusPlus(lang))
4085  lang = DW_LANG_C_plus_plus;
4086  return LanguageTypeFromDWARF(lang);
4087 }
4088 
4090  if (m_index)
4091  return m_index->GetIndexTime();
4092  return {};
4093 }
lldb_private::DWARFExpression::Update_DW_OP_addr
bool Update_DW_OP_addr(lldb::addr_t file_addr)
Definition: DWARFExpression.cpp:451
lldb_private::SourceLocationSpec::GetFileSpec
FileSpec GetFileSpec() const
Definition: SourceLocationSpec.h:166
lldb_private::Declaration::SetLine
void SetLine(uint32_t line)
Set accessor for the declaration line number.
Definition: Declaration.h:168
SymbolFileDWARF::GetCompUnitForDWARFCompUnit
lldb_private::CompileUnit * GetCompUnitForDWARFCompUnit(DWARFCompileUnit &dwarf_cu)
Definition: SymbolFileDWARF.cpp:1616
lldb_private::DWARFContext::getOrLoadAbbrevData
const DWARFDataExtractor & getOrLoadAbbrevData()
Definition: DWARFContext.cpp:53
RegularExpression.h
lldb_private::LineTable::FindLineEntryByAddress
bool FindLineEntryByAddress(const Address &so_addr, LineEntry &line_entry, uint32_t *index_ptr=nullptr)
Find a line entry that contains the section offset address so_addr.
Definition: LineTable.cpp:188
SymbolFileDWARF::CalculateNumCompileUnits
uint32_t CalculateNumCompileUnits() override
Definition: SymbolFileDWARF.cpp:804
lldb_private::AddressRange::GetBaseAddress
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:209
DWARFDebugInfo::ContainsTypeUnits
bool ContainsTypeUnits()
Definition: DWARFDebugInfo.cpp:171
Block.h
SymbolFileDWARF::DecodeUID
llvm::Optional< DecodedUID > DecodeUID(lldb::user_id_t uid)
Definition: SymbolFileDWARF.cpp:1381
DWARFFormValue.h
SymbolFileDWARF::m_debug_macros_map
DebugMacrosMap m_debug_macros_map
Definition: SymbolFileDWARF.h:536
SymbolFileDWARFDebugMap.h
list
MATCHES FreeBSD list(APPEND FBSDKERNEL_LIBS kvm) endif() if(NOT FBSDKERNEL_LIBS) message(STATUS "Skipping FreeBSDKernel plugin due to missing libfbsdvmcore") return() endif() add_lldb_library(lldbPluginProcessFreeBSDKernel PLUGIN ProcessFreeBSDKernel.cpp RegisterContextFreeBSDKernel_arm64.cpp RegisterContextFreeBSDKernel_i386.cpp RegisterContextFreeBSDKernel_x86_64.cpp ThreadFreeBSDKernel.cpp LINK_LIBS lldbCore lldbTarget $
Definition: Plugins/Process/FreeBSDKernel/CMakeLists.txt:6
SymbolFileDWARF::GetDebugInfoIndexTime
lldb_private::StatsDuration::Duration GetDebugInfoIndexTime() override
Return the time it took to index the debug information in the object file.
Definition: SymbolFileDWARF.cpp:4089
DIERef
Identifies a DWARF debug info entry within a given Module.
Definition: DIERef.h:26
lldb_private::SymbolFile
Provides public interface for all SymbolFiles.
Definition: SymbolFile.h:45
lldb_private::SymbolContext::block
Block * block
The Block for a given query.
Definition: SymbolContext.h:321
lldb_private::DW_TAG_value_to_name
const char * DW_TAG_value_to_name(uint32_t val)
Definition: DWARFDefines.cpp:17
SymbolFileDWARF::GetFunction
bool GetFunction(const DWARFDIE &die, lldb_private::SymbolContext &sc)
Definition: SymbolFileDWARF.cpp:1638
lldb_private::Range::GetRangeBase
BaseType GetRangeBase() const
Definition: RangeMap.h:46
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
lldb_private::SymbolContext::comp_unit
CompileUnit * comp_unit
The CompileUnit for a given query.
Definition: SymbolContext.h:319
lldb_private::SectionList::FindSectionByName
lldb::SectionSP FindSectionByName(ConstString section_dstr) const
Definition: Section.cpp:546
DWARFUnit::SetUserData
void SetUserData(void *d)
Definition: DWARFUnit.cpp:647
lldb_private::CompileUnit::GetSupportFiles
const FileSpecList & GetSupportFiles()
Get the compile unit's support file list.
Definition: CompileUnit.cpp:390
Scalar.h
lldb_private::CompileUnit::GetVariableList
lldb::VariableListSP GetVariableList(bool can_create)
Get the variable list for a compile unit.
Definition: CompileUnit.cpp:208
SymbolFileDWARF::DIEDeclContextsMatch
bool DIEDeclContextsMatch(const DWARFDIE &die1, const DWARFDIE &die2)
Definition: SymbolFileDWARF.cpp:2768
lldb::eSectionTypeDWARFAppleNamespaces
@ eSectionTypeDWARFAppleNamespaces
Definition: lldb-enumerations.h:686
DWARFFormValue::Reference
DWARFDIE Reference() const
Definition: DWARFFormValue.cpp:502
LLDB_SCOPED_TIMERF
#define LLDB_SCOPED_TIMERF(...)
Definition: Timer.h:86
lldb::eSectionTypeDWARFAppleObjC
@ eSectionTypeDWARFAppleObjC
Definition: lldb-enumerations.h:687
DWARFDIE::GetParent
DWARFDIE GetParent() const
Definition: DWARFDIE.cpp:91
SymbolFileDWARF::InitializeFirstCodeAddressRecursive
void InitializeFirstCodeAddressRecursive(const lldb_private::SectionList &section_list)
Definition: SymbolFileDWARF.cpp:503
SymbolFileDWARF::m_dwo_warning_issued
std::atomic_flag m_dwo_warning_issued
Definition: SymbolFileDWARF.h:563
DWARFCompileUnit.h
lldb::eValueTypeVariableGlobal
@ eValueTypeVariableGlobal
globals variable
Definition: lldb-enumerations.h:317
lldb_private::Block::GetBlockVariableList
lldb::VariableListSP GetBlockVariableList(bool can_create)
Get the variable list for this block only.
Definition: Block.cpp:399
lldb_private::Function::CalculateSymbolContextModule
lldb::ModuleSP CalculateSymbolContextModule() override
Definition: Function.cpp:409
lldb_private::RegularExpression
Definition: RegularExpression.h:18
DWARFBaseDIE::GetData
const lldb_private::DWARFDataExtractor & GetData() const
Definition: DWARFBaseDIE.cpp:123
FileSystem.h
lldb_private::DWARFContext::getOrLoadStrData
const DWARFDataExtractor & getOrLoadStrData()
Definition: DWARFContext.cpp:110
UNUSED_IF_ASSERT_DISABLED
#define UNUSED_IF_ASSERT_DISABLED(x)
Definition: lldb-defines.h:125
SymbolFileDWARF::m_abbr
std::unique_ptr< DWARFDebugAbbrev > m_abbr
Definition: SymbolFileDWARF.h:531
lldb_private::SymbolFileCommon::GetSymtab
Symtab * GetSymtab() override
Definition: SymbolFile.cpp:166
lldb_private::Address::Clear
void Clear()
Clear the object's state.
Definition: Address.h:178
lldb_private::Address::IsValid
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:345
SymbolFileDWARF::m_external_type_modules
ExternalTypeModuleMap m_external_type_modules
Definition: SymbolFileDWARF.h:538
SymbolFileDWARF::GetFile
lldb_private::FileSpec GetFile(DWARFUnit &unit, size_t file_idx)
Definition: SymbolFileDWARF.cpp:1002
CPlusPlusLanguage.h
CompilerDecl.h
lldb_private::CompilerDeclContext::GetScopeQualifiedName
ConstString GetScopeQualifiedName() const
Definition: CompilerDeclContext.cpp:31
DWARFBaseDIE::GetDIERef
llvm::Optional< DIERef > GetDIERef() const
Definition: DWARFBaseDIE.cpp:21
ClangModulesDeclVendor.h
DWARFDebugMacro.h
CompileUnit.h
ModuleSpec.h
SymbolFileDWARF::ParseLineTable
bool ParseLineTable(lldb_private::CompileUnit &comp_unit) override
Definition: SymbolFileDWARF.cpp:1113
lldb_private::DebugMacros
Definition: DebugMacros.h:71
lldb_private::Function::GetAddressRange
const AddressRange & GetAddressRange()
Definition: Function.h:457
SymbolFileDWARF::ResolveTypeUID
lldb_private::Type * ResolveTypeUID(lldb::user_id_t type_uid) override
Definition: SymbolFileDWARF.cpp:1463
TypeMap.h
SymbolFileDWARF::ParseFunctions
size_t ParseFunctions(lldb_private::CompileUnit &comp_unit) override
Definition: SymbolFileDWARF.cpp:916
SymbolFileDWARF::m_parse_time
lldb_private::StatsDuration m_parse_time
Definition: SymbolFileDWARF.h:562
lldb_private::Value
Definition: Value.h:38
lldb_private::Symbol
Definition: Symbol.h:20
SymbolFileDWARF::ParseType
lldb::TypeSP ParseType(const lldb_private::SymbolContext &sc, const DWARFDIE &die, bool *type_is_new)
Definition: SymbolFileDWARF.cpp:2967
lldb_private::Symbol::ValueIsAddress
bool ValueIsAddress() const
Definition: Symbol.cpp:117
DWARFBaseDIE::Supports_DW_AT_APPLE_objc_complete_type
bool Supports_DW_AT_APPLE_objc_complete_type() const
Definition: DWARFBaseDIE.cpp:103
DWARFDebugAranges
Definition: DWARFDebugAranges.h:16
lldb_private::SourceLocationSpec
Definition: SourceLocationSpec.h:27
lldb_private::DataExtractor::ValidOffset
bool ValidOffset(lldb::offset_t offset) const
Test the validity of offset.
Definition: DataExtractor.h:956
SymbolFileDWARF::ParseVariableDIE
lldb::VariableSP ParseVariableDIE(const lldb_private::SymbolContext &sc, const DWARFDIE &die, const lldb::addr_t func_low_pc)
Definition: SymbolFileDWARF.cpp:3144
lldb_private::SymbolFile::VariableTypes
@ VariableTypes
Definition: SymbolFile.h:69
Host.h
SymbolFileDWARF::GetParentSymbolContextDIE
static DWARFDIE GetParentSymbolContextDIE(const DWARFDIE &die)
Definition: SymbolFileDWARF.cpp:389
SymbolFileDWARF::GetPluginNameStatic
static llvm::StringRef GetPluginNameStatic()
Definition: SymbolFileDWARF.h:87
lldb_private::contextMatches
bool contextMatches(llvm::ArrayRef< CompilerContext > context_chain, llvm::ArrayRef< CompilerContext > pattern)
Match context_chain against pattern, which may contain "Any" kinds.
Definition: Type.cpp:37
SymbolFileDWARF::ParseAndAppendGlobalVariable
void ParseAndAppendGlobalVariable(const lldb_private::SymbolContext &sc, const DWARFDIE &die, lldb_private::VariableList &cc_variable_list)
Definition: SymbolFileDWARF.cpp:3521
DWARFBaseDIE::GetAttributes
size_t GetAttributes(DWARFAttributes &attributes, Recurse recurse=Recurse::yes) const
Definition: DWARFBaseDIE.cpp:107
lldb_private::CompilerDeclContext::GetOpaqueDeclContext
void * GetOpaqueDeclContext() const
Definition: CompilerDeclContext.h:103
lldb_private::SymbolContextList::Append
void Append(const SymbolContext &sc)
Append a new symbol context to the list.
Definition: SymbolContext.cpp:1186
lldb_private::Value::GetValueType
ValueType GetValueType() const
Definition: Value.cpp:106
dw_tag_t
llvm::dwarf::Tag dw_tag_t
Definition: dwarf.h:28
SymbolFileDWARF::GetTypeSystem
static llvm::Expected< lldb_private::TypeSystem & > GetTypeSystem(DWARFUnit &unit)
Definition: SymbolFileDWARF.cpp:4023
SymbolFileDWARF::ParseLanguage
lldb::LanguageType ParseLanguage(lldb_private::CompileUnit &comp_unit) override
Definition: SymbolFileDWARF.cpp:879
DWARFASTParser::ParseChildArrayInfo
static llvm::Optional< lldb_private::SymbolFile::ArrayInfo > ParseChildArrayInfo(const DWARFDIE &parent_die, const lldb_private::ExecutionContext *exe_ctx=nullptr)
Definition: DWARFASTParser.cpp:22
lldb_private::SourceModule
Information needed to import a source-language module.
Definition: SourceModule.h:18
lldb_private::UserID
Definition: UserID.h:31
DWARFDebugInfo
Definition: DWARFDebugInfo.h:26
DWARFTypeUnit
Definition: DWARFTypeUnit.h:15
DWARFDebugInfo::GetNumUnits
size_t GetNumUnits()
Definition: DWARFDebugInfo.cpp:105
SymbolFileDWARF::m_unique_ast_type_map
UniqueDWARFASTTypeMap m_unique_ast_type_map
Definition: SymbolFileDWARF.h:547
DWARFFormValue::Address
dw_addr_t Address() const
Definition: DWARFFormValue.cpp:484
lldb_private::StatsDuration::Duration
std::chrono::duration< double > Duration
Definition: Statistics.h:29
lldb_private::eLazyBoolYes
@ eLazyBoolYes
Definition: lldb-private-enumerations.h:115
lldb_private::ElapsedTime
A class that measures elapsed time in an exception safe way.
Definition: Statistics.h:66
DWARFUnit::GetDwoSymbolFile
SymbolFileDWARFDwo * GetDwoSymbolFile()
Definition: DWARFUnit.cpp:818
lldb_private::RangeVector::GetMinRangeBase
BaseType GetMinRangeBase(BaseType fail_value) const
Definition: RangeMap.h:256
SymbolFileDWARF::m_dwp_symfile_once_flag
llvm::once_flag m_dwp_symfile_once_flag
Definition: SymbolFileDWARF.h:523
lldb::eLanguageTypeMipsAssembler
@ eLanguageTypeMipsAssembler
Mips_Assembler.
Definition: lldb-enumerations.h:480
Module.h
lldb::eSectionTypeDWARFDebugLine
@ eSectionTypeDWARFDebugLine
Definition: lldb-enumerations.h:675
SymbolFileDWARF::m_lldb_cu_to_dwarf_unit
std::vector< uint32_t > m_lldb_cu_to_dwarf_unit
Definition: SymbolFileDWARF.h:554
SymbolFileDWARF::GetTypeUnitSupportFiles
const lldb_private::FileSpecList & GetTypeUnitSupportFiles(DWARFTypeUnit &tu)
Definition: SymbolFileDWARF.cpp:1014
lldb_private::RangeVector::GetEntryRef
Entry & GetEntryRef(size_t i)
Definition: RangeMap.h:298
lldb_private::XcodeSDK
An abstraction for Xcode-style SDKs that works like ArchSpec.
Definition: XcodeSDK.h:24
DWARFDIE::GetDeclContextDIEs
std::vector< DWARFDIE > GetDeclContextDIEs() const
Definition: DWARFDIE.cpp:362
SymbolFileDWARF::ParseImportedModules
bool ParseImportedModules(const lldb_private::SymbolContext &sc, std::vector< lldb_private::SourceModule > &imported_modules) override
Definition: SymbolFileDWARF.cpp:1058
SymbolFileDWARF
Definition: SymbolFileDWARF.h:59
lldb_private::CompileUnit::SetVariableList
void SetVariableList(lldb::VariableListSP &variable_list_sp)
Set accessor for the variable list.
Definition: CompileUnit.cpp:365
lldb_private::VariableList::GetSize
size_t GetSize() const
Definition: VariableList.cpp:165
DIE_IS_BEING_PARSED
#define DIE_IS_BEING_PARSED
Definition: SymbolFileDWARF.h:57
lldb::LanguageType
LanguageType
Programming language type.
Definition: lldb-enumerations.h:436
SymbolFileDWARF.h
lldb::eSymbolTypeData
@ eSymbolTypeData
Definition: lldb-enumerations.h:624
lldb_private::SymbolContextList
Definition: SymbolContext.h:379
lldb_private::CompilerDecl
Represents a generic declaration such as a function declaration.
Definition: CompilerDecl.h:28
lldb_private::Module
Definition: Module.h:85
SymbolFileDWARF::GetDWARFCompileUnit
virtual DWARFCompileUnit * GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit)
Definition: SymbolFileDWARF.cpp:644
SymbolFileDWARFDebugMap::Supports_DW_AT_APPLE_objc_complete_type
bool Supports_DW_AT_APPLE_objc_complete_type(SymbolFileDWARF *skip_dwarf_oso)
Definition: SymbolFileDWARFDebugMap.cpp:1090
SymbolFileDWARF::Terminate
static void Terminate()
Definition: SymbolFileDWARF.cpp:258
lldb_private::ConstString::AsCString
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:193
LocateSymbolFile.h
lldb_private::Variable::GetSymbolContextScope
SymbolContextScope * GetSymbolContextScope() const
Definition: Variable.h:51
lldb_private::SectionList
Definition: Section.h:34
SymbolFileDWARF::ID
static char ID
LLVM RTTI support.
Definition: SymbolFileDWARF.h:62
lldb_private::Section::GetFileSize
lldb::offset_t GetFileSize() const
Definition: Section.h:152
lldb_private::CompilerType::GetOpaqueQualType
lldb::opaque_compiler_type_t GetOpaqueQualType() const
Definition: CompilerType.h:173
lldb::offset_t
uint64_t offset_t
Definition: lldb-types.h:87
DWARFDIE::GetDeclContext
void GetDeclContext(llvm::SmallVectorImpl< lldb_private::CompilerContext > &context) const
Return this DIE's decl context as it is needed to look up types in Clang's -gmodules debug info forma...
Definition: DWARFDIE.cpp:376
DWARFBaseDIE::GetModule
lldb::ModuleSP GetModule() const
Definition: DWARFBaseDIE.cpp:77
SymbolFileDWARF::GetDebugRanges
DWARFDebugRanges * GetDebugRanges()
Definition: SymbolFileDWARF.cpp:657
lldb_private::DWARFExpression::LinkThreadLocalStorage
bool LinkThreadLocalStorage(lldb::ModuleSP new_module_sp, std::function< lldb::addr_t(lldb::addr_t file_addr)> const &link_address_callback)
Definition: DWARFExpression.cpp:509
DWARFBaseDIE::GetDWARF
SymbolFileDWARF * GetDWARF() const
Definition: DWARFBaseDIE.cpp:92
DWARFDebugAranges::FindAddress
dw_offset_t FindAddress(dw_addr_t address) const
Definition: DWARFDebugAranges.cpp:99
lldb_private::SymbolFile::CompileUnits
@ CompileUnits
Definition: SymbolFile.h:63
ManualDWARFIndex.h
SymbolFileDWARF::GetDIEToVariable
virtual DIEToVariableSP & GetDIEToVariable()
Definition: SymbolFileDWARF.h:492
DEBUG_PRINTF
#define DEBUG_PRINTF(fmt,...)
Definition: SymbolFileDWARF.cpp:94
lldb_private::Stream
Definition: Stream.h:28
lldb_private::FileSpec::MakeAbsolute
void MakeAbsolute(const FileSpec &dir)
Make the FileSpec absolute by treating it relative to dir.
Definition: FileSpec.cpp:493
lldb_private::Type::GetName
ConstString GetName()
Definition: Type.cpp:302
lldb_private::RangeData
Definition: RangeMap.h:410
lldb_private::DWARFDataExtractor
Definition: DWARFDataExtractor.h:18
SymbolFileDWARF::GetDWARFUnitIndex
llvm::Optional< uint32_t > GetDWARFUnitIndex(uint32_t cu_idx)
Definition: SymbolFileDWARF.cpp:795
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
Language.h
DWARFBaseDIE::GetCU
DWARFUnit * GetCU() const
Definition: DWARFBaseDIE.h:54
SymbolFileDWARF::FindNamespace
lldb_private::CompilerDeclContext FindNamespace(lldb_private::ConstString name, const lldb_private::CompilerDeclContext &parent_decl_ctx) override
Definition: SymbolFileDWARF.cpp:2533
dw_offset_t
uint32_t dw_offset_t
Definition: dwarf.h:33
SymbolFileDWARF::Supports_DW_AT_APPLE_objc_complete_type
bool Supports_DW_AT_APPLE_objc_complete_type(DWARFUnit *cu)
Definition: SymbolFileDWARF.cpp:2680
DWARFDebugInfoEntry
DWARFDebugInfoEntry objects assume that they are living in one big vector and do pointer arithmetic o...
Definition: DWARFDebugInfoEntry.h:31
DW_INVALID_OFFSET
#define DW_INVALID_OFFSET
Definition: dwarf.h:37
lldb_private::SymbolFileCommon
Containing protected virtual methods for child classes to override.
Definition: SymbolFile.h:374
DIERef::die_offset
dw_offset_t die_offset() const
Definition: DIERef.h:45
DWARFDebugInfo::GetCompileUnitAranges
const DWARFDebugAranges & GetCompileUnitAranges()
Definition: DWARFDebugInfo.cpp:36
lldb_private::SymbolContext
Definition: SymbolContext.h:33
Section.h
lldb_private::TypeMap::GetSize
uint32_t GetSize() const
Definition: TypeMap.cpp:75
SymbolFileDWARF::InitializeFirstCodeAddress
void InitializeFirstCodeAddress()
Definition: SymbolFileDWARF.cpp:496
lldb_private::SymbolFile::Functions
@ Functions
Definition: SymbolFile.h:65
SymbolFileDWARF::GetDynamicArrayInfoForUID
llvm::Optional< ArrayInfo > GetDynamicArrayInfoForUID(lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) override
If type_uid points to an array type, return its characteristics.
Definition: SymbolFileDWARF.cpp:1475
ParseLLVMLineTable
static const llvm::DWARFDebugLine::LineTable * ParseLLVMLineTable(lldb_private::DWARFContext &context, llvm::DWARFDebugLine &line, dw_offset_t line_offset, dw_offset_t unit_offset)
Definition: SymbolFileDWARF.cpp:140
lldb_private::DWARFContext
Definition: DWARFContext.h:20
lldb_private::VariableList
Definition: VariableList.h:18
lldb_private::StreamString::GetString
llvm::StringRef GetString() const
Definition: StreamString.cpp:51
lldb_private::ModuleSpec::GetSymbolFileSpec
FileSpec & GetSymbolFileSpec()
Definition: ModuleSpec.h:77
DWARFAttributes
Definition: DWARFAttribute.h:44
SymbolFileDWARF::GetObjCMethods
virtual void GetObjCMethods(lldb_private::ConstString class_name, llvm::function_ref< bool(DWARFDIE die)> callback)
Definition: SymbolFileDWARF.cpp:1633
lldb_private::FileSpec::PrependPathComponent
void PrependPathComponent(llvm::StringRef component)
Definition: FileSpec.cpp:420
DWARFDeclContext.h
SymbolFileDWARF::GetDebugMapSymfile
SymbolFileDWARFDebugMap * GetDebugMapSymfile()
Definition: SymbolFileDWARF.cpp:3986
SymbolFileDWARF::FindGlobalVariables
void FindGlobalVariables(lldb_private::ConstString name, const lldb_private::CompilerDeclContext &parent_decl_ctx, uint32_t max_matches, lldb_private::VariableList &variables) override
Definition: SymbolFileDWARF.cpp:2125
ClangUtil.h
DIEArray
std::vector< DIERef > DIEArray
Definition: DIERef.h:94
lldb_private::RangeDataVector::Entry
RangeData< B, S, T > Entry
Definition: RangeMap.h:438
lldb_private::CompileUnit
Definition: CompileUnit.h:38
lldb_private::TypeSystem::GetDWARFParser
virtual DWARFASTParser * GetDWARFParser()
Definition: TypeSystem.h:89
SymbolFileDWARF::ParseVariableDIECached
lldb::VariableSP ParseVariableDIECached(const lldb_private::SymbolContext &sc, const DWARFDIE &die)
Definition: SymbolFileDWARF.cpp:3124
lldb_private::VariableList::GetVariableAtIndex
lldb::VariableSP GetVariableAtIndex(size_t idx) const
Definition: VariableList.cpp:47
DWARFDIE
Definition: DWARFDIE.h:16
lldb_private::FileSpec::GetCString
const char * GetCString(bool denormalize=true) const
Definition: FileSpec.cpp:363
DWARFFormValue::Boolean
bool Boolean() const
Definition: DWARFFormValue.h:63
DWARFDeclContext::GetQualifiedNameAsConstString
lldb_private::ConstString GetQualifiedNameAsConstString() const
Definition: DWARFDeclContext.h:69
SymbolFileDWARF::DebuggerInitialize
static void DebuggerInitialize(lldb_private::Debugger &debugger)
Definition: SymbolFileDWARF.cpp:247
SymbolFileDWARF::GetTypeSystemForLanguage
llvm::Expected< lldb_private::TypeSystem & > GetTypeSystemForLanguage(lldb::LanguageType language) override
Definition: SymbolFileDWARF.cpp:435
SymbolFileDWARF::GetMangledNamesForFunction
void GetMangledNamesForFunction(const std::string &scope_qualified_name, std::vector< lldb_private::ConstString > &mangled_names) override
Definition: SymbolFileDWARF.cpp:2389
Target.h
SymbolFileDWARF::ParseCompileUnit
lldb::CompUnitSP ParseCompileUnit(DWARFCompileUnit &dwarf_cu)
Definition: SymbolFileDWARF.cpp:697
lldb_private::Properties
Definition: UserSettingsController.h:33
lldb_private::Value::GetScalar
const Scalar & GetScalar() const
Definition: Value.h:112
lldb_private::ObjectFile::GetSymtab
Symtab * GetSymtab()
Gets the symbol table for the currently selected architecture (and object for archives).
Definition: ObjectFile.cpp:725
lldb_private::Block::AddRange
void AddRange(const Range &range)
Add a new offset range to this block.
Definition: Block.cpp:335
SymbolFileDWARF::GetDeclForUID
lldb_private::CompilerDecl GetDeclForUID(lldb::user_id_t uid) override
Definition: SymbolFileDWARF.cpp:1427
lldb_private::Symtab::FindFirstSymbolWithNameAndType
Symbol * FindFirstSymbolWithNameAndType(ConstString name, lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility)
Definition: Symtab.cpp:857
SymbolFileDWARF::m_first_code_address
lldb::addr_t m_first_code_address
DWARF does not provide a good way for traditional (concatenating) linkers to invalidate debug info de...
Definition: SymbolFileDWARF.h:561
SymbolFileDWARF::ParseCompileUnitAtIndex
lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) override
Definition: SymbolFileDWARF.cpp:810
DWARFUnit::GetDWARFLanguageType
uint64_t GetDWARFLanguageType()
Definition: DWARFUnit.cpp:713
lldb_private::FileSpec
Definition: FileSpec.h:56
lldb_private::DWARFExpression::DumpLocationForAddress
bool DumpLocationForAddress(Stream *s, lldb::DescriptionLevel level, lldb::addr_t func_load_addr, lldb::addr_t address, ABI *abi)
Definition: DWARFExpression.cpp:616
SymbolFileDWARFDwo.h
DWARFCompileUnit
Definition: DWARFCompileUnit.h:15
elapsed
static double elapsed(const StatsTimepoint &start, const StatsTimepoint &end)
Definition: Statistics.cpp:36
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
SymbolFileDWARF::ResolveSymbolContext
uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr, lldb::SymbolContextItem resolve_scope, lldb_private::SymbolContext &sc) override
DWARFDIE::GetPubname
const char * GetPubname() const
Definition: DWARFDIE.cpp:211
DWARFUnit::GetAddressByteSize
uint8_t GetAddressByteSize() const
Definition: DWARFUnit.h:157
lldb_private::DWARFContext::GetAsLLVM
llvm::DWARFContext & GetAsLLVM()
Definition: DWARFContext.cpp:126
SymbolFileDWARFDebugMap::Terminate
static void Terminate()
Definition: SymbolFileDWARFDebugMap.cpp:227
SymbolFileDWARF::UpdateExternalModuleListIfNeeded
void UpdateExternalModuleListIfNeeded()
Definition: SymbolFileDWARF.cpp:1770
lldb_private::CompilerDeclContext::IsValid
bool IsValid() const
Definition: CompilerDeclContext.h:55
lldb_private::SymbolFileCommon::m_objfile_sp
lldb::ObjectFileSP m_objfile_sp
Definition: SymbolFile.h:444
SymbolFileDWARF::CreateInstance
static lldb_private::SymbolFile * CreateInstance(lldb::ObjectFileSP objfile_sp)
Definition: SymbolFileDWARF.cpp:268
lldb_private::DWARFExpression::GetLocation_DW_OP_addr
lldb::addr_t GetLocation_DW_OP_addr(uint32_t op_addr_idx, bool &error) const
If a location is not a location list, return true if the location contains a DW_OP_addr () opcode in ...
Definition: DWARFExpression.cpp:412
lldb_private::LineTable
Definition: LineTable.h:40
lldb_private::Function
Definition: Function.h:409
SymbolFileDWARF::ForEachExternalModule
bool ForEachExternalModule(lldb_private::CompileUnit &, llvm::DenseSet< lldb_private::SymbolFile * > &, llvm::function_ref< bool(lldb_private::Module &)>) override
Definition: SymbolFileDWARF.cpp:939
DWARFUnit
Definition: DWARFUnit.h:83
SymbolFileDWARF::SymbolFileDWARF
SymbolFileDWARF(lldb::ObjectFileSP objfile_sp, lldb_private::SectionList *dwo_section_list)
SymbolFileDWARF::GetForwardDeclClangTypeToDie
virtual ClangTypeToDIE & GetForwardDeclClangTypeToDie()
Definition: SymbolFileDWARF.h:498
ModuleList.h
SymbolFileDWARF::ResolveFunction
bool ResolveFunction(const DWARFDIE &die, bool include_inlines, lldb_private::SymbolContextList &sc_list)
Definition: SymbolFileDWARF.cpp:2241
DWARFASTParser::ParseFunctionFromDWARF
virtual lldb_private::Function * ParseFunctionFromDWARF(lldb_private::CompileUnit &comp_unit, const DWARFDIE &die, const lldb_private::AddressRange &range)=0
lldb::eSectionTypeDWARFDebugAbbrev
@ eSectionTypeDWARFDebugAbbrev
Definition: lldb-enumerations.h:669
DWARFUnit::GetCompilationDirectory
const lldb_private::FileSpec & GetCompilationDirectory()
Definition: DWARFUnit.cpp:745
lldb_private::Function::GetCompileUnit
CompileUnit * GetCompileUnit()
Get accessor for the compile unit that owns this function.
Definition: Function.cpp:361
DWARFBaseDIE::Recurse::no
@ no
DWARFDIE::GetQualifiedName
const char * GetQualifiedName(std::string &storage) const
Definition: DWARFDIE.cpp:218
dwarf
Definition: ABISysV_arc.cpp:61
GetFileByIndex
static llvm::Optional< std::string > GetFileByIndex(const llvm::DWARFDebugLine::Prologue &prologue, size_t idx, llvm::StringRef compile_dir, FileSpec::Style style)
Definition: SymbolFileDWARF.cpp:191
lldb_private::DataExtractor
Definition: DataExtractor.h:48
lldb_private::ConstString::GetStringRef
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
Definition: ConstString.h:202
lldb_private::Scalar::ULongLong
unsigned long long ULongLong(unsigned long long fail_value=0) const
Definition: Scalar.cpp:334
SymbolFileDWARF::GetDwoSymbolFileForCompileUnit
std::shared_ptr< SymbolFileDWARFDwo > GetDwoSymbolFileForCompileUnit(DWARFUnit &dwarf_cu, const DWARFDebugInfoEntry &cu_die)
Definition: SymbolFileDWARF.cpp:1705
lldb_private::SymbolFile::LocalVariables
@ LocalVariables
Definition: SymbolFile.h:68
lldb_private::SymbolContextScope::CalculateSymbolContextCompileUnit
virtual CompileUnit * CalculateSymbolContextCompileUnit()
Definition: SymbolContextScope.h:82
TypeSystemClang.h
lldb_private::ConstString::IsEmpty
bool IsEmpty() const
Test for empty string.
Definition: ConstString.h:304
SymbolFileDWARF::DeclContextMatchesThisSymbolFile
bool DeclContextMatchesThisSymbolFile(const lldb_private::CompilerDeclContext &decl_ctx)
Definition: SymbolFileDWARF.cpp:2094
SymbolFileDWARF::GetGlobalAranges
GlobalVariableMap & GetGlobalAranges()
Definition: SymbolFileDWARF.cpp:1872
lldb::eSectionTypeDWARFDebugStr
@ eSectionTypeDWARFDebugStr
Definition: lldb-enumerations.h:682
ParseSupportFilesFromPrologue
static FileSpecList ParseSupportFilesFromPrologue(const lldb::ModuleSP &module, const llvm::DWARFDebugLine::Prologue &prologue, FileSpec::Style style, llvm::StringRef compile_dir={})
Definition: SymbolFileDWARF.cpp:208
lldb_private::Declaration::SetColumn
void SetColumn(uint16_t column)
Set accessor for the declaration column number.
Definition: Declaration.h:175
lldb_private::TypeList::Insert
void Insert(const lldb::TypeSP &type)
Definition: TypeList.cpp:27
lldb_private::Function::GetBlock
Block & GetBlock(bool can_create)
Get accessor for the block list.
Definition: Function.cpp:346
MakeAbsoluteAndRemap
static void MakeAbsoluteAndRemap(FileSpec &file_spec, DWARFUnit &dwarf_cu, const ModuleSP &module_sp)
Make an absolute path out of file_spec and remap it using the module's source remapping dictionary.
Definition: SymbolFileDWARF.cpp:673
DWARFDebugMacroHeader::OffsetIs64Bit
bool OffsetIs64Bit() const
Definition: DWARFDebugMacro.h:39
DWARFDebugAbbrev::GetUnsupportedForms
void GetUnsupportedForms(std::set< dw_form_t > &invalid_forms) const
Definition: DWARFDebugAbbrev.cpp:141
lldb_private::DWARFExpression::SetModule
void SetModule(const lldb::ModuleSP &module)
Definition: DWARFExpression.h:114
DWARFDeclContext::GetQualifiedName
const char * GetQualifiedName() const
Definition: DWARFDeclContext.cpp:13
DWARFDeclContext::GetSize
uint32_t GetSize() const
Definition: DWARFDeclContext.h:53
DWARFDebugInfo::GetUnitAtIndex
DWARFUnit * GetUnitAtIndex(size_t idx)
Definition: DWARFDebugInfo.cpp:110
lldb_private::Block::AddChild
void AddChild(const lldb::BlockSP &child_block_sp)
Add a child to this object.
Definition: Block.cpp:385
Progress.h
lldb_private::StreamString::GetData
const char * GetData() const
Definition: StreamString.h:43
DWARFBaseDIE::GetTagAsCString
const char * GetTagAsCString() const
Definition: DWARFBaseDIE.cpp:36
DWARFDIE::GetName
void GetName(lldb_private::Stream &s) const
Definition: DWARFDIE.cpp:230
DWARFBaseDIE::Clear
void Clear()
Definition: DWARFBaseDIE.h:69
DWARFBaseDIE::GetDIE
DWARFDebugInfoEntry * GetDIE() const
Definition: DWARFBaseDIE.h:56
lldb_private::Section::GetChildren
SectionList & GetChildren()
Definition: Section.h:132
SymbolFileDWARF::LoadSectionData
virtual void LoadSectionData(lldb::SectionType sect_type, lldb_private::DWARFDataExtractor &data)
Definition: SymbolFileDWARF.cpp:599
lldb_private::CallSiteParameterArray
llvm::SmallVector< CallSiteParameter, 0 > CallSiteParameterArray
A vector of CallSiteParameter.
Definition: Function.h:261
lldb_private::SymbolContextScope::CalculateSymbolContext
virtual void CalculateSymbolContext(SymbolContext *sc)=0
Reconstruct the object's symbol context into sc.
DWARFUnit::GetPathStyle
lldb_private::FileSpec::Style GetPathStyle()
Definition: DWARFUnit.cpp:739
lldb_private::SymbolContext::function
Function * function
The Function for a given query.
Definition: SymbolContext.h:320
StreamString.h
lldb_private::Address::GetFileAddress
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:291
SymbolFileDWARF::GetLanguageFamily
static lldb::LanguageType GetLanguageFamily(DWARFUnit &unit)
Same as GetLanguage() but reports all C++ versions as C++ (no version).
Definition: SymbolFileDWARF.cpp:4082
SymbolFileDWARF::FindBlockContainingSpecification
DWARFDIE FindBlockContainingSpecification(const DIERef &func_die_ref, dw_offset_t spec_block_die_offset)
Definition: SymbolFileDWARF.cpp:3478
SymbolFileDWARF::ResolveFunctionAndBlock
void ResolveFunctionAndBlock(lldb::addr_t file_vm_addr, bool lookup_block, lldb_private::SymbolContext &sc)
Resolve functions and (possibly) blocks for the given file address and a compile unit.
Definition: SymbolFileDWARF.cpp:1916
SymbolFileDWARFDebugMap::GetCompileUnit
lldb::CompUnitSP GetCompileUnit(SymbolFileDWARF *oso_dwarf)
Definition: SymbolFileDWARFDebugMap.cpp:1220
lldb_private::Symbol::GetAddressRef
Address & GetAddressRef()
Definition: Symbol.h:57
DWARFASTParser.h
lldb_private::DWARFExpression
Definition: DWARFExpression.h:36
DWARFDIE::GetMangledName
const char * GetMangledName() const
Definition: DWARFDIE.cpp:204
lldb_private::ClangASTImporter::CompleteType
bool CompleteType(const CompilerType &compiler_type)
Definition: ClangASTImporter.cpp:505
lldb_private::DebugMacrosSP
std::shared_ptr< DebugMacros > DebugMacrosSP
Definition: DebugMacros.h:21
DWARFFormValue::Form
dw_form_t Form() const
Definition: DWARFFormValue.h:47
DWARFASTParser::EnsureAllDIEsInDeclContextHaveBeenParsed
virtual void EnsureAllDIEsInDeclContextHaveBeenParsed(lldb_private::CompilerDeclContext decl_context)=0
SymbolFileDWARF::GetModuleMutex
std::recursive_mutex & GetModuleMutex() const override
Symbols file subclasses should override this to return the Module that owns the TypeSystem that this ...
Definition: SymbolFileDWARF.cpp:2087
lldb_private::TypeSystemClang::GetDWARFParser
DWARFASTParser * GetDWARFParser() override
Definition: TypeSystemClang.cpp:9310
lldb_private::DataExtractor::GetDataStart
const uint8_t * GetDataStart() const
Get the data start pointer.
Definition: DataExtractor.h:422
lldb_private::SymbolContextList::GetSize
uint32_t GetSize() const
Get accessor for a symbol context list size.
Definition: SymbolContext.cpp:1276
lldb_private::ConstString
Definition: ConstString.h:40
SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext
virtual lldb::TypeSP FindDefinitionTypeForDWARFDeclContext(const DWARFDeclContext &die_decl_ctx)
Definition: SymbolFileDWARF.cpp:2848
SymbolFileDWARFDebugMap
Definition: SymbolFileDWARFDebugMap.h:25
lldb_private::StreamString
Definition: StreamString.h:23
lldb::eSectionTypeDWARFDebugInfo
@ eSectionTypeDWARFDebugInfo
Definition: lldb-enumerations.h:674
lldb::eDescriptionLevelFull
@ eDescriptionLevelFull
Definition: lldb-enumerations.h:209
lldb_private::AddressRange
Definition: AddressRange.h:25
Timer.h
DWARFDebugAranges.h
DWARFASTParser::GetDeclContextForUIDFromDWARF
virtual lldb_private::CompilerDeclContext GetDeclContextForUIDFromDWARF(const DWARFDIE &die)=0
SymbolFileDWARF::GetDWARFDeclContext
static DWARFDeclContext GetDWARFDeclContext(const DWARFDIE &die)
Definition: SymbolFileDWARF.cpp:4056
lldb_private::Progress
A Progress indicator helper class.
Definition: Progress.h:55
DWARFFormValue
Definition: DWARFFormValue.h:20
lldb_private::CompileUnit::SetSupportFiles
void SetSupportFiles(const FileSpecList &support_files)
Definition: CompileUnit.cpp:180
SymbolFileDWARF::GetDIEToType
virtual DIEToTypePtr & GetDIEToType()
Definition: SymbolFileDWARF.h:490
SymbolFileDWARF::GetDwpSymbolFile
const std::shared_ptr< SymbolFileDWARFDwo > & GetDwpSymbolFile()
Definition: SymbolFileDWARF.cpp:3997
SymbolFileDWARF::m_debug_map_symfile
SymbolFileDWARFDebugMap * m_debug_map_symfile
Definition: SymbolFileDWARF.h:521
lldb_private::CompileUnit::SetLineTable
void SetLineTable(LineTable *line_table)
Set the line table for the compile unit.
Definition: CompileUnit.cpp:172
lldb_private::Declaration::SetFile
void SetFile(const FileSpec &file_spec)
Set accessor for the declaration file specification.
Definition: Declaration.h:161
SymbolFileDWARF::ParseTypes
size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override
Definition: SymbolFileDWARF.cpp:3060
SymbolFileDWARF::Dump
void Dump(lldb_private::Stream &s) override
Definition: SymbolFileDWARF.cpp:3970
lldb_private::Range
Definition: Process.h:61
SymbolFileDWARF::SupportedVersion
static bool SupportedVersion(uint16_t version)
Definition: SymbolFileDWARF.cpp:515
lldb::eSectionTypeDWARFAppleTypes
@ eSectionTypeDWARFAppleTypes
Definition: lldb-enumerations.h:685
lldb::eSectionTypeDWARFAppleNames
@ eSectionTypeDWARFAppleNames
Definition: lldb-enumerations.h:684
LLDB_SCOPED_TIMER
#define LLDB_SCOPED_TIMER()
Definition: Timer.h:83
SymbolFileDWARF::DIEInDeclContext
static bool DIEInDeclContext(const lldb_private::CompilerDeclContext &parent_decl_ctx, const DWARFDIE &die)
Definition: SymbolFileDWARF.cpp:2292
DWARFDIE::GetReferencedDIE
DWARFDIE GetReferencedDIE(const dw_attr_t attr) const
Definition: DWARFDIE.cpp:115
LogChannelDWARF.h
lldb::eSymbolTypeObjCClass
@ eSymbolTypeObjCClass
Definition: lldb-enumerations.h:646
lldb_private::SourceModule::sysroot
ConstString sysroot
Definition: SourceModule.h:22
SymbolFileDWARF::GetTypeForDIE
lldb::TypeSP GetTypeForDIE(const DWARFDIE &die, bool resolve_function_context=false)
Definition: SymbolFileDWARF.cpp:2575
lldb_private::SymbolContext::variable
Variable * variable
The global variable matching the given query.
Definition: SymbolContext.h:324
SymbolFileDWARF::m_dwp_symfile
std::shared_ptr< SymbolFileDWARFDwo > m_dwp_symfile
Definition: SymbolFileDWARF.h:524
DWARFFormValue::IsBlockForm
static bool IsBlockForm(const dw_form_t form)
Definition: DWARFFormValue.cpp:569
lldb_private::Debugger
Definition: Debugger.h:74
lldb_private::CompileUnit::SetDebugMacros
void SetDebugMacros(const DebugMacrosSP &debug_macros)
Definition: CompileUnit.cpp:200
lldb_private::CompileUnit::GetPrimaryFile
const FileSpec & GetPrimaryFile() const
Return the primary source file associated with this compile unit.
Definition: CompileUnit.h:227
SymbolFileDWARF::GetDeclContextForUID
lldb_private::CompilerDeclContext GetDeclContextForUID(lldb::user_id_t uid) override
Definition: SymbolFileDWARF.cpp:1440
lldb::eValueTypeVariableArgument
@ eValueTypeVariableArgument
function argument variables
Definition: lldb-enumerations.h:319
DWARFBaseDIE::GetAttributeValueAsString
const char * GetAttributeValueAsString(const dw_attr_t attr, const char *fail_value) const
Definition: DWARFBaseDIE.cpp:40
lldb_private::CallSiteParameter
Definition: Function.h:255
DWARFDebugRanges
Definition: DWARFDebugRanges.h:20
lldb_private::Block::SetInlinedFunctionInfo
void SetInlinedFunctionInfo(const char *name, const char *mangled, const Declaration *decl_ptr, const Declaration *call_decl_ptr)
Set accessor for any inlined function information.
Definition: Block.cpp:392
lldb_private::SymbolFileCommon::GetNumCompileUnits
uint32_t GetNumCompileUnits() override
Definition: SymbolFile.cpp:194
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
DWARFDIE::GetFirstChild
DWARFDIE GetFirstChild() const
Definition: DWARFDIE.cpp:99
DWARFDebugInfo.h
lldb_private::RangeVector::GetMaxRangeEnd
BaseType GetMaxRangeEnd(BaseType fail_value) const
Definition: RangeMap.h:267
lldb_private::Address::GetSection
lldb::SectionSP GetSection() const
Get const accessor for the section.
Definition: Address.h:429
AppleDWARFIndex.h
SymbolFileDWARF::GetExternalModule
lldb::ModuleSP GetExternalModule(lldb_private::ConstString name)
Definition: SymbolFileDWARF.cpp:1659
SymbolFileDWARF::GetObjCClassSymbol
lldb_private::Symbol * GetObjCClassSymbol(lldb_private::ConstString objc_class_name)
Definition: SymbolFileDWARF.cpp:2660
DWARFUnit.h
lldb_private::CompileUnit::GetLineTable
LineTable * GetLineTable()
Get the line table for the compile unit.
Definition: CompileUnit.cpp:161
lldb_private::CompileUnit::GetLanguage
lldb::LanguageType GetLanguage()
Definition: CompileUnit.cpp:150
lldb_private::CompilerDeclContext::GetName
ConstString GetName() const
Definition: CompilerDeclContext.cpp:25
TypeSystem.h
SymbolFileDWARFDebugMap::Initialize
static void Initialize()
Definition: SymbolFileDWARFDebugMap.cpp:222
DWARFUnit::GetByteOrder
lldb::ByteOrder GetByteOrder() const
Definition: DWARFUnit.cpp:591
DWARFAttributes::ExtractFormValueAtIndex
bool ExtractFormValueAtIndex(uint32_t i, DWARFFormValue &form_value) const
Definition: DWARFAttribute.cpp:38
lldb_private::RangeVector
Definition: RangeMap.h:131
DWARFDebugMacroEntry::ReadMacroEntries
static void ReadMacroEntries(const lldb_private::DWARFDataExtractor &debug_macro_data, const lldb_private::DWARFDataExtractor &debug_str_data, const bool offset_is_64_bit, lldb::offset_t *sect_offset, SymbolFileDWARF *sym_file_dwarf, lldb_private::DebugMacrosSP &debug_macros_sp)
Definition: DWARFDebugMacro.cpp:60
DWARFDebugInfoEntry::GetAttributeValueAsString
const char * GetAttributeValueAsString(const DWARFUnit *cu, const dw_attr_t attr, const char *fail_value, bool check_specification_or_abstract_origin=false) const
Definition: DWARFDebugInfoEntry.cpp:525
SymbolFileDWARF::ParseXcodeSDK
lldb_private::XcodeSDK ParseXcodeSDK(lldb_private::CompileUnit &comp_unit) override
Return the Xcode SDK comp_unit was compiled against.
Definition: SymbolFileDWARF.cpp:888
DWARFFormValue::Unsigned
uint64_t Unsigned() const
Definition: DWARFFormValue.h:64
VariableList.h
SymbolFileDWARF::CollectCallEdges
std::vector< std::unique_ptr< lldb_private::CallEdge > > CollectCallEdges(lldb::ModuleSP module, DWARFDIE function_die)
Parse call site entries (DW_TAG_call_site), including any nested call site parameters (DW_TAG_call_si...
Definition: SymbolFileDWARF.cpp:3799
lldb_private::TypeMap
Definition: TypeMap.h:20
DWARFUnit::GetBaseAddress
dw_addr_t GetBaseAddress() const
Definition: DWARFUnit.h:159
UniqueDWARFASTTypeMap
Definition: UniqueDWARFASTType.h:71
SymbolFileDWARF::GetDWARFParser
static DWARFASTParser * GetDWARFParser(DWARFUnit &unit)
Definition: SymbolFileDWARF.cpp:4027
DWARFDIE::GetDIENamesAndRanges
bool GetDIENamesAndRanges(const char *&name, const char *&mangled, DWARFRangeList &ranges, int &decl_file, int &decl_line, int &decl_column, int &call_file, int &call_line, int &call_column, lldb_private::DWARFExpression *frame_base) const
Definition: DWARFDIE.cpp:440
DWARFUnit::GetLineTableOffset
dw_offset_t GetLineTableOffset()
Definition: DWARFUnit.cpp:426
lldb_private::CompilerDeclContext
Represents a generic declaration context in a program.
Definition: CompilerDeclContext.h:30
SymbolFileDWARF::m_info_once_flag
llvm::once_flag m_info_once_flag
Definition: SymbolFileDWARF.h:528
OptionValueProperties.h
DWARFUnit::dies
die_iterator_range dies()
Definition: DWARFUnit.h:214
lldb_private::DWARFExpression::UpdateValue
void UpdateValue(uint64_t const_value, lldb::offset_t const_value_byte_size, uint8_t addr_byte_size)
Definition: DWARFExpression.cpp:77
SymbolFileDWARF::DecodedUID
Definition: SymbolFileDWARF.h:505
lldb_private::SymbolContextScope
Definition: SymbolContextScope.h:64
ObjectFile.h
DWARFASTParserClang::GetClangASTImporter
lldb_private::ClangASTImporter & GetClangASTImporter()
Definition: DWARFASTParserClang.cpp:79
SymbolFileDWARF::ParseVariablesForContext
size_t ParseVariablesForContext(const lldb_private::SymbolContext &sc) override
Definition: SymbolFileDWARF.cpp:3076
lldb_private::UserID::GetID
lldb::user_id_t GetID() const
Get accessor for the user ID.
Definition: UserID.h:47
SymbolFileDWARF::m_function_scope_qualified_name_map
NameToOffsetMap m_function_scope_qualified_name_map
Definition: SymbolFileDWARF.h:545
DWARFUnit::GetOffset
dw_offset_t GetOffset() const
Definition: DWARFUnit.h:133
DWARFUnit::IsDWOUnit
bool IsDWOUnit()
Definition: DWARFUnit.h:94
SymbolFileDWARF::ParseIsOptimized
bool ParseIsOptimized(lldb_private::CompileUnit &comp_unit) override
Definition: SymbolFileDWARF.cpp:1050
SymbolFileDWARF::MergeBlockAbstractParameters
DIEArray MergeBlockAbstractParameters(const DWARFDIE &block_die, DIEArray &&variable_dies)
Definition: SymbolFileDWARF.cpp:3577
DWARFDebugMacroHeader
Definition: DWARFDebugMacro.h:27
SymbolFileDWARF::TypeSet
llvm::SetVector< lldb_private::Type * > TypeSet
Definition: SymbolFileDWARF.h:476
CollectCallSiteParameters
static CallSiteParameterArray CollectCallSiteParameters(ModuleSP module, DWARFDIE call_site_die)
Collect call site parameters in a DW_TAG_call_site DIE.
Definition: SymbolFileDWARF.cpp:3751
DWARFDebugAbbrev
Definition: DWARFDebugAbbrev.h:64
lldb_private::Section
Definition: Section.h:102
DWARFFormValue::GetUnit
const DWARFUnit * GetUnit() const
Definition: DWARFFormValue.h:45
SymbolFileDWARF::m_context
lldb_private::DWARFContext m_context
Definition: SymbolFileDWARF.h:526
DWARFFormValue::IsDataForm
static bool IsDataForm(const dw_form_t form)
Definition: DWARFFormValue.cpp:581
lldb_private::DWARFContext::getOrLoadRangesData
const DWARFDataExtractor & getOrLoadRangesData()
Definition: DWARFContext.cpp:99
ASSERT_MODULE_LOCK
#define ASSERT_MODULE_LOCK(expr)
Definition: SymbolFile.h:34
DW_INVALID_INDEX
#define DW_INVALID_INDEX
Definition: dwarf.h:38
lldb_private::FileSpec::Style
llvm::sys::path::Style Style
Definition: FileSpec.h:58
SymbolFileDWARF::ResolveType
lldb_private::Type * ResolveType(const DWARFDIE &die, bool assert_not_being_parsed=true, bool resolve_function_context=false)
Definition: SymbolFileDWARF.cpp:1595
StreamFile.h
lldb::eSectionTypeCode
@ eSectionTypeCode
Definition: lldb-enumerations.h:654
lldbassert
#define lldbassert(x)
Definition: LLDBAssert.h:15
SymbolFileDWARF::CompleteType
bool CompleteType(lldb_private::CompilerType &compiler_type) override
Definition: SymbolFileDWARF.cpp:1549
SymbolFileDWARF::DIEToVariableSP
llvm::DenseMap< const DWARFDebugInfoEntry *, lldb::VariableSP > DIEToVariableSP
Definition: SymbolFileDWARF.h:335
lldb_private::TypeMap::InsertUnique
bool InsertUnique(const lldb::TypeSP &type)
Definition: TypeMap.cpp:34
DWARFDeclContext::GetLanguage
lldb::LanguageType GetLanguage() const
Definition: DWARFDeclContext.h:78
SymbolFileDWARF::FixupAddress
lldb::addr_t FixupAddress(lldb::addr_t file_addr)
If this symbol file is linked to by a debug map (see SymbolFileDWARFDebugMap), and file_addr is a fil...
Definition: SymbolFileDWARF.cpp:864
lldb_private::TypeSystem::GetMinimumLanguage
virtual lldb::LanguageType GetMinimumLanguage(lldb::opaque_compiler_type_t type)=0
lldb_private::SectionList::FindSectionByType
lldb::SectionSP FindSectionByType(lldb::SectionType sect_type, bool check_children, size_t start_idx=0) const
Definition: Section.cpp:586
SymbolFileDWARF::m_index
std::unique_ptr< lldb_private::DWARFIndex > m_index
Definition: SymbolFileDWARF.h:539
lldb_private::VariableList::RemoveVariableAtIndex
lldb::VariableSP RemoveVariableAtIndex(size_t idx)
Definition: VariableList.cpp:54
lldb_private::Block::SetVariableList
void SetVariableList(lldb::VariableListSP &variable_list_sp)
Set accessor for the variable list.
Definition: Block.h:331
DWARFASTParserClang
Definition: DWARFASTParserClang.h:37
lldb_private::ModuleSpec::GetFileSpec
FileSpec & GetFileSpec()
Definition: ModuleSpec.h:53
lldb_private::ModuleSpec
Definition: ModuleSpec.h:27
SymbolFileDWARF::GetDecl
static lldb_private::CompilerDecl GetDecl(const DWARFDIE &die)
Definition: SymbolFileDWARF.cpp:4037
DWARFBaseDIE::GetAttributeValueAsUnsigned
uint64_t GetAttributeValueAsUnsigned(const dw_attr_t attr, uint64_t fail_value) const
Definition: DWARFBaseDIE.cpp:48
SymbolFileDWARF::LanguageTypeFromDWARF
static lldb::LanguageType LanguageTypeFromDWARF(uint64_t val)
Definition: SymbolFileDWARF.cpp:4065
lldb::eValueTypeVariableLocal
@ eValueTypeVariableLocal
function local variables
Definition: lldb-enumerations.h:320
lldb_private::Status
Definition: Status.h:44
SymbolFileDWARF::ParseFunction
lldb_private::Function * ParseFunction(lldb_private::CompileUnit &comp_unit, const DWARFDIE &die)
Definition: SymbolFileDWARF.cpp:820
SymbolFileDWARF::GetLanguage
static lldb::LanguageType GetLanguage(DWARFUnit &unit)
Definition: SymbolFileDWARF.cpp:4078
lldb_private::FileSpec::IsRelative
bool IsRelative() const
Returns true if the filespec represents a relative path.
Definition: FileSpec.cpp:474
lldb::ValueType
ValueType
Definition: lldb-enumerations.h:315
SymbolFileDWARF::m_global_aranges_up
std::unique_ptr< GlobalVariableMap > m_global_aranges_up
Definition: SymbolFileDWARF.h:532
SymbolFileDWARF::ParseDebugMacros
bool ParseDebugMacros(lldb_private::CompileUnit &comp_unit) override
Definition: SymbolFileDWARF.cpp:1198
lldb_private::Block
Definition: Block.h:41
lldb::eLanguageTypeUnknown
@ eLanguageTypeUnknown
Unknown or invalid language value.
Definition: lldb-enumerations.h:437
lldb_private::Symtab
Definition: Symtab.h:22
lldb::eLanguageTypeExtRenderScript
@ eLanguageTypeExtRenderScript
RenderScript.
Definition: lldb-enumerations.h:481
SymbolFileDWARF::GetPluginDescriptionStatic
static llvm::StringRef GetPluginDescriptionStatic()
Definition: SymbolFileDWARF.cpp:264
uint32_t
DWARFDebugInfo::GetUnitAtOffset
DWARFUnit * GetUnitAtOffset(DIERef::Section section, dw_offset_t cu_offset, uint32_t *idx_ptr=nullptr)
Definition: DWARFDebugInfo.cpp:135
SymbolFileDWARFDebugMap::LinkOSOAddress
bool LinkOSOAddress(lldb_private::Address &addr)
Convert addr from a .o file address, to an executable address.
Definition: SymbolFileDWARFDebugMap.cpp:1362
DWARFASTParser
Definition: DWARFASTParser.h:26
lldb_private::eLazyBoolNo
@ eLazyBoolNo
Definition: lldb-private-enumerations.h:115
SymbolFileDWARF::GetTypeList
lldb_private::TypeList & GetTypeList() override
Definition: SymbolFileDWARF.cpp:273
DWARFDebugInfoEntry.h
DWARFUnit::GetUnitDIEOnly
DWARFBaseDIE GetUnitDIEOnly()
Definition: DWARFUnit.h:175
DWARFUnit::GetVersion
uint16_t GetVersion() const
Definition: DWARFUnit.h:154
lldb::SectionType
SectionType
Definition: lldb-enumerations.h:652
SymbolFileDWARF::m_fetched_external_modules
bool m_fetched_external_modules
Definition: SymbolFileDWARF.h:540
DWARFFormValue::BlockData
const uint8_t * BlockData() const
Definition: DWARFFormValue.cpp:567
SymbolFileDWARF::m_debug_map_module_wp
lldb::ModuleWP m_debug_map_module_wp
Definition: SymbolFileDWARF.h:520
SymbolFileDWARF::Initialize
static void Initialize()
Definition: SymbolFileDWARF.cpp:239
lldb_private::Address
Definition: Address.h:59
SymbolFileDWARF::m_ranges
std::unique_ptr< DWARFDebugRanges > m_ranges
Definition: SymbolFileDWARF.h:546
lldb::eSectionTypeDWARFDebugNames
@ eSectionTypeDWARFDebugNames
DWARF v5 .debug_names.
Definition: lldb-enumerations.h:702
DWARFASTParser::ParseTypeFromDWARF
virtual lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc, const DWARFDIE &die, bool *type_is_new_ptr)=0
DWARFASTParserClang.h
SymbolFileDWARF::GetDeclContext
static lldb_private::CompilerDeclContext GetDeclContext(const DWARFDIE &die)
Definition: SymbolFileDWARF.cpp:4043
SymbolFileDWARF::InitializeObject
void InitializeObject() override
Initialize the SymbolFile object.
Definition: SymbolFileDWARF.cpp:447
SymbolFileDWARFDebugMap::GetUniqueDWARFASTTypeMap
UniqueDWARFASTTypeMap & GetUniqueDWARFASTTypeMap()
Definition: SymbolFileDWARFDebugMap.h:275
lldb_private::CompilerType::GetTypeSystem
TypeSystem * GetTypeSystem() const
Accessors.
Definition: CompilerType.h:162
lldb_private::SymbolContext::GetResolvedMask
uint32_t GetResolvedMask() const
Definition: SymbolContext.cpp:285
SymbolFileDWARF::m_supports_DW_AT_APPLE_objc_complete_type
lldb_private::LazyBool m_supports_DW_AT_APPLE_objc_complete_type
Definition: SymbolFileDWARF.h:541
DIERef::section
Section section() const
Definition: DIERef.h:43
lldb_private::Block::FinalizeRanges
void FinalizeRanges()
Definition: Block.cpp:330
lldb_private::RangeDataVector
Definition: RangeMap.h:435
SymbolFileDWARF::GetContainingDeclContext
static lldb_private::CompilerDeclContext GetContainingDeclContext(const DWARFDIE &die)
Definition: SymbolFileDWARF.cpp:4050
lldb_private::Type
Definition: Type.h:66
LineTable.h
DWARFBaseDIE::GetOffset
dw_offset_t GetOffset() const
Definition: DWARFBaseDIE.cpp:85
DWARFBaseDIE::GetName
const char * GetName() const
Definition: DWARFBaseDIE.cpp:70
DWARFDebugRanges.h
lldb_private::Address::ResolveAddressUsingFileSections
bool ResolveAddressUsingFileSections(lldb::addr_t addr, const SectionList *sections)
Resolve a file virtual address using a section list.
Definition: Address.cpp:248
DWARFDIE::GetDIE
DWARFDIE GetDIE(dw_offset_t die_offset) const
Definition: DWARFDIE.cpp:123
ArchSpec.h
lldb_private::Range::GetByteSize
SizeType GetByteSize() const
Definition: RangeMap.h:82
lldb_private::Stream::AsRawOstream
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
Definition: Stream.h:357
SymbolFileDWARFDwo
Definition: SymbolFileDWARFDwo.h:14
SymbolFileDWARF::m_type_unit_support_files
llvm::DenseMap< dw_offset_t, lldb_private::FileSpecList > m_type_unit_support_files
Definition: SymbolFileDWARF.h:553
DWARFUnit::GetNonSkeletonUnit
DWARFUnit & GetNonSkeletonUnit()
Definition: DWARFUnit.cpp:630
DWARFUnit::Supports_DW_AT_APPLE_objc_complete_type
bool Supports_DW_AT_APPLE_objc_complete_type()
Definition: DWARFUnit.cpp:649
lldb_private::ModuleChild::GetModule
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
Definition: ModuleChild.cpp:24
SymbolFileDWARF::m_info
std::unique_ptr< DWARFDebugInfo > m_info
Definition: SymbolFileDWARF.h:529
SymbolFileDWARF::ParseDeclsForContext
void ParseDeclsForContext(lldb_private::CompilerDeclContext decl_ctx) override
Definition: SymbolFileDWARF.cpp:1363
if
if(APPLE AND LLVM_ENABLE_LOCAL_SUBMODULE_VISIBILITY) remove_module_flags() endif() macro(add_host_subdirectory group) list(APPEND HOST_SOURCES $
Definition: Host/CMakeLists.txt:1
lldb_private::DWARFDataExtractor::GetAsLLVM
llvm::DWARFDataExtractor GetAsLLVM() const
Definition: DWARFDataExtractor.cpp:24
lldb_private::CompileUnit::ResolveSymbolContext
void ResolveSymbolContext(const SourceLocationSpec &src_location_spec, lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list)
Resolve symbol contexts by file and line.
Definition: CompileUnit.cpp:248
lldb_private::SymbolContext::module_sp
lldb::ModuleSP module_sp
The Module for a given query.
Definition: SymbolContext.h:318
uint16_t
DWARFBaseDIE::GetID
lldb::user_id_t GetID() const
Definition: DWARFBaseDIE.cpp:64
DWARFDebugAbbrev.h
SymbolFileDWARF::DebugInfo
DWARFDebugInfo & DebugInfo()
Definition: SymbolFileDWARF.cpp:635
PluginManager.h
DWARFUnit::GetLocationData
lldb_private::DWARFDataExtractor GetLocationData() const
Definition: DWARFUnit.cpp:504
lldb_private::Block::SetDidParseVariables
void SetDidParseVariables(bool b, bool set_children)
Definition: Block.cpp:496
lldb_private::AddressRange::SetByteSize
void SetByteSize(lldb::addr_t byte_size)
Set accessor for the byte size of this range.
Definition: AddressRange.h:237
DIERef::dwo_num
llvm::Optional< uint32_t > dwo_num() const
Definition: DIERef.h:37
LLDB_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:74
lldb_private::ConstString::GetCString
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:216
lldb_private::ModuleSpec::GetArchitecture
ArchSpec & GetArchitecture()
Definition: ModuleSpec.h:89
LLDB_LOG
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:336
lldb_private::CompileUnit::FindFunctionByUID
lldb::FunctionSP FindFunctionByUID(lldb::user_id_t uid)
Finds a function by user ID.
Definition: CompileUnit.cpp:143
DWARFFormValue::AsCString
const char * AsCString() const
Definition: DWARFFormValue.cpp:459
lldb_private::DWARFContext::getOrLoadMacroData
const DWARFDataExtractor & getOrLoadMacroData()
Definition: DWARFContext.cpp:94
clang
Definition: ASTResultSynthesizer.h:15
lldb_private::CallEdge::AddrType
AddrType
Definition: Function.h:269
DWARFAttributes::AttributeAtIndex
dw_attr_t AttributeAtIndex(uint32_t i) const
Definition: DWARFAttribute.h:55
lldb_private::CompilerDeclContext::GetTypeSystem
TypeSystem * GetTypeSystem() const
Definition: CompilerDeclContext.h:101
lldb_private::CompilerType
Generic representation of a type in a programming language.
Definition: CompilerType.h:33
lldb_private::SymbolFileCommon::GetCompileUnitAtIndex
lldb::CompUnitSP GetCompileUnitAtIndex(uint32_t idx) override
Definition: SymbolFile.cpp:204
DWARFTypeUnit.h
DWARFUnit::GetLoclistOffset
llvm::Optional< uint64_t > GetLoclistOffset(uint32_t Index)
Definition: DWARFUnit.h:240
DWARFUnit::GetUserData
void * GetUserData() const
Definition: DWARFUnit.cpp:645
lldb_private::SymbolFileCommon::GetObjectFile
ObjectFile * GetObjectFile() override
Definition: SymbolFile.h:403
lldb_private::DWARFExpression::ContainsThreadLocalStorage
bool ContainsThreadLocalStorage() const
Definition: DWARFExpression.cpp:489
lldb::user_id_t
uint64_t user_id_t
Definition: lldb-types.h:84
SymbolFileDWARF::FindTypes
void FindTypes(lldb_private::ConstString name, const lldb_private::CompilerDeclContext &parent_decl_ctx, uint32_t max_matches, llvm::DenseSet< lldb_private::SymbolFile * > &searched_symbol_files, lldb_private::TypeMap &types) override
lldb_private::SymbolContext::Clear
void Clear(bool clear_target)
Clear the object's state.
Definition: SymbolContext.cpp:56
SymbolFileDWARF::FindFunctions
void FindFunctions(lldb_private::ConstString name, const lldb_private::CompilerDeclContext &parent_decl_ctx, lldb::FunctionNameType name_type_mask, bool include_inlines, lldb_private::SymbolContextList &sc_list) override
lldb::eValueTypeVariableThreadLocal
@ eValueTypeVariableThreadLocal
thread local storage variable
Definition: lldb-enumerations.h:324
SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE
virtual lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(const DWARFDIE &die, lldb_private::ConstString type_name, bool must_be_implementation)
Definition: SymbolFileDWARF.cpp:2706
lldb_private::FileSpec::AppendPathComponent
void AppendPathComponent(llvm::StringRef component)
Definition: FileSpec.cpp:434
SymbolFileDWARF::ParseBlocksRecursive
size_t ParseBlocksRecursive(lldb_private::Function &func) override
Definition: SymbolFileDWARF.cpp:3039
CompilerDeclContext.h
DWARFDeclContext
Definition: DWARFDeclContext.h:23
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
DWARFDIE::children
llvm::iterator_range< child_iterator > children() const
The range of all the children of this DIE.
Definition: DWARFDIE.cpp:453
lldb_private::eLazyBoolCalculate
@ eLazyBoolCalculate
Definition: lldb-private-enumerations.h:115
SymbolFileDWARF::GetUniqueDWARFASTTypeMap
virtual UniqueDWARFASTTypeMap & GetUniqueDWARFASTTypeMap()
Definition: SymbolFileDWARF.cpp:426
lldb::eValueTypeInvalid
@ eValueTypeInvalid
Definition: lldb-enumerations.h:316
DWARFDebugInfoEntry::Tag
dw_tag_t Tag() const
Definition: DWARFDebugInfoEntry.h:114
lldb_private::Block::FindBlockByID
Block * FindBlockByID(lldb::user_id_t block_id)
Definition: Block.cpp:112
DWARFDeclContext::SetLanguage
void SetLanguage(lldb::LanguageType language)
Definition: DWARFDeclContext.h:80
lldb_private::TypeSystem
Interface for representing a type system.
Definition: TypeSystem.h:71
Error
llvm::Error Error
Definition: UdtRecordCompleter.cpp:30
DWARFCompileUnit::LookupAddress
DWARFDIE LookupAddress(const dw_addr_t address)
Definition: DWARFCompileUnit.cpp:107
DWARFUnit::DIE
DWARFDIE DIE()
Definition: DWARFUnit.h:177
lldb_private::TypeList
Definition: TypeList.h:20
SymbolFileDWARF::DebugAbbrev
DWARFDebugAbbrev * DebugAbbrev()
Definition: SymbolFileDWARF.cpp:614
DWARFCompileUnit::GetNonSkeletonUnit
DWARFCompileUnit & GetNonSkeletonUnit()
Definition: DWARFCompileUnit.cpp:103
SymbolFileDWARF::PopulateBlockVariableList
size_t PopulateBlockVariableList(lldb_private::VariableList &variable_list, const lldb_private::SymbolContext &sc, llvm::ArrayRef< DIERef > variable_dies, lldb::addr_t func_low_pc)
Definition: SymbolFileDWARF.cpp:3737
lldb_private::TypeSystemClang
A TypeSystem implementation based on Clang.
Definition: TypeSystemClang.h:105
DWARFDIE::GetSibling
DWARFDIE GetSibling() const
Definition: DWARFDIE.cpp:107
SymbolFileDWARF::GetDwoNum
virtual llvm::Optional< uint32_t > GetDwoNum()
Definition: SymbolFileDWARF.h:278
SymbolFileDWARFDebugMap::LinkOSOFileAddress
lldb::addr_t LinkOSOFileAddress(SymbolFileDWARF *oso_symfile, lldb::addr_t oso_file_addr)
Convert a .o file "file address" to an executable "file address".
Definition: SymbolFileDWARFDebugMap.cpp:1341
lldb_private::VariableList::AddVariableIfUnique
bool AddVariableIfUnique(const lldb::VariableSP &var_sp)
Definition: VariableList.cpp:29
lldb_private::Address::GetOffset
lldb::addr_t GetOffset() const
Get the section relative offset value.
Definition: Address.h:319
SymbolFileDWARF::DWARFDIE
friend class DWARFDIE
Definition: SymbolFileDWARF.h:77
lldb_private::DataExtractor::Clear
void Clear()
Clears the object state.
Definition: DataExtractor.cpp:192
SymbolFileDWARF::GetDWOId
llvm::Optional< uint64_t > GetDWOId()
If this is a DWARF object with a single CU, return its DW_AT_dwo_id.
Definition: SymbolFileDWARF.cpp:1693
OptionValueFileSpecList.h
lldb_private::LanguageSet
A SmallBitVector that represents a set of source languages (lldb::LanguageType).
Definition: TypeSystem.h:40
DWARFDebugMacroHeader::ParseHeader
static DWARFDebugMacroHeader ParseHeader(const lldb_private::DWARFDataExtractor &debug_macro_data, lldb::offset_t *offset)
Definition: DWARFDebugMacro.cpp:20
lldb_private::SourceModule::search_path
ConstString search_path
Definition: SourceModule.h:21
DebugMacros.h
DWARFDIE::LookupDeepestBlock
DWARFDIE LookupDeepestBlock(lldb::addr_t file_addr) const
Definition: DWARFDIE.cpp:144
SymbolFileDWARF::PreloadSymbols
void PreloadSymbols() override
Definition: SymbolFileDWARF.cpp:2075
lldb_private::DWARFExpression::SetLocationListAddresses
void SetLocationListAddresses(lldb::addr_t cu_file_addr, lldb::addr_t func_file_addr)
Tells the expression that it refers to a location list.
Definition: DWARFExpression.cpp:97
lldb_private::Block::GetStartAddress
bool GetStartAddress(Address &addr)
Definition: Block.cpp:317
SymbolFileDWARF::GetDeclContextContainingUID
lldb_private::CompilerDeclContext GetDeclContextContainingUID(lldb::user_id_t uid) override
Definition: SymbolFileDWARF.cpp:1453
lldb_private::SymbolFile::Blocks
@ Blocks
Definition: SymbolFile.h:66
SymbolFileDWARF::ParseSupportFiles
bool ParseSupportFiles(lldb_private::CompileUnit &comp_unit, lldb_private::FileSpecList &support_files) override
LLDB_PLUGIN_DEFINE
#define LLDB_PLUGIN_DEFINE(PluginName)
Definition: PluginManager.h:31
lldb_private::Log
Definition: Log.h:115
lldb_private::SourceLocationSpec::GetCheckInlines
bool GetCheckInlines() const
Definition: SourceLocationSpec.h:172
lldb::eValueTypeVariableStatic
@ eValueTypeVariableStatic
static variable
Definition: lldb-enumerations.h:318
SymbolFileDWARF::GlobalVariableMap
lldb_private::RangeDataVector< lldb::addr_t, lldb::addr_t, lldb_private::Variable * > GlobalVariableMap
Definition: SymbolFileDWARF.h:484
lldb_private::Variable
Definition: Variable.h:25
SymbolFileDWARF::ParseVariablesInFunctionContextRecursive
size_t ParseVariablesInFunctionContextRecursive(const lldb_private::SymbolContext &sc, const DWARFDIE &die, lldb::addr_t func_low_pc, DIEArray &accumulator)
Definition: SymbolFileDWARF.cpp:3670
lldb_private::SymbolFile::GlobalVariables
@ GlobalVariables
Definition: SymbolFile.h:67
DWARFUnit::GetSymbolFileDWARF
SymbolFileDWARF & GetSymbolFileDWARF() const
Definition: DWARFUnit.h:197
lldb_private::FileSpec::SetFile
void SetFile(llvm::StringRef path, Style style)
Change the file specified with a new path.
Definition: FileSpec.cpp:172
lldb_private::DWARFExpression::Evaluate
bool Evaluate(ExecutionContextScope *exe_scope, lldb::addr_t func_load_addr, const Value *initial_value_ptr, const Value *object_address_ptr, Value &result, Status *error_ptr) const
Wrapper for the static evaluate function that accepts an ExecutionContextScope instead of an Executio...
Definition: DWARFExpression.cpp:842
GetDWOName
static const char * GetDWOName(DWARFCompileUnit &dwarf_cu, const DWARFDebugInfoEntry &cu_die)
Return the DW_AT_(GNU_)dwo_name.
Definition: SymbolFileDWARF.cpp:687
ParseLLVMLineTablePrologue
static bool ParseLLVMLineTablePrologue(lldb_private::DWARFContext &context, llvm::DWARFDebugLine::Prologue &prologue, dw_offset_t line_offset, dw_offset_t unit_offset)
Definition: SymbolFileDWARF.cpp:163
DebugNamesDWARFIndex.h
lldb_private::RegularExpression::GetText
llvm::StringRef GetText() const
Access the regular expression text.
Definition: RegularExpression.cpp:33
lldb_private::CompilerDeclContext::IsContainedInLookup
bool IsContainedInLookup(CompilerDeclContext other) const
Check if the given other decl context is contained in the lookup of this decl context (for example be...
Definition: CompilerDeclContext.cpp:47
lldb_private::SymbolContext::line_entry
LineEntry line_entry
The LineEntry for a given query.
Definition: SymbolContext.h:322
SymbolFileDWARF::GetDIE
virtual DWARFDIE GetDIE(const DIERef &die_ref)
Definition: SymbolFileDWARF.cpp:1669
lldb_private::ClangASTImporter::CanImport
bool CanImport(const CompilerType &type)
Returns true iff the given type was copied from another TypeSystemClang and the original type in this...
Definition: ClangASTImporter.cpp:358
dw_addr_t
uint64_t dw_addr_t
Definition: dwarf.h:29
DWARFUnit::GetIsOptimized
bool GetIsOptimized()
Definition: DWARFUnit.cpp:725
lldb_private::GetLog
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:308
GetDWOId
static uint64_t GetDWOId(DWARFCompileUnit &dwarf_cu, const DWARFDebugInfoEntry &cu_die)
Return the DW_AT_(GNU_)dwo_id.
Definition: SymbolFileDWARF.cpp:1684
lldb_private::FileSpec::GetPath
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:347
lldb_private::Declaration
Definition: Declaration.h:24
DWARFAttributes::CompileUnitAtIndex
DWARFUnit * CompileUnitAtIndex(uint32_t i) const
Definition: DWARFAttribute.h:51
SymbolFileDWARF::~SymbolFileDWARF
~SymbolFileDWARF() override
SymbolFileDWARF::ParseVariablesInFunctionContext
size_t ParseVariablesInFunctionContext(const lldb_private::SymbolContext &sc, const DWARFDIE &die, const lldb::addr_t func_low_pc)
Definition: SymbolFileDWARF.cpp:3652
lldb_private::DataExtractor::GetByteSize
uint64_t GetByteSize() const
Get the number of bytes contained in this object.
Definition: DataExtractor.h:270
lldb_private::DWARFExpression::IsValid
bool IsValid() const
Return true if the location expression contains data.
Definition: DWARFExpression.cpp:75
SymbolFileDWARF::GetDeclContextDIEContainingDIE
DWARFDIE GetDeclContextDIEContainingDIE(const DWARFDIE &die)
Definition: SymbolFileDWARF.cpp:2609
DWARFDebugInfoEntry::GetParent
DWARFDebugInfoEntry * GetParent()
Definition: DWARFDebugInfoEntry.h:126
DWARFDebugInfoEntry::GetAttributeValueAsUnsigned
uint64_t GetAttributeValueAsUnsigned(const DWARFUnit *cu, const dw_attr_t attr, uint64_t fail_value, bool check_specification_or_abstract_origin=false) const
Definition: DWARFDebugInfoEntry.cpp:538
lldb_private::SourceModule::path
std::vector< ConstString > path
Something like "Module.Submodule".
Definition: SourceModule.h:20
lldb
Definition: SBAddress.h:15
DWARFDebugInfo::GetDIE
DWARFDIE GetDIE(const DIERef &die_ref)
Definition: DWARFDebugInfo.cpp:180
DWARFBaseDIE::Tag
dw_tag_t Tag() const
Definition: DWARFBaseDIE.cpp:29
LLDB_LOG_ERROR
#define LLDB_LOG_ERROR(log, error,...)
Definition: Log.h:359
SymbolFileDWARF::HasForwardDeclForClangType
bool HasForwardDeclForClangType(const lldb_private::CompilerType &compiler_type)
Definition: SymbolFileDWARF.cpp:1530
Value.h
SymbolFileDWARF::ParseCallEdgesInFunction
std::vector< std::unique_ptr< lldb_private::CallEdge > > ParseCallEdgesInFunction(UserID func_id) override
Definition: SymbolFileDWARF.cpp:3958
SymbolFileDWARF::GetTypes
void GetTypes(lldb_private::SymbolContextScope *sc_scope, lldb::TypeClass type_mask, lldb_private::TypeList &type_list) override
lldb_private::SymbolFile::LineTables
@ LineTables
Definition: SymbolFile.h:64
LLDBLog.h
SymbolFile.h
DWARFBaseDIE::HasChildren
bool HasChildren() const
Definition: DWARFBaseDIE.cpp:99
lldb_private::dwarf
Definition: dwarf.h:19
lldb_private::ObjectFile
Definition: ObjectFile.h:60
lldb_private::SymbolFileCommon::SetCompileUnitAtIndex
void SetCompileUnitAtIndex(uint32_t idx, const lldb::CompUnitSP &cu_sp)
Definition: SymbolFile.cpp:215
lldb::eDescriptionLevelBrief
@ eDescriptionLevelBrief
Definition: lldb-enumerations.h:208
lldb_private::DWARFContext::getOrLoadLineData
const DWARFDataExtractor & getOrLoadLineData()
Definition: DWARFContext.cpp:73
SymbolFileDWARF::DumpClangAST
void DumpClangAST(lldb_private::Stream &s) override
Definition: SymbolFileDWARF.cpp:3975
DWARFFormValue::IsValid
bool IsValid() const
Definition: DWARFFormValue.h:70
SymbolFileDWARF::ClassOrStructIsVirtual
bool ClassOrStructIsVirtual(const DWARFDIE &die)
Definition: SymbolFileDWARF.cpp:1341
DIERef::Section
Section
Definition: DIERef.h:28
DWARFUnit::GetFile
lldb_private::FileSpec GetFile(size_t file_idx)
Definition: DWARFUnit.cpp:757
SymbolFileDWARF::BuildCuTranslationTable
void BuildCuTranslationTable()
Definition: SymbolFileDWARF.cpp:778
DWARFBaseDIE
Definition: DWARFBaseDIE.h:25
lldb_private::TypeSystem::SupportsLanguage
virtual bool SupportsLanguage(lldb::LanguageType language)=0
lldb_private::DWARFLog::DebugInfo
@ DebugInfo
SymbolFileDWARF::CalculateAbilities
uint32_t CalculateAbilities() override
Definition: SymbolFileDWARF.cpp:519
SymbolFileDWARF::GetUID
lldb::user_id_t GetUID(const DWARFBaseDIE &die)
Definition: SymbolFileDWARF.h:264
GetDWARFMachOSegmentName
static ConstString GetDWARFMachOSegmentName()
Definition: SymbolFileDWARF.cpp:421
lldb_private::RangeVector::GetSize
size_t GetSize() const
Definition: RangeMap.h:290
DWARFBaseDIE::IsValid
bool IsValid() const
Definition: DWARFBaseDIE.h:45
lldb::eLanguageTypeC_plus_plus
@ eLanguageTypeC_plus_plus
ISO C++:1998.
Definition: lldb-enumerations.h:441
DWARFUnit::GetDIE
DWARFDIE GetDIE(dw_offset_t die_offset)
Definition: DWARFUnit.cpp:609
lldb_private::Range::GetRangeEnd
BaseType GetRangeEnd() const
Definition: RangeMap.h:73