.githooks/
riscv/
test/
.clang-format
570 B
.gitignore
5 B
.gitsigners
112 B
AGENTS.md
227 B
LICENSE
1.1 KiB
Makefile
3.5 KiB
README
12.5 KiB
STYLE
781 B
abi_host.c
12.2 KiB
abi_linux.c
3.7 KiB
bitmanip.h
5.8 KiB
color.h
567 B
debug_map.c
5.1 KiB
debug_map.h
1.3 KiB
emulator.c
87.3 KiB
host.h
5.5 KiB
host_posix.c
11.2 KiB
hosted.h
5.7 KiB
image_native.c
4.6 KiB
image_rad0.c
2.7 KiB
image_raw.c
2.6 KiB
io.c
1.1 KiB
io.h
444 B
jit.c
99.2 KiB
jit.h
7.8 KiB
machine.c
4.4 KiB
machine.h
2.1 KiB
machine_cpu.c
13.6 KiB
machine_csr.c
4.6 KiB
machine_devices.c
10.8 KiB
machine_fdt.c
8.7 KiB
machine_internal.h
7.4 KiB
muldiv.h
1.0 KiB
profile.c
17.5 KiB
profile.h
1.4 KiB
riscv.c
755 B
riscv.h
4.3 KiB
types.h
1019 B
vector.c
54.0 KiB
vector.h
1.3 KiB
bitmanip.h
raw
| 1 | /* RV64 Zba, Zbb, and Zbs instruction decoding and execution. */ |
| 2 | #ifndef BITMANIP_H |
| 3 | #define BITMANIP_H |
| 4 | |
| 5 | #include <emmintrin.h> |
| 6 | |
| 7 | #include "types.h" |
| 8 | |
| 9 | /* Required bit manipulation operations. Zero denotes another instruction. */ |
| 10 | enum bitmanip_op { |
| 11 | BM_NONE, |
| 12 | BM_ADDUW, |
| 13 | BM_SH1ADD, |
| 14 | BM_SH2ADD, |
| 15 | BM_SH3ADD, |
| 16 | BM_SH1ADDUW, |
| 17 | BM_SH2ADDUW, |
| 18 | BM_SH3ADDUW, |
| 19 | BM_ANDN, |
| 20 | BM_ORN, |
| 21 | BM_XNOR, |
| 22 | BM_MIN, |
| 23 | BM_MINU, |
| 24 | BM_MAX, |
| 25 | BM_MAXU, |
| 26 | BM_ROL, |
| 27 | BM_ROR, |
| 28 | BM_ROLW, |
| 29 | BM_RORW, |
| 30 | BM_BCLR, |
| 31 | BM_BEXT, |
| 32 | BM_BINV, |
| 33 | BM_BSET, |
| 34 | BM_CLZ, |
| 35 | BM_CTZ, |
| 36 | BM_CPOP, |
| 37 | BM_CLZW, |
| 38 | BM_CTZW, |
| 39 | BM_CPOPW, |
| 40 | BM_SEXTB, |
| 41 | BM_SEXTH, |
| 42 | BM_ORCB, |
| 43 | BM_REV8, |
| 44 | BM_ZEXTH, |
| 45 | BM_SLLIUW, |
| 46 | BM_RORI, |
| 47 | BM_RORIW, |
| 48 | BM_BCLRI, |
| 49 | BM_BEXTI, |
| 50 | BM_BINVI, |
| 51 | BM_BSETI, |
| 52 | }; |
| 53 | |
| 54 | /* Decode only architecturally defined operand forms. */ |
| 55 | static inline enum bitmanip_op bitmanip_decode(u32 ins) { |
| 56 | switch (ins & 0xfe00707fU) { |
| 57 | case 0x6000501b: |
| 58 | return BM_RORIW; |
| 59 | case 0x0800003b: |
| 60 | return BM_ADDUW; |
| 61 | case 0x20002033: |
| 62 | return BM_SH1ADD; |
| 63 | case 0x20004033: |
| 64 | return BM_SH2ADD; |
| 65 | case 0x20006033: |
| 66 | return BM_SH3ADD; |
| 67 | case 0x2000203b: |
| 68 | return BM_SH1ADDUW; |
| 69 | case 0x2000403b: |
| 70 | return BM_SH2ADDUW; |
| 71 | case 0x2000603b: |
| 72 | return BM_SH3ADDUW; |
| 73 | case 0x40007033: |
| 74 | return BM_ANDN; |
| 75 | case 0x40006033: |
| 76 | return BM_ORN; |
| 77 | case 0x40004033: |
| 78 | return BM_XNOR; |
| 79 | case 0x0a004033: |
| 80 | return BM_MIN; |
| 81 | case 0x0a005033: |
| 82 | return BM_MINU; |
| 83 | case 0x0a006033: |
| 84 | return BM_MAX; |
| 85 | case 0x0a007033: |
| 86 | return BM_MAXU; |
| 87 | case 0x60001033: |
| 88 | return BM_ROL; |
| 89 | case 0x60005033: |
| 90 | return BM_ROR; |
| 91 | case 0x6000103b: |
| 92 | return BM_ROLW; |
| 93 | case 0x6000503b: |
| 94 | return BM_RORW; |
| 95 | case 0x48001033: |
| 96 | return BM_BCLR; |
| 97 | case 0x48005033: |
| 98 | return BM_BEXT; |
| 99 | case 0x68001033: |
| 100 | return BM_BINV; |
| 101 | case 0x28001033: |
| 102 | return BM_BSET; |
| 103 | default: |
| 104 | break; |
| 105 | } |
| 106 | switch (ins & 0xfff0707fU) { |
| 107 | case 0x60001013: |
| 108 | return BM_CLZ; |
| 109 | case 0x60101013: |
| 110 | return BM_CTZ; |
| 111 | case 0x60201013: |
| 112 | return BM_CPOP; |
| 113 | case 0x6000101b: |
| 114 | return BM_CLZW; |
| 115 | case 0x6010101b: |
| 116 | return BM_CTZW; |
| 117 | case 0x6020101b: |
| 118 | return BM_CPOPW; |
| 119 | case 0x60401013: |
| 120 | return BM_SEXTB; |
| 121 | case 0x60501013: |
| 122 | return BM_SEXTH; |
| 123 | case 0x28705013: |
| 124 | return BM_ORCB; |
| 125 | case 0x6b805013: |
| 126 | return BM_REV8; |
| 127 | case 0x0800403b: |
| 128 | return BM_ZEXTH; |
| 129 | default: |
| 130 | break; |
| 131 | } |
| 132 | switch (ins & 0xfc00707fU) { |
| 133 | case 0x0800101b: |
| 134 | return BM_SLLIUW; |
| 135 | case 0x60005013: |
| 136 | return BM_RORI; |
| 137 | case 0x48001013: |
| 138 | return BM_BCLRI; |
| 139 | case 0x48005013: |
| 140 | return BM_BEXTI; |
| 141 | case 0x68001013: |
| 142 | return BM_BINVI; |
| 143 | case 0x28001013: |
| 144 | return BM_BSETI; |
| 145 | default: |
| 146 | break; |
| 147 | } |
| 148 | return BM_NONE; |
| 149 | } |
| 150 | |
| 151 | /* Evaluate a decoded operation with unsigned register values. */ |
| 152 | static inline u64 bitmanip_execute(enum bitmanip_op op, u32 ins, u64 a, u64 b) { |
| 153 | u32 n = (ins >> 20) & 63; |
| 154 | switch (op) { |
| 155 | case BM_ADDUW: |
| 156 | return (u32)a + b; |
| 157 | case BM_SH1ADD: |
| 158 | return ((u64)a << 1) + b; |
| 159 | case BM_SH2ADD: |
| 160 | return ((u64)a << 2) + b; |
| 161 | case BM_SH3ADD: |
| 162 | return ((u64)a << 3) + b; |
| 163 | case BM_SH1ADDUW: |
| 164 | return ((u64)(u32)a << 1) + b; |
| 165 | case BM_SH2ADDUW: |
| 166 | return ((u64)(u32)a << 2) + b; |
| 167 | case BM_SH3ADDUW: |
| 168 | return ((u64)(u32)a << 3) + b; |
| 169 | case BM_ANDN: |
| 170 | return a & ~b; |
| 171 | case BM_ORN: |
| 172 | return a | ~b; |
| 173 | case BM_XNOR: |
| 174 | return ~(a ^ b); |
| 175 | case BM_MIN: |
| 176 | return (i64)a < (i64)b ? a : b; |
| 177 | case BM_MINU: |
| 178 | return a < b ? a : b; |
| 179 | case BM_MAX: |
| 180 | return (i64)a > (i64)b ? a : b; |
| 181 | case BM_MAXU: |
| 182 | return a > b ? a : b; |
| 183 | case BM_ROL: |
| 184 | n = (u32)b & 63; |
| 185 | return (a << n) | (a >> ((0U - n) & 63)); |
| 186 | case BM_ROR: |
| 187 | n = (u32)b & 63; |
| 188 | return (a >> n) | (a << ((0U - n) & 63)); |
| 189 | case BM_ROLW: |
| 190 | n = (u32)b & 31; |
| 191 | return (u64)(i64)(i32)(((u32)a << n) | ((u32)a >> ((0U - n) & 31))); |
| 192 | case BM_RORW: |
| 193 | n = (u32)b & 31; |
| 194 | return (u64)(i64)(i32)(((u32)a >> n) | ((u32)a << ((0U - n) & 31))); |
| 195 | case BM_BCLR: |
| 196 | n = (u32)b & 63; |
| 197 | return a & ~(1ULL << n); |
| 198 | case BM_BEXT: |
| 199 | n = (u32)b & 63; |
| 200 | return (a >> n) & 1; |
| 201 | case BM_BINV: |
| 202 | n = (u32)b & 63; |
| 203 | return a ^ (1ULL << n); |
| 204 | case BM_BSET: |
| 205 | n = (u32)b & 63; |
| 206 | return a | (1ULL << n); |
| 207 | case BM_CLZ: |
| 208 | return a ? (u64)__builtin_clzll(a) : 64; |
| 209 | case BM_CTZ: |
| 210 | return a ? (u64)__builtin_ctzll(a) : 64; |
| 211 | case BM_CPOP: |
| 212 | return (u64)__builtin_popcountll(a); |
| 213 | case BM_CLZW: |
| 214 | return (u32)a ? (u64)__builtin_clz((u32)a) : 32; |
| 215 | case BM_CTZW: |
| 216 | return (u32)a ? (u64)__builtin_ctz((u32)a) : 32; |
| 217 | case BM_CPOPW: |
| 218 | return (u64)__builtin_popcount((u32)a); |
| 219 | case BM_SEXTB: |
| 220 | return (u64)(i64)(i8)a; |
| 221 | case BM_SEXTH: |
| 222 | return (u64)(i64)(i16)a; |
| 223 | case BM_ORCB: { |
| 224 | __m128i bytes = _mm_cvtsi64_si128((i64)a); |
| 225 | __m128i empty = _mm_cmpeq_epi8(bytes, _mm_setzero_si128()); |
| 226 | return (u64)_mm_cvtsi128_si64(_mm_xor_si128(empty, _mm_set1_epi8(-1))); |
| 227 | } |
| 228 | case BM_REV8: |
| 229 | return __builtin_bswap64(a); |
| 230 | case BM_ZEXTH: |
| 231 | return (u16)a; |
| 232 | case BM_SLLIUW: |
| 233 | return (u64)(u32)a << n; |
| 234 | case BM_RORI: |
| 235 | n = n & 63; |
| 236 | return (a >> n) | (a << ((0U - n) & 63)); |
| 237 | case BM_RORIW: |
| 238 | n = n & 31; |
| 239 | return (u64)(i64)(i32)(((u32)a >> n) | ((u32)a << ((0U - n) & 31))); |
| 240 | case BM_BCLRI: |
| 241 | return a & ~(1ULL << n); |
| 242 | case BM_BEXTI: |
| 243 | return (a >> n) & 1; |
| 244 | case BM_BINVI: |
| 245 | return a ^ (1ULL << n); |
| 246 | case BM_BSETI: |
| 247 | return a | (1ULL << n); |
| 248 | case BM_NONE: |
| 249 | break; |
| 250 | } |
| 251 | return 0; |
| 252 | } |
| 253 | |
| 254 | #endif |