ELF

Parser

lief.ELF.parse(*args, **kwargs)

Overloaded function.

  1. parse(filename: str, dynsym_count_method: lief.ELF.DYNSYM_COUNT_METHODS = DYNSYM_COUNT_METHODS.AUTO) -> LIEF::ELF::Binary

Parse the given binary and return a Binary object

For weird binaries (e.g sectionless) you can choose the method to use to count dynamic symbols (DYNSYM_COUNT_METHODS)

  1. parse(raw: List[int], name: str = ‘’, dynsym_count_method: lief.ELF.DYNSYM_COUNT_METHODS = DYNSYM_COUNT_METHODS.AUTO) -> LIEF::ELF::Binary

Parse the given binary and return a Binary object

For weird binaries (e.g sectionless) you can choose the method to use to count dynamic symbols (DYNSYM_COUNT_METHODS)

  1. parse(io: object, name: str = ‘’) -> LIEF::ELF::Binary


Binary

class lief.ELF.Binary(self: lief.ELF.Binary, arg0: str, arg1: lief.ELF.ELF_CLASS) → None

ELF binary representation

class VA_TYPES(self: lief.Binary.VA_TYPES, arg0: int) → None

Members:

AUTO

VA

RVA

AUTO = VA_TYPES.AUTO
RVA = VA_TYPES.RVA
VA = VA_TYPES.VA
property name

(self: handle) -> str

property abstract

Return the Binary object

Warning

Getting this property modifies the __class__ attribute so that the current binary looks like a Binary.

Use the concrete to get back to the original binary.

add(*args, **kwargs)

Overloaded function.

  1. add(self: lief.ELF.Binary, arg0: LIEF::ELF::DynamicEntry) -> LIEF::ELF::DynamicEntry

dynamic_entry

  1. add(self: lief.ELF.Binary, section: LIEF::ELF::Section, loaded: bool = True) -> LIEF::ELF::Section

Add the given Section to the binary.

If the section should not be loaded in memory, loaded parameter have to be set to False (default: True)

  1. add(self: lief.ELF.Binary, segment: LIEF::ELF::Segment, base: int = 0) -> LIEF::ELF::Segment

Add a segment in the binary

  1. add(self: lief.ELF.Binary, note: LIEF::ELF::Note) -> LIEF::ELF::Note

Add a new Note in the binary

add_dynamic_relocation(self: lief.ELF.Binary, arg0: LIEF::ELF::Relocation) → LIEF::ELF::Relocation
add_dynamic_symbol(self: lief.ELF.Binary, symbol: LIEF::ELF::Symbol, symbol_version: lief.ELF.SymbolVersion = <lief.ELF.SymbolVersion object at 0x7ff152d703b0>) → LIEF::ELF::Symbol

Add a dynamic Symbol to the binary

add_exported_function(self: lief.ELF.Binary, address: int, name: str = '') → LIEF::ELF::Symbol

Create a symbol for the function at the given address and export it

add_library(self: lief.ELF.Binary, library_name: str) → LIEF::ELF::DynamicEntryLibrary

Add a library with the given name as dependency

add_pltgot_relocation(self: lief.ELF.Binary, arg0: LIEF::ELF::Relocation) → LIEF::ELF::Relocation
add_static_symbol(self: lief.ELF.Binary, symbol: LIEF::ELF::Symbol) → LIEF::ELF::Symbol

Add a static Symbol to the binary

property concrete

Return either lief.ELF.Binary, lief.PE.Binary, lief.MachO.Binary object

property ctor_functions

Constructor functions that are called prior any other functions

property dtor_functions

Destuctor functions that are called the main execution

property dynamic_entries

Return an iterator to DynamicEntry entries as a list

property dynamic_relocations

Return an iterator over dynamics Relocation

property dynamic_symbols

Return an iterator to dynamic Symbol

property entrypoint

Binary’s entrypoint

property eof_offset

Last offset that is used by the ELF format. Data after this offset are considered as overlay data

export_symbol(*args, **kwargs)

Overloaded function.

  1. export_symbol(self: lief.ELF.Binary, symbol: LIEF::ELF::Symbol) -> LIEF::ELF::Symbol

Export the given symbol and create it if it doesn’t exist

  1. export_symbol(self: lief.ELF.Binary, symbol_name: str, value: int = 0) -> LIEF::ELF::Symbol

Export the symbol with the given name and create it if it doesn’t exist

property exported_functions

Return binary’s exported Function

property exported_symbols

Return dynamic Symbol which are exported

extend(*args, **kwargs)

Overloaded function.

  1. extend(self: lief.ELF.Binary, segment: LIEF::ELF::Segment, size: int) -> LIEF::ELF::Segment

Extend the given given Segment by the given size

  1. extend(self: lief.ELF.Binary, segment: LIEF::ELF::Section, size: int) -> LIEF::ELF::Section

Extend the given given Section by the given size

property format

File format EXE_FORMATS of the underlying binary.

property functions
get(*args, **kwargs)

Overloaded function.

  1. get(self: lief.ELF.Binary, tag: lief.ELF.DYNAMIC_TAGS) -> LIEF::ELF::DynamicEntry

Return first binary’s DynamicEntry given its DYNAMIC_TAGS

  1. get(self: lief.ELF.Binary, type: lief.ELF.SEGMENT_TYPES) -> LIEF::ELF::Segment

Return first binary’s Segment given its SEGMENT_TYPES

  1. get(self: lief.ELF.Binary, type: lief.ELF.NOTE_TYPES) -> LIEF::ELF::Note

Return first binary’s Note given its NOTE_TYPES

  1. get(self: lief.ELF.Binary, type: lief.ELF.SECTION_TYPES) -> LIEF::ELF::Section

Return first binary’s Section given its ELF_SECTION_TYPES

get_content_from_virtual_address(self: lief.Binary, virtual_address: int, size: int, va_type: lief.Binary.VA_TYPES = VA_TYPES.AUTO) → List[int]

Return the content located at virtual address.

Virtual address is specified in the first argument and size to read (in bytes) in the second. If the underlying binary is a PE, one can specify if the virtual address is a RVA or a VA. By default it is set to AUTO

get_dynamic_symbol(self: lief.ELF.Binary, symbol_name: str) → LIEF::ELF::Symbol

Get the dynamic symbol from the given name

get_function_address(self: lief.Binary, function_name: str) → int

Return the address of the given function name

get_library(self: lief.ELF.Binary, library_name: str) → LIEF::ELF::DynamicEntryLibrary

Return the DynamicEntryLibrary with the given name

get_relocation(*args, **kwargs)

Overloaded function.

  1. get_relocation(self: lief.ELF.Binary, symbol_name: str) -> LIEF::ELF::Relocation

Return the Relocation associated with the given symbol name

  1. get_relocation(self: lief.ELF.Binary, symbol: LIEF::ELF::Symbol) -> LIEF::ELF::Relocation

Return the Relocation associated with the given Symbol

  1. get_relocation(self: lief.ELF.Binary, address: int) -> LIEF::ELF::Relocation

Return the Relocation associated with the given address

get_section(self: lief.ELF.Binary, section_name: str) → LIEF::ELF::Section

Return the Section with the given name

get_static_symbol(self: lief.ELF.Binary, symbol_name: str) → LIEF::ELF::Symbol

Get the dynamic symbol from the given name

get_strings(self: lief.ELF.Binary, min_size: int = 5) → List[str]

Return list of strings used in the current ELF file with a minimal size given in first parameter (Default: 5) It looks for strings in the .roadata section

get_symbol(self: lief.Binary, symbol_name: str) → LIEF::Symbol

Return the Symbol with the given name

property gnu_hash

Return the GnuHash object

Hash are used by the loader to speed up symbols resolving (GNU Version)

has(*args, **kwargs)

Overloaded function.

  1. has(self: lief.ELF.Binary, tag: lief.ELF.DYNAMIC_TAGS) -> bool

Check if the DynamicEntry associated with the given DYNAMIC_TAGS exists

  1. has(self: lief.ELF.Binary, type: lief.ELF.SEGMENT_TYPES) -> bool

Check if a Segment of type (SEGMENT_TYPES) exists

  1. has(self: lief.ELF.Binary, type: lief.ELF.NOTE_TYPES) -> bool

Check if a Note of type (NOTE_TYPES) exists

  1. has(self: lief.ELF.Binary, type: lief.ELF.SECTION_TYPES) -> bool

Check if a Section of type (ECTION_TYPES) exists

has_dynamic_symbol(self: lief.ELF.Binary, symbol_name: str) → bool

Check if the symbol with the given name exists in the dynamic symbol table

property has_interpreter

True if the binary uses a loader

has_library(self: lief.ELF.Binary, library_name: str) → bool

Check if the given library name exists in the current binary

property has_notes

True if the binary contains notes

property has_nx

Check if the binary uses NX protection

property has_overlay

True if data are appended to the end of the binary

has_section(self: lief.ELF.Binary, section_name: str) → bool

Check if a section with the given name exists in the binary

has_section_with_offset(self: lief.ELF.Binary, offset: int) → bool

Check if a section that handle the given offset exists

has_section_with_va(self: lief.ELF.Binary, va: int) → bool

Check if a section that handle the given virtual address exists

has_static_symbol(self: lief.ELF.Binary, symbol_name: str) → bool

Check if the symbol with the given name exists in the static symbol table

has_symbol(self: lief.Binary, symbol_name: str) → bool

Check if a Symbol with the given name exists

property header

Return Header object

property imagebase

Return the program image base. (e.g. 0x400000)

property imported_functions

Return binary’s imported Function (name)

property imported_symbols

Return dynamic Symbol which are imported

property interpreter

ELF interprer (loader) if any. (e.g. /lib64/ld-linux-x86-64.so.2)

property is_pie

True if the binary is a pie one

property last_offset_section

Return the last offset used in binary according to section headers

property last_offset_segment

Return the last offset used in binary according to segment headers

property libraries

Return binary’s imported libraries (name)

property name

Binary’s name

property next_virtual_address

Return the next virtual address available

property notes

Return an iterator to Note entries as a list

property object_relocations

Return an iterator over object Relocation

property overlay

Overlay data that are not a part of the ELF format

patch_address(*args, **kwargs)

Overloaded function.

  1. patch_address(self: lief.Binary, address: int, patch_value: List[int], va_type: lief.Binary.VA_TYPES = VA_TYPES.AUTO) -> None

Virtual address is specified in the first argument and the content in the second (as a list of bytes). If the underlying binary is a PE, one can specify if the virtual address is a RVA or a VA. By default it is set to AUTO

  1. patch_address(self: lief.Binary, address: int, patch_value: int, size: int = 8, va_type: lief.Binary.VA_TYPES = VA_TYPES.AUTO) -> None

Virtual address is specified in the first argument, integer in the second and sizeof the integer in third one. If the underlying binary is a PE, one can specify if the virtual address is a RVA or a VA. By default it is set to AUTO

patch_pltgot(*args, **kwargs)

Overloaded function.

  1. patch_pltgot(self: lief.ELF.Binary, symbol_name: str, address: int) -> None

Patch the imported symbol’s name with the address

  1. patch_pltgot(self: lief.ELF.Binary, symbol: LIEF::ELF::Symbol, address: int) -> None

Patch the imported Symbol with the address

permute_dynamic_symbols(self: lief.ELF.Binary, permutation: List[int]) → None

Apply the given permutation on the dynamic symbols table

property pltgot_relocations

Return an iterator over PLT/GOT Relocation

property relocations

Return an iterator over all Relocation s

remove(*args, **kwargs)

Overloaded function.

  1. remove(self: lief.ELF.Binary, dynamic_entry: LIEF::ELF::DynamicEntry) -> None

Remove the given DynamicEntry from the dynamic table

  1. remove(self: lief.ELF.Binary, tag: lief.ELF.DYNAMIC_TAGS) -> None

Remove all DynamicEntry with the given DYNAMIC_TAGS

  1. remove(self: lief.ELF.Binary, section: LIEF::ELF::Section, clear: bool = False) -> None

Remove the given Section. clear specify whether or not we must fill its content with 0 before removing

  1. remove(self: lief.ELF.Binary, note: LIEF::ELF::Note) -> None

Remove the given Note

  1. remove(self: lief.ELF.Binary, type: lief.ELF.NOTE_TYPES) -> None

Remove all Note with the given NOTE_TYPES

remove_library(self: lief.ELF.Binary, library_name: str) → None

Remove the given library

remove_section(self: lief.Binary, name: str, clear: bool = False) → None

Remove the section with the given name

remove_static_symbol(self: lief.ELF.Binary, arg0: LIEF::ELF::Symbol) → None

Remove the given Symbol in the .symtab section

replace(self: lief.ELF.Binary, new_segment: LIEF::ELF::Segment, original_segment: LIEF::ELF::Segment, base: int = 0) → LIEF::ELF::Segment

Replace the segment given in 2nd parameter with the segment given in the first one and return the updated segment

section_from_offset(self: lief.ELF.Binary, offset: int) → LIEF::ELF::Section

Return binary’s Section which holds the offset

section_from_virtual_address(self: lief.ELF.Binary, address: int) → LIEF::ELF::Section

Return binary’s Section which holds the given virtual address

property sections

Return an iterator to binary’s Section

segment_from_offset(self: lief.ELF.Binary, offset: int) → LIEF::ELF::Segment

Return binary’s Segment which holds the offset

segment_from_virtual_address(self: lief.ELF.Binary, address: int) → LIEF::ELF::Segment

Return binary’s Segment which holds the address

property segments

Return an interator to binary’s Segment

property static_symbols

Return an iterator to static Symbol

property strings

Return list of strings used in the current ELF file. Basically we look for strings in the .roadata section

strip(self: lief.ELF.Binary) → None

Strip the binary

property symbols

Return an iterator over both static and dynamic Symbol

property symbols_version

Return an iterator SymbolVersion

property symbols_version_definition

Return an iterator to SymbolVersionDefinition

property symbols_version_requirement

Return an iterator to SymbolVersionRequirement

property sysv_hash

Return the SysvHash object

Hash are used by the loader to speed up symbols resolving (SYSV version)

property type

Return the binary’s ELF_CLASS

property use_gnu_hash

True if GNU hash is used

property use_sysv_hash

True if SYSV hash is used

virtual_address_to_offset(self: lief.ELF.Binary, virtual_address: int) → int

Convert the virtual address to an offset in the binary

property virtual_size

Return the binary’s size when mapped in memory

write(self: lief.ELF.Binary, output: str) → None

Rebuild the binary and write it in a file

xref(self: lief.Binary, Return all **virtual address** that *use* the ``address`` given in parametervirtual_address: int) → List[int]


Section

class lief.ELF.Section(*args, **kwargs)

Overloaded function.

  1. __init__(self: lief.ELF.Section) -> None

Default constructor

  1. __init__(self: lief.ELF.Section, name: str, type: lief.ELF.SECTION_TYPES = SECTION_TYPES.PROGBITS) -> None

Constructor from name and type

  1. __init__(self: lief.ELF.Section, arg0: lief.ELF.Section, arg1: List[int], arg2: lief.ELF.ELF_CLASS) -> None

add(self: lief.ELF.Section, flag: lief.ELF.SECTION_FLAGS) → None

Add the given SECTION_FLAGS to the list of flags

property alignment

Section alignment

clear(self: lief.ELF.Section, value: int = 0) → lief.ELF.Section

Clear the content of the section with the given value

property content

Section’s content

property entropy

Section’s entropy

property entry_size

If section’s content is an array, entry_size holds the element size

Example

The .dynamic section contains an array of DynamicEntry. As the size of a dynamic entry is 0x10 (for ELF64), entry_size will contains this value

Warning

This value is not necessarily reliable.

property file_offset

Offset of the section’s content

property flags

Return section’s flags as an integer

property flags_list

Return section’s flags as a list of SECTION_FLAGS

has(*args, **kwargs)

Overloaded function.

  1. has(self: lief.ELF.Section, flag: lief.ELF.SECTION_FLAGS) -> bool

Check if the given SECTION_FLAGS is present

  1. has(self: lief.ELF.Section, segment: LIEF::ELF::Segment) -> bool

