authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-05-10 21:46:24-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-05-10 21:50:55-07:00
logb33c8b0b06dd6a24d89efb278eeb833db93b2f9b
tree6b5c91beeae7563c581279f8d08d553e08c40d3f
parentf5edf78eea403c14635a05e1729672cfb50aca89

Sema: comptime float negation supports negative zero

When handling the `negate` ZIR instruction, Zig now checks for a comptime operand and handles it as a special case rather than lowering it as `0 - x` so that the expression `-x` where `x` is a floating point value known at compile-time, will get the negative zero bitwise representation.

3 files changed, 84 insertions(+), 21 deletions(-)

src/Sema.zig+31-13
......@@ -758,8 +758,8 @@ fn analyzeBodyInner(
758758 .is_non_null => try sema.zirIsNonNull(block, inst),
759759 .is_non_null_ptr => try sema.zirIsNonNullPtr(block, inst),
760760 .merge_error_sets => try sema.zirMergeErrorSets(block, inst),
761 .negate => try sema.zirNegate(block, inst, .sub),
762 .negate_wrap => try sema.zirNegate(block, inst, .subwrap),
761 .negate => try sema.zirNegate(block, inst),
762 .negate_wrap => try sema.zirNegateWrap(block, inst),
763763 .optional_payload_safe => try sema.zirOptionalPayload(block, inst, true),
764764 .optional_payload_safe_ptr => try sema.zirOptionalPayloadPtr(block, inst, true),
765765 .optional_payload_unsafe => try sema.zirOptionalPayload(block, inst, false),
......@@ -9328,15 +9328,7 @@ fn zirArrayMul(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
93289328 return sema.fail(block, lhs_src, "TODO runtime array_mul", .{});
93299329}
93309330
9331fn zirNegate(
9332 sema: *Sema,
9333 block: *Block,
9334 inst: Zir.Inst.Index,
9335 tag_override: Zir.Inst.Tag,
9336) CompileError!Air.Inst.Ref {
9337 const tracy = trace(@src());
9338 defer tracy.end();
9339
9331fn zirNegate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
93409332 const inst_data = sema.code.instructions.items(.data)[inst].un_node;
93419333 const src = inst_data.src();
93429334 const lhs_src = src;
......@@ -9346,16 +9338,42 @@ fn zirNegate(
93469338 const rhs_ty = sema.typeOf(rhs);
93479339 const rhs_scalar_ty = rhs_ty.scalarType();
93489340
9349 if (tag_override == .sub and rhs_scalar_ty.isUnsignedInt()) {
9341 if (rhs_scalar_ty.isUnsignedInt()) {
93509342 return sema.fail(block, src, "negation of type '{}'", .{rhs_ty.fmt(sema.mod)});
93519343 }
93529344
9345 if (rhs_scalar_ty.isAnyFloat()) {
9346 // We handle comptime negation here to ensure negative zero is represented in the bits.
9347 if (try sema.resolveMaybeUndefVal(block, rhs_src, rhs)) |rhs_val| {
9348 if (rhs_val.isUndef()) return sema.addConstUndef(rhs_ty);
9349 const target = sema.mod.getTarget();
9350 return sema.addConstant(rhs_ty, try rhs_val.floatNeg(rhs_ty, sema.arena, target));
9351 }
9352 }
9353
9354 const lhs = if (rhs_ty.zigTypeTag() == .Vector)
9355 try sema.addConstant(rhs_ty, try Value.Tag.repeated.create(sema.arena, Value.zero))
9356 else
9357 sema.resolveInst(.zero);
9358
9359 return sema.analyzeArithmetic(block, .sub, lhs, rhs, src, lhs_src, rhs_src);
9360}
9361
9362fn zirNegateWrap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
9363 const inst_data = sema.code.instructions.items(.data)[inst].un_node;
9364 const src = inst_data.src();
9365 const lhs_src = src;
9366 const rhs_src = src; // TODO better source location
9367
9368 const rhs = sema.resolveInst(inst_data.operand);
9369 const rhs_ty = sema.typeOf(rhs);
9370
93539371 const lhs = if (rhs_ty.zigTypeTag() == .Vector)
93549372 try sema.addConstant(rhs_ty, try Value.Tag.repeated.create(sema.arena, Value.zero))
93559373 else
93569374 sema.resolveInst(.zero);
93579375
9358 return sema.analyzeArithmetic(block, tag_override, lhs, rhs, src, lhs_src, rhs_src);
9376 return sema.analyzeArithmetic(block, .subwrap, lhs, rhs, src, lhs_src, rhs_src);
93599377}
93609378
93619379fn zirArithmetic(
src/value.zig+32
......@@ -4155,6 +4155,38 @@ pub const Value = extern union {
41554155 }
41564156 }
41574157
4158 pub fn floatNeg(
4159 val: Value,
4160 float_type: Type,
4161 arena: Allocator,
4162 target: Target,
4163 ) !Value {
4164 if (float_type.zigTypeTag() == .Vector) {
4165 const result_data = try arena.alloc(Value, float_type.vectorLen());
4166 for (result_data) |*scalar, i| {
4167 scalar.* = try floatNegScalar(val.indexVectorlike(i), float_type.scalarType(), arena, target);
4168 }
4169 return Value.Tag.aggregate.create(arena, result_data);
4170 }
4171 return floatNegScalar(val, float_type, arena, target);
4172 }
4173
4174 pub fn floatNegScalar(
4175 val: Value,
4176 float_type: Type,
4177 arena: Allocator,
4178 target: Target,
4179 ) !Value {
4180 switch (float_type.floatBits(target)) {
4181 16 => return Value.Tag.float_16.create(arena, -val.toFloat(f16)),
4182 32 => return Value.Tag.float_32.create(arena, -val.toFloat(f32)),
4183 64 => return Value.Tag.float_64.create(arena, -val.toFloat(f64)),
4184 80 => return Value.Tag.float_80.create(arena, -val.toFloat(f80)),
4185 128 => return Value.Tag.float_128.create(arena, -val.toFloat(f128)),
4186 else => unreachable,
4187 }
4188 }
4189
41584190 pub fn floatDiv(
41594191 lhs: Value,
41604192 rhs: Value,
test/behavior/math.zig+21-8
......@@ -1593,17 +1593,30 @@ test "compare undefined literal with comptime_int" {
15931593}
15941594
15951595test "signed zeros are represented properly" {
1596 if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
1596 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1597 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1598 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1599 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1600 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
15971601
15981602 const S = struct {
15991603 fn doTheTest() !void {
1600 inline for ([_]type{ f16, f32, f64, f128 }) |T| {
1601 const ST = std.meta.Int(.unsigned, @typeInfo(T).Float.bits);
1602 var as_fp_val = -@as(T, 0.0);
1603 var as_uint_val = @bitCast(ST, as_fp_val);
1604 // Ensure the sign bit is set.
1605 try expect(as_uint_val >> (@typeInfo(T).Float.bits - 1) == 1);
1606 }
1604 try testOne(f16);
1605 try testOne(f32);
1606 try testOne(f64);
1607 // TODO enable this
1608 //try testOne(f80);
1609 try testOne(f128);
1610 // TODO enable this
1611 //try testOne(c_longdouble);
1612 }
1613
1614 fn testOne(comptime T: type) !void {
1615 const ST = std.meta.Int(.unsigned, @typeInfo(T).Float.bits);
1616 var as_fp_val = -@as(T, 0.0);
1617 var as_uint_val = @bitCast(ST, as_fp_val);
1618 // Ensure the sign bit is set.
1619 try expect(as_uint_val >> (@typeInfo(T).Float.bits - 1) == 1);
16071620 }
16081621 };
16091622