Commit b33c8b0b06dd6a24d89efb278eeb833db93b2f9b | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-05-10 21:46:24-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2022-05-10 21:50:55-07:00
log	b33c8b0b06dd6a24d89efb278eeb833db93b2f9b
tree	6b5c91beeae7563c581279f8d08d553e08c40d3f
parent	f5edf78eea403c14635a05e1729672cfb50aca89

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
- value.zig
test
- behavior
  - math.zig

src/Sema.zig+31-13

 @@ -758,8 +758,8 @@ fn analyzeBodyInner(
             .is_non_null                  => try sema.zirIsNonNull(block, inst),
             .is_non_null_ptr              => try sema.zirIsNonNullPtr(block, inst),
             .merge_error_sets             => try sema.zirMergeErrorSets(block, inst),
-            .negate                       => try sema.zirNegate(block, inst, .sub),
+            .negate                       => try sema.zirNegate(block, inst),
-            .negate_wrap                  => try sema.zirNegate(block, inst, .subwrap),
+            .negate_wrap                  => try sema.zirNegateWrap(block, inst),
             .optional_payload_safe        => try sema.zirOptionalPayload(block, inst, true),
             .optional_payload_safe_ptr    => try sema.zirOptionalPayloadPtr(block, inst, true),
             .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
     return sema.fail(block, lhs_src, "TODO runtime array_mul", .{});
 }
-fn zirNegate(
+fn zirNegate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
-    sema: *Sema,
-    block: *Block,
-    inst: Zir.Inst.Index,
-    tag_override: Zir.Inst.Tag,
-) CompileError!Air.Inst.Ref {
-    const tracy = trace(@src());
-    defer tracy.end();
     const inst_data = sema.code.instructions.items(.data)[inst].un_node;
     const src = inst_data.src();
     const lhs_src = src;
 @@ -9346,16 +9338,42 @@ fn zirNegate(
     const rhs_ty = sema.typeOf(rhs);
     const rhs_scalar_ty = rhs_ty.scalarType();
-    if (tag_override == .sub and rhs_scalar_ty.isUnsignedInt()) {
+    if (rhs_scalar_ty.isUnsignedInt()) {
         return sema.fail(block, src, "negation of type '{}'", .{rhs_ty.fmt(sema.mod)});
     }
+    if (rhs_scalar_ty.isAnyFloat()) {
+        // We handle comptime negation here to ensure negative zero is represented in the bits.
+        if (try sema.resolveMaybeUndefVal(block, rhs_src, rhs)) |rhs_val| {
+            if (rhs_val.isUndef()) return sema.addConstUndef(rhs_ty);
+            const target = sema.mod.getTarget();
+            return sema.addConstant(rhs_ty, try rhs_val.floatNeg(rhs_ty, sema.arena, target));
+        }
+    }
+    const lhs = if (rhs_ty.zigTypeTag() == .Vector)
+        try sema.addConstant(rhs_ty, try Value.Tag.repeated.create(sema.arena, Value.zero))
+    else
+        sema.resolveInst(.zero);
+    return sema.analyzeArithmetic(block, .sub, lhs, rhs, src, lhs_src, rhs_src);
+}
+fn zirNegateWrap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
+    const inst_data = sema.code.instructions.items(.data)[inst].un_node;
+    const src = inst_data.src();
+    const lhs_src = src;
+    const rhs_src = src; // TODO better source location
+    const rhs = sema.resolveInst(inst_data.operand);
+    const rhs_ty = sema.typeOf(rhs);
     const lhs = if (rhs_ty.zigTypeTag() == .Vector)
         try sema.addConstant(rhs_ty, try Value.Tag.repeated.create(sema.arena, Value.zero))
     else
         sema.resolveInst(.zero);
-    return sema.analyzeArithmetic(block, tag_override, lhs, rhs, src, lhs_src, rhs_src);
+    return sema.analyzeArithmetic(block, .subwrap, lhs, rhs, src, lhs_src, rhs_src);
 }
 fn zirArithmetic(

src/value.zig+32

...	@@ -4155,6 +4155,38 @@ pub const Value = extern union {	...	@@ -4155,6 +4155,38 @@ pub const Value = extern union {
4155	}	4155	}
4156	}	4156	}
4157		4157
		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
4158	pub fn floatDiv(	4190	pub fn floatDiv(
4159	lhs: Value,	4191	lhs: Value,
4160	rhs: Value,	4192	rhs: Value,

test/behavior/math.zig+21-8

 @@ -1593,17 +1593,30 @@ test "compare undefined literal with comptime_int" {
 }
 test "signed zeros are represented properly" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     const S = struct {
         fn doTheTest() !void {
-            inline for ([_]type{ f16, f32, f64, f128 }) |T| {
+            try testOne(f16);
-                const ST = std.meta.Int(.unsigned, @typeInfo(T).Float.bits);
+            try testOne(f32);
-                var as_fp_val = -@as(T, 0.0);
+            try testOne(f64);
-                var as_uint_val = @bitCast(ST, as_fp_val);
+            // TODO enable this
-                // Ensure the sign bit is set.
+            //try testOne(f80);
-                try expect(as_uint_val >> (@typeInfo(T).Float.bits - 1) == 1);
+            try testOne(f128);
-            }
+            // TODO enable this
+            //try testOne(c_longdouble);
+        }
+        fn testOne(comptime T: type) !void {
+            const ST = std.meta.Int(.unsigned, @typeInfo(T).Float.bits);
+            var as_fp_val = -@as(T, 0.0);
+            var as_uint_val = @bitCast(ST, as_fp_val);
+            // Ensure the sign bit is set.
+            try expect(as_uint_val >> (@typeInfo(T).Float.bits - 1) == 1);
         }
     };