Check if the given Segment is present in segments

property information

Section information (this value depends on the section)

Index to another section

property name

Section’s name

property name_idx

Index of the section’s name in the string table

Warning

The value will probably change when re-building binary.

property offset

Section’s offset

property original_size

original data size. Without modification we have original_size == size

remove(self: lief.ELF.Section, flag: lief.ELF.SECTION_FLAGS) → None

Remove the given SECTION_FLAGS to the list of flags

search(*args, **kwargs)

Overloaded function.

  1. search(self: lief.Section, number: int, pos: int = 0, size: int = 0) -> int

Look for integer within the current section

  1. search(self: lief.Section, str: str, pos: int = 0) -> int

Look for string within the current section

search_all(*args, **kwargs)

Overloaded function.

  1. search_all(self: lief.Section, number: int, size: int = 0) -> List[int]

Look for all integers within the current section

  1. search_all(self: lief.Section, str: str) -> List[int]

Look for all strings within the current section

property segments

Return segment(s) associated with the given section

property size

Section’s size

property type

Return a SECTION_TYPES

property virtual_address

Return address where the section will be mapped in memory

Warning

This value is not reliable use segment’s virtual address (virtual_address) instead.


Segment

class lief.ELF.Segment(*args, **kwargs)

Overloaded function.

  1. __init__(self: lief.ELF.Segment) -> None

  2. __init__(self: lief.ELF.Segment, arg0: List[int]) -> None

  3. __init__(self: lief.ELF.Segment, arg0: List[int], arg1: lief.ELF.ELF_CLASS) -> None

add(self: lief.ELF.Segment, flag: lief.ELF.SEGMENT_FLAGS) → None

Add the given SEGMENT_FLAGS to the list of flags

property alignment

This member gives the value to which the segments are aligned in memory and in the file. Values 0 and 1 mean no alignment is required.

property content

Segment’s raw data

property file_offset

Data offset in the binary

property flags

Segment’s flags

has(*args, **kwargs)

Overloaded function.

  1. has(self: lief.ELF.Segment, flag: lief.ELF.SEGMENT_FLAGS) -> bool

Check if the given SEGMENT_FLAGS is present

  1. has(self: lief.ELF.Segment, section: lief.ELF.Section) -> bool

Check if the given Section is present in sections

  1. has(self: lief.ELF.Segment, section_name: str) -> bool

Check if the given Section ‘s name is present in sections

property physical_address

Physical address of beginning of segment (OS-specific)

property physical_size

Size of data in the binary

remove(self: lief.ELF.Segment, flag: lief.ELF.SEGMENT_FLAGS) → None

Remove the given SEGMENT_FLAGS to the list of flags

property sections

Section (s) inside this segment

property type

Segment’s SEGMENT_TYPES

property virtual_address

Address where the segment will be mapped

Warning

We must have

\[ \begin{align}\begin{aligned}\text{virtual address} \equiv \text{file offset} \pmod{\text{page size}}\\\text{virtual address} \equiv \text{file offset} \pmod{\text{alignment}}\end{aligned}\end{align} \]
property virtual_size

Size of this segment in memory


Dynamic Entry

class lief.ELF.DynamicEntry(*args, **kwargs)

Overloaded function.

  1. __init__(self: lief.ELF.DynamicEntry) -> None

Default constructor

  1. __init__(self: lief.ELF.DynamicEntry, tag: lief.ELF.DYNAMIC_TAGS, value: int) -> None

Constructor with DYNAMIC_TAGS and value

property tag

Return the entry’s DYNAMIC_TAGS which represent the entry type

property value

Return the entry’s value.


Dynamic Entry Library

class lief.ELF.DynamicEntryLibrary(self: lief.ELF.DynamicEntryLibrary, library_name: str) → None

Constructor from library name

property name

Return library’s name

property tag

Return the entry’s DYNAMIC_TAGS which represent the entry type

property value

Return the entry’s value.


Dynamic Shared Object

class lief.ELF.DynamicSharedObject(self: lief.ELF.DynamicSharedObject, library_name: str) → None

Constructor from library name

property name

Return the library name

property tag

Return the entry’s DYNAMIC_TAGS which represent the entry type

property value

Return the entry’s value.


Dynamic Entry Run Path

class lief.ELF.DynamicEntryRunPath(*args, **kwargs)

Overloaded function.

  1. __init__(self: lief.ELF.DynamicEntryRunPath, path: str = ‘’) -> None

Constructor from (run)path

  1. __init__(self: lief.ELF.DynamicEntryRunPath, paths: List[str]) -> None

Constructor from a list of paths

append(self: lief.ELF.DynamicEntryRunPath, path: str) → lief.ELF.DynamicEntryRunPath

Append the given path

insert(self: lief.ELF.DynamicEntryRunPath, position: int, path: str) → lief.ELF.DynamicEntryRunPath

Insert a path at the given position

property name

Runpath raw value

property paths

Paths as a list

remove(self: lief.ELF.DynamicEntryRunPath, path: str) → lief.ELF.DynamicEntryRunPath

Remove the given path

property runpath

Runpath raw value

property tag

Return the entry’s DYNAMIC_TAGS which represent the entry type

property value

Return the entry’s value.


Dynamic Entry RPath

class lief.ELF.DynamicEntryRpath(*args, **kwargs)

Overloaded function.

  1. __init__(self: lief.ELF.DynamicEntryRpath, path: str = ‘’) -> None

Constructor from (r)path

  1. __init__(self: lief.ELF.DynamicEntryRpath, paths: List[str]) -> None

Constructor from a list of paths

append(self: lief.ELF.DynamicEntryRpath, path: str) → lief.ELF.DynamicEntryRpath

Append the given path

insert(self: lief.ELF.DynamicEntryRpath, position: int, path: str) → lief.ELF.DynamicEntryRpath

Insert a path at the given position

property name

Return path value

property paths

Paths as a list

remove(self: lief.ELF.DynamicEntryRpath, path: str) → lief.ELF.DynamicEntryRpath

Remove the given path

property rpath

Return path value

property tag

Return the entry’s DYNAMIC_TAGS which represent the entry type

property value

Return the entry’s value.


Dynamic Entry Array

class lief.ELF.DynamicEntryArray(*args, **kwargs)

Overloaded function.

  1. __init__(self: lief.ELF.DynamicEntryArray) -> None

  2. __init__(self: lief.ELF.DynamicEntryArray, tag: lief.ELF.DYNAMIC_TAGS, value: int) -> None

Constructor with DYNAMIC_TAGS and value

append(self: lief.ELF.DynamicEntryArray, callback: int) → lief.ELF.DynamicEntryArray

Append the given callback

property array

Return the array

insert(self: lief.ELF.DynamicEntryArray, position: int, callback: int) → lief.ELF.DynamicEntryArray

Insert a callback at the given position

remove(self: lief.ELF.DynamicEntryArray, callback: int) → lief.ELF.DynamicEntryArray

Remove the given callback

property tag

Return the entry’s DYNAMIC_TAGS which represent the entry type

property value

Return the entry’s value.


Dynamic Entry Flags

class lief.ELF.DynamicEntryFlags(*args, **kwargs)

Overloaded function.

  1. __init__(self: lief.ELF.DynamicEntryFlags) -> None

  2. __init__(self: lief.ELF.DynamicEntryFlags, tag: lief.ELF.DYNAMIC_TAGS, value: int) -> None

Constructor with DYNAMIC_TAGS and value

add(*args, **kwargs)

Overloaded function.

  1. add(self: lief.ELF.DynamicEntryFlags, flag: lief.ELF.DYNAMIC_FLAGS) -> None

Add the given DYNAMIC_FLAGS

  1. add(self: lief.ELF.DynamicEntryFlags, flag: lief.ELF.DYNAMIC_FLAGS_1) -> None

Add the given DYNAMIC_FLAGS_1

property flags

Return list of DYNAMIC_FLAGS or DYNAMIC_FLAGS_1 (integer)

remove(*args, **kwargs)

Overloaded function.

  1. remove(self: lief.ELF.DynamicEntryFlags, flag: lief.ELF.DYNAMIC_FLAGS) -> None

Remove the given DYNAMIC_FLAGS

  1. remove(self: lief.ELF.DynamicEntryFlags, flag: lief.ELF.DYNAMIC_FLAGS_1) -> None

Remove the given DYNAMIC_FLAGS_1

property tag

Return the entry’s DYNAMIC_TAGS which represent the entry type

property value

Return the entry’s value.


Relocations

class lief.ELF.Relocation(*args, **kwargs)

Overloaded function.

  1. __init__(self: lief.ELF.Relocation) -> None

  2. __init__(self: lief.ELF.Relocation, address: int, type: int = 0, addend: int = 0, is_rela: bool = False) -> None

property addend

Additional value

property address

Relocation’s address

property has_section

True if a this relocation has a Section associated

property has_symbol

True if a Symbol is associated with the relocations

property info

Extra information like symbol index

property is_rel

True if the relocation doesn’t use the addend proprety

property is_rela

True if the relocation uses the addend proprety

property purpose

Purpose (RELOCATION_PURPOSES) of the relocation

property section

Section to which the relocation applies

property size

Relocation’s size (in bits)

property symbol

Symbol associated with the relocation

property type

Relocation type.

See:


Symbol

class lief.ELF.Symbol(self: lief.ELF.Symbol) → None
property binding

A symbol’s binding determines the linkage visibility and behavior. See SYMBOL_BINDINGS

property demangled_name

Symbol’s unmangled name

property exported

Whether or not the symbol is exported

property has_version

Check if this symbols has a SymbolVersion

property imported

Whether or not the symbol is imported

property information

This member specifies the symbol’s type and binding attributes

property is_function

True if the symbol is a function

property is_static

True if the symbol is a static one

property is_variable

True if the symbol is a variable

property name

Symbol’s name

property other

This member should holds 0 and should not have defined meaning.

See: visibility

property shndx

Section index associated with the symbol

property size

Many symbols have associated sizes. For example, a data object’s size is the number of bytes contained in the object. This member holds 0 if the symbol has no size or an unknown size.

property symbol_version

Return the SymbolVersion associated with this symbol

property type

A symbol’s type provides a general classification for the associated entity. See: SYMBOL_TYPES

property value

This member have slightly different interpretations

  • In relocatable files, value holds alignment constraints for a symbol whose section index is SHN_COMMON.

  • In relocatable files, value holds a section offset for a defined symbol. That is, value is anoffset from the beginning of the section associated with this symbol.

  • In executable and shared object files, value holds a virtual address. To make these files’ssymbols more useful for the dynamic linker, the section offset (file interpretation) gives way toa virtual address (memory interpretation) for which the section number is irrelevant.

property visibility

Symbol SYMBOL_VISIBILITY.

It’s basically an alias on other


Symbol Version

class lief.ELF.SymbolVersion(*args, **kwargs)

Overloaded function.

  1. __init__(self: lief.ELF.SymbolVersion) -> None

Default constructor

  1. __init__(self: lief.ELF.SymbolVersion, arg0: int) -> None

Constructor from value

global_ = <lief.ELF.SymbolVersion object>
property has_auxiliary_version

Check if this symbols has a SymbolVersionAux

local = <lief.ELF.SymbolVersion object>
property symbol_version_auxiliary

Return the SymbolVersionAux associated with this version

property value
  • 0 : The symbol is local

  • 1 : The symbol is global

All other values are used for versions in the own object or in any of the dependencies. This is the version the symbol is tight to.


Symbol Version Auxiliary

class lief.ELF.SymbolVersionAux

Class which modelize an Auxiliary Symbol version

property name

Symbol’s name


Symbol Version Definition

class lief.ELF.SymbolVersionDefinition

Class which modelization of an entry defined in DT_VERDEF (or .gnu.version_d)

property auxiliary_symbols
property flags
property hash
property version

Version revision. Should holds 1


Symbol Version Requirement

class lief.ELF.SymbolVersionRequirement

Class which modelize an entry in DT_VERNEED or .gnu.version_r table

get_auxiliary_symbols(self: lief.ELF.SymbolVersionRequirement) → lief.N4LIEF12ref_iteratorIRSt6vectorIPNS_3ELF27SymbolVersionAuxRequirementESaIS4_EEN9__gnu_cxx17__normal_iteratorIPS4_S6_EEEE

Auxiliary entries

property name
property version

Version revision. Should holds 1


GNU Hash table

class lief.ELF.GnuHash(self: lief.ELF.GnuHash) → None
property bloom_filters

Bloom filters

property buckets

hash buckets

check(*args, **kwargs)

Overloaded function.

  1. check(self: lief.ELF.GnuHash, symbol_name: str) -> bool

Check if the symbol probably exists. If the returned value is false you can assume at 100% that the symbol with the given name doesn’t exists. If true you can’t do any assumption

  1. check(self: lief.ELF.GnuHash, hash_value: int) -> bool

Check if the symbol associated with the given probably exists. If the returned value is false you can assume at 100% that the symbol doesn’t exists. If true you can’t do any assumption

check_bloom_filter(self: lief.ELF.GnuHash, hash: int) → bool

Check if the given hash pass the bloom filter

check_bucket(self: lief.ELF.GnuHash, hash: int) → bool

Check if the given hash pass the bucket filter

property hash_values

Hash values

property nb_buckets

Return the number of buckets

property shift2

Shift count used in the bloom filter

property symbol_index

Index of the first symbol in the dynamic symbols table which is accessible with the hash table


SYSV Hash table

class lief.ELF.SysvHash(self: lief.ELF.SysvHash) → None
property buckets

Buckets values

property chains

Chains values

property nbucket

Return the number of buckets

property nchain

Return the number of chains (symbol table index)


Note

class lief.ELF.Note(*args, **kwargs)

Overloaded function.

  1. __init__(self: lief.ELF.Note) -> None

Default ctor

  1. __init__(self: lief.ELF.Note, name: str, type: lief.ELF.NOTE_TYPES, description: List[int]) -> None

Ctor from name, type and description

property description

Return the description associated with the note

property details

Parse the given note description and return a NoteDetails object

property is_android

True if the note is an Android one

property is_core

True if the note is associated with a coredump

property name

Return the name of the note (Usually the owner).

property type

Return the type of the note. Can be one of the NOTE_TYPES values

property type_core

Return the type of the note for core ELF (ET_CORE). Can be one of the NOTE_TYPES_CORE values


Note Details

class lief.ELF.NoteDetails(self: lief.ELF.NoteDetails) → None

Default ctor


Core PrPsInfo

class lief.ELF.CorePrPsInfo
property file_name

Process file name

property flags

Process flags

property gid

Process Group ID

property pgrp

Process session group ID

property pid

Process ID

property ppid

Process parent ID

property sid

Process session ID

property uid

Process User ID


Core PrStatus

class lief.ELF.CorePrStatus
class REGISTERS(self: lief.ELF.CorePrStatus.REGISTERS, arg0: int) → None

Members:

UNKNOWN

X86_EBX

X86_ECX

X86_EDX

X86_ESI

X86_EDI

X86_EBP

X86_EAX

X86_DS

X86_ES

X86_FS

X86_GS

X86__

X86_EIP

X86_CS

X86_EFLAGS

X86_ESP

X86_SS

X86_64_R15

X86_64_R14

X86_64_R13

X86_64_R12

X86_64_RBP

X86_64_RBX

X86_64_R11

X86_64_R10

X86_64_R9

X86_64_R8

X86_64_RAX

X86_64_RCX

X86_64_RDX

X86_64_RSI

X86_64_RDI

X86_64__

X86_64_RIP

X86_64_CS

X86_64_EFLAGS

X86_64_RSP

X86_64_SS

ARM_R0

ARM_R1

ARM_R2

ARM_R3

ARM_R4

ARM_R5

ARM_R6

ARM_R7

ARM_R8

ARM_R9

ARM_R10

ARM_R11

ARM_R12

ARM_R13

ARM_R14

ARM_R15

ARM_CPSR

AARCH64_X0

AARCH64_X1

AARCH64_X2

AARCH64_X3

AARCH64_X4

