[OpenMP] Fix mangling for linear modifiers with variable stride

[mikerice]

Summary

This adds support for variable stride with the val, uval, and ref linear
modifiers. Previously only the no modifer type ls<argno> was supported.

val  -> Ls<argno>
uval -> Us<argno>
ref  -> Rs<argno>

[ABataev]

LG

clang/lib/CodeGen/CGOpenMPRuntime.cpp

if (IfCond) {
     RegionCodeGenTy ThenRCG(TargetThenGen);
     ThenRCG(CGF);
   }
 }
 
 namespace {
   /// Kind of parameter in a function with 'declare simd' directive.
 enum ParamKindTy {
-  LinearWithVarStride,
   Linear,
   LinearRef,
   LinearUVal,
   LinearVal,
   Uniform,
   Vector,
 };
 /// Attribute set of the parameter.
 struct ParamAttrTy {
   ParamKindTy Kind = Vector;
   llvm::APSInt StrideOrArg;
   llvm::APSInt Alignment;
+  bool HasVarStride = false;
 };
 } // namespace
 
 static unsigned evaluateCDTSize(const FunctionDecl *FD,
                                 ArrayRef<ParamAttrTy> ParamAttrs) {
   // Every vector variant of a SIMD-enabled function has a vector length (VLEN).
   // If OpenMP clause "simdlen" is used, the VLEN is the value of the argument
   // of that clause. The VLEN value must be power of 2.

 /// Mangle the parameter part of the vector function name according to
 /// their OpenMP classification. The mangling function is defined in
 /// section 4.5 of the AAVFABI(2021Q1).
 static std::string mangleVectorParameters(ArrayRef<ParamAttrTy> ParamAttrs) {
   SmallString<256> Buffer;
   llvm::raw_svector_ostream Out(Buffer);
   for (const auto &ParamAttr : ParamAttrs) {
     switch (ParamAttr.Kind) {
-    case LinearWithVarStride:
-      Out << "ls" << ParamAttr.StrideOrArg;
-      break;
     case Linear:
       Out << 'l';
       break;
     case LinearRef:
       Out << 'R';
       break;
     case LinearUVal:
       Out << 'U';
       break;
     case LinearVal:
       Out << 'L';
       break;
     case Uniform:
       Out << 'u';
       break;
     case Vector:
       Out << 'v';
       break;
     }
-    if (ParamAttr.Kind == Linear || ParamAttr.Kind == LinearRef ||
+    if (ParamAttr.HasVarStride)
+      Out << "s" << ParamAttr.StrideOrArg;
+    else if (ParamAttr.Kind == Linear || ParamAttr.Kind == LinearRef ||
              ParamAttr.Kind == LinearUVal || ParamAttr.Kind == LinearVal) {
       // Don't print the step value if it is not present or if it is
       // equal to 1.
       if (ParamAttr.StrideOrArg != 1)
         Out << ParamAttr.StrideOrArg;
     }
 
     if (!!ParamAttr.Alignment)
       Out << 'a' << ParamAttr.Alignment;

 }
 
 // This are the Functions that are needed to mangle the name of the
 // vector functions generated by the compiler, according to the rules
 // defined in the "Vector Function ABI specifications for AArch64",
 // available at
 // https://developer.arm.com/products/software-development-tools/hpc/arm-compiler-for-hpc/vector-function-abi.
 
-/// Maps To Vector (MTV), as defined in 3.1.1 of the AAVFABI.
-///
-/// TODO: Need to implement the behavior for reference marked with a
-/// var or no linear modifiers (1.b in the section). For this, we
-/// need to extend ParamKindTy to support the linear modifiers.
+/// Maps To Vector (MTV), as defined in 4.1.1 of the AAVFABI (2021Q1).
 static bool getAArch64MTV(QualType QT, ParamKindTy Kind) {
   QT = QT.getCanonicalType();
 
   if (QT->isVoidType())
     return false;
 
   if (Kind == ParamKindTy::Uniform)
     return false;
 
-  if (Kind == ParamKindTy::Linear)
+  if (Kind == ParamKindTy::LinearUVal || ParamKindTy::LinearRef)
     return false;
 
-  // TODO: Handle linear references with modifiers
-
-  if (Kind == ParamKindTy::LinearWithVarStride)
+  if ((Kind == ParamKindTy::Linear || Kind == ParamKindTy::LinearVal) &&
+      !QT->isReferenceType())
     return false;
 
   return true;
 }
 
 /// Pass By Value (PBV), as defined in 3.1.2 of the AAVFABI.
 static bool getAArch64PBV(QualType QT, ASTContext &C) {
   QT = QT.getCanonicalType();
for (const auto *Attr : FD->specific_attrs<OMPDeclareSimdDeclAttr>()) {
         ParamAttr.StrideOrArg = llvm::APSInt::getUnsigned(1);
         if (*SI) {
           Expr::EvalResult Result;
           if (!(*SI)->EvaluateAsInt(Result, C, Expr::SE_AllowSideEffects)) {
             if (const auto *DRE =
                     cast<DeclRefExpr>((*SI)->IgnoreParenImpCasts())) {
               if (const auto *StridePVD =
                       dyn_cast<ParmVarDecl>(DRE->getDecl())) {
-                ParamAttr.Kind = LinearWithVarStride;
+                ParamAttr.HasVarStride = true;
                 auto It = ParamPositions.find(StridePVD->getCanonicalDecl());
                 assert(It != ParamPositions.end() &&
                        "Function parameter not found");
                 ParamAttr.StrideOrArg = llvm::APSInt::getUnsigned(It->second);
               }
             }
           } else {
             ParamAttr.StrideOrArg = Result.Val.getInt();
           }
         }
         // If we are using a linear clause on a pointer, we need to
         // rescale the value of linear_step with the byte size of the
         // pointee type.
-        if (ParamAttr.Kind == Linear || ParamAttr.Kind == LinearRef)
+        if (!ParamAttr.HasVarStride &&
+            (ParamAttr.Kind == Linear || ParamAttr.Kind == LinearRef))
           ParamAttr.StrideOrArg = ParamAttr.StrideOrArg * PtrRescalingFactor;
         ++SI;
         ++MI;
       }
       llvm::APSInt VLENVal;
       SourceLocation ExprLoc;
       const Expr *VLENExpr = Attr->getSimdlen();
       if (VLENExpr) {

clang/test/OpenMP/declare_simd_codegen.cpp

 }
 
 // linear(ref(x) case
 #pragma omp declare simd simdlen(4) linear(ref(a):2) linear(ref(b))
 double Four(int& a, int &b) {
   return a;
 }
 
+// Test reference parameters with variable stride.
+#pragma omp declare simd simdlen(4) uniform(a)               \
+                         linear(b:2) linear(c:a)             \
+                         linear(val(d):4) linear(val(e):a)   \
+                         linear(uval(f):8) linear(uval(g):a) \
+                         linear(ref(h):16) linear(ref(i):a)
+double Five(int a, short &b, short &c, short &d, short &e, short &f, short &g,
+            short &h, short &i) {
+  return a + int(b);
+}
+
 // 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: define {{.+}}@_Z3OneRiPiiS_S0_i
+// CHECK-DAG: define {{.+}}@_Z3TwoRiPiiS_S0_i
+// CHECK-DAG: define {{.+}}@_Z5ThreeRiS_
+// CHECK-DAG: define {{.+}}@_Z4FourRiS_
+// CHECK-DAG: define {{.+}}@_Z4FiveiRsS_S_S_S_S_S_S_
 
 // CHECK-DAG: "_ZGVbM4l32__Z5add_1Pf"
 // CHECK-DAG: "_ZGVbN4l32__Z5add_1Pf"
 // CHECK-DAG: "_ZGVcM8l32__Z5add_1Pf"
 // CHECK-DAG: "_ZGVcN8l32__Z5add_1Pf"
 // CHECK-DAG: "_ZGVdM8l32__Z5add_1Pf"
 // CHECK-DAG: "_ZGVdN8l32__Z5add_1Pf"
 // CHECK-DAG: "_ZGVeM16l32__Z5add_1Pf"

 // CHECK-DAG: "_ZGVbM4L2l16l8Ll4l__Z3OneRiPiiS_S0_i"
 // CHECK-DAG: "_ZGVbN4L2l16l8Ll4l__Z3OneRiPiiS_S0_i"
 // CHECK-DAG: "_ZGVbM4L2l16l8Ll4l__Z3TwoRiPiiS_S0_i"
 // CHECK-DAG: "_ZGVbN4L2l16l8Ll4l__Z3TwoRiPiiS_S0_i"
 // CHECK-DAG: "_ZGVbM4U2U__Z5ThreeRiS_"
 // CHECK-DAG: "_ZGVbN4U2U__Z5ThreeRiS_"
 // CHECK-DAG: "_ZGVbM4R8R4__Z4FourRiS_"
 // CHECK-DAG: "_ZGVbN4R8R4__Z4FourRiS_"
+// CHECK-DAG: "_ZGVbM4uL2Ls0L4Ls0U8Us0R32Rs0__Z4FiveiRsS_S_S_S_S_S_S_"
+// CHECK-DAG: "_ZGVbN4uL2Ls0L4Ls0U8Us0R32Rs0__Z4FiveiRsS_S_S_S_S_S_S_"
 
 // CHECK-NOT: "_ZGV{{.+}}__Z1fRA_i
 
 #endif