OperationType

integer addition, signed or unsigned

binary-AND (careful not to confuse with LOG_AND

Resulting carry from the addition of two operands with no carry-in bit.
It is recommended to avoid using this operator: Replace CARRY(OP1, OP2) by LT_U(RESULT, OP1) (or LT_U(RESULT, OP2))

unsigned truncation (unsigned cast), used for upsizing, downsizing, or regular type casts: the EOperation carries the resulting bitsize (and optional etype)

signed extension (signed cast), used for upsizing: the EOperation carries the resulting bitsize (and optional etype)

[NO NOT USE] full signed integer division: input=(2N, N), output=(N, N)

[NO NOT USE] full unsigned integer division: input=(2N, N), output=(N, N)

signed integer division, simple: input=(N, N), output=N (remainder discarded)

unsigned integer division, simple: input=(N, N), output=N (remainder discarded)

IEEE-754 addition

IEEE-754 division

IEEE-754 ordered and equal comparison operation
- note that is_NaN can be emulated with FEQ: is_Nan(x) == !FEQ(x, x)
- note that is_unordered can be emulated with FEQ: is_unordered(x, y) == is_Nan(x) || is_Nan(y) == !FEQ(x, x) || !FEQ(y, y)

IEEE-754 ordered and greater-or-equal-than operation

IEEE-754 ordered and greater-than operation

IEEE-754 ordered and less-or-equal-than operation

IEEE-754 ordered and less-than operation

IEEE-754 multiplication

IEEE-754 unordered or unequal comparison operation

floating-point to floating-point upgrade or downgrade (supported FP formats: binary32, binary64, intel x87 extended double-precision 80-bit)
The details of the conversion are unspecified (examples: how the operator deals with loss of precision; what truncation mode is used).

floating-point to signed integer conversion (supported FP formats: binary32, binary64, intel x87 extended double-precision 80-bit)
The details of the conversion are unspecified (examples: how the operator deals with loss of precision; what truncation mode is used).

floating-point to unsigned integer conversion (supported FP formats: binary32, binary64)
The details of the conversion are unspecified (examples: how the operator deals with loss of precision; what truncation mode is used).

IEEE-754 subtraction

IEEE-754 is_unordered operation, i.e. determine if either operand is NaN
note that this operator can be can be used to determine whether a value is NaN since: is_NaN(x) == is_unordered(x, x)

Custom function, further defined in FunctionOptype

signed greater or equal

unsigned greater or equal

signed greater (strict)

unsigned greater (strict)

signed integer to floating-point conversion (supported FP formats: binary32, binary64, intel x87 extended double-precision 80-bit)
The details of the conversion are unspecified (examples: how the operator deals with loss of precision; what truncation mode is used).

signed less or equal

unsigned less or equal

logical-AND (careful not to confuse with binary-AND

logical equality

logical inequality

logical-NOT (careful not to confuse with binary-NOT. In practice in C, same as binary-NOT.

logical-OR (careful not to confuse with binary-OR

signed less (strict)

unsigned less (strict) - can be used to compute the carry resulting from a subtraction

Truncated integer multiplication (signed or unsigned): input=(N, N), output=N
It is bitwise-equivalent to an unsigned truncated multiply (operator MUL_U) Use preferably for signed operations, as it will help with type propagation.

non-truncated signed integer multiplication: input=(N, N), output=2N

non-truncated unsigned integer multiplication: input=(N, N), output=2N

Equivalent to MUL. Should not be used from JEB 4.12 onward.

binary-NOT (careful not to confuse with LOG_NOT.

binary-OR (careful not to confuse with LOG_OR

Standard parity operator: single operand, single-bit result; result is 1 if number of bits (in operand) set to 1 is even.
Cannot be translated to a simple operator, for convenience only. It will need ad-hoc translators in C.

Power (exponentiation) operator

signed integer modulo, simple: input=(N, N), output=N (quotient discarded)

unsigned integer modulo, simple: input=(N, N), output=N (quotient discarded)

Rotate left, always unsigned

Rotate right, always unsigned

arithmetic shift right with count modulo-positive bitsize, signed

logical shift left with count modulo-positive bitsize, always unsigned

logical shift right with count modulo-positive bitsize, unsigned. Note: in C, also represented '>>'; unsigned or signed shift depends on the type of the variable to be shifted.

integer subtraction, signed or unsigned

unsigned integer to floating-point conversion (supported FP formats: binary32, binary64)
The details of the conversion are unspecified (examples: how the operator deals with loss of precision; what truncation mode is used).

binary-XOR