AARCH64_X5

AARCH64_X6

AARCH64_X7

AARCH64_X8

AARCH64_X9

AARCH64_X10

AARCH64_X11

AARCH64_X12

AARCH64_X13

AARCH64_X14

AARCH64_X15

AARCH64_X16

AARCH64_X17

AARCH64_X18

AARCH64_X19

AARCH64_X20

AARCH64_X21

AARCH64_X22

AARCH64_X23

AARCH64_X24

AARCH64_X25

AARCH64_X26

AARCH64_X27

AARCH64_X28

AARCH64_X29

AARCH64_X30

AARCH64_X31

AARCH64_PC

AARCH64__

AARCH64_PC = REGISTERS.AARCH64_PC
AARCH64_X0 = REGISTERS.AARCH64_X0
AARCH64_X1 = REGISTERS.AARCH64_X1
AARCH64_X10 = REGISTERS.AARCH64_X10
AARCH64_X11 = REGISTERS.AARCH64_X11
AARCH64_X12 = REGISTERS.AARCH64_X12
AARCH64_X13 = REGISTERS.AARCH64_X13
AARCH64_X14 = REGISTERS.AARCH64_X14
AARCH64_X15 = REGISTERS.AARCH64_X15
AARCH64_X16 = REGISTERS.AARCH64_X16
AARCH64_X17 = REGISTERS.AARCH64_X17
AARCH64_X18 = REGISTERS.AARCH64_X18
AARCH64_X19 = REGISTERS.AARCH64_X19
AARCH64_X2 = REGISTERS.AARCH64_X2
AARCH64_X20 = REGISTERS.AARCH64_X20
AARCH64_X21 = REGISTERS.AARCH64_X21
AARCH64_X22 = REGISTERS.AARCH64_X22
AARCH64_X23 = REGISTERS.AARCH64_X23
AARCH64_X24 = REGISTERS.AARCH64_X24
AARCH64_X25 = REGISTERS.AARCH64_X25
AARCH64_X26 = REGISTERS.AARCH64_X26
AARCH64_X27 = REGISTERS.AARCH64_X27
AARCH64_X28 = REGISTERS.AARCH64_X28
AARCH64_X29 = REGISTERS.AARCH64_X29
AARCH64_X3 = REGISTERS.AARCH64_X3
AARCH64_X30 = REGISTERS.AARCH64_X30
AARCH64_X31 = REGISTERS.AARCH64_X31
AARCH64_X4 = REGISTERS.AARCH64_X4
AARCH64_X5 = REGISTERS.AARCH64_X5
AARCH64_X6 = REGISTERS.AARCH64_X6
AARCH64_X7 = REGISTERS.AARCH64_X7
AARCH64_X8 = REGISTERS.AARCH64_X8
AARCH64_X9 = REGISTERS.AARCH64_X9
AARCH64__ = REGISTERS.AARCH64__
ARM_CPSR = REGISTERS.ARM_CPSR
ARM_R0 = REGISTERS.ARM_R0
ARM_R1 = REGISTERS.ARM_R1
ARM_R10 = REGISTERS.ARM_R10
ARM_R11 = REGISTERS.ARM_R11
ARM_R12 = REGISTERS.ARM_R12
ARM_R13 = REGISTERS.ARM_R13
ARM_R14 = REGISTERS.ARM_R14
ARM_R15 = REGISTERS.ARM_R15
ARM_R2 = REGISTERS.ARM_R2
ARM_R3 = REGISTERS.ARM_R3
ARM_R4 = REGISTERS.ARM_R4
ARM_R5 = REGISTERS.ARM_R5
ARM_R6 = REGISTERS.ARM_R6
ARM_R7 = REGISTERS.ARM_R7
ARM_R8 = REGISTERS.ARM_R8
ARM_R9 = REGISTERS.ARM_R9
UNKNOWN = REGISTERS.UNKNOWN
X86_64_CS = REGISTERS.X86_64_CS
X86_64_EFLAGS = REGISTERS.X86_64_EFLAGS
X86_64_R10 = REGISTERS.X86_64_R10
X86_64_R11 = REGISTERS.X86_64_R11
X86_64_R12 = REGISTERS.X86_64_R12
X86_64_R13 = REGISTERS.X86_64_R13
X86_64_R14 = REGISTERS.X86_64_R14
X86_64_R15 = REGISTERS.X86_64_R15
X86_64_R8 = REGISTERS.X86_64_R8
X86_64_R9 = REGISTERS.X86_64_R9
X86_64_RAX = REGISTERS.X86_64_RAX
X86_64_RBP = REGISTERS.X86_64_RBP
X86_64_RBX = REGISTERS.X86_64_RBX
X86_64_RCX = REGISTERS.X86_64_RCX
X86_64_RDI = REGISTERS.X86_64_RDI
X86_64_RDX = REGISTERS.X86_64_RDX
X86_64_RIP = REGISTERS.X86_64_RIP
X86_64_RSI = REGISTERS.X86_64_RSI
X86_64_RSP = REGISTERS.X86_64_RSP
X86_64_SS = REGISTERS.X86_64_SS
X86_64__ = REGISTERS.X86_64__
X86_CS = REGISTERS.X86_CS
X86_DS = REGISTERS.X86_DS
X86_EAX = REGISTERS.X86_EAX
X86_EBP = REGISTERS.X86_EBP
X86_EBX = REGISTERS.X86_EBX
X86_ECX = REGISTERS.X86_ECX
X86_EDI = REGISTERS.X86_EDI
X86_EDX = REGISTERS.X86_EDX
X86_EFLAGS = REGISTERS.X86_EFLAGS
X86_EIP = REGISTERS.X86_EIP
X86_ES = REGISTERS.X86_ES
X86_ESI = REGISTERS.X86_ESI
X86_ESP = REGISTERS.X86_ESP
X86_FS = REGISTERS.X86_FS
X86_GS = REGISTERS.X86_GS
X86_SS = REGISTERS.X86_SS
X86__ = REGISTERS.X86__
property name

(self: handle) -> str

property cstime

Cumulative system time (timeval)

property current_sig

Current Signal

property cutime

Cumulative user time (timeval)

get(self: lief.ELF.CorePrStatus, register: LIEF::ELF::CorePrStatus::REGISTERS) → object

Return the register value

has(self: lief.ELF.CorePrStatus, register: LIEF::ELF::CorePrStatus::REGISTERS) → bool

Check if a value is associated with the given register

property pgrp

Process group ID

property pid

Process ID

property ppid

Process parent ID

property register_context

Current registers state as a dictionarry whose keys are REGISTERS and the values the register’s value

set(self: lief.ELF.CorePrStatus, register: LIEF::ELF::CorePrStatus::REGISTERS, value: int) → bool

Set register value

property sid

Process session ID

property sighold

Set of held signals

property siginfo

Info associated with the signal

property sigpend

Set of pending signals

property stime

System time (timeval)

class timeval
property sec
property usec
property utime

User time (timeval)


Core File

class lief.ELF.CoreFile
property files

List of files mapped in core. (list of CoreFileEntry)


Core File Entry

class lief.ELF.CoreFileEntry
property end

End address of mapped file

property file_ofs

Offset (in core) of mapped file

property path

Path of mapped file

property start

Start address of mapped file


Core Siginfo

class lief.ELF.CoreSigInfo
property sigcode

Signal code

property sigerrno

If non-zero, an errno value associated with this signal

property signo

Signal number


Core Auxiliary Vector

class lief.ELF.CoreAuxv
class TYPES(self: lief.ELF.CoreAuxv.TYPES, arg0: int) → None

Members:

NULL

IGNORE

EXECFD

PHDR

PHENT

PHNUM

PAGESZ

BASE

FLAGS

ENTRY

NOTELF

UID

EUID

GID

EGID

CKLTCK

PLATFORM

HWCAP

HWCAP2

FPUCW

DCACHEBSIZE

ICACHEBSIZE

UCACHEBSIZE

IGNOREPPC

SECURE

BASE_PLATFORM

RANDOM

EXECFN

SYSINFO

SYSINFO_EHDR

L1I_CACHESHAPE

L1D_CACHESHAPE

BASE = TYPES.BASE
BASE_PLATFORM = TYPES.BASE_PLATFORM
CKLTCK = TYPES.CKLTCK
DCACHEBSIZE = TYPES.DCACHEBSIZE
EGID = TYPES.EGID
ENTRY = TYPES.ENTRY
EUID = TYPES.EUID
EXECFD = TYPES.EXECFD
EXECFN = TYPES.EXECFN
FLAGS = TYPES.FLAGS
FPUCW = TYPES.FPUCW
GID = TYPES.GID
HWCAP = TYPES.HWCAP
HWCAP2 = TYPES.HWCAP2
ICACHEBSIZE = TYPES.ICACHEBSIZE
IGNORE = TYPES.IGNORE
IGNOREPPC = TYPES.IGNOREPPC
L1D_CACHESHAPE = TYPES.L1D_CACHESHAPE
L1I_CACHESHAPE = TYPES.L1I_CACHESHAPE
NOTELF = TYPES.NOTELF
NULL = TYPES.NULL
PAGESZ = TYPES.PAGESZ
PHDR = TYPES.PHDR
PHENT = TYPES.PHENT
PHNUM = TYPES.PHNUM
PLATFORM = TYPES.PLATFORM
RANDOM = TYPES.RANDOM
SECURE = TYPES.SECURE
SYSINFO = TYPES.SYSINFO
SYSINFO_EHDR = TYPES.SYSINFO_EHDR
UCACHEBSIZE = TYPES.UCACHEBSIZE
UID = TYPES.UID
property name

(self: handle) -> str

get(self: lief.ELF.CoreAuxv, type: LIEF::ELF::AUX_TYPE) → object

Return the type value

has(self: lief.ELF.CoreAuxv, type: LIEF::ELF::AUX_TYPE) → bool

Check if a value is associated with the given type

set(self: lief.ELF.CoreAuxv, type: LIEF::ELF::AUX_TYPE, value: int) → bool

Set type value

property values

Current values as a dictionarry whose keys are AUXV types


Android Note

class lief.ELF.AndroidNote
property ndk_build_number

Android NDK build number

property ndk_version

Android NDK version used to build the current binary

property sdk_version

Target SDK platform


Note ABI

class lief.ELF.NoteAbi
property abi

Return the target NOTE_ABIS

property version

Return the target version as (Major, Minor, Patch)


Builder

class lief.ELF.Builder(self: lief.ELF.Builder, elf_binary: lief.ELF.Binary) → None

Constructor that takes a Binary

build(self: lief.ELF.Builder) → None

Perform the build process

empties_gnuhash(self: lief.ELF.Builder, arg0: bool) → lief.ELF.Builder

Disable the GnuHash

get_build(self: lief.ELF.Builder) → List[int]

Return the build result as a list of bytes

write(self: lief.ELF.Builder, output: str) → None

Write the build result into the output file

Enums

Identity

class lief.ELF.IDENTITY(self: lief.ELF.IDENTITY, arg0: int) → None

Members:

MAG0

MAG1

MAG2

MAG3

CLASS

DATA

VERSION

OSABI

ABIVERSION

PAD

NIDENT

ABIVERSION = IDENTITY.ABIVERSION
CLASS = IDENTITY.CLASS
DATA = IDENTITY.DATA
MAG0 = IDENTITY.MAG0
MAG1 = IDENTITY.MAG1
MAG2 = IDENTITY.MAG2
MAG3 = IDENTITY.MAG3
NIDENT = IDENTITY.NIDENT
OSABI = IDENTITY.OSABI
PAD = IDENTITY.PAD
VERSION = IDENTITY.VERSION
property name

(self: handle) -> str


ELF Class

class lief.ELF.ELF_CLASS(self: lief.ELF.ELF_CLASS, arg0: int) → None

Members:

NONE

CLASS32

CLASS64

CLASS32 = ELF_CLASS.CLASS32
CLASS64 = ELF_CLASS.CLASS64
NONE = ELF_CLASS.NONE
property name

(self: handle) -> str


ELF Data

class lief.ELF.ELF_DATA(self: lief.ELF.ELF_DATA, arg0: int) → None

Members:

NONE

LSB

MSB

LSB = ELF_DATA.LSB
MSB = ELF_DATA.MSB
NONE = ELF_DATA.NONE
property name

(self: handle) -> str


ELF OS/ABI

class lief.ELF.OS_ABI(self: lief.ELF.OS_ABI, arg0: int) → None

Members:

SYSTEMV

HPUX

NETBSD

LINUX

GNU

HURD

SOLARIS

AIX

IRIX

FREEBSD

TRU64

MODESTO

OPENBSD

OPENVMS

NSK

AROS

FENIXOS

CLOUDABI

AMDGPU_HSA

C6000_ELFABI

C6000_LINUX

ARM

STANDALONE

AIX = OS_ABI.AIX
AMDGPU_HSA = OS_ABI.AMDGPU_HSA
ARM = OS_ABI.ARM
AROS = OS_ABI.AROS
C6000_ELFABI = OS_ABI.AMDGPU_HSA
C6000_LINUX = OS_ABI.C6000_LINUX
CLOUDABI = OS_ABI.CLOUDABI
FENIXOS = OS_ABI.FENIXOS
FREEBSD = OS_ABI.FREEBSD
GNU = OS_ABI.LINUX
HPUX = OS_ABI.HPUX
HURD = OS_ABI.HURD
IRIX = OS_ABI.IRIX
LINUX = OS_ABI.LINUX
MODESTO = OS_ABI.MODESTO
NETBSD = OS_ABI.NETBSD
NSK = OS_ABI.NSK
OPENBSD = OS_ABI.OPENBSD
OPENVMS = OS_ABI.OPENVMS
SOLARIS = OS_ABI.SOLARIS
STANDALONE = OS_ABI.STANDALONE
SYSTEMV = OS_ABI.SYSTEMV
TRU64 = OS_ABI.TRU64
property name

(self: handle) -> str


Symbol section index

class lief.ELF.SYMBOL_SECTION_INDEX(self: lief.ELF.SYMBOL_SECTION_INDEX, arg0: int) → None

Members:

UNDEF

ABS

COMMON

XINDEX

ABS = SYMBOL_SECTION_INDEX.ABS
COMMON = SYMBOL_SECTION_INDEX.COMMON
UNDEF = SYMBOL_SECTION_INDEX.UNDEF
XINDEX = SYMBOL_SECTION_INDEX.XINDEX
property name

(self: handle) -> str


Binary types

class lief.ELF.E_TYPE(self: lief.ELF.E_TYPE, arg0: int) → None

Members:

NONE

RELOCATABLE

EXECUTABLE

DYNAMIC

CORE

LOPROC

HIPROC

CORE = E_TYPE.CORE
DYNAMIC = E_TYPE.DYNAMIC
EXECUTABLE = E_TYPE.EXECUTABLE
HIPROC = E_TYPE.HIPROC
LOPROC = E_TYPE.LOPROC
NONE = E_TYPE.NONE
RELOCATABLE = E_TYPE.RELOCATABLE
property name

(self: handle) -> str


Section types

class lief.ELF.SECTION_TYPES(self: lief.ELF.SECTION_TYPES, arg0: int) → None

Members:

NULL

PROGBITS

SYMTAB

STRTAB

RELA

HASH

DYNAMIC

NOTE

NOBITS

REL

SHLIB

DYNSYM

INIT_ARRAY

FINI_ARRAY

PREINIT_ARRAY

GROUP

SYMTAB_SHNDX

LOOS

GNU_ATTRIBUTES

GNU_HASH

GNU_VERDEF

GNU_VERNEED

HIOS

ARM_EXIDX

ARM_PREEMPTMAP

ARM_ATTRIBUTES

ARM_DEBUGOVERLAY

ARM_OVERLAYSECTION

HEX_ORDERED

X86_64_UNWIND

HIPROC

LOUSER

HIUSER

