IEConverter

Create a simple, failsafe prototype for the given routine.

Determine if the decompilation pipeline is allowed to create more IECall instructions than those already provided by the converter, after the conversion-to-IR stage completed.

Most decompiler plugins will want to return true. Decompiler plugins that do not implement full support for ECall creation (e.g. convertReturnExpressions, convertParameterExpressions, convertReturnLocation, etc.) in pipeline stages may want to return false.

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

Convert a native code routine to its initial intermediate representation. The initial IR consists only of IEAssign, IEJump, IENop and IEUntranslatedInstruction statements. Each statement instruction must have a size of 1. The resulting IR is verified and the initial IR-CFG created.

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.

Create an EMem using the adequate segment register (if any) for the current converter.

Custom/specific initialization of registers prior to emulation.

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.

This method attempts to provide the stack pointer delta resulting from the execution of a routine. The provided state is the current execution state right after the call or jump to the under-examination routine has occurred.

Evaluate untranslated IR instructions. This method is preferred to the internal evaluator, which currently throws by default when attempting to evaluate an IEUntranslatedInstruction.

The default implementation returns null.

Generate statistics about this converter.

Generate C statement from an untranslated IR instruction. This method is preferred to the internal generator, which produces ICNativeStatement wrapping IEUntranslatedInstruction.

Get the size of a native address, in bits.

Retrieve a reference to the decompiler managing this converter.

This heuristic does a best-effort determination of the side-effects resulting by calling a sub routine (used/defined registers, stack delta). Implementors should not attempt to do complex determination (eg, involving IR processing) in this method; the result provided by this method is meant to augment PC-assignments in earlier phases of the decompilation pipeline.

Used by IECallsiteResolver.

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

Retrieve the native code context that this converter should use.

Get the native platform register number or id (as defined in a register bank layout) corresponding to the provided EVar-register IR variable.

Same as getNativeRegisterIdFromRegisterVariable(IEVar, false).

Retrieve the IR variable object that represents the program counter.

Create an instance of a prototype handler.

Retrieve an EVar-register by its name.

Get the size of a standard, general-purpose native register, in bits.

Get the EVar-register IR variable representing a native platform register number or id (as defined in a register bank layout).

See getRegisterVariableFromNativeRegisterId(long, ELocation). No location provided

Retrieve the IR variable object that represents the return address register.

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.

Retrieve the IR variable object that represents the stack pointer.

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.

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.

Initialize the registers of an IR execution state to safe defaults.

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.

Determine if an EMem references bytes in the primary, unit-code managed virtual memory object, or some other memory object.

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