0d586d06a7
r303188 removed all the uses of aliases for EABI functions from compiler-rt, because some of them had mismatched calling conventions. Obviously, we can't use aliases for functions which don't have the same calling convention, but that's only an issue for floating-point functions with the hardfloat ABI. In other cases, the stubs increase size and reduce performance for no benefit. This patch adds back the aliases, with appropriate checks to make sure they're only used in cases where the calling convention matches. llvm-svn: 314851
154 lines
4.3 KiB
C
154 lines
4.3 KiB
C
//===-- lib/comparesf2.c - Single-precision comparisons -----------*- C -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is dual licensed under the MIT and the University of Illinois Open
|
|
// Source Licenses. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the following soft-fp_t comparison routines:
|
|
//
|
|
// __eqsf2 __gesf2 __unordsf2
|
|
// __lesf2 __gtsf2
|
|
// __ltsf2
|
|
// __nesf2
|
|
//
|
|
// The semantics of the routines grouped in each column are identical, so there
|
|
// is a single implementation for each, and wrappers to provide the other names.
|
|
//
|
|
// The main routines behave as follows:
|
|
//
|
|
// __lesf2(a,b) returns -1 if a < b
|
|
// 0 if a == b
|
|
// 1 if a > b
|
|
// 1 if either a or b is NaN
|
|
//
|
|
// __gesf2(a,b) returns -1 if a < b
|
|
// 0 if a == b
|
|
// 1 if a > b
|
|
// -1 if either a or b is NaN
|
|
//
|
|
// __unordsf2(a,b) returns 0 if both a and b are numbers
|
|
// 1 if either a or b is NaN
|
|
//
|
|
// Note that __lesf2( ) and __gesf2( ) are identical except in their handling of
|
|
// NaN values.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#define SINGLE_PRECISION
|
|
#include "fp_lib.h"
|
|
|
|
enum LE_RESULT {
|
|
LE_LESS = -1,
|
|
LE_EQUAL = 0,
|
|
LE_GREATER = 1,
|
|
LE_UNORDERED = 1
|
|
};
|
|
|
|
COMPILER_RT_ABI enum LE_RESULT
|
|
__lesf2(fp_t a, fp_t b) {
|
|
|
|
const srep_t aInt = toRep(a);
|
|
const srep_t bInt = toRep(b);
|
|
const rep_t aAbs = aInt & absMask;
|
|
const rep_t bAbs = bInt & absMask;
|
|
|
|
// If either a or b is NaN, they are unordered.
|
|
if (aAbs > infRep || 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;
|
|
}
|
|
}
|
|
|
|
#if defined(__ELF__)
|
|
// Alias for libgcc compatibility
|
|
FNALIAS(__cmpsf2, __lesf2);
|
|
#endif
|
|
|
|
enum GE_RESULT {
|
|
GE_LESS = -1,
|
|
GE_EQUAL = 0,
|
|
GE_GREATER = 1,
|
|
GE_UNORDERED = -1 // Note: different from LE_UNORDERED
|
|
};
|
|
|
|
COMPILER_RT_ABI enum GE_RESULT
|
|
__gesf2(fp_t a, fp_t b) {
|
|
|
|
const srep_t aInt = toRep(a);
|
|
const srep_t bInt = toRep(b);
|
|
const rep_t aAbs = aInt & absMask;
|
|
const rep_t bAbs = bInt & absMask;
|
|
|
|
if (aAbs > infRep || 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;
|
|
}
|
|
}
|
|
|
|
COMPILER_RT_ABI int
|
|
__unordsf2(fp_t a, fp_t b) {
|
|
const rep_t aAbs = toRep(a) & absMask;
|
|
const rep_t bAbs = toRep(b) & absMask;
|
|
return aAbs > infRep || bAbs > infRep;
|
|
}
|
|
|
|
// The following are alternative names for the preceding routines.
|
|
|
|
COMPILER_RT_ABI enum LE_RESULT
|
|
__eqsf2(fp_t a, fp_t b) {
|
|
return __lesf2(a, b);
|
|
}
|
|
|
|
COMPILER_RT_ABI enum LE_RESULT
|
|
__ltsf2(fp_t a, fp_t b) {
|
|
return __lesf2(a, b);
|
|
}
|
|
|
|
COMPILER_RT_ABI enum LE_RESULT
|
|
__nesf2(fp_t a, fp_t b) {
|
|
return __lesf2(a, b);
|
|
}
|
|
|
|
COMPILER_RT_ABI enum GE_RESULT
|
|
__gtsf2(fp_t a, fp_t b) {
|
|
return __gesf2(a, b);
|
|
}
|
|
|
|
#if defined(__ARM_EABI__)
|
|
#if defined(COMPILER_RT_ARMHF_TARGET)
|
|
AEABI_RTABI int __aeabi_fcmpun(fp_t a, fp_t b) {
|
|
return __unordsf2(a, b);
|
|
}
|
|
#else
|
|
AEABI_RTABI int __aeabi_fcmpun(fp_t a, fp_t b) COMPILER_RT_ALIAS(__unordsf2);
|
|
#endif
|
|
#endif
|