public class

EUtil

extends Object
java.lang.Object
   ↳ com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EUtil

Class Overview

Utility methods to manipulate IR expressions.

Summary

Public Constructors
EUtil()
Public Methods
static IEOperation add(IEGeneric a, IEGeneric b, IEGeneric c)
static IEOperation add(IEGeneric a, IEGeneric b)
static int adjustBranchToIRInstruction(IEStatement stm, int currentTargetIROffset, int newTargetIROffset)
static IEOperation andB(IEGeneric a, IEGeneric b)
static IEOperation andL(IEGeneric a, IEGeneric b)
static IEGeneric buildCarryFlag(IEGeneric a, IEGeneric b, IEGeneric result, boolean addition, boolean nativeOp)
Generate an IR expression computing the carry flag bit of an integer addition or subtraction operation.
static IEOperation buildLogicalOperation(IEOperation e)
Transform the operands of an operation into logical operands (LOG_NEQ with 0).
static IEGeneric buildOverflowFlag(IEGeneric a, IEGeneric b, IEGeneric result, boolean addition)
Generate an IR expression computing the overflow flag bit of an integer addition or subtraction operation.
static IECond buildStrictLogicalECond(IECond e)
Check if the ECond predicate is a ""boolean"", i.e.
static IEOperation buildStrictLogicalOperation(IEOperation e)
Check if the operands of logical OR, AND and NOT are ""booleans"", i.e.
static int calculateComplexity(IEGeneric e)
Calculate the trivial complexity metric for the provided IR expression.
static Boolean checkCallReturnAddress(IERoutineContext ctx, CFG<IEStatement> cfg, BasicBlock<IEStatement> b, int insnIndex)
static IEGeneric checkFalse(IEGeneric e)
static IEGeneric checkTrue(IEGeneric e)
static Set<IEVar> collectVars(IEGeneric e)
static void collectVars(IEGeneric e, Set<IEVar> r)
static IEGeneric compose(IEGeneric... elts)
Create a composition if the provided list of elements contains at least two entries, else return the single element.
static IEGeneric compose(Collection<IEGeneric> elts)
Create a composition if the provided list of elements contains at list two entries, else return the single element.
static boolean containsUndeterminedInvocations(IEGeneric e)
static IERoutineContext convertLinearRoutineToSSA(IERoutineContext inputRoutine)
Convert an IR routine into a equivalent routine in single-static assignment form, i.e.
static int countExpressionPresence(IEGeneric e, IEGeneric target)
Recursively count (using deep equality) how many times the provided target is seen in the input expression.
static void countExpressionsPresence(IEGeneric e, List<IEGeneric> targets, int[] acounts)
Recursively count (using deep equality) how many times each of the provided targets is seen in the input expression.
static int countSubExpressions(IEGeneric e)
Collect sub-expressions of the input expression and return the cardinal of that collection.
static int countVariablePresence(IEGeneric e, IEVar target)
Count the number of times an EVar is present in an expression.
static int countVariableUse(IEGeneric e)
static IEOperation createConversionOperation(OperationType convOperator, IEGeneric src, int dstSize)
Create a conversion operation: an integer truncation, integer extension (zero or signed), float truncation or extension, float-to-int and int-to-float conversion.
static IEOperation createResizeOperation(IEGeneric src, int dstSize, boolean signed)
Create a resize operation operation: truncation, zero-extension, or sign-extension.
static int determineArgumentStackSlotCount(IWildcardPrototype prototype, Collection<IWildcardType> varArgTypes)
Determine the number of stacks slots used by invoking a method having the provided prototype and an optional list of additional arguments.
static int determineReturnValuesStackSlotCount(IWildcardPrototype prototype, int inputStackSlotCount)
Determine the number of stack slots filled out when a routine with the provided prototype returns.
static IEOperation div(IEGeneric a, IEGeneric b, boolean signed)
static IEOperation divS(IEGeneric a, IEGeneric b)
static IEOperation divU(IEGeneric a, IEGeneric b)
static IEOperation eq(IEGeneric a, IEGeneric b)
static IEGeneric eqFloat(IEGeneric op1, IEGeneric op2)
Not(NaN) and eq (with 0 == -0)
static long evaluateAddress_preVerified(IEGeneric e)
static long evaluateAddress_preVerified(IEGeneric e, EState state)
static long evaluateUnsignedLong_preVerified(IEGeneric e)
static long evaluateUnsignedLong_preVerified(IEGeneric e, EState state)
static IEImm evaluate_preVerified(IEGeneric e, EState state)
static IEImm evaluate_preVerified(IEGeneric e)
static CFG<IEStatement> expandStatementSize(IERoutineContext ectx, IEStatement stm0, int minSize)
Expand the size of a statement.
static CFG<IEStatement> expandStatementSizes(IERoutineContext ectx, Collection<IEStatement> stmcoll, int minSize)
Expand the sizes of a collection of statements.
static IEGeneric extend(IEGeneric a, int bitsize, boolean signExtend)
Extend an IEGeneric.
static String formatIRCFGWithContext(int mode, CFG<IEStatement> cfg, IERoutineContext ectx)
Format an IR-CFG.
static String formatVars(IERoutineContext ctx, Collection<Integer> varids)
static String formatVars(IERoutineContext ctx, int... varids)
static List<IWildcardType> gatherArgumentTypes(IWildcardPrototype prototype, Collection<IWildcardType> varArgTypes)
Retrieve the list of input types, by examining the provided prototype and optional list of additional arguments.
static IEOperation geS(IEGeneric a, IEGeneric b)
static IEOperation geU(IEGeneric a, IEGeneric b)
static IEMem getAssigningFromMemory(IEStatement stm)
Determine if the statement is an IEAssign from an IEMem.
static IEMem getAssigningToMemory(IEStatement stm)
Determine if the statement is an IEAssign to an IEMem.
static IEGeneric getAssignmentDestination(IEStatement stm)
Retrieve the destination of an IEAssign (or null if is not an assignment).
static IEGeneric getAssignmentSource(IEStatement stm)
Retrieve the source of an IEAssign (or null if is not an assignment).
static IWildcardType getBestType(IWildcardType a, IWildcardType b)
static OperationType getMirrorOperation(OperationType optype)
static OperationType getOperation(IEGeneric e, OperationType... optypes)
static OperationType getOperation(IEOperation e, OperationType... optypes)
static OperationType getReverseOperation(OperationType optype)
static IEGeneric getSignExtensionBase(IECompose e)
Check if the composition is a sign-extension of a base expression, and if so, provide the base expression.
static IEGeneric getSignExtensionBase(IEGeneric e)
Check if an IR expression looks like a sign-extension operation, and if so, provide the base expression.
static IEGeneric getSignExtensionBase(IEGeneric base, IEGeneric extend)
Check if the composition of both expressions make up a sign-extension, and if so, provide the base expression.
static List<IEGeneric> getSubExpressions(IEGeneric e)
Collect the sub-expressions of an IRE.
static Set<Integer> getUsedVarIds(IEGeneric e)
static IEVar getVarSlice(IEGeneric e)
static Integer getVarSliceId(IEGeneric e)
static List<IEVar> getVars(IERoutineContext ctx, Collection<Integer> varids)
static List<IWildcardType> getWildcardTypes(IWildcardTypeManager etypeman, Collection<IEGeneric> elts)
static IEGeneric gtFloat(IEGeneric op1, IEGeneric op2)
Not(NaN) and gt
static IEOperation gtS(IEGeneric a, IEGeneric b)
static IEOperation gtU(IEGeneric a, IEGeneric b)
static boolean hasExplicitlyUsedVar(IEGeneric e, IEVar target)
static boolean hasLinearControlFlow(IERoutineContext inputRoutine)
Checks if an IR routine contains only basic blocks with one parent and one child (no merge or disjunction of control-flow)
static boolean hasNoSideEffect(IEGeneric e)
Determine if an IR expression is side-effect free.
static boolean hasNoTypeInfo(IEGeneric e)
Determine if the provided IR expression embeds no amount at all of type information.
static boolean hasSameType(IEGeneric e1, IEGeneric e2)
static boolean hasSideEffect(IEGeneric e)
static boolean hasTypeInfo(IEGeneric e)
Determine if the provided IR expression embeds some amount of type information.
static IEGeneric identL(IEGeneric a)
static IEImm imm(byte[] val, int bitsize)
Create an arbitrary-long immediate.
static IEImm imm(String val, int bitsize)
Create an arbitrary-long immediate.
static IEImm imm(BigInteger val, int bitsize)
Create an arbitrary-long immediate.
static IEImm imm(long val, int bitsize)
Create an immediate, limited to 64 bits.
static boolean isAssignedIn(BasicBlock<IEStatement> bb, IEGeneric checkedDst)
Check that an IRE is assigned in a basic block.
static boolean isBitOne(IEGeneric e)
Verify that an IRE is a single-bit immediate set to 1 (technically, -1).
static boolean isBitZero(IEGeneric e)
Verify that an IRE is a single-bit immediate set to 0.
static boolean isComparableOperation(IEOperation e)
static boolean isComparableOperation(IEOperation e, boolean allowUnsigned)
static boolean isComparableOperation(IEGeneric e)
""Boolean"" comparable operation (eq/neq and all greater/lesser comparisons)
static boolean isComparableSignedOperation(IEOperation e)
static boolean isCondEAssign(IEGeneric e)
static boolean isConditionalJump(IEGeneric e)
static boolean isExpressionModified(IEStatement insn, IEGeneric target, boolean defuse)
static boolean isFirstBit(IESlice s2)
static boolean isImmNonZero(IEGeneric e)
static boolean isImmSize(IEGeneric e, int bitsize)
static boolean isImmValue(IEGeneric e, long value)
static boolean isImmValue(IEGeneric e, BigInteger value)
static boolean isImmZero(IEGeneric e)
static boolean isImmediate(IEGeneric e)
Determine if the IRE is an EImm.
static boolean isJump(IEGeneric e)
static boolean isLastBit(IESlice s2)
static boolean isLikeImmediate(IEGeneric a)
Determine if the IRE is an EImm or a slice or composition of immediates.
static boolean isLikeSmallImmediate(IEGeneric a)
Determine if the IRE is an EImm that can be read onto a long primitive, or a slice or composition of small immediates.
static boolean isLogicalOperation(IEGeneric e)
""Boolean"" operation (and, or, not, eq/neq and all greater/lesser comparisons)
static boolean isMatchDuaryOperation(IEGeneric e, OperationType wantedOperationType, IEGeneric wantedOperand1, IEGeneric wantedOperand2)
static boolean isMinusOne(IEGeneric e)
Verify that an IRE is an immediate holding the value -1.
static boolean isNBit(IESlice s2, int n)
static IEGeneric isNaN(IEGeneric op)
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
static boolean isNotPredicate(IEGeneric p, IEGeneric p2)
Indicate if p == !p2.
static boolean isOne(IEGeneric e)
Verify that an IRE is an immediate holding 1.
static boolean isOperation(IEGeneric e, OperationType optype)
static boolean isOperation(IEGeneric e, OperationType... optypes)
static boolean isOperationSize(IEGeneric e, int bitsize)
static boolean isPCAssign(IEStatement stm)
Determine if the provided statement is a PC-assign: PC = ...
static boolean isSPAssign(IEStatement stm)
Determine if the provided statement is a SP-assign: SP = ...
static boolean isSameType(IWildcardType a, IWildcardType b)
static boolean isSmallImmediate(IEGeneric e)
Determine if the IRE is an EImm that can be read onto a long primitive.
static boolean isStrictLogicalOperation(IEOperation e)
static boolean isStrictLogicalOperation(IEGeneric e)
Logical operations that should have logical operands (and, or, not)
static boolean isTrampoline(BasicBlock<IEStatement> bb)
static boolean isUnconditionalJump(IEGeneric e)
static boolean isVar(IEGeneric e, int id)
static boolean isVarOrVarSlice(IEGeneric e)
static boolean isVariableAssigned(IEStatement stm, IEVar var)
static boolean isZero(IEGeneric e)
Verify that an IRE is a Zero representation (EImm(0) or ESlice(0, x, x))
static boolean isZeroExtend(IECompose e)
static IEOperation leS(IEGeneric a, IEGeneric b)
static IEOperation leU(IEGeneric a, IEGeneric b)
static void loglist(List<? extends IEStatement> irlist)
static boolean looksLikeSignExtension(IECompose e)
Determine if a composition looks like a sign-extension operation.
static IEGeneric ltFloat(IEGeneric op1, IEGeneric op2)
Not(NaN) and lt
static IEOperation ltS(IEGeneric a, IEGeneric b)
static IEOperation ltU(IEGeneric a, IEGeneric b)
static void makeUncond(IEJump j)
throws if failure
static IEImm mask(int bitsize, int maskbits)
Create a bit mask, eg mask(16, 4) will create the mask: b0000000000001111
static IEImm mask(int bitsize, int maskbegin, int maskend)
Create a bit mask, eg mask(16, 1, 5) will create the mask: b0000000000011110
static IEImm minusOne(int bitsize)
Generates the value -1, ie an EImm filled with ones.
static IEOperation mul(IEGeneric a, IEGeneric b, boolean signed)
static IEOperation mulS(IEGeneric a, IEGeneric b)
static IEOperation mulU(IEGeneric a, IEGeneric b)
static IEOperation ne(IEGeneric a, IEGeneric b)
static IEGeneric notB(IEGeneric a)
static IEGeneric notL(IEGeneric a, boolean allowOpt)
static IEGeneric notL(IEGeneric a)
static IEImm one(int bitsize)
Generates the value 1L with defined bitsize.
static IEOperation op(OperationType operator, IEGeneric a, IEGeneric b)
static IEOperation op(OperationType operator, IEGeneric a)
static IEOperation orB(IEGeneric a, IEGeneric b)
static IEOperation orL(IEGeneric a, IEGeneric b)
static IEOperation pow(IEGeneric a, IEGeneric b)
static IEOperation remS(IEGeneric a, IEGeneric b)
static IEOperation remU(IEGeneric a, IEGeneric b)
static IEGeneric replaceSubExpressionRecursive(IEGeneric stm, IEGeneric src, IEGeneric dst, EVisitResults results)
static IEGeneric replaceSubExpressionRecursive(IEGeneric stm, IEGeneric src, IEGeneric dst)
static boolean requiresExplicitCast(IWildcardType a, IWildcardType b)
Determine if type `b` can be implicitly converted to type `a`, without a cast.
static boolean resolveExpressionsBackward(Object name, IEConverter<?> conv, List<IEStatement> r, IEGeneric... targets)
Apply a list of IEStatements to user targets, resolving expression starting from last IEStatement to first.
static IEGeneric reversePredicate(IEGeneric predicate)
static IEGeneric safeExtend(IEGeneric a, int bitsize, boolean signExtend)
Safely extend an IEGeneric.
static int sameBitsize(IEGeneric... elts)
If all the provided expressions have the same bitsize, return it.
static int sameBitsizeAllowNulls(IEGeneric... elts)
If all the provided expressions have the same bitsize, return it.
static IEOperation sar(IEGeneric a, IEGeneric b)
static IEOperation shl(IEGeneric a, IEGeneric b)
static IEOperation shr(IEGeneric a, IEGeneric b)
static IEGeneric signExt(IEGeneric src, int dstSize)
Sign-extend operation IRE.
static IEOperation sub(IEGeneric a, IEGeneric b)
static IEGeneric truncate(IEGeneric src, int dstSize)
Truncate operation IRE.
static IEOperation xorB(IEGeneric a, IEGeneric b)
static IEImm zero(int bitsize)
Generates the value 0 with defined bitsize.
static IEGeneric zeroExt(IEGeneric src, int dstSize)
Zero-extend operation IRE.
[Expand]
Inherited Methods
From class java.lang.Object

