C++¶

Note

You can also find the Doxygen documentation here: here

inline std::unique_ptr<DebugInfo> LIEF::dwarf::load(const std::string &dwarf_path)¶: Load DWARF file from the given path.

DebugInfo¶

class DebugInfo : public LIEF::DebugInfo ¶

This class represents a DWARF debug information. It can embed different compilation units which can be accessed through compilation_units() .

This class can be instantiated from LIEF::Binary::debug_info() or load()

Public Types

using compilation_units_it = iterator_range<CompilationUnit::Iterator>¶: Iterator over the CompilationUnit.

Public Functions

std::unique_ptr<Function> find_function(const std::string &name) const¶

Try to find the function with the given name (mangled or not).

const DebugInfo& info = ...;
if (auto func = info.find_function("_ZNSt6localeD1Ev")) {
  // Found
}
if (auto func = info.find_function("std::locale::~locale()")) {
  // Found
}

std::unique_ptr<Function> find_function(uint64_t addr) const¶: Try to find the function at the given virtual address.

std::unique_ptr<Variable> find_variable(const std::string &name) const¶: Try to find the variable with the given name. This name can be mangled or not.

std::unique_ptr<Variable> find_variable(uint64_t addr) const¶: Try to find the variable at the given virtual address.

std::unique_ptr<Type> find_type(const std::string &name) const¶: Try to find the type with the given name.

compilation_units_it compilation_units() const¶: Iterator on the CompilationUnit embedded in this dwarf.

virtual std::optional<uint64_t> find_function_address(const std::string &name) const override¶: Attempt to resolve the address of the function specified by name.

inline virtual FORMAT format() const override¶

virtual ~DebugInfo() override = default¶

DebugInfo(std::unique_ptr<details::DebugInfo> impl)¶

Public Static Functions

static std::unique_ptr<DebugInfo> from_file(const std::string &path)¶

static inline bool classof(const LIEF::DebugInfo *info)¶

CompilationUnit¶

class CompilationUnit¶

This class represents a DWARF compilation unit.

Public Types

using functions_it = iterator_range<Function::Iterator>¶: Iterator over the dwarf::Function.

using types_it = iterator_range<Type::Iterator>¶: Iterator over the dwarf::Type.

using vars_it = iterator_range<Variable::Iterator>¶: Iterator over the CompilationUnit’s variables.

Public Functions

CompilationUnit(std::unique_ptr<details::CompilationUnit> impl)¶

~CompilationUnit()¶

std::string name() const¶

Name of the file associated with this compilation unit (e.g. test.cpp) Return an empty string if the name is not found or can’t be resolved.

This value matches the DW_AT_name attribute

std::string producer() const¶

Information about the program (or library) that generated this compilation unit. For instance, it can output: Debian clang version 17.0.6.

It returns an empty string if the producer is not present or can’t be resolved

This value matches the DW_AT_producer attribute

std::string compilation_dir() const¶

Return the path to the directory in which the compilation took place for compiling this compilation unit (e.g. /workdir/build).

It returns an empty string if the entry is not present or can’t be resolved

This value matches the DW_AT_comp_dir attribute

Language language() const¶

Original language of this compilation unit.

This value matches the DW_AT_language attribute.

uint64_t low_address() const¶: Return the lowest virtual address owned by this compilation unit.

uint64_t high_address() const¶: Return the highest virtual address owned by this compilation unit.

uint64_t size() const¶

Return the size of the compilation unit according to its range of address.

If the compilation is fragmented (i.e. there are some address ranges between the lowest address and the highest that are not owned by the CU), then it returns the sum of all the address ranges owned by this CU.

If the compilation unit is not fragmented, then it basically returns high_address - low_address.

std::vector<range_t> ranges() const¶

Return a list of address ranges owned by this compilation unit.

If the compilation unit owns a contiguous range, it should return a single range.

std::unique_ptr<Function> find_function(const std::string &name) const¶

Try to find the function whose name is given in parameter.

The provided name can be demangled

std::unique_ptr<Function> find_function(uint64_t addr) const¶: Try to find the function at the given address.

std::unique_ptr<Variable> find_variable(uint64_t addr) const¶: Try to find the Variable at the given address.

std::unique_ptr<Variable> find_variable(const std::string &name) const¶: Try to find the Variable with the given name.

functions_it functions() const¶

Return an iterator over the functions implemented in this compilation unit.

Note that this iterator only iterates over the functions that have a concrete implementation in the compilation unit.

For instance with this code:

inline const char* get_secret_env() {
  return getenv("MY_SECRET_ENV");
}

int main() {
  printf("%s", get_secret_env());
  return 0;
}

The iterator will only return one function for main since get_secret_env is inlined and thus, its implementation is located in main.

functions_it imported_functions() const¶

Return an iterator over the functions imported in this compilation unit but not implemented.

For instance with this code:

#include <cstdio>
int main() {
  printf("Hello\n");
  return 0;
}

printf is imported from the standard libc so the function is returned by the iterator. On the other hand, main() is implemented in this compilation unit so it is not returned by imported_function() but functions().

types_it types() const¶: Return an iterator over the different types defined in this compilation unit.

vars_it variables() const¶

Return an iterator over all the variables defined in this compilation unit:

static int A = 1; // Returned by the iterator
static const char* B = "Hello"; // Returned by the iterator

int get() {
  static int C = 2; // Returned by the iterator
  return C;
}

std::string to_decl(const DeclOpt &opt = DeclOpt()) const¶: Generate a C/C++ definition for the functions defined in this compilation unit.

class Iterator : public LIEF::iterator_facade_base<Iterator, std::bidirectional_iterator_tag, CompilationUnit, std::ptrdiff_t, const CompilationUnit*, const CompilationUnit&>¶

Public Types

using implementation = details::CompilationUnitIt¶

Public Functions

Iterator()¶

Iterator(std::unique_ptr<details::CompilationUnitIt> impl)¶

Iterator(const Iterator&)¶

Iterator &operator=(const Iterator&)¶

Iterator(Iterator&&) noexcept¶

Iterator &operator=(Iterator&&) noexcept¶

~Iterator()¶

Iterator &operator++()¶

Iterator &operator--()¶

const CompilationUnit &operator*() const¶

const CompilationUnit *operator->() const¶

std::unique_ptr<CompilationUnit> yield()¶: Transfer ownership of the compilation unit at the current position to the caller. Returns nullptr if the iterator is past-the-end.

inline DerivedT operator++(int)¶

inline DerivedT operator--(int)¶

Friends

friend bool operator==(const Iterator &LHS, const Iterator &RHS)¶

