Implement more diagnostic cases

Author: Fznamznon

clang/lib/Sema/SemaSYCL.cpp

@@ -46,6 +46,11 @@ void Sema::checkSYCLDeviceFunction(SourceLocation Loc, FunctionDecl *Callee) {
   assert(Callee && "Callee may not be null.");
   FunctionDecl *Caller = dyn_cast<FunctionDecl>(getCurLexicalContext());
 
+  // Errors in unevaluated context don't need to be generated,
+  // so we can safely skip them.
+  if (isUnevaluatedContext())
+    return;
+
   // If the caller is known-emitted, mark the callee as known-emitted.
   // Otherwise, mark the call in our call graph so we can traverse it later.
   if (Caller && isKnownEmitted(*this, Caller))

clang/lib/Sema/SemaTemplateDeduction.cpp

@@ -4712,6 +4712,9 @@ Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result,
     }
   }
 
+  if (!Context.getTargetInfo().hasFloat128Type() &&
+      (Result->isFloat128Type()) && getLangOpts().SYCLIsDevice)
+    SYCLDiagIfDeviceCode(Loc, diag::err_type_unsupported) << "__float128";
   return DAR_Succeeded;
 }
 

clang/lib/Sema/SemaType.cpp

@@ -1516,12 +1516,8 @@ static QualType ConvertDeclSpecToType(TypeProcessingState &state) {
     break;
   case DeclSpec::TST_float128:
     if (!S.Context.getTargetInfo().hasFloat128Type() &&
-        S.getLangOpts().SYCLIsDevice)
-      S.SYCLDiagIfDeviceCode(DS.getTypeSpecTypeLoc(),
-                             diag::err_type_unsupported)
-          << "__float128";
-    else if (!S.Context.getTargetInfo().hasFloat128Type() &&
-             !(S.getLangOpts().OpenMP && S.getLangOpts().OpenMPIsDevice))
+        !(S.getLangOpts().OpenMP && S.getLangOpts().OpenMPIsDevice) &&
+        !S.getLangOpts().SYCLIsDevice)
       S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
           << "__float128";
     Result = Context.Float128Ty;
@@ -3095,7 +3091,6 @@ static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state,
   if (DeducedType *Deduced = T->getContainedDeducedType()) {
     AutoType *Auto = dyn_cast<AutoType>(Deduced);
     int Error = -1;
-
     // Is this a 'auto' or 'decltype(auto)' type (as opposed to __auto_type or
     // class template argument deduction)?
     bool IsCXXAutoType =
@@ -5441,6 +5436,11 @@ TypeSourceInfo *Sema::GetTypeForDeclarator(Declarator &D, Scope *S) {
 
   TypeSourceInfo *ReturnTypeInfo = nullptr;
   QualType T = GetDeclSpecTypeForDeclarator(state, ReturnTypeInfo);
+  if (!Context.getTargetInfo().hasFloat128Type() && (T->isFloat128Type()) &&
+      getLangOpts().SYCLIsDevice &&
+      D.getContext() != DeclaratorContext::TemplateArgContext)
+    SYCLDiagIfDeviceCode(D.getIdentifierLoc(), diag::err_type_unsupported)
+        << "__float128";
   if (D.isPrototypeContext() && getLangOpts().ObjCAutoRefCount)
     inferARCWriteback(state, T);
 
@@ -5551,6 +5551,11 @@ TypeSourceInfo *Sema::GetTypeForDeclaratorCast(Declarator &D, QualType FromTy) {
 
   TypeSourceInfo *ReturnTypeInfo = nullptr;
   QualType declSpecTy = GetDeclSpecTypeForDeclarator(state, ReturnTypeInfo);
+  if (!Context.getTargetInfo().hasFloat128Type() &&
+      (declSpecTy->isFloat128Type()) && getLangOpts().SYCLIsDevice &&
+      D.getContext() != DeclaratorContext::TemplateParamContext)
+    SYCLDiagIfDeviceCode(D.getIdentifierLoc(), diag::err_type_unsupported)
+        << "__float128";
 
   if (getLangOpts().ObjC) {
     Qualifiers::ObjCLifetime ownership = Context.getInnerObjCOwnership(FromTy);

clang/test/SemaSYCL/sycl-restrict.cpp

@@ -30,44 +30,53 @@ template<typename t> void foo2(){};
 // getCurLexicalContext() returns translation unit decl and we can diagnose only
 // inside function decls
 __float128 foo(__float128 P) {
-  // expected-error@+1 {{__float128 is not supported on this target}}
-  Z<__float128> A;
+
+  // TODO should this be diagnosed?
   bar(P);
-  bar(A);
   // expected-error@+1 {{__float128 is not supported on this target}}
   __float128 B;
   bar(B);
-  // expected-error@+1 {{__float128 is not supported on this target}}
-  bar((__float128)0);
 
-  // TODO
-  // NOT ANALYZED PROBLEM
+  // expected-error@+1 2{{__float128 is not supported on this target}}
+  auto D = bar((__float128)0);
   // expected-error@+1 {{__float128 is not supported on this target}}
+  auto C = D;
+
+  // expected-error@+1 2{{__float128 is not supported on this target}}
+  decltype(bar((__float128)0)) E = bar((__float128)0);
+
   foo2<__float128>();
+  Z<__float128> A;
   return P;
 }
 
 void usage() {
   // expected-error@+1 {{__float128 is not supported on this target}}
   __float128 A;
-  // expected-note@+1{{called by 'usage'}}
+  // expected-note@+2{{called by 'usage'}}
+  // expected-error@+1 {{__float128 is not supported on this target}}
   auto B = foo(A);
   int E = sizeof(__float128);
 
-  // NOT ANALYZED PROBLEM
+  // expected-error@+1 {{__float128 is not supported on this target}}
   decltype(A) C;
+  // expected-error@+1 {{__float128 is not supported on this target}}
   decltype(foo1()) D;
 }
 
 template <typename Name, typename Func>
 __attribute__((sycl_kernel)) void kernel_single_task(Func kernelFunc) {
-  // expected-note@+1 2{{called by 'kernel_single_task}}
+  // expected-note@+1 3{{called by 'kernel_single_task}}
   kernelFunc();
 }
 
 int main() {
-  // expected-note@+1 2{{called by 'operator()'}}
-  kernel_single_task<class fake_kernel>([]() { usage(); });
+  __float128 B = 1;
+  // expected-note@+2 2{{called by 'operator()'}}
+  kernel_single_task<class fake_kernel>([=]() {
+          usage();
+  // expected-error@+1 {{__float128 is not supported on this target}}
+          auto C = B; });
   return 0;
 }