Enumeration
    XcoreIns
public enum XcoreIns
XCore instruction
Relationships
Conforms To
UInt32
Enumeration Cases
        invalid
    
    case invalid
        add
    
    case add
        andnot
    
    case andnot
        and
    
    case and
        ashr
    
    case ashr
        bau
    
    case bau
        bitrev
    
    case bitrev
        bla
    
    case bla
        blat
    
    case blat
        bl
    
    case bl
        bf
    
    case bf
        bt
    
    case bt
        bu
    
    case bu
        bru
    
    case bru
        byterev
    
    case byterev
        chkct
    
    case chkct
        clre
    
    case clre
        clrpt
    
    case clrpt
        clrsr
    
    case clrsr
        clz
    
    case clz
        crc8
    
    case crc8
        crc32
    
    case crc32
        dcall
    
    case dcall
        dentsp
    
    case dentsp
        dgetreg
    
    case dgetreg
        divs
    
    case divs
        divu
    
    case divu
        drestsp
    
    case drestsp
        dret
    
    case dret
        ecallf
    
    case ecallf
        ecallt
    
    case ecallt
        edu
    
    case edu
        eef
    
    case eef
        eet
    
    case eet
        eeu
    
    case eeu
        endin
    
    case endin
        entsp
    
    case entsp
        eq
    
    case eq
        extdp
    
    case extdp
        extsp
    
    case extsp
        freer
    
    case freer
        freet
    
    case freet
        getd
    
    case getd
        get
    
    case get
        getn
    
    case getn
        getr
    
    case getr
        getsr
    
    case getsr
        getst
    
    case getst
        getts
    
    case getts
        inct
    
    case inct
        `init`
    
    case `init`
        inpw
    
    case inpw
        inshr
    
    case inshr
        int
    
    case int
        `in`
    
    case `in`
        kcall
    
    case kcall
        kentsp
    
    case kentsp
        krestsp
    
    case krestsp
        kret
    
    case kret
        ladd
    
    case ladd
        ld16s
    
    case ld16s
        ld8u
    
    case ld8u
        lda16
    
    case lda16
        ldap
    
    case ldap
        ldaw
    
    case ldaw
        ldc
    
    case ldc
        ldw
    
    case ldw
        ldivu
    
    case ldivu
        lmul
    
    case lmul
        lss
    
    case lss
        lsub
    
    case lsub
        lsu
    
    case lsu
        maccs
    
    case maccs
        maccu
    
    case maccu
        mjoin
    
    case mjoin
        mkmsk
    
    case mkmsk
        msync
    
    case msync
        mul
    
    case mul
        neg
    
    case neg
        not
    
    case not
        or
    
    case or
        outct
    
    case outct
        outpw
    
    case outpw
        outshr
    
    case outshr
        outt
    
    case outt
        out
    
    case out
        peek
    
    case peek
        rems
    
    case rems
        remu
    
    case remu
        retsp
    
    case retsp
        setclk
    
    case setclk
        set
    
    case set
        setc
    
    case setc
        setd
    
    case setd
        setev
    
    case setev
        setn
    
    case setn
        setpsc
    
    case setpsc
        setpt
    
    case setpt
        setrdy
    
    case setrdy
        setsr
    
    case setsr
        settw
    
    case settw
        setv
    
    case setv
        sext
    
    case sext
        shl
    
    case shl
        shr
    
    case shr
        ssync
    
    case ssync
        st16
    
    case st16
        st8
    
    case st8
        stw
    
    case stw
        sub
    
    case sub
        syncr
    
    case syncr
        testct
    
    case testct
        testlcl
    
    case testlcl
        testwct
    
    case testwct
        tsetmr
    
    case tsetmr
        start
    
    case start
        waitef
    
    case waitef
        waitet
    
    case waitet
        waiteu
    
    case waiteu
        xor
    
    case xor
        zext
    
    case zext
        ending
    
    case ending