Data Structures
struct	CpuList

Functions
static void	android_cpuInit (void)

static void	android_cpuInitDummy (void)

static void	android_cpuInitFamily (void)

int	android_getCpuCount (void)

AndroidCpuFamily	android_getCpuFamily (void)

uint64_t	android_getCpuFeatures (void)

uint32_t	android_getCpuIdArm (void)

int	android_setCpu (int cpu_count, uint64_t cpu_features)

int	android_setCpuArm (int cpu_count, uint64_t cpu_features, uint32_t cpu_id)

static __inline__ void	cpulist_and (CpuList list1, CpuList list2)

static __inline__ int	cpulist_count (CpuList *list)

static __inline__ void	cpulist_init (CpuList *list)

static void	cpulist_parse (CpuList list, const char line, int line_len)

static void	cpulist_read_from (CpuList list, const char filename)

static __inline__ void	cpulist_set (CpuList *list, int index)

static char *	extract_cpuinfo_field (const char buffer, int buflen, const char field)

static int	get_cpu_count (void)

static uint32_t	get_elf_hwcap_from_getauxval (void)

static uint32_t	get_elf_hwcap_from_proc_cpuinfo (const char *cpuinfo, int cpuinfo_len)

static uint32_t	get_elf_hwcap_from_proc_self_auxv (void)

static int	get_file_size (const char *pathname)

static int	has_list_item (const char list, const char item)

static const char *	parse_decimal (const char input, const char limit, int *result)

static const char *	parse_hexadecimal (const char input, const char limit, int *result)

static const char *	parse_number (const char input, const char limit, int base, int *result)

static int	read_file (const char pathname, char buffer, size_t buffsize)

static __inline__ void	x86_cpuid (int func, int values[4])

Variables
static const int	android_cpufeatures_debug = 0

static int	g_cpuCount

static AndroidCpuFamily	g_cpuFamily

static uint64_t	g_cpuFeatures

static uint32_t	g_cpuIdArm

static int	g_inited

static pthread_once_t	g_once

Data Structure Documentation

struct CpuList

Definition at line 327 of file cpu-features.c.

Data Fields
uint32_t	mask

Function Documentation

static void android_cpuInit ( void )

static

