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: 0>) -> LIEF::ELF::Binary

    Parse the ELF binary from the given file path and return a lief.ELF.Binary object

    For weird binaries (e.g sectionless) you can choose the method to use to count dynamic symbols (lief.ELF.DYNSYM_COUNT_METHODS). By default, the value is set to lief.ELF.DYNSYM_COUNT_METHODS.COUNT_AUTO

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

    Parse the ELF binary from the given list of bytes and return a lief.ELF.Binary object

    For weird binaries (e.g sectionless) you can choose the method to use to count dynamic symbols (lief.ELF.DYNSYM_COUNT_METHODS). By default, the value is set to lief.ELF.DYNSYM_COUNT_METHODS.COUNT_AUTO

  3. parse(io: object, name: str = ‘’, dynsym_count_method: lief.ELF.DYNSYM_COUNT_METHODS = <DYNSYM_COUNT_METHODS.AUTO: 0>) -> LIEF::ELF::Binary

    Parse the ELF binary from a Python IO stream and return a lief.ELF.Binary object

    For weird binaries (e.g sectionless) you can choose the method to use to count dynamic symbols (lief.ELF.lief.ELF.DYNSYM_COUNT_METHODS). By default, the value is set to lief.ELF.lief.ELF.DYNSYM_COUNT_METHODS.COUNT_AUTO


Binary

class lief.ELF.Binary

Class which represents an ELF binary

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

Members:

AUTO

VA

RVA

AUTO = <VA_TYPES.AUTO: 0>
RVA = <VA_TYPES.RVA: 1>
VA = <VA_TYPES.VA: 2>
property name
property value
property abstract

Return the abstract representation of the current binary (lief.Binary)

Warning

Getting this property modifies the __class__ attribute such as the current binary looks like a lief.Binary.

To get back to the original binary, one needs to access lief.Binary.concrete

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 does not aim at being loaded in memory, the loaded parameter has to be set to False (default: True)

  2. add(self: lief.ELF.Binary, Add a new Segment in the binarysegment: LIEF::ELF::Segment, base: int = 0) -> LIEF::ELF::Segment

  3. 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, relocation: LIEF::ELF::Relocation) LIEF::ELF::Relocation

Add a new dynamic relocation.

We consider a dynamic relocation as a relocation which is not plt-related.

See: lief.ELF.Binary.add_pltgot_relocation()

add_dynamic_symbol(self: lief.ELF.Binary, symbol: LIEF::ELF::Symbol, symbol_version: lief.ELF.SymbolVersion = None) LIEF::ELF::Symbol

Add a dynamic Symbol to the binary

The function also takes an optional lief.ELF.SymbolVersion

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 create an export

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

Add a library with the given name as dependency

add_object_relocation(self: lief.ELF.Binary, relocation: LIEF::ELF::Relocation, section: LIEF::ELF::Section) LIEF::ELF::Relocation

Add relocation for object file (.o)

The first parameter is the section to add while the second parameter is the Section associated with the relocation.

If there is an error, this function returns a nullptr. Otherwise, it returns the relocation added.”,

add_pltgot_relocation(self: lief.ELF.Binary, relocation: LIEF::ELF::Relocation) LIEF::ELF::Relocation

Add a .plt.got relocation. This kind of relocation is usually associated with a PLT stub that aims at resolving the underlying symbol.

See: lief.ELF.Binary.add_dynamic_relocation()

add_static_symbol(self: lief.ELF.Binary, symbol: LIEF::ELF::Symbol) LIEF::ELF::Symbol

Add a static Symbol to the binary

property concrete

The concrete representation of the binary. Basically, this property cast a lief.Binary into a lief.PE.Binary, lief.ELF.Binary or lief.MachO.Binary.

See also: lief.Binary.abstract

property ctor_functions

Constructor functions that are called prior to any other functions

property dtor_functions

List of the binary destructors (typically, the functions located in the .fini_array)

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

Return the last offset used by the ELF binary according to both: the sections table and the segments table.

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 an entry 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 an entry if it doesn’t exist

property exported_functions

Return the 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

List of the functions found the in the binary

get(*args, **kwargs)

Overloaded function.

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

    Return the first binary’s DynamicEntry from the given DYNAMIC_TAGS.

    It returns None if the dynamic entry can’t be found.

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

    Return the first binary’s Segment from the given SEGMENT_TYPES

    It returns None if the segment can’t be found.

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

    Return the first binary’s Note from the given NOTE_TYPES.

    It returns None if the note can’t be found.

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

    Return the first binary’s Section from the given ELF_SECTION_TYPES

    It returns None if the section can’t be found.

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

Return the content located at the provided virtual address. The 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.

It returns None if it can’t be found.

get_function_address(self: lief.Binary, function_name: str) object

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

It returns None if the library can’t be found.

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

It returns None if the section can’t be found.

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

Get the static symbol from the given name.

It returns None if it can’t be found.

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 from the given name.

If the symbol can’t be found, it returns None.

property gnu_hash

Return the GnuHash object

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

has(*args, **kwargs)

Overloaded function.

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

    Check if it exists a DynamicEntry with the given DYNAMIC_TAGS

  2. 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

Check if the binary uses a loader (also named linker or interpreter)

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 has NX protection (non executable stack)

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 encompasses the given offset exists

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

Check if a Section that encompasses 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 the binary’s imported Function (name)

property imported_symbols

Return dynamic Symbol which are imported

property interpreter

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

property is_pie

Check if the binary has been compiled with -fpie -pie flags

To do so we check if there is a PT_INTERP segment and if the binary type is ET_DYN (Shared object)

class it_dyn_static_symbols
class it_dynamic_entries
class it_filter_relocation
class it_filter_symbols
class it_notes
class it_relocations
class it_sections
class it_segments
class it_symbols
class it_symbols_version
class it_symbols_version_definition
class it_symbols_version_requirement
property last_offset_section

Return the last offset used in binary according to sections table

property last_offset_segment

Return the last offset used in binary according to segments table

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 over the Note entries

property object_relocations

Return an iterator over object Relocation

offset_to_virtual_address(self: lief.Binary, offset: int, slide: int = 0) object

Convert an offset into a virtual address.

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: 0>) -> None

    Patch the address with the given list of bytes. The 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.

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

    Patch the address with the given integer value. The virtual address is specified in the first argument, the integer in the second and the integer’s size of 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

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 the DynamicEntry with the given DYNAMIC_TAGS

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

Remove the given Section. The clear parameter specifies 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 the Note with the given NOTE_TYPES

remove_dynamic_symbol(*args, **kwargs)

Overloaded function.

  1. remove_dynamic_symbol(self: lief.ELF.Binary, arg0: LIEF::ELF::Symbol) -> None

Remove the given Symbol from the .dynsym section

  1. remove_dynamic_symbol(self: lief.ELF.Binary, arg0: str) -> None

Remove the Symbol with the name given in parameter from the .dynsym section

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 from 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 parameter and return the updated segment.

Warning

The original_segment is no longer valid after this function

section_from_offset(self: lief.ELF.Binary, offset: int, skip_nobits: bool = True) LIEF::ELF::Section

Return the Section which encompasses the given offset. It returns None if a section can’t be found.

If skip_nobits is set (which is the case by default), this function won’t consider sections for which the type is SHT_NOBITS (like .bss, .tbss, ...)

section_from_virtual_address(self: lief.ELF.Binary, address: int, skip_nobits: bool = True) LIEF::ELF::Section

Return the Section which encompasses the given virtual address. It returns None if a section can’t be found.

If skip_nobits is set (which is the case by default), this function won’t consider sections for which the type is SHT_NOBITS (like .bss, .tbss, ...)

property sections

Return an iterator over binary’s Section

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

Return the Segment which encompasses the given offset. It returns None if a segment can’t be found.

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

Return the Segment which encompasses the given virtual address. It returns None if a segment can’t be found.

property segments

Return an iterator 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 this function looks 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 resolution (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) object

Convert the virtual address to a file offset

property virtual_size

Return the size of the mapped binary

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

Rebuild the binary and write it in a file

xref(self: lief.Binary, virtual_address: int) List[int]

Return all virtual addresses that use the address given in parameter



Section

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

Class which represents an ELF section.

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: 1>) -> None

Constructor from a name and a section 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

as_frame(self: lief.ELF.Section) lief.ELF.Section
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

This property returns the size of an element in the case of a section that contains an array.

Example

The .dynamic section contains an array of DynamicEntry. As the size of the raw C structure of this entry is 0x10 (sizeof(Elf64_Dyn)) in a ELF64, the entry_size, is set to this value.

property file_offset

Offset of the section’s content

property flags

Return the section’s flags as an integer

property flags_list

Return section’s flags as a list of SECTION_FLAGS

property fullname

Return the fullname of the section including the trailing bytes

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)

property is_frame
class it_segments

Index to another section

property name

Section’s name

property offset

Section’s file offset

property original_size

Original size of the section’s data.

This value is used by the Builder to determine if it needs to be relocated to avoid an override of the data

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

Remove the given SECTION_FLAGS from 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 the SECTION_TYPES

property virtual_address

Section’s virtual address


Segment

class lief.ELF.Segment(self: lief.ELF.Segment) None

Class which represents the ELF segments

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

Add the given SEGMENT_FLAGS to the list of flags

property alignment

The offset alignment of the segment

property content

The raw data associated with this segment.

property file_offset

The file offset of the data associated with this segment

property flags

The flag permissions associated with this segment

static from_raw(arg0: bytes) object
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

class it_sections
property physical_address

The physical address of the segment. This value is not really relevant on systems like Linux or Android. On the other hand, Qualcomm trustlets might use this value.

Usually this value matches virtual_address

property physical_size

The file size of the data associated with this segment

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

Remove the given SEGMENT_FLAGS from the list of flags

property sections

Iterator over the Section wrapped by this segment

property type

Segment’s type: SEGMENT_TYPES

property virtual_address

The virtual address of the segment.

Warning

The ELF format specifications require the following relationship:

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

The in-memory size of this segment.

Usually, if the .bss segment is wrapped by this segment then, virtual_size is larger than physical_size


Dynamic Entry

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

Class which represents an entry in the dynamic table These entries are located in the .dynamic section or the PT_DYNAMIC segment

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 from a DYNAMIC_TAGS and value

property tag

Return the entry’s DYNAMIC_TAGS which represent the entry type

property value

Return the entry’s value

The meaning of the value strongly depends on the tag. It can be an offset, an index, a flag, …


Dynamic Entry Library

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

Class which represents a DT_NEEDED entry in the dynamic table.

This kind of entry is usually used to create library dependency.

Constructor from a library name

property name

Library associated with this entry (e.g. libc.so.6)

property tag

Return the entry’s DYNAMIC_TAGS which represent the entry type

property value

Return the entry’s value

The meaning of the value strongly depends on the tag. It can be an offset, an index, a flag, …


Dynamic Shared Object

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

Class which represents a DT_SONAME entry in the dynamic table This kind of entry is usually used no name the original library.

This entry is not present for executable.

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

The meaning of the value strongly depends on the tag. It can be an offset, an index, a flag, …


Dynamic Entry Run Path

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

Class that represents a DT_RUNPATH wich is used by the loader to resolve libraries (DynamicEntryLibrary).

Overloaded function.

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

Constructor from a (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

The meaning of the value strongly depends on the tag. It can be an offset, an index, a flag, …


Dynamic Entry RPath

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

Class which represents a DT_RPATH entry. This attribute is deprecated (cf. man ld) in favour of DT_RUNPATH (See DynamicRunPath)

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

The actual rpath as a string

property paths

Paths as a list

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

Remove the given path

property rpath

The actual rpath as a string

property tag

Return the entry’s DYNAMIC_TAGS which represent the entry type

property value

Return the entry’s value

The meaning of the value strongly depends on the tag. It can be an offset, an index, a flag, …


Dynamic Entry Array

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

Class that represent an Array in the dynamic table. This entry is associated with constructors: - DT_PREINIT_ARRAY - DT_INIT_ARRAY - DT_FINI_ARRAY

The underlying values are 64-bits integers to cover both: ELF32 and ELF64 binaries.

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, function: int) lief.ELF.DynamicEntryArray

Append the given function

property array

Return the array as a list of intergers

insert(self: lief.ELF.DynamicEntryArray, pos: int, function: int) lief.ELF.DynamicEntryArray

Insert the given function at pos

remove(self: lief.ELF.DynamicEntryArray, function: int) lief.ELF.DynamicEntryArray

Remove the given function

property tag

Return the entry’s DYNAMIC_TAGS which represent the entry type

property value

Return the entry’s value

The meaning of the value strongly depends on the tag. It can be an offset, an index, a flag, …


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)

has(*args, **kwargs)

Overloaded function.

  1. has(self: lief.ELF.DynamicEntryFlags, flag: lief.ELF.DYNAMIC_FLAGS) -> bool

Check if this entry contains the given DYNAMIC_FLAGS

  1. has(self: lief.ELF.DynamicEntryFlags, flag: lief.ELF.DYNAMIC_FLAGS_1) -> bool

Check if this entry contains the given DYNAMIC_FLAGS_1

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

The meaning of the value strongly depends on the tag. It can be an offset, an index, a flag, …


Relocations

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

Class that represents an ELF relocation.

Overloaded function.

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

  2. __init__(self: lief.ELF.Relocation, arch: lief.ELF.ARCH) -> None

  3. __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 this relocation has a lief.ELF.Section associated with.

This is usually the case for object files (.o)

property has_symbol

True if a Symbol is associated with the relocation

property info

Extra information like the 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 of the relocation (RELOCATION_PURPOSES).

This value provides the information about how the relocation is used (PLT/GOT resolution, .o file, …)

property section

Section in which the relocation is applied or None if not relevant

property size

Relocation’s size (in bits)

property symbol

Symbol associated with the relocation or None if no symbol are associated with this relocation.

property type

Relocation type. This value depends on the underlying architecture.

See:

Symbol

class lief.ELF.Symbol(self: lief.ELF.Symbol) None

“Class which represents an ELF symbol”

property binding

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

property demangled_name

Symbol’s name demangled or an empty string if the demangling is not possible/failed

property exported

Whether the symbol is exported

property has_version

Check if this symbols has a SymbolVersion

property imported

Whether the symbol is imported

property information

This property 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 (i.e. from the .symtab section

property is_variable

True if the symbol is a variable

property name

Symbol’s name

property other

Alias for: 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

It returns None if no version is tied to this symbol.

property type

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

property value

This member has different menaing depending on the symbol’s type and the type of the ELF file (library, object, …)

  • In relocatable files, this property contains the alignment constraints of the symbol for which the section index is SHN_COMMON.

  • In relocatable files, can also contain a section’s offset for a defined symbol. That is, value is an offset from the beginning of the section associated with this symbol.

  • In executable and libraries, this property contains a virtual address.

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 or None if not present.

The value can be changed by assigning a SymbolVersionAuxRequirement which must already exist in the SymbolVersionRequirement. Once can use add_aux_requirement() to add a new SymbolVersionAuxRequirement.

property value

Value associated with the symbol.

If the given SymbolVersion hasn’t Auxiliary version:

  • 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 represents an Auxiliary Symbol version

property name

Symbol’s name (e.g. GLIBC_2.2.5)


Symbol Version Definition

class lief.ELF.SymbolVersionDefinition

Class which represents an entry defined in DT_VERDEF or .gnu.version_d

property auxiliary_symbols
property flags

Version information

property hash

Hash value of the symbol’s name (using ELF hash function)

class it_version_aux
property version

Version revision. Should be 1

This field should always have the value 1. It will be changed if the versioning implementation has to be changed in an incompatible way.


Symbol Version Requirement

class lief.ELF.SymbolVersionRequirement

Class which represents an entry in the DT_VERNEED or .gnu.version_r table

add_auxiliary_requirement(self: lief.ELF.SymbolVersionRequirement, arg0: lief.ELF.SymbolVersionAuxRequirement) lief.ELF.SymbolVersionAuxRequirement

Add an auxiliary version requirement to the existing entries

get_auxiliary_symbols(self: lief.ELF.SymbolVersionRequirement) lief.ELF.SymbolVersionRequirement.it_aux_requirement

Auxiliary entries (iterator over SymbolVersionAuxRequirement)

class it_aux_requirement
property name

Library’s name associated with this requirement (e.g. libc.so.6)

property version

Version revision. Should be 1


Symbol Version Auxiliary Requirement

class lief.ELF.SymbolVersionAuxRequirement(self: lief.ELF.SymbolVersionAuxRequirement) None

Default constructor

property flags

Bitmask of flags

property hash

Hash value of the dependency name (use ELF hashing function)

property name

Symbol’s name (e.g. GLIBC_2.2.5)

property other

It returns the unique version index for the file which is used in the version symbol table. If the highest bit (bit 15) is set this is a hidden symbol which cannot be referenced from outside the object.


GNU Hash table

class lief.ELF.GnuHash(self: lief.ELF.GnuHash) None

Class which provides a view over the GNU Hash implementation. Most of the fields are read-only since the values are re-computed by the lief.ELF.Builder.

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

Class which represents the SYSV hash for the symbols resolution

References:

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)

Class which represents an ELF note.

Overloaded function.

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

Default constructor

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

Constructor from a 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 current note is specific to Android.

