[SYCL][OpenMP] Fix compilation errors for unsupported __bf16 intrinsics

[eandrews]

Summary

This patch uses existing deferred diagnostics framework to emit error for unsupported type __bf16 in device code. Error is not emitted in host code.

[bader]

LGTM.

I expect this to be a common issue for all single-source offloading programming models (i.e. CUDA and HIP in addition to SYCL and OpenMP offload). Probably we can generalize the code patterns used in this patch for all of them.

In addition to that, there are other built-in data types not supported either by host or device, which are handled similar way. Right?

[eandrews]

In D141375#4041360, @bader wrote:

LGTM.
I expect this to be a common issue for all single-source offloading programming models (i.e. CUDA and HIP in addition to SYCL and OpenMP offload). Probably we can generalize the code patterns used in this patch for all of them.

Looks like CUDA added support for the type - https://reviews.llvm.org/D136311, https://reviews.llvm.org/rG678d8946ba2ba790c4c52e96e2134ee136e30057.

In addition to that, there are other built-in data types not supported either by host or device, which are handled similar way. Right?

Yes. Code added here is similar to code added for other unsupported types like __float128

[mikerice]

LGTM too.

[eandrews]

Thanks for the reviews!

[tra]

clang/lib/Sema/Sema.cpp

1977–1978

@eandrews Do you recall what was the reason for *not* issuing the diagnostic on the GPU side?

It appears to do the opposite to what the patch description says. We're supposed to emit error for unsupported type __bf16 in device code, but instead we specifically ignore it during GPU-side compilation. What am I missing?

[eandrews]

clang/lib/Sema/Sema.cpp

1977–1978

I don't recall the specifics but I think CUDA had code handling __bf16 differently and this change broke a test with CUDA diagnostics and so I excluded it from the patch. I could try removing this check and seeing what breaks if you'd like.

[tra]

clang/lib/Sema/Sema.cpp

1977–1978

It may have been around the time when x86 started exposing bf16 type in the host headers, but NVPTX didn't have any support for the type yet.

This change may have just papered over the problem. Oh, well. That would be just one of the places where we currently don't handle the 'unusual' types across the host/GPU boundary. I'm attempting to clean it up, and will take care of this instance there.

clang/lib/AST/ASTContext.cpp

case Type::Builtin:
     case BuiltinType::SatULongFract:
       Width = Target->getLongFractWidth();
       Align = Target->getLongFractAlign();
       break;
     case BuiltinType::BFloat16:
       if (Target->hasBFloat16Type()) {
         Width = Target->getBFloat16Width();
         Align = Target->getBFloat16Align();
+      } else if ((getLangOpts().SYCLIsDevice ||
+                  (getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice)) &&
+                 AuxTarget->hasBFloat16Type()) {
+        Width = AuxTarget->getBFloat16Width();
+        Align = AuxTarget->getBFloat16Align();
       }
       break;
     case BuiltinType::Float16:
     case BuiltinType::Half:
       if (Target->hasFloat16Type() || !getLangOpts().OpenMP ||
           !getLangOpts().OpenMPIsDevice) {
         Width = Target->getHalfWidth();
         Align = Target->getHalfAlign();

clang/lib/AST/ItaniumMangle.cpp

case BuiltinType::Float128: {
     const TargetInfo *TI = getASTContext().getLangOpts().OpenMP &&
                                    getASTContext().getLangOpts().OpenMPIsDevice
                                ? getASTContext().getAuxTargetInfo()
                                : &getASTContext().getTargetInfo();
     Out << TI->getFloat128Mangling();
     break;
   }
   case BuiltinType::BFloat16: {
-    const TargetInfo *TI = &getASTContext().getTargetInfo();
+    const TargetInfo *TI = ((getASTContext().getLangOpts().OpenMP &&
+                             getASTContext().getLangOpts().OpenMPIsDevice) ||
+                            getASTContext().getLangOpts().SYCLIsDevice)
+                               ? getASTContext().getAuxTargetInfo()
+                               : &getASTContext().getTargetInfo();
     Out << TI->getBFloat16Mangling();
     break;
   }
   case BuiltinType::Ibm128: {
     const TargetInfo *TI = &getASTContext().getTargetInfo();
     Out << TI->getIbm128Mangling();
     break;
   }

clang/lib/Sema/Sema.cpp

if (Ty->isRealFloatingType() && Context.getTypeSize(Ty) == 128) {
         LongDoubleMismatched = true;
     }
 
     if ((Ty->isFloat16Type() && !Context.getTargetInfo().hasFloat16Type()) ||
         (Ty->isFloat128Type() && !Context.getTargetInfo().hasFloat128Type()) ||
         (Ty->isIbm128Type() && !Context.getTargetInfo().hasIbm128Type()) ||
         (Ty->isIntegerType() && Context.getTypeSize(Ty) == 128 &&
          !Context.getTargetInfo().hasInt128Type()) ||
+        (Ty->isBFloat16Type() && !Context.getTargetInfo().hasBFloat16Type() &&
+         !LangOpts.CUDAIsDevice) ||
         LongDoubleMismatched) {
       PartialDiagnostic PD = PDiag(diag::err_target_unsupported_type);
       if (D)
         PD << D;
       else
         PD << "expression";
 
       if (targetDiag(Loc, PD, FD)

clang/lib/Sema/SemaType.cpp

case DeclSpec::TST_float16:
     if (!S.Context.getTargetInfo().hasFloat16Type() && !S.getLangOpts().CUDA &&
         !(S.getLangOpts().OpenMP && S.getLangOpts().OpenMPIsDevice))
       S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
         << "_Float16";
     Result = Context.Float16Ty;
     break;
   case DeclSpec::TST_half:    Result = Context.HalfTy; break;
   case DeclSpec::TST_BFloat16:
-    if (!S.Context.getTargetInfo().hasBFloat16Type())
-      S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
-        << "__bf16";
+    if (!S.Context.getTargetInfo().hasBFloat16Type() &&
+        !(S.getLangOpts().OpenMP && S.getLangOpts().OpenMPIsDevice) &&
+        !S.getLangOpts().SYCLIsDevice)
+      S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported) << "__bf16";
     Result = Context.BFloat16Ty;
     break;
   case DeclSpec::TST_float:   Result = Context.FloatTy; break;
   case DeclSpec::TST_double:
     if (DS.getTypeSpecWidth() == TypeSpecifierWidth::Long)
       Result = Context.LongDoubleTy;
     else
       Result = Context.DoubleTy;

clang/test/SemaSYCL/bf16.cpp

+// RUN: %clang_cc1 -triple spir64 -aux-triple x86_64-unknown-linux-gnu -fsycl-is-device -verify -fsyntax-only %s
+
+template <typename Name, typename Func>
+__attribute__((sycl_kernel)) void kernel(Func kernelFunc) {
+  kernelFunc(); // expected-note {{called by 'kernel}}
+}
+
+void host_ok(void) {
+  __bf16 A;
+}
+
+int main()
+{  host_ok();
+  __bf16 var; // expected-note {{'var' defined here}}
+  kernel<class variables>([=]() {
+    (void)var; // expected-error {{'var' requires 16 bit size '__bf16' type support, but target 'spir64' does not support it}}
+    int B = sizeof(__bf16);
+  });
+
+  return 0;
+}
+