# Class: com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EUtil Utility methods to manipulate [IR expressions](IEGeneric). ## Static Method: abs - parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext` - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond` Description: Absolute\-value operation applied to [IEGeneric](IEGeneric). parameter: ctx: routine context parameter: a: operand return: conditional absolute\-value expression ## Static Method: add - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: add - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `c`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: adjustBranchToIRInstruction - parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement` - parameter: `currentTargetIROffset`, type: `int` - parameter: `newTargetIROffset`, type: `int` - return type: `int` ## Static Method: andB - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: andL - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: buildCarryFlag - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `result`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `addition`, type: `boolean` - parameter: `nativeOp`, type: `boolean` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` Description: 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. parameter: a: operand a parameter: b: operand b parameter: result: result c \(may have an additional carry flag added before\) parameter: addition: true if the carry is to be computed for "a \+ b", false for "a \- b" parameter: nativeOp: indicate it [OperationType#CARRY](OperationType#CARRY) / [OperationType#LT_U](OperationType#LT_U) can be used over complex xor expression return: a one\-bit overflow flag IR expression ## Static Method: buildLogicalOperation - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` Description: Transform the operands of an operation into logical operands \(LOG\_NEQ with 0\). parameter: e: operation to transform return: transformed operation, or the input if no transformation was needed ## Static Method: buildOverflowFlag - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `result`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `addition`, type: `boolean` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` Description: 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. parameter: a: operand a parameter: b: operand b parameter: result: result c, comprising an optional carry flag added beforehand parameter: addition: true if the overflow is to be computed for "a \+ b", false for "a \- b" return: a one\-bit overflow flag IR expression ## Static Method: buildStrictLogicalECond - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond` Description: 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\). parameter: e: conditional expression to transform return: transformed IRE ## Static Method: buildStrictLogicalOperation - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` Description: 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\). parameter: e: operation to transform return: transformed IRE ## Static Method: calculateComplexity - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `int` Description: Calculate the trivial complexity metric for the provided IR expression. Every IR element has a weight of 1. parameter: e: expression to inspect return: trivial complexity value ## Static Method: checkCallReturnAddress - parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext` - parameter: `cfg`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.CFG` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.BasicBlock` - parameter: `insnIndex`, type: `int` - return type: `java.lang.Boolean` Description: parameter: ctx: parameter: cfg: parameter: b: parameter: insnIndex: return: null if the return address is not set; true if it is an immediate value matching the call expected return address \(i.e., following the call instruction itself\); false otherwise ## Static Method: checkFalse - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` ## Static Method: checkTrue - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` ## Static Method: cmpFloat - parameter: `op`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType` - parameter: `op1`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `op2`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` ## Static Method: collectVars - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `java.util.Set` ## Static Method: collectVars - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `sink`, type: `java.util.Collection` Description: Collect all EVars of an expression. If the expression is an EVar, it will be collected. parameter: e: IR expression parameter: sink: a recipient for collected EVars. Note that a set may be used to collect unique EVars, or a list may be used to collect all encountered EVars ## Static Method: compose - parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext` - parameter: `elts`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric[]` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` Description: Create a composition if the provided list of elements contains at least two entries, else return the single element. parameter: ctx: routine context used to create the composition parameter: elts: elements to compose return: composed expression, or the sole element if only one was provided ## Static Method: compose - parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext` - parameter: `elts`, type: `java.util.Collection` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` Description: Create a composition if the provided list of elements contains at list two entries, else return the single element. parameter: ctx: routine context used to create the composition parameter: elts: elements to compose return: composed expression, or the sole element if only one was provided ## Static Method: composeImms - parameter: `g`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IEGlobalContext` - parameter: `elts`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm[]` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm` ## Static Method: contains - parameter: `target`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `token`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: Indicates if the target expression contains any token expression parameter: target: expression to search into parameter: token: token to search return: true if target contains token ## Static Method: containsMemoryAccess - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: Indicates if the generic expression contains any memory access \(meaning [IEMem](IEMem)\) parameter: e: [IEGeneric](IEGeneric) return: true if the expression contains memory access. ## Static Method: containsUndeterminedInvocations - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: Indicates if the generic expression invokes any undetermined kind of call \(meaning [IECall](IECall), [IEJumpFar](IEJumpFar) or [IEUntranslatedInstruction](IEUntranslatedInstruction)\) parameter: e: [IEGeneric](IEGeneric) return: true if the expression contains undetermined invocation. ## Static Method: countExpressionPresence - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `target`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `int` Description: Recursively count \(using deep equality\) how many times the provided target is seen in the input expression. parameter: e: expression to be examined parameter: target: target return: presence count ## Static Method: countExpressionsPresence - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `targets`, type: `java.util.List` - parameter: `acounts`, type: `int[]` Description: Recursively count \(using deep equality\) how many times each of the provided targets is seen in the input expression. parameter: e: expression to be examined parameter: targets: targets parameter: acounts: output counts, the array size must match target's, and counts must be initially set to 0 ## Static Method: countSubExpressions - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `int` Description: Collect sub\-expressions of the input expression and return the cardinal of that collection. Simply calls [IEGeneric#collectSubExpressions(java.util.Collection)](IEGeneric#collectSubExpressions(java.util.Collection)). Not recursive\! parameter: e: expression to inspect return: number of direct sub\-expressions ## Static Method: countVariablePresence - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `target`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar` - return type: `int` Description: Count the number of times an [IEVar](IEVar) is present in an expression. \(Defined vars are counted as well.\) parameter: e: expression to inspect parameter: target: [IEVar](IEVar) to count return: number of occurrences ## Static Method: countVariableUse - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `int` ## Static Method: createConversionOperation - parameter: `convOperator`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType` - parameter: `src`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `dstSize`, type: `int` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` Description: Create a conversion operation: an integer truncation, integer extension \(zero or signed\), float truncation or extension, float\-to\-int and int\-to\-float conversion. parameter: convOperator: one of for which [OperationType#isConversion()](OperationType#isConversion()) returns true \(eg, [OperationType#CAST](OperationType#CAST), [OperationType#CAST_S](OperationType#CAST_S), [OperationType#FP2FP](OperationType#FP2FP), [OperationType#FP2INT](OperationType#FP2INT), [OperationType#INT2FP](OperationType#INT2FP)\) parameter: src: operand to be extended, truncated, or converted parameter: dstSize: resulting bitsize return: the operation IRE ## Static Method: createResizeOperation - parameter: `src`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `dstSize`, type: `int` - parameter: `signed`, type: `boolean` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` Description: Create a resize operation operation: truncation, zero\-extension, or sign\-extension. parameter: src: the source to be extended \(`dstSize > srcSize`\) or truncated \(`dstSize < srcSize`\) parameter: dstSize: the destination size; should be different than the source's parameter: signed: for extensions, else N/A return: the operation IRE ## Static Method: determineArgumentStackSlotCount - parameter: `prototype`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardPrototype` - parameter: `varArgTypes`, type: `java.util.Collection` - return type: `int` Description: Determine the number of stacks slots used by invoking a method having the provided prototype and an optional list of additional arguments. parameter: prototype: parameter: varArgTypes: optional; the prototype MUST be marked VarArg for this to not be disregarded return: ## Static Method: determineReturnValuesStackSlotCount - parameter: `prototype`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardPrototype` - parameter: `inputStackSlotCount`, type: `int` - return type: `int` Description: Determine the number of stack slots filled out when a routine with the provided prototype returns. parameter: prototype: parameter: 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 return: ## Static Method: div - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `signed`, type: `boolean` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` Description: Alias for [#divS(IEGeneric, IEGeneric)](#divS(IEGeneric, IEGeneric)) / [#divU(IEGeneric, IEGeneric)](#divU(IEGeneric, IEGeneric)). parameter: a: dividend parameter: b: divisor parameter: signed: true to create a signed division return: division operation ## Static Method: divS - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: divU - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: dump - parameter: `cfg`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.CFG` - parameter: `filename`, type: `java.lang.String` Description: Dump an IR\-CFG to a Graphviz `dot` file in the user's temporary folder. parameter: cfg: CFG parameter: filename: filename \(the ".dot" extension will be appended if necessary\) ## Static Method: dump - parameter: `cfg`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.CFG` - parameter: `filename`, type: `java.lang.String` - parameter: `title`, type: `java.lang.String` Description: Dump an IR\-CFG to a Graphviz `dot` file in the user's temporary folder. parameter: cfg: CFG parameter: filename: filename \(the ".dot" extension will be appended if necessary\) parameter: title: optional title or header string ## Static Method: eq - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: evalAsPositiveInt - parameter: `imm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm` - return type: `int` Description: Evaluate an immediate to a 32\-bit positive int. Apply Integer positive mask is greater than [Integer#MAX_VALUE](Integer#MAX_VALUE). parameter: imm: return: ## Static Method: evalAsSaturatedPositiveInt - parameter: `imm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm` - return type: `int` Description: Evaluate and convert a positive immediate to a 32\-bit int. If the immediate is greater than [Long#MAX_VALUE](Long#MAX_VALUE), the method will throw. It the evaluated value is greater than [Integer#MAX_VALUE](Integer#MAX_VALUE), Integer\#MAX\_VALUE will be returned. parameter: imm: immediate to be evaluated return: a 32\-bit positive or zero int see also: IEImm#getValueAsUnsignedLong() ## Static Method: evaluateAddress_preVerified - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `state`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EState` - return type: `long` ## Static Method: evaluateAddress_preVerified - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `long` ## Static Method: evaluateUnsignedLong_preVerified - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `state`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EState` - return type: `long` ## Static Method: evaluateUnsignedLong_preVerified - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `long` ## Static Method: evaluate_preVerified - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `state`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EState` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm` ## Static Method: evaluate_preVerified - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm` ## Static Method: expandCalls - parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext` - parameter: `alsoExpandPCAssign`, type: `boolean` - return type: `boolean` Description: 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 parameter: ctx: routine context parameter: alsoExpandPCAssign: if true, PC\-assigns will also be expanded; else, only ECalls are expanded return: success indicator ## Static Method: expandStatementSize - parameter: `ectx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext` - parameter: `stm0`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement` - parameter: `minSize`, type: `int` - return type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.CFG` Description: Expand the [size](IInstruction#getSize()) of a statement. CAREFUL\! This method can modify the structure of the CFG \(block order, block count, etc.\). parameter: ectx: parameter: stm0: parameter: minSize: return: the resulting CFG \(it may be the original CFG\) ## Static Method: expandStatementSizes - parameter: `ectx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext` - parameter: `stmcoll`, type: `java.util.Collection` - parameter: `minSize`, type: `int` - return type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.CFG` Description: Expand the [sizes](IInstruction#getSize()) of a collection of statements. CAREFUL\! This method can modify the structure of the CFG \(block order, block count, etc.\). parameter: ectx: parameter: stmcoll: parameter: minSize: return: the resulting CFG \(it may be the original CFG\) ## Static Method: extend - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `bitsize`, type: `int` - parameter: `signExtend`, type: `boolean` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` Description: Extend an [IEGeneric](IEGeneric). Return null if provided [IEGeneric](IEGeneric) is null. parameter: a: expression to extend parameter: bitsize: target bitsize parameter: signExtend: true to sign\-extend, false to zero\-extend return: extended expression, or null if `a` is null ## Static Method: fabs - parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext` - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond` Description: Operation [Math#abs(float)](Math#abs(float)) applied to [IEGeneric](IEGeneric). parameter: ctx: routine context parameter: a: operand return: conditional absolute\-value expression ## Static Method: fmax - parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext` - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond` Description: Operation [Math#max(float, float)](Math#max(float, float)) applied to [IEGeneric](IEGeneric) parameter: ctx: routine context parameter: a: first operand parameter: b: second operand return: conditional maximum expression ## Static Method: fmin - parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext` - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond` Description: Operation [Math#min(float, float)](Math#min(float, float)) applied to [IEGeneric](IEGeneric) parameter: ctx: routine context parameter: a: first operand parameter: b: second operand return: conditional minimum expression ## Static Method: formatIR - parameter: `ectx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext` - return type: `java.lang.String` Description: Format an IR\-CFG. parameter: ectx: routine context return: the formatted CFG ## Static Method: formatIR - parameter: `ectx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext` - parameter: `displayOffsets`, type: `boolean` - parameter: `displayDataChains`, type: `boolean` - parameter: `displayTypes`, type: `boolean` - return type: `java.lang.String` Description: Format an IR\-CFG. parameter: ectx: routine context parameter: displayOffsets: true to display IR offsets parameter: displayDataChains: true to display data\-flow information parameter: displayTypes: true to display expression types return: the formatted CFG ## Static Method: formatStatements - parameter: `irlist`, type: `java.util.List` - return type: `java.lang.String` ## Static Method: formatVars - parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext` - parameter: `varids`, type: `java.util.Collection` - return type: `java.lang.String` ## Static Method: formatVars - parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext` - parameter: `varids`, type: `int[]` - return type: `java.lang.String` ## Static Method: gatherArgumentTypes - parameter: `prototype`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardPrototype` - parameter: `varArgTypes`, type: `java.util.Collection` - return type: `java.util.List` Description: Retrieve the list of input types, by examining the provided prototype and optional list of additional arguments. parameter: prototype: parameter: varArgTypes: optional; the prototype MUST be marked VarArg for this to not be disregarded return: ## Static Method: geS - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: geU - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: getAssigningFromMemory - parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEMem` Description: Determine if the statement is an [IEAssign](IEAssign) from an [IEMem](IEMem). If so, return the memory source. parameter: stm: return: a memory IRE or null ## Static Method: getAssigningToMemory - parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEMem` Description: Determine if the statement is an [IEAssign](IEAssign) to an [IEMem](IEMem). If so, return the memory target. ``` DST = mXX[???] ``` parameter: stm: return: a memory IRE or null ## Static Method: getAssignmentDestination - parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` Description: Retrieve the destination of an [IEAssign](IEAssign) \(or null if is not an assignment\). parameter: stm: return: ## Static Method: getAssignmentSource - parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` Description: Retrieve the source of an [IEAssign](IEAssign) \(or null if is not an assignment\). parameter: stm: return: ## Static Method: getBestType - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType` Description: parameter: a: parameter: b: return: ## Static Method: getMirrorOperation - parameter: `optype`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType` ## Static Method: getOperation - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `optypes`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType[]` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType` ## Static Method: getOperation - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` - parameter: `optypes`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType[]` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType` ## Static Method: getParents - parameter: `expression`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `value`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `java.util.List` Description: Retrieve all the parents of a value. The search is done by reference. parameter: expression: expression to search into. parameter: value: value to be searched. return: the list of direct parents. ## Static Method: getReverseOperation - parameter: `optype`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType` ## Static Method: getSignExtensionBase - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` Description: Check if an IR expression looks like a sign\-extension operation, and if so, provide the base expression. parameter: e: expression to inspect return: base expression if the input looks like a sign extension, null otherwise ## Static Method: getSignExtensionBase - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECompose` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` Description: Check if the composition is a sign\-extension of a base expression, and if so, provide the base expression. parameter: e: expression to test that should be a signExtend return: the base expression ## Static Method: getSignExtensionBase - parameter: `base`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `extend`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` Description: 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` parameter: base: candidate base \(i.e., base we expect to retrieve\) parameter: extend: candidate sign\-extension expression, extending `base` return: base on success, else null ## Static Method: getSubExpressions - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `java.util.List` Description: Collect the sub\-expressions of an IRE. Simply calls [IEGeneric#collectSubExpressions(java.util.Collection)](IEGeneric#collectSubExpressions(java.util.Collection)). Not recursive\! parameter: e: expression to inspect return: direct sub\-expressions ## Static Method: getUsedVarIds - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `java.util.Set` ## Static Method: getVarSlice - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar` ## Static Method: getVarSliceId - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `java.lang.Integer` ## Static Method: getVars - parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext` - parameter: `varids`, type: `java.util.Collection` - return type: `java.util.List` ## Static Method: getWildcardTypes - parameter: `etypeman`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardTypeManager` - parameter: `elts`, type: `java.util.Collection` - return type: `java.util.List` ## Static Method: gtS - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: gtU - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: hasExplicitlyUsedVar - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `target`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar` - return type: `boolean` ## Static Method: hasLinearControlFlow - parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext` - return type: `boolean` Description: Checks if an IR routine contains only basic blocks with one parent and one child \(no merge or disjunction of control\-flow\). return: ## Static Method: hasNoSideEffect - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: 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)](#hasSideEffect(IEGeneric)). parameter: e: return: ## Static Method: hasNoTypeInfo - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: Determine if the provided IR expression embeds *no amount at all* of type information. parameter: e: return: ## Static Method: hasSameType - parameter: `e1`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `e2`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: parameter: e1: parameter: e2: return: ## Static Method: hasSideEffect - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: The opposite of [#hasNoSideEffect(IEGeneric)](#hasNoSideEffect(IEGeneric)). parameter: e: return: ## Static Method: hasTypeInfo - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: Determine if the provided IR expression embeds some type information. Note that the sub\-expressions are **not** examined. parameter: e: return: ## Static Method: identL - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` ## Static Method: imm - parameter: `val`, type: `long` - parameter: `bitsize`, type: `int` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm` Description: Create an immediate, limited to 64 bits. parameter: val: immediate value parameter: bitsize: immediate bitsize return: immediate expression ## Static Method: imm - parameter: `val`, type: `byte[]` - parameter: `bitsize`, type: `int` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm` Description: Create an arbitrary\-long immediate. parameter: val: big\-endian bytes of the value parameter: bitsize: immediate bitsize return: immediate expression ## Static Method: imm - parameter: `val`, type: `java.math.BigInteger` - parameter: `bitsize`, type: `int` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm` Description: Create an arbitrary\-long immediate. parameter: val: value parameter: bitsize: immediate bitsize return: immediate expression ## Static Method: imm - parameter: `val`, type: `java.lang.String` - parameter: `bitsize`, type: `int` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm` Description: Create an arbitrary\-long immediate. parameter: val: string representation of the integer immediate parameter: bitsize: immediate bitsize return: immediate expression ## Static Method: immToInt32Array - parameter: `val`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm` - return type: `int[]` ## Static Method: immToInt32Array - parameter: `val`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm` - parameter: `dst`, type: `int[]` - parameter: `index`, type: `int` ## Static Method: int32ArrayToImm - parameter: `g`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IEGlobalContext` - parameter: `dst`, type: `int[]` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm` ## Static Method: int32ArrayToImm - parameter: `g`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IEGlobalContext` - parameter: `dst`, type: `int[]` - parameter: `index`, type: `int` - parameter: `indexEnd`, type: `int` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm` ## Static Method: isAssignedIn - parameter: `bb`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.BasicBlock` - parameter: `checkedDst`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: 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. parameter: bb: basic block to inspect parameter: checkedDst: destination expression to search for return: true if the destination is assigned in the block ## Static Method: isBitOne - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: Verify that an IRE is a single\-bit immediate set to 1 \(technically, \-1\). parameter: e: expression to test return: true if the expression is a one\-bit immediate set to 1 ## Static Method: isBitZero - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: Verify that an IRE is a single\-bit immediate set to 0. parameter: e: expression to test return: true if the expression is a one\-bit immediate set to 0 ## Static Method: isComparableIntegerOperation - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` - return type: `boolean` ## Static Method: isComparableOperation - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: ""Boolean"" comparable operation \(eq/neq and all greater/lesser comparisons\) parameter: e: IR expression return: true if this is a comparable operation ## Static Method: isComparableOperation - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` - return type: `boolean` ## Static Method: isComparableOperation - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` - parameter: `allowUnsigned`, type: `boolean` - parameter: `allowFloat`, type: `boolean` - return type: `boolean` ## Static Method: isComparableSignedOperation - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` - return type: `boolean` ## Static Method: isCondEAssign - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement` - return type: `boolean` ## Static Method: isConditionalJump - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement` - return type: `boolean` ## Static Method: isExpressionModified - parameter: `insn`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement` - parameter: `target`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `defuse`, type: `boolean` - return type: `boolean` ## Static Method: isFirstBit - parameter: `s2`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IESlice` - return type: `boolean` ## Static Method: isImmNonZero - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` ## Static Method: isImmSize - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `bitsize`, type: `int` - return type: `boolean` ## Static Method: isImmValue - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `value`, type: `long` - return type: `boolean` ## Static Method: isImmValue - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `value`, type: `java.math.BigInteger` - return type: `boolean` ## Static Method: isImmZero - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` ## Static Method: isImmediate - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: Determine if the [IEGeneric](IEGeneric) is an [IEImm](IEImm). Use when e can be null, otherwise prefer native [IEGeneric#isImm()](IEGeneric#isImm()) parameter: e: IR expression return: `e != null && e.IsImm()` ## Static Method: isJump - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` ## Static Method: isLastBit - parameter: `s2`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IESlice` - return type: `boolean` ## Static Method: isLegalSignedImmediate - parameter: `v`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm` - parameter: `checkedBitsize`, type: `int` - return type: `boolean` Description: Verify that the provided immediate is a legal signed value if it were to be treated as a signed integer of \`checkedBitsize\`. Examples: ``` the 64-bit value 0x00000000_07FFFFFFF is legal if treated as a 32-bit signed immediate the 64-bit value 0xFFFFFFFF_FFFFE0000 is legal if treated as a 32-bit signed immediate the 64-bit value 0x00000000_87FFFFFFF is ILLEGAL if treated as a 32-bit signed immediate the 64-bit value 0x00100000_000000012 is ILLEGAL if treated as a 32-bit signed immediate the 64-bit value 0xFFFF00FF_FFFFE0000 is ILLEGAL if treated as a 32-bit signed immediate ``` parameter: v: parameter: checkedBitsize: return: ## Static Method: isLegalUnsignedImmediate - parameter: `v`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm` - parameter: `checkedBitsize`, type: `int` - return type: `boolean` Description: Verify that the provided immediate is a legal unsigned value if it were to be treated as an unsigned integer of \`checkedBitsize\`. parameter: v: parameter: checkedBitsize: return: ## Static Method: isLikeImmediate - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: Determine if the IRE is an EImm or a slice or composition of immediates. parameter: a: return: ## Static Method: isLikeLongImmediate - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: Determine if the expression is equivalent to an EImm that can be read as a `long` primitive. parameter: e: expression return: ## Static Method: isLikeLongImmediate - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `unsigned`, type: `boolean` - return type: `boolean` Description: Determine if the expression is equivalent to an EImm that can be read as a `long` primitive. parameter: e: expression parameter: unsigned: return: ## Static Method: isLogicalOperation - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: ""Boolean"" operation \(and, or, not, eq/neq and all greater/lesser comparisons\) parameter: e: IR expression return: true if this is a logical operation ## Static Method: isLongImmediate - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: Determine if the expression is an EImm that can be read as a `long` primitive. parameter: e: expression return: ## Static Method: isLongImmediate - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `unsigned`, type: `boolean` - return type: `boolean` Description: Determine if the expression is an EImm that can be read as a `long` primitive. parameter: e: expression parameter: unsigned: return: ## Static Method: isMatchDuaryOperation - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `wantedOperationType`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType` - parameter: `wantedOperand1`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `wantedOperand2`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` ## Static Method: isMinusOne - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: Verify that an IRE is an immediate holding the value \-1. parameter: e: expression to test return: true if the expression is an immediate holding \-1 ## Static Method: isNBit - parameter: `s2`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IESlice` - parameter: `n`, type: `int` - return type: `boolean` ## Static Method: isNaN - parameter: `op`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` Description: 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 parameter: op: floating\-point expression to test return: expression evaluating to true if the operand is NaN ## Static Method: isNotPredicate - parameter: `p`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `p2`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: Indicate if p == \!p2. Search for reversed operator as well as mirrored predicate. Do not consider NOT operations. parameter: p: reference predicate parameter: p2: predicate to test return: true if `p2` is the negation of `p` ## Static Method: isOne - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: 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)](#isBitOne(IEGeneric)) or [#isMinusOne(IEGeneric)](#isMinusOne(IEGeneric)) instead. parameter: e: expression to test return: true if the expression is an immediate holding 1 ## Static Method: isOperation - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `optype`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType` - return type: `boolean` Description: Determine if the [IEGeneric](IEGeneric) is an [IEOperation](IEOperation). Use when e can be null, otherwise prefer native [IEGeneric#isOperation(OperationType)](IEGeneric#isOperation(OperationType)) parameter: e: IR expression parameter: optype: operation type to test return: `e != null && e.IsOperation(optype)` ## Static Method: isOperation - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `optypes`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType[]` - return type: `boolean` Description: Determine if the [IEGeneric](IEGeneric) is an [IEOperation](IEOperation). Use when e can be null, otherwise prefer native [IEGeneric#isOperation(OperationType...)](IEGeneric#isOperation(OperationType...)) parameter: e: IR expression parameter: optypes: operation types to test return: `e != null && e.IsOperation(optypes)` ## Static Method: isOperationSize - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `bitsize`, type: `int` - return type: `boolean` ## Static Method: isPCAssign - parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement` - return type: `boolean` Description: Determine if the provided statement is a PC\-assign: `PC = ...` parameter: stm: a statement return: true if the statement assigns the program counter ## Static Method: isSPAssign - parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement` - return type: `boolean` Description: Determine if the provided statement is a SP\-assign: `SP = ...` or `SP[slice] = ...`. parameter: stm: a statement return: true if the statement assigns the stack pointer ## Static Method: isSPAssignOrPCAssign - parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement` - return type: `boolean` Description: Determine if the provided statement is assigning the stack pointer or the program counter. Combines [#isSPAssign(IEStatement)](#isSPAssign(IEStatement)) [#isPCAssign(IEStatement)](#isPCAssign(IEStatement)) in a single efficient call. parameter: stm: a statement return: true if the statement assigns the stack pointer or the program counter ## Static Method: isSameType - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType` - return type: `boolean` Description: parameter: a: parameter: b: return: ## Static Method: isStrictLogicalOperation - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: Logical operations that should have logical operands \(and, or, not\). parameter: e: expression to test return: true if the expression is a strict logical operation ## Static Method: isStrictLogicalOperation - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` - return type: `boolean` ## Static Method: isTrampoline - parameter: `bb`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.BasicBlock` - return type: `boolean` ## Static Method: isUnconditionalJump - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement` - return type: `boolean` ## Static Method: isVar - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `id`, type: `int` - return type: `boolean` ## Static Method: isVarOrVarSlice - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` ## Static Method: isVariableAssigned - parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement` - parameter: `var`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar` - return type: `boolean` Description: parameter: stm: parameter: var: return: ## Static Method: isZero - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` Description: Verify that an IRE is a Zero representation \(EImm\(0\) or ESlice\(0, x, x\)\). parameter: e: expression to test return: true if the expression is zero ## Static Method: isZeroExtend - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `boolean` ## Static Method: isZeroExtend - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECompose` - return type: `boolean` ## Static Method: leS - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: leU - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: looksLikeSignExtension - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECompose` - return type: `boolean` Description: Determine if a composition looks like a sign\-extension operation. parameter: e: composition to inspect return: true if the composition looks like a sign extension ## Static Method: ltS - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: ltU - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: makeUncond - parameter: `j`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEJumpWithOptionalCondition` Description: Make a jump unconditional. parameter: j: jump to update throws: if the jump condition contains undetermined invocations ## Static Method: mask - parameter: `bitsize`, type: `int` - parameter: `maskbits`, type: `int` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm` Description: Create a bit mask, eg mask\(16, 4\) will create the mask: `b0000000000001111` parameter: bitsize: immediate bitsize parameter: maskbits: number of low bits to set; must be less than or equal to `bitsize` return: mask immediate ## Static Method: mask - parameter: `bitsize`, type: `int` - parameter: `maskbegin`, type: `int` - parameter: `maskend`, type: `int` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm` Description: Create a bit mask, eg mask\(16, 1, 5\) will create the mask: `b0000000000011110` parameter: bitsize: immediate bitsize parameter: maskbegin: start bit of the mask, inclusive parameter: maskend: end bit of the mask, exclusive return: mask immediate ## Static Method: max - parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext` - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `signed`, type: `boolean` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond` Description: Operation [Math#max(int, int)](Math#max(int, int)) applied to [IEGeneric](IEGeneric). parameter: ctx: routine context parameter: a: first operand parameter: b: second operand parameter: signed: true to use signed comparison return: conditional maximum expression ## Static Method: min - parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext` - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `signed`, type: `boolean` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond` Description: Operation [Math#min(int, int)](Math#min(int, int)) applied to [IEGeneric](IEGeneric). parameter: ctx: routine context parameter: a: first operand parameter: b: second operand parameter: signed: true to use signed comparison return: conditional minimum expression ## Static Method: minusOne - parameter: `bitsize`, type: `int` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm` Description: Generates the value \-1, ie an [IEImm](IEImm) filled with ones. parameter: bitsize: bitsize of the [IEImm](IEImm) return: immediate expression ## Static Method: mul - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: ne - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: notB - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` ## Static Method: notL - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` ## Static Method: notL - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `allowOpt`, type: `boolean` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` ## Static Method: one - parameter: `bitsize`, type: `int` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm` Description: Generates the value 1L with defined bitsize. Do not mistake [one](#one(int)) for [minusOne](#minusOne(int)) parameter: bitsize: bitsize of the [IEImm](IEImm) return: immediate expression ## Static Method: op - parameter: `operator`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType` - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: op - parameter: `operator`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType` - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: orB - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: orL - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: pow - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: remS - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: remU - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: replaceSubExpressionRecursive - parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `src`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `dst`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` ## Static Method: replaceSubExpressionRecursive - parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `src`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `dst`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `results`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EVisitResults` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` ## Static Method: requiresExplicitCast - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType` - return type: `boolean` Description: Determine if type \`b\` can be implicitly converted to type \`a\`, without a cast. parameter: a: parameter: b: return: ## Static Method: resize - parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `wantedBitsize`, type: `int` - parameter: `signExtend`, type: `boolean` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` ## Static Method: resolveExpressionsBackward - parameter: `name`, type: `java.lang.Object` - parameter: `conv`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IEConverter` - parameter: `r`, type: `java.util.List` - parameter: `targets`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric[]` - return type: `boolean` Description: Apply a list of IEStatements to user targets, resolving expression starting from last [IEStatement](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 ``` parameter: name: parameter: conv: parameter: r: parameter: targets: return: ## Static Method: reversePredicate - parameter: `predicate`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` ## Static Method: safeExtend - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `bitsize`, type: `int` - parameter: `signExtend`, type: `boolean` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` Description: Safely extend an [IEGeneric](IEGeneric). Return null if provided [IEGeneric](IEGeneric) is null. If bitsize is less that current [IEGeneric](IEGeneric), the [IEGeneric](IEGeneric) relative part is returned. parameter: a: expression to extend or truncate parameter: bitsize: target bitsize parameter: signExtend: true to sign\-extend, false to zero\-extend return: resized expression, or null if `a` is null ## Static Method: sameBitsize - parameter: `elts`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric[]` - return type: `int` Description: 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\). parameter: elts: a list of IRE return: the common bitsize of all provided elements; 0 if the elements do not have the same bitsize ## Static Method: sameBitsizeAllowNulls - parameter: `elts`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric[]` - return type: `int` Description: If all the provided expressions have the same bitsize, return it. Null elements are ignored. parameter: elts: a list of IRE return: the common bitsize of all provided elements; 0 if the elements do not have the same bitsize ## Static Method: sar - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: setLowerLevelAddress - parameter: `addr`, type: `long` - parameter: `list`, type: `java.util.List` ## Static Method: setLowerLevelAddress - parameter: `addr`, type: `long` - parameter: `list`, type: `java.util.List` - parameter: `fromIndex`, type: `int` - parameter: `toIndex`, type: `int` ## Static Method: setLowerLevelAddressIfNone - parameter: `addr`, type: `long` - parameter: `list`, type: `java.util.List` ## Static Method: setLowerLevelAddressIfNone - parameter: `addr`, type: `long` - parameter: `list`, type: `java.util.List` - parameter: `fromIndex`, type: `int` - parameter: `toIndex`, type: `int` ## Static Method: shl - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: shr - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: signExt - parameter: `src`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `dstSize`, type: `int` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` Description: Sign\-extend operation IRE. parameter: src: expression to extend parameter: dstSize: must be greater or equal than src's size return: sign\-extended expression ## Static Method: sub - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: sxr - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `signedExtension`, type: `boolean` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: truncate - parameter: `src`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `dstSize`, type: `int` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` Description: Truncate operation IRE. parameter: src: expression to truncate parameter: dstSize: must be less or equal than src's size return: truncated expression ## Static Method: verify - parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext` Description: Verify an IR\-CFG. This method relies on the [ECFGVerifier](ECFGVerifier) and throws on error. parameter: ctx: IR context ## Static Method: verify - parameter: `cfg`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.CFG` Description: Verify an IR\-CFG. This method relies on the [ECFGVerifier](ECFGVerifier) and throws on error. parameter: cfg: IR graph ## Static Method: xorB - parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation` ## Static Method: zero - parameter: `bitsize`, type: `int` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm` Description: Generates the value 0 with defined bitsize. parameter: bitsize: bitsize of the [IEImm](IEImm) return: immediate expression ## Static Method: zeroExt - parameter: `src`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` - parameter: `dstSize`, type: `int` - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric` Description: Zero\-extend operation IRE. parameter: src: expression to extend parameter: dstSize: must be greater or equal than src's size return: zero\-extended expression