1 /*
2 * Mesa 3-D graphics library
3 * Version: 6.5.1
4 *
5 * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25 /**
26 * \file common_x86.c
27 *
28 * Check CPU capabilities & initialize optimized funtions for this particular
29 * processor.
30 *
31 * Changed by Andre Werthmann for using the new SSE functions.
32 *
33 * \author Holger Waechtler <holger@akaflieg.extern.tu-berlin.de>
34 * \author Andre Werthmann <wertmann@cs.uni-potsdam.de>
35 */
36
37 /* XXX these includes should probably go into imports.h or glheader.h */
38 #if defined(USE_SSE_ASM) && defined(__linux__)
39 #include <linux/version.h>
40 #endif
41 #if defined(USE_SSE_ASM) && defined(__FreeBSD__)
42 #include <sys/types.h>
43 #include <sys/sysctl.h>
44 #endif
45 #if defined(USE_SSE_ASM) && defined(__OpenBSD__)
46 #include <sys/param.h>
47 #include <sys/sysctl.h>
48 #include <machine/cpu.h>
49 #endif
50
51 #include "main/imports.h"
52 #include "common_x86_asm.h"
53
54
55 /** Bitmask of X86_FEATURE_x bits */
56 int _mesa_x86_cpu_features = 0x0;
57
58 static int detection_debug = GL_FALSE;
59
60 /* No reason for this to be public.
61 */
62 extern GLuint _ASMAPI _mesa_x86_has_cpuid(void);
63 extern void _ASMAPI _mesa_x86_cpuid(GLuint op, GLuint *reg_eax, GLuint *reg_ebx, GLuint *reg_ecx, GLuint *reg_edx);
64 extern GLuint _ASMAPI _mesa_x86_cpuid_eax(GLuint op);
65 extern GLuint _ASMAPI _mesa_x86_cpuid_ebx(GLuint op);
66 extern GLuint _ASMAPI _mesa_x86_cpuid_ecx(GLuint op);
67 extern GLuint _ASMAPI _mesa_x86_cpuid_edx(GLuint op);
68
69
70 #if defined(USE_SSE_ASM)
71 /*
72 * We must verify that the Streaming SIMD Extensions are truly supported
73 * on this processor before we go ahead and hook out the optimized code.
74 *
75 * However, I have been told by Alan Cox that all 2.4 (and later) Linux
76 * kernels provide full SSE support on all processors that expose SSE via
77 * the CPUID mechanism.
78 */
79
80 /* These are assembly functions: */
81 extern void _mesa_test_os_sse_support( void );
82 extern void _mesa_test_os_sse_exception_support( void );
83
84
85 #if defined(WIN32)
86 #ifndef STATUS_FLOAT_MULTIPLE_TRAPS
87 # define STATUS_FLOAT_MULTIPLE_TRAPS (0xC00002B5L)
88 #endif
ExceptionFilter(LPEXCEPTION_POINTERS exp)89 static LONG WINAPI ExceptionFilter(LPEXCEPTION_POINTERS exp)
90 {
91 PEXCEPTION_RECORD rec = exp->ExceptionRecord;
92 PCONTEXT ctx = exp->ContextRecord;
93
94 if ( rec->ExceptionCode == EXCEPTION_ILLEGAL_INSTRUCTION ) {
95 _mesa_debug(NULL, "EXCEPTION_ILLEGAL_INSTRUCTION\n" );
96 _mesa_x86_cpu_features &= ~(X86_FEATURE_XMM);
97 } else if ( rec->ExceptionCode == STATUS_FLOAT_MULTIPLE_TRAPS ) {
98 _mesa_debug(NULL, "STATUS_FLOAT_MULTIPLE_TRAPS\n");
99 /* Windows seems to clear the exception flag itself, we just have to increment Eip */
100 } else {
101 _mesa_debug(NULL, "UNEXPECTED EXCEPTION (0x%08x), terminating!\n" );
102 return EXCEPTION_EXECUTE_HANDLER;
103 }
104
105 if ( (ctx->ContextFlags & CONTEXT_CONTROL) != CONTEXT_CONTROL ) {
106 _mesa_debug(NULL, "Context does not contain control registers, terminating!\n");
107 return EXCEPTION_EXECUTE_HANDLER;
108 }
109 ctx->Eip += 3;
110
111 return EXCEPTION_CONTINUE_EXECUTION;
112 }
113 #endif /* WIN32 */
114
115
116 /**
117 * Check if SSE is supported.
118 * If not, turn off the X86_FEATURE_XMM flag in _mesa_x86_cpu_features.
119 */
_mesa_check_os_sse_support(void)120 void _mesa_check_os_sse_support( void )
121 {
122 #if defined(__FreeBSD__)
123 {
124 int ret, enabled;
125 unsigned int len;
126 len = sizeof(enabled);
127 ret = sysctlbyname("hw.instruction_sse", &enabled, &len, NULL, 0);
128 if (ret || !enabled)
129 _mesa_x86_cpu_features &= ~(X86_FEATURE_XMM);
130 }
131 #elif defined (__NetBSD__)
132 {
133 int ret, enabled;
134 size_t len = sizeof(enabled);
135 ret = sysctlbyname("machdep.sse", &enabled, &len, (void *)NULL, 0);
136 if (ret || !enabled)
137 _mesa_x86_cpu_features &= ~(X86_FEATURE_XMM);
138 }
139 #elif defined(__OpenBSD__)
140 {
141 int mib[2];
142 int ret, enabled;
143 size_t len = sizeof(enabled);
144
145 mib[0] = CTL_MACHDEP;
146 mib[1] = CPU_SSE;
147
148 ret = sysctl(mib, 2, &enabled, &len, NULL, 0);
149 if (ret || !enabled)
150 _mesa_x86_cpu_features &= ~(X86_FEATURE_XMM);
151 }
152 #elif defined(WIN32)
153 LPTOP_LEVEL_EXCEPTION_FILTER oldFilter;
154
155 /* Install our ExceptionFilter */
156 oldFilter = SetUnhandledExceptionFilter( ExceptionFilter );
157
158 if ( cpu_has_xmm ) {
159 _mesa_debug(NULL, "Testing OS support for SSE...\n");
160
161 _mesa_test_os_sse_support();
162
163 if ( cpu_has_xmm ) {
164 _mesa_debug(NULL, "Yes.\n");
165 } else {
166 _mesa_debug(NULL, "No!\n");
167 }
168 }
169
170 if ( cpu_has_xmm ) {
171 _mesa_debug(NULL, "Testing OS support for SSE unmasked exceptions...\n");
172
173 _mesa_test_os_sse_exception_support();
174
175 if ( cpu_has_xmm ) {
176 _mesa_debug(NULL, "Yes.\n");
177 } else {
178 _mesa_debug(NULL, "No!\n");
179 }
180 }
181
182 /* Restore previous exception filter */
183 SetUnhandledExceptionFilter( oldFilter );
184
185 if ( cpu_has_xmm ) {
186 _mesa_debug(NULL, "Tests of OS support for SSE passed.\n");
187 } else {
188 _mesa_debug(NULL, "Tests of OS support for SSE failed!\n");
189 }
190 #else
191 /* Do nothing on other platforms for now.
192 */
193 if (detection_debug)
194 _mesa_debug(NULL, "Not testing OS support for SSE, leaving enabled.\n");
195 #endif /* __FreeBSD__ */
196 }
197
198 #endif /* USE_SSE_ASM */
199
200
201 /**
202 * Initialize the _mesa_x86_cpu_features bitfield.
203 * This is a no-op if called more than once.
204 */
205 void
_mesa_get_x86_features(void)206 _mesa_get_x86_features(void)
207 {
208 static int called = 0;
209
210 if (called)
211 return;
212
213 called = 1;
214
215 #ifdef USE_X86_ASM
216 _mesa_x86_cpu_features = 0x0;
217
218 if (_mesa_getenv( "MESA_NO_ASM")) {
219 return;
220 }
221
222 if (!_mesa_x86_has_cpuid()) {
223 _mesa_debug(NULL, "CPUID not detected\n");
224 }
225 else {
226 GLuint cpu_features;
227 GLuint cpu_ext_features;
228 GLuint cpu_ext_info;
229 char cpu_vendor[13];
230 GLuint result;
231
232 /* get vendor name */
233 _mesa_x86_cpuid(0, &result, (GLuint *)(cpu_vendor + 0), (GLuint *)(cpu_vendor + 8), (GLuint *)(cpu_vendor + 4));
234 cpu_vendor[12] = '\0';
235
236 if (detection_debug)
237 _mesa_debug(NULL, "CPU vendor: %s\n", cpu_vendor);
238
239 /* get cpu features */
240 cpu_features = _mesa_x86_cpuid_edx(1);
241
242 if (cpu_features & X86_CPU_FPU)
243 _mesa_x86_cpu_features |= X86_FEATURE_FPU;
244 if (cpu_features & X86_CPU_CMOV)
245 _mesa_x86_cpu_features |= X86_FEATURE_CMOV;
246
247 #ifdef USE_MMX_ASM
248 if (cpu_features & X86_CPU_MMX)
249 _mesa_x86_cpu_features |= X86_FEATURE_MMX;
250 #endif
251
252 #ifdef USE_SSE_ASM
253 if (cpu_features & X86_CPU_XMM)
254 _mesa_x86_cpu_features |= X86_FEATURE_XMM;
255 if (cpu_features & X86_CPU_XMM2)
256 _mesa_x86_cpu_features |= X86_FEATURE_XMM2;
257 #endif
258
259 /* query extended cpu features */
260 if ((cpu_ext_info = _mesa_x86_cpuid_eax(0x80000000)) > 0x80000000) {
261 if (cpu_ext_info >= 0x80000001) {
262
263 cpu_ext_features = _mesa_x86_cpuid_edx(0x80000001);
264
265 if (cpu_features & X86_CPU_MMX) {
266
267 #ifdef USE_3DNOW_ASM
268 if (cpu_ext_features & X86_CPUEXT_3DNOW)
269 _mesa_x86_cpu_features |= X86_FEATURE_3DNOW;
270 if (cpu_ext_features & X86_CPUEXT_3DNOW_EXT)
271 _mesa_x86_cpu_features |= X86_FEATURE_3DNOWEXT;
272 #endif
273
274 #ifdef USE_MMX_ASM
275 if (cpu_ext_features & X86_CPUEXT_MMX_EXT)
276 _mesa_x86_cpu_features |= X86_FEATURE_MMXEXT;
277 #endif
278 }
279 }
280
281 /* query cpu name */
282 if (cpu_ext_info >= 0x80000002) {
283 GLuint ofs;
284 char cpu_name[49];
285 for (ofs = 0; ofs < 3; ofs++)
286 _mesa_x86_cpuid(0x80000002+ofs, (GLuint *)(cpu_name + (16*ofs)+0), (GLuint *)(cpu_name + (16*ofs)+4), (GLuint *)(cpu_name + (16*ofs)+8), (GLuint *)(cpu_name + (16*ofs)+12));
287 cpu_name[48] = '\0'; /* the name should be NULL terminated, but just to be sure */
288
289 if (detection_debug)
290 _mesa_debug(NULL, "CPU name: %s\n", cpu_name);
291 }
292 }
293
294 }
295
296 #ifdef USE_MMX_ASM
297 if ( cpu_has_mmx ) {
298 if ( _mesa_getenv( "MESA_NO_MMX" ) == 0 ) {
299 if (detection_debug)
300 _mesa_debug(NULL, "MMX cpu detected.\n");
301 } else {
302 _mesa_x86_cpu_features &= ~(X86_FEATURE_MMX);
303 }
304 }
305 #endif
306
307 #ifdef USE_3DNOW_ASM
308 if ( cpu_has_3dnow ) {
309 if ( _mesa_getenv( "MESA_NO_3DNOW" ) == 0 ) {
310 if (detection_debug)
311 _mesa_debug(NULL, "3DNow! cpu detected.\n");
312 } else {
313 _mesa_x86_cpu_features &= ~(X86_FEATURE_3DNOW);
314 }
315 }
316 #endif
317
318 #ifdef USE_SSE_ASM
319 if ( cpu_has_xmm ) {
320 if ( _mesa_getenv( "MESA_NO_SSE" ) == 0 ) {
321 if (detection_debug)
322 _mesa_debug(NULL, "SSE cpu detected.\n");
323 if ( _mesa_getenv( "MESA_FORCE_SSE" ) == 0 ) {
324 _mesa_check_os_sse_support();
325 }
326 } else {
327 _mesa_debug(NULL, "SSE cpu detected, but switched off by user.\n");
328 _mesa_x86_cpu_features &= ~(X86_FEATURE_XMM);
329 }
330 }
331 #endif
332
333 #endif /* USE_X86_ASM */
334
335 (void) detection_debug;
336 }
337