- Only allow letters, digits and slash in access/demux specification
[vlc.git] / src / misc / cpu.c
1 /*****************************************************************************
2  * cpu.c: CPU detection code
3  *****************************************************************************
4  * Copyright (C) 1998-2004 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Samuel Hocevar <sam@zoy.org>
8  *          Christophe Massiot <massiot@via.ecp.fr>
9  *          Eugenio Jarosiewicz <ej0@cise.ufl.eduEujenio>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
24  *****************************************************************************/
25
26 /*****************************************************************************
27  * Preamble
28  *****************************************************************************/
29 #include <vlc/vlc.h>
30
31 #ifdef HAVE_SIGNAL_H
32 #   include <signal.h>                            /* SIGHUP, SIGINT, SIGKILL */
33 #   include <setjmp.h>                                    /* longjmp, setjmp */
34 #endif
35
36 #if defined(__APPLE__) && (defined(__ppc__) || defined(__ppc64__))
37 #include <sys/sysctl.h>
38 #endif
39
40 /*****************************************************************************
41  * Local prototypes
42  *****************************************************************************/
43 #ifdef HAVE_SIGNAL_H
44 static void SigHandler   ( int );
45 #endif
46
47 /*****************************************************************************
48  * Global variables - they're needed for signal handling
49  *****************************************************************************/
50 #ifdef HAVE_SIGNAL_H
51 static jmp_buf env;
52 static int     i_illegal;
53 #if defined( __i386__ ) || defined( __x86_64__ )
54 static const char *psz_capability;
55 #endif
56 #endif
57
58 /*****************************************************************************
59  * CPUCapabilities: get the CPU capabilities
60  *****************************************************************************
61  * This function is called to list extensions the CPU may have.
62  *****************************************************************************/
63 uint32_t CPUCapabilities( void )
64 {
65     volatile uint32_t i_capabilities = CPU_CAPABILITY_NONE;
66
67 #if defined(__APPLE__) && (defined(__ppc__) || defined(__ppc64__))
68     int selectors[2] = { CTL_HW, HW_VECTORUNIT };
69     int i_has_altivec = 0;
70     size_t i_length = sizeof( i_has_altivec );
71     int i_error = sysctl( selectors, 2, &i_has_altivec, &i_length, NULL, 0);
72
73     i_capabilities |= CPU_CAPABILITY_FPU;
74
75     if( i_error == 0 && i_has_altivec != 0 )
76         i_capabilities |= CPU_CAPABILITY_ALTIVEC;
77
78     return i_capabilities;
79
80 #elif defined( __i386__ ) || defined( __x86_64__ )
81     volatile unsigned int  i_eax, i_ebx, i_ecx, i_edx;
82     volatile vlc_bool_t    b_amd;
83
84     /* Needed for x86 CPU capabilities detection */
85 #   if defined( __x86_64__ )
86 #       define cpuid( reg )                    \
87             asm volatile ( "cpuid\n\t"         \
88                            "movl %%ebx,%1\n\t" \
89                          : "=a" ( i_eax ),     \
90                            "=b" ( i_ebx ),     \
91                            "=c" ( i_ecx ),     \
92                            "=d" ( i_edx )      \
93                          : "a"  ( reg )        \
94                          : "cc" );
95 #   else
96 #       define cpuid( reg )                    \
97             asm volatile ( "push %%ebx\n\t"    \
98                            "cpuid\n\t"         \
99                            "movl %%ebx,%1\n\t" \
100                            "pop %%ebx\n\t"     \
101                          : "=a" ( i_eax ),     \
102                            "=r" ( i_ebx ),     \
103                            "=c" ( i_ecx ),     \
104                            "=d" ( i_edx )      \
105                          : "a"  ( reg )        \
106                          : "cc" );
107 #   endif
108
109 #   if defined( CAN_COMPILE_SSE ) || defined ( CAN_COMPILE_3DNOW ) \
110      && defined( HAVE_SIGNAL_H )
111     void (*pf_sigill) (int) = signal( SIGILL, SigHandler );
112 #   endif
113
114     i_capabilities |= CPU_CAPABILITY_FPU;
115
116 #   if defined( __i386__ )
117     /* check if cpuid instruction is supported */
118     asm volatile ( "push %%ebx\n\t"
119                    "pushf\n\t"
120                    "pop %%eax\n\t"
121                    "movl %%eax, %%ebx\n\t"
122                    "xorl $0x200000, %%eax\n\t"
123                    "push %%eax\n\t"
124                    "popf\n\t"
125                    "pushf\n\t"
126                    "pop %%eax\n\t"
127                    "movl %%ebx,%1\n\t"
128                    "pop %%ebx\n\t"
129                  : "=a" ( i_eax ),
130                    "=r" ( i_ebx )
131                  :
132                  : "cc" );
133
134     if( i_eax == i_ebx )
135     {
136 #       if defined( CAN_COMPILE_SSE ) || defined ( CAN_COMPILE_3DNOW ) \
137             && defined( HAVE_SIGNAL_H )
138         signal( SIGILL, pf_sigill );
139 #       endif
140         return i_capabilities;
141     }
142 #   else
143     /* x86_64 supports cpuid instruction, so we dont need to check it */
144 #   endif
145
146     i_capabilities |= CPU_CAPABILITY_486;
147
148     /* the CPU supports the CPUID instruction - get its level */
149     cpuid( 0x00000000 );
150
151     if( !i_eax )
152     {
153 #   if defined( CAN_COMPILE_SSE ) || defined ( CAN_COMPILE_3DNOW ) \
154      && defined( HAVE_SIGNAL_H )
155         signal( SIGILL, pf_sigill );
156 #   endif
157         return i_capabilities;
158     }
159
160     /* FIXME: this isn't correct, since some 486s have cpuid */
161     i_capabilities |= CPU_CAPABILITY_586;
162
163     /* borrowed from mpeg2dec */
164     b_amd = ( i_ebx == 0x68747541 ) && ( i_ecx == 0x444d4163 )
165                     && ( i_edx == 0x69746e65 );
166
167     /* test for the MMX flag */
168     cpuid( 0x00000001 );
169
170     if( ! (i_edx & 0x00800000) )
171     {
172 #   if defined( CAN_COMPILE_SSE ) || defined ( CAN_COMPILE_3DNOW ) \
173      && defined( HAVE_SIGNAL_H )
174         signal( SIGILL, pf_sigill );
175 #   endif
176         return i_capabilities;
177     }
178
179     i_capabilities |= CPU_CAPABILITY_MMX;
180
181     if( i_edx & 0x02000000 )
182     {
183         i_capabilities |= CPU_CAPABILITY_MMXEXT;
184
185 #   ifdef CAN_COMPILE_SSE
186         /* We test if OS supports the SSE instructions */
187         psz_capability = "SSE";
188         i_illegal = 0;
189
190         if( setjmp( env ) == 0 )
191         {
192             /* Test a SSE instruction */
193             __asm__ __volatile__ ( "xorps %%xmm0,%%xmm0\n" : : );
194         }
195
196         if( i_illegal == 0 )
197         {
198             i_capabilities |= CPU_CAPABILITY_SSE;
199         }
200 #   endif
201     }
202
203     if( i_edx & 0x04000000 )
204     {
205 #   if defined(CAN_COMPILE_SSE)
206         /* We test if OS supports the SSE instructions */
207         psz_capability = "SSE2";
208         i_illegal = 0;
209
210         if( setjmp( env ) == 0 )
211         {
212             /* Test a SSE2 instruction */
213             __asm__ __volatile__ ( "movupd %%xmm0, %%xmm0\n" : : );
214         }
215
216         if( i_illegal == 0 )
217         {
218             i_capabilities |= CPU_CAPABILITY_SSE2;
219         }
220 #   endif
221     }
222
223     /* test for additional capabilities */
224     cpuid( 0x80000000 );
225
226     if( i_eax < 0x80000001 )
227     {
228 #   if defined( CAN_COMPILE_SSE ) || defined ( CAN_COMPILE_3DNOW ) \
229      && defined( HAVE_SIGNAL_H )
230         signal( SIGILL, pf_sigill );
231 #   endif
232         return i_capabilities;
233     }
234
235     /* list these additional capabilities */
236     cpuid( 0x80000001 );
237
238 #   ifdef CAN_COMPILE_3DNOW
239     if( i_edx & 0x80000000 )
240     {
241         psz_capability = "3D Now!";
242         i_illegal = 0;
243
244         if( setjmp( env ) == 0 )
245         {
246             /* Test a 3D Now! instruction */
247             __asm__ __volatile__ ( "pfadd %%mm0,%%mm0\n" "femms\n" : : );
248         }
249
250         if( i_illegal == 0 )
251         {
252             i_capabilities |= CPU_CAPABILITY_3DNOW;
253         }
254     }
255 #   endif
256
257     if( b_amd && ( i_edx & 0x00400000 ) )
258     {
259         i_capabilities |= CPU_CAPABILITY_MMXEXT;
260     }
261
262 #   if defined( CAN_COMPILE_SSE ) || defined ( CAN_COMPILE_3DNOW ) \
263      && defined( HAVE_SIGNAL_H )
264     signal( SIGILL, pf_sigill );
265 #   endif
266     return i_capabilities;
267
268 #elif defined( __powerpc__ ) || defined( __ppc__ ) || defined( __ppc64__ )
269
270 #   ifdef CAN_COMPILE_ALTIVEC && defined( HAVE_SIGNAL_H )
271     void (*pf_sigill) (int) = signal( SIGILL, SigHandler );
272
273     i_capabilities |= CPU_CAPABILITY_FPU;
274
275     i_illegal = 0;
276
277     if( setjmp( env ) == 0 )
278     {
279         asm volatile ("mtspr 256, %0\n\t"
280                       "vand %%v0, %%v0, %%v0"
281                       :
282                       : "r" (-1));
283     }
284
285     if( i_illegal == 0 )
286     {
287         i_capabilities |= CPU_CAPABILITY_ALTIVEC;
288     }
289
290     signal( SIGILL, pf_sigill );
291 #   endif
292
293     return i_capabilities;
294
295 #elif defined( __sparc__ )
296
297     i_capabilities |= CPU_CAPABILITY_FPU;
298     return i_capabilities;
299
300 #elif defined( _MSC_VER ) && !defined( UNDER_CE )
301     i_capabilities |= CPU_CAPABILITY_FPU;
302     return i_capabilities;
303
304 #else
305     /* default behaviour */
306     return i_capabilities;
307
308 #endif
309 }
310
311 /*****************************************************************************
312  * SigHandler: system signal handler
313  *****************************************************************************
314  * This function is called when an illegal instruction signal is received by
315  * the program. We use this function to test OS and CPU capabilities
316  *****************************************************************************/
317 #if defined( HAVE_SIGNAL_H )
318 static void SigHandler( int i_signal )
319 {
320     /* Acknowledge the signal received */
321     i_illegal = 1;
322
323 #ifdef HAVE_SIGRELSE
324     sigrelse( i_signal );
325 #endif
326
327 #if defined( __i386__ )
328     fprintf( stderr, "warning: your CPU has %s instructions, but not your "
329                      "operating system.\n", psz_capability );
330     fprintf( stderr, "         some optimizations will be disabled unless "
331                      "you upgrade your OS\n" );
332 #   if defined( SYS_LINUX )
333     fprintf( stderr, "         (for instance Linux kernel 2.4.x or later)\n" );
334 #   endif
335 #endif
336
337     longjmp( env, 1 );
338 }
339 #endif
340
341
342 extern uint32_t cpu_flags = 0;
343
344
345 /*****************************************************************************
346  * vlc_CPU: get pre-computed CPU capability flags
347  ****************************************************************************/
348 unsigned vlc_CPU (void)
349 {
350     return cpu_flags;
351 }
352