From e25760d8e5319c9cc1ca17d255399b3d9624e6a4 Mon Sep 17 00:00:00 2001 From: David Harris Date: Tue, 11 Jan 2022 21:01:48 +0000 Subject: [PATCH] Added C test cases --- .gitmodules | 3 + addins/riscv-tests | 1 + examples/C/common/LICENSE | 24 + examples/C/common/README | 1 + examples/C/common/crt.S | 225 +++ examples/C/common/encoding.h | 2832 ++++++++++++++++++++++++++++++++++ examples/C/common/syscalls.c | 469 ++++++ examples/C/common/test.ld | 66 + examples/C/common/util.h | 90 ++ examples/C/mm/Makefile | 16 + examples/C/mm/common.h | 36 + examples/C/mm/mm | Bin 0 -> 112448 bytes examples/C/mm/mm.c | 152 ++ examples/C/mm/mm_main.c | 76 + examples/C/mm/old.gen.scala | 81 + examples/C/mm/rb.h | 210 +++ examples/C/simple/Makefile | 12 +- examples/C/simple/simple | Bin 0 -> 39560 bytes examples/C/simple/simple.c | 11 +- examples/link/linkc.ld | 17 - 20 files changed, 4298 insertions(+), 24 deletions(-) create mode 160000 addins/riscv-tests create mode 100644 examples/C/common/LICENSE create mode 100644 examples/C/common/README create mode 100644 examples/C/common/crt.S create mode 100644 examples/C/common/encoding.h create mode 100644 examples/C/common/syscalls.c create mode 100644 examples/C/common/test.ld create mode 100644 examples/C/common/util.h create mode 100644 examples/C/mm/Makefile create mode 100644 examples/C/mm/common.h create mode 100755 examples/C/mm/mm create mode 100644 examples/C/mm/mm.c create mode 100644 examples/C/mm/mm_main.c create mode 100644 examples/C/mm/old.gen.scala create mode 100644 examples/C/mm/rb.h create mode 100755 examples/C/simple/simple delete mode 100644 examples/link/linkc.ld diff --git a/.gitmodules b/.gitmodules index 0182e1388..bd2adf269 100644 --- a/.gitmodules +++ b/.gitmodules @@ -8,3 +8,6 @@ [submodule "addins/imperas-riscv-tests"] path = addins/imperas-riscv-tests url = https://github.com/riscv-ovpsim/imperas-riscv-tests +[submodule "addins/riscv-tests"] + path = addins/riscv-tests + url = https://github.com/riscv-software-src/riscv-tests diff --git a/addins/riscv-tests b/addins/riscv-tests new file mode 160000 index 000000000..cf04274f5 --- /dev/null +++ b/addins/riscv-tests @@ -0,0 +1 @@ +Subproject commit cf04274f50621fd9ef9147793cca6dd1657985c7 diff --git a/examples/C/common/LICENSE b/examples/C/common/LICENSE new file mode 100644 index 000000000..48fe522ac --- /dev/null +++ b/examples/C/common/LICENSE @@ -0,0 +1,24 @@ +Copyright (c) 2012-2015, The Regents of the University of California (Regents). +All Rights Reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of the Regents nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + +IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, +SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING +OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF REGENTS HAS +BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED +HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO OBLIGATION TO PROVIDE +MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. diff --git a/examples/C/common/README b/examples/C/common/README new file mode 100644 index 000000000..5d23ec69e --- /dev/null +++ b/examples/C/common/README @@ -0,0 +1 @@ +These files are from github.com/riscv-software-src/riscv-tests diff --git a/examples/C/common/crt.S b/examples/C/common/crt.S new file mode 100644 index 000000000..018f92913 --- /dev/null +++ b/examples/C/common/crt.S @@ -0,0 +1,225 @@ +# See LICENSE for license details. + +#include "encoding.h" + +#if __riscv_xlen == 64 +# define LREG ld +# define SREG sd +# define REGBYTES 8 +#else +# define LREG lw +# define SREG sw +# define REGBYTES 4 +#endif + + .section ".text.init" + .globl _start +_start: + li x1, 0 + li x2, 0 + li x3, 0 + li x4, 0 + li x5, 0 + li x6, 0 + li x7, 0 + li x8, 0 + li x9, 0 + li x10,0 + li x11,0 + li x12,0 + li x13,0 + li x14,0 + li x15,0 + li x16,0 + li x17,0 + li x18,0 + li x19,0 + li x20,0 + li x21,0 + li x22,0 + li x23,0 + li x24,0 + li x25,0 + li x26,0 + li x27,0 + li x28,0 + li x29,0 + li x30,0 + li x31,0 + + # enable FPU and accelerator if present + li t0, MSTATUS_FS | MSTATUS_XS + csrs mstatus, t0 + + # make sure XLEN agrees with compilation choice + li t0, 1 + slli t0, t0, 31 +#if __riscv_xlen == 64 + bgez t0, 1f +#else + bltz t0, 1f +#endif +2: + li a0, 1 + sw a0, tohost, t0 + j 2b +1: + +#ifdef __riscv_flen + # initialize FPU if we have one + la t0, 1f + csrw mtvec, t0 + + fssr x0 + fmv.s.x f0, x0 + fmv.s.x f1, x0 + fmv.s.x f2, x0 + fmv.s.x f3, x0 + fmv.s.x f4, x0 + fmv.s.x f5, x0 + fmv.s.x f6, x0 + fmv.s.x f7, x0 + fmv.s.x f8, x0 + fmv.s.x f9, x0 + fmv.s.x f10,x0 + fmv.s.x f11,x0 + fmv.s.x f12,x0 + fmv.s.x f13,x0 + fmv.s.x f14,x0 + fmv.s.x f15,x0 + fmv.s.x f16,x0 + fmv.s.x f17,x0 + fmv.s.x f18,x0 + fmv.s.x f19,x0 + fmv.s.x f20,x0 + fmv.s.x f21,x0 + fmv.s.x f22,x0 + fmv.s.x f23,x0 + fmv.s.x f24,x0 + fmv.s.x f25,x0 + fmv.s.x f26,x0 + fmv.s.x f27,x0 + fmv.s.x f28,x0 + fmv.s.x f29,x0 + fmv.s.x f30,x0 + fmv.s.x f31,x0 +1: +#endif + + # initialize trap vector + la t0, trap_entry + csrw mtvec, t0 + + # initialize global pointer +.option push +.option norelax + la gp, __global_pointer$ +.option pop + + la tp, _end + 63 + and tp, tp, -64 + + # get core id + csrr a0, mhartid + # for now, assume only 1 core + li a1, 1 +1:bgeu a0, a1, 1b + + # give each core 128KB of stack + TLS +#define STKSHIFT 17 + add sp, a0, 1 + sll sp, sp, STKSHIFT + add sp, sp, tp + sll a2, a0, STKSHIFT + add tp, tp, a2 + + j _init + + .align 2 +trap_entry: + addi sp, sp, -272 + + SREG x1, 1*REGBYTES(sp) + SREG x2, 2*REGBYTES(sp) + SREG x3, 3*REGBYTES(sp) + SREG x4, 4*REGBYTES(sp) + SREG x5, 5*REGBYTES(sp) + SREG x6, 6*REGBYTES(sp) + SREG x7, 7*REGBYTES(sp) + SREG x8, 8*REGBYTES(sp) + SREG x9, 9*REGBYTES(sp) + SREG x10, 10*REGBYTES(sp) + SREG x11, 11*REGBYTES(sp) + SREG x12, 12*REGBYTES(sp) + SREG x13, 13*REGBYTES(sp) + SREG x14, 14*REGBYTES(sp) + SREG x15, 15*REGBYTES(sp) + SREG x16, 16*REGBYTES(sp) + SREG x17, 17*REGBYTES(sp) + SREG x18, 18*REGBYTES(sp) + SREG x19, 19*REGBYTES(sp) + SREG x20, 20*REGBYTES(sp) + SREG x21, 21*REGBYTES(sp) + SREG x22, 22*REGBYTES(sp) + SREG x23, 23*REGBYTES(sp) + SREG x24, 24*REGBYTES(sp) + SREG x25, 25*REGBYTES(sp) + SREG x26, 26*REGBYTES(sp) + SREG x27, 27*REGBYTES(sp) + SREG x28, 28*REGBYTES(sp) + SREG x29, 29*REGBYTES(sp) + SREG x30, 30*REGBYTES(sp) + SREG x31, 31*REGBYTES(sp) + + csrr a0, mcause + csrr a1, mepc + mv a2, sp + jal handle_trap + csrw mepc, a0 + + # Remain in M-mode after eret + li t0, MSTATUS_MPP + csrs mstatus, t0 + + LREG x1, 1*REGBYTES(sp) + LREG x2, 2*REGBYTES(sp) + LREG x3, 3*REGBYTES(sp) + LREG x4, 4*REGBYTES(sp) + LREG x5, 5*REGBYTES(sp) + LREG x6, 6*REGBYTES(sp) + LREG x7, 7*REGBYTES(sp) + LREG x8, 8*REGBYTES(sp) + LREG x9, 9*REGBYTES(sp) + LREG x10, 10*REGBYTES(sp) + LREG x11, 11*REGBYTES(sp) + LREG x12, 12*REGBYTES(sp) + LREG x13, 13*REGBYTES(sp) + LREG x14, 14*REGBYTES(sp) + LREG x15, 15*REGBYTES(sp) + LREG x16, 16*REGBYTES(sp) + LREG x17, 17*REGBYTES(sp) + LREG x18, 18*REGBYTES(sp) + LREG x19, 19*REGBYTES(sp) + LREG x20, 20*REGBYTES(sp) + LREG x21, 21*REGBYTES(sp) + LREG x22, 22*REGBYTES(sp) + LREG x23, 23*REGBYTES(sp) + LREG x24, 24*REGBYTES(sp) + LREG x25, 25*REGBYTES(sp) + LREG x26, 26*REGBYTES(sp) + LREG x27, 27*REGBYTES(sp) + LREG x28, 28*REGBYTES(sp) + LREG x29, 29*REGBYTES(sp) + LREG x30, 30*REGBYTES(sp) + LREG x31, 31*REGBYTES(sp) + + addi sp, sp, 272 + mret + +.section ".tohost","aw",@progbits +.align 6 +.globl tohost +tohost: .dword 0 +.align 6 +.globl fromhost +fromhost: .dword 0 diff --git a/examples/C/common/encoding.h b/examples/C/common/encoding.h new file mode 100644 index 000000000..2aa895b86 --- /dev/null +++ b/examples/C/common/encoding.h @@ -0,0 +1,2832 @@ +/* See LICENSE for license details. */ + +#ifndef RISCV_CSR_ENCODING_H +#define RISCV_CSR_ENCODING_H + +#define MSTATUS_UIE 0x00000001 +#define MSTATUS_SIE 0x00000002 +#define MSTATUS_HIE 0x00000004 +#define MSTATUS_MIE 0x00000008 +#define MSTATUS_UPIE 0x00000010 +#define MSTATUS_SPIE 0x00000020 +#define MSTATUS_HPIE 0x00000040 +#define MSTATUS_MPIE 0x00000080 +#define MSTATUS_SPP 0x00000100 +#define MSTATUS_VS 0x00000600 +#define MSTATUS_MPP 0x00001800 +#define MSTATUS_FS 0x00006000 +#define MSTATUS_XS 0x00018000 +#define MSTATUS_MPRV 0x00020000 +#define MSTATUS_SUM 0x00040000 +#define MSTATUS_MXR 0x00080000 +#define MSTATUS_TVM 0x00100000 +#define MSTATUS_TW 0x00200000 +#define MSTATUS_TSR 0x00400000 +#define MSTATUS32_SD 0x80000000 +#define MSTATUS_UXL 0x0000000300000000 +#define MSTATUS_SXL 0x0000000C00000000 +#define MSTATUS64_SD 0x8000000000000000 + +#define SSTATUS_UIE 0x00000001 +#define SSTATUS_SIE 0x00000002 +#define SSTATUS_UPIE 0x00000010 +#define SSTATUS_SPIE 0x00000020 +#define SSTATUS_SPP 0x00000100 +#define SSTATUS_VS 0x00000600 +#define SSTATUS_FS 0x00006000 +#define SSTATUS_XS 0x00018000 +#define SSTATUS_SUM 0x00040000 +#define SSTATUS_MXR 0x00080000 +#define SSTATUS32_SD 0x80000000 +#define SSTATUS_UXL 0x0000000300000000 +#define SSTATUS64_SD 0x8000000000000000 + +#define USTATUS_UIE 0x00000001 +#define USTATUS_UPIE 0x00000010 + +#define DCSR_XDEBUGVER (3U<<30) +#define DCSR_NDRESET (1<<29) +#define DCSR_FULLRESET (1<<28) +#define DCSR_EBREAKM (1<<15) +#define DCSR_EBREAKH (1<<14) +#define DCSR_EBREAKS (1<<13) +#define DCSR_EBREAKU (1<<12) +#define DCSR_STOPCYCLE (1<<10) +#define DCSR_STOPTIME (1<<9) +#define DCSR_CAUSE (7<<6) +#define DCSR_DEBUGINT (1<<5) +#define DCSR_HALT (1<<3) +#define DCSR_STEP (1<<2) +#define DCSR_PRV (3<<0) + +#define DCSR_CAUSE_NONE 0 +#define DCSR_CAUSE_SWBP 1 +#define DCSR_CAUSE_HWBP 2 +#define DCSR_CAUSE_DEBUGINT 3 +#define DCSR_CAUSE_STEP 4 +#define DCSR_CAUSE_HALT 5 + +#define MCONTROL_TYPE(xlen) (0xfULL<<((xlen)-4)) +#define MCONTROL_DMODE(xlen) (1ULL<<((xlen)-5)) +#define MCONTROL_MASKMAX(xlen) (0x3fULL<<((xlen)-11)) + +#define MCONTROL_SELECT (1<<19) +#define MCONTROL_TIMING (1<<18) +#define MCONTROL_ACTION (0x3f<<12) +#define MCONTROL_CHAIN (1<<11) +#define MCONTROL_MATCH (0xf<<7) +#define MCONTROL_M (1<<6) +#define MCONTROL_H (1<<5) +#define MCONTROL_S (1<<4) +#define MCONTROL_U (1<<3) +#define MCONTROL_EXECUTE (1<<2) +#define MCONTROL_STORE (1<<1) +#define MCONTROL_LOAD (1<<0) + +#define MCONTROL_TYPE_NONE 0 +#define MCONTROL_TYPE_MATCH 2 + +#define MCONTROL_ACTION_DEBUG_EXCEPTION 0 +#define MCONTROL_ACTION_DEBUG_MODE 1 +#define MCONTROL_ACTION_TRACE_START 2 +#define MCONTROL_ACTION_TRACE_STOP 3 +#define MCONTROL_ACTION_TRACE_EMIT 4 + +#define MCONTROL_MATCH_EQUAL 0 +#define MCONTROL_MATCH_NAPOT 1 +#define MCONTROL_MATCH_GE 2 +#define MCONTROL_MATCH_LT 3 +#define MCONTROL_MATCH_MASK_LOW 4 +#define MCONTROL_MATCH_MASK_HIGH 5 + +#define MIP_USIP (1 << IRQ_U_SOFT) +#define MIP_SSIP (1 << IRQ_S_SOFT) +#define MIP_HSIP (1 << IRQ_H_SOFT) +#define MIP_MSIP (1 << IRQ_M_SOFT) +#define MIP_UTIP (1 << IRQ_U_TIMER) +#define MIP_STIP (1 << IRQ_S_TIMER) +#define MIP_HTIP (1 << IRQ_H_TIMER) +#define MIP_MTIP (1 << IRQ_M_TIMER) +#define MIP_UEIP (1 << IRQ_U_EXT) +#define MIP_SEIP (1 << IRQ_S_EXT) +#define MIP_HEIP (1 << IRQ_H_EXT) +#define MIP_MEIP (1 << IRQ_M_EXT) + +#define SIP_SSIP MIP_SSIP +#define SIP_STIP MIP_STIP + +#define PRV_U 0 +#define PRV_S 1 +#define PRV_H 2 +#define PRV_M 3 + +#define SATP32_MODE 0x80000000 +#define SATP32_ASID 0x7FC00000 +#define SATP32_PPN 0x003FFFFF +#define SATP64_MODE 0xF000000000000000 +#define SATP64_ASID 0x0FFFF00000000000 +#define SATP64_PPN 0x00000FFFFFFFFFFF + +#define SATP_MODE_OFF 0 +#define SATP_MODE_SV32 1 +#define SATP_MODE_SV39 8 +#define SATP_MODE_SV48 9 +#define SATP_MODE_SV57 10 +#define SATP_MODE_SV64 11 + +#define PMP_R 0x01 +#define PMP_W 0x02 +#define PMP_X 0x04 +#define PMP_A 0x18 +#define PMP_L 0x80 +#define PMP_SHIFT 2 + +#define PMP_TOR 0x08 +#define PMP_NA4 0x10 +#define PMP_NAPOT 0x18 + +#define IRQ_U_SOFT 0 +#define IRQ_S_SOFT 1 +#define IRQ_H_SOFT 2 +#define IRQ_M_SOFT 3 +#define IRQ_U_TIMER 4 +#define IRQ_S_TIMER 5 +#define IRQ_H_TIMER 6 +#define IRQ_M_TIMER 7 +#define IRQ_U_EXT 8 +#define IRQ_S_EXT 9 +#define IRQ_H_EXT 10 +#define IRQ_M_EXT 11 +#define IRQ_COP 12 +#define IRQ_HOST 13 + +#define DEFAULT_RSTVEC 0x00001000 +#define CLINT_BASE 0x02000000 +#define CLINT_SIZE 0x000c0000 +#define EXT_IO_BASE 0x40000000 +#define DRAM_BASE 0x80000000 + +/* page table entry (PTE) fields */ +#define PTE_V 0x001 /* Valid */ +#define PTE_R 0x002 /* Read */ +#define PTE_W 0x004 /* Write */ +#define PTE_X 0x008 /* Execute */ +#define PTE_U 0x010 /* User */ +#define PTE_G 0x020 /* Global */ +#define PTE_A 0x040 /* Accessed */ +#define PTE_D 0x080 /* Dirty */ +#define PTE_SOFT 0x300 /* Reserved for Software */ +#define PTE_RSVD 0x1FC0000000000000 /* Reserved for future standard use */ +#define PTE_PBMT 0x6000000000000000 /* Svpbmt: Page-based memory types */ +#define PTE_N 0x8000000000000000 /* Svnapot: NAPOT translation contiguity */ +#define PTE_ATTR 0xFFC0000000000000 /* All attributes and reserved bits */ + +#define PTE_PPN_SHIFT 10 + +#define PTE_TABLE(PTE) (((PTE) & (PTE_V | PTE_R | PTE_W | PTE_X)) == PTE_V) + +#ifdef __riscv + +#if __riscv_xlen == 64 +# define MSTATUS_SD MSTATUS64_SD +# define SSTATUS_SD SSTATUS64_SD +# define RISCV_PGLEVEL_BITS 9 +# define SATP_MODE SATP64_MODE +#else +# define MSTATUS_SD MSTATUS32_SD +# define SSTATUS_SD SSTATUS32_SD +# define RISCV_PGLEVEL_BITS 10 +# define SATP_MODE SATP32_MODE +#endif +#define RISCV_PGSHIFT 12 +#define RISCV_PGSIZE (1 << RISCV_PGSHIFT) + +#ifndef __ASSEMBLER__ + +#ifdef __GNUC__ + +#define read_csr(reg) ({ unsigned long __tmp; \ + asm volatile ("csrr %0, " #reg : "=r"(__tmp)); \ + __tmp; }) + +#define write_csr(reg, val) ({ \ + asm volatile ("csrw " #reg ", %0" :: "rK"(val)); }) + +#define swap_csr(reg, val) ({ unsigned long __tmp; \ + asm volatile ("csrrw %0, " #reg ", %1" : "=r"(__tmp) : "rK"(val)); \ + __tmp; }) + +#define set_csr(reg, bit) ({ unsigned long __tmp; \ + asm volatile ("csrrs %0, " #reg ", %1" : "=r"(__tmp) : "rK"(bit)); \ + __tmp; }) + +#define clear_csr(reg, bit) ({ unsigned long __tmp; \ + asm volatile ("csrrc %0, " #reg ", %1" : "=r"(__tmp) : "rK"(bit)); \ + __tmp; }) + +#define rdtime() read_csr(time) +#define rdcycle() read_csr(cycle) +#define rdinstret() read_csr(instret) + +#endif + +#endif + +#endif + +#endif +/* Automatically generated by parse_opcodes. */ +#ifndef RISCV_ENCODING_H +#define RISCV_ENCODING_H +#define MATCH_SLLI_RV32 0x1013 +#define MASK_SLLI_RV32 0xfe00707f +#define MATCH_SRLI_RV32 0x5013 +#define MASK_SRLI_RV32 0xfe00707f +#define MATCH_SRAI_RV32 0x40005013 +#define MASK_SRAI_RV32 0xfe00707f +#define MATCH_FRFLAGS 0x102073 +#define MASK_FRFLAGS 0xfffff07f +#define MATCH_FSFLAGS 0x101073 +#define MASK_FSFLAGS 0xfff0707f +#define MATCH_FSFLAGSI 0x105073 +#define MASK_FSFLAGSI 0xfff0707f +#define MATCH_FRRM 0x202073 +#define MASK_FRRM 0xfffff07f +#define MATCH_FSRM 0x201073 +#define MASK_FSRM 0xfff0707f +#define MATCH_FSRMI 0x205073 +#define MASK_FSRMI 0xfff0707f +#define MATCH_FSCSR 0x301073 +#define MASK_FSCSR 0xfff0707f +#define MATCH_FRCSR 0x302073 +#define MASK_FRCSR 0xfffff07f +#define MATCH_RDCYCLE 0xc0002073 +#define MASK_RDCYCLE 0xfffff07f +#define MATCH_RDTIME 0xc0102073 +#define MASK_RDTIME 0xfffff07f +#define MATCH_RDINSTRET 0xc0202073 +#define MASK_RDINSTRET 0xfffff07f +#define MATCH_RDCYCLEH 0xc8002073 +#define MASK_RDCYCLEH 0xfffff07f +#define MATCH_RDTIMEH 0xc8102073 +#define MASK_RDTIMEH 0xfffff07f +#define MATCH_RDINSTRETH 0xc8202073 +#define MASK_RDINSTRETH 0xfffff07f +#define MATCH_SCALL 0x73 +#define MASK_SCALL 0xffffffff +#define MATCH_SBREAK 0x100073 +#define MASK_SBREAK 0xffffffff +#define MATCH_FMV_X_S 0xe0000053 +#define MASK_FMV_X_S 0xfff0707f +#define MATCH_FMV_S_X 0xf0000053 +#define MASK_FMV_S_X 0xfff0707f +#define MATCH_FENCE_TSO 0x8330000f +#define MASK_FENCE_TSO 0xfff0707f +#define MATCH_PAUSE 0x100000f +#define MASK_PAUSE 0xffffffff +#define MATCH_BEQ 0x63 +#define MASK_BEQ 0x707f +#define MATCH_BNE 0x1063 +#define MASK_BNE 0x707f +#define MATCH_BLT 0x4063 +#define MASK_BLT 0x707f +#define MATCH_BGE 0x5063 +#define MASK_BGE 0x707f +#define MATCH_BLTU 0x6063 +#define MASK_BLTU 0x707f +#define MATCH_BGEU 0x7063 +#define MASK_BGEU 0x707f +#define MATCH_JALR 0x67 +#define MASK_JALR 0x707f +#define MATCH_JAL 0x6f +#define MASK_JAL 0x7f +#define MATCH_LUI 0x37 +#define MASK_LUI 0x7f +#define MATCH_AUIPC 0x17 +#define MASK_AUIPC 0x7f +#define MATCH_ADDI 0x13 +#define MASK_ADDI 0x707f +#define MATCH_SLLI 0x1013 +#define MASK_SLLI 0xfc00707f +#define MATCH_SLTI 0x2013 +#define MASK_SLTI 0x707f +#define MATCH_SLTIU 0x3013 +#define MASK_SLTIU 0x707f +#define MATCH_XORI 0x4013 +#define MASK_XORI 0x707f +#define MATCH_SRLI 0x5013 +#define MASK_SRLI 0xfc00707f +#define MATCH_SRAI 0x40005013 +#define MASK_SRAI 0xfc00707f +#define MATCH_ORI 0x6013 +#define MASK_ORI 0x707f +#define MATCH_ANDI 0x7013 +#define MASK_ANDI 0x707f +#define MATCH_ADD 0x33 +#define MASK_ADD 0xfe00707f +#define MATCH_SUB 0x40000033 +#define MASK_SUB 0xfe00707f +#define MATCH_SLL 0x1033 +#define MASK_SLL 0xfe00707f +#define MATCH_SLT 0x2033 +#define MASK_SLT 0xfe00707f +#define MATCH_SLTU 0x3033 +#define MASK_SLTU 0xfe00707f +#define MATCH_XOR 0x4033 +#define MASK_XOR 0xfe00707f +#define MATCH_SRL 0x5033 +#define MASK_SRL 0xfe00707f +#define MATCH_SRA 0x40005033 +#define MASK_SRA 0xfe00707f +#define MATCH_OR 0x6033 +#define MASK_OR 0xfe00707f +#define MATCH_AND 0x7033 +#define MASK_AND 0xfe00707f +#define MATCH_LB 0x3 +#define MASK_LB 0x707f +#define MATCH_LH 0x1003 +#define MASK_LH 0x707f +#define MATCH_LW 0x2003 +#define MASK_LW 0x707f +#define MATCH_LBU 0x4003 +#define MASK_LBU 0x707f +#define MATCH_LHU 0x5003 +#define MASK_LHU 0x707f +#define MATCH_SB 0x23 +#define MASK_SB 0x707f +#define MATCH_SH 0x1023 +#define MASK_SH 0x707f +#define MATCH_SW 0x2023 +#define MASK_SW 0x707f +#define MATCH_FENCE 0xf +#define MASK_FENCE 0x707f +#define MATCH_FENCE_I 0x100f +#define MASK_FENCE_I 0x707f +#define MATCH_ADDIW 0x1b +#define MASK_ADDIW 0x707f +#define MATCH_SLLIW 0x101b +#define MASK_SLLIW 0xfe00707f +#define MATCH_SRLIW 0x501b +#define MASK_SRLIW 0xfe00707f +#define MATCH_SRAIW 0x4000501b +#define MASK_SRAIW 0xfe00707f +#define MATCH_ADDW 0x3b +#define MASK_ADDW 0xfe00707f +#define MATCH_SUBW 0x4000003b +#define MASK_SUBW 0xfe00707f +#define MATCH_SLLW 0x103b +#define MASK_SLLW 0xfe00707f +#define MATCH_SRLW 0x503b +#define MASK_SRLW 0xfe00707f +#define MATCH_SRAW 0x4000503b +#define MASK_SRAW 0xfe00707f +#define MATCH_LD 0x3003 +#define MASK_LD 0x707f +#define MATCH_LWU 0x6003 +#define MASK_LWU 0x707f +#define MATCH_SD 0x3023 +#define MASK_SD 0x707f +#define MATCH_MUL 0x2000033 +#define MASK_MUL 0xfe00707f +#define MATCH_MULH 0x2001033 +#define MASK_MULH 0xfe00707f +#define MATCH_MULHSU 0x2002033 +#define MASK_MULHSU 0xfe00707f +#define MATCH_MULHU 0x2003033 +#define MASK_MULHU 0xfe00707f +#define MATCH_DIV 0x2004033 +#define MASK_DIV 0xfe00707f +#define MATCH_DIVU 0x2005033 +#define MASK_DIVU 0xfe00707f +#define MATCH_REM 0x2006033 +#define MASK_REM 0xfe00707f +#define MATCH_REMU 0x2007033 +#define MASK_REMU 0xfe00707f +#define MATCH_MULW 0x200003b +#define MASK_MULW 0xfe00707f +#define MATCH_DIVW 0x200403b +#define MASK_DIVW 0xfe00707f +#define MATCH_DIVUW 0x200503b +#define MASK_DIVUW 0xfe00707f +#define MATCH_REMW 0x200603b +#define MASK_REMW 0xfe00707f +#define MATCH_REMUW 0x200703b +#define MASK_REMUW 0xfe00707f +#define MATCH_AMOADD_W 0x202f +#define MASK_AMOADD_W 0xf800707f +#define MATCH_AMOXOR_W 0x2000202f +#define MASK_AMOXOR_W 0xf800707f +#define MATCH_AMOOR_W 0x4000202f +#define MASK_AMOOR_W 0xf800707f +#define MATCH_AMOAND_W 0x6000202f +#define MASK_AMOAND_W 0xf800707f +#define MATCH_AMOMIN_W 0x8000202f +#define MASK_AMOMIN_W 0xf800707f +#define MATCH_AMOMAX_W 0xa000202f +#define MASK_AMOMAX_W 0xf800707f +#define MATCH_AMOMINU_W 0xc000202f +#define MASK_AMOMINU_W 0xf800707f +#define MATCH_AMOMAXU_W 0xe000202f +#define MASK_AMOMAXU_W 0xf800707f +#define MATCH_AMOSWAP_W 0x800202f +#define MASK_AMOSWAP_W 0xf800707f +#define MATCH_LR_W 0x1000202f +#define MASK_LR_W 0xf9f0707f +#define MATCH_SC_W 0x1800202f +#define MASK_SC_W 0xf800707f +#define MATCH_AMOADD_D 0x302f +#define MASK_AMOADD_D 0xf800707f +#define MATCH_AMOXOR_D 0x2000302f +#define MASK_AMOXOR_D 0xf800707f +#define MATCH_AMOOR_D 0x4000302f +#define MASK_AMOOR_D 0xf800707f +#define MATCH_AMOAND_D 0x6000302f +#define MASK_AMOAND_D 0xf800707f +#define MATCH_AMOMIN_D 0x8000302f +#define MASK_AMOMIN_D 0xf800707f +#define MATCH_AMOMAX_D 0xa000302f +#define MASK_AMOMAX_D 0xf800707f +#define MATCH_AMOMINU_D 0xc000302f +#define MASK_AMOMINU_D 0xf800707f +#define MATCH_AMOMAXU_D 0xe000302f +#define MASK_AMOMAXU_D 0xf800707f +#define MATCH_AMOSWAP_D 0x800302f +#define MASK_AMOSWAP_D 0xf800707f +#define MATCH_LR_D 0x1000302f +#define MASK_LR_D 0xf9f0707f +#define MATCH_SC_D 0x1800302f +#define MASK_SC_D 0xf800707f +#define MATCH_FADD_S 0x53 +#define MASK_FADD_S 0xfe00007f +#define MATCH_FSUB_S 0x8000053 +#define MASK_FSUB_S 0xfe00007f +#define MATCH_FMUL_S 0x10000053 +#define MASK_FMUL_S 0xfe00007f +#define MATCH_FDIV_S 0x18000053 +#define MASK_FDIV_S 0xfe00007f +#define MATCH_FSGNJ_S 0x20000053 +#define MASK_FSGNJ_S 0xfe00707f +#define MATCH_FSGNJN_S 0x20001053 +#define MASK_FSGNJN_S 0xfe00707f +#define MATCH_FSGNJX_S 0x20002053 +#define MASK_FSGNJX_S 0xfe00707f +#define MATCH_FMIN_S 0x28000053 +#define MASK_FMIN_S 0xfe00707f +#define MATCH_FMAX_S 0x28001053 +#define MASK_FMAX_S 0xfe00707f +#define MATCH_FSQRT_S 0x58000053 +#define MASK_FSQRT_S 0xfff0007f +#define MATCH_FLE_S 0xa0000053 +#define MASK_FLE_S 0xfe00707f +#define MATCH_FLT_S 0xa0001053 +#define MASK_FLT_S 0xfe00707f +#define MATCH_FEQ_S 0xa0002053 +#define MASK_FEQ_S 0xfe00707f +#define MATCH_FCVT_W_S 0xc0000053 +#define MASK_FCVT_W_S 0xfff0007f +#define MATCH_FCVT_WU_S 0xc0100053 +#define MASK_FCVT_WU_S 0xfff0007f +#define MATCH_FMV_X_W 0xe0000053 +#define MASK_FMV_X_W 0xfff0707f +#define MATCH_FCLASS_S 0xe0001053 +#define MASK_FCLASS_S 0xfff0707f +#define MATCH_FCVT_S_W 0xd0000053 +#define MASK_FCVT_S_W 0xfff0007f +#define MATCH_FCVT_S_WU 0xd0100053 +#define MASK_FCVT_S_WU 0xfff0007f +#define MATCH_FMV_W_X 0xf0000053 +#define MASK_FMV_W_X 0xfff0707f +#define MATCH_FLW 0x2007 +#define MASK_FLW 0x707f +#define MATCH_FSW 0x2027 +#define MASK_FSW 0x707f +#define MATCH_FMADD_S 0x43 +#define MASK_FMADD_S 0x600007f +#define MATCH_FMSUB_S 0x47 +#define MASK_FMSUB_S 0x600007f +#define MATCH_FNMSUB_S 0x4b +#define MASK_FNMSUB_S 0x600007f +#define MATCH_FNMADD_S 0x4f +#define MASK_FNMADD_S 0x600007f +#define MATCH_FCVT_L_S 0xc0200053 +#define MASK_FCVT_L_S 0xfff0007f +#define MATCH_FCVT_LU_S 0xc0300053 +#define MASK_FCVT_LU_S 0xfff0007f +#define MATCH_FCVT_S_L 0xd0200053 +#define MASK_FCVT_S_L 0xfff0007f +#define MATCH_FCVT_S_LU 0xd0300053 +#define MASK_FCVT_S_LU 0xfff0007f +#define MATCH_FADD_D 0x2000053 +#define MASK_FADD_D 0xfe00007f +#define MATCH_FSUB_D 0xa000053 +#define MASK_FSUB_D 0xfe00007f +#define MATCH_FMUL_D 0x12000053 +#define MASK_FMUL_D 0xfe00007f +#define MATCH_FDIV_D 0x1a000053 +#define MASK_FDIV_D 0xfe00007f +#define MATCH_FSGNJ_D 0x22000053 +#define MASK_FSGNJ_D 0xfe00707f +#define MATCH_FSGNJN_D 0x22001053 +#define MASK_FSGNJN_D 0xfe00707f +#define MATCH_FSGNJX_D 0x22002053 +#define MASK_FSGNJX_D 0xfe00707f +#define MATCH_FMIN_D 0x2a000053 +#define MASK_FMIN_D 0xfe00707f +#define MATCH_FMAX_D 0x2a001053 +#define MASK_FMAX_D 0xfe00707f +#define MATCH_FCVT_S_D 0x40100053 +#define MASK_FCVT_S_D 0xfff0007f +#define MATCH_FCVT_D_S 0x42000053 +#define MASK_FCVT_D_S 0xfff0007f +#define MATCH_FSQRT_D 0x5a000053 +#define MASK_FSQRT_D 0xfff0007f +#define MATCH_FLE_D 0xa2000053 +#define MASK_FLE_D 0xfe00707f +#define MATCH_FLT_D 0xa2001053 +#define MASK_FLT_D 0xfe00707f +#define MATCH_FEQ_D 0xa2002053 +#define MASK_FEQ_D 0xfe00707f +#define MATCH_FCVT_W_D 0xc2000053 +#define MASK_FCVT_W_D 0xfff0007f +#define MATCH_FCVT_WU_D 0xc2100053 +#define MASK_FCVT_WU_D 0xfff0007f +#define MATCH_FCLASS_D 0xe2001053 +#define MASK_FCLASS_D 0xfff0707f +#define MATCH_FCVT_D_W 0xd2000053 +#define MASK_FCVT_D_W 0xfff0007f +#define MATCH_FCVT_D_WU 0xd2100053 +#define MASK_FCVT_D_WU 0xfff0007f +#define MATCH_FLD 0x3007 +#define MASK_FLD 0x707f +#define MATCH_FSD 0x3027 +#define MASK_FSD 0x707f +#define MATCH_FMADD_D 0x2000043 +#define MASK_FMADD_D 0x600007f +#define MATCH_FMSUB_D 0x2000047 +#define MASK_FMSUB_D 0x600007f +#define MATCH_FNMSUB_D 0x200004b +#define MASK_FNMSUB_D 0x600007f +#define MATCH_FNMADD_D 0x200004f +#define MASK_FNMADD_D 0x600007f +#define MATCH_FCVT_L_D 0xc2200053 +#define MASK_FCVT_L_D 0xfff0007f +#define MATCH_FCVT_LU_D 0xc2300053 +#define MASK_FCVT_LU_D 0xfff0007f +#define MATCH_FMV_X_D 0xe2000053 +#define MASK_FMV_X_D 0xfff0707f +#define MATCH_FCVT_D_L 0xd2200053 +#define MASK_FCVT_D_L 0xfff0007f +#define MATCH_FCVT_D_LU 0xd2300053 +#define MASK_FCVT_D_LU 0xfff0007f +#define MATCH_FMV_D_X 0xf2000053 +#define MASK_FMV_D_X 0xfff0707f +#define MATCH_FADD_Q 0x6000053 +#define MASK_FADD_Q 0xfe00007f +#define MATCH_FSUB_Q 0xe000053 +#define MASK_FSUB_Q 0xfe00007f +#define MATCH_FMUL_Q 0x16000053 +#define MASK_FMUL_Q 0xfe00007f +#define MATCH_FDIV_Q 0x1e000053 +#define MASK_FDIV_Q 0xfe00007f +#define MATCH_FSGNJ_Q 0x26000053 +#define MASK_FSGNJ_Q 0xfe00707f +#define MATCH_FSGNJN_Q 0x26001053 +#define MASK_FSGNJN_Q 0xfe00707f +#define MATCH_FSGNJX_Q 0x26002053 +#define MASK_FSGNJX_Q 0xfe00707f +#define MATCH_FMIN_Q 0x2e000053 +#define MASK_FMIN_Q 0xfe00707f +#define MATCH_FMAX_Q 0x2e001053 +#define MASK_FMAX_Q 0xfe00707f +#define MATCH_FCVT_S_Q 0x40300053 +#define MASK_FCVT_S_Q 0xfff0007f +#define MATCH_FCVT_Q_S 0x46000053 +#define MASK_FCVT_Q_S 0xfff0007f +#define MATCH_FCVT_D_Q 0x42300053 +#define MASK_FCVT_D_Q 0xfff0007f +#define MATCH_FCVT_Q_D 0x46100053 +#define MASK_FCVT_Q_D 0xfff0007f +#define MATCH_FSQRT_Q 0x5e000053 +#define MASK_FSQRT_Q 0xfff0007f +#define MATCH_FLE_Q 0xa6000053 +#define MASK_FLE_Q 0xfe00707f +#define MATCH_FLT_Q 0xa6001053 +#define MASK_FLT_Q 0xfe00707f +#define MATCH_FEQ_Q 0xa6002053 +#define MASK_FEQ_Q 0xfe00707f +#define MATCH_FCVT_W_Q 0xc6000053 +#define MASK_FCVT_W_Q 0xfff0007f +#define MATCH_FCVT_WU_Q 0xc6100053 +#define MASK_FCVT_WU_Q 0xfff0007f +#define MATCH_FCLASS_Q 0xe6001053 +#define MASK_FCLASS_Q 0xfff0707f +#define MATCH_FCVT_Q_W 0xd6000053 +#define MASK_FCVT_Q_W 0xfff0007f +#define MATCH_FCVT_Q_WU 0xd6100053 +#define MASK_FCVT_Q_WU 0xfff0007f +#define MATCH_FLQ 0x4007 +#define MASK_FLQ 0x707f +#define MATCH_FSQ 0x4027 +#define MASK_FSQ 0x707f +#define MATCH_FMADD_Q 0x6000043 +#define MASK_FMADD_Q 0x600007f +#define MATCH_FMSUB_Q 0x6000047 +#define MASK_FMSUB_Q 0x600007f +#define MATCH_FNMSUB_Q 0x600004b +#define MASK_FNMSUB_Q 0x600007f +#define MATCH_FNMADD_Q 0x600004f +#define MASK_FNMADD_Q 0x600007f +#define MATCH_FCVT_L_Q 0xc6200053 +#define MASK_FCVT_L_Q 0xfff0007f +#define MATCH_FCVT_LU_Q 0xc6300053 +#define MASK_FCVT_LU_Q 0xfff0007f +#define MATCH_FCVT_Q_L 0xd6200053 +#define MASK_FCVT_Q_L 0xfff0007f +#define MATCH_FCVT_Q_LU 0xd6300053 +#define MASK_FCVT_Q_LU 0xfff0007f +#define MATCH_FMV_X_Q 0xe6000053 +#define MASK_FMV_X_Q 0xfff0707f +#define MATCH_FMV_Q_X 0xf6000053 +#define MASK_FMV_Q_X 0xfff0707f +#define MATCH_ECALL 0x73 +#define MASK_ECALL 0xffffffff +#define MATCH_EBREAK 0x100073 +#define MASK_EBREAK 0xffffffff +#define MATCH_URET 0x200073 +#define MASK_URET 0xffffffff +#define MATCH_SRET 0x10200073 +#define MASK_SRET 0xffffffff +#define MATCH_MRET 0x30200073 +#define MASK_MRET 0xffffffff +#define MATCH_DRET 0x7b200073 +#define MASK_DRET 0xffffffff +#define MATCH_SFENCE_VMA 0x12000073 +#define MASK_SFENCE_VMA 0xfe007fff +#define MATCH_WFI 0x10500073 +#define MASK_WFI 0xffffffff +#define MATCH_CSRRW 0x1073 +#define MASK_CSRRW 0x707f +#define MATCH_CSRRS 0x2073 +#define MASK_CSRRS 0x707f +#define MATCH_CSRRC 0x3073 +#define MASK_CSRRC 0x707f +#define MATCH_CSRRWI 0x5073 +#define MASK_CSRRWI 0x707f +#define MATCH_CSRRSI 0x6073 +#define MASK_CSRRSI 0x707f +#define MATCH_CSRRCI 0x7073 +#define MASK_CSRRCI 0x707f +#define MATCH_HFENCE_VVMA 0x22000073 +#define MASK_HFENCE_VVMA 0xfe007fff +#define MATCH_HFENCE_GVMA 0x62000073 +#define MASK_HFENCE_GVMA 0xfe007fff +#define MATCH_C_NOP 0x1 +#define MASK_C_NOP 0xffff +#define MATCH_C_ADDI16SP 0x6101 +#define MASK_C_ADDI16SP 0xef83 +#define MATCH_C_JR 0x8002 +#define MASK_C_JR 0xf07f +#define MATCH_C_JALR 0x9002 +#define MASK_C_JALR 0xf07f +#define MATCH_C_EBREAK 0x9002 +#define MASK_C_EBREAK 0xffff +#define MATCH_C_ADDI4SPN 0x0 +#define MASK_C_ADDI4SPN 0xe003 +#define MATCH_C_FLD 0x2000 +#define MASK_C_FLD 0xe003 +#define MATCH_C_LW 0x4000 +#define MASK_C_LW 0xe003 +#define MATCH_C_FLW 0x6000 +#define MASK_C_FLW 0xe003 +#define MATCH_C_FSD 0xa000 +#define MASK_C_FSD 0xe003 +#define MATCH_C_SW 0xc000 +#define MASK_C_SW 0xe003 +#define MATCH_C_FSW 0xe000 +#define MASK_C_FSW 0xe003 +#define MATCH_C_ADDI 0x1 +#define MASK_C_ADDI 0xe003 +#define MATCH_C_JAL 0x2001 +#define MASK_C_JAL 0xe003 +#define MATCH_C_LI 0x4001 +#define MASK_C_LI 0xe003 +#define MATCH_C_LUI 0x6001 +#define MASK_C_LUI 0xe003 +#define MATCH_C_SRLI 0x8001 +#define MASK_C_SRLI 0xec03 +#define MATCH_C_SRAI 0x8401 +#define MASK_C_SRAI 0xec03 +#define MATCH_C_ANDI 0x8801 +#define MASK_C_ANDI 0xec03 +#define MATCH_C_SUB 0x8c01 +#define MASK_C_SUB 0xfc63 +#define MATCH_C_XOR 0x8c21 +#define MASK_C_XOR 0xfc63 +#define MATCH_C_OR 0x8c41 +#define MASK_C_OR 0xfc63 +#define MATCH_C_AND 0x8c61 +#define MASK_C_AND 0xfc63 +#define MATCH_C_J 0xa001 +#define MASK_C_J 0xe003 +#define MATCH_C_BEQZ 0xc001 +#define MASK_C_BEQZ 0xe003 +#define MATCH_C_BNEZ 0xe001 +#define MASK_C_BNEZ 0xe003 +#define MATCH_C_SLLI 0x2 +#define MASK_C_SLLI 0xe003 +#define MATCH_C_FLDSP 0x2002 +#define MASK_C_FLDSP 0xe003 +#define MATCH_C_LWSP 0x4002 +#define MASK_C_LWSP 0xe003 +#define MATCH_C_FLWSP 0x6002 +#define MASK_C_FLWSP 0xe003 +#define MATCH_C_MV 0x8002 +#define MASK_C_MV 0xf003 +#define MATCH_C_ADD 0x9002 +#define MASK_C_ADD 0xf003 +#define MATCH_C_FSDSP 0xa002 +#define MASK_C_FSDSP 0xe003 +#define MATCH_C_SWSP 0xc002 +#define MASK_C_SWSP 0xe003 +#define MATCH_C_FSWSP 0xe002 +#define MASK_C_FSWSP 0xe003 +#define MATCH_C_SRLI_RV32 0x8001 +#define MASK_C_SRLI_RV32 0xfc03 +#define MATCH_C_SRAI_RV32 0x8401 +#define MASK_C_SRAI_RV32 0xfc03 +#define MATCH_C_SLLI_RV32 0x2 +#define MASK_C_SLLI_RV32 0xf003 +#define MATCH_C_LD 0x6000 +#define MASK_C_LD 0xe003 +#define MATCH_C_SD 0xe000 +#define MASK_C_SD 0xe003 +#define MATCH_C_SUBW 0x9c01 +#define MASK_C_SUBW 0xfc63 +#define MATCH_C_ADDW 0x9c21 +#define MASK_C_ADDW 0xfc63 +#define MATCH_C_ADDIW 0x2001 +#define MASK_C_ADDIW 0xe003 +#define MATCH_C_LDSP 0x6002 +#define MASK_C_LDSP 0xe003 +#define MATCH_C_SDSP 0xe002 +#define MASK_C_SDSP 0xe003 +#define MATCH_C_LQ 0x2000 +#define MASK_C_LQ 0xe003 +#define MATCH_C_SQ 0xa000 +#define MASK_C_SQ 0xe003 +#define MATCH_C_LQSP 0x2002 +#define MASK_C_LQSP 0xe003 +#define MATCH_C_SQSP 0xa002 +#define MASK_C_SQSP 0xe003 +#define MATCH_CUSTOM0 0xb +#define MASK_CUSTOM0 0x707f +#define MATCH_CUSTOM0_RS1 0x200b +#define MASK_CUSTOM0_RS1 0x707f +#define MATCH_CUSTOM0_RS1_RS2 0x300b +#define MASK_CUSTOM0_RS1_RS2 0x707f +#define MATCH_CUSTOM0_RD 0x400b +#define MASK_CUSTOM0_RD 0x707f +#define MATCH_CUSTOM0_RD_RS1 0x600b +#define MASK_CUSTOM0_RD_RS1 0x707f +#define MATCH_CUSTOM0_RD_RS1_RS2 0x700b +#define MASK_CUSTOM0_RD_RS1_RS2 0x707f +#define MATCH_CUSTOM1 0x2b +#define MASK_CUSTOM1 0x707f +#define MATCH_CUSTOM1_RS1 0x202b +#define MASK_CUSTOM1_RS1 0x707f +#define MATCH_CUSTOM1_RS1_RS2 0x302b +#define MASK_CUSTOM1_RS1_RS2 0x707f +#define MATCH_CUSTOM1_RD 0x402b +#define MASK_CUSTOM1_RD 0x707f +#define MATCH_CUSTOM1_RD_RS1 0x602b +#define MASK_CUSTOM1_RD_RS1 0x707f +#define MATCH_CUSTOM1_RD_RS1_RS2 0x702b +#define MASK_CUSTOM1_RD_RS1_RS2 0x707f +#define MATCH_CUSTOM2 0x5b +#define MASK_CUSTOM2 0x707f +#define MATCH_CUSTOM2_RS1 0x205b +#define MASK_CUSTOM2_RS1 0x707f +#define MATCH_CUSTOM2_RS1_RS2 0x305b +#define MASK_CUSTOM2_RS1_RS2 0x707f +#define MATCH_CUSTOM2_RD 0x405b +#define MASK_CUSTOM2_RD 0x707f +#define MATCH_CUSTOM2_RD_RS1 0x605b +#define MASK_CUSTOM2_RD_RS1 0x707f +#define MATCH_CUSTOM2_RD_RS1_RS2 0x705b +#define MASK_CUSTOM2_RD_RS1_RS2 0x707f +#define MATCH_CUSTOM3 0x7b +#define MASK_CUSTOM3 0x707f +#define MATCH_CUSTOM3_RS1 0x207b +#define MASK_CUSTOM3_RS1 0x707f +#define MATCH_CUSTOM3_RS1_RS2 0x307b +#define MASK_CUSTOM3_RS1_RS2 0x707f +#define MATCH_CUSTOM3_RD 0x407b +#define MASK_CUSTOM3_RD 0x707f +#define MATCH_CUSTOM3_RD_RS1 0x607b +#define MASK_CUSTOM3_RD_RS1 0x707f +#define MATCH_CUSTOM3_RD_RS1_RS2 0x707b +#define MASK_CUSTOM3_RD_RS1_RS2 0x707f +#define MATCH_VSETVLI 0x7057 +#define MASK_VSETVLI 0x8000707f +#define MATCH_VSETVL 0x80007057 +#define MASK_VSETVL 0xfe00707f +#define MATCH_VLB_V 0x10000007 +#define MASK_VLB_V 0x1df0707f +#define MATCH_VLH_V 0x10005007 +#define MASK_VLH_V 0x1df0707f +#define MATCH_VLW_V 0x10006007 +#define MASK_VLW_V 0x1df0707f +#define MATCH_VLE_V 0x7007 +#define MASK_VLE_V 0x1df0707f +#define MATCH_VLBU_V 0x7 +#define MASK_VLBU_V 0x1df0707f +#define MATCH_VLHU_V 0x5007 +#define MASK_VLHU_V 0x1df0707f +#define MATCH_VLWU_V 0x6007 +#define MASK_VLWU_V 0x1df0707f +#define MATCH_VSB_V 0x27 +#define MASK_VSB_V 0x1df0707f +#define MATCH_VSH_V 0x5027 +#define MASK_VSH_V 0x1df0707f +#define MATCH_VSW_V 0x6027 +#define MASK_VSW_V 0x1df0707f +#define MATCH_VSE_V 0x7027 +#define MASK_VSE_V 0x1df0707f +#define MATCH_VLSB_V 0x18000007 +#define MASK_VLSB_V 0x1c00707f +#define MATCH_VLSH_V 0x18005007 +#define MASK_VLSH_V 0x1c00707f +#define MATCH_VLSW_V 0x18006007 +#define MASK_VLSW_V 0x1c00707f +#define MATCH_VLSE_V 0x8007007 +#define MASK_VLSE_V 0x1c00707f +#define MATCH_VLSBU_V 0x8000007 +#define MASK_VLSBU_V 0x1c00707f +#define MATCH_VLSHU_V 0x8005007 +#define MASK_VLSHU_V 0x1c00707f +#define MATCH_VLSWU_V 0x8006007 +#define MASK_VLSWU_V 0x1c00707f +#define MATCH_VSSB_V 0x8000027 +#define MASK_VSSB_V 0x1c00707f +#define MATCH_VSSH_V 0x8005027 +#define MASK_VSSH_V 0x1c00707f +#define MATCH_VSSW_V 0x8006027 +#define MASK_VSSW_V 0x1c00707f +#define MATCH_VSSE_V 0x8007027 +#define MASK_VSSE_V 0x1c00707f +#define MATCH_VLXB_V 0x1c000007 +#define MASK_VLXB_V 0x1c00707f +#define MATCH_VLXH_V 0x1c005007 +#define MASK_VLXH_V 0x1c00707f +#define MATCH_VLXW_V 0x1c006007 +#define MASK_VLXW_V 0x1c00707f +#define MATCH_VLXE_V 0xc007007 +#define MASK_VLXE_V 0x1c00707f +#define MATCH_VLXBU_V 0xc000007 +#define MASK_VLXBU_V 0x1c00707f +#define MATCH_VLXHU_V 0xc005007 +#define MASK_VLXHU_V 0x1c00707f +#define MATCH_VLXWU_V 0xc006007 +#define MASK_VLXWU_V 0x1c00707f +#define MATCH_VSXB_V 0xc000027 +#define MASK_VSXB_V 0x1c00707f +#define MATCH_VSXH_V 0xc005027 +#define MASK_VSXH_V 0x1c00707f +#define MATCH_VSXW_V 0xc006027 +#define MASK_VSXW_V 0x1c00707f +#define MATCH_VSXE_V 0xc007027 +#define MASK_VSXE_V 0x1c00707f +#define MATCH_VSUXB_V 0x1c000027 +#define MASK_VSUXB_V 0xfc00707f +#define MATCH_VSUXH_V 0x1c005027 +#define MASK_VSUXH_V 0xfc00707f +#define MATCH_VSUXW_V 0x1c006027 +#define MASK_VSUXW_V 0xfc00707f +#define MATCH_VSUXE_V 0x1c007027 +#define MASK_VSUXE_V 0xfc00707f +#define MATCH_VLBFF_V 0x11000007 +#define MASK_VLBFF_V 0x1df0707f +#define MATCH_VLHFF_V 0x11005007 +#define MASK_VLHFF_V 0x1df0707f +#define MATCH_VLWFF_V 0x11006007 +#define MASK_VLWFF_V 0x1df0707f +#define MATCH_VLEFF_V 0x1007007 +#define MASK_VLEFF_V 0x1df0707f +#define MATCH_VLBUFF_V 0x1000007 +#define MASK_VLBUFF_V 0x1df0707f +#define MATCH_VLHUFF_V 0x1005007 +#define MASK_VLHUFF_V 0x1df0707f +#define MATCH_VLWUFF_V 0x1006007 +#define MASK_VLWUFF_V 0x1df0707f +#define MATCH_VL1R_V 0x2807007 +#define MASK_VL1R_V 0xfff0707f +#define MATCH_VS1R_V 0x2807027 +#define MASK_VS1R_V 0xfff0707f +#define MATCH_VFADD_VF 0x5057 +#define MASK_VFADD_VF 0xfc00707f +#define MATCH_VFSUB_VF 0x8005057 +#define MASK_VFSUB_VF 0xfc00707f +#define MATCH_VFMIN_VF 0x10005057 +#define MASK_VFMIN_VF 0xfc00707f +#define MATCH_VFMAX_VF 0x18005057 +#define MASK_VFMAX_VF 0xfc00707f +#define MATCH_VFSGNJ_VF 0x20005057 +#define MASK_VFSGNJ_VF 0xfc00707f +#define MATCH_VFSGNJN_VF 0x24005057 +#define MASK_VFSGNJN_VF 0xfc00707f +#define MATCH_VFSGNJX_VF 0x28005057 +#define MASK_VFSGNJX_VF 0xfc00707f +#define MATCH_VFSLIDE1UP_VF 0x38005057 +#define MASK_VFSLIDE1UP_VF 0xfc00707f +#define MATCH_VFSLIDE1DOWN_VF 0x3c005057 +#define MASK_VFSLIDE1DOWN_VF 0xfc00707f +#define MATCH_VFMV_S_F 0x42005057 +#define MASK_VFMV_S_F 0xfff0707f +#define MATCH_VFMERGE_VFM 0x5c005057 +#define MASK_VFMERGE_VFM 0xfe00707f +#define MATCH_VFMV_V_F 0x5e005057 +#define MASK_VFMV_V_F 0xfff0707f +#define MATCH_VMFEQ_VF 0x60005057 +#define MASK_VMFEQ_VF 0xfc00707f +#define MATCH_VMFLE_VF 0x64005057 +#define MASK_VMFLE_VF 0xfc00707f +#define MATCH_VMFLT_VF 0x6c005057 +#define MASK_VMFLT_VF 0xfc00707f +#define MATCH_VMFNE_VF 0x70005057 +#define MASK_VMFNE_VF 0xfc00707f +#define MATCH_VMFGT_VF 0x74005057 +#define MASK_VMFGT_VF 0xfc00707f +#define MATCH_VMFGE_VF 0x7c005057 +#define MASK_VMFGE_VF 0xfc00707f +#define MATCH_VFDIV_VF 0x80005057 +#define MASK_VFDIV_VF 0xfc00707f +#define MATCH_VFRDIV_VF 0x84005057 +#define MASK_VFRDIV_VF 0xfc00707f +#define MATCH_VFMUL_VF 0x90005057 +#define MASK_VFMUL_VF 0xfc00707f +#define MATCH_VFRSUB_VF 0x9c005057 +#define MASK_VFRSUB_VF 0xfc00707f +#define MATCH_VFMADD_VF 0xa0005057 +#define MASK_VFMADD_VF 0xfc00707f +#define MATCH_VFNMADD_VF 0xa4005057 +#define MASK_VFNMADD_VF 0xfc00707f +#define MATCH_VFMSUB_VF 0xa8005057 +#define MASK_VFMSUB_VF 0xfc00707f +#define MATCH_VFNMSUB_VF 0xac005057 +#define MASK_VFNMSUB_VF 0xfc00707f +#define MATCH_VFMACC_VF 0xb0005057 +#define MASK_VFMACC_VF 0xfc00707f +#define MATCH_VFNMACC_VF 0xb4005057 +#define MASK_VFNMACC_VF 0xfc00707f +#define MATCH_VFMSAC_VF 0xb8005057 +#define MASK_VFMSAC_VF 0xfc00707f +#define MATCH_VFNMSAC_VF 0xbc005057 +#define MASK_VFNMSAC_VF 0xfc00707f +#define MATCH_VFWADD_VF 0xc0005057 +#define MASK_VFWADD_VF 0xfc00707f +#define MATCH_VFWSUB_VF 0xc8005057 +#define MASK_VFWSUB_VF 0xfc00707f +#define MATCH_VFWADD_WF 0xd0005057 +#define MASK_VFWADD_WF 0xfc00707f +#define MATCH_VFWSUB_WF 0xd8005057 +#define MASK_VFWSUB_WF 0xfc00707f +#define MATCH_VFWMUL_VF 0xe0005057 +#define MASK_VFWMUL_VF 0xfc00707f +#define MATCH_VFWMACC_VF 0xf0005057 +#define MASK_VFWMACC_VF 0xfc00707f +#define MATCH_VFWNMACC_VF 0xf4005057 +#define MASK_VFWNMACC_VF 0xfc00707f +#define MATCH_VFWMSAC_VF 0xf8005057 +#define MASK_VFWMSAC_VF 0xfc00707f +#define MATCH_VFWNMSAC_VF 0xfc005057 +#define MASK_VFWNMSAC_VF 0xfc00707f +#define MATCH_VFADD_VV 0x1057 +#define MASK_VFADD_VV 0xfc00707f +#define MATCH_VFREDSUM_VS 0x4001057 +#define MASK_VFREDSUM_VS 0xfc00707f +#define MATCH_VFSUB_VV 0x8001057 +#define MASK_VFSUB_VV 0xfc00707f +#define MATCH_VFREDOSUM_VS 0xc001057 +#define MASK_VFREDOSUM_VS 0xfc00707f +#define MATCH_VFMIN_VV 0x10001057 +#define MASK_VFMIN_VV 0xfc00707f +#define MATCH_VFREDMIN_VS 0x14001057 +#define MASK_VFREDMIN_VS 0xfc00707f +#define MATCH_VFMAX_VV 0x18001057 +#define MASK_VFMAX_VV 0xfc00707f +#define MATCH_VFREDMAX_VS 0x1c001057 +#define MASK_VFREDMAX_VS 0xfc00707f +#define MATCH_VFSGNJ_VV 0x20001057 +#define MASK_VFSGNJ_VV 0xfc00707f +#define MATCH_VFSGNJN_VV 0x24001057 +#define MASK_VFSGNJN_VV 0xfc00707f +#define MATCH_VFSGNJX_VV 0x28001057 +#define MASK_VFSGNJX_VV 0xfc00707f +#define MATCH_VFMV_F_S 0x42001057 +#define MASK_VFMV_F_S 0xfe0ff07f +#define MATCH_VMFEQ_VV 0x60001057 +#define MASK_VMFEQ_VV 0xfc00707f +#define MATCH_VMFLE_VV 0x64001057 +#define MASK_VMFLE_VV 0xfc00707f +#define MATCH_VMFLT_VV 0x6c001057 +#define MASK_VMFLT_VV 0xfc00707f +#define MATCH_VMFNE_VV 0x70001057 +#define MASK_VMFNE_VV 0xfc00707f +#define MATCH_VFDIV_VV 0x80001057 +#define MASK_VFDIV_VV 0xfc00707f +#define MATCH_VFMUL_VV 0x90001057 +#define MASK_VFMUL_VV 0xfc00707f +#define MATCH_VFMADD_VV 0xa0001057 +#define MASK_VFMADD_VV 0xfc00707f +#define MATCH_VFNMADD_VV 0xa4001057 +#define MASK_VFNMADD_VV 0xfc00707f +#define MATCH_VFMSUB_VV 0xa8001057 +#define MASK_VFMSUB_VV 0xfc00707f +#define MATCH_VFNMSUB_VV 0xac001057 +#define MASK_VFNMSUB_VV 0xfc00707f +#define MATCH_VFMACC_VV 0xb0001057 +#define MASK_VFMACC_VV 0xfc00707f +#define MATCH_VFNMACC_VV 0xb4001057 +#define MASK_VFNMACC_VV 0xfc00707f +#define MATCH_VFMSAC_VV 0xb8001057 +#define MASK_VFMSAC_VV 0xfc00707f +#define MATCH_VFNMSAC_VV 0xbc001057 +#define MASK_VFNMSAC_VV 0xfc00707f +#define MATCH_VFCVT_XU_F_V 0x88001057 +#define MASK_VFCVT_XU_F_V 0xfc0ff07f +#define MATCH_VFCVT_X_F_V 0x88009057 +#define MASK_VFCVT_X_F_V 0xfc0ff07f +#define MATCH_VFCVT_F_XU_V 0x88011057 +#define MASK_VFCVT_F_XU_V 0xfc0ff07f +#define MATCH_VFCVT_F_X_V 0x88019057 +#define MASK_VFCVT_F_X_V 0xfc0ff07f +#define MATCH_VFCVT_RTZ_XU_F_V 0x88031057 +#define MASK_VFCVT_RTZ_XU_F_V 0xfc0ff07f +#define MATCH_VFCVT_RTZ_X_F_V 0x88039057 +#define MASK_VFCVT_RTZ_X_F_V 0xfc0ff07f +#define MATCH_VFWCVT_XU_F_V 0x88041057 +#define MASK_VFWCVT_XU_F_V 0xfc0ff07f +#define MATCH_VFWCVT_X_F_V 0x88049057 +#define MASK_VFWCVT_X_F_V 0xfc0ff07f +#define MATCH_VFWCVT_F_XU_V 0x88051057 +#define MASK_VFWCVT_F_XU_V 0xfc0ff07f +#define MATCH_VFWCVT_F_X_V 0x88059057 +#define MASK_VFWCVT_F_X_V 0xfc0ff07f +#define MATCH_VFWCVT_F_F_V 0x88061057 +#define MASK_VFWCVT_F_F_V 0xfc0ff07f +#define MATCH_VFWCVT_RTZ_XU_F_V 0x88071057 +#define MASK_VFWCVT_RTZ_XU_F_V 0xfc0ff07f +#define MATCH_VFWCVT_RTZ_X_F_V 0x88079057 +#define MASK_VFWCVT_RTZ_X_F_V 0xfc0ff07f +#define MATCH_VFNCVT_XU_F_W 0x88081057 +#define MASK_VFNCVT_XU_F_W 0xfc0ff07f +#define MATCH_VFNCVT_X_F_W 0x88089057 +#define MASK_VFNCVT_X_F_W 0xfc0ff07f +#define MATCH_VFNCVT_F_XU_W 0x88091057 +#define MASK_VFNCVT_F_XU_W 0xfc0ff07f +#define MATCH_VFNCVT_F_X_W 0x88099057 +#define MASK_VFNCVT_F_X_W 0xfc0ff07f +#define MATCH_VFNCVT_F_F_W 0x880a1057 +#define MASK_VFNCVT_F_F_W 0xfc0ff07f +#define MATCH_VFNCVT_ROD_F_F_W 0x880a9057 +#define MASK_VFNCVT_ROD_F_F_W 0xfc0ff07f +#define MATCH_VFNCVT_RTZ_XU_F_W 0x880b1057 +#define MASK_VFNCVT_RTZ_XU_F_W 0xfc0ff07f +#define MATCH_VFNCVT_RTZ_X_F_W 0x880b9057 +#define MASK_VFNCVT_RTZ_X_F_W 0xfc0ff07f +#define MATCH_VFSQRT_V 0x8c001057 +#define MASK_VFSQRT_V 0xfc0ff07f +#define MATCH_VFCLASS_V 0x8c081057 +#define MASK_VFCLASS_V 0xfc0ff07f +#define MATCH_VFWADD_VV 0xc0001057 +#define MASK_VFWADD_VV 0xfc00707f +#define MATCH_VFWREDSUM_VS 0xc4001057 +#define MASK_VFWREDSUM_VS 0xfc00707f +#define MATCH_VFWSUB_VV 0xc8001057 +#define MASK_VFWSUB_VV 0xfc00707f +#define MATCH_VFWREDOSUM_VS 0xcc001057 +#define MASK_VFWREDOSUM_VS 0xfc00707f +#define MATCH_VFWADD_WV 0xd0001057 +#define MASK_VFWADD_WV 0xfc00707f +#define MATCH_VFWSUB_WV 0xd8001057 +#define MASK_VFWSUB_WV 0xfc00707f +#define MATCH_VFWMUL_VV 0xe0001057 +#define MASK_VFWMUL_VV 0xfc00707f +#define MATCH_VFDOT_VV 0xe4001057 +#define MASK_VFDOT_VV 0xfc00707f +#define MATCH_VFWMACC_VV 0xf0001057 +#define MASK_VFWMACC_VV 0xfc00707f +#define MATCH_VFWNMACC_VV 0xf4001057 +#define MASK_VFWNMACC_VV 0xfc00707f +#define MATCH_VFWMSAC_VV 0xf8001057 +#define MASK_VFWMSAC_VV 0xfc00707f +#define MATCH_VFWNMSAC_VV 0xfc001057 +#define MASK_VFWNMSAC_VV 0xfc00707f +#define MATCH_VADD_VX 0x4057 +#define MASK_VADD_VX 0xfc00707f +#define MATCH_VSUB_VX 0x8004057 +#define MASK_VSUB_VX 0xfc00707f +#define MATCH_VRSUB_VX 0xc004057 +#define MASK_VRSUB_VX 0xfc00707f +#define MATCH_VMINU_VX 0x10004057 +#define MASK_VMINU_VX 0xfc00707f +#define MATCH_VMIN_VX 0x14004057 +#define MASK_VMIN_VX 0xfc00707f +#define MATCH_VMAXU_VX 0x18004057 +#define MASK_VMAXU_VX 0xfc00707f +#define MATCH_VMAX_VX 0x1c004057 +#define MASK_VMAX_VX 0xfc00707f +#define MATCH_VAND_VX 0x24004057 +#define MASK_VAND_VX 0xfc00707f +#define MATCH_VOR_VX 0x28004057 +#define MASK_VOR_VX 0xfc00707f +#define MATCH_VXOR_VX 0x2c004057 +#define MASK_VXOR_VX 0xfc00707f +#define MATCH_VRGATHER_VX 0x30004057 +#define MASK_VRGATHER_VX 0xfc00707f +#define MATCH_VSLIDEUP_VX 0x38004057 +#define MASK_VSLIDEUP_VX 0xfc00707f +#define MATCH_VSLIDEDOWN_VX 0x3c004057 +#define MASK_VSLIDEDOWN_VX 0xfc00707f +#define MATCH_VADC_VXM 0x40004057 +#define MASK_VADC_VXM 0xfe00707f +#define MATCH_VMADC_VXM 0x44004057 +#define MASK_VMADC_VXM 0xfc00707f +#define MATCH_VSBC_VXM 0x48004057 +#define MASK_VSBC_VXM 0xfe00707f +#define MATCH_VMSBC_VXM 0x4c004057 +#define MASK_VMSBC_VXM 0xfc00707f +#define MATCH_VMERGE_VXM 0x5c004057 +#define MASK_VMERGE_VXM 0xfe00707f +#define MATCH_VMV_V_X 0x5e004057 +#define MASK_VMV_V_X 0xfff0707f +#define MATCH_VMSEQ_VX 0x60004057 +#define MASK_VMSEQ_VX 0xfc00707f +#define MATCH_VMSNE_VX 0x64004057 +#define MASK_VMSNE_VX 0xfc00707f +#define MATCH_VMSLTU_VX 0x68004057 +#define MASK_VMSLTU_VX 0xfc00707f +#define MATCH_VMSLT_VX 0x6c004057 +#define MASK_VMSLT_VX 0xfc00707f +#define MATCH_VMSLEU_VX 0x70004057 +#define MASK_VMSLEU_VX 0xfc00707f +#define MATCH_VMSLE_VX 0x74004057 +#define MASK_VMSLE_VX 0xfc00707f +#define MATCH_VMSGTU_VX 0x78004057 +#define MASK_VMSGTU_VX 0xfc00707f +#define MATCH_VMSGT_VX 0x7c004057 +#define MASK_VMSGT_VX 0xfc00707f +#define MATCH_VSADDU_VX 0x80004057 +#define MASK_VSADDU_VX 0xfc00707f +#define MATCH_VSADD_VX 0x84004057 +#define MASK_VSADD_VX 0xfc00707f +#define MATCH_VSSUBU_VX 0x88004057 +#define MASK_VSSUBU_VX 0xfc00707f +#define MATCH_VSSUB_VX 0x8c004057 +#define MASK_VSSUB_VX 0xfc00707f +#define MATCH_VSLL_VX 0x94004057 +#define MASK_VSLL_VX 0xfc00707f +#define MATCH_VSMUL_VX 0x9c004057 +#define MASK_VSMUL_VX 0xfc00707f +#define MATCH_VSRL_VX 0xa0004057 +#define MASK_VSRL_VX 0xfc00707f +#define MATCH_VSRA_VX 0xa4004057 +#define MASK_VSRA_VX 0xfc00707f +#define MATCH_VSSRL_VX 0xa8004057 +#define MASK_VSSRL_VX 0xfc00707f +#define MATCH_VSSRA_VX 0xac004057 +#define MASK_VSSRA_VX 0xfc00707f +#define MATCH_VNSRL_WX 0xb0004057 +#define MASK_VNSRL_WX 0xfc00707f +#define MATCH_VNSRA_WX 0xb4004057 +#define MASK_VNSRA_WX 0xfc00707f +#define MATCH_VNCLIPU_WX 0xb8004057 +#define MASK_VNCLIPU_WX 0xfc00707f +#define MATCH_VNCLIP_WX 0xbc004057 +#define MASK_VNCLIP_WX 0xfc00707f +#define MATCH_VQMACCU_VX 0xf0004057 +#define MASK_VQMACCU_VX 0xfc00707f +#define MATCH_VQMACC_VX 0xf4004057 +#define MASK_VQMACC_VX 0xfc00707f +#define MATCH_VQMACCUS_VX 0xf8004057 +#define MASK_VQMACCUS_VX 0xfc00707f +#define MATCH_VQMACCSU_VX 0xfc004057 +#define MASK_VQMACCSU_VX 0xfc00707f +#define MATCH_VADD_VV 0x57 +#define MASK_VADD_VV 0xfc00707f +#define MATCH_VSUB_VV 0x8000057 +#define MASK_VSUB_VV 0xfc00707f +#define MATCH_VMINU_VV 0x10000057 +#define MASK_VMINU_VV 0xfc00707f +#define MATCH_VMIN_VV 0x14000057 +#define MASK_VMIN_VV 0xfc00707f +#define MATCH_VMAXU_VV 0x18000057 +#define MASK_VMAXU_VV 0xfc00707f +#define MATCH_VMAX_VV 0x1c000057 +#define MASK_VMAX_VV 0xfc00707f +#define MATCH_VAND_VV 0x24000057 +#define MASK_VAND_VV 0xfc00707f +#define MATCH_VOR_VV 0x28000057 +#define MASK_VOR_VV 0xfc00707f +#define MATCH_VXOR_VV 0x2c000057 +#define MASK_VXOR_VV 0xfc00707f +#define MATCH_VRGATHER_VV 0x30000057 +#define MASK_VRGATHER_VV 0xfc00707f +#define MATCH_VADC_VVM 0x40000057 +#define MASK_VADC_VVM 0xfe00707f +#define MATCH_VMADC_VVM 0x44000057 +#define MASK_VMADC_VVM 0xfc00707f +#define MATCH_VSBC_VVM 0x48000057 +#define MASK_VSBC_VVM 0xfe00707f +#define MATCH_VMSBC_VVM 0x4c000057 +#define MASK_VMSBC_VVM 0xfc00707f +#define MATCH_VMERGE_VVM 0x5c000057 +#define MASK_VMERGE_VVM 0xfe00707f +#define MATCH_VMV_V_V 0x5e000057 +#define MASK_VMV_V_V 0xfff0707f +#define MATCH_VMSEQ_VV 0x60000057 +#define MASK_VMSEQ_VV 0xfc00707f +#define MATCH_VMSNE_VV 0x64000057 +#define MASK_VMSNE_VV 0xfc00707f +#define MATCH_VMSLTU_VV 0x68000057 +#define MASK_VMSLTU_VV 0xfc00707f +#define MATCH_VMSLT_VV 0x6c000057 +#define MASK_VMSLT_VV 0xfc00707f +#define MATCH_VMSLEU_VV 0x70000057 +#define MASK_VMSLEU_VV 0xfc00707f +#define MATCH_VMSLE_VV 0x74000057 +#define MASK_VMSLE_VV 0xfc00707f +#define MATCH_VSADDU_VV 0x80000057 +#define MASK_VSADDU_VV 0xfc00707f +#define MATCH_VSADD_VV 0x84000057 +#define MASK_VSADD_VV 0xfc00707f +#define MATCH_VSSUBU_VV 0x88000057 +#define MASK_VSSUBU_VV 0xfc00707f +#define MATCH_VSSUB_VV 0x8c000057 +#define MASK_VSSUB_VV 0xfc00707f +#define MATCH_VSLL_VV 0x94000057 +#define MASK_VSLL_VV 0xfc00707f +#define MATCH_VSMUL_VV 0x9c000057 +#define MASK_VSMUL_VV 0xfc00707f +#define MATCH_VSRL_VV 0xa0000057 +#define MASK_VSRL_VV 0xfc00707f +#define MATCH_VSRA_VV 0xa4000057 +#define MASK_VSRA_VV 0xfc00707f +#define MATCH_VSSRL_VV 0xa8000057 +#define MASK_VSSRL_VV 0xfc00707f +#define MATCH_VSSRA_VV 0xac000057 +#define MASK_VSSRA_VV 0xfc00707f +#define MATCH_VNSRL_WV 0xb0000057 +#define MASK_VNSRL_WV 0xfc00707f +#define MATCH_VNSRA_WV 0xb4000057 +#define MASK_VNSRA_WV 0xfc00707f +#define MATCH_VNCLIPU_WV 0xb8000057 +#define MASK_VNCLIPU_WV 0xfc00707f +#define MATCH_VNCLIP_WV 0xbc000057 +#define MASK_VNCLIP_WV 0xfc00707f +#define MATCH_VWREDSUMU_VS 0xc0000057 +#define MASK_VWREDSUMU_VS 0xfc00707f +#define MATCH_VWREDSUM_VS 0xc4000057 +#define MASK_VWREDSUM_VS 0xfc00707f +#define MATCH_VDOTU_VV 0xe0000057 +#define MASK_VDOTU_VV 0xfc00707f +#define MATCH_VDOT_VV 0xe4000057 +#define MASK_VDOT_VV 0xfc00707f +#define MATCH_VQMACCU_VV 0xf0000057 +#define MASK_VQMACCU_VV 0xfc00707f +#define MATCH_VQMACC_VV 0xf4000057 +#define MASK_VQMACC_VV 0xfc00707f +#define MATCH_VQMACCSU_VV 0xfc000057 +#define MASK_VQMACCSU_VV 0xfc00707f +#define MATCH_VADD_VI 0x3057 +#define MASK_VADD_VI 0xfc00707f +#define MATCH_VRSUB_VI 0xc003057 +#define MASK_VRSUB_VI 0xfc00707f +#define MATCH_VAND_VI 0x24003057 +#define MASK_VAND_VI 0xfc00707f +#define MATCH_VOR_VI 0x28003057 +#define MASK_VOR_VI 0xfc00707f +#define MATCH_VXOR_VI 0x2c003057 +#define MASK_VXOR_VI 0xfc00707f +#define MATCH_VRGATHER_VI 0x30003057 +#define MASK_VRGATHER_VI 0xfc00707f +#define MATCH_VSLIDEUP_VI 0x38003057 +#define MASK_VSLIDEUP_VI 0xfc00707f +#define MATCH_VSLIDEDOWN_VI 0x3c003057 +#define MASK_VSLIDEDOWN_VI 0xfc00707f +#define MATCH_VADC_VIM 0x40003057 +#define MASK_VADC_VIM 0xfe00707f +#define MATCH_VMADC_VIM 0x44003057 +#define MASK_VMADC_VIM 0xfc00707f +#define MATCH_VMERGE_VIM 0x5c003057 +#define MASK_VMERGE_VIM 0xfe00707f +#define MATCH_VMV_V_I 0x5e003057 +#define MASK_VMV_V_I 0xfff0707f +#define MATCH_VMSEQ_VI 0x60003057 +#define MASK_VMSEQ_VI 0xfc00707f +#define MATCH_VMSNE_VI 0x64003057 +#define MASK_VMSNE_VI 0xfc00707f +#define MATCH_VMSLEU_VI 0x70003057 +#define MASK_VMSLEU_VI 0xfc00707f +#define MATCH_VMSLE_VI 0x74003057 +#define MASK_VMSLE_VI 0xfc00707f +#define MATCH_VMSGTU_VI 0x78003057 +#define MASK_VMSGTU_VI 0xfc00707f +#define MATCH_VMSGT_VI 0x7c003057 +#define MASK_VMSGT_VI 0xfc00707f +#define MATCH_VSADDU_VI 0x80003057 +#define MASK_VSADDU_VI 0xfc00707f +#define MATCH_VSADD_VI 0x84003057 +#define MASK_VSADD_VI 0xfc00707f +#define MATCH_VSLL_VI 0x94003057 +#define MASK_VSLL_VI 0xfc00707f +#define MATCH_VMV1R_V 0x9e003057 +#define MASK_VMV1R_V 0xfe0ff07f +#define MATCH_VMV2R_V 0x9e00b057 +#define MASK_VMV2R_V 0xfe0ff07f +#define MATCH_VMV4R_V 0x9e01b057 +#define MASK_VMV4R_V 0xfe0ff07f +#define MATCH_VMV8R_V 0x9e03b057 +#define MASK_VMV8R_V 0xfe0ff07f +#define MATCH_VSRL_VI 0xa0003057 +#define MASK_VSRL_VI 0xfc00707f +#define MATCH_VSRA_VI 0xa4003057 +#define MASK_VSRA_VI 0xfc00707f +#define MATCH_VSSRL_VI 0xa8003057 +#define MASK_VSSRL_VI 0xfc00707f +#define MATCH_VSSRA_VI 0xac003057 +#define MASK_VSSRA_VI 0xfc00707f +#define MATCH_VNSRL_WI 0xb0003057 +#define MASK_VNSRL_WI 0xfc00707f +#define MATCH_VNSRA_WI 0xb4003057 +#define MASK_VNSRA_WI 0xfc00707f +#define MATCH_VNCLIPU_WI 0xb8003057 +#define MASK_VNCLIPU_WI 0xfc00707f +#define MATCH_VNCLIP_WI 0xbc003057 +#define MASK_VNCLIP_WI 0xfc00707f +#define MATCH_VREDSUM_VS 0x2057 +#define MASK_VREDSUM_VS 0xfc00707f +#define MATCH_VREDAND_VS 0x4002057 +#define MASK_VREDAND_VS 0xfc00707f +#define MATCH_VREDOR_VS 0x8002057 +#define MASK_VREDOR_VS 0xfc00707f +#define MATCH_VREDXOR_VS 0xc002057 +#define MASK_VREDXOR_VS 0xfc00707f +#define MATCH_VREDMINU_VS 0x10002057 +#define MASK_VREDMINU_VS 0xfc00707f +#define MATCH_VREDMIN_VS 0x14002057 +#define MASK_VREDMIN_VS 0xfc00707f +#define MATCH_VREDMAXU_VS 0x18002057 +#define MASK_VREDMAXU_VS 0xfc00707f +#define MATCH_VREDMAX_VS 0x1c002057 +#define MASK_VREDMAX_VS 0xfc00707f +#define MATCH_VAADDU_VV 0x20002057 +#define MASK_VAADDU_VV 0xfc00707f +#define MATCH_VAADD_VV 0x24002057 +#define MASK_VAADD_VV 0xfc00707f +#define MATCH_VASUBU_VV 0x28002057 +#define MASK_VASUBU_VV 0xfc00707f +#define MATCH_VASUB_VV 0x2c002057 +#define MASK_VASUB_VV 0xfc00707f +#define MATCH_VMV_X_S 0x42002057 +#define MASK_VMV_X_S 0xfe0ff07f +#define MATCH_VCOMPRESS_VM 0x5e002057 +#define MASK_VCOMPRESS_VM 0xfe00707f +#define MATCH_VMANDNOT_MM 0x60002057 +#define MASK_VMANDNOT_MM 0xfc00707f +#define MATCH_VMAND_MM 0x64002057 +#define MASK_VMAND_MM 0xfc00707f +#define MATCH_VMOR_MM 0x68002057 +#define MASK_VMOR_MM 0xfc00707f +#define MATCH_VMXOR_MM 0x6c002057 +#define MASK_VMXOR_MM 0xfc00707f +#define MATCH_VMORNOT_MM 0x70002057 +#define MASK_VMORNOT_MM 0xfc00707f +#define MATCH_VMNAND_MM 0x74002057 +#define MASK_VMNAND_MM 0xfc00707f +#define MATCH_VMNOR_MM 0x78002057 +#define MASK_VMNOR_MM 0xfc00707f +#define MATCH_VMXNOR_MM 0x7c002057 +#define MASK_VMXNOR_MM 0xfc00707f +#define MATCH_VMSBF_M 0x5000a057 +#define MASK_VMSBF_M 0xfc0ff07f +#define MATCH_VMSOF_M 0x50012057 +#define MASK_VMSOF_M 0xfc0ff07f +#define MATCH_VMSIF_M 0x5001a057 +#define MASK_VMSIF_M 0xfc0ff07f +#define MATCH_VIOTA_M 0x50082057 +#define MASK_VIOTA_M 0xfc0ff07f +#define MATCH_VID_V 0x5008a057 +#define MASK_VID_V 0xfdfff07f +#define MATCH_VPOPC_M 0x40082057 +#define MASK_VPOPC_M 0xfc0ff07f +#define MATCH_VFIRST_M 0x4008a057 +#define MASK_VFIRST_M 0xfc0ff07f +#define MATCH_VDIVU_VV 0x80002057 +#define MASK_VDIVU_VV 0xfc00707f +#define MATCH_VDIV_VV 0x84002057 +#define MASK_VDIV_VV 0xfc00707f +#define MATCH_VREMU_VV 0x88002057 +#define MASK_VREMU_VV 0xfc00707f +#define MATCH_VREM_VV 0x8c002057 +#define MASK_VREM_VV 0xfc00707f +#define MATCH_VMULHU_VV 0x90002057 +#define MASK_VMULHU_VV 0xfc00707f +#define MATCH_VMUL_VV 0x94002057 +#define MASK_VMUL_VV 0xfc00707f +#define MATCH_VMULHSU_VV 0x98002057 +#define MASK_VMULHSU_VV 0xfc00707f +#define MATCH_VMULH_VV 0x9c002057 +#define MASK_VMULH_VV 0xfc00707f +#define MATCH_VMADD_VV 0xa4002057 +#define MASK_VMADD_VV 0xfc00707f +#define MATCH_VNMSUB_VV 0xac002057 +#define MASK_VNMSUB_VV 0xfc00707f +#define MATCH_VMACC_VV 0xb4002057 +#define MASK_VMACC_VV 0xfc00707f +#define MATCH_VNMSAC_VV 0xbc002057 +#define MASK_VNMSAC_VV 0xfc00707f +#define MATCH_VWADDU_VV 0xc0002057 +#define MASK_VWADDU_VV 0xfc00707f +#define MATCH_VWADD_VV 0xc4002057 +#define MASK_VWADD_VV 0xfc00707f +#define MATCH_VWSUBU_VV 0xc8002057 +#define MASK_VWSUBU_VV 0xfc00707f +#define MATCH_VWSUB_VV 0xcc002057 +#define MASK_VWSUB_VV 0xfc00707f +#define MATCH_VWADDU_WV 0xd0002057 +#define MASK_VWADDU_WV 0xfc00707f +#define MATCH_VWADD_WV 0xd4002057 +#define MASK_VWADD_WV 0xfc00707f +#define MATCH_VWSUBU_WV 0xd8002057 +#define MASK_VWSUBU_WV 0xfc00707f +#define MATCH_VWSUB_WV 0xdc002057 +#define MASK_VWSUB_WV 0xfc00707f +#define MATCH_VWMULU_VV 0xe0002057 +#define MASK_VWMULU_VV 0xfc00707f +#define MATCH_VWMULSU_VV 0xe8002057 +#define MASK_VWMULSU_VV 0xfc00707f +#define MATCH_VWMUL_VV 0xec002057 +#define MASK_VWMUL_VV 0xfc00707f +#define MATCH_VWMACCU_VV 0xf0002057 +#define MASK_VWMACCU_VV 0xfc00707f +#define MATCH_VWMACC_VV 0xf4002057 +#define MASK_VWMACC_VV 0xfc00707f +#define MATCH_VWMACCSU_VV 0xfc002057 +#define MASK_VWMACCSU_VV 0xfc00707f +#define MATCH_VAADDU_VX 0x20006057 +#define MASK_VAADDU_VX 0xfc00707f +#define MATCH_VAADD_VX 0x24006057 +#define MASK_VAADD_VX 0xfc00707f +#define MATCH_VASUBU_VX 0x28006057 +#define MASK_VASUBU_VX 0xfc00707f +#define MATCH_VASUB_VX 0x2c006057 +#define MASK_VASUB_VX 0xfc00707f +#define MATCH_VMV_S_X 0x42006057 +#define MASK_VMV_S_X 0xfff0707f +#define MATCH_VSLIDE1UP_VX 0x38006057 +#define MASK_VSLIDE1UP_VX 0xfc00707f +#define MATCH_VSLIDE1DOWN_VX 0x3c006057 +#define MASK_VSLIDE1DOWN_VX 0xfc00707f +#define MATCH_VDIVU_VX 0x80006057 +#define MASK_VDIVU_VX 0xfc00707f +#define MATCH_VDIV_VX 0x84006057 +#define MASK_VDIV_VX 0xfc00707f +#define MATCH_VREMU_VX 0x88006057 +#define MASK_VREMU_VX 0xfc00707f +#define MATCH_VREM_VX 0x8c006057 +#define MASK_VREM_VX 0xfc00707f +#define MATCH_VMULHU_VX 0x90006057 +#define MASK_VMULHU_VX 0xfc00707f +#define MATCH_VMUL_VX 0x94006057 +#define MASK_VMUL_VX 0xfc00707f +#define MATCH_VMULHSU_VX 0x98006057 +#define MASK_VMULHSU_VX 0xfc00707f +#define MATCH_VMULH_VX 0x9c006057 +#define MASK_VMULH_VX 0xfc00707f +#define MATCH_VMADD_VX 0xa4006057 +#define MASK_VMADD_VX 0xfc00707f +#define MATCH_VNMSUB_VX 0xac006057 +#define MASK_VNMSUB_VX 0xfc00707f +#define MATCH_VMACC_VX 0xb4006057 +#define MASK_VMACC_VX 0xfc00707f +#define MATCH_VNMSAC_VX 0xbc006057 +#define MASK_VNMSAC_VX 0xfc00707f +#define MATCH_VWADDU_VX 0xc0006057 +#define MASK_VWADDU_VX 0xfc00707f +#define MATCH_VWADD_VX 0xc4006057 +#define MASK_VWADD_VX 0xfc00707f +#define MATCH_VWSUBU_VX 0xc8006057 +#define MASK_VWSUBU_VX 0xfc00707f +#define MATCH_VWSUB_VX 0xcc006057 +#define MASK_VWSUB_VX 0xfc00707f +#define MATCH_VWADDU_WX 0xd0006057 +#define MASK_VWADDU_WX 0xfc00707f +#define MATCH_VWADD_WX 0xd4006057 +#define MASK_VWADD_WX 0xfc00707f +#define MATCH_VWSUBU_WX 0xd8006057 +#define MASK_VWSUBU_WX 0xfc00707f +#define MATCH_VWSUB_WX 0xdc006057 +#define MASK_VWSUB_WX 0xfc00707f +#define MATCH_VWMULU_VX 0xe0006057 +#define MASK_VWMULU_VX 0xfc00707f +#define MATCH_VWMULSU_VX 0xe8006057 +#define MASK_VWMULSU_VX 0xfc00707f +#define MATCH_VWMUL_VX 0xec006057 +#define MASK_VWMUL_VX 0xfc00707f +#define MATCH_VWMACCU_VX 0xf0006057 +#define MASK_VWMACCU_VX 0xfc00707f +#define MATCH_VWMACC_VX 0xf4006057 +#define MASK_VWMACC_VX 0xfc00707f +#define MATCH_VWMACCUS_VX 0xf8006057 +#define MASK_VWMACCUS_VX 0xfc00707f +#define MATCH_VWMACCSU_VX 0xfc006057 +#define MASK_VWMACCSU_VX 0xfc00707f +#define MATCH_VAMOSWAPW_V 0x800602f +#define MASK_VAMOSWAPW_V 0xf800707f +#define MATCH_VAMOADDW_V 0x602f +#define MASK_VAMOADDW_V 0xf800707f +#define MATCH_VAMOXORW_V 0x2000602f +#define MASK_VAMOXORW_V 0xf800707f +#define MATCH_VAMOANDW_V 0x6000602f +#define MASK_VAMOANDW_V 0xf800707f +#define MATCH_VAMOORW_V 0x4000602f +#define MASK_VAMOORW_V 0xf800707f +#define MATCH_VAMOMINW_V 0x8000602f +#define MASK_VAMOMINW_V 0xf800707f +#define MATCH_VAMOMAXW_V 0xa000602f +#define MASK_VAMOMAXW_V 0xf800707f +#define MATCH_VAMOMINUW_V 0xc000602f +#define MASK_VAMOMINUW_V 0xf800707f +#define MATCH_VAMOMAXUW_V 0xe000602f +#define MASK_VAMOMAXUW_V 0xf800707f +#define MATCH_VAMOSWAPE_V 0x800702f +#define MASK_VAMOSWAPE_V 0xf800707f +#define MATCH_VAMOADDE_V 0x702f +#define MASK_VAMOADDE_V 0xf800707f +#define MATCH_VAMOXORE_V 0x2000702f +#define MASK_VAMOXORE_V 0xf800707f +#define MATCH_VAMOANDE_V 0x6000702f +#define MASK_VAMOANDE_V 0xf800707f +#define MATCH_VAMOORE_V 0x4000702f +#define MASK_VAMOORE_V 0xf800707f +#define MATCH_VAMOMINE_V 0x8000702f +#define MASK_VAMOMINE_V 0xf800707f +#define MATCH_VAMOMAXE_V 0xa000702f +#define MASK_VAMOMAXE_V 0xf800707f +#define MATCH_VAMOMINUE_V 0xc000702f +#define MASK_VAMOMINUE_V 0xf800707f +#define MATCH_VAMOMAXUE_V 0xe000702f +#define MASK_VAMOMAXUE_V 0xf800707f +#define MATCH_VMVNFR_V 0x9e003057 +#define MASK_VMVNFR_V 0xfe00707f +#define CSR_FFLAGS 0x1 +#define CSR_FRM 0x2 +#define CSR_FCSR 0x3 +#define CSR_USTATUS 0x0 +#define CSR_UIE 0x4 +#define CSR_UTVEC 0x5 +#define CSR_VSTART 0x8 +#define CSR_VXSAT 0x9 +#define CSR_VXRM 0xa +#define CSR_VCSR 0xf +#define CSR_USCRATCH 0x40 +#define CSR_UEPC 0x41 +#define CSR_UCAUSE 0x42 +#define CSR_UTVAL 0x43 +#define CSR_UIP 0x44 +#define CSR_CYCLE 0xc00 +#define CSR_TIME 0xc01 +#define CSR_INSTRET 0xc02 +#define CSR_HPMCOUNTER3 0xc03 +#define CSR_HPMCOUNTER4 0xc04 +#define CSR_HPMCOUNTER5 0xc05 +#define CSR_HPMCOUNTER6 0xc06 +#define CSR_HPMCOUNTER7 0xc07 +#define CSR_HPMCOUNTER8 0xc08 +#define CSR_HPMCOUNTER9 0xc09 +#define CSR_HPMCOUNTER10 0xc0a +#define CSR_HPMCOUNTER11 0xc0b +#define CSR_HPMCOUNTER12 0xc0c +#define CSR_HPMCOUNTER13 0xc0d +#define CSR_HPMCOUNTER14 0xc0e +#define CSR_HPMCOUNTER15 0xc0f +#define CSR_HPMCOUNTER16 0xc10 +#define CSR_HPMCOUNTER17 0xc11 +#define CSR_HPMCOUNTER18 0xc12 +#define CSR_HPMCOUNTER19 0xc13 +#define CSR_HPMCOUNTER20 0xc14 +#define CSR_HPMCOUNTER21 0xc15 +#define CSR_HPMCOUNTER22 0xc16 +#define CSR_HPMCOUNTER23 0xc17 +#define CSR_HPMCOUNTER24 0xc18 +#define CSR_HPMCOUNTER25 0xc19 +#define CSR_HPMCOUNTER26 0xc1a +#define CSR_HPMCOUNTER27 0xc1b +#define CSR_HPMCOUNTER28 0xc1c +#define CSR_HPMCOUNTER29 0xc1d +#define CSR_HPMCOUNTER30 0xc1e +#define CSR_HPMCOUNTER31 0xc1f +#define CSR_VL 0xc20 +#define CSR_VTYPE 0xc21 +#define CSR_VLENB 0xc22 +#define CSR_SSTATUS 0x100 +#define CSR_SEDELEG 0x102 +#define CSR_SIDELEG 0x103 +#define CSR_SIE 0x104 +#define CSR_STVEC 0x105 +#define CSR_SCOUNTEREN 0x106 +#define CSR_SSCRATCH 0x140 +#define CSR_SEPC 0x141 +#define CSR_SCAUSE 0x142 +#define CSR_STVAL 0x143 +#define CSR_SIP 0x144 +#define CSR_SATP 0x180 +#define CSR_VSSTATUS 0x200 +#define CSR_VSIE 0x204 +#define CSR_VSTVEC 0x205 +#define CSR_VSSCRATCH 0x240 +#define CSR_VSEPC 0x241 +#define CSR_VSCAUSE 0x242 +#define CSR_VSTVAL 0x243 +#define CSR_VSIP 0x244 +#define CSR_VSATP 0x280 +#define CSR_HSTATUS 0x600 +#define CSR_HEDELEG 0x602 +#define CSR_HIDELEG 0x603 +#define CSR_HIE 0x604 +#define CSR_HTIMEDELTA 0x605 +#define CSR_HCOUNTEREN 0x606 +#define CSR_HGEIE 0x607 +#define CSR_HTVAL 0x643 +#define CSR_HIP 0x644 +#define CSR_HVIP 0x645 +#define CSR_HTINST 0x64a +#define CSR_HGATP 0x680 +#define CSR_HGEIP 0xe12 +#define CSR_UTVT 0x7 +#define CSR_UNXTI 0x45 +#define CSR_UINTSTATUS 0x46 +#define CSR_USCRATCHCSW 0x48 +#define CSR_USCRATCHCSWL 0x49 +#define CSR_STVT 0x107 +#define CSR_SNXTI 0x145 +#define CSR_SINTSTATUS 0x146 +#define CSR_SSCRATCHCSW 0x148 +#define CSR_SSCRATCHCSWL 0x149 +#define CSR_MTVT 0x307 +#define CSR_MNXTI 0x345 +#define CSR_MINTSTATUS 0x346 +#define CSR_MSCRATCHCSW 0x348 +#define CSR_MSCRATCHCSWL 0x349 +#define CSR_MSTATUS 0x300 +#define CSR_MISA 0x301 +#define CSR_MEDELEG 0x302 +#define CSR_MIDELEG 0x303 +#define CSR_MIE 0x304 +#define CSR_MTVEC 0x305 +#define CSR_MCOUNTEREN 0x306 +#define CSR_MCOUNTINHIBIT 0x320 +#define CSR_MSCRATCH 0x340 +#define CSR_MEPC 0x341 +#define CSR_MCAUSE 0x342 +#define CSR_MTVAL 0x343 +#define CSR_MIP 0x344 +#define CSR_MTINST 0x34a +#define CSR_MTVAL2 0x34b +#define CSR_PMPCFG0 0x3a0 +#define CSR_PMPCFG1 0x3a1 +#define CSR_PMPCFG2 0x3a2 +#define CSR_PMPCFG3 0x3a3 +#define CSR_PMPADDR0 0x3b0 +#define CSR_PMPADDR1 0x3b1 +#define CSR_PMPADDR2 0x3b2 +#define CSR_PMPADDR3 0x3b3 +#define CSR_PMPADDR4 0x3b4 +#define CSR_PMPADDR5 0x3b5 +#define CSR_PMPADDR6 0x3b6 +#define CSR_PMPADDR7 0x3b7 +#define CSR_PMPADDR8 0x3b8 +#define CSR_PMPADDR9 0x3b9 +#define CSR_PMPADDR10 0x3ba +#define CSR_PMPADDR11 0x3bb +#define CSR_PMPADDR12 0x3bc +#define CSR_PMPADDR13 0x3bd +#define CSR_PMPADDR14 0x3be +#define CSR_PMPADDR15 0x3bf +#define CSR_TSELECT 0x7a0 +#define CSR_TDATA1 0x7a1 +#define CSR_TDATA2 0x7a2 +#define CSR_TDATA3 0x7a3 +#define CSR_DCSR 0x7b0 +#define CSR_DPC 0x7b1 +#define CSR_DSCRATCH0 0x7b2 +#define CSR_DSCRATCH1 0x7b3 +#define CSR_MCYCLE 0xb00 +#define CSR_MINSTRET 0xb02 +#define CSR_MHPMCOUNTER3 0xb03 +#define CSR_MHPMCOUNTER4 0xb04 +#define CSR_MHPMCOUNTER5 0xb05 +#define CSR_MHPMCOUNTER6 0xb06 +#define CSR_MHPMCOUNTER7 0xb07 +#define CSR_MHPMCOUNTER8 0xb08 +#define CSR_MHPMCOUNTER9 0xb09 +#define CSR_MHPMCOUNTER10 0xb0a +#define CSR_MHPMCOUNTER11 0xb0b +#define CSR_MHPMCOUNTER12 0xb0c +#define CSR_MHPMCOUNTER13 0xb0d +#define CSR_MHPMCOUNTER14 0xb0e +#define CSR_MHPMCOUNTER15 0xb0f +#define CSR_MHPMCOUNTER16 0xb10 +#define CSR_MHPMCOUNTER17 0xb11 +#define CSR_MHPMCOUNTER18 0xb12 +#define CSR_MHPMCOUNTER19 0xb13 +#define CSR_MHPMCOUNTER20 0xb14 +#define CSR_MHPMCOUNTER21 0xb15 +#define CSR_MHPMCOUNTER22 0xb16 +#define CSR_MHPMCOUNTER23 0xb17 +#define CSR_MHPMCOUNTER24 0xb18 +#define CSR_MHPMCOUNTER25 0xb19 +#define CSR_MHPMCOUNTER26 0xb1a +#define CSR_MHPMCOUNTER27 0xb1b +#define CSR_MHPMCOUNTER28 0xb1c +#define CSR_MHPMCOUNTER29 0xb1d +#define CSR_MHPMCOUNTER30 0xb1e +#define CSR_MHPMCOUNTER31 0xb1f +#define CSR_MHPMEVENT3 0x323 +#define CSR_MHPMEVENT4 0x324 +#define CSR_MHPMEVENT5 0x325 +#define CSR_MHPMEVENT6 0x326 +#define CSR_MHPMEVENT7 0x327 +#define CSR_MHPMEVENT8 0x328 +#define CSR_MHPMEVENT9 0x329 +#define CSR_MHPMEVENT10 0x32a +#define CSR_MHPMEVENT11 0x32b +#define CSR_MHPMEVENT12 0x32c +#define CSR_MHPMEVENT13 0x32d +#define CSR_MHPMEVENT14 0x32e +#define CSR_MHPMEVENT15 0x32f +#define CSR_MHPMEVENT16 0x330 +#define CSR_MHPMEVENT17 0x331 +#define CSR_MHPMEVENT18 0x332 +#define CSR_MHPMEVENT19 0x333 +#define CSR_MHPMEVENT20 0x334 +#define CSR_MHPMEVENT21 0x335 +#define CSR_MHPMEVENT22 0x336 +#define CSR_MHPMEVENT23 0x337 +#define CSR_MHPMEVENT24 0x338 +#define CSR_MHPMEVENT25 0x339 +#define CSR_MHPMEVENT26 0x33a +#define CSR_MHPMEVENT27 0x33b +#define CSR_MHPMEVENT28 0x33c +#define CSR_MHPMEVENT29 0x33d +#define CSR_MHPMEVENT30 0x33e +#define CSR_MHPMEVENT31 0x33f +#define CSR_MVENDORID 0xf11 +#define CSR_MARCHID 0xf12 +#define CSR_MIMPID 0xf13 +#define CSR_MHARTID 0xf14 +#define CSR_HTIMEDELTAH 0x615 +#define CSR_CYCLEH 0xc80 +#define CSR_TIMEH 0xc81 +#define CSR_INSTRETH 0xc82 +#define CSR_HPMCOUNTER3H 0xc83 +#define CSR_HPMCOUNTER4H 0xc84 +#define CSR_HPMCOUNTER5H 0xc85 +#define CSR_HPMCOUNTER6H 0xc86 +#define CSR_HPMCOUNTER7H 0xc87 +#define CSR_HPMCOUNTER8H 0xc88 +#define CSR_HPMCOUNTER9H 0xc89 +#define CSR_HPMCOUNTER10H 0xc8a +#define CSR_HPMCOUNTER11H 0xc8b +#define CSR_HPMCOUNTER12H 0xc8c +#define CSR_HPMCOUNTER13H 0xc8d +#define CSR_HPMCOUNTER14H 0xc8e +#define CSR_HPMCOUNTER15H 0xc8f +#define CSR_HPMCOUNTER16H 0xc90 +#define CSR_HPMCOUNTER17H 0xc91 +#define CSR_HPMCOUNTER18H 0xc92 +#define CSR_HPMCOUNTER19H 0xc93 +#define CSR_HPMCOUNTER20H 0xc94 +#define CSR_HPMCOUNTER21H 0xc95 +#define CSR_HPMCOUNTER22H 0xc96 +#define CSR_HPMCOUNTER23H 0xc97 +#define CSR_HPMCOUNTER24H 0xc98 +#define CSR_HPMCOUNTER25H 0xc99 +#define CSR_HPMCOUNTER26H 0xc9a +#define CSR_HPMCOUNTER27H 0xc9b +#define CSR_HPMCOUNTER28H 0xc9c +#define CSR_HPMCOUNTER29H 0xc9d +#define CSR_HPMCOUNTER30H 0xc9e +#define CSR_HPMCOUNTER31H 0xc9f +#define CSR_MSTATUSH 0x310 +#define CSR_MCYCLEH 0xb80 +#define CSR_MINSTRETH 0xb82 +#define CSR_MHPMCOUNTER3H 0xb83 +#define CSR_MHPMCOUNTER4H 0xb84 +#define CSR_MHPMCOUNTER5H 0xb85 +#define CSR_MHPMCOUNTER6H 0xb86 +#define CSR_MHPMCOUNTER7H 0xb87 +#define CSR_MHPMCOUNTER8H 0xb88 +#define CSR_MHPMCOUNTER9H 0xb89 +#define CSR_MHPMCOUNTER10H 0xb8a +#define CSR_MHPMCOUNTER11H 0xb8b +#define CSR_MHPMCOUNTER12H 0xb8c +#define CSR_MHPMCOUNTER13H 0xb8d +#define CSR_MHPMCOUNTER14H 0xb8e +#define CSR_MHPMCOUNTER15H 0xb8f +#define CSR_MHPMCOUNTER16H 0xb90 +#define CSR_MHPMCOUNTER17H 0xb91 +#define CSR_MHPMCOUNTER18H 0xb92 +#define CSR_MHPMCOUNTER19H 0xb93 +#define CSR_MHPMCOUNTER20H 0xb94 +#define CSR_MHPMCOUNTER21H 0xb95 +#define CSR_MHPMCOUNTER22H 0xb96 +#define CSR_MHPMCOUNTER23H 0xb97 +#define CSR_MHPMCOUNTER24H 0xb98 +#define CSR_MHPMCOUNTER25H 0xb99 +#define CSR_MHPMCOUNTER26H 0xb9a +#define CSR_MHPMCOUNTER27H 0xb9b +#define CSR_MHPMCOUNTER28H 0xb9c +#define CSR_MHPMCOUNTER29H 0xb9d +#define CSR_MHPMCOUNTER30H 0xb9e +#define CSR_MHPMCOUNTER31H 0xb9f +#define CAUSE_MISALIGNED_FETCH 0x0 +#define CAUSE_FETCH_ACCESS 0x1 +#define CAUSE_ILLEGAL_INSTRUCTION 0x2 +#define CAUSE_BREAKPOINT 0x3 +#define CAUSE_MISALIGNED_LOAD 0x4 +#define CAUSE_LOAD_ACCESS 0x5 +#define CAUSE_MISALIGNED_STORE 0x6 +#define CAUSE_STORE_ACCESS 0x7 +#define CAUSE_USER_ECALL 0x8 +#define CAUSE_SUPERVISOR_ECALL 0x9 +#define CAUSE_HYPERVISOR_ECALL 0xa +#define CAUSE_MACHINE_ECALL 0xb +#define CAUSE_FETCH_PAGE_FAULT 0xc +#define CAUSE_LOAD_PAGE_FAULT 0xd +#define CAUSE_STORE_PAGE_FAULT 0xf +#endif +#ifdef DECLARE_INSN +DECLARE_INSN(slli_rv32, MATCH_SLLI_RV32, MASK_SLLI_RV32) +DECLARE_INSN(srli_rv32, MATCH_SRLI_RV32, MASK_SRLI_RV32) +DECLARE_INSN(srai_rv32, MATCH_SRAI_RV32, MASK_SRAI_RV32) +DECLARE_INSN(frflags, MATCH_FRFLAGS, MASK_FRFLAGS) +DECLARE_INSN(fsflags, MATCH_FSFLAGS, MASK_FSFLAGS) +DECLARE_INSN(fsflagsi, MATCH_FSFLAGSI, MASK_FSFLAGSI) +DECLARE_INSN(frrm, MATCH_FRRM, MASK_FRRM) +DECLARE_INSN(fsrm, MATCH_FSRM, MASK_FSRM) +DECLARE_INSN(fsrmi, MATCH_FSRMI, MASK_FSRMI) +DECLARE_INSN(fscsr, MATCH_FSCSR, MASK_FSCSR) +DECLARE_INSN(frcsr, MATCH_FRCSR, MASK_FRCSR) +DECLARE_INSN(rdcycle, MATCH_RDCYCLE, MASK_RDCYCLE) +DECLARE_INSN(rdtime, MATCH_RDTIME, MASK_RDTIME) +DECLARE_INSN(rdinstret, MATCH_RDINSTRET, MASK_RDINSTRET) +DECLARE_INSN(rdcycleh, MATCH_RDCYCLEH, MASK_RDCYCLEH) +DECLARE_INSN(rdtimeh, MATCH_RDTIMEH, MASK_RDTIMEH) +DECLARE_INSN(rdinstreth, MATCH_RDINSTRETH, MASK_RDINSTRETH) +DECLARE_INSN(scall, MATCH_SCALL, MASK_SCALL) +DECLARE_INSN(sbreak, MATCH_SBREAK, MASK_SBREAK) +DECLARE_INSN(fmv_x_s, MATCH_FMV_X_S, MASK_FMV_X_S) +DECLARE_INSN(fmv_s_x, MATCH_FMV_S_X, MASK_FMV_S_X) +DECLARE_INSN(fence_tso, MATCH_FENCE_TSO, MASK_FENCE_TSO) +DECLARE_INSN(pause, MATCH_PAUSE, MASK_PAUSE) +DECLARE_INSN(beq, MATCH_BEQ, MASK_BEQ) +DECLARE_INSN(bne, MATCH_BNE, MASK_BNE) +DECLARE_INSN(blt, MATCH_BLT, MASK_BLT) +DECLARE_INSN(bge, MATCH_BGE, MASK_BGE) +DECLARE_INSN(bltu, MATCH_BLTU, MASK_BLTU) +DECLARE_INSN(bgeu, MATCH_BGEU, MASK_BGEU) +DECLARE_INSN(jalr, MATCH_JALR, MASK_JALR) +DECLARE_INSN(jal, MATCH_JAL, MASK_JAL) +DECLARE_INSN(lui, MATCH_LUI, MASK_LUI) +DECLARE_INSN(auipc, MATCH_AUIPC, MASK_AUIPC) +DECLARE_INSN(addi, MATCH_ADDI, MASK_ADDI) +DECLARE_INSN(slli, MATCH_SLLI, MASK_SLLI) +DECLARE_INSN(slti, MATCH_SLTI, MASK_SLTI) +DECLARE_INSN(sltiu, MATCH_SLTIU, MASK_SLTIU) +DECLARE_INSN(xori, MATCH_XORI, MASK_XORI) +DECLARE_INSN(srli, MATCH_SRLI, MASK_SRLI) +DECLARE_INSN(srai, MATCH_SRAI, MASK_SRAI) +DECLARE_INSN(ori, MATCH_ORI, MASK_ORI) +DECLARE_INSN(andi, MATCH_ANDI, MASK_ANDI) +DECLARE_INSN(add, MATCH_ADD, MASK_ADD) +DECLARE_INSN(sub, MATCH_SUB, MASK_SUB) +DECLARE_INSN(sll, MATCH_SLL, MASK_SLL) +DECLARE_INSN(slt, MATCH_SLT, MASK_SLT) +DECLARE_INSN(sltu, MATCH_SLTU, MASK_SLTU) +DECLARE_INSN(xor, MATCH_XOR, MASK_XOR) +DECLARE_INSN(srl, MATCH_SRL, MASK_SRL) +DECLARE_INSN(sra, MATCH_SRA, MASK_SRA) +DECLARE_INSN(or, MATCH_OR, MASK_OR) +DECLARE_INSN(and, MATCH_AND, MASK_AND) +DECLARE_INSN(lb, MATCH_LB, MASK_LB) +DECLARE_INSN(lh, MATCH_LH, MASK_LH) +DECLARE_INSN(lw, MATCH_LW, MASK_LW) +DECLARE_INSN(lbu, MATCH_LBU, MASK_LBU) +DECLARE_INSN(lhu, MATCH_LHU, MASK_LHU) +DECLARE_INSN(sb, MATCH_SB, MASK_SB) +DECLARE_INSN(sh, MATCH_SH, MASK_SH) +DECLARE_INSN(sw, MATCH_SW, MASK_SW) +DECLARE_INSN(fence, MATCH_FENCE, MASK_FENCE) +DECLARE_INSN(fence_i, MATCH_FENCE_I, MASK_FENCE_I) +DECLARE_INSN(addiw, MATCH_ADDIW, MASK_ADDIW) +DECLARE_INSN(slliw, MATCH_SLLIW, MASK_SLLIW) +DECLARE_INSN(srliw, MATCH_SRLIW, MASK_SRLIW) +DECLARE_INSN(sraiw, MATCH_SRAIW, MASK_SRAIW) +DECLARE_INSN(addw, MATCH_ADDW, MASK_ADDW) +DECLARE_INSN(subw, MATCH_SUBW, MASK_SUBW) +DECLARE_INSN(sllw, MATCH_SLLW, MASK_SLLW) +DECLARE_INSN(srlw, MATCH_SRLW, MASK_SRLW) +DECLARE_INSN(sraw, MATCH_SRAW, MASK_SRAW) +DECLARE_INSN(ld, MATCH_LD, MASK_LD) +DECLARE_INSN(lwu, MATCH_LWU, MASK_LWU) +DECLARE_INSN(sd, MATCH_SD, MASK_SD) +DECLARE_INSN(mul, MATCH_MUL, MASK_MUL) +DECLARE_INSN(mulh, MATCH_MULH, MASK_MULH) +DECLARE_INSN(mulhsu, MATCH_MULHSU, MASK_MULHSU) +DECLARE_INSN(mulhu, MATCH_MULHU, MASK_MULHU) +DECLARE_INSN(div, MATCH_DIV, MASK_DIV) +DECLARE_INSN(divu, MATCH_DIVU, MASK_DIVU) +DECLARE_INSN(rem, MATCH_REM, MASK_REM) +DECLARE_INSN(remu, MATCH_REMU, MASK_REMU) +DECLARE_INSN(mulw, MATCH_MULW, MASK_MULW) +DECLARE_INSN(divw, MATCH_DIVW, MASK_DIVW) +DECLARE_INSN(divuw, MATCH_DIVUW, MASK_DIVUW) +DECLARE_INSN(remw, MATCH_REMW, MASK_REMW) +DECLARE_INSN(remuw, MATCH_REMUW, MASK_REMUW) +DECLARE_INSN(amoadd_w, MATCH_AMOADD_W, MASK_AMOADD_W) +DECLARE_INSN(amoxor_w, MATCH_AMOXOR_W, MASK_AMOXOR_W) +DECLARE_INSN(amoor_w, MATCH_AMOOR_W, MASK_AMOOR_W) +DECLARE_INSN(amoand_w, MATCH_AMOAND_W, MASK_AMOAND_W) +DECLARE_INSN(amomin_w, MATCH_AMOMIN_W, MASK_AMOMIN_W) +DECLARE_INSN(amomax_w, MATCH_AMOMAX_W, MASK_AMOMAX_W) +DECLARE_INSN(amominu_w, MATCH_AMOMINU_W, MASK_AMOMINU_W) +DECLARE_INSN(amomaxu_w, MATCH_AMOMAXU_W, MASK_AMOMAXU_W) +DECLARE_INSN(amoswap_w, MATCH_AMOSWAP_W, MASK_AMOSWAP_W) +DECLARE_INSN(lr_w, MATCH_LR_W, MASK_LR_W) +DECLARE_INSN(sc_w, MATCH_SC_W, MASK_SC_W) +DECLARE_INSN(amoadd_d, MATCH_AMOADD_D, MASK_AMOADD_D) +DECLARE_INSN(amoxor_d, MATCH_AMOXOR_D, MASK_AMOXOR_D) +DECLARE_INSN(amoor_d, MATCH_AMOOR_D, MASK_AMOOR_D) +DECLARE_INSN(amoand_d, MATCH_AMOAND_D, MASK_AMOAND_D) +DECLARE_INSN(amomin_d, MATCH_AMOMIN_D, MASK_AMOMIN_D) +DECLARE_INSN(amomax_d, MATCH_AMOMAX_D, MASK_AMOMAX_D) +DECLARE_INSN(amominu_d, MATCH_AMOMINU_D, MASK_AMOMINU_D) +DECLARE_INSN(amomaxu_d, MATCH_AMOMAXU_D, MASK_AMOMAXU_D) +DECLARE_INSN(amoswap_d, MATCH_AMOSWAP_D, MASK_AMOSWAP_D) +DECLARE_INSN(lr_d, MATCH_LR_D, MASK_LR_D) +DECLARE_INSN(sc_d, MATCH_SC_D, MASK_SC_D) +DECLARE_INSN(fadd_s, MATCH_FADD_S, MASK_FADD_S) +DECLARE_INSN(fsub_s, MATCH_FSUB_S, MASK_FSUB_S) +DECLARE_INSN(fmul_s, MATCH_FMUL_S, MASK_FMUL_S) +DECLARE_INSN(fdiv_s, MATCH_FDIV_S, MASK_FDIV_S) +DECLARE_INSN(fsgnj_s, MATCH_FSGNJ_S, MASK_FSGNJ_S) +DECLARE_INSN(fsgnjn_s, MATCH_FSGNJN_S, MASK_FSGNJN_S) +DECLARE_INSN(fsgnjx_s, MATCH_FSGNJX_S, MASK_FSGNJX_S) +DECLARE_INSN(fmin_s, MATCH_FMIN_S, MASK_FMIN_S) +DECLARE_INSN(fmax_s, MATCH_FMAX_S, MASK_FMAX_S) +DECLARE_INSN(fsqrt_s, MATCH_FSQRT_S, MASK_FSQRT_S) +DECLARE_INSN(fle_s, MATCH_FLE_S, MASK_FLE_S) +DECLARE_INSN(flt_s, MATCH_FLT_S, MASK_FLT_S) +DECLARE_INSN(feq_s, MATCH_FEQ_S, MASK_FEQ_S) +DECLARE_INSN(fcvt_w_s, MATCH_FCVT_W_S, MASK_FCVT_W_S) +DECLARE_INSN(fcvt_wu_s, MATCH_FCVT_WU_S, MASK_FCVT_WU_S) +DECLARE_INSN(fmv_x_w, MATCH_FMV_X_W, MASK_FMV_X_W) +DECLARE_INSN(fclass_s, MATCH_FCLASS_S, MASK_FCLASS_S) +DECLARE_INSN(fcvt_s_w, MATCH_FCVT_S_W, MASK_FCVT_S_W) +DECLARE_INSN(fcvt_s_wu, MATCH_FCVT_S_WU, MASK_FCVT_S_WU) +DECLARE_INSN(fmv_w_x, MATCH_FMV_W_X, MASK_FMV_W_X) +DECLARE_INSN(flw, MATCH_FLW, MASK_FLW) +DECLARE_INSN(fsw, MATCH_FSW, MASK_FSW) +DECLARE_INSN(fmadd_s, MATCH_FMADD_S, MASK_FMADD_S) +DECLARE_INSN(fmsub_s, MATCH_FMSUB_S, MASK_FMSUB_S) +DECLARE_INSN(fnmsub_s, MATCH_FNMSUB_S, MASK_FNMSUB_S) +DECLARE_INSN(fnmadd_s, MATCH_FNMADD_S, MASK_FNMADD_S) +DECLARE_INSN(fcvt_l_s, MATCH_FCVT_L_S, MASK_FCVT_L_S) +DECLARE_INSN(fcvt_lu_s, MATCH_FCVT_LU_S, MASK_FCVT_LU_S) +DECLARE_INSN(fcvt_s_l, MATCH_FCVT_S_L, MASK_FCVT_S_L) +DECLARE_INSN(fcvt_s_lu, MATCH_FCVT_S_LU, MASK_FCVT_S_LU) +DECLARE_INSN(fadd_d, MATCH_FADD_D, MASK_FADD_D) +DECLARE_INSN(fsub_d, MATCH_FSUB_D, MASK_FSUB_D) +DECLARE_INSN(fmul_d, MATCH_FMUL_D, MASK_FMUL_D) +DECLARE_INSN(fdiv_d, MATCH_FDIV_D, MASK_FDIV_D) +DECLARE_INSN(fsgnj_d, MATCH_FSGNJ_D, MASK_FSGNJ_D) +DECLARE_INSN(fsgnjn_d, MATCH_FSGNJN_D, MASK_FSGNJN_D) +DECLARE_INSN(fsgnjx_d, MATCH_FSGNJX_D, MASK_FSGNJX_D) +DECLARE_INSN(fmin_d, MATCH_FMIN_D, MASK_FMIN_D) +DECLARE_INSN(fmax_d, MATCH_FMAX_D, MASK_FMAX_D) +DECLARE_INSN(fcvt_s_d, MATCH_FCVT_S_D, MASK_FCVT_S_D) +DECLARE_INSN(fcvt_d_s, MATCH_FCVT_D_S, MASK_FCVT_D_S) +DECLARE_INSN(fsqrt_d, MATCH_FSQRT_D, MASK_FSQRT_D) +DECLARE_INSN(fle_d, MATCH_FLE_D, MASK_FLE_D) +DECLARE_INSN(flt_d, MATCH_FLT_D, MASK_FLT_D) +DECLARE_INSN(feq_d, MATCH_FEQ_D, MASK_FEQ_D) +DECLARE_INSN(fcvt_w_d, MATCH_FCVT_W_D, MASK_FCVT_W_D) +DECLARE_INSN(fcvt_wu_d, MATCH_FCVT_WU_D, MASK_FCVT_WU_D) +DECLARE_INSN(fclass_d, MATCH_FCLASS_D, MASK_FCLASS_D) +DECLARE_INSN(fcvt_d_w, MATCH_FCVT_D_W, MASK_FCVT_D_W) +DECLARE_INSN(fcvt_d_wu, MATCH_FCVT_D_WU, MASK_FCVT_D_WU) +DECLARE_INSN(fld, MATCH_FLD, MASK_FLD) +DECLARE_INSN(fsd, MATCH_FSD, MASK_FSD) +DECLARE_INSN(fmadd_d, MATCH_FMADD_D, MASK_FMADD_D) +DECLARE_INSN(fmsub_d, MATCH_FMSUB_D, MASK_FMSUB_D) +DECLARE_INSN(fnmsub_d, MATCH_FNMSUB_D, MASK_FNMSUB_D) +DECLARE_INSN(fnmadd_d, MATCH_FNMADD_D, MASK_FNMADD_D) +DECLARE_INSN(fcvt_l_d, MATCH_FCVT_L_D, MASK_FCVT_L_D) +DECLARE_INSN(fcvt_lu_d, MATCH_FCVT_LU_D, MASK_FCVT_LU_D) +DECLARE_INSN(fmv_x_d, MATCH_FMV_X_D, MASK_FMV_X_D) +DECLARE_INSN(fcvt_d_l, MATCH_FCVT_D_L, MASK_FCVT_D_L) +DECLARE_INSN(fcvt_d_lu, MATCH_FCVT_D_LU, MASK_FCVT_D_LU) +DECLARE_INSN(fmv_d_x, MATCH_FMV_D_X, MASK_FMV_D_X) +DECLARE_INSN(fadd_q, MATCH_FADD_Q, MASK_FADD_Q) +DECLARE_INSN(fsub_q, MATCH_FSUB_Q, MASK_FSUB_Q) +DECLARE_INSN(fmul_q, MATCH_FMUL_Q, MASK_FMUL_Q) +DECLARE_INSN(fdiv_q, MATCH_FDIV_Q, MASK_FDIV_Q) +DECLARE_INSN(fsgnj_q, MATCH_FSGNJ_Q, MASK_FSGNJ_Q) +DECLARE_INSN(fsgnjn_q, MATCH_FSGNJN_Q, MASK_FSGNJN_Q) +DECLARE_INSN(fsgnjx_q, MATCH_FSGNJX_Q, MASK_FSGNJX_Q) +DECLARE_INSN(fmin_q, MATCH_FMIN_Q, MASK_FMIN_Q) +DECLARE_INSN(fmax_q, MATCH_FMAX_Q, MASK_FMAX_Q) +DECLARE_INSN(fcvt_s_q, MATCH_FCVT_S_Q, MASK_FCVT_S_Q) +DECLARE_INSN(fcvt_q_s, MATCH_FCVT_Q_S, MASK_FCVT_Q_S) +DECLARE_INSN(fcvt_d_q, MATCH_FCVT_D_Q, MASK_FCVT_D_Q) +DECLARE_INSN(fcvt_q_d, MATCH_FCVT_Q_D, MASK_FCVT_Q_D) +DECLARE_INSN(fsqrt_q, MATCH_FSQRT_Q, MASK_FSQRT_Q) +DECLARE_INSN(fle_q, MATCH_FLE_Q, MASK_FLE_Q) +DECLARE_INSN(flt_q, MATCH_FLT_Q, MASK_FLT_Q) +DECLARE_INSN(feq_q, MATCH_FEQ_Q, MASK_FEQ_Q) +DECLARE_INSN(fcvt_w_q, MATCH_FCVT_W_Q, MASK_FCVT_W_Q) +DECLARE_INSN(fcvt_wu_q, MATCH_FCVT_WU_Q, MASK_FCVT_WU_Q) +DECLARE_INSN(fclass_q, MATCH_FCLASS_Q, MASK_FCLASS_Q) +DECLARE_INSN(fcvt_q_w, MATCH_FCVT_Q_W, MASK_FCVT_Q_W) +DECLARE_INSN(fcvt_q_wu, MATCH_FCVT_Q_WU, MASK_FCVT_Q_WU) +DECLARE_INSN(flq, MATCH_FLQ, MASK_FLQ) +DECLARE_INSN(fsq, MATCH_FSQ, MASK_FSQ) +DECLARE_INSN(fmadd_q, MATCH_FMADD_Q, MASK_FMADD_Q) +DECLARE_INSN(fmsub_q, MATCH_FMSUB_Q, MASK_FMSUB_Q) +DECLARE_INSN(fnmsub_q, MATCH_FNMSUB_Q, MASK_FNMSUB_Q) +DECLARE_INSN(fnmadd_q, MATCH_FNMADD_Q, MASK_FNMADD_Q) +DECLARE_INSN(fcvt_l_q, MATCH_FCVT_L_Q, MASK_FCVT_L_Q) +DECLARE_INSN(fcvt_lu_q, MATCH_FCVT_LU_Q, MASK_FCVT_LU_Q) +DECLARE_INSN(fcvt_q_l, MATCH_FCVT_Q_L, MASK_FCVT_Q_L) +DECLARE_INSN(fcvt_q_lu, MATCH_FCVT_Q_LU, MASK_FCVT_Q_LU) +DECLARE_INSN(fmv_x_q, MATCH_FMV_X_Q, MASK_FMV_X_Q) +DECLARE_INSN(fmv_q_x, MATCH_FMV_Q_X, MASK_FMV_Q_X) +DECLARE_INSN(ecall, MATCH_ECALL, MASK_ECALL) +DECLARE_INSN(ebreak, MATCH_EBREAK, MASK_EBREAK) +DECLARE_INSN(uret, MATCH_URET, MASK_URET) +DECLARE_INSN(sret, MATCH_SRET, MASK_SRET) +DECLARE_INSN(mret, MATCH_MRET, MASK_MRET) +DECLARE_INSN(dret, MATCH_DRET, MASK_DRET) +DECLARE_INSN(sfence_vma, MATCH_SFENCE_VMA, MASK_SFENCE_VMA) +DECLARE_INSN(wfi, MATCH_WFI, MASK_WFI) +DECLARE_INSN(csrrw, MATCH_CSRRW, MASK_CSRRW) +DECLARE_INSN(csrrs, MATCH_CSRRS, MASK_CSRRS) +DECLARE_INSN(csrrc, MATCH_CSRRC, MASK_CSRRC) +DECLARE_INSN(csrrwi, MATCH_CSRRWI, MASK_CSRRWI) +DECLARE_INSN(csrrsi, MATCH_CSRRSI, MASK_CSRRSI) +DECLARE_INSN(csrrci, MATCH_CSRRCI, MASK_CSRRCI) +DECLARE_INSN(hfence_vvma, MATCH_HFENCE_VVMA, MASK_HFENCE_VVMA) +DECLARE_INSN(hfence_gvma, MATCH_HFENCE_GVMA, MASK_HFENCE_GVMA) +DECLARE_INSN(c_nop, MATCH_C_NOP, MASK_C_NOP) +DECLARE_INSN(c_addi16sp, MATCH_C_ADDI16SP, MASK_C_ADDI16SP) +DECLARE_INSN(c_jr, MATCH_C_JR, MASK_C_JR) +DECLARE_INSN(c_jalr, MATCH_C_JALR, MASK_C_JALR) +DECLARE_INSN(c_ebreak, MATCH_C_EBREAK, MASK_C_EBREAK) +DECLARE_INSN(c_addi4spn, MATCH_C_ADDI4SPN, MASK_C_ADDI4SPN) +DECLARE_INSN(c_fld, MATCH_C_FLD, MASK_C_FLD) +DECLARE_INSN(c_lw, MATCH_C_LW, MASK_C_LW) +DECLARE_INSN(c_flw, MATCH_C_FLW, MASK_C_FLW) +DECLARE_INSN(c_fsd, MATCH_C_FSD, MASK_C_FSD) +DECLARE_INSN(c_sw, MATCH_C_SW, MASK_C_SW) +DECLARE_INSN(c_fsw, MATCH_C_FSW, MASK_C_FSW) +DECLARE_INSN(c_addi, MATCH_C_ADDI, MASK_C_ADDI) +DECLARE_INSN(c_jal, MATCH_C_JAL, MASK_C_JAL) +DECLARE_INSN(c_li, MATCH_C_LI, MASK_C_LI) +DECLARE_INSN(c_lui, MATCH_C_LUI, MASK_C_LUI) +DECLARE_INSN(c_srli, MATCH_C_SRLI, MASK_C_SRLI) +DECLARE_INSN(c_srai, MATCH_C_SRAI, MASK_C_SRAI) +DECLARE_INSN(c_andi, MATCH_C_ANDI, MASK_C_ANDI) +DECLARE_INSN(c_sub, MATCH_C_SUB, MASK_C_SUB) +DECLARE_INSN(c_xor, MATCH_C_XOR, MASK_C_XOR) +DECLARE_INSN(c_or, MATCH_C_OR, MASK_C_OR) +DECLARE_INSN(c_and, MATCH_C_AND, MASK_C_AND) +DECLARE_INSN(c_j, MATCH_C_J, MASK_C_J) +DECLARE_INSN(c_beqz, MATCH_C_BEQZ, MASK_C_BEQZ) +DECLARE_INSN(c_bnez, MATCH_C_BNEZ, MASK_C_BNEZ) +DECLARE_INSN(c_slli, MATCH_C_SLLI, MASK_C_SLLI) +DECLARE_INSN(c_fldsp, MATCH_C_FLDSP, MASK_C_FLDSP) +DECLARE_INSN(c_lwsp, MATCH_C_LWSP, MASK_C_LWSP) +DECLARE_INSN(c_flwsp, MATCH_C_FLWSP, MASK_C_FLWSP) +DECLARE_INSN(c_mv, MATCH_C_MV, MASK_C_MV) +DECLARE_INSN(c_add, MATCH_C_ADD, MASK_C_ADD) +DECLARE_INSN(c_fsdsp, MATCH_C_FSDSP, MASK_C_FSDSP) +DECLARE_INSN(c_swsp, MATCH_C_SWSP, MASK_C_SWSP) +DECLARE_INSN(c_fswsp, MATCH_C_FSWSP, MASK_C_FSWSP) +DECLARE_INSN(c_srli_rv32, MATCH_C_SRLI_RV32, MASK_C_SRLI_RV32) +DECLARE_INSN(c_srai_rv32, MATCH_C_SRAI_RV32, MASK_C_SRAI_RV32) +DECLARE_INSN(c_slli_rv32, MATCH_C_SLLI_RV32, MASK_C_SLLI_RV32) +DECLARE_INSN(c_ld, MATCH_C_LD, MASK_C_LD) +DECLARE_INSN(c_sd, MATCH_C_SD, MASK_C_SD) +DECLARE_INSN(c_subw, MATCH_C_SUBW, MASK_C_SUBW) +DECLARE_INSN(c_addw, MATCH_C_ADDW, MASK_C_ADDW) +DECLARE_INSN(c_addiw, MATCH_C_ADDIW, MASK_C_ADDIW) +DECLARE_INSN(c_ldsp, MATCH_C_LDSP, MASK_C_LDSP) +DECLARE_INSN(c_sdsp, MATCH_C_SDSP, MASK_C_SDSP) +DECLARE_INSN(c_lq, MATCH_C_LQ, MASK_C_LQ) +DECLARE_INSN(c_sq, MATCH_C_SQ, MASK_C_SQ) +DECLARE_INSN(c_lqsp, MATCH_C_LQSP, MASK_C_LQSP) +DECLARE_INSN(c_sqsp, MATCH_C_SQSP, MASK_C_SQSP) +DECLARE_INSN(custom0, MATCH_CUSTOM0, MASK_CUSTOM0) +DECLARE_INSN(custom0_rs1, MATCH_CUSTOM0_RS1, MASK_CUSTOM0_RS1) +DECLARE_INSN(custom0_rs1_rs2, MATCH_CUSTOM0_RS1_RS2, MASK_CUSTOM0_RS1_RS2) +DECLARE_INSN(custom0_rd, MATCH_CUSTOM0_RD, MASK_CUSTOM0_RD) +DECLARE_INSN(custom0_rd_rs1, MATCH_CUSTOM0_RD_RS1, MASK_CUSTOM0_RD_RS1) +DECLARE_INSN(custom0_rd_rs1_rs2, MATCH_CUSTOM0_RD_RS1_RS2, MASK_CUSTOM0_RD_RS1_RS2) +DECLARE_INSN(custom1, MATCH_CUSTOM1, MASK_CUSTOM1) +DECLARE_INSN(custom1_rs1, MATCH_CUSTOM1_RS1, MASK_CUSTOM1_RS1) +DECLARE_INSN(custom1_rs1_rs2, MATCH_CUSTOM1_RS1_RS2, MASK_CUSTOM1_RS1_RS2) +DECLARE_INSN(custom1_rd, MATCH_CUSTOM1_RD, MASK_CUSTOM1_RD) +DECLARE_INSN(custom1_rd_rs1, MATCH_CUSTOM1_RD_RS1, MASK_CUSTOM1_RD_RS1) +DECLARE_INSN(custom1_rd_rs1_rs2, MATCH_CUSTOM1_RD_RS1_RS2, MASK_CUSTOM1_RD_RS1_RS2) +DECLARE_INSN(custom2, MATCH_CUSTOM2, MASK_CUSTOM2) +DECLARE_INSN(custom2_rs1, MATCH_CUSTOM2_RS1, MASK_CUSTOM2_RS1) +DECLARE_INSN(custom2_rs1_rs2, MATCH_CUSTOM2_RS1_RS2, MASK_CUSTOM2_RS1_RS2) +DECLARE_INSN(custom2_rd, MATCH_CUSTOM2_RD, MASK_CUSTOM2_RD) +DECLARE_INSN(custom2_rd_rs1, MATCH_CUSTOM2_RD_RS1, MASK_CUSTOM2_RD_RS1) +DECLARE_INSN(custom2_rd_rs1_rs2, MATCH_CUSTOM2_RD_RS1_RS2, MASK_CUSTOM2_RD_RS1_RS2) +DECLARE_INSN(custom3, MATCH_CUSTOM3, MASK_CUSTOM3) +DECLARE_INSN(custom3_rs1, MATCH_CUSTOM3_RS1, MASK_CUSTOM3_RS1) +DECLARE_INSN(custom3_rs1_rs2, MATCH_CUSTOM3_RS1_RS2, MASK_CUSTOM3_RS1_RS2) +DECLARE_INSN(custom3_rd, MATCH_CUSTOM3_RD, MASK_CUSTOM3_RD) +DECLARE_INSN(custom3_rd_rs1, MATCH_CUSTOM3_RD_RS1, MASK_CUSTOM3_RD_RS1) +DECLARE_INSN(custom3_rd_rs1_rs2, MATCH_CUSTOM3_RD_RS1_RS2, MASK_CUSTOM3_RD_RS1_RS2) +DECLARE_INSN(vsetvli, MATCH_VSETVLI, MASK_VSETVLI) +DECLARE_INSN(vsetvl, MATCH_VSETVL, MASK_VSETVL) +DECLARE_INSN(vlb_v, MATCH_VLB_V, MASK_VLB_V) +DECLARE_INSN(vlh_v, MATCH_VLH_V, MASK_VLH_V) +DECLARE_INSN(vlw_v, MATCH_VLW_V, MASK_VLW_V) +DECLARE_INSN(vle_v, MATCH_VLE_V, MASK_VLE_V) +DECLARE_INSN(vlbu_v, MATCH_VLBU_V, MASK_VLBU_V) +DECLARE_INSN(vlhu_v, MATCH_VLHU_V, MASK_VLHU_V) +DECLARE_INSN(vlwu_v, MATCH_VLWU_V, MASK_VLWU_V) +DECLARE_INSN(vsb_v, MATCH_VSB_V, MASK_VSB_V) +DECLARE_INSN(vsh_v, MATCH_VSH_V, MASK_VSH_V) +DECLARE_INSN(vsw_v, MATCH_VSW_V, MASK_VSW_V) +DECLARE_INSN(vse_v, MATCH_VSE_V, MASK_VSE_V) +DECLARE_INSN(vlsb_v, MATCH_VLSB_V, MASK_VLSB_V) +DECLARE_INSN(vlsh_v, MATCH_VLSH_V, MASK_VLSH_V) +DECLARE_INSN(vlsw_v, MATCH_VLSW_V, MASK_VLSW_V) +DECLARE_INSN(vlse_v, MATCH_VLSE_V, MASK_VLSE_V) +DECLARE_INSN(vlsbu_v, MATCH_VLSBU_V, MASK_VLSBU_V) +DECLARE_INSN(vlshu_v, MATCH_VLSHU_V, MASK_VLSHU_V) +DECLARE_INSN(vlswu_v, MATCH_VLSWU_V, MASK_VLSWU_V) +DECLARE_INSN(vssb_v, MATCH_VSSB_V, MASK_VSSB_V) +DECLARE_INSN(vssh_v, MATCH_VSSH_V, MASK_VSSH_V) +DECLARE_INSN(vssw_v, MATCH_VSSW_V, MASK_VSSW_V) +DECLARE_INSN(vsse_v, MATCH_VSSE_V, MASK_VSSE_V) +DECLARE_INSN(vlxb_v, MATCH_VLXB_V, MASK_VLXB_V) +DECLARE_INSN(vlxh_v, MATCH_VLXH_V, MASK_VLXH_V) +DECLARE_INSN(vlxw_v, MATCH_VLXW_V, MASK_VLXW_V) +DECLARE_INSN(vlxe_v, MATCH_VLXE_V, MASK_VLXE_V) +DECLARE_INSN(vlxbu_v, MATCH_VLXBU_V, MASK_VLXBU_V) +DECLARE_INSN(vlxhu_v, MATCH_VLXHU_V, MASK_VLXHU_V) +DECLARE_INSN(vlxwu_v, MATCH_VLXWU_V, MASK_VLXWU_V) +DECLARE_INSN(vsxb_v, MATCH_VSXB_V, MASK_VSXB_V) +DECLARE_INSN(vsxh_v, MATCH_VSXH_V, MASK_VSXH_V) +DECLARE_INSN(vsxw_v, MATCH_VSXW_V, MASK_VSXW_V) +DECLARE_INSN(vsxe_v, MATCH_VSXE_V, MASK_VSXE_V) +DECLARE_INSN(vsuxb_v, MATCH_VSUXB_V, MASK_VSUXB_V) +DECLARE_INSN(vsuxh_v, MATCH_VSUXH_V, MASK_VSUXH_V) +DECLARE_INSN(vsuxw_v, MATCH_VSUXW_V, MASK_VSUXW_V) +DECLARE_INSN(vsuxe_v, MATCH_VSUXE_V, MASK_VSUXE_V) +DECLARE_INSN(vlbff_v, MATCH_VLBFF_V, MASK_VLBFF_V) +DECLARE_INSN(vlhff_v, MATCH_VLHFF_V, MASK_VLHFF_V) +DECLARE_INSN(vlwff_v, MATCH_VLWFF_V, MASK_VLWFF_V) +DECLARE_INSN(vleff_v, MATCH_VLEFF_V, MASK_VLEFF_V) +DECLARE_INSN(vlbuff_v, MATCH_VLBUFF_V, MASK_VLBUFF_V) +DECLARE_INSN(vlhuff_v, MATCH_VLHUFF_V, MASK_VLHUFF_V) +DECLARE_INSN(vlwuff_v, MATCH_VLWUFF_V, MASK_VLWUFF_V) +DECLARE_INSN(vl1r_v, MATCH_VL1R_V, MASK_VL1R_V) +DECLARE_INSN(vs1r_v, MATCH_VS1R_V, MASK_VS1R_V) +DECLARE_INSN(vfadd_vf, MATCH_VFADD_VF, MASK_VFADD_VF) +DECLARE_INSN(vfsub_vf, MATCH_VFSUB_VF, MASK_VFSUB_VF) +DECLARE_INSN(vfmin_vf, MATCH_VFMIN_VF, MASK_VFMIN_VF) +DECLARE_INSN(vfmax_vf, MATCH_VFMAX_VF, MASK_VFMAX_VF) +DECLARE_INSN(vfsgnj_vf, MATCH_VFSGNJ_VF, MASK_VFSGNJ_VF) +DECLARE_INSN(vfsgnjn_vf, MATCH_VFSGNJN_VF, MASK_VFSGNJN_VF) +DECLARE_INSN(vfsgnjx_vf, MATCH_VFSGNJX_VF, MASK_VFSGNJX_VF) +DECLARE_INSN(vfslide1up_vf, MATCH_VFSLIDE1UP_VF, MASK_VFSLIDE1UP_VF) +DECLARE_INSN(vfslide1down_vf, MATCH_VFSLIDE1DOWN_VF, MASK_VFSLIDE1DOWN_VF) +DECLARE_INSN(vfmv_s_f, MATCH_VFMV_S_F, MASK_VFMV_S_F) +DECLARE_INSN(vfmerge_vfm, MATCH_VFMERGE_VFM, MASK_VFMERGE_VFM) +DECLARE_INSN(vfmv_v_f, MATCH_VFMV_V_F, MASK_VFMV_V_F) +DECLARE_INSN(vmfeq_vf, MATCH_VMFEQ_VF, MASK_VMFEQ_VF) +DECLARE_INSN(vmfle_vf, MATCH_VMFLE_VF, MASK_VMFLE_VF) +DECLARE_INSN(vmflt_vf, MATCH_VMFLT_VF, MASK_VMFLT_VF) +DECLARE_INSN(vmfne_vf, MATCH_VMFNE_VF, MASK_VMFNE_VF) +DECLARE_INSN(vmfgt_vf, MATCH_VMFGT_VF, MASK_VMFGT_VF) +DECLARE_INSN(vmfge_vf, MATCH_VMFGE_VF, MASK_VMFGE_VF) +DECLARE_INSN(vfdiv_vf, MATCH_VFDIV_VF, MASK_VFDIV_VF) +DECLARE_INSN(vfrdiv_vf, MATCH_VFRDIV_VF, MASK_VFRDIV_VF) +DECLARE_INSN(vfmul_vf, MATCH_VFMUL_VF, MASK_VFMUL_VF) +DECLARE_INSN(vfrsub_vf, MATCH_VFRSUB_VF, MASK_VFRSUB_VF) +DECLARE_INSN(vfmadd_vf, MATCH_VFMADD_VF, MASK_VFMADD_VF) +DECLARE_INSN(vfnmadd_vf, MATCH_VFNMADD_VF, MASK_VFNMADD_VF) +DECLARE_INSN(vfmsub_vf, MATCH_VFMSUB_VF, MASK_VFMSUB_VF) +DECLARE_INSN(vfnmsub_vf, MATCH_VFNMSUB_VF, MASK_VFNMSUB_VF) +DECLARE_INSN(vfmacc_vf, MATCH_VFMACC_VF, MASK_VFMACC_VF) +DECLARE_INSN(vfnmacc_vf, MATCH_VFNMACC_VF, MASK_VFNMACC_VF) +DECLARE_INSN(vfmsac_vf, MATCH_VFMSAC_VF, MASK_VFMSAC_VF) +DECLARE_INSN(vfnmsac_vf, MATCH_VFNMSAC_VF, MASK_VFNMSAC_VF) +DECLARE_INSN(vfwadd_vf, MATCH_VFWADD_VF, MASK_VFWADD_VF) +DECLARE_INSN(vfwsub_vf, MATCH_VFWSUB_VF, MASK_VFWSUB_VF) +DECLARE_INSN(vfwadd_wf, MATCH_VFWADD_WF, MASK_VFWADD_WF) +DECLARE_INSN(vfwsub_wf, MATCH_VFWSUB_WF, MASK_VFWSUB_WF) +DECLARE_INSN(vfwmul_vf, MATCH_VFWMUL_VF, MASK_VFWMUL_VF) +DECLARE_INSN(vfwmacc_vf, MATCH_VFWMACC_VF, MASK_VFWMACC_VF) +DECLARE_INSN(vfwnmacc_vf, MATCH_VFWNMACC_VF, MASK_VFWNMACC_VF) +DECLARE_INSN(vfwmsac_vf, MATCH_VFWMSAC_VF, MASK_VFWMSAC_VF) +DECLARE_INSN(vfwnmsac_vf, MATCH_VFWNMSAC_VF, MASK_VFWNMSAC_VF) +DECLARE_INSN(vfadd_vv, MATCH_VFADD_VV, MASK_VFADD_VV) +DECLARE_INSN(vfredsum_vs, MATCH_VFREDSUM_VS, MASK_VFREDSUM_VS) +DECLARE_INSN(vfsub_vv, MATCH_VFSUB_VV, MASK_VFSUB_VV) +DECLARE_INSN(vfredosum_vs, MATCH_VFREDOSUM_VS, MASK_VFREDOSUM_VS) +DECLARE_INSN(vfmin_vv, MATCH_VFMIN_VV, MASK_VFMIN_VV) +DECLARE_INSN(vfredmin_vs, MATCH_VFREDMIN_VS, MASK_VFREDMIN_VS) +DECLARE_INSN(vfmax_vv, MATCH_VFMAX_VV, MASK_VFMAX_VV) +DECLARE_INSN(vfredmax_vs, MATCH_VFREDMAX_VS, MASK_VFREDMAX_VS) +DECLARE_INSN(vfsgnj_vv, MATCH_VFSGNJ_VV, MASK_VFSGNJ_VV) +DECLARE_INSN(vfsgnjn_vv, MATCH_VFSGNJN_VV, MASK_VFSGNJN_VV) +DECLARE_INSN(vfsgnjx_vv, MATCH_VFSGNJX_VV, MASK_VFSGNJX_VV) +DECLARE_INSN(vfmv_f_s, MATCH_VFMV_F_S, MASK_VFMV_F_S) +DECLARE_INSN(vmfeq_vv, MATCH_VMFEQ_VV, MASK_VMFEQ_VV) +DECLARE_INSN(vmfle_vv, MATCH_VMFLE_VV, MASK_VMFLE_VV) +DECLARE_INSN(vmflt_vv, MATCH_VMFLT_VV, MASK_VMFLT_VV) +DECLARE_INSN(vmfne_vv, MATCH_VMFNE_VV, MASK_VMFNE_VV) +DECLARE_INSN(vfdiv_vv, MATCH_VFDIV_VV, MASK_VFDIV_VV) +DECLARE_INSN(vfmul_vv, MATCH_VFMUL_VV, MASK_VFMUL_VV) +DECLARE_INSN(vfmadd_vv, MATCH_VFMADD_VV, MASK_VFMADD_VV) +DECLARE_INSN(vfnmadd_vv, MATCH_VFNMADD_VV, MASK_VFNMADD_VV) +DECLARE_INSN(vfmsub_vv, MATCH_VFMSUB_VV, MASK_VFMSUB_VV) +DECLARE_INSN(vfnmsub_vv, MATCH_VFNMSUB_VV, MASK_VFNMSUB_VV) +DECLARE_INSN(vfmacc_vv, MATCH_VFMACC_VV, MASK_VFMACC_VV) +DECLARE_INSN(vfnmacc_vv, MATCH_VFNMACC_VV, MASK_VFNMACC_VV) +DECLARE_INSN(vfmsac_vv, MATCH_VFMSAC_VV, MASK_VFMSAC_VV) +DECLARE_INSN(vfnmsac_vv, MATCH_VFNMSAC_VV, MASK_VFNMSAC_VV) +DECLARE_INSN(vfcvt_xu_f_v, MATCH_VFCVT_XU_F_V, MASK_VFCVT_XU_F_V) +DECLARE_INSN(vfcvt_x_f_v, MATCH_VFCVT_X_F_V, MASK_VFCVT_X_F_V) +DECLARE_INSN(vfcvt_f_xu_v, MATCH_VFCVT_F_XU_V, MASK_VFCVT_F_XU_V) +DECLARE_INSN(vfcvt_f_x_v, MATCH_VFCVT_F_X_V, MASK_VFCVT_F_X_V) +DECLARE_INSN(vfcvt_rtz_xu_f_v, MATCH_VFCVT_RTZ_XU_F_V, MASK_VFCVT_RTZ_XU_F_V) +DECLARE_INSN(vfcvt_rtz_x_f_v, MATCH_VFCVT_RTZ_X_F_V, MASK_VFCVT_RTZ_X_F_V) +DECLARE_INSN(vfwcvt_xu_f_v, MATCH_VFWCVT_XU_F_V, MASK_VFWCVT_XU_F_V) +DECLARE_INSN(vfwcvt_x_f_v, MATCH_VFWCVT_X_F_V, MASK_VFWCVT_X_F_V) +DECLARE_INSN(vfwcvt_f_xu_v, MATCH_VFWCVT_F_XU_V, MASK_VFWCVT_F_XU_V) +DECLARE_INSN(vfwcvt_f_x_v, MATCH_VFWCVT_F_X_V, MASK_VFWCVT_F_X_V) +DECLARE_INSN(vfwcvt_f_f_v, MATCH_VFWCVT_F_F_V, MASK_VFWCVT_F_F_V) +DECLARE_INSN(vfwcvt_rtz_xu_f_v, MATCH_VFWCVT_RTZ_XU_F_V, MASK_VFWCVT_RTZ_XU_F_V) +DECLARE_INSN(vfwcvt_rtz_x_f_v, MATCH_VFWCVT_RTZ_X_F_V, MASK_VFWCVT_RTZ_X_F_V) +DECLARE_INSN(vfncvt_xu_f_w, MATCH_VFNCVT_XU_F_W, MASK_VFNCVT_XU_F_W) +DECLARE_INSN(vfncvt_x_f_w, MATCH_VFNCVT_X_F_W, MASK_VFNCVT_X_F_W) +DECLARE_INSN(vfncvt_f_xu_w, MATCH_VFNCVT_F_XU_W, MASK_VFNCVT_F_XU_W) +DECLARE_INSN(vfncvt_f_x_w, MATCH_VFNCVT_F_X_W, MASK_VFNCVT_F_X_W) +DECLARE_INSN(vfncvt_f_f_w, MATCH_VFNCVT_F_F_W, MASK_VFNCVT_F_F_W) +DECLARE_INSN(vfncvt_rod_f_f_w, MATCH_VFNCVT_ROD_F_F_W, MASK_VFNCVT_ROD_F_F_W) +DECLARE_INSN(vfncvt_rtz_xu_f_w, MATCH_VFNCVT_RTZ_XU_F_W, MASK_VFNCVT_RTZ_XU_F_W) +DECLARE_INSN(vfncvt_rtz_x_f_w, MATCH_VFNCVT_RTZ_X_F_W, MASK_VFNCVT_RTZ_X_F_W) +DECLARE_INSN(vfsqrt_v, MATCH_VFSQRT_V, MASK_VFSQRT_V) +DECLARE_INSN(vfclass_v, MATCH_VFCLASS_V, MASK_VFCLASS_V) +DECLARE_INSN(vfwadd_vv, MATCH_VFWADD_VV, MASK_VFWADD_VV) +DECLARE_INSN(vfwredsum_vs, MATCH_VFWREDSUM_VS, MASK_VFWREDSUM_VS) +DECLARE_INSN(vfwsub_vv, MATCH_VFWSUB_VV, MASK_VFWSUB_VV) +DECLARE_INSN(vfwredosum_vs, MATCH_VFWREDOSUM_VS, MASK_VFWREDOSUM_VS) +DECLARE_INSN(vfwadd_wv, MATCH_VFWADD_WV, MASK_VFWADD_WV) +DECLARE_INSN(vfwsub_wv, MATCH_VFWSUB_WV, MASK_VFWSUB_WV) +DECLARE_INSN(vfwmul_vv, MATCH_VFWMUL_VV, MASK_VFWMUL_VV) +DECLARE_INSN(vfdot_vv, MATCH_VFDOT_VV, MASK_VFDOT_VV) +DECLARE_INSN(vfwmacc_vv, MATCH_VFWMACC_VV, MASK_VFWMACC_VV) +DECLARE_INSN(vfwnmacc_vv, MATCH_VFWNMACC_VV, MASK_VFWNMACC_VV) +DECLARE_INSN(vfwmsac_vv, MATCH_VFWMSAC_VV, MASK_VFWMSAC_VV) +DECLARE_INSN(vfwnmsac_vv, MATCH_VFWNMSAC_VV, MASK_VFWNMSAC_VV) +DECLARE_INSN(vadd_vx, MATCH_VADD_VX, MASK_VADD_VX) +DECLARE_INSN(vsub_vx, MATCH_VSUB_VX, MASK_VSUB_VX) +DECLARE_INSN(vrsub_vx, MATCH_VRSUB_VX, MASK_VRSUB_VX) +DECLARE_INSN(vminu_vx, MATCH_VMINU_VX, MASK_VMINU_VX) +DECLARE_INSN(vmin_vx, MATCH_VMIN_VX, MASK_VMIN_VX) +DECLARE_INSN(vmaxu_vx, MATCH_VMAXU_VX, MASK_VMAXU_VX) +DECLARE_INSN(vmax_vx, MATCH_VMAX_VX, MASK_VMAX_VX) +DECLARE_INSN(vand_vx, MATCH_VAND_VX, MASK_VAND_VX) +DECLARE_INSN(vor_vx, MATCH_VOR_VX, MASK_VOR_VX) +DECLARE_INSN(vxor_vx, MATCH_VXOR_VX, MASK_VXOR_VX) +DECLARE_INSN(vrgather_vx, MATCH_VRGATHER_VX, MASK_VRGATHER_VX) +DECLARE_INSN(vslideup_vx, MATCH_VSLIDEUP_VX, MASK_VSLIDEUP_VX) +DECLARE_INSN(vslidedown_vx, MATCH_VSLIDEDOWN_VX, MASK_VSLIDEDOWN_VX) +DECLARE_INSN(vadc_vxm, MATCH_VADC_VXM, MASK_VADC_VXM) +DECLARE_INSN(vmadc_vxm, MATCH_VMADC_VXM, MASK_VMADC_VXM) +DECLARE_INSN(vsbc_vxm, MATCH_VSBC_VXM, MASK_VSBC_VXM) +DECLARE_INSN(vmsbc_vxm, MATCH_VMSBC_VXM, MASK_VMSBC_VXM) +DECLARE_INSN(vmerge_vxm, MATCH_VMERGE_VXM, MASK_VMERGE_VXM) +DECLARE_INSN(vmv_v_x, MATCH_VMV_V_X, MASK_VMV_V_X) +DECLARE_INSN(vmseq_vx, MATCH_VMSEQ_VX, MASK_VMSEQ_VX) +DECLARE_INSN(vmsne_vx, MATCH_VMSNE_VX, MASK_VMSNE_VX) +DECLARE_INSN(vmsltu_vx, MATCH_VMSLTU_VX, MASK_VMSLTU_VX) +DECLARE_INSN(vmslt_vx, MATCH_VMSLT_VX, MASK_VMSLT_VX) +DECLARE_INSN(vmsleu_vx, MATCH_VMSLEU_VX, MASK_VMSLEU_VX) +DECLARE_INSN(vmsle_vx, MATCH_VMSLE_VX, MASK_VMSLE_VX) +DECLARE_INSN(vmsgtu_vx, MATCH_VMSGTU_VX, MASK_VMSGTU_VX) +DECLARE_INSN(vmsgt_vx, MATCH_VMSGT_VX, MASK_VMSGT_VX) +DECLARE_INSN(vsaddu_vx, MATCH_VSADDU_VX, MASK_VSADDU_VX) +DECLARE_INSN(vsadd_vx, MATCH_VSADD_VX, MASK_VSADD_VX) +DECLARE_INSN(vssubu_vx, MATCH_VSSUBU_VX, MASK_VSSUBU_VX) +DECLARE_INSN(vssub_vx, MATCH_VSSUB_VX, MASK_VSSUB_VX) +DECLARE_INSN(vsll_vx, MATCH_VSLL_VX, MASK_VSLL_VX) +DECLARE_INSN(vsmul_vx, MATCH_VSMUL_VX, MASK_VSMUL_VX) +DECLARE_INSN(vsrl_vx, MATCH_VSRL_VX, MASK_VSRL_VX) +DECLARE_INSN(vsra_vx, MATCH_VSRA_VX, MASK_VSRA_VX) +DECLARE_INSN(vssrl_vx, MATCH_VSSRL_VX, MASK_VSSRL_VX) +DECLARE_INSN(vssra_vx, MATCH_VSSRA_VX, MASK_VSSRA_VX) +DECLARE_INSN(vnsrl_wx, MATCH_VNSRL_WX, MASK_VNSRL_WX) +DECLARE_INSN(vnsra_wx, MATCH_VNSRA_WX, MASK_VNSRA_WX) +DECLARE_INSN(vnclipu_wx, MATCH_VNCLIPU_WX, MASK_VNCLIPU_WX) +DECLARE_INSN(vnclip_wx, MATCH_VNCLIP_WX, MASK_VNCLIP_WX) +DECLARE_INSN(vqmaccu_vx, MATCH_VQMACCU_VX, MASK_VQMACCU_VX) +DECLARE_INSN(vqmacc_vx, MATCH_VQMACC_VX, MASK_VQMACC_VX) +DECLARE_INSN(vqmaccus_vx, MATCH_VQMACCUS_VX, MASK_VQMACCUS_VX) +DECLARE_INSN(vqmaccsu_vx, MATCH_VQMACCSU_VX, MASK_VQMACCSU_VX) +DECLARE_INSN(vadd_vv, MATCH_VADD_VV, MASK_VADD_VV) +DECLARE_INSN(vsub_vv, MATCH_VSUB_VV, MASK_VSUB_VV) +DECLARE_INSN(vminu_vv, MATCH_VMINU_VV, MASK_VMINU_VV) +DECLARE_INSN(vmin_vv, MATCH_VMIN_VV, MASK_VMIN_VV) +DECLARE_INSN(vmaxu_vv, MATCH_VMAXU_VV, MASK_VMAXU_VV) +DECLARE_INSN(vmax_vv, MATCH_VMAX_VV, MASK_VMAX_VV) +DECLARE_INSN(vand_vv, MATCH_VAND_VV, MASK_VAND_VV) +DECLARE_INSN(vor_vv, MATCH_VOR_VV, MASK_VOR_VV) +DECLARE_INSN(vxor_vv, MATCH_VXOR_VV, MASK_VXOR_VV) +DECLARE_INSN(vrgather_vv, MATCH_VRGATHER_VV, MASK_VRGATHER_VV) +DECLARE_INSN(vadc_vvm, MATCH_VADC_VVM, MASK_VADC_VVM) +DECLARE_INSN(vmadc_vvm, MATCH_VMADC_VVM, MASK_VMADC_VVM) +DECLARE_INSN(vsbc_vvm, MATCH_VSBC_VVM, MASK_VSBC_VVM) +DECLARE_INSN(vmsbc_vvm, MATCH_VMSBC_VVM, MASK_VMSBC_VVM) +DECLARE_INSN(vmerge_vvm, MATCH_VMERGE_VVM, MASK_VMERGE_VVM) +DECLARE_INSN(vmv_v_v, MATCH_VMV_V_V, MASK_VMV_V_V) +DECLARE_INSN(vmseq_vv, MATCH_VMSEQ_VV, MASK_VMSEQ_VV) +DECLARE_INSN(vmsne_vv, MATCH_VMSNE_VV, MASK_VMSNE_VV) +DECLARE_INSN(vmsltu_vv, MATCH_VMSLTU_VV, MASK_VMSLTU_VV) +DECLARE_INSN(vmslt_vv, MATCH_VMSLT_VV, MASK_VMSLT_VV) +DECLARE_INSN(vmsleu_vv, MATCH_VMSLEU_VV, MASK_VMSLEU_VV) +DECLARE_INSN(vmsle_vv, MATCH_VMSLE_VV, MASK_VMSLE_VV) +DECLARE_INSN(vsaddu_vv, MATCH_VSADDU_VV, MASK_VSADDU_VV) +DECLARE_INSN(vsadd_vv, MATCH_VSADD_VV, MASK_VSADD_VV) +DECLARE_INSN(vssubu_vv, MATCH_VSSUBU_VV, MASK_VSSUBU_VV) +DECLARE_INSN(vssub_vv, MATCH_VSSUB_VV, MASK_VSSUB_VV) +DECLARE_INSN(vsll_vv, MATCH_VSLL_VV, MASK_VSLL_VV) +DECLARE_INSN(vsmul_vv, MATCH_VSMUL_VV, MASK_VSMUL_VV) +DECLARE_INSN(vsrl_vv, MATCH_VSRL_VV, MASK_VSRL_VV) +DECLARE_INSN(vsra_vv, MATCH_VSRA_VV, MASK_VSRA_VV) +DECLARE_INSN(vssrl_vv, MATCH_VSSRL_VV, MASK_VSSRL_VV) +DECLARE_INSN(vssra_vv, MATCH_VSSRA_VV, MASK_VSSRA_VV) +DECLARE_INSN(vnsrl_wv, MATCH_VNSRL_WV, MASK_VNSRL_WV) +DECLARE_INSN(vnsra_wv, MATCH_VNSRA_WV, MASK_VNSRA_WV) +DECLARE_INSN(vnclipu_wv, MATCH_VNCLIPU_WV, MASK_VNCLIPU_WV) +DECLARE_INSN(vnclip_wv, MATCH_VNCLIP_WV, MASK_VNCLIP_WV) +DECLARE_INSN(vwredsumu_vs, MATCH_VWREDSUMU_VS, MASK_VWREDSUMU_VS) +DECLARE_INSN(vwredsum_vs, MATCH_VWREDSUM_VS, MASK_VWREDSUM_VS) +DECLARE_INSN(vdotu_vv, MATCH_VDOTU_VV, MASK_VDOTU_VV) +DECLARE_INSN(vdot_vv, MATCH_VDOT_VV, MASK_VDOT_VV) +DECLARE_INSN(vqmaccu_vv, MATCH_VQMACCU_VV, MASK_VQMACCU_VV) +DECLARE_INSN(vqmacc_vv, MATCH_VQMACC_VV, MASK_VQMACC_VV) +DECLARE_INSN(vqmaccsu_vv, MATCH_VQMACCSU_VV, MASK_VQMACCSU_VV) +DECLARE_INSN(vadd_vi, MATCH_VADD_VI, MASK_VADD_VI) +DECLARE_INSN(vrsub_vi, MATCH_VRSUB_VI, MASK_VRSUB_VI) +DECLARE_INSN(vand_vi, MATCH_VAND_VI, MASK_VAND_VI) +DECLARE_INSN(vor_vi, MATCH_VOR_VI, MASK_VOR_VI) +DECLARE_INSN(vxor_vi, MATCH_VXOR_VI, MASK_VXOR_VI) +DECLARE_INSN(vrgather_vi, MATCH_VRGATHER_VI, MASK_VRGATHER_VI) +DECLARE_INSN(vslideup_vi, MATCH_VSLIDEUP_VI, MASK_VSLIDEUP_VI) +DECLARE_INSN(vslidedown_vi, MATCH_VSLIDEDOWN_VI, MASK_VSLIDEDOWN_VI) +DECLARE_INSN(vadc_vim, MATCH_VADC_VIM, MASK_VADC_VIM) +DECLARE_INSN(vmadc_vim, MATCH_VMADC_VIM, MASK_VMADC_VIM) +DECLARE_INSN(vmerge_vim, MATCH_VMERGE_VIM, MASK_VMERGE_VIM) +DECLARE_INSN(vmv_v_i, MATCH_VMV_V_I, MASK_VMV_V_I) +DECLARE_INSN(vmseq_vi, MATCH_VMSEQ_VI, MASK_VMSEQ_VI) +DECLARE_INSN(vmsne_vi, MATCH_VMSNE_VI, MASK_VMSNE_VI) +DECLARE_INSN(vmsleu_vi, MATCH_VMSLEU_VI, MASK_VMSLEU_VI) +DECLARE_INSN(vmsle_vi, MATCH_VMSLE_VI, MASK_VMSLE_VI) +DECLARE_INSN(vmsgtu_vi, MATCH_VMSGTU_VI, MASK_VMSGTU_VI) +DECLARE_INSN(vmsgt_vi, MATCH_VMSGT_VI, MASK_VMSGT_VI) +DECLARE_INSN(vsaddu_vi, MATCH_VSADDU_VI, MASK_VSADDU_VI) +DECLARE_INSN(vsadd_vi, MATCH_VSADD_VI, MASK_VSADD_VI) +DECLARE_INSN(vsll_vi, MATCH_VSLL_VI, MASK_VSLL_VI) +DECLARE_INSN(vmv1r_v, MATCH_VMV1R_V, MASK_VMV1R_V) +DECLARE_INSN(vmv2r_v, MATCH_VMV2R_V, MASK_VMV2R_V) +DECLARE_INSN(vmv4r_v, MATCH_VMV4R_V, MASK_VMV4R_V) +DECLARE_INSN(vmv8r_v, MATCH_VMV8R_V, MASK_VMV8R_V) +DECLARE_INSN(vsrl_vi, MATCH_VSRL_VI, MASK_VSRL_VI) +DECLARE_INSN(vsra_vi, MATCH_VSRA_VI, MASK_VSRA_VI) +DECLARE_INSN(vssrl_vi, MATCH_VSSRL_VI, MASK_VSSRL_VI) +DECLARE_INSN(vssra_vi, MATCH_VSSRA_VI, MASK_VSSRA_VI) +DECLARE_INSN(vnsrl_wi, MATCH_VNSRL_WI, MASK_VNSRL_WI) +DECLARE_INSN(vnsra_wi, MATCH_VNSRA_WI, MASK_VNSRA_WI) +DECLARE_INSN(vnclipu_wi, MATCH_VNCLIPU_WI, MASK_VNCLIPU_WI) +DECLARE_INSN(vnclip_wi, MATCH_VNCLIP_WI, MASK_VNCLIP_WI) +DECLARE_INSN(vredsum_vs, MATCH_VREDSUM_VS, MASK_VREDSUM_VS) +DECLARE_INSN(vredand_vs, MATCH_VREDAND_VS, MASK_VREDAND_VS) +DECLARE_INSN(vredor_vs, MATCH_VREDOR_VS, MASK_VREDOR_VS) +DECLARE_INSN(vredxor_vs, MATCH_VREDXOR_VS, MASK_VREDXOR_VS) +DECLARE_INSN(vredminu_vs, MATCH_VREDMINU_VS, MASK_VREDMINU_VS) +DECLARE_INSN(vredmin_vs, MATCH_VREDMIN_VS, MASK_VREDMIN_VS) +DECLARE_INSN(vredmaxu_vs, MATCH_VREDMAXU_VS, MASK_VREDMAXU_VS) +DECLARE_INSN(vredmax_vs, MATCH_VREDMAX_VS, MASK_VREDMAX_VS) +DECLARE_INSN(vaaddu_vv, MATCH_VAADDU_VV, MASK_VAADDU_VV) +DECLARE_INSN(vaadd_vv, MATCH_VAADD_VV, MASK_VAADD_VV) +DECLARE_INSN(vasubu_vv, MATCH_VASUBU_VV, MASK_VASUBU_VV) +DECLARE_INSN(vasub_vv, MATCH_VASUB_VV, MASK_VASUB_VV) +DECLARE_INSN(vmv_x_s, MATCH_VMV_X_S, MASK_VMV_X_S) +DECLARE_INSN(vcompress_vm, MATCH_VCOMPRESS_VM, MASK_VCOMPRESS_VM) +DECLARE_INSN(vmandnot_mm, MATCH_VMANDNOT_MM, MASK_VMANDNOT_MM) +DECLARE_INSN(vmand_mm, MATCH_VMAND_MM, MASK_VMAND_MM) +DECLARE_INSN(vmor_mm, MATCH_VMOR_MM, MASK_VMOR_MM) +DECLARE_INSN(vmxor_mm, MATCH_VMXOR_MM, MASK_VMXOR_MM) +DECLARE_INSN(vmornot_mm, MATCH_VMORNOT_MM, MASK_VMORNOT_MM) +DECLARE_INSN(vmnand_mm, MATCH_VMNAND_MM, MASK_VMNAND_MM) +DECLARE_INSN(vmnor_mm, MATCH_VMNOR_MM, MASK_VMNOR_MM) +DECLARE_INSN(vmxnor_mm, MATCH_VMXNOR_MM, MASK_VMXNOR_MM) +DECLARE_INSN(vmsbf_m, MATCH_VMSBF_M, MASK_VMSBF_M) +DECLARE_INSN(vmsof_m, MATCH_VMSOF_M, MASK_VMSOF_M) +DECLARE_INSN(vmsif_m, MATCH_VMSIF_M, MASK_VMSIF_M) +DECLARE_INSN(viota_m, MATCH_VIOTA_M, MASK_VIOTA_M) +DECLARE_INSN(vid_v, MATCH_VID_V, MASK_VID_V) +DECLARE_INSN(vpopc_m, MATCH_VPOPC_M, MASK_VPOPC_M) +DECLARE_INSN(vfirst_m, MATCH_VFIRST_M, MASK_VFIRST_M) +DECLARE_INSN(vdivu_vv, MATCH_VDIVU_VV, MASK_VDIVU_VV) +DECLARE_INSN(vdiv_vv, MATCH_VDIV_VV, MASK_VDIV_VV) +DECLARE_INSN(vremu_vv, MATCH_VREMU_VV, MASK_VREMU_VV) +DECLARE_INSN(vrem_vv, MATCH_VREM_VV, MASK_VREM_VV) +DECLARE_INSN(vmulhu_vv, MATCH_VMULHU_VV, MASK_VMULHU_VV) +DECLARE_INSN(vmul_vv, MATCH_VMUL_VV, MASK_VMUL_VV) +DECLARE_INSN(vmulhsu_vv, MATCH_VMULHSU_VV, MASK_VMULHSU_VV) +DECLARE_INSN(vmulh_vv, MATCH_VMULH_VV, MASK_VMULH_VV) +DECLARE_INSN(vmadd_vv, MATCH_VMADD_VV, MASK_VMADD_VV) +DECLARE_INSN(vnmsub_vv, MATCH_VNMSUB_VV, MASK_VNMSUB_VV) +DECLARE_INSN(vmacc_vv, MATCH_VMACC_VV, MASK_VMACC_VV) +DECLARE_INSN(vnmsac_vv, MATCH_VNMSAC_VV, MASK_VNMSAC_VV) +DECLARE_INSN(vwaddu_vv, MATCH_VWADDU_VV, MASK_VWADDU_VV) +DECLARE_INSN(vwadd_vv, MATCH_VWADD_VV, MASK_VWADD_VV) +DECLARE_INSN(vwsubu_vv, MATCH_VWSUBU_VV, MASK_VWSUBU_VV) +DECLARE_INSN(vwsub_vv, MATCH_VWSUB_VV, MASK_VWSUB_VV) +DECLARE_INSN(vwaddu_wv, MATCH_VWADDU_WV, MASK_VWADDU_WV) +DECLARE_INSN(vwadd_wv, MATCH_VWADD_WV, MASK_VWADD_WV) +DECLARE_INSN(vwsubu_wv, MATCH_VWSUBU_WV, MASK_VWSUBU_WV) +DECLARE_INSN(vwsub_wv, MATCH_VWSUB_WV, MASK_VWSUB_WV) +DECLARE_INSN(vwmulu_vv, MATCH_VWMULU_VV, MASK_VWMULU_VV) +DECLARE_INSN(vwmulsu_vv, MATCH_VWMULSU_VV, MASK_VWMULSU_VV) +DECLARE_INSN(vwmul_vv, MATCH_VWMUL_VV, MASK_VWMUL_VV) +DECLARE_INSN(vwmaccu_vv, MATCH_VWMACCU_VV, MASK_VWMACCU_VV) +DECLARE_INSN(vwmacc_vv, MATCH_VWMACC_VV, MASK_VWMACC_VV) +DECLARE_INSN(vwmaccsu_vv, MATCH_VWMACCSU_VV, MASK_VWMACCSU_VV) +DECLARE_INSN(vaaddu_vx, MATCH_VAADDU_VX, MASK_VAADDU_VX) +DECLARE_INSN(vaadd_vx, MATCH_VAADD_VX, MASK_VAADD_VX) +DECLARE_INSN(vasubu_vx, MATCH_VASUBU_VX, MASK_VASUBU_VX) +DECLARE_INSN(vasub_vx, MATCH_VASUB_VX, MASK_VASUB_VX) +DECLARE_INSN(vmv_s_x, MATCH_VMV_S_X, MASK_VMV_S_X) +DECLARE_INSN(vslide1up_vx, MATCH_VSLIDE1UP_VX, MASK_VSLIDE1UP_VX) +DECLARE_INSN(vslide1down_vx, MATCH_VSLIDE1DOWN_VX, MASK_VSLIDE1DOWN_VX) +DECLARE_INSN(vdivu_vx, MATCH_VDIVU_VX, MASK_VDIVU_VX) +DECLARE_INSN(vdiv_vx, MATCH_VDIV_VX, MASK_VDIV_VX) +DECLARE_INSN(vremu_vx, MATCH_VREMU_VX, MASK_VREMU_VX) +DECLARE_INSN(vrem_vx, MATCH_VREM_VX, MASK_VREM_VX) +DECLARE_INSN(vmulhu_vx, MATCH_VMULHU_VX, MASK_VMULHU_VX) +DECLARE_INSN(vmul_vx, MATCH_VMUL_VX, MASK_VMUL_VX) +DECLARE_INSN(vmulhsu_vx, MATCH_VMULHSU_VX, MASK_VMULHSU_VX) +DECLARE_INSN(vmulh_vx, MATCH_VMULH_VX, MASK_VMULH_VX) +DECLARE_INSN(vmadd_vx, MATCH_VMADD_VX, MASK_VMADD_VX) +DECLARE_INSN(vnmsub_vx, MATCH_VNMSUB_VX, MASK_VNMSUB_VX) +DECLARE_INSN(vmacc_vx, MATCH_VMACC_VX, MASK_VMACC_VX) +DECLARE_INSN(vnmsac_vx, MATCH_VNMSAC_VX, MASK_VNMSAC_VX) +DECLARE_INSN(vwaddu_vx, MATCH_VWADDU_VX, MASK_VWADDU_VX) +DECLARE_INSN(vwadd_vx, MATCH_VWADD_VX, MASK_VWADD_VX) +DECLARE_INSN(vwsubu_vx, MATCH_VWSUBU_VX, MASK_VWSUBU_VX) +DECLARE_INSN(vwsub_vx, MATCH_VWSUB_VX, MASK_VWSUB_VX) +DECLARE_INSN(vwaddu_wx, MATCH_VWADDU_WX, MASK_VWADDU_WX) +DECLARE_INSN(vwadd_wx, MATCH_VWADD_WX, MASK_VWADD_WX) +DECLARE_INSN(vwsubu_wx, MATCH_VWSUBU_WX, MASK_VWSUBU_WX) +DECLARE_INSN(vwsub_wx, MATCH_VWSUB_WX, MASK_VWSUB_WX) +DECLARE_INSN(vwmulu_vx, MATCH_VWMULU_VX, MASK_VWMULU_VX) +DECLARE_INSN(vwmulsu_vx, MATCH_VWMULSU_VX, MASK_VWMULSU_VX) +DECLARE_INSN(vwmul_vx, MATCH_VWMUL_VX, MASK_VWMUL_VX) +DECLARE_INSN(vwmaccu_vx, MATCH_VWMACCU_VX, MASK_VWMACCU_VX) +DECLARE_INSN(vwmacc_vx, MATCH_VWMACC_VX, MASK_VWMACC_VX) +DECLARE_INSN(vwmaccus_vx, MATCH_VWMACCUS_VX, MASK_VWMACCUS_VX) +DECLARE_INSN(vwmaccsu_vx, MATCH_VWMACCSU_VX, MASK_VWMACCSU_VX) +DECLARE_INSN(vamoswapw_v, MATCH_VAMOSWAPW_V, MASK_VAMOSWAPW_V) +DECLARE_INSN(vamoaddw_v, MATCH_VAMOADDW_V, MASK_VAMOADDW_V) +DECLARE_INSN(vamoxorw_v, MATCH_VAMOXORW_V, MASK_VAMOXORW_V) +DECLARE_INSN(vamoandw_v, MATCH_VAMOANDW_V, MASK_VAMOANDW_V) +DECLARE_INSN(vamoorw_v, MATCH_VAMOORW_V, MASK_VAMOORW_V) +DECLARE_INSN(vamominw_v, MATCH_VAMOMINW_V, MASK_VAMOMINW_V) +DECLARE_INSN(vamomaxw_v, MATCH_VAMOMAXW_V, MASK_VAMOMAXW_V) +DECLARE_INSN(vamominuw_v, MATCH_VAMOMINUW_V, MASK_VAMOMINUW_V) +DECLARE_INSN(vamomaxuw_v, MATCH_VAMOMAXUW_V, MASK_VAMOMAXUW_V) +DECLARE_INSN(vamoswape_v, MATCH_VAMOSWAPE_V, MASK_VAMOSWAPE_V) +DECLARE_INSN(vamoadde_v, MATCH_VAMOADDE_V, MASK_VAMOADDE_V) +DECLARE_INSN(vamoxore_v, MATCH_VAMOXORE_V, MASK_VAMOXORE_V) +DECLARE_INSN(vamoande_v, MATCH_VAMOANDE_V, MASK_VAMOANDE_V) +DECLARE_INSN(vamoore_v, MATCH_VAMOORE_V, MASK_VAMOORE_V) +DECLARE_INSN(vamomine_v, MATCH_VAMOMINE_V, MASK_VAMOMINE_V) +DECLARE_INSN(vamomaxe_v, MATCH_VAMOMAXE_V, MASK_VAMOMAXE_V) +DECLARE_INSN(vamominue_v, MATCH_VAMOMINUE_V, MASK_VAMOMINUE_V) +DECLARE_INSN(vamomaxue_v, MATCH_VAMOMAXUE_V, MASK_VAMOMAXUE_V) +DECLARE_INSN(vmvnfr_v, MATCH_VMVNFR_V, MASK_VMVNFR_V) +#endif +#ifdef DECLARE_CSR +DECLARE_CSR(fflags, CSR_FFLAGS) +DECLARE_CSR(frm, CSR_FRM) +DECLARE_CSR(fcsr, CSR_FCSR) +DECLARE_CSR(ustatus, CSR_USTATUS) +DECLARE_CSR(uie, CSR_UIE) +DECLARE_CSR(utvec, CSR_UTVEC) +DECLARE_CSR(vstart, CSR_VSTART) +DECLARE_CSR(vxsat, CSR_VXSAT) +DECLARE_CSR(vxrm, CSR_VXRM) +DECLARE_CSR(vcsr, CSR_VCSR) +DECLARE_CSR(uscratch, CSR_USCRATCH) +DECLARE_CSR(uepc, CSR_UEPC) +DECLARE_CSR(ucause, CSR_UCAUSE) +DECLARE_CSR(utval, CSR_UTVAL) +DECLARE_CSR(uip, CSR_UIP) +DECLARE_CSR(cycle, CSR_CYCLE) +DECLARE_CSR(time, CSR_TIME) +DECLARE_CSR(instret, CSR_INSTRET) +DECLARE_CSR(hpmcounter3, CSR_HPMCOUNTER3) +DECLARE_CSR(hpmcounter4, CSR_HPMCOUNTER4) +DECLARE_CSR(hpmcounter5, CSR_HPMCOUNTER5) +DECLARE_CSR(hpmcounter6, CSR_HPMCOUNTER6) +DECLARE_CSR(hpmcounter7, CSR_HPMCOUNTER7) +DECLARE_CSR(hpmcounter8, CSR_HPMCOUNTER8) +DECLARE_CSR(hpmcounter9, CSR_HPMCOUNTER9) +DECLARE_CSR(hpmcounter10, CSR_HPMCOUNTER10) +DECLARE_CSR(hpmcounter11, CSR_HPMCOUNTER11) +DECLARE_CSR(hpmcounter12, CSR_HPMCOUNTER12) +DECLARE_CSR(hpmcounter13, CSR_HPMCOUNTER13) +DECLARE_CSR(hpmcounter14, CSR_HPMCOUNTER14) +DECLARE_CSR(hpmcounter15, CSR_HPMCOUNTER15) +DECLARE_CSR(hpmcounter16, CSR_HPMCOUNTER16) +DECLARE_CSR(hpmcounter17, CSR_HPMCOUNTER17) +DECLARE_CSR(hpmcounter18, CSR_HPMCOUNTER18) +DECLARE_CSR(hpmcounter19, CSR_HPMCOUNTER19) +DECLARE_CSR(hpmcounter20, CSR_HPMCOUNTER20) +DECLARE_CSR(hpmcounter21, CSR_HPMCOUNTER21) +DECLARE_CSR(hpmcounter22, CSR_HPMCOUNTER22) +DECLARE_CSR(hpmcounter23, CSR_HPMCOUNTER23) +DECLARE_CSR(hpmcounter24, CSR_HPMCOUNTER24) +DECLARE_CSR(hpmcounter25, CSR_HPMCOUNTER25) +DECLARE_CSR(hpmcounter26, CSR_HPMCOUNTER26) +DECLARE_CSR(hpmcounter27, CSR_HPMCOUNTER27) +DECLARE_CSR(hpmcounter28, CSR_HPMCOUNTER28) +DECLARE_CSR(hpmcounter29, CSR_HPMCOUNTER29) +DECLARE_CSR(hpmcounter30, CSR_HPMCOUNTER30) +DECLARE_CSR(hpmcounter31, CSR_HPMCOUNTER31) +DECLARE_CSR(vl, CSR_VL) +DECLARE_CSR(vtype, CSR_VTYPE) +DECLARE_CSR(vlenb, CSR_VLENB) +DECLARE_CSR(sstatus, CSR_SSTATUS) +DECLARE_CSR(sedeleg, CSR_SEDELEG) +DECLARE_CSR(sideleg, CSR_SIDELEG) +DECLARE_CSR(sie, CSR_SIE) +DECLARE_CSR(stvec, CSR_STVEC) +DECLARE_CSR(scounteren, CSR_SCOUNTEREN) +DECLARE_CSR(sscratch, CSR_SSCRATCH) +DECLARE_CSR(sepc, CSR_SEPC) +DECLARE_CSR(scause, CSR_SCAUSE) +DECLARE_CSR(stval, CSR_STVAL) +DECLARE_CSR(sip, CSR_SIP) +DECLARE_CSR(satp, CSR_SATP) +DECLARE_CSR(vsstatus, CSR_VSSTATUS) +DECLARE_CSR(vsie, CSR_VSIE) +DECLARE_CSR(vstvec, CSR_VSTVEC) +DECLARE_CSR(vsscratch, CSR_VSSCRATCH) +DECLARE_CSR(vsepc, CSR_VSEPC) +DECLARE_CSR(vscause, CSR_VSCAUSE) +DECLARE_CSR(vstval, CSR_VSTVAL) +DECLARE_CSR(vsip, CSR_VSIP) +DECLARE_CSR(vsatp, CSR_VSATP) +DECLARE_CSR(hstatus, CSR_HSTATUS) +DECLARE_CSR(hedeleg, CSR_HEDELEG) +DECLARE_CSR(hideleg, CSR_HIDELEG) +DECLARE_CSR(hie, CSR_HIE) +DECLARE_CSR(htimedelta, CSR_HTIMEDELTA) +DECLARE_CSR(hcounteren, CSR_HCOUNTEREN) +DECLARE_CSR(hgeie, CSR_HGEIE) +DECLARE_CSR(htval, CSR_HTVAL) +DECLARE_CSR(hip, CSR_HIP) +DECLARE_CSR(hvip, CSR_HVIP) +DECLARE_CSR(htinst, CSR_HTINST) +DECLARE_CSR(hgatp, CSR_HGATP) +DECLARE_CSR(hgeip, CSR_HGEIP) +DECLARE_CSR(utvt, CSR_UTVT) +DECLARE_CSR(unxti, CSR_UNXTI) +DECLARE_CSR(uintstatus, CSR_UINTSTATUS) +DECLARE_CSR(uscratchcsw, CSR_USCRATCHCSW) +DECLARE_CSR(uscratchcswl, CSR_USCRATCHCSWL) +DECLARE_CSR(stvt, CSR_STVT) +DECLARE_CSR(snxti, CSR_SNXTI) +DECLARE_CSR(sintstatus, CSR_SINTSTATUS) +DECLARE_CSR(sscratchcsw, CSR_SSCRATCHCSW) +DECLARE_CSR(sscratchcswl, CSR_SSCRATCHCSWL) +DECLARE_CSR(mtvt, CSR_MTVT) +DECLARE_CSR(mnxti, CSR_MNXTI) +DECLARE_CSR(mintstatus, CSR_MINTSTATUS) +DECLARE_CSR(mscratchcsw, CSR_MSCRATCHCSW) +DECLARE_CSR(mscratchcswl, CSR_MSCRATCHCSWL) +DECLARE_CSR(mstatus, CSR_MSTATUS) +DECLARE_CSR(misa, CSR_MISA) +DECLARE_CSR(medeleg, CSR_MEDELEG) +DECLARE_CSR(mideleg, CSR_MIDELEG) +DECLARE_CSR(mie, CSR_MIE) +DECLARE_CSR(mtvec, CSR_MTVEC) +DECLARE_CSR(mcounteren, CSR_MCOUNTEREN) +DECLARE_CSR(mcountinhibit, CSR_MCOUNTINHIBIT) +DECLARE_CSR(mscratch, CSR_MSCRATCH) +DECLARE_CSR(mepc, CSR_MEPC) +DECLARE_CSR(mcause, CSR_MCAUSE) +DECLARE_CSR(mtval, CSR_MTVAL) +DECLARE_CSR(mip, CSR_MIP) +DECLARE_CSR(mtinst, CSR_MTINST) +DECLARE_CSR(mtval2, CSR_MTVAL2) +DECLARE_CSR(pmpcfg0, CSR_PMPCFG0) +DECLARE_CSR(pmpcfg1, CSR_PMPCFG1) +DECLARE_CSR(pmpcfg2, CSR_PMPCFG2) +DECLARE_CSR(pmpcfg3, CSR_PMPCFG3) +DECLARE_CSR(pmpaddr0, CSR_PMPADDR0) +DECLARE_CSR(pmpaddr1, CSR_PMPADDR1) +DECLARE_CSR(pmpaddr2, CSR_PMPADDR2) +DECLARE_CSR(pmpaddr3, CSR_PMPADDR3) +DECLARE_CSR(pmpaddr4, CSR_PMPADDR4) +DECLARE_CSR(pmpaddr5, CSR_PMPADDR5) +DECLARE_CSR(pmpaddr6, CSR_PMPADDR6) +DECLARE_CSR(pmpaddr7, CSR_PMPADDR7) +DECLARE_CSR(pmpaddr8, CSR_PMPADDR8) +DECLARE_CSR(pmpaddr9, CSR_PMPADDR9) +DECLARE_CSR(pmpaddr10, CSR_PMPADDR10) +DECLARE_CSR(pmpaddr11, CSR_PMPADDR11) +DECLARE_CSR(pmpaddr12, CSR_PMPADDR12) +DECLARE_CSR(pmpaddr13, CSR_PMPADDR13) +DECLARE_CSR(pmpaddr14, CSR_PMPADDR14) +DECLARE_CSR(pmpaddr15, CSR_PMPADDR15) +DECLARE_CSR(tselect, CSR_TSELECT) +DECLARE_CSR(tdata1, CSR_TDATA1) +DECLARE_CSR(tdata2, CSR_TDATA2) +DECLARE_CSR(tdata3, CSR_TDATA3) +DECLARE_CSR(dcsr, CSR_DCSR) +DECLARE_CSR(dpc, CSR_DPC) +DECLARE_CSR(dscratch0, CSR_DSCRATCH0) +DECLARE_CSR(dscratch1, CSR_DSCRATCH1) +DECLARE_CSR(mcycle, CSR_MCYCLE) +DECLARE_CSR(minstret, CSR_MINSTRET) +DECLARE_CSR(mhpmcounter3, CSR_MHPMCOUNTER3) +DECLARE_CSR(mhpmcounter4, CSR_MHPMCOUNTER4) +DECLARE_CSR(mhpmcounter5, CSR_MHPMCOUNTER5) +DECLARE_CSR(mhpmcounter6, CSR_MHPMCOUNTER6) +DECLARE_CSR(mhpmcounter7, CSR_MHPMCOUNTER7) +DECLARE_CSR(mhpmcounter8, CSR_MHPMCOUNTER8) +DECLARE_CSR(mhpmcounter9, CSR_MHPMCOUNTER9) +DECLARE_CSR(mhpmcounter10, CSR_MHPMCOUNTER10) +DECLARE_CSR(mhpmcounter11, CSR_MHPMCOUNTER11) +DECLARE_CSR(mhpmcounter12, CSR_MHPMCOUNTER12) +DECLARE_CSR(mhpmcounter13, CSR_MHPMCOUNTER13) +DECLARE_CSR(mhpmcounter14, CSR_MHPMCOUNTER14) +DECLARE_CSR(mhpmcounter15, CSR_MHPMCOUNTER15) +DECLARE_CSR(mhpmcounter16, CSR_MHPMCOUNTER16) +DECLARE_CSR(mhpmcounter17, CSR_MHPMCOUNTER17) +DECLARE_CSR(mhpmcounter18, CSR_MHPMCOUNTER18) +DECLARE_CSR(mhpmcounter19, CSR_MHPMCOUNTER19) +DECLARE_CSR(mhpmcounter20, CSR_MHPMCOUNTER20) +DECLARE_CSR(mhpmcounter21, CSR_MHPMCOUNTER21) +DECLARE_CSR(mhpmcounter22, CSR_MHPMCOUNTER22) +DECLARE_CSR(mhpmcounter23, CSR_MHPMCOUNTER23) +DECLARE_CSR(mhpmcounter24, CSR_MHPMCOUNTER24) +DECLARE_CSR(mhpmcounter25, CSR_MHPMCOUNTER25) +DECLARE_CSR(mhpmcounter26, CSR_MHPMCOUNTER26) +DECLARE_CSR(mhpmcounter27, CSR_MHPMCOUNTER27) +DECLARE_CSR(mhpmcounter28, CSR_MHPMCOUNTER28) +DECLARE_CSR(mhpmcounter29, CSR_MHPMCOUNTER29) +DECLARE_CSR(mhpmcounter30, CSR_MHPMCOUNTER30) +DECLARE_CSR(mhpmcounter31, CSR_MHPMCOUNTER31) +DECLARE_CSR(mhpmevent3, CSR_MHPMEVENT3) +DECLARE_CSR(mhpmevent4, CSR_MHPMEVENT4) +DECLARE_CSR(mhpmevent5, CSR_MHPMEVENT5) +DECLARE_CSR(mhpmevent6, CSR_MHPMEVENT6) +DECLARE_CSR(mhpmevent7, CSR_MHPMEVENT7) +DECLARE_CSR(mhpmevent8, CSR_MHPMEVENT8) +DECLARE_CSR(mhpmevent9, CSR_MHPMEVENT9) +DECLARE_CSR(mhpmevent10, CSR_MHPMEVENT10) +DECLARE_CSR(mhpmevent11, CSR_MHPMEVENT11) +DECLARE_CSR(mhpmevent12, CSR_MHPMEVENT12) +DECLARE_CSR(mhpmevent13, CSR_MHPMEVENT13) +DECLARE_CSR(mhpmevent14, CSR_MHPMEVENT14) +DECLARE_CSR(mhpmevent15, CSR_MHPMEVENT15) +DECLARE_CSR(mhpmevent16, CSR_MHPMEVENT16) +DECLARE_CSR(mhpmevent17, CSR_MHPMEVENT17) +DECLARE_CSR(mhpmevent18, CSR_MHPMEVENT18) +DECLARE_CSR(mhpmevent19, CSR_MHPMEVENT19) +DECLARE_CSR(mhpmevent20, CSR_MHPMEVENT20) +DECLARE_CSR(mhpmevent21, CSR_MHPMEVENT21) +DECLARE_CSR(mhpmevent22, CSR_MHPMEVENT22) +DECLARE_CSR(mhpmevent23, CSR_MHPMEVENT23) +DECLARE_CSR(mhpmevent24, CSR_MHPMEVENT24) +DECLARE_CSR(mhpmevent25, CSR_MHPMEVENT25) +DECLARE_CSR(mhpmevent26, CSR_MHPMEVENT26) +DECLARE_CSR(mhpmevent27, CSR_MHPMEVENT27) +DECLARE_CSR(mhpmevent28, CSR_MHPMEVENT28) +DECLARE_CSR(mhpmevent29, CSR_MHPMEVENT29) +DECLARE_CSR(mhpmevent30, CSR_MHPMEVENT30) +DECLARE_CSR(mhpmevent31, CSR_MHPMEVENT31) +DECLARE_CSR(mvendorid, CSR_MVENDORID) +DECLARE_CSR(marchid, CSR_MARCHID) +DECLARE_CSR(mimpid, CSR_MIMPID) +DECLARE_CSR(mhartid, CSR_MHARTID) +DECLARE_CSR(htimedeltah, CSR_HTIMEDELTAH) +DECLARE_CSR(cycleh, CSR_CYCLEH) +DECLARE_CSR(timeh, CSR_TIMEH) +DECLARE_CSR(instreth, CSR_INSTRETH) +DECLARE_CSR(hpmcounter3h, CSR_HPMCOUNTER3H) +DECLARE_CSR(hpmcounter4h, CSR_HPMCOUNTER4H) +DECLARE_CSR(hpmcounter5h, CSR_HPMCOUNTER5H) +DECLARE_CSR(hpmcounter6h, CSR_HPMCOUNTER6H) +DECLARE_CSR(hpmcounter7h, CSR_HPMCOUNTER7H) +DECLARE_CSR(hpmcounter8h, CSR_HPMCOUNTER8H) +DECLARE_CSR(hpmcounter9h, CSR_HPMCOUNTER9H) +DECLARE_CSR(hpmcounter10h, CSR_HPMCOUNTER10H) +DECLARE_CSR(hpmcounter11h, CSR_HPMCOUNTER11H) +DECLARE_CSR(hpmcounter12h, CSR_HPMCOUNTER12H) +DECLARE_CSR(hpmcounter13h, CSR_HPMCOUNTER13H) +DECLARE_CSR(hpmcounter14h, CSR_HPMCOUNTER14H) +DECLARE_CSR(hpmcounter15h, CSR_HPMCOUNTER15H) +DECLARE_CSR(hpmcounter16h, CSR_HPMCOUNTER16H) +DECLARE_CSR(hpmcounter17h, CSR_HPMCOUNTER17H) +DECLARE_CSR(hpmcounter18h, CSR_HPMCOUNTER18H) +DECLARE_CSR(hpmcounter19h, CSR_HPMCOUNTER19H) +DECLARE_CSR(hpmcounter20h, CSR_HPMCOUNTER20H) +DECLARE_CSR(hpmcounter21h, CSR_HPMCOUNTER21H) +DECLARE_CSR(hpmcounter22h, CSR_HPMCOUNTER22H) +DECLARE_CSR(hpmcounter23h, CSR_HPMCOUNTER23H) +DECLARE_CSR(hpmcounter24h, CSR_HPMCOUNTER24H) +DECLARE_CSR(hpmcounter25h, CSR_HPMCOUNTER25H) +DECLARE_CSR(hpmcounter26h, CSR_HPMCOUNTER26H) +DECLARE_CSR(hpmcounter27h, CSR_HPMCOUNTER27H) +DECLARE_CSR(hpmcounter28h, CSR_HPMCOUNTER28H) +DECLARE_CSR(hpmcounter29h, CSR_HPMCOUNTER29H) +DECLARE_CSR(hpmcounter30h, CSR_HPMCOUNTER30H) +DECLARE_CSR(hpmcounter31h, CSR_HPMCOUNTER31H) +DECLARE_CSR(mstatush, CSR_MSTATUSH) +DECLARE_CSR(mcycleh, CSR_MCYCLEH) +DECLARE_CSR(minstreth, CSR_MINSTRETH) +DECLARE_CSR(mhpmcounter3h, CSR_MHPMCOUNTER3H) +DECLARE_CSR(mhpmcounter4h, CSR_MHPMCOUNTER4H) +DECLARE_CSR(mhpmcounter5h, CSR_MHPMCOUNTER5H) +DECLARE_CSR(mhpmcounter6h, CSR_MHPMCOUNTER6H) +DECLARE_CSR(mhpmcounter7h, CSR_MHPMCOUNTER7H) +DECLARE_CSR(mhpmcounter8h, CSR_MHPMCOUNTER8H) +DECLARE_CSR(mhpmcounter9h, CSR_MHPMCOUNTER9H) +DECLARE_CSR(mhpmcounter10h, CSR_MHPMCOUNTER10H) +DECLARE_CSR(mhpmcounter11h, CSR_MHPMCOUNTER11H) +DECLARE_CSR(mhpmcounter12h, CSR_MHPMCOUNTER12H) +DECLARE_CSR(mhpmcounter13h, CSR_MHPMCOUNTER13H) +DECLARE_CSR(mhpmcounter14h, CSR_MHPMCOUNTER14H) +DECLARE_CSR(mhpmcounter15h, CSR_MHPMCOUNTER15H) +DECLARE_CSR(mhpmcounter16h, CSR_MHPMCOUNTER16H) +DECLARE_CSR(mhpmcounter17h, CSR_MHPMCOUNTER17H) +DECLARE_CSR(mhpmcounter18h, CSR_MHPMCOUNTER18H) +DECLARE_CSR(mhpmcounter19h, CSR_MHPMCOUNTER19H) +DECLARE_CSR(mhpmcounter20h, CSR_MHPMCOUNTER20H) +DECLARE_CSR(mhpmcounter21h, CSR_MHPMCOUNTER21H) +DECLARE_CSR(mhpmcounter22h, CSR_MHPMCOUNTER22H) +DECLARE_CSR(mhpmcounter23h, CSR_MHPMCOUNTER23H) +DECLARE_CSR(mhpmcounter24h, CSR_MHPMCOUNTER24H) +DECLARE_CSR(mhpmcounter25h, CSR_MHPMCOUNTER25H) +DECLARE_CSR(mhpmcounter26h, CSR_MHPMCOUNTER26H) +DECLARE_CSR(mhpmcounter27h, CSR_MHPMCOUNTER27H) +DECLARE_CSR(mhpmcounter28h, CSR_MHPMCOUNTER28H) +DECLARE_CSR(mhpmcounter29h, CSR_MHPMCOUNTER29H) +DECLARE_CSR(mhpmcounter30h, CSR_MHPMCOUNTER30H) +DECLARE_CSR(mhpmcounter31h, CSR_MHPMCOUNTER31H) +#endif +#ifdef DECLARE_CAUSE +DECLARE_CAUSE("misaligned fetch", CAUSE_MISALIGNED_FETCH) +DECLARE_CAUSE("fetch access", CAUSE_FETCH_ACCESS) +DECLARE_CAUSE("illegal instruction", CAUSE_ILLEGAL_INSTRUCTION) +DECLARE_CAUSE("breakpoint", CAUSE_BREAKPOINT) +DECLARE_CAUSE("misaligned load", CAUSE_MISALIGNED_LOAD) +DECLARE_CAUSE("load access", CAUSE_LOAD_ACCESS) +DECLARE_CAUSE("misaligned store", CAUSE_MISALIGNED_STORE) +DECLARE_CAUSE("store access", CAUSE_STORE_ACCESS) +DECLARE_CAUSE("user_ecall", CAUSE_USER_ECALL) +DECLARE_CAUSE("supervisor_ecall", CAUSE_SUPERVISOR_ECALL) +DECLARE_CAUSE("hypervisor_ecall", CAUSE_HYPERVISOR_ECALL) +DECLARE_CAUSE("machine_ecall", CAUSE_MACHINE_ECALL) +DECLARE_CAUSE("fetch page fault", CAUSE_FETCH_PAGE_FAULT) +DECLARE_CAUSE("load page fault", CAUSE_LOAD_PAGE_FAULT) +DECLARE_CAUSE("store page fault", CAUSE_STORE_PAGE_FAULT) +#endif diff --git a/examples/C/common/syscalls.c b/examples/C/common/syscalls.c new file mode 100644 index 000000000..39547b3d0 --- /dev/null +++ b/examples/C/common/syscalls.c @@ -0,0 +1,469 @@ +// See LICENSE for license details. + +#include +#include +#include +#include +#include +#include +#include "util.h" + +#define SYS_write 64 + +#undef strcmp + +extern volatile uint64_t tohost; +extern volatile uint64_t fromhost; + +static uintptr_t syscall(uintptr_t which, uint64_t arg0, uint64_t arg1, uint64_t arg2) +{ + volatile uint64_t magic_mem[8] __attribute__((aligned(64))); + magic_mem[0] = which; + magic_mem[1] = arg0; + magic_mem[2] = arg1; + magic_mem[3] = arg2; + __sync_synchronize(); + + tohost = (uintptr_t)magic_mem; + while (fromhost == 0) + ; + fromhost = 0; + + __sync_synchronize(); + return magic_mem[0]; +} + +#define NUM_COUNTERS 2 +static uintptr_t counters[NUM_COUNTERS]; +static char* counter_names[NUM_COUNTERS]; + +void setStats(int enable) +{ + int i = 0; +#define READ_CTR(name) do { \ + while (i >= NUM_COUNTERS) ; \ + uintptr_t csr = read_csr(name); \ + if (!enable) { csr -= counters[i]; counter_names[i] = #name; } \ + counters[i++] = csr; \ + } while (0) + + READ_CTR(mcycle); + READ_CTR(minstret); + +#undef READ_CTR +} + +void __attribute__((noreturn)) tohost_exit(uintptr_t code) +{ + tohost = (code << 1) | 1; + while (1); +} + +uintptr_t __attribute__((weak)) handle_trap(uintptr_t cause, uintptr_t epc, uintptr_t regs[32]) +{ + tohost_exit(1337); +} + +void exit(int code) +{ + tohost_exit(code); +} + +void abort() +{ + exit(128 + SIGABRT); +} + +void printstr(const char* s) +{ + syscall(SYS_write, 1, (uintptr_t)s, strlen(s)); +} + +void __attribute__((weak)) thread_entry(int cid, int nc) +{ + // multi-threaded programs override this function. + // for the case of single-threaded programs, only let core 0 proceed. + while (cid != 0); +} + +int __attribute__((weak)) main(int argc, char** argv) +{ + // single-threaded programs override this function. + printstr("Implement main(), foo!\n"); + return -1; +} + +static void init_tls() +{ + register void* thread_pointer asm("tp"); + extern char _tdata_begin, _tdata_end, _tbss_end; + size_t tdata_size = &_tdata_end - &_tdata_begin; + memcpy(thread_pointer, &_tdata_begin, tdata_size); + size_t tbss_size = &_tbss_end - &_tdata_end; + memset(thread_pointer + tdata_size, 0, tbss_size); +} + +void _init(int cid, int nc) +{ + init_tls(); + thread_entry(cid, nc); + + // only single-threaded programs should ever get here. + int ret = main(0, 0); + + char buf[NUM_COUNTERS * 32] __attribute__((aligned(64))); + char* pbuf = buf; + for (int i = 0; i < NUM_COUNTERS; i++) + if (counters[i]) + pbuf += sprintf(pbuf, "%s = %d\n", counter_names[i], counters[i]); + if (pbuf != buf) + printstr(buf); + + exit(ret); +} + +#undef putchar +int putchar(int ch) +{ + static __thread char buf[64] __attribute__((aligned(64))); + static __thread int buflen = 0; + + buf[buflen++] = ch; + + if (ch == '\n' || buflen == sizeof(buf)) + { + syscall(SYS_write, 1, (uintptr_t)buf, buflen); + buflen = 0; + } + + return 0; +} + +void printhex(uint64_t x) +{ + char str[17]; + int i; + for (i = 0; i < 16; i++) + { + str[15-i] = (x & 0xF) + ((x & 0xF) < 10 ? '0' : 'a'-10); + x >>= 4; + } + str[16] = 0; + + printstr(str); +} + +static inline void printnum(void (*putch)(int, void**), void **putdat, + unsigned long long num, unsigned base, int width, int padc) +{ + unsigned digs[sizeof(num)*CHAR_BIT]; + int pos = 0; + + while (1) + { + digs[pos++] = num % base; + if (num < base) + break; + num /= base; + } + + while (width-- > pos) + putch(padc, putdat); + + while (pos-- > 0) + putch(digs[pos] + (digs[pos] >= 10 ? 'a' - 10 : '0'), putdat); +} + +static unsigned long long getuint(va_list *ap, int lflag) +{ + if (lflag >= 2) + return va_arg(*ap, unsigned long long); + else if (lflag) + return va_arg(*ap, unsigned long); + else + return va_arg(*ap, unsigned int); +} + +static long long getint(va_list *ap, int lflag) +{ + if (lflag >= 2) + return va_arg(*ap, long long); + else if (lflag) + return va_arg(*ap, long); + else + return va_arg(*ap, int); +} + +static void vprintfmt(void (*putch)(int, void**), void **putdat, const char *fmt, va_list ap) +{ + register const char* p; + const char* last_fmt; + register int ch, err; + unsigned long long num; + int base, lflag, width, precision, altflag; + char padc; + + while (1) { + while ((ch = *(unsigned char *) fmt) != '%') { + if (ch == '\0') + return; + fmt++; + putch(ch, putdat); + } + fmt++; + + // Process a %-escape sequence + last_fmt = fmt; + padc = ' '; + width = -1; + precision = -1; + lflag = 0; + altflag = 0; + reswitch: + switch (ch = *(unsigned char *) fmt++) { + + // flag to pad on the right + case '-': + padc = '-'; + goto reswitch; + + // flag to pad with 0's instead of spaces + case '0': + padc = '0'; + goto reswitch; + + // width field + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + for (precision = 0; ; ++fmt) { + precision = precision * 10 + ch - '0'; + ch = *fmt; + if (ch < '0' || ch > '9') + break; + } + goto process_precision; + + case '*': + precision = va_arg(ap, int); + goto process_precision; + + case '.': + if (width < 0) + width = 0; + goto reswitch; + + case '#': + altflag = 1; + goto reswitch; + + process_precision: + if (width < 0) + width = precision, precision = -1; + goto reswitch; + + // long flag (doubled for long long) + case 'l': + lflag++; + goto reswitch; + + // character + case 'c': + putch(va_arg(ap, int), putdat); + break; + + // string + case 's': + if ((p = va_arg(ap, char *)) == NULL) + p = "(null)"; + if (width > 0 && padc != '-') + for (width -= strnlen(p, precision); width > 0; width--) + putch(padc, putdat); + for (; (ch = *p) != '\0' && (precision < 0 || --precision >= 0); width--) { + putch(ch, putdat); + p++; + } + for (; width > 0; width--) + putch(' ', putdat); + break; + + // (signed) decimal + case 'd': + num = getint(&ap, lflag); + if ((long long) num < 0) { + putch('-', putdat); + num = -(long long) num; + } + base = 10; + goto signed_number; + + // unsigned decimal + case 'u': + base = 10; + goto unsigned_number; + + // (unsigned) octal + case 'o': + // should do something with padding so it's always 3 octits + base = 8; + goto unsigned_number; + + // pointer + case 'p': + static_assert(sizeof(long) == sizeof(void*)); + lflag = 1; + putch('0', putdat); + putch('x', putdat); + /* fall through to 'x' */ + + // (unsigned) hexadecimal + case 'x': + base = 16; + unsigned_number: + num = getuint(&ap, lflag); + signed_number: + printnum(putch, putdat, num, base, width, padc); + break; + + // escaped '%' character + case '%': + putch(ch, putdat); + break; + + // unrecognized escape sequence - just print it literally + default: + putch('%', putdat); + fmt = last_fmt; + break; + } + } +} + +int printf(const char* fmt, ...) +{ + va_list ap; + va_start(ap, fmt); + + vprintfmt((void*)putchar, 0, fmt, ap); + + va_end(ap); + return 0; // incorrect return value, but who cares, anyway? +} + +int sprintf(char* str, const char* fmt, ...) +{ + va_list ap; + char* str0 = str; + va_start(ap, fmt); + + void sprintf_putch(int ch, void** data) + { + char** pstr = (char**)data; + **pstr = ch; + (*pstr)++; + } + + vprintfmt(sprintf_putch, (void**)&str, fmt, ap); + *str = 0; + + va_end(ap); + return str - str0; +} + +void* memcpy(void* dest, const void* src, size_t len) +{ + if ((((uintptr_t)dest | (uintptr_t)src | len) & (sizeof(uintptr_t)-1)) == 0) { + const uintptr_t* s = src; + uintptr_t *d = dest; + while (d < (uintptr_t*)(dest + len)) + *d++ = *s++; + } else { + const char* s = src; + char *d = dest; + while (d < (char*)(dest + len)) + *d++ = *s++; + } + return dest; +} + +void* memset(void* dest, int byte, size_t len) +{ + if ((((uintptr_t)dest | len) & (sizeof(uintptr_t)-1)) == 0) { + uintptr_t word = byte & 0xFF; + word |= word << 8; + word |= word << 16; + word |= word << 16 << 16; + + uintptr_t *d = dest; + while (d < (uintptr_t*)(dest + len)) + *d++ = word; + } else { + char *d = dest; + while (d < (char*)(dest + len)) + *d++ = byte; + } + return dest; +} + +size_t strlen(const char *s) +{ + const char *p = s; + while (*p) + p++; + return p - s; +} + +size_t strnlen(const char *s, size_t n) +{ + const char *p = s; + while (n-- && *p) + p++; + return p - s; +} + +int strcmp(const char* s1, const char* s2) +{ + unsigned char c1, c2; + + do { + c1 = *s1++; + c2 = *s2++; + } while (c1 != 0 && c1 == c2); + + return c1 - c2; +} + +char* strcpy(char* dest, const char* src) +{ + char* d = dest; + while ((*d++ = *src++)) + ; + return dest; +} + +long atol(const char* str) +{ + long res = 0; + int sign = 0; + + while (*str == ' ') + str++; + + if (*str == '-' || *str == '+') { + sign = *str == '-'; + str++; + } + + while (*str) { + res *= 10; + res += *str++ - '0'; + } + + return sign ? -res : res; +} diff --git a/examples/C/common/test.ld b/examples/C/common/test.ld new file mode 100644 index 000000000..a50b017e8 --- /dev/null +++ b/examples/C/common/test.ld @@ -0,0 +1,66 @@ +/*======================================================================*/ +/* Proxy kernel linker script */ +/*======================================================================*/ +/* This is the linker script used when building the proxy kernel. */ + +/*----------------------------------------------------------------------*/ +/* Setup */ +/*----------------------------------------------------------------------*/ + +/* The OUTPUT_ARCH command specifies the machine architecture where the + argument is one of the names used in the BFD library. More + specifically one of the entires in bfd/cpu-mips.c */ + +OUTPUT_ARCH( "riscv" ) +ENTRY(_start) + +/*----------------------------------------------------------------------*/ +/* Sections */ +/*----------------------------------------------------------------------*/ + +SECTIONS +{ + + /* text: test code section */ + . = 0x80000000; + .text.init : { *(.text.init) } + + . = ALIGN(0x1000); + .tohost : { *(.tohost) } + + . = ALIGN(0x1000); + .text : { *(.text) } + + /* data segment */ + .data : { *(.data) } + + .sdata : { + __global_pointer$ = . + 0x800; + *(.srodata.cst16) *(.srodata.cst8) *(.srodata.cst4) *(.srodata.cst2) *(.srodata*) + *(.sdata .sdata.* .gnu.linkonce.s.*) + } + + /* bss segment */ + .sbss : { + *(.sbss .sbss.* .gnu.linkonce.sb.*) + *(.scommon) + } + .bss : { *(.bss) } + + /* thread-local data segment */ + .tdata : + { + _tdata_begin = .; + *(.tdata) + _tdata_end = .; + } + .tbss : + { + *(.tbss) + _tbss_end = .; + } + + /* End of uninitalized data segement */ + _end = .; +} + diff --git a/examples/C/common/util.h b/examples/C/common/util.h new file mode 100644 index 000000000..081cfd634 --- /dev/null +++ b/examples/C/common/util.h @@ -0,0 +1,90 @@ +// See LICENSE for license details. + +#ifndef __UTIL_H +#define __UTIL_H + +extern void setStats(int enable); + +#include + +#define static_assert(cond) switch(0) { case 0: case !!(long)(cond): ; } + +static int verify(int n, const volatile int* test, const int* verify) +{ + int i; + // Unrolled for faster verification + for (i = 0; i < n/2*2; i+=2) + { + int t0 = test[i], t1 = test[i+1]; + int v0 = verify[i], v1 = verify[i+1]; + if (t0 != v0) return i+1; + if (t1 != v1) return i+2; + } + if (n % 2 != 0 && test[n-1] != verify[n-1]) + return n; + return 0; +} + +static int verifyDouble(int n, const volatile double* test, const double* verify) +{ + int i; + // Unrolled for faster verification + for (i = 0; i < n/2*2; i+=2) + { + double t0 = test[i], t1 = test[i+1]; + double v0 = verify[i], v1 = verify[i+1]; + int eq1 = t0 == v0, eq2 = t1 == v1; + if (!(eq1 & eq2)) return i+1+eq1; + } + if (n % 2 != 0 && test[n-1] != verify[n-1]) + return n; + return 0; +} + +static void __attribute__((noinline)) barrier(int ncores) +{ + static volatile int sense; + static volatile int count; + static __thread int threadsense; + + __sync_synchronize(); + + threadsense = !threadsense; + if (__sync_fetch_and_add(&count, 1) == ncores-1) + { + count = 0; + sense = threadsense; + } + else while(sense != threadsense) + ; + + __sync_synchronize(); +} + +static uint64_t lfsr(uint64_t x) +{ + uint64_t bit = (x ^ (x >> 1)) & 1; + return (x >> 1) | (bit << 62); +} + +static uintptr_t insn_len(uintptr_t pc) +{ + return (*(unsigned short*)pc & 3) ? 4 : 2; +} + +#ifdef __riscv +#include "encoding.h" +#endif + +#define stringify_1(s) #s +#define stringify(s) stringify_1(s) +#define stats(code, iter) do { \ + unsigned long _c = -read_csr(mcycle), _i = -read_csr(minstret); \ + code; \ + _c += read_csr(mcycle), _i += read_csr(minstret); \ + if (cid == 0) \ + printf("\n%s: %ld cycles, %ld.%ld cycles/iter, %ld.%ld CPI\n", \ + stringify(code), _c, _c/iter, 10*_c/iter%10, _c/_i, 10*_c/_i%10); \ + } while(0) + +#endif //__UTIL_H diff --git a/examples/C/mm/Makefile b/examples/C/mm/Makefile new file mode 100644 index 000000000..0a7fbb4a1 --- /dev/null +++ b/examples/C/mm/Makefile @@ -0,0 +1,16 @@ +TARGET = mm + +$(TARGET).objdump: $(TARGET) + riscv64-unknown-elf-objdump -S -D $(TARGET) > $(TARGET).objdump + +$(TARGET): $(TARGET).c Makefile + riscv64-unknown-elf-gcc -g -o $(TARGET) -march=rv64gc -mabi=lp64d -mcmodel=medany \ + -DPREALLOCATE=1 -mcmodel=medany -static -std=gnu99 -O2 -ffast-math -fno-common \ + -fno-builtin-printf -fno-tree-loop-distribute-patterns \ + -static -nostdlib -nostartfiles -lm -lgcc -T../common/test.ld \ + -I../common \ + -O *.c \ + ../common/crt.S ../common/syscalls.c + +clean: + rm -f $(TARGET) $(TARGET).objdump diff --git a/examples/C/mm/common.h b/examples/C/mm/common.h new file mode 100644 index 000000000..01b9f3fe7 --- /dev/null +++ b/examples/C/mm/common.h @@ -0,0 +1,36 @@ +// See LICENSE for license details. + +#ifndef _MM_H +#define _MM_H + +#include +#include +#include + +#ifdef SP +typedef float t; +#define fma fmaf +#else +typedef double t; +#endif + +#define inline inline __attribute__((always_inline)) + +#define alloca_aligned(s, a) ((void*)(((uintptr_t)alloca((s)+(a)-1)+(a)-1)&~((a)-1))) + +#include "rb.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void mm(size_t m, size_t n, size_t p, + t* a, size_t lda, t* b, size_t ldb, t* c, size_t ldc); + +#ifdef __cplusplus +} +#endif + +//void rb(t* a, t* b, t* c, size_t lda, size_t ldb, size_t ldc); + +#endif diff --git a/examples/C/mm/mm b/examples/C/mm/mm new file mode 100755 index 0000000000000000000000000000000000000000..ae176956134cc44c4d28fb537042f707ade75c1b GIT binary patch literal 112448 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 +#include +#include +#include + +#define MIN(a, b) ((a) < (b) ? (a) : (b)) + +static void mm_naive(size_t m, size_t n, size_t p, + t* a, size_t lda, t* b, size_t ldb, t* c, size_t ldc) +{ + for (size_t i = 0; i < m; i++) + { + for (size_t j = 0; j < n; j++) + { + t s0 = c[i*ldc+j], s1 = 0, s2 = 0, s3 = 0; + for (size_t k = 0; k < p/4*4; k+=4) + { + s0 = fma(a[i*lda+k+0], b[(k+0)*ldb+j], s0); + s1 = fma(a[i*lda+k+1], b[(k+1)*ldb+j], s1); + s2 = fma(a[i*lda+k+2], b[(k+2)*ldb+j], s2); + s3 = fma(a[i*lda+k+3], b[(k+3)*ldb+j], s3); + } + for (size_t k = p/4*4; k < p; k++) + s0 = fma(a[i*lda+k], b[k*ldb+j], s0); + c[i*ldc+j] = (s0 + s1) + (s2 + s3); + } + } +} + +static inline void mm_rb(size_t m, size_t n, size_t p, + t* a, size_t lda, t* b, size_t ldb, t* c, size_t ldc) +{ + size_t mb = m/RBM*RBM, nb = n/RBN*RBN; + for (size_t i = 0; i < mb; i += RBM) + { + for (size_t j = 0; j < nb; j += RBN) + kloop(p, a+i*lda, lda, b+j, ldb, c+i*ldc+j, ldc); + mm_naive(RBM, n - nb, p, a+i*lda, lda, b+nb, ldb, c+i*ldc+nb, ldc); + } + mm_naive(m - mb, n, p, a+mb*lda, lda, b, ldb, c+mb*ldc, ldc); +} + +static inline void repack(t* a, size_t lda, const t* a0, size_t lda0, size_t m, size_t p) +{ + for (size_t i = 0; i < m; i++) + { + for (size_t j = 0; j < p/8*8; j+=8) + { + t t0 = a0[i*lda0+j+0]; + t t1 = a0[i*lda0+j+1]; + t t2 = a0[i*lda0+j+2]; + t t3 = a0[i*lda0+j+3]; + t t4 = a0[i*lda0+j+4]; + t t5 = a0[i*lda0+j+5]; + t t6 = a0[i*lda0+j+6]; + t t7 = a0[i*lda0+j+7]; + a[i*lda+j+0] = t0; + a[i*lda+j+1] = t1; + a[i*lda+j+2] = t2; + a[i*lda+j+3] = t3; + a[i*lda+j+4] = t4; + a[i*lda+j+5] = t5; + a[i*lda+j+6] = t6; + a[i*lda+j+7] = t7; + } + for (size_t j = p/8*8; j < p; j++) + a[i*lda+j] = a0[i*lda0+j]; + } +} + +static void mm_cb(size_t m, size_t n, size_t p, + t* a, size_t lda, t* b, size_t ldb, t* c, size_t ldc) +{ + size_t nmb = m/CBM, nnb = n/CBN, npb = p/CBK; + size_t mb = nmb*CBM, nb = nnb*CBN, pb = npb*CBK; + //t a1[mb*pb], b1[pb*nb], c1[mb*nb]; + t* a1 = (t*)alloca_aligned(sizeof(t)*mb*pb, 8192); + t* b1 = (t*)alloca_aligned(sizeof(t)*pb*nb, 8192); + t* c1 = (t*)alloca_aligned(sizeof(t)*mb*nb, 8192); + + for (size_t i = 0; i < mb; i += CBM) + for (size_t j = 0; j < pb; j += CBK) + repack(a1 + (npb*(i/CBM) + j/CBK)*(CBM*CBK), CBK, a + i*lda + j, lda, CBM, CBK); + + for (size_t i = 0; i < pb; i += CBK) + for (size_t j = 0; j < nb; j += CBN) + repack(b1 + (nnb*(i/CBK) + j/CBN)*(CBK*CBN), CBN, b + i*ldb + j, ldb, CBK, CBN); + + for (size_t i = 0; i < mb; i += CBM) + for (size_t j = 0; j < nb; j += CBN) + repack(c1 + (nnb*(i/CBM) + j/CBN)*(CBM*CBN), CBN, c + i*ldc + j, ldc, CBM, CBN); + + for (size_t i = 0; i < mb; i += CBM) + { + for (size_t j = 0; j < nb; j += CBN) + { + for (size_t k = 0; k < pb; k += CBK) + { + mm_rb(CBM, CBN, CBK, + a1 + (npb*(i/CBM) + k/CBK)*(CBM*CBK), CBK, + b1 + (nnb*(k/CBK) + j/CBN)*(CBK*CBN), CBN, + c1 + (nnb*(i/CBM) + j/CBN)*(CBM*CBN), CBN); + } + if (pb < p) + { + mm_rb(CBM, CBN, p - pb, + a + i*lda + pb, lda, + b + pb*ldb + j, ldb, + c1 + (nnb*(i/CBM) + j/CBN)*(CBM*CBN), CBN); + } + } + if (nb < n) + { + for (size_t k = 0; k < p; k += CBK) + { + mm_rb(CBM, n - nb, MIN(p - k, CBK), + a + i*lda + k, lda, + b + k*ldb + nb, ldb, + c + i*ldc + nb, ldc); + } + } + } + if (mb < m) + { + for (size_t j = 0; j < n; j += CBN) + { + for (size_t k = 0; k < p; k += CBK) + { + mm_rb(m - mb, MIN(n - j, CBN), MIN(p - k, CBK), + a + mb*lda + k, lda, + b + k*ldb + j, ldb, + c + mb*ldc + j, ldc); + } + } + } + + for (size_t i = 0; i < mb; i += CBM) + for (size_t j = 0; j < nb; j += CBN) + repack(c + i*ldc + j, ldc, c1 + (nnb*(i/CBM) + j/CBN)*(CBM*CBN), CBN, CBM, CBN); +} + +void mm(size_t m, size_t n, size_t p, + t* a, size_t lda, t* b, size_t ldb, t* c, size_t ldc) +{ + if (__builtin_expect(m <= 2*CBM && n <= 2*CBN && p <= 2*CBK, 1)) + mm_rb(m, n, p, a, lda, b, ldb, c, ldc); + else + mm_cb(m, n, p, a, lda, b, ldb, c, ldc); +} diff --git a/examples/C/mm/mm_main.c b/examples/C/mm/mm_main.c new file mode 100644 index 000000000..5a90d1ab1 --- /dev/null +++ b/examples/C/mm/mm_main.c @@ -0,0 +1,76 @@ +// See LICENSE for license details. + +#include "common.h" +#include +#include +#include +#include "util.h" + +#pragma GCC optimize ("unroll-loops") + +int main(int argc, char** argv) +//void thread_entry(int cid, int nc) +{ + const int R = 8; + int m, n, p; + uint64_t s = 0xdeadbeefU; + + int cid = 0; + int nc = 0; + + m = CBM; + n = CBN; + p = CBK; + + t a[m*p]; + t b[p*n]; + t c[m*n]; + + for (size_t i = 0; i < m; i++) + for (size_t j = 0; j < p; j++) + a[i*p+j] = (t)(s = lfsr(s)); + for (size_t i = 0; i < p; i++) + for (size_t j = 0; j < n; j++) + b[i*n+j] = (t)(s = lfsr(s)); + memset(c, 0, m*n*sizeof(c[0])); + + size_t instret, cycles; + for (int i = 0; i < R; i++) + { + instret = -read_csr(minstret); + cycles = -read_csr(mcycle); + mm(m, n, p, a, p, b, n, c, n); + instret += read_csr(minstret); + cycles += read_csr(mcycle); + } + + asm volatile("fence"); + + printf("C%d: reg block %dx%dx%d, cache block %dx%dx%d\n", + cid, RBM, RBN, RBK, CBM, CBN, CBK); + printf("C%d: %d instructions\n", cid, (int)(instret)); + printf("C%d: %d cycles\n", cid, (int)(cycles)); + printf("C%d: %d flops\n", cid, 2*m*n*p); + printf("C%d: %d Mflops @ 1 GHz\n", cid, 2000*m*n*p/(cycles)); + +#if 1 + for (size_t i = 0; i < m; i++) + { + for (size_t j = 0; j < n; j++) + { + t s = 0; + for (size_t k = 0; k < p; k++) + s += a[i*p+k] * b[k*n+j]; + s *= R; + if (fabs(c[i*n+j]-s) > fabs(1e-6*s)) + { + printf("C%d: c[%lu][%lu] %f != %f\n", cid, i, j, c[i*n+j], s); + exit(1); + } + } + } +#endif + + //barrier(nc); + exit(0); +} diff --git a/examples/C/mm/old.gen.scala b/examples/C/mm/old.gen.scala new file mode 100644 index 000000000..982daa86d --- /dev/null +++ b/examples/C/mm/old.gen.scala @@ -0,0 +1,81 @@ +import scala.sys.process._ +object MMGen { + implicit def i2s(i: Int) = i.toString + def writeFile(name: String, contents: String) = { + val f = new java.io.FileWriter(name) + f.write(contents) + f.close + } + + var indent = 0 + def spacing = " " * indent + def assign(lhs: String, rhs: String) = + spacing + lhs + " = " + rhs + ";\n" + def init(t: String, n: String, v: String) = + assign(t+" "+n, v) + def open_block(s: String = "") = { + val result = (if (s != "") spacing + s else "") + spacing + "{\n" + indent = indent + 1 + result + } + def close_block = { + indent = indent - 1 + spacing + "}\n" + } + + def ar(m: String, i: String) = m+"["+i+"]" + def r(a: String, b: String*) = (a :: b.toList).reduceLeft(_+"_"+_) + + def rb(m: Int, n: Int, p: Int) = { + var s = open_block("static inline void kloop(size_t p, t* a0, size_t lda, t* b0, size_t ldb, t* c, size_t ldc)\n") + + for (i <- 0 until m) + s += init("t*", r("c", i), "&"+ar("c", "ldc*"+i)) + for (i <- 0 until m; j <- 0 until n) + s += init("t", r("c", i, j), ar(r("c", i), j)) + + def doit(m: Int, n: Int, p: Int) = { + for (i <- 0 until m) + s += init("t*", r("a", i), "&"+ar("a", "lda*"+i)) + for (k <- 0 until p) + s += init("t*", r("b", k), "&"+ar("b", "ldb*"+k)) + for (k <- 0 until p; i <- 0 until m; j <- 0 until n) + s += assign(r("c", i, j), "fma(" + ar(r("a", i), k) + ", " + ar(r("b", k), j) + ", " + r("c", i, j) + ")") + } + + s += open_block("for (t *a = a0, *b = b0; a < a0 + p/RBK*RBK; a += RBK, b += RBK*ldb)\n") + doit(m, n, p) + s += close_block + + s += open_block("for (t *a = a0 + p/RBK*RBK, *b = b0 + p/RBK*RBK*ldb; a < a0 + p; a++, b += ldb)\n") + doit(m, n, 1) + s += close_block + + for (i <- 0 until m; j <- 0 until n) + s += assign(ar(r("c", i), j), r("c", i, j)) + s += close_block + + s + } + def gcd(a: Int, b: Int): Int = if (b == 0) a else gcd(b, a%b) + def lcm(a: Int, b: Int): Int = a*b/gcd(a, b) + def lcm(a: Seq[Int]): Int = { + if (a.tail.isEmpty) a.head + else lcm(a.head, lcm(a.tail)) + } + def test1(m: Int, n: Int, p: Int, m1: Int, n1: Int, p1: Int) = { + val decl = "static const int RBM = "+m+", RBN = "+n+", RBK = "+p+";\n" + + "static const int CBM = "+m1+", CBN = "+n1+", CBK = "+p1+";\n" + writeFile("rb.h", decl + rb(m, n, p)) + //"make"!! + + "make run"! + + ("cp a.out " + Seq("b", m, n, p, m1, n1, p1, "run").reduce(_+"."+_))! + } + def main(args: Array[String]): Unit = { + test1(4, 5, 6, 24, 25, 24) + //for (i <- 4 to 6; j <- 4 to 6; k <- 4 to 6) + // test1(i, j, k, if (i == 5) 35 else 36, if (j == 5) 35 else 36, if (k == 5) 35 else 36) + } +} diff --git a/examples/C/mm/rb.h b/examples/C/mm/rb.h new file mode 100644 index 000000000..421c9648f --- /dev/null +++ b/examples/C/mm/rb.h @@ -0,0 +1,210 @@ +static const int RBM = 4, RBN = 5, RBK = 6; +static const int CBM = 24, CBN = 25, CBK = 24; +static inline void kloop(size_t p, t* a0, size_t lda, t* b0, size_t ldb, t* c, size_t ldc) +{ + t* c_0 = &c[ldc*0]; + t* c_1 = &c[ldc*1]; + t* c_2 = &c[ldc*2]; + t* c_3 = &c[ldc*3]; + t c_0_0 = c_0[0]; + t c_0_1 = c_0[1]; + t c_0_2 = c_0[2]; + t c_0_3 = c_0[3]; + t c_0_4 = c_0[4]; + t c_1_0 = c_1[0]; + t c_1_1 = c_1[1]; + t c_1_2 = c_1[2]; + t c_1_3 = c_1[3]; + t c_1_4 = c_1[4]; + t c_2_0 = c_2[0]; + t c_2_1 = c_2[1]; + t c_2_2 = c_2[2]; + t c_2_3 = c_2[3]; + t c_2_4 = c_2[4]; + t c_3_0 = c_3[0]; + t c_3_1 = c_3[1]; + t c_3_2 = c_3[2]; + t c_3_3 = c_3[3]; + t c_3_4 = c_3[4]; + for (t *a = a0, *b = b0; a < a0 + p/RBK*RBK; a += RBK, b += RBK*ldb) + { + t* a_0 = &a[lda*0]; + t* a_1 = &a[lda*1]; + t* a_2 = &a[lda*2]; + t* a_3 = &a[lda*3]; + t* b_0 = &b[ldb*0]; + t* b_1 = &b[ldb*1]; + t* b_2 = &b[ldb*2]; + t* b_3 = &b[ldb*3]; + t* b_4 = &b[ldb*4]; + t* b_5 = &b[ldb*5]; + c_0_0 = fma(a_0[0], b_0[0], c_0_0); + c_0_1 = fma(a_0[0], b_0[1], c_0_1); + c_0_2 = fma(a_0[0], b_0[2], c_0_2); + c_0_3 = fma(a_0[0], b_0[3], c_0_3); + c_0_4 = fma(a_0[0], b_0[4], c_0_4); + c_1_0 = fma(a_1[0], b_0[0], c_1_0); + c_1_1 = fma(a_1[0], b_0[1], c_1_1); + c_1_2 = fma(a_1[0], b_0[2], c_1_2); + c_1_3 = fma(a_1[0], b_0[3], c_1_3); + c_1_4 = fma(a_1[0], b_0[4], c_1_4); + c_2_0 = fma(a_2[0], b_0[0], c_2_0); + c_2_1 = fma(a_2[0], b_0[1], c_2_1); + c_2_2 = fma(a_2[0], b_0[2], c_2_2); + c_2_3 = fma(a_2[0], b_0[3], c_2_3); + c_2_4 = fma(a_2[0], b_0[4], c_2_4); + c_3_0 = fma(a_3[0], b_0[0], c_3_0); + c_3_1 = fma(a_3[0], b_0[1], c_3_1); + c_3_2 = fma(a_3[0], b_0[2], c_3_2); + c_3_3 = fma(a_3[0], b_0[3], c_3_3); + c_3_4 = fma(a_3[0], b_0[4], c_3_4); + c_0_0 = fma(a_0[1], b_1[0], c_0_0); + c_0_1 = fma(a_0[1], b_1[1], c_0_1); + c_0_2 = fma(a_0[1], b_1[2], c_0_2); + c_0_3 = fma(a_0[1], b_1[3], c_0_3); + c_0_4 = fma(a_0[1], b_1[4], c_0_4); + c_1_0 = fma(a_1[1], b_1[0], c_1_0); + c_1_1 = fma(a_1[1], b_1[1], c_1_1); + c_1_2 = fma(a_1[1], b_1[2], c_1_2); + c_1_3 = fma(a_1[1], b_1[3], c_1_3); + c_1_4 = fma(a_1[1], b_1[4], c_1_4); + c_2_0 = fma(a_2[1], b_1[0], c_2_0); + c_2_1 = fma(a_2[1], b_1[1], c_2_1); + c_2_2 = fma(a_2[1], b_1[2], c_2_2); + c_2_3 = fma(a_2[1], b_1[3], c_2_3); + c_2_4 = fma(a_2[1], b_1[4], c_2_4); + c_3_0 = fma(a_3[1], b_1[0], c_3_0); + c_3_1 = fma(a_3[1], b_1[1], c_3_1); + c_3_2 = fma(a_3[1], b_1[2], c_3_2); + c_3_3 = fma(a_3[1], b_1[3], c_3_3); + c_3_4 = fma(a_3[1], b_1[4], c_3_4); + c_0_0 = fma(a_0[2], b_2[0], c_0_0); + c_0_1 = fma(a_0[2], b_2[1], c_0_1); + c_0_2 = fma(a_0[2], b_2[2], c_0_2); + c_0_3 = fma(a_0[2], b_2[3], c_0_3); + c_0_4 = fma(a_0[2], b_2[4], c_0_4); + c_1_0 = fma(a_1[2], b_2[0], c_1_0); + c_1_1 = fma(a_1[2], b_2[1], c_1_1); + c_1_2 = fma(a_1[2], b_2[2], c_1_2); + c_1_3 = fma(a_1[2], b_2[3], c_1_3); + c_1_4 = fma(a_1[2], b_2[4], c_1_4); + c_2_0 = fma(a_2[2], b_2[0], c_2_0); + c_2_1 = fma(a_2[2], b_2[1], c_2_1); + c_2_2 = fma(a_2[2], b_2[2], c_2_2); + c_2_3 = fma(a_2[2], b_2[3], c_2_3); + c_2_4 = fma(a_2[2], b_2[4], c_2_4); + c_3_0 = fma(a_3[2], b_2[0], c_3_0); + c_3_1 = fma(a_3[2], b_2[1], c_3_1); + c_3_2 = fma(a_3[2], b_2[2], c_3_2); + c_3_3 = fma(a_3[2], b_2[3], c_3_3); + c_3_4 = fma(a_3[2], b_2[4], c_3_4); + c_0_0 = fma(a_0[3], b_3[0], c_0_0); + c_0_1 = fma(a_0[3], b_3[1], c_0_1); + c_0_2 = fma(a_0[3], b_3[2], c_0_2); + c_0_3 = fma(a_0[3], b_3[3], c_0_3); + c_0_4 = fma(a_0[3], b_3[4], c_0_4); + c_1_0 = fma(a_1[3], b_3[0], c_1_0); + c_1_1 = fma(a_1[3], b_3[1], c_1_1); + c_1_2 = fma(a_1[3], b_3[2], c_1_2); + c_1_3 = fma(a_1[3], b_3[3], c_1_3); + c_1_4 = fma(a_1[3], b_3[4], c_1_4); + c_2_0 = fma(a_2[3], b_3[0], c_2_0); + c_2_1 = fma(a_2[3], b_3[1], c_2_1); + c_2_2 = fma(a_2[3], b_3[2], c_2_2); + c_2_3 = fma(a_2[3], b_3[3], c_2_3); + c_2_4 = fma(a_2[3], b_3[4], c_2_4); + c_3_0 = fma(a_3[3], b_3[0], c_3_0); + c_3_1 = fma(a_3[3], b_3[1], c_3_1); + c_3_2 = fma(a_3[3], b_3[2], c_3_2); + c_3_3 = fma(a_3[3], b_3[3], c_3_3); + c_3_4 = fma(a_3[3], b_3[4], c_3_4); + c_0_0 = fma(a_0[4], b_4[0], c_0_0); + c_0_1 = fma(a_0[4], b_4[1], c_0_1); + c_0_2 = fma(a_0[4], b_4[2], c_0_2); + c_0_3 = fma(a_0[4], b_4[3], c_0_3); + c_0_4 = fma(a_0[4], b_4[4], c_0_4); + c_1_0 = fma(a_1[4], b_4[0], c_1_0); + c_1_1 = fma(a_1[4], b_4[1], c_1_1); + c_1_2 = fma(a_1[4], b_4[2], c_1_2); + c_1_3 = fma(a_1[4], b_4[3], c_1_3); + c_1_4 = fma(a_1[4], b_4[4], c_1_4); + c_2_0 = fma(a_2[4], b_4[0], c_2_0); + c_2_1 = fma(a_2[4], b_4[1], c_2_1); + c_2_2 = fma(a_2[4], b_4[2], c_2_2); + c_2_3 = fma(a_2[4], b_4[3], c_2_3); + c_2_4 = fma(a_2[4], b_4[4], c_2_4); + c_3_0 = fma(a_3[4], b_4[0], c_3_0); + c_3_1 = fma(a_3[4], b_4[1], c_3_1); + c_3_2 = fma(a_3[4], b_4[2], c_3_2); + c_3_3 = fma(a_3[4], b_4[3], c_3_3); + c_3_4 = fma(a_3[4], b_4[4], c_3_4); + c_0_0 = fma(a_0[5], b_5[0], c_0_0); + c_0_1 = fma(a_0[5], b_5[1], c_0_1); + c_0_2 = fma(a_0[5], b_5[2], c_0_2); + c_0_3 = fma(a_0[5], b_5[3], c_0_3); + c_0_4 = fma(a_0[5], b_5[4], c_0_4); + c_1_0 = fma(a_1[5], b_5[0], c_1_0); + c_1_1 = fma(a_1[5], b_5[1], c_1_1); + c_1_2 = fma(a_1[5], b_5[2], c_1_2); + c_1_3 = fma(a_1[5], b_5[3], c_1_3); + c_1_4 = fma(a_1[5], b_5[4], c_1_4); + c_2_0 = fma(a_2[5], b_5[0], c_2_0); + c_2_1 = fma(a_2[5], b_5[1], c_2_1); + c_2_2 = fma(a_2[5], b_5[2], c_2_2); + c_2_3 = fma(a_2[5], b_5[3], c_2_3); + c_2_4 = fma(a_2[5], b_5[4], c_2_4); + c_3_0 = fma(a_3[5], b_5[0], c_3_0); + c_3_1 = fma(a_3[5], b_5[1], c_3_1); + c_3_2 = fma(a_3[5], b_5[2], c_3_2); + c_3_3 = fma(a_3[5], b_5[3], c_3_3); + c_3_4 = fma(a_3[5], b_5[4], c_3_4); + } + for (t *a = a0 + p/RBK*RBK, *b = b0 + p/RBK*RBK*ldb; a < a0 + p; a++, b += ldb) + { + t* a_0 = &a[lda*0]; + t* a_1 = &a[lda*1]; + t* a_2 = &a[lda*2]; + t* a_3 = &a[lda*3]; + t* b_0 = &b[ldb*0]; + c_0_0 = fma(a_0[0], b_0[0], c_0_0); + c_0_1 = fma(a_0[0], b_0[1], c_0_1); + c_0_2 = fma(a_0[0], b_0[2], c_0_2); + c_0_3 = fma(a_0[0], b_0[3], c_0_3); + c_0_4 = fma(a_0[0], b_0[4], c_0_4); + c_1_0 = fma(a_1[0], b_0[0], c_1_0); + c_1_1 = fma(a_1[0], b_0[1], c_1_1); + c_1_2 = fma(a_1[0], b_0[2], c_1_2); + c_1_3 = fma(a_1[0], b_0[3], c_1_3); + c_1_4 = fma(a_1[0], b_0[4], c_1_4); + c_2_0 = fma(a_2[0], b_0[0], c_2_0); + c_2_1 = fma(a_2[0], b_0[1], c_2_1); + c_2_2 = fma(a_2[0], b_0[2], c_2_2); + c_2_3 = fma(a_2[0], b_0[3], c_2_3); + c_2_4 = fma(a_2[0], b_0[4], c_2_4); + c_3_0 = fma(a_3[0], b_0[0], c_3_0); + c_3_1 = fma(a_3[0], b_0[1], c_3_1); + c_3_2 = fma(a_3[0], b_0[2], c_3_2); + c_3_3 = fma(a_3[0], b_0[3], c_3_3); + c_3_4 = fma(a_3[0], b_0[4], c_3_4); + } + c_0[0] = c_0_0; + c_0[1] = c_0_1; + c_0[2] = c_0_2; + c_0[3] = c_0_3; + c_0[4] = c_0_4; + c_1[0] = c_1_0; + c_1[1] = c_1_1; + c_1[2] = c_1_2; + c_1[3] = c_1_3; + c_1[4] = c_1_4; + c_2[0] = c_2_0; + c_2[1] = c_2_1; + c_2[2] = c_2_2; + c_2[3] = c_2_3; + c_2[4] = c_2_4; + c_3[0] = c_3_0; + c_3[1] = c_3_1; + c_3[2] = c_3_2; + c_3[3] = c_3_3; + c_3[4] = c_3_4; +} diff --git a/examples/C/simple/Makefile b/examples/C/simple/Makefile index 66fe7d7bc..b4d49957d 100644 --- a/examples/C/simple/Makefile +++ b/examples/C/simple/Makefile @@ -3,12 +3,14 @@ TARGET = simple $(TARGET).objdump: $(TARGET) riscv64-unknown-elf-objdump -S -D $(TARGET) > $(TARGET).objdump -$(TARGET): $(TARGET).c +$(TARGET): $(TARGET).c Makefile riscv64-unknown-elf-gcc -g -o $(TARGET) -march=rv64gc -mabi=lp64d -mcmodel=medany \ - -O $(TARGET).c -# -O -T../../link/linkc.ld $(TARGET).c -# -nostartfiles -nostdlib $(TARGET).c -# -nostartfiles -nostdlib -T../../link/link.ld $(TARGET).c + -DPREALLOCATE=1 -mcmodel=medany -static -std=gnu99 -O2 -ffast-math -fno-common \ + -fno-builtin-printf -fno-tree-loop-distribute-patterns \ + -static -nostdlib -nostartfiles -lm -lgcc -T../common/test.ld \ + -I../common \ + -O $(TARGET).c \ + ../common/crt.S ../common/syscalls.c clean: rm -f $(TARGET) $(TARGET).objdump diff --git a/examples/C/simple/simple b/examples/C/simple/simple new file mode 100755 index 0000000000000000000000000000000000000000..4dfc521fdd8d44e75db5ceddfe144f5c6d17a850 GIT binary patch literal 39560 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 literal 0 HcmV?d00001 diff --git a/examples/C/simple/simple.c b/examples/C/simple/simple.c index d610f2999..2bd33ac54 100644 --- a/examples/C/simple/simple.c +++ b/examples/C/simple/simple.c @@ -2,13 +2,20 @@ // David_Harris@hmc.edu 24 December 2021 // Simple illustration of compiling C code +#include + long sum(long N) { long result, i; result = 0; - for (i=1; i<=N; i++) result = result + i; + for (i=1; i<=N; i++) { + result = result + i; + } return result; } int main(void) { - return sum(4); + long s; + s = sum(4); + printf("s = %ld\n", s); + return 0; // 0 means success } \ No newline at end of file diff --git a/examples/link/linkc.ld b/examples/link/linkc.ld deleted file mode 100644 index 7b2566785..000000000 --- a/examples/link/linkc.ld +++ /dev/null @@ -1,17 +0,0 @@ -OUTPUT_ARCH( "riscv" ) -ENTRY(main) - -SECTIONS -{ - . = 0x80000000; - .text : { *(.text) } - . = ALIGN(0x1000); - .tohost : { *(.tohost) } - . = ALIGN(0x1000); - .data : { *(.data) } - .data.string : { *(.data.string)} - . = ALIGN(0x1000); - .bss : { *(.bss) } - _end = .; -} -