/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

Bug Summary

File:	tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
Warning:	line 67, column 29 Use of memory after it is freed

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SymbolFileDWARF.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D HAVE_ROUND -D LLDB_CONFIGURATION_RELEASE -D LLDB_USE_BUILTIN_DEMANGLER -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/lldb/source/Plugins/SymbolFile/DWARF -I /build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/lldb/include -I /build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/include -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn326246/include -I /usr/include/python2.7 -I /build/llvm-toolchain-snapshot-7~svn326246/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/lldb/../clang/include -I /build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/. -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -Wno-deprecated-declarations -Wno-unknown-pragmas -Wno-strict-aliasing -Wno-deprecated-register -Wno-vla-extension -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/lldb/source/Plugins/SymbolFile/DWARF -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-02-28-041547-14988-1 -x c++ /build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

→

1//===-- SymbolFileDWARF.cpp ------------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//

10#include "SymbolFileDWARF.h"

12// Other libraries and framework includes
13#include "llvm/Support/Casting.h"
14#include "llvm/Support/Threading.h"

16#include "lldb/Core/Module.h"
17#include "lldb/Core/ModuleList.h"
18#include "lldb/Core/ModuleSpec.h"
19#include "lldb/Core/PluginManager.h"
20#include "lldb/Core/Scalar.h"
21#include "lldb/Core/Section.h"
22#include "lldb/Core/StreamFile.h"
23#include "lldb/Core/Value.h"
24#include "lldb/Utility/ArchSpec.h"
25#include "lldb/Utility/RegularExpression.h"
26#include "lldb/Utility/StreamString.h"
27#include "lldb/Utility/Timer.h"

29#include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"

31#include "lldb/Host/FileSystem.h"
32#include "lldb/Host/Host.h"
33#include "lldb/Host/Symbols.h"

35#include "lldb/Interpreter/OptionValueFileSpecList.h"
36#include "lldb/Interpreter/OptionValueProperties.h"

38#include "lldb/Symbol/Block.h"
39#include "lldb/Symbol/ClangASTContext.h"
40#include "lldb/Symbol/ClangUtil.h"
41#include "lldb/Symbol/CompileUnit.h"
42#include "lldb/Symbol/CompilerDecl.h"
43#include "lldb/Symbol/CompilerDeclContext.h"
44#include "lldb/Symbol/DebugMacros.h"
45#include "lldb/Symbol/LineTable.h"
46#include "lldb/Symbol/ObjectFile.h"
47#include "lldb/Symbol/SymbolVendor.h"
48#include "lldb/Symbol/TypeMap.h"
49#include "lldb/Symbol/TypeSystem.h"
50#include "lldb/Symbol/VariableList.h"

52#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
53#include "Plugins/Language/ObjC/ObjCLanguage.h"

55#include "lldb/Target/Language.h"

57#include "lldb/Host/TaskPool.h"

59#include "DWARFASTParser.h"
60#include "DWARFASTParserClang.h"
61#include "DWARFCompileUnit.h"
62#include "DWARFDIECollection.h"
63#include "DWARFDebugAbbrev.h"
64#include "DWARFDebugAranges.h"
65#include "DWARFDebugInfo.h"
66#include "DWARFDebugLine.h"
67#include "DWARFDebugMacro.h"
68#include "DWARFDebugRanges.h"
69#include "DWARFDeclContext.h"
70#include "DWARFFormValue.h"
71#include "LogChannelDWARF.h"
72#include "SymbolFileDWARFDebugMap.h"
73#include "SymbolFileDWARFDwo.h"
74#include "SymbolFileDWARFDwp.h"

76#include "llvm/Support/FileSystem.h"

78#include <map>

80#include <ctype.h>
81#include <string.h>

83//#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN

85#ifdef ENABLE_DEBUG_PRINTF
86#include <stdio.h>
87#define DEBUG_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__)
88#else
89#define DEBUG_PRINTF(fmt, ...)
90#endif

92using namespace lldb;
93using namespace lldb_private;

95// static inline bool
96// child_requires_parent_class_union_or_struct_to_be_completed (dw_tag_t tag)
97//{
98//    switch (tag)
99//    {
100//    default:
101//        break;
102//    case DW_TAG_subprogram:
103//    case DW_TAG_inlined_subroutine:
104//    case DW_TAG_class_type:
105//    case DW_TAG_structure_type:
106//    case DW_TAG_union_type:
107//        return true;
108//    }
109//    return false;
110//}
111//

113namespace {

115PropertyDefinition g_properties[] = {
  {"comp-dir-symlink-paths", OptionValue::eTypeFileSpecList, true, 0, nullptr,
   nullptr, "If the DW_AT_comp_dir matches any of these paths the symbolic "
            "links will be resolved at DWARF parse time."},
  {nullptr, OptionValue::eTypeInvalid, false, 0, nullptr, nullptr, nullptr}};

121enum { ePropertySymLinkPaths };

123class PluginProperties : public Properties {
124public:
static ConstString GetSettingName() {
  return SymbolFileDWARF::GetPluginNameStatic();
}

PluginProperties() {
  m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
  m_collection_sp->Initialize(g_properties);
}

FileSpecList &GetSymLinkPaths() {
  OptionValueFileSpecList *option_value =
      m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(
          nullptr, true, ePropertySymLinkPaths);
  assert(option_value)(static_cast <bool> (option_value) ? void (0) : __assert_fail
 ("option_value", "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp"
, 138, __extension__ __PRETTY_FUNCTION__));
  return option_value->GetCurrentValue();
}
141};

143typedef std::shared_ptr<PluginProperties> SymbolFileDWARFPropertiesSP;

145static const SymbolFileDWARFPropertiesSP &GetGlobalPluginProperties() {
static const auto g_settings_sp(std::make_shared<PluginProperties>());
return g_settings_sp;
148}

150} // anonymous namespace end

152static const char *removeHostnameFromPathname(const char *path_from_dwarf) {
if (!path_from_dwarf || !path_from_dwarf[0]) {
  return path_from_dwarf;
}

const char *colon_pos = strchr(path_from_dwarf, ':');
if (nullptr == colon_pos) {
  return path_from_dwarf;
}

const char *slash_pos = strchr(path_from_dwarf, '/');
if (slash_pos && (slash_pos < colon_pos)) {
  return path_from_dwarf;
}

// check whether we have a windows path, and so the first character
// is a drive-letter not a hostname.
if (colon_pos == path_from_dwarf + 1 && isalpha(*path_from_dwarf) &&
    strlen(path_from_dwarf) > 2 && '\\' == path_from_dwarf[2]) {
  return path_from_dwarf;
}

return colon_pos + 1;
175}

177static const char *resolveCompDir(const char *path_from_dwarf) {
if (!path_from_dwarf)
  return nullptr;

// DWARF2/3 suggests the form hostname:pathname for compilation directory.
// Remove the host part if present.
const char *local_path = removeHostnameFromPathname(path_from_dwarf);
if (!local_path)
  return nullptr;

bool is_symlink = false;
FileSpec local_path_spec(local_path, false);
const auto &file_specs = GetGlobalPluginProperties()->GetSymLinkPaths();
for (size_t i = 0; i < file_specs.GetSize() && !is_symlink; ++i)
  is_symlink = FileSpec::Equal(file_specs.GetFileSpecAtIndex(i),
                               local_path_spec, true);

if (!is_symlink)
  return local_path;

namespace fs = llvm::sys::fs;
if (fs::get_file_type(local_path_spec.GetPath(), false) !=
    fs::file_type::symlink_file)
  return local_path;

FileSpec resolved_local_path_spec;
const auto error =
    FileSystem::Readlink(local_path_spec, resolved_local_path_spec);
if (error.Success())
  return resolved_local_path_spec.GetCString();

return nullptr;
209}

211DWARFCompileUnit *SymbolFileDWARF::GetBaseCompileUnit() {
return nullptr;
213}

215void SymbolFileDWARF::Initialize() {
LogChannelDWARF::Initialize();
PluginManager::RegisterPlugin(GetPluginNameStatic(),
                              GetPluginDescriptionStatic(), CreateInstance,
                              DebuggerInitialize);
220}

222void SymbolFileDWARF::DebuggerInitialize(Debugger &debugger) {
if (!PluginManager::GetSettingForSymbolFilePlugin(
        debugger, PluginProperties::GetSettingName())) {
  const bool is_global_setting = true;
  PluginManager::CreateSettingForSymbolFilePlugin(
      debugger, GetGlobalPluginProperties()->GetValueProperties(),
      ConstString("Properties for the dwarf symbol-file plug-in."),
      is_global_setting);
}
231}

233void SymbolFileDWARF::Terminate() {
PluginManager::UnregisterPlugin(CreateInstance);
LogChannelDWARF::Terminate();
236}

238lldb_private::ConstString SymbolFileDWARF::GetPluginNameStatic() {
static ConstString g_name("dwarf");
return g_name;
241}

243const char *SymbolFileDWARF::GetPluginDescriptionStatic() {
return "DWARF and DWARF3 debug symbol file reader.";
245}

247SymbolFile *SymbolFileDWARF::CreateInstance(ObjectFile *obj_file) {
return new SymbolFileDWARF(obj_file);
249}

251TypeList *SymbolFileDWARF::GetTypeList() {
SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
if (debug_map_symfile)
  return debug_map_symfile->GetTypeList();
else
  return m_obj_file->GetModule()->GetTypeList();
257}
258void SymbolFileDWARF::GetTypes(const DWARFDIE &die, dw_offset_t min_die_offset,
                             dw_offset_t max_die_offset, uint32_t type_mask,
                             TypeSet &type_set) {
if (die) {
  const dw_offset_t die_offset = die.GetOffset();

  if (die_offset >= max_die_offset)
    return;

  if (die_offset >= min_die_offset) {
    const dw_tag_t tag = die.Tag();

    bool add_type = false;

    switch (tag) {
    case DW_TAG_array_type:
      add_type = (type_mask & eTypeClassArray) != 0;
      break;
    case DW_TAG_unspecified_type:
    case DW_TAG_base_type:
      add_type = (type_mask & eTypeClassBuiltin) != 0;
      break;
    case DW_TAG_class_type:
      add_type = (type_mask & eTypeClassClass) != 0;
      break;
    case DW_TAG_structure_type:
      add_type = (type_mask & eTypeClassStruct) != 0;
      break;
    case DW_TAG_union_type:
      add_type = (type_mask & eTypeClassUnion) != 0;
      break;
    case DW_TAG_enumeration_type:
      add_type = (type_mask & eTypeClassEnumeration) != 0;
      break;
    case DW_TAG_subroutine_type:
    case DW_TAG_subprogram:
    case DW_TAG_inlined_subroutine:
      add_type = (type_mask & eTypeClassFunction) != 0;
      break;
    case DW_TAG_pointer_type:
      add_type = (type_mask & eTypeClassPointer) != 0;
      break;
    case DW_TAG_rvalue_reference_type:
    case DW_TAG_reference_type:
      add_type = (type_mask & eTypeClassReference) != 0;
      break;
    case DW_TAG_typedef:
      add_type = (type_mask & eTypeClassTypedef) != 0;
      break;
    case DW_TAG_ptr_to_member_type:
      add_type = (type_mask & eTypeClassMemberPointer) != 0;
      break;
    }

    if (add_type) {
      const bool assert_not_being_parsed = true;
      Type *type = ResolveTypeUID(die, assert_not_being_parsed);
      if (type) {
        if (type_set.find(type) == type_set.end())
          type_set.insert(type);
      }
    }
  }

  for (DWARFDIE child_die = die.GetFirstChild(); child_die.IsValid();
       child_die = child_die.GetSibling()) {
    GetTypes(child_die, min_die_offset, max_die_offset, type_mask, type_set);
  }
}
327}

329size_t SymbolFileDWARF::GetTypes(SymbolContextScope *sc_scope,
                               uint32_t type_mask, TypeList &type_list)

332{
TypeSet type_set;

CompileUnit *comp_unit = NULL__null;
DWARFCompileUnit *dwarf_cu = NULL__null;
if (sc_scope)
  comp_unit = sc_scope->CalculateSymbolContextCompileUnit();

if (comp_unit) {
  dwarf_cu = GetDWARFCompileUnit(comp_unit);
  if (dwarf_cu == 0)
    return 0;
  GetTypes(dwarf_cu->DIE(), dwarf_cu->GetOffset(),
           dwarf_cu->GetNextCompileUnitOffset(), type_mask, type_set);
} else {
  DWARFDebugInfo *info = DebugInfo();
  if (info) {
    const size_t num_cus = info->GetNumCompileUnits();
    for (size_t cu_idx = 0; cu_idx < num_cus; ++cu_idx) {
      dwarf_cu = info->GetCompileUnitAtIndex(cu_idx);
      if (dwarf_cu) {
        GetTypes(dwarf_cu->DIE(), 0, UINT32_MAX(4294967295U), type_mask, type_set);
      }
    }
  }
}

std::set<CompilerType> compiler_type_set;
size_t num_types_added = 0;
for (Type *type : type_set) {
  CompilerType compiler_type = type->GetForwardCompilerType();
  if (compiler_type_set.find(compiler_type) == compiler_type_set.end()) {
    compiler_type_set.insert(compiler_type);
    type_list.Insert(type->shared_from_this());
    ++num_types_added;
  }
}
return num_types_added;
370}

372//----------------------------------------------------------------------
373// Gets the first parent that is a lexical block, function or inlined
374// subroutine, or compile unit.
375//----------------------------------------------------------------------
376DWARFDIE
377SymbolFileDWARF::GetParentSymbolContextDIE(const DWARFDIE &child_die) {
DWARFDIE die;
for (die = child_die.GetParent(); die; die = die.GetParent()) {
  dw_tag_t tag = die.Tag();

  switch (tag) {
  case DW_TAG_compile_unit:
  case DW_TAG_subprogram:
  case DW_TAG_inlined_subroutine:
  case DW_TAG_lexical_block:
    return die;
  }
}
return DWARFDIE();
391}

393SymbolFileDWARF::SymbolFileDWARF(ObjectFile *objfile)
  : SymbolFile(objfile),
    UserID(uint64_t(DW_INVALID_OFFSET(~(dw_offset_t)0)) << 32), // Used by SymbolFileDWARFDebugMap to when
                                               // this class parses .o files to contain
                                               // the .o file index/ID
    m_debug_map_module_wp(), m_debug_map_symfile(NULL__null), m_data_debug_abbrev(),
    m_data_debug_aranges(), m_data_debug_frame(), m_data_debug_info(),
    m_data_debug_line(), m_data_debug_macro(), m_data_debug_loc(),
    m_data_debug_ranges(), m_data_debug_str(), m_data_apple_names(),
    m_data_apple_types(), m_data_apple_namespaces(), m_abbr(), m_info(),
    m_line(), m_apple_names_ap(), m_apple_types_ap(), m_apple_namespaces_ap(),
    m_apple_objc_ap(), m_function_basename_index(),
    m_function_fullname_index(), m_function_method_index(),
    m_function_selector_index(), m_objc_class_selectors_index(),
    m_global_index(), m_type_index(), m_namespace_index(), m_indexed(false),
    m_using_apple_tables(false), m_fetched_external_modules(false),
    m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate), m_ranges(),
    m_unique_ast_type_map() {}

412SymbolFileDWARF::~SymbolFileDWARF() {}

414static const ConstString &GetDWARFMachOSegmentName() {
static ConstString g_dwarf_section_name("__DWARF");
return g_dwarf_section_name;
417}

419UniqueDWARFASTTypeMap &SymbolFileDWARF::GetUniqueDWARFASTTypeMap() {
SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
if (debug_map_symfile)
  return debug_map_symfile->GetUniqueDWARFASTTypeMap();
else
  return m_unique_ast_type_map;
425}

427TypeSystem *SymbolFileDWARF::GetTypeSystemForLanguage(LanguageType language) {
SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
TypeSystem *type_system;
if (debug_map_symfile) {
  type_system = debug_map_symfile->GetTypeSystemForLanguage(language);
} else {
  type_system = m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
  if (type_system)
    type_system->SetSymbolFile(this);
}
return type_system;
438}

440void SymbolFileDWARF::InitializeObject() {
ModuleSP module_sp(m_obj_file->GetModule());
if (module_sp) {
  const SectionList *section_list = module_sp->GetSectionList();
  Section *section =
      section_list->FindSectionByName(GetDWARFMachOSegmentName()).get();

  if (section)
    m_obj_file->ReadSectionData(section, m_dwarf_data);
}

get_apple_names_data();
if (m_data_apple_names.m_data.GetByteSize() > 0) {
  m_apple_names_ap.reset(new DWARFMappedHash::MemoryTable(
      m_data_apple_names.m_data, get_debug_str_data(), ".apple_names"));
  if (m_apple_names_ap->IsValid())
    m_using_apple_tables = true;
  else
    m_apple_names_ap.reset();
}
get_apple_types_data();
if (m_data_apple_types.m_data.GetByteSize() > 0) {
  m_apple_types_ap.reset(new DWARFMappedHash::MemoryTable(
      m_data_apple_types.m_data, get_debug_str_data(), ".apple_types"));
  if (m_apple_types_ap->IsValid())
    m_using_apple_tables = true;
  else
    m_apple_types_ap.reset();
}

get_apple_namespaces_data();
if (m_data_apple_namespaces.m_data.GetByteSize() > 0) {
  m_apple_namespaces_ap.reset(new DWARFMappedHash::MemoryTable(
      m_data_apple_namespaces.m_data, get_debug_str_data(),
      ".apple_namespaces"));
  if (m_apple_namespaces_ap->IsValid())
    m_using_apple_tables = true;
  else
    m_apple_namespaces_ap.reset();
}

get_apple_objc_data();
if (m_data_apple_objc.m_data.GetByteSize() > 0) {
  m_apple_objc_ap.reset(new DWARFMappedHash::MemoryTable(
      m_data_apple_objc.m_data, get_debug_str_data(), ".apple_objc"));
  if (m_apple_objc_ap->IsValid())
    m_using_apple_tables = true;
  else
    m_apple_objc_ap.reset();
}
490}

492bool SymbolFileDWARF::SupportedVersion(uint16_t version) {
return version == 2 || version == 3 || version == 4;
494}

496uint32_t SymbolFileDWARF::CalculateAbilities() {
uint32_t abilities = 0;
if (m_obj_file != NULL__null) {
  const Section *section = NULL__null;
  const SectionList *section_list = m_obj_file->GetSectionList();
  if (section_list == NULL__null)
    return 0;

  // On non Apple platforms we might have .debug_types debug info that
  // is created by using "-fdebug-types-section". LLDB currently will try
  // to load this debug info, but it causes crashes during debugging when
  // types are missing since it doesn't know how to parse the info in
  // the .debug_types type units. This causes all complex debug info
  // types to be unresolved. Because this causes LLDB to crash and since
  // it really doesn't provide a solid debuggiung experience, we should
  // disable trying to debug this kind of DWARF until support gets
  // added or deprecated.
  if (section_list->FindSectionByName(ConstString(".debug_types"))) {
    m_obj_file->GetModule()->ReportWarning(
      "lldb doesn’t support .debug_types debug info");
    return 0;
  }

  uint64_t debug_abbrev_file_size = 0;
  uint64_t debug_info_file_size = 0;
  uint64_t debug_line_file_size = 0;

  section = section_list->FindSectionByName(GetDWARFMachOSegmentName()).get();

  if (section)
    section_list = &section->GetChildren();

  section =
      section_list->FindSectionByType(eSectionTypeDWARFDebugInfo, true).get();
  if (section != NULL__null) {
    debug_info_file_size = section->GetFileSize();

    section =
        section_list->FindSectionByType(eSectionTypeDWARFDebugAbbrev, true)
            .get();
    if (section)
      debug_abbrev_file_size = section->GetFileSize();

    DWARFDebugAbbrev *abbrev = DebugAbbrev();
    if (abbrev) {
      std::set<dw_form_t> invalid_forms;
      abbrev->GetUnsupportedForms(invalid_forms);
      if (!invalid_forms.empty()) {
        StreamString error;
        error.Printf("unsupported DW_FORM value%s:", invalid_forms.size() > 1 ? "s" : "");
        for (auto form : invalid_forms)
          error.Printf(" %#x", form);
        m_obj_file->GetModule()->ReportWarning("%s", error.GetString().str().c_str());
        return 0;
      }
    }

    section =
        section_list->FindSectionByType(eSectionTypeDWARFDebugLine, true)
            .get();
    if (section)
      debug_line_file_size = section->GetFileSize();
  } else {
    const char *symfile_dir_cstr =
        m_obj_file->GetFileSpec().GetDirectory().GetCString();
    if (symfile_dir_cstr) {
      if (strcasestr(symfile_dir_cstr, ".dsym")) {
        if (m_obj_file->GetType() == ObjectFile::eTypeDebugInfo) {
          // We have a dSYM file that didn't have a any debug info.
          // If the string table has a size of 1, then it was made from
          // an executable with no debug info, or from an executable that
          // was stripped.
          section =
              section_list->FindSectionByType(eSectionTypeDWARFDebugStr, true)
                  .get();
          if (section && section->GetFileSize() == 1) {
            m_obj_file->GetModule()->ReportWarning(
                "empty dSYM file detected, dSYM was created with an "
                "executable with no debug info.");
          }
        }
      }
    }
  }

  if (debug_abbrev_file_size > 0 && debug_info_file_size > 0)
    abilities |= CompileUnits | Functions | Blocks | GlobalVariables |
                 LocalVariables | VariableTypes;

  if (debug_line_file_size > 0)
    abilities |= LineTables;
}
return abilities;
589}

591const DWARFDataExtractor &
592SymbolFileDWARF::GetCachedSectionData(lldb::SectionType sect_type,
                                    DWARFDataSegment &data_segment) {
llvm::call_once(data_segment.m_flag, [this, sect_type, &data_segment] {
  this->LoadSectionData(sect_type, std::ref(data_segment.m_data));
});
return data_segment.m_data;
598}

600void SymbolFileDWARF::LoadSectionData(lldb::SectionType sect_type,
                                    DWARFDataExtractor &data) {
ModuleSP module_sp(m_obj_file->GetModule());
const SectionList *section_list = module_sp->GetSectionList();
if (section_list) {
  SectionSP section_sp(section_list->FindSectionByType(sect_type, true));
  if (section_sp) {
    // See if we memory mapped the DWARF segment?
    if (m_dwarf_data.GetByteSize()) {
      data.SetData(m_dwarf_data, section_sp->GetOffset(),
                   section_sp->GetFileSize());
    } else {
      if (m_obj_file->ReadSectionData(section_sp.get(), data) == 0)
        data.Clear();
    }
  }
}
617}

619const DWARFDataExtractor &SymbolFileDWARF::get_debug_abbrev_data() {
return GetCachedSectionData(eSectionTypeDWARFDebugAbbrev,
                            m_data_debug_abbrev);
622}

624const DWARFDataExtractor &SymbolFileDWARF::get_debug_addr_data() {
return GetCachedSectionData(eSectionTypeDWARFDebugAddr, m_data_debug_addr);
626}

628const DWARFDataExtractor &SymbolFileDWARF::get_debug_aranges_data() {
return GetCachedSectionData(eSectionTypeDWARFDebugAranges,
                            m_data_debug_aranges);
631}

633const DWARFDataExtractor &SymbolFileDWARF::get_debug_frame_data() {
return GetCachedSectionData(eSectionTypeDWARFDebugFrame, m_data_debug_frame);
635}

637const DWARFDataExtractor &SymbolFileDWARF::get_debug_info_data() {
return GetCachedSectionData(eSectionTypeDWARFDebugInfo, m_data_debug_info);
639}

641const DWARFDataExtractor &SymbolFileDWARF::get_debug_line_data() {
return GetCachedSectionData(eSectionTypeDWARFDebugLine, m_data_debug_line);
643}

645const DWARFDataExtractor &SymbolFileDWARF::get_debug_macro_data() {
return GetCachedSectionData(eSectionTypeDWARFDebugMacro, m_data_debug_macro);
647}

649const DWARFDataExtractor &SymbolFileDWARF::get_debug_loc_data() {
return GetCachedSectionData(eSectionTypeDWARFDebugLoc, m_data_debug_loc);
651}

653const DWARFDataExtractor &SymbolFileDWARF::get_debug_ranges_data() {
return GetCachedSectionData(eSectionTypeDWARFDebugRanges,
                            m_data_debug_ranges);
656}

658const DWARFDataExtractor &SymbolFileDWARF::get_debug_str_data() {
return GetCachedSectionData(eSectionTypeDWARFDebugStr, m_data_debug_str);
660}

662const DWARFDataExtractor &SymbolFileDWARF::get_debug_str_offsets_data() {
return GetCachedSectionData(eSectionTypeDWARFDebugStrOffsets,
                            m_data_debug_str_offsets);
665}

667const DWARFDataExtractor &SymbolFileDWARF::get_apple_names_data() {
return GetCachedSectionData(eSectionTypeDWARFAppleNames, m_data_apple_names);
669}

671const DWARFDataExtractor &SymbolFileDWARF::get_apple_types_data() {
return GetCachedSectionData(eSectionTypeDWARFAppleTypes, m_data_apple_types);
673}

675const DWARFDataExtractor &SymbolFileDWARF::get_apple_namespaces_data() {
return GetCachedSectionData(eSectionTypeDWARFAppleNamespaces,
                            m_data_apple_namespaces);
678}

680const DWARFDataExtractor &SymbolFileDWARF::get_apple_objc_data() {
return GetCachedSectionData(eSectionTypeDWARFAppleObjC, m_data_apple_objc);
682}

684DWARFDebugAbbrev *SymbolFileDWARF::DebugAbbrev() {
if (m_abbr.get() == NULL__null) {
  const DWARFDataExtractor &debug_abbrev_data = get_debug_abbrev_data();
  if (debug_abbrev_data.GetByteSize() > 0) {
    m_abbr.reset(new DWARFDebugAbbrev());
    if (m_abbr.get())
      m_abbr->Parse(debug_abbrev_data);
  }
}
return m_abbr.get();
694}

696const DWARFDebugAbbrev *SymbolFileDWARF::DebugAbbrev() const {
return m_abbr.get();
698}

700DWARFDebugInfo *SymbolFileDWARF::DebugInfo() {
if (m_info.get() == NULL__null) {
  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION__PRETTY_FUNCTION__);
  Timer scoped_timer(func_cat, "%s this = %p", LLVM_PRETTY_FUNCTION__PRETTY_FUNCTION__,
                     static_cast<void *>(this));
  if (get_debug_info_data().GetByteSize() > 0) {
    m_info.reset(new DWARFDebugInfo());
    if (m_info.get()) {
      m_info->SetDwarfData(this);
    }
  }
}
return m_info.get();
713}

715const DWARFDebugInfo *SymbolFileDWARF::DebugInfo() const {
return m_info.get();
717}

719DWARFCompileUnit *
720SymbolFileDWARF::GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit) {
if (!comp_unit)
  return nullptr;

DWARFDebugInfo *info = DebugInfo();
if (info) {
  // Just a normal DWARF file whose user ID for the compile unit is
  // the DWARF offset itself

  DWARFCompileUnit *dwarf_cu =
      info->GetCompileUnit((dw_offset_t)comp_unit->GetID());
  if (dwarf_cu && dwarf_cu->GetUserData() == NULL__null)
    dwarf_cu->SetUserData(comp_unit);
  return dwarf_cu;
}
return NULL__null;
736}

738DWARFDebugRanges *SymbolFileDWARF::DebugRanges() {
if (m_ranges.get() == NULL__null) {
  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION__PRETTY_FUNCTION__);
  Timer scoped_timer(func_cat, "%s this = %p", LLVM_PRETTY_FUNCTION__PRETTY_FUNCTION__,
                     static_cast<void *>(this));
  if (get_debug_ranges_data().GetByteSize() > 0) {
    m_ranges.reset(new DWARFDebugRanges());
    if (m_ranges.get())
      m_ranges->Extract(this);
  }
}
return m_ranges.get();
750}

752const DWARFDebugRanges *SymbolFileDWARF::DebugRanges() const {
return m_ranges.get();
754}

