1 /* 2 * RISC-V Bitmanip Extension Helpers for QEMU. 3 * 4 * Copyright (c) 2020 Kito Cheng, kito.cheng@sifive.com 5 * Copyright (c) 2020 Frank Chang, frank.chang@sifive.com 6 * Copyright (c) 2021 Philipp Tomsich, philipp.tomsich@vrull.eu 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms and conditions of the GNU General Public License, 10 * version 2 or later, as published by the Free Software Foundation. 11 * 12 * This program is distributed in the hope it will be useful, but WITHOUT 13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 15 * more details. 16 * 17 * You should have received a copy of the GNU General Public License along with 18 * this program. If not, see <http://www.gnu.org/licenses/>. 19 */ 20 21 #include "qemu/osdep.h" 22 #include "qemu/host-utils.h" 23 #include "exec/exec-all.h" 24 #include "exec/helper-proto.h" 25 #include "tcg/tcg.h" 26 HELPER(clmul)27 target_ulong HELPER(clmul)(target_ulong rs1, target_ulong rs2) 28 { 29 target_ulong result = 0; 30 31 for (int i = 0; i < TARGET_LONG_BITS; i++) { 32 if ((rs2 >> i) & 1) { 33 result ^= (rs1 << i); 34 } 35 } 36 37 return result; 38 } 39 HELPER(clmulr)40 target_ulong HELPER(clmulr)(target_ulong rs1, target_ulong rs2) 41 { 42 target_ulong result = 0; 43 44 for (int i = 0; i < TARGET_LONG_BITS; i++) { 45 if ((rs2 >> i) & 1) { 46 result ^= (rs1 >> (TARGET_LONG_BITS - i - 1)); 47 } 48 } 49 50 return result; 51 } 52 do_swap(target_ulong x,uint64_t mask,int shift)53 static inline target_ulong do_swap(target_ulong x, uint64_t mask, int shift) 54 { 55 return ((x & mask) << shift) | ((x & ~mask) >> shift); 56 } 57 HELPER(brev8)58 target_ulong HELPER(brev8)(target_ulong rs1) 59 { 60 target_ulong x = rs1; 61 62 x = do_swap(x, 0x5555555555555555ull, 1); 63 x = do_swap(x, 0x3333333333333333ull, 2); 64 x = do_swap(x, 0x0f0f0f0f0f0f0f0full, 4); 65 return x; 66 } 67 68 static const uint64_t shuf_masks[] = { 69 dup_const(MO_8, 0x44), 70 dup_const(MO_8, 0x30), 71 dup_const(MO_16, 0x0f00), 72 dup_const(MO_32, 0xff0000) 73 }; 74 do_shuf_stage(target_ulong src,uint64_t maskL,uint64_t maskR,int shift)75 static inline target_ulong do_shuf_stage(target_ulong src, uint64_t maskL, 76 uint64_t maskR, int shift) 77 { 78 target_ulong x = src & ~(maskL | maskR); 79 80 x |= ((src << shift) & maskL) | ((src >> shift) & maskR); 81 return x; 82 } 83 HELPER(unzip)84 target_ulong HELPER(unzip)(target_ulong rs1) 85 { 86 target_ulong x = rs1; 87 88 x = do_shuf_stage(x, shuf_masks[0], shuf_masks[0] >> 1, 1); 89 x = do_shuf_stage(x, shuf_masks[1], shuf_masks[1] >> 2, 2); 90 x = do_shuf_stage(x, shuf_masks[2], shuf_masks[2] >> 4, 4); 91 x = do_shuf_stage(x, shuf_masks[3], shuf_masks[3] >> 8, 8); 92 return x; 93 } 94 HELPER(zip)95 target_ulong HELPER(zip)(target_ulong rs1) 96 { 97 target_ulong x = rs1; 98 99 x = do_shuf_stage(x, shuf_masks[3], shuf_masks[3] >> 8, 8); 100 x = do_shuf_stage(x, shuf_masks[2], shuf_masks[2] >> 4, 4); 101 x = do_shuf_stage(x, shuf_masks[1], shuf_masks[1] >> 2, 2); 102 x = do_shuf_stage(x, shuf_masks[0], shuf_masks[0] >> 1, 1); 103 return x; 104 } 105 do_xperm(target_ulong rs1,target_ulong rs2,uint32_t sz_log2)106 static inline target_ulong do_xperm(target_ulong rs1, target_ulong rs2, 107 uint32_t sz_log2) 108 { 109 target_ulong r = 0; 110 target_ulong sz = 1LL << sz_log2; 111 target_ulong mask = (1LL << sz) - 1; 112 target_ulong pos; 113 114 for (int i = 0; i < TARGET_LONG_BITS; i += sz) { 115 pos = ((rs2 >> i) & mask) << sz_log2; 116 if (pos < sizeof(target_ulong) * 8) { 117 r |= ((rs1 >> pos) & mask) << i; 118 } 119 } 120 return r; 121 } 122 HELPER(xperm4)123 target_ulong HELPER(xperm4)(target_ulong rs1, target_ulong rs2) 124 { 125 return do_xperm(rs1, rs2, 2); 126 } 127 HELPER(xperm8)128 target_ulong HELPER(xperm8)(target_ulong rs1, target_ulong rs2) 129 { 130 return do_xperm(rs1, rs2, 3); 131 } 132