1 //===-- comparesf2.S - Implement single-precision soft-float comparisons --===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is dual licensed under the MIT and the University of Illinois Open 6 // Source Licenses. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements the following soft-fp_t comparison routines: 11 // 12 // __eqsf2 __gesf2 __unordsf2 13 // __lesf2 __gtsf2 14 // __ltsf2 15 // __nesf2 16 // 17 // The semantics of the routines grouped in each column are identical, so there 18 // is a single implementation for each, with multiple names. 19 // 20 // The routines behave as follows: 21 // 22 // __lesf2(a,b) returns -1 if a < b 23 // 0 if a == b 24 // 1 if a > b 25 // 1 if either a or b is NaN 26 // 27 // __gesf2(a,b) returns -1 if a < b 28 // 0 if a == b 29 // 1 if a > b 30 // -1 if either a or b is NaN 31 // 32 // __unordsf2(a,b) returns 0 if both a and b are numbers 33 // 1 if either a or b is NaN 34 // 35 // Note that __lesf2( ) and __gesf2( ) are identical except in their handling of 36 // NaN values. 37 // 38 //===----------------------------------------------------------------------===// 39 40 #include "../assembly.h" 41 .syntax unified 42 43 .p2align 2 44 DEFINE_COMPILERRT_FUNCTION(__eqsf2) 45 // Make copies of a and b with the sign bit shifted off the top. These will 46 // be used to detect zeros and NaNs. 47 mov r2, r0, lsl #1 48 mov r3, r1, lsl #1 49 50 // We do the comparison in three stages (ignoring NaN values for the time 51 // being). First, we orr the absolute values of a and b; this sets the Z 52 // flag if both a and b are zero (of either sign). The shift of r3 doesn't 53 // effect this at all, but it *does* make sure that the C flag is clear for 54 // the subsequent operations. 55 orrs r12, r2, r3, lsr #1 56 57 // Next, we check if a and b have the same or different signs. If they have 58 // opposite signs, this eor will set the N flag. 59 it ne 60 eorsne r12, r0, r1 61 62 // If a and b are equal (either both zeros or bit identical; again, we're 63 // ignoring NaNs for now), this subtract will zero out r0. If they have the 64 // same sign, the flags are updated as they would be for a comparison of the 65 // absolute values of a and b. 66 it pl 67 subspl r0, r2, r3 68 69 // If a is smaller in magnitude than b and both have the same sign, place 70 // the negation of the sign of b in r0. Thus, if both are negative and 71 // a > b, this sets r0 to 0; if both are positive and a < b, this sets 72 // r0 to -1. 73 // 74 // This is also done if a and b have opposite signs and are not both zero, 75 // because in that case the subtract was not performed and the C flag is 76 // still clear from the shift argument in orrs; if a is positive and b 77 // negative, this places 0 in r0; if a is negative and b positive, -1 is 78 // placed in r0. 79 it lo 80 mvnlo r0, r1, asr #31 81 82 // If a is greater in magnitude than b and both have the same sign, place 83 // the sign of b in r0. Thus, if both are negative and a < b, -1 is placed 84 // in r0, which is the desired result. Conversely, if both are positive 85 // and a > b, zero is placed in r0. 86 it hi 87 movhi r0, r1, asr #31 88 89 // If you've been keeping track, at this point r0 contains -1 if a < b and 90 // 0 if a >= b. All that remains to be done is to set it to 1 if a > b. 91 // If a == b, then the Z flag is set, so we can get the correct final value 92 // into r0 by simply or'ing with 1 if Z is clear. 93 it ne 94 orrne r0, r0, #1 95 96 // Finally, we need to deal with NaNs. If either argument is NaN, replace 97 // the value in r0 with 1. 98 cmp r2, #0xff000000 99 ite ls 100 cmpls r3, #0xff000000 101 movhi r0, #1 102 JMP(lr) 103 END_COMPILERRT_FUNCTION(__eqsf2) 104 DEFINE_COMPILERRT_FUNCTION_ALIAS(__lesf2, __eqsf2) 105 DEFINE_COMPILERRT_FUNCTION_ALIAS(__ltsf2, __eqsf2) 106 DEFINE_COMPILERRT_FUNCTION_ALIAS(__nesf2, __eqsf2) 107 108 .p2align 2 109 DEFINE_COMPILERRT_FUNCTION(__gtsf2) 110 // Identical to the preceding except in that we return -1 for NaN values. 111 // Given that the two paths share so much code, one might be tempted to 112 // unify them; however, the extra code needed to do so makes the code size 113 // to performance tradeoff very hard to justify for such small functions. 114 mov r2, r0, lsl #1 115 mov r3, r1, lsl #1 116 orrs r12, r2, r3, lsr #1 117 it ne 118 eorsne r12, r0, r1 119 it pl 120 subspl r0, r2, r3 121 it lo 122 mvnlo r0, r1, asr #31 123 it hi 124 movhi r0, r1, asr #31 125 it ne 126 orrne r0, r0, #1 127 cmp r2, #0xff000000 128 ite ls 129 cmpls r3, #0xff000000 130 movhi r0, #-1 131 JMP(lr) 132 END_COMPILERRT_FUNCTION(__gtsf2) 133 DEFINE_COMPILERRT_FUNCTION_ALIAS(__gesf2, __gtsf2) 134 135 .p2align 2 136 DEFINE_COMPILERRT_FUNCTION(__unordsf2) 137 // Return 1 for NaN values, 0 otherwise. 138 mov r2, r0, lsl #1 139 mov r3, r1, lsl #1 140 mov r0, #0 141 cmp r2, #0xff000000 142 ite ls 143 cmpls r3, #0xff000000 144 movhi r0, #1 145 JMP(lr) 146 END_COMPILERRT_FUNCTION(__unordsf2) 147 148 DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_fcmpun, __unordsf2) 149 150 NO_EXEC_STACK_DIRECTIVE 151 152