Public Constructors

public EUtil ()

Public Methods

public static IEOperation add (IEGeneric a, IEGeneric b, IEGeneric c)

public static IEOperation add (IEGeneric a, IEGeneric b)

public static int adjustBranchToIRInstruction (IEStatement stm, int currentTargetIROffset, int newTargetIROffset)

public static IEOperation andB (IEGeneric a, IEGeneric b)

public static IEOperation andL (IEGeneric a, IEGeneric b)

public static IEGeneric buildCarryFlag (IEGeneric a, IEGeneric b, IEGeneric result, boolean addition, boolean nativeOp)

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.

Parameters
a operand a
b operand b
result result c (may have an additional carry flag added before)
addition true if the carry is to be computed for "a + b", false for "a - b"
nativeOp indicate it CARRY / LT_U can be used over complex xor expression
Returns
  • a one-bit overflow flag IR expression

public static IEOperation buildLogicalOperation (IEOperation e)

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

public static IEGeneric buildOverflowFlag (IEGeneric a, IEGeneric b, IEGeneric result, boolean addition)

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.

Parameters
a operand a
b operand b
result result c, comprising an optional carry flag added beforehand
addition true if the overflow is to be computed for "a + b", false for "a - b"
Returns
  • a one-bit overflow flag IR expression

