Print this page
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/lib/libm/amd64/src/libm_inlines.h
+++ new/usr/src/lib/libm/amd64/src/libm_inlines.h
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
|
↓ open down ↓ |
23 lines elided |
↑ open up ↑ |
24 24 */
25 25 /*
26 26 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
27 27 * Use is subject to license terms.
28 28 */
29 29
30 30 /*
31 31 * Copyright 2011, Richard Lowe.
32 32 */
33 33
34 -/* Functions in this file are duplicated in libm.m4. Keep them in sync */
34 +/* Functions in this file are duplicated in locallibm.il. Keep them in sync */
35 35
36 36 #ifndef _LIBM_INLINES_H
37 37 #define _LIBM_INLINES_H
38 38
39 39 #ifdef __GNUC__
40 40
41 41 #ifdef __cplusplus
42 42 extern "C" {
43 43 #endif
44 44
45 45 #include <sys/types.h>
46 46 #include <sys/ieeefp.h>
47 47
48 -extern __inline__ double
49 -__ieee754_sqrt(double a)
50 -{
51 - double ret;
52 -
53 - __asm__ __volatile__("sqrtsd %1, %0\n\t" : "=x" (ret) : "x" (a));
54 - return (ret);
55 -}
56 -
57 48 extern __inline__ float
58 49 __inline_sqrtf(float a)
59 50 {
60 51 float ret;
61 52
62 53 __asm__ __volatile__("sqrtss %1, %0\n\t" : "=x" (ret) : "x" (a));
63 54 return (ret);
64 55 }
65 56
66 57 extern __inline__ double
67 58 __inline_sqrt(double a)
68 59 {
69 60 double ret;
70 61
71 62 __asm__ __volatile__("sqrtsd %1, %0\n\t" : "=x" (ret) : "x" (a));
72 63 return (ret);
73 64 }
74 65
75 -/* XXX: Not actually called */
76 -extern __inline__ short
77 -__inline_fstsw(void)
66 +extern __inline__ double
67 +__ieee754_sqrt(double a)
78 68 {
79 - short ret;
80 -
81 - __asm__ __volatile__("fstsw %0\n\t" : "=r" (ret));
82 - return (ret);
69 + return (__inline_sqrt(a));
83 70 }
84 71
85 72 /*
86 73 * 00 - 24 bits
87 74 * 01 - reserved
88 75 * 10 - 53 bits
89 76 * 11 - 64 bits
90 77 */
91 78 extern __inline__ int
92 79 __swapRP(int i)
93 80 {
94 81 int ret;
95 82 uint16_t cw;
96 83
97 84 __asm__ __volatile__("fstcw %0\n\t" : "=m" (cw));
98 85
99 86 ret = (cw >> 8) & 0x3;
100 87 cw = (cw & 0xfcff) | ((i & 0x3) << 8);
101 88
102 89 __asm__ __volatile__("fldcw %0\n\t" : : "m" (cw));
103 90
104 91 return (ret);
105 92 }
106 93
107 94 /*
108 95 * 00 - Round to nearest, with even preferred
109 96 * 01 - Round down
110 97 * 10 - Round up
111 98 * 11 - Chop
112 99 */
113 100 extern __inline__ enum fp_direction_type
114 101 __swap87RD(enum fp_direction_type i)
115 102 {
116 103 int ret;
117 104 uint16_t cw;
118 105
119 106 __asm__ __volatile__("fstcw %0\n\t" : "=m" (cw));
120 107
121 108 ret = (cw >> 10) & 0x3;
122 109 cw = (cw & 0xf3ff) | ((i & 0x3) << 10);
123 110
|
↓ open down ↓ |
31 lines elided |
↑ open up ↑ |
124 111 __asm__ __volatile__("fldcw %0\n\t" : : "m" (cw));
125 112
126 113 return (ret);
127 114 }
128 115
129 116 extern __inline__ int
130 117 abs(int i)
131 118 {
132 119 int ret;
133 120 __asm__ __volatile__(
134 - "movl %1,%0\n\t"
121 + "movl %1, %0\n\t"
135 122 "negl %1\n\t"
136 - "cmovnsl %1,%0\n\t"
137 - : "=r" (ret), "+r" (i));
123 + "cmovnsl %1, %0\n\t"
124 + : "=r" (ret), "+r" (i)
125 + :
126 + : "cc");
138 127 return (ret);
139 128 }
140 129
141 130 extern __inline__ double
142 131 copysign(double d1, double d2)
143 132 {
144 - double ret;
133 + double tmpd;
145 134
146 135 __asm__ __volatile__(
147 - "movq $0x7fffffffffffffff,%%rax\n\t"
148 - "movd %%rax,%%xmm2\n\t"
149 - "andpd %%xmm2,%0\n\t"
150 - "andnpd %1,%%xmm2\n\t"
151 - "orpd %%xmm2,%0\n\t"
152 - : "=x" (ret)
153 - : "x" (d2), "0" (d1)
154 - : "xmm2", "rax");
136 + "movd %3, %1\n\t"
137 + "andpd %1, %0\n\t"
138 + "andnpd %2, %1\n\t"
139 + "orpd %1, %0\n\t"
140 + : "+x" (d1), "=x" (tmpd)
141 + : "x" (d2), "r" (0x7fffffffffffffff));
155 142
156 - return (ret);
157 -}
158 -
159 -extern __inline__ double
160 -d_sqrt_(double *d)
161 -{
162 - double ret;
163 - __asm__ __volatile__(
164 - "movlpd %1,%0\n\t"
165 - "sqrtsd %0,%0"
166 - : "=x" (ret)
167 - : "m" (*d));
168 - return (ret);
143 + return (d1);
169 144 }
170 145
171 146 extern __inline__ double
172 147 fabs(double d)
173 148 {
174 - double ret;
149 + double tmp;
175 150
176 151 __asm__ __volatile__(
177 - "movq $0x7fffffffffffffff,%%rax\n\t"
178 - "movd %%rax,%%xmm1\n\t"
179 - "andpd %%xmm1,%0"
180 - : "=x" (ret)
181 - : "0" (d)
182 - : "rax", "xmm1");
152 + "movd %2, %1\n\t"
153 + "andpd %1, %0"
154 + : "+x" (d), "=x" (tmp)
155 + : "r" (0x7fffffffffffffff));
183 156
184 - return (ret);
157 + return (d);
185 158 }
186 159
187 160 extern __inline__ float
188 161 fabsf(float d)
189 162 {
190 - float ret;
191 -
192 163 __asm__ __volatile__(
193 - "andpd %2,%0"
194 - : "=x" (ret)
195 - : "0" (d), "x" (0x7fffffff));
164 + "andpd %1, %0"
165 + : "+x" (d)
166 + : "x" (0x7fffffff));
196 167
197 - return (ret);
168 + return (d);
198 169 }
199 170
200 171 extern __inline__ int
201 172 finite(double d)
202 173 {
203 - long ret; /* A long, so gcc chooses an %r* for %0 */
174 + long ret = 0x7fffffffffffffff;
175 + uint64_t tmp;
204 176
205 177 __asm__ __volatile__(
206 - "movq %1,%%rcx\n\t"
207 - "movq $0x7fffffffffffffff,%0\n\t"
208 - "andq %%rcx,%0\n\t"
209 - "movq $0x7ff0000000000000,%%rcx\n\t"
210 - "subq %%rcx,%0\n\t"
211 - "shrq $63,%0\n\t"
212 - : "=r" (ret)
178 + "movq %2, %1\n\t"
179 + "andq %1, %0\n\t"
180 + "movq $0x7ff0000000000000, %1\n\t"
181 + "subq %1, %0\n\t"
182 + "shrq $63, %0\n\t"
183 + : "+r" (ret), "=r" (tmp)
213 184 : "x" (d)
214 - : "rcx");
185 + : "cc");
215 186
216 187 return (ret);
217 188 }
218 189
219 -extern __inline__ float
220 -r_sqrt_(float *f)
221 -{
222 - float ret;
223 -
224 - __asm__ __volatile__(
225 - "movss %1,%0\n\t"
226 - "sqrtss %0,%0\n\t"
227 - : "+x" (ret)
228 - : "m" (*f));
229 - return (ret);
230 -}
231 -
232 190 extern __inline__ int
233 191 signbit(double d)
234 192 {
235 193 long ret;
236 194 __asm__ __volatile__(
237 - "movmskpd %1,%0\n\t"
195 + "movmskpd %1, %0\n\t"
238 196 "andq $1, %0\n\t"
239 197 : "=r" (ret)
240 - : "x" (d));
241 - return (ret);
242 -}
243 -
244 -extern __inline__ int
245 -signbitf(float f)
246 -{
247 - int ret;
248 - __asm__ __volatile__(
249 - "movskps %1,%0\n\t"
250 - "andq $1, %0\n\t"
251 - : "=r" (ret)
252 - : "x" (f));
198 + : "x" (d)
199 + : "cc");
253 200 return (ret);
254 201 }
255 202
256 203 extern __inline__ double
257 204 sqrt(double d)
258 205 {
259 - double ret;
260 -
261 - __asm__ __volatile__(
262 - "sqrtsd %0, %0"
263 - : "=x" (ret)
264 - : "0" (d));
265 - return (ret);
206 + return (__inline_sqrt(d));
266 207 }
267 208
268 209 extern __inline__ float
269 210 sqrtf(float f)
270 211 {
271 - float ret;
272 -
273 - __asm__ __volatile__(
274 - "sqrtss %0, %0"
275 - : "=x" (ret)
276 - : "0" (f));
277 - return (ret);
212 + return (__inline_sqrtf(f));
278 213 }
279 214
280 215 #ifdef __cplusplus
281 216 }
282 217 #endif
283 218
284 219 #endif /* __GNUC__ */
285 220
286 221 #endif /* _LIBM_INLINES_H */
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX