398 lines
16 KiB
C++
398 lines
16 KiB
C++
//===- subzero/crosstest/test_arith_main.cpp - Driver for tests -----------===//
|
|
//
|
|
// The Subzero Code Generator
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Driver for crosstesting arithmetic operations
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/* crosstest.py --test=test_arith.cpp --test=test_arith_frem.ll \
|
|
--test=test_arith_sqrt.ll --driver=test_arith_main.cpp \
|
|
--prefix=Subzero_ --output=test_arith */
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <cfloat>
|
|
#include <climits> // CHAR_BIT
|
|
#include <cmath> // fmodf
|
|
#include <cstring> // memcmp
|
|
#include <iostream>
|
|
#include <limits>
|
|
|
|
// Include test_arith.h twice - once normally, and once within the
|
|
// Subzero_ namespace, corresponding to the llc and Subzero translated
|
|
// object files, respectively.
|
|
#include "test_arith.h"
|
|
|
|
namespace Subzero_ {
|
|
#include "test_arith.h"
|
|
}
|
|
|
|
#include "insertelement.h"
|
|
#include "xdefs.h"
|
|
|
|
template <class T> bool inputsMayTriggerException(T Value1, T Value2) {
|
|
// Avoid HW divide-by-zero exception.
|
|
if (Value2 == 0)
|
|
return true;
|
|
// Avoid HW overflow exception (on x86-32). TODO: adjust
|
|
// for other architecture.
|
|
if (Value1 == std::numeric_limits<T>::min() && Value2 == -1)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
template <typename TypeUnsigned, typename TypeSigned>
|
|
void testsInt(size_t &TotalTests, size_t &Passes, size_t &Failures) {
|
|
typedef TypeUnsigned (*FuncTypeUnsigned)(TypeUnsigned, TypeUnsigned);
|
|
typedef TypeSigned (*FuncTypeSigned)(TypeSigned, TypeSigned);
|
|
volatile unsigned Values[] = INT_VALUE_ARRAY;
|
|
const static size_t NumValues = sizeof(Values) / sizeof(*Values);
|
|
static struct {
|
|
// For functions that operate on unsigned values, the
|
|
// FuncLlcSigned and FuncSzSigned fields are NULL. For functions
|
|
// that operate on signed values, the FuncLlcUnsigned and
|
|
// FuncSzUnsigned fields are NULL.
|
|
const char *Name;
|
|
FuncTypeUnsigned FuncLlcUnsigned;
|
|
FuncTypeUnsigned FuncSzUnsigned;
|
|
FuncTypeSigned FuncLlcSigned;
|
|
FuncTypeSigned FuncSzSigned;
|
|
bool ExcludeDivExceptions; // for divide related tests
|
|
} Funcs[] = {
|
|
#define X(inst, op, isdiv, isshift) \
|
|
{STR(inst), test##inst, Subzero_::test##inst, NULL, NULL, isdiv},
|
|
UINTOP_TABLE
|
|
#undef X
|
|
#define X(inst, op, isdiv, isshift) \
|
|
{STR(inst), NULL, NULL, test##inst, Subzero_::test##inst, isdiv},
|
|
SINTOP_TABLE
|
|
#undef X
|
|
#define X(mult_by) \
|
|
{"Mult-By-" STR(mult_by), \
|
|
testMultiplyBy##mult_by, \
|
|
Subzero_::testMultiplyBy##mult_by, \
|
|
NULL, \
|
|
NULL, \
|
|
false}, \
|
|
{"Mult-By-Neg-" STR(mult_by), \
|
|
testMultiplyByNeg##mult_by, \
|
|
Subzero_::testMultiplyByNeg##mult_by, \
|
|
NULL, \
|
|
NULL, \
|
|
false},
|
|
MULIMM_TABLE};
|
|
#undef X
|
|
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
|
|
|
|
if (sizeof(TypeUnsigned) <= sizeof(uint32_t)) {
|
|
// This is the "normal" version of the loop nest, for 32-bit or
|
|
// narrower types.
|
|
for (size_t f = 0; f < NumFuncs; ++f) {
|
|
for (size_t i = 0; i < NumValues; ++i) {
|
|
for (size_t j = 0; j < NumValues; ++j) {
|
|
TypeUnsigned Value1 = Values[i];
|
|
TypeUnsigned Value2 = Values[j];
|
|
// Avoid HW divide-by-zero exception.
|
|
if (Funcs[f].ExcludeDivExceptions &&
|
|
inputsMayTriggerException<TypeSigned>(Value1, Value2))
|
|
continue;
|
|
++TotalTests;
|
|
TypeUnsigned ResultSz, ResultLlc;
|
|
if (Funcs[f].FuncSzUnsigned) {
|
|
ResultSz = Funcs[f].FuncSzUnsigned(Value1, Value2);
|
|
ResultLlc = Funcs[f].FuncLlcUnsigned(Value1, Value2);
|
|
} else {
|
|
ResultSz = Funcs[f].FuncSzSigned(Value1, Value2);
|
|
ResultLlc = Funcs[f].FuncLlcSigned(Value1, Value2);
|
|
}
|
|
if (ResultSz == ResultLlc) {
|
|
++Passes;
|
|
} else {
|
|
++Failures;
|
|
std::cout << "test" << Funcs[f].Name
|
|
<< (CHAR_BIT * sizeof(TypeUnsigned)) << "(" << Value1
|
|
<< ", " << Value2 << "): sz=" << (unsigned)ResultSz
|
|
<< " llc=" << (unsigned)ResultLlc << "\n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// This is the 64-bit version. Test values are synthesized from
|
|
// the 32-bit values in Values[].
|
|
for (size_t f = 0; f < NumFuncs; ++f) {
|
|
for (size_t iLo = 0; iLo < NumValues; ++iLo) {
|
|
for (size_t iHi = 0; iHi < NumValues; ++iHi) {
|
|
for (size_t jLo = 0; jLo < NumValues; ++jLo) {
|
|
for (size_t jHi = 0; jHi < NumValues; ++jHi) {
|
|
TypeUnsigned Value1 =
|
|
(((TypeUnsigned)Values[iHi]) << 32) + Values[iLo];
|
|
TypeUnsigned Value2 =
|
|
(((TypeUnsigned)Values[jHi]) << 32) + Values[jLo];
|
|
if (Funcs[f].ExcludeDivExceptions &&
|
|
inputsMayTriggerException<TypeSigned>(Value1, Value2))
|
|
continue;
|
|
++TotalTests;
|
|
TypeUnsigned ResultSz, ResultLlc;
|
|
if (Funcs[f].FuncSzUnsigned) {
|
|
ResultSz = Funcs[f].FuncSzUnsigned(Value1, Value2);
|
|
ResultLlc = Funcs[f].FuncLlcUnsigned(Value1, Value2);
|
|
} else {
|
|
ResultSz = Funcs[f].FuncSzSigned(Value1, Value2);
|
|
ResultLlc = Funcs[f].FuncLlcSigned(Value1, Value2);
|
|
}
|
|
if (ResultSz == ResultLlc) {
|
|
++Passes;
|
|
} else {
|
|
++Failures;
|
|
std::cout << "test" << Funcs[f].Name
|
|
<< (CHAR_BIT * sizeof(TypeUnsigned)) << "(" << Value1
|
|
<< ", " << Value2 << "): sz=" << (uint64)ResultSz
|
|
<< " llc=" << (uint64)ResultLlc << "\n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
const static size_t MaxTestsPerFunc = 100000;
|
|
|
|
template <typename TypeUnsignedLabel, typename TypeSignedLabel>
|
|
void testsVecInt(size_t &TotalTests, size_t &Passes, size_t &Failures) {
|
|
typedef typename Vectors<TypeUnsignedLabel>::Ty TypeUnsigned;
|
|
typedef typename Vectors<TypeSignedLabel>::Ty TypeSigned;
|
|
typedef typename Vectors<TypeUnsignedLabel>::ElementTy ElementTypeUnsigned;
|
|
typedef typename Vectors<TypeSignedLabel>::ElementTy ElementTypeSigned;
|
|
|
|
typedef TypeUnsigned (*FuncTypeUnsigned)(TypeUnsigned, TypeUnsigned);
|
|
typedef TypeSigned (*FuncTypeSigned)(TypeSigned, TypeSigned);
|
|
volatile unsigned Values[] = INT_VALUE_ARRAY;
|
|
const static size_t NumValues = sizeof(Values) / sizeof(*Values);
|
|
static struct {
|
|
// For functions that operate on unsigned values, the
|
|
// FuncLlcSigned and FuncSzSigned fields are NULL. For functions
|
|
// that operate on signed values, the FuncLlcUnsigned and
|
|
// FuncSzUnsigned fields are NULL.
|
|
const char *Name;
|
|
FuncTypeUnsigned FuncLlcUnsigned;
|
|
FuncTypeUnsigned FuncSzUnsigned;
|
|
FuncTypeSigned FuncLlcSigned;
|
|
FuncTypeSigned FuncSzSigned;
|
|
bool ExcludeDivExceptions; // for divide related tests
|
|
bool MaskShiftOperations; // for shift related tests
|
|
} Funcs[] = {
|
|
#define X(inst, op, isdiv, isshift) \
|
|
{STR(inst), test##inst, Subzero_::test##inst, NULL, NULL, isdiv, isshift},
|
|
UINTOP_TABLE
|
|
#undef X
|
|
#define X(inst, op, isdiv, isshift) \
|
|
{STR(inst), NULL, NULL, test##inst, Subzero_::test##inst, isdiv, isshift},
|
|
SINTOP_TABLE
|
|
#undef X
|
|
};
|
|
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
|
|
const static size_t NumElementsInType = Vectors<TypeUnsigned>::NumElements;
|
|
for (size_t f = 0; f < NumFuncs; ++f) {
|
|
PRNG Index;
|
|
for (size_t i = 0; i < MaxTestsPerFunc; ++i) {
|
|
// Initialize the test vectors.
|
|
TypeUnsigned Value1, Value2;
|
|
for (size_t j = 0; j < NumElementsInType; ++j) {
|
|
ElementTypeUnsigned Element1 = Values[Index() % NumValues];
|
|
ElementTypeUnsigned Element2 = Values[Index() % NumValues];
|
|
if (Funcs[f].ExcludeDivExceptions &&
|
|
inputsMayTriggerException<ElementTypeSigned>(Element1, Element2))
|
|
continue;
|
|
if (Funcs[f].MaskShiftOperations)
|
|
Element2 &= CHAR_BIT * sizeof(ElementTypeUnsigned) - 1;
|
|
setElement(Value1, j, Element1);
|
|
setElement(Value2, j, Element2);
|
|
}
|
|
// Perform the test.
|
|
TypeUnsigned ResultSz, ResultLlc;
|
|
++TotalTests;
|
|
if (Funcs[f].FuncSzUnsigned) {
|
|
ResultSz = Funcs[f].FuncSzUnsigned(Value1, Value2);
|
|
ResultLlc = Funcs[f].FuncLlcUnsigned(Value1, Value2);
|
|
} else {
|
|
ResultSz = Funcs[f].FuncSzSigned(Value1, Value2);
|
|
ResultLlc = Funcs[f].FuncLlcSigned(Value1, Value2);
|
|
}
|
|
if (!memcmp(&ResultSz, &ResultLlc, sizeof(ResultSz))) {
|
|
++Passes;
|
|
} else {
|
|
++Failures;
|
|
std::cout << "test" << Funcs[f].Name << "v" << NumElementsInType << "i"
|
|
<< (CHAR_BIT * sizeof(ElementTypeUnsigned)) << "("
|
|
<< vectAsString<TypeUnsignedLabel>(Value1) << ","
|
|
<< vectAsString<TypeUnsignedLabel>(Value2)
|
|
<< "): sz=" << vectAsString<TypeUnsignedLabel>(ResultSz)
|
|
<< " llc=" << vectAsString<TypeUnsignedLabel>(ResultLlc)
|
|
<< "\n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
template <typename Type>
|
|
void testsFp(size_t &TotalTests, size_t &Passes, size_t &Failures) {
|
|
static const Type NegInf = -1.0 / 0.0;
|
|
static const Type PosInf = 1.0 / 0.0;
|
|
static const Type Nan = 0.0 / 0.0;
|
|
static const Type NegNan = -0.0 / 0.0;
|
|
volatile Type Values[] = FP_VALUE_ARRAY(NegInf, PosInf, NegNan, Nan);
|
|
const static size_t NumValues = sizeof(Values) / sizeof(*Values);
|
|
typedef Type (*FuncType)(Type, Type);
|
|
static struct {
|
|
const char *Name;
|
|
FuncType FuncLlc;
|
|
FuncType FuncSz;
|
|
} Funcs[] = {
|
|
#define X(inst, op, func) \
|
|
{STR(inst), (FuncType)test##inst, (FuncType)Subzero_::test##inst},
|
|
FPOP_TABLE
|
|
#undef X
|
|
};
|
|
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
|
|
|
|
for (size_t f = 0; f < NumFuncs; ++f) {
|
|
for (size_t i = 0; i < NumValues; ++i) {
|
|
for (size_t j = 0; j < NumValues; ++j) {
|
|
Type Value1 = Values[i];
|
|
Type Value2 = Values[j];
|
|
++TotalTests;
|
|
Type ResultSz = Funcs[f].FuncSz(Value1, Value2);
|
|
Type ResultLlc = Funcs[f].FuncLlc(Value1, Value2);
|
|
// Compare results using memcmp() in case they are both NaN.
|
|
if (!memcmp(&ResultSz, &ResultLlc, sizeof(Type))) {
|
|
++Passes;
|
|
} else {
|
|
++Failures;
|
|
std::cout << std::fixed << "test" << Funcs[f].Name
|
|
<< (CHAR_BIT * sizeof(Type)) << "(" << Value1 << ", "
|
|
<< Value2 << "): sz=" << ResultSz << " llc=" << ResultLlc
|
|
<< "\n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (size_t i = 0; i < NumValues; ++i) {
|
|
Type Value = Values[i];
|
|
++TotalTests;
|
|
Type ResultSz = Subzero_::mySqrt(Value);
|
|
Type ResultLlc = mySqrt(Value);
|
|
// Compare results using memcmp() in case they are both NaN.
|
|
if (!memcmp(&ResultSz, &ResultLlc, sizeof(Type))) {
|
|
++Passes;
|
|
} else {
|
|
++Failures;
|
|
std::cout << std::fixed << "test_sqrt" << (CHAR_BIT * sizeof(Type)) << "("
|
|
<< Value << "): sz=" << ResultSz << " llc=" << ResultLlc
|
|
<< "\n";
|
|
}
|
|
++TotalTests;
|
|
ResultSz = Subzero_::myFabs(Value);
|
|
ResultLlc = myFabs(Value);
|
|
// Compare results using memcmp() in case they are both NaN.
|
|
if (!memcmp(&ResultSz, &ResultLlc, sizeof(Type))) {
|
|
++Passes;
|
|
} else {
|
|
++Failures;
|
|
std::cout << std::fixed << "test_fabs" << (CHAR_BIT * sizeof(Type)) << "("
|
|
<< Value << "): sz=" << ResultSz << " llc=" << ResultLlc
|
|
<< "\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
void testsVecFp(size_t &TotalTests, size_t &Passes, size_t &Failures) {
|
|
static const float NegInf = -1.0 / 0.0;
|
|
static const float PosInf = 1.0 / 0.0;
|
|
static const float Nan = 0.0 / 0.0;
|
|
static const float NegNan = -0.0 / 0.0;
|
|
volatile float Values[] = FP_VALUE_ARRAY(NegInf, PosInf, NegNan, Nan);
|
|
const static size_t NumValues = sizeof(Values) / sizeof(*Values);
|
|
typedef v4f32 (*FuncType)(v4f32, v4f32);
|
|
static struct {
|
|
const char *Name;
|
|
FuncType FuncLlc;
|
|
FuncType FuncSz;
|
|
} Funcs[] = {
|
|
#define X(inst, op, func) \
|
|
{STR(inst), (FuncType)test##inst, (FuncType)Subzero_::test##inst},
|
|
FPOP_TABLE
|
|
#undef X
|
|
};
|
|
const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
|
|
const static size_t NumElementsInType = 4;
|
|
for (size_t f = 0; f < NumFuncs; ++f) {
|
|
PRNG Index;
|
|
for (size_t i = 0; i < MaxTestsPerFunc; ++i) {
|
|
// Initialize the test vectors.
|
|
v4f32 Value1, Value2;
|
|
for (size_t j = 0; j < NumElementsInType; ++j) {
|
|
setElement(Value1, j, Values[Index() % NumValues]);
|
|
setElement(Value2, j, Values[Index() % NumValues]);
|
|
}
|
|
// Perform the test.
|
|
v4f32 ResultSz = Funcs[f].FuncSz(Value1, Value2);
|
|
v4f32 ResultLlc = Funcs[f].FuncLlc(Value1, Value2);
|
|
++TotalTests;
|
|
if (!memcmp(&ResultSz, &ResultLlc, sizeof(ResultSz))) {
|
|
++Passes;
|
|
} else {
|
|
++Failures;
|
|
std::cout << "test" << Funcs[f].Name << "v4f32"
|
|
<< "(" << vectAsString<v4f32>(Value1) << ","
|
|
<< vectAsString<v4f32>(Value2)
|
|
<< "): sz=" << vectAsString<v4f32>(ResultSz) << " llc"
|
|
<< vectAsString<v4f32>(ResultLlc) << "\n";
|
|
}
|
|
// Special case for unary fabs operation. Use Value1, ignore Value2.
|
|
ResultSz = Subzero_::myFabs(Value1);
|
|
ResultLlc = myFabs(Value1);
|
|
++TotalTests;
|
|
if (!memcmp(&ResultSz, &ResultLlc, sizeof(ResultSz))) {
|
|
++Passes;
|
|
} else {
|
|
++Failures;
|
|
std::cout << "test_fabs_v4f32"
|
|
<< "(" << vectAsString<v4f32>(Value1)
|
|
<< "): sz=" << vectAsString<v4f32>(ResultSz) << " llc"
|
|
<< vectAsString<v4f32>(ResultLlc) << "\n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int main(int argc, char *argv[]) {
|
|
size_t TotalTests = 0;
|
|
size_t Passes = 0;
|
|
size_t Failures = 0;
|
|
|
|
testsInt<bool, bool>(TotalTests, Passes, Failures);
|
|
testsInt<uint8_t, myint8_t>(TotalTests, Passes, Failures);
|
|
testsInt<uint16_t, int16_t>(TotalTests, Passes, Failures);
|
|
testsInt<uint32_t, int32_t>(TotalTests, Passes, Failures);
|
|
testsInt<uint64, int64>(TotalTests, Passes, Failures);
|
|
testsVecInt<v4ui32, v4si32>(TotalTests, Passes, Failures);
|
|
testsVecInt<v8ui16, v8si16>(TotalTests, Passes, Failures);
|
|
testsVecInt<v16ui8, v16si8>(TotalTests, Passes, Failures);
|
|
testsFp<float>(TotalTests, Passes, Failures);
|
|
testsFp<double>(TotalTests, Passes, Failures);
|
|
testsVecFp(TotalTests, Passes, Failures);
|
|
|
|
std::cout << "TotalTests=" << TotalTests << " Passes=" << Passes
|
|
<< " Failures=" << Failures << "\n";
|
|
return Failures;
|
|
}
|