[SYCL] Add more tests for experimental::printf (intel/llvm-test-suite#569)

Signed-off-by: Artem Gindinson <artem.gindinson@intel.com>

Author: AlexeySachkov

SYCL/Printf/char.cpp

@@ -0,0 +1,78 @@
+// This test is written with an aim to check that experimental::printf behaves
+// in the same way as printf from C99/C11
+//
+// The test is written using conversion specifiers table from cppreference [1]
+// [1]: https://en.cppreference.com/w/cpp/io/c/fprintf
+//
+// RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple %s -o %t.out
+// RUN: %CPU_RUN_PLACEHOLDER %t.out %CPU_CHECK_PLACEHOLDER
+// RUN: %GPU_RUN_PLACEHOLDER %t.out %GPU_CHECK_PLACEHOLDER
+// RUN: %ACC_RUN_PLACEHOLDER %t.out %ACC_CHECK_PLACEHOLDER
+// FIXME: Remove dedicated constant address space testing once generic AS
+//        support is considered stable.
+// RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple %s -o %t.constant.out \
+// RUN: -DTEST_CONSTANT_AS
+// RUN: %CPU_RUN_PLACEHOLDER %t.constant.out %CPU_CHECK_PLACEHOLDER
+// RUN: %GPU_RUN_PLACEHOLDER %t.constant.out %GPU_CHECK_PLACEHOLDER
+// RUN: %ACC_RUN_PLACEHOLDER %t.constant.out %ACC_CHECK_PLACEHOLDER
+//
+// FIXME: wchar_t* is not supported on GPU
+// FIXME: String literal prefixes (L, u8, u, U) are not functioning on Windows
+//
+// CHECK: c=a
+// CHECK: literal strings: s=Hello World!
+// CHECK_DISABLED: non-literal strings: s=Hello, World! ls=
+
+#include <CL/sycl.hpp>
+
+#include <cstring>
+
+#include "helper.hpp"
+
+using namespace sycl;
+
+void do_char_string_test() {
+  {
+    // %c format specifier, single character
+    FORMAT_STRING(fmt) = "c=%c\n"; // FIXME: lc is not tested
+
+    char c = 'a';
+
+    ext::oneapi::experimental::printf(fmt, c);
+  }
+
+  {
+    // %s format specifier, character string
+    FORMAT_STRING(fmt1) = "literal strings: s=%s %s\n";
+    ext::oneapi::experimental::printf(fmt1, "Hello",
+                                      // World!
+                                      "\x57\x6F\x72\x6C\x64\x21");
+
+    // FIXME: lack of support for non-literal strings in %s is an OpenCL
+    // limitation
+    /*
+    FORMAT_STRING(fmt2) = "non-literal strings: s=%s ls=%ls\n";
+    char str[20] = { '\0' };
+    const char *s = "Hello, World!";
+    for (int i = 0; i < 13; ++i) {
+      str[i] = s[i];
+    }
+
+    // FIXME: ls is untested here
+    ext::oneapi::experimental::printf(fmt2, str, "");
+    */
+  }
+}
+
+class CharTest;
+
+int main() {
+  queue q;
+
+  q.submit([](handler &cgh) {
+    cgh.single_task<CharTest>([]() { do_char_string_test(); });
+  });
+  q.wait();
+
+  return 0;
+}

SYCL/Printf/float.cpp

@@ -0,0 +1,87 @@
+// This test is written with an aim to check that experimental::printf behaves
+// in the same way as printf from C99/C11
+//
+// The test is written using conversion specifiers table from cppreference [1]
+// [1]: https://en.cppreference.com/w/cpp/io/c/fprintf
+//
+// RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple %s -o %t.out
+// RUN: %CPU_RUN_PLACEHOLDER %t.out %CPU_CHECK_PLACEHOLDER
+// RUN: %GPU_RUN_PLACEHOLDER %t.out %GPU_CHECK_PLACEHOLDER
+// RUN: %ACC_RUN_PLACEHOLDER %t.out %ACC_CHECK_PLACEHOLDER
+// FIXME: Remove dedicated constant address space testing once generic AS
+//        support is considered stable.
+// RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple %s -o %t.constant.out \
+// RUN: -DTEST_CONSTANT_AS
+// RUN: %CPU_RUN_PLACEHOLDER %t.constant.out %CPU_CHECK_PLACEHOLDER
+// RUN: %GPU_RUN_PLACEHOLDER %t.constant.out %GPU_CHECK_PLACEHOLDER
+// RUN: %ACC_RUN_PLACEHOLDER %t.constant.out %ACC_CHECK_PLACEHOLDER
+//
+// CHECK: float 3.140000e+00, 3.140000E+00
+// CHECK: double -6.813800e+00, -6.813800E+00
+// CHECK: mixed 3.140000e+00, -6.813800E+00
+// CHECK: float 0x1.91eb86{{0*}}p+1, 0X1.91EB86{{0*}}P+1
+// CHECK: double -0x1.b4154d8cccccdp+2, -0X1.B4154D8CCCCCDP+2
+// CHECK: mixed 0x1.91eb86{{0*}}p+1, -0X1.B4154D8CCCCCDP+2
+// CHECK: float 3.14, 3.14
+// CHECK: double -6.8138, -6.8138
+// CHECK: mixed 3.14, -6.8138
+
+#include <CL/sycl.hpp>
+
+#include "helper.hpp"
+
+using namespace sycl;
+
+void do_float_test() {
+  {
+    // %e, %E floating-point, decimal exponent notation
+    FORMAT_STRING(fmt1) = "float %e, %E\n";
+    FORMAT_STRING(fmt2) = "double %e, %E\n";
+    FORMAT_STRING(fmt3) = "mixed %e, %E\n";
+
+    float f = 3.14;
+    double d = -f * 2.17;
+    ext::oneapi::experimental::printf(fmt1, f, f);
+    ext::oneapi::experimental::printf(fmt2, d, d);
+    ext::oneapi::experimental::printf(fmt3, f, d);
+  }
+
+  {
+    // %a, %A floating-point, hexadecimal exponent notation
+    FORMAT_STRING(fmt1) = "float %a, %A\n";
+    FORMAT_STRING(fmt2) = "double %a, %A\n";
+    FORMAT_STRING(fmt3) = "mixed %a, %A\n";
+
+    float f = 3.14;
+    double d = -f * 2.17;
+    ext::oneapi::experimental::printf(fmt1, f, f);
+    ext::oneapi::experimental::printf(fmt2, d, d);
+    ext::oneapi::experimental::printf(fmt3, f, d);
+  }
+
+  {
+    // %g, %G floating-point
+    FORMAT_STRING(fmt1) = "float %g, %G\n";
+    FORMAT_STRING(fmt2) = "double %g, %G\n";
+    FORMAT_STRING(fmt3) = "mixed %g, %G\n";
+
+    float f = 3.14;
+    double d = -f * 2.17;
+    ext::oneapi::experimental::printf(fmt1, f, f);
+    ext::oneapi::experimental::printf(fmt2, d, d);
+    ext::oneapi::experimental::printf(fmt3, f, d);
+  }
+}
+
+class FloatTest;
+
+int main() {
+  queue q;
+
+  q.submit([](handler &cgh) {
+    cgh.single_task<FloatTest>([]() { do_float_test(); });
+  });
+  q.wait();
+
+  return 0;
+}

SYCL/Printf/helper.hpp

@@ -0,0 +1,8 @@
+#if defined(__SYCL_DEVICE_ONLY__) && defined(TEST_CONSTANT_AS)
+// On device side, we have to put format string into a constant address space
+// FIXME: remove this header completely once the toolchain's support for
+// generic address-spaced format strings is stable.
+#define FORMAT_STRING(X) static const __attribute__((opencl_constant)) char X[]
+#else
+#define FORMAT_STRING(X) static const char X[]
+#endif