[SYCL] Fix formatting

Author: npmiller

clang/lib/CodeGen/CodeGenModule.cpp

@@ -4414,41 +4414,40 @@ void CodeGenModule::EmitGlobal(GlobalDecl GD) {
     }
   }
 
-
   // When using SYCLDeviceOnlyAttr, there can be two functions with the same
   // mangling, the host function and the device overload. So when compiling for
   // device we need to make sure we're selecting the SYCLDeviceOnlyAttr
   // overload and dropping the host overload.
   if (LangOpts.SYCLIsDevice) {
-      StringRef MangledName = getMangledName(GD);
-      auto DDI = DeferredDecls.find(MangledName);
-      // If we have an existing declaration with the same mangling for this
-      // symbol it may be a SYCLDeviceOnlyAttr case.
-      if (DDI != DeferredDecls.end()) {
-        auto *G = cast<ValueDecl>(DeferredDecls[MangledName].getDecl());
-
-        if (!G->hasAttr<SYCLDeviceOnlyAttr>() &&
-            Global->hasAttr<SYCLDeviceOnlyAttr>() &&
-            Global->hasAttr<SYCLDeviceAttr>()) {
-          // If the host declaration was already processed and the device only
-          // declaration is also a sycl external declaration, remove the host
-          // variant and skip. The device only variant will be generated later
-          // as it's marked sycl external.
-          DeferredDecls.erase(DDI);
-          return;
-        } else if (!G->hasAttr<SYCLDeviceOnlyAttr>() &&
-                   Global->hasAttr<SYCLDeviceOnlyAttr>()) {
-          // If the host declaration was already processed, replace it with the
-          // device only declaration.
-          DeferredDecls[MangledName] = GD;
-          return;
-        } else if (!Global->hasAttr<SYCLDeviceOnlyAttr>() &&
-                   G->hasAttr<SYCLDeviceOnlyAttr>()) {
-          // If the device only declaration was already processed, skip the
-          // host declaration.
-          return;
-        }
+    StringRef MangledName = getMangledName(GD);
+    auto DDI = DeferredDecls.find(MangledName);
+    // If we have an existing declaration with the same mangling for this
+    // symbol it may be a SYCLDeviceOnlyAttr case.
+    if (DDI != DeferredDecls.end()) {
+      auto *G = cast<ValueDecl>(DeferredDecls[MangledName].getDecl());
+
+      if (!G->hasAttr<SYCLDeviceOnlyAttr>() &&
+          Global->hasAttr<SYCLDeviceOnlyAttr>() &&
+          Global->hasAttr<SYCLDeviceAttr>()) {
+        // If the host declaration was already processed and the device only
+        // declaration is also a sycl external declaration, remove the host
+        // variant and skip. The device only variant will be generated later
+        // as it's marked sycl external.
+        DeferredDecls.erase(DDI);
+        return;
+      } else if (!G->hasAttr<SYCLDeviceOnlyAttr>() &&
+                 Global->hasAttr<SYCLDeviceOnlyAttr>()) {
+        // If the host declaration was already processed, replace it with the
+        // device only declaration.
+        DeferredDecls[MangledName] = GD;
+        return;
+      } else if (!Global->hasAttr<SYCLDeviceOnlyAttr>() &&
+                 G->hasAttr<SYCLDeviceOnlyAttr>()) {
+        // If the device only declaration was already processed, skip the
+        // host declaration.
+        return;
       }
+    }
   }
 
   // clang::ParseAST ensures that we emit the SYCL devices at the end, so

clang/test/CodeGenSYCL/sycl-device-only.cpp

@@ -11,9 +11,7 @@ int foo(int a) { return a + 10; }
 __attribute__((sycl_device_only)) int foo(int a) { return a + 20; }
 
 // Use a `sycl_device` function as entry point
-__attribute__((sycl_device)) int bar(int b) {
-  return foo(b);
-}
+__attribute__((sycl_device)) int bar(int b) { return foo(b); }
 
 // Verify that the order of declaration doesn't change the behavior.
 //
@@ -24,9 +22,7 @@ __attribute__((sycl_device_only)) int fooswap(int a) { return a + 20; }
 int fooswap(int a) { return a + 10; }
 
 // Use a `sycl_device` function as entry point
-__attribute__((sycl_device)) int barswap(int b) {
-  return fooswap(b);
-}
+__attribute__((sycl_device)) int barswap(int b) { return fooswap(b); }
 
 // Verify that in extern C the attribute enables mangling.
 extern "C" {
@@ -37,30 +33,28 @@ int fooc(int a) { return a + 10; }
 __attribute__((sycl_device_only)) int fooc(int a) { return a + 20; }
 
 // Use a `sycl_device` function as entry point
-__attribute__((sycl_device)) int barc(int b) {
-  return fooc(b);
-}
+__attribute__((sycl_device)) int barc(int b) { return fooc(b); }
 }
 
 // Check that both attributes can work together
 // CHECK-LABEL: _Z3fooai
 // CHECKH: %add = add nsw i32 %0, 10
 // CHECKD: %add = add nsw i32 %0, 20
 int fooa(int a) { return a + 10; }
-__attribute__((sycl_device_only, sycl_device)) int fooa(int a) { return a + 20; }
+__attribute__((sycl_device_only, sycl_device)) int fooa(int a) {
+  return a + 20;
+}
 
 // Use a `sycl_device` function as entry point
-__attribute__((sycl_device)) int bara(int b) {
-  return fooa(b);
-}
+__attribute__((sycl_device)) int bara(int b) { return fooa(b); }
 
 // CHECK-LABEL: _Z3fooaswapi
 // CHECKH: %add = add nsw i32 %0, 10
 // CHECKD: %add = add nsw i32 %0, 20
-__attribute__((sycl_device_only, sycl_device)) int fooaswap(int a) { return a + 20; }
+__attribute__((sycl_device_only, sycl_device)) int fooaswap(int a) {
+  return a + 20;
+}
 int fooaswap(int a) { return a + 10; }
 
 // Use a `sycl_device` function as entry point
-__attribute__((sycl_device)) int baraswap(int b) {
-  return fooaswap(b);
-}
+__attribute__((sycl_device)) int baraswap(int b) { return fooaswap(b); }