756lldb::CompUnitSP SymbolFileDWARF::ParseCompileUnit(DWARFCompileUnit *dwarf_cu,
                                                 uint32_t cu_idx) {
CompUnitSP cu_sp;
if (dwarf_cu) {
  CompileUnit *comp_unit = (CompileUnit *)dwarf_cu->GetUserData();
  if (comp_unit) {
    // We already parsed this compile unit, had out a shared pointer to it
    cu_sp = comp_unit->shared_from_this();
  } else {
    if (dwarf_cu->GetSymbolFileDWARF() != this) {
      return dwarf_cu->GetSymbolFileDWARF()->ParseCompileUnit(dwarf_cu,
                                                              cu_idx);
    } else if (dwarf_cu->GetOffset() == 0 && GetDebugMapSymfile()) {
      // Let the debug map create the compile unit
      cu_sp = m_debug_map_symfile->GetCompileUnit(this);
      dwarf_cu->SetUserData(cu_sp.get());
    } else {
      ModuleSP module_sp(m_obj_file->GetModule());
      if (module_sp) {
        const DWARFDIE cu_die = dwarf_cu->GetCompileUnitDIEOnly();
        if (cu_die) {
          FileSpec cu_file_spec{cu_die.GetName(), false};
          if (cu_file_spec) {
            // If we have a full path to the compile unit, we don't need to
            // resolve
            // the file.  This can be expensive e.g. when the source files are
            // NFS mounted.
            if (cu_file_spec.IsRelative()) {
              const char *cu_comp_dir{
                  cu_die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr)};
              cu_file_spec.PrependPathComponent(resolveCompDir(cu_comp_dir));
            }

            std::string remapped_file;
            if (module_sp->RemapSourceFile(cu_file_spec.GetPath(),
                                           remapped_file))
              cu_file_spec.SetFile(remapped_file, false);
          }

          LanguageType cu_language = DWARFCompileUnit::LanguageTypeFromDWARF(
              cu_die.GetAttributeValueAsUnsigned(DW_AT_language, 0));

          bool is_optimized = dwarf_cu->GetIsOptimized();
          cu_sp.reset(new CompileUnit(
              module_sp, dwarf_cu, cu_file_spec, dwarf_cu->GetID(),
              cu_language, is_optimized ? eLazyBoolYes : eLazyBoolNo));
          if (cu_sp) {
            // If we just created a compile unit with an invalid file spec,
            // try and get the
            // first entry in the supports files from the line table as that
            // should be the
            // compile unit.
            if (!cu_file_spec) {
              cu_file_spec = cu_sp->GetSupportFiles().GetFileSpecAtIndex(1);
              if (cu_file_spec) {
                (FileSpec &)(*cu_sp) = cu_file_spec;
                // Also fix the invalid file spec which was copied from the
                // compile unit.
                cu_sp->GetSupportFiles().Replace(0, cu_file_spec);
              }
            }

            dwarf_cu->SetUserData(cu_sp.get());

            // Figure out the compile unit index if we weren't given one
            if (cu_idx == UINT32_MAX(4294967295U))
              DebugInfo()->GetCompileUnit(dwarf_cu->GetOffset(), &cu_idx);

            m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(
                cu_idx, cu_sp);
          }
        }
      }
    }
  }
}
return cu_sp;
833}

835uint32_t SymbolFileDWARF::GetNumCompileUnits() {
DWARFDebugInfo *info = DebugInfo();
if (info)
  return info->GetNumCompileUnits();
return 0;
840}

842CompUnitSP SymbolFileDWARF::ParseCompileUnitAtIndex(uint32_t cu_idx) {
CompUnitSP cu_sp;
DWARFDebugInfo *info = DebugInfo();
if (info) {
  DWARFCompileUnit *dwarf_cu = info->GetCompileUnitAtIndex(cu_idx);
  if (dwarf_cu)
    cu_sp = ParseCompileUnit(dwarf_cu, cu_idx);
}
return cu_sp;
851}

853Function *SymbolFileDWARF::ParseCompileUnitFunction(const SymbolContext &sc,
                                                  const DWARFDIE &die) {
if (die.IsValid()) {
  TypeSystem *type_system =
      GetTypeSystemForLanguage(die.GetCU()->GetLanguageType());

  if (type_system) {
    DWARFASTParser *dwarf_ast = type_system->GetDWARFParser();
    if (dwarf_ast)
      return dwarf_ast->ParseFunctionFromDWARF(sc, die);
  }
}
return nullptr;
866}

868bool SymbolFileDWARF::FixupAddress(Address &addr) {
SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
if (debug_map_symfile) {
  return debug_map_symfile->LinkOSOAddress(addr);
}
// This is a normal DWARF file, no address fixups need to happen
return true;
875}
876lldb::LanguageType
877SymbolFileDWARF::ParseCompileUnitLanguage(const SymbolContext &sc) {
assert(sc.comp_unit)(static_cast <bool> (sc.comp_unit) ? void (0) : __assert_fail
 ("sc.comp_unit", "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp"
, 878, __extension__ __PRETTY_FUNCTION__));
DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
if (dwarf_cu)
  return dwarf_cu->GetLanguageType();
else
  return eLanguageTypeUnknown;
884}

886size_t SymbolFileDWARF::ParseCompileUnitFunctions(const SymbolContext &sc) {
assert(sc.comp_unit)(static_cast <bool> (sc.comp_unit) ? void (0) : __assert_fail
 ("sc.comp_unit", "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp"
, 887, __extension__ __PRETTY_FUNCTION__));
size_t functions_added = 0;
DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
if (dwarf_cu) {
  DWARFDIECollection function_dies;
  const size_t num_functions =
      dwarf_cu->AppendDIEsWithTag(DW_TAG_subprogram, function_dies);
  size_t func_idx;
  for (func_idx = 0; func_idx < num_functions; ++func_idx) {
    DWARFDIE die = function_dies.GetDIEAtIndex(func_idx);
    if (sc.comp_unit->FindFunctionByUID(die.GetID()).get() == NULL__null) {
      if (ParseCompileUnitFunction(sc, die))
        ++functions_added;
    }
  }
  // FixupTypes();
}
return functions_added;
905}

907bool SymbolFileDWARF::ParseCompileUnitSupportFiles(
  const SymbolContext &sc, FileSpecList &support_files) {
assert(sc.comp_unit)(static_cast <bool> (sc.comp_unit) ? void (0) : __assert_fail
 ("sc.comp_unit", "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp"
, 909, __extension__ __PRETTY_FUNCTION__));
DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
if (dwarf_cu) {
  const DWARFDIE cu_die = dwarf_cu->GetCompileUnitDIEOnly();

  if (cu_die) {
    const char *cu_comp_dir = resolveCompDir(
        cu_die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr));
    const dw_offset_t stmt_list = cu_die.GetAttributeValueAsUnsigned(
        DW_AT_stmt_list, DW_INVALID_OFFSET(~(dw_offset_t)0));
    if (stmt_list != DW_INVALID_OFFSET(~(dw_offset_t)0)) {
      // All file indexes in DWARF are one based and a file of index zero is
      // supposed to be the compile unit itself.
      support_files.Append(*sc.comp_unit);
      return DWARFDebugLine::ParseSupportFiles(
          sc.comp_unit->GetModule(), get_debug_line_data(), cu_comp_dir,
          stmt_list, support_files);
    }
  }
}
return false;
930}

932bool SymbolFileDWARF::ParseCompileUnitIsOptimized(
  const lldb_private::SymbolContext &sc) {
DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
if (dwarf_cu)
  return dwarf_cu->GetIsOptimized();
return false;
938}

940bool SymbolFileDWARF::ParseImportedModules(
  const lldb_private::SymbolContext &sc,
  std::vector<lldb_private::ConstString> &imported_modules) {
assert(sc.comp_unit)(static_cast <bool> (sc.comp_unit) ? void (0) : __assert_fail
 ("sc.comp_unit", "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp"
, 943, __extension__ __PRETTY_FUNCTION__));
DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
if (dwarf_cu) {
  if (ClangModulesDeclVendor::LanguageSupportsClangModules(
          sc.comp_unit->GetLanguage())) {
    UpdateExternalModuleListIfNeeded();

    if (sc.comp_unit) {
      const DWARFDIE die = dwarf_cu->GetCompileUnitDIEOnly();

      if (die) {
        for (DWARFDIE child_die = die.GetFirstChild(); child_die;
             child_die = child_die.GetSibling()) {
          if (child_die.Tag() == DW_TAG_imported_declaration) {
            if (DWARFDIE module_die =
                    child_die.GetReferencedDIE(DW_AT_import)) {
              if (module_die.Tag() == DW_TAG_module) {
                if (const char *name = module_die.GetAttributeValueAsString(
                        DW_AT_name, nullptr)) {
                  ConstString const_name(name);
                  imported_modules.push_back(const_name);
                }
              }
            }
          }
        }
      }
    } else {
      for (const auto &pair : m_external_type_modules) {
        imported_modules.push_back(pair.first);
      }
    }
  }
}
return false;
978}

980struct ParseDWARFLineTableCallbackInfo {
LineTable *line_table;
std::unique_ptr<LineSequence> sequence_ap;
lldb::addr_t addr_mask;
984};

986//----------------------------------------------------------------------
987// ParseStatementTableCallback
988//----------------------------------------------------------------------
989static void ParseDWARFLineTableCallback(dw_offset_t offset,
                                      const DWARFDebugLine::State &state,
                                      void *userData) {
if (state.row == DWARFDebugLine::State::StartParsingLineTable) {
  // Just started parsing the line table
} else if (state.row == DWARFDebugLine::State::DoneParsingLineTable) {
  // Done parsing line table, nothing to do for the cleanup
} else {
  ParseDWARFLineTableCallbackInfo *info =
      (ParseDWARFLineTableCallbackInfo *)userData;
  LineTable *line_table = info->line_table;

  // If this is our first time here, we need to create a
  // sequence container.
  if (!info->sequence_ap.get()) {
    info->sequence_ap.reset(line_table->CreateLineSequenceContainer());
    assert(info->sequence_ap.get())(static_cast <bool> (info->sequence_ap.get()) ? void
 (0) : __assert_fail ("info->sequence_ap.get()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp"
, 1005, __extension__ __PRETTY_FUNCTION__));
  }
  line_table->AppendLineEntryToSequence(
      info->sequence_ap.get(), state.address & info->addr_mask, state.line,
      state.column, state.file, state.is_stmt, state.basic_block,
      state.prologue_end, state.epilogue_begin, state.end_sequence);
  if (state.end_sequence) {
    // First, put the current sequence into the line table.
    line_table->InsertSequence(info->sequence_ap.get());
    // Then, empty it to prepare for the next sequence.
    info->sequence_ap->Clear();
  }
}
1018}

1020bool SymbolFileDWARF::ParseCompileUnitLineTable(const SymbolContext &sc) {
assert(sc.comp_unit)(static_cast <bool> (sc.comp_unit) ? void (0) : __assert_fail
 ("sc.comp_unit", "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp"
, 1021, __extension__ __PRETTY_FUNCTION__));
if (sc.comp_unit->GetLineTable() != NULL__null)
  return true;

DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
if (dwarf_cu) {
  const DWARFDIE dwarf_cu_die = dwarf_cu->GetCompileUnitDIEOnly();
  if (dwarf_cu_die) {
    const dw_offset_t cu_line_offset =
        dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_stmt_list,
                                                 DW_INVALID_OFFSET(~(dw_offset_t)0));
    if (cu_line_offset != DW_INVALID_OFFSET(~(dw_offset_t)0)) {
      std::unique_ptr<LineTable> line_table_ap(new LineTable(sc.comp_unit));
      if (line_table_ap.get()) {
        ParseDWARFLineTableCallbackInfo info;
        info.line_table = line_table_ap.get();

        /*
         * MIPS:
         * The SymbolContext may not have a valid target, thus we may not be
         * able
         * to call Address::GetOpcodeLoadAddress() which would clear the bit
         * #0
         * for MIPS. Use ArchSpec to clear the bit #0.
        */
        ArchSpec arch;
        GetObjectFile()->GetArchitecture(arch);
        switch (arch.GetMachine()) {
        case llvm::Triple::mips:
        case llvm::Triple::mipsel:
        case llvm::Triple::mips64:
        case llvm::Triple::mips64el:
          info.addr_mask = ~((lldb::addr_t)1);
          break;
        default:
          info.addr_mask = ~((lldb::addr_t)0);
          break;
        }

        lldb::offset_t offset = cu_line_offset;
        DWARFDebugLine::ParseStatementTable(get_debug_line_data(), &offset,
                                            ParseDWARFLineTableCallback,
                                            &info);
        SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
        if (debug_map_symfile) {
          // We have an object file that has a line table with addresses
          // that are not linked. We need to link the line table and convert
          // the addresses that are relative to the .o file into addresses
          // for the main executable.
          sc.comp_unit->SetLineTable(
              debug_map_symfile->LinkOSOLineTable(this, line_table_ap.get()));
        } else {
          sc.comp_unit->SetLineTable(line_table_ap.release());
          return true;
        }
      }
    }
  }
}
return false;
1081}

1083lldb_private::DebugMacrosSP
1084SymbolFileDWARF::ParseDebugMacros(lldb::offset_t *offset) {
auto iter = m_debug_macros_map.find(*offset);
if (iter != m_debug_macros_map.end())
  return iter->second;

const DWARFDataExtractor &debug_macro_data = get_debug_macro_data();
if (debug_macro_data.GetByteSize() == 0)
  return DebugMacrosSP();

lldb_private::DebugMacrosSP debug_macros_sp(new lldb_private::DebugMacros());
m_debug_macros_map[*offset] = debug_macros_sp;

const DWARFDebugMacroHeader &header =
    DWARFDebugMacroHeader::ParseHeader(debug_macro_data, offset);
DWARFDebugMacroEntry::ReadMacroEntries(debug_macro_data, get_debug_str_data(),
                                       header.OffsetIs64Bit(), offset, this,
                                       debug_macros_sp);

return debug_macros_sp;
1103}

1105bool SymbolFileDWARF::ParseCompileUnitDebugMacros(const SymbolContext &sc) {
assert(sc.comp_unit)(static_cast <bool> (sc.comp_unit) ? void (0) : __assert_fail
 ("sc.comp_unit", "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp"
, 1106, __extension__ __PRETTY_FUNCTION__));

DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
if (dwarf_cu == nullptr)
  return false;

const DWARFDIE dwarf_cu_die = dwarf_cu->GetCompileUnitDIEOnly();
if (!dwarf_cu_die)
  return false;

lldb::offset_t sect_offset =
    dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_macros, DW_INVALID_OFFSET(~(dw_offset_t)0));
if (sect_offset == DW_INVALID_OFFSET(~(dw_offset_t)0))
  sect_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_GNU_macros,
                                                         DW_INVALID_OFFSET(~(dw_offset_t)0));
if (sect_offset == DW_INVALID_OFFSET(~(dw_offset_t)0))
  return false;

sc.comp_unit->SetDebugMacros(ParseDebugMacros(&sect_offset));

return true;
1127}

1129size_t SymbolFileDWARF::ParseFunctionBlocks(const SymbolContext &sc,
                                          Block *parent_block,
                                          const DWARFDIE &orig_die,
                                          addr_t subprogram_low_pc,
                                          uint32_t depth) {
size_t blocks_added = 0;
DWARFDIE die = orig_die;
while (die) {
  dw_tag_t tag = die.Tag();

  switch (tag) {
  case DW_TAG_inlined_subroutine:
  case DW_TAG_subprogram:
  case DW_TAG_lexical_block: {
    Block *block = NULL__null;
    if (tag == DW_TAG_subprogram) {
      // Skip any DW_TAG_subprogram DIEs that are inside
      // of a normal or inlined functions. These will be
      // parsed on their own as separate entities.

      if (depth > 0)
        break;

      block = parent_block;
    } else {
      BlockSP block_sp(new Block(die.GetID()));
      parent_block->AddChild(block_sp);
      block = block_sp.get();
    }
    DWARFRangeList ranges;
    const char *name = NULL__null;
    const char *mangled_name = NULL__null;

    int decl_file = 0;
    int decl_line = 0;
    int decl_column = 0;
    int call_file = 0;
    int call_line = 0;
    int call_column = 0;
    if (die.GetDIENamesAndRanges(name, mangled_name, ranges, decl_file,
                                 decl_line, decl_column, call_file, call_line,
                                 call_column, nullptr)) {
      if (tag == DW_TAG_subprogram) {
        assert(subprogram_low_pc == LLDB_INVALID_ADDRESS)(static_cast <bool> (subprogram_low_pc == (18446744073709551615UL
)) ? void (0) : __assert_fail ("subprogram_low_pc == LLDB_INVALID_ADDRESS"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp"
, 1172, __extension__ __PRETTY_FUNCTION__));
        subprogram_low_pc = ranges.GetMinRangeBase(0);
      } else if (tag == DW_TAG_inlined_subroutine) {
        // We get called here for inlined subroutines in two ways.
        // The first time is when we are making the Function object
        // for this inlined concrete instance.  Since we're creating a top
        // level block at
        // here, the subprogram_low_pc will be LLDB_INVALID_ADDRESS.  So we
        // need to
        // adjust the containing address.
        // The second time is when we are parsing the blocks inside the
        // function that contains
        // the inlined concrete instance.  Since these will be blocks inside
        // the containing "real"
        // function the offset will be for that function.
        if (subprogram_low_pc == LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
          subprogram_low_pc = ranges.GetMinRangeBase(0);
        }
      }

      const size_t num_ranges = ranges.GetSize();
      for (size_t i = 0; i < num_ranges; ++i) {
        const DWARFRangeList::Entry &range = ranges.GetEntryRef(i);
        const addr_t range_base = range.GetRangeBase();
        if (range_base >= subprogram_low_pc)
          block->AddRange(Block::Range(range_base - subprogram_low_pc,
                                       range.GetByteSize()));
        else {
          GetObjectFile()->GetModule()->ReportError(
              "0x%8.8" PRIx64"l" "x" ": adding range [0x%" PRIx64"l" "x" "-0x%" PRIx64"l" "x"
              ") which has a base that is less than the function's low PC "
              "0x%" PRIx64"l" "x" ". Please file a bug and attach the file at the "
                           "start of this error message",
              block->GetID(), range_base, range.GetRangeEnd(),
              subprogram_low_pc);
        }
      }
      block->FinalizeRanges();

      if (tag != DW_TAG_subprogram &&
          (name != NULL__null || mangled_name != NULL__null)) {
        std::unique_ptr<Declaration> decl_ap;
        if (decl_file != 0 || decl_line != 0 || decl_column != 0)
          decl_ap.reset(new Declaration(
              sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(decl_file),
              decl_line, decl_column));

        std::unique_ptr<Declaration> call_ap;
        if (call_file != 0 || call_line != 0 || call_column != 0)
          call_ap.reset(new Declaration(
              sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(call_file),
              call_line, call_column));

        block->SetInlinedFunctionInfo(name, mangled_name, decl_ap.get(),
                                      call_ap.get());
      }

      ++blocks_added;

      if (die.HasChildren()) {
        blocks_added += ParseFunctionBlocks(sc, block, die.GetFirstChild(),
                                            subprogram_low_pc, depth + 1);
      }
    }
  } break;
  default:
    break;
  }

  // Only parse siblings of the block if we are not at depth zero. A depth
  // of zero indicates we are currently parsing the top level
  // DW_TAG_subprogram DIE

  if (depth == 0)
    die.Clear();
  else
    die = die.GetSibling();
}
return blocks_added;
1251}

1253bool SymbolFileDWARF::ClassOrStructIsVirtual(const DWARFDIE &parent_die) {
if (parent_die) {
  for (DWARFDIE die = parent_die.GetFirstChild(); die;
       die = die.GetSibling()) {
    dw_tag_t tag = die.Tag();
    bool check_virtuality = false;
    switch (tag) {
    case DW_TAG_inheritance:
    case DW_TAG_subprogram:
      check_virtuality = true;
      break;
    default:
      break;
    }
    if (check_virtuality) {
      if (die.GetAttributeValueAsUnsigned(DW_AT_virtuality, 0) != 0)
        return true;
    }
  }
}
return false;
1274}

1276void SymbolFileDWARF::ParseDeclsForContext(CompilerDeclContext decl_ctx) {
TypeSystem *type_system = decl_ctx.GetTypeSystem();
DWARFASTParser *ast_parser = type_system->GetDWARFParser();
std::vector<DWARFDIE> decl_ctx_die_list =
    ast_parser->GetDIEForDeclContext(decl_ctx);

for (DWARFDIE decl_ctx_die : decl_ctx_die_list)
  for (DWARFDIE decl = decl_ctx_die.GetFirstChild(); decl;
       decl = decl.GetSibling())
    ast_parser->GetDeclForUIDFromDWARF(decl);
1286}

1288SymbolFileDWARF *SymbolFileDWARF::GetDWARFForUID(lldb::user_id_t uid) {
// Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API
// we must make sure we use the correct DWARF file when resolving things.
// On MacOSX, when using SymbolFileDWARFDebugMap, we will use multiple
// SymbolFileDWARF classes, one for each .o file. We can often end up
// with references to other DWARF objects and we must be ready to receive
// a "lldb::user_id_t" that specifies a DIE from another SymbolFileDWARF
// instance.
SymbolFileDWARFDebugMap *debug_map = GetDebugMapSymfile();
if (debug_map)
  return debug_map->GetSymbolFileByOSOIndex(
      debug_map->GetOSOIndexFromUserID(uid));
return this;
1301}

1303DWARFDIE
1304SymbolFileDWARF::GetDIEFromUID(lldb::user_id_t uid) {
// Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API
// we must make sure we use the correct DWARF file when resolving things.
// On MacOSX, when using SymbolFileDWARFDebugMap, we will use multiple
// SymbolFileDWARF classes, one for each .o file. We can often end up
// with references to other DWARF objects and we must be ready to receive
// a "lldb::user_id_t" that specifies a DIE from another SymbolFileDWARF
// instance.
SymbolFileDWARF *dwarf = GetDWARFForUID(uid);
if (dwarf)
  return dwarf->GetDIE(DIERef(uid, dwarf));
return DWARFDIE();
1316}

1318CompilerDecl SymbolFileDWARF::GetDeclForUID(lldb::user_id_t type_uid) {
// Anytime we have a lldb::user_id_t, we must get the DIE by
// calling SymbolFileDWARF::GetDIEFromUID(). See comments inside
// the SymbolFileDWARF::GetDIEFromUID() for details.
DWARFDIE die = GetDIEFromUID(type_uid);
if (die)
  return die.GetDecl();
return CompilerDecl();
1326}

1328CompilerDeclContext
1329SymbolFileDWARF::GetDeclContextForUID(lldb::user_id_t type_uid) {
// Anytime we have a lldb::user_id_t, we must get the DIE by
// calling SymbolFileDWARF::GetDIEFromUID(). See comments inside
// the SymbolFileDWARF::GetDIEFromUID() for details.
DWARFDIE die = GetDIEFromUID(type_uid);
if (die)
  return die.GetDeclContext();
return CompilerDeclContext();
1337}

1339CompilerDeclContext
1340SymbolFileDWARF::GetDeclContextContainingUID(lldb::user_id_t type_uid) {
// Anytime we have a lldb::user_id_t, we must get the DIE by
// calling SymbolFileDWARF::GetDIEFromUID(). See comments inside
// the SymbolFileDWARF::GetDIEFromUID() for details.
DWARFDIE die = GetDIEFromUID(type_uid);
if (die)
  return die.GetContainingDeclContext();
return CompilerDeclContext();
1348}

1350Type *SymbolFileDWARF::ResolveTypeUID(lldb::user_id_t type_uid) {
// Anytime we have a lldb::user_id_t, we must get the DIE by
// calling SymbolFileDWARF::GetDIEFromUID(). See comments inside
// the SymbolFileDWARF::GetDIEFromUID() for details.
DWARFDIE type_die = GetDIEFromUID(type_uid);
if (type_die)
  return type_die.ResolveType();
else
  return nullptr;
1359}

1361Type *SymbolFileDWARF::ResolveTypeUID(const DIERef &die_ref) {
return ResolveType(GetDIE(die_ref), true);
1363}

1365Type *SymbolFileDWARF::ResolveTypeUID(const DWARFDIE &die,
                                    bool assert_not_being_parsed) {
if (die) {
  Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO(1u << 1)));
  if (log)
    GetObjectFile()->GetModule()->LogMessage(
        log, "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s'",
        die.GetOffset(), die.GetTagAsCString(), die.GetName());

  // We might be coming in in the middle of a type tree (a class
  // within a class, an enum within a class), so parse any needed
  // parent DIEs before we get to this one...
  DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(die);
  if (decl_ctx_die) {
    if (log) {
      switch (decl_ctx_die.Tag()) {
      case DW_TAG_structure_type:
      case DW_TAG_union_type:
      case DW_TAG_class_type: {
        // Get the type, which could be a forward declaration
        if (log)
          GetObjectFile()->GetModule()->LogMessage(
              log, "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s' "
                   "resolve parent forward type for 0x%8.8x",
              die.GetOffset(), die.GetTagAsCString(), die.GetName(),
              decl_ctx_die.GetOffset());
      } break;

      default:
        break;
      }
    }
  }
  return ResolveType(die);
}
return NULL__null;
1401}

1403// This function is used when SymbolFileDWARFDebugMap owns a bunch of
1404// SymbolFileDWARF objects to detect if this DWARF file is the one that
1405// can resolve a compiler_type.
1406bool SymbolFileDWARF::HasForwardDeclForClangType(
  const CompilerType &compiler_type) {
CompilerType compiler_type_no_qualifiers =
    ClangUtil::RemoveFastQualifiers(compiler_type);
if (GetForwardDeclClangTypeToDie().count(
        compiler_type_no_qualifiers.GetOpaqueQualType())) {
  return true;
}
TypeSystem *type_system = compiler_type.GetTypeSystem();

ClangASTContext *clang_type_system =
    llvm::dyn_cast_or_null<ClangASTContext>(type_system);
if (!clang_type_system)
  return false;
DWARFASTParserClang *ast_parser =
    static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser());
return ast_parser->GetClangASTImporter().CanImport(compiler_type);
1423}

1425bool SymbolFileDWARF::CompleteType(CompilerType &compiler_type) {
std::lock_guard<std::recursive_mutex> guard(
    GetObjectFile()->GetModule()->GetMutex());

ClangASTContext *clang_type_system =
    llvm::dyn_cast_or_null<ClangASTContext>(compiler_type.GetTypeSystem());
if (clang_type_system) {
  DWARFASTParserClang *ast_parser =
      static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser());
  if (ast_parser &&
      ast_parser->GetClangASTImporter().CanImport(compiler_type))
    return ast_parser->GetClangASTImporter().CompleteType(compiler_type);
}

// We have a struct/union/class/enum that needs to be fully resolved.
CompilerType compiler_type_no_qualifiers =
    ClangUtil::RemoveFastQualifiers(compiler_type);
auto die_it = GetForwardDeclClangTypeToDie().find(
    compiler_type_no_qualifiers.GetOpaqueQualType());
if (die_it == GetForwardDeclClangTypeToDie().end()) {
  // We have already resolved this type...
  return true;
}

DWARFDIE dwarf_die = GetDIE(die_it->getSecond());
if (dwarf_die) {
  // Once we start resolving this type, remove it from the forward declaration
  // map in case anyone child members or other types require this type to get
  // resolved.
  // The type will get resolved when all of the calls to
  // SymbolFileDWARF::ResolveClangOpaqueTypeDefinition
  // are done.
  GetForwardDeclClangTypeToDie().erase(die_it);

  Type *type = GetDIEToType().lookup(dwarf_die.GetDIE());

  Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO(1u << 1) |
                                        DWARF_LOG_TYPE_COMPLETION(1u << 7)));
  if (log)
    GetObjectFile()->GetModule()->LogMessageVerboseBacktrace(
        log, "0x%8.8" PRIx64"l" "x" ": %s '%s' resolving forward declaration...",
        dwarf_die.GetID(), dwarf_die.GetTagAsCString(),
        type->GetName().AsCString());
  assert(compiler_type)(static_cast <bool> (compiler_type) ? void (0) : __assert_fail
 ("compiler_type", "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp"
, 1468, __extension__ __PRETTY_FUNCTION__));
  DWARFASTParser *dwarf_ast = dwarf_die.GetDWARFParser();
  if (dwarf_ast)
    return dwarf_ast->CompleteTypeFromDWARF(dwarf_die, type, compiler_type);
}
return false;
1474}

1476Type *SymbolFileDWARF::ResolveType(const DWARFDIE &die,
                                 bool assert_not_being_parsed,
                                 bool resolve_function_context) {
if (die) {
  Type *type = GetTypeForDIE(die, resolve_function_context).get();

  if (assert_not_being_parsed) {
    if (type != DIE_IS_BEING_PARSED((lldb_private::Type *)1))
      return type;

    GetObjectFile()->GetModule()->ReportError(
        "Parsing a die that is being parsed die: 0x%8.8x: %s %s",
        die.GetOffset(), die.GetTagAsCString(), die.GetName());

  } else
    return type;
}
return nullptr;
1494}

1496CompileUnit *
1497SymbolFileDWARF::GetCompUnitForDWARFCompUnit(DWARFCompileUnit *dwarf_cu,
                                           uint32_t cu_idx) {
// Check if the symbol vendor already knows about this compile unit?
if (dwarf_cu->GetUserData() == NULL__null) {
  // The symbol vendor doesn't know about this compile unit, we
  // need to parse and add it to the symbol vendor object.
  return ParseCompileUnit(dwarf_cu, cu_idx).get();
}
return (CompileUnit *)dwarf_cu->GetUserData();
1506}

1508size_t SymbolFileDWARF::GetObjCMethodDIEOffsets(ConstString class_name,
                                              DIEArray &method_die_offsets) {
method_die_offsets.clear();
if (m_using_apple_tables) {
  if (m_apple_objc_ap.get())
    m_apple_objc_ap->FindByName(class_name.GetStringRef(),
                                method_die_offsets);
} else {
  if (!m_indexed)
    Index();

  m_objc_class_selectors_index.Find(class_name, method_die_offsets);
}
return method_die_offsets.size();
1522}

1524bool SymbolFileDWARF::GetFunction(const DWARFDIE &die, SymbolContext &sc) {
sc.Clear(false);

if (die) {
  // Check if the symbol vendor already knows about this compile unit?
  sc.comp_unit = GetCompUnitForDWARFCompUnit(die.GetCU(), UINT32_MAX(4294967295U));

  sc.function = sc.comp_unit->FindFunctionByUID(die.GetID()).get();
  if (sc.function == NULL__null)
    sc.function = ParseCompileUnitFunction(sc, die);

  if (sc.function) {
    sc.module_sp = sc.function->CalculateSymbolContextModule();
    return true;
  }
}

return false;
1542}

