[OpenMP] Allow const parameters in declare simd linear clause

[huntergr]

Summary

Section 2.19.3 (List Item Privatization) of the OpenMP 5.0 standard does not apply to declarative directives, only to constructs. As such it's legal for a const-qualified function parameter to be marked as linear in a declare simd directive. I have confirmed this with the language committee.

Suggestions on a better approach are welcome -- I tried using DSAStack, but it didn't have a valid current directive when the restriction was checked.

[ABataev]

LG

[fpetrogalli]

clang/test/OpenMP/declare_simd_codegen.cpp

118

Shouldn't you check that the _ZGV * name is generated?

[huntergr]

clang/test/OpenMP/declare_simd_codegen.cpp

118

Ok, and I can take care of the formatting issue as well.

[huntergr]

• Added a function body to the test so that it would generate symbols
• Added check lines to ensure the mangled name is present
• Reformatted the params of Sema::CheckOpenMPLinearDecl to comply with coding style.

[fpetrogalli]

clang/test/OpenMP/declare_simd_codegen.cpp

327

I think we should add the same checks in the AArch64 test: OpenMP/declare_simd_aarch64.c, so that we won't forget about it when we switch to the vector-function-abi-variant attribute.

[huntergr]

• Removed the ) my editor helpfully added to the CHECK line
• Added a test to declare_simd_aarch64.c

[fpetrogalli]

LGTM, thank you @huntergr !

clang/include/clang/Sema/Sema.h

StmtResult ActOnOpenMPTargetTeamsDistributeSimdDirective(
       SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
 
   /// Checks correctness of linear modifiers.
   bool CheckOpenMPLinearModifier(OpenMPLinearClauseKind LinKind,
                                  SourceLocation LinLoc);
   /// Checks that the specified declaration matches requirements for the linear
   /// decls.
   bool CheckOpenMPLinearDecl(const ValueDecl *D, SourceLocation ELoc,
-                             OpenMPLinearClauseKind LinKind, QualType Type);
+                             OpenMPLinearClauseKind LinKind, QualType Type,
+                             bool IsDeclareSimd = false);
 
   /// Called on well-formed '\#pragma omp declare simd' after parsing of
   /// the associated method/function.
   DeclGroupPtrTy ActOnOpenMPDeclareSimdDirective(
       DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS,
       Expr *Simdlen, ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds,
       ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears,
       ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR);

clang/lib/Sema/SemaOpenMP.cpp

if (const auto *DRE = dyn_cast<DeclRefExpr>(E))
             continue;
           }
           LinearArgs[CanonPVD] = E;
           if (E->isValueDependent() || E->isTypeDependent() ||
               E->isInstantiationDependent() ||
               E->containsUnexpandedParameterPack())
             continue;
           (void)CheckOpenMPLinearDecl(CanonPVD, E->getExprLoc(), LinKind,
-                                      PVD->getOriginalType());
+                                      PVD->getOriginalType(),
+                                      /*IsDeclareSimd=*/true);
           continue;
         }
       }
     if (isa<CXXThisExpr>(E)) {
       if (UniformedLinearThis) {
         Diag(E->getExprLoc(), diag::err_omp_wrong_dsa)
             << getOpenMPClauseName(OMPC_linear)
             << getOpenMPClauseName(IsUniformedThis ? OMPC_uniform : OMPC_linear)
             << E->getSourceRange();
         Diag(UniformedLinearThis->getExprLoc(), diag::note_omp_explicit_dsa)
             << getOpenMPClauseName(IsUniformedThis ? OMPC_uniform
                                                    : OMPC_linear);
         continue;
       }
       UniformedLinearThis = E;
       if (E->isValueDependent() || E->isTypeDependent() ||
           E->isInstantiationDependent() || E->containsUnexpandedParameterPack())
         continue;
       (void)CheckOpenMPLinearDecl(/*D=*/nullptr, E->getExprLoc(), LinKind,
-                                  E->getType());
+                                  E->getType(), /*IsDeclareSimd=*/true);
       continue;
     }
     Diag(E->getExprLoc(), diag::err_omp_param_or_this_in_clause)
         << FD->getDeclName() << (isa<CXXMethodDecl>(ADecl) ? 1 : 0);
   }
   Expr *Step = nullptr;
   Expr *NewStep = nullptr;
   SmallVector<Expr *, 4> NewSteps;
