1 /* 2 * RISC-V Vector Extension Helpers for QEMU. 3 * 4 * Copyright (c) 2020 T-Head Semiconductor Co., Ltd. All rights reserved. 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 #include "qemu/osdep.h" 20 #include "cpu.h" 21 #include "exec/memop.h" 22 #include "exec/exec-all.h" 23 #include "exec/helper-proto.h" 24 #include "fpu/softfloat.h" 25 #include "tcg/tcg-gvec-desc.h" 26 #include "internals.h" 27 #include <math.h> 28 29 target_ulong HELPER(vsetvl)(CPURISCVState *env, target_ulong s1, 30 target_ulong s2) 31 { 32 int vlmax, vl; 33 RISCVCPU *cpu = env_archcpu(env); 34 uint16_t sew = 8 << FIELD_EX64(s2, VTYPE, VSEW); 35 uint8_t ediv = FIELD_EX64(s2, VTYPE, VEDIV); 36 bool vill = FIELD_EX64(s2, VTYPE, VILL); 37 target_ulong reserved = FIELD_EX64(s2, VTYPE, RESERVED); 38 39 if ((sew > cpu->cfg.elen) || vill || (ediv != 0) || (reserved != 0)) { 40 /* only set vill bit. */ 41 env->vtype = FIELD_DP64(0, VTYPE, VILL, 1); 42 env->vl = 0; 43 env->vstart = 0; 44 return 0; 45 } 46 47 vlmax = vext_get_vlmax(cpu, s2); 48 if (s1 <= vlmax) { 49 vl = s1; 50 } else { 51 vl = vlmax; 52 } 53 env->vl = vl; 54 env->vtype = s2; 55 env->vstart = 0; 56 return vl; 57 } 58 59 /* 60 * Note that vector data is stored in host-endian 64-bit chunks, 61 * so addressing units smaller than that needs a host-endian fixup. 62 */ 63 #ifdef HOST_WORDS_BIGENDIAN 64 #define H1(x) ((x) ^ 7) 65 #define H1_2(x) ((x) ^ 6) 66 #define H1_4(x) ((x) ^ 4) 67 #define H2(x) ((x) ^ 3) 68 #define H4(x) ((x) ^ 1) 69 #define H8(x) ((x)) 70 #else 71 #define H1(x) (x) 72 #define H1_2(x) (x) 73 #define H1_4(x) (x) 74 #define H2(x) (x) 75 #define H4(x) (x) 76 #define H8(x) (x) 77 #endif 78 79 static inline uint32_t vext_nf(uint32_t desc) 80 { 81 return FIELD_EX32(simd_data(desc), VDATA, NF); 82 } 83 84 static inline uint32_t vext_mlen(uint32_t desc) 85 { 86 return FIELD_EX32(simd_data(desc), VDATA, MLEN); 87 } 88 89 static inline uint32_t vext_vm(uint32_t desc) 90 { 91 return FIELD_EX32(simd_data(desc), VDATA, VM); 92 } 93 94 static inline uint32_t vext_lmul(uint32_t desc) 95 { 96 return FIELD_EX32(simd_data(desc), VDATA, LMUL); 97 } 98 99 static uint32_t vext_wd(uint32_t desc) 100 { 101 return (simd_data(desc) >> 11) & 0x1; 102 } 103 104 /* 105 * Get vector group length in bytes. Its range is [64, 2048]. 106 * 107 * As simd_desc support at most 256, the max vlen is 512 bits. 108 * So vlen in bytes is encoded as maxsz. 109 */ 110 static inline uint32_t vext_maxsz(uint32_t desc) 111 { 112 return simd_maxsz(desc) << vext_lmul(desc); 113 } 114 115 /* 116 * This function checks watchpoint before real load operation. 117 * 118 * In softmmu mode, the TLB API probe_access is enough for watchpoint check. 119 * In user mode, there is no watchpoint support now. 120 * 121 * It will trigger an exception if there is no mapping in TLB 122 * and page table walk can't fill the TLB entry. Then the guest 123 * software can return here after process the exception or never return. 124 */ 125 static void probe_pages(CPURISCVState *env, target_ulong addr, 126 target_ulong len, uintptr_t ra, 127 MMUAccessType access_type) 128 { 129 target_ulong pagelen = -(addr | TARGET_PAGE_MASK); 130 target_ulong curlen = MIN(pagelen, len); 131 132 probe_access(env, addr, curlen, access_type, 133 cpu_mmu_index(env, false), ra); 134 if (len > curlen) { 135 addr += curlen; 136 curlen = len - curlen; 137 probe_access(env, addr, curlen, access_type, 138 cpu_mmu_index(env, false), ra); 139 } 140 } 141 142 #ifdef HOST_WORDS_BIGENDIAN 143 static void vext_clear(void *tail, uint32_t cnt, uint32_t tot) 144 { 145 /* 146 * Split the remaining range to two parts. 147 * The first part is in the last uint64_t unit. 148 * The second part start from the next uint64_t unit. 149 */ 150 int part1 = 0, part2 = tot - cnt; 151 if (cnt % 8) { 152 part1 = 8 - (cnt % 8); 153 part2 = tot - cnt - part1; 154 memset(QEMU_ALIGN_PTR_DOWN(tail, 8), 0, part1); 155 memset(QEMU_ALIGN_PTR_UP(tail, 8), 0, part2); 156 } else { 157 memset(tail, 0, part2); 158 } 159 } 160 #else 161 static void vext_clear(void *tail, uint32_t cnt, uint32_t tot) 162 { 163 memset(tail, 0, tot - cnt); 164 } 165 #endif 166 167 static void clearb(void *vd, uint32_t idx, uint32_t cnt, uint32_t tot) 168 { 169 int8_t *cur = ((int8_t *)vd + H1(idx)); 170 vext_clear(cur, cnt, tot); 171 } 172 173 static void clearh(void *vd, uint32_t idx, uint32_t cnt, uint32_t tot) 174 { 175 int16_t *cur = ((int16_t *)vd + H2(idx)); 176 vext_clear(cur, cnt, tot); 177 } 178 179 static void clearl(void *vd, uint32_t idx, uint32_t cnt, uint32_t tot) 180 { 181 int32_t *cur = ((int32_t *)vd + H4(idx)); 182 vext_clear(cur, cnt, tot); 183 } 184 185 static void clearq(void *vd, uint32_t idx, uint32_t cnt, uint32_t tot) 186 { 187 int64_t *cur = (int64_t *)vd + idx; 188 vext_clear(cur, cnt, tot); 189 } 190 191 static inline void vext_set_elem_mask(void *v0, int mlen, int index, 192 uint8_t value) 193 { 194 int idx = (index * mlen) / 64; 195 int pos = (index * mlen) % 64; 196 uint64_t old = ((uint64_t *)v0)[idx]; 197 ((uint64_t *)v0)[idx] = deposit64(old, pos, mlen, value); 198 } 199 200 static inline int vext_elem_mask(void *v0, int mlen, int index) 201 { 202 int idx = (index * mlen) / 64; 203 int pos = (index * mlen) % 64; 204 return (((uint64_t *)v0)[idx] >> pos) & 1; 205 } 206 207 /* elements operations for load and store */ 208 typedef void vext_ldst_elem_fn(CPURISCVState *env, target_ulong addr, 209 uint32_t idx, void *vd, uintptr_t retaddr); 210 typedef void clear_fn(void *vd, uint32_t idx, uint32_t cnt, uint32_t tot); 211 212 #define GEN_VEXT_LD_ELEM(NAME, MTYPE, ETYPE, H, LDSUF) \ 213 static void NAME(CPURISCVState *env, abi_ptr addr, \ 214 uint32_t idx, void *vd, uintptr_t retaddr)\ 215 { \ 216 MTYPE data; \ 217 ETYPE *cur = ((ETYPE *)vd + H(idx)); \ 218 data = cpu_##LDSUF##_data_ra(env, addr, retaddr); \ 219 *cur = data; \ 220 } \ 221 222 GEN_VEXT_LD_ELEM(ldb_b, int8_t, int8_t, H1, ldsb) 223 GEN_VEXT_LD_ELEM(ldb_h, int8_t, int16_t, H2, ldsb) 224 GEN_VEXT_LD_ELEM(ldb_w, int8_t, int32_t, H4, ldsb) 225 GEN_VEXT_LD_ELEM(ldb_d, int8_t, int64_t, H8, ldsb) 226 GEN_VEXT_LD_ELEM(ldh_h, int16_t, int16_t, H2, ldsw) 227 GEN_VEXT_LD_ELEM(ldh_w, int16_t, int32_t, H4, ldsw) 228 GEN_VEXT_LD_ELEM(ldh_d, int16_t, int64_t, H8, ldsw) 229 GEN_VEXT_LD_ELEM(ldw_w, int32_t, int32_t, H4, ldl) 230 GEN_VEXT_LD_ELEM(ldw_d, int32_t, int64_t, H8, ldl) 231 GEN_VEXT_LD_ELEM(lde_b, int8_t, int8_t, H1, ldsb) 232 GEN_VEXT_LD_ELEM(lde_h, int16_t, int16_t, H2, ldsw) 233 GEN_VEXT_LD_ELEM(lde_w, int32_t, int32_t, H4, ldl) 234 GEN_VEXT_LD_ELEM(lde_d, int64_t, int64_t, H8, ldq) 235 GEN_VEXT_LD_ELEM(ldbu_b, uint8_t, uint8_t, H1, ldub) 236 GEN_VEXT_LD_ELEM(ldbu_h, uint8_t, uint16_t, H2, ldub) 237 GEN_VEXT_LD_ELEM(ldbu_w, uint8_t, uint32_t, H4, ldub) 238 GEN_VEXT_LD_ELEM(ldbu_d, uint8_t, uint64_t, H8, ldub) 239 GEN_VEXT_LD_ELEM(ldhu_h, uint16_t, uint16_t, H2, lduw) 240 GEN_VEXT_LD_ELEM(ldhu_w, uint16_t, uint32_t, H4, lduw) 241 GEN_VEXT_LD_ELEM(ldhu_d, uint16_t, uint64_t, H8, lduw) 242 GEN_VEXT_LD_ELEM(ldwu_w, uint32_t, uint32_t, H4, ldl) 243 GEN_VEXT_LD_ELEM(ldwu_d, uint32_t, uint64_t, H8, ldl) 244 245 #define GEN_VEXT_ST_ELEM(NAME, ETYPE, H, STSUF) \ 246 static void NAME(CPURISCVState *env, abi_ptr addr, \ 247 uint32_t idx, void *vd, uintptr_t retaddr)\ 248 { \ 249 ETYPE data = *((ETYPE *)vd + H(idx)); \ 250 cpu_##STSUF##_data_ra(env, addr, data, retaddr); \ 251 } 252 253 GEN_VEXT_ST_ELEM(stb_b, int8_t, H1, stb) 254 GEN_VEXT_ST_ELEM(stb_h, int16_t, H2, stb) 255 GEN_VEXT_ST_ELEM(stb_w, int32_t, H4, stb) 256 GEN_VEXT_ST_ELEM(stb_d, int64_t, H8, stb) 257 GEN_VEXT_ST_ELEM(sth_h, int16_t, H2, stw) 258 GEN_VEXT_ST_ELEM(sth_w, int32_t, H4, stw) 259 GEN_VEXT_ST_ELEM(sth_d, int64_t, H8, stw) 260 GEN_VEXT_ST_ELEM(stw_w, int32_t, H4, stl) 261 GEN_VEXT_ST_ELEM(stw_d, int64_t, H8, stl) 262 GEN_VEXT_ST_ELEM(ste_b, int8_t, H1, stb) 263 GEN_VEXT_ST_ELEM(ste_h, int16_t, H2, stw) 264 GEN_VEXT_ST_ELEM(ste_w, int32_t, H4, stl) 265 GEN_VEXT_ST_ELEM(ste_d, int64_t, H8, stq) 266 267 /* 268 *** stride: access vector element from strided memory 269 */ 270 static void 271 vext_ldst_stride(void *vd, void *v0, target_ulong base, 272 target_ulong stride, CPURISCVState *env, 273 uint32_t desc, uint32_t vm, 274 vext_ldst_elem_fn *ldst_elem, clear_fn *clear_elem, 275 uint32_t esz, uint32_t msz, uintptr_t ra, 276 MMUAccessType access_type) 277 { 278 uint32_t i, k; 279 uint32_t nf = vext_nf(desc); 280 uint32_t mlen = vext_mlen(desc); 281 uint32_t vlmax = vext_maxsz(desc) / esz; 282 283 /* probe every access*/ 284 for (i = 0; i < env->vl; i++) { 285 if (!vm && !vext_elem_mask(v0, mlen, i)) { 286 continue; 287 } 288 probe_pages(env, base + stride * i, nf * msz, ra, access_type); 289 } 290 /* do real access */ 291 for (i = 0; i < env->vl; i++) { 292 k = 0; 293 if (!vm && !vext_elem_mask(v0, mlen, i)) { 294 continue; 295 } 296 while (k < nf) { 297 target_ulong addr = base + stride * i + k * msz; 298 ldst_elem(env, addr, i + k * vlmax, vd, ra); 299 k++; 300 } 301 } 302 /* clear tail elements */ 303 if (clear_elem) { 304 for (k = 0; k < nf; k++) { 305 clear_elem(vd, env->vl + k * vlmax, env->vl * esz, vlmax * esz); 306 } 307 } 308 } 309 310 #define GEN_VEXT_LD_STRIDE(NAME, MTYPE, ETYPE, LOAD_FN, CLEAR_FN) \ 311 void HELPER(NAME)(void *vd, void * v0, target_ulong base, \ 312 target_ulong stride, CPURISCVState *env, \ 313 uint32_t desc) \ 314 { \ 315 uint32_t vm = vext_vm(desc); \ 316 vext_ldst_stride(vd, v0, base, stride, env, desc, vm, LOAD_FN, \ 317 CLEAR_FN, sizeof(ETYPE), sizeof(MTYPE), \ 318 GETPC(), MMU_DATA_LOAD); \ 319 } 320 321 GEN_VEXT_LD_STRIDE(vlsb_v_b, int8_t, int8_t, ldb_b, clearb) 322 GEN_VEXT_LD_STRIDE(vlsb_v_h, int8_t, int16_t, ldb_h, clearh) 323 GEN_VEXT_LD_STRIDE(vlsb_v_w, int8_t, int32_t, ldb_w, clearl) 324 GEN_VEXT_LD_STRIDE(vlsb_v_d, int8_t, int64_t, ldb_d, clearq) 325 GEN_VEXT_LD_STRIDE(vlsh_v_h, int16_t, int16_t, ldh_h, clearh) 326 GEN_VEXT_LD_STRIDE(vlsh_v_w, int16_t, int32_t, ldh_w, clearl) 327 GEN_VEXT_LD_STRIDE(vlsh_v_d, int16_t, int64_t, ldh_d, clearq) 328 GEN_VEXT_LD_STRIDE(vlsw_v_w, int32_t, int32_t, ldw_w, clearl) 329 GEN_VEXT_LD_STRIDE(vlsw_v_d, int32_t, int64_t, ldw_d, clearq) 330 GEN_VEXT_LD_STRIDE(vlse_v_b, int8_t, int8_t, lde_b, clearb) 331 GEN_VEXT_LD_STRIDE(vlse_v_h, int16_t, int16_t, lde_h, clearh) 332 GEN_VEXT_LD_STRIDE(vlse_v_w, int32_t, int32_t, lde_w, clearl) 333 GEN_VEXT_LD_STRIDE(vlse_v_d, int64_t, int64_t, lde_d, clearq) 334 GEN_VEXT_LD_STRIDE(vlsbu_v_b, uint8_t, uint8_t, ldbu_b, clearb) 335 GEN_VEXT_LD_STRIDE(vlsbu_v_h, uint8_t, uint16_t, ldbu_h, clearh) 336 GEN_VEXT_LD_STRIDE(vlsbu_v_w, uint8_t, uint32_t, ldbu_w, clearl) 337 GEN_VEXT_LD_STRIDE(vlsbu_v_d, uint8_t, uint64_t, ldbu_d, clearq) 338 GEN_VEXT_LD_STRIDE(vlshu_v_h, uint16_t, uint16_t, ldhu_h, clearh) 339 GEN_VEXT_LD_STRIDE(vlshu_v_w, uint16_t, uint32_t, ldhu_w, clearl) 340 GEN_VEXT_LD_STRIDE(vlshu_v_d, uint16_t, uint64_t, ldhu_d, clearq) 341 GEN_VEXT_LD_STRIDE(vlswu_v_w, uint32_t, uint32_t, ldwu_w, clearl) 342 GEN_VEXT_LD_STRIDE(vlswu_v_d, uint32_t, uint64_t, ldwu_d, clearq) 343 344 #define GEN_VEXT_ST_STRIDE(NAME, MTYPE, ETYPE, STORE_FN) \ 345 void HELPER(NAME)(void *vd, void *v0, target_ulong base, \ 346 target_ulong stride, CPURISCVState *env, \ 347 uint32_t desc) \ 348 { \ 349 uint32_t vm = vext_vm(desc); \ 350 vext_ldst_stride(vd, v0, base, stride, env, desc, vm, STORE_FN, \ 351 NULL, sizeof(ETYPE), sizeof(MTYPE), \ 352 GETPC(), MMU_DATA_STORE); \ 353 } 354 355 GEN_VEXT_ST_STRIDE(vssb_v_b, int8_t, int8_t, stb_b) 356 GEN_VEXT_ST_STRIDE(vssb_v_h, int8_t, int16_t, stb_h) 357 GEN_VEXT_ST_STRIDE(vssb_v_w, int8_t, int32_t, stb_w) 358 GEN_VEXT_ST_STRIDE(vssb_v_d, int8_t, int64_t, stb_d) 359 GEN_VEXT_ST_STRIDE(vssh_v_h, int16_t, int16_t, sth_h) 360 GEN_VEXT_ST_STRIDE(vssh_v_w, int16_t, int32_t, sth_w) 361 GEN_VEXT_ST_STRIDE(vssh_v_d, int16_t, int64_t, sth_d) 362 GEN_VEXT_ST_STRIDE(vssw_v_w, int32_t, int32_t, stw_w) 363 GEN_VEXT_ST_STRIDE(vssw_v_d, int32_t, int64_t, stw_d) 364 GEN_VEXT_ST_STRIDE(vsse_v_b, int8_t, int8_t, ste_b) 365 GEN_VEXT_ST_STRIDE(vsse_v_h, int16_t, int16_t, ste_h) 366 GEN_VEXT_ST_STRIDE(vsse_v_w, int32_t, int32_t, ste_w) 367 GEN_VEXT_ST_STRIDE(vsse_v_d, int64_t, int64_t, ste_d) 368 369 /* 370 *** unit-stride: access elements stored contiguously in memory 371 */ 372 373 /* unmasked unit-stride load and store operation*/ 374 static void 375 vext_ldst_us(void *vd, target_ulong base, CPURISCVState *env, uint32_t desc, 376 vext_ldst_elem_fn *ldst_elem, clear_fn *clear_elem, 377 uint32_t esz, uint32_t msz, uintptr_t ra, 378 MMUAccessType access_type) 379 { 380 uint32_t i, k; 381 uint32_t nf = vext_nf(desc); 382 uint32_t vlmax = vext_maxsz(desc) / esz; 383 384 /* probe every access */ 385 probe_pages(env, base, env->vl * nf * msz, ra, access_type); 386 /* load bytes from guest memory */ 387 for (i = 0; i < env->vl; i++) { 388 k = 0; 389 while (k < nf) { 390 target_ulong addr = base + (i * nf + k) * msz; 391 ldst_elem(env, addr, i + k * vlmax, vd, ra); 392 k++; 393 } 394 } 395 /* clear tail elements */ 396 if (clear_elem) { 397 for (k = 0; k < nf; k++) { 398 clear_elem(vd, env->vl + k * vlmax, env->vl * esz, vlmax * esz); 399 } 400 } 401 } 402 403 /* 404 * masked unit-stride load and store operation will be a special case of stride, 405 * stride = NF * sizeof (MTYPE) 406 */ 407 408 #define GEN_VEXT_LD_US(NAME, MTYPE, ETYPE, LOAD_FN, CLEAR_FN) \ 409 void HELPER(NAME##_mask)(void *vd, void *v0, target_ulong base, \ 410 CPURISCVState *env, uint32_t desc) \ 411 { \ 412 uint32_t stride = vext_nf(desc) * sizeof(MTYPE); \ 413 vext_ldst_stride(vd, v0, base, stride, env, desc, false, LOAD_FN, \ 414 CLEAR_FN, sizeof(ETYPE), sizeof(MTYPE), \ 415 GETPC(), MMU_DATA_LOAD); \ 416 } \ 417 \ 418 void HELPER(NAME)(void *vd, void *v0, target_ulong base, \ 419 CPURISCVState *env, uint32_t desc) \ 420 { \ 421 vext_ldst_us(vd, base, env, desc, LOAD_FN, CLEAR_FN, \ 422 sizeof(ETYPE), sizeof(MTYPE), GETPC(), MMU_DATA_LOAD); \ 423 } 424 425 GEN_VEXT_LD_US(vlb_v_b, int8_t, int8_t, ldb_b, clearb) 426 GEN_VEXT_LD_US(vlb_v_h, int8_t, int16_t, ldb_h, clearh) 427 GEN_VEXT_LD_US(vlb_v_w, int8_t, int32_t, ldb_w, clearl) 428 GEN_VEXT_LD_US(vlb_v_d, int8_t, int64_t, ldb_d, clearq) 429 GEN_VEXT_LD_US(vlh_v_h, int16_t, int16_t, ldh_h, clearh) 430 GEN_VEXT_LD_US(vlh_v_w, int16_t, int32_t, ldh_w, clearl) 431 GEN_VEXT_LD_US(vlh_v_d, int16_t, int64_t, ldh_d, clearq) 432 GEN_VEXT_LD_US(vlw_v_w, int32_t, int32_t, ldw_w, clearl) 433 GEN_VEXT_LD_US(vlw_v_d, int32_t, int64_t, ldw_d, clearq) 434 GEN_VEXT_LD_US(vle_v_b, int8_t, int8_t, lde_b, clearb) 435 GEN_VEXT_LD_US(vle_v_h, int16_t, int16_t, lde_h, clearh) 436 GEN_VEXT_LD_US(vle_v_w, int32_t, int32_t, lde_w, clearl) 437 GEN_VEXT_LD_US(vle_v_d, int64_t, int64_t, lde_d, clearq) 438 GEN_VEXT_LD_US(vlbu_v_b, uint8_t, uint8_t, ldbu_b, clearb) 439 GEN_VEXT_LD_US(vlbu_v_h, uint8_t, uint16_t, ldbu_h, clearh) 440 GEN_VEXT_LD_US(vlbu_v_w, uint8_t, uint32_t, ldbu_w, clearl) 441 GEN_VEXT_LD_US(vlbu_v_d, uint8_t, uint64_t, ldbu_d, clearq) 442 GEN_VEXT_LD_US(vlhu_v_h, uint16_t, uint16_t, ldhu_h, clearh) 443 GEN_VEXT_LD_US(vlhu_v_w, uint16_t, uint32_t, ldhu_w, clearl) 444 GEN_VEXT_LD_US(vlhu_v_d, uint16_t, uint64_t, ldhu_d, clearq) 445 GEN_VEXT_LD_US(vlwu_v_w, uint32_t, uint32_t, ldwu_w, clearl) 446 GEN_VEXT_LD_US(vlwu_v_d, uint32_t, uint64_t, ldwu_d, clearq) 447 448 #define GEN_VEXT_ST_US(NAME, MTYPE, ETYPE, STORE_FN) \ 449 void HELPER(NAME##_mask)(void *vd, void *v0, target_ulong base, \ 450 CPURISCVState *env, uint32_t desc) \ 451 { \ 452 uint32_t stride = vext_nf(desc) * sizeof(MTYPE); \ 453 vext_ldst_stride(vd, v0, base, stride, env, desc, false, STORE_FN, \ 454 NULL, sizeof(ETYPE), sizeof(MTYPE), \ 455 GETPC(), MMU_DATA_STORE); \ 456 } \ 457 \ 458 void HELPER(NAME)(void *vd, void *v0, target_ulong base, \ 459 CPURISCVState *env, uint32_t desc) \ 460 { \ 461 vext_ldst_us(vd, base, env, desc, STORE_FN, NULL, \ 462 sizeof(ETYPE), sizeof(MTYPE), GETPC(), MMU_DATA_STORE);\ 463 } 464 465 GEN_VEXT_ST_US(vsb_v_b, int8_t, int8_t , stb_b) 466 GEN_VEXT_ST_US(vsb_v_h, int8_t, int16_t, stb_h) 467 GEN_VEXT_ST_US(vsb_v_w, int8_t, int32_t, stb_w) 468 GEN_VEXT_ST_US(vsb_v_d, int8_t, int64_t, stb_d) 469 GEN_VEXT_ST_US(vsh_v_h, int16_t, int16_t, sth_h) 470 GEN_VEXT_ST_US(vsh_v_w, int16_t, int32_t, sth_w) 471 GEN_VEXT_ST_US(vsh_v_d, int16_t, int64_t, sth_d) 472 GEN_VEXT_ST_US(vsw_v_w, int32_t, int32_t, stw_w) 473 GEN_VEXT_ST_US(vsw_v_d, int32_t, int64_t, stw_d) 474 GEN_VEXT_ST_US(vse_v_b, int8_t, int8_t , ste_b) 475 GEN_VEXT_ST_US(vse_v_h, int16_t, int16_t, ste_h) 476 GEN_VEXT_ST_US(vse_v_w, int32_t, int32_t, ste_w) 477 GEN_VEXT_ST_US(vse_v_d, int64_t, int64_t, ste_d) 478 479 /* 480 *** index: access vector element from indexed memory 481 */ 482 typedef target_ulong vext_get_index_addr(target_ulong base, 483 uint32_t idx, void *vs2); 484 485 #define GEN_VEXT_GET_INDEX_ADDR(NAME, ETYPE, H) \ 486 static target_ulong NAME(target_ulong base, \ 487 uint32_t idx, void *vs2) \ 488 { \ 489 return (base + *((ETYPE *)vs2 + H(idx))); \ 490 } 491 492 GEN_VEXT_GET_INDEX_ADDR(idx_b, int8_t, H1) 493 GEN_VEXT_GET_INDEX_ADDR(idx_h, int16_t, H2) 494 GEN_VEXT_GET_INDEX_ADDR(idx_w, int32_t, H4) 495 GEN_VEXT_GET_INDEX_ADDR(idx_d, int64_t, H8) 496 497 static inline void 498 vext_ldst_index(void *vd, void *v0, target_ulong base, 499 void *vs2, CPURISCVState *env, uint32_t desc, 500 vext_get_index_addr get_index_addr, 501 vext_ldst_elem_fn *ldst_elem, 502 clear_fn *clear_elem, 503 uint32_t esz, uint32_t msz, uintptr_t ra, 504 MMUAccessType access_type) 505 { 506 uint32_t i, k; 507 uint32_t nf = vext_nf(desc); 508 uint32_t vm = vext_vm(desc); 509 uint32_t mlen = vext_mlen(desc); 510 uint32_t vlmax = vext_maxsz(desc) / esz; 511 512 /* probe every access*/ 513 for (i = 0; i < env->vl; i++) { 514 if (!vm && !vext_elem_mask(v0, mlen, i)) { 515 continue; 516 } 517 probe_pages(env, get_index_addr(base, i, vs2), nf * msz, ra, 518 access_type); 519 } 520 /* load bytes from guest memory */ 521 for (i = 0; i < env->vl; i++) { 522 k = 0; 523 if (!vm && !vext_elem_mask(v0, mlen, i)) { 524 continue; 525 } 526 while (k < nf) { 527 abi_ptr addr = get_index_addr(base, i, vs2) + k * msz; 528 ldst_elem(env, addr, i + k * vlmax, vd, ra); 529 k++; 530 } 531 } 532 /* clear tail elements */ 533 if (clear_elem) { 534 for (k = 0; k < nf; k++) { 535 clear_elem(vd, env->vl + k * vlmax, env->vl * esz, vlmax * esz); 536 } 537 } 538 } 539 540 #define GEN_VEXT_LD_INDEX(NAME, MTYPE, ETYPE, INDEX_FN, LOAD_FN, CLEAR_FN) \ 541 void HELPER(NAME)(void *vd, void *v0, target_ulong base, \ 542 void *vs2, CPURISCVState *env, uint32_t desc) \ 543 { \ 544 vext_ldst_index(vd, v0, base, vs2, env, desc, INDEX_FN, \ 545 LOAD_FN, CLEAR_FN, sizeof(ETYPE), sizeof(MTYPE), \ 546 GETPC(), MMU_DATA_LOAD); \ 547 } 548 549 GEN_VEXT_LD_INDEX(vlxb_v_b, int8_t, int8_t, idx_b, ldb_b, clearb) 550 GEN_VEXT_LD_INDEX(vlxb_v_h, int8_t, int16_t, idx_h, ldb_h, clearh) 551 GEN_VEXT_LD_INDEX(vlxb_v_w, int8_t, int32_t, idx_w, ldb_w, clearl) 552 GEN_VEXT_LD_INDEX(vlxb_v_d, int8_t, int64_t, idx_d, ldb_d, clearq) 553 GEN_VEXT_LD_INDEX(vlxh_v_h, int16_t, int16_t, idx_h, ldh_h, clearh) 554 GEN_VEXT_LD_INDEX(vlxh_v_w, int16_t, int32_t, idx_w, ldh_w, clearl) 555 GEN_VEXT_LD_INDEX(vlxh_v_d, int16_t, int64_t, idx_d, ldh_d, clearq) 556 GEN_VEXT_LD_INDEX(vlxw_v_w, int32_t, int32_t, idx_w, ldw_w, clearl) 557 GEN_VEXT_LD_INDEX(vlxw_v_d, int32_t, int64_t, idx_d, ldw_d, clearq) 558 GEN_VEXT_LD_INDEX(vlxe_v_b, int8_t, int8_t, idx_b, lde_b, clearb) 559 GEN_VEXT_LD_INDEX(vlxe_v_h, int16_t, int16_t, idx_h, lde_h, clearh) 560 GEN_VEXT_LD_INDEX(vlxe_v_w, int32_t, int32_t, idx_w, lde_w, clearl) 561 GEN_VEXT_LD_INDEX(vlxe_v_d, int64_t, int64_t, idx_d, lde_d, clearq) 562 GEN_VEXT_LD_INDEX(vlxbu_v_b, uint8_t, uint8_t, idx_b, ldbu_b, clearb) 563 GEN_VEXT_LD_INDEX(vlxbu_v_h, uint8_t, uint16_t, idx_h, ldbu_h, clearh) 564 GEN_VEXT_LD_INDEX(vlxbu_v_w, uint8_t, uint32_t, idx_w, ldbu_w, clearl) 565 GEN_VEXT_LD_INDEX(vlxbu_v_d, uint8_t, uint64_t, idx_d, ldbu_d, clearq) 566 GEN_VEXT_LD_INDEX(vlxhu_v_h, uint16_t, uint16_t, idx_h, ldhu_h, clearh) 567 GEN_VEXT_LD_INDEX(vlxhu_v_w, uint16_t, uint32_t, idx_w, ldhu_w, clearl) 568 GEN_VEXT_LD_INDEX(vlxhu_v_d, uint16_t, uint64_t, idx_d, ldhu_d, clearq) 569 GEN_VEXT_LD_INDEX(vlxwu_v_w, uint32_t, uint32_t, idx_w, ldwu_w, clearl) 570 GEN_VEXT_LD_INDEX(vlxwu_v_d, uint32_t, uint64_t, idx_d, ldwu_d, clearq) 571 572 #define GEN_VEXT_ST_INDEX(NAME, MTYPE, ETYPE, INDEX_FN, STORE_FN)\ 573 void HELPER(NAME)(void *vd, void *v0, target_ulong base, \ 574 void *vs2, CPURISCVState *env, uint32_t desc) \ 575 { \ 576 vext_ldst_index(vd, v0, base, vs2, env, desc, INDEX_FN, \ 577 STORE_FN, NULL, sizeof(ETYPE), sizeof(MTYPE),\ 578 GETPC(), MMU_DATA_STORE); \ 579 } 580 581 GEN_VEXT_ST_INDEX(vsxb_v_b, int8_t, int8_t, idx_b, stb_b) 582 GEN_VEXT_ST_INDEX(vsxb_v_h, int8_t, int16_t, idx_h, stb_h) 583 GEN_VEXT_ST_INDEX(vsxb_v_w, int8_t, int32_t, idx_w, stb_w) 584 GEN_VEXT_ST_INDEX(vsxb_v_d, int8_t, int64_t, idx_d, stb_d) 585 GEN_VEXT_ST_INDEX(vsxh_v_h, int16_t, int16_t, idx_h, sth_h) 586 GEN_VEXT_ST_INDEX(vsxh_v_w, int16_t, int32_t, idx_w, sth_w) 587 GEN_VEXT_ST_INDEX(vsxh_v_d, int16_t, int64_t, idx_d, sth_d) 588 GEN_VEXT_ST_INDEX(vsxw_v_w, int32_t, int32_t, idx_w, stw_w) 589 GEN_VEXT_ST_INDEX(vsxw_v_d, int32_t, int64_t, idx_d, stw_d) 590 GEN_VEXT_ST_INDEX(vsxe_v_b, int8_t, int8_t, idx_b, ste_b) 591 GEN_VEXT_ST_INDEX(vsxe_v_h, int16_t, int16_t, idx_h, ste_h) 592 GEN_VEXT_ST_INDEX(vsxe_v_w, int32_t, int32_t, idx_w, ste_w) 593 GEN_VEXT_ST_INDEX(vsxe_v_d, int64_t, int64_t, idx_d, ste_d) 594 595 /* 596 *** unit-stride fault-only-fisrt load instructions 597 */ 598 static inline void 599 vext_ldff(void *vd, void *v0, target_ulong base, 600 CPURISCVState *env, uint32_t desc, 601 vext_ldst_elem_fn *ldst_elem, 602 clear_fn *clear_elem, 603 uint32_t esz, uint32_t msz, uintptr_t ra) 604 { 605 void *host; 606 uint32_t i, k, vl = 0; 607 uint32_t mlen = vext_mlen(desc); 608 uint32_t nf = vext_nf(desc); 609 uint32_t vm = vext_vm(desc); 610 uint32_t vlmax = vext_maxsz(desc) / esz; 611 target_ulong addr, offset, remain; 612 613 /* probe every access*/ 614 for (i = 0; i < env->vl; i++) { 615 if (!vm && !vext_elem_mask(v0, mlen, i)) { 616 continue; 617 } 618 addr = base + nf * i * msz; 619 if (i == 0) { 620 probe_pages(env, addr, nf * msz, ra, MMU_DATA_LOAD); 621 } else { 622 /* if it triggers an exception, no need to check watchpoint */ 623 remain = nf * msz; 624 while (remain > 0) { 625 offset = -(addr | TARGET_PAGE_MASK); 626 host = tlb_vaddr_to_host(env, addr, MMU_DATA_LOAD, 627 cpu_mmu_index(env, false)); 628 if (host) { 629 #ifdef CONFIG_USER_ONLY 630 if (page_check_range(addr, nf * msz, PAGE_READ) < 0) { 631 vl = i; 632 goto ProbeSuccess; 633 } 634 #else 635 probe_pages(env, addr, nf * msz, ra, MMU_DATA_LOAD); 636 #endif 637 } else { 638 vl = i; 639 goto ProbeSuccess; 640 } 641 if (remain <= offset) { 642 break; 643 } 644 remain -= offset; 645 addr += offset; 646 } 647 } 648 } 649 ProbeSuccess: 650 /* load bytes from guest memory */ 651 if (vl != 0) { 652 env->vl = vl; 653 } 654 for (i = 0; i < env->vl; i++) { 655 k = 0; 656 if (!vm && !vext_elem_mask(v0, mlen, i)) { 657 continue; 658 } 659 while (k < nf) { 660 target_ulong addr = base + (i * nf + k) * msz; 661 ldst_elem(env, addr, i + k * vlmax, vd, ra); 662 k++; 663 } 664 } 665 /* clear tail elements */ 666 if (vl != 0) { 667 return; 668 } 669 for (k = 0; k < nf; k++) { 670 clear_elem(vd, env->vl + k * vlmax, env->vl * esz, vlmax * esz); 671 } 672 } 673 674 #define GEN_VEXT_LDFF(NAME, MTYPE, ETYPE, LOAD_FN, CLEAR_FN) \ 675 void HELPER(NAME)(void *vd, void *v0, target_ulong base, \ 676 CPURISCVState *env, uint32_t desc) \ 677 { \ 678 vext_ldff(vd, v0, base, env, desc, LOAD_FN, CLEAR_FN, \ 679 sizeof(ETYPE), sizeof(MTYPE), GETPC()); \ 680 } 681 682 GEN_VEXT_LDFF(vlbff_v_b, int8_t, int8_t, ldb_b, clearb) 683 GEN_VEXT_LDFF(vlbff_v_h, int8_t, int16_t, ldb_h, clearh) 684 GEN_VEXT_LDFF(vlbff_v_w, int8_t, int32_t, ldb_w, clearl) 685 GEN_VEXT_LDFF(vlbff_v_d, int8_t, int64_t, ldb_d, clearq) 686 GEN_VEXT_LDFF(vlhff_v_h, int16_t, int16_t, ldh_h, clearh) 687 GEN_VEXT_LDFF(vlhff_v_w, int16_t, int32_t, ldh_w, clearl) 688 GEN_VEXT_LDFF(vlhff_v_d, int16_t, int64_t, ldh_d, clearq) 689 GEN_VEXT_LDFF(vlwff_v_w, int32_t, int32_t, ldw_w, clearl) 690 GEN_VEXT_LDFF(vlwff_v_d, int32_t, int64_t, ldw_d, clearq) 691 GEN_VEXT_LDFF(vleff_v_b, int8_t, int8_t, lde_b, clearb) 692 GEN_VEXT_LDFF(vleff_v_h, int16_t, int16_t, lde_h, clearh) 693 GEN_VEXT_LDFF(vleff_v_w, int32_t, int32_t, lde_w, clearl) 694 GEN_VEXT_LDFF(vleff_v_d, int64_t, int64_t, lde_d, clearq) 695 GEN_VEXT_LDFF(vlbuff_v_b, uint8_t, uint8_t, ldbu_b, clearb) 696 GEN_VEXT_LDFF(vlbuff_v_h, uint8_t, uint16_t, ldbu_h, clearh) 697 GEN_VEXT_LDFF(vlbuff_v_w, uint8_t, uint32_t, ldbu_w, clearl) 698 GEN_VEXT_LDFF(vlbuff_v_d, uint8_t, uint64_t, ldbu_d, clearq) 699 GEN_VEXT_LDFF(vlhuff_v_h, uint16_t, uint16_t, ldhu_h, clearh) 700 GEN_VEXT_LDFF(vlhuff_v_w, uint16_t, uint32_t, ldhu_w, clearl) 701 GEN_VEXT_LDFF(vlhuff_v_d, uint16_t, uint64_t, ldhu_d, clearq) 702 GEN_VEXT_LDFF(vlwuff_v_w, uint32_t, uint32_t, ldwu_w, clearl) 703 GEN_VEXT_LDFF(vlwuff_v_d, uint32_t, uint64_t, ldwu_d, clearq) 704 705 /* 706 *** Vector AMO Operations (Zvamo) 707 */ 708 typedef void vext_amo_noatomic_fn(void *vs3, target_ulong addr, 709 uint32_t wd, uint32_t idx, CPURISCVState *env, 710 uintptr_t retaddr); 711 712 /* no atomic opreation for vector atomic insructions */ 713 #define DO_SWAP(N, M) (M) 714 #define DO_AND(N, M) (N & M) 715 #define DO_XOR(N, M) (N ^ M) 716 #define DO_OR(N, M) (N | M) 717 #define DO_ADD(N, M) (N + M) 718 719 #define GEN_VEXT_AMO_NOATOMIC_OP(NAME, ESZ, MSZ, H, DO_OP, SUF) \ 720 static void \ 721 vext_##NAME##_noatomic_op(void *vs3, target_ulong addr, \ 722 uint32_t wd, uint32_t idx, \ 723 CPURISCVState *env, uintptr_t retaddr)\ 724 { \ 725 typedef int##ESZ##_t ETYPE; \ 726 typedef int##MSZ##_t MTYPE; \ 727 typedef uint##MSZ##_t UMTYPE __attribute__((unused)); \ 728 ETYPE *pe3 = (ETYPE *)vs3 + H(idx); \ 729 MTYPE a = cpu_ld##SUF##_data(env, addr), b = *pe3; \ 730 \ 731 cpu_st##SUF##_data(env, addr, DO_OP(a, b)); \ 732 if (wd) { \ 733 *pe3 = a; \ 734 } \ 735 } 736 737 /* Signed min/max */ 738 #define DO_MAX(N, M) ((N) >= (M) ? (N) : (M)) 739 #define DO_MIN(N, M) ((N) >= (M) ? (M) : (N)) 740 741 /* Unsigned min/max */ 742 #define DO_MAXU(N, M) DO_MAX((UMTYPE)N, (UMTYPE)M) 743 #define DO_MINU(N, M) DO_MIN((UMTYPE)N, (UMTYPE)M) 744 745 GEN_VEXT_AMO_NOATOMIC_OP(vamoswapw_v_w, 32, 32, H4, DO_SWAP, l) 746 GEN_VEXT_AMO_NOATOMIC_OP(vamoaddw_v_w, 32, 32, H4, DO_ADD, l) 747 GEN_VEXT_AMO_NOATOMIC_OP(vamoxorw_v_w, 32, 32, H4, DO_XOR, l) 748 GEN_VEXT_AMO_NOATOMIC_OP(vamoandw_v_w, 32, 32, H4, DO_AND, l) 749 GEN_VEXT_AMO_NOATOMIC_OP(vamoorw_v_w, 32, 32, H4, DO_OR, l) 750 GEN_VEXT_AMO_NOATOMIC_OP(vamominw_v_w, 32, 32, H4, DO_MIN, l) 751 GEN_VEXT_AMO_NOATOMIC_OP(vamomaxw_v_w, 32, 32, H4, DO_MAX, l) 752 GEN_VEXT_AMO_NOATOMIC_OP(vamominuw_v_w, 32, 32, H4, DO_MINU, l) 753 GEN_VEXT_AMO_NOATOMIC_OP(vamomaxuw_v_w, 32, 32, H4, DO_MAXU, l) 754 GEN_VEXT_AMO_NOATOMIC_OP(vamoswapw_v_d, 64, 32, H8, DO_SWAP, l) 755 GEN_VEXT_AMO_NOATOMIC_OP(vamoswapd_v_d, 64, 64, H8, DO_SWAP, q) 756 GEN_VEXT_AMO_NOATOMIC_OP(vamoaddw_v_d, 64, 32, H8, DO_ADD, l) 757 GEN_VEXT_AMO_NOATOMIC_OP(vamoaddd_v_d, 64, 64, H8, DO_ADD, q) 758 GEN_VEXT_AMO_NOATOMIC_OP(vamoxorw_v_d, 64, 32, H8, DO_XOR, l) 759 GEN_VEXT_AMO_NOATOMIC_OP(vamoxord_v_d, 64, 64, H8, DO_XOR, q) 760 GEN_VEXT_AMO_NOATOMIC_OP(vamoandw_v_d, 64, 32, H8, DO_AND, l) 761 GEN_VEXT_AMO_NOATOMIC_OP(vamoandd_v_d, 64, 64, H8, DO_AND, q) 762 GEN_VEXT_AMO_NOATOMIC_OP(vamoorw_v_d, 64, 32, H8, DO_OR, l) 763 GEN_VEXT_AMO_NOATOMIC_OP(vamoord_v_d, 64, 64, H8, DO_OR, q) 764 GEN_VEXT_AMO_NOATOMIC_OP(vamominw_v_d, 64, 32, H8, DO_MIN, l) 765 GEN_VEXT_AMO_NOATOMIC_OP(vamomind_v_d, 64, 64, H8, DO_MIN, q) 766 GEN_VEXT_AMO_NOATOMIC_OP(vamomaxw_v_d, 64, 32, H8, DO_MAX, l) 767 GEN_VEXT_AMO_NOATOMIC_OP(vamomaxd_v_d, 64, 64, H8, DO_MAX, q) 768 GEN_VEXT_AMO_NOATOMIC_OP(vamominuw_v_d, 64, 32, H8, DO_MINU, l) 769 GEN_VEXT_AMO_NOATOMIC_OP(vamominud_v_d, 64, 64, H8, DO_MINU, q) 770 GEN_VEXT_AMO_NOATOMIC_OP(vamomaxuw_v_d, 64, 32, H8, DO_MAXU, l) 771 GEN_VEXT_AMO_NOATOMIC_OP(vamomaxud_v_d, 64, 64, H8, DO_MAXU, q) 772 773 static inline void 774 vext_amo_noatomic(void *vs3, void *v0, target_ulong base, 775 void *vs2, CPURISCVState *env, uint32_t desc, 776 vext_get_index_addr get_index_addr, 777 vext_amo_noatomic_fn *noatomic_op, 778 clear_fn *clear_elem, 779 uint32_t esz, uint32_t msz, uintptr_t ra) 780 { 781 uint32_t i; 782 target_long addr; 783 uint32_t wd = vext_wd(desc); 784 uint32_t vm = vext_vm(desc); 785 uint32_t mlen = vext_mlen(desc); 786 uint32_t vlmax = vext_maxsz(desc) / esz; 787 788 for (i = 0; i < env->vl; i++) { 789 if (!vm && !vext_elem_mask(v0, mlen, i)) { 790 continue; 791 } 792 probe_pages(env, get_index_addr(base, i, vs2), msz, ra, MMU_DATA_LOAD); 793 probe_pages(env, get_index_addr(base, i, vs2), msz, ra, MMU_DATA_STORE); 794 } 795 for (i = 0; i < env->vl; i++) { 796 if (!vm && !vext_elem_mask(v0, mlen, i)) { 797 continue; 798 } 799 addr = get_index_addr(base, i, vs2); 800 noatomic_op(vs3, addr, wd, i, env, ra); 801 } 802 clear_elem(vs3, env->vl, env->vl * esz, vlmax * esz); 803 } 804 805 #define GEN_VEXT_AMO(NAME, MTYPE, ETYPE, INDEX_FN, CLEAR_FN) \ 806 void HELPER(NAME)(void *vs3, void *v0, target_ulong base, \ 807 void *vs2, CPURISCVState *env, uint32_t desc) \ 808 { \ 809 vext_amo_noatomic(vs3, v0, base, vs2, env, desc, \ 810 INDEX_FN, vext_##NAME##_noatomic_op, \ 811 CLEAR_FN, sizeof(ETYPE), sizeof(MTYPE), \ 812 GETPC()); \ 813 } 814 815 GEN_VEXT_AMO(vamoswapw_v_d, int32_t, int64_t, idx_d, clearq) 816 GEN_VEXT_AMO(vamoswapd_v_d, int64_t, int64_t, idx_d, clearq) 817 GEN_VEXT_AMO(vamoaddw_v_d, int32_t, int64_t, idx_d, clearq) 818 GEN_VEXT_AMO(vamoaddd_v_d, int64_t, int64_t, idx_d, clearq) 819 GEN_VEXT_AMO(vamoxorw_v_d, int32_t, int64_t, idx_d, clearq) 820 GEN_VEXT_AMO(vamoxord_v_d, int64_t, int64_t, idx_d, clearq) 821 GEN_VEXT_AMO(vamoandw_v_d, int32_t, int64_t, idx_d, clearq) 822 GEN_VEXT_AMO(vamoandd_v_d, int64_t, int64_t, idx_d, clearq) 823 GEN_VEXT_AMO(vamoorw_v_d, int32_t, int64_t, idx_d, clearq) 824 GEN_VEXT_AMO(vamoord_v_d, int64_t, int64_t, idx_d, clearq) 825 GEN_VEXT_AMO(vamominw_v_d, int32_t, int64_t, idx_d, clearq) 826 GEN_VEXT_AMO(vamomind_v_d, int64_t, int64_t, idx_d, clearq) 827 GEN_VEXT_AMO(vamomaxw_v_d, int32_t, int64_t, idx_d, clearq) 828 GEN_VEXT_AMO(vamomaxd_v_d, int64_t, int64_t, idx_d, clearq) 829 GEN_VEXT_AMO(vamominuw_v_d, uint32_t, uint64_t, idx_d, clearq) 830 GEN_VEXT_AMO(vamominud_v_d, uint64_t, uint64_t, idx_d, clearq) 831 GEN_VEXT_AMO(vamomaxuw_v_d, uint32_t, uint64_t, idx_d, clearq) 832 GEN_VEXT_AMO(vamomaxud_v_d, uint64_t, uint64_t, idx_d, clearq) 833 GEN_VEXT_AMO(vamoswapw_v_w, int32_t, int32_t, idx_w, clearl) 834 GEN_VEXT_AMO(vamoaddw_v_w, int32_t, int32_t, idx_w, clearl) 835 GEN_VEXT_AMO(vamoxorw_v_w, int32_t, int32_t, idx_w, clearl) 836 GEN_VEXT_AMO(vamoandw_v_w, int32_t, int32_t, idx_w, clearl) 837 GEN_VEXT_AMO(vamoorw_v_w, int32_t, int32_t, idx_w, clearl) 838 GEN_VEXT_AMO(vamominw_v_w, int32_t, int32_t, idx_w, clearl) 839 GEN_VEXT_AMO(vamomaxw_v_w, int32_t, int32_t, idx_w, clearl) 840 GEN_VEXT_AMO(vamominuw_v_w, uint32_t, uint32_t, idx_w, clearl) 841 GEN_VEXT_AMO(vamomaxuw_v_w, uint32_t, uint32_t, idx_w, clearl) 842 843 /* 844 *** Vector Integer Arithmetic Instructions 845 */ 846 847 /* expand macro args before macro */ 848 #define RVVCALL(macro, ...) macro(__VA_ARGS__) 849 850 /* (TD, T1, T2, TX1, TX2) */ 851 #define OP_SSS_B int8_t, int8_t, int8_t, int8_t, int8_t 852 #define OP_SSS_H int16_t, int16_t, int16_t, int16_t, int16_t 853 #define OP_SSS_W int32_t, int32_t, int32_t, int32_t, int32_t 854 #define OP_SSS_D int64_t, int64_t, int64_t, int64_t, int64_t 855 #define OP_UUU_B uint8_t, uint8_t, uint8_t, uint8_t, uint8_t 856 #define OP_UUU_H uint16_t, uint16_t, uint16_t, uint16_t, uint16_t 857 #define OP_UUU_W uint32_t, uint32_t, uint32_t, uint32_t, uint32_t 858 #define OP_UUU_D uint64_t, uint64_t, uint64_t, uint64_t, uint64_t 859 #define OP_SUS_B int8_t, uint8_t, int8_t, uint8_t, int8_t 860 #define OP_SUS_H int16_t, uint16_t, int16_t, uint16_t, int16_t 861 #define OP_SUS_W int32_t, uint32_t, int32_t, uint32_t, int32_t 862 #define OP_SUS_D int64_t, uint64_t, int64_t, uint64_t, int64_t 863 #define WOP_UUU_B uint16_t, uint8_t, uint8_t, uint16_t, uint16_t 864 #define WOP_UUU_H uint32_t, uint16_t, uint16_t, uint32_t, uint32_t 865 #define WOP_UUU_W uint64_t, uint32_t, uint32_t, uint64_t, uint64_t 866 #define WOP_SSS_B int16_t, int8_t, int8_t, int16_t, int16_t 867 #define WOP_SSS_H int32_t, int16_t, int16_t, int32_t, int32_t 868 #define WOP_SSS_W int64_t, int32_t, int32_t, int64_t, int64_t 869 #define WOP_SUS_B int16_t, uint8_t, int8_t, uint16_t, int16_t 870 #define WOP_SUS_H int32_t, uint16_t, int16_t, uint32_t, int32_t 871 #define WOP_SUS_W int64_t, uint32_t, int32_t, uint64_t, int64_t 872 #define WOP_SSU_B int16_t, int8_t, uint8_t, int16_t, uint16_t 873 #define WOP_SSU_H int32_t, int16_t, uint16_t, int32_t, uint32_t 874 #define WOP_SSU_W int64_t, int32_t, uint32_t, int64_t, uint64_t 875 #define NOP_SSS_B int8_t, int8_t, int16_t, int8_t, int16_t 876 #define NOP_SSS_H int16_t, int16_t, int32_t, int16_t, int32_t 877 #define NOP_SSS_W int32_t, int32_t, int64_t, int32_t, int64_t 878 #define NOP_UUU_B uint8_t, uint8_t, uint16_t, uint8_t, uint16_t 879 #define NOP_UUU_H uint16_t, uint16_t, uint32_t, uint16_t, uint32_t 880 #define NOP_UUU_W uint32_t, uint32_t, uint64_t, uint32_t, uint64_t 881 882 /* operation of two vector elements */ 883 typedef void opivv2_fn(void *vd, void *vs1, void *vs2, int i); 884 885 #define OPIVV2(NAME, TD, T1, T2, TX1, TX2, HD, HS1, HS2, OP) \ 886 static void do_##NAME(void *vd, void *vs1, void *vs2, int i) \ 887 { \ 888 TX1 s1 = *((T1 *)vs1 + HS1(i)); \ 889 TX2 s2 = *((T2 *)vs2 + HS2(i)); \ 890 *((TD *)vd + HD(i)) = OP(s2, s1); \ 891 } 892 #define DO_SUB(N, M) (N - M) 893 #define DO_RSUB(N, M) (M - N) 894 895 RVVCALL(OPIVV2, vadd_vv_b, OP_SSS_B, H1, H1, H1, DO_ADD) 896 RVVCALL(OPIVV2, vadd_vv_h, OP_SSS_H, H2, H2, H2, DO_ADD) 897 RVVCALL(OPIVV2, vadd_vv_w, OP_SSS_W, H4, H4, H4, DO_ADD) 898 RVVCALL(OPIVV2, vadd_vv_d, OP_SSS_D, H8, H8, H8, DO_ADD) 899 RVVCALL(OPIVV2, vsub_vv_b, OP_SSS_B, H1, H1, H1, DO_SUB) 900 RVVCALL(OPIVV2, vsub_vv_h, OP_SSS_H, H2, H2, H2, DO_SUB) 901 RVVCALL(OPIVV2, vsub_vv_w, OP_SSS_W, H4, H4, H4, DO_SUB) 902 RVVCALL(OPIVV2, vsub_vv_d, OP_SSS_D, H8, H8, H8, DO_SUB) 903 904 static void do_vext_vv(void *vd, void *v0, void *vs1, void *vs2, 905 CPURISCVState *env, uint32_t desc, 906 uint32_t esz, uint32_t dsz, 907 opivv2_fn *fn, clear_fn *clearfn) 908 { 909 uint32_t vlmax = vext_maxsz(desc) / esz; 910 uint32_t mlen = vext_mlen(desc); 911 uint32_t vm = vext_vm(desc); 912 uint32_t vl = env->vl; 913 uint32_t i; 914 915 for (i = 0; i < vl; i++) { 916 if (!vm && !vext_elem_mask(v0, mlen, i)) { 917 continue; 918 } 919 fn(vd, vs1, vs2, i); 920 } 921 clearfn(vd, vl, vl * dsz, vlmax * dsz); 922 } 923 924 /* generate the helpers for OPIVV */ 925 #define GEN_VEXT_VV(NAME, ESZ, DSZ, CLEAR_FN) \ 926 void HELPER(NAME)(void *vd, void *v0, void *vs1, \ 927 void *vs2, CPURISCVState *env, \ 928 uint32_t desc) \ 929 { \ 930 do_vext_vv(vd, v0, vs1, vs2, env, desc, ESZ, DSZ, \ 931 do_##NAME, CLEAR_FN); \ 932 } 933 934 GEN_VEXT_VV(vadd_vv_b, 1, 1, clearb) 935 GEN_VEXT_VV(vadd_vv_h, 2, 2, clearh) 936 GEN_VEXT_VV(vadd_vv_w, 4, 4, clearl) 937 GEN_VEXT_VV(vadd_vv_d, 8, 8, clearq) 938 GEN_VEXT_VV(vsub_vv_b, 1, 1, clearb) 939 GEN_VEXT_VV(vsub_vv_h, 2, 2, clearh) 940 GEN_VEXT_VV(vsub_vv_w, 4, 4, clearl) 941 GEN_VEXT_VV(vsub_vv_d, 8, 8, clearq) 942 943 typedef void opivx2_fn(void *vd, target_long s1, void *vs2, int i); 944 945 /* 946 * (T1)s1 gives the real operator type. 947 * (TX1)(T1)s1 expands the operator type of widen or narrow operations. 948 */ 949 #define OPIVX2(NAME, TD, T1, T2, TX1, TX2, HD, HS2, OP) \ 950 static void do_##NAME(void *vd, target_long s1, void *vs2, int i) \ 951 { \ 952 TX2 s2 = *((T2 *)vs2 + HS2(i)); \ 953 *((TD *)vd + HD(i)) = OP(s2, (TX1)(T1)s1); \ 954 } 955 956 RVVCALL(OPIVX2, vadd_vx_b, OP_SSS_B, H1, H1, DO_ADD) 957 RVVCALL(OPIVX2, vadd_vx_h, OP_SSS_H, H2, H2, DO_ADD) 958 RVVCALL(OPIVX2, vadd_vx_w, OP_SSS_W, H4, H4, DO_ADD) 959 RVVCALL(OPIVX2, vadd_vx_d, OP_SSS_D, H8, H8, DO_ADD) 960 RVVCALL(OPIVX2, vsub_vx_b, OP_SSS_B, H1, H1, DO_SUB) 961 RVVCALL(OPIVX2, vsub_vx_h, OP_SSS_H, H2, H2, DO_SUB) 962 RVVCALL(OPIVX2, vsub_vx_w, OP_SSS_W, H4, H4, DO_SUB) 963 RVVCALL(OPIVX2, vsub_vx_d, OP_SSS_D, H8, H8, DO_SUB) 964 RVVCALL(OPIVX2, vrsub_vx_b, OP_SSS_B, H1, H1, DO_RSUB) 965 RVVCALL(OPIVX2, vrsub_vx_h, OP_SSS_H, H2, H2, DO_RSUB) 966 RVVCALL(OPIVX2, vrsub_vx_w, OP_SSS_W, H4, H4, DO_RSUB) 967 RVVCALL(OPIVX2, vrsub_vx_d, OP_SSS_D, H8, H8, DO_RSUB) 968 969 static void do_vext_vx(void *vd, void *v0, target_long s1, void *vs2, 970 CPURISCVState *env, uint32_t desc, 971 uint32_t esz, uint32_t dsz, 972 opivx2_fn fn, clear_fn *clearfn) 973 { 974 uint32_t vlmax = vext_maxsz(desc) / esz; 975 uint32_t mlen = vext_mlen(desc); 976 uint32_t vm = vext_vm(desc); 977 uint32_t vl = env->vl; 978 uint32_t i; 979 980 for (i = 0; i < vl; i++) { 981 if (!vm && !vext_elem_mask(v0, mlen, i)) { 982 continue; 983 } 984 fn(vd, s1, vs2, i); 985 } 986 clearfn(vd, vl, vl * dsz, vlmax * dsz); 987 } 988 989 /* generate the helpers for OPIVX */ 990 #define GEN_VEXT_VX(NAME, ESZ, DSZ, CLEAR_FN) \ 991 void HELPER(NAME)(void *vd, void *v0, target_ulong s1, \ 992 void *vs2, CPURISCVState *env, \ 993 uint32_t desc) \ 994 { \ 995 do_vext_vx(vd, v0, s1, vs2, env, desc, ESZ, DSZ, \ 996 do_##NAME, CLEAR_FN); \ 997 } 998 999 GEN_VEXT_VX(vadd_vx_b, 1, 1, clearb) 1000 GEN_VEXT_VX(vadd_vx_h, 2, 2, clearh) 1001 GEN_VEXT_VX(vadd_vx_w, 4, 4, clearl) 1002 GEN_VEXT_VX(vadd_vx_d, 8, 8, clearq) 1003 GEN_VEXT_VX(vsub_vx_b, 1, 1, clearb) 1004 GEN_VEXT_VX(vsub_vx_h, 2, 2, clearh) 1005 GEN_VEXT_VX(vsub_vx_w, 4, 4, clearl) 1006 GEN_VEXT_VX(vsub_vx_d, 8, 8, clearq) 1007 GEN_VEXT_VX(vrsub_vx_b, 1, 1, clearb) 1008 GEN_VEXT_VX(vrsub_vx_h, 2, 2, clearh) 1009 GEN_VEXT_VX(vrsub_vx_w, 4, 4, clearl) 1010 GEN_VEXT_VX(vrsub_vx_d, 8, 8, clearq) 1011 1012 void HELPER(vec_rsubs8)(void *d, void *a, uint64_t b, uint32_t desc) 1013 { 1014 intptr_t oprsz = simd_oprsz(desc); 1015 intptr_t i; 1016 1017 for (i = 0; i < oprsz; i += sizeof(uint8_t)) { 1018 *(uint8_t *)(d + i) = (uint8_t)b - *(uint8_t *)(a + i); 1019 } 1020 } 1021 1022 void HELPER(vec_rsubs16)(void *d, void *a, uint64_t b, uint32_t desc) 1023 { 1024 intptr_t oprsz = simd_oprsz(desc); 1025 intptr_t i; 1026 1027 for (i = 0; i < oprsz; i += sizeof(uint16_t)) { 1028 *(uint16_t *)(d + i) = (uint16_t)b - *(uint16_t *)(a + i); 1029 } 1030 } 1031 1032 void HELPER(vec_rsubs32)(void *d, void *a, uint64_t b, uint32_t desc) 1033 { 1034 intptr_t oprsz = simd_oprsz(desc); 1035 intptr_t i; 1036 1037 for (i = 0; i < oprsz; i += sizeof(uint32_t)) { 1038 *(uint32_t *)(d + i) = (uint32_t)b - *(uint32_t *)(a + i); 1039 } 1040 } 1041 1042 void HELPER(vec_rsubs64)(void *d, void *a, uint64_t b, uint32_t desc) 1043 { 1044 intptr_t oprsz = simd_oprsz(desc); 1045 intptr_t i; 1046 1047 for (i = 0; i < oprsz; i += sizeof(uint64_t)) { 1048 *(uint64_t *)(d + i) = b - *(uint64_t *)(a + i); 1049 } 1050 } 1051 1052 /* Vector Widening Integer Add/Subtract */ 1053 #define WOP_UUU_B uint16_t, uint8_t, uint8_t, uint16_t, uint16_t 1054 #define WOP_UUU_H uint32_t, uint16_t, uint16_t, uint32_t, uint32_t 1055 #define WOP_UUU_W uint64_t, uint32_t, uint32_t, uint64_t, uint64_t 1056 #define WOP_SSS_B int16_t, int8_t, int8_t, int16_t, int16_t 1057 #define WOP_SSS_H int32_t, int16_t, int16_t, int32_t, int32_t 1058 #define WOP_SSS_W int64_t, int32_t, int32_t, int64_t, int64_t 1059 #define WOP_WUUU_B uint16_t, uint8_t, uint16_t, uint16_t, uint16_t 1060 #define WOP_WUUU_H uint32_t, uint16_t, uint32_t, uint32_t, uint32_t 1061 #define WOP_WUUU_W uint64_t, uint32_t, uint64_t, uint64_t, uint64_t 1062 #define WOP_WSSS_B int16_t, int8_t, int16_t, int16_t, int16_t 1063 #define WOP_WSSS_H int32_t, int16_t, int32_t, int32_t, int32_t 1064 #define WOP_WSSS_W int64_t, int32_t, int64_t, int64_t, int64_t 1065 RVVCALL(OPIVV2, vwaddu_vv_b, WOP_UUU_B, H2, H1, H1, DO_ADD) 1066 RVVCALL(OPIVV2, vwaddu_vv_h, WOP_UUU_H, H4, H2, H2, DO_ADD) 1067 RVVCALL(OPIVV2, vwaddu_vv_w, WOP_UUU_W, H8, H4, H4, DO_ADD) 1068 RVVCALL(OPIVV2, vwsubu_vv_b, WOP_UUU_B, H2, H1, H1, DO_SUB) 1069 RVVCALL(OPIVV2, vwsubu_vv_h, WOP_UUU_H, H4, H2, H2, DO_SUB) 1070 RVVCALL(OPIVV2, vwsubu_vv_w, WOP_UUU_W, H8, H4, H4, DO_SUB) 1071 RVVCALL(OPIVV2, vwadd_vv_b, WOP_SSS_B, H2, H1, H1, DO_ADD) 1072 RVVCALL(OPIVV2, vwadd_vv_h, WOP_SSS_H, H4, H2, H2, DO_ADD) 1073 RVVCALL(OPIVV2, vwadd_vv_w, WOP_SSS_W, H8, H4, H4, DO_ADD) 1074 RVVCALL(OPIVV2, vwsub_vv_b, WOP_SSS_B, H2, H1, H1, DO_SUB) 1075 RVVCALL(OPIVV2, vwsub_vv_h, WOP_SSS_H, H4, H2, H2, DO_SUB) 1076 RVVCALL(OPIVV2, vwsub_vv_w, WOP_SSS_W, H8, H4, H4, DO_SUB) 1077 RVVCALL(OPIVV2, vwaddu_wv_b, WOP_WUUU_B, H2, H1, H1, DO_ADD) 1078 RVVCALL(OPIVV2, vwaddu_wv_h, WOP_WUUU_H, H4, H2, H2, DO_ADD) 1079 RVVCALL(OPIVV2, vwaddu_wv_w, WOP_WUUU_W, H8, H4, H4, DO_ADD) 1080 RVVCALL(OPIVV2, vwsubu_wv_b, WOP_WUUU_B, H2, H1, H1, DO_SUB) 1081 RVVCALL(OPIVV2, vwsubu_wv_h, WOP_WUUU_H, H4, H2, H2, DO_SUB) 1082 RVVCALL(OPIVV2, vwsubu_wv_w, WOP_WUUU_W, H8, H4, H4, DO_SUB) 1083 RVVCALL(OPIVV2, vwadd_wv_b, WOP_WSSS_B, H2, H1, H1, DO_ADD) 1084 RVVCALL(OPIVV2, vwadd_wv_h, WOP_WSSS_H, H4, H2, H2, DO_ADD) 1085 RVVCALL(OPIVV2, vwadd_wv_w, WOP_WSSS_W, H8, H4, H4, DO_ADD) 1086 RVVCALL(OPIVV2, vwsub_wv_b, WOP_WSSS_B, H2, H1, H1, DO_SUB) 1087 RVVCALL(OPIVV2, vwsub_wv_h, WOP_WSSS_H, H4, H2, H2, DO_SUB) 1088 RVVCALL(OPIVV2, vwsub_wv_w, WOP_WSSS_W, H8, H4, H4, DO_SUB) 1089 GEN_VEXT_VV(vwaddu_vv_b, 1, 2, clearh) 1090 GEN_VEXT_VV(vwaddu_vv_h, 2, 4, clearl) 1091 GEN_VEXT_VV(vwaddu_vv_w, 4, 8, clearq) 1092 GEN_VEXT_VV(vwsubu_vv_b, 1, 2, clearh) 1093 GEN_VEXT_VV(vwsubu_vv_h, 2, 4, clearl) 1094 GEN_VEXT_VV(vwsubu_vv_w, 4, 8, clearq) 1095 GEN_VEXT_VV(vwadd_vv_b, 1, 2, clearh) 1096 GEN_VEXT_VV(vwadd_vv_h, 2, 4, clearl) 1097 GEN_VEXT_VV(vwadd_vv_w, 4, 8, clearq) 1098 GEN_VEXT_VV(vwsub_vv_b, 1, 2, clearh) 1099 GEN_VEXT_VV(vwsub_vv_h, 2, 4, clearl) 1100 GEN_VEXT_VV(vwsub_vv_w, 4, 8, clearq) 1101 GEN_VEXT_VV(vwaddu_wv_b, 1, 2, clearh) 1102 GEN_VEXT_VV(vwaddu_wv_h, 2, 4, clearl) 1103 GEN_VEXT_VV(vwaddu_wv_w, 4, 8, clearq) 1104 GEN_VEXT_VV(vwsubu_wv_b, 1, 2, clearh) 1105 GEN_VEXT_VV(vwsubu_wv_h, 2, 4, clearl) 1106 GEN_VEXT_VV(vwsubu_wv_w, 4, 8, clearq) 1107 GEN_VEXT_VV(vwadd_wv_b, 1, 2, clearh) 1108 GEN_VEXT_VV(vwadd_wv_h, 2, 4, clearl) 1109 GEN_VEXT_VV(vwadd_wv_w, 4, 8, clearq) 1110 GEN_VEXT_VV(vwsub_wv_b, 1, 2, clearh) 1111 GEN_VEXT_VV(vwsub_wv_h, 2, 4, clearl) 1112 GEN_VEXT_VV(vwsub_wv_w, 4, 8, clearq) 1113 1114 RVVCALL(OPIVX2, vwaddu_vx_b, WOP_UUU_B, H2, H1, DO_ADD) 1115 RVVCALL(OPIVX2, vwaddu_vx_h, WOP_UUU_H, H4, H2, DO_ADD) 1116 RVVCALL(OPIVX2, vwaddu_vx_w, WOP_UUU_W, H8, H4, DO_ADD) 1117 RVVCALL(OPIVX2, vwsubu_vx_b, WOP_UUU_B, H2, H1, DO_SUB) 1118 RVVCALL(OPIVX2, vwsubu_vx_h, WOP_UUU_H, H4, H2, DO_SUB) 1119 RVVCALL(OPIVX2, vwsubu_vx_w, WOP_UUU_W, H8, H4, DO_SUB) 1120 RVVCALL(OPIVX2, vwadd_vx_b, WOP_SSS_B, H2, H1, DO_ADD) 1121 RVVCALL(OPIVX2, vwadd_vx_h, WOP_SSS_H, H4, H2, DO_ADD) 1122 RVVCALL(OPIVX2, vwadd_vx_w, WOP_SSS_W, H8, H4, DO_ADD) 1123 RVVCALL(OPIVX2, vwsub_vx_b, WOP_SSS_B, H2, H1, DO_SUB) 1124 RVVCALL(OPIVX2, vwsub_vx_h, WOP_SSS_H, H4, H2, DO_SUB) 1125 RVVCALL(OPIVX2, vwsub_vx_w, WOP_SSS_W, H8, H4, DO_SUB) 1126 RVVCALL(OPIVX2, vwaddu_wx_b, WOP_WUUU_B, H2, H1, DO_ADD) 1127 RVVCALL(OPIVX2, vwaddu_wx_h, WOP_WUUU_H, H4, H2, DO_ADD) 1128 RVVCALL(OPIVX2, vwaddu_wx_w, WOP_WUUU_W, H8, H4, DO_ADD) 1129 RVVCALL(OPIVX2, vwsubu_wx_b, WOP_WUUU_B, H2, H1, DO_SUB) 1130 RVVCALL(OPIVX2, vwsubu_wx_h, WOP_WUUU_H, H4, H2, DO_SUB) 1131 RVVCALL(OPIVX2, vwsubu_wx_w, WOP_WUUU_W, H8, H4, DO_SUB) 1132 RVVCALL(OPIVX2, vwadd_wx_b, WOP_WSSS_B, H2, H1, DO_ADD) 1133 RVVCALL(OPIVX2, vwadd_wx_h, WOP_WSSS_H, H4, H2, DO_ADD) 1134 RVVCALL(OPIVX2, vwadd_wx_w, WOP_WSSS_W, H8, H4, DO_ADD) 1135 RVVCALL(OPIVX2, vwsub_wx_b, WOP_WSSS_B, H2, H1, DO_SUB) 1136 RVVCALL(OPIVX2, vwsub_wx_h, WOP_WSSS_H, H4, H2, DO_SUB) 1137 RVVCALL(OPIVX2, vwsub_wx_w, WOP_WSSS_W, H8, H4, DO_SUB) 1138 GEN_VEXT_VX(vwaddu_vx_b, 1, 2, clearh) 1139 GEN_VEXT_VX(vwaddu_vx_h, 2, 4, clearl) 1140 GEN_VEXT_VX(vwaddu_vx_w, 4, 8, clearq) 1141 GEN_VEXT_VX(vwsubu_vx_b, 1, 2, clearh) 1142 GEN_VEXT_VX(vwsubu_vx_h, 2, 4, clearl) 1143 GEN_VEXT_VX(vwsubu_vx_w, 4, 8, clearq) 1144 GEN_VEXT_VX(vwadd_vx_b, 1, 2, clearh) 1145 GEN_VEXT_VX(vwadd_vx_h, 2, 4, clearl) 1146 GEN_VEXT_VX(vwadd_vx_w, 4, 8, clearq) 1147 GEN_VEXT_VX(vwsub_vx_b, 1, 2, clearh) 1148 GEN_VEXT_VX(vwsub_vx_h, 2, 4, clearl) 1149 GEN_VEXT_VX(vwsub_vx_w, 4, 8, clearq) 1150 GEN_VEXT_VX(vwaddu_wx_b, 1, 2, clearh) 1151 GEN_VEXT_VX(vwaddu_wx_h, 2, 4, clearl) 1152 GEN_VEXT_VX(vwaddu_wx_w, 4, 8, clearq) 1153 GEN_VEXT_VX(vwsubu_wx_b, 1, 2, clearh) 1154 GEN_VEXT_VX(vwsubu_wx_h, 2, 4, clearl) 1155 GEN_VEXT_VX(vwsubu_wx_w, 4, 8, clearq) 1156 GEN_VEXT_VX(vwadd_wx_b, 1, 2, clearh) 1157 GEN_VEXT_VX(vwadd_wx_h, 2, 4, clearl) 1158 GEN_VEXT_VX(vwadd_wx_w, 4, 8, clearq) 1159 GEN_VEXT_VX(vwsub_wx_b, 1, 2, clearh) 1160 GEN_VEXT_VX(vwsub_wx_h, 2, 4, clearl) 1161 GEN_VEXT_VX(vwsub_wx_w, 4, 8, clearq) 1162 1163 /* Vector Integer Add-with-Carry / Subtract-with-Borrow Instructions */ 1164 #define DO_VADC(N, M, C) (N + M + C) 1165 #define DO_VSBC(N, M, C) (N - M - C) 1166 1167 #define GEN_VEXT_VADC_VVM(NAME, ETYPE, H, DO_OP, CLEAR_FN) \ 1168 void HELPER(NAME)(void *vd, void *v0, void *vs1, void *vs2, \ 1169 CPURISCVState *env, uint32_t desc) \ 1170 { \ 1171 uint32_t mlen = vext_mlen(desc); \ 1172 uint32_t vl = env->vl; \ 1173 uint32_t esz = sizeof(ETYPE); \ 1174 uint32_t vlmax = vext_maxsz(desc) / esz; \ 1175 uint32_t i; \ 1176 \ 1177 for (i = 0; i < vl; i++) { \ 1178 ETYPE s1 = *((ETYPE *)vs1 + H(i)); \ 1179 ETYPE s2 = *((ETYPE *)vs2 + H(i)); \ 1180 uint8_t carry = vext_elem_mask(v0, mlen, i); \ 1181 \ 1182 *((ETYPE *)vd + H(i)) = DO_OP(s2, s1, carry); \ 1183 } \ 1184 CLEAR_FN(vd, vl, vl * esz, vlmax * esz); \ 1185 } 1186 1187 GEN_VEXT_VADC_VVM(vadc_vvm_b, uint8_t, H1, DO_VADC, clearb) 1188 GEN_VEXT_VADC_VVM(vadc_vvm_h, uint16_t, H2, DO_VADC, clearh) 1189 GEN_VEXT_VADC_VVM(vadc_vvm_w, uint32_t, H4, DO_VADC, clearl) 1190 GEN_VEXT_VADC_VVM(vadc_vvm_d, uint64_t, H8, DO_VADC, clearq) 1191 1192 GEN_VEXT_VADC_VVM(vsbc_vvm_b, uint8_t, H1, DO_VSBC, clearb) 1193 GEN_VEXT_VADC_VVM(vsbc_vvm_h, uint16_t, H2, DO_VSBC, clearh) 1194 GEN_VEXT_VADC_VVM(vsbc_vvm_w, uint32_t, H4, DO_VSBC, clearl) 1195 GEN_VEXT_VADC_VVM(vsbc_vvm_d, uint64_t, H8, DO_VSBC, clearq) 1196 1197 #define GEN_VEXT_VADC_VXM(NAME, ETYPE, H, DO_OP, CLEAR_FN) \ 1198 void HELPER(NAME)(void *vd, void *v0, target_ulong s1, void *vs2, \ 1199 CPURISCVState *env, uint32_t desc) \ 1200 { \ 1201 uint32_t mlen = vext_mlen(desc); \ 1202 uint32_t vl = env->vl; \ 1203 uint32_t esz = sizeof(ETYPE); \ 1204 uint32_t vlmax = vext_maxsz(desc) / esz; \ 1205 uint32_t i; \ 1206 \ 1207 for (i = 0; i < vl; i++) { \ 1208 ETYPE s2 = *((ETYPE *)vs2 + H(i)); \ 1209 uint8_t carry = vext_elem_mask(v0, mlen, i); \ 1210 \ 1211 *((ETYPE *)vd + H(i)) = DO_OP(s2, (ETYPE)(target_long)s1, carry);\ 1212 } \ 1213 CLEAR_FN(vd, vl, vl * esz, vlmax * esz); \ 1214 } 1215 1216 GEN_VEXT_VADC_VXM(vadc_vxm_b, uint8_t, H1, DO_VADC, clearb) 1217 GEN_VEXT_VADC_VXM(vadc_vxm_h, uint16_t, H2, DO_VADC, clearh) 1218 GEN_VEXT_VADC_VXM(vadc_vxm_w, uint32_t, H4, DO_VADC, clearl) 1219 GEN_VEXT_VADC_VXM(vadc_vxm_d, uint64_t, H8, DO_VADC, clearq) 1220 1221 GEN_VEXT_VADC_VXM(vsbc_vxm_b, uint8_t, H1, DO_VSBC, clearb) 1222 GEN_VEXT_VADC_VXM(vsbc_vxm_h, uint16_t, H2, DO_VSBC, clearh) 1223 GEN_VEXT_VADC_VXM(vsbc_vxm_w, uint32_t, H4, DO_VSBC, clearl) 1224 GEN_VEXT_VADC_VXM(vsbc_vxm_d, uint64_t, H8, DO_VSBC, clearq) 1225 1226 #define DO_MADC(N, M, C) (C ? (__typeof(N))(N + M + 1) <= N : \ 1227 (__typeof(N))(N + M) < N) 1228 #define DO_MSBC(N, M, C) (C ? N <= M : N < M) 1229 1230 #define GEN_VEXT_VMADC_VVM(NAME, ETYPE, H, DO_OP) \ 1231 void HELPER(NAME)(void *vd, void *v0, void *vs1, void *vs2, \ 1232 CPURISCVState *env, uint32_t desc) \ 1233 { \ 1234 uint32_t mlen = vext_mlen(desc); \ 1235 uint32_t vl = env->vl; \ 1236 uint32_t vlmax = vext_maxsz(desc) / sizeof(ETYPE); \ 1237 uint32_t i; \ 1238 \ 1239 for (i = 0; i < vl; i++) { \ 1240 ETYPE s1 = *((ETYPE *)vs1 + H(i)); \ 1241 ETYPE s2 = *((ETYPE *)vs2 + H(i)); \ 1242 uint8_t carry = vext_elem_mask(v0, mlen, i); \ 1243 \ 1244 vext_set_elem_mask(vd, mlen, i, DO_OP(s2, s1, carry));\ 1245 } \ 1246 for (; i < vlmax; i++) { \ 1247 vext_set_elem_mask(vd, mlen, i, 0); \ 1248 } \ 1249 } 1250 1251 GEN_VEXT_VMADC_VVM(vmadc_vvm_b, uint8_t, H1, DO_MADC) 1252 GEN_VEXT_VMADC_VVM(vmadc_vvm_h, uint16_t, H2, DO_MADC) 1253 GEN_VEXT_VMADC_VVM(vmadc_vvm_w, uint32_t, H4, DO_MADC) 1254 GEN_VEXT_VMADC_VVM(vmadc_vvm_d, uint64_t, H8, DO_MADC) 1255 1256 GEN_VEXT_VMADC_VVM(vmsbc_vvm_b, uint8_t, H1, DO_MSBC) 1257 GEN_VEXT_VMADC_VVM(vmsbc_vvm_h, uint16_t, H2, DO_MSBC) 1258 GEN_VEXT_VMADC_VVM(vmsbc_vvm_w, uint32_t, H4, DO_MSBC) 1259 GEN_VEXT_VMADC_VVM(vmsbc_vvm_d, uint64_t, H8, DO_MSBC) 1260 1261 #define GEN_VEXT_VMADC_VXM(NAME, ETYPE, H, DO_OP) \ 1262 void HELPER(NAME)(void *vd, void *v0, target_ulong s1, \ 1263 void *vs2, CPURISCVState *env, uint32_t desc) \ 1264 { \ 1265 uint32_t mlen = vext_mlen(desc); \ 1266 uint32_t vl = env->vl; \ 1267 uint32_t vlmax = vext_maxsz(desc) / sizeof(ETYPE); \ 1268 uint32_t i; \ 1269 \ 1270 for (i = 0; i < vl; i++) { \ 1271 ETYPE s2 = *((ETYPE *)vs2 + H(i)); \ 1272 uint8_t carry = vext_elem_mask(v0, mlen, i); \ 1273 \ 1274 vext_set_elem_mask(vd, mlen, i, \ 1275 DO_OP(s2, (ETYPE)(target_long)s1, carry)); \ 1276 } \ 1277 for (; i < vlmax; i++) { \ 1278 vext_set_elem_mask(vd, mlen, i, 0); \ 1279 } \ 1280 } 1281 1282 GEN_VEXT_VMADC_VXM(vmadc_vxm_b, uint8_t, H1, DO_MADC) 1283 GEN_VEXT_VMADC_VXM(vmadc_vxm_h, uint16_t, H2, DO_MADC) 1284 GEN_VEXT_VMADC_VXM(vmadc_vxm_w, uint32_t, H4, DO_MADC) 1285 GEN_VEXT_VMADC_VXM(vmadc_vxm_d, uint64_t, H8, DO_MADC) 1286 1287 GEN_VEXT_VMADC_VXM(vmsbc_vxm_b, uint8_t, H1, DO_MSBC) 1288 GEN_VEXT_VMADC_VXM(vmsbc_vxm_h, uint16_t, H2, DO_MSBC) 1289 GEN_VEXT_VMADC_VXM(vmsbc_vxm_w, uint32_t, H4, DO_MSBC) 1290 GEN_VEXT_VMADC_VXM(vmsbc_vxm_d, uint64_t, H8, DO_MSBC) 1291 1292 /* Vector Bitwise Logical Instructions */ 1293 RVVCALL(OPIVV2, vand_vv_b, OP_SSS_B, H1, H1, H1, DO_AND) 1294 RVVCALL(OPIVV2, vand_vv_h, OP_SSS_H, H2, H2, H2, DO_AND) 1295 RVVCALL(OPIVV2, vand_vv_w, OP_SSS_W, H4, H4, H4, DO_AND) 1296 RVVCALL(OPIVV2, vand_vv_d, OP_SSS_D, H8, H8, H8, DO_AND) 1297 RVVCALL(OPIVV2, vor_vv_b, OP_SSS_B, H1, H1, H1, DO_OR) 1298 RVVCALL(OPIVV2, vor_vv_h, OP_SSS_H, H2, H2, H2, DO_OR) 1299 RVVCALL(OPIVV2, vor_vv_w, OP_SSS_W, H4, H4, H4, DO_OR) 1300 RVVCALL(OPIVV2, vor_vv_d, OP_SSS_D, H8, H8, H8, DO_OR) 1301 RVVCALL(OPIVV2, vxor_vv_b, OP_SSS_B, H1, H1, H1, DO_XOR) 1302 RVVCALL(OPIVV2, vxor_vv_h, OP_SSS_H, H2, H2, H2, DO_XOR) 1303 RVVCALL(OPIVV2, vxor_vv_w, OP_SSS_W, H4, H4, H4, DO_XOR) 1304 RVVCALL(OPIVV2, vxor_vv_d, OP_SSS_D, H8, H8, H8, DO_XOR) 1305 GEN_VEXT_VV(vand_vv_b, 1, 1, clearb) 1306 GEN_VEXT_VV(vand_vv_h, 2, 2, clearh) 1307 GEN_VEXT_VV(vand_vv_w, 4, 4, clearl) 1308 GEN_VEXT_VV(vand_vv_d, 8, 8, clearq) 1309 GEN_VEXT_VV(vor_vv_b, 1, 1, clearb) 1310 GEN_VEXT_VV(vor_vv_h, 2, 2, clearh) 1311 GEN_VEXT_VV(vor_vv_w, 4, 4, clearl) 1312 GEN_VEXT_VV(vor_vv_d, 8, 8, clearq) 1313 GEN_VEXT_VV(vxor_vv_b, 1, 1, clearb) 1314 GEN_VEXT_VV(vxor_vv_h, 2, 2, clearh) 1315 GEN_VEXT_VV(vxor_vv_w, 4, 4, clearl) 1316 GEN_VEXT_VV(vxor_vv_d, 8, 8, clearq) 1317 1318 RVVCALL(OPIVX2, vand_vx_b, OP_SSS_B, H1, H1, DO_AND) 1319 RVVCALL(OPIVX2, vand_vx_h, OP_SSS_H, H2, H2, DO_AND) 1320 RVVCALL(OPIVX2, vand_vx_w, OP_SSS_W, H4, H4, DO_AND) 1321 RVVCALL(OPIVX2, vand_vx_d, OP_SSS_D, H8, H8, DO_AND) 1322 RVVCALL(OPIVX2, vor_vx_b, OP_SSS_B, H1, H1, DO_OR) 1323 RVVCALL(OPIVX2, vor_vx_h, OP_SSS_H, H2, H2, DO_OR) 1324 RVVCALL(OPIVX2, vor_vx_w, OP_SSS_W, H4, H4, DO_OR) 1325 RVVCALL(OPIVX2, vor_vx_d, OP_SSS_D, H8, H8, DO_OR) 1326 RVVCALL(OPIVX2, vxor_vx_b, OP_SSS_B, H1, H1, DO_XOR) 1327 RVVCALL(OPIVX2, vxor_vx_h, OP_SSS_H, H2, H2, DO_XOR) 1328 RVVCALL(OPIVX2, vxor_vx_w, OP_SSS_W, H4, H4, DO_XOR) 1329 RVVCALL(OPIVX2, vxor_vx_d, OP_SSS_D, H8, H8, DO_XOR) 1330 GEN_VEXT_VX(vand_vx_b, 1, 1, clearb) 1331 GEN_VEXT_VX(vand_vx_h, 2, 2, clearh) 1332 GEN_VEXT_VX(vand_vx_w, 4, 4, clearl) 1333 GEN_VEXT_VX(vand_vx_d, 8, 8, clearq) 1334 GEN_VEXT_VX(vor_vx_b, 1, 1, clearb) 1335 GEN_VEXT_VX(vor_vx_h, 2, 2, clearh) 1336 GEN_VEXT_VX(vor_vx_w, 4, 4, clearl) 1337 GEN_VEXT_VX(vor_vx_d, 8, 8, clearq) 1338 GEN_VEXT_VX(vxor_vx_b, 1, 1, clearb) 1339 GEN_VEXT_VX(vxor_vx_h, 2, 2, clearh) 1340 GEN_VEXT_VX(vxor_vx_w, 4, 4, clearl) 1341 GEN_VEXT_VX(vxor_vx_d, 8, 8, clearq) 1342 1343 /* Vector Single-Width Bit Shift Instructions */ 1344 #define DO_SLL(N, M) (N << (M)) 1345 #define DO_SRL(N, M) (N >> (M)) 1346 1347 /* generate the helpers for shift instructions with two vector operators */ 1348 #define GEN_VEXT_SHIFT_VV(NAME, TS1, TS2, HS1, HS2, OP, MASK, CLEAR_FN) \ 1349 void HELPER(NAME)(void *vd, void *v0, void *vs1, \ 1350 void *vs2, CPURISCVState *env, uint32_t desc) \ 1351 { \ 1352 uint32_t mlen = vext_mlen(desc); \ 1353 uint32_t vm = vext_vm(desc); \ 1354 uint32_t vl = env->vl; \ 1355 uint32_t esz = sizeof(TS1); \ 1356 uint32_t vlmax = vext_maxsz(desc) / esz; \ 1357 uint32_t i; \ 1358 \ 1359 for (i = 0; i < vl; i++) { \ 1360 if (!vm && !vext_elem_mask(v0, mlen, i)) { \ 1361 continue; \ 1362 } \ 1363 TS1 s1 = *((TS1 *)vs1 + HS1(i)); \ 1364 TS2 s2 = *((TS2 *)vs2 + HS2(i)); \ 1365 *((TS1 *)vd + HS1(i)) = OP(s2, s1 & MASK); \ 1366 } \ 1367 CLEAR_FN(vd, vl, vl * esz, vlmax * esz); \ 1368 } 1369 1370 GEN_VEXT_SHIFT_VV(vsll_vv_b, uint8_t, uint8_t, H1, H1, DO_SLL, 0x7, clearb) 1371 GEN_VEXT_SHIFT_VV(vsll_vv_h, uint16_t, uint16_t, H2, H2, DO_SLL, 0xf, clearh) 1372 GEN_VEXT_SHIFT_VV(vsll_vv_w, uint32_t, uint32_t, H4, H4, DO_SLL, 0x1f, clearl) 1373 GEN_VEXT_SHIFT_VV(vsll_vv_d, uint64_t, uint64_t, H8, H8, DO_SLL, 0x3f, clearq) 1374 1375 GEN_VEXT_SHIFT_VV(vsrl_vv_b, uint8_t, uint8_t, H1, H1, DO_SRL, 0x7, clearb) 1376 GEN_VEXT_SHIFT_VV(vsrl_vv_h, uint16_t, uint16_t, H2, H2, DO_SRL, 0xf, clearh) 1377 GEN_VEXT_SHIFT_VV(vsrl_vv_w, uint32_t, uint32_t, H4, H4, DO_SRL, 0x1f, clearl) 1378 GEN_VEXT_SHIFT_VV(vsrl_vv_d, uint64_t, uint64_t, H8, H8, DO_SRL, 0x3f, clearq) 1379 1380 GEN_VEXT_SHIFT_VV(vsra_vv_b, uint8_t, int8_t, H1, H1, DO_SRL, 0x7, clearb) 1381 GEN_VEXT_SHIFT_VV(vsra_vv_h, uint16_t, int16_t, H2, H2, DO_SRL, 0xf, clearh) 1382 GEN_VEXT_SHIFT_VV(vsra_vv_w, uint32_t, int32_t, H4, H4, DO_SRL, 0x1f, clearl) 1383 GEN_VEXT_SHIFT_VV(vsra_vv_d, uint64_t, int64_t, H8, H8, DO_SRL, 0x3f, clearq) 1384 1385 /* generate the helpers for shift instructions with one vector and one scalar */ 1386 #define GEN_VEXT_SHIFT_VX(NAME, TD, TS2, HD, HS2, OP, MASK, CLEAR_FN) \ 1387 void HELPER(NAME)(void *vd, void *v0, target_ulong s1, \ 1388 void *vs2, CPURISCVState *env, uint32_t desc) \ 1389 { \ 1390 uint32_t mlen = vext_mlen(desc); \ 1391 uint32_t vm = vext_vm(desc); \ 1392 uint32_t vl = env->vl; \ 1393 uint32_t esz = sizeof(TD); \ 1394 uint32_t vlmax = vext_maxsz(desc) / esz; \ 1395 uint32_t i; \ 1396 \ 1397 for (i = 0; i < vl; i++) { \ 1398 if (!vm && !vext_elem_mask(v0, mlen, i)) { \ 1399 continue; \ 1400 } \ 1401 TS2 s2 = *((TS2 *)vs2 + HS2(i)); \ 1402 *((TD *)vd + HD(i)) = OP(s2, s1 & MASK); \ 1403 } \ 1404 CLEAR_FN(vd, vl, vl * esz, vlmax * esz); \ 1405 } 1406 1407 GEN_VEXT_SHIFT_VX(vsll_vx_b, uint8_t, int8_t, H1, H1, DO_SLL, 0x7, clearb) 1408 GEN_VEXT_SHIFT_VX(vsll_vx_h, uint16_t, int16_t, H2, H2, DO_SLL, 0xf, clearh) 1409 GEN_VEXT_SHIFT_VX(vsll_vx_w, uint32_t, int32_t, H4, H4, DO_SLL, 0x1f, clearl) 1410 GEN_VEXT_SHIFT_VX(vsll_vx_d, uint64_t, int64_t, H8, H8, DO_SLL, 0x3f, clearq) 1411 1412 GEN_VEXT_SHIFT_VX(vsrl_vx_b, uint8_t, uint8_t, H1, H1, DO_SRL, 0x7, clearb) 1413 GEN_VEXT_SHIFT_VX(vsrl_vx_h, uint16_t, uint16_t, H2, H2, DO_SRL, 0xf, clearh) 1414 GEN_VEXT_SHIFT_VX(vsrl_vx_w, uint32_t, uint32_t, H4, H4, DO_SRL, 0x1f, clearl) 1415 GEN_VEXT_SHIFT_VX(vsrl_vx_d, uint64_t, uint64_t, H8, H8, DO_SRL, 0x3f, clearq) 1416 1417 GEN_VEXT_SHIFT_VX(vsra_vx_b, int8_t, int8_t, H1, H1, DO_SRL, 0x7, clearb) 1418 GEN_VEXT_SHIFT_VX(vsra_vx_h, int16_t, int16_t, H2, H2, DO_SRL, 0xf, clearh) 1419 GEN_VEXT_SHIFT_VX(vsra_vx_w, int32_t, int32_t, H4, H4, DO_SRL, 0x1f, clearl) 1420 GEN_VEXT_SHIFT_VX(vsra_vx_d, int64_t, int64_t, H8, H8, DO_SRL, 0x3f, clearq) 1421 1422 /* Vector Narrowing Integer Right Shift Instructions */ 1423 GEN_VEXT_SHIFT_VV(vnsrl_vv_b, uint8_t, uint16_t, H1, H2, DO_SRL, 0xf, clearb) 1424 GEN_VEXT_SHIFT_VV(vnsrl_vv_h, uint16_t, uint32_t, H2, H4, DO_SRL, 0x1f, clearh) 1425 GEN_VEXT_SHIFT_VV(vnsrl_vv_w, uint32_t, uint64_t, H4, H8, DO_SRL, 0x3f, clearl) 1426 GEN_VEXT_SHIFT_VV(vnsra_vv_b, uint8_t, int16_t, H1, H2, DO_SRL, 0xf, clearb) 1427 GEN_VEXT_SHIFT_VV(vnsra_vv_h, uint16_t, int32_t, H2, H4, DO_SRL, 0x1f, clearh) 1428 GEN_VEXT_SHIFT_VV(vnsra_vv_w, uint32_t, int64_t, H4, H8, DO_SRL, 0x3f, clearl) 1429 GEN_VEXT_SHIFT_VX(vnsrl_vx_b, uint8_t, uint16_t, H1, H2, DO_SRL, 0xf, clearb) 1430 GEN_VEXT_SHIFT_VX(vnsrl_vx_h, uint16_t, uint32_t, H2, H4, DO_SRL, 0x1f, clearh) 1431 GEN_VEXT_SHIFT_VX(vnsrl_vx_w, uint32_t, uint64_t, H4, H8, DO_SRL, 0x3f, clearl) 1432 GEN_VEXT_SHIFT_VX(vnsra_vx_b, int8_t, int16_t, H1, H2, DO_SRL, 0xf, clearb) 1433 GEN_VEXT_SHIFT_VX(vnsra_vx_h, int16_t, int32_t, H2, H4, DO_SRL, 0x1f, clearh) 1434 GEN_VEXT_SHIFT_VX(vnsra_vx_w, int32_t, int64_t, H4, H8, DO_SRL, 0x3f, clearl) 1435 1436 /* Vector Integer Comparison Instructions */ 1437 #define DO_MSEQ(N, M) (N == M) 1438 #define DO_MSNE(N, M) (N != M) 1439 #define DO_MSLT(N, M) (N < M) 1440 #define DO_MSLE(N, M) (N <= M) 1441 #define DO_MSGT(N, M) (N > M) 1442 1443 #define GEN_VEXT_CMP_VV(NAME, ETYPE, H, DO_OP) \ 1444 void HELPER(NAME)(void *vd, void *v0, void *vs1, void *vs2, \ 1445 CPURISCVState *env, uint32_t desc) \ 1446 { \ 1447 uint32_t mlen = vext_mlen(desc); \ 1448 uint32_t vm = vext_vm(desc); \ 1449 uint32_t vl = env->vl; \ 1450 uint32_t vlmax = vext_maxsz(desc) / sizeof(ETYPE); \ 1451 uint32_t i; \ 1452 \ 1453 for (i = 0; i < vl; i++) { \ 1454 ETYPE s1 = *((ETYPE *)vs1 + H(i)); \ 1455 ETYPE s2 = *((ETYPE *)vs2 + H(i)); \ 1456 if (!vm && !vext_elem_mask(v0, mlen, i)) { \ 1457 continue; \ 1458 } \ 1459 vext_set_elem_mask(vd, mlen, i, DO_OP(s2, s1)); \ 1460 } \ 1461 for (; i < vlmax; i++) { \ 1462 vext_set_elem_mask(vd, mlen, i, 0); \ 1463 } \ 1464 } 1465 1466 GEN_VEXT_CMP_VV(vmseq_vv_b, uint8_t, H1, DO_MSEQ) 1467 GEN_VEXT_CMP_VV(vmseq_vv_h, uint16_t, H2, DO_MSEQ) 1468 GEN_VEXT_CMP_VV(vmseq_vv_w, uint32_t, H4, DO_MSEQ) 1469 GEN_VEXT_CMP_VV(vmseq_vv_d, uint64_t, H8, DO_MSEQ) 1470 1471 GEN_VEXT_CMP_VV(vmsne_vv_b, uint8_t, H1, DO_MSNE) 1472 GEN_VEXT_CMP_VV(vmsne_vv_h, uint16_t, H2, DO_MSNE) 1473 GEN_VEXT_CMP_VV(vmsne_vv_w, uint32_t, H4, DO_MSNE) 1474 GEN_VEXT_CMP_VV(vmsne_vv_d, uint64_t, H8, DO_MSNE) 1475 1476 GEN_VEXT_CMP_VV(vmsltu_vv_b, uint8_t, H1, DO_MSLT) 1477 GEN_VEXT_CMP_VV(vmsltu_vv_h, uint16_t, H2, DO_MSLT) 1478 GEN_VEXT_CMP_VV(vmsltu_vv_w, uint32_t, H4, DO_MSLT) 1479 GEN_VEXT_CMP_VV(vmsltu_vv_d, uint64_t, H8, DO_MSLT) 1480 1481 GEN_VEXT_CMP_VV(vmslt_vv_b, int8_t, H1, DO_MSLT) 1482 GEN_VEXT_CMP_VV(vmslt_vv_h, int16_t, H2, DO_MSLT) 1483 GEN_VEXT_CMP_VV(vmslt_vv_w, int32_t, H4, DO_MSLT) 1484 GEN_VEXT_CMP_VV(vmslt_vv_d, int64_t, H8, DO_MSLT) 1485 1486 GEN_VEXT_CMP_VV(vmsleu_vv_b, uint8_t, H1, DO_MSLE) 1487 GEN_VEXT_CMP_VV(vmsleu_vv_h, uint16_t, H2, DO_MSLE) 1488 GEN_VEXT_CMP_VV(vmsleu_vv_w, uint32_t, H4, DO_MSLE) 1489 GEN_VEXT_CMP_VV(vmsleu_vv_d, uint64_t, H8, DO_MSLE) 1490 1491 GEN_VEXT_CMP_VV(vmsle_vv_b, int8_t, H1, DO_MSLE) 1492 GEN_VEXT_CMP_VV(vmsle_vv_h, int16_t, H2, DO_MSLE) 1493 GEN_VEXT_CMP_VV(vmsle_vv_w, int32_t, H4, DO_MSLE) 1494 GEN_VEXT_CMP_VV(vmsle_vv_d, int64_t, H8, DO_MSLE) 1495 1496 #define GEN_VEXT_CMP_VX(NAME, ETYPE, H, DO_OP) \ 1497 void HELPER(NAME)(void *vd, void *v0, target_ulong s1, void *vs2, \ 1498 CPURISCVState *env, uint32_t desc) \ 1499 { \ 1500 uint32_t mlen = vext_mlen(desc); \ 1501 uint32_t vm = vext_vm(desc); \ 1502 uint32_t vl = env->vl; \ 1503 uint32_t vlmax = vext_maxsz(desc) / sizeof(ETYPE); \ 1504 uint32_t i; \ 1505 \ 1506 for (i = 0; i < vl; i++) { \ 1507 ETYPE s2 = *((ETYPE *)vs2 + H(i)); \ 1508 if (!vm && !vext_elem_mask(v0, mlen, i)) { \ 1509 continue; \ 1510 } \ 1511 vext_set_elem_mask(vd, mlen, i, \ 1512 DO_OP(s2, (ETYPE)(target_long)s1)); \ 1513 } \ 1514 for (; i < vlmax; i++) { \ 1515 vext_set_elem_mask(vd, mlen, i, 0); \ 1516 } \ 1517 } 1518 1519 GEN_VEXT_CMP_VX(vmseq_vx_b, uint8_t, H1, DO_MSEQ) 1520 GEN_VEXT_CMP_VX(vmseq_vx_h, uint16_t, H2, DO_MSEQ) 1521 GEN_VEXT_CMP_VX(vmseq_vx_w, uint32_t, H4, DO_MSEQ) 1522 GEN_VEXT_CMP_VX(vmseq_vx_d, uint64_t, H8, DO_MSEQ) 1523 1524 GEN_VEXT_CMP_VX(vmsne_vx_b, uint8_t, H1, DO_MSNE) 1525 GEN_VEXT_CMP_VX(vmsne_vx_h, uint16_t, H2, DO_MSNE) 1526 GEN_VEXT_CMP_VX(vmsne_vx_w, uint32_t, H4, DO_MSNE) 1527 GEN_VEXT_CMP_VX(vmsne_vx_d, uint64_t, H8, DO_MSNE) 1528 1529 GEN_VEXT_CMP_VX(vmsltu_vx_b, uint8_t, H1, DO_MSLT) 1530 GEN_VEXT_CMP_VX(vmsltu_vx_h, uint16_t, H2, DO_MSLT) 1531 GEN_VEXT_CMP_VX(vmsltu_vx_w, uint32_t, H4, DO_MSLT) 1532 GEN_VEXT_CMP_VX(vmsltu_vx_d, uint64_t, H8, DO_MSLT) 1533 1534 GEN_VEXT_CMP_VX(vmslt_vx_b, int8_t, H1, DO_MSLT) 1535 GEN_VEXT_CMP_VX(vmslt_vx_h, int16_t, H2, DO_MSLT) 1536 GEN_VEXT_CMP_VX(vmslt_vx_w, int32_t, H4, DO_MSLT) 1537 GEN_VEXT_CMP_VX(vmslt_vx_d, int64_t, H8, DO_MSLT) 1538 1539 GEN_VEXT_CMP_VX(vmsleu_vx_b, uint8_t, H1, DO_MSLE) 1540 GEN_VEXT_CMP_VX(vmsleu_vx_h, uint16_t, H2, DO_MSLE) 1541 GEN_VEXT_CMP_VX(vmsleu_vx_w, uint32_t, H4, DO_MSLE) 1542 GEN_VEXT_CMP_VX(vmsleu_vx_d, uint64_t, H8, DO_MSLE) 1543 1544 GEN_VEXT_CMP_VX(vmsle_vx_b, int8_t, H1, DO_MSLE) 1545 GEN_VEXT_CMP_VX(vmsle_vx_h, int16_t, H2, DO_MSLE) 1546 GEN_VEXT_CMP_VX(vmsle_vx_w, int32_t, H4, DO_MSLE) 1547 GEN_VEXT_CMP_VX(vmsle_vx_d, int64_t, H8, DO_MSLE) 1548 1549 GEN_VEXT_CMP_VX(vmsgtu_vx_b, uint8_t, H1, DO_MSGT) 1550 GEN_VEXT_CMP_VX(vmsgtu_vx_h, uint16_t, H2, DO_MSGT) 1551 GEN_VEXT_CMP_VX(vmsgtu_vx_w, uint32_t, H4, DO_MSGT) 1552 GEN_VEXT_CMP_VX(vmsgtu_vx_d, uint64_t, H8, DO_MSGT) 1553 1554 GEN_VEXT_CMP_VX(vmsgt_vx_b, int8_t, H1, DO_MSGT) 1555 GEN_VEXT_CMP_VX(vmsgt_vx_h, int16_t, H2, DO_MSGT) 1556 GEN_VEXT_CMP_VX(vmsgt_vx_w, int32_t, H4, DO_MSGT) 1557 GEN_VEXT_CMP_VX(vmsgt_vx_d, int64_t, H8, DO_MSGT) 1558 1559 /* Vector Integer Min/Max Instructions */ 1560 RVVCALL(OPIVV2, vminu_vv_b, OP_UUU_B, H1, H1, H1, DO_MIN) 1561 RVVCALL(OPIVV2, vminu_vv_h, OP_UUU_H, H2, H2, H2, DO_MIN) 1562 RVVCALL(OPIVV2, vminu_vv_w, OP_UUU_W, H4, H4, H4, DO_MIN) 1563 RVVCALL(OPIVV2, vminu_vv_d, OP_UUU_D, H8, H8, H8, DO_MIN) 1564 RVVCALL(OPIVV2, vmin_vv_b, OP_SSS_B, H1, H1, H1, DO_MIN) 1565 RVVCALL(OPIVV2, vmin_vv_h, OP_SSS_H, H2, H2, H2, DO_MIN) 1566 RVVCALL(OPIVV2, vmin_vv_w, OP_SSS_W, H4, H4, H4, DO_MIN) 1567 RVVCALL(OPIVV2, vmin_vv_d, OP_SSS_D, H8, H8, H8, DO_MIN) 1568 RVVCALL(OPIVV2, vmaxu_vv_b, OP_UUU_B, H1, H1, H1, DO_MAX) 1569 RVVCALL(OPIVV2, vmaxu_vv_h, OP_UUU_H, H2, H2, H2, DO_MAX) 1570 RVVCALL(OPIVV2, vmaxu_vv_w, OP_UUU_W, H4, H4, H4, DO_MAX) 1571 RVVCALL(OPIVV2, vmaxu_vv_d, OP_UUU_D, H8, H8, H8, DO_MAX) 1572 RVVCALL(OPIVV2, vmax_vv_b, OP_SSS_B, H1, H1, H1, DO_MAX) 1573 RVVCALL(OPIVV2, vmax_vv_h, OP_SSS_H, H2, H2, H2, DO_MAX) 1574 RVVCALL(OPIVV2, vmax_vv_w, OP_SSS_W, H4, H4, H4, DO_MAX) 1575 RVVCALL(OPIVV2, vmax_vv_d, OP_SSS_D, H8, H8, H8, DO_MAX) 1576 GEN_VEXT_VV(vminu_vv_b, 1, 1, clearb) 1577 GEN_VEXT_VV(vminu_vv_h, 2, 2, clearh) 1578 GEN_VEXT_VV(vminu_vv_w, 4, 4, clearl) 1579 GEN_VEXT_VV(vminu_vv_d, 8, 8, clearq) 1580 GEN_VEXT_VV(vmin_vv_b, 1, 1, clearb) 1581 GEN_VEXT_VV(vmin_vv_h, 2, 2, clearh) 1582 GEN_VEXT_VV(vmin_vv_w, 4, 4, clearl) 1583 GEN_VEXT_VV(vmin_vv_d, 8, 8, clearq) 1584 GEN_VEXT_VV(vmaxu_vv_b, 1, 1, clearb) 1585 GEN_VEXT_VV(vmaxu_vv_h, 2, 2, clearh) 1586 GEN_VEXT_VV(vmaxu_vv_w, 4, 4, clearl) 1587 GEN_VEXT_VV(vmaxu_vv_d, 8, 8, clearq) 1588 GEN_VEXT_VV(vmax_vv_b, 1, 1, clearb) 1589 GEN_VEXT_VV(vmax_vv_h, 2, 2, clearh) 1590 GEN_VEXT_VV(vmax_vv_w, 4, 4, clearl) 1591 GEN_VEXT_VV(vmax_vv_d, 8, 8, clearq) 1592 1593 RVVCALL(OPIVX2, vminu_vx_b, OP_UUU_B, H1, H1, DO_MIN) 1594 RVVCALL(OPIVX2, vminu_vx_h, OP_UUU_H, H2, H2, DO_MIN) 1595 RVVCALL(OPIVX2, vminu_vx_w, OP_UUU_W, H4, H4, DO_MIN) 1596 RVVCALL(OPIVX2, vminu_vx_d, OP_UUU_D, H8, H8, DO_MIN) 1597 RVVCALL(OPIVX2, vmin_vx_b, OP_SSS_B, H1, H1, DO_MIN) 1598 RVVCALL(OPIVX2, vmin_vx_h, OP_SSS_H, H2, H2, DO_MIN) 1599 RVVCALL(OPIVX2, vmin_vx_w, OP_SSS_W, H4, H4, DO_MIN) 1600 RVVCALL(OPIVX2, vmin_vx_d, OP_SSS_D, H8, H8, DO_MIN) 1601 RVVCALL(OPIVX2, vmaxu_vx_b, OP_UUU_B, H1, H1, DO_MAX) 1602 RVVCALL(OPIVX2, vmaxu_vx_h, OP_UUU_H, H2, H2, DO_MAX) 1603 RVVCALL(OPIVX2, vmaxu_vx_w, OP_UUU_W, H4, H4, DO_MAX) 1604 RVVCALL(OPIVX2, vmaxu_vx_d, OP_UUU_D, H8, H8, DO_MAX) 1605 RVVCALL(OPIVX2, vmax_vx_b, OP_SSS_B, H1, H1, DO_MAX) 1606 RVVCALL(OPIVX2, vmax_vx_h, OP_SSS_H, H2, H2, DO_MAX) 1607 RVVCALL(OPIVX2, vmax_vx_w, OP_SSS_W, H4, H4, DO_MAX) 1608 RVVCALL(OPIVX2, vmax_vx_d, OP_SSS_D, H8, H8, DO_MAX) 1609 GEN_VEXT_VX(vminu_vx_b, 1, 1, clearb) 1610 GEN_VEXT_VX(vminu_vx_h, 2, 2, clearh) 1611 GEN_VEXT_VX(vminu_vx_w, 4, 4, clearl) 1612 GEN_VEXT_VX(vminu_vx_d, 8, 8, clearq) 1613 GEN_VEXT_VX(vmin_vx_b, 1, 1, clearb) 1614 GEN_VEXT_VX(vmin_vx_h, 2, 2, clearh) 1615 GEN_VEXT_VX(vmin_vx_w, 4, 4, clearl) 1616 GEN_VEXT_VX(vmin_vx_d, 8, 8, clearq) 1617 GEN_VEXT_VX(vmaxu_vx_b, 1, 1, clearb) 1618 GEN_VEXT_VX(vmaxu_vx_h, 2, 2, clearh) 1619 GEN_VEXT_VX(vmaxu_vx_w, 4, 4, clearl) 1620 GEN_VEXT_VX(vmaxu_vx_d, 8, 8, clearq) 1621 GEN_VEXT_VX(vmax_vx_b, 1, 1, clearb) 1622 GEN_VEXT_VX(vmax_vx_h, 2, 2, clearh) 1623 GEN_VEXT_VX(vmax_vx_w, 4, 4, clearl) 1624 GEN_VEXT_VX(vmax_vx_d, 8, 8, clearq) 1625 1626 /* Vector Single-Width Integer Multiply Instructions */ 1627 #define DO_MUL(N, M) (N * M) 1628 RVVCALL(OPIVV2, vmul_vv_b, OP_SSS_B, H1, H1, H1, DO_MUL) 1629 RVVCALL(OPIVV2, vmul_vv_h, OP_SSS_H, H2, H2, H2, DO_MUL) 1630 RVVCALL(OPIVV2, vmul_vv_w, OP_SSS_W, H4, H4, H4, DO_MUL) 1631 RVVCALL(OPIVV2, vmul_vv_d, OP_SSS_D, H8, H8, H8, DO_MUL) 1632 GEN_VEXT_VV(vmul_vv_b, 1, 1, clearb) 1633 GEN_VEXT_VV(vmul_vv_h, 2, 2, clearh) 1634 GEN_VEXT_VV(vmul_vv_w, 4, 4, clearl) 1635 GEN_VEXT_VV(vmul_vv_d, 8, 8, clearq) 1636 1637 static int8_t do_mulh_b(int8_t s2, int8_t s1) 1638 { 1639 return (int16_t)s2 * (int16_t)s1 >> 8; 1640 } 1641 1642 static int16_t do_mulh_h(int16_t s2, int16_t s1) 1643 { 1644 return (int32_t)s2 * (int32_t)s1 >> 16; 1645 } 1646 1647 static int32_t do_mulh_w(int32_t s2, int32_t s1) 1648 { 1649 return (int64_t)s2 * (int64_t)s1 >> 32; 1650 } 1651 1652 static int64_t do_mulh_d(int64_t s2, int64_t s1) 1653 { 1654 uint64_t hi_64, lo_64; 1655 1656 muls64(&lo_64, &hi_64, s1, s2); 1657 return hi_64; 1658 } 1659 1660 static uint8_t do_mulhu_b(uint8_t s2, uint8_t s1) 1661 { 1662 return (uint16_t)s2 * (uint16_t)s1 >> 8; 1663 } 1664 1665 static uint16_t do_mulhu_h(uint16_t s2, uint16_t s1) 1666 { 1667 return (uint32_t)s2 * (uint32_t)s1 >> 16; 1668 } 1669 1670 static uint32_t do_mulhu_w(uint32_t s2, uint32_t s1) 1671 { 1672 return (uint64_t)s2 * (uint64_t)s1 >> 32; 1673 } 1674 1675 static uint64_t do_mulhu_d(uint64_t s2, uint64_t s1) 1676 { 1677 uint64_t hi_64, lo_64; 1678 1679 mulu64(&lo_64, &hi_64, s2, s1); 1680 return hi_64; 1681 } 1682 1683 static int8_t do_mulhsu_b(int8_t s2, uint8_t s1) 1684 { 1685 return (int16_t)s2 * (uint16_t)s1 >> 8; 1686 } 1687 1688 static int16_t do_mulhsu_h(int16_t s2, uint16_t s1) 1689 { 1690 return (int32_t)s2 * (uint32_t)s1 >> 16; 1691 } 1692 1693 static int32_t do_mulhsu_w(int32_t s2, uint32_t s1) 1694 { 1695 return (int64_t)s2 * (uint64_t)s1 >> 32; 1696 } 1697 1698 /* 1699 * Let A = signed operand, 1700 * B = unsigned operand 1701 * P = mulu64(A, B), unsigned product 1702 * 1703 * LET X = 2 ** 64 - A, 2's complement of A 1704 * SP = signed product 1705 * THEN 1706 * IF A < 0 1707 * SP = -X * B 1708 * = -(2 ** 64 - A) * B 1709 * = A * B - 2 ** 64 * B 1710 * = P - 2 ** 64 * B 1711 * ELSE 1712 * SP = P 1713 * THEN 1714 * HI_P -= (A < 0 ? B : 0) 1715 */ 1716 1717 static int64_t do_mulhsu_d(int64_t s2, uint64_t s1) 1718 { 1719 uint64_t hi_64, lo_64; 1720 1721 mulu64(&lo_64, &hi_64, s2, s1); 1722 1723 hi_64 -= s2 < 0 ? s1 : 0; 1724 return hi_64; 1725 } 1726 1727 RVVCALL(OPIVV2, vmulh_vv_b, OP_SSS_B, H1, H1, H1, do_mulh_b) 1728 RVVCALL(OPIVV2, vmulh_vv_h, OP_SSS_H, H2, H2, H2, do_mulh_h) 1729 RVVCALL(OPIVV2, vmulh_vv_w, OP_SSS_W, H4, H4, H4, do_mulh_w) 1730 RVVCALL(OPIVV2, vmulh_vv_d, OP_SSS_D, H8, H8, H8, do_mulh_d) 1731 RVVCALL(OPIVV2, vmulhu_vv_b, OP_UUU_B, H1, H1, H1, do_mulhu_b) 1732 RVVCALL(OPIVV2, vmulhu_vv_h, OP_UUU_H, H2, H2, H2, do_mulhu_h) 1733 RVVCALL(OPIVV2, vmulhu_vv_w, OP_UUU_W, H4, H4, H4, do_mulhu_w) 1734 RVVCALL(OPIVV2, vmulhu_vv_d, OP_UUU_D, H8, H8, H8, do_mulhu_d) 1735 RVVCALL(OPIVV2, vmulhsu_vv_b, OP_SUS_B, H1, H1, H1, do_mulhsu_b) 1736 RVVCALL(OPIVV2, vmulhsu_vv_h, OP_SUS_H, H2, H2, H2, do_mulhsu_h) 1737 RVVCALL(OPIVV2, vmulhsu_vv_w, OP_SUS_W, H4, H4, H4, do_mulhsu_w) 1738 RVVCALL(OPIVV2, vmulhsu_vv_d, OP_SUS_D, H8, H8, H8, do_mulhsu_d) 1739 GEN_VEXT_VV(vmulh_vv_b, 1, 1, clearb) 1740 GEN_VEXT_VV(vmulh_vv_h, 2, 2, clearh) 1741 GEN_VEXT_VV(vmulh_vv_w, 4, 4, clearl) 1742 GEN_VEXT_VV(vmulh_vv_d, 8, 8, clearq) 1743 GEN_VEXT_VV(vmulhu_vv_b, 1, 1, clearb) 1744 GEN_VEXT_VV(vmulhu_vv_h, 2, 2, clearh) 1745 GEN_VEXT_VV(vmulhu_vv_w, 4, 4, clearl) 1746 GEN_VEXT_VV(vmulhu_vv_d, 8, 8, clearq) 1747 GEN_VEXT_VV(vmulhsu_vv_b, 1, 1, clearb) 1748 GEN_VEXT_VV(vmulhsu_vv_h, 2, 2, clearh) 1749 GEN_VEXT_VV(vmulhsu_vv_w, 4, 4, clearl) 1750 GEN_VEXT_VV(vmulhsu_vv_d, 8, 8, clearq) 1751 1752 RVVCALL(OPIVX2, vmul_vx_b, OP_SSS_B, H1, H1, DO_MUL) 1753 RVVCALL(OPIVX2, vmul_vx_h, OP_SSS_H, H2, H2, DO_MUL) 1754 RVVCALL(OPIVX2, vmul_vx_w, OP_SSS_W, H4, H4, DO_MUL) 1755 RVVCALL(OPIVX2, vmul_vx_d, OP_SSS_D, H8, H8, DO_MUL) 1756 RVVCALL(OPIVX2, vmulh_vx_b, OP_SSS_B, H1, H1, do_mulh_b) 1757 RVVCALL(OPIVX2, vmulh_vx_h, OP_SSS_H, H2, H2, do_mulh_h) 1758 RVVCALL(OPIVX2, vmulh_vx_w, OP_SSS_W, H4, H4, do_mulh_w) 1759 RVVCALL(OPIVX2, vmulh_vx_d, OP_SSS_D, H8, H8, do_mulh_d) 1760 RVVCALL(OPIVX2, vmulhu_vx_b, OP_UUU_B, H1, H1, do_mulhu_b) 1761 RVVCALL(OPIVX2, vmulhu_vx_h, OP_UUU_H, H2, H2, do_mulhu_h) 1762 RVVCALL(OPIVX2, vmulhu_vx_w, OP_UUU_W, H4, H4, do_mulhu_w) 1763 RVVCALL(OPIVX2, vmulhu_vx_d, OP_UUU_D, H8, H8, do_mulhu_d) 1764 RVVCALL(OPIVX2, vmulhsu_vx_b, OP_SUS_B, H1, H1, do_mulhsu_b) 1765 RVVCALL(OPIVX2, vmulhsu_vx_h, OP_SUS_H, H2, H2, do_mulhsu_h) 1766 RVVCALL(OPIVX2, vmulhsu_vx_w, OP_SUS_W, H4, H4, do_mulhsu_w) 1767 RVVCALL(OPIVX2, vmulhsu_vx_d, OP_SUS_D, H8, H8, do_mulhsu_d) 1768 GEN_VEXT_VX(vmul_vx_b, 1, 1, clearb) 1769 GEN_VEXT_VX(vmul_vx_h, 2, 2, clearh) 1770 GEN_VEXT_VX(vmul_vx_w, 4, 4, clearl) 1771 GEN_VEXT_VX(vmul_vx_d, 8, 8, clearq) 1772 GEN_VEXT_VX(vmulh_vx_b, 1, 1, clearb) 1773 GEN_VEXT_VX(vmulh_vx_h, 2, 2, clearh) 1774 GEN_VEXT_VX(vmulh_vx_w, 4, 4, clearl) 1775 GEN_VEXT_VX(vmulh_vx_d, 8, 8, clearq) 1776 GEN_VEXT_VX(vmulhu_vx_b, 1, 1, clearb) 1777 GEN_VEXT_VX(vmulhu_vx_h, 2, 2, clearh) 1778 GEN_VEXT_VX(vmulhu_vx_w, 4, 4, clearl) 1779 GEN_VEXT_VX(vmulhu_vx_d, 8, 8, clearq) 1780 GEN_VEXT_VX(vmulhsu_vx_b, 1, 1, clearb) 1781 GEN_VEXT_VX(vmulhsu_vx_h, 2, 2, clearh) 1782 GEN_VEXT_VX(vmulhsu_vx_w, 4, 4, clearl) 1783 GEN_VEXT_VX(vmulhsu_vx_d, 8, 8, clearq) 1784 1785 /* Vector Integer Divide Instructions */ 1786 #define DO_DIVU(N, M) (unlikely(M == 0) ? (__typeof(N))(-1) : N / M) 1787 #define DO_REMU(N, M) (unlikely(M == 0) ? N : N % M) 1788 #define DO_DIV(N, M) (unlikely(M == 0) ? (__typeof(N))(-1) :\ 1789 unlikely((N == -N) && (M == (__typeof(N))(-1))) ? N : N / M) 1790 #define DO_REM(N, M) (unlikely(M == 0) ? N :\ 1791 unlikely((N == -N) && (M == (__typeof(N))(-1))) ? 0 : N % M) 1792 1793 RVVCALL(OPIVV2, vdivu_vv_b, OP_UUU_B, H1, H1, H1, DO_DIVU) 1794 RVVCALL(OPIVV2, vdivu_vv_h, OP_UUU_H, H2, H2, H2, DO_DIVU) 1795 RVVCALL(OPIVV2, vdivu_vv_w, OP_UUU_W, H4, H4, H4, DO_DIVU) 1796 RVVCALL(OPIVV2, vdivu_vv_d, OP_UUU_D, H8, H8, H8, DO_DIVU) 1797 RVVCALL(OPIVV2, vdiv_vv_b, OP_SSS_B, H1, H1, H1, DO_DIV) 1798 RVVCALL(OPIVV2, vdiv_vv_h, OP_SSS_H, H2, H2, H2, DO_DIV) 1799 RVVCALL(OPIVV2, vdiv_vv_w, OP_SSS_W, H4, H4, H4, DO_DIV) 1800 RVVCALL(OPIVV2, vdiv_vv_d, OP_SSS_D, H8, H8, H8, DO_DIV) 1801 RVVCALL(OPIVV2, vremu_vv_b, OP_UUU_B, H1, H1, H1, DO_REMU) 1802 RVVCALL(OPIVV2, vremu_vv_h, OP_UUU_H, H2, H2, H2, DO_REMU) 1803 RVVCALL(OPIVV2, vremu_vv_w, OP_UUU_W, H4, H4, H4, DO_REMU) 1804 RVVCALL(OPIVV2, vremu_vv_d, OP_UUU_D, H8, H8, H8, DO_REMU) 1805 RVVCALL(OPIVV2, vrem_vv_b, OP_SSS_B, H1, H1, H1, DO_REM) 1806 RVVCALL(OPIVV2, vrem_vv_h, OP_SSS_H, H2, H2, H2, DO_REM) 1807 RVVCALL(OPIVV2, vrem_vv_w, OP_SSS_W, H4, H4, H4, DO_REM) 1808 RVVCALL(OPIVV2, vrem_vv_d, OP_SSS_D, H8, H8, H8, DO_REM) 1809 GEN_VEXT_VV(vdivu_vv_b, 1, 1, clearb) 1810 GEN_VEXT_VV(vdivu_vv_h, 2, 2, clearh) 1811 GEN_VEXT_VV(vdivu_vv_w, 4, 4, clearl) 1812 GEN_VEXT_VV(vdivu_vv_d, 8, 8, clearq) 1813 GEN_VEXT_VV(vdiv_vv_b, 1, 1, clearb) 1814 GEN_VEXT_VV(vdiv_vv_h, 2, 2, clearh) 1815 GEN_VEXT_VV(vdiv_vv_w, 4, 4, clearl) 1816 GEN_VEXT_VV(vdiv_vv_d, 8, 8, clearq) 1817 GEN_VEXT_VV(vremu_vv_b, 1, 1, clearb) 1818 GEN_VEXT_VV(vremu_vv_h, 2, 2, clearh) 1819 GEN_VEXT_VV(vremu_vv_w, 4, 4, clearl) 1820 GEN_VEXT_VV(vremu_vv_d, 8, 8, clearq) 1821 GEN_VEXT_VV(vrem_vv_b, 1, 1, clearb) 1822 GEN_VEXT_VV(vrem_vv_h, 2, 2, clearh) 1823 GEN_VEXT_VV(vrem_vv_w, 4, 4, clearl) 1824 GEN_VEXT_VV(vrem_vv_d, 8, 8, clearq) 1825 1826 RVVCALL(OPIVX2, vdivu_vx_b, OP_UUU_B, H1, H1, DO_DIVU) 1827 RVVCALL(OPIVX2, vdivu_vx_h, OP_UUU_H, H2, H2, DO_DIVU) 1828 RVVCALL(OPIVX2, vdivu_vx_w, OP_UUU_W, H4, H4, DO_DIVU) 1829 RVVCALL(OPIVX2, vdivu_vx_d, OP_UUU_D, H8, H8, DO_DIVU) 1830 RVVCALL(OPIVX2, vdiv_vx_b, OP_SSS_B, H1, H1, DO_DIV) 1831 RVVCALL(OPIVX2, vdiv_vx_h, OP_SSS_H, H2, H2, DO_DIV) 1832 RVVCALL(OPIVX2, vdiv_vx_w, OP_SSS_W, H4, H4, DO_DIV) 1833 RVVCALL(OPIVX2, vdiv_vx_d, OP_SSS_D, H8, H8, DO_DIV) 1834 RVVCALL(OPIVX2, vremu_vx_b, OP_UUU_B, H1, H1, DO_REMU) 1835 RVVCALL(OPIVX2, vremu_vx_h, OP_UUU_H, H2, H2, DO_REMU) 1836 RVVCALL(OPIVX2, vremu_vx_w, OP_UUU_W, H4, H4, DO_REMU) 1837 RVVCALL(OPIVX2, vremu_vx_d, OP_UUU_D, H8, H8, DO_REMU) 1838 RVVCALL(OPIVX2, vrem_vx_b, OP_SSS_B, H1, H1, DO_REM) 1839 RVVCALL(OPIVX2, vrem_vx_h, OP_SSS_H, H2, H2, DO_REM) 1840 RVVCALL(OPIVX2, vrem_vx_w, OP_SSS_W, H4, H4, DO_REM) 1841 RVVCALL(OPIVX2, vrem_vx_d, OP_SSS_D, H8, H8, DO_REM) 1842 GEN_VEXT_VX(vdivu_vx_b, 1, 1, clearb) 1843 GEN_VEXT_VX(vdivu_vx_h, 2, 2, clearh) 1844 GEN_VEXT_VX(vdivu_vx_w, 4, 4, clearl) 1845 GEN_VEXT_VX(vdivu_vx_d, 8, 8, clearq) 1846 GEN_VEXT_VX(vdiv_vx_b, 1, 1, clearb) 1847 GEN_VEXT_VX(vdiv_vx_h, 2, 2, clearh) 1848 GEN_VEXT_VX(vdiv_vx_w, 4, 4, clearl) 1849 GEN_VEXT_VX(vdiv_vx_d, 8, 8, clearq) 1850 GEN_VEXT_VX(vremu_vx_b, 1, 1, clearb) 1851 GEN_VEXT_VX(vremu_vx_h, 2, 2, clearh) 1852 GEN_VEXT_VX(vremu_vx_w, 4, 4, clearl) 1853 GEN_VEXT_VX(vremu_vx_d, 8, 8, clearq) 1854 GEN_VEXT_VX(vrem_vx_b, 1, 1, clearb) 1855 GEN_VEXT_VX(vrem_vx_h, 2, 2, clearh) 1856 GEN_VEXT_VX(vrem_vx_w, 4, 4, clearl) 1857 GEN_VEXT_VX(vrem_vx_d, 8, 8, clearq) 1858 1859 /* Vector Widening Integer Multiply Instructions */ 1860 RVVCALL(OPIVV2, vwmul_vv_b, WOP_SSS_B, H2, H1, H1, DO_MUL) 1861 RVVCALL(OPIVV2, vwmul_vv_h, WOP_SSS_H, H4, H2, H2, DO_MUL) 1862 RVVCALL(OPIVV2, vwmul_vv_w, WOP_SSS_W, H8, H4, H4, DO_MUL) 1863 RVVCALL(OPIVV2, vwmulu_vv_b, WOP_UUU_B, H2, H1, H1, DO_MUL) 1864 RVVCALL(OPIVV2, vwmulu_vv_h, WOP_UUU_H, H4, H2, H2, DO_MUL) 1865 RVVCALL(OPIVV2, vwmulu_vv_w, WOP_UUU_W, H8, H4, H4, DO_MUL) 1866 RVVCALL(OPIVV2, vwmulsu_vv_b, WOP_SUS_B, H2, H1, H1, DO_MUL) 1867 RVVCALL(OPIVV2, vwmulsu_vv_h, WOP_SUS_H, H4, H2, H2, DO_MUL) 1868 RVVCALL(OPIVV2, vwmulsu_vv_w, WOP_SUS_W, H8, H4, H4, DO_MUL) 1869 GEN_VEXT_VV(vwmul_vv_b, 1, 2, clearh) 1870 GEN_VEXT_VV(vwmul_vv_h, 2, 4, clearl) 1871 GEN_VEXT_VV(vwmul_vv_w, 4, 8, clearq) 1872 GEN_VEXT_VV(vwmulu_vv_b, 1, 2, clearh) 1873 GEN_VEXT_VV(vwmulu_vv_h, 2, 4, clearl) 1874 GEN_VEXT_VV(vwmulu_vv_w, 4, 8, clearq) 1875 GEN_VEXT_VV(vwmulsu_vv_b, 1, 2, clearh) 1876 GEN_VEXT_VV(vwmulsu_vv_h, 2, 4, clearl) 1877 GEN_VEXT_VV(vwmulsu_vv_w, 4, 8, clearq) 1878 1879 RVVCALL(OPIVX2, vwmul_vx_b, WOP_SSS_B, H2, H1, DO_MUL) 1880 RVVCALL(OPIVX2, vwmul_vx_h, WOP_SSS_H, H4, H2, DO_MUL) 1881 RVVCALL(OPIVX2, vwmul_vx_w, WOP_SSS_W, H8, H4, DO_MUL) 1882 RVVCALL(OPIVX2, vwmulu_vx_b, WOP_UUU_B, H2, H1, DO_MUL) 1883 RVVCALL(OPIVX2, vwmulu_vx_h, WOP_UUU_H, H4, H2, DO_MUL) 1884 RVVCALL(OPIVX2, vwmulu_vx_w, WOP_UUU_W, H8, H4, DO_MUL) 1885 RVVCALL(OPIVX2, vwmulsu_vx_b, WOP_SUS_B, H2, H1, DO_MUL) 1886 RVVCALL(OPIVX2, vwmulsu_vx_h, WOP_SUS_H, H4, H2, DO_MUL) 1887 RVVCALL(OPIVX2, vwmulsu_vx_w, WOP_SUS_W, H8, H4, DO_MUL) 1888 GEN_VEXT_VX(vwmul_vx_b, 1, 2, clearh) 1889 GEN_VEXT_VX(vwmul_vx_h, 2, 4, clearl) 1890 GEN_VEXT_VX(vwmul_vx_w, 4, 8, clearq) 1891 GEN_VEXT_VX(vwmulu_vx_b, 1, 2, clearh) 1892 GEN_VEXT_VX(vwmulu_vx_h, 2, 4, clearl) 1893 GEN_VEXT_VX(vwmulu_vx_w, 4, 8, clearq) 1894 GEN_VEXT_VX(vwmulsu_vx_b, 1, 2, clearh) 1895 GEN_VEXT_VX(vwmulsu_vx_h, 2, 4, clearl) 1896 GEN_VEXT_VX(vwmulsu_vx_w, 4, 8, clearq) 1897 1898 /* Vector Single-Width Integer Multiply-Add Instructions */ 1899 #define OPIVV3(NAME, TD, T1, T2, TX1, TX2, HD, HS1, HS2, OP) \ 1900 static void do_##NAME(void *vd, void *vs1, void *vs2, int i) \ 1901 { \ 1902 TX1 s1 = *((T1 *)vs1 + HS1(i)); \ 1903 TX2 s2 = *((T2 *)vs2 + HS2(i)); \ 1904 TD d = *((TD *)vd + HD(i)); \ 1905 *((TD *)vd + HD(i)) = OP(s2, s1, d); \ 1906 } 1907 1908 #define DO_MACC(N, M, D) (M * N + D) 1909 #define DO_NMSAC(N, M, D) (-(M * N) + D) 1910 #define DO_MADD(N, M, D) (M * D + N) 1911 #define DO_NMSUB(N, M, D) (-(M * D) + N) 1912 RVVCALL(OPIVV3, vmacc_vv_b, OP_SSS_B, H1, H1, H1, DO_MACC) 1913 RVVCALL(OPIVV3, vmacc_vv_h, OP_SSS_H, H2, H2, H2, DO_MACC) 1914 RVVCALL(OPIVV3, vmacc_vv_w, OP_SSS_W, H4, H4, H4, DO_MACC) 1915 RVVCALL(OPIVV3, vmacc_vv_d, OP_SSS_D, H8, H8, H8, DO_MACC) 1916 RVVCALL(OPIVV3, vnmsac_vv_b, OP_SSS_B, H1, H1, H1, DO_NMSAC) 1917 RVVCALL(OPIVV3, vnmsac_vv_h, OP_SSS_H, H2, H2, H2, DO_NMSAC) 1918 RVVCALL(OPIVV3, vnmsac_vv_w, OP_SSS_W, H4, H4, H4, DO_NMSAC) 1919 RVVCALL(OPIVV3, vnmsac_vv_d, OP_SSS_D, H8, H8, H8, DO_NMSAC) 1920 RVVCALL(OPIVV3, vmadd_vv_b, OP_SSS_B, H1, H1, H1, DO_MADD) 1921 RVVCALL(OPIVV3, vmadd_vv_h, OP_SSS_H, H2, H2, H2, DO_MADD) 1922 RVVCALL(OPIVV3, vmadd_vv_w, OP_SSS_W, H4, H4, H4, DO_MADD) 1923 RVVCALL(OPIVV3, vmadd_vv_d, OP_SSS_D, H8, H8, H8, DO_MADD) 1924 RVVCALL(OPIVV3, vnmsub_vv_b, OP_SSS_B, H1, H1, H1, DO_NMSUB) 1925 RVVCALL(OPIVV3, vnmsub_vv_h, OP_SSS_H, H2, H2, H2, DO_NMSUB) 1926 RVVCALL(OPIVV3, vnmsub_vv_w, OP_SSS_W, H4, H4, H4, DO_NMSUB) 1927 RVVCALL(OPIVV3, vnmsub_vv_d, OP_SSS_D, H8, H8, H8, DO_NMSUB) 1928 GEN_VEXT_VV(vmacc_vv_b, 1, 1, clearb) 1929 GEN_VEXT_VV(vmacc_vv_h, 2, 2, clearh) 1930 GEN_VEXT_VV(vmacc_vv_w, 4, 4, clearl) 1931 GEN_VEXT_VV(vmacc_vv_d, 8, 8, clearq) 1932 GEN_VEXT_VV(vnmsac_vv_b, 1, 1, clearb) 1933 GEN_VEXT_VV(vnmsac_vv_h, 2, 2, clearh) 1934 GEN_VEXT_VV(vnmsac_vv_w, 4, 4, clearl) 1935 GEN_VEXT_VV(vnmsac_vv_d, 8, 8, clearq) 1936 GEN_VEXT_VV(vmadd_vv_b, 1, 1, clearb) 1937 GEN_VEXT_VV(vmadd_vv_h, 2, 2, clearh) 1938 GEN_VEXT_VV(vmadd_vv_w, 4, 4, clearl) 1939 GEN_VEXT_VV(vmadd_vv_d, 8, 8, clearq) 1940 GEN_VEXT_VV(vnmsub_vv_b, 1, 1, clearb) 1941 GEN_VEXT_VV(vnmsub_vv_h, 2, 2, clearh) 1942 GEN_VEXT_VV(vnmsub_vv_w, 4, 4, clearl) 1943 GEN_VEXT_VV(vnmsub_vv_d, 8, 8, clearq) 1944 1945 #define OPIVX3(NAME, TD, T1, T2, TX1, TX2, HD, HS2, OP) \ 1946 static void do_##NAME(void *vd, target_long s1, void *vs2, int i) \ 1947 { \ 1948 TX2 s2 = *((T2 *)vs2 + HS2(i)); \ 1949 TD d = *((TD *)vd + HD(i)); \ 1950 *((TD *)vd + HD(i)) = OP(s2, (TX1)(T1)s1, d); \ 1951 } 1952 1953 RVVCALL(OPIVX3, vmacc_vx_b, OP_SSS_B, H1, H1, DO_MACC) 1954 RVVCALL(OPIVX3, vmacc_vx_h, OP_SSS_H, H2, H2, DO_MACC) 1955 RVVCALL(OPIVX3, vmacc_vx_w, OP_SSS_W, H4, H4, DO_MACC) 1956 RVVCALL(OPIVX3, vmacc_vx_d, OP_SSS_D, H8, H8, DO_MACC) 1957 RVVCALL(OPIVX3, vnmsac_vx_b, OP_SSS_B, H1, H1, DO_NMSAC) 1958 RVVCALL(OPIVX3, vnmsac_vx_h, OP_SSS_H, H2, H2, DO_NMSAC) 1959 RVVCALL(OPIVX3, vnmsac_vx_w, OP_SSS_W, H4, H4, DO_NMSAC) 1960 RVVCALL(OPIVX3, vnmsac_vx_d, OP_SSS_D, H8, H8, DO_NMSAC) 1961 RVVCALL(OPIVX3, vmadd_vx_b, OP_SSS_B, H1, H1, DO_MADD) 1962 RVVCALL(OPIVX3, vmadd_vx_h, OP_SSS_H, H2, H2, DO_MADD) 1963 RVVCALL(OPIVX3, vmadd_vx_w, OP_SSS_W, H4, H4, DO_MADD) 1964 RVVCALL(OPIVX3, vmadd_vx_d, OP_SSS_D, H8, H8, DO_MADD) 1965 RVVCALL(OPIVX3, vnmsub_vx_b, OP_SSS_B, H1, H1, DO_NMSUB) 1966 RVVCALL(OPIVX3, vnmsub_vx_h, OP_SSS_H, H2, H2, DO_NMSUB) 1967 RVVCALL(OPIVX3, vnmsub_vx_w, OP_SSS_W, H4, H4, DO_NMSUB) 1968 RVVCALL(OPIVX3, vnmsub_vx_d, OP_SSS_D, H8, H8, DO_NMSUB) 1969 GEN_VEXT_VX(vmacc_vx_b, 1, 1, clearb) 1970 GEN_VEXT_VX(vmacc_vx_h, 2, 2, clearh) 1971 GEN_VEXT_VX(vmacc_vx_w, 4, 4, clearl) 1972 GEN_VEXT_VX(vmacc_vx_d, 8, 8, clearq) 1973 GEN_VEXT_VX(vnmsac_vx_b, 1, 1, clearb) 1974 GEN_VEXT_VX(vnmsac_vx_h, 2, 2, clearh) 1975 GEN_VEXT_VX(vnmsac_vx_w, 4, 4, clearl) 1976 GEN_VEXT_VX(vnmsac_vx_d, 8, 8, clearq) 1977 GEN_VEXT_VX(vmadd_vx_b, 1, 1, clearb) 1978 GEN_VEXT_VX(vmadd_vx_h, 2, 2, clearh) 1979 GEN_VEXT_VX(vmadd_vx_w, 4, 4, clearl) 1980 GEN_VEXT_VX(vmadd_vx_d, 8, 8, clearq) 1981 GEN_VEXT_VX(vnmsub_vx_b, 1, 1, clearb) 1982 GEN_VEXT_VX(vnmsub_vx_h, 2, 2, clearh) 1983 GEN_VEXT_VX(vnmsub_vx_w, 4, 4, clearl) 1984 GEN_VEXT_VX(vnmsub_vx_d, 8, 8, clearq) 1985 1986 /* Vector Widening Integer Multiply-Add Instructions */ 1987 RVVCALL(OPIVV3, vwmaccu_vv_b, WOP_UUU_B, H2, H1, H1, DO_MACC) 1988 RVVCALL(OPIVV3, vwmaccu_vv_h, WOP_UUU_H, H4, H2, H2, DO_MACC) 1989 RVVCALL(OPIVV3, vwmaccu_vv_w, WOP_UUU_W, H8, H4, H4, DO_MACC) 1990 RVVCALL(OPIVV3, vwmacc_vv_b, WOP_SSS_B, H2, H1, H1, DO_MACC) 1991 RVVCALL(OPIVV3, vwmacc_vv_h, WOP_SSS_H, H4, H2, H2, DO_MACC) 1992 RVVCALL(OPIVV3, vwmacc_vv_w, WOP_SSS_W, H8, H4, H4, DO_MACC) 1993 RVVCALL(OPIVV3, vwmaccsu_vv_b, WOP_SSU_B, H2, H1, H1, DO_MACC) 1994 RVVCALL(OPIVV3, vwmaccsu_vv_h, WOP_SSU_H, H4, H2, H2, DO_MACC) 1995 RVVCALL(OPIVV3, vwmaccsu_vv_w, WOP_SSU_W, H8, H4, H4, DO_MACC) 1996 GEN_VEXT_VV(vwmaccu_vv_b, 1, 2, clearh) 1997 GEN_VEXT_VV(vwmaccu_vv_h, 2, 4, clearl) 1998 GEN_VEXT_VV(vwmaccu_vv_w, 4, 8, clearq) 1999 GEN_VEXT_VV(vwmacc_vv_b, 1, 2, clearh) 2000 GEN_VEXT_VV(vwmacc_vv_h, 2, 4, clearl) 2001 GEN_VEXT_VV(vwmacc_vv_w, 4, 8, clearq) 2002 GEN_VEXT_VV(vwmaccsu_vv_b, 1, 2, clearh) 2003 GEN_VEXT_VV(vwmaccsu_vv_h, 2, 4, clearl) 2004 GEN_VEXT_VV(vwmaccsu_vv_w, 4, 8, clearq) 2005 2006 RVVCALL(OPIVX3, vwmaccu_vx_b, WOP_UUU_B, H2, H1, DO_MACC) 2007 RVVCALL(OPIVX3, vwmaccu_vx_h, WOP_UUU_H, H4, H2, DO_MACC) 2008 RVVCALL(OPIVX3, vwmaccu_vx_w, WOP_UUU_W, H8, H4, DO_MACC) 2009 RVVCALL(OPIVX3, vwmacc_vx_b, WOP_SSS_B, H2, H1, DO_MACC) 2010 RVVCALL(OPIVX3, vwmacc_vx_h, WOP_SSS_H, H4, H2, DO_MACC) 2011 RVVCALL(OPIVX3, vwmacc_vx_w, WOP_SSS_W, H8, H4, DO_MACC) 2012 RVVCALL(OPIVX3, vwmaccsu_vx_b, WOP_SSU_B, H2, H1, DO_MACC) 2013 RVVCALL(OPIVX3, vwmaccsu_vx_h, WOP_SSU_H, H4, H2, DO_MACC) 2014 RVVCALL(OPIVX3, vwmaccsu_vx_w, WOP_SSU_W, H8, H4, DO_MACC) 2015 RVVCALL(OPIVX3, vwmaccus_vx_b, WOP_SUS_B, H2, H1, DO_MACC) 2016 RVVCALL(OPIVX3, vwmaccus_vx_h, WOP_SUS_H, H4, H2, DO_MACC) 2017 RVVCALL(OPIVX3, vwmaccus_vx_w, WOP_SUS_W, H8, H4, DO_MACC) 2018 GEN_VEXT_VX(vwmaccu_vx_b, 1, 2, clearh) 2019 GEN_VEXT_VX(vwmaccu_vx_h, 2, 4, clearl) 2020 GEN_VEXT_VX(vwmaccu_vx_w, 4, 8, clearq) 2021 GEN_VEXT_VX(vwmacc_vx_b, 1, 2, clearh) 2022 GEN_VEXT_VX(vwmacc_vx_h, 2, 4, clearl) 2023 GEN_VEXT_VX(vwmacc_vx_w, 4, 8, clearq) 2024 GEN_VEXT_VX(vwmaccsu_vx_b, 1, 2, clearh) 2025 GEN_VEXT_VX(vwmaccsu_vx_h, 2, 4, clearl) 2026 GEN_VEXT_VX(vwmaccsu_vx_w, 4, 8, clearq) 2027 GEN_VEXT_VX(vwmaccus_vx_b, 1, 2, clearh) 2028 GEN_VEXT_VX(vwmaccus_vx_h, 2, 4, clearl) 2029 GEN_VEXT_VX(vwmaccus_vx_w, 4, 8, clearq) 2030 2031 /* Vector Integer Merge and Move Instructions */ 2032 #define GEN_VEXT_VMV_VV(NAME, ETYPE, H, CLEAR_FN) \ 2033 void HELPER(NAME)(void *vd, void *vs1, CPURISCVState *env, \ 2034 uint32_t desc) \ 2035 { \ 2036 uint32_t vl = env->vl; \ 2037 uint32_t esz = sizeof(ETYPE); \ 2038 uint32_t vlmax = vext_maxsz(desc) / esz; \ 2039 uint32_t i; \ 2040 \ 2041 for (i = 0; i < vl; i++) { \ 2042 ETYPE s1 = *((ETYPE *)vs1 + H(i)); \ 2043 *((ETYPE *)vd + H(i)) = s1; \ 2044 } \ 2045 CLEAR_FN(vd, vl, vl * esz, vlmax * esz); \ 2046 } 2047 2048 GEN_VEXT_VMV_VV(vmv_v_v_b, int8_t, H1, clearb) 2049 GEN_VEXT_VMV_VV(vmv_v_v_h, int16_t, H2, clearh) 2050 GEN_VEXT_VMV_VV(vmv_v_v_w, int32_t, H4, clearl) 2051 GEN_VEXT_VMV_VV(vmv_v_v_d, int64_t, H8, clearq) 2052 2053 #define GEN_VEXT_VMV_VX(NAME, ETYPE, H, CLEAR_FN) \ 2054 void HELPER(NAME)(void *vd, uint64_t s1, CPURISCVState *env, \ 2055 uint32_t desc) \ 2056 { \ 2057 uint32_t vl = env->vl; \ 2058 uint32_t esz = sizeof(ETYPE); \ 2059 uint32_t vlmax = vext_maxsz(desc) / esz; \ 2060 uint32_t i; \ 2061 \ 2062 for (i = 0; i < vl; i++) { \ 2063 *((ETYPE *)vd + H(i)) = (ETYPE)s1; \ 2064 } \ 2065 CLEAR_FN(vd, vl, vl * esz, vlmax * esz); \ 2066 } 2067 2068 GEN_VEXT_VMV_VX(vmv_v_x_b, int8_t, H1, clearb) 2069 GEN_VEXT_VMV_VX(vmv_v_x_h, int16_t, H2, clearh) 2070 GEN_VEXT_VMV_VX(vmv_v_x_w, int32_t, H4, clearl) 2071 GEN_VEXT_VMV_VX(vmv_v_x_d, int64_t, H8, clearq) 2072 2073 #define GEN_VEXT_VMERGE_VV(NAME, ETYPE, H, CLEAR_FN) \ 2074 void HELPER(NAME)(void *vd, void *v0, void *vs1, void *vs2, \ 2075 CPURISCVState *env, uint32_t desc) \ 2076 { \ 2077 uint32_t mlen = vext_mlen(desc); \ 2078 uint32_t vl = env->vl; \ 2079 uint32_t esz = sizeof(ETYPE); \ 2080 uint32_t vlmax = vext_maxsz(desc) / esz; \ 2081 uint32_t i; \ 2082 \ 2083 for (i = 0; i < vl; i++) { \ 2084 ETYPE *vt = (!vext_elem_mask(v0, mlen, i) ? vs2 : vs1); \ 2085 *((ETYPE *)vd + H(i)) = *(vt + H(i)); \ 2086 } \ 2087 CLEAR_FN(vd, vl, vl * esz, vlmax * esz); \ 2088 } 2089 2090 GEN_VEXT_VMERGE_VV(vmerge_vvm_b, int8_t, H1, clearb) 2091 GEN_VEXT_VMERGE_VV(vmerge_vvm_h, int16_t, H2, clearh) 2092 GEN_VEXT_VMERGE_VV(vmerge_vvm_w, int32_t, H4, clearl) 2093 GEN_VEXT_VMERGE_VV(vmerge_vvm_d, int64_t, H8, clearq) 2094 2095 #define GEN_VEXT_VMERGE_VX(NAME, ETYPE, H, CLEAR_FN) \ 2096 void HELPER(NAME)(void *vd, void *v0, target_ulong s1, \ 2097 void *vs2, CPURISCVState *env, uint32_t desc) \ 2098 { \ 2099 uint32_t mlen = vext_mlen(desc); \ 2100 uint32_t vl = env->vl; \ 2101 uint32_t esz = sizeof(ETYPE); \ 2102 uint32_t vlmax = vext_maxsz(desc) / esz; \ 2103 uint32_t i; \ 2104 \ 2105 for (i = 0; i < vl; i++) { \ 2106 ETYPE s2 = *((ETYPE *)vs2 + H(i)); \ 2107 ETYPE d = (!vext_elem_mask(v0, mlen, i) ? s2 : \ 2108 (ETYPE)(target_long)s1); \ 2109 *((ETYPE *)vd + H(i)) = d; \ 2110 } \ 2111 CLEAR_FN(vd, vl, vl * esz, vlmax * esz); \ 2112 } 2113 2114 GEN_VEXT_VMERGE_VX(vmerge_vxm_b, int8_t, H1, clearb) 2115 GEN_VEXT_VMERGE_VX(vmerge_vxm_h, int16_t, H2, clearh) 2116 GEN_VEXT_VMERGE_VX(vmerge_vxm_w, int32_t, H4, clearl) 2117 GEN_VEXT_VMERGE_VX(vmerge_vxm_d, int64_t, H8, clearq) 2118 2119 /* 2120 *** Vector Fixed-Point Arithmetic Instructions 2121 */ 2122 2123 /* Vector Single-Width Saturating Add and Subtract */ 2124 2125 /* 2126 * As fixed point instructions probably have round mode and saturation, 2127 * define common macros for fixed point here. 2128 */ 2129 typedef void opivv2_rm_fn(void *vd, void *vs1, void *vs2, int i, 2130 CPURISCVState *env, int vxrm); 2131 2132 #define OPIVV2_RM(NAME, TD, T1, T2, TX1, TX2, HD, HS1, HS2, OP) \ 2133 static inline void \ 2134 do_##NAME(void *vd, void *vs1, void *vs2, int i, \ 2135 CPURISCVState *env, int vxrm) \ 2136 { \ 2137 TX1 s1 = *((T1 *)vs1 + HS1(i)); \ 2138 TX2 s2 = *((T2 *)vs2 + HS2(i)); \ 2139 *((TD *)vd + HD(i)) = OP(env, vxrm, s2, s1); \ 2140 } 2141 2142 static inline void 2143 vext_vv_rm_1(void *vd, void *v0, void *vs1, void *vs2, 2144 CPURISCVState *env, 2145 uint32_t vl, uint32_t vm, uint32_t mlen, int vxrm, 2146 opivv2_rm_fn *fn) 2147 { 2148 for (uint32_t i = 0; i < vl; i++) { 2149 if (!vm && !vext_elem_mask(v0, mlen, i)) { 2150 continue; 2151 } 2152 fn(vd, vs1, vs2, i, env, vxrm); 2153 } 2154 } 2155 2156 static inline void 2157 vext_vv_rm_2(void *vd, void *v0, void *vs1, void *vs2, 2158 CPURISCVState *env, 2159 uint32_t desc, uint32_t esz, uint32_t dsz, 2160 opivv2_rm_fn *fn, clear_fn *clearfn) 2161 { 2162 uint32_t vlmax = vext_maxsz(desc) / esz; 2163 uint32_t mlen = vext_mlen(desc); 2164 uint32_t vm = vext_vm(desc); 2165 uint32_t vl = env->vl; 2166 2167 switch (env->vxrm) { 2168 case 0: /* rnu */ 2169 vext_vv_rm_1(vd, v0, vs1, vs2, 2170 env, vl, vm, mlen, 0, fn); 2171 break; 2172 case 1: /* rne */ 2173 vext_vv_rm_1(vd, v0, vs1, vs2, 2174 env, vl, vm, mlen, 1, fn); 2175 break; 2176 case 2: /* rdn */ 2177 vext_vv_rm_1(vd, v0, vs1, vs2, 2178 env, vl, vm, mlen, 2, fn); 2179 break; 2180 default: /* rod */ 2181 vext_vv_rm_1(vd, v0, vs1, vs2, 2182 env, vl, vm, mlen, 3, fn); 2183 break; 2184 } 2185 2186 clearfn(vd, vl, vl * dsz, vlmax * dsz); 2187 } 2188 2189 /* generate helpers for fixed point instructions with OPIVV format */ 2190 #define GEN_VEXT_VV_RM(NAME, ESZ, DSZ, CLEAR_FN) \ 2191 void HELPER(NAME)(void *vd, void *v0, void *vs1, void *vs2, \ 2192 CPURISCVState *env, uint32_t desc) \ 2193 { \ 2194 vext_vv_rm_2(vd, v0, vs1, vs2, env, desc, ESZ, DSZ, \ 2195 do_##NAME, CLEAR_FN); \ 2196 } 2197 2198 static inline uint8_t saddu8(CPURISCVState *env, int vxrm, uint8_t a, uint8_t b) 2199 { 2200 uint8_t res = a + b; 2201 if (res < a) { 2202 res = UINT8_MAX; 2203 env->vxsat = 0x1; 2204 } 2205 return res; 2206 } 2207 2208 static inline uint16_t saddu16(CPURISCVState *env, int vxrm, uint16_t a, 2209 uint16_t b) 2210 { 2211 uint16_t res = a + b; 2212 if (res < a) { 2213 res = UINT16_MAX; 2214 env->vxsat = 0x1; 2215 } 2216 return res; 2217 } 2218 2219 static inline uint32_t saddu32(CPURISCVState *env, int vxrm, uint32_t a, 2220 uint32_t b) 2221 { 2222 uint32_t res = a + b; 2223 if (res < a) { 2224 res = UINT32_MAX; 2225 env->vxsat = 0x1; 2226 } 2227 return res; 2228 } 2229 2230 static inline uint64_t saddu64(CPURISCVState *env, int vxrm, uint64_t a, 2231 uint64_t b) 2232 { 2233 uint64_t res = a + b; 2234 if (res < a) { 2235 res = UINT64_MAX; 2236 env->vxsat = 0x1; 2237 } 2238 return res; 2239 } 2240 2241 RVVCALL(OPIVV2_RM, vsaddu_vv_b, OP_UUU_B, H1, H1, H1, saddu8) 2242 RVVCALL(OPIVV2_RM, vsaddu_vv_h, OP_UUU_H, H2, H2, H2, saddu16) 2243 RVVCALL(OPIVV2_RM, vsaddu_vv_w, OP_UUU_W, H4, H4, H4, saddu32) 2244 RVVCALL(OPIVV2_RM, vsaddu_vv_d, OP_UUU_D, H8, H8, H8, saddu64) 2245 GEN_VEXT_VV_RM(vsaddu_vv_b, 1, 1, clearb) 2246 GEN_VEXT_VV_RM(vsaddu_vv_h, 2, 2, clearh) 2247 GEN_VEXT_VV_RM(vsaddu_vv_w, 4, 4, clearl) 2248 GEN_VEXT_VV_RM(vsaddu_vv_d, 8, 8, clearq) 2249 2250 typedef void opivx2_rm_fn(void *vd, target_long s1, void *vs2, int i, 2251 CPURISCVState *env, int vxrm); 2252 2253 #define OPIVX2_RM(NAME, TD, T1, T2, TX1, TX2, HD, HS2, OP) \ 2254 static inline void \ 2255 do_##NAME(void *vd, target_long s1, void *vs2, int i, \ 2256 CPURISCVState *env, int vxrm) \ 2257 { \ 2258 TX2 s2 = *((T2 *)vs2 + HS2(i)); \ 2259 *((TD *)vd + HD(i)) = OP(env, vxrm, s2, (TX1)(T1)s1); \ 2260 } 2261 2262 static inline void 2263 vext_vx_rm_1(void *vd, void *v0, target_long s1, void *vs2, 2264 CPURISCVState *env, 2265 uint32_t vl, uint32_t vm, uint32_t mlen, int vxrm, 2266 opivx2_rm_fn *fn) 2267 { 2268 for (uint32_t i = 0; i < vl; i++) { 2269 if (!vm && !vext_elem_mask(v0, mlen, i)) { 2270 continue; 2271 } 2272 fn(vd, s1, vs2, i, env, vxrm); 2273 } 2274 } 2275 2276 static inline void 2277 vext_vx_rm_2(void *vd, void *v0, target_long s1, void *vs2, 2278 CPURISCVState *env, 2279 uint32_t desc, uint32_t esz, uint32_t dsz, 2280 opivx2_rm_fn *fn, clear_fn *clearfn) 2281 { 2282 uint32_t vlmax = vext_maxsz(desc) / esz; 2283 uint32_t mlen = vext_mlen(desc); 2284 uint32_t vm = vext_vm(desc); 2285 uint32_t vl = env->vl; 2286 2287 switch (env->vxrm) { 2288 case 0: /* rnu */ 2289 vext_vx_rm_1(vd, v0, s1, vs2, 2290 env, vl, vm, mlen, 0, fn); 2291 break; 2292 case 1: /* rne */ 2293 vext_vx_rm_1(vd, v0, s1, vs2, 2294 env, vl, vm, mlen, 1, fn); 2295 break; 2296 case 2: /* rdn */ 2297 vext_vx_rm_1(vd, v0, s1, vs2, 2298 env, vl, vm, mlen, 2, fn); 2299 break; 2300 default: /* rod */ 2301 vext_vx_rm_1(vd, v0, s1, vs2, 2302 env, vl, vm, mlen, 3, fn); 2303 break; 2304 } 2305 2306 clearfn(vd, vl, vl * dsz, vlmax * dsz); 2307 } 2308 2309 /* generate helpers for fixed point instructions with OPIVX format */ 2310 #define GEN_VEXT_VX_RM(NAME, ESZ, DSZ, CLEAR_FN) \ 2311 void HELPER(NAME)(void *vd, void *v0, target_ulong s1, \ 2312 void *vs2, CPURISCVState *env, uint32_t desc) \ 2313 { \ 2314 vext_vx_rm_2(vd, v0, s1, vs2, env, desc, ESZ, DSZ, \ 2315 do_##NAME, CLEAR_FN); \ 2316 } 2317 2318 RVVCALL(OPIVX2_RM, vsaddu_vx_b, OP_UUU_B, H1, H1, saddu8) 2319 RVVCALL(OPIVX2_RM, vsaddu_vx_h, OP_UUU_H, H2, H2, saddu16) 2320 RVVCALL(OPIVX2_RM, vsaddu_vx_w, OP_UUU_W, H4, H4, saddu32) 2321 RVVCALL(OPIVX2_RM, vsaddu_vx_d, OP_UUU_D, H8, H8, saddu64) 2322 GEN_VEXT_VX_RM(vsaddu_vx_b, 1, 1, clearb) 2323 GEN_VEXT_VX_RM(vsaddu_vx_h, 2, 2, clearh) 2324 GEN_VEXT_VX_RM(vsaddu_vx_w, 4, 4, clearl) 2325 GEN_VEXT_VX_RM(vsaddu_vx_d, 8, 8, clearq) 2326 2327 static inline int8_t sadd8(CPURISCVState *env, int vxrm, int8_t a, int8_t b) 2328 { 2329 int8_t res = a + b; 2330 if ((res ^ a) & (res ^ b) & INT8_MIN) { 2331 res = a > 0 ? INT8_MAX : INT8_MIN; 2332 env->vxsat = 0x1; 2333 } 2334 return res; 2335 } 2336 2337 static inline int16_t sadd16(CPURISCVState *env, int vxrm, int16_t a, int16_t b) 2338 { 2339 int16_t res = a + b; 2340 if ((res ^ a) & (res ^ b) & INT16_MIN) { 2341 res = a > 0 ? INT16_MAX : INT16_MIN; 2342 env->vxsat = 0x1; 2343 } 2344 return res; 2345 } 2346 2347 static inline int32_t sadd32(CPURISCVState *env, int vxrm, int32_t a, int32_t b) 2348 { 2349 int32_t res = a + b; 2350 if ((res ^ a) & (res ^ b) & INT32_MIN) { 2351 res = a > 0 ? INT32_MAX : INT32_MIN; 2352 env->vxsat = 0x1; 2353 } 2354 return res; 2355 } 2356 2357 static inline int64_t sadd64(CPURISCVState *env, int vxrm, int64_t a, int64_t b) 2358 { 2359 int64_t res = a + b; 2360 if ((res ^ a) & (res ^ b) & INT64_MIN) { 2361 res = a > 0 ? INT64_MAX : INT64_MIN; 2362 env->vxsat = 0x1; 2363 } 2364 return res; 2365 } 2366 2367 RVVCALL(OPIVV2_RM, vsadd_vv_b, OP_SSS_B, H1, H1, H1, sadd8) 2368 RVVCALL(OPIVV2_RM, vsadd_vv_h, OP_SSS_H, H2, H2, H2, sadd16) 2369 RVVCALL(OPIVV2_RM, vsadd_vv_w, OP_SSS_W, H4, H4, H4, sadd32) 2370 RVVCALL(OPIVV2_RM, vsadd_vv_d, OP_SSS_D, H8, H8, H8, sadd64) 2371 GEN_VEXT_VV_RM(vsadd_vv_b, 1, 1, clearb) 2372 GEN_VEXT_VV_RM(vsadd_vv_h, 2, 2, clearh) 2373 GEN_VEXT_VV_RM(vsadd_vv_w, 4, 4, clearl) 2374 GEN_VEXT_VV_RM(vsadd_vv_d, 8, 8, clearq) 2375 2376 RVVCALL(OPIVX2_RM, vsadd_vx_b, OP_SSS_B, H1, H1, sadd8) 2377 RVVCALL(OPIVX2_RM, vsadd_vx_h, OP_SSS_H, H2, H2, sadd16) 2378 RVVCALL(OPIVX2_RM, vsadd_vx_w, OP_SSS_W, H4, H4, sadd32) 2379 RVVCALL(OPIVX2_RM, vsadd_vx_d, OP_SSS_D, H8, H8, sadd64) 2380 GEN_VEXT_VX_RM(vsadd_vx_b, 1, 1, clearb) 2381 GEN_VEXT_VX_RM(vsadd_vx_h, 2, 2, clearh) 2382 GEN_VEXT_VX_RM(vsadd_vx_w, 4, 4, clearl) 2383 GEN_VEXT_VX_RM(vsadd_vx_d, 8, 8, clearq) 2384 2385 static inline uint8_t ssubu8(CPURISCVState *env, int vxrm, uint8_t a, uint8_t b) 2386 { 2387 uint8_t res = a - b; 2388 if (res > a) { 2389 res = 0; 2390 env->vxsat = 0x1; 2391 } 2392 return res; 2393 } 2394 2395 static inline uint16_t ssubu16(CPURISCVState *env, int vxrm, uint16_t a, 2396 uint16_t b) 2397 { 2398 uint16_t res = a - b; 2399 if (res > a) { 2400 res = 0; 2401 env->vxsat = 0x1; 2402 } 2403 return res; 2404 } 2405 2406 static inline uint32_t ssubu32(CPURISCVState *env, int vxrm, uint32_t a, 2407 uint32_t b) 2408 { 2409 uint32_t res = a - b; 2410 if (res > a) { 2411 res = 0; 2412 env->vxsat = 0x1; 2413 } 2414 return res; 2415 } 2416 2417 static inline uint64_t ssubu64(CPURISCVState *env, int vxrm, uint64_t a, 2418 uint64_t b) 2419 { 2420 uint64_t res = a - b; 2421 if (res > a) { 2422 res = 0; 2423 env->vxsat = 0x1; 2424 } 2425 return res; 2426 } 2427 2428 RVVCALL(OPIVV2_RM, vssubu_vv_b, OP_UUU_B, H1, H1, H1, ssubu8) 2429 RVVCALL(OPIVV2_RM, vssubu_vv_h, OP_UUU_H, H2, H2, H2, ssubu16) 2430 RVVCALL(OPIVV2_RM, vssubu_vv_w, OP_UUU_W, H4, H4, H4, ssubu32) 2431 RVVCALL(OPIVV2_RM, vssubu_vv_d, OP_UUU_D, H8, H8, H8, ssubu64) 2432 GEN_VEXT_VV_RM(vssubu_vv_b, 1, 1, clearb) 2433 GEN_VEXT_VV_RM(vssubu_vv_h, 2, 2, clearh) 2434 GEN_VEXT_VV_RM(vssubu_vv_w, 4, 4, clearl) 2435 GEN_VEXT_VV_RM(vssubu_vv_d, 8, 8, clearq) 2436 2437 RVVCALL(OPIVX2_RM, vssubu_vx_b, OP_UUU_B, H1, H1, ssubu8) 2438 RVVCALL(OPIVX2_RM, vssubu_vx_h, OP_UUU_H, H2, H2, ssubu16) 2439 RVVCALL(OPIVX2_RM, vssubu_vx_w, OP_UUU_W, H4, H4, ssubu32) 2440 RVVCALL(OPIVX2_RM, vssubu_vx_d, OP_UUU_D, H8, H8, ssubu64) 2441 GEN_VEXT_VX_RM(vssubu_vx_b, 1, 1, clearb) 2442 GEN_VEXT_VX_RM(vssubu_vx_h, 2, 2, clearh) 2443 GEN_VEXT_VX_RM(vssubu_vx_w, 4, 4, clearl) 2444 GEN_VEXT_VX_RM(vssubu_vx_d, 8, 8, clearq) 2445 2446 static inline int8_t ssub8(CPURISCVState *env, int vxrm, int8_t a, int8_t b) 2447 { 2448 int8_t res = a - b; 2449 if ((res ^ a) & (a ^ b) & INT8_MIN) { 2450 res = a >= 0 ? INT8_MAX : INT8_MIN; 2451 env->vxsat = 0x1; 2452 } 2453 return res; 2454 } 2455 2456 static inline int16_t ssub16(CPURISCVState *env, int vxrm, int16_t a, int16_t b) 2457 { 2458 int16_t res = a - b; 2459 if ((res ^ a) & (a ^ b) & INT16_MIN) { 2460 res = a >= 0 ? INT16_MAX : INT16_MIN; 2461 env->vxsat = 0x1; 2462 } 2463 return res; 2464 } 2465 2466 static inline int32_t ssub32(CPURISCVState *env, int vxrm, int32_t a, int32_t b) 2467 { 2468 int32_t res = a - b; 2469 if ((res ^ a) & (a ^ b) & INT32_MIN) { 2470 res = a >= 0 ? INT32_MAX : INT32_MIN; 2471 env->vxsat = 0x1; 2472 } 2473 return res; 2474 } 2475 2476 static inline int64_t ssub64(CPURISCVState *env, int vxrm, int64_t a, int64_t b) 2477 { 2478 int64_t res = a - b; 2479 if ((res ^ a) & (a ^ b) & INT64_MIN) { 2480 res = a >= 0 ? INT64_MAX : INT64_MIN; 2481 env->vxsat = 0x1; 2482 } 2483 return res; 2484 } 2485 2486 RVVCALL(OPIVV2_RM, vssub_vv_b, OP_SSS_B, H1, H1, H1, ssub8) 2487 RVVCALL(OPIVV2_RM, vssub_vv_h, OP_SSS_H, H2, H2, H2, ssub16) 2488 RVVCALL(OPIVV2_RM, vssub_vv_w, OP_SSS_W, H4, H4, H4, ssub32) 2489 RVVCALL(OPIVV2_RM, vssub_vv_d, OP_SSS_D, H8, H8, H8, ssub64) 2490 GEN_VEXT_VV_RM(vssub_vv_b, 1, 1, clearb) 2491 GEN_VEXT_VV_RM(vssub_vv_h, 2, 2, clearh) 2492 GEN_VEXT_VV_RM(vssub_vv_w, 4, 4, clearl) 2493 GEN_VEXT_VV_RM(vssub_vv_d, 8, 8, clearq) 2494 2495 RVVCALL(OPIVX2_RM, vssub_vx_b, OP_SSS_B, H1, H1, ssub8) 2496 RVVCALL(OPIVX2_RM, vssub_vx_h, OP_SSS_H, H2, H2, ssub16) 2497 RVVCALL(OPIVX2_RM, vssub_vx_w, OP_SSS_W, H4, H4, ssub32) 2498 RVVCALL(OPIVX2_RM, vssub_vx_d, OP_SSS_D, H8, H8, ssub64) 2499 GEN_VEXT_VX_RM(vssub_vx_b, 1, 1, clearb) 2500 GEN_VEXT_VX_RM(vssub_vx_h, 2, 2, clearh) 2501 GEN_VEXT_VX_RM(vssub_vx_w, 4, 4, clearl) 2502 GEN_VEXT_VX_RM(vssub_vx_d, 8, 8, clearq) 2503 2504 /* Vector Single-Width Averaging Add and Subtract */ 2505 static inline uint8_t get_round(int vxrm, uint64_t v, uint8_t shift) 2506 { 2507 uint8_t d = extract64(v, shift, 1); 2508 uint8_t d1; 2509 uint64_t D1, D2; 2510 2511 if (shift == 0 || shift > 64) { 2512 return 0; 2513 } 2514 2515 d1 = extract64(v, shift - 1, 1); 2516 D1 = extract64(v, 0, shift); 2517 if (vxrm == 0) { /* round-to-nearest-up (add +0.5 LSB) */ 2518 return d1; 2519 } else if (vxrm == 1) { /* round-to-nearest-even */ 2520 if (shift > 1) { 2521 D2 = extract64(v, 0, shift - 1); 2522 return d1 & ((D2 != 0) | d); 2523 } else { 2524 return d1 & d; 2525 } 2526 } else if (vxrm == 3) { /* round-to-odd (OR bits into LSB, aka "jam") */ 2527 return !d & (D1 != 0); 2528 } 2529 return 0; /* round-down (truncate) */ 2530 } 2531 2532 static inline int32_t aadd32(CPURISCVState *env, int vxrm, int32_t a, int32_t b) 2533 { 2534 int64_t res = (int64_t)a + b; 2535 uint8_t round = get_round(vxrm, res, 1); 2536 2537 return (res >> 1) + round; 2538 } 2539 2540 static inline int64_t aadd64(CPURISCVState *env, int vxrm, int64_t a, int64_t b) 2541 { 2542 int64_t res = a + b; 2543 uint8_t round = get_round(vxrm, res, 1); 2544 int64_t over = (res ^ a) & (res ^ b) & INT64_MIN; 2545 2546 /* With signed overflow, bit 64 is inverse of bit 63. */ 2547 return ((res >> 1) ^ over) + round; 2548 } 2549 2550 RVVCALL(OPIVV2_RM, vaadd_vv_b, OP_SSS_B, H1, H1, H1, aadd32) 2551 RVVCALL(OPIVV2_RM, vaadd_vv_h, OP_SSS_H, H2, H2, H2, aadd32) 2552 RVVCALL(OPIVV2_RM, vaadd_vv_w, OP_SSS_W, H4, H4, H4, aadd32) 2553 RVVCALL(OPIVV2_RM, vaadd_vv_d, OP_SSS_D, H8, H8, H8, aadd64) 2554 GEN_VEXT_VV_RM(vaadd_vv_b, 1, 1, clearb) 2555 GEN_VEXT_VV_RM(vaadd_vv_h, 2, 2, clearh) 2556 GEN_VEXT_VV_RM(vaadd_vv_w, 4, 4, clearl) 2557 GEN_VEXT_VV_RM(vaadd_vv_d, 8, 8, clearq) 2558 2559 RVVCALL(OPIVX2_RM, vaadd_vx_b, OP_SSS_B, H1, H1, aadd32) 2560 RVVCALL(OPIVX2_RM, vaadd_vx_h, OP_SSS_H, H2, H2, aadd32) 2561 RVVCALL(OPIVX2_RM, vaadd_vx_w, OP_SSS_W, H4, H4, aadd32) 2562 RVVCALL(OPIVX2_RM, vaadd_vx_d, OP_SSS_D, H8, H8, aadd64) 2563 GEN_VEXT_VX_RM(vaadd_vx_b, 1, 1, clearb) 2564 GEN_VEXT_VX_RM(vaadd_vx_h, 2, 2, clearh) 2565 GEN_VEXT_VX_RM(vaadd_vx_w, 4, 4, clearl) 2566 GEN_VEXT_VX_RM(vaadd_vx_d, 8, 8, clearq) 2567 2568 static inline int32_t asub32(CPURISCVState *env, int vxrm, int32_t a, int32_t b) 2569 { 2570 int64_t res = (int64_t)a - b; 2571 uint8_t round = get_round(vxrm, res, 1); 2572 2573 return (res >> 1) + round; 2574 } 2575 2576 static inline int64_t asub64(CPURISCVState *env, int vxrm, int64_t a, int64_t b) 2577 { 2578 int64_t res = (int64_t)a - b; 2579 uint8_t round = get_round(vxrm, res, 1); 2580 int64_t over = (res ^ a) & (a ^ b) & INT64_MIN; 2581 2582 /* With signed overflow, bit 64 is inverse of bit 63. */ 2583 return ((res >> 1) ^ over) + round; 2584 } 2585 2586 RVVCALL(OPIVV2_RM, vasub_vv_b, OP_SSS_B, H1, H1, H1, asub32) 2587 RVVCALL(OPIVV2_RM, vasub_vv_h, OP_SSS_H, H2, H2, H2, asub32) 2588 RVVCALL(OPIVV2_RM, vasub_vv_w, OP_SSS_W, H4, H4, H4, asub32) 2589 RVVCALL(OPIVV2_RM, vasub_vv_d, OP_SSS_D, H8, H8, H8, asub64) 2590 GEN_VEXT_VV_RM(vasub_vv_b, 1, 1, clearb) 2591 GEN_VEXT_VV_RM(vasub_vv_h, 2, 2, clearh) 2592 GEN_VEXT_VV_RM(vasub_vv_w, 4, 4, clearl) 2593 GEN_VEXT_VV_RM(vasub_vv_d, 8, 8, clearq) 2594 2595 RVVCALL(OPIVX2_RM, vasub_vx_b, OP_SSS_B, H1, H1, asub32) 2596 RVVCALL(OPIVX2_RM, vasub_vx_h, OP_SSS_H, H2, H2, asub32) 2597 RVVCALL(OPIVX2_RM, vasub_vx_w, OP_SSS_W, H4, H4, asub32) 2598 RVVCALL(OPIVX2_RM, vasub_vx_d, OP_SSS_D, H8, H8, asub64) 2599 GEN_VEXT_VX_RM(vasub_vx_b, 1, 1, clearb) 2600 GEN_VEXT_VX_RM(vasub_vx_h, 2, 2, clearh) 2601 GEN_VEXT_VX_RM(vasub_vx_w, 4, 4, clearl) 2602 GEN_VEXT_VX_RM(vasub_vx_d, 8, 8, clearq) 2603 2604 /* Vector Single-Width Fractional Multiply with Rounding and Saturation */ 2605 static inline int8_t vsmul8(CPURISCVState *env, int vxrm, int8_t a, int8_t b) 2606 { 2607 uint8_t round; 2608 int16_t res; 2609 2610 res = (int16_t)a * (int16_t)b; 2611 round = get_round(vxrm, res, 7); 2612 res = (res >> 7) + round; 2613 2614 if (res > INT8_MAX) { 2615 env->vxsat = 0x1; 2616 return INT8_MAX; 2617 } else if (res < INT8_MIN) { 2618 env->vxsat = 0x1; 2619 return INT8_MIN; 2620 } else { 2621 return res; 2622 } 2623 } 2624 2625 static int16_t vsmul16(CPURISCVState *env, int vxrm, int16_t a, int16_t b) 2626 { 2627 uint8_t round; 2628 int32_t res; 2629 2630 res = (int32_t)a * (int32_t)b; 2631 round = get_round(vxrm, res, 15); 2632 res = (res >> 15) + round; 2633 2634 if (res > INT16_MAX) { 2635 env->vxsat = 0x1; 2636 return INT16_MAX; 2637 } else if (res < INT16_MIN) { 2638 env->vxsat = 0x1; 2639 return INT16_MIN; 2640 } else { 2641 return res; 2642 } 2643 } 2644 2645 static int32_t vsmul32(CPURISCVState *env, int vxrm, int32_t a, int32_t b) 2646 { 2647 uint8_t round; 2648 int64_t res; 2649 2650 res = (int64_t)a * (int64_t)b; 2651 round = get_round(vxrm, res, 31); 2652 res = (res >> 31) + round; 2653 2654 if (res > INT32_MAX) { 2655 env->vxsat = 0x1; 2656 return INT32_MAX; 2657 } else if (res < INT32_MIN) { 2658 env->vxsat = 0x1; 2659 return INT32_MIN; 2660 } else { 2661 return res; 2662 } 2663 } 2664 2665 static int64_t vsmul64(CPURISCVState *env, int vxrm, int64_t a, int64_t b) 2666 { 2667 uint8_t round; 2668 uint64_t hi_64, lo_64; 2669 int64_t res; 2670 2671 if (a == INT64_MIN && b == INT64_MIN) { 2672 env->vxsat = 1; 2673 return INT64_MAX; 2674 } 2675 2676 muls64(&lo_64, &hi_64, a, b); 2677 round = get_round(vxrm, lo_64, 63); 2678 /* 2679 * Cannot overflow, as there are always 2680 * 2 sign bits after multiply. 2681 */ 2682 res = (hi_64 << 1) | (lo_64 >> 63); 2683 if (round) { 2684 if (res == INT64_MAX) { 2685 env->vxsat = 1; 2686 } else { 2687 res += 1; 2688 } 2689 } 2690 return res; 2691 } 2692 2693 RVVCALL(OPIVV2_RM, vsmul_vv_b, OP_SSS_B, H1, H1, H1, vsmul8) 2694 RVVCALL(OPIVV2_RM, vsmul_vv_h, OP_SSS_H, H2, H2, H2, vsmul16) 2695 RVVCALL(OPIVV2_RM, vsmul_vv_w, OP_SSS_W, H4, H4, H4, vsmul32) 2696 RVVCALL(OPIVV2_RM, vsmul_vv_d, OP_SSS_D, H8, H8, H8, vsmul64) 2697 GEN_VEXT_VV_RM(vsmul_vv_b, 1, 1, clearb) 2698 GEN_VEXT_VV_RM(vsmul_vv_h, 2, 2, clearh) 2699 GEN_VEXT_VV_RM(vsmul_vv_w, 4, 4, clearl) 2700 GEN_VEXT_VV_RM(vsmul_vv_d, 8, 8, clearq) 2701 2702 RVVCALL(OPIVX2_RM, vsmul_vx_b, OP_SSS_B, H1, H1, vsmul8) 2703 RVVCALL(OPIVX2_RM, vsmul_vx_h, OP_SSS_H, H2, H2, vsmul16) 2704 RVVCALL(OPIVX2_RM, vsmul_vx_w, OP_SSS_W, H4, H4, vsmul32) 2705 RVVCALL(OPIVX2_RM, vsmul_vx_d, OP_SSS_D, H8, H8, vsmul64) 2706 GEN_VEXT_VX_RM(vsmul_vx_b, 1, 1, clearb) 2707 GEN_VEXT_VX_RM(vsmul_vx_h, 2, 2, clearh) 2708 GEN_VEXT_VX_RM(vsmul_vx_w, 4, 4, clearl) 2709 GEN_VEXT_VX_RM(vsmul_vx_d, 8, 8, clearq) 2710 2711 /* Vector Widening Saturating Scaled Multiply-Add */ 2712 static inline uint16_t 2713 vwsmaccu8(CPURISCVState *env, int vxrm, uint8_t a, uint8_t b, 2714 uint16_t c) 2715 { 2716 uint8_t round; 2717 uint16_t res = (uint16_t)a * b; 2718 2719 round = get_round(vxrm, res, 4); 2720 res = (res >> 4) + round; 2721 return saddu16(env, vxrm, c, res); 2722 } 2723 2724 static inline uint32_t 2725 vwsmaccu16(CPURISCVState *env, int vxrm, uint16_t a, uint16_t b, 2726 uint32_t c) 2727 { 2728 uint8_t round; 2729 uint32_t res = (uint32_t)a * b; 2730 2731 round = get_round(vxrm, res, 8); 2732 res = (res >> 8) + round; 2733 return saddu32(env, vxrm, c, res); 2734 } 2735 2736 static inline uint64_t 2737 vwsmaccu32(CPURISCVState *env, int vxrm, uint32_t a, uint32_t b, 2738 uint64_t c) 2739 { 2740 uint8_t round; 2741 uint64_t res = (uint64_t)a * b; 2742 2743 round = get_round(vxrm, res, 16); 2744 res = (res >> 16) + round; 2745 return saddu64(env, vxrm, c, res); 2746 } 2747 2748 #define OPIVV3_RM(NAME, TD, T1, T2, TX1, TX2, HD, HS1, HS2, OP) \ 2749 static inline void \ 2750 do_##NAME(void *vd, void *vs1, void *vs2, int i, \ 2751 CPURISCVState *env, int vxrm) \ 2752 { \ 2753 TX1 s1 = *((T1 *)vs1 + HS1(i)); \ 2754 TX2 s2 = *((T2 *)vs2 + HS2(i)); \ 2755 TD d = *((TD *)vd + HD(i)); \ 2756 *((TD *)vd + HD(i)) = OP(env, vxrm, s2, s1, d); \ 2757 } 2758 2759 RVVCALL(OPIVV3_RM, vwsmaccu_vv_b, WOP_UUU_B, H2, H1, H1, vwsmaccu8) 2760 RVVCALL(OPIVV3_RM, vwsmaccu_vv_h, WOP_UUU_H, H4, H2, H2, vwsmaccu16) 2761 RVVCALL(OPIVV3_RM, vwsmaccu_vv_w, WOP_UUU_W, H8, H4, H4, vwsmaccu32) 2762 GEN_VEXT_VV_RM(vwsmaccu_vv_b, 1, 2, clearh) 2763 GEN_VEXT_VV_RM(vwsmaccu_vv_h, 2, 4, clearl) 2764 GEN_VEXT_VV_RM(vwsmaccu_vv_w, 4, 8, clearq) 2765 2766 #define OPIVX3_RM(NAME, TD, T1, T2, TX1, TX2, HD, HS2, OP) \ 2767 static inline void \ 2768 do_##NAME(void *vd, target_long s1, void *vs2, int i, \ 2769 CPURISCVState *env, int vxrm) \ 2770 { \ 2771 TX2 s2 = *((T2 *)vs2 + HS2(i)); \ 2772 TD d = *((TD *)vd + HD(i)); \ 2773 *((TD *)vd + HD(i)) = OP(env, vxrm, s2, (TX1)(T1)s1, d); \ 2774 } 2775 2776 RVVCALL(OPIVX3_RM, vwsmaccu_vx_b, WOP_UUU_B, H2, H1, vwsmaccu8) 2777 RVVCALL(OPIVX3_RM, vwsmaccu_vx_h, WOP_UUU_H, H4, H2, vwsmaccu16) 2778 RVVCALL(OPIVX3_RM, vwsmaccu_vx_w, WOP_UUU_W, H8, H4, vwsmaccu32) 2779 GEN_VEXT_VX_RM(vwsmaccu_vx_b, 1, 2, clearh) 2780 GEN_VEXT_VX_RM(vwsmaccu_vx_h, 2, 4, clearl) 2781 GEN_VEXT_VX_RM(vwsmaccu_vx_w, 4, 8, clearq) 2782 2783 static inline int16_t 2784 vwsmacc8(CPURISCVState *env, int vxrm, int8_t a, int8_t b, int16_t c) 2785 { 2786 uint8_t round; 2787 int16_t res = (int16_t)a * b; 2788 2789 round = get_round(vxrm, res, 4); 2790 res = (res >> 4) + round; 2791 return sadd16(env, vxrm, c, res); 2792 } 2793 2794 static inline int32_t 2795 vwsmacc16(CPURISCVState *env, int vxrm, int16_t a, int16_t b, int32_t c) 2796 { 2797 uint8_t round; 2798 int32_t res = (int32_t)a * b; 2799 2800 round = get_round(vxrm, res, 8); 2801 res = (res >> 8) + round; 2802 return sadd32(env, vxrm, c, res); 2803 2804 } 2805 2806 static inline int64_t 2807 vwsmacc32(CPURISCVState *env, int vxrm, int32_t a, int32_t b, int64_t c) 2808 { 2809 uint8_t round; 2810 int64_t res = (int64_t)a * b; 2811 2812 round = get_round(vxrm, res, 16); 2813 res = (res >> 16) + round; 2814 return sadd64(env, vxrm, c, res); 2815 } 2816 2817 RVVCALL(OPIVV3_RM, vwsmacc_vv_b, WOP_SSS_B, H2, H1, H1, vwsmacc8) 2818 RVVCALL(OPIVV3_RM, vwsmacc_vv_h, WOP_SSS_H, H4, H2, H2, vwsmacc16) 2819 RVVCALL(OPIVV3_RM, vwsmacc_vv_w, WOP_SSS_W, H8, H4, H4, vwsmacc32) 2820 GEN_VEXT_VV_RM(vwsmacc_vv_b, 1, 2, clearh) 2821 GEN_VEXT_VV_RM(vwsmacc_vv_h, 2, 4, clearl) 2822 GEN_VEXT_VV_RM(vwsmacc_vv_w, 4, 8, clearq) 2823 RVVCALL(OPIVX3_RM, vwsmacc_vx_b, WOP_SSS_B, H2, H1, vwsmacc8) 2824 RVVCALL(OPIVX3_RM, vwsmacc_vx_h, WOP_SSS_H, H4, H2, vwsmacc16) 2825 RVVCALL(OPIVX3_RM, vwsmacc_vx_w, WOP_SSS_W, H8, H4, vwsmacc32) 2826 GEN_VEXT_VX_RM(vwsmacc_vx_b, 1, 2, clearh) 2827 GEN_VEXT_VX_RM(vwsmacc_vx_h, 2, 4, clearl) 2828 GEN_VEXT_VX_RM(vwsmacc_vx_w, 4, 8, clearq) 2829 2830 static inline int16_t 2831 vwsmaccsu8(CPURISCVState *env, int vxrm, uint8_t a, int8_t b, int16_t c) 2832 { 2833 uint8_t round; 2834 int16_t res = a * (int16_t)b; 2835 2836 round = get_round(vxrm, res, 4); 2837 res = (res >> 4) + round; 2838 return ssub16(env, vxrm, c, res); 2839 } 2840 2841 static inline int32_t 2842 vwsmaccsu16(CPURISCVState *env, int vxrm, uint16_t a, int16_t b, uint32_t c) 2843 { 2844 uint8_t round; 2845 int32_t res = a * (int32_t)b; 2846 2847 round = get_round(vxrm, res, 8); 2848 res = (res >> 8) + round; 2849 return ssub32(env, vxrm, c, res); 2850 } 2851 2852 static inline int64_t 2853 vwsmaccsu32(CPURISCVState *env, int vxrm, uint32_t a, int32_t b, int64_t c) 2854 { 2855 uint8_t round; 2856 int64_t res = a * (int64_t)b; 2857 2858 round = get_round(vxrm, res, 16); 2859 res = (res >> 16) + round; 2860 return ssub64(env, vxrm, c, res); 2861 } 2862 2863 RVVCALL(OPIVV3_RM, vwsmaccsu_vv_b, WOP_SSU_B, H2, H1, H1, vwsmaccsu8) 2864 RVVCALL(OPIVV3_RM, vwsmaccsu_vv_h, WOP_SSU_H, H4, H2, H2, vwsmaccsu16) 2865 RVVCALL(OPIVV3_RM, vwsmaccsu_vv_w, WOP_SSU_W, H8, H4, H4, vwsmaccsu32) 2866 GEN_VEXT_VV_RM(vwsmaccsu_vv_b, 1, 2, clearh) 2867 GEN_VEXT_VV_RM(vwsmaccsu_vv_h, 2, 4, clearl) 2868 GEN_VEXT_VV_RM(vwsmaccsu_vv_w, 4, 8, clearq) 2869 RVVCALL(OPIVX3_RM, vwsmaccsu_vx_b, WOP_SSU_B, H2, H1, vwsmaccsu8) 2870 RVVCALL(OPIVX3_RM, vwsmaccsu_vx_h, WOP_SSU_H, H4, H2, vwsmaccsu16) 2871 RVVCALL(OPIVX3_RM, vwsmaccsu_vx_w, WOP_SSU_W, H8, H4, vwsmaccsu32) 2872 GEN_VEXT_VX_RM(vwsmaccsu_vx_b, 1, 2, clearh) 2873 GEN_VEXT_VX_RM(vwsmaccsu_vx_h, 2, 4, clearl) 2874 GEN_VEXT_VX_RM(vwsmaccsu_vx_w, 4, 8, clearq) 2875 2876 static inline int16_t 2877 vwsmaccus8(CPURISCVState *env, int vxrm, int8_t a, uint8_t b, int16_t c) 2878 { 2879 uint8_t round; 2880 int16_t res = (int16_t)a * b; 2881 2882 round = get_round(vxrm, res, 4); 2883 res = (res >> 4) + round; 2884 return ssub16(env, vxrm, c, res); 2885 } 2886 2887 static inline int32_t 2888 vwsmaccus16(CPURISCVState *env, int vxrm, int16_t a, uint16_t b, int32_t c) 2889 { 2890 uint8_t round; 2891 int32_t res = (int32_t)a * b; 2892 2893 round = get_round(vxrm, res, 8); 2894 res = (res >> 8) + round; 2895 return ssub32(env, vxrm, c, res); 2896 } 2897 2898 static inline int64_t 2899 vwsmaccus32(CPURISCVState *env, int vxrm, int32_t a, uint32_t b, int64_t c) 2900 { 2901 uint8_t round; 2902 int64_t res = (int64_t)a * b; 2903 2904 round = get_round(vxrm, res, 16); 2905 res = (res >> 16) + round; 2906 return ssub64(env, vxrm, c, res); 2907 } 2908 2909 RVVCALL(OPIVX3_RM, vwsmaccus_vx_b, WOP_SUS_B, H2, H1, vwsmaccus8) 2910 RVVCALL(OPIVX3_RM, vwsmaccus_vx_h, WOP_SUS_H, H4, H2, vwsmaccus16) 2911 RVVCALL(OPIVX3_RM, vwsmaccus_vx_w, WOP_SUS_W, H8, H4, vwsmaccus32) 2912 GEN_VEXT_VX_RM(vwsmaccus_vx_b, 1, 2, clearh) 2913 GEN_VEXT_VX_RM(vwsmaccus_vx_h, 2, 4, clearl) 2914 GEN_VEXT_VX_RM(vwsmaccus_vx_w, 4, 8, clearq) 2915 2916 /* Vector Single-Width Scaling Shift Instructions */ 2917 static inline uint8_t 2918 vssrl8(CPURISCVState *env, int vxrm, uint8_t a, uint8_t b) 2919 { 2920 uint8_t round, shift = b & 0x7; 2921 uint8_t res; 2922 2923 round = get_round(vxrm, a, shift); 2924 res = (a >> shift) + round; 2925 return res; 2926 } 2927 static inline uint16_t 2928 vssrl16(CPURISCVState *env, int vxrm, uint16_t a, uint16_t b) 2929 { 2930 uint8_t round, shift = b & 0xf; 2931 uint16_t res; 2932 2933 round = get_round(vxrm, a, shift); 2934 res = (a >> shift) + round; 2935 return res; 2936 } 2937 static inline uint32_t 2938 vssrl32(CPURISCVState *env, int vxrm, uint32_t a, uint32_t b) 2939 { 2940 uint8_t round, shift = b & 0x1f; 2941 uint32_t res; 2942 2943 round = get_round(vxrm, a, shift); 2944 res = (a >> shift) + round; 2945 return res; 2946 } 2947 static inline uint64_t 2948 vssrl64(CPURISCVState *env, int vxrm, uint64_t a, uint64_t b) 2949 { 2950 uint8_t round, shift = b & 0x3f; 2951 uint64_t res; 2952 2953 round = get_round(vxrm, a, shift); 2954 res = (a >> shift) + round; 2955 return res; 2956 } 2957 RVVCALL(OPIVV2_RM, vssrl_vv_b, OP_UUU_B, H1, H1, H1, vssrl8) 2958 RVVCALL(OPIVV2_RM, vssrl_vv_h, OP_UUU_H, H2, H2, H2, vssrl16) 2959 RVVCALL(OPIVV2_RM, vssrl_vv_w, OP_UUU_W, H4, H4, H4, vssrl32) 2960 RVVCALL(OPIVV2_RM, vssrl_vv_d, OP_UUU_D, H8, H8, H8, vssrl64) 2961 GEN_VEXT_VV_RM(vssrl_vv_b, 1, 1, clearb) 2962 GEN_VEXT_VV_RM(vssrl_vv_h, 2, 2, clearh) 2963 GEN_VEXT_VV_RM(vssrl_vv_w, 4, 4, clearl) 2964 GEN_VEXT_VV_RM(vssrl_vv_d, 8, 8, clearq) 2965 2966 RVVCALL(OPIVX2_RM, vssrl_vx_b, OP_UUU_B, H1, H1, vssrl8) 2967 RVVCALL(OPIVX2_RM, vssrl_vx_h, OP_UUU_H, H2, H2, vssrl16) 2968 RVVCALL(OPIVX2_RM, vssrl_vx_w, OP_UUU_W, H4, H4, vssrl32) 2969 RVVCALL(OPIVX2_RM, vssrl_vx_d, OP_UUU_D, H8, H8, vssrl64) 2970 GEN_VEXT_VX_RM(vssrl_vx_b, 1, 1, clearb) 2971 GEN_VEXT_VX_RM(vssrl_vx_h, 2, 2, clearh) 2972 GEN_VEXT_VX_RM(vssrl_vx_w, 4, 4, clearl) 2973 GEN_VEXT_VX_RM(vssrl_vx_d, 8, 8, clearq) 2974 2975 static inline int8_t 2976 vssra8(CPURISCVState *env, int vxrm, int8_t a, int8_t b) 2977 { 2978 uint8_t round, shift = b & 0x7; 2979 int8_t res; 2980 2981 round = get_round(vxrm, a, shift); 2982 res = (a >> shift) + round; 2983 return res; 2984 } 2985 static inline int16_t 2986 vssra16(CPURISCVState *env, int vxrm, int16_t a, int16_t b) 2987 { 2988 uint8_t round, shift = b & 0xf; 2989 int16_t res; 2990 2991 round = get_round(vxrm, a, shift); 2992 res = (a >> shift) + round; 2993 return res; 2994 } 2995 static inline int32_t 2996 vssra32(CPURISCVState *env, int vxrm, int32_t a, int32_t b) 2997 { 2998 uint8_t round, shift = b & 0x1f; 2999 int32_t res; 3000 3001 round = get_round(vxrm, a, shift); 3002 res = (a >> shift) + round; 3003 return res; 3004 } 3005 static inline int64_t 3006 vssra64(CPURISCVState *env, int vxrm, int64_t a, int64_t b) 3007 { 3008 uint8_t round, shift = b & 0x3f; 3009 int64_t res; 3010 3011 round = get_round(vxrm, a, shift); 3012 res = (a >> shift) + round; 3013 return res; 3014 } 3015 3016 RVVCALL(OPIVV2_RM, vssra_vv_b, OP_SSS_B, H1, H1, H1, vssra8) 3017 RVVCALL(OPIVV2_RM, vssra_vv_h, OP_SSS_H, H2, H2, H2, vssra16) 3018 RVVCALL(OPIVV2_RM, vssra_vv_w, OP_SSS_W, H4, H4, H4, vssra32) 3019 RVVCALL(OPIVV2_RM, vssra_vv_d, OP_SSS_D, H8, H8, H8, vssra64) 3020 GEN_VEXT_VV_RM(vssra_vv_b, 1, 1, clearb) 3021 GEN_VEXT_VV_RM(vssra_vv_h, 2, 2, clearh) 3022 GEN_VEXT_VV_RM(vssra_vv_w, 4, 4, clearl) 3023 GEN_VEXT_VV_RM(vssra_vv_d, 8, 8, clearq) 3024 3025 RVVCALL(OPIVX2_RM, vssra_vx_b, OP_SSS_B, H1, H1, vssra8) 3026 RVVCALL(OPIVX2_RM, vssra_vx_h, OP_SSS_H, H2, H2, vssra16) 3027 RVVCALL(OPIVX2_RM, vssra_vx_w, OP_SSS_W, H4, H4, vssra32) 3028 RVVCALL(OPIVX2_RM, vssra_vx_d, OP_SSS_D, H8, H8, vssra64) 3029 GEN_VEXT_VX_RM(vssra_vx_b, 1, 1, clearb) 3030 GEN_VEXT_VX_RM(vssra_vx_h, 2, 2, clearh) 3031 GEN_VEXT_VX_RM(vssra_vx_w, 4, 4, clearl) 3032 GEN_VEXT_VX_RM(vssra_vx_d, 8, 8, clearq) 3033 3034 /* Vector Narrowing Fixed-Point Clip Instructions */ 3035 static inline int8_t 3036 vnclip8(CPURISCVState *env, int vxrm, int16_t a, int8_t b) 3037 { 3038 uint8_t round, shift = b & 0xf; 3039 int16_t res; 3040 3041 round = get_round(vxrm, a, shift); 3042 res = (a >> shift) + round; 3043 if (res > INT8_MAX) { 3044 env->vxsat = 0x1; 3045 return INT8_MAX; 3046 } else if (res < INT8_MIN) { 3047 env->vxsat = 0x1; 3048 return INT8_MIN; 3049 } else { 3050 return res; 3051 } 3052 } 3053 3054 static inline int16_t 3055 vnclip16(CPURISCVState *env, int vxrm, int32_t a, int16_t b) 3056 { 3057 uint8_t round, shift = b & 0x1f; 3058 int32_t res; 3059 3060 round = get_round(vxrm, a, shift); 3061 res = (a >> shift) + round; 3062 if (res > INT16_MAX) { 3063 env->vxsat = 0x1; 3064 return INT16_MAX; 3065 } else if (res < INT16_MIN) { 3066 env->vxsat = 0x1; 3067 return INT16_MIN; 3068 } else { 3069 return res; 3070 } 3071 } 3072 3073 static inline int32_t 3074 vnclip32(CPURISCVState *env, int vxrm, int64_t a, int32_t b) 3075 { 3076 uint8_t round, shift = b & 0x3f; 3077 int64_t res; 3078 3079 round = get_round(vxrm, a, shift); 3080 res = (a >> shift) + round; 3081 if (res > INT32_MAX) { 3082 env->vxsat = 0x1; 3083 return INT32_MAX; 3084 } else if (res < INT32_MIN) { 3085 env->vxsat = 0x1; 3086 return INT32_MIN; 3087 } else { 3088 return res; 3089 } 3090 } 3091 3092 RVVCALL(OPIVV2_RM, vnclip_vv_b, NOP_SSS_B, H1, H2, H1, vnclip8) 3093 RVVCALL(OPIVV2_RM, vnclip_vv_h, NOP_SSS_H, H2, H4, H2, vnclip16) 3094 RVVCALL(OPIVV2_RM, vnclip_vv_w, NOP_SSS_W, H4, H8, H4, vnclip32) 3095 GEN_VEXT_VV_RM(vnclip_vv_b, 1, 1, clearb) 3096 GEN_VEXT_VV_RM(vnclip_vv_h, 2, 2, clearh) 3097 GEN_VEXT_VV_RM(vnclip_vv_w, 4, 4, clearl) 3098 3099 RVVCALL(OPIVX2_RM, vnclip_vx_b, NOP_SSS_B, H1, H2, vnclip8) 3100 RVVCALL(OPIVX2_RM, vnclip_vx_h, NOP_SSS_H, H2, H4, vnclip16) 3101 RVVCALL(OPIVX2_RM, vnclip_vx_w, NOP_SSS_W, H4, H8, vnclip32) 3102 GEN_VEXT_VX_RM(vnclip_vx_b, 1, 1, clearb) 3103 GEN_VEXT_VX_RM(vnclip_vx_h, 2, 2, clearh) 3104 GEN_VEXT_VX_RM(vnclip_vx_w, 4, 4, clearl) 3105 3106 static inline uint8_t 3107 vnclipu8(CPURISCVState *env, int vxrm, uint16_t a, uint8_t b) 3108 { 3109 uint8_t round, shift = b & 0xf; 3110 uint16_t res; 3111 3112 round = get_round(vxrm, a, shift); 3113 res = (a >> shift) + round; 3114 if (res > UINT8_MAX) { 3115 env->vxsat = 0x1; 3116 return UINT8_MAX; 3117 } else { 3118 return res; 3119 } 3120 } 3121 3122 static inline uint16_t 3123 vnclipu16(CPURISCVState *env, int vxrm, uint32_t a, uint16_t b) 3124 { 3125 uint8_t round, shift = b & 0x1f; 3126 uint32_t res; 3127 3128 round = get_round(vxrm, a, shift); 3129 res = (a >> shift) + round; 3130 if (res > UINT16_MAX) { 3131 env->vxsat = 0x1; 3132 return UINT16_MAX; 3133 } else { 3134 return res; 3135 } 3136 } 3137 3138 static inline uint32_t 3139 vnclipu32(CPURISCVState *env, int vxrm, uint64_t a, uint32_t b) 3140 { 3141 uint8_t round, shift = b & 0x3f; 3142 int64_t res; 3143 3144 round = get_round(vxrm, a, shift); 3145 res = (a >> shift) + round; 3146 if (res > UINT32_MAX) { 3147 env->vxsat = 0x1; 3148 return UINT32_MAX; 3149 } else { 3150 return res; 3151 } 3152 } 3153 3154 RVVCALL(OPIVV2_RM, vnclipu_vv_b, NOP_UUU_B, H1, H2, H1, vnclipu8) 3155 RVVCALL(OPIVV2_RM, vnclipu_vv_h, NOP_UUU_H, H2, H4, H2, vnclipu16) 3156 RVVCALL(OPIVV2_RM, vnclipu_vv_w, NOP_UUU_W, H4, H8, H4, vnclipu32) 3157 GEN_VEXT_VV_RM(vnclipu_vv_b, 1, 1, clearb) 3158 GEN_VEXT_VV_RM(vnclipu_vv_h, 2, 2, clearh) 3159 GEN_VEXT_VV_RM(vnclipu_vv_w, 4, 4, clearl) 3160 3161 RVVCALL(OPIVX2_RM, vnclipu_vx_b, NOP_UUU_B, H1, H2, vnclipu8) 3162 RVVCALL(OPIVX2_RM, vnclipu_vx_h, NOP_UUU_H, H2, H4, vnclipu16) 3163 RVVCALL(OPIVX2_RM, vnclipu_vx_w, NOP_UUU_W, H4, H8, vnclipu32) 3164 GEN_VEXT_VX_RM(vnclipu_vx_b, 1, 1, clearb) 3165 GEN_VEXT_VX_RM(vnclipu_vx_h, 2, 2, clearh) 3166 GEN_VEXT_VX_RM(vnclipu_vx_w, 4, 4, clearl) 3167 3168 /* 3169 *** Vector Float Point Arithmetic Instructions 3170 */ 3171 /* Vector Single-Width Floating-Point Add/Subtract Instructions */ 3172 #define OPFVV2(NAME, TD, T1, T2, TX1, TX2, HD, HS1, HS2, OP) \ 3173 static void do_##NAME(void *vd, void *vs1, void *vs2, int i, \ 3174 CPURISCVState *env) \ 3175 { \ 3176 TX1 s1 = *((T1 *)vs1 + HS1(i)); \ 3177 TX2 s2 = *((T2 *)vs2 + HS2(i)); \ 3178 *((TD *)vd + HD(i)) = OP(s2, s1, &env->fp_status); \ 3179 } 3180 3181 #define GEN_VEXT_VV_ENV(NAME, ESZ, DSZ, CLEAR_FN) \ 3182 void HELPER(NAME)(void *vd, void *v0, void *vs1, \ 3183 void *vs2, CPURISCVState *env, \ 3184 uint32_t desc) \ 3185 { \ 3186 uint32_t vlmax = vext_maxsz(desc) / ESZ; \ 3187 uint32_t mlen = vext_mlen(desc); \ 3188 uint32_t vm = vext_vm(desc); \ 3189 uint32_t vl = env->vl; \ 3190 uint32_t i; \ 3191 \ 3192 for (i = 0; i < vl; i++) { \ 3193 if (!vm && !vext_elem_mask(v0, mlen, i)) { \ 3194 continue; \ 3195 } \ 3196 do_##NAME(vd, vs1, vs2, i, env); \ 3197 } \ 3198 CLEAR_FN(vd, vl, vl * DSZ, vlmax * DSZ); \ 3199 } 3200 3201 RVVCALL(OPFVV2, vfadd_vv_h, OP_UUU_H, H2, H2, H2, float16_add) 3202 RVVCALL(OPFVV2, vfadd_vv_w, OP_UUU_W, H4, H4, H4, float32_add) 3203 RVVCALL(OPFVV2, vfadd_vv_d, OP_UUU_D, H8, H8, H8, float64_add) 3204 GEN_VEXT_VV_ENV(vfadd_vv_h, 2, 2, clearh) 3205 GEN_VEXT_VV_ENV(vfadd_vv_w, 4, 4, clearl) 3206 GEN_VEXT_VV_ENV(vfadd_vv_d, 8, 8, clearq) 3207 3208 #define OPFVF2(NAME, TD, T1, T2, TX1, TX2, HD, HS2, OP) \ 3209 static void do_##NAME(void *vd, uint64_t s1, void *vs2, int i, \ 3210 CPURISCVState *env) \ 3211 { \ 3212 TX2 s2 = *((T2 *)vs2 + HS2(i)); \ 3213 *((TD *)vd + HD(i)) = OP(s2, (TX1)(T1)s1, &env->fp_status);\ 3214 } 3215 3216 #define GEN_VEXT_VF(NAME, ESZ, DSZ, CLEAR_FN) \ 3217 void HELPER(NAME)(void *vd, void *v0, uint64_t s1, \ 3218 void *vs2, CPURISCVState *env, \ 3219 uint32_t desc) \ 3220 { \ 3221 uint32_t vlmax = vext_maxsz(desc) / ESZ; \ 3222 uint32_t mlen = vext_mlen(desc); \ 3223 uint32_t vm = vext_vm(desc); \ 3224 uint32_t vl = env->vl; \ 3225 uint32_t i; \ 3226 \ 3227 for (i = 0; i < vl; i++) { \ 3228 if (!vm && !vext_elem_mask(v0, mlen, i)) { \ 3229 continue; \ 3230 } \ 3231 do_##NAME(vd, s1, vs2, i, env); \ 3232 } \ 3233 CLEAR_FN(vd, vl, vl * DSZ, vlmax * DSZ); \ 3234 } 3235 3236 RVVCALL(OPFVF2, vfadd_vf_h, OP_UUU_H, H2, H2, float16_add) 3237 RVVCALL(OPFVF2, vfadd_vf_w, OP_UUU_W, H4, H4, float32_add) 3238 RVVCALL(OPFVF2, vfadd_vf_d, OP_UUU_D, H8, H8, float64_add) 3239 GEN_VEXT_VF(vfadd_vf_h, 2, 2, clearh) 3240 GEN_VEXT_VF(vfadd_vf_w, 4, 4, clearl) 3241 GEN_VEXT_VF(vfadd_vf_d, 8, 8, clearq) 3242 3243 RVVCALL(OPFVV2, vfsub_vv_h, OP_UUU_H, H2, H2, H2, float16_sub) 3244 RVVCALL(OPFVV2, vfsub_vv_w, OP_UUU_W, H4, H4, H4, float32_sub) 3245 RVVCALL(OPFVV2, vfsub_vv_d, OP_UUU_D, H8, H8, H8, float64_sub) 3246 GEN_VEXT_VV_ENV(vfsub_vv_h, 2, 2, clearh) 3247 GEN_VEXT_VV_ENV(vfsub_vv_w, 4, 4, clearl) 3248 GEN_VEXT_VV_ENV(vfsub_vv_d, 8, 8, clearq) 3249 RVVCALL(OPFVF2, vfsub_vf_h, OP_UUU_H, H2, H2, float16_sub) 3250 RVVCALL(OPFVF2, vfsub_vf_w, OP_UUU_W, H4, H4, float32_sub) 3251 RVVCALL(OPFVF2, vfsub_vf_d, OP_UUU_D, H8, H8, float64_sub) 3252 GEN_VEXT_VF(vfsub_vf_h, 2, 2, clearh) 3253 GEN_VEXT_VF(vfsub_vf_w, 4, 4, clearl) 3254 GEN_VEXT_VF(vfsub_vf_d, 8, 8, clearq) 3255 3256 static uint16_t float16_rsub(uint16_t a, uint16_t b, float_status *s) 3257 { 3258 return float16_sub(b, a, s); 3259 } 3260 3261 static uint32_t float32_rsub(uint32_t a, uint32_t b, float_status *s) 3262 { 3263 return float32_sub(b, a, s); 3264 } 3265 3266 static uint64_t float64_rsub(uint64_t a, uint64_t b, float_status *s) 3267 { 3268 return float64_sub(b, a, s); 3269 } 3270 3271 RVVCALL(OPFVF2, vfrsub_vf_h, OP_UUU_H, H2, H2, float16_rsub) 3272 RVVCALL(OPFVF2, vfrsub_vf_w, OP_UUU_W, H4, H4, float32_rsub) 3273 RVVCALL(OPFVF2, vfrsub_vf_d, OP_UUU_D, H8, H8, float64_rsub) 3274 GEN_VEXT_VF(vfrsub_vf_h, 2, 2, clearh) 3275 GEN_VEXT_VF(vfrsub_vf_w, 4, 4, clearl) 3276 GEN_VEXT_VF(vfrsub_vf_d, 8, 8, clearq) 3277 3278 /* Vector Widening Floating-Point Add/Subtract Instructions */ 3279 static uint32_t vfwadd16(uint16_t a, uint16_t b, float_status *s) 3280 { 3281 return float32_add(float16_to_float32(a, true, s), 3282 float16_to_float32(b, true, s), s); 3283 } 3284 3285 static uint64_t vfwadd32(uint32_t a, uint32_t b, float_status *s) 3286 { 3287 return float64_add(float32_to_float64(a, s), 3288 float32_to_float64(b, s), s); 3289 3290 } 3291 3292 RVVCALL(OPFVV2, vfwadd_vv_h, WOP_UUU_H, H4, H2, H2, vfwadd16) 3293 RVVCALL(OPFVV2, vfwadd_vv_w, WOP_UUU_W, H8, H4, H4, vfwadd32) 3294 GEN_VEXT_VV_ENV(vfwadd_vv_h, 2, 4, clearl) 3295 GEN_VEXT_VV_ENV(vfwadd_vv_w, 4, 8, clearq) 3296 RVVCALL(OPFVF2, vfwadd_vf_h, WOP_UUU_H, H4, H2, vfwadd16) 3297 RVVCALL(OPFVF2, vfwadd_vf_w, WOP_UUU_W, H8, H4, vfwadd32) 3298 GEN_VEXT_VF(vfwadd_vf_h, 2, 4, clearl) 3299 GEN_VEXT_VF(vfwadd_vf_w, 4, 8, clearq) 3300 3301 static uint32_t vfwsub16(uint16_t a, uint16_t b, float_status *s) 3302 { 3303 return float32_sub(float16_to_float32(a, true, s), 3304 float16_to_float32(b, true, s), s); 3305 } 3306 3307 static uint64_t vfwsub32(uint32_t a, uint32_t b, float_status *s) 3308 { 3309 return float64_sub(float32_to_float64(a, s), 3310 float32_to_float64(b, s), s); 3311 3312 } 3313 3314 RVVCALL(OPFVV2, vfwsub_vv_h, WOP_UUU_H, H4, H2, H2, vfwsub16) 3315 RVVCALL(OPFVV2, vfwsub_vv_w, WOP_UUU_W, H8, H4, H4, vfwsub32) 3316 GEN_VEXT_VV_ENV(vfwsub_vv_h, 2, 4, clearl) 3317 GEN_VEXT_VV_ENV(vfwsub_vv_w, 4, 8, clearq) 3318 RVVCALL(OPFVF2, vfwsub_vf_h, WOP_UUU_H, H4, H2, vfwsub16) 3319 RVVCALL(OPFVF2, vfwsub_vf_w, WOP_UUU_W, H8, H4, vfwsub32) 3320 GEN_VEXT_VF(vfwsub_vf_h, 2, 4, clearl) 3321 GEN_VEXT_VF(vfwsub_vf_w, 4, 8, clearq) 3322 3323 static uint32_t vfwaddw16(uint32_t a, uint16_t b, float_status *s) 3324 { 3325 return float32_add(a, float16_to_float32(b, true, s), s); 3326 } 3327 3328 static uint64_t vfwaddw32(uint64_t a, uint32_t b, float_status *s) 3329 { 3330 return float64_add(a, float32_to_float64(b, s), s); 3331 } 3332 3333 RVVCALL(OPFVV2, vfwadd_wv_h, WOP_WUUU_H, H4, H2, H2, vfwaddw16) 3334 RVVCALL(OPFVV2, vfwadd_wv_w, WOP_WUUU_W, H8, H4, H4, vfwaddw32) 3335 GEN_VEXT_VV_ENV(vfwadd_wv_h, 2, 4, clearl) 3336 GEN_VEXT_VV_ENV(vfwadd_wv_w, 4, 8, clearq) 3337 RVVCALL(OPFVF2, vfwadd_wf_h, WOP_WUUU_H, H4, H2, vfwaddw16) 3338 RVVCALL(OPFVF2, vfwadd_wf_w, WOP_WUUU_W, H8, H4, vfwaddw32) 3339 GEN_VEXT_VF(vfwadd_wf_h, 2, 4, clearl) 3340 GEN_VEXT_VF(vfwadd_wf_w, 4, 8, clearq) 3341 3342 static uint32_t vfwsubw16(uint32_t a, uint16_t b, float_status *s) 3343 { 3344 return float32_sub(a, float16_to_float32(b, true, s), s); 3345 } 3346 3347 static uint64_t vfwsubw32(uint64_t a, uint32_t b, float_status *s) 3348 { 3349 return float64_sub(a, float32_to_float64(b, s), s); 3350 } 3351 3352 RVVCALL(OPFVV2, vfwsub_wv_h, WOP_WUUU_H, H4, H2, H2, vfwsubw16) 3353 RVVCALL(OPFVV2, vfwsub_wv_w, WOP_WUUU_W, H8, H4, H4, vfwsubw32) 3354 GEN_VEXT_VV_ENV(vfwsub_wv_h, 2, 4, clearl) 3355 GEN_VEXT_VV_ENV(vfwsub_wv_w, 4, 8, clearq) 3356 RVVCALL(OPFVF2, vfwsub_wf_h, WOP_WUUU_H, H4, H2, vfwsubw16) 3357 RVVCALL(OPFVF2, vfwsub_wf_w, WOP_WUUU_W, H8, H4, vfwsubw32) 3358 GEN_VEXT_VF(vfwsub_wf_h, 2, 4, clearl) 3359 GEN_VEXT_VF(vfwsub_wf_w, 4, 8, clearq) 3360 3361 /* Vector Single-Width Floating-Point Multiply/Divide Instructions */ 3362 RVVCALL(OPFVV2, vfmul_vv_h, OP_UUU_H, H2, H2, H2, float16_mul) 3363 RVVCALL(OPFVV2, vfmul_vv_w, OP_UUU_W, H4, H4, H4, float32_mul) 3364 RVVCALL(OPFVV2, vfmul_vv_d, OP_UUU_D, H8, H8, H8, float64_mul) 3365 GEN_VEXT_VV_ENV(vfmul_vv_h, 2, 2, clearh) 3366 GEN_VEXT_VV_ENV(vfmul_vv_w, 4, 4, clearl) 3367 GEN_VEXT_VV_ENV(vfmul_vv_d, 8, 8, clearq) 3368 RVVCALL(OPFVF2, vfmul_vf_h, OP_UUU_H, H2, H2, float16_mul) 3369 RVVCALL(OPFVF2, vfmul_vf_w, OP_UUU_W, H4, H4, float32_mul) 3370 RVVCALL(OPFVF2, vfmul_vf_d, OP_UUU_D, H8, H8, float64_mul) 3371 GEN_VEXT_VF(vfmul_vf_h, 2, 2, clearh) 3372 GEN_VEXT_VF(vfmul_vf_w, 4, 4, clearl) 3373 GEN_VEXT_VF(vfmul_vf_d, 8, 8, clearq) 3374 3375 RVVCALL(OPFVV2, vfdiv_vv_h, OP_UUU_H, H2, H2, H2, float16_div) 3376 RVVCALL(OPFVV2, vfdiv_vv_w, OP_UUU_W, H4, H4, H4, float32_div) 3377 RVVCALL(OPFVV2, vfdiv_vv_d, OP_UUU_D, H8, H8, H8, float64_div) 3378 GEN_VEXT_VV_ENV(vfdiv_vv_h, 2, 2, clearh) 3379 GEN_VEXT_VV_ENV(vfdiv_vv_w, 4, 4, clearl) 3380 GEN_VEXT_VV_ENV(vfdiv_vv_d, 8, 8, clearq) 3381 RVVCALL(OPFVF2, vfdiv_vf_h, OP_UUU_H, H2, H2, float16_div) 3382 RVVCALL(OPFVF2, vfdiv_vf_w, OP_UUU_W, H4, H4, float32_div) 3383 RVVCALL(OPFVF2, vfdiv_vf_d, OP_UUU_D, H8, H8, float64_div) 3384 GEN_VEXT_VF(vfdiv_vf_h, 2, 2, clearh) 3385 GEN_VEXT_VF(vfdiv_vf_w, 4, 4, clearl) 3386 GEN_VEXT_VF(vfdiv_vf_d, 8, 8, clearq) 3387 3388 static uint16_t float16_rdiv(uint16_t a, uint16_t b, float_status *s) 3389 { 3390 return float16_div(b, a, s); 3391 } 3392 3393 static uint32_t float32_rdiv(uint32_t a, uint32_t b, float_status *s) 3394 { 3395 return float32_div(b, a, s); 3396 } 3397 3398 static uint64_t float64_rdiv(uint64_t a, uint64_t b, float_status *s) 3399 { 3400 return float64_div(b, a, s); 3401 } 3402 3403 RVVCALL(OPFVF2, vfrdiv_vf_h, OP_UUU_H, H2, H2, float16_rdiv) 3404 RVVCALL(OPFVF2, vfrdiv_vf_w, OP_UUU_W, H4, H4, float32_rdiv) 3405 RVVCALL(OPFVF2, vfrdiv_vf_d, OP_UUU_D, H8, H8, float64_rdiv) 3406 GEN_VEXT_VF(vfrdiv_vf_h, 2, 2, clearh) 3407 GEN_VEXT_VF(vfrdiv_vf_w, 4, 4, clearl) 3408 GEN_VEXT_VF(vfrdiv_vf_d, 8, 8, clearq) 3409 3410 /* Vector Widening Floating-Point Multiply */ 3411 static uint32_t vfwmul16(uint16_t a, uint16_t b, float_status *s) 3412 { 3413 return float32_mul(float16_to_float32(a, true, s), 3414 float16_to_float32(b, true, s), s); 3415 } 3416 3417 static uint64_t vfwmul32(uint32_t a, uint32_t b, float_status *s) 3418 { 3419 return float64_mul(float32_to_float64(a, s), 3420 float32_to_float64(b, s), s); 3421 3422 } 3423 RVVCALL(OPFVV2, vfwmul_vv_h, WOP_UUU_H, H4, H2, H2, vfwmul16) 3424 RVVCALL(OPFVV2, vfwmul_vv_w, WOP_UUU_W, H8, H4, H4, vfwmul32) 3425 GEN_VEXT_VV_ENV(vfwmul_vv_h, 2, 4, clearl) 3426 GEN_VEXT_VV_ENV(vfwmul_vv_w, 4, 8, clearq) 3427 RVVCALL(OPFVF2, vfwmul_vf_h, WOP_UUU_H, H4, H2, vfwmul16) 3428 RVVCALL(OPFVF2, vfwmul_vf_w, WOP_UUU_W, H8, H4, vfwmul32) 3429 GEN_VEXT_VF(vfwmul_vf_h, 2, 4, clearl) 3430 GEN_VEXT_VF(vfwmul_vf_w, 4, 8, clearq) 3431 3432 /* Vector Single-Width Floating-Point Fused Multiply-Add Instructions */ 3433 #define OPFVV3(NAME, TD, T1, T2, TX1, TX2, HD, HS1, HS2, OP) \ 3434 static void do_##NAME(void *vd, void *vs1, void *vs2, int i, \ 3435 CPURISCVState *env) \ 3436 { \ 3437 TX1 s1 = *((T1 *)vs1 + HS1(i)); \ 3438 TX2 s2 = *((T2 *)vs2 + HS2(i)); \ 3439 TD d = *((TD *)vd + HD(i)); \ 3440 *((TD *)vd + HD(i)) = OP(s2, s1, d, &env->fp_status); \ 3441 } 3442 3443 static uint16_t fmacc16(uint16_t a, uint16_t b, uint16_t d, float_status *s) 3444 { 3445 return float16_muladd(a, b, d, 0, s); 3446 } 3447 3448 static uint32_t fmacc32(uint32_t a, uint32_t b, uint32_t d, float_status *s) 3449 { 3450 return float32_muladd(a, b, d, 0, s); 3451 } 3452 3453 static uint64_t fmacc64(uint64_t a, uint64_t b, uint64_t d, float_status *s) 3454 { 3455 return float64_muladd(a, b, d, 0, s); 3456 } 3457 3458 RVVCALL(OPFVV3, vfmacc_vv_h, OP_UUU_H, H2, H2, H2, fmacc16) 3459 RVVCALL(OPFVV3, vfmacc_vv_w, OP_UUU_W, H4, H4, H4, fmacc32) 3460 RVVCALL(OPFVV3, vfmacc_vv_d, OP_UUU_D, H8, H8, H8, fmacc64) 3461 GEN_VEXT_VV_ENV(vfmacc_vv_h, 2, 2, clearh) 3462 GEN_VEXT_VV_ENV(vfmacc_vv_w, 4, 4, clearl) 3463 GEN_VEXT_VV_ENV(vfmacc_vv_d, 8, 8, clearq) 3464 3465 #define OPFVF3(NAME, TD, T1, T2, TX1, TX2, HD, HS2, OP) \ 3466 static void do_##NAME(void *vd, uint64_t s1, void *vs2, int i, \ 3467 CPURISCVState *env) \ 3468 { \ 3469 TX2 s2 = *((T2 *)vs2 + HS2(i)); \ 3470 TD d = *((TD *)vd + HD(i)); \ 3471 *((TD *)vd + HD(i)) = OP(s2, (TX1)(T1)s1, d, &env->fp_status);\ 3472 } 3473 3474 RVVCALL(OPFVF3, vfmacc_vf_h, OP_UUU_H, H2, H2, fmacc16) 3475 RVVCALL(OPFVF3, vfmacc_vf_w, OP_UUU_W, H4, H4, fmacc32) 3476 RVVCALL(OPFVF3, vfmacc_vf_d, OP_UUU_D, H8, H8, fmacc64) 3477 GEN_VEXT_VF(vfmacc_vf_h, 2, 2, clearh) 3478 GEN_VEXT_VF(vfmacc_vf_w, 4, 4, clearl) 3479 GEN_VEXT_VF(vfmacc_vf_d, 8, 8, clearq) 3480 3481 static uint16_t fnmacc16(uint16_t a, uint16_t b, uint16_t d, float_status *s) 3482 { 3483 return float16_muladd(a, b, d, 3484 float_muladd_negate_c | float_muladd_negate_product, s); 3485 } 3486 3487 static uint32_t fnmacc32(uint32_t a, uint32_t b, uint32_t d, float_status *s) 3488 { 3489 return float32_muladd(a, b, d, 3490 float_muladd_negate_c | float_muladd_negate_product, s); 3491 } 3492 3493 static uint64_t fnmacc64(uint64_t a, uint64_t b, uint64_t d, float_status *s) 3494 { 3495 return float64_muladd(a, b, d, 3496 float_muladd_negate_c | float_muladd_negate_product, s); 3497 } 3498 3499 RVVCALL(OPFVV3, vfnmacc_vv_h, OP_UUU_H, H2, H2, H2, fnmacc16) 3500 RVVCALL(OPFVV3, vfnmacc_vv_w, OP_UUU_W, H4, H4, H4, fnmacc32) 3501 RVVCALL(OPFVV3, vfnmacc_vv_d, OP_UUU_D, H8, H8, H8, fnmacc64) 3502 GEN_VEXT_VV_ENV(vfnmacc_vv_h, 2, 2, clearh) 3503 GEN_VEXT_VV_ENV(vfnmacc_vv_w, 4, 4, clearl) 3504 GEN_VEXT_VV_ENV(vfnmacc_vv_d, 8, 8, clearq) 3505 RVVCALL(OPFVF3, vfnmacc_vf_h, OP_UUU_H, H2, H2, fnmacc16) 3506 RVVCALL(OPFVF3, vfnmacc_vf_w, OP_UUU_W, H4, H4, fnmacc32) 3507 RVVCALL(OPFVF3, vfnmacc_vf_d, OP_UUU_D, H8, H8, fnmacc64) 3508 GEN_VEXT_VF(vfnmacc_vf_h, 2, 2, clearh) 3509 GEN_VEXT_VF(vfnmacc_vf_w, 4, 4, clearl) 3510 GEN_VEXT_VF(vfnmacc_vf_d, 8, 8, clearq) 3511 3512 static uint16_t fmsac16(uint16_t a, uint16_t b, uint16_t d, float_status *s) 3513 { 3514 return float16_muladd(a, b, d, float_muladd_negate_c, s); 3515 } 3516 3517 static uint32_t fmsac32(uint32_t a, uint32_t b, uint32_t d, float_status *s) 3518 { 3519 return float32_muladd(a, b, d, float_muladd_negate_c, s); 3520 } 3521 3522 static uint64_t fmsac64(uint64_t a, uint64_t b, uint64_t d, float_status *s) 3523 { 3524 return float64_muladd(a, b, d, float_muladd_negate_c, s); 3525 } 3526 3527 RVVCALL(OPFVV3, vfmsac_vv_h, OP_UUU_H, H2, H2, H2, fmsac16) 3528 RVVCALL(OPFVV3, vfmsac_vv_w, OP_UUU_W, H4, H4, H4, fmsac32) 3529 RVVCALL(OPFVV3, vfmsac_vv_d, OP_UUU_D, H8, H8, H8, fmsac64) 3530 GEN_VEXT_VV_ENV(vfmsac_vv_h, 2, 2, clearh) 3531 GEN_VEXT_VV_ENV(vfmsac_vv_w, 4, 4, clearl) 3532 GEN_VEXT_VV_ENV(vfmsac_vv_d, 8, 8, clearq) 3533 RVVCALL(OPFVF3, vfmsac_vf_h, OP_UUU_H, H2, H2, fmsac16) 3534 RVVCALL(OPFVF3, vfmsac_vf_w, OP_UUU_W, H4, H4, fmsac32) 3535 RVVCALL(OPFVF3, vfmsac_vf_d, OP_UUU_D, H8, H8, fmsac64) 3536 GEN_VEXT_VF(vfmsac_vf_h, 2, 2, clearh) 3537 GEN_VEXT_VF(vfmsac_vf_w, 4, 4, clearl) 3538 GEN_VEXT_VF(vfmsac_vf_d, 8, 8, clearq) 3539 3540 static uint16_t fnmsac16(uint16_t a, uint16_t b, uint16_t d, float_status *s) 3541 { 3542 return float16_muladd(a, b, d, float_muladd_negate_product, s); 3543 } 3544 3545 static uint32_t fnmsac32(uint32_t a, uint32_t b, uint32_t d, float_status *s) 3546 { 3547 return float32_muladd(a, b, d, float_muladd_negate_product, s); 3548 } 3549 3550 static uint64_t fnmsac64(uint64_t a, uint64_t b, uint64_t d, float_status *s) 3551 { 3552 return float64_muladd(a, b, d, float_muladd_negate_product, s); 3553 } 3554 3555 RVVCALL(OPFVV3, vfnmsac_vv_h, OP_UUU_H, H2, H2, H2, fnmsac16) 3556 RVVCALL(OPFVV3, vfnmsac_vv_w, OP_UUU_W, H4, H4, H4, fnmsac32) 3557 RVVCALL(OPFVV3, vfnmsac_vv_d, OP_UUU_D, H8, H8, H8, fnmsac64) 3558 GEN_VEXT_VV_ENV(vfnmsac_vv_h, 2, 2, clearh) 3559 GEN_VEXT_VV_ENV(vfnmsac_vv_w, 4, 4, clearl) 3560 GEN_VEXT_VV_ENV(vfnmsac_vv_d, 8, 8, clearq) 3561 RVVCALL(OPFVF3, vfnmsac_vf_h, OP_UUU_H, H2, H2, fnmsac16) 3562 RVVCALL(OPFVF3, vfnmsac_vf_w, OP_UUU_W, H4, H4, fnmsac32) 3563 RVVCALL(OPFVF3, vfnmsac_vf_d, OP_UUU_D, H8, H8, fnmsac64) 3564 GEN_VEXT_VF(vfnmsac_vf_h, 2, 2, clearh) 3565 GEN_VEXT_VF(vfnmsac_vf_w, 4, 4, clearl) 3566 GEN_VEXT_VF(vfnmsac_vf_d, 8, 8, clearq) 3567 3568 static uint16_t fmadd16(uint16_t a, uint16_t b, uint16_t d, float_status *s) 3569 { 3570 return float16_muladd(d, b, a, 0, s); 3571 } 3572 3573 static uint32_t fmadd32(uint32_t a, uint32_t b, uint32_t d, float_status *s) 3574 { 3575 return float32_muladd(d, b, a, 0, s); 3576 } 3577 3578 static uint64_t fmadd64(uint64_t a, uint64_t b, uint64_t d, float_status *s) 3579 { 3580 return float64_muladd(d, b, a, 0, s); 3581 } 3582 3583 RVVCALL(OPFVV3, vfmadd_vv_h, OP_UUU_H, H2, H2, H2, fmadd16) 3584 RVVCALL(OPFVV3, vfmadd_vv_w, OP_UUU_W, H4, H4, H4, fmadd32) 3585 RVVCALL(OPFVV3, vfmadd_vv_d, OP_UUU_D, H8, H8, H8, fmadd64) 3586 GEN_VEXT_VV_ENV(vfmadd_vv_h, 2, 2, clearh) 3587 GEN_VEXT_VV_ENV(vfmadd_vv_w, 4, 4, clearl) 3588 GEN_VEXT_VV_ENV(vfmadd_vv_d, 8, 8, clearq) 3589 RVVCALL(OPFVF3, vfmadd_vf_h, OP_UUU_H, H2, H2, fmadd16) 3590 RVVCALL(OPFVF3, vfmadd_vf_w, OP_UUU_W, H4, H4, fmadd32) 3591 RVVCALL(OPFVF3, vfmadd_vf_d, OP_UUU_D, H8, H8, fmadd64) 3592 GEN_VEXT_VF(vfmadd_vf_h, 2, 2, clearh) 3593 GEN_VEXT_VF(vfmadd_vf_w, 4, 4, clearl) 3594 GEN_VEXT_VF(vfmadd_vf_d, 8, 8, clearq) 3595 3596 static uint16_t fnmadd16(uint16_t a, uint16_t b, uint16_t d, float_status *s) 3597 { 3598 return float16_muladd(d, b, a, 3599 float_muladd_negate_c | float_muladd_negate_product, s); 3600 } 3601 3602 static uint32_t fnmadd32(uint32_t a, uint32_t b, uint32_t d, float_status *s) 3603 { 3604 return float32_muladd(d, b, a, 3605 float_muladd_negate_c | float_muladd_negate_product, s); 3606 } 3607 3608 static uint64_t fnmadd64(uint64_t a, uint64_t b, uint64_t d, float_status *s) 3609 { 3610 return float64_muladd(d, b, a, 3611 float_muladd_negate_c | float_muladd_negate_product, s); 3612 } 3613 3614 RVVCALL(OPFVV3, vfnmadd_vv_h, OP_UUU_H, H2, H2, H2, fnmadd16) 3615 RVVCALL(OPFVV3, vfnmadd_vv_w, OP_UUU_W, H4, H4, H4, fnmadd32) 3616 RVVCALL(OPFVV3, vfnmadd_vv_d, OP_UUU_D, H8, H8, H8, fnmadd64) 3617 GEN_VEXT_VV_ENV(vfnmadd_vv_h, 2, 2, clearh) 3618 GEN_VEXT_VV_ENV(vfnmadd_vv_w, 4, 4, clearl) 3619 GEN_VEXT_VV_ENV(vfnmadd_vv_d, 8, 8, clearq) 3620 RVVCALL(OPFVF3, vfnmadd_vf_h, OP_UUU_H, H2, H2, fnmadd16) 3621 RVVCALL(OPFVF3, vfnmadd_vf_w, OP_UUU_W, H4, H4, fnmadd32) 3622 RVVCALL(OPFVF3, vfnmadd_vf_d, OP_UUU_D, H8, H8, fnmadd64) 3623 GEN_VEXT_VF(vfnmadd_vf_h, 2, 2, clearh) 3624 GEN_VEXT_VF(vfnmadd_vf_w, 4, 4, clearl) 3625 GEN_VEXT_VF(vfnmadd_vf_d, 8, 8, clearq) 3626 3627 static uint16_t fmsub16(uint16_t a, uint16_t b, uint16_t d, float_status *s) 3628 { 3629 return float16_muladd(d, b, a, float_muladd_negate_c, s); 3630 } 3631 3632 static uint32_t fmsub32(uint32_t a, uint32_t b, uint32_t d, float_status *s) 3633 { 3634 return float32_muladd(d, b, a, float_muladd_negate_c, s); 3635 } 3636 3637 static uint64_t fmsub64(uint64_t a, uint64_t b, uint64_t d, float_status *s) 3638 { 3639 return float64_muladd(d, b, a, float_muladd_negate_c, s); 3640 } 3641 3642 RVVCALL(OPFVV3, vfmsub_vv_h, OP_UUU_H, H2, H2, H2, fmsub16) 3643 RVVCALL(OPFVV3, vfmsub_vv_w, OP_UUU_W, H4, H4, H4, fmsub32) 3644 RVVCALL(OPFVV3, vfmsub_vv_d, OP_UUU_D, H8, H8, H8, fmsub64) 3645 GEN_VEXT_VV_ENV(vfmsub_vv_h, 2, 2, clearh) 3646 GEN_VEXT_VV_ENV(vfmsub_vv_w, 4, 4, clearl) 3647 GEN_VEXT_VV_ENV(vfmsub_vv_d, 8, 8, clearq) 3648 RVVCALL(OPFVF3, vfmsub_vf_h, OP_UUU_H, H2, H2, fmsub16) 3649 RVVCALL(OPFVF3, vfmsub_vf_w, OP_UUU_W, H4, H4, fmsub32) 3650 RVVCALL(OPFVF3, vfmsub_vf_d, OP_UUU_D, H8, H8, fmsub64) 3651 GEN_VEXT_VF(vfmsub_vf_h, 2, 2, clearh) 3652 GEN_VEXT_VF(vfmsub_vf_w, 4, 4, clearl) 3653 GEN_VEXT_VF(vfmsub_vf_d, 8, 8, clearq) 3654 3655 static uint16_t fnmsub16(uint16_t a, uint16_t b, uint16_t d, float_status *s) 3656 { 3657 return float16_muladd(d, b, a, float_muladd_negate_product, s); 3658 } 3659 3660 static uint32_t fnmsub32(uint32_t a, uint32_t b, uint32_t d, float_status *s) 3661 { 3662 return float32_muladd(d, b, a, float_muladd_negate_product, s); 3663 } 3664 3665 static uint64_t fnmsub64(uint64_t a, uint64_t b, uint64_t d, float_status *s) 3666 { 3667 return float64_muladd(d, b, a, float_muladd_negate_product, s); 3668 } 3669 3670 RVVCALL(OPFVV3, vfnmsub_vv_h, OP_UUU_H, H2, H2, H2, fnmsub16) 3671 RVVCALL(OPFVV3, vfnmsub_vv_w, OP_UUU_W, H4, H4, H4, fnmsub32) 3672 RVVCALL(OPFVV3, vfnmsub_vv_d, OP_UUU_D, H8, H8, H8, fnmsub64) 3673 GEN_VEXT_VV_ENV(vfnmsub_vv_h, 2, 2, clearh) 3674 GEN_VEXT_VV_ENV(vfnmsub_vv_w, 4, 4, clearl) 3675 GEN_VEXT_VV_ENV(vfnmsub_vv_d, 8, 8, clearq) 3676 RVVCALL(OPFVF3, vfnmsub_vf_h, OP_UUU_H, H2, H2, fnmsub16) 3677 RVVCALL(OPFVF3, vfnmsub_vf_w, OP_UUU_W, H4, H4, fnmsub32) 3678 RVVCALL(OPFVF3, vfnmsub_vf_d, OP_UUU_D, H8, H8, fnmsub64) 3679 GEN_VEXT_VF(vfnmsub_vf_h, 2, 2, clearh) 3680 GEN_VEXT_VF(vfnmsub_vf_w, 4, 4, clearl) 3681 GEN_VEXT_VF(vfnmsub_vf_d, 8, 8, clearq) 3682 3683 /* Vector Widening Floating-Point Fused Multiply-Add Instructions */ 3684 static uint32_t fwmacc16(uint16_t a, uint16_t b, uint32_t d, float_status *s) 3685 { 3686 return float32_muladd(float16_to_float32(a, true, s), 3687 float16_to_float32(b, true, s), d, 0, s); 3688 } 3689 3690 static uint64_t fwmacc32(uint32_t a, uint32_t b, uint64_t d, float_status *s) 3691 { 3692 return float64_muladd(float32_to_float64(a, s), 3693 float32_to_float64(b, s), d, 0, s); 3694 } 3695 3696 RVVCALL(OPFVV3, vfwmacc_vv_h, WOP_UUU_H, H4, H2, H2, fwmacc16) 3697 RVVCALL(OPFVV3, vfwmacc_vv_w, WOP_UUU_W, H8, H4, H4, fwmacc32) 3698 GEN_VEXT_VV_ENV(vfwmacc_vv_h, 2, 4, clearl) 3699 GEN_VEXT_VV_ENV(vfwmacc_vv_w, 4, 8, clearq) 3700 RVVCALL(OPFVF3, vfwmacc_vf_h, WOP_UUU_H, H4, H2, fwmacc16) 3701 RVVCALL(OPFVF3, vfwmacc_vf_w, WOP_UUU_W, H8, H4, fwmacc32) 3702 GEN_VEXT_VF(vfwmacc_vf_h, 2, 4, clearl) 3703 GEN_VEXT_VF(vfwmacc_vf_w, 4, 8, clearq) 3704 3705 static uint32_t fwnmacc16(uint16_t a, uint16_t b, uint32_t d, float_status *s) 3706 { 3707 return float32_muladd(float16_to_float32(a, true, s), 3708 float16_to_float32(b, true, s), d, 3709 float_muladd_negate_c | float_muladd_negate_product, s); 3710 } 3711 3712 static uint64_t fwnmacc32(uint32_t a, uint32_t b, uint64_t d, float_status *s) 3713 { 3714 return float64_muladd(float32_to_float64(a, s), 3715 float32_to_float64(b, s), d, 3716 float_muladd_negate_c | float_muladd_negate_product, s); 3717 } 3718 3719 RVVCALL(OPFVV3, vfwnmacc_vv_h, WOP_UUU_H, H4, H2, H2, fwnmacc16) 3720 RVVCALL(OPFVV3, vfwnmacc_vv_w, WOP_UUU_W, H8, H4, H4, fwnmacc32) 3721 GEN_VEXT_VV_ENV(vfwnmacc_vv_h, 2, 4, clearl) 3722 GEN_VEXT_VV_ENV(vfwnmacc_vv_w, 4, 8, clearq) 3723 RVVCALL(OPFVF3, vfwnmacc_vf_h, WOP_UUU_H, H4, H2, fwnmacc16) 3724 RVVCALL(OPFVF3, vfwnmacc_vf_w, WOP_UUU_W, H8, H4, fwnmacc32) 3725 GEN_VEXT_VF(vfwnmacc_vf_h, 2, 4, clearl) 3726 GEN_VEXT_VF(vfwnmacc_vf_w, 4, 8, clearq) 3727 3728 static uint32_t fwmsac16(uint16_t a, uint16_t b, uint32_t d, float_status *s) 3729 { 3730 return float32_muladd(float16_to_float32(a, true, s), 3731 float16_to_float32(b, true, s), d, 3732 float_muladd_negate_c, s); 3733 } 3734 3735 static uint64_t fwmsac32(uint32_t a, uint32_t b, uint64_t d, float_status *s) 3736 { 3737 return float64_muladd(float32_to_float64(a, s), 3738 float32_to_float64(b, s), d, 3739 float_muladd_negate_c, s); 3740 } 3741 3742 RVVCALL(OPFVV3, vfwmsac_vv_h, WOP_UUU_H, H4, H2, H2, fwmsac16) 3743 RVVCALL(OPFVV3, vfwmsac_vv_w, WOP_UUU_W, H8, H4, H4, fwmsac32) 3744 GEN_VEXT_VV_ENV(vfwmsac_vv_h, 2, 4, clearl) 3745 GEN_VEXT_VV_ENV(vfwmsac_vv_w, 4, 8, clearq) 3746 RVVCALL(OPFVF3, vfwmsac_vf_h, WOP_UUU_H, H4, H2, fwmsac16) 3747 RVVCALL(OPFVF3, vfwmsac_vf_w, WOP_UUU_W, H8, H4, fwmsac32) 3748 GEN_VEXT_VF(vfwmsac_vf_h, 2, 4, clearl) 3749 GEN_VEXT_VF(vfwmsac_vf_w, 4, 8, clearq) 3750 3751 static uint32_t fwnmsac16(uint16_t a, uint16_t b, uint32_t d, float_status *s) 3752 { 3753 return float32_muladd(float16_to_float32(a, true, s), 3754 float16_to_float32(b, true, s), d, 3755 float_muladd_negate_product, s); 3756 } 3757 3758 static uint64_t fwnmsac32(uint32_t a, uint32_t b, uint64_t d, float_status *s) 3759 { 3760 return float64_muladd(float32_to_float64(a, s), 3761 float32_to_float64(b, s), d, 3762 float_muladd_negate_product, s); 3763 } 3764 3765 RVVCALL(OPFVV3, vfwnmsac_vv_h, WOP_UUU_H, H4, H2, H2, fwnmsac16) 3766 RVVCALL(OPFVV3, vfwnmsac_vv_w, WOP_UUU_W, H8, H4, H4, fwnmsac32) 3767 GEN_VEXT_VV_ENV(vfwnmsac_vv_h, 2, 4, clearl) 3768 GEN_VEXT_VV_ENV(vfwnmsac_vv_w, 4, 8, clearq) 3769 RVVCALL(OPFVF3, vfwnmsac_vf_h, WOP_UUU_H, H4, H2, fwnmsac16) 3770 RVVCALL(OPFVF3, vfwnmsac_vf_w, WOP_UUU_W, H8, H4, fwnmsac32) 3771 GEN_VEXT_VF(vfwnmsac_vf_h, 2, 4, clearl) 3772 GEN_VEXT_VF(vfwnmsac_vf_w, 4, 8, clearq) 3773 3774 /* Vector Floating-Point Square-Root Instruction */ 3775 /* (TD, T2, TX2) */ 3776 #define OP_UU_H uint16_t, uint16_t, uint16_t 3777 #define OP_UU_W uint32_t, uint32_t, uint32_t 3778 #define OP_UU_D uint64_t, uint64_t, uint64_t 3779 3780 #define OPFVV1(NAME, TD, T2, TX2, HD, HS2, OP) \ 3781 static void do_##NAME(void *vd, void *vs2, int i, \ 3782 CPURISCVState *env) \ 3783 { \ 3784 TX2 s2 = *((T2 *)vs2 + HS2(i)); \ 3785 *((TD *)vd + HD(i)) = OP(s2, &env->fp_status); \ 3786 } 3787 3788 #define GEN_VEXT_V_ENV(NAME, ESZ, DSZ, CLEAR_FN) \ 3789 void HELPER(NAME)(void *vd, void *v0, void *vs2, \ 3790 CPURISCVState *env, uint32_t desc) \ 3791 { \ 3792 uint32_t vlmax = vext_maxsz(desc) / ESZ; \ 3793 uint32_t mlen = vext_mlen(desc); \ 3794 uint32_t vm = vext_vm(desc); \ 3795 uint32_t vl = env->vl; \ 3796 uint32_t i; \ 3797 \ 3798 if (vl == 0) { \ 3799 return; \ 3800 } \ 3801 for (i = 0; i < vl; i++) { \ 3802 if (!vm && !vext_elem_mask(v0, mlen, i)) { \ 3803 continue; \ 3804 } \ 3805 do_##NAME(vd, vs2, i, env); \ 3806 } \ 3807 CLEAR_FN(vd, vl, vl * DSZ, vlmax * DSZ); \ 3808 } 3809 3810 RVVCALL(OPFVV1, vfsqrt_v_h, OP_UU_H, H2, H2, float16_sqrt) 3811 RVVCALL(OPFVV1, vfsqrt_v_w, OP_UU_W, H4, H4, float32_sqrt) 3812 RVVCALL(OPFVV1, vfsqrt_v_d, OP_UU_D, H8, H8, float64_sqrt) 3813 GEN_VEXT_V_ENV(vfsqrt_v_h, 2, 2, clearh) 3814 GEN_VEXT_V_ENV(vfsqrt_v_w, 4, 4, clearl) 3815 GEN_VEXT_V_ENV(vfsqrt_v_d, 8, 8, clearq) 3816 3817 /* Vector Floating-Point MIN/MAX Instructions */ 3818 RVVCALL(OPFVV2, vfmin_vv_h, OP_UUU_H, H2, H2, H2, float16_minnum) 3819 RVVCALL(OPFVV2, vfmin_vv_w, OP_UUU_W, H4, H4, H4, float32_minnum) 3820 RVVCALL(OPFVV2, vfmin_vv_d, OP_UUU_D, H8, H8, H8, float64_minnum) 3821 GEN_VEXT_VV_ENV(vfmin_vv_h, 2, 2, clearh) 3822 GEN_VEXT_VV_ENV(vfmin_vv_w, 4, 4, clearl) 3823 GEN_VEXT_VV_ENV(vfmin_vv_d, 8, 8, clearq) 3824 RVVCALL(OPFVF2, vfmin_vf_h, OP_UUU_H, H2, H2, float16_minnum) 3825 RVVCALL(OPFVF2, vfmin_vf_w, OP_UUU_W, H4, H4, float32_minnum) 3826 RVVCALL(OPFVF2, vfmin_vf_d, OP_UUU_D, H8, H8, float64_minnum) 3827 GEN_VEXT_VF(vfmin_vf_h, 2, 2, clearh) 3828 GEN_VEXT_VF(vfmin_vf_w, 4, 4, clearl) 3829 GEN_VEXT_VF(vfmin_vf_d, 8, 8, clearq) 3830 3831 RVVCALL(OPFVV2, vfmax_vv_h, OP_UUU_H, H2, H2, H2, float16_maxnum) 3832 RVVCALL(OPFVV2, vfmax_vv_w, OP_UUU_W, H4, H4, H4, float32_maxnum) 3833 RVVCALL(OPFVV2, vfmax_vv_d, OP_UUU_D, H8, H8, H8, float64_maxnum) 3834 GEN_VEXT_VV_ENV(vfmax_vv_h, 2, 2, clearh) 3835 GEN_VEXT_VV_ENV(vfmax_vv_w, 4, 4, clearl) 3836 GEN_VEXT_VV_ENV(vfmax_vv_d, 8, 8, clearq) 3837 RVVCALL(OPFVF2, vfmax_vf_h, OP_UUU_H, H2, H2, float16_maxnum) 3838 RVVCALL(OPFVF2, vfmax_vf_w, OP_UUU_W, H4, H4, float32_maxnum) 3839 RVVCALL(OPFVF2, vfmax_vf_d, OP_UUU_D, H8, H8, float64_maxnum) 3840 GEN_VEXT_VF(vfmax_vf_h, 2, 2, clearh) 3841 GEN_VEXT_VF(vfmax_vf_w, 4, 4, clearl) 3842 GEN_VEXT_VF(vfmax_vf_d, 8, 8, clearq) 3843 3844 /* Vector Floating-Point Sign-Injection Instructions */ 3845 static uint16_t fsgnj16(uint16_t a, uint16_t b, float_status *s) 3846 { 3847 return deposit64(b, 0, 15, a); 3848 } 3849 3850 static uint32_t fsgnj32(uint32_t a, uint32_t b, float_status *s) 3851 { 3852 return deposit64(b, 0, 31, a); 3853 } 3854 3855 static uint64_t fsgnj64(uint64_t a, uint64_t b, float_status *s) 3856 { 3857 return deposit64(b, 0, 63, a); 3858 } 3859 3860 RVVCALL(OPFVV2, vfsgnj_vv_h, OP_UUU_H, H2, H2, H2, fsgnj16) 3861 RVVCALL(OPFVV2, vfsgnj_vv_w, OP_UUU_W, H4, H4, H4, fsgnj32) 3862 RVVCALL(OPFVV2, vfsgnj_vv_d, OP_UUU_D, H8, H8, H8, fsgnj64) 3863 GEN_VEXT_VV_ENV(vfsgnj_vv_h, 2, 2, clearh) 3864 GEN_VEXT_VV_ENV(vfsgnj_vv_w, 4, 4, clearl) 3865 GEN_VEXT_VV_ENV(vfsgnj_vv_d, 8, 8, clearq) 3866 RVVCALL(OPFVF2, vfsgnj_vf_h, OP_UUU_H, H2, H2, fsgnj16) 3867 RVVCALL(OPFVF2, vfsgnj_vf_w, OP_UUU_W, H4, H4, fsgnj32) 3868 RVVCALL(OPFVF2, vfsgnj_vf_d, OP_UUU_D, H8, H8, fsgnj64) 3869 GEN_VEXT_VF(vfsgnj_vf_h, 2, 2, clearh) 3870 GEN_VEXT_VF(vfsgnj_vf_w, 4, 4, clearl) 3871 GEN_VEXT_VF(vfsgnj_vf_d, 8, 8, clearq) 3872 3873 static uint16_t fsgnjn16(uint16_t a, uint16_t b, float_status *s) 3874 { 3875 return deposit64(~b, 0, 15, a); 3876 } 3877 3878 static uint32_t fsgnjn32(uint32_t a, uint32_t b, float_status *s) 3879 { 3880 return deposit64(~b, 0, 31, a); 3881 } 3882 3883 static uint64_t fsgnjn64(uint64_t a, uint64_t b, float_status *s) 3884 { 3885 return deposit64(~b, 0, 63, a); 3886 } 3887 3888 RVVCALL(OPFVV2, vfsgnjn_vv_h, OP_UUU_H, H2, H2, H2, fsgnjn16) 3889 RVVCALL(OPFVV2, vfsgnjn_vv_w, OP_UUU_W, H4, H4, H4, fsgnjn32) 3890 RVVCALL(OPFVV2, vfsgnjn_vv_d, OP_UUU_D, H8, H8, H8, fsgnjn64) 3891 GEN_VEXT_VV_ENV(vfsgnjn_vv_h, 2, 2, clearh) 3892 GEN_VEXT_VV_ENV(vfsgnjn_vv_w, 4, 4, clearl) 3893 GEN_VEXT_VV_ENV(vfsgnjn_vv_d, 8, 8, clearq) 3894 RVVCALL(OPFVF2, vfsgnjn_vf_h, OP_UUU_H, H2, H2, fsgnjn16) 3895 RVVCALL(OPFVF2, vfsgnjn_vf_w, OP_UUU_W, H4, H4, fsgnjn32) 3896 RVVCALL(OPFVF2, vfsgnjn_vf_d, OP_UUU_D, H8, H8, fsgnjn64) 3897 GEN_VEXT_VF(vfsgnjn_vf_h, 2, 2, clearh) 3898 GEN_VEXT_VF(vfsgnjn_vf_w, 4, 4, clearl) 3899 GEN_VEXT_VF(vfsgnjn_vf_d, 8, 8, clearq) 3900 3901 static uint16_t fsgnjx16(uint16_t a, uint16_t b, float_status *s) 3902 { 3903 return deposit64(b ^ a, 0, 15, a); 3904 } 3905 3906 static uint32_t fsgnjx32(uint32_t a, uint32_t b, float_status *s) 3907 { 3908 return deposit64(b ^ a, 0, 31, a); 3909 } 3910 3911 static uint64_t fsgnjx64(uint64_t a, uint64_t b, float_status *s) 3912 { 3913 return deposit64(b ^ a, 0, 63, a); 3914 } 3915 3916 RVVCALL(OPFVV2, vfsgnjx_vv_h, OP_UUU_H, H2, H2, H2, fsgnjx16) 3917 RVVCALL(OPFVV2, vfsgnjx_vv_w, OP_UUU_W, H4, H4, H4, fsgnjx32) 3918 RVVCALL(OPFVV2, vfsgnjx_vv_d, OP_UUU_D, H8, H8, H8, fsgnjx64) 3919 GEN_VEXT_VV_ENV(vfsgnjx_vv_h, 2, 2, clearh) 3920 GEN_VEXT_VV_ENV(vfsgnjx_vv_w, 4, 4, clearl) 3921 GEN_VEXT_VV_ENV(vfsgnjx_vv_d, 8, 8, clearq) 3922 RVVCALL(OPFVF2, vfsgnjx_vf_h, OP_UUU_H, H2, H2, fsgnjx16) 3923 RVVCALL(OPFVF2, vfsgnjx_vf_w, OP_UUU_W, H4, H4, fsgnjx32) 3924 RVVCALL(OPFVF2, vfsgnjx_vf_d, OP_UUU_D, H8, H8, fsgnjx64) 3925 GEN_VEXT_VF(vfsgnjx_vf_h, 2, 2, clearh) 3926 GEN_VEXT_VF(vfsgnjx_vf_w, 4, 4, clearl) 3927 GEN_VEXT_VF(vfsgnjx_vf_d, 8, 8, clearq) 3928 3929 /* Vector Floating-Point Compare Instructions */ 3930 #define GEN_VEXT_CMP_VV_ENV(NAME, ETYPE, H, DO_OP) \ 3931 void HELPER(NAME)(void *vd, void *v0, void *vs1, void *vs2, \ 3932 CPURISCVState *env, uint32_t desc) \ 3933 { \ 3934 uint32_t mlen = vext_mlen(desc); \ 3935 uint32_t vm = vext_vm(desc); \ 3936 uint32_t vl = env->vl; \ 3937 uint32_t vlmax = vext_maxsz(desc) / sizeof(ETYPE); \ 3938 uint32_t i; \ 3939 \ 3940 for (i = 0; i < vl; i++) { \ 3941 ETYPE s1 = *((ETYPE *)vs1 + H(i)); \ 3942 ETYPE s2 = *((ETYPE *)vs2 + H(i)); \ 3943 if (!vm && !vext_elem_mask(v0, mlen, i)) { \ 3944 continue; \ 3945 } \ 3946 vext_set_elem_mask(vd, mlen, i, \ 3947 DO_OP(s2, s1, &env->fp_status)); \ 3948 } \ 3949 for (; i < vlmax; i++) { \ 3950 vext_set_elem_mask(vd, mlen, i, 0); \ 3951 } \ 3952 } 3953 3954 GEN_VEXT_CMP_VV_ENV(vmfeq_vv_h, uint16_t, H2, float16_eq_quiet) 3955 GEN_VEXT_CMP_VV_ENV(vmfeq_vv_w, uint32_t, H4, float32_eq_quiet) 3956 GEN_VEXT_CMP_VV_ENV(vmfeq_vv_d, uint64_t, H8, float64_eq_quiet) 3957 3958 #define GEN_VEXT_CMP_VF(NAME, ETYPE, H, DO_OP) \ 3959 void HELPER(NAME)(void *vd, void *v0, uint64_t s1, void *vs2, \ 3960 CPURISCVState *env, uint32_t desc) \ 3961 { \ 3962 uint32_t mlen = vext_mlen(desc); \ 3963 uint32_t vm = vext_vm(desc); \ 3964 uint32_t vl = env->vl; \ 3965 uint32_t vlmax = vext_maxsz(desc) / sizeof(ETYPE); \ 3966 uint32_t i; \ 3967 \ 3968 for (i = 0; i < vl; i++) { \ 3969 ETYPE s2 = *((ETYPE *)vs2 + H(i)); \ 3970 if (!vm && !vext_elem_mask(v0, mlen, i)) { \ 3971 continue; \ 3972 } \ 3973 vext_set_elem_mask(vd, mlen, i, \ 3974 DO_OP(s2, (ETYPE)s1, &env->fp_status)); \ 3975 } \ 3976 for (; i < vlmax; i++) { \ 3977 vext_set_elem_mask(vd, mlen, i, 0); \ 3978 } \ 3979 } 3980 3981 GEN_VEXT_CMP_VF(vmfeq_vf_h, uint16_t, H2, float16_eq_quiet) 3982 GEN_VEXT_CMP_VF(vmfeq_vf_w, uint32_t, H4, float32_eq_quiet) 3983 GEN_VEXT_CMP_VF(vmfeq_vf_d, uint64_t, H8, float64_eq_quiet) 3984 3985 static bool vmfne16(uint16_t a, uint16_t b, float_status *s) 3986 { 3987 FloatRelation compare = float16_compare_quiet(a, b, s); 3988 return compare != float_relation_equal; 3989 } 3990 3991 static bool vmfne32(uint32_t a, uint32_t b, float_status *s) 3992 { 3993 FloatRelation compare = float32_compare_quiet(a, b, s); 3994 return compare != float_relation_equal; 3995 } 3996 3997 static bool vmfne64(uint64_t a, uint64_t b, float_status *s) 3998 { 3999 FloatRelation compare = float64_compare_quiet(a, b, s); 4000 return compare != float_relation_equal; 4001 } 4002 4003 GEN_VEXT_CMP_VV_ENV(vmfne_vv_h, uint16_t, H2, vmfne16) 4004 GEN_VEXT_CMP_VV_ENV(vmfne_vv_w, uint32_t, H4, vmfne32) 4005 GEN_VEXT_CMP_VV_ENV(vmfne_vv_d, uint64_t, H8, vmfne64) 4006 GEN_VEXT_CMP_VF(vmfne_vf_h, uint16_t, H2, vmfne16) 4007 GEN_VEXT_CMP_VF(vmfne_vf_w, uint32_t, H4, vmfne32) 4008 GEN_VEXT_CMP_VF(vmfne_vf_d, uint64_t, H8, vmfne64) 4009 4010 GEN_VEXT_CMP_VV_ENV(vmflt_vv_h, uint16_t, H2, float16_lt) 4011 GEN_VEXT_CMP_VV_ENV(vmflt_vv_w, uint32_t, H4, float32_lt) 4012 GEN_VEXT_CMP_VV_ENV(vmflt_vv_d, uint64_t, H8, float64_lt) 4013 GEN_VEXT_CMP_VF(vmflt_vf_h, uint16_t, H2, float16_lt) 4014 GEN_VEXT_CMP_VF(vmflt_vf_w, uint32_t, H4, float32_lt) 4015 GEN_VEXT_CMP_VF(vmflt_vf_d, uint64_t, H8, float64_lt) 4016 4017 GEN_VEXT_CMP_VV_ENV(vmfle_vv_h, uint16_t, H2, float16_le) 4018 GEN_VEXT_CMP_VV_ENV(vmfle_vv_w, uint32_t, H4, float32_le) 4019 GEN_VEXT_CMP_VV_ENV(vmfle_vv_d, uint64_t, H8, float64_le) 4020 GEN_VEXT_CMP_VF(vmfle_vf_h, uint16_t, H2, float16_le) 4021 GEN_VEXT_CMP_VF(vmfle_vf_w, uint32_t, H4, float32_le) 4022 GEN_VEXT_CMP_VF(vmfle_vf_d, uint64_t, H8, float64_le) 4023 4024 static bool vmfgt16(uint16_t a, uint16_t b, float_status *s) 4025 { 4026 FloatRelation compare = float16_compare(a, b, s); 4027 return compare == float_relation_greater; 4028 } 4029 4030 static bool vmfgt32(uint32_t a, uint32_t b, float_status *s) 4031 { 4032 FloatRelation compare = float32_compare(a, b, s); 4033 return compare == float_relation_greater; 4034 } 4035 4036 static bool vmfgt64(uint64_t a, uint64_t b, float_status *s) 4037 { 4038 FloatRelation compare = float64_compare(a, b, s); 4039 return compare == float_relation_greater; 4040 } 4041 4042 GEN_VEXT_CMP_VF(vmfgt_vf_h, uint16_t, H2, vmfgt16) 4043 GEN_VEXT_CMP_VF(vmfgt_vf_w, uint32_t, H4, vmfgt32) 4044 GEN_VEXT_CMP_VF(vmfgt_vf_d, uint64_t, H8, vmfgt64) 4045 4046 static bool vmfge16(uint16_t a, uint16_t b, float_status *s) 4047 { 4048 FloatRelation compare = float16_compare(a, b, s); 4049 return compare == float_relation_greater || 4050 compare == float_relation_equal; 4051 } 4052 4053 static bool vmfge32(uint32_t a, uint32_t b, float_status *s) 4054 { 4055 FloatRelation compare = float32_compare(a, b, s); 4056 return compare == float_relation_greater || 4057 compare == float_relation_equal; 4058 } 4059 4060 static bool vmfge64(uint64_t a, uint64_t b, float_status *s) 4061 { 4062 FloatRelation compare = float64_compare(a, b, s); 4063 return compare == float_relation_greater || 4064 compare == float_relation_equal; 4065 } 4066 4067 GEN_VEXT_CMP_VF(vmfge_vf_h, uint16_t, H2, vmfge16) 4068 GEN_VEXT_CMP_VF(vmfge_vf_w, uint32_t, H4, vmfge32) 4069 GEN_VEXT_CMP_VF(vmfge_vf_d, uint64_t, H8, vmfge64) 4070 4071 GEN_VEXT_CMP_VV_ENV(vmford_vv_h, uint16_t, H2, !float16_unordered_quiet) 4072 GEN_VEXT_CMP_VV_ENV(vmford_vv_w, uint32_t, H4, !float32_unordered_quiet) 4073 GEN_VEXT_CMP_VV_ENV(vmford_vv_d, uint64_t, H8, !float64_unordered_quiet) 4074 GEN_VEXT_CMP_VF(vmford_vf_h, uint16_t, H2, !float16_unordered_quiet) 4075 GEN_VEXT_CMP_VF(vmford_vf_w, uint32_t, H4, !float32_unordered_quiet) 4076 GEN_VEXT_CMP_VF(vmford_vf_d, uint64_t, H8, !float64_unordered_quiet) 4077 4078 /* Vector Floating-Point Classify Instruction */ 4079 #define OPIVV1(NAME, TD, T2, TX2, HD, HS2, OP) \ 4080 static void do_##NAME(void *vd, void *vs2, int i) \ 4081 { \ 4082 TX2 s2 = *((T2 *)vs2 + HS2(i)); \ 4083 *((TD *)vd + HD(i)) = OP(s2); \ 4084 } 4085 4086 #define GEN_VEXT_V(NAME, ESZ, DSZ, CLEAR_FN) \ 4087 void HELPER(NAME)(void *vd, void *v0, void *vs2, \ 4088 CPURISCVState *env, uint32_t desc) \ 4089 { \ 4090 uint32_t vlmax = vext_maxsz(desc) / ESZ; \ 4091 uint32_t mlen = vext_mlen(desc); \ 4092 uint32_t vm = vext_vm(desc); \ 4093 uint32_t vl = env->vl; \ 4094 uint32_t i; \ 4095 \ 4096 for (i = 0; i < vl; i++) { \ 4097 if (!vm && !vext_elem_mask(v0, mlen, i)) { \ 4098 continue; \ 4099 } \ 4100 do_##NAME(vd, vs2, i); \ 4101 } \ 4102 CLEAR_FN(vd, vl, vl * DSZ, vlmax * DSZ); \ 4103 } 4104 4105 target_ulong fclass_h(uint64_t frs1) 4106 { 4107 float16 f = frs1; 4108 bool sign = float16_is_neg(f); 4109 4110 if (float16_is_infinity(f)) { 4111 return sign ? 1 << 0 : 1 << 7; 4112 } else if (float16_is_zero(f)) { 4113 return sign ? 1 << 3 : 1 << 4; 4114 } else if (float16_is_zero_or_denormal(f)) { 4115 return sign ? 1 << 2 : 1 << 5; 4116 } else if (float16_is_any_nan(f)) { 4117 float_status s = { }; /* for snan_bit_is_one */ 4118 return float16_is_quiet_nan(f, &s) ? 1 << 9 : 1 << 8; 4119 } else { 4120 return sign ? 1 << 1 : 1 << 6; 4121 } 4122 } 4123 4124 target_ulong fclass_s(uint64_t frs1) 4125 { 4126 float32 f = frs1; 4127 bool sign = float32_is_neg(f); 4128 4129 if (float32_is_infinity(f)) { 4130 return sign ? 1 << 0 : 1 << 7; 4131 } else if (float32_is_zero(f)) { 4132 return sign ? 1 << 3 : 1 << 4; 4133 } else if (float32_is_zero_or_denormal(f)) { 4134 return sign ? 1 << 2 : 1 << 5; 4135 } else if (float32_is_any_nan(f)) { 4136 float_status s = { }; /* for snan_bit_is_one */ 4137 return float32_is_quiet_nan(f, &s) ? 1 << 9 : 1 << 8; 4138 } else { 4139 return sign ? 1 << 1 : 1 << 6; 4140 } 4141 } 4142 4143 target_ulong fclass_d(uint64_t frs1) 4144 { 4145 float64 f = frs1; 4146 bool sign = float64_is_neg(f); 4147 4148 if (float64_is_infinity(f)) { 4149 return sign ? 1 << 0 : 1 << 7; 4150 } else if (float64_is_zero(f)) { 4151 return sign ? 1 << 3 : 1 << 4; 4152 } else if (float64_is_zero_or_denormal(f)) { 4153 return sign ? 1 << 2 : 1 << 5; 4154 } else if (float64_is_any_nan(f)) { 4155 float_status s = { }; /* for snan_bit_is_one */ 4156 return float64_is_quiet_nan(f, &s) ? 1 << 9 : 1 << 8; 4157 } else { 4158 return sign ? 1 << 1 : 1 << 6; 4159 } 4160 } 4161 4162 RVVCALL(OPIVV1, vfclass_v_h, OP_UU_H, H2, H2, fclass_h) 4163 RVVCALL(OPIVV1, vfclass_v_w, OP_UU_W, H4, H4, fclass_s) 4164 RVVCALL(OPIVV1, vfclass_v_d, OP_UU_D, H8, H8, fclass_d) 4165 GEN_VEXT_V(vfclass_v_h, 2, 2, clearh) 4166 GEN_VEXT_V(vfclass_v_w, 4, 4, clearl) 4167 GEN_VEXT_V(vfclass_v_d, 8, 8, clearq) 4168 4169 /* Vector Floating-Point Merge Instruction */ 4170 #define GEN_VFMERGE_VF(NAME, ETYPE, H, CLEAR_FN) \ 4171 void HELPER(NAME)(void *vd, void *v0, uint64_t s1, void *vs2, \ 4172 CPURISCVState *env, uint32_t desc) \ 4173 { \ 4174 uint32_t mlen = vext_mlen(desc); \ 4175 uint32_t vm = vext_vm(desc); \ 4176 uint32_t vl = env->vl; \ 4177 uint32_t esz = sizeof(ETYPE); \ 4178 uint32_t vlmax = vext_maxsz(desc) / esz; \ 4179 uint32_t i; \ 4180 \ 4181 for (i = 0; i < vl; i++) { \ 4182 ETYPE s2 = *((ETYPE *)vs2 + H(i)); \ 4183 *((ETYPE *)vd + H(i)) \ 4184 = (!vm && !vext_elem_mask(v0, mlen, i) ? s2 : s1); \ 4185 } \ 4186 CLEAR_FN(vd, vl, vl * esz, vlmax * esz); \ 4187 } 4188 4189 GEN_VFMERGE_VF(vfmerge_vfm_h, int16_t, H2, clearh) 4190 GEN_VFMERGE_VF(vfmerge_vfm_w, int32_t, H4, clearl) 4191 GEN_VFMERGE_VF(vfmerge_vfm_d, int64_t, H8, clearq) 4192 4193 /* Single-Width Floating-Point/Integer Type-Convert Instructions */ 4194 /* vfcvt.xu.f.v vd, vs2, vm # Convert float to unsigned integer. */ 4195 RVVCALL(OPFVV1, vfcvt_xu_f_v_h, OP_UU_H, H2, H2, float16_to_uint16) 4196 RVVCALL(OPFVV1, vfcvt_xu_f_v_w, OP_UU_W, H4, H4, float32_to_uint32) 4197 RVVCALL(OPFVV1, vfcvt_xu_f_v_d, OP_UU_D, H8, H8, float64_to_uint64) 4198 GEN_VEXT_V_ENV(vfcvt_xu_f_v_h, 2, 2, clearh) 4199 GEN_VEXT_V_ENV(vfcvt_xu_f_v_w, 4, 4, clearl) 4200 GEN_VEXT_V_ENV(vfcvt_xu_f_v_d, 8, 8, clearq) 4201 4202 /* vfcvt.x.f.v vd, vs2, vm # Convert float to signed integer. */ 4203 RVVCALL(OPFVV1, vfcvt_x_f_v_h, OP_UU_H, H2, H2, float16_to_int16) 4204 RVVCALL(OPFVV1, vfcvt_x_f_v_w, OP_UU_W, H4, H4, float32_to_int32) 4205 RVVCALL(OPFVV1, vfcvt_x_f_v_d, OP_UU_D, H8, H8, float64_to_int64) 4206 GEN_VEXT_V_ENV(vfcvt_x_f_v_h, 2, 2, clearh) 4207 GEN_VEXT_V_ENV(vfcvt_x_f_v_w, 4, 4, clearl) 4208 GEN_VEXT_V_ENV(vfcvt_x_f_v_d, 8, 8, clearq) 4209 4210 /* vfcvt.f.xu.v vd, vs2, vm # Convert unsigned integer to float. */ 4211 RVVCALL(OPFVV1, vfcvt_f_xu_v_h, OP_UU_H, H2, H2, uint16_to_float16) 4212 RVVCALL(OPFVV1, vfcvt_f_xu_v_w, OP_UU_W, H4, H4, uint32_to_float32) 4213 RVVCALL(OPFVV1, vfcvt_f_xu_v_d, OP_UU_D, H8, H8, uint64_to_float64) 4214 GEN_VEXT_V_ENV(vfcvt_f_xu_v_h, 2, 2, clearh) 4215 GEN_VEXT_V_ENV(vfcvt_f_xu_v_w, 4, 4, clearl) 4216 GEN_VEXT_V_ENV(vfcvt_f_xu_v_d, 8, 8, clearq) 4217 4218 /* vfcvt.f.x.v vd, vs2, vm # Convert integer to float. */ 4219 RVVCALL(OPFVV1, vfcvt_f_x_v_h, OP_UU_H, H2, H2, int16_to_float16) 4220 RVVCALL(OPFVV1, vfcvt_f_x_v_w, OP_UU_W, H4, H4, int32_to_float32) 4221 RVVCALL(OPFVV1, vfcvt_f_x_v_d, OP_UU_D, H8, H8, int64_to_float64) 4222 GEN_VEXT_V_ENV(vfcvt_f_x_v_h, 2, 2, clearh) 4223 GEN_VEXT_V_ENV(vfcvt_f_x_v_w, 4, 4, clearl) 4224 GEN_VEXT_V_ENV(vfcvt_f_x_v_d, 8, 8, clearq) 4225 4226 /* Widening Floating-Point/Integer Type-Convert Instructions */ 4227 /* (TD, T2, TX2) */ 4228 #define WOP_UU_H uint32_t, uint16_t, uint16_t 4229 #define WOP_UU_W uint64_t, uint32_t, uint32_t 4230 /* vfwcvt.xu.f.v vd, vs2, vm # Convert float to double-width unsigned integer.*/ 4231 RVVCALL(OPFVV1, vfwcvt_xu_f_v_h, WOP_UU_H, H4, H2, float16_to_uint32) 4232 RVVCALL(OPFVV1, vfwcvt_xu_f_v_w, WOP_UU_W, H8, H4, float32_to_uint64) 4233 GEN_VEXT_V_ENV(vfwcvt_xu_f_v_h, 2, 4, clearl) 4234 GEN_VEXT_V_ENV(vfwcvt_xu_f_v_w, 4, 8, clearq) 4235 4236 /* vfwcvt.x.f.v vd, vs2, vm # Convert float to double-width signed integer. */ 4237 RVVCALL(OPFVV1, vfwcvt_x_f_v_h, WOP_UU_H, H4, H2, float16_to_int32) 4238 RVVCALL(OPFVV1, vfwcvt_x_f_v_w, WOP_UU_W, H8, H4, float32_to_int64) 4239 GEN_VEXT_V_ENV(vfwcvt_x_f_v_h, 2, 4, clearl) 4240 GEN_VEXT_V_ENV(vfwcvt_x_f_v_w, 4, 8, clearq) 4241 4242 /* vfwcvt.f.xu.v vd, vs2, vm # Convert unsigned integer to double-width float */ 4243 RVVCALL(OPFVV1, vfwcvt_f_xu_v_h, WOP_UU_H, H4, H2, uint16_to_float32) 4244 RVVCALL(OPFVV1, vfwcvt_f_xu_v_w, WOP_UU_W, H8, H4, uint32_to_float64) 4245 GEN_VEXT_V_ENV(vfwcvt_f_xu_v_h, 2, 4, clearl) 4246 GEN_VEXT_V_ENV(vfwcvt_f_xu_v_w, 4, 8, clearq) 4247 4248 /* vfwcvt.f.x.v vd, vs2, vm # Convert integer to double-width float. */ 4249 RVVCALL(OPFVV1, vfwcvt_f_x_v_h, WOP_UU_H, H4, H2, int16_to_float32) 4250 RVVCALL(OPFVV1, vfwcvt_f_x_v_w, WOP_UU_W, H8, H4, int32_to_float64) 4251 GEN_VEXT_V_ENV(vfwcvt_f_x_v_h, 2, 4, clearl) 4252 GEN_VEXT_V_ENV(vfwcvt_f_x_v_w, 4, 8, clearq) 4253 4254 /* 4255 * vfwcvt.f.f.v vd, vs2, vm # 4256 * Convert single-width float to double-width float. 4257 */ 4258 static uint32_t vfwcvtffv16(uint16_t a, float_status *s) 4259 { 4260 return float16_to_float32(a, true, s); 4261 } 4262 4263 RVVCALL(OPFVV1, vfwcvt_f_f_v_h, WOP_UU_H, H4, H2, vfwcvtffv16) 4264 RVVCALL(OPFVV1, vfwcvt_f_f_v_w, WOP_UU_W, H8, H4, float32_to_float64) 4265 GEN_VEXT_V_ENV(vfwcvt_f_f_v_h, 2, 4, clearl) 4266 GEN_VEXT_V_ENV(vfwcvt_f_f_v_w, 4, 8, clearq) 4267 4268 /* Narrowing Floating-Point/Integer Type-Convert Instructions */ 4269 /* (TD, T2, TX2) */ 4270 #define NOP_UU_H uint16_t, uint32_t, uint32_t 4271 #define NOP_UU_W uint32_t, uint64_t, uint64_t 4272 /* vfncvt.xu.f.v vd, vs2, vm # Convert float to unsigned integer. */ 4273 RVVCALL(OPFVV1, vfncvt_xu_f_v_h, NOP_UU_H, H2, H4, float32_to_uint16) 4274 RVVCALL(OPFVV1, vfncvt_xu_f_v_w, NOP_UU_W, H4, H8, float64_to_uint32) 4275 GEN_VEXT_V_ENV(vfncvt_xu_f_v_h, 2, 2, clearh) 4276 GEN_VEXT_V_ENV(vfncvt_xu_f_v_w, 4, 4, clearl) 4277 4278 /* vfncvt.x.f.v vd, vs2, vm # Convert double-width float to signed integer. */ 4279 RVVCALL(OPFVV1, vfncvt_x_f_v_h, NOP_UU_H, H2, H4, float32_to_int16) 4280 RVVCALL(OPFVV1, vfncvt_x_f_v_w, NOP_UU_W, H4, H8, float64_to_int32) 4281 GEN_VEXT_V_ENV(vfncvt_x_f_v_h, 2, 2, clearh) 4282 GEN_VEXT_V_ENV(vfncvt_x_f_v_w, 4, 4, clearl) 4283 4284 /* vfncvt.f.xu.v vd, vs2, vm # Convert double-width unsigned integer to float */ 4285 RVVCALL(OPFVV1, vfncvt_f_xu_v_h, NOP_UU_H, H2, H4, uint32_to_float16) 4286 RVVCALL(OPFVV1, vfncvt_f_xu_v_w, NOP_UU_W, H4, H8, uint64_to_float32) 4287 GEN_VEXT_V_ENV(vfncvt_f_xu_v_h, 2, 2, clearh) 4288 GEN_VEXT_V_ENV(vfncvt_f_xu_v_w, 4, 4, clearl) 4289 4290 /* vfncvt.f.x.v vd, vs2, vm # Convert double-width integer to float. */ 4291 RVVCALL(OPFVV1, vfncvt_f_x_v_h, NOP_UU_H, H2, H4, int32_to_float16) 4292 RVVCALL(OPFVV1, vfncvt_f_x_v_w, NOP_UU_W, H4, H8, int64_to_float32) 4293 GEN_VEXT_V_ENV(vfncvt_f_x_v_h, 2, 2, clearh) 4294 GEN_VEXT_V_ENV(vfncvt_f_x_v_w, 4, 4, clearl) 4295 4296 /* vfncvt.f.f.v vd, vs2, vm # Convert double float to single-width float. */ 4297 static uint16_t vfncvtffv16(uint32_t a, float_status *s) 4298 { 4299 return float32_to_float16(a, true, s); 4300 } 4301 4302 RVVCALL(OPFVV1, vfncvt_f_f_v_h, NOP_UU_H, H2, H4, vfncvtffv16) 4303 RVVCALL(OPFVV1, vfncvt_f_f_v_w, NOP_UU_W, H4, H8, float64_to_float32) 4304 GEN_VEXT_V_ENV(vfncvt_f_f_v_h, 2, 2, clearh) 4305 GEN_VEXT_V_ENV(vfncvt_f_f_v_w, 4, 4, clearl) 4306 4307 /* 4308 *** Vector Reduction Operations 4309 */ 4310 /* Vector Single-Width Integer Reduction Instructions */ 4311 #define GEN_VEXT_RED(NAME, TD, TS2, HD, HS2, OP, CLEAR_FN)\ 4312 void HELPER(NAME)(void *vd, void *v0, void *vs1, \ 4313 void *vs2, CPURISCVState *env, uint32_t desc) \ 4314 { \ 4315 uint32_t mlen = vext_mlen(desc); \ 4316 uint32_t vm = vext_vm(desc); \ 4317 uint32_t vl = env->vl; \ 4318 uint32_t i; \ 4319 uint32_t tot = env_archcpu(env)->cfg.vlen / 8; \ 4320 TD s1 = *((TD *)vs1 + HD(0)); \ 4321 \ 4322 for (i = 0; i < vl; i++) { \ 4323 TS2 s2 = *((TS2 *)vs2 + HS2(i)); \ 4324 if (!vm && !vext_elem_mask(v0, mlen, i)) { \ 4325 continue; \ 4326 } \ 4327 s1 = OP(s1, (TD)s2); \ 4328 } \ 4329 *((TD *)vd + HD(0)) = s1; \ 4330 CLEAR_FN(vd, 1, sizeof(TD), tot); \ 4331 } 4332 4333 /* vd[0] = sum(vs1[0], vs2[*]) */ 4334 GEN_VEXT_RED(vredsum_vs_b, int8_t, int8_t, H1, H1, DO_ADD, clearb) 4335 GEN_VEXT_RED(vredsum_vs_h, int16_t, int16_t, H2, H2, DO_ADD, clearh) 4336 GEN_VEXT_RED(vredsum_vs_w, int32_t, int32_t, H4, H4, DO_ADD, clearl) 4337 GEN_VEXT_RED(vredsum_vs_d, int64_t, int64_t, H8, H8, DO_ADD, clearq) 4338 4339 /* vd[0] = maxu(vs1[0], vs2[*]) */ 4340 GEN_VEXT_RED(vredmaxu_vs_b, uint8_t, uint8_t, H1, H1, DO_MAX, clearb) 4341 GEN_VEXT_RED(vredmaxu_vs_h, uint16_t, uint16_t, H2, H2, DO_MAX, clearh) 4342 GEN_VEXT_RED(vredmaxu_vs_w, uint32_t, uint32_t, H4, H4, DO_MAX, clearl) 4343 GEN_VEXT_RED(vredmaxu_vs_d, uint64_t, uint64_t, H8, H8, DO_MAX, clearq) 4344 4345 /* vd[0] = max(vs1[0], vs2[*]) */ 4346 GEN_VEXT_RED(vredmax_vs_b, int8_t, int8_t, H1, H1, DO_MAX, clearb) 4347 GEN_VEXT_RED(vredmax_vs_h, int16_t, int16_t, H2, H2, DO_MAX, clearh) 4348 GEN_VEXT_RED(vredmax_vs_w, int32_t, int32_t, H4, H4, DO_MAX, clearl) 4349 GEN_VEXT_RED(vredmax_vs_d, int64_t, int64_t, H8, H8, DO_MAX, clearq) 4350 4351 /* vd[0] = minu(vs1[0], vs2[*]) */ 4352 GEN_VEXT_RED(vredminu_vs_b, uint8_t, uint8_t, H1, H1, DO_MIN, clearb) 4353 GEN_VEXT_RED(vredminu_vs_h, uint16_t, uint16_t, H2, H2, DO_MIN, clearh) 4354 GEN_VEXT_RED(vredminu_vs_w, uint32_t, uint32_t, H4, H4, DO_MIN, clearl) 4355 GEN_VEXT_RED(vredminu_vs_d, uint64_t, uint64_t, H8, H8, DO_MIN, clearq) 4356 4357 /* vd[0] = min(vs1[0], vs2[*]) */ 4358 GEN_VEXT_RED(vredmin_vs_b, int8_t, int8_t, H1, H1, DO_MIN, clearb) 4359 GEN_VEXT_RED(vredmin_vs_h, int16_t, int16_t, H2, H2, DO_MIN, clearh) 4360 GEN_VEXT_RED(vredmin_vs_w, int32_t, int32_t, H4, H4, DO_MIN, clearl) 4361 GEN_VEXT_RED(vredmin_vs_d, int64_t, int64_t, H8, H8, DO_MIN, clearq) 4362 4363 /* vd[0] = and(vs1[0], vs2[*]) */ 4364 GEN_VEXT_RED(vredand_vs_b, int8_t, int8_t, H1, H1, DO_AND, clearb) 4365 GEN_VEXT_RED(vredand_vs_h, int16_t, int16_t, H2, H2, DO_AND, clearh) 4366 GEN_VEXT_RED(vredand_vs_w, int32_t, int32_t, H4, H4, DO_AND, clearl) 4367 GEN_VEXT_RED(vredand_vs_d, int64_t, int64_t, H8, H8, DO_AND, clearq) 4368 4369 /* vd[0] = or(vs1[0], vs2[*]) */ 4370 GEN_VEXT_RED(vredor_vs_b, int8_t, int8_t, H1, H1, DO_OR, clearb) 4371 GEN_VEXT_RED(vredor_vs_h, int16_t, int16_t, H2, H2, DO_OR, clearh) 4372 GEN_VEXT_RED(vredor_vs_w, int32_t, int32_t, H4, H4, DO_OR, clearl) 4373 GEN_VEXT_RED(vredor_vs_d, int64_t, int64_t, H8, H8, DO_OR, clearq) 4374 4375 /* vd[0] = xor(vs1[0], vs2[*]) */ 4376 GEN_VEXT_RED(vredxor_vs_b, int8_t, int8_t, H1, H1, DO_XOR, clearb) 4377 GEN_VEXT_RED(vredxor_vs_h, int16_t, int16_t, H2, H2, DO_XOR, clearh) 4378 GEN_VEXT_RED(vredxor_vs_w, int32_t, int32_t, H4, H4, DO_XOR, clearl) 4379 GEN_VEXT_RED(vredxor_vs_d, int64_t, int64_t, H8, H8, DO_XOR, clearq) 4380 4381 /* Vector Widening Integer Reduction Instructions */ 4382 /* signed sum reduction into double-width accumulator */ 4383 GEN_VEXT_RED(vwredsum_vs_b, int16_t, int8_t, H2, H1, DO_ADD, clearh) 4384 GEN_VEXT_RED(vwredsum_vs_h, int32_t, int16_t, H4, H2, DO_ADD, clearl) 4385 GEN_VEXT_RED(vwredsum_vs_w, int64_t, int32_t, H8, H4, DO_ADD, clearq) 4386 4387 /* Unsigned sum reduction into double-width accumulator */ 4388 GEN_VEXT_RED(vwredsumu_vs_b, uint16_t, uint8_t, H2, H1, DO_ADD, clearh) 4389 GEN_VEXT_RED(vwredsumu_vs_h, uint32_t, uint16_t, H4, H2, DO_ADD, clearl) 4390 GEN_VEXT_RED(vwredsumu_vs_w, uint64_t, uint32_t, H8, H4, DO_ADD, clearq) 4391 4392 /* Vector Single-Width Floating-Point Reduction Instructions */ 4393 #define GEN_VEXT_FRED(NAME, TD, TS2, HD, HS2, OP, CLEAR_FN)\ 4394 void HELPER(NAME)(void *vd, void *v0, void *vs1, \ 4395 void *vs2, CPURISCVState *env, \ 4396 uint32_t desc) \ 4397 { \ 4398 uint32_t mlen = vext_mlen(desc); \ 4399 uint32_t vm = vext_vm(desc); \ 4400 uint32_t vl = env->vl; \ 4401 uint32_t i; \ 4402 uint32_t tot = env_archcpu(env)->cfg.vlen / 8; \ 4403 TD s1 = *((TD *)vs1 + HD(0)); \ 4404 \ 4405 for (i = 0; i < vl; i++) { \ 4406 TS2 s2 = *((TS2 *)vs2 + HS2(i)); \ 4407 if (!vm && !vext_elem_mask(v0, mlen, i)) { \ 4408 continue; \ 4409 } \ 4410 s1 = OP(s1, (TD)s2, &env->fp_status); \ 4411 } \ 4412 *((TD *)vd + HD(0)) = s1; \ 4413 CLEAR_FN(vd, 1, sizeof(TD), tot); \ 4414 } 4415 4416 /* Unordered sum */ 4417 GEN_VEXT_FRED(vfredsum_vs_h, uint16_t, uint16_t, H2, H2, float16_add, clearh) 4418 GEN_VEXT_FRED(vfredsum_vs_w, uint32_t, uint32_t, H4, H4, float32_add, clearl) 4419 GEN_VEXT_FRED(vfredsum_vs_d, uint64_t, uint64_t, H8, H8, float64_add, clearq) 4420 4421 /* Maximum value */ 4422 GEN_VEXT_FRED(vfredmax_vs_h, uint16_t, uint16_t, H2, H2, float16_maxnum, clearh) 4423 GEN_VEXT_FRED(vfredmax_vs_w, uint32_t, uint32_t, H4, H4, float32_maxnum, clearl) 4424 GEN_VEXT_FRED(vfredmax_vs_d, uint64_t, uint64_t, H8, H8, float64_maxnum, clearq) 4425 4426 /* Minimum value */ 4427 GEN_VEXT_FRED(vfredmin_vs_h, uint16_t, uint16_t, H2, H2, float16_minnum, clearh) 4428 GEN_VEXT_FRED(vfredmin_vs_w, uint32_t, uint32_t, H4, H4, float32_minnum, clearl) 4429 GEN_VEXT_FRED(vfredmin_vs_d, uint64_t, uint64_t, H8, H8, float64_minnum, clearq) 4430 4431 /* Vector Widening Floating-Point Reduction Instructions */ 4432 /* Unordered reduce 2*SEW = 2*SEW + sum(promote(SEW)) */ 4433 void HELPER(vfwredsum_vs_h)(void *vd, void *v0, void *vs1, 4434 void *vs2, CPURISCVState *env, uint32_t desc) 4435 { 4436 uint32_t mlen = vext_mlen(desc); 4437 uint32_t vm = vext_vm(desc); 4438 uint32_t vl = env->vl; 4439 uint32_t i; 4440 uint32_t tot = env_archcpu(env)->cfg.vlen / 8; 4441 uint32_t s1 = *((uint32_t *)vs1 + H4(0)); 4442 4443 for (i = 0; i < vl; i++) { 4444 uint16_t s2 = *((uint16_t *)vs2 + H2(i)); 4445 if (!vm && !vext_elem_mask(v0, mlen, i)) { 4446 continue; 4447 } 4448 s1 = float32_add(s1, float16_to_float32(s2, true, &env->fp_status), 4449 &env->fp_status); 4450 } 4451 *((uint32_t *)vd + H4(0)) = s1; 4452 clearl(vd, 1, sizeof(uint32_t), tot); 4453 } 4454 4455 void HELPER(vfwredsum_vs_w)(void *vd, void *v0, void *vs1, 4456 void *vs2, CPURISCVState *env, uint32_t desc) 4457 { 4458 uint32_t mlen = vext_mlen(desc); 4459 uint32_t vm = vext_vm(desc); 4460 uint32_t vl = env->vl; 4461 uint32_t i; 4462 uint32_t tot = env_archcpu(env)->cfg.vlen / 8; 4463 uint64_t s1 = *((uint64_t *)vs1); 4464 4465 for (i = 0; i < vl; i++) { 4466 uint32_t s2 = *((uint32_t *)vs2 + H4(i)); 4467 if (!vm && !vext_elem_mask(v0, mlen, i)) { 4468 continue; 4469 } 4470 s1 = float64_add(s1, float32_to_float64(s2, &env->fp_status), 4471 &env->fp_status); 4472 } 4473 *((uint64_t *)vd) = s1; 4474 clearq(vd, 1, sizeof(uint64_t), tot); 4475 } 4476 4477 /* 4478 *** Vector Mask Operations 4479 */ 4480 /* Vector Mask-Register Logical Instructions */ 4481 #define GEN_VEXT_MASK_VV(NAME, OP) \ 4482 void HELPER(NAME)(void *vd, void *v0, void *vs1, \ 4483 void *vs2, CPURISCVState *env, \ 4484 uint32_t desc) \ 4485 { \ 4486 uint32_t mlen = vext_mlen(desc); \ 4487 uint32_t vlmax = env_archcpu(env)->cfg.vlen / mlen; \ 4488 uint32_t vl = env->vl; \ 4489 uint32_t i; \ 4490 int a, b; \ 4491 \ 4492 for (i = 0; i < vl; i++) { \ 4493 a = vext_elem_mask(vs1, mlen, i); \ 4494 b = vext_elem_mask(vs2, mlen, i); \ 4495 vext_set_elem_mask(vd, mlen, i, OP(b, a)); \ 4496 } \ 4497 for (; i < vlmax; i++) { \ 4498 vext_set_elem_mask(vd, mlen, i, 0); \ 4499 } \ 4500 } 4501 4502 #define DO_NAND(N, M) (!(N & M)) 4503 #define DO_ANDNOT(N, M) (N & !M) 4504 #define DO_NOR(N, M) (!(N | M)) 4505 #define DO_ORNOT(N, M) (N | !M) 4506 #define DO_XNOR(N, M) (!(N ^ M)) 4507 4508 GEN_VEXT_MASK_VV(vmand_mm, DO_AND) 4509 GEN_VEXT_MASK_VV(vmnand_mm, DO_NAND) 4510 GEN_VEXT_MASK_VV(vmandnot_mm, DO_ANDNOT) 4511 GEN_VEXT_MASK_VV(vmxor_mm, DO_XOR) 4512 GEN_VEXT_MASK_VV(vmor_mm, DO_OR) 4513 GEN_VEXT_MASK_VV(vmnor_mm, DO_NOR) 4514 GEN_VEXT_MASK_VV(vmornot_mm, DO_ORNOT) 4515 GEN_VEXT_MASK_VV(vmxnor_mm, DO_XNOR) 4516 4517 /* Vector mask population count vmpopc */ 4518 target_ulong HELPER(vmpopc_m)(void *v0, void *vs2, CPURISCVState *env, 4519 uint32_t desc) 4520 { 4521 target_ulong cnt = 0; 4522 uint32_t mlen = vext_mlen(desc); 4523 uint32_t vm = vext_vm(desc); 4524 uint32_t vl = env->vl; 4525 int i; 4526 4527 for (i = 0; i < vl; i++) { 4528 if (vm || vext_elem_mask(v0, mlen, i)) { 4529 if (vext_elem_mask(vs2, mlen, i)) { 4530 cnt++; 4531 } 4532 } 4533 } 4534 return cnt; 4535 } 4536 4537 /* vmfirst find-first-set mask bit*/ 4538 target_ulong HELPER(vmfirst_m)(void *v0, void *vs2, CPURISCVState *env, 4539 uint32_t desc) 4540 { 4541 uint32_t mlen = vext_mlen(desc); 4542 uint32_t vm = vext_vm(desc); 4543 uint32_t vl = env->vl; 4544 int i; 4545 4546 for (i = 0; i < vl; i++) { 4547 if (vm || vext_elem_mask(v0, mlen, i)) { 4548 if (vext_elem_mask(vs2, mlen, i)) { 4549 return i; 4550 } 4551 } 4552 } 4553 return -1LL; 4554 } 4555 4556 enum set_mask_type { 4557 ONLY_FIRST = 1, 4558 INCLUDE_FIRST, 4559 BEFORE_FIRST, 4560 }; 4561 4562 static void vmsetm(void *vd, void *v0, void *vs2, CPURISCVState *env, 4563 uint32_t desc, enum set_mask_type type) 4564 { 4565 uint32_t mlen = vext_mlen(desc); 4566 uint32_t vlmax = env_archcpu(env)->cfg.vlen / mlen; 4567 uint32_t vm = vext_vm(desc); 4568 uint32_t vl = env->vl; 4569 int i; 4570 bool first_mask_bit = false; 4571 4572 for (i = 0; i < vl; i++) { 4573 if (!vm && !vext_elem_mask(v0, mlen, i)) { 4574 continue; 4575 } 4576 /* write a zero to all following active elements */ 4577 if (first_mask_bit) { 4578 vext_set_elem_mask(vd, mlen, i, 0); 4579 continue; 4580 } 4581 if (vext_elem_mask(vs2, mlen, i)) { 4582 first_mask_bit = true; 4583 if (type == BEFORE_FIRST) { 4584 vext_set_elem_mask(vd, mlen, i, 0); 4585 } else { 4586 vext_set_elem_mask(vd, mlen, i, 1); 4587 } 4588 } else { 4589 if (type == ONLY_FIRST) { 4590 vext_set_elem_mask(vd, mlen, i, 0); 4591 } else { 4592 vext_set_elem_mask(vd, mlen, i, 1); 4593 } 4594 } 4595 } 4596 for (; i < vlmax; i++) { 4597 vext_set_elem_mask(vd, mlen, i, 0); 4598 } 4599 } 4600 4601 void HELPER(vmsbf_m)(void *vd, void *v0, void *vs2, CPURISCVState *env, 4602 uint32_t desc) 4603 { 4604 vmsetm(vd, v0, vs2, env, desc, BEFORE_FIRST); 4605 } 4606 4607 void HELPER(vmsif_m)(void *vd, void *v0, void *vs2, CPURISCVState *env, 4608 uint32_t desc) 4609 { 4610 vmsetm(vd, v0, vs2, env, desc, INCLUDE_FIRST); 4611 } 4612 4613 void HELPER(vmsof_m)(void *vd, void *v0, void *vs2, CPURISCVState *env, 4614 uint32_t desc) 4615 { 4616 vmsetm(vd, v0, vs2, env, desc, ONLY_FIRST); 4617 } 4618 4619 /* Vector Iota Instruction */ 4620 #define GEN_VEXT_VIOTA_M(NAME, ETYPE, H, CLEAR_FN) \ 4621 void HELPER(NAME)(void *vd, void *v0, void *vs2, CPURISCVState *env, \ 4622 uint32_t desc) \ 4623 { \ 4624 uint32_t mlen = vext_mlen(desc); \ 4625 uint32_t vlmax = env_archcpu(env)->cfg.vlen / mlen; \ 4626 uint32_t vm = vext_vm(desc); \ 4627 uint32_t vl = env->vl; \ 4628 uint32_t sum = 0; \ 4629 int i; \ 4630 \ 4631 for (i = 0; i < vl; i++) { \ 4632 if (!vm && !vext_elem_mask(v0, mlen, i)) { \ 4633 continue; \ 4634 } \ 4635 *((ETYPE *)vd + H(i)) = sum; \ 4636 if (vext_elem_mask(vs2, mlen, i)) { \ 4637 sum++; \ 4638 } \ 4639 } \ 4640 CLEAR_FN(vd, vl, vl * sizeof(ETYPE), vlmax * sizeof(ETYPE)); \ 4641 } 4642 4643 GEN_VEXT_VIOTA_M(viota_m_b, uint8_t, H1, clearb) 4644 GEN_VEXT_VIOTA_M(viota_m_h, uint16_t, H2, clearh) 4645 GEN_VEXT_VIOTA_M(viota_m_w, uint32_t, H4, clearl) 4646 GEN_VEXT_VIOTA_M(viota_m_d, uint64_t, H8, clearq) 4647 4648 /* Vector Element Index Instruction */ 4649 #define GEN_VEXT_VID_V(NAME, ETYPE, H, CLEAR_FN) \ 4650 void HELPER(NAME)(void *vd, void *v0, CPURISCVState *env, uint32_t desc) \ 4651 { \ 4652 uint32_t mlen = vext_mlen(desc); \ 4653 uint32_t vlmax = env_archcpu(env)->cfg.vlen / mlen; \ 4654 uint32_t vm = vext_vm(desc); \ 4655 uint32_t vl = env->vl; \ 4656 int i; \ 4657 \ 4658 for (i = 0; i < vl; i++) { \ 4659 if (!vm && !vext_elem_mask(v0, mlen, i)) { \ 4660 continue; \ 4661 } \ 4662 *((ETYPE *)vd + H(i)) = i; \ 4663 } \ 4664 CLEAR_FN(vd, vl, vl * sizeof(ETYPE), vlmax * sizeof(ETYPE)); \ 4665 } 4666 4667 GEN_VEXT_VID_V(vid_v_b, uint8_t, H1, clearb) 4668 GEN_VEXT_VID_V(vid_v_h, uint16_t, H2, clearh) 4669 GEN_VEXT_VID_V(vid_v_w, uint32_t, H4, clearl) 4670 GEN_VEXT_VID_V(vid_v_d, uint64_t, H8, clearq) 4671 4672 /* 4673 *** Vector Permutation Instructions 4674 */ 4675 4676 /* Vector Slide Instructions */ 4677 #define GEN_VEXT_VSLIDEUP_VX(NAME, ETYPE, H, CLEAR_FN) \ 4678 void HELPER(NAME)(void *vd, void *v0, target_ulong s1, void *vs2, \ 4679 CPURISCVState *env, uint32_t desc) \ 4680 { \ 4681 uint32_t mlen = vext_mlen(desc); \ 4682 uint32_t vlmax = env_archcpu(env)->cfg.vlen / mlen; \ 4683 uint32_t vm = vext_vm(desc); \ 4684 uint32_t vl = env->vl; \ 4685 target_ulong offset = s1, i; \ 4686 \ 4687 for (i = offset; i < vl; i++) { \ 4688 if (!vm && !vext_elem_mask(v0, mlen, i)) { \ 4689 continue; \ 4690 } \ 4691 *((ETYPE *)vd + H(i)) = *((ETYPE *)vs2 + H(i - offset)); \ 4692 } \ 4693 CLEAR_FN(vd, vl, vl * sizeof(ETYPE), vlmax * sizeof(ETYPE)); \ 4694 } 4695 4696 /* vslideup.vx vd, vs2, rs1, vm # vd[i+rs1] = vs2[i] */ 4697 GEN_VEXT_VSLIDEUP_VX(vslideup_vx_b, uint8_t, H1, clearb) 4698 GEN_VEXT_VSLIDEUP_VX(vslideup_vx_h, uint16_t, H2, clearh) 4699 GEN_VEXT_VSLIDEUP_VX(vslideup_vx_w, uint32_t, H4, clearl) 4700 GEN_VEXT_VSLIDEUP_VX(vslideup_vx_d, uint64_t, H8, clearq) 4701 4702 #define GEN_VEXT_VSLIDEDOWN_VX(NAME, ETYPE, H, CLEAR_FN) \ 4703 void HELPER(NAME)(void *vd, void *v0, target_ulong s1, void *vs2, \ 4704 CPURISCVState *env, uint32_t desc) \ 4705 { \ 4706 uint32_t mlen = vext_mlen(desc); \ 4707 uint32_t vlmax = env_archcpu(env)->cfg.vlen / mlen; \ 4708 uint32_t vm = vext_vm(desc); \ 4709 uint32_t vl = env->vl; \ 4710 target_ulong offset = s1, i; \ 4711 \ 4712 for (i = 0; i < vl; ++i) { \ 4713 target_ulong j = i + offset; \ 4714 if (!vm && !vext_elem_mask(v0, mlen, i)) { \ 4715 continue; \ 4716 } \ 4717 *((ETYPE *)vd + H(i)) = j >= vlmax ? 0 : *((ETYPE *)vs2 + H(j)); \ 4718 } \ 4719 CLEAR_FN(vd, vl, vl * sizeof(ETYPE), vlmax * sizeof(ETYPE)); \ 4720 } 4721 4722 /* vslidedown.vx vd, vs2, rs1, vm # vd[i] = vs2[i+rs1] */ 4723 GEN_VEXT_VSLIDEDOWN_VX(vslidedown_vx_b, uint8_t, H1, clearb) 4724 GEN_VEXT_VSLIDEDOWN_VX(vslidedown_vx_h, uint16_t, H2, clearh) 4725 GEN_VEXT_VSLIDEDOWN_VX(vslidedown_vx_w, uint32_t, H4, clearl) 4726 GEN_VEXT_VSLIDEDOWN_VX(vslidedown_vx_d, uint64_t, H8, clearq) 4727 4728 #define GEN_VEXT_VSLIDE1UP_VX(NAME, ETYPE, H, CLEAR_FN) \ 4729 void HELPER(NAME)(void *vd, void *v0, target_ulong s1, void *vs2, \ 4730 CPURISCVState *env, uint32_t desc) \ 4731 { \ 4732 uint32_t mlen = vext_mlen(desc); \ 4733 uint32_t vlmax = env_archcpu(env)->cfg.vlen / mlen; \ 4734 uint32_t vm = vext_vm(desc); \ 4735 uint32_t vl = env->vl; \ 4736 uint32_t i; \ 4737 \ 4738 for (i = 0; i < vl; i++) { \ 4739 if (!vm && !vext_elem_mask(v0, mlen, i)) { \ 4740 continue; \ 4741 } \ 4742 if (i == 0) { \ 4743 *((ETYPE *)vd + H(i)) = s1; \ 4744 } else { \ 4745 *((ETYPE *)vd + H(i)) = *((ETYPE *)vs2 + H(i - 1)); \ 4746 } \ 4747 } \ 4748 CLEAR_FN(vd, vl, vl * sizeof(ETYPE), vlmax * sizeof(ETYPE)); \ 4749 } 4750 4751 /* vslide1up.vx vd, vs2, rs1, vm # vd[0]=x[rs1], vd[i+1] = vs2[i] */ 4752 GEN_VEXT_VSLIDE1UP_VX(vslide1up_vx_b, uint8_t, H1, clearb) 4753 GEN_VEXT_VSLIDE1UP_VX(vslide1up_vx_h, uint16_t, H2, clearh) 4754 GEN_VEXT_VSLIDE1UP_VX(vslide1up_vx_w, uint32_t, H4, clearl) 4755 GEN_VEXT_VSLIDE1UP_VX(vslide1up_vx_d, uint64_t, H8, clearq) 4756 4757 #define GEN_VEXT_VSLIDE1DOWN_VX(NAME, ETYPE, H, CLEAR_FN) \ 4758 void HELPER(NAME)(void *vd, void *v0, target_ulong s1, void *vs2, \ 4759 CPURISCVState *env, uint32_t desc) \ 4760 { \ 4761 uint32_t mlen = vext_mlen(desc); \ 4762 uint32_t vlmax = env_archcpu(env)->cfg.vlen / mlen; \ 4763 uint32_t vm = vext_vm(desc); \ 4764 uint32_t vl = env->vl; \ 4765 uint32_t i; \ 4766 \ 4767 for (i = 0; i < vl; i++) { \ 4768 if (!vm && !vext_elem_mask(v0, mlen, i)) { \ 4769 continue; \ 4770 } \ 4771 if (i == vl - 1) { \ 4772 *((ETYPE *)vd + H(i)) = s1; \ 4773 } else { \ 4774 *((ETYPE *)vd + H(i)) = *((ETYPE *)vs2 + H(i + 1)); \ 4775 } \ 4776 } \ 4777 CLEAR_FN(vd, vl, vl * sizeof(ETYPE), vlmax * sizeof(ETYPE)); \ 4778 } 4779 4780 /* vslide1down.vx vd, vs2, rs1, vm # vd[i] = vs2[i+1], vd[vl-1]=x[rs1] */ 4781 GEN_VEXT_VSLIDE1DOWN_VX(vslide1down_vx_b, uint8_t, H1, clearb) 4782 GEN_VEXT_VSLIDE1DOWN_VX(vslide1down_vx_h, uint16_t, H2, clearh) 4783 GEN_VEXT_VSLIDE1DOWN_VX(vslide1down_vx_w, uint32_t, H4, clearl) 4784 GEN_VEXT_VSLIDE1DOWN_VX(vslide1down_vx_d, uint64_t, H8, clearq) 4785 4786 /* Vector Register Gather Instruction */ 4787 #define GEN_VEXT_VRGATHER_VV(NAME, ETYPE, H, CLEAR_FN) \ 4788 void HELPER(NAME)(void *vd, void *v0, void *vs1, void *vs2, \ 4789 CPURISCVState *env, uint32_t desc) \ 4790 { \ 4791 uint32_t mlen = vext_mlen(desc); \ 4792 uint32_t vlmax = env_archcpu(env)->cfg.vlen / mlen; \ 4793 uint32_t vm = vext_vm(desc); \ 4794 uint32_t vl = env->vl; \ 4795 uint64_t index; \ 4796 uint32_t i; \ 4797 \ 4798 for (i = 0; i < vl; i++) { \ 4799 if (!vm && !vext_elem_mask(v0, mlen, i)) { \ 4800 continue; \ 4801 } \ 4802 index = *((ETYPE *)vs1 + H(i)); \ 4803 if (index >= vlmax) { \ 4804 *((ETYPE *)vd + H(i)) = 0; \ 4805 } else { \ 4806 *((ETYPE *)vd + H(i)) = *((ETYPE *)vs2 + H(index)); \ 4807 } \ 4808 } \ 4809 CLEAR_FN(vd, vl, vl * sizeof(ETYPE), vlmax * sizeof(ETYPE)); \ 4810 } 4811 4812 /* vd[i] = (vs1[i] >= VLMAX) ? 0 : vs2[vs1[i]]; */ 4813 GEN_VEXT_VRGATHER_VV(vrgather_vv_b, uint8_t, H1, clearb) 4814 GEN_VEXT_VRGATHER_VV(vrgather_vv_h, uint16_t, H2, clearh) 4815 GEN_VEXT_VRGATHER_VV(vrgather_vv_w, uint32_t, H4, clearl) 4816 GEN_VEXT_VRGATHER_VV(vrgather_vv_d, uint64_t, H8, clearq) 4817 4818 #define GEN_VEXT_VRGATHER_VX(NAME, ETYPE, H, CLEAR_FN) \ 4819 void HELPER(NAME)(void *vd, void *v0, target_ulong s1, void *vs2, \ 4820 CPURISCVState *env, uint32_t desc) \ 4821 { \ 4822 uint32_t mlen = vext_mlen(desc); \ 4823 uint32_t vlmax = env_archcpu(env)->cfg.vlen / mlen; \ 4824 uint32_t vm = vext_vm(desc); \ 4825 uint32_t vl = env->vl; \ 4826 uint64_t index = s1; \ 4827 uint32_t i; \ 4828 \ 4829 for (i = 0; i < vl; i++) { \ 4830 if (!vm && !vext_elem_mask(v0, mlen, i)) { \ 4831 continue; \ 4832 } \ 4833 if (index >= vlmax) { \ 4834 *((ETYPE *)vd + H(i)) = 0; \ 4835 } else { \ 4836 *((ETYPE *)vd + H(i)) = *((ETYPE *)vs2 + H(index)); \ 4837 } \ 4838 } \ 4839 CLEAR_FN(vd, vl, vl * sizeof(ETYPE), vlmax * sizeof(ETYPE)); \ 4840 } 4841 4842 /* vd[i] = (x[rs1] >= VLMAX) ? 0 : vs2[rs1] */ 4843 GEN_VEXT_VRGATHER_VX(vrgather_vx_b, uint8_t, H1, clearb) 4844 GEN_VEXT_VRGATHER_VX(vrgather_vx_h, uint16_t, H2, clearh) 4845 GEN_VEXT_VRGATHER_VX(vrgather_vx_w, uint32_t, H4, clearl) 4846 GEN_VEXT_VRGATHER_VX(vrgather_vx_d, uint64_t, H8, clearq) 4847 4848 /* Vector Compress Instruction */ 4849 #define GEN_VEXT_VCOMPRESS_VM(NAME, ETYPE, H, CLEAR_FN) \ 4850 void HELPER(NAME)(void *vd, void *v0, void *vs1, void *vs2, \ 4851 CPURISCVState *env, uint32_t desc) \ 4852 { \ 4853 uint32_t mlen = vext_mlen(desc); \ 4854 uint32_t vlmax = env_archcpu(env)->cfg.vlen / mlen; \ 4855 uint32_t vl = env->vl; \ 4856 uint32_t num = 0, i; \ 4857 \ 4858 for (i = 0; i < vl; i++) { \ 4859 if (!vext_elem_mask(vs1, mlen, i)) { \ 4860 continue; \ 4861 } \ 4862 *((ETYPE *)vd + H(num)) = *((ETYPE *)vs2 + H(i)); \ 4863 num++; \ 4864 } \ 4865 CLEAR_FN(vd, num, num * sizeof(ETYPE), vlmax * sizeof(ETYPE)); \ 4866 } 4867 4868 /* Compress into vd elements of vs2 where vs1 is enabled */ 4869 GEN_VEXT_VCOMPRESS_VM(vcompress_vm_b, uint8_t, H1, clearb) 4870 GEN_VEXT_VCOMPRESS_VM(vcompress_vm_h, uint16_t, H2, clearh) 4871 GEN_VEXT_VCOMPRESS_VM(vcompress_vm_w, uint32_t, H4, clearl) 4872 GEN_VEXT_VCOMPRESS_VM(vcompress_vm_d, uint64_t, H8, clearq) 4873