IEGeneric

Determine whether this IRE accesses memory.

Add flags to this IRE's flags list.

Retrieve a one bit value at the pos position

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.

Copy the base properties from the provided IR source expression to this expression.

Count successive bits in an integer, starting from MSB or LSB.

Clone (deep copy) the expression.

Same as #equals() with the possibility to exclude the type from the comparison.

Evaluate the IRE.

Evaluate the IRE as a 64-bit address.@return

Evaluate the IRE as an unsigned long value. This convenience method will throw if the underlying immediate bit size exceeds 63 bits (unsigned value).

Visit the constituents of this expression, and check if one of them is passing the provided test.

Find the parent of the the provided child element.

Find a child element by type.

Find the first child element by type.

Find the parent of the the provided child element. The comparison is done by identity.

Find the parent of the first instance of the provided child element. The comparison is done by identity.

Generate the C abstract syntax tree portion for this expression.

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

For non-statements only. Assuming 'this' is a destination value, extract the variable or variable bits that are used and defined by it.

Get a list of variable or variable bits 'explicitly used' (read) by the instruction. This method is inherently deep.

Convenience method around #getExplictlyUsed(EDefUseInfo).

Get the expression flags.

The flags are defined in the sub-interfaces. They do not overlap.

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

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.

Shallow collection of this expression's constituents, in evaluation order. Appends to `list` (existing elements are not cleared). The current element (this) is not appended, only the descendants are considered.

Get the currently set intermediate-type.

Convenience method to invoke getUsed(EDefUseInfo).

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, PC-assigns, UntranslatedInstruction. This method returns those implicit uses.

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.

Check if this IRE contains the provided flags.

left shift of an expression

left shift of an expression, with an optional slice(int, int)

Return the least significant bit (lsb) of an expression. No duplicate is done, it is up to caller to duplicate current IEGeneric if needed.

Return the most significant bit (msb) of an expression. No duplicate is done, it is up to caller to duplicate current IEGeneric if needed.

Equivalent to slice(0, cnt)

Remove flags from this IRE's flags list.

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.

Deep replace. All matching variables 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.

right shift of an expression

right shift of an expression, with an optional slice(int, int)

Generate and assign a safe wildcard type to the expression if it doesn't already have one.

Set the expression's flags.

Set a pre-propagation intermediate-type. Does not propagate/update type in the super- or sub-expression.

Set a pre-propagation intermediate-type. Does not propagate/update type in the super- or sub-expression. Not forced.

Set a pre-propagation intermediate-type. Does not propagate/update type in the super- or sub-expression.

Sign extend the current IEGeneric. This method will create a valid IEGeneric (meaning IEGeneric 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)

Slice of an IEGeneric.

Equivalent to slice(begin, bitsize).

Slice of an IEGeneric.

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.

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

Verify the legality of this IR expression.

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.

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.

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.

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 EVisitResults#setReplacedNode(IEGeneric) 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.

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 EVisitResults#setReplacedNode(IEGeneric) 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.

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 EVisitResults#setReplacedNode(IEGeneric) 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.

Zero extend the current IEGeneric