1a0c9400aSSong Gao /* SPDX-License-Identifier: GPL-2.0-or-later */ 2a0c9400aSSong Gao /* 31dc33f26SSong Gao * QEMU LoongArch vector helper functions. 4a0c9400aSSong Gao * 5a0c9400aSSong Gao * Copyright (c) 2022-2023 Loongson Technology Corporation Limited 6a0c9400aSSong Gao */ 7c037fbc9SSong Gao 8c037fbc9SSong Gao #include "qemu/osdep.h" 9c037fbc9SSong Gao #include "cpu.h" 10c037fbc9SSong Gao #include "exec/exec-all.h" 11c037fbc9SSong Gao #include "exec/helper-proto.h" 12aca67472SSong Gao #include "fpu/softfloat.h" 13aca67472SSong Gao #include "internals.h" 14d0dfa19aSSong Gao #include "tcg/tcg.h" 15c037fbc9SSong Gao 16c037fbc9SSong Gao #define DO_ADD(a, b) (a + b) 17c037fbc9SSong Gao #define DO_SUB(a, b) (a - b) 18c037fbc9SSong Gao 19c037fbc9SSong Gao #define DO_ODD_EVEN(NAME, BIT, E1, E2, DO_OP) \ 2004711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 21c037fbc9SSong Gao { \ 22c037fbc9SSong Gao int i; \ 2304711da1SSong Gao VReg *Vd = (VReg *)vd; \ 2404711da1SSong Gao VReg *Vj = (VReg *)vj; \ 2504711da1SSong Gao VReg *Vk = (VReg *)vk; \ 26c037fbc9SSong Gao typedef __typeof(Vd->E1(0)) TD; \ 27c037fbc9SSong Gao \ 28c037fbc9SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 29c037fbc9SSong Gao Vd->E1(i) = DO_OP((TD)Vj->E2(2 * i + 1), (TD)Vk->E2(2 * i)); \ 30c037fbc9SSong Gao } \ 31c037fbc9SSong Gao } 32c037fbc9SSong Gao 33c037fbc9SSong Gao DO_ODD_EVEN(vhaddw_h_b, 16, H, B, DO_ADD) 34c037fbc9SSong Gao DO_ODD_EVEN(vhaddw_w_h, 32, W, H, DO_ADD) 35c037fbc9SSong Gao DO_ODD_EVEN(vhaddw_d_w, 64, D, W, DO_ADD) 36c037fbc9SSong Gao 3704711da1SSong Gao void HELPER(vhaddw_q_d)(void *vd, void *vj, void *vk, uint32_t desc) 38c037fbc9SSong Gao { 3904711da1SSong Gao VReg *Vd = (VReg *)vd; 4004711da1SSong Gao VReg *Vj = (VReg *)vj; 4104711da1SSong Gao VReg *Vk = (VReg *)vk; 42c037fbc9SSong Gao 43c037fbc9SSong Gao Vd->Q(0) = int128_add(int128_makes64(Vj->D(1)), int128_makes64(Vk->D(0))); 44c037fbc9SSong Gao } 45c037fbc9SSong Gao 46c037fbc9SSong Gao DO_ODD_EVEN(vhsubw_h_b, 16, H, B, DO_SUB) 47c037fbc9SSong Gao DO_ODD_EVEN(vhsubw_w_h, 32, W, H, DO_SUB) 48c037fbc9SSong Gao DO_ODD_EVEN(vhsubw_d_w, 64, D, W, DO_SUB) 49c037fbc9SSong Gao 5004711da1SSong Gao void HELPER(vhsubw_q_d)(void *vd, void *vj, void *vk, uint32_t desc) 51c037fbc9SSong Gao { 5204711da1SSong Gao VReg *Vd = (VReg *)vd; 5304711da1SSong Gao VReg *Vj = (VReg *)vj; 5404711da1SSong Gao VReg *Vk = (VReg *)vk; 55c037fbc9SSong Gao 56c037fbc9SSong Gao Vd->Q(0) = int128_sub(int128_makes64(Vj->D(1)), int128_makes64(Vk->D(0))); 57c037fbc9SSong Gao } 58c037fbc9SSong Gao 59c037fbc9SSong Gao DO_ODD_EVEN(vhaddw_hu_bu, 16, UH, UB, DO_ADD) 60c037fbc9SSong Gao DO_ODD_EVEN(vhaddw_wu_hu, 32, UW, UH, DO_ADD) 61c037fbc9SSong Gao DO_ODD_EVEN(vhaddw_du_wu, 64, UD, UW, DO_ADD) 62c037fbc9SSong Gao 6304711da1SSong Gao void HELPER(vhaddw_qu_du)(void *vd, void *vj, void *vk, uint32_t desc) 64c037fbc9SSong Gao { 6504711da1SSong Gao VReg *Vd = (VReg *)vd; 6604711da1SSong Gao VReg *Vj = (VReg *)vj; 6704711da1SSong Gao VReg *Vk = (VReg *)vk; 68c037fbc9SSong Gao 69c037fbc9SSong Gao Vd->Q(0) = int128_add(int128_make64((uint64_t)Vj->D(1)), 70c037fbc9SSong Gao int128_make64((uint64_t)Vk->D(0))); 71c037fbc9SSong Gao } 72c037fbc9SSong Gao 73c037fbc9SSong Gao DO_ODD_EVEN(vhsubw_hu_bu, 16, UH, UB, DO_SUB) 74c037fbc9SSong Gao DO_ODD_EVEN(vhsubw_wu_hu, 32, UW, UH, DO_SUB) 75c037fbc9SSong Gao DO_ODD_EVEN(vhsubw_du_wu, 64, UD, UW, DO_SUB) 76c037fbc9SSong Gao 7704711da1SSong Gao void HELPER(vhsubw_qu_du)(void *vd, void *vj, void *vk, uint32_t desc) 78c037fbc9SSong Gao { 7904711da1SSong Gao VReg *Vd = (VReg *)vd; 8004711da1SSong Gao VReg *Vj = (VReg *)vj; 8104711da1SSong Gao VReg *Vk = (VReg *)vk; 82c037fbc9SSong Gao 83c037fbc9SSong Gao Vd->Q(0) = int128_sub(int128_make64((uint64_t)Vj->D(1)), 84c037fbc9SSong Gao int128_make64((uint64_t)Vk->D(0))); 85c037fbc9SSong Gao } 862d5f950cSSong Gao 872d5f950cSSong Gao #define DO_EVEN(NAME, BIT, E1, E2, DO_OP) \ 882d5f950cSSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t v) \ 892d5f950cSSong Gao { \ 902d5f950cSSong Gao int i; \ 912d5f950cSSong Gao VReg *Vd = (VReg *)vd; \ 922d5f950cSSong Gao VReg *Vj = (VReg *)vj; \ 932d5f950cSSong Gao VReg *Vk = (VReg *)vk; \ 942d5f950cSSong Gao typedef __typeof(Vd->E1(0)) TD; \ 952d5f950cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 962d5f950cSSong Gao Vd->E1(i) = DO_OP((TD)Vj->E2(2 * i) ,(TD)Vk->E2(2 * i)); \ 972d5f950cSSong Gao } \ 982d5f950cSSong Gao } 992d5f950cSSong Gao 1002d5f950cSSong Gao #define DO_ODD(NAME, BIT, E1, E2, DO_OP) \ 1012d5f950cSSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t v) \ 1022d5f950cSSong Gao { \ 1032d5f950cSSong Gao int i; \ 1042d5f950cSSong Gao VReg *Vd = (VReg *)vd; \ 1052d5f950cSSong Gao VReg *Vj = (VReg *)vj; \ 1062d5f950cSSong Gao VReg *Vk = (VReg *)vk; \ 1072d5f950cSSong Gao typedef __typeof(Vd->E1(0)) TD; \ 1082d5f950cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1092d5f950cSSong Gao Vd->E1(i) = DO_OP((TD)Vj->E2(2 * i + 1), (TD)Vk->E2(2 * i + 1)); \ 1102d5f950cSSong Gao } \ 1112d5f950cSSong Gao } 1122d5f950cSSong Gao 1132d5f950cSSong Gao void HELPER(vaddwev_q_d)(void *vd, void *vj, void *vk, uint32_t v) 1142d5f950cSSong Gao { 1152d5f950cSSong Gao VReg *Vd = (VReg *)vd; 1162d5f950cSSong Gao VReg *Vj = (VReg *)vj; 1172d5f950cSSong Gao VReg *Vk = (VReg *)vk; 1182d5f950cSSong Gao 1192d5f950cSSong Gao Vd->Q(0) = int128_add(int128_makes64(Vj->D(0)), int128_makes64(Vk->D(0))); 1202d5f950cSSong Gao } 1212d5f950cSSong Gao 1222d5f950cSSong Gao DO_EVEN(vaddwev_h_b, 16, H, B, DO_ADD) 1232d5f950cSSong Gao DO_EVEN(vaddwev_w_h, 32, W, H, DO_ADD) 1242d5f950cSSong Gao DO_EVEN(vaddwev_d_w, 64, D, W, DO_ADD) 1252d5f950cSSong Gao 1262d5f950cSSong Gao void HELPER(vaddwod_q_d)(void *vd, void *vj, void *vk, uint32_t v) 1272d5f950cSSong Gao { 1282d5f950cSSong Gao VReg *Vd = (VReg *)vd; 1292d5f950cSSong Gao VReg *Vj = (VReg *)vj; 1302d5f950cSSong Gao VReg *Vk = (VReg *)vk; 1312d5f950cSSong Gao 1322d5f950cSSong Gao Vd->Q(0) = int128_add(int128_makes64(Vj->D(1)), int128_makes64(Vk->D(1))); 1332d5f950cSSong Gao } 1342d5f950cSSong Gao 1352d5f950cSSong Gao DO_ODD(vaddwod_h_b, 16, H, B, DO_ADD) 1362d5f950cSSong Gao DO_ODD(vaddwod_w_h, 32, W, H, DO_ADD) 1372d5f950cSSong Gao DO_ODD(vaddwod_d_w, 64, D, W, DO_ADD) 1382d5f950cSSong Gao 1392d5f950cSSong Gao void HELPER(vsubwev_q_d)(void *vd, void *vj, void *vk, uint32_t v) 1402d5f950cSSong Gao { 1412d5f950cSSong Gao VReg *Vd = (VReg *)vd; 1422d5f950cSSong Gao VReg *Vj = (VReg *)vj; 1432d5f950cSSong Gao VReg *Vk = (VReg *)vk; 1442d5f950cSSong Gao 1452d5f950cSSong Gao Vd->Q(0) = int128_sub(int128_makes64(Vj->D(0)), int128_makes64(Vk->D(0))); 1462d5f950cSSong Gao } 1472d5f950cSSong Gao 1482d5f950cSSong Gao DO_EVEN(vsubwev_h_b, 16, H, B, DO_SUB) 1492d5f950cSSong Gao DO_EVEN(vsubwev_w_h, 32, W, H, DO_SUB) 1502d5f950cSSong Gao DO_EVEN(vsubwev_d_w, 64, D, W, DO_SUB) 1512d5f950cSSong Gao 1522d5f950cSSong Gao void HELPER(vsubwod_q_d)(void *vd, void *vj, void *vk, uint32_t v) 1532d5f950cSSong Gao { 1542d5f950cSSong Gao VReg *Vd = (VReg *)vd; 1552d5f950cSSong Gao VReg *Vj = (VReg *)vj; 1562d5f950cSSong Gao VReg *Vk = (VReg *)vk; 1572d5f950cSSong Gao 1582d5f950cSSong Gao Vd->Q(0) = int128_sub(int128_makes64(Vj->D(1)), int128_makes64(Vk->D(1))); 1592d5f950cSSong Gao } 1602d5f950cSSong Gao 1612d5f950cSSong Gao DO_ODD(vsubwod_h_b, 16, H, B, DO_SUB) 1622d5f950cSSong Gao DO_ODD(vsubwod_w_h, 32, W, H, DO_SUB) 1632d5f950cSSong Gao DO_ODD(vsubwod_d_w, 64, D, W, DO_SUB) 1642d5f950cSSong Gao 1652d5f950cSSong Gao void HELPER(vaddwev_q_du)(void *vd, void *vj, void *vk, uint32_t v) 1662d5f950cSSong Gao { 1672d5f950cSSong Gao VReg *Vd = (VReg *)vd; 1682d5f950cSSong Gao VReg *Vj = (VReg *)vj; 1692d5f950cSSong Gao VReg *Vk = (VReg *)vk; 1702d5f950cSSong Gao 1712d5f950cSSong Gao Vd->Q(0) = int128_add(int128_make64((uint64_t)Vj->D(0)), 1722d5f950cSSong Gao int128_make64((uint64_t)Vk->D(0))); 1732d5f950cSSong Gao } 1742d5f950cSSong Gao 1752d5f950cSSong Gao DO_EVEN(vaddwev_h_bu, 16, UH, UB, DO_ADD) 1762d5f950cSSong Gao DO_EVEN(vaddwev_w_hu, 32, UW, UH, DO_ADD) 1772d5f950cSSong Gao DO_EVEN(vaddwev_d_wu, 64, UD, UW, DO_ADD) 1782d5f950cSSong Gao 1792d5f950cSSong Gao void HELPER(vaddwod_q_du)(void *vd, void *vj, void *vk, uint32_t v) 1802d5f950cSSong Gao { 1812d5f950cSSong Gao VReg *Vd = (VReg *)vd; 1822d5f950cSSong Gao VReg *Vj = (VReg *)vj; 1832d5f950cSSong Gao VReg *Vk = (VReg *)vk; 1842d5f950cSSong Gao 1852d5f950cSSong Gao Vd->Q(0) = int128_add(int128_make64((uint64_t)Vj->D(1)), 1862d5f950cSSong Gao int128_make64((uint64_t)Vk->D(1))); 1872d5f950cSSong Gao } 1882d5f950cSSong Gao 1892d5f950cSSong Gao DO_ODD(vaddwod_h_bu, 16, UH, UB, DO_ADD) 1902d5f950cSSong Gao DO_ODD(vaddwod_w_hu, 32, UW, UH, DO_ADD) 1912d5f950cSSong Gao DO_ODD(vaddwod_d_wu, 64, UD, UW, DO_ADD) 1922d5f950cSSong Gao 1932d5f950cSSong Gao void HELPER(vsubwev_q_du)(void *vd, void *vj, void *vk, uint32_t v) 1942d5f950cSSong Gao { 1952d5f950cSSong Gao VReg *Vd = (VReg *)vd; 1962d5f950cSSong Gao VReg *Vj = (VReg *)vj; 1972d5f950cSSong Gao VReg *Vk = (VReg *)vk; 1982d5f950cSSong Gao 1992d5f950cSSong Gao Vd->Q(0) = int128_sub(int128_make64((uint64_t)Vj->D(0)), 2002d5f950cSSong Gao int128_make64((uint64_t)Vk->D(0))); 2012d5f950cSSong Gao } 2022d5f950cSSong Gao 2032d5f950cSSong Gao DO_EVEN(vsubwev_h_bu, 16, UH, UB, DO_SUB) 2042d5f950cSSong Gao DO_EVEN(vsubwev_w_hu, 32, UW, UH, DO_SUB) 2052d5f950cSSong Gao DO_EVEN(vsubwev_d_wu, 64, UD, UW, DO_SUB) 2062d5f950cSSong Gao 2072d5f950cSSong Gao void HELPER(vsubwod_q_du)(void *vd, void *vj, void *vk, uint32_t v) 2082d5f950cSSong Gao { 2092d5f950cSSong Gao VReg *Vd = (VReg *)vd; 2102d5f950cSSong Gao VReg *Vj = (VReg *)vj; 2112d5f950cSSong Gao VReg *Vk = (VReg *)vk; 2122d5f950cSSong Gao 2132d5f950cSSong Gao Vd->Q(0) = int128_sub(int128_make64((uint64_t)Vj->D(1)), 2142d5f950cSSong Gao int128_make64((uint64_t)Vk->D(1))); 2152d5f950cSSong Gao } 2162d5f950cSSong Gao 2172d5f950cSSong Gao DO_ODD(vsubwod_h_bu, 16, UH, UB, DO_SUB) 2182d5f950cSSong Gao DO_ODD(vsubwod_w_hu, 32, UW, UH, DO_SUB) 2192d5f950cSSong Gao DO_ODD(vsubwod_d_wu, 64, UD, UW, DO_SUB) 2202d5f950cSSong Gao 2212d5f950cSSong Gao #define DO_EVEN_U_S(NAME, BIT, ES1, EU1, ES2, EU2, DO_OP) \ 2222d5f950cSSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t v) \ 2232d5f950cSSong Gao { \ 2242d5f950cSSong Gao int i; \ 2252d5f950cSSong Gao VReg *Vd = (VReg *)vd; \ 2262d5f950cSSong Gao VReg *Vj = (VReg *)vj; \ 2272d5f950cSSong Gao VReg *Vk = (VReg *)vk; \ 2282d5f950cSSong Gao typedef __typeof(Vd->ES1(0)) TDS; \ 2292d5f950cSSong Gao typedef __typeof(Vd->EU1(0)) TDU; \ 2302d5f950cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2312d5f950cSSong Gao Vd->ES1(i) = DO_OP((TDU)Vj->EU2(2 * i) ,(TDS)Vk->ES2(2 * i)); \ 2322d5f950cSSong Gao } \ 2332d5f950cSSong Gao } 2342d5f950cSSong Gao 2352d5f950cSSong Gao #define DO_ODD_U_S(NAME, BIT, ES1, EU1, ES2, EU2, DO_OP) \ 2362d5f950cSSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t v) \ 2372d5f950cSSong Gao { \ 2382d5f950cSSong Gao int i; \ 2392d5f950cSSong Gao VReg *Vd = (VReg *)vd; \ 2402d5f950cSSong Gao VReg *Vj = (VReg *)vj; \ 2412d5f950cSSong Gao VReg *Vk = (VReg *)vk; \ 2422d5f950cSSong Gao typedef __typeof(Vd->ES1(0)) TDS; \ 2432d5f950cSSong Gao typedef __typeof(Vd->EU1(0)) TDU; \ 2442d5f950cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2452d5f950cSSong Gao Vd->ES1(i) = DO_OP((TDU)Vj->EU2(2 * i + 1), (TDS)Vk->ES2(2 * i + 1)); \ 2462d5f950cSSong Gao } \ 2472d5f950cSSong Gao } 2482d5f950cSSong Gao 2492d5f950cSSong Gao void HELPER(vaddwev_q_du_d)(void *vd, void *vj, void *vk, uint32_t v) 2502d5f950cSSong Gao { 2512d5f950cSSong Gao VReg *Vd = (VReg *)vd; 2522d5f950cSSong Gao VReg *Vj = (VReg *)vj; 2532d5f950cSSong Gao VReg *Vk = (VReg *)vk; 2542d5f950cSSong Gao 2552d5f950cSSong Gao Vd->Q(0) = int128_add(int128_make64((uint64_t)Vj->D(0)), 2562d5f950cSSong Gao int128_makes64(Vk->D(0))); 2572d5f950cSSong Gao } 2582d5f950cSSong Gao 2592d5f950cSSong Gao DO_EVEN_U_S(vaddwev_h_bu_b, 16, H, UH, B, UB, DO_ADD) 2602d5f950cSSong Gao DO_EVEN_U_S(vaddwev_w_hu_h, 32, W, UW, H, UH, DO_ADD) 2612d5f950cSSong Gao DO_EVEN_U_S(vaddwev_d_wu_w, 64, D, UD, W, UW, DO_ADD) 2622d5f950cSSong Gao 2632d5f950cSSong Gao void HELPER(vaddwod_q_du_d)(void *vd, void *vj, void *vk, uint32_t v) 2642d5f950cSSong Gao { 2652d5f950cSSong Gao VReg *Vd = (VReg *)vd; 2662d5f950cSSong Gao VReg *Vj = (VReg *)vj; 2672d5f950cSSong Gao VReg *Vk = (VReg *)vk; 2682d5f950cSSong Gao 2692d5f950cSSong Gao Vd->Q(0) = int128_add(int128_make64((uint64_t)Vj->D(1)), 2702d5f950cSSong Gao int128_makes64(Vk->D(1))); 2712d5f950cSSong Gao } 2722d5f950cSSong Gao 2732d5f950cSSong Gao DO_ODD_U_S(vaddwod_h_bu_b, 16, H, UH, B, UB, DO_ADD) 2742d5f950cSSong Gao DO_ODD_U_S(vaddwod_w_hu_h, 32, W, UW, H, UH, DO_ADD) 2752d5f950cSSong Gao DO_ODD_U_S(vaddwod_d_wu_w, 64, D, UD, W, UW, DO_ADD) 27639e9b0a7SSong Gao 27739e9b0a7SSong Gao #define DO_VAVG(a, b) ((a >> 1) + (b >> 1) + (a & b & 1)) 27839e9b0a7SSong Gao #define DO_VAVGR(a, b) ((a >> 1) + (b >> 1) + ((a | b) & 1)) 27939e9b0a7SSong Gao 28039e9b0a7SSong Gao #define DO_3OP(NAME, BIT, E, DO_OP) \ 28139e9b0a7SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t v) \ 28239e9b0a7SSong Gao { \ 28339e9b0a7SSong Gao int i; \ 28439e9b0a7SSong Gao VReg *Vd = (VReg *)vd; \ 28539e9b0a7SSong Gao VReg *Vj = (VReg *)vj; \ 28639e9b0a7SSong Gao VReg *Vk = (VReg *)vk; \ 28739e9b0a7SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 28839e9b0a7SSong Gao Vd->E(i) = DO_OP(Vj->E(i), Vk->E(i)); \ 28939e9b0a7SSong Gao } \ 29039e9b0a7SSong Gao } 29139e9b0a7SSong Gao 29239e9b0a7SSong Gao DO_3OP(vavg_b, 8, B, DO_VAVG) 29339e9b0a7SSong Gao DO_3OP(vavg_h, 16, H, DO_VAVG) 29439e9b0a7SSong Gao DO_3OP(vavg_w, 32, W, DO_VAVG) 29539e9b0a7SSong Gao DO_3OP(vavg_d, 64, D, DO_VAVG) 29639e9b0a7SSong Gao DO_3OP(vavgr_b, 8, B, DO_VAVGR) 29739e9b0a7SSong Gao DO_3OP(vavgr_h, 16, H, DO_VAVGR) 29839e9b0a7SSong Gao DO_3OP(vavgr_w, 32, W, DO_VAVGR) 29939e9b0a7SSong Gao DO_3OP(vavgr_d, 64, D, DO_VAVGR) 30039e9b0a7SSong Gao DO_3OP(vavg_bu, 8, UB, DO_VAVG) 30139e9b0a7SSong Gao DO_3OP(vavg_hu, 16, UH, DO_VAVG) 30239e9b0a7SSong Gao DO_3OP(vavg_wu, 32, UW, DO_VAVG) 30339e9b0a7SSong Gao DO_3OP(vavg_du, 64, UD, DO_VAVG) 30439e9b0a7SSong Gao DO_3OP(vavgr_bu, 8, UB, DO_VAVGR) 30539e9b0a7SSong Gao DO_3OP(vavgr_hu, 16, UH, DO_VAVGR) 30639e9b0a7SSong Gao DO_3OP(vavgr_wu, 32, UW, DO_VAVGR) 30739e9b0a7SSong Gao DO_3OP(vavgr_du, 64, UD, DO_VAVGR) 30849725659SSong Gao 30949725659SSong Gao #define DO_VABSD(a, b) ((a > b) ? (a -b) : (b-a)) 31049725659SSong Gao 31149725659SSong Gao DO_3OP(vabsd_b, 8, B, DO_VABSD) 31249725659SSong Gao DO_3OP(vabsd_h, 16, H, DO_VABSD) 31349725659SSong Gao DO_3OP(vabsd_w, 32, W, DO_VABSD) 31449725659SSong Gao DO_3OP(vabsd_d, 64, D, DO_VABSD) 31549725659SSong Gao DO_3OP(vabsd_bu, 8, UB, DO_VABSD) 31649725659SSong Gao DO_3OP(vabsd_hu, 16, UH, DO_VABSD) 31749725659SSong Gao DO_3OP(vabsd_wu, 32, UW, DO_VABSD) 31849725659SSong Gao DO_3OP(vabsd_du, 64, UD, DO_VABSD) 319af448cb3SSong Gao 320af448cb3SSong Gao #define DO_VABS(a) ((a < 0) ? (-a) : (a)) 321af448cb3SSong Gao 322af448cb3SSong Gao #define DO_VADDA(NAME, BIT, E, DO_OP) \ 323af448cb3SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t v) \ 324af448cb3SSong Gao { \ 325af448cb3SSong Gao int i; \ 326af448cb3SSong Gao VReg *Vd = (VReg *)vd; \ 327af448cb3SSong Gao VReg *Vj = (VReg *)vj; \ 328af448cb3SSong Gao VReg *Vk = (VReg *)vk; \ 329af448cb3SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 330af448cb3SSong Gao Vd->E(i) = DO_OP(Vj->E(i)) + DO_OP(Vk->E(i)); \ 331af448cb3SSong Gao } \ 332af448cb3SSong Gao } 333af448cb3SSong Gao 334af448cb3SSong Gao DO_VADDA(vadda_b, 8, B, DO_VABS) 335af448cb3SSong Gao DO_VADDA(vadda_h, 16, H, DO_VABS) 336af448cb3SSong Gao DO_VADDA(vadda_w, 32, W, DO_VABS) 337af448cb3SSong Gao DO_VADDA(vadda_d, 64, D, DO_VABS) 3389ab29520SSong Gao 3399ab29520SSong Gao #define DO_MIN(a, b) (a < b ? a : b) 3409ab29520SSong Gao #define DO_MAX(a, b) (a > b ? a : b) 3419ab29520SSong Gao 3429ab29520SSong Gao #define VMINMAXI(NAME, BIT, E, DO_OP) \ 3439ab29520SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t v) \ 3449ab29520SSong Gao { \ 3459ab29520SSong Gao int i; \ 3469ab29520SSong Gao VReg *Vd = (VReg *)vd; \ 3479ab29520SSong Gao VReg *Vj = (VReg *)vj; \ 3489ab29520SSong Gao typedef __typeof(Vd->E(0)) TD; \ 3499ab29520SSong Gao \ 3509ab29520SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 3519ab29520SSong Gao Vd->E(i) = DO_OP(Vj->E(i), (TD)imm); \ 3529ab29520SSong Gao } \ 3539ab29520SSong Gao } 3549ab29520SSong Gao 3559ab29520SSong Gao VMINMAXI(vmini_b, 8, B, DO_MIN) 3569ab29520SSong Gao VMINMAXI(vmini_h, 16, H, DO_MIN) 3579ab29520SSong Gao VMINMAXI(vmini_w, 32, W, DO_MIN) 3589ab29520SSong Gao VMINMAXI(vmini_d, 64, D, DO_MIN) 3599ab29520SSong Gao VMINMAXI(vmaxi_b, 8, B, DO_MAX) 3609ab29520SSong Gao VMINMAXI(vmaxi_h, 16, H, DO_MAX) 3619ab29520SSong Gao VMINMAXI(vmaxi_w, 32, W, DO_MAX) 3629ab29520SSong Gao VMINMAXI(vmaxi_d, 64, D, DO_MAX) 3639ab29520SSong Gao VMINMAXI(vmini_bu, 8, UB, DO_MIN) 3649ab29520SSong Gao VMINMAXI(vmini_hu, 16, UH, DO_MIN) 3659ab29520SSong Gao VMINMAXI(vmini_wu, 32, UW, DO_MIN) 3669ab29520SSong Gao VMINMAXI(vmini_du, 64, UD, DO_MIN) 3679ab29520SSong Gao VMINMAXI(vmaxi_bu, 8, UB, DO_MAX) 3689ab29520SSong Gao VMINMAXI(vmaxi_hu, 16, UH, DO_MAX) 3699ab29520SSong Gao VMINMAXI(vmaxi_wu, 32, UW, DO_MAX) 3709ab29520SSong Gao VMINMAXI(vmaxi_du, 64, UD, DO_MAX) 371cd1c49adSSong Gao 372cd1c49adSSong Gao #define DO_VMUH(NAME, BIT, E1, E2, DO_OP) \ 373cd1c49adSSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t v) \ 374cd1c49adSSong Gao { \ 375cd1c49adSSong Gao int i; \ 376cd1c49adSSong Gao VReg *Vd = (VReg *)vd; \ 377cd1c49adSSong Gao VReg *Vj = (VReg *)vj; \ 378cd1c49adSSong Gao VReg *Vk = (VReg *)vk; \ 379cd1c49adSSong Gao typedef __typeof(Vd->E1(0)) T; \ 380cd1c49adSSong Gao \ 381cd1c49adSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 382cd1c49adSSong Gao Vd->E2(i) = ((T)Vj->E2(i)) * ((T)Vk->E2(i)) >> BIT; \ 383cd1c49adSSong Gao } \ 384cd1c49adSSong Gao } 385cd1c49adSSong Gao 386cd1c49adSSong Gao void HELPER(vmuh_d)(void *vd, void *vj, void *vk, uint32_t v) 387cd1c49adSSong Gao { 388cd1c49adSSong Gao uint64_t l, h1, h2; 389cd1c49adSSong Gao VReg *Vd = (VReg *)vd; 390cd1c49adSSong Gao VReg *Vj = (VReg *)vj; 391cd1c49adSSong Gao VReg *Vk = (VReg *)vk; 392cd1c49adSSong Gao 393cd1c49adSSong Gao muls64(&l, &h1, Vj->D(0), Vk->D(0)); 394cd1c49adSSong Gao muls64(&l, &h2, Vj->D(1), Vk->D(1)); 395cd1c49adSSong Gao 396cd1c49adSSong Gao Vd->D(0) = h1; 397cd1c49adSSong Gao Vd->D(1) = h2; 398cd1c49adSSong Gao } 399cd1c49adSSong Gao 400cd1c49adSSong Gao DO_VMUH(vmuh_b, 8, H, B, DO_MUH) 401cd1c49adSSong Gao DO_VMUH(vmuh_h, 16, W, H, DO_MUH) 402cd1c49adSSong Gao DO_VMUH(vmuh_w, 32, D, W, DO_MUH) 403cd1c49adSSong Gao 404cd1c49adSSong Gao void HELPER(vmuh_du)(void *vd, void *vj, void *vk, uint32_t v) 405cd1c49adSSong Gao { 406cd1c49adSSong Gao uint64_t l, h1, h2; 407cd1c49adSSong Gao VReg *Vd = (VReg *)vd; 408cd1c49adSSong Gao VReg *Vj = (VReg *)vj; 409cd1c49adSSong Gao VReg *Vk = (VReg *)vk; 410cd1c49adSSong Gao 411cd1c49adSSong Gao mulu64(&l, &h1, Vj->D(0), Vk->D(0)); 412cd1c49adSSong Gao mulu64(&l, &h2, Vj->D(1), Vk->D(1)); 413cd1c49adSSong Gao 414cd1c49adSSong Gao Vd->D(0) = h1; 415cd1c49adSSong Gao Vd->D(1) = h2; 416cd1c49adSSong Gao } 417cd1c49adSSong Gao 418cd1c49adSSong Gao DO_VMUH(vmuh_bu, 8, UH, UB, DO_MUH) 419cd1c49adSSong Gao DO_VMUH(vmuh_hu, 16, UW, UH, DO_MUH) 420cd1c49adSSong Gao DO_VMUH(vmuh_wu, 32, UD, UW, DO_MUH) 421cd1c49adSSong Gao 422cd1c49adSSong Gao #define DO_MUL(a, b) (a * b) 423cd1c49adSSong Gao 424cd1c49adSSong Gao DO_EVEN(vmulwev_h_b, 16, H, B, DO_MUL) 425cd1c49adSSong Gao DO_EVEN(vmulwev_w_h, 32, W, H, DO_MUL) 426cd1c49adSSong Gao DO_EVEN(vmulwev_d_w, 64, D, W, DO_MUL) 427cd1c49adSSong Gao 428cd1c49adSSong Gao DO_ODD(vmulwod_h_b, 16, H, B, DO_MUL) 429cd1c49adSSong Gao DO_ODD(vmulwod_w_h, 32, W, H, DO_MUL) 430cd1c49adSSong Gao DO_ODD(vmulwod_d_w, 64, D, W, DO_MUL) 431cd1c49adSSong Gao 432cd1c49adSSong Gao DO_EVEN(vmulwev_h_bu, 16, UH, UB, DO_MUL) 433cd1c49adSSong Gao DO_EVEN(vmulwev_w_hu, 32, UW, UH, DO_MUL) 434cd1c49adSSong Gao DO_EVEN(vmulwev_d_wu, 64, UD, UW, DO_MUL) 435cd1c49adSSong Gao 436cd1c49adSSong Gao DO_ODD(vmulwod_h_bu, 16, UH, UB, DO_MUL) 437cd1c49adSSong Gao DO_ODD(vmulwod_w_hu, 32, UW, UH, DO_MUL) 438cd1c49adSSong Gao DO_ODD(vmulwod_d_wu, 64, UD, UW, DO_MUL) 439cd1c49adSSong Gao 440cd1c49adSSong Gao DO_EVEN_U_S(vmulwev_h_bu_b, 16, H, UH, B, UB, DO_MUL) 441cd1c49adSSong Gao DO_EVEN_U_S(vmulwev_w_hu_h, 32, W, UW, H, UH, DO_MUL) 442cd1c49adSSong Gao DO_EVEN_U_S(vmulwev_d_wu_w, 64, D, UD, W, UW, DO_MUL) 443cd1c49adSSong Gao 444cd1c49adSSong Gao DO_ODD_U_S(vmulwod_h_bu_b, 16, H, UH, B, UB, DO_MUL) 445cd1c49adSSong Gao DO_ODD_U_S(vmulwod_w_hu_h, 32, W, UW, H, UH, DO_MUL) 446cd1c49adSSong Gao DO_ODD_U_S(vmulwod_d_wu_w, 64, D, UD, W, UW, DO_MUL) 447d3aec65bSSong Gao 448d3aec65bSSong Gao #define DO_MADD(a, b, c) (a + b * c) 449d3aec65bSSong Gao #define DO_MSUB(a, b, c) (a - b * c) 450d3aec65bSSong Gao 451d3aec65bSSong Gao #define VMADDSUB(NAME, BIT, E, DO_OP) \ 452d3aec65bSSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t v) \ 453d3aec65bSSong Gao { \ 454d3aec65bSSong Gao int i; \ 455d3aec65bSSong Gao VReg *Vd = (VReg *)vd; \ 456d3aec65bSSong Gao VReg *Vj = (VReg *)vj; \ 457d3aec65bSSong Gao VReg *Vk = (VReg *)vk; \ 458d3aec65bSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 459d3aec65bSSong Gao Vd->E(i) = DO_OP(Vd->E(i), Vj->E(i) ,Vk->E(i)); \ 460d3aec65bSSong Gao } \ 461d3aec65bSSong Gao } 462d3aec65bSSong Gao 463d3aec65bSSong Gao VMADDSUB(vmadd_b, 8, B, DO_MADD) 464d3aec65bSSong Gao VMADDSUB(vmadd_h, 16, H, DO_MADD) 465d3aec65bSSong Gao VMADDSUB(vmadd_w, 32, W, DO_MADD) 466d3aec65bSSong Gao VMADDSUB(vmadd_d, 64, D, DO_MADD) 467d3aec65bSSong Gao VMADDSUB(vmsub_b, 8, B, DO_MSUB) 468d3aec65bSSong Gao VMADDSUB(vmsub_h, 16, H, DO_MSUB) 469d3aec65bSSong Gao VMADDSUB(vmsub_w, 32, W, DO_MSUB) 470d3aec65bSSong Gao VMADDSUB(vmsub_d, 64, D, DO_MSUB) 471d3aec65bSSong Gao 472d3aec65bSSong Gao #define VMADDWEV(NAME, BIT, E1, E2, DO_OP) \ 473d3aec65bSSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t v) \ 474d3aec65bSSong Gao { \ 475d3aec65bSSong Gao int i; \ 476d3aec65bSSong Gao VReg *Vd = (VReg *)vd; \ 477d3aec65bSSong Gao VReg *Vj = (VReg *)vj; \ 478d3aec65bSSong Gao VReg *Vk = (VReg *)vk; \ 479d3aec65bSSong Gao typedef __typeof(Vd->E1(0)) TD; \ 480d3aec65bSSong Gao \ 481d3aec65bSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 482d3aec65bSSong Gao Vd->E1(i) += DO_OP((TD)Vj->E2(2 * i), (TD)Vk->E2(2 * i)); \ 483d3aec65bSSong Gao } \ 484d3aec65bSSong Gao } 485d3aec65bSSong Gao 486d3aec65bSSong Gao VMADDWEV(vmaddwev_h_b, 16, H, B, DO_MUL) 487d3aec65bSSong Gao VMADDWEV(vmaddwev_w_h, 32, W, H, DO_MUL) 488d3aec65bSSong Gao VMADDWEV(vmaddwev_d_w, 64, D, W, DO_MUL) 489d3aec65bSSong Gao VMADDWEV(vmaddwev_h_bu, 16, UH, UB, DO_MUL) 490d3aec65bSSong Gao VMADDWEV(vmaddwev_w_hu, 32, UW, UH, DO_MUL) 491d3aec65bSSong Gao VMADDWEV(vmaddwev_d_wu, 64, UD, UW, DO_MUL) 492d3aec65bSSong Gao 493d3aec65bSSong Gao #define VMADDWOD(NAME, BIT, E1, E2, DO_OP) \ 494d3aec65bSSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t v) \ 495d3aec65bSSong Gao { \ 496d3aec65bSSong Gao int i; \ 497d3aec65bSSong Gao VReg *Vd = (VReg *)vd; \ 498d3aec65bSSong Gao VReg *Vj = (VReg *)vj; \ 499d3aec65bSSong Gao VReg *Vk = (VReg *)vk; \ 500d3aec65bSSong Gao typedef __typeof(Vd->E1(0)) TD; \ 501d3aec65bSSong Gao \ 502d3aec65bSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 503d3aec65bSSong Gao Vd->E1(i) += DO_OP((TD)Vj->E2(2 * i + 1), \ 504d3aec65bSSong Gao (TD)Vk->E2(2 * i + 1)); \ 505d3aec65bSSong Gao } \ 506d3aec65bSSong Gao } 507d3aec65bSSong Gao 508d3aec65bSSong Gao VMADDWOD(vmaddwod_h_b, 16, H, B, DO_MUL) 509d3aec65bSSong Gao VMADDWOD(vmaddwod_w_h, 32, W, H, DO_MUL) 510d3aec65bSSong Gao VMADDWOD(vmaddwod_d_w, 64, D, W, DO_MUL) 511d3aec65bSSong Gao VMADDWOD(vmaddwod_h_bu, 16, UH, UB, DO_MUL) 512d3aec65bSSong Gao VMADDWOD(vmaddwod_w_hu, 32, UW, UH, DO_MUL) 513d3aec65bSSong Gao VMADDWOD(vmaddwod_d_wu, 64, UD, UW, DO_MUL) 514d3aec65bSSong Gao 515d3aec65bSSong Gao #define VMADDWEV_U_S(NAME, BIT, ES1, EU1, ES2, EU2, DO_OP) \ 516d3aec65bSSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t v) \ 517d3aec65bSSong Gao { \ 518d3aec65bSSong Gao int i; \ 519d3aec65bSSong Gao VReg *Vd = (VReg *)vd; \ 520d3aec65bSSong Gao VReg *Vj = (VReg *)vj; \ 521d3aec65bSSong Gao VReg *Vk = (VReg *)vk; \ 522d3aec65bSSong Gao typedef __typeof(Vd->ES1(0)) TS1; \ 523d3aec65bSSong Gao typedef __typeof(Vd->EU1(0)) TU1; \ 524d3aec65bSSong Gao \ 525d3aec65bSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 526d3aec65bSSong Gao Vd->ES1(i) += DO_OP((TU1)Vj->EU2(2 * i), \ 527d3aec65bSSong Gao (TS1)Vk->ES2(2 * i)); \ 528d3aec65bSSong Gao } \ 529d3aec65bSSong Gao } 530d3aec65bSSong Gao 531d3aec65bSSong Gao VMADDWEV_U_S(vmaddwev_h_bu_b, 16, H, UH, B, UB, DO_MUL) 532d3aec65bSSong Gao VMADDWEV_U_S(vmaddwev_w_hu_h, 32, W, UW, H, UH, DO_MUL) 533d3aec65bSSong Gao VMADDWEV_U_S(vmaddwev_d_wu_w, 64, D, UD, W, UW, DO_MUL) 534d3aec65bSSong Gao 535d3aec65bSSong Gao #define VMADDWOD_U_S(NAME, BIT, ES1, EU1, ES2, EU2, DO_OP) \ 536d3aec65bSSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t v) \ 537d3aec65bSSong Gao { \ 538d3aec65bSSong Gao int i; \ 539d3aec65bSSong Gao VReg *Vd = (VReg *)vd; \ 540d3aec65bSSong Gao VReg *Vj = (VReg *)vj; \ 541d3aec65bSSong Gao VReg *Vk = (VReg *)vk; \ 542d3aec65bSSong Gao typedef __typeof(Vd->ES1(0)) TS1; \ 543d3aec65bSSong Gao typedef __typeof(Vd->EU1(0)) TU1; \ 544d3aec65bSSong Gao \ 545d3aec65bSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 546d3aec65bSSong Gao Vd->ES1(i) += DO_OP((TU1)Vj->EU2(2 * i + 1), \ 547d3aec65bSSong Gao (TS1)Vk->ES2(2 * i + 1)); \ 548d3aec65bSSong Gao } \ 549d3aec65bSSong Gao } 550d3aec65bSSong Gao 551d3aec65bSSong Gao VMADDWOD_U_S(vmaddwod_h_bu_b, 16, H, UH, B, UB, DO_MUL) 552d3aec65bSSong Gao VMADDWOD_U_S(vmaddwod_w_hu_h, 32, W, UW, H, UH, DO_MUL) 553d3aec65bSSong Gao VMADDWOD_U_S(vmaddwod_d_wu_w, 64, D, UD, W, UW, DO_MUL) 5544cc4c0f7SSong Gao 5554cc4c0f7SSong Gao #define DO_DIVU(N, M) (unlikely(M == 0) ? 0 : N / M) 5564cc4c0f7SSong Gao #define DO_REMU(N, M) (unlikely(M == 0) ? 0 : N % M) 5574cc4c0f7SSong Gao #define DO_DIV(N, M) (unlikely(M == 0) ? 0 :\ 5584cc4c0f7SSong Gao unlikely((N == -N) && (M == (__typeof(N))(-1))) ? N : N / M) 5594cc4c0f7SSong Gao #define DO_REM(N, M) (unlikely(M == 0) ? 0 :\ 5604cc4c0f7SSong Gao unlikely((N == -N) && (M == (__typeof(N))(-1))) ? 0 : N % M) 5614cc4c0f7SSong Gao 5624cc4c0f7SSong Gao #define VDIV(NAME, BIT, E, DO_OP) \ 56304711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 5644cc4c0f7SSong Gao { \ 5654cc4c0f7SSong Gao int i; \ 56604711da1SSong Gao VReg *Vd = (VReg *)vd; \ 56704711da1SSong Gao VReg *Vj = (VReg *)vj; \ 56804711da1SSong Gao VReg *Vk = (VReg *)vk; \ 5694cc4c0f7SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 5704cc4c0f7SSong Gao Vd->E(i) = DO_OP(Vj->E(i), Vk->E(i)); \ 5714cc4c0f7SSong Gao } \ 5724cc4c0f7SSong Gao } 5734cc4c0f7SSong Gao 5744cc4c0f7SSong Gao VDIV(vdiv_b, 8, B, DO_DIV) 5754cc4c0f7SSong Gao VDIV(vdiv_h, 16, H, DO_DIV) 5764cc4c0f7SSong Gao VDIV(vdiv_w, 32, W, DO_DIV) 5774cc4c0f7SSong Gao VDIV(vdiv_d, 64, D, DO_DIV) 5784cc4c0f7SSong Gao VDIV(vdiv_bu, 8, UB, DO_DIVU) 5794cc4c0f7SSong Gao VDIV(vdiv_hu, 16, UH, DO_DIVU) 5804cc4c0f7SSong Gao VDIV(vdiv_wu, 32, UW, DO_DIVU) 5814cc4c0f7SSong Gao VDIV(vdiv_du, 64, UD, DO_DIVU) 5824cc4c0f7SSong Gao VDIV(vmod_b, 8, B, DO_REM) 5834cc4c0f7SSong Gao VDIV(vmod_h, 16, H, DO_REM) 5844cc4c0f7SSong Gao VDIV(vmod_w, 32, W, DO_REM) 5854cc4c0f7SSong Gao VDIV(vmod_d, 64, D, DO_REM) 5864cc4c0f7SSong Gao VDIV(vmod_bu, 8, UB, DO_REMU) 5874cc4c0f7SSong Gao VDIV(vmod_hu, 16, UH, DO_REMU) 5884cc4c0f7SSong Gao VDIV(vmod_wu, 32, UW, DO_REMU) 5894cc4c0f7SSong Gao VDIV(vmod_du, 64, UD, DO_REMU) 590cbe44190SSong Gao 591cbe44190SSong Gao #define VSAT_S(NAME, BIT, E) \ 592cbe44190SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t max, uint32_t v) \ 593cbe44190SSong Gao { \ 594cbe44190SSong Gao int i; \ 595cbe44190SSong Gao VReg *Vd = (VReg *)vd; \ 596cbe44190SSong Gao VReg *Vj = (VReg *)vj; \ 597cbe44190SSong Gao typedef __typeof(Vd->E(0)) TD; \ 598cbe44190SSong Gao \ 599cbe44190SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 600cbe44190SSong Gao Vd->E(i) = Vj->E(i) > (TD)max ? (TD)max : \ 601cbe44190SSong Gao Vj->E(i) < (TD)~max ? (TD)~max: Vj->E(i); \ 602cbe44190SSong Gao } \ 603cbe44190SSong Gao } 604cbe44190SSong Gao 605cbe44190SSong Gao VSAT_S(vsat_b, 8, B) 606cbe44190SSong Gao VSAT_S(vsat_h, 16, H) 607cbe44190SSong Gao VSAT_S(vsat_w, 32, W) 608cbe44190SSong Gao VSAT_S(vsat_d, 64, D) 609cbe44190SSong Gao 610cbe44190SSong Gao #define VSAT_U(NAME, BIT, E) \ 611cbe44190SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t max, uint32_t v) \ 612cbe44190SSong Gao { \ 613cbe44190SSong Gao int i; \ 614cbe44190SSong Gao VReg *Vd = (VReg *)vd; \ 615cbe44190SSong Gao VReg *Vj = (VReg *)vj; \ 616cbe44190SSong Gao typedef __typeof(Vd->E(0)) TD; \ 617cbe44190SSong Gao \ 618cbe44190SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 619cbe44190SSong Gao Vd->E(i) = Vj->E(i) > (TD)max ? (TD)max : Vj->E(i); \ 620cbe44190SSong Gao } \ 621cbe44190SSong Gao } 622cbe44190SSong Gao 623cbe44190SSong Gao VSAT_U(vsat_bu, 8, UB) 624cbe44190SSong Gao VSAT_U(vsat_hu, 16, UH) 625cbe44190SSong Gao VSAT_U(vsat_wu, 32, UW) 626cbe44190SSong Gao VSAT_U(vsat_du, 64, UD) 6273734ad93SSong Gao 6283734ad93SSong Gao #define VEXTH(NAME, BIT, E1, E2) \ 629ff27e335SSong Gao void HELPER(NAME)(void *vd, void *vj, uint32_t desc) \ 6303734ad93SSong Gao { \ 6313734ad93SSong Gao int i; \ 632ff27e335SSong Gao VReg *Vd = (VReg *)vd; \ 633ff27e335SSong Gao VReg *Vj = (VReg *)vj; \ 6343734ad93SSong Gao \ 6353734ad93SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 6363734ad93SSong Gao Vd->E1(i) = Vj->E2(i + LSX_LEN/BIT); \ 6373734ad93SSong Gao } \ 6383734ad93SSong Gao } 6393734ad93SSong Gao 640ff27e335SSong Gao void HELPER(vexth_q_d)(void *vd, void *vj, uint32_t desc) 6413734ad93SSong Gao { 642ff27e335SSong Gao VReg *Vd = (VReg *)vd; 643ff27e335SSong Gao VReg *Vj = (VReg *)vj; 6443734ad93SSong Gao 6453734ad93SSong Gao Vd->Q(0) = int128_makes64(Vj->D(1)); 6463734ad93SSong Gao } 6473734ad93SSong Gao 648ff27e335SSong Gao void HELPER(vexth_qu_du)(void *vd, void *vj, uint32_t desc) 6493734ad93SSong Gao { 650ff27e335SSong Gao VReg *Vd = (VReg *)vd; 651ff27e335SSong Gao VReg *Vj = (VReg *)vj; 6523734ad93SSong Gao 6533734ad93SSong Gao Vd->Q(0) = int128_make64((uint64_t)Vj->D(1)); 6543734ad93SSong Gao } 6553734ad93SSong Gao 6563734ad93SSong Gao VEXTH(vexth_h_b, 16, H, B) 6573734ad93SSong Gao VEXTH(vexth_w_h, 32, W, H) 6583734ad93SSong Gao VEXTH(vexth_d_w, 64, D, W) 6593734ad93SSong Gao VEXTH(vexth_hu_bu, 16, UH, UB) 6603734ad93SSong Gao VEXTH(vexth_wu_hu, 32, UW, UH) 6613734ad93SSong Gao VEXTH(vexth_du_wu, 64, UD, UW) 662f0e395dfSSong Gao 663f0e395dfSSong Gao #define DO_SIGNCOV(a, b) (a == 0 ? 0 : a < 0 ? -b : b) 664f0e395dfSSong Gao 665f0e395dfSSong Gao DO_3OP(vsigncov_b, 8, B, DO_SIGNCOV) 666f0e395dfSSong Gao DO_3OP(vsigncov_h, 16, H, DO_SIGNCOV) 667f0e395dfSSong Gao DO_3OP(vsigncov_w, 32, W, DO_SIGNCOV) 668f0e395dfSSong Gao DO_3OP(vsigncov_d, 64, D, DO_SIGNCOV) 669789f4a4cSSong Gao 670789f4a4cSSong Gao static uint64_t do_vmskltz_b(int64_t val) 671789f4a4cSSong Gao { 672789f4a4cSSong Gao uint64_t m = 0x8080808080808080ULL; 673789f4a4cSSong Gao uint64_t c = val & m; 674789f4a4cSSong Gao c |= c << 7; 675789f4a4cSSong Gao c |= c << 14; 676789f4a4cSSong Gao c |= c << 28; 677789f4a4cSSong Gao return c >> 56; 678789f4a4cSSong Gao } 679789f4a4cSSong Gao 680ff27e335SSong Gao void HELPER(vmskltz_b)(void *vd, void *vj, uint32_t desc) 681789f4a4cSSong Gao { 682789f4a4cSSong Gao uint16_t temp = 0; 683ff27e335SSong Gao VReg *Vd = (VReg *)vd; 684ff27e335SSong Gao VReg *Vj = (VReg *)vj; 685789f4a4cSSong Gao 686789f4a4cSSong Gao temp = do_vmskltz_b(Vj->D(0)); 687789f4a4cSSong Gao temp |= (do_vmskltz_b(Vj->D(1)) << 8); 688789f4a4cSSong Gao Vd->D(0) = temp; 689789f4a4cSSong Gao Vd->D(1) = 0; 690789f4a4cSSong Gao } 691789f4a4cSSong Gao 692789f4a4cSSong Gao static uint64_t do_vmskltz_h(int64_t val) 693789f4a4cSSong Gao { 694789f4a4cSSong Gao uint64_t m = 0x8000800080008000ULL; 695789f4a4cSSong Gao uint64_t c = val & m; 696789f4a4cSSong Gao c |= c << 15; 697789f4a4cSSong Gao c |= c << 30; 698789f4a4cSSong Gao return c >> 60; 699789f4a4cSSong Gao } 700789f4a4cSSong Gao 701ff27e335SSong Gao void HELPER(vmskltz_h)(void *vd, void *vj, uint32_t desc) 702789f4a4cSSong Gao { 703789f4a4cSSong Gao uint16_t temp = 0; 704ff27e335SSong Gao VReg *Vd = (VReg *)vd; 705ff27e335SSong Gao VReg *Vj = (VReg *)vj; 706789f4a4cSSong Gao 707789f4a4cSSong Gao temp = do_vmskltz_h(Vj->D(0)); 708789f4a4cSSong Gao temp |= (do_vmskltz_h(Vj->D(1)) << 4); 709789f4a4cSSong Gao Vd->D(0) = temp; 710789f4a4cSSong Gao Vd->D(1) = 0; 711789f4a4cSSong Gao } 712789f4a4cSSong Gao 713789f4a4cSSong Gao static uint64_t do_vmskltz_w(int64_t val) 714789f4a4cSSong Gao { 715789f4a4cSSong Gao uint64_t m = 0x8000000080000000ULL; 716789f4a4cSSong Gao uint64_t c = val & m; 717789f4a4cSSong Gao c |= c << 31; 718789f4a4cSSong Gao return c >> 62; 719789f4a4cSSong Gao } 720789f4a4cSSong Gao 721ff27e335SSong Gao void HELPER(vmskltz_w)(void *vd, void *vj, uint32_t desc) 722789f4a4cSSong Gao { 723789f4a4cSSong Gao uint16_t temp = 0; 724ff27e335SSong Gao VReg *Vd = (VReg *)vd; 725ff27e335SSong Gao VReg *Vj = (VReg *)vj; 726789f4a4cSSong Gao 727789f4a4cSSong Gao temp = do_vmskltz_w(Vj->D(0)); 728789f4a4cSSong Gao temp |= (do_vmskltz_w(Vj->D(1)) << 2); 729789f4a4cSSong Gao Vd->D(0) = temp; 730789f4a4cSSong Gao Vd->D(1) = 0; 731789f4a4cSSong Gao } 732789f4a4cSSong Gao 733789f4a4cSSong Gao static uint64_t do_vmskltz_d(int64_t val) 734789f4a4cSSong Gao { 735789f4a4cSSong Gao return (uint64_t)val >> 63; 736789f4a4cSSong Gao } 737ff27e335SSong Gao void HELPER(vmskltz_d)(void *vd, void *vj, uint32_t desc) 738789f4a4cSSong Gao { 739789f4a4cSSong Gao uint16_t temp = 0; 740ff27e335SSong Gao VReg *Vd = (VReg *)vd; 741ff27e335SSong Gao VReg *Vj = (VReg *)vj; 742789f4a4cSSong Gao 743789f4a4cSSong Gao temp = do_vmskltz_d(Vj->D(0)); 744789f4a4cSSong Gao temp |= (do_vmskltz_d(Vj->D(1)) << 1); 745789f4a4cSSong Gao Vd->D(0) = temp; 746789f4a4cSSong Gao Vd->D(1) = 0; 747789f4a4cSSong Gao } 748789f4a4cSSong Gao 749ff27e335SSong Gao void HELPER(vmskgez_b)(void *vd, void *vj, uint32_t desc) 750789f4a4cSSong Gao { 751789f4a4cSSong Gao uint16_t temp = 0; 752ff27e335SSong Gao VReg *Vd = (VReg *)vd; 753ff27e335SSong Gao VReg *Vj = (VReg *)vj; 754789f4a4cSSong Gao 755789f4a4cSSong Gao temp = do_vmskltz_b(Vj->D(0)); 756789f4a4cSSong Gao temp |= (do_vmskltz_b(Vj->D(1)) << 8); 757789f4a4cSSong Gao Vd->D(0) = (uint16_t)(~temp); 758789f4a4cSSong Gao Vd->D(1) = 0; 759789f4a4cSSong Gao } 760789f4a4cSSong Gao 761789f4a4cSSong Gao static uint64_t do_vmskez_b(uint64_t a) 762789f4a4cSSong Gao { 763789f4a4cSSong Gao uint64_t m = 0x7f7f7f7f7f7f7f7fULL; 764789f4a4cSSong Gao uint64_t c = ~(((a & m) + m) | a | m); 765789f4a4cSSong Gao c |= c << 7; 766789f4a4cSSong Gao c |= c << 14; 767789f4a4cSSong Gao c |= c << 28; 768789f4a4cSSong Gao return c >> 56; 769789f4a4cSSong Gao } 770789f4a4cSSong Gao 771ff27e335SSong Gao void HELPER(vmsknz_b)(void *vd, void *vj, uint32_t desc) 772789f4a4cSSong Gao { 773789f4a4cSSong Gao uint16_t temp = 0; 774ff27e335SSong Gao VReg *Vd = (VReg *)vd; 775ff27e335SSong Gao VReg *Vj = (VReg *)vj; 776789f4a4cSSong Gao 777789f4a4cSSong Gao temp = do_vmskez_b(Vj->D(0)); 778789f4a4cSSong Gao temp |= (do_vmskez_b(Vj->D(1)) << 8); 779789f4a4cSSong Gao Vd->D(0) = (uint16_t)(~temp); 780789f4a4cSSong Gao Vd->D(1) = 0; 781789f4a4cSSong Gao } 782f205a539SSong Gao 783f205a539SSong Gao void HELPER(vnori_b)(void *vd, void *vj, uint64_t imm, uint32_t v) 784f205a539SSong Gao { 785f205a539SSong Gao int i; 786f205a539SSong Gao VReg *Vd = (VReg *)vd; 787f205a539SSong Gao VReg *Vj = (VReg *)vj; 788f205a539SSong Gao 789f205a539SSong Gao for (i = 0; i < LSX_LEN/8; i++) { 790f205a539SSong Gao Vd->B(i) = ~(Vj->B(i) | (uint8_t)imm); 791f205a539SSong Gao } 792f205a539SSong Gao } 7939b21a7a5SSong Gao 7949b21a7a5SSong Gao #define VSLLWIL(NAME, BIT, E1, E2) \ 7959b21a7a5SSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 7969b21a7a5SSong Gao uint32_t vd, uint32_t vj, uint32_t imm) \ 7979b21a7a5SSong Gao { \ 7989b21a7a5SSong Gao int i; \ 7999b21a7a5SSong Gao VReg temp; \ 8009b21a7a5SSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 8019b21a7a5SSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 8029b21a7a5SSong Gao typedef __typeof(temp.E1(0)) TD; \ 8039b21a7a5SSong Gao \ 8049b21a7a5SSong Gao temp.D(0) = 0; \ 8059b21a7a5SSong Gao temp.D(1) = 0; \ 8069b21a7a5SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 8079b21a7a5SSong Gao temp.E1(i) = (TD)Vj->E2(i) << (imm % BIT); \ 8089b21a7a5SSong Gao } \ 8099b21a7a5SSong Gao *Vd = temp; \ 8109b21a7a5SSong Gao } 8119b21a7a5SSong Gao 812ff27e335SSong Gao void HELPER(vextl_q_d)(void *vd, void *vj, uint32_t desc) 8139b21a7a5SSong Gao { 814ff27e335SSong Gao VReg *Vd = (VReg *)vd; 815ff27e335SSong Gao VReg *Vj = (VReg *)vj; 8169b21a7a5SSong Gao 8179b21a7a5SSong Gao Vd->Q(0) = int128_makes64(Vj->D(0)); 8189b21a7a5SSong Gao } 8199b21a7a5SSong Gao 820ff27e335SSong Gao void HELPER(vextl_qu_du)(void *vd, void *vj, uint32_t desc) 8219b21a7a5SSong Gao { 822ff27e335SSong Gao VReg *Vd = (VReg *)vd; 823ff27e335SSong Gao VReg *Vj = (VReg *)vj; 8249b21a7a5SSong Gao 8259b21a7a5SSong Gao Vd->Q(0) = int128_make64(Vj->D(0)); 8269b21a7a5SSong Gao } 8279b21a7a5SSong Gao 8289b21a7a5SSong Gao VSLLWIL(vsllwil_h_b, 16, H, B) 8299b21a7a5SSong Gao VSLLWIL(vsllwil_w_h, 32, W, H) 8309b21a7a5SSong Gao VSLLWIL(vsllwil_d_w, 64, D, W) 8319b21a7a5SSong Gao VSLLWIL(vsllwil_hu_bu, 16, UH, UB) 8329b21a7a5SSong Gao VSLLWIL(vsllwil_wu_hu, 32, UW, UH) 8339b21a7a5SSong Gao VSLLWIL(vsllwil_du_wu, 64, UD, UW) 834ecb93716SSong Gao 835ecb93716SSong Gao #define do_vsrlr(E, T) \ 836ecb93716SSong Gao static T do_vsrlr_ ##E(T s1, int sh) \ 837ecb93716SSong Gao { \ 838ecb93716SSong Gao if (sh == 0) { \ 839ecb93716SSong Gao return s1; \ 840ecb93716SSong Gao } else { \ 841ecb93716SSong Gao return (s1 >> sh) + ((s1 >> (sh - 1)) & 0x1); \ 842ecb93716SSong Gao } \ 843ecb93716SSong Gao } 844ecb93716SSong Gao 845ecb93716SSong Gao do_vsrlr(B, uint8_t) 846ecb93716SSong Gao do_vsrlr(H, uint16_t) 847ecb93716SSong Gao do_vsrlr(W, uint32_t) 848ecb93716SSong Gao do_vsrlr(D, uint64_t) 849ecb93716SSong Gao 850ecb93716SSong Gao #define VSRLR(NAME, BIT, T, E) \ 85104711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 852ecb93716SSong Gao { \ 853ecb93716SSong Gao int i; \ 85404711da1SSong Gao VReg *Vd = (VReg *)vd; \ 85504711da1SSong Gao VReg *Vj = (VReg *)vj; \ 85604711da1SSong Gao VReg *Vk = (VReg *)vk; \ 857ecb93716SSong Gao \ 858ecb93716SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 859ecb93716SSong Gao Vd->E(i) = do_vsrlr_ ## E(Vj->E(i), ((T)Vk->E(i))%BIT); \ 860ecb93716SSong Gao } \ 861ecb93716SSong Gao } 862ecb93716SSong Gao 863ecb93716SSong Gao VSRLR(vsrlr_b, 8, uint8_t, B) 864ecb93716SSong Gao VSRLR(vsrlr_h, 16, uint16_t, H) 865ecb93716SSong Gao VSRLR(vsrlr_w, 32, uint32_t, W) 866ecb93716SSong Gao VSRLR(vsrlr_d, 64, uint64_t, D) 867ecb93716SSong Gao 868ecb93716SSong Gao #define VSRLRI(NAME, BIT, E) \ 869ecb93716SSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 870ecb93716SSong Gao uint32_t vd, uint32_t vj, uint32_t imm) \ 871ecb93716SSong Gao { \ 872ecb93716SSong Gao int i; \ 873ecb93716SSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 874ecb93716SSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 875ecb93716SSong Gao \ 876ecb93716SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 877ecb93716SSong Gao Vd->E(i) = do_vsrlr_ ## E(Vj->E(i), imm); \ 878ecb93716SSong Gao } \ 879ecb93716SSong Gao } 880ecb93716SSong Gao 881ecb93716SSong Gao VSRLRI(vsrlri_b, 8, B) 882ecb93716SSong Gao VSRLRI(vsrlri_h, 16, H) 883ecb93716SSong Gao VSRLRI(vsrlri_w, 32, W) 884ecb93716SSong Gao VSRLRI(vsrlri_d, 64, D) 885ecb93716SSong Gao 886ecb93716SSong Gao #define do_vsrar(E, T) \ 887ecb93716SSong Gao static T do_vsrar_ ##E(T s1, int sh) \ 888ecb93716SSong Gao { \ 889ecb93716SSong Gao if (sh == 0) { \ 890ecb93716SSong Gao return s1; \ 891ecb93716SSong Gao } else { \ 892ecb93716SSong Gao return (s1 >> sh) + ((s1 >> (sh - 1)) & 0x1); \ 893ecb93716SSong Gao } \ 894ecb93716SSong Gao } 895ecb93716SSong Gao 896ecb93716SSong Gao do_vsrar(B, int8_t) 897ecb93716SSong Gao do_vsrar(H, int16_t) 898ecb93716SSong Gao do_vsrar(W, int32_t) 899ecb93716SSong Gao do_vsrar(D, int64_t) 900ecb93716SSong Gao 901ecb93716SSong Gao #define VSRAR(NAME, BIT, T, E) \ 90204711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 903ecb93716SSong Gao { \ 904ecb93716SSong Gao int i; \ 90504711da1SSong Gao VReg *Vd = (VReg *)vd; \ 90604711da1SSong Gao VReg *Vj = (VReg *)vj; \ 90704711da1SSong Gao VReg *Vk = (VReg *)vk; \ 908ecb93716SSong Gao \ 909ecb93716SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 910ecb93716SSong Gao Vd->E(i) = do_vsrar_ ## E(Vj->E(i), ((T)Vk->E(i))%BIT); \ 911ecb93716SSong Gao } \ 912ecb93716SSong Gao } 913ecb93716SSong Gao 914ecb93716SSong Gao VSRAR(vsrar_b, 8, uint8_t, B) 915ecb93716SSong Gao VSRAR(vsrar_h, 16, uint16_t, H) 916ecb93716SSong Gao VSRAR(vsrar_w, 32, uint32_t, W) 917ecb93716SSong Gao VSRAR(vsrar_d, 64, uint64_t, D) 918ecb93716SSong Gao 919ecb93716SSong Gao #define VSRARI(NAME, BIT, E) \ 920ecb93716SSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 921ecb93716SSong Gao uint32_t vd, uint32_t vj, uint32_t imm) \ 922ecb93716SSong Gao { \ 923ecb93716SSong Gao int i; \ 924ecb93716SSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 925ecb93716SSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 926ecb93716SSong Gao \ 927ecb93716SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 928ecb93716SSong Gao Vd->E(i) = do_vsrar_ ## E(Vj->E(i), imm); \ 929ecb93716SSong Gao } \ 930ecb93716SSong Gao } 931ecb93716SSong Gao 932ecb93716SSong Gao VSRARI(vsrari_b, 8, B) 933ecb93716SSong Gao VSRARI(vsrari_h, 16, H) 934ecb93716SSong Gao VSRARI(vsrari_w, 32, W) 935ecb93716SSong Gao VSRARI(vsrari_d, 64, D) 936d79fb8ddSSong Gao 937d79fb8ddSSong Gao #define R_SHIFT(a, b) (a >> b) 938d79fb8ddSSong Gao 939d79fb8ddSSong Gao #define VSRLN(NAME, BIT, T, E1, E2) \ 94004711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 941d79fb8ddSSong Gao { \ 942d79fb8ddSSong Gao int i; \ 94304711da1SSong Gao VReg *Vd = (VReg *)vd; \ 94404711da1SSong Gao VReg *Vj = (VReg *)vj; \ 94504711da1SSong Gao VReg *Vk = (VReg *)vk; \ 946d79fb8ddSSong Gao \ 947d79fb8ddSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 948d79fb8ddSSong Gao Vd->E1(i) = R_SHIFT((T)Vj->E2(i),((T)Vk->E2(i)) % BIT); \ 949d79fb8ddSSong Gao } \ 950d79fb8ddSSong Gao Vd->D(1) = 0; \ 951d79fb8ddSSong Gao } 952d79fb8ddSSong Gao 953d79fb8ddSSong Gao VSRLN(vsrln_b_h, 16, uint16_t, B, H) 954d79fb8ddSSong Gao VSRLN(vsrln_h_w, 32, uint32_t, H, W) 955d79fb8ddSSong Gao VSRLN(vsrln_w_d, 64, uint64_t, W, D) 956d79fb8ddSSong Gao 957d79fb8ddSSong Gao #define VSRAN(NAME, BIT, T, E1, E2) \ 95804711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 959d79fb8ddSSong Gao { \ 960d79fb8ddSSong Gao int i; \ 96104711da1SSong Gao VReg *Vd = (VReg *)vd; \ 96204711da1SSong Gao VReg *Vj = (VReg *)vj; \ 96304711da1SSong Gao VReg *Vk = (VReg *)vk; \ 964d79fb8ddSSong Gao \ 965d79fb8ddSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 966d79fb8ddSSong Gao Vd->E1(i) = R_SHIFT(Vj->E2(i), ((T)Vk->E2(i)) % BIT); \ 967d79fb8ddSSong Gao } \ 968d79fb8ddSSong Gao Vd->D(1) = 0; \ 969d79fb8ddSSong Gao } 970d79fb8ddSSong Gao 971d79fb8ddSSong Gao VSRAN(vsran_b_h, 16, uint16_t, B, H) 972d79fb8ddSSong Gao VSRAN(vsran_h_w, 32, uint32_t, H, W) 973d79fb8ddSSong Gao VSRAN(vsran_w_d, 64, uint64_t, W, D) 974d79fb8ddSSong Gao 975d79fb8ddSSong Gao #define VSRLNI(NAME, BIT, T, E1, E2) \ 976d79fb8ddSSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 977d79fb8ddSSong Gao uint32_t vd, uint32_t vj, uint32_t imm) \ 978d79fb8ddSSong Gao { \ 979d79fb8ddSSong Gao int i, max; \ 980d79fb8ddSSong Gao VReg temp; \ 981d79fb8ddSSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 982d79fb8ddSSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 983d79fb8ddSSong Gao \ 984d79fb8ddSSong Gao temp.D(0) = 0; \ 985d79fb8ddSSong Gao temp.D(1) = 0; \ 986d79fb8ddSSong Gao max = LSX_LEN/BIT; \ 987d79fb8ddSSong Gao for (i = 0; i < max; i++) { \ 988d79fb8ddSSong Gao temp.E1(i) = R_SHIFT((T)Vj->E2(i), imm); \ 989d79fb8ddSSong Gao temp.E1(i + max) = R_SHIFT((T)Vd->E2(i), imm); \ 990d79fb8ddSSong Gao } \ 991d79fb8ddSSong Gao *Vd = temp; \ 992d79fb8ddSSong Gao } 993d79fb8ddSSong Gao 994d79fb8ddSSong Gao void HELPER(vsrlni_d_q)(CPULoongArchState *env, 995d79fb8ddSSong Gao uint32_t vd, uint32_t vj, uint32_t imm) 996d79fb8ddSSong Gao { 997d79fb8ddSSong Gao VReg temp; 998d79fb8ddSSong Gao VReg *Vd = &(env->fpr[vd].vreg); 999d79fb8ddSSong Gao VReg *Vj = &(env->fpr[vj].vreg); 1000d79fb8ddSSong Gao 1001d79fb8ddSSong Gao temp.D(0) = 0; 1002d79fb8ddSSong Gao temp.D(1) = 0; 1003d79fb8ddSSong Gao temp.D(0) = int128_getlo(int128_urshift(Vj->Q(0), imm % 128)); 1004d79fb8ddSSong Gao temp.D(1) = int128_getlo(int128_urshift(Vd->Q(0), imm % 128)); 1005d79fb8ddSSong Gao *Vd = temp; 1006d79fb8ddSSong Gao } 1007d79fb8ddSSong Gao 1008d79fb8ddSSong Gao VSRLNI(vsrlni_b_h, 16, uint16_t, B, H) 1009d79fb8ddSSong Gao VSRLNI(vsrlni_h_w, 32, uint32_t, H, W) 1010d79fb8ddSSong Gao VSRLNI(vsrlni_w_d, 64, uint64_t, W, D) 1011d79fb8ddSSong Gao 1012d79fb8ddSSong Gao #define VSRANI(NAME, BIT, E1, E2) \ 1013d79fb8ddSSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 1014d79fb8ddSSong Gao uint32_t vd, uint32_t vj, uint32_t imm) \ 1015d79fb8ddSSong Gao { \ 1016d79fb8ddSSong Gao int i, max; \ 1017d79fb8ddSSong Gao VReg temp; \ 1018d79fb8ddSSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 1019d79fb8ddSSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 1020d79fb8ddSSong Gao \ 1021d79fb8ddSSong Gao temp.D(0) = 0; \ 1022d79fb8ddSSong Gao temp.D(1) = 0; \ 1023d79fb8ddSSong Gao max = LSX_LEN/BIT; \ 1024d79fb8ddSSong Gao for (i = 0; i < max; i++) { \ 1025d79fb8ddSSong Gao temp.E1(i) = R_SHIFT(Vj->E2(i), imm); \ 1026d79fb8ddSSong Gao temp.E1(i + max) = R_SHIFT(Vd->E2(i), imm); \ 1027d79fb8ddSSong Gao } \ 1028d79fb8ddSSong Gao *Vd = temp; \ 1029d79fb8ddSSong Gao } 1030d79fb8ddSSong Gao 1031d79fb8ddSSong Gao void HELPER(vsrani_d_q)(CPULoongArchState *env, 1032d79fb8ddSSong Gao uint32_t vd, uint32_t vj, uint32_t imm) 1033d79fb8ddSSong Gao { 1034d79fb8ddSSong Gao VReg temp; 1035d79fb8ddSSong Gao VReg *Vd = &(env->fpr[vd].vreg); 1036d79fb8ddSSong Gao VReg *Vj = &(env->fpr[vj].vreg); 1037d79fb8ddSSong Gao 1038d79fb8ddSSong Gao temp.D(0) = 0; 1039d79fb8ddSSong Gao temp.D(1) = 0; 1040d79fb8ddSSong Gao temp.D(0) = int128_getlo(int128_rshift(Vj->Q(0), imm % 128)); 1041d79fb8ddSSong Gao temp.D(1) = int128_getlo(int128_rshift(Vd->Q(0), imm % 128)); 1042d79fb8ddSSong Gao *Vd = temp; 1043d79fb8ddSSong Gao } 1044d79fb8ddSSong Gao 1045d79fb8ddSSong Gao VSRANI(vsrani_b_h, 16, B, H) 1046d79fb8ddSSong Gao VSRANI(vsrani_h_w, 32, H, W) 1047d79fb8ddSSong Gao VSRANI(vsrani_w_d, 64, W, D) 1048a5200a17SSong Gao 1049a5200a17SSong Gao #define VSRLRN(NAME, BIT, T, E1, E2) \ 105004711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 1051a5200a17SSong Gao { \ 1052a5200a17SSong Gao int i; \ 105304711da1SSong Gao VReg *Vd = (VReg *)vd; \ 105404711da1SSong Gao VReg *Vj = (VReg *)vj; \ 105504711da1SSong Gao VReg *Vk = (VReg *)vk; \ 1056a5200a17SSong Gao \ 1057a5200a17SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1058a5200a17SSong Gao Vd->E1(i) = do_vsrlr_ ## E2(Vj->E2(i), ((T)Vk->E2(i))%BIT); \ 1059a5200a17SSong Gao } \ 1060a5200a17SSong Gao Vd->D(1) = 0; \ 1061a5200a17SSong Gao } 1062a5200a17SSong Gao 1063a5200a17SSong Gao VSRLRN(vsrlrn_b_h, 16, uint16_t, B, H) 1064a5200a17SSong Gao VSRLRN(vsrlrn_h_w, 32, uint32_t, H, W) 1065a5200a17SSong Gao VSRLRN(vsrlrn_w_d, 64, uint64_t, W, D) 1066a5200a17SSong Gao 1067a5200a17SSong Gao #define VSRARN(NAME, BIT, T, E1, E2) \ 106804711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 1069a5200a17SSong Gao { \ 1070a5200a17SSong Gao int i; \ 107104711da1SSong Gao VReg *Vd = (VReg *)vd; \ 107204711da1SSong Gao VReg *Vj = (VReg *)vj; \ 107304711da1SSong Gao VReg *Vk = (VReg *)vk; \ 1074a5200a17SSong Gao \ 1075a5200a17SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1076a5200a17SSong Gao Vd->E1(i) = do_vsrar_ ## E2(Vj->E2(i), ((T)Vk->E2(i))%BIT); \ 1077a5200a17SSong Gao } \ 1078a5200a17SSong Gao Vd->D(1) = 0; \ 1079a5200a17SSong Gao } 1080a5200a17SSong Gao 1081a5200a17SSong Gao VSRARN(vsrarn_b_h, 16, uint8_t, B, H) 1082a5200a17SSong Gao VSRARN(vsrarn_h_w, 32, uint16_t, H, W) 1083a5200a17SSong Gao VSRARN(vsrarn_w_d, 64, uint32_t, W, D) 1084a5200a17SSong Gao 1085a5200a17SSong Gao #define VSRLRNI(NAME, BIT, E1, E2) \ 1086a5200a17SSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 1087a5200a17SSong Gao uint32_t vd, uint32_t vj, uint32_t imm) \ 1088a5200a17SSong Gao { \ 1089a5200a17SSong Gao int i, max; \ 1090a5200a17SSong Gao VReg temp; \ 1091a5200a17SSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 1092a5200a17SSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 1093a5200a17SSong Gao \ 1094a5200a17SSong Gao temp.D(0) = 0; \ 1095a5200a17SSong Gao temp.D(1) = 0; \ 1096a5200a17SSong Gao max = LSX_LEN/BIT; \ 1097a5200a17SSong Gao for (i = 0; i < max; i++) { \ 1098a5200a17SSong Gao temp.E1(i) = do_vsrlr_ ## E2(Vj->E2(i), imm); \ 1099a5200a17SSong Gao temp.E1(i + max) = do_vsrlr_ ## E2(Vd->E2(i), imm); \ 1100a5200a17SSong Gao } \ 1101a5200a17SSong Gao *Vd = temp; \ 1102a5200a17SSong Gao } 1103a5200a17SSong Gao 1104a5200a17SSong Gao void HELPER(vsrlrni_d_q)(CPULoongArchState *env, 1105a5200a17SSong Gao uint32_t vd, uint32_t vj, uint32_t imm) 1106a5200a17SSong Gao { 1107a5200a17SSong Gao VReg temp; 1108a5200a17SSong Gao VReg *Vd = &(env->fpr[vd].vreg); 1109a5200a17SSong Gao VReg *Vj = &(env->fpr[vj].vreg); 1110a5200a17SSong Gao Int128 r1, r2; 1111a5200a17SSong Gao 1112a5200a17SSong Gao if (imm == 0) { 1113a5200a17SSong Gao temp.D(0) = int128_getlo(Vj->Q(0)); 1114a5200a17SSong Gao temp.D(1) = int128_getlo(Vd->Q(0)); 1115a5200a17SSong Gao } else { 1116a5200a17SSong Gao r1 = int128_and(int128_urshift(Vj->Q(0), (imm -1)), int128_one()); 1117a5200a17SSong Gao r2 = int128_and(int128_urshift(Vd->Q(0), (imm -1)), int128_one()); 1118a5200a17SSong Gao 1119a5200a17SSong Gao temp.D(0) = int128_getlo(int128_add(int128_urshift(Vj->Q(0), imm), r1)); 1120a5200a17SSong Gao temp.D(1) = int128_getlo(int128_add(int128_urshift(Vd->Q(0), imm), r2)); 1121a5200a17SSong Gao } 1122a5200a17SSong Gao *Vd = temp; 1123a5200a17SSong Gao } 1124a5200a17SSong Gao 1125a5200a17SSong Gao VSRLRNI(vsrlrni_b_h, 16, B, H) 1126a5200a17SSong Gao VSRLRNI(vsrlrni_h_w, 32, H, W) 1127a5200a17SSong Gao VSRLRNI(vsrlrni_w_d, 64, W, D) 1128a5200a17SSong Gao 1129a5200a17SSong Gao #define VSRARNI(NAME, BIT, E1, E2) \ 1130a5200a17SSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 1131a5200a17SSong Gao uint32_t vd, uint32_t vj, uint32_t imm) \ 1132a5200a17SSong Gao { \ 1133a5200a17SSong Gao int i, max; \ 1134a5200a17SSong Gao VReg temp; \ 1135a5200a17SSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 1136a5200a17SSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 1137a5200a17SSong Gao \ 1138a5200a17SSong Gao temp.D(0) = 0; \ 1139a5200a17SSong Gao temp.D(1) = 0; \ 1140a5200a17SSong Gao max = LSX_LEN/BIT; \ 1141a5200a17SSong Gao for (i = 0; i < max; i++) { \ 1142a5200a17SSong Gao temp.E1(i) = do_vsrar_ ## E2(Vj->E2(i), imm); \ 1143a5200a17SSong Gao temp.E1(i + max) = do_vsrar_ ## E2(Vd->E2(i), imm); \ 1144a5200a17SSong Gao } \ 1145a5200a17SSong Gao *Vd = temp; \ 1146a5200a17SSong Gao } 1147a5200a17SSong Gao 1148a5200a17SSong Gao void HELPER(vsrarni_d_q)(CPULoongArchState *env, 1149a5200a17SSong Gao uint32_t vd, uint32_t vj, uint32_t imm) 1150a5200a17SSong Gao { 1151a5200a17SSong Gao VReg temp; 1152a5200a17SSong Gao VReg *Vd = &(env->fpr[vd].vreg); 1153a5200a17SSong Gao VReg *Vj = &(env->fpr[vj].vreg); 1154a5200a17SSong Gao Int128 r1, r2; 1155a5200a17SSong Gao 1156a5200a17SSong Gao if (imm == 0) { 1157a5200a17SSong Gao temp.D(0) = int128_getlo(Vj->Q(0)); 1158a5200a17SSong Gao temp.D(1) = int128_getlo(Vd->Q(0)); 1159a5200a17SSong Gao } else { 1160a5200a17SSong Gao r1 = int128_and(int128_rshift(Vj->Q(0), (imm -1)), int128_one()); 1161a5200a17SSong Gao r2 = int128_and(int128_rshift(Vd->Q(0), (imm -1)), int128_one()); 1162a5200a17SSong Gao 1163a5200a17SSong Gao temp.D(0) = int128_getlo(int128_add(int128_rshift(Vj->Q(0), imm), r1)); 1164a5200a17SSong Gao temp.D(1) = int128_getlo(int128_add(int128_rshift(Vd->Q(0), imm), r2)); 1165a5200a17SSong Gao } 1166a5200a17SSong Gao *Vd = temp; 1167a5200a17SSong Gao } 1168a5200a17SSong Gao 1169a5200a17SSong Gao VSRARNI(vsrarni_b_h, 16, B, H) 1170a5200a17SSong Gao VSRARNI(vsrarni_h_w, 32, H, W) 1171a5200a17SSong Gao VSRARNI(vsrarni_w_d, 64, W, D) 117283b3815dSSong Gao 117383b3815dSSong Gao #define SSRLNS(NAME, T1, T2, T3) \ 117483b3815dSSong Gao static T1 do_ssrlns_ ## NAME(T2 e2, int sa, int sh) \ 117583b3815dSSong Gao { \ 117683b3815dSSong Gao T1 shft_res; \ 117783b3815dSSong Gao if (sa == 0) { \ 117883b3815dSSong Gao shft_res = e2; \ 117983b3815dSSong Gao } else { \ 118083b3815dSSong Gao shft_res = (((T1)e2) >> sa); \ 118183b3815dSSong Gao } \ 118283b3815dSSong Gao T3 mask; \ 118383b3815dSSong Gao mask = (1ull << sh) -1; \ 118483b3815dSSong Gao if (shft_res > mask) { \ 118583b3815dSSong Gao return mask; \ 118683b3815dSSong Gao } else { \ 118783b3815dSSong Gao return shft_res; \ 118883b3815dSSong Gao } \ 118983b3815dSSong Gao } 119083b3815dSSong Gao 119183b3815dSSong Gao SSRLNS(B, uint16_t, int16_t, uint8_t) 119283b3815dSSong Gao SSRLNS(H, uint32_t, int32_t, uint16_t) 119383b3815dSSong Gao SSRLNS(W, uint64_t, int64_t, uint32_t) 119483b3815dSSong Gao 119583b3815dSSong Gao #define VSSRLN(NAME, BIT, T, E1, E2) \ 119604711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 119783b3815dSSong Gao { \ 119883b3815dSSong Gao int i; \ 119904711da1SSong Gao VReg *Vd = (VReg *)vd; \ 120004711da1SSong Gao VReg *Vj = (VReg *)vj; \ 120104711da1SSong Gao VReg *Vk = (VReg *)vk; \ 120283b3815dSSong Gao \ 120383b3815dSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 120483b3815dSSong Gao Vd->E1(i) = do_ssrlns_ ## E1(Vj->E2(i), (T)Vk->E2(i)% BIT, BIT/2 -1); \ 120583b3815dSSong Gao } \ 120683b3815dSSong Gao Vd->D(1) = 0; \ 120783b3815dSSong Gao } 120883b3815dSSong Gao 120983b3815dSSong Gao VSSRLN(vssrln_b_h, 16, uint16_t, B, H) 121083b3815dSSong Gao VSSRLN(vssrln_h_w, 32, uint32_t, H, W) 121183b3815dSSong Gao VSSRLN(vssrln_w_d, 64, uint64_t, W, D) 121283b3815dSSong Gao 121383b3815dSSong Gao #define SSRANS(E, T1, T2) \ 121483b3815dSSong Gao static T1 do_ssrans_ ## E(T1 e2, int sa, int sh) \ 121583b3815dSSong Gao { \ 121683b3815dSSong Gao T1 shft_res; \ 121783b3815dSSong Gao if (sa == 0) { \ 121883b3815dSSong Gao shft_res = e2; \ 121983b3815dSSong Gao } else { \ 122083b3815dSSong Gao shft_res = e2 >> sa; \ 122183b3815dSSong Gao } \ 122283b3815dSSong Gao T2 mask; \ 122383b3815dSSong Gao mask = (1ll << sh) -1; \ 122483b3815dSSong Gao if (shft_res > mask) { \ 122583b3815dSSong Gao return mask; \ 122683b3815dSSong Gao } else if (shft_res < -(mask +1)) { \ 122783b3815dSSong Gao return ~mask; \ 122883b3815dSSong Gao } else { \ 122983b3815dSSong Gao return shft_res; \ 123083b3815dSSong Gao } \ 123183b3815dSSong Gao } 123283b3815dSSong Gao 123383b3815dSSong Gao SSRANS(B, int16_t, int8_t) 123483b3815dSSong Gao SSRANS(H, int32_t, int16_t) 123583b3815dSSong Gao SSRANS(W, int64_t, int32_t) 123683b3815dSSong Gao 123783b3815dSSong Gao #define VSSRAN(NAME, BIT, T, E1, E2) \ 123804711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 123983b3815dSSong Gao { \ 124083b3815dSSong Gao int i; \ 124104711da1SSong Gao VReg *Vd = (VReg *)vd; \ 124204711da1SSong Gao VReg *Vj = (VReg *)vj; \ 124304711da1SSong Gao VReg *Vk = (VReg *)vk; \ 124483b3815dSSong Gao \ 124583b3815dSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 124683b3815dSSong Gao Vd->E1(i) = do_ssrans_ ## E1(Vj->E2(i), (T)Vk->E2(i)%BIT, BIT/2 -1); \ 124783b3815dSSong Gao } \ 124883b3815dSSong Gao Vd->D(1) = 0; \ 124983b3815dSSong Gao } 125083b3815dSSong Gao 125183b3815dSSong Gao VSSRAN(vssran_b_h, 16, uint16_t, B, H) 125283b3815dSSong Gao VSSRAN(vssran_h_w, 32, uint32_t, H, W) 125383b3815dSSong Gao VSSRAN(vssran_w_d, 64, uint64_t, W, D) 125483b3815dSSong Gao 125583b3815dSSong Gao #define SSRLNU(E, T1, T2, T3) \ 125683b3815dSSong Gao static T1 do_ssrlnu_ ## E(T3 e2, int sa, int sh) \ 125783b3815dSSong Gao { \ 125883b3815dSSong Gao T1 shft_res; \ 125983b3815dSSong Gao if (sa == 0) { \ 126083b3815dSSong Gao shft_res = e2; \ 126183b3815dSSong Gao } else { \ 126283b3815dSSong Gao shft_res = (((T1)e2) >> sa); \ 126383b3815dSSong Gao } \ 126483b3815dSSong Gao T2 mask; \ 126583b3815dSSong Gao mask = (1ull << sh) -1; \ 126683b3815dSSong Gao if (shft_res > mask) { \ 126783b3815dSSong Gao return mask; \ 126883b3815dSSong Gao } else { \ 126983b3815dSSong Gao return shft_res; \ 127083b3815dSSong Gao } \ 127183b3815dSSong Gao } 127283b3815dSSong Gao 127383b3815dSSong Gao SSRLNU(B, uint16_t, uint8_t, int16_t) 127483b3815dSSong Gao SSRLNU(H, uint32_t, uint16_t, int32_t) 127583b3815dSSong Gao SSRLNU(W, uint64_t, uint32_t, int64_t) 127683b3815dSSong Gao 127783b3815dSSong Gao #define VSSRLNU(NAME, BIT, T, E1, E2) \ 127804711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 127983b3815dSSong Gao { \ 128083b3815dSSong Gao int i; \ 128104711da1SSong Gao VReg *Vd = (VReg *)vd; \ 128204711da1SSong Gao VReg *Vj = (VReg *)vj; \ 128304711da1SSong Gao VReg *Vk = (VReg *)vk; \ 128483b3815dSSong Gao \ 128583b3815dSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 128683b3815dSSong Gao Vd->E1(i) = do_ssrlnu_ ## E1(Vj->E2(i), (T)Vk->E2(i)%BIT, BIT/2); \ 128783b3815dSSong Gao } \ 128883b3815dSSong Gao Vd->D(1) = 0; \ 128983b3815dSSong Gao } 129083b3815dSSong Gao 129183b3815dSSong Gao VSSRLNU(vssrln_bu_h, 16, uint16_t, B, H) 129283b3815dSSong Gao VSSRLNU(vssrln_hu_w, 32, uint32_t, H, W) 129383b3815dSSong Gao VSSRLNU(vssrln_wu_d, 64, uint64_t, W, D) 129483b3815dSSong Gao 129583b3815dSSong Gao #define SSRANU(E, T1, T2, T3) \ 129683b3815dSSong Gao static T1 do_ssranu_ ## E(T3 e2, int sa, int sh) \ 129783b3815dSSong Gao { \ 129883b3815dSSong Gao T1 shft_res; \ 129983b3815dSSong Gao if (sa == 0) { \ 130083b3815dSSong Gao shft_res = e2; \ 130183b3815dSSong Gao } else { \ 130283b3815dSSong Gao shft_res = e2 >> sa; \ 130383b3815dSSong Gao } \ 130483b3815dSSong Gao if (e2 < 0) { \ 130583b3815dSSong Gao shft_res = 0; \ 130683b3815dSSong Gao } \ 130783b3815dSSong Gao T2 mask; \ 130883b3815dSSong Gao mask = (1ull << sh) -1; \ 130983b3815dSSong Gao if (shft_res > mask) { \ 131083b3815dSSong Gao return mask; \ 131183b3815dSSong Gao } else { \ 131283b3815dSSong Gao return shft_res; \ 131383b3815dSSong Gao } \ 131483b3815dSSong Gao } 131583b3815dSSong Gao 131683b3815dSSong Gao SSRANU(B, uint16_t, uint8_t, int16_t) 131783b3815dSSong Gao SSRANU(H, uint32_t, uint16_t, int32_t) 131883b3815dSSong Gao SSRANU(W, uint64_t, uint32_t, int64_t) 131983b3815dSSong Gao 132083b3815dSSong Gao #define VSSRANU(NAME, BIT, T, E1, E2) \ 132104711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 132283b3815dSSong Gao { \ 132383b3815dSSong Gao int i; \ 132404711da1SSong Gao VReg *Vd = (VReg *)vd; \ 132504711da1SSong Gao VReg *Vj = (VReg *)vj; \ 132604711da1SSong Gao VReg *Vk = (VReg *)vk; \ 132783b3815dSSong Gao \ 132883b3815dSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 132983b3815dSSong Gao Vd->E1(i) = do_ssranu_ ## E1(Vj->E2(i), (T)Vk->E2(i)%BIT, BIT/2); \ 133083b3815dSSong Gao } \ 133183b3815dSSong Gao Vd->D(1) = 0; \ 133283b3815dSSong Gao } 133383b3815dSSong Gao 133483b3815dSSong Gao VSSRANU(vssran_bu_h, 16, uint16_t, B, H) 133583b3815dSSong Gao VSSRANU(vssran_hu_w, 32, uint32_t, H, W) 133683b3815dSSong Gao VSSRANU(vssran_wu_d, 64, uint64_t, W, D) 133783b3815dSSong Gao 133883b3815dSSong Gao #define VSSRLNI(NAME, BIT, E1, E2) \ 133983b3815dSSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 134083b3815dSSong Gao uint32_t vd, uint32_t vj, uint32_t imm) \ 134183b3815dSSong Gao { \ 134283b3815dSSong Gao int i; \ 134383b3815dSSong Gao VReg temp; \ 134483b3815dSSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 134583b3815dSSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 134683b3815dSSong Gao \ 134783b3815dSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 134883b3815dSSong Gao temp.E1(i) = do_ssrlns_ ## E1(Vj->E2(i), imm, BIT/2 -1); \ 134983b3815dSSong Gao temp.E1(i + LSX_LEN/BIT) = do_ssrlns_ ## E1(Vd->E2(i), imm, BIT/2 -1);\ 135083b3815dSSong Gao } \ 135183b3815dSSong Gao *Vd = temp; \ 135283b3815dSSong Gao } 135383b3815dSSong Gao 135483b3815dSSong Gao void HELPER(vssrlni_d_q)(CPULoongArchState *env, 135583b3815dSSong Gao uint32_t vd, uint32_t vj, uint32_t imm) 135683b3815dSSong Gao { 135783b3815dSSong Gao Int128 shft_res1, shft_res2, mask; 135883b3815dSSong Gao VReg *Vd = &(env->fpr[vd].vreg); 135983b3815dSSong Gao VReg *Vj = &(env->fpr[vj].vreg); 136083b3815dSSong Gao 136183b3815dSSong Gao if (imm == 0) { 136283b3815dSSong Gao shft_res1 = Vj->Q(0); 136383b3815dSSong Gao shft_res2 = Vd->Q(0); 136483b3815dSSong Gao } else { 136583b3815dSSong Gao shft_res1 = int128_urshift(Vj->Q(0), imm); 136683b3815dSSong Gao shft_res2 = int128_urshift(Vd->Q(0), imm); 136783b3815dSSong Gao } 136883b3815dSSong Gao mask = int128_sub(int128_lshift(int128_one(), 63), int128_one()); 136983b3815dSSong Gao 137083b3815dSSong Gao if (int128_ult(mask, shft_res1)) { 137183b3815dSSong Gao Vd->D(0) = int128_getlo(mask); 137283b3815dSSong Gao }else { 137383b3815dSSong Gao Vd->D(0) = int128_getlo(shft_res1); 137483b3815dSSong Gao } 137583b3815dSSong Gao 137683b3815dSSong Gao if (int128_ult(mask, shft_res2)) { 137783b3815dSSong Gao Vd->D(1) = int128_getlo(mask); 137883b3815dSSong Gao }else { 137983b3815dSSong Gao Vd->D(1) = int128_getlo(shft_res2); 138083b3815dSSong Gao } 138183b3815dSSong Gao } 138283b3815dSSong Gao 138383b3815dSSong Gao VSSRLNI(vssrlni_b_h, 16, B, H) 138483b3815dSSong Gao VSSRLNI(vssrlni_h_w, 32, H, W) 138583b3815dSSong Gao VSSRLNI(vssrlni_w_d, 64, W, D) 138683b3815dSSong Gao 138783b3815dSSong Gao #define VSSRANI(NAME, BIT, E1, E2) \ 138883b3815dSSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 138983b3815dSSong Gao uint32_t vd, uint32_t vj, uint32_t imm) \ 139083b3815dSSong Gao { \ 139183b3815dSSong Gao int i; \ 139283b3815dSSong Gao VReg temp; \ 139383b3815dSSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 139483b3815dSSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 139583b3815dSSong Gao \ 139683b3815dSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 139783b3815dSSong Gao temp.E1(i) = do_ssrans_ ## E1(Vj->E2(i), imm, BIT/2 -1); \ 139883b3815dSSong Gao temp.E1(i + LSX_LEN/BIT) = do_ssrans_ ## E1(Vd->E2(i), imm, BIT/2 -1); \ 139983b3815dSSong Gao } \ 140083b3815dSSong Gao *Vd = temp; \ 140183b3815dSSong Gao } 140283b3815dSSong Gao 140383b3815dSSong Gao void HELPER(vssrani_d_q)(CPULoongArchState *env, 140483b3815dSSong Gao uint32_t vd, uint32_t vj, uint32_t imm) 140583b3815dSSong Gao { 140683b3815dSSong Gao Int128 shft_res1, shft_res2, mask, min; 140783b3815dSSong Gao VReg *Vd = &(env->fpr[vd].vreg); 140883b3815dSSong Gao VReg *Vj = &(env->fpr[vj].vreg); 140983b3815dSSong Gao 141083b3815dSSong Gao if (imm == 0) { 141183b3815dSSong Gao shft_res1 = Vj->Q(0); 141283b3815dSSong Gao shft_res2 = Vd->Q(0); 141383b3815dSSong Gao } else { 141483b3815dSSong Gao shft_res1 = int128_rshift(Vj->Q(0), imm); 141583b3815dSSong Gao shft_res2 = int128_rshift(Vd->Q(0), imm); 141683b3815dSSong Gao } 141783b3815dSSong Gao mask = int128_sub(int128_lshift(int128_one(), 63), int128_one()); 141883b3815dSSong Gao min = int128_lshift(int128_one(), 63); 141983b3815dSSong Gao 142083b3815dSSong Gao if (int128_gt(shft_res1, mask)) { 142183b3815dSSong Gao Vd->D(0) = int128_getlo(mask); 142283b3815dSSong Gao } else if (int128_lt(shft_res1, int128_neg(min))) { 142383b3815dSSong Gao Vd->D(0) = int128_getlo(min); 142483b3815dSSong Gao } else { 142583b3815dSSong Gao Vd->D(0) = int128_getlo(shft_res1); 142683b3815dSSong Gao } 142783b3815dSSong Gao 142883b3815dSSong Gao if (int128_gt(shft_res2, mask)) { 142983b3815dSSong Gao Vd->D(1) = int128_getlo(mask); 143083b3815dSSong Gao } else if (int128_lt(shft_res2, int128_neg(min))) { 143183b3815dSSong Gao Vd->D(1) = int128_getlo(min); 143283b3815dSSong Gao } else { 143383b3815dSSong Gao Vd->D(1) = int128_getlo(shft_res2); 143483b3815dSSong Gao } 143583b3815dSSong Gao } 143683b3815dSSong Gao 143783b3815dSSong Gao VSSRANI(vssrani_b_h, 16, B, H) 143883b3815dSSong Gao VSSRANI(vssrani_h_w, 32, H, W) 143983b3815dSSong Gao VSSRANI(vssrani_w_d, 64, W, D) 144083b3815dSSong Gao 144183b3815dSSong Gao #define VSSRLNUI(NAME, BIT, E1, E2) \ 144283b3815dSSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 144383b3815dSSong Gao uint32_t vd, uint32_t vj, uint32_t imm) \ 144483b3815dSSong Gao { \ 144583b3815dSSong Gao int i; \ 144683b3815dSSong Gao VReg temp; \ 144783b3815dSSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 144883b3815dSSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 144983b3815dSSong Gao \ 145083b3815dSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 145183b3815dSSong Gao temp.E1(i) = do_ssrlnu_ ## E1(Vj->E2(i), imm, BIT/2); \ 145283b3815dSSong Gao temp.E1(i + LSX_LEN/BIT) = do_ssrlnu_ ## E1(Vd->E2(i), imm, BIT/2); \ 145383b3815dSSong Gao } \ 145483b3815dSSong Gao *Vd = temp; \ 145583b3815dSSong Gao } 145683b3815dSSong Gao 145783b3815dSSong Gao void HELPER(vssrlni_du_q)(CPULoongArchState *env, 145883b3815dSSong Gao uint32_t vd, uint32_t vj, uint32_t imm) 145983b3815dSSong Gao { 146083b3815dSSong Gao Int128 shft_res1, shft_res2, mask; 146183b3815dSSong Gao VReg *Vd = &(env->fpr[vd].vreg); 146283b3815dSSong Gao VReg *Vj = &(env->fpr[vj].vreg); 146383b3815dSSong Gao 146483b3815dSSong Gao if (imm == 0) { 146583b3815dSSong Gao shft_res1 = Vj->Q(0); 146683b3815dSSong Gao shft_res2 = Vd->Q(0); 146783b3815dSSong Gao } else { 146883b3815dSSong Gao shft_res1 = int128_urshift(Vj->Q(0), imm); 146983b3815dSSong Gao shft_res2 = int128_urshift(Vd->Q(0), imm); 147083b3815dSSong Gao } 147183b3815dSSong Gao mask = int128_sub(int128_lshift(int128_one(), 64), int128_one()); 147283b3815dSSong Gao 147383b3815dSSong Gao if (int128_ult(mask, shft_res1)) { 147483b3815dSSong Gao Vd->D(0) = int128_getlo(mask); 147583b3815dSSong Gao }else { 147683b3815dSSong Gao Vd->D(0) = int128_getlo(shft_res1); 147783b3815dSSong Gao } 147883b3815dSSong Gao 147983b3815dSSong Gao if (int128_ult(mask, shft_res2)) { 148083b3815dSSong Gao Vd->D(1) = int128_getlo(mask); 148183b3815dSSong Gao }else { 148283b3815dSSong Gao Vd->D(1) = int128_getlo(shft_res2); 148383b3815dSSong Gao } 148483b3815dSSong Gao } 148583b3815dSSong Gao 148683b3815dSSong Gao VSSRLNUI(vssrlni_bu_h, 16, B, H) 148783b3815dSSong Gao VSSRLNUI(vssrlni_hu_w, 32, H, W) 148883b3815dSSong Gao VSSRLNUI(vssrlni_wu_d, 64, W, D) 148983b3815dSSong Gao 149083b3815dSSong Gao #define VSSRANUI(NAME, BIT, E1, E2) \ 149183b3815dSSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 149283b3815dSSong Gao uint32_t vd, uint32_t vj, uint32_t imm) \ 149383b3815dSSong Gao { \ 149483b3815dSSong Gao int i; \ 149583b3815dSSong Gao VReg temp; \ 149683b3815dSSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 149783b3815dSSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 149883b3815dSSong Gao \ 149983b3815dSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 150083b3815dSSong Gao temp.E1(i) = do_ssranu_ ## E1(Vj->E2(i), imm, BIT/2); \ 150183b3815dSSong Gao temp.E1(i + LSX_LEN/BIT) = do_ssranu_ ## E1(Vd->E2(i), imm, BIT/2); \ 150283b3815dSSong Gao } \ 150383b3815dSSong Gao *Vd = temp; \ 150483b3815dSSong Gao } 150583b3815dSSong Gao 150683b3815dSSong Gao void HELPER(vssrani_du_q)(CPULoongArchState *env, 150783b3815dSSong Gao uint32_t vd, uint32_t vj, uint32_t imm) 150883b3815dSSong Gao { 150983b3815dSSong Gao Int128 shft_res1, shft_res2, mask; 151083b3815dSSong Gao VReg *Vd = &(env->fpr[vd].vreg); 151183b3815dSSong Gao VReg *Vj = &(env->fpr[vj].vreg); 151283b3815dSSong Gao 151383b3815dSSong Gao if (imm == 0) { 151483b3815dSSong Gao shft_res1 = Vj->Q(0); 151583b3815dSSong Gao shft_res2 = Vd->Q(0); 151683b3815dSSong Gao } else { 151783b3815dSSong Gao shft_res1 = int128_rshift(Vj->Q(0), imm); 151883b3815dSSong Gao shft_res2 = int128_rshift(Vd->Q(0), imm); 151983b3815dSSong Gao } 152083b3815dSSong Gao 152183b3815dSSong Gao if (int128_lt(Vj->Q(0), int128_zero())) { 152283b3815dSSong Gao shft_res1 = int128_zero(); 152383b3815dSSong Gao } 152483b3815dSSong Gao 152583b3815dSSong Gao if (int128_lt(Vd->Q(0), int128_zero())) { 152683b3815dSSong Gao shft_res2 = int128_zero(); 152783b3815dSSong Gao } 152883b3815dSSong Gao 152983b3815dSSong Gao mask = int128_sub(int128_lshift(int128_one(), 64), int128_one()); 153083b3815dSSong Gao 153183b3815dSSong Gao if (int128_ult(mask, shft_res1)) { 153283b3815dSSong Gao Vd->D(0) = int128_getlo(mask); 153383b3815dSSong Gao }else { 153483b3815dSSong Gao Vd->D(0) = int128_getlo(shft_res1); 153583b3815dSSong Gao } 153683b3815dSSong Gao 153783b3815dSSong Gao if (int128_ult(mask, shft_res2)) { 153883b3815dSSong Gao Vd->D(1) = int128_getlo(mask); 153983b3815dSSong Gao }else { 154083b3815dSSong Gao Vd->D(1) = int128_getlo(shft_res2); 154183b3815dSSong Gao } 154283b3815dSSong Gao } 154383b3815dSSong Gao 154483b3815dSSong Gao VSSRANUI(vssrani_bu_h, 16, B, H) 154583b3815dSSong Gao VSSRANUI(vssrani_hu_w, 32, H, W) 154683b3815dSSong Gao VSSRANUI(vssrani_wu_d, 64, W, D) 1547162cd32cSSong Gao 1548162cd32cSSong Gao #define SSRLRNS(E1, E2, T1, T2, T3) \ 1549162cd32cSSong Gao static T1 do_ssrlrns_ ## E1(T2 e2, int sa, int sh) \ 1550162cd32cSSong Gao { \ 1551162cd32cSSong Gao T1 shft_res; \ 1552162cd32cSSong Gao \ 1553162cd32cSSong Gao shft_res = do_vsrlr_ ## E2(e2, sa); \ 1554162cd32cSSong Gao T1 mask; \ 1555162cd32cSSong Gao mask = (1ull << sh) -1; \ 1556162cd32cSSong Gao if (shft_res > mask) { \ 1557162cd32cSSong Gao return mask; \ 1558162cd32cSSong Gao } else { \ 1559162cd32cSSong Gao return shft_res; \ 1560162cd32cSSong Gao } \ 1561162cd32cSSong Gao } 1562162cd32cSSong Gao 1563162cd32cSSong Gao SSRLRNS(B, H, uint16_t, int16_t, uint8_t) 1564162cd32cSSong Gao SSRLRNS(H, W, uint32_t, int32_t, uint16_t) 1565162cd32cSSong Gao SSRLRNS(W, D, uint64_t, int64_t, uint32_t) 1566162cd32cSSong Gao 1567162cd32cSSong Gao #define VSSRLRN(NAME, BIT, T, E1, E2) \ 156804711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 1569162cd32cSSong Gao { \ 1570162cd32cSSong Gao int i; \ 157104711da1SSong Gao VReg *Vd = (VReg *)vd; \ 157204711da1SSong Gao VReg *Vj = (VReg *)vj; \ 157304711da1SSong Gao VReg *Vk = (VReg *)vk; \ 1574162cd32cSSong Gao \ 1575162cd32cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1576162cd32cSSong Gao Vd->E1(i) = do_ssrlrns_ ## E1(Vj->E2(i), (T)Vk->E2(i)%BIT, BIT/2 -1); \ 1577162cd32cSSong Gao } \ 1578162cd32cSSong Gao Vd->D(1) = 0; \ 1579162cd32cSSong Gao } 1580162cd32cSSong Gao 1581162cd32cSSong Gao VSSRLRN(vssrlrn_b_h, 16, uint16_t, B, H) 1582162cd32cSSong Gao VSSRLRN(vssrlrn_h_w, 32, uint32_t, H, W) 1583162cd32cSSong Gao VSSRLRN(vssrlrn_w_d, 64, uint64_t, W, D) 1584162cd32cSSong Gao 1585162cd32cSSong Gao #define SSRARNS(E1, E2, T1, T2) \ 1586162cd32cSSong Gao static T1 do_ssrarns_ ## E1(T1 e2, int sa, int sh) \ 1587162cd32cSSong Gao { \ 1588162cd32cSSong Gao T1 shft_res; \ 1589162cd32cSSong Gao \ 1590162cd32cSSong Gao shft_res = do_vsrar_ ## E2(e2, sa); \ 1591162cd32cSSong Gao T2 mask; \ 1592162cd32cSSong Gao mask = (1ll << sh) -1; \ 1593162cd32cSSong Gao if (shft_res > mask) { \ 1594162cd32cSSong Gao return mask; \ 1595162cd32cSSong Gao } else if (shft_res < -(mask +1)) { \ 1596162cd32cSSong Gao return ~mask; \ 1597162cd32cSSong Gao } else { \ 1598162cd32cSSong Gao return shft_res; \ 1599162cd32cSSong Gao } \ 1600162cd32cSSong Gao } 1601162cd32cSSong Gao 1602162cd32cSSong Gao SSRARNS(B, H, int16_t, int8_t) 1603162cd32cSSong Gao SSRARNS(H, W, int32_t, int16_t) 1604162cd32cSSong Gao SSRARNS(W, D, int64_t, int32_t) 1605162cd32cSSong Gao 1606162cd32cSSong Gao #define VSSRARN(NAME, BIT, T, E1, E2) \ 160704711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 1608162cd32cSSong Gao { \ 1609162cd32cSSong Gao int i; \ 161004711da1SSong Gao VReg *Vd = (VReg *)vd; \ 161104711da1SSong Gao VReg *Vj = (VReg *)vj; \ 161204711da1SSong Gao VReg *Vk = (VReg *)vk; \ 1613162cd32cSSong Gao \ 1614162cd32cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1615162cd32cSSong Gao Vd->E1(i) = do_ssrarns_ ## E1(Vj->E2(i), (T)Vk->E2(i)%BIT, BIT/2 -1); \ 1616162cd32cSSong Gao } \ 1617162cd32cSSong Gao Vd->D(1) = 0; \ 1618162cd32cSSong Gao } 1619162cd32cSSong Gao 1620162cd32cSSong Gao VSSRARN(vssrarn_b_h, 16, uint16_t, B, H) 1621162cd32cSSong Gao VSSRARN(vssrarn_h_w, 32, uint32_t, H, W) 1622162cd32cSSong Gao VSSRARN(vssrarn_w_d, 64, uint64_t, W, D) 1623162cd32cSSong Gao 1624162cd32cSSong Gao #define SSRLRNU(E1, E2, T1, T2, T3) \ 1625162cd32cSSong Gao static T1 do_ssrlrnu_ ## E1(T3 e2, int sa, int sh) \ 1626162cd32cSSong Gao { \ 1627162cd32cSSong Gao T1 shft_res; \ 1628162cd32cSSong Gao \ 1629162cd32cSSong Gao shft_res = do_vsrlr_ ## E2(e2, sa); \ 1630162cd32cSSong Gao \ 1631162cd32cSSong Gao T2 mask; \ 1632162cd32cSSong Gao mask = (1ull << sh) -1; \ 1633162cd32cSSong Gao if (shft_res > mask) { \ 1634162cd32cSSong Gao return mask; \ 1635162cd32cSSong Gao } else { \ 1636162cd32cSSong Gao return shft_res; \ 1637162cd32cSSong Gao } \ 1638162cd32cSSong Gao } 1639162cd32cSSong Gao 1640162cd32cSSong Gao SSRLRNU(B, H, uint16_t, uint8_t, int16_t) 1641162cd32cSSong Gao SSRLRNU(H, W, uint32_t, uint16_t, int32_t) 1642162cd32cSSong Gao SSRLRNU(W, D, uint64_t, uint32_t, int64_t) 1643162cd32cSSong Gao 1644162cd32cSSong Gao #define VSSRLRNU(NAME, BIT, T, E1, E2) \ 164504711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 1646162cd32cSSong Gao { \ 1647162cd32cSSong Gao int i; \ 164804711da1SSong Gao VReg *Vd = (VReg *)vd; \ 164904711da1SSong Gao VReg *Vj = (VReg *)vj; \ 165004711da1SSong Gao VReg *Vk = (VReg *)vk; \ 1651162cd32cSSong Gao \ 1652162cd32cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1653162cd32cSSong Gao Vd->E1(i) = do_ssrlrnu_ ## E1(Vj->E2(i), (T)Vk->E2(i)%BIT, BIT/2); \ 1654162cd32cSSong Gao } \ 1655162cd32cSSong Gao Vd->D(1) = 0; \ 1656162cd32cSSong Gao } 1657162cd32cSSong Gao 1658162cd32cSSong Gao VSSRLRNU(vssrlrn_bu_h, 16, uint16_t, B, H) 1659162cd32cSSong Gao VSSRLRNU(vssrlrn_hu_w, 32, uint32_t, H, W) 1660162cd32cSSong Gao VSSRLRNU(vssrlrn_wu_d, 64, uint64_t, W, D) 1661162cd32cSSong Gao 1662162cd32cSSong Gao #define SSRARNU(E1, E2, T1, T2, T3) \ 1663162cd32cSSong Gao static T1 do_ssrarnu_ ## E1(T3 e2, int sa, int sh) \ 1664162cd32cSSong Gao { \ 1665162cd32cSSong Gao T1 shft_res; \ 1666162cd32cSSong Gao \ 1667162cd32cSSong Gao if (e2 < 0) { \ 1668162cd32cSSong Gao shft_res = 0; \ 1669162cd32cSSong Gao } else { \ 1670162cd32cSSong Gao shft_res = do_vsrar_ ## E2(e2, sa); \ 1671162cd32cSSong Gao } \ 1672162cd32cSSong Gao T2 mask; \ 1673162cd32cSSong Gao mask = (1ull << sh) -1; \ 1674162cd32cSSong Gao if (shft_res > mask) { \ 1675162cd32cSSong Gao return mask; \ 1676162cd32cSSong Gao } else { \ 1677162cd32cSSong Gao return shft_res; \ 1678162cd32cSSong Gao } \ 1679162cd32cSSong Gao } 1680162cd32cSSong Gao 1681162cd32cSSong Gao SSRARNU(B, H, uint16_t, uint8_t, int16_t) 1682162cd32cSSong Gao SSRARNU(H, W, uint32_t, uint16_t, int32_t) 1683162cd32cSSong Gao SSRARNU(W, D, uint64_t, uint32_t, int64_t) 1684162cd32cSSong Gao 1685162cd32cSSong Gao #define VSSRARNU(NAME, BIT, T, E1, E2) \ 168604711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 1687162cd32cSSong Gao { \ 1688162cd32cSSong Gao int i; \ 168904711da1SSong Gao VReg *Vd = (VReg *)vd; \ 169004711da1SSong Gao VReg *Vj = (VReg *)vj; \ 169104711da1SSong Gao VReg *Vk = (VReg *)vk; \ 1692162cd32cSSong Gao \ 1693162cd32cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1694162cd32cSSong Gao Vd->E1(i) = do_ssrarnu_ ## E1(Vj->E2(i), (T)Vk->E2(i)%BIT, BIT/2); \ 1695162cd32cSSong Gao } \ 1696162cd32cSSong Gao Vd->D(1) = 0; \ 1697162cd32cSSong Gao } 1698162cd32cSSong Gao 1699162cd32cSSong Gao VSSRARNU(vssrarn_bu_h, 16, uint16_t, B, H) 1700162cd32cSSong Gao VSSRARNU(vssrarn_hu_w, 32, uint32_t, H, W) 1701162cd32cSSong Gao VSSRARNU(vssrarn_wu_d, 64, uint64_t, W, D) 1702162cd32cSSong Gao 1703162cd32cSSong Gao #define VSSRLRNI(NAME, BIT, E1, E2) \ 1704162cd32cSSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 1705162cd32cSSong Gao uint32_t vd, uint32_t vj, uint32_t imm) \ 1706162cd32cSSong Gao { \ 1707162cd32cSSong Gao int i; \ 1708162cd32cSSong Gao VReg temp; \ 1709162cd32cSSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 1710162cd32cSSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 1711162cd32cSSong Gao \ 1712162cd32cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1713162cd32cSSong Gao temp.E1(i) = do_ssrlrns_ ## E1(Vj->E2(i), imm, BIT/2 -1); \ 1714162cd32cSSong Gao temp.E1(i + LSX_LEN/BIT) = do_ssrlrns_ ## E1(Vd->E2(i), imm, BIT/2 -1);\ 1715162cd32cSSong Gao } \ 1716162cd32cSSong Gao *Vd = temp; \ 1717162cd32cSSong Gao } 1718162cd32cSSong Gao 1719162cd32cSSong Gao #define VSSRLRNI_Q(NAME, sh) \ 1720162cd32cSSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 1721162cd32cSSong Gao uint32_t vd, uint32_t vj, uint32_t imm) \ 1722162cd32cSSong Gao { \ 1723162cd32cSSong Gao Int128 shft_res1, shft_res2, mask, r1, r2; \ 1724162cd32cSSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 1725162cd32cSSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 1726162cd32cSSong Gao \ 1727162cd32cSSong Gao if (imm == 0) { \ 1728162cd32cSSong Gao shft_res1 = Vj->Q(0); \ 1729162cd32cSSong Gao shft_res2 = Vd->Q(0); \ 1730162cd32cSSong Gao } else { \ 1731162cd32cSSong Gao r1 = int128_and(int128_urshift(Vj->Q(0), (imm -1)), int128_one()); \ 1732162cd32cSSong Gao r2 = int128_and(int128_urshift(Vd->Q(0), (imm -1)), int128_one()); \ 1733162cd32cSSong Gao \ 1734162cd32cSSong Gao shft_res1 = (int128_add(int128_urshift(Vj->Q(0), imm), r1)); \ 1735162cd32cSSong Gao shft_res2 = (int128_add(int128_urshift(Vd->Q(0), imm), r2)); \ 1736162cd32cSSong Gao } \ 1737162cd32cSSong Gao \ 1738162cd32cSSong Gao mask = int128_sub(int128_lshift(int128_one(), sh), int128_one()); \ 1739162cd32cSSong Gao \ 1740162cd32cSSong Gao if (int128_ult(mask, shft_res1)) { \ 1741162cd32cSSong Gao Vd->D(0) = int128_getlo(mask); \ 1742162cd32cSSong Gao }else { \ 1743162cd32cSSong Gao Vd->D(0) = int128_getlo(shft_res1); \ 1744162cd32cSSong Gao } \ 1745162cd32cSSong Gao \ 1746162cd32cSSong Gao if (int128_ult(mask, shft_res2)) { \ 1747162cd32cSSong Gao Vd->D(1) = int128_getlo(mask); \ 1748162cd32cSSong Gao }else { \ 1749162cd32cSSong Gao Vd->D(1) = int128_getlo(shft_res2); \ 1750162cd32cSSong Gao } \ 1751162cd32cSSong Gao } 1752162cd32cSSong Gao 1753162cd32cSSong Gao VSSRLRNI(vssrlrni_b_h, 16, B, H) 1754162cd32cSSong Gao VSSRLRNI(vssrlrni_h_w, 32, H, W) 1755162cd32cSSong Gao VSSRLRNI(vssrlrni_w_d, 64, W, D) 1756162cd32cSSong Gao VSSRLRNI_Q(vssrlrni_d_q, 63) 1757162cd32cSSong Gao 1758162cd32cSSong Gao #define VSSRARNI(NAME, BIT, E1, E2) \ 1759162cd32cSSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 1760162cd32cSSong Gao uint32_t vd, uint32_t vj, uint32_t imm) \ 1761162cd32cSSong Gao { \ 1762162cd32cSSong Gao int i; \ 1763162cd32cSSong Gao VReg temp; \ 1764162cd32cSSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 1765162cd32cSSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 1766162cd32cSSong Gao \ 1767162cd32cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1768162cd32cSSong Gao temp.E1(i) = do_ssrarns_ ## E1(Vj->E2(i), imm, BIT/2 -1); \ 1769162cd32cSSong Gao temp.E1(i + LSX_LEN/BIT) = do_ssrarns_ ## E1(Vd->E2(i), imm, BIT/2 -1); \ 1770162cd32cSSong Gao } \ 1771162cd32cSSong Gao *Vd = temp; \ 1772162cd32cSSong Gao } 1773162cd32cSSong Gao 1774162cd32cSSong Gao void HELPER(vssrarni_d_q)(CPULoongArchState *env, 1775162cd32cSSong Gao uint32_t vd, uint32_t vj, uint32_t imm) 1776162cd32cSSong Gao { 1777162cd32cSSong Gao Int128 shft_res1, shft_res2, mask1, mask2, r1, r2; 1778162cd32cSSong Gao VReg *Vd = &(env->fpr[vd].vreg); 1779162cd32cSSong Gao VReg *Vj = &(env->fpr[vj].vreg); 1780162cd32cSSong Gao 1781162cd32cSSong Gao if (imm == 0) { 1782162cd32cSSong Gao shft_res1 = Vj->Q(0); 1783162cd32cSSong Gao shft_res2 = Vd->Q(0); 1784162cd32cSSong Gao } else { 1785162cd32cSSong Gao r1 = int128_and(int128_rshift(Vj->Q(0), (imm -1)), int128_one()); 1786162cd32cSSong Gao r2 = int128_and(int128_rshift(Vd->Q(0), (imm -1)), int128_one()); 1787162cd32cSSong Gao 1788162cd32cSSong Gao shft_res1 = int128_add(int128_rshift(Vj->Q(0), imm), r1); 1789162cd32cSSong Gao shft_res2 = int128_add(int128_rshift(Vd->Q(0), imm), r2); 1790162cd32cSSong Gao } 1791162cd32cSSong Gao 1792162cd32cSSong Gao mask1 = int128_sub(int128_lshift(int128_one(), 63), int128_one()); 1793162cd32cSSong Gao mask2 = int128_lshift(int128_one(), 63); 1794162cd32cSSong Gao 1795162cd32cSSong Gao if (int128_gt(shft_res1, mask1)) { 1796162cd32cSSong Gao Vd->D(0) = int128_getlo(mask1); 1797162cd32cSSong Gao } else if (int128_lt(shft_res1, int128_neg(mask2))) { 1798162cd32cSSong Gao Vd->D(0) = int128_getlo(mask2); 1799162cd32cSSong Gao } else { 1800162cd32cSSong Gao Vd->D(0) = int128_getlo(shft_res1); 1801162cd32cSSong Gao } 1802162cd32cSSong Gao 1803162cd32cSSong Gao if (int128_gt(shft_res2, mask1)) { 1804162cd32cSSong Gao Vd->D(1) = int128_getlo(mask1); 1805162cd32cSSong Gao } else if (int128_lt(shft_res2, int128_neg(mask2))) { 1806162cd32cSSong Gao Vd->D(1) = int128_getlo(mask2); 1807162cd32cSSong Gao } else { 1808162cd32cSSong Gao Vd->D(1) = int128_getlo(shft_res2); 1809162cd32cSSong Gao } 1810162cd32cSSong Gao } 1811162cd32cSSong Gao 1812162cd32cSSong Gao VSSRARNI(vssrarni_b_h, 16, B, H) 1813162cd32cSSong Gao VSSRARNI(vssrarni_h_w, 32, H, W) 1814162cd32cSSong Gao VSSRARNI(vssrarni_w_d, 64, W, D) 1815162cd32cSSong Gao 1816162cd32cSSong Gao #define VSSRLRNUI(NAME, BIT, E1, E2) \ 1817162cd32cSSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 1818162cd32cSSong Gao uint32_t vd, uint32_t vj, uint32_t imm) \ 1819162cd32cSSong Gao { \ 1820162cd32cSSong Gao int i; \ 1821162cd32cSSong Gao VReg temp; \ 1822162cd32cSSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 1823162cd32cSSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 1824162cd32cSSong Gao \ 1825162cd32cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1826162cd32cSSong Gao temp.E1(i) = do_ssrlrnu_ ## E1(Vj->E2(i), imm, BIT/2); \ 1827162cd32cSSong Gao temp.E1(i + LSX_LEN/BIT) = do_ssrlrnu_ ## E1(Vd->E2(i), imm, BIT/2); \ 1828162cd32cSSong Gao } \ 1829162cd32cSSong Gao *Vd = temp; \ 1830162cd32cSSong Gao } 1831162cd32cSSong Gao 1832162cd32cSSong Gao VSSRLRNUI(vssrlrni_bu_h, 16, B, H) 1833162cd32cSSong Gao VSSRLRNUI(vssrlrni_hu_w, 32, H, W) 1834162cd32cSSong Gao VSSRLRNUI(vssrlrni_wu_d, 64, W, D) 1835162cd32cSSong Gao VSSRLRNI_Q(vssrlrni_du_q, 64) 1836162cd32cSSong Gao 1837162cd32cSSong Gao #define VSSRARNUI(NAME, BIT, E1, E2) \ 1838162cd32cSSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 1839162cd32cSSong Gao uint32_t vd, uint32_t vj, uint32_t imm) \ 1840162cd32cSSong Gao { \ 1841162cd32cSSong Gao int i; \ 1842162cd32cSSong Gao VReg temp; \ 1843162cd32cSSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 1844162cd32cSSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 1845162cd32cSSong Gao \ 1846162cd32cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1847162cd32cSSong Gao temp.E1(i) = do_ssrarnu_ ## E1(Vj->E2(i), imm, BIT/2); \ 1848162cd32cSSong Gao temp.E1(i + LSX_LEN/BIT) = do_ssrarnu_ ## E1(Vd->E2(i), imm, BIT/2); \ 1849162cd32cSSong Gao } \ 1850162cd32cSSong Gao *Vd = temp; \ 1851162cd32cSSong Gao } 1852162cd32cSSong Gao 1853162cd32cSSong Gao void HELPER(vssrarni_du_q)(CPULoongArchState *env, 1854162cd32cSSong Gao uint32_t vd, uint32_t vj, uint32_t imm) 1855162cd32cSSong Gao { 1856162cd32cSSong Gao Int128 shft_res1, shft_res2, mask1, mask2, r1, r2; 1857162cd32cSSong Gao VReg *Vd = &(env->fpr[vd].vreg); 1858162cd32cSSong Gao VReg *Vj = &(env->fpr[vj].vreg); 1859162cd32cSSong Gao 1860162cd32cSSong Gao if (imm == 0) { 1861162cd32cSSong Gao shft_res1 = Vj->Q(0); 1862162cd32cSSong Gao shft_res2 = Vd->Q(0); 1863162cd32cSSong Gao } else { 1864162cd32cSSong Gao r1 = int128_and(int128_rshift(Vj->Q(0), (imm -1)), int128_one()); 1865162cd32cSSong Gao r2 = int128_and(int128_rshift(Vd->Q(0), (imm -1)), int128_one()); 1866162cd32cSSong Gao 1867162cd32cSSong Gao shft_res1 = int128_add(int128_rshift(Vj->Q(0), imm), r1); 1868162cd32cSSong Gao shft_res2 = int128_add(int128_rshift(Vd->Q(0), imm), r2); 1869162cd32cSSong Gao } 1870162cd32cSSong Gao 1871162cd32cSSong Gao if (int128_lt(Vj->Q(0), int128_zero())) { 1872162cd32cSSong Gao shft_res1 = int128_zero(); 1873162cd32cSSong Gao } 1874162cd32cSSong Gao if (int128_lt(Vd->Q(0), int128_zero())) { 1875162cd32cSSong Gao shft_res2 = int128_zero(); 1876162cd32cSSong Gao } 1877162cd32cSSong Gao 1878162cd32cSSong Gao mask1 = int128_sub(int128_lshift(int128_one(), 64), int128_one()); 1879162cd32cSSong Gao mask2 = int128_lshift(int128_one(), 64); 1880162cd32cSSong Gao 1881162cd32cSSong Gao if (int128_gt(shft_res1, mask1)) { 1882162cd32cSSong Gao Vd->D(0) = int128_getlo(mask1); 1883162cd32cSSong Gao } else if (int128_lt(shft_res1, int128_neg(mask2))) { 1884162cd32cSSong Gao Vd->D(0) = int128_getlo(mask2); 1885162cd32cSSong Gao } else { 1886162cd32cSSong Gao Vd->D(0) = int128_getlo(shft_res1); 1887162cd32cSSong Gao } 1888162cd32cSSong Gao 1889162cd32cSSong Gao if (int128_gt(shft_res2, mask1)) { 1890162cd32cSSong Gao Vd->D(1) = int128_getlo(mask1); 1891162cd32cSSong Gao } else if (int128_lt(shft_res2, int128_neg(mask2))) { 1892162cd32cSSong Gao Vd->D(1) = int128_getlo(mask2); 1893162cd32cSSong Gao } else { 1894162cd32cSSong Gao Vd->D(1) = int128_getlo(shft_res2); 1895162cd32cSSong Gao } 1896162cd32cSSong Gao } 1897162cd32cSSong Gao 1898162cd32cSSong Gao VSSRARNUI(vssrarni_bu_h, 16, B, H) 1899162cd32cSSong Gao VSSRARNUI(vssrarni_hu_w, 32, H, W) 1900162cd32cSSong Gao VSSRARNUI(vssrarni_wu_d, 64, W, D) 19012e105e12SSong Gao 19022e105e12SSong Gao #define DO_2OP(NAME, BIT, E, DO_OP) \ 1903ff27e335SSong Gao void HELPER(NAME)(void *vd, void *vj, uint32_t desc) \ 19042e105e12SSong Gao { \ 19052e105e12SSong Gao int i; \ 1906ff27e335SSong Gao VReg *Vd = (VReg *)vd; \ 1907ff27e335SSong Gao VReg *Vj = (VReg *)vj; \ 19082e105e12SSong Gao \ 19092e105e12SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) \ 19102e105e12SSong Gao { \ 19112e105e12SSong Gao Vd->E(i) = DO_OP(Vj->E(i)); \ 19122e105e12SSong Gao } \ 19132e105e12SSong Gao } 19142e105e12SSong Gao 19152e105e12SSong Gao #define DO_CLO_B(N) (clz32(~N & 0xff) - 24) 19162e105e12SSong Gao #define DO_CLO_H(N) (clz32(~N & 0xffff) - 16) 19172e105e12SSong Gao #define DO_CLO_W(N) (clz32(~N)) 19182e105e12SSong Gao #define DO_CLO_D(N) (clz64(~N)) 19192e105e12SSong Gao #define DO_CLZ_B(N) (clz32(N) - 24) 19202e105e12SSong Gao #define DO_CLZ_H(N) (clz32(N) - 16) 19212e105e12SSong Gao #define DO_CLZ_W(N) (clz32(N)) 19222e105e12SSong Gao #define DO_CLZ_D(N) (clz64(N)) 19232e105e12SSong Gao 19242e105e12SSong Gao DO_2OP(vclo_b, 8, UB, DO_CLO_B) 19252e105e12SSong Gao DO_2OP(vclo_h, 16, UH, DO_CLO_H) 19262e105e12SSong Gao DO_2OP(vclo_w, 32, UW, DO_CLO_W) 19272e105e12SSong Gao DO_2OP(vclo_d, 64, UD, DO_CLO_D) 19282e105e12SSong Gao DO_2OP(vclz_b, 8, UB, DO_CLZ_B) 19292e105e12SSong Gao DO_2OP(vclz_h, 16, UH, DO_CLZ_H) 19302e105e12SSong Gao DO_2OP(vclz_w, 32, UW, DO_CLZ_W) 19312e105e12SSong Gao DO_2OP(vclz_d, 64, UD, DO_CLZ_D) 1932bb22ee57SSong Gao 1933bb22ee57SSong Gao #define VPCNT(NAME, BIT, E, FN) \ 1934ff27e335SSong Gao void HELPER(NAME)(void *vd, void *vj, uint32_t desc) \ 1935bb22ee57SSong Gao { \ 1936bb22ee57SSong Gao int i; \ 1937ff27e335SSong Gao VReg *Vd = (VReg *)vd; \ 1938ff27e335SSong Gao VReg *Vj = (VReg *)vj; \ 1939bb22ee57SSong Gao \ 1940bb22ee57SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) \ 1941bb22ee57SSong Gao { \ 1942bb22ee57SSong Gao Vd->E(i) = FN(Vj->E(i)); \ 1943bb22ee57SSong Gao } \ 1944bb22ee57SSong Gao } 1945bb22ee57SSong Gao 1946bb22ee57SSong Gao VPCNT(vpcnt_b, 8, UB, ctpop8) 1947bb22ee57SSong Gao VPCNT(vpcnt_h, 16, UH, ctpop16) 1948bb22ee57SSong Gao VPCNT(vpcnt_w, 32, UW, ctpop32) 1949bb22ee57SSong Gao VPCNT(vpcnt_d, 64, UD, ctpop64) 19500b1e6705SSong Gao 19510b1e6705SSong Gao #define DO_BITCLR(a, bit) (a & ~(1ull << bit)) 19520b1e6705SSong Gao #define DO_BITSET(a, bit) (a | 1ull << bit) 19530b1e6705SSong Gao #define DO_BITREV(a, bit) (a ^ (1ull << bit)) 19540b1e6705SSong Gao 19550b1e6705SSong Gao #define DO_BIT(NAME, BIT, E, DO_OP) \ 19560b1e6705SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t v) \ 19570b1e6705SSong Gao { \ 19580b1e6705SSong Gao int i; \ 19590b1e6705SSong Gao VReg *Vd = (VReg *)vd; \ 19600b1e6705SSong Gao VReg *Vj = (VReg *)vj; \ 19610b1e6705SSong Gao VReg *Vk = (VReg *)vk; \ 19620b1e6705SSong Gao \ 19630b1e6705SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 19640b1e6705SSong Gao Vd->E(i) = DO_OP(Vj->E(i), Vk->E(i)%BIT); \ 19650b1e6705SSong Gao } \ 19660b1e6705SSong Gao } 19670b1e6705SSong Gao 19680b1e6705SSong Gao DO_BIT(vbitclr_b, 8, UB, DO_BITCLR) 19690b1e6705SSong Gao DO_BIT(vbitclr_h, 16, UH, DO_BITCLR) 19700b1e6705SSong Gao DO_BIT(vbitclr_w, 32, UW, DO_BITCLR) 19710b1e6705SSong Gao DO_BIT(vbitclr_d, 64, UD, DO_BITCLR) 19720b1e6705SSong Gao DO_BIT(vbitset_b, 8, UB, DO_BITSET) 19730b1e6705SSong Gao DO_BIT(vbitset_h, 16, UH, DO_BITSET) 19740b1e6705SSong Gao DO_BIT(vbitset_w, 32, UW, DO_BITSET) 19750b1e6705SSong Gao DO_BIT(vbitset_d, 64, UD, DO_BITSET) 19760b1e6705SSong Gao DO_BIT(vbitrev_b, 8, UB, DO_BITREV) 19770b1e6705SSong Gao DO_BIT(vbitrev_h, 16, UH, DO_BITREV) 19780b1e6705SSong Gao DO_BIT(vbitrev_w, 32, UW, DO_BITREV) 19790b1e6705SSong Gao DO_BIT(vbitrev_d, 64, UD, DO_BITREV) 19800b1e6705SSong Gao 19810b1e6705SSong Gao #define DO_BITI(NAME, BIT, E, DO_OP) \ 19820b1e6705SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t v) \ 19830b1e6705SSong Gao { \ 19840b1e6705SSong Gao int i; \ 19850b1e6705SSong Gao VReg *Vd = (VReg *)vd; \ 19860b1e6705SSong Gao VReg *Vj = (VReg *)vj; \ 19870b1e6705SSong Gao \ 19880b1e6705SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 19890b1e6705SSong Gao Vd->E(i) = DO_OP(Vj->E(i), imm); \ 19900b1e6705SSong Gao } \ 19910b1e6705SSong Gao } 19920b1e6705SSong Gao 19930b1e6705SSong Gao DO_BITI(vbitclri_b, 8, UB, DO_BITCLR) 19940b1e6705SSong Gao DO_BITI(vbitclri_h, 16, UH, DO_BITCLR) 19950b1e6705SSong Gao DO_BITI(vbitclri_w, 32, UW, DO_BITCLR) 19960b1e6705SSong Gao DO_BITI(vbitclri_d, 64, UD, DO_BITCLR) 19970b1e6705SSong Gao DO_BITI(vbitseti_b, 8, UB, DO_BITSET) 19980b1e6705SSong Gao DO_BITI(vbitseti_h, 16, UH, DO_BITSET) 19990b1e6705SSong Gao DO_BITI(vbitseti_w, 32, UW, DO_BITSET) 20000b1e6705SSong Gao DO_BITI(vbitseti_d, 64, UD, DO_BITSET) 20010b1e6705SSong Gao DO_BITI(vbitrevi_b, 8, UB, DO_BITREV) 20020b1e6705SSong Gao DO_BITI(vbitrevi_h, 16, UH, DO_BITREV) 20030b1e6705SSong Gao DO_BITI(vbitrevi_w, 32, UW, DO_BITREV) 20040b1e6705SSong Gao DO_BITI(vbitrevi_d, 64, UD, DO_BITREV) 2005ac95a0b9SSong Gao 2006ac95a0b9SSong Gao #define VFRSTP(NAME, BIT, MASK, E) \ 200704711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 2008ac95a0b9SSong Gao { \ 2009ac95a0b9SSong Gao int i, m; \ 201004711da1SSong Gao VReg *Vd = (VReg *)vd; \ 201104711da1SSong Gao VReg *Vj = (VReg *)vj; \ 201204711da1SSong Gao VReg *Vk = (VReg *)vk; \ 2013ac95a0b9SSong Gao \ 2014ac95a0b9SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2015ac95a0b9SSong Gao if (Vj->E(i) < 0) { \ 2016ac95a0b9SSong Gao break; \ 2017ac95a0b9SSong Gao } \ 2018ac95a0b9SSong Gao } \ 2019ac95a0b9SSong Gao m = Vk->E(0) & MASK; \ 2020ac95a0b9SSong Gao Vd->E(m) = i; \ 2021ac95a0b9SSong Gao } 2022ac95a0b9SSong Gao 2023ac95a0b9SSong Gao VFRSTP(vfrstp_b, 8, 0xf, B) 2024ac95a0b9SSong Gao VFRSTP(vfrstp_h, 16, 0x7, H) 2025ac95a0b9SSong Gao 2026ac95a0b9SSong Gao #define VFRSTPI(NAME, BIT, E) \ 2027ac95a0b9SSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 2028ac95a0b9SSong Gao uint32_t vd, uint32_t vj, uint32_t imm) \ 2029ac95a0b9SSong Gao { \ 2030ac95a0b9SSong Gao int i, m; \ 2031ac95a0b9SSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 2032ac95a0b9SSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 2033ac95a0b9SSong Gao \ 2034ac95a0b9SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2035ac95a0b9SSong Gao if (Vj->E(i) < 0) { \ 2036ac95a0b9SSong Gao break; \ 2037ac95a0b9SSong Gao } \ 2038ac95a0b9SSong Gao } \ 2039ac95a0b9SSong Gao m = imm % (LSX_LEN/BIT); \ 2040ac95a0b9SSong Gao Vd->E(m) = i; \ 2041ac95a0b9SSong Gao } 2042ac95a0b9SSong Gao 2043ac95a0b9SSong Gao VFRSTPI(vfrstpi_b, 8, B) 2044ac95a0b9SSong Gao VFRSTPI(vfrstpi_h, 16, H) 2045aca67472SSong Gao 2046aca67472SSong Gao static void vec_update_fcsr0_mask(CPULoongArchState *env, 2047aca67472SSong Gao uintptr_t pc, int mask) 2048aca67472SSong Gao { 2049aca67472SSong Gao int flags = get_float_exception_flags(&env->fp_status); 2050aca67472SSong Gao 2051aca67472SSong Gao set_float_exception_flags(0, &env->fp_status); 2052aca67472SSong Gao 2053aca67472SSong Gao flags &= ~mask; 2054aca67472SSong Gao 2055aca67472SSong Gao if (flags) { 2056aca67472SSong Gao flags = ieee_ex_to_loongarch(flags); 2057aca67472SSong Gao UPDATE_FP_CAUSE(env->fcsr0, flags); 2058aca67472SSong Gao } 2059aca67472SSong Gao 2060aca67472SSong Gao if (GET_FP_ENABLES(env->fcsr0) & flags) { 2061aca67472SSong Gao do_raise_exception(env, EXCCODE_FPE, pc); 2062aca67472SSong Gao } else { 2063aca67472SSong Gao UPDATE_FP_FLAGS(env->fcsr0, flags); 2064aca67472SSong Gao } 2065aca67472SSong Gao } 2066aca67472SSong Gao 2067aca67472SSong Gao static void vec_update_fcsr0(CPULoongArchState *env, uintptr_t pc) 2068aca67472SSong Gao { 2069aca67472SSong Gao vec_update_fcsr0_mask(env, pc, 0); 2070aca67472SSong Gao } 2071aca67472SSong Gao 2072aca67472SSong Gao static inline void vec_clear_cause(CPULoongArchState *env) 2073aca67472SSong Gao { 2074aca67472SSong Gao SET_FP_CAUSE(env->fcsr0, 0); 2075aca67472SSong Gao } 2076aca67472SSong Gao 2077aca67472SSong Gao #define DO_3OP_F(NAME, BIT, E, FN) \ 20783b286753SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, \ 20793b286753SSong Gao CPULoongArchState *env, uint32_t desc) \ 2080aca67472SSong Gao { \ 2081aca67472SSong Gao int i; \ 20823b286753SSong Gao VReg *Vd = (VReg *)vd; \ 20833b286753SSong Gao VReg *Vj = (VReg *)vj; \ 20843b286753SSong Gao VReg *Vk = (VReg *)vk; \ 2085aca67472SSong Gao \ 2086aca67472SSong Gao vec_clear_cause(env); \ 2087aca67472SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2088aca67472SSong Gao Vd->E(i) = FN(Vj->E(i), Vk->E(i), &env->fp_status); \ 2089aca67472SSong Gao vec_update_fcsr0(env, GETPC()); \ 2090aca67472SSong Gao } \ 2091aca67472SSong Gao } 2092aca67472SSong Gao 2093aca67472SSong Gao DO_3OP_F(vfadd_s, 32, UW, float32_add) 2094aca67472SSong Gao DO_3OP_F(vfadd_d, 64, UD, float64_add) 2095aca67472SSong Gao DO_3OP_F(vfsub_s, 32, UW, float32_sub) 2096aca67472SSong Gao DO_3OP_F(vfsub_d, 64, UD, float64_sub) 2097aca67472SSong Gao DO_3OP_F(vfmul_s, 32, UW, float32_mul) 2098aca67472SSong Gao DO_3OP_F(vfmul_d, 64, UD, float64_mul) 2099aca67472SSong Gao DO_3OP_F(vfdiv_s, 32, UW, float32_div) 2100aca67472SSong Gao DO_3OP_F(vfdiv_d, 64, UD, float64_div) 2101aca67472SSong Gao DO_3OP_F(vfmax_s, 32, UW, float32_maxnum) 2102aca67472SSong Gao DO_3OP_F(vfmax_d, 64, UD, float64_maxnum) 2103aca67472SSong Gao DO_3OP_F(vfmin_s, 32, UW, float32_minnum) 2104aca67472SSong Gao DO_3OP_F(vfmin_d, 64, UD, float64_minnum) 2105aca67472SSong Gao DO_3OP_F(vfmaxa_s, 32, UW, float32_maxnummag) 2106aca67472SSong Gao DO_3OP_F(vfmaxa_d, 64, UD, float64_maxnummag) 2107aca67472SSong Gao DO_3OP_F(vfmina_s, 32, UW, float32_minnummag) 2108aca67472SSong Gao DO_3OP_F(vfmina_d, 64, UD, float64_minnummag) 2109aca67472SSong Gao 2110aca67472SSong Gao #define DO_4OP_F(NAME, BIT, E, FN, flags) \ 2111e2600dadSSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, void *va, \ 2112e2600dadSSong Gao CPULoongArchState *env, uint32_t desc) \ 2113aca67472SSong Gao { \ 2114aca67472SSong Gao int i; \ 2115e2600dadSSong Gao VReg *Vd = (VReg *)vd; \ 2116e2600dadSSong Gao VReg *Vj = (VReg *)vj; \ 2117e2600dadSSong Gao VReg *Vk = (VReg *)vk; \ 2118e2600dadSSong Gao VReg *Va = (VReg *)va; \ 2119aca67472SSong Gao \ 2120aca67472SSong Gao vec_clear_cause(env); \ 2121aca67472SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2122aca67472SSong Gao Vd->E(i) = FN(Vj->E(i), Vk->E(i), Va->E(i), flags, &env->fp_status); \ 2123aca67472SSong Gao vec_update_fcsr0(env, GETPC()); \ 2124aca67472SSong Gao } \ 2125aca67472SSong Gao } 2126aca67472SSong Gao 2127aca67472SSong Gao DO_4OP_F(vfmadd_s, 32, UW, float32_muladd, 0) 2128aca67472SSong Gao DO_4OP_F(vfmadd_d, 64, UD, float64_muladd, 0) 2129aca67472SSong Gao DO_4OP_F(vfmsub_s, 32, UW, float32_muladd, float_muladd_negate_c) 2130aca67472SSong Gao DO_4OP_F(vfmsub_d, 64, UD, float64_muladd, float_muladd_negate_c) 2131aca67472SSong Gao DO_4OP_F(vfnmadd_s, 32, UW, float32_muladd, float_muladd_negate_result) 2132aca67472SSong Gao DO_4OP_F(vfnmadd_d, 64, UD, float64_muladd, float_muladd_negate_result) 2133aca67472SSong Gao DO_4OP_F(vfnmsub_s, 32, UW, float32_muladd, 2134aca67472SSong Gao float_muladd_negate_c | float_muladd_negate_result) 2135aca67472SSong Gao DO_4OP_F(vfnmsub_d, 64, UD, float64_muladd, 2136aca67472SSong Gao float_muladd_negate_c | float_muladd_negate_result) 2137aca67472SSong Gao 2138aca67472SSong Gao #define DO_2OP_F(NAME, BIT, E, FN) \ 2139226bf881SSong Gao void HELPER(NAME)(void *vd, void *vj, \ 2140226bf881SSong Gao CPULoongArchState *env, uint32_t desc) \ 2141aca67472SSong Gao { \ 2142aca67472SSong Gao int i; \ 2143226bf881SSong Gao VReg *Vd = (VReg *)vd; \ 2144226bf881SSong Gao VReg *Vj = (VReg *)vj; \ 2145aca67472SSong Gao \ 2146aca67472SSong Gao vec_clear_cause(env); \ 2147aca67472SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2148aca67472SSong Gao Vd->E(i) = FN(env, Vj->E(i)); \ 2149aca67472SSong Gao } \ 2150aca67472SSong Gao } 2151aca67472SSong Gao 2152aca67472SSong Gao #define FLOGB(BIT, T) \ 2153aca67472SSong Gao static T do_flogb_## BIT(CPULoongArchState *env, T fj) \ 2154aca67472SSong Gao { \ 2155aca67472SSong Gao T fp, fd; \ 2156aca67472SSong Gao float_status *status = &env->fp_status; \ 2157aca67472SSong Gao FloatRoundMode old_mode = get_float_rounding_mode(status); \ 2158aca67472SSong Gao \ 2159aca67472SSong Gao set_float_rounding_mode(float_round_down, status); \ 2160aca67472SSong Gao fp = float ## BIT ##_log2(fj, status); \ 2161aca67472SSong Gao fd = float ## BIT ##_round_to_int(fp, status); \ 2162aca67472SSong Gao set_float_rounding_mode(old_mode, status); \ 2163aca67472SSong Gao vec_update_fcsr0_mask(env, GETPC(), float_flag_inexact); \ 2164aca67472SSong Gao return fd; \ 2165aca67472SSong Gao } 2166aca67472SSong Gao 2167aca67472SSong Gao FLOGB(32, uint32_t) 2168aca67472SSong Gao FLOGB(64, uint64_t) 2169aca67472SSong Gao 2170aca67472SSong Gao #define FCLASS(NAME, BIT, E, FN) \ 2171226bf881SSong Gao void HELPER(NAME)(void *vd, void *vj, \ 2172226bf881SSong Gao CPULoongArchState *env, uint32_t desc) \ 2173aca67472SSong Gao { \ 2174aca67472SSong Gao int i; \ 2175226bf881SSong Gao VReg *Vd = (VReg *)vd; \ 2176226bf881SSong Gao VReg *Vj = (VReg *)vj; \ 2177aca67472SSong Gao \ 2178aca67472SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2179aca67472SSong Gao Vd->E(i) = FN(env, Vj->E(i)); \ 2180aca67472SSong Gao } \ 2181aca67472SSong Gao } 2182aca67472SSong Gao 2183aca67472SSong Gao FCLASS(vfclass_s, 32, UW, helper_fclass_s) 2184aca67472SSong Gao FCLASS(vfclass_d, 64, UD, helper_fclass_d) 2185aca67472SSong Gao 2186aca67472SSong Gao #define FSQRT(BIT, T) \ 2187aca67472SSong Gao static T do_fsqrt_## BIT(CPULoongArchState *env, T fj) \ 2188aca67472SSong Gao { \ 2189aca67472SSong Gao T fd; \ 2190aca67472SSong Gao fd = float ## BIT ##_sqrt(fj, &env->fp_status); \ 2191aca67472SSong Gao vec_update_fcsr0(env, GETPC()); \ 2192aca67472SSong Gao return fd; \ 2193aca67472SSong Gao } 2194aca67472SSong Gao 2195aca67472SSong Gao FSQRT(32, uint32_t) 2196aca67472SSong Gao FSQRT(64, uint64_t) 2197aca67472SSong Gao 2198aca67472SSong Gao #define FRECIP(BIT, T) \ 2199aca67472SSong Gao static T do_frecip_## BIT(CPULoongArchState *env, T fj) \ 2200aca67472SSong Gao { \ 2201aca67472SSong Gao T fd; \ 2202aca67472SSong Gao fd = float ## BIT ##_div(float ## BIT ##_one, fj, &env->fp_status); \ 2203aca67472SSong Gao vec_update_fcsr0(env, GETPC()); \ 2204aca67472SSong Gao return fd; \ 2205aca67472SSong Gao } 2206aca67472SSong Gao 2207aca67472SSong Gao FRECIP(32, uint32_t) 2208aca67472SSong Gao FRECIP(64, uint64_t) 2209aca67472SSong Gao 2210aca67472SSong Gao #define FRSQRT(BIT, T) \ 2211aca67472SSong Gao static T do_frsqrt_## BIT(CPULoongArchState *env, T fj) \ 2212aca67472SSong Gao { \ 2213aca67472SSong Gao T fd, fp; \ 2214aca67472SSong Gao fp = float ## BIT ##_sqrt(fj, &env->fp_status); \ 2215aca67472SSong Gao fd = float ## BIT ##_div(float ## BIT ##_one, fp, &env->fp_status); \ 2216aca67472SSong Gao vec_update_fcsr0(env, GETPC()); \ 2217aca67472SSong Gao return fd; \ 2218aca67472SSong Gao } 2219aca67472SSong Gao 2220aca67472SSong Gao FRSQRT(32, uint32_t) 2221aca67472SSong Gao FRSQRT(64, uint64_t) 2222aca67472SSong Gao 2223aca67472SSong Gao DO_2OP_F(vflogb_s, 32, UW, do_flogb_32) 2224aca67472SSong Gao DO_2OP_F(vflogb_d, 64, UD, do_flogb_64) 2225aca67472SSong Gao DO_2OP_F(vfsqrt_s, 32, UW, do_fsqrt_32) 2226aca67472SSong Gao DO_2OP_F(vfsqrt_d, 64, UD, do_fsqrt_64) 2227aca67472SSong Gao DO_2OP_F(vfrecip_s, 32, UW, do_frecip_32) 2228aca67472SSong Gao DO_2OP_F(vfrecip_d, 64, UD, do_frecip_64) 2229aca67472SSong Gao DO_2OP_F(vfrsqrt_s, 32, UW, do_frsqrt_32) 2230aca67472SSong Gao DO_2OP_F(vfrsqrt_d, 64, UD, do_frsqrt_64) 2231399665d2SSong Gao 2232399665d2SSong Gao static uint32_t float16_cvt_float32(uint16_t h, float_status *status) 2233399665d2SSong Gao { 2234399665d2SSong Gao return float16_to_float32(h, true, status); 2235399665d2SSong Gao } 2236399665d2SSong Gao static uint64_t float32_cvt_float64(uint32_t s, float_status *status) 2237399665d2SSong Gao { 2238399665d2SSong Gao return float32_to_float64(s, status); 2239399665d2SSong Gao } 2240399665d2SSong Gao 2241399665d2SSong Gao static uint16_t float32_cvt_float16(uint32_t s, float_status *status) 2242399665d2SSong Gao { 2243399665d2SSong Gao return float32_to_float16(s, true, status); 2244399665d2SSong Gao } 2245399665d2SSong Gao static uint32_t float64_cvt_float32(uint64_t d, float_status *status) 2246399665d2SSong Gao { 2247399665d2SSong Gao return float64_to_float32(d, status); 2248399665d2SSong Gao } 2249399665d2SSong Gao 2250226bf881SSong Gao void HELPER(vfcvtl_s_h)(void *vd, void *vj, 2251226bf881SSong Gao CPULoongArchState *env, uint32_t desc) 2252399665d2SSong Gao { 2253399665d2SSong Gao int i; 2254399665d2SSong Gao VReg temp; 2255226bf881SSong Gao VReg *Vd = (VReg *)vd; 2256226bf881SSong Gao VReg *Vj = (VReg *)vj; 2257399665d2SSong Gao 2258399665d2SSong Gao vec_clear_cause(env); 2259399665d2SSong Gao for (i = 0; i < LSX_LEN/32; i++) { 2260399665d2SSong Gao temp.UW(i) = float16_cvt_float32(Vj->UH(i), &env->fp_status); 2261399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2262399665d2SSong Gao } 2263399665d2SSong Gao *Vd = temp; 2264399665d2SSong Gao } 2265399665d2SSong Gao 2266226bf881SSong Gao void HELPER(vfcvtl_d_s)(void *vd, void *vj, 2267226bf881SSong Gao CPULoongArchState *env, uint32_t desc) 2268399665d2SSong Gao { 2269399665d2SSong Gao int i; 2270399665d2SSong Gao VReg temp; 2271226bf881SSong Gao VReg *Vd = (VReg *)vd; 2272226bf881SSong Gao VReg *Vj = (VReg *)vj; 2273399665d2SSong Gao 2274399665d2SSong Gao vec_clear_cause(env); 2275399665d2SSong Gao for (i = 0; i < LSX_LEN/64; i++) { 2276399665d2SSong Gao temp.UD(i) = float32_cvt_float64(Vj->UW(i), &env->fp_status); 2277399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2278399665d2SSong Gao } 2279399665d2SSong Gao *Vd = temp; 2280399665d2SSong Gao } 2281399665d2SSong Gao 2282226bf881SSong Gao void HELPER(vfcvth_s_h)(void *vd, void *vj, 2283226bf881SSong Gao CPULoongArchState *env, uint32_t desc) 2284399665d2SSong Gao { 2285399665d2SSong Gao int i; 2286399665d2SSong Gao VReg temp; 2287226bf881SSong Gao VReg *Vd = (VReg *)vd; 2288226bf881SSong Gao VReg *Vj = (VReg *)vj; 2289399665d2SSong Gao 2290399665d2SSong Gao vec_clear_cause(env); 2291399665d2SSong Gao for (i = 0; i < LSX_LEN/32; i++) { 2292399665d2SSong Gao temp.UW(i) = float16_cvt_float32(Vj->UH(i + 4), &env->fp_status); 2293399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2294399665d2SSong Gao } 2295399665d2SSong Gao *Vd = temp; 2296399665d2SSong Gao } 2297399665d2SSong Gao 2298226bf881SSong Gao void HELPER(vfcvth_d_s)(void *vd, void *vj, 2299226bf881SSong Gao CPULoongArchState *env, uint32_t desc) 2300399665d2SSong Gao { 2301399665d2SSong Gao int i; 2302399665d2SSong Gao VReg temp; 2303226bf881SSong Gao VReg *Vd = (VReg *)vd; 2304226bf881SSong Gao VReg *Vj = (VReg *)vj; 2305399665d2SSong Gao 2306399665d2SSong Gao vec_clear_cause(env); 2307399665d2SSong Gao for (i = 0; i < LSX_LEN/64; i++) { 2308399665d2SSong Gao temp.UD(i) = float32_cvt_float64(Vj->UW(i + 2), &env->fp_status); 2309399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2310399665d2SSong Gao } 2311399665d2SSong Gao *Vd = temp; 2312399665d2SSong Gao } 2313399665d2SSong Gao 23143b286753SSong Gao void HELPER(vfcvt_h_s)(void *vd, void *vj, void *vk, 23153b286753SSong Gao CPULoongArchState *env, uint32_t desc) 2316399665d2SSong Gao { 2317399665d2SSong Gao int i; 2318399665d2SSong Gao VReg temp; 23193b286753SSong Gao VReg *Vd = (VReg *)vd; 23203b286753SSong Gao VReg *Vj = (VReg *)vj; 23213b286753SSong Gao VReg *Vk = (VReg *)vk; 2322399665d2SSong Gao 2323399665d2SSong Gao vec_clear_cause(env); 2324399665d2SSong Gao for(i = 0; i < LSX_LEN/32; i++) { 2325399665d2SSong Gao temp.UH(i + 4) = float32_cvt_float16(Vj->UW(i), &env->fp_status); 2326399665d2SSong Gao temp.UH(i) = float32_cvt_float16(Vk->UW(i), &env->fp_status); 2327399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2328399665d2SSong Gao } 2329399665d2SSong Gao *Vd = temp; 2330399665d2SSong Gao } 2331399665d2SSong Gao 23323b286753SSong Gao void HELPER(vfcvt_s_d)(void *vd, void *vj, void *vk, 23333b286753SSong Gao CPULoongArchState *env, uint32_t desc) 2334399665d2SSong Gao { 2335399665d2SSong Gao int i; 2336399665d2SSong Gao VReg temp; 23373b286753SSong Gao VReg *Vd = (VReg *)vd; 23383b286753SSong Gao VReg *Vj = (VReg *)vj; 23393b286753SSong Gao VReg *Vk = (VReg *)vk; 2340399665d2SSong Gao 2341399665d2SSong Gao vec_clear_cause(env); 2342399665d2SSong Gao for(i = 0; i < LSX_LEN/64; i++) { 2343399665d2SSong Gao temp.UW(i + 2) = float64_cvt_float32(Vj->UD(i), &env->fp_status); 2344399665d2SSong Gao temp.UW(i) = float64_cvt_float32(Vk->UD(i), &env->fp_status); 2345399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2346399665d2SSong Gao } 2347399665d2SSong Gao *Vd = temp; 2348399665d2SSong Gao } 2349399665d2SSong Gao 2350226bf881SSong Gao void HELPER(vfrint_s)(void *vd, void *vj, 2351226bf881SSong Gao CPULoongArchState *env, uint32_t desc) 2352399665d2SSong Gao { 2353399665d2SSong Gao int i; 2354226bf881SSong Gao VReg *Vd = (VReg *)vd; 2355226bf881SSong Gao VReg *Vj = (VReg *)vj; 2356399665d2SSong Gao 2357399665d2SSong Gao vec_clear_cause(env); 2358399665d2SSong Gao for (i = 0; i < 4; i++) { 2359399665d2SSong Gao Vd->W(i) = float32_round_to_int(Vj->UW(i), &env->fp_status); 2360399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2361399665d2SSong Gao } 2362399665d2SSong Gao } 2363399665d2SSong Gao 2364226bf881SSong Gao void HELPER(vfrint_d)(void *vd, void *vj, 2365226bf881SSong Gao CPULoongArchState *env, uint32_t desc) 2366399665d2SSong Gao { 2367399665d2SSong Gao int i; 2368226bf881SSong Gao VReg *Vd = (VReg *)vd; 2369226bf881SSong Gao VReg *Vj = (VReg *)vj; 2370399665d2SSong Gao 2371399665d2SSong Gao vec_clear_cause(env); 2372399665d2SSong Gao for (i = 0; i < 2; i++) { 2373399665d2SSong Gao Vd->D(i) = float64_round_to_int(Vj->UD(i), &env->fp_status); 2374399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2375399665d2SSong Gao } 2376399665d2SSong Gao } 2377399665d2SSong Gao 2378399665d2SSong Gao #define FCVT_2OP(NAME, BIT, E, MODE) \ 2379226bf881SSong Gao void HELPER(NAME)(void *vd, void *vj, \ 2380226bf881SSong Gao CPULoongArchState *env, uint32_t desc) \ 2381399665d2SSong Gao { \ 2382399665d2SSong Gao int i; \ 2383226bf881SSong Gao VReg *Vd = (VReg *)vd; \ 2384226bf881SSong Gao VReg *Vj = (VReg *)vj; \ 2385399665d2SSong Gao \ 2386399665d2SSong Gao vec_clear_cause(env); \ 2387399665d2SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2388399665d2SSong Gao FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); \ 2389399665d2SSong Gao set_float_rounding_mode(MODE, &env->fp_status); \ 2390399665d2SSong Gao Vd->E(i) = float## BIT ## _round_to_int(Vj->E(i), &env->fp_status); \ 2391399665d2SSong Gao set_float_rounding_mode(old_mode, &env->fp_status); \ 2392399665d2SSong Gao vec_update_fcsr0(env, GETPC()); \ 2393399665d2SSong Gao } \ 2394399665d2SSong Gao } 2395399665d2SSong Gao 2396399665d2SSong Gao FCVT_2OP(vfrintrne_s, 32, UW, float_round_nearest_even) 2397399665d2SSong Gao FCVT_2OP(vfrintrne_d, 64, UD, float_round_nearest_even) 2398399665d2SSong Gao FCVT_2OP(vfrintrz_s, 32, UW, float_round_to_zero) 2399399665d2SSong Gao FCVT_2OP(vfrintrz_d, 64, UD, float_round_to_zero) 2400399665d2SSong Gao FCVT_2OP(vfrintrp_s, 32, UW, float_round_up) 2401399665d2SSong Gao FCVT_2OP(vfrintrp_d, 64, UD, float_round_up) 2402399665d2SSong Gao FCVT_2OP(vfrintrm_s, 32, UW, float_round_down) 2403399665d2SSong Gao FCVT_2OP(vfrintrm_d, 64, UD, float_round_down) 2404399665d2SSong Gao 2405399665d2SSong Gao #define FTINT(NAME, FMT1, FMT2, T1, T2, MODE) \ 2406399665d2SSong Gao static T2 do_ftint ## NAME(CPULoongArchState *env, T1 fj) \ 2407399665d2SSong Gao { \ 2408399665d2SSong Gao T2 fd; \ 2409399665d2SSong Gao FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); \ 2410399665d2SSong Gao \ 2411399665d2SSong Gao set_float_rounding_mode(MODE, &env->fp_status); \ 2412399665d2SSong Gao fd = do_## FMT1 ##_to_## FMT2(env, fj); \ 2413399665d2SSong Gao set_float_rounding_mode(old_mode, &env->fp_status); \ 2414399665d2SSong Gao return fd; \ 2415399665d2SSong Gao } 2416399665d2SSong Gao 2417399665d2SSong Gao #define DO_FTINT(FMT1, FMT2, T1, T2) \ 2418399665d2SSong Gao static T2 do_## FMT1 ##_to_## FMT2(CPULoongArchState *env, T1 fj) \ 2419399665d2SSong Gao { \ 2420399665d2SSong Gao T2 fd; \ 2421399665d2SSong Gao \ 2422399665d2SSong Gao fd = FMT1 ##_to_## FMT2(fj, &env->fp_status); \ 2423399665d2SSong Gao if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { \ 2424399665d2SSong Gao if (FMT1 ##_is_any_nan(fj)) { \ 2425399665d2SSong Gao fd = 0; \ 2426399665d2SSong Gao } \ 2427399665d2SSong Gao } \ 2428399665d2SSong Gao vec_update_fcsr0(env, GETPC()); \ 2429399665d2SSong Gao return fd; \ 2430399665d2SSong Gao } 2431399665d2SSong Gao 2432399665d2SSong Gao DO_FTINT(float32, int32, uint32_t, uint32_t) 2433399665d2SSong Gao DO_FTINT(float64, int64, uint64_t, uint64_t) 2434399665d2SSong Gao DO_FTINT(float32, uint32, uint32_t, uint32_t) 2435399665d2SSong Gao DO_FTINT(float64, uint64, uint64_t, uint64_t) 2436399665d2SSong Gao DO_FTINT(float64, int32, uint64_t, uint32_t) 2437399665d2SSong Gao DO_FTINT(float32, int64, uint32_t, uint64_t) 2438399665d2SSong Gao 2439399665d2SSong Gao FTINT(rne_w_s, float32, int32, uint32_t, uint32_t, float_round_nearest_even) 2440399665d2SSong Gao FTINT(rne_l_d, float64, int64, uint64_t, uint64_t, float_round_nearest_even) 2441399665d2SSong Gao FTINT(rp_w_s, float32, int32, uint32_t, uint32_t, float_round_up) 2442399665d2SSong Gao FTINT(rp_l_d, float64, int64, uint64_t, uint64_t, float_round_up) 2443399665d2SSong Gao FTINT(rz_w_s, float32, int32, uint32_t, uint32_t, float_round_to_zero) 2444399665d2SSong Gao FTINT(rz_l_d, float64, int64, uint64_t, uint64_t, float_round_to_zero) 2445399665d2SSong Gao FTINT(rm_w_s, float32, int32, uint32_t, uint32_t, float_round_down) 2446399665d2SSong Gao FTINT(rm_l_d, float64, int64, uint64_t, uint64_t, float_round_down) 2447399665d2SSong Gao 2448399665d2SSong Gao DO_2OP_F(vftintrne_w_s, 32, UW, do_ftintrne_w_s) 2449399665d2SSong Gao DO_2OP_F(vftintrne_l_d, 64, UD, do_ftintrne_l_d) 2450399665d2SSong Gao DO_2OP_F(vftintrp_w_s, 32, UW, do_ftintrp_w_s) 2451399665d2SSong Gao DO_2OP_F(vftintrp_l_d, 64, UD, do_ftintrp_l_d) 2452399665d2SSong Gao DO_2OP_F(vftintrz_w_s, 32, UW, do_ftintrz_w_s) 2453399665d2SSong Gao DO_2OP_F(vftintrz_l_d, 64, UD, do_ftintrz_l_d) 2454399665d2SSong Gao DO_2OP_F(vftintrm_w_s, 32, UW, do_ftintrm_w_s) 2455399665d2SSong Gao DO_2OP_F(vftintrm_l_d, 64, UD, do_ftintrm_l_d) 2456399665d2SSong Gao DO_2OP_F(vftint_w_s, 32, UW, do_float32_to_int32) 2457399665d2SSong Gao DO_2OP_F(vftint_l_d, 64, UD, do_float64_to_int64) 2458399665d2SSong Gao 2459399665d2SSong Gao FTINT(rz_wu_s, float32, uint32, uint32_t, uint32_t, float_round_to_zero) 2460399665d2SSong Gao FTINT(rz_lu_d, float64, uint64, uint64_t, uint64_t, float_round_to_zero) 2461399665d2SSong Gao 2462399665d2SSong Gao DO_2OP_F(vftintrz_wu_s, 32, UW, do_ftintrz_wu_s) 2463399665d2SSong Gao DO_2OP_F(vftintrz_lu_d, 64, UD, do_ftintrz_lu_d) 2464399665d2SSong Gao DO_2OP_F(vftint_wu_s, 32, UW, do_float32_to_uint32) 2465399665d2SSong Gao DO_2OP_F(vftint_lu_d, 64, UD, do_float64_to_uint64) 2466399665d2SSong Gao 2467399665d2SSong Gao FTINT(rm_w_d, float64, int32, uint64_t, uint32_t, float_round_down) 2468399665d2SSong Gao FTINT(rp_w_d, float64, int32, uint64_t, uint32_t, float_round_up) 2469399665d2SSong Gao FTINT(rz_w_d, float64, int32, uint64_t, uint32_t, float_round_to_zero) 2470399665d2SSong Gao FTINT(rne_w_d, float64, int32, uint64_t, uint32_t, float_round_nearest_even) 2471399665d2SSong Gao 2472399665d2SSong Gao #define FTINT_W_D(NAME, FN) \ 24733b286753SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, \ 24743b286753SSong Gao CPULoongArchState *env, uint32_t desc) \ 2475399665d2SSong Gao { \ 2476399665d2SSong Gao int i; \ 2477399665d2SSong Gao VReg temp; \ 24783b286753SSong Gao VReg *Vd = (VReg *)vd; \ 24793b286753SSong Gao VReg *Vj = (VReg *)vj; \ 24803b286753SSong Gao VReg *Vk = (VReg *)vk; \ 2481399665d2SSong Gao \ 2482399665d2SSong Gao vec_clear_cause(env); \ 2483399665d2SSong Gao for (i = 0; i < 2; i++) { \ 2484399665d2SSong Gao temp.W(i + 2) = FN(env, Vj->UD(i)); \ 2485399665d2SSong Gao temp.W(i) = FN(env, Vk->UD(i)); \ 2486399665d2SSong Gao } \ 2487399665d2SSong Gao *Vd = temp; \ 2488399665d2SSong Gao } 2489399665d2SSong Gao 2490399665d2SSong Gao FTINT_W_D(vftint_w_d, do_float64_to_int32) 2491399665d2SSong Gao FTINT_W_D(vftintrm_w_d, do_ftintrm_w_d) 2492399665d2SSong Gao FTINT_W_D(vftintrp_w_d, do_ftintrp_w_d) 2493399665d2SSong Gao FTINT_W_D(vftintrz_w_d, do_ftintrz_w_d) 2494399665d2SSong Gao FTINT_W_D(vftintrne_w_d, do_ftintrne_w_d) 2495399665d2SSong Gao 2496399665d2SSong Gao FTINT(rml_l_s, float32, int64, uint32_t, uint64_t, float_round_down) 2497399665d2SSong Gao FTINT(rpl_l_s, float32, int64, uint32_t, uint64_t, float_round_up) 2498399665d2SSong Gao FTINT(rzl_l_s, float32, int64, uint32_t, uint64_t, float_round_to_zero) 2499399665d2SSong Gao FTINT(rnel_l_s, float32, int64, uint32_t, uint64_t, float_round_nearest_even) 2500399665d2SSong Gao FTINT(rmh_l_s, float32, int64, uint32_t, uint64_t, float_round_down) 2501399665d2SSong Gao FTINT(rph_l_s, float32, int64, uint32_t, uint64_t, float_round_up) 2502399665d2SSong Gao FTINT(rzh_l_s, float32, int64, uint32_t, uint64_t, float_round_to_zero) 2503399665d2SSong Gao FTINT(rneh_l_s, float32, int64, uint32_t, uint64_t, float_round_nearest_even) 2504399665d2SSong Gao 2505399665d2SSong Gao #define FTINTL_L_S(NAME, FN) \ 2506226bf881SSong Gao void HELPER(NAME)(void *vd, void *vj, \ 2507226bf881SSong Gao CPULoongArchState *env, uint32_t desc) \ 2508399665d2SSong Gao { \ 2509399665d2SSong Gao int i; \ 2510399665d2SSong Gao VReg temp; \ 2511226bf881SSong Gao VReg *Vd = (VReg *)vd; \ 2512226bf881SSong Gao VReg *Vj = (VReg *)vj; \ 2513399665d2SSong Gao \ 2514399665d2SSong Gao vec_clear_cause(env); \ 2515399665d2SSong Gao for (i = 0; i < 2; i++) { \ 2516399665d2SSong Gao temp.D(i) = FN(env, Vj->UW(i)); \ 2517399665d2SSong Gao } \ 2518399665d2SSong Gao *Vd = temp; \ 2519399665d2SSong Gao } 2520399665d2SSong Gao 2521399665d2SSong Gao FTINTL_L_S(vftintl_l_s, do_float32_to_int64) 2522399665d2SSong Gao FTINTL_L_S(vftintrml_l_s, do_ftintrml_l_s) 2523399665d2SSong Gao FTINTL_L_S(vftintrpl_l_s, do_ftintrpl_l_s) 2524399665d2SSong Gao FTINTL_L_S(vftintrzl_l_s, do_ftintrzl_l_s) 2525399665d2SSong Gao FTINTL_L_S(vftintrnel_l_s, do_ftintrnel_l_s) 2526399665d2SSong Gao 2527399665d2SSong Gao #define FTINTH_L_S(NAME, FN) \ 2528226bf881SSong Gao void HELPER(NAME)(void *vd, void *vj, \ 2529226bf881SSong Gao CPULoongArchState *env, uint32_t desc) \ 2530399665d2SSong Gao { \ 2531399665d2SSong Gao int i; \ 2532399665d2SSong Gao VReg temp; \ 2533226bf881SSong Gao VReg *Vd = (VReg *)vd; \ 2534226bf881SSong Gao VReg *Vj = (VReg *)vj; \ 2535399665d2SSong Gao \ 2536399665d2SSong Gao vec_clear_cause(env); \ 2537399665d2SSong Gao for (i = 0; i < 2; i++) { \ 2538399665d2SSong Gao temp.D(i) = FN(env, Vj->UW(i + 2)); \ 2539399665d2SSong Gao } \ 2540399665d2SSong Gao *Vd = temp; \ 2541399665d2SSong Gao } 2542399665d2SSong Gao 2543399665d2SSong Gao FTINTH_L_S(vftinth_l_s, do_float32_to_int64) 2544399665d2SSong Gao FTINTH_L_S(vftintrmh_l_s, do_ftintrmh_l_s) 2545399665d2SSong Gao FTINTH_L_S(vftintrph_l_s, do_ftintrph_l_s) 2546399665d2SSong Gao FTINTH_L_S(vftintrzh_l_s, do_ftintrzh_l_s) 2547399665d2SSong Gao FTINTH_L_S(vftintrneh_l_s, do_ftintrneh_l_s) 2548399665d2SSong Gao 2549399665d2SSong Gao #define FFINT(NAME, FMT1, FMT2, T1, T2) \ 2550399665d2SSong Gao static T2 do_ffint_ ## NAME(CPULoongArchState *env, T1 fj) \ 2551399665d2SSong Gao { \ 2552399665d2SSong Gao T2 fd; \ 2553399665d2SSong Gao \ 2554399665d2SSong Gao fd = FMT1 ##_to_## FMT2(fj, &env->fp_status); \ 2555399665d2SSong Gao vec_update_fcsr0(env, GETPC()); \ 2556399665d2SSong Gao return fd; \ 2557399665d2SSong Gao } 2558399665d2SSong Gao 2559399665d2SSong Gao FFINT(s_w, int32, float32, int32_t, uint32_t) 2560399665d2SSong Gao FFINT(d_l, int64, float64, int64_t, uint64_t) 2561399665d2SSong Gao FFINT(s_wu, uint32, float32, uint32_t, uint32_t) 2562399665d2SSong Gao FFINT(d_lu, uint64, float64, uint64_t, uint64_t) 2563399665d2SSong Gao 2564399665d2SSong Gao DO_2OP_F(vffint_s_w, 32, W, do_ffint_s_w) 2565399665d2SSong Gao DO_2OP_F(vffint_d_l, 64, D, do_ffint_d_l) 2566399665d2SSong Gao DO_2OP_F(vffint_s_wu, 32, UW, do_ffint_s_wu) 2567399665d2SSong Gao DO_2OP_F(vffint_d_lu, 64, UD, do_ffint_d_lu) 2568399665d2SSong Gao 2569226bf881SSong Gao void HELPER(vffintl_d_w)(void *vd, void *vj, 2570226bf881SSong Gao CPULoongArchState *env, uint32_t desc) 2571399665d2SSong Gao { 2572399665d2SSong Gao int i; 2573399665d2SSong Gao VReg temp; 2574226bf881SSong Gao VReg *Vd = (VReg *)vd; 2575226bf881SSong Gao VReg *Vj = (VReg *)vj; 2576399665d2SSong Gao 2577399665d2SSong Gao vec_clear_cause(env); 2578399665d2SSong Gao for (i = 0; i < 2; i++) { 2579399665d2SSong Gao temp.D(i) = int32_to_float64(Vj->W(i), &env->fp_status); 2580399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2581399665d2SSong Gao } 2582399665d2SSong Gao *Vd = temp; 2583399665d2SSong Gao } 2584399665d2SSong Gao 2585226bf881SSong Gao void HELPER(vffinth_d_w)(void *vd, void *vj, 2586226bf881SSong Gao CPULoongArchState *env, uint32_t desc) 2587399665d2SSong Gao { 2588399665d2SSong Gao int i; 2589399665d2SSong Gao VReg temp; 2590226bf881SSong Gao VReg *Vd = (VReg *)vd; 2591226bf881SSong Gao VReg *Vj = (VReg *)vj; 2592399665d2SSong Gao 2593399665d2SSong Gao vec_clear_cause(env); 2594399665d2SSong Gao for (i = 0; i < 2; i++) { 2595399665d2SSong Gao temp.D(i) = int32_to_float64(Vj->W(i + 2), &env->fp_status); 2596399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2597399665d2SSong Gao } 2598399665d2SSong Gao *Vd = temp; 2599399665d2SSong Gao } 2600399665d2SSong Gao 26013b286753SSong Gao void HELPER(vffint_s_l)(void *vd, void *vj, void *vk, 26023b286753SSong Gao CPULoongArchState *env, uint32_t desc) 2603399665d2SSong Gao { 2604399665d2SSong Gao int i; 2605399665d2SSong Gao VReg temp; 26063b286753SSong Gao VReg *Vd = (VReg *)vd; 26073b286753SSong Gao VReg *Vj = (VReg *)vj; 26083b286753SSong Gao VReg *Vk = (VReg *)vk; 2609399665d2SSong Gao 2610399665d2SSong Gao vec_clear_cause(env); 2611399665d2SSong Gao for (i = 0; i < 2; i++) { 2612399665d2SSong Gao temp.W(i + 2) = int64_to_float32(Vj->D(i), &env->fp_status); 2613399665d2SSong Gao temp.W(i) = int64_to_float32(Vk->D(i), &env->fp_status); 2614399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2615399665d2SSong Gao } 2616399665d2SSong Gao *Vd = temp; 2617399665d2SSong Gao } 2618f435e1e5SSong Gao 2619f435e1e5SSong Gao #define VSEQ(a, b) (a == b ? -1 : 0) 2620f435e1e5SSong Gao #define VSLE(a, b) (a <= b ? -1 : 0) 2621f435e1e5SSong Gao #define VSLT(a, b) (a < b ? -1 : 0) 2622f435e1e5SSong Gao 2623f435e1e5SSong Gao #define VCMPI(NAME, BIT, E, DO_OP) \ 2624f435e1e5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t v) \ 2625f435e1e5SSong Gao { \ 2626f435e1e5SSong Gao int i; \ 2627f435e1e5SSong Gao VReg *Vd = (VReg *)vd; \ 2628f435e1e5SSong Gao VReg *Vj = (VReg *)vj; \ 2629f435e1e5SSong Gao typedef __typeof(Vd->E(0)) TD; \ 2630f435e1e5SSong Gao \ 2631f435e1e5SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2632f435e1e5SSong Gao Vd->E(i) = DO_OP(Vj->E(i), (TD)imm); \ 2633f435e1e5SSong Gao } \ 2634f435e1e5SSong Gao } 2635f435e1e5SSong Gao 2636f435e1e5SSong Gao VCMPI(vseqi_b, 8, B, VSEQ) 2637f435e1e5SSong Gao VCMPI(vseqi_h, 16, H, VSEQ) 2638f435e1e5SSong Gao VCMPI(vseqi_w, 32, W, VSEQ) 2639f435e1e5SSong Gao VCMPI(vseqi_d, 64, D, VSEQ) 2640f435e1e5SSong Gao VCMPI(vslei_b, 8, B, VSLE) 2641f435e1e5SSong Gao VCMPI(vslei_h, 16, H, VSLE) 2642f435e1e5SSong Gao VCMPI(vslei_w, 32, W, VSLE) 2643f435e1e5SSong Gao VCMPI(vslei_d, 64, D, VSLE) 2644f435e1e5SSong Gao VCMPI(vslei_bu, 8, UB, VSLE) 2645f435e1e5SSong Gao VCMPI(vslei_hu, 16, UH, VSLE) 2646f435e1e5SSong Gao VCMPI(vslei_wu, 32, UW, VSLE) 2647f435e1e5SSong Gao VCMPI(vslei_du, 64, UD, VSLE) 2648f435e1e5SSong Gao VCMPI(vslti_b, 8, B, VSLT) 2649f435e1e5SSong Gao VCMPI(vslti_h, 16, H, VSLT) 2650f435e1e5SSong Gao VCMPI(vslti_w, 32, W, VSLT) 2651f435e1e5SSong Gao VCMPI(vslti_d, 64, D, VSLT) 2652f435e1e5SSong Gao VCMPI(vslti_bu, 8, UB, VSLT) 2653f435e1e5SSong Gao VCMPI(vslti_hu, 16, UH, VSLT) 2654f435e1e5SSong Gao VCMPI(vslti_wu, 32, UW, VSLT) 2655f435e1e5SSong Gao VCMPI(vslti_du, 64, UD, VSLT) 2656386c4e86SSong Gao 2657386c4e86SSong Gao static uint64_t vfcmp_common(CPULoongArchState *env, 2658386c4e86SSong Gao FloatRelation cmp, uint32_t flags) 2659386c4e86SSong Gao { 2660386c4e86SSong Gao uint64_t ret = 0; 2661386c4e86SSong Gao 2662386c4e86SSong Gao switch (cmp) { 2663386c4e86SSong Gao case float_relation_less: 2664386c4e86SSong Gao ret = (flags & FCMP_LT); 2665386c4e86SSong Gao break; 2666386c4e86SSong Gao case float_relation_equal: 2667386c4e86SSong Gao ret = (flags & FCMP_EQ); 2668386c4e86SSong Gao break; 2669386c4e86SSong Gao case float_relation_greater: 2670386c4e86SSong Gao ret = (flags & FCMP_GT); 2671386c4e86SSong Gao break; 2672386c4e86SSong Gao case float_relation_unordered: 2673386c4e86SSong Gao ret = (flags & FCMP_UN); 2674386c4e86SSong Gao break; 2675386c4e86SSong Gao default: 2676386c4e86SSong Gao g_assert_not_reached(); 2677386c4e86SSong Gao } 2678386c4e86SSong Gao 2679386c4e86SSong Gao if (ret) { 2680386c4e86SSong Gao ret = -1; 2681386c4e86SSong Gao } 2682386c4e86SSong Gao 2683386c4e86SSong Gao return ret; 2684386c4e86SSong Gao } 2685386c4e86SSong Gao 2686386c4e86SSong Gao #define VFCMP(NAME, BIT, E, FN) \ 2687386c4e86SSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 2688386c4e86SSong Gao uint32_t vd, uint32_t vj, uint32_t vk, uint32_t flags) \ 2689386c4e86SSong Gao { \ 2690386c4e86SSong Gao int i; \ 2691386c4e86SSong Gao VReg t; \ 2692386c4e86SSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 2693386c4e86SSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 2694386c4e86SSong Gao VReg *Vk = &(env->fpr[vk].vreg); \ 2695386c4e86SSong Gao \ 2696386c4e86SSong Gao vec_clear_cause(env); \ 2697386c4e86SSong Gao for (i = 0; i < LSX_LEN/BIT ; i++) { \ 2698386c4e86SSong Gao FloatRelation cmp; \ 2699386c4e86SSong Gao cmp = FN(Vj->E(i), Vk->E(i), &env->fp_status); \ 2700386c4e86SSong Gao t.E(i) = vfcmp_common(env, cmp, flags); \ 2701386c4e86SSong Gao vec_update_fcsr0(env, GETPC()); \ 2702386c4e86SSong Gao } \ 2703386c4e86SSong Gao *Vd = t; \ 2704386c4e86SSong Gao } 2705386c4e86SSong Gao 2706386c4e86SSong Gao VFCMP(vfcmp_c_s, 32, UW, float32_compare_quiet) 2707386c4e86SSong Gao VFCMP(vfcmp_s_s, 32, UW, float32_compare) 2708386c4e86SSong Gao VFCMP(vfcmp_c_d, 64, UD, float64_compare_quiet) 2709386c4e86SSong Gao VFCMP(vfcmp_s_d, 64, UD, float64_compare) 2710d0dfa19aSSong Gao 2711d0dfa19aSSong Gao void HELPER(vbitseli_b)(void *vd, void *vj, uint64_t imm, uint32_t v) 2712d0dfa19aSSong Gao { 2713d0dfa19aSSong Gao int i; 2714d0dfa19aSSong Gao VReg *Vd = (VReg *)vd; 2715d0dfa19aSSong Gao VReg *Vj = (VReg *)vj; 2716d0dfa19aSSong Gao 2717d0dfa19aSSong Gao for (i = 0; i < 16; i++) { 2718d0dfa19aSSong Gao Vd->B(i) = (~Vd->B(i) & Vj->B(i)) | (Vd->B(i) & imm); 2719d0dfa19aSSong Gao } 2720d0dfa19aSSong Gao } 2721d0dfa19aSSong Gao 2722d0dfa19aSSong Gao /* Copy from target/arm/tcg/sve_helper.c */ 2723d0dfa19aSSong Gao static inline bool do_match2(uint64_t n, uint64_t m0, uint64_t m1, int esz) 2724d0dfa19aSSong Gao { 2725d0dfa19aSSong Gao uint64_t bits = 8 << esz; 2726d0dfa19aSSong Gao uint64_t ones = dup_const(esz, 1); 2727d0dfa19aSSong Gao uint64_t signs = ones << (bits - 1); 2728d0dfa19aSSong Gao uint64_t cmp0, cmp1; 2729d0dfa19aSSong Gao 2730d0dfa19aSSong Gao cmp1 = dup_const(esz, n); 2731d0dfa19aSSong Gao cmp0 = cmp1 ^ m0; 2732d0dfa19aSSong Gao cmp1 = cmp1 ^ m1; 2733d0dfa19aSSong Gao cmp0 = (cmp0 - ones) & ~cmp0; 2734d0dfa19aSSong Gao cmp1 = (cmp1 - ones) & ~cmp1; 2735d0dfa19aSSong Gao return (cmp0 | cmp1) & signs; 2736d0dfa19aSSong Gao } 2737d0dfa19aSSong Gao 2738d0dfa19aSSong Gao #define SETANYEQZ(NAME, MO) \ 2739d0dfa19aSSong Gao void HELPER(NAME)(CPULoongArchState *env, uint32_t cd, uint32_t vj) \ 2740d0dfa19aSSong Gao { \ 2741d0dfa19aSSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 2742d0dfa19aSSong Gao \ 2743d0dfa19aSSong Gao env->cf[cd & 0x7] = do_match2(0, Vj->D(0), Vj->D(1), MO); \ 2744d0dfa19aSSong Gao } 2745d0dfa19aSSong Gao SETANYEQZ(vsetanyeqz_b, MO_8) 2746d0dfa19aSSong Gao SETANYEQZ(vsetanyeqz_h, MO_16) 2747d0dfa19aSSong Gao SETANYEQZ(vsetanyeqz_w, MO_32) 2748d0dfa19aSSong Gao SETANYEQZ(vsetanyeqz_d, MO_64) 2749d0dfa19aSSong Gao 2750d0dfa19aSSong Gao #define SETALLNEZ(NAME, MO) \ 2751d0dfa19aSSong Gao void HELPER(NAME)(CPULoongArchState *env, uint32_t cd, uint32_t vj) \ 2752d0dfa19aSSong Gao { \ 2753d0dfa19aSSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 2754d0dfa19aSSong Gao \ 2755d0dfa19aSSong Gao env->cf[cd & 0x7]= !do_match2(0, Vj->D(0), Vj->D(1), MO); \ 2756d0dfa19aSSong Gao } 2757d0dfa19aSSong Gao SETALLNEZ(vsetallnez_b, MO_8) 2758d0dfa19aSSong Gao SETALLNEZ(vsetallnez_h, MO_16) 2759d0dfa19aSSong Gao SETALLNEZ(vsetallnez_w, MO_32) 2760d0dfa19aSSong Gao SETALLNEZ(vsetallnez_d, MO_64) 2761d5e5563cSSong Gao 2762d5e5563cSSong Gao #define VPACKEV(NAME, BIT, E) \ 276304711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 2764d5e5563cSSong Gao { \ 2765d5e5563cSSong Gao int i; \ 2766d5e5563cSSong Gao VReg temp; \ 276704711da1SSong Gao VReg *Vd = (VReg *)vd; \ 276804711da1SSong Gao VReg *Vj = (VReg *)vj; \ 276904711da1SSong Gao VReg *Vk = (VReg *)vk; \ 2770d5e5563cSSong Gao \ 2771d5e5563cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2772d5e5563cSSong Gao temp.E(2 * i + 1) = Vj->E(2 * i); \ 2773d5e5563cSSong Gao temp.E(2 *i) = Vk->E(2 * i); \ 2774d5e5563cSSong Gao } \ 2775d5e5563cSSong Gao *Vd = temp; \ 2776d5e5563cSSong Gao } 2777d5e5563cSSong Gao 2778d5e5563cSSong Gao VPACKEV(vpackev_b, 16, B) 2779d5e5563cSSong Gao VPACKEV(vpackev_h, 32, H) 2780d5e5563cSSong Gao VPACKEV(vpackev_w, 64, W) 2781d5e5563cSSong Gao VPACKEV(vpackev_d, 128, D) 2782d5e5563cSSong Gao 2783d5e5563cSSong Gao #define VPACKOD(NAME, BIT, E) \ 278404711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 2785d5e5563cSSong Gao { \ 2786d5e5563cSSong Gao int i; \ 2787d5e5563cSSong Gao VReg temp; \ 278804711da1SSong Gao VReg *Vd = (VReg *)vd; \ 278904711da1SSong Gao VReg *Vj = (VReg *)vj; \ 279004711da1SSong Gao VReg *Vk = (VReg *)vk; \ 2791d5e5563cSSong Gao \ 2792d5e5563cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2793d5e5563cSSong Gao temp.E(2 * i + 1) = Vj->E(2 * i + 1); \ 2794d5e5563cSSong Gao temp.E(2 * i) = Vk->E(2 * i + 1); \ 2795d5e5563cSSong Gao } \ 2796d5e5563cSSong Gao *Vd = temp; \ 2797d5e5563cSSong Gao } 2798d5e5563cSSong Gao 2799d5e5563cSSong Gao VPACKOD(vpackod_b, 16, B) 2800d5e5563cSSong Gao VPACKOD(vpackod_h, 32, H) 2801d5e5563cSSong Gao VPACKOD(vpackod_w, 64, W) 2802d5e5563cSSong Gao VPACKOD(vpackod_d, 128, D) 2803d5e5563cSSong Gao 2804d5e5563cSSong Gao #define VPICKEV(NAME, BIT, E) \ 280504711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 2806d5e5563cSSong Gao { \ 2807d5e5563cSSong Gao int i; \ 2808d5e5563cSSong Gao VReg temp; \ 280904711da1SSong Gao VReg *Vd = (VReg *)vd; \ 281004711da1SSong Gao VReg *Vj = (VReg *)vj; \ 281104711da1SSong Gao VReg *Vk = (VReg *)vk; \ 2812d5e5563cSSong Gao \ 2813d5e5563cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2814d5e5563cSSong Gao temp.E(i + LSX_LEN/BIT) = Vj->E(2 * i); \ 2815d5e5563cSSong Gao temp.E(i) = Vk->E(2 * i); \ 2816d5e5563cSSong Gao } \ 2817d5e5563cSSong Gao *Vd = temp; \ 2818d5e5563cSSong Gao } 2819d5e5563cSSong Gao 2820d5e5563cSSong Gao VPICKEV(vpickev_b, 16, B) 2821d5e5563cSSong Gao VPICKEV(vpickev_h, 32, H) 2822d5e5563cSSong Gao VPICKEV(vpickev_w, 64, W) 2823d5e5563cSSong Gao VPICKEV(vpickev_d, 128, D) 2824d5e5563cSSong Gao 2825d5e5563cSSong Gao #define VPICKOD(NAME, BIT, E) \ 282604711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 2827d5e5563cSSong Gao { \ 2828d5e5563cSSong Gao int i; \ 2829d5e5563cSSong Gao VReg temp; \ 283004711da1SSong Gao VReg *Vd = (VReg *)vd; \ 283104711da1SSong Gao VReg *Vj = (VReg *)vj; \ 283204711da1SSong Gao VReg *Vk = (VReg *)vk; \ 2833d5e5563cSSong Gao \ 2834d5e5563cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2835d5e5563cSSong Gao temp.E(i + LSX_LEN/BIT) = Vj->E(2 * i + 1); \ 2836d5e5563cSSong Gao temp.E(i) = Vk->E(2 * i + 1); \ 2837d5e5563cSSong Gao } \ 2838d5e5563cSSong Gao *Vd = temp; \ 2839d5e5563cSSong Gao } 2840d5e5563cSSong Gao 2841d5e5563cSSong Gao VPICKOD(vpickod_b, 16, B) 2842d5e5563cSSong Gao VPICKOD(vpickod_h, 32, H) 2843d5e5563cSSong Gao VPICKOD(vpickod_w, 64, W) 2844d5e5563cSSong Gao VPICKOD(vpickod_d, 128, D) 2845e93dd431SSong Gao 2846e93dd431SSong Gao #define VILVL(NAME, BIT, E) \ 284704711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 2848e93dd431SSong Gao { \ 2849e93dd431SSong Gao int i; \ 2850e93dd431SSong Gao VReg temp; \ 285104711da1SSong Gao VReg *Vd = (VReg *)vd; \ 285204711da1SSong Gao VReg *Vj = (VReg *)vj; \ 285304711da1SSong Gao VReg *Vk = (VReg *)vk; \ 2854e93dd431SSong Gao \ 2855e93dd431SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2856e93dd431SSong Gao temp.E(2 * i + 1) = Vj->E(i); \ 2857e93dd431SSong Gao temp.E(2 * i) = Vk->E(i); \ 2858e93dd431SSong Gao } \ 2859e93dd431SSong Gao *Vd = temp; \ 2860e93dd431SSong Gao } 2861e93dd431SSong Gao 2862e93dd431SSong Gao VILVL(vilvl_b, 16, B) 2863e93dd431SSong Gao VILVL(vilvl_h, 32, H) 2864e93dd431SSong Gao VILVL(vilvl_w, 64, W) 2865e93dd431SSong Gao VILVL(vilvl_d, 128, D) 2866e93dd431SSong Gao 2867e93dd431SSong Gao #define VILVH(NAME, BIT, E) \ 286804711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 2869e93dd431SSong Gao { \ 2870e93dd431SSong Gao int i; \ 2871e93dd431SSong Gao VReg temp; \ 287204711da1SSong Gao VReg *Vd = (VReg *)vd; \ 287304711da1SSong Gao VReg *Vj = (VReg *)vj; \ 287404711da1SSong Gao VReg *Vk = (VReg *)vk; \ 2875e93dd431SSong Gao \ 2876e93dd431SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2877e93dd431SSong Gao temp.E(2 * i + 1) = Vj->E(i + LSX_LEN/BIT); \ 2878e93dd431SSong Gao temp.E(2 * i) = Vk->E(i + LSX_LEN/BIT); \ 2879e93dd431SSong Gao } \ 2880e93dd431SSong Gao *Vd = temp; \ 2881e93dd431SSong Gao } 2882e93dd431SSong Gao 2883e93dd431SSong Gao VILVH(vilvh_b, 16, B) 2884e93dd431SSong Gao VILVH(vilvh_h, 32, H) 2885e93dd431SSong Gao VILVH(vilvh_w, 64, W) 2886e93dd431SSong Gao VILVH(vilvh_d, 128, D) 2887e93dd431SSong Gao 2888eb48ab22SSong Gao void HELPER(vshuf_b)(void *vd, void *vj, void *vk, void *va, uint32_t desc) 2889e93dd431SSong Gao { 2890e93dd431SSong Gao int i, m; 2891e93dd431SSong Gao VReg temp; 2892eb48ab22SSong Gao VReg *Vd = (VReg *)vd; 2893eb48ab22SSong Gao VReg *Vj = (VReg *)vj; 2894eb48ab22SSong Gao VReg *Vk = (VReg *)vk; 2895eb48ab22SSong Gao VReg *Va = (VReg *)va; 2896e93dd431SSong Gao 2897e93dd431SSong Gao m = LSX_LEN/8; 2898e93dd431SSong Gao for (i = 0; i < m ; i++) { 2899e93dd431SSong Gao uint64_t k = (uint8_t)Va->B(i) % (2 * m); 2900e93dd431SSong Gao temp.B(i) = k < m ? Vk->B(k) : Vj->B(k - m); 2901e93dd431SSong Gao } 2902e93dd431SSong Gao *Vd = temp; 2903e93dd431SSong Gao } 2904e93dd431SSong Gao 2905e93dd431SSong Gao #define VSHUF(NAME, BIT, E) \ 290604711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 2907e93dd431SSong Gao { \ 2908e93dd431SSong Gao int i, m; \ 2909e93dd431SSong Gao VReg temp; \ 291004711da1SSong Gao VReg *Vd = (VReg *)vd; \ 291104711da1SSong Gao VReg *Vj = (VReg *)vj; \ 291204711da1SSong Gao VReg *Vk = (VReg *)vk; \ 2913e93dd431SSong Gao \ 2914e93dd431SSong Gao m = LSX_LEN/BIT; \ 2915e93dd431SSong Gao for (i = 0; i < m; i++) { \ 2916e93dd431SSong Gao uint64_t k = ((uint8_t) Vd->E(i)) % (2 * m); \ 2917e93dd431SSong Gao temp.E(i) = k < m ? Vk->E(k) : Vj->E(k - m); \ 2918e93dd431SSong Gao } \ 2919e93dd431SSong Gao *Vd = temp; \ 2920e93dd431SSong Gao } 2921e93dd431SSong Gao 2922e93dd431SSong Gao VSHUF(vshuf_h, 16, H) 2923e93dd431SSong Gao VSHUF(vshuf_w, 32, W) 2924e93dd431SSong Gao VSHUF(vshuf_d, 64, D) 2925e93dd431SSong Gao 2926e93dd431SSong Gao #define VSHUF4I(NAME, BIT, E) \ 2927e93dd431SSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 2928e93dd431SSong Gao uint32_t vd, uint32_t vj, uint32_t imm) \ 2929e93dd431SSong Gao { \ 2930e93dd431SSong Gao int i; \ 2931e93dd431SSong Gao VReg temp; \ 2932e93dd431SSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 2933e93dd431SSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 2934e93dd431SSong Gao \ 2935e93dd431SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2936e93dd431SSong Gao temp.E(i) = Vj->E(((i) & 0xfc) + (((imm) >> \ 2937e93dd431SSong Gao (2 * ((i) & 0x03))) & 0x03)); \ 2938e93dd431SSong Gao } \ 2939e93dd431SSong Gao *Vd = temp; \ 2940e93dd431SSong Gao } 2941e93dd431SSong Gao 2942e93dd431SSong Gao VSHUF4I(vshuf4i_b, 8, B) 2943e93dd431SSong Gao VSHUF4I(vshuf4i_h, 16, H) 2944e93dd431SSong Gao VSHUF4I(vshuf4i_w, 32, W) 2945e93dd431SSong Gao 2946e93dd431SSong Gao void HELPER(vshuf4i_d)(CPULoongArchState *env, 2947e93dd431SSong Gao uint32_t vd, uint32_t vj, uint32_t imm) 2948e93dd431SSong Gao { 2949e93dd431SSong Gao VReg *Vd = &(env->fpr[vd].vreg); 2950e93dd431SSong Gao VReg *Vj = &(env->fpr[vj].vreg); 2951e93dd431SSong Gao 2952e93dd431SSong Gao VReg temp; 2953e93dd431SSong Gao temp.D(0) = (imm & 2 ? Vj : Vd)->D(imm & 1); 2954e93dd431SSong Gao temp.D(1) = (imm & 8 ? Vj : Vd)->D((imm >> 2) & 1); 2955e93dd431SSong Gao *Vd = temp; 2956e93dd431SSong Gao } 2957e93dd431SSong Gao 2958e93dd431SSong Gao void HELPER(vpermi_w)(CPULoongArchState *env, 2959e93dd431SSong Gao uint32_t vd, uint32_t vj, uint32_t imm) 2960e93dd431SSong Gao { 2961e93dd431SSong Gao VReg temp; 2962e93dd431SSong Gao VReg *Vd = &(env->fpr[vd].vreg); 2963e93dd431SSong Gao VReg *Vj = &(env->fpr[vj].vreg); 2964e93dd431SSong Gao 2965e93dd431SSong Gao temp.W(0) = Vj->W(imm & 0x3); 2966e93dd431SSong Gao temp.W(1) = Vj->W((imm >> 2) & 0x3); 2967e93dd431SSong Gao temp.W(2) = Vd->W((imm >> 4) & 0x3); 2968e93dd431SSong Gao temp.W(3) = Vd->W((imm >> 6) & 0x3); 2969e93dd431SSong Gao *Vd = temp; 2970e93dd431SSong Gao } 2971e93dd431SSong Gao 2972e93dd431SSong Gao #define VEXTRINS(NAME, BIT, E, MASK) \ 2973e93dd431SSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 2974e93dd431SSong Gao uint32_t vd, uint32_t vj, uint32_t imm) \ 2975e93dd431SSong Gao { \ 2976e93dd431SSong Gao int ins, extr; \ 2977e93dd431SSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 2978e93dd431SSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 2979e93dd431SSong Gao \ 2980e93dd431SSong Gao ins = (imm >> 4) & MASK; \ 2981e93dd431SSong Gao extr = imm & MASK; \ 2982e93dd431SSong Gao Vd->E(ins) = Vj->E(extr); \ 2983e93dd431SSong Gao } 2984e93dd431SSong Gao 2985e93dd431SSong Gao VEXTRINS(vextrins_b, 8, B, 0xf) 2986e93dd431SSong Gao VEXTRINS(vextrins_h, 16, H, 0x7) 2987e93dd431SSong Gao VEXTRINS(vextrins_w, 32, W, 0x3) 2988e93dd431SSong Gao VEXTRINS(vextrins_d, 64, D, 0x1) 2989