inline friend bool operator!=(const Iterator &LHS, const Iterator &RHS)¶

class Language¶

Languages supported by the DWARF (v5) format. See: https://dwarfstd.org/languages.html.

Some languages (like C++11, C++17, ..) have a version (11, 17, …) which is stored in a dedicated attribute: version

Public Types

enum LANG¶

Values:

enumerator UNKNOWN = 0¶

enumerator C¶

enumerator CPP¶

enumerator RUST¶

enumerator DART¶

enumerator MODULA¶

enumerator FORTRAN¶

enumerator SWIFT¶

enumerator D¶

enumerator JAVA¶

enumerator COBOL¶

Public Functions

Language() = default¶

inline Language(LANG lang, uint32_t version)¶

inline Language(LANG lang)¶

Language(const Language&) = default¶

Language &operator=(const Language&) = default¶

Language(Language&&) = default¶

Language &operator=(Language&&) = default¶

~Language() = default¶

Public Members

LANG lang = UNKNOWN ¶: The language itself.

uint32_t version = 0¶: Version of the language (e.g. 17 for C++17).

Function¶

class Function¶

This class represents a DWARF function which can be associated with either: DW_TAG_subprogram or DW_TAG_inlined_subroutine.

Public Types

using vars_it = iterator_range<Variable::Iterator>¶: Iterator over the variables defined in the scope of this function.

using parameters_t = std::vector<std::unique_ptr<Parameter>>¶

using thrown_types_t = std::vector<std::unique_ptr<Type>>¶

using lexical_blocks_it = iterator_range<LexicalBlock::Iterator>¶

using instructions_it = iterator_range<assembly::Instruction::Iterator>¶

Public Functions

Function(std::unique_ptr<details::Function> impl)¶

std::string name() const¶: The name of the function (DW_AT_name).

std::string linkage_name() const¶

The name of the function which is used for linking (DW_AT_linkage_name).

This name differs from name() as it is usually mangled. The function returns an empty string if the linkage name is not available.

result<uint64_t> address() const¶: Return the address of the function (DW_AT_entry_pc or DW_AT_low_pc).

vars_it variables() const¶: Return an iterator of variables (DW_TAG_variable) defined within the scope of this function. This includes regular stack-based variables as well as static ones.

bool is_artificial() const¶: Whether this function is created by the compiler and not present in the original source code.

bool is_external() const¶: Whether the function is defined outside the current compilation unit (DW_AT_external).

uint64_t size() const¶: Return the size taken by this function in the binary.

std::vector<range_t> ranges() const¶: Ranges of virtual addresses owned by this function.

debug_location_t debug_location() const¶: Original source code location.

std::unique_ptr<Type> type() const¶: Return the dwarf::Type associated with the return type of this function.

parameters_t parameters() const¶: Return the function’s parameters (including any template parameter).

thrown_types_t thrown_types() const¶

List of exceptions (types) that can be thrown by the function.

For instance, given this Swift code:

func summarize(_ ratings: [Int]) throws(StatisticsError) {
  // ...
}

thrown_types() returns one element associated with the Type: StatisticsError.

std::unique_ptr<Scope> scope() const¶: Return the scope in which this function is defined.

instructions_it instructions() const¶: Disassemble the current function by returning an iterator over the assembly::Instruction.

lexical_blocks_it lexical_blocks() const¶: Iterator over the LexicalBlock owned by this function.

std::string description() const¶: Description (DW_AT_description) of this function or an empty string.

std::string to_decl(const DeclOpt &opt = DeclOpt()) const¶: Generates a C/C++ definition for this function.

~Function()¶

class Iterator : public LIEF::iterator_facade_base<Iterator, std::bidirectional_iterator_tag, Function, std::ptrdiff_t, const Function*, const Function&>¶

Public Types

using implementation = details::FunctionIt¶

Public Functions

Iterator()¶

Iterator(std::unique_ptr<details::FunctionIt> impl)¶

Iterator(const Iterator&)¶

Iterator &operator=(const Iterator&)¶

Iterator(Iterator&&) noexcept¶

Iterator &operator=(Iterator&&) noexcept¶

~Iterator()¶

Iterator &operator++()¶

Iterator &operator--()¶

const Function &operator*() const¶

const Function *operator->() const¶

std::unique_ptr<Function> yield()¶: Transfer ownership of the function at the current position to the caller. Returns nullptr if the iterator is past-the-end.

inline DerivedT operator++(int)¶

inline DerivedT operator--(int)¶

Friends

friend bool operator==(const Iterator &LHS, const Iterator &RHS)¶

inline friend bool operator!=(const Iterator &LHS, const Iterator &RHS)¶

Parameter¶

class Parameter¶

This class represents a DWARF parameter which can be either:

A regular function parameter (see: parameters::Formal)
A template type parameter (see: parameters::TemplateType)
A template value parameter (see: parameters::TemplateValue)

Subclassed by LIEF::dwarf::parameters::Formal, LIEF::dwarf::parameters::TemplateType, LIEF::dwarf::parameters::TemplateValue

Public Types

enum class KIND¶

Values:

enumerator UNKNOWN = 0¶

enumerator TEMPLATE_TYPE¶: DW_TAG_template_type_parameter.

enumerator TEMPLATE_VALUE¶: DW_TAG_template_value_parameter.

enumerator FORMAL¶: DW_TAG_formal_parameter.

Public Functions

Parameter() = delete¶

Parameter(Parameter &&other) noexcept¶

Parameter &operator=(Parameter &&other) noexcept¶

Parameter &operator=(const Parameter&) = delete¶

Parameter(const Parameter&) = delete¶

KIND kind() const¶

std::string name() const¶: Name of the parameter.

std::unique_ptr<Type> type() const¶: Type of this parameter.

std::unique_ptr<Location> location() const¶: Location of this parameter. For instance it can be a specific register that is not following the calling convention.

template<class T> inline const T *as() const¶

virtual ~Parameter()¶

Public Static Functions

static std::unique_ptr<Parameter> create(std::unique_ptr<details::Parameter> impl)¶

class Location¶

This class exposes information about the location of a parameter.

Subclassed by LIEF::dwarf::Parameter::RegisterLoc

Public Types

enum class Type : uint8_t¶

Values:

enumerator UNKNOWN = 0¶

enumerator REG¶

Public Functions

inline Location(Type ty)¶

template<class T> inline const T *as() const¶

Public Members

Type type = Type::UNKNOWN ¶

class RegisterLoc : public LIEF::dwarf::Parameter::Location ¶

This class represents a register location.

Public Functions