Definition at line 627 of file cpu-features.c.

 {
     char* cpuinfo = NULL;
     int   cpuinfo_len;
 
     android_cpuInitFamily();
 
     g_cpuFeatures = 0;
     g_cpuCount    = 1;
     g_inited      = 1;
 
     cpuinfo_len = get_file_size("/proc/cpuinfo");
     if (cpuinfo_len < 0) {
       D("cpuinfo_len cannot be computed!");
       return;
     }
     cpuinfo = (char *) malloc(cpuinfo_len);
     if (cpuinfo == NULL) {
       D("cpuinfo buffer could not be allocated");
       return;
     }
     cpuinfo_len = read_file("/proc/cpuinfo", cpuinfo, cpuinfo_len);
     D("cpuinfo_len is (%d):\n%.*s\n", cpuinfo_len,
       cpuinfo_len >= 0 ? cpuinfo_len : 0, cpuinfo);
 
     if (cpuinfo_len < 0)  /* should not happen */ {
         free(cpuinfo);
         return;
     }
 
     /* Count the CPU cores, the value may be 0 for single-core CPUs */
     g_cpuCount = get_cpu_count();
     if (g_cpuCount == 0) {
         g_cpuCount = 1;
     }
 
     D("found cpuCount = %d\n", g_cpuCount);
 
 #ifdef __arm__
     {
         /* Extract architecture from the "CPU Architecture" field.
          * The list is well-known, unlike the the output of
          * the 'Processor' field which can vary greatly.
          *
          * See the definition of the 'proc_arch' array in
          * $KERNEL/arch/arm/kernel/setup.c and the 'c_show' function in
          * same file.
          */
         char* cpuArch = extract_cpuinfo_field(cpuinfo, cpuinfo_len, "CPU architecture");
 
         if (cpuArch != NULL) {
             char*  end;
             long   archNumber;
             int    hasARMv7 = 0;
 
             D("found cpuArch = '%s'\n", cpuArch);
 
             /* read the initial decimal number, ignore the rest */
             archNumber = strtol(cpuArch, &end, 10);
 
             /* Note that ARMv8 is upwards compatible with ARMv7. */
             if (end > cpuArch && archNumber >= 7) {
                 hasARMv7 = 1;
             }
 
             /* Unfortunately, it seems that certain ARMv6-based CPUs
              * report an incorrect architecture number of 7!
              *
              * See http://code.google.com/p/android/issues/detail?id=10812
              *
              * We try to correct this by looking at the 'elf_format'
              * field reported by the 'Processor' field, which is of the
              * form of "(v7l)" for an ARMv7-based CPU, and "(v6l)" for
              * an ARMv6-one.
              */
             if (hasARMv7) {
                 char* cpuProc = extract_cpuinfo_field(cpuinfo, cpuinfo_len,
                                                       "Processor");
                 if (cpuProc != NULL) {
                     D("found cpuProc = '%s'\n", cpuProc);
                     if (has_list_item(cpuProc, "(v6l)")) {
                         D("CPU processor and architecture mismatch!!\n");
                         hasARMv7 = 0;
                     }
                     free(cpuProc);
                 }
             }
 
             if (hasARMv7) {
                 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_ARMv7;
             }
 
             /* The LDREX / STREX instructions are available from ARMv6 */
             if (archNumber >= 6) {
                 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_LDREX_STREX;
             }
 
             free(cpuArch);
         }
 
         /* Extract the list of CPU features from ELF hwcaps */
         uint32_t hwcaps = 0;
         hwcaps = get_elf_hwcap_from_getauxval();
         if (!hwcaps) {
             D("Parsing /proc/self/auxv to extract ELF hwcaps!\n");
             hwcaps = get_elf_hwcap_from_proc_self_auxv();
         }
         if (!hwcaps) {
             // Parsing /proc/self/auxv will fail from regular application
             // processes on some Android platform versions, when this happens
             // parse proc/cpuinfo instead.
             D("Parsing /proc/cpuinfo to extract ELF hwcaps!\n");
             hwcaps = get_elf_hwcap_from_proc_cpuinfo(cpuinfo, cpuinfo_len);
         }
 
         if (hwcaps != 0) {
             int has_vfp = (hwcaps & HWCAP_VFP);
             int has_vfpv3 = (hwcaps & HWCAP_VFPv3);
             int has_vfpv3d16 = (hwcaps & HWCAP_VFPv3D16);
             int has_vfpv4 = (hwcaps & HWCAP_VFPv4);
             int has_neon = (hwcaps & HWCAP_NEON);
             int has_idiva = (hwcaps & HWCAP_IDIVA);
             int has_idivt = (hwcaps & HWCAP_IDIVT);
             int has_iwmmxt = (hwcaps & HWCAP_IWMMXT);
 
             // The kernel does a poor job at ensuring consistency when
             // describing CPU features. So lots of guessing is needed.
 
             // 'vfpv4' implies VFPv3|VFP_FMA|FP16
             if (has_vfpv4)
                 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_VFPv3    |
                                  ANDROID_CPU_ARM_FEATURE_VFP_FP16 |
                                  ANDROID_CPU_ARM_FEATURE_VFP_FMA;
 
             // 'vfpv3' or 'vfpv3d16' imply VFPv3. Note that unlike GCC,
             // a value of 'vfpv3' doesn't necessarily mean that the D32
             // feature is present, so be conservative. All CPUs in the
             // field that support D32 also support NEON, so this should
             // not be a problem in practice.
             if (has_vfpv3 || has_vfpv3d16)
                 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_VFPv3;
 
             // 'vfp' is super ambiguous. Depending on the kernel, it can
             // either mean VFPv2 or VFPv3. Make it depend on ARMv7.
             if (has_vfp) {
               if (g_cpuFeatures & ANDROID_CPU_ARM_FEATURE_ARMv7)
                   g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_VFPv3;
               else
                   g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_VFPv2;
             }
 
             // Neon implies VFPv3|D32, and if vfpv4 is detected, NEON_FMA
             if (has_neon) {
                 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_VFPv3 |
                                  ANDROID_CPU_ARM_FEATURE_NEON |
                                  ANDROID_CPU_ARM_FEATURE_VFP_D32;
               if (has_vfpv4)
                   g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_NEON_FMA;
             }
 
             // VFPv3 implies VFPv2 and ARMv7
             if (g_cpuFeatures & ANDROID_CPU_ARM_FEATURE_VFPv3)
                 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_VFPv2 |
                                  ANDROID_CPU_ARM_FEATURE_ARMv7;
 
             if (has_idiva)
                 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_IDIV_ARM;
             if (has_idivt)
                 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_IDIV_THUMB2;
 
             if (has_iwmmxt)
                 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_iWMMXt;
         }
 
         /* Extract the cpuid value from various fields */
         // The CPUID value is broken up in several entries in /proc/cpuinfo.
         // This table is used to rebuild it from the entries.
         static const struct CpuIdEntry {
             const char* field;
             char        format;
             char        bit_lshift;
             char        bit_length;
         } cpu_id_entries[] = {
             { "CPU implementer", 'x', 24, 8 },
             { "CPU variant", 'x', 20, 4 },
             { "CPU part", 'x', 4, 12 },
             { "CPU revision", 'd', 0, 4 },
         };
         size_t i;
         D("Parsing /proc/cpuinfo to recover CPUID\n");
         for (i = 0;
              i < sizeof(cpu_id_entries)/sizeof(cpu_id_entries[0]);
              ++i) {
             const struct CpuIdEntry* entry = &cpu_id_entries[i];
             char* value = extract_cpuinfo_field(cpuinfo,
                                                 cpuinfo_len,
                                                 entry->field);
             if (value == NULL)
                 continue;
 
             D("field=%s value='%s'\n", entry->field, value);
             char* value_end = value + strlen(value);
             int val = 0;
             const char* start = value;
             const char* p;
             if (value[0] == '0' && (value[1] == 'x' || value[1] == 'X')) {
               start += 2;
               p = parse_hexadecimal(start, value_end, &val);
             } else if (entry->format == 'x')
               p = parse_hexadecimal(value, value_end, &val);
             else
               p = parse_decimal(value, value_end, &val);
 
             if (p > (const char*)start) {
               val &= ((1 << entry->bit_length)-1);
               val <<= entry->bit_lshift;
               g_cpuIdArm |= (uint32_t) val;
             }
 
             free(value);
         }
 
         // Handle kernel configuration bugs that prevent the correct
         // reporting of CPU features.
         static const struct CpuFix {
             uint32_t  cpuid;
             uint64_t  or_flags;
         } cpu_fixes[] = {
             /* The Nexus 4 (Qualcomm Krait) kernel configuration
              * forgets to report IDIV support. */
             { 0x510006f2, ANDROID_CPU_ARM_FEATURE_IDIV_ARM |
                           ANDROID_CPU_ARM_FEATURE_IDIV_THUMB2 },
             { 0x510006f3, ANDROID_CPU_ARM_FEATURE_IDIV_ARM |
                           ANDROID_CPU_ARM_FEATURE_IDIV_THUMB2 },
         };
         size_t n;
         for (n = 0; n < sizeof(cpu_fixes)/sizeof(cpu_fixes[0]); ++n) {
             const struct CpuFix* entry = &cpu_fixes[n];
 
             if (g_cpuIdArm == entry->cpuid)
                 g_cpuFeatures |= entry->or_flags;
         }
 
         // Special case: The emulator-specific Android 4.2 kernel fails
         // to report support for the 32-bit ARM IDIV instruction.
         // Technically, this is a feature of the virtual CPU implemented
         // by the emulator. Note that it could also support Thumb IDIV
         // in the future, and this will have to be slightly updated.
         char* hardware = extract_cpuinfo_field(cpuinfo,
                                                cpuinfo_len,
                                                "Hardware");
         if (hardware) {
             if (!strcmp(hardware, "Goldfish") &&
                 g_cpuIdArm == 0x4100c080 &&
                 (g_cpuFamily & ANDROID_CPU_ARM_FEATURE_ARMv7) != 0) {
                 g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_IDIV_ARM;
             }
             free(hardware);
         }
     }
 #endif /* __arm__ */
 
 #ifdef __i386__
     int regs[4];
 
 /* According to http://en.wikipedia.org/wiki/CPUID */
 #define VENDOR_INTEL_b  0x756e6547
 #define VENDOR_INTEL_c  0x6c65746e
 #define VENDOR_INTEL_d  0x49656e69
 
     x86_cpuid(0, regs);
     int vendorIsIntel = (regs[1] == VENDOR_INTEL_b &&
                          regs[2] == VENDOR_INTEL_c &&
                          regs[3] == VENDOR_INTEL_d);
 
     x86_cpuid(1, regs);
     if ((regs[2] & (1 << 9)) != 0) {
         g_cpuFeatures |= ANDROID_CPU_X86_FEATURE_SSSE3;
     }
     if ((regs[2] & (1 << 23)) != 0) {
         g_cpuFeatures |= ANDROID_CPU_X86_FEATURE_POPCNT;
     }
     if (vendorIsIntel && (regs[2] & (1 << 22)) != 0) {
         g_cpuFeatures |= ANDROID_CPU_X86_FEATURE_MOVBE;
     }
 #endif
 
     free(cpuinfo);
 }