ARM_ATTRIBUTES = SECTION_TYPES.ARM_ATTRIBUTES
ARM_DEBUGOVERLAY = SECTION_TYPES.ARM_DEBUGOVERLAY
ARM_EXIDX = SECTION_TYPES.ARM_EXIDX
ARM_OVERLAYSECTION = SECTION_TYPES.ARM_OVERLAYSECTION
ARM_PREEMPTMAP = SECTION_TYPES.ARM_PREEMPTMAP
DYNAMIC = SECTION_TYPES.DYNAMIC
DYNSYM = SECTION_TYPES.DYNSYM
FINI_ARRAY = SECTION_TYPES.FINI_ARRAY
GNU_ATTRIBUTES = SECTION_TYPES.GNU_ATTRIBUTES
GNU_HASH = SECTION_TYPES.GNU_HASH
GNU_VERDEF = SECTION_TYPES.GNU_VERDEF
GNU_VERNEED = SECTION_TYPES.GNU_VERNEED
GROUP = SECTION_TYPES.GROUP
HASH = SECTION_TYPES.HASH
HEX_ORDERED = SECTION_TYPES.HEX_ORDERED
HIOS = SECTION_TYPES.HIOS
HIPROC = SECTION_TYPES.HIPROC
HIUSER = SECTION_TYPES.HIUSER
INIT_ARRAY = SECTION_TYPES.INIT_ARRAY
LOOS = SECTION_TYPES.LOOS
LOUSER = SECTION_TYPES.LOUSER
NOBITS = SECTION_TYPES.NOBITS
NOTE = SECTION_TYPES.NOTE
NULL = SECTION_TYPES.NULL
PREINIT_ARRAY = SECTION_TYPES.PREINIT_ARRAY
PROGBITS = SECTION_TYPES.PROGBITS
REL = SECTION_TYPES.REL
RELA = SECTION_TYPES.RELA
SHLIB = SECTION_TYPES.SHLIB
STRTAB = SECTION_TYPES.STRTAB
SYMTAB = SECTION_TYPES.SYMTAB
SYMTAB_SHNDX = SECTION_TYPES.SYMTAB_SHNDX
X86_64_UNWIND = SECTION_TYPES.ARM_EXIDX
property name

(self: handle) -> str


Section flags

class lief.ELF.SECTION_FLAGS(self: lief.ELF.SECTION_FLAGS, arg0: int) → None

Members:

NONE

WRITE

ALLOC

EXECINSTR

MERGE

STRINGS

INFO_LINK

LINK_ORDER

OS_NONCONFORMING

GROUP

TLS

MIPS_STRING

SHF_CP_SECTION

XCORE_SHF_CP_SECTION

MASKOS

MASKPROC

HEX_GPREL

ALLOC = SECTION_FLAGS.ALLOC
EXECINSTR = SECTION_FLAGS.EXECINSTR
GROUP = SECTION_FLAGS.GROUP
HEX_GPREL = SECTION_FLAGS.HEX_GPREL
MASKOS = SECTION_FLAGS.MASKOS
MASKPROC = SECTION_FLAGS.MASKPROC
MERGE = SECTION_FLAGS.MERGE
MIPS_STRING = SECTION_FLAGS.MIPS_STRING
NONE = SECTION_FLAGS.NONE
OS_NONCONFORMING = SECTION_FLAGS.OS_NONCONFORMING
SHF_CP_SECTION = SECTION_FLAGS.SHF_CP_SECTION
STRINGS = SECTION_FLAGS.STRINGS
TLS = SECTION_FLAGS.TLS
WRITE = SECTION_FLAGS.WRITE
XCORE_SHF_CP_SECTION = SECTION_FLAGS.XCORE_SHF_CP_SECTION
property name

(self: handle) -> str


Segment types

class lief.ELF.SEGMENT_TYPES(self: lief.ELF.SEGMENT_TYPES, arg0: int) → None

Members:

NULL

LOAD

DYNAMIC

INTERP

NOTE

SHLIB

PHDR

TLS

GNU_EH_FRAME

GNU_PROPERTY

GNU_STACK

GNU_RELRO

ARM_ARCHEXT

ARM_UNWIND

UNWIND

ARM_ARCHEXT = SEGMENT_TYPES.ARM_ARCHEXT
ARM_UNWIND = SEGMENT_TYPES.ARM_UNWIND
DYNAMIC = SEGMENT_TYPES.DYNAMIC
GNU_EH_FRAME = SEGMENT_TYPES.GNU_EH_FRAME
GNU_PROPERTY = SEGMENT_TYPES.GNU_PROPERTY
GNU_RELRO = SEGMENT_TYPES.GNU_RELRO
GNU_STACK = SEGMENT_TYPES.GNU_STACK
INTERP = SEGMENT_TYPES.INTERP
LOAD = SEGMENT_TYPES.LOAD
NOTE = SEGMENT_TYPES.NOTE
NULL = SEGMENT_TYPES.NULL
PHDR = SEGMENT_TYPES.PHDR
SHLIB = SEGMENT_TYPES.SHLIB
TLS = SEGMENT_TYPES.TLS
UNWIND = SEGMENT_TYPES.ARM_UNWIND
property name

(self: handle) -> str


Segment flags

class lief.ELF.SEGMENT_FLAGS(self: lief.ELF.SEGMENT_FLAGS, arg0: int) → None

Members:

NONE

X

W

R

NONE = SEGMENT_FLAGS.NONE
R = SEGMENT_FLAGS.R
W = SEGMENT_FLAGS.W
X = SEGMENT_FLAGS.X
property name

(self: handle) -> str


Architectures

class lief.ELF.ARCH(self: lief.ELF.ARCH, arg0: int) → None

Members:

None

M32

SPARC

i386

ARCH_68K

ARCH_88K

IAMCU

ARCH_860

MIPS

S370

MIPS_RS3_LE

PARISC

VPP500

SPARC32PLUS

ARCH_960

PPC

PPC64

S390

SPU

V800

FR20

RH32

RCE

ARM

ALPHA

SH

SPARCV9

TRICORE

ARC

H8_300

H8_300H

H8S

H8_500

IA_64

MIPS_X

COLDFIRE

ARCH_68HC12

MMA

PCP

NCPU

NDR1

STARCORE

ME16

ST100

TINYJ

x86_64

PDSP

PDP10

PDP11

FX66

ST9PLUS

ST7

ARCH_68HC16

ARCH_68HC11

ARCH_68HC08

ARCH_68HC05

SVX

ST19

VAX

CRIS

JAVELIN

FIREPATH

ZSP

MMIX

HUANY

PRISM

AVR

FR30

D10V

D30V

V850

M32R

MN10300

MN10200

PJ

OPENRISC

ARC_COMPACT

XTENSA

VIDEOCORE

TMM_GPP

NS32K

TPC

SNP1K

ST200

IP2K

MAX

CR

F2MC16

MSP430

BLACKFIN

SE_C33

SEP

ARCA

UNICORE

EXCESS

DXP

ALTERA_NIOS2

CRX

XGATE

C166

M16C

DSPIC30F

CE

M32C

TSK3000

RS08

SHARC

ECOG2

SCORE7

DSP24

VIDEOCORE3

LATTICEMICO32

SE_C17

TI_C6000

TI_C2000

TI_C5500

MMDSP_PLUS

CYPRESS_M8C

R32C

TRIMEDIA

HEXAGON

ARCH_8051

STXP7X

NDS32

ECOG1

ECOG1X

MAXQ30

XIMO16

MANIK

CRAYNV2

RX

METAG

MCST_ELBRUS

ECOG16

CR16

ETPU

SLE9X

L10M

K10M

AARCH64

AVR32

STM8

TILE64

TILEPRO

CUDA

TILEGX

CLOUDSHIELD

COREA_1ST

COREA_2ND

ARC_COMPACT2

OPEN8

RL78

VIDEOCORE5

ARCH_78KOR

ARCH_56800EX

BA1

BA2

XCORE

MCHP_PIC

INTEL205

INTEL206

INTEL207

INTEL208

INTEL209

KM32

KMX32

KMX16

KMX8

KVARC

CDP

COGE

COOL

NORC

CSR_KALIMBA

AMDGPU

AARCH64 = ARCH.AARCH64
ALPHA = ARCH.ALPHA
ALTERA_NIOS2 = ARCH.ALTERA_NIOS2
AMDGPU = ARCH.AMDGPU
ARC = ARCH.ARC
ARCA = ARCH.ARCA
ARCH_56800EX = ARCH.ARCH_56800EX
ARCH_68HC05 = ARCH.ARCH_68HC05
ARCH_68HC08 = ARCH.ARCH_68HC08
ARCH_68HC11 = ARCH.ARCH_68HC11
ARCH_68HC12 = ARCH.ARCH_68HC12
ARCH_68HC16 = ARCH.ARCH_68HC16
ARCH_68K = ARCH.ARCH_68K
ARCH_78KOR = ARCH.ARCH_78KOR
ARCH_8051 = ARCH.ARCH_8051
ARCH_860 = ARCH.ARCH_860
ARCH_88K = ARCH.ARCH_88K
ARCH_960 = ARCH.ARCH_960
ARC_COMPACT = ARCH.ARC_COMPACT
ARC_COMPACT2 = ARCH.ARC_COMPACT2
ARM = ARCH.ARM
AVR = ARCH.AVR
AVR32 = ARCH.AVR32
BA1 = ARCH.BA1
BA2 = ARCH.BA2
BLACKFIN = ARCH.BLACKFIN
C166 = ARCH.C166
CDP = ARCH.CDP
CE = ARCH.CE
CLOUDSHIELD = ARCH.CLOUDSHIELD
COGE = ARCH.COGE
COLDFIRE = ARCH.COLDFIRE
COOL = ARCH.COOL
COREA_1ST = ARCH.COREA_1ST
COREA_2ND = ARCH.COREA_2ND
CR = ARCH.CR
CR16 = ARCH.CR16
CRAYNV2 = ARCH.CRAYNV2
CRIS = ARCH.CRIS
CRX = ARCH.CRX
CSR_KALIMBA = ARCH.CSR_KALIMBA
CUDA = ARCH.CUDA
CYPRESS_M8C = ARCH.CYPRESS_M8C
D10V = ARCH.D10V
D30V = ARCH.D30V
DSP24 = ARCH.DSP24
DSPIC30F = ARCH.DSPIC30F
DXP = ARCH.DXP
ECOG1 = ARCH.ECOG1
ECOG16 = ARCH.ECOG16
ECOG1X = ARCH.ECOG1
ECOG2 = ARCH.ECOG2
ETPU = ARCH.ETPU
EXCESS = ARCH.EXCESS
F2MC16 = ARCH.F2MC16
FIREPATH = ARCH.FIREPATH
FR20 = ARCH.FR20
FR30 = ARCH.FR30
FX66 = ARCH.FX66
H8S = ARCH.H8S
H8_300 = ARCH.H8_300
H8_300H = ARCH.H8_300H
H8_500 = ARCH.H8_500
HEXAGON = ARCH.HEXAGON
HUANY = ARCH.HUANY
IAMCU = ARCH.IAMCU
IA_64 = ARCH.IA_64
INTEL205 = ARCH.INTEL205
INTEL206 = ARCH.INTEL206
INTEL207 = ARCH.INTEL207
INTEL208 = ARCH.INTEL208
INTEL209 = ARCH.INTEL209
IP2K = ARCH.IP2K
JAVELIN = ARCH.JAVELIN
K10M = ARCH.K10M
KM32 = ARCH.KM32
KMX16 = ARCH.KMX16
KMX32 = ARCH.KMX32
KMX8 = ARCH.KMX8
KVARC = ARCH.KVARC
L10M = ARCH.L10M
LATTICEMICO32 = ARCH.LATTICEMICO32
M16C = ARCH.M16C
M32 = ARCH.M32
M32C = ARCH.M32C
M32R = ARCH.M32R
MANIK = ARCH.MANIK
MAX = ARCH.MAX
MAXQ30 = ARCH.MAXQ30
MCHP_PIC = ARCH.MCHP_PIC
MCST_ELBRUS = ARCH.MCST_ELBRUS
ME16 = ARCH.ME16
METAG = ARCH.METAG
MIPS = ARCH.MIPS
MIPS_RS3_LE = ARCH.MIPS_RS3_LE
MIPS_X = ARCH.MIPS_X
MMA = ARCH.MMA
MMDSP_PLUS = ARCH.MMDSP_PLUS
MMIX = ARCH.MMIX
MN10200 = ARCH.MN10200
MN10300 = ARCH.MN10300
MSP430 = ARCH.MSP430
NCPU = ARCH.NCPU
NDR1 = ARCH.NDR1
NDS32 = ARCH.NDS32
NORC = ARCH.NORC
NS32K = ARCH.NS32K
None = ARCH.None
OPEN8 = ARCH.OPEN8
OPENRISC = ARCH.OPENRISC
PARISC = ARCH.PARISC
PCP = ARCH.PCP
PDP10 = ARCH.PDP10
PDP11 = ARCH.PDP11
PDSP = ARCH.PDSP
PJ = ARCH.PJ
PPC = ARCH.PPC
PPC64 = ARCH.PPC64
PRISM = ARCH.PRISM
R32C = ARCH.R32C
RCE = ARCH.RCE
RH32 = ARCH.RH32
RL78 = ARCH.RL78
RS08 = ARCH.RS08
RX = ARCH.RX
S370 = ARCH.S370
S390 = ARCH.S390
SCORE7 = ARCH.SCORE7
SEP = ARCH.SEP
SE_C17 = ARCH.SE_C17
SE_C33 = ARCH.SE_C33
SH = ARCH.SH
SHARC = ARCH.SHARC
SLE9X = ARCH.SLE9X
SNP1K = ARCH.SNP1K
SPARC = ARCH.SPARC
SPARC32PLUS = ARCH.SPARC32PLUS
SPARCV9 = ARCH.SPARCV9
SPU = ARCH.SPU
ST100 = ARCH.ST100
ST19 = ARCH.ST19
ST200 = ARCH.ST200
ST7 = ARCH.ST7
ST9PLUS = ARCH.ST9PLUS
STARCORE = ARCH.STARCORE
STM8 = ARCH.STM8
STXP7X = ARCH.STXP7X
SVX = ARCH.SVX
TILE64 = ARCH.TILE64
TILEGX = ARCH.TILEGX
TILEPRO = ARCH.TILEPRO
TINYJ = ARCH.TINYJ
TI_C2000 = ARCH.TI_C2000
TI_C5500 = ARCH.TI_C5500
TI_C6000 = ARCH.TI_C6000
TMM_GPP = ARCH.TMM_GPP
TPC = ARCH.TPC
TRICORE = ARCH.TRICORE
TRIMEDIA = ARCH.TRIMEDIA
TSK3000 = ARCH.TSK3000
UNICORE = ARCH.UNICORE
V800 = ARCH.V800
V850 = ARCH.V850
VAX = ARCH.VAX
VIDEOCORE = ARCH.VIDEOCORE
VIDEOCORE3 = ARCH.VIDEOCORE3
VIDEOCORE5 = ARCH.VIDEOCORE5
VPP500 = ARCH.VPP500
XCORE = ARCH.XCORE
XGATE = ARCH.XGATE
XIMO16 = ARCH.XIMO16
XTENSA = ARCH.XTENSA
ZSP = ARCH.ZSP
i386 = ARCH.i386
property name

(self: handle) -> str

x86_64 = ARCH.x86_64

Version

class lief.ELF.VERSION(self: lief.ELF.VERSION, arg0: int) → None

Members:

NONE

CURRENT

CURRENT = VERSION.CURRENT
NONE = VERSION.NONE
property name

(self: handle) -> str


Dynamic tags

class lief.ELF.DYNAMIC_TAGS(self: lief.ELF.DYNAMIC_TAGS, arg0: int) → None

Members:

NULL

NEEDED

PLTRELSZ

PLTGOT

HASH

STRTAB

SYMTAB

RELA

RELASZ

RELAENT

STRSZ

SYMENT

INIT

FINI

SONAME

RPATH

SYMBOLIC

REL

RELSZ

RELENT

PLTREL

DEBUG

TEXTREL

JMPREL

BIND_NOW

INIT_ARRAY

FINI_ARRAY

INIT_ARRAYSZ