public static IECond buildStrictLogicalECond (IECond e)

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

Returns
  • transformed IRE

public static IEOperation buildStrictLogicalOperation (IEOperation e)

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

Returns
  • transformed IRE

public static int calculateComplexity (IEGeneric e)

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

public static Boolean checkCallReturnAddress (IERoutineContext ctx, CFG<IEStatement> cfg, BasicBlock<IEStatement> b, int insnIndex)

Returns
  • null if the return address is not set or not an immediate value; true if it is an immediate value matching the call expected return address (i.e., following the call instruction itself); false otherwise

public static IEGeneric checkFalse (IEGeneric e)

public static IEGeneric checkTrue (IEGeneric e)

public static Set<IEVar> collectVars (IEGeneric e)

public static void collectVars (IEGeneric e, Set<IEVar> r)

public static IEGeneric compose (IEGeneric... elts)

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

public static IEGeneric compose (Collection<IEGeneric> elts)

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

public static boolean containsUndeterminedInvocations (IEGeneric e)

public static IERoutineContext convertLinearRoutineToSSA (IERoutineContext inputRoutine)

Convert an IR routine into a equivalent routine in single-static assignment form, i.e. where each left-hand side is only defined once.

Warning: two important limitations:

  • The input routine has to have a linear control-flow, i.e. each basic block has only one parent and one child.
  • The statements are EAssign with EVar as their left hand side.