1544lldb::ModuleSP SymbolFileDWARF::GetDWOModule(ConstString name) {
UpdateExternalModuleListIfNeeded();
const auto &pos = m_external_type_modules.find(name);
if (pos != m_external_type_modules.end())
  return pos->second;
else
  return lldb::ModuleSP();
1551}

1553DWARFDIE
1554SymbolFileDWARF::GetDIE(const DIERef &die_ref) {
DWARFDebugInfo *debug_info = DebugInfo();
if (debug_info)
  return debug_info->GetDIE(die_ref);
else
  return DWARFDIE();
1560}

1562std::unique_ptr<SymbolFileDWARFDwo>
1563SymbolFileDWARF::GetDwoSymbolFileForCompileUnit(
  DWARFCompileUnit &dwarf_cu, const DWARFDebugInfoEntry &cu_die) {
// If we are using a dSYM file, we never want the standard DWO files since
// the -gmodules support uses the same DWO machanism to specify full debug
// info files for modules.
if (GetDebugMapSymfile())
  return nullptr;

const char *dwo_name = cu_die.GetAttributeValueAsString(
    this, &dwarf_cu, DW_AT_GNU_dwo_name, nullptr);
if (!dwo_name)
  return nullptr;

SymbolFileDWARFDwp *dwp_symfile = GetDwpSymbolFile();
if (dwp_symfile) {
  uint64_t dwo_id = cu_die.GetAttributeValueAsUnsigned(this, &dwarf_cu,
                                                       DW_AT_GNU_dwo_id, 0);
  std::unique_ptr<SymbolFileDWARFDwo> dwo_symfile =
      dwp_symfile->GetSymbolFileForDwoId(&dwarf_cu, dwo_id);
  if (dwo_symfile)
    return dwo_symfile;
}

FileSpec dwo_file(dwo_name, true);
if (dwo_file.IsRelative()) {
  const char *comp_dir = cu_die.GetAttributeValueAsString(
      this, &dwarf_cu, DW_AT_comp_dir, nullptr);
  if (!comp_dir)
    return nullptr;

  dwo_file.SetFile(comp_dir, true);
  dwo_file.AppendPathComponent(dwo_name);
}

if (!dwo_file.Exists())
  return nullptr;

const lldb::offset_t file_offset = 0;
DataBufferSP dwo_file_data_sp;
lldb::offset_t dwo_file_data_offset = 0;
ObjectFileSP dwo_obj_file = ObjectFile::FindPlugin(
    GetObjectFile()->GetModule(), &dwo_file, file_offset,
    dwo_file.GetByteSize(), dwo_file_data_sp, dwo_file_data_offset);
if (dwo_obj_file == nullptr)
  return nullptr;

return llvm::make_unique<SymbolFileDWARFDwo>(dwo_obj_file, &dwarf_cu);
1610}

1612void SymbolFileDWARF::UpdateExternalModuleListIfNeeded() {
if (m_fetched_external_modules)
15
←
Assuming the condition is false→
16
←
Taking false branch→
  return;
m_fetched_external_modules = true;

DWARFDebugInfo *debug_info = DebugInfo();

const uint32_t num_compile_units = GetNumCompileUnits();
for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
17
←
Assuming 'cu_idx' is < 'num_compile_units'→
18
←
Loop condition is true.  Entering loop body→
21
←
Assuming 'cu_idx' is < 'num_compile_units'→
22
←
Loop condition is true.  Entering loop body→
25
←
Assuming 'cu_idx' is < 'num_compile_units'→
26
←
Loop condition is true.  Entering loop body→
53
←
Assuming 'cu_idx' is < 'num_compile_units'→
54
←
Loop condition is true.  Entering loop body→
  DWARFCompileUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);

  const DWARFDIE die = dwarf_cu->GetCompileUnitDIEOnly();
  if (die && die.HasChildren() == false) {
19
←
Assuming the condition is false→
20
←
Taking false branch→
23
←
Assuming the condition is false→
24
←
Taking false branch→
27
←
Assuming the condition is true→
28
←
Taking true branch→
55
←
Assuming the condition is true→
56
←
Taking true branch→
    const char *name = die.GetAttributeValueAsString(DW_AT_name, nullptr);

    if (name) {
29
←
Assuming 'name' is non-null→
30
←
Taking true branch→
57
←
Assuming 'name' is non-null→
58
←
Taking true branch→
      ConstString const_name(name);
      if (m_external_type_modules.find(const_name) ==
31
←
Assuming the condition is true→
32
←
Taking true branch→
59
←
Assuming the condition is true→
60
←
Taking true branch→
          m_external_type_modules.end()) {
        ModuleSP module_sp;
        const char *dwo_path =
            die.GetAttributeValueAsString(DW_AT_GNU_dwo_name, nullptr);
        if (dwo_path) {
33
←
Assuming 'dwo_path' is null→
34
←
Taking false branch→
61
←
Assuming 'dwo_path' is null→
62
←
Taking false branch→
          ModuleSpec dwo_module_spec;
          dwo_module_spec.GetFileSpec().SetFile(dwo_path, false);
          if (dwo_module_spec.GetFileSpec().IsRelative()) {
            const char *comp_dir =
                die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr);
            if (comp_dir) {
              dwo_module_spec.GetFileSpec().SetFile(comp_dir, true);
              dwo_module_spec.GetFileSpec().AppendPathComponent(dwo_path);
            }
          }
          dwo_module_spec.GetArchitecture() =
              m_obj_file->GetModule()->GetArchitecture();

          // When LLDB loads "external" modules it looks at the
          // presence of DW_AT_GNU_dwo_name.
          // However, when the already created module
          // (corresponding to .dwo itself) is being processed,
          // it will see the presence of DW_AT_GNU_dwo_name
          // (which contains the name of dwo file) and
          // will try to call ModuleList::GetSharedModule again.
          // In some cases (i.e. for empty files) Clang 4.0
          // generates a *.dwo file which has DW_AT_GNU_dwo_name,
          // but no DW_AT_comp_dir. In this case the method
          // ModuleList::GetSharedModule will fail and
          // the warning will be printed. However, as one can notice
          // in this case we don't actually need to try to load the already
          // loaded module (corresponding to .dwo) so we simply skip it.
          if (m_obj_file->GetFileSpec()
                      .GetFileNameExtension()
                      .GetStringRef() == "dwo" &&
              llvm::StringRef(m_obj_file->GetFileSpec().GetPath())
                  .endswith(dwo_module_spec.GetFileSpec().GetPath())) {
            continue;
          }

          Status error = ModuleList::GetSharedModule(
              dwo_module_spec, module_sp, NULL__null, NULL__null, NULL__null);
          if (!module_sp) {
            GetObjectFile()->GetModule()->ReportWarning(
                "0x%8.8x: unable to locate module needed for external types: "
                "%s\nerror: %s\nDebugging will be degraded due to missing "
                "types. Rebuilding your project will regenerate the needed "
                "module files.",
                die.GetOffset(),
                dwo_module_spec.GetFileSpec().GetPath().c_str(),
                error.AsCString("unknown error"));
          }
        }
        m_external_type_modules[const_name] = module_sp;
35
←
Calling defaulted copy assignment operator for 'shared_ptr'→
52
←
Returning; memory was released→
63
←
Calling defaulted copy assignment operator for 'shared_ptr'→
      }
    }
  }
}
1688}

1690SymbolFileDWARF::GlobalVariableMap &SymbolFileDWARF::GetGlobalAranges() {
if (!m_global_aranges_ap) {
  m_global_aranges_ap.reset(new GlobalVariableMap());

  ModuleSP module_sp = GetObjectFile()->GetModule();
  if (module_sp) {
    const size_t num_cus = module_sp->GetNumCompileUnits();
    for (size_t i = 0; i < num_cus; ++i) {
      CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex(i);
      if (cu_sp) {
        VariableListSP globals_sp = cu_sp->GetVariableList(true);
        if (globals_sp) {
          const size_t num_globals = globals_sp->GetSize();
          for (size_t g = 0; g < num_globals; ++g) {
            VariableSP var_sp = globals_sp->GetVariableAtIndex(g);
            if (var_sp && !var_sp->GetLocationIsConstantValueData()) {
              const DWARFExpression &location = var_sp->LocationExpression();
              Value location_result;
              Status error;
              if (location.Evaluate(nullptr, LLDB_INVALID_ADDRESS(18446744073709551615UL), nullptr,
                                    nullptr, location_result, &error)) {
                if (location_result.GetValueType() ==
                    Value::eValueTypeFileAddress) {
                  lldb::addr_t file_addr =
                      location_result.GetScalar().ULongLong();
                  lldb::addr_t byte_size = 1;
                  if (var_sp->GetType())
                    byte_size = var_sp->GetType()->GetByteSize();
                  m_global_aranges_ap->Append(GlobalVariableMap::Entry(
                      file_addr, byte_size, var_sp.get()));
                }
              }
            }
          }
        }
      }
    }
  }
  m_global_aranges_ap->Sort();
}
return *m_global_aranges_ap;
1731}

1733uint32_t SymbolFileDWARF::ResolveSymbolContext(const Address &so_addr,
                                             uint32_t resolve_scope,
                                             SymbolContext &sc) {
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION__PRETTY_FUNCTION__);
Timer scoped_timer(func_cat,
                   "SymbolFileDWARF::"
                   "ResolveSymbolContext (so_addr = { "
                   "section = %p, offset = 0x%" PRIx64"l" "x"
                   " }, resolve_scope = 0x%8.8x)",
                   static_cast<void *>(so_addr.GetSection().get()),
                   so_addr.GetOffset(), resolve_scope);
uint32_t resolved = 0;
if (resolve_scope &
    (eSymbolContextCompUnit | eSymbolContextFunction | eSymbolContextBlock |
     eSymbolContextLineEntry | eSymbolContextVariable)) {
  lldb::addr_t file_vm_addr = so_addr.GetFileAddress();

  DWARFDebugInfo *debug_info = DebugInfo();
  if (debug_info) {
    const dw_offset_t cu_offset =
        debug_info->GetCompileUnitAranges().FindAddress(file_vm_addr);
    if (cu_offset == DW_INVALID_OFFSET(~(dw_offset_t)0)) {
      // Global variables are not in the compile unit address ranges. The only
      // way to
      // currently find global variables is to iterate over the
      // .debug_pubnames or the
      // __apple_names table and find all items in there that point to
      // DW_TAG_variable
      // DIEs and then find the address that matches.
      if (resolve_scope & eSymbolContextVariable) {
        GlobalVariableMap &map = GetGlobalAranges();
        const GlobalVariableMap::Entry *entry =
            map.FindEntryThatContains(file_vm_addr);
        if (entry && entry->data) {
          Variable *variable = entry->data;
          SymbolContextScope *scc = variable->GetSymbolContextScope();
          if (scc) {
            scc->CalculateSymbolContext(&sc);
            sc.variable = variable;
          }
          return sc.GetResolvedMask();
        }
      }
    } else {
      uint32_t cu_idx = DW_INVALID_INDEX0xFFFFFFFFul;
      DWARFCompileUnit *dwarf_cu =
          debug_info->GetCompileUnit(cu_offset, &cu_idx);
      if (dwarf_cu) {
        sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx);
        if (sc.comp_unit) {
          resolved |= eSymbolContextCompUnit;

          bool force_check_line_table = false;
          if (resolve_scope &
              (eSymbolContextFunction | eSymbolContextBlock)) {
            DWARFDIE function_die = dwarf_cu->LookupAddress(file_vm_addr);
            DWARFDIE block_die;
            if (function_die) {
              sc.function =
                  sc.comp_unit->FindFunctionByUID(function_die.GetID()).get();
              if (sc.function == NULL__null)
                sc.function = ParseCompileUnitFunction(sc, function_die);

              if (sc.function && (resolve_scope & eSymbolContextBlock))
                block_die = function_die.LookupDeepestBlock(file_vm_addr);
            } else {
              // We might have had a compile unit that had discontiguous
              // address ranges where the gaps are symbols that don't have
              // any debug info. Discontiguous compile unit address ranges
              // should only happen when there aren't other functions from
              // other compile units in these gaps. This helps keep the size
              // of the aranges down.
              force_check_line_table = true;
            }

            if (sc.function != NULL__null) {
              resolved |= eSymbolContextFunction;

              if (resolve_scope & eSymbolContextBlock) {
                Block &block = sc.function->GetBlock(true);

                if (block_die)
                  sc.block = block.FindBlockByID(block_die.GetID());
                else
                  sc.block = block.FindBlockByID(function_die.GetID());
                if (sc.block)
                  resolved |= eSymbolContextBlock;
              }
            }
          }

          if ((resolve_scope & eSymbolContextLineEntry) ||
              force_check_line_table) {
            LineTable *line_table = sc.comp_unit->GetLineTable();
            if (line_table != NULL__null) {
              // And address that makes it into this function should be in
              // terms
              // of this debug file if there is no debug map, or it will be an
              // address in the .o file which needs to be fixed up to be in
              // terms
              // of the debug map executable. Either way, calling
              // FixupAddress()
              // will work for us.
              Address exe_so_addr(so_addr);
              if (FixupAddress(exe_so_addr)) {
                if (line_table->FindLineEntryByAddress(exe_so_addr,
                                                       sc.line_entry)) {
                  resolved |= eSymbolContextLineEntry;
                }
              }
            }
          }

          if (force_check_line_table &&
              !(resolved & eSymbolContextLineEntry)) {
            // We might have had a compile unit that had discontiguous
            // address ranges where the gaps are symbols that don't have
            // any debug info. Discontiguous compile unit address ranges
            // should only happen when there aren't other functions from
            // other compile units in these gaps. This helps keep the size
            // of the aranges down.
            sc.comp_unit = NULL__null;
            resolved &= ~eSymbolContextCompUnit;
          }
        } else {
          GetObjectFile()->GetModule()->ReportWarning(
              "0x%8.8x: compile unit %u failed to create a valid "
              "lldb_private::CompileUnit class.",
              cu_offset, cu_idx);
        }
      }
    }
  }
}
return resolved;
1868}

1870uint32_t SymbolFileDWARF::ResolveSymbolContext(const FileSpec &file_spec,
                                             uint32_t line,
                                             bool check_inlines,
                                             uint32_t resolve_scope,
                                             SymbolContextList &sc_list) {
const uint32_t prev_size = sc_list.GetSize();
if (resolve_scope & eSymbolContextCompUnit) {
  DWARFDebugInfo *debug_info = DebugInfo();
  if (debug_info) {
    uint32_t cu_idx;
    DWARFCompileUnit *dwarf_cu = NULL__null;

    for (cu_idx = 0;
         (dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx)) != NULL__null;
         ++cu_idx) {
      CompileUnit *dc_cu = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx);
      const bool full_match = (bool)file_spec.GetDirectory();
      bool file_spec_matches_cu_file_spec =
          dc_cu != NULL__null && FileSpec::Equal(file_spec, *dc_cu, full_match);
      if (check_inlines || file_spec_matches_cu_file_spec) {
        SymbolContext sc(m_obj_file->GetModule());
        sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx);
        if (sc.comp_unit) {
          uint32_t file_idx = UINT32_MAX(4294967295U);

          // If we are looking for inline functions only and we don't
          // find it in the support files, we are done.
          if (check_inlines) {
            file_idx = sc.comp_unit->GetSupportFiles().FindFileIndex(
                1, file_spec, true);
            if (file_idx == UINT32_MAX(4294967295U))
              continue;
          }

          if (line != 0) {
            LineTable *line_table = sc.comp_unit->GetLineTable();

            if (line_table != NULL__null && line != 0) {
              // We will have already looked up the file index if
              // we are searching for inline entries.
              if (!check_inlines)
                file_idx = sc.comp_unit->GetSupportFiles().FindFileIndex(
                    1, file_spec, true);

              if (file_idx != UINT32_MAX(4294967295U)) {
                uint32_t found_line;
                uint32_t line_idx = line_table->FindLineEntryIndexByFileIndex(
                    0, file_idx, line, false, &sc.line_entry);
                found_line = sc.line_entry.line;

                while (line_idx != UINT32_MAX(4294967295U)) {
                  sc.function = NULL__null;
                  sc.block = NULL__null;
                  if (resolve_scope &
                      (eSymbolContextFunction | eSymbolContextBlock)) {
                    const lldb::addr_t file_vm_addr =
                        sc.line_entry.range.GetBaseAddress().GetFileAddress();
                    if (file_vm_addr != LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
                      DWARFDIE function_die =
                          dwarf_cu->LookupAddress(file_vm_addr);
                      DWARFDIE block_die;
                      if (function_die) {
                        sc.function =
                            sc.comp_unit
                                ->FindFunctionByUID(function_die.GetID())
                                .get();
                        if (sc.function == NULL__null)
                          sc.function =
                              ParseCompileUnitFunction(sc, function_die);

                        if (sc.function &&
                            (resolve_scope & eSymbolContextBlock))
                          block_die =
                              function_die.LookupDeepestBlock(file_vm_addr);
                      }

                      if (sc.function != NULL__null) {
                        Block &block = sc.function->GetBlock(true);

                        if (block_die)
                          sc.block = block.FindBlockByID(block_die.GetID());
                        else if (function_die)
                          sc.block =
                              block.FindBlockByID(function_die.GetID());
                      }
                    }
                  }

                  sc_list.Append(sc);
                  line_idx = line_table->FindLineEntryIndexByFileIndex(
                      line_idx + 1, file_idx, found_line, true,
                      &sc.line_entry);
                }
              }
            } else if (file_spec_matches_cu_file_spec && !check_inlines) {
              // only append the context if we aren't looking for inline call
              // sites
              // by file and line and if the file spec matches that of the
              // compile unit
              sc_list.Append(sc);
            }
          } else if (file_spec_matches_cu_file_spec && !check_inlines) {
            // only append the context if we aren't looking for inline call
            // sites
            // by file and line and if the file spec matches that of the
            // compile unit
            sc_list.Append(sc);
          }

          if (!check_inlines)
            break;
        }
      }
    }
  }
}
return sc_list.GetSize() - prev_size;
1987}

1989void SymbolFileDWARF::PreloadSymbols() {
std::lock_guard<std::recursive_mutex> guard(
    GetObjectFile()->GetModule()->GetMutex());
Index();
1993}

1995void SymbolFileDWARF::Index() {
if (m_indexed)
  return;
m_indexed = true;
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION__PRETTY_FUNCTION__);
Timer scoped_timer(
    func_cat, "SymbolFileDWARF::Index (%s)",
    GetObjectFile()->GetFileSpec().GetFilename().AsCString("<Unknown>"));

DWARFDebugInfo *debug_info = DebugInfo();
if (debug_info) {
  const uint32_t num_compile_units = GetNumCompileUnits();
  if (num_compile_units == 0)
    return;

  std::vector<NameToDIE> function_basename_index(num_compile_units);
  std::vector<NameToDIE> function_fullname_index(num_compile_units);
  std::vector<NameToDIE> function_method_index(num_compile_units);
  std::vector<NameToDIE> function_selector_index(num_compile_units);
  std::vector<NameToDIE> objc_class_selectors_index(num_compile_units);
  std::vector<NameToDIE> global_index(num_compile_units);
  std::vector<NameToDIE> type_index(num_compile_units);
  std::vector<NameToDIE> namespace_index(num_compile_units);

  // std::vector<bool> might be implemented using bit test-and-set, so use
  // uint8_t instead.
  std::vector<uint8_t> clear_cu_dies(num_compile_units, false);
  auto parser_fn = [debug_info, &function_basename_index,
                    &function_fullname_index, &function_method_index,
                    &function_selector_index, &objc_class_selectors_index,
                    &global_index, &type_index,
                    &namespace_index](size_t cu_idx) {
    DWARFCompileUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
    if (dwarf_cu) {
      dwarf_cu->Index(
          function_basename_index[cu_idx], function_fullname_index[cu_idx],
          function_method_index[cu_idx], function_selector_index[cu_idx],
          objc_class_selectors_index[cu_idx], global_index[cu_idx],
          type_index[cu_idx], namespace_index[cu_idx]);
    }
  };

  auto extract_fn = [debug_info, &clear_cu_dies](size_t cu_idx) {
    DWARFCompileUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
    if (dwarf_cu) {
      // dwarf_cu->ExtractDIEsIfNeeded(false) will return zero if the
      // DIEs for a compile unit have already been parsed.
      if (dwarf_cu->ExtractDIEsIfNeeded(false) > 1)
        clear_cu_dies[cu_idx] = true;
    }
  };

  // Create a task runner that extracts dies for each DWARF compile unit in a
  // separate thread
  //----------------------------------------------------------------------
  // First figure out which compile units didn't have their DIEs already
  // parsed and remember this.  If no DIEs were parsed prior to this index
  // function call, we are going to want to clear the CU dies after we
  // are done indexing to make sure we don't pull in all DWARF dies, but
  // we need to wait until all compile units have been indexed in case
  // a DIE in one compile unit refers to another and the indexes accesses
  // those DIEs.
  //----------------------------------------------------------------------
  TaskMapOverInt(0, num_compile_units, extract_fn);

  // Now create a task runner that can index each DWARF compile unit in a
  // separate
  // thread so we can index quickly.

  TaskMapOverInt(0, num_compile_units, parser_fn);

  auto finalize_fn = [](NameToDIE &index, std::vector<NameToDIE> &srcs) {
    for (auto &src : srcs)
      index.Append(src);
    index.Finalize();
  };

  TaskPool::RunTasks(
      [&]() {
        finalize_fn(m_function_basename_index, function_basename_index);
      },
      [&]() {
        finalize_fn(m_function_fullname_index, function_fullname_index);
      },
      [&]() { finalize_fn(m_function_method_index, function_method_index); },
      [&]() {
        finalize_fn(m_function_selector_index, function_selector_index);
      },
      [&]() {
        finalize_fn(m_objc_class_selectors_index, objc_class_selectors_index);
      },
      [&]() { finalize_fn(m_global_index, global_index); },
      [&]() { finalize_fn(m_type_index, type_index); },
      [&]() { finalize_fn(m_namespace_index, namespace_index); });

  //----------------------------------------------------------------------
  // Keep memory down by clearing DIEs for any compile units if indexing
  // caused us to load the compile unit's DIEs.
  //----------------------------------------------------------------------
  for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
    if (clear_cu_dies[cu_idx])
      debug_info->GetCompileUnitAtIndex(cu_idx)->ClearDIEs(true);
  }

2099#if defined(ENABLE_DEBUG_PRINTF)
  StreamFile s(stdoutstdout, false);
  s.Printf("DWARF index for '%s':",
           GetObjectFile()->GetFileSpec().GetPath().c_str());
  s.Printf("\nFunction basenames:\n");
  m_function_basename_index.Dump(&s);
  s.Printf("\nFunction fullnames:\n");
  m_function_fullname_index.Dump(&s);
  s.Printf("\nFunction methods:\n");
  m_function_method_index.Dump(&s);
  s.Printf("\nFunction selectors:\n");
  m_function_selector_index.Dump(&s);
  s.Printf("\nObjective C class selectors:\n");
  m_objc_class_selectors_index.Dump(&s);
  s.Printf("\nGlobals and statics:\n");
  m_global_index.Dump(&s);
  s.Printf("\nTypes:\n");
  m_type_index.Dump(&s);
  s.Printf("\nNamespaces:\n");
  m_namespace_index.Dump(&s);
2119#endif
}
2121}

2123bool SymbolFileDWARF::DeclContextMatchesThisSymbolFile(
  const lldb_private::CompilerDeclContext *decl_ctx) {
if (decl_ctx == nullptr || !decl_ctx->IsValid()) {
  // Invalid namespace decl which means we aren't matching only things
  // in this symbol file, so return true to indicate it matches this
  // symbol file.
  return true;
}

TypeSystem *decl_ctx_type_system = decl_ctx->GetTypeSystem();
TypeSystem *type_system = GetTypeSystemForLanguage(
    decl_ctx_type_system->GetMinimumLanguage(nullptr));
if (decl_ctx_type_system == type_system)
  return true; // The type systems match, return true

// The namespace AST was valid, and it does not match...
Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS(1u << 6)));

if (log)
  GetObjectFile()->GetModule()->LogMessage(
      log, "Valid namespace does not match symbol file");

return false;
2146}

2148uint32_t SymbolFileDWARF::FindGlobalVariables(
  const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
  bool append, uint32_t max_matches, VariableList &variables) {
Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS(1u << 6)));

if (log)
  GetObjectFile()->GetModule()->LogMessage(
      log, "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", "
           "parent_decl_ctx=%p, append=%u, max_matches=%u, variables)",
      name.GetCString(), static_cast<const void *>(parent_decl_ctx), append,
      max_matches);

if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
  return 0;

DWARFDebugInfo *info = DebugInfo();
if (info == NULL__null)
  return 0;

// If we aren't appending the results to this list, then clear the list
if (!append)
  variables.Clear();

// Remember how many variables are in the list before we search in case
// we are appending the results to a variable list.
const uint32_t original_size = variables.GetSize();

DIEArray die_offsets;

if (m_using_apple_tables) {
  if (m_apple_names_ap.get()) {
    const char *name_cstr = name.GetCString();
    llvm::StringRef basename;
    llvm::StringRef context;

    if (!CPlusPlusLanguage::ExtractContextAndIdentifier(name_cstr, context,
                                                        basename))
      basename = name_cstr;

    m_apple_names_ap->FindByName(basename, die_offsets);
  }
} else {
  // Index the DWARF if we haven't already
  if (!m_indexed)
    Index();

  m_global_index.Find(name, die_offsets);
}

const size_t num_die_matches = die_offsets.size();
if (num_die_matches) {
  SymbolContext sc;
  sc.module_sp = m_obj_file->GetModule();
  assert(sc.module_sp)(static_cast <bool> (sc.module_sp) ? void (0) : __assert_fail
 ("sc.module_sp", "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp"
, 2201, __extension__ __PRETTY_FUNCTION__));

  bool done = false;
  for (size_t i = 0; i < num_die_matches && !done; ++i) {
    const DIERef &die_ref = die_offsets[i];
    DWARFDIE die = GetDIE(die_ref);

    if (die) {
      switch (die.Tag()) {
      default:
      case DW_TAG_subprogram:
      case DW_TAG_inlined_subroutine:
      case DW_TAG_try_block:
      case DW_TAG_catch_block:
        break;

      case DW_TAG_variable: {
        sc.comp_unit = GetCompUnitForDWARFCompUnit(die.GetCU(), UINT32_MAX(4294967295U));

        if (parent_decl_ctx) {
          DWARFASTParser *dwarf_ast = die.GetDWARFParser();
          if (dwarf_ast) {
            CompilerDeclContext actual_parent_decl_ctx =
                dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
            if (!actual_parent_decl_ctx ||
                actual_parent_decl_ctx != *parent_decl_ctx)
              continue;
          }
        }

        ParseVariables(sc, die, LLDB_INVALID_ADDRESS(18446744073709551615UL), false, false,
                       &variables);

        if (variables.GetSize() - original_size >= max_matches)
          done = true;
      } break;
      }
    } else {
      if (m_using_apple_tables) {
        GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
            "the DWARF debug information has been modified (.apple_names "
            "accelerator table had bad die 0x%8.8x for '%s')\n",
            die_ref.die_offset, name.GetCString());
      }
    }
  }
}

// Return the number of variable that were appended to the list
const uint32_t num_matches = variables.GetSize() - original_size;
if (log && num_matches > 0) {
  GetObjectFile()->GetModule()->LogMessage(
      log, "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", "
           "parent_decl_ctx=%p, append=%u, max_matches=%u, variables) => %u",
      name.GetCString(), static_cast<const void *>(parent_decl_ctx), append,
      max_matches, num_matches);
}
return num_matches;
2259}

2261uint32_t SymbolFileDWARF::FindGlobalVariables(const RegularExpression &regex,
                                            bool append, uint32_t max_matches,
                                            VariableList &variables) {
Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS(1u << 6)));

if (log) {
  GetObjectFile()->GetModule()->LogMessage(
      log, "SymbolFileDWARF::FindGlobalVariables (regex=\"%s\", append=%u, "
           "max_matches=%u, variables)",
      regex.GetText().str().c_str(), append, max_matches);
}

DWARFDebugInfo *info = DebugInfo();
if (info == NULL__null)
  return 0;

// If we aren't appending the results to this list, then clear the list
if (!append)
  variables.Clear();

// Remember how many variables are in the list before we search in case
// we are appending the results to a variable list.
const uint32_t original_size = variables.GetSize();

DIEArray die_offsets;

if (m_using_apple_tables) {
  if (m_apple_names_ap.get()) {
    DWARFMappedHash::DIEInfoArray hash_data_array;
    if (m_apple_names_ap->AppendAllDIEsThatMatchingRegex(regex,
                                                         hash_data_array))
      DWARFMappedHash::ExtractDIEArray(hash_data_array, die_offsets);
  }
} else {
  // Index the DWARF if we haven't already
  if (!m_indexed)
    Index();

  m_global_index.Find(regex, die_offsets);
}