if ((!LangOpts.CPlusPlus && LinKind != OMPC_LINEAR_val) ||
       LinKind == OMPC_LINEAR_unknown) {
     Diag(LinLoc, diag::err_omp_wrong_linear_modifier) << LangOpts.CPlusPlus;
     return true;
   }
   return false;
 }
 
 bool Sema::CheckOpenMPLinearDecl(const ValueDecl *D, SourceLocation ELoc,
-                                 OpenMPLinearClauseKind LinKind,
-                                 QualType Type) {
+                                 OpenMPLinearClauseKind LinKind, QualType Type,
+                                 bool IsDeclareSimd) {
   const auto *VD = dyn_cast_or_null<VarDecl>(D);
   // A variable must not have an incomplete type or a reference type.
   if (RequireCompleteType(ELoc, Type, diag::err_omp_linear_incomplete_type))
     return true;
   if ((LinKind == OMPC_LINEAR_uval || LinKind == OMPC_LINEAR_ref) &&
       !Type->isReferenceType()) {
     Diag(ELoc, diag::err_omp_wrong_linear_modifier_non_reference)
         << Type << getOpenMPSimpleClauseTypeName(OMPC_linear, LinKind);
     return true;
   }
   Type = Type.getNonReferenceType();
 
   // OpenMP 5.0 [2.19.3, List Item Privatization, Restrictions]
   // A variable that is privatized must not have a const-qualified type
   // unless it is of class type with a mutable member. This restriction does
-  // not apply to the firstprivate clause.
-  if (rejectConstNotMutableType(*this, D, Type, OMPC_linear, ELoc))
+  // not apply to the firstprivate clause, nor to the linear clause on
+  // declarative directives (like declare simd).
+  if (!IsDeclareSimd &&
+      rejectConstNotMutableType(*this, D, Type, OMPC_linear, ELoc))
     return true;
 
   // A list item must be of integral or pointer type.
   Type = Type.getUnqualifiedType().getCanonicalType();
   const auto *Ty = Type.getTypePtrOrNull();
   if (!Ty || (LinKind != OMPC_LINEAR_ref && !Ty->isDependentType() &&
               !Ty->isIntegralType(Context) && !Ty->isPointerType())) {
     Diag(ELoc, diag::err_omp_linear_expected_int_or_ptr) << Type;

clang/test/OpenMP/declare_simd_aarch64.c

 // AARCH64: "_ZGVnM8vv_c01"
 // AARCH64-NOT: c01
 
 #pragma omp declare simd inbranch uniform(x)
 double c02(double *x, char y);
 // AARCH64: "_ZGVnM16uv_c02" "_ZGVnM8uv_c02"
 // AARCH64-NOT: c02
 
+/************************************/
+/* Linear with a constant parameter */
+/************************************/
+
+#pragma omp declare simd notinbranch linear(i)
+double constlinear(const int i);
+// AARCH64: "_ZGVnN2l_constlinear" "_ZGVnN4l_constlinear"
+// AARCH64-NOT: constlinear
+
 /*************************/
 /* sincos-like signature */
 /*************************/
 #pragma omp declare simd linear(sin) linear(cos)
 void sincos(double in, double *sin, double *cos);
 // AARCH64: "_ZGVnN2vll_sincos"
 // AARCH64-NOT: sincos
 
void do_something() {
   simple_64bit(*L);
   *C = a01(*I);
   *L = a02(*S);
   *I = b01(I);
   *C = b02(C);
   D = b03(D);
   *I = c01(D, *S);
   *D = c02(D, *S);
+  constlinear(*I);
   sincos(*D, D, D);
   SinCos(*D, D, D);
   foo2(I, *I);
   foo3(I, *I, *C);
   foo4(I, *F);
 }
 
 typedef struct S {

clang/test/OpenMP/declare_simd_codegen.cpp

 #pragma omp declare simd
 #pragma omp declare simd inbranch linear(a : b) uniform(v, b)
 void bax(VV v, double *a, int b) {}
 #pragma omp declare simd uniform(q) aligned(q : 16) linear(k : 1)
 float foo(float *q, float x, int k) { return 0; }
 #pragma omp declare simd notinbranch
 double foo(double x) { return 0; }
 
+#pragma omp declare simd notinbranch linear(i)
+double constlinear(const int i) { return 0.0; }
+
 // CHECK-DAG: define {{.+}}@_Z5add_1Pf(
 // CHECK-DAG: define {{.+}}@_Z1hIiEvPT_S1_S1_S1_(
 // CHECK-DAG: define {{.+}}@_Z1hIfEvPT_S1_S1_S1_(
 // CHECK-DAG: define {{.+}}@_ZN2VV3addEii(
 // CHECK-DAG: define {{.+}}@_ZN2VV6taddpfEPfRS0_(
 // CHECK-DAG: define {{.+}}@_ZN2VV4taddERA_iRi(
 // CHECK-DAG: define {{.+}}@_Z1fRA_i(
 // CHECK-DAG: define {{.+}}@_ZN3TVVILi16EfE6taddpfEPfRS1_(
 // CHECK-DAG: define {{.+}}@_ZN3TVVILi16EfE4taddEi(
 // CHECK-DAG: define {{.+}}@_Z3fooILi64EEvRAT__iRPf(
 // CHECK-DAG: define {{.+}}@_Z3bar2VVPf(
 // CHECK-DAG: define {{.+}}@_Z3baz2VVPi(
 // CHECK-DAG: define {{.+}}@_Z3bay2VVRPd(
 // CHECK-DAG: define {{.+}}@_Z3bax2VVPdi(
 // CHECK-DAG: define {{.+}}@_Z3fooPffi(
 // CHECK-DAG: define {{.+}}@_Z3food(
 // CHECK-DAG: declare {{.+}}@_Z5add_2Pf(
+// CHECK-DAG: define {{.+}}@_Z11constlineari(
 
 // CHECK-DAG: "_ZGVbM4l8__Z5add_1Pf"
 // CHECK-DAG: "_ZGVbN4l8__Z5add_1Pf"
 // CHECK-DAG: "_ZGVcM8l8__Z5add_1Pf"
 // CHECK-DAG: "_ZGVcN8l8__Z5add_1Pf"
 // CHECK-DAG: "_ZGVdM8l8__Z5add_1Pf"
 // CHECK-DAG: "_ZGVdN8l8__Z5add_1Pf"
 // CHECK-DAG: "_ZGVeM16l8__Z5add_1Pf"

 // CHECK-DAG: "_ZGVdN4v__Z5add_2Pf"
 // CHECK-DAG: "_ZGVeN8v__Z5add_2Pf"
 
 // CHECK-DAG: "_ZGVbN2v__Z3food"
 // CHECK-DAG: "_ZGVcN4v__Z3food"
 // CHECK-DAG: "_ZGVdN4v__Z3food"
 // CHECK-DAG: "_ZGVeN8v__Z3food"
 
+// CHECK-DAG: "_ZGVbN2l__Z11constlineari"
+// CHECK-DAG: "_ZGVcN4l__Z11constlineari"
+// CHECK-DAG: "_ZGVdN4l__Z11constlineari"
+// CHECK-DAG: "_ZGVeN8l__Z11constlineari"
+
 // CHECK-NOT: "_ZGV{{.+}}__Z1fRA_i
 
 #endif