Throws
IllegalArgumentException when one of the two previously mentionned limitations is not respected.

public static int countExpressionPresence (IEGeneric e, IEGeneric target)

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

Parameters
e expression to be examined
target target
Returns
  • presence count

public static void countExpressionsPresence (IEGeneric e, List<IEGeneric> targets, int[] acounts)

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

Parameters
e expression to be examined
targets targets
acounts output counts, the array size must match target's, and counts must be initially set to 0

public static int countSubExpressions (IEGeneric e)

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

public static int countVariablePresence (IEGeneric e, IEVar target)

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

Parameters
target EVar to be counter

public static int countVariableUse (IEGeneric e)

public static IEOperation createConversionOperation (OperationType convOperator, IEGeneric src, int dstSize)

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

Parameters
convOperator one of for which isConversion() returns true (eg, CAST, CAST_S, FP2FP, FP2INT, INT2FP)
src operand to be extended, truncated, or converted
dstSize resulting bitsize
Returns
  • the operation IRE

public static IEOperation createResizeOperation (IEGeneric src, int dstSize, boolean signed)

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

Parameters
src the source to be extended (dstSize > srcSize) or truncated (dstSize < srcSize)
dstSize the destination size; should be different than the source's
signed for extensions, else N/A
Returns
  • the operation IRE

