# Interface: com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric
- Super interfaces: `com.pnfsoftware.jeb.core.units.code.IInstructionOperand`

Base interface for IR expressions \(IRE\) used by JEB's native decompilation engine,  `gendec`. They can be statements or non\-statements.  

  Refer to sub\-interfaces. Refer to [IEStatement](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement.md) for statements.

## Abstract Method: accessesMemory
- return type: `boolean`

Description: Determine whether this IRE accesses memory.
return: true if the expression reads or writes to memory

## Abstract Method: addFlags
- parameter: `addedFlags`, type: `int`
- return type: `boolean`

Description: Add flags to this IRE's flags list.
parameter: addedFlags: flags to add
return: true if the flags were effectively changed \(new additions were made\); false otherwise

## Default Method: asCompose
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECompose`

Description: 
return: this IRE as an [IECompose](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECompose.md)

## Default Method: asCond
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond`

Description: 
return: this IRE as an [IECond](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond.md)

## Default Method: asGroup
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGroup`

Description: 
return: this IRE as an [IEGroup](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGroup.md)

## Default Method: asGroupElt
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGroupElt`

Description: 
return: this IRE as an [IEGroupElt](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGroupElt.md)

## Default Method: asImm
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`

Description: 
return: this IRE as an [IEImm](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm.md)

## Default Method: asMem
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEMem`

Description: 
return: this IRE as an [IEMem](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEMem.md)

## Default Method: asOperation
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`

Description: 
return: this IRE as an [IEOperation](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation.md)

## Default Method: asRange
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IERange`

Description: 
return: this IRE as an [IERange](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IERange.md)

## Default Method: asSlice
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IESlice`

Description: 
return: this IRE as an [IESlice](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IESlice.md)

## Default Method: asStatement
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement`

Description: 
return: this IRE as an [IEStatement](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement.md)

## Default Method: asVar
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar`

Description: 
return: this IRE as an [IEVar](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar.md)

## Abstract Method: bit
- parameter: `pos`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Retrieve a one bit value at the pos position
parameter: pos: bit position to be retrieved
return: [IEGeneric](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric.md) of size 1 with bit at position \`pos\`

## Abstract Method: collectSubExpressions
- parameter: `sink`, type: `java.util.Collection<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric>`

Description: Perform a shallow collection of the sub\-expressions of this expression. All collected  expressions are directly rooted in this IRE \(i.e. their parent is this IR expression\).  

  This method appends to the provided sink \(existing elements are not cleared\). The current  element \(this\) is not appended; only the sub\-expressions are considered.
parameter: sink: output collection

## Abstract Method: copyProperties
- parameter: `srcExp`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Copy the base properties from the provided IR source expression to this expression.
parameter: srcExp: source expression

## Abstract Method: countSuccessiveBits
- parameter: `ones`, type: `boolean`
- parameter: `fromMsb`, type: `boolean`
- parameter: `bitsize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond`

Description: Count successive bits in an integer, starting from MSB or LSB.
parameter: ones: true if '1's should be counted, false for '0's
parameter: fromMsb: true if count should start from MSB, false from LSB
parameter: bitsize: 

## Abstract Method: duplicate
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Clone \(deep copy\) the expression.
return: the duplicate expression

## Abstract Method: equalsEx
- parameter: `obj`, type: `java.lang.Object`
- parameter: `includeType`, type: `boolean`
- return type: `boolean`

Description: Same as [Object#equals(Object)](Object#equals(Object)) with the possibility to exclude the type from the  comparison.
parameter: obj: object to compare
parameter: includeType: true to include the type in the equality test
return: true if equal

## Abstract Method: evaluate
- 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`
- throws: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.exceptions.EvaluationException`

Description: Evaluate the IRE.
parameter: state: IR state \(input and output\)
return: the evaluation if the IRE; null if the state is configured to soft\-fail on errors
throws: thrown if the state is configured to hard\-fail on errors              \(default\)

## Abstract Method: evaluateAddress
- parameter: `state`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EState`
- return type: `long`
- throws: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.exceptions.EvaluationException`

Description: Evaluate the IRE as a 64\-bit address.
parameter: state: IR state
return: the evaluated address
throws: thrown if the state is configured to hard\-fail on errors              \(default\)

## Abstract Method: evaluateUnsignedLong
- parameter: `state`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EState`
- return type: `long`
- throws: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.exceptions.EvaluationException`

Description: Evaluate the IRE as an unsigned long value. This convenience method will throw if the  underlying immediate bit size exceeds 63 bits \(unsigned value\).
parameter: state: IR state
return: the evaluation if the IRE, as an **unsigned** value, if meaningful; the state is          also updated
throws: thrown if the state is configured to hard\-fail on errors              \(default\)

## Default Method: examine
- parameter: `tester`, type: `java.util.function.Predicate<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric>`
- return type: `boolean`

Description: Visit the constituents of this expression, and check if one of them is passing the provided  test.
parameter: tester: a predicate object examining the [IEGeneric](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric.md) elements of this expression
return: true if a constituent passed the test; false if none passed the test

## Default Method: extend
- parameter: `newBitsize`, type: `int`
- parameter: `signedExtension`, type: `boolean`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: 
parameter: newBitsize: 
parameter: signedExtension: 
return: 

## Abstract Method: find
- parameter: `elt`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `start`, type: `int`
- parameter: `comparisonMethod`, type: `int`
- parameter: `thisParent`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.util.base.Couple<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric,com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric>`

