PR: attribute check

Author: jchlanda

clang/lib/Sema/SemaDeclAttr.cpp

@@ -207,11 +207,6 @@ static std::enable_if_t<std::is_base_of_v<Attr, T>, SourceLocation>
 getAttrLoc(const T &AL) {
   return AL.getLocation();
 }
-template <typename T,
-          std::enable_if_t<std::is_same_v<AttributeCommonInfo, T>, bool> = true>
-static SourceLocation getAttrLoc(const T &AL) {
-  return AL.getScopeLoc();
-}
 static SourceLocation getAttrLoc(const ParsedAttr &AL) { return AL.getLoc(); }
 
 /// If Expr is a valid integer constant, get the value of the integer
@@ -4452,6 +4447,25 @@ void Sema::AddSYCLIntelMaxGlobalWorkDimAttr(Decl *D,
   D->addAttr(::new (Context) SYCLIntelMaxGlobalWorkDimAttr(Context, CI, E));
 }
 
+// Check that the value is a non-negative integer constant that can fit in
+// 32-bits. Issue correct error message and return false on failure.
+bool static check32BitInt(const Expr *E, Sema &S, llvm::APSInt &I,
+                          const AttributeCommonInfo &CI) {
+  if (!I.isIntN(32)) {
+    S.Diag(E->getExprLoc(), diag::err_ice_too_large)
+        << llvm::toString(I, 10, false) << 32 << /* Unsigned */ 1;
+    return false;
+  }
+
+  if (I.isSigned() && I.isNegative()) {
+    S.Diag(E->getExprLoc(), diag::err_attribute_requires_positive_integer)
+        << CI << /* Non-negative */ 1;
+    return false;
+  }
+
+  return true;
+}
+
 void Sema::AddSYCLIntelMinWorkGroupsPerComputeUnitAttr(
     Decl *D, const AttributeCommonInfo &CI, Expr *E) {
   if (Context.getLangOpts().SYCLIsDevice &&
@@ -4461,20 +4475,15 @@ void Sema::AddSYCLIntelMinWorkGroupsPerComputeUnitAttr(
     return;
   }
   if (!E->isValueDependent()) {
-    uint32_t Val;
-    if (!checkUInt32Argument(*this, CI, E, Val, UINT_MAX /* Idx */,
-                             true /* StrictlyUnsigned */))
-      return;
-
     // Validate that we have an integer constant expression and then store the
     // converted constant expression into the semantic attribute so that we
     // don't have to evaluate it again later.
     llvm::APSInt ArgVal;
     ExprResult Res = VerifyIntegerConstantExpression(E, &ArgVal);
     if (Res.isInvalid())
       return;
-    if (Val != ArgVal)
-      llvm_unreachable("Values must not differ.");
+    if (!check32BitInt(E, *this, ArgVal, CI))
+      return;
     E = Res.get();
 
     // Check to see if there's a duplicate attribute with different values
@@ -4526,21 +4535,16 @@ void Sema::AddSYCLIntelMaxWorkGroupsPerMultiprocessorAttr(
     }
   }
   if (!E->isValueDependent()) {
-    uint32_t Val;
-    if (!checkUInt32Argument(*this, CI, E, Val, UINT_MAX /* Idx */,
-                             true /* StrictlyUnsigned */))
-      return;
-
     // Validate that we have an integer constant expression and then store the
     // converted constant expression into the semantic attribute so that we
     // don't have to evaluate it again later.
     llvm::APSInt ArgVal;
     ExprResult Res = VerifyIntegerConstantExpression(E, &ArgVal);
     if (Res.isInvalid())
       return;
+    if (!check32BitInt(E, *this, ArgVal, CI))
+      return;
     E = Res.get();
-    if (Val != ArgVal)
-      llvm_unreachable("Values must not differ.");
 
     // Check to see if there's a duplicate attribute with different values
     // already applied to the declaration.

clang/test/SemaSYCL/lb_sm_70.cpp

@@ -26,14 +26,15 @@ int main() {
               intel::max_work_groups_per_mp(4)]] () { volatile int A = 42; });
 
     constexpr float A = 2.0;
-    // expected-error@+4 {{'min_work_groups_per_cu' attribute requires an integer constant}}
-    // expected-warning@+4 {{'maxclusterrank' requires sm_90 or higher, CUDA arch provided: sm_70, ignoring 'max_work_groups_per_mp' attribute}}
+    // expected-warning@+5{{'maxclusterrank' requires sm_90 or higher, CUDA arch provided: sm_70, ignoring 'max_work_groups_per_mp' attribute}}
+    // expected-error@+3 {{integral constant expression must have integral or unscoped enumeration type, not 'float'}}
     cgh.single_task<class T2>(
         [=] [[intel::max_work_group_size(1, 1, 256),
               intel::min_work_groups_per_cu(A),
               intel::max_work_groups_per_mp(4)]] () { volatile int A = 42; });
 
-    // expected-error@+3 {{'min_work_groups_per_cu' attribute requires an integer constant}}
+    // expected-error@+4 {{expression is not an integral constant expression}}
+    // expected-note@+3 {{value 2147483648 is outside the range of representable values of type 'int'}}
     cgh.single_task<class T3>(
         [=] [[intel::max_work_group_size(1, 1, 256),
               intel::min_work_groups_per_cu(2147483647 + 1)]] () {