inline RegisterLoc(uint64_t reg_id)¶

Public Members

uint64_t id = 0¶: DWARF id of the register.

Public Static Functions

static inline bool classof(const Location *loc)¶

Formal Parameter¶

class Formal : public LIEF::dwarf::Parameter ¶

This class represents a regular function parameter.

For instance, given this prototype:

int main(int argc, const char** argv);

The function main has two parameters::Formal parameters:

argc (Parameter::name) typed as int (types::Base from Parameter::type)
argv (Parameter::name) typed as const char** (types::Const from Parameter::type)

Public Functions

~Formal() override = default¶

Parameter() = delete¶

Parameter(Parameter &&other) noexcept¶

Parameter(const Parameter&) = delete¶

Public Static Functions

static inline bool classof(const Parameter *P)¶

Template Value Parameter¶

class TemplateValue : public LIEF::dwarf::Parameter ¶

This class represents a template value parameter.

For instance, given this prototype:

template<int X = 5>
void generic();

The function generic has one parameters::TemplateValue parameter: X.

Public Functions

~TemplateValue() override = default¶

Parameter() = delete¶

Parameter(Parameter &&other) noexcept¶

Parameter(const Parameter&) = delete¶

Public Static Functions

static inline bool classof(const Parameter *P)¶

Template Type Parameter¶

class TemplateType : public LIEF::dwarf::Parameter ¶

This class represents a template type parameter.

For instance, given this prototype:

template<class Y>
void generic();

The function generic has one parameters::TemplateType parameter: Y.

Public Functions

~TemplateType() override = default¶

Parameter() = delete¶

Parameter(Parameter &&other) noexcept¶

Parameter(const Parameter&) = delete¶

Public Static Functions

static inline bool classof(const Parameter *P)¶

Scope¶

class Scope¶

This class materializes a scope in which Function, Variable, Type, … can be defined.

Public Types

enum class TYPE : uint32_t¶

Values:

enumerator UNKNOWN = 0¶

enumerator UNION¶

enumerator CLASS¶

enumerator STRUCT¶

enumerator NAMESPACE¶

enumerator FUNCTION¶

enumerator COMPILATION_UNIT¶

Public Functions

Scope(std::unique_ptr<details::Scope> impl)¶

std::string name() const¶: Name of the scope. For instance namespace’s name or function’s name.

std::unique_ptr<Scope> parent() const¶: Parent scope (if any).

TYPE type() const¶: The current scope type.

std::string chained(const std::string &sep = "::") const¶: Represent the whole chain of all (parent) scopes using the provided separator. E.g. ns1::ns2::Class1::Struct2::Type.

~Scope()¶

Variable¶

class Variable¶

This class represents a DWARF variable which can be owned by a dwarf::Function or a dwarf::CompilationUnit.

Public Functions

Variable(std::unique_ptr<details::Variable> impl)¶

std::string name() const¶: Name of the variable (usually demangled).

std::string linkage_name() const¶

The name of the variable which is used for linking (DW_AT_linkage_name).

This name differs from name() as it is usually mangled. The function returns an empty string if the linkage name is not available.

result<int64_t> address() const¶

Address of the variable.

If the variable is static, it returns the virtual address where it is defined. If the variable is stack-based, it returns the relative offset from the frame based register.

If the address can’t be resolved, it returns a lief_errors.

result<uint64_t> size() const¶

Return the size of the variable (or a lief_errors if it can’t be resolved).

This size is defined by its type.

bool is_constexpr() const¶: Whether it’s a constexpr variable.

bool is_stack_based() const¶: Whether this variable is allocated on the stack.

debug_location_t debug_location() const¶: The original source location where the variable is defined.

std::unique_ptr<Type> type() const¶: Return the type of this variable.

std::unique_ptr<Scope> scope() const¶: Return the scope in which this variable is defined.

std::string description() const¶: Description (DW_AT_description) of the variable or an empty string.

std::string to_decl(const DeclOpt &opt = DeclOpt()) const¶: Generates a C/C++ definition for this variable.

~Variable()¶

class Iterator : public LIEF::iterator_facade_base<Iterator, std::bidirectional_iterator_tag, Variable, std::ptrdiff_t, const Variable*, const Variable&>¶

Public Types

using implementation = details::VariableIt¶

Public Functions

Iterator()¶

Iterator(std::unique_ptr<details::VariableIt> impl)¶

Iterator(const Iterator&)¶

Iterator &operator=(const Iterator&)¶

Iterator(Iterator&&) noexcept¶

Iterator &operator=(Iterator&&) noexcept¶

~Iterator()¶

Iterator &operator++()¶

Iterator &operator--()¶

const Variable &operator*() const¶

const Variable *operator->() const¶

std::unique_ptr<Variable> yield()¶: Transfer ownership of the variable at the current position to the caller. Returns nullptr if the iterator is past-the-end.

inline DerivedT operator++(int)¶

inline DerivedT operator--(int)¶

Friends

friend bool operator==(const Iterator &LHS, const Iterator &RHS)¶

inline friend bool operator!=(const Iterator &LHS, const Iterator &RHS)¶

LexicalBlock¶

class LexicalBlock¶

This class represents a DWARF lexical block (DW_TAG_lexical_block).

Public Types

using sub_blocks_it = iterator_range<Iterator>¶

Public Functions

LexicalBlock(std::unique_ptr<details::LexicalBlock> impl)¶

LexicalBlock() = delete¶

LexicalBlock &operator=(const LexicalBlock&) = delete¶

LexicalBlock(const LexicalBlock&) = delete¶

std::string name() const¶: Return the name associated with this lexical block or an empty string.

std::string description() const¶: Return the description associated with this lexical block or an empty string.

sub_blocks_it sub_blocks() const¶: Return an iterator over the sub-LexicalBlock owned by this block.

std::optional<uint64_t> addr() const¶: Return the start address of this block.

uint64_t size() const¶: Return the size of this block as the difference of the highest address and the lowest address.

std::optional<uint64_t> low_pc() const¶: Return the lowest virtual address owned by this block.

std::optional<uint64_t> high_pc() const¶: Return the highest virtual address owned by this block.

std::vector<range_t> ranges() const¶

Return a list of address ranges owned by this block.

If the lexical block owns a contiguous range, it should return a single range.

~LexicalBlock()¶

Public Static Functions

static std::unique_ptr<LexicalBlock> create(std::unique_ptr<details::LexicalBlock> impl)¶

class Iterator : public LIEF::iterator_facade_base<Iterator, std::bidirectional_iterator_tag, LexicalBlock, std::ptrdiff_t, const LexicalBlock*, const LexicalBlock&>¶

