# Enum: com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType

IR [operation](IEOperation) types.

## Constant: ADD
Description: integer addition, signed or unsigned

## Constant: ADD_SSAT

## Constant: ADD_USAT

## Constant: AND
Description: binary\-AND \(careful not to confuse with [#LOG_AND](#LOG_AND)

## Constant: CARRY
Description: 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)`\)

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

## Constant: CAST_S
Description: signed extension \(signed cast\), used for upsizing: the EOperation carries the resulting bitsize \(and optional etype\)

## Constant: DIV2_S
Description: \[NO NOT USE\] full signed integer division: input=\(2N, N\), output=\(N, N\)

## Constant: DIV2_U
Description: \[NO NOT USE\] full unsigned integer division: input=\(2N, N\), output=\(N, N\)

## Constant: DIV_S
Description: signed integer division, simple: input=\(N, N\), output=N \(remainder discarded\)

## Constant: DIV_U
Description: unsigned integer division, simple: input=\(N, N\), output=N \(remainder discarded\)

## Constant: FADD
Description: IEEE\-754 addition

## Constant: FDIV
Description: IEEE\-754 division

## Constant: FEQ
Description: 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)`

## Constant: FGE
Description: IEEE\-754 ordered and greater\-or\-equal\-than operation

## Constant: FGT
Description: IEEE\-754 ordered and greater\-than operation

## Constant: FLE
Description: IEEE\-754 ordered and less\-or\-equal\-than operation

## Constant: FLT
Description: IEEE\-754 ordered and less\-than operation

## Constant: FMUL
Description: IEEE\-754 multiplication

## Constant: FNE
Description: IEEE\-754 unordered or unequal comparison operation

## Constant: FP2FP
Description: 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\).

## Constant: FP2INT
Description: 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\).

## Constant: FP2UINT
Description: 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\).

## Constant: FSUB
Description: IEEE\-754 subtraction

## Constant: FUN
Description: 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)`

## Constant: FUNCTION
Description: Custom function, further defined in [FunctionOptype](FunctionOptype)

## Constant: GE_S
Description: signed greater or equal

## Constant: GE_U
Description: unsigned greater or equal

## Constant: GT_S
Description: signed greater \(strict\)

## Constant: GT_U
Description: unsigned greater \(strict\)

## Constant: INT2FP
Description: 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\).

## Constant: LE_S
Description: signed less or equal

## Constant: LE_U
Description: unsigned less or equal

## Constant: LOG_AND
Description: logical\-AND \(careful not to confuse with binary\-[#AND](#AND)

## Constant: LOG_EQ
Description: logical equality

## Constant: LOG_NEQ
Description: logical inequality

## Constant: LOG_NOT
Description: logical\-NOT \(careful not to confuse with binary\-[#NOT](#NOT). In practice in C, same as binary\-NOT.

## Constant: LOG_OR
Description: logical\-OR \(careful not to confuse with binary\-[#OR](#OR)

## Constant: LT_S
Description: signed less \(strict\)

## Constant: LT_U
Description: unsigned less \(strict\) \- can be used to compute the carry resulting from a subtraction

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

## Constant: MUL2_S
Description: non\-truncated signed integer multiplication: input=\(N, N\), output=2N

## Constant: MUL2_U
Description: non\-truncated unsigned integer multiplication: input=\(N, N\), output=2N

## Constant: MUL_U
Description: Equivalent to [#MUL](#MUL). Should not be used from JEB 4.12 onward.

## Constant: NOT
Description: binary\-NOT \(careful not to confuse with [#LOG_NOT](#LOG_NOT).

## Constant: OR
Description: binary\-OR \(careful not to confuse with [#LOG_OR](#LOG_OR)

## Constant: PAR
Description: 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.

## Constant: POW
Description: Power \(exponentiation\) operator

## Constant: REM_S
Description: signed integer modulo, simple: input=\(N, N\), output=N \(quotient discarded\)

## Constant: REM_U
Description: unsigned integer modulo, simple: input=\(N, N\), output=N \(quotient discarded\)

## Constant: ROL
Description: Rotate left, always unsigned

## Constant: ROR
Description: Rotate right, always unsigned

## Constant: SAR
Description: arithmetic shift right with count modulo\-positive bitsize, signed

## Constant: SHL
Description: logical shift left with count modulo\-positive bitsize, always unsigned

## Constant: SHR
Description: 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.

## Constant: SUB
Description: integer subtraction, signed or unsigned

## Constant: SUB_SSAT

## Constant: SUB_USAT

## Constant: UINT2FP
Description: 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\).

## Constant: XOR
Description: binary\-XOR

## Method: getOperandCount
- return type: `int`


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


## Method: isConversion
- return type: `boolean`


## Method: isFloatComparison
- return type: `boolean`


## Method: isFloatConversion
- return type: `boolean`


## Method: isFloatOperation
- return type: `boolean`


## Method: isIntegerConversion
- return type: `boolean`


## Method: isLogical
- return type: `boolean`


## Method: isShift
- return type: `boolean`


## Method: isValid
- parameter: `nbParameters`, type: `int`
- return type: `boolean`


## Method: shouldNotUse
- return type: `boolean`


## Method: toString
- return type: `java.lang.String`


## Static Method: fromName
- parameter: `name`, type: `java.lang.String`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType`


## Static Method: valueOf
- parameter: `name`, type: `java.lang.String`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType`


## Static Method: values
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType[]`


