Skip to main content

ContractInstruction

ab_contract_file::instruction

Enum ContractInstruction 

Source 
pub enum ContractInstruction<Reg = ContractRegister> {

Show 182 variants    CAddi4spn {
        rd: Reg,
        nzuimm: u16,
        /* private fields */
    },
    CLw {
        rs1: Reg,
        rd: Reg,
        uimm: u8,
        /* private fields */
    },
    CLd {
        rs1: Reg,
        rd: Reg,
        uimm: u8,
        /* private fields */
    },
    CSw {
        rs1: Reg,
        rs2: Reg,
        uimm: u8,
    },
    CSd {
        rs1: Reg,
        rs2: Reg,
        uimm: u8,
    },
    CNop { /* private fields */ },
    CAddi {
        rd: Reg,
        nzimm: i8,
        /* private fields */
    },
    CAddiw {
        rd: Reg,
        imm: i8,
        /* private fields */
    },
    CLi {
        rd: Reg,
        imm: i8,
        /* private fields */
    },
    CAddi16sp {
        nzimm: i16,
        /* private fields */
    },
    CLui {
        rd: Reg,
        nzimm: I24,
        /* private fields */
    },
    CSrli {
        rd: Reg,
        shamt: u8,
        /* private fields */
    },
    CSrai {
        rd: Reg,
        shamt: u8,
        /* private fields */
    },
    CAndi {
        rd: Reg,
        imm: i8,
        /* private fields */
    },
    CSub {
        rs2: Reg,
        rd: Reg,
        /* private fields */
    },
    CXor {
        rs2: Reg,
        rd: Reg,
        /* private fields */
    },
    COr {
        rs2: Reg,
        rd: Reg,
        /* private fields */
    },
    CAnd {
        rs2: Reg,
        rd: Reg,
        /* private fields */
    },
    CSubw {
        rs2: Reg,
        rd: Reg,
        /* private fields */
    },
    CAddw {
        rs2: Reg,
        rd: Reg,
        /* private fields */
    },
    CJ {
        imm: i16,
        /* private fields */
    },
    CBeqz {
        rs1: Reg,
        imm: i16,
        /* private fields */
    },
    CBnez {
        rs1: Reg,
        imm: i16,
        /* private fields */
    },
    CSlli {
        rd: Reg,
        shamt: u8,
        /* private fields */
    },
    CLwsp {
        rd: Reg,
        uimm: u8,
        /* private fields */
    },
    CLdsp {
        rd: Reg,
        uimm: u16,
        /* private fields */
    },
    CJr {
        rs1: Reg,
        /* private fields */
    },
    CMv {
        rs2: Reg,
        rd: Reg,
        /* private fields */
    },
    CEbreak { /* private fields */ },
    CJalr {
        rs1: Reg,
        /* private fields */
    },
    CAdd {
        rs2: Reg,
        rd: Reg,
        /* private fields */
    },
    CSwsp {
        rs2: Reg,
        uimm: u8,
        /* private fields */
    },
    CSdsp {
        rs2: Reg,
        uimm: u16,
        /* private fields */
    },
    CUnimp { /* private fields */ },
    CLbu {
        rs1: Reg,
        rd: Reg,
        uimm: u8,
        /* private fields */
    },
    CLh {
        rs1: Reg,
        rd: Reg,
        uimm: u8,
        /* private fields */
    },
    CLhu {
        rs1: Reg,
        rd: Reg,
        uimm: u8,
        /* private fields */
    },
    CSb {
        rs1: Reg,
        rs2: Reg,
        uimm: u8,
    },
    CSh {
        rs1: Reg,
        rs2: Reg,
        uimm: u8,
    },
    CZextB {
        rd: Reg,
        /* private fields */
    },
    CSextB {
        rd: Reg,
        /* private fields */
    },
    CZextH {
        rd: Reg,
        /* private fields */
    },
    CSextH {
        rd: Reg,
        /* private fields */
    },
    CZextW {
        rd: Reg,
        /* private fields */
    },
    CNot {
        rd: Reg,
        /* private fields */
    },
    CMul {
        rs2: Reg,
        rd: Reg,
        /* private fields */
    },
    CmPush {
        urlist: ZcmpUrlist<Reg>,
        stack_adj: u8,
        /* private fields */
    },
    CmPop {
        urlist: ZcmpUrlist<Reg>,
        stack_adj: u8,
        /* private fields */
    },
    CmPopretz {
        urlist: ZcmpUrlist<Reg>,
        stack_adj: u8,
        /* private fields */
    },
    CmPopret {
        urlist: ZcmpUrlist<Reg>,
        stack_adj: u8,
        /* private fields */
    },
    CmMva01s {
        rs1: Reg,
        rs2: Reg,
    },
    CmMvsa01 {
        rs1: Reg,
        rs2: Reg,
    },
    Add {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Sub {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Sll {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Slt {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Sltu {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Xor {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Srl {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Sra {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Or {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    And {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Addw {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Subw {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Sllw {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Srlw {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Sraw {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Addi {
        rs1: Reg,
        rd: Reg,
        imm: i16,
        /* private fields */
    },
    Slti {
        rs1: Reg,
        rd: Reg,
        imm: i16,
        /* private fields */
    },
    Sltiu {
        rs1: Reg,
        rd: Reg,
        imm: i16,
        /* private fields */
    },
    Xori {
        rs1: Reg,
        rd: Reg,
        imm: i16,
        /* private fields */
    },
    Ori {
        rs1: Reg,
        rd: Reg,
        imm: i16,
        /* private fields */
    },
    Andi {
        rs1: Reg,
        rd: Reg,
        imm: i16,
        /* private fields */
    },
    Slli {
        rs1: Reg,
        rd: Reg,
        shamt: u8,
        /* private fields */
    },
    Srli {
        rs1: Reg,
        rd: Reg,
        shamt: u8,
        /* private fields */
    },
    Srai {
        rs1: Reg,
        rd: Reg,
        shamt: u8,
        /* private fields */
    },
    Addiw {
        rs1: Reg,
        rd: Reg,
        imm: i16,
        /* private fields */
    },
    Slliw {
        rs1: Reg,
        rd: Reg,
        shamt: u8,
        /* private fields */
    },
    Srliw {
        rs1: Reg,
        rd: Reg,
        shamt: u8,
        /* private fields */
    },
    Sraiw {
        rs1: Reg,
        rd: Reg,
        shamt: u8,
        /* private fields */
    },
    Lb {
        rs1: Reg,
        rd: Reg,
        imm: i16,
        /* private fields */
    },
    Lh {
        rs1: Reg,
        rd: Reg,
        imm: i16,
        /* private fields */
    },
    Lw {
        rs1: Reg,
        rd: Reg,
        imm: i16,
        /* private fields */
    },
    Ld {
        rs1: Reg,
        rd: Reg,
        imm: i16,
        /* private fields */
    },
    Lbu {
        rs1: Reg,
        rd: Reg,
        imm: i16,
        /* private fields */
    },
    Lhu {
        rs1: Reg,
        rd: Reg,
        imm: i16,
        /* private fields */
    },
    Lwu {
        rs1: Reg,
        rd: Reg,
        imm: i16,
        /* private fields */
    },
    Jalr {
        rs1: Reg,
        rd: Reg,
        imm: i16,
        /* private fields */
    },
    Sb {
        rs1: Reg,
        rs2: Reg,
        imm: i16,
    },
    Sh {
        rs1: Reg,
        rs2: Reg,
        imm: i16,
    },
    Sw {
        rs1: Reg,
        rs2: Reg,
        imm: i16,
    },
    Sd {
        rs1: Reg,
        rs2: Reg,
        imm: i16,
    },
    Beq {
        rs1: Reg,
        rs2: Reg,
        imm: I24,
    },
    Bne {
        rs1: Reg,
        rs2: Reg,
        imm: I24,
    },
    Blt {
        rs1: Reg,
        rs2: Reg,
        imm: I24,
    },
    Bge {
        rs1: Reg,
        rs2: Reg,
        imm: I24,
    },
    Bltu {
        rs1: Reg,
        rs2: Reg,
        imm: I24,
    },
    Bgeu {
        rs1: Reg,
        rs2: Reg,
        imm: I24,
    },
    Lui {
        rd: Reg,
        imm: I24WithZeroedBits<12>,
        /* private fields */
    },
    Auipc {
        rd: Reg,
        imm: I24WithZeroedBits<12>,
        /* private fields */
    },
    Jal {
        rd: Reg,
        imm: I24,
        /* private fields */
    },
    Ebreak { /* private fields */ },
    Unimp { /* private fields */ },
    Mul {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Mulh {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Mulhsu {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Mulhu {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Div {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Divu {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Rem {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Remu {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Mulw {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Divw {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Divuw {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Remw {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Remuw {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    AddUw {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Sh1add {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Sh1addUw {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Sh2add {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Sh2addUw {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Sh3add {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Sh3addUw {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    SlliUw {
        rs1: Reg,
        rd: Reg,
        shamt: u8,
        /* private fields */
    },
    Andn {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Orn {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Xnor {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Clz {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    Clzw {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    Ctz {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    Ctzw {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    Cpop {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    Cpopw {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    Max {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Maxu {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Min {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Minu {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Sextb {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    Sexth {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    Zexth {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    Rol {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Rolw {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Ror {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Rori {
        rs1: Reg,
        rd: Reg,
        shamt: u8,
        /* private fields */
    },
    Roriw {
        rs1: Reg,
        rd: Reg,
        shamt: u8,
        /* private fields */
    },
    Rorw {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Orcb {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    Rev8 {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    Bset {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Bseti {
        rs1: Reg,
        rd: Reg,
        shamt: u8,
        /* private fields */
    },
    Bclr {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Bclri {
        rs1: Reg,
        rd: Reg,
        shamt: u8,
        /* private fields */
    },
    Binv {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Binvi {
        rs1: Reg,
        rd: Reg,
        shamt: u8,
        /* private fields */
    },
    Bext {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Bexti {
        rs1: Reg,
        rd: Reg,
        shamt: u8,
        /* private fields */
    },
    Clmul {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Clmulh {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Clmulr {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Pack {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Packh {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Packw {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Brev8 {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    Xperm4 {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Xperm8 {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Aes64Ds {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Aes64Dsm {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Aes64Im {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    Aes64Ks1i {
        rs1: Reg,
        rd: Reg,
        rnum: Rv64ZkndKsRnum,
        /* private fields */
    },
    Aes64Ks2 {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Aes64Es {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Aes64Esm {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    Sha256Sig0 {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    Sha256Sig1 {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    Sha256Sum0 {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    Sha256Sum1 {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    Sha512Sig0 {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    Sha512Sig1 {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    Sha512Sum0 {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    Sha512Sum1 {
        rs1: Reg,
        rd: Reg,
        /* private fields */
    },
    CzeroEqz {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },
    CzeroNez {
        rs1: Reg,
        rs2: Reg,
        rd: Reg,
    },

}
Expand description

An instruction type used by contracts

Variants§

§

CAddi4spn

C.ADDI4SPN rd’ = sp + nzuimm (nzuimm ∈ 4..1020 step 4)

Fields

§rd: Reg
§nzuimm: u16
§

CLw

C.LW rd’ = sext(mem32[rs1’ + uimm])

Fields

§rs1: Reg
§rd: Reg
§uimm: u8
§

CLd

C.LD rd’ = mem64[rs1’ + uimm]

Fields

§rs1: Reg
§rd: Reg
§uimm: u8
§

CSw

C.SW mem32[rs1’ + uimm] = rs2’

Fields

§rs1: Reg
§rs2: Reg
§uimm: u8
§

CSd

C.SD mem64[rs1’ + uimm] = rs2’

Fields

§rs1: Reg
§rs2: Reg
§uimm: u8
§

CNop

C.NOP (ADDI x0, x0, 0 with rd==x0 and nzimm==0)

§

CAddi

C.ADDI rd += nzimm (rd != x0)

Fields

§rd: Reg
§nzimm: i8
§

CAddiw

C.ADDIW rd = sext((rd[31:0] + imm)[31:0]) (rd != x0)

Fields

§rd: Reg
§imm: i8
§

CLi

C.LI rd = sext(imm) (rd=x0 is a HINT)

Fields

§rd: Reg
§imm: i8
§

CAddi16sp

C.ADDI16SP sp += nzimm*16 (nzimm != 0)

Fields

§nzimm: i16
§

CLui

C.LUI rd = sext(nzimm << 12) (rd != x0, rd != x2, nzimm != 0)

Fields

§rd: Reg
§nzimm: I24
§

CSrli

C.SRLI rd’ >>= shamt (logical right shift; shamt=0 with rd’=x0 is a HINT)

Fields

§rd: Reg
§shamt: u8
§

CSrai

C.SRAI rd’ >>= shamt (arithmetic right shift; shamt=0 with rd’=x0 is a HINT)

Fields

§rd: Reg
§shamt: u8
§

CAndi

C.ANDI rd’ &= sext(imm)

Fields

§rd: Reg
§imm: i8
§

CSub

C.SUB rd’ -= rs2’

Fields

§rs2: Reg
§rd: Reg
§

CXor

C.XOR rd’ ^= rs2’

Fields

§rs2: Reg
§rd: Reg
§

COr

C.OR rd’ |= rs2’

Fields

§rs2: Reg
§rd: Reg
§

CAnd

C.AND rd’ &= rs2’

Fields

§rs2: Reg
§rd: Reg
§

CSubw

C.SUBW rd’ = sext((rd’[31:0] - rs2’[31:0])[31:0])

Fields

§rs2: Reg
§rd: Reg
§

CAddw

C.ADDW rd’ = sext((rd’[31:0] + rs2’[31:0])[31:0])

Fields

§rs2: Reg
§rd: Reg
§

CJ

C.J pc += sext(imm)

Fields

§imm: i16
§

CBeqz

C.BEQZ if rs1’ == 0: pc += sext(imm)

Fields

§rs1: Reg
§imm: i16
§

CBnez

C.BNEZ if rs1’ != 0: pc += sext(imm)

Fields

§rs1: Reg
§imm: i16
§

CSlli

C.SLLI rd <<= shamt (rd=x0 or shamt=0 is a HINT)

Fields

§rd: Reg
§shamt: u8
§

CLwsp

C.LWSP rd = sext(mem32[sp + uimm]) (rd != x0)

Fields

§rd: Reg
§uimm: u8
§

CLdsp

C.LDSP rd = mem64[sp + uimm] (rd != x0)

Fields

§rd: Reg
§uimm: u16
§

CJr

C.JR pc = rs1 (rs1 != x0)

Fields

§rs1: Reg
§

CMv

C.MV rd = rs2 (rs2 != x0; rd=x0 is a HINT)

Fields

§rs2: Reg
§rd: Reg
§

CEbreak

C.EBREAK

§

CJalr

C.JALR ra = pc+2; pc = rs1 (rs1 != x0)

Fields

§rs1: Reg
§

CAdd

C.ADD rd += rs2 (rs2 != x0; rd=x0 is a HINT)

Fields

§rs2: Reg
§rd: Reg
§

CSwsp

C.SWSP mem32[sp + uimm] = rs2

Fields

§rs2: Reg
§uimm: u8
§

CSdsp

C.SDSP mem64[sp + uimm] = rs2

Fields

§rs2: Reg
§uimm: u16
§

CUnimp

§

CLbu

C.LBU rd’ = zero_extend(mem8[rs1’ + uimm]) uimm ∈ {0,1,2,3}

Fields

§rs1: Reg
§rd: Reg
§uimm: u8
§

CLh

C.LH rd’ = sign_extend(mem16[rs1’ + uimm]) uimm ∈ {0,2}

Fields

§rs1: Reg
§rd: Reg
§uimm: u8
§

CLhu

C.LHU rd’ = zero_extend(mem16[rs1’ + uimm]) uimm ∈ {0,2}

Fields

§rs1: Reg
§rd: Reg
§uimm: u8
§

CSb

C.SB mem8[rs1’ + uimm] = rs2’ uimm ∈ {0,1,2,3}

Fields

§rs1: Reg
§rs2: Reg
§uimm: u8
§

CSh

C.SH mem16[rs1’ + uimm] = rs2’ uimm ∈ {0,2}

Fields

§rs1: Reg
§rs2: Reg
§uimm: u8
§

CZextB

C.ZEXT.B rd’ = rd’ & 0xff

Fields

§rd: Reg
§

CSextB

C.SEXT.B rd’ = sext(rd’[7:0]) (requires Zbb)

Fields

§rd: Reg
§

CZextH

C.ZEXT.H rd’ = rd’ & 0xffff (requires Zbb)

Fields

§rd: Reg
§

CSextH

C.SEXT.H rd’ = sext(rd’[15:0]) (requires Zbb)

Fields

§rd: Reg
§

CZextW

C.ZEXT.W rd’ = rd’ & 0xffff_ffff (requires Zba)

Fields

§rd: Reg
§

CNot

C.NOT rd’ = ~rd’

Fields

§rd: Reg
§

CMul

C.MUL rd’ = (rd’ * rs2’)[XLEN-1:0] (requires M or Zmmul)

Fields

§rs2: Reg
§rd: Reg
§

CmPush

CM.PUSH - push reg_list, decrement sp by stack_adj

stack_adj = urlist.stack_adj_base() + spimm * 16 from the encoding.

Fields

§urlist: ZcmpUrlist<Reg>
§stack_adj: u8
§

CmPop

CM.POP - pop reg_list, increment sp by stack_adj (no return)

Fields

§urlist: ZcmpUrlist<Reg>
§stack_adj: u8
§

CmPopretz

CM.POPRETZ - pop reg_list, set a0=0, increment sp, return

Fields

§urlist: ZcmpUrlist<Reg>
§stack_adj: u8
§

CmPopret

CM.POPRET - pop reg_list, increment sp, return

Fields

§urlist: ZcmpUrlist<Reg>
§stack_adj: u8
§

CmMva01s

CM.MVA01S - a0 = r1s’, a1 = r2s’.

The fields are called both r1s/r2s and rs1/rs2 in the spec, rs1/rs2 is used here for consistency with other instructions.

Fields

§rs1: Reg
§rs2: Reg
§

CmMvsa01

CM.MVSA01 - r1s’ = a0, r2s’ = a1 (r1s’ != r2s’).

The fields are called both r1s/r2s and rs1/rs2 in the spec, rs1/rs2 is used here for consistency with other instructions.

Fields

§rs1: Reg
§rs2: Reg
§

Add

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Sub

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Sll

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Slt

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Sltu

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Xor

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Srl

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Sra

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Or

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

And

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Addw

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Subw

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Sllw

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Srlw

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Sraw

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Addi

Fields

§rs1: Reg
§rd: Reg
§imm: i16
§

Slti

Fields

§rs1: Reg
§rd: Reg
§imm: i16
§

Sltiu

Fields

§rs1: Reg
§rd: Reg
§imm: i16
§

Xori

Fields

§rs1: Reg
§rd: Reg
§imm: i16
§

Ori

Fields

§rs1: Reg
§rd: Reg
§imm: i16
§

Andi

Fields

§rs1: Reg
§rd: Reg
§imm: i16
§

Slli

Fields

§rs1: Reg
§rd: Reg
§shamt: u8
§

Srli

Fields

§rs1: Reg
§rd: Reg
§shamt: u8
§

Srai

Fields

§rs1: Reg
§rd: Reg
§shamt: u8
§

Addiw

Fields

§rs1: Reg
§rd: Reg
§imm: i16
§

Slliw

Fields

§rs1: Reg
§rd: Reg
§shamt: u8
§

Srliw

Fields

§rs1: Reg
§rd: Reg
§shamt: u8
§

Sraiw

Fields

§rs1: Reg
§rd: Reg
§shamt: u8
§

Lb

Fields

§rs1: Reg
§rd: Reg
§imm: i16
§

Lh

Fields

§rs1: Reg
§rd: Reg
§imm: i16
§

Lw

Fields

§rs1: Reg
§rd: Reg
§imm: i16
§

Ld

Fields

§rs1: Reg
§rd: Reg
§imm: i16
§

Lbu

Fields

§rs1: Reg
§rd: Reg
§imm: i16
§

Lhu

Fields

§rs1: Reg
§rd: Reg
§imm: i16
§

Lwu

Fields

§rs1: Reg
§rd: Reg
§imm: i16
§

Jalr

Fields

§rs1: Reg
§rd: Reg
§imm: i16
§

Sb

Fields

§rs1: Reg
§rs2: Reg
§imm: i16
§

Sh

Fields

§rs1: Reg
§rs2: Reg
§imm: i16
§

Sw

Fields

§rs1: Reg
§rs2: Reg
§imm: i16
§

Sd

Fields

§rs1: Reg
§rs2: Reg
§imm: i16
§

Beq

Fields

§rs1: Reg
§rs2: Reg
§imm: I24
§

Bne

Fields

§rs1: Reg
§rs2: Reg
§imm: I24
§

Blt

Fields

§rs1: Reg
§rs2: Reg
§imm: I24
§

Bge

Fields

§rs1: Reg
§rs2: Reg
§imm: I24
§

Bltu

Fields

§rs1: Reg
§rs2: Reg
§imm: I24
§

Bgeu

Fields

§rs1: Reg
§rs2: Reg
§imm: I24
§

Lui

Fields

§rd: Reg
§imm: I24WithZeroedBits<12>
§

Auipc

Fields

§rd: Reg
§imm: I24WithZeroedBits<12>
§

Jal

Fields

§rd: Reg
§imm: I24
§

Ebreak

§

Unimp

§

Mul

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Mulh

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Mulhsu

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Mulhu

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Div

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Divu

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Rem

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Remu

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Mulw

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Divw

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Divuw

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Remw

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Remuw

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

AddUw

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Sh1add

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Sh1addUw

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Sh2add

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Sh2addUw

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Sh3add

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Sh3addUw

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

SlliUw

Fields

§rs1: Reg
§rd: Reg
§shamt: u8
§

Andn

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Orn

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Xnor

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Clz

Fields

§rs1: Reg
§rd: Reg
§

Clzw

Fields

§rs1: Reg
§rd: Reg
§

Ctz

Fields

§rs1: Reg
§rd: Reg
§

Ctzw

Fields

§rs1: Reg
§rd: Reg
§

Cpop

Fields

§rs1: Reg
§rd: Reg
§

Cpopw

Fields

§rs1: Reg
§rd: Reg
§

Max

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Maxu

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Min

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Minu

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Sextb

Fields

§rs1: Reg
§rd: Reg
§

Sexth

Fields

§rs1: Reg
§rd: Reg
§

Zexth

Fields

§rs1: Reg
§rd: Reg
§

Rol

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Rolw

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Ror

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Rori

Fields

§rs1: Reg
§rd: Reg
§shamt: u8
§

Roriw

Fields

§rs1: Reg
§rd: Reg
§shamt: u8
§

Rorw

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Orcb

Fields

§rs1: Reg
§rd: Reg
§

Rev8

Fields

§rs1: Reg
§rd: Reg
§

Bset

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Bseti

Fields

§rs1: Reg
§rd: Reg
§shamt: u8
§

Bclr

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Bclri

Fields

§rs1: Reg
§rd: Reg
§shamt: u8
§

Binv

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Binvi

Fields

§rs1: Reg
§rd: Reg
§shamt: u8
§

Bext

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Bexti

Fields

§rs1: Reg
§rd: Reg
§shamt: u8
§

Clmul

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Clmulh

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Clmulr

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Pack

Pack low 32 bits of rs1 and rs2 into rd

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Packh

Pack low 8 bits of rs1 and rs2 into rd bytes 0 and 1

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Packw

Pack low 16 bits of rs1 and rs2 into lower 32 bits of rd, sign-extend

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Brev8

Reverse bits in each byte of rs1

Fields

§rs1: Reg
§rd: Reg
§

Xperm4

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Xperm8

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Aes64Ds

AES final round decryption: InvShiftRows + InvSubBytes, no MixColumns

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Aes64Dsm

AES middle round decryption: InvShiftRows + InvSubBytes + InvMixColumns

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Aes64Im

AES inverse MixColumns on each 32-bit word of rs1

Fields

§rs1: Reg
§rd: Reg
§

Aes64Ks1i

AES key schedule step 1 (rnum in 0..=10)

Fields

§rs1: Reg
§rd: Reg
§rnum: Rv64ZkndKsRnum
§

Aes64Ks2

AES key schedule step 2

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Aes64Es

AES final round encryption: ShiftRows + SubBytes, no MixColumns

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Aes64Esm

AES middle round encryption: ShiftRows + SubBytes + MixColumns

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

Sha256Sig0

Fields

§rs1: Reg
§rd: Reg
§

Sha256Sig1

Fields

§rs1: Reg
§rd: Reg
§

Sha256Sum0

Fields

§rs1: Reg
§rd: Reg
§

Sha256Sum1

Fields

§rs1: Reg
§rd: Reg
§

Sha512Sig0

Fields

§rs1: Reg
§rd: Reg
§

Sha512Sig1

Fields

§rs1: Reg
§rd: Reg
§

Sha512Sum0

Fields

§rs1: Reg
§rd: Reg
§

Sha512Sum1

Fields

§rs1: Reg
§rd: Reg
§

CzeroEqz

czero.eqz rd, rs1, rs2 - move zero to rd if rs2 == 0, else move rs1

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg
§

CzeroNez

czero.nez rd, rs1, rs2 - move zero to rd if rs2 != 0, else move rs1

Fields

§rs1: Reg
§rs2: Reg
§rd: Reg

Implementations§

Source§

impl<Reg> ContractInstruction<Reg>

Source

pub fn is_jump(&self) -> bool

Check if the instruction is a jump instruction of any kind (affects program counter)

Trait Implementations§

Source§

impl<Reg: Clone> Clone for ContractInstruction<Reg>

Source§

fn clone(&self) -> ContractInstruction<Reg>

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl<Reg: Debug> Debug for ContractInstruction<Reg>

Source§

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

Formats the value using the given formatter. Read more
§

impl<Reg> Display for ContractInstruction<Reg>
where Reg: Register,

§

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

Formats the value using the given formatter. Read more
§

impl<Reg, Regs, ExtState, Memory, PC, InstructionHandler, CustomError> ExecutableInstruction<Regs, ExtState, Memory, PC, InstructionHandler, CustomError> for ContractInstruction<Reg>
where Reg: Register + Register<Type = u64> + ZcmpRegister<Type = u64>, Regs: RegisterFile<Reg>, Memory: VirtualMemory, PC: ProgramCounter<Reg::Type, Memory, CustomError>, InstructionHandler: SystemInstructionHandler<Reg, Regs, Memory, PC, CustomError>,

§

fn execute( self, _: Rs1Rs2OperandValues<<Self::Reg as Register>::Type>, regs: &mut Regs, _ext_state: &mut ExtState, memory: &mut Memory, program_counter: &mut PC, system_instruction_handler: &mut InstructionHandler, ) -> Result<ControlFlow<(), (Self::Reg, <Self::Reg as Register>::Type)>, ExecutionError<Reg::Type, CustomError>>

Execute instruction. Read more
§

impl<Reg, ExtState, CustomError> ExecutableInstructionCsr<ExtState, CustomError> for ContractInstruction<Reg>
where Reg: Register<Type = u64> + ZcmpRegister<Type = u64> + Register,

§

fn prepare_csr_read( ext_state: &ExtState, csr_index: u16, raw_value: <Self::Reg as Register>::Type, output_value: &mut <Self::Reg as Register>::Type, ) -> Result<bool, CsrError<CustomError>>

Prepare CSR read. Read more
§

fn prepare_csr_write( ext_state: &mut ExtState, csr_index: u16, write_value: <Self::Reg as Register>::Type, output_value: &mut <Self::Reg as Register>::Type, ) -> Result<bool, CsrError<CustomError>>

Prepare CSR write. Read more
§

impl<Reg> ExecutableInstructionOperands for ContractInstruction<Reg>
where Reg: Register<Type = u64> + ZcmpRegister<Type = u64> + Register,

§

fn get_rs1_rs2_operands(self) -> Rs1Rs2Operands<Self::Reg>

rs1/rs2 instruction operands. Read more
§

impl<Reg> Instruction for ContractInstruction<Reg>
where Reg: Register<Type = u64> + ZcmpRegister<Type = u64> + Register,

§

type Reg = Reg

A register type used by the instruction
§

fn try_decode(instruction: u32) -> Option<Self>

Try to decode a single valid instruction
§

fn alignment() -> u8

Instruction alignment in bytes
§

fn size(&self) -> u8

Instruction size in bytes
Source§

impl<Reg: PartialEq> PartialEq for ContractInstruction<Reg>

Source§

fn eq(&self, other: &ContractInstruction<Reg>) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

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

impl<Reg: Copy> Copy for ContractInstruction<Reg>

Source§

impl<Reg: Eq> Eq for ContractInstruction<Reg>

Source§

impl<Reg> StructuralPartialEq for ContractInstruction<Reg>

Auto Trait Implementations§

§

impl<Reg> Freeze for ContractInstruction<Reg>
where Reg: Freeze,

§

impl<Reg> RefUnwindSafe for ContractInstruction<Reg>
where Reg: RefUnwindSafe,

§

impl<Reg> Send for ContractInstruction<Reg>
where Reg: Send,

§

impl<Reg> Sync for ContractInstruction<Reg>
where Reg: Sync,

§

impl<Reg> Unpin for ContractInstruction<Reg>
where Reg: Unpin,

§

impl<Reg> UnsafeUnpin for ContractInstruction<Reg>
where Reg: UnsafeUnpin,

§

impl<Reg> UnwindSafe for ContractInstruction<Reg>
where Reg: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T> ToString for T
where T: Display + ?Sized,

Source§

fn to_string(&self) -> String

Converts the given value to a String. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more