SymbolContext sc;
sc.module_sp = m_obj_file->GetModule();
assert(sc.module_sp)(static_cast <bool> (sc.module_sp) ? void (0) : __assert_fail
 ("sc.module_sp", "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp"
, 2304, __extension__ __PRETTY_FUNCTION__));

const size_t num_matches = die_offsets.size();
if (num_matches) {
  for (size_t i = 0; i < num_matches; ++i) {
    const DIERef &die_ref = die_offsets[i];
    DWARFDIE die = GetDIE(die_ref);

    if (die) {
      sc.comp_unit = GetCompUnitForDWARFCompUnit(die.GetCU(), UINT32_MAX(4294967295U));

      ParseVariables(sc, die, LLDB_INVALID_ADDRESS(18446744073709551615UL), false, false, &variables);

      if (variables.GetSize() - original_size >= max_matches)
        break;
    } else {
      if (m_using_apple_tables) {
        GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
            "the DWARF debug information has been modified (.apple_names "
            "accelerator table had bad die 0x%8.8x for regex '%s')\n",
            die_ref.die_offset, regex.GetText().str().c_str());
      }
    }
  }
}

// Return the number of variable that were appended to the list
return variables.GetSize() - original_size;
2332}

2334bool SymbolFileDWARF::ResolveFunction(const DIERef &die_ref,
                                    bool include_inlines,
                                    SymbolContextList &sc_list) {
DWARFDIE die = DebugInfo()->GetDIE(die_ref);
return ResolveFunction(die, include_inlines, sc_list);
2339}

2341bool SymbolFileDWARF::ResolveFunction(const DWARFDIE &orig_die,
                                    bool include_inlines,
                                    SymbolContextList &sc_list) {
SymbolContext sc;

if (!orig_die)
  return false;

// If we were passed a die that is not a function, just return false...
if (!(orig_die.Tag() == DW_TAG_subprogram ||
      (include_inlines && orig_die.Tag() == DW_TAG_inlined_subroutine)))
  return false;

DWARFDIE die = orig_die;
DWARFDIE inlined_die;
if (die.Tag() == DW_TAG_inlined_subroutine) {
  inlined_die = die;

  while (1) {
    die = die.GetParent();

    if (die) {
      if (die.Tag() == DW_TAG_subprogram)
        break;
    } else
      break;
  }
}
assert(die && die.Tag() == DW_TAG_subprogram)(static_cast <bool> (die && die.Tag() == DW_TAG_subprogram
) ? void (0) : __assert_fail ("die && die.Tag() == DW_TAG_subprogram"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp"
, 2369, __extension__ __PRETTY_FUNCTION__));
if (GetFunction(die, sc)) {
  Address addr;
  // Parse all blocks if needed
  if (inlined_die) {
    Block &function_block = sc.function->GetBlock(true);
    sc.block = function_block.FindBlockByID(inlined_die.GetID());
    if (sc.block == NULL__null)
      sc.block = function_block.FindBlockByID(inlined_die.GetOffset());
    if (sc.block == NULL__null || sc.block->GetStartAddress(addr) == false)
      addr.Clear();
  } else {
    sc.block = NULL__null;
    addr = sc.function->GetAddressRange().GetBaseAddress();
  }

  if (addr.IsValid()) {
    sc_list.Append(sc);
    return true;
  }
}

return false;
2392}

2394void SymbolFileDWARF::FindFunctions(const ConstString &name,
                                  const NameToDIE &name_to_die,
                                  bool include_inlines,
                                  SymbolContextList &sc_list) {
DIEArray die_offsets;
if (name_to_die.Find(name, die_offsets)) {
  ParseFunctions(die_offsets, include_inlines, sc_list);
}
2402}

2404void SymbolFileDWARF::FindFunctions(const RegularExpression &regex,
                                  const NameToDIE &name_to_die,
                                  bool include_inlines,
                                  SymbolContextList &sc_list) {
DIEArray die_offsets;
if (name_to_die.Find(regex, die_offsets)) {
  ParseFunctions(die_offsets, include_inlines, sc_list);
}
2412}

2414void SymbolFileDWARF::FindFunctions(
  const RegularExpression &regex,
  const DWARFMappedHash::MemoryTable &memory_table, bool include_inlines,
  SymbolContextList &sc_list) {
DIEArray die_offsets;
DWARFMappedHash::DIEInfoArray hash_data_array;
if (memory_table.AppendAllDIEsThatMatchingRegex(regex, hash_data_array)) {
  DWARFMappedHash::ExtractDIEArray(hash_data_array, die_offsets);
  ParseFunctions(die_offsets, include_inlines, sc_list);
}
2424}

2426void SymbolFileDWARF::ParseFunctions(const DIEArray &die_offsets,
                                   bool include_inlines,
                                   SymbolContextList &sc_list) {
const size_t num_matches = die_offsets.size();
if (num_matches) {
  for (size_t i = 0; i < num_matches; ++i)
    ResolveFunction(die_offsets[i], include_inlines, sc_list);
}
2434}

2436bool SymbolFileDWARF::DIEInDeclContext(const CompilerDeclContext *decl_ctx,
                                     const DWARFDIE &die) {
// If we have no parent decl context to match this DIE matches, and if the
// parent
// decl context isn't valid, we aren't trying to look for any particular decl
// context so any die matches.
if (decl_ctx == nullptr || !decl_ctx->IsValid())
  return true;

if (die) {
  DWARFASTParser *dwarf_ast = die.GetDWARFParser();
  if (dwarf_ast) {
    CompilerDeclContext actual_decl_ctx =
        dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
    if (actual_decl_ctx)
      return actual_decl_ctx == *decl_ctx;
  }
}
return false;
2455}

2457uint32_t
2458SymbolFileDWARF::FindFunctions(const ConstString &name,
                             const CompilerDeclContext *parent_decl_ctx,
                             uint32_t name_type_mask, bool include_inlines,
                             bool append, SymbolContextList &sc_list) {
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION__PRETTY_FUNCTION__);
Timer scoped_timer(func_cat, "SymbolFileDWARF::FindFunctions (name = '%s')",
                   name.AsCString());

// eFunctionNameTypeAuto should be pre-resolved by a call to
// Module::LookupInfo::LookupInfo()
assert((name_type_mask & eFunctionNameTypeAuto) == 0)(static_cast <bool> ((name_type_mask & eFunctionNameTypeAuto
) == 0) ? void (0) : __assert_fail ("(name_type_mask & eFunctionNameTypeAuto) == 0"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp"
, 2468, __extension__ __PRETTY_FUNCTION__));

Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS(1u << 6)));

if (log) {
  GetObjectFile()->GetModule()->LogMessage(
      log, "SymbolFileDWARF::FindFunctions (name=\"%s\", "
           "name_type_mask=0x%x, append=%u, sc_list)",
      name.GetCString(), name_type_mask, append);
}

// If we aren't appending the results to this list, then clear the list
if (!append)
  sc_list.Clear();

if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
  return 0;

// If name is empty then we won't find anything.
if (name.IsEmpty())
  return 0;

// Remember how many sc_list are in the list before we search in case
// we are appending the results to a variable list.

const uint32_t original_size = sc_list.GetSize();

DWARFDebugInfo *info = DebugInfo();
if (info == NULL__null)
  return 0;

std::set<const DWARFDebugInfoEntry *> resolved_dies;
if (m_using_apple_tables) {
  if (m_apple_names_ap.get()) {

    DIEArray die_offsets;

    uint32_t num_matches = 0;

    if (name_type_mask & eFunctionNameTypeFull) {
      // If they asked for the full name, match what they typed.  At some
      // point we may
      // want to canonicalize this (strip double spaces, etc.  For now, we
      // just add all the
      // dies that we find by exact match.
      num_matches =
          m_apple_names_ap->FindByName(name.GetStringRef(), die_offsets);
      for (uint32_t i = 0; i < num_matches; i++) {
        const DIERef &die_ref = die_offsets[i];
        DWARFDIE die = info->GetDIE(die_ref);
        if (die) {
          if (!DIEInDeclContext(parent_decl_ctx, die))
            continue; // The containing decl contexts don't match

          if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) {
            if (ResolveFunction(die, include_inlines, sc_list))
              resolved_dies.insert(die.GetDIE());
          }
        } else {
          GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
              "the DWARF debug information has been modified (.apple_names "
              "accelerator table had bad die 0x%8.8x for '%s')",
              die_ref.die_offset, name.GetCString());
        }
      }
    }

    if (name_type_mask & eFunctionNameTypeSelector) {
      if (parent_decl_ctx && parent_decl_ctx->IsValid())
        return 0; // no selectors in namespaces

      num_matches =
          m_apple_names_ap->FindByName(name.GetStringRef(), die_offsets);
      // Now make sure these are actually ObjC methods.  In this case we can
      // simply look up the name,
      // and if it is an ObjC method name, we're good.

      for (uint32_t i = 0; i < num_matches; i++) {
        const DIERef &die_ref = die_offsets[i];
        DWARFDIE die = info->GetDIE(die_ref);
        if (die) {
          const char *die_name = die.GetName();
          if (ObjCLanguage::IsPossibleObjCMethodName(die_name)) {
            if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) {
              if (ResolveFunction(die, include_inlines, sc_list))
                resolved_dies.insert(die.GetDIE());
            }
          }
        } else {
          GetObjectFile()->GetModule()->ReportError(
              "the DWARF debug information has been modified (.apple_names "
              "accelerator table had bad die 0x%8.8x for '%s')",
              die_ref.die_offset, name.GetCString());
        }
      }
      die_offsets.clear();
    }

    if (((name_type_mask & eFunctionNameTypeMethod) && !parent_decl_ctx) ||
        name_type_mask & eFunctionNameTypeBase) {
      // The apple_names table stores just the "base name" of C++ methods in
      // the table.  So we have to
      // extract the base name, look that up, and if there is any other
      // information in the name we were
      // passed in we have to post-filter based on that.

      // FIXME: Arrange the logic above so that we don't calculate the base
      // name twice:
      num_matches =
          m_apple_names_ap->FindByName(name.GetStringRef(), die_offsets);

      for (uint32_t i = 0; i < num_matches; i++) {
        const DIERef &die_ref = die_offsets[i];
        DWARFDIE die = info->GetDIE(die_ref);
        if (die) {
          if (!DIEInDeclContext(parent_decl_ctx, die))
            continue; // The containing decl contexts don't match

          // If we get to here, the die is good, and we should add it:
          if (resolved_dies.find(die.GetDIE()) == resolved_dies.end() &&
              ResolveFunction(die, include_inlines, sc_list)) {
            bool keep_die = true;
            if ((name_type_mask &
                 (eFunctionNameTypeBase | eFunctionNameTypeMethod)) !=
                (eFunctionNameTypeBase | eFunctionNameTypeMethod)) {
              // We are looking for either basenames or methods, so we need to
              // trim out the ones we won't want by looking at the type
              SymbolContext sc;
              if (sc_list.GetLastContext(sc)) {
                if (sc.block) {
                  // We have an inlined function
                } else if (sc.function) {
                  Type *type = sc.function->GetType();

                  if (type) {
                    CompilerDeclContext decl_ctx =
                        GetDeclContextContainingUID(type->GetID());
                    if (decl_ctx.IsStructUnionOrClass()) {
                      if (name_type_mask & eFunctionNameTypeBase) {
                        sc_list.RemoveContextAtIndex(sc_list.GetSize() - 1);
                        keep_die = false;
                      }
                    } else {
                      if (name_type_mask & eFunctionNameTypeMethod) {
                        sc_list.RemoveContextAtIndex(sc_list.GetSize() - 1);
                        keep_die = false;
                      }
                    }
                  } else {
                    GetObjectFile()->GetModule()->ReportWarning(
                        "function at die offset 0x%8.8x had no function type",
                        die_ref.die_offset);
                  }
                }
              }
            }
            if (keep_die)
              resolved_dies.insert(die.GetDIE());
          }
        } else {
          GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
              "the DWARF debug information has been modified (.apple_names "
              "accelerator table had bad die 0x%8.8x for '%s')",
              die_ref.die_offset, name.GetCString());
        }
      }
      die_offsets.clear();
    }
  }
} else {

  // Index the DWARF if we haven't already
  if (!m_indexed)
    Index();

  if (name_type_mask & eFunctionNameTypeFull) {
    FindFunctions(name, m_function_fullname_index, include_inlines, sc_list);

    // FIXME Temporary workaround for global/anonymous namespace
    // functions debugging FreeBSD and Linux binaries.
    // If we didn't find any functions in the global namespace try
    // looking in the basename index but ignore any returned
    // functions that have a namespace but keep functions which
    // have an anonymous namespace
    // TODO: The arch in the object file isn't correct for MSVC
    // binaries on windows, we should find a way to make it
    // correct and handle those symbols as well.
    if (sc_list.GetSize() == original_size) {
      ArchSpec arch;
      if (!parent_decl_ctx && GetObjectFile()->GetArchitecture(arch) &&
          arch.GetTriple().isOSBinFormatELF()) {
        SymbolContextList temp_sc_list;
        FindFunctions(name, m_function_basename_index, include_inlines,
                      temp_sc_list);
        SymbolContext sc;
        for (uint32_t i = 0; i < temp_sc_list.GetSize(); i++) {
          if (temp_sc_list.GetContextAtIndex(i, sc)) {
            ConstString mangled_name =
                sc.GetFunctionName(Mangled::ePreferMangled);
            ConstString demangled_name =
                sc.GetFunctionName(Mangled::ePreferDemangled);
            // Mangled names on Linux and FreeBSD are of the form:
            // _ZN18function_namespace13function_nameEv.
            if (strncmp(mangled_name.GetCString(), "_ZN", 3) ||
                !strncmp(demangled_name.GetCString(), "(anonymous namespace)",
                         21)) {
              sc_list.Append(sc);
            }
          }
        }
      }
    }
  }
  DIEArray die_offsets;
  if (name_type_mask & eFunctionNameTypeBase) {
    uint32_t num_base = m_function_basename_index.Find(name, die_offsets);
    for (uint32_t i = 0; i < num_base; i++) {
      DWARFDIE die = info->GetDIE(die_offsets[i]);
      if (die) {
        if (!DIEInDeclContext(parent_decl_ctx, die))
          continue; // The containing decl contexts don't match

        // If we get to here, the die is good, and we should add it:
        if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) {
          if (ResolveFunction(die, include_inlines, sc_list))
            resolved_dies.insert(die.GetDIE());
        }
      }
    }
    die_offsets.clear();
  }

  if (name_type_mask & eFunctionNameTypeMethod) {
    if (parent_decl_ctx && parent_decl_ctx->IsValid())
      return 0; // no methods in namespaces

    uint32_t num_base = m_function_method_index.Find(name, die_offsets);
    {
      for (uint32_t i = 0; i < num_base; i++) {
        DWARFDIE die = info->GetDIE(die_offsets[i]);
        if (die) {
          // If we get to here, the die is good, and we should add it:
          if (resolved_dies.find(die.GetDIE()) == resolved_dies.end()) {
            if (ResolveFunction(die, include_inlines, sc_list))
              resolved_dies.insert(die.GetDIE());
          }
        }
      }
    }
    die_offsets.clear();
  }

  if ((name_type_mask & eFunctionNameTypeSelector) &&
      (!parent_decl_ctx || !parent_decl_ctx->IsValid())) {
    FindFunctions(name, m_function_selector_index, include_inlines, sc_list);
  }
}

// Return the number of variable that were appended to the list
const uint32_t num_matches = sc_list.GetSize() - original_size;

if (log && num_matches > 0) {
  GetObjectFile()->GetModule()->LogMessage(
      log, "SymbolFileDWARF::FindFunctions (name=\"%s\", "
           "name_type_mask=0x%x, include_inlines=%d, append=%u, sc_list) => "
           "%u",
      name.GetCString(), name_type_mask, include_inlines, append,
      num_matches);
}
return num_matches;
2738}

2740uint32_t SymbolFileDWARF::FindFunctions(const RegularExpression &regex,
                                      bool include_inlines, bool append,
                                      SymbolContextList &sc_list) {
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION__PRETTY_FUNCTION__);
Timer scoped_timer(func_cat, "SymbolFileDWARF::FindFunctions (regex = '%s')",
                   regex.GetText().str().c_str());

Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS(1u << 6)));

if (log) {
  GetObjectFile()->GetModule()->LogMessage(
      log,
      "SymbolFileDWARF::FindFunctions (regex=\"%s\", append=%u, sc_list)",
      regex.GetText().str().c_str(), append);
}

// If we aren't appending the results to this list, then clear the list
if (!append)
  sc_list.Clear();

// Remember how many sc_list are in the list before we search in case
// we are appending the results to a variable list.
uint32_t original_size = sc_list.GetSize();

if (m_using_apple_tables) {
  if (m_apple_names_ap.get())
    FindFunctions(regex, *m_apple_names_ap, include_inlines, sc_list);
} else {
  // Index the DWARF if we haven't already
  if (!m_indexed)
    Index();

  FindFunctions(regex, m_function_basename_index, include_inlines, sc_list);

  FindFunctions(regex, m_function_fullname_index, include_inlines, sc_list);
}

// Return the number of variable that were appended to the list
return sc_list.GetSize() - original_size;
2779}

2781void SymbolFileDWARF::GetMangledNamesForFunction(
  const std::string &scope_qualified_name,
  std::vector<ConstString> &mangled_names) {
DWARFDebugInfo *info = DebugInfo();
uint32_t num_comp_units = 0;
if (info)
  num_comp_units = info->GetNumCompileUnits();

for (uint32_t i = 0; i < num_comp_units; i++) {
  DWARFCompileUnit *cu = info->GetCompileUnitAtIndex(i);
  if (cu == nullptr)
    continue;

  SymbolFileDWARFDwo *dwo = cu->GetDwoSymbolFile();
  if (dwo)
    dwo->GetMangledNamesForFunction(scope_qualified_name, mangled_names);
}

NameToOffsetMap::iterator iter =
    m_function_scope_qualified_name_map.find(scope_qualified_name);
if (iter == m_function_scope_qualified_name_map.end())
  return;

DIERefSetSP set_sp = (*iter).second;
std::set<DIERef>::iterator set_iter;
for (set_iter = set_sp->begin(); set_iter != set_sp->end(); set_iter++) {
  DWARFDIE die = DebugInfo()->GetDIE(*set_iter);
  mangled_names.push_back(ConstString(die.GetMangledName()));
}
2810}

2812uint32_t SymbolFileDWARF::FindTypes(
  const SymbolContext &sc, const ConstString &name,
  const CompilerDeclContext *parent_decl_ctx, bool append,
  uint32_t max_matches,
  llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
  TypeMap &types) {
// If we aren't appending the results to this list, then clear the list
if (!append)
1
Assuming 'append' is not equal to 0→
2
←
Taking false branch→
  types.Clear();

// Make sure we haven't already searched this SymbolFile before...
if (searched_symbol_files.count(this))
3
←
Assuming the condition is false→
4
←
Taking false branch→
  return 0;
else
  searched_symbol_files.insert(this);

DWARFDebugInfo *info = DebugInfo();
if (info == NULL__null)
5
←
Taking false branch→
  return 0;

Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS(1u << 6)));

if (log) {
6
←
Taking false branch→
  if (parent_decl_ctx)
    GetObjectFile()->GetModule()->LogMessage(
        log, "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = "
             "%p (\"%s\"), append=%u, max_matches=%u, type_list)",
        name.GetCString(), static_cast<const void *>(parent_decl_ctx),
        parent_decl_ctx->GetName().AsCString("<NULL>"), append, max_matches);
  else
    GetObjectFile()->GetModule()->LogMessage(
        log, "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = "
             "NULL, append=%u, max_matches=%u, type_list)",
        name.GetCString(), append, max_matches);
}

if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
7
←
Taking false branch→
  return 0;

DIEArray die_offsets;

if (m_using_apple_tables) {
8
←
Assuming the condition is false→
9
←
Taking false branch→
  if (m_apple_types_ap.get()) {
    m_apple_types_ap->FindByName(name.GetStringRef(), die_offsets);
  }
} else {
  if (!m_indexed)
10
←
Assuming the condition is false→
11
←
Taking false branch→
    Index();

  m_type_index.Find(name, die_offsets);
}

const size_t num_die_matches = die_offsets.size();

if (num_die_matches) {
12
←
Assuming 'num_die_matches' is 0→
13
←
Taking false branch→
  const uint32_t initial_types_size = types.GetSize();
  for (size_t i = 0; i < num_die_matches; ++i) {
    const DIERef &die_ref = die_offsets[i];
    DWARFDIE die = GetDIE(die_ref);

    if (die) {
      if (!DIEInDeclContext(parent_decl_ctx, die))
        continue; // The containing decl contexts don't match

      Type *matching_type = ResolveType(die, true, true);
      if (matching_type) {
        // We found a type pointer, now find the shared pointer form our type
        // list
        types.InsertUnique(matching_type->shared_from_this());
        if (types.GetSize() >= max_matches)
          break;
      }
    } else {
      if (m_using_apple_tables) {
        GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
            "the DWARF debug information has been modified (.apple_types "
            "accelerator table had bad die 0x%8.8x for '%s')\n",
            die_ref.die_offset, name.GetCString());
      }
    }
  }
  const uint32_t num_matches = types.GetSize() - initial_types_size;
  if (log && num_matches) {
    if (parent_decl_ctx) {
      GetObjectFile()->GetModule()->LogMessage(
          log, "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx "
               "= %p (\"%s\"), append=%u, max_matches=%u, type_list) => %u",
          name.GetCString(), static_cast<const void *>(parent_decl_ctx),
          parent_decl_ctx->GetName().AsCString("<NULL>"), append, max_matches,
          num_matches);
    } else {
      GetObjectFile()->GetModule()->LogMessage(
          log, "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx "
               "= NULL, append=%u, max_matches=%u, type_list) => %u",
          name.GetCString(), append, max_matches, num_matches);
    }
  }
  return num_matches;
} else {
  UpdateExternalModuleListIfNeeded();
14
←
Calling 'SymbolFileDWARF::UpdateExternalModuleListIfNeeded'→

  for (const auto &pair : m_external_type_modules) {
    ModuleSP external_module_sp = pair.second;
    if (external_module_sp) {
      SymbolVendor *sym_vendor = external_module_sp->GetSymbolVendor();
      if (sym_vendor) {
        const uint32_t num_external_matches =
            sym_vendor->FindTypes(sc, name, parent_decl_ctx, append,
                                  max_matches, searched_symbol_files, types);
        if (num_external_matches)
          return num_external_matches;
      }
    }
  }
}

return 0;
2929}

2931size_t SymbolFileDWARF::FindTypes(const std::vector<CompilerContext> &context,
                                bool append, TypeMap &types) {
if (!append)
  types.Clear();

if (context.empty())
  return 0;

DIEArray die_offsets;

ConstString name = context.back().name;

if (!name)
  return 0;

if (m_using_apple_tables) {
  if (m_apple_types_ap.get()) {
    m_apple_types_ap->FindByName(name.GetStringRef(), die_offsets);
  }
} else {
  if (!m_indexed)
    Index();

  m_type_index.Find(name, die_offsets);
}

const size_t num_die_matches = die_offsets.size();

if (num_die_matches) {
  size_t num_matches = 0;
  for (size_t i = 0; i < num_die_matches; ++i) {
    const DIERef &die_ref = die_offsets[i];
    DWARFDIE die = GetDIE(die_ref);

    if (die) {
      std::vector<CompilerContext> die_context;
      die.GetDWOContext(die_context);
      if (die_context != context)
        continue;

      Type *matching_type = ResolveType(die, true, true);
      if (matching_type) {
        // We found a type pointer, now find the shared pointer form our type
        // list
        types.InsertUnique(matching_type->shared_from_this());
        ++num_matches;
      }
    } else {
      if (m_using_apple_tables) {
        GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
            "the DWARF debug information has been modified (.apple_types "
            "accelerator table had bad die 0x%8.8x for '%s')\n",
            die_ref.die_offset, name.GetCString());
      }
    }
  }
  return num_matches;
}
return 0;
2990}

2992CompilerDeclContext
2993SymbolFileDWARF::FindNamespace(const SymbolContext &sc, const ConstString &name,
                             const CompilerDeclContext *parent_decl_ctx) {
Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS(1u << 6)));

if (log) {
  GetObjectFile()->GetModule()->LogMessage(
      log, "SymbolFileDWARF::FindNamespace (sc, name=\"%s\")",
      name.GetCString());
}

CompilerDeclContext namespace_decl_ctx;

if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
  return namespace_decl_ctx;

DWARFDebugInfo *info = DebugInfo();
if (info) {
  DIEArray die_offsets;

  // Index if we already haven't to make sure the compile units
  // get indexed and make their global DIE index list
  if (m_using_apple_tables) {
    if (m_apple_namespaces_ap.get()) {
      m_apple_namespaces_ap->FindByName(name.GetStringRef(), die_offsets);
    }
  } else {
    if (!m_indexed)
      Index();

    m_namespace_index.Find(name, die_offsets);
  }

  const size_t num_matches = die_offsets.size();
  if (num_matches) {
    for (size_t i = 0; i < num_matches; ++i) {
      const DIERef &die_ref = die_offsets[i];
      DWARFDIE die = GetDIE(die_ref);

      if (die) {
        if (!DIEInDeclContext(parent_decl_ctx, die))
          continue; // The containing decl contexts don't match

        DWARFASTParser *dwarf_ast = die.GetDWARFParser();
        if (dwarf_ast) {
          namespace_decl_ctx = dwarf_ast->GetDeclContextForUIDFromDWARF(die);
          if (namespace_decl_ctx)
            break;
        }
      } else {
        if (m_using_apple_tables) {
          GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
              "the DWARF debug information has been modified "
              "(.apple_namespaces accelerator table had bad die 0x%8.8x for "
              "'%s')\n",
              die_ref.die_offset, name.GetCString());
        }
      }
    }
  }
}
if (log && namespace_decl_ctx) {
  GetObjectFile()->GetModule()->LogMessage(
      log, "SymbolFileDWARF::FindNamespace (sc, name=\"%s\") => "
           "CompilerDeclContext(%p/%p) \"%s\"",
      name.GetCString(),
      static_cast<const void *>(namespace_decl_ctx.GetTypeSystem()),
      static_cast<const void *>(namespace_decl_ctx.GetOpaqueDeclContext()),
      namespace_decl_ctx.GetName().AsCString("<NULL>"));
}

return namespace_decl_ctx;
3064}

3066TypeSP SymbolFileDWARF::GetTypeForDIE(const DWARFDIE &die,
                                    bool resolve_function_context) {
TypeSP type_sp;
if (die) {
  Type *type_ptr = GetDIEToType().lookup(die.GetDIE());
  if (type_ptr == NULL__null) {
    CompileUnit *lldb_cu = GetCompUnitForDWARFCompUnit(die.GetCU());
    assert(lldb_cu)(static_cast <bool> (lldb_cu) ? void (0) : __assert_fail
 ("lldb_cu", "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp"
, 3073, __extension__ __PRETTY_FUNCTION__));
    SymbolContext sc(lldb_cu);
    const DWARFDebugInfoEntry *parent_die = die.GetParent().GetDIE();
    while (parent_die != nullptr) {
      if (parent_die->Tag() == DW_TAG_subprogram)
        break;
      parent_die = parent_die->GetParent();
    }
    SymbolContext sc_backup = sc;
    if (resolve_function_context && parent_die != nullptr &&
        !GetFunction(DWARFDIE(die.GetCU(), parent_die), sc))
      sc = sc_backup;

    type_sp = ParseType(sc, die, NULL__null);
  } else if (type_ptr != DIE_IS_BEING_PARSED((lldb_private::Type *)1)) {
    // Grab the existing type from the master types lists
    type_sp = type_ptr->shared_from_this();
  }
}
return type_sp;
3093}

3095DWARFDIE
3096SymbolFileDWARF::GetDeclContextDIEContainingDIE(const DWARFDIE &orig_die) {
if (orig_die) {
  DWARFDIE die = orig_die;

  while (die) {
    // If this is the original DIE that we are searching for a declaration
    // for, then don't look in the cache as we don't want our own decl
    // context to be our decl context...
    if (orig_die != die) {
      switch (die.Tag()) {
      case DW_TAG_compile_unit:
      case DW_TAG_namespace:
      case DW_TAG_structure_type:
      case DW_TAG_union_type:
      case DW_TAG_class_type:
      case DW_TAG_lexical_block:
      case DW_TAG_subprogram:
        return die;
      case DW_TAG_inlined_subroutine: {
        DWARFDIE abs_die = die.GetReferencedDIE(DW_AT_abstract_origin);
        if (abs_die) {
          return abs_die;
        }
        break;
      }
      default:
        break;
      }
    }

    DWARFDIE spec_die = die.GetReferencedDIE(DW_AT_specification);
    if (spec_die) {
      DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(spec_die);
      if (decl_ctx_die)
        return decl_ctx_die;
    }

    DWARFDIE abs_die = die.GetReferencedDIE(DW_AT_abstract_origin);
    if (abs_die) {
      DWARFDIE decl_ctx_die = GetDeclContextDIEContainingDIE(abs_die);
      if (decl_ctx_die)
        return decl_ctx_die;
    }

    die = die.GetParent();
  }
}
return DWARFDIE();
3144}

