From bb25f212b3630eeaac6a76575f21875d7d94e1a4 Mon Sep 17 00:00:00 2001 From: vegecode Date: Thu, 11 Apr 2019 13:20:24 -0500 Subject: [PATCH] compiler-rt: add aeabi_fcmp, comparesf2 --- CMakeLists.txt | 2 + std/special/compiler_rt.zig | 21 ++++ std/special/compiler_rt/arm/aeabi_fcmp.zig | 108 ++++++++++++++++++ std/special/compiler_rt/comparesf2.zig | 118 ++++++++++++++++++++ std/special/compiler_rt/comparesf2_test.zig | 101 +++++++++++++++++ 5 files changed, 350 insertions(+) create mode 100644 std/special/compiler_rt/arm/aeabi_fcmp.zig create mode 100644 std/special/compiler_rt/comparesf2.zig create mode 100644 std/special/compiler_rt/comparesf2_test.zig diff --git a/CMakeLists.txt b/CMakeLists.txt index f70f79c16b..a482ddf50f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -636,10 +636,12 @@ set(ZIG_STD_FILES "special/build_runner.zig" "special/builtin.zig" "special/compiler_rt.zig" + "special/compiler_rt/arm/aeabi_fcmp.zig" "special/compiler_rt/addXf3.zig" "special/compiler_rt/aulldiv.zig" "special/compiler_rt/aullrem.zig" "special/compiler_rt/comparetf2.zig" + "special/compiler_rt/comparesf2.zig" "special/compiler_rt/divsf3.zig" "special/compiler_rt/divdf3.zig" "special/compiler_rt/divti3.zig" diff --git a/std/special/compiler_rt.zig b/std/special/compiler_rt.zig index e2ecd1b0cf..b3f7a6660e 100644 --- a/std/special/compiler_rt.zig +++ b/std/special/compiler_rt.zig @@ -5,20 +5,34 @@ comptime { const linkage = if (is_test) builtin.GlobalLinkage.Internal else builtin.GlobalLinkage.Weak; const strong_linkage = if (is_test) builtin.GlobalLinkage.Internal else builtin.GlobalLinkage.Strong; + @export("__lesf2", @import("compiler_rt/comparesf2.zig").__lesf2, linkage); @export("__letf2", @import("compiler_rt/comparetf2.zig").__letf2, linkage); + + @export("__gesf2", @import("compiler_rt/comparesf2.zig").__gesf2, linkage); @export("__getf2", @import("compiler_rt/comparetf2.zig").__getf2, linkage); if (!is_test) { // only create these aliases when not testing + @export("__cmpsf2", @import("compiler_rt/comparesf2.zig").__lesf2, linkage); @export("__cmptf2", @import("compiler_rt/comparetf2.zig").__letf2, linkage); + + @export("__eqsf2", @import("compiler_rt/comparesf2.zig").__eqsf2, linkage); @export("__eqtf2", @import("compiler_rt/comparetf2.zig").__letf2, linkage); + + @export("__ltsf2", @import("compiler_rt/comparesf2.zig").__ltsf2, linkage); @export("__lttf2", @import("compiler_rt/comparetf2.zig").__letf2, linkage); + + @export("__nesf2", @import("compiler_rt/comparesf2.zig").__nesf2, linkage); @export("__netf2", @import("compiler_rt/comparetf2.zig").__letf2, linkage); + + @export("__gtsf2", @import("compiler_rt/comparesf2.zig").__gtsf2, linkage); @export("__gttf2", @import("compiler_rt/comparetf2.zig").__getf2, linkage); + @export("__gnu_h2f_ieee", @import("compiler_rt/extendXfYf2.zig").__extendhfsf2, linkage); @export("__gnu_f2h_ieee", @import("compiler_rt/truncXfYf2.zig").__truncsfhf2, linkage); } + @export("__unordsf2", @import("compiler_rt/comparesf2.zig").__unordsf2, linkage); @export("__unordtf2", @import("compiler_rt/comparetf2.zig").__unordtf2, linkage); @export("__addsf3", @import("compiler_rt/addXf3.zig").__addsf3, linkage); @@ -144,6 +158,13 @@ comptime { @export("__aeabi_fdiv", @import("compiler_rt/divsf3.zig").__divsf3, linkage); @export("__aeabi_ddiv", @import("compiler_rt/divdf3.zig").__divdf3, linkage); + + @export("__aeabi_fcmpeq", @import("compiler_rt/arm/aeabi_fcmp.zig").__aeabi_fcmpeq, linkage); + @export("__aeabi_fcmplt", @import("compiler_rt/arm/aeabi_fcmp.zig").__aeabi_fcmplt, linkage); + @export("__aeabi_fcmple", @import("compiler_rt/arm/aeabi_fcmp.zig").__aeabi_fcmple, linkage); + @export("__aeabi_fcmpge", @import("compiler_rt/arm/aeabi_fcmp.zig").__aeabi_fcmpge, linkage); + @export("__aeabi_fcmpgt", @import("compiler_rt/arm/aeabi_fcmp.zig").__aeabi_fcmpgt, linkage); + @export("__aeabi_fcmpun", @import("compiler_rt/comparesf2.zig").__unordsf2, linkage); } if (builtin.os == builtin.Os.windows) { switch (builtin.arch) { diff --git a/std/special/compiler_rt/arm/aeabi_fcmp.zig b/std/special/compiler_rt/arm/aeabi_fcmp.zig new file mode 100644 index 0000000000..192f7485f3 --- /dev/null +++ b/std/special/compiler_rt/arm/aeabi_fcmp.zig @@ -0,0 +1,108 @@ +// Ported from: +// +// https://github.com/llvm/llvm-project/commit/d674d96bc56c0f377879d01c9d8dfdaaa7859cdb/compiler-rt/lib/builtins/arm/aeabi_fcmp.S + +const compiler_rt_armhf_target = false; // TODO + +const ConditionalOperator = enum { + Eq, + Lt, + Le, + Ge, + Gt, +}; + +pub nakedcc fn __aeabi_fcmpeq() noreturn { + @setRuntimeSafety(false); + aeabi_fcmp(.Eq); + unreachable; +} + +pub nakedcc fn __aeabi_fcmplt() noreturn { + @setRuntimeSafety(false); + aeabi_fcmp(.Lt); + unreachable; +} + +pub nakedcc fn __aeabi_fcmple() noreturn { + @setRuntimeSafety(false); + aeabi_fcmp(.Le); + unreachable; +} + +pub nakedcc fn __aeabi_fcmpge() noreturn { + @setRuntimeSafety(false); + aeabi_fcmp(.Ge); + unreachable; +} + +pub nakedcc fn __aeabi_fcmpgt() noreturn { + @setRuntimeSafety(false); + aeabi_fcmp(.Gt); + unreachable; +} + +inline fn convert_fcmp_args_to_sf2_args() void { + asm volatile ( + \\ vmov s0, r0 + \\ vmov s1, r1 + ); +} + +inline fn aeabi_fcmp(comptime cond: ConditionalOperator) void { + @setRuntimeSafety(false); + asm volatile ( + \\ push { r4, lr } + ); + + if (compiler_rt_armhf_target) { + convert_fcmp_args_to_sf2_args(); + } + + switch (cond) { + .Eq => asm volatile ( + \\ bl __eqsf2 + \\ cmp r0, #0 + \\ beq 1f + \\ movs r0, #0 + \\ pop { r4, pc } + \\ 1: + ), + .Lt => asm volatile ( + \\ bl __ltsf2 + \\ cmp r0, #0 + \\ blt 1f + \\ movs r0, #0 + \\ pop { r4, pc } + \\ 1: + ), + .Le => asm volatile ( + \\ bl __lesf2 + \\ cmp r0, #0 + \\ ble 1f + \\ movs r0, #0 + \\ pop { r4, pc } + \\ 1: + ), + .Ge => asm volatile ( + \\ bl __ltsf2 + \\ cmp r0, #0 + \\ blt 1f + \\ movs r0, #0 + \\ pop { r4, pc } + \\ 1: + ), + .Gt => asm volatile ( + \\ bl __gtsf2 + \\ cmp r0, #0 + \\ bgt 1f + \\ movs r0, #0 + \\ pop { r4, pc } + \\ 1: + ), + } + asm volatile ( + \\ movs r0, #1 + \\ pop { r4, pc } + ); +} diff --git a/std/special/compiler_rt/comparesf2.zig b/std/special/compiler_rt/comparesf2.zig new file mode 100644 index 0000000000..b3734a5af9 --- /dev/null +++ b/std/special/compiler_rt/comparesf2.zig @@ -0,0 +1,118 @@ +// Ported from: +// +// https://github.com/llvm/llvm-project/commit/d674d96bc56c0f377879d01c9d8dfdaaa7859cdb/compiler-rt/lib/builtins/comparesf2.c + +const std = @import("std"); +const builtin = @import("builtin"); +const is_test = builtin.is_test; + +const fp_t = f32; +const rep_t = u32; +const srep_t = i32; + +const typeWidth = rep_t.bit_count; +const significandBits = std.math.floatMantissaBits(fp_t); +const exponentBits = std.math.floatExponentBits(fp_t); +const signBit = (rep_t(1) << (significandBits + exponentBits)); +const absMask = signBit - 1; +const implicitBit = rep_t(1) << significandBits; +const significandMask = implicitBit - 1; +const exponentMask = absMask ^ significandMask; +const infRep = @bitCast(rep_t, std.math.inf(fp_t)); + +// TODO https://github.com/ziglang/zig/issues/641 +// and then make the return types of some of these functions the enum instead of c_int +const LE_LESS = c_int(-1); +const LE_EQUAL = c_int(0); +const LE_GREATER = c_int(1); +const LE_UNORDERED = c_int(1); + +pub extern fn __lesf2(a: fp_t, b: fp_t) c_int { + @setRuntimeSafety(is_test); + const aInt: srep_t = @bitCast(srep_t, a); + const bInt: srep_t = @bitCast(srep_t, b); + const aAbs: rep_t = @bitCast(rep_t, aInt) & absMask; + const bAbs: rep_t = @bitCast(rep_t, bInt) & absMask; + + // If either a or b is NaN, they are unordered. + if (aAbs > infRep or bAbs > infRep) return LE_UNORDERED; + + // If a and b are both zeros, they are equal. + if ((aAbs | bAbs) == 0) return LE_EQUAL; + + // If at least one of a and b is positive, we get the same result comparing + // a and b as signed integers as we would with a fp_ting-point compare. + if ((aInt & bInt) >= 0) { + if (aInt < bInt) { + return LE_LESS; + } else if (aInt == bInt) { + return LE_EQUAL; + } else return LE_GREATER; + } + + // Otherwise, both are negative, so we need to flip the sense of the + // comparison to get the correct result. (This assumes a twos- or ones- + // complement integer representation; if integers are represented in a + // sign-magnitude representation, then this flip is incorrect). + else { + if (aInt > bInt) { + return LE_LESS; + } else if (aInt == bInt) { + return LE_EQUAL; + } else return LE_GREATER; + } +} + +// TODO https://github.com/ziglang/zig/issues/641 +// and then make the return types of some of these functions the enum instead of c_int +const GE_LESS = c_int(-1); +const GE_EQUAL = c_int(0); +const GE_GREATER = c_int(1); +const GE_UNORDERED = c_int(-1); // Note: different from LE_UNORDERED + +pub extern fn __gesf2(a: fp_t, b: fp_t) c_int { + @setRuntimeSafety(is_test); + const aInt: srep_t = @bitCast(srep_t, a); + const bInt: srep_t = @bitCast(srep_t, b); + const aAbs: rep_t = @bitCast(rep_t, aInt) & absMask; + const bAbs: rep_t = @bitCast(rep_t, bInt) & absMask; + + if (aAbs > infRep or bAbs > infRep) return GE_UNORDERED; + if ((aAbs | bAbs) == 0) return GE_EQUAL; + if ((aInt & bInt) >= 0) { + if (aInt < bInt) { + return GE_LESS; + } else if (aInt == bInt) { + return GE_EQUAL; + } else return GE_GREATER; + } else { + if (aInt > bInt) { + return GE_LESS; + } else if (aInt == bInt) { + return GE_EQUAL; + } else return GE_GREATER; + } +} + +pub extern fn __unordsf2(a: fp_t, b: fp_t) c_int { + @setRuntimeSafety(is_test); + const aAbs: rep_t = @bitCast(rep_t, a) & absMask; + const bAbs: rep_t = @bitCast(rep_t, b) & absMask; + return @boolToInt(aAbs > infRep or bAbs > infRep); +} + +pub extern fn __eqsf2(a: fp_t, b: fp_t) c_int { + return __lesf2(a, b); +} + +pub extern fn __ltsf2(a: fp_t, b: fp_t) c_int { + return __lesf2(a, b); +} + +pub extern fn __nesf2(a: fp_t, b: fp_t) c_int { + return __lesf2(a, b); +} + +pub extern fn __gtsf2(a: fp_t, b: fp_t) c_int { + return __gesf2(a, b); +} diff --git a/std/special/compiler_rt/comparesf2_test.zig b/std/special/compiler_rt/comparesf2_test.zig new file mode 100644 index 0000000000..e460634fad --- /dev/null +++ b/std/special/compiler_rt/comparesf2_test.zig @@ -0,0 +1,101 @@ +// Ported from: +// +// https://github.com/llvm/llvm-project/commit/d674d96bc56c0f377879d01c9d8dfdaaa7859cdb/compiler-rt/test/builtins/Unit/comparesf2_test.c + +const std = @import("std"); +const builtin = @import("builtin"); +const is_test = builtin.is_test; + +const comparesf2 = @import("comparesf2.zig"); + +const TestVector = struct { + a: f32, + b: f32, + eqReference: c_int, + geReference: c_int, + gtReference: c_int, + leReference: c_int, + ltReference: c_int, + neReference: c_int, + unReference: c_int, +}; + +fn test__cmpsf2(vector: TestVector) bool { + if (comparesf2.__eqsf2(vector.a, vector.b) != vector.eqReference) { + return false; + } + if (comparesf2.__gesf2(vector.a, vector.b) != vector.geReference) { + return false; + } + if (comparesf2.__gtsf2(vector.a, vector.b) != vector.gtReference) { + return false; + } + if (comparesf2.__lesf2(vector.a, vector.b) != vector.leReference) { + return false; + } + if (comparesf2.__ltsf2(vector.a, vector.b) != vector.ltReference) { + return false; + } + if (comparesf2.__nesf2(vector.a, vector.b) != vector.neReference) { + return false; + } + if (comparesf2.__unordsf2(vector.a, vector.b) != vector.unReference) { + return false; + } + return true; +} + +const arguments = []f32{ + std.math.nan(f32), + -std.math.inf(f32), + -0x1.fffffep127, + -0x1.000002p0 - 0x1.000000p0, + -0x1.fffffep-1, + -0x1.000000p-126, + -0x0.fffffep-126, + -0x0.000002p-126, + -0.0, + 0.0, + 0x0.000002p-126, + 0x0.fffffep-126, + 0x1.000000p-126, + 0x1.fffffep-1, + 0x1.000000p0, + 0x1.000002p0, + 0x1.fffffep127, + std.math.inf(f32), +}; + +fn generateVector(comptime a: f32, comptime b: f32) TestVector { + const leResult = if (a < b) -1 else if (a == b) 0 else 1; + const geResult = if (a > b) 1 else if (a == b) 0 else -1; + const unResult = if (a != a or b != b) 1 else 0; + return TestVector{ + .a = a, + .b = b, + .eqReference = leResult, + .geReference = geResult, + .gtReference = geResult, + .leReference = leResult, + .ltReference = leResult, + .neReference = leResult, + .unReference = unResult, + }; +} + +const test_vectors = init: { + @setEvalBranchQuota(10000); + var vectors: [arguments.len * arguments.len]TestVector = undefined; + for (arguments[0..]) |arg_i, i| { + for (arguments[0..]) |arg_j, j| { + vectors[(i * arguments.len) + j] = generateVector(arg_i, arg_j); + } + } + break :init vectors; +}; + +test "compare f32" { + for (test_vectors) |vector, i| { + std.testing.expect(test__cmpsf2(vector)); + } +}