cc1125097b1ab681e93289985b80cb0c46c1b67a
[dragonfly.git] / lib / libm / arch / i386 / fenv.c
1 /*-
2  * Copyright (c) 2004-2005 David Schultz <das@FreeBSD.ORG>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD: src/lib/msun/i387/fenv.c,v 1.4 2010/02/03 20:23:47 kib Exp $
27  */
28
29 #include <sys/cdefs.h>
30 #include <sys/types.h>
31 #include <machine/npx.h>
32 #include "fenv.h"
33
34 const fenv_t __fe_dfl_env = {
35         __INITIAL_NPXCW__,
36         0x0000,
37         0x00001f80,
38         0xffffffff,
39         { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
40           0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff }
41 };
42
43 enum __sse_support __has_sse =
44 #ifdef __SSE__
45         __SSE_YES;
46 #else
47         __SSE_UNK;
48 #endif
49
50 #define getfl(x)        __asm __volatile("pushfl\n\tpopl %0" : "=mr" (*(x)))
51 #define setfl(x)        __asm __volatile("pushl %0\n\tpopfl" : : "g" (x))
52 #define cpuid_dx(x)     __asm __volatile("pushl %%ebx\n\tmovl $1, %%eax\n\t"  \
53                                          "cpuid\n\tpopl %%ebx"                \
54                                         : "=d" (*(x)) : : "eax", "ecx")
55
56 /*
57  * Test for SSE support on this processor.  We need to do this because
58  * we need to use ldmxcsr/stmxcsr to get correct results if any part
59  * of the program was compiled to use SSE floating-point, but we can't
60  * use SSE on older processors.
61  */
62 int
63 __test_sse(void)
64 {
65         int flag, nflag;
66         int dx_features;
67
68         /* Am I a 486? */
69         getfl(&flag);
70         nflag = flag ^ 0x200000;
71         setfl(nflag);
72         getfl(&nflag);
73         if (flag != nflag) {
74                 /* Not a 486, so CPUID should work. */
75                 cpuid_dx(&dx_features);
76                 if (dx_features & 0x2000000) {
77                         __has_sse = __SSE_YES;
78                         return (1);
79                 }
80         }
81         __has_sse = __SSE_NO;
82         return (0);
83 }
84
85 int
86 fesetexceptflag(const fexcept_t *flagp, int excepts)
87 {
88         fenv_t env;
89         __uint32_t mxcsr;
90
91         __fnstenv(&env);
92         env.__status &= ~excepts;
93         env.__status |= *flagp & excepts;
94         __fldenv(env);
95
96         if (__HAS_SSE()) {
97                 __stmxcsr(&mxcsr);
98                 mxcsr &= ~excepts;
99                 mxcsr |= *flagp & excepts;
100                 __ldmxcsr(mxcsr);
101         }
102
103         return (0);
104 }
105
106 int
107 feraiseexcept(int excepts)
108 {
109         fexcept_t ex = excepts;
110
111         fesetexceptflag(&ex, excepts);
112         __fwait();
113         return (0);
114 }
115
116 int
117 fegetenv(fenv_t *envp)
118 {
119         __uint32_t mxcsr;
120
121         __fnstenv(envp);
122         /*
123          * fnstenv masks all exceptions, so we need to restore
124          * the old control word to avoid this side effect.
125          */
126         __fldcw(envp->__control);
127         if (__HAS_SSE()) {
128                 __stmxcsr(&mxcsr);
129                 envp->__mxcsr = mxcsr;
130         }
131         return (0);
132 }
133
134 int
135 feholdexcept(fenv_t *envp)
136 {
137         __uint32_t mxcsr;
138
139         __fnstenv(envp);
140         __fnclex();
141         if (__HAS_SSE()) {
142                 __stmxcsr(&mxcsr);
143                 envp->__mxcsr = mxcsr;
144                 mxcsr &= ~FE_ALL_EXCEPT;
145                 mxcsr |= FE_ALL_EXCEPT << _SSE_EMASK_SHIFT;
146                 __ldmxcsr(mxcsr);
147         }
148         return (0);
149 }
150
151 int
152 feupdateenv(const fenv_t *envp)
153 {
154         __uint32_t mxcsr;
155         __uint16_t status;
156
157         __fnstsw(&status);
158         if (__HAS_SSE())
159                 __stmxcsr(&mxcsr);
160         else
161                 mxcsr = 0;
162         fesetenv(envp);
163         feraiseexcept((mxcsr | status) & FE_ALL_EXCEPT);
164         return (0);
165 }
166
167 int
168 __feenableexcept(int mask)
169 {
170         __uint32_t mxcsr, omask;
171         __uint16_t control;
172
173         mask &= FE_ALL_EXCEPT;
174         __fnstcw(&control);
175         if (__HAS_SSE())
176                 __stmxcsr(&mxcsr);
177         else
178                 mxcsr = 0;
179         omask = (control | mxcsr >> _SSE_EMASK_SHIFT) & FE_ALL_EXCEPT;
180         control &= ~mask;
181         __fldcw(control);
182         if (__HAS_SSE()) {
183                 mxcsr &= ~(mask << _SSE_EMASK_SHIFT);
184                 __ldmxcsr(mxcsr);
185         }
186         return (~omask);
187 }
188
189 int
190 __fedisableexcept(int mask)
191 {
192         __uint32_t mxcsr, omask;
193         __uint16_t control;
194
195         mask &= FE_ALL_EXCEPT;
196         __fnstcw(&control);
197         if (__HAS_SSE())
198                 __stmxcsr(&mxcsr);
199         else
200                 mxcsr = 0;
201         omask = (control | mxcsr >> _SSE_EMASK_SHIFT) & FE_ALL_EXCEPT;
202         control |= mask;
203         __fldcw(control);
204         if (__HAS_SSE()) {
205                 mxcsr |= mask << _SSE_EMASK_SHIFT;
206                 __ldmxcsr(mxcsr);
207         }
208         return (~omask);
209 }
210
211 __weak_reference(__feenableexcept, feenableexcept);
212 __weak_reference(__fedisableexcept, fedisableexcept);