066eea75d3
This casued asserts:
llvm/lib/IR/Metadata.cpp:689:
void llvm::MDNode::resolve(): Assertion `isUniqued() && "Expected this to be uniqued"' failed.
See comments on the PR.
This also reverts the dependent follow-up commits, see below.
> When an LLDB user asks for the value of a static data member, LLDB
> starts by searching the Names accelerator table for the corresponding
> variable definition DIE. For static data members with out-of-class
> definitions that works fine, because those get represented as global
> variables with a location and making them eligible to be added to the
> Names table. However, in-class definitions won<E2><80><99>t get indexed because
> we usually don't emit global variables for them. So in DWARF we end
> up with a single `DW_TAG_member` that usually holds the constant
> initializer. But we don't get a corresponding CU-level
> `DW_TAG_variable` like we do for out-of-class definitions.
>
> To make it more convenient for debuggers to get to the value of
> inline static data members, this patch makes sure we emit definitions
> for static variables with constant initializers the same way we do
> for other static variables. This also aligns Clang closer to GCC,
> which produces CU-level definitions for inline statics and also
> emits these into `.debug_pubnames`.
>
> The implementation keeps track of newly created static data members.
> Then in `CGDebugInfo::finalize`, we emit a global `DW_TAG_variable`
> with a `DW_AT_const_value` for any of those declarations that didn't
> end up with a definition in the `DeclCache`.
>
> The newly emitted `DW_TAG_variable` will look as follows:
> ```
> 0x0000007b: DW_TAG_structure_type
> DW_AT_calling_convention (DW_CC_pass_by_value)
> DW_AT_name ("Foo")
> ...
>
> 0x0000008d: DW_TAG_member
> DW_AT_name ("i")
> DW_AT_type (0x00000062 "const int")
> DW_AT_external (true)
> DW_AT_declaration (true)
> DW_AT_const_value (4)
>
> Newly added
> vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
>
> 0x0000009a: DW_TAG_variable
> DW_AT_specification (0x0000008d "i")
> DW_AT_const_value (4)
> DW_AT_linkage_name ("_ZN2t2IiE1iIfEE")
> ```
>
> This patch also drops the `DW_AT_const_value` off of the declaration
> since we now always have it on the definition. This ensures that the
> `DWARFParallelLinker` can type-merge class with static members where
> we couldn't attach the constant on the declaration in some CUs.
This reverts commit 7c3707aea8a6f1fc245ad2862982b8a51b6c0fea.
This reverts commit cab0a19467ac2e6e1e022087f4b6cb90d55da040.
This reverts commit 317481b3c8b34b0c3f106c514e6aa39b70886110.
This reverts commit 15fc809404d4715822e5349b76dcca50eb100eec.
This reverts commit 470de2bbec7f5fdd199775aa99c68ac76f4d5c74.
145 lines
5.0 KiB
C++
145 lines
5.0 KiB
C++
//===-- SymbolFileDWARFDwo.cpp --------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "SymbolFileDWARFDwo.h"
|
|
|
|
#include "lldb/Core/Section.h"
|
|
#include "lldb/Expression/DWARFExpression.h"
|
|
#include "lldb/Symbol/ObjectFile.h"
|
|
#include "lldb/Utility/LLDBAssert.h"
|
|
#include "llvm/Support/Casting.h"
|
|
|
|
#include "DWARFCompileUnit.h"
|
|
#include "DWARFDebugInfo.h"
|
|
#include "DWARFUnit.h"
|
|
#include <optional>
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
using namespace lldb_private::plugin::dwarf;
|
|
|
|
char SymbolFileDWARFDwo::ID;
|
|
|
|
SymbolFileDWARFDwo::SymbolFileDWARFDwo(SymbolFileDWARF &base_symbol_file,
|
|
ObjectFileSP objfile, uint32_t id)
|
|
: SymbolFileDWARF(objfile, objfile->GetSectionList(
|
|
/*update_module_section_list*/ false)),
|
|
m_base_symbol_file(base_symbol_file) {
|
|
SetFileIndex(id);
|
|
|
|
// Parsing of the dwarf unit index is not thread-safe, so we need to prime it
|
|
// to enable subsequent concurrent lookups.
|
|
m_context.GetAsLLVM().getCUIndex();
|
|
}
|
|
|
|
DWARFCompileUnit *SymbolFileDWARFDwo::GetDWOCompileUnitForHash(uint64_t hash) {
|
|
if (const llvm::DWARFUnitIndex &index = m_context.GetAsLLVM().getCUIndex()) {
|
|
if (const llvm::DWARFUnitIndex::Entry *entry = index.getFromHash(hash)) {
|
|
if (auto *unit_contrib = entry->getContribution())
|
|
return llvm::dyn_cast_or_null<DWARFCompileUnit>(
|
|
DebugInfo().GetUnitAtOffset(DIERef::Section::DebugInfo,
|
|
unit_contrib->getOffset()));
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
DWARFCompileUnit *cu = FindSingleCompileUnit();
|
|
if (!cu)
|
|
return nullptr;
|
|
std::optional<uint64_t> dwo_id = cu->GetDWOId();
|
|
if (!dwo_id || hash != *dwo_id)
|
|
return nullptr;
|
|
return cu;
|
|
}
|
|
|
|
DWARFCompileUnit *SymbolFileDWARFDwo::FindSingleCompileUnit() {
|
|
DWARFDebugInfo &debug_info = DebugInfo();
|
|
|
|
// Right now we only support dwo files with one compile unit. If we don't have
|
|
// type units, we can just check for the unit count.
|
|
if (!debug_info.ContainsTypeUnits() && debug_info.GetNumUnits() == 1)
|
|
return llvm::cast<DWARFCompileUnit>(debug_info.GetUnitAtIndex(0));
|
|
|
|
// Otherwise, we have to run through all units, and find the compile unit that
|
|
// way.
|
|
DWARFCompileUnit *cu = nullptr;
|
|
for (size_t i = 0; i < debug_info.GetNumUnits(); ++i) {
|
|
if (auto *candidate =
|
|
llvm::dyn_cast<DWARFCompileUnit>(debug_info.GetUnitAtIndex(i))) {
|
|
if (cu)
|
|
return nullptr; // More that one CU found.
|
|
cu = candidate;
|
|
}
|
|
}
|
|
return cu;
|
|
}
|
|
|
|
lldb::offset_t SymbolFileDWARFDwo::GetVendorDWARFOpcodeSize(
|
|
const lldb_private::DataExtractor &data, const lldb::offset_t data_offset,
|
|
const uint8_t op) const {
|
|
return GetBaseSymbolFile().GetVendorDWARFOpcodeSize(data, data_offset, op);
|
|
}
|
|
|
|
bool SymbolFileDWARFDwo::ParseVendorDWARFOpcode(
|
|
uint8_t op, const lldb_private::DataExtractor &opcodes,
|
|
lldb::offset_t &offset, std::vector<lldb_private::Value> &stack) const {
|
|
return GetBaseSymbolFile().ParseVendorDWARFOpcode(op, opcodes, offset, stack);
|
|
}
|
|
|
|
SymbolFileDWARF::DIEToTypePtr &SymbolFileDWARFDwo::GetDIEToType() {
|
|
return GetBaseSymbolFile().GetDIEToType();
|
|
}
|
|
|
|
SymbolFileDWARF::DIEToVariableSP &SymbolFileDWARFDwo::GetDIEToVariable() {
|
|
return GetBaseSymbolFile().GetDIEToVariable();
|
|
}
|
|
|
|
SymbolFileDWARF::DIEToCompilerType &
|
|
SymbolFileDWARFDwo::GetForwardDeclDIEToCompilerType() {
|
|
return GetBaseSymbolFile().GetForwardDeclDIEToCompilerType();
|
|
}
|
|
|
|
SymbolFileDWARF::CompilerTypeToDIE &
|
|
SymbolFileDWARFDwo::GetForwardDeclCompilerTypeToDIE() {
|
|
return GetBaseSymbolFile().GetForwardDeclCompilerTypeToDIE();
|
|
}
|
|
|
|
void SymbolFileDWARFDwo::GetObjCMethods(
|
|
lldb_private::ConstString class_name,
|
|
llvm::function_ref<bool(DWARFDIE die)> callback) {
|
|
GetBaseSymbolFile().GetObjCMethods(class_name, callback);
|
|
}
|
|
|
|
UniqueDWARFASTTypeMap &SymbolFileDWARFDwo::GetUniqueDWARFASTTypeMap() {
|
|
return GetBaseSymbolFile().GetUniqueDWARFASTTypeMap();
|
|
}
|
|
|
|
lldb::TypeSP
|
|
SymbolFileDWARFDwo::FindDefinitionTypeForDWARFDeclContext(const DWARFDIE &die) {
|
|
return GetBaseSymbolFile().FindDefinitionTypeForDWARFDeclContext(die);
|
|
}
|
|
|
|
lldb::TypeSP SymbolFileDWARFDwo::FindCompleteObjCDefinitionTypeForDIE(
|
|
const DWARFDIE &die, lldb_private::ConstString type_name,
|
|
bool must_be_implementation) {
|
|
return GetBaseSymbolFile().FindCompleteObjCDefinitionTypeForDIE(
|
|
die, type_name, must_be_implementation);
|
|
}
|
|
|
|
llvm::Expected<lldb::TypeSystemSP>
|
|
SymbolFileDWARFDwo::GetTypeSystemForLanguage(LanguageType language) {
|
|
return GetBaseSymbolFile().GetTypeSystemForLanguage(language);
|
|
}
|
|
|
|
DWARFDIE
|
|
SymbolFileDWARFDwo::GetDIE(const DIERef &die_ref) {
|
|
if (die_ref.file_index() == GetFileIndex())
|
|
return DebugInfo().GetDIE(die_ref);
|
|
return GetBaseSymbolFile().GetDIE(die_ref);
|
|
}
|