Description: Find the parent of the the provided child element.
parameter: elt: an IR element; if the element is `this`, the method will return null
parameter: start: count of instances of `elt` that should be skipped before returning the             parent element; this is useful is the element provided may not be unique within             the tree \(e.g. IEVar\)
parameter: comparisonMethod: 0= identity, 1= equality, 2= type\-less equality
parameter: thisParent: optional parent of *this* IR element
return: if found, the pair \(parent, element\) parent; else, null

## Abstract Method: findByType
- parameter: `clazz`, type: `java.lang.Class<T>`
- return type: `T`

Description: Find the first child element by type.
parameter: T: 
parameter: clazz: type of the element to be found; careful, if the type is the one of             `this`, then this object will be returned
return: the element or null

## Abstract Method: findByType
- parameter: `clazz`, type: `java.lang.Class<T>`
- parameter: `start`, type: `int`
- return type: `T`

Description: Find a child element by type.
parameter: T: 
parameter: clazz: type of the element to be found; careful, if the type is the one of             `this`, then this object will be returned
parameter: start: count of matched elements that should be skipped before returning the element
return: the element or null

## Abstract Method: findParent
- parameter: `elt`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Find the parent of the first instance of the provided child element. The comparison is done  by identity.
parameter: elt: an IR element; if the element is `this`, the method will return null
return: the parent or null

## Abstract Method: findParent
- parameter: `elt`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `start`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Find the parent of the the provided child element. The comparison is done by identity.
parameter: elt: an IR element; if the element is `this`, the method will return null
parameter: start: count of instances of `elt` that should be skipped before returning the             parent element; this is useful is the element provided may not be unique within             the tree \(e.g. IEVar\)
return: the parent or null

## Abstract Method: generateC
- parameter: `ectx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `cctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ast.ICMethod`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ast.ICElement`

Description: Generate the C abstract syntax tree portion for this expression.
parameter: ectx: IR routine context
parameter: cctx: C routine local context
return: the C AST element \(may contain sub\-elements\)

## Abstract Method: getBitsize
- return type: `int`

Description: Get the size, in bits, of the IR expression. It is illegal to query The bitsize of some  expressions.
return: the size in bits

