OLD | NEW |
(Empty) | |
| 1 /* crosstest.py --test=test_cast.cpp --test=test_cast_to_u1.ll \ |
| 2 --driver=test_cast_main.cpp --prefix=Subzero_ --output=test_cast */ |
| 3 |
| 4 #include <cstring> |
| 5 #include <iostream> |
| 6 #include <stdint.h> |
| 7 |
| 8 // Include test_cast.h twice - once normally, and once within the |
| 9 // Subzero_ namespace, corresponding to the llc and Subzero translated |
| 10 // object files, respectively. |
| 11 #include "test_cast.h" |
| 12 namespace Subzero_ { |
| 13 #include "test_cast.h" |
| 14 } |
| 15 |
| 16 #define XSTR(s) STR(s) |
| 17 #define STR(s) #s |
| 18 #define COMPARE(Func, FromCName, ToCName, Input) \ |
| 19 do { \ |
| 20 ToCName ResultSz, ResultLlc; \ |
| 21 ResultLlc = Func<FromCName, ToCName>(Input); \ |
| 22 ResultSz = Subzero_::Func<FromCName, ToCName>(Input); \ |
| 23 ++TotalTests; \ |
| 24 if (!memcmp(&ResultLlc, &ResultSz, sizeof(ToCName))) { \ |
| 25 ++Passes; \ |
| 26 } else { \ |
| 27 ++Failures; \ |
| 28 std::cout << std::fixed << XSTR(Func) \ |
| 29 << "<" XSTR(FromCName) ", " XSTR(ToCName) ">(" << Input \ |
| 30 << "): sz=" << ResultSz << " llc=" << ResultLlc << "\n"; \ |
| 31 } \ |
| 32 } while (0) |
| 33 |
| 34 template <typename FromType> |
| 35 void testValue(FromType Val, size_t &TotalTests, size_t &Passes, |
| 36 size_t &Failures) { |
| 37 COMPARE(cast, FromType, bool, Val); |
| 38 COMPARE(cast, FromType, uint8_t, Val); |
| 39 COMPARE(cast, FromType, int8_t, Val); |
| 40 COMPARE(cast, FromType, uint16_t, Val); |
| 41 COMPARE(cast, FromType, int16_t, Val); |
| 42 COMPARE(cast, FromType, uint32_t, Val); |
| 43 COMPARE(cast, FromType, int32_t, Val); |
| 44 COMPARE(cast, FromType, uint64_t, Val); |
| 45 COMPARE(cast, FromType, int64_t, Val); |
| 46 COMPARE(cast, FromType, float, Val); |
| 47 COMPARE(cast, FromType, double, Val); |
| 48 } |
| 49 |
| 50 int main(int argc, char **argv) { |
| 51 size_t TotalTests = 0; |
| 52 size_t Passes = 0; |
| 53 size_t Failures = 0; |
| 54 |
| 55 volatile bool ValsUi1[] = { false, true }; |
| 56 static const size_t NumValsUi1 = sizeof(ValsUi1) / sizeof(*ValsUi1); |
| 57 volatile uint8_t ValsUi8[] = { 0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff }; |
| 58 static const size_t NumValsUi8 = sizeof(ValsUi8) / sizeof(*ValsUi8); |
| 59 |
| 60 volatile int8_t ValsSi8[] = { 0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff }; |
| 61 static const size_t NumValsSi8 = sizeof(ValsSi8) / sizeof(*ValsSi8); |
| 62 |
| 63 volatile uint16_t ValsUi16[] = { 0, 1, 0x7e, 0x7f, 0x80, |
| 64 0x81, 0xfe, 0xff, 0x7ffe, 0x7fff, |
| 65 0x8000, 0x8001, 0xfffe, 0xffff }; |
| 66 static const size_t NumValsUi16 = sizeof(ValsUi16) / sizeof(*ValsUi16); |
| 67 |
| 68 volatile int16_t ValsSi16[] = { 0, 1, 0x7e, 0x7f, 0x80, |
| 69 0x81, 0xfe, 0xff, 0x7ffe, 0x7fff, |
| 70 0x8000, 0x8001, 0xfffe, 0xffff }; |
| 71 static const size_t NumValsSi16 = sizeof(ValsSi16) / sizeof(*ValsSi16); |
| 72 |
| 73 volatile size_t ValsUi32[] = { |
| 74 0, 1, 0x7e, 0x7f, 0x80, |
| 75 0x81, 0xfe, 0xff, 0x7ffe, 0x7fff, |
| 76 0x8000, 0x8001, 0xfffe, 0xffff, 0x7ffffffe, |
| 77 0x7fffffff, 0x80000000, 0x80000001, 0xfffffffe, 0xffffffff |
| 78 }; |
| 79 static const size_t NumValsUi32 = sizeof(ValsUi32) / sizeof(*ValsUi32); |
| 80 |
| 81 volatile size_t ValsSi32[] = { |
| 82 0, 1, 0x7e, 0x7f, 0x80, |
| 83 0x81, 0xfe, 0xff, 0x7ffe, 0x7fff, |
| 84 0x8000, 0x8001, 0xfffe, 0xffff, 0x7ffffffe, |
| 85 0x7fffffff, 0x80000000, 0x80000001, 0xfffffffe, 0xffffffff |
| 86 }; |
| 87 static const size_t NumValsSi32 = sizeof(ValsSi32) / sizeof(*ValsSi32); |
| 88 |
| 89 volatile uint64_t ValsUi64[] = { |
| 90 0, 1, 0x7e, |
| 91 0x7f, 0x80, 0x81, |
| 92 0xfe, 0xff, 0x7ffe, |
| 93 0x7fff, 0x8000, 0x8001, |
| 94 0xfffe, 0xffff, 0x7ffffffe, |
| 95 0x7fffffff, 0x80000000, 0x80000001, |
| 96 0xfffffffe, 0xffffffff, 0x100000000ull, |
| 97 0x100000001ull, 0x7ffffffffffffffeull, 0x7fffffffffffffffull, |
| 98 0x8000000000000000ull, 0x8000000000000001ull, 0xfffffffffffffffeull, |
| 99 0xffffffffffffffffull |
| 100 }; |
| 101 static const size_t NumValsUi64 = sizeof(ValsUi64) / sizeof(*ValsUi64); |
| 102 |
| 103 volatile int64_t ValsSi64[] = { |
| 104 0, 1, 0x7e, |
| 105 0x7f, 0x80, 0x81, |
| 106 0xfe, 0xff, 0x7ffe, |
| 107 0x7fff, 0x8000, 0x8001, |
| 108 0xfffe, 0xffff, 0x7ffffffe, |
| 109 0x7fffffff, 0x80000000, 0x80000001, |
| 110 0xfffffffe, 0xffffffff, 0x100000000ll, |
| 111 0x100000001ll, 0x7ffffffffffffffell, 0x7fffffffffffffffll, |
| 112 0x8000000000000000ll, 0x8000000000000001ll, 0xfffffffffffffffell, |
| 113 0xffffffffffffffffll |
| 114 }; |
| 115 static const size_t NumValsSi64 = sizeof(ValsSi64) / sizeof(*ValsSi64); |
| 116 |
| 117 volatile float ValsF32[] = { |
| 118 0, 1, 0x7e, |
| 119 0x7f, 0x80, 0x81, |
| 120 0xfe, 0xff, 0x7ffe, |
| 121 0x7fff, 0x8000, 0x8001, |
| 122 0xfffe, 0xffff, 0x7ffffffe, |
| 123 0x7fffffff, 0x80000000, 0x80000001, |
| 124 0xfffffffe, 0xffffffff, 0x100000000ll, |
| 125 0x100000001ll, 0x7ffffffffffffffell, 0x7fffffffffffffffll, |
| 126 0x8000000000000000ll, 0x8000000000000001ll, 0xfffffffffffffffell, |
| 127 0xffffffffffffffffll |
| 128 }; |
| 129 static const size_t NumValsF32 = sizeof(ValsF32) / sizeof(*ValsF32); |
| 130 |
| 131 volatile double ValsF64[] = { |
| 132 0, 1, 0x7e, |
| 133 0x7f, 0x80, 0x81, |
| 134 0xfe, 0xff, 0x7ffe, |
| 135 0x7fff, 0x8000, 0x8001, |
| 136 0xfffe, 0xffff, 0x7ffffffe, |
| 137 0x7fffffff, 0x80000000, 0x80000001, |
| 138 0xfffffffe, 0xffffffff, 0x100000000ll, |
| 139 0x100000001ll, 0x7ffffffffffffffell, 0x7fffffffffffffffll, |
| 140 0x8000000000000000ll, 0x8000000000000001ll, 0xfffffffffffffffell, |
| 141 0xffffffffffffffffll |
| 142 }; |
| 143 static const size_t NumValsF64 = sizeof(ValsF64) / sizeof(*ValsF64); |
| 144 |
| 145 for (size_t i = 0; i < NumValsUi1; ++i) { |
| 146 bool Val = ValsUi1[i]; |
| 147 testValue<bool>(Val, TotalTests, Passes, Failures); |
| 148 } |
| 149 for (size_t i = 0; i < NumValsUi8; ++i) { |
| 150 uint8_t Val = ValsUi8[i]; |
| 151 testValue<uint8_t>(Val, TotalTests, Passes, Failures); |
| 152 } |
| 153 for (size_t i = 0; i < NumValsSi8; ++i) { |
| 154 int8_t Val = ValsSi8[i]; |
| 155 testValue<int8_t>(Val, TotalTests, Passes, Failures); |
| 156 } |
| 157 for (size_t i = 0; i < NumValsUi16; ++i) { |
| 158 uint16_t Val = ValsUi16[i]; |
| 159 testValue<uint16_t>(Val, TotalTests, Passes, Failures); |
| 160 } |
| 161 for (size_t i = 0; i < NumValsSi16; ++i) { |
| 162 int16_t Val = ValsSi16[i]; |
| 163 testValue<int16_t>(Val, TotalTests, Passes, Failures); |
| 164 } |
| 165 for (size_t i = 0; i < NumValsUi32; ++i) { |
| 166 uint32_t Val = ValsUi32[i]; |
| 167 testValue<uint32_t>(Val, TotalTests, Passes, Failures); |
| 168 COMPARE(castBits, uint32_t, float, Val); |
| 169 } |
| 170 for (size_t i = 0; i < NumValsSi32; ++i) { |
| 171 int32_t Val = ValsSi32[i]; |
| 172 testValue<int32_t>(Val, TotalTests, Passes, Failures); |
| 173 } |
| 174 for (size_t i = 0; i < NumValsUi64; ++i) { |
| 175 uint64_t Val = ValsUi64[i]; |
| 176 testValue<uint64_t>(Val, TotalTests, Passes, Failures); |
| 177 COMPARE(castBits, uint64_t, double, Val); |
| 178 } |
| 179 for (size_t i = 0; i < NumValsSi64; ++i) { |
| 180 int64_t Val = ValsSi64[i]; |
| 181 testValue<int64_t>(Val, TotalTests, Passes, Failures); |
| 182 } |
| 183 for (size_t i = 0; i < NumValsF32; ++i) { |
| 184 for (unsigned j = 0; j < 2; ++j) { |
| 185 float Val = ValsF32[i]; |
| 186 if (j > 0) |
| 187 Val = -Val; |
| 188 testValue<float>(Val, TotalTests, Passes, Failures); |
| 189 COMPARE(castBits, float, uint32_t, Val); |
| 190 } |
| 191 } |
| 192 for (size_t i = 0; i < NumValsF64; ++i) { |
| 193 for (unsigned j = 0; j < 2; ++j) { |
| 194 double Val = ValsF64[i]; |
| 195 if (j > 0) |
| 196 Val = -Val; |
| 197 testValue<double>(Val, TotalTests, Passes, Failures); |
| 198 COMPARE(castBits, double, uint64_t, Val); |
| 199 } |
| 200 } |
| 201 |
| 202 std::cout << "TotalTests=" << TotalTests << " Passes=" << Passes |
| 203 << " Failures=" << Failures << "\n"; |
| 204 return Failures; |
| 205 } |
| 206 |
| 207 //////////////////////////////////////////////////////////////// |
| 208 |
| 209 // The following are helper definitions that should be part of the |
| 210 // Subzero runtime. |
| 211 |
| 212 extern "C" { |
| 213 uint32_t cvtdtoui32(double a) { return (uint32_t)a; } |
| 214 uint32_t cvtftoui32(float a) { return (uint32_t)a; } |
| 215 int64_t cvtdtosi64(double a) { return (int64_t)a; } |
| 216 int64_t cvtftosi64(float a) { return (int64_t)a; } |
| 217 uint64_t cvtdtoui64(double a) { return (uint64_t)a; } |
| 218 uint64_t cvtftoui64(float a) { return (uint64_t)a; } |
| 219 float cvtui64tof(uint64_t a) { return (float)a; } |
| 220 double cvtui64tod(uint64_t a) { return (double)a; } |
| 221 float cvtsi64tof(int64_t a) { return (float)a; } |
| 222 float cvtui32tof(uint32_t a) { return (float)a; } |
| 223 double cvtui32tod(uint32_t a) { return (double)a; } |
| 224 double cvtsi64tod(int64_t a) { return (double)a; } |
| 225 } |
OLD | NEW |