[SYCL] Fix some code-style issues

Signed-off-by: Sergey Kanaev <sergey.kanaev@intel.com>

Author: Sergey Kanaev

clang/lib/Sema/SemaDecl.cpp

@@ -17942,9 +17942,9 @@ Decl *Sema::getObjCDeclContext() const {
 Sema::FunctionEmissionStatus Sema::getEmissionStatus(FunctionDecl *FD) {
   // Due to SYCL functions are template we check if they have appropriate
   // attribute prior to checking if it is a template
-  if (LangOpts.SYCLIsDevice && (FD->hasAttr<SYCLDeviceAttr>() ||
-                                FD->hasAttr<SYCLKernelAttr>()))
-      return FunctionEmissionStatus::Emitted;
+  if (LangOpts.SYCLIsDevice &&
+      (FD->hasAttr<SYCLDeviceAttr>() || FD->hasAttr<SYCLKernelAttr>()))
+    return FunctionEmissionStatus::Emitted;
 
   // Templates are emitted when they're instantiated.
   if (FD->isDependentContext())

clang/test/SemaSYCL/call-to-undefined-function.cpp

@@ -31,7 +31,7 @@ void definedPartialTpl() {
   // empty
 }
 
-template<>
+template <>
 void definedPartialTpl<char, true>() {
   // empty
 }

clang/test/SemaSYCL/restrict-recursion4.cpp

@@ -2,25 +2,24 @@
 
 // This recursive function is not called from sycl kernel,
 // so it should not be diagnosed.
-int fib(int n)
-{
-   if (n <= 1)
-      return n;
-   return fib(n-1) + fib(n-2);
+int fib(int n) {
+  if (n <= 1)
+    return n;
+  return fib(n - 1) + fib(n - 2);
 }
 
-  // expected-note@+1 2{{function implemented using recursion declared here}}
+// expected-note@+1 2{{function implemented using recursion declared here}}
 void kernel2(void) {
   // expected-error@+1 {{SYCL kernel cannot call a recursive function}}
   kernel2();
 }
 
-using myFuncDef = int(int,int);
+using myFuncDef = int(int, int);
 
 typedef __typeof__(sizeof(int)) size_t;
 
 SYCL_EXTERNAL
-void* operator new(size_t);
+void *operator new(size_t);
 
 void usage2(myFuncDef functionPtr) {
   // expected-error@+1 {{SYCL kernel cannot allocate storage}}
@@ -30,7 +29,7 @@ void usage2(myFuncDef functionPtr) {
 }
 
 int addInt(int n, int m) {
-  return n+m;
+  return n + m;
 }
 
 template <typename name, typename Func>
@@ -41,6 +40,6 @@ __attribute__((sycl_kernel)) void kernel_single_task(Func kernelFunc) {
 
 int main() {
   // expected-note@+1 {{called by 'operator()'}}
-  kernel_single_task<class fake_kernel>([]() {usage2(&addInt);});
+  kernel_single_task<class fake_kernel>([]() { usage2(&addInt); });
   return fib(5);
 }

clang/test/SemaSYCL/sycl-restrict.cpp

@@ -2,47 +2,46 @@
 // RUN: %clang_cc1 -fcxx-exceptions -triple spir64 -fsycl-is-device -fno-sycl-allow-func-ptr -Wno-return-type -verify -fsyntax-only -std=c++17 %s
 // RUN: %clang_cc1 -fcxx-exceptions -triple spir64 -fsycl-is-device -DALLOW_FP=1 -fsycl-allow-func-ptr -Wno-return-type -verify -fsyntax-only -std=c++17 %s
 
-
 namespace std {
-  class type_info;
-  typedef __typeof__(sizeof(int)) size_t;
-}
+class type_info;
+typedef __typeof__(sizeof(int)) size_t;
+} // namespace std
 
 // we're testing a restricted mode, thus just provide a stub implementation for
 // function with address-space-unspecified pointers.
-void* operator new(std::size_t) {
+void *operator new(std::size_t) {
   return reinterpret_cast<void *>(1);
 }
 
 namespace Check_User_Operators {
-class Fraction
-{
-    // expected-error@+2 {{SYCL kernel cannot call a recursive function}}
-    // expected-note@+1 {{function implemented using recursion declared here}}
-    int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
-    int n, d;
+class Fraction {
+  // expected-error@+2 {{SYCL kernel cannot call a recursive function}}
+  // expected-note@+1 {{function implemented using recursion declared here}}
+  int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
+  int n, d;
+
 public:
-    Fraction(int n, int d = 1) : n(n/gcd(n, d)), d(d/gcd(n, d)) { }
-    int num() const { return n; }
-    int den() const { return d; }
+  Fraction(int n, int d = 1) : n(n / gcd(n, d)), d(d / gcd(n, d)) {}
+  int num() const { return n; }
+  int den() const { return d; }
 };
-bool operator==(const Fraction& lhs, const Fraction& rhs)
-{
-    new int; // expected-error {{SYCL kernel cannot allocate storage}}
-    return lhs.num() == rhs.num() && lhs.den() == rhs.den();
-}}
+bool operator==(const Fraction &lhs, const Fraction &rhs) {
+  new int; // expected-error {{SYCL kernel cannot allocate storage}}
+  return lhs.num() == rhs.num() && lhs.den() == rhs.den();
+}
+} // namespace Check_User_Operators
 
 namespace Check_VLA_Restriction {
 void no_restriction(int p) {
-  int index[p+2];
+  int index[p + 2];
 }
 void restriction(int p) {
   // expected-error@+1 {{variable length arrays are not supported for the current target}}
-  int index[p+2];
-}
+  int index[p + 2];
 }
+} // namespace Check_VLA_Restriction
 
-void* operator new (std::size_t size, void* ptr) throw() { return ptr; };
+void *operator new(std::size_t size, void *ptr) throw() { return ptr; };
 namespace Check_RTTI_Restriction {
 struct A {
   virtual ~A(){};
@@ -57,35 +56,38 @@ struct OverloadedNewDelete {
   void *operator new(std::size_t size) throw() {
     // expected-error@+1 {{SYCL kernel cannot allocate storage}}
     float *pt = new float;
-    return 0;}
+    return 0;
+  }
   // This overload does not allocate: no diagnostic.
-  void *operator new[](std::size_t size) throw() {return 0;}
+  void *operator new[](std::size_t size) throw() { return 0; }
   void operator delete(void *){};
   void operator delete[](void *){};
 };
 
 bool isa_B(A *a) {
   Check_User_Operators::Fraction f1(3, 8), f2(1, 2), f3(10, 2);
-  if (f1 == f2) return false;
+  if (f1 == f2)
+    return false;
 
   Check_VLA_Restriction::restriction(7);
   // expected-error@+1 {{SYCL kernel cannot allocate storage}}
   int *ip = new int;
-  int i; int *p3 = new(&i) int; // no error on placement new
+  int i;
+  int *p3 = new (&i) int; // no error on placement new
   // expected-note@+1 {{called by 'isa_B'}}
-  OverloadedNewDelete *x = new( struct OverloadedNewDelete );
-  auto y = new struct OverloadedNewDelete [5];
+  OverloadedNewDelete *x = new (struct OverloadedNewDelete);
+  auto y = new struct OverloadedNewDelete[5];
   // expected-error@+1 {{SYCL kernel cannot use rtti}}
   (void)typeid(int);
   // expected-error@+1 {{SYCL kernel cannot use rtti}}
   return dynamic_cast<B *>(a) != 0;
 }
 
-template<typename N, typename L>
+template <typename N, typename L>
 __attribute__((sycl_kernel)) void kernel1(L l) {
   l();
 }
-}
+} // namespace Check_RTTI_Restriction
 
 typedef struct Base {
   virtual void f() const {}
@@ -94,22 +96,19 @@ typedef struct Base {
 typedef struct A {
   static int stat_member;
   const static int const_stat_member;
-  constexpr static int constexpr_stat_member=0;
+  constexpr static int constexpr_stat_member = 0;
 
-  int fm(void)
-  {
+  int fm(void) {
     // expected-error@+1 {{SYCL kernel cannot use a non-const static data variable}}
     return stat_member;
   }
 } a_type;
 
-
 b_type b;
 
-using myFuncDef = int(int,int);
+using myFuncDef = int(int, int);
 
-void eh_ok(void)
-{
+void eh_ok(void) {
   __float128 A;
   try {
     ;
@@ -119,8 +118,7 @@ void eh_ok(void)
   throw 20;
 }
 
-void eh_not_ok(void)
-{
+void eh_not_ok(void) {
   // expected-error@+1 {{SYCL kernel cannot use exceptions}}
   try {
     ;
@@ -153,44 +151,50 @@ void usage(myFuncDef functionPtr) {
 }
 
 namespace ns {
-  int glob;
+int glob;
 }
 extern "C++" {
-  int another_global = 5;
-  namespace AnotherNS {
-    int moar_globals = 5;
-   }
+int another_global = 5;
+namespace AnotherNS {
+int moar_globals = 5;
+}
 }
 
 int addInt(int n, int m) {
-    return n+m;
+  return n + m;
 }
 
-int use2 ( a_type ab, a_type *abp ) {
+int use2(a_type ab, a_type *abp) {
 
-  if (ab.constexpr_stat_member) return 2;
-  if (ab.const_stat_member) return 1;
+  if (ab.constexpr_stat_member)
+    return 2;
+  if (ab.const_stat_member)
+    return 1;
   // expected-error@+1 {{SYCL kernel cannot use a non-const static data variable}}
-  if (ab.stat_member) return 0;
+  if (ab.stat_member)
+    return 0;
   // expected-error@+1 {{SYCL kernel cannot use a non-const static data variable}}
-  if (abp->stat_member) return 0;
-  if (ab.fm()) return 0;
+  if (abp->stat_member)
+    return 0;
+  if (ab.fm())
+    return 0;
   // expected-error@+1 {{SYCL kernel cannot use a global variable}}
-  return another_global ;
+  return another_global;
   // expected-error@+1 {{SYCL kernel cannot use a global variable}}
   return ns::glob +
-  // expected-error@+1 {{SYCL kernel cannot use a global variable}}
-    AnotherNS::moar_globals;
+         // expected-error@+1 {{SYCL kernel cannot use a global variable}}
+         AnotherNS::moar_globals;
   // expected-note@+1 {{called by 'use2'}}
   eh_not_ok();
-  Check_RTTI_Restriction:: A *a;
+  Check_RTTI_Restriction::A *a;
   // expected-note@+1 2{{called by 'use2'}}
-  Check_RTTI_Restriction:: isa_B(a);
+  Check_RTTI_Restriction::isa_B(a);
   // expected-note@+1 {{called by 'use2'}}
   usage(&addInt);
   Check_User_Operators::Fraction f1(3, 8), f2(1, 2), f3(10, 2);
   // expected-note@+1 {{called by 'use2'}}
-  if (f1 == f2) return false;
+  if (f1 == f2)
+    return false;
 }
 
 template <typename name, typename Func>
@@ -204,7 +208,6 @@ __attribute__((sycl_kernel)) void kernel_single_task(Func kernelFunc) {
 
 int main() {
   a_type ab;
-  kernel_single_task<class fake_kernel>([]() { usage(  &addInt ); });
+  kernel_single_task<class fake_kernel>([]() { usage(&addInt); });
   return 0;
 }
-

clang/test/SemaSYCL/sycl-varargs-cconv.cpp

@@ -9,7 +9,7 @@
 #if defined(PRINTF_INVALID_DECL)
 extern "C" SYCL_EXTERNAL int __spirv_ocl_printf(const char *__format, ...);
 namespace A {
-  SYCL_EXTERNAL int __spirv_ocl_printf(const char *__format, ...);
+SYCL_EXTERNAL int __spirv_ocl_printf(const char *__format, ...);
 }
 #elif defined(PRINTF_INVALID_DEF)
 int __spirv_ocl_printf(const char *__format, ...) {
@@ -23,10 +23,10 @@ SYCL_EXTERNAL
 int __spirv_ocl_printf(const char *__format, ...);
 #elif defined(PRINTF_VALID2)
 extern "C" {
-  extern "C++" {
-    SYCL_EXTERNAL
-    int __spirv_ocl_printf(const char *__format, ...);
-  }
+extern "C++" {
+SYCL_EXTERNAL
+int __spirv_ocl_printf(const char *__format, ...);
+}
 }
 #else
 SYCL_EXTERNAL
@@ -38,7 +38,7 @@ SYCL_EXTERNAL int __cdecl foo(int, ...); // expected-no-error
 float bar(float f, ...) { return ++f; } // expected-no-error
 
 void bar() {
-  foo(5); // expected-no-error
+  foo(5);    // expected-no-error
   bar(7.0f); // expected-no-error
 }
 

sycl/include/CL/sycl/builtins.hpp

@@ -1545,14 +1545,13 @@ detail::enable_if_t<detail::is_genfloatf<T>::value, T> tan(T x) __NOEXC {
 #ifdef __SYCL_DEVICE_ONLY__
 #if defined(__GNUC__) || defined(__clang__)
 extern "C" {
-extern SYCL_EXTERNAL
-void __assert_fail(const char *expr, const char *file,
-                   unsigned int line, const char *func);
+extern SYCL_EXTERNAL void __assert_fail(const char *expr, const char *file,
+                                        unsigned int line, const char *func);
 }
 #elif defined(_MSC_VER)
 extern "C" {
-extern SYCL_EXTERNAL
-void _wassert(const wchar_t *wexpr, const wchar_t *wfile, unsigned line);
+extern SYCL_EXTERNAL void _wassert(const wchar_t *wexpr, const wchar_t *wfile,
+                                   unsigned line);
 }
 #endif // defined(_MSC_VER_)
 #endif // __SYCL_DEVICE_ONLY__