Stephen Canon | c8c6359 | 2010-07-08 17:45:05 +0000 | [diff] [blame] | 1 | //===-- comparesf2.S - Implement single-precision soft-float comparisons --===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Howard Hinnant | 9ad441f | 2010-11-16 22:13:33 +0000 | [diff] [blame] | 5 | // This file is dual licensed under the MIT and the University of Illinois Open |
| 6 | // Source Licenses. See LICENSE.TXT for details. |
Stephen Canon | c8c6359 | 2010-07-08 17:45:05 +0000 | [diff] [blame] | 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 | |
Stephen Canon | c8c6359 | 2010-07-08 17:45:05 +0000 | [diff] [blame] | 40 | #include "../assembly.h" |
| 41 | .syntax unified |
| 42 | |
| 43 | .align 2 |
| 44 | DEFINE_COMPILERRT_FUNCTION(__eqsf2) |
| 45 | DEFINE_COMPILERRT_FUNCTION(__lesf2) |
| 46 | DEFINE_COMPILERRT_FUNCTION(__ltsf2) |
| 47 | DEFINE_COMPILERRT_FUNCTION(__nesf2) |
| 48 | // Make copies of a and b with the sign bit shifted off the top. These will |
| 49 | // be used to detect zeros and NaNs. |
| 50 | mov r2, r0, lsl #1 |
| 51 | mov r3, r1, lsl #1 |
| 52 | |
| 53 | // We do the comparison in three stages (ignoring NaN values for the time |
| 54 | // being). First, we orr the absolute values of a and b; this sets the Z |
| 55 | // flag if both a and b are zero (of either sign). The shift of r3 doesn't |
| 56 | // effect this at all, but it *does* make sure that the C flag is clear for |
| 57 | // the subsequent operations. |
| 58 | orrs r12, r2, r3, lsr #1 |
| 59 | |
| 60 | // Next, we check if a and b have the same or different signs. If they have |
| 61 | // opposite signs, this eor will set the N flag. |
| 62 | eorsne r12, r0, r1 |
| 63 | |
| 64 | // If a and b are equal (either both zeros or bit identical; again, we're |
| 65 | // ignoring NaNs for now), this subtract will zero out r0. If they have the |
| 66 | // same sign, the flags are updated as they would be for a comparison of the |
| 67 | // absolute values of a and b. |
| 68 | subspl r0, r2, r3 |
| 69 | |
| 70 | // If a is smaller in magnitude than b and both have the same sign, place |
| 71 | // the negation of the sign of b in r0. Thus, if both are negative and |
| 72 | // a > b, this sets r0 to 0; if both are positive and a < b, this sets |
| 73 | // r0 to -1. |
| 74 | // |
| 75 | // This is also done if a and b have opposite signs and are not both zero, |
| 76 | // because in that case the subtract was not performed and the C flag is |
| 77 | // still clear from the shift argument in orrs; if a is positive and b |
| 78 | // negative, this places 0 in r0; if a is negative and b positive, -1 is |
| 79 | // placed in r0. |
| 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 | movhi r0, r1, asr #31 |
| 87 | |
| 88 | // If you've been keeping track, at this point r0 contains -1 if a < b and |
| 89 | // 0 if a >= b. All that remains to be done is to set it to 1 if a > b. |
| 90 | // If a == b, then the Z flag is set, so we can get the correct final value |
| 91 | // into r0 by simply or'ing with 1 if Z is clear. |
| 92 | orrne r0, r0, #1 |
| 93 | |
| 94 | // Finally, we need to deal with NaNs. If either argument is NaN, replace |
| 95 | // the value in r0 with 1. |
| 96 | cmp r2, #0xff000000 |
| 97 | cmpls r3, #0xff000000 |
| 98 | movhi r0, #1 |
| 99 | bx lr |
| 100 | |
| 101 | .align 2 |
| 102 | DEFINE_COMPILERRT_FUNCTION(__gesf2) |
| 103 | DEFINE_COMPILERRT_FUNCTION(__gtsf2) |
| 104 | // Identical to the preceeding except in that we return -1 for NaN values. |
| 105 | // Given that the two paths share so much code, one might be tempted to |
| 106 | // unify them; however, the extra code needed to do so makes the code size |
| 107 | // to performance tradeoff very hard to justify for such small functions. |
| 108 | mov r2, r0, lsl #1 |
| 109 | mov r3, r1, lsl #1 |
| 110 | orrs r12, r2, r3, lsr #1 |
| 111 | eorsne r12, r0, r1 |
| 112 | subspl r0, r2, r3 |
| 113 | mvnlo r0, r1, asr #31 |
| 114 | movhi r0, r1, asr #31 |
| 115 | orrne r0, r0, #1 |
| 116 | cmp r2, #0xff000000 |
| 117 | cmpls r3, #0xff000000 |
| 118 | movhi r0, #-1 |
| 119 | bx lr |
| 120 | |
| 121 | .align 2 |
| 122 | DEFINE_COMPILERRT_FUNCTION(__unordsf2) |
| 123 | // Return 1 for NaN values, 0 otherwise. |
| 124 | mov r2, r0, lsl #1 |
| 125 | mov r3, r1, lsl #1 |
| 126 | mov r0, #0 |
| 127 | cmp r2, #0xff000000 |
| 128 | cmpls r3, #0xff000000 |
| 129 | movhi r0, #1 |
| 130 | bx lr |