FINI_ARRAYSZ

RUNPATH

FLAGS

PREINIT_ARRAY

PREINIT_ARRAYSZ

GNU_HASH

RELACOUNT

RELCOUNT

FLAGS_1

VERSYM

VERDEF

VERDEFNUM

VERNEED

VERNEEDNUM

MIPS_RLD_VERSION

MIPS_TIME_STAMP

MIPS_ICHECKSUM

MIPS_IVERSION

MIPS_FLAGS

MIPS_BASE_ADDRESS

MIPS_MSYM

MIPS_CONFLICT

MIPS_LIBLIST

MIPS_LOCAL_GOTNO

MIPS_CONFLICTNO

MIPS_LIBLISTNO

MIPS_SYMTABNO

MIPS_UNREFEXTNO

MIPS_GOTSYM

MIPS_HIPAGENO

MIPS_RLD_MAP

MIPS_DELTA_CLASS

MIPS_DELTA_CLASS_NO

MIPS_DELTA_INSTANCE

MIPS_DELTA_INSTANCE_NO

MIPS_DELTA_RELOC

MIPS_DELTA_RELOC_NO

MIPS_DELTA_SYM

MIPS_DELTA_SYM_NO

MIPS_DELTA_CLASSSYM

MIPS_DELTA_CLASSSYM_NO

MIPS_CXX_FLAGS

MIPS_PIXIE_INIT

MIPS_SYMBOL_LIB

MIPS_LOCALPAGE_GOTIDX

MIPS_LOCAL_GOTIDX

MIPS_HIDDEN_GOTIDX

MIPS_PROTECTED_GOTIDX

MIPS_OPTIONS

MIPS_INTERFACE

MIPS_DYNSTR_ALIGN

MIPS_INTERFACE_SIZE

MIPS_RLD_TEXT_RESOLVE_ADDR

MIPS_PERF_SUFFIX

MIPS_COMPACT_SIZE

MIPS_GP_VALUE

MIPS_AUX_DYNAMIC

MIPS_PLTGOT

MIPS_RWPLT

BIND_NOW = DYNAMIC_TAGS.BIND_NOW
DEBUG = DYNAMIC_TAGS.DEBUG
FINI = DYNAMIC_TAGS.FINI
FINI_ARRAY = DYNAMIC_TAGS.FINI_ARRAY
FINI_ARRAYSZ = DYNAMIC_TAGS.FINI_ARRAYSZ
FLAGS = DYNAMIC_TAGS.FLAGS
FLAGS_1 = DYNAMIC_TAGS.FLAGS_1
GNU_HASH = DYNAMIC_TAGS.GNU_HASH
HASH = DYNAMIC_TAGS.HASH
INIT = DYNAMIC_TAGS.INIT
INIT_ARRAY = DYNAMIC_TAGS.INIT_ARRAY
INIT_ARRAYSZ = DYNAMIC_TAGS.INIT_ARRAYSZ
JMPREL = DYNAMIC_TAGS.JMPREL
MIPS_AUX_DYNAMIC = DYNAMIC_TAGS.MIPS_AUX_DYNAMIC
MIPS_BASE_ADDRESS = DYNAMIC_TAGS.MIPS_BASE_ADDRESS
MIPS_COMPACT_SIZE = DYNAMIC_TAGS.MIPS_COMPACT_SIZE
MIPS_CONFLICT = DYNAMIC_TAGS.MIPS_CONFLICT
MIPS_CONFLICTNO = DYNAMIC_TAGS.MIPS_CONFLICTNO
MIPS_CXX_FLAGS = DYNAMIC_TAGS.MIPS_CXX_FLAGS
MIPS_DELTA_CLASS = DYNAMIC_TAGS.MIPS_DELTA_CLASS
MIPS_DELTA_CLASSSYM = DYNAMIC_TAGS.MIPS_DELTA_CLASSSYM
MIPS_DELTA_CLASSSYM_NO = DYNAMIC_TAGS.MIPS_DELTA_CLASSSYM_NO
MIPS_DELTA_CLASS_NO = DYNAMIC_TAGS.MIPS_DELTA_CLASS_NO
MIPS_DELTA_INSTANCE = DYNAMIC_TAGS.MIPS_DELTA_INSTANCE
MIPS_DELTA_INSTANCE_NO = DYNAMIC_TAGS.MIPS_DELTA_INSTANCE_NO
MIPS_DELTA_RELOC = DYNAMIC_TAGS.MIPS_DELTA_RELOC
MIPS_DELTA_RELOC_NO = DYNAMIC_TAGS.MIPS_DELTA_RELOC_NO
MIPS_DELTA_SYM = DYNAMIC_TAGS.MIPS_DELTA_SYM
MIPS_DELTA_SYM_NO = DYNAMIC_TAGS.MIPS_DELTA_SYM_NO
MIPS_DYNSTR_ALIGN = DYNAMIC_TAGS.MIPS_DYNSTR_ALIGN
MIPS_FLAGS = DYNAMIC_TAGS.MIPS_FLAGS
MIPS_GOTSYM = DYNAMIC_TAGS.MIPS_GOTSYM
MIPS_GP_VALUE = DYNAMIC_TAGS.MIPS_GP_VALUE
MIPS_HIDDEN_GOTIDX = DYNAMIC_TAGS.MIPS_HIDDEN_GOTIDX
MIPS_HIPAGENO = DYNAMIC_TAGS.MIPS_HIPAGENO
MIPS_ICHECKSUM = DYNAMIC_TAGS.MIPS_ICHECKSUM
MIPS_INTERFACE = DYNAMIC_TAGS.MIPS_INTERFACE
MIPS_INTERFACE_SIZE = DYNAMIC_TAGS.MIPS_INTERFACE_SIZE
MIPS_IVERSION = DYNAMIC_TAGS.MIPS_IVERSION
MIPS_LIBLIST = DYNAMIC_TAGS.MIPS_LIBLIST
MIPS_LIBLISTNO = DYNAMIC_TAGS.MIPS_LIBLISTNO
MIPS_LOCALPAGE_GOTIDX = DYNAMIC_TAGS.MIPS_LOCALPAGE_GOTIDX
MIPS_LOCAL_GOTIDX = DYNAMIC_TAGS.MIPS_LOCAL_GOTIDX
MIPS_LOCAL_GOTNO = DYNAMIC_TAGS.MIPS_LOCAL_GOTNO
MIPS_MSYM = DYNAMIC_TAGS.MIPS_MSYM
MIPS_OPTIONS = DYNAMIC_TAGS.MIPS_OPTIONS
MIPS_PERF_SUFFIX = DYNAMIC_TAGS.MIPS_PERF_SUFFIX
MIPS_PIXIE_INIT = DYNAMIC_TAGS.MIPS_PIXIE_INIT
MIPS_PLTGOT = DYNAMIC_TAGS.MIPS_PLTGOT
MIPS_PROTECTED_GOTIDX = DYNAMIC_TAGS.MIPS_PROTECTED_GOTIDX
MIPS_RLD_MAP = DYNAMIC_TAGS.MIPS_RLD_MAP
MIPS_RLD_TEXT_RESOLVE_ADDR = DYNAMIC_TAGS.MIPS_RLD_TEXT_RESOLVE_ADDR
MIPS_RLD_VERSION = DYNAMIC_TAGS.MIPS_RLD_VERSION
MIPS_RWPLT = DYNAMIC_TAGS.MIPS_RWPLT
MIPS_SYMBOL_LIB = DYNAMIC_TAGS.MIPS_SYMBOL_LIB
MIPS_SYMTABNO = DYNAMIC_TAGS.MIPS_SYMTABNO
MIPS_TIME_STAMP = DYNAMIC_TAGS.MIPS_TIME_STAMP
MIPS_UNREFEXTNO = DYNAMIC_TAGS.MIPS_UNREFEXTNO
NEEDED = DYNAMIC_TAGS.NEEDED
NULL = DYNAMIC_TAGS.NULL
PLTGOT = DYNAMIC_TAGS.PLTGOT
PLTREL = DYNAMIC_TAGS.PLTREL
PLTRELSZ = DYNAMIC_TAGS.PLTRELSZ
PREINIT_ARRAY = DYNAMIC_TAGS.PREINIT_ARRAY
PREINIT_ARRAYSZ = DYNAMIC_TAGS.PREINIT_ARRAYSZ
REL = DYNAMIC_TAGS.REL
RELA = DYNAMIC_TAGS.RELA
RELACOUNT = DYNAMIC_TAGS.RELACOUNT
RELAENT = DYNAMIC_TAGS.RELAENT
RELASZ = DYNAMIC_TAGS.RELASZ
RELCOUNT = DYNAMIC_TAGS.RELCOUNT
RELENT = DYNAMIC_TAGS.RELENT
RELSZ = DYNAMIC_TAGS.RELSZ
RPATH = DYNAMIC_TAGS.RPATH
RUNPATH = DYNAMIC_TAGS.RUNPATH
SONAME = DYNAMIC_TAGS.SONAME
STRSZ = DYNAMIC_TAGS.STRSZ
STRTAB = DYNAMIC_TAGS.STRTAB
SYMBOLIC = DYNAMIC_TAGS.SYMBOLIC
SYMENT = DYNAMIC_TAGS.SYMENT
SYMTAB = DYNAMIC_TAGS.SYMTAB
TEXTREL = DYNAMIC_TAGS.TEXTREL
VERDEF = DYNAMIC_TAGS.VERDEF
VERDEFNUM = DYNAMIC_TAGS.VERDEFNUM
VERNEED = DYNAMIC_TAGS.VERNEED
VERNEEDNUM = DYNAMIC_TAGS.VERNEEDNUM
VERSYM = DYNAMIC_TAGS.VERSYM
property name

(self: handle) -> str


Dynamic flags

class lief.ELF.DYNAMIC_FLAGS(self: lief.ELF.DYNAMIC_FLAGS, arg0: int) → None

Members:

ORIGIN

SYMBOLIC

TEXTREL

BIND_NOW

STATIC_TLS

BIND_NOW = DYNAMIC_FLAGS.BIND_NOW
ORIGIN = DYNAMIC_FLAGS.ORIGIN
STATIC_TLS = DYNAMIC_FLAGS.STATIC_TLS
SYMBOLIC = DYNAMIC_FLAGS.SYMBOLIC
TEXTREL = DYNAMIC_FLAGS.TEXTREL
property name

(self: handle) -> str


Dynamic flags 1

class lief.ELF.DYNAMIC_FLAGS_1(self: lief.ELF.DYNAMIC_FLAGS_1, arg0: int) → None

Members:

NOW

GLOBAL

GROUP

NODELETE

LOADFLTR

INITFIRST

NOOPEN

ORIGIN

DIRECT

TRANS

INTERPOSE

NODEFLIB

NODUMP

CONFALT

ENDFILTEE

DISPRELDNE

DISPRELPND

NODIRECT

IGNMULDEF

NOKSYMS

NOHDR

EDITED

NORELOC

SYMINTPOSE

GLOBAUDIT

SINGLETON

CONFALT = DYNAMIC_FLAGS_1.CONFALT
DIRECT = DYNAMIC_FLAGS_1.DIRECT
DISPRELDNE = DYNAMIC_FLAGS_1.DISPRELDNE
DISPRELPND = DYNAMIC_FLAGS_1.DISPRELPND
EDITED = DYNAMIC_FLAGS_1.EDITED
ENDFILTEE = DYNAMIC_FLAGS_1.ENDFILTEE
GLOBAL = DYNAMIC_FLAGS_1.GLOBAL
GLOBAUDIT = DYNAMIC_FLAGS_1.GLOBAUDIT
GROUP = DYNAMIC_FLAGS_1.GROUP
IGNMULDEF = DYNAMIC_FLAGS_1.IGNMULDEF
INITFIRST = DYNAMIC_FLAGS_1.INITFIRST
INTERPOSE = DYNAMIC_FLAGS_1.INTERPOSE
LOADFLTR = DYNAMIC_FLAGS_1.LOADFLTR
NODEFLIB = DYNAMIC_FLAGS_1.NODEFLIB
NODELETE = DYNAMIC_FLAGS_1.NODELETE
NODIRECT = DYNAMIC_FLAGS_1.NODIRECT
NODUMP = DYNAMIC_FLAGS_1.NODUMP
NOHDR = DYNAMIC_FLAGS_1.NOHDR
NOKSYMS = DYNAMIC_FLAGS_1.NOKSYMS
NOOPEN = DYNAMIC_FLAGS_1.NOOPEN
NORELOC = DYNAMIC_FLAGS_1.NORELOC
NOW = DYNAMIC_FLAGS_1.NOW
ORIGIN = DYNAMIC_FLAGS_1.ORIGIN
SINGLETON = DYNAMIC_FLAGS_1.SINGLETON
SYMINTPOSE = DYNAMIC_FLAGS_1.SYMINTPOSE
TRANS = DYNAMIC_FLAGS_1.TRANS
property name

(self: handle) -> str


Symbol types

class lief.ELF.SYMBOL_TYPES(self: lief.ELF.SYMBOL_TYPES, arg0: int) → None

Members:

NOTYPE

OBJECT

FUNC

SECTION

FILE

COMMON

TLS

GNU_IFUNC

COMMON = SYMBOL_TYPES.COMMON
FILE = SYMBOL_TYPES.FILE
FUNC = SYMBOL_TYPES.FUNC
GNU_IFUNC = SYMBOL_TYPES.GNU_IFUNC
NOTYPE = SYMBOL_TYPES.NOTYPE
OBJECT = SYMBOL_TYPES.OBJECT
SECTION = SYMBOL_TYPES.SECTION
TLS = SYMBOL_TYPES.TLS
property name

(self: handle) -> str


Symbol bindings

class lief.ELF.SYMBOL_BINDINGS(self: lief.ELF.SYMBOL_BINDINGS, arg0: int) → None

Members:

LOCAL

GLOBAL

WEAK

GNU_UNIQUE

GLOBAL = SYMBOL_BINDINGS.GLOBAL
GNU_UNIQUE = SYMBOL_BINDINGS.GNU_UNIQUE
LOCAL = SYMBOL_BINDINGS.LOCAL
WEAK = SYMBOL_BINDINGS.WEAK
property name

(self: handle) -> str


Symbol Visibility

class lief.ELF.SYMBOL_VISIBILITY(self: lief.ELF.SYMBOL_VISIBILITY, arg0: int) → None

Members:

DEFAULT

HIDDEN

INTERNAL

PROTECTED

DEFAULT = SYMBOL_VISIBILITY.DEFAULT
HIDDEN = SYMBOL_VISIBILITY.HIDDEN
INTERNAL = SYMBOL_VISIBILITY.INTERNAL
PROTECTED = SYMBOL_VISIBILITY.PROTECTED
property name

(self: handle) -> str


Relocations x86-64

class lief.ELF.RELOCATION_X86_64(self: lief.ELF.RELOCATION_X86_64, arg0: int) → None

Members:

NONE

R64

PC32

GOT32

PLT32

COPY

GLOB_DAT

JUMP_SLOT

RELATIVE

GOTPCREL

R32

R32S

R16

PC16

R8

PC8

DTPMOD64

DTPOFF64

TPOFF64

TLSGD

TLSLD

DTPOFF32

GOTTPOFF

TPOFF32

PC64

GOTOFF64

GOTPC32

GOT64

GOTPCREL64

GOTPC64

GOTPLT64

PLTOFF64

SIZE32

SIZE64

GOTPC32_TLSDESC

TLSDESC_CALL

TLSDESC

IRELATIVE

RELATIVE64

PC32_BND

PLT32_BND

GOTPCRELX

REX_GOTPCRELX

