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...@@ -13341,28 +13341,14 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
13341 const target = sema.mod.getTarget();13341 const target = sema.mod.getTarget();
13342 const dest_info = dest_scalar_ty.intInfo(target);13342 const dest_info = dest_scalar_ty.intInfo(target);
1334313343
13344 if (dest_info.bits == 0) {13344 if (try sema.typeHasOnePossibleValue(block, dest_ty_src, dest_ty)) |val| {
13345 if (is_vector) {13345 return sema.addConstant(dest_ty, val);
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 }
13353 }13346 }
1335413347
13355 if (operand_scalar_ty.zigTypeTag() != .ComptimeInt) {13348 if (operand_scalar_ty.zigTypeTag() != .ComptimeInt) {
13356 const operand_info = operand_ty.intInfo(target);13349 const operand_info = operand_ty.intInfo(target);
13357 if (operand_info.bits == 0) {13350 if (try sema.typeHasOnePossibleValue(block, operand_src, operand_ty)) |val| {
13358 if (is_vector) {13351 return sema.addConstant(operand_ty, val);
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 }
13366 }13352 }
1336713353
13368 if (operand_info.signedness != dest_info.signedness) {13354 if (operand_info.signedness != dest_info.signedness) {
...@@ -13461,15 +13447,9 @@ fn zirBitCount(...@@ -13461,15 +13447,9 @@ fn zirBitCount(
13461 _ = try checkIntOrVector(sema, block, operand, operand_src);13447 _ = try checkIntOrVector(sema, block, operand, operand_src);
13462 const target = sema.mod.getTarget();13448 const target = sema.mod.getTarget();
13463 const bits = operand_ty.intInfo(target).bits;13449 const bits = operand_ty.intInfo(target).bits;
13464 if (bits == 0) {13450
13465 switch (operand_ty.zigTypeTag()) {13451 if (try sema.typeHasOnePossibleValue(block, operand_src, operand_ty)) |val| {
13466 .Vector => return sema.addConstant(13452 return sema.addConstant(operand_ty, val);
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 }
13473 }13453 }
1347413454
13475 const result_scalar_ty = try Type.smallestUnsignedInt(sema.arena, bits);13455 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...@@ -13528,10 +13508,12 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
13528 );13508 );
13529 }13509 }
1353013510
13511 if (try sema.typeHasOnePossibleValue(block, operand_src, operand_ty)) |val| {
13512 return sema.addConstant(operand_ty, val);
13513 }
13514
13531 switch (operand_ty.zigTypeTag()) {13515 switch (operand_ty.zigTypeTag()) {
13532 .Int, .ComptimeInt => {13516 .Int, .ComptimeInt => {
13533 if (bits == 0) return Air.Inst.Ref.zero;
13534
13535 const runtime_src = if (try sema.resolveMaybeUndefVal(block, operand_src, operand)) |val| {13517 const runtime_src = if (try sema.resolveMaybeUndefVal(block, operand_src, operand)) |val| {
13536 if (val.isUndef()) return sema.addConstUndef(operand_ty);13518 if (val.isUndef()) return sema.addConstUndef(operand_ty);
13537 const result_val = try val.byteSwap(operand_ty, target, sema.arena);13519 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...@@ -13542,13 +13524,6 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
13542 return block.addTyOp(.byte_swap, operand_ty, operand);13524 return block.addTyOp(.byte_swap, operand_ty, operand);
13543 },13525 },
13544 .Vector => {13526 .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
13552 const runtime_src = if (try sema.resolveMaybeUndefVal(block, operand_src, operand)) |val| {13527 const runtime_src = if (try sema.resolveMaybeUndefVal(block, operand_src, operand)) |val| {
13553 if (val.isUndef())13528 if (val.isUndef())
13554 return sema.addConstUndef(operand_ty);13529 return sema.addConstUndef(operand_ty);
...@@ -13575,28 +13550,50 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai...@@ -13575,28 +13550,50 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1357513550
13576fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {13551fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
13577 const inst_data = sema.code.instructions.items(.data)[inst].un_node;13552 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 };
13579 const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node };13553 const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = inst_data.src_node };
13580 const operand = sema.resolveInst(inst_data.operand);13554 const operand = sema.resolveInst(inst_data.operand);
13581 const operand_ty = sema.typeOf(operand);13555 const operand_ty = sema.typeOf(operand);
13582 // TODO implement support for vectors13556 _ = try sema.checkIntOrVectorAllowComptime(block, operand, operand_src);
13583 if (operand_ty.zigTypeTag() != .Int) {13557
13584 return sema.fail(block, ty_src, "expected integer type, found '{}'", .{13558 if (try sema.typeHasOnePossibleValue(block, operand_src, operand_ty)) |val| {
13585 operand_ty,13559 return sema.addConstant(operand_ty, val);
13586 });
13587 }13560 }
13561
13588 const target = sema.mod.getTarget();13562 const target = sema.mod.getTarget();
13589 const bits = operand_ty.intInfo(target).bits;13563 switch (operand_ty.zigTypeTag()) {
13590 if (bits == 0) return Air.Inst.Ref.zero;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| {13571 try sema.requireRuntimeBlock(block, runtime_src);
13593 if (val.isUndef()) return sema.addConstUndef(operand_ty);13572 return block.addTyOp(.bit_reverse, operand_ty, operand);
13594 const result_val = try val.bitReverse(operand_ty, target, sema.arena);13573 },
13595 return sema.addConstant(operand_ty, result_val);13574 .Vector => {
13596 } else operand_src;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);13579 const vec_len = operand_ty.vectorLen();
13599 return block.addTyOp(.bit_reverse, operand_ty, operand);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 }
13600}13597}
1360113598
13602fn zirBitOffsetOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {13599fn 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 {...@@ -87,3 +87,79 @@ fn testBitReverse() !void {
87 var neg32: i32 = -16773785;87 var neg32: i32 = -16773785;
88 try expect(@bitReverse(i32, @as(i32, -16773785)) == @bitReverse(i32, neg32));88 try expect(@bitReverse(i32, @as(i32, -16773785)) == @bitReverse(i32, neg32));
89}89}
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}