--- documentID: "97df546bf02b908886d651fe6e934050dbee923b4228827a1a017f2af1b18117" docname: "extended/dwarf/cpp" title: "DWARF C++ API - LIEF Documentation" description: "DWARF C++ API reference documentation for LIEF, including APIs and examples for parsing, inspecting, modifying, and writing executable formats." canonical: "https://lief.re/doc/latest/extended/dwarf/cpp.html" markdownURL: "https://lief.re/doc/latest/extended/dwarf/cpp.md" documentationVersion: "2.0.0" documentationChannel: "latest" language: "en" contentHash: "c2c73cbab50486b66d0114509bee2fab89d21a848b51a755fedc6efc50eb6bdf" --- # [C++]() > **Note** > > You can also find the Doxygen documentation here: [here]() ## [` LIEF::dwarf::load `]() inline std::unique\_ptr<[DebugInfo]( "LIEF::dwarf::DebugInfo")> LIEF::dwarf::load(const std::string &dwarf\_path) Load DWARF file from the given path. ## [DebugInfo]() ### [` DebugInfo `]() class DebugInfo : public LIEF::[DebugInfo]( "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 #### [` compilation_units_it `]() using compilation\_units\_it = [iterator\_range]( "LIEF::iterator_range")<[CompilationUnit]( "LIEF::dwarf::CompilationUnit")::[Iterator]( "LIEF::dwarf::CompilationUnit::Iterator")> Iterator over the [CompilationUnit](). Public Functions #### [` find_function `]() std::unique\_ptr<[Function]( "LIEF::dwarf::Function")> find\_function(const std::string &name) const Try to find the function with the given name (mangled or not). ```cpp const DebugInfo& info = ...; if (auto func = info.find_function("_ZNSt6localeD1Ev")) { // Found } if (auto func = info.find_function("std::locale::~locale()")) { // Found } ``` #### [` find_function `]() std::unique\_ptr<[Function]( "LIEF::dwarf::Function")> find\_function(uint64\_t addr) const Try to find the function at the given **virtual** address. #### [` find_variable `]() std::unique\_ptr<[Variable]( "LIEF::dwarf::Variable")> find\_variable(const std::string &name) const Try to find the variable with the given name. This name can be mangled or not. #### [` find_variable `]() std::unique\_ptr<[Variable]( "LIEF::dwarf::Variable")> find\_variable(uint64\_t addr) const Try to find the variable at the given **virtual** address. #### [` find_type `]() std::unique\_ptr<[Type]( "LIEF::dwarf::Type")> find\_type(const std::string &name) const Try to find the type with the given name. #### [` compilation_units `]() [compilation\_units\_it]( "LIEF::dwarf::DebugInfo::compilation_units_it") compilation\_units() const Iterator on the [CompilationUnit]() embedded in this dwarf. #### [` find_function_address `]() 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`. #### [` format `]() inline virtual FORMAT format() const override #### [` ~DebugInfo `]() virtual ~DebugInfo() override = default #### [` DebugInfo `]() DebugInfo(std::unique\_ptr<details::DebugInfo> impl) Public Static Functions #### [` from_file `]() static std::unique\_ptr<[DebugInfo]( "LIEF::dwarf::DebugInfo")> from\_file(const std::string &path) #### [` classof `]() static inline bool classof(const LIEF::[DebugInfo]( "LIEF::DebugInfo") \*info) --- ## [CompilationUnit]() ### [` CompilationUnit `]() class CompilationUnit This class represents a DWARF compilation unit. Public Types #### [` functions_it `]() using functions\_it = [iterator\_range]( "LIEF::iterator_range")<[Function]( "LIEF::dwarf::Function")::[Iterator]( "LIEF::dwarf::Function::Iterator")> [Iterator]() over the [dwarf::Function](). #### [` types_it `]() using types\_it = [iterator\_range]( "LIEF::iterator_range")<[Type]( "LIEF::dwarf::Type")::[Iterator]( "LIEF::dwarf::Type::Iterator")> [Iterator]() over the [dwarf::Type](). #### [` vars_it `]() using vars\_it = [iterator\_range]( "LIEF::iterator_range")<[Variable]( "LIEF::dwarf::Variable")::[Iterator]( "LIEF::dwarf::Variable::Iterator")> [Iterator]() over the [CompilationUnit]()’s variables. Public Functions #### [` CompilationUnit `]() CompilationUnit(std::unique\_ptr<details::CompilationUnit> impl) #### [` ~CompilationUnit `]() ~CompilationUnit() #### [` name `]() 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 #### [` producer `]() 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 #### [` compilation_dir `]() 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]( "LIEF::dwarf::CompilationUnit::Language") language() const Original language of this compilation unit. This value matches the `DW_AT_language` attribute. #### [` low_address `]() uint64\_t low\_address() const Return the lowest virtual address owned by this compilation unit. #### [` high_address `]() uint64\_t high\_address() const Return the highest virtual address owned by this compilation unit. #### [` size `]() 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`. #### [` ranges `]() 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. #### [` find_function `]() std::unique\_ptr<[Function]( "LIEF::dwarf::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 #### [` find_function `]() std::unique\_ptr<[Function]( "LIEF::dwarf::Function")> find\_function(uint64\_t addr) const Try to find the function at the given address. #### [` find_variable `]() std::unique\_ptr<[Variable]( "LIEF::dwarf::Variable")> find\_variable(uint64\_t addr) const Try to find the [Variable]() at the given address. #### [` find_variable `]() std::unique\_ptr<[Variable]( "LIEF::dwarf::Variable")> find\_variable(const std::string &name) const Try to find the [Variable]() with the given name. #### [` functions `]() [functions\_it]( "LIEF::dwarf::CompilationUnit::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: ```cpp 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`. #### [` imported_functions `]() [functions\_it]( "LIEF::dwarf::CompilationUnit::functions_it") imported\_functions() const Return an iterator over the functions **imported** in this compilation unit **but not** implemented. For instance with this code: ```cpp #include 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 `]() [types\_it]( "LIEF::dwarf::CompilationUnit::types_it") types() const Return an iterator over the different types defined in this compilation unit. #### [` variables `]() [vars\_it]( "LIEF::dwarf::CompilationUnit::vars_it") variables() const Return an iterator over all the variables defined in this compilation unit: ```cpp 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; } ``` #### [` to_decl `]() std::string to\_decl(const [DeclOpt]( "LIEF::DeclOpt") &opt = [DeclOpt]( "LIEF::DeclOpt")()) const Generate a C/C++ definition for the functions defined in this compilation unit. #### [` Iterator `]() class Iterator : public LIEF::iterator\_facade\_base<[Iterator]( "LIEF::dwarf::CompilationUnit::Iterator"), std::bidirectional\_iterator\_tag, [CompilationUnit]( "LIEF::dwarf::CompilationUnit"), std::ptrdiff\_t, const [CompilationUnit]( "LIEF::dwarf::CompilationUnit")\*, const [CompilationUnit]( "LIEF::dwarf::CompilationUnit")&> Public Types ##### [` implementation `]() using implementation = details::CompilationUnitIt Public Functions ##### [` Iterator `]() Iterator() ##### [` Iterator `]() Iterator(std::unique\_ptr<details::CompilationUnitIt> impl) ##### [` Iterator `]() Iterator(const [Iterator]( "LIEF::dwarf::CompilationUnit::Iterator::Iterator")&) ##### [` operator= `]() [Iterator]( "LIEF::dwarf::CompilationUnit::Iterator") &operator=(const [Iterator]( "LIEF::dwarf::CompilationUnit::Iterator")&) ##### [` Iterator `]() Iterator([Iterator]( "LIEF::dwarf::CompilationUnit::Iterator::Iterator")&&) noexcept ##### [` operator= `]() [Iterator]( "LIEF::dwarf::CompilationUnit::Iterator") &operator=([Iterator]( "LIEF::dwarf::CompilationUnit::Iterator")&&) noexcept ##### [` ~Iterator `]() ~Iterator() ##### [` operator++ `]() [Iterator]( "LIEF::dwarf::CompilationUnit::Iterator") &operator++() ##### [` operator-- `]() [Iterator]( "LIEF::dwarf::CompilationUnit::Iterator") &operator--() ##### [` operator* `]() const [CompilationUnit]( "LIEF::dwarf::CompilationUnit") &operator\*() const ##### [` operator-> `]() const [CompilationUnit]( "LIEF::dwarf::CompilationUnit") \*operator->() const ##### [` yield `]() std::unique\_ptr<[CompilationUnit]( "LIEF::dwarf::CompilationUnit")> yield() Transfer ownership of the compilation unit at the current position to the caller. Returns `nullptr` if the iterator is past-the-end. ##### [` operator++ `]() inline DerivedT operator++(int) ##### [` operator-- `]() inline DerivedT operator--(int) Friends ##### [` operator== `]() friend bool operator==(const [Iterator]( "LIEF::dwarf::CompilationUnit::Iterator") &LHS, const [Iterator]( "LIEF::dwarf::CompilationUnit::Iterator") &RHS) ##### [` operator!= `]() inline friend bool operator!=(const [Iterator]( "LIEF::dwarf::CompilationUnit::Iterator") &LHS, const [Iterator]( "LIEF::dwarf::CompilationUnit::Iterator") &RHS) #### [` Language `]() 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 ##### [` LANG `]() enum LANG *Values:* ###### [` UNKNOWN `]() enumerator UNKNOWN = 0 ###### [` C `]() enumerator C ###### [` CPP `]() enumerator CPP ###### [` RUST `]() enumerator RUST ###### [` DART `]() enumerator DART ###### [` MODULA `]() enumerator MODULA ###### [` FORTRAN `]() enumerator FORTRAN ###### [` SWIFT `]() enumerator SWIFT ###### [` D `]() enumerator D ###### [` JAVA `]() enumerator JAVA ###### [` COBOL `]() enumerator COBOL Public Functions ##### [` Language `]() Language() = default ##### [` Language `]() inline Language([LANG]( "LIEF::dwarf::CompilationUnit::Language::LANG") lang, uint32\_t version) ##### [` Language `]() inline Language([LANG]( "LIEF::dwarf::CompilationUnit::Language::LANG") lang) ##### [` Language `]() Language(const [Language]( "LIEF::dwarf::CompilationUnit::Language::Language")&) = default ##### [` operator= `]() [Language]( "LIEF::dwarf::CompilationUnit::Language") &operator=(const [Language]( "LIEF::dwarf::CompilationUnit::Language")&) = default ##### [` Language `]() Language([Language]( "LIEF::dwarf::CompilationUnit::Language::Language")&&) = default ##### [` operator= `]() [Language]( "LIEF::dwarf::CompilationUnit::Language") &operator=([Language]( "LIEF::dwarf::CompilationUnit::Language")&&) = default ##### [` ~Language `]() ~Language() = default Public Members ##### [` lang `]() [LANG]( "LIEF::dwarf::CompilationUnit::Language::LANG") lang = [UNKNOWN]( "LIEF::dwarf::CompilationUnit::Language::UNKNOWN") The language itself. ##### [` version `]() uint32\_t version = 0 Version of the language (e.g. 17 for C++17). --- ## [Function]() ### [` 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 #### [` vars_it `]() using vars\_it = [iterator\_range]( "LIEF::iterator_range")<[Variable]( "LIEF::dwarf::Variable")::[Iterator]( "LIEF::dwarf::Variable::Iterator")> [Iterator]() over the variables defined in the scope of this function. #### [` parameters_t `]() using parameters\_t = std::vector<std::unique\_ptr<[Parameter]( "LIEF::dwarf::Parameter")>> #### [` thrown_types_t `]() using thrown\_types\_t = std::vector<std::unique\_ptr<[Type]( "LIEF::dwarf::Type")>> #### [` lexical_blocks_it `]() using lexical\_blocks\_it = [iterator\_range]( "LIEF::iterator_range")<[LexicalBlock]( "LIEF::dwarf::LexicalBlock")::[Iterator]( "LIEF::dwarf::LexicalBlock::Iterator")> #### [` instructions_it `]() using instructions\_it = [iterator\_range]( "LIEF::iterator_range")<assembly::[Instruction]( "LIEF::assembly::Instruction")::[Iterator]( "LIEF::assembly::Instruction::Iterator")> Public Functions #### [` Function `]() Function(std::unique\_ptr<details::Function> impl) #### [` name `]() std::string name() const The name of the function (`DW_AT_name`). #### [` linkage_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. #### [` address `]() [result]( "LIEF::result")<uint64\_t> address() const Return the address of the function (`DW_AT_entry_pc` or `DW_AT_low_pc`). #### [` variables `]() [vars\_it]( "LIEF::dwarf::Function::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. #### [` is_artificial `]() bool is\_artificial() const Whether this function is created by the compiler and not present in the original source code. #### [` is_external `]() bool is\_external() const Whether the function is defined **outside** the current compilation unit (`DW_AT_external`). #### [` size `]() uint64\_t size() const Return the size taken by this function in the binary. #### [` ranges `]() std::vector<range\_t> ranges() const Ranges of virtual addresses owned by this function. #### [` debug_location `]() [debug\_location\_t]( "LIEF::debug_location_t") debug\_location() const Original source code location. #### [` type `]() std::unique\_ptr<[Type]( "LIEF::dwarf::Type")> type() const Return the [dwarf::Type]() associated with the **return type** of this function. #### [` parameters `]() [parameters\_t]( "LIEF::dwarf::Function::parameters_t") parameters() const Return the function’s parameters (including any template parameter). #### [` thrown_types `]() [thrown\_types\_t]( "LIEF::dwarf::Function::thrown_types_t") thrown\_types() const List of exceptions (types) that can be thrown by the function. For instance, given this Swift code: ```swift func summarize(_ ratings: [Int]) throws(StatisticsError) { // ... } ``` [thrown\_types()]() returns one element associated with the [Type](): `StatisticsError`. #### [` scope `]() std::unique\_ptr<[Scope]( "LIEF::dwarf::Scope")> scope() const Return the scope in which this function is defined. #### [` instructions `]() [instructions\_it]( "LIEF::dwarf::Function::instructions_it") instructions() const Disassemble the current function by returning an iterator over the [assembly::Instruction](). #### [` lexical_blocks `]() [lexical\_blocks\_it]( "LIEF::dwarf::Function::lexical_blocks_it") lexical\_blocks() const [Iterator]() over the [LexicalBlock]() owned by this function. #### [` description `]() std::string description() const Description (`DW_AT_description`) of this function or an empty string. #### [` to_decl `]() std::string to\_decl(const [DeclOpt]( "LIEF::DeclOpt") &opt = [DeclOpt]( "LIEF::DeclOpt")()) const Generates a C/C++ definition for this function. #### [` ~Function `]() ~Function() #### [` Iterator `]() class Iterator : public LIEF::iterator\_facade\_base<[Iterator]( "LIEF::dwarf::Function::Iterator"), std::bidirectional\_iterator\_tag, [Function]( "LIEF::dwarf::Function"), std::ptrdiff\_t, const [Function]( "LIEF::dwarf::Function")\*, const [Function]( "LIEF::dwarf::Function")&> Public Types ##### [` implementation `]() using implementation = details::FunctionIt Public Functions ##### [` Iterator `]() Iterator() ##### [` Iterator `]() Iterator(std::unique\_ptr<details::FunctionIt> impl) ##### [` Iterator `]() Iterator(const [Iterator]( "LIEF::dwarf::Function::Iterator::Iterator")&) ##### [` operator= `]() [Iterator]( "LIEF::dwarf::Function::Iterator") &operator=(const [Iterator]( "LIEF::dwarf::Function::Iterator")&) ##### [` Iterator `]() Iterator([Iterator]( "LIEF::dwarf::Function::Iterator::Iterator")&&) noexcept ##### [` operator= `]() [Iterator]( "LIEF::dwarf::Function::Iterator") &operator=([Iterator]( "LIEF::dwarf::Function::Iterator")&&) noexcept ##### [` ~Iterator `]() ~Iterator() ##### [` operator++ `]() [Iterator]( "LIEF::dwarf::Function::Iterator") &operator++() ##### [` operator-- `]() [Iterator]( "LIEF::dwarf::Function::Iterator") &operator--() ##### [` operator* `]() const [Function]( "LIEF::dwarf::Function") &operator\*() const ##### [` operator-> `]() const [Function]( "LIEF::dwarf::Function") \*operator->() const ##### [` yield `]() std::unique\_ptr<[Function]( "LIEF::dwarf::Function")> yield() Transfer ownership of the function at the current position to the caller. Returns `nullptr` if the iterator is past-the-end. ##### [` operator++ `]() inline DerivedT operator++(int) ##### [` operator-- `]() inline DerivedT operator--(int) Friends ##### [` operator== `]() friend bool operator==(const [Iterator]( "LIEF::dwarf::Function::Iterator") &LHS, const [Iterator]( "LIEF::dwarf::Function::Iterator") &RHS) ##### [` operator!= `]() inline friend bool operator!=(const [Iterator]( "LIEF::dwarf::Function::Iterator") &LHS, const [Iterator]( "LIEF::dwarf::Function::Iterator") &RHS) --- ## [Parameter]() ### [` 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 #### [` KIND `]() enum class KIND *Values:* ##### [` UNKNOWN `]() enumerator UNKNOWN = 0 ##### [` TEMPLATE_TYPE `]() enumerator TEMPLATE\_TYPE DW\_TAG\_template\_type\_parameter. ##### [` TEMPLATE_VALUE `]() enumerator TEMPLATE\_VALUE DW\_TAG\_template\_value\_parameter. ##### [` FORMAL `]() enumerator FORMAL DW\_TAG\_formal\_parameter. Public Functions #### [` Parameter `]() Parameter() = delete #### [` Parameter `]() Parameter([Parameter]( "LIEF::dwarf::Parameter::Parameter") &&other) noexcept #### [` operator= `]() [Parameter]( "LIEF::dwarf::Parameter") &operator=([Parameter]( "LIEF::dwarf::Parameter") &&other) noexcept #### [` operator= `]() [Parameter]( "LIEF::dwarf::Parameter") &operator=(const [Parameter]( "LIEF::dwarf::Parameter")&) = delete #### [` Parameter `]() Parameter(const [Parameter]( "LIEF::dwarf::Parameter::Parameter")&) = delete #### [` kind `]() [KIND]( "LIEF::dwarf::Parameter::KIND") kind() const #### [` name `]() std::string name() const Name of the parameter. #### [` type `]() std::unique\_ptr<[Type]( "LIEF::dwarf::Type")> type() const [Type]() of this parameter. #### [` location `]() std::unique\_ptr<[Location]( "LIEF::dwarf::Parameter::Location")> location() const [Location]() of this parameter. For instance it can be a specific register that is not following the calling convention. #### [` Tas `]() template<class T> inline const [T]( "LIEF::dwarf::Parameter::as::T") \*as() const #### [` ~Parameter `]() virtual ~Parameter() Public Static Functions #### [` create `]() static std::unique\_ptr<[Parameter]( "LIEF::dwarf::Parameter")> create(std::unique\_ptr<details::Parameter> impl) #### [` Location `]() class Location This class exposes information about the location of a parameter. Subclassed by [LIEF::dwarf::Parameter::RegisterLoc]() Public Types ##### [` Type `]() enum class Type : uint8\_t *Values:* ###### [` UNKNOWN `]() enumerator UNKNOWN = 0 ###### [` REG `]() enumerator REG Public Functions ##### [` Location `]() inline Location([Type]( "LIEF::dwarf::Parameter::Location::Type") ty) ##### [` Tas `]() template<class T> inline const [T]( "LIEF::dwarf::Parameter::Location::as::T") \*as() const Public Members ##### [` type `]() [Type]( "LIEF::dwarf::Parameter::Location::Type") type = [Type]( "LIEF::dwarf::Parameter::Location::Type")::[UNKNOWN]( "LIEF::dwarf::Parameter::Location::Type::UNKNOWN") #### [` RegisterLoc `]() class RegisterLoc : public LIEF::dwarf::[Parameter]( "LIEF::dwarf::Parameter")::[Location]( "LIEF::dwarf::Parameter::Location") This class represents a register location. Public Functions ##### [` RegisterLoc `]() inline RegisterLoc(uint64\_t reg\_id) Public Members ##### [` id `]() uint64\_t id = 0 DWARF id of the register. Public Static Functions ##### [` classof `]() static inline bool classof(const [Location]( "LIEF::dwarf::Parameter::Location") \*loc) --- ## [Formal Parameter]() ### [` Formal `]() class Formal : public LIEF::dwarf::[Parameter]( "LIEF::dwarf::Parameter") This class represents a regular function parameter. For instance, given this prototype: ```cpp int main(int argc, const char** argv); ``` The function `main` has two [parameters::Formal]() parameters: 1. `argc` ([Parameter::name]()) typed as `int` ([types::Base]() from [Parameter::type]()) 2. `argv` ([Parameter::name]()) typed as `const char**` ([types::Const]() from [Parameter::type]()) Public Functions #### [` ~Formal `]() ~Formal() override = default #### [` Parameter `]() Parameter() = delete #### [` Parameter `]() Parameter([Parameter]( "LIEF::dwarf::parameters::Formal::Parameter") &&other) noexcept #### [` Parameter `]() Parameter(const [Parameter]( "LIEF::dwarf::parameters::Formal::Parameter")&) = delete Public Static Functions #### [` classof `]() static inline bool classof(const [Parameter]( "LIEF::dwarf::parameters::Formal::Parameter") \*P) --- ## [Template Value Parameter]() ### [` TemplateValue `]() class TemplateValue : public LIEF::dwarf::[Parameter]( "LIEF::dwarf::Parameter") This class represents a template **value** parameter. For instance, given this prototype: ```cpp template void generic(); ``` The function `generic` has one [parameters::TemplateValue]() parameter: `X`. Public Functions #### [` ~TemplateValue `]() ~TemplateValue() override = default #### [` Parameter `]() Parameter() = delete #### [` Parameter `]() Parameter([Parameter]( "LIEF::dwarf::parameters::TemplateValue::Parameter") &&other) noexcept #### [` Parameter `]() Parameter(const [Parameter]( "LIEF::dwarf::parameters::TemplateValue::Parameter")&) = delete Public Static Functions #### [` classof `]() static inline bool classof(const [Parameter]( "LIEF::dwarf::parameters::TemplateValue::Parameter") \*P) --- ## [Template Type Parameter]() ### [` TemplateType `]() class TemplateType : public LIEF::dwarf::[Parameter]( "LIEF::dwarf::Parameter") This class represents a template **type** parameter. For instance, given this prototype: ```cpp template void generic(); ``` The function `generic` has one [parameters::TemplateType]() parameter: `Y`. Public Functions #### [` ~TemplateType `]() ~TemplateType() override = default #### [` Parameter `]() Parameter() = delete #### [` Parameter `]() Parameter([Parameter]( "LIEF::dwarf::parameters::TemplateType::Parameter") &&other) noexcept #### [` Parameter `]() Parameter(const [Parameter]( "LIEF::dwarf::parameters::TemplateType::Parameter")&) = delete Public Static Functions #### [` classof `]() static inline bool classof(const [Parameter]( "LIEF::dwarf::parameters::TemplateType::Parameter") \*P) --- ## [Scope]() ### [` Scope `]() class Scope This class materializes a scope in which [Function](), [Variable](), [Type](), … can be defined. Public Types #### [` TYPE `]() enum class TYPE : uint32\_t *Values:* ##### [` UNKNOWN `]() enumerator UNKNOWN = 0 ##### [` UNION `]() enumerator UNION ##### [` CLASS `]() enumerator CLASS ##### [` STRUCT `]() enumerator STRUCT ##### [` NAMESPACE `]() enumerator NAMESPACE ##### [` FUNCTION `]() enumerator FUNCTION ##### [` COMPILATION_UNIT `]() enumerator COMPILATION\_UNIT Public Functions #### [` Scope `]() Scope(std::unique\_ptr<details::Scope> impl) #### [` name `]() std::string name() const Name of the scope. For instance namespace’s name or function’s name. #### [` parent `]() std::unique\_ptr<[Scope]( "LIEF::dwarf::Scope")> parent() const Parent scope (if any). #### [` type `]() [TYPE]( "LIEF::dwarf::Scope::TYPE") type() const The current scope type. #### [` chained `]() 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 `]() ~Scope() --- ## [Variable]() ### [` Variable `]() class Variable This class represents a DWARF variable which can be owned by a [dwarf::Function]() or a [dwarf::CompilationUnit](). Public Functions #### [` Variable `]() Variable(std::unique\_ptr<details::Variable> impl) #### [` name `]() std::string name() const Name of the variable (usually demangled). #### [` linkage_name `]() 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. #### [` address `]() [result]( "LIEF::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](). #### [` size `]() [result]( "LIEF::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. #### [` is_constexpr `]() bool is\_constexpr() const Whether it’s a `constexpr` variable. #### [` is_stack_based `]() bool is\_stack\_based() const Whether this variable is allocated on the stack. #### [` debug_location `]() [debug\_location\_t]( "LIEF::debug_location_t") debug\_location() const The original source location where the variable is defined. #### [` type `]() std::unique\_ptr<[Type]( "LIEF::dwarf::Type")> type() const Return the type of this variable. #### [` scope `]() std::unique\_ptr<[Scope]( "LIEF::dwarf::Scope")> scope() const Return the scope in which this variable is defined. #### [` description `]() std::string description() const Description (`DW_AT_description`) of the variable or an empty string. #### [` to_decl `]() std::string to\_decl(const [DeclOpt]( "LIEF::DeclOpt") &opt = [DeclOpt]( "LIEF::DeclOpt")()) const Generates a C/C++ definition for this variable. #### [` ~Variable `]() ~Variable() #### [` Iterator `]() class Iterator : public LIEF::iterator\_facade\_base<[Iterator]( "LIEF::dwarf::Variable::Iterator"), std::bidirectional\_iterator\_tag, [Variable]( "LIEF::dwarf::Variable"), std::ptrdiff\_t, const [Variable]( "LIEF::dwarf::Variable")\*, const [Variable]( "LIEF::dwarf::Variable")&> Public Types ##### [` implementation `]() using implementation = details::VariableIt Public Functions ##### [` Iterator `]() Iterator() ##### [` Iterator `]() Iterator(std::unique\_ptr<details::VariableIt> impl) ##### [` Iterator `]() Iterator(const [Iterator]( "LIEF::dwarf::Variable::Iterator::Iterator")&) ##### [` operator= `]() [Iterator]( "LIEF::dwarf::Variable::Iterator") &operator=(const [Iterator]( "LIEF::dwarf::Variable::Iterator")&) ##### [` Iterator `]() Iterator([Iterator]( "LIEF::dwarf::Variable::Iterator::Iterator")&&) noexcept ##### [` operator= `]() [Iterator]( "LIEF::dwarf::Variable::Iterator") &operator=([Iterator]( "LIEF::dwarf::Variable::Iterator")&&) noexcept ##### [` ~Iterator `]() ~Iterator() ##### [` operator++ `]() [Iterator]( "LIEF::dwarf::Variable::Iterator") &operator++() ##### [` operator-- `]() [Iterator]( "LIEF::dwarf::Variable::Iterator") &operator--() ##### [` operator* `]() const [Variable]( "LIEF::dwarf::Variable") &operator\*() const ##### [` operator-> `]() const [Variable]( "LIEF::dwarf::Variable") \*operator->() const ##### [` yield `]() std::unique\_ptr<[Variable]( "LIEF::dwarf::Variable")> yield() Transfer ownership of the variable at the current position to the caller. Returns `nullptr` if the iterator is past-the-end. ##### [` operator++ `]() inline DerivedT operator++(int) ##### [` operator-- `]() inline DerivedT operator--(int) Friends ##### [` operator== `]() friend bool operator==(const [Iterator]( "LIEF::dwarf::Variable::Iterator") &LHS, const [Iterator]( "LIEF::dwarf::Variable::Iterator") &RHS) ##### [` operator!= `]() inline friend bool operator!=(const [Iterator]( "LIEF::dwarf::Variable::Iterator") &LHS, const [Iterator]( "LIEF::dwarf::Variable::Iterator") &RHS) --- ## [LexicalBlock]() ### [` LexicalBlock `]() class LexicalBlock This class represents a DWARF lexical block (`DW_TAG_lexical_block`). Public Types #### [` sub_blocks_it `]() using sub\_blocks\_it = [iterator\_range]( "LIEF::iterator_range")<[Iterator]( "LIEF::dwarf::LexicalBlock::Iterator")> Public Functions #### [` LexicalBlock `]() LexicalBlock(std::unique\_ptr<details::LexicalBlock> impl) #### [` LexicalBlock `]() LexicalBlock() = delete #### [` operator= `]() [LexicalBlock]( "LIEF::dwarf::LexicalBlock") &operator=(const [LexicalBlock]( "LIEF::dwarf::LexicalBlock")&) = delete #### [` LexicalBlock `]() LexicalBlock(const [LexicalBlock]( "LIEF::dwarf::LexicalBlock::LexicalBlock")&) = delete #### [` name `]() std::string name() const Return the *name* associated with this lexical block or an empty string. #### [` description `]() std::string description() const Return the description associated with this lexical block or an empty string. #### [` sub_blocks `]() [sub\_blocks\_it]( "LIEF::dwarf::LexicalBlock::sub_blocks_it") sub\_blocks() const Return an iterator over the sub-LexicalBlock owned by this block. #### [` addr `]() std::optional<uint64\_t> addr() const Return the start address of this block. #### [` size `]() uint64\_t size() const Return the size of this block as the difference of the highest address and the lowest address. #### [` low_pc `]() std::optional<uint64\_t> low\_pc() const Return the lowest virtual address owned by this block. #### [` high_pc `]() std::optional<uint64\_t> high\_pc() const Return the highest virtual address owned by this block. #### [` ranges `]() 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 `]() ~LexicalBlock() Public Static Functions #### [` create `]() static std::unique\_ptr<[LexicalBlock]( "LIEF::dwarf::LexicalBlock")> create(std::unique\_ptr<details::LexicalBlock> impl) #### [` Iterator `]() class Iterator : public LIEF::iterator\_facade\_base<[Iterator]( "LIEF::dwarf::LexicalBlock::Iterator"), std::bidirectional\_iterator\_tag, [LexicalBlock]( "LIEF::dwarf::LexicalBlock"), std::ptrdiff\_t, const [LexicalBlock]( "LIEF::dwarf::LexicalBlock")\*, const [LexicalBlock]( "LIEF::dwarf::LexicalBlock")&> Public Types ##### [` implementation `]() using implementation = details::LexicalBlockIt Public Functions ##### [` Iterator `]() Iterator() ##### [` Iterator `]() Iterator(std::unique\_ptr<details::LexicalBlockIt> impl) ##### [` Iterator `]() Iterator(const [Iterator]( "LIEF::dwarf::LexicalBlock::Iterator::Iterator")&) ##### [` operator= `]() [Iterator]( "LIEF::dwarf::LexicalBlock::Iterator") &operator=(const [Iterator]( "LIEF::dwarf::LexicalBlock::Iterator")&) ##### [` Iterator `]() Iterator([Iterator]( "LIEF::dwarf::LexicalBlock::Iterator::Iterator")&&) noexcept ##### [` operator= `]() [Iterator]( "LIEF::dwarf::LexicalBlock::Iterator") &operator=([Iterator]( "LIEF::dwarf::LexicalBlock::Iterator")&&) noexcept ##### [` ~Iterator `]() ~Iterator() ##### [` operator++ `]() [Iterator]( "LIEF::dwarf::LexicalBlock::Iterator") &operator++() ##### [` operator-- `]() [Iterator]( "LIEF::dwarf::LexicalBlock::Iterator") &operator--() ##### [` operator* `]() const [LexicalBlock]( "LIEF::dwarf::LexicalBlock") &operator\*() const ##### [` operator-> `]() const [LexicalBlock]( "LIEF::dwarf::LexicalBlock") \*operator->() const ##### [` yield `]() std::unique\_ptr<[LexicalBlock]( "LIEF::dwarf::LexicalBlock")> yield() Transfer ownership of the lexical block at the current position to the caller. Returns `nullptr` if the iterator is past-the-end. ##### [` operator++ `]() inline DerivedT operator++(int) ##### [` operator-- `]() inline DerivedT operator--(int) Friends ##### [` operator== `]() friend bool operator==(const [Iterator]( "LIEF::dwarf::LexicalBlock::Iterator") &LHS, const [Iterator]( "LIEF::dwarf::LexicalBlock::Iterator") &RHS) ##### [` operator!= `]() inline friend bool operator!=(const [Iterator]( "LIEF::dwarf::LexicalBlock::Iterator") &LHS, const [Iterator]( "LIEF::dwarf::LexicalBlock::Iterator") &RHS) --- ## [Type]() ### [` 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` Subclassed by [LIEF::dwarf::types::Array](), [LIEF::dwarf::types::Atomic](), [LIEF::dwarf::types::Base](), [LIEF::dwarf::types::ClassLike](), [LIEF::dwarf::types::Coarray](), [LIEF::dwarf::types::Const](), [LIEF::dwarf::types::Dynamic](), [LIEF::dwarf::types::Enum](), [LIEF::dwarf::types::File](), [LIEF::dwarf::types::Immutable](), [LIEF::dwarf::types::Interface](), [LIEF::dwarf::types::Pointer](), [LIEF::dwarf::types::PointerToMember](), [LIEF::dwarf::types::RValueReference](), [LIEF::dwarf::types::Reference](), [LIEF::dwarf::types::Restrict](), [LIEF::dwarf::types::SetTy](), [LIEF::dwarf::types::Shared](), [LIEF::dwarf::types::StringTy](), [LIEF::dwarf::types::Subroutine](), [LIEF::dwarf::types::TemplateAlias](), [LIEF::dwarf::types::Thrown](), [LIEF::dwarf::types::Typedef](), [LIEF::dwarf::types::Volatile]() Public Types #### [` KIND `]() enum class KIND *Values:* ##### [` UNKNOWN `]() enumerator UNKNOWN = 0 ##### [` UNSPECIFIED `]() enumerator UNSPECIFIED ##### [` BASE `]() enumerator BASE ##### [` CONST_KIND `]() enumerator CONST\_KIND ##### [` CLASS `]() enumerator CLASS ##### [` ARRAY `]() enumerator ARRAY ##### [` POINTER `]() enumerator POINTER ##### [` STRUCT `]() enumerator STRUCT ##### [` UNION `]() enumerator UNION ##### [` TYPEDEF `]() enumerator TYPEDEF ##### [` REF `]() enumerator REF ##### [` SET_TYPE `]() enumerator SET\_TYPE ##### [` STRING `]() enumerator STRING ##### [` SUBROUTINE `]() enumerator SUBROUTINE ##### [` POINTER_MEMBER `]() enumerator POINTER\_MEMBER ##### [` PACKED `]() enumerator PACKED ##### [` FILE `]() enumerator FILE ##### [` THROWN `]() enumerator THROWN ##### [` VOLATILE `]() enumerator VOLATILE ##### [` RESTRICT `]() enumerator RESTRICT ##### [` INTERFACE `]() enumerator INTERFACE ##### [` SHARED `]() enumerator SHARED ##### [` RVALREF `]() enumerator RVALREF ##### [` TEMPLATE_ALIAS `]() enumerator TEMPLATE\_ALIAS ##### [` COARRAY `]() enumerator COARRAY ##### [` DYNAMIC `]() enumerator DYNAMIC ##### [` ATOMIC `]() enumerator ATOMIC ##### [` IMMUTABLE `]() enumerator IMMUTABLE ##### [` ENUM `]() enumerator ENUM Public Functions #### [` Type `]() Type(std::unique\_ptr<details::Type> impl) #### [` Type `]() Type(details::Type &impl) #### [` Type `]() Type(const [Type]( "LIEF::dwarf::Type::Type")&) = delete #### [` operator= `]() [Type]( "LIEF::dwarf::Type") &operator=(const [Type]( "LIEF::dwarf::Type")&) = delete #### [` Type `]() Type([Type]( "LIEF::dwarf::Type::Type")&&) noexcept #### [` operator= `]() [Type]( "LIEF::dwarf::Type") &operator=([Type]( "LIEF::dwarf::Type")&&) noexcept #### [` ~Type `]() virtual ~Type() #### [` kind `]() [KIND]( "LIEF::dwarf::Type::KIND") kind() const #### [` is_unspecified `]() inline bool is\_unspecified() const Whether this type is a `DW_TAG_unspecified_type`. #### [` name `]() [result]( "LIEF::result")<std::string> name() const Return the type’s name using either `DW_AT_name` or `DW_AT_picture_string` (if any). #### [` size `]() [result]( "LIEF::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)`. #### [` location `]() [debug\_location\_t]( "LIEF::debug_location_t") location() const Return the debug location where this type is defined. #### [` scope `]() std::unique\_ptr<[Scope]( "LIEF::dwarf::Scope")> scope() const Return the scope in which this type is defined. #### [` to_decl `]() std::string to\_decl(const [DeclOpt]( "LIEF::DeclOpt") &opt = [DeclOpt]( "LIEF::DeclOpt")()) const Generates a C/C++ definition for this type. #### [` Tas `]() template<class T> inline const [T]( "LIEF::dwarf::Type::as::T") \*as() const Public Static Functions #### [` create `]() static std::unique\_ptr<[Type]( "LIEF::dwarf::Type")> create(std::unique\_ptr<details::Type> impl) #### [` Iterator `]() class Iterator : public LIEF::iterator\_facade\_base<[Iterator]( "LIEF::dwarf::Type::Iterator"), std::bidirectional\_iterator\_tag, [Type]( "LIEF::dwarf::Type"), std::ptrdiff\_t, const [Type]( "LIEF::dwarf::Type")\*, const [Type]( "LIEF::dwarf::Type")&> Public Types ##### [` implementation `]() using implementation = details::TypeIt Public Functions ##### [` Iterator `]() Iterator() ##### [` Iterator `]() Iterator(std::unique\_ptr<details::TypeIt> impl) ##### [` Iterator `]() Iterator(const [Iterator]( "LIEF::dwarf::Type::Iterator::Iterator")&) ##### [` operator= `]() [Iterator]( "LIEF::dwarf::Type::Iterator") &operator=(const [Iterator]( "LIEF::dwarf::Type::Iterator")&) ##### [` Iterator `]() Iterator([Iterator]( "LIEF::dwarf::Type::Iterator::Iterator")&&) noexcept ##### [` operator= `]() [Iterator]( "LIEF::dwarf::Type::Iterator") &operator=([Iterator]( "LIEF::dwarf::Type::Iterator")&&) noexcept ##### [` ~Iterator `]() ~Iterator() ##### [` operator++ `]() [Iterator]( "LIEF::dwarf::Type::Iterator") &operator++() ##### [` operator-- `]() [Iterator]( "LIEF::dwarf::Type::Iterator") &operator--() ##### [` operator* `]() const [Type]( "LIEF::dwarf::Type") &operator\*() const ##### [` operator-> `]() const [Type]( "LIEF::dwarf::Type") \*operator->() const ##### [` yield `]() std::unique\_ptr<[Type]( "LIEF::dwarf::Type")> yield() Transfer ownership of the type at the current position to the caller. Returns `nullptr` if the iterator is past-the-end. ##### [` operator++ `]() inline DerivedT operator++(int) ##### [` operator-- `]() inline DerivedT operator--(int) Friends ##### [` operator== `]() friend bool operator==(const [Iterator]( "LIEF::dwarf::Type::Iterator") &LHS, const [Iterator]( "LIEF::dwarf::Type::Iterator") &RHS) ##### [` operator!= `]() inline friend bool operator!=(const [Iterator]( "LIEF::dwarf::Type::Iterator") &LHS, const [Iterator]( "LIEF::dwarf::Type::Iterator") &RHS) --- ## [Array]() ### [` Array `]() class Array : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_array_type`. Public Functions #### [` ArgsArray `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::Array::Array::Args")&&...>>> inline Array([Args]( "LIEF::dwarf::types::Array::Array::Args")&&... args) #### [` Array `]() Array(const [Array]( "LIEF::dwarf::types::Array::Array")&) = delete #### [` operator= `]() [Array]( "LIEF::dwarf::types::Array") &operator=(const [Array]( "LIEF::dwarf::types::Array")&) = delete #### [` Array `]() Array([Array]( "LIEF::dwarf::types::Array::Array")&&) noexcept = default #### [` operator= `]() [Array]( "LIEF::dwarf::types::Array") &operator=([Array]( "LIEF::dwarf::types::Array")&&) noexcept = default #### [` underlying_type `]() const [Type]( "LIEF::dwarf::Type") \*underlying\_type() const The underlying type of this array. #### [` operator-> `]() inline const [Type]( "LIEF::dwarf::Type") \*operator->() const #### [` operator* `]() inline const [Type]( "LIEF::dwarf::Type") &operator\*() const #### [` size_info `]() [size\_info\_t]( "LIEF::dwarf::types::Array::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 `]() ~Array() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) #### [` size_info_t `]() struct size\_info\_t [Structure]() that wraps information about the dimension of this array. Public Functions ##### [` operator bool `]() inline operator bool() const Public Members ##### [` type `]() std::unique\_ptr<[Type]( "LIEF::dwarf::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`. ##### [` name `]() std::string name Name of the index (usually not relevant like `__ARRAY_SIZE_TYPE__`). ##### [` size `]() size\_t size = 0 Size of the array. For instance in `uint8_t[3]`, it returns 3. --- ## [Base]() ### [` Base `]() class Base : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class wraps the `DW_TAG_base_type` type which can be used &#8212; for instance &#8212; to represent integers or primitive types. Public Types #### [` ENCODING `]() enum class ENCODING *Values:* ##### [` NONE `]() enumerator NONE = 0 ##### [` SIGNED `]() enumerator SIGNED Mirror `DW_ATE_signed`. ##### [` SIGNED_CHAR `]() enumerator SIGNED\_CHAR Mirror `DW_ATE_signed_char`. ##### [` UNSIGNED `]() enumerator UNSIGNED Mirror `DW_ATE_unsigned`. ##### [` UNSIGNED_CHAR `]() enumerator UNSIGNED\_CHAR Mirror `DW_ATE_unsigned_char`. ##### [` FLOAT `]() enumerator FLOAT Mirror `DW_ATE_float`. ##### [` BOOLEAN `]() enumerator BOOLEAN Mirror `DW_ATE_boolean`. ##### [` ADDRESS `]() enumerator ADDRESS Mirror `DW_ATE_address`. Public Functions #### [` ArgsBase `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::Base::Base::Args")&&...>>> inline Base([Args]( "LIEF::dwarf::types::Base::Base::Args")&&... args) #### [` Base `]() Base(const [Base]( "LIEF::dwarf::types::Base::Base")&) = delete #### [` operator= `]() [Base]( "LIEF::dwarf::types::Base") &operator=(const [Base]( "LIEF::dwarf::types::Base")&) = delete #### [` Base `]() Base([Base]( "LIEF::dwarf::types::Base::Base")&&) noexcept = default #### [` operator= `]() [Base]( "LIEF::dwarf::types::Base") &operator=([Base]( "LIEF::dwarf::types::Base")&&) noexcept = default #### [` encoding `]() [ENCODING]( "LIEF::dwarf::types::Base::ENCODING") encoding() const Describe how the base type is encoded and should be interpreted. #### [` ~Base `]() ~Base() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [ClassLike]() ### [` ClassLike `]() class ClassLike : public LIEF::dwarf::[Type]( "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 #### [` functions_it `]() using functions\_it = [iterator\_range]( "LIEF::iterator_range")<[Function]( "LIEF::dwarf::Function")::[Iterator]( "LIEF::dwarf::Function::Iterator")> Public Functions #### [` ArgsClassLike `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::ClassLike::ClassLike::Args")&&...>>> inline ClassLike([Args]( "LIEF::dwarf::types::ClassLike::ClassLike::Args")&&... args) #### [` ClassLike `]() ClassLike(const [ClassLike]( "LIEF::dwarf::types::ClassLike::ClassLike")&) = delete #### [` operator= `]() [ClassLike]( "LIEF::dwarf::types::ClassLike") &operator=(const [ClassLike]( "LIEF::dwarf::types::ClassLike")&) = delete #### [` ClassLike `]() ClassLike([ClassLike]( "LIEF::dwarf::types::ClassLike::ClassLike")&&) noexcept = default #### [` operator= `]() [ClassLike]( "LIEF::dwarf::types::ClassLike") &operator=([ClassLike]( "LIEF::dwarf::types::ClassLike")&&) noexcept = default #### [` members `]() std::vector<[Member]( "LIEF::dwarf::types::ClassLike::Member")> members() const Return the list of all the attributes defined in this class-like type. #### [` find_member `]() std::unique\_ptr<[Member]( "LIEF::dwarf::types::ClassLike::Member")> find\_member(uint64\_t offset) const Try to find the attribute at the given offset. #### [` functions `]() [functions\_it]( "LIEF::dwarf::types::ClassLike::functions_it") functions() const [Iterator]() over the functions defined by the class-like. #### [` ~ClassLike `]() ~ClassLike() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) #### [` Member `]() class Member This represents a class/struct/union attribute. Public Functions ##### [` Member `]() Member(std::unique\_ptr<details::Member> impl) ##### [` Member `]() Member([Member]( "LIEF::dwarf::types::ClassLike::Member::Member") &&other) noexcept ##### [` operator= `]() [Member]( "LIEF::dwarf::types::ClassLike::Member") &operator=([Member]( "LIEF::dwarf::types::ClassLike::Member") &&other) noexcept ##### [` Member `]() Member(const [Member]( "LIEF::dwarf::types::ClassLike::Member::Member")&) = delete ##### [` operator= `]() [Member]( "LIEF::dwarf::types::ClassLike::Member") &operator=(const [Member]( "LIEF::dwarf::types::ClassLike::Member")&) = delete ##### [` name `]() std::string name() const Name of the member. ##### [` offset `]() [result]( "LIEF::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]() ##### [` bit_offset `]() [result]( "LIEF::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: ```cpp 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]() ##### [` bit_size `]() [result]( "LIEF::result")<uint64\_t> bit\_size() const If the current member is a bit-field, this function returns its size in bits. ##### [` type `]() std::unique\_ptr<[Type]( "LIEF::dwarf::Type")> type() const [Type]() of the current member. ##### [` is_external `]() bool is\_external() const ##### [` is_declaration `]() bool is\_declaration() const ##### [` ~Member `]() ~Member() --- ## [Structure]() ### [` Structure `]() class Structure : public LIEF::dwarf::types::[ClassLike]( "LIEF::dwarf::types::ClassLike") This class represents a DWARF `struct` type (`DW_TAG_structure_type`). Public Functions #### [` ArgsStructure `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[ClassLike]( "LIEF::dwarf::types::ClassLike"), [Args]( "LIEF::dwarf::types::Structure::Structure::Args")&&...>>> inline Structure([Args]( "LIEF::dwarf::types::Structure::Structure::Args")&&... args) #### [` Structure `]() Structure(const [Structure]( "LIEF::dwarf::types::Structure::Structure")&) = delete #### [` operator= `]() [Structure]( "LIEF::dwarf::types::Structure") &operator=(const [Structure]( "LIEF::dwarf::types::Structure")&) = delete #### [` Structure `]() Structure([Structure]( "LIEF::dwarf::types::Structure::Structure")&&) noexcept = default #### [` operator= `]() [Structure]( "LIEF::dwarf::types::Structure") &operator=([Structure]( "LIEF::dwarf::types::Structure")&&) noexcept = default #### [` ~Structure `]() ~Structure() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [Class]() ### [` Class `]() class Class : public LIEF::dwarf::types::[ClassLike]( "LIEF::dwarf::types::ClassLike") This class represents a DWARF `class` type (`DW_TAG_class_type`). Public Functions #### [` ArgsClass `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[ClassLike]( "LIEF::dwarf::types::ClassLike"), [Args]( "LIEF::dwarf::types::Class::Class::Args")&&...>>> inline Class([Args]( "LIEF::dwarf::types::Class::Class::Args")&&... args) #### [` Class `]() Class(const [Class]( "LIEF::dwarf::types::Class::Class")&) = delete #### [` operator= `]() [Class]( "LIEF::dwarf::types::Class") &operator=(const [Class]( "LIEF::dwarf::types::Class")&) = delete #### [` Class `]() Class([Class]( "LIEF::dwarf::types::Class::Class")&&) noexcept = default #### [` operator= `]() [Class]( "LIEF::dwarf::types::Class") &operator=([Class]( "LIEF::dwarf::types::Class")&&) noexcept = default #### [` ~Class `]() ~Class() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [Union]() ### [` Union `]() class Union : public LIEF::dwarf::types::[ClassLike]( "LIEF::dwarf::types::ClassLike") This class represents a DWARF `union` type (`DW_TAG_union_type`). Public Functions #### [` ArgsUnion `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[ClassLike]( "LIEF::dwarf::types::ClassLike"), [Args]( "LIEF::dwarf::types::Union::Union::Args")&&...>>> inline Union([Args]( "LIEF::dwarf::types::Union::Union::Args")&&... args) #### [` Union `]() Union(const [Union]( "LIEF::dwarf::types::Union::Union")&) = delete #### [` operator= `]() [Union]( "LIEF::dwarf::types::Union") &operator=(const [Union]( "LIEF::dwarf::types::Union")&) = delete #### [` Union `]() Union([Union]( "LIEF::dwarf::types::Union::Union")&&) noexcept = default #### [` operator= `]() [Union]( "LIEF::dwarf::types::Union") &operator=([Union]( "LIEF::dwarf::types::Union")&&) noexcept = default #### [` ~Union `]() ~Union() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [Packed]() ### [` Packed `]() class Packed : public LIEF::dwarf::types::[ClassLike]( "LIEF::dwarf::types::ClassLike") This class represents a DWARF `packed` type (`DW_TAG_packed_type`). Public Functions #### [` ArgsPacked `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[ClassLike]( "LIEF::dwarf::types::ClassLike"), [Args]( "LIEF::dwarf::types::Packed::Packed::Args")&&...>>> inline Packed([Args]( "LIEF::dwarf::types::Packed::Packed::Args")&&... args) #### [` Packed `]() Packed(const [Packed]( "LIEF::dwarf::types::Packed::Packed")&) = delete #### [` operator= `]() [Packed]( "LIEF::dwarf::types::Packed") &operator=(const [Packed]( "LIEF::dwarf::types::Packed")&) = delete #### [` Packed `]() Packed([Packed]( "LIEF::dwarf::types::Packed::Packed")&&) noexcept = default #### [` operator= `]() [Packed]( "LIEF::dwarf::types::Packed") &operator=([Packed]( "LIEF::dwarf::types::Packed")&&) noexcept = default #### [` ~Packed `]() ~Packed() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [Const]() ### [` Const `]() class Const : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_const_type`. Public Functions #### [` ArgsConst `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::Const::Const::Args")&&...>>> inline Const([Args]( "LIEF::dwarf::types::Const::Const::Args")&&... args) #### [` Const `]() Const(const [Const]( "LIEF::dwarf::types::Const::Const")&) = delete #### [` operator= `]() [Const]( "LIEF::dwarf::types::Const") &operator=(const [Const]( "LIEF::dwarf::types::Const")&) = delete #### [` Const `]() Const([Const]( "LIEF::dwarf::types::Const::Const")&&) noexcept = default #### [` operator= `]() [Const]( "LIEF::dwarf::types::Const") &operator=([Const]( "LIEF::dwarf::types::Const")&&) noexcept = default #### [` underlying_type `]() const [Type]( "LIEF::dwarf::Type") \*underlying\_type() const The underlying type being const-ed. #### [` operator-> `]() inline const [Type]( "LIEF::dwarf::Type") \*operator->() const #### [` operator* `]() inline const [Type]( "LIEF::dwarf::Type") &operator\*() const #### [` ~Const `]() ~Const() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [Pointer]() ### [` Pointer `]() class Pointer : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_pointer_type` DWARF type. Public Functions #### [` ArgsPointer `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::Pointer::Pointer::Args")&&...>>> inline Pointer([Args]( "LIEF::dwarf::types::Pointer::Pointer::Args")&&... args) #### [` Pointer `]() Pointer(const [Pointer]( "LIEF::dwarf::types::Pointer::Pointer")&) = delete #### [` operator= `]() [Pointer]( "LIEF::dwarf::types::Pointer") &operator=(const [Pointer]( "LIEF::dwarf::types::Pointer")&) = delete #### [` Pointer `]() Pointer([Pointer]( "LIEF::dwarf::types::Pointer::Pointer")&&) noexcept = default #### [` operator= `]() [Pointer]( "LIEF::dwarf::types::Pointer") &operator=([Pointer]( "LIEF::dwarf::types::Pointer")&&) noexcept = default #### [` underlying_type `]() const [Type]( "LIEF::dwarf::Type") \*underlying\_type() const The type pointed by this pointer. #### [` operator-> `]() inline const [Type]( "LIEF::dwarf::Type") \*operator->() const #### [` operator* `]() inline const [Type]( "LIEF::dwarf::Type") &operator\*() const #### [` ~Pointer `]() ~Pointer() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [Typedef]() ### [` Typedef `]() class Typedef : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_typedef` type. Public Functions #### [` ArgsTypedef `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::Typedef::Typedef::Args")&&...>>> inline Typedef([Args]( "LIEF::dwarf::types::Typedef::Typedef::Args")&&... args) #### [` Typedef `]() Typedef(const [Typedef]( "LIEF::dwarf::types::Typedef::Typedef")&) = delete #### [` operator= `]() [Typedef]( "LIEF::dwarf::types::Typedef") &operator=(const [Typedef]( "LIEF::dwarf::types::Typedef")&) = delete #### [` Typedef `]() Typedef([Typedef]( "LIEF::dwarf::types::Typedef::Typedef")&&) noexcept = default #### [` operator= `]() [Typedef]( "LIEF::dwarf::types::Typedef") &operator=([Typedef]( "LIEF::dwarf::types::Typedef")&&) noexcept = default #### [` underlying_type `]() const [Type]( "LIEF::dwarf::Type") \*underlying\_type() const The type aliased by this typedef. #### [` operator-> `]() inline const [Type]( "LIEF::dwarf::Type") \*operator->() const #### [` operator* `]() inline const [Type]( "LIEF::dwarf::Type") &operator\*() const #### [` ~Typedef `]() ~Typedef() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [Atomic]() ### [` Atomic `]() class Atomic : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_atomic_type`. Public Functions #### [` ArgsAtomic `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::Atomic::Atomic::Args")&&...>>> inline Atomic([Args]( "LIEF::dwarf::types::Atomic::Atomic::Args")&&... args) #### [` Atomic `]() Atomic(const [Atomic]( "LIEF::dwarf::types::Atomic::Atomic")&) = delete #### [` operator= `]() [Atomic]( "LIEF::dwarf::types::Atomic") &operator=(const [Atomic]( "LIEF::dwarf::types::Atomic")&) = delete #### [` Atomic `]() Atomic([Atomic]( "LIEF::dwarf::types::Atomic::Atomic")&&) noexcept = default #### [` operator= `]() [Atomic]( "LIEF::dwarf::types::Atomic") &operator=([Atomic]( "LIEF::dwarf::types::Atomic")&&) noexcept = default #### [` underlying_type `]() const [Type]( "LIEF::dwarf::Type") \*underlying\_type() const The underlying type being atomic. #### [` operator-> `]() inline const [Type]( "LIEF::dwarf::Type") \*operator->() const #### [` operator* `]() inline const [Type]( "LIEF::dwarf::Type") &operator\*() const #### [` ~Atomic `]() ~Atomic() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [Coarray]() ### [` Coarray `]() class Coarray : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_coarray_type`. Public Functions #### [` ArgsCoarray `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::Coarray::Coarray::Args")&&...>>> inline Coarray([Args]( "LIEF::dwarf::types::Coarray::Coarray::Args")&&... args) #### [` Coarray `]() Coarray(const [Coarray]( "LIEF::dwarf::types::Coarray::Coarray")&) = delete #### [` operator= `]() [Coarray]( "LIEF::dwarf::types::Coarray") &operator=(const [Coarray]( "LIEF::dwarf::types::Coarray")&) = delete #### [` Coarray `]() Coarray([Coarray]( "LIEF::dwarf::types::Coarray::Coarray")&&) noexcept = default #### [` operator= `]() [Coarray]( "LIEF::dwarf::types::Coarray") &operator=([Coarray]( "LIEF::dwarf::types::Coarray")&&) noexcept = default #### [` ~Coarray `]() ~Coarray() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [Dynamic]() ### [` Dynamic `]() class Dynamic : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_dynamic_type`. Public Functions #### [` ArgsDynamic `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::Dynamic::Dynamic::Args")&&...>>> inline Dynamic([Args]( "LIEF::dwarf::types::Dynamic::Dynamic::Args")&&... args) #### [` Dynamic `]() Dynamic(const [Dynamic]( "LIEF::dwarf::types::Dynamic::Dynamic")&) = delete #### [` operator= `]() [Dynamic]( "LIEF::dwarf::types::Dynamic") &operator=(const [Dynamic]( "LIEF::dwarf::types::Dynamic")&) = delete #### [` Dynamic `]() Dynamic([Dynamic]( "LIEF::dwarf::types::Dynamic::Dynamic")&&) noexcept = default #### [` operator= `]() [Dynamic]( "LIEF::dwarf::types::Dynamic") &operator=([Dynamic]( "LIEF::dwarf::types::Dynamic")&&) noexcept = default #### [` ~Dynamic `]() ~Dynamic() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [Enum]() ### [` Enum `]() class Enum : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_enumeration_type`. Public Functions #### [` ArgsEnum `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::Enum::Enum::Args")&&...>>> inline Enum([Args]( "LIEF::dwarf::types::Enum::Enum::Args")&&... args) #### [` Enum `]() Enum(const [Enum]( "LIEF::dwarf::types::Enum::Enum")&) = delete #### [` operator= `]() [Enum]( "LIEF::dwarf::types::Enum") &operator=(const [Enum]( "LIEF::dwarf::types::Enum")&) = delete #### [` Enum `]() Enum([Enum]( "LIEF::dwarf::types::Enum::Enum")&&) noexcept = default #### [` operator= `]() [Enum]( "LIEF::dwarf::types::Enum") &operator=([Enum]( "LIEF::dwarf::types::Enum")&&) noexcept = default #### [` entries `]() std::vector<[Entry]( "LIEF::dwarf::types::Enum::Entry")> entries() const Return the different entries associated with this enum. #### [` underlying_type `]() const [Type]( "LIEF::dwarf::Type") \*underlying\_type() const The underlying type that is used to encode this enum. #### [` find_entry `]() std::optional<[Entry]( "LIEF::dwarf::types::Enum::Entry")> find\_entry(int64\_t value) const Try to find the enum matching the given value. #### [` ~Enum `]() ~Enum() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) #### [` Entry `]() class Entry This class represents an enum entry which is essentially composed of a name and its value (integer). Public Functions ##### [` Entry `]() Entry(std::unique\_ptr<details::EnumEntry> impl) ##### [` Entry `]() Entry([Entry]( "LIEF::dwarf::types::Enum::Entry::Entry") &&other) noexcept ##### [` operator= `]() [Entry]( "LIEF::dwarf::types::Enum::Entry") &operator=([Entry]( "LIEF::dwarf::types::Enum::Entry") &&other) noexcept ##### [` Entry `]() Entry(const [Entry]( "LIEF::dwarf::types::Enum::Entry::Entry")&) = delete ##### [` operator= `]() [Entry]( "LIEF::dwarf::types::Enum::Entry") &operator=(const [Entry]( "LIEF::dwarf::types::Enum::Entry")&) = delete ##### [` name `]() std::string name() const [Enum]() entry’s name. ##### [` value `]() std::optional<int64\_t> value() const [Enum]() entry’s value (if any). ##### [` ~Entry `]() ~Entry() --- ## [File]() ### [` File `]() class File : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_file_type`. Public Functions #### [` ArgsFile `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::File::File::Args")&&...>>> inline File([Args]( "LIEF::dwarf::types::File::File::Args")&&... args) #### [` File `]() File(const [File]( "LIEF::dwarf::types::File::File")&) = delete #### [` operator= `]() [File]( "LIEF::dwarf::types::File") &operator=(const [File]( "LIEF::dwarf::types::File")&) = delete #### [` File `]() File([File]( "LIEF::dwarf::types::File::File")&&) noexcept = default #### [` operator= `]() [File]( "LIEF::dwarf::types::File") &operator=([File]( "LIEF::dwarf::types::File")&&) noexcept = default #### [` ~File `]() ~File() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [Immutable]() ### [` Immutable `]() class Immutable : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_immutable_type`. Public Functions #### [` ArgsImmutable `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::Immutable::Immutable::Args")&&...>>> inline Immutable([Args]( "LIEF::dwarf::types::Immutable::Immutable::Args")&&... args) #### [` Immutable `]() Immutable(const [Immutable]( "LIEF::dwarf::types::Immutable::Immutable")&) = delete #### [` operator= `]() [Immutable]( "LIEF::dwarf::types::Immutable") &operator=(const [Immutable]( "LIEF::dwarf::types::Immutable")&) = delete #### [` Immutable `]() Immutable([Immutable]( "LIEF::dwarf::types::Immutable::Immutable")&&) noexcept = default #### [` operator= `]() [Immutable]( "LIEF::dwarf::types::Immutable") &operator=([Immutable]( "LIEF::dwarf::types::Immutable")&&) noexcept = default #### [` underlying_type `]() const [Type]( "LIEF::dwarf::Type") \*underlying\_type() const The underlying type. #### [` operator-> `]() inline const [Type]( "LIEF::dwarf::Type") \*operator->() const #### [` operator* `]() inline const [Type]( "LIEF::dwarf::Type") &operator\*() const #### [` ~Immutable `]() ~Immutable() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [Interface]() ### [` Interface `]() class Interface : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_interface_type`. Public Functions #### [` ArgsInterface `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::Interface::Interface::Args")&&...>>> inline Interface([Args]( "LIEF::dwarf::types::Interface::Interface::Args")&&... args) #### [` Interface `]() Interface(const [Interface]( "LIEF::dwarf::types::Interface::Interface")&) = delete #### [` operator= `]() [Interface]( "LIEF::dwarf::types::Interface") &operator=(const [Interface]( "LIEF::dwarf::types::Interface")&) = delete #### [` Interface `]() Interface([Interface]( "LIEF::dwarf::types::Interface::Interface")&&) noexcept = default #### [` operator= `]() [Interface]( "LIEF::dwarf::types::Interface") &operator=([Interface]( "LIEF::dwarf::types::Interface")&&) noexcept = default #### [` ~Interface `]() ~Interface() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [PointerToMember]() ### [` PointerToMember `]() class PointerToMember : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_ptr_to_member_type`. Public Functions #### [` ArgsPointerToMember `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::PointerToMember::PointerToMember::Args")&&...>>> inline PointerToMember([Args]( "LIEF::dwarf::types::PointerToMember::PointerToMember::Args")&&... args) #### [` PointerToMember `]() PointerToMember(const [PointerToMember]( "LIEF::dwarf::types::PointerToMember::PointerToMember")&) = delete #### [` operator= `]() [PointerToMember]( "LIEF::dwarf::types::PointerToMember") &operator=(const [PointerToMember]( "LIEF::dwarf::types::PointerToMember")&) = delete #### [` PointerToMember `]() PointerToMember([PointerToMember]( "LIEF::dwarf::types::PointerToMember::PointerToMember")&&) noexcept = default #### [` operator= `]() [PointerToMember]( "LIEF::dwarf::types::PointerToMember") &operator=([PointerToMember]( "LIEF::dwarf::types::PointerToMember")&&) noexcept = default #### [` underlying_type `]() const [Type]( "LIEF::dwarf::Type") \*underlying\_type() const The type of the member referenced by this pointer. #### [` operator-> `]() inline const [Type]( "LIEF::dwarf::Type") \*operator->() const #### [` operator* `]() inline const [Type]( "LIEF::dwarf::Type") \*operator\*() const #### [` containing_type `]() std::unique\_ptr<[Type]( "LIEF::dwarf::Type")> containing\_type() const The type that embeds this member. #### [` ~PointerToMember `]() ~PointerToMember() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [RValueReference]() ### [` RValueReference `]() class RValueReference : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_rvalue_reference_type`. Public Functions #### [` ArgsRValueReference `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::RValueReference::RValueReference::Args")&&...>>> inline RValueReference([Args]( "LIEF::dwarf::types::RValueReference::RValueReference::Args")&&... args) #### [` RValueReference `]() RValueReference(const [RValueReference]( "LIEF::dwarf::types::RValueReference::RValueReference")&) = delete #### [` operator= `]() [RValueReference]( "LIEF::dwarf::types::RValueReference") &operator=(const [RValueReference]( "LIEF::dwarf::types::RValueReference")&) = delete #### [` RValueReference `]() RValueReference([RValueReference]( "LIEF::dwarf::types::RValueReference::RValueReference")&&) noexcept = default #### [` operator= `]() [RValueReference]( "LIEF::dwarf::types::RValueReference") &operator=([RValueReference]( "LIEF::dwarf::types::RValueReference")&&) noexcept = default #### [` underlying_type `]() const [Type]( "LIEF::dwarf::Type") \*underlying\_type() const The underlying type referenced by this rvalue-type. #### [` operator-> `]() inline const [Type]( "LIEF::dwarf::Type") \*operator->() const #### [` operator* `]() inline const [Type]( "LIEF::dwarf::Type") \*operator\*() const #### [` ~RValueReference `]() ~RValueReference() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [Reference]() ### [` Reference `]() class Reference : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_reference_type`. Public Functions #### [` ArgsReference `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::Reference::Reference::Args")&&...>>> inline Reference([Args]( "LIEF::dwarf::types::Reference::Reference::Args")&&... args) #### [` Reference `]() Reference(const [Reference]( "LIEF::dwarf::types::Reference::Reference")&) = delete #### [` operator= `]() [Reference]( "LIEF::dwarf::types::Reference") &operator=(const [Reference]( "LIEF::dwarf::types::Reference")&) = delete #### [` Reference `]() Reference([Reference]( "LIEF::dwarf::types::Reference::Reference")&&) noexcept = default #### [` operator= `]() [Reference]( "LIEF::dwarf::types::Reference") &operator=([Reference]( "LIEF::dwarf::types::Reference")&&) noexcept = default #### [` underlying_type `]() const [Type]( "LIEF::dwarf::Type") \*underlying\_type() const The underlying type referenced by this ref-type. #### [` operator-> `]() inline const [Type]( "LIEF::dwarf::Type") \*operator->() const #### [` operator* `]() inline const [Type]( "LIEF::dwarf::Type") \*operator\*() const #### [` ~Reference `]() ~Reference() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [Restrict]() ### [` Restrict `]() class Restrict : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_restrict_type`. Public Functions #### [` ArgsRestrict `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::Restrict::Restrict::Args")&&...>>> inline Restrict([Args]( "LIEF::dwarf::types::Restrict::Restrict::Args")&&... args) #### [` Restrict `]() Restrict(const [Restrict]( "LIEF::dwarf::types::Restrict::Restrict")&) = delete #### [` operator= `]() [Restrict]( "LIEF::dwarf::types::Restrict") &operator=(const [Restrict]( "LIEF::dwarf::types::Restrict")&) = delete #### [` Restrict `]() Restrict([Restrict]( "LIEF::dwarf::types::Restrict::Restrict")&&) noexcept = default #### [` operator= `]() [Restrict]( "LIEF::dwarf::types::Restrict") &operator=([Restrict]( "LIEF::dwarf::types::Restrict")&&) noexcept = default #### [` underlying_type `]() const [Type]( "LIEF::dwarf::Type") \*underlying\_type() const The underlying type referenced by this restrict-type. #### [` operator-> `]() inline const [Type]( "LIEF::dwarf::Type") \*operator->() const #### [` operator* `]() inline const [Type]( "LIEF::dwarf::Type") \*operator\*() const #### [` ~Restrict `]() ~Restrict() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [SetTy]() ### [` SetTy `]() class SetTy : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_set_type`. Public Functions #### [` ArgsSetTy `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::SetTy::SetTy::Args")&&...>>> inline SetTy([Args]( "LIEF::dwarf::types::SetTy::SetTy::Args")&&... args) #### [` SetTy `]() SetTy(const [SetTy]( "LIEF::dwarf::types::SetTy::SetTy")&) = delete #### [` operator= `]() [SetTy]( "LIEF::dwarf::types::SetTy") &operator=(const [SetTy]( "LIEF::dwarf::types::SetTy")&) = delete #### [` SetTy `]() SetTy([SetTy]( "LIEF::dwarf::types::SetTy::SetTy")&&) noexcept = default #### [` operator= `]() [SetTy]( "LIEF::dwarf::types::SetTy") &operator=([SetTy]( "LIEF::dwarf::types::SetTy")&&) noexcept = default #### [` underlying_type `]() const [Type]( "LIEF::dwarf::Type") \*underlying\_type() const The underlying type referenced by this set-type. #### [` operator-> `]() inline const [Type]( "LIEF::dwarf::Type") \*operator->() const #### [` operator* `]() inline const [Type]( "LIEF::dwarf::Type") \*operator\*() const #### [` ~SetTy `]() ~SetTy() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [Shared]() ### [` Shared `]() class Shared : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_shared_type`. Public Functions #### [` ArgsShared `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::Shared::Shared::Args")&&...>>> inline Shared([Args]( "LIEF::dwarf::types::Shared::Shared::Args")&&... args) #### [` Shared `]() Shared(const [Shared]( "LIEF::dwarf::types::Shared::Shared")&) = delete #### [` operator= `]() [Shared]( "LIEF::dwarf::types::Shared") &operator=(const [Shared]( "LIEF::dwarf::types::Shared")&) = delete #### [` Shared `]() Shared([Shared]( "LIEF::dwarf::types::Shared::Shared")&&) noexcept = default #### [` operator= `]() [Shared]( "LIEF::dwarf::types::Shared") &operator=([Shared]( "LIEF::dwarf::types::Shared")&&) noexcept = default #### [` underlying_type `]() const [Type]( "LIEF::dwarf::Type") \*underlying\_type() const The underlying type referenced by this shared-type. #### [` operator-> `]() inline const [Type]( "LIEF::dwarf::Type") \*operator->() const #### [` operator* `]() inline const [Type]( "LIEF::dwarf::Type") \*operator\*() const #### [` ~Shared `]() ~Shared() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [StringTy]() ### [` StringTy `]() class StringTy : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_string_type`. Public Functions #### [` ArgsStringTy `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::StringTy::StringTy::Args")&&...>>> inline StringTy([Args]( "LIEF::dwarf::types::StringTy::StringTy::Args")&&... args) #### [` StringTy `]() StringTy(const [StringTy]( "LIEF::dwarf::types::StringTy::StringTy")&) = delete #### [` operator= `]() [StringTy]( "LIEF::dwarf::types::StringTy") &operator=(const [StringTy]( "LIEF::dwarf::types::StringTy")&) = delete #### [` StringTy `]() StringTy([StringTy]( "LIEF::dwarf::types::StringTy::StringTy")&&) noexcept = default #### [` operator= `]() [StringTy]( "LIEF::dwarf::types::StringTy") &operator=([StringTy]( "LIEF::dwarf::types::StringTy")&&) noexcept = default #### [` ~StringTy `]() ~StringTy() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [Subroutine]() ### [` Subroutine `]() class Subroutine : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_subroutine_type`. Public Types #### [` parameters_t `]() using parameters\_t = std::vector<std::unique\_ptr<[Parameter]( "LIEF::dwarf::Parameter")>> Public Functions #### [` ArgsSubroutine `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::Subroutine::Subroutine::Args")&&...>>> inline Subroutine([Args]( "LIEF::dwarf::types::Subroutine::Subroutine::Args")&&... args) #### [` Subroutine `]() Subroutine(const [Subroutine]( "LIEF::dwarf::types::Subroutine::Subroutine")&) = delete #### [` operator= `]() [Subroutine]( "LIEF::dwarf::types::Subroutine") &operator=(const [Subroutine]( "LIEF::dwarf::types::Subroutine")&) = delete #### [` Subroutine `]() Subroutine([Subroutine]( "LIEF::dwarf::types::Subroutine::Subroutine")&&) noexcept = default #### [` operator= `]() [Subroutine]( "LIEF::dwarf::types::Subroutine") &operator=([Subroutine]( "LIEF::dwarf::types::Subroutine")&&) noexcept = default #### [` return_type `]() std::unique\_ptr<[Type]( "LIEF::dwarf::Type")> return\_type() const Return the [dwarf::Type]() associated with the **return type** of this function. #### [` parameters `]() [parameters\_t]( "LIEF::dwarf::types::Subroutine::parameters_t") parameters() const Parameters of this subroutine. #### [` ~Subroutine `]() ~Subroutine() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [TemplateAlias]() ### [` TemplateAlias `]() class TemplateAlias : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_template_alias`. Public Types #### [` parameters_t `]() using parameters\_t = std::vector<std::unique\_ptr<[Parameter]( "LIEF::dwarf::Parameter")>> Public Functions #### [` ArgsTemplateAlias `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::TemplateAlias::TemplateAlias::Args")&&...>>> inline TemplateAlias([Args]( "LIEF::dwarf::types::TemplateAlias::TemplateAlias::Args")&&... args) #### [` TemplateAlias `]() TemplateAlias(const [TemplateAlias]( "LIEF::dwarf::types::TemplateAlias::TemplateAlias")&) = delete #### [` operator= `]() [TemplateAlias]( "LIEF::dwarf::types::TemplateAlias") &operator=(const [TemplateAlias]( "LIEF::dwarf::types::TemplateAlias")&) = delete #### [` TemplateAlias `]() TemplateAlias([TemplateAlias]( "LIEF::dwarf::types::TemplateAlias::TemplateAlias")&&) noexcept = default #### [` operator= `]() [TemplateAlias]( "LIEF::dwarf::types::TemplateAlias") &operator=([TemplateAlias]( "LIEF::dwarf::types::TemplateAlias")&&) noexcept = default #### [` underlying_type `]() const [Type]( "LIEF::dwarf::Type") \*underlying\_type() const The underlying type aliased by this type. #### [` operator-> `]() inline const [Type]( "LIEF::dwarf::Type") \*operator->() const #### [` operator* `]() inline const [Type]( "LIEF::dwarf::Type") &operator\*() const #### [` parameters `]() [parameters\_t]( "LIEF::dwarf::types::TemplateAlias::parameters_t") parameters() const Parameters associated with the underlying template. #### [` ~TemplateAlias `]() ~TemplateAlias() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [Thrown]() ### [` Thrown `]() class Thrown : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_thrown_type`. Public Functions #### [` ArgsThrown `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::Thrown::Thrown::Args")&&...>>> inline Thrown([Args]( "LIEF::dwarf::types::Thrown::Thrown::Args")&&... args) #### [` Thrown `]() Thrown(const [Thrown]( "LIEF::dwarf::types::Thrown::Thrown")&) = delete #### [` operator= `]() [Thrown]( "LIEF::dwarf::types::Thrown") &operator=(const [Thrown]( "LIEF::dwarf::types::Thrown")&) = delete #### [` Thrown `]() Thrown([Thrown]( "LIEF::dwarf::types::Thrown::Thrown")&&) noexcept = default #### [` operator= `]() [Thrown]( "LIEF::dwarf::types::Thrown") &operator=([Thrown]( "LIEF::dwarf::types::Thrown")&&) noexcept = default #### [` underlying_type `]() const [Type]( "LIEF::dwarf::Type") \*underlying\_type() const The underlying type being thrown. #### [` operator-> `]() inline const [Type]( "LIEF::dwarf::Type") \*operator->() const #### [` operator* `]() inline const [Type]( "LIEF::dwarf::Type") &operator\*() const #### [` ~Thrown `]() ~Thrown() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [Volatile]() ### [` Volatile `]() class Volatile : public LIEF::dwarf::[Type]( "LIEF::dwarf::Type") This class represents a `DW_TAG_volatile_type`. Public Functions #### [` ArgsVolatile `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::Type"), [Args]( "LIEF::dwarf::types::Volatile::Volatile::Args")&&...>>> inline Volatile([Args]( "LIEF::dwarf::types::Volatile::Volatile::Args")&&... args) #### [` Volatile `]() Volatile(const [Volatile]( "LIEF::dwarf::types::Volatile::Volatile")&) = delete #### [` operator= `]() [Volatile]( "LIEF::dwarf::types::Volatile") &operator=(const [Volatile]( "LIEF::dwarf::types::Volatile")&) = delete #### [` Volatile `]() Volatile([Volatile]( "LIEF::dwarf::types::Volatile::Volatile")&&) noexcept = default #### [` operator= `]() [Volatile]( "LIEF::dwarf::types::Volatile") &operator=([Volatile]( "LIEF::dwarf::types::Volatile")&&) noexcept = default #### [` underlying_type `]() const [Type]( "LIEF::dwarf::Type") \*underlying\_type() const The underlying type. #### [` operator-> `]() inline const [Type]( "LIEF::dwarf::Type") \*operator->() const #### [` operator* `]() inline const [Type]( "LIEF::dwarf::Type") &operator\*() const #### [` ~Volatile `]() ~Volatile() override Public Static Functions #### [` classof `]() static inline bool classof(const [Type]( "LIEF::dwarf::Type") \*type) --- ## [Editor]() ### [` Editor `]() class Editor This class exposes the main API to create DWARF information. Public Types #### [` FORMAT `]() enum class FORMAT : uint32\_t *Values:* ##### [` ELF `]() enumerator ELF ##### [` MACHO `]() enumerator MACHO ##### [` PE `]() enumerator PE #### [` ARCH `]() enum class ARCH : uint32\_t *Values:* ##### [` UNKNOWN `]() enumerator UNKNOWN ##### [` X64 `]() enumerator X64 ##### [` X86 `]() enumerator X86 ##### [` AARCH64 `]() enumerator AARCH64 ##### [` ARM `]() enumerator ARM Public Functions #### [` Editor `]() Editor() = delete #### [` Editor `]() Editor(std::unique\_ptr<details::Editor> impl) #### [` create_compilation_unit `]() std::unique\_ptr<editor::[CompilationUnit]( "LIEF::dwarf::editor::CompilationUnit")> create\_compilation\_unit() Create a new compilation unit. #### [` write `]() void write(const std::string &output) Write the DWARF file to the specified output. #### [` ~Editor `]() ~Editor() Public Static Functions #### [` from_binary `]() static std::unique\_ptr<[Editor]( "LIEF::dwarf::Editor")> from\_binary(LIEF::[Binary]( "LIEF::Binary") &bin) Instantiate an editor for the given binary object. #### [` create `]() static std::unique\_ptr<[Editor]( "LIEF::dwarf::Editor")> create([FORMAT]( "LIEF::dwarf::Editor::FORMAT") fmt, [ARCH]( "LIEF::dwarf::Editor::ARCH") arch) Instantiate an editor for the given format and arch. --- ## [Editor - CompilationUnit]() ### [` CompilationUnit `]() class CompilationUnit This class represents an **editable** DWARF compilation unit. Public Functions #### [` CompilationUnit `]() CompilationUnit() = delete #### [` CompilationUnit `]() CompilationUnit(std::unique\_ptr<details::CompilationUnit> impl) #### [` set_producer `]() [CompilationUnit]( "LIEF::dwarf::editor::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`) #### [` create_function `]() std::unique\_ptr<[Function]( "LIEF::dwarf::editor::Function")> create\_function(const std::string &name) Create a new function owned by this compilation unit. #### [` create_variable `]() std::unique\_ptr<[Variable]( "LIEF::dwarf::editor::Variable")> create\_variable(const std::string &name) Create a new **global** variable owned by this compilation unit. #### [` create_generic_type `]() std::unique\_ptr<[Type]( "LIEF::dwarf::editor::Type")> create\_generic\_type(const std::string &name) Create a `DW_TAG_unspecified_type` type with the given name. #### [` create_enum `]() std::unique\_ptr<[EnumType]( "LIEF::dwarf::editor::EnumType")> create\_enum(const std::string &name) Create an enum type (`DW_TAG_enumeration_type`). #### [` create_typedef `]() std::unique\_ptr<[TypeDef]( "LIEF::dwarf::editor::TypeDef")> create\_typedef(const std::string &name, const [Type]( "LIEF::dwarf::editor::Type") &type) Create a typedef with the name provided in the first parameter which aliases the type provided in the second parameter. #### [` create_structure `]() std::unique\_ptr<[StructType]( "LIEF::dwarf::editor::StructType")> create\_structure(const std::string &name, [StructType]( "LIEF::dwarf::editor::StructType")::[TYPE]( "LIEF::dwarf::editor::StructType::TYPE") kind = [StructType]( "LIEF::dwarf::editor::StructType")::[TYPE]( "LIEF::dwarf::editor::StructType::TYPE")::[STRUCT]( "LIEF::dwarf::editor::StructType::TYPE::STRUCT")) Create a struct-like type (struct, class, union) with the given name. #### [` create_base_type `]() std::unique\_ptr<[BaseType]( "LIEF::dwarf::editor::BaseType")> create\_base\_type(const std::string &name, size\_t size, [BaseType]( "LIEF::dwarf::editor::BaseType")::[ENCODING]( "LIEF::dwarf::editor::BaseType::ENCODING") encoding = [BaseType]( "LIEF::dwarf::editor::BaseType")::[ENCODING]( "LIEF::dwarf::editor::BaseType::ENCODING")::[NONE]( "LIEF::dwarf::editor::BaseType::ENCODING::NONE")) Create a primitive type with the given name and size. #### [` create_function_type `]() std::unique\_ptr<[FunctionType]( "LIEF::dwarf::editor::FunctionType")> create\_function\_type(const std::string &name) Create a function type with the given name. #### [` create_pointer_type `]() inline std::unique\_ptr<[PointerType]( "LIEF::dwarf::editor::PointerType")> create\_pointer\_type(const [Type]( "LIEF::dwarf::editor::Type") &ty) Create a pointer on the provided type. #### [` create_void_type `]() std::unique\_ptr<[Type]( "LIEF::dwarf::editor::Type")> create\_void\_type() Create a `void` type. #### [` create_array `]() std::unique\_ptr<[ArrayType]( "LIEF::dwarf::editor::ArrayType")> create\_array(const std::string &name, const [Type]( "LIEF::dwarf::editor::Type") &type, size\_t count) Create an array type with the given name, type and size. #### [` ~CompilationUnit `]() ~CompilationUnit() --- ## [Editor - Function]() ### [` Function `]() class Function This class represents an **editable** DWARF function (`DW_TAG_subprogram`). Public Functions #### [` Function `]() Function() = delete #### [` Function `]() Function(std::unique\_ptr<details::Function> impl) #### [` set_address `]() [Function]( "LIEF::dwarf::editor::Function") &set\_address(uint64\_t addr) Set the address of this function by defining `DW_AT_entry_pc`. #### [` set_low_high `]() [Function]( "LIEF::dwarf::editor::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` #### [` set_ranges `]() [Function]( "LIEF::dwarf::editor::Function") &set\_ranges(const std::vector<[range\_t]( "LIEF::dwarf::editor::Function::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. #### [` set_external `]() [Function]( "LIEF::dwarf::editor::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. #### [` set_return_type `]() [Function]( "LIEF::dwarf::editor::Function") &set\_return\_type(const [Type]( "LIEF::dwarf::editor::Type") &type) Set the return type of this function. #### [` add_parameter `]() std::unique\_ptr<[Parameter]( "LIEF::dwarf::editor::Function::Parameter")> add\_parameter(const std::string &name, const [Type]( "LIEF::dwarf::editor::Type") &type) Add a parameter to the current function. #### [` create_stack_variable `]() std::unique\_ptr<[Variable]( "LIEF::dwarf::editor::Variable")> create\_stack\_variable(const std::string &name) Create a stack-based variable owned by the current function. #### [` add_lexical_block `]() std::unique\_ptr<[LexicalBlock]( "LIEF::dwarf::editor::Function::LexicalBlock")> add\_lexical\_block(uint64\_t start, uint64\_t end) Add a lexical block with the given range. #### [` add_label `]() std::unique\_ptr<[Label]( "LIEF::dwarf::editor::Function::Label")> add\_label(uint64\_t addr, const std::string &label) Add a label at the given address. #### [` add_description `]() [Function]( "LIEF::dwarf::editor::Function") &add\_description(const std::string &description) Create a `DW_AT_description` entry with the description provided in parameter. #### [` ~Function `]() ~Function() #### [` range_t `]() struct range\_t Public Functions ##### [` range_t `]() range\_t() = default ##### [` range_t `]() inline range\_t(uint64\_t start, uint64\_t end) Public Members ##### [` start `]() uint64\_t start = 0 ##### [` end `]() uint64\_t end = 0 #### [` Parameter `]() class Parameter This class represents a parameter of the current function (`DW_TAG_formal_parameter`). Public Functions ##### [` Parameter `]() Parameter() = delete ##### [` Parameter `]() Parameter(std::unique\_ptr<details::FunctionParameter> impl) ##### [` ~Parameter `]() ~Parameter() ##### [` assign_register `]() [Parameter]( "LIEF::dwarf::editor::Function::Parameter") &assign\_register(const std::string &name) Assign this parameter to a specific named register. ##### [` assign_register `]() [Parameter]( "LIEF::dwarf::editor::Function::Parameter") &assign\_register(uint64\_t reg) Assign this parameter to the given DWARF register id (e.g. `DW_OP_reg0`). #### [` LexicalBlock `]() class LexicalBlock This class mirrors the `DW_TAG_lexical_block` DWARF tag. Public Functions ##### [` LexicalBlock `]() LexicalBlock() = delete ##### [` LexicalBlock `]() LexicalBlock(std::unique\_ptr<details::FunctionLexicalBlock> impl) ##### [` add_block `]() std::unique\_ptr<[LexicalBlock]( "LIEF::dwarf::editor::Function::LexicalBlock")> add\_block(uint64\_t start, uint64\_t end) Create a sub-block with the given low/high addresses. ##### [` add_block `]() std::unique\_ptr<[LexicalBlock]( "LIEF::dwarf::editor::Function::LexicalBlock")> add\_block(const std::vector<[range\_t]( "LIEF::dwarf::editor::Function::range_t")> &range) Create a sub-block with the given range of addresses. ##### [` add_description `]() [LexicalBlock]( "LIEF::dwarf::editor::Function::LexicalBlock") &add\_description(const std::string &description) Create a `DW_AT_description` entry with the description provided in parameter. ##### [` add_name `]() [LexicalBlock]( "LIEF::dwarf::editor::Function::LexicalBlock") &add\_name(const std::string &name) Create a `DW_AT_name` entry to associate a name to this entry. ##### [` ~LexicalBlock `]() ~LexicalBlock() #### [` Label `]() class Label This class mirrors the `DW_TAG_label` DWARF tag. Public Functions ##### [` Label `]() Label() = delete ##### [` Label `]() Label(std::unique\_ptr<details::FunctionLabel> impl) ##### [` ~Label `]() ~Label() --- ## [Editor - Variable]() ### [` 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 `]() Variable() = delete #### [` Variable `]() Variable(std::unique\_ptr<details::Variable> impl) #### [` set_addr `]() [Variable]( "LIEF::dwarf::editor::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 #### [` set_stack_offset `]() [Variable]( "LIEF::dwarf::editor::Variable") &set\_stack\_offset(uint64\_t offset) Set the stack offset of this variable. This function sets the `DW_AT_location` attribute #### [` set_external `]() [Variable]( "LIEF::dwarf::editor::Variable") &set\_external() Mark this variable as **imported**. #### [` set_type `]() [Variable]( "LIEF::dwarf::editor::Variable") &set\_type(const [Type]( "LIEF::dwarf::editor::Type") &type) Set the type of the current variable. #### [` add_description `]() [Variable]( "LIEF::dwarf::editor::Variable") &add\_description(const std::string &description) Create a `DW_AT_description` entry with the description provided in parameter. #### [` ~Variable `]() ~Variable() --- ## [Editor - Type]() ### [` 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 `]() Type() = delete #### [` Type `]() Type(std::unique\_ptr<details::Type> impl) #### [` pointer_to `]() std::unique\_ptr<[PointerType]( "LIEF::dwarf::editor::PointerType")> pointer\_to() const Create a pointer type pointing to this type. #### [` ~Type `]() virtual ~Type() #### [` impl `]() inline const details::Type &impl() const --- ## [Editor - PointerType]() ### [` PointerType `]() class PointerType : public LIEF::dwarf::editor::[Type]( "LIEF::dwarf::editor::Type") This class represents a pointer to another type. Public Functions #### [` ArgsPointerType `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::editor::Type"), [Args]( "LIEF::dwarf::editor::PointerType::PointerType::Args")&&...>>> inline PointerType([Args]( "LIEF::dwarf::editor::PointerType::PointerType::Args")&&... args) #### [` ~PointerType `]() ~PointerType() override = default Public Static Functions #### [` classof `]() static bool classof(const [Type]( "LIEF::dwarf::editor::Type") \*type) --- ## [Editor - EnumType]() ### [` EnumType `]() class EnumType : public LIEF::dwarf::editor::[Type]( "LIEF::dwarf::editor::Type") This class represents an editable enum type (`DW_TAG_enumeration_type`). Public Functions #### [` ArgsEnumType `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::editor::Type"), [Args]( "LIEF::dwarf::editor::EnumType::EnumType::Args")&&...>>> inline EnumType([Args]( "LIEF::dwarf::editor::EnumType::EnumType::Args")&&... args) #### [` set_size `]() [EnumType]( "LIEF::dwarf::editor::EnumType") &set\_size(uint64\_t size) Define the number of bytes required to hold an instance of the enumeration (`DW_AT_byte_size`). #### [` set_underlying_type `]() [EnumType]( "LIEF::dwarf::editor::EnumType") &set\_underlying\_type(const [Type]( "LIEF::dwarf::editor::Type") &type) Set the underlying type that is used to encode this enum. #### [` add_value `]() std::unique\_ptr<[Value]( "LIEF::dwarf::editor::EnumType::Value")> add\_value(const std::string &name, int64\_t value) Add an enum value by specifying its name and its integer value. #### [` ~EnumType `]() ~EnumType() override = default Public Static Functions #### [` classof `]() static bool classof(const [Type]( "LIEF::dwarf::editor::Type") \*type) #### [` Value `]() class Value This class represents an enum value. Public Functions ##### [` Value `]() Value() = delete ##### [` Value `]() Value(std::unique\_ptr<details::EnumValue> impl) ##### [` ~Value `]() ~Value() --- ## [Editor - BaseType]() ### [` BaseType `]() class BaseType : public LIEF::dwarf::editor::[Type]( "LIEF::dwarf::editor::Type") This class represents a primitive type like `int, char`. Public Types #### [` ENCODING `]() enum class ENCODING : uint32\_t *Values:* ##### [` NONE `]() enumerator NONE = 0 ##### [` ADDRESS `]() enumerator ADDRESS ##### [` SIGNED `]() enumerator SIGNED ##### [` SIGNED_CHAR `]() enumerator SIGNED\_CHAR ##### [` UNSIGNED `]() enumerator UNSIGNED ##### [` UNSIGNED_CHAR `]() enumerator UNSIGNED\_CHAR ##### [` BOOLEAN `]() enumerator BOOLEAN ##### [` FLOAT `]() enumerator FLOAT Public Functions #### [` ArgsBaseType `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::editor::Type"), [Args]( "LIEF::dwarf::editor::BaseType::BaseType::Args")&&...>>> inline BaseType([Args]( "LIEF::dwarf::editor::BaseType::BaseType::Args")&&... args) #### [` ~BaseType `]() ~BaseType() override = default Public Static Functions #### [` classof `]() static bool classof(const [Type]( "LIEF::dwarf::editor::Type") \*type) --- ## [Editor - ArrayType]() ### [` ArrayType `]() class ArrayType : public LIEF::dwarf::editor::[Type]( "LIEF::dwarf::editor::Type") This class represents an array type (`DW_TAG_array_type`). Public Functions #### [` ArgsArrayType `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::editor::Type"), [Args]( "LIEF::dwarf::editor::ArrayType::ArrayType::Args")&&...>>> inline ArrayType([Args]( "LIEF::dwarf::editor::ArrayType::ArrayType::Args")&&... args) #### [` ~ArrayType `]() ~ArrayType() override = default Public Static Functions #### [` classof `]() static bool classof(const [Type]( "LIEF::dwarf::editor::Type") \*type) --- ## [Editor - FunctionType]() ### [` FunctionType `]() class FunctionType : public LIEF::dwarf::editor::[Type]( "LIEF::dwarf::editor::Type") This class represents a function type (`DW_TAG_subroutine_type`). Public Functions #### [` ArgsFunctionType `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::editor::Type"), [Args]( "LIEF::dwarf::editor::FunctionType::FunctionType::Args")&&...>>> inline FunctionType([Args]( "LIEF::dwarf::editor::FunctionType::FunctionType::Args")&&... args) #### [` set_return_type `]() [FunctionType]( "LIEF::dwarf::editor::FunctionType") &set\_return\_type(const [Type]( "LIEF::dwarf::editor::Type") &type) Set the return type of this function. #### [` add_parameter `]() std::unique\_ptr<[Parameter]( "LIEF::dwarf::editor::FunctionType::Parameter")> add\_parameter(const [Type]( "LIEF::dwarf::editor::Type") &type) Add a parameter. #### [` ~FunctionType `]() ~FunctionType() override = default Public Static Functions #### [` classof `]() static bool classof(const [Type]( "LIEF::dwarf::editor::Type") \*type) #### [` Parameter `]() class Parameter This class represents a function’s parameter. Public Functions ##### [` Parameter `]() Parameter() = delete ##### [` Parameter `]() Parameter(std::unique\_ptr<details::FunctionTyParameter> impl) ##### [` ~Parameter `]() ~Parameter() --- ## [Editor - TypeDef]() ### [` TypeDef `]() class TypeDef : public LIEF::dwarf::editor::[Type]( "LIEF::dwarf::editor::Type") This class represents a typedef (`DW_TAG_typedef`). Public Functions #### [` ArgsTypeDef `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::editor::Type"), [Args]( "LIEF::dwarf::editor::TypeDef::TypeDef::Args")&&...>>> inline TypeDef([Args]( "LIEF::dwarf::editor::TypeDef::TypeDef::Args")&&... args) #### [` ~TypeDef `]() ~TypeDef() override = default Public Static Functions #### [` classof `]() static bool classof(const [Type]( "LIEF::dwarf::editor::Type") \*type) --- ## [Editor - StructType]() ### [` StructType `]() class StructType : public LIEF::dwarf::editor::[Type]( "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 #### [` TYPE `]() enum class TYPE : uint32\_t *Values:* ##### [` CLASS `]() enumerator CLASS ##### [` STRUCT `]() enumerator STRUCT Discriminant for `DW_TAG_class_type`. ##### [` UNION `]() enumerator UNION Discriminant for `DW_TAG_structure_type`. Public Functions #### [` ArgsStructType `]() template<typename ...Args, typename = std::enable\_if\_t<std::is\_constructible\_v<[Type]( "LIEF::dwarf::editor::Type"), [Args]( "LIEF::dwarf::editor::StructType::StructType::Args")&&...>>> inline StructType([Args]( "LIEF::dwarf::editor::StructType::StructType::Args")&&... args) #### [` set_size `]() [StructType]( "LIEF::dwarf::editor::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 #### [` add_member `]() std::unique\_ptr<[Member]( "LIEF::dwarf::editor::StructType::Member")> add\_member(const std::string &name, const [Type]( "LIEF::dwarf::editor::Type") &type, int64\_t offset = -1) Adds a member to the current struct-like. #### [` add_bitfield `]() std::unique\_ptr<[Member]( "LIEF::dwarf::editor::StructType::Member")> add\_bitfield(const std::string &name, const [Type]( "LIEF::dwarf::editor::Type") &type, uint64\_t bitsize, int64\_t bitoffset = -1) Adds a bitfield member to the current structure. #### [` ~StructType `]() ~StructType() override = default Public Static Functions #### [` classof `]() static bool classof(const [Type]( "LIEF::dwarf::editor::Type") \*type) #### [` Member `]() class Member This class represents a member of the struct-like. Public Functions ##### [` Member `]() Member() = delete ##### [` Member `]() Member(std::unique\_ptr<details::StructMember> impl) ##### [` ~Member `]() ~Member()