| //===-- comparesf2.S - Implement single-precision soft-float comparisons --===// |
| // |
| // 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, with multiple names. |
| // |
| // The 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. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "../assembly.h" |
| .syntax unified |
| #if __ARM_ARCH_ISA_THUMB == 2 |
| .thumb |
| #endif |
| |
| @ int __eqsf2(float a, float b) |
| |
| .p2align 2 |
| DEFINE_COMPILERRT_FUNCTION(__eqsf2) |
| #if defined(COMPILER_RT_ARMHF_TARGET) |
| vmov r0, s0 |
| vmov r1, s1 |
| #endif |
| // Make copies of a and b with the sign bit shifted off the top. These will |
| // be used to detect zeros and NaNs. |
| #if __ARM_ARCH_ISA_THUMB == 1 |
| push {r6, lr} |
| lsls r2, r0, #1 |
| lsls r3, r1, #1 |
| #else |
| mov r2, r0, lsl #1 |
| mov r3, r1, lsl #1 |
| #endif |
| |
| // We do the comparison in three stages (ignoring NaN values for the time |
| // being). First, we orr the absolute values of a and b; this sets the Z |
| // flag if both a and b are zero (of either sign). The shift of r3 doesn't |
| // effect this at all, but it *does* make sure that the C flag is clear for |
| // the subsequent operations. |
| #if __ARM_ARCH_ISA_THUMB == 1 |
| lsrs r6, r3, #1 |
| orrs r6, r2 |
| #else |
| orrs r12, r2, r3, lsr #1 |
| #endif |
| // Next, we check if a and b have the same or different signs. If they have |
| // opposite signs, this eor will set the N flag. |
| #if __ARM_ARCH_ISA_THUMB == 1 |
| beq 1f |
| movs r6, r0 |
| eors r6, r1 |
| 1: |
| #else |
| it ne |
| eorsne r12, r0, r1 |
| #endif |
| |
| // If a and b are equal (either both zeros or bit identical; again, we're |
| // ignoring NaNs for now), this subtract will zero out r0. If they have the |
| // same sign, the flags are updated as they would be for a comparison of the |
| // absolute values of a and b. |
| #if __ARM_ARCH_ISA_THUMB == 1 |
| bmi 1f |
| subs r0, r2, r3 |
| 1: |
| #else |
| it pl |
| subspl r0, r2, r3 |
| #endif |
| |
| // If a is smaller in magnitude than b and both have the same sign, place |
| // the negation of the sign of b in r0. Thus, if both are negative and |
| // a > b, this sets r0 to 0; if both are positive and a < b, this sets |
| // r0 to -1. |
| // |
| // This is also done if a and b have opposite signs and are not both zero, |
| // because in that case the subtract was not performed and the C flag is |
| // still clear from the shift argument in orrs; if a is positive and b |
| // negative, this places 0 in r0; if a is negative and b positive, -1 is |
| // placed in r0. |
| #if __ARM_ARCH_ISA_THUMB == 1 |
| bhs 1f |
| // Here if a and b have the same sign and absA < absB, the result is thus |
| // b < 0 ? 1 : -1. Same if a and b have the opposite sign (ignoring Nan). |
| movs r0, #1 |
| lsrs r1, #31 |
| bne LOCAL_LABEL(CHECK_NAN) |
| negs r0, r0 |
| b LOCAL_LABEL(CHECK_NAN) |
| 1: |
| #else |
| it lo |
| mvnlo r0, r1, asr #31 |
| #endif |
| |
| // If a is greater in magnitude than b and both have the same sign, place |
| // the sign of b in r0. Thus, if both are negative and a < b, -1 is placed |
| // in r0, which is the desired result. Conversely, if both are positive |
| // and a > b, zero is placed in r0. |
| #if __ARM_ARCH_ISA_THUMB == 1 |
| bls 1f |
| // Here both have the same sign and absA > absB. |
| movs r0, #1 |
| lsrs r1, #31 |
| beq LOCAL_LABEL(CHECK_NAN) |
| negs r0, r0 |
| 1: |
| #else |
| it hi |
| movhi r0, r1, asr #31 |
| #endif |
| |
| // If you've been keeping track, at this point r0 contains -1 if a < b and |
| // 0 if a >= b. All that remains to be done is to set it to 1 if a > b. |
| // If a == b, then the Z flag is set, so we can get the correct final value |
| // into r0 by simply or'ing with 1 if Z is clear. |
| // For Thumb-1, r0 contains -1 if a < b, 0 if a > b and 0 if a == b. |
| #if __ARM_ARCH_ISA_THUMB != 1 |
| it ne |
| orrne r0, r0, #1 |
| #endif |
| |
| // Finally, we need to deal with NaNs. If either argument is NaN, replace |
| // the value in r0 with 1. |
| #if __ARM_ARCH_ISA_THUMB == 1 |
| LOCAL_LABEL(CHECK_NAN): |
| movs r6, #0xff |
| lsls r6, #24 |
| cmp r2, r6 |
| bhi 1f |
| cmp r3, r6 |
| 1: |
| bls 2f |
| movs r0, #1 |
| 2: |
| pop {r6, pc} |
| #else |
| cmp r2, #0xff000000 |
| ite ls |
| cmpls r3, #0xff000000 |
| movhi r0, #1 |
| JMP(lr) |
| #endif |
| END_COMPILERRT_FUNCTION(__eqsf2) |
| |
| DEFINE_COMPILERRT_FUNCTION_ALIAS(__lesf2, __eqsf2) |
| DEFINE_COMPILERRT_FUNCTION_ALIAS(__ltsf2, __eqsf2) |
| DEFINE_COMPILERRT_FUNCTION_ALIAS(__nesf2, __eqsf2) |
| |
| @ int __gtsf2(float a, float b) |
| |
| .p2align 2 |
| DEFINE_COMPILERRT_FUNCTION(__gtsf2) |
| // Identical to the preceding except in that we return -1 for NaN values. |
| // Given that the two paths share so much code, one might be tempted to |
| // unify them; however, the extra code needed to do so makes the code size |
| // to performance tradeoff very hard to justify for such small functions. |
| #if defined(COMPILER_RT_ARMHF_TARGET) |
| vmov r0, s0 |
| vmov r1, s1 |
| #endif |
| #if __ARM_ARCH_ISA_THUMB == 1 |
| push {r6, lr} |
| lsls r2, r0, #1 |
| lsls r3, r1, #1 |
| lsrs r6, r3, #1 |
| orrs r6, r2 |
| beq 1f |
| movs r6, r0 |
| eors r6, r1 |
| 1: |
| bmi 2f |
| subs r0, r2, r3 |
| 2: |
| bhs 3f |
| movs r0, #1 |
| lsrs r1, #31 |
| bne LOCAL_LABEL(CHECK_NAN_2) |
| negs r0, r0 |
| b LOCAL_LABEL(CHECK_NAN_2) |
| 3: |
| bls 4f |
| movs r0, #1 |
| lsrs r1, #31 |
| beq LOCAL_LABEL(CHECK_NAN_2) |
| negs r0, r0 |
| 4: |
| LOCAL_LABEL(CHECK_NAN_2): |
| movs r6, #0xff |
| lsls r6, #24 |
| cmp r2, r6 |
| bhi 5f |
| cmp r3, r6 |
| 5: |
| bls 6f |
| movs r0, #1 |
| negs r0, r0 |
| 6: |
| pop {r6, pc} |
| #else |
| mov r2, r0, lsl #1 |
| mov r3, r1, lsl #1 |
| orrs r12, r2, r3, lsr #1 |
| it ne |
| eorsne r12, r0, r1 |
| it pl |
| subspl r0, r2, r3 |
| it lo |
| mvnlo r0, r1, asr #31 |
| it hi |
| movhi r0, r1, asr #31 |
| it ne |
| orrne r0, r0, #1 |
| cmp r2, #0xff000000 |
| ite ls |
| cmpls r3, #0xff000000 |
| movhi r0, #-1 |
| JMP(lr) |
| #endif |
| END_COMPILERRT_FUNCTION(__gtsf2) |
| |
| DEFINE_COMPILERRT_FUNCTION_ALIAS(__gesf2, __gtsf2) |
| |
| @ int __unordsf2(float a, float b) |
| |
| .p2align 2 |
| DEFINE_COMPILERRT_FUNCTION(__unordsf2) |
| #if defined(COMPILER_RT_ARMHF_TARGET) |
| vmov r0, s0 |
| vmov r1, s1 |
| #endif |
| // Return 1 for NaN values, 0 otherwise. |
| lsls r2, r0, #1 |
| lsls r3, r1, #1 |
| movs r0, #0 |
| #if __ARM_ARCH_ISA_THUMB == 1 |
| movs r1, #0xff |
| lsls r1, #24 |
| cmp r2, r1 |
| bhi 1f |
| cmp r3, r1 |
| 1: |
| bls 2f |
| movs r0, #1 |
| 2: |
| #else |
| cmp r2, #0xff000000 |
| ite ls |
| cmpls r3, #0xff000000 |
| movhi r0, #1 |
| #endif |
| JMP(lr) |
| END_COMPILERRT_FUNCTION(__unordsf2) |
| |
| #if defined(COMPILER_RT_ARMHF_TARGET) |
| DEFINE_COMPILERRT_FUNCTION(__aeabi_fcmpum) |
| vmov s0, r0 |
| vmov s1, r1 |
| b SYMBOL_NAME(__unordsf2) |
| END_COMPILERRT_FUNCTION(__aeabi_fcmpum) |
| #else |
| DEFINE_AEABI_FUNCTION_ALIAS(__aeabi_fcmpun, __unordsf2) |
| #endif |
| |
| NO_EXEC_STACK_DIRECTIVE |
| |
