EUtil

Generate an IR expression computing the carry flag bit of an integer addition or subtraction operation.

The carry flag is used to indicate wrap-around for unsigned operations.

Transform the operands of an operation into logical operands (LOG_NEQ with 0).

Generate an IR expression computing the overflow flag bit of an integer addition or subtraction operation.

The Overflow flag is used to indicate wrap-around for signed operations.

Note: The generated IR is equivalent to: MSB((a ^ c) & ~(a ^ b)) for an addition, or MSB((a ^ c) & (a ^ b)) for a subtraction.

Check if the ECond predicate is a ""boolean"", i.e. a logical operation.

In case it is not, a new ECond with a boolean predicate is built (based on LOG_NEQ 0).

Check if the operands of logical OR, AND and NOT are ""booleans"", i.e. logical operations.

In case they are not, a new operation with boolean operands is built (based on LOG_NEQ 0).

Calculate the trivial complexity metric for the provided IR expression. Every IR element has a weight of 1.

Collect all EVars of an expression. If the expression is an EVar, it will be collected.

Create a composition if the provided list of elements contains at least two entries, else return the single element.@return7

Create a composition if the provided list of elements contains at least two entries, else return the single element.

Create a composition if the provided list of elements contains at list two entries, else return the single element.

Indicates if the target expression contains any token expression

Indicates if the generic expression contains any memory access (meaning IEMem)

Indicates if the generic expression invokes any undetermined kind of call (meaning IECall, IEJumpFar or IEUntranslatedInstruction)

Recursively count (using deep equality) how many times the provided target is seen in the input expression.

Recursively count (using deep equality) how many times each of the provided targets is seen in the input expression.

Collect sub-expressions of the input expression and return the cardinal of that collection. Simply calls getSubExpressions(List). Not recursive!

Count the number of times an EVar is present in an expression. (Defined vars are counted as well.)

Create a conversion operation: an integer truncation, integer extension (zero or signed), float truncation or extension, float-to-int and int-to-float conversion.

Create a resize operation operation: truncation, zero-extension, or sign-extension.

Determine the number of stacks slots used by invoking a method having the provided prototype and an optional list of additional arguments.

Determine the number of stack slots filled out when a routine with the provided prototype returns.

Alias for divS(IEGeneric, IEGeneric) / divU(IEGeneric, IEGeneric)

Not(NaN) and eq (with 0 == -0)

Evaluate an immediate to a 32-bit positive int. Apply Integer positive mask is greater than MAX_VALUE.

Evaluate and convert a positive immediate to a 32-bit int. If the immediate is greater than MAX_VALUE, the method will throw. It the evaluated value is greater than MAX_VALUE, Integer#MAX_VALUE will be returned.

Call/PC-assign expansion: augment the size to at least 2, to accommodate splitting:
- if an EReturn is to be inserted (tail-calls) in lieu of a ECall
- if a raw PC-assign cannot be converted to a single EJumpFar

Expand the size of a statement.

CAREFUL! This method can modify the structure of the CFG (block order, block count, etc.).

Expand the sizes of a collection of statements.

CAREFUL! This method can modify the structure of the CFG (block order, block count, etc.).

Extend an IEGeneric. Return null if provided IEGeneric is null.

Format an IR-CFG.

Retrieve the list of input types, by examining the provided prototype and optional list of additional arguments.

Determine if the statement is an IEAssign from an IEMem. If so, return the memory source.

Determine if the statement is an IEAssign to an IEMem. If so, return the memory target.

 DST = mXX[???]
 

Retrieve the destination of an IEAssign (or null if is not an assignment).

Retrieve the source of an IEAssign (or null if is not an assignment).

Retrieve all the parents of a value. The search is done by reference.

Check if the composition is a sign-extension of a base expression, and if so, provide the base expression.

Check if an IR expression looks like a sign-extension operation, and if so, provide the base expression.

Check if the composition of both expressions make up a sign-extension, and if so, provide the base expression.

