Merge pull request #4797 from laytan/improve-abs-of-float

improve abs() on floats for more correct and faster results

src/check_builtin.cpp

@@ -3488,9 +3488,12 @@ gb_internal bool check_builtin_procedure(CheckerContext *c, Operand *operand, As
 			case ExactValue_Integer:
 				mp_abs(&operand->value.value_integer, &operand->value.value_integer);
 				break;
-			case ExactValue_Float:
-				operand->value.value_float = gb_abs(operand->value.value_float);
+			case ExactValue_Float: {
+				u64 abs = bit_cast<u64>(operand->value.value_float);
+				abs &= 0x7FFFFFFFFFFFFFFF;
+				operand->value.value_float = bit_cast<f64>(abs);
 				break;
+			}
 			case ExactValue_Complex: {
 				f64 r = operand->value.value_complex->real;
 				f64 i = operand->value.value_complex->imag;

src/llvm_backend_proc.cpp

@@ -2174,7 +2174,32 @@ gb_internal lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValu
 			case 128: return lb_emit_runtime_call(p, "abs_complex128", args);
 			}
 			GB_PANIC("Unknown complex type");
+		} else if (is_type_float(t)) {
+			bool little = is_type_endian_little(t) || (is_type_endian_platform(t) && build_context.endian_kind == TargetEndian_Little);
+			Type *t_unsigned = nullptr;
+			lbValue mask = {0};
+			switch (type_size_of(t)) {
+			case 2:
+				t_unsigned = t_u16;
+				mask = lb_const_int(p->module, t_unsigned, little ? 0x7FFF : 0xFF7F);
+				break;
+			case 4:
+				t_unsigned = t_u32;
+				mask = lb_const_int(p->module, t_unsigned, little ? 0x7FFFFFFF : 0xFFFFFF7F);
+				break;
+			case 8:
+				t_unsigned = t_u64;
+				mask = lb_const_int(p->module, t_unsigned, little ? 0x7FFFFFFFFFFFFFFF : 0xFFFFFFFFFFFFFF7F);
+				break;
+			default:
+				GB_PANIC("abs: unhandled float size");
+			}
+
+			lbValue as_unsigned = lb_emit_transmute(p, x, t_unsigned);
+			lbValue abs = lb_emit_arith(p, Token_And, as_unsigned, mask, t_unsigned);
+			return lb_emit_transmute(p, abs, t);
 		}
+
 		lbValue zero = lb_const_nil(p->module, t);
 		lbValue cond = lb_emit_comp(p, Token_Lt, x, zero);
 		lbValue neg = lb_emit_unary_arith(p, Token_Sub, x, t);

tests/internal/test_abs.odin

