ad75a51e84
Allow the name 'cpu_env' to be used for something else. Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
607 lines
27 KiB
C++
607 lines
27 KiB
C++
/*
|
|
* RISC-V translation routines for the vector crypto extension.
|
|
*
|
|
* Copyright (C) 2023 SiFive, Inc.
|
|
* Written by Codethink Ltd and SiFive.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms and conditions of the GNU General Public License,
|
|
* version 2 or later, as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
* more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with
|
|
* this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/*
|
|
* Zvbc
|
|
*/
|
|
|
|
#define GEN_VV_MASKED_TRANS(NAME, CHECK) \
|
|
static bool trans_##NAME(DisasContext *s, arg_rmrr *a) \
|
|
{ \
|
|
if (CHECK(s, a)) { \
|
|
return opivv_trans(a->rd, a->rs1, a->rs2, a->vm, \
|
|
gen_helper_##NAME, s); \
|
|
} \
|
|
return false; \
|
|
}
|
|
|
|
static bool vclmul_vv_check(DisasContext *s, arg_rmrr *a)
|
|
{
|
|
return opivv_check(s, a) &&
|
|
s->cfg_ptr->ext_zvbc == true &&
|
|
s->sew == MO_64;
|
|
}
|
|
|
|
GEN_VV_MASKED_TRANS(vclmul_vv, vclmul_vv_check)
|
|
GEN_VV_MASKED_TRANS(vclmulh_vv, vclmul_vv_check)
|
|
|
|
#define GEN_VX_MASKED_TRANS(NAME, CHECK) \
|
|
static bool trans_##NAME(DisasContext *s, arg_rmrr *a) \
|
|
{ \
|
|
if (CHECK(s, a)) { \
|
|
return opivx_trans(a->rd, a->rs1, a->rs2, a->vm, \
|
|
gen_helper_##NAME, s); \
|
|
} \
|
|
return false; \
|
|
}
|
|
|
|
static bool vclmul_vx_check(DisasContext *s, arg_rmrr *a)
|
|
{
|
|
return opivx_check(s, a) &&
|
|
s->cfg_ptr->ext_zvbc == true &&
|
|
s->sew == MO_64;
|
|
}
|
|
|
|
GEN_VX_MASKED_TRANS(vclmul_vx, vclmul_vx_check)
|
|
GEN_VX_MASKED_TRANS(vclmulh_vx, vclmul_vx_check)
|
|
|
|
/*
|
|
* Zvbb
|
|
*/
|
|
|
|
#define GEN_OPIVI_GVEC_TRANS_CHECK(NAME, IMM_MODE, OPIVX, SUF, CHECK) \
|
|
static bool trans_##NAME(DisasContext *s, arg_rmrr *a) \
|
|
{ \
|
|
if (CHECK(s, a)) { \
|
|
static gen_helper_opivx *const fns[4] = { \
|
|
gen_helper_##OPIVX##_b, \
|
|
gen_helper_##OPIVX##_h, \
|
|
gen_helper_##OPIVX##_w, \
|
|
gen_helper_##OPIVX##_d, \
|
|
}; \
|
|
return do_opivi_gvec(s, a, tcg_gen_gvec_##SUF, fns[s->sew], \
|
|
IMM_MODE); \
|
|
} \
|
|
return false; \
|
|
}
|
|
|
|
#define GEN_OPIVV_GVEC_TRANS_CHECK(NAME, SUF, CHECK) \
|
|
static bool trans_##NAME(DisasContext *s, arg_rmrr *a) \
|
|
{ \
|
|
if (CHECK(s, a)) { \
|
|
static gen_helper_gvec_4_ptr *const fns[4] = { \
|
|
gen_helper_##NAME##_b, \
|
|
gen_helper_##NAME##_h, \
|
|
gen_helper_##NAME##_w, \
|
|
gen_helper_##NAME##_d, \
|
|
}; \
|
|
return do_opivv_gvec(s, a, tcg_gen_gvec_##SUF, fns[s->sew]); \
|
|
} \
|
|
return false; \
|
|
}
|
|
|
|
#define GEN_OPIVX_GVEC_SHIFT_TRANS_CHECK(NAME, SUF, CHECK) \
|
|
static bool trans_##NAME(DisasContext *s, arg_rmrr *a) \
|
|
{ \
|
|
if (CHECK(s, a)) { \
|
|
static gen_helper_opivx *const fns[4] = { \
|
|
gen_helper_##NAME##_b, \
|
|
gen_helper_##NAME##_h, \
|
|
gen_helper_##NAME##_w, \
|
|
gen_helper_##NAME##_d, \
|
|
}; \
|
|
return do_opivx_gvec_shift(s, a, tcg_gen_gvec_##SUF, \
|
|
fns[s->sew]); \
|
|
} \
|
|
return false; \
|
|
}
|
|
|
|
static bool zvbb_vv_check(DisasContext *s, arg_rmrr *a)
|
|
{
|
|
return opivv_check(s, a) && s->cfg_ptr->ext_zvbb == true;
|
|
}
|
|
|
|
static bool zvbb_vx_check(DisasContext *s, arg_rmrr *a)
|
|
{
|
|
return opivx_check(s, a) && s->cfg_ptr->ext_zvbb == true;
|
|
}
|
|
|
|
/* vrol.v[vx] */
|
|
GEN_OPIVV_GVEC_TRANS_CHECK(vrol_vv, rotlv, zvbb_vv_check)
|
|
GEN_OPIVX_GVEC_SHIFT_TRANS_CHECK(vrol_vx, rotls, zvbb_vx_check)
|
|
|
|
/* vror.v[vxi] */
|
|
GEN_OPIVV_GVEC_TRANS_CHECK(vror_vv, rotrv, zvbb_vv_check)
|
|
GEN_OPIVX_GVEC_SHIFT_TRANS_CHECK(vror_vx, rotrs, zvbb_vx_check)
|
|
GEN_OPIVI_GVEC_TRANS_CHECK(vror_vi, IMM_TRUNC_SEW, vror_vx, rotri, zvbb_vx_check)
|
|
|
|
#define GEN_OPIVX_GVEC_TRANS_CHECK(NAME, SUF, CHECK) \
|
|
static bool trans_##NAME(DisasContext *s, arg_rmrr *a) \
|
|
{ \
|
|
if (CHECK(s, a)) { \
|
|
static gen_helper_opivx *const fns[4] = { \
|
|
gen_helper_##NAME##_b, \
|
|
gen_helper_##NAME##_h, \
|
|
gen_helper_##NAME##_w, \
|
|
gen_helper_##NAME##_d, \
|
|
}; \
|
|
return do_opivx_gvec(s, a, tcg_gen_gvec_##SUF, fns[s->sew]); \
|
|
} \
|
|
return false; \
|
|
}
|
|
|
|
/* vandn.v[vx] */
|
|
GEN_OPIVV_GVEC_TRANS_CHECK(vandn_vv, andc, zvbb_vv_check)
|
|
GEN_OPIVX_GVEC_TRANS_CHECK(vandn_vx, andcs, zvbb_vx_check)
|
|
|
|
#define GEN_OPIV_TRANS(NAME, CHECK) \
|
|
static bool trans_##NAME(DisasContext *s, arg_rmr *a) \
|
|
{ \
|
|
if (CHECK(s, a)) { \
|
|
uint32_t data = 0; \
|
|
static gen_helper_gvec_3_ptr *const fns[4] = { \
|
|
gen_helper_##NAME##_b, \
|
|
gen_helper_##NAME##_h, \
|
|
gen_helper_##NAME##_w, \
|
|
gen_helper_##NAME##_d, \
|
|
}; \
|
|
TCGLabel *over = gen_new_label(); \
|
|
tcg_gen_brcond_tl(TCG_COND_GEU, cpu_vstart, cpu_vl, over); \
|
|
\
|
|
data = FIELD_DP32(data, VDATA, VM, a->vm); \
|
|
data = FIELD_DP32(data, VDATA, LMUL, s->lmul); \
|
|
data = FIELD_DP32(data, VDATA, VTA, s->vta); \
|
|
data = FIELD_DP32(data, VDATA, VTA_ALL_1S, s->cfg_vta_all_1s); \
|
|
data = FIELD_DP32(data, VDATA, VMA, s->vma); \
|
|
tcg_gen_gvec_3_ptr(vreg_ofs(s, a->rd), vreg_ofs(s, 0), \
|
|
vreg_ofs(s, a->rs2), tcg_env, \
|
|
s->cfg_ptr->vlen / 8, s->cfg_ptr->vlen / 8, \
|
|
data, fns[s->sew]); \
|
|
mark_vs_dirty(s); \
|
|
gen_set_label(over); \
|
|
return true; \
|
|
} \
|
|
return false; \
|
|
}
|
|
|
|
static bool zvbb_opiv_check(DisasContext *s, arg_rmr *a)
|
|
{
|
|
return s->cfg_ptr->ext_zvbb == true &&
|
|
require_rvv(s) &&
|
|
vext_check_isa_ill(s) &&
|
|
vext_check_ss(s, a->rd, a->rs2, a->vm);
|
|
}
|
|
|
|
GEN_OPIV_TRANS(vbrev8_v, zvbb_opiv_check)
|
|
GEN_OPIV_TRANS(vrev8_v, zvbb_opiv_check)
|
|
GEN_OPIV_TRANS(vbrev_v, zvbb_opiv_check)
|
|
GEN_OPIV_TRANS(vclz_v, zvbb_opiv_check)
|
|
GEN_OPIV_TRANS(vctz_v, zvbb_opiv_check)
|
|
GEN_OPIV_TRANS(vcpop_v, zvbb_opiv_check)
|
|
|
|
static bool vwsll_vv_check(DisasContext *s, arg_rmrr *a)
|
|
{
|
|
return s->cfg_ptr->ext_zvbb && opivv_widen_check(s, a);
|
|
}
|
|
|
|
static bool vwsll_vx_check(DisasContext *s, arg_rmrr *a)
|
|
{
|
|
return s->cfg_ptr->ext_zvbb && opivx_widen_check(s, a);
|
|
}
|
|
|
|
/* OPIVI without GVEC IR */
|
|
#define GEN_OPIVI_WIDEN_TRANS(NAME, IMM_MODE, OPIVX, CHECK) \
|
|
static bool trans_##NAME(DisasContext *s, arg_rmrr *a) \
|
|
{ \
|
|
if (CHECK(s, a)) { \
|
|
static gen_helper_opivx *const fns[3] = { \
|
|
gen_helper_##OPIVX##_b, \
|
|
gen_helper_##OPIVX##_h, \
|
|
gen_helper_##OPIVX##_w, \
|
|
}; \
|
|
return opivi_trans(a->rd, a->rs1, a->rs2, a->vm, fns[s->sew], s, \
|
|
IMM_MODE); \
|
|
} \
|
|
return false; \
|
|
}
|
|
|
|
GEN_OPIVV_WIDEN_TRANS(vwsll_vv, vwsll_vv_check)
|
|
GEN_OPIVX_WIDEN_TRANS(vwsll_vx, vwsll_vx_check)
|
|
GEN_OPIVI_WIDEN_TRANS(vwsll_vi, IMM_ZX, vwsll_vx, vwsll_vx_check)
|
|
|
|
/*
|
|
* Zvkned
|
|
*/
|
|
|
|
#define ZVKNED_EGS 4
|
|
|
|
#define GEN_V_UNMASKED_TRANS(NAME, CHECK, EGS) \
|
|
static bool trans_##NAME(DisasContext *s, arg_##NAME *a) \
|
|
{ \
|
|
if (CHECK(s, a)) { \
|
|
TCGv_ptr rd_v, rs2_v; \
|
|
TCGv_i32 desc, egs; \
|
|
uint32_t data = 0; \
|
|
TCGLabel *over = gen_new_label(); \
|
|
\
|
|
if (!s->vstart_eq_zero || !s->vl_eq_vlmax) { \
|
|
/* save opcode for unwinding in case we throw an exception */ \
|
|
decode_save_opc(s); \
|
|
egs = tcg_constant_i32(EGS); \
|
|
gen_helper_egs_check(egs, tcg_env); \
|
|
tcg_gen_brcond_tl(TCG_COND_GEU, cpu_vstart, cpu_vl, over); \
|
|
} \
|
|
\
|
|
data = FIELD_DP32(data, VDATA, VM, a->vm); \
|
|
data = FIELD_DP32(data, VDATA, LMUL, s->lmul); \
|
|
data = FIELD_DP32(data, VDATA, VTA, s->vta); \
|
|
data = FIELD_DP32(data, VDATA, VTA_ALL_1S, s->cfg_vta_all_1s); \
|
|
data = FIELD_DP32(data, VDATA, VMA, s->vma); \
|
|
rd_v = tcg_temp_new_ptr(); \
|
|
rs2_v = tcg_temp_new_ptr(); \
|
|
desc = tcg_constant_i32( \
|
|
simd_desc(s->cfg_ptr->vlen / 8, s->cfg_ptr->vlen / 8, data)); \
|
|
tcg_gen_addi_ptr(rd_v, tcg_env, vreg_ofs(s, a->rd)); \
|
|
tcg_gen_addi_ptr(rs2_v, tcg_env, vreg_ofs(s, a->rs2)); \
|
|
gen_helper_##NAME(rd_v, rs2_v, tcg_env, desc); \
|
|
mark_vs_dirty(s); \
|
|
gen_set_label(over); \
|
|
return true; \
|
|
} \
|
|
return false; \
|
|
}
|
|
|
|
static bool vaes_check_vv(DisasContext *s, arg_rmr *a)
|
|
{
|
|
int egw_bytes = ZVKNED_EGS << s->sew;
|
|
return s->cfg_ptr->ext_zvkned == true &&
|
|
require_rvv(s) &&
|
|
vext_check_isa_ill(s) &&
|
|
MAXSZ(s) >= egw_bytes &&
|
|
require_align(a->rd, s->lmul) &&
|
|
require_align(a->rs2, s->lmul) &&
|
|
s->sew == MO_32;
|
|
}
|
|
|
|
static bool vaes_check_overlap(DisasContext *s, int vd, int vs2)
|
|
{
|
|
int8_t op_size = s->lmul <= 0 ? 1 : 1 << s->lmul;
|
|
return !is_overlapped(vd, op_size, vs2, 1);
|
|
}
|
|
|
|
static bool vaes_check_vs(DisasContext *s, arg_rmr *a)
|
|
{
|
|
int egw_bytes = ZVKNED_EGS << s->sew;
|
|
return vaes_check_overlap(s, a->rd, a->rs2) &&
|
|
MAXSZ(s) >= egw_bytes &&
|
|
s->cfg_ptr->ext_zvkned == true &&
|
|
require_rvv(s) &&
|
|
vext_check_isa_ill(s) &&
|
|
require_align(a->rd, s->lmul) &&
|
|
s->sew == MO_32;
|
|
}
|
|
|
|
GEN_V_UNMASKED_TRANS(vaesef_vv, vaes_check_vv, ZVKNED_EGS)
|
|
GEN_V_UNMASKED_TRANS(vaesef_vs, vaes_check_vs, ZVKNED_EGS)
|
|
GEN_V_UNMASKED_TRANS(vaesdf_vv, vaes_check_vv, ZVKNED_EGS)
|
|
GEN_V_UNMASKED_TRANS(vaesdf_vs, vaes_check_vs, ZVKNED_EGS)
|
|
GEN_V_UNMASKED_TRANS(vaesdm_vv, vaes_check_vv, ZVKNED_EGS)
|
|
GEN_V_UNMASKED_TRANS(vaesdm_vs, vaes_check_vs, ZVKNED_EGS)
|
|
GEN_V_UNMASKED_TRANS(vaesz_vs, vaes_check_vs, ZVKNED_EGS)
|
|
GEN_V_UNMASKED_TRANS(vaesem_vv, vaes_check_vv, ZVKNED_EGS)
|
|
GEN_V_UNMASKED_TRANS(vaesem_vs, vaes_check_vs, ZVKNED_EGS)
|
|
|
|
#define GEN_VI_UNMASKED_TRANS(NAME, CHECK, EGS) \
|
|
static bool trans_##NAME(DisasContext *s, arg_##NAME *a) \
|
|
{ \
|
|
if (CHECK(s, a)) { \
|
|
TCGv_ptr rd_v, rs2_v; \
|
|
TCGv_i32 uimm_v, desc, egs; \
|
|
uint32_t data = 0; \
|
|
TCGLabel *over = gen_new_label(); \
|
|
\
|
|
if (!s->vstart_eq_zero || !s->vl_eq_vlmax) { \
|
|
/* save opcode for unwinding in case we throw an exception */ \
|
|
decode_save_opc(s); \
|
|
egs = tcg_constant_i32(EGS); \
|
|
gen_helper_egs_check(egs, tcg_env); \
|
|
tcg_gen_brcond_tl(TCG_COND_GEU, cpu_vstart, cpu_vl, over); \
|
|
} \
|
|
\
|
|
data = FIELD_DP32(data, VDATA, VM, a->vm); \
|
|
data = FIELD_DP32(data, VDATA, LMUL, s->lmul); \
|
|
data = FIELD_DP32(data, VDATA, VTA, s->vta); \
|
|
data = FIELD_DP32(data, VDATA, VTA_ALL_1S, s->cfg_vta_all_1s); \
|
|
data = FIELD_DP32(data, VDATA, VMA, s->vma); \
|
|
\
|
|
rd_v = tcg_temp_new_ptr(); \
|
|
rs2_v = tcg_temp_new_ptr(); \
|
|
uimm_v = tcg_constant_i32(a->rs1); \
|
|
desc = tcg_constant_i32( \
|
|
simd_desc(s->cfg_ptr->vlen / 8, s->cfg_ptr->vlen / 8, data)); \
|
|
tcg_gen_addi_ptr(rd_v, tcg_env, vreg_ofs(s, a->rd)); \
|
|
tcg_gen_addi_ptr(rs2_v, tcg_env, vreg_ofs(s, a->rs2)); \
|
|
gen_helper_##NAME(rd_v, rs2_v, uimm_v, tcg_env, desc); \
|
|
mark_vs_dirty(s); \
|
|
gen_set_label(over); \
|
|
return true; \
|
|
} \
|
|
return false; \
|
|
}
|
|
|
|
static bool vaeskf1_check(DisasContext *s, arg_vaeskf1_vi *a)
|
|
{
|
|
int egw_bytes = ZVKNED_EGS << s->sew;
|
|
return s->cfg_ptr->ext_zvkned == true &&
|
|
require_rvv(s) &&
|
|
vext_check_isa_ill(s) &&
|
|
MAXSZ(s) >= egw_bytes &&
|
|
s->sew == MO_32 &&
|
|
require_align(a->rd, s->lmul) &&
|
|
require_align(a->rs2, s->lmul);
|
|
}
|
|
|
|
static bool vaeskf2_check(DisasContext *s, arg_vaeskf2_vi *a)
|
|
{
|
|
int egw_bytes = ZVKNED_EGS << s->sew;
|
|
return s->cfg_ptr->ext_zvkned == true &&
|
|
require_rvv(s) &&
|
|
vext_check_isa_ill(s) &&
|
|
MAXSZ(s) >= egw_bytes &&
|
|
s->sew == MO_32 &&
|
|
require_align(a->rd, s->lmul) &&
|
|
require_align(a->rs2, s->lmul);
|
|
}
|
|
|
|
GEN_VI_UNMASKED_TRANS(vaeskf1_vi, vaeskf1_check, ZVKNED_EGS)
|
|
GEN_VI_UNMASKED_TRANS(vaeskf2_vi, vaeskf2_check, ZVKNED_EGS)
|
|
|
|
/*
|
|
* Zvknh
|
|
*/
|
|
|
|
#define ZVKNH_EGS 4
|
|
|
|
#define GEN_VV_UNMASKED_TRANS(NAME, CHECK, EGS) \
|
|
static bool trans_##NAME(DisasContext *s, arg_rmrr *a) \
|
|
{ \
|
|
if (CHECK(s, a)) { \
|
|
uint32_t data = 0; \
|
|
TCGLabel *over = gen_new_label(); \
|
|
TCGv_i32 egs; \
|
|
\
|
|
if (!s->vstart_eq_zero || !s->vl_eq_vlmax) { \
|
|
/* save opcode for unwinding in case we throw an exception */ \
|
|
decode_save_opc(s); \
|
|
egs = tcg_constant_i32(EGS); \
|
|
gen_helper_egs_check(egs, tcg_env); \
|
|
tcg_gen_brcond_tl(TCG_COND_GEU, cpu_vstart, cpu_vl, over); \
|
|
} \
|
|
\
|
|
data = FIELD_DP32(data, VDATA, VM, a->vm); \
|
|
data = FIELD_DP32(data, VDATA, LMUL, s->lmul); \
|
|
data = FIELD_DP32(data, VDATA, VTA, s->vta); \
|
|
data = FIELD_DP32(data, VDATA, VTA_ALL_1S, s->cfg_vta_all_1s); \
|
|
data = FIELD_DP32(data, VDATA, VMA, s->vma); \
|
|
\
|
|
tcg_gen_gvec_3_ptr(vreg_ofs(s, a->rd), vreg_ofs(s, a->rs1), \
|
|
vreg_ofs(s, a->rs2), tcg_env, \
|
|
s->cfg_ptr->vlen / 8, s->cfg_ptr->vlen / 8, \
|
|
data, gen_helper_##NAME); \
|
|
\
|
|
mark_vs_dirty(s); \
|
|
gen_set_label(over); \
|
|
return true; \
|
|
} \
|
|
return false; \
|
|
}
|
|
|
|
static bool vsha_check_sew(DisasContext *s)
|
|
{
|
|
return (s->cfg_ptr->ext_zvknha == true && s->sew == MO_32) ||
|
|
(s->cfg_ptr->ext_zvknhb == true &&
|
|
(s->sew == MO_32 || s->sew == MO_64));
|
|
}
|
|
|
|
static bool vsha_check(DisasContext *s, arg_rmrr *a)
|
|
{
|
|
int egw_bytes = ZVKNH_EGS << s->sew;
|
|
int mult = 1 << MAX(s->lmul, 0);
|
|
return opivv_check(s, a) &&
|
|
vsha_check_sew(s) &&
|
|
MAXSZ(s) >= egw_bytes &&
|
|
!is_overlapped(a->rd, mult, a->rs1, mult) &&
|
|
!is_overlapped(a->rd, mult, a->rs2, mult) &&
|
|
s->lmul >= 0;
|
|
}
|
|
|
|
GEN_VV_UNMASKED_TRANS(vsha2ms_vv, vsha_check, ZVKNH_EGS)
|
|
|
|
static bool trans_vsha2cl_vv(DisasContext *s, arg_rmrr *a)
|
|
{
|
|
if (vsha_check(s, a)) {
|
|
uint32_t data = 0;
|
|
TCGLabel *over = gen_new_label();
|
|
TCGv_i32 egs;
|
|
|
|
if (!s->vstart_eq_zero || !s->vl_eq_vlmax) {
|
|
/* save opcode for unwinding in case we throw an exception */
|
|
decode_save_opc(s);
|
|
egs = tcg_constant_i32(ZVKNH_EGS);
|
|
gen_helper_egs_check(egs, tcg_env);
|
|
tcg_gen_brcond_tl(TCG_COND_GEU, cpu_vstart, cpu_vl, over);
|
|
}
|
|
|
|
data = FIELD_DP32(data, VDATA, VM, a->vm);
|
|
data = FIELD_DP32(data, VDATA, LMUL, s->lmul);
|
|
data = FIELD_DP32(data, VDATA, VTA, s->vta);
|
|
data = FIELD_DP32(data, VDATA, VTA_ALL_1S, s->cfg_vta_all_1s);
|
|
data = FIELD_DP32(data, VDATA, VMA, s->vma);
|
|
|
|
tcg_gen_gvec_3_ptr(vreg_ofs(s, a->rd), vreg_ofs(s, a->rs1),
|
|
vreg_ofs(s, a->rs2), tcg_env, s->cfg_ptr->vlen / 8,
|
|
s->cfg_ptr->vlen / 8, data,
|
|
s->sew == MO_32 ?
|
|
gen_helper_vsha2cl32_vv : gen_helper_vsha2cl64_vv);
|
|
|
|
mark_vs_dirty(s);
|
|
gen_set_label(over);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool trans_vsha2ch_vv(DisasContext *s, arg_rmrr *a)
|
|
{
|
|
if (vsha_check(s, a)) {
|
|
uint32_t data = 0;
|
|
TCGLabel *over = gen_new_label();
|
|
TCGv_i32 egs;
|
|
|
|
if (!s->vstart_eq_zero || !s->vl_eq_vlmax) {
|
|
/* save opcode for unwinding in case we throw an exception */
|
|
decode_save_opc(s);
|
|
egs = tcg_constant_i32(ZVKNH_EGS);
|
|
gen_helper_egs_check(egs, tcg_env);
|
|
tcg_gen_brcond_tl(TCG_COND_GEU, cpu_vstart, cpu_vl, over);
|
|
}
|
|
|
|
data = FIELD_DP32(data, VDATA, VM, a->vm);
|
|
data = FIELD_DP32(data, VDATA, LMUL, s->lmul);
|
|
data = FIELD_DP32(data, VDATA, VTA, s->vta);
|
|
data = FIELD_DP32(data, VDATA, VTA_ALL_1S, s->cfg_vta_all_1s);
|
|
data = FIELD_DP32(data, VDATA, VMA, s->vma);
|
|
|
|
tcg_gen_gvec_3_ptr(vreg_ofs(s, a->rd), vreg_ofs(s, a->rs1),
|
|
vreg_ofs(s, a->rs2), tcg_env, s->cfg_ptr->vlen / 8,
|
|
s->cfg_ptr->vlen / 8, data,
|
|
s->sew == MO_32 ?
|
|
gen_helper_vsha2ch32_vv : gen_helper_vsha2ch64_vv);
|
|
|
|
mark_vs_dirty(s);
|
|
gen_set_label(over);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* Zvksh
|
|
*/
|
|
|
|
#define ZVKSH_EGS 8
|
|
|
|
static inline bool vsm3_check(DisasContext *s, arg_rmrr *a)
|
|
{
|
|
int egw_bytes = ZVKSH_EGS << s->sew;
|
|
int mult = 1 << MAX(s->lmul, 0);
|
|
return s->cfg_ptr->ext_zvksh == true &&
|
|
require_rvv(s) &&
|
|
vext_check_isa_ill(s) &&
|
|
!is_overlapped(a->rd, mult, a->rs2, mult) &&
|
|
MAXSZ(s) >= egw_bytes &&
|
|
s->sew == MO_32;
|
|
}
|
|
|
|
static inline bool vsm3me_check(DisasContext *s, arg_rmrr *a)
|
|
{
|
|
return vsm3_check(s, a) && vext_check_sss(s, a->rd, a->rs1, a->rs2, a->vm);
|
|
}
|
|
|
|
static inline bool vsm3c_check(DisasContext *s, arg_rmrr *a)
|
|
{
|
|
return vsm3_check(s, a) && vext_check_ss(s, a->rd, a->rs2, a->vm);
|
|
}
|
|
|
|
GEN_VV_UNMASKED_TRANS(vsm3me_vv, vsm3me_check, ZVKSH_EGS)
|
|
GEN_VI_UNMASKED_TRANS(vsm3c_vi, vsm3c_check, ZVKSH_EGS)
|
|
|
|
/*
|
|
* Zvkg
|
|
*/
|
|
|
|
#define ZVKG_EGS 4
|
|
|
|
static bool vgmul_check(DisasContext *s, arg_rmr *a)
|
|
{
|
|
int egw_bytes = ZVKG_EGS << s->sew;
|
|
return s->cfg_ptr->ext_zvkg == true &&
|
|
vext_check_isa_ill(s) &&
|
|
require_rvv(s) &&
|
|
MAXSZ(s) >= egw_bytes &&
|
|
vext_check_ss(s, a->rd, a->rs2, a->vm) &&
|
|
s->sew == MO_32;
|
|
}
|
|
|
|
GEN_V_UNMASKED_TRANS(vgmul_vv, vgmul_check, ZVKG_EGS)
|
|
|
|
static bool vghsh_check(DisasContext *s, arg_rmrr *a)
|
|
{
|
|
int egw_bytes = ZVKG_EGS << s->sew;
|
|
return s->cfg_ptr->ext_zvkg == true &&
|
|
opivv_check(s, a) &&
|
|
MAXSZ(s) >= egw_bytes &&
|
|
s->sew == MO_32;
|
|
}
|
|
|
|
GEN_VV_UNMASKED_TRANS(vghsh_vv, vghsh_check, ZVKG_EGS)
|
|
|
|
/*
|
|
* Zvksed
|
|
*/
|
|
|
|
#define ZVKSED_EGS 4
|
|
|
|
static bool zvksed_check(DisasContext *s)
|
|
{
|
|
int egw_bytes = ZVKSED_EGS << s->sew;
|
|
return s->cfg_ptr->ext_zvksed == true &&
|
|
require_rvv(s) &&
|
|
vext_check_isa_ill(s) &&
|
|
MAXSZ(s) >= egw_bytes &&
|
|
s->sew == MO_32;
|
|
}
|
|
|
|
static bool vsm4k_vi_check(DisasContext *s, arg_rmrr *a)
|
|
{
|
|
return zvksed_check(s) &&
|
|
require_align(a->rd, s->lmul) &&
|
|
require_align(a->rs2, s->lmul);
|
|
}
|
|
|
|
GEN_VI_UNMASKED_TRANS(vsm4k_vi, vsm4k_vi_check, ZVKSED_EGS)
|
|
|
|
static bool vsm4r_vv_check(DisasContext *s, arg_rmr *a)
|
|
{
|
|
return zvksed_check(s) &&
|
|
require_align(a->rd, s->lmul) &&
|
|
require_align(a->rs2, s->lmul);
|
|
}
|
|
|
|
GEN_V_UNMASKED_TRANS(vsm4r_vv, vsm4r_vv_check, ZVKSED_EGS)
|
|
|
|
static bool vsm4r_vs_check(DisasContext *s, arg_rmr *a)
|
|
{
|
|
return zvksed_check(s) &&
|
|
!is_overlapped(a->rd, 1 << MAX(s->lmul, 0), a->rs2, 1) &&
|
|
require_align(a->rd, s->lmul);
|
|
}
|
|
|
|
GEN_V_UNMASKED_TRANS(vsm4r_vs, vsm4r_vs_check, ZVKSED_EGS)
|