516229433ae0d012f47a537e378144c131b16527
[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 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #include <vlc_common.h>
34
35 #include <sys/types.h>
36 #ifndef WIN32
37 #include <unistd.h>
38 #include <sys/wait.h>
39 #endif
40
41 #include "libvlc.h"
42
43 #if defined(__APPLE__) && (defined(__ppc__) || defined(__ppc64__))
44 #include <sys/sysctl.h>
45 #endif
46
47 #if defined( __i386__ ) || defined( __x86_64__ ) \
48  || defined( __ppc__ ) || defined( __ppc64__ )
49 static bool check_OS_capability( const char *psz_capability, pid_t pid )
50 {
51 #ifndef WIN32
52     int status;
53
54     if( pid == -1 )
55         return false; /* fail safe :-/ */
56
57     while( waitpid( pid, &status, 0 ) == -1 );
58
59     if( WIFEXITED( status ) && WEXITSTATUS( status ) == 0 )
60         return true;
61
62     fprintf( stderr, "warning: your CPU has %s instructions, but not your "
63                      "operating system.\n", psz_capability );
64     fprintf( stderr, "         some optimizations will be disabled unless "
65                      "you upgrade your OS\n" );
66     return false;
67 #else
68 # warning FIXME!
69 # define fork() (errno = ENOSYS, -1)
70     (void)pid;
71     (void)psz_capability;
72     return true;
73 #endif
74 }
75 #endif
76
77 /*****************************************************************************
78  * CPUCapabilities: get the CPU capabilities
79  *****************************************************************************
80  * This function is called to list extensions the CPU may have.
81  *****************************************************************************/
82 uint32_t CPUCapabilities( void )
83 {
84     uint32_t i_capabilities = CPU_CAPABILITY_NONE;
85
86 #if defined( __i386__ ) || defined( __x86_64__ )
87      unsigned int i_eax, i_ebx, i_ecx, i_edx;
88      bool b_amd;
89
90     /* Needed for x86 CPU capabilities detection */
91 #   if defined( __x86_64__ )
92 #       define cpuid( reg )                    \
93             asm volatile ( "cpuid\n\t"         \
94                            "movl %%ebx,%1\n\t" \
95                          : "=a" ( i_eax ),     \
96                            "=b" ( i_ebx ),     \
97                            "=c" ( i_ecx ),     \
98                            "=d" ( i_edx )      \
99                          : "a"  ( reg )        \
100                          : "cc" );
101 #   else
102 #       define cpuid( reg )                    \
103             asm volatile ( "push %%ebx\n\t"    \
104                            "cpuid\n\t"         \
105                            "movl %%ebx,%1\n\t" \
106                            "pop %%ebx\n\t"     \
107                          : "=a" ( i_eax ),     \
108                            "=r" ( i_ebx ),     \
109                            "=c" ( i_ecx ),     \
110                            "=d" ( i_edx )      \
111                          : "a"  ( reg )        \
112                          : "cc" );
113 #   endif
114
115     i_capabilities |= CPU_CAPABILITY_FPU;
116
117 #   if defined( __i386__ )
118     /* check if cpuid instruction is supported */
119     asm volatile ( "push %%ebx\n\t"
120                    "pushf\n\t"
121                    "pop %%eax\n\t"
122                    "movl %%eax, %%ebx\n\t"
123                    "xorl $0x200000, %%eax\n\t"
124                    "push %%eax\n\t"
125                    "popf\n\t"
126                    "pushf\n\t"
127                    "pop %%eax\n\t"
128                    "movl %%ebx,%1\n\t"
129                    "pop %%ebx\n\t"
130                  : "=a" ( i_eax ),
131                    "=r" ( i_ebx )
132                  :
133                  : "cc" );
134
135     if( i_eax == i_ebx )
136         goto out;
137 #   else
138     /* x86_64 supports cpuid instruction, so we dont need to check it */
139 #   endif
140
141     i_capabilities |= CPU_CAPABILITY_486;
142
143     /* the CPU supports the CPUID instruction - get its level */
144     cpuid( 0x00000000 );
145
146     if( !i_eax )
147         goto out;
148
149     /* FIXME: this isn't correct, since some 486s have cpuid */
150     i_capabilities |= CPU_CAPABILITY_586;
151
152     /* borrowed from mpeg2dec */
153     b_amd = ( i_ebx == 0x68747541 ) && ( i_ecx == 0x444d4163 )
154                     && ( i_edx == 0x69746e65 );
155
156     /* test for the MMX flag */
157     cpuid( 0x00000001 );
158
159     if( ! (i_edx & 0x00800000) )
160         goto out;
161
162     i_capabilities |= CPU_CAPABILITY_MMX;
163
164     if( i_edx & 0x02000000 )
165     {
166         i_capabilities |= CPU_CAPABILITY_MMXEXT;
167
168 #   ifdef CAN_COMPILE_SSE
169         /* We test if OS supports the SSE instructions */
170         pid_t pid = fork();
171         if( pid == 0 )
172         {
173             /* Test a SSE instruction */
174             __asm__ __volatile__ ( "xorps %%xmm0,%%xmm0\n" : : );
175             exit(0);
176         }
177         if( check_OS_capability( "SSE", pid ) )
178             i_capabilities |= CPU_CAPABILITY_SSE;
179 #   endif
180     }
181
182     if( i_edx & 0x04000000 )
183     {
184 #   if defined(CAN_COMPILE_SSE)
185         /* We test if OS supports the SSE2 instructions */
186         pid_t pid = fork();
187         if( pid == 0 )
188         {
189             /* Test a SSE2 instruction */
190             __asm__ __volatile__ ( "movupd %%xmm0, %%xmm0\n" : : );
191             exit(0);
192         }
193         if( check_OS_capability( "SSE2", pid ) )
194             i_capabilities |= CPU_CAPABILITY_SSE2;
195 #   endif
196     }
197
198     /* test for additional capabilities */
199     cpuid( 0x80000000 );
200
201     if( i_eax < 0x80000001 )
202         goto out;
203
204     /* list these additional capabilities */
205     cpuid( 0x80000001 );
206
207 #   ifdef CAN_COMPILE_3DNOW
208     if( i_edx & 0x80000000 )
209     {
210         pid_t pid = fork();
211         if( pid == 0 )
212         {
213             /* Test a 3D Now! instruction */
214             __asm__ __volatile__ ( "pfadd %%mm0,%%mm0\n" "femms\n" : : );
215             exit(0);
216         }
217         if( check_OS_capability( "3D Now!", pid ) )
218             i_capabilities |= CPU_CAPABILITY_3DNOW;
219     }
220 #   endif
221
222     if( b_amd && ( i_edx & 0x00400000 ) )
223     {
224         i_capabilities |= CPU_CAPABILITY_MMXEXT;
225     }
226 out:
227
228 #elif defined( __arm__ )
229 #   if defined( __ARM_EABI__ ) && !defined( __SOFTFP__ )
230 //    i_capabilities |= CPU_CAPABILITY_FPU;
231 #   endif
232
233 #elif defined( __powerpc__ ) || defined( __ppc__ ) || defined( __ppc64__ )
234
235     i_capabilities |= CPU_CAPABILITY_FPU;
236
237 #   if defined(__APPLE__)
238     int selectors[2] = { CTL_HW, HW_VECTORUNIT };
239     int i_has_altivec = 0;
240     size_t i_length = sizeof( i_has_altivec );
241     int i_error = sysctl( selectors, 2, &i_has_altivec, &i_length, NULL, 0);
242
243     if( i_error == 0 && i_has_altivec != 0 )
244         i_capabilities |= CPU_CAPABILITY_ALTIVEC;
245
246 #   elif defined( CAN_COMPILE_ALTIVEC )
247     pid_t pid = fork();
248     if( pid == 0 )
249     {
250         asm volatile ("mtspr 256, %0\n\t"
251                       "vand %%v0, %%v0, %%v0"
252                       :
253                       : "r" (-1));
254         exit(0);
255     }
256
257     if( check_OS_capability( "Altivec", pid ) )
258         i_capabilities |= CPU_CAPABILITY_ALTIVEC;
259
260 #   endif
261
262 #elif defined( __sparc__ )
263     i_capabilities |= CPU_CAPABILITY_FPU;
264
265 #elif defined( _MSC_VER ) && !defined( UNDER_CE )
266     i_capabilities |= CPU_CAPABILITY_FPU;
267
268 #endif
269     return i_capabilities;
270 }
271
272 uint32_t cpu_flags = 0;
273
274
275 /*****************************************************************************
276  * vlc_CPU: get pre-computed CPU capability flags
277  ****************************************************************************/
278 unsigned vlc_CPU (void)
279 {
280     return cpu_flags;
281 }
282
283 static vlc_memcpy_t pf_vlc_memcpy = memcpy;
284 static vlc_memset_t pf_vlc_memset = memset;
285
286 void vlc_fastmem_register (vlc_memcpy_t cpy, vlc_memset_t set)
287 {
288     if (cpy)
289         pf_vlc_memcpy = cpy;
290     if (set)
291         pf_vlc_memset = set;
292 }
293
294 /**
295  * vlc_memcpy: fast CPU-dependent memcpy
296  */
297 void *vlc_memcpy (void *tgt, const void *src, size_t n)
298 {
299     return pf_vlc_memcpy (tgt, src, n);
300 }
301
302 /**
303  * vlc_memset: fast CPU-dependent memset
304  */
305 void *vlc_memset (void *tgt, int c, size_t n)
306 {
307     return pf_vlc_memset (tgt, c, n);
308 }