src/mesa/x86/common_x86.c

   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
  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  */
 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
 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 }