static void android_cpuInitDummy ( void )

static

Definition at line 942 of file cpu-features.c.

 {
     g_inited = 1;
 }

static void android_cpuInitFamily ( void )

static

Definition at line 606 of file cpu-features.c.

 {
 #if defined(__arm__)
     g_cpuFamily = ANDROID_CPU_FAMILY_ARM;
 #elif defined(__i386__)
     g_cpuFamily = ANDROID_CPU_FAMILY_X86;
 #elif defined(__mips64)
 /* Needs to be before __mips__ since the compiler defines both */
     g_cpuFamily = ANDROID_CPU_FAMILY_MIPS64;
 #elif defined(__mips__)
     g_cpuFamily = ANDROID_CPU_FAMILY_MIPS;
 #elif defined(__aarch64__)
     g_cpuFamily = ANDROID_CPU_FAMILY_ARM64;
 #elif defined(__x86_64__)
     g_cpuFamily = ANDROID_CPU_FAMILY_X86_64;
 #else
     g_cpuFamily = ANDROID_CPU_FAMILY_UNKNOWN;
 #endif
 }

int android_getCpuCount ( void )

Definition at line 935 of file cpu-features.c.

 {
     pthread_once(&g_once, android_cpuInit);
     return g_cpuCount;
 }

AndroidCpuFamily android_getCpuFamily ( void )

