zenilib  0.5.3.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
SDL_cpuinfo.c
Go to the documentation of this file.
1 /*
2  Simple DirectMedia Layer
3  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
4 
5  This software is provided 'as-is', without any express or implied
6  warranty. In no event will the authors be held liable for any damages
7  arising from the use of this software.
8 
9  Permission is granted to anyone to use this software for any purpose,
10  including commercial applications, and to alter it and redistribute it
11  freely, subject to the following restrictions:
12 
13  1. The origin of this software must not be misrepresented; you must not
14  claim that you wrote the original software. If you use this software
15  in a product, an acknowledgment in the product documentation would be
16  appreciated but is not required.
17  2. Altered source versions must be plainly marked as such, and must not be
18  misrepresented as being the original software.
19  3. This notice may not be removed or altered from any source distribution.
20 */
21 #include "SDL_config.h"
22 
23 /* CPU feature detection for SDL */
24 
25 #include "SDL_cpuinfo.h"
26 
27 #ifdef HAVE_SYSCONF
28 #include <unistd.h>
29 #endif
30 #ifdef HAVE_SYSCTLBYNAME
31 #include <sys/types.h>
32 #include <sys/sysctl.h>
33 #endif
34 #if defined(__MACOSX__) && (defined(__ppc__) || defined(__ppc64__))
35 #include <sys/sysctl.h> /* For AltiVec check */
36 #elif defined(__OpenBSD__) && defined(__powerpc__)
37 #include <sys/param.h>
38 #include <sys/sysctl.h> /* For AltiVec check */
39 #include <machine/cpu.h>
40 #elif SDL_ALTIVEC_BLITTERS && HAVE_SETJMP
41 #include <signal.h>
42 #include <setjmp.h>
43 #endif
44 #ifdef __WIN32__
45 #include "../core/windows/SDL_windows.h"
46 #endif
47 
48 #define CPU_HAS_RDTSC 0x00000001
49 #define CPU_HAS_ALTIVEC 0x00000002
50 #define CPU_HAS_MMX 0x00000004
51 #define CPU_HAS_3DNOW 0x00000008
52 #define CPU_HAS_SSE 0x00000010
53 #define CPU_HAS_SSE2 0x00000020
54 #define CPU_HAS_SSE3 0x00000040
55 #define CPU_HAS_SSE41 0x00000100
56 #define CPU_HAS_SSE42 0x00000200
57 
58 #if SDL_ALTIVEC_BLITTERS && HAVE_SETJMP && !__MACOSX__ && !__OpenBSD__
59 /* This is the brute force way of detecting instruction sets...
60  the idea is borrowed from the libmpeg2 library - thanks!
61  */
62 static jmp_buf jmpbuf;
63 static void
64 illegal_instruction(int sig)
65 {
66  longjmp(jmpbuf, 1);
67 }
68 #endif /* HAVE_SETJMP */
69 
70 static __inline__ int
72 {
73  int has_CPUID = 0;
74 /* *INDENT-OFF* */
75 #if defined(__GNUC__) && defined(i386)
76  __asm__ (
77 " pushfl # Get original EFLAGS \n"
78 " popl %%eax \n"
79 " movl %%eax,%%ecx \n"
80 " xorl $0x200000,%%eax # Flip ID bit in EFLAGS \n"
81 " pushl %%eax # Save new EFLAGS value on stack \n"
82 " popfl # Replace current EFLAGS value \n"
83 " pushfl # Get new EFLAGS \n"
84 " popl %%eax # Store new EFLAGS in EAX \n"
85 " xorl %%ecx,%%eax # Can not toggle ID bit, \n"
86 " jz 1f # Processor=80486 \n"
87 " movl $1,%0 # We have CPUID support \n"
88 "1: \n"
89  : "=m" (has_CPUID)
90  :
91  : "%eax", "%ecx"
92  );
93 #elif defined(__GNUC__) && defined(__x86_64__)
94 /* Technically, if this is being compiled under __x86_64__ then it has
95 CPUid by definition. But it's nice to be able to prove it. :) */
96  __asm__ (
97 " pushfq # Get original EFLAGS \n"
98 " popq %%rax \n"
99 " movq %%rax,%%rcx \n"
100 " xorl $0x200000,%%eax # Flip ID bit in EFLAGS \n"
101 " pushq %%rax # Save new EFLAGS value on stack \n"
102 " popfq # Replace current EFLAGS value \n"
103 " pushfq # Get new EFLAGS \n"
104 " popq %%rax # Store new EFLAGS in EAX \n"
105 " xorl %%ecx,%%eax # Can not toggle ID bit, \n"
106 " jz 1f # Processor=80486 \n"
107 " movl $1,%0 # We have CPUID support \n"
108 "1: \n"
109  : "=m" (has_CPUID)
110  :
111  : "%rax", "%rcx"
112  );
113 #elif (defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)
114  __asm {
115  pushfd ; Get original EFLAGS
116  pop eax
117  mov ecx, eax
118  xor eax, 200000h ; Flip ID bit in EFLAGS
119  push eax ; Save new EFLAGS value on stack
120  popfd ; Replace current EFLAGS value
121  pushfd ; Get new EFLAGS
122  pop eax ; Store new EFLAGS in EAX
123  xor eax, ecx ; Can not toggle ID bit,
124  jz done ; Processor=80486
125  mov has_CPUID,1 ; We have CPUID support
126 done:
127  }
128 #elif defined(__sun) && defined(__i386)
129  __asm (
130 " pushfl \n"
131 " popl %eax \n"
132 " movl %eax,%ecx \n"
133 " xorl $0x200000,%eax \n"
134 " pushl %eax \n"
135 " popfl \n"
136 " pushfl \n"
137 " popl %eax \n"
138 " xorl %ecx,%eax \n"
139 " jz 1f \n"
140 " movl $1,-8(%ebp) \n"
141 "1: \n"
142  );
143 #elif defined(__sun) && defined(__amd64)
144  __asm (
145 " pushfq \n"
146 " popq %rax \n"
147 " movq %rax,%rcx \n"
148 " xorl $0x200000,%eax \n"
149 " pushq %rax \n"
150 " popfq \n"
151 " pushfq \n"
152 " popq %rax \n"
153 " xorl %ecx,%eax \n"
154 " jz 1f \n"
155 " movl $1,-8(%rbp) \n"
156 "1: \n"
157  );
158 #endif
159 /* *INDENT-ON* */
160  return has_CPUID;
161 }
162 
163 #if defined(__GNUC__) && defined(i386)
164 #define cpuid(func, a, b, c, d) \
165  __asm__ __volatile__ ( \
166 " pushl %%ebx \n" \
167 " cpuid \n" \
168 " movl %%ebx, %%esi \n" \
169 " popl %%ebx \n" : \
170  "=a" (a), "=S" (b), "=c" (c), "=d" (d) : "a" (func))
171 #elif defined(__GNUC__) && defined(__x86_64__)
172 #define cpuid(func, a, b, c, d) \
173  __asm__ __volatile__ ( \
174 " pushq %%rbx \n" \
175 " cpuid \n" \
176 " movq %%rbx, %%rsi \n" \
177 " popq %%rbx \n" : \
178  "=a" (a), "=S" (b), "=c" (c), "=d" (d) : "a" (func))
179 #elif (defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)
180 #define cpuid(func, a, b, c, d) \
181  __asm { \
182  __asm mov eax, func \
183  __asm cpuid \
184  __asm mov a, eax \
185  __asm mov b, ebx \
186  __asm mov c, ecx \
187  __asm mov d, edx \
188  }
189 #else
190 #define cpuid(func, a, b, c, d) \
191  a = b = c = d = 0
192 #endif
193 
194 static __inline__ int
196 {
197  int features = 0;
198  int a, b, c, d;
199 
200  cpuid(0, a, b, c, d);
201  if (a >= 1) {
202  cpuid(1, a, b, c, d);
203  features = d;
204  }
205  return features;
206 }
207 
208 static __inline__ int
210 {
211  if (CPU_haveCPUID()) {
212  return (CPU_getCPUIDFeatures() & 0x00000010);
213  }
214  return 0;
215 }
216 
217 static __inline__ int
219 {
220  volatile int altivec = 0;
221 #if (defined(__MACOSX__) && (defined(__ppc__) || defined(__ppc64__))) || (defined(__OpenBSD__) && defined(__powerpc__))
222 #ifdef __OpenBSD__
223  int selectors[2] = { CTL_MACHDEP, CPU_ALTIVEC };
224 #else
225  int selectors[2] = { CTL_HW, HW_VECTORUNIT };
226 #endif
227  int hasVectorUnit = 0;
228  size_t length = sizeof(hasVectorUnit);
229  int error = sysctl(selectors, 2, &hasVectorUnit, &length, NULL, 0);
230  if (0 == error)
231  altivec = (hasVectorUnit != 0);
232 #elif SDL_ALTIVEC_BLITTERS && HAVE_SETJMP
233  void (*handler) (int sig);
234  handler = signal(SIGILL, illegal_instruction);
235  if (setjmp(jmpbuf) == 0) {
236  asm volatile ("mtspr 256, %0\n\t" "vand %%v0, %%v0, %%v0"::"r" (-1));
237  altivec = 1;
238  }
239  signal(SIGILL, handler);
240 #endif
241  return altivec;
242 }
243 
244 static __inline__ int
246 {
247  if (CPU_haveCPUID()) {
248  return (CPU_getCPUIDFeatures() & 0x00800000);
249  }
250  return 0;
251 }
252 
253 static __inline__ int
255 {
256  if (CPU_haveCPUID()) {
257  int a, b, c, d;
258 
259  cpuid(0x80000000, a, b, c, d);
260  if (a >= 0x80000001) {
261  cpuid(0x80000001, a, b, c, d);
262  return (d & 0x80000000);
263  }
264  }
265  return 0;
266 }
267 
268 static __inline__ int
270 {
271  if (CPU_haveCPUID()) {
272  return (CPU_getCPUIDFeatures() & 0x02000000);
273  }
274  return 0;
275 }
276 
277 static __inline__ int
279 {
280  if (CPU_haveCPUID()) {
281  return (CPU_getCPUIDFeatures() & 0x04000000);
282  }
283  return 0;
284 }
285 
286 static __inline__ int
288 {
289  if (CPU_haveCPUID()) {
290  int a, b, c, d;
291 
292  cpuid(0, a, b, c, d);
293  if (a >= 1) {
294  cpuid(1, a, b, c, d);
295  return (c & 0x00000001);
296  }
297  }
298  return 0;
299 }
300 
301 static __inline__ int
303 {
304  if (CPU_haveCPUID()) {
305  int a, b, c, d;
306 
307  cpuid(1, a, b, c, d);
308  if (a >= 1) {
309  cpuid(1, a, b, c, d);
310  return (c & 0x00080000);
311  }
312  }
313  return 0;
314 }
315 
316 static __inline__ int
318 {
319  if (CPU_haveCPUID()) {
320  int a, b, c, d;
321 
322  cpuid(1, a, b, c, d);
323  if (a >= 1) {
324  cpuid(1, a, b, c, d);
325  return (c & 0x00100000);
326  }
327  }
328  return 0;
329 }
330 
331 static int SDL_CPUCount = 0;
332 
333 int
335 {
336  if (!SDL_CPUCount) {
337 #if defined(HAVE_SYSCONF) && defined(_SC_NPROCESSORS_ONLN)
338  if (SDL_CPUCount <= 0) {
339  SDL_CPUCount = (int)sysconf(_SC_NPROCESSORS_ONLN);
340  }
341 #endif
342 #ifdef HAVE_SYSCTLBYNAME
343  if (SDL_CPUCount <= 0) {
344  size_t size = sizeof(SDL_CPUCount);
345  sysctlbyname("hw.ncpu", &SDL_CPUCount, &size, NULL, 0);
346  }
347 #endif
348 #ifdef __WIN32__
349  if (SDL_CPUCount <= 0) {
350  SYSTEM_INFO info;
351  GetSystemInfo(&info);
352  SDL_CPUCount = info.dwNumberOfProcessors;
353  }
354 #endif
355  /* There has to be at least 1, right? :) */
356  if (SDL_CPUCount <= 0) {
357  SDL_CPUCount = 1;
358  }
359  }
360  return SDL_CPUCount;
361 }
362 
363 /* Oh, such a sweet sweet trick, just not very useful. :) */
364 static const char *
366 {
367  static char SDL_CPUType[13];
368 
369  if (!SDL_CPUType[0]) {
370  int i = 0;
371  int a, b, c, d;
372 
373  if (CPU_haveCPUID()) {
374  cpuid(0x00000000, a, b, c, d);
375  SDL_CPUType[i++] = (char)(b & 0xff); b >>= 8;
376  SDL_CPUType[i++] = (char)(b & 0xff); b >>= 8;
377  SDL_CPUType[i++] = (char)(b & 0xff); b >>= 8;
378  SDL_CPUType[i++] = (char)(b & 0xff); b >>= 8;
379  SDL_CPUType[i++] = (char)(d & 0xff); d >>= 8;
380  SDL_CPUType[i++] = (char)(d & 0xff); d >>= 8;
381  SDL_CPUType[i++] = (char)(d & 0xff); d >>= 8;
382  SDL_CPUType[i++] = (char)(d & 0xff); d >>= 8;
383  SDL_CPUType[i++] = (char)(c & 0xff); c >>= 8;
384  SDL_CPUType[i++] = (char)(c & 0xff); c >>= 8;
385  SDL_CPUType[i++] = (char)(c & 0xff); c >>= 8;
386  SDL_CPUType[i++] = (char)(c & 0xff); c >>= 8;
387  }
388  if (!SDL_CPUType[0]) {
389  SDL_strlcpy(SDL_CPUType, "Unknown", sizeof(SDL_CPUType));
390  }
391  }
392  return SDL_CPUType;
393 }
394 
395 
396 #ifdef TEST_MAIN /* !!! FIXME: only used for test at the moment. */
397 static const char *
398 SDL_GetCPUName(void)
399 {
400  static char SDL_CPUName[48];
401 
402  if (!SDL_CPUName[0]) {
403  int i = 0;
404  int a, b, c, d;
405 
406  if (CPU_haveCPUID()) {
407  cpuid(0x80000000, a, b, c, d);
408  if (a >= 0x80000004) {
409  cpuid(0x80000002, a, b, c, d);
410  SDL_CPUName[i++] = (char)(a & 0xff); a >>= 8;
411  SDL_CPUName[i++] = (char)(a & 0xff); a >>= 8;
412  SDL_CPUName[i++] = (char)(a & 0xff); a >>= 8;
413  SDL_CPUName[i++] = (char)(a & 0xff); a >>= 8;
414  SDL_CPUName[i++] = (char)(b & 0xff); b >>= 8;
415  SDL_CPUName[i++] = (char)(b & 0xff); b >>= 8;
416  SDL_CPUName[i++] = (char)(b & 0xff); b >>= 8;
417  SDL_CPUName[i++] = (char)(b & 0xff); b >>= 8;
418  SDL_CPUName[i++] = (char)(c & 0xff); c >>= 8;
419  SDL_CPUName[i++] = (char)(c & 0xff); c >>= 8;
420  SDL_CPUName[i++] = (char)(c & 0xff); c >>= 8;
421  SDL_CPUName[i++] = (char)(c & 0xff); c >>= 8;
422  SDL_CPUName[i++] = (char)(d & 0xff); d >>= 8;
423  SDL_CPUName[i++] = (char)(d & 0xff); d >>= 8;
424  SDL_CPUName[i++] = (char)(d & 0xff); d >>= 8;
425  SDL_CPUName[i++] = (char)(d & 0xff); d >>= 8;
426  cpuid(0x80000003, a, b, c, d);
427  SDL_CPUName[i++] = (char)(a & 0xff); a >>= 8;
428  SDL_CPUName[i++] = (char)(a & 0xff); a >>= 8;
429  SDL_CPUName[i++] = (char)(a & 0xff); a >>= 8;
430  SDL_CPUName[i++] = (char)(a & 0xff); a >>= 8;
431  SDL_CPUName[i++] = (char)(b & 0xff); b >>= 8;
432  SDL_CPUName[i++] = (char)(b & 0xff); b >>= 8;
433  SDL_CPUName[i++] = (char)(b & 0xff); b >>= 8;
434  SDL_CPUName[i++] = (char)(b & 0xff); b >>= 8;
435  SDL_CPUName[i++] = (char)(c & 0xff); c >>= 8;
436  SDL_CPUName[i++] = (char)(c & 0xff); c >>= 8;
437  SDL_CPUName[i++] = (char)(c & 0xff); c >>= 8;
438  SDL_CPUName[i++] = (char)(c & 0xff); c >>= 8;
439  SDL_CPUName[i++] = (char)(d & 0xff); d >>= 8;
440  SDL_CPUName[i++] = (char)(d & 0xff); d >>= 8;
441  SDL_CPUName[i++] = (char)(d & 0xff); d >>= 8;
442  SDL_CPUName[i++] = (char)(d & 0xff); d >>= 8;
443  cpuid(0x80000004, a, b, c, d);
444  SDL_CPUName[i++] = (char)(a & 0xff); a >>= 8;
445  SDL_CPUName[i++] = (char)(a & 0xff); a >>= 8;
446  SDL_CPUName[i++] = (char)(a & 0xff); a >>= 8;
447  SDL_CPUName[i++] = (char)(a & 0xff); a >>= 8;
448  SDL_CPUName[i++] = (char)(b & 0xff); b >>= 8;
449  SDL_CPUName[i++] = (char)(b & 0xff); b >>= 8;
450  SDL_CPUName[i++] = (char)(b & 0xff); b >>= 8;
451  SDL_CPUName[i++] = (char)(b & 0xff); b >>= 8;
452  SDL_CPUName[i++] = (char)(c & 0xff); c >>= 8;
453  SDL_CPUName[i++] = (char)(c & 0xff); c >>= 8;
454  SDL_CPUName[i++] = (char)(c & 0xff); c >>= 8;
455  SDL_CPUName[i++] = (char)(c & 0xff); c >>= 8;
456  SDL_CPUName[i++] = (char)(d & 0xff); d >>= 8;
457  SDL_CPUName[i++] = (char)(d & 0xff); d >>= 8;
458  SDL_CPUName[i++] = (char)(d & 0xff); d >>= 8;
459  SDL_CPUName[i++] = (char)(d & 0xff); d >>= 8;
460  }
461  }
462  if (!SDL_CPUName[0]) {
463  SDL_strlcpy(SDL_CPUName, "Unknown", sizeof(SDL_CPUName));
464  }
465  }
466  return SDL_CPUName;
467 }
468 #endif
469 
470 int
472 {
473  const char *cpuType = SDL_GetCPUType();
474 
475  if (SDL_strcmp(cpuType, "GenuineIntel") == 0) {
476  int a, b, c, d;
477 
478  cpuid(0x00000001, a, b, c, d);
479  return (((b >> 8) & 0xff) * 8);
480  } else if (SDL_strcmp(cpuType, "AuthenticAMD") == 0) {
481  int a, b, c, d;
482 
483  cpuid(0x80000005, a, b, c, d);
484  return (c & 0xff);
485  } else {
486  /* Just make a guess here... */
487  return SDL_CACHELINE_SIZE;
488  }
489 }
490 
491 static Uint32 SDL_CPUFeatures = 0xFFFFFFFF;
492 
493 static Uint32
495 {
496  if (SDL_CPUFeatures == 0xFFFFFFFF) {
497  SDL_CPUFeatures = 0;
498  if (CPU_haveRDTSC()) {
499  SDL_CPUFeatures |= CPU_HAS_RDTSC;
500  }
501  if (CPU_haveAltiVec()) {
502  SDL_CPUFeatures |= CPU_HAS_ALTIVEC;
503  }
504  if (CPU_haveMMX()) {
505  SDL_CPUFeatures |= CPU_HAS_MMX;
506  }
507  if (CPU_have3DNow()) {
508  SDL_CPUFeatures |= CPU_HAS_3DNOW;
509  }
510  if (CPU_haveSSE()) {
511  SDL_CPUFeatures |= CPU_HAS_SSE;
512  }
513  if (CPU_haveSSE2()) {
514  SDL_CPUFeatures |= CPU_HAS_SSE2;
515  }
516  if (CPU_haveSSE3()) {
517  SDL_CPUFeatures |= CPU_HAS_SSE3;
518  }
519  if (CPU_haveSSE41()) {
520  SDL_CPUFeatures |= CPU_HAS_SSE41;
521  }
522  if (CPU_haveSSE42()) {
523  SDL_CPUFeatures |= CPU_HAS_SSE42;
524  }
525  }
526  return SDL_CPUFeatures;
527 }
528 
529 SDL_bool
531 {
533  return SDL_TRUE;
534  }
535  return SDL_FALSE;
536 }
537 
538 SDL_bool
540 {
542  return SDL_TRUE;
543  }
544  return SDL_FALSE;
545 }
546 
547 SDL_bool
549 {
551  return SDL_TRUE;
552  }
553  return SDL_FALSE;
554 }
555 
556 SDL_bool
558 {
560  return SDL_TRUE;
561  }
562  return SDL_FALSE;
563 }
564 
565 SDL_bool
567 {
569  return SDL_TRUE;
570  }
571  return SDL_FALSE;
572 }
573 
574 SDL_bool
576 {
578  return SDL_TRUE;
579  }
580  return SDL_FALSE;
581 }
582 
583 SDL_bool
585 {
587  return SDL_TRUE;
588  }
589  return SDL_FALSE;
590 }
591 
592 SDL_bool
594 {
596  return SDL_TRUE;
597  }
598  return SDL_FALSE;
599 }
600 
601 SDL_bool
603 {
605  return SDL_TRUE;
606  }
607  return SDL_FALSE;
608 }
609 
610 #ifdef TEST_MAIN
611 
612 #include <stdio.h>
613 
614 int
615 main()
616 {
617  printf("CPU count: %d\n", SDL_GetCPUCount());
618  printf("CPU type: %s\n", SDL_GetCPUType());
619  printf("CPU name: %s\n", SDL_GetCPUName());
620  printf("CacheLine size: %d\n", SDL_GetCPUCacheLineSize());
621  printf("RDTSC: %d\n", SDL_HasRDTSC());
622  printf("Altivec: %d\n", SDL_HasAltiVec());
623  printf("MMX: %d\n", SDL_HasMMX());
624  printf("3DNow: %d\n", SDL_Has3DNow());
625  printf("SSE: %d\n", SDL_HasSSE());
626  printf("SSE2: %d\n", SDL_HasSSE2());
627  printf("SSE3: %d\n", SDL_HasSSE3());
628  printf("SSE4.1: %d\n", SDL_HasSSE41());
629  printf("SSE4.2: %d\n", SDL_HasSSE42());
630  return 0;
631 }
632 
633 #endif /* TEST_MAIN */
634 
635 /* vi: set ts=4 sw=4 expandtab: */
#define CPU_HAS_SSE41
Definition: SDL_cpuinfo.c:55
static __inline__ int CPU_haveMMX(void)
Definition: SDL_cpuinfo.c:245
static __inline__ int CPU_have3DNow(void)
Definition: SDL_cpuinfo.c:254
#define __inline__
Definition: begin_code.h:119
#define CPU_HAS_RDTSC
Definition: SDL_cpuinfo.c:48
#define CPU_HAS_SSE3
Definition: SDL_cpuinfo.c:54
GLfloat GLfloat GLfloat GLfloat h
Definition: glew.h:7294
GLvoid **typedef void(GLAPIENTRY *PFNGLGETVERTEXATTRIBDVPROC)(GLuint
Definition: glew.h:1824
int main(int argc, char **argv)
Definition: bootstrap.cpp:102
#define NULL
Definition: ftobjs.h:61
DECLSPEC SDL_bool SDLCALL SDL_HasSSE2(void)
Definition: SDL_cpuinfo.c:575
static __inline__ int CPU_haveAltiVec(void)
Definition: SDL_cpuinfo.c:218
SDL_bool
Definition: SDL_stdinc.h:116
static const char * SDL_GetCPUType(void)
Definition: SDL_cpuinfo.c:365
static __inline__ int CPU_getCPUIDFeatures(void)
Definition: SDL_cpuinfo.c:195
#define CPU_HAS_SSE2
Definition: SDL_cpuinfo.c:53
DECLSPEC SDL_bool SDLCALL SDL_HasMMX(void)
Definition: SDL_cpuinfo.c:548
GLuint in
Definition: glew.h:10672
GLboolean GLboolean GLboolean GLboolean a
Definition: glew.h:8736
static __inline__ int CPU_haveSSE41(void)
Definition: SDL_cpuinfo.c:302
DECLSPEC SDL_bool SDLCALL SDL_HasSSE(void)
Definition: SDL_cpuinfo.c:566
return Display return Display Bool Bool int d
Definition: SDL_x11sym.h:30
DECLSPEC SDL_bool SDLCALL SDL_HasSSE42(void)
Definition: SDL_cpuinfo.c:602
#define CPU_HAS_ALTIVEC
Definition: SDL_cpuinfo.c:49
DECLSPEC SDL_bool SDLCALL SDL_HasSSE41(void)
Definition: SDL_cpuinfo.c:593
jz
Definition: k_rem_pio2.c:207
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:145
DECLSPEC SDL_bool SDLCALL SDL_HasRDTSC(void)
Definition: SDL_cpuinfo.c:530
int
Definition: SDL_systhread.c:37
GLsizei GLsizei * length
Definition: gl2ext.h:792
FT_Error error
Definition: cffdrivr.c:407
static __inline__ int CPU_haveSSE42(void)
Definition: SDL_cpuinfo.c:317
#define pop
Definition: SDL_qsort.c:125
DECLSPEC int SDLCALL SDL_GetCPUCount(void)
Definition: SDL_cpuinfo.c:334
DECLSPEC size_t SDLCALL SDL_strlcpy(char *dst, const char *src, size_t maxlen)
Definition: SDL_string.c:448
#define SDL_CACHELINE_SIZE
Definition: SDL_cpuinfo.h:77
const GLfloat * c
Definition: glew.h:14913
DECLSPEC SDL_bool SDLCALL SDL_Has3DNow(void)
Definition: SDL_cpuinfo.c:557
#define cpuid(func, a, b, c, d)
Definition: SDL_cpuinfo.c:190
static Uint32 SDL_CPUFeatures
Definition: SDL_cpuinfo.c:491
static __inline__ int CPU_haveRDTSC(void)
Definition: SDL_cpuinfo.c:209
DECLSPEC int SDLCALL SDL_GetCPUCacheLineSize(void)
Definition: SDL_cpuinfo.c:471
static Uint32 SDL_GetCPUFeatures(void)
Definition: SDL_cpuinfo.c:494
DECLSPEC int SDLCALL SDL_strcmp(const char *str1, const char *str2)
Definition: SDL_string.c:910
#define CPU_HAS_SSE
Definition: SDL_cpuinfo.c:52
DECLSPEC SDL_bool SDLCALL SDL_HasSSE3(void)
Definition: SDL_cpuinfo.c:584
static __inline__ int CPU_haveSSE3(void)
Definition: SDL_cpuinfo.c:287
#define CPU_HAS_MMX
Definition: SDL_cpuinfo.c:50
EGLSurface EGLint void ** value
Definition: eglext.h:301
DECLSPEC SDL_bool SDLCALL SDL_HasAltiVec(void)
Definition: SDL_cpuinfo.c:539
static __inline__ int CPU_haveSSE(void)
Definition: SDL_cpuinfo.c:269
GLdouble GLdouble GLdouble b
Definition: glew.h:8383
static int SDL_CPUCount
Definition: SDL_cpuinfo.c:331
#define CPU_HAS_SSE42
Definition: SDL_cpuinfo.c:56
int i
Definition: pngrutil.c:1377
#define CPU_HAS_3DNOW
Definition: SDL_cpuinfo.c:51
static __inline__ int CPU_haveSSE2(void)
Definition: SDL_cpuinfo.c:278
static __inline__ int CPU_haveCPUID(void)
Definition: SDL_cpuinfo.c:71
GLsizei size
Definition: gl2ext.h:1467