3146Symbol *
3147SymbolFileDWARF::GetObjCClassSymbol(const ConstString &objc_class_name) {
Symbol *objc_class_symbol = NULL__null;
if (m_obj_file) {
  Symtab *symtab = m_obj_file->GetSymtab();
  if (symtab) {
    objc_class_symbol = symtab->FindFirstSymbolWithNameAndType(
        objc_class_name, eSymbolTypeObjCClass, Symtab::eDebugNo,
        Symtab::eVisibilityAny);
  }
}
return objc_class_symbol;
3158}

3160// Some compilers don't emit the DW_AT_APPLE_objc_complete_type attribute. If
3161// they don't
3162// then we can end up looking through all class types for a complete type and
3163// never find
3164// the full definition. We need to know if this attribute is supported, so we
3165// determine
3166// this here and cache th result. We also need to worry about the debug map
3167// DWARF file
3168// if we are doing darwin DWARF in .o file debugging.
3169bool SymbolFileDWARF::Supports_DW_AT_APPLE_objc_complete_type(
  DWARFCompileUnit *cu) {
if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolCalculate) {
  m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolNo;
  if (cu && cu->Supports_DW_AT_APPLE_objc_complete_type())
    m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes;
  else {
    DWARFDebugInfo *debug_info = DebugInfo();
    const uint32_t num_compile_units = GetNumCompileUnits();
    for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
      DWARFCompileUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
      if (dwarf_cu != cu &&
          dwarf_cu->Supports_DW_AT_APPLE_objc_complete_type()) {
        m_supports_DW_AT_APPLE_objc_complete_type = eLazyBoolYes;
        break;
      }
    }
  }
  if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolNo &&
      GetDebugMapSymfile())
    return m_debug_map_symfile->Supports_DW_AT_APPLE_objc_complete_type(this);
}
return m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolYes;
3192}

3194// This function can be used when a DIE is found that is a forward declaration
3195// DIE and we want to try and find a type that has the complete definition.
3196TypeSP SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE(
  const DWARFDIE &die, const ConstString &type_name,
  bool must_be_implementation) {

TypeSP type_sp;

if (!type_name || (must_be_implementation && !GetObjCClassSymbol(type_name)))
  return type_sp;

DIEArray die_offsets;

if (m_using_apple_tables) {
  if (m_apple_types_ap.get()) {
    m_apple_types_ap->FindCompleteObjCClassByName(
        type_name.GetStringRef(), die_offsets, must_be_implementation);
  }
} else {
  if (!m_indexed)
    Index();

  m_type_index.Find(type_name, die_offsets);
}

const size_t num_matches = die_offsets.size();

if (num_matches) {
  for (size_t i = 0; i < num_matches; ++i) {
    const DIERef &die_ref = die_offsets[i];
    DWARFDIE type_die = GetDIE(die_ref);

    if (type_die) {
      bool try_resolving_type = false;

      // Don't try and resolve the DIE we are looking for with the DIE itself!
      if (type_die != die) {
        switch (type_die.Tag()) {
        case DW_TAG_class_type:
        case DW_TAG_structure_type:
          try_resolving_type = true;
          break;
        default:
          break;
        }
      }

      if (try_resolving_type) {
        if (must_be_implementation &&
            type_die.Supports_DW_AT_APPLE_objc_complete_type())
          try_resolving_type = type_die.GetAttributeValueAsUnsigned(
              DW_AT_APPLE_objc_complete_type, 0);

        if (try_resolving_type) {
          Type *resolved_type = ResolveType(type_die, false, true);
          if (resolved_type && resolved_type != DIE_IS_BEING_PARSED((lldb_private::Type *)1)) {
            DEBUG_PRINTF("resolved 0x%8.8" PRIx64 " from %s to 0x%8.8" PRIx64
                         " (cu 0x%8.8" PRIx64 ")\n",
                         die.GetID(),
                         m_obj_file->GetFileSpec().GetFilename().AsCString(
                             "<Unknown>"),
                         type_die.GetID(), type_cu->GetID());

            if (die)
              GetDIEToType()[die.GetDIE()] = resolved_type;
            type_sp = resolved_type->shared_from_this();
            break;
          }
        }
      }
    } else {
      if (m_using_apple_tables) {
        GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
            "the DWARF debug information has been modified (.apple_types "
            "accelerator table had bad die 0x%8.8x for '%s')\n",
            die_ref.die_offset, type_name.GetCString());
      }
    }
  }
}
return type_sp;
3275}

3277//----------------------------------------------------------------------
3278// This function helps to ensure that the declaration contexts match for
3279// two different DIEs. Often times debug information will refer to a
3280// forward declaration of a type (the equivalent of "struct my_struct;".
3281// There will often be a declaration of that type elsewhere that has the
3282// full definition. When we go looking for the full type "my_struct", we
3283// will find one or more matches in the accelerator tables and we will
3284// then need to make sure the type was in the same declaration context
3285// as the original DIE. This function can efficiently compare two DIEs
3286// and will return true when the declaration context matches, and false
3287// when they don't.
3288//----------------------------------------------------------------------
3289bool SymbolFileDWARF::DIEDeclContextsMatch(const DWARFDIE &die1,
                                         const DWARFDIE &die2) {
if (die1 == die2)
  return true;

DWARFDIECollection decl_ctx_1;
DWARFDIECollection decl_ctx_2;
// The declaration DIE stack is a stack of the declaration context
// DIEs all the way back to the compile unit. If a type "T" is
// declared inside a class "B", and class "B" is declared inside
// a class "A" and class "A" is in a namespace "lldb", and the
// namespace is in a compile unit, there will be a stack of DIEs:
//
//   [0] DW_TAG_class_type for "B"
//   [1] DW_TAG_class_type for "A"
//   [2] DW_TAG_namespace  for "lldb"
//   [3] DW_TAG_compile_unit for the source file.
//
// We grab both contexts and make sure that everything matches
// all the way back to the compiler unit.

// First lets grab the decl contexts for both DIEs
die1.GetDeclContextDIEs(decl_ctx_1);
die2.GetDeclContextDIEs(decl_ctx_2);
// Make sure the context arrays have the same size, otherwise
// we are done
const size_t count1 = decl_ctx_1.Size();
const size_t count2 = decl_ctx_2.Size();
if (count1 != count2)
  return false;

// Make sure the DW_TAG values match all the way back up the
// compile unit. If they don't, then we are done.
DWARFDIE decl_ctx_die1;
DWARFDIE decl_ctx_die2;
size_t i;
for (i = 0; i < count1; i++) {
  decl_ctx_die1 = decl_ctx_1.GetDIEAtIndex(i);
  decl_ctx_die2 = decl_ctx_2.GetDIEAtIndex(i);
  if (decl_ctx_die1.Tag() != decl_ctx_die2.Tag())
    return false;
}
3331#if defined LLDB_CONFIGURATION_DEBUG

// Make sure the top item in the decl context die array is always
// DW_TAG_compile_unit. If it isn't then something went wrong in
// the DWARFDIE::GetDeclContextDIEs() function...
assert(decl_ctx_1.GetDIEAtIndex(count1 - 1).Tag() == DW_TAG_compile_unit)(static_cast <bool> (decl_ctx_1.GetDIEAtIndex(count1 - 1
).Tag() == DW_TAG_compile_unit) ? void (0) : __assert_fail ("decl_ctx_1.GetDIEAtIndex(count1 - 1).Tag() == DW_TAG_compile_unit"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp"
, 3336, __extension__ __PRETTY_FUNCTION__));

3338#endif
// Always skip the compile unit when comparing by only iterating up to
// "count - 1". Here we compare the names as we go.
for (i = 0; i < count1 - 1; i++) {
  decl_ctx_die1 = decl_ctx_1.GetDIEAtIndex(i);
  decl_ctx_die2 = decl_ctx_2.GetDIEAtIndex(i);
  const char *name1 = decl_ctx_die1.GetName();
  const char *name2 = decl_ctx_die2.GetName();
  // If the string was from a DW_FORM_strp, then the pointer will often
  // be the same!
  if (name1 == name2)
    continue;

  // Name pointers are not equal, so only compare the strings
  // if both are not NULL.
  if (name1 && name2) {
    // If the strings don't compare, we are done...
    if (strcmp(name1, name2) != 0)
      return false;
  } else {
    // One name was NULL while the other wasn't
    return false;
  }
}
// We made it through all of the checks and the declaration contexts
// are equal.
return true;
3365}

3367TypeSP SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(
  const DWARFDeclContext &dwarf_decl_ctx) {
TypeSP type_sp;

const uint32_t dwarf_decl_ctx_count = dwarf_decl_ctx.GetSize();
if (dwarf_decl_ctx_count > 0) {
  const ConstString type_name(dwarf_decl_ctx[0].name);
  const dw_tag_t tag = dwarf_decl_ctx[0].tag;

  if (type_name) {
    Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION(1u << 7) |
                                          DWARF_LOG_LOOKUPS(1u << 6)));
    if (log) {
      GetObjectFile()->GetModule()->LogMessage(
          log, "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%"
               "s, qualified-name='%s')",
          DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
          dwarf_decl_ctx.GetQualifiedName());
    }

    DIEArray die_offsets;

    if (m_using_apple_tables) {
      if (m_apple_types_ap.get()) {
        const bool has_tag =
            m_apple_types_ap->GetHeader().header_data.ContainsAtom(
                DWARFMappedHash::eAtomTypeTag);
        const bool has_qualified_name_hash =
            m_apple_types_ap->GetHeader().header_data.ContainsAtom(
                DWARFMappedHash::eAtomTypeQualNameHash);
        if (has_tag && has_qualified_name_hash) {
          const char *qualified_name = dwarf_decl_ctx.GetQualifiedName();
          const uint32_t qualified_name_hash = llvm::djbHash(qualified_name);
          if (log)
            GetObjectFile()->GetModule()->LogMessage(
                log, "FindByNameAndTagAndQualifiedNameHash()");
          m_apple_types_ap->FindByNameAndTagAndQualifiedNameHash(
              type_name.GetStringRef(), tag, qualified_name_hash,
              die_offsets);
        } else if (has_tag) {
          if (log)
            GetObjectFile()->GetModule()->LogMessage(log,
                                                     "FindByNameAndTag()");
          m_apple_types_ap->FindByNameAndTag(type_name.GetStringRef(), tag,
                                             die_offsets);
        } else {
          m_apple_types_ap->FindByName(type_name.GetStringRef(), die_offsets);
        }
      }
    } else {
      if (!m_indexed)
        Index();

      m_type_index.Find(type_name, die_offsets);
    }

    const size_t num_matches = die_offsets.size();

    // Get the type system that we are looking to find a type for. We will use
    // this
    // to ensure any matches we find are in a language that this type system
    // supports
    const LanguageType language = dwarf_decl_ctx.GetLanguage();
    TypeSystem *type_system = (language == eLanguageTypeUnknown)
                                  ? nullptr
                                  : GetTypeSystemForLanguage(language);

    if (num_matches) {
      for (size_t i = 0; i < num_matches; ++i) {
        const DIERef &die_ref = die_offsets[i];
        DWARFDIE type_die = GetDIE(die_ref);

        if (type_die) {
          // Make sure type_die's langauge matches the type system we are
          // looking for.
          // We don't want to find a "Foo" type from Java if we are looking
          // for a "Foo"
          // type for C, C++, ObjC, or ObjC++.
          if (type_system &&
              !type_system->SupportsLanguage(type_die.GetLanguage()))
            continue;
          bool try_resolving_type = false;

          // Don't try and resolve the DIE we are looking for with the DIE
          // itself!
          const dw_tag_t type_tag = type_die.Tag();
          // Make sure the tags match
          if (type_tag == tag) {
            // The tags match, lets try resolving this type
            try_resolving_type = true;
          } else {
            // The tags don't match, but we need to watch our for a
            // forward declaration for a struct and ("struct foo")
            // ends up being a class ("class foo { ... };") or
            // vice versa.
            switch (type_tag) {
            case DW_TAG_class_type:
              // We had a "class foo", see if we ended up with a "struct foo {
              // ... };"
              try_resolving_type = (tag == DW_TAG_structure_type);
              break;
            case DW_TAG_structure_type:
              // We had a "struct foo", see if we ended up with a "class foo {
              // ... };"
              try_resolving_type = (tag == DW_TAG_class_type);
              break;
            default:
              // Tags don't match, don't event try to resolve
              // using this type whose name matches....
              break;
            }
          }

          if (try_resolving_type) {
            DWARFDeclContext type_dwarf_decl_ctx;
            type_die.GetDWARFDeclContext(type_dwarf_decl_ctx);

            if (log) {
              GetObjectFile()->GetModule()->LogMessage(
                  log, "SymbolFileDWARF::"
                       "FindDefinitionTypeForDWARFDeclContext(tag=%s, "
                       "qualified-name='%s') trying die=0x%8.8x (%s)",
                  DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
                  dwarf_decl_ctx.GetQualifiedName(), type_die.GetOffset(),
                  type_dwarf_decl_ctx.GetQualifiedName());
            }

            // Make sure the decl contexts match all the way up
            if (dwarf_decl_ctx == type_dwarf_decl_ctx) {
              Type *resolved_type = ResolveType(type_die, false);
              if (resolved_type && resolved_type != DIE_IS_BEING_PARSED((lldb_private::Type *)1)) {
                type_sp = resolved_type->shared_from_this();
                break;
              }
            }
          } else {
            if (log) {
              std::string qualified_name;
              type_die.GetQualifiedName(qualified_name);
              GetObjectFile()->GetModule()->LogMessage(
                  log, "SymbolFileDWARF::"
                       "FindDefinitionTypeForDWARFDeclContext(tag=%s, "
                       "qualified-name='%s') ignoring die=0x%8.8x (%s)",
                  DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
                  dwarf_decl_ctx.GetQualifiedName(), type_die.GetOffset(),
                  qualified_name.c_str());
            }
          }
        } else {
          if (m_using_apple_tables) {
            GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
                "the DWARF debug information has been modified (.apple_types "
                "accelerator table had bad die 0x%8.8x for '%s')\n",
                die_ref.die_offset, type_name.GetCString());
          }
        }
      }
    }
  }
}
return type_sp;
3528}

3530TypeSP SymbolFileDWARF::ParseType(const SymbolContext &sc, const DWARFDIE &die,
                                bool *type_is_new_ptr) {
TypeSP type_sp;

if (die) {
  TypeSystem *type_system =
      GetTypeSystemForLanguage(die.GetCU()->GetLanguageType());

  if (type_system) {
    DWARFASTParser *dwarf_ast = type_system->GetDWARFParser();
    if (dwarf_ast) {
      Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO(1u << 1));
      type_sp = dwarf_ast->ParseTypeFromDWARF(sc, die, log, type_is_new_ptr);
      if (type_sp) {
        TypeList *type_list = GetTypeList();
        if (type_list)
          type_list->Insert(type_sp);

        if (die.Tag() == DW_TAG_subprogram) {
          DIERef die_ref = die.GetDIERef();
          std::string scope_qualified_name(GetDeclContextForUID(die.GetID())
                                               .GetScopeQualifiedName()
                                               .AsCString(""));
          if (scope_qualified_name.size()) {
            NameToOffsetMap::iterator iter =
                m_function_scope_qualified_name_map.find(
                    scope_qualified_name);
            if (iter != m_function_scope_qualified_name_map.end())
              (*iter).second->insert(die_ref);
            else {
              DIERefSetSP new_set(new std::set<DIERef>);
              new_set->insert(die_ref);
              m_function_scope_qualified_name_map.emplace(
                  std::make_pair(scope_qualified_name, new_set));
            }
          }
        }
      }
    }
  }
}

return type_sp;
3573}

3575size_t SymbolFileDWARF::ParseTypes(const SymbolContext &sc,
                                 const DWARFDIE &orig_die,
                                 bool parse_siblings, bool parse_children) {
size_t types_added = 0;
DWARFDIE die = orig_die;
while (die) {
  bool type_is_new = false;
  if (ParseType(sc, die, &type_is_new).get()) {
    if (type_is_new)
      ++types_added;
  }

  if (parse_children && die.HasChildren()) {
    if (die.Tag() == DW_TAG_subprogram) {
      SymbolContext child_sc(sc);
      child_sc.function = sc.comp_unit->FindFunctionByUID(die.GetID()).get();
      types_added += ParseTypes(child_sc, die.GetFirstChild(), true, true);
    } else
      types_added += ParseTypes(sc, die.GetFirstChild(), true, true);
  }

  if (parse_siblings)
    die = die.GetSibling();
  else
    die.Clear();
}
return types_added;
3602}

3604size_t SymbolFileDWARF::ParseFunctionBlocks(const SymbolContext &sc) {
assert(sc.comp_unit && sc.function)(static_cast <bool> (sc.comp_unit && sc.function
) ? void (0) : __assert_fail ("sc.comp_unit && sc.function"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp"
, 3605, __extension__ __PRETTY_FUNCTION__));
size_t functions_added = 0;
DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
if (dwarf_cu) {
  const dw_offset_t function_die_offset = sc.function->GetID();
  DWARFDIE function_die = dwarf_cu->GetDIE(function_die_offset);
  if (function_die) {
    ParseFunctionBlocks(sc, &sc.function->GetBlock(false), function_die,
                        LLDB_INVALID_ADDRESS(18446744073709551615UL), 0);
  }
}

return functions_added;
3618}

3620size_t SymbolFileDWARF::ParseTypes(const SymbolContext &sc) {
// At least a compile unit must be valid
assert(sc.comp_unit)(static_cast <bool> (sc.comp_unit) ? void (0) : __assert_fail
 ("sc.comp_unit", "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp"
, 3622, __extension__ __PRETTY_FUNCTION__));
size_t types_added = 0;
DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
if (dwarf_cu) {
  if (sc.function) {
    dw_offset_t function_die_offset = sc.function->GetID();
    DWARFDIE func_die = dwarf_cu->GetDIE(function_die_offset);
    if (func_die && func_die.HasChildren()) {
      types_added = ParseTypes(sc, func_die.GetFirstChild(), true, true);
    }
  } else {
    DWARFDIE dwarf_cu_die = dwarf_cu->DIE();
    if (dwarf_cu_die && dwarf_cu_die.HasChildren()) {
      types_added = ParseTypes(sc, dwarf_cu_die.GetFirstChild(), true, true);
    }
  }
}

return types_added;
3641}

3643size_t SymbolFileDWARF::ParseVariablesForContext(const SymbolContext &sc) {
if (sc.comp_unit != NULL__null) {
  DWARFDebugInfo *info = DebugInfo();
  if (info == NULL__null)
    return 0;

  if (sc.function) {
    DWARFDIE function_die = info->GetDIE(DIERef(sc.function->GetID(), this));

    const dw_addr_t func_lo_pc = function_die.GetAttributeValueAsAddress(
        DW_AT_low_pc, LLDB_INVALID_ADDRESS(18446744073709551615UL));
    if (func_lo_pc != LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
      const size_t num_variables = ParseVariables(
          sc, function_die.GetFirstChild(), func_lo_pc, true, true);

      // Let all blocks know they have parse all their variables
      sc.function->GetBlock(false).SetDidParseVariables(true, true);
      return num_variables;
    }
  } else if (sc.comp_unit) {
    DWARFCompileUnit *dwarf_cu = info->GetCompileUnit(sc.comp_unit->GetID());

    if (dwarf_cu == NULL__null)
      return 0;

    uint32_t vars_added = 0;
    VariableListSP variables(sc.comp_unit->GetVariableList(false));

    if (variables.get() == NULL__null) {
      variables.reset(new VariableList());
      sc.comp_unit->SetVariableList(variables);

      DIEArray die_offsets;
      if (m_using_apple_tables) {
        if (m_apple_names_ap.get()) {
          DWARFMappedHash::DIEInfoArray hash_data_array;
          if (m_apple_names_ap->AppendAllDIEsInRange(
                  dwarf_cu->GetOffset(), dwarf_cu->GetNextCompileUnitOffset(),
                  hash_data_array)) {
            DWARFMappedHash::ExtractDIEArray(hash_data_array, die_offsets);
          }
        }
      } else {
        // Index if we already haven't to make sure the compile units
        // get indexed and make their global DIE index list
        if (!m_indexed)
          Index();

        m_global_index.FindAllEntriesForCompileUnit(dwarf_cu->GetOffset(),
                                                    die_offsets);
      }

      const size_t num_matches = die_offsets.size();
      if (num_matches) {
        for (size_t i = 0; i < num_matches; ++i) {
          const DIERef &die_ref = die_offsets[i];
          DWARFDIE die = GetDIE(die_ref);
          if (die) {
            VariableSP var_sp(
                ParseVariableDIE(sc, die, LLDB_INVALID_ADDRESS(18446744073709551615UL)));
            if (var_sp) {
              variables->AddVariableIfUnique(var_sp);
              ++vars_added;
            }
          } else {
            if (m_using_apple_tables) {
              GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
                  "the DWARF debug information has been modified "
                  "(.apple_names accelerator table had bad die 0x%8.8x)\n",
                  die_ref.die_offset);
            }
          }
        }
      }
    }
    return vars_added;
  }
}
return 0;
3722}

3724VariableSP SymbolFileDWARF::ParseVariableDIE(const SymbolContext &sc,
                                           const DWARFDIE &die,
                                           const lldb::addr_t func_low_pc) {
if (die.GetDWARF() != this)
  return die.GetDWARF()->ParseVariableDIE(sc, die, func_low_pc);

VariableSP var_sp;
if (!die)
  return var_sp;

var_sp = GetDIEToVariable()[die.GetDIE()];
if (var_sp)
  return var_sp; // Already been parsed!

const dw_tag_t tag = die.Tag();
ModuleSP module = GetObjectFile()->GetModule();

if ((tag == DW_TAG_variable) || (tag == DW_TAG_constant) ||
    (tag == DW_TAG_formal_parameter && sc.function)) {
  DWARFAttributes attributes;
  const size_t num_attributes = die.GetAttributes(attributes);
  DWARFDIE spec_die;
  if (num_attributes > 0) {
    const char *name = NULL__null;
    const char *mangled = NULL__null;
    Declaration decl;
    uint32_t i;
    DWARFFormValue type_die_form;
    DWARFExpression location(die.GetCU());
    bool is_external = false;
    bool is_artificial = false;
    bool location_is_const_value_data = false;
    bool has_explicit_location = false;
    DWARFFormValue const_value;
    Variable::RangeList scope_ranges;
    // AccessType accessibility = eAccessNone;

    for (i = 0; i < num_attributes; ++i) {
      dw_attr_t attr = attributes.AttributeAtIndex(i);
      DWARFFormValue form_value;

      if (attributes.ExtractFormValueAtIndex(i, form_value)) {
        switch (attr) {
        case DW_AT_decl_file:
          decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(
              form_value.Unsigned()));
          break;
        case DW_AT_decl_line:
          decl.SetLine(form_value.Unsigned());
          break;
        case DW_AT_decl_column:
          decl.SetColumn(form_value.Unsigned());
          break;
        case DW_AT_name:
          name = form_value.AsCString();
          break;
        case DW_AT_linkage_name:
        case DW_AT_MIPS_linkage_name:
          mangled = form_value.AsCString();
          break;
        case DW_AT_type:
          type_die_form = form_value;
          break;
        case DW_AT_external:
          is_external = form_value.Boolean();
          break;
        case DW_AT_const_value:
          // If we have already found a DW_AT_location attribute, ignore this
          // attribute.
          if (!has_explicit_location) {
            location_is_const_value_data = true;
            // The constant value will be either a block, a data value or a
            // string.
            const DWARFDataExtractor &debug_info_data = get_debug_info_data();
            if (DWARFFormValue::IsBlockForm(form_value.Form())) {
              // Retrieve the value as a block expression.
              uint32_t block_offset =
                  form_value.BlockData() - debug_info_data.GetDataStart();
              uint32_t block_length = form_value.Unsigned();
              location.CopyOpcodeData(module, debug_info_data, block_offset,
                                      block_length);
            } else if (DWARFFormValue::IsDataForm(form_value.Form())) {
              // Retrieve the value as a data expression.
              DWARFFormValue::FixedFormSizes fixed_form_sizes =
                  DWARFFormValue::GetFixedFormSizesForAddressSize(
                      attributes.CompileUnitAtIndex(i)->GetAddressByteSize(),
                      attributes.CompileUnitAtIndex(i)->IsDWARF64());
              uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
              uint32_t data_length =
                  fixed_form_sizes.GetSize(form_value.Form());
              if (data_length == 0) {
                const uint8_t *data_pointer = form_value.BlockData();
                if (data_pointer) {
                  form_value.Unsigned();
                } else if (DWARFFormValue::IsDataForm(form_value.Form())) {
                  // we need to get the byte size of the type later after we
                  // create the variable
                  const_value = form_value;
                }
              } else
                location.CopyOpcodeData(module, debug_info_data, data_offset,
                                        data_length);
            } else {
              // Retrieve the value as a string expression.
              if (form_value.Form() == DW_FORM_strp) {
                DWARFFormValue::FixedFormSizes fixed_form_sizes =
                    DWARFFormValue::GetFixedFormSizesForAddressSize(
                        attributes.CompileUnitAtIndex(i)
                            ->GetAddressByteSize(),
                        attributes.CompileUnitAtIndex(i)->IsDWARF64());
                uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
                uint32_t data_length =
                    fixed_form_sizes.GetSize(form_value.Form());
                location.CopyOpcodeData(module, debug_info_data, data_offset,
                                        data_length);
              } else {
                const char *str = form_value.AsCString();
                uint32_t string_offset =
                    str - (const char *)debug_info_data.GetDataStart();
                uint32_t string_length = strlen(str) + 1;
                location.CopyOpcodeData(module, debug_info_data,
                                        string_offset, string_length);
              }
            }
          }
          break;
        case DW_AT_location: {
          location_is_const_value_data = false;
          has_explicit_location = true;
          if (DWARFFormValue::IsBlockForm(form_value.Form())) {
            const DWARFDataExtractor &debug_info_data = get_debug_info_data();

            uint32_t block_offset =
                form_value.BlockData() - debug_info_data.GetDataStart();
            uint32_t block_length = form_value.Unsigned();
            location.CopyOpcodeData(module, get_debug_info_data(),
                                    block_offset, block_length);
          } else {
            const DWARFDataExtractor &debug_loc_data = get_debug_loc_data();
            const dw_offset_t debug_loc_offset = form_value.Unsigned();

            size_t loc_list_length = DWARFExpression::LocationListSize(
                die.GetCU(), debug_loc_data, debug_loc_offset);
            if (loc_list_length > 0) {
              location.CopyOpcodeData(module, debug_loc_data,
                                      debug_loc_offset, loc_list_length);
              assert(func_low_pc != LLDB_INVALID_ADDRESS)(static_cast <bool> (func_low_pc != (18446744073709551615UL
)) ? void (0) : __assert_fail ("func_low_pc != LLDB_INVALID_ADDRESS"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp"
, 3870, __extension__ __PRETTY_FUNCTION__));
              location.SetLocationListSlide(
                  func_low_pc -
                  attributes.CompileUnitAtIndex(i)->GetBaseAddress());
            }
          }
        } break;
        case DW_AT_specification:
          spec_die = GetDIE(DIERef(form_value));
          break;
        case DW_AT_start_scope: {
          if (form_value.Form() == DW_FORM_sec_offset) {
            DWARFRangeList dwarf_scope_ranges;
            const DWARFDebugRanges *debug_ranges = DebugRanges();
            debug_ranges->FindRanges(die.GetCU()->GetRangesBase(),
                                     form_value.Unsigned(),
                                     dwarf_scope_ranges);

            // All DW_AT_start_scope are relative to the base address of the
            // compile unit. We add the compile unit base address to make
            // sure all the addresses are properly fixed up.
            for (size_t i = 0, count = dwarf_scope_ranges.GetSize();
                 i < count; ++i) {
              const DWARFRangeList::Entry &range =
                  dwarf_scope_ranges.GetEntryRef(i);
              scope_ranges.Append(range.GetRangeBase() +
                                      die.GetCU()->GetBaseAddress(),
                                  range.GetByteSize());
            }
          } else {
            // TODO: Handle the case when DW_AT_start_scope have form
            // constant. The
            // dwarf spec is a bit ambiguous about what is the expected
            // behavior in
            // case the enclosing block have a non coninious address range and
            // the
            // DW_AT_start_scope entry have a form constant.
            GetObjectFile()->GetModule()->ReportWarning(
                "0x%8.8" PRIx64"l" "x"
                ": DW_AT_start_scope has unsupported form type (0x%x)\n",
                die.GetID(), form_value.Form());
          }

          scope_ranges.Sort();
          scope_ranges.CombineConsecutiveRanges();
        } break;
        case DW_AT_artificial:
          is_artificial = form_value.Boolean();
          break;
        case DW_AT_accessibility:
          break; // accessibility =
                 // DW_ACCESS_to_AccessType(form_value.Unsigned()); break;
        case DW_AT_declaration:
        case DW_AT_description:
        case DW_AT_endianity:
        case DW_AT_segment:
        case DW_AT_visibility:
        default:
        case DW_AT_abstract_origin:
        case DW_AT_sibling:
          break;
        }
      }
    }

    const DWARFDIE parent_context_die = GetDeclContextDIEContainingDIE(die);
    const dw_tag_t parent_tag = die.GetParent().Tag();
    bool is_static_member =
        parent_tag == DW_TAG_compile_unit &&
        (parent_context_die.Tag() == DW_TAG_class_type ||
         parent_context_die.Tag() == DW_TAG_structure_type);

    ValueType scope = eValueTypeInvalid;

    const DWARFDIE sc_parent_die = GetParentSymbolContextDIE(die);
    SymbolContextScope *symbol_context_scope = NULL__null;

    bool has_explicit_mangled = mangled != nullptr;
    if (!mangled) {
      // LLDB relies on the mangled name (DW_TAG_linkage_name or
      // DW_AT_MIPS_linkage_name) to
      // generate fully qualified names of global variables with commands like
      // "frame var j".
      // For example, if j were an int variable holding a value 4 and declared
      // in a namespace
      // B which in turn is contained in a namespace A, the command "frame var
      // j" returns
      // "(int) A::B::j = 4". If the compiler does not emit a linkage name, we
      // should be able
      // to generate a fully qualified name from the declaration context.
      if (parent_tag == DW_TAG_compile_unit &&
          Language::LanguageIsCPlusPlus(die.GetLanguage())) {
        DWARFDeclContext decl_ctx;

        die.GetDWARFDeclContext(decl_ctx);
        mangled = decl_ctx.GetQualifiedNameAsConstString().GetCString();
      }
    }

    if (tag == DW_TAG_formal_parameter)
      scope = eValueTypeVariableArgument;
    else {
      // DWARF doesn't specify if a DW_TAG_variable is a local, global
      // or static variable, so we have to do a little digging:
      // 1) DW_AT_linkage_name implies static lifetime (but may be missing)
      // 2) An empty DW_AT_location is an (optimized-out) static lifetime var.
      // 3) DW_AT_location containing a DW_OP_addr implies static lifetime.
      // Clang likes to combine small global variables into the same symbol
      // with locations like: DW_OP_addr(0x1000), DW_OP_constu(2), DW_OP_plus
      // so we need to look through the whole expression.
      bool is_static_lifetime =
          has_explicit_mangled ||
          (has_explicit_location && !location.IsValid());
      // Check if the location has a DW_OP_addr with any address value...
      lldb::addr_t location_DW_OP_addr = LLDB_INVALID_ADDRESS(18446744073709551615UL);
      if (!location_is_const_value_data) {
        bool op_error = false;
        location_DW_OP_addr = location.GetLocation_DW_OP_addr(0, op_error);
        if (op_error) {
          StreamString strm;
          location.DumpLocationForAddress(&strm, eDescriptionLevelFull, 0, 0,
                                          NULL__null);
          GetObjectFile()->GetModule()->ReportError(
              "0x%8.8x: %s has an invalid location: %s", die.GetOffset(),
              die.GetTagAsCString(), strm.GetData());
        }
        if (location_DW_OP_addr != LLDB_INVALID_ADDRESS(18446744073709551615UL))
          is_static_lifetime = true;
      }
      SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();

      if (is_static_lifetime) {
        if (is_external)
          scope = eValueTypeVariableGlobal;
        else
          scope = eValueTypeVariableStatic;

        if (debug_map_symfile) {
          // When leaving the DWARF in the .o files on darwin,
          // when we have a global variable that wasn't initialized,
          // the .o file might not have allocated a virtual
          // address for the global variable. In this case it will
          // have created a symbol for the global variable
          // that is undefined/data and external and the value will
          // be the byte size of the variable. When we do the
          // address map in SymbolFileDWARFDebugMap we rely on
          // having an address, we need to do some magic here
          // so we can get the correct address for our global
          // variable. The address for all of these entries
          // will be zero, and there will be an undefined symbol
          // in this object file, and the executable will have
          // a matching symbol with a good address. So here we
          // dig up the correct address and replace it in the
          // location for the variable, and set the variable's
          // symbol context scope to be that of the main executable
          // so the file address will resolve correctly.
          bool linked_oso_file_addr = false;
          if (is_external && location_DW_OP_addr == 0) {
            // we have a possible uninitialized extern global
            ConstString const_name(mangled ? mangled : name);
            ObjectFile *debug_map_objfile =
                debug_map_symfile->GetObjectFile();
            if (debug_map_objfile) {
              Symtab *debug_map_symtab = debug_map_objfile->GetSymtab();
              if (debug_map_symtab) {
                Symbol *exe_symbol =
                    debug_map_symtab->FindFirstSymbolWithNameAndType(
                        const_name, eSymbolTypeData, Symtab::eDebugYes,
                        Symtab::eVisibilityExtern);
                if (exe_symbol) {
                  if (exe_symbol->ValueIsAddress()) {
                    const addr_t exe_file_addr =
                        exe_symbol->GetAddressRef().GetFileAddress();
                    if (exe_file_addr != LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
                      if (location.Update_DW_OP_addr(exe_file_addr)) {
                        linked_oso_file_addr = true;
                        symbol_context_scope = exe_symbol;
                      }
                    }
                  }
                }
              }
            }
          }

          if (!linked_oso_file_addr) {
            // The DW_OP_addr is not zero, but it contains a .o file address
            // which
            // needs to be linked up correctly.
            const lldb::addr_t exe_file_addr =
                debug_map_symfile->LinkOSOFileAddress(this,
                                                      location_DW_OP_addr);
            if (exe_file_addr != LLDB_INVALID_ADDRESS(18446744073709551615UL)) {
              // Update the file address for this variable
              location.Update_DW_OP_addr(exe_file_addr);
            } else {
              // Variable didn't make it into the final executable
              return var_sp;
            }
          }
        }
      } else {
        if (location_is_const_value_data)
          scope = eValueTypeVariableStatic;
        else {
          scope = eValueTypeVariableLocal;
          if (debug_map_symfile) {
            // We need to check for TLS addresses that we need to fixup
            if (location.ContainsThreadLocalStorage()) {
              location.LinkThreadLocalStorage(
                  debug_map_symfile->GetObjectFile()->GetModule(),
                  [this, debug_map_symfile](
                      lldb::addr_t unlinked_file_addr) -> lldb::addr_t {
                    return debug_map_symfile->LinkOSOFileAddress(
                        this, unlinked_file_addr);
                  });
              scope = eValueTypeVariableThreadLocal;
            }
          }
        }
      }
    }

    if (symbol_context_scope == NULL__null) {
      switch (parent_tag) {
      case DW_TAG_subprogram:
      case DW_TAG_inlined_subroutine:
      case DW_TAG_lexical_block:
        if (sc.function) {
          symbol_context_scope = sc.function->GetBlock(true).FindBlockByID(
              sc_parent_die.GetID());
          if (symbol_context_scope == NULL__null)
            symbol_context_scope = sc.function;
        }
        break;

      default:
        symbol_context_scope = sc.comp_unit;
        break;
      }
    }

    if (symbol_context_scope) {
      SymbolFileTypeSP type_sp(
          new SymbolFileType(*this, DIERef(type_die_form).GetUID(this)));

      if (const_value.Form() && type_sp && type_sp->GetType())
        location.CopyOpcodeData(const_value.Unsigned(),
                                type_sp->GetType()->GetByteSize(),
                                die.GetCU()->GetAddressByteSize());

      var_sp.reset(new Variable(die.GetID(), name, mangled, type_sp, scope,
                                symbol_context_scope, scope_ranges, &decl,
                                location, is_external, is_artificial,
                                is_static_member));

      var_sp->SetLocationIsConstantValueData(location_is_const_value_data);
    } else {
      // Not ready to parse this variable yet. It might be a global
      // or static variable that is in a function scope and the function
      // in the symbol context wasn't filled in yet
      return var_sp;
    }
  }
  // Cache var_sp even if NULL (the variable was just a specification or
  // was missing vital information to be able to be displayed in the debugger
  // (missing location due to optimization, etc)) so we don't re-parse
  // this DIE over and over later...
  GetDIEToVariable()[die.GetDIE()] = var_sp;
  if (spec_die)
    GetDIEToVariable()[spec_die.GetDIE()] = var_sp;
}
return var_sp;
4143}