Definition at line 919 of file cpu-features.c.

 {
     pthread_once(&g_once, android_cpuInit);
     return g_cpuFamily;
 }

uint64_t android_getCpuFeatures ( void )

Definition at line 927 of file cpu-features.c.

 {
     pthread_once(&g_once, android_cpuInit);
     return g_cpuFeatures;
 }

uint32_t android_getCpuIdArm ( void )

Definition at line 964 of file cpu-features.c.

 {
     pthread_once(&g_once, android_cpuInit);
     return g_cpuIdArm;
 }

int android_setCpu	(	int	cpu_count,
		uint64_t	cpu_features
	)

Definition at line 948 of file cpu-features.c.

 {
     /* Fail if the library was already initialized. */
     if (g_inited)
         return 0;
 
     android_cpuInitFamily();
     g_cpuCount = (cpu_count <= 0 ? 1 : cpu_count);
     g_cpuFeatures = cpu_features;
     pthread_once(&g_once, android_cpuInitDummy);
 
     return 1;
 }

int android_setCpuArm	(	int	cpu_count,
		uint64_t	cpu_features,
		uint32_t	cpu_id
	)

Definition at line 971 of file cpu-features.c.

 {
     if (!android_setCpu(cpu_count, cpu_features))
         return 0;
 
     g_cpuIdArm = cpu_id;
     return 1;
 }

static __inline__ void cpulist_and	(	CpuList *	list1,
		CpuList *	list2
	)

static

Definition at line 337 of file cpu-features.c.

                                             {
     list1->mask &= list2->mask;
 }

static __inline__ int cpulist_count ( CpuList * list )

static

Definition at line 349 of file cpu-features.c.

                              {
     return __builtin_popcount(list->mask);
 }

static __inline__ void cpulist_init ( CpuList * list )

static

