/* Integer vector instruction execution. */ #include "vector.h" /* One instruction's fixed opcode fields. */ struct vector_opcode { const char *name; u32 value, mask; }; static const struct vector_opcode vector_opcodes[] = { { "vsetivli", 0xc0007057, 0xc000707f }, { "vsetvli", 0x00007057, 0x8000707f }, { "vsetvl", 0x80007057, 0xfe00707f }, { "vlm.v", 0x02b00007, 0xfff0707f }, { "vsm.v", 0x02b00027, 0xfff0707f }, { "vle8.v", 0x00000007, 0x1df0707f }, { "vle16.v", 0x00005007, 0x1df0707f }, { "vle32.v", 0x00006007, 0x1df0707f }, { "vle64.v", 0x00007007, 0x1df0707f }, { "vse8.v", 0x00000027, 0x1df0707f }, { "vse16.v", 0x00005027, 0x1df0707f }, { "vse32.v", 0x00006027, 0x1df0707f }, { "vse64.v", 0x00007027, 0x1df0707f }, { "vluxei8.v", 0x04000007, 0x1c00707f }, { "vluxei16.v", 0x04005007, 0x1c00707f }, { "vluxei32.v", 0x04006007, 0x1c00707f }, { "vluxei64.v", 0x04007007, 0x1c00707f }, { "vsuxei8.v", 0x04000027, 0x1c00707f }, { "vsuxei16.v", 0x04005027, 0x1c00707f }, { "vsuxei32.v", 0x04006027, 0x1c00707f }, { "vsuxei64.v", 0x04007027, 0x1c00707f }, { "vlse8.v", 0x08000007, 0x1c00707f }, { "vlse16.v", 0x08005007, 0x1c00707f }, { "vlse32.v", 0x08006007, 0x1c00707f }, { "vlse64.v", 0x08007007, 0x1c00707f }, { "vsse8.v", 0x08000027, 0x1c00707f }, { "vsse16.v", 0x08005027, 0x1c00707f }, { "vsse32.v", 0x08006027, 0x1c00707f }, { "vsse64.v", 0x08007027, 0x1c00707f }, { "vloxei8.v", 0x0c000007, 0x1c00707f }, { "vloxei16.v", 0x0c005007, 0x1c00707f }, { "vloxei32.v", 0x0c006007, 0x1c00707f }, { "vloxei64.v", 0x0c007007, 0x1c00707f }, { "vsoxei8.v", 0x0c000027, 0x1c00707f }, { "vsoxei16.v", 0x0c005027, 0x1c00707f }, { "vsoxei32.v", 0x0c006027, 0x1c00707f }, { "vsoxei64.v", 0x0c007027, 0x1c00707f }, { "vle8ff.v", 0x01000007, 0x1df0707f }, { "vle16ff.v", 0x01005007, 0x1df0707f }, { "vle32ff.v", 0x01006007, 0x1df0707f }, { "vle64ff.v", 0x01007007, 0x1df0707f }, { "vl1re8.v", 0x02800007, 0xfff0707f }, { "vl1re16.v", 0x02805007, 0xfff0707f }, { "vl1re32.v", 0x02806007, 0xfff0707f }, { "vl1re64.v", 0x02807007, 0xfff0707f }, { "vl2re8.v", 0x22800007, 0xfff0707f }, { "vl2re16.v", 0x22805007, 0xfff0707f }, { "vl2re32.v", 0x22806007, 0xfff0707f }, { "vl2re64.v", 0x22807007, 0xfff0707f }, { "vl4re8.v", 0x62800007, 0xfff0707f }, { "vl4re16.v", 0x62805007, 0xfff0707f }, { "vl4re32.v", 0x62806007, 0xfff0707f }, { "vl4re64.v", 0x62807007, 0xfff0707f }, { "vl8re8.v", 0xe2800007, 0xfff0707f }, { "vl8re16.v", 0xe2805007, 0xfff0707f }, { "vl8re32.v", 0xe2806007, 0xfff0707f }, { "vl8re64.v", 0xe2807007, 0xfff0707f }, { "vs1r.v", 0x02800027, 0xfff0707f }, { "vs2r.v", 0x22800027, 0xfff0707f }, { "vs4r.v", 0x62800027, 0xfff0707f }, { "vs8r.v", 0xe2800027, 0xfff0707f }, { "vadd.vx", 0x00004057, 0xfc00707f }, { "vsub.vx", 0x08004057, 0xfc00707f }, { "vrsub.vx", 0x0c004057, 0xfc00707f }, { "vminu.vx", 0x10004057, 0xfc00707f }, { "vmin.vx", 0x14004057, 0xfc00707f }, { "vmaxu.vx", 0x18004057, 0xfc00707f }, { "vmax.vx", 0x1c004057, 0xfc00707f }, { "vand.vx", 0x24004057, 0xfc00707f }, { "vor.vx", 0x28004057, 0xfc00707f }, { "vxor.vx", 0x2c004057, 0xfc00707f }, { "vrgather.vx", 0x30004057, 0xfc00707f }, { "vslideup.vx", 0x38004057, 0xfc00707f }, { "vslidedown.vx", 0x3c004057, 0xfc00707f }, { "vadc.vxm", 0x40004057, 0xfe00707f }, { "vmadc.vxm", 0x44004057, 0xfe00707f }, { "vmadc.vx", 0x46004057, 0xfe00707f }, { "vsbc.vxm", 0x48004057, 0xfe00707f }, { "vmsbc.vxm", 0x4c004057, 0xfe00707f }, { "vmsbc.vx", 0x4e004057, 0xfe00707f }, { "vmerge.vxm", 0x5c004057, 0xfe00707f }, { "vmv.v.x", 0x5e004057, 0xfff0707f }, { "vmseq.vx", 0x60004057, 0xfc00707f }, { "vmsne.vx", 0x64004057, 0xfc00707f }, { "vmsltu.vx", 0x68004057, 0xfc00707f }, { "vmslt.vx", 0x6c004057, 0xfc00707f }, { "vmsleu.vx", 0x70004057, 0xfc00707f }, { "vmsle.vx", 0x74004057, 0xfc00707f }, { "vmsgtu.vx", 0x78004057, 0xfc00707f }, { "vmsgt.vx", 0x7c004057, 0xfc00707f }, { "vsaddu.vx", 0x80004057, 0xfc00707f }, { "vsadd.vx", 0x84004057, 0xfc00707f }, { "vssubu.vx", 0x88004057, 0xfc00707f }, { "vssub.vx", 0x8c004057, 0xfc00707f }, { "vsll.vx", 0x94004057, 0xfc00707f }, { "vsmul.vx", 0x9c004057, 0xfc00707f }, { "vsrl.vx", 0xa0004057, 0xfc00707f }, { "vsra.vx", 0xa4004057, 0xfc00707f }, { "vssrl.vx", 0xa8004057, 0xfc00707f }, { "vssra.vx", 0xac004057, 0xfc00707f }, { "vnsrl.wx", 0xb0004057, 0xfc00707f }, { "vnsra.wx", 0xb4004057, 0xfc00707f }, { "vnclipu.wx", 0xb8004057, 0xfc00707f }, { "vnclip.wx", 0xbc004057, 0xfc00707f }, { "vadd.vv", 0x00000057, 0xfc00707f }, { "vsub.vv", 0x08000057, 0xfc00707f }, { "vminu.vv", 0x10000057, 0xfc00707f }, { "vmin.vv", 0x14000057, 0xfc00707f }, { "vmaxu.vv", 0x18000057, 0xfc00707f }, { "vmax.vv", 0x1c000057, 0xfc00707f }, { "vand.vv", 0x24000057, 0xfc00707f }, { "vor.vv", 0x28000057, 0xfc00707f }, { "vxor.vv", 0x2c000057, 0xfc00707f }, { "vrgather.vv", 0x30000057, 0xfc00707f }, { "vrgatherei16.vv", 0x38000057, 0xfc00707f }, { "vadc.vvm", 0x40000057, 0xfe00707f }, { "vmadc.vvm", 0x44000057, 0xfe00707f }, { "vmadc.vv", 0x46000057, 0xfe00707f }, { "vsbc.vvm", 0x48000057, 0xfe00707f }, { "vmsbc.vvm", 0x4c000057, 0xfe00707f }, { "vmsbc.vv", 0x4e000057, 0xfe00707f }, { "vmerge.vvm", 0x5c000057, 0xfe00707f }, { "vmv.v.v", 0x5e000057, 0xfff0707f }, { "vmseq.vv", 0x60000057, 0xfc00707f }, { "vmsne.vv", 0x64000057, 0xfc00707f }, { "vmsltu.vv", 0x68000057, 0xfc00707f }, { "vmslt.vv", 0x6c000057, 0xfc00707f }, { "vmsleu.vv", 0x70000057, 0xfc00707f }, { "vmsle.vv", 0x74000057, 0xfc00707f }, { "vsaddu.vv", 0x80000057, 0xfc00707f }, { "vsadd.vv", 0x84000057, 0xfc00707f }, { "vssubu.vv", 0x88000057, 0xfc00707f }, { "vssub.vv", 0x8c000057, 0xfc00707f }, { "vsll.vv", 0x94000057, 0xfc00707f }, { "vsmul.vv", 0x9c000057, 0xfc00707f }, { "vsrl.vv", 0xa0000057, 0xfc00707f }, { "vsra.vv", 0xa4000057, 0xfc00707f }, { "vssrl.vv", 0xa8000057, 0xfc00707f }, { "vssra.vv", 0xac000057, 0xfc00707f }, { "vnsrl.wv", 0xb0000057, 0xfc00707f }, { "vnsra.wv", 0xb4000057, 0xfc00707f }, { "vnclipu.wv", 0xb8000057, 0xfc00707f }, { "vnclip.wv", 0xbc000057, 0xfc00707f }, { "vwredsumu.vs", 0xc0000057, 0xfc00707f }, { "vwredsum.vs", 0xc4000057, 0xfc00707f }, { "vadd.vi", 0x00003057, 0xfc00707f }, { "vrsub.vi", 0x0c003057, 0xfc00707f }, { "vand.vi", 0x24003057, 0xfc00707f }, { "vor.vi", 0x28003057, 0xfc00707f }, { "vxor.vi", 0x2c003057, 0xfc00707f }, { "vrgather.vi", 0x30003057, 0xfc00707f }, { "vslideup.vi", 0x38003057, 0xfc00707f }, { "vslidedown.vi", 0x3c003057, 0xfc00707f }, { "vadc.vim", 0x40003057, 0xfe00707f }, { "vmadc.vim", 0x44003057, 0xfe00707f }, { "vmadc.vi", 0x46003057, 0xfe00707f }, { "vmerge.vim", 0x5c003057, 0xfe00707f }, { "vmv.v.i", 0x5e003057, 0xfff0707f }, { "vmseq.vi", 0x60003057, 0xfc00707f }, { "vmsne.vi", 0x64003057, 0xfc00707f }, { "vmsleu.vi", 0x70003057, 0xfc00707f }, { "vmsle.vi", 0x74003057, 0xfc00707f }, { "vmsgtu.vi", 0x78003057, 0xfc00707f }, { "vmsgt.vi", 0x7c003057, 0xfc00707f }, { "vsaddu.vi", 0x80003057, 0xfc00707f }, { "vsadd.vi", 0x84003057, 0xfc00707f }, { "vsll.vi", 0x94003057, 0xfc00707f }, { "vmv1r.v", 0x9e003057, 0xfe0ff07f }, { "vmv2r.v", 0x9e00b057, 0xfe0ff07f }, { "vmv4r.v", 0x9e01b057, 0xfe0ff07f }, { "vmv8r.v", 0x9e03b057, 0xfe0ff07f }, { "vsrl.vi", 0xa0003057, 0xfc00707f }, { "vsra.vi", 0xa4003057, 0xfc00707f }, { "vssrl.vi", 0xa8003057, 0xfc00707f }, { "vssra.vi", 0xac003057, 0xfc00707f }, { "vnsrl.wi", 0xb0003057, 0xfc00707f }, { "vnsra.wi", 0xb4003057, 0xfc00707f }, { "vnclipu.wi", 0xb8003057, 0xfc00707f }, { "vnclip.wi", 0xbc003057, 0xfc00707f }, { "vredsum.vs", 0x00002057, 0xfc00707f }, { "vredand.vs", 0x04002057, 0xfc00707f }, { "vredor.vs", 0x08002057, 0xfc00707f }, { "vredxor.vs", 0x0c002057, 0xfc00707f }, { "vredminu.vs", 0x10002057, 0xfc00707f }, { "vredmin.vs", 0x14002057, 0xfc00707f }, { "vredmaxu.vs", 0x18002057, 0xfc00707f }, { "vredmax.vs", 0x1c002057, 0xfc00707f }, { "vaaddu.vv", 0x20002057, 0xfc00707f }, { "vaadd.vv", 0x24002057, 0xfc00707f }, { "vasubu.vv", 0x28002057, 0xfc00707f }, { "vasub.vv", 0x2c002057, 0xfc00707f }, { "vmv.x.s", 0x42002057, 0xfe0ff07f }, { "vzext.vf8", 0x48012057, 0xfc0ff07f }, { "vsext.vf8", 0x4801a057, 0xfc0ff07f }, { "vzext.vf4", 0x48022057, 0xfc0ff07f }, { "vsext.vf4", 0x4802a057, 0xfc0ff07f }, { "vzext.vf2", 0x48032057, 0xfc0ff07f }, { "vsext.vf2", 0x4803a057, 0xfc0ff07f }, { "vcompress.vm", 0x5e002057, 0xfe00707f }, { "vmandn.mm", 0x62002057, 0xfe00707f }, { "vmand.mm", 0x66002057, 0xfe00707f }, { "vmor.mm", 0x6a002057, 0xfe00707f }, { "vmxor.mm", 0x6e002057, 0xfe00707f }, { "vmorn.mm", 0x72002057, 0xfe00707f }, { "vmnand.mm", 0x76002057, 0xfe00707f }, { "vmnor.mm", 0x7a002057, 0xfe00707f }, { "vmxnor.mm", 0x7e002057, 0xfe00707f }, { "vmsbf.m", 0x5000a057, 0xfc0ff07f }, { "vmsof.m", 0x50012057, 0xfc0ff07f }, { "vmsif.m", 0x5001a057, 0xfc0ff07f }, { "viota.m", 0x50082057, 0xfc0ff07f }, { "vid.v", 0x5008a057, 0xfdfff07f }, { "vcpop.m", 0x40082057, 0xfc0ff07f }, { "vfirst.m", 0x4008a057, 0xfc0ff07f }, { "vdivu.vv", 0x80002057, 0xfc00707f }, { "vdiv.vv", 0x84002057, 0xfc00707f }, { "vremu.vv", 0x88002057, 0xfc00707f }, { "vrem.vv", 0x8c002057, 0xfc00707f }, { "vmulhu.vv", 0x90002057, 0xfc00707f }, { "vmul.vv", 0x94002057, 0xfc00707f }, { "vmulhsu.vv", 0x98002057, 0xfc00707f }, { "vmulh.vv", 0x9c002057, 0xfc00707f }, { "vmadd.vv", 0xa4002057, 0xfc00707f }, { "vnmsub.vv", 0xac002057, 0xfc00707f }, { "vmacc.vv", 0xb4002057, 0xfc00707f }, { "vnmsac.vv", 0xbc002057, 0xfc00707f }, { "vwaddu.vv", 0xc0002057, 0xfc00707f }, { "vwadd.vv", 0xc4002057, 0xfc00707f }, { "vwsubu.vv", 0xc8002057, 0xfc00707f }, { "vwsub.vv", 0xcc002057, 0xfc00707f }, { "vwaddu.wv", 0xd0002057, 0xfc00707f }, { "vwadd.wv", 0xd4002057, 0xfc00707f }, { "vwsubu.wv", 0xd8002057, 0xfc00707f }, { "vwsub.wv", 0xdc002057, 0xfc00707f }, { "vwmulu.vv", 0xe0002057, 0xfc00707f }, { "vwmulsu.vv", 0xe8002057, 0xfc00707f }, { "vwmul.vv", 0xec002057, 0xfc00707f }, { "vwmaccu.vv", 0xf0002057, 0xfc00707f }, { "vwmacc.vv", 0xf4002057, 0xfc00707f }, { "vwmaccsu.vv", 0xfc002057, 0xfc00707f }, { "vaaddu.vx", 0x20006057, 0xfc00707f }, { "vaadd.vx", 0x24006057, 0xfc00707f }, { "vasubu.vx", 0x28006057, 0xfc00707f }, { "vasub.vx", 0x2c006057, 0xfc00707f }, { "vmv.s.x", 0x42006057, 0xfff0707f }, { "vslide1up.vx", 0x38006057, 0xfc00707f }, { "vslide1down.vx", 0x3c006057, 0xfc00707f }, { "vdivu.vx", 0x80006057, 0xfc00707f }, { "vdiv.vx", 0x84006057, 0xfc00707f }, { "vremu.vx", 0x88006057, 0xfc00707f }, { "vrem.vx", 0x8c006057, 0xfc00707f }, { "vmulhu.vx", 0x90006057, 0xfc00707f }, { "vmul.vx", 0x94006057, 0xfc00707f }, { "vmulhsu.vx", 0x98006057, 0xfc00707f }, { "vmulh.vx", 0x9c006057, 0xfc00707f }, { "vmadd.vx", 0xa4006057, 0xfc00707f }, { "vnmsub.vx", 0xac006057, 0xfc00707f }, { "vmacc.vx", 0xb4006057, 0xfc00707f }, { "vnmsac.vx", 0xbc006057, 0xfc00707f }, { "vwaddu.vx", 0xc0006057, 0xfc00707f }, { "vwadd.vx", 0xc4006057, 0xfc00707f }, { "vwsubu.vx", 0xc8006057, 0xfc00707f }, { "vwsub.vx", 0xcc006057, 0xfc00707f }, { "vwaddu.wx", 0xd0006057, 0xfc00707f }, { "vwadd.wx", 0xd4006057, 0xfc00707f }, { "vwsubu.wx", 0xd8006057, 0xfc00707f }, { "vwsub.wx", 0xdc006057, 0xfc00707f }, { "vwmulu.vx", 0xe0006057, 0xfc00707f }, { "vwmulsu.vx", 0xe8006057, 0xfc00707f }, { "vwmul.vx", 0xec006057, 0xfc00707f }, { "vwmaccu.vx", 0xf0006057, 0xfc00707f }, { "vwmacc.vx", 0xf4006057, 0xfc00707f }, { "vwmaccus.vx", 0xf8006057, 0xfc00707f }, { "vwmaccsu.vx", 0xfc006057, 0xfc00707f }, { "vandn.vv", 0x04000057, 0xfc00707f }, { "vandn.vx", 0x04004057, 0xfc00707f }, { "vbrev.v", 0x48052057, 0xfc0ff07f }, { "vbrev8.v", 0x48042057, 0xfc0ff07f }, { "vrev8.v", 0x4804a057, 0xfc0ff07f }, { "vclz.v", 0x48062057, 0xfc0ff07f }, { "vctz.v", 0x4806a057, 0xfc0ff07f }, { "vcpop.v", 0x48072057, 0xfc0ff07f }, { "vrol.vv", 0x54000057, 0xfc00707f }, { "vrol.vx", 0x54004057, 0xfc00707f }, { "vror.vv", 0x50000057, 0xfc00707f }, { "vror.vx", 0x50004057, 0xfc00707f }, { "vror.vi", 0x50003057, 0xf800707f }, { "vwsll.vv", 0xd4000057, 0xfc00707f }, { "vwsll.vx", 0xd4004057, 0xfc00707f }, { "vwsll.vi", 0xd4003057, 0xfc00707f }, }; /* Return an element mask without a shift by the host word width. */ static u64 vector_mask(u32 bits) { return bits == 64 ? ~0ULL : (1ULL << bits) - 1; } /* Sign-extend an element to the host word width. */ static i64 vector_signed(u64 value, u32 bits) { u64 sign = 1ULL << (bits - 1); return (i64)((value ^ sign) - sign); } /* Read an element from a validated register group. */ static u64 vector_get(const struct vector_state *v, u32 r, u32 i, u32 bits) { u64 value = 0; u32 offset = r * VECTOR_BYTES + i * (bits / 8); for (u32 j = 0; j < bits / 8; j++) value |= (u64)((const u8 *)v->reg)[offset + j] << (8 * j); return value; } /* Write an element to a validated register group. */ static void vector_put( struct vector_state *v, u32 r, u32 i, u32 bits, u64 value ) { u32 offset = r * VECTOR_BYTES + i * (bits / 8); for (u32 j = 0; j < bits / 8; j++) ((u8 *)v->reg)[offset + j] = value >> (8 * j); } /* Read a packed mask bit. */ static bool vector_bit(const struct vector_state *v, u32 r, u32 i) { return (v->reg[r][i / 8] >> (i % 8)) & 1; } /* Write a packed mask bit. */ static void vector_set_bit(struct vector_state *v, u32 r, u32 i, bool bit) { u8 mask = 1u << (i % 8); v->reg[r][i / 8] = (v->reg[r][i / 8] & ~mask) | (bit ? mask : 0); } /* Check register group alignment and architectural bounds. */ static bool vector_group(u32 reg, u32 bytes) { u32 count = (bytes + VECTOR_BYTES - 1) / VECTOR_BYTES; return bytes >= VECTOR_BYTES / 8 && count && count <= 8 && reg + count <= 32 && reg % count == 0; } /* Process one register per host vector. memcpy permits unaligned registers. * Each lane has an unsigned element type so arithmetic wraps at SEW. */ #define VECTOR_NATIVE(bits) \ static bool vector_native##bits( \ struct vector_state *v, u64 x[32], u32 ins, u32 fn \ ) { \ typedef u##bits uv __attribute__((vector_size(VECTOR_BYTES))); \ typedef i##bits sv __attribute__((vector_size(VECTOR_BYTES))); \ typedef u8 bv __attribute__((vector_size(VECTOR_BYTES))); \ u32 d = (ins >> 7) & 31, s1 = (ins >> 15) & 31; \ u32 s2 = (ins >> 20) & 31, form = (ins >> 12) & 7; \ bool vm = (ins >> 25) & 1; \ u32 lanes = VECTOR_BYTES * 8 / bits; \ u64 scalar = form == 3 ? (u64)vector_signed(s1, 5) : x[s1]; \ if (form == 3 && fn >= 20 && fn <= 22) \ scalar = s1 | ((ins >> 21) & 32); \ if (form == 3 && (fn == 37 || fn == 40 || fn == 41)) \ scalar = s1; \ uv splat; \ for (u32 j = 0; j < lanes; j++) \ splat[j] = scalar; \ for (u32 i = v->vstart / lanes * lanes; i < v->vl; i += lanes) { \ u32 off = i * (bits / 8); \ uv a, b = splat, old, z; \ memcpy(&a, (u8 *)v->reg + s2 * VECTOR_BYTES + off, sizeof(a)); \ memcpy(&old, (u8 *)v->reg + d * VECTOR_BYTES + off, sizeof(old)); \ if (form == 0 || (form == 2 && fn >= 96)) \ memcpy(&b, (u8 *)v->reg + s1 * VECTOR_BYTES + off, sizeof(b)); \ uv n = b & (bits - 1), back = -n & (bits - 1); \ switch (fn) { \ case 0: \ z = a + b; \ break; \ case 1: \ z = a & ~b; \ break; \ case 2: \ z = a - b; \ break; \ case 3: \ z = b - a; \ break; \ case 4: \ z = __builtin_elementwise_min(a, b); \ break; \ case 5: \ z = (uv)__builtin_elementwise_min((sv)a, (sv)b); \ break; \ case 6: \ z = __builtin_elementwise_max(a, b); \ break; \ case 7: \ z = (uv)__builtin_elementwise_max((sv)a, (sv)b); \ break; \ case 9: \ z = a & b; \ break; \ case 10: \ z = a | b; \ break; \ case 11: \ z = a ^ b; \ break; \ case 20: \ case 22: \ z = (a >> n) | (a << back); \ break; \ case 21: \ z = form == 3 ? (a >> n) | (a << back) \ : (a << n) | (a >> back); \ break; \ case 23: \ if (!vm) \ return false; \ z = b; \ break; \ case 37: \ z = a << n; \ break; \ case 40: \ z = a >> n; \ break; \ case 41: \ z = (uv)((sv)a >> n); \ break; \ case 72: \ z = (uv)__builtin_elementwise_bitreverse((bv)a); \ break; \ case 73: \ z = (uv)__builtin_elementwise_bitreverse((bv)a); \ z = __builtin_elementwise_bitreverse(z); \ break; \ case 74: \ z = __builtin_elementwise_bitreverse(a); \ break; \ case 76: \ z = __builtin_elementwise_clzg(a, (a ^ a) + bits); \ break; \ case 77: \ z = __builtin_elementwise_ctzg(a, (a ^ a) + bits); \ break; \ case 78: \ z = __builtin_elementwise_popcount(a); \ break; \ case 101: \ z = a * b; \ break; \ case 105: \ z = b * old + a; \ break; \ case 107: \ z = a - b * old; \ break; \ case 109: \ z = a * b + old; \ break; \ case 111: \ z = old - a * b; \ break; \ default: \ return false; \ } \ if (!vm || i < v->vstart || v->vl - i < lanes) { \ uv mask; \ for (u32 j = 0; j < lanes; j++) \ mask[j] = i + j >= v->vstart && i + j < v->vl && \ (vm || vector_bit(v, 0, i + j)) \ ? (u##bits) ~0ULL \ : 0; \ z = (z & mask) | (old & ~mask); \ } \ memcpy((u8 *)v->reg + d * VECTOR_BYTES + off, &z, sizeof(z)); \ } \ v->vstart = 0; \ return true; \ } VECTOR_NATIVE(8) VECTOR_NATIVE(16) VECTOR_NATIVE(32) VECTOR_NATIVE(64) #undef VECTOR_NATIVE /* Select lane-wise operations after architectural operand validation. * Host vectors use the register file's little-endian element layout. */ static bool vector_native(struct vector_state *v, u64 x[32], u32 ins, u32 sew) { #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ u32 form = (ins >> 12) & 7, fn = ins >> 26; if (form == 2 || form == 6) { if (form == 2 && fn == 18) { u32 sel = (ins >> 15) & 31; if (sel != 8 && sel != 9 && sel != 10 && sel != 12 && sel != 13 && sel != 14) return false; fn = 64 + sel; } else if (fn == 37 || fn == 41 || fn == 43 || fn == 45 || fn == 47) fn += 64; else return false; } else if (form == 0 || form == 3 || form == 4) { switch (fn) { case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 9: case 10: case 11: case 20: case 21: case 22: case 37: case 40: case 41: break; case 23: if (!((ins >> 25) & 1)) return false; break; default: return false; } } else return false; switch (sew) { case 8: return vector_native8(v, x, ins, fn); case 16: return vector_native16(v, x, ins, fn); case 32: return vector_native32(v, x, ins, fn); case 64: return vector_native64(v, x, ins, fn); } #endif return false; } /* Fixed-point rounding increment for a right shift. */ static u64 vector_round(u64 value, u32 shift, u32 mode) { if (!shift) return 0; u64 low = value & vector_mask(shift); bool high = (value >> (shift - 1)) & 1; switch (mode) { case 0: return high; case 1: return high && ((low & vector_mask(shift - 1)) || ((value >> shift) & 1)); case 2: return 0; default: return low && !((value >> shift) & 1); } } /* Read or write a vector CSR. */ bool vector_csr(struct vector_state *v, u32 ins, u64 x[32]) { u32 csr = ins >> 20, f3 = (ins >> 12) & 7, rd = (ins >> 7) & 31, rs = (ins >> 15) & 31; u64 old; switch (csr) { case 8: old = v->vstart; break; case 9: old = v->vxsat; break; case 10: old = v->vxrm; break; case 15: old = v->vxrm * 2 + v->vxsat; break; case 0xc20: old = v->vl; break; case 0xc21: old = v->vtype; break; case 0xc22: old = VECTOR_BYTES; break; default: return false; } if (!(f3 & 3)) return false; u64 value = (f3 & 4) ? rs : x[rs]; bool write = (f3 & 3) == 1 || rs; if (write && csr >= 0xc00) return false; if (write) { if ((f3 & 3) == 2) value = old | value; if ((f3 & 3) == 3) value = old & ~value; switch (csr) { case 8: v->vstart = value & (VECTOR_BYTES * 8 - 1); break; case 9: v->vxsat = value & 1; break; case 10: v->vxrm = value & 3; break; case 15: v->vxrm = (value >> 1) & 3; v->vxsat = value & 1; break; } } if (rd) x[rd] = old; return true; } /* Execute one integer vector instruction. Inactive and tail elements are * preserved. Faulting memory operations retain the first uncompleted index. */ enum vector_result vector_execute( struct vector_state *v, u64 x[32], u32 ins, vector_memory memory, void *ctx ) { u32 op = ins & 127, f3 = (ins >> 12) & 7, d = (ins >> 7) & 31, s1 = (ins >> 15) & 31, s2 = (ins >> 20) & 31; if (op == 0x73) return vector_csr(v, ins, x) ? VECTOR_OK : VECTOR_ILLEGAL; const char *name = NULL; for (u32 j = 0; j < sizeof(vector_opcodes) / sizeof(vector_opcodes[0]); j++) if ((ins & vector_opcodes[j].mask) == vector_opcodes[j].value) { name = vector_opcodes[j].name; break; } if (!name) return VECTOR_ILLEGAL; if (op == 0x57 && f3 == 7) { u64 type, avl; if ((ins >> 30) == 3) { type = (ins >> 20) & 1023; avl = s1; } else { type = (ins >> 31) ? x[s2] : (ins >> 20) & 2047; avl = s1 ? x[s1] : d ? ~0ULL : v->vl; } u32 sew = 8u << ((type >> 3) & 7), lm = type & 7; bool invalid = (type & ~255ULL) || sew > 64 || lm == 4; u32 bytes = lm < 4 ? VECTOR_BYTES << lm : VECTOR_BYTES >> (8 - lm); if (bytes * 8 < sew) invalid = true; u64 max = invalid ? 0 : bytes * 8 / sew; if (!s1 && !d && (ins >> 30) != 3 && !invalid) { u32 oldlm = v->vtype & 7, oldsew = 8u << ((v->vtype >> 3) & 7); u32 oldbytes = oldlm < 4 ? VECTOR_BYTES << oldlm : VECTOR_BYTES >> (8 - oldlm); if ((v->vtype >> 63) || oldbytes * 8 / oldsew != max) return VECTOR_ILLEGAL; } v->vtype = invalid ? 1ULL << 63 : type; v->vl = invalid ? 0 : avl < max ? avl : max; v->vstart = 0; if (d) x[d] = v->vl; return VECTOR_OK; } u32 fn = ins >> 26; u32 sew = 8u << ((v->vtype >> 3) & 7), lm = v->vtype & 7; bool independent = ((op == 7 || op == 39) && ((ins >> 26) & 3) == 0 && s2 == 8) || (op == 0x57 && f3 == 3 && fn == 0x27); if (v->vtype >> 63 || sew > 64 || lm == 4) { if (!independent) return VECTOR_ILLEGAL; sew = 8; lm = 0; } u32 bytes = lm < 4 ? VECTOR_BYTES << lm : VECTOR_BYTES >> (8 - lm); u32 max = bytes * 8 / sew; bool unmasked = (ins >> 25) & 1; if (op == 7 || op == 39) { struct vector_state source = *v; bool store = op == 39; u32 mode = (ins >> 26) & 3, fields = (ins >> 29) + 1; u32 width = f3 == 0 ? 8 : f3 == 5 ? 16 : f3 == 6 ? 32 : f3 == 7 ? 64 : 0; if (!width) return VECTOR_ILLEGAL; u32 eb = mode & 1 ? sew : width, group = bytes * eb / sew; u32 step = (group + VECTOR_BYTES - 1) / VECTOR_BYTES; bool whole = mode == 0 && s2 == 8, mask = mode == 0 && s2 == 11; u32 count = v->vl; if (whole) { group = VECTOR_BYTES; step = 1; eb = width; count = fields * VECTOR_BYTES / (eb / 8); fields = 1; } if (mask) { group = VECTOR_BYTES; step = 1; eb = 8; count = (v->vl + 7) / 8; } if (whole) { u32 n = (ins >> 29) + 1; if ((n != 1 && n != 2 && n != 4 && n != 8) || d % n || d + n > 32) return VECTOR_ILLEGAL; } else if ( !vector_group(d, group) || d + fields * step > 32 || fields * group > 8 * VECTOR_BYTES ) return VECTOR_ILLEGAL; if ((mode & 1) && !vector_group(s2, bytes * width / sew)) return VECTOR_ILLEGAL; if ((mode & 1) && !store) { u32 index_count = (bytes * width / sew + VECTOR_BYTES - 1) / VECTOR_BYTES; if (d < s2 + index_count && s2 < d + fields * step) return VECTOR_ILLEGAL; } if (!unmasked && !store && d == 0) return VECTOR_ILLEGAL; for (u32 i = v->vstart; i < count; i++) { if (!whole && !mask && !unmasked && !vector_bit(&source, 0, i)) continue; u64 stride = mode == 2 ? x[s2] : fields * (eb / 8); u64 offset = (mode & 1) ? vector_get(&source, s2, i, width) : (u64)i * stride; for (u32 field = 0; field < fields; field++) { u32 reg = d + field * step; u64 address = x[s1] + offset + field * (eb / 8); u64 value = store ? vector_get(&source, reg, i, eb) : 0; if (!memory(ctx, address, eb / 8, store, &value)) { if (!store && mode == 0 && s2 == 16 && i > 0) { v->vl = i; v->vstart = 0; return VECTOR_OK; } v->vstart = i; return VECTOR_FAULT; } if (!store) vector_put(v, reg, i, eb, value); } } v->vstart = 0; return VECTOR_OK; } if (f3 == 3 && fn == 0x27) { struct vector_state source = *v; u32 count = s1 + 1; if ((count != 1 && count != 2 && count != 4 && count != 8) || d % count || s2 % count || d + count > 32 || s2 + count > 32) return VECTOR_ILLEGAL; for (u32 i = v->vstart; i < count * VECTOR_BYTES * 8 / sew; i++) vector_put(v, d, i, sew, vector_get(&source, s2, i, sew)); v->vstart = 0; return VECTOR_OK; } bool maskdest = (f3 == 0 || f3 == 3 || f3 == 4) && fn >= 0x18 && fn <= 0x1f; bool masklogic = f3 == 2 && fn >= 0x18 && fn <= 0x1f; bool wide_reduction = f3 == 0 && (fn == 0x30 || fn == 0x31); bool reduction = (f3 == 2 && fn <= 7) || wide_reduction; bool widening = ((f3 == 2 || f3 == 6) && fn >= 0x30) || ((f3 == 0 || f3 == 3 || f3 == 4) && fn == 0x35); bool narrowing = (f3 == 0 || f3 == 3 || f3 == 4) && fn >= 0x2c && fn <= 0x2f; bool wide_source = (f3 == 2 || f3 == 6) && fn >= 0x34 && fn <= 0x37; u32 dbits = (widening || wide_reduction) ? sew * 2 : sew, sbits = (narrowing || wide_source) ? sew * 2 : sew; if (dbits > 64 || sbits > 64) return VECTOR_ILLEGAL; bool scalarout = f3 == 2 && fn == 0x10; bool scalarin = f3 == 6 && fn == 0x10; bool mask_prefix = f3 == 2 && fn == 0x14 && s1 <= 3; if (scalarout && s1 != 0 && v->vstart) return VECTOR_ILLEGAL; bool mask_source = f3 == 2 && (fn == 0x14 || fn == 0x10); bool extension = f3 == 2 && fn == 0x12 && s1 >= 2 && s1 <= 7; u32 srcbytes = bytes * sbits / sew, dstbytes = bytes * dbits / sew; if (scalarin) dstbytes = VECTOR_BYTES; if (extension) { u32 factor = 1u << (4 - s1 / 2); if (sew / factor < 8) return VECTOR_ILLEGAL; srcbytes = bytes / factor; sbits = sew / factor; } if (mask_source || masklogic) srcbytes = VECTOR_BYTES; u32 src1bytes = (f3 == 0 && fn == 14) ? bytes * 16 / sew : bytes; bool vector_source1 = (f3 == 0 || f3 == 2) && !scalarout && !mask_source && !extension && !(f3 == 2 && fn == 0x12); if (reduction || masklogic || (f3 == 2 && fn == 0x17)) src1bytes = VECTOR_BYTES; if (!maskdest && !masklogic && !mask_prefix && !scalarout && !reduction && !vector_group(d, dstbytes)) return VECTOR_ILLEGAL; if (!vector_group(s2, srcbytes)) return VECTOR_ILLEGAL; if (vector_source1 && !vector_group(s1, src1bytes)) return VECTOR_ILLEGAL; if (!unmasked && d == 0 && !maskdest && !scalarout && !reduction) return VECTOR_ILLEGAL; if ((reduction || (f3 == 2 && ((fn == 0x14 && s1 != 17) || fn == 0x17))) && v->vstart) return VECTOR_ILLEGAL; u32 dn = (maskdest || masklogic || mask_prefix || reduction) ? 1 : (dstbytes + VECTOR_BYTES - 1) / VECTOR_BYTES; u32 sn = (srcbytes + VECTOR_BYTES - 1) / VECTOR_BYTES; u32 s1n = (src1bytes + VECTOR_BYTES - 1) / VECTOR_BYTES; bool overlap2 = d < s2 + sn && s2 < d + dn; bool overlap1 = vector_source1 && d < s1 + s1n && s1 < d + dn; if (f3 == 2 && fn == 0x14 && s1 != 17 && overlap2) return VECTOR_ILLEGAL; bool gather = (f3 == 0 || f3 == 3 || f3 == 4) && (fn == 12 || (fn == 14 && f3 == 0)); bool slideup = fn == 14 && (f3 == 3 || f3 == 4 || f3 == 6); if (maskdest && ((overlap2 && d != s2) || (overlap1 && d != s1))) return VECTOR_ILLEGAL; if (gather && (overlap2 || overlap1)) return VECTOR_ILLEGAL; if (slideup && overlap2) return VECTOR_ILLEGAL; if (f3 == 2 && fn == 0x17 && (overlap2 || (d <= s1 && s1 < d + dn) || !unmasked)) return VECTOR_ILLEGAL; if (widening && overlap2 && (srcbytes < VECTOR_BYTES || s2 + sn != d + dn)) return VECTOR_ILLEGAL; if (widening && overlap1 && (src1bytes < VECTOR_BYTES || s1 + s1n != d + dn)) return VECTOR_ILLEGAL; if (narrowing && overlap2 && d != s2) return VECTOR_ILLEGAL; if (extension && overlap2 && (srcbytes < VECTOR_BYTES || s2 + sn != d + dn)) return VECTOR_ILLEGAL; if (vector_native(v, x, ins, sew)) return VECTOR_OK; struct vector_state source = *v; u64 acc = vector_get(&source, s1, 0, wide_reduction ? dbits : sew), population = 0, first = ~0ULL; u32 compressed = 0; bool found = false; if (scalarout && s1 == 0) { if (d) x[d] = (u64)vector_signed(vector_get(&source, s2, 0, sew), sew); v->vstart = 0; return VECTOR_OK; } if (f3 == 6 && fn == 0x10) { if (v->vl && !v->vstart) vector_put(v, d, 0, sew, x[s1]); v->vstart = 0; return VECTOR_OK; } for (u32 i = v->vstart; i < v->vl; i++) { bool active = unmasked || vector_bit(&source, 0, i), carry = vector_bit(&source, 0, i); bool maskop = (f3 == 0 || f3 == 3 || f3 == 4) && ((fn >= 0x10 && fn <= 0x13) || fn == 0x17); if (!active && !maskop) continue; u64 a = (mask_source || masklogic) ? 0 : vector_get(&source, s2, i, sbits), b; if (f3 == 3) b = (u64)vector_signed(s1, 5); else if (f3 == 4 || f3 == 6) b = x[s1]; else if ( !vector_source1 || masklogic || reduction || (f3 == 2 && fn == 0x17) ) b = 0; else b = vector_get(&source, s1, i, (f3 == 0 && fn == 14) ? 16 : sew); if (f3 == 3 && (fn == 12 || fn == 14 || fn == 15 || fn == 37 || fn >= 40)) b = s1; b &= vector_mask(sew); i64 sa = vector_signed(a, sbits), sb = vector_signed(b, sew); u32 shift = b & (sew - 1); u64 z = 0; bool bit = false; if (masklogic) { bool a = vector_bit(&source, s2, i), b = vector_bit(&source, s1, i); switch (fn) { case 0x18: bit = a && !b; break; case 0x19: bit = a && b; break; case 0x1a: bit = a || b; break; case 0x1b: bit = a != b; break; case 0x1c: bit = a || !b; break; case 0x1d: bit = !(a && b); break; case 0x1e: bit = !(a || b); break; case 0x1f: bit = a == b; break; } vector_set_bit(v, d, i, bit); continue; } if (reduction) { if (wide_reduction) { acc += fn == 0x31 ? (u64)sa : a; continue; } switch (fn) { case 0: acc += a; break; case 1: acc &= a; break; case 2: acc |= a; break; case 3: acc ^= a; break; case 4: if (a < acc) acc = a; break; case 5: if (sa < vector_signed(acc, sew)) acc = a; break; case 6: if (a > acc) acc = a; break; case 7: if (sa > vector_signed(acc, sew)) acc = a; break; } continue; } if (scalarout) { if (vector_bit(&source, s2, i)) { population++; if (first == ~0ULL) first = i; } continue; } if (f3 == 2 && fn == 0x14) { bool selected = vector_bit(&source, s2, i); if (s1 == 16) z = population; else if (s1 == 17) z = i; else { bit = s1 == 1 ? !found && !selected : s1 == 2 ? !found && selected : !found; vector_set_bit(v, d, i, bit); } if (selected) { population++; found = true; } if (s1 <= 3) continue; } else if (f3 == 2 && fn == 0x17) { if (vector_bit(&source, s1, i)) vector_put(v, d, compressed++, sew, a); continue; } else if (f3 == 2 && fn == 0x12) { if (s1 >= 2 && s1 <= 7) { u32 bits = sew >> (4 - s1 / 2); if (bits < 8) return VECTOR_ILLEGAL; z = vector_get(&source, s2, i, bits); if (s1 & 1) z = vector_signed(z, bits); } else if (s1 == 8 || s1 == 9 || s1 == 10) { for (u32 j = 0; j < sew; j++) { u32 dst = s1 == 10 ? sew - 1 - j : s1 == 8 ? (j & ~7) + (7 - j % 8) : sew - 8 - (j & ~7) + j % 8; z |= ((a >> j) & 1) << dst; } } else if (s1 == 12) { z = a ? (u32)__builtin_clzll(a) - (64 - sew) : sew; } else if (s1 == 13) { z = a ? __builtin_ctzll(a) : sew; } else if (s1 == 14) { z = __builtin_popcountll(a); } else return VECTOR_ILLEGAL; } else if (f3 == 0 || f3 == 3 || f3 == 4) { switch (fn) { case 0: z = a + b; break; case 1: z = a & ~b; break; case 2: z = a - b; break; case 3: z = b - a; break; case 4: z = a < b ? a : b; break; case 5: z = sa < sb ? a : b; break; case 6: z = a > b ? a : b; break; case 7: z = sa > sb ? a : b; break; case 9: z = a & b; break; case 10: z = a | b; break; case 11: z = a ^ b; break; case 12: { u64 index = f3 == 3 ? s1 : f3 == 4 ? x[s1] : b; z = index < max ? vector_get(&source, s2, index, sew) : 0; break; } case 14: { if (f3 == 0) { u64 index = vector_get(&source, s1, i, 16); z = index < max ? vector_get(&source, s2, index, sew) : 0; break; } u64 amount = f3 == 3 ? s1 : x[s1]; if (i < amount) continue; z = vector_get(&source, s2, i - amount, sew); break; } case 15: { u64 amount = f3 == 3 ? s1 : x[s1]; z = amount < max && i < max - amount ? vector_get(&source, s2, i + amount, sew) : 0; break; } case 16: case 17: { __uint128_t sum = (__uint128_t)a + b + (!unmasked && carry); z = (u64)sum; bit = (sum >> sew) & 1; if (fn == 17) { vector_set_bit(v, d, i, bit); continue; } break; } case 18: case 19: { u64 c = !unmasked && carry; z = a - b - c; bit = a < b || (a == b && c); if (fn == 19) { vector_set_bit(v, d, i, bit); continue; } break; } case 20: case 21: case 22: { u32 n = f3 == 3 ? ((ins >> 15) & 31) | ((ins >> 21) & 32) : shift; n &= sew - 1; bool left = fn == 21 && f3 != 3; z = !n ? a : left ? (a << n) | (a >> (sew - n)) : (a >> n) | (a << (sew - n)); break; } case 23: z = unmasked ? b : carry ? b : a; break; case 24: bit = a == b; break; case 25: bit = a != b; break; case 26: bit = a < b; break; case 27: bit = sa < sb; break; case 28: bit = a <= b; break; case 29: bit = sa <= sb; break; case 30: bit = a > b; break; case 31: bit = sa > sb; break; case 32: { __uint128_t sum = (__uint128_t)a + b; u64 limit = vector_mask(sew); if (sum > limit) { z = limit; v->vxsat = 1; } else z = sum; break; } case 33: case 35: { __int128 sum = fn == 33 ? (__int128)sa + sb : (__int128)sa - sb; __int128 limit = (__int128)1 << (sew - 1); if (sum >= limit) { sum = limit - 1; v->vxsat = 1; } if (sum < -limit) { sum = -limit; v->vxsat = 1; } z = sum; break; } case 34: if (a < b) { z = 0; v->vxsat = 1; } else z = a - b; break; case 37: z = a << shift; break; case 39: { __int128 product = (__int128)sa * sb; u64 raw = (u64)product; __int128 result = (product >> (sew - 1)) + vector_round(raw, sew - 1, v->vxrm); __int128 limit = (__int128)1 << (sew - 1); if (result >= limit) { result = limit - 1; v->vxsat = 1; } z = result; break; } case 40: z = a >> shift; break; case 41: z = sa >> shift; break; case 42: z = (a >> shift) + vector_round(a, shift, v->vxrm); break; case 43: z = (sa >> shift) + vector_round(a, shift, v->vxrm); break; case 44: z = a >> (b & (sbits - 1)); break; case 45: z = sa >> (b & (sbits - 1)); break; case 46: case 47: { u32 n = b & (sbits - 1); if (fn == 46) { z = (a >> n) + vector_round(a, n, v->vxrm); if (z > vector_mask(sew)) { z = vector_mask(sew); v->vxsat = 1; } } else { i64 t = (sa >> n) + vector_round(a, n, v->vxrm); i64 hi = (i64)(1ULL << (sew - 1)) - 1, lo = -hi - 1; if (t > hi) { t = hi; v->vxsat = 1; } if (t < lo) { t = lo; v->vxsat = 1; } z = t; } break; } case 53: z = a << (b & (dbits - 1)); break; default: return VECTOR_ILLEGAL; } } else if (f3 == 2 || f3 == 6) { u64 old = vector_get(&source, d, i, dbits); switch (fn) { case 8: case 9: case 10: case 11: { bool sign = fn & 1, sub = fn & 2; __int128 sum = sign ? (sub ? (__int128)sa - sb : (__int128)sa + sb) : (sub ? (__int128)a - b : (__int128)a + b); z = (sum >> 1) + vector_round((u64)sum, 1, v->vxrm); break; } case 14: if (i == 0) z = b; else z = vector_get(&source, s2, i - 1, sew); break; case 15: if (i + 1 == v->vl) z = b; else z = vector_get(&source, s2, i + 1, sew); break; case 32: z = b ? a / b : vector_mask(sew); break; case 33: if (!b) z = vector_mask(sew); else if ( sa == vector_signed(1ULL << (sew - 1), sew) && sb == -1 ) z = a; else z = sa / sb; break; case 34: z = b ? a % b : a; break; case 35: if (!b) z = a; else if (sb == -1) z = 0; else z = sa % sb; break; case 36: z = ((__uint128_t)a * b) >> sew; break; case 37: z = a * b; break; case 38: z = ((__int128)sa * b) >> sew; break; case 39: z = ((__int128)sa * sb) >> sew; break; case 41: z = b * old + a; break; case 43: z = -b * old + a; break; case 45: z = a * b + old; break; case 47: z = -a * b + old; break; case 48: case 49: case 50: case 51: case 52: case 53: case 54: case 55: { bool wide = fn >= 52, sign = fn & 1, sub = fn & 2; u64 aa = wide ? vector_get(&source, s2, i, dbits) : sign ? (u64)sa : a; u64 bb = sign ? (u64)sb : b; z = sub ? aa - bb : aa + bb; break; } case 56: z = a * b; break; case 58: z = sa * b; break; case 59: z = sa * sb; break; case 60: z = old + a * b; break; case 61: z = old + sa * sb; break; case 62: z = old + sa * b; break; case 63: z = old + a * sb; break; default: return VECTOR_ILLEGAL; } } else return VECTOR_ILLEGAL; if (maskdest) vector_set_bit(v, d, i, bit); else vector_put(v, d, i, dbits, z); } if (reduction && v->vl && source.vstart < v->vl) vector_put(v, d, 0, wide_reduction ? dbits : sew, acc); if (scalarout && d) x[d] = s1 == 16 ? population : first; v->vstart = 0; return VECTOR_OK; }