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.align 2 44DEFINE_COMPILERRT_FUNCTION(__eqsf2) 45DEFINE_COMPILERRT_FUNCTION(__lesf2) 46DEFINE_COMPILERRT_FUNCTION(__ltsf2) 47DEFINE_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 102DEFINE_COMPILERRT_FUNCTION(__gesf2) 103DEFINE_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 122DEFINE_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 131