zicfilp protects forward control flow (if enabled) by enforcing all
indirect call and jmp must land on a landing pad instruction `lpad`. If
target of an indirect call or jmp is not `lpad` then cpu/hart must raise
a sw check exception with tval = 2.
This patch implements the mechanism using TCG. Target architecture branch
instruction must define the end of a TB. Using this property, during
translation of branch instruction, TB flag = FCFI_LP_EXPECTED can be set.
Translation of target TB can check if FCFI_LP_EXPECTED flag is set and a
flag (fcfi_lp_expected) can be set in DisasContext. If `lpad` gets
translated, fcfi_lp_expected flag in DisasContext can be cleared. Else
it'll fault.
Signed-off-by: Deepak Gupta <debug@rivosinc.com>
Co-developed-by: Jim Shu <jim.shu@sifive.com>
Co-developed-by: Andy Chiu <andy.chiu@sifive.com>
---
include/tcg/tcg.h | 1 +
target/riscv/cpu.h | 3 +++
target/riscv/cpu_bits.h | 3 +++
target/riscv/cpu_helper.c | 12 ++++++++++++
target/riscv/helper.h | 3 +++
target/riscv/op_helper.c | 6 ++++++
target/riscv/translate.c | 37 +++++++++++++++++++++++++++++++++++++
7 files changed, 65 insertions(+)
diff --git a/include/tcg/tcg.h b/include/tcg/tcg.h
index 21d5884741..561abc3878 100644
--- a/include/tcg/tcg.h
+++ b/include/tcg/tcg.h
@@ -528,6 +528,7 @@ struct TCGContext {
#endif
TCGLabel *exitreq_label;
+ TCGOp *cfi_lp_check;
#ifdef CONFIG_PLUGIN
/*
diff --git a/target/riscv/cpu.h b/target/riscv/cpu.h
index 11c6513a90..edf540339a 100644
--- a/target/riscv/cpu.h
+++ b/target/riscv/cpu.h
@@ -606,6 +606,9 @@ FIELD(TB_FLAGS, ITRIGGER, 22, 1)
FIELD(TB_FLAGS, VIRT_ENABLED, 23, 1)
FIELD(TB_FLAGS, PRIV, 24, 2)
FIELD(TB_FLAGS, AXL, 26, 2)
+/* zicfilp needs a TB flag to track indirect branches */
+FIELD(TB_FLAGS, FCFI_ENABLED, 28, 1)
+FIELD(TB_FLAGS, FCFI_LP_EXPECTED, 29, 1)
#ifdef TARGET_RISCV32
#define riscv_cpu_mxl(env) ((void)(env), MXL_RV32)
diff --git a/target/riscv/cpu_bits.h b/target/riscv/cpu_bits.h
index b05ebe6f29..900769ce60 100644
--- a/target/riscv/cpu_bits.h
+++ b/target/riscv/cpu_bits.h
@@ -685,6 +685,9 @@ typedef enum RISCVException {
RISCV_EXCP_SEMIHOST = 0x3f,
} RISCVException;
+/* zicfilp defines lp violation results in sw check with tval = 2*/
+#define RISCV_EXCP_SW_CHECK_FCFI_TVAL 2
+
#define RISCV_EXCP_INT_FLAG 0x80000000
#define RISCV_EXCP_INT_MASK 0x7fffffff
diff --git a/target/riscv/cpu_helper.c b/target/riscv/cpu_helper.c
index 9f08a67a9e..3a56bea8b9 100644
--- a/target/riscv/cpu_helper.c
+++ b/target/riscv/cpu_helper.c
@@ -133,6 +133,18 @@ void cpu_get_tb_cpu_state(CPURISCVState *env, vaddr *pc,
flags = FIELD_DP32(flags, TB_FLAGS, VILL, 1);
}
+ if (cpu_get_fcfien(env)) {
+ /*
+ * For Forward CFI, only the expectation of a lpcll at
+ * the start of the block is tracked (which can only happen
+ * when FCFI is enabled for the current processor mode). A jump
+ * or call at the end of the previous TB will have updated
+ * env->elp to indicate the expectation.
+ */
+ flags = FIELD_DP32(flags, TB_FLAGS, FCFI_LP_EXPECTED, env->elp);
+ flags = FIELD_DP32(flags, TB_FLAGS, FCFI_ENABLED, 1);
+ }
+
#ifdef CONFIG_USER_ONLY
fs = EXT_STATUS_DIRTY;
vs = EXT_STATUS_DIRTY;
diff --git a/target/riscv/helper.h b/target/riscv/helper.h
index 451261ce5a..e946ba61fd 100644
--- a/target/riscv/helper.h
+++ b/target/riscv/helper.h
@@ -121,6 +121,9 @@ DEF_HELPER_2(cbo_clean_flush, void, env, tl)
DEF_HELPER_2(cbo_inval, void, env, tl)
DEF_HELPER_2(cbo_zero, void, env, tl)
+/* helper to raise sw check exception */
+DEF_HELPER_2(raise_sw_check_excep, void, env, tl)
+
/* Special functions */
DEF_HELPER_2(csrr, tl, env, int)
DEF_HELPER_3(csrw, void, env, int, tl)
diff --git a/target/riscv/op_helper.c b/target/riscv/op_helper.c
index 5848aaf437..9ec19c4afa 100644
--- a/target/riscv/op_helper.c
+++ b/target/riscv/op_helper.c
@@ -259,6 +259,12 @@ void helper_cbo_inval(CPURISCVState *env, target_ulong address)
/* We don't emulate the cache-hierarchy, so we're done. */
}
+void helper_raise_sw_check_excep(CPURISCVState *env, target_ulong swcheck_code)
+{
+ env->sw_check_code = swcheck_code;
+ riscv_raise_exception(env, RISCV_EXCP_SW_CHECK, GETPC());
+}
+
#ifndef CONFIG_USER_ONLY
target_ulong helper_sret(CPURISCVState *env)
diff --git a/target/riscv/translate.c b/target/riscv/translate.c
index acba90f170..f1522e8b96 100644
--- a/target/riscv/translate.c
+++ b/target/riscv/translate.c
@@ -116,6 +116,9 @@ typedef struct DisasContext {
bool frm_valid;
bool insn_start_updated;
const GPtrArray *decoders;
+ /* zicfilp extension. fcfi_enabled, lp expected or not */
+ bool fcfi_enabled;
+ bool fcfi_lp_expected;
} DisasContext;
static inline bool has_ext(DisasContext *ctx, uint32_t ext)
@@ -1238,6 +1241,8 @@ static void riscv_tr_init_disas_context(DisasContextBase *dcbase, CPUState *cs)
ctx->pm_base_enabled = FIELD_EX32(tb_flags, TB_FLAGS, PM_BASE_ENABLED);
ctx->ztso = cpu->cfg.ext_ztso;
ctx->itrigger = FIELD_EX32(tb_flags, TB_FLAGS, ITRIGGER);
+ ctx->fcfi_lp_expected = FIELD_EX32(tb_flags, TB_FLAGS, FCFI_LP_EXPECTED);
+ ctx->fcfi_enabled = FIELD_EX32(tb_flags, TB_FLAGS, FCFI_ENABLED);
ctx->zero = tcg_constant_tl(0);
ctx->virt_inst_excp = false;
ctx->decoders = cpu->decoders;
@@ -1245,6 +1250,7 @@ static void riscv_tr_init_disas_context(DisasContextBase *dcbase, CPUState *cs)
static void riscv_tr_tb_start(DisasContextBase *db, CPUState *cpu)
{
+
}
static void riscv_tr_insn_start(DisasContextBase *dcbase, CPUState *cpu)
@@ -1266,6 +1272,28 @@ static void riscv_tr_translate_insn(DisasContextBase *dcbase, CPUState *cpu)
CPURISCVState *env = cpu_env(cpu);
uint16_t opcode16 = translator_lduw(env, &ctx->base, ctx->base.pc_next);
+ if (ctx->fcfi_lp_expected) {
+ /*
+ * Since we can't look ahead to confirm that the first
+ * instruction is a legal landing pad instruction, emit
+ * compare-and-branch sequence that will be fixed-up in
+ * riscv_tr_tb_stop() to either statically hit or skip an
+ * illegal instruction exception depending on whether the
+ * flag was lowered by translation of a CJLP or JLP as
+ * the first instruction in the block.
+ */
+ TCGv_i32 immediate;
+ TCGLabel *l;
+ l = gen_new_label();
+ immediate = tcg_temp_new_i32();
+ tcg_gen_movi_i32(immediate, 0);
+ tcg_ctx->cfi_lp_check = tcg_last_op();
+ tcg_gen_brcondi_i32(TCG_COND_EQ, immediate, 0, l);
+ gen_helper_raise_sw_check_excep(tcg_env,
+ tcg_constant_tl(RISCV_EXCP_SW_CHECK_FCFI_TVAL));
+ gen_set_label(l);
+ }
+
ctx->ol = ctx->xl;
decode_opc(env, ctx, opcode16);
ctx->base.pc_next += ctx->cur_insn_len;
@@ -1303,6 +1331,15 @@ static void riscv_tr_tb_stop(DisasContextBase *dcbase, CPUState *cpu)
default:
g_assert_not_reached();
}
+
+ if (ctx->fcfi_lp_expected) {
+ /*
+ * If the "lp expected" flag is still up, the block needs to take an
+ * illegal instruction exception.
+ */
+ tcg_set_insn_param(tcg_ctx->cfi_lp_check, 1,
+ tcgv_i32_arg(tcg_constant_i32(1)));
+ }
}
static const TranslatorOps riscv_tr_ops = {
--
2.44.0On 8/16/24 11:06, Deepak Gupta wrote:
> @@ -1245,6 +1250,7 @@ static void riscv_tr_init_disas_context(DisasContextBase *dcbase, CPUState *cs)
>
> static void riscv_tr_tb_start(DisasContextBase *db, CPUState *cpu)
> {
> +
> }
Watch the unrelated changes.
> @@ -1266,6 +1272,28 @@ static void riscv_tr_translate_insn(DisasContextBase *dcbase, CPUState *cpu)
> CPURISCVState *env = cpu_env(cpu);
> uint16_t opcode16 = translator_lduw(env, &ctx->base, ctx->base.pc_next);
>
> + if (ctx->fcfi_lp_expected) {
> + /*
> + * Since we can't look ahead to confirm that the first
> + * instruction is a legal landing pad instruction, emit
> + * compare-and-branch sequence that will be fixed-up in
> + * riscv_tr_tb_stop() to either statically hit or skip an
> + * illegal instruction exception depending on whether the
> + * flag was lowered by translation of a CJLP or JLP as
> + * the first instruction in the block.
> + */
> + TCGv_i32 immediate;
> + TCGLabel *l;
> + l = gen_new_label();
> + immediate = tcg_temp_new_i32();
> + tcg_gen_movi_i32(immediate, 0);
> + tcg_ctx->cfi_lp_check = tcg_last_op();
> + tcg_gen_brcondi_i32(TCG_COND_EQ, immediate, 0, l);
> + gen_helper_raise_sw_check_excep(tcg_env,
> + tcg_constant_tl(RISCV_EXCP_SW_CHECK_FCFI_TVAL));
> + gen_set_label(l);
> + }
> +
I think this is over-complicated.
> ctx->ol = ctx->xl;
> decode_opc(env, ctx, opcode16);
> ctx->base.pc_next += ctx->cur_insn_len;
If we delay the check until here, then
(1) we've decoded the opcode, and processed lpad or not.
(2) we can know that lpad will have cleared ctx->fcfi_lp_expected,
so that if it is still set here, then we didn't see an lpad.
We can go back an insert the exception like so:
if (ctx->fcfi_lp_expected) {
/* Emit after insn_start, i.e. before the op following insn_start. */
tcg_ctx->emit_before_op = QTAILQ_NEXT(ctx->base.insn_start, link);
tcg_gen_st_tl(tcg_constant_tl(RISCV_EXCP_SW_CHECK_FCFI_TVAL),
tcg_env, offsetof(CPURISCVState, sw_check_code));
gen_helper_raise_exception(tcg_env, tcg_constant_i32(RISCV_EXCP_SW_CHECK));
tcg_ctx->emit_before_op = NULL;
ctx->base.is_jmp = DISAS_NORETURN;
}
Emit the store to sw_check_code directly; no need for an extra helper. Using
gen_helper_raise_exception instead of generate_exception means we don't get a spurious pc
update.
r~
On Fri, Aug 16, 2024 at 01:41:51PM +1000, Richard Henderson wrote:
>On 8/16/24 11:06, Deepak Gupta wrote:
>>@@ -1245,6 +1250,7 @@ static void riscv_tr_init_disas_context(DisasContextBase *dcbase, CPUState *cs)
>> static void riscv_tr_tb_start(DisasContextBase *db, CPUState *cpu)
>> {
>>+
>> }
>
>Watch the unrelated changes.
>
>>@@ -1266,6 +1272,28 @@ static void riscv_tr_translate_insn(DisasContextBase *dcbase, CPUState *cpu)
>> CPURISCVState *env = cpu_env(cpu);
>> uint16_t opcode16 = translator_lduw(env, &ctx->base, ctx->base.pc_next);
>>+ if (ctx->fcfi_lp_expected) {
>>+ /*
>>+ * Since we can't look ahead to confirm that the first
>>+ * instruction is a legal landing pad instruction, emit
>>+ * compare-and-branch sequence that will be fixed-up in
>>+ * riscv_tr_tb_stop() to either statically hit or skip an
>>+ * illegal instruction exception depending on whether the
>>+ * flag was lowered by translation of a CJLP or JLP as
>>+ * the first instruction in the block.
>>+ */
>>+ TCGv_i32 immediate;
>>+ TCGLabel *l;
>>+ l = gen_new_label();
>>+ immediate = tcg_temp_new_i32();
>>+ tcg_gen_movi_i32(immediate, 0);
>>+ tcg_ctx->cfi_lp_check = tcg_last_op();
>>+ tcg_gen_brcondi_i32(TCG_COND_EQ, immediate, 0, l);
>>+ gen_helper_raise_sw_check_excep(tcg_env,
>>+ tcg_constant_tl(RISCV_EXCP_SW_CHECK_FCFI_TVAL));
>>+ gen_set_label(l);
>>+ }
>>+
>
>I think this is over-complicated.
>
>> ctx->ol = ctx->xl;
>> decode_opc(env, ctx, opcode16);
>> ctx->base.pc_next += ctx->cur_insn_len;
>
>If we delay the check until here, then
>
>(1) we've decoded the opcode, and processed lpad or not.
>(2) we can know that lpad will have cleared ctx->fcfi_lp_expected,
> so that if it is still set here, then we didn't see an lpad.
>
>We can go back an insert the exception like so:
>
> if (ctx->fcfi_lp_expected) {
> /* Emit after insn_start, i.e. before the op following insn_start. */
> tcg_ctx->emit_before_op = QTAILQ_NEXT(ctx->base.insn_start, link);
>
> tcg_gen_st_tl(tcg_constant_tl(RISCV_EXCP_SW_CHECK_FCFI_TVAL),
> tcg_env, offsetof(CPURISCVState, sw_check_code));
> gen_helper_raise_exception(tcg_env, tcg_constant_i32(RISCV_EXCP_SW_CHECK));
>
> tcg_ctx->emit_before_op = NULL;
> ctx->base.is_jmp = DISAS_NORETURN;
> }
>
Hmm. Yes this reduces complication of check. Let me do that.
>Emit the store to sw_check_code directly; no need for an extra helper.
>Using gen_helper_raise_exception instead of generate_exception means
>we don't get a spurious pc update.
>
>r~
© 2016 - 2024 Red Hat, Inc.