[SYCL] Rename max_concurrency attribute to max_private_copies

Signed-off-by: Dmitry Sidorov <[email protected]>

Author: MrSidims

clang/include/clang/Basic/Attr.td

@@ -1498,12 +1498,12 @@ def IntelFPGANumBanks : Attr {
   }];
 }
 
-def IntelFPGAMaxConcurrency : InheritableAttr {
-  let Spellings = [GNU<"max_concurrency">, CXX11<"intelfpga","max_concurrency">];
+def IntelFPGAMaxPrivateCopies : InheritableAttr {
+  let Spellings = [GNU<"max_private_copies">, CXX11<"intelfpga","max_private_copies">];
   let Args = [ExprArgument<"Value">];
   let LangOpts = [SYCL];
   let Subjects = SubjectList<[IntelFPGALocalNonConstVar, Field], ErrorDiag>;
-  let Documentation = [IntelFPGAMaxConcurrencyAttrDocs];
+  let Documentation = [IntelFPGAMaxPrivateCopiesAttrDocs];
   let AdditionalMembers = [{
     static unsigned getMinValue() {
       return 0;

clang/include/clang/Basic/AttrDocs.td

@@ -1729,9 +1729,9 @@ with N banks.
   }];
 }
 
-def IntelFPGAMaxConcurrencyAttrDocs : Documentation {
+def IntelFPGAMaxPrivateCopiesAttrDocs : Documentation {
   let Category = DocCatVariable;
-  let Heading = "max_concurrency (IntelFPGA)";
+  let Heading = "max_private_copies (IntelFPGA)";
   let Content = [{
 This attribute may be attached to a variable or struct member declaration and
 instructs the backend to replicate the memory generated for the variable or

clang/lib/CodeGen/CodeGenModule.cpp

@@ -3539,7 +3539,7 @@ void CodeGenModule::generateIntelFPGAAnnotation(
     llvm::APSInt BWAInt = BWA->getValue()->EvaluateKnownConstInt(getContext());
     Out << '{' << BWA->getSpelling() << ':' << BWAInt << '}';
   }
-  if (const auto *MCA = D->getAttr<IntelFPGAMaxConcurrencyAttr>()) {
+  if (const auto *MCA = D->getAttr<IntelFPGAMaxPrivateCopiesAttr>()) {
     llvm::APSInt MCAInt = MCA->getValue()->EvaluateKnownConstInt(getContext());
     Out << '{' << MCA->getSpelling() << ':' << MCAInt << '}';
   }

clang/lib/Sema/SemaDeclAttr.cpp

@@ -3793,7 +3793,7 @@ void Sema::AddOneConstantValueAttr(SourceRange AttrRange, Decl *D, Expr *E,
     E = ICE.get();
   }
 
-  if (IntelFPGAMaxConcurrencyAttr::classof(&TmpAttr)) {
+  if (IntelFPGAMaxPrivateCopiesAttr::classof(&TmpAttr)) {
     if (!D->hasAttr<IntelFPGAMemoryAttr>())
       D->addAttr(IntelFPGAMemoryAttr::CreateImplicit(
           Context, IntelFPGAMemoryAttr::Default));
@@ -5083,7 +5083,7 @@ static bool checkIntelFPGARegisterAttrCompatibility(Sema &S, Decl *D,
     InCompat = true;
   if (checkAttrMutualExclusion<IntelFPGABankWidthAttr>(S, D, Attr))
     InCompat = true;
-  if (checkAttrMutualExclusion<IntelFPGAMaxConcurrencyAttr>(S, D, Attr))
+  if (checkAttrMutualExclusion<IntelFPGAMaxPrivateCopiesAttr>(S, D, Attr))
     InCompat = true;
   if (auto *NBA = D->getAttr<IntelFPGANumBanksAttr>())
     if (!NBA->isImplicit() &&
@@ -5122,13 +5122,13 @@ static void handleOneConstantPowerTwoValueAttr(Sema &S, Decl *D,
       Attr.getAttributeSpellingListIndex());
 }
 
-static void handleIntelFPGAMaxConcurrencyAttr(Sema &S, Decl *D,
+static void handleIntelFPGAMaxPrivateCopiesAttr(Sema &S, Decl *D,
                                               const ParsedAttr &Attr) {
-  checkForDuplicateAttribute<IntelFPGAMaxConcurrencyAttr>(S, D, Attr);
+  checkForDuplicateAttribute<IntelFPGAMaxPrivateCopiesAttr>(S, D, Attr);
   if (checkAttrMutualExclusion<IntelFPGARegisterAttr>(S, D, Attr))
     return;
 
-  S.AddOneConstantValueAttr<IntelFPGAMaxConcurrencyAttr>(
+  S.AddOneConstantValueAttr<IntelFPGAMaxPrivateCopiesAttr>(
       Attr.getRange(), D, Attr.getArgAsExpr(0),
       Attr.getAttributeSpellingListIndex());
 }
@@ -7503,8 +7503,8 @@ static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
   case ParsedAttr::AT_IntelFPGANumBanks:
     handleOneConstantPowerTwoValueAttr<IntelFPGANumBanksAttr>(S, D, AL);
     break;
-  case ParsedAttr::AT_IntelFPGAMaxConcurrency:
-    handleIntelFPGAMaxConcurrencyAttr(S, D, AL);
+  case ParsedAttr::AT_IntelFPGAMaxPrivateCopies:
+    handleIntelFPGAMaxPrivateCopiesAttr(S, D, AL);
     break;
 
   case ParsedAttr::AT_AnyX86NoCallerSavedRegisters:

clang/test/CodeGenSYCL/intel-fpga-local.cpp

@@ -4,13 +4,13 @@
 //CHECK: [[ANN2:@.str[\.]*[0-9]*]] = {{.*}}{register:1}
 //CHECK: [[ANN3:@.str[\.]*[0-9]*]] = {{.*}}{memory:DEFAULT}
 //CHECK: [[ANN4:@.str[\.]*[0-9]*]] = {{.*}}{memory:DEFAULT}{bankwidth:4}
-//CHECK: [[ANN5:@.str[\.]*[0-9]*]] = {{.*}}{memory:DEFAULT}{max_concurrency:8}
+//CHECK: [[ANN5:@.str[\.]*[0-9]*]] = {{.*}}{memory:DEFAULT}{max_private_copies:8}
 //CHECK: [[ANN10:@.str[\.]*[0-9]*]] = {{.*}}{memory:DEFAULT}{pump:1}
 //CHECK: [[ANN11:@.str[\.]*[0-9]*]] = {{.*}}{memory:DEFAULT}{pump:2}
 //CHECK: [[ANN6:@.str[\.]*[0-9]*]] = {{.*}}{memory:BLOCK_RAM}
 //CHECK: [[ANN7:@.str[\.]*[0-9]*]] = {{.*}}{memory:MLAB}
 //CHECK: [[ANN8:@.str[\.]*[0-9]*]] = {{.*}}{memory:DEFAULT}{bankwidth:8}
-//CHECK: [[ANN9:@.str[\.]*[0-9]*]] = {{.*}}{memory:DEFAULT}{max_concurrency:4}
+//CHECK: [[ANN9:@.str[\.]*[0-9]*]] = {{.*}}{memory:DEFAULT}{max_private_copies:4}
 
 void foo() {
   //CHECK: %[[VAR_ONE:[0-9]+]] = bitcast{{.*}}var_one
@@ -36,7 +36,7 @@ struct foo_two {
   int __attribute__((register)) f2;
   int __attribute__((__memory__)) f3;
   int __attribute__((__bankwidth__(4))) f4;
-  int __attribute__((max_concurrency(8))) f5;
+  int __attribute__((max_private_copies(8))) f5;
   int __attribute__((singlepump)) f6;
   int __attribute__((doublepump)) f7;
 };
@@ -101,7 +101,7 @@ void baz() {
   //CHECK: %[[V_SEVEN:[0-9]+]] = bitcast{{.*}}v_seven
   //CHECK: %[[V_SEVEN1:v_seven[0-9]+]] = bitcast{{.*}}v_seven
   //CHECK: llvm.var.annotation{{.*}}%[[V_SEVEN1]],{{.*}}[[ANN9]]
-  int v_seven [[intelfpga::max_concurrency(4)]];
+  int v_seven [[intelfpga::max_private_copies(4)]];
   //CHECK: %[[V_EIGHT:[0-9]+]] = bitcast{{.*}}v_eight
   //CHECK: %[[V_EIGHT1:v_eight[0-9]+]] = bitcast{{.*}}v_eight
   //CHECK: llvm.var.annotation{{.*}}%[[V_EIGHT1]],{{.*}}[[ANN10]]

clang/test/SemaSYCL/intel-fpga-local.cpp

@@ -79,18 +79,18 @@ void foo1()
 
   //CHECK: VarDecl{{.*}}v_seven
   //CHECK: IntelFPGAMemoryAttr{{.*}}Implicit
-  //CHECK: IntelFPGAMaxConcurrencyAttr
+  //CHECK: IntelFPGAMaxPrivateCopiesAttr
   //CHECK-NEXT: ConstantExpr
   //CHECK-NEXT: IntegerLiteral{{.*}}4{{$}}
-  __attribute__((max_concurrency(4)))
+  __attribute__((max_private_copies(4)))
   unsigned int v_seven[64];
 
   //CHECK: VarDecl{{.*}}v_seven2
   //CHECK: IntelFPGAMemoryAttr{{.*}}Implicit
-  //CHECK: IntelFPGAMaxConcurrencyAttr
+  //CHECK: IntelFPGAMaxPrivateCopiesAttr
   //CHECK-NEXT: ConstantExpr
   //CHECK-NEXT: IntegerLiteral{{.*}}8{{$}}
-  [[intelfpga::max_concurrency(8)]] unsigned int v_seven2[64];
+  [[intelfpga::max_private_copies(8)]] unsigned int v_seven2[64];
 
   //CHECK: VarDecl{{.*}}v_fourteen
   //CHECK: IntelFPGADoublePumpAttr
@@ -179,7 +179,7 @@ void foo1()
 
   //expected-error@+2{{attributes are not compatible}}
   __attribute__((__register__))
-  __attribute__((__max_concurrency__(16)))
+  __attribute__((__max_private_copies__(16)))
   //expected-note@-2 {{conflicting attribute is here}}
   unsigned int reg_six_two[64];
 
@@ -241,37 +241,37 @@ void foo1()
   __attribute__((__bankwidth__(0)))
   unsigned int bw_seven[64];
 
-  // max_concurrency
+  // max_private_copies_
   //expected-error@+2{{attributes are not compatible}}
-  __attribute__((__max_concurrency__(16)))
+  __attribute__((__max_private_copies__(16)))
   __attribute__((__register__))
   //expected-note@-2 {{conflicting attribute is here}}
   unsigned int mc_one[64];
 
   //CHECK: VarDecl{{.*}}mc_two
-  //CHECK: IntelFPGAMaxConcurrencyAttr
+  //CHECK: IntelFPGAMaxPrivateCopiesAttr
   //CHECK-NEXT: ConstantExpr
   //CHECK-NEXT: IntegerLiteral{{.*}}8{{$}}
-  //CHECK: IntelFPGAMaxConcurrencyAttr
+  //CHECK: IntelFPGAMaxPrivateCopiesAttr
   //CHECK-NEXT: ConstantExpr
   //CHECK-NEXT: IntegerLiteral{{.*}}16{{$}}
   //expected-warning@+2{{is already applied}}
-  __attribute__((__max_concurrency__(8)))
-  __attribute__((__max_concurrency__(16)))
+  __attribute__((__max_private_copies__(8)))
+  __attribute__((__max_private_copies__(16)))
   unsigned int mc_two[64];
 
-  //expected-error@+1{{'max_concurrency' attribute requires integer constant between 0 and 1048576 inclusive}}
-  __attribute__((__max_concurrency__(-4)))
+  //expected-error@+1{{'max_private_copies' attribute requires integer constant between 0 and 1048576 inclusive}}
+  __attribute__((__max_private_copies__(-4)))
   unsigned int mc_four[64];
 
-  int i_max_concurrency = 32; // expected-note {{declared here}}
+  int i_max_private_copies = 32; // expected-note {{declared here}}
   //expected-error@+1{{expression is not an integral constant expression}}
-  __attribute__((__max_concurrency__(i_max_concurrency)))
-  //expected-note@-1{{read of non-const variable 'i_max_concurrency' is not allowed in a constant expression}}
+  __attribute__((__max_private_copies__(i_max_private_copies)))
+  //expected-note@-1{{read of non-const variable 'i_max_private_copies' is not allowed in a constant expression}}
   unsigned int mc_five[64];
 
-  //expected-error@+1{{'__max_concurrency__' attribute takes one argument}}
-  __attribute__((__max_concurrency__(4,8)))
+  //expected-error@+1{{'__max_private_copies__' attribute takes one argument}}
+  __attribute__((__max_private_copies__(4,8)))
   unsigned int mc_six[64];
 
   // numbanks
@@ -317,17 +317,17 @@ void foo1()
 }
 
 //expected-error@+1{{attribute only applies to local non-const variables and non-static data members}}
-__attribute__((__max_concurrency__(8)))
+__attribute__((__max_private_copies__(8)))
 __constant unsigned int ext_two[64] = { 1, 2, 3 };
 
 void other2()
 {
   //expected-error@+1{{attribute only applies to local non-const variables and non-static data members}}
-  __attribute__((__max_concurrency__(8))) const int ext_six[64] = { 0, 1 };
+  __attribute__((__max_private_copies__(8))) const int ext_six[64] = { 0, 1 };
 }
 
 //expected-error@+1{{attribute only applies to local non-const variables and non-static data members}}
-void other3(__attribute__((__max_concurrency__(8))) int pfoo) {}
+void other3(__attribute__((__max_private_copies__(8))) int pfoo) {}
 
 struct foo {
   //CHECK: FieldDecl{{.*}}v_one
@@ -378,10 +378,10 @@ struct foo {
 
   //CHECK: FieldDecl{{.*}}v_seven
   //CHECK: IntelFPGAMemoryAttr{{.*}}Implicit
-  //CHECK: IntelFPGAMaxConcurrencyAttr
+  //CHECK: IntelFPGAMaxPrivateCopiesAttr
   //CHECK-NEXT: ConstantExpr
   //CHECK-NEXT: IntegerLiteral{{.*}}4{{$}}
-  __attribute__((__max_concurrency__(4))) unsigned int v_seven[64];
+  __attribute__((__max_private_copies__(4))) unsigned int v_seven[64];
 };
 
 template <typename name, typename Func>