if the input expression is as such: COMPOSE(base, MSB(base) ? -1: 0), then return: base

Collect the sub-expressions of an IRE. Simply calls getSubExpressions(List). Not recursive!

Not(NaN) and gt

Checks if an IR routine contains only basic blocks with one parent and one child (no merge or disjunction of control-flow).

Determine if an IR expression is side-effect free.

This method is taking a liberal approach to side-effects: Side effects include invocations to other routines determined to be non side-effect-free, voluntarily throwing an exception, or performing a memory-access that will trigger an exception.

The opposite of hasSideEffect(IEGeneric).

Determine if the provided IR expression embeds no amount at all of type information.

The opposite of hasNoSideEffect(IEGeneric).

Determine if the provided IR expression embeds some type information. Note that the sub-expressions are not examined.

Create an arbitrary-long immediate.

Create an arbitrary-long immediate.

Create an arbitrary-long immediate.

Create an immediate, limited to 64 bits.

Check that an IRE is assigned in a basic block.

This method does not rely on data flow analysis; it simply searches for an assignment to the given IRE.

Verify that an IRE is a single-bit immediate set to 1 (technically, -1).

Verify that an IRE is a single-bit immediate set to 0.

""Boolean"" comparable operation (eq/neq and all greater/lesser comparisons)

Determine if the IRE is an EImm.

Determine if the IRE is an EImm or a slice or composition of immediates.

Determine if the expression is equivalent to an EImm that can be read as a long primitive.

Determine if the expression is equivalent to an EImm that can be read as a long primitive.

""Boolean"" operation (and, or, not, eq/neq and all greater/lesser comparisons)

Determine if the expression is an EImm that can be read as a long primitive.

Determine if the expression is an EImm that can be read as a long primitive.

Verify that an IRE is an immediate holding the value -1.

As per IEEE 754-1985 floating-point standard, is NaN a number which exponent is filled with ones and a non-zero number in the mantissa

Indicate if p == !p2. Search for reversed operator as well as mirrored predicate. Do not consider NOT operations.

Verify that an IRE is an immediate holding 1.

IMPORTANT: i1:1 will fail the test since it is equal to -1. Consider using isBitOne(IEGeneric) or isMinusOne(IEGeneric) instead.

Determine if the provided statement is a PC-assign: PC = ...

Determine if the provided statement is a SP-assign: SP = ... or SP[slice] = ....

Logical operations that should have logical operands (and, or, not)

Verify that an IRE is a Zero representation (EImm(0) or ESlice(0, x, x))

Determine if a composition looks like a sign-extension operation.

Not(NaN) and lt

throws if failure

Create a bit mask, eg mask(16, 4) will create the mask: b0000000000001111

Create a bit mask, eg mask(16, 1, 5) will create the mask: b0000000000011110

Operation max(int, int) applied to IEGeneric

Operation min(int, int) applied to IEGeneric

Generates the value -1, ie an EImm filled with ones.

Generates the value 1L with defined bitsize. Do not mistake #one(ERoutineContext, int) for #ones(ERoutineContext, int)

Determine if type `b` can be implicitly converted to type `a`, without a cast.

Apply a list of IEStatements to user targets, resolving expression starting from last IEStatement to first. If any error occur (something can not be translated for example), this method returns false. As an example:

 r = {R0 = 7; R0 = R0 + 4; R1 = 8}
 targets = [R0, R1]
 
 i = 2 => targets = [R0, 8]
 i = 1 => targets = [R0+4, 8]
 i = 0 => targets = [11, 8]
 return true
 

Safely extend an IEGeneric. Return null if provided IEGeneric is null. If bitsize is less that current IEGeneric, the IEGeneric relative part is returned.

If all the provided expressions have the same bitsize, return it. Null elements are considered invalid and will result in a failure (the method will return 0).

If all the provided expressions have the same bitsize, return it. Null elements are ignored.

Sign-extend operation IRE.

Truncate operation IRE.

Generates the value 0 with defined bitsize.

Zero-extend operation IRE.