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) \ 795329517d5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \ 7969b21a7a5SSong Gao { \ 7979b21a7a5SSong Gao int i; \ 7989b21a7a5SSong Gao VReg temp; \ 799329517d5SSong Gao VReg *Vd = (VReg *)vd; \ 800329517d5SSong Gao VReg *Vj = (VReg *)vj; \ 8019b21a7a5SSong Gao typedef __typeof(temp.E1(0)) TD; \ 8029b21a7a5SSong Gao \ 8039b21a7a5SSong Gao temp.D(0) = 0; \ 8049b21a7a5SSong Gao temp.D(1) = 0; \ 8059b21a7a5SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 8069b21a7a5SSong Gao temp.E1(i) = (TD)Vj->E2(i) << (imm % BIT); \ 8079b21a7a5SSong Gao } \ 8089b21a7a5SSong Gao *Vd = temp; \ 8099b21a7a5SSong Gao } 8109b21a7a5SSong Gao 811ff27e335SSong Gao void HELPER(vextl_q_d)(void *vd, void *vj, uint32_t desc) 8129b21a7a5SSong Gao { 813ff27e335SSong Gao VReg *Vd = (VReg *)vd; 814ff27e335SSong Gao VReg *Vj = (VReg *)vj; 8159b21a7a5SSong Gao 8169b21a7a5SSong Gao Vd->Q(0) = int128_makes64(Vj->D(0)); 8179b21a7a5SSong Gao } 8189b21a7a5SSong Gao 819ff27e335SSong Gao void HELPER(vextl_qu_du)(void *vd, void *vj, uint32_t desc) 8209b21a7a5SSong Gao { 821ff27e335SSong Gao VReg *Vd = (VReg *)vd; 822ff27e335SSong Gao VReg *Vj = (VReg *)vj; 8239b21a7a5SSong Gao 8249b21a7a5SSong Gao Vd->Q(0) = int128_make64(Vj->D(0)); 8259b21a7a5SSong Gao } 8269b21a7a5SSong Gao 8279b21a7a5SSong Gao VSLLWIL(vsllwil_h_b, 16, H, B) 8289b21a7a5SSong Gao VSLLWIL(vsllwil_w_h, 32, W, H) 8299b21a7a5SSong Gao VSLLWIL(vsllwil_d_w, 64, D, W) 8309b21a7a5SSong Gao VSLLWIL(vsllwil_hu_bu, 16, UH, UB) 8319b21a7a5SSong Gao VSLLWIL(vsllwil_wu_hu, 32, UW, UH) 8329b21a7a5SSong Gao VSLLWIL(vsllwil_du_wu, 64, UD, UW) 833ecb93716SSong Gao 834ecb93716SSong Gao #define do_vsrlr(E, T) \ 835ecb93716SSong Gao static T do_vsrlr_ ##E(T s1, int sh) \ 836ecb93716SSong Gao { \ 837ecb93716SSong Gao if (sh == 0) { \ 838ecb93716SSong Gao return s1; \ 839ecb93716SSong Gao } else { \ 840ecb93716SSong Gao return (s1 >> sh) + ((s1 >> (sh - 1)) & 0x1); \ 841ecb93716SSong Gao } \ 842ecb93716SSong Gao } 843ecb93716SSong Gao 844ecb93716SSong Gao do_vsrlr(B, uint8_t) 845ecb93716SSong Gao do_vsrlr(H, uint16_t) 846ecb93716SSong Gao do_vsrlr(W, uint32_t) 847ecb93716SSong Gao do_vsrlr(D, uint64_t) 848ecb93716SSong Gao 849ecb93716SSong Gao #define VSRLR(NAME, BIT, T, E) \ 85004711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 851ecb93716SSong Gao { \ 852ecb93716SSong Gao int i; \ 85304711da1SSong Gao VReg *Vd = (VReg *)vd; \ 85404711da1SSong Gao VReg *Vj = (VReg *)vj; \ 85504711da1SSong Gao VReg *Vk = (VReg *)vk; \ 856ecb93716SSong Gao \ 857ecb93716SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 858ecb93716SSong Gao Vd->E(i) = do_vsrlr_ ## E(Vj->E(i), ((T)Vk->E(i))%BIT); \ 859ecb93716SSong Gao } \ 860ecb93716SSong Gao } 861ecb93716SSong Gao 862ecb93716SSong Gao VSRLR(vsrlr_b, 8, uint8_t, B) 863ecb93716SSong Gao VSRLR(vsrlr_h, 16, uint16_t, H) 864ecb93716SSong Gao VSRLR(vsrlr_w, 32, uint32_t, W) 865ecb93716SSong Gao VSRLR(vsrlr_d, 64, uint64_t, D) 866ecb93716SSong Gao 867ecb93716SSong Gao #define VSRLRI(NAME, BIT, E) \ 868329517d5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \ 869ecb93716SSong Gao { \ 870ecb93716SSong Gao int i; \ 871329517d5SSong Gao VReg *Vd = (VReg *)vd; \ 872329517d5SSong Gao VReg *Vj = (VReg *)vj; \ 873ecb93716SSong Gao \ 874ecb93716SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 875ecb93716SSong Gao Vd->E(i) = do_vsrlr_ ## E(Vj->E(i), imm); \ 876ecb93716SSong Gao } \ 877ecb93716SSong Gao } 878ecb93716SSong Gao 879ecb93716SSong Gao VSRLRI(vsrlri_b, 8, B) 880ecb93716SSong Gao VSRLRI(vsrlri_h, 16, H) 881ecb93716SSong Gao VSRLRI(vsrlri_w, 32, W) 882ecb93716SSong Gao VSRLRI(vsrlri_d, 64, D) 883ecb93716SSong Gao 884ecb93716SSong Gao #define do_vsrar(E, T) \ 885ecb93716SSong Gao static T do_vsrar_ ##E(T s1, int sh) \ 886ecb93716SSong Gao { \ 887ecb93716SSong Gao if (sh == 0) { \ 888ecb93716SSong Gao return s1; \ 889ecb93716SSong Gao } else { \ 890ecb93716SSong Gao return (s1 >> sh) + ((s1 >> (sh - 1)) & 0x1); \ 891ecb93716SSong Gao } \ 892ecb93716SSong Gao } 893ecb93716SSong Gao 894ecb93716SSong Gao do_vsrar(B, int8_t) 895ecb93716SSong Gao do_vsrar(H, int16_t) 896ecb93716SSong Gao do_vsrar(W, int32_t) 897ecb93716SSong Gao do_vsrar(D, int64_t) 898ecb93716SSong Gao 899ecb93716SSong Gao #define VSRAR(NAME, BIT, T, E) \ 90004711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 901ecb93716SSong Gao { \ 902ecb93716SSong Gao int i; \ 90304711da1SSong Gao VReg *Vd = (VReg *)vd; \ 90404711da1SSong Gao VReg *Vj = (VReg *)vj; \ 90504711da1SSong Gao VReg *Vk = (VReg *)vk; \ 906ecb93716SSong Gao \ 907ecb93716SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 908ecb93716SSong Gao Vd->E(i) = do_vsrar_ ## E(Vj->E(i), ((T)Vk->E(i))%BIT); \ 909ecb93716SSong Gao } \ 910ecb93716SSong Gao } 911ecb93716SSong Gao 912ecb93716SSong Gao VSRAR(vsrar_b, 8, uint8_t, B) 913ecb93716SSong Gao VSRAR(vsrar_h, 16, uint16_t, H) 914ecb93716SSong Gao VSRAR(vsrar_w, 32, uint32_t, W) 915ecb93716SSong Gao VSRAR(vsrar_d, 64, uint64_t, D) 916ecb93716SSong Gao 917ecb93716SSong Gao #define VSRARI(NAME, BIT, E) \ 918329517d5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \ 919ecb93716SSong Gao { \ 920ecb93716SSong Gao int i; \ 921329517d5SSong Gao VReg *Vd = (VReg *)vd; \ 922329517d5SSong Gao VReg *Vj = (VReg *)vj; \ 923ecb93716SSong Gao \ 924ecb93716SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 925ecb93716SSong Gao Vd->E(i) = do_vsrar_ ## E(Vj->E(i), imm); \ 926ecb93716SSong Gao } \ 927ecb93716SSong Gao } 928ecb93716SSong Gao 929ecb93716SSong Gao VSRARI(vsrari_b, 8, B) 930ecb93716SSong Gao VSRARI(vsrari_h, 16, H) 931ecb93716SSong Gao VSRARI(vsrari_w, 32, W) 932ecb93716SSong Gao VSRARI(vsrari_d, 64, D) 933d79fb8ddSSong Gao 934d79fb8ddSSong Gao #define R_SHIFT(a, b) (a >> b) 935d79fb8ddSSong Gao 936d79fb8ddSSong Gao #define VSRLN(NAME, BIT, T, E1, E2) \ 93704711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 938d79fb8ddSSong Gao { \ 939d79fb8ddSSong Gao int i; \ 94004711da1SSong Gao VReg *Vd = (VReg *)vd; \ 94104711da1SSong Gao VReg *Vj = (VReg *)vj; \ 94204711da1SSong Gao VReg *Vk = (VReg *)vk; \ 943d79fb8ddSSong Gao \ 944d79fb8ddSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 945d79fb8ddSSong Gao Vd->E1(i) = R_SHIFT((T)Vj->E2(i),((T)Vk->E2(i)) % BIT); \ 946d79fb8ddSSong Gao } \ 947d79fb8ddSSong Gao Vd->D(1) = 0; \ 948d79fb8ddSSong Gao } 949d79fb8ddSSong Gao 950d79fb8ddSSong Gao VSRLN(vsrln_b_h, 16, uint16_t, B, H) 951d79fb8ddSSong Gao VSRLN(vsrln_h_w, 32, uint32_t, H, W) 952d79fb8ddSSong Gao VSRLN(vsrln_w_d, 64, uint64_t, W, D) 953d79fb8ddSSong Gao 954d79fb8ddSSong Gao #define VSRAN(NAME, BIT, T, E1, E2) \ 95504711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 956d79fb8ddSSong Gao { \ 957d79fb8ddSSong Gao int i; \ 95804711da1SSong Gao VReg *Vd = (VReg *)vd; \ 95904711da1SSong Gao VReg *Vj = (VReg *)vj; \ 96004711da1SSong Gao VReg *Vk = (VReg *)vk; \ 961d79fb8ddSSong Gao \ 962d79fb8ddSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 963d79fb8ddSSong Gao Vd->E1(i) = R_SHIFT(Vj->E2(i), ((T)Vk->E2(i)) % BIT); \ 964d79fb8ddSSong Gao } \ 965d79fb8ddSSong Gao Vd->D(1) = 0; \ 966d79fb8ddSSong Gao } 967d79fb8ddSSong Gao 968d79fb8ddSSong Gao VSRAN(vsran_b_h, 16, uint16_t, B, H) 969d79fb8ddSSong Gao VSRAN(vsran_h_w, 32, uint32_t, H, W) 970d79fb8ddSSong Gao VSRAN(vsran_w_d, 64, uint64_t, W, D) 971d79fb8ddSSong Gao 972d79fb8ddSSong Gao #define VSRLNI(NAME, BIT, T, E1, E2) \ 973329517d5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \ 974d79fb8ddSSong Gao { \ 975d79fb8ddSSong Gao int i, max; \ 976d79fb8ddSSong Gao VReg temp; \ 977329517d5SSong Gao VReg *Vd = (VReg *)vd; \ 978329517d5SSong Gao VReg *Vj = (VReg *)vj; \ 979d79fb8ddSSong Gao \ 980d79fb8ddSSong Gao temp.D(0) = 0; \ 981d79fb8ddSSong Gao temp.D(1) = 0; \ 982d79fb8ddSSong Gao max = LSX_LEN/BIT; \ 983d79fb8ddSSong Gao for (i = 0; i < max; i++) { \ 984d79fb8ddSSong Gao temp.E1(i) = R_SHIFT((T)Vj->E2(i), imm); \ 985d79fb8ddSSong Gao temp.E1(i + max) = R_SHIFT((T)Vd->E2(i), imm); \ 986d79fb8ddSSong Gao } \ 987d79fb8ddSSong Gao *Vd = temp; \ 988d79fb8ddSSong Gao } 989d79fb8ddSSong Gao 990329517d5SSong Gao void HELPER(vsrlni_d_q)(void *vd, void *vj, uint64_t imm, uint32_t desc) 991d79fb8ddSSong Gao { 992d79fb8ddSSong Gao VReg temp; 993329517d5SSong Gao VReg *Vd = (VReg *)vd; 994329517d5SSong Gao VReg *Vj = (VReg *)vj; 995d79fb8ddSSong Gao 996d79fb8ddSSong Gao temp.D(0) = 0; 997d79fb8ddSSong Gao temp.D(1) = 0; 998d79fb8ddSSong Gao temp.D(0) = int128_getlo(int128_urshift(Vj->Q(0), imm % 128)); 999d79fb8ddSSong Gao temp.D(1) = int128_getlo(int128_urshift(Vd->Q(0), imm % 128)); 1000d79fb8ddSSong Gao *Vd = temp; 1001d79fb8ddSSong Gao } 1002d79fb8ddSSong Gao 1003d79fb8ddSSong Gao VSRLNI(vsrlni_b_h, 16, uint16_t, B, H) 1004d79fb8ddSSong Gao VSRLNI(vsrlni_h_w, 32, uint32_t, H, W) 1005d79fb8ddSSong Gao VSRLNI(vsrlni_w_d, 64, uint64_t, W, D) 1006d79fb8ddSSong Gao 1007d79fb8ddSSong Gao #define VSRANI(NAME, BIT, E1, E2) \ 1008329517d5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \ 1009d79fb8ddSSong Gao { \ 1010d79fb8ddSSong Gao int i, max; \ 1011d79fb8ddSSong Gao VReg temp; \ 1012329517d5SSong Gao VReg *Vd = (VReg *)vd; \ 1013329517d5SSong Gao VReg *Vj = (VReg *)vj; \ 1014d79fb8ddSSong Gao \ 1015d79fb8ddSSong Gao temp.D(0) = 0; \ 1016d79fb8ddSSong Gao temp.D(1) = 0; \ 1017d79fb8ddSSong Gao max = LSX_LEN/BIT; \ 1018d79fb8ddSSong Gao for (i = 0; i < max; i++) { \ 1019d79fb8ddSSong Gao temp.E1(i) = R_SHIFT(Vj->E2(i), imm); \ 1020d79fb8ddSSong Gao temp.E1(i + max) = R_SHIFT(Vd->E2(i), imm); \ 1021d79fb8ddSSong Gao } \ 1022d79fb8ddSSong Gao *Vd = temp; \ 1023d79fb8ddSSong Gao } 1024d79fb8ddSSong Gao 1025329517d5SSong Gao void HELPER(vsrani_d_q)(void *vd, void *vj, uint64_t imm, uint32_t desc) 1026d79fb8ddSSong Gao { 1027d79fb8ddSSong Gao VReg temp; 1028329517d5SSong Gao VReg *Vd = (VReg *)vd; 1029329517d5SSong Gao VReg *Vj = (VReg *)vj; 1030d79fb8ddSSong Gao 1031d79fb8ddSSong Gao temp.D(0) = 0; 1032d79fb8ddSSong Gao temp.D(1) = 0; 1033d79fb8ddSSong Gao temp.D(0) = int128_getlo(int128_rshift(Vj->Q(0), imm % 128)); 1034d79fb8ddSSong Gao temp.D(1) = int128_getlo(int128_rshift(Vd->Q(0), imm % 128)); 1035d79fb8ddSSong Gao *Vd = temp; 1036d79fb8ddSSong Gao } 1037d79fb8ddSSong Gao 1038d79fb8ddSSong Gao VSRANI(vsrani_b_h, 16, B, H) 1039d79fb8ddSSong Gao VSRANI(vsrani_h_w, 32, H, W) 1040d79fb8ddSSong Gao VSRANI(vsrani_w_d, 64, W, D) 1041a5200a17SSong Gao 1042a5200a17SSong Gao #define VSRLRN(NAME, BIT, T, E1, E2) \ 104304711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 1044a5200a17SSong Gao { \ 1045a5200a17SSong Gao int i; \ 104604711da1SSong Gao VReg *Vd = (VReg *)vd; \ 104704711da1SSong Gao VReg *Vj = (VReg *)vj; \ 104804711da1SSong Gao VReg *Vk = (VReg *)vk; \ 1049a5200a17SSong Gao \ 1050a5200a17SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1051a5200a17SSong Gao Vd->E1(i) = do_vsrlr_ ## E2(Vj->E2(i), ((T)Vk->E2(i))%BIT); \ 1052a5200a17SSong Gao } \ 1053a5200a17SSong Gao Vd->D(1) = 0; \ 1054a5200a17SSong Gao } 1055a5200a17SSong Gao 1056a5200a17SSong Gao VSRLRN(vsrlrn_b_h, 16, uint16_t, B, H) 1057a5200a17SSong Gao VSRLRN(vsrlrn_h_w, 32, uint32_t, H, W) 1058a5200a17SSong Gao VSRLRN(vsrlrn_w_d, 64, uint64_t, W, D) 1059a5200a17SSong Gao 1060a5200a17SSong Gao #define VSRARN(NAME, BIT, T, E1, E2) \ 106104711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 1062a5200a17SSong Gao { \ 1063a5200a17SSong Gao int i; \ 106404711da1SSong Gao VReg *Vd = (VReg *)vd; \ 106504711da1SSong Gao VReg *Vj = (VReg *)vj; \ 106604711da1SSong Gao VReg *Vk = (VReg *)vk; \ 1067a5200a17SSong Gao \ 1068a5200a17SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1069a5200a17SSong Gao Vd->E1(i) = do_vsrar_ ## E2(Vj->E2(i), ((T)Vk->E2(i))%BIT); \ 1070a5200a17SSong Gao } \ 1071a5200a17SSong Gao Vd->D(1) = 0; \ 1072a5200a17SSong Gao } 1073a5200a17SSong Gao 1074a5200a17SSong Gao VSRARN(vsrarn_b_h, 16, uint8_t, B, H) 1075a5200a17SSong Gao VSRARN(vsrarn_h_w, 32, uint16_t, H, W) 1076a5200a17SSong Gao VSRARN(vsrarn_w_d, 64, uint32_t, W, D) 1077a5200a17SSong Gao 1078a5200a17SSong Gao #define VSRLRNI(NAME, BIT, E1, E2) \ 1079329517d5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \ 1080a5200a17SSong Gao { \ 1081a5200a17SSong Gao int i, max; \ 1082a5200a17SSong Gao VReg temp; \ 1083329517d5SSong Gao VReg *Vd = (VReg *)vd; \ 1084329517d5SSong Gao VReg *Vj = (VReg *)vj; \ 1085a5200a17SSong Gao \ 1086a5200a17SSong Gao temp.D(0) = 0; \ 1087a5200a17SSong Gao temp.D(1) = 0; \ 1088a5200a17SSong Gao max = LSX_LEN/BIT; \ 1089a5200a17SSong Gao for (i = 0; i < max; i++) { \ 1090a5200a17SSong Gao temp.E1(i) = do_vsrlr_ ## E2(Vj->E2(i), imm); \ 1091a5200a17SSong Gao temp.E1(i + max) = do_vsrlr_ ## E2(Vd->E2(i), imm); \ 1092a5200a17SSong Gao } \ 1093a5200a17SSong Gao *Vd = temp; \ 1094a5200a17SSong Gao } 1095a5200a17SSong Gao 1096329517d5SSong Gao void HELPER(vsrlrni_d_q)(void *vd, void *vj, uint64_t imm, uint32_t desc) 1097a5200a17SSong Gao { 1098a5200a17SSong Gao VReg temp; 1099329517d5SSong Gao VReg *Vd = (VReg *)vd; 1100329517d5SSong Gao VReg *Vj = (VReg *)vj; 1101a5200a17SSong Gao Int128 r1, r2; 1102a5200a17SSong Gao 1103a5200a17SSong Gao if (imm == 0) { 1104a5200a17SSong Gao temp.D(0) = int128_getlo(Vj->Q(0)); 1105a5200a17SSong Gao temp.D(1) = int128_getlo(Vd->Q(0)); 1106a5200a17SSong Gao } else { 1107a5200a17SSong Gao r1 = int128_and(int128_urshift(Vj->Q(0), (imm -1)), int128_one()); 1108a5200a17SSong Gao r2 = int128_and(int128_urshift(Vd->Q(0), (imm -1)), int128_one()); 1109a5200a17SSong Gao 1110a5200a17SSong Gao temp.D(0) = int128_getlo(int128_add(int128_urshift(Vj->Q(0), imm), r1)); 1111a5200a17SSong Gao temp.D(1) = int128_getlo(int128_add(int128_urshift(Vd->Q(0), imm), r2)); 1112a5200a17SSong Gao } 1113a5200a17SSong Gao *Vd = temp; 1114a5200a17SSong Gao } 1115a5200a17SSong Gao 1116a5200a17SSong Gao VSRLRNI(vsrlrni_b_h, 16, B, H) 1117a5200a17SSong Gao VSRLRNI(vsrlrni_h_w, 32, H, W) 1118a5200a17SSong Gao VSRLRNI(vsrlrni_w_d, 64, W, D) 1119a5200a17SSong Gao 1120a5200a17SSong Gao #define VSRARNI(NAME, BIT, E1, E2) \ 1121329517d5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \ 1122a5200a17SSong Gao { \ 1123a5200a17SSong Gao int i, max; \ 1124a5200a17SSong Gao VReg temp; \ 1125329517d5SSong Gao VReg *Vd = (VReg *)vd; \ 1126329517d5SSong Gao VReg *Vj = (VReg *)vj; \ 1127a5200a17SSong Gao \ 1128a5200a17SSong Gao temp.D(0) = 0; \ 1129a5200a17SSong Gao temp.D(1) = 0; \ 1130a5200a17SSong Gao max = LSX_LEN/BIT; \ 1131a5200a17SSong Gao for (i = 0; i < max; i++) { \ 1132a5200a17SSong Gao temp.E1(i) = do_vsrar_ ## E2(Vj->E2(i), imm); \ 1133a5200a17SSong Gao temp.E1(i + max) = do_vsrar_ ## E2(Vd->E2(i), imm); \ 1134a5200a17SSong Gao } \ 1135a5200a17SSong Gao *Vd = temp; \ 1136a5200a17SSong Gao } 1137a5200a17SSong Gao 1138329517d5SSong Gao void HELPER(vsrarni_d_q)(void *vd, void *vj, uint64_t imm, uint32_t desc) 1139a5200a17SSong Gao { 1140a5200a17SSong Gao VReg temp; 1141329517d5SSong Gao VReg *Vd = (VReg *)vd; 1142329517d5SSong Gao VReg *Vj = (VReg *)vj; 1143a5200a17SSong Gao Int128 r1, r2; 1144a5200a17SSong Gao 1145a5200a17SSong Gao if (imm == 0) { 1146a5200a17SSong Gao temp.D(0) = int128_getlo(Vj->Q(0)); 1147a5200a17SSong Gao temp.D(1) = int128_getlo(Vd->Q(0)); 1148a5200a17SSong Gao } else { 1149a5200a17SSong Gao r1 = int128_and(int128_rshift(Vj->Q(0), (imm -1)), int128_one()); 1150a5200a17SSong Gao r2 = int128_and(int128_rshift(Vd->Q(0), (imm -1)), int128_one()); 1151a5200a17SSong Gao 1152a5200a17SSong Gao temp.D(0) = int128_getlo(int128_add(int128_rshift(Vj->Q(0), imm), r1)); 1153a5200a17SSong Gao temp.D(1) = int128_getlo(int128_add(int128_rshift(Vd->Q(0), imm), r2)); 1154a5200a17SSong Gao } 1155a5200a17SSong Gao *Vd = temp; 1156a5200a17SSong Gao } 1157a5200a17SSong Gao 1158a5200a17SSong Gao VSRARNI(vsrarni_b_h, 16, B, H) 1159a5200a17SSong Gao VSRARNI(vsrarni_h_w, 32, H, W) 1160a5200a17SSong Gao VSRARNI(vsrarni_w_d, 64, W, D) 116183b3815dSSong Gao 116283b3815dSSong Gao #define SSRLNS(NAME, T1, T2, T3) \ 116383b3815dSSong Gao static T1 do_ssrlns_ ## NAME(T2 e2, int sa, int sh) \ 116483b3815dSSong Gao { \ 116583b3815dSSong Gao T1 shft_res; \ 116683b3815dSSong Gao if (sa == 0) { \ 116783b3815dSSong Gao shft_res = e2; \ 116883b3815dSSong Gao } else { \ 116983b3815dSSong Gao shft_res = (((T1)e2) >> sa); \ 117083b3815dSSong Gao } \ 117183b3815dSSong Gao T3 mask; \ 117283b3815dSSong Gao mask = (1ull << sh) -1; \ 117383b3815dSSong Gao if (shft_res > mask) { \ 117483b3815dSSong Gao return mask; \ 117583b3815dSSong Gao } else { \ 117683b3815dSSong Gao return shft_res; \ 117783b3815dSSong Gao } \ 117883b3815dSSong Gao } 117983b3815dSSong Gao 118083b3815dSSong Gao SSRLNS(B, uint16_t, int16_t, uint8_t) 118183b3815dSSong Gao SSRLNS(H, uint32_t, int32_t, uint16_t) 118283b3815dSSong Gao SSRLNS(W, uint64_t, int64_t, uint32_t) 118383b3815dSSong Gao 118483b3815dSSong Gao #define VSSRLN(NAME, BIT, T, E1, E2) \ 118504711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 118683b3815dSSong Gao { \ 118783b3815dSSong Gao int i; \ 118804711da1SSong Gao VReg *Vd = (VReg *)vd; \ 118904711da1SSong Gao VReg *Vj = (VReg *)vj; \ 119004711da1SSong Gao VReg *Vk = (VReg *)vk; \ 119183b3815dSSong Gao \ 119283b3815dSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 119383b3815dSSong Gao Vd->E1(i) = do_ssrlns_ ## E1(Vj->E2(i), (T)Vk->E2(i)% BIT, BIT/2 -1); \ 119483b3815dSSong Gao } \ 119583b3815dSSong Gao Vd->D(1) = 0; \ 119683b3815dSSong Gao } 119783b3815dSSong Gao 119883b3815dSSong Gao VSSRLN(vssrln_b_h, 16, uint16_t, B, H) 119983b3815dSSong Gao VSSRLN(vssrln_h_w, 32, uint32_t, H, W) 120083b3815dSSong Gao VSSRLN(vssrln_w_d, 64, uint64_t, W, D) 120183b3815dSSong Gao 120283b3815dSSong Gao #define SSRANS(E, T1, T2) \ 120383b3815dSSong Gao static T1 do_ssrans_ ## E(T1 e2, int sa, int sh) \ 120483b3815dSSong Gao { \ 120583b3815dSSong Gao T1 shft_res; \ 120683b3815dSSong Gao if (sa == 0) { \ 120783b3815dSSong Gao shft_res = e2; \ 120883b3815dSSong Gao } else { \ 120983b3815dSSong Gao shft_res = e2 >> sa; \ 121083b3815dSSong Gao } \ 121183b3815dSSong Gao T2 mask; \ 121283b3815dSSong Gao mask = (1ll << sh) -1; \ 121383b3815dSSong Gao if (shft_res > mask) { \ 121483b3815dSSong Gao return mask; \ 121583b3815dSSong Gao } else if (shft_res < -(mask +1)) { \ 121683b3815dSSong Gao return ~mask; \ 121783b3815dSSong Gao } else { \ 121883b3815dSSong Gao return shft_res; \ 121983b3815dSSong Gao } \ 122083b3815dSSong Gao } 122183b3815dSSong Gao 122283b3815dSSong Gao SSRANS(B, int16_t, int8_t) 122383b3815dSSong Gao SSRANS(H, int32_t, int16_t) 122483b3815dSSong Gao SSRANS(W, int64_t, int32_t) 122583b3815dSSong Gao 122683b3815dSSong Gao #define VSSRAN(NAME, BIT, T, E1, E2) \ 122704711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 122883b3815dSSong Gao { \ 122983b3815dSSong Gao int i; \ 123004711da1SSong Gao VReg *Vd = (VReg *)vd; \ 123104711da1SSong Gao VReg *Vj = (VReg *)vj; \ 123204711da1SSong Gao VReg *Vk = (VReg *)vk; \ 123383b3815dSSong Gao \ 123483b3815dSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 123583b3815dSSong Gao Vd->E1(i) = do_ssrans_ ## E1(Vj->E2(i), (T)Vk->E2(i)%BIT, BIT/2 -1); \ 123683b3815dSSong Gao } \ 123783b3815dSSong Gao Vd->D(1) = 0; \ 123883b3815dSSong Gao } 123983b3815dSSong Gao 124083b3815dSSong Gao VSSRAN(vssran_b_h, 16, uint16_t, B, H) 124183b3815dSSong Gao VSSRAN(vssran_h_w, 32, uint32_t, H, W) 124283b3815dSSong Gao VSSRAN(vssran_w_d, 64, uint64_t, W, D) 124383b3815dSSong Gao 124483b3815dSSong Gao #define SSRLNU(E, T1, T2, T3) \ 124583b3815dSSong Gao static T1 do_ssrlnu_ ## E(T3 e2, int sa, int sh) \ 124683b3815dSSong Gao { \ 124783b3815dSSong Gao T1 shft_res; \ 124883b3815dSSong Gao if (sa == 0) { \ 124983b3815dSSong Gao shft_res = e2; \ 125083b3815dSSong Gao } else { \ 125183b3815dSSong Gao shft_res = (((T1)e2) >> sa); \ 125283b3815dSSong Gao } \ 125383b3815dSSong Gao T2 mask; \ 125483b3815dSSong Gao mask = (1ull << sh) -1; \ 125583b3815dSSong Gao if (shft_res > mask) { \ 125683b3815dSSong Gao return mask; \ 125783b3815dSSong Gao } else { \ 125883b3815dSSong Gao return shft_res; \ 125983b3815dSSong Gao } \ 126083b3815dSSong Gao } 126183b3815dSSong Gao 126283b3815dSSong Gao SSRLNU(B, uint16_t, uint8_t, int16_t) 126383b3815dSSong Gao SSRLNU(H, uint32_t, uint16_t, int32_t) 126483b3815dSSong Gao SSRLNU(W, uint64_t, uint32_t, int64_t) 126583b3815dSSong Gao 126683b3815dSSong Gao #define VSSRLNU(NAME, BIT, T, E1, E2) \ 126704711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 126883b3815dSSong Gao { \ 126983b3815dSSong Gao int i; \ 127004711da1SSong Gao VReg *Vd = (VReg *)vd; \ 127104711da1SSong Gao VReg *Vj = (VReg *)vj; \ 127204711da1SSong Gao VReg *Vk = (VReg *)vk; \ 127383b3815dSSong Gao \ 127483b3815dSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 127583b3815dSSong Gao Vd->E1(i) = do_ssrlnu_ ## E1(Vj->E2(i), (T)Vk->E2(i)%BIT, BIT/2); \ 127683b3815dSSong Gao } \ 127783b3815dSSong Gao Vd->D(1) = 0; \ 127883b3815dSSong Gao } 127983b3815dSSong Gao 128083b3815dSSong Gao VSSRLNU(vssrln_bu_h, 16, uint16_t, B, H) 128183b3815dSSong Gao VSSRLNU(vssrln_hu_w, 32, uint32_t, H, W) 128283b3815dSSong Gao VSSRLNU(vssrln_wu_d, 64, uint64_t, W, D) 128383b3815dSSong Gao 128483b3815dSSong Gao #define SSRANU(E, T1, T2, T3) \ 128583b3815dSSong Gao static T1 do_ssranu_ ## E(T3 e2, int sa, int sh) \ 128683b3815dSSong Gao { \ 128783b3815dSSong Gao T1 shft_res; \ 128883b3815dSSong Gao if (sa == 0) { \ 128983b3815dSSong Gao shft_res = e2; \ 129083b3815dSSong Gao } else { \ 129183b3815dSSong Gao shft_res = e2 >> sa; \ 129283b3815dSSong Gao } \ 129383b3815dSSong Gao if (e2 < 0) { \ 129483b3815dSSong Gao shft_res = 0; \ 129583b3815dSSong Gao } \ 129683b3815dSSong Gao T2 mask; \ 129783b3815dSSong Gao mask = (1ull << sh) -1; \ 129883b3815dSSong Gao if (shft_res > mask) { \ 129983b3815dSSong Gao return mask; \ 130083b3815dSSong Gao } else { \ 130183b3815dSSong Gao return shft_res; \ 130283b3815dSSong Gao } \ 130383b3815dSSong Gao } 130483b3815dSSong Gao 130583b3815dSSong Gao SSRANU(B, uint16_t, uint8_t, int16_t) 130683b3815dSSong Gao SSRANU(H, uint32_t, uint16_t, int32_t) 130783b3815dSSong Gao SSRANU(W, uint64_t, uint32_t, int64_t) 130883b3815dSSong Gao 130983b3815dSSong Gao #define VSSRANU(NAME, BIT, T, E1, E2) \ 131004711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 131183b3815dSSong Gao { \ 131283b3815dSSong Gao int i; \ 131304711da1SSong Gao VReg *Vd = (VReg *)vd; \ 131404711da1SSong Gao VReg *Vj = (VReg *)vj; \ 131504711da1SSong Gao VReg *Vk = (VReg *)vk; \ 131683b3815dSSong Gao \ 131783b3815dSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 131883b3815dSSong Gao Vd->E1(i) = do_ssranu_ ## E1(Vj->E2(i), (T)Vk->E2(i)%BIT, BIT/2); \ 131983b3815dSSong Gao } \ 132083b3815dSSong Gao Vd->D(1) = 0; \ 132183b3815dSSong Gao } 132283b3815dSSong Gao 132383b3815dSSong Gao VSSRANU(vssran_bu_h, 16, uint16_t, B, H) 132483b3815dSSong Gao VSSRANU(vssran_hu_w, 32, uint32_t, H, W) 132583b3815dSSong Gao VSSRANU(vssran_wu_d, 64, uint64_t, W, D) 132683b3815dSSong Gao 132783b3815dSSong Gao #define VSSRLNI(NAME, BIT, E1, E2) \ 1328329517d5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \ 132983b3815dSSong Gao { \ 133083b3815dSSong Gao int i; \ 133183b3815dSSong Gao VReg temp; \ 1332329517d5SSong Gao VReg *Vd = (VReg *)vd; \ 1333329517d5SSong Gao VReg *Vj = (VReg *)vj; \ 133483b3815dSSong Gao \ 133583b3815dSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 133683b3815dSSong Gao temp.E1(i) = do_ssrlns_ ## E1(Vj->E2(i), imm, BIT/2 -1); \ 133783b3815dSSong Gao temp.E1(i + LSX_LEN/BIT) = do_ssrlns_ ## E1(Vd->E2(i), imm, BIT/2 -1);\ 133883b3815dSSong Gao } \ 133983b3815dSSong Gao *Vd = temp; \ 134083b3815dSSong Gao } 134183b3815dSSong Gao 1342329517d5SSong Gao void HELPER(vssrlni_d_q)(void *vd, void *vj, uint64_t imm, uint32_t desc) 134383b3815dSSong Gao { 134483b3815dSSong Gao Int128 shft_res1, shft_res2, mask; 1345329517d5SSong Gao VReg *Vd = (VReg *)vd; 1346329517d5SSong Gao VReg *Vj = (VReg *)vj; 134783b3815dSSong Gao 134883b3815dSSong Gao if (imm == 0) { 134983b3815dSSong Gao shft_res1 = Vj->Q(0); 135083b3815dSSong Gao shft_res2 = Vd->Q(0); 135183b3815dSSong Gao } else { 135283b3815dSSong Gao shft_res1 = int128_urshift(Vj->Q(0), imm); 135383b3815dSSong Gao shft_res2 = int128_urshift(Vd->Q(0), imm); 135483b3815dSSong Gao } 135583b3815dSSong Gao mask = int128_sub(int128_lshift(int128_one(), 63), int128_one()); 135683b3815dSSong Gao 135783b3815dSSong Gao if (int128_ult(mask, shft_res1)) { 135883b3815dSSong Gao Vd->D(0) = int128_getlo(mask); 135983b3815dSSong Gao }else { 136083b3815dSSong Gao Vd->D(0) = int128_getlo(shft_res1); 136183b3815dSSong Gao } 136283b3815dSSong Gao 136383b3815dSSong Gao if (int128_ult(mask, shft_res2)) { 136483b3815dSSong Gao Vd->D(1) = int128_getlo(mask); 136583b3815dSSong Gao }else { 136683b3815dSSong Gao Vd->D(1) = int128_getlo(shft_res2); 136783b3815dSSong Gao } 136883b3815dSSong Gao } 136983b3815dSSong Gao 137083b3815dSSong Gao VSSRLNI(vssrlni_b_h, 16, B, H) 137183b3815dSSong Gao VSSRLNI(vssrlni_h_w, 32, H, W) 137283b3815dSSong Gao VSSRLNI(vssrlni_w_d, 64, W, D) 137383b3815dSSong Gao 137483b3815dSSong Gao #define VSSRANI(NAME, BIT, E1, E2) \ 1375329517d5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \ 137683b3815dSSong Gao { \ 137783b3815dSSong Gao int i; \ 137883b3815dSSong Gao VReg temp; \ 1379329517d5SSong Gao VReg *Vd = (VReg *)vd; \ 1380329517d5SSong Gao VReg *Vj = (VReg *)vj; \ 138183b3815dSSong Gao \ 138283b3815dSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 138383b3815dSSong Gao temp.E1(i) = do_ssrans_ ## E1(Vj->E2(i), imm, BIT/2 -1); \ 138483b3815dSSong Gao temp.E1(i + LSX_LEN/BIT) = do_ssrans_ ## E1(Vd->E2(i), imm, BIT/2 -1); \ 138583b3815dSSong Gao } \ 138683b3815dSSong Gao *Vd = temp; \ 138783b3815dSSong Gao } 138883b3815dSSong Gao 1389329517d5SSong Gao void HELPER(vssrani_d_q)(void *vd, void *vj, uint64_t imm, uint32_t desc) 139083b3815dSSong Gao { 139183b3815dSSong Gao Int128 shft_res1, shft_res2, mask, min; 1392329517d5SSong Gao VReg *Vd = (VReg *)vd; 1393329517d5SSong Gao VReg *Vj = (VReg *)vj; 139483b3815dSSong Gao 139583b3815dSSong Gao if (imm == 0) { 139683b3815dSSong Gao shft_res1 = Vj->Q(0); 139783b3815dSSong Gao shft_res2 = Vd->Q(0); 139883b3815dSSong Gao } else { 139983b3815dSSong Gao shft_res1 = int128_rshift(Vj->Q(0), imm); 140083b3815dSSong Gao shft_res2 = int128_rshift(Vd->Q(0), imm); 140183b3815dSSong Gao } 140283b3815dSSong Gao mask = int128_sub(int128_lshift(int128_one(), 63), int128_one()); 140383b3815dSSong Gao min = int128_lshift(int128_one(), 63); 140483b3815dSSong Gao 140583b3815dSSong Gao if (int128_gt(shft_res1, mask)) { 140683b3815dSSong Gao Vd->D(0) = int128_getlo(mask); 140783b3815dSSong Gao } else if (int128_lt(shft_res1, int128_neg(min))) { 140883b3815dSSong Gao Vd->D(0) = int128_getlo(min); 140983b3815dSSong Gao } else { 141083b3815dSSong Gao Vd->D(0) = int128_getlo(shft_res1); 141183b3815dSSong Gao } 141283b3815dSSong Gao 141383b3815dSSong Gao if (int128_gt(shft_res2, mask)) { 141483b3815dSSong Gao Vd->D(1) = int128_getlo(mask); 141583b3815dSSong Gao } else if (int128_lt(shft_res2, int128_neg(min))) { 141683b3815dSSong Gao Vd->D(1) = int128_getlo(min); 141783b3815dSSong Gao } else { 141883b3815dSSong Gao Vd->D(1) = int128_getlo(shft_res2); 141983b3815dSSong Gao } 142083b3815dSSong Gao } 142183b3815dSSong Gao 142283b3815dSSong Gao VSSRANI(vssrani_b_h, 16, B, H) 142383b3815dSSong Gao VSSRANI(vssrani_h_w, 32, H, W) 142483b3815dSSong Gao VSSRANI(vssrani_w_d, 64, W, D) 142583b3815dSSong Gao 142683b3815dSSong Gao #define VSSRLNUI(NAME, BIT, E1, E2) \ 1427329517d5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \ 142883b3815dSSong Gao { \ 142983b3815dSSong Gao int i; \ 143083b3815dSSong Gao VReg temp; \ 1431329517d5SSong Gao VReg *Vd = (VReg *)vd; \ 1432329517d5SSong Gao VReg *Vj = (VReg *)vj; \ 143383b3815dSSong Gao \ 143483b3815dSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 143583b3815dSSong Gao temp.E1(i) = do_ssrlnu_ ## E1(Vj->E2(i), imm, BIT/2); \ 143683b3815dSSong Gao temp.E1(i + LSX_LEN/BIT) = do_ssrlnu_ ## E1(Vd->E2(i), imm, BIT/2); \ 143783b3815dSSong Gao } \ 143883b3815dSSong Gao *Vd = temp; \ 143983b3815dSSong Gao } 144083b3815dSSong Gao 1441329517d5SSong Gao void HELPER(vssrlni_du_q)(void *vd, void *vj, uint64_t imm, uint32_t desc) 144283b3815dSSong Gao { 144383b3815dSSong Gao Int128 shft_res1, shft_res2, mask; 1444329517d5SSong Gao VReg *Vd = (VReg *)vd; 1445329517d5SSong Gao VReg *Vj = (VReg *)vj; 144683b3815dSSong Gao 144783b3815dSSong Gao if (imm == 0) { 144883b3815dSSong Gao shft_res1 = Vj->Q(0); 144983b3815dSSong Gao shft_res2 = Vd->Q(0); 145083b3815dSSong Gao } else { 145183b3815dSSong Gao shft_res1 = int128_urshift(Vj->Q(0), imm); 145283b3815dSSong Gao shft_res2 = int128_urshift(Vd->Q(0), imm); 145383b3815dSSong Gao } 145483b3815dSSong Gao mask = int128_sub(int128_lshift(int128_one(), 64), int128_one()); 145583b3815dSSong Gao 145683b3815dSSong Gao if (int128_ult(mask, shft_res1)) { 145783b3815dSSong Gao Vd->D(0) = int128_getlo(mask); 145883b3815dSSong Gao }else { 145983b3815dSSong Gao Vd->D(0) = int128_getlo(shft_res1); 146083b3815dSSong Gao } 146183b3815dSSong Gao 146283b3815dSSong Gao if (int128_ult(mask, shft_res2)) { 146383b3815dSSong Gao Vd->D(1) = int128_getlo(mask); 146483b3815dSSong Gao }else { 146583b3815dSSong Gao Vd->D(1) = int128_getlo(shft_res2); 146683b3815dSSong Gao } 146783b3815dSSong Gao } 146883b3815dSSong Gao 146983b3815dSSong Gao VSSRLNUI(vssrlni_bu_h, 16, B, H) 147083b3815dSSong Gao VSSRLNUI(vssrlni_hu_w, 32, H, W) 147183b3815dSSong Gao VSSRLNUI(vssrlni_wu_d, 64, W, D) 147283b3815dSSong Gao 147383b3815dSSong Gao #define VSSRANUI(NAME, BIT, E1, E2) \ 1474329517d5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \ 147583b3815dSSong Gao { \ 147683b3815dSSong Gao int i; \ 147783b3815dSSong Gao VReg temp; \ 1478329517d5SSong Gao VReg *Vd = (VReg *)vd; \ 1479329517d5SSong Gao VReg *Vj = (VReg *)vj; \ 148083b3815dSSong Gao \ 148183b3815dSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 148283b3815dSSong Gao temp.E1(i) = do_ssranu_ ## E1(Vj->E2(i), imm, BIT/2); \ 148383b3815dSSong Gao temp.E1(i + LSX_LEN/BIT) = do_ssranu_ ## E1(Vd->E2(i), imm, BIT/2); \ 148483b3815dSSong Gao } \ 148583b3815dSSong Gao *Vd = temp; \ 148683b3815dSSong Gao } 148783b3815dSSong Gao 1488329517d5SSong Gao void HELPER(vssrani_du_q)(void *vd, void *vj, uint64_t imm, uint32_t desc) 148983b3815dSSong Gao { 149083b3815dSSong Gao Int128 shft_res1, shft_res2, mask; 1491329517d5SSong Gao VReg *Vd = (VReg *)vd; 1492329517d5SSong Gao VReg *Vj = (VReg *)vj; 149383b3815dSSong Gao 149483b3815dSSong Gao if (imm == 0) { 149583b3815dSSong Gao shft_res1 = Vj->Q(0); 149683b3815dSSong Gao shft_res2 = Vd->Q(0); 149783b3815dSSong Gao } else { 149883b3815dSSong Gao shft_res1 = int128_rshift(Vj->Q(0), imm); 149983b3815dSSong Gao shft_res2 = int128_rshift(Vd->Q(0), imm); 150083b3815dSSong Gao } 150183b3815dSSong Gao 150283b3815dSSong Gao if (int128_lt(Vj->Q(0), int128_zero())) { 150383b3815dSSong Gao shft_res1 = int128_zero(); 150483b3815dSSong Gao } 150583b3815dSSong Gao 150683b3815dSSong Gao if (int128_lt(Vd->Q(0), int128_zero())) { 150783b3815dSSong Gao shft_res2 = int128_zero(); 150883b3815dSSong Gao } 150983b3815dSSong Gao 151083b3815dSSong Gao mask = int128_sub(int128_lshift(int128_one(), 64), int128_one()); 151183b3815dSSong Gao 151283b3815dSSong Gao if (int128_ult(mask, shft_res1)) { 151383b3815dSSong Gao Vd->D(0) = int128_getlo(mask); 151483b3815dSSong Gao }else { 151583b3815dSSong Gao Vd->D(0) = int128_getlo(shft_res1); 151683b3815dSSong Gao } 151783b3815dSSong Gao 151883b3815dSSong Gao if (int128_ult(mask, shft_res2)) { 151983b3815dSSong Gao Vd->D(1) = int128_getlo(mask); 152083b3815dSSong Gao }else { 152183b3815dSSong Gao Vd->D(1) = int128_getlo(shft_res2); 152283b3815dSSong Gao } 152383b3815dSSong Gao } 152483b3815dSSong Gao 152583b3815dSSong Gao VSSRANUI(vssrani_bu_h, 16, B, H) 152683b3815dSSong Gao VSSRANUI(vssrani_hu_w, 32, H, W) 152783b3815dSSong Gao VSSRANUI(vssrani_wu_d, 64, W, D) 1528162cd32cSSong Gao 1529162cd32cSSong Gao #define SSRLRNS(E1, E2, T1, T2, T3) \ 1530162cd32cSSong Gao static T1 do_ssrlrns_ ## E1(T2 e2, int sa, int sh) \ 1531162cd32cSSong Gao { \ 1532162cd32cSSong Gao T1 shft_res; \ 1533162cd32cSSong Gao \ 1534162cd32cSSong Gao shft_res = do_vsrlr_ ## E2(e2, sa); \ 1535162cd32cSSong Gao T1 mask; \ 1536162cd32cSSong Gao mask = (1ull << sh) -1; \ 1537162cd32cSSong Gao if (shft_res > mask) { \ 1538162cd32cSSong Gao return mask; \ 1539162cd32cSSong Gao } else { \ 1540162cd32cSSong Gao return shft_res; \ 1541162cd32cSSong Gao } \ 1542162cd32cSSong Gao } 1543162cd32cSSong Gao 1544162cd32cSSong Gao SSRLRNS(B, H, uint16_t, int16_t, uint8_t) 1545162cd32cSSong Gao SSRLRNS(H, W, uint32_t, int32_t, uint16_t) 1546162cd32cSSong Gao SSRLRNS(W, D, uint64_t, int64_t, uint32_t) 1547162cd32cSSong Gao 1548162cd32cSSong Gao #define VSSRLRN(NAME, BIT, T, E1, E2) \ 154904711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 1550162cd32cSSong Gao { \ 1551162cd32cSSong Gao int i; \ 155204711da1SSong Gao VReg *Vd = (VReg *)vd; \ 155304711da1SSong Gao VReg *Vj = (VReg *)vj; \ 155404711da1SSong Gao VReg *Vk = (VReg *)vk; \ 1555162cd32cSSong Gao \ 1556162cd32cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1557162cd32cSSong Gao Vd->E1(i) = do_ssrlrns_ ## E1(Vj->E2(i), (T)Vk->E2(i)%BIT, BIT/2 -1); \ 1558162cd32cSSong Gao } \ 1559162cd32cSSong Gao Vd->D(1) = 0; \ 1560162cd32cSSong Gao } 1561162cd32cSSong Gao 1562162cd32cSSong Gao VSSRLRN(vssrlrn_b_h, 16, uint16_t, B, H) 1563162cd32cSSong Gao VSSRLRN(vssrlrn_h_w, 32, uint32_t, H, W) 1564162cd32cSSong Gao VSSRLRN(vssrlrn_w_d, 64, uint64_t, W, D) 1565162cd32cSSong Gao 1566162cd32cSSong Gao #define SSRARNS(E1, E2, T1, T2) \ 1567162cd32cSSong Gao static T1 do_ssrarns_ ## E1(T1 e2, int sa, int sh) \ 1568162cd32cSSong Gao { \ 1569162cd32cSSong Gao T1 shft_res; \ 1570162cd32cSSong Gao \ 1571162cd32cSSong Gao shft_res = do_vsrar_ ## E2(e2, sa); \ 1572162cd32cSSong Gao T2 mask; \ 1573162cd32cSSong Gao mask = (1ll << sh) -1; \ 1574162cd32cSSong Gao if (shft_res > mask) { \ 1575162cd32cSSong Gao return mask; \ 1576162cd32cSSong Gao } else if (shft_res < -(mask +1)) { \ 1577162cd32cSSong Gao return ~mask; \ 1578162cd32cSSong Gao } else { \ 1579162cd32cSSong Gao return shft_res; \ 1580162cd32cSSong Gao } \ 1581162cd32cSSong Gao } 1582162cd32cSSong Gao 1583162cd32cSSong Gao SSRARNS(B, H, int16_t, int8_t) 1584162cd32cSSong Gao SSRARNS(H, W, int32_t, int16_t) 1585162cd32cSSong Gao SSRARNS(W, D, int64_t, int32_t) 1586162cd32cSSong Gao 1587162cd32cSSong Gao #define VSSRARN(NAME, BIT, T, E1, E2) \ 158804711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 1589162cd32cSSong Gao { \ 1590162cd32cSSong Gao int i; \ 159104711da1SSong Gao VReg *Vd = (VReg *)vd; \ 159204711da1SSong Gao VReg *Vj = (VReg *)vj; \ 159304711da1SSong Gao VReg *Vk = (VReg *)vk; \ 1594162cd32cSSong Gao \ 1595162cd32cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1596162cd32cSSong Gao Vd->E1(i) = do_ssrarns_ ## E1(Vj->E2(i), (T)Vk->E2(i)%BIT, BIT/2 -1); \ 1597162cd32cSSong Gao } \ 1598162cd32cSSong Gao Vd->D(1) = 0; \ 1599162cd32cSSong Gao } 1600162cd32cSSong Gao 1601162cd32cSSong Gao VSSRARN(vssrarn_b_h, 16, uint16_t, B, H) 1602162cd32cSSong Gao VSSRARN(vssrarn_h_w, 32, uint32_t, H, W) 1603162cd32cSSong Gao VSSRARN(vssrarn_w_d, 64, uint64_t, W, D) 1604162cd32cSSong Gao 1605162cd32cSSong Gao #define SSRLRNU(E1, E2, T1, T2, T3) \ 1606162cd32cSSong Gao static T1 do_ssrlrnu_ ## E1(T3 e2, int sa, int sh) \ 1607162cd32cSSong Gao { \ 1608162cd32cSSong Gao T1 shft_res; \ 1609162cd32cSSong Gao \ 1610162cd32cSSong Gao shft_res = do_vsrlr_ ## E2(e2, sa); \ 1611162cd32cSSong Gao \ 1612162cd32cSSong Gao T2 mask; \ 1613162cd32cSSong Gao mask = (1ull << sh) -1; \ 1614162cd32cSSong Gao if (shft_res > mask) { \ 1615162cd32cSSong Gao return mask; \ 1616162cd32cSSong Gao } else { \ 1617162cd32cSSong Gao return shft_res; \ 1618162cd32cSSong Gao } \ 1619162cd32cSSong Gao } 1620162cd32cSSong Gao 1621162cd32cSSong Gao SSRLRNU(B, H, uint16_t, uint8_t, int16_t) 1622162cd32cSSong Gao SSRLRNU(H, W, uint32_t, uint16_t, int32_t) 1623162cd32cSSong Gao SSRLRNU(W, D, uint64_t, uint32_t, int64_t) 1624162cd32cSSong Gao 1625162cd32cSSong Gao #define VSSRLRNU(NAME, BIT, T, E1, E2) \ 162604711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 1627162cd32cSSong Gao { \ 1628162cd32cSSong Gao int i; \ 162904711da1SSong Gao VReg *Vd = (VReg *)vd; \ 163004711da1SSong Gao VReg *Vj = (VReg *)vj; \ 163104711da1SSong Gao VReg *Vk = (VReg *)vk; \ 1632162cd32cSSong Gao \ 1633162cd32cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1634162cd32cSSong Gao Vd->E1(i) = do_ssrlrnu_ ## E1(Vj->E2(i), (T)Vk->E2(i)%BIT, BIT/2); \ 1635162cd32cSSong Gao } \ 1636162cd32cSSong Gao Vd->D(1) = 0; \ 1637162cd32cSSong Gao } 1638162cd32cSSong Gao 1639162cd32cSSong Gao VSSRLRNU(vssrlrn_bu_h, 16, uint16_t, B, H) 1640162cd32cSSong Gao VSSRLRNU(vssrlrn_hu_w, 32, uint32_t, H, W) 1641162cd32cSSong Gao VSSRLRNU(vssrlrn_wu_d, 64, uint64_t, W, D) 1642162cd32cSSong Gao 1643162cd32cSSong Gao #define SSRARNU(E1, E2, T1, T2, T3) \ 1644162cd32cSSong Gao static T1 do_ssrarnu_ ## E1(T3 e2, int sa, int sh) \ 1645162cd32cSSong Gao { \ 1646162cd32cSSong Gao T1 shft_res; \ 1647162cd32cSSong Gao \ 1648162cd32cSSong Gao if (e2 < 0) { \ 1649162cd32cSSong Gao shft_res = 0; \ 1650162cd32cSSong Gao } else { \ 1651162cd32cSSong Gao shft_res = do_vsrar_ ## E2(e2, sa); \ 1652162cd32cSSong Gao } \ 1653162cd32cSSong Gao T2 mask; \ 1654162cd32cSSong Gao mask = (1ull << sh) -1; \ 1655162cd32cSSong Gao if (shft_res > mask) { \ 1656162cd32cSSong Gao return mask; \ 1657162cd32cSSong Gao } else { \ 1658162cd32cSSong Gao return shft_res; \ 1659162cd32cSSong Gao } \ 1660162cd32cSSong Gao } 1661162cd32cSSong Gao 1662162cd32cSSong Gao SSRARNU(B, H, uint16_t, uint8_t, int16_t) 1663162cd32cSSong Gao SSRARNU(H, W, uint32_t, uint16_t, int32_t) 1664162cd32cSSong Gao SSRARNU(W, D, uint64_t, uint32_t, int64_t) 1665162cd32cSSong Gao 1666162cd32cSSong Gao #define VSSRARNU(NAME, BIT, T, E1, E2) \ 166704711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 1668162cd32cSSong Gao { \ 1669162cd32cSSong Gao int i; \ 167004711da1SSong Gao VReg *Vd = (VReg *)vd; \ 167104711da1SSong Gao VReg *Vj = (VReg *)vj; \ 167204711da1SSong Gao VReg *Vk = (VReg *)vk; \ 1673162cd32cSSong Gao \ 1674162cd32cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1675162cd32cSSong Gao Vd->E1(i) = do_ssrarnu_ ## E1(Vj->E2(i), (T)Vk->E2(i)%BIT, BIT/2); \ 1676162cd32cSSong Gao } \ 1677162cd32cSSong Gao Vd->D(1) = 0; \ 1678162cd32cSSong Gao } 1679162cd32cSSong Gao 1680162cd32cSSong Gao VSSRARNU(vssrarn_bu_h, 16, uint16_t, B, H) 1681162cd32cSSong Gao VSSRARNU(vssrarn_hu_w, 32, uint32_t, H, W) 1682162cd32cSSong Gao VSSRARNU(vssrarn_wu_d, 64, uint64_t, W, D) 1683162cd32cSSong Gao 1684162cd32cSSong Gao #define VSSRLRNI(NAME, BIT, E1, E2) \ 1685329517d5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \ 1686162cd32cSSong Gao { \ 1687162cd32cSSong Gao int i; \ 1688162cd32cSSong Gao VReg temp; \ 1689329517d5SSong Gao VReg *Vd = (VReg *)vd; \ 1690329517d5SSong Gao VReg *Vj = (VReg *)vj; \ 1691162cd32cSSong Gao \ 1692162cd32cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1693162cd32cSSong Gao temp.E1(i) = do_ssrlrns_ ## E1(Vj->E2(i), imm, BIT/2 -1); \ 1694162cd32cSSong Gao temp.E1(i + LSX_LEN/BIT) = do_ssrlrns_ ## E1(Vd->E2(i), imm, BIT/2 -1);\ 1695162cd32cSSong Gao } \ 1696162cd32cSSong Gao *Vd = temp; \ 1697162cd32cSSong Gao } 1698162cd32cSSong Gao 1699162cd32cSSong Gao #define VSSRLRNI_Q(NAME, sh) \ 1700329517d5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \ 1701162cd32cSSong Gao { \ 1702162cd32cSSong Gao Int128 shft_res1, shft_res2, mask, r1, r2; \ 1703329517d5SSong Gao VReg *Vd = (VReg *)vd; \ 1704329517d5SSong Gao VReg *Vj = (VReg *)vj; \ 1705162cd32cSSong Gao \ 1706162cd32cSSong Gao if (imm == 0) { \ 1707162cd32cSSong Gao shft_res1 = Vj->Q(0); \ 1708162cd32cSSong Gao shft_res2 = Vd->Q(0); \ 1709162cd32cSSong Gao } else { \ 1710162cd32cSSong Gao r1 = int128_and(int128_urshift(Vj->Q(0), (imm -1)), int128_one()); \ 1711162cd32cSSong Gao r2 = int128_and(int128_urshift(Vd->Q(0), (imm -1)), int128_one()); \ 1712162cd32cSSong Gao \ 1713162cd32cSSong Gao shft_res1 = (int128_add(int128_urshift(Vj->Q(0), imm), r1)); \ 1714162cd32cSSong Gao shft_res2 = (int128_add(int128_urshift(Vd->Q(0), imm), r2)); \ 1715162cd32cSSong Gao } \ 1716162cd32cSSong Gao \ 1717162cd32cSSong Gao mask = int128_sub(int128_lshift(int128_one(), sh), int128_one()); \ 1718162cd32cSSong Gao \ 1719162cd32cSSong Gao if (int128_ult(mask, shft_res1)) { \ 1720162cd32cSSong Gao Vd->D(0) = int128_getlo(mask); \ 1721162cd32cSSong Gao }else { \ 1722162cd32cSSong Gao Vd->D(0) = int128_getlo(shft_res1); \ 1723162cd32cSSong Gao } \ 1724162cd32cSSong Gao \ 1725162cd32cSSong Gao if (int128_ult(mask, shft_res2)) { \ 1726162cd32cSSong Gao Vd->D(1) = int128_getlo(mask); \ 1727162cd32cSSong Gao }else { \ 1728162cd32cSSong Gao Vd->D(1) = int128_getlo(shft_res2); \ 1729162cd32cSSong Gao } \ 1730162cd32cSSong Gao } 1731162cd32cSSong Gao 1732162cd32cSSong Gao VSSRLRNI(vssrlrni_b_h, 16, B, H) 1733162cd32cSSong Gao VSSRLRNI(vssrlrni_h_w, 32, H, W) 1734162cd32cSSong Gao VSSRLRNI(vssrlrni_w_d, 64, W, D) 1735162cd32cSSong Gao VSSRLRNI_Q(vssrlrni_d_q, 63) 1736162cd32cSSong Gao 1737162cd32cSSong Gao #define VSSRARNI(NAME, BIT, E1, E2) \ 1738329517d5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \ 1739162cd32cSSong Gao { \ 1740162cd32cSSong Gao int i; \ 1741162cd32cSSong Gao VReg temp; \ 1742329517d5SSong Gao VReg *Vd = (VReg *)vd; \ 1743329517d5SSong Gao VReg *Vj = (VReg *)vj; \ 1744162cd32cSSong Gao \ 1745162cd32cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1746162cd32cSSong Gao temp.E1(i) = do_ssrarns_ ## E1(Vj->E2(i), imm, BIT/2 -1); \ 1747162cd32cSSong Gao temp.E1(i + LSX_LEN/BIT) = do_ssrarns_ ## E1(Vd->E2(i), imm, BIT/2 -1); \ 1748162cd32cSSong Gao } \ 1749162cd32cSSong Gao *Vd = temp; \ 1750162cd32cSSong Gao } 1751162cd32cSSong Gao 1752329517d5SSong Gao void HELPER(vssrarni_d_q)(void *vd, void *vj, uint64_t imm, uint32_t desc) 1753162cd32cSSong Gao { 1754162cd32cSSong Gao Int128 shft_res1, shft_res2, mask1, mask2, r1, r2; 1755329517d5SSong Gao VReg *Vd = (VReg *)vd; 1756329517d5SSong Gao VReg *Vj = (VReg *)vj; 1757162cd32cSSong Gao 1758162cd32cSSong Gao if (imm == 0) { 1759162cd32cSSong Gao shft_res1 = Vj->Q(0); 1760162cd32cSSong Gao shft_res2 = Vd->Q(0); 1761162cd32cSSong Gao } else { 1762162cd32cSSong Gao r1 = int128_and(int128_rshift(Vj->Q(0), (imm -1)), int128_one()); 1763162cd32cSSong Gao r2 = int128_and(int128_rshift(Vd->Q(0), (imm -1)), int128_one()); 1764162cd32cSSong Gao 1765162cd32cSSong Gao shft_res1 = int128_add(int128_rshift(Vj->Q(0), imm), r1); 1766162cd32cSSong Gao shft_res2 = int128_add(int128_rshift(Vd->Q(0), imm), r2); 1767162cd32cSSong Gao } 1768162cd32cSSong Gao 1769162cd32cSSong Gao mask1 = int128_sub(int128_lshift(int128_one(), 63), int128_one()); 1770162cd32cSSong Gao mask2 = int128_lshift(int128_one(), 63); 1771162cd32cSSong Gao 1772162cd32cSSong Gao if (int128_gt(shft_res1, mask1)) { 1773162cd32cSSong Gao Vd->D(0) = int128_getlo(mask1); 1774162cd32cSSong Gao } else if (int128_lt(shft_res1, int128_neg(mask2))) { 1775162cd32cSSong Gao Vd->D(0) = int128_getlo(mask2); 1776162cd32cSSong Gao } else { 1777162cd32cSSong Gao Vd->D(0) = int128_getlo(shft_res1); 1778162cd32cSSong Gao } 1779162cd32cSSong Gao 1780162cd32cSSong Gao if (int128_gt(shft_res2, mask1)) { 1781162cd32cSSong Gao Vd->D(1) = int128_getlo(mask1); 1782162cd32cSSong Gao } else if (int128_lt(shft_res2, int128_neg(mask2))) { 1783162cd32cSSong Gao Vd->D(1) = int128_getlo(mask2); 1784162cd32cSSong Gao } else { 1785162cd32cSSong Gao Vd->D(1) = int128_getlo(shft_res2); 1786162cd32cSSong Gao } 1787162cd32cSSong Gao } 1788162cd32cSSong Gao 1789162cd32cSSong Gao VSSRARNI(vssrarni_b_h, 16, B, H) 1790162cd32cSSong Gao VSSRARNI(vssrarni_h_w, 32, H, W) 1791162cd32cSSong Gao VSSRARNI(vssrarni_w_d, 64, W, D) 1792162cd32cSSong Gao 1793162cd32cSSong Gao #define VSSRLRNUI(NAME, BIT, E1, E2) \ 1794329517d5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \ 1795162cd32cSSong Gao { \ 1796162cd32cSSong Gao int i; \ 1797162cd32cSSong Gao VReg temp; \ 1798329517d5SSong Gao VReg *Vd = (VReg *)vd; \ 1799329517d5SSong Gao VReg *Vj = (VReg *)vj; \ 1800162cd32cSSong Gao \ 1801162cd32cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1802162cd32cSSong Gao temp.E1(i) = do_ssrlrnu_ ## E1(Vj->E2(i), imm, BIT/2); \ 1803162cd32cSSong Gao temp.E1(i + LSX_LEN/BIT) = do_ssrlrnu_ ## E1(Vd->E2(i), imm, BIT/2); \ 1804162cd32cSSong Gao } \ 1805162cd32cSSong Gao *Vd = temp; \ 1806162cd32cSSong Gao } 1807162cd32cSSong Gao 1808162cd32cSSong Gao VSSRLRNUI(vssrlrni_bu_h, 16, B, H) 1809162cd32cSSong Gao VSSRLRNUI(vssrlrni_hu_w, 32, H, W) 1810162cd32cSSong Gao VSSRLRNUI(vssrlrni_wu_d, 64, W, D) 1811162cd32cSSong Gao VSSRLRNI_Q(vssrlrni_du_q, 64) 1812162cd32cSSong Gao 1813162cd32cSSong Gao #define VSSRARNUI(NAME, BIT, E1, E2) \ 1814329517d5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \ 1815162cd32cSSong Gao { \ 1816162cd32cSSong Gao int i; \ 1817162cd32cSSong Gao VReg temp; \ 1818329517d5SSong Gao VReg *Vd = (VReg *)vd; \ 1819329517d5SSong Gao VReg *Vj = (VReg *)vj; \ 1820162cd32cSSong Gao \ 1821162cd32cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1822162cd32cSSong Gao temp.E1(i) = do_ssrarnu_ ## E1(Vj->E2(i), imm, BIT/2); \ 1823162cd32cSSong Gao temp.E1(i + LSX_LEN/BIT) = do_ssrarnu_ ## E1(Vd->E2(i), imm, BIT/2); \ 1824162cd32cSSong Gao } \ 1825162cd32cSSong Gao *Vd = temp; \ 1826162cd32cSSong Gao } 1827162cd32cSSong Gao 1828329517d5SSong Gao void HELPER(vssrarni_du_q)(void *vd, void *vj, uint64_t imm, uint32_t desc) 1829162cd32cSSong Gao { 1830162cd32cSSong Gao Int128 shft_res1, shft_res2, mask1, mask2, r1, r2; 1831329517d5SSong Gao VReg *Vd = (VReg *)vd; 1832329517d5SSong Gao VReg *Vj = (VReg *)vj; 1833162cd32cSSong Gao 1834162cd32cSSong Gao if (imm == 0) { 1835162cd32cSSong Gao shft_res1 = Vj->Q(0); 1836162cd32cSSong Gao shft_res2 = Vd->Q(0); 1837162cd32cSSong Gao } else { 1838162cd32cSSong Gao r1 = int128_and(int128_rshift(Vj->Q(0), (imm -1)), int128_one()); 1839162cd32cSSong Gao r2 = int128_and(int128_rshift(Vd->Q(0), (imm -1)), int128_one()); 1840162cd32cSSong Gao 1841162cd32cSSong Gao shft_res1 = int128_add(int128_rshift(Vj->Q(0), imm), r1); 1842162cd32cSSong Gao shft_res2 = int128_add(int128_rshift(Vd->Q(0), imm), r2); 1843162cd32cSSong Gao } 1844162cd32cSSong Gao 1845162cd32cSSong Gao if (int128_lt(Vj->Q(0), int128_zero())) { 1846162cd32cSSong Gao shft_res1 = int128_zero(); 1847162cd32cSSong Gao } 1848162cd32cSSong Gao if (int128_lt(Vd->Q(0), int128_zero())) { 1849162cd32cSSong Gao shft_res2 = int128_zero(); 1850162cd32cSSong Gao } 1851162cd32cSSong Gao 1852162cd32cSSong Gao mask1 = int128_sub(int128_lshift(int128_one(), 64), int128_one()); 1853162cd32cSSong Gao mask2 = int128_lshift(int128_one(), 64); 1854162cd32cSSong Gao 1855162cd32cSSong Gao if (int128_gt(shft_res1, mask1)) { 1856162cd32cSSong Gao Vd->D(0) = int128_getlo(mask1); 1857162cd32cSSong Gao } else if (int128_lt(shft_res1, int128_neg(mask2))) { 1858162cd32cSSong Gao Vd->D(0) = int128_getlo(mask2); 1859162cd32cSSong Gao } else { 1860162cd32cSSong Gao Vd->D(0) = int128_getlo(shft_res1); 1861162cd32cSSong Gao } 1862162cd32cSSong Gao 1863162cd32cSSong Gao if (int128_gt(shft_res2, mask1)) { 1864162cd32cSSong Gao Vd->D(1) = int128_getlo(mask1); 1865162cd32cSSong Gao } else if (int128_lt(shft_res2, int128_neg(mask2))) { 1866162cd32cSSong Gao Vd->D(1) = int128_getlo(mask2); 1867162cd32cSSong Gao } else { 1868162cd32cSSong Gao Vd->D(1) = int128_getlo(shft_res2); 1869162cd32cSSong Gao } 1870162cd32cSSong Gao } 1871162cd32cSSong Gao 1872162cd32cSSong Gao VSSRARNUI(vssrarni_bu_h, 16, B, H) 1873162cd32cSSong Gao VSSRARNUI(vssrarni_hu_w, 32, H, W) 1874162cd32cSSong Gao VSSRARNUI(vssrarni_wu_d, 64, W, D) 18752e105e12SSong Gao 18762e105e12SSong Gao #define DO_2OP(NAME, BIT, E, DO_OP) \ 1877ff27e335SSong Gao void HELPER(NAME)(void *vd, void *vj, uint32_t desc) \ 18782e105e12SSong Gao { \ 18792e105e12SSong Gao int i; \ 1880ff27e335SSong Gao VReg *Vd = (VReg *)vd; \ 1881ff27e335SSong Gao VReg *Vj = (VReg *)vj; \ 18822e105e12SSong Gao \ 18832e105e12SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) \ 18842e105e12SSong Gao { \ 18852e105e12SSong Gao Vd->E(i) = DO_OP(Vj->E(i)); \ 18862e105e12SSong Gao } \ 18872e105e12SSong Gao } 18882e105e12SSong Gao 18892e105e12SSong Gao #define DO_CLO_B(N) (clz32(~N & 0xff) - 24) 18902e105e12SSong Gao #define DO_CLO_H(N) (clz32(~N & 0xffff) - 16) 18912e105e12SSong Gao #define DO_CLO_W(N) (clz32(~N)) 18922e105e12SSong Gao #define DO_CLO_D(N) (clz64(~N)) 18932e105e12SSong Gao #define DO_CLZ_B(N) (clz32(N) - 24) 18942e105e12SSong Gao #define DO_CLZ_H(N) (clz32(N) - 16) 18952e105e12SSong Gao #define DO_CLZ_W(N) (clz32(N)) 18962e105e12SSong Gao #define DO_CLZ_D(N) (clz64(N)) 18972e105e12SSong Gao 18982e105e12SSong Gao DO_2OP(vclo_b, 8, UB, DO_CLO_B) 18992e105e12SSong Gao DO_2OP(vclo_h, 16, UH, DO_CLO_H) 19002e105e12SSong Gao DO_2OP(vclo_w, 32, UW, DO_CLO_W) 19012e105e12SSong Gao DO_2OP(vclo_d, 64, UD, DO_CLO_D) 19022e105e12SSong Gao DO_2OP(vclz_b, 8, UB, DO_CLZ_B) 19032e105e12SSong Gao DO_2OP(vclz_h, 16, UH, DO_CLZ_H) 19042e105e12SSong Gao DO_2OP(vclz_w, 32, UW, DO_CLZ_W) 19052e105e12SSong Gao DO_2OP(vclz_d, 64, UD, DO_CLZ_D) 1906bb22ee57SSong Gao 1907bb22ee57SSong Gao #define VPCNT(NAME, BIT, E, FN) \ 1908ff27e335SSong Gao void HELPER(NAME)(void *vd, void *vj, uint32_t desc) \ 1909bb22ee57SSong Gao { \ 1910bb22ee57SSong Gao int i; \ 1911ff27e335SSong Gao VReg *Vd = (VReg *)vd; \ 1912ff27e335SSong Gao VReg *Vj = (VReg *)vj; \ 1913bb22ee57SSong Gao \ 1914bb22ee57SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) \ 1915bb22ee57SSong Gao { \ 1916bb22ee57SSong Gao Vd->E(i) = FN(Vj->E(i)); \ 1917bb22ee57SSong Gao } \ 1918bb22ee57SSong Gao } 1919bb22ee57SSong Gao 1920bb22ee57SSong Gao VPCNT(vpcnt_b, 8, UB, ctpop8) 1921bb22ee57SSong Gao VPCNT(vpcnt_h, 16, UH, ctpop16) 1922bb22ee57SSong Gao VPCNT(vpcnt_w, 32, UW, ctpop32) 1923bb22ee57SSong Gao VPCNT(vpcnt_d, 64, UD, ctpop64) 19240b1e6705SSong Gao 19250b1e6705SSong Gao #define DO_BITCLR(a, bit) (a & ~(1ull << bit)) 19260b1e6705SSong Gao #define DO_BITSET(a, bit) (a | 1ull << bit) 19270b1e6705SSong Gao #define DO_BITREV(a, bit) (a ^ (1ull << bit)) 19280b1e6705SSong Gao 19290b1e6705SSong Gao #define DO_BIT(NAME, BIT, E, DO_OP) \ 19300b1e6705SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t v) \ 19310b1e6705SSong Gao { \ 19320b1e6705SSong Gao int i; \ 19330b1e6705SSong Gao VReg *Vd = (VReg *)vd; \ 19340b1e6705SSong Gao VReg *Vj = (VReg *)vj; \ 19350b1e6705SSong Gao VReg *Vk = (VReg *)vk; \ 19360b1e6705SSong Gao \ 19370b1e6705SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 19380b1e6705SSong Gao Vd->E(i) = DO_OP(Vj->E(i), Vk->E(i)%BIT); \ 19390b1e6705SSong Gao } \ 19400b1e6705SSong Gao } 19410b1e6705SSong Gao 19420b1e6705SSong Gao DO_BIT(vbitclr_b, 8, UB, DO_BITCLR) 19430b1e6705SSong Gao DO_BIT(vbitclr_h, 16, UH, DO_BITCLR) 19440b1e6705SSong Gao DO_BIT(vbitclr_w, 32, UW, DO_BITCLR) 19450b1e6705SSong Gao DO_BIT(vbitclr_d, 64, UD, DO_BITCLR) 19460b1e6705SSong Gao DO_BIT(vbitset_b, 8, UB, DO_BITSET) 19470b1e6705SSong Gao DO_BIT(vbitset_h, 16, UH, DO_BITSET) 19480b1e6705SSong Gao DO_BIT(vbitset_w, 32, UW, DO_BITSET) 19490b1e6705SSong Gao DO_BIT(vbitset_d, 64, UD, DO_BITSET) 19500b1e6705SSong Gao DO_BIT(vbitrev_b, 8, UB, DO_BITREV) 19510b1e6705SSong Gao DO_BIT(vbitrev_h, 16, UH, DO_BITREV) 19520b1e6705SSong Gao DO_BIT(vbitrev_w, 32, UW, DO_BITREV) 19530b1e6705SSong Gao DO_BIT(vbitrev_d, 64, UD, DO_BITREV) 19540b1e6705SSong Gao 19550b1e6705SSong Gao #define DO_BITI(NAME, BIT, E, DO_OP) \ 19560b1e6705SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t v) \ 19570b1e6705SSong Gao { \ 19580b1e6705SSong Gao int i; \ 19590b1e6705SSong Gao VReg *Vd = (VReg *)vd; \ 19600b1e6705SSong Gao VReg *Vj = (VReg *)vj; \ 19610b1e6705SSong Gao \ 19620b1e6705SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 19630b1e6705SSong Gao Vd->E(i) = DO_OP(Vj->E(i), imm); \ 19640b1e6705SSong Gao } \ 19650b1e6705SSong Gao } 19660b1e6705SSong Gao 19670b1e6705SSong Gao DO_BITI(vbitclri_b, 8, UB, DO_BITCLR) 19680b1e6705SSong Gao DO_BITI(vbitclri_h, 16, UH, DO_BITCLR) 19690b1e6705SSong Gao DO_BITI(vbitclri_w, 32, UW, DO_BITCLR) 19700b1e6705SSong Gao DO_BITI(vbitclri_d, 64, UD, DO_BITCLR) 19710b1e6705SSong Gao DO_BITI(vbitseti_b, 8, UB, DO_BITSET) 19720b1e6705SSong Gao DO_BITI(vbitseti_h, 16, UH, DO_BITSET) 19730b1e6705SSong Gao DO_BITI(vbitseti_w, 32, UW, DO_BITSET) 19740b1e6705SSong Gao DO_BITI(vbitseti_d, 64, UD, DO_BITSET) 19750b1e6705SSong Gao DO_BITI(vbitrevi_b, 8, UB, DO_BITREV) 19760b1e6705SSong Gao DO_BITI(vbitrevi_h, 16, UH, DO_BITREV) 19770b1e6705SSong Gao DO_BITI(vbitrevi_w, 32, UW, DO_BITREV) 19780b1e6705SSong Gao DO_BITI(vbitrevi_d, 64, UD, DO_BITREV) 1979ac95a0b9SSong Gao 1980ac95a0b9SSong Gao #define VFRSTP(NAME, BIT, MASK, E) \ 198104711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 1982ac95a0b9SSong Gao { \ 1983ac95a0b9SSong Gao int i, m; \ 198404711da1SSong Gao VReg *Vd = (VReg *)vd; \ 198504711da1SSong Gao VReg *Vj = (VReg *)vj; \ 198604711da1SSong Gao VReg *Vk = (VReg *)vk; \ 1987ac95a0b9SSong Gao \ 1988ac95a0b9SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 1989ac95a0b9SSong Gao if (Vj->E(i) < 0) { \ 1990ac95a0b9SSong Gao break; \ 1991ac95a0b9SSong Gao } \ 1992ac95a0b9SSong Gao } \ 1993ac95a0b9SSong Gao m = Vk->E(0) & MASK; \ 1994ac95a0b9SSong Gao Vd->E(m) = i; \ 1995ac95a0b9SSong Gao } 1996ac95a0b9SSong Gao 1997ac95a0b9SSong Gao VFRSTP(vfrstp_b, 8, 0xf, B) 1998ac95a0b9SSong Gao VFRSTP(vfrstp_h, 16, 0x7, H) 1999ac95a0b9SSong Gao 2000ac95a0b9SSong Gao #define VFRSTPI(NAME, BIT, E) \ 2001329517d5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \ 2002ac95a0b9SSong Gao { \ 2003ac95a0b9SSong Gao int i, m; \ 2004329517d5SSong Gao VReg *Vd = (VReg *)vd; \ 2005329517d5SSong Gao VReg *Vj = (VReg *)vj; \ 2006ac95a0b9SSong Gao \ 2007ac95a0b9SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2008ac95a0b9SSong Gao if (Vj->E(i) < 0) { \ 2009ac95a0b9SSong Gao break; \ 2010ac95a0b9SSong Gao } \ 2011ac95a0b9SSong Gao } \ 2012ac95a0b9SSong Gao m = imm % (LSX_LEN/BIT); \ 2013ac95a0b9SSong Gao Vd->E(m) = i; \ 2014ac95a0b9SSong Gao } 2015ac95a0b9SSong Gao 2016ac95a0b9SSong Gao VFRSTPI(vfrstpi_b, 8, B) 2017ac95a0b9SSong Gao VFRSTPI(vfrstpi_h, 16, H) 2018aca67472SSong Gao 2019aca67472SSong Gao static void vec_update_fcsr0_mask(CPULoongArchState *env, 2020aca67472SSong Gao uintptr_t pc, int mask) 2021aca67472SSong Gao { 2022aca67472SSong Gao int flags = get_float_exception_flags(&env->fp_status); 2023aca67472SSong Gao 2024aca67472SSong Gao set_float_exception_flags(0, &env->fp_status); 2025aca67472SSong Gao 2026aca67472SSong Gao flags &= ~mask; 2027aca67472SSong Gao 2028aca67472SSong Gao if (flags) { 2029aca67472SSong Gao flags = ieee_ex_to_loongarch(flags); 2030aca67472SSong Gao UPDATE_FP_CAUSE(env->fcsr0, flags); 2031aca67472SSong Gao } 2032aca67472SSong Gao 2033aca67472SSong Gao if (GET_FP_ENABLES(env->fcsr0) & flags) { 2034aca67472SSong Gao do_raise_exception(env, EXCCODE_FPE, pc); 2035aca67472SSong Gao } else { 2036aca67472SSong Gao UPDATE_FP_FLAGS(env->fcsr0, flags); 2037aca67472SSong Gao } 2038aca67472SSong Gao } 2039aca67472SSong Gao 2040aca67472SSong Gao static void vec_update_fcsr0(CPULoongArchState *env, uintptr_t pc) 2041aca67472SSong Gao { 2042aca67472SSong Gao vec_update_fcsr0_mask(env, pc, 0); 2043aca67472SSong Gao } 2044aca67472SSong Gao 2045aca67472SSong Gao static inline void vec_clear_cause(CPULoongArchState *env) 2046aca67472SSong Gao { 2047aca67472SSong Gao SET_FP_CAUSE(env->fcsr0, 0); 2048aca67472SSong Gao } 2049aca67472SSong Gao 2050aca67472SSong Gao #define DO_3OP_F(NAME, BIT, E, FN) \ 20513b286753SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, \ 20523b286753SSong Gao CPULoongArchState *env, uint32_t desc) \ 2053aca67472SSong Gao { \ 2054aca67472SSong Gao int i; \ 20553b286753SSong Gao VReg *Vd = (VReg *)vd; \ 20563b286753SSong Gao VReg *Vj = (VReg *)vj; \ 20573b286753SSong Gao VReg *Vk = (VReg *)vk; \ 2058aca67472SSong Gao \ 2059aca67472SSong Gao vec_clear_cause(env); \ 2060aca67472SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2061aca67472SSong Gao Vd->E(i) = FN(Vj->E(i), Vk->E(i), &env->fp_status); \ 2062aca67472SSong Gao vec_update_fcsr0(env, GETPC()); \ 2063aca67472SSong Gao } \ 2064aca67472SSong Gao } 2065aca67472SSong Gao 2066aca67472SSong Gao DO_3OP_F(vfadd_s, 32, UW, float32_add) 2067aca67472SSong Gao DO_3OP_F(vfadd_d, 64, UD, float64_add) 2068aca67472SSong Gao DO_3OP_F(vfsub_s, 32, UW, float32_sub) 2069aca67472SSong Gao DO_3OP_F(vfsub_d, 64, UD, float64_sub) 2070aca67472SSong Gao DO_3OP_F(vfmul_s, 32, UW, float32_mul) 2071aca67472SSong Gao DO_3OP_F(vfmul_d, 64, UD, float64_mul) 2072aca67472SSong Gao DO_3OP_F(vfdiv_s, 32, UW, float32_div) 2073aca67472SSong Gao DO_3OP_F(vfdiv_d, 64, UD, float64_div) 2074aca67472SSong Gao DO_3OP_F(vfmax_s, 32, UW, float32_maxnum) 2075aca67472SSong Gao DO_3OP_F(vfmax_d, 64, UD, float64_maxnum) 2076aca67472SSong Gao DO_3OP_F(vfmin_s, 32, UW, float32_minnum) 2077aca67472SSong Gao DO_3OP_F(vfmin_d, 64, UD, float64_minnum) 2078aca67472SSong Gao DO_3OP_F(vfmaxa_s, 32, UW, float32_maxnummag) 2079aca67472SSong Gao DO_3OP_F(vfmaxa_d, 64, UD, float64_maxnummag) 2080aca67472SSong Gao DO_3OP_F(vfmina_s, 32, UW, float32_minnummag) 2081aca67472SSong Gao DO_3OP_F(vfmina_d, 64, UD, float64_minnummag) 2082aca67472SSong Gao 2083aca67472SSong Gao #define DO_4OP_F(NAME, BIT, E, FN, flags) \ 2084e2600dadSSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, void *va, \ 2085e2600dadSSong Gao CPULoongArchState *env, uint32_t desc) \ 2086aca67472SSong Gao { \ 2087aca67472SSong Gao int i; \ 2088e2600dadSSong Gao VReg *Vd = (VReg *)vd; \ 2089e2600dadSSong Gao VReg *Vj = (VReg *)vj; \ 2090e2600dadSSong Gao VReg *Vk = (VReg *)vk; \ 2091e2600dadSSong Gao VReg *Va = (VReg *)va; \ 2092aca67472SSong Gao \ 2093aca67472SSong Gao vec_clear_cause(env); \ 2094aca67472SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2095aca67472SSong Gao Vd->E(i) = FN(Vj->E(i), Vk->E(i), Va->E(i), flags, &env->fp_status); \ 2096aca67472SSong Gao vec_update_fcsr0(env, GETPC()); \ 2097aca67472SSong Gao } \ 2098aca67472SSong Gao } 2099aca67472SSong Gao 2100aca67472SSong Gao DO_4OP_F(vfmadd_s, 32, UW, float32_muladd, 0) 2101aca67472SSong Gao DO_4OP_F(vfmadd_d, 64, UD, float64_muladd, 0) 2102aca67472SSong Gao DO_4OP_F(vfmsub_s, 32, UW, float32_muladd, float_muladd_negate_c) 2103aca67472SSong Gao DO_4OP_F(vfmsub_d, 64, UD, float64_muladd, float_muladd_negate_c) 2104aca67472SSong Gao DO_4OP_F(vfnmadd_s, 32, UW, float32_muladd, float_muladd_negate_result) 2105aca67472SSong Gao DO_4OP_F(vfnmadd_d, 64, UD, float64_muladd, float_muladd_negate_result) 2106aca67472SSong Gao DO_4OP_F(vfnmsub_s, 32, UW, float32_muladd, 2107aca67472SSong Gao float_muladd_negate_c | float_muladd_negate_result) 2108aca67472SSong Gao DO_4OP_F(vfnmsub_d, 64, UD, float64_muladd, 2109aca67472SSong Gao float_muladd_negate_c | float_muladd_negate_result) 2110aca67472SSong Gao 2111aca67472SSong Gao #define DO_2OP_F(NAME, BIT, E, FN) \ 2112226bf881SSong Gao void HELPER(NAME)(void *vd, void *vj, \ 2113226bf881SSong Gao CPULoongArchState *env, uint32_t desc) \ 2114aca67472SSong Gao { \ 2115aca67472SSong Gao int i; \ 2116226bf881SSong Gao VReg *Vd = (VReg *)vd; \ 2117226bf881SSong Gao VReg *Vj = (VReg *)vj; \ 2118aca67472SSong Gao \ 2119aca67472SSong Gao vec_clear_cause(env); \ 2120aca67472SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2121aca67472SSong Gao Vd->E(i) = FN(env, Vj->E(i)); \ 2122aca67472SSong Gao } \ 2123aca67472SSong Gao } 2124aca67472SSong Gao 2125aca67472SSong Gao #define FLOGB(BIT, T) \ 2126aca67472SSong Gao static T do_flogb_## BIT(CPULoongArchState *env, T fj) \ 2127aca67472SSong Gao { \ 2128aca67472SSong Gao T fp, fd; \ 2129aca67472SSong Gao float_status *status = &env->fp_status; \ 2130aca67472SSong Gao FloatRoundMode old_mode = get_float_rounding_mode(status); \ 2131aca67472SSong Gao \ 2132aca67472SSong Gao set_float_rounding_mode(float_round_down, status); \ 2133aca67472SSong Gao fp = float ## BIT ##_log2(fj, status); \ 2134aca67472SSong Gao fd = float ## BIT ##_round_to_int(fp, status); \ 2135aca67472SSong Gao set_float_rounding_mode(old_mode, status); \ 2136aca67472SSong Gao vec_update_fcsr0_mask(env, GETPC(), float_flag_inexact); \ 2137aca67472SSong Gao return fd; \ 2138aca67472SSong Gao } 2139aca67472SSong Gao 2140aca67472SSong Gao FLOGB(32, uint32_t) 2141aca67472SSong Gao FLOGB(64, uint64_t) 2142aca67472SSong Gao 2143aca67472SSong Gao #define FCLASS(NAME, BIT, E, FN) \ 2144226bf881SSong Gao void HELPER(NAME)(void *vd, void *vj, \ 2145226bf881SSong Gao CPULoongArchState *env, uint32_t desc) \ 2146aca67472SSong Gao { \ 2147aca67472SSong Gao int i; \ 2148226bf881SSong Gao VReg *Vd = (VReg *)vd; \ 2149226bf881SSong Gao VReg *Vj = (VReg *)vj; \ 2150aca67472SSong Gao \ 2151aca67472SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2152aca67472SSong Gao Vd->E(i) = FN(env, Vj->E(i)); \ 2153aca67472SSong Gao } \ 2154aca67472SSong Gao } 2155aca67472SSong Gao 2156aca67472SSong Gao FCLASS(vfclass_s, 32, UW, helper_fclass_s) 2157aca67472SSong Gao FCLASS(vfclass_d, 64, UD, helper_fclass_d) 2158aca67472SSong Gao 2159aca67472SSong Gao #define FSQRT(BIT, T) \ 2160aca67472SSong Gao static T do_fsqrt_## BIT(CPULoongArchState *env, T fj) \ 2161aca67472SSong Gao { \ 2162aca67472SSong Gao T fd; \ 2163aca67472SSong Gao fd = float ## BIT ##_sqrt(fj, &env->fp_status); \ 2164aca67472SSong Gao vec_update_fcsr0(env, GETPC()); \ 2165aca67472SSong Gao return fd; \ 2166aca67472SSong Gao } 2167aca67472SSong Gao 2168aca67472SSong Gao FSQRT(32, uint32_t) 2169aca67472SSong Gao FSQRT(64, uint64_t) 2170aca67472SSong Gao 2171aca67472SSong Gao #define FRECIP(BIT, T) \ 2172aca67472SSong Gao static T do_frecip_## BIT(CPULoongArchState *env, T fj) \ 2173aca67472SSong Gao { \ 2174aca67472SSong Gao T fd; \ 2175aca67472SSong Gao fd = float ## BIT ##_div(float ## BIT ##_one, fj, &env->fp_status); \ 2176aca67472SSong Gao vec_update_fcsr0(env, GETPC()); \ 2177aca67472SSong Gao return fd; \ 2178aca67472SSong Gao } 2179aca67472SSong Gao 2180aca67472SSong Gao FRECIP(32, uint32_t) 2181aca67472SSong Gao FRECIP(64, uint64_t) 2182aca67472SSong Gao 2183aca67472SSong Gao #define FRSQRT(BIT, T) \ 2184aca67472SSong Gao static T do_frsqrt_## BIT(CPULoongArchState *env, T fj) \ 2185aca67472SSong Gao { \ 2186aca67472SSong Gao T fd, fp; \ 2187aca67472SSong Gao fp = float ## BIT ##_sqrt(fj, &env->fp_status); \ 2188aca67472SSong Gao fd = float ## BIT ##_div(float ## BIT ##_one, fp, &env->fp_status); \ 2189aca67472SSong Gao vec_update_fcsr0(env, GETPC()); \ 2190aca67472SSong Gao return fd; \ 2191aca67472SSong Gao } 2192aca67472SSong Gao 2193aca67472SSong Gao FRSQRT(32, uint32_t) 2194aca67472SSong Gao FRSQRT(64, uint64_t) 2195aca67472SSong Gao 2196aca67472SSong Gao DO_2OP_F(vflogb_s, 32, UW, do_flogb_32) 2197aca67472SSong Gao DO_2OP_F(vflogb_d, 64, UD, do_flogb_64) 2198aca67472SSong Gao DO_2OP_F(vfsqrt_s, 32, UW, do_fsqrt_32) 2199aca67472SSong Gao DO_2OP_F(vfsqrt_d, 64, UD, do_fsqrt_64) 2200aca67472SSong Gao DO_2OP_F(vfrecip_s, 32, UW, do_frecip_32) 2201aca67472SSong Gao DO_2OP_F(vfrecip_d, 64, UD, do_frecip_64) 2202aca67472SSong Gao DO_2OP_F(vfrsqrt_s, 32, UW, do_frsqrt_32) 2203aca67472SSong Gao DO_2OP_F(vfrsqrt_d, 64, UD, do_frsqrt_64) 2204399665d2SSong Gao 2205399665d2SSong Gao static uint32_t float16_cvt_float32(uint16_t h, float_status *status) 2206399665d2SSong Gao { 2207399665d2SSong Gao return float16_to_float32(h, true, status); 2208399665d2SSong Gao } 2209399665d2SSong Gao static uint64_t float32_cvt_float64(uint32_t s, float_status *status) 2210399665d2SSong Gao { 2211399665d2SSong Gao return float32_to_float64(s, status); 2212399665d2SSong Gao } 2213399665d2SSong Gao 2214399665d2SSong Gao static uint16_t float32_cvt_float16(uint32_t s, float_status *status) 2215399665d2SSong Gao { 2216399665d2SSong Gao return float32_to_float16(s, true, status); 2217399665d2SSong Gao } 2218399665d2SSong Gao static uint32_t float64_cvt_float32(uint64_t d, float_status *status) 2219399665d2SSong Gao { 2220399665d2SSong Gao return float64_to_float32(d, status); 2221399665d2SSong Gao } 2222399665d2SSong Gao 2223226bf881SSong Gao void HELPER(vfcvtl_s_h)(void *vd, void *vj, 2224226bf881SSong Gao CPULoongArchState *env, uint32_t desc) 2225399665d2SSong Gao { 2226399665d2SSong Gao int i; 2227399665d2SSong Gao VReg temp; 2228226bf881SSong Gao VReg *Vd = (VReg *)vd; 2229226bf881SSong Gao VReg *Vj = (VReg *)vj; 2230399665d2SSong Gao 2231399665d2SSong Gao vec_clear_cause(env); 2232399665d2SSong Gao for (i = 0; i < LSX_LEN/32; i++) { 2233399665d2SSong Gao temp.UW(i) = float16_cvt_float32(Vj->UH(i), &env->fp_status); 2234399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2235399665d2SSong Gao } 2236399665d2SSong Gao *Vd = temp; 2237399665d2SSong Gao } 2238399665d2SSong Gao 2239226bf881SSong Gao void HELPER(vfcvtl_d_s)(void *vd, void *vj, 2240226bf881SSong Gao CPULoongArchState *env, uint32_t desc) 2241399665d2SSong Gao { 2242399665d2SSong Gao int i; 2243399665d2SSong Gao VReg temp; 2244226bf881SSong Gao VReg *Vd = (VReg *)vd; 2245226bf881SSong Gao VReg *Vj = (VReg *)vj; 2246399665d2SSong Gao 2247399665d2SSong Gao vec_clear_cause(env); 2248399665d2SSong Gao for (i = 0; i < LSX_LEN/64; i++) { 2249399665d2SSong Gao temp.UD(i) = float32_cvt_float64(Vj->UW(i), &env->fp_status); 2250399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2251399665d2SSong Gao } 2252399665d2SSong Gao *Vd = temp; 2253399665d2SSong Gao } 2254399665d2SSong Gao 2255226bf881SSong Gao void HELPER(vfcvth_s_h)(void *vd, void *vj, 2256226bf881SSong Gao CPULoongArchState *env, uint32_t desc) 2257399665d2SSong Gao { 2258399665d2SSong Gao int i; 2259399665d2SSong Gao VReg temp; 2260226bf881SSong Gao VReg *Vd = (VReg *)vd; 2261226bf881SSong Gao VReg *Vj = (VReg *)vj; 2262399665d2SSong Gao 2263399665d2SSong Gao vec_clear_cause(env); 2264399665d2SSong Gao for (i = 0; i < LSX_LEN/32; i++) { 2265399665d2SSong Gao temp.UW(i) = float16_cvt_float32(Vj->UH(i + 4), &env->fp_status); 2266399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2267399665d2SSong Gao } 2268399665d2SSong Gao *Vd = temp; 2269399665d2SSong Gao } 2270399665d2SSong Gao 2271226bf881SSong Gao void HELPER(vfcvth_d_s)(void *vd, void *vj, 2272226bf881SSong Gao CPULoongArchState *env, uint32_t desc) 2273399665d2SSong Gao { 2274399665d2SSong Gao int i; 2275399665d2SSong Gao VReg temp; 2276226bf881SSong Gao VReg *Vd = (VReg *)vd; 2277226bf881SSong Gao VReg *Vj = (VReg *)vj; 2278399665d2SSong Gao 2279399665d2SSong Gao vec_clear_cause(env); 2280399665d2SSong Gao for (i = 0; i < LSX_LEN/64; i++) { 2281399665d2SSong Gao temp.UD(i) = float32_cvt_float64(Vj->UW(i + 2), &env->fp_status); 2282399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2283399665d2SSong Gao } 2284399665d2SSong Gao *Vd = temp; 2285399665d2SSong Gao } 2286399665d2SSong Gao 22873b286753SSong Gao void HELPER(vfcvt_h_s)(void *vd, void *vj, void *vk, 22883b286753SSong Gao CPULoongArchState *env, uint32_t desc) 2289399665d2SSong Gao { 2290399665d2SSong Gao int i; 2291399665d2SSong Gao VReg temp; 22923b286753SSong Gao VReg *Vd = (VReg *)vd; 22933b286753SSong Gao VReg *Vj = (VReg *)vj; 22943b286753SSong Gao VReg *Vk = (VReg *)vk; 2295399665d2SSong Gao 2296399665d2SSong Gao vec_clear_cause(env); 2297399665d2SSong Gao for(i = 0; i < LSX_LEN/32; i++) { 2298399665d2SSong Gao temp.UH(i + 4) = float32_cvt_float16(Vj->UW(i), &env->fp_status); 2299399665d2SSong Gao temp.UH(i) = float32_cvt_float16(Vk->UW(i), &env->fp_status); 2300399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2301399665d2SSong Gao } 2302399665d2SSong Gao *Vd = temp; 2303399665d2SSong Gao } 2304399665d2SSong Gao 23053b286753SSong Gao void HELPER(vfcvt_s_d)(void *vd, void *vj, void *vk, 23063b286753SSong Gao CPULoongArchState *env, uint32_t desc) 2307399665d2SSong Gao { 2308399665d2SSong Gao int i; 2309399665d2SSong Gao VReg temp; 23103b286753SSong Gao VReg *Vd = (VReg *)vd; 23113b286753SSong Gao VReg *Vj = (VReg *)vj; 23123b286753SSong Gao VReg *Vk = (VReg *)vk; 2313399665d2SSong Gao 2314399665d2SSong Gao vec_clear_cause(env); 2315399665d2SSong Gao for(i = 0; i < LSX_LEN/64; i++) { 2316399665d2SSong Gao temp.UW(i + 2) = float64_cvt_float32(Vj->UD(i), &env->fp_status); 2317399665d2SSong Gao temp.UW(i) = float64_cvt_float32(Vk->UD(i), &env->fp_status); 2318399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2319399665d2SSong Gao } 2320399665d2SSong Gao *Vd = temp; 2321399665d2SSong Gao } 2322399665d2SSong Gao 2323226bf881SSong Gao void HELPER(vfrint_s)(void *vd, void *vj, 2324226bf881SSong Gao CPULoongArchState *env, uint32_t desc) 2325399665d2SSong Gao { 2326399665d2SSong Gao int i; 2327226bf881SSong Gao VReg *Vd = (VReg *)vd; 2328226bf881SSong Gao VReg *Vj = (VReg *)vj; 2329399665d2SSong Gao 2330399665d2SSong Gao vec_clear_cause(env); 2331399665d2SSong Gao for (i = 0; i < 4; i++) { 2332399665d2SSong Gao Vd->W(i) = float32_round_to_int(Vj->UW(i), &env->fp_status); 2333399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2334399665d2SSong Gao } 2335399665d2SSong Gao } 2336399665d2SSong Gao 2337226bf881SSong Gao void HELPER(vfrint_d)(void *vd, void *vj, 2338226bf881SSong Gao CPULoongArchState *env, uint32_t desc) 2339399665d2SSong Gao { 2340399665d2SSong Gao int i; 2341226bf881SSong Gao VReg *Vd = (VReg *)vd; 2342226bf881SSong Gao VReg *Vj = (VReg *)vj; 2343399665d2SSong Gao 2344399665d2SSong Gao vec_clear_cause(env); 2345399665d2SSong Gao for (i = 0; i < 2; i++) { 2346399665d2SSong Gao Vd->D(i) = float64_round_to_int(Vj->UD(i), &env->fp_status); 2347399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2348399665d2SSong Gao } 2349399665d2SSong Gao } 2350399665d2SSong Gao 2351399665d2SSong Gao #define FCVT_2OP(NAME, BIT, E, MODE) \ 2352226bf881SSong Gao void HELPER(NAME)(void *vd, void *vj, \ 2353226bf881SSong Gao CPULoongArchState *env, uint32_t desc) \ 2354399665d2SSong Gao { \ 2355399665d2SSong Gao int i; \ 2356226bf881SSong Gao VReg *Vd = (VReg *)vd; \ 2357226bf881SSong Gao VReg *Vj = (VReg *)vj; \ 2358399665d2SSong Gao \ 2359399665d2SSong Gao vec_clear_cause(env); \ 2360399665d2SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2361399665d2SSong Gao FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); \ 2362399665d2SSong Gao set_float_rounding_mode(MODE, &env->fp_status); \ 2363399665d2SSong Gao Vd->E(i) = float## BIT ## _round_to_int(Vj->E(i), &env->fp_status); \ 2364399665d2SSong Gao set_float_rounding_mode(old_mode, &env->fp_status); \ 2365399665d2SSong Gao vec_update_fcsr0(env, GETPC()); \ 2366399665d2SSong Gao } \ 2367399665d2SSong Gao } 2368399665d2SSong Gao 2369399665d2SSong Gao FCVT_2OP(vfrintrne_s, 32, UW, float_round_nearest_even) 2370399665d2SSong Gao FCVT_2OP(vfrintrne_d, 64, UD, float_round_nearest_even) 2371399665d2SSong Gao FCVT_2OP(vfrintrz_s, 32, UW, float_round_to_zero) 2372399665d2SSong Gao FCVT_2OP(vfrintrz_d, 64, UD, float_round_to_zero) 2373399665d2SSong Gao FCVT_2OP(vfrintrp_s, 32, UW, float_round_up) 2374399665d2SSong Gao FCVT_2OP(vfrintrp_d, 64, UD, float_round_up) 2375399665d2SSong Gao FCVT_2OP(vfrintrm_s, 32, UW, float_round_down) 2376399665d2SSong Gao FCVT_2OP(vfrintrm_d, 64, UD, float_round_down) 2377399665d2SSong Gao 2378399665d2SSong Gao #define FTINT(NAME, FMT1, FMT2, T1, T2, MODE) \ 2379399665d2SSong Gao static T2 do_ftint ## NAME(CPULoongArchState *env, T1 fj) \ 2380399665d2SSong Gao { \ 2381399665d2SSong Gao T2 fd; \ 2382399665d2SSong Gao FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); \ 2383399665d2SSong Gao \ 2384399665d2SSong Gao set_float_rounding_mode(MODE, &env->fp_status); \ 2385399665d2SSong Gao fd = do_## FMT1 ##_to_## FMT2(env, fj); \ 2386399665d2SSong Gao set_float_rounding_mode(old_mode, &env->fp_status); \ 2387399665d2SSong Gao return fd; \ 2388399665d2SSong Gao } 2389399665d2SSong Gao 2390399665d2SSong Gao #define DO_FTINT(FMT1, FMT2, T1, T2) \ 2391399665d2SSong Gao static T2 do_## FMT1 ##_to_## FMT2(CPULoongArchState *env, T1 fj) \ 2392399665d2SSong Gao { \ 2393399665d2SSong Gao T2 fd; \ 2394399665d2SSong Gao \ 2395399665d2SSong Gao fd = FMT1 ##_to_## FMT2(fj, &env->fp_status); \ 2396399665d2SSong Gao if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { \ 2397399665d2SSong Gao if (FMT1 ##_is_any_nan(fj)) { \ 2398399665d2SSong Gao fd = 0; \ 2399399665d2SSong Gao } \ 2400399665d2SSong Gao } \ 2401399665d2SSong Gao vec_update_fcsr0(env, GETPC()); \ 2402399665d2SSong Gao return fd; \ 2403399665d2SSong Gao } 2404399665d2SSong Gao 2405399665d2SSong Gao DO_FTINT(float32, int32, uint32_t, uint32_t) 2406399665d2SSong Gao DO_FTINT(float64, int64, uint64_t, uint64_t) 2407399665d2SSong Gao DO_FTINT(float32, uint32, uint32_t, uint32_t) 2408399665d2SSong Gao DO_FTINT(float64, uint64, uint64_t, uint64_t) 2409399665d2SSong Gao DO_FTINT(float64, int32, uint64_t, uint32_t) 2410399665d2SSong Gao DO_FTINT(float32, int64, uint32_t, uint64_t) 2411399665d2SSong Gao 2412399665d2SSong Gao FTINT(rne_w_s, float32, int32, uint32_t, uint32_t, float_round_nearest_even) 2413399665d2SSong Gao FTINT(rne_l_d, float64, int64, uint64_t, uint64_t, float_round_nearest_even) 2414399665d2SSong Gao FTINT(rp_w_s, float32, int32, uint32_t, uint32_t, float_round_up) 2415399665d2SSong Gao FTINT(rp_l_d, float64, int64, uint64_t, uint64_t, float_round_up) 2416399665d2SSong Gao FTINT(rz_w_s, float32, int32, uint32_t, uint32_t, float_round_to_zero) 2417399665d2SSong Gao FTINT(rz_l_d, float64, int64, uint64_t, uint64_t, float_round_to_zero) 2418399665d2SSong Gao FTINT(rm_w_s, float32, int32, uint32_t, uint32_t, float_round_down) 2419399665d2SSong Gao FTINT(rm_l_d, float64, int64, uint64_t, uint64_t, float_round_down) 2420399665d2SSong Gao 2421399665d2SSong Gao DO_2OP_F(vftintrne_w_s, 32, UW, do_ftintrne_w_s) 2422399665d2SSong Gao DO_2OP_F(vftintrne_l_d, 64, UD, do_ftintrne_l_d) 2423399665d2SSong Gao DO_2OP_F(vftintrp_w_s, 32, UW, do_ftintrp_w_s) 2424399665d2SSong Gao DO_2OP_F(vftintrp_l_d, 64, UD, do_ftintrp_l_d) 2425399665d2SSong Gao DO_2OP_F(vftintrz_w_s, 32, UW, do_ftintrz_w_s) 2426399665d2SSong Gao DO_2OP_F(vftintrz_l_d, 64, UD, do_ftintrz_l_d) 2427399665d2SSong Gao DO_2OP_F(vftintrm_w_s, 32, UW, do_ftintrm_w_s) 2428399665d2SSong Gao DO_2OP_F(vftintrm_l_d, 64, UD, do_ftintrm_l_d) 2429399665d2SSong Gao DO_2OP_F(vftint_w_s, 32, UW, do_float32_to_int32) 2430399665d2SSong Gao DO_2OP_F(vftint_l_d, 64, UD, do_float64_to_int64) 2431399665d2SSong Gao 2432399665d2SSong Gao FTINT(rz_wu_s, float32, uint32, uint32_t, uint32_t, float_round_to_zero) 2433399665d2SSong Gao FTINT(rz_lu_d, float64, uint64, uint64_t, uint64_t, float_round_to_zero) 2434399665d2SSong Gao 2435399665d2SSong Gao DO_2OP_F(vftintrz_wu_s, 32, UW, do_ftintrz_wu_s) 2436399665d2SSong Gao DO_2OP_F(vftintrz_lu_d, 64, UD, do_ftintrz_lu_d) 2437399665d2SSong Gao DO_2OP_F(vftint_wu_s, 32, UW, do_float32_to_uint32) 2438399665d2SSong Gao DO_2OP_F(vftint_lu_d, 64, UD, do_float64_to_uint64) 2439399665d2SSong Gao 2440399665d2SSong Gao FTINT(rm_w_d, float64, int32, uint64_t, uint32_t, float_round_down) 2441399665d2SSong Gao FTINT(rp_w_d, float64, int32, uint64_t, uint32_t, float_round_up) 2442399665d2SSong Gao FTINT(rz_w_d, float64, int32, uint64_t, uint32_t, float_round_to_zero) 2443399665d2SSong Gao FTINT(rne_w_d, float64, int32, uint64_t, uint32_t, float_round_nearest_even) 2444399665d2SSong Gao 2445399665d2SSong Gao #define FTINT_W_D(NAME, FN) \ 24463b286753SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, \ 24473b286753SSong Gao CPULoongArchState *env, uint32_t desc) \ 2448399665d2SSong Gao { \ 2449399665d2SSong Gao int i; \ 2450399665d2SSong Gao VReg temp; \ 24513b286753SSong Gao VReg *Vd = (VReg *)vd; \ 24523b286753SSong Gao VReg *Vj = (VReg *)vj; \ 24533b286753SSong Gao VReg *Vk = (VReg *)vk; \ 2454399665d2SSong Gao \ 2455399665d2SSong Gao vec_clear_cause(env); \ 2456399665d2SSong Gao for (i = 0; i < 2; i++) { \ 2457399665d2SSong Gao temp.W(i + 2) = FN(env, Vj->UD(i)); \ 2458399665d2SSong Gao temp.W(i) = FN(env, Vk->UD(i)); \ 2459399665d2SSong Gao } \ 2460399665d2SSong Gao *Vd = temp; \ 2461399665d2SSong Gao } 2462399665d2SSong Gao 2463399665d2SSong Gao FTINT_W_D(vftint_w_d, do_float64_to_int32) 2464399665d2SSong Gao FTINT_W_D(vftintrm_w_d, do_ftintrm_w_d) 2465399665d2SSong Gao FTINT_W_D(vftintrp_w_d, do_ftintrp_w_d) 2466399665d2SSong Gao FTINT_W_D(vftintrz_w_d, do_ftintrz_w_d) 2467399665d2SSong Gao FTINT_W_D(vftintrne_w_d, do_ftintrne_w_d) 2468399665d2SSong Gao 2469399665d2SSong Gao FTINT(rml_l_s, float32, int64, uint32_t, uint64_t, float_round_down) 2470399665d2SSong Gao FTINT(rpl_l_s, float32, int64, uint32_t, uint64_t, float_round_up) 2471399665d2SSong Gao FTINT(rzl_l_s, float32, int64, uint32_t, uint64_t, float_round_to_zero) 2472399665d2SSong Gao FTINT(rnel_l_s, float32, int64, uint32_t, uint64_t, float_round_nearest_even) 2473399665d2SSong Gao FTINT(rmh_l_s, float32, int64, uint32_t, uint64_t, float_round_down) 2474399665d2SSong Gao FTINT(rph_l_s, float32, int64, uint32_t, uint64_t, float_round_up) 2475399665d2SSong Gao FTINT(rzh_l_s, float32, int64, uint32_t, uint64_t, float_round_to_zero) 2476399665d2SSong Gao FTINT(rneh_l_s, float32, int64, uint32_t, uint64_t, float_round_nearest_even) 2477399665d2SSong Gao 2478399665d2SSong Gao #define FTINTL_L_S(NAME, FN) \ 2479226bf881SSong Gao void HELPER(NAME)(void *vd, void *vj, \ 2480226bf881SSong Gao CPULoongArchState *env, uint32_t desc) \ 2481399665d2SSong Gao { \ 2482399665d2SSong Gao int i; \ 2483399665d2SSong Gao VReg temp; \ 2484226bf881SSong Gao VReg *Vd = (VReg *)vd; \ 2485226bf881SSong Gao VReg *Vj = (VReg *)vj; \ 2486399665d2SSong Gao \ 2487399665d2SSong Gao vec_clear_cause(env); \ 2488399665d2SSong Gao for (i = 0; i < 2; i++) { \ 2489399665d2SSong Gao temp.D(i) = FN(env, Vj->UW(i)); \ 2490399665d2SSong Gao } \ 2491399665d2SSong Gao *Vd = temp; \ 2492399665d2SSong Gao } 2493399665d2SSong Gao 2494399665d2SSong Gao FTINTL_L_S(vftintl_l_s, do_float32_to_int64) 2495399665d2SSong Gao FTINTL_L_S(vftintrml_l_s, do_ftintrml_l_s) 2496399665d2SSong Gao FTINTL_L_S(vftintrpl_l_s, do_ftintrpl_l_s) 2497399665d2SSong Gao FTINTL_L_S(vftintrzl_l_s, do_ftintrzl_l_s) 2498399665d2SSong Gao FTINTL_L_S(vftintrnel_l_s, do_ftintrnel_l_s) 2499399665d2SSong Gao 2500399665d2SSong Gao #define FTINTH_L_S(NAME, FN) \ 2501226bf881SSong Gao void HELPER(NAME)(void *vd, void *vj, \ 2502226bf881SSong Gao CPULoongArchState *env, uint32_t desc) \ 2503399665d2SSong Gao { \ 2504399665d2SSong Gao int i; \ 2505399665d2SSong Gao VReg temp; \ 2506226bf881SSong Gao VReg *Vd = (VReg *)vd; \ 2507226bf881SSong Gao VReg *Vj = (VReg *)vj; \ 2508399665d2SSong Gao \ 2509399665d2SSong Gao vec_clear_cause(env); \ 2510399665d2SSong Gao for (i = 0; i < 2; i++) { \ 2511399665d2SSong Gao temp.D(i) = FN(env, Vj->UW(i + 2)); \ 2512399665d2SSong Gao } \ 2513399665d2SSong Gao *Vd = temp; \ 2514399665d2SSong Gao } 2515399665d2SSong Gao 2516399665d2SSong Gao FTINTH_L_S(vftinth_l_s, do_float32_to_int64) 2517399665d2SSong Gao FTINTH_L_S(vftintrmh_l_s, do_ftintrmh_l_s) 2518399665d2SSong Gao FTINTH_L_S(vftintrph_l_s, do_ftintrph_l_s) 2519399665d2SSong Gao FTINTH_L_S(vftintrzh_l_s, do_ftintrzh_l_s) 2520399665d2SSong Gao FTINTH_L_S(vftintrneh_l_s, do_ftintrneh_l_s) 2521399665d2SSong Gao 2522399665d2SSong Gao #define FFINT(NAME, FMT1, FMT2, T1, T2) \ 2523399665d2SSong Gao static T2 do_ffint_ ## NAME(CPULoongArchState *env, T1 fj) \ 2524399665d2SSong Gao { \ 2525399665d2SSong Gao T2 fd; \ 2526399665d2SSong Gao \ 2527399665d2SSong Gao fd = FMT1 ##_to_## FMT2(fj, &env->fp_status); \ 2528399665d2SSong Gao vec_update_fcsr0(env, GETPC()); \ 2529399665d2SSong Gao return fd; \ 2530399665d2SSong Gao } 2531399665d2SSong Gao 2532399665d2SSong Gao FFINT(s_w, int32, float32, int32_t, uint32_t) 2533399665d2SSong Gao FFINT(d_l, int64, float64, int64_t, uint64_t) 2534399665d2SSong Gao FFINT(s_wu, uint32, float32, uint32_t, uint32_t) 2535399665d2SSong Gao FFINT(d_lu, uint64, float64, uint64_t, uint64_t) 2536399665d2SSong Gao 2537399665d2SSong Gao DO_2OP_F(vffint_s_w, 32, W, do_ffint_s_w) 2538399665d2SSong Gao DO_2OP_F(vffint_d_l, 64, D, do_ffint_d_l) 2539399665d2SSong Gao DO_2OP_F(vffint_s_wu, 32, UW, do_ffint_s_wu) 2540399665d2SSong Gao DO_2OP_F(vffint_d_lu, 64, UD, do_ffint_d_lu) 2541399665d2SSong Gao 2542226bf881SSong Gao void HELPER(vffintl_d_w)(void *vd, void *vj, 2543226bf881SSong Gao CPULoongArchState *env, uint32_t desc) 2544399665d2SSong Gao { 2545399665d2SSong Gao int i; 2546399665d2SSong Gao VReg temp; 2547226bf881SSong Gao VReg *Vd = (VReg *)vd; 2548226bf881SSong Gao VReg *Vj = (VReg *)vj; 2549399665d2SSong Gao 2550399665d2SSong Gao vec_clear_cause(env); 2551399665d2SSong Gao for (i = 0; i < 2; i++) { 2552399665d2SSong Gao temp.D(i) = int32_to_float64(Vj->W(i), &env->fp_status); 2553399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2554399665d2SSong Gao } 2555399665d2SSong Gao *Vd = temp; 2556399665d2SSong Gao } 2557399665d2SSong Gao 2558226bf881SSong Gao void HELPER(vffinth_d_w)(void *vd, void *vj, 2559226bf881SSong Gao CPULoongArchState *env, uint32_t desc) 2560399665d2SSong Gao { 2561399665d2SSong Gao int i; 2562399665d2SSong Gao VReg temp; 2563226bf881SSong Gao VReg *Vd = (VReg *)vd; 2564226bf881SSong Gao VReg *Vj = (VReg *)vj; 2565399665d2SSong Gao 2566399665d2SSong Gao vec_clear_cause(env); 2567399665d2SSong Gao for (i = 0; i < 2; i++) { 2568399665d2SSong Gao temp.D(i) = int32_to_float64(Vj->W(i + 2), &env->fp_status); 2569399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2570399665d2SSong Gao } 2571399665d2SSong Gao *Vd = temp; 2572399665d2SSong Gao } 2573399665d2SSong Gao 25743b286753SSong Gao void HELPER(vffint_s_l)(void *vd, void *vj, void *vk, 25753b286753SSong Gao CPULoongArchState *env, uint32_t desc) 2576399665d2SSong Gao { 2577399665d2SSong Gao int i; 2578399665d2SSong Gao VReg temp; 25793b286753SSong Gao VReg *Vd = (VReg *)vd; 25803b286753SSong Gao VReg *Vj = (VReg *)vj; 25813b286753SSong Gao VReg *Vk = (VReg *)vk; 2582399665d2SSong Gao 2583399665d2SSong Gao vec_clear_cause(env); 2584399665d2SSong Gao for (i = 0; i < 2; i++) { 2585399665d2SSong Gao temp.W(i + 2) = int64_to_float32(Vj->D(i), &env->fp_status); 2586399665d2SSong Gao temp.W(i) = int64_to_float32(Vk->D(i), &env->fp_status); 2587399665d2SSong Gao vec_update_fcsr0(env, GETPC()); 2588399665d2SSong Gao } 2589399665d2SSong Gao *Vd = temp; 2590399665d2SSong Gao } 2591f435e1e5SSong Gao 2592f435e1e5SSong Gao #define VSEQ(a, b) (a == b ? -1 : 0) 2593f435e1e5SSong Gao #define VSLE(a, b) (a <= b ? -1 : 0) 2594f435e1e5SSong Gao #define VSLT(a, b) (a < b ? -1 : 0) 2595f435e1e5SSong Gao 2596f435e1e5SSong Gao #define VCMPI(NAME, BIT, E, DO_OP) \ 2597f435e1e5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t v) \ 2598f435e1e5SSong Gao { \ 2599f435e1e5SSong Gao int i; \ 2600f435e1e5SSong Gao VReg *Vd = (VReg *)vd; \ 2601f435e1e5SSong Gao VReg *Vj = (VReg *)vj; \ 2602f435e1e5SSong Gao typedef __typeof(Vd->E(0)) TD; \ 2603f435e1e5SSong Gao \ 2604f435e1e5SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2605f435e1e5SSong Gao Vd->E(i) = DO_OP(Vj->E(i), (TD)imm); \ 2606f435e1e5SSong Gao } \ 2607f435e1e5SSong Gao } 2608f435e1e5SSong Gao 2609f435e1e5SSong Gao VCMPI(vseqi_b, 8, B, VSEQ) 2610f435e1e5SSong Gao VCMPI(vseqi_h, 16, H, VSEQ) 2611f435e1e5SSong Gao VCMPI(vseqi_w, 32, W, VSEQ) 2612f435e1e5SSong Gao VCMPI(vseqi_d, 64, D, VSEQ) 2613f435e1e5SSong Gao VCMPI(vslei_b, 8, B, VSLE) 2614f435e1e5SSong Gao VCMPI(vslei_h, 16, H, VSLE) 2615f435e1e5SSong Gao VCMPI(vslei_w, 32, W, VSLE) 2616f435e1e5SSong Gao VCMPI(vslei_d, 64, D, VSLE) 2617f435e1e5SSong Gao VCMPI(vslei_bu, 8, UB, VSLE) 2618f435e1e5SSong Gao VCMPI(vslei_hu, 16, UH, VSLE) 2619f435e1e5SSong Gao VCMPI(vslei_wu, 32, UW, VSLE) 2620f435e1e5SSong Gao VCMPI(vslei_du, 64, UD, VSLE) 2621f435e1e5SSong Gao VCMPI(vslti_b, 8, B, VSLT) 2622f435e1e5SSong Gao VCMPI(vslti_h, 16, H, VSLT) 2623f435e1e5SSong Gao VCMPI(vslti_w, 32, W, VSLT) 2624f435e1e5SSong Gao VCMPI(vslti_d, 64, D, VSLT) 2625f435e1e5SSong Gao VCMPI(vslti_bu, 8, UB, VSLT) 2626f435e1e5SSong Gao VCMPI(vslti_hu, 16, UH, VSLT) 2627f435e1e5SSong Gao VCMPI(vslti_wu, 32, UW, VSLT) 2628f435e1e5SSong Gao VCMPI(vslti_du, 64, UD, VSLT) 2629386c4e86SSong Gao 2630386c4e86SSong Gao static uint64_t vfcmp_common(CPULoongArchState *env, 2631386c4e86SSong Gao FloatRelation cmp, uint32_t flags) 2632386c4e86SSong Gao { 2633386c4e86SSong Gao uint64_t ret = 0; 2634386c4e86SSong Gao 2635386c4e86SSong Gao switch (cmp) { 2636386c4e86SSong Gao case float_relation_less: 2637386c4e86SSong Gao ret = (flags & FCMP_LT); 2638386c4e86SSong Gao break; 2639386c4e86SSong Gao case float_relation_equal: 2640386c4e86SSong Gao ret = (flags & FCMP_EQ); 2641386c4e86SSong Gao break; 2642386c4e86SSong Gao case float_relation_greater: 2643386c4e86SSong Gao ret = (flags & FCMP_GT); 2644386c4e86SSong Gao break; 2645386c4e86SSong Gao case float_relation_unordered: 2646386c4e86SSong Gao ret = (flags & FCMP_UN); 2647386c4e86SSong Gao break; 2648386c4e86SSong Gao default: 2649386c4e86SSong Gao g_assert_not_reached(); 2650386c4e86SSong Gao } 2651386c4e86SSong Gao 2652386c4e86SSong Gao if (ret) { 2653386c4e86SSong Gao ret = -1; 2654386c4e86SSong Gao } 2655386c4e86SSong Gao 2656386c4e86SSong Gao return ret; 2657386c4e86SSong Gao } 2658386c4e86SSong Gao 2659386c4e86SSong Gao #define VFCMP(NAME, BIT, E, FN) \ 2660386c4e86SSong Gao void HELPER(NAME)(CPULoongArchState *env, \ 2661386c4e86SSong Gao uint32_t vd, uint32_t vj, uint32_t vk, uint32_t flags) \ 2662386c4e86SSong Gao { \ 2663386c4e86SSong Gao int i; \ 2664386c4e86SSong Gao VReg t; \ 2665386c4e86SSong Gao VReg *Vd = &(env->fpr[vd].vreg); \ 2666386c4e86SSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 2667386c4e86SSong Gao VReg *Vk = &(env->fpr[vk].vreg); \ 2668386c4e86SSong Gao \ 2669386c4e86SSong Gao vec_clear_cause(env); \ 2670386c4e86SSong Gao for (i = 0; i < LSX_LEN/BIT ; i++) { \ 2671386c4e86SSong Gao FloatRelation cmp; \ 2672386c4e86SSong Gao cmp = FN(Vj->E(i), Vk->E(i), &env->fp_status); \ 2673386c4e86SSong Gao t.E(i) = vfcmp_common(env, cmp, flags); \ 2674386c4e86SSong Gao vec_update_fcsr0(env, GETPC()); \ 2675386c4e86SSong Gao } \ 2676386c4e86SSong Gao *Vd = t; \ 2677386c4e86SSong Gao } 2678386c4e86SSong Gao 2679386c4e86SSong Gao VFCMP(vfcmp_c_s, 32, UW, float32_compare_quiet) 2680386c4e86SSong Gao VFCMP(vfcmp_s_s, 32, UW, float32_compare) 2681386c4e86SSong Gao VFCMP(vfcmp_c_d, 64, UD, float64_compare_quiet) 2682386c4e86SSong Gao VFCMP(vfcmp_s_d, 64, UD, float64_compare) 2683d0dfa19aSSong Gao 2684d0dfa19aSSong Gao void HELPER(vbitseli_b)(void *vd, void *vj, uint64_t imm, uint32_t v) 2685d0dfa19aSSong Gao { 2686d0dfa19aSSong Gao int i; 2687d0dfa19aSSong Gao VReg *Vd = (VReg *)vd; 2688d0dfa19aSSong Gao VReg *Vj = (VReg *)vj; 2689d0dfa19aSSong Gao 2690d0dfa19aSSong Gao for (i = 0; i < 16; i++) { 2691d0dfa19aSSong Gao Vd->B(i) = (~Vd->B(i) & Vj->B(i)) | (Vd->B(i) & imm); 2692d0dfa19aSSong Gao } 2693d0dfa19aSSong Gao } 2694d0dfa19aSSong Gao 2695d0dfa19aSSong Gao /* Copy from target/arm/tcg/sve_helper.c */ 2696d0dfa19aSSong Gao static inline bool do_match2(uint64_t n, uint64_t m0, uint64_t m1, int esz) 2697d0dfa19aSSong Gao { 2698d0dfa19aSSong Gao uint64_t bits = 8 << esz; 2699d0dfa19aSSong Gao uint64_t ones = dup_const(esz, 1); 2700d0dfa19aSSong Gao uint64_t signs = ones << (bits - 1); 2701d0dfa19aSSong Gao uint64_t cmp0, cmp1; 2702d0dfa19aSSong Gao 2703d0dfa19aSSong Gao cmp1 = dup_const(esz, n); 2704d0dfa19aSSong Gao cmp0 = cmp1 ^ m0; 2705d0dfa19aSSong Gao cmp1 = cmp1 ^ m1; 2706d0dfa19aSSong Gao cmp0 = (cmp0 - ones) & ~cmp0; 2707d0dfa19aSSong Gao cmp1 = (cmp1 - ones) & ~cmp1; 2708d0dfa19aSSong Gao return (cmp0 | cmp1) & signs; 2709d0dfa19aSSong Gao } 2710d0dfa19aSSong Gao 2711d0dfa19aSSong Gao #define SETANYEQZ(NAME, MO) \ 2712d0dfa19aSSong Gao void HELPER(NAME)(CPULoongArchState *env, uint32_t cd, uint32_t vj) \ 2713d0dfa19aSSong Gao { \ 2714d0dfa19aSSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 2715d0dfa19aSSong Gao \ 2716d0dfa19aSSong Gao env->cf[cd & 0x7] = do_match2(0, Vj->D(0), Vj->D(1), MO); \ 2717d0dfa19aSSong Gao } 2718d0dfa19aSSong Gao SETANYEQZ(vsetanyeqz_b, MO_8) 2719d0dfa19aSSong Gao SETANYEQZ(vsetanyeqz_h, MO_16) 2720d0dfa19aSSong Gao SETANYEQZ(vsetanyeqz_w, MO_32) 2721d0dfa19aSSong Gao SETANYEQZ(vsetanyeqz_d, MO_64) 2722d0dfa19aSSong Gao 2723d0dfa19aSSong Gao #define SETALLNEZ(NAME, MO) \ 2724d0dfa19aSSong Gao void HELPER(NAME)(CPULoongArchState *env, uint32_t cd, uint32_t vj) \ 2725d0dfa19aSSong Gao { \ 2726d0dfa19aSSong Gao VReg *Vj = &(env->fpr[vj].vreg); \ 2727d0dfa19aSSong Gao \ 2728d0dfa19aSSong Gao env->cf[cd & 0x7]= !do_match2(0, Vj->D(0), Vj->D(1), MO); \ 2729d0dfa19aSSong Gao } 2730d0dfa19aSSong Gao SETALLNEZ(vsetallnez_b, MO_8) 2731d0dfa19aSSong Gao SETALLNEZ(vsetallnez_h, MO_16) 2732d0dfa19aSSong Gao SETALLNEZ(vsetallnez_w, MO_32) 2733d0dfa19aSSong Gao SETALLNEZ(vsetallnez_d, MO_64) 2734d5e5563cSSong Gao 2735d5e5563cSSong Gao #define VPACKEV(NAME, BIT, E) \ 273604711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 2737d5e5563cSSong Gao { \ 2738d5e5563cSSong Gao int i; \ 2739d5e5563cSSong Gao VReg temp; \ 274004711da1SSong Gao VReg *Vd = (VReg *)vd; \ 274104711da1SSong Gao VReg *Vj = (VReg *)vj; \ 274204711da1SSong Gao VReg *Vk = (VReg *)vk; \ 2743d5e5563cSSong Gao \ 2744d5e5563cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2745d5e5563cSSong Gao temp.E(2 * i + 1) = Vj->E(2 * i); \ 2746d5e5563cSSong Gao temp.E(2 *i) = Vk->E(2 * i); \ 2747d5e5563cSSong Gao } \ 2748d5e5563cSSong Gao *Vd = temp; \ 2749d5e5563cSSong Gao } 2750d5e5563cSSong Gao 2751d5e5563cSSong Gao VPACKEV(vpackev_b, 16, B) 2752d5e5563cSSong Gao VPACKEV(vpackev_h, 32, H) 2753d5e5563cSSong Gao VPACKEV(vpackev_w, 64, W) 2754d5e5563cSSong Gao VPACKEV(vpackev_d, 128, D) 2755d5e5563cSSong Gao 2756d5e5563cSSong Gao #define VPACKOD(NAME, BIT, E) \ 275704711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 2758d5e5563cSSong Gao { \ 2759d5e5563cSSong Gao int i; \ 2760d5e5563cSSong Gao VReg temp; \ 276104711da1SSong Gao VReg *Vd = (VReg *)vd; \ 276204711da1SSong Gao VReg *Vj = (VReg *)vj; \ 276304711da1SSong Gao VReg *Vk = (VReg *)vk; \ 2764d5e5563cSSong Gao \ 2765d5e5563cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2766d5e5563cSSong Gao temp.E(2 * i + 1) = Vj->E(2 * i + 1); \ 2767d5e5563cSSong Gao temp.E(2 * i) = Vk->E(2 * i + 1); \ 2768d5e5563cSSong Gao } \ 2769d5e5563cSSong Gao *Vd = temp; \ 2770d5e5563cSSong Gao } 2771d5e5563cSSong Gao 2772d5e5563cSSong Gao VPACKOD(vpackod_b, 16, B) 2773d5e5563cSSong Gao VPACKOD(vpackod_h, 32, H) 2774d5e5563cSSong Gao VPACKOD(vpackod_w, 64, W) 2775d5e5563cSSong Gao VPACKOD(vpackod_d, 128, D) 2776d5e5563cSSong Gao 2777d5e5563cSSong Gao #define VPICKEV(NAME, BIT, E) \ 277804711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 2779d5e5563cSSong Gao { \ 2780d5e5563cSSong Gao int i; \ 2781d5e5563cSSong Gao VReg temp; \ 278204711da1SSong Gao VReg *Vd = (VReg *)vd; \ 278304711da1SSong Gao VReg *Vj = (VReg *)vj; \ 278404711da1SSong Gao VReg *Vk = (VReg *)vk; \ 2785d5e5563cSSong Gao \ 2786d5e5563cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2787d5e5563cSSong Gao temp.E(i + LSX_LEN/BIT) = Vj->E(2 * i); \ 2788d5e5563cSSong Gao temp.E(i) = Vk->E(2 * i); \ 2789d5e5563cSSong Gao } \ 2790d5e5563cSSong Gao *Vd = temp; \ 2791d5e5563cSSong Gao } 2792d5e5563cSSong Gao 2793d5e5563cSSong Gao VPICKEV(vpickev_b, 16, B) 2794d5e5563cSSong Gao VPICKEV(vpickev_h, 32, H) 2795d5e5563cSSong Gao VPICKEV(vpickev_w, 64, W) 2796d5e5563cSSong Gao VPICKEV(vpickev_d, 128, D) 2797d5e5563cSSong Gao 2798d5e5563cSSong Gao #define VPICKOD(NAME, BIT, E) \ 279904711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 2800d5e5563cSSong Gao { \ 2801d5e5563cSSong Gao int i; \ 2802d5e5563cSSong Gao VReg temp; \ 280304711da1SSong Gao VReg *Vd = (VReg *)vd; \ 280404711da1SSong Gao VReg *Vj = (VReg *)vj; \ 280504711da1SSong Gao VReg *Vk = (VReg *)vk; \ 2806d5e5563cSSong Gao \ 2807d5e5563cSSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2808d5e5563cSSong Gao temp.E(i + LSX_LEN/BIT) = Vj->E(2 * i + 1); \ 2809d5e5563cSSong Gao temp.E(i) = Vk->E(2 * i + 1); \ 2810d5e5563cSSong Gao } \ 2811d5e5563cSSong Gao *Vd = temp; \ 2812d5e5563cSSong Gao } 2813d5e5563cSSong Gao 2814d5e5563cSSong Gao VPICKOD(vpickod_b, 16, B) 2815d5e5563cSSong Gao VPICKOD(vpickod_h, 32, H) 2816d5e5563cSSong Gao VPICKOD(vpickod_w, 64, W) 2817d5e5563cSSong Gao VPICKOD(vpickod_d, 128, D) 2818e93dd431SSong Gao 2819e93dd431SSong Gao #define VILVL(NAME, BIT, E) \ 282004711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 2821e93dd431SSong Gao { \ 2822e93dd431SSong Gao int i; \ 2823e93dd431SSong Gao VReg temp; \ 282404711da1SSong Gao VReg *Vd = (VReg *)vd; \ 282504711da1SSong Gao VReg *Vj = (VReg *)vj; \ 282604711da1SSong Gao VReg *Vk = (VReg *)vk; \ 2827e93dd431SSong Gao \ 2828e93dd431SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2829e93dd431SSong Gao temp.E(2 * i + 1) = Vj->E(i); \ 2830e93dd431SSong Gao temp.E(2 * i) = Vk->E(i); \ 2831e93dd431SSong Gao } \ 2832e93dd431SSong Gao *Vd = temp; \ 2833e93dd431SSong Gao } 2834e93dd431SSong Gao 2835e93dd431SSong Gao VILVL(vilvl_b, 16, B) 2836e93dd431SSong Gao VILVL(vilvl_h, 32, H) 2837e93dd431SSong Gao VILVL(vilvl_w, 64, W) 2838e93dd431SSong Gao VILVL(vilvl_d, 128, D) 2839e93dd431SSong Gao 2840e93dd431SSong Gao #define VILVH(NAME, BIT, E) \ 284104711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 2842e93dd431SSong Gao { \ 2843e93dd431SSong Gao int i; \ 2844e93dd431SSong Gao VReg temp; \ 284504711da1SSong Gao VReg *Vd = (VReg *)vd; \ 284604711da1SSong Gao VReg *Vj = (VReg *)vj; \ 284704711da1SSong Gao VReg *Vk = (VReg *)vk; \ 2848e93dd431SSong Gao \ 2849e93dd431SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2850e93dd431SSong Gao temp.E(2 * i + 1) = Vj->E(i + LSX_LEN/BIT); \ 2851e93dd431SSong Gao temp.E(2 * i) = Vk->E(i + LSX_LEN/BIT); \ 2852e93dd431SSong Gao } \ 2853e93dd431SSong Gao *Vd = temp; \ 2854e93dd431SSong Gao } 2855e93dd431SSong Gao 2856e93dd431SSong Gao VILVH(vilvh_b, 16, B) 2857e93dd431SSong Gao VILVH(vilvh_h, 32, H) 2858e93dd431SSong Gao VILVH(vilvh_w, 64, W) 2859e93dd431SSong Gao VILVH(vilvh_d, 128, D) 2860e93dd431SSong Gao 2861eb48ab22SSong Gao void HELPER(vshuf_b)(void *vd, void *vj, void *vk, void *va, uint32_t desc) 2862e93dd431SSong Gao { 2863e93dd431SSong Gao int i, m; 2864e93dd431SSong Gao VReg temp; 2865eb48ab22SSong Gao VReg *Vd = (VReg *)vd; 2866eb48ab22SSong Gao VReg *Vj = (VReg *)vj; 2867eb48ab22SSong Gao VReg *Vk = (VReg *)vk; 2868eb48ab22SSong Gao VReg *Va = (VReg *)va; 2869e93dd431SSong Gao 2870e93dd431SSong Gao m = LSX_LEN/8; 2871e93dd431SSong Gao for (i = 0; i < m ; i++) { 2872e93dd431SSong Gao uint64_t k = (uint8_t)Va->B(i) % (2 * m); 2873e93dd431SSong Gao temp.B(i) = k < m ? Vk->B(k) : Vj->B(k - m); 2874e93dd431SSong Gao } 2875e93dd431SSong Gao *Vd = temp; 2876e93dd431SSong Gao } 2877e93dd431SSong Gao 2878e93dd431SSong Gao #define VSHUF(NAME, BIT, E) \ 287904711da1SSong Gao void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \ 2880e93dd431SSong Gao { \ 2881e93dd431SSong Gao int i, m; \ 2882e93dd431SSong Gao VReg temp; \ 288304711da1SSong Gao VReg *Vd = (VReg *)vd; \ 288404711da1SSong Gao VReg *Vj = (VReg *)vj; \ 288504711da1SSong Gao VReg *Vk = (VReg *)vk; \ 2886e93dd431SSong Gao \ 2887e93dd431SSong Gao m = LSX_LEN/BIT; \ 2888e93dd431SSong Gao for (i = 0; i < m; i++) { \ 2889e93dd431SSong Gao uint64_t k = ((uint8_t) Vd->E(i)) % (2 * m); \ 2890e93dd431SSong Gao temp.E(i) = k < m ? Vk->E(k) : Vj->E(k - m); \ 2891e93dd431SSong Gao } \ 2892e93dd431SSong Gao *Vd = temp; \ 2893e93dd431SSong Gao } 2894e93dd431SSong Gao 2895e93dd431SSong Gao VSHUF(vshuf_h, 16, H) 2896e93dd431SSong Gao VSHUF(vshuf_w, 32, W) 2897e93dd431SSong Gao VSHUF(vshuf_d, 64, D) 2898e93dd431SSong Gao 2899e93dd431SSong Gao #define VSHUF4I(NAME, BIT, E) \ 2900329517d5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \ 2901e93dd431SSong Gao { \ 2902e93dd431SSong Gao int i; \ 2903e93dd431SSong Gao VReg temp; \ 2904329517d5SSong Gao VReg *Vd = (VReg *)vd; \ 2905329517d5SSong Gao VReg *Vj = (VReg *)vj; \ 2906e93dd431SSong Gao \ 2907e93dd431SSong Gao for (i = 0; i < LSX_LEN/BIT; i++) { \ 2908e93dd431SSong Gao temp.E(i) = Vj->E(((i) & 0xfc) + (((imm) >> \ 2909e93dd431SSong Gao (2 * ((i) & 0x03))) & 0x03)); \ 2910e93dd431SSong Gao } \ 2911e93dd431SSong Gao *Vd = temp; \ 2912e93dd431SSong Gao } 2913e93dd431SSong Gao 2914e93dd431SSong Gao VSHUF4I(vshuf4i_b, 8, B) 2915e93dd431SSong Gao VSHUF4I(vshuf4i_h, 16, H) 2916e93dd431SSong Gao VSHUF4I(vshuf4i_w, 32, W) 2917e93dd431SSong Gao 2918329517d5SSong Gao void HELPER(vshuf4i_d)(void *vd, void *vj, uint64_t imm, uint32_t desc) 2919e93dd431SSong Gao { 2920329517d5SSong Gao VReg *Vd = (VReg *)vd; 2921329517d5SSong Gao VReg *Vj = (VReg *)vj; 2922e93dd431SSong Gao 2923e93dd431SSong Gao VReg temp; 2924e93dd431SSong Gao temp.D(0) = (imm & 2 ? Vj : Vd)->D(imm & 1); 2925e93dd431SSong Gao temp.D(1) = (imm & 8 ? Vj : Vd)->D((imm >> 2) & 1); 2926e93dd431SSong Gao *Vd = temp; 2927e93dd431SSong Gao } 2928e93dd431SSong Gao 2929329517d5SSong Gao void HELPER(vpermi_w)(void *vd, void *vj, uint64_t imm, uint32_t desc) 2930e93dd431SSong Gao { 2931e93dd431SSong Gao VReg temp; 2932329517d5SSong Gao VReg *Vd = (VReg *)vd; 2933329517d5SSong Gao VReg *Vj = (VReg *)vj; 2934e93dd431SSong Gao 2935e93dd431SSong Gao temp.W(0) = Vj->W(imm & 0x3); 2936e93dd431SSong Gao temp.W(1) = Vj->W((imm >> 2) & 0x3); 2937e93dd431SSong Gao temp.W(2) = Vd->W((imm >> 4) & 0x3); 2938e93dd431SSong Gao temp.W(3) = Vd->W((imm >> 6) & 0x3); 2939e93dd431SSong Gao *Vd = temp; 2940e93dd431SSong Gao } 2941e93dd431SSong Gao 2942e93dd431SSong Gao #define VEXTRINS(NAME, BIT, E, MASK) \ 2943329517d5SSong Gao void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \ 2944e93dd431SSong Gao { \ 2945e93dd431SSong Gao int ins, extr; \ 2946329517d5SSong Gao VReg *Vd = (VReg *)vd; \ 2947329517d5SSong Gao VReg *Vj = (VReg *)vj; \ 2948e93dd431SSong Gao \ 2949e93dd431SSong Gao ins = (imm >> 4) & MASK; \ 2950e93dd431SSong Gao extr = imm & MASK; \ 2951e93dd431SSong Gao Vd->E(ins) = Vj->E(extr); \ 2952e93dd431SSong Gao } 2953e93dd431SSong Gao 2954e93dd431SSong Gao VEXTRINS(vextrins_b, 8, B, 0xf) 2955e93dd431SSong Gao VEXTRINS(vextrins_h, 16, H, 0x7) 2956e93dd431SSong Gao VEXTRINS(vextrins_w, 32, W, 0x3) 2957e93dd431SSong Gao VEXTRINS(vextrins_d, 64, D, 0x1) 2958