Definition at line 332 of file cpu-features.c.

                             {
     list->mask = 0;
 }

static void cpulist_parse	(	CpuList *	list,
		const char *	line,
		int	line_len
	)

static

Definition at line 364 of file cpu-features.c.

 {
     const char* p = line;
     const char* end = p + line_len;
     const char* q;
 
     /* NOTE: the input line coming from sysfs typically contains a
      * trailing newline, so take care of it in the code below
      */
     while (p < end && *p != '\n')
     {
         int val, start_value, end_value;
 
         /* Find the end of current item, and put it into 'q' */
         q = (const char *) memchr(p, ',', end-p);
         if (q == NULL) {
             q = end;
         }
 
         /* Get first value */
         p = parse_decimal(p, q, &start_value);
         if (p == NULL)
             goto BAD_FORMAT;
 
         end_value = start_value;
 
         /* If we're not at the end of the item, expect a dash and
          * and integer; extract end value.
          */
         if (p < q && *p == '-') {
             p = parse_decimal(p+1, q, &end_value);
             if (p == NULL)
                 goto BAD_FORMAT;
         }
 
         /* Set bits CPU list bits */
         for (val = start_value; val <= end_value; val++) {
             cpulist_set(list, val);
         }
 
         /* Jump to next item */
         p = q;
         if (p < end)
             p++;
     }
 
 BAD_FORMAT:
     ;
 }

static void cpulist_read_from	(	CpuList *	list,
		const char *	filename
	)

static

Definition at line 416 of file cpu-features.c.

 {
     char   file[64];
     int    filelen;
 
     cpulist_init(list);
 
     filelen = read_file(filename, file, sizeof file);
     if (filelen < 0) {
         D("Could not read %s: %s\n", filename, strerror(errno));
         return;
     }
 
     cpulist_parse(list, file, filelen);
 }

static __inline__ void cpulist_set	(	CpuList *	list,
		int	index
	)

static

Definition at line 342 of file cpu-features.c.

                                       {
     if ((unsigned)index < 32) {
         list->mask |= (uint32_t)(1U << index);
     }
 }

static char* extract_cpuinfo_field	(	const char *	buffer,
		int	buflen,
		const char *	field
	)

static

Definition at line 193 of file cpu-features.c.

 {
     int  fieldlen = strlen(field);
     const char* bufend = buffer + buflen;
     char* result = NULL;
     int len, ignore;
     const char *p, *q;
 
     /* Look for first field occurence, and ensures it starts the line. */
     p = buffer;
     for (;;) {
         p = (const char *) memmem(p, bufend-p, field, fieldlen);
         if (p == NULL)
             goto EXIT;
 
         if (p == buffer || p[-1] == '\n')
             break;
 
         p += fieldlen;
     }
 
     /* Skip to the first column followed by a space */
     p += fieldlen;
     p  = (const char *) memchr(p, ':', bufend-p);
     if (p == NULL || p[1] != ' ')
         goto EXIT;
 
     /* Find the end of the line */
     p += 2;
     q = (const char *) memchr(p, '\n', bufend-p);
     if (q == NULL)
         q = bufend;
 
     /* Copy the line into a heap-allocated buffer */
     len = q-p;
     result = (char *) malloc(len+1);
     if (result == NULL)
         goto EXIT;
 
     memcpy(result, p, len);
     result[len] = '\0';
 
 EXIT:
     return result;
 }

static int get_cpu_count ( void )

static

Definition at line 589 of file cpu-features.c.

 {
     CpuList cpus_present[1];
     CpuList cpus_possible[1];
 
     cpulist_read_from(cpus_present, "/sys/devices/system/cpu/present");
     cpulist_read_from(cpus_possible, "/sys/devices/system/cpu/possible");
 
     /* Compute the intersection of both sets to get the actual number of
      * CPU cores that can be used on this device by the kernel.
      */
     cpulist_and(cpus_present, cpus_possible);
 
     return cpulist_count(cpus_present);
 }

static uint32_t get_elf_hwcap_from_getauxval ( void )

static