Public Types

using implementation = details::LexicalBlockIt¶

Public Functions

Iterator()¶

Iterator(std::unique_ptr<details::LexicalBlockIt> impl)¶

Iterator(const Iterator&)¶

Iterator &operator=(const Iterator&)¶

Iterator(Iterator&&) noexcept¶

Iterator &operator=(Iterator&&) noexcept¶

~Iterator()¶

Iterator &operator++()¶

Iterator &operator--()¶

const LexicalBlock &operator*() const¶

const LexicalBlock *operator->() const¶

std::unique_ptr<LexicalBlock> yield()¶: Transfer ownership of the lexical block at the current position to the caller. Returns nullptr if the iterator is past-the-end.

inline DerivedT operator++(int)¶

inline DerivedT operator--(int)¶

Friends

friend bool operator==(const Iterator &LHS, const Iterator &RHS)¶

inline friend bool operator!=(const Iterator &LHS, const Iterator &RHS)¶

Type¶

class Type¶

This class represents a DWARF Type which includes:

DW_TAG_array_type
DW_TAG_atomic_type
DW_TAG_base_type
DW_TAG_class_type
DW_TAG_coarray_type
DW_TAG_const_type
DW_TAG_dynamic_type
DW_TAG_enumeration_type
DW_TAG_file_type
DW_TAG_immutable_type
DW_TAG_interface_type
DW_TAG_packed_type
DW_TAG_pointer_type
DW_TAG_ptr_to_member_type
DW_TAG_reference_type
DW_TAG_restrict_type
DW_TAG_rvalue_reference_type
DW_TAG_set_type
DW_TAG_shared_type
DW_TAG_string_type
DW_TAG_structure_type
DW_TAG_subroutine_type
DW_TAG_template_alias
DW_TAG_thrown_type
DW_TAG_typedef
DW_TAG_union_type
DW_TAG_unspecified_type
DW_TAG_volatile_type

Public Types

enum class KIND¶

Values:

enumerator UNKNOWN = 0¶

enumerator UNSPECIFIED¶

enumerator BASE¶

enumerator CONST_KIND¶

enumerator CLASS¶

enumerator ARRAY¶

enumerator POINTER¶

enumerator STRUCT¶

enumerator UNION¶

enumerator TYPEDEF¶

enumerator REF¶

enumerator SET_TYPE¶

enumerator STRING¶

enumerator SUBROUTINE¶

enumerator POINTER_MEMBER¶

enumerator PACKED¶

enumerator FILE¶

enumerator THROWN¶

enumerator VOLATILE¶

enumerator RESTRICT¶

enumerator INTERFACE¶

enumerator SHARED¶

enumerator RVALREF¶

enumerator TEMPLATE_ALIAS¶

enumerator COARRAY¶

enumerator DYNAMIC¶

enumerator ATOMIC¶

enumerator IMMUTABLE¶

enumerator ENUM¶

Public Functions

Type(std::unique_ptr<details::Type> impl)¶

Type(details::Type &impl)¶

Type(const Type&) = delete¶

Type &operator=(const Type&) = delete¶

Type(Type&&) noexcept¶

Type &operator=(Type&&) noexcept¶

virtual ~Type()¶

KIND kind() const¶

inline bool is_unspecified() const¶: Whether this type is a DW_TAG_unspecified_type.

result<std::string> name() const¶: Return the type’s name using either DW_AT_name or DW_AT_picture_string (if any).

result<uint64_t> size() const¶

Return the size of the type or an error if it can’t be computed.

This size should match the equivalent of sizeof(Type).

debug_location_t location() const¶: Return the debug location where this type is defined.

std::unique_ptr<Scope> scope() const¶: Return the scope in which this type is defined.

std::string to_decl(const DeclOpt &opt = DeclOpt()) const¶: Generates a C/C++ definition for this type.

template<class T> inline const T *as() const¶

Public Static Functions

static std::unique_ptr<Type> create(std::unique_ptr<details::Type> impl)¶

class Iterator : public LIEF::iterator_facade_base<Iterator, std::bidirectional_iterator_tag, Type, std::ptrdiff_t, const Type*, const Type&>¶

Public Types

using implementation = details::TypeIt¶

Public Functions

Iterator()¶

Iterator(std::unique_ptr<details::TypeIt> impl)¶

Iterator(const Iterator&)¶

Iterator &operator=(const Iterator&)¶

Iterator(Iterator&&) noexcept¶

Iterator &operator=(Iterator&&) noexcept¶

~Iterator()¶

Iterator &operator++()¶

Iterator &operator--()¶

const Type &operator*() const¶

const Type *operator->() const¶

std::unique_ptr<Type> yield()¶: Transfer ownership of the type at the current position to the caller. Returns nullptr if the iterator is past-the-end.

inline DerivedT operator++(int)¶

inline DerivedT operator--(int)¶

Friends

friend bool operator==(const Iterator &LHS, const Iterator &RHS)¶

inline friend bool operator!=(const Iterator &LHS, const Iterator &RHS)¶

Array¶

class Array : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_array_type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline Array(Args&&... args)¶

Array(const Array&) = delete¶

Array &operator=(const Array&) = delete¶

Array(Array&&) noexcept = default¶

Array &operator=(Array&&) noexcept = default¶

const Type *underlying_type() const¶: The underlying type of this array.

inline const Type *operator->() const¶

inline const Type &operator*() const¶

size_info_t size_info() const¶

Return information about the size of this array.

This size info is usually embedded in a DW_TAG_subrange_type DIE which is represented by the size_info_t structure.

~Array() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

struct size_info_t¶

Structure that wraps information about the dimension of this array.

Public Functions

inline operator bool() const¶

Public Members

std::unique_ptr<Type> type = nullptr¶

Type of the index for this array.

For instance in uint8_t[3] the index type could be set to a size_t.

std::string name¶: Name of the index (usually not relevant like __ARRAY_SIZE_TYPE__).

size_t size = 0¶: Size of the array. For instance in uint8_t[3], it returns 3.

Base¶

class Base : public LIEF::dwarf::Type ¶

This class wraps the DW_TAG_base_type type which can be used — for instance — to represent integers or primitive types.

Public Types

enum class ENCODING¶

Values:

enumerator NONE = 0¶

enumerator SIGNED¶: Mirror DW_ATE_signed.

enumerator SIGNED_CHAR¶: Mirror DW_ATE_signed_char.

enumerator UNSIGNED¶: Mirror DW_ATE_unsigned.