COPY = RELOCATION_X86_64.COPY
DTPMOD64 = RELOCATION_X86_64.DTPMOD64
DTPOFF32 = RELOCATION_X86_64.DTPOFF32
DTPOFF64 = RELOCATION_X86_64.DTPOFF64
GLOB_DAT = RELOCATION_X86_64.GLOB_DAT
GOT32 = RELOCATION_X86_64.GOT32
GOT64 = RELOCATION_X86_64.GOT64
GOTOFF64 = RELOCATION_X86_64.GOTOFF64
GOTPC32 = RELOCATION_X86_64.GOTPC32
GOTPC32_TLSDESC = RELOCATION_X86_64.GOTPC32_TLSDESC
GOTPC64 = RELOCATION_X86_64.GOTPC64
GOTPCREL = RELOCATION_X86_64.GOTPCREL
GOTPCREL64 = RELOCATION_X86_64.GOTPCREL64
GOTPCRELX = RELOCATION_X86_64.GOTPCRELX
GOTPLT64 = RELOCATION_X86_64.GOTPLT64
GOTTPOFF = RELOCATION_X86_64.GOTTPOFF
IRELATIVE = RELOCATION_X86_64.IRELATIVE
JUMP_SLOT = RELOCATION_X86_64.JUMP_SLOT
NONE = RELOCATION_X86_64.NONE
PC16 = RELOCATION_X86_64.PC16
PC32 = RELOCATION_X86_64.PC32
PC32_BND = RELOCATION_X86_64.PC32_BND
PC64 = RELOCATION_X86_64.PC64
PC8 = RELOCATION_X86_64.PC8
PLT32 = RELOCATION_X86_64.PLT32
PLT32_BND = RELOCATION_X86_64.PLT32_BND
PLTOFF64 = RELOCATION_X86_64.PLTOFF64
R16 = RELOCATION_X86_64.R16
R32 = RELOCATION_X86_64.R32
R32S = RELOCATION_X86_64.R32S
R64 = RELOCATION_X86_64.R64
R8 = RELOCATION_X86_64.R8
RELATIVE = RELOCATION_X86_64.RELATIVE
RELATIVE64 = RELOCATION_X86_64.RELATIVE64
REX_GOTPCRELX = RELOCATION_X86_64.REX_GOTPCRELX
SIZE32 = RELOCATION_X86_64.SIZE32
SIZE64 = RELOCATION_X86_64.SIZE64
TLSDESC = RELOCATION_X86_64.TLSDESC
TLSDESC_CALL = RELOCATION_X86_64.TLSDESC_CALL
TLSGD = RELOCATION_X86_64.TLSGD
TLSLD = RELOCATION_X86_64.TLSLD
TPOFF32 = RELOCATION_X86_64.TPOFF32
TPOFF64 = RELOCATION_X86_64.TPOFF64
property name

(self: handle) -> str


Relocations x86 (i386)

class lief.ELF.RELOCATION_i386(self: lief.ELF.RELOCATION_i386, arg0: int) → None

Members:

NONE

R32

PC32

GOT32

PLT32

COPY

GLOB_DAT

JUMP_SLOT

RELATIVE

GOTOFF

GOTPC

R32PLT

TLS_TPOFF

TLS_IE

TLS_GOTIE

TLS_LE

TLS_GD

TLS_LDM

R16

PC16

R8

PC8

TLS_GD_32

TLS_GD_PUSH

TLS_GD_CALL

TLS_GD_POP

TLS_LDM_32

TLS_LDM_PUSH

TLS_LDM_CALL

TLS_LDM_POP

TLS_LDO_32

TLS_IE_32

TLS_LE_32

TLS_DTPMOD32

TLS_DTPOFF32

TLS_TPOFF32

TLS_GOTDESC

TLS_DESC_CALL

TLS_DESC

IRELATIVE

NUM

COPY = RELOCATION_i386.COPY
GLOB_DAT = RELOCATION_i386.GLOB_DAT
GOT32 = RELOCATION_i386.GOT32
GOTOFF = RELOCATION_i386.GOTOFF
GOTPC = RELOCATION_i386.GOTPC
IRELATIVE = RELOCATION_i386.IRELATIVE
JUMP_SLOT = RELOCATION_i386.JUMP_SLOT
NONE = RELOCATION_i386.NONE
NUM = RELOCATION_i386.NUM
PC16 = RELOCATION_i386.PC16
PC32 = RELOCATION_i386.PC32
PC8 = RELOCATION_i386.PC8
PLT32 = RELOCATION_i386.PLT32
R16 = RELOCATION_i386.R16
R32 = RELOCATION_i386.R32
R32PLT = RELOCATION_i386.R32PLT
R8 = RELOCATION_i386.R8
RELATIVE = RELOCATION_i386.RELATIVE
TLS_DESC = RELOCATION_i386.TLS_DESC
TLS_DESC_CALL = RELOCATION_i386.TLS_DESC_CALL
TLS_DTPMOD32 = RELOCATION_i386.TLS_DTPMOD32
TLS_DTPOFF32 = RELOCATION_i386.TLS_DTPOFF32
TLS_GD = RELOCATION_i386.TLS_GD
TLS_GD_32 = RELOCATION_i386.TLS_GD_32
TLS_GD_CALL = RELOCATION_i386.TLS_GD_CALL
TLS_GD_POP = RELOCATION_i386.TLS_GD_POP
TLS_GD_PUSH = RELOCATION_i386.TLS_GD_PUSH
TLS_GOTDESC = RELOCATION_i386.TLS_GOTDESC
TLS_GOTIE = RELOCATION_i386.TLS_GOTIE
TLS_IE = RELOCATION_i386.TLS_IE
TLS_IE_32 = RELOCATION_i386.TLS_IE_32
TLS_LDM = RELOCATION_i386.TLS_LDM
TLS_LDM_32 = RELOCATION_i386.TLS_LDM_32
TLS_LDM_CALL = RELOCATION_i386.TLS_LDM_CALL
TLS_LDM_POP = RELOCATION_i386.TLS_LDM_POP
TLS_LDM_PUSH = RELOCATION_i386.TLS_LDM_PUSH
TLS_LDO_32 = RELOCATION_i386.TLS_LDO_32
TLS_LE = RELOCATION_i386.TLS_LE
TLS_LE_32 = RELOCATION_i386.TLS_LE_32
TLS_TPOFF = RELOCATION_i386.TLS_TPOFF
TLS_TPOFF32 = RELOCATION_i386.TLS_TPOFF32
property name

(self: handle) -> str


Relocations ARM

class lief.ELF.RELOCATION_ARM(self: lief.ELF.RELOCATION_ARM, arg0: int) → None

Members:

NONE

PC24

ABS32

REL32

LDR_PC_G0

ABS16

ABS12

THM_ABS5

ABS8

SBREL32

THM_CALL

THM_PC8

BREL_ADJ

TLS_DESC

THM_SWI8

XPC25

THM_XPC22

TLS_DTPMOD32

TLS_DTPOFF32

TLS_TPOFF32

COPY

GLOB_DAT

JUMP_SLOT

RELATIVE

GOTOFF32

BASE_PREL

GOT_BREL

PLT32

CALL

JUMP24

THM_JUMP24

BASE_ABS

ALU_PCREL_7_0

ALU_PCREL_15_8

ALU_PCREL_23_15

LDR_SBREL_11_0_NC

ALU_SBREL_19_12_NC

ALU_SBREL_27_20_CK

TARGET1

SBREL31

V4BX

TARGET2

PREL31

MOVW_ABS_NC

MOVT_ABS

MOVW_PREL_NC

MOVT_PREL

THM_MOVW_ABS_NC

THM_MOVT_ABS

THM_MOVW_PREL_NC

THM_MOVT_PREL

THM_JUMP19

THM_JUMP6

THM_ALU_PREL_11_0

THM_PC12

ABS32_NOI

REL32_NOI

ALU_PC_G0_NC

ALU_PC_G0

ALU_PC_G1_NC

ALU_PC_G1

ALU_PC_G2

LDR_PC_G1

LDR_PC_G2

LDRS_PC_G0

LDRS_PC_G1

LDRS_PC_G2

LDC_PC_G0

LDC_PC_G1

LDC_PC_G2

ALU_SB_G0_NC

ALU_SB_G0

ALU_SB_G1_NC

ALU_SB_G1

ALU_SB_G2

LDR_SB_G0

LDR_SB_G1

LDR_SB_G2

LDRS_SB_G0

LDRS_SB_G1

LDRS_SB_G2

LDC_SB_G0

LDC_SB_G1

LDC_SB_G2

MOVW_BREL_NC

MOVT_BREL

MOVW_BREL

THM_MOVW_BREL_NC

THM_MOVT_BREL

THM_MOVW_BREL

TLS_GOTDESC

TLS_CALL

TLS_DESCSEQ

THM_TLS_CALL

PLT32_ABS

GOT_ABS

GOT_PREL

GOT_BREL12

GOTOFF12

GOTRELAX

GNU_VTENTRY

GNU_VTINHERIT

THM_JUMP11

THM_JUMP8

TLS_GD32

TLS_LDM32

TLS_LDO32

TLS_IE32

TLS_LE32

TLS_LDO12

TLS_LE12

TLS_IE12GP

PRIVATE_0

PRIVATE_1

PRIVATE_2

PRIVATE_3

PRIVATE_4

PRIVATE_5

PRIVATE_6

PRIVATE_7

PRIVATE_8

PRIVATE_9

PRIVATE_10

PRIVATE_11

PRIVATE_12

PRIVATE_13

PRIVATE_14

PRIVATE_15

ME_TOO

THM_TLS_DESCSEQ16

THM_TLS_DESCSEQ32

IRELATIVE

RXPC25

RSBREL32

THM_RPC22

RREL32

RPC24

RBASE

ABS12 = RELOCATION_ARM.ABS12
ABS16 = RELOCATION_ARM.ABS16
ABS32 = RELOCATION_ARM.ABS32
ABS32_NOI = RELOCATION_ARM.ABS32_NOI
ABS8 = RELOCATION_ARM.ABS8
ALU_PCREL_15_8 = RELOCATION_ARM.ALU_PCREL_15_8
ALU_PCREL_23_15 = RELOCATION_ARM.ALU_PCREL_23_15
ALU_PCREL_7_0 = RELOCATION_ARM.ALU_PCREL_7_0
ALU_PC_G0 = RELOCATION_ARM.ALU_PC_G0
ALU_PC_G0_NC = RELOCATION_ARM.ALU_PC_G0_NC
ALU_PC_G1 = RELOCATION_ARM.ALU_PC_G1
ALU_PC_G1_NC = RELOCATION_ARM.ALU_PC_G1_NC
ALU_PC_G2 = RELOCATION_ARM.ALU_PC_G2
ALU_SBREL_19_12_NC = RELOCATION_ARM.ALU_SBREL_19_12_NC
ALU_SBREL_27_20_CK = RELOCATION_ARM.ALU_SBREL_27_20_CK
ALU_SB_G0 = RELOCATION_ARM.ALU_SB_G0
ALU_SB_G0_NC = RELOCATION_ARM.ALU_SB_G0_NC
ALU_SB_G1 = RELOCATION_ARM.ALU_SB_G1
ALU_SB_G1_NC = RELOCATION_ARM.ALU_SB_G1_NC
ALU_SB_G2 = RELOCATION_ARM.ALU_SB_G2
BASE_ABS = RELOCATION_ARM.BASE_ABS
BASE_PREL = RELOCATION_ARM.BASE_PREL
BREL_ADJ = RELOCATION_ARM.BREL_ADJ
CALL = RELOCATION_ARM.CALL
COPY = RELOCATION_ARM.COPY
GLOB_DAT = RELOCATION_ARM.GLOB_DAT
GNU_VTENTRY = RELOCATION_ARM.GNU_VTENTRY
GNU_VTINHERIT = RELOCATION_ARM.GNU_VTINHERIT
GOTOFF12 = RELOCATION_ARM.GOTOFF12
GOTOFF32 = RELOCATION_ARM.GOTOFF32
GOTRELAX = RELOCATION_ARM.GOTRELAX
GOT_ABS = RELOCATION_ARM.GOT_ABS
GOT_BREL = RELOCATION_ARM.GOT_BREL
GOT_BREL12 = RELOCATION_ARM.GOT_BREL12
GOT_PREL = RELOCATION_ARM.GOT_PREL
IRELATIVE = RELOCATION_ARM.IRELATIVE
JUMP24 = RELOCATION_ARM.JUMP24
JUMP_SLOT = RELOCATION_ARM.JUMP_SLOT
LDC_PC_G0 = RELOCATION_ARM.LDC_PC_G0
LDC_PC_G1 = RELOCATION_ARM.LDC_PC_G1
LDC_PC_G2 = RELOCATION_ARM.LDC_PC_G2
LDC_SB_G0 = RELOCATION_ARM.LDC_SB_G0
LDC_SB_G1 = RELOCATION_ARM.LDC_SB_G1
LDC_SB_G2 = RELOCATION_ARM.LDC_SB_G2
LDRS_PC_G0 = RELOCATION_ARM.LDRS_PC_G0
LDRS_PC_G1 = RELOCATION_ARM.LDRS_PC_G1
LDRS_PC_G2 = RELOCATION_ARM.LDRS_PC_G2
LDRS_SB_G0 = RELOCATION_ARM.LDRS_SB_G0
LDRS_SB_G1 = RELOCATION_ARM.LDRS_SB_G1
LDRS_SB_G2 = RELOCATION_ARM.LDRS_SB_G2
LDR_PC_G0 = RELOCATION_ARM.LDR_PC_G0
LDR_PC_G1 = RELOCATION_ARM.LDR_PC_G1
LDR_PC_G2 = RELOCATION_ARM.LDR_PC_G2
LDR_SBREL_11_0_NC = RELOCATION_ARM.LDR_SBREL_11_0_NC
LDR_SB_G0 = RELOCATION_ARM.LDR_SB_G0
LDR_SB_G1 = RELOCATION_ARM.LDR_SB_G1
LDR_SB_G2 = RELOCATION_ARM.LDR_SB_G2
ME_TOO = RELOCATION_ARM.ME_TOO
MOVT_ABS = RELOCATION_ARM.MOVT_ABS
MOVT_BREL = RELOCATION_ARM.MOVT_BREL
MOVT_PREL = RELOCATION_ARM.MOVT_PREL
MOVW_ABS_NC = RELOCATION_ARM.MOVW_ABS_NC
MOVW_BREL = RELOCATION_ARM.MOVW_BREL
MOVW_BREL_NC = RELOCATION_ARM.MOVW_BREL_NC
MOVW_PREL_NC = RELOCATION_ARM.MOVW_PREL_NC
NONE = RELOCATION_ARM.NONE
PC24 = RELOCATION_ARM.PC24
PLT32 = RELOCATION_ARM.PLT32
PLT32_ABS = RELOCATION_ARM.PLT32_ABS
PREL31 = RELOCATION_ARM.PREL31
PRIVATE_0 = RELOCATION_ARM.PRIVATE_0
PRIVATE_1 = RELOCATION_ARM.PRIVATE_1
PRIVATE_10 = RELOCATION_ARM.PRIVATE_10
PRIVATE_11 = RELOCATION_ARM.PRIVATE_11
PRIVATE_12 = RELOCATION_ARM.PRIVATE_12
PRIVATE_13 = RELOCATION_ARM.PRIVATE_13
PRIVATE_14 = RELOCATION_ARM.PRIVATE_14
PRIVATE_15 = RELOCATION_ARM.PRIVATE_15
PRIVATE_2 = RELOCATION_ARM.PRIVATE_2
PRIVATE_3 = RELOCATION_ARM.PRIVATE_3
PRIVATE_4 = RELOCATION_ARM.PRIVATE_4
PRIVATE_5 = RELOCATION_ARM.PRIVATE_5
PRIVATE_6 = RELOCATION_ARM.PRIVATE_6
PRIVATE_7 = RELOCATION_ARM.PRIVATE_7
PRIVATE_8 = RELOCATION_ARM.PRIVATE_8
PRIVATE_9 = RELOCATION_ARM.PRIVATE_9
RBASE = RELOCATION_ARM.RBASE
REL32 = RELOCATION_ARM.REL32
REL32_NOI = RELOCATION_ARM.REL32_NOI
RELATIVE = RELOCATION_ARM.RELATIVE
RPC24 = RELOCATION_ARM.RPC24
RREL32 = RELOCATION_ARM.RREL32
RSBREL32 = RELOCATION_ARM.RSBREL32
RXPC25 = RELOCATION_ARM.RXPC25
SBREL31 = RELOCATION_ARM.SBREL31
SBREL32 = RELOCATION_ARM.SBREL32
TARGET1 = RELOCATION_ARM.TARGET1
TARGET2 = RELOCATION_ARM.TARGET2
THM_ABS5 = RELOCATION_ARM.THM_ABS5
THM_ALU_PREL_11_0 = RELOCATION_ARM.THM_ALU_PREL_11_0
THM_CALL = RELOCATION_ARM.THM_CALL
THM_JUMP11 = RELOCATION_ARM.THM_JUMP11
THM_JUMP19 = RELOCATION_ARM.THM_JUMP19
THM_JUMP24 = RELOCATION_ARM.THM_JUMP24
THM_JUMP6 = RELOCATION_ARM.THM_JUMP6
THM_JUMP8 = RELOCATION_ARM.THM_JUMP8
THM_MOVT_ABS = RELOCATION_ARM.THM_MOVT_ABS
THM_MOVT_BREL = RELOCATION_ARM.THM_MOVT_BREL
THM_MOVT_PREL = RELOCATION_ARM.THM_MOVT_PREL
THM_MOVW_ABS_NC = RELOCATION_ARM.THM_MOVW_ABS_NC
THM_MOVW_BREL = RELOCATION_ARM.THM_MOVW_BREL
THM_MOVW_BREL_NC = RELOCATION_ARM.THM_MOVW_BREL_NC
THM_MOVW_PREL_NC = RELOCATION_ARM.THM_MOVW_PREL_NC
THM_PC12 = RELOCATION_ARM.THM_PC12
THM_PC8 = RELOCATION_ARM.THM_PC8
THM_RPC22 = RELOCATION_ARM.THM_RPC22
THM_SWI8 = RELOCATION_ARM.THM_SWI8
THM_TLS_CALL = RELOCATION_ARM.THM_TLS_CALL
THM_TLS_DESCSEQ16 = RELOCATION_ARM.THM_TLS_DESCSEQ16
THM_TLS_DESCSEQ32 = RELOCATION_ARM.THM_TLS_DESCSEQ32
THM_XPC22 = RELOCATION_ARM.THM_XPC22
TLS_CALL = RELOCATION_ARM.TLS_CALL
TLS_DESC = RELOCATION_ARM.TLS_DESC
TLS_DESCSEQ = RELOCATION_ARM.TLS_DESCSEQ
TLS_DTPMOD32 = RELOCATION_ARM.TLS_DTPMOD32
TLS_DTPOFF32 = RELOCATION_ARM.TLS_DTPOFF32
TLS_GD32 = RELOCATION_ARM.TLS_GD32
TLS_GOTDESC = RELOCATION_ARM.TLS_GOTDESC
TLS_IE12GP = RELOCATION_ARM.TLS_IE12GP
TLS_IE32 = RELOCATION_ARM.TLS_IE32
TLS_LDM32 = RELOCATION_ARM.TLS_LDM32
TLS_LDO12 = RELOCATION_ARM.TLS_LDO12
TLS_LDO32 = RELOCATION_ARM.TLS_LDO32
TLS_LE12 = RELOCATION_ARM.TLS_LE12
TLS_LE32 = RELOCATION_ARM.TLS_LE32
TLS_TPOFF32 = RELOCATION_ARM.TLS_TPOFF32
V4BX = RELOCATION_ARM.V4BX
XPC25 = RELOCATION_ARM.XPC25
property name