public static int determineArgumentStackSlotCount (IWildcardPrototype prototype, Collection<IWildcardType> varArgTypes)

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

Parameters
varArgTypes optional; the prototype MUST be marked VarArg for this to not be disregarded

public static int determineReturnValuesStackSlotCount (IWildcardPrototype prototype, int inputStackSlotCount)

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

Parameters
inputStackSlotCount the number of stack slots used for input (arguments); depending on the calling convention specified in the prototype, this value may be needed in order to calculate the count correctly

public static IEOperation div (IEGeneric a, IEGeneric b, boolean signed)

public static IEOperation divS (IEGeneric a, IEGeneric b)

public static IEOperation divU (IEGeneric a, IEGeneric b)

public static IEOperation eq (IEGeneric a, IEGeneric b)

public static IEGeneric eqFloat (IEGeneric op1, IEGeneric op2)

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

public static long evaluateAddress_preVerified (IEGeneric e)

public static long evaluateAddress_preVerified (IEGeneric e, EState state)

public static long evaluateUnsignedLong_preVerified (IEGeneric e)

public static long evaluateUnsignedLong_preVerified (IEGeneric e, EState state)

public static IEImm evaluate_preVerified (IEGeneric e, EState state)

public static IEImm evaluate_preVerified (IEGeneric e)