If true, lief.Note.details returns a reference to the AndroidNote object

property is_core

True if the note is associated with a coredump

property name

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

property size

Size of the raw note

property type

Return the type of the note. It can be one of the NOTE_TYPES values

property type_core

Return the type of the note for ELF Core (ET_CORE). It 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, value: 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: 95>
AARCH64_X0 = <REGISTERS.AARCH64_X0: 63>
AARCH64_X1 = <REGISTERS.AARCH64_X1: 64>
AARCH64_X10 = <REGISTERS.AARCH64_X10: 73>
AARCH64_X11 = <REGISTERS.AARCH64_X11: 74>
AARCH64_X12 = <REGISTERS.AARCH64_X12: 75>
AARCH64_X13 = <REGISTERS.AARCH64_X13: 76>
AARCH64_X14 = <REGISTERS.AARCH64_X14: 77>
AARCH64_X15 = <REGISTERS.AARCH64_X15: 78>
AARCH64_X16 = <REGISTERS.AARCH64_X16: 79>
AARCH64_X17 = <REGISTERS.AARCH64_X17: 80>
AARCH64_X18 = <REGISTERS.AARCH64_X18: 81>
AARCH64_X19 = <REGISTERS.AARCH64_X19: 82>
AARCH64_X2 = <REGISTERS.AARCH64_X2: 65>
AARCH64_X20 = <REGISTERS.AARCH64_X20: 83>
AARCH64_X21 = <REGISTERS.AARCH64_X21: 84>
AARCH64_X22 = <REGISTERS.AARCH64_X22: 85>
AARCH64_X23 = <REGISTERS.AARCH64_X23: 86>
AARCH64_X24 = <REGISTERS.AARCH64_X24: 87>
AARCH64_X25 = <REGISTERS.AARCH64_X25: 88>
AARCH64_X26 = <REGISTERS.AARCH64_X26: 89>
AARCH64_X27 = <REGISTERS.AARCH64_X27: 90>
AARCH64_X28 = <REGISTERS.AARCH64_X28: 91>
AARCH64_X29 = <REGISTERS.AARCH64_X29: 92>
AARCH64_X3 = <REGISTERS.AARCH64_X3: 66>
AARCH64_X30 = <REGISTERS.AARCH64_X30: 93>
AARCH64_X31 = <REGISTERS.AARCH64_X31: 94>
AARCH64_X4 = <REGISTERS.AARCH64_X4: 67>
AARCH64_X5 = <REGISTERS.AARCH64_X5: 68>
AARCH64_X6 = <REGISTERS.AARCH64_X6: 69>
AARCH64_X7 = <REGISTERS.AARCH64_X7: 70>
AARCH64_X8 = <REGISTERS.AARCH64_X8: 71>
AARCH64_X9 = <REGISTERS.AARCH64_X9: 72>
AARCH64__ = <REGISTERS.AARCH64__: 96>
ARM_CPSR = <REGISTERS.ARM_CPSR: 60>
ARM_R0 = <REGISTERS.ARM_R0: 44>
ARM_R1 = <REGISTERS.ARM_R1: 45>
ARM_R10 = <REGISTERS.ARM_R10: 54>
ARM_R11 = <REGISTERS.ARM_R11: 55>
ARM_R12 = <REGISTERS.ARM_R12: 56>
ARM_R13 = <REGISTERS.ARM_R13: 57>
ARM_R14 = <REGISTERS.ARM_R14: 58>
ARM_R15 = <REGISTERS.ARM_R15: 59>
ARM_R2 = <REGISTERS.ARM_R2: 46>
ARM_R3 = <REGISTERS.ARM_R3: 47>
ARM_R4 = <REGISTERS.ARM_R4: 48>
ARM_R5 = <REGISTERS.ARM_R5: 49>
ARM_R6 = <REGISTERS.ARM_R6: 50>
ARM_R7 = <REGISTERS.ARM_R7: 51>
ARM_R8 = <REGISTERS.ARM_R8: 52>
ARM_R9 = <REGISTERS.ARM_R9: 53>
UNKNOWN = <REGISTERS.UNKNOWN: 0>
X86_64_CS = <REGISTERS.X86_64_CS: 38>
X86_64_EFLAGS = <REGISTERS.X86_64_EFLAGS: 39>
X86_64_R10 = <REGISTERS.X86_64_R10: 28>
X86_64_R11 = <REGISTERS.X86_64_R11: 27>
X86_64_R12 = <REGISTERS.X86_64_R12: 24>
X86_64_R13 = <REGISTERS.X86_64_R13: 23>
X86_64_R14 = <REGISTERS.X86_64_R14: 22>
X86_64_R15 = <REGISTERS.X86_64_R15: 21>
X86_64_R8 = <REGISTERS.X86_64_R8: 30>
X86_64_R9 = <REGISTERS.X86_64_R9: 29>
X86_64_RAX = <REGISTERS.X86_64_RAX: 31>
X86_64_RBP = <REGISTERS.X86_64_RBP: 25>
X86_64_RBX = <REGISTERS.X86_64_RBX: 26>
X86_64_RCX = <REGISTERS.X86_64_RCX: 32>
X86_64_RDI = <REGISTERS.X86_64_RDI: 35>
X86_64_RDX = <REGISTERS.X86_64_RDX: 33>
X86_64_RIP = <REGISTERS.X86_64_RIP: 37>
X86_64_RSI = <REGISTERS.X86_64_RSI: 34>
X86_64_RSP = <REGISTERS.X86_64_RSP: 40>
X86_64_SS = <REGISTERS.X86_64_SS: 41>
X86_64__ = <REGISTERS.X86_64__: 36>
X86_CS = <REGISTERS.X86_CS: 15>
X86_DS = <REGISTERS.X86_DS: 9>
X86_EAX = <REGISTERS.X86_EAX: 8>
X86_EBP = <REGISTERS.X86_EBP: 7>
X86_EBX = <REGISTERS.X86_EBX: 2>
X86_ECX = <REGISTERS.X86_ECX: 3>
X86_EDI = <REGISTERS.X86_EDI: 6>
X86_EDX = <REGISTERS.X86_EDX: 4>
X86_EFLAGS = <REGISTERS.X86_EFLAGS: 16>
X86_EIP = <REGISTERS.X86_EIP: 14>
X86_ES = <REGISTERS.X86_ES: 10>
X86_ESI = <REGISTERS.X86_ESI: 5>
X86_ESP = <REGISTERS.X86_ESP: 17>
X86_FS = <REGISTERS.X86_FS: 11>
X86_GS = <REGISTERS.X86_GS: 12>
X86_SS = <REGISTERS.X86_SS: 18>
X86__ = <REGISTERS.X86__: 13>
property name
property value
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 dictionary where the 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, value: 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: 7>
BASE_PLATFORM = <TYPES.BASE_PLATFORM: 24>
CKLTCK = <TYPES.CKLTCK: 17>
DCACHEBSIZE = <TYPES.DCACHEBSIZE: 19>
EGID = <TYPES.EGID: 14>
ENTRY = <TYPES.ENTRY: 9>
EUID = <TYPES.EUID: 12>
EXECFD = <TYPES.EXECFD: 2>
EXECFN = <TYPES.EXECFN: 31>
FLAGS = <TYPES.FLAGS: 8>
FPUCW = <TYPES.FPUCW: 18>
GID = <TYPES.GID: 13>
HWCAP = <TYPES.HWCAP: 16>
HWCAP2 = <TYPES.HWCAP2: 26>
ICACHEBSIZE = <TYPES.ICACHEBSIZE: 20>
IGNORE = <TYPES.IGNORE: 1>
IGNOREPPC = <TYPES.IGNOREPPC: 22>
L1D_CACHESHAPE = <TYPES.L1D_CACHESHAPE: 35>
L1I_CACHESHAPE = <TYPES.L1I_CACHESHAPE: 34>
NOTELF = <TYPES.NOTELF: 10>
NULL = <TYPES.NULL: 0>
PAGESZ = <TYPES.PAGESZ: 6>
PHDR = <TYPES.PHDR: 3>
PHENT = <TYPES.PHENT: 4>
PHNUM = <TYPES.PHNUM: 5>
PLATFORM = <TYPES.PLATFORM: 15>
RANDOM = <TYPES.RANDOM: 25>
SECURE = <TYPES.SECURE: 23>
SYSINFO = <TYPES.SYSINFO: 32>
SYSINFO_EHDR = <TYPES.SYSINFO_EHDR: 33>
UCACHEBSIZE = <TYPES.UCACHEBSIZE: 21>
UID = <TYPES.UID: 11>
property name
property value
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 for which 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

Class which takes an lief.ELF.Binary object and reconstructs a valid binary

Constructor that takes a Binary

build(self: lief.ELF.Builder) None

Perform the build of the provided ELF binary

property config

Tweak the ELF builder with the provided config parameter

class config_t(self: lief.ELF.Builder.config_t) None

Interface to tweak the Builder

property dt_hash
property dyn_str
property dynamic_section
property fini_array
property force_relocate

Force to relocate all the ELF structures that can be relocated (mostly for testing)

property init_array
property interpreter
property jmprel
property notes
property preinit_array
property rela
property static_symtab
property sym_verdef
property sym_verneed
property sym_versym
property symtab
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, value: int) None

Members:

MAG0

MAG1

MAG2

MAG3

CLASS

DATA

VERSION

OSABI

ABIVERSION

PAD

NIDENT

ABIVERSION = <IDENTITY.ABIVERSION: 8>
CLASS = <IDENTITY.CLASS: 4>
DATA = <IDENTITY.DATA: 5>
MAG0 = <IDENTITY.MAG0: 0>
MAG1 = <IDENTITY.MAG1: 1>
MAG2 = <IDENTITY.MAG2: 2>
MAG3 = <IDENTITY.MAG3: 3>
NIDENT = <IDENTITY.NIDENT: 16>
OSABI = <IDENTITY.OSABI: 7>
PAD = <IDENTITY.PAD: 9>
VERSION = <IDENTITY.VERSION: 6>
property name
property value

ELF Class

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

Members:

NONE

CLASS32

CLASS64

CLASS32 = <ELF_CLASS.CLASS32: 1>
CLASS64 = <ELF_CLASS.CLASS64: 2>
NONE = <ELF_CLASS.NONE: 0>
property name
property value

ELF Data

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

Members:

NONE

LSB

MSB

LSB = <ELF_DATA.LSB: 1>
MSB = <ELF_DATA.MSB: 2>
NONE = <ELF_DATA.NONE: 0>
property name
property value

ELF OS/ABI