(self: handle) -> str


Relocations AARCH64

class lief.ELF.RELOCATION_AARCH64(self: lief.ELF.RELOCATION_AARCH64, arg0: int) → None

Members:

NONE

ABS64

ABS32

ABS16

PREL64

PREL32

PREL16

MOVW_UABS_G0

MOVW_UABS_G0_NC

MOVW_UABS_G1

MOVW_UABS_G1_NC

MOVW_UABS_G2

MOVW_UABS_G2_NC

MOVW_UABS_G3

MOVW_SABS_G0

MOVW_SABS_G1

MOVW_SABS_G2

LD_PREL_LO19

ADR_PREL_LO21

ADR_PREL_PG_HI21

ADR_PREL_PG_HI21_NC

ADD_ABS_LO12_NC

LDST8_ABS_LO12_NC

TSTBR14

CONDBR19

JUMP26

CALL26

LDST16_ABS_LO12_NC

LDST32_ABS_LO12_NC

LDST64_ABS_LO12_NC

MOVW_PREL_G0

MOVW_PREL_G0_NC

MOVW_PREL_G1

MOVW_PREL_G1_NC

MOVW_PREL_G2

MOVW_PREL_G2_NC

MOVW_PREL_G3

LDST128_ABS_LO12_NC

MOVW_GOTOFF_G0

MOVW_GOTOFF_G0_NC

MOVW_GOTOFF_G1

MOVW_GOTOFF_G1_NC

MOVW_GOTOFF_G2

MOVW_GOTOFF_G2_NC

MOVW_GOTOFF_G3

GOTREL64

GOTREL32

GOT_LD_PREL19

LD64_GOTOFF_LO15

ADR_GOT_PAGE

LD64_GOT_LO12_NC

LD64_GOTPAGE_LO15

TLSGD_ADR_PREL21

TLSGD_ADR_PAGE21

TLSGD_ADD_LO12_NC

TLSGD_MOVW_G1

TLSGD_MOVW_G0_NC

TLSLD_ADR_PREL21

TLSLD_ADR_PAGE21

TLSLD_ADD_LO12_NC

TLSLD_MOVW_G1

TLSLD_MOVW_G0_NC

TLSLD_LD_PREL19

TLSLD_MOVW_DTPREL_G2

TLSLD_MOVW_DTPREL_G1

TLSLD_MOVW_DTPREL_G1_NC

TLSLD_MOVW_DTPREL_G0

TLSLD_MOVW_DTPREL_G0_NC

TLSLD_ADD_DTPREL_HI12

TLSLD_ADD_DTPREL_LO12

TLSLD_ADD_DTPREL_LO12_NC

TLSLD_LDST8_DTPREL_LO12

TLSLD_LDST8_DTPREL_LO12_NC

TLSLD_LDST16_DTPREL_LO12

TLSLD_LDST16_DTPREL_LO12_NC

TLSLD_LDST32_DTPREL_LO12

TLSLD_LDST32_DTPREL_LO12_NC

TLSLD_LDST64_DTPREL_LO12

TLSLD_LDST64_DTPREL_LO12_NC

TLSIE_MOVW_GOTTPREL_G1

TLSIE_MOVW_GOTTPREL_G0_NC

TLSIE_ADR_GOTTPREL_PAGE21

TLSIE_LD64_GOTTPREL_LO12_NC

TLSIE_LD_GOTTPREL_PREL19

TLSLE_MOVW_TPREL_G2

TLSLE_MOVW_TPREL_G1

TLSLE_MOVW_TPREL_G1_NC

TLSLE_MOVW_TPREL_G0

TLSLE_MOVW_TPREL_G0_NC

TLSLE_ADD_TPREL_HI12

TLSLE_ADD_TPREL_LO12

TLSLE_ADD_TPREL_LO12_NC

TLSLE_LDST8_TPREL_LO12

TLSLE_LDST8_TPREL_LO12_NC

TLSLE_LDST16_TPREL_LO12

TLSLE_LDST16_TPREL_LO12_NC

TLSLE_LDST32_TPREL_LO12

TLSLE_LDST32_TPREL_LO12_NC

TLSLE_LDST64_TPREL_LO12

TLSLE_LDST64_TPREL_LO12_NC

TLSDESC_LD_PREL19

TLSDESC_ADR_PREL21

TLSDESC_ADR_PAGE21

TLSDESC_LD64_LO12_NC

TLSDESC_ADD_LO12_NC

TLSDESC_OFF_G1

TLSDESC_OFF_G0_NC

TLSDESC_LDR

TLSDESC_ADD

TLSDESC_CALL

TLSLE_LDST128_TPREL_LO12

TLSLE_LDST128_TPREL_LO12_NC

TLSLD_LDST128_DTPREL_LO12

TLSLD_LDST128_DTPREL_LO12_NC

COPY

GLOB_DAT

JUMP_SLOT

RELATIVE

TLS_DTPREL64

TLS_DTPMOD64

TLS_TPREL64

TLSDESC

IRELATIVE

ABS16 = RELOCATION_AARCH64.ABS16
ABS32 = RELOCATION_AARCH64.ABS32
ABS64 = RELOCATION_AARCH64.ABS64
ADD_ABS_LO12_NC = RELOCATION_AARCH64.ADD_ABS_LO12_NC
ADR_GOT_PAGE = RELOCATION_AARCH64.ADR_GOT_PAGE
ADR_PREL_LO21 = RELOCATION_AARCH64.ADR_PREL_LO21
ADR_PREL_PG_HI21 = RELOCATION_AARCH64.ADR_PREL_PG_HI21
ADR_PREL_PG_HI21_NC = RELOCATION_AARCH64.ADR_PREL_PG_HI21_NC
CALL26 = RELOCATION_AARCH64.CALL26
CONDBR19 = RELOCATION_AARCH64.CONDBR19
COPY = RELOCATION_AARCH64.COPY
GLOB_DAT = RELOCATION_AARCH64.GLOB_DAT
GOTREL32 = RELOCATION_AARCH64.GOTREL32
GOTREL64 = RELOCATION_AARCH64.GOTREL64
GOT_LD_PREL19 = RELOCATION_AARCH64.GOT_LD_PREL19
IRELATIVE = RELOCATION_AARCH64.IRELATIVE
JUMP26 = RELOCATION_AARCH64.JUMP26
JUMP_SLOT = RELOCATION_AARCH64.JUMP_SLOT
LD64_GOTOFF_LO15 = RELOCATION_AARCH64.LD64_GOTOFF_LO15
LD64_GOTPAGE_LO15 = RELOCATION_AARCH64.LD64_GOTPAGE_LO15
LD64_GOT_LO12_NC = RELOCATION_AARCH64.LD64_GOT_LO12_NC
LDST128_ABS_LO12_NC = RELOCATION_AARCH64.LDST128_ABS_LO12_NC
LDST16_ABS_LO12_NC = RELOCATION_AARCH64.LDST16_ABS_LO12_NC
LDST32_ABS_LO12_NC = RELOCATION_AARCH64.LDST32_ABS_LO12_NC
LDST64_ABS_LO12_NC = RELOCATION_AARCH64.LDST64_ABS_LO12_NC
LDST8_ABS_LO12_NC = RELOCATION_AARCH64.LDST8_ABS_LO12_NC
LD_PREL_LO19 = RELOCATION_AARCH64.LD_PREL_LO19
MOVW_GOTOFF_G0 = RELOCATION_AARCH64.MOVW_GOTOFF_G0
MOVW_GOTOFF_G0_NC = RELOCATION_AARCH64.MOVW_GOTOFF_G0_NC
MOVW_GOTOFF_G1 = RELOCATION_AARCH64.MOVW_GOTOFF_G1
MOVW_GOTOFF_G1_NC = RELOCATION_AARCH64.MOVW_GOTOFF_G1_NC
MOVW_GOTOFF_G2 = RELOCATION_AARCH64.MOVW_GOTOFF_G2
MOVW_GOTOFF_G2_NC = RELOCATION_AARCH64.MOVW_GOTOFF_G2_NC
MOVW_GOTOFF_G3 = RELOCATION_AARCH64.MOVW_GOTOFF_G3
MOVW_PREL_G0 = RELOCATION_AARCH64.MOVW_PREL_G0
MOVW_PREL_G0_NC = RELOCATION_AARCH64.MOVW_PREL_G0_NC
MOVW_PREL_G1 = RELOCATION_AARCH64.MOVW_PREL_G1
MOVW_PREL_G1_NC = RELOCATION_AARCH64.MOVW_PREL_G1_NC
MOVW_PREL_G2 = RELOCATION_AARCH64.MOVW_PREL_G2
MOVW_PREL_G2_NC = RELOCATION_AARCH64.MOVW_PREL_G2_NC
MOVW_PREL_G3 = RELOCATION_AARCH64.MOVW_PREL_G3
MOVW_SABS_G0 = RELOCATION_AARCH64.MOVW_SABS_G0
MOVW_SABS_G1 = RELOCATION_AARCH64.MOVW_SABS_G1
MOVW_SABS_G2 = RELOCATION_AARCH64.MOVW_SABS_G2
MOVW_UABS_G0 = RELOCATION_AARCH64.MOVW_UABS_G0
MOVW_UABS_G0_NC = RELOCATION_AARCH64.MOVW_UABS_G0_NC
MOVW_UABS_G1 = RELOCATION_AARCH64.MOVW_UABS_G1
MOVW_UABS_G1_NC = RELOCATION_AARCH64.MOVW_UABS_G1_NC
MOVW_UABS_G2 = RELOCATION_AARCH64.MOVW_UABS_G2
MOVW_UABS_G2_NC = RELOCATION_AARCH64.MOVW_UABS_G2_NC
MOVW_UABS_G3 = RELOCATION_AARCH64.MOVW_UABS_G3
NONE = RELOCATION_AARCH64.NONE
PREL16 = RELOCATION_AARCH64.PREL16
PREL32 = RELOCATION_AARCH64.PREL32
PREL64 = RELOCATION_AARCH64.PREL64
RELATIVE = RELOCATION_AARCH64.RELATIVE
TLSDESC = RELOCATION_AARCH64.TLSDESC
TLSDESC_ADD = RELOCATION_AARCH64.TLSDESC_ADD
TLSDESC_ADD_LO12_NC = RELOCATION_AARCH64.TLSDESC_ADD_LO12_NC
TLSDESC_ADR_PAGE21 = RELOCATION_AARCH64.TLSDESC_ADR_PAGE21
TLSDESC_ADR_PREL21 = RELOCATION_AARCH64.TLSDESC_ADR_PREL21
TLSDESC_CALL = RELOCATION_AARCH64.TLSDESC_CALL
TLSDESC_LD64_LO12_NC = RELOCATION_AARCH64.TLSDESC_LD64_LO12_NC
TLSDESC_LDR = RELOCATION_AARCH64.TLSDESC_LDR
TLSDESC_LD_PREL19 = RELOCATION_AARCH64.TLSDESC_LD_PREL19
TLSDESC_OFF_G0_NC = RELOCATION_AARCH64.TLSDESC_OFF_G0_NC
TLSDESC_OFF_G1 = RELOCATION_AARCH64.TLSDESC_OFF_G1
TLSGD_ADD_LO12_NC = RELOCATION_AARCH64.TLSGD_ADD_LO12_NC
TLSGD_ADR_PAGE21 = RELOCATION_AARCH64.TLSGD_ADR_PAGE21
TLSGD_ADR_PREL21 = RELOCATION_AARCH64.TLSGD_ADR_PREL21
TLSGD_MOVW_G0_NC = RELOCATION_AARCH64.TLSGD_MOVW_G0_NC
TLSGD_MOVW_G1 = RELOCATION_AARCH64.TLSGD_MOVW_G1
TLSIE_ADR_GOTTPREL_PAGE21 = RELOCATION_AARCH64.TLSIE_ADR_GOTTPREL_PAGE21
TLSIE_LD64_GOTTPREL_LO12_NC = RELOCATION_AARCH64.TLSIE_LD64_GOTTPREL_LO12_NC
TLSIE_LD_GOTTPREL_PREL19 = RELOCATION_AARCH64.TLSIE_LD_GOTTPREL_PREL19
TLSIE_MOVW_GOTTPREL_G0_NC = RELOCATION_AARCH64.TLSIE_MOVW_GOTTPREL_G0_NC
TLSIE_MOVW_GOTTPREL_G1 = RELOCATION_AARCH64.TLSIE_MOVW_GOTTPREL_G1
TLSLD_ADD_DTPREL_HI12 = RELOCATION_AARCH64.TLSLD_ADD_DTPREL_HI12
TLSLD_ADD_DTPREL_LO12 = RELOCATION_AARCH64.TLSLD_ADD_DTPREL_LO12
TLSLD_ADD_DTPREL_LO12_NC = RELOCATION_AARCH64.TLSLD_ADD_DTPREL_LO12_NC
TLSLD_ADD_LO12_NC = RELOCATION_AARCH64.TLSLD_ADD_LO12_NC
TLSLD_ADR_PAGE21 = RELOCATION_AARCH64.TLSLD_ADR_PAGE21
TLSLD_ADR_PREL21 = RELOCATION_AARCH64.TLSLD_ADR_PREL21
TLSLD_LDST128_DTPREL_LO12 = RELOCATION_AARCH64.TLSLD_LDST128_DTPREL_LO12
TLSLD_LDST128_DTPREL_LO12_NC = RELOCATION_AARCH64.TLSLD_LDST128_DTPREL_LO12_NC
TLSLD_LDST16_DTPREL_LO12 = RELOCATION_AARCH64.TLSLD_LDST16_DTPREL_LO12
TLSLD_LDST16_DTPREL_LO12_NC = RELOCATION_AARCH64.TLSLD_LDST16_DTPREL_LO12_NC
TLSLD_LDST32_DTPREL_LO12 = RELOCATION_AARCH64.TLSLD_LDST32_DTPREL_LO12
TLSLD_LDST32_DTPREL_LO12_NC = RELOCATION_AARCH64.TLSLD_LDST32_DTPREL_LO12_NC
TLSLD_LDST64_DTPREL_LO12 = RELOCATION_AARCH64.TLSLD_LDST64_DTPREL_LO12
TLSLD_LDST64_DTPREL_LO12_NC = RELOCATION_AARCH64.TLSLD_LDST64_DTPREL_LO12_NC
TLSLD_LDST8_DTPREL_LO12 = RELOCATION_AARCH64.TLSLD_LDST8_DTPREL_LO12
TLSLD_LDST8_DTPREL_LO12_NC = RELOCATION_AARCH64.TLSLD_LDST8_DTPREL_LO12_NC
TLSLD_LD_PREL19 = RELOCATION_AARCH64.TLSLD_LD_PREL19
TLSLD_MOVW_DTPREL_G0 = RELOCATION_AARCH64.TLSLD_MOVW_DTPREL_G0
TLSLD_MOVW_DTPREL_G0_NC = RELOCATION_AARCH64.TLSLD_MOVW_DTPREL_G0_NC
TLSLD_MOVW_DTPREL_G1 = RELOCATION_AARCH64.TLSLD_MOVW_DTPREL_G1
TLSLD_MOVW_DTPREL_G1_NC = RELOCATION_AARCH64.TLSLD_MOVW_DTPREL_G1_NC
TLSLD_MOVW_DTPREL_G2 = RELOCATION_AARCH64.TLSLD_MOVW_DTPREL_G2
TLSLD_MOVW_G0_NC = RELOCATION_AARCH64.TLSLD_MOVW_G0_NC
TLSLD_MOVW_G1 = RELOCATION_AARCH64.TLSLD_MOVW_G1
TLSLE_ADD_TPREL_HI12 = RELOCATION_AARCH64.TLSLE_ADD_TPREL_HI12
TLSLE_ADD_TPREL_LO12 = RELOCATION_AARCH64.TLSLE_ADD_TPREL_LO12
TLSLE_ADD_TPREL_LO12_NC = RELOCATION_AARCH64.TLSLE_ADD_TPREL_LO12_NC
TLSLE_LDST128_TPREL_LO12 = RELOCATION_AARCH64.TLSLE_LDST128_TPREL_LO12
TLSLE_LDST128_TPREL_LO12_NC = RELOCATION_AARCH64.TLSLE_LDST128_TPREL_LO12_NC
TLSLE_LDST16_TPREL_LO12 = RELOCATION_AARCH64.TLSLE_LDST16_TPREL_LO12
TLSLE_LDST16_TPREL_LO12_NC = RELOCATION_AARCH64.TLSLE_LDST16_TPREL_LO12_NC
TLSLE_LDST32_TPREL_LO12 = RELOCATION_AARCH64.TLSLE_LDST32_TPREL_LO12
TLSLE_LDST32_TPREL_LO12_NC = RELOCATION_AARCH64.TLSLE_LDST32_TPREL_LO12_NC
TLSLE_LDST64_TPREL_LO12 = RELOCATION_AARCH64.TLSLE_LDST64_TPREL_LO12
TLSLE_LDST64_TPREL_LO12_NC = RELOCATION_AARCH64.TLSLE_LDST64_TPREL_LO12_NC
TLSLE_LDST8_TPREL_LO12 = RELOCATION_AARCH64.TLSLE_LDST8_TPREL_LO12
TLSLE_LDST8_TPREL_LO12_NC = RELOCATION_AARCH64.TLSLE_LDST8_TPREL_LO12_NC
TLSLE_MOVW_TPREL_G0 = RELOCATION_AARCH64.TLSLE_MOVW_TPREL_G0
TLSLE_MOVW_TPREL_G0_NC = RELOCATION_AARCH64.TLSLE_MOVW_TPREL_G0_NC
TLSLE_MOVW_TPREL_G1 = RELOCATION_AARCH64.TLSLE_MOVW_TPREL_G1
TLSLE_MOVW_TPREL_G1_NC = RELOCATION_AARCH64.TLSLE_MOVW_TPREL_G1_NC
TLSLE_MOVW_TPREL_G2 = RELOCATION_AARCH64.TLSLE_MOVW_TPREL_G2
TLS_DTPMOD64 = RELOCATION_AARCH64.TLS_DTPMOD64
TLS_DTPREL64 = RELOCATION_AARCH64.TLS_DTPREL64
TLS_TPREL64 = RELOCATION_AARCH64.TLS_TPREL64
TSTBR14 = RELOCATION_AARCH64.TSTBR14
property name

