[SYCL] Fix attribute emission handling

Author: npmiller

clang/include/clang/Basic/AttrDocs.td

@@ -4526,7 +4526,9 @@ This attribute can only be applied to functions and indicates that the function
 is only available for the device. It allows functions marked with it to
 overload existing functions without the attribute, in which case the overload
 with the attribute will be used on the device side and the overload without
-will be used on the host side.
+will be used on the host side. Note: as opposed to ``sycl_device`` this does
+not mark the function as being exported, both attributes can be used together
+if needed.
   }];
 }
 

clang/lib/CodeGen/CodeGenModule.cpp

@@ -4414,6 +4414,43 @@ 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;
+        }
+      }
+  }
+
   // clang::ParseAST ensures that we emit the SYCL devices at the end, so
   // anything that is a device (or indirectly called) will be handled later.
   if (LangOpts.SYCLIsDevice && MustBeEmitted(Global)) {

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

@@ -15,6 +15,19 @@ __attribute__((sycl_device)) int bar(int b) {
   return foo(b);
 }
 
+// Verify that the order of declaration doesn't change the behavior.
+//
+// CHECK-LABEL: _Z3fooswapi
+// CHECKH: %add = add nsw i32 %0, 10
+// CHECKD: %add = add nsw i32 %0, 20
+__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);
+}
+
 // Verify that in extern C the attribute enables mangling.
 extern "C" {
 // CHECK-LABEL: _Z3fooci
@@ -28,3 +41,26 @@ __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; }
+
+// Use a `sycl_device` function as entry point
+__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; }
+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);
+}