// Copyright 2016, VIXL authors
// 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.
// * Neither the name of ARM Limited nor the names of its contributors may be
// used to endorse or promote products derived from this software without
// specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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.
#include <iostream>
#include <set>
#include <sstream>
#include <vector>
#include "test-runner.h"
#include "cpu-features.h"
#include "utils-vixl.h"
#if __cplusplus >= 201103L
#include <type_traits>
#endif
#define TEST(name) TEST_(API_##name)
#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
namespace vixl {
// Describe the result of a test. Should IsUintN() and IsIntN() return true or
// false for N and X?
template <typename T>
struct UintIntTest {
bool is_uintn;
bool is_intn;
unsigned n;
T x;
};
// Test IsUintN() and IsIntN() against various values and integral types.
TEST(IsUint_IsInt) {
UintIntTest<uint32_t> test_little_values_unsigned[] = {
{true, true, 1, UINT32_C(0x0)}, {true, false, 1, UINT32_C(0x1)},
{false, false, 1, UINT32_C(0x2)}, {false, false, 1, UINT32_C(0x3)},
{false, false, 1, UINT32_C(0x4)}, {false, false, 1, UINT32_C(0x5)},
{false, false, 1, UINT32_C(0x6)}, {false, false, 1, UINT32_C(0x7)},
{false, false, 1, UINT32_C(0x8)}, {false, false, 1, UINT32_C(0x9)},
{false, false, 1, UINT32_C(0xa)}, {false, false, 1, UINT32_C(0xb)},
{false, false, 1, UINT32_C(0xc)}, {false, false, 1, UINT32_C(0xd)},
{false, false, 1, UINT32_C(0xe)}, {false, false, 1, UINT32_C(0xf)},
{true, true, 2, UINT32_C(0x0)}, {true, true, 2, UINT32_C(0x1)},
{true, false, 2, UINT32_C(0x2)}, {true, false, 2, UINT32_C(0x3)},
{false, false, 2, UINT32_C(0x4)}, {false, false, 2, UINT32_C(0x5)},
{false, false, 2, UINT32_C(0x6)}, {false, false, 2, UINT32_C(0x7)},
{false, false, 2, UINT32_C(0x8)}, {false, false, 2, UINT32_C(0x9)},
{false, false, 2, UINT32_C(0xa)}, {false, false, 2, UINT32_C(0xb)},
{false, false, 2, UINT32_C(0xc)}, {false, false, 2, UINT32_C(0xd)},
{false, false, 2, UINT32_C(0xe)}, {false, false, 2, UINT32_C(0xf)},
};
UintIntTest<int32_t> test_little_values_signed[] = {
{true, true, 1, INT32_C(0)}, {true, false, 1, INT32_C(1)},
{false, false, 1, INT32_C(2)}, {false, false, 1, INT32_C(3)},
{false, false, 1, INT32_C(4)}, {false, false, 1, INT32_C(5)},
{false, false, 1, INT32_C(6)}, {false, false, 1, INT32_C(7)},
{false, true, 1, INT32_C(-1)}, {false, false, 1, INT32_C(-2)},
{false, false, 1, INT32_C(-3)}, {false, false, 1, INT32_C(-4)},
{false, false, 1, INT32_C(-5)}, {false, false, 1, INT32_C(-6)},
{false, false, 1, INT32_C(-7)}, {false, false, 1, INT32_C(-8)},
{true, true, 2, INT32_C(0)}, {true, true, 2, INT32_C(1)},
{true, false, 2, INT32_C(2)}, {true, false, 2, INT32_C(3)},
{false, false, 2, INT32_C(4)}, {false, false, 2, INT32_C(5)},
{false, false, 2, INT32_C(6)}, {false, false, 2, INT32_C(7)},
{false, true, 2, INT32_C(-1)}, {false, true, 2, INT32_C(-2)},
{false, false, 2, INT32_C(-3)}, {false, false, 2, INT32_C(-4)},
{false, false, 2, INT32_C(-5)}, {false, false, 2, INT32_C(-6)},
{false, false, 2, INT32_C(-7)}, {false, false, 2, INT32_C(-8)},
};
UintIntTest<uint32_t> test_u16[] = {
{true, true, 16, UINT32_C(0x0)},
{true, false, 16, UINT32_C(0xabcd)},
{true, false, 16, UINT32_C(0x8000)},
{true, false, 16, UINT32_C(0xffff)},
{false, false, 16, UINT32_C(0x10000)},
{false, false, 16, UINT32_C(0xffff0000)},
{false, false, 16, UINT32_C(0xffff8000)},
{false, false, 16, UINT32_C(0xffffffff)},
};
UintIntTest<int32_t> test_i16[] = {
{true, true, 16, INT32_C(0x0)},
{true, false, 16, INT32_C(0xabcd)},
{true, false, 16, INT32_C(0x8000)},
{true, false, 16, INT32_C(0xffff)},
{false, false, 16, INT32_C(0x10000)},
{true, true, 16, INT32_C(42)},
{false, true, 16, INT32_C(-42)},
{false, true, 16, INT32_C(-1)},
};
UintIntTest<uint64_t> test_u32[] = {
{true, true, 32, UINT64_C(0x0)},
{true, false, 32, UINT64_C(0xabcdabcd)},
{true, false, 32, UINT64_C(0x80000000)},
{true, false, 32, UINT64_C(0xffffffff)},
};
UintIntTest<int64_t> test_i32[] = {
{true, true, 32, INT64_C(0)},
{true, true, 32, INT64_C(42)},
{false, true, 32, INT64_C(-42)},
{false, true, 32, INT64_C(-1)},
{true, true, 32, INT64_C(2147483647)}, // (1 << (32 - 1)) - 1
{false, true, 32, INT64_C(-2147483648)}, // -(1 << (32 - 1))
};
UintIntTest<uint64_t> test_unsigned_higher_than_32[] = {
{false, false, 54, UINT64_C(0xabcdef9012345678)},
{true, false, 33, UINT64_C(0x100000000)},
{true, false, 62, UINT64_C(0x3fffffffffffffff)},
{true, false, 63, UINT64_C(0x7fffffffffffffff)},
};
UintIntTest<int64_t> test_signed_higher_than_32[] = {
{true, true, 54, INT64_C(9007199254740991)}, // (1 << (54 - 1)) - 1
{true, false, 54, INT64_C(9007199254740992)}, // 1 << (54 - 1)
{true, true, 33, INT64_C(4294967295)}, // (1 << (33 - 1) - 1)
{false, true, 33, INT64_C(-4294967296)}, // -(1 << (33 - 1))
};
#define TEST_LIST(M) \
M(test_little_values_unsigned) \
M(test_little_values_signed) \
M(test_u16) \
M(test_i16) \
M(test_u32) \
M(test_i32) \
M(test_unsigned_higher_than_32) \
M(test_signed_higher_than_32)
#define TEST_UINT(test_vector) \
for (unsigned i = 0; i < ARRAY_SIZE(test_vector); i++) { \
if (test_vector[i].is_uintn) { \
VIXL_CHECK(IsUintN(test_vector[i].n, test_vector[i].x)); \
} else { \
VIXL_CHECK(!IsUintN(test_vector[i].n, test_vector[i].x)); \
} \
}
#define TEST_INT(test_vector) \
for (unsigned i = 0; i < ARRAY_SIZE(test_vector); i++) { \
if (test_vector[i].is_intn) { \
VIXL_CHECK(IsIntN(test_vector[i].n, test_vector[i].x)); \
} else { \
VIXL_CHECK(!IsIntN(test_vector[i].n, test_vector[i].x)); \
} \
}
TEST_LIST(TEST_UINT)
TEST_LIST(TEST_INT)
#undef TEST_UINT
#undef TEST_INT
#undef TEST_LIST
}
TEST(CPUFeatures_iterator_api) {
// CPUFeaturesIterator does not fully satisfy the requirements of C++'s
// iterator concepts, but it should implement enough for some basic usage.
// Arbitrary feature lists.
CPUFeatures f1(CPUFeatures::kFP, CPUFeatures::kNEON);
CPUFeatures f2(CPUFeatures::kFP, CPUFeatures::kNEON, CPUFeatures::kCRC32);
CPUFeatures f3;
typedef CPUFeatures::const_iterator It;
It it0;
It it1_neon(&f1, CPUFeatures::kNEON);
It it2_neon(&f2, CPUFeatures::kNEON);
It it2_crc32(&f2, CPUFeatures::kCRC32);
It it3(&f3);
// Equality
VIXL_CHECK(it0 == it0);
VIXL_CHECK(it1_neon == it1_neon);
VIXL_CHECK(it2_neon == it2_neon);
VIXL_CHECK(it2_crc32 == it2_crc32);
VIXL_CHECK(it3 == it3);
VIXL_CHECK(!(it0 == it1_neon));
VIXL_CHECK(!(it0 == it3));
VIXL_CHECK(!(it1_neon == it2_neon));
VIXL_CHECK(!(it1_neon == it2_crc32));
VIXL_CHECK(!(it1_neon == it3));
VIXL_CHECK(!(it2_neon == it2_crc32));
VIXL_CHECK(!(it3 == it0));
VIXL_CHECK(!(it3 == it1_neon));
// Inequality
// (a == b) <-> !(a != b)
VIXL_CHECK(!(it0 != it0));
VIXL_CHECK(!(it1_neon != it1_neon));
VIXL_CHECK(!(it2_neon != it2_neon));
VIXL_CHECK(!(it2_crc32 != it2_crc32));
VIXL_CHECK(!(it3 != it3));
// !(a == b) <-> (a != b)
VIXL_CHECK(it0 != it1_neon);
VIXL_CHECK(it0 != it3);
VIXL_CHECK(it1_neon != it2_neon);
VIXL_CHECK(it1_neon != it2_crc32);
VIXL_CHECK(it1_neon != it3);
VIXL_CHECK(it2_neon != it2_crc32);
VIXL_CHECK(it3 != it0);
VIXL_CHECK(it3 != it1_neon);
// Dereferenceable
VIXL_CHECK(*it0 == CPUFeatures::kNone);
VIXL_CHECK(*it1_neon == CPUFeatures::kNEON);
VIXL_CHECK(*it2_neon == CPUFeatures::kNEON);
VIXL_CHECK(*it2_crc32 == CPUFeatures::kCRC32);
VIXL_CHECK(*it3 == CPUFeatures::kNone);
#if __cplusplus >= 201103L
VIXL_STATIC_ASSERT(std::is_copy_constructible<It>::value);
VIXL_STATIC_ASSERT(std::is_copy_assignable<It>::value);
VIXL_STATIC_ASSERT(std::is_destructible<It>::value);
#endif
// Copy constructable
It test0 = it0;
It test1 = it1_neon;
It test2(it2_neon);
VIXL_CHECK(test0 == It(NULL, CPUFeatures::kNone));
VIXL_CHECK(test1 == It(&f1, CPUFeatures::kNEON));
VIXL_CHECK(test2 == It(&f2, CPUFeatures::kNEON));
// Copy assignable
test2 = it2_crc32;
VIXL_CHECK(test2 == It(&f2, CPUFeatures::kCRC32));
// Incrementable
// - Incrementing has no effect on an empty CPUFeatures.
VIXL_CHECK(it3++ == CPUFeatures::kNone);
VIXL_CHECK(++it3 == CPUFeatures::kNone);
VIXL_CHECK(it3 == It(&f3, CPUFeatures::kNone));
// - Incrementing moves to the next feature, wrapping around (through kNone).
// This test will need to be updated if the Feature enum is reordered.
VIXL_CHECK(it2_neon++ == CPUFeatures::kNEON);
VIXL_CHECK(it2_neon++ == CPUFeatures::kCRC32);
VIXL_CHECK(it2_neon++ == CPUFeatures::kNone);
VIXL_CHECK(it2_neon++ == CPUFeatures::kFP);
VIXL_CHECK(it2_neon == It(&f2, CPUFeatures::kNEON));
VIXL_CHECK(++it2_crc32 == CPUFeatures::kNone);
VIXL_CHECK(++it2_crc32 == CPUFeatures::kFP);
VIXL_CHECK(++it2_crc32 == CPUFeatures::kNEON);
VIXL_CHECK(++it2_crc32 == CPUFeatures::kCRC32);
VIXL_CHECK(it2_crc32 == It(&f2, CPUFeatures::kCRC32));
}
TEST(CPUFeatures_iterator_loops) {
// Check that CPUFeaturesIterator can be used for some simple loops.
// Arbitrary feature lists.
CPUFeatures f1(CPUFeatures::kFP, CPUFeatures::kNEON);
CPUFeatures f2(CPUFeatures::kFP, CPUFeatures::kNEON, CPUFeatures::kCRC32);
CPUFeatures f3;
// This test will need to be updated if the Feature enum is reordered.
std::vector<CPUFeatures::Feature> f1_list;
for (CPUFeatures::const_iterator it = f1.begin(); it != f1.end(); ++it) {
f1_list.push_back(*it);
}
VIXL_CHECK(f1_list.size() == 2);
VIXL_CHECK(f1_list[0] == CPUFeatures::kFP);
VIXL_CHECK(f1_list[1] == CPUFeatures::kNEON);
std::vector<CPUFeatures::Feature> f2_list;
for (CPUFeatures::const_iterator it = f2.begin(); it != f2.end(); ++it) {
f2_list.push_back(*it);
}
VIXL_CHECK(f2_list.size() == 3);
VIXL_CHECK(f2_list[0] == CPUFeatures::kFP);
VIXL_CHECK(f2_list[1] == CPUFeatures::kNEON);
VIXL_CHECK(f2_list[2] == CPUFeatures::kCRC32);
std::vector<CPUFeatures::Feature> f3_list;
for (CPUFeatures::const_iterator it = f3.begin(); it != f3.end(); ++it) {
f3_list.push_back(*it);
}
VIXL_CHECK(f3_list.size() == 0);
#if __cplusplus >= 201103L
std::vector<CPUFeatures::Feature> f2_list_cxx11;
for (auto&& feature : f2) {
f2_list_cxx11.push_back(feature);
}
VIXL_CHECK(f2_list_cxx11.size() == 3);
VIXL_CHECK(f2_list_cxx11[0] == CPUFeatures::kFP);
VIXL_CHECK(f2_list_cxx11[1] == CPUFeatures::kNEON);
VIXL_CHECK(f2_list_cxx11[2] == CPUFeatures::kCRC32);
std::vector<CPUFeatures::Feature> f3_list_cxx11;
for (auto&& feature : f3) {
f3_list_cxx11.push_back(feature);
}
VIXL_CHECK(f3_list_cxx11.size() == 0);
#endif
}
TEST(CPUFeatures_empty) {
// A default-constructed CPUFeatures has no features enabled.
CPUFeatures f;
for (CPUFeatures::const_iterator it = f.begin(); it != f.end(); ++it) {
VIXL_ABORT();
}
}
static void CPUFeaturesFormatHelper(const char* expected,
const CPUFeatures& features) {
std::stringstream os;
os << features;
std::string os_str = os.str();
if (os_str != expected) {
std::cout << "Found: " << os_str << "\n";
std::cout << "Expected: " << expected << "\n";
VIXL_ABORT();
}
}
TEST(CPUFeatures_format) {
// Check that the debug output is complete and accurate.
// Individual features.
CPUFeaturesFormatHelper("", CPUFeatures(CPUFeatures::kNone));
CPUFeaturesFormatHelper("FP", CPUFeatures(CPUFeatures::kFP));
CPUFeaturesFormatHelper("NEON", CPUFeatures(CPUFeatures::kNEON));
CPUFeaturesFormatHelper("AES", CPUFeatures(CPUFeatures::kAES));
CPUFeaturesFormatHelper("Pmull1Q", CPUFeatures(CPUFeatures::kPmull1Q));
CPUFeaturesFormatHelper("SHA1", CPUFeatures(CPUFeatures::kSHA1));
CPUFeaturesFormatHelper("SHA2", CPUFeatures(CPUFeatures::kSHA2));
CPUFeaturesFormatHelper("CRC32", CPUFeatures(CPUFeatures::kCRC32));
// Combinations of (arbitrary) features.
// This test will need to be updated if the Feature enum is reordered.
CPUFeatures f(CPUFeatures::kFP, CPUFeatures::kNEON);
CPUFeaturesFormatHelper("FP, NEON", f);
f.Combine(CPUFeatures::kCRC32);
CPUFeaturesFormatHelper("FP, NEON, CRC32", f);
f.Combine(CPUFeatures::kFcma);
CPUFeaturesFormatHelper("FP, NEON, CRC32, Fcma", f);
f.Combine(CPUFeatures::kSHA1);
CPUFeaturesFormatHelper("FP, NEON, CRC32, SHA1, Fcma", f);
CPUFeaturesFormatHelper(
"ID register emulation, "
// Armv8.0
"FP, NEON, CRC32, "
"AES, SHA1, SHA2, Pmull1Q, "
// Armv8.1
"Atomics, LORegions, RDM, "
// Armv8.2
"DotProduct, FPHalf, NEONHalf, RAS, DCPoP, SHA3, SHA512, SM3, SM4, "
// Armv8.3
"PAuth, PAuthQARMA, PAuthGeneric, PAuthGenericQARMA, JSCVT, RCpc, Fcma",
CPUFeatures::All());
}
static void CPUFeaturesPredefinedResultCheckHelper(
const std::set<CPUFeatures::Feature>& unexpected,
const std::set<CPUFeatures::Feature>& expected) {
// Print a helpful diagnostic before checking the result.
typedef std::set<CPUFeatures::Feature>::const_iterator It;
if (!unexpected.empty()) {
std::cout << "Unexpected features:\n";
for (It it = unexpected.begin(); it != unexpected.end(); ++it) {
std::cout << " " << *it << "\n";
}
}
if (!expected.empty()) {
std::cout << "Missing features:\n";
for (It it = expected.begin(); it != expected.end(); ++it) {
std::cout << " " << *it << "\n";
}
}
VIXL_CHECK(unexpected.empty() && expected.empty());
}
TEST(CPUFeatures_predefined_legacy) {
CPUFeatures f = CPUFeatures::AArch64LegacyBaseline();
std::set<CPUFeatures::Feature> unexpected;
std::set<CPUFeatures::Feature> expected;
expected.insert(CPUFeatures::kFP);
expected.insert(CPUFeatures::kNEON);
expected.insert(CPUFeatures::kCRC32);
for (CPUFeatures::const_iterator it = f.begin(); it != f.end(); ++it) {
if (expected.erase(*it) == 0) unexpected.insert(*it);
}
CPUFeaturesPredefinedResultCheckHelper(unexpected, expected);
}
TEST(CPUFeatures_predefined_all) {
CPUFeatures f = CPUFeatures::All();
std::set<CPUFeatures::Feature> found;
for (CPUFeatures::const_iterator it = f.begin(); it != f.end(); ++it) {
found.insert(*it);
}
VIXL_CHECK(found.size() == CPUFeatures::kNumberOfFeatures);
}
// The CPUFeaturesScope constructor is templated, and needs an object which
// implements `CPUFeatures* GetCPUFeatures()`. This is normally something like
// the Assembler, but for the tests we use an architecture-independent wrapper.
class GetCPUFeaturesWrapper {
public:
explicit GetCPUFeaturesWrapper(CPUFeatures* cpu_features)
: cpu_features_(cpu_features) {}
CPUFeatures* GetCPUFeatures() const { return cpu_features_; }
private:
CPUFeatures* cpu_features_;
};
TEST(CPUFeaturesScope) {
// Test that CPUFeaturesScope properly preserves state.
CPUFeatures cpu(CPUFeatures::kCRC32, CPUFeatures::kSHA1, CPUFeatures::kAES);
GetCPUFeaturesWrapper top_level(&cpu);
const CPUFeatures original_outer = cpu;
{ // Test setting both new and existing features.
CPUFeaturesScope outer(&top_level, CPUFeatures::kSHA2, CPUFeatures::kAES);
VIXL_CHECK(outer.GetCPUFeatures() == &cpu);
VIXL_CHECK(cpu.Has(CPUFeatures::kCRC32,
CPUFeatures::kSHA1,
CPUFeatures::kSHA2,
CPUFeatures::kAES));
// Features can be added or removed directly, in the usual fashion.
// (The scope will restore their original status when it ends.)
cpu.Combine(CPUFeatures::kSHA1, CPUFeatures::kAtomics);
VIXL_CHECK(cpu.Has(CPUFeatures::kCRC32,
CPUFeatures::kSHA1,
CPUFeatures::kSHA2,
CPUFeatures::kAES));
VIXL_CHECK(cpu.Has(CPUFeatures::kAtomics));
cpu.Remove(CPUFeatures::kSHA2, CPUFeatures::kAES);
VIXL_CHECK(!cpu.Has(CPUFeatures::kSHA2, CPUFeatures::kAES));
VIXL_CHECK(cpu.Has(CPUFeatures::kCRC32,
CPUFeatures::kSHA1,
CPUFeatures::kAtomics));
const CPUFeatures original_inner = cpu;
// Scopes can be nested.
{
// A CPUFeaturesScope can be constructed from a CPUFeatures*, or any
// (non-local) object that implements `CPUFeatures* GetCPUFeatures()`.
// Typically, this would be an Assembler or MacroAssembler, but
// CPUFeatureScope itself provides this method, and allows the test to
// remain architecture-agnostic.
CPUFeatures auth(CPUFeatures::kPAuth,
CPUFeatures::kPAuthQARMA,
CPUFeatures::kPAuthGeneric,
CPUFeatures::kPAuthGenericQARMA);
CPUFeaturesScope inner(&outer, auth);
VIXL_CHECK(inner.GetCPUFeatures() == &cpu);
VIXL_CHECK(cpu.Has(auth.With(CPUFeatures::kCRC32,
CPUFeatures::kSHA1,
CPUFeatures::kAtomics)));
}
// Check for equivalence.
VIXL_CHECK(cpu.Has(original_inner));
VIXL_CHECK(original_inner.Has(cpu));
}
// Check for equivalence.
VIXL_CHECK(cpu.Has(original_outer));
VIXL_CHECK(original_outer.Has(cpu));
}
} // namespace vixl