.githooks/
riscv/
test/
jit_calls.c
5.5 KiB
jit_vector.c
15.8 KiB
vector.c
10.7 KiB
vector_machine.c
1.8 KiB
.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
test/vector.c
raw
| 1 | #include <assert.h> |
| 2 | #include <string.h> |
| 3 | |
| 4 | #include "vector.h" |
| 5 | |
| 6 | /* Transfer a checked element in test memory. */ |
| 7 | static bool mem(void *ctx, u64 address, u32 size, bool store, u64 *value) { |
| 8 | u8 *bytes = ctx; |
| 9 | if (address > 4096 || size > 4096 - address) |
| 10 | return false; |
| 11 | if (!store) |
| 12 | *value = 0; |
| 13 | for (u32 j = 0; j < size; j++) { |
| 14 | if (store) |
| 15 | bytes[address + j] = *value >> (j * 8); |
| 16 | else |
| 17 | *value |= (u64)bytes[address + j] << (j * 8); |
| 18 | } |
| 19 | return true; |
| 20 | } |
| 21 | |
| 22 | /* Set one little-endian element in a register group. */ |
| 23 | static void put(struct vector_state *v, u32 r, u32 i, u32 bits, u64 n) { |
| 24 | u8 *p = &v->reg[r][0] + i * (bits / 8); |
| 25 | for (u32 j = 0; j < bits / 8; j++) |
| 26 | p[j] = n >> (8 * j); |
| 27 | } |
| 28 | |
| 29 | /* Read one little-endian element in a register group. */ |
| 30 | static u64 get(struct vector_state *v, u32 r, u32 i, u32 bits) { |
| 31 | u64 n = 0; |
| 32 | u8 *p = &v->reg[r][0] + i * (bits / 8); |
| 33 | for (u32 j = 0; j < bits / 8; j++) |
| 34 | n |= (u64)p[j] << (8 * j); |
| 35 | return n; |
| 36 | } |
| 37 | |
| 38 | /* Construct OP-V operands independently of the instruction catalog. */ |
| 39 | static u32 alu(u32 fn, u32 form, u32 d, u32 a, u32 b, bool mask) { |
| 40 | return fn << 26 | (!mask) << 25 | a << 20 | b << 15 | form << 12 | d << 7 | |
| 41 | 0x57; |
| 42 | } |
| 43 | |
| 44 | /* Check rotations, masking and tail preservation for each element width. */ |
| 45 | static void rotations(void) { |
| 46 | for (u32 bits = 8, sew = 0; bits <= 64; bits *= 2, sew++) { |
| 47 | struct vector_state v = { 0 }; |
| 48 | u64 x[32] = { 0 }; |
| 49 | u8 bytes[4096] = { 0 }; |
| 50 | v.vtype = sew << 3; |
| 51 | v.vl = 3; |
| 52 | u64 mask = bits == 64 ? ~0ULL : (1ULL << bits) - 1; |
| 53 | u64 a = 0x81a53c779e0142ffULL & mask; |
| 54 | for (u32 i = 0; i < 4; i++) { |
| 55 | put(&v, 8, i, bits, 0x55); |
| 56 | put(&v, 16, i, bits, a); |
| 57 | } |
| 58 | for (u32 n = 0; n < 64; n++) { |
| 59 | u32 ins = alu(0x14 | (n >> 5), 3, 8, 16, n & 31, false); |
| 60 | assert(vector_execute(&v, x, ins, mem, bytes) == VECTOR_OK); |
| 61 | u32 k = n & (bits - 1); |
| 62 | u64 expected = k ? ((a >> k) | (a << (bits - k))) & mask : a; |
| 63 | assert(get(&v, 8, 0, bits) == expected); |
| 64 | assert(get(&v, 8, 3, bits) == 0x55); |
| 65 | } |
| 66 | v.reg[0][0] = 5; |
| 67 | put(&v, 8, 1, bits, 0x55); |
| 68 | assert( |
| 69 | vector_execute(&v, x, alu(0, 0, 8, 16, 16, true), mem, bytes) == |
| 70 | VECTOR_OK |
| 71 | ); |
| 72 | assert(get(&v, 8, 0, bits) == ((a + a) & mask)); |
| 73 | assert(get(&v, 8, 1, bits) == 0x55); |
| 74 | assert(get(&v, 8, 2, bits) == ((a + a) & mask)); |
| 75 | } |
| 76 | } |
| 77 | |
| 78 | /* Check memory restart, fault-only-first loads and segmented addressing. */ |
| 79 | static void memory_cases(void) { |
| 80 | struct vector_state v = { 0 }; |
| 81 | u64 x[32] = { 0 }; |
| 82 | u8 bytes[4096] = { 0 }; |
| 83 | v.vtype = 16; |
| 84 | v.vl = 4; |
| 85 | x[10] = 4092; |
| 86 | bytes[4092] = 17; |
| 87 | u32 load = 0x02056407; /* vle32.v v8, (a0) */ |
| 88 | assert(vector_execute(&v, x, load, mem, bytes) == VECTOR_FAULT); |
| 89 | assert(v.vstart == 1 && get(&v, 8, 0, 32) == 17); |
| 90 | x[10] = 0; |
| 91 | bytes[4] = 19; |
| 92 | assert(vector_execute(&v, x, load, mem, bytes) == VECTOR_OK); |
| 93 | assert(v.vstart == 0 && get(&v, 8, 0, 32) == 17 && get(&v, 8, 1, 32) == 19); |
| 94 | x[10] = 4092; |
| 95 | assert(vector_execute(&v, x, load | (16 << 20), mem, bytes) == VECTOR_OK); |
| 96 | assert(v.vl == 1 && v.vstart == 0); |
| 97 | x[10] = 0; |
| 98 | v.vl = 2; |
| 99 | bytes[0] = 1; |
| 100 | bytes[4] = 2; |
| 101 | bytes[8] = 3; |
| 102 | bytes[12] = 4; |
| 103 | assert(vector_execute(&v, x, load | (1u << 29), mem, bytes) == VECTOR_OK); |
| 104 | assert(get(&v, 8, 0, 32) == 1 && get(&v, 9, 0, 32) == 2); |
| 105 | assert(get(&v, 8, 1, 32) == 3 && get(&v, 9, 1, 32) == 4); |
| 106 | } |
| 107 | |
| 108 | /* Check fixed-point saturation, extension and packed mask reductions. */ |
| 109 | static void integer_cases(void) { |
| 110 | struct vector_state v = { 0 }; |
| 111 | u64 x[32] = { 0 }; |
| 112 | u8 bytes[4096] = { 0 }; |
| 113 | v.vl = 4; |
| 114 | put(&v, 16, 0, 8, 255); |
| 115 | put(&v, 24, 0, 8, 1); |
| 116 | assert( |
| 117 | vector_execute(&v, x, alu(32, 0, 8, 16, 24, false), mem, bytes) == |
| 118 | VECTOR_OK |
| 119 | ); |
| 120 | assert(get(&v, 8, 0, 8) == 255 && v.vxsat == 1); |
| 121 | put(&v, 16, 0, 8, 127); |
| 122 | put(&v, 24, 0, 8, 1); |
| 123 | assert( |
| 124 | vector_execute(&v, x, alu(33, 0, 8, 16, 24, false), mem, bytes) == |
| 125 | VECTOR_OK |
| 126 | ); |
| 127 | assert(get(&v, 8, 0, 8) == 127); |
| 128 | v.vtype = 16; |
| 129 | v.reg[31][0] = 0x80; |
| 130 | assert( |
| 131 | vector_execute(&v, x, alu(18, 2, 8, 31, 5, false), mem, bytes) == |
| 132 | VECTOR_OK |
| 133 | ); |
| 134 | assert(get(&v, 8, 0, 32) == 0xffffff80); |
| 135 | v.vtype = 3; |
| 136 | v.vl = 256; |
| 137 | memset(v.reg[31], 255, VECTOR_BYTES); |
| 138 | assert( |
| 139 | vector_execute(&v, x, alu(16, 2, 10, 31, 16, false), mem, bytes) == |
| 140 | VECTOR_OK |
| 141 | ); |
| 142 | assert(x[10] == 256); |
| 143 | assert( |
| 144 | vector_execute(&v, x, alu(16, 2, 10, 31, 17, false), mem, bytes) == |
| 145 | VECTOR_OK |
| 146 | ); |
| 147 | assert(x[10] == 0); |
| 148 | /* Destination alignment is checked before a register group is written. */ |
| 149 | struct vector_state before = v; |
| 150 | assert( |
| 151 | vector_execute(&v, x, alu(0, 0, 31, 16, 24, false), mem, bytes) == |
| 152 | VECTOR_ILLEGAL |
| 153 | ); |
| 154 | assert(memcmp(&before, &v, sizeof(v)) == 0); |
| 155 | } |
| 156 | |
| 157 | /* Check each unary Zvbb operation against fixed element results. */ |
| 158 | static void bit_operations(void) { |
| 159 | struct vector_state v = { 0 }; |
| 160 | u64 x[32] = { 0 }; |
| 161 | u8 bytes[4096] = { 0 }; |
| 162 | const u32 selectors[] = { 8, 9, 10, 12, 13, 14 }; |
| 163 | const u32 expected[] = { 0x808040c0, 0x03020101, 0xc0408080, 7, 0, 5 }; |
| 164 | v.vtype = 16; |
| 165 | v.vl = 1; |
| 166 | put(&v, 16, 0, 32, 0x01010203); |
| 167 | for (u32 i = 0; i < 6; i++) { |
| 168 | assert( |
| 169 | vector_execute( |
| 170 | &v, x, alu(18, 2, 8, 16, selectors[i], false), mem, bytes |
| 171 | ) == VECTOR_OK |
| 172 | ); |
| 173 | assert(get(&v, 8, 0, 32) == expected[i]); |
| 174 | } |
| 175 | v.vtype = 16; |
| 176 | put(&v, 16, 0, 32, 1); |
| 177 | assert( |
| 178 | vector_execute(&v, x, alu(53, 3, 8, 16, 31, false), mem, bytes) == |
| 179 | VECTOR_OK |
| 180 | ); |
| 181 | assert(get(&v, 8, 0, 64) == 1ULL << 31); |
| 182 | } |
| 183 | |
| 184 | /* Mask results and scalar moves occupy one register for every LMUL. */ |
| 185 | static void mask_registers(void) { |
| 186 | struct vector_state v = { 0 }; |
| 187 | u64 x[32] = { 0 }; |
| 188 | u8 bytes[4096] = { 0 }; |
| 189 | v.vtype = 3; |
| 190 | v.vl = 8; |
| 191 | v.reg[31][0] = 4; |
| 192 | assert( |
| 193 | vector_execute(&v, x, alu(20, 2, 3, 31, 1, false), mem, bytes) == |
| 194 | VECTOR_OK |
| 195 | ); |
| 196 | assert(v.reg[3][0] == 3); |
| 197 | assert( |
| 198 | vector_execute(&v, x, alu(20, 2, 31, 31, 1, false), mem, bytes) == |
| 199 | VECTOR_ILLEGAL |
| 200 | ); |
| 201 | assert( |
| 202 | vector_execute(&v, x, alu(20, 2, 8, 8, 16, false), mem, bytes) == |
| 203 | VECTOR_ILLEGAL |
| 204 | ); |
| 205 | x[10] = 23; |
| 206 | assert( |
| 207 | vector_execute(&v, x, alu(16, 6, 3, 0, 10, false), mem, bytes) == |
| 208 | VECTOR_OK |
| 209 | ); |
| 210 | assert(v.reg[3][0] == 23); |
| 211 | } |
| 212 | |
| 213 | /* Check SIMD register groups, aliases, masks, tails and restart positions. */ |
| 214 | static void native_lanes(void) { |
| 215 | const u32 lms[] = { 0, 1, 2, 3, 5, 6, 7 }; |
| 216 | for (u32 w = 0; w < 4; w++) { |
| 217 | u32 bits = 8u << w; |
| 218 | u64 mask = bits == 64 ? ~0ULL : (1ULL << bits) - 1; |
| 219 | for (u32 lm = 0; lm < sizeof(lms) / sizeof(lms[0]); lm++) { |
| 220 | u32 bytes = lms[lm] < 4 ? VECTOR_BYTES << lms[lm] |
| 221 | : VECTOR_BYTES >> (8 - lms[lm]); |
| 222 | u32 max = bytes * 8 / bits; |
| 223 | if (!max) |
| 224 | continue; |
| 225 | for (u32 k = 0; k < 4; k++) |
| 226 | for (u32 mode = 0; mode < 8; mode++) { |
| 227 | struct vector_state v = { 0 }; |
| 228 | u64 x[32] = { 0 }; |
| 229 | for (u32 j = 0; j < sizeof(v.reg); j++) |
| 230 | ((u8 *)v.reg)[j] = j * 37 + 129; |
| 231 | v.vtype = w * 8 + lms[lm]; |
| 232 | v.vl = mode & 1 ? max : max - 1; |
| 233 | v.vstart = mode & 2 ? max / 3 : 0; |
| 234 | bool masked = mode & 4; |
| 235 | u32 d = mode & 1 ? 24 : 8; |
| 236 | u32 ops[] = { |
| 237 | alu(0, 0, d, 24, 16, masked), |
| 238 | alu(37, 2, d, 24, 16, masked), |
| 239 | alu(20, 4, d, 24, 10, masked), |
| 240 | alu(18, 2, d, 24, 14, masked), |
| 241 | }; |
| 242 | x[10] = bits - 1; |
| 243 | struct vector_state want = v; |
| 244 | for (u32 i = v.vstart; i < v.vl; i++) { |
| 245 | if (masked && !((v.reg[0][i / 8] >> (i % 8)) & 1)) |
| 246 | continue; |
| 247 | u64 a = get(&v, 24, i, bits); |
| 248 | u64 b = get(&v, 16, i, bits); |
| 249 | u64 z = k == 0 ? a + b |
| 250 | : k == 1 ? a * b |
| 251 | : k == 2 ? (a >> (bits - 1)) | (a << 1) |
| 252 | : (u64)__builtin_popcountll(a); |
| 253 | put(&want, d, i, bits, z & mask); |
| 254 | } |
| 255 | want.vstart = 0; |
| 256 | assert( |
| 257 | vector_execute(&v, x, ops[k], mem, NULL) == VECTOR_OK |
| 258 | ); |
| 259 | assert(memcmp(&v, &want, sizeof(v)) == 0); |
| 260 | } |
| 261 | } |
| 262 | } |
| 263 | } |
| 264 | |
| 265 | /* Exercise integer vector execution without host image loading. */ |
| 266 | int main(void) { |
| 267 | native_lanes(); |
| 268 | mask_registers(); |
| 269 | bit_operations(); |
| 270 | rotations(); |
| 271 | memory_cases(); |
| 272 | integer_cases(); |
| 273 | struct vector_state shift = { 0 }; |
| 274 | u64 sx[32] = { 0 }; |
| 275 | u8 sm[4096] = { 0 }; |
| 276 | shift.vtype = 24; |
| 277 | shift.vl = 1; |
| 278 | put(&shift, 16, 0, 64, 1); |
| 279 | assert( |
| 280 | vector_execute(&shift, sx, alu(37, 3, 8, 16, 31, false), mem, sm) == |
| 281 | VECTOR_OK |
| 282 | ); |
| 283 | assert(get(&shift, 8, 0, 64) == 1ULL << 31); |
| 284 | struct vector_state v = { 0 }; |
| 285 | u64 x[32] = { 0 }; |
| 286 | u8 bytes[4096] = { 0 }; |
| 287 | assert(vector_execute(&v, x, 0xc1027557, mem, bytes) == VECTOR_OK); |
| 288 | assert(v.vl == 4 && v.vtype == 16 && x[10] == 4); |
| 289 | for (int i = 0; i < 4; i++) { |
| 290 | v.reg[9][i * 4] = i + 1; |
| 291 | v.reg[10][i * 4] = 10; |
| 292 | } |
| 293 | assert(vector_execute(&v, x, 0x02950457, mem, bytes) == VECTOR_OK); |
| 294 | for (int i = 0; i < 4; i++) |
| 295 | assert(v.reg[8][i * 4] == i + 11); |
| 296 | assert(vector_execute(&v, x, 0x52943457, mem, bytes) == VECTOR_OK); |
| 297 | assert(v.reg[8][0] == 0 && v.reg[8][3] == 1); |
| 298 | return 0; |
| 299 | } |