android_development/ndk/sources/cpufeatures/cpu-features.c

/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
#include <sys/system_properties.h>
#include <machine/cpu-features.h>
#include <pthread.h>
#include "cpu-features.h"
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>

static  pthread_once_t     g_once;
static  AndroidCpuFamily   g_cpuFamily;
static  uint64_t           g_cpuFeatures;

static const int  android_cpufeatures_debug = 0;

#define  D(...) \
    do { \
        if (android_cpufeatures_debug) { \
            printf(__VA_ARGS__); fflush(stdout); \
        } \
    } while (0)

/* 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, len;

    fd = open(pathname, O_RDONLY);
    if (fd < 0)
        return -1;

    do {
        len = read(fd, buffer, buffsize);
    } while (len < 0 && errno == EINTR);

    close(fd);

    return len;
}

/* 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(char* buffer, int buflen, const char* field)
{
    int  fieldlen = strlen(field);
    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;
    bufend = buffer + buflen;
    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;
}


static void
android_cpuInit(void)
{
    g_cpuFamily   = ANDROID_CPU_FAMILY_UNKNOWN;
    g_cpuFeatures = 0;

#ifdef __ARM_ARCH__
    {
        char   cpuinfo[4096];
        int    cpuinfo_len = read_file("/proc/cpuinfo", cpuinfo, sizeof cpuinfo);
        char*  features = NULL;
        char*  architecture = NULL;

        g_cpuFamily = ANDROID_CPU_FAMILY_ARM;

        D("cpuinfo_len is (%d):\n%.*s\n", cpuinfo_len, cpuinfo_len, cpuinfo);

        if (cpuinfo_len < 0)  /* should not happen */ {
            return;
        }

        /* Extract architecture from the "CPU Architecture" field,
         * Which can be something like 5JTE, 7, or something else.
         * We cannot rely on the 'Processor' field here.
         */
        {
            char* cpuArch = extract_cpuinfo_field(cpuinfo, cpuinfo_len, "CPU architecture");

            if (cpuArch != NULL) {
                char*  end;
                long   archNumber;

                D("found cpuArch = '%s'\n", cpuArch);

                /* read the initial decimal number, ignore the rest */
                archNumber = strtol(cpuArch, &end, 10);

                /* Here we assume that ARMv8 will be upwards compatible with v7
                 * in the future. Unfortunately, there is no 'Features' field to
                 * indicate that Thumb-2 is supported.
                 */
                if (end > cpuArch && archNumber >= 7) {
                    g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_ARMv7;
                }
                free(cpuArch);
            }
        }

        /* Extract the list of CPU features from 'Features' field */
        {
            char* cpuFeatures = extract_cpuinfo_field(cpuinfo, cpuinfo_len, "Features");

            if (cpuFeatures != NULL) {

                D("found cpuFeatures = '%s'\n", cpuFeatures);

                if (has_list_item(cpuFeatures, "vfpv3"))
                    g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_VFPv3;

                if (has_list_item(cpuFeatures, "neon"))
                    g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_NEON;

                free(cpuFeatures);
            }
        }
    }
#endif /* __ARM_ARCH__ */
}


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


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