Definition at line 472 of file cpu-features.c.

                                    {
     typedef unsigned long getauxval_func_t(unsigned long);
 
     dlerror();
     void* libc_handle = dlopen("libc.so", RTLD_NOW);
     if (!libc_handle) {
         D("Could not dlopen() C library: %s\n", dlerror());
         return 0;
     }
 
     uint32_t ret = 0;
     getauxval_func_t* func = (getauxval_func_t*)
             dlsym(libc_handle, "getauxval");
     if (!func) {
         D("Could not find getauxval() in C library\n");
     } else {
         // Note: getauxval() returns 0 on failure. Doesn't touch errno.
         ret = (uint32_t)(*func)(AT_HWCAP);
     }
     dlclose(libc_handle);
     return ret;
 }

static uint32_t get_elf_hwcap_from_proc_cpuinfo	(	const char *	cpuinfo,
		int	cpuinfo_len
	)

static

Definition at line 535 of file cpu-features.c.

                                                                       {
     uint32_t hwcaps = 0;
     long architecture = 0;
     char* cpuArch = extract_cpuinfo_field(cpuinfo, cpuinfo_len, "CPU architecture");
     if (cpuArch) {
         architecture = strtol(cpuArch, NULL, 10);
         free(cpuArch);
 
         if (architecture >= 8L) {
             // This is a 32-bit ARM binary running on a 64-bit ARM64 kernel.
             // The 'Features' line only lists the optional features that the
             // device's CPU supports, compared to its reference architecture
             // which are of no use for this process.
             D("Faking 32-bit ARM HWCaps on ARMv%ld CPU\n", architecture);
             return HWCAP_SET_FOR_ARMV8;
         }
     }
 
     char* cpuFeatures = extract_cpuinfo_field(cpuinfo, cpuinfo_len, "Features");
     if (cpuFeatures != NULL) {
         D("Found cpuFeatures = '%s'\n", cpuFeatures);
 
         if (has_list_item(cpuFeatures, "vfp"))
             hwcaps |= HWCAP_VFP;
         if (has_list_item(cpuFeatures, "vfpv3"))
             hwcaps |= HWCAP_VFPv3;
         if (has_list_item(cpuFeatures, "vfpv3d16"))
             hwcaps |= HWCAP_VFPv3D16;
         if (has_list_item(cpuFeatures, "vfpv4"))
             hwcaps |= HWCAP_VFPv4;
         if (has_list_item(cpuFeatures, "neon"))
             hwcaps |= HWCAP_NEON;
         if (has_list_item(cpuFeatures, "idiva"))
             hwcaps |= HWCAP_IDIVA;
         if (has_list_item(cpuFeatures, "idivt"))
             hwcaps |= HWCAP_IDIVT;
         if (has_list_item(cpuFeatures, "idiv"))
             hwcaps |= HWCAP_IDIVA | HWCAP_IDIVT;
         if (has_list_item(cpuFeatures, "iwmmxt"))
             hwcaps |= HWCAP_IWMMXT;
 
         free(cpuFeatures);
     }
     return hwcaps;
 }

static uint32_t get_elf_hwcap_from_proc_self_auxv ( void )

static

Definition at line 500 of file cpu-features.c.

                                         {
     const char filepath[] = "/proc/self/auxv";
     int fd = TEMP_FAILURE_RETRY(open(filepath, O_RDONLY));
     if (fd < 0) {
         D("Could not open %s: %s\n", filepath, strerror(errno));
         return 0;
     }
 
     struct { uint32_t tag; uint32_t value; } entry;
 
     uint32_t result = 0;
     for (;;) {
         int ret = TEMP_FAILURE_RETRY(read(fd, (char*)&entry, sizeof entry));
         if (ret < 0) {
             D("Error while reading %s: %s\n", filepath, strerror(errno));
             break;
         }
         // Detect end of list.
         if (ret == 0 || (entry.tag == 0 && entry.value == 0))
           break;
         if (entry.tag == AT_HWCAP) {
           result = entry.value;
           break;
         }
     }
     close(fd);
     return result;
 }

static int get_file_size ( const char * pathname )

static