(self: handle) -> str


Dynamic symbols counting

class lief.ELF.DYNSYM_COUNT_METHODS(self: lief.ELF.DYNSYM_COUNT_METHODS, arg0: int) → None

Members:

AUTO

SECTION

HASH

RELOCATIONS

AUTO = DYNSYM_COUNT_METHODS.AUTO
HASH = DYNSYM_COUNT_METHODS.HASH
RELOCATIONS = DYNSYM_COUNT_METHODS.RELOCATIONS
SECTION = DYNSYM_COUNT_METHODS.SECTION
property name

(self: handle) -> str


Relocation purpose

class lief.ELF.RELOCATION_PURPOSES(self: lief.ELF.RELOCATION_PURPOSES, arg0: int) → None

Members:

NONE

PLTGOT

DYNAMIC

OBJECT

DYNAMIC = RELOCATION_PURPOSES.DYNAMIC
NONE = RELOCATION_PURPOSES.NONE
OBJECT = RELOCATION_PURPOSES.OBJECT
PLTGOT = RELOCATION_PURPOSES.PLTGOT
property name

(self: handle) -> str


Note types

class lief.ELF.NOTE_TYPES(self: lief.ELF.NOTE_TYPES, arg0: int) → None

Members:

UNKNOWN

ABI_TAG

HWCAP

BUILD_ID

GOLD_VERSION

ABI_TAG = NOTE_TYPES.ABI_TAG
BUILD_ID = NOTE_TYPES.BUILD_ID
GOLD_VERSION = NOTE_TYPES.GOLD_VERSION
HWCAP = NOTE_TYPES.HWCAP
UNKNOWN = NOTE_TYPES.UNKNOWN
property name

(self: handle) -> str


Note ABIs

class lief.ELF.NOTE_ABIS(self: lief.ELF.NOTE_ABIS, arg0: int) → None

Members:

UNKNOWN

LINUX

GNU

SOLARIS2

FREEBSD

NETBSD

SYLLABLE

FREEBSD = NOTE_ABIS.FREEBSD
GNU = NOTE_ABIS.GNU
LINUX = NOTE_ABIS.LINUX
NETBSD = NOTE_ABIS.NETBSD
SOLARIS2 = NOTE_ABIS.SOLARIS2
SYLLABLE = NOTE_ABIS.SYLLABLE
UNKNOWN = NOTE_ABIS.UNKNOWN
property name

(self: handle) -> str


Note Core types

class lief.ELF.NOTE_TYPES_CORE(self: lief.ELF.NOTE_TYPES_CORE, arg0: int) → None

Members:

UNKNOWN

PRSTATUS

PRFPREG

PRPSINFO

TASKSTRUCT

AUXV

SIGINFO

FILE

ARM_VFP

ARM_TLS

ARM_HW_BREAK

ARM_HW_WATCH

ARM_SYSTEM_CALL

ARM_SVE

I386_TLS

I386_IOPERM

I386_XSTATE

ARM_HW_BREAK = NOTE_TYPES_CORE.ARM_HW_BREAK
ARM_HW_WATCH = NOTE_TYPES_CORE.ARM_HW_WATCH
ARM_SVE = NOTE_TYPES_CORE.ARM_SVE
ARM_SYSTEM_CALL = NOTE_TYPES_CORE.ARM_SYSTEM_CALL
ARM_TLS = NOTE_TYPES_CORE.ARM_TLS
ARM_VFP = NOTE_TYPES_CORE.ARM_VFP
AUXV = NOTE_TYPES_CORE.AUXV
FILE = NOTE_TYPES_CORE.FILE
I386_IOPERM = NOTE_TYPES_CORE.I386_IOPERM
I386_TLS = NOTE_TYPES_CORE.I386_TLS
I386_XSTATE = NOTE_TYPES_CORE.I386_XSTATE
PRFPREG = NOTE_TYPES_CORE.PRFPREG
PRPSINFO = NOTE_TYPES_CORE.PRPSINFO
PRSTATUS = NOTE_TYPES_CORE.PRSTATUS
SIGINFO = NOTE_TYPES_CORE.SIGINFO
TASKSTRUCT = NOTE_TYPES_CORE.TASKSTRUCT
UNKNOWN = NOTE_TYPES_CORE.UNKNOWN
property name

(self: handle) -> str


ARM Processor flags

class lief.ELF.ARM_EFLAGS(self: lief.ELF.ARM_EFLAGS, arg0: int) → None

Members:

SOFT_FLOAT

VFP_FLOAT

UNKNOWN

EABI_VER1

EABI_VER2

EABI_VER3

EABI_VER4

EABI_VER5

EABI_VER1 = ARM_EFLAGS.EABI_VER1
EABI_VER2 = ARM_EFLAGS.EABI_VER2
EABI_VER3 = ARM_EFLAGS.EABI_VER3
EABI_VER4 = ARM_EFLAGS.EABI_VER4
EABI_VER5 = ARM_EFLAGS.EABI_VER5
SOFT_FLOAT = ARM_EFLAGS.SOFT_FLOAT
UNKNOWN = ARM_EFLAGS.UNKNOWN
VFP_FLOAT = ARM_EFLAGS.VFP_FLOAT
property name

(self: handle) -> str


MIPS Processor flags

class lief.ELF.MIPS_EFLAGS(self: lief.ELF.MIPS_EFLAGS, arg0: int) → None

Members:

NOREORDER

PIC

CPIC

ABI2

_32BITMODE

FP64

NAN2008

ABI_O32

ABI_O64

ABI_EABI32

ABI_EABI64

MACH_3900

MACH_4010

MACH_4100

MACH_4650

MACH_4120

MACH_4111

MACH_SB1

MACH_OCTEON

MACH_XLR

MACH_OCTEON2

MACH_OCTEON3

MACH_5400

MACH_5900

MACH_5500

MACH_9000

MACH_LS2E

MACH_LS2F

MACH_LS3A

MICROMIPS

ARCH_ASE_M16

ARCH_ASE_MDMX

ARCH_1

ARCH_2

ARCH_3

ARCH_4

ARCH_5

ARCH_32

ARCH_64

ARCH_32R2

ARCH_64R2

ARCH_32R6

ARCH_64R6

ABI2 = MIPS_EFLAGS.ABI2
ABI_EABI32 = MIPS_EFLAGS.ABI_EABI32
ABI_EABI64 = MIPS_EFLAGS.ABI_EABI64
ABI_O32 = MIPS_EFLAGS.ABI_O32
ABI_O64 = MIPS_EFLAGS.ABI_O64
ARCH_1 = MIPS_EFLAGS.ARCH_1
ARCH_2 = MIPS_EFLAGS.ARCH_2
ARCH_3 = MIPS_EFLAGS.ARCH_3
ARCH_32 = MIPS_EFLAGS.ARCH_32
ARCH_32R2 = MIPS_EFLAGS.ARCH_32R2
ARCH_32R6 = MIPS_EFLAGS.ARCH_32R6
ARCH_4 = MIPS_EFLAGS.ARCH_4
ARCH_5 = MIPS_EFLAGS.ARCH_5
ARCH_64 = MIPS_EFLAGS.ARCH_64
ARCH_64R2 = MIPS_EFLAGS.ARCH_64R2
ARCH_64R6 = MIPS_EFLAGS.ARCH_64R6
ARCH_ASE_M16 = MIPS_EFLAGS.ARCH_ASE_M16
ARCH_ASE_MDMX = MIPS_EFLAGS.ARCH_ASE_MDMX
CPIC = MIPS_EFLAGS.CPIC
FP64 = MIPS_EFLAGS.FP64
MACH_3900 = MIPS_EFLAGS.MACH_3900
MACH_4010 = MIPS_EFLAGS.MACH_4010
MACH_4100 = MIPS_EFLAGS.MACH_4100
MACH_4111 = MIPS_EFLAGS.MACH_4111
MACH_4120 = MIPS_EFLAGS.MACH_4120
MACH_4650 = MIPS_EFLAGS.MACH_4650
MACH_5400 = MIPS_EFLAGS.MACH_5400
MACH_5500 = MIPS_EFLAGS.MACH_5500
MACH_5900 = MIPS_EFLAGS.MACH_5900
MACH_9000 = MIPS_EFLAGS.MACH_9000
MACH_LS2E = MIPS_EFLAGS.MACH_LS2E
MACH_LS2F = MIPS_EFLAGS.MACH_LS2F
MACH_LS3A = MIPS_EFLAGS.MACH_LS3A
MACH_OCTEON = MIPS_EFLAGS.MACH_OCTEON
MACH_OCTEON2 = MIPS_EFLAGS.MACH_OCTEON2
MACH_OCTEON3 = MIPS_EFLAGS.MACH_OCTEON3
MACH_SB1 = MIPS_EFLAGS.MACH_SB1
MACH_XLR = MIPS_EFLAGS.MACH_XLR
MICROMIPS = MIPS_EFLAGS.MICROMIPS
NAN2008 = MIPS_EFLAGS.NAN2008
NOREORDER = MIPS_EFLAGS.NOREORDER
PIC = MIPS_EFLAGS.PIC
property name

(self: handle) -> str


PPC64 Processor flags

class lief.ELF.PPC64_EFLAGS(self: lief.ELF.PPC64_EFLAGS, arg0: int) → None

Members:

ABI

ABI = PPC64_EFLAGS.ABI
property name

(self: handle) -> str


Hexagon Processor flags

class lief.ELF.HEXAGON_EFLAGS(self: lief.ELF.HEXAGON_EFLAGS, arg0: int) → None

Members:

MACH_V2

MACH_V3

MACH_V4

MACH_V5

ISA_MACH

ISA_V2

ISA_V3

ISA_V4

ISA_V5

ISA_MACH = HEXAGON_EFLAGS.ISA_MACH
ISA_V2 = HEXAGON_EFLAGS.ISA_V2
ISA_V3 = HEXAGON_EFLAGS.ISA_V3
ISA_V4 = HEXAGON_EFLAGS.ISA_V4
ISA_V5 = HEXAGON_EFLAGS.ISA_V5
MACH_V2 = HEXAGON_EFLAGS.MACH_V2
MACH_V3 = HEXAGON_EFLAGS.MACH_V3
MACH_V4 = HEXAGON_EFLAGS.MACH_V4
MACH_V5 = HEXAGON_EFLAGS.MACH_V5
property name

(self: handle) -> str