4145DWARFDIE
4146SymbolFileDWARF::FindBlockContainingSpecification(
  const DIERef &func_die_ref, dw_offset_t spec_block_die_offset) {
// Give the concrete function die specified by "func_die_offset", find the
// concrete block whose DW_AT_specification or DW_AT_abstract_origin points
// to "spec_block_die_offset"
return FindBlockContainingSpecification(DebugInfo()->GetDIE(func_die_ref),
                                        spec_block_die_offset);
4153}

4155DWARFDIE
4156SymbolFileDWARF::FindBlockContainingSpecification(
  const DWARFDIE &die, dw_offset_t spec_block_die_offset) {
if (die) {
  switch (die.Tag()) {
  case DW_TAG_subprogram:
  case DW_TAG_inlined_subroutine:
  case DW_TAG_lexical_block: {
    if (die.GetAttributeValueAsReference(
            DW_AT_specification, DW_INVALID_OFFSET(~(dw_offset_t)0)) == spec_block_die_offset)
      return die;

    if (die.GetAttributeValueAsReference(DW_AT_abstract_origin,
                                         DW_INVALID_OFFSET(~(dw_offset_t)0)) ==
        spec_block_die_offset)
      return die;
  } break;
  }

  // Give the concrete function die specified by "func_die_offset", find the
  // concrete block whose DW_AT_specification or DW_AT_abstract_origin points
  // to "spec_block_die_offset"
  for (DWARFDIE child_die = die.GetFirstChild(); child_die;
       child_die = child_die.GetSibling()) {
    DWARFDIE result_die =
        FindBlockContainingSpecification(child_die, spec_block_die_offset);
    if (result_die)
      return result_die;
  }
}

return DWARFDIE();
4187}

4189size_t SymbolFileDWARF::ParseVariables(const SymbolContext &sc,
                                     const DWARFDIE &orig_die,
                                     const lldb::addr_t func_low_pc,
                                     bool parse_siblings, bool parse_children,
                                     VariableList *cc_variable_list) {
if (!orig_die)
  return 0;

VariableListSP variable_list_sp;

size_t vars_added = 0;
DWARFDIE die = orig_die;
while (die) {
  dw_tag_t tag = die.Tag();

  // Check to see if we have already parsed this variable or constant?
  VariableSP var_sp = GetDIEToVariable()[die.GetDIE()];
  if (var_sp) {
    if (cc_variable_list)
      cc_variable_list->AddVariableIfUnique(var_sp);
  } else {
    // We haven't already parsed it, lets do that now.
    if ((tag == DW_TAG_variable) || (tag == DW_TAG_constant) ||
        (tag == DW_TAG_formal_parameter && sc.function)) {
      if (variable_list_sp.get() == NULL__null) {
        DWARFDIE sc_parent_die = GetParentSymbolContextDIE(orig_die);
        dw_tag_t parent_tag = sc_parent_die.Tag();
        switch (parent_tag) {
        case DW_TAG_compile_unit:
          if (sc.comp_unit != NULL__null) {
            variable_list_sp = sc.comp_unit->GetVariableList(false);
            if (variable_list_sp.get() == NULL__null) {
              variable_list_sp.reset(new VariableList());
              sc.comp_unit->SetVariableList(variable_list_sp);
            }
          } else {
            GetObjectFile()->GetModule()->ReportError(
                "parent 0x%8.8" PRIx64"l" "x" " %s with no valid compile unit in "
                                       "symbol context for 0x%8.8" PRIx64"l" "x"
                " %s.\n",
                sc_parent_die.GetID(), sc_parent_die.GetTagAsCString(),
                orig_die.GetID(), orig_die.GetTagAsCString());
          }
          break;

        case DW_TAG_subprogram:
        case DW_TAG_inlined_subroutine:
        case DW_TAG_lexical_block:
          if (sc.function != NULL__null) {
            // Check to see if we already have parsed the variables for the
            // given scope

            Block *block = sc.function->GetBlock(true).FindBlockByID(
                sc_parent_die.GetID());
            if (block == NULL__null) {
              // This must be a specification or abstract origin with
              // a concrete block counterpart in the current function. We need
              // to find the concrete block so we can correctly add the
              // variable to it
              const DWARFDIE concrete_block_die =
                  FindBlockContainingSpecification(
                      DIERef(sc.function->GetID(), this),
                      sc_parent_die.GetOffset());
              if (concrete_block_die)
                block = sc.function->GetBlock(true).FindBlockByID(
                    concrete_block_die.GetID());
            }

            if (block != NULL__null) {
              const bool can_create = false;
              variable_list_sp = block->GetBlockVariableList(can_create);
              if (variable_list_sp.get() == NULL__null) {
                variable_list_sp.reset(new VariableList());
                block->SetVariableList(variable_list_sp);
              }
            }
          }
          break;

        default:
          GetObjectFile()->GetModule()->ReportError(
              "didn't find appropriate parent DIE for variable list for "
              "0x%8.8" PRIx64"l" "x" " %s.\n",
              orig_die.GetID(), orig_die.GetTagAsCString());
          break;
        }
      }

      if (variable_list_sp) {
        VariableSP var_sp(ParseVariableDIE(sc, die, func_low_pc));
        if (var_sp) {
          variable_list_sp->AddVariableIfUnique(var_sp);
          if (cc_variable_list)
            cc_variable_list->AddVariableIfUnique(var_sp);
          ++vars_added;
        }
      }
    }
  }

  bool skip_children = (sc.function == NULL__null && tag == DW_TAG_subprogram);

  if (!skip_children && parse_children && die.HasChildren()) {
    vars_added += ParseVariables(sc, die.GetFirstChild(), func_low_pc, true,
                                 true, cc_variable_list);
  }

  if (parse_siblings)
    die = die.GetSibling();
  else
    die.Clear();
}
return vars_added;
4302}

4304//------------------------------------------------------------------
4305// PluginInterface protocol
4306//------------------------------------------------------------------
4307ConstString SymbolFileDWARF::GetPluginName() { return GetPluginNameStatic(); }

4309uint32_t SymbolFileDWARF::GetPluginVersion() { return 1; }

4311void SymbolFileDWARF::DumpIndexes() {
StreamFile s(stdoutstdout, false);

s.Printf(
    "DWARF index for (%s) '%s':",
    GetObjectFile()->GetModule()->GetArchitecture().GetArchitectureName(),
    GetObjectFile()->GetFileSpec().GetPath().c_str());
s.Printf("\nFunction basenames:\n");
m_function_basename_index.Dump(&s);
s.Printf("\nFunction fullnames:\n");
m_function_fullname_index.Dump(&s);
s.Printf("\nFunction methods:\n");
m_function_method_index.Dump(&s);
s.Printf("\nFunction selectors:\n");
m_function_selector_index.Dump(&s);
s.Printf("\nObjective C class selectors:\n");
m_objc_class_selectors_index.Dump(&s);
s.Printf("\nGlobals and statics:\n");
m_global_index.Dump(&s);
s.Printf("\nTypes:\n");
m_type_index.Dump(&s);
s.Printf("\nNamespaces:\n");
m_namespace_index.Dump(&s);
4334}

4336SymbolFileDWARFDebugMap *SymbolFileDWARF::GetDebugMapSymfile() {
if (m_debug_map_symfile == NULL__null && !m_debug_map_module_wp.expired()) {
  lldb::ModuleSP module_sp(m_debug_map_module_wp.lock());
  if (module_sp) {
    SymbolVendor *sym_vendor = module_sp->GetSymbolVendor();
    if (sym_vendor)
      m_debug_map_symfile =
          (SymbolFileDWARFDebugMap *)sym_vendor->GetSymbolFile();
  }
}
return m_debug_map_symfile;
4347}

4349DWARFExpression::LocationListFormat
4350SymbolFileDWARF::GetLocationListFormat() const {
return DWARFExpression::RegularLocationList;
4352}

4354SymbolFileDWARFDwp *SymbolFileDWARF::GetDwpSymbolFile() {
llvm::call_once(m_dwp_symfile_once_flag, [this]() {
  ModuleSpec module_spec;
  module_spec.GetFileSpec() = m_obj_file->GetFileSpec();
  module_spec.GetSymbolFileSpec() =
      FileSpec(m_obj_file->GetFileSpec().GetPath() + ".dwp", false);
  FileSpec dwp_filespec = Symbols::LocateExecutableSymbolFile(module_spec);
  if (dwp_filespec.Exists()) {
    m_dwp_symfile = SymbolFileDWARFDwp::Create(GetObjectFile()->GetModule(),
                                               dwp_filespec);
  }
});
return m_dwp_symfile.get();
4367}

←

/usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/bits/shared_ptr.h

→

1// shared_ptr and weak_ptr implementation -*- C++ -*-

3// Copyright (C) 2007-2017 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25// GCC Note: Based on files from version 1.32.0 of the Boost library.

27//  shared_count.hpp
28//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.

30//  shared_ptr.hpp
31//  Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
32//  Copyright (C) 2001, 2002, 2003 Peter Dimov

34//  weak_ptr.hpp
35//  Copyright (C) 2001, 2002, 2003 Peter Dimov

37//  enable_shared_from_this.hpp
38//  Copyright (C) 2002 Peter Dimov

40// Distributed under the Boost Software License, Version 1.0. (See
41// accompanying file LICENSE_1_0.txt or copy at
42// http://www.boost.org/LICENSE_1_0.txt)

44/** @file
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{memory}
*/

49#ifndef _SHARED_PTR_H1
50#define _SHARED_PTR_H1 1

52#include <bits/shared_ptr_base.h>

54namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
55{
56_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup pointer_abstractions
 * @{
 */

/// 20.7.2.2.11 shared_ptr I/O
template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
  inline std::basic_ostream<_Ch, _Tr>&
  operator<<(std::basic_ostream<_Ch, _Tr>& __os,
      const __shared_ptr<_Tp, _Lp>& __p)
  {
    __os << __p.get();
    return __os;
  }

/// 20.7.2.2.10 shared_ptr get_deleter
template<typename _Del, typename _Tp, _Lock_policy _Lp>
  inline _Del*
  get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept
  {
78#if __cpp_rtti199711
    return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
80#else
    return 0;
82#endif
  }


/**
 *  @brief  A smart pointer with reference-counted copy semantics.
 *
 *  The object pointed to is deleted when the last shared_ptr pointing to
 *  it is destroyed or reset.
*/
template<typename _Tp>
  class shared_ptr : public __shared_ptr<_Tp>
  {
    template<typename... _Args>
using _Constructible = typename enable_if<
 is_constructible<__shared_ptr<_Tp>, _Args...>::value
>::type;

    template<typename _Arg>
using _Assignable = typename enable_if<
 is_assignable<__shared_ptr<_Tp>&, _Arg>::value, shared_ptr&
>::type;

  public:

    using element_type = typename __shared_ptr<_Tp>::element_type;

109#if __cplusplus201103L > 201402L
110# define __cpp_lib_shared_ptr_weak_type 201606
    using weak_type = weak_ptr<_Tp>;
112#endif
    /**
     *  @brief  Construct an empty %shared_ptr.
     *  @post   use_count()==0 && get()==0
     */
    constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { }

    shared_ptr(const shared_ptr&) noexcept = default;

    /**
     *  @brief  Construct a %shared_ptr that owns the pointer @a __p.
     *  @param  __p  A pointer that is convertible to element_type*.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @c delete @a __p is called.
     */
    template<typename _Yp, typename = _Constructible<_Yp*>>
explicit
shared_ptr(_Yp* __p) : __shared_ptr<_Tp>(__p) { }

    /**
     *  @brief  Construct a %shared_ptr that owns the pointer @a __p
     *          and the deleter @a __d.
     *  @param  __p  A pointer.
     *  @param  __d  A deleter.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
     *
     *  Requirements: _Deleter's copy constructor and destructor must
     *  not throw
     *
     *  __shared_ptr will release __p by calling __d(__p)
     */
    template<typename _Yp, typename _Deleter,
      typename = _Constructible<_Yp*, _Deleter>>
shared_ptr(_Yp* __p, _Deleter __d)
      : __shared_ptr<_Tp>(__p, std::move(__d)) { }

    /**
     *  @brief  Construct a %shared_ptr that owns a null pointer
     *          and the deleter @a __d.
     *  @param  __p  A null pointer constant.
     *  @param  __d  A deleter.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
     *
     *  Requirements: _Deleter's copy constructor and destructor must
     *  not throw
     *
     *  The last owner will call __d(__p)
     */
    template<typename _Deleter>
shared_ptr(nullptr_t __p, _Deleter __d)
      : __shared_ptr<_Tp>(__p, std::move(__d)) { }

    /**
     *  @brief  Construct a %shared_ptr that owns the pointer @a __p
     *          and the deleter @a __d.
     *  @param  __p  A pointer.
     *  @param  __d  A deleter.
     *  @param  __a  An allocator.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
     *
     *  Requirements: _Deleter's copy constructor and destructor must
     *  not throw _Alloc's copy constructor and destructor must not
     *  throw.
     *
     *  __shared_ptr will release __p by calling __d(__p)
     */
    template<typename _Yp, typename _Deleter, typename _Alloc,
      typename = _Constructible<_Yp*, _Deleter, _Alloc>>
shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
: __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }

    /**
     *  @brief  Construct a %shared_ptr that owns a null pointer
     *          and the deleter @a __d.
     *  @param  __p  A null pointer constant.
     *  @param  __d  A deleter.
     *  @param  __a  An allocator.
     *  @post   use_count() == 1 && get() == __p
     *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
     *
     *  Requirements: _Deleter's copy constructor and destructor must
     *  not throw _Alloc's copy constructor and destructor must not
     *  throw.
     *
     *  The last owner will call __d(__p)
     */
    template<typename _Deleter, typename _Alloc>
shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
: __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }

    // Aliasing constructor

    /**
     *  @brief  Constructs a %shared_ptr instance that stores @a __p
     *          and shares ownership with @a __r.
     *  @param  __r  A %shared_ptr.
     *  @param  __p  A pointer that will remain valid while @a *__r is valid.
     *  @post   get() == __p && use_count() == __r.use_count()
     *
     *  This can be used to construct a @c shared_ptr to a sub-object
     *  of an object managed by an existing @c shared_ptr.
     *
     * @code
     * shared_ptr< pair<int,int> > pii(new pair<int,int>());
     * shared_ptr<int> pi(pii, &pii->first);
     * assert(pii.use_count() == 2);
     * @endcode
     */
    template<typename _Yp>
shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept
: __shared_ptr<_Tp>(__r, __p) { }

    /**
     *  @brief  If @a __r is empty, constructs an empty %shared_ptr;
     *          otherwise construct a %shared_ptr that shares ownership
     *          with @a __r.
     *  @param  __r  A %shared_ptr.
     *  @post   get() == __r.get() && use_count() == __r.use_count()
     */
    template<typename _Yp,
      typename = _Constructible<const shared_ptr<_Yp>&>>
shared_ptr(const shared_ptr<_Yp>& __r) noexcept
      : __shared_ptr<_Tp>(__r) { }

    /**
     *  @brief  Move-constructs a %shared_ptr instance from @a __r.
     *  @param  __r  A %shared_ptr rvalue.
     *  @post   *this contains the old value of @a __r, @a __r is empty.
     */
    shared_ptr(shared_ptr&& __r) noexcept
    : __shared_ptr<_Tp>(std::move(__r)) { }

    /**
     *  @brief  Move-constructs a %shared_ptr instance from @a __r.
     *  @param  __r  A %shared_ptr rvalue.
     *  @post   *this contains the old value of @a __r, @a __r is empty.
     */
    template<typename _Yp, typename = _Constructible<shared_ptr<_Yp>>>
shared_ptr(shared_ptr<_Yp>&& __r) noexcept
: __shared_ptr<_Tp>(std::move(__r)) { }

    /**
     *  @brief  Constructs a %shared_ptr that shares ownership with @a __r
     *          and stores a copy of the pointer stored in @a __r.
     *  @param  __r  A weak_ptr.
     *  @post   use_count() == __r.use_count()
     *  @throw  bad_weak_ptr when __r.expired(),
     *          in which case the constructor has no effect.
     */
    template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
explicit shared_ptr(const weak_ptr<_Yp>& __r)
: __shared_ptr<_Tp>(__r) { }

268#if _GLIBCXX_USE_DEPRECATED1
    template<typename _Yp, typename = _Constructible<auto_ptr<_Yp>>>
shared_ptr(auto_ptr<_Yp>&& __r);
271#endif

    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 2399. shared_ptr's constructor from unique_ptr should be constrained
    template<typename _Yp, typename _Del,
      typename = _Constructible<unique_ptr<_Yp, _Del>>>
shared_ptr(unique_ptr<_Yp, _Del>&& __r)
: __shared_ptr<_Tp>(std::move(__r)) { }

280#if __cplusplus201103L <= 201402L && _GLIBCXX_USE_DEPRECATED1
    // This non-standard constructor exists to support conversions that
    // were possible in C++11 and C++14 but are ill-formed in C++17.
    // If an exception is thrown this constructor has no effect.
    template<typename _Yp, typename _Del,
_Constructible<unique_ptr<_Yp, _Del>, __sp_array_delete>* = 0>
shared_ptr(unique_ptr<_Yp, _Del>&& __r)
: __shared_ptr<_Tp>(std::move(__r), __sp_array_delete()) { }
288#endif

    /**
     *  @brief  Construct an empty %shared_ptr.
     *  @post   use_count() == 0 && get() == nullptr
     */
    constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }

    shared_ptr& operator=(const shared_ptr&) noexcept = default;
36
←
Calling defaulted copy assignment operator for '__shared_ptr'→
51
←
Returning; memory was released→
64
←
Calling defaulted copy assignment operator for '__shared_ptr'→

    template<typename _Yp>
_Assignable<const shared_ptr<_Yp>&>
operator=(const shared_ptr<_Yp>& __r) noexcept
{
 this->__shared_ptr<_Tp>::operator=(__r);
 return *this;
}

306#if _GLIBCXX_USE_DEPRECATED1
    template<typename _Yp>
_Assignable<auto_ptr<_Yp>>
operator=(auto_ptr<_Yp>&& __r)
{
 this->__shared_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}
314#endif

    shared_ptr&
    operator=(shared_ptr&& __r) noexcept
    {
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
    }

    template<class _Yp>
_Assignable<shared_ptr<_Yp>>
operator=(shared_ptr<_Yp>&& __r) noexcept
{
 this->__shared_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}

    template<typename _Yp, typename _Del>
_Assignable<unique_ptr<_Yp, _Del>>
operator=(unique_ptr<_Yp, _Del>&& __r)
{
 this->__shared_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}

  private:
    // This constructor is non-standard, it is used by allocate_shared.
    template<typename _Alloc, typename... _Args>
shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
   _Args&&... __args)
: __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
{ }

    template<typename _Yp, typename _Alloc, typename... _Args>
friend shared_ptr<_Yp>
allocate_shared(const _Alloc& __a, _Args&&... __args);

    // This constructor is non-standard, it is used by weak_ptr::lock().
    shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)
    : __shared_ptr<_Tp>(__r, std::nothrow) { }

    friend class weak_ptr<_Tp>;
  };

358#if __cpp_deduction_guides >= 201606
template<typename _Tp>
  shared_ptr(weak_ptr<_Tp>) ->  shared_ptr<_Tp>;
template<typename _Tp, typename _Del>
  shared_ptr(unique_ptr<_Tp, _Del>) ->  shared_ptr<_Tp>;
363#endif

// 20.7.2.2.7 shared_ptr comparisons
template<typename _Tp, typename _Up>
  inline bool
  operator==(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return __a.get() == __b.get(); }

template<typename _Tp>
  inline bool
  operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return !__a; }

template<typename _Tp>
  inline bool
  operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return !__a; }

template<typename _Tp, typename _Up>
  inline bool
  operator!=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return __a.get() != __b.get(); }

template<typename _Tp>
  inline bool
  operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return (bool)__a; }

template<typename _Tp>
  inline bool
  operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return (bool)__a; }

template<typename _Tp, typename _Up>
  inline bool
  operator<(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  {
    using _Tp_elt = typename shared_ptr<_Tp>::element_type;
    using _Up_elt = typename shared_ptr<_Up>::element_type;
    using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type;
    return less<_Vp>()(__a.get(), __b.get());
  }

template<typename _Tp>
  inline bool
  operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  {
    using _Tp_elt = typename shared_ptr<_Tp>::element_type;
    return less<_Tp_elt*>()(__a.get(), nullptr);
  }

template<typename _Tp>
  inline bool
  operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  {
    using _Tp_elt = typename shared_ptr<_Tp>::element_type;
    return less<_Tp_elt*>()(nullptr, __a.get());
  }

template<typename _Tp, typename _Up>
  inline bool
  operator<=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return !(__b < __a); }

template<typename _Tp>
  inline bool
  operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return !(nullptr < __a); }

template<typename _Tp>
  inline bool
  operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return !(__a < nullptr); }

template<typename _Tp, typename _Up>
  inline bool
  operator>(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return (__b < __a); }

template<typename _Tp>
  inline bool
  operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return nullptr < __a; }

template<typename _Tp>
  inline bool
  operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return __a < nullptr; }

template<typename _Tp, typename _Up>
  inline bool
  operator>=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
  { return !(__a < __b); }

template<typename _Tp>
  inline bool
  operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
  { return !(__a < nullptr); }

template<typename _Tp>
  inline bool
  operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
  { return !(nullptr < __a); }

template<typename _Tp>
  struct less<shared_ptr<_Tp>> : public _Sp_less<shared_ptr<_Tp>>
  { };

// 20.7.2.2.8 shared_ptr specialized algorithms.
template<typename _Tp>
  inline void
  swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept
  { __a.swap(__b); }