public static CFG<IEStatement> expandStatementSize (IERoutineContext ectx, IEStatement stm0, int minSize)

Expand the size of a statement.

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

Returns
  • the resulting CFG (it may be the original CFG)

public static CFG<IEStatement> expandStatementSizes (IERoutineContext ectx, Collection<IEStatement> stmcoll, int minSize)

Expand the sizes of a collection of statements.

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

Returns
  • the resulting CFG (it may be the original CFG)

public static IEGeneric extend (IEGeneric a, int bitsize, boolean signExtend)

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

public static String formatIRCFGWithContext (int mode, CFG<IEStatement> cfg, IERoutineContext ectx)

Format an IR-CFG.

Parameters
mode 0=no chains
1=with simple chains
2=with full chains
3=with simple chains and IR types
4=with full chains and IR types
cfg IR-CFG
ectx optional routine context; one must be provided to get EVar id name resolution
Returns
  • the formatted string

public static String formatVars (IERoutineContext ctx, Collection<Integer> varids)

public static String formatVars (IERoutineContext ctx, int... varids)

public static List<IWildcardType> gatherArgumentTypes (IWildcardPrototype prototype, Collection<IWildcardType> varArgTypes)

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

Parameters
varArgTypes optional; the prototype MUST be marked VarArg for this to not be disregarded

public static IEOperation geS (IEGeneric a, IEGeneric b)

public static IEOperation geU (IEGeneric a, IEGeneric b)

public static IEMem getAssigningFromMemory (IEStatement stm)

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

Returns
  • a memory IRE or null

public static IEMem getAssigningToMemory (IEStatement stm)

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

 DST = mXX[???]
 

Returns
  • a memory IRE or null

public static IEGeneric getAssignmentDestination (IEStatement stm)

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

public static IEGeneric getAssignmentSource (IEStatement stm)

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

public static IWildcardType getBestType (IWildcardType a, IWildcardType b)

public static OperationType getMirrorOperation (OperationType optype)

public static OperationType getOperation (IEGeneric e, OperationType... optypes)

public static OperationType getOperation (IEOperation e, OperationType... optypes)

public static OperationType getReverseOperation (OperationType optype)

public static IEGeneric getSignExtensionBase (IECompose e)

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

Parameters
e expression to test that should be a signExtend
Returns
  • the base expression

public static IEGeneric getSignExtensionBase (IEGeneric e)

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

public static IEGeneric getSignExtensionBase (IEGeneric base, IEGeneric extend)

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

Parameters
base candidate base (i.e., base we expect to retrieve)
extend candidate sign-extension expression, extending base
Returns
  • base on success, else null

public static List<IEGeneric> getSubExpressions (IEGeneric e)

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

public static Set<Integer> getUsedVarIds (IEGeneric e)

public static IEVar getVarSlice (IEGeneric e)

public static Integer getVarSliceId (IEGeneric e)

public static List<IEVar> getVars (IERoutineContext ctx, Collection<Integer> varids)

public static List<IWildcardType> getWildcardTypes (IWildcardTypeManager etypeman, Collection<IEGeneric> elts)

public static IEGeneric gtFloat (IEGeneric op1, IEGeneric op2)

Not(NaN) and gt

public static IEOperation gtS (IEGeneric a, IEGeneric b)

