Type Alias Opcode 

pub type Opcode = Opcode;

Aliased Type

pub enum Opcode {
    Copy = 1,
    Load = 2,
    Store = 3,
    Branch = 4,
    CBranch = 5,
    BranchInd = 6,
    Call = 7,
    CallInd = 8,
    CallOther = 9,
    Return = 10,
    IntEqual = 11,
    IntNotEqual = 12,
    IntSLess = 13,
    IntSLessEqual = 14,
    IntLess = 15,
    IntLessEqual = 16,
    IntZExt = 17,
    IntSExt = 18,
    IntAdd = 19,
    IntSub = 20,
    IntCarry = 21,
    IntSCarry = 22,
    IntSBorrow = 23,
    Int2Comp = 24,
    IntNegate = 25,
    IntXor = 26,
    IntAnd = 27,
    IntOr = 28,
    IntLeft = 29,
    IntRight = 30,
    IntSRight = 31,
    IntMult = 32,
    IntDiv = 33,
    IntSDiv = 34,
    IntRem = 35,
    IntSRem = 36,
    BoolNegate = 37,
    BoolXor = 38,
    BoolAnd = 39,
    BoolOr = 40,
    FloatEqual = 41,
    FloatNotEqual = 42,
    FloatLess = 43,
    FloatLessEqual = 44,
    FloatNan = 46,
    FloatAdd = 47,
    FloatDiv = 48,
    FloatMult = 49,
    FloatSub = 50,
    FloatNeg = 51,
    FloatAbs = 52,
    FloatSqrt = 53,
    FloatInt2Float = 54,
    FloatFloat2Float = 55,
    FloatTrunc = 56,
    FloatCeil = 57,
    FloatFloor = 58,
    FloatRound = 59,
    MultiEqual = 60,
    Indirect = 61,
    Piece = 62,
    SubPiece = 63,
    Cast = 64,
    PtrAdd = 65,
    PtrSub = 66,
    SegmentOp = 67,
    CPoolRef = 68,
    New = 69,
    Insert = 70,
    Extract = 71,
    PopCount = 72,
    Max = 73,
}

Variants

Copy = 1

Load = 2

< Copy one operand to another

Store = 3

< Load from a pointer into a specified address space

Branch = 4

< Store at a pointer into a specified address space

CBranch = 5

< Always branch

BranchInd = 6

< Conditional branch

Call = 7

< Indirect branch (jumptable)

CallInd = 8

< Call to an absolute address

CallOther = 9

< Call through an indirect address

Return = 10

< User-defined operation

IntEqual = 11

< Return from subroutine

IntNotEqual = 12

< Integer comparison, equality (==)

IntSLess = 13

< Integer comparison, in-equality (!=)

IntSLessEqual = 14

< Integer comparison, signed less-than (<)

IntLess = 15

< Integer comparison, signed less-than-or-equal (<=)

IntLessEqual = 16

< Integer comparison, unsigned less-than (<)

IntZExt = 17

< Integer comparison, unsigned less-than-or-equal (<=)

IntSExt = 18

< Zero extension

IntAdd = 19

< Sign extension

IntSub = 20

< Addition, signed or unsigned (+)

IntCarry = 21

< Subtraction, signed or unsigned (-)

IntSCarry = 22

< Test for unsigned carry

IntSBorrow = 23

< Test for signed carry

Int2Comp = 24

< Test for signed borrow

IntNegate = 25

< Twos complement

IntXor = 26

< Logical/bitwise negation (~)

IntAnd = 27

< Logical/bitwise exclusive-or (^)

IntOr = 28

< Logical/bitwise and (&)

IntLeft = 29

< Logical/bitwise or (|)

IntRight = 30

< Left shift (<<)

IntSRight = 31

< Right shift, logical (>>)

IntMult = 32

< Right shift, arithmetic (>>)

IntDiv = 33

< Integer multiplication, signed and unsigned (*)

IntSDiv = 34

< Integer division, unsigned (/)

IntRem = 35

< Integer division, signed (/)

IntSRem = 36

< Remainder/modulo, unsigned (%)

BoolNegate = 37

< Remainder/modulo, signed (%)

BoolXor = 38

< Boolean negate (!)

BoolAnd = 39

< Boolean exclusive-or (^^)

BoolOr = 40

< Boolean and (&&)

FloatEqual = 41

< Boolean or (||)

FloatNotEqual = 42

< Floating-point comparison, equality (==)

FloatLess = 43

< Floating-point comparison, in-equality (!=)

FloatLessEqual = 44

< Floating-point comparison, less-than (<)

FloatNan = 46

< Floating-point comparison, less-than-or-equal (<=)

FloatAdd = 47

< Not-a-number test (NaN)

FloatDiv = 48

< Floating-point addition (+)

FloatMult = 49

< Floating-point division (/)

FloatSub = 50

< Floating-point multiplication (*)

FloatNeg = 51

< Floating-point subtraction (-)

FloatAbs = 52

< Floating-point negation (-)

FloatSqrt = 53

< Floating-point absolute value (abs)

FloatInt2Float = 54

< Floating-point square root (sqrt)

FloatFloat2Float = 55

< Convert an integer to a floating-point

FloatTrunc = 56

< Convert between different floating-point sizes

FloatCeil = 57

< Round towards zero

FloatFloor = 58

< Round towards +infinity

FloatRound = 59

< Round towards -infinity

MultiEqual = 60

< Round towards nearest

Indirect = 61

< Phi-node operator

Piece = 62

< Copy with an indirect effect

SubPiece = 63

< Concatenate

Cast = 64

< Truncate

PtrAdd = 65

< Cast from one data-type to another

PtrSub = 66

< Index into an array ([])

SegmentOp = 67

< Drill down to a sub-field (->)

CPoolRef = 68

< Look-up a \e segmented address

New = 69

< Recover a value from the \e constant \e pool

Insert = 70

< Allocate a new object (new)

Extract = 71

< Insert a bit-range

PopCount = 72

< Extract a bit-range

Max = 73

< Count the 1-bits