Enum Opcode 

pub enum Opcode {
    Ld,
    St,
    Mov,
    Cvta,
    Cvt,
    Add,
    Sub,
    Mul,
    Div,
    Rem,
    Mad,
    Fma,
    Neg,
    Abs,
    Min,
    Max,
    And,
    Or,
    Xor,
    Not,
    Shl,
    Shr,
    Setp,
    Selp,
    Bra,
    Call,
    Ret,
    Exit,
    Bar,
    MemBar,
    Atom,
    Red,
    Tex,
    Tld4,
    Suld,
    Sust,
    Shfl,
    Vote,
    Mma,
    Wmma,
    LdMatrix,
    Cp,
    Prefetch,
    Unknown,
}

PTX Opcodes

Variants

Ld

Load

St

Store

Mov

Move

Cvta

Convert address space

Cvt

Convert type

Add

Add

Sub

Subtract

Mul

Multiply

Div

Divide

Rem

Remainder

Mad

Multiply-add

Fma

Fused multiply-add

Neg

Negate

Abs

Absolute value

Min

Minimum

Max

Maximum

And

Bitwise AND

Or

Bitwise OR

Xor

Bitwise XOR

Not

Bitwise NOT

Shl

Shift left

Shr

Shift right

Setp

Set predicate

Selp

Select

Bra

Branch

Call

Call function

Ret

Return

Exit

Exit kernel

Bar

Barrier

MemBar

Memory barrier

Atom

Atomic operation

Red

Reduction operation

Tex

Texture load

Tld4

Texture load 4

Suld

Surface load

Sust

Surface store

Shfl

Warp shuffle

Vote

Warp vote

Mma

Matrix multiply-accumulate

Wmma

Warp MMA

LdMatrix

Load matrix

Cp

Copy (async)

Prefetch

Prefetch

Unknown

Unknown opcode

Implementations

impl Opcode

pub fn is_load(&self) -> bool

Is this a load instruction

pub fn is_store(&self) -> bool

Is this a store instruction

pub fn is_memory_op(&self) -> bool

Is this a memory operation

pub fn is_sync(&self) -> bool

Is this a synchronization instruction

pub fn is_branch(&self) -> bool

Is this a branch instruction

Trait Implementations

impl Clone for Opcode

fn clone(&self) -> Opcode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Opcode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Opcode

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Opcode

fn eq(&self, other: &Opcode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Opcode

impl Eq for Opcode

impl StructuralPartialEq for Opcode