content
stringlengths 0
376M
|
|---|
require_extension('C');
WRITE_RVC_RS1S(RVC_RS1S & RVC_RS2S);
|
require_extension('C');
WRITE_RVC_RS1S(RVC_RS1S & insn.rvc_imm());
|
require_extension('C');
if (RVC_RS1S == 0)
set_pc(pc + insn.rvc_b_imm());
|
require_extension('C');
if (RVC_RS1S != 0)
set_pc(pc + insn.rvc_b_imm());
|
require_extension('C');
throw trap_breakpoint(pc);
|
require_extension('C');
require_extension('D');
require_fp;
WRITE_RVC_FRS2S(f64(MMU.load_uint64(RVC_RS1S + insn.rvc_ld_imm())));
|
require_extension('C');
require_extension('D');
require_fp;
WRITE_FRD(f64(MMU.load_uint64(RVC_SP + insn.rvc_ldsp_imm())));
|
require_extension('C');
if (xlen == 32) {
require_extension('F');
require_fp;
WRITE_RVC_FRS2S(f32(MMU.load_uint32(RVC_RS1S + insn.rvc_lw_imm())));
} else { // c.ld
WRITE_RVC_RS2S(MMU.load_int64(RVC_RS1S + insn.rvc_ld_imm()));
}
|
require_extension('C');
if (xlen == 32) {
require_extension('F');
require_fp;
WRITE_FRD(f32(MMU.load_uint32(RVC_SP + insn.rvc_lwsp_imm())));
} else { // c.ldsp
require(insn.rvc_rd() != 0);
WRITE_RD(MMU.load_int64(RVC_SP + insn.rvc_ldsp_imm()));
}
|
require_extension('C');
require_extension('D');
require_fp;
MMU.store_uint64(RVC_RS1S + insn.rvc_ld_imm(), RVC_FRS2S.v[0]);
|
require_extension('C');
require_extension('D');
require_fp;
MMU.store_uint64(RVC_SP + insn.rvc_sdsp_imm(), RVC_FRS2.v[0]);
|
require_extension('C');
if (xlen == 32) {
require_extension('F');
require_fp;
MMU.store_uint32(RVC_RS1S + insn.rvc_lw_imm(), RVC_FRS2S.v[0]);
} else { // c.sd
MMU.store_uint64(RVC_RS1S + insn.rvc_ld_imm(), RVC_RS2S);
}
|
require_extension('C');
if (xlen == 32) {
require_extension('F');
require_fp;
MMU.store_uint32(RVC_SP + insn.rvc_swsp_imm(), RVC_FRS2.v[0]);
} else { // c.sdsp
MMU.store_uint64(RVC_SP + insn.rvc_sdsp_imm(), RVC_RS2);
}
|
require_extension('C');
set_pc(pc + insn.rvc_j_imm());
|
require_extension('C');
if (xlen == 32) {
reg_t tmp = npc;
set_pc(pc + insn.rvc_j_imm());
WRITE_REG(X_RA, tmp);
} else { // c.addiw
require(insn.rvc_rd() != 0);
WRITE_RD(sext32(RVC_RS1 + insn.rvc_imm()));
}
|
require_extension('C');
require(insn.rvc_rs1() != 0);
reg_t tmp = npc;
set_pc(RVC_RS1 & ~reg_t(1));
WRITE_REG(X_RA, tmp);
|
require_extension('C');
require(insn.rvc_rs1() != 0);
set_pc(RVC_RS1 & ~reg_t(1));
|
require_extension('C');
WRITE_RD(insn.rvc_imm());
|
require_extension('C');
if (insn.rvc_rd() == 2) { // c.addi16sp
require(insn.rvc_addi16sp_imm() != 0);
WRITE_REG(X_SP, sext_xlen(RVC_SP + insn.rvc_addi16sp_imm()));
} else {
require(insn.rvc_imm() != 0);
WRITE_RD(insn.rvc_imm() << 12);
}
|
require_extension('C');
WRITE_RVC_RS2S(MMU.load_int32(RVC_RS1S + insn.rvc_lw_imm()));
|
require_extension('C');
require(insn.rvc_rd() != 0);
WRITE_RD(MMU.load_int32(RVC_SP + insn.rvc_lwsp_imm()));
|
require_extension('C');
require(insn.rvc_rs2() != 0);
WRITE_RD(RVC_RS2);
|
require_extension('C');
WRITE_RVC_RS1S(RVC_RS1S | RVC_RS2S);
|
require_extension('C');
require(insn.rvc_zimm() < xlen);
WRITE_RD(sext_xlen(RVC_RS1 << insn.rvc_zimm()));
|
require_extension('C');
require(insn.rvc_zimm() < xlen);
WRITE_RVC_RS1S(sext_xlen(sext_xlen(RVC_RS1S) >> insn.rvc_zimm()));
|
require_extension('C');
require(insn.rvc_zimm() < xlen);
WRITE_RVC_RS1S(sext_xlen(zext_xlen(RVC_RS1S) >> insn.rvc_zimm()));
|
require_extension('C');
WRITE_RVC_RS1S(sext_xlen(RVC_RS1S - RVC_RS2S));
|
require_extension('C');
require_rv64;
WRITE_RVC_RS1S(sext32(RVC_RS1S - RVC_RS2S));
|
require_extension('C');
MMU.store_uint32(RVC_RS1S + insn.rvc_lw_imm(), RVC_RS2S);
|
require_extension('C');
MMU.store_uint32(RVC_SP + insn.rvc_swsp_imm(), RVC_RS2);
|
require_extension('C');
WRITE_RVC_RS1S(RVC_RS1S ^ RVC_RS2S);
|
require_extension('M');
sreg_t lhs = sext_xlen(RS1);
sreg_t rhs = sext_xlen(RS2);
if(rhs == 0)
WRITE_RD(UINT64_MAX);
else if(lhs == INT64_MIN && rhs == -1)
WRITE_RD(lhs);
else
WRITE_RD(sext_xlen(lhs / rhs));
|
require_extension('M');
reg_t lhs = zext_xlen(RS1);
reg_t rhs = zext_xlen(RS2);
if(rhs == 0)
WRITE_RD(UINT64_MAX);
else
WRITE_RD(sext_xlen(lhs / rhs));
|
require_extension('M');
require_rv64;
reg_t lhs = zext32(RS1);
reg_t rhs = zext32(RS2);
if(rhs == 0)
WRITE_RD(UINT64_MAX);
else
WRITE_RD(sext32(lhs / rhs));
|
require_extension('M');
require_rv64;
sreg_t lhs = sext32(RS1);
sreg_t rhs = sext32(RS2);
if(rhs == 0)
WRITE_RD(UINT64_MAX);
else
WRITE_RD(sext32(lhs / rhs));
|
require_privilege(PRV_M);
set_pc_and_serialize(STATE.dpc);
p->set_privilege(STATE.dcsr.prv);
/* We're not in Debug Mode anymore. */
STATE.dcsr.cause = 0;
if (STATE.dcsr.step)
STATE.single_step = STATE.STEP_STEPPING;
|
throw trap_breakpoint(pc);
|
switch (STATE.prv)
{
case PRV_U: throw trap_user_ecall();
case PRV_S: throw trap_supervisor_ecall();
case PRV_M: throw trap_machine_ecall();
default: abort();
}
|
require_extension('D');
require_fp;
softfloat_roundingMode = RM;
WRITE_FRD(f64_add(f64(FRS1), f64(FRS2)));
set_fp_exceptions;
|
require_extension('Q');
require_fp;
softfloat_roundingMode = RM;
WRITE_FRD(f128_add(f128(FRS1), f128(FRS2)));
set_fp_exceptions;
|
require_extension('F');
require_fp;
softfloat_roundingMode = RM;
WRITE_FRD(f32_add(f32(FRS1), f32(FRS2)));
set_fp_exceptions;
|
require_extension('D');
require_fp;
WRITE_RD(f64_classify(f64(FRS1)));
|
require_extension('Q');
require_fp;
WRITE_RD(f128_classify(f128(FRS1)));
|
require_extension('F');
require_fp;
WRITE_RD(f32_classify(f32(FRS1)));
|
require_extension('D');
require_rv64;
require_fp;
softfloat_roundingMode = RM;
WRITE_FRD(i64_to_f64(RS1));
set_fp_exceptions;
|
require_extension('D');
require_rv64;
require_fp;
softfloat_roundingMode = RM;
WRITE_FRD(ui64_to_f64(RS1));
set_fp_exceptions;
|