## Abstract Method: getDefinedOrUsedAsDestination
- parameter: `defuse`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EDefUseInfo`

Description: For [non\-statements](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement.md) only. Assuming 'this' is a destination value, extract  the variable or variable bits that are used and defined by it.
parameter: defuse: sink \- both the \`def\` and \`use\` field may be modified

## Abstract Method: getExplicitlyUsed
- parameter: `defuse`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EDefUseInfo`

Description: Get a list of variable or variable bits 'explicitly used' \(read\) by the instruction. This  method is inherently deep.
parameter: defuse: sink \- only the \`use\` field is modified

## Default Method: getExplicitlyUsed
- return type: `com.pnfsoftware.jeb.core.units.code.IdRanges`

Description: Convenience method around [#getExplicitlyUsed(EDefUseInfo)](#getExplicitlyUsed(EDefUseInfo)).
return: an used id ranges object

## Abstract Method: getFlags
- return type: `int`

Description: Get the expression flags.  

  The flags are defined in the sub\-interfaces. They do not overlap.
return: expression flags

## Abstract Method: getPriority
- return type: `int`

Description: Get the base priority level of the expression. Higher number correlates to lower priority; 0  means "no priority". \(Therefore, the highest priority level is 1.\)
return: expression priority

## Abstract Method: getSafeType
- parameter: `etypeman`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardTypeManager`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType`

Description: Generate a safe wildcard type for the expression, if it doesn't already have one. If  generated, the type is NOT assigned to the IR expression.
parameter: etypeman: 
return: the wildcard type, never null

## Abstract Method: getType
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType`

Description: Get the currently set intermediate\-type.
return: 

## Abstract Method: getUsed
- parameter: `defuse`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EDefUseInfo`

Description: Retrieve the variables or variable bits 'used' \(read\) by the instruction. This method is  inherently deep.  

  Note that some IRE may implicitly use variables, such as some [ECall](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECall.md),  [PC\-assigns](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEAssign.md), [UntranslatedInstruction](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEUntranslatedInstruction.md). This  method returns those implicit uses.
parameter: defuse: sink \- only the \`use\` field is modified

## Default Method: getUsed
- return type: `com.pnfsoftware.jeb.core.units.code.IdRanges`

Description: Convenience method to invoke [#getUsed(EDefUseInfo)](#getUsed(EDefUseInfo)).
return: an used id ranges object

## Abstract Method: half
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Retrieve the lower half\-part of this IRE. If the IRE does not have an even count of bits N,  then the lowest CEIL\(N/2\) bits are returned.
return: 

## Abstract Method: hasFlags
- parameter: `checkedFlags`, type: `int`
- return type: `boolean`

Description: Check if this IRE contains the provided flags.
parameter: checkedFlags: flags to check
return: true if all the checked flags are present

## Default Method: isCompose
- return type: `boolean`

Description: 
return: true if this IRE is an [IECompose](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECompose.md)

## Default Method: isCond
- return type: `boolean`

Description: 
return: true if this IRE is an [IECond](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond.md)

## Default Method: isGroup
- return type: `boolean`

Description: 
return: true if this IRE is an [IEGroup](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGroup.md)

## Default Method: isGroupElt
- return type: `boolean`

Description: 
return: true if this IRE is an [IEGroupElt](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGroupElt.md)

## Default Method: isImm
- return type: `boolean`

Description: 
return: true if this IRE is an [IEImm](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm.md)

## Default Method: isMem
- return type: `boolean`

Description: 
return: true if this IRE is an [IEMem](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEMem.md)

## Default Method: isOperation
- return type: `boolean`

Description: 
return: true if this IRE is an [IEOperation](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation.md)

## Default Method: isOperation
- parameter: `expectedOp`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType`
- return type: `boolean`

Description: 
parameter: expectedOp: an operator
return: true if this IRE is an [IEOperation](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation.md) using the provided operator

