1//===-- lib/fp_compare_impl.inc - Floating-point comparison -------*- C -*-===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8 9#include "fp_lib.h" 10 11// GCC uses long (at least for x86_64) as the return type of the comparison 12// functions. We need to ensure that the return value is sign-extended in the 13// same way as GCC expects (since otherwise GCC-generated __builtin_isinf 14// returns true for finite 128-bit floating-point numbers). 15#ifdef __aarch64__ 16// AArch64 GCC overrides libgcc_cmp_return to use int instead of long. 17typedef int CMP_RESULT; 18#elif __SIZEOF_POINTER__ == 8 && __SIZEOF_LONG__ == 4 19// LLP64 ABIs use long long instead of long. 20typedef long long CMP_RESULT; 21#elif __AVR__ 22// AVR uses a single byte for the return value. 23typedef char CMP_RESULT; 24#else 25// Otherwise the comparison functions return long. 26typedef long CMP_RESULT; 27#endif 28 29#if !defined(__clang__) && defined(__GNUC__) 30// GCC uses a special __libgcc_cmp_return__ mode to define the return type, so 31// check that we are ABI-compatible when compiling the builtins with GCC. 32typedef int GCC_CMP_RESULT __attribute__((__mode__(__libgcc_cmp_return__))); 33_Static_assert(sizeof(GCC_CMP_RESULT) == sizeof(CMP_RESULT), 34 "SOFTFP ABI not compatible with GCC"); 35#endif 36 37enum { 38 LE_LESS = -1, 39 LE_EQUAL = 0, 40 LE_GREATER = 1, 41 LE_UNORDERED = 1, 42}; 43 44static inline CMP_RESULT __leXf2__(fp_t a, fp_t b) { 45 const srep_t aInt = toRep(a); 46 const srep_t bInt = toRep(b); 47 const rep_t aAbs = aInt & absMask; 48 const rep_t bAbs = bInt & absMask; 49 50 // If either a or b is NaN, they are unordered. 51 if (aAbs > infRep || bAbs > infRep) 52 return LE_UNORDERED; 53 54 // If a and b are both zeros, they are equal. 55 if ((aAbs | bAbs) == 0) 56 return LE_EQUAL; 57 58 // If at least one of a and b is positive, we get the same result comparing 59 // a and b as signed integers as we would with a floating-point compare. 60 if ((aInt & bInt) >= 0) { 61 if (aInt < bInt) 62 return LE_LESS; 63 else if (aInt == bInt) 64 return LE_EQUAL; 65 else 66 return LE_GREATER; 67 } else { 68 // Otherwise, both are negative, so we need to flip the sense of the 69 // comparison to get the correct result. (This assumes a twos- or ones- 70 // complement integer representation; if integers are represented in a 71 // sign-magnitude representation, then this flip is incorrect). 72 if (aInt > bInt) 73 return LE_LESS; 74 else if (aInt == bInt) 75 return LE_EQUAL; 76 else 77 return LE_GREATER; 78 } 79} 80 81enum { 82 GE_LESS = -1, 83 GE_EQUAL = 0, 84 GE_GREATER = 1, 85 GE_UNORDERED = -1 // Note: different from LE_UNORDERED 86}; 87 88static inline CMP_RESULT __geXf2__(fp_t a, fp_t b) { 89 const srep_t aInt = toRep(a); 90 const srep_t bInt = toRep(b); 91 const rep_t aAbs = aInt & absMask; 92 const rep_t bAbs = bInt & absMask; 93 94 if (aAbs > infRep || bAbs > infRep) 95 return GE_UNORDERED; 96 if ((aAbs | bAbs) == 0) 97 return GE_EQUAL; 98 if ((aInt & bInt) >= 0) { 99 if (aInt < bInt) 100 return GE_LESS; 101 else if (aInt == bInt) 102 return GE_EQUAL; 103 else 104 return GE_GREATER; 105 } else { 106 if (aInt > bInt) 107 return GE_LESS; 108 else if (aInt == bInt) 109 return GE_EQUAL; 110 else 111 return GE_GREATER; 112 } 113} 114 115static inline CMP_RESULT __unordXf2__(fp_t a, fp_t b) { 116 const rep_t aAbs = toRep(a) & absMask; 117 const rep_t bAbs = toRep(b) & absMask; 118 return aAbs > infRep || bAbs > infRep; 119} 120