admin/revng-revng
1
0
Fork 0
mirror of https://github.com/revng/revng synced 2026-06-21 14:07:57 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
feature/remove-s3-cpp
revng-revng/lib/Model/Importer/DebugInfo/DwarfImporter.cpp
T
Ivan Krysak c8de226f56 DwarfImporter: remove an input-dependent assert 
Not checking for primitives there doesn't change anything anyway, as
`purge-invalid-types` model pass will clean anything invalid still
left after the importer.
2025-04-17 11:19:17 +03:00

1488 lines
48 KiB
C++
Raw Permalink Blame History

/// \file DwarfImporter.cpp
//
// This file is distributed under the MIT License. See LICENSE.md for details.
//
#include <csignal>
#include <optional>
#include "llvm/ADT/DepthFirstIterator.h"
#include "llvm/ADT/EquivalenceClasses.h"
#include "llvm/ADT/Triple.h"
#include "llvm/BinaryFormat/Dwarf.h"
#include "llvm/DebugInfo/DWARF/DWARFContext.h"
#include "llvm/DebugInfo/DWARF/DWARFDie.h"
#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/Object/ELFObjectFile.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/Process.h"
#include "llvm/Support/Progress.h"
#include "llvm/Support/raw_os_ostream.h"
#include "llvm/Support/raw_ostream.h"
#include "revng/ADT/STLExtras.h"
#include "revng/Model/Binary.h"
#include "revng/Model/Importer/Binary/BinaryImporterHelper.h"
#include "revng/Model/Importer/Binary/Options.h"
#include "revng/Model/Importer/DebugInfo/DwarfImporter.h"
#include "revng/Model/Pass/AllPasses.h"
#include "revng/Model/Processing.h"
#include "revng/Support/Assert.h"
#include "revng/Support/Debug.h"
#include "revng/Support/PathList.h"
#include "revng/Support/ProgramRunner.h"
#include "ImportDebugInfoHelper.h"
using namespace llvm;
using namespace llvm::dwarf;
static Logger<> DILogger("dwarf-importer");
static const std::string GlobalDebugDirectory = "/usr/lib/debug/";
template<typename M>
class ScopedSetElement {
private:
M &Set;
typename M::value_type ToInsert;
public:
ScopedSetElement(M &Set, typename M::value_type ToInsert) :
Set(Set), ToInsert(ToInsert) {}
~ScopedSetElement() { Set.erase(ToInsert); }
public:
bool insert() {
auto It = Set.find(ToInsert);
if (It != Set.end()) {
return false;
} else {
Set.insert(It, ToInsert);
return true;
}
}
};
static model::PrimitiveKind::Values dwarfEncodingToModel(uint32_t Encoding) {
switch (Encoding) {
case dwarf::DW_ATE_unsigned_char:
case dwarf::DW_ATE_unsigned:
case dwarf::DW_ATE_boolean:
return model::PrimitiveKind::Unsigned;
case dwarf::DW_ATE_signed_char:
case dwarf::DW_ATE_signed:
return model::PrimitiveKind::Signed;
case dwarf::DW_ATE_float:
return model::PrimitiveKind::Float;
default:
return model::PrimitiveKind::Invalid;
}
}
static std::optional<uint64_t>
getUnsignedOrSigned(const DWARFFormValue &Value) {
auto MaybeUnsigned = Value.getAsUnsignedConstant();
auto MaybeSigned = Value.getAsSignedConstant();
if (MaybeUnsigned)
return *MaybeUnsigned;
else if (MaybeSigned)
return *MaybeSigned;
else
return {};
}
static std::optional<uint64_t> getUnsignedOrSigned(const DWARFDie &Die,
dwarf::Attribute Attribute) {
auto Value = Die.find(Attribute);
if (not Value)
return {};
else
return getUnsignedOrSigned(*Value);
}
static std::optional<uint64_t> getAddress(const DWARFFormValue &Value) {
auto MaybeResult = Value.getAsAddress();
if (MaybeResult)
return *MaybeResult;
else
return {};
}
static std::optional<uint64_t> getAddress(const DWARFDie &Die) {
// TODO: Add support for DW_AT_pc, which is DWARF 5 Standard version of the
// attribute.
auto Value = Die.find(DW_AT_low_pc);
if (not Value) {
auto Ranges = Die.find(DW_AT_ranges);
if (not Ranges)
return {};
auto Offset = *Ranges->getAsSectionOffset();
auto MaybeRange = Die.getDwarfUnit()->findRnglistFromOffset(Offset);
if (auto Error = MaybeRange.takeError()) {
revng_log(DILogger, "findRnglistFromOffset failed: " << Error);
consumeError(std::move(Error));
return {};
}
// TODO: This is a vector, so we may want to return LowPC from every range
// we found.
return MaybeRange->begin()->LowPC;
} else {
return getAddress(*Value);
}
}
static bool isTrue(const DWARFFormValue &Value) {
return getUnsignedOrSigned(Value) != 0;
}
template<typename S, typename O, typename... A>
void dumpToStream(S &Stream, const O &Object, A... Args) {
std::string Buffer;
{
llvm::raw_string_ostream WrapperStream(Buffer);
Object.dump(WrapperStream, Args...);
}
Stream << Buffer;
}
static void commentDie(const DWARFDie &Die, const Twine &Reason) {
if (DILogger.isEnabled()) {
DILogger << Reason.str();
dumpToStream(DILogger, Die, 0);
DILogger << DoLog;
}
}
static void reportIgnoredDie(const DWARFDie &Die, const Twine &Reason) {
commentDie(Die, "Ignoring DWARF die: " + Reason);
}
class DwarfToModelConverter : public BinaryImporterHelper {
private:
DwarfImporter &Importer;
TupleTree<model::Binary> &Model;
size_t Index;
size_t AltIndex;
size_t TypesWithIdentityCount;
DWARFContext &Context;
std::map<size_t, const model::TypeDefinition *> Placeholders;
std::set<const model::TypeDefinition *> InvalidPrimitives;
std::set<const DWARFDie *> InProgressDies;
public:
DwarfToModelConverter(DwarfImporter &Importer,
DWARFContext &Context,
size_t Index,
size_t AltIndex,
uint64_t PreferredBaseAddress) :
BinaryImporterHelper(*Importer.getModel(), PreferredBaseAddress, DILogger),
Importer(Importer),
Model(Importer.getModel()),
Index(Index),
AltIndex(AltIndex),
Context(Context) {
// When we import DWARF, we assume we already have parsed Segments
processSegments();
BaseAddress = PreferredBaseAddress;
// Ensure the architecture is consistent.
auto Arch = model::Architecture::fromLLVMArchitecture(Context.getArch());
if (Model->Architecture() == model::Architecture::Invalid)
Model->Architecture() = Arch;
// Set default ABI
if (Model->DefaultABI() == model::ABI::Invalid) {
if (auto ABI = model::ABI::getDefaultForELF(Model->Architecture())) {
Model->DefaultABI() = ABI.value();
} else {
auto AName = model::Architecture::getName(Model->Architecture()).str();
revng_abort(("Unsupported architecture for ELF: " + AName).c_str());
}
}
}
private:
model::ABI::Values getABI(CallingConvention CC = DW_CC_normal) const {
if (CC != DW_CC_normal)
return model::ABI::Invalid;
// NOTE: static functions do not always follow the standard calling
// convention which is a problem since `CABIFunctionTypes` we generate
// for them do not correspond to the real functions, leading to
// problems downstream.
// TODO: investigate.
return Model->DefaultABI();
}
const model::UpcastableType &record(const DWARFDie &Die,
model::UpcastableType &&Type,
bool IsNotPlaceholder) {
revng_assert(!Type.isEmpty());
if (not IsNotPlaceholder) {
// `model::UpcastableType::empty()` (as in, no definition) represents
// a primitive placeholder.
Placeholders[Die.getOffset()] = Type->tryGetAsDefinition();
}
return Importer.recordType({ Index, Die.getOffset() }, std::move(Type));
}
enum class TypeSearchResult {
Absent,
PlaceholderType,
RegularType
};
std::pair<TypeSearchResult, model::UpcastableType>
findType(const DWARFDie &Die) {
auto Found = Importer.findType({ Index, Die.getOffset() });
if (Found.isEmpty())
return { TypeSearchResult::Absent, model::UpcastableType::empty() };
else if (Placeholders.contains(Die.getOffset()))
return { TypeSearchResult::PlaceholderType, std::move(Found) };
else
return { TypeSearchResult::RegularType, std::move(Found) };
}
private:
static bool isType(dwarf::Tag Tag) {
switch (Tag) {
case llvm::dwarf::DW_TAG_base_type:
case llvm::dwarf::DW_TAG_typedef:
case llvm::dwarf::DW_TAG_restrict_type:
case llvm::dwarf::DW_TAG_volatile_type:
case llvm::dwarf::DW_TAG_structure_type:
case llvm::dwarf::DW_TAG_union_type:
case llvm::dwarf::DW_TAG_enumeration_type:
case llvm::dwarf::DW_TAG_array_type:
case llvm::dwarf::DW_TAG_const_type:
case llvm::dwarf::DW_TAG_pointer_type:
case llvm::dwarf::DW_TAG_subroutine_type:
return true;
default:
return false;
}
}
static bool hasModelIdentity(dwarf::Tag Tag) {
revng_assert(isType(Tag));
switch (Tag) {
case llvm::dwarf::DW_TAG_base_type:
case llvm::dwarf::DW_TAG_typedef:
case llvm::dwarf::DW_TAG_restrict_type:
case llvm::dwarf::DW_TAG_volatile_type:
case llvm::dwarf::DW_TAG_structure_type:
case llvm::dwarf::DW_TAG_union_type:
case llvm::dwarf::DW_TAG_enumeration_type:
case llvm::dwarf::DW_TAG_subroutine_type:
return true;
case llvm::dwarf::DW_TAG_array_type:
case llvm::dwarf::DW_TAG_const_type:
case llvm::dwarf::DW_TAG_pointer_type:
return false;
default:
revng_abort();
}
}
void createInvalidPrimitivePlaceholder(const DWARFDie &Die) {
auto &&[Definition, Type] = Model->makeTypedefDefinition();
record(Die, std::move(Type), false);
InvalidPrimitives.insert(&Definition);
}
void createType(const DWARFDie &Die) {
auto Tag = Die.getTag();
revng_assert(hasModelIdentity(Tag));
switch (Tag) {
case llvm::dwarf::DW_TAG_base_type: {
uint8_t Size = 0;
model::PrimitiveKind::Values Kind = model::PrimitiveKind::Invalid;
auto MaybeByteSize = Die.find(DW_AT_byte_size);
if (MaybeByteSize)
Size = *MaybeByteSize->getAsUnsignedConstant();
auto MaybeEncoding = Die.find(DW_AT_encoding);
if (MaybeEncoding)
Kind = dwarfEncodingToModel(*MaybeEncoding->getAsUnsignedConstant());
if (Kind == model::PrimitiveKind::Invalid) {
reportIgnoredDie(Die, "Unknown primitive type");
createInvalidPrimitivePlaceholder(Die);
return;
}
if (Size == 0) {
reportIgnoredDie(Die, "Invalid size for primitive type");
createInvalidPrimitivePlaceholder(Die);
return;
}
record(Die, model::PrimitiveType::make(Kind, Size), true);
} break;
case llvm::dwarf::DW_TAG_subroutine_type:
record(Die, Model->makeCABIFunctionDefinition().second, false);
break;
case llvm::dwarf::DW_TAG_typedef:
case llvm::dwarf::DW_TAG_restrict_type:
case llvm::dwarf::DW_TAG_volatile_type:
record(Die, std::move(Model->makeTypedefDefinition().second), false);
break;
case llvm::dwarf::DW_TAG_structure_type:
record(Die, std::move(Model->makeStructDefinition().second), false);
break;
case llvm::dwarf::DW_TAG_union_type:
if (auto MaybeByteSize = Die.find(DW_AT_byte_size);
MaybeByteSize and not Die.hasChildren()) {
// Handle small empty unions, usually due to transparent unions
auto Size = *MaybeByteSize->getAsUnsignedConstant();
record(Die, model::PrimitiveType::makeGeneric(Size), true);
} else {
// Handle regular unions
record(Die, std::move(Model->makeUnionDefinition().second), false);
}
break;
case llvm::dwarf::DW_TAG_enumeration_type:
record(Die, std::move(Model->makeEnumDefinition().second), false);
break;
default:
reportIgnoredDie(Die, "Unexpected type");
}
}
void handleTypeDeclaration(const DWARFDie &Die) {
auto Tag = Die.getTag();
if ((Tag == llvm::dwarf::DW_TAG_structure_type
or Tag == llvm::dwarf::DW_TAG_union_type
or Tag == llvm::dwarf::DW_TAG_enumeration_type)) {
record(Die, model::PrimitiveType::makeVoid(), true);
} else {
reportIgnoredDie(Die,
"Unexpected declaration for tag "
+ llvm::dwarf::TagString(Tag));
}
}
void materializeTypesWithIdentity() {
SmallVector<llvm::DWARFUnit *, 16> CompileUnits;
for (const auto &CU : Context.compile_units())
CompileUnits.push_back(CU.get());
Task T(CompileUnits.size(), "Compile units");
for (llvm::DWARFUnit *CU : CompileUnits) {
T.advance("", true);
SmallVector<llvm::DWARFDebugInfoEntry *, 16> Dies;
for (llvm::DWARFDebugInfoEntry &Entry : CU->dies())
Dies.push_back(&Entry);
for (DWARFDebugInfoEntry *Entry : Dies) {
DWARFDie Die = { CU, Entry };
auto Tag = Die.getTag();
if (isType(Tag) and hasModelIdentity(Tag)) {
auto MaybeDeclaration = Die.find(DW_AT_declaration);
if (MaybeDeclaration && isTrue(*MaybeDeclaration)) {
handleTypeDeclaration(Die);
} else {
createType(Die);
}
}
}
}
TypesWithIdentityCount = Placeholders.size();
}
std::string getName(const DWARFDie &Die) const {
if (auto MaybeName = Die.find(DW_AT_name)) {
auto MaybeString = MaybeName->getAsCString();
if (auto Error = MaybeString.takeError()) {
revng_log(DILogger, "Can't get DIE name: " << Error);
consumeError(std::move(Error));
return {};
} else {
return *MaybeString;
}
} else if (auto MaybeOrigin = Die.find(DW_AT_abstract_origin)) {
DWARFDie Origin = Context.getDIEForOffset(*MaybeOrigin->getAsReference());
return getName(Origin);
} else {
return {};
}
}
static bool isNoReturn(DWARFUnit &CU, const DWARFDie &Die) {
auto Tag = Die.getTag();
revng_assert(Tag == DW_TAG_subprogram);
if (Die.find(DW_AT_noreturn))
return true;
// Check if the specification of this subprogram defines it.
auto SpecificationAttribute = Die.find(DW_AT_specification);
if (SpecificationAttribute) {
if (SpecificationAttribute->getAsReference()) {
auto DieOffset = *(SpecificationAttribute->getAsReference());
DWARFDie SpecificationDie = CU.getDIEForOffset(DieOffset);
if (SpecificationDie.find(DW_AT_noreturn))
return true;
}
}
return false;
}
RecursiveCoroutine<model::UpcastableType> makeType(const DWARFDie &Die) {
if (auto Type = Die.find(DW_AT_type)) {
if (Type->getForm() == llvm::dwarf::DW_FORM_GNU_ref_alt) {
rc_return Importer.findType({ AltIndex, Type->getRawUValue() }).copy();
} else {
DWARFDie InnerDie = Context.getDIEForOffset(*Type->getAsReference());
rc_return rc_recur resolveType(InnerDie, false);
}
} else if (auto MaybeOrigin = Die.find(DW_AT_abstract_origin)) {
DWARFDie Origin = Context.getDIEForOffset(*MaybeOrigin->getAsReference());
rc_return rc_recur makeType(Origin);
} else {
rc_return model::UpcastableType::empty();
}
}
RecursiveCoroutine<model::UpcastableType>
makeTypeOrVoid(const DWARFDie &Die) {
if (model::UpcastableType Result = rc_recur makeType(Die))
rc_return Result;
else
rc_return model::PrimitiveType::makeVoid();
}
RecursiveCoroutine<void>
resolveTypeWithIdentity(const DWARFDie &Die, model::UpcastableType &Type) {
using namespace model;
auto Offset = Die.getOffset();
auto Tag = Die.getTag();
revng_assert(Placeholders.contains(Offset));
std::string Name = getName(Die);
model::TypeDefinition &Definition = *Type->tryGetAsDefinition();
if (InvalidPrimitives.contains(&Definition))
rc_return;
switch (Tag) {
case llvm::dwarf::DW_TAG_subroutine_type: {
auto &FunctionType = cast<model::CABIFunctionDefinition>(Definition);
FunctionType.Name() = Name;
FunctionType.ABI() = getABI();
if (FunctionType.ABI() == model::ABI::Invalid) {
reportIgnoredDie(Die, "Unknown calling convention");
rc_return;
}
FunctionType.ReturnType() = rc_recur makeType(Die);
uint64_t Index = 0;
for (const DWARFDie &ChildDie : Die.children()) {
if (ChildDie.getTag() == DW_TAG_formal_parameter) {
model::UpcastableType ArgumentType = rc_recur makeType(ChildDie);
if (ArgumentType.isEmpty()) {
reportIgnoredDie(Die,
"The type of argument " + Twine(++Index)
+ " cannot be resolved");
rc_return;
}
// Note: at this stage we don't check the size. If an argument is
// unsized, the function will be purged later on.
FunctionType.addArgument(std::move(ArgumentType));
}
}
} break;
case llvm::dwarf::DW_TAG_typedef:
case llvm::dwarf::DW_TAG_restrict_type:
case llvm::dwarf::DW_TAG_volatile_type: {
auto &Typedef = cast<model::TypedefDefinition>(Definition);
Typedef.Name() = Name;
Typedef.UnderlyingType() = rc_recur makeTypeOrVoid(Die);
} break;
case llvm::dwarf::DW_TAG_structure_type: {
auto MaybeSize = Die.find(DW_AT_byte_size);
if (not MaybeSize) {
reportIgnoredDie(Die, "Struct has no size");
rc_return;
}
auto &Struct = cast<model::StructDefinition>(Definition);
Struct.Name() = Name;
Struct.Size() = *MaybeSize->getAsUnsignedConstant();
uint64_t Index = 0;
for (const DWARFDie &ChildDie : Die.children()) {
if (ChildDie.getTag() == DW_TAG_member) {
// Collect offset
auto MaybeOffset = ChildDie.find(DW_AT_data_member_location);
if (not MaybeOffset) {
reportIgnoredDie(ChildDie, "Struct field has no offset");
continue;
}
auto Offset = *MaybeOffset->getAsUnsignedConstant();
if (ChildDie.find(DW_AT_bit_size)) {
reportIgnoredDie(ChildDie, "Ignoring bitfield in struct");
continue;
}
model::UpcastableType MemberType = rc_recur makeType(ChildDie);
if (MemberType.isEmpty()) {
reportIgnoredDie(Die,
"The type of member " + Twine(Index + 1)
+ " cannot be resolved");
rc_return;
}
// Create new field
auto &Field = Struct.Fields()[Offset];
Field.Name() = getName(ChildDie);
Field.Type() = std::move(MemberType);
++Index;
}
}
if (Index == 0) {
reportIgnoredDie(Die, "Struct has no fields");
rc_return;
}
} break;
case llvm::dwarf::DW_TAG_union_type: {
auto &Union = cast<model::UnionDefinition>(Definition);
Union.Name() = Name;
for (const DWARFDie &ChildDie : Die.children()) {
if (ChildDie.getTag() == DW_TAG_member) {
model::UpcastableType MemberType = rc_recur makeType(ChildDie);
if (MemberType.isEmpty()) {
reportIgnoredDie(Die,
"The type of one of the fields cannot be "
"resolved");
rc_return;
}
// Create new field
auto &Field = Union.addField(std::move(MemberType));
Field.Name() = getName(ChildDie);
}
}
if (Union.Fields().empty()) {
reportIgnoredDie(Die, "Union has no fields");
rc_return;
}
} break;
case llvm::dwarf::DW_TAG_enumeration_type: {
auto &Enum = llvm::cast<model::EnumDefinition>(Definition);
Enum.Name() = Name;
const model::UpcastableType UnderlyingType = rc_recur makeType(Die);
if (UnderlyingType.isEmpty()) {
reportIgnoredDie(Die, "The enum underlying type cannot be resolved");
rc_return;
}
Enum.UnderlyingType() = std::move(UnderlyingType);
uint64_t Index = 0;
for (const DWARFDie &ChildDie : Die.children()) {
if (ChildDie.getTag() == DW_TAG_enumerator) {
// Collect value
auto MaybeValue = getUnsignedOrSigned(ChildDie, DW_AT_const_value);
if (not MaybeValue) {
reportIgnoredDie(ChildDie,
"Ignoring enum entry " + Twine(Index + 1)
+ " without a value");
rc_return;
}
uint64_t Value = *MaybeValue;
// Create new entry
std::string EntryName = getName(ChildDie);
// If it's the first time, set the name
auto *It = Enum.Entries().tryGet(Value);
if (It == nullptr) {
auto &Entry = Enum.Entries()[Value];
Entry.Name() = EntryName;
} else {
// Ignore aliases
}
++Index;
}
}
} break;
default:
reportIgnoredDie(Die, "Unknown type");
rc_return;
}
Placeholders.erase(Offset);
rc_return;
}
RecursiveCoroutine<model::UpcastableType>
resolveType(const DWARFDie &Die, bool ResolveIfHasIdentity) {
// Ensure there are no loops in the dies we're exploring
using ScopedSetElement = ScopedSetElement<decltype(InProgressDies)>;
ScopedSetElement InProgressDie(InProgressDies, &Die);
if (not InProgressDie.insert()) {
reportIgnoredDie(Die, "Recursive die");
rc_return model::UpcastableType::empty();
}
auto Tag = Die.getTag();
auto &&[SearchResult, Type] = findType(Die);
switch (SearchResult) {
case TypeSearchResult::Absent: {
// At this stage, all the type definitions (as in, types with an identity
// in the model) should have been materialized.
// Therefore, here we only deal with DWARF types the model represents as
// by nesting.
/// \note There could be some TAGs we do not handle/recognize as types.
if (isType(Tag))
revng_assert(not hasModelIdentity(Tag));
bool HasType = Die.find(DW_AT_type).has_value();
model::UpcastableType Result = rc_recur makeTypeOrVoid(Die);
switch (Tag) {
case llvm::dwarf::DW_TAG_const_type: {
revng_assert(Result->IsConst() == false);
Result->IsConst() = true;
} break;
case llvm::dwarf::DW_TAG_array_type: {
if (not HasType) {
reportIgnoredDie(Die, "Array does not specify element type");
rc_return model::UpcastableType::empty();
}
for (const DWARFDie &ChildDie : Die.children()) {
if (ChildDie.getTag() == llvm::dwarf::DW_TAG_subrange_type) {
auto MaybeUpperBound = getUnsignedOrSigned(ChildDie,
DW_AT_upper_bound);
auto MaybeCount = getUnsignedOrSigned(ChildDie, DW_AT_count);
if (MaybeUpperBound and MaybeCount
and *MaybeUpperBound != *MaybeCount + 1) {
reportIgnoredDie(Die, "DW_AT_upper_bound != DW_AT_count + 1");
rc_return model::UpcastableType::empty();
}
if (MaybeUpperBound) {
Result = model::ArrayType::make(std::move(Result),
*MaybeUpperBound + 1);
} else if (MaybeCount) {
Result = model::ArrayType::make(std::move(Result), *MaybeCount);
} else {
reportIgnoredDie(Die,
"Array upper bound/elements count missing or "
"invalid");
rc_return model::UpcastableType::empty();
}
}
}
} break;
case llvm::dwarf::DW_TAG_pointer_type: {
auto MaybeByteSize = Die.find(DW_AT_byte_size);
if (not MaybeByteSize) {
// TODO: force architecture pointer size
reportIgnoredDie(Die, "Pointer has no size");
rc_return model::UpcastableType::empty();
}
uint64_t PointerSize = *MaybeByteSize->getAsUnsignedConstant();
Result = model::PointerType::make(std::move(Result), PointerSize);
} break;
default:
reportIgnoredDie(Die, "Unknown type");
rc_return model::UpcastableType::empty();
}
rc_return record(Die, std::move(Result), true).copy();
}
case TypeSearchResult::PlaceholderType: {
if (Type.isEmpty()) {
reportIgnoredDie(Die, "Couldn't materialize type");
rc_return model::UpcastableType::empty();
}
revng_assert(Placeholders.contains(Die.getOffset()));
// This die is already present in the map. Either it has already been
// fully imported, or it's a type with an identity on the model.
// In the latter case, proceed only if explicitly told to do so.
if (ResolveIfHasIdentity)
rc_recur resolveTypeWithIdentity(Die, Type);
rc_return std::move(Type);
}
case TypeSearchResult::RegularType:
if (Type.isEmpty()) {
reportIgnoredDie(Die, "Couldn't materialize type");
rc_return model::UpcastableType::empty();
}
rc_return std::move(Type);
default:
revng_abort();
}
}
void resolveAllTypes() {
for (const auto &CU : Context.compile_units()) {
for (const auto &Entry : CU->dies()) {
DWARFDie Die = { CU.get(), &Entry };
if (not isType(Die.getTag()))
continue;
resolveType(Die, true);
}
}
}
model::UpcastableType getSubprogramPrototype(const DWARFDie &Die) {
// Create function type
auto NewType = model::makeTypeDefinition<model::CABIFunctionDefinition>();
auto &FunctionType = cast<model::CABIFunctionDefinition>(*NewType.get());
// Detect ABI
CallingConvention CC = DW_CC_normal;
auto MaybeCC = getUnsignedOrSigned(Die, DW_AT_calling_convention);
if (MaybeCC)
CC = static_cast<CallingConvention>(*MaybeCC);
FunctionType.ABI() = getABI(CC);
if (FunctionType.ABI() == model::ABI::Invalid) {
reportIgnoredDie(Die, "Unknown calling convention");
return model::UpcastableType::empty();
}
// Arguments
uint64_t Index = 0;
for (const DWARFDie &ChildDie : Die.children()) {
if (ChildDie.getTag() == DW_TAG_formal_parameter) {
model::UpcastableType ArgumentType = makeType(ChildDie);
if (ArgumentType.isEmpty()) {
reportIgnoredDie(Die,
"The type of argument " + Twine(++Index)
+ " cannot be resolved");
return model::UpcastableType::empty();
}
// Note: at this stage we don't check the size. If an argument is
// unsized, the function will be purged later on.
model::Argument &A = FunctionType.addArgument(std::move(ArgumentType));
A.Name() = getName(ChildDie);
}
}
// Return type
FunctionType.ReturnType() = makeType(Die);
return Model->recordNewType(std::move(NewType)).second;
}
void createFunctions() {
revng_log(DILogger, "Creating functions");
for (const auto &CU : Context.compile_units()) {
for (const auto &Entry : CU->dies()) {
DWARFDie Die = { CU.get(), &Entry };
if (Die.getTag() != DW_TAG_subprogram)
continue;
auto &Functions = Model->ImportedDynamicFunctions();
model::UpcastableType Prototype = getSubprogramPrototype(Die);
std::string SymbolName = getName(Die);
MetaAddress LowPC;
if (auto MaybeLowPC = getAddress(Die)) {
// TODO: do a proper check to see if it's in a valid segment
if (*MaybeLowPC != 0)
LowPC = relocate(fromPC(*MaybeLowPC));
}
if (LowPC.isValid()) {
revng_log(DILogger,
"Found a subprogram with LowPC "
<< LowPC.toString() << " and name \"" << SymbolName
<< "\"");
// Get/create the local function
if (auto *Function = registerFunctionEntry(LowPC)) {
if (Prototype.isEmpty())
revng_log(DILogger, "Can't get the prototype");
else if (not Function->prototype())
Function->Prototype() = std::move(Prototype);
if (SymbolName.size() != 0) {
Function->ExportedNames().insert(SymbolName);
if (Function->Name().size() == 0)
Function->Name() = SymbolName;
}
if (isNoReturn(*CU.get(), Die))
Function->Attributes().insert(model::FunctionAttribute::NoReturn);
}
} else if (not SymbolName.empty() and Functions.contains(SymbolName)) {
// It's a dynamic function
if (Prototype.isEmpty()) {
reportIgnoredDie(Die, "Couldn't build subprogram prototype");
continue;
}
// Get/create dynamic function
auto &DynamicFunction = Model->ImportedDynamicFunctions()[SymbolName];
// If a function already has a valid prototype, don't override it
if (DynamicFunction.prototype() != nullptr)
continue;
const model::TypeDefinition &Def = *Prototype->tryGetAsDefinition();
revng_assert(isa<model::CABIFunctionDefinition>(Def));
DynamicFunction.Prototype() = std::move(Prototype);
if (isNoReturn(*CU.get(), Die)) {
using namespace model;
DynamicFunction.Attributes().insert(FunctionAttribute::NoReturn);
}
} else {
reportIgnoredDie(Die, "Ignoring subprogram");
}
}
}
}
void purgeUnresolvedPlaceholders() {
std::set<const model::TypeDefinition *> ToDrop;
for (auto &&[_, Type] : Placeholders)
ToDrop.insert(Type);
unsigned DroppedTypes = dropTypesDependingOnDefinitions(Model, ToDrop);
if (DroppedTypes > 0) {
revng_log(DILogger,
"Purging " << DroppedTypes << " types (out of "
<< TypesWithIdentityCount << ") due to "
<< Placeholders.size() << " unresolved types");
}
Placeholders.clear();
}
public:
void run() {
Task T(10, "Importing DWARF");
T.advance("Materialize types with an identity", true);
materializeTypesWithIdentity();
T.advance("Resolve types", true);
resolveAllTypes();
T.advance("Create model functions", true);
createFunctions();
T.advance("Remove types that depend on unresolved placeholders", true);
purgeUnresolvedPlaceholders();
T.advance("Remove types that couldn't be imported fully", true);
purgeInvalidTypes(Model);
T.advance("Flatten primitive typedefs", true);
model::flattenPrimitiveTypedefs(Model);
T.advance("Deduplicate equivalent types", true);
deduplicateEquivalentTypes(Model);
T.advance("Deduplicate colliding names", true);
model::deduplicateCollidingNames(Model);
T.advance("Purge unnamed unreachable types", true);
purgeUnnamedAndUnreachableTypes(Model);
T.advance("Verify the model", true);
Model->verify(true);
}
};
template<typename T>
ArrayRef<uint8_t> getSectionsContents(StringRef Name, T &ELF) {
auto MaybeSections = ELF.sections();
if (auto Error = MaybeSections.takeError()) {
revng_log(DILogger, "Failed to get sections: " << Error);
consumeError(std::move(Error));
return {};
}
for (const auto &Section : *MaybeSections) {
auto MaybeName = expectedToOptional(ELF.getSectionName(Section));
if (MaybeName and *MaybeName == Name) {
auto MaybeContents = expectedToOptional(ELF.getSectionContents(Section));
if (MaybeContents)
return *MaybeContents;
}
}
return {};
}
static std::string getBuildID(const object::Binary *B) {
using namespace llvm::object;
auto Handler = [&](auto *ELFObject) -> std::string {
const auto &ELF = ELFObject->getELFFile();
ArrayRef<uint8_t> Contents = getSectionsContents(".note.gnu.build-id", ELF);
if (Contents.size() == 0)
return {};
std::string StringForBytes;
raw_string_ostream OutputStream(StringForBytes);
for (uint8_t Byte : Contents)
OutputStream << format_hex_no_prefix(Byte, 2);
// Build ID uses SHA1, so it is 20 bytes long.
constexpr unsigned SHA1Size = 40;
return OutputStream.str().substr(OutputStream.str().size() - SHA1Size);
};
std::string BuildID;
if (auto *ELF = dyn_cast<ELF32BEObjectFile>(B)) {
BuildID = Handler(ELF);
} else if (auto *ELF = dyn_cast<ELF64BEObjectFile>(B)) {
BuildID = Handler(ELF);
} else if (auto *ELF = dyn_cast<ELF32LEObjectFile>(B)) {
BuildID = Handler(ELF);
} else if (auto *ELF = dyn_cast<ELF64LEObjectFile>(B)) {
BuildID = Handler(ELF);
} else {
revng_abort();
}
return BuildID;
}
static StringRef getDebugFileName(const object::Binary *B) {
using namespace llvm::object;
// TODO: Handle Split DWARF/DW_AT_GNU_dwo_name. Part of DWARF 5.
auto Handler = [&](auto *ELFObject) -> StringRef {
const auto &ELF = ELFObject->getELFFile();
ArrayRef<uint8_t> Contents = getSectionsContents(".gnu_debuglink", ELF);
if (Contents.size() == 0) {
// If there is no ".gnu_debuglink", try ".gnu_debugaltlink".
Contents = getSectionsContents(".gnu_debugaltlink", ELF);
}
if (Contents.size() == 0) {
// TODO: Handle .debug_sup, which is DWARF 5 implementation of GNU
// extension .gnu_debuglink sections.
return {};
}
// TODO: improve accuracy
// Extract path name and ignore everything after \0
return StringRef(reinterpret_cast<const char *>(Contents.data()));
};
StringRef AltDebugLinkPath;
if (auto *ELF = dyn_cast<ELF32BEObjectFile>(B)) {
AltDebugLinkPath = Handler(ELF);
} else if (auto *ELF = dyn_cast<ELF64BEObjectFile>(B)) {
AltDebugLinkPath = Handler(ELF);
} else if (auto *ELF = dyn_cast<ELF32LEObjectFile>(B)) {
AltDebugLinkPath = Handler(ELF);
} else if (auto *ELF = dyn_cast<ELF64LEObjectFile>(B)) {
AltDebugLinkPath = Handler(ELF);
} else {
revng_abort();
}
return llvm::sys::path::filename(AltDebugLinkPath);
}
static bool fileExists(const Twine &Path) {
bool Result = sys::fs::exists(Path);
if (Result) {
revng_log(DILogger, "Found: " << Path.str());
} else {
revng_log(DILogger, "The following path does not exist: " << Path.str());
}
return Result;
}
static std::optional<std::string>
findDebugInfoFileByName(StringRef FileName,
StringRef DebugFileName,
llvm::object::ObjectFile *ELF) {
revng_log(DILogger,
"Looking for \"" << DebugFileName << "\" for " << FileName << "\"");
LoggerIndent<> Indent(DILogger);
// Let's find it in canonical places, where debug info was fetched.
// 1) Look for a .gnu_debuglink/.gnu_debugaltlink/.debug_sup section.
// The .debug file should be in canonical places.
// E.g., if the executable is `/usr/bin/ls`, we look for:
// - /usr/bin/ls.debug (current dir of exe)
// - /usr/bin/.debug/ls.debug
// - /usr/lib/debug/usr/bin/ls.debug
llvm::SmallString<128> ResultPath;
if (llvm::sys::path::has_parent_path(FileName)) {
llvm::sys::path::append(ResultPath,
llvm::sys::path::parent_path(FileName),
DebugFileName);
} else {
llvm::sys::path::append(ResultPath, DebugFileName);
}
if (fileExists(ResultPath.str())) {
return std::string(ResultPath.str());
} else {
// Try in .debug/ directory.
ResultPath.clear();
llvm::sys::path::append(ResultPath,
llvm::sys::path::parent_path(FileName),
".debug/",
DebugFileName);
if (fileExists(ResultPath.str())) {
return std::string(ResultPath.str());
} else {
// Try `/usr/lib/debug/usr/bin/ls.debug`-like path.
ResultPath.clear();
if (sys::path::is_absolute(FileName)) {
llvm::sys::path::append(ResultPath,
GlobalDebugDirectory,
llvm::sys::path::parent_path(FileName),
DebugFileName);
} else {
// Relative path.
llvm::SmallString<64> CurrentDirectory;
auto ErrorCode = llvm::sys::fs::current_path(CurrentDirectory);
if (!ErrorCode) {
llvm::sys::path::append(ResultPath,
GlobalDebugDirectory,
CurrentDirectory,
llvm::sys::path::parent_path(FileName),
DebugFileName);
} else {
revng_log(DILogger, "Can't get current working path.");
}
}
if (fileExists(ResultPath.str())) {
return std::string(ResultPath.str());
} else {
// Try If build-id is `abcdef1234`, we look for:
// - /usr/lib/debug/.build-id/ab/cdef1234.debug
ResultPath.clear();
auto BuildID = getBuildID(ELF);
if (BuildID.size()) {
// First two chars of build-id forms the debug info file directory.
auto DebugDir = BuildID.substr(0, 2);
// The rest of build-id forms the debug info file name.
auto DebugFile = BuildID.substr(BuildID.size() - 38);
auto DebugFileWithExtension = DebugFile.append(".debug");
llvm::sys::path::append(ResultPath,
GlobalDebugDirectory,
".build-id/",
DebugDir,
DebugFileWithExtension);
if (fileExists(ResultPath.str())) {
return std::string(ResultPath.str());
}
// Try in CacheDirectory at the end.
ResultPath.clear();
std::string CacheDir = getCacheDirectory();
ResultPath = joinPath(CacheDir,
"debug-symbols",
"elf",
BuildID,
"debug");
if (fileExists(ResultPath.str())) {
return ResultPath.str().str();
}
revng_log(DILogger, "Can't find " << DebugFileName);
} else {
revng_log(DILogger, "Can't parse build-id.");
}
}
}
}
// We have not found the debug info file on the device.
return std::nullopt;
}
void DwarfImporter::import(StringRef FileName, const ImporterOptions &Options) {
revng_log(DILogger,
"Importing DWARF information for "
<< llvm::sys::path::filename(FileName));
LoggerIndent<> Indent(DILogger);
Task T(3,
"Importing DWARF information for "
+ llvm::sys::path::filename(FileName));
T.advance("Fetching debug info", true);
using namespace llvm::object;
ErrorOr<std::unique_ptr<MemoryBuffer>>
MaybeBuffer = MemoryBuffer::getFileOrSTDIN(FileName);
if (not MaybeBuffer) {
revng_log(DILogger,
"Couldn't open file " << FileName << " "
<< MaybeBuffer.getError().message());
return;
}
std::unique_ptr<MemoryBuffer> Buffer = std::move(MaybeBuffer.get());
Expected<std::unique_ptr<Binary>> MaybeBinary = object::createBinary(*Buffer);
if (auto Error = MaybeBinary.takeError()) {
revng_log(DILogger, "Couldn't load binary: " << Error);
consumeError(std::move(Error));
return;
}
// Find Debugging Information.
// If the file has debug info sections within itself, no need for finding
// it on the device.
// TODO: When we add support for Split DWARF, this will need additional
// improvement.
auto HasDebugInfo = [](ObjectFile *Object) {
for (const SectionRef &Section : Object->sections()) {
StringRef SectionName;
if (Expected<StringRef> NameOrErr = Section.getName()) {
SectionName = *NameOrErr;
} else {
llvm::consumeError(NameOrErr.takeError());
continue;
}
// TODO: When adding support for Split dwarf, there will be
// .debug_info.dwo section, so we need to handle it.
if (SectionName == ".debug_info")
return true;
}
return false;
};
auto PerformImport = [this, &T, &Options](StringRef FilePath,
StringRef TheDebugFile) {
auto ExpectedBinary = object::createBinary(FilePath);
if (!ExpectedBinary) {
revng_log(DILogger, "Can't create binary for " << FilePath);
llvm::consumeError(ExpectedBinary.takeError());
} else {
revng_log(DILogger, "Importing " << TheDebugFile.str());
T.advance("Parsing detached debug info file "
+ llvm::sys::path::filename(TheDebugFile),
true);
import(*ExpectedBinary->getBinary(), TheDebugFile, Options.BaseAddress);
}
};
if (auto *ELF = dyn_cast<ObjectFile>(MaybeBinary->get())) {
if (Options.DebugInfo != DebugInfoLevel::No && !HasDebugInfo(ELF)) {
// There are no .debug_* sections in the file itself, let's try to find it
// on the device, otherwise find it on web by using the `fetch-debuginfo`
// tool.
std::string DebugFile = getDebugFileName(MaybeBinary->get()).str();
if (!DebugFile.size()) {
DebugFile = (llvm::sys::path::filename(FileName) + ".debug").str();
revng_log(DILogger,
"Can't find file name of the debug file, using "
<< DebugFile);
}
auto DebugFilePath = findDebugInfoFileByName(FileName, DebugFile, ELF);
if (!DebugFilePath) {
if (!::Runner.isProgramAvailable("revng")) {
revng_log(DILogger,
"Can't find `revng` binary to run `fetch-debuginfo`.");
return;
}
int ExitCode = runFetchDebugInfo(FileName, DILogger.isEnabled());
if (ExitCode != 0) {
revng_log(DILogger,
"Failed to find debug info with `revng model "
"fetch-debuginfo`.");
} else {
DebugFilePath = findDebugInfoFileByName(FileName, DebugFile, ELF);
if (DebugFilePath)
PerformImport(*DebugFilePath, DebugFile);
}
} else {
PerformImport(*DebugFilePath, DebugFile);
}
}
}
T.advance("Parsing debug info in the binary itself", true);
import(*MaybeBinary->get(), FileName, Options.BaseAddress);
}
auto zipPairs(auto &&R) {
auto BeginIt = R.begin();
auto EndIt = R.end();
if (BeginIt == EndIt)
return zip(make_range(EndIt, EndIt), make_range(EndIt, EndIt));
auto First = BeginIt;
auto Second = ++BeginIt;
if (Second == EndIt)
return zip(make_range(EndIt, EndIt), make_range(EndIt, EndIt));
auto End = EndIt;
auto Last = --EndIt;
return zip(make_range(First, Last), make_range(Second, End));
}
/// This function considers all symbols with name of type STT_FUNC and clusters
/// them by address/type
static EquivalenceClasses<StringRef>
computeEquivalentSymbols(const llvm::object::ObjectFile &ELF) {
using namespace llvm::object;
EquivalenceClasses<StringRef> Result;
struct SymbolDescriptor {
uint64_t Address = 0;
// TODO: one day we will want to consider STT_OBJECT too
SymbolRef::Type Type = SymbolRef::ST_Unknown;
/// \note we ignore this field for comparison purposes
StringRef Name;
auto key() const { return std::tie(Address, Type); }
bool operator<(const SymbolDescriptor &Other) const {
return key() < Other.key();
}
bool operator==(const SymbolDescriptor &Other) const {
return key() == Other.key();
}
};
std::vector<SymbolDescriptor> Symbols;
for (const object::SymbolRef &Symbol : ELF.symbols()) {
SymbolDescriptor NewSymbol;
auto MaybeType = Symbol.getType();
auto MaybeAddress = Symbol.getAddress();
auto MaybeName = Symbol.getName();
auto MaybeFlags = Symbol.getFlags();
if (auto Error = MaybeType.takeError()) {
consumeError(std::move(Error));
continue;
} else if (auto Error = MaybeAddress.takeError()) {
consumeError(std::move(Error));
continue;
} else if (auto Error = MaybeName.takeError()) {
consumeError(std::move(Error));
continue;
} else if (auto Error = MaybeFlags.takeError()) {
consumeError(std::move(Error));
continue;
}
// Ignore unnamed and nullptr symbols
if (MaybeName->size() == 0 or *MaybeAddress == 0)
continue;
// Consider only STT_FUNC symbols
if (*MaybeType != SymbolRef::ST_Function)
continue;
// Consider only global symbols
if (!((*MaybeFlags) & SymbolRef::SF_Global))
continue;
Symbols.push_back({ *MaybeAddress, *MaybeType, *MaybeName });
}
llvm::sort(Symbols);
for (const auto &[Previous, Current] : zipPairs(Symbols))
if (Previous == Current)
Result.unionSets(Previous.Name, Current.Name);
return Result;
}
// TODO: it would be beneficial to do this even at other levels
inline void detectAliases(const llvm::object::ObjectFile &ELF,
TupleTree<model::Binary> &Model) {
EquivalenceClasses<StringRef> Aliases = computeEquivalentSymbols(ELF);
auto &ImportedDynamicFunctions = Model->ImportedDynamicFunctions();
auto &Functions = Model->Functions();
std::unordered_map<std::string, model::Function *> FunctionsByName;
// Map functions by names, so we have faster lookup below.
for (auto &Function : Functions) {
if (Function.Name().size()) {
FunctionsByName[Function.Name()] = &Function;
}
}
for (auto AliasesIt = Aliases.begin(), E = Aliases.end(); AliasesIt != E;
++AliasesIt) {
llvm::SmallVector<std::string, 4> CurrentAliases;
if (AliasesIt->isLeader()) {
SmallVector<std::string, 4> UnprototypedFunctionsNames;
model::UpcastableType Prototype;
for (auto AliasSetIt = Aliases.member_begin(AliasesIt);
AliasSetIt != Aliases.member_end();
++AliasSetIt) {
std::string Name = AliasSetIt->str();
if (Name.size() == 0)
continue;
CurrentAliases.push_back(Name);
// Create DynamicFunction, if it doesn't exist already
auto It = ImportedDynamicFunctions.tryGet(Name);
bool Found = It != nullptr;
// If DynamicFunction doesn't have a prototype, register it for copying
// it from the leader.
// Otherwise, record the type as the leader.
if (Found and not It->Prototype().isEmpty()) {
Prototype = It->Prototype().copy();
} else {
UnprototypedFunctionsNames.push_back(Name);
}
}
// Check if we should add an ExportedName for local Functions.
llvm::SmallVector<std::string, 4> PotentialExportedNamesToBeAdded;
bool IsLocalFunction = false;
model::Function *TheFunction = nullptr;
for (auto &Name : CurrentAliases) {
auto It = FunctionsByName.find(Name);
PotentialExportedNamesToBeAdded.push_back(Name);
if (It != FunctionsByName.end()) {
// We found a local function.
// TODO: In some situations Name is not in the ExportedNames?
// For example in the case of importing `__libc_calloc` from
// libc.so.6.
TheFunction = It->second;
}
}
// It is a local function. Populate the ExportedNames.
if (TheFunction) {
for (auto &Name : PotentialExportedNamesToBeAdded)
TheFunction->ExportedNames().insert(Name);
continue;
}
// Consider it as a Dynamic function.
if (not Prototype.isEmpty()) {
for (const std::string &Name : UnprototypedFunctionsNames) {
auto It = ImportedDynamicFunctions.find(Name);
if (It == ImportedDynamicFunctions.end())
It = ImportedDynamicFunctions.insert({ Name }).first;
It->Prototype() = std::move(Prototype);
}
}
}
}
}
void DwarfImporter::import(const llvm::object::Binary &TheBinary,
StringRef FileName,
uint64_t PreferredBaseAddress) {
using namespace llvm::object;
if (auto *ELF = dyn_cast<ELFObjectFileBase>(&TheBinary)) {
{
using namespace model::Architecture;
if (Model->Architecture() == Invalid)
Model->Architecture() = fromLLVMArchitecture(ELF->getArch());
}
if (ELF->getEType() != ELF::ET_DYN)
PreferredBaseAddress = 0;
// Check if we already loaded the alt debug info file
size_t AltIndex = -1;
// Check if we already loaded the alt debug info file.
StringRef SeparateDebugFileName = getDebugFileName(ELF);
if (SeparateDebugFileName.size() > 0) {
auto Begin = LoadedFiles.begin();
auto End = LoadedFiles.end();
auto It = std::find(Begin, End, SeparateDebugFileName);
if (It != End)
AltIndex = It - Begin;
}
auto TheDWARFContext = DWARFContext::create(*ELF);
DwarfToModelConverter Converter(*this,
*TheDWARFContext,
LoadedFiles.size(),
AltIndex,
PreferredBaseAddress);
Converter.run();
detectAliases(*ELF, Model);
}
LoadedFiles.push_back(sys::path::filename(FileName).str());
}
Reference in New Issue View Git Blame Copy Permalink