public static IEOperation gtU (IEGeneric a, IEGeneric b)

public static boolean hasExplicitlyUsedVar (IEGeneric e, IEVar target)

public static boolean hasLinearControlFlow (IERoutineContext inputRoutine)

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

public static boolean hasNoSideEffect (IEGeneric e)

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

public static boolean hasNoTypeInfo (IEGeneric e)

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

public static boolean hasSameType (IEGeneric e1, IEGeneric e2)

public static boolean hasSideEffect (IEGeneric e)

public static boolean hasTypeInfo (IEGeneric e)

Determine if the provided IR expression embeds some amount of type information.

public static IEGeneric identL (IEGeneric a)

public static IEImm imm (byte[] val, int bitsize)

Create an arbitrary-long immediate.

Parameters
val big-endian bytes of the value

public static IEImm imm (String val, int bitsize)

Create an arbitrary-long immediate.

Parameters
val string representation of the integer immediate

public static IEImm imm (BigInteger val, int bitsize)

Create an arbitrary-long immediate.

Parameters
val value

public static IEImm imm (long val, int bitsize)

Create an immediate, limited to 64 bits.

public static boolean isAssignedIn (BasicBlock<IEStatement> bb, IEGeneric checkedDst)

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.

public static boolean isBitOne (IEGeneric e)

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

public static boolean isBitZero (IEGeneric e)

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

public static boolean isComparableOperation (IEOperation e)

public static boolean isComparableOperation (IEOperation e, boolean allowUnsigned)

public static boolean isComparableOperation (IEGeneric e)

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

public static boolean isComparableSignedOperation (IEOperation e)

public static boolean isCondEAssign (IEGeneric e)

public static boolean isConditionalJump (IEGeneric e)

public static boolean isExpressionModified (IEStatement insn, IEGeneric target, boolean defuse)

public static boolean isFirstBit (IESlice s2)

public static boolean isImmNonZero (IEGeneric e)

public static boolean isImmSize (IEGeneric e, int bitsize)

public static boolean isImmValue (IEGeneric e, long value)

public static boolean isImmValue (IEGeneric e, BigInteger value)

public static boolean isImmZero (IEGeneric e)

public static boolean isImmediate (IEGeneric e)

Determine if the IRE is an EImm.

public static boolean isJump (IEGeneric e)

public static boolean isLastBit (IESlice s2)

public static boolean isLikeImmediate (IEGeneric a)

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

public static boolean isLikeSmallImmediate (IEGeneric a)

Determine if the IRE is an EImm that can be read onto a long primitive, or a slice or composition of small immediates.

public static boolean isLogicalOperation (IEGeneric e)

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

public static boolean isMatchDuaryOperation (IEGeneric e, OperationType wantedOperationType, IEGeneric wantedOperand1, IEGeneric wantedOperand2)

public static boolean isMinusOne (IEGeneric e)

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

public static boolean isNBit (IESlice s2, int n)

public static IEGeneric isNaN (IEGeneric op)

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

public static boolean isNotPredicate (IEGeneric p, IEGeneric p2)

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

Parameters
p reference predicate
p2 predicate to test

public static boolean isOne (IEGeneric e)

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.

public static boolean isOperation (IEGeneric e, OperationType optype)

public static boolean isOperation (IEGeneric e, OperationType... optypes)

public static boolean isOperationSize (IEGeneric e, int bitsize)

public static boolean isPCAssign (IEStatement stm)

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

public static boolean isSPAssign (IEStatement stm)

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

public static boolean isSameType (IWildcardType a, IWildcardType b)

public static boolean isSmallImmediate (IEGeneric e)

Determine if the IRE is an EImm that can be read onto a long primitive.

public static boolean isStrictLogicalOperation (IEOperation e)

public static boolean isStrictLogicalOperation (IEGeneric e)

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

public static boolean isTrampoline (BasicBlock<IEStatement> bb)

public static boolean isUnconditionalJump (IEGeneric e)

public static boolean isVar (IEGeneric e, int id)

public static boolean isVarOrVarSlice (IEGeneric e)

