IHex#

class cle.backends.ihex.Hex[source]#

Bases: Backend

A loader for Intel Hex Objects See https://en.wikipedia.org/wiki/Intel_HEX

is_default = True#

static parse_record(line)[source]#

static coalesce_regions(regions)[source]#

__init__(*args, **kwargs)[source]#

Parameters:

binary – The path to the binary to load
binary_stream – The open stream to this binary. The reference to this will be held until you call close.
is_main_bin – Whether this binary should be loaded as the main executable

addr_to_offset(addr: int) → int | None#

Return type:: Optional[int]
Parameters:: addr (int) –

property arch: Arch#

classmethod check_compatibility(spec, obj) → bool#

Performs a minimal static load of spec and returns whether it’s compatible with other_obj

Return type:: bool

classmethod check_magic_compatibility(stream: BinaryIO) → bool#

Check if a stream of bytes contains the same magic number as the main object

Return type:: bool
Parameters:: stream (BinaryIO) –

close() → None#

Return type:: None

contains_addr(addr)#: Is addr in one of the binary’s segments/sections we have loaded? (i.e. is it mapped into memory ?)

property entry#

static extract_soname(path) → str | None#

Extracts the shared object identifier from the path, or returns None if it cannot.

Return type:: Optional[str]

property finalizers: List[int]#: Stub function. Like initializers, but with finalizers.

find_loadable_containing(addr)#

find_section_containing(addr: int) → cle.backends.region.Section | None#

Returns the section that contains addr or None.

Return type:: Optional[Section]
Parameters:: addr (int) –

find_segment_containing(addr: int) → cle.backends.region.Segment | None#

Returns the segment that contains addr, or None.

Return type:: Optional[Segment]
Parameters:: addr (int) –

get_symbol(name: str) → cle.backends.symbol.Symbol | None#

Stub function. Implement to find the symbol with name name.

Return type:: Optional[Symbol]
Parameters:: name (str) –

property image_base_delta#

initial_register_values()#: Deprecated

property initializers: List[int]#: Stub function. Should be overridden by backends that can provide initializer functions that ought to be run before execution reaches the entry point. Addresses should be rebased.

property loader: Loader#

property max_addr: int#: This returns the highest virtual address contained in any loaded segment of the binary.

property min_addr: int#: This returns the lowest virtual address contained in any loaded segment of the binary.

offset_to_addr(offset: int) → int | None#

Return type:: Optional[int]
Parameters:: offset (int) –

rebase(new_base)#: Rebase backend’s regions to the new base where they were mapped by the loader

relocate()#

Apply all resolved relocations to memory.

The meaning of “resolved relocations” is somewhat subtle - there is a linking step which attempts to resolve each relocation, currently only present in the main internal loading function since the calculation of which objects should be available

property sections: Regions[Section]#

property segments: Regions[Segment]#

set_arch(arch)#

property symbols_by_addr#

thread_registers(thread=None) → Dict[str, Any]#

If this backend represents a dump of a running program, it may contain one or more thread contexts, i.e. register files. This method should return the register file for a given thread (as named in Backend.threads) as a dict mapping register names (as seen in archinfo) to numbers. If the thread is not specified, it should return the context for a “default” thread. If there are no threads, it should return an empty dict.

Return type:: Dict[str, Any]

property threads: List#: If this backend represents a dump of a running program, it may contain one or more thread contexts, i.e. register files. This property should contain a list of names for these threads, which should be unique.

symbols: List[Symbol]#

imports: typing.Dict[str, 'Relocation']#

relocs: List[Relocation]#

child_objects: List['Backend']#

exception_handlings: List[ExceptionHandling]#

function_hints: List[FunctionHint]#

memory: Clemory#

static is_compatible(stream)[source]#: Determine quickly whether this backend can load an object from this stream