target/riscv/insn_trans/trans_rvh.c.inc

   1 /*
   2  * RISC-V translation routines for the RVXI Base Integer Instruction Set.
   3  *
   4  * Copyright (c) 2020 Western Digital
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms and conditions of the GNU General Public License,
   8  * version 2 or later, as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along with
  16  * this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #ifndef CONFIG_USER_ONLY
  20 static void check_access(DisasContext *ctx) {
  21     if (!ctx->hlsx) {
  22         if (ctx->virt_enabled) {
  23             generate_exception(ctx, RISCV_EXCP_VIRT_INSTRUCTION_FAULT);
  24         } else {
  25             generate_exception(ctx, RISCV_EXCP_ILLEGAL_INST);
  26         }
  27     }
  28 }
  29 #endif
  30
  31 static bool trans_hlv_b(DisasContext *ctx, arg_hlv_b *a)
  32 {
  33     REQUIRE_EXT(ctx, RVH);
  34 #ifndef CONFIG_USER_ONLY
  35     TCGv t0 = tcg_temp_new();
  36     TCGv t1 = tcg_temp_new();
  37
  38     check_access(ctx);
  39
  40     gen_get_gpr(t0, a->rs1);
  41
  42     tcg_gen_qemu_ld_tl(t1, t0, ctx->mem_idx | TB_FLAGS_PRIV_HYP_ACCESS_MASK, MO_SB);
  43     gen_set_gpr(a->rd, t1);
  44
  45     tcg_temp_free(t0);
  46     tcg_temp_free(t1);
  47     return true;
  48 #else
  49     return false;
  50 #endif
  51 }
  52
  53 static bool trans_hlv_h(DisasContext *ctx, arg_hlv_h *a)
  54 {
  55     REQUIRE_EXT(ctx, RVH);
  56 #ifndef CONFIG_USER_ONLY
  57     TCGv t0 = tcg_temp_new();
  58     TCGv t1 = tcg_temp_new();
  59
  60     check_access(ctx);
  61
  62     gen_get_gpr(t0, a->rs1);
  63
  64     tcg_gen_qemu_ld_tl(t1, t0, ctx->mem_idx | TB_FLAGS_PRIV_HYP_ACCESS_MASK, MO_TESW);
  65     gen_set_gpr(a->rd, t1);
  66
  67     tcg_temp_free(t0);
  68     tcg_temp_free(t1);
  69     return true;
  70 #else
  71     return false;
  72 #endif
  73 }
  74
  75 static bool trans_hlv_w(DisasContext *ctx, arg_hlv_w *a)
  76 {
  77     REQUIRE_EXT(ctx, RVH);
  78 #ifndef CONFIG_USER_ONLY
  79     TCGv t0 = tcg_temp_new();
  80     TCGv t1 = tcg_temp_new();
  81
  82     check_access(ctx);
  83
  84     gen_get_gpr(t0, a->rs1);
  85
  86     tcg_gen_qemu_ld_tl(t1, t0, ctx->mem_idx | TB_FLAGS_PRIV_HYP_ACCESS_MASK, MO_TESL);
  87     gen_set_gpr(a->rd, t1);
  88
  89     tcg_temp_free(t0);
  90     tcg_temp_free(t1);
  91     return true;
  92 #else
  93     return false;
  94 #endif
  95 }
  96
  97 static bool trans_hlv_bu(DisasContext *ctx, arg_hlv_bu *a)
  98 {
  99     REQUIRE_EXT(ctx, RVH);
 100 #ifndef CONFIG_USER_ONLY
 101     TCGv t0 = tcg_temp_new();
 102     TCGv t1 = tcg_temp_new();
 103
 104     check_access(ctx);
 105
 106     gen_get_gpr(t0, a->rs1);
 107
 108     tcg_gen_qemu_ld_tl(t1, t0, ctx->mem_idx | TB_FLAGS_PRIV_HYP_ACCESS_MASK, MO_UB);
 109     gen_set_gpr(a->rd, t1);
 110
 111     tcg_temp_free(t0);
 112     tcg_temp_free(t1);
 113     return true;
 114 #else
 115     return false;
 116 #endif
 117 }
 118
 119 static bool trans_hlv_hu(DisasContext *ctx, arg_hlv_hu *a)
 120 {
 121     REQUIRE_EXT(ctx, RVH);
 122 #ifndef CONFIG_USER_ONLY
 123     TCGv t0 = tcg_temp_new();
 124     TCGv t1 = tcg_temp_new();
 125
 126     check_access(ctx);
 127
 128     gen_get_gpr(t0, a->rs1);
 129     tcg_gen_qemu_ld_tl(t1, t0, ctx->mem_idx | TB_FLAGS_PRIV_HYP_ACCESS_MASK, MO_TEUW);
 130     gen_set_gpr(a->rd, t1);
 131
 132     tcg_temp_free(t0);
 133     tcg_temp_free(t1);
 134     return true;
 135 #else
 136     return false;
 137 #endif
 138 }
 139
 140 static bool trans_hsv_b(DisasContext *ctx, arg_hsv_b *a)
 141 {
 142     REQUIRE_EXT(ctx, RVH);
 143 #ifndef CONFIG_USER_ONLY
 144     TCGv t0 = tcg_temp_new();
 145     TCGv dat = tcg_temp_new();
 146
 147     check_access(ctx);
 148
 149     gen_get_gpr(t0, a->rs1);
 150     gen_get_gpr(dat, a->rs2);
 151
 152     tcg_gen_qemu_st_tl(dat, t0, ctx->mem_idx | TB_FLAGS_PRIV_HYP_ACCESS_MASK, MO_SB);
 153
 154     tcg_temp_free(t0);
 155     tcg_temp_free(dat);
 156     return true;
 157 #else
 158     return false;
 159 #endif
 160 }
 161
 162 static bool trans_hsv_h(DisasContext *ctx, arg_hsv_h *a)
 163 {
 164     REQUIRE_EXT(ctx, RVH);
 165 #ifndef CONFIG_USER_ONLY
 166     TCGv t0 = tcg_temp_new();
 167     TCGv dat = tcg_temp_new();
 168
 169     check_access(ctx);
 170
 171     gen_get_gpr(t0, a->rs1);
 172     gen_get_gpr(dat, a->rs2);
 173
 174     tcg_gen_qemu_st_tl(dat, t0, ctx->mem_idx | TB_FLAGS_PRIV_HYP_ACCESS_MASK, MO_TESW);
 175
 176     tcg_temp_free(t0);
 177     tcg_temp_free(dat);
 178     return true;
 179 #else
 180     return false;
 181 #endif
 182 }
 183
 184 static bool trans_hsv_w(DisasContext *ctx, arg_hsv_w *a)
 185 {
 186     REQUIRE_EXT(ctx, RVH);
 187 #ifndef CONFIG_USER_ONLY
 188     TCGv t0 = tcg_temp_new();
 189     TCGv dat = tcg_temp_new();
 190
 191     check_access(ctx);
 192
 193     gen_get_gpr(t0, a->rs1);
 194     gen_get_gpr(dat, a->rs2);
 195
 196     tcg_gen_qemu_st_tl(dat, t0, ctx->mem_idx | TB_FLAGS_PRIV_HYP_ACCESS_MASK, MO_TESL);
 197
 198     tcg_temp_free(t0);
 199     tcg_temp_free(dat);
 200     return true;
 201 #else
 202     return false;
 203 #endif
 204 }
 205
 206 #ifdef TARGET_RISCV64
 207 static bool trans_hlv_wu(DisasContext *ctx, arg_hlv_wu *a)
 208 {
 209     REQUIRE_EXT(ctx, RVH);
 210 #ifndef CONFIG_USER_ONLY
 211     TCGv t0 = tcg_temp_new();
 212     TCGv t1 = tcg_temp_new();
 213
 214     check_access(ctx);
 215
 216     gen_get_gpr(t0, a->rs1);
 217
 218     tcg_gen_qemu_ld_tl(t1, t0, ctx->mem_idx | TB_FLAGS_PRIV_HYP_ACCESS_MASK, MO_TEUL);
 219     gen_set_gpr(a->rd, t1);
 220
 221     tcg_temp_free(t0);
 222     tcg_temp_free(t1);
 223     return true;
 224 #else
 225     return false;
 226 #endif
 227 }
 228
 229 static bool trans_hlv_d(DisasContext *ctx, arg_hlv_d *a)
 230 {
 231     REQUIRE_EXT(ctx, RVH);
 232 #ifndef CONFIG_USER_ONLY
 233     TCGv t0 = tcg_temp_new();
 234     TCGv t1 = tcg_temp_new();
 235
 236     check_access(ctx);
 237
 238     gen_get_gpr(t0, a->rs1);
 239
 240     tcg_gen_qemu_ld_tl(t1, t0, ctx->mem_idx | TB_FLAGS_PRIV_HYP_ACCESS_MASK, MO_TEQ);
 241     gen_set_gpr(a->rd, t1);
 242
 243     tcg_temp_free(t0);
 244     tcg_temp_free(t1);
 245     return true;
 246 #else
 247     return false;
 248 #endif
 249 }
 250
 251 static bool trans_hsv_d(DisasContext *ctx, arg_hsv_d *a)
 252 {
 253     REQUIRE_EXT(ctx, RVH);
 254 #ifndef CONFIG_USER_ONLY
 255     TCGv t0 = tcg_temp_new();
 256     TCGv dat = tcg_temp_new();
 257
 258     check_access(ctx);
 259
 260     gen_get_gpr(t0, a->rs1);
 261     gen_get_gpr(dat, a->rs2);
 262
 263     tcg_gen_qemu_st_tl(dat, t0, ctx->mem_idx | TB_FLAGS_PRIV_HYP_ACCESS_MASK, MO_TEQ);
 264
 265     tcg_temp_free(t0);
 266     tcg_temp_free(dat);
 267     return true;
 268 #else
 269     return false;
 270 #endif
 271 }
 272 #endif
 273
 274 static bool trans_hlvx_hu(DisasContext *ctx, arg_hlvx_hu *a)
 275 {
 276     REQUIRE_EXT(ctx, RVH);
 277 #ifndef CONFIG_USER_ONLY
 278     TCGv t0 = tcg_temp_new();
 279     TCGv t1 = tcg_temp_new();
 280
 281     check_access(ctx);
 282
 283     gen_get_gpr(t0, a->rs1);
 284
 285     gen_helper_hyp_hlvx_hu(t1, cpu_env, t0);
 286     gen_set_gpr(a->rd, t1);
 287
 288     tcg_temp_free(t0);
 289     tcg_temp_free(t1);
 290     return true;
 291 #else
 292     return false;
 293 #endif
 294 }
 295
 296 static bool trans_hlvx_wu(DisasContext *ctx, arg_hlvx_wu *a)
 297 {
 298     REQUIRE_EXT(ctx, RVH);
 299 #ifndef CONFIG_USER_ONLY
 300     TCGv t0 = tcg_temp_new();
 301     TCGv t1 = tcg_temp_new();
 302
 303     check_access(ctx);
 304
 305     gen_get_gpr(t0, a->rs1);
 306
 307     gen_helper_hyp_hlvx_wu(t1, cpu_env, t0);
 308     gen_set_gpr(a->rd, t1);
 309
 310     tcg_temp_free(t0);
 311     tcg_temp_free(t1);
 312     return true;
 313 #else
 314     return false;
 315 #endif
 316 }
 317
 318 static bool trans_hfence_gvma(DisasContext *ctx, arg_sfence_vma *a)
 319 {
 320     REQUIRE_EXT(ctx, RVH);
 321 #ifndef CONFIG_USER_ONLY
 322     gen_helper_hyp_gvma_tlb_flush(cpu_env);
 323     return true;
 324 #endif
 325     return false;
 326 }
 327
 328 static bool trans_hfence_vvma(DisasContext *ctx, arg_sfence_vma *a)
 329 {
 330     REQUIRE_EXT(ctx, RVH);
 331 #ifndef CONFIG_USER_ONLY
 332     gen_helper_hyp_tlb_flush(cpu_env);
 333     return true;
 334 #endif
 335     return false;
 336 }