322 lines
15 KiB
C++
322 lines
15 KiB
C++
//===- subzero/crosstest/test_cast_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 cast operations.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/* crosstest.py --test=test_cast.cpp --test=test_cast_to_u1.ll \
|
|
--test=test_cast_vectors.ll \
|
|
--driver=test_cast_main.cpp --prefix=Subzero_ --output=test_cast */
|
|
|
|
#include <cfloat>
|
|
#include <cstring>
|
|
#include <iostream>
|
|
#include <stdint.h>
|
|
|
|
#include "test_arith.def"
|
|
#include "vectors.h"
|
|
#include "xdefs.h"
|
|
|
|
// Include test_cast.h twice - once normally, and once within the
|
|
// Subzero_ namespace, corresponding to the llc and Subzero translated
|
|
// object files, respectively.
|
|
#include "test_cast.h"
|
|
namespace Subzero_ {
|
|
#include "test_cast.h"
|
|
}
|
|
|
|
#define XSTR(s) STR(s)
|
|
#define STR(s) #s
|
|
#define COMPARE(Func, FromCName, ToCName, Input, FromString) \
|
|
do { \
|
|
ToCName ResultSz, ResultLlc; \
|
|
ResultLlc = Func<FromCName, ToCName>(Input); \
|
|
ResultSz = Subzero_::Func<FromCName, ToCName>(Input); \
|
|
++TotalTests; \
|
|
if (!memcmp(&ResultLlc, &ResultSz, sizeof(ToCName))) { \
|
|
++Passes; \
|
|
} else { \
|
|
++Failures; \
|
|
std::cout << std::fixed << XSTR(Func) << "<" << FromString \
|
|
<< ", " XSTR(ToCName) ">(" << Input << "): "; \
|
|
if (sizeof(ToCName) == 1) \
|
|
std::cout << "sz=" << (int)ResultSz << " llc=" << (int)ResultLlc; \
|
|
else \
|
|
std::cout << "sz=" << ResultSz << " llc=" << ResultLlc; \
|
|
std::cout << "\n"; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define COMPARE_ARG(Func, FromCName, ToCName, Input, FromString) \
|
|
do { \
|
|
ToCName ResultSz, ResultLlc; \
|
|
ResultLlc = Func<FromCName, ToCName>(1, Input, 2); \
|
|
ResultSz = Subzero_::Func<FromCName, ToCName>(1, Input, 2); \
|
|
++TotalTests; \
|
|
if (!memcmp(&ResultLlc, &ResultSz, sizeof(ToCName))) { \
|
|
++Passes; \
|
|
} else { \
|
|
++Failures; \
|
|
std::cout << std::fixed << XSTR(Func) << "<" << FromString \
|
|
<< ", " XSTR(ToCName) ">(" << Input << "): "; \
|
|
if (sizeof(ToCName) == 1) \
|
|
std::cout << "sz=" << (int)ResultSz << " llc=" << (int)ResultLlc; \
|
|
else \
|
|
std::cout << "sz=" << ResultSz << " llc=" << ResultLlc; \
|
|
std::cout << "\n"; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define COMPARE_VEC(Func, FromCName, ToCName, Input, FromString, ToString) \
|
|
do { \
|
|
ToCName ResultSz, ResultLlc; \
|
|
ResultLlc = Func<FromCName, ToCName>(Input); \
|
|
ResultSz = Subzero_::Func<FromCName, ToCName>(Input); \
|
|
++TotalTests; \
|
|
if (!memcmp(&ResultLlc, &ResultSz, sizeof(ToCName))) { \
|
|
++Passes; \
|
|
} else { \
|
|
++Failures; \
|
|
std::cout << std::fixed << XSTR(Func) << "<" << FromString << ", " \
|
|
<< ToString << ">(" << vectAsString<FromCName>(Input) \
|
|
<< "): "; \
|
|
std::cout << "sz=" << vectAsString<ToCName>(ResultSz) \
|
|
<< " llc=" << vectAsString<ToCName>(ResultLlc); \
|
|
std::cout << "\n"; \
|
|
} \
|
|
} while (0)
|
|
|
|
template <typename FromType>
|
|
void testValue(FromType Val, size_t &TotalTests, size_t &Passes,
|
|
size_t &Failures, const char *FromTypeString) {
|
|
COMPARE(cast, FromType, bool, Val, FromTypeString);
|
|
COMPARE(cast, FromType, uint8_t, Val, FromTypeString);
|
|
COMPARE(cast, FromType, myint8_t, Val, FromTypeString);
|
|
COMPARE(cast, FromType, uint16_t, Val, FromTypeString);
|
|
COMPARE(cast, FromType, int16_t, Val, FromTypeString);
|
|
COMPARE(cast, FromType, uint32_t, Val, FromTypeString);
|
|
COMPARE(cast, FromType, int32_t, Val, FromTypeString);
|
|
COMPARE(cast, FromType, uint64, Val, FromTypeString);
|
|
COMPARE(cast, FromType, int64, Val, FromTypeString);
|
|
COMPARE(cast, FromType, float, Val, FromTypeString);
|
|
COMPARE(cast, FromType, double, Val, FromTypeString);
|
|
COMPARE_ARG(cast, FromType, bool, Val, FromTypeString);
|
|
COMPARE_ARG(cast, FromType, uint8_t, Val, FromTypeString);
|
|
COMPARE_ARG(cast, FromType, myint8_t, Val, FromTypeString);
|
|
COMPARE_ARG(cast, FromType, uint16_t, Val, FromTypeString);
|
|
COMPARE_ARG(cast, FromType, int16_t, Val, FromTypeString);
|
|
COMPARE_ARG(cast, FromType, uint32_t, Val, FromTypeString);
|
|
COMPARE_ARG(cast, FromType, int32_t, Val, FromTypeString);
|
|
COMPARE_ARG(cast, FromType, uint64, Val, FromTypeString);
|
|
COMPARE_ARG(cast, FromType, int64, Val, FromTypeString);
|
|
COMPARE_ARG(cast, FromType, float, Val, FromTypeString);
|
|
COMPARE_ARG(cast, FromType, double, Val, FromTypeString);
|
|
}
|
|
|
|
template <typename FromType, typename ToType>
|
|
void testVector(size_t &TotalTests, size_t &Passes, size_t &Failures,
|
|
const char *FromTypeString, const char *ToTypeString) {
|
|
const static size_t NumElementsInType = Vectors<FromType>::NumElements;
|
|
PRNG Index;
|
|
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);
|
|
static const size_t NumValues = sizeof(Values) / sizeof(*Values);
|
|
const size_t MaxTestsPerFunc = 20000;
|
|
for (size_t i = 0; i < MaxTestsPerFunc; ++i) {
|
|
// Initialize the test vectors.
|
|
FromType Value;
|
|
for (size_t j = 0; j < NumElementsInType; ++j) {
|
|
Value[j] = Values[Index() % NumValues];
|
|
}
|
|
COMPARE_VEC(cast, FromType, ToType, Value, FromTypeString, ToTypeString);
|
|
}
|
|
}
|
|
|
|
int main(int argc, char *argv[]) {
|
|
size_t TotalTests = 0;
|
|
size_t Passes = 0;
|
|
size_t Failures = 0;
|
|
|
|
volatile bool ValsUi1[] = {false, true};
|
|
static const size_t NumValsUi1 = sizeof(ValsUi1) / sizeof(*ValsUi1);
|
|
volatile uint8_t ValsUi8[] = {0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff};
|
|
static const size_t NumValsUi8 = sizeof(ValsUi8) / sizeof(*ValsUi8);
|
|
|
|
volatile myint8_t ValsSi8[] = {0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff};
|
|
static const size_t NumValsSi8 = sizeof(ValsSi8) / sizeof(*ValsSi8);
|
|
|
|
volatile uint16_t ValsUi16[] = {0, 1, 0x7e, 0x7f, 0x80,
|
|
0x81, 0xfe, 0xff, 0x7ffe, 0x7fff,
|
|
0x8000, 0x8001, 0xfffe, 0xffff};
|
|
static const size_t NumValsUi16 = sizeof(ValsUi16) / sizeof(*ValsUi16);
|
|
|
|
volatile int16_t ValsSi16[] = {0, 1, 0x7e, 0x7f, 0x80,
|
|
0x81, 0xfe, 0xff, 0x7ffe, 0x7fff,
|
|
0x8000, 0x8001, 0xfffe, 0xffff};
|
|
static const size_t NumValsSi16 = sizeof(ValsSi16) / sizeof(*ValsSi16);
|
|
|
|
volatile size_t ValsUi32[] = {0, 1, 0x7e, 0x7f,
|
|
0x80, 0x81, 0xfe, 0xff,
|
|
0x7ffe, 0x7fff, 0x8000, 0x8001,
|
|
0xfffe, 0xffff, 0x7ffffffe, 0x7fffffff,
|
|
0x80000000, 0x80000001, 0xfffffffe, 0xffffffff};
|
|
static const size_t NumValsUi32 = sizeof(ValsUi32) / sizeof(*ValsUi32);
|
|
|
|
volatile size_t ValsSi32[] = {0, 1, 0x7e, 0x7f,
|
|
0x80, 0x81, 0xfe, 0xff,
|
|
0x7ffe, 0x7fff, 0x8000, 0x8001,
|
|
0xfffe, 0xffff, 0x7ffffffe, 0x7fffffff,
|
|
0x80000000, 0x80000001, 0xfffffffe, 0xffffffff};
|
|
static const size_t NumValsSi32 = sizeof(ValsSi32) / sizeof(*ValsSi32);
|
|
|
|
volatile uint64 ValsUi64[] = {0,
|
|
1,
|
|
0x7e,
|
|
0x7f,
|
|
0x80,
|
|
0x81,
|
|
0xfe,
|
|
0xff,
|
|
0x7ffe,
|
|
0x7fff,
|
|
0x8000,
|
|
0x8001,
|
|
0xfffe,
|
|
0xffff,
|
|
0x7ffffffe,
|
|
0x7fffffff,
|
|
0x80000000,
|
|
0x80000001,
|
|
0xfffffffe,
|
|
0xffffffff,
|
|
0x100000000ull,
|
|
0x100000001ull,
|
|
0x7ffffffffffffffeull,
|
|
0x7fffffffffffffffull,
|
|
0x8000000000000000ull,
|
|
0x8000000000000001ull,
|
|
0xfffffffffffffffeull,
|
|
0xffffffffffffffffull};
|
|
static const size_t NumValsUi64 = sizeof(ValsUi64) / sizeof(*ValsUi64);
|
|
|
|
volatile int64 ValsSi64[] = {0,
|
|
1,
|
|
0x7e,
|
|
0x7f,
|
|
0x80,
|
|
0x81,
|
|
0xfe,
|
|
0xff,
|
|
0x7ffe,
|
|
0x7fff,
|
|
0x8000,
|
|
0x8001,
|
|
0xfffe,
|
|
0xffff,
|
|
0x7ffffffe,
|
|
0x7fffffff,
|
|
0x80000000,
|
|
0x80000001,
|
|
0xfffffffe,
|
|
0xffffffff,
|
|
0x100000000ll,
|
|
0x100000001ll,
|
|
0x7ffffffffffffffell,
|
|
0x7fffffffffffffffll,
|
|
0x8000000000000000ll,
|
|
0x8000000000000001ll,
|
|
0xfffffffffffffffell,
|
|
0xffffffffffffffffll};
|
|
static const size_t NumValsSi64 = sizeof(ValsSi64) / sizeof(*ValsSi64);
|
|
|
|
static const double NegInf = -1.0 / 0.0;
|
|
static const double PosInf = 1.0 / 0.0;
|
|
static const double Nan = 0.0 / 0.0;
|
|
static const double NegNan = -0.0 / 0.0;
|
|
volatile float ValsF32[] = FP_VALUE_ARRAY(NegInf, PosInf, NegNan, Nan);
|
|
static const size_t NumValsF32 = sizeof(ValsF32) / sizeof(*ValsF32);
|
|
|
|
volatile double ValsF64[] = FP_VALUE_ARRAY(NegInf, PosInf, NegNan, Nan);
|
|
static const size_t NumValsF64 = sizeof(ValsF64) / sizeof(*ValsF64);
|
|
|
|
for (size_t i = 0; i < NumValsUi1; ++i) {
|
|
bool Val = ValsUi1[i];
|
|
testValue<bool>(Val, TotalTests, Passes, Failures, "bool");
|
|
}
|
|
for (size_t i = 0; i < NumValsUi8; ++i) {
|
|
uint8_t Val = ValsUi8[i];
|
|
testValue<uint8_t>(Val, TotalTests, Passes, Failures, "uint8_t");
|
|
}
|
|
for (size_t i = 0; i < NumValsSi8; ++i) {
|
|
myint8_t Val = ValsSi8[i];
|
|
testValue<myint8_t>(Val, TotalTests, Passes, Failures, "int8_t");
|
|
}
|
|
for (size_t i = 0; i < NumValsUi16; ++i) {
|
|
uint16_t Val = ValsUi16[i];
|
|
testValue<uint16_t>(Val, TotalTests, Passes, Failures, "uint16_t");
|
|
}
|
|
for (size_t i = 0; i < NumValsSi16; ++i) {
|
|
int16_t Val = ValsSi16[i];
|
|
testValue<int16_t>(Val, TotalTests, Passes, Failures, "int16_t");
|
|
}
|
|
for (size_t i = 0; i < NumValsUi32; ++i) {
|
|
uint32_t Val = ValsUi32[i];
|
|
testValue<uint32_t>(Val, TotalTests, Passes, Failures, "uint32_t");
|
|
COMPARE(castBits, uint32_t, float, Val, "uint32_t");
|
|
COMPARE_ARG(castBits, uint32_t, float, Val, "uint32_t");
|
|
}
|
|
for (size_t i = 0; i < NumValsSi32; ++i) {
|
|
int32_t Val = ValsSi32[i];
|
|
testValue<int32_t>(Val, TotalTests, Passes, Failures, "int32_t");
|
|
}
|
|
for (size_t i = 0; i < NumValsUi64; ++i) {
|
|
uint64 Val = ValsUi64[i];
|
|
testValue<uint64>(Val, TotalTests, Passes, Failures, "uint64");
|
|
COMPARE(castBits, uint64, double, Val, "uint64");
|
|
COMPARE_ARG(castBits, uint64, double, Val, "uint64");
|
|
}
|
|
for (size_t i = 0; i < NumValsSi64; ++i) {
|
|
int64 Val = ValsSi64[i];
|
|
testValue<int64>(Val, TotalTests, Passes, Failures, "int64");
|
|
}
|
|
for (size_t i = 0; i < NumValsF32; ++i) {
|
|
for (unsigned j = 0; j < 2; ++j) {
|
|
float Val = ValsF32[i];
|
|
if (j > 0)
|
|
Val = -Val;
|
|
testValue<float>(Val, TotalTests, Passes, Failures, "float");
|
|
COMPARE(castBits, float, uint32_t, Val, "float");
|
|
COMPARE_ARG(castBits, float, uint32_t, Val, "float");
|
|
}
|
|
}
|
|
for (size_t i = 0; i < NumValsF64; ++i) {
|
|
for (unsigned j = 0; j < 2; ++j) {
|
|
double Val = ValsF64[i];
|
|
if (j > 0)
|
|
Val = -Val;
|
|
testValue<double>(Val, TotalTests, Passes, Failures, "double");
|
|
COMPARE(castBits, double, uint64, Val, "double");
|
|
COMPARE_ARG(castBits, double, uint64, Val, "double");
|
|
}
|
|
}
|
|
|
|
testVector<v4ui32, v4f32>(TotalTests, Passes, Failures, "v4ui32", "v4f32");
|
|
testVector<v4si32, v4f32>(TotalTests, Passes, Failures, "v4si32", "v4f32");
|
|
testVector<v4f32, v4si32>(TotalTests, Passes, Failures, "v4f32", "v4si32");
|
|
testVector<v4f32, v4ui32>(TotalTests, Passes, Failures, "v4f32", "v4ui32");
|
|
|
|
std::cout << "TotalTests=" << TotalTests << " Passes=" << Passes
|
|
<< " Failures=" << Failures << "\n";
|
|
return Failures;
|
|
}
|