1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
24 */
25 /*
26 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
27 * Use is subject to license terms.
28 */
29
30 /*
31 * Copyright 2011, Richard Lowe.
32 */
33
34 /* Functions in this file are duplicated in locallibm.il. Keep them in sync */
35
36 #ifndef _LIBM_INLINES_H
37 #define _LIBM_INLINES_H
38
39 #ifdef __GNUC__
40
41 #ifdef __cplusplus
42 extern "C" {
43 #endif
44
45 #include <sys/types.h>
46 #include <sys/ieeefp.h>
47
48 extern __inline__ float
49 __inline_sqrtf(float a)
50 {
51 float ret;
52
53 __asm__ __volatile__("sqrtss %1, %0\n\t" : "=x" (ret) : "x" (a));
54 return (ret);
55 }
56
57 extern __inline__ double
58 __inline_sqrt(double a)
59 {
60 double ret;
61
62 __asm__ __volatile__("sqrtsd %1, %0\n\t" : "=x" (ret) : "x" (a));
63 return (ret);
64 }
65
66 extern __inline__ double
67 __ieee754_sqrt(double a)
68 {
69 return (__inline_sqrt(a));
70 }
71
72 /*
73 * 00 - 24 bits
74 * 01 - reserved
75 * 10 - 53 bits
76 * 11 - 64 bits
77 */
78 extern __inline__ int
79 __swapRP(int i)
80 {
81 int ret;
82 uint16_t cw;
83
84 __asm__ __volatile__("fstcw %0\n\t" : "=m" (cw));
85
86 ret = (cw >> 8) & 0x3;
87 cw = (cw & 0xfcff) | ((i & 0x3) << 8);
88
89 __asm__ __volatile__("fldcw %0\n\t" : : "m" (cw));
90
91 return (ret);
92 }
93
94 /*
95 * 00 - Round to nearest, with even preferred
96 * 01 - Round down
97 * 10 - Round up
98 * 11 - Chop
99 */
100 extern __inline__ enum fp_direction_type
101 __swap87RD(enum fp_direction_type i)
102 {
103 int ret;
104 uint16_t cw;
105
106 __asm__ __volatile__("fstcw %0\n\t" : "=m" (cw));
107
108 ret = (cw >> 10) & 0x3;
109 cw = (cw & 0xf3ff) | ((i & 0x3) << 10);
110
111 __asm__ __volatile__("fldcw %0\n\t" : : "m" (cw));
112
113 return (ret);
114 }
115
116 extern __inline__ int
117 abs(int i)
118 {
119 int ret;
120 __asm__ __volatile__(
121 "movl %1, %0\n\t"
122 "negl %1\n\t"
123 "cmovnsl %1, %0\n\t"
124 : "=r" (ret), "+r" (i)
125 :
126 : "cc");
127 return (ret);
128 }
129
130 extern __inline__ double
131 copysign(double d1, double d2)
132 {
133 double tmpd;
134
135 __asm__ __volatile__(
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));
142
143 return (d1);
144 }
145
146 extern __inline__ double
147 fabs(double d)
148 {
149 double tmp;
150
151 __asm__ __volatile__(
152 "movd %2, %1\n\t"
153 "andpd %1, %0"
154 : "+x" (d), "=&x" (tmp)
155 : "r" (0x7fffffffffffffff));
156
157 return (d);
158 }
159
160 extern __inline__ float
161 fabsf(float d)
162 {
163 __asm__ __volatile__(
164 "andpd %1, %0"
165 : "+x" (d)
166 : "x" (0x7fffffff));
167
168 return (d);
169 }
170
171 extern __inline__ int
172 finite(double d)
173 {
174 long ret = 0x7fffffffffffffff;
175 uint64_t tmp;
176
177 __asm__ __volatile__(
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)
184 : "x" (d)
185 : "cc");
186
187 return (ret);
188 }
189
190 extern __inline__ int
191 signbit(double d)
192 {
193 long ret;
194 __asm__ __volatile__(
195 "movmskpd %1, %0\n\t"
196 "andq $1, %0\n\t"
197 : "=r" (ret)
198 : "x" (d)
199 : "cc");
200 return (ret);
201 }
202
203 extern __inline__ double
204 sqrt(double d)
205 {
206 return (__inline_sqrt(d));
207 }
208
209 extern __inline__ float
210 sqrtf(float f)
211 {
212 return (__inline_sqrtf(f));
213 }
214
215 #ifdef __cplusplus
216 }
217 #endif
218
219 #endif /* __GNUC__ */
220
221 #endif /* _LIBM_INLINES_H */