/*

 * Copyright (C) 2010 The Android Open Source Project

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *  * Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 *  * Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in

 *    the documentation and/or other materials provided with the

 *    distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS

 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT

 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 */

/* ChangeLog for this library:

 *

 * NDK r10e?: Add MIPS MSA feature.

 *

 * NDK r10: Support for 64-bit CPUs (Intel, ARM & MIPS).

 *

 * NDK r8d: Add android_setCpu().

 *

 * NDK r8c: Add new ARM CPU features: VFPv2, VFP_D32, VFP_FP16,

 *          VFP_FMA, NEON_FMA, IDIV_ARM, IDIV_THUMB2 and iWMMXt.

 *

 *          Rewrite the code to parse /proc/self/auxv instead of

 *          the "Features" field in /proc/cpuinfo.

 *

 *          Dynamically allocate the buffer that hold the content

 *          of /proc/cpuinfo to deal with newer hardware.

 *

 * NDK r7c: Fix CPU count computation. The old method only reported the

 *           number of _active_ CPUs when the library was initialized,

 *           which could be less than the real total.

 *

 * NDK r5: Handle buggy kernels which report a CPU Architecture number of 7

 *         for an ARMv6 CPU (see below).

 *

 *         Handle kernels that only report 'neon', and not 'vfpv3'

 *         (VFPv3 is mandated by the ARM architecture is Neon is implemented)

 *

 *         Handle kernels that only report 'vfpv3d16', and not 'vfpv3'

 *

 *         Fix x86 compilation. Report ANDROID_CPU_FAMILY_X86 in

 *         android_getCpuFamily().

 *

 * NDK r4: Initial release

 */

#include "cpu-features.h"

#include <dlfcn.h>

#include <errno.h>

#include <fcntl.h>

#include <pthread.h>

#include <stdio.h>

#include <stdlib.h>

#include <sys/system_properties.h>

#include <unistd.h>

#include <winpr/wtypes.h>

static pthread_once_t g_once;

static int g_inited;

static AndroidCpuFamily g_cpuFamily;

static uint64_t g_cpuFeatures;

static int g_cpuCount;

#ifdef __arm__

static uint32_t g_cpuIdArm;

#endif

static const int android_cpufeatures_debug = 0;

#define D(...)                         \

	do                                 \

	{                                  \

		if (android_cpufeatures_debug) \

		{                              \

			printf(__VA_ARGS__);       \

			fflush(stdout);            \

		}                              \

	} while (0)

#ifdef __i386__

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

{

	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;

}

#elif defined(__x86_64__)

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

{

	int64_t 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 %%rbx\n"

	                     "cpuid\n"

	                     "mov %%rbx, %1\n"

	                     "pop %%rbx\n"

	                     : "=a"(a), "=r"(b), "=c"(c), "=d"(d)

	                     : "a"(func));

	values[0] = a;

	values[1] = b;

	values[2] = c;

	values[3] = d;

}

#endif

/* Get the size of a file by reading it until the end. This is needed

 * because files under /proc do not always return a valid size when

 * using fseek(0, SEEK_END) + ftell(). Nor can they be mmap()-ed.

 */

static int get_file_size(const char* pathname)

{

	int fd, 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;

}

/* Read the content of /proc/cpuinfo into a user-provided buffer.

 * Return the length of the data, or -1 on error. Does *not*

 * zero-terminate the content. Will not read more

 * than 'buffsize' bytes.

 */

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

{

	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;

}

#ifdef __arm__

/* Extract the content of a the first occurence of a given field in

 * the content of /proc/cpuinfo and return it as a heap-allocated

 * string that must be freed by the caller.

 *

 * Return NULL if not found

 */

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