@@ -0,0 +1,168 @@
+package test_internal
+
+import "core:testing"
+
+@(private="file")
+not_const :: proc(v: $T) -> T { return v }
+
+@(test)
+abs_f16_const :: proc(t: ^testing.T) {
+	// Constant f16
+	testing.expect_value(t, abs(f16(0.)), 0.)
+	testing.expect_value(t, abs(f16(-0.)), 0.)
+	testing.expect_value(t, abs(f16(-1.)), 1.)
+	testing.expect_value(t, abs(min(f16)), max(f16))
+	testing.expect_value(t, abs(max(f16)), max(f16))
+	testing.expect_value(t, abs(f16(-.12)), .12)
+
+	// Constant f16le
+	testing.expect_value(t, abs(f16le(0.)), 0.)
+	testing.expect_value(t, abs(f16le(-0.)), 0.)
+	testing.expect_value(t, abs(f16le(-1.)), 1.)
+	testing.expect_value(t, abs(min(f16le)), max(f16le))
+	testing.expect_value(t, abs(max(f16le)), max(f16le))
+	testing.expect_value(t, abs(f16le(-.12)), .12)
+
+	// Constant f16be
+	testing.expect_value(t, abs(f16be(0.)), 0.)
+	testing.expect_value(t, abs(f16be(-0.)), 0.)
+	testing.expect_value(t, abs(f16be(-1.)), 1.)
+	testing.expect_value(t, abs(min(f16be)), max(f16be))
+	testing.expect_value(t, abs(max(f16be)), max(f16be))
+	testing.expect_value(t, abs(f16be(-.12)), .12)
+}
+
+@(test)
+abs_f16_variable :: proc(t: ^testing.T) {
+	// Variable f16
+	testing.expect_value(t, abs(not_const(f16(0.))), 0.)
+	testing.expect_value(t, abs(not_const(f16(-0.))), 0.)
+	testing.expect_value(t, abs(not_const(f16(-1.))), 1.)
+	testing.expect_value(t, abs(not_const(min(f16))), max(f16))
+	testing.expect_value(t, abs(not_const(max(f16))), max(f16))
+	testing.expect_value(t, abs(not_const(f16(-.12))), .12)
+
+	// Variable f16le
+	testing.expect_value(t, abs(not_const(f16le(0.))), 0.)
+	testing.expect_value(t, abs(not_const(f16le(-0.))), 0.)
+	testing.expect_value(t, abs(not_const(f16le(-1.))), 1.)
+	testing.expect_value(t, abs(not_const(min(f16le))), max(f16le))
+	testing.expect_value(t, abs(not_const(max(f16le))), max(f16le))
+	testing.expect_value(t, abs(not_const(f16le(-.12))), .12)
+
+	// Variable f16be
+	testing.expect_value(t, abs(not_const(f16be(0.))), 0.)
+	testing.expect_value(t, abs(not_const(f16be(-0.))), 0.)
+	testing.expect_value(t, abs(not_const(f16be(-1.))), 1.)
+	testing.expect_value(t, abs(not_const(min(f16be))), max(f16be))
+	testing.expect_value(t, abs(not_const(max(f16be))), max(f16be))
+	testing.expect_value(t, abs(not_const(f16be(-.12))), .12)
+}
+
+@(test)
+abs_f32_const :: proc(t: ^testing.T) {
+	// Constant f32
+	testing.expect_value(t, abs(f32(0.)), 0.)
+	testing.expect_value(t, abs(f32(-0.)), 0.)
+	testing.expect_value(t, abs(f32(-1.)), 1.)
+	testing.expect_value(t, abs(min(f32)), max(f32))
+	testing.expect_value(t, abs(max(f32)), max(f32))
+	testing.expect_value(t, abs(f32(-.12345)), .12345)
+
+	// Constant f32le
+	testing.expect_value(t, abs(f32le(0.)), 0.)
+	testing.expect_value(t, abs(f32le(-0.)), 0.)
+	testing.expect_value(t, abs(f32le(-1.)), 1.)
+	testing.expect_value(t, abs(min(f32le)), max(f32le))
+	testing.expect_value(t, abs(max(f32le)), max(f32le))
+	testing.expect_value(t, abs(f32le(-.12345)), .12345)
+
+	// Constant f32be
+	testing.expect_value(t, abs(f32be(0.)), 0.)
+	testing.expect_value(t, abs(f32be(-0.)), 0.)
+	testing.expect_value(t, abs(f32be(-1.)), 1.)
+	testing.expect_value(t, abs(min(f32be)), max(f32be))
+	testing.expect_value(t, abs(max(f32be)), max(f32be))
+	testing.expect_value(t, abs(f32be(-.12345)), .12345)
+}
+
+@(test)
+abs_f32_variable :: proc(t: ^testing.T) {
+	// Variable f32
+	testing.expect_value(t, abs(not_const(f32(0.))), 0.)
+	testing.expect_value(t, abs(not_const(f32(-0.))), 0.)
+	testing.expect_value(t, abs(not_const(f32(-1.))), 1.)
+	testing.expect_value(t, abs(not_const(min(f32))), max(f32))
+	testing.expect_value(t, abs(not_const(max(f32))), max(f32))
+	testing.expect_value(t, abs(not_const(f32(-.12345))), .12345)
+
+	// Variable f32le
+	testing.expect_value(t, abs(not_const(f32le(0.))), 0.)
+	testing.expect_value(t, abs(not_const(f32le(-0.))), 0.)
+	testing.expect_value(t, abs(not_const(f32le(-1.))), 1.)
+	testing.expect_value(t, abs(not_const(min(f32le))), max(f32le))
+	testing.expect_value(t, abs(not_const(max(f32le))), max(f32le))
+	testing.expect_value(t, abs(not_const(f32le(-.12345))), .12345)
+
+	// Variable f32be
+	testing.expect_value(t, abs(not_const(f32be(0.))), 0.)
+	testing.expect_value(t, abs(not_const(f32be(-0.))), 0.)
+	testing.expect_value(t, abs(not_const(f32be(-1.))), 1.)
+	testing.expect_value(t, abs(not_const(min(f32be))), max(f32be))
+	testing.expect_value(t, abs(not_const(max(f32be))), max(f32be))
+	testing.expect_value(t, abs(not_const(f32be(-.12345))), .12345)
+}
+
+@(test)
+abs_f64_const :: proc(t: ^testing.T) {
+	// Constant f64
+	testing.expect_value(t, abs(f64(0.)), 0.)
+	testing.expect_value(t, abs(f64(-0.)), 0.)
+	testing.expect_value(t, abs(f64(-1.)), 1.)
+	testing.expect_value(t, abs(min(f64)), max(f64))
+	testing.expect_value(t, abs(max(f64)), max(f64))
+	testing.expect_value(t, abs(f64(-.12345)), .12345)
+
+	// Constant f64le
+	testing.expect_value(t, abs(f64le(0.)), 0.)
+	testing.expect_value(t, abs(f64le(-0.)), 0.)
+	testing.expect_value(t, abs(f64le(-1.)), 1.)
+	testing.expect_value(t, abs(min(f64le)), max(f64le))
+	testing.expect_value(t, abs(max(f64le)), max(f64le))
+	testing.expect_value(t, abs(f64le(-.12345)), .12345)
+
+	// Constant f64be
+	testing.expect_value(t, abs(f64be(0.)), 0.)
+	testing.expect_value(t, abs(f64be(-0.)), 0.)
+	testing.expect_value(t, abs(f64be(-1.)), 1.)
+	testing.expect_value(t, abs(min(f64be)), max(f64be))
+	testing.expect_value(t, abs(max(f64be)), max(f64be))
+	testing.expect_value(t, abs(f64be(-.12345)), .12345)
+}
+
+@(test)
+abs_f64_variable :: proc(t: ^testing.T) {
+	// Variable f64
+	testing.expect_value(t, abs(not_const(f64(0.))), 0.)
+	testing.expect_value(t, abs(not_const(f64(-0.))), 0.)
+	testing.expect_value(t, abs(not_const(f64(-1.))), 1.)
+	testing.expect_value(t, abs(not_const(min(f64))), max(f64))
+	testing.expect_value(t, abs(not_const(max(f64))), max(f64))
+	testing.expect_value(t, abs(not_const(f64(-.12345))), .12345)
+
+	// Variable f64le
+	testing.expect_value(t, abs(not_const(f64le(0.))), 0.)
+	testing.expect_value(t, abs(not_const(f64le(-0.))), 0.)
+	testing.expect_value(t, abs(not_const(f64le(-1.))), 1.)
+	testing.expect_value(t, abs(not_const(min(f64le))), max(f64le))
+	testing.expect_value(t, abs(not_const(max(f64le))), max(f64le))
+	testing.expect_value(t, abs(not_const(f64le(-.12345))), .12345)
+
+	// Variable f64be
+	testing.expect_value(t, abs(not_const(f64be(0.))), 0.)
+	testing.expect_value(t, abs(not_const(f64be(-0.))), 0.)
+	testing.expect_value(t, abs(not_const(f64be(-1.))), 1.)
+	testing.expect_value(t, abs(not_const(min(f64be))), max(f64be))
+	testing.expect_value(t, abs(not_const(max(f64be))), max(f64be))
+	testing.expect_value(t, abs(not_const(f64be(-.12345))), .12345)
+}