## Default Method: isOperation
- parameter: `candidateOps`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType[]`
- return type: `boolean`

Description: 
parameter: candidateOps: a list of operators
return: true if this IRE is an [IEOperation](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation.md) using one of the candidate operators

## Default Method: isOperation
- parameter: `name`, type: `java.lang.String`
- return type: `boolean`

Description: 
parameter: name: operation name
return: true if this IRE is an [IEOperation](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation.md) of the provided name

## Default Method: isRange
- return type: `boolean`

Description: 
return: true if this IRE is an [IERange](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IERange.md)

## Default Method: isSlice
- return type: `boolean`

Description: 
return: true if this IRE is a [IESlice](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IESlice.md)

## Default Method: isSlice
- parameter: `wantedStart`, type: `int`
- parameter: `wantedEnd`, type: `int`
- return type: `boolean`

Description: 
parameter: wantedStart: 
parameter: wantedEnd: 
return: true if this IRE is a [IESlice](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IESlice.md) of the provided range

## Default Method: isStatement
- return type: `boolean`

Description: 
return: true if this IRE is an [IEStatement](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement.md)

## Default Method: isVar
- return type: `boolean`

Description: 
return: true if this IRE is an [IEVar](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar.md)

## Default Method: isVar
- parameter: `wantedVarId`, type: `int`
- return type: `boolean`

Description: 
parameter: wantedVarId: variable id
return: true if this IRE is an [IEVar](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar.md) having the provided id

## Abstract Method: leftShift
- parameter: `shift`, type: `int`
- parameter: `bitsize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: left shift of an expression, with an optional [#slice(int, int)](#slice(int, int))
parameter: shift: left shift value
parameter: bitsize: bitsize of the final [IEGeneric](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric.md). Note that             `bitSize - shift < currentBitSize` must be respected.
return: [IEGeneric](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric.md) left shifted by the shift value

## Abstract Method: leftShift
- parameter: `shift`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: left shift of an expression
parameter: shift: left shift value
return: [IEGeneric](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric.md) left shifted by the shift value

## Abstract Method: lsb
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Return the least significant bit \(lsb\) of an expression. No duplicate is done, it is up to  caller to duplicate current [IEGeneric](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric.md) if needed.
return: the least significant bit

## Abstract Method: msb
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Return the most significant bit \(msb\) of an expression. No duplicate is done, it is up to  caller to duplicate current [IEGeneric](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric.md) if needed.
return: the most significant bit

## Abstract Method: part
- parameter: `cnt`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Equivalent to `slice(0, cnt)`
parameter: cnt: wanted bit count
return: 

## Abstract Method: removeFlags
- parameter: `removedFlags`, type: `int`

Description: Remove flags from this IRE's flags list.
parameter: removedFlags: flags to remove

## Abstract Method: replaceSubExpression
- parameter: `oldExp`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `newExp`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`
- throws: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.exceptions.IllegalIntermediateExpressionException`

Description: Shallow replacement, by reference. Only the first occurrence is replaced.  

  Be careful when replacing immediates or variables. Unexpected behaviors may happen if the  expression contains multiple instances of the same imm or var.
parameter: oldExp: the expression to be replaced
parameter: newExp: the new expression, whose type must be consistent with the expression replaced
return: success indicator
throws: 

## Abstract Method: replaceVar
- parameter: `var`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar`
- parameter: `repl`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `int`
- throws: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.exceptions.IllegalIntermediateExpressionException`

Description: Deep replace. All matching [variables](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar.md) are replaced. The implementation is  responsible for duplicating the IR expressions, to ensure that the resulting statement or  group of statement does not contain duplicate references to mutable objects.
parameter: var: variable to replace
parameter: repl: replacement expression
return: the number of instances replaced
throws: if replacement produces an invalid expression

## Abstract Method: rightShift
- parameter: `shift`, type: `int`
- parameter: `bitsize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: right shift of an expression, with an optional [#slice(int, int)](#slice(int, int))
parameter: shift: right shift value
parameter: bitsize: bitsize of the final [IEGeneric](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric.md). Note that             `bitSize < currentBitSize` must be respected.
return: [IEGeneric](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric.md) right shifted by the shift value

## Abstract Method: rightShift
- parameter: `shift`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: right shift of an expression
parameter: shift: right shift value
return: [IEGeneric](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric.md) right shifted by the shift value

## Abstract Method: safelyType
- parameter: `etypeman`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardTypeManager`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType`

Description: Generate and assign a safe wildcard type to the expression if it doesn't already have one.
parameter: etypeman: 
return: the wildcard type, never null

## Abstract Method: setFlags
- parameter: `newFlags`, type: `int`

Description: Set the expression's flags.
parameter: newFlags: new expression flags

## Abstract Method: setType
- parameter: `type`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType`
- return type: `boolean`

Description: Set a pre\-propagation intermediate\-type. Does not propagate/update type in the super\- or  sub\-expression.
parameter: type: the new type; may be null
return: true if a type was set correctly, or unchanged; false if the type was not set, eg          because of a conflict with the current type

## Abstract Method: setType
- parameter: `newType`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType`
- parameter: `ti`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.ETypeInfo`
- return type: `boolean`

Description: Set a pre\-propagation intermediate\-type. Does not propagate/update type in the super\- or  sub\-expression. Not forced.
parameter: newType: the new type; may be null
parameter: ti: optional type\-setting information structure, contains information about how many             types were set, the list of type conflicts, etc.
return: true if a type was set correctly, or unchanged; false if the type was not set, eg          because of a conflict with the current type

## Abstract Method: setType
- parameter: `newType`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType`
- parameter: `ti`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.ETypeInfo`
- parameter: `forceUpdate`, type: `boolean`
- return type: `boolean`

Description: Set a pre\-propagation intermediate\-type. Does not propagate/update type in the super\- or  sub\-expression.
parameter: newType: the new type; may be null
parameter: ti: optional type\-setting information structure, contains information about how many             types were set, the list of type conflicts, etc.
parameter: forceUpdate: true to force a type update even if the new type is less speciialized \(has             a lesser score\) than the currently existing type
return: true if a type was set correctly, or unchanged; false if the type was not set, eg          because of a conflict with the current type

## Abstract Method: signExtend
- parameter: `newBitsize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Sign extend the current [IEGeneric](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric.md). This method will create a valid [IEGeneric](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric.md)  \(meaning [IEGeneric](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric.md) will not have duplicates id \- in particular, in the form C\(x,  x.msb\(\)?ones\(\):zeros\(\)\) where x will be present in base value and msb predicate\)
parameter: newBitsize: must be superior to [#getBitsize()](#getBitsize())

## Abstract Method: slice
- parameter: `begin`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Equivalent to `slice(begin, [bitsize](#getBitsize()))`.
parameter: begin: start position
return: the sliced [IEGeneric](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric.md)

## Abstract Method: slice
- parameter: `begin`, type: `int`
- parameter: `end`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Slice of an [IEGeneric](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric.md).
parameter: begin: start \(inclusive\) position
parameter: end: end \(exclusive\) position. Note that `end <= bitsize && begin < end` must be             respected
return: the sliced [IEGeneric](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric.md)

## Abstract Method: slice
- parameter: `r`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IERange`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Slice of an [IEGeneric](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric.md).
parameter: r: 
return: 

## Abstract Method: topHalf
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Retrieve the top half\-part of this IRE. If the IRE does not have an even count of bits N,  then the highest FLOOR\(N/2\) bits are returned.
return: 

## Abstract Method: updateTypes
- parameter: `ti`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.ETypeInfo`

Description: Deep update the types of the constituents of this IRE, update the IRE type as well the direct  constituents if needed. Not forced. When this method is called, it is the responsibility to  verify that the constituent IREs are typeable, and if not, to make them typeable \(eg, EImm  updates, EVar copies, etc.\).
parameter: ti: optional type information object; provides access to a [wildcard type manager](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardTypeManager.md), and used to record typing conflicts

## Abstract Method: verify
- throws: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.exceptions.IllegalIntermediateExpressionException`

Description: Verify the legality of this IR expression.
throws: if the IRE is deemed invalid or illegal

## Abstract Method: visitDepthPost
- parameter: `visitor`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVisitor`
- return type: `boolean`

Description: Depth\-first search, post\-order visit of an expression tree or sub\-tree. The node being  visited may be replaced without notifying the visitor.  

  Pre\-order visits offer more options than post order visits: the visitor may decide to skip  children; to skip the destination of assignments. However, replacement of nodes requires  additional code to register the new node. Conversely, post\-order visits do not offer any  specific option, but provide the simplest way to replace nodes.
parameter: visitor: 
return: 

## Abstract Method: visitDepthPost
- parameter: `visitor`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVisitor`
- parameter: `parent`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Depth\-first search, post\-order visit of an expression tree or sub\-tree. The node being  visited may be replaced without notifying the visitor.  

  Pre\-order visits offer more options than post order visits: the visitor may decide to skip  children; to skip the destination of assignments. However, replacement of nodes requires  additional code to register the new node. Conversely, post\-order visits do not offer any  specific option, but provide the simplest way to replace nodes.
parameter: visitor: 
parameter: parent: 
return: 

## Abstract Method: visitDepthPost
- parameter: `visitor`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVisitor`
- parameter: `parent`, 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: `boolean`

Description: Depth\-first search, post\-order visit of an expression tree or sub\-tree. The node being  visited may be replaced without notifying the visitor.  

  Pre\-order visits offer more options than post order visits: the visitor may decide to skip  children; to skip the destination of assignments. However, replacement of nodes requires  additional code to register the new node. Conversely, post\-order visits do not offer any  specific option, but provide the simplest way to replace nodes.
parameter: visitor: the visitor object
parameter: parent: 
parameter: results: 
return: true if the visit was successful

## Abstract Method: visitDepthPre
- parameter: `visitor`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVisitor`
- return type: `boolean`

Description: Depth\-first search, pre\-order visit of an expression tree or sub\-tree. The node being visited  may be replaced, but the client code is responsible for  `setReplacedNode` notifying the visitor.  

  Pre\-order visits offer more options than post order visits: the visitor may decide to skip  children; to skip the destination of assignments. However, replacement of nodes requires  additional code to register the new node. Conversely, post\-order visits do not offer any  specific option, but provide the simplest way to replace nodes.
parameter: visitor: 
return: 

## Abstract Method: visitDepthPre
- parameter: `visitor`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVisitor`
- parameter: `parent`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Depth\-first search, pre\-order visit of an expression tree or sub\-tree. The node being visited  may be replaced, but the client code is responsible for  `setReplacedNode` notifying the visitor.  

  Pre\-order visits offer more options than post order visits: the visitor may decide to skip  children; to skip the destination of assignments. However, replacement of nodes requires  additional code to register the new node. Conversely, post\-order visits do not offer any  specific option, but provide the simplest way to replace nodes.
parameter: visitor: 
parameter: parent: 
return: 

## Abstract Method: visitDepthPre
- parameter: `visitor`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVisitor`
- parameter: `parent`, 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: `boolean`

Description: Depth\-first search, pre\-order visit of an expression tree or sub\-tree. The node being visited  may be replaced, but the client code is responsible for  `setReplacedNode` notifying the visitor.  

  Pre\-order visits offer more options than post order visits: the visitor may decide to skip  children; to skip the destination of assignments. However, replacement of nodes requires  additional code to register the new node. Conversely, post\-order visits do not offer any  specific option, but provide the simplest way to replace nodes.
parameter: visitor: the visitor object
parameter: parent: 
parameter: results: 
return: true if the visit was successful

## Abstract Method: zeroExtend
- parameter: `newBitsize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Zero extend the current [IEGeneric](com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric.md)
parameter: newBitsize: must be superior to [#getBitsize()](#getBitsize())