enumerator UNSIGNED_CHAR¶: Mirror DW_ATE_unsigned_char.

enumerator FLOAT¶: Mirror DW_ATE_float.

enumerator BOOLEAN¶: Mirror DW_ATE_boolean.

enumerator ADDRESS¶: Mirror DW_ATE_address.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline Base(Args&&... args)¶

Base(const Base&) = delete¶

Base &operator=(const Base&) = delete¶

Base(Base&&) noexcept = default¶

Base &operator=(Base&&) noexcept = default¶

ENCODING encoding() const¶: Describe how the base type is encoded and should be interpreted.

~Base() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

ClassLike¶

class ClassLike : public LIEF::dwarf::Type ¶

This class abstracts a DWARF aggregate: DW_TAG_structure_type, DW_TAG_class_type, DW_TAG_union_type.

Subclassed by LIEF::dwarf::types::Class, LIEF::dwarf::types::Packed, LIEF::dwarf::types::Structure, LIEF::dwarf::types::Union

Public Types

using functions_it = iterator_range<Function::Iterator>¶

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline ClassLike(Args&&... args)¶

ClassLike(const ClassLike&) = delete¶

ClassLike &operator=(const ClassLike&) = delete¶

ClassLike(ClassLike&&) noexcept = default¶

ClassLike &operator=(ClassLike&&) noexcept = default¶

std::vector<Member> members() const¶: Return the list of all the attributes defined in this class-like type.

std::unique_ptr<Member> find_member(uint64_t offset) const¶: Try to find the attribute at the given offset.

functions_it functions() const¶: Iterator over the functions defined by the class-like.

~ClassLike() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

class Member¶

This represents a class/struct/union attribute.

Public Functions

Member(std::unique_ptr<details::Member> impl)¶

Member(Member &&other) noexcept¶

Member &operator=(Member &&other) noexcept¶

Member(const Member&) = delete¶

Member &operator=(const Member&) = delete¶

std::string name() const¶: Name of the member.

result<uint64_t> offset() const¶

Offset of the current member in the struct/union/class.

If the offset can’t be resolved it returns a lief_errors

result<uint64_t> bit_offset() const¶

Offset of the current member in bits in the struct/union/class.

This function differs from offset() for aggregates using bit-field declaration:

struct S {
  int flag : 4;
  int opt : 1
};

Usually, offset() * 8 == bit_offset()

If the offset can’t be resolved it returns a lief_errors

result<uint64_t> bit_size() const¶: If the current member is a bit-field, this function returns its size in bits.

std::unique_ptr<Type> type() const¶: Type of the current member.

bool is_external() const¶

bool is_declaration() const¶

~Member()¶

Structure¶

class Structure : public LIEF::dwarf::types::ClassLike ¶

This class represents a DWARF struct type (DW_TAG_structure_type).

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<ClassLike, Args&&...>>> inline Structure(Args&&... args)¶

Structure(const Structure&) = delete¶

Structure &operator=(const Structure&) = delete¶

Structure(Structure&&) noexcept = default¶

Structure &operator=(Structure&&) noexcept = default¶

~Structure() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

Class¶

class Class : public LIEF::dwarf::types::ClassLike ¶

This class represents a DWARF class type (DW_TAG_class_type).

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<ClassLike, Args&&...>>> inline Class(Args&&... args)¶

Class(const Class&) = delete¶

Class &operator=(const Class&) = delete¶

Class(Class&&) noexcept = default¶

Class &operator=(Class&&) noexcept = default¶

~Class() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

Union¶

class Union : public LIEF::dwarf::types::ClassLike ¶

This class represents a DWARF union type (DW_TAG_union_type).

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<ClassLike, Args&&...>>> inline Union(Args&&... args)¶

Union(const Union&) = delete¶

Union &operator=(const Union&) = delete¶

Union(Union&&) noexcept = default¶

Union &operator=(Union&&) noexcept = default¶

~Union() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

Packed¶

class Packed : public LIEF::dwarf::types::ClassLike ¶

This class represents a DWARF packed type (DW_TAG_packed_type).

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<ClassLike, Args&&...>>> inline Packed(Args&&... args)¶

Packed(const Packed&) = delete¶

Packed &operator=(const Packed&) = delete¶

Packed(Packed&&) noexcept = default¶

Packed &operator=(Packed&&) noexcept = default¶

~Packed() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

Const¶

class Const : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_const_type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline Const(Args&&... args)¶

Const(const Const&) = delete¶

Const &operator=(const Const&) = delete¶

Const(Const&&) noexcept = default¶

Const &operator=(Const&&) noexcept = default¶

const Type *underlying_type() const¶: The underlying type being const-ed.

inline const Type *operator->() const¶

inline const Type &operator*() const¶

~Const() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

Pointer¶

class Pointer : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_pointer_type DWARF type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline Pointer(Args&&... args)¶

Pointer(const Pointer&) = delete¶

Pointer &operator=(const Pointer&) = delete¶

Pointer(Pointer&&) noexcept = default¶

Pointer &operator=(Pointer&&) noexcept = default¶

const Type *underlying_type() const¶: The type pointed by this pointer.

inline const Type *operator->() const¶

inline const Type &operator*() const¶

~Pointer() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

Typedef¶

class Typedef : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_typedef type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline Typedef(Args&&... args)¶

Typedef(const Typedef&) = delete¶

Typedef &operator=(const Typedef&) = delete¶

Typedef(Typedef&&) noexcept = default¶

Typedef &operator=(Typedef&&) noexcept = default¶

const Type *underlying_type() const¶: The type aliased by this typedef.

inline const Type *operator->() const¶

inline const Type &operator*() const¶

~Typedef() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

Atomic¶

class Atomic : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_atomic_type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline Atomic(Args&&... args)¶

Atomic(const Atomic&) = delete¶

Atomic &operator=(const Atomic&) = delete¶

Atomic(Atomic&&) noexcept = default¶

Atomic &operator=(Atomic&&) noexcept = default¶

const Type *underlying_type() const¶: The underlying type being atomic.

inline const Type *operator->() const¶

inline const Type &operator*() const¶

~Atomic() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

Coarray¶

class Coarray : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_coarray_type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline Coarray(Args&&... args)¶

Coarray(const Coarray&) = delete¶

Coarray &operator=(const Coarray&) = delete¶

Coarray(Coarray&&) noexcept = default¶

Coarray &operator=(Coarray&&) noexcept = default¶

~Coarray() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

Dynamic¶

class Dynamic : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_dynamic_type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline Dynamic(Args&&... args)¶

Dynamic(const Dynamic&) = delete¶

