Nuke some repeated code
LemonBoy
parent
7d94e712f1
commit
6b056d1fb9
|
|
@ -16,42 +16,42 @@ comptime {
|
|||
else => {},
|
||||
}
|
||||
|
||||
@export(@import("compiler_rt/comparesf2.zig").__lesf2, .{ .name = "__lesf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/comparedf2.zig").__ledf2, .{ .name = "__ledf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/comparetf2.zig").__letf2, .{ .name = "__letf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__lesf2, .{ .name = "__lesf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__ledf2, .{ .name = "__ledf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__letf2, .{ .name = "__letf2", .linkage = linkage });
|
||||
|
||||
@export(@import("compiler_rt/comparesf2.zig").__gesf2, .{ .name = "__gesf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/comparedf2.zig").__gedf2, .{ .name = "__gedf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/comparetf2.zig").__getf2, .{ .name = "__getf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__gesf2, .{ .name = "__gesf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__gedf2, .{ .name = "__gedf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__getf2, .{ .name = "__getf2", .linkage = linkage });
|
||||
|
||||
if (!is_test) {
|
||||
@export(@import("compiler_rt/comparesf2.zig").__lesf2, .{ .name = "__cmpsf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/comparedf2.zig").__ledf2, .{ .name = "__cmpdf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/comparetf2.zig").__letf2, .{ .name = "__cmptf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__lesf2, .{ .name = "__cmpsf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__ledf2, .{ .name = "__cmpdf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__letf2, .{ .name = "__cmptf2", .linkage = linkage });
|
||||
|
||||
@export(@import("compiler_rt/comparesf2.zig").__eqsf2, .{ .name = "__eqsf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/comparedf2.zig").__eqdf2, .{ .name = "__eqdf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/comparetf2.zig").__letf2, .{ .name = "__eqtf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__eqsf2, .{ .name = "__eqsf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__eqdf2, .{ .name = "__eqdf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__letf2, .{ .name = "__eqtf2", .linkage = linkage });
|
||||
|
||||
@export(@import("compiler_rt/comparesf2.zig").__ltsf2, .{ .name = "__ltsf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/comparedf2.zig").__ltdf2, .{ .name = "__ltdf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/comparetf2.zig").__letf2, .{ .name = "__lttf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__ltsf2, .{ .name = "__ltsf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__ltdf2, .{ .name = "__ltdf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__letf2, .{ .name = "__lttf2", .linkage = linkage });
|
||||
|
||||
@export(@import("compiler_rt/comparesf2.zig").__nesf2, .{ .name = "__nesf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/comparedf2.zig").__nedf2, .{ .name = "__nedf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/comparetf2.zig").__letf2, .{ .name = "__netf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__nesf2, .{ .name = "__nesf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__nedf2, .{ .name = "__nedf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__letf2, .{ .name = "__netf2", .linkage = linkage });
|
||||
|
||||
@export(@import("compiler_rt/comparesf2.zig").__gtsf2, .{ .name = "__gtsf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/comparedf2.zig").__gtdf2, .{ .name = "__gtdf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/comparetf2.zig").__getf2, .{ .name = "__gttf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__gtsf2, .{ .name = "__gtsf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__gtdf2, .{ .name = "__gtdf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__getf2, .{ .name = "__gttf2", .linkage = linkage });
|
||||
|
||||
@export(@import("compiler_rt/extendXfYf2.zig").__extendhfsf2, .{ .name = "__gnu_h2f_ieee", .linkage = linkage });
|
||||
@export(@import("compiler_rt/truncXfYf2.zig").__truncsfhf2, .{ .name = "__gnu_f2h_ieee", .linkage = linkage });
|
||||
}
|
||||
|
||||
@export(@import("compiler_rt/comparesf2.zig").__unordsf2, .{ .name = "__unordsf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/comparedf2.zig").__unorddf2, .{ .name = "__unorddf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/comparetf2.zig").__unordtf2, .{ .name = "__unordtf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__unordsf2, .{ .name = "__unordsf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__unorddf2, .{ .name = "__unorddf2", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__unordtf2, .{ .name = "__unordtf2", .linkage = linkage });
|
||||
|
||||
@export(@import("compiler_rt/addXf3.zig").__addsf3, .{ .name = "__addsf3", .linkage = linkage });
|
||||
@export(@import("compiler_rt/addXf3.zig").__adddf3, .{ .name = "__adddf3", .linkage = linkage });
|
||||
|
|
@ -231,14 +231,14 @@ comptime {
|
|||
@export(@import("compiler_rt/arm/aeabi_fcmp.zig").__aeabi_fcmple, .{ .name = "__aeabi_fcmple", .linkage = linkage });
|
||||
@export(@import("compiler_rt/arm/aeabi_fcmp.zig").__aeabi_fcmpge, .{ .name = "__aeabi_fcmpge", .linkage = linkage });
|
||||
@export(@import("compiler_rt/arm/aeabi_fcmp.zig").__aeabi_fcmpgt, .{ .name = "__aeabi_fcmpgt", .linkage = linkage });
|
||||
@export(@import("compiler_rt/comparesf2.zig").__aeabi_fcmpun, .{ .name = "__aeabi_fcmpun", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__aeabi_fcmpun, .{ .name = "__aeabi_fcmpun", .linkage = linkage });
|
||||
|
||||
@export(@import("compiler_rt/arm/aeabi_dcmp.zig").__aeabi_dcmpeq, .{ .name = "__aeabi_dcmpeq", .linkage = linkage });
|
||||
@export(@import("compiler_rt/arm/aeabi_dcmp.zig").__aeabi_dcmplt, .{ .name = "__aeabi_dcmplt", .linkage = linkage });
|
||||
@export(@import("compiler_rt/arm/aeabi_dcmp.zig").__aeabi_dcmple, .{ .name = "__aeabi_dcmple", .linkage = linkage });
|
||||
@export(@import("compiler_rt/arm/aeabi_dcmp.zig").__aeabi_dcmpge, .{ .name = "__aeabi_dcmpge", .linkage = linkage });
|
||||
@export(@import("compiler_rt/arm/aeabi_dcmp.zig").__aeabi_dcmpgt, .{ .name = "__aeabi_dcmpgt", .linkage = linkage });
|
||||
@export(@import("compiler_rt/comparedf2.zig").__aeabi_dcmpun, .{ .name = "__aeabi_dcmpun", .linkage = linkage });
|
||||
@export(@import("compiler_rt/compareXf2.zig").__aeabi_dcmpun, .{ .name = "__aeabi_dcmpun", .linkage = linkage });
|
||||
}
|
||||
if (builtin.os == .windows) {
|
||||
// Default stack-probe functions emitted by LLVM
|
||||
|
|
|
|||
|
|
@ -0,0 +1,201 @@
|
|||
// 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 LE = extern enum(i32) {
|
||||
Less = -1,
|
||||
Equal = 0,
|
||||
Greater = 1,
|
||||
Unordered = 1,
|
||||
};
|
||||
|
||||
const GE = extern enum(i32) {
|
||||
Less = -1,
|
||||
Equal = 0,
|
||||
Greater = 1,
|
||||
Unordered = -1,
|
||||
};
|
||||
|
||||
pub fn cmp(comptime T: type, comptime RT: type, a: T, b: T) RT {
|
||||
@setRuntimeSafety(builtin.is_test);
|
||||
|
||||
const srep_t = @IntType(true, T.bit_count);
|
||||
const rep_t = @IntType(false, T.bit_count);
|
||||
|
||||
const significandBits = std.math.floatMantissaBits(T);
|
||||
const exponentBits = std.math.floatExponentBits(T);
|
||||
const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
|
||||
const absMask = signBit - 1;
|
||||
const infRep = @bitCast(rep_t, std.math.inf(T));
|
||||
|
||||
const aInt = @bitCast(srep_t, a);
|
||||
const bInt = @bitCast(srep_t, b);
|
||||
const aAbs = @bitCast(rep_t, aInt) & absMask;
|
||||
const bAbs = @bitCast(rep_t, bInt) & absMask;
|
||||
|
||||
// If either a or b is NaN, they are unordered.
|
||||
if (aAbs > infRep or bAbs > infRep) return .Unordered;
|
||||
|
||||
// If a and b are both zeros, they are equal.
|
||||
if ((aAbs | bAbs) == 0) return .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 .Less;
|
||||
} else if (aInt == bInt) {
|
||||
return .Equal;
|
||||
} else return .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 .Less;
|
||||
} else if (aInt == bInt) {
|
||||
return .Equal;
|
||||
} else return .Greater;
|
||||
}
|
||||
}
|
||||
|
||||
pub fn unordcmp(comptime T: type, a: T, b: T) i32 {
|
||||
@setRuntimeSafety(builtin.is_test);
|
||||
|
||||
const rep_t = @IntType(false, T.bit_count);
|
||||
|
||||
const significandBits = std.math.floatMantissaBits(T);
|
||||
const exponentBits = std.math.floatExponentBits(T);
|
||||
const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
|
||||
const absMask = signBit - 1;
|
||||
const infRep = @bitCast(rep_t, std.math.inf(T));
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
// Comparison between f32
|
||||
|
||||
pub fn __lesf2(a: f32, b: f32) callconv(.C) i32 {
|
||||
@setRuntimeSafety(builtin.is_test);
|
||||
return @bitCast(i32, @call(.{ .modifier = .always_inline }, cmp, .{ f32, LE, a, b }));
|
||||
}
|
||||
|
||||
pub fn __gesf2(a: f32, b: f32) callconv(.C) i32 {
|
||||
@setRuntimeSafety(builtin.is_test);
|
||||
return @bitCast(i32, @call(.{ .modifier = .always_inline }, cmp, .{ f32, GE, a, b }));
|
||||
}
|
||||
|
||||
pub fn __eqsf2(a: f32, b: f32) callconv(.C) i32 {
|
||||
return __lesf2(a, b);
|
||||
}
|
||||
|
||||
pub fn __ltsf2(a: f32, b: f32) callconv(.C) i32 {
|
||||
return __lesf2(a, b);
|
||||
}
|
||||
|
||||
pub fn __nesf2(a: f32, b: f32) callconv(.C) i32 {
|
||||
return __lesf2(a, b);
|
||||
}
|
||||
|
||||
pub fn __gtsf2(a: f32, b: f32) callconv(.C) i32 {
|
||||
return __gesf2(a, b);
|
||||
}
|
||||
|
||||
// Comparison between f64
|
||||
|
||||
pub fn __ledf2(a: f64, b: f64) callconv(.C) i32 {
|
||||
@setRuntimeSafety(builtin.is_test);
|
||||
return @bitCast(i32, @call(.{ .modifier = .always_inline }, cmp, .{ f64, LE, a, b }));
|
||||
}
|
||||
|
||||
pub fn __gedf2(a: f64, b: f64) callconv(.C) i32 {
|
||||
@setRuntimeSafety(builtin.is_test);
|
||||
return @bitCast(i32, @call(.{ .modifier = .always_inline }, cmp, .{ f64, GE, a, b }));
|
||||
}
|
||||
|
||||
pub fn __eqdf2(a: f64, b: f64) callconv(.C) i32 {
|
||||
return __ledf2(a, b);
|
||||
}
|
||||
|
||||
pub fn __ltdf2(a: f64, b: f64) callconv(.C) i32 {
|
||||
return __ledf2(a, b);
|
||||
}
|
||||
|
||||
pub fn __nedf2(a: f64, b: f64) callconv(.C) i32 {
|
||||
return __ledf2(a, b);
|
||||
}
|
||||
|
||||
pub fn __gtdf2(a: f64, b: f64) callconv(.C) i32 {
|
||||
return __gedf2(a, b);
|
||||
}
|
||||
|
||||
// Comparison between f128
|
||||
|
||||
pub fn __letf2(a: f128, b: f128) callconv(.C) i32 {
|
||||
@setRuntimeSafety(builtin.is_test);
|
||||
return @bitCast(i32, @call(.{ .modifier = .always_inline }, cmp, .{ f128, LE, a, b }));
|
||||
}
|
||||
|
||||
pub fn __getf2(a: f128, b: f128) callconv(.C) i32 {
|
||||
@setRuntimeSafety(builtin.is_test);
|
||||
return @bitCast(i32, @call(.{ .modifier = .always_inline }, cmp, .{ f128, GE, a, b }));
|
||||
}
|
||||
|
||||
pub fn __eqtf2(a: f128, b: f128) callconv(.C) i32 {
|
||||
return __letf2(a, b);
|
||||
}
|
||||
|
||||
pub fn __lttf2(a: f128, b: f128) callconv(.C) i32 {
|
||||
return __letf2(a, b);
|
||||
}
|
||||
|
||||
pub fn __netf2(a: f128, b: f128) callconv(.C) i32 {
|
||||
return __letf2(a, b);
|
||||
}
|
||||
|
||||
pub fn __gttf2(a: f128, b: f128) callconv(.C) i32 {
|
||||
return __getf2(a, b);
|
||||
}
|
||||
|
||||
// Unordered comparison between f32/f64/f128
|
||||
|
||||
pub fn __unordsf2(a: f32, b: f32) callconv(.C) i32 {
|
||||
@setRuntimeSafety(builtin.is_test);
|
||||
return @call(.{ .modifier = .always_inline }, unordcmp, .{ f32, a, b });
|
||||
}
|
||||
|
||||
pub fn __unorddf2(a: f64, b: f64) callconv(.C) i32 {
|
||||
@setRuntimeSafety(builtin.is_test);
|
||||
return @call(.{ .modifier = .always_inline }, unordcmp, .{ f64, a, b });
|
||||
}
|
||||
|
||||
pub fn __unordtf2(a: f128, b: f128) callconv(.C) i32 {
|
||||
@setRuntimeSafety(builtin.is_test);
|
||||
return @call(.{ .modifier = .always_inline }, unordcmp, .{ f128, a, b });
|
||||
}
|
||||
|
||||
pub fn __aeabi_fcmpun(a: f32, b: f32) callconv(.AAPCS) i32 {
|
||||
@setRuntimeSafety(false);
|
||||
return @call(.{ .modifier = .always_inline }, __unordsf2, .{ a, b });
|
||||
}
|
||||
|
||||
pub fn __aeabi_dcmpun(a: f64, b: f64) callconv(.AAPCS) i32 {
|
||||
@setRuntimeSafety(false);
|
||||
return @call(.{ .modifier = .always_inline }, __unorddf2, .{ a, b });
|
||||
}
|
||||
|
||||
test "comparesf2" {
|
||||
_ = @import("comparesf2_test.zig");
|
||||
}
|
||||
test "comparedf2" {
|
||||
_ = @import("comparedf2_test.zig");
|
||||
}
|
||||
|
|
@ -1,127 +0,0 @@
|
|||
// Ported from:
|
||||
//
|
||||
// https://github.com/llvm/llvm-project/commit/d674d96bc56c0f377879d01c9d8dfdaaa7859cdb/compiler-rt/lib/builtins/comparedf2.c
|
||||
|
||||
const std = @import("std");
|
||||
const builtin = @import("builtin");
|
||||
const is_test = builtin.is_test;
|
||||
|
||||
const fp_t = f64;
|
||||
const rep_t = u64;
|
||||
const srep_t = i64;
|
||||
|
||||
const typeWidth = rep_t.bit_count;
|
||||
const significandBits = std.math.floatMantissaBits(fp_t);
|
||||
const exponentBits = std.math.floatExponentBits(fp_t);
|
||||
const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
|
||||
const absMask = signBit - 1;
|
||||
const implicitBit = @as(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 = @as(c_int, -1);
|
||||
const LE_EQUAL = @as(c_int, 0);
|
||||
const LE_GREATER = @as(c_int, 1);
|
||||
const LE_UNORDERED = @as(c_int, 1);
|
||||
|
||||
pub fn __ledf2(a: fp_t, b: fp_t) callconv(.C) 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 = @as(c_int, -1);
|
||||
const GE_EQUAL = @as(c_int, 0);
|
||||
const GE_GREATER = @as(c_int, 1);
|
||||
const GE_UNORDERED = @as(c_int, -1); // Note: different from LE_UNORDERED
|
||||
|
||||
pub fn __gedf2(a: fp_t, b: fp_t) callconv(.C) 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 fn __unorddf2(a: fp_t, b: fp_t) callconv(.C) 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 fn __eqdf2(a: fp_t, b: fp_t) callconv(.C) c_int {
|
||||
return __ledf2(a, b);
|
||||
}
|
||||
|
||||
pub fn __ltdf2(a: fp_t, b: fp_t) callconv(.C) c_int {
|
||||
return __ledf2(a, b);
|
||||
}
|
||||
|
||||
pub fn __nedf2(a: fp_t, b: fp_t) callconv(.C) c_int {
|
||||
return __ledf2(a, b);
|
||||
}
|
||||
|
||||
pub fn __gtdf2(a: fp_t, b: fp_t) callconv(.C) c_int {
|
||||
return __gedf2(a, b);
|
||||
}
|
||||
|
||||
pub fn __aeabi_dcmpun(a: fp_t, b: fp_t) callconv(.AAPCS) c_int {
|
||||
@setRuntimeSafety(false);
|
||||
return @call(.{ .modifier = .always_inline }, __unorddf2, .{ a, b });
|
||||
}
|
||||
|
||||
test "import comparedf2" {
|
||||
_ = @import("comparedf2_test.zig");
|
||||
}
|
||||
|
|
@ -1,127 +0,0 @@
|
|||
// 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 = (@as(rep_t, 1) << (significandBits + exponentBits));
|
||||
const absMask = signBit - 1;
|
||||
const implicitBit = @as(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 = @as(c_int, -1);
|
||||
const LE_EQUAL = @as(c_int, 0);
|
||||
const LE_GREATER = @as(c_int, 1);
|
||||
const LE_UNORDERED = @as(c_int, 1);
|
||||
|
||||
pub fn __lesf2(a: fp_t, b: fp_t) callconv(.C) 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 = @as(c_int, -1);
|
||||
const GE_EQUAL = @as(c_int, 0);
|
||||
const GE_GREATER = @as(c_int, 1);
|
||||
const GE_UNORDERED = @as(c_int, -1); // Note: different from LE_UNORDERED
|
||||
|
||||
pub fn __gesf2(a: fp_t, b: fp_t) callconv(.C) 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 fn __unordsf2(a: fp_t, b: fp_t) callconv(.C) 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 fn __eqsf2(a: fp_t, b: fp_t) callconv(.C) c_int {
|
||||
return __lesf2(a, b);
|
||||
}
|
||||
|
||||
pub fn __ltsf2(a: fp_t, b: fp_t) callconv(.C) c_int {
|
||||
return __lesf2(a, b);
|
||||
}
|
||||
|
||||
pub fn __nesf2(a: fp_t, b: fp_t) callconv(.C) c_int {
|
||||
return __lesf2(a, b);
|
||||
}
|
||||
|
||||
pub fn __gtsf2(a: fp_t, b: fp_t) callconv(.C) c_int {
|
||||
return __gesf2(a, b);
|
||||
}
|
||||
|
||||
pub fn __aeabi_fcmpun(a: fp_t, b: fp_t) callconv(.AAPCS) c_int {
|
||||
@setRuntimeSafety(false);
|
||||
return @call(.{ .modifier = .always_inline }, __unordsf2, .{ a, b });
|
||||
}
|
||||
|
||||
test "import comparesf2" {
|
||||
_ = @import("comparesf2_test.zig");
|
||||
}
|
||||
|
|
@ -1,99 +0,0 @@
|
|||
// 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 = @as(c_int, -1);
|
||||
const LE_EQUAL = @as(c_int, 0);
|
||||
const LE_GREATER = @as(c_int, 1);
|
||||
const LE_UNORDERED = @as(c_int, 1);
|
||||
|
||||
const rep_t = u128;
|
||||
const srep_t = i128;
|
||||
|
||||
const typeWidth = rep_t.bit_count;
|
||||
const significandBits = 112;
|
||||
const exponentBits = (typeWidth - significandBits - 1);
|
||||
const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
|
||||
const absMask = signBit - 1;
|
||||
const implicitBit = @as(rep_t, 1) << significandBits;
|
||||
const significandMask = implicitBit - 1;
|
||||
const exponentMask = absMask ^ significandMask;
|
||||
const infRep = exponentMask;
|
||||
|
||||
const builtin = @import("builtin");
|
||||
const is_test = builtin.is_test;
|
||||
|
||||
pub fn __letf2(a: f128, b: f128) callconv(.C) c_int {
|
||||
@setRuntimeSafety(is_test);
|
||||
|
||||
const aInt = @bitCast(rep_t, a);
|
||||
const bInt = @bitCast(rep_t, b);
|
||||
|
||||
const aAbs: rep_t = aInt & absMask;
|
||||
const bAbs: 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 floating-point compare.
|
||||
return if ((aInt & bInt) >= 0)
|
||||
if (aInt < bInt)
|
||||
LE_LESS
|
||||
else if (aInt == bInt)
|
||||
LE_EQUAL
|
||||
else
|
||||
LE_GREATER
|
||||
else
|
||||
// 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).
|
||||
if (aInt > bInt)
|
||||
LE_LESS
|
||||
else if (aInt == bInt)
|
||||
LE_EQUAL
|
||||
else
|
||||
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 = @as(c_int, -1);
|
||||
const GE_EQUAL = @as(c_int, 0);
|
||||
const GE_GREATER = @as(c_int, 1);
|
||||
const GE_UNORDERED = @as(c_int, -1); // Note: different from LE_UNORDERED
|
||||
|
||||
pub fn __getf2(a: f128, b: f128) callconv(.C) c_int {
|
||||
@setRuntimeSafety(is_test);
|
||||
|
||||
const aInt = @bitCast(srep_t, a);
|
||||
const bInt = @bitCast(srep_t, b);
|
||||
const aAbs = @bitCast(rep_t, aInt) & absMask;
|
||||
const bAbs = @bitCast(rep_t, bInt) & absMask;
|
||||
|
||||
if (aAbs > infRep or bAbs > infRep) return GE_UNORDERED;
|
||||
if ((aAbs | bAbs) == 0) return GE_EQUAL;
|
||||
return if ((aInt & bInt) >= 0)
|
||||
if (aInt < bInt)
|
||||
GE_LESS
|
||||
else if (aInt == bInt)
|
||||
GE_EQUAL
|
||||
else
|
||||
GE_GREATER
|
||||
else if (aInt > bInt)
|
||||
GE_LESS
|
||||
else if (aInt == bInt)
|
||||
GE_EQUAL
|
||||
else
|
||||
GE_GREATER;
|
||||
}
|
||||
|
||||
pub fn __unordtf2(a: f128, b: f128) callconv(.C) c_int {
|
||||
@setRuntimeSafety(is_test);
|
||||
|
||||
const aAbs = @bitCast(rep_t, a) & absMask;
|
||||
const bAbs = @bitCast(rep_t, b) & absMask;
|
||||
return @boolToInt(aAbs > infRep or bAbs > infRep);
|
||||
}
|
||||
Loading…
Reference in New Issue