Definition at line 124 of file cpu-features.c.

 {
     int fd, ret, result = 0;
     char buffer[256];
 
     fd = open(pathname, O_RDONLY);
     if (fd < 0) {
         D("Can't open %s: %s\n", pathname, strerror(errno));
         return -1;
     }
 
     for (;;) {
         int ret = read(fd, buffer, sizeof buffer);
         if (ret < 0) {
             if (errno == EINTR)
                 continue;
             D("Error while reading %s: %s\n", pathname, strerror(errno));
             break;
         }
         if (ret == 0)
             break;
 
         result += ret;
     }
     close(fd);
     return result;
 }

static int has_list_item	(	const char *	list,
		const char *	item
	)

static

Definition at line 243 of file cpu-features.c.

 {
     const char*  p = list;
     int itemlen = strlen(item);
 
     if (list == NULL)
         return 0;
 
     while (*p) {
         const char*  q;
 
         /* skip spaces */
         while (*p == ' ' || *p == '\t')
             p++;
 
         /* find end of current list item */
         q = p;
         while (*q && *q != ' ' && *q != '\t')
             q++;
 
         if (itemlen == q-p && !memcmp(p, item, itemlen))
             return 1;
 
         /* skip to next item */
         p = q;
     }
     return 0;
 }

static const char* parse_decimal	(	const char *	input,
		const char *	limit,
		int *	result
	)

static

Definition at line 310 of file cpu-features.c.

 {
     return parse_number(input, limit, 10, result);
 }

static const char* parse_hexadecimal	(	const char *	input,
		const char *	limit,
		int *	result
	)

static

Definition at line 316 of file cpu-features.c.

 {
     return parse_number(input, limit, 16, result);
 }

static const char* parse_number	(	const char *	input,
		const char *	limit,
		int	base,
		int *	result
	)

static

Definition at line 283 of file cpu-features.c.

 {
     const char* p = input;
     int val = 0;
     while (p < limit) {
         int d = (*p - '0');
         if ((unsigned)d >= 10U) {
             d = (*p - 'a');
             if ((unsigned)d >= 6U)
               d = (*p - 'A');
             if ((unsigned)d >= 6U)
               break;
             d += 10;
         }
         if (d >= base)
           break;
         val = val*base + d;
         p++;
     }
     if (p == input)
         return NULL;
 
     *result = val;
     return p;
 }

static int read_file	(	const char *	pathname,
		char *	buffer,
		size_t	buffsize
	)

static

Definition at line 158 of file cpu-features.c.

 {
     int  fd, count;
 
     fd = open(pathname, O_RDONLY);
     if (fd < 0) {
         D("Could not open %s: %s\n", pathname, strerror(errno));
         return -1;
     }
     count = 0;
     while (count < (int)buffsize) {
         int ret = read(fd, buffer + count, buffsize - count);
         if (ret < 0) {
             if (errno == EINTR)
                 continue;
             D("Error while reading from %s: %s\n", pathname, strerror(errno));
             if (count == 0)
                 count = -1;
             break;
         }
         if (ret == 0)
             break;
         count += ret;
     }
     close(fd);
     return count;
 }

static __inline__ void x86_cpuid	(	int	func,
		int	values[4]
	)

static

Definition at line 99 of file cpu-features.c.

 {
     int a, b, c, d;
     /* We need to preserve ebx since we're compiling PIC code */
     /* this means we can't use "=b" for the second output register */
     __asm__ __volatile__ ( \
       "push %%ebx\n"
       "cpuid\n" \
       "mov %%ebx, %1\n"
       "pop %%ebx\n"
       : "=a" (a), "=r" (b), "=c" (c), "=d" (d) \
       : "a" (func) \
     );
     values[0] = a;
     values[1] = b;
     values[2] = c;
     values[3] = d;
 }

Variable Documentation

const int android_cpufeatures_debug = 0

static

Definition at line 89 of file cpu-features.c.

int g_cpuCount

static

Definition at line 83 of file cpu-features.c.

AndroidCpuFamily g_cpuFamily

static

Definition at line 81 of file cpu-features.c.

uint64_t g_cpuFeatures

static

Definition at line 82 of file cpu-features.c.

uint32_t g_cpuIdArm

static

Definition at line 86 of file cpu-features.c.

int g_inited

static

Definition at line 80 of file cpu-features.c.

pthread_once_t g_once

static

Definition at line 79 of file cpu-features.c.

Data Structures

Functions

Variables

Data Structure Documentation

Function Documentation

Variable Documentation