class lief.ELF.OS_ABI(self: lief.ELF.OS_ABI, value: 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: 7>
AMDGPU_HSA = <OS_ABI.AMDGPU_HSA: 64>
ARM = <OS_ABI.ARM: 97>
AROS = <OS_ABI.AROS: 15>
C6000_ELFABI = <OS_ABI.AMDGPU_HSA: 64>
C6000_LINUX = <OS_ABI.C6000_LINUX: 65>
CLOUDABI = <OS_ABI.CLOUDABI: 17>
FENIXOS = <OS_ABI.FENIXOS: 16>
FREEBSD = <OS_ABI.FREEBSD: 9>
GNU = <OS_ABI.LINUX: 3>
HPUX = <OS_ABI.HPUX: 1>
HURD = <OS_ABI.HURD: 4>
IRIX = <OS_ABI.IRIX: 8>
LINUX = <OS_ABI.LINUX: 3>
MODESTO = <OS_ABI.MODESTO: 11>
NETBSD = <OS_ABI.NETBSD: 2>
NSK = <OS_ABI.NSK: 14>
OPENBSD = <OS_ABI.OPENBSD: 12>
OPENVMS = <OS_ABI.OPENVMS: 13>
SOLARIS = <OS_ABI.SOLARIS: 6>
STANDALONE = <OS_ABI.STANDALONE: 255>
SYSTEMV = <OS_ABI.SYSTEMV: 0>
TRU64 = <OS_ABI.TRU64: 10>
property name
property value

Symbol section index

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

Members:

UNDEF

ABS

COMMON

XINDEX

ABS = <SYMBOL_SECTION_INDEX.ABS: 65521>
COMMON = <SYMBOL_SECTION_INDEX.COMMON: 65522>
UNDEF = <SYMBOL_SECTION_INDEX.UNDEF: 0>
XINDEX = <SYMBOL_SECTION_INDEX.XINDEX: 65535>
property name
property value

Binary types

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

Members:

NONE

RELOCATABLE

EXECUTABLE

DYNAMIC

CORE

LOPROC

HIPROC

CORE = <E_TYPE.CORE: 4>
DYNAMIC = <E_TYPE.DYNAMIC: 3>
EXECUTABLE = <E_TYPE.EXECUTABLE: 2>
HIPROC = <E_TYPE.HIPROC: 65535>
LOPROC = <E_TYPE.LOPROC: 65280>
NONE = <E_TYPE.NONE: 0>
RELOCATABLE = <E_TYPE.RELOCATABLE: 1>
property name
property value

Section types

class lief.ELF.SECTION_TYPES(self: lief.ELF.SECTION_TYPES, value: 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

ANDROID_REL

ANDROID_RELA

LLVM_ADDRSIG

RELR

ARM_EXIDX

ARM_PREEMPTMAP

ARM_ATTRIBUTES

ARM_DEBUGOVERLAY

ARM_OVERLAYSECTION

LOPROC

X86_64_UNWIND

HIPROC

LOUSER

HIUSER

ANDROID_REL = <SECTION_TYPES.ANDROID_REL: 1610612737>
ANDROID_RELA = <SECTION_TYPES.ANDROID_RELA: 1610612738>
ARM_ATTRIBUTES = <SECTION_TYPES.ARM_ATTRIBUTES: 1879048195>
ARM_DEBUGOVERLAY = <SECTION_TYPES.ARM_DEBUGOVERLAY: 1879048196>
ARM_EXIDX = <SECTION_TYPES.ARM_EXIDX: 1879048193>
ARM_OVERLAYSECTION = <SECTION_TYPES.ARM_OVERLAYSECTION: 1879048197>
ARM_PREEMPTMAP = <SECTION_TYPES.ARM_PREEMPTMAP: 1879048194>
DYNAMIC = <SECTION_TYPES.DYNAMIC: 6>
DYNSYM = <SECTION_TYPES.DYNSYM: 11>
FINI_ARRAY = <SECTION_TYPES.FINI_ARRAY: 15>
GNU_ATTRIBUTES = <SECTION_TYPES.GNU_ATTRIBUTES: 1879048181>
GNU_HASH = <SECTION_TYPES.GNU_HASH: 1879048182>
GNU_VERDEF = <SECTION_TYPES.GNU_VERDEF: 1879048189>
GNU_VERNEED = <SECTION_TYPES.GNU_VERNEED: 1879048190>
GROUP = <SECTION_TYPES.GROUP: 17>
HASH = <SECTION_TYPES.HASH: 5>
HIOS = <SECTION_TYPES.HIOS: 1879048191>
HIPROC = <SECTION_TYPES.HIPROC: 2147483647>
HIUSER = <SECTION_TYPES.HIUSER: 4294967295>
INIT_ARRAY = <SECTION_TYPES.INIT_ARRAY: 14>
LLVM_ADDRSIG = <SECTION_TYPES.LLVM_ADDRSIG: 1879002115>
LOOS = <SECTION_TYPES.LOOS: 1610612736>
LOPROC = <SECTION_TYPES.LOPROC: 1879048192>
LOUSER = <SECTION_TYPES.LOUSER: 2147483648>
NOBITS = <SECTION_TYPES.NOBITS: 8>
NOTE = <SECTION_TYPES.NOTE: 7>
NULL = <SECTION_TYPES.NULL: 0>
PREINIT_ARRAY = <SECTION_TYPES.PREINIT_ARRAY: 16>
PROGBITS = <SECTION_TYPES.PROGBITS: 1>
REL = <SECTION_TYPES.REL: 9>
RELA = <SECTION_TYPES.RELA: 4>
RELR = <SECTION_TYPES.RELR: 1879047936>
SHLIB = <SECTION_TYPES.SHLIB: 10>
STRTAB = <SECTION_TYPES.STRTAB: 3>
SYMTAB = <SECTION_TYPES.SYMTAB: 2>
SYMTAB_SHNDX = <SECTION_TYPES.SYMTAB_SHNDX: 18>
X86_64_UNWIND = <SECTION_TYPES.ARM_EXIDX: 1879048193>
property name
property value

Section flags

class lief.ELF.SECTION_FLAGS(self: lief.ELF.SECTION_FLAGS, value: 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: 2>
EXECINSTR = <SECTION_FLAGS.EXECINSTR: 4>
GROUP = <SECTION_FLAGS.GROUP: 512>
HEX_GPREL = <SECTION_FLAGS.HEX_GPREL: 268435456>
MASKOS = <SECTION_FLAGS.MASKOS: 267386880>
MASKPROC = <SECTION_FLAGS.MASKPROC: 4026531840>
MERGE = <SECTION_FLAGS.MERGE: 16>
MIPS_STRING = <SECTION_FLAGS.MIPS_STRING: 2147483648>
NONE = <SECTION_FLAGS.NONE: 0>
OS_NONCONFORMING = <SECTION_FLAGS.OS_NONCONFORMING: 256>
SHF_CP_SECTION = <SECTION_FLAGS.SHF_CP_SECTION: 2048>
STRINGS = <SECTION_FLAGS.STRINGS: 32>
TLS = <SECTION_FLAGS.TLS: 1024>
WRITE = <SECTION_FLAGS.WRITE: 1>
XCORE_SHF_CP_SECTION = <SECTION_FLAGS.XCORE_SHF_CP_SECTION: 4096>
property name
property value

Segment types

class lief.ELF.SEGMENT_TYPES(self: lief.ELF.SEGMENT_TYPES, value: 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: 1879048192>
ARM_UNWIND = <SEGMENT_TYPES.ARM_UNWIND: 1879048193>
DYNAMIC = <SEGMENT_TYPES.DYNAMIC: 2>
GNU_EH_FRAME = <SEGMENT_TYPES.GNU_EH_FRAME: 1685382480>
GNU_PROPERTY = <SEGMENT_TYPES.GNU_PROPERTY: 1685382483>
GNU_RELRO = <SEGMENT_TYPES.GNU_RELRO: 1685382482>
GNU_STACK = <SEGMENT_TYPES.GNU_STACK: 1685382481>
INTERP = <SEGMENT_TYPES.INTERP: 3>
LOAD = <SEGMENT_TYPES.LOAD: 1>
NOTE = <SEGMENT_TYPES.NOTE: 4>
NULL = <SEGMENT_TYPES.NULL: 0>
PHDR = <SEGMENT_TYPES.PHDR: 6>
SHLIB = <SEGMENT_TYPES.SHLIB: 5>
TLS = <SEGMENT_TYPES.TLS: 7>
UNWIND = <SEGMENT_TYPES.ARM_UNWIND: 1879048193>
property name
property value

Segment flags

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

Members:

NONE

X

W

R

NONE = <SEGMENT_FLAGS.NONE: 0>
R = <SEGMENT_FLAGS.R: 4>
W = <SEGMENT_FLAGS.W: 2>
X = <SEGMENT_FLAGS.X: 1>
property name
property value

Architectures

class lief.ELF.ARCH(self: lief.ELF.ARCH, value: 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

RISCV

BPF

AARCH64 = <ARCH.AARCH64: 183>
ALPHA = <ARCH.ALPHA: 41>
ALTERA_NIOS2 = <ARCH.ALTERA_NIOS2: 113>
AMDGPU = <ARCH.AMDGPU: 224>
ARC = <ARCH.ARC: 45>
ARCA = <ARCH.ARCA: 109>
ARCH_56800EX = <ARCH.ARCH_56800EX: 200>
ARCH_68HC05 = <ARCH.ARCH_68HC05: 72>
ARCH_68HC08 = <ARCH.ARCH_68HC08: 71>
ARCH_68HC11 = <ARCH.ARCH_68HC11: 70>
ARCH_68HC12 = <ARCH.ARCH_68HC12: 53>
ARCH_68HC16 = <ARCH.ARCH_68HC16: 69>
ARCH_68K = <ARCH.ARCH_68K: 4>
ARCH_78KOR = <ARCH.ARCH_78KOR: 199>
ARCH_8051 = <ARCH.ARCH_8051: 165>
ARCH_860 = <ARCH.ARCH_860: 7>
ARCH_88K = <ARCH.ARCH_88K: 5>
ARCH_960 = <ARCH.ARCH_960: 19>
ARC_COMPACT = <ARCH.ARC_COMPACT: 93>
ARC_COMPACT2 = <ARCH.ARC_COMPACT2: 195>
ARM = <ARCH.ARM: 40>
AVR = <ARCH.AVR: 83>
AVR32 = <ARCH.AVR32: 185>
BA1 = <ARCH.BA1: 201>
BA2 = <ARCH.BA2: 202>
BLACKFIN = <ARCH.BLACKFIN: 106>
BPF = <ARCH.BPF: 247>
C166 = <ARCH.C166: 116>
CDP = <ARCH.CDP: 215>
CE = <ARCH.CE: 119>
CLOUDSHIELD = <ARCH.CLOUDSHIELD: 192>
COGE = <ARCH.COGE: 216>
COLDFIRE = <ARCH.COLDFIRE: 52>
COOL = <ARCH.COOL: 217>
COREA_1ST = <ARCH.COREA_1ST: 193>
COREA_2ND = <ARCH.COREA_2ND: 194>
CR = <ARCH.CR: 103>
CR16 = <ARCH.CR16: 177>
CRAYNV2 = <ARCH.CRAYNV2: 172>
CRIS = <ARCH.CRIS: 76>
CRX = <ARCH.CRX: 114>
CSR_KALIMBA = <ARCH.CSR_KALIMBA: 219>
CUDA = <ARCH.CUDA: 190>
CYPRESS_M8C = <ARCH.CYPRESS_M8C: 161>
D10V = <ARCH.D10V: 85>
D30V = <ARCH.D30V: 86>
DSP24 = <ARCH.DSP24: 136>
DSPIC30F = <ARCH.DSPIC30F: 118>
DXP = <ARCH.DXP: 112>
ECOG1 = <ARCH.ECOG1: 168>
ECOG16 = <ARCH.ECOG16: 176>
ECOG1X = <ARCH.ECOG1: 168>
ECOG2 = <ARCH.ECOG2: 134>
ETPU = <ARCH.ETPU: 178>
EXCESS = <ARCH.EXCESS: 111>
F2MC16 = <ARCH.F2MC16: 104>
FIREPATH = <ARCH.FIREPATH: 78>
FR20 = <ARCH.FR20: 37>
FR30 = <ARCH.FR30: 84>
FX66 = <ARCH.FX66: 66>
H8S = <ARCH.H8S: 48>
H8_300 = <ARCH.H8_300: 46>
H8_300H = <ARCH.H8_300H: 47>
H8_500 = <ARCH.H8_500: 49>
HEXAGON = <ARCH.HEXAGON: 164>
HUANY = <ARCH.HUANY: 81>
IAMCU = <ARCH.IAMCU: 6>
IA_64 = <ARCH.IA_64: 50>
INTEL205 = <ARCH.INTEL205: 205>
INTEL206 = <ARCH.INTEL206: 206>
INTEL207 = <ARCH.INTEL207: 207>
INTEL208 = <ARCH.INTEL208: 208>
INTEL209 = <ARCH.INTEL209: 209>
IP2K = <ARCH.IP2K: 101>
JAVELIN = <ARCH.JAVELIN: 77>
K10M = <ARCH.K10M: 181>
KM32 = <ARCH.KM32: 210>
KMX16 = <ARCH.KMX16: 212>
KMX32 = <ARCH.KMX32: 211>
KMX8 = <ARCH.KMX8: 213>
KVARC = <ARCH.KVARC: 214>
L10M = <ARCH.L10M: 180>
LATTICEMICO32 = <ARCH.LATTICEMICO32: 138>
M16C = <ARCH.M16C: 117>
M32 = <ARCH.M32: 1>
M32C = <ARCH.M32C: 120>
M32R = <ARCH.M32R: 88>
MANIK = <ARCH.MANIK: 171>
MAX = <ARCH.MAX: 102>
MAXQ30 = <ARCH.MAXQ30: 169>
MCHP_PIC = <ARCH.MCHP_PIC: 204>
MCST_ELBRUS = <ARCH.MCST_ELBRUS: 175>
ME16 = <ARCH.ME16: 59>
METAG = <ARCH.METAG: 174>
MIPS = <ARCH.MIPS: 8>
MIPS_RS3_LE = <ARCH.MIPS_RS3_LE: 10>
MIPS_X = <ARCH.MIPS_X: 51>
MMA = <ARCH.MMA: 54>
MMDSP_PLUS = <ARCH.MMDSP_PLUS: 160>
MMIX = <ARCH.MMIX: 80>
MN10200 = <ARCH.MN10200: 90>
MN10300 = <ARCH.MN10300: 89>
MSP430 = <ARCH.MSP430: 105>
NCPU = <ARCH.NCPU: 56>
NDR1 = <ARCH.NDR1: 57>
NDS32 = <ARCH.NDS32: 167>
NONE = <ARCH.NONE: 0>
NORC = <ARCH.NORC: 218>
NS32K = <ARCH.NS32K: 97>
OPEN8 = <ARCH.OPEN8: 196>
OPENRISC = <ARCH.OPENRISC: 92>
PARISC = <ARCH.PARISC: 15>
PCP = <ARCH.PCP: 55>
PDP10 = <ARCH.PDP10: 64>
PDP11 = <ARCH.PDP11: 65>
PDSP = <ARCH.PDSP: 63>
PJ = <ARCH.PJ: 91>
PPC = <ARCH.PPC: 20>
PPC64 = <ARCH.PPC64: 21>
PRISM = <ARCH.PRISM: 82>
R32C = <ARCH.R32C: 162>
RCE = <ARCH.RCE: 39>
RH32 = <ARCH.RH32: 38>
RISCV = <ARCH.RISCV: 243>
RL78 = <ARCH.RL78: 197>
RS08 = <ARCH.RS08: 132>
RX = <ARCH.RX: 173>
S370 = <ARCH.S370: 9>
S390 = <ARCH.S390: 22>
SCORE7 = <ARCH.SCORE7: 135>
SEP = <ARCH.SEP: 108>
SE_C17 = <ARCH.SE_C17: 139>
SE_C33 = <ARCH.SE_C33: 107>
SH = <ARCH.SH: 42>
SHARC = <ARCH.SHARC: 133>
SLE9X = <ARCH.SLE9X: 179>
SNP1K = <ARCH.SNP1K: 99>
SPARC = <ARCH.SPARC: 2>
SPARC32PLUS = <ARCH.SPARC32PLUS: 18>
SPARCV9 = <ARCH.SPARCV9: 43>
SPU = <ARCH.SPU: 23>
ST100 = <ARCH.ST100: 60>
ST19 = <ARCH.ST19: 74>
ST200 = <ARCH.ST200: 100>
ST7 = <ARCH.ST7: 68>
ST9PLUS = <ARCH.ST9PLUS: 67>
STARCORE = <ARCH.STARCORE: 58>
STM8 = <ARCH.STM8: 186>
STXP7X = <ARCH.STXP7X: 166>
SVX = <ARCH.SVX: 73>
TILE64 = <ARCH.TILE64: 187>
TILEGX = <ARCH.TILEGX: 191>
TILEPRO = <ARCH.TILEPRO: 188>
TINYJ = <ARCH.TINYJ: 61>
TI_C2000 = <ARCH.TI_C2000: 141>
TI_C5500 = <ARCH.TI_C5500: 142>
TI_C6000 = <ARCH.TI_C6000: 140>
TMM_GPP = <ARCH.TMM_GPP: 96>
TPC = <ARCH.TPC: 98>
TRICORE = <ARCH.TRICORE: 44>
TRIMEDIA = <ARCH.TRIMEDIA: 163>
TSK3000 = <ARCH.TSK3000: 131>
UNICORE = <ARCH.UNICORE: 110>
V800 = <ARCH.V800: 36>
V850 = <ARCH.V850: 87>
VAX = <ARCH.VAX: 75>
VIDEOCORE = <ARCH.VIDEOCORE: 95>
VIDEOCORE3 = <ARCH.VIDEOCORE3: 137>
VIDEOCORE5 = <ARCH.VIDEOCORE5: 198>
VPP500 = <ARCH.VPP500: 17>
XCORE = <ARCH.XCORE: 203>
XGATE = <ARCH.XGATE: 115>
XIMO16 = <ARCH.XIMO16: 170>
XTENSA = <ARCH.XTENSA: 94>
ZSP = <ARCH.ZSP: 79>
i386 = <ARCH.i386: 3>
property name
property value
x86_64 = <ARCH.x86_64: 62>

Version

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

Members:

NONE

CURRENT

CURRENT = <VERSION.CURRENT: 1>
NONE = <VERSION.NONE: 0>
property name
property value

Dynamic tags

class lief.ELF.DYNAMIC_TAGS(self: lief.ELF.DYNAMIC_TAGS, value: 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

ANDROID_REL_OFFSET

ANDROID_REL_SIZE

ANDROID_REL

ANDROID_RELSZ

ANDROID_RELA

ANDROID_RELASZ

RELR

RELRSZ

RELRENT

RELRCOUNT

ANDROID_REL = <DYNAMIC_TAGS.ANDROID_REL: 1610612751>
ANDROID_RELA = <DYNAMIC_TAGS.ANDROID_RELA: 1610612753>
ANDROID_RELASZ = <DYNAMIC_TAGS.ANDROID_RELASZ: 1610612754>
ANDROID_RELSZ = <DYNAMIC_TAGS.ANDROID_RELSZ: 1610612752>
ANDROID_REL_OFFSET = <DYNAMIC_TAGS.ANDROID_REL_OFFSET: 1610612749>
ANDROID_REL_SIZE = <DYNAMIC_TAGS.ANDROID_REL_SIZE: 1610612750>
BIND_NOW = <DYNAMIC_TAGS.BIND_NOW: 24>
DEBUG = <DYNAMIC_TAGS.DEBUG: 21>
FINI = <DYNAMIC_TAGS.FINI: 13>
FINI_ARRAY = <DYNAMIC_TAGS.FINI_ARRAY: 26>
FINI_ARRAYSZ = <DYNAMIC_TAGS.FINI_ARRAYSZ: 28>
FLAGS = <DYNAMIC_TAGS.FLAGS: 30>
FLAGS_1 = <DYNAMIC_TAGS.FLAGS_1: 1879048187>
GNU_HASH = <DYNAMIC_TAGS.GNU_HASH: 1879047925>
HASH = <DYNAMIC_TAGS.HASH: 4>
INIT = <DYNAMIC_TAGS.INIT: 12>
INIT_ARRAY = <DYNAMIC_TAGS.INIT_ARRAY: 25>
INIT_ARRAYSZ = <DYNAMIC_TAGS.INIT_ARRAYSZ: 27>
JMPREL = <DYNAMIC_TAGS.JMPREL: 23>
MIPS_AUX_DYNAMIC = <DYNAMIC_TAGS.MIPS_AUX_DYNAMIC: 1879048241>
MIPS_BASE_ADDRESS = <DYNAMIC_TAGS.MIPS_BASE_ADDRESS: 1879048198>
MIPS_COMPACT_SIZE = <DYNAMIC_TAGS.MIPS_COMPACT_SIZE: 1879048239>
MIPS_CONFLICT = <DYNAMIC_TAGS.MIPS_CONFLICT: 1879048200>
MIPS_CONFLICTNO = <DYNAMIC_TAGS.MIPS_CONFLICTNO: 1879048203>
MIPS_CXX_FLAGS = <DYNAMIC_TAGS.MIPS_CXX_FLAGS: 1879048226>
MIPS_DELTA_CLASS = <DYNAMIC_TAGS.MIPS_DELTA_CLASS: 1879048215>
MIPS_DELTA_CLASSSYM = <DYNAMIC_TAGS.MIPS_DELTA_CLASSSYM: 1879048224>
MIPS_DELTA_CLASSSYM_NO = <DYNAMIC_TAGS.MIPS_DELTA_CLASSSYM_NO: 1879048225>
MIPS_DELTA_CLASS_NO = <DYNAMIC_TAGS.MIPS_DELTA_CLASS_NO: 1879048216>
MIPS_DELTA_INSTANCE = <DYNAMIC_TAGS.MIPS_DELTA_INSTANCE: 1879048217>
MIPS_DELTA_INSTANCE_NO = <DYNAMIC_TAGS.MIPS_DELTA_INSTANCE_NO: 1879048218>
MIPS_DELTA_RELOC = <DYNAMIC_TAGS.MIPS_DELTA_RELOC: 1879048219>
MIPS_DELTA_RELOC_NO = <DYNAMIC_TAGS.MIPS_DELTA_RELOC_NO: 1879048220>
MIPS_DELTA_SYM = <DYNAMIC_TAGS.MIPS_DELTA_SYM: 1879048221>
MIPS_DELTA_SYM_NO = <DYNAMIC_TAGS.MIPS_DELTA_SYM_NO: 1879048222>
MIPS_DYNSTR_ALIGN = <DYNAMIC_TAGS.MIPS_DYNSTR_ALIGN: 1879048235>
MIPS_FLAGS = <DYNAMIC_TAGS.MIPS_FLAGS: 1879048197>
MIPS_GOTSYM = <DYNAMIC_TAGS.MIPS_GOTSYM: 1879048211>
MIPS_GP_VALUE = <DYNAMIC_TAGS.MIPS_GP_VALUE: 1879048240>
MIPS_HIDDEN_GOTIDX = <DYNAMIC_TAGS.MIPS_HIDDEN_GOTIDX: 1879048231>
MIPS_HIPAGENO = <DYNAMIC_TAGS.MIPS_HIPAGENO: 1879048212>
MIPS_ICHECKSUM = <DYNAMIC_TAGS.MIPS_ICHECKSUM: 1879048195>
MIPS_INTERFACE = <DYNAMIC_TAGS.MIPS_INTERFACE: 1879048234>
MIPS_INTERFACE_SIZE = <DYNAMIC_TAGS.MIPS_INTERFACE_SIZE: 1879048236>
MIPS_IVERSION = <DYNAMIC_TAGS.MIPS_IVERSION: 1879048196>
MIPS_LIBLIST = <DYNAMIC_TAGS.MIPS_LIBLIST: 1879048201>
MIPS_LIBLISTNO = <DYNAMIC_TAGS.MIPS_LIBLISTNO: 1879048208>
MIPS_LOCALPAGE_GOTIDX = <DYNAMIC_TAGS.MIPS_LOCALPAGE_GOTIDX: 1879048229>
MIPS_LOCAL_GOTIDX = <DYNAMIC_TAGS.MIPS_LOCAL_GOTIDX: 1879048230>
MIPS_LOCAL_GOTNO = <DYNAMIC_TAGS.MIPS_LOCAL_GOTNO: 1879048202>
MIPS_MSYM = <DYNAMIC_TAGS.MIPS_MSYM: 1879048199>
MIPS_OPTIONS = <DYNAMIC_TAGS.MIPS_OPTIONS: 1879048233>
MIPS_PERF_SUFFIX = <DYNAMIC_TAGS.MIPS_PERF_SUFFIX: 1879048238>
MIPS_PIXIE_INIT = <DYNAMIC_TAGS.MIPS_PIXIE_INIT: 1879048227>
MIPS_PLTGOT = <DYNAMIC_TAGS.MIPS_PLTGOT: 1879048242>
MIPS_PROTECTED_GOTIDX = <DYNAMIC_TAGS.MIPS_PROTECTED_GOTIDX: 1879048232>
MIPS_RLD_MAP = <DYNAMIC_TAGS.MIPS_RLD_MAP: 1879048214>
MIPS_RLD_TEXT_RESOLVE_ADDR = <DYNAMIC_TAGS.MIPS_RLD_TEXT_RESOLVE_ADDR: 1879048237>
MIPS_RLD_VERSION = <DYNAMIC_TAGS.MIPS_RLD_VERSION: 1879048193>
MIPS_RWPLT = <DYNAMIC_TAGS.MIPS_RWPLT: 1879048244>
MIPS_SYMBOL_LIB = <DYNAMIC_TAGS.MIPS_SYMBOL_LIB: 1879048228>
MIPS_SYMTABNO = <DYNAMIC_TAGS.MIPS_SYMTABNO: 1879048209>
MIPS_TIME_STAMP = <DYNAMIC_TAGS.MIPS_TIME_STAMP: 1879048194>
MIPS_UNREFEXTNO = <DYNAMIC_TAGS.MIPS_UNREFEXTNO: 1879048210>
NEEDED = <DYNAMIC_TAGS.NEEDED: 1>
NULL = <DYNAMIC_TAGS.NULL: 0>
PLTGOT = <DYNAMIC_TAGS.PLTGOT: 3>
PLTREL = <DYNAMIC_TAGS.PLTREL: 20>
PLTRELSZ = <DYNAMIC_TAGS.PLTRELSZ: 2>
PREINIT_ARRAY = <DYNAMIC_TAGS.PREINIT_ARRAY: 32>
PREINIT_ARRAYSZ = <DYNAMIC_TAGS.PREINIT_ARRAYSZ: 33>
REL = <DYNAMIC_TAGS.REL: 17>
RELA = <DYNAMIC_TAGS.RELA: 7>
RELACOUNT = <DYNAMIC_TAGS.RELACOUNT: 1879048185>
RELAENT = <DYNAMIC_TAGS.RELAENT: 9>
RELASZ = <DYNAMIC_TAGS.RELASZ: 8>
RELCOUNT = <DYNAMIC_TAGS.RELCOUNT: 1879048186>
RELENT = <DYNAMIC_TAGS.RELENT: 19>
RELR = <DYNAMIC_TAGS.RELR: 1879040000>
RELRCOUNT = <DYNAMIC_TAGS.RELRCOUNT: 1879040005>
RELRENT = <DYNAMIC_TAGS.RELRENT: 1879040003>
RELRSZ = <DYNAMIC_TAGS.RELRSZ: 1879040001>
RELSZ = <DYNAMIC_TAGS.RELSZ: 18>
RPATH = <DYNAMIC_TAGS.RPATH: 15>
RUNPATH = <DYNAMIC_TAGS.RUNPATH: 29>
SONAME = <DYNAMIC_TAGS.SONAME: 14>
STRSZ = <DYNAMIC_TAGS.STRSZ: 10>
STRTAB = <DYNAMIC_TAGS.STRTAB: 5>
SYMBOLIC = <DYNAMIC_TAGS.SYMBOLIC: 16>
SYMENT = <DYNAMIC_TAGS.SYMENT: 11>
SYMTAB = <DYNAMIC_TAGS.SYMTAB: 6>
TEXTREL = <DYNAMIC_TAGS.TEXTREL: 22>
VERDEF = <DYNAMIC_TAGS.VERDEF: 1879048188>
VERDEFNUM = <DYNAMIC_TAGS.VERDEFNUM: 1879048189>
VERNEED = <DYNAMIC_TAGS.VERNEED: 1879048190>
VERNEEDNUM = <DYNAMIC_TAGS.VERNEEDNUM: 1879048191>
VERSYM = <DYNAMIC_TAGS.VERSYM: 1879048176>
property name
property value

Dynamic flags

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

Members:

ORIGIN

SYMBOLIC

TEXTREL

BIND_NOW

STATIC_TLS

BIND_NOW = <DYNAMIC_FLAGS.BIND_NOW: 8>
ORIGIN = <DYNAMIC_FLAGS.ORIGIN: 1>
STATIC_TLS = <DYNAMIC_FLAGS.STATIC_TLS: 16>
SYMBOLIC = <DYNAMIC_FLAGS.SYMBOLIC: 2>
TEXTREL = <DYNAMIC_FLAGS.TEXTREL: 4>
property name
property value

Dynamic flags 1

class lief.ELF.DYNAMIC_FLAGS_1(self: lief.ELF.DYNAMIC_FLAGS_1, value: 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

PIE

CONFALT = <DYNAMIC_FLAGS_1.CONFALT: 8192>
DIRECT = <DYNAMIC_FLAGS_1.DIRECT: 256>
DISPRELDNE = <DYNAMIC_FLAGS_1.DISPRELDNE: 32768>
DISPRELPND = <DYNAMIC_FLAGS_1.DISPRELPND: 65536>
EDITED = <DYNAMIC_FLAGS_1.EDITED: 2097152>
ENDFILTEE = <DYNAMIC_FLAGS_1.ENDFILTEE: 16384>
GLOBAL = <DYNAMIC_FLAGS_1.GLOBAL: 2>
GLOBAUDIT = <DYNAMIC_FLAGS_1.GLOBAUDIT: 16777216>
GROUP = <DYNAMIC_FLAGS_1.GROUP: 4>
IGNMULDEF = <DYNAMIC_FLAGS_1.IGNMULDEF: 262144>
INITFIRST = <DYNAMIC_FLAGS_1.INITFIRST: 32>
INTERPOSE = <DYNAMIC_FLAGS_1.INTERPOSE: 1024>
LOADFLTR = <DYNAMIC_FLAGS_1.LOADFLTR: 16>
NODEFLIB = <DYNAMIC_FLAGS_1.NODEFLIB: 2048>
NODELETE = <DYNAMIC_FLAGS_1.NODELETE: 8>
NODIRECT = <DYNAMIC_FLAGS_1.NODIRECT: 131072>
NODUMP = <DYNAMIC_FLAGS_1.NODUMP: 4096>
NOHDR = <DYNAMIC_FLAGS_1.NOHDR: 1048576>
NOKSYMS = <DYNAMIC_FLAGS_1.NOKSYMS: 524288>
NOOPEN = <DYNAMIC_FLAGS_1.NOOPEN: 64>
NORELOC = <DYNAMIC_FLAGS_1.NORELOC: 4194304>
NOW = <DYNAMIC_FLAGS_1.NOW: 1>
ORIGIN = <DYNAMIC_FLAGS_1.ORIGIN: 128>
PIE = <DYNAMIC_FLAGS_1.PIE: 134217728>
SINGLETON = <DYNAMIC_FLAGS_1.SINGLETON: 33554432>
SYMINTPOSE = <DYNAMIC_FLAGS_1.SYMINTPOSE: 8388608>
TRANS = <DYNAMIC_FLAGS_1.TRANS: 512>
property name
property value

Symbol types

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

Members:

NOTYPE

OBJECT

FUNC

SECTION

FILE

COMMON

TLS

GNU_IFUNC

COMMON = <SYMBOL_TYPES.COMMON: 5>
FILE = <SYMBOL_TYPES.FILE: 4>
FUNC = <SYMBOL_TYPES.FUNC: 2>
GNU_IFUNC = <SYMBOL_TYPES.GNU_IFUNC: 10>
NOTYPE = <SYMBOL_TYPES.NOTYPE: 0>
OBJECT = <SYMBOL_TYPES.OBJECT: 1>
SECTION = <SYMBOL_TYPES.SECTION: 3>
TLS = <SYMBOL_TYPES.TLS: 6>
property name
property value

Symbol bindings

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

Members:

LOCAL

GLOBAL

WEAK

GNU_UNIQUE

GLOBAL = <SYMBOL_BINDINGS.GLOBAL: 1>
GNU_UNIQUE = <SYMBOL_BINDINGS.GNU_UNIQUE: 10>
LOCAL = <SYMBOL_BINDINGS.LOCAL: 0>
WEAK = <SYMBOL_BINDINGS.WEAK: 2>
property name
property value

Symbol Visibility

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

Members:

DEFAULT

HIDDEN

INTERNAL

PROTECTED

DEFAULT = <SYMBOL_VISIBILITY.DEFAULT: 0>
HIDDEN = <SYMBOL_VISIBILITY.HIDDEN: 2>
INTERNAL = <SYMBOL_VISIBILITY.INTERNAL: 1>
PROTECTED = <SYMBOL_VISIBILITY.PROTECTED: 3>
property name
property value

Relocations x86-64

class lief.ELF.RELOCATION_X86_64(self: lief.ELF.RELOCATION_X86_64, value: 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: 5>
DTPMOD64 = <RELOCATION_X86_64.DTPMOD64: 16>
DTPOFF32 = <RELOCATION_X86_64.DTPOFF32: 21>
DTPOFF64 = <RELOCATION_X86_64.DTPOFF64: 17>
GLOB_DAT = <RELOCATION_X86_64.GLOB_DAT: 6>
GOT32 = <RELOCATION_X86_64.GOT32: 3>
GOT64 = <RELOCATION_X86_64.GOT64: 27>
GOTOFF64 = <RELOCATION_X86_64.GOTOFF64: 25>
GOTPC32 = <RELOCATION_X86_64.GOTPC32: 26>
GOTPC32_TLSDESC = <RELOCATION_X86_64.GOTPC32_TLSDESC: 34>
GOTPC64 = <RELOCATION_X86_64.GOTPC64: 29>
GOTPCREL = <RELOCATION_X86_64.GOTPCREL: 9>
GOTPCREL64 = <RELOCATION_X86_64.GOTPCREL64: 28>
GOTPCRELX = <RELOCATION_X86_64.GOTPCRELX: 41>
GOTPLT64 = <RELOCATION_X86_64.GOTPLT64: 30>
GOTTPOFF = <RELOCATION_X86_64.GOTTPOFF: 22>
IRELATIVE = <RELOCATION_X86_64.IRELATIVE: 37>
JUMP_SLOT = <RELOCATION_X86_64.JUMP_SLOT: 7>
NONE = <RELOCATION_X86_64.NONE: 0>
PC16 = <RELOCATION_X86_64.PC16: 13>
PC32 = <RELOCATION_X86_64.PC32: 2>
PC32_BND = <RELOCATION_X86_64.PC32_BND: 39>
PC64 = <RELOCATION_X86_64.PC64: 24>
PC8 = <RELOCATION_X86_64.PC8: 15>
PLT32 = <RELOCATION_X86_64.PLT32: 4>
PLT32_BND = <RELOCATION_X86_64.PLT32_BND: 40>
PLTOFF64 = <RELOCATION_X86_64.PLTOFF64: 31>
R16 = <RELOCATION_X86_64.R16: 12>
R32 = <RELOCATION_X86_64.R32: 10>
R32S = <RELOCATION_X86_64.R32S: 11>
R64 = <RELOCATION_X86_64.R64: 1>
R8 = <RELOCATION_X86_64.R8: 14>
RELATIVE = <RELOCATION_X86_64.RELATIVE: 8>
RELATIVE64 = <RELOCATION_X86_64.RELATIVE64: 38>
REX_GOTPCRELX = <RELOCATION_X86_64.REX_GOTPCRELX: 42>
SIZE32 = <RELOCATION_X86_64.SIZE32: 32>
SIZE64 = <RELOCATION_X86_64.SIZE64: 33>
TLSDESC = <RELOCATION_X86_64.TLSDESC: 36>
TLSDESC_CALL = <RELOCATION_X86_64.TLSDESC_CALL: 35>
TLSGD = <RELOCATION_X86_64.TLSGD: 19>
TLSLD = <RELOCATION_X86_64.TLSLD: 20>
TPOFF32 = <RELOCATION_X86_64.TPOFF32: 23>
TPOFF64 = <RELOCATION_X86_64.TPOFF64: 18>
property name
property value

Relocations x86 (i386)

class lief.ELF.RELOCATION_i386(self: lief.ELF.RELOCATION_i386, value: 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: 5>
GLOB_DAT = <RELOCATION_i386.GLOB_DAT: 6>
GOT32 = <RELOCATION_i386.GOT32: 3>
GOTOFF = <RELOCATION_i386.GOTOFF: 9>
GOTPC = <RELOCATION_i386.GOTPC: 10>
IRELATIVE = <RELOCATION_i386.IRELATIVE: 42>
JUMP_SLOT = <RELOCATION_i386.JUMP_SLOT: 7>
NONE = <RELOCATION_i386.NONE: 0>
NUM = <RELOCATION_i386.NUM: 43>
PC16 = <RELOCATION_i386.PC16: 21>
PC32 = <RELOCATION_i386.PC32: 2>
PC8 = <RELOCATION_i386.PC8: 23>
PLT32 = <RELOCATION_i386.PLT32: 4>
R16 = <RELOCATION_i386.R16: 20>
R32 = <RELOCATION_i386.R32: 1>
R32PLT = <RELOCATION_i386.R32PLT: 11>
R8 = <RELOCATION_i386.R8: 22>
RELATIVE = <RELOCATION_i386.RELATIVE: 8>
TLS_DESC = <RELOCATION_i386.TLS_DESC: 41>
TLS_DESC_CALL = <RELOCATION_i386.TLS_DESC_CALL: 40>
TLS_DTPMOD32 = <RELOCATION_i386.TLS_DTPMOD32: 35>
TLS_DTPOFF32 = <RELOCATION_i386.TLS_DTPOFF32: 36>
TLS_GD = <RELOCATION_i386.TLS_GD: 18>
TLS_GD_32 = <RELOCATION_i386.TLS_GD_32: 24>
TLS_GD_CALL = <RELOCATION_i386.TLS_GD_CALL: 26>
TLS_GD_POP = <RELOCATION_i386.TLS_GD_POP: 27>
TLS_GD_PUSH = <RELOCATION_i386.TLS_GD_PUSH: 25>
TLS_GOTDESC = <RELOCATION_i386.TLS_GOTDESC: 39>
TLS_GOTIE = <RELOCATION_i386.TLS_GOTIE: 16>
TLS_IE = <RELOCATION_i386.TLS_IE: 15>
TLS_IE_32 = <RELOCATION_i386.TLS_IE_32: 33>
TLS_LDM = <RELOCATION_i386.TLS_LDM: 19>
TLS_LDM_32 = <RELOCATION_i386.TLS_LDM_32: 28>
TLS_LDM_CALL = <RELOCATION_i386.TLS_LDM_CALL: 30>
TLS_LDM_POP = <RELOCATION_i386.TLS_LDM_POP: 31>
TLS_LDM_PUSH = <RELOCATION_i386.TLS_LDM_PUSH: 29>
TLS_LDO_32 = <RELOCATION_i386.TLS_LDO_32: 32>
TLS_LE = <RELOCATION_i386.TLS_LE: 17>
TLS_LE_32 = <RELOCATION_i386.TLS_LE_32: 34>
TLS_TPOFF = <RELOCATION_i386.TLS_TPOFF: 14>
TLS_TPOFF32 = <RELOCATION_i386.TLS_TPOFF32: 37>
property name
property value

Relocations ARM

class lief.ELF.RELOCATION_ARM(self: lief.ELF.RELOCATION_ARM, value: 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: 6>
ABS16 = <RELOCATION_ARM.ABS16: 5>
ABS32 = <RELOCATION_ARM.ABS32: 2>
ABS32_NOI = <RELOCATION_ARM.ABS32_NOI: 55>
ABS8 = <RELOCATION_ARM.ABS8: 8>
ALU_PCREL_15_8 = <RELOCATION_ARM.ALU_PCREL_15_8: 33>
ALU_PCREL_23_15 = <RELOCATION_ARM.ALU_PCREL_23_15: 34>
ALU_PCREL_7_0 = <RELOCATION_ARM.ALU_PCREL_7_0: 32>
ALU_PC_G0 = <RELOCATION_ARM.ALU_PC_G0: 58>
ALU_PC_G0_NC = <RELOCATION_ARM.ALU_PC_G0_NC: 57>
ALU_PC_G1 = <RELOCATION_ARM.ALU_PC_G1: 60>
ALU_PC_G1_NC = <RELOCATION_ARM.ALU_PC_G1_NC: 59>
ALU_PC_G2 = <RELOCATION_ARM.ALU_PC_G2: 61>
ALU_SBREL_19_12_NC = <RELOCATION_ARM.ALU_SBREL_19_12_NC: 36>
ALU_SBREL_27_20_CK = <RELOCATION_ARM.ALU_SBREL_27_20_CK: 37>
ALU_SB_G0 = <RELOCATION_ARM.ALU_SB_G0: 71>
ALU_SB_G0_NC = <RELOCATION_ARM.ALU_SB_G0_NC: 70>
ALU_SB_G1 = <RELOCATION_ARM.ALU_SB_G1: 73>
ALU_SB_G1_NC = <RELOCATION_ARM.ALU_SB_G1_NC: 72>
ALU_SB_G2 = <RELOCATION_ARM.ALU_SB_G2: 74>
BASE_ABS = <RELOCATION_ARM.BASE_ABS: 31>
BASE_PREL = <RELOCATION_ARM.BASE_PREL: 25>
BREL_ADJ = <RELOCATION_ARM.BREL_ADJ: 12>
CALL = <RELOCATION_ARM.CALL: 28>
COPY = <RELOCATION_ARM.COPY: 20>
GLOB_DAT = <RELOCATION_ARM.GLOB_DAT: 21>
GNU_VTENTRY = <RELOCATION_ARM.GNU_VTENTRY: 100>
GNU_VTINHERIT = <RELOCATION_ARM.GNU_VTINHERIT: 101>
GOTOFF12 = <RELOCATION_ARM.GOTOFF12: 98>
GOTOFF32 = <RELOCATION_ARM.GOTOFF32: 24>
GOTRELAX = <RELOCATION_ARM.GOTRELAX: 99>
GOT_ABS = <RELOCATION_ARM.GOT_ABS: 95>
GOT_BREL = <RELOCATION_ARM.GOT_BREL: 26>
GOT_BREL12 = <RELOCATION_ARM.GOT_BREL12: 97>
GOT_PREL = <RELOCATION_ARM.GOT_PREL: 96>
IRELATIVE = <RELOCATION_ARM.IRELATIVE: 160>
JUMP24 = <RELOCATION_ARM.JUMP24: 29>
JUMP_SLOT = <RELOCATION_ARM.JUMP_SLOT: 22>
LDC_PC_G0 = <RELOCATION_ARM.LDC_PC_G0: 67>
LDC_PC_G1 = <RELOCATION_ARM.LDC_PC_G1: 68>
LDC_PC_G2 = <RELOCATION_ARM.LDC_PC_G2: 69>
LDC_SB_G0 = <RELOCATION_ARM.LDC_SB_G0: 81>
LDC_SB_G1 = <RELOCATION_ARM.LDC_SB_G1: 82>
LDC_SB_G2 = <RELOCATION_ARM.LDC_SB_G2: 83>
LDRS_PC_G0 = <RELOCATION_ARM.LDRS_PC_G0: 64>
LDRS_PC_G1 = <RELOCATION_ARM.LDRS_PC_G1: 65>
LDRS_PC_G2 = <RELOCATION_ARM.LDRS_PC_G2: 66>
LDRS_SB_G0 = <RELOCATION_ARM.LDRS_SB_G0: 78>
LDRS_SB_G1 = <RELOCATION_ARM.LDRS_SB_G1: 79>
LDRS_SB_G2 = <RELOCATION_ARM.LDRS_SB_G2: 80>
LDR_PC_G0 = <RELOCATION_ARM.LDR_PC_G0: 4>
LDR_PC_G1 = <RELOCATION_ARM.LDR_PC_G1: 62>
LDR_PC_G2 = <RELOCATION_ARM.LDR_PC_G2: 63>
LDR_SBREL_11_0_NC = <RELOCATION_ARM.LDR_SBREL_11_0_NC: 35>
LDR_SB_G0 = <RELOCATION_ARM.LDR_SB_G0: 75>
LDR_SB_G1 = <RELOCATION_ARM.LDR_SB_G1: 76>
LDR_SB_G2 = <RELOCATION_ARM.LDR_SB_G2: 77>
ME_TOO = <RELOCATION_ARM.ME_TOO: 128>
MOVT_ABS = <RELOCATION_ARM.MOVT_ABS: 44>
MOVT_BREL = <RELOCATION_ARM.MOVT_BREL: 85>
MOVT_PREL = <RELOCATION_ARM.MOVT_PREL: 46>
MOVW_ABS_NC = <RELOCATION_ARM.MOVW_ABS_NC: 43>
MOVW_BREL = <RELOCATION_ARM.MOVW_BREL: 86>
MOVW_BREL_NC = <RELOCATION_ARM.MOVW_BREL_NC: 84>
MOVW_PREL_NC = <RELOCATION_ARM.MOVW_PREL_NC: 45>
NONE = <RELOCATION_ARM.NONE: 0>
PC24 = <RELOCATION_ARM.PC24: 1>
PLT32 = <RELOCATION_ARM.PLT32: 27>
PLT32_ABS = <RELOCATION_ARM.PLT32_ABS: 94>
PREL31 = <RELOCATION_ARM.PREL31: 42>
PRIVATE_0 = <RELOCATION_ARM.PRIVATE_0: 112>
PRIVATE_1 = <RELOCATION_ARM.PRIVATE_1: 113>
PRIVATE_10 = <RELOCATION_ARM.PRIVATE_10: 122>
PRIVATE_11 = <RELOCATION_ARM.PRIVATE_11: 123>
PRIVATE_12 = <RELOCATION_ARM.PRIVATE_12: 124>
PRIVATE_13 = <RELOCATION_ARM.PRIVATE_13: 125>
PRIVATE_14 = <RELOCATION_ARM.PRIVATE_14: 126>
PRIVATE_15 = <RELOCATION_ARM.PRIVATE_15: 127>
PRIVATE_2 = <RELOCATION_ARM.PRIVATE_2: 114>
PRIVATE_3 = <RELOCATION_ARM.PRIVATE_3: 115>
PRIVATE_4 = <RELOCATION_ARM.PRIVATE_4: 116>
PRIVATE_5 = <RELOCATION_ARM.PRIVATE_5: 117>
PRIVATE_6 = <RELOCATION_ARM.PRIVATE_6: 118>
PRIVATE_7 = <RELOCATION_ARM.PRIVATE_7: 119>
PRIVATE_8 = <RELOCATION_ARM.PRIVATE_8: 120>
PRIVATE_9 = <RELOCATION_ARM.PRIVATE_9: 121>
RBASE = <RELOCATION_ARM.RBASE: 254>
REL32 = <RELOCATION_ARM.REL32: 3>
REL32_NOI = <RELOCATION_ARM.REL32_NOI: 56>
RELATIVE = <RELOCATION_ARM.RELATIVE: 23>
RPC24 = <RELOCATION_ARM.RPC24: 253>
RREL32 = <RELOCATION_ARM.RREL32: 252>
RSBREL32 = <RELOCATION_ARM.RSBREL32: 250>
RXPC25 = <RELOCATION_ARM.RXPC25: 249>
SBREL31 = <RELOCATION_ARM.SBREL31: 39>
SBREL32 = <RELOCATION_ARM.SBREL32: 9>
TARGET1 = <RELOCATION_ARM.TARGET1: 38>
TARGET2 = <RELOCATION_ARM.TARGET2: 41>
THM_ABS5 = <RELOCATION_ARM.THM_ABS5: 7>
THM_ALU_PREL_11_0 = <RELOCATION_ARM.THM_ALU_PREL_11_0: 53>
THM_CALL = <RELOCATION_ARM.THM_CALL: 10>
THM_JUMP11 = <RELOCATION_ARM.THM_JUMP11: 102>
THM_JUMP19 = <RELOCATION_ARM.THM_JUMP19: 51>
THM_JUMP24 = <RELOCATION_ARM.THM_JUMP24: 30>
THM_JUMP6 = <RELOCATION_ARM.THM_JUMP6: 52>
THM_JUMP8 = <RELOCATION_ARM.THM_JUMP8: 103>
THM_MOVT_ABS = <RELOCATION_ARM.THM_MOVT_ABS: 48>
THM_MOVT_BREL = <RELOCATION_ARM.THM_MOVT_BREL: 88>
THM_MOVT_PREL = <RELOCATION_ARM.THM_MOVT_PREL: 50>
THM_MOVW_ABS_NC = <RELOCATION_ARM.THM_MOVW_ABS_NC: 47>
THM_MOVW_BREL = <RELOCATION_ARM.THM_MOVW_BREL: 89>
THM_MOVW_BREL_NC = <RELOCATION_ARM.THM_MOVW_BREL_NC: 87>
THM_MOVW_PREL_NC = <RELOCATION_ARM.THM_MOVW_PREL_NC: 49>
THM_PC12 = <RELOCATION_ARM.THM_PC12: 54>
THM_PC8 = <RELOCATION_ARM.THM_PC8: 11>
THM_RPC22 = <RELOCATION_ARM.THM_RPC22: 251>
THM_SWI8 = <RELOCATION_ARM.THM_SWI8: 14>
THM_TLS_CALL = <RELOCATION_ARM.THM_TLS_CALL: 93>
THM_TLS_DESCSEQ16 = <RELOCATION_ARM.THM_TLS_DESCSEQ16: 129>
THM_TLS_DESCSEQ32 = <RELOCATION_ARM.THM_TLS_DESCSEQ32: 130>
THM_XPC22 = <RELOCATION_ARM.THM_XPC22: 16>
TLS_CALL = <RELOCATION_ARM.TLS_CALL: 91>
TLS_DESC = <RELOCATION_ARM.TLS_DESC: 13>
TLS_DESCSEQ = <RELOCATION_ARM.TLS_DESCSEQ: 92>
TLS_DTPMOD32 = <RELOCATION_ARM.TLS_DTPMOD32: 17>
TLS_DTPOFF32 = <RELOCATION_ARM.TLS_DTPOFF32: 18>
TLS_GD32 = <RELOCATION_ARM.TLS_GD32: 104>
TLS_GOTDESC = <RELOCATION_ARM.TLS_GOTDESC: 90>
TLS_IE12GP = <RELOCATION_ARM.TLS_IE12GP: 111>
TLS_IE32 = <RELOCATION_ARM.TLS_IE32: 107>
TLS_LDM32 = <RELOCATION_ARM.TLS_LDM32: 105>
TLS_LDO12 = <RELOCATION_ARM.TLS_LDO12: 109>
TLS_LDO32 = <RELOCATION_ARM.TLS_LDO32: 106>
TLS_LE12 = <RELOCATION_ARM.TLS_LE12: 110>
TLS_LE32 = <RELOCATION_ARM.TLS_LE32: 108>
TLS_TPOFF32 = <RELOCATION_ARM.TLS_TPOFF32: 19>
V4BX = <RELOCATION_ARM.V4BX: 40>
XPC25 = <RELOCATION_ARM.XPC25: 15>
property name
property value

Relocations AARCH64

class lief.ELF.RELOCATION_AARCH64(self: lief.ELF.RELOCATION_AARCH64, value: 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: 259>
ABS32 = <RELOCATION_AARCH64.ABS32: 258>
ABS64 = <RELOCATION_AARCH64.ABS64: 257>
ADD_ABS_LO12_NC = <RELOCATION_AARCH64.ADD_ABS_LO12_NC: 277>
ADR_GOT_PAGE = <RELOCATION_AARCH64.ADR_GOT_PAGE: 311>
ADR_PREL_LO21 = <RELOCATION_AARCH64.ADR_PREL_LO21: 274>
ADR_PREL_PG_HI21 = <RELOCATION_AARCH64.ADR_PREL_PG_HI21: 275>
ADR_PREL_PG_HI21_NC = <RELOCATION_AARCH64.ADR_PREL_PG_HI21_NC: 276>
CALL26 = <RELOCATION_AARCH64.CALL26: 283>
CONDBR19 = <RELOCATION_AARCH64.CONDBR19: 280>
COPY = <RELOCATION_AARCH64.COPY: 1024>
GLOB_DAT = <RELOCATION_AARCH64.GLOB_DAT: 1025>
GOTREL32 = <RELOCATION_AARCH64.GOTREL32: 308>
GOTREL64 = <RELOCATION_AARCH64.GOTREL64: 307>
GOT_LD_PREL19 = <RELOCATION_AARCH64.GOT_LD_PREL19: 309>
IRELATIVE = <RELOCATION_AARCH64.IRELATIVE: 1032>
JUMP26 = <RELOCATION_AARCH64.JUMP26: 282>
JUMP_SLOT = <RELOCATION_AARCH64.JUMP_SLOT: 1026>
LD64_GOTOFF_LO15 = <RELOCATION_AARCH64.LD64_GOTOFF_LO15: 310>
LD64_GOTPAGE_LO15 = <RELOCATION_AARCH64.LD64_GOTPAGE_LO15: 313>
LD64_GOT_LO12_NC = <RELOCATION_AARCH64.LD64_GOT_LO12_NC: 312>
LDST128_ABS_LO12_NC = <RELOCATION_AARCH64.LDST128_ABS_LO12_NC: 299>
LDST16_ABS_LO12_NC = <RELOCATION_AARCH64.LDST16_ABS_LO12_NC: 284>
LDST32_ABS_LO12_NC = <RELOCATION_AARCH64.LDST32_ABS_LO12_NC: 285>
LDST64_ABS_LO12_NC = <RELOCATION_AARCH64.LDST64_ABS_LO12_NC: 286>
LDST8_ABS_LO12_NC = <RELOCATION_AARCH64.LDST8_ABS_LO12_NC: 278>
LD_PREL_LO19 = <RELOCATION_AARCH64.LD_PREL_LO19: 273>
MOVW_GOTOFF_G0 = <RELOCATION_AARCH64.MOVW_GOTOFF_G0: 300>
MOVW_GOTOFF_G0_NC = <RELOCATION_AARCH64.MOVW_GOTOFF_G0_NC: 301>
MOVW_GOTOFF_G1 = <RELOCATION_AARCH64.MOVW_GOTOFF_G1: 302>
MOVW_GOTOFF_G1_NC = <RELOCATION_AARCH64.MOVW_GOTOFF_G1_NC: 303>
MOVW_GOTOFF_G2 = <RELOCATION_AARCH64.MOVW_GOTOFF_G2: 304>
MOVW_GOTOFF_G2_NC = <RELOCATION_AARCH64.MOVW_GOTOFF_G2_NC: 305>
MOVW_GOTOFF_G3 = <RELOCATION_AARCH64.MOVW_GOTOFF_G3: 306>
MOVW_PREL_G0 = <RELOCATION_AARCH64.MOVW_PREL_G0: 287>
MOVW_PREL_G0_NC = <RELOCATION_AARCH64.MOVW_PREL_G0_NC: 288>
MOVW_PREL_G1 = <RELOCATION_AARCH64.MOVW_PREL_G1: 289>
MOVW_PREL_G1_NC = <RELOCATION_AARCH64.MOVW_PREL_G1_NC: 290>
MOVW_PREL_G2 = <RELOCATION_AARCH64.MOVW_PREL_G2: 291>
MOVW_PREL_G2_NC = <RELOCATION_AARCH64.MOVW_PREL_G2_NC: 292>
MOVW_PREL_G3 = <RELOCATION_AARCH64.MOVW_PREL_G3: 293>
MOVW_SABS_G0 = <RELOCATION_AARCH64.MOVW_SABS_G0: 270>
MOVW_SABS_G1 = <RELOCATION_AARCH64.MOVW_SABS_G1: 271>
MOVW_SABS_G2 = <RELOCATION_AARCH64.MOVW_SABS_G2: 272>
MOVW_UABS_G0 = <RELOCATION_AARCH64.MOVW_UABS_G0: 263>
MOVW_UABS_G0_NC = <RELOCATION_AARCH64.MOVW_UABS_G0_NC: 264>
MOVW_UABS_G1 = <RELOCATION_AARCH64.MOVW_UABS_G1: 265>
MOVW_UABS_G1_NC = <RELOCATION_AARCH64.MOVW_UABS_G1_NC: 266>
MOVW_UABS_G2 = <RELOCATION_AARCH64.MOVW_UABS_G2: 267>
MOVW_UABS_G2_NC = <RELOCATION_AARCH64.MOVW_UABS_G2_NC: 268>
MOVW_UABS_G3 = <RELOCATION_AARCH64.MOVW_UABS_G3: 269>
NONE = <RELOCATION_AARCH64.NONE: 0>
PREL16 = <RELOCATION_AARCH64.PREL16: 262>
PREL32 = <RELOCATION_AARCH64.PREL32: 261>
PREL64 = <RELOCATION_AARCH64.PREL64: 260>
RELATIVE = <RELOCATION_AARCH64.RELATIVE: 1027>
TLSDESC = <RELOCATION_AARCH64.TLSDESC: 1031>
TLSDESC_ADD = <RELOCATION_AARCH64.TLSDESC_ADD: 568>
TLSDESC_ADD_LO12_NC = <RELOCATION_AARCH64.TLSDESC_ADD_LO12_NC: 564>
TLSDESC_ADR_PAGE21 = <RELOCATION_AARCH64.TLSDESC_ADR_PAGE21: 562>
TLSDESC_ADR_PREL21 = <RELOCATION_AARCH64.TLSDESC_ADR_PREL21: 561>
TLSDESC_CALL = <RELOCATION_AARCH64.TLSDESC_CALL: 569>
TLSDESC_LD64_LO12_NC = <RELOCATION_AARCH64.TLSDESC_LD64_LO12_NC: 563>
TLSDESC_LDR = <RELOCATION_AARCH64.TLSDESC_LDR: 567>
TLSDESC_LD_PREL19 = <RELOCATION_AARCH64.TLSDESC_LD_PREL19: 560>
TLSDESC_OFF_G0_NC = <RELOCATION_AARCH64.TLSDESC_OFF_G0_NC: 566>
TLSDESC_OFF_G1 = <RELOCATION_AARCH64.TLSDESC_OFF_G1: 565>
TLSGD_ADD_LO12_NC = <RELOCATION_AARCH64.TLSGD_ADD_LO12_NC: 514>
TLSGD_ADR_PAGE21 = <RELOCATION_AARCH64.TLSGD_ADR_PAGE21: 513>
TLSGD_ADR_PREL21 = <RELOCATION_AARCH64.TLSGD_ADR_PREL21: 512>
TLSGD_MOVW_G0_NC = <RELOCATION_AARCH64.TLSGD_MOVW_G0_NC: 516>
TLSGD_MOVW_G1 = <RELOCATION_AARCH64.TLSGD_MOVW_G1: 515>
TLSIE_ADR_GOTTPREL_PAGE21 = <RELOCATION_AARCH64.TLSIE_ADR_GOTTPREL_PAGE21: 541>
TLSIE_LD64_GOTTPREL_LO12_NC = <RELOCATION_AARCH64.TLSIE_LD64_GOTTPREL_LO12_NC: 542>
TLSIE_LD_GOTTPREL_PREL19 = <RELOCATION_AARCH64.TLSIE_LD_GOTTPREL_PREL19: 543>
TLSIE_MOVW_GOTTPREL_G0_NC = <RELOCATION_AARCH64.TLSIE_MOVW_GOTTPREL_G0_NC: 540>
TLSIE_MOVW_GOTTPREL_G1 = <RELOCATION_AARCH64.TLSIE_MOVW_GOTTPREL_G1: 539>
TLSLD_ADD_DTPREL_HI12 = <RELOCATION_AARCH64.TLSLD_ADD_DTPREL_HI12: 528>
TLSLD_ADD_DTPREL_LO12 = <RELOCATION_AARCH64.TLSLD_ADD_DTPREL_LO12: 529>
TLSLD_ADD_DTPREL_LO12_NC = <RELOCATION_AARCH64.TLSLD_ADD_DTPREL_LO12_NC: 530>
TLSLD_ADD_LO12_NC = <RELOCATION_AARCH64.TLSLD_ADD_LO12_NC: 519>
TLSLD_ADR_PAGE21 = <RELOCATION_AARCH64.TLSLD_ADR_PAGE21: 518>
TLSLD_ADR_PREL21 = <RELOCATION_AARCH64.TLSLD_ADR_PREL21: 517>
TLSLD_LDST128_DTPREL_LO12 = <RELOCATION_AARCH64.TLSLD_LDST128_DTPREL_LO12: 572>
TLSLD_LDST128_DTPREL_LO12_NC = <RELOCATION_AARCH64.TLSLD_LDST128_DTPREL_LO12_NC: 573>
TLSLD_LDST16_DTPREL_LO12 = <RELOCATION_AARCH64.TLSLD_LDST16_DTPREL_LO12: 533>
TLSLD_LDST16_DTPREL_LO12_NC = <RELOCATION_AARCH64.TLSLD_LDST16_DTPREL_LO12_NC: 534>
TLSLD_LDST32_DTPREL_LO12 = <RELOCATION_AARCH64.TLSLD_LDST32_DTPREL_LO12: 535>
TLSLD_LDST32_DTPREL_LO12_NC = <RELOCATION_AARCH64.TLSLD_LDST32_DTPREL_LO12_NC: 536>
TLSLD_LDST64_DTPREL_LO12 = <RELOCATION_AARCH64.TLSLD_LDST64_DTPREL_LO12: 537>
TLSLD_LDST64_DTPREL_LO12_NC = <RELOCATION_AARCH64.TLSLD_LDST64_DTPREL_LO12_NC: 538>
TLSLD_LDST8_DTPREL_LO12 = <RELOCATION_AARCH64.TLSLD_LDST8_DTPREL_LO12: 531>
TLSLD_LDST8_DTPREL_LO12_NC = <RELOCATION_AARCH64.TLSLD_LDST8_DTPREL_LO12_NC: 532>
TLSLD_LD_PREL19 = <RELOCATION_AARCH64.TLSLD_LD_PREL19: 522>
TLSLD_MOVW_DTPREL_G0 = <RELOCATION_AARCH64.TLSLD_MOVW_DTPREL_G0: 526>
TLSLD_MOVW_DTPREL_G0_NC = <RELOCATION_AARCH64.TLSLD_MOVW_DTPREL_G0_NC: 527>
TLSLD_MOVW_DTPREL_G1 = <RELOCATION_AARCH64.TLSLD_MOVW_DTPREL_G1: 524>
TLSLD_MOVW_DTPREL_G1_NC = <RELOCATION_AARCH64.TLSLD_MOVW_DTPREL_G1_NC: 525>
TLSLD_MOVW_DTPREL_G2 = <RELOCATION_AARCH64.TLSLD_MOVW_DTPREL_G2: 523>
TLSLD_MOVW_G0_NC = <RELOCATION_AARCH64.TLSLD_MOVW_G0_NC: 521>
TLSLD_MOVW_G1 = <RELOCATION_AARCH64.TLSLD_MOVW_G1: 520>
TLSLE_ADD_TPREL_HI12 = <RELOCATION_AARCH64.TLSLE_ADD_TPREL_HI12: 549>
TLSLE_ADD_TPREL_LO12 = <RELOCATION_AARCH64.TLSLE_ADD_TPREL_LO12: 550>
TLSLE_ADD_TPREL_LO12_NC = <RELOCATION_AARCH64.TLSLE_ADD_TPREL_LO12_NC: 551>
TLSLE_LDST128_TPREL_LO12 = <RELOCATION_AARCH64.TLSLE_LDST128_TPREL_LO12: 570>
TLSLE_LDST128_TPREL_LO12_NC = <RELOCATION_AARCH64.TLSLE_LDST128_TPREL_LO12_NC: 571>
TLSLE_LDST16_TPREL_LO12 = <RELOCATION_AARCH64.TLSLE_LDST16_TPREL_LO12: 554>
TLSLE_LDST16_TPREL_LO12_NC = <RELOCATION_AARCH64.TLSLE_LDST16_TPREL_LO12_NC: 555>
TLSLE_LDST32_TPREL_LO12 = <RELOCATION_AARCH64.TLSLE_LDST32_TPREL_LO12: 556>
TLSLE_LDST32_TPREL_LO12_NC = <RELOCATION_AARCH64.TLSLE_LDST32_TPREL_LO12_NC: 557>
TLSLE_LDST64_TPREL_LO12 = <RELOCATION_AARCH64.TLSLE_LDST64_TPREL_LO12: 558>
TLSLE_LDST64_TPREL_LO12_NC = <RELOCATION_AARCH64.TLSLE_LDST64_TPREL_LO12_NC: 559>
TLSLE_LDST8_TPREL_LO12 = <RELOCATION_AARCH64.TLSLE_LDST8_TPREL_LO12: 552>
TLSLE_LDST8_TPREL_LO12_NC = <RELOCATION_AARCH64.TLSLE_LDST8_TPREL_LO12_NC: 553>
TLSLE_MOVW_TPREL_G0 = <RELOCATION_AARCH64.TLSLE_MOVW_TPREL_G0: 547>
TLSLE_MOVW_TPREL_G0_NC = <RELOCATION_AARCH64.TLSLE_MOVW_TPREL_G0_NC: 548>
TLSLE_MOVW_TPREL_G1 = <RELOCATION_AARCH64.TLSLE_MOVW_TPREL_G1: 545>
TLSLE_MOVW_TPREL_G1_NC = <RELOCATION_AARCH64.TLSLE_MOVW_TPREL_G1_NC: 546>
TLSLE_MOVW_TPREL_G2 = <RELOCATION_AARCH64.TLSLE_MOVW_TPREL_G2: 544>
TLS_DTPMOD64 = <RELOCATION_AARCH64.TLS_DTPMOD64: 1029>
TLS_DTPREL64 = <RELOCATION_AARCH64.TLS_DTPREL64: 1028>
TLS_TPREL64 = <RELOCATION_AARCH64.TLS_TPREL64: 1030>
TSTBR14 = <RELOCATION_AARCH64.TSTBR14: 279>
property name
property value

Relocations MIPS

class lief.ELF.RELOCATION_MIPS(self: lief.ELF.RELOCATION_MIPS, value: int) None

Members:

MIPS_NONE

MIPS16_16

MIPS_32

MIPS_REL32

MIPS_26

MIPS_HI16

MIPS_LO16

MIPS_GPREL16

MIPS_LITERAL

MIPS_GOT16

MIPS_PC16

MIPS_CALL16

MIPS_GPREL32

MIPS_UNUSED1

MIPS_UNUSED2

MIPS_UNUSED3

MIPS_SHIFT5

MIPS_SHIFT6

MIPS_64

MIPS_GOT_DISP

MIPS_GOT_PAGE

MIPS_GOT_OFST

MIPS_GOT_HI16

MIPS_GOT_LO16

MIPS_SUB

MIPS_INSERT_A

MIPS_INSERT_B

MIPS_DELETE

MIPS_HIGHER

MIPS_HIGHEST

MIPS_CALL_HI16

MIPS_CALL_LO16

MIPS_SCN_DISP

MIPS_REL16

MIPS_ADD_IMMEDIATE

MIPS_PJUMP

MIPS_RELGOT

MIPS_JALR

MIPS_TLS_DTPMOD32

MIPS_TLS_DTPREL32

MIPS_TLS_DTPMOD64

MIPS_TLS_DTPREL64

MIPS_TLS_GD

MIPS_TLS_LDM

MIPS_TLS_DTPREL_HI16

MIPS_TLS_DTPREL_LO16

MIPS_TLS_GOTTPREL

MIPS_TLS_TPREL32

MIPS_TLS_TPREL64

MIPS_TLS_TPREL_HI16

MIPS_TLS_TPREL_LO16

MIPS_GLOB_DAT

MIPS_PC21_S2

MIPS_PC26_S2

MIPS_PC18_S3

MIPS_PC19_S2

MIPS_PCHI16

MIPS_PCLO16

MIPS16_26

MIPS16_GPREL

MIPS16_GOT16

MIPS16_CALL16

MIPS16_HI16

MIPS16_LO16

MIPS16_TLS_GD

MIPS16_TLS_LDM

MIPS16_TLS_DTPREL_HI16

MIPS16_TLS_DTPREL_LO16

MIPS16_TLS_GOTTPREL

MIPS16_TLS_TPREL_HI16

MIPS16_TLS_TPREL_LO16

MIPS_COPY

MIPS_JUMP_SLOT

MIRCRO_MIPS_26_S1

MIRCRO_MIPS_HI16

MIRCRO_MIPS_LO16

MIRCRO_MIPS_GPREL16

MIRCRO_MIPS_LITERAL

MIRCRO_MIPS_GOT16

MIRCRO_MIPS_PC7_S1

MIRCRO_MIPS_PC10_S1

MIRCRO_MIPS_PC16_S1

MIRCRO_MIPS_CALL16

MIRCRO_MIPS_GOT_DISP

MIRCRO_MIPS_GOT_PAGE

MIRCRO_MIPS_GOT_OFST

MIRCRO_MIPS_GOT_HI16

MIRCRO_MIPS_GOT_LO16

MIRCRO_MIPS_SUB

MIRCRO_MIPS_HIGHER

MIRCRO_MIPS_HIGHEST

MIRCRO_MIPS_CALL_HI16

MIRCRO_MIPS_CALL_LO16

MIRCRO_MIPS_SCN_DISP

MIRCRO_MIPS_JALR

MIRCRO_MIPS_HI0_LO16

MIRCRO_MIPS_TLS_GD

MIRCRO_MIPS_TLS_LDM

MIRCRO_MIPS_TLS_DTPREL_HI16

MIRCRO_MIPS_TLS_DTPREL_LO16

MIRCRO_MIPS_TLS_GOTTPREL

MIRCRO_MIPS_TLS_TPREL_HI16

MIRCRO_MIPS_TLS_TPREL_LO16

MIRCRO_MIPS_GPREL7_S2

MIRCRO_MIPS_PC23_S2

MIRCRO_MIPS_PC21_S2

MIRCRO_MIPS_PC26_S2

MIRCRO_MIPS_PC18_S3

MIRCRO_MIPS_PC19_S2

MIPS16_16 = <RELOCATION_MIPS.MIPS16_16: 1>
MIPS16_26 = <RELOCATION_MIPS.MIPS16_26: 100>
MIPS16_CALL16 = <RELOCATION_MIPS.MIPS16_CALL16: 103>
MIPS16_GOT16 = <RELOCATION_MIPS.MIPS16_GOT16: 102>
MIPS16_GPREL = <RELOCATION_MIPS.MIPS16_GPREL: 101>
MIPS16_HI16 = <RELOCATION_MIPS.MIPS16_HI16: 104>
MIPS16_LO16 = <RELOCATION_MIPS.MIPS16_LO16: 105>
MIPS16_TLS_DTPREL_HI16 = <RELOCATION_MIPS.MIPS16_TLS_DTPREL_HI16: 108>
MIPS16_TLS_DTPREL_LO16 = <RELOCATION_MIPS.MIPS16_TLS_DTPREL_LO16: 109>
MIPS16_TLS_GD = <RELOCATION_MIPS.MIPS16_TLS_GD: 106>
MIPS16_TLS_GOTTPREL = <RELOCATION_MIPS.MIPS16_TLS_GOTTPREL: 110>
MIPS16_TLS_LDM = <RELOCATION_MIPS.MIPS16_TLS_LDM: 107>
MIPS16_TLS_TPREL_HI16 = <RELOCATION_MIPS.MIPS16_TLS_TPREL_HI16: 111>
MIPS16_TLS_TPREL_LO16 = <RELOCATION_MIPS.MIPS16_TLS_TPREL_LO16: 112>
MIPS_26 = <RELOCATION_MIPS.MIPS_26: 4>
MIPS_32 = <RELOCATION_MIPS.MIPS_32: 2>
MIPS_64 = <RELOCATION_MIPS.MIPS_64: 18>
MIPS_ADD_IMMEDIATE = <RELOCATION_MIPS.MIPS_ADD_IMMEDIATE: 34>
MIPS_CALL16 = <RELOCATION_MIPS.MIPS_CALL16: 11>
MIPS_CALL_HI16 = <RELOCATION_MIPS.MIPS_CALL_HI16: 30>
MIPS_CALL_LO16 = <RELOCATION_MIPS.MIPS_CALL_LO16: 31>
MIPS_COPY = <RELOCATION_MIPS.MIPS_COPY: 126>
MIPS_DELETE = <RELOCATION_MIPS.MIPS_DELETE: 27>
MIPS_GLOB_DAT = <RELOCATION_MIPS.MIPS_GLOB_DAT: 51>
MIPS_GOT16 = <RELOCATION_MIPS.MIPS_GOT16: 9>
MIPS_GOT_DISP = <RELOCATION_MIPS.MIPS_GOT_DISP: 19>
MIPS_GOT_HI16 = <RELOCATION_MIPS.MIPS_GOT_HI16: 22>
MIPS_GOT_LO16 = <RELOCATION_MIPS.MIPS_GOT_LO16: 23>
MIPS_GOT_OFST = <RELOCATION_MIPS.MIPS_GOT_OFST: 21>
MIPS_GOT_PAGE = <RELOCATION_MIPS.MIPS_GOT_PAGE: 20>
MIPS_GPREL16 = <RELOCATION_MIPS.MIPS_GPREL16: 7>
MIPS_GPREL32 = <RELOCATION_MIPS.MIPS_GPREL32: 12>
MIPS_HI16 = <RELOCATION_MIPS.MIPS_HI16: 5>
MIPS_HIGHER = <RELOCATION_MIPS.MIPS_HIGHER: 28>
MIPS_HIGHEST = <RELOCATION_MIPS.MIPS_HIGHEST: 29>
MIPS_INSERT_A = <RELOCATION_MIPS.MIPS_INSERT_A: 25>
MIPS_INSERT_B = <RELOCATION_MIPS.MIPS_INSERT_B: 26>
MIPS_JALR = <RELOCATION_MIPS.MIPS_JALR: 37>
MIPS_JUMP_SLOT = <RELOCATION_MIPS.MIPS_JUMP_SLOT: 127>
MIPS_LITERAL = <RELOCATION_MIPS.MIPS_LITERAL: 8>
MIPS_LO16 = <RELOCATION_MIPS.MIPS_LO16: 6>
MIPS_NONE = <RELOCATION_MIPS.MIPS_NONE: 0>
MIPS_PC16 = <RELOCATION_MIPS.MIPS_PC16: 10>
MIPS_PC18_S3 = <RELOCATION_MIPS.MIPS_PC18_S3: 62>
MIPS_PC19_S2 = <RELOCATION_MIPS.MIPS_PC19_S2: 63>
MIPS_PC21_S2 = <RELOCATION_MIPS.MIPS_PC21_S2: 60>
MIPS_PC26_S2 = <RELOCATION_MIPS.MIPS_PC26_S2: 61>
MIPS_PCHI16 = <RELOCATION_MIPS.MIPS_PCHI16: 64>
MIPS_PCLO16 = <RELOCATION_MIPS.MIPS_PCLO16: 65>
MIPS_PJUMP = <RELOCATION_MIPS.MIPS_PJUMP: 35>
MIPS_REL16 = <RELOCATION_MIPS.MIPS_REL16: 33>
MIPS_REL32 = <RELOCATION_MIPS.MIPS_REL32: 3>
MIPS_RELGOT = <RELOCATION_MIPS.MIPS_RELGOT: 36>
MIPS_SCN_DISP = <RELOCATION_MIPS.MIPS_SCN_DISP: 32>
MIPS_SHIFT5 = <RELOCATION_MIPS.MIPS_SHIFT5: 16>
MIPS_SHIFT6 = <RELOCATION_MIPS.MIPS_SHIFT6: 17>
MIPS_SUB = <RELOCATION_MIPS.MIPS_SUB: 24>
MIPS_TLS_DTPMOD32 = <RELOCATION_MIPS.MIPS_TLS_DTPMOD32: 38>
MIPS_TLS_DTPMOD64 = <RELOCATION_MIPS.MIPS_TLS_DTPMOD64: 40>
MIPS_TLS_DTPREL32 = <RELOCATION_MIPS.MIPS_TLS_DTPREL32: 39>
MIPS_TLS_DTPREL64 = <RELOCATION_MIPS.MIPS_TLS_DTPREL64: 41>
MIPS_TLS_DTPREL_HI16 = <RELOCATION_MIPS.MIPS_TLS_DTPREL_HI16: 44>
MIPS_TLS_DTPREL_LO16 = <RELOCATION_MIPS.MIPS_TLS_DTPREL_LO16: 45>
MIPS_TLS_GD = <RELOCATION_MIPS.MIPS_TLS_GD: 42>
MIPS_TLS_GOTTPREL = <RELOCATION_MIPS.MIPS_TLS_GOTTPREL: 46>
MIPS_TLS_LDM = <RELOCATION_MIPS.MIPS_TLS_LDM: 43>
MIPS_TLS_TPREL32 = <RELOCATION_MIPS.MIPS_TLS_TPREL32: 47>
MIPS_TLS_TPREL64 = <RELOCATION_MIPS.MIPS_TLS_TPREL64: 48>
MIPS_TLS_TPREL_HI16 = <RELOCATION_MIPS.MIPS_TLS_TPREL_HI16: 49>
MIPS_TLS_TPREL_LO16 = <RELOCATION_MIPS.MIPS_TLS_TPREL_LO16: 50>
MIPS_UNUSED1 = <RELOCATION_MIPS.MIPS_UNUSED1: 13>
MIPS_UNUSED2 = <RELOCATION_MIPS.MIPS_UNUSED2: 14>
MIPS_UNUSED3 = <RELOCATION_MIPS.MIPS_UNUSED3: 15>
MIRCRO_MIPS_26_S1 = <RELOCATION_MIPS.MIRCRO_MIPS_26_S1: 133>
MIRCRO_MIPS_CALL16 = <RELOCATION_MIPS.MIRCRO_MIPS_CALL16: 142>
MIRCRO_MIPS_CALL_HI16 = <RELOCATION_MIPS.MIRCRO_MIPS_CALL_HI16: 153>
MIRCRO_MIPS_CALL_LO16 = <RELOCATION_MIPS.MIRCRO_MIPS_CALL_LO16: 154>
MIRCRO_MIPS_GOT16 = <RELOCATION_MIPS.MIRCRO_MIPS_GOT16: 138>
MIRCRO_MIPS_GOT_DISP = <RELOCATION_MIPS.MIRCRO_MIPS_GOT_DISP: 145>
MIRCRO_MIPS_GOT_HI16 = <RELOCATION_MIPS.MIRCRO_MIPS_GOT_HI16: 148>
MIRCRO_MIPS_GOT_LO16 = <RELOCATION_MIPS.MIRCRO_MIPS_GOT_LO16: 149>
MIRCRO_MIPS_GOT_OFST = <RELOCATION_MIPS.MIRCRO_MIPS_GOT_OFST: 147>
MIRCRO_MIPS_GOT_PAGE = <RELOCATION_MIPS.MIRCRO_MIPS_GOT_PAGE: 146>
MIRCRO_MIPS_GPREL16 = <RELOCATION_MIPS.MIRCRO_MIPS_GPREL16: 136>
MIRCRO_MIPS_GPREL7_S2 = <RELOCATION_MIPS.MIRCRO_MIPS_GPREL7_S2: 172>
MIRCRO_MIPS_HI0_LO16 = <RELOCATION_MIPS.MIRCRO_MIPS_HI0_LO16: 157>
MIRCRO_MIPS_HI16 = <RELOCATION_MIPS.MIRCRO_MIPS_HI16: 134>
MIRCRO_MIPS_HIGHER = <RELOCATION_MIPS.MIRCRO_MIPS_HIGHER: 151>
MIRCRO_MIPS_HIGHEST = <RELOCATION_MIPS.MIRCRO_MIPS_HIGHEST: 152>
MIRCRO_MIPS_JALR = <RELOCATION_MIPS.MIRCRO_MIPS_JALR: 156>
MIRCRO_MIPS_LITERAL = <RELOCATION_MIPS.MIRCRO_MIPS_LITERAL: 137>
MIRCRO_MIPS_LO16 = <RELOCATION_MIPS.MIRCRO_MIPS_LO16: 135>
MIRCRO_MIPS_PC10_S1 = <RELOCATION_MIPS.MIRCRO_MIPS_PC10_S1: 140>
MIRCRO_MIPS_PC16_S1 = <RELOCATION_MIPS.MIRCRO_MIPS_PC16_S1: 141>
MIRCRO_MIPS_PC18_S3 = <RELOCATION_MIPS.MIRCRO_MIPS_PC18_S3: 176>
MIRCRO_MIPS_PC19_S2 = <RELOCATION_MIPS.MIRCRO_MIPS_PC19_S2: 177>
MIRCRO_MIPS_PC21_S2 = <RELOCATION_MIPS.MIRCRO_MIPS_PC21_S2: 174>
MIRCRO_MIPS_PC23_S2 = <RELOCATION_MIPS.MIRCRO_MIPS_PC23_S2: 173>
MIRCRO_MIPS_PC26_S2 = <RELOCATION_MIPS.MIRCRO_MIPS_PC26_S2: 175>
MIRCRO_MIPS_PC7_S1 = <RELOCATION_MIPS.MIRCRO_MIPS_PC7_S1: 139>
MIRCRO_MIPS_SCN_DISP = <RELOCATION_MIPS.MIRCRO_MIPS_SCN_DISP: 155>
MIRCRO_MIPS_SUB = <RELOCATION_MIPS.MIRCRO_MIPS_SUB: 150>
MIRCRO_MIPS_TLS_DTPREL_HI16 = <RELOCATION_MIPS.MIRCRO_MIPS_TLS_DTPREL_HI16: 164>
MIRCRO_MIPS_TLS_DTPREL_LO16 = <RELOCATION_MIPS.MIRCRO_MIPS_TLS_DTPREL_LO16: 165>
MIRCRO_MIPS_TLS_GD = <RELOCATION_MIPS.MIRCRO_MIPS_TLS_GD: 162>
MIRCRO_MIPS_TLS_GOTTPREL = <RELOCATION_MIPS.MIRCRO_MIPS_TLS_GOTTPREL: 166>
MIRCRO_MIPS_TLS_LDM = <RELOCATION_MIPS.MIRCRO_MIPS_TLS_LDM: 163>
MIRCRO_MIPS_TLS_TPREL_HI16 = <RELOCATION_MIPS.MIRCRO_MIPS_TLS_TPREL_HI16: 169>
MIRCRO_MIPS_TLS_TPREL_LO16 = <RELOCATION_MIPS.MIRCRO_MIPS_TLS_TPREL_LO16: 170>
property name
property value

Relocations PPC

class lief.ELF.RELOCATION_PPC(self: lief.ELF.RELOCATION_PPC, value: int) None

Members:

NONE

ADDR32

ADDR24

ADDR16

ADDR16_LO

ADDR16_HI

ADDR16_HA

ADDR14

ADDR14_BRTAKEN

ADDR14_BRNTAKEN

REL24

REL14

REL14_BRTAKEN

REL14_BRNTAKEN

GOT16

GOT16_LO

GOT16_HI

GOT16_HA

PLTREL24

JMP_SLOT

RELATIVE

LOCAL24PC

REL32

TLS

DTPMOD32

TPREL16

TPREL16_LO

TPREL16_HI

TPREL16_HA

TPREL32

DTPREL16

DTPREL16_LO

DTPREL16_HI

DTPREL16_HA

DTPREL32

GOT_TLSGD16

GOT_TLSGD16_LO

GOT_TLSGD16_HI

GOT_TLSGD16_HA

GOT_TLSLD16

GOT_TLSLD16_LO

GOT_TLSLD16_HI

GOT_TLSLD16_HA

GOT_TPREL16

GOT_TPREL16_LO

GOT_TPREL16_HI

GOT_TPREL16_HA

GOT_DTPREL16

GOT_DTPREL16_LO

GOT_DTPREL16_HI

GOT_DTPREL16_HA

TLSGD

TLSLD

REL16

REL16_LO

REL16_HI

REL16_HA

ADDR14 = <RELOCATION_PPC.ADDR14: 7>
ADDR14_BRNTAKEN = <RELOCATION_PPC.ADDR14_BRNTAKEN: 9>
ADDR14_BRTAKEN = <RELOCATION_PPC.ADDR14_BRTAKEN: 8>
ADDR16 = <RELOCATION_PPC.ADDR16: 3>
ADDR16_HA = <RELOCATION_PPC.ADDR16_HA: 6>
ADDR16_HI = <RELOCATION_PPC.ADDR16_HI: 5>
ADDR16_LO = <RELOCATION_PPC.ADDR16_LO: 4>
ADDR24 = <RELOCATION_PPC.ADDR24: 2>
ADDR32 = <RELOCATION_PPC.ADDR32: 1>
DTPMOD32 = <RELOCATION_PPC.DTPMOD32: 68>
DTPREL16 = <RELOCATION_PPC.DTPREL16: 74>
DTPREL16_HA = <RELOCATION_PPC.DTPREL16_HA: 77>
DTPREL16_HI = <RELOCATION_PPC.DTPREL16_HI: 76>
DTPREL16_LO = <RELOCATION_PPC.DTPREL16_LO: 75>
DTPREL32 = <RELOCATION_PPC.DTPREL32: 78>
GOT16 = <RELOCATION_PPC.GOT16: 14>
GOT16_HA = <RELOCATION_PPC.GOT16_HA: 17>
GOT16_HI = <RELOCATION_PPC.GOT16_HI: 16>
GOT16_LO = <RELOCATION_PPC.GOT16_LO: 15>
GOT_DTPREL16 = <RELOCATION_PPC.GOT_DTPREL16: 91>
GOT_DTPREL16_HA = <RELOCATION_PPC.GOT_DTPREL16_HA: 94>
GOT_DTPREL16_HI = <RELOCATION_PPC.GOT_DTPREL16_HI: 93>
GOT_DTPREL16_LO = <RELOCATION_PPC.GOT_DTPREL16_LO: 92>
GOT_TLSGD16 = <RELOCATION_PPC.GOT_TLSGD16: 79>
GOT_TLSGD16_HA = <RELOCATION_PPC.GOT_TLSGD16_HA: 82>
GOT_TLSGD16_HI = <RELOCATION_PPC.GOT_TLSGD16_HI: 81>
GOT_TLSGD16_LO = <RELOCATION_PPC.GOT_TLSGD16_LO: 80>
GOT_TLSLD16 = <RELOCATION_PPC.GOT_TLSLD16: 83>
GOT_TLSLD16_HA = <RELOCATION_PPC.GOT_TLSLD16_HA: 86>
GOT_TLSLD16_HI = <RELOCATION_PPC.GOT_TLSLD16_HI: 85>
GOT_TLSLD16_LO = <RELOCATION_PPC.GOT_TLSLD16_LO: 84>
GOT_TPREL16 = <RELOCATION_PPC.GOT_TPREL16: 87>
GOT_TPREL16_HA = <RELOCATION_PPC.GOT_TPREL16_HA: 90>
GOT_TPREL16_HI = <RELOCATION_PPC.GOT_TPREL16_HI: 89>
GOT_TPREL16_LO = <RELOCATION_PPC.GOT_TPREL16_LO: 88>
JMP_SLOT = <RELOCATION_PPC.JMP_SLOT: 21>
LOCAL24PC = <RELOCATION_PPC.LOCAL24PC: 23>
NONE = <RELOCATION_PPC.NONE: 0>
PLTREL24 = <RELOCATION_PPC.PLTREL24: 18>
REL14 = <RELOCATION_PPC.REL14: 11>
REL14_BRNTAKEN = <RELOCATION_PPC.REL14_BRNTAKEN: 13>
REL14_BRTAKEN = <RELOCATION_PPC.REL14_BRTAKEN: 12>
REL16 = <RELOCATION_PPC.REL16: 249>
REL16_HA = <RELOCATION_PPC.REL16_HA: 252>
REL16_HI = <RELOCATION_PPC.REL16_HI: 251>
REL16_LO = <RELOCATION_PPC.REL16_LO: 250>
REL24 = <RELOCATION_PPC.REL24: 10>
REL32 = <RELOCATION_PPC.REL32: 26>
RELATIVE = <RELOCATION_PPC.RELATIVE: 22>
TLS = <RELOCATION_PPC.TLS: 67>
TLSGD = <RELOCATION_PPC.TLSGD: 95>
TLSLD = <RELOCATION_PPC.TLSLD: 96>
TPREL16 = <RELOCATION_PPC.TPREL16: 69>
TPREL16_HA = <RELOCATION_PPC.TPREL16_HA: 72>
TPREL16_HI = <RELOCATION_PPC.TPREL16_HI: 71>
TPREL16_LO = <RELOCATION_PPC.TPREL16_LO: 70>
TPREL32 = <RELOCATION_PPC.TPREL32: 73>
property name
property value

Relocations PPC64

class lief.ELF.RELOCATION_PPC64(self: lief.ELF.RELOCATION_PPC64, value: int) None

Members:

NONE

ADDR32

ADDR24

ADDR16

ADDR16_LO

ADDR16_HI

ADDR16_HA

ADDR14

ADDR14_BRTAKEN

ADDR14_BRNTAKEN

REL24

REL14

REL14_BRTAKEN

REL14_BRNTAKEN

GOT16

GOT16_LO

GOT16_HI

GOT16_HA

JMP_SLOT

RELATIVE

REL32

ADDR64

ADDR16_HIGHER

ADDR16_HIGHERA

ADDR16_HIGHEST

ADDR16_HIGHESTA

REL64

TOC16

TOC16_LO

TOC16_HI

TOC16_HA

TOC

ADDR16_DS

ADDR16_LO_DS

GOT16_DS

GOT16_LO_DS

TOC16_DS

TOC16_LO_DS

TLS

DTPMOD64

TPREL16

TPREL16_LO

TPREL16_HI

TPREL16_HA

TPREL64

DTPREL16

DTPREL16_LO

DTPREL16_HI

DTPREL16_HA

DTPREL64

GOT_TLSGD16

GOT_TLSGD16_LO

GOT_TLSGD16_HI

GOT_TLSGD16_HA

GOT_TLSLD16

GOT_TLSLD16_LO

GOT_TLSLD16_HI

GOT_TLSLD16_HA

GOT_TPREL16_DS

GOT_TPREL16_LO_DS

GOT_TPREL16_HI

GOT_TPREL16_HA

GOT_DTPREL16_DS

GOT_DTPREL16_LO_DS

GOT_DTPREL16_HI

GOT_DTPREL16_HA

TPREL16_DS

TPREL16_LO_DS

TPREL16_HIGHER

TPREL16_HIGHERA

TPREL16_HIGHEST

TPREL16_HIGHESTA

DTPREL16_DS

DTPREL16_LO_DS

DTPREL16_HIGHER

DTPREL16_HIGHERA

DTPREL16_HIGHEST

DTPREL16_HIGHESTA

TLSGD

TLSLD

REL16

REL16_LO

REL16_HI

REL16_HA

ADDR14 = <RELOCATION_PPC64.ADDR14: 7>
ADDR14_BRNTAKEN = <RELOCATION_PPC64.ADDR14_BRNTAKEN: 9>
ADDR14_BRTAKEN = <RELOCATION_PPC64.ADDR14_BRTAKEN: 8>
ADDR16 = <RELOCATION_PPC64.ADDR16: 3>
ADDR16_DS = <RELOCATION_PPC64.ADDR16_DS: 56>
ADDR16_HA = <RELOCATION_PPC64.ADDR16_HA: 6>
ADDR16_HI = <RELOCATION_PPC64.ADDR16_HI: 5>
ADDR16_HIGHER = <RELOCATION_PPC64.ADDR16_HIGHER: 39>
ADDR16_HIGHERA = <RELOCATION_PPC64.ADDR16_HIGHERA: 40>
ADDR16_HIGHEST = <RELOCATION_PPC64.ADDR16_HIGHEST: 41>
ADDR16_HIGHESTA = <RELOCATION_PPC64.ADDR16_HIGHESTA: 42>
ADDR16_LO = <RELOCATION_PPC64.ADDR16_LO: 4>
ADDR16_LO_DS = <RELOCATION_PPC64.ADDR16_LO_DS: 57>
ADDR24 = <RELOCATION_PPC64.ADDR24: 2>
ADDR32 = <RELOCATION_PPC64.ADDR32: 1>
ADDR64 = <RELOCATION_PPC64.ADDR64: 38>
DTPMOD64 = <RELOCATION_PPC64.DTPMOD64: 68>
DTPREL16 = <RELOCATION_PPC64.DTPREL16: 74>
DTPREL16_DS = <RELOCATION_PPC64.DTPREL16_DS: 101>
DTPREL16_HA = <RELOCATION_PPC64.DTPREL16_HA: 77>
DTPREL16_HI = <RELOCATION_PPC64.DTPREL16_HI: 76>
DTPREL16_HIGHER = <RELOCATION_PPC64.DTPREL16_HIGHER: 103>
DTPREL16_HIGHERA = <RELOCATION_PPC64.DTPREL16_HIGHERA: 104>
DTPREL16_HIGHEST = <RELOCATION_PPC64.DTPREL16_HIGHEST: 105>
DTPREL16_HIGHESTA = <RELOCATION_PPC64.DTPREL16_HIGHESTA: 106>
DTPREL16_LO = <RELOCATION_PPC64.DTPREL16_LO: 75>
DTPREL16_LO_DS = <RELOCATION_PPC64.DTPREL16_LO_DS: 102>
DTPREL64 = <RELOCATION_PPC64.DTPREL64: 78>
GOT16 = <RELOCATION_PPC64.GOT16: 14>
GOT16_DS = <RELOCATION_PPC64.GOT16_DS: 58>
GOT16_HA = <RELOCATION_PPC64.GOT16_HA: 17>
GOT16_HI = <RELOCATION_PPC64.GOT16_HI: 16>
GOT16_LO = <RELOCATION_PPC64.GOT16_LO: 15>
GOT16_LO_DS = <RELOCATION_PPC64.GOT16_LO_DS: 59>
GOT_DTPREL16_DS = <RELOCATION_PPC64.GOT_DTPREL16_DS: 91>
GOT_DTPREL16_HA = <RELOCATION_PPC64.GOT_DTPREL16_HA: 94>
GOT_DTPREL16_HI = <RELOCATION_PPC64.GOT_DTPREL16_HI: 93>
GOT_DTPREL16_LO_DS = <RELOCATION_PPC64.GOT_DTPREL16_LO_DS: 92>
GOT_TLSGD16 = <RELOCATION_PPC64.GOT_TLSGD16: 79>
GOT_TLSGD16_HA = <RELOCATION_PPC64.GOT_TLSGD16_HA: 82>
GOT_TLSGD16_HI = <RELOCATION_PPC64.GOT_TLSGD16_HI: 81>
GOT_TLSGD16_LO = <RELOCATION_PPC64.GOT_TLSGD16_LO: 80>
GOT_TLSLD16 = <RELOCATION_PPC64.GOT_TLSLD16: 83>
GOT_TLSLD16_HA = <RELOCATION_PPC64.GOT_TLSLD16_HA: 86>
GOT_TLSLD16_HI = <RELOCATION_PPC64.GOT_TLSLD16_HI: 85>
GOT_TLSLD16_LO = <RELOCATION_PPC64.GOT_TLSLD16_LO: 84>
GOT_TPREL16_DS = <RELOCATION_PPC64.GOT_TPREL16_DS: 87>
GOT_TPREL16_HA = <RELOCATION_PPC64.GOT_TPREL16_HA: 90>
GOT_TPREL16_HI = <RELOCATION_PPC64.GOT_TPREL16_HI: 89>
GOT_TPREL16_LO_DS = <RELOCATION_PPC64.GOT_TPREL16_LO_DS: 88>
JMP_SLOT = <RELOCATION_PPC64.JMP_SLOT: 21>
NONE = <RELOCATION_PPC64.NONE: 0>
REL14 = <RELOCATION_PPC64.REL14: 11>
REL14_BRNTAKEN = <RELOCATION_PPC64.REL14_BRNTAKEN: 13>
REL14_BRTAKEN = <RELOCATION_PPC64.REL14_BRTAKEN: 12>
REL16 = <RELOCATION_PPC64.REL16: 249>
REL16_HA = <RELOCATION_PPC64.REL16_HA: 252>
REL16_HI = <RELOCATION_PPC64.REL16_HI: 251>
REL16_LO = <RELOCATION_PPC64.REL16_LO: 250>
REL24 = <RELOCATION_PPC64.REL24: 10>
REL32 = <RELOCATION_PPC64.REL32: 26>
REL64 = <RELOCATION_PPC64.REL64: 44>
RELATIVE = <RELOCATION_PPC64.RELATIVE: 22>
TLS = <RELOCATION_PPC64.TLS: 67>
TLSGD = <RELOCATION_PPC64.TLSGD: 107>
TLSLD = <RELOCATION_PPC64.TLSLD: 108>
TOC = <RELOCATION_PPC64.TOC: 51>
TOC16 = <RELOCATION_PPC64.TOC16: 47>
TOC16_DS = <RELOCATION_PPC64.TOC16_DS: 63>
TOC16_HA = <RELOCATION_PPC64.TOC16_HA: 50>
TOC16_HI = <RELOCATION_PPC64.TOC16_HI: 49>
TOC16_LO = <RELOCATION_PPC64.TOC16_LO: 48>
TOC16_LO_DS = <RELOCATION_PPC64.TOC16_LO_DS: 64>
TPREL16 = <RELOCATION_PPC64.TPREL16: 69>
TPREL16_DS = <RELOCATION_PPC64.TPREL16_DS: 95>
TPREL16_HA = <RELOCATION_PPC64.TPREL16_HA: 72>
TPREL16_HI = <RELOCATION_PPC64.TPREL16_HI: 71>
TPREL16_HIGHER = <RELOCATION_PPC64.TPREL16_HIGHER: 97>
TPREL16_HIGHERA = <RELOCATION_PPC64.TPREL16_HIGHERA: 98>
TPREL16_HIGHEST = <RELOCATION_PPC64.TPREL16_HIGHEST: 99>
TPREL16_HIGHESTA = <RELOCATION_PPC64.TPREL16_HIGHESTA: 100>
TPREL16_LO = <RELOCATION_PPC64.TPREL16_LO: 70>
TPREL16_LO_DS = <RELOCATION_PPC64.TPREL16_LO_DS: 96>
TPREL64 = <RELOCATION_PPC64.TPREL64: 73>
property name
property value

Dynamic symbols counting

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

Members:

AUTO

SECTION

HASH

RELOCATIONS

AUTO = <DYNSYM_COUNT_METHODS.AUTO: 0>
HASH = <DYNSYM_COUNT_METHODS.HASH: 2>
RELOCATIONS = <DYNSYM_COUNT_METHODS.RELOCATIONS: 3>
SECTION = <DYNSYM_COUNT_METHODS.SECTION: 1>
property name
property value

Relocation purpose

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

Members:

NONE

PLTGOT

DYNAMIC

OBJECT

DYNAMIC = <RELOCATION_PURPOSES.DYNAMIC: 2>
NONE = <RELOCATION_PURPOSES.NONE: 0>
OBJECT = <RELOCATION_PURPOSES.OBJECT: 3>
PLTGOT = <RELOCATION_PURPOSES.PLTGOT: 1>
property name
property value

Note types

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

Members:

UNKNOWN

ABI_TAG

HWCAP

BUILD_ID

GOLD_VERSION

PROPERTY_TYPE_0

GNU_BUILD_ATTRIBUTE_OPEN

GNU_BUILD_ATTRIBUTE_FUNC

CRASHPAD

ABI_TAG = <NOTE_TYPES.ABI_TAG: 1>
BUILD_ID = <NOTE_TYPES.BUILD_ID: 3>
CRASHPAD = <NOTE_TYPES.CRASHPAD: 1330007625>
GNU_BUILD_ATTRIBUTE_FUNC = <NOTE_TYPES.GNU_BUILD_ATTRIBUTE_FUNC: 257>
GNU_BUILD_ATTRIBUTE_OPEN = <NOTE_TYPES.GNU_BUILD_ATTRIBUTE_OPEN: 256>
GOLD_VERSION = <NOTE_TYPES.GOLD_VERSION: 4>
HWCAP = <NOTE_TYPES.HWCAP: 2>
PROPERTY_TYPE_0 = <NOTE_TYPES.PROPERTY_TYPE_0: 5>
UNKNOWN = <NOTE_TYPES.UNKNOWN: 0>
property name
property value

Note ABIs

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

Members:

UNKNOWN

LINUX

GNU

SOLARIS2

FREEBSD

NETBSD

SYLLABLE

FREEBSD = <NOTE_ABIS.FREEBSD: 3>
GNU = <NOTE_ABIS.GNU: 1>
LINUX = <NOTE_ABIS.LINUX: 0>
NETBSD = <NOTE_ABIS.NETBSD: 4>
SOLARIS2 = <NOTE_ABIS.SOLARIS2: 2>
SYLLABLE = <NOTE_ABIS.SYLLABLE: 5>
UNKNOWN = <NOTE_ABIS.UNKNOWN: 4294967295>
property name
property value

Note Core types

class lief.ELF.NOTE_TYPES_CORE(self: lief.ELF.NOTE_TYPES_CORE, value: 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: 1026>
ARM_HW_WATCH = <NOTE_TYPES_CORE.ARM_HW_WATCH: 1027>
ARM_SVE = <NOTE_TYPES_CORE.ARM_SVE: 1029>
ARM_SYSTEM_CALL = <NOTE_TYPES_CORE.ARM_SYSTEM_CALL: 1028>
ARM_TLS = <NOTE_TYPES_CORE.ARM_TLS: 1025>
ARM_VFP = <NOTE_TYPES_CORE.ARM_VFP: 1024>
AUXV = <NOTE_TYPES_CORE.AUXV: 6>
FILE = <NOTE_TYPES_CORE.FILE: 1179208773>
I386_IOPERM = <NOTE_TYPES_CORE.I386_IOPERM: 513>
I386_TLS = <NOTE_TYPES_CORE.I386_TLS: 512>
I386_XSTATE = <NOTE_TYPES_CORE.I386_XSTATE: 514>
PRFPREG = <NOTE_TYPES_CORE.PRFPREG: 2>
PRPSINFO = <NOTE_TYPES_CORE.PRPSINFO: 3>
PRSTATUS = <NOTE_TYPES_CORE.PRSTATUS: 1>
SIGINFO = <NOTE_TYPES_CORE.SIGINFO: 1397311305>
TASKSTRUCT = <NOTE_TYPES_CORE.TASKSTRUCT: 4>
UNKNOWN = <NOTE_TYPES_CORE.UNKNOWN: 0>
property name
property value

ARM Processor flags

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

Members:

SOFT_FLOAT

VFP_FLOAT

UNKNOWN

EABI_VER1

EABI_VER2

EABI_VER3

EABI_VER4

EABI_VER5

EABI_VER1 = <ARM_EFLAGS.EABI_VER1: 16777216>
EABI_VER2 = <ARM_EFLAGS.EABI_VER2: 33554432>
EABI_VER3 = <ARM_EFLAGS.EABI_VER3: 50331648>
EABI_VER4 = <ARM_EFLAGS.EABI_VER4: 67108864>
EABI_VER5 = <ARM_EFLAGS.EABI_VER5: 83886080>
SOFT_FLOAT = <ARM_EFLAGS.SOFT_FLOAT: 512>
UNKNOWN = <ARM_EFLAGS.UNKNOWN: 0>
VFP_FLOAT = <ARM_EFLAGS.VFP_FLOAT: 1024>
property name
property value

MIPS Processor flags

class lief.ELF.MIPS_EFLAGS(self: lief.ELF.MIPS_EFLAGS, value: 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: 32>
ABI_EABI32 = <MIPS_EFLAGS.ABI_EABI32: 12288>
ABI_EABI64 = <MIPS_EFLAGS.ABI_EABI64: 16384>
ABI_O32 = <MIPS_EFLAGS.ABI_O32: 4096>
ABI_O64 = <MIPS_EFLAGS.ABI_O64: 8192>
ARCH_1 = <MIPS_EFLAGS.ARCH_1: 0>
ARCH_2 = <MIPS_EFLAGS.ARCH_2: 268435456>
ARCH_3 = <MIPS_EFLAGS.ARCH_3: 536870912>
ARCH_32 = <MIPS_EFLAGS.ARCH_32: 1342177280>
ARCH_32R2 = <MIPS_EFLAGS.ARCH_32R2: 1879048192>
ARCH_32R6 = <MIPS_EFLAGS.ARCH_32R6: 2415919104>
ARCH_4 = <MIPS_EFLAGS.ARCH_4: 805306368>
ARCH_5 = <MIPS_EFLAGS.ARCH_5: 1073741824>
ARCH_64 = <MIPS_EFLAGS.ARCH_64: 1610612736>
ARCH_64R2 = <MIPS_EFLAGS.ARCH_64R2: 2147483648>
ARCH_64R6 = <MIPS_EFLAGS.ARCH_64R6: 2684354560>
ARCH_ASE_M16 = <MIPS_EFLAGS.ARCH_ASE_M16: 67108864>
ARCH_ASE_MDMX = <MIPS_EFLAGS.ARCH_ASE_MDMX: 134217728>
CPIC = <MIPS_EFLAGS.CPIC: 4>
FP64 = <MIPS_EFLAGS.FP64: 512>
MACH_3900 = <MIPS_EFLAGS.MACH_3900: 8454144>
MACH_4010 = <MIPS_EFLAGS.MACH_4010: 8519680>
MACH_4100 = <MIPS_EFLAGS.MACH_4100: 8585216>
MACH_4111 = <MIPS_EFLAGS.MACH_4111: 8912896>
MACH_4120 = <MIPS_EFLAGS.MACH_4120: 8847360>
MACH_4650 = <MIPS_EFLAGS.MACH_4650: 8716288>
MACH_5400 = <MIPS_EFLAGS.MACH_5400: 9502720>
MACH_5500 = <MIPS_EFLAGS.MACH_5500: 9961472>
MACH_5900 = <MIPS_EFLAGS.MACH_5900: 9568256>
MACH_9000 = <MIPS_EFLAGS.MACH_9000: 10027008>
MACH_LS2E = <MIPS_EFLAGS.MACH_LS2E: 10485760>
MACH_LS2F = <MIPS_EFLAGS.MACH_LS2F: 10551296>
MACH_LS3A = <MIPS_EFLAGS.MACH_LS3A: 10616832>
MACH_OCTEON = <MIPS_EFLAGS.MACH_OCTEON: 9109504>
MACH_OCTEON2 = <MIPS_EFLAGS.MACH_OCTEON2: 9240576>
MACH_OCTEON3 = <MIPS_EFLAGS.MACH_OCTEON3: 9306112>
MACH_SB1 = <MIPS_EFLAGS.MACH_SB1: 9043968>
MACH_XLR = <MIPS_EFLAGS.MACH_XLR: 9175040>
MICROMIPS = <MIPS_EFLAGS.MICROMIPS: 33554432>
NAN2008 = <MIPS_EFLAGS.NAN2008: 1024>
NOREORDER = <MIPS_EFLAGS.NOREORDER: 1>
PIC = <MIPS_EFLAGS.PIC: 2>
property name
property value

PPC64 Processor flags

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

Members:

ABI

ABI = <PPC64_EFLAGS.ABI: 3>
property name
property value

Hexagon Processor flags

class lief.ELF.HEXAGON_EFLAGS(self: lief.ELF.HEXAGON_EFLAGS, value: 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: 0>
ISA_V2 = <HEXAGON_EFLAGS.ISA_V2: 16>
ISA_V3 = <HEXAGON_EFLAGS.ISA_V3: 32>
ISA_V4 = <HEXAGON_EFLAGS.ISA_V4: 48>
ISA_V5 = <HEXAGON_EFLAGS.ISA_V5: 64>
MACH_V2 = <HEXAGON_EFLAGS.MACH_V2: 1>
MACH_V3 = <HEXAGON_EFLAGS.MACH_V3: 2>
MACH_V4 = <HEXAGON_EFLAGS.MACH_V4: 3>
MACH_V5 = <HEXAGON_EFLAGS.MACH_V5: 4>
property name
property value