AbstractConverter

Per-routine data - works because convert() is not re-entrant (same found in X86ConvXxx helper classes).
Should be set before converting a routine, and reset to null after it's done.

The default implementation provides a no-arg/no-return prototype: "void __defaultCC ()".

Custom implementations may return something more suitable to a given architecture

The default implementation returns true.

Convert a routine. Convenience method for convert(routine, false).

Convert the blocks of the native routine's CFG after the other. The blocks' edges are not considered.

Reserved for testing.

Given a prototype, determine the list of IR expressions representing the input expressions (would also contain implicitly read registers).

Used by IECall.

Given a prototype, determine the list of IR expressions representing the output expressions. Spoiled register expressions can also be returned.

Used by IECall.

Given a prototype, determine the IR expression representing the return address location of a call to a method of said prototype.

Used by IECall.

The default implementation assumes a segment-less memory model. (The EMem segment component is set to null.)

The default implementation does nothing.

Convert PC-assignment to IEJumpFar statements. This method is a fail-safe converter for PC-assignments, and should be called as late as possible in the IR conversion phases. After executing this method, the CFG should no longer contain PC-assignments.

Determine the amount of bytes that were pushed on the stack before calling the routine with the provided prototype and optional additional slots. That should include all routine parameters pushed on the stack as well as the return address bytes as well, if it is located on the stack (per the provided calling convention).

Used by IECall.

Determine the stack pointer delta (in bytes) after the IECall executed and returned.
Careful: "IR-Call" and the "native-call" may not have the same structure; it depends on how the conversion of "native-call" is implemented, and therefore is converter-dependent. The SP delta returned by this method is the one after an execution over IECall.

Used by IECall.

The default implementation returns null.

The default implementation returns null.

The default implementation formats basic details about the number of converted methods.

The default implementation returns null.

The default implementation returns the size of the program counter.

Retrieve a reference to the decompiler managing this converter.

The default implementation returns a basic branch detail object specifying nothing (no def, no use, no spoils, etc.).

Converters should override this method.

Retrieve the global program context. There is a single global context per decompiler, common to all routine contexts.

The default implementation returns null.

Retrieve the native code context that this converter should use.

The default implementation attempts to resolve the register variable by querying the associated processor's register bank layout. It throws if the resolution fails.

Same as getNativeRegisterIdFromRegisterVariable(IEVar, false).

The default implementation returns null.

Create an instance of a prototype handler.

The default implementation forwards to getVariableByName(String).

The default implementation returns the address bitsize.

The default implementation attempts to resolve the native register id or number by querying the associated processor's register bank layout. It throws if the resolution fails.

See getRegisterVariableFromNativeRegisterId(long, ELocation). No location provided

The default implementation considers that there is no specific Return Address Register. Override if one exists.

Get the name of the slice of a physical register. The slice name may be an official name or a convenience name decided by the converter.

Get the size of standard slot on the stack, in bytes.

Retrieve the current processor mode relative to the provided EState. Refer to getMode() for the semantics of mode.

The default implementation returns INTEGER.

This method is called by the owner decompiler after the principal components of the lower-level code unit have been initialized. Initialization requiring, e.g. access to the type manager, should be performed here instead of within the constructor.

This method initializes and sets all physical registers declared by this converter to 0, except for the ones possibly used as arguments that are kept undefined (see #isPossibleParameterRegisterForProcessorCallingConventions(IEGeneric)). After this is done, customInitStateRegisters(EState, Long) is invoked.

This method introduces IEReturn statements into the IR. Must be performed only after prototype discovery is completed.

Data chains: not used, may be invalidated; in the latter case, this method is responsible for recalculating them.

Check if a native register id corresponds to a register that can possibly be used as a routine parameter on this processor.

To do so, the given id is compared against all input registers for all known calling conventions for the current processor. In particular, this method does not rely on the routine prototype and calling convention being defined, and can therefore be used early on during decompilation.

Check if a native register id corresponds to a physical register that can possibly be spoiled by a routine call on this processor.

To do so, the given id is compared against all spoiled registers for all known calling conventions for the current processor. In particular, this method does not rely on the routine prototype and calling convention being defined, and can therefore be used early on during decompilation.

The default implementation returns true: by default, all EMem are assumed to reference bytes in the primary VM.

Normalize a branching expression.

Implementations should be aggressive and fast: calls to this method should always be enclosed in a try-catch.

TODO: MOVE to the CBDU

The default implementation truncates the provided value to accomodate getAddressBitsize().

setup the helper converter classes

Reserved.

Convert a block.

For native routines that have their entry point in-the-middle (ie, not at their lowest address), insert a synthetic IEJump as the first instruction of the converted method.

By using this trick, we ensure that native routines that have their entry-point in the middle of their code can be converted to IR routines with an entry-point always set to offset 0 (the beginning of the IR code). The reason is that this helps with graph manipulation passes that come later on, in the AST phases.

Can be overridden by implementors when complex return expression matching is needed.

This method is called after convertBlock(BasicBlock, List) is called. The default implementation sanitizes fake calls, i.e. it switches call-to-sub-PC-assigns to regular PC-assigns if the underlying analyzer detected that what looked like a call-to-sub is not.

Executed by convert after converting the blocks. The default implementation does nothing.

This method is called before convertBlock(BasicBlock, List) is called. It can be overridden. Sub-classes do not need to call the default implementation. The default implementation returns the provided input block.

Executed by convert before converting the blocks. The default implementation does nothing.