092031724c90b2fd82a6945e1e7c7b2d5d34efad
[flac.git] / src / libFLAC / cpu.c
1 /* libFLAC - Free Lossless Audio Codec library
2  * Copyright (C) 2001-2009  Josh Coalson
3  * Copyright (C) 2011-2013  Xiph.Org Foundation
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * - Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *
12  * - Redistributions in binary form must reproduce the above copyright
13  * notice, this list of conditions and the following disclaimer in the
14  * documentation and/or other materials provided with the distribution.
15  *
16  * - Neither the name of the Xiph.org Foundation nor the names of its
17  * contributors may be used to endorse or promote products derived from
18  * this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23  * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
27  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
28  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
29  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
30  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32
33 #if HAVE_CONFIG_H
34 #  include <config.h>
35 #endif
36
37 #include "private/cpu.h"
38 #include <stdlib.h>
39 #include <stdio.h>
40
41 #if defined FLAC__CPU_IA32
42 # include <signal.h>
43 #elif defined FLAC__CPU_PPC
44 # if !defined FLAC__NO_ASM
45 #  if defined FLAC__SYS_DARWIN
46 #   include <sys/sysctl.h>
47 #   include <mach/mach.h>
48 #   include <mach/mach_host.h>
49 #   include <mach/host_info.h>
50 #   include <mach/machine.h>
51 #   ifndef CPU_SUBTYPE_POWERPC_970
52 #    define CPU_SUBTYPE_POWERPC_970 ((cpu_subtype_t) 100)
53 #   endif
54 #  else /* FLAC__SYS_DARWIN */
55
56 #   include <signal.h>
57 #   include <setjmp.h>
58
59 static sigjmp_buf jmpbuf;
60 static volatile sig_atomic_t canjump = 0;
61
62 static void sigill_handler (int sig)
63 {
64         if (!canjump) {
65                 signal (sig, SIG_DFL);
66                 raise (sig);
67         }
68         canjump = 0;
69         siglongjmp (jmpbuf, 1);
70 }
71 #  endif /* FLAC__SYS_DARWIN */
72 # endif /* FLAC__NO_ASM */
73 #endif /* FLAC__CPU_PPC */
74
75 #if defined (__NetBSD__) || defined(__OpenBSD__)
76 #include <sys/param.h>
77 #include <sys/sysctl.h>
78 #include <machine/cpu.h>
79 #endif
80
81 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
82 #include <sys/types.h>
83 #include <sys/sysctl.h>
84 #endif
85
86 #if defined(__APPLE__)
87 /* how to get sysctlbyname()? */
88 #endif
89
90 /* these are flags in EDX of CPUID AX=00000001 */
91 static const unsigned FLAC__CPUINFO_IA32_CPUID_CMOV = 0x00008000;
92 static const unsigned FLAC__CPUINFO_IA32_CPUID_MMX = 0x00800000;
93 static const unsigned FLAC__CPUINFO_IA32_CPUID_FXSR = 0x01000000;
94 static const unsigned FLAC__CPUINFO_IA32_CPUID_SSE = 0x02000000;
95 static const unsigned FLAC__CPUINFO_IA32_CPUID_SSE2 = 0x04000000;
96 /* these are flags in ECX of CPUID AX=00000001 */
97 static const unsigned FLAC__CPUINFO_IA32_CPUID_SSE3 = 0x00000001;
98 static const unsigned FLAC__CPUINFO_IA32_CPUID_SSSE3 = 0x00000200;
99 static const unsigned FLAC__CPUINFO_IA32_CPUID_SSE41 = 0x00080000;
100 static const unsigned FLAC__CPUINFO_IA32_CPUID_SSE42 = 0x00100000;
101 /* these are flags in EDX of CPUID AX=80000001 */
102 static const unsigned FLAC__CPUINFO_IA32_CPUID_EXTENDED_AMD_3DNOW = 0x80000000;
103 static const unsigned FLAC__CPUINFO_IA32_CPUID_EXTENDED_AMD_EXT3DNOW = 0x40000000;
104 static const unsigned FLAC__CPUINFO_IA32_CPUID_EXTENDED_AMD_EXTMMX = 0x00400000;
105
106
107 /*
108  * Extra stuff needed for detection of OS support for SSE on IA-32
109  */
110 #if defined(FLAC__CPU_IA32) && !defined FLAC__NO_ASM && defined FLAC__HAS_NASM && !defined FLAC__NO_SSE_OS && !defined FLAC__SSE_OS
111 # if defined(__linux__)
112 /*
113  * If the OS doesn't support SSE, we will get here with a SIGILL.  We
114  * modify the return address to jump over the offending SSE instruction
115  * and also the operation following it that indicates the instruction
116  * executed successfully.  In this way we use no global variables and
117  * stay thread-safe.
118  *
119  * 3 + 3 + 6:
120  *   3 bytes for "xorps xmm0,xmm0"
121  *   3 bytes for estimate of how long the follwing "inc var" instruction is
122  *   6 bytes extra in case our estimate is wrong
123  * 12 bytes puts us in the NOP "landing zone"
124  */
125 #  undef USE_OBSOLETE_SIGCONTEXT_FLAVOR /* #define this to use the older signal handler method */
126 #  ifdef USE_OBSOLETE_SIGCONTEXT_FLAVOR
127         static void sigill_handler_sse_os(int signal, struct sigcontext sc)
128         {
129                 (void)signal;
130                 sc.eip += 3 + 3 + 6;
131         }
132 #  else
133 #   include <sys/ucontext.h>
134         static void sigill_handler_sse_os(int signal, siginfo_t *si, void *uc)
135         {
136                 (void)signal, (void)si;
137                 ((ucontext_t*)uc)->uc_mcontext.gregs[14/*REG_EIP*/] += 3 + 3 + 6;
138         }
139 #  endif
140 # elif defined(_MSC_VER)
141 #  include <windows.h>
142 #  define USE_TRY_CATCH_FLAVOR /* sigill_handler flavor resulted in several crash reports on win32 */
143 #  ifdef USE_TRY_CATCH_FLAVOR
144 #  else
145         LONG CALLBACK sigill_handler_sse_os(EXCEPTION_POINTERS *ep)
146         {
147                 if(ep->ExceptionRecord->ExceptionCode == EXCEPTION_ILLEGAL_INSTRUCTION) {
148                         ep->ContextRecord->Eip += 3 + 3 + 6;
149                         return EXCEPTION_CONTINUE_EXECUTION;
150                 }
151                 return EXCEPTION_CONTINUE_SEARCH;
152         }
153 #  endif
154 # endif
155 #endif
156
157
158 void FLAC__cpu_info(FLAC__CPUInfo *info)
159 {
160 /*
161  * IA32-specific
162  */
163 #ifdef FLAC__CPU_IA32
164         info->type = FLAC__CPUINFO_TYPE_IA32;
165 #if !defined FLAC__NO_ASM && defined FLAC__HAS_NASM
166         info->use_asm = true; /* we assume a minimum of 80386 with FLAC__CPU_IA32 */
167         info->ia32.cpuid = FLAC__cpu_have_cpuid_asm_ia32()? true : false;
168         info->ia32.bswap = info->ia32.cpuid; /* CPUID => BSWAP since it came after */
169         info->ia32.cmov = false;
170         info->ia32.mmx = false;
171         info->ia32.fxsr = false;
172         info->ia32.sse = false;
173         info->ia32.sse2 = false;
174         info->ia32.sse3 = false;
175         info->ia32.ssse3 = false;
176         info->ia32.sse41 = false;
177         info->ia32.sse42 = false;
178         info->ia32._3dnow = false;
179         info->ia32.ext3dnow = false;
180         info->ia32.extmmx = false;
181         if(info->ia32.cpuid) {
182                 /* http://www.sandpile.org/x86/cpuid.htm */
183                 FLAC__uint32 flags_edx, flags_ecx;
184                 FLAC__cpu_info_asm_ia32(&flags_edx, &flags_ecx);
185                 info->ia32.cmov  = (flags_edx & FLAC__CPUINFO_IA32_CPUID_CMOV )? true : false;
186                 info->ia32.mmx   = (flags_edx & FLAC__CPUINFO_IA32_CPUID_MMX  )? true : false;
187                 info->ia32.fxsr  = (flags_edx & FLAC__CPUINFO_IA32_CPUID_FXSR )? true : false;
188                 info->ia32.sse   = (flags_edx & FLAC__CPUINFO_IA32_CPUID_SSE  )? true : false;
189                 info->ia32.sse2  = (flags_edx & FLAC__CPUINFO_IA32_CPUID_SSE2 )? true : false;
190                 info->ia32.sse3  = (flags_ecx & FLAC__CPUINFO_IA32_CPUID_SSE3 )? true : false;
191                 info->ia32.ssse3 = (flags_ecx & FLAC__CPUINFO_IA32_CPUID_SSSE3)? true : false;
192                 info->ia32.sse41 = (flags_ecx & FLAC__CPUINFO_IA32_CPUID_SSE41)? true : false;
193                 info->ia32.sse42 = (flags_ecx & FLAC__CPUINFO_IA32_CPUID_SSE42)? true : false;
194
195 #ifdef FLAC__USE_3DNOW
196                 flags_edx = FLAC__cpu_info_extended_amd_asm_ia32();
197                 info->ia32._3dnow   = (flags_edx & FLAC__CPUINFO_IA32_CPUID_EXTENDED_AMD_3DNOW   )? true : false;
198                 info->ia32.ext3dnow = (flags_edx & FLAC__CPUINFO_IA32_CPUID_EXTENDED_AMD_EXT3DNOW)? true : false;
199                 info->ia32.extmmx   = (flags_edx & FLAC__CPUINFO_IA32_CPUID_EXTENDED_AMD_EXTMMX  )? true : false;
200 #else
201                 info->ia32._3dnow = info->ia32.ext3dnow = info->ia32.extmmx = false;
202 #endif
203
204 #ifdef DEBUG
205                 fprintf(stderr, "CPU info (IA-32):\n");
206                 fprintf(stderr, "  CPUID ...... %c\n", info->ia32.cpuid   ? 'Y' : 'n');
207                 fprintf(stderr, "  BSWAP ...... %c\n", info->ia32.bswap   ? 'Y' : 'n');
208                 fprintf(stderr, "  CMOV ....... %c\n", info->ia32.cmov    ? 'Y' : 'n');
209                 fprintf(stderr, "  MMX ........ %c\n", info->ia32.mmx     ? 'Y' : 'n');
210                 fprintf(stderr, "  FXSR ....... %c\n", info->ia32.fxsr    ? 'Y' : 'n');
211                 fprintf(stderr, "  SSE ........ %c\n", info->ia32.sse     ? 'Y' : 'n');
212                 fprintf(stderr, "  SSE2 ....... %c\n", info->ia32.sse2    ? 'Y' : 'n');
213                 fprintf(stderr, "  SSE3 ....... %c\n", info->ia32.sse3    ? 'Y' : 'n');
214                 fprintf(stderr, "  SSSE3 ...... %c\n", info->ia32.ssse3   ? 'Y' : 'n');
215                 fprintf(stderr, "  SSE41 ...... %c\n", info->ia32.sse41   ? 'Y' : 'n');
216                 fprintf(stderr, "  SSE42 ...... %c\n", info->ia32.sse42   ? 'Y' : 'n');
217                 fprintf(stderr, "  3DNow! ..... %c\n", info->ia32._3dnow  ? 'Y' : 'n');
218                 fprintf(stderr, "  3DNow!-ext . %c\n", info->ia32.ext3dnow? 'Y' : 'n');
219                 fprintf(stderr, "  3DNow!-MMX . %c\n", info->ia32.extmmx  ? 'Y' : 'n');
220 #endif
221
222                 /*
223                  * now have to check for OS support of SSE/SSE2
224                  */
225                 if(info->ia32.fxsr || info->ia32.sse || info->ia32.sse2) {
226 #if defined FLAC__NO_SSE_OS
227                         /* assume user knows better than us; turn it off */
228                         info->ia32.fxsr = info->ia32.sse = info->ia32.sse2 = info->ia32.sse3 = info->ia32.ssse3 = info->ia32.sse41 = info->ia32.sse42 = false;
229 #elif defined FLAC__SSE_OS
230                         /* assume user knows better than us; leave as detected above */
231 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) || defined(__APPLE__)
232                         int sse = 0;
233                         size_t len;
234                         /* at least one of these must work: */
235                         len = sizeof(sse); sse = sse || (sysctlbyname("hw.instruction_sse", &sse, &len, NULL, 0) == 0 && sse);
236                         len = sizeof(sse); sse = sse || (sysctlbyname("hw.optional.sse"   , &sse, &len, NULL, 0) == 0 && sse); /* __APPLE__ ? */
237                         if(!sse)
238                                 info->ia32.fxsr = info->ia32.sse = info->ia32.sse2 = info->ia32.sse3 = info->ia32.ssse3 = info->ia32.sse41 = info->ia32.sse42 = false;
239 #elif defined(__NetBSD__) || defined (__OpenBSD__)
240 # if __NetBSD_Version__ >= 105250000 || (defined __OpenBSD__)
241                         int val = 0, mib[2] = { CTL_MACHDEP, CPU_SSE };
242                         size_t len = sizeof(val);
243                         if(sysctl(mib, 2, &val, &len, NULL, 0) < 0 || !val)
244                                 info->ia32.fxsr = info->ia32.sse = info->ia32.sse2 = info->ia32.sse3 = info->ia32.ssse3 = info->ia32.sse41 = info->ia32.sse42 = false;
245                         else { /* double-check SSE2 */
246                                 mib[1] = CPU_SSE2;
247                                 len = sizeof(val);
248                                 if(sysctl(mib, 2, &val, &len, NULL, 0) < 0 || !val)
249                                         info->ia32.sse2 = info->ia32.sse3 = info->ia32.ssse3 = info->ia32.sse41 = info->ia32.sse42 = false;
250                         }
251 # else
252                         info->ia32.fxsr = info->ia32.sse = info->ia32.sse2 = info->ia32.sse3 = info->ia32.ssse3 = info->ia32.sse41 = info->ia32.sse42 = false;
253 # endif
254 #elif defined(__linux__)
255                         int sse = 0;
256                         struct sigaction sigill_save;
257 #ifdef USE_OBSOLETE_SIGCONTEXT_FLAVOR
258                         if(0 == sigaction(SIGILL, NULL, &sigill_save) && signal(SIGILL, (void (*)(int))sigill_handler_sse_os) != SIG_ERR)
259 #else
260                         struct sigaction sigill_sse;
261                         sigill_sse.sa_sigaction = sigill_handler_sse_os;
262                         __sigemptyset(&sigill_sse.sa_mask);
263                         sigill_sse.sa_flags = SA_SIGINFO | SA_RESETHAND; /* SA_RESETHAND just in case our SIGILL return jump breaks, so we don't get stuck in a loop */
264                         if(0 == sigaction(SIGILL, &sigill_sse, &sigill_save))
265 #endif
266                         {
267                                 /* http://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html */
268                                 /* see sigill_handler_sse_os() for an explanation of the following: */
269                                 asm volatile (
270                                         "xorl %0,%0\n\t"          /* for some reason, still need to do this to clear 'sse' var */
271                                         "xorps %%xmm0,%%xmm0\n\t" /* will cause SIGILL if unsupported by OS */
272                                         "incl %0\n\t"             /* SIGILL handler will jump over this */
273                                         /* landing zone */
274                                         "nop\n\t" /* SIGILL jump lands here if "inc" is 9 bytes */
275                                         "nop\n\t"
276                                         "nop\n\t"
277                                         "nop\n\t"
278                                         "nop\n\t"
279                                         "nop\n\t"
280                                         "nop\n\t" /* SIGILL jump lands here if "inc" is 3 bytes (expected) */
281                                         "nop\n\t"
282                                         "nop"     /* SIGILL jump lands here if "inc" is 1 byte */
283                                         : "=r"(sse)
284                                         : "r"(sse)
285                                 );
286
287                                 sigaction(SIGILL, &sigill_save, NULL);
288                         }
289
290                         if(!sse)
291                                 info->ia32.fxsr = info->ia32.sse = info->ia32.sse2 = info->ia32.sse3 = info->ia32.ssse3 = info->ia32.sse41 = info->ia32.sse42 = false;
292 #elif defined(_MSC_VER)
293 # ifdef USE_TRY_CATCH_FLAVOR
294                         __try {
295                                 __asm {
296                                         xorps xmm0,xmm0
297                                 }
298                         }
299                         __except(EXCEPTION_EXECUTE_HANDLER) {
300                                 if (_exception_code() == STATUS_ILLEGAL_INSTRUCTION)
301                                         info->ia32.fxsr = info->ia32.sse = info->ia32.sse2 = info->ia32.sse3 = info->ia32.ssse3 = info->ia32.sse41 = info->ia32.sse42 = false;
302                         }
303 # else
304                         int sse = 0;
305                         LPTOP_LEVEL_EXCEPTION_FILTER save = SetUnhandledExceptionFilter(sigill_handler_sse_os);
306                         /* see GCC version above for explanation */
307                         /*  http://msdn2.microsoft.com/en-us/library/4ks26t93.aspx */
308                         /*  http://www.codeproject.com/cpp/gccasm.asp */
309                         /*  http://www.hick.org/~mmiller/msvc_inline_asm.html */
310                         __asm {
311                                 xorps xmm0,xmm0
312                                 inc sse
313                                 nop
314                                 nop
315                                 nop
316                                 nop
317                                 nop
318                                 nop
319                                 nop
320                                 nop
321                                 nop
322                         }
323                         SetUnhandledExceptionFilter(save);
324                         if(!sse)
325                                 info->ia32.fxsr = info->ia32.sse = info->ia32.sse2 = info->ia32.sse3 = info->ia32.ssse3 = info->ia32.sse41 = info->ia32.sse42 = false;
326 # endif
327 #else
328                         /* no way to test, disable to be safe */
329                         info->ia32.fxsr = info->ia32.sse = info->ia32.sse2 = info->ia32.sse3 = info->ia32.ssse3 = info->ia32.sse41 = info->ia32.sse42 = false;
330 #endif
331 #ifdef DEBUG
332                 fprintf(stderr, "  SSE OS sup . %c\n", info->ia32.sse     ? 'Y' : 'n');
333 #endif
334
335                 }
336         }
337 #else
338         info->use_asm = false;
339 #endif
340
341 /*
342  * x86-64-specific
343  */
344 #elif defined FLAC__CPU_X86_64
345         info->type = FLAC__CPUINFO_TYPE_X86_64;
346 #if !defined FLAC__NO_ASM && defined FLAC__HAS_X86INTRIN
347         info->use_asm = true;
348         {
349                 /* http://www.sandpile.org/x86/cpuid.htm */
350                 FLAC__uint32 flags_edx, flags_ecx;
351                 FLAC__cpu_info_x86(&flags_edx, &flags_ecx);
352                 info->x86_64.sse3  = (flags_ecx & FLAC__CPUINFO_IA32_CPUID_SSE3 )? true : false;
353                 info->x86_64.ssse3 = (flags_ecx & FLAC__CPUINFO_IA32_CPUID_SSSE3)? true : false;
354                 info->x86_64.sse41 = (flags_ecx & FLAC__CPUINFO_IA32_CPUID_SSE41)? true : false;
355                 info->x86_64.sse42 = (flags_ecx & FLAC__CPUINFO_IA32_CPUID_SSE42)? true : false;
356         }
357 #ifdef DEBUG
358         fprintf(stderr, "CPU info (x86-64):\n");
359         fprintf(stderr, "  SSE3 ....... %c\n", info->x86_64.sse3    ? 'Y' : 'n');
360         fprintf(stderr, "  SSSE3 ...... %c\n", info->x86_64.ssse3   ? 'Y' : 'n');
361         fprintf(stderr, "  SSE41 ...... %c\n", info->x86_64.sse41   ? 'Y' : 'n');
362         fprintf(stderr, "  SSE42 ...... %c\n", info->x86_64.sse42   ? 'Y' : 'n');
363 #endif
364
365 #else
366         info->use_asm = false;
367 #endif
368
369 /*
370  * PPC-specific
371  */
372 #elif defined FLAC__CPU_PPC
373         info->type = FLAC__CPUINFO_TYPE_PPC;
374 # if !defined FLAC__NO_ASM
375         info->use_asm = true;
376 #  ifdef FLAC__USE_ALTIVEC
377 #   if defined FLAC__SYS_DARWIN
378         {
379                 int val = 0, mib[2] = { CTL_HW, HW_VECTORUNIT };
380                 size_t len = sizeof(val);
381                 info->ppc.altivec = !(sysctl(mib, 2, &val, &len, NULL, 0) || !val);
382         }
383         {
384                 host_basic_info_data_t hostInfo;
385                 mach_msg_type_number_t infoCount;
386
387                 infoCount = HOST_BASIC_INFO_COUNT;
388                 host_info(mach_host_self(), HOST_BASIC_INFO, (host_info_t)&hostInfo, &infoCount);
389
390                 info->ppc.ppc64 = (hostInfo.cpu_type == CPU_TYPE_POWERPC) && (hostInfo.cpu_subtype == CPU_SUBTYPE_POWERPC_970);
391         }
392 #   else /* FLAC__USE_ALTIVEC && !FLAC__SYS_DARWIN */
393         {
394                 /* no Darwin, do it the brute-force way */
395                 /* @@@@@@ this is not thread-safe; replace with SSE OS method above or remove */
396                 info->ppc.altivec = 0;
397                 info->ppc.ppc64 = 0;
398
399                 signal (SIGILL, sigill_handler);
400                 canjump = 0;
401                 if (!sigsetjmp (jmpbuf, 1)) {
402                         canjump = 1;
403
404                         asm volatile (
405                                 "mtspr 256, %0\n\t"
406                                 "vand %%v0, %%v0, %%v0"
407                                 :
408                                 : "r" (-1)
409                         );
410
411                         info->ppc.altivec = 1;
412                 }
413                 canjump = 0;
414                 if (!sigsetjmp (jmpbuf, 1)) {
415                         int x = 0;
416                         canjump = 1;
417
418                         /* PPC64 hardware implements the cntlzd instruction */
419                         asm volatile ("cntlzd %0, %1" : "=r" (x) : "r" (x) );
420
421                         info->ppc.ppc64 = 1;
422                 }
423                 signal (SIGILL, SIG_DFL); /*@@@@@@ should save and restore old signal */
424         }
425 #   endif
426 #  else /* !FLAC__USE_ALTIVEC */
427         info->ppc.altivec = 0;
428         info->ppc.ppc64 = 0;
429 #  endif
430 # else
431         info->use_asm = false;
432 # endif
433
434 /*
435  * unknown CPU
436  */
437 #else
438         info->type = FLAC__CPUINFO_TYPE_UNKNOWN;
439         info->use_asm = false;
440 #endif
441 }
442
443 #if (defined FLAC__CPU_IA32 || defined FLAC__CPU_X86_64) && defined FLAC__HAS_X86INTRIN
444
445 #if defined _MSC_VER
446 #include <intrin.h> /* for __cpuid() */
447 #elif defined __GNUC__
448 #include <cpuid.h> /* for __get_cpuid() */
449 #endif
450
451 void FLAC__cpu_info_x86(FLAC__uint32 *flags_edx, FLAC__uint32 *flags_ecx)
452 {
453 #if defined _MSC_VER || defined __INTEL_COMPILER
454         int cpuinfo[4];
455         __cpuid(cpuinfo, 1);
456         *flags_ecx = cpuinfo[2];
457         *flags_edx = cpuinfo[3];
458 #elif defined __GNUC__
459         FLAC__uint32 flags_eax, flags_ebx;
460         if (0 == __get_cpuid(1, &flags_eax, &flags_ebx, flags_ecx, flags_edx))
461                 *flags_ecx = *flags_edx = 0;
462 #else
463         *flags_ecx = *flags_edx = 0;
464 #endif
465 }
466
467 #endif /* (FLAC__CPU_IA32 || FLAC__CPU_X86_64) && FLAC__HAS_X86INTRIN */