public static boolean isVariableAssigned (IEStatement stm, IEVar var)

public static boolean isZero (IEGeneric e)

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

public static boolean isZeroExtend (IECompose e)

public static IEOperation leS (IEGeneric a, IEGeneric b)

public static IEOperation leU (IEGeneric a, IEGeneric b)

public static void loglist (List<? extends IEStatement> irlist)

public static boolean looksLikeSignExtension (IECompose e)

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

public static IEGeneric ltFloat (IEGeneric op1, IEGeneric op2)

Not(NaN) and lt

public static IEOperation ltS (IEGeneric a, IEGeneric b)

public static IEOperation ltU (IEGeneric a, IEGeneric b)

public static void makeUncond (IEJump j)

throws if failure

public static IEImm mask (int bitsize, int maskbits)

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

Parameters
maskbits must be less than or equal to `bitsize`

public static IEImm mask (int bitsize, int maskbegin, int maskend)

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

Parameters
maskbegin start bit of the mask, inclusive
maskend end bit of the mask, exclusive

public static IEImm minusOne (int bitsize)

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

Parameters
bitsize Bitsize of the EImm

public static IEOperation mul (IEGeneric a, IEGeneric b, boolean signed)

public static IEOperation mulS (IEGeneric a, IEGeneric b)

public static IEOperation mulU (IEGeneric a, IEGeneric b)

public static IEOperation ne (IEGeneric a, IEGeneric b)

public static IEGeneric notB (IEGeneric a)

public static IEGeneric notL (IEGeneric a, boolean allowOpt)

public static IEGeneric notL (IEGeneric a)

public static IEImm one (int bitsize)

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

Parameters
bitsize Bitsize of the EImm

public static IEOperation op (OperationType operator, IEGeneric a, IEGeneric b)

public static IEOperation op (OperationType operator, IEGeneric a)

public static IEOperation orB (IEGeneric a, IEGeneric b)

public static IEOperation orL (IEGeneric a, IEGeneric b)

public static IEOperation pow (IEGeneric a, IEGeneric b)

public static IEOperation remS (IEGeneric a, IEGeneric b)

public static IEOperation remU (IEGeneric a, IEGeneric b)

public static IEGeneric replaceSubExpressionRecursive (IEGeneric stm, IEGeneric src, IEGeneric dst, EVisitResults results)

public static IEGeneric replaceSubExpressionRecursive (IEGeneric stm, IEGeneric src, IEGeneric dst)

public static boolean requiresExplicitCast (IWildcardType a, IWildcardType b)

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

public static boolean resolveExpressionsBackward (Object name, IEConverter<?> conv, List<IEStatement> r, IEGeneric... targets)

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
 

public static IEGeneric reversePredicate (IEGeneric predicate)

public static IEGeneric safeExtend (IEGeneric a, int bitsize, boolean signExtend)

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

public static int sameBitsize (IEGeneric... elts)

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

Parameters
elts a list of IRE
Returns
  • the common bitsize of all provided elements; 0 if the elements do not have the same bitsize

public static int sameBitsizeAllowNulls (IEGeneric... elts)

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

Parameters
elts a list of IRE
Returns
  • the common bitsize of all provided elements; 0 if the elements do not have the same bitsize

public static IEOperation sar (IEGeneric a, IEGeneric b)

public static IEOperation shl (IEGeneric a, IEGeneric b)

public static IEOperation shr (IEGeneric a, IEGeneric b)

public static IEGeneric signExt (IEGeneric src, int dstSize)

Sign-extend operation IRE.

Parameters
dstSize must be greater or equal than src's size

public static IEOperation sub (IEGeneric a, IEGeneric b)

public static IEGeneric truncate (IEGeneric src, int dstSize)

Truncate operation IRE.

Parameters
dstSize must be less or equal than src's size

public static IEOperation xorB (IEGeneric a, IEGeneric b)

public static IEImm zero (int bitsize)

Generates the value 0 with defined bitsize.

Parameters
bitsize Bitsize of the EImm

public static IEGeneric zeroExt (IEGeneric src, int dstSize)

Zero-extend operation IRE.

Parameters
dstSize must be greater or equal than src's size