Handle some comments.

Author: ergawy

flang/lib/Lower/OpenMP.cpp

@@ -163,7 +163,7 @@ class DataSharingProcessor {
 
   bool useDelayedPrivatizationWhenPossible;
   Fortran::lower::SymMap *symTable;
-  llvm::SetVector<mlir::SymbolRefAttr> privateInitializers;
+  llvm::SetVector<mlir::SymbolRefAttr> privatizers;
   llvm::SetVector<mlir::Value> privateSymHostAddrsses;
 
   bool needBarrier();
@@ -214,8 +214,8 @@ class DataSharingProcessor {
     loopIV = iv;
   }
 
-  const llvm::SetVector<mlir::SymbolRefAttr> &getPrivateInitializers() const {
-    return privateInitializers;
+  const llvm::SetVector<mlir::SymbolRefAttr> &getPrivatizers() const {
+    return privatizers;
   };
 
   const llvm::SetVector<mlir::Value> &getPrivateSymHostAddrsses() const {
@@ -547,7 +547,7 @@ void DataSharingProcessor::privatize() {
         symTable->popScope();
         firOpBuilder.restoreInsertionPoint(ip);
 
-        privateInitializers.insert(mlir::SymbolRefAttr::get(privatizerOp));
+        privatizers.insert(mlir::SymbolRefAttr::get(privatizerOp));
         privateSymHostAddrsses.insert(hsb.getAddr());
       } else {
         cloneSymbol(sym);
@@ -2584,8 +2584,8 @@ genParallelOp(Fortran::lower::AbstractConverter &converter,
     dsp.processStep1();
   }
 
-  llvm::SmallVector<mlir::Attribute> privateInits(
-      dsp.getPrivateInitializers().begin(), dsp.getPrivateInitializers().end());
+  llvm::SmallVector<mlir::Attribute> privatizers(dsp.getPrivatizers().begin(),
+                                                 dsp.getPrivatizers().end());
 
   llvm::SmallVector<mlir::Value> privateSymAddresses(
       dsp.getPrivateSymHostAddrsses().begin(),
@@ -2596,16 +2596,16 @@ genParallelOp(Fortran::lower::AbstractConverter &converter,
       &dsp,
       /*resultTypes=*/mlir::TypeRange(), ifClauseOperand,
       numThreadsClauseOperand, allocateOperands, allocatorOperands,
-      reductionVars, privateSymAddresses,
+      reductionVars,
       reductionDeclSymbols.empty()
           ? nullptr
           : mlir::ArrayAttr::get(converter.getFirOpBuilder().getContext(),
                                  reductionDeclSymbols),
-      procBindKindAttr,
-      privateInits.empty()
+      procBindKindAttr, privateSymAddresses,
+      privatizers.empty()
           ? nullptr
           : mlir::ArrayAttr::get(converter.getFirOpBuilder().getContext(),
-                                 privateInits));
+                                 privatizers));
 }
 
 static mlir::omp::SectionOp

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

@@ -179,10 +179,10 @@ def ParallelOp : OpenMP_Op<"parallel", [
              Variadic<AnyType>:$allocate_vars,
              Variadic<AnyType>:$allocators_vars,
              Variadic<OpenMP_PointerLikeType>:$reduction_vars,
-             Variadic<AnyType>:$private_vars,
              OptionalAttr<SymbolRefArrayAttr>:$reductions,
              OptionalAttr<ProcBindKindAttr>:$proc_bind_val,
-             OptionalAttr<SymbolRefArrayAttr>:$private_inits);
+             Variadic<AnyType>:$private_vars,
+             OptionalAttr<SymbolRefArrayAttr>:$privatizers);
 
   let regions = (region AnyRegion:$region);
 
@@ -208,7 +208,7 @@ def ParallelOp : OpenMP_Op<"parallel", [
           | `proc_bind` `(` custom<ClauseAttr>($proc_bind_val) `)`
           | `private` `(`
               custom<PrivateVarList>(
-                $private_vars, type($private_vars), $private_inits
+                $private_vars, type($private_vars), $privatizers
               ) `)`
     ) $region attr-dict
   }];

mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp

@@ -419,10 +419,10 @@ struct ParallelOpLowering : public OpRewritePattern<scf::ParallelOp> {
         /* allocate_vars = */ llvm::SmallVector<Value>{},
         /* allocators_vars = */ llvm::SmallVector<Value>{},
         /* reduction_vars = */ llvm::SmallVector<Value>{},
-        /*private_vars=*/mlir::ValueRange{},
         /* reductions = */ ArrayAttr{},
         /* proc_bind_val = */ omp::ClauseProcBindKindAttr{},
-        /*private_inits*/ nullptr);
+        /*private_vars=*/mlir::ValueRange{},
+        /*privatizers=*/nullptr);
     {
 
       OpBuilder::InsertionGuard guard(rewriter);

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

@@ -989,9 +989,10 @@ void ParallelOp::build(OpBuilder &builder, OperationState &state,
   ParallelOp::build(
       builder, state, /*if_expr_var=*/nullptr, /*num_threads_var=*/nullptr,
       /*allocate_vars=*/ValueRange(), /*allocators_vars=*/ValueRange(),
-      /*reduction_vars=*/ValueRange(), /*private_vars=*/ValueRange(),
+      /*reduction_vars=*/ValueRange(),
       /*reductions=*/nullptr,
-      /*proc_bind_val=*/nullptr, /*private_inits*/ nullptr);
+      /*proc_bind_val=*/nullptr, /*private_vars=*/ValueRange(),
+      /*privatizers*/ nullptr);
   state.addAttributes(attributes);
 }
 
@@ -1610,20 +1611,20 @@ void PrivateClauseOp::build(OpBuilder &odsBuilder, OperationState &odsState,
 static ParseResult parsePrivateVarList(
     OpAsmParser &parser,
     llvm::SmallVector<OpAsmParser::UnresolvedOperand, 4> &privateVarsOperands,
-    llvm::SmallVector<Type, 1> &privateVarsTypes, ArrayAttr &privateInitsAttr) {
+    llvm::SmallVector<Type, 1> &privateVarsTypes, ArrayAttr &privatizersAttr) {
   SymbolRefAttr privatizerSym;
   OpAsmParser::UnresolvedOperand arg;
   OpAsmParser::UnresolvedOperand blockArg;
   Type argType;
 
-  SmallVector<SymbolRefAttr> privateInitsVec;
+  SmallVector<SymbolRefAttr> privatizersVec;
 
   auto parsePrivatizers = [&]() -> ParseResult {
     if (parser.parseAttribute(privatizerSym) || parser.parseOperand(arg)) {
       return failure();
     }
 
-    privateInitsVec.push_back(privatizerSym);
+    privatizersVec.push_back(privatizerSym);
     privateVarsOperands.push_back(arg);
     return success();
   };
@@ -1638,9 +1639,9 @@ static ParseResult parsePrivateVarList(
   if (parser.parseCommaSeparatedList(parsePrivatizers))
     return failure();
 
-  SmallVector<Attribute> privateInits(privateInitsVec.begin(),
-                                      privateInitsVec.end());
-  privateInitsAttr = ArrayAttr::get(parser.getContext(), privateInits);
+  SmallVector<Attribute> privatizers(privatizersVec.begin(),
+                                     privatizersVec.end());
+  privatizersAttr = ArrayAttr::get(parser.getContext(), privatizers);
 
   if (parser.parseColon())
     return failure();
@@ -1654,17 +1655,18 @@ static ParseResult parsePrivateVarList(
 static void printPrivateVarList(OpAsmPrinter &printer, Operation *op,
                                 OperandRange privateVars,
                                 TypeRange privateVarTypes,
-                                std::optional<ArrayAttr> privateInitsAttr) {
+                                std::optional<ArrayAttr> privatizersAttr) {
   unsigned argIndex = 0;
-  assert(privateVars.size() == privateVarTypes.size() &&
-         ((privateVars.empty()) ||
-          (*privateInitsAttr &&
-           (privateInitsAttr->size() == privateVars.size()))));
+  // TODO Add an op verifier instead of this assertion.
+  assert(
+      privateVars.size() == privateVarTypes.size() &&
+      ((privateVars.empty()) ||
+       (*privatizersAttr && (privatizersAttr->size() == privateVars.size()))));
 
   for (const auto &privateVar : privateVars) {
-    assert(privateInitsAttr);
-    const auto &privateInitSym = (*privateInitsAttr)[argIndex];
-    printer << privateInitSym << " " << privateVar;
+    assert(privatizersAttr);
+    const auto &privatizerSym = (*privatizersAttr)[argIndex];
+    printer << privatizerSym << " " << privateVar;
 
     argIndex++;
     if (argIndex < privateVars.size())

mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp

@@ -1099,7 +1099,7 @@ convertOmpParallel(omp::ParallelOp opInst, llvm::IRBuilderBase &builder,
           privInit] = [&]() -> std::pair<mlir::Value, omp::PrivateClauseOp> {
       if (!opInst.getPrivateVars().empty()) {
         auto privVars = opInst.getPrivateVars();
-        auto privInits = opInst.getPrivateInits();
+        auto privInits = opInst.getPrivatizers();
         assert(privInits && privInits->size() == privVars.size());
 
         const auto *privInitIt = privInits->begin();