{

	int fieldlen = strlen(field);

	const char* bufend = buffer + buflen;

	char* result = NULL;

	int len;

	const char *p, *q;

	/* Look for first field occurence, and ensures it starts the line. */

	p = buffer;

	for (;;)

	{

		p = 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 = memchr(p, ':', bufend - p);

	if (p == NULL || p[1] != ' ')

		goto EXIT;

	/* Find the end of the line */

	p += 2;

	q = memchr(p, '\n', bufend - p);

	if (q == NULL)

		q = bufend;

	/* Copy the line into a heap-allocated buffer */

	len = q - p;

	result = malloc(len + 1);

	if (result == NULL)

		goto EXIT;

	memcpy(result, p, len);

	result[len] = '\0';

EXIT:

	return result;

}

/* Checks that a space-separated list of items contains one given 'item'.

 * Returns 1 if found, 0 otherwise.

 */

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

{

	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;

}

#endif /* __arm__ */

/* Parse a number starting from 'input', but not going further

 * than 'limit'. Return the value into '*result'.

 *

 * NOTE: Does not skip over leading spaces, or deal with sign characters.

 * NOTE: Ignores overflows.

 *

 * The function returns NULL in case of error (bad format), or the new

 * position after the decimal number in case of success (which will always

 * be <= 'limit').

 */

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

{

	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 const char* parse_decimal(const char* input, const char* limit, int* result)

{

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

}

#ifdef __arm__

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

{

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

}

#endif /* __arm__ */

/* This small data type is used to represent a CPU list / mask, as read

 * from sysfs on Linux. See http://www.kernel.org/doc/Documentation/cputopology.txt

 *

 * For now, we don't expect more than 32 cores on mobile devices, so keep

 * everything simple.

 */

typedef struct

{

	uint32_t mask;

} CpuList;

static __inline__ void cpulist_init(CpuList* list)

{

	list->mask = 0;

}

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

{

	list1->mask &= list2->mask;

}

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

{

	if ((unsigned)index < 32)

	{

		list->mask |= (uint32_t)(1U << index);

	}

}

static __inline__ int cpulist_count(CpuList* list)

{

	return __builtin_popcount(list->mask);

}

/* Parse a textual list of cpus and store the result inside a CpuList object.

 * Input format is the following:

 * - comma-separated list of items (no spaces)

 * - each item is either a single decimal number (cpu index), or a range made

 *   of two numbers separated by a single dash (-). Ranges are inclusive.

 *

 * Examples:   0

 *             2,4-127,128-143

 *             0-1

 */

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

{

	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 = 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:;

}

/* Read a CPU list from one sysfs file */

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

{

	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);

}

#if defined(__aarch64__)

// see <uapi/asm/hwcap.h> kernel header

#define HWCAP_FP (1 << 0)

#define HWCAP_ASIMD (1 << 1)

#define HWCAP_AES (1 << 3)

#define HWCAP_PMULL (1 << 4)

#define HWCAP_SHA1 (1 << 5)

#define HWCAP_SHA2 (1 << 6)

#define HWCAP_CRC32 (1 << 7)

#endif

#if defined(__arm__)

// See <asm/hwcap.h> kernel header.

#define HWCAP_VFP (1 << 6)

#define HWCAP_IWMMXT (1 << 9)

#define HWCAP_NEON (1 << 12)

#define HWCAP_VFPv3 (1 << 13)

#define HWCAP_VFPv3D16 (1 << 14)

#define HWCAP_VFPv4 (1 << 16)

#define HWCAP_IDIVA (1 << 17)

#define HWCAP_IDIVT (1 << 18)

// see <uapi/asm/hwcap.h> kernel header

#define HWCAP2_AES (1 << 0)

#define HWCAP2_PMULL (1 << 1)

#define HWCAP2_SHA1 (1 << 2)

#define HWCAP2_SHA2 (1 << 3)

#define HWCAP2_CRC32 (1 << 4)

// This is the list of 32-bit ARMv7 optional features that are _always_

// supported by ARMv8 CPUs, as mandated by the ARM Architecture Reference

// Manual.

#define HWCAP_SET_FOR_ARMV8 \

	(HWCAP_VFP | HWCAP_NEON | HWCAP_VFPv3 | HWCAP_VFPv4 | HWCAP_IDIVA | HWCAP_IDIVT)

#endif

#if defined(__mips__)

// see <uapi/asm/hwcap.h> kernel header

#define HWCAP_MIPS_R6 (1 << 0)

#define HWCAP_MIPS_MSA (1 << 1)

#endif

#if defined(__arm__) || defined(__aarch64__) || defined(__mips__)

#define AT_HWCAP 16

#define AT_HWCAP2 26

// Probe the system's C library for a 'getauxval' function and call it if

// it exits, or return 0 for failure. This function is available since API

// level 20.

//

// This code does *NOT* check for '__ANDROID_API__ >= 20' to support the

// edge case where some NDK developers use headers for a platform that is

// newer than the one really targetted by their application.

// This is typically done to use newer native APIs only when running on more

// recent Android versions, and requires careful symbol management.

//

// Note that getauxval() can't really be re-implemented here, because

// its implementation does not parse /proc/self/auxv. Instead it depends

// on values  that are passed by the kernel at process-init time to the

// C runtime initialization layer.

static uint32_t get_elf_hwcap_from_getauxval(int hwcap_type)

{

	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)(hwcap_type);

	}

	dlclose(libc_handle);

	return ret;

}

#endif

#if defined(__arm__)

// Parse /proc/self/auxv to extract the ELF HW capabilities bitmap for the

// current CPU. Note that this file is not accessible from regular

// application processes on some Android platform releases.

// On success, return new ELF hwcaps, or 0 on failure.

static uint32_t get_elf_hwcap_from_proc_self_auxv(void)

{

	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;

}

/* Compute the ELF HWCAP flags from the content of /proc/cpuinfo.

 * This works by parsing the 'Features' line, which lists which optional

 * features the device's CPU supports, on top of its reference

 * architecture.

 */

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

{

	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;

}

#endif /* __arm__ */

/* Return the number of cpus present on a given device.

 *

 * To handle all weird kernel configurations, we need to compute the

 * intersection of the 'present' and 'possible' CPU lists and count

 * the result.

 */

static int get_cpu_count(void)

{

	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 void android_cpuInitFamily(void)

{

#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

}

static void android_cpuInit(void)

{

	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 = 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(AT_HWCAP);

		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;