// 20.7.2.2.9 shared_ptr casts.
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  static_pointer_cast(const shared_ptr<_Up>& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get()));
  }

template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  const_pointer_cast(const shared_ptr<_Up>& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get()));
  }

template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  dynamic_pointer_cast(const shared_ptr<_Up>& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
return _Sp(__r, __p);
    return _Sp();
  }

504#if __cplusplus201103L > 201402L
template<typename _Tp, typename _Up>
  inline shared_ptr<_Tp>
  reinterpret_pointer_cast(const shared_ptr<_Up>& __r) noexcept
  {
    using _Sp = shared_ptr<_Tp>;
    return _Sp(__r, reinterpret_cast<typename _Sp::element_type*>(__r.get()));
  }
512#endif

/**
 *  @brief  A smart pointer with weak semantics.
 *
 *  With forwarding constructors and assignment operators.
 */
template<typename _Tp>
  class weak_ptr : public __weak_ptr<_Tp>
  {
    template<typename _Arg>
using _Constructible = typename enable_if<
 is_constructible<__weak_ptr<_Tp>, _Arg>::value
>::type;

    template<typename _Arg>
using _Assignable = typename enable_if<
 is_assignable<__weak_ptr<_Tp>&, _Arg>::value, weak_ptr&
>::type;

  public:
    constexpr weak_ptr() noexcept = default;

    template<typename _Yp,
      typename = _Constructible<const shared_ptr<_Yp>&>>
weak_ptr(const shared_ptr<_Yp>& __r) noexcept
: __weak_ptr<_Tp>(__r) { }

    weak_ptr(const weak_ptr&) noexcept = default;

    template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
weak_ptr(const weak_ptr<_Yp>& __r) noexcept
: __weak_ptr<_Tp>(__r) { }

    weak_ptr(weak_ptr&&) noexcept = default;

    template<typename _Yp, typename = _Constructible<weak_ptr<_Yp>>>
weak_ptr(weak_ptr<_Yp>&& __r) noexcept
: __weak_ptr<_Tp>(std::move(__r)) { }

    weak_ptr&
    operator=(const weak_ptr& __r) noexcept = default;

    template<typename _Yp>
_Assignable<const weak_ptr<_Yp>&>
operator=(const weak_ptr<_Yp>& __r) noexcept
{
 this->__weak_ptr<_Tp>::operator=(__r);
 return *this;
}

    template<typename _Yp>
_Assignable<const shared_ptr<_Yp>&>
operator=(const shared_ptr<_Yp>& __r) noexcept
{
 this->__weak_ptr<_Tp>::operator=(__r);
 return *this;
}

    weak_ptr&
    operator=(weak_ptr&& __r) noexcept = default;

    template<typename _Yp>
_Assignable<weak_ptr<_Yp>>
operator=(weak_ptr<_Yp>&& __r) noexcept
{
 this->__weak_ptr<_Tp>::operator=(std::move(__r));
 return *this;
}

    shared_ptr<_Tp>
    lock() const noexcept
    { return shared_ptr<_Tp>(*this, std::nothrow); }
  };

587#if __cpp_deduction_guides >= 201606
template<typename _Tp>
  weak_ptr(shared_ptr<_Tp>) ->  weak_ptr<_Tp>;
590#endif

// 20.7.2.3.6 weak_ptr specialized algorithms.
template<typename _Tp>
  inline void
  swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept
  { __a.swap(__b); }


/// Primary template owner_less
template<typename _Tp = void>
  struct owner_less;

/// Void specialization of owner_less
template<>
  struct owner_less<void> : _Sp_owner_less<void, void>
  { };

/// Partial specialization of owner_less for shared_ptr.
template<typename _Tp>
  struct owner_less<shared_ptr<_Tp>>
  : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
  { };

/// Partial specialization of owner_less for weak_ptr.
template<typename _Tp>
  struct owner_less<weak_ptr<_Tp>>
  : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
  { };

/**
 *  @brief Base class allowing use of member function shared_from_this.
 */
template<typename _Tp>
  class enable_shared_from_this
  {
  protected:
    constexpr enable_shared_from_this() noexcept { }

    enable_shared_from_this(const enable_shared_from_this&) noexcept { }

    enable_shared_from_this&
    operator=(const enable_shared_from_this&) noexcept
    { return *this; }

    ~enable_shared_from_this() { }

  public:
    shared_ptr<_Tp>
    shared_from_this()
    { return shared_ptr<_Tp>(this->_M_weak_this); }

    shared_ptr<const _Tp>
    shared_from_this() const
    { return shared_ptr<const _Tp>(this->_M_weak_this); }

646#if __cplusplus201103L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
647#define __cpp_lib_enable_shared_from_this 201603
    weak_ptr<_Tp>
    weak_from_this() noexcept
    { return this->_M_weak_this; }

    weak_ptr<const _Tp>
    weak_from_this() const noexcept
    { return this->_M_weak_this; }
655#endif

  private:
    template<typename _Tp1>
void
_M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept
{ _M_weak_this._M_assign(__p, __n); }

    // Found by ADL when this is an associated class.
    friend const enable_shared_from_this*
    __enable_shared_from_this_base(const __shared_count<>&,
		     const enable_shared_from_this* __p)
    { return __p; }

    template<typename, _Lock_policy>
friend class __shared_ptr;

    mutable weak_ptr<_Tp>  _M_weak_this;
  };

/**
 *  @brief  Create an object that is owned by a shared_ptr.
 *  @param  __a     An allocator.
 *  @param  __args  Arguments for the @a _Tp object's constructor.
 *  @return A shared_ptr that owns the newly created object.
 *  @throw  An exception thrown from @a _Alloc::allocate or from the
 *          constructor of @a _Tp.
 *
 *  A copy of @a __a will be used to allocate memory for the shared_ptr
 *  and the new object.
 */
template<typename _Tp, typename _Alloc, typename... _Args>
  inline shared_ptr<_Tp>
  allocate_shared(const _Alloc& __a, _Args&&... __args)
  {
    return shared_ptr<_Tp>(_Sp_make_shared_tag(), __a,
	     std::forward<_Args>(__args)...);
  }

/**
 *  @brief  Create an object that is owned by a shared_ptr.
 *  @param  __args  Arguments for the @a _Tp object's constructor.
 *  @return A shared_ptr that owns the newly created object.
 *  @throw  std::bad_alloc, or an exception thrown from the
 *          constructor of @a _Tp.
 */
template<typename _Tp, typename... _Args>
  inline shared_ptr<_Tp>
  make_shared(_Args&&... __args)
  {
    typedef typename std::remove_const<_Tp>::type _Tp_nc;
    return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
		       std::forward<_Args>(__args)...);
  }

/// std::hash specialization for shared_ptr.
template<typename _Tp>
  struct hash<shared_ptr<_Tp>>
  : public __hash_base<size_t, shared_ptr<_Tp>>
  {
    size_t
    operator()(const shared_ptr<_Tp>& __s) const noexcept
    {
return std::hash<typename shared_ptr<_Tp>::element_type*>()(__s.get());
    }
  };

// @} group pointer_abstractions

724_GLIBCXX_END_NAMESPACE_VERSION
725} // namespace

727#endif // _SHARED_PTR_H

←

/usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/bits/shared_ptr_base.h

→

1// shared_ptr and weak_ptr implementation details -*- C++ -*-

3// Copyright (C) 2007-2017 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25// GCC Note: Based on files from version 1.32.0 of the Boost library.

27//  shared_count.hpp
28//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.

30//  shared_ptr.hpp
31//  Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
32//  Copyright (C) 2001, 2002, 2003 Peter Dimov

34//  weak_ptr.hpp
35//  Copyright (C) 2001, 2002, 2003 Peter Dimov

37//  enable_shared_from_this.hpp
38//  Copyright (C) 2002 Peter Dimov

40// Distributed under the Boost Software License, Version 1.0. (See
41// accompanying file LICENSE_1_0.txt or copy at
42// http://www.boost.org/LICENSE_1_0.txt)

44/** @file bits/shared_ptr_base.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{memory}
*/

49#ifndef _SHARED_PTR_BASE_H1
50#define _SHARED_PTR_BASE_H1 1

52#if __cpp_rtti199711
53# include <typeinfo>
54#endif
55#include <bits/allocated_ptr.h>
56#include <bits/refwrap.h>
57#include <bits/stl_function.h>
58#include <ext/aligned_buffer.h>

60namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
61{
62_GLIBCXX_BEGIN_NAMESPACE_VERSION

64#if _GLIBCXX_USE_DEPRECATED1
template<typename> class auto_ptr;
66#endif

/**
 *  @brief  Exception possibly thrown by @c shared_ptr.
 *  @ingroup exceptions
 */
class bad_weak_ptr : public std::exception
{
public:
  virtual char const* what() const noexcept;

  virtual ~bad_weak_ptr() noexcept;
};

// Substitute for bad_weak_ptr object in the case of -fno-exceptions.
inline void
__throw_bad_weak_ptr()
{ _GLIBCXX_THROW_OR_ABORT(bad_weak_ptr())(__builtin_abort()); }

using __gnu_cxx::_Lock_policy;
using __gnu_cxx::__default_lock_policy;
using __gnu_cxx::_S_single;
using __gnu_cxx::_S_mutex;
using __gnu_cxx::_S_atomic;

// Empty helper class except when the template argument is _S_mutex.
template<_Lock_policy _Lp>
  class _Mutex_base
  {
  protected:
    // The atomic policy uses fully-fenced builtins, single doesn't care.
    enum { _S_need_barriers = 0 };
  };

template<>
  class _Mutex_base<_S_mutex>
  : public __gnu_cxx::__mutex
  {
  protected:
    // This policy is used when atomic builtins are not available.
    // The replacement atomic operations might not have the necessary
    // memory barriers.
    enum { _S_need_barriers = 1 };
  };

template<_Lock_policy _Lp = __default_lock_policy>
  class _Sp_counted_base
  : public _Mutex_base<_Lp>
  {
  public:
    _Sp_counted_base() noexcept
    : _M_use_count(1), _M_weak_count(1) { }

    virtual
    ~_Sp_counted_base() noexcept
    { }

    // Called when _M_use_count drops to zero, to release the resources
    // managed by *this.
    virtual void
    _M_dispose() noexcept = 0;

    // Called when _M_weak_count drops to zero.
    virtual void
    _M_destroy() noexcept
    { delete this; }
47
←
Memory is released→

    virtual void*
    _M_get_deleter(const std::type_info&) noexcept = 0;

    void
    _M_add_ref_copy()
    { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }

    void
    _M_add_ref_lock();

    bool
    _M_add_ref_lock_nothrow();

    void
    _M_release() noexcept
    {
      // Be race-detector-friendly.  For more info see bits/c++config.
      _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
42
←
Assuming the condition is true→
43
←
Taking true branch→
70
←
Calling '__exchange_and_add_dispatch'→
 {
          _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
   _M_dispose();
   // There must be a memory barrier between dispose() and destroy()
   // to ensure that the effects of dispose() are observed in the
   // thread that runs destroy().
   // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html
   if (_Mutex_base<_Lp>::_S_need_barriers)
44
←
Taking false branch→
     {
__atomic_thread_fence (__ATOMIC_ACQ_REL4);
     }

          // Be race-detector-friendly.  For more info see bits/c++config.
          _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
   if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
45
←
Taking true branch→
				       -1) == 1)
            {
              _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
       _M_destroy();
46
←
Calling '_Sp_counted_base::_M_destroy'→
48
←
Returning; memory was released→
            }
 }
    }

    void
    _M_weak_add_ref() noexcept
    { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }

    void
    _M_weak_release() noexcept
    {
      // Be race-detector-friendly. For more info see bits/c++config.
      _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
 {
          _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
   if (_Mutex_base<_Lp>::_S_need_barriers)
     {
       // See _M_release(),
       // destroy() must observe results of dispose()
__atomic_thread_fence (__ATOMIC_ACQ_REL4);
     }
   _M_destroy();
 }
    }

    long
    _M_get_use_count() const noexcept
    {
      // No memory barrier is used here so there is no synchronization
      // with other threads.
      return __atomic_load_n(&_M_use_count, __ATOMIC_RELAXED0);
    }

  private:
    _Sp_counted_base(_Sp_counted_base const&) = delete;
    _Sp_counted_base& operator=(_Sp_counted_base const&) = delete;

    _Atomic_word  _M_use_count;     // #shared
    _Atomic_word  _M_weak_count;    // #weak + (#shared != 0)
  };

template<>
  inline void
  _Sp_counted_base<_S_single>::
  _M_add_ref_lock()
  {
    if (_M_use_count == 0)
__throw_bad_weak_ptr();
    ++_M_use_count;
  }

template<>
  inline void
  _Sp_counted_base<_S_mutex>::
  _M_add_ref_lock()
  {
    __gnu_cxx::__scoped_lock sentry(*this);
    if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
{
 _M_use_count = 0;
 __throw_bad_weak_ptr();
}
  }

template<>
  inline void
  _Sp_counted_base<_S_atomic>::
  _M_add_ref_lock()
  {
    // Perform lock-free add-if-not-zero operation.
    _Atomic_word __count = _M_get_use_count();
    do
{
 if (__count == 0)
   __throw_bad_weak_ptr();
 // Replace the current counter value with the old value + 1, as
 // long as it's not changed meanwhile.
}
    while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
			  true, __ATOMIC_ACQ_REL4,
			  __ATOMIC_RELAXED0));
  }

template<>
  inline bool
  _Sp_counted_base<_S_single>::
  _M_add_ref_lock_nothrow()
  {
    if (_M_use_count == 0)
return false;
    ++_M_use_count;
    return true;
  }

template<>
  inline bool
  _Sp_counted_base<_S_mutex>::
  _M_add_ref_lock_nothrow()
  {
    __gnu_cxx::__scoped_lock sentry(*this);
    if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
{
 _M_use_count = 0;
 return false;
}
    return true;
  }

template<>
  inline bool
  _Sp_counted_base<_S_atomic>::
  _M_add_ref_lock_nothrow()
  {
    // Perform lock-free add-if-not-zero operation.
    _Atomic_word __count = _M_get_use_count();
    do
{
 if (__count == 0)
   return false;
 // Replace the current counter value with the old value + 1, as
 // long as it's not changed meanwhile.
}
    while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
			  true, __ATOMIC_ACQ_REL4,
			  __ATOMIC_RELAXED0));
    return true;
  }

template<>
  inline void
  _Sp_counted_base<_S_single>::_M_add_ref_copy()
  { ++_M_use_count; }

template<>
  inline void
  _Sp_counted_base<_S_single>::_M_release() noexcept
  {
    if (--_M_use_count == 0)
      {
        _M_dispose();
        if (--_M_weak_count == 0)
          _M_destroy();
      }
  }

template<>
  inline void
  _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept
  { ++_M_weak_count; }

template<>
  inline void
  _Sp_counted_base<_S_single>::_M_weak_release() noexcept
  {
    if (--_M_weak_count == 0)
      _M_destroy();
  }

template<>
  inline long
  _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept
  { return _M_use_count; }


// Forward declarations.
template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
  class __shared_ptr;

template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
  class __weak_ptr;

template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
  class __enable_shared_from_this;

template<typename _Tp>
  class shared_ptr;

template<typename _Tp>
  class weak_ptr;

template<typename _Tp>
  struct owner_less;

template<typename _Tp>
  class enable_shared_from_this;

template<_Lock_policy _Lp = __default_lock_policy>
  class __weak_count;

template<_Lock_policy _Lp = __default_lock_policy>
  class __shared_count;


// Counted ptr with no deleter or allocator support
template<typename _Ptr, _Lock_policy _Lp>
  class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
  {
  public:
    explicit
    _Sp_counted_ptr(_Ptr __p) noexcept
    : _M_ptr(__p) { }

    virtual void
    _M_dispose() noexcept
    { delete _M_ptr; }

    virtual void
    _M_destroy() noexcept
    { delete this; }

    virtual void*
    _M_get_deleter(const std::type_info&) noexcept
    { return nullptr; }

    _Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
    _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;

  private:
    _Ptr             _M_ptr;
  };

template<>
  inline void
  _Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept { }

template<>
  inline void
  _Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept { }

template<>
  inline void
  _Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept { }

template<int _Nm, typename _Tp,
  bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
  struct _Sp_ebo_helper;

/// Specialization using EBO.
template<int _Nm, typename _Tp>
  struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp
  {
    explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { }
    explicit _Sp_ebo_helper(_Tp&& __tp) : _Tp(std::move(__tp)) { }

    static _Tp&
    _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); }
  };

/// Specialization not using EBO.
template<int _Nm, typename _Tp>
  struct _Sp_ebo_helper<_Nm, _Tp, false>
  {
    explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { }
    explicit _Sp_ebo_helper(_Tp&& __tp) : _M_tp(std::move(__tp)) { }

    static _Tp&
    _S_get(_Sp_ebo_helper& __eboh)
    { return __eboh._M_tp; }

  private:
    _Tp _M_tp;
  };

// Support for custom deleter and/or allocator
template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
  class _Sp_counted_deleter final : public _Sp_counted_base<_Lp>
  {
    class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc>
    {
typedef _Sp_ebo_helper<0, _Deleter>	_Del_base;
typedef _Sp_ebo_helper<1, _Alloc>	_Alloc_base;

    public:
_Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
: _M_ptr(__p), _Del_base(std::move(__d)), _Alloc_base(__a)
{ }

_Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); }
_Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); }

_Ptr _M_ptr;
    };

  public:
    using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>;

    // __d(__p) must not throw.
    _Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept
    : _M_impl(__p, std::move(__d), _Alloc()) { }

    // __d(__p) must not throw.
    _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
    : _M_impl(__p, std::move(__d), __a) { }

    ~_Sp_counted_deleter() noexcept { }

    virtual void
    _M_dispose() noexcept
    { _M_impl._M_del()(_M_impl._M_ptr); }

    virtual void
    _M_destroy() noexcept
    {
__allocator_type __a(_M_impl._M_alloc());
__allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
this->~_Sp_counted_deleter();
    }

    virtual void*
    _M_get_deleter(const std::type_info& __ti) noexcept
    {
483#if __cpp_rtti199711
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2400. shared_ptr's get_deleter() should use addressof()
      return __ti == typeid(_Deleter)
 ? std::__addressof(_M_impl._M_del())
 : nullptr;
489#else
      return nullptr;
491#endif
    }

  private:
    _Impl _M_impl;
  };

// helpers for make_shared / allocate_shared

struct _Sp_make_shared_tag { };

template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
  class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp>
  {
    class _Impl : _Sp_ebo_helper<0, _Alloc>
    {
typedef _Sp_ebo_helper<0, _Alloc>	_A_base;

    public:
explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { }

_Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); }

__gnu_cxx::__aligned_buffer<_Tp> _M_storage;
    };

  public:
    using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>;

    template<typename... _Args>
_Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
: _M_impl(__a)
{
 // _GLIBCXX_RESOLVE_LIB_DEFECTS
 // 2070.  allocate_shared should use allocator_traits<A>::construct
 allocator_traits<_Alloc>::construct(__a, _M_ptr(),
     std::forward<_Args>(__args)...); // might throw
}

    ~_Sp_counted_ptr_inplace() noexcept { }

    virtual void
    _M_dispose() noexcept
    {
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
    }

    // Override because the allocator needs to know the dynamic type
    virtual void
    _M_destroy() noexcept
    {
__allocator_type __a(_M_impl._M_alloc());
__allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
this->~_Sp_counted_ptr_inplace();
    }

    // Sneaky trick so __shared_ptr can get the managed pointer
    virtual void*
    _M_get_deleter(const std::type_info& __ti) noexcept
    {
551#if __cpp_rtti199711
if (__ti == typeid(_Sp_make_shared_tag))
 return const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
554#endif
return nullptr;
    }

  private:
    _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); }

    _Impl _M_impl;
  };

// The default deleter for shared_ptr<T[]> and shared_ptr<T[N]>.
struct __sp_array_delete
{
  template<typename _Yp>
    void operator()(_Yp* __p) const { delete[] __p; }
};

template<_Lock_policy _Lp>
  class __shared_count
  {
  public:
    constexpr __shared_count() noexcept : _M_pi(0)
    { }

    template<typename _Ptr>
      explicit
__shared_count(_Ptr __p) : _M_pi(0)
{
 __tryif (true)
   {
     _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
   }
 __catch(...)if (false)
   {
     delete __p;
     __throw_exception_again;
   }
}

    template<typename _Ptr>
__shared_count(_Ptr __p, /* is_array = */ false_type)
: __shared_count(__p)
{ }

    template<typename _Ptr>
__shared_count(_Ptr __p, /* is_array = */ true_type)
: __shared_count(__p, __sp_array_delete{}, allocator<void>())
{ }

    template<typename _Ptr, typename _Deleter>
__shared_count(_Ptr __p, _Deleter __d)
: __shared_count(__p, std::move(__d), allocator<void>())
{ }

    template<typename _Ptr, typename _Deleter, typename _Alloc>
__shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
{
 typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
 __tryif (true)
   {
     typename _Sp_cd_type::__allocator_type __a2(__a);
     auto __guard = std::__allocate_guarded(__a2);
     _Sp_cd_type* __mem = __guard.get();
     ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a));
     _M_pi = __mem;
     __guard = nullptr;
   }
 __catch(...)if (false)
   {
     __d(__p); // Call _Deleter on __p.
     __throw_exception_again;
   }
}

    template<typename _Tp, typename _Alloc, typename... _Args>
__shared_count(_Sp_make_shared_tag, _Tp*, const _Alloc& __a,
       _Args&&... __args)
: _M_pi(0)
{
 typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
 typename _Sp_cp_type::__allocator_type __a2(__a);
 auto __guard = std::__allocate_guarded(__a2);
 _Sp_cp_type* __mem = __guard.get();
 ::new (__mem) _Sp_cp_type(std::move(__a),
		    std::forward<_Args>(__args)...);
 _M_pi = __mem;
 __guard = nullptr;
}

643#if _GLIBCXX_USE_DEPRECATED1
    // Special case for auto_ptr<_Tp> to provide the strong guarantee.
    template<typename _Tp>
      explicit
__shared_count(std::auto_ptr<_Tp>&& __r);
648#endif

    // Special case for unique_ptr<_Tp,_Del> to provide the strong guarantee.
    template<typename _Tp, typename _Del>
      explicit
__shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0)
{
 // _GLIBCXX_RESOLVE_LIB_DEFECTS
 // 2415. Inconsistency between unique_ptr and shared_ptr
 if (__r.get() == nullptr)
   return;

 using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
 using _Del2 = typename conditional<is_reference<_Del>::value,
     reference_wrapper<typename remove_reference<_Del>::type>,
     _Del>::type;
 using _Sp_cd_type
   = _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
 using _Alloc = allocator<_Sp_cd_type>;
 using _Alloc_traits = allocator_traits<_Alloc>;
 _Alloc __a;
 _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);
 _Alloc_traits::construct(__a, __mem, __r.release(),
		   __r.get_deleter());  // non-throwing
 _M_pi = __mem;
}

    // Throw bad_weak_ptr when __r._M_get_use_count() == 0.
    explicit __shared_count(const __weak_count<_Lp>& __r);

    // Does not throw if __r._M_get_use_count() == 0, caller must check.
    explicit __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t);

    ~__shared_count() noexcept
    {
if (_M_pi != nullptr)
 _M_pi->_M_release();
    }

    __shared_count(const __shared_count& __r) noexcept
    : _M_pi(__r._M_pi)
    {
if (_M_pi != 0)
 _M_pi->_M_add_ref_copy();
    }

    __shared_count&
    operator=(const __shared_count& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != _M_pi)
38
←
Taking true branch→
66
←
Taking true branch→
 {
   if (__tmp != 0)
39
←
Taking false branch→
67
←
Taking false branch→
     __tmp->_M_add_ref_copy();
   if (_M_pi != 0)
40
←
Taking true branch→
68
←
Taking true branch→
     _M_pi->_M_release();
41
←
Calling '_Sp_counted_base::_M_release'→
49
←
Returning; memory was released→
69
←
Calling '_Sp_counted_base::_M_release'→
   _M_pi = __tmp;
 }
return *this;
    }

    void
    _M_swap(__shared_count& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
    }

    long
    _M_get_use_count() const noexcept
    { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }

    bool
    _M_unique() const noexcept
    { return this->_M_get_use_count() == 1; }

    void*
    _M_get_deleter(const std::type_info& __ti) const noexcept
    { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; }

    bool
    _M_less(const __shared_count& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    bool
    _M_less(const __weak_count<_Lp>& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    // Friend function injected into enclosing namespace and found by ADL
    friend inline bool
    operator==(const __shared_count& __a, const __shared_count& __b) noexcept
    { return __a._M_pi == __b._M_pi; }

  private:
    friend class __weak_count<_Lp>;

    _Sp_counted_base<_Lp>*  _M_pi;
  };


template<_Lock_policy _Lp>
  class __weak_count
  {
  public:
    constexpr __weak_count() noexcept : _M_pi(nullptr)
    { }

    __weak_count(const __shared_count<_Lp>& __r) noexcept
    : _M_pi(__r._M_pi)
    {
if (_M_pi != nullptr)
 _M_pi->_M_weak_add_ref();
    }

    __weak_count(const __weak_count& __r) noexcept
    : _M_pi(__r._M_pi)
    {
if (_M_pi != nullptr)
 _M_pi->_M_weak_add_ref();
    }

    __weak_count(__weak_count&& __r) noexcept
    : _M_pi(__r._M_pi)
    { __r._M_pi = nullptr; }

    ~__weak_count() noexcept
    {
if (_M_pi != nullptr)
 _M_pi->_M_weak_release();
    }

    __weak_count&
    operator=(const __shared_count<_Lp>& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != nullptr)
 __tmp->_M_weak_add_ref();
if (_M_pi != nullptr)
 _M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
    }

    __weak_count&
    operator=(const __weak_count& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
if (__tmp != nullptr)
 __tmp->_M_weak_add_ref();
if (_M_pi != nullptr)
 _M_pi->_M_weak_release();
_M_pi = __tmp;
return *this;
    }

    __weak_count&
    operator=(__weak_count&& __r) noexcept
    {
if (_M_pi != nullptr)
 _M_pi->_M_weak_release();
_M_pi = __r._M_pi;
      __r._M_pi = nullptr;
return *this;
    }

    void
    _M_swap(__weak_count& __r) noexcept
    {
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
    }

    long
    _M_get_use_count() const noexcept
    { return _M_pi != nullptr ? _M_pi->_M_get_use_count() : 0; }

    bool
    _M_less(const __weak_count& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    bool
    _M_less(const __shared_count<_Lp>& __rhs) const noexcept
    { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }

    // Friend function injected into enclosing namespace and found by ADL
    friend inline bool
    operator==(const __weak_count& __a, const __weak_count& __b) noexcept
    { return __a._M_pi == __b._M_pi; }

  private:
    friend class __shared_count<_Lp>;

    _Sp_counted_base<_Lp>*  _M_pi;
  };

// Now that __weak_count is defined we can define this constructor:
template<_Lock_policy _Lp>
  inline
  __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r)
  : _M_pi(__r._M_pi)
  {
    if (_M_pi != nullptr)
_M_pi->_M_add_ref_lock();
    else
__throw_bad_weak_ptr();
  }

// Now that __weak_count is defined we can define this constructor:
template<_Lock_policy _Lp>
  inline
  __shared_count<_Lp>::
  __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t)
  : _M_pi(__r._M_pi)
  {
    if (_M_pi != nullptr)
if (!_M_pi->_M_add_ref_lock_nothrow())
 _M_pi = nullptr;
  }

869#define __cpp_lib_shared_ptr_arrays201603 201603

// Helper traits for shared_ptr of array:

// A pointer type Y* is said to be compatible with a pointer type T* when
// either Y* is convertible to T* or Y is U[N] and T is U cv [].
template<typename _Yp_ptr, typename _Tp_ptr>
  struct __sp_compatible_with
  : false_type
  { };

template<typename _Yp, typename _Tp>
  struct __sp_compatible_with<_Yp*, _Tp*>
  : is_convertible<_Yp*, _Tp*>::type
  { };

template<typename _Up, size_t _Nm>
  struct __sp_compatible_with<_Up(*)[_Nm], _Up(*)[]>
  : true_type
  { };

template<typename _Up, size_t _Nm>
  struct __sp_compatible_with<_Up(*)[_Nm], const _Up(*)[]>
  : true_type
  { };

template<typename _Up, size_t _Nm>
  struct __sp_compatible_with<_Up(*)[_Nm], volatile _Up(*)[]>
  : true_type
  { };

template<typename _Up, size_t _Nm>
  struct __sp_compatible_with<_Up(*)[_Nm], const volatile _Up(*)[]>
  : true_type
  { };

// Test conversion from Y(*)[N] to U(*)[N] without forming invalid type Y[N].
template<typename _Up, size_t _Nm, typename _Yp, typename = void>
  struct __sp_is_constructible_arrN
  : false_type
  { };

template<typename _Up, size_t _Nm, typename _Yp>
  struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>>
  : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type
  { };

// Test conversion from Y(*)[] to U(*)[] without forming invalid type Y[].
template<typename _Up, typename _Yp, typename = void>
  struct __sp_is_constructible_arr
  : false_type
  { };

template<typename _Up, typename _Yp>
  struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>>
  : is_convertible<_Yp(*)[], _Up(*)[]>::type
  { };

