crypto/cpu_arm_linux.h

// Copyright 2018 The BoringSSL Authors
//
// 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
//
//     https://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.

#ifndef OPENSSL_HEADER_CRYPTO_CPU_ARM_LINUX_H
#define OPENSSL_HEADER_CRYPTO_CPU_ARM_LINUX_H

#include <openssl/base.h>

#include <assert.h>

#include <string_view>

#include "internal.h"


BSSL_NAMESPACE_BEGIN
namespace armcap {

// The cpuinfo parser lives in a header file so it may be accessible from
// cross-platform fuzzers without adding code to those platforms normally.

#define CRYPTO_HWCAP_NEON (1 << 12)

// See /usr/include/asm/hwcap.h on an ARM installation for the source of
// these values.
// We add the prefix "CRYPTO_" to the definitions so as not to collide with
// some versions of glibc (>= 2.41) that expose them through <sys/auxv.h>.
#define CRYPTO_HWCAP2_AES (1 << 0)
#define CRYPTO_HWCAP2_PMULL (1 << 1)
#define CRYPTO_HWCAP2_SHA1 (1 << 2)
#define CRYPTO_HWCAP2_SHA2 (1 << 3)

// SplitStringView finds the first occurrence of `sep` in `in` and, if found,
// sets `*out_left` and `*out_right` to `in` split before and after `sep`, and
// returns true. If not found, it returns false.
inline bool SplitStringView(std::string_view *out_left,
                            std::string_view *out_right, std::string_view in,
                            char sep) {
  auto pos = in.find(sep);
  if (pos == std::string_view::npos) {
    return false;
  }
  *out_left = in.substr(0, pos);
  *out_right = in.substr(pos + 1);
  return true;
}

// GetDelimited reads a `sep`-delimited entry from `s`, writing it to `out` and
// updating `s` to point beyond it. It returns true on success and false if `s`
// is empty. If `s` has no copies of `sep` and is non-empty, it reads the entire
// string to `out`.
inline bool GetDelimited(std::string_view *s, std::string_view *out, char sep) {
  if (s->empty()) {
    return false;
  }
  if (!SplitStringView(out, s, *s, sep)) {
    // `s` had no instances of `sep`. Return the entire string.
    *out = *s;
    *s = std::string_view();
  }
  return true;
}

// TrimStringView removes leading and trailing whitespace from `s`.
inline std::string_view TrimStringView(std::string_view s) {
  size_t pos = s.find_first_not_of(" \t");
  if (pos == std::string_view::npos) {
    return {};
  }
  s = s.substr(pos);
  pos = s.find_last_not_of(" \t");
  assert(pos != std::string_view::npos);
  return s.substr(0, pos + 1);
}

// ExtractCpuinfoField extracts a /proc/cpuinfo field named `field` from `in`.
// If found, it returns the value. Otherwise, it returns the empty string.
inline std::string_view ExtractCpuinfoField(std::string_view in,
                                            std::string_view field) {
  // Process `in` one line at a time.
  std::string_view line;
  while (GetDelimited(&in, &line, '\n')) {
    std::string_view key, value;
    if (!SplitStringView(&key, &value, line, ':')) {
      continue;
    }
    if (TrimStringView(key) == field) {
      return TrimStringView(value);
    }
  }

  return {};
}

// HasListItem treats `list` as a space-separated list of items and returns
// whether `item` is contained in `list`.
inline bool HasListItem(std::string_view list, std::string_view item) {
  std::string_view feature;
  while (GetDelimited(&list, &feature, ' ')) {
    if (feature == item) {
      return true;
    }
  }
  return false;
}

// GetHWCAP2FromCpuinfo returns an equivalent ARM `AT_HWCAP2` value from
// `cpuinfo`.
inline unsigned long GetHWCAP2FromCpuinfo(std::string_view cpuinfo) {
  std::string_view features = ExtractCpuinfoField(cpuinfo, "Features");
  unsigned long ret = 0;
  if (HasListItem(features, "aes")) {
    ret |= CRYPTO_HWCAP2_AES;
  }
  if (HasListItem(features, "pmull")) {
    ret |= CRYPTO_HWCAP2_PMULL;
  }
  if (HasListItem(features, "sha1")) {
    ret |= CRYPTO_HWCAP2_SHA1;
  }
  if (HasListItem(features, "sha2")) {
    ret |= CRYPTO_HWCAP2_SHA2;
  }
  return ret;
}

}  // namespace armcap
BSSL_NAMESPACE_END

#endif  // OPENSSL_HEADER_CRYPTO_CPU_ARM_LINUX_H