authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-03-18 15:27:08-04:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2022-03-18 15:27:08-04:00
logd5803441cd0c06d3fb7f11f5cb447c20e0d62d52
treec478deb5396dd9293bd028f8ddaa4aae44cc03ae
parente60c0468aaed9bae19ff40bcc163927e98aa2dd9
parente99b1b398a1a4c4fb6b5998b7bb5e29ff841c2a5
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #11220 from schmee/vector-bitreverse

stage2: implement `@bitReverse` for vectors

2 files changed, 124 insertions(+), 51 deletions(-)

src/Sema.zig+48-51
......@@ -13341,28 +13341,14 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1334113341 const target = sema.mod.getTarget();
1334213342 const dest_info = dest_scalar_ty.intInfo(target);
1334313343
13344 if (dest_info.bits == 0) {
13345 if (is_vector) {
13346 return sema.addConstant(
13347 dest_ty,
13348 try Value.Tag.repeated.create(sema.arena, Value.zero),
13349 );
13350 } else {
13351 return sema.addConstant(dest_ty, Value.zero);
13352 }
13344 if (try sema.typeHasOnePossibleValue(block, dest_ty_src, dest_ty)) |val| {
13345 return sema.addConstant(dest_ty, val);
1335313346 }
1335413347
1335513348 if (operand_scalar_ty.zigTypeTag() != .ComptimeInt) {
1335613349 const operand_info = operand_ty.intInfo(target);
13357 if (operand_info.bits == 0) {
13358 if (is_vector) {
13359 return sema.addConstant(
13360 dest_ty,
13361 try Value.Tag.repeated.create(sema.arena, Value.zero),
13362 );
13363 } else {
13364 return sema.addConstant(dest_ty, Value.zero);
13365 }
13350 if (try sema.typeHasOnePossibleValue(block, operand_src, operand_ty)) |val| {
13351 return sema.addConstant(operand_ty, val);
1336613352 }
1336713353
1336813354 if (operand_info.signedness != dest_info.signedness) {
......@@ -13461,15 +13447,9 @@ fn zirBitCount(
1346113447 _ = try checkIntOrVector(sema, block, operand, operand_src);
1346213448 const target = sema.mod.getTarget();
1346313449 const bits = operand_ty.intInfo(target).bits;
13464 if (bits == 0) {
13465 switch (operand_ty.zigTypeTag()) {
13466 .Vector => return sema.addConstant(
13467 try Type.vector(sema.arena, operand_ty.vectorLen(), Type.comptime_int),
13468 try Value.Tag.repeated.create(sema.arena, Value.zero),
13469 ),
13470 .Int => return Air.Inst.Ref.zero,
13471 else => unreachable,
13472 }
13450
13451 if (try sema.typeHasOnePossibleValue(block, operand_src, operand_ty)) |val| {
13452 return sema.addConstant(operand_ty, val);
1347313453 }
1347413454
1347513455 const result_scalar_ty = try Type.smallestUnsignedInt(sema.arena, bits);
......@@ -13528,10 +13508,12 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1352813508 );
1352913509 }
1353013510
13511 if (try sema.typeHasOnePossibleValue(block, operand_src, operand_ty)) |val| {
13512 return sema.addConstant(operand_ty, val);
13513 }
13514
1353113515 switch (operand_ty.zigTypeTag()) {
1353213516 .Int, .ComptimeInt => {
13533 if (bits == 0) return Air.Inst.Ref.zero;
13534
1353513517 const runtime_src = if (try sema.resolveMaybeUndefVal(block, operand_src, operand)) |val| {
1353613518 if (val.isUndef()) return sema.addConstUndef(operand_ty);
1353713519 const result_val = try val.byteSwap(operand_ty, target, sema.arena);
......@@ -13542,13 +13524,6 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1354213524 return block.addTyOp(.byte_swap, operand_ty, operand);
1354313525 },
1354413526 .Vector => {
13545 if (bits == 0) {
13546 return sema.addConstant(
13547 operand_ty,
13548 try Value.Tag.repeated.create(sema.arena, Value.zero),
13549 );
13550 }
13551
1355213527 const runtime_src = if (try sema.resolveMaybeUndefVal(block, operand_src, operand)) |val| {
1355313528 if (val.isUndef())
1355413529 return sema.addConstUndef(operand_ty);
......@@ -13575,28 +13550,50 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1357513550
1357613551fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
1357713552 const inst_data = sema.code.instructions.items(.data)[inst].un_node;
13578 const ty_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = inst_data.src_node };
1357913553 const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node };
1358013554 const operand = sema.resolveInst(inst_data.operand);
1358113555 const operand_ty = sema.typeOf(operand);
13582 // TODO implement support for vectors
13583 if (operand_ty.zigTypeTag() != .Int) {
13584 return sema.fail(block, ty_src, "expected integer type, found '{}'", .{
13585 operand_ty,
13586 });
13556 _ = try sema.checkIntOrVectorAllowComptime(block, operand, operand_src);
13557
13558 if (try sema.typeHasOnePossibleValue(block, operand_src, operand_ty)) |val| {
13559 return sema.addConstant(operand_ty, val);
1358713560 }
13561
1358813562 const target = sema.mod.getTarget();
13589 const bits = operand_ty.intInfo(target).bits;
13590 if (bits == 0) return Air.Inst.Ref.zero;
13563 switch (operand_ty.zigTypeTag()) {
13564 .Int, .ComptimeInt => {
13565 const runtime_src = if (try sema.resolveMaybeUndefVal(block, operand_src, operand)) |val| {
13566 if (val.isUndef()) return sema.addConstUndef(operand_ty);
13567 const result_val = try val.bitReverse(operand_ty, target, sema.arena);
13568 return sema.addConstant(operand_ty, result_val);
13569 } else operand_src;
1359113570
13592 const runtime_src = if (try sema.resolveMaybeUndefVal(block, operand_src, operand)) |val| {
13593 if (val.isUndef()) return sema.addConstUndef(operand_ty);
13594 const result_val = try val.bitReverse(operand_ty, target, sema.arena);
13595 return sema.addConstant(operand_ty, result_val);
13596 } else operand_src;
13571 try sema.requireRuntimeBlock(block, runtime_src);
13572 return block.addTyOp(.bit_reverse, operand_ty, operand);
13573 },
13574 .Vector => {
13575 const runtime_src = if (try sema.resolveMaybeUndefVal(block, operand_src, operand)) |val| {
13576 if (val.isUndef())
13577 return sema.addConstUndef(operand_ty);
1359713578
13598 try sema.requireRuntimeBlock(block, runtime_src);
13599 return block.addTyOp(.bit_reverse, operand_ty, operand);
13579 const vec_len = operand_ty.vectorLen();
13580 var elem_buf: Value.ElemValueBuffer = undefined;
13581 const elems = try sema.arena.alloc(Value, vec_len);
13582 for (elems) |*elem, i| {
13583 const elem_val = val.elemValueBuffer(i, &elem_buf);
13584 elem.* = try elem_val.bitReverse(operand_ty, target, sema.arena);
13585 }
13586 return sema.addConstant(
13587 operand_ty,
13588 try Value.Tag.aggregate.create(sema.arena, elems),
13589 );
13590 } else operand_src;
13591
13592 try sema.requireRuntimeBlock(block, runtime_src);
13593 return block.addTyOp(.bit_reverse, operand_ty, operand);
13594 },
13595 else => unreachable,
13596 }
1360013597}
1360113598
1360213599fn zirBitOffsetOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
test/behavior/bitreverse.zig+76
......@@ -87,3 +87,79 @@ fn testBitReverse() !void {
8787 var neg32: i32 = -16773785;
8888 try expect(@bitReverse(i32, @as(i32, -16773785)) == @bitReverse(i32, neg32));
8989}
90
91fn vector8() !void {
92 var v = @Vector(2, u8){ 0x12, 0x23 };
93 var result = @bitReverse(u8, v);
94 try expect(result[0] == 0x48);
95 try expect(result[1] == 0xc4);
96}
97
98test "bitReverse vectors u8" {
99 if (builtin.zig_backend == .stage1) return error.SkipZigTest;
100 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
101 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
102 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
103 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
104 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
105
106 comptime try vector8();
107 try vector8();
108}
109
110fn vector16() !void {
111 var v = @Vector(2, u16){ 0x1234, 0x2345 };
112 var result = @bitReverse(u16, v);
113 try expect(result[0] == 0x2c48);
114 try expect(result[1] == 0xa2c4);
115}
116
117test "bitReverse vectors u16" {
118 if (builtin.zig_backend == .stage1) return error.SkipZigTest;
119 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
120 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
121 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
122 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
123 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
124
125 comptime try vector16();
126 try vector16();
127}
128
129fn vector24() !void {
130 var v = @Vector(2, u24){ 0x123456, 0x234567 };
131 var result = @bitReverse(u24, v);
132 try expect(result[0] == 0x6a2c48);
133 try expect(result[1] == 0xe6a2c4);
134}
135
136test "bitReverse vectors u24" {
137 if (builtin.zig_backend == .stage1) return error.SkipZigTest;
138 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
139 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
140 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
141 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
142 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
143
144 comptime try vector24();
145 try vector24();
146}
147
148fn vector0() !void {
149 var v = @Vector(2, u0){ 0, 0 };
150 var result = @bitReverse(u0, v);
151 try expect(result[0] == 0);
152 try expect(result[1] == 0);
153}
154
155test "bitReverse vectors u0" {
156 if (builtin.zig_backend == .stage1) return error.SkipZigTest;
157 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
158 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
159 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
160 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
161 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
162
163 comptime try vector0();
164 try vector0();
165}