]>
Commit | Line | Data |
---|---|---|
223e47cc LB |
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 | |
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 |