1 /*
2 * Copyright (C) 2010 The Android Open Source Project
3 * All rights reserved.
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 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in
12 * the documentation and/or other materials provided with the
13 * distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 /* ChangeLog for this library:
30 *
31 * NDK r8d: Add android_setCpu().
32 *
33 * NDK r8c: Add new ARM CPU features: VFPv2, VFP_D32, VFP_FP16,
34 * VFP_FMA, NEON_FMA, IDIV_ARM, IDIV_THUMB2 and iWMMXt.
35 *
36 * Rewrite the code to parse /proc/self/auxv instead of
37 * the "Features" field in /proc/cpuinfo.
38 *
39 * Dynamically allocate the buffer that hold the content
40 * of /proc/cpuinfo to deal with newer hardware.
41 *
42 * NDK r7c: Fix CPU count computation. The old method only reported the
43 * number of _active_ CPUs when the library was initialized,
44 * which could be less than the real total.
45 *
46 * NDK r5: Handle buggy kernels which report a CPU Architecture number of 7
47 * for an ARMv6 CPU (see below).
48 *
49 * Handle kernels that only report 'neon', and not 'vfpv3'
50 * (VFPv3 is mandated by the ARM architecture is Neon is implemented)
51 *
52 * Handle kernels that only report 'vfpv3d16', and not 'vfpv3'
53 *
54 * Fix x86 compilation. Report ANDROID_CPU_FAMILY_X86 in
55 * android_getCpuFamily().
56 *
57 * NDK r4: Initial release
58 */
59 #include <sys/system_properties.h>
60 #ifdef __arm__
61 #include <machine/cpu-features.h>
62 #endif
63 #include <pthread.h>
64 #include "cpu-features.h"
65 #include <stdio.h>
66 #include <stdlib.h>
67 #include <fcntl.h>
68 #include <errno.h>
69
70 static pthread_once_t g_once;
71 static int g_inited;
72 static AndroidCpuFamily g_cpuFamily;
73 static uint64_t g_cpuFeatures;
74 static int g_cpuCount;
75
76 static const int android_cpufeatures_debug = 0;
77
78 #ifdef __arm__
79 # define DEFAULT_CPU_FAMILY ANDROID_CPU_FAMILY_ARM
80 #elif defined __i386__
81 # define DEFAULT_CPU_FAMILY ANDROID_CPU_FAMILY_X86
82 #else
83 # define DEFAULT_CPU_FAMILY ANDROID_CPU_FAMILY_UNKNOWN
84 #endif
85
86 #define D(...) \
87 do { \
88 if (android_cpufeatures_debug) { \
89 printf(__VA_ARGS__); fflush(stdout); \
90 } \
91 } while (0)
92
93 #ifdef __i386__
x86_cpuid(int func,int values[4])94 static __inline__ void x86_cpuid(int func, int values[4])
95 {
96 int a, b, c, d;
97 /* We need to preserve ebx since we're compiling PIC code */
98 /* this means we can't use "=b" for the second output register */
99 __asm__ __volatile__ ( \
100 "push %%ebx\n"
101 "cpuid\n" \
102 "mov %%ebx, %1\n"
103 "pop %%ebx\n"
104 : "=a" (a), "=r" (b), "=c" (c), "=d" (d) \
105 : "a" (func) \
106 );
107 values[0] = a;
108 values[1] = b;
109 values[2] = c;
110 values[3] = d;
111 }
112 #endif
113
114 /* Get the size of a file by reading it until the end. This is needed
115 * because files under /proc do not always return a valid size when
116 * using fseek(0, SEEK_END) + ftell(). Nor can they be mmap()-ed.
117 */
118 static int
get_file_size(const char * pathname)119 get_file_size(const char* pathname)
120 {
121 int fd, ret, result = 0;
122 char buffer[256];
123
124 fd = open(pathname, O_RDONLY);
125 if (fd < 0) {
126 D("Can't open %s: %s\n", pathname, strerror(errno));
127 return -1;
128 }
129
130 for (;;) {
131 int ret = read(fd, buffer, sizeof buffer);
132 if (ret < 0) {
133 if (errno == EINTR)
134 continue;
135 D("Error while reading %s: %s\n", pathname, strerror(errno));
136 break;
137 }
138 if (ret == 0)
139 break;
140
141 result += ret;
142 }
143 close(fd);
144 return result;
145 }
146
147 /* Read the content of /proc/cpuinfo into a user-provided buffer.
148 * Return the length of the data, or -1 on error. Does *not*
149 * zero-terminate the content. Will not read more
150 * than 'buffsize' bytes.
151 */
152 static int
read_file(const char * pathname,char * buffer,size_t buffsize)153 read_file(const char* pathname, char* buffer, size_t buffsize)
154 {
155 int fd, count;
156
157 fd = open(pathname, O_RDONLY);
158 if (fd < 0) {
159 D("Could not open %s: %s\n", pathname, strerror(errno));
160 return -1;
161 }
162 count = 0;
163 while (count < (int)buffsize) {
164 int ret = read(fd, buffer + count, buffsize - count);
165 if (ret < 0) {
166 if (errno == EINTR)
167 continue;
168 D("Error while reading from %s: %s\n", pathname, strerror(errno));
169 if (count == 0)
170 count = -1;
171 break;
172 }
173 if (ret == 0)
174 break;
175 count += ret;
176 }
177 close(fd);
178 return count;
179 }
180
181 /* Extract the content of a the first occurence of a given field in
182 * the content of /proc/cpuinfo and return it as a heap-allocated
183 * string that must be freed by the caller.
184 *
185 * Return NULL if not found
186 */
187 static char*
extract_cpuinfo_field(const char * buffer,int buflen,const char * field)188 extract_cpuinfo_field(const char* buffer, int buflen, const char* field)
189 {
190 int fieldlen = strlen(field);
191 const char* bufend = buffer + buflen;
192 char* result = NULL;
193 int len, ignore;
194 const char *p, *q;
195
196 /* Look for first field occurence, and ensures it starts the line. */
197 p = buffer;
198 for (;;) {
199 p = memmem(p, bufend-p, field, fieldlen);
200 if (p == NULL)
201 goto EXIT;
202
203 if (p == buffer || p[-1] == '\n')
204 break;
205
206 p += fieldlen;
207 }
208
209 /* Skip to the first column followed by a space */
210 p += fieldlen;
211 p = memchr(p, ':', bufend-p);
212 if (p == NULL || p[1] != ' ')
213 goto EXIT;
214
215 /* Find the end of the line */
216 p += 2;
217 q = memchr(p, '\n', bufend-p);
218 if (q == NULL)
219 q = bufend;
220
221 /* Copy the line into a heap-allocated buffer */
222 len = q-p;
223 result = malloc(len+1);
224 if (result == NULL)
225 goto EXIT;
226
227 memcpy(result, p, len);
228 result[len] = '\0';
229
230 EXIT:
231 return result;
232 }
233
234 /* Like strlen(), but for constant string literals */
235 #define STRLEN_CONST(x) ((sizeof(x)-1)
236
237
238 /* Checks that a space-separated list of items contains one given 'item'.
239 * Returns 1 if found, 0 otherwise.
240 */
241 static int
has_list_item(const char * list,const char * item)242 has_list_item(const char* list, const char* item)
243 {
244 const char* p = list;
245 int itemlen = strlen(item);
246
247 if (list == NULL)
248 return 0;
249
250 while (*p) {
251 const char* q;
252
253 /* skip spaces */
254 while (*p == ' ' || *p == '\t')
255 p++;
256
257 /* find end of current list item */
258 q = p;
259 while (*q && *q != ' ' && *q != '\t')
260 q++;
261
262 if (itemlen == q-p && !memcmp(p, item, itemlen))
263 return 1;
264
265 /* skip to next item */
266 p = q;
267 }
268 return 0;
269 }
270
271 /* Parse an decimal integer starting from 'input', but not going further
272 * than 'limit'. Return the value into '*result'.
273 *
274 * NOTE: Does not skip over leading spaces, or deal with sign characters.
275 * NOTE: Ignores overflows.
276 *
277 * The function returns NULL in case of error (bad format), or the new
278 * position after the decimal number in case of success (which will always
279 * be <= 'limit').
280 */
281 static const char*
parse_decimal(const char * input,const char * limit,int * result)282 parse_decimal(const char* input, const char* limit, int* result)
283 {
284 const char* p = input;
285 int val = 0;
286 while (p < limit) {
287 int d = (*p - '0');
288 if ((unsigned)d >= 10U)
289 break;
290 val = val*10 + d;
291 p++;
292 }
293 if (p == input)
294 return NULL;
295
296 *result = val;
297 return p;
298 }
299
300 /* This small data type is used to represent a CPU list / mask, as read
301 * from sysfs on Linux. See http://www.kernel.org/doc/Documentation/cputopology.txt
302 *
303 * For now, we don't expect more than 32 cores on mobile devices, so keep
304 * everything simple.
305 */
306 typedef struct {
307 uint32_t mask;
308 } CpuList;
309
310 static __inline__ void
cpulist_init(CpuList * list)311 cpulist_init(CpuList* list) {
312 list->mask = 0;
313 }
314
315 static __inline__ void
cpulist_and(CpuList * list1,CpuList * list2)316 cpulist_and(CpuList* list1, CpuList* list2) {
317 list1->mask &= list2->mask;
318 }
319
320 static __inline__ void
cpulist_set(CpuList * list,int index)321 cpulist_set(CpuList* list, int index) {
322 if ((unsigned)index < 32) {
323 list->mask |= (uint32_t)(1U << index);
324 }
325 }
326
327 static __inline__ int
cpulist_count(CpuList * list)328 cpulist_count(CpuList* list) {
329 return __builtin_popcount(list->mask);
330 }
331
332 /* Parse a textual list of cpus and store the result inside a CpuList object.
333 * Input format is the following:
334 * - comma-separated list of items (no spaces)
335 * - each item is either a single decimal number (cpu index), or a range made
336 * of two numbers separated by a single dash (-). Ranges are inclusive.
337 *
338 * Examples: 0
339 * 2,4-127,128-143
340 * 0-1
341 */
342 static void
cpulist_parse(CpuList * list,const char * line,int line_len)343 cpulist_parse(CpuList* list, const char* line, int line_len)
344 {
345 const char* p = line;
346 const char* end = p + line_len;
347 const char* q;
348
349 /* NOTE: the input line coming from sysfs typically contains a
350 * trailing newline, so take care of it in the code below
351 */
352 while (p < end && *p != '\n')
353 {
354 int val, start_value, end_value;
355
356 /* Find the end of current item, and put it into 'q' */
357 q = memchr(p, ',', end-p);
358 if (q == NULL) {
359 q = end;
360 }
361
362 /* Get first value */
363 p = parse_decimal(p, q, &start_value);
364 if (p == NULL)
365 goto BAD_FORMAT;
366
367 end_value = start_value;
368
369 /* If we're not at the end of the item, expect a dash and
370 * and integer; extract end value.
371 */
372 if (p < q && *p == '-') {
373 p = parse_decimal(p+1, q, &end_value);
374 if (p == NULL)
375 goto BAD_FORMAT;
376 }
377
378 /* Set bits CPU list bits */
379 for (val = start_value; val <= end_value; val++) {
380 cpulist_set(list, val);
381 }
382
383 /* Jump to next item */
384 p = q;
385 if (p < end)
386 p++;
387 }
388
389 BAD_FORMAT:
390 ;
391 }
392
393 /* Read a CPU list from one sysfs file */
394 static void
cpulist_read_from(CpuList * list,const char * filename)395 cpulist_read_from(CpuList* list, const char* filename)
396 {
397 char file[64];
398 int filelen;
399
400 cpulist_init(list);
401
402 filelen = read_file(filename, file, sizeof file);
403 if (filelen < 0) {
404 D("Could not read %s: %s\n", filename, strerror(errno));
405 return;
406 }
407
408 cpulist_parse(list, file, filelen);
409 }
410
411 // See <asm/hwcap.h> kernel header.
412 #define HWCAP_VFP (1 << 6)
413 #define HWCAP_IWMMXT (1 << 9)
414 #define HWCAP_NEON (1 << 12)
415 #define HWCAP_VFPv3 (1 << 13)
416 #define HWCAP_VFPv3D16 (1 << 14)
417 #define HWCAP_VFPv4 (1 << 16)
418 #define HWCAP_IDIVA (1 << 17)
419 #define HWCAP_IDIVT (1 << 18)
420
421 #define AT_HWCAP 16
422
423 #if defined(__arm__)
424 /* Compute the ELF HWCAP flags.
425 */
426 static uint32_t
get_elf_hwcap(const char * cpuinfo,int cpuinfo_len)427 get_elf_hwcap(const char* cpuinfo, int cpuinfo_len)
428 {
429 /* IMPORTANT:
430 * Accessing /proc/self/auxv doesn't work anymore on all
431 * platform versions. More specifically, when running inside
432 * a regular application process, most of /proc/self/ will be
433 * non-readable, including /proc/self/auxv. This doesn't
434 * happen however if the application is debuggable, or when
435 * running under the "shell" UID, which is why this was not
436 * detected appropriately.
437 */
438 #if 0
439 uint32_t result = 0;
440 const char filepath[] = "/proc/self/auxv";
441 int fd = open(filepath, O_RDONLY);
442 if (fd < 0) {
443 D("Could not open %s: %s\n", filepath, strerror(errno));
444 return 0;
445 }
446
447 struct { uint32_t tag; uint32_t value; } entry;
448
449 for (;;) {
450 int ret = read(fd, (char*)&entry, sizeof entry);
451 if (ret < 0) {
452 if (errno == EINTR)
453 continue;
454 D("Error while reading %s: %s\n", filepath, strerror(errno));
455 break;
456 }
457 // Detect end of list.
458 if (ret == 0 || (entry.tag == 0 && entry.value == 0))
459 break;
460 if (entry.tag == AT_HWCAP) {
461 result = entry.value;
462 break;
463 }
464 }
465 close(fd);
466 return result;
467 #else
468 // Recreate ELF hwcaps by parsing /proc/cpuinfo Features tag.
469 uint32_t hwcaps = 0;
470
471 char* cpuFeatures = extract_cpuinfo_field(cpuinfo, cpuinfo_len, "Features");
472
473 if (cpuFeatures != NULL) {
474 D("Found cpuFeatures = '%s'\n", cpuFeatures);
475
476 if (has_list_item(cpuFeatures, "vfp"))
477 hwcaps |= HWCAP_VFP;
478 if (has_list_item(cpuFeatures, "vfpv3"))
479 hwcaps |= HWCAP_VFPv3;
480 if (has_list_item(cpuFeatures, "vfpv3d16"))
481 hwcaps |= HWCAP_VFPv3D16;
482 if (has_list_item(cpuFeatures, "vfpv4"))
483 hwcaps |= HWCAP_VFPv4;
484 if (has_list_item(cpuFeatures, "neon"))
485 hwcaps |= HWCAP_NEON;
486 if (has_list_item(cpuFeatures, "idiva"))
487 hwcaps |= HWCAP_IDIVA;
488 if (has_list_item(cpuFeatures, "idivt"))
489 hwcaps |= HWCAP_IDIVT;
490 if (has_list_item(cpuFeatures, "idiv"))
491 hwcaps |= HWCAP_IDIVA | HWCAP_IDIVT;
492 if (has_list_item(cpuFeatures, "iwmmxt"))
493 hwcaps |= HWCAP_IWMMXT;
494
495 free(cpuFeatures);
496 }
497 return hwcaps;
498 #endif
499 }
500 #endif /* __arm__ */
501
502 /* Return the number of cpus present on a given device.
503 *
504 * To handle all weird kernel configurations, we need to compute the
505 * intersection of the 'present' and 'possible' CPU lists and count
506 * the result.
507 */
508 static int
get_cpu_count(void)509 get_cpu_count(void)
510 {
511 CpuList cpus_present[1];
512 CpuList cpus_possible[1];
513
514 cpulist_read_from(cpus_present, "/sys/devices/system/cpu/present");
515 cpulist_read_from(cpus_possible, "/sys/devices/system/cpu/possible");
516
517 /* Compute the intersection of both sets to get the actual number of
518 * CPU cores that can be used on this device by the kernel.
519 */
520 cpulist_and(cpus_present, cpus_possible);
521
522 return cpulist_count(cpus_present);
523 }
524
525 static void
android_cpuInitFamily(void)526 android_cpuInitFamily(void)
527 {
528 #if defined(__ARM_ARCH__)
529 g_cpuFamily = ANDROID_CPU_FAMILY_ARM;
530 #elif defined(__i386__)
531 g_cpuFamily = ANDROID_CPU_FAMILY_X86;
532 #elif defined(_MIPS_ARCH)
533 g_cpuFamily = ANDROID_CPU_FAMILY_MIPS;
534 #else
535 g_cpuFamily = ANDROID_CPU_FAMILY_UNKNOWN;
536 #endif
537 }
538
539 static void
android_cpuInit(void)540 android_cpuInit(void)
541 {
542 char* cpuinfo = NULL;
543 int cpuinfo_len;
544
545 android_cpuInitFamily();
546
547 g_cpuFeatures = 0;
548 g_cpuCount = 1;
549 g_inited = 1;
550
551 cpuinfo_len = get_file_size("/proc/cpuinfo");
552 if (cpuinfo_len < 0) {
553 D("cpuinfo_len cannot be computed!");
554 return;
555 }
556 cpuinfo = malloc(cpuinfo_len);
557 if (cpuinfo == NULL) {
558 D("cpuinfo buffer could not be allocated");
559 return;
560 }
561 cpuinfo_len = read_file("/proc/cpuinfo", cpuinfo, cpuinfo_len);
562 D("cpuinfo_len is (%d):\n%.*s\n", cpuinfo_len,
563 cpuinfo_len >= 0 ? cpuinfo_len : 0, cpuinfo);
564
565 if (cpuinfo_len < 0) /* should not happen */ {
566 free(cpuinfo);
567 return;
568 }
569
570 /* Count the CPU cores, the value may be 0 for single-core CPUs */
571 g_cpuCount = get_cpu_count();
572 if (g_cpuCount == 0) {
573 g_cpuCount = 1;
574 }
575
576 D("found cpuCount = %d\n", g_cpuCount);
577
578 #ifdef __ARM_ARCH__
579 {
580 char* features = NULL;
581 char* architecture = NULL;
582
583 /* Extract architecture from the "CPU Architecture" field.
584 * The list is well-known, unlike the the output of
585 * the 'Processor' field which can vary greatly.
586 *
587 * See the definition of the 'proc_arch' array in
588 * $KERNEL/arch/arm/kernel/setup.c and the 'c_show' function in
589 * same file.
590 */
591 char* cpuArch = extract_cpuinfo_field(cpuinfo, cpuinfo_len, "CPU architecture");
592
593 if (cpuArch != NULL) {
594 char* end;
595 long archNumber;
596 int hasARMv7 = 0;
597
598 D("found cpuArch = '%s'\n", cpuArch);
599
600 /* read the initial decimal number, ignore the rest */
601 archNumber = strtol(cpuArch, &end, 10);
602
603 /* Here we assume that ARMv8 will be upwards compatible with v7
604 * in the future. Unfortunately, there is no 'Features' field to
605 * indicate that Thumb-2 is supported.
606 */
607 if (end > cpuArch && archNumber >= 7) {
608 hasARMv7 = 1;
609 }
610
611 /* Unfortunately, it seems that certain ARMv6-based CPUs
612 * report an incorrect architecture number of 7!
613 *
614 * See http://code.google.com/p/android/issues/detail?id=10812
615 *
616 * We try to correct this by looking at the 'elf_format'
617 * field reported by the 'Processor' field, which is of the
618 * form of "(v7l)" for an ARMv7-based CPU, and "(v6l)" for
619 * an ARMv6-one.
620 */
621 if (hasARMv7) {
622 char* cpuProc = extract_cpuinfo_field(cpuinfo, cpuinfo_len,
623 "Processor");
624 if (cpuProc != NULL) {
625 D("found cpuProc = '%s'\n", cpuProc);
626 if (has_list_item(cpuProc, "(v6l)")) {
627 D("CPU processor and architecture mismatch!!\n");
628 hasARMv7 = 0;
629 }
630 free(cpuProc);
631 }
632 }
633
634 if (hasARMv7) {
635 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_ARMv7;
636 }
637
638 /* The LDREX / STREX instructions are available from ARMv6 */
639 if (archNumber >= 6) {
640 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_LDREX_STREX;
641 }
642
643 free(cpuArch);
644 }
645
646 /* Extract the list of CPU features from ELF hwcaps */
647 uint32_t hwcaps = get_elf_hwcap(cpuinfo, cpuinfo_len);
648
649 if (hwcaps != 0) {
650 int has_vfp = (hwcaps & HWCAP_VFP);
651 int has_vfpv3 = (hwcaps & HWCAP_VFPv3);
652 int has_vfpv3d16 = (hwcaps & HWCAP_VFPv3D16);
653 int has_vfpv4 = (hwcaps & HWCAP_VFPv4);
654 int has_neon = (hwcaps & HWCAP_NEON);
655 int has_idiva = (hwcaps & HWCAP_IDIVA);
656 int has_idivt = (hwcaps & HWCAP_IDIVT);
657 int has_iwmmxt = (hwcaps & HWCAP_IWMMXT);
658
659 // The kernel does a poor job at ensuring consistency when
660 // describing CPU features. So lots of guessing is needed.
661
662 // 'vfpv4' implies VFPv3|VFP_FMA|FP16
663 if (has_vfpv4)
664 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_VFPv3 |
665 ANDROID_CPU_ARM_FEATURE_VFP_FP16 |
666 ANDROID_CPU_ARM_FEATURE_VFP_FMA;
667
668 // 'vfpv3' or 'vfpv3d16' imply VFPv3. Note that unlike GCC,
669 // a value of 'vfpv3' doesn't necessarily mean that the D32
670 // feature is present, so be conservative. All CPUs in the
671 // field that support D32 also support NEON, so this should
672 // not be a problem in practice.
673 if (has_vfpv3 || has_vfpv3d16)
674 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_VFPv3;
675
676 // 'vfp' is super ambiguous. Depending on the kernel, it can
677 // either mean VFPv2 or VFPv3. Make it depend on ARMv7.
678 if (has_vfp) {
679 if (g_cpuFeatures & ANDROID_CPU_ARM_FEATURE_ARMv7)
680 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_VFPv3;
681 else
682 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_VFPv2;
683 }
684
685 // Neon implies VFPv3|D32, and if vfpv4 is detected, NEON_FMA
686 if (has_neon) {
687 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_VFPv3 |
688 ANDROID_CPU_ARM_FEATURE_NEON |
689 ANDROID_CPU_ARM_FEATURE_VFP_D32;
690 if (has_vfpv4)
691 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_NEON_FMA;
692 }
693
694 // VFPv3 implies VFPv2 and ARMv7
695 if (g_cpuFeatures & ANDROID_CPU_ARM_FEATURE_VFPv3)
696 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_VFPv2 |
697 ANDROID_CPU_ARM_FEATURE_ARMv7;
698
699 // Note that some buggy kernels do not report these even when
700 // the CPU actually support the division instructions. However,
701 // assume that if 'vfpv4' is detected, then the CPU supports
702 // sdiv/udiv properly.
703 if (has_idiva || has_vfpv4)
704 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_IDIV_ARM;
705 if (has_idivt || has_vfpv4)
706 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_IDIV_THUMB2;
707
708 if (has_iwmmxt)
709 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_iWMMXt;
710 }
711 }
712 #endif /* __ARM_ARCH__ */
713
714 #ifdef __i386__
715 int regs[4];
716
717 /* According to http://en.wikipedia.org/wiki/CPUID */
718 #define VENDOR_INTEL_b 0x756e6547
719 #define VENDOR_INTEL_c 0x6c65746e
720 #define VENDOR_INTEL_d 0x49656e69
721
722 x86_cpuid(0, regs);
723 int vendorIsIntel = (regs[1] == VENDOR_INTEL_b &&
724 regs[2] == VENDOR_INTEL_c &&
725 regs[3] == VENDOR_INTEL_d);
726
727 x86_cpuid(1, regs);
728 if ((regs[2] & (1 << 9)) != 0) {
729 g_cpuFeatures |= ANDROID_CPU_X86_FEATURE_SSSE3;
730 }
731 if ((regs[2] & (1 << 23)) != 0) {
732 g_cpuFeatures |= ANDROID_CPU_X86_FEATURE_POPCNT;
733 }
734 if (vendorIsIntel && (regs[2] & (1 << 22)) != 0) {
735 g_cpuFeatures |= ANDROID_CPU_X86_FEATURE_MOVBE;
736 }
737 #endif
738
739 free(cpuinfo);
740 }
741
742
743 AndroidCpuFamily
android_getCpuFamily(void)744 android_getCpuFamily(void)
745 {
746 pthread_once(&g_once, android_cpuInit);
747 return g_cpuFamily;
748 }
749
750
751 uint64_t
android_getCpuFeatures(void)752 android_getCpuFeatures(void)
753 {
754 pthread_once(&g_once, android_cpuInit);
755 return g_cpuFeatures;
756 }
757
758
759 int
android_getCpuCount(void)760 android_getCpuCount(void)
761 {
762 pthread_once(&g_once, android_cpuInit);
763 return g_cpuCount;
764 }
765
766 static void
android_cpuInitDummy(void)767 android_cpuInitDummy(void)
768 {
769 g_inited = 1;
770 }
771
772 int
android_setCpu(int cpu_count,uint64_t cpu_features)773 android_setCpu(int cpu_count, uint64_t cpu_features)
774 {
775 /* Fail if the library was already initialized. */
776 if (g_inited)
777 return 0;
778
779 android_cpuInitFamily();
780 g_cpuCount = (cpu_count <= 0 ? 1 : cpu_count);
781 g_cpuFeatures = cpu_features;
782 pthread_once(&g_once, android_cpuInitDummy);
783
784 return 1;
785 }
786
787 /*
788 * Technical note: Making sense of ARM's FPU architecture versions.
789 *
790 * FPA was ARM's first attempt at an FPU architecture. There is no Android
791 * device that actually uses it since this technology was already obsolete
792 * when the project started. If you see references to FPA instructions
793 * somewhere, you can be sure that this doesn't apply to Android at all.
794 *
795 * FPA was followed by "VFP", soon renamed "VFPv1" due to the emergence of
796 * new versions / additions to it. ARM considers this obsolete right now,
797 * and no known Android device implements it either.
798 *
799 * VFPv2 added a few instructions to VFPv1, and is an *optional* extension
800 * supported by some ARMv5TE, ARMv6 and ARMv6T2 CPUs. Note that a device
801 * supporting the 'armeabi' ABI doesn't necessarily support these.
802 *
803 * VFPv3-D16 adds a few instructions on top of VFPv2 and is typically used
804 * on ARMv7-A CPUs which implement a FPU. Note that it is also mandated
805 * by the Android 'armeabi-v7a' ABI. The -D16 suffix in its name means
806 * that it provides 16 double-precision FPU registers (d0-d15) and 32
807 * single-precision ones (s0-s31) which happen to be mapped to the same
808 * register banks.
809 *
810 * VFPv3-D32 is the name of an extension to VFPv3-D16 that provides 16
811 * additional double precision registers (d16-d31). Note that there are
812 * still only 32 single precision registers.
813 *
814 * VFPv3xD is a *subset* of VFPv3-D16 that only provides single-precision
815 * registers. It is only used on ARMv7-M (i.e. on micro-controllers) which
816 * are not supported by Android. Note that it is not compatible with VFPv2.
817 *
818 * NOTE: The term 'VFPv3' usually designate either VFPv3-D16 or VFPv3-D32
819 * depending on context. For example GCC uses it for VFPv3-D32, but
820 * the Linux kernel code uses it for VFPv3-D16 (especially in
821 * /proc/cpuinfo). Always try to use the full designation when
822 * possible.
823 *
824 * NEON, a.k.a. "ARM Advanced SIMD" is an extension that provides
825 * instructions to perform parallel computations on vectors of 8, 16,
826 * 32, 64 and 128 bit quantities. NEON requires VFPv32-D32 since all
827 * NEON registers are also mapped to the same register banks.
828 *
829 * VFPv4-D16, adds a few instructions on top of VFPv3-D16 in order to
830 * perform fused multiply-accumulate on VFP registers, as well as
831 * half-precision (16-bit) conversion operations.
832 *
833 * VFPv4-D32 is VFPv4-D16 with 32, instead of 16, FPU double precision
834 * registers.
835 *
836 * VPFv4-NEON is VFPv4-D32 with NEON instructions. It also adds fused
837 * multiply-accumulate instructions that work on the NEON registers.
838 *
839 * NOTE: Similarly, "VFPv4" might either reference VFPv4-D16 or VFPv4-D32
840 * depending on context.
841 *
842 * The following information was determined by scanning the binutils-2.22
843 * sources:
844 *
845 * Basic VFP instruction subsets:
846 *
847 * #define FPU_VFP_EXT_V1xD 0x08000000 // Base VFP instruction set.
848 * #define FPU_VFP_EXT_V1 0x04000000 // Double-precision insns.
849 * #define FPU_VFP_EXT_V2 0x02000000 // ARM10E VFPr1.
850 * #define FPU_VFP_EXT_V3xD 0x01000000 // VFPv3 single-precision.
851 * #define FPU_VFP_EXT_V3 0x00800000 // VFPv3 double-precision.
852 * #define FPU_NEON_EXT_V1 0x00400000 // Neon (SIMD) insns.
853 * #define FPU_VFP_EXT_D32 0x00200000 // Registers D16-D31.
854 * #define FPU_VFP_EXT_FP16 0x00100000 // Half-precision extensions.
855 * #define FPU_NEON_EXT_FMA 0x00080000 // Neon fused multiply-add
856 * #define FPU_VFP_EXT_FMA 0x00040000 // VFP fused multiply-add
857 *
858 * FPU types (excluding NEON)
859 *
860 * FPU_VFP_V1xD (EXT_V1xD)
861 * |
862 * +--------------------------+
863 * | |
864 * FPU_VFP_V1 (+EXT_V1) FPU_VFP_V3xD (+EXT_V2+EXT_V3xD)
865 * | |
866 * | |
867 * FPU_VFP_V2 (+EXT_V2) FPU_VFP_V4_SP_D16 (+EXT_FP16+EXT_FMA)
868 * |
869 * FPU_VFP_V3D16 (+EXT_Vx3D+EXT_V3)
870 * |
871 * +--------------------------+
872 * | |
873 * FPU_VFP_V3 (+EXT_D32) FPU_VFP_V4D16 (+EXT_FP16+EXT_FMA)
874 * | |
875 * | FPU_VFP_V4 (+EXT_D32)
876 * |
877 * FPU_VFP_HARD (+EXT_FMA+NEON_EXT_FMA)
878 *
879 * VFP architectures:
880 *
881 * ARCH_VFP_V1xD (EXT_V1xD)
882 * |
883 * +------------------+
884 * | |
885 * | ARCH_VFP_V3xD (+EXT_V2+EXT_V3xD)
886 * | |
887 * | ARCH_VFP_V3xD_FP16 (+EXT_FP16)
888 * | |
889 * | ARCH_VFP_V4_SP_D16 (+EXT_FMA)
890 * |
891 * ARCH_VFP_V1 (+EXT_V1)
892 * |
893 * ARCH_VFP_V2 (+EXT_V2)
894 * |
895 * ARCH_VFP_V3D16 (+EXT_V3xD+EXT_V3)
896 * |
897 * +-------------------+
898 * | |
899 * | ARCH_VFP_V3D16_FP16 (+EXT_FP16)
900 * |
901 * +-------------------+
902 * | |
903 * | ARCH_VFP_V4_D16 (+EXT_FP16+EXT_FMA)
904 * | |
905 * | ARCH_VFP_V4 (+EXT_D32)
906 * | |
907 * | ARCH_NEON_VFP_V4 (+EXT_NEON+EXT_NEON_FMA)
908 * |
909 * ARCH_VFP_V3 (+EXT_D32)
910 * |
911 * +-------------------+
912 * | |
913 * | ARCH_VFP_V3_FP16 (+EXT_FP16)
914 * |
915 * ARCH_VFP_V3_PLUS_NEON_V1 (+EXT_NEON)
916 * |
917 * ARCH_NEON_FP16 (+EXT_FP16)
918 *
919 * -fpu=<name> values and their correspondance with FPU architectures above:
920 *
921 * {"vfp", FPU_ARCH_VFP_V2},
922 * {"vfp9", FPU_ARCH_VFP_V2},
923 * {"vfp3", FPU_ARCH_VFP_V3}, // For backwards compatbility.
924 * {"vfp10", FPU_ARCH_VFP_V2},
925 * {"vfp10-r0", FPU_ARCH_VFP_V1},
926 * {"vfpxd", FPU_ARCH_VFP_V1xD},
927 * {"vfpv2", FPU_ARCH_VFP_V2},
928 * {"vfpv3", FPU_ARCH_VFP_V3},
929 * {"vfpv3-fp16", FPU_ARCH_VFP_V3_FP16},
930 * {"vfpv3-d16", FPU_ARCH_VFP_V3D16},
931 * {"vfpv3-d16-fp16", FPU_ARCH_VFP_V3D16_FP16},
932 * {"vfpv3xd", FPU_ARCH_VFP_V3xD},
933 * {"vfpv3xd-fp16", FPU_ARCH_VFP_V3xD_FP16},
934 * {"neon", FPU_ARCH_VFP_V3_PLUS_NEON_V1},
935 * {"neon-fp16", FPU_ARCH_NEON_FP16},
936 * {"vfpv4", FPU_ARCH_VFP_V4},
937 * {"vfpv4-d16", FPU_ARCH_VFP_V4D16},
938 * {"fpv4-sp-d16", FPU_ARCH_VFP_V4_SP_D16},
939 * {"neon-vfpv4", FPU_ARCH_NEON_VFP_V4},
940 *
941 *
942 * Simplified diagram that only includes FPUs supported by Android:
943 * Only ARCH_VFP_V3D16 is actually mandated by the armeabi-v7a ABI,
944 * all others are optional and must be probed at runtime.
945 *
946 * ARCH_VFP_V3D16 (EXT_V1xD+EXT_V1+EXT_V2+EXT_V3xD+EXT_V3)
947 * |
948 * +-------------------+
949 * | |
950 * | ARCH_VFP_V3D16_FP16 (+EXT_FP16)
951 * |
952 * +-------------------+
953 * | |
954 * | ARCH_VFP_V4_D16 (+EXT_FP16+EXT_FMA)
955 * | |
956 * | ARCH_VFP_V4 (+EXT_D32)
957 * | |
958 * | ARCH_NEON_VFP_V4 (+EXT_NEON+EXT_NEON_FMA)
959 * |
960 * ARCH_VFP_V3 (+EXT_D32)
961 * |
962 * +-------------------+
963 * | |
964 * | ARCH_VFP_V3_FP16 (+EXT_FP16)
965 * |
966 * ARCH_VFP_V3_PLUS_NEON_V1 (+EXT_NEON)
967 * |
968 * ARCH_NEON_FP16 (+EXT_FP16)
969 *
970 */
971