Unit test for Conditionally eliminate library calls

[xur]

Summary

This patch is the unit test for conditionally eliminate library calls patch,
which is being reviewed here:
https://reviews.llvm.org/D24414

[davidxl]

SingleSource/Regression/C++/cdce_macro.inc

16 ↗

(On Diff #70882)

use upper case for macro?

Why is the macro needed?

20 ↗

(On Diff #70882)

why 10 ?

21 ↗

(On Diff #70882)

-->TEST_VAL_RANGE?

33 ↗

(On Diff #70882)

-->TEST_VAL

This macro be used in TEST_VAL_RANGE definition

33 ↗

(On Diff #70882)

make it take a value argument

[xur]

SingleSource/Regression/C++/cdce_macro.inc

16 ↗

(On Diff #70882)

OK. used the upper case in the new patch.

We need this because, we need to postfix "l" or "f" to the name for long double and float. For double type, we don't need to do anything, that's the default here.

20 ↗

(On Diff #70882)

just an arbitrary number. Do you want it to be a larger number? testing all the integers seems to be excessive.

[xur]

Integrated David's review comments and changed the file names in sync to https://reviews.llvm.org/D24414

SingleSource/Regression/C++/Makefile

   pointer_member \
   pointer_method \
   pointer_method2 \
-  short_circuit_dtor
+  short_circuit_dtor \
+        libcalls_shrinkwrap_test_double.cpp \
+        libcalls_shrinkwrap_test_double_pow.cpp \
+        libcalls_shrinkwrap_test_float.cpp \
+        libcalls_shrinkwrap_test_long_double.cpp
+
 endif
 
 LDFLAGS += -lstdc++

SingleSource/Regression/C++/libcalls_shrinkwrap_func.def

+TARGETFUNC(acos)
+TARGETFUNC(asin)
+TARGETFUNC(cos)
+TARGETFUNC(sin)
+TARGETFUNC(acosh)
+TARGETFUNC(sqrt)
+TARGETFUNC(cosh)
+TARGETFUNC(exp)
+TARGETFUNC(exp10)
+TARGETFUNC(exp2)
+TARGETFUNC(sinh)
+TARGETFUNC(expm1)
+TARGETFUNC(atanh)
+TARGETFUNC(log)
+TARGETFUNC(log10)
+TARGETFUNC(log2)
+TARGETFUNC(logb)
+TARGETFUNC(log1p)
+

SingleSource/Regression/C++/libcalls_shrinkwrap_macro.inc

+#include <errno.h>
+#include <limits>
+#include <math.h>
+#include <iostream>
+#include <stdlib.h>
+
+template<typename T> static void __attribute__((noinline))
+check(const char *name, T v, int errno_saved, int errno_val, double ret) {
+  volatile double val = ret;
+  if (errno_saved == errno_val)
+    return;
+  std::cerr << "For " << name <<" (" << v << "), new_error=" << errno_saved
+            << " while errnor=" << errno_val << std::endl;
+  abort();
+}
+
+#define FUNC_STR(s) #s
+
+#ifndef FUNC_NAME
+#define FUNC_NAME(s) s
+#endif
+
+#define RANGE 10
+#define TEST_VAL_RANGE(FUNC, VAL)                                              \
+  {                                                                            \
+    for (int i = VAL - RANGE; i < VAL + RANGE; i++)                            \
+      TEST_VAL(FUNC, i)                                                        \
+  }                                                                            \
+
+#define TEST_VAL(FUNC, V)                                                      \
+  {                                                                            \
+    errno = 0;                                                                 \
+    FUNC_NAME(FUNC)(V);                                                        \
+    int errno_saved = errno;                                                   \
+    errno = 0;                                                                 \
+    T ret = FUNC_NAME(FUNC)(V);                                                \
+    check(FUNC_STR(FUNC), V, errno_saved, errno, ret);                         \
+  }
+
+template <typename T> static void test_max() {
+  T v = std::numeric_limits<T>::max();
+#define TARGETFUNC(FUNC) TEST_VAL(FUNC, v)
+#include "libcalls_shrinkwrap_func.def"
+#undef TARGETFUNC
+}
+
+template <typename T> static void test_min() {
+  T v = std::numeric_limits<T>::min();
+#define TARGETFUNC(FUNC) TEST_VAL(FUNC, v)
+#include "libcalls_shrinkwrap_func.def"
+#undef TARGETFUNC
+}
+
+template <typename T> static void test_inf() {
+  T v = std::numeric_limits<T>::infinity();
+#define TARGETFUNC(FUNC) TEST_VAL(FUNC, v)
+#include "libcalls_shrinkwrap_func.def"
+#undef TARGETFUNC
+}
+
+template <typename T> static void test_neg_inf() {
+  T v = -1 * std::numeric_limits<T>::infinity();
+#define TARGETFUNC(FUNC) TEST_VAL(FUNC, v)
+#include "libcalls_shrinkwrap_func.def"
+#undef TARGETFUNC
+}
+
+template <typename T> static void test_nan() {
+  T v = std::numeric_limits<T>::quiet_NaN();
+#define TARGETFUNC(FUNC) TEST_VAL(FUNC, v)
+#include "libcalls_shrinkwrap_func.def"
+#undef TARGETFUNC
+}
+
+template <typename T> static void test_special_val() {
+  test_min<T>();
+  test_max<T>();
+  test_inf<T>();
+  test_neg_inf<T>();
+  test_nan<T>();
+}

SingleSource/Regression/C++/libcalls_shrinkwrap_test_double.cpp

+#define FP_TYPE double
+#include "libcalls_shrinkwrap_macro.inc"
+
+template <typename T> static void test_val() {
+  TEST_VAL_RANGE(acos, -1)
+  TEST_VAL_RANGE(asin, -1)
+  TEST_VAL_RANGE(acosh, 1)
+  TEST_VAL_RANGE(sqrt, 0)
+  TEST_VAL_RANGE(cosh, -710)
+  TEST_VAL_RANGE(cosh, 710)
+  TEST_VAL_RANGE(exp, -745)
+  TEST_VAL_RANGE(exp, 709)
+  TEST_VAL_RANGE(exp10, -323)
+  TEST_VAL_RANGE(exp10, 308)
+  TEST_VAL_RANGE(exp2, -1074)
+  TEST_VAL_RANGE(exp2, 4932)
+  TEST_VAL_RANGE(sinh, -710)
+  TEST_VAL_RANGE(sinh, 710)
+  TEST_VAL_RANGE(expm1, 709)
+  TEST_VAL_RANGE(atanh, 0)
+  TEST_VAL_RANGE(log, 0)
+  TEST_VAL_RANGE(log10, 0)
+  TEST_VAL_RANGE(log2, 0)
+  TEST_VAL_RANGE(logb, 0)
+  TEST_VAL_RANGE(log1p, 0)
+}
+
+int main() {
+  test_special_val<FP_TYPE>();
+  test_val<FP_TYPE>();
+  return 0;
+}

SingleSource/Regression/C++/libcalls_shrinkwrap_test_double.reference_output

+exit 0

SingleSource/Regression/C++/libcalls_shrinkwrap_test_double_pow.cpp

+#include <errno.h>
+#include <limits>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+static void __attribute__((noinline))
+check(double bv, double ev, int errno_saved, int errno_val, double ret) {
+  volatile double val = ret;
+  if (errno_saved == errno_val)
+    return;
+  fprintf(stderr, "For pow (%f,%f), new_errno=%d while errno=%d\n", bv, ev,
+          errno_saved, errno_val);
+
+  abort();
+}
+
+#define RANGE 10
+#define TEST_VAL_RANGE(BASE, EXP)                                                 \
+  {                                                                            \
+    for (int i = EXP - RANGE; i < EXP + RANGE; i++) {                          \
+      errno = 0;                                                               \
+      pow(BASE, i);                                                            \
+      int errno_saved = errno;                                                 \
+      errno = 0;                                                               \
+      double ret = pow(BASE, i);                                               \
+      check(BASE, i, errno_saved, errno, ret);                                          \
+    }                                                                          \
+  }
+
+static void test_constant_base() { TEST_VAL_RANGE(2.5, 127.0f) }
+
+static void test_from_int_convert() {
+  unsigned char c = 5;
+  TEST_VAL_RANGE(c, 128)
+  unsigned short s = 6;
+  TEST_VAL_RANGE(s, 64)
+  unsigned int x = 7;
+  TEST_VAL_RANGE(x, 32);
+}
+
+int main() {
+  test_constant_base();
+  test_from_int_convert();
+  return 0;
+}

SingleSource/Regression/C++/libcalls_shrinkwrap_test_double_pow.reference_output

+exit 0

SingleSource/Regression/C++/libcalls_shrinkwrap_test_float.cpp

+#define FUNC_NAME(s) s##f
+#define FP_TYPE float
+#include "libcalls_shrinkwrap_macro.inc"
+
+template <typename T> static void test_val() {
+  TEST_VAL_RANGE(acos, -1)
+  TEST_VAL_RANGE(asin, -1)
+  TEST_VAL_RANGE(acosh, 1)
+  TEST_VAL_RANGE(sqrt, 0)
+  TEST_VAL_RANGE(cosh, -89)
+  TEST_VAL_RANGE(cosh, 89)
+  TEST_VAL_RANGE(exp, -103)
+  TEST_VAL_RANGE(exp, 88)
+  TEST_VAL_RANGE(exp10, -45)
+  TEST_VAL_RANGE(exp10, 38)
+  TEST_VAL_RANGE(exp2, -149)
+  TEST_VAL_RANGE(exp2, 127)
+  TEST_VAL_RANGE(sinh, -89)
+  TEST_VAL_RANGE(sinh, 89)
+  TEST_VAL_RANGE(expm1, 88)
+  TEST_VAL_RANGE(atanh, 0)
+  TEST_VAL_RANGE(log, 0)
+  TEST_VAL_RANGE(log10, 0)
+  TEST_VAL_RANGE(log2, 0)
+  TEST_VAL_RANGE(logb, 0)
+  TEST_VAL_RANGE(log1p, 0)
+}
+
+int main() {
+  test_special_val<FP_TYPE>();
+  test_val<FP_TYPE>();
+  return 0;
+}

SingleSource/Regression/C++/libcalls_shrinkwrap_test_float.reference_output

+exit 0

SingleSource/Regression/C++/libcalls_shrinkwrap_test_long_double.cpp

+#define FUNC_NAME(s) s##l
+#define FP_TYPE long double
+#include "libcalls_shrinkwrap_macro.inc"
+
+template <typename T> static void test_val() {
+  TEST_VAL_RANGE(acos, -1)
+  TEST_VAL_RANGE(asin, -1)
+  TEST_VAL_RANGE(acosh, 1)
+  TEST_VAL_RANGE(sqrt, 0)
+  TEST_VAL_RANGE(cosh, -11357)
+  TEST_VAL_RANGE(cosh, 11357)
+  TEST_VAL_RANGE(exp, -11399)
+  TEST_VAL_RANGE(exp, 11356)
+  TEST_VAL_RANGE(exp10, -4950)
+  TEST_VAL_RANGE(exp10, 4932)
+  TEST_VAL_RANGE(exp2, -16445)
+  TEST_VAL_RANGE(exp2, 11383)
+  TEST_VAL_RANGE(sinh, -11357)
+  TEST_VAL_RANGE(sinh, 11357)
+  TEST_VAL_RANGE(expm1, 11356)
+  TEST_VAL_RANGE(atanh, 0)
+  TEST_VAL_RANGE(log, 0)
+  TEST_VAL_RANGE(log10, 0)
+  TEST_VAL_RANGE(log2, 0)
+  TEST_VAL_RANGE(logb, 0)
+  TEST_VAL_RANGE(log1p, 0)
+}
+
+int main() {
+  test_special_val<FP_TYPE>();
+  test_val<FP_TYPE>();
+  return 0;
+}

SingleSource/Regression/C++/libcalls_shrinkwrap_test_long_double.reference_output

+exit 0