Dynamic &operator=(const Dynamic&) = delete¶

Dynamic(Dynamic&&) noexcept = default¶

Dynamic &operator=(Dynamic&&) noexcept = default¶

~Dynamic() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

Enum¶

class Enum : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_enumeration_type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline Enum(Args&&... args)¶

Enum(const Enum&) = delete¶

Enum &operator=(const Enum&) = delete¶

Enum(Enum&&) noexcept = default¶

Enum &operator=(Enum&&) noexcept = default¶

std::vector<Entry> entries() const¶: Return the different entries associated with this enum.

const Type *underlying_type() const¶: The underlying type that is used to encode this enum.

std::optional<Entry> find_entry(int64_t value) const¶: Try to find the enum matching the given value.

~Enum() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

class Entry¶

This class represents an enum entry which is essentially composed of a name and its value (integer).

Public Functions

Entry(std::unique_ptr<details::EnumEntry> impl)¶

Entry(Entry &&other) noexcept¶

Entry &operator=(Entry &&other) noexcept¶

Entry(const Entry&) = delete¶

Entry &operator=(const Entry&) = delete¶

std::string name() const¶: Enum entry’s name.

std::optional<int64_t> value() const¶: Enum entry’s value (if any).

~Entry()¶

File¶

class File : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_file_type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline File(Args&&... args)¶

File(const File&) = delete¶

File &operator=(const File&) = delete¶

File(File&&) noexcept = default¶

File &operator=(File&&) noexcept = default¶

~File() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

Immutable¶

class Immutable : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_immutable_type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline Immutable(Args&&... args)¶

Immutable(const Immutable&) = delete¶

Immutable &operator=(const Immutable&) = delete¶

Immutable(Immutable&&) noexcept = default¶

Immutable &operator=(Immutable&&) noexcept = default¶

const Type *underlying_type() const¶: The underlying type.

inline const Type *operator->() const¶

inline const Type &operator*() const¶

~Immutable() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

Interface¶

class Interface : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_interface_type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline Interface(Args&&... args)¶

Interface(const Interface&) = delete¶

Interface &operator=(const Interface&) = delete¶

Interface(Interface&&) noexcept = default¶

Interface &operator=(Interface&&) noexcept = default¶

~Interface() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

PointerToMember¶

class PointerToMember : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_ptr_to_member_type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline PointerToMember(Args&&... args)¶

PointerToMember(const PointerToMember&) = delete¶

PointerToMember &operator=(const PointerToMember&) = delete¶

PointerToMember(PointerToMember&&) noexcept = default¶

PointerToMember &operator=(PointerToMember&&) noexcept = default¶

const Type *underlying_type() const¶: The type of the member referenced by this pointer.

inline const Type *operator->() const¶

inline const Type *operator*() const¶

std::unique_ptr<Type> containing_type() const¶: The type that embeds this member.

~PointerToMember() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

RValueReference¶

class RValueReference : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_rvalue_reference_type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline RValueReference(Args&&... args)¶

RValueReference(const RValueReference&) = delete¶

RValueReference &operator=(const RValueReference&) = delete¶

RValueReference(RValueReference&&) noexcept = default¶

RValueReference &operator=(RValueReference&&) noexcept = default¶

const Type *underlying_type() const¶: The underlying type referenced by this rvalue-type.

inline const Type *operator->() const¶

inline const Type *operator*() const¶

~RValueReference() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

Reference¶

class Reference : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_reference_type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline Reference(Args&&... args)¶

Reference(const Reference&) = delete¶

Reference &operator=(const Reference&) = delete¶

Reference(Reference&&) noexcept = default¶

Reference &operator=(Reference&&) noexcept = default¶

const Type *underlying_type() const¶: The underlying type referenced by this ref-type.

inline const Type *operator->() const¶

inline const Type *operator*() const¶

~Reference() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

Restrict¶

class Restrict : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_restrict_type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline Restrict(Args&&... args)¶

Restrict(const Restrict&) = delete¶

Restrict &operator=(const Restrict&) = delete¶

Restrict(Restrict&&) noexcept = default¶

Restrict &operator=(Restrict&&) noexcept = default¶

const Type *underlying_type() const¶: The underlying type referenced by this restrict-type.

inline const Type *operator->() const¶

inline const Type *operator*() const¶

~Restrict() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

SetTy¶

class SetTy : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_set_type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline SetTy(Args&&... args)¶

SetTy(const SetTy&) = delete¶

SetTy &operator=(const SetTy&) = delete¶

SetTy(SetTy&&) noexcept = default¶

SetTy &operator=(SetTy&&) noexcept = default¶

const Type *underlying_type() const¶: The underlying type referenced by this set-type.

inline const Type *operator->() const¶

inline const Type *operator*() const¶

~SetTy() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

Shared¶

class Shared : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_shared_type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline Shared(Args&&... args)¶

Shared(const Shared&) = delete¶

Shared &operator=(const Shared&) = delete¶

Shared(Shared&&) noexcept = default¶

Shared &operator=(Shared&&) noexcept = default¶

const Type *underlying_type() const¶: The underlying type referenced by this shared-type.

inline const Type *operator->() const¶

inline const Type *operator*() const¶

~Shared() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

StringTy¶

class StringTy : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_string_type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline StringTy(Args&&... args)¶

StringTy(const StringTy&) = delete¶

StringTy &operator=(const StringTy&) = delete¶

StringTy(StringTy&&) noexcept = default¶

StringTy &operator=(StringTy&&) noexcept = default¶

~StringTy() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

Subroutine¶

class Subroutine : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_subroutine_type.

Public Types

using parameters_t = std::vector<std::unique_ptr<Parameter>>¶

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline Subroutine(Args&&... args)¶

Subroutine(const Subroutine&) = delete¶

Subroutine &operator=(const Subroutine&) = delete¶

Subroutine(Subroutine&&) noexcept = default¶

Subroutine &operator=(Subroutine&&) noexcept = default¶

std::unique_ptr<Type> return_type() const¶: Return the dwarf::Type associated with the return type of this function.

parameters_t parameters() const¶: Parameters of this subroutine.

~Subroutine() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

TemplateAlias¶

class TemplateAlias : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_template_alias.

Public Types

using parameters_t = std::vector<std::unique_ptr<Parameter>>¶

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline TemplateAlias(Args&&... args)¶

TemplateAlias(const TemplateAlias&) = delete¶

TemplateAlias &operator=(const TemplateAlias&) = delete¶

TemplateAlias(TemplateAlias&&) noexcept = default¶

TemplateAlias &operator=(TemplateAlias&&) noexcept = default¶

