| /* |
| * Copyright 2020 The Emscripten Authors. All rights reserved. |
| * Emscripten is available under two separate licenses, the MIT license and the |
| * University of Illinois/NCSA Open Source License. Both these licenses can be |
| * found in the LICENSE file. |
| */ |
| #pragma once |
| |
| #include <stdio.h> |
| #include <math.h> |
| #include <time.h> |
| #include <inttypes.h> |
| #include <float.h> |
| #include <assert.h> |
| #include <string.h> |
| |
| #ifdef __EMSCRIPTEN__ |
| #include <emscripten/emscripten.h> |
| #define align1_int emscripten_align1_int |
| #define align1_int64 emscripten_align1_int64 |
| #define align1_float emscripten_align1_float |
| #define align1_double emscripten_align1_double |
| #else |
| #define align1_int64 int64_t |
| #define align1_int int |
| #define align1_float float |
| #define align1_double double |
| #endif |
| |
| // Recasts floating point representation of f to an integer. |
| uint32_t fcastu(float f) { return *(uint32_t*)&f; } |
| uint64_t dcastu(double f) { return *(uint64_t*)&f; } |
| float ucastf(uint32_t t) { return *(float*)&t; } |
| double ucastd(uint64_t t) { return *(double*)&t; } |
| |
| // Data used in test. Store them global and access via a getter to confuse optimizer to not "solve" the whole test suite at compile-time, |
| // so that the operation will actually be performed at runtime, and not at compile-time. (Testing the capacity of the compiler to perform |
| // SIMD ops at compile-time would be interesting as well, but that's for another test) |
| float interesting_floats_[] = { -INFINITY, -FLT_MAX, -2.5f, -1.5f, -1.4f, -1.0f, -0.5f, -0.2f, -FLT_MIN, -0.f, 0.f, |
| 1.401298464e-45f, FLT_MIN, 0.3f, 0.5f, 0.8f, 1.0f, 1.5f, 2.5f, 3.5f, 3.6f, FLT_MAX, INFINITY, NAN, |
| ucastf(0x01020304), ucastf(0x80000000), ucastf(0x7FFFFFFF), ucastf(0xFFFFFFFF) |
| }; |
| |
| double interesting_doubles_[] = { -INFINITY, -FLT_MAX, -2.5, -1.5, -1.4, -1.0, -0.5, -0.2, -FLT_MIN, -0.0, 0.0, |
| 1.401298464e-45, FLT_MIN, 0.3, 0.5, 0.8, 1.0, 1.5, 2.5, 3.5, 3.6, FLT_MAX, INFINITY, NAN, |
| ucastd(0x0102030405060708ULL), ucastd(0x8000000000000000ULL), |
| ucastd(0x7FFFFFFFFFFFFFFFULL), ucastd(0xFFFFFFFFFFFFFFFFULL) |
| }; |
| |
| uint32_t interesting_ints_[] = { 0, 1, 2, 3, 0x01020304, 0x10203040, 0x7FFFFFFF, 0xFFFFFFFF, 0xFFFFFFFE, 0x12345678, 0x9ABCDEF1, 0x80000000, |
| 0x80808080, 0x7F7F7F7F, 0x01010101, 0x11111111, 0x20202020, 0x0F0F0F0F, 0xF0F0F0F0, |
| fcastu(-INFINITY), fcastu(-FLT_MAX), fcastu(-2.5f), fcastu(-1.5f), fcastu(-1.4f), fcastu(-1.0f), fcastu(-0.5f), |
| fcastu(-0.2f), fcastu(-FLT_MIN), 0xF9301AB9, 0x0039AB12, 0x19302BCD, |
| fcastu(1.401298464e-45f), fcastu(FLT_MIN), fcastu(0.3f), fcastu(0.5f), fcastu(0.8f), fcastu(1.0f), fcastu(1.5f), |
| fcastu(2.5f), fcastu(3.5f), fcastu(3.6f), fcastu(FLT_MAX), fcastu(INFINITY), fcastu(NAN) }; |
| |
| bool always_true() { return time(NULL) != 0; } // This function always returns true, but the compiler should not know this. |
| |
| bool IsNan(float f) { return (fcastu(f) << 1) > 0xFF000000u; } |
| |
| // Replaces all occurrences of 'src' in string 'str' with 'dst', operating in place. strlen(dst) <= strlen(src). |
| void contract_inplace(char *str, const char *src, const char *dst) |
| { |
| int dstLen = strlen(dst); |
| int srcLen = strlen(src); |
| int diff = srcLen - dstLen; |
| assert(diff >= 0); |
| |
| while(true) |
| { |
| char *pos = strstr(str, src); |
| if (!pos) return; |
| str = pos; |
| strcpy(pos, dst); |
| pos += dstLen; |
| strcpy(pos, pos + diff); |
| } |
| } |
| |
| // sprintf standard does not allow controlling how many leading zeros to use |
| // for printing out the exponent, and different compilers give different |
| // values. Perform a canonicalization step that enforces the printouts are |
| // the same. |
| void CanonicalizeStringComparisons(char *s) |
| { |
| contract_inplace(s, "e+00", "e+"); |
| contract_inplace(s, "e-00", "e-"); |
| contract_inplace(s, "e+0", "e+"); |
| contract_inplace(s, "e-0", "e-"); |
| contract_inplace(s, "1.#INF", "inf"); |
| } |
| |
| // Global test state that is used per-test to determine whether to validate the state of exact NaN bits |
| // in specific functions. |
| extern bool testNaNBits; |
| |
| char *SerializeFloat(float f, char *dstStr, bool approximate = false) { |
| if (IsNan(f)) { |
| uint32_t u = fcastu(f); |
| int numChars = testNaNBits ? sprintf(dstStr, "NaN(0x%8X)", (unsigned int)u) : sprintf(dstStr, "NaN"); |
| return dstStr + numChars; |
| } else { |
| if (approximate > 0) { |
| if (fabs(f) < FLT_MIN) // Flush denormals to zero (for _mm_rcp_ps) |
| sprintf(dstStr, "%f", copysign(0.f, f)); |
| else if (fabs(f) >= 2.6e22f) // Flush large numbers to infinity (for _mm_rsqrt_ps) |
| sprintf(dstStr, "%f", copysign(INFINITY, f)); |
| else |
| sprintf(dstStr, "%.2g", f); |
| } else { |
| sprintf(dstStr, "%.9g", f); |
| } |
| CanonicalizeStringComparisons(dstStr); |
| return dstStr + strlen(dstStr); |
| } |
| } |
| |
| char *SerializeDouble(double f, char *dstStr) { |
| if (IsNan(f)) { |
| uint64_t u = dcastu(f); |
| int numChars = testNaNBits ? sprintf(dstStr, "NaN(0x%08X%08X)", (unsigned int)(u>>32), (unsigned int)u) : sprintf(dstStr, "NaN"); |
| return dstStr + numChars; |
| } else { |
| sprintf(dstStr, "%.17g", f); |
| CanonicalizeStringComparisons(dstStr); |
| return dstStr + strlen(dstStr); |
| } |
| } |
| |
| void tostr(__m128 *m, char *outstr) { |
| union { __m128 m; float val[4]; } u; |
| u.m = *m; |
| char s[4][32]; |
| SerializeFloat(u.val[0], s[0]); |
| SerializeFloat(u.val[1], s[1]); |
| SerializeFloat(u.val[2], s[2]); |
| SerializeFloat(u.val[3], s[3]); |
| sprintf(outstr, "[%s,%s,%s,%s]", s[3], s[2], s[1], s[0]); |
| } |
| |
| void tostr_approx(__m128 *m, char *outstr, bool approximate) { |
| union { __m128 m; float val[4]; } u; |
| u.m = *m; |
| char s[4][32]; |
| SerializeFloat(u.val[0], s[0], approximate); |
| SerializeFloat(u.val[1], s[1], approximate); |
| SerializeFloat(u.val[2], s[2], approximate); |
| SerializeFloat(u.val[3], s[3], approximate); |
| sprintf(outstr, "[%s,%s,%s,%s]", s[3], s[2], s[1], s[0]); |
| } |
| |
| void tostr(__m128i *m, char *outstr) { |
| union { __m128i m; uint32_t val[4]; } u; |
| u.m = *m; |
| sprintf(outstr, "[0x%08X,0x%08X,0x%08X,0x%08X]", u.val[3], u.val[2], u.val[1], u.val[0]); |
| } |
| |
| #ifdef __SSE2__ |
| |
| void tostr(__m128d *m, char *outstr) { |
| union { __m128d m; double val[2]; } u; |
| u.m = *m; |
| char s[2][64]; |
| SerializeDouble(u.val[0], s[0]); |
| SerializeDouble(u.val[1], s[1]); |
| sprintf(outstr, "[%s,%s]", s[1], s[0]); |
| } |
| |
| __m128i ExtractInRandomOrder(uint32_t *arr, int i, int n, int prime) { |
| return _mm_set_epi32(arr[(i*prime)%n], arr[((i+1)*prime)%n], arr[((i+2)*prime)%n], arr[((i+3)*prime)%n]); |
| } |
| |
| __m128d ExtractInRandomOrder(double *arr, int i, int n, int prime) { |
| return _mm_set_pd(arr[(i*prime)%n], arr[((i+1)*prime)%n]); |
| } |
| #endif |
| |
| void tostr(align1_int *m, char *outstr) { |
| sprintf(outstr, "0x%08X", *m); |
| } |
| |
| void tostr(align1_int64 *m, char *outstr) { |
| sprintf(outstr, "0x%08X%08X", (int)(*m >> 32), (int)*m); |
| } |
| |
| void tostr(align1_float *m, char *outstr) { |
| SerializeFloat(*m, outstr); |
| } |
| |
| void tostr(align1_double *m, char *outstr) { |
| SerializeDouble(*m, outstr); |
| } |
| |
| void tostr(align1_double *m, int numElems, char *outstr) { |
| char s[2][64]; |
| for(int i = 0; i < numElems; ++i) |
| SerializeDouble(m[i], s[i]); |
| switch(numElems) { |
| case 1: sprintf(outstr, "{%s}", s[0]); break; |
| case 2: sprintf(outstr, "{%s,%s}", s[0], s[1]); break; |
| } |
| } |
| |
| void tostr(align1_float *m, int numElems, char *outstr) { |
| char s[4][64]; |
| for(int i = 0; i < numElems; ++i) |
| SerializeFloat(m[i], s[i]); |
| switch(numElems) { |
| case 1: sprintf(outstr, "{%s}", s[0]); break; |
| case 2: sprintf(outstr, "{%s,%s}", s[0], s[1]); break; |
| case 3: sprintf(outstr, "{%s,%s,%s}", s[0], s[1], s[2]); break; |
| case 4: sprintf(outstr, "{%s,%s,%s,%s}", s[0], s[1], s[2], s[3]); break; |
| } |
| } |
| |
| void tostr(align1_int *s, int numElems, char *outstr) { |
| switch(numElems) { |
| case 1: sprintf(outstr, "{0x%08X}", s[0]); break; |
| case 2: sprintf(outstr, "{0x%08X,0x%08X}", s[0], s[1]); break; |
| case 3: sprintf(outstr, "{0x%08X,0x%08X,0x%08X}", s[0], s[1], s[2]); break; |
| case 4: sprintf(outstr, "{0x%08X,0x%08X,0x%08X,0x%08X}", s[0], s[1], s[2], s[3]); break; |
| } |
| } |
| |
| void tostr(align1_int64 *m, int numElems, char *outstr) { |
| switch(numElems) { |
| case 1: sprintf(outstr, "{0x%08X%08X}", (int)(*m >> 32), (int)*m); break; |
| case 2: sprintf(outstr, "{0x%08X%08X,0x%08X%08X}", (int)(*m >> 32), (int)*m, (int)(m[1] >> 32), (int)m[1]); |
| } |
| } |
| |
| // Accessors to the test data in a way that the compiler can't optimize at compile-time. |
| __attribute__((noinline)) float *get_interesting_floats() { |
| return always_true() ? interesting_floats_ : 0; |
| } |
| |
| __attribute__((noinline)) uint32_t *get_interesting_ints() { |
| return always_true() ? interesting_ints_ : 0; |
| } |
| |
| __attribute__((noinline)) double *get_interesting_doubles() { |
| return always_true() ? interesting_doubles_ : 0; |
| } |
| |
| __m128 ExtractFloatInRandomOrder(float *arr, int i, int n, int prime) { |
| return _mm_set_ps(arr[(i*prime)%n], arr[((i+1)*prime)%n], arr[((i+2)*prime)%n], arr[((i+3)*prime)%n]); |
| } |
| |
| #ifdef __SSE2__ |
| __m128d ExtractDoubleInRandomOrder(double *arr, int i, int n, int prime) { |
| return _mm_set_pd(arr[(i*prime)%n], arr[((i+1)*prime)%n]); |
| } |
| #endif |
| |
| __m128 ExtractIntInRandomOrder(unsigned int *arr, int i, int n, int prime) { |
| return _mm_set_ps(*(float*)&arr[(i*prime)%n], *(float*)&arr[((i+1)*prime)%n], *(float*)&arr[((i+2)*prime)%n], *(float*)&arr[((i+3)*prime)%n]); |
| } |
| |
| #define E1(arr, i, n) ExtractFloatInRandomOrder(arr, i, n, 1) |
| #define E2(arr, i, n) ExtractFloatInRandomOrder(arr, i, n, 1787) |
| |
| #define E1_Double(arr, i, n) ExtractDoubleInRandomOrder(arr, i, n, 1) |
| #define E2_Double(arr, i, n) ExtractDoubleInRandomOrder(arr, i, n, 1787) |
| |
| #define E1_Int(arr, i, n) ExtractIntInRandomOrder(arr, i, n, 1) |
| #define E2_Int(arr, i, n) ExtractIntInRandomOrder(arr, i, n, 1787) |
| |
| #define M128i_M128i_M128i(func) \ |
| for(int i = 0; i < numInterestingInts / 4; ++i) \ |
| for(int k = 0; k < 4; ++k) \ |
| for(int j = 0; j < numInterestingInts / 4; ++j) \ |
| { \ |
| __m128i m1 = (__m128i)E1_Int(interesting_ints, i*4+k, numInterestingInts); \ |
| __m128i m2 = (__m128i)E2_Int(interesting_ints, j*4, numInterestingInts); \ |
| __m128i ret = func(m1, m2); \ |
| /* a op b */ \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&m2, str2); \ |
| char str3[256]; tostr(&ret, str3); \ |
| printf("%s(%s, %s) = %s\n", #func, str, str2, str3); \ |
| /* b op a */ \ |
| ret = func(m2, m1); \ |
| tostr(&m1, str); \ |
| tostr(&m2, str2); \ |
| tostr(&ret, str3); \ |
| printf("%s(%s, %s) = %s\n", #func, str, str2, str3); \ |
| } |
| |
| #define Ret_M128_Tint_body(Ret_type, func, Tint) \ |
| for(int i = 0; i < numInterestingFloats / 4; ++i) \ |
| for(int k = 0; k < 4; ++k) \ |
| { \ |
| __m128 m1 = E1(interesting_floats, i*4+k, numInterestingFloats); \ |
| Ret_type ret = func(m1, Tint); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&ret, str2); \ |
| printf("%s(%s, %d) = %s\n", #func, str, Tint, str2); \ |
| } |
| |
| #define Ret_M128d_Tint_body(Ret_type, func, Tint) \ |
| for(int i = 0; i < numInterestingDoubles / 2; ++i) \ |
| for(int k = 0; k < 2; ++k) \ |
| { \ |
| __m128d m1 = E1_Double(interesting_doubles, i*2+k, numInterestingDoubles); \ |
| Ret_type ret = func(m1, Tint); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&ret, str2); \ |
| printf("%s(%s, %d) = %s\n", #func, str, Tint, str2); \ |
| } |
| |
| #define Ret_M128i_Tint_body(Ret_type, func, Tint) \ |
| for(int i = 0; i < numInterestingInts / 4; ++i) \ |
| for(int k = 0; k < 4; ++k) \ |
| { \ |
| __m128i m1 = (__m128i)E1_Int(interesting_ints, i*4+k, numInterestingInts); \ |
| Ret_type ret = func(m1, Tint); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&ret, str2); \ |
| printf("%s(%s, %d) = %s\n", #func, str, Tint, str2); \ |
| } |
| |
| #define Ret_M128i_int_Tint_body(Ret_type, func, Tint) \ |
| for(int i = 0; i < numInterestingInts / 4; ++i) \ |
| for(int j = 0; j < numInterestingInts; ++j) \ |
| for(int k = 0; k < 4; ++k) \ |
| { \ |
| __m128i m1 = (__m128i)E1_Int(interesting_ints, i*4+k, numInterestingInts); \ |
| Ret_type ret = func(m1, interesting_ints[j], Tint); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&ret, str2); \ |
| printf("%s(%s, 0x%08X, %d) = %s\n", #func, str, interesting_ints[j], Tint, str2); \ |
| } |
| |
| #define Ret_M128d_M128d_Tint_body(Ret_type, func, Tint) \ |
| for(int i = 0; i < numInterestingDoubles / 2; ++i) \ |
| for(int k = 0; k < 2; ++k) \ |
| for(int j = 0; j < numInterestingDoubles / 2; ++j) \ |
| { \ |
| __m128d m1 = E1_Double(interesting_doubles, i*2+k, numInterestingDoubles); \ |
| __m128d m2 = E2_Double(interesting_doubles, j*2, numInterestingDoubles); \ |
| Ret_type ret = func(m1, m2, Tint); \ |
| /* a op b */ \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&m2, str2); \ |
| char str3[256]; tostr(&ret, str3); \ |
| printf("%s(%s, %s, %d) = %s\n", #func, str, str2, Tint, str3); \ |
| /* b op a */ \ |
| ret = func(m2, m1, Tint); \ |
| tostr(&m1, str); \ |
| tostr(&m2, str2); \ |
| tostr(&ret, str3); \ |
| printf("%s(%s, %s, %d) = %s\n", #func, str, str2, Tint, str3); \ |
| } |
| |
| #define Ret_M128i_M128i_Tint_body(Ret_type, func, Tint) \ |
| for(int i = 0; i < numInterestingInts / 4; ++i) \ |
| for(int k = 0; k < 4; ++k) \ |
| for(int j = 0; j < numInterestingInts / 4; ++j) \ |
| { \ |
| __m128i m1 = (__m128i)E1_Int(interesting_ints, i*4+k, numInterestingInts); \ |
| __m128i m2 = (__m128i)E2_Int(interesting_ints, j*4, numInterestingInts); \ |
| Ret_type ret = func(m1, m2, Tint); \ |
| /* a op b */ \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&m2, str2); \ |
| char str3[256]; tostr(&ret, str3); \ |
| printf("%s(%s, %s, %d) = %s\n", #func, str, str2, Tint, str3); \ |
| /* b op a */ \ |
| ret = func(m2, m1, Tint); \ |
| tostr(&m1, str); \ |
| tostr(&m2, str2); \ |
| tostr(&ret, str3); \ |
| printf("%s(%s, %s, %d) = %s\n", #func, str, str2, Tint, str3); \ |
| } |
| |
| #define Ret_M128_M128_Tint_body(Ret_type, func, Tint) \ |
| for(int i = 0; i < numInterestingFloats / 4; ++i) \ |
| for(int k = 0; k < 4; ++k) \ |
| for(int j = 0; j < numInterestingFloats / 4; ++j) \ |
| { \ |
| __m128 m1 = E1(interesting_floats, i*4+k, numInterestingFloats); \ |
| __m128 m2 = E2(interesting_floats, j*4, numInterestingFloats); \ |
| Ret_type ret = func(m1, m2, Tint); \ |
| /* a op b */ \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&m2, str2); \ |
| char str3[256]; tostr(&ret, str3); \ |
| printf("%s(%s, %s, %d) = %s\n", #func, str, str2, Tint, str3); \ |
| /* b op a */ \ |
| ret = func(m2, m1, Tint); \ |
| tostr(&m1, str); \ |
| tostr(&m2, str2); \ |
| tostr(&ret, str3); \ |
| printf("%s(%s, %s, %d) = %s\n", #func, str, str2, Tint, str3); \ |
| } |
| |
| #define const_int8_unroll(Ret_type, F, func) \ |
| F(Ret_type, func, 0); \ |
| F(Ret_type, func, 1); \ |
| F(Ret_type, func, 2); \ |
| F(Ret_type, func, 3); \ |
| F(Ret_type, func, 5); \ |
| F(Ret_type, func, 7); \ |
| F(Ret_type, func, 11); \ |
| F(Ret_type, func, 13); \ |
| F(Ret_type, func, 15); \ |
| F(Ret_type, func, 16); \ |
| F(Ret_type, func, 17); \ |
| F(Ret_type, func, 23); \ |
| F(Ret_type, func, 29); \ |
| F(Ret_type, func, 31); \ |
| F(Ret_type, func, 37); \ |
| F(Ret_type, func, 43); \ |
| F(Ret_type, func, 47); \ |
| F(Ret_type, func, 59); \ |
| F(Ret_type, func, 127); \ |
| F(Ret_type, func, 128); \ |
| F(Ret_type, func, 191); \ |
| F(Ret_type, func, 254); \ |
| F(Ret_type, func, 255); |
| |
| #define const_int5_full_unroll(Ret_type, F, func) \ |
| F(Ret_type, func, 0); \ |
| F(Ret_type, func, 1); \ |
| F(Ret_type, func, 2); \ |
| F(Ret_type, func, 3); \ |
| F(Ret_type, func, 4); \ |
| F(Ret_type, func, 5); \ |
| F(Ret_type, func, 6); \ |
| F(Ret_type, func, 7); \ |
| F(Ret_type, func, 8); \ |
| F(Ret_type, func, 9); \ |
| F(Ret_type, func, 10); \ |
| F(Ret_type, func, 11); \ |
| F(Ret_type, func, 12); \ |
| F(Ret_type, func, 13); \ |
| F(Ret_type, func, 14); \ |
| F(Ret_type, func, 15); \ |
| F(Ret_type, func, 16); \ |
| F(Ret_type, func, 17); \ |
| F(Ret_type, func, 18); \ |
| F(Ret_type, func, 19); \ |
| F(Ret_type, func, 20); \ |
| F(Ret_type, func, 21); \ |
| F(Ret_type, func, 22); \ |
| F(Ret_type, func, 23); \ |
| F(Ret_type, func, 24); \ |
| F(Ret_type, func, 25); \ |
| F(Ret_type, func, 26); \ |
| F(Ret_type, func, 27); \ |
| F(Ret_type, func, 28); \ |
| F(Ret_type, func, 29); \ |
| F(Ret_type, func, 30); \ |
| F(Ret_type, func, 31); |
| |
| #define Ret_M128_Tint(Ret_type, func) const_int8_unroll(Ret_type, Ret_M128_Tint_body, func) |
| #define Ret_M128d_Tint(Ret_type, func) const_int8_unroll(Ret_type, Ret_M128d_Tint_body, func) |
| #define Ret_M128i_Tint(Ret_type, func) const_int8_unroll(Ret_type, Ret_M128i_Tint_body, func) |
| #define Ret_M128i_int_Tint(Ret_type, func) const_int8_unroll(Ret_type, Ret_M128i_int_Tint_body, func) |
| #define Ret_M128i_M128i_Tint(Ret_type, func) const_int8_unroll(Ret_type, Ret_M128i_M128i_Tint_body, func) |
| #define Ret_M128d_M128d_Tint(Ret_type, func) const_int8_unroll(Ret_type, Ret_M128d_M128d_Tint_body, func) |
| #define Ret_M128d_M128d_Tint_5bits(Ret_type, func) const_int5_full_unroll(Ret_type, Ret_M128d_M128d_Tint_body, func) |
| #define Ret_M128_M128_Tint(Ret_type, func) const_int8_unroll(Ret_type, Ret_M128_M128_Tint_body, func) |
| #define Ret_M128_M128_Tint_5bits(Ret_type, func) const_int5_full_unroll(Ret_type, Ret_M128_M128_Tint_body, func) |
| |
| #define Ret_M128d_M128d(Ret_type, func) \ |
| for(int i = 0; i < numInterestingDoubles / 2; ++i) \ |
| for(int k = 0; k < 2; ++k) \ |
| for(int j = 0; j < numInterestingDoubles / 2; ++j) \ |
| { \ |
| __m128d m1 = E1_Double(interesting_doubles, i*2+k, numInterestingDoubles); \ |
| __m128d m2 = E2_Double(interesting_doubles, j*2, numInterestingDoubles); \ |
| Ret_type ret = func(m1, m2); \ |
| /* a op b */ \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&m2, str2); \ |
| char str3[256]; tostr(&ret, str3); \ |
| printf("%s(%s, %s) = %s\n", #func, str, str2, str3); \ |
| /* b op a */ \ |
| ret = func(m2, m1); \ |
| tostr(&m1, str); \ |
| tostr(&m2, str2); \ |
| tostr(&ret, str3); \ |
| printf("%s(%s, %s) = %s\n", #func, str, str2, str3); \ |
| } |
| |
| #define Ret_M128d_M128d_M128d(Ret_type, func) \ |
| for(int i = 0; i < numInterestingDoubles / 2; ++i) \ |
| for(int k = 0; k < 2; ++k) \ |
| for(int j = 0; j < numInterestingDoubles / 2; ++j) \ |
| for(int l = 0; l < numInterestingDoubles / 2; ++l) \ |
| { \ |
| __m128d m1 = E1_Double(interesting_doubles, i*2+k, numInterestingDoubles); \ |
| __m128d m2 = E2_Double(interesting_doubles, j*2, numInterestingDoubles); \ |
| __m128d m3 = E1_Double(interesting_doubles, l*2, numInterestingDoubles); \ |
| Ret_type ret = func(m1, m2, m3); \ |
| /* a, b, c */ \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&m2, str2); \ |
| char str3[256]; tostr(&m3, str3); \ |
| char str4[256]; tostr(&ret, str4); \ |
| printf("%s(%s, %s, %s) = %s\n", #func, str, str2, str3, str4); \ |
| /* b, c, a */ \ |
| ret = func(m2, m3, m1); \ |
| tostr(&m1, str); \ |
| tostr(&m2, str2); \ |
| tostr(&m3, str3); \ |
| tostr(&ret, str4); \ |
| printf("%s(%s, %s, %s) = %s\n", #func, str, str2, str3, str4); \ |
| /* c, a, b */ \ |
| ret = func(m3, m1, m2); \ |
| tostr(&m1, str); \ |
| tostr(&m2, str2); \ |
| tostr(&m3, str3); \ |
| tostr(&ret, str4); \ |
| printf("%s(%s, %s, %s) = %s\n", #func, str, str2, str3, str4); \ |
| } |
| |
| #define Ret_M128d_M128(Ret_type, func) \ |
| for(int i = 0; i < numInterestingDoubles / 2; ++i) \ |
| for(int k = 0; k < 2; ++k) \ |
| for(int j = 0; j < numInterestingDoubles / 2; ++j) \ |
| { \ |
| __m128d m1 = E1_Double(interesting_doubles, i*2+k, numInterestingDoubles); \ |
| __m128 m2 = E2(interesting_floats, i*4+k, numInterestingFloats); \ |
| Ret_type ret = func(m1, m2); \ |
| /* a op b */ \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&m2, str2); \ |
| char str3[256]; tostr(&ret, str3); \ |
| printf("%s(%s, %s) = %s\n", #func, str, str2, str3); \ |
| } |
| |
| #define Ret_M128d_int(Ret_type, func) \ |
| for(int i = 0; i < numInterestingDoubles / 2; ++i) \ |
| for(int k = 0; k < 2; ++k) \ |
| for(int j = 0; j < numInterestingInts; ++j) \ |
| { \ |
| __m128d m1 = E1_Double(interesting_doubles, i*2+k, numInterestingDoubles); \ |
| int m2 = interesting_ints[j]; \ |
| Ret_type ret = func(m1, m2); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&m2, str2); \ |
| char str3[256]; tostr(&ret, str3); \ |
| printf("%s(%s, %s) = %s\n", #func, str, str2, str3); \ |
| } |
| |
| #define Ret_M128d_int64(Ret_type, func) \ |
| for(int i = 0; i < numInterestingDoubles / 2; ++i) \ |
| for(int k = 0; k < 2; ++k) \ |
| for(int j = 0; j < numInterestingInts; ++j) \ |
| for(int l = 0; l < numInterestingInts; ++l) \ |
| { \ |
| __m128d m1 = E1_Double(interesting_doubles, i*2+k, numInterestingDoubles); \ |
| int64_t m2 = (int64_t)(((uint64_t)interesting_ints[j]) << 32 | (uint64_t)interesting_ints[l]); \ |
| Ret_type ret = func(m1, m2); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&m2, str2); \ |
| char str3[256]; tostr(&ret, str3); \ |
| printf("%s(%s, %s) = %s\n", #func, str, str2, str3); \ |
| } |
| |
| #define Ret_M128d(Ret_type, func) \ |
| for(int i = 0; i < numInterestingDoubles / 2; ++i) \ |
| for(int k = 0; k < 2; ++k) \ |
| { \ |
| __m128d m1 = E1_Double(interesting_doubles, i*2+k, numInterestingDoubles); \ |
| Ret_type ret = func(m1); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&ret, str2); \ |
| printf("%s(%s) = %s\n", #func, str, str2); \ |
| } |
| |
| #define Ret_DoublePtr(Ret_type, func, numElemsAccessed, inc) \ |
| for(int i = 0; i+numElemsAccessed <= numInterestingDoubles; i += inc) \ |
| { \ |
| double *ptr = interesting_doubles + i; \ |
| Ret_type ret = func(ptr); \ |
| char str[256]; tostr(ptr, numElemsAccessed, str); \ |
| char str2[256]; tostr(&ret, str2); \ |
| printf("%s(%s) = %s\n", #func, str, str2); \ |
| } |
| |
| #define Ret_DoublePtr_M128i(Ret_type, func, numElemsAccessed, inc) \ |
| for(int i = 0; i+numElemsAccessed <= numInterestingDoubles; i += inc) \ |
| for(int j = 0; j < numInterestingInts / 4; ++j) \ |
| { \ |
| double *ptr = interesting_doubles + i; \ |
| __m128i m1 = (__m128i)E2_Int(interesting_ints, j*4, numInterestingInts); \ |
| Ret_type ret = func(ptr, m1); \ |
| char str[256]; tostr(ptr, numElemsAccessed, str); \ |
| char str2[256]; tostr(&ret, str2); \ |
| printf("%s(%s) = %s\n", #func, str, str2); \ |
| } |
| |
| float tempOutFloatStore[16]; |
| float *getTempOutFloatStore(int alignmentBytes) { |
| memset(tempOutFloatStore, 0, sizeof(tempOutFloatStore)); |
| uintptr_t addr = (uintptr_t)tempOutFloatStore; |
| addr = (addr + alignmentBytes - 1) & ~(alignmentBytes-1); |
| return (float*)addr; |
| } |
| |
| int *getTempOutIntStore(int alignmentBytes) { return (int*)getTempOutFloatStore(alignmentBytes); } |
| double *getTempOutDoubleStore(int alignmentBytes) { return (double*)getTempOutFloatStore(alignmentBytes); } |
| |
| #define void_OutFloatPtr_M128(func, Ptr_type, numBytesWritten, alignmentBytes) \ |
| for(int i = 0; i < numInterestingFloats / 4; ++i) \ |
| for(int offset = 0; offset < numBytesWritten; offset += alignmentBytes) \ |
| for(int k = 0; k < 4; ++k) \ |
| { \ |
| uintptr_t base = (uintptr_t)getTempOutFloatStore(16); \ |
| __m128 m1 = E1(interesting_floats, i*4+k, numInterestingFloats); \ |
| align1_float *out = (align1_float*)(base + offset); \ |
| func((Ptr_type)out, m1); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(out, numBytesWritten/sizeof(float), str2); \ |
| printf("%s(p:align=%d, %s) = %s\n", #func, offset, str, str2); \ |
| } |
| |
| #define void_OutFloatPtr_M128i_M128(func, Ptr_type, numBytesWritten, alignmentBytes) \ |
| for(int i = 0; i < numInterestingFloats / 4; ++i) \ |
| for(int j = 0; j < numInterestingInts / 4; ++j) \ |
| for(int offset = 0; offset < numBytesWritten; offset += alignmentBytes) \ |
| for(int k = 0; k < 4; ++k) \ |
| { \ |
| uintptr_t base = (uintptr_t)getTempOutFloatStore(16); \ |
| __m128i m1 = (__m128i)E1_Int(interesting_ints, j*4, numInterestingInts); \ |
| __m128 m2 = E1(interesting_floats, i*4+k, numInterestingFloats); \ |
| align1_float *out = (align1_float*)(base + offset); \ |
| func((Ptr_type)out, m1, m2); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&m2, str2); \ |
| char str3[256]; tostr(out, numBytesWritten/sizeof(float), str3); \ |
| printf("%s(p:align=%d, %s, %s) = %s\n", #func, offset, str, str2, str3); \ |
| } |
| |
| #define void_OutDoublePtr_M128d(func, Ptr_type, numBytesWritten, alignmentBytes) \ |
| for(int i = 0; i < numInterestingDoubles / 2; ++i) \ |
| for(int offset = 0; offset < numBytesWritten; offset += alignmentBytes) \ |
| for(int k = 0; k < 2; ++k) \ |
| { \ |
| uintptr_t base = (uintptr_t)getTempOutDoubleStore(16); \ |
| __m128d m1 = E1_Double(interesting_doubles, i*2+k, numInterestingDoubles); \ |
| align1_double *out = (align1_double*)(base + offset); \ |
| func((Ptr_type)out, m1); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(out, numBytesWritten/sizeof(double), str2); \ |
| printf("%s(p:align=%d, %s) = %s\n", #func, offset, str, str2); \ |
| } |
| |
| #define void_OutDoublePtr_M128i_M128d(func, Ptr_type, numBytesWritten, alignmentBytes) \ |
| for(int i = 0; i < numInterestingDoubles / 2; ++i) \ |
| for(int j = 0; j < numInterestingInts / 4; ++j) \ |
| for(int offset = 0; offset < numBytesWritten; offset += alignmentBytes) \ |
| for(int k = 0; k < 2; ++k) \ |
| { \ |
| uintptr_t base = (uintptr_t)getTempOutDoubleStore(16); \ |
| __m128i m1 = (__m128i)E1_Int(interesting_ints, j*4, numInterestingInts); \ |
| __m128d m2 = E1_Double(interesting_doubles, i*2+k, numInterestingDoubles); \ |
| align1_double *out = (align1_double*)(base + offset); \ |
| func((Ptr_type)out, m1, m2); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&m2, str2); \ |
| char str3[256]; tostr(out, numBytesWritten/sizeof(double), str3); \ |
| printf("%s(p:align=%d, %s, %s) = %s\n", #func, offset, str, str2, str3); \ |
| } |
| |
| #define void_OutIntPtr_M128i(func, Ptr_type, numBytesWritten, alignmentBytes) \ |
| for(int i = 0; i < numInterestingInts / 4; ++i) \ |
| for(int offset = 0; offset < numBytesWritten; offset += alignmentBytes) \ |
| for(int k = 0; k < 4; ++k) \ |
| { \ |
| uintptr_t base = (uintptr_t)getTempOutIntStore(16); \ |
| __m128i m1 = (__m128i)E1_Int(interesting_ints, i*4+k, numInterestingInts); \ |
| align1_int *out = (align1_int*)(base + offset); \ |
| func((Ptr_type)out, m1); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(out, (numBytesWritten+sizeof(int)-1)/sizeof(int), str2); \ |
| printf("%s(p:align=%d, %s) = %s\n", #func, offset, str, str2); \ |
| } |
| |
| #define void_OutIntPtr_int(func, Ptr_type, numBytesWritten, alignmentBytes) \ |
| for(int i = 0; i < numInterestingInts; ++i) \ |
| for(int offset = 0; offset < numBytesWritten; offset += alignmentBytes) \ |
| for(int k = 0; k < 4; ++k) \ |
| { \ |
| uintptr_t base = (uintptr_t)getTempOutIntStore(16); \ |
| int m1 = interesting_ints[i]; \ |
| align1_int *out = (align1_int*)(base + offset); \ |
| func((Ptr_type)out, m1); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(out, numBytesWritten/sizeof(int), str2); \ |
| printf("%s(p:align=%d, %s) = %s\n", #func, offset, str, str2); \ |
| } |
| |
| #define void_OutIntPtr_int64(func, Ptr_type, numBytesWritten, alignmentBytes) \ |
| for(int i = 0; i < numInterestingInts; ++i) \ |
| for(int j = 0; j < numInterestingInts; ++j) \ |
| for(int offset = 0; offset < numBytesWritten; offset += alignmentBytes) \ |
| { \ |
| uintptr_t base = (uintptr_t)getTempOutIntStore(16); \ |
| int64_t m1 = (int64_t)(((uint64_t)interesting_ints[i]) << 32 | (uint64_t)interesting_ints[j]); \ |
| align1_int64 *out = (align1_int64*)(base + offset); \ |
| func((Ptr_type)out, m1); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(out, numBytesWritten/sizeof(int64_t), str2); \ |
| printf("%s(p:align=%d, %s) = %s\n", #func, offset, str, str2); \ |
| } |
| |
| #define void_M128i_M128i_OutIntPtr(func, Ptr_type, numBytesWritten, alignmentBytes) \ |
| for(int i = 0; i < numInterestingInts / 4; ++i) \ |
| for(int j = 0; j < numInterestingInts / 4; ++j) \ |
| for(int offset = 0; offset < numBytesWritten; offset += alignmentBytes) \ |
| for(int k = 0; k < 4; ++k) \ |
| { \ |
| uintptr_t base = (uintptr_t)getTempOutIntStore(16); \ |
| __m128i m1 = (__m128i)E1_Int(interesting_ints, i*4+k, numInterestingInts); \ |
| __m128i m2 = (__m128i)E2_Int(interesting_ints, j*4, numInterestingInts); \ |
| align1_int *out = (int*)(base + offset); \ |
| func(m1, m2, (Ptr_type)out); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&m2, str2); \ |
| char str3[256]; tostr(out, numBytesWritten/sizeof(int), str3); \ |
| printf("%s(%s, %s, p:align=%d) = %s\n", #func, str, str2, offset, str3); \ |
| } |
| |
| #define Ret_M128(Ret_type, func) \ |
| for(int i = 0; i < numInterestingFloats / 4; ++i) \ |
| for(int k = 0; k < 4; ++k) \ |
| { \ |
| __m128 m1 = E1(interesting_floats, i*4+k, numInterestingFloats); \ |
| Ret_type ret = func(m1); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&ret, str2); \ |
| printf("%s(%s) = %s\n", #func, str, str2); \ |
| } |
| |
| #define Ret_M128approx(Ret_type, func) \ |
| for(int i = 0; i < numInterestingFloats / 4; ++i) \ |
| for(int k = 0; k < 4; ++k) \ |
| { \ |
| __m128 m1 = E1(interesting_floats, i*4+k, numInterestingFloats); \ |
| Ret_type ret = func(m1); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr_approx(&ret, str2, true/*approximate*/); \ |
| printf("%s(%s) = %s\n", #func, str, str2); \ |
| } |
| |
| #define Ret_FloatPtr(Ret_type, func, numElemsAccessed, inc) \ |
| for(int i = 0; i+numElemsAccessed <= numInterestingFloats; i += inc) \ |
| { \ |
| float *ptr = interesting_floats + i; \ |
| Ret_type ret = func(ptr); \ |
| char str[256]; tostr(ptr, numElemsAccessed, str); \ |
| char str2[256]; tostr(&ret, str2); \ |
| printf("%s(%s) = %s\n", #func, str, str2); \ |
| } |
| |
| #define Ret_FloatPtr_M128i(Ret_type, func, numElemsAccessed, inc) \ |
| for(int i = 0; i+numElemsAccessed <= numInterestingFloats; i += inc) \ |
| for(int j = 0; j < numInterestingInts / 4; ++j) \ |
| { \ |
| float *ptr = interesting_floats + i; \ |
| __m128i m1 = (__m128i)E1_Int(interesting_ints, j*4, numInterestingInts); \ |
| Ret_type ret = func(ptr, m1); \ |
| char str[256]; tostr(ptr, numElemsAccessed, str); \ |
| char str2[256]; tostr(&ret, str2); \ |
| printf("%s(%s) = %s\n", #func, str, str2); \ |
| } |
| |
| #define Ret_Float4(Ret_type, func, inc) \ |
| for(int i = 0; i+4 <= numInterestingFloats; i += inc) \ |
| { \ |
| float *ptr = interesting_floats + i; \ |
| Ret_type ret = func(ptr[0], ptr[1], ptr[2], ptr[3]); \ |
| char str[256]; tostr(ptr, 4, str); \ |
| char str2[256]; tostr(&ret, str2); \ |
| printf("%s(%s) = %s\n", #func, str, str2); \ |
| } |
| |
| #define Ret_Float(Ret_type, func, inc) \ |
| for(int i = 0; i+1 <= numInterestingFloats; i += inc) \ |
| { \ |
| float *ptr = interesting_floats + i; \ |
| Ret_type ret = func(*ptr); \ |
| char str[256]; tostr(ptr, 1, str); \ |
| char str2[256]; tostr(&ret, str2); \ |
| printf("%s(%s) = %s\n", #func, str, str2); \ |
| } |
| |
| #define Ret_IntPtr(Ret_type, func, Ptr_type, numElemsAccessed, inc) \ |
| for(int i = 0; i+numElemsAccessed <= numInterestingInts; i += inc) \ |
| { \ |
| uint32_t *ptr = interesting_ints + i; \ |
| Ret_type ret = func((Ptr_type)ptr); \ |
| char str[256]; tostr((int*)ptr, numElemsAccessed, str); \ |
| char str2[256]; tostr(&ret, str2); \ |
| printf("%s(%s) = %s\n", #func, str, str2); \ |
| } |
| |
| #define Ret_M128_FloatPtr(Ret_type, func, Ptr_type, numElemsAccessed, inc) \ |
| for(int i = 0; i < numInterestingFloats / 4; ++i) \ |
| for(int k = 0; k < 4; ++k) \ |
| for(int j = 0; j+numElemsAccessed <= numInterestingFloats; j += inc) \ |
| { \ |
| __m128 m1 = E1(interesting_floats, i*4+k, numInterestingFloats); \ |
| float *ptr = interesting_floats + j; \ |
| Ret_type ret = func(m1, (Ptr_type)ptr); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(ptr, numElemsAccessed, str2); \ |
| char str3[256]; tostr(&ret, str3); \ |
| printf("%s(%s, %s) = %s\n", #func, str, str2, str3); \ |
| } |
| |
| #define Ret_M128d_DoublePtr(Ret_type, func, Ptr_type, numElemsAccessed, inc) \ |
| for(int i = 0; i < numInterestingDoubles / 2; ++i) \ |
| for(int k = 0; k < 2; ++k) \ |
| for(int j = 0; j+numElemsAccessed <= numInterestingDoubles; j += inc) \ |
| { \ |
| __m128d m1 = E1_Double(interesting_doubles, i*2+k, numInterestingDoubles); \ |
| double *ptr = interesting_doubles + j; \ |
| Ret_type ret = func(m1, (Ptr_type)ptr); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(ptr, numElemsAccessed, str2); \ |
| char str3[256]; tostr(&ret, str3); \ |
| printf("%s(%s, %s) = %s\n", #func, str, str2, str3); \ |
| } |
| |
| #define Ret_M128i(Ret_type, func) \ |
| for(int i = 0; i < numInterestingInts / 4; ++i) \ |
| for(int k = 0; k < 4; ++k) \ |
| { \ |
| __m128i m1 = (__m128i)E1_Int(interesting_ints, i*4+k, numInterestingInts); \ |
| Ret_type ret = func(m1); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&ret, str2); \ |
| printf("%s(%s) = %s\n", #func, str, str2); \ |
| } |
| |
| #define Ret_M128i_M128i(Ret_type, func) \ |
| for(int i = 0; i < numInterestingInts / 4; ++i) \ |
| for(int k = 0; k < 4; ++k) \ |
| for(int j = 0; j < numInterestingInts / 4; ++j) \ |
| { \ |
| __m128i m1 = (__m128i)E1_Int(interesting_ints, i*4+k, numInterestingInts); \ |
| __m128i m2 = (__m128i)E2_Int(interesting_ints, j*4, numInterestingInts); \ |
| Ret_type ret = func(m1, m2); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&m2, str2); \ |
| char str3[256]; tostr(&ret, str3); \ |
| printf("%s(%s, %s) = %s\n", #func, str, str2, str3); \ |
| } |
| |
| #define Ret_M128i_M128i_M128i(Ret_type, func) \ |
| for(int i = 0; i < numInterestingInts / 4; ++i) \ |
| for(int k = 0; k < 4; ++k) \ |
| for(int j = 0; j < numInterestingInts / 4; ++j) \ |
| for(int l = 0; l < numInterestingInts / 4; ++l) \ |
| { \ |
| __m128i m1 = (__m128i)E1_Int(interesting_ints, i*4+k, numInterestingInts); \ |
| __m128i m2 = (__m128i)E2_Int(interesting_ints, j*4, numInterestingInts); \ |
| __m128i m3 = (__m128i)E1_Int(interesting_ints, l*4, numInterestingInts); \ |
| Ret_type ret = func(m1, m2, m3); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&m2, str2); \ |
| char str3[256]; tostr(&m3, str3); \ |
| char str4[256]; tostr(&ret, str4); \ |
| printf("%s(%s, %s, %s) = %s\n", #func, str, str2, str3, str4); \ |
| } |
| |
| #define Ret_int(Ret_type, func) \ |
| for(int i = 0; i < numInterestingInts; ++i) \ |
| { \ |
| Ret_type ret = func(interesting_ints[i]); \ |
| char str[256]; tostr((int*)&interesting_ints[i], str); \ |
| char str2[256]; tostr(&ret, str2); \ |
| printf("%s(%s) = %s\n", #func, str, str2); \ |
| } |
| |
| #define Ret_int64(Ret_type, func) \ |
| for(int i = 0; i < numInterestingInts; ++i) \ |
| for(int j = 0; j < numInterestingInts; ++j) \ |
| { \ |
| int64_t m1 = (int64_t)(((uint64_t)interesting_ints[i]) << 32 | (uint64_t)interesting_ints[j]); \ |
| Ret_type ret = func(m1); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&ret, str2); \ |
| printf("%s(%s) = %s\n", #func, str, str2); \ |
| } |
| |
| #define Ret_M128_M128(Ret_type, func) \ |
| for(int i = 0; i < numInterestingFloats / 4; ++i) \ |
| for(int k = 0; k < 4; ++k) \ |
| for(int j = 0; j < numInterestingFloats / 4; ++j) \ |
| { \ |
| __m128 m1 = E1(interesting_floats, i*4+k, numInterestingFloats); \ |
| __m128 m2 = E2(interesting_floats, j*4, numInterestingFloats); \ |
| Ret_type ret = func(m1, m2); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&m2, str2); \ |
| char str3[256]; tostr(&ret, str3); \ |
| printf("%s(%s, %s) = %s\n", #func, str, str2, str3); \ |
| } |
| |
| #define Ret_M128_M128_M128(Ret_type, func) \ |
| for(int i = 0; i < numInterestingFloats / 4; ++i) \ |
| for(int k = 0; k < 4; ++k) \ |
| for(int j = 0; j < numInterestingFloats / 4; ++j) \ |
| for(int l = 0; l < numInterestingFloats / 4; ++l) \ |
| { \ |
| __m128 m1 = E1(interesting_floats, i*4+k, numInterestingFloats); \ |
| __m128 m2 = E2(interesting_floats, j*4, numInterestingFloats); \ |
| __m128 m3 = E1(interesting_floats, l*4, numInterestingFloats); \ |
| Ret_type ret = func(m1, m2, m3); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&m2, str2); \ |
| char str3[256]; tostr(&m3, str3); \ |
| char str4[256]; tostr(&ret, str4); \ |
| printf("%s(%s, %s, %s) = %s\n", #func, str, str2, str3, str4); \ |
| } |
| |
| #define Ret_M128_int(Ret_type, func) \ |
| for(int i = 0; i < numInterestingFloats / 4; ++i) \ |
| for(int k = 0; k < 4; ++k) \ |
| for(int j = 0; j < numInterestingInts; ++j) \ |
| { \ |
| __m128 m1 = E1(interesting_floats, i*4+k, numInterestingFloats); \ |
| int m2 = interesting_ints[j]; \ |
| Ret_type ret = func(m1, m2); \ |
| char str[256]; tostr(&m1, str); \ |
| char str2[256]; tostr(&m2, str2); \ |
| char str3[256]; tostr(&ret, str3); \ |
| printf("%s(%s, %s) = %s\n", #func, str, str2, str3); \ |
| } |