// Trait to check if shared_ptr<T> can be constructed from Y*.
template<typename _Tp, typename _Yp>
  struct __sp_is_constructible;

// When T is U[N], Y(*)[N] shall be convertible to T*;
template<typename _Up, size_t _Nm, typename _Yp>
  struct __sp_is_constructible<_Up[_Nm], _Yp>
  : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type
  { };

// when T is U[], Y(*)[] shall be convertible to T*;
template<typename _Up, typename _Yp>
  struct __sp_is_constructible<_Up[], _Yp>
  : __sp_is_constructible_arr<_Up, _Yp>::type
  { };

// otherwise, Y* shall be convertible to T*.
template<typename _Tp, typename _Yp>
  struct __sp_is_constructible
  : is_convertible<_Yp*, _Tp*>::type
  { };


// Define operator* and operator-> for shared_ptr<T>.
template<typename _Tp, _Lock_policy _Lp,
  bool = is_array<_Tp>::value, bool = is_void<_Tp>::value>
  class __shared_ptr_access
  {
  public:
    using element_type = _Tp;

    element_type&
    operator*() const noexcept
    {
__glibcxx_assert(_M_get() != nullptr);
return *_M_get();
    }

    element_type*
    operator->() const noexcept
    {
_GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr);
return _M_get();
    }

  private:
    element_type*
    _M_get() const noexcept
    { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
  };

// Define operator-> for shared_ptr<cv void>.
template<typename _Tp, _Lock_policy _Lp>
  class __shared_ptr_access<_Tp, _Lp, false, true>
  {
  public:
    using element_type = _Tp;

    element_type*
    operator->() const noexcept
    {
auto __ptr = static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get();
_GLIBCXX_DEBUG_PEDASSERT(__ptr != nullptr);
return __ptr;
    }
  };

// Define operator[] for shared_ptr<T[]> and shared_ptr<T[N]>.
template<typename _Tp, _Lock_policy _Lp>
  class __shared_ptr_access<_Tp, _Lp, true, false>
  {
  public:
    using element_type = typename remove_extent<_Tp>::type;

1001#if __cplusplus201103L <= 201402L
    [[__deprecated__("shared_ptr<T[]>::operator* is absent from C++17")]]
    element_type&
    operator*() const noexcept
    {
__glibcxx_assert(_M_get() != nullptr);
return *_M_get();
    }

    [[__deprecated__("shared_ptr<T[]>::operator-> is absent from C++17")]]
    element_type*
    operator->() const noexcept
    {
_GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr);
return _M_get();
    }
1017#endif

    element_type&
    operator[](ptrdiff_t __i) const
    {
__glibcxx_assert(_M_get() != nullptr);
__glibcxx_assert(!extent<_Tp>::value || __i < extent<_Tp>::value);
return _M_get()[__i];
    }

  private:
    element_type*
    _M_get() const noexcept
    { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
  };

template<typename _Tp, _Lock_policy _Lp>
  class __shared_ptr
  : public __shared_ptr_access<_Tp, _Lp>
  {
  public:
    using element_type = typename remove_extent<_Tp>::type;

  private:
    // Constraint for taking ownership of a pointer of type _Yp*:
    template<typename _Yp>
using _SafeConv
 = typename enable_if<__sp_is_constructible<_Tp, _Yp>::value>::type;

    // Constraint for construction from shared_ptr and weak_ptr:
    template<typename _Yp, typename _Res = void>
using _Compatible = typename
 enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;

    // Constraint for assignment from shared_ptr and weak_ptr:
    template<typename _Yp>
using _Assignable = _Compatible<_Yp, __shared_ptr&>;

    // Constraint for construction from unique_ptr:
    template<typename _Yp, typename _Del, typename _Res = void,
      typename _Ptr = typename unique_ptr<_Yp, _Del>::pointer>
using _UniqCompatible = typename enable_if<__and_<
 __sp_compatible_with<_Yp*, _Tp*>, is_convertible<_Ptr, element_type*>
 >::value, _Res>::type;

    // Constraint for assignment from unique_ptr:
    template<typename _Yp, typename _Del>
using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>;

  public:

1068#if __cplusplus201103L > 201402L
    using weak_type = __weak_ptr<_Tp, _Lp>;
1070#endif

    constexpr __shared_ptr() noexcept
    : _M_ptr(0), _M_refcount()
    { }

    template<typename _Yp, typename = _SafeConv<_Yp>>
explicit
__shared_ptr(_Yp* __p)
: _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type())
{
 static_assert( !is_void<_Yp>::value, "incomplete type" );
 static_assert( sizeof(_Yp) > 0, "incomplete type" );
 _M_enable_shared_from_this_with(__p);
}

    template<typename _Yp, typename _Deleter, typename = _SafeConv<_Yp>>
__shared_ptr(_Yp* __p, _Deleter __d)
: _M_ptr(__p), _M_refcount(__p, std::move(__d))
{
 static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
     "deleter expression d(p) is well-formed");
 _M_enable_shared_from_this_with(__p);
}

    template<typename _Yp, typename _Deleter, typename _Alloc,
      typename = _SafeConv<_Yp>>
__shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
: _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a))
{
 static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
     "deleter expression d(p) is well-formed");
 _M_enable_shared_from_this_with(__p);
}

    template<typename _Deleter>
__shared_ptr(nullptr_t __p, _Deleter __d)
: _M_ptr(0), _M_refcount(__p, std::move(__d))
{ }

    template<typename _Deleter, typename _Alloc>
      __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
: _M_ptr(0), _M_refcount(__p, std::move(__d), std::move(__a))
{ }

    template<typename _Yp>
__shared_ptr(const __shared_ptr<_Yp, _Lp>& __r,
     element_type* __p) noexcept
: _M_ptr(__p), _M_refcount(__r._M_refcount) // never throws
{ }

    __shared_ptr(const __shared_ptr&) noexcept = default;
    __shared_ptr& operator=(const __shared_ptr&) noexcept = default;
37
←
Calling copy assignment operator for '__shared_count'→
50
←
Returning; memory was released→
65
←
Calling copy assignment operator for '__shared_count'→
    ~__shared_ptr() = default;

    template<typename _Yp, typename = _Compatible<_Yp>>
__shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
{ }

    __shared_ptr(__shared_ptr&& __r) noexcept
    : _M_ptr(__r._M_ptr), _M_refcount()
    {
_M_refcount._M_swap(__r._M_refcount);
__r._M_ptr = 0;
    }

    template<typename _Yp, typename = _Compatible<_Yp>>
__shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount()
{
 _M_refcount._M_swap(__r._M_refcount);
 __r._M_ptr = 0;
}

    template<typename _Yp, typename = _Compatible<_Yp>>
explicit __shared_ptr(const __weak_ptr<_Yp, _Lp>& __r)
: _M_refcount(__r._M_refcount) // may throw
{
 // It is now safe to copy __r._M_ptr, as
 // _M_refcount(__r._M_refcount) did not throw.
 _M_ptr = __r._M_ptr;
}

    // If an exception is thrown this constructor has no effect.
    template<typename _Yp, typename _Del,
      typename = _UniqCompatible<_Yp, _Del>>
__shared_ptr(unique_ptr<_Yp, _Del>&& __r)
: _M_ptr(__r.get()), _M_refcount()
{
 auto __raw = _S_raw_ptr(__r.get());
 _M_refcount = __shared_count<_Lp>(std::move(__r));
 _M_enable_shared_from_this_with(__raw);
}

1165#if __cplusplus201103L <= 201402L && _GLIBCXX_USE_DEPRECATED1
  protected:
    // If an exception is thrown this constructor has no effect.
    template<typename _Tp1, typename _Del,
      typename enable_if<__and_<
 __not_<is_array<_Tp>>, is_array<_Tp1>,
        is_convertible<typename unique_ptr<_Tp1, _Del>::pointer, _Tp*>
      >::value, bool>::type = true>
__shared_ptr(unique_ptr<_Tp1, _Del>&& __r, __sp_array_delete)
: _M_ptr(__r.get()), _M_refcount()
{
 auto __raw = _S_raw_ptr(__r.get());
 _M_refcount = __shared_count<_Lp>(std::move(__r));
 _M_enable_shared_from_this_with(__raw);
}
  public:
1181#endif

1183#if _GLIBCXX_USE_DEPRECATED1
    // Postcondition: use_count() == 1 and __r.get() == 0
    template<typename _Yp, typename = _Compatible<_Yp>>
__shared_ptr(auto_ptr<_Yp>&& __r);
1187#endif

    constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { }

    template<typename _Yp>
_Assignable<_Yp>
operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
{
 _M_ptr = __r._M_ptr;
 _M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw
 return *this;
}

1200#if _GLIBCXX_USE_DEPRECATED1
    template<typename _Yp>
_Assignable<_Yp>
operator=(auto_ptr<_Yp>&& __r)
{
 __shared_ptr(std::move(__r)).swap(*this);
 return *this;
}
1208#endif

    __shared_ptr&
    operator=(__shared_ptr&& __r) noexcept
    {
__shared_ptr(std::move(__r)).swap(*this);
return *this;
    }

    template<class _Yp>
_Assignable<_Yp>
operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept
{
 __shared_ptr(std::move(__r)).swap(*this);
 return *this;
}

    template<typename _Yp, typename _Del>
_UniqAssignable<_Yp, _Del>
operator=(unique_ptr<_Yp, _Del>&& __r)
{
 __shared_ptr(std::move(__r)).swap(*this);
 return *this;
}

    void
    reset() noexcept
    { __shared_ptr().swap(*this); }

    template<typename _Yp>
_SafeConv<_Yp>
reset(_Yp* __p) // _Yp must be complete.
{
 // Catch self-reset errors.
 __glibcxx_assert(__p == 0 || __p != _M_ptr);
 __shared_ptr(__p).swap(*this);
}

    template<typename _Yp, typename _Deleter>
_SafeConv<_Yp>
reset(_Yp* __p, _Deleter __d)
{ __shared_ptr(__p, std::move(__d)).swap(*this); }

    template<typename _Yp, typename _Deleter, typename _Alloc>
_SafeConv<_Yp>
reset(_Yp* __p, _Deleter __d, _Alloc __a)
      { __shared_ptr(__p, std::move(__d), std::move(__a)).swap(*this); }

    element_type*
    get() const noexcept
    { return _M_ptr; }

    explicit operator bool() const // never throws
    { return _M_ptr == 0 ? false : true; }

    bool
    unique() const noexcept
    { return _M_refcount._M_unique(); }

    long
    use_count() const noexcept
    { return _M_refcount._M_get_use_count(); }

    void
    swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
    {
std::swap(_M_ptr, __other._M_ptr);
_M_refcount._M_swap(__other._M_refcount);
    }

    template<typename _Tp1>
bool
owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const noexcept
{ return _M_refcount._M_less(__rhs._M_refcount); }

    template<typename _Tp1>
bool
owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const noexcept
{ return _M_refcount._M_less(__rhs._M_refcount); }

1288#if __cpp_rtti199711
  protected:
    // This constructor is non-standard, it is used by allocate_shared.
    template<typename _Alloc, typename... _Args>
__shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
     _Args&&... __args)
: _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a,
		std::forward<_Args>(__args)...)
{
 // _M_ptr needs to point to the newly constructed object.
 // This relies on _Sp_counted_ptr_inplace::_M_get_deleter.
 void* __p = _M_refcount._M_get_deleter(typeid(__tag));
 _M_ptr = static_cast<_Tp*>(__p);
 _M_enable_shared_from_this_with(_M_ptr);
}
1303#else
    template<typename _Alloc>
      struct _Deleter
      {
        void operator()(typename _Alloc::value_type* __ptr)
        {
   __allocated_ptr<_Alloc> __guard{ _M_alloc, __ptr };
   allocator_traits<_Alloc>::destroy(_M_alloc, __guard.get());
        }
        _Alloc _M_alloc;
      };

    template<typename _Alloc, typename... _Args>
__shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
     _Args&&... __args)
: _M_ptr(), _M_refcount()
{
 typedef typename allocator_traits<_Alloc>::template
   rebind_traits<typename std::remove_cv<_Tp>::type> __traits;
 _Deleter<typename __traits::allocator_type> __del = { __a };
 auto __guard = std::__allocate_guarded(__del._M_alloc);
 auto __ptr = __guard.get();
 // _GLIBCXX_RESOLVE_LIB_DEFECTS
 // 2070. allocate_shared should use allocator_traits<A>::construct
 __traits::construct(__del._M_alloc, __ptr,
	      std::forward<_Args>(__args)...);
 __guard = nullptr;
 __shared_count<_Lp> __count(__ptr, __del, __del._M_alloc);
 _M_refcount._M_swap(__count);
 _M_ptr = __ptr;
 _M_enable_shared_from_this_with(_M_ptr);
}
1335#endif

    template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
      typename... _Args>
friend __shared_ptr<_Tp1, _Lp1>
__allocate_shared(const _Alloc& __a, _Args&&... __args);

    // This constructor is used by __weak_ptr::lock() and
    // shared_ptr::shared_ptr(const weak_ptr&, std::nothrow_t).
    __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t)
    : _M_refcount(__r._M_refcount, std::nothrow)
    {
_M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;
    }

    friend class __weak_ptr<_Tp, _Lp>;

  private:

    template<typename _Yp>
using __esft_base_t = decltype(__enable_shared_from_this_base(
     std::declval<const __shared_count<_Lp>&>(),
     std::declval<_Yp*>()));

    // Detect an accessible and unambiguous enable_shared_from_this base.
    template<typename _Yp, typename = void>
struct __has_esft_base
: false_type { };

    template<typename _Yp>
struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>>
: __not_<is_array<_Tp>> { }; // No enable shared_from_this for arrays

    template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
typename enable_if<__has_esft_base<_Yp2>::value>::type
_M_enable_shared_from_this_with(_Yp* __p) noexcept
{
 if (auto __base = __enable_shared_from_this_base(_M_refcount, __p))
   __base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount);
}

    template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
typename enable_if<!__has_esft_base<_Yp2>::value>::type
_M_enable_shared_from_this_with(_Yp*) noexcept
{ }

    void*
    _M_get_deleter(const std::type_info& __ti) const noexcept
    { return _M_refcount._M_get_deleter(__ti); }

    template<typename _Tp1>
static _Tp1*
_S_raw_ptr(_Tp1* __ptr)
{ return __ptr; }

    template<typename _Tp1>
static auto
_S_raw_ptr(_Tp1 __ptr) -> decltype(std::__addressof(*__ptr))
{ return std::__addressof(*__ptr); }

    template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
    template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;

    template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept;

    element_type*	   _M_ptr;         // Contained pointer.
    __shared_count<_Lp>  _M_refcount;    // Reference counter.
  };


// 20.7.2.2.7 shared_ptr comparisons
template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator==(const __shared_ptr<_Tp1, _Lp>& __a,
      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return __a.get() == __b.get(); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return !__a; }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return !__a; }

template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return __a.get() != __b.get(); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return (bool)__a; }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return (bool)__a; }

template<typename _Tp, typename _Up, _Lock_policy _Lp>
  inline bool
  operator<(const __shared_ptr<_Tp, _Lp>& __a,
     const __shared_ptr<_Up, _Lp>& __b) noexcept
  {
    using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
    using _Up_elt = typename __shared_ptr<_Up, _Lp>::element_type;
    using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type;
    return less<_Vp>()(__a.get(), __b.get());
  }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  {
    using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
    return less<_Tp_elt*>()(__a.get(), nullptr);
  }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  {
    using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
    return less<_Tp_elt*>()(nullptr, __a.get());
  }

template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator<=(const __shared_ptr<_Tp1, _Lp>& __a,
      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return !(__b < __a); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return !(nullptr < __a); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return !(__a < nullptr); }

template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator>(const __shared_ptr<_Tp1, _Lp>& __a,
     const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return (__b < __a); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return nullptr < __a; }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return __a < nullptr; }

template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  inline bool
  operator>=(const __shared_ptr<_Tp1, _Lp>& __a,
      const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  { return !(__a < __b); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  { return !(__a < nullptr); }

template<typename _Tp, _Lock_policy _Lp>
  inline bool
  operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  { return !(nullptr < __a); }

template<typename _Sp>
  struct _Sp_less : public binary_function<_Sp, _Sp, bool>
  {
    bool
    operator()(const _Sp& __lhs, const _Sp& __rhs) const noexcept
    {
typedef typename _Sp::element_type element_type;
return std::less<element_type*>()(__lhs.get(), __rhs.get());
    }
  };

template<typename _Tp, _Lock_policy _Lp>
  struct less<__shared_ptr<_Tp, _Lp>>
  : public _Sp_less<__shared_ptr<_Tp, _Lp>>
  { };

// 20.7.2.2.8 shared_ptr specialized algorithms.
template<typename _Tp, _Lock_policy _Lp>
  inline void
  swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept
  { __a.swap(__b); }

// 20.7.2.2.9 shared_ptr casts

// The seemingly equivalent code:
// shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))
// will eventually result in undefined behaviour, attempting to
// delete the same object twice.
/// static_pointer_cast
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  inline __shared_ptr<_Tp, _Lp>
  static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  {
    using _Sp = __shared_ptr<_Tp, _Lp>;
    return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get()));
  }

// The seemingly equivalent code:
// shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))
// will eventually result in undefined behaviour, attempting to
// delete the same object twice.
/// const_pointer_cast
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  inline __shared_ptr<_Tp, _Lp>
  const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  {
    using _Sp = __shared_ptr<_Tp, _Lp>;
    return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get()));
  }

// The seemingly equivalent code:
// shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))
// will eventually result in undefined behaviour, attempting to
// delete the same object twice.
/// dynamic_pointer_cast
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  inline __shared_ptr<_Tp, _Lp>
  dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  {
    using _Sp = __shared_ptr<_Tp, _Lp>;
    if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
return _Sp(__r, __p);
    return _Sp();
  }

1579#if __cplusplus201103L > 201402L
template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  inline __shared_ptr<_Tp, _Lp>
  reinterpret_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  {
    using _Sp = __shared_ptr<_Tp, _Lp>;
    return _Sp(__r, reinterpret_cast<typename _Sp::element_type*>(__r.get()));
  }
1587#endif

template<typename _Tp, _Lock_policy _Lp>
  class __weak_ptr
  {
    template<typename _Yp, typename _Res = void>
using _Compatible = typename
 enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;

    // Constraint for assignment from shared_ptr and weak_ptr:
    template<typename _Yp>
using _Assignable = _Compatible<_Yp, __weak_ptr&>;

  public:
    using element_type = typename remove_extent<_Tp>::type;

    constexpr __weak_ptr() noexcept
    : _M_ptr(nullptr), _M_refcount()
    { }

    __weak_ptr(const __weak_ptr&) noexcept = default;

    ~__weak_ptr() = default;

    // The "obvious" converting constructor implementation:
    //
    //  template<typename _Tp1>
    //    __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
    //    : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
    //    { }
    //
    // has a serious problem.
    //
    //  __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr)
    //  conversion may require access to *__r._M_ptr (virtual inheritance).
    //
    // It is not possible to avoid spurious access violations since
    // in multithreaded programs __r._M_ptr may be invalidated at any point.
    template<typename _Yp, typename = _Compatible<_Yp>>
__weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept
: _M_refcount(__r._M_refcount)
      { _M_ptr = __r.lock().get(); }

    template<typename _Yp, typename = _Compatible<_Yp>>
__weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
{ }

    __weak_ptr(__weak_ptr&& __r) noexcept
    : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount))
    { __r._M_ptr = nullptr; }

    template<typename _Yp, typename = _Compatible<_Yp>>
__weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept
: _M_ptr(__r.lock().get()), _M_refcount(std::move(__r._M_refcount))
      { __r._M_ptr = nullptr; }

    __weak_ptr&
    operator=(const __weak_ptr& __r) noexcept = default;

    template<typename _Yp>
_Assignable<_Yp>
operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept
{
 _M_ptr = __r.lock().get();
 _M_refcount = __r._M_refcount;
 return *this;
}

    template<typename _Yp>
_Assignable<_Yp>
operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
{
 _M_ptr = __r._M_ptr;
 _M_refcount = __r._M_refcount;
 return *this;
}

    __weak_ptr&
    operator=(__weak_ptr&& __r) noexcept
    {
_M_ptr = __r._M_ptr;
_M_refcount = std::move(__r._M_refcount);
__r._M_ptr = nullptr;
return *this;
    }

    template<typename _Yp>
_Assignable<_Yp>
operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept
{
 _M_ptr = __r.lock().get();
 _M_refcount = std::move(__r._M_refcount);
 __r._M_ptr = nullptr;
 return *this;
}

    __shared_ptr<_Tp, _Lp>
    lock() const noexcept
    { return __shared_ptr<element_type, _Lp>(*this, std::nothrow); }

    long
    use_count() const noexcept
    { return _M_refcount._M_get_use_count(); }

    bool
    expired() const noexcept
    { return _M_refcount._M_get_use_count() == 0; }

    template<typename _Tp1>
bool
owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const noexcept
{ return _M_refcount._M_less(__rhs._M_refcount); }

    template<typename _Tp1>
bool
owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const noexcept
{ return _M_refcount._M_less(__rhs._M_refcount); }

    void
    reset() noexcept
    { __weak_ptr().swap(*this); }

    void
    swap(__weak_ptr& __s) noexcept
    {
std::swap(_M_ptr, __s._M_ptr);
_M_refcount._M_swap(__s._M_refcount);
    }

  private:
    // Used by __enable_shared_from_this.
    void
    _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
    {
if (use_count() == 0)
 {
   _M_ptr = __ptr;
   _M_refcount = __refcount;
 }
    }

    template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
    template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
    friend class __enable_shared_from_this<_Tp, _Lp>;
    friend class enable_shared_from_this<_Tp>;

    element_type*	 _M_ptr;         // Contained pointer.
    __weak_count<_Lp>  _M_refcount;    // Reference counter.
  };

// 20.7.2.3.6 weak_ptr specialized algorithms.
template<typename _Tp, _Lock_policy _Lp>
  inline void
  swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept
  { __a.swap(__b); }

template<typename _Tp, typename _Tp1>
  struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
  {
    bool
    operator()(const _Tp& __lhs, const _Tp& __rhs) const noexcept
    { return __lhs.owner_before(__rhs); }

    bool
    operator()(const _Tp& __lhs, const _Tp1& __rhs) const noexcept
    { return __lhs.owner_before(__rhs); }

    bool
    operator()(const _Tp1& __lhs, const _Tp& __rhs) const noexcept
    { return __lhs.owner_before(__rhs); }
  };

template<>
  struct _Sp_owner_less<void, void>
  {
    template<typename _Tp, typename _Up>
auto
operator()(const _Tp& __lhs, const _Up& __rhs) const noexcept
-> decltype(__lhs.owner_before(__rhs))
{ return __lhs.owner_before(__rhs); }

    using is_transparent = void;
  };

template<typename _Tp, _Lock_policy _Lp>
  struct owner_less<__shared_ptr<_Tp, _Lp>>
  : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
  { };

template<typename _Tp, _Lock_policy _Lp>
  struct owner_less<__weak_ptr<_Tp, _Lp>>
  : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
  { };


template<typename _Tp, _Lock_policy _Lp>
  class __enable_shared_from_this
  {
  protected:
    constexpr __enable_shared_from_this() noexcept { }

    __enable_shared_from_this(const __enable_shared_from_this&) noexcept { }

    __enable_shared_from_this&
    operator=(const __enable_shared_from_this&) noexcept
    { return *this; }

    ~__enable_shared_from_this() { }

  public:
    __shared_ptr<_Tp, _Lp>
    shared_from_this()
    { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }

    __shared_ptr<const _Tp, _Lp>
    shared_from_this() const
    { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }

1806#if __cplusplus201103L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
    __weak_ptr<_Tp, _Lp>
    weak_from_this() noexcept
    { return this->_M_weak_this; }

    __weak_ptr<const _Tp, _Lp>
    weak_from_this() const noexcept
    { return this->_M_weak_this; }
1814#endif

  private:
    template<typename _Tp1>
void
_M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept
{ _M_weak_this._M_assign(__p, __n); }

    friend const __enable_shared_from_this*
    __enable_shared_from_this_base(const __shared_count<_Lp>&,
		     const __enable_shared_from_this* __p)
    { return __p; }

    template<typename, _Lock_policy>
friend class __shared_ptr;

    mutable __weak_ptr<_Tp, _Lp>  _M_weak_this;
  };

template<typename _Tp, _Lock_policy _Lp, typename _Alloc, typename... _Args>
  inline __shared_ptr<_Tp, _Lp>
  __allocate_shared(const _Alloc& __a, _Args&&... __args)
  {
    return __shared_ptr<_Tp, _Lp>(_Sp_make_shared_tag(), __a,
		    std::forward<_Args>(__args)...);
  }

template<typename _Tp, _Lock_policy _Lp, typename... _Args>
  inline __shared_ptr<_Tp, _Lp>
  __make_shared(_Args&&... __args)
  {
    typedef typename std::remove_const<_Tp>::type _Tp_nc;
    return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
			      std::forward<_Args>(__args)...);
  }

/// std::hash specialization for __shared_ptr.
template<typename _Tp, _Lock_policy _Lp>
  struct hash<__shared_ptr<_Tp, _Lp>>
  : public __hash_base<size_t, __shared_ptr<_Tp, _Lp>>
  {
    size_t
    operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept
    {
return hash<typename __shared_ptr<_Tp, _Lp>::element_type*>()(
   __s.get());
    }
  };

1863_GLIBCXX_END_NAMESPACE_VERSION
1864} // namespace

1866#endif // _SHARED_PTR_BASE_H

←

/usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/ext/atomicity.h

1// Support for atomic operations -*- C++ -*-
2 
3// Copyright (C) 2004-2017 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10 
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.
15 
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19 
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.
24 
25/** @file ext/atomicity.h
26 *  This file is a GNU extension to the Standard C++ Library.
27 */
28 
29#ifndef _GLIBCXX_ATOMICITY_H1
30#define _GLIBCXX_ATOMICITY_H1	1
31 
32#pragma GCC system_header
33 
34#include <bits/c++config.h>
35#include <bits/gthr.h>
36#include <bits/atomic_word.h>
37 
38namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
39{
40_GLIBCXX_BEGIN_NAMESPACE_VERSION
41 
42  // Functions for portable atomic access.
43  // To abstract locking primitives across all thread policies, use:
44  // __exchange_and_add_dispatch
45  // __atomic_add_dispatch
46#ifdef _GLIBCXX_ATOMIC_BUILTINS1
47  static inline _Atomic_word 
48  __exchange_and_add(volatile _Atomic_word* __mem, int __val)
49  { return __atomic_fetch_add(__mem, __val, __ATOMIC_ACQ_REL4); }
50 
51  static inline void
52  __atomic_add(volatile _Atomic_word* __mem, int __val)
53  { __atomic_fetch_add(__mem, __val, __ATOMIC_ACQ_REL4); }
54#else
55  _Atomic_word
56  __attribute__ ((__unused__))
57  __exchange_and_add(volatile _Atomic_word*, int) throw ();
58 
59  void
60  __attribute__ ((__unused__))
61  __atomic_add(volatile _Atomic_word*, int) throw ();
62#endif
63 
64  static inline _Atomic_word
65  __exchange_and_add_single(_Atomic_word* __mem, int __val)
66  {
67    _Atomic_word __result = *__mem;
74
←
Use of memory after it is freed
68    *__mem += __val;
69    return __result;
70  }
71 
72  static inline void
73  __atomic_add_single(_Atomic_word* __mem, int __val)
74  { *__mem += __val; }
75 
76  static inline _Atomic_word
77  __attribute__ ((__unused__))
78  __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
79  {
80#ifdef __GTHREADS1
81    if (__gthread_active_p())
71
←
Assuming the condition is false→
72
←
Taking false branch→
82      return __exchange_and_add(__mem, __val);
83    else
84      return __exchange_and_add_single(__mem, __val);
73
←
Calling '__exchange_and_add_single'→
85#else
86    return __exchange_and_add_single(__mem, __val);
87#endif
88  }
89 
90  static inline void
91  __attribute__ ((__unused__))
92  __atomic_add_dispatch(_Atomic_word* __mem, int __val)
93  {
94#ifdef __GTHREADS1
95    if (__gthread_active_p())
96      __atomic_add(__mem, __val);
97    else
98      __atomic_add_single(__mem, __val);
99#else
100    __atomic_add_single(__mem, __val);
101#endif
102  }
103 
104_GLIBCXX_END_NAMESPACE_VERSION
105} // namespace
106 
107// Even if the CPU doesn't need a memory barrier, we need to ensure
108// that the compiler doesn't reorder memory accesses across the
109// barriers.
110#ifndef _GLIBCXX_READ_MEM_BARRIER__atomic_thread_fence (2)
111#define _GLIBCXX_READ_MEM_BARRIER__atomic_thread_fence (2) __atomic_thread_fence (__ATOMIC_ACQUIRE2)
112#endif
113#ifndef _GLIBCXX_WRITE_MEM_BARRIER__atomic_thread_fence (3)
114#define _GLIBCXX_WRITE_MEM_BARRIER__atomic_thread_fence (3) __atomic_thread_fence (__ATOMIC_RELEASE3)
115#endif
116 
117#endif 