const Type *underlying_type() const¶: The underlying type aliased by this type.

inline const Type *operator->() const¶

inline const Type &operator*() const¶

parameters_t parameters() const¶: Parameters associated with the underlying template.

~TemplateAlias() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

Thrown¶

class Thrown : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_thrown_type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline Thrown(Args&&... args)¶

Thrown(const Thrown&) = delete¶

Thrown &operator=(const Thrown&) = delete¶

Thrown(Thrown&&) noexcept = default¶

Thrown &operator=(Thrown&&) noexcept = default¶

const Type *underlying_type() const¶: The underlying type being thrown.

inline const Type *operator->() const¶

inline const Type &operator*() const¶

~Thrown() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

Volatile¶

class Volatile : public LIEF::dwarf::Type ¶

This class represents a DW_TAG_volatile_type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline Volatile(Args&&... args)¶

Volatile(const Volatile&) = delete¶

Volatile &operator=(const Volatile&) = delete¶

Volatile(Volatile&&) noexcept = default¶

Volatile &operator=(Volatile&&) noexcept = default¶

const Type *underlying_type() const¶: The underlying type.

inline const Type *operator->() const¶

inline const Type &operator*() const¶

~Volatile() override¶

Public Static Functions

static inline bool classof(const Type *type)¶

Editor¶

class Editor¶

This class exposes the main API to create DWARF information.

Public Types

enum class FORMAT : uint32_t¶

Values:

enumerator ELF¶

enumerator MACHO¶

enumerator PE¶

enum class ARCH : uint32_t¶

Values:

enumerator UNKNOWN¶

enumerator X64¶

enumerator X86¶

enumerator AARCH64¶

enumerator ARM¶

Public Functions

Editor() = delete¶

Editor(std::unique_ptr<details::Editor> impl)¶

std::unique_ptr<editor::CompilationUnit> create_compilation_unit()¶: Create a new compilation unit.

void write(const std::string &output)¶: Write the DWARF file to the specified output.

~Editor()¶

Public Static Functions

static std::unique_ptr<Editor> from_binary(LIEF::Binary &bin)¶: Instantiate an editor for the given binary object.

static std::unique_ptr<Editor> create(FORMAT fmt, ARCH arch)¶: Instantiate an editor for the given format and arch.

Editor - CompilationUnit¶

class CompilationUnit¶

This class represents an editable DWARF compilation unit.

Public Functions

CompilationUnit() = delete¶

CompilationUnit(std::unique_ptr<details::CompilationUnit> impl)¶

CompilationUnit &set_producer(const std::string &producer)¶

Set the DW_AT_producer producer attribute.

This attribute aims to inform about the program that generated this compilation unit (e.g. LIEF Extended)

std::unique_ptr<Function> create_function(const std::string &name)¶: Create a new function owned by this compilation unit.

std::unique_ptr<Variable> create_variable(const std::string &name)¶: Create a new global variable owned by this compilation unit.

std::unique_ptr<Type> create_generic_type(const std::string &name)¶: Create a DW_TAG_unspecified_type type with the given name.

std::unique_ptr<EnumType> create_enum(const std::string &name)¶: Create an enum type (DW_TAG_enumeration_type).

std::unique_ptr<TypeDef> create_typedef(const std::string &name, const Type &type)¶: Create a typedef with the name provided in the first parameter which aliases the type provided in the second parameter.

std::unique_ptr<StructType> create_structure(const std::string &name, StructType::TYPE kind = StructType::TYPE::STRUCT)¶: Create a struct-like type (struct, class, union) with the given name.

std::unique_ptr<BaseType> create_base_type(const std::string &name, size_t size, BaseType::ENCODING encoding = BaseType::ENCODING::NONE)¶: Create a primitive type with the given name and size.

std::unique_ptr<FunctionType> create_function_type(const std::string &name)¶: Create a function type with the given name.

inline std::unique_ptr<PointerType> create_pointer_type(const Type &ty)¶: Create a pointer on the provided type.

std::unique_ptr<Type> create_void_type()¶: Create a void type.

std::unique_ptr<ArrayType> create_array(const std::string &name, const Type &type, size_t count)¶: Create an array type with the given name, type and size.

~CompilationUnit()¶

Editor - Function¶

class Function¶

This class represents an editable DWARF function (DW_TAG_subprogram).

Public Functions

Function() = delete¶

Function(std::unique_ptr<details::Function> impl)¶

Function &set_address(uint64_t addr)¶: Set the address of this function by defining DW_AT_entry_pc.

Function &set_low_high(uint64_t low, uint64_t high)¶

Set the upper and lower bound addresses for this function. This assumes that the function is contiguous between low and high.

Underneath, the function defines DW_AT_low_pc and DW_AT_high_pc

Function &set_ranges(const std::vector<range_t> &ranges)¶

Set the ranges of addresses owned by the implementation of this function by setting the DW_AT_ranges attribute.

This setter should be used for non-contiguous functions.

Function &set_external()¶: Set the function as external by defining DW_AT_external to true. This means that the function is imported by the current compilation unit.

Function &set_return_type(const Type &type)¶: Set the return type of this function.

std::unique_ptr<Parameter> add_parameter(const std::string &name, const Type &type)¶: Add a parameter to the current function.

std::unique_ptr<Variable> create_stack_variable(const std::string &name)¶: Create a stack-based variable owned by the current function.

std::unique_ptr<LexicalBlock> add_lexical_block(uint64_t start, uint64_t end)¶: Add a lexical block with the given range.

std::unique_ptr<Label> add_label(uint64_t addr, const std::string &label)¶: Add a label at the given address.

Function &add_description(const std::string &description)¶: Create a DW_AT_description entry with the description provided in parameter.

~Function()¶

struct range_t¶

Public Functions

range_t() = default¶

inline range_t(uint64_t start, uint64_t end)¶

Public Members

uint64_t start = 0¶

uint64_t end = 0¶

class Parameter¶

This class represents a parameter of the current function (DW_TAG_formal_parameter).

Public Functions

Parameter() = delete¶

Parameter(std::unique_ptr<details::FunctionParameter> impl)¶

~Parameter()¶

Parameter &assign_register(const std::string &name)¶: Assign this parameter to a specific named register.

Parameter &assign_register(uint64_t reg)¶: Assign this parameter to the given DWARF register id (e.g. DW_OP_reg0).

class LexicalBlock¶

This class mirrors the DW_TAG_lexical_block DWARF tag.

Public Functions

LexicalBlock() = delete¶

LexicalBlock(std::unique_ptr<details::FunctionLexicalBlock> impl)¶

std::unique_ptr<LexicalBlock> add_block(uint64_t start, uint64_t end)¶: Create a sub-block with the given low/high addresses.

std::unique_ptr<LexicalBlock> add_block(const std::vector<range_t> &range)¶: Create a sub-block with the given range of addresses.

LexicalBlock &add_description(const std::string &description)¶: Create a DW_AT_description entry with the description provided in parameter.

LexicalBlock &add_name(const std::string &name)¶: Create a DW_AT_name entry to associate a name to this entry.

~LexicalBlock()¶

class Label¶

This class mirrors the DW_TAG_label DWARF tag.

Public Functions

Label() = delete¶

Label(std::unique_ptr<details::FunctionLabel> impl)¶

~Label()¶

Editor - Variable¶

class Variable¶

This class represents an editable DWARF variable which can be scoped by a function or a compilation unit (DW_TAG_variable).

Public Functions

Variable() = delete¶

Variable(std::unique_ptr<details::Variable> impl)¶

Variable &set_addr(uint64_t address)¶

Set the global address of this variable. Setting this address is only relevant in the case of a static global variable. For stack variable, you should use set_stack_offset.

This function sets the DW_AT_location attribute

Variable &set_stack_offset(uint64_t offset)¶

Set the stack offset of this variable.

This function sets the DW_AT_location attribute

Variable &set_external()¶: Mark this variable as imported.

Variable &set_type(const Type &type)¶: Set the type of the current variable.

Variable &add_description(const std::string &description)¶: Create a DW_AT_description entry with the description provided in parameter.

~Variable()¶

Editor - Type¶

class Type¶

This class is the base class for any types created when editing DWARF debug info.

A type is owned by a LIEF::dwarf::editor::CompilationUnit and should be created from this class.

Subclassed by LIEF::dwarf::editor::ArrayType, LIEF::dwarf::editor::BaseType, LIEF::dwarf::editor::EnumType, LIEF::dwarf::editor::FunctionType, LIEF::dwarf::editor::PointerType, LIEF::dwarf::editor::StructType, LIEF::dwarf::editor::TypeDef

Public Functions

Type() = delete¶

Type(std::unique_ptr<details::Type> impl)¶

std::unique_ptr<PointerType> pointer_to() const¶: Create a pointer type pointing to this type.

virtual ~Type()¶

inline const details::Type &impl() const¶

Editor - PointerType¶

class PointerType : public LIEF::dwarf::editor::Type ¶

This class represents a pointer to another type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline PointerType(Args&&... args)¶

~PointerType() override = default¶

Public Static Functions

static bool classof(const Type *type)¶

Editor - EnumType¶

class EnumType : public LIEF::dwarf::editor::Type ¶

This class represents an editable enum type (DW_TAG_enumeration_type).

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline EnumType(Args&&... args)¶

EnumType &set_size(uint64_t size)¶: Define the number of bytes required to hold an instance of the enumeration (DW_AT_byte_size).

EnumType &set_underlying_type(const Type &type)¶: Set the underlying type that is used to encode this enum.

std::unique_ptr<Value> add_value(const std::string &name, int64_t value)¶: Add an enum value by specifying its name and its integer value.

~EnumType() override = default¶

Public Static Functions

static bool classof(const Type *type)¶

class Value¶

This class represents an enum value.

Public Functions

Value() = delete¶

Value(std::unique_ptr<details::EnumValue> impl)¶

~Value()¶

Editor - BaseType¶

class BaseType : public LIEF::dwarf::editor::Type ¶

This class represents a primitive type like int, char.

Public Types

enum class ENCODING : uint32_t¶

Values:

enumerator NONE = 0¶

enumerator ADDRESS¶

enumerator SIGNED¶

enumerator SIGNED_CHAR¶

enumerator UNSIGNED¶

enumerator UNSIGNED_CHAR¶

enumerator BOOLEAN¶

enumerator FLOAT¶

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline BaseType(Args&&... args)¶

~BaseType() override = default¶

Public Static Functions

static bool classof(const Type *type)¶

Editor - ArrayType¶

class ArrayType : public LIEF::dwarf::editor::Type ¶

This class represents an array type (DW_TAG_array_type).

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline ArrayType(Args&&... args)¶

~ArrayType() override = default¶

Public Static Functions

static bool classof(const Type *type)¶

Editor - FunctionType¶

class FunctionType : public LIEF::dwarf::editor::Type ¶

This class represents a function type (DW_TAG_subroutine_type).

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline FunctionType(Args&&... args)¶

FunctionType &set_return_type(const Type &type)¶: Set the return type of this function.

std::unique_ptr<Parameter> add_parameter(const Type &type)¶: Add a parameter.

~FunctionType() override = default¶

Public Static Functions

static bool classof(const Type *type)¶

class Parameter¶

This class represents a function’s parameter.

Public Functions

Parameter() = delete¶

Parameter(std::unique_ptr<details::FunctionTyParameter> impl)¶

~Parameter()¶

Editor - TypeDef¶

class TypeDef : public LIEF::dwarf::editor::Type ¶

This class represents a typedef (DW_TAG_typedef).

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline TypeDef(Args&&... args)¶

~TypeDef() override = default¶

Public Static Functions

static bool classof(const Type *type)¶

Editor - StructType¶

class StructType : public LIEF::dwarf::editor::Type ¶

This class represents a struct-like type which can be:

DW_TAG_class_type
DW_TAG_structure_type
DW_TAG_union_type

Public Types

enum class TYPE : uint32_t¶

Values:

enumerator CLASS¶

enumerator STRUCT¶: Discriminant for DW_TAG_class_type.

enumerator UNION¶: Discriminant for DW_TAG_structure_type.

Public Functions

template<typename ...Args, typename = std::enable_if_t<std::is_constructible_v<Type, Args&&...>>> inline StructType(Args&&... args)¶

StructType &set_size(uint64_t size)¶

Define the overall size which is equivalent to the sizeof of the current type.

This function defines the DW_AT_byte_size attribute

std::unique_ptr<Member> add_member(const std::string &name, const Type &type, int64_t offset = -1)¶: Adds a member to the current struct-like.

std::unique_ptr<Member> add_bitfield(const std::string &name, const Type &type, uint64_t bitsize, int64_t bitoffset = -1)¶: Adds a bitfield member to the current structure.

~StructType() override = default¶

Public Static Functions

static bool classof(const Type *type)¶

class Member¶

This class represents a member of the struct-like.

Public Functions

Member() = delete¶

Member(std::unique_ptr<details::StructMember> impl)¶

~Member()¶