[Flang][OpenMP] Add support for integer multiplication reduction in worksharing-loop

[DylanFleming-arm]

Summary

Adds support for reduction of multiplcation
by extending OpenMP.cpp::genOpenMPReduction()
and altering the identity constant emitted in
OpenMP.cpp::createReductionDelc()

This patch builds D130077 and as such,
only supports reductions for interger types in
worksharping loops.

[tschuett]

flang/lib/Lower/OpenMP.cpp

811

Could this be get_identity(name)?

824

You misuse the identity to find the operator?

Could this be get_op(name)?

[clementval]

flang/lib/Lower/OpenMP.cpp

1687–1708

This part is copy/pasted from the code above. Please make it a function to avoid code duplication.

[DylanFleming-arm]

I moved the code for getting the identity to a seperate function as suggested.

However, I haven't created a function for creating the operations because it seems a little strange to me to use the StringRef (which was created from the operatior) to then find the operatior.
I do agree using the identiy was messy, so I've instead changed the createReductionDecl() to take in the operator, as that can then be used instead.
I am of course open to suggestions for changing this again, if anyone has problems with my current approch.

I've added a templated function, updateReduction(), in order to deal with the code duplication issue raised and updated genOpenMPReduction() to call it.

[peixin]

flang/lib/Lower/OpenMP.cpp

814

Can this be extracted out as to the function as getReductionInitValue(loc, type, name)?

[tschuett]

flang/lib/Lower/OpenMP.cpp

786

For consistency, you could add a statichere.

[DylanFleming-arm]

Created getReductionInitValue(), and made getOperationIdentity static

[awarzynski]

Thanks for working on this @DylanFleming-arm , some comments inline. I've not had a chance to scan the tests yet - will try later :)

flang/lib/Lower/OpenMP.cpp

786–792

It wasn't immediately obvious to me what this method is for (I assumed that you meant "identity" as somebody's name). I would actually fold this method into getReductionInitValue (that's the only that this is currently needed).

1707

The name of this method is not accurate - it only updates the reduction conditionally. And the condition verification is split across updateReduction and genOpenMPReduction. This comment above is key:

// This implementation finds the chain : load reduction var -> reduction_operation -> store reduction var and replaces it with the reduction operation.

It would make much more sense to check for a chain first (in genOpenMPReduction, perhaps in a dedicated method to make the implementation cleaner) and only once that condition is satisfied, have this method to update things unconditionally. Could you try that?

1708

symVal is a rather enigmatic name. IIUC, this is an accumulator and I would use that instead as a more descriptive name.

[DylanFleming-arm]

In D130767#3690673, @awarzynski wrote:

It would make much more sense to check for a chain first (in genOpenMPReduction, perhaps in a dedicated method to make the implementation cleaner) and only once that condition is satisfied, have this method to update things unconditionally. Could you try that?

I think this makes a lot of sense, however it's not directly related to adding multiplication support, so I've implemented these changes in a separate patch instead here: D131161

I'll rebase this patch on top of it shortly!

[DylanFleming-arm]

rebased onto D131161

[awarzynski]

"reduction-multiply.f90" is inconsistent with "wsloop-reduction-int.f90". I would rename this files as "wsloop-reduction-int-mul.f90" and "wsloop-reduction-int-add.f90", respectively.

flang/lib/Lower/OpenMP.cpp

786–792

Can you either fold this method or add a comment that explains what "identity" means in this context.

[tschuett]

I like named functions and named constants and values. Idk whether folding the two functions and adding comments or having two functions is better in terms of understanding the intent.

1 * 5 = 5
0 + 5 = 5

So 1 or 0 is the identity value. Maybe getIdentityValue + some doxygen is easier to understand.

[DylanFleming-arm]

Added comment to getOperationIdentity() to explain it's usage.
Renamed "name" to "reductionOpName" for clarity.

[awarzynski]

LGTM

From what I can see, you've addressed all comments from all reviewers, thanks! But just in case I missed something, please wait till tomorrow before merging this.

[peixin]

clang-format error in x64 debian.

[DylanFleming-arm]

I've re-ran clang-format on OpenMP.cpp, hopefully that fixes the problem!

flang/include/flang/Lower/OpenMP.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_OPENMP_H
 #define FORTRAN_LOWER_OPENMP_H
 
 #include <cinttypes>
 
+namespace mlir {
+class Value;
+} // namespace mlir
+
+namespace fir {
+class FirOpBuilder;
+} // namespace fir
+
 namespace Fortran {
 namespace parser {
 struct OpenMPConstruct;
 struct OpenMPDeclarativeConstruct;
 struct OmpEndLoopDirective;
 struct OmpClauseList;
 } // namespace parser
 
void genOpenMPConstruct(AbstractConverter &, pft::Evaluation &,
                         const parser::OpenMPConstruct &);
 void genOpenMPDeclarativeConstruct(AbstractConverter &, pft::Evaluation &,
                                    const parser::OpenMPDeclarativeConstruct &);
 int64_t getCollapseValue(const Fortran::parser::OmpClauseList &clauseList);
 void genThreadprivateOp(AbstractConverter &, const pft::Variable &);
 void genOpenMPReduction(AbstractConverter &,
                         const Fortran::parser::OmpClauseList &clauseList);
 
+template <typename OpType>
+void updateReduction(OpType &op, fir::FirOpBuilder &firOpBuilder,
+                     mlir::Value loadVal, mlir::Value symVal);
 } // namespace lower
 } // namespace Fortran
 
 #endif // FORTRAN_LOWER_OPENMP_H

flang/lib/Lower/OpenMP.cpp

auto taskOp = firOpBuilder.create<mlir::omp::TaskOp>(
         /*in_reductions=*/nullptr, priorityClauseOperand, allocateOperands,
         allocatorOperands);
     createBodyOfOp(taskOp, converter, currentLocation, eval, &opClauseList);
   } else {
     TODO(converter.getCurrentLocation(), "Unhandled block directive");
   }
 }
 
+int getOperationIdentity(llvm::StringRef name, mlir::Location loc) {
+  if (name.contains("add"))
+    return 0;
+  else if (name.contains("multiply"))
+    return 1;
+  TODO(loc, "Reduction of some intrinsic operators is not supported");
+}
+
 /// Creates an OpenMP reduction declaration and inserts it into the provided
 /// symbol table. The declaration has a constant initializer with the neutral
 /// value `initValue`, and the reduction combiner carried over from `reduce`.
 /// TODO: Generalize this for non-integer types, add atomic region.
-static omp::ReductionDeclareOp createReductionDecl(fir::FirOpBuilder &builder,
-                                                   llvm::StringRef name,
-                                                   mlir::Type type,
-                                                   mlir::Location loc) {
+static omp::ReductionDeclareOp createReductionDecl(
+    fir::FirOpBuilder &builder, llvm::StringRef name,
+    Fortran::parser::DefinedOperator::IntrinsicOperator intrinsicOp,
+    mlir::Type type, mlir::Location loc) {
   OpBuilder::InsertionGuard guard(builder);
   mlir::ModuleOp module = builder.getModule();
   mlir::OpBuilder modBuilder(module.getBodyRegion());
   auto decl = module.lookupSymbol<mlir::omp::ReductionDeclareOp>(name);
   if (!decl)
     decl = modBuilder.create<omp::ReductionDeclareOp>(loc, name, type);
   else
     return decl;
 
   builder.createBlock(&decl.initializerRegion(), decl.initializerRegion().end(),
                       {type}, {loc});
   builder.setInsertionPointToEnd(&decl.initializerRegion().back());
   Value init = builder.create<mlir::arith::ConstantOp>(
-      loc, type, builder.getIntegerAttr(type, 0));
+      loc, type, builder.getIntegerAttr(type, getOperationIdentity(name, loc)));
   builder.create<omp::YieldOp>(loc, init);
 
   builder.createBlock(&decl.reductionRegion(), decl.reductionRegion().end(),
                       {type, type}, {loc, loc});
   builder.setInsertionPointToEnd(&decl.reductionRegion().back());
   mlir::Value op1 = decl.reductionRegion().front().getArgument(0);
   mlir::Value op2 = decl.reductionRegion().front().getArgument(1);
-  Value addRes = builder.create<mlir::arith::AddIOp>(loc, op1, op2);
-  builder.create<omp::YieldOp>(loc, addRes);
+
+  Value res;
+  switch (intrinsicOp) {
+  case Fortran::parser::DefinedOperator::IntrinsicOperator::Add:
+    res = builder.create<mlir::arith::AddIOp>(loc, op1, op2);
+    break;
+  case Fortran::parser::DefinedOperator::IntrinsicOperator::Multiply:
+    res = builder.create<mlir::arith::MulIOp>(loc, op1, op2);
+    break;
+  default:
+    TODO(loc, "Reduction of some intrinsic operators is not supported");
+  }
+
+  builder.create<omp::YieldOp>(loc, res);
   return decl;
 }
 
 static mlir::omp::ScheduleModifier
 translateModifier(const Fortran::parser::OmpScheduleModifierType &m) {
   switch (m.v) {
   case Fortran::parser::OmpScheduleModifierType::ModType::Monotonic:
     return mlir::omp::ScheduleModifier::monotonic;
getSIMDModifier(const Fortran::parser::OmpScheduleClause &x) {
   }
   return mlir::omp::ScheduleModifier::none;
 }
 
 static std::string getReductionName(
     Fortran::parser::DefinedOperator::IntrinsicOperator intrinsicOp,
     mlir::Type ty) {
   std::string reductionName;
-  if (intrinsicOp == Fortran::parser::DefinedOperator::IntrinsicOperator::Add)
+
+  switch (intrinsicOp) {
+  case Fortran::parser::DefinedOperator::IntrinsicOperator::Add:
     reductionName = "add_reduction";
-  else
+    break;
+  case Fortran::parser::DefinedOperator::IntrinsicOperator::Multiply:
+    reductionName = "multiply_reduction";
+    break;
+  default:
     reductionName = "other_reduction";
+    break;
+  }
 
   return (llvm::Twine(reductionName) +
           (ty.isIntOrIndex() ? llvm::Twine("_i_") : llvm::Twine("_f_")) +
           llvm::Twine(ty.getIntOrFloatBitWidth()))
       .str();
 }
 
 static void genOMP(Fortran::lower::AbstractConverter &converter,
if (const auto &scheduleClause =
           reductionClause->v.t)};
       const auto &objectList{
           std::get<Fortran::parser::OmpObjectList>(reductionClause->v.t)};
       if (const auto &redDefinedOp =
               std::get_if<Fortran::parser::DefinedOperator>(&redOperator.u)) {
         const auto &intrinsicOp{
             std::get<Fortran::parser::DefinedOperator::IntrinsicOperator>(
                 redDefinedOp->u)};
-        if (intrinsicOp !=
-            Fortran::parser::DefinedOperator::IntrinsicOperator::Add)
+        switch (intrinsicOp) {
+        case Fortran::parser::DefinedOperator::IntrinsicOperator::Add:
+        case Fortran::parser::DefinedOperator::IntrinsicOperator::Multiply:
+          break;
+
+        default:
           TODO(currentLocation,
                "Reduction of some intrinsic operators is not supported");
+          break;
+        }
         for (const auto &ompObject : objectList.v) {
           if (const auto *name{
                   Fortran::parser::Unwrap<Fortran::parser::Name>(ompObject)}) {
             if (const auto *symbol{name->symbol}) {
               mlir::Value symVal = converter.getSymbolAddress(*symbol);
               mlir::Type redType =
                   symVal.getType().cast<fir::ReferenceType>().getEleTy();
               reductionVars.push_back(symVal);
               if (redType.isIntOrIndex()) {
                 decl = createReductionDecl(
                     firOpBuilder, getReductionName(intrinsicOp, redType),
-                    redType, currentLocation);
+                    intrinsicOp, redType, currentLocation);
               } else {
                 TODO(currentLocation,
                      "Reduction of some types is not supported");
               }
               reductionDeclSymbols.push_back(SymbolRefAttr::get(
                   firOpBuilder.getContext(), decl.sym_name()));
             }
           }
std::visit(
           },
       },
       ompDeclConstruct.u);
 }
 
 // Generate an OpenMP reduction operation. This implementation finds the chain :
 // load reduction var -> reduction_operation -> store reduction var and replaces
 // it with the reduction operation.
-// TODO: Currently assumes it is an integer addition reduction. Generalize this
-// for various reduction operation types.
+// TODO: Currently assumes it is an integer addition/multiplication reduction.
+// Generalize this for various reduction operation types.
 // TODO: Generate the reduction operation during lowering instead of creating
 // and removing operations since this is not a robust approach. Also, removing
 // ops in the builder (instead of a rewriter) is probably not the best approach.
 void Fortran::lower::genOpenMPReduction(
     Fortran::lower::AbstractConverter &converter,
     const Fortran::parser::OmpClauseList &clauseList) {
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
 
   for (const auto &clause : clauseList.v) {
     if (const auto &reductionClause =
             std::get_if<Fortran::parser::OmpClause::Reduction>(&clause.u)) {
       const auto &redOperator{std::get<Fortran::parser::OmpReductionOperator>(
           reductionClause->v.t)};
       const auto &objectList{
           std::get<Fortran::parser::OmpObjectList>(reductionClause->v.t)};
       if (auto reductionOp =
               std::get_if<Fortran::parser::DefinedOperator>(&redOperator.u)) {
         const auto &intrinsicOp{
             std::get<Fortran::parser::DefinedOperator::IntrinsicOperator>(
                 reductionOp->u)};
-        if (intrinsicOp !=
-            Fortran::parser::DefinedOperator::IntrinsicOperator::Add)
+
+        switch (intrinsicOp) {
+        case Fortran::parser::DefinedOperator::IntrinsicOperator::Add:
+        case Fortran::parser::DefinedOperator::IntrinsicOperator::Multiply:
+          break;
+        default:
           continue;
+        }
         for (const auto &ompObject : objectList.v) {
           if (const auto *name{
                   Fortran::parser::Unwrap<Fortran::parser::Name>(ompObject)}) {
             if (const auto *symbol{name->symbol}) {
               mlir::Value symVal = converter.getSymbolAddress(*symbol);
               mlir::Type redType =
                   symVal.getType().cast<fir::ReferenceType>().getEleTy();
               if (!redType.isIntOrIndex())
                 continue;
               for (mlir::OpOperand &use1 : symVal.getUses()) {
                 if (auto load = mlir::dyn_cast<fir::LoadOp>(use1.getOwner())) {
                   mlir::Value loadVal = load.getRes();
                   for (mlir::OpOperand &use2 : loadVal.getUses()) {
-                    if (auto add = mlir::dyn_cast<mlir::arith::AddIOp>(
-                            use2.getOwner())) {
-                      mlir::Value addRes = add.getResult();
-                      for (mlir::OpOperand &use3 : addRes.getUses()) {
-                        if (auto store =
-                                mlir::dyn_cast<fir::StoreOp>(use3.getOwner())) {
-                          if (store.getMemref() == symVal) {
-                            // Chain found! Now replace load->reduction->store
-                            // with the OpenMP reduction operation.
-                            mlir::OpBuilder::InsertPoint insertPtDel =
-                                firOpBuilder.saveInsertionPoint();
-                            firOpBuilder.setInsertionPoint(add);
-                            if (add.getLhs() == loadVal) {
-                              firOpBuilder.create<mlir::omp::ReductionOp>(
-                                  add.getLoc(), add.getRhs(), symVal);
-                            } else {
-                              firOpBuilder.create<mlir::omp::ReductionOp>(
-                                  add.getLoc(), add.getLhs(), symVal);
-                            }
-                            store.erase();
-                            add.erase();
-                            load.erase();
-                            firOpBuilder.restoreInsertionPoint(insertPtDel);
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
+                    if (isa<mlir::arith::AddIOp>(use2.getOwner())) {
+                      auto add =
+                          mlir::dyn_cast<mlir::arith::AddIOp>(use2.getOwner());
+                      updateReduction(add, firOpBuilder, loadVal, symVal);
+                    } else if (isa<mlir::arith::MulIOp>(use2.getOwner())) {
+                      auto mul =
+                          mlir::dyn_cast<mlir::arith::MulIOp>(use2.getOwner());
+                      updateReduction(mul, firOpBuilder, loadVal, symVal);
+                    } else
+                      continue;
+
+template <typename OpType>
+void Fortran::lower::updateReduction(OpType &op,
+                                     fir::FirOpBuilder &firOpBuilder,
+                                     mlir::Value loadVal, mlir::Value symVal) {
+  mlir::Value opRes = op.getResult();
+  for (mlir::OpOperand &use3 : opRes.getUses()) {
+    if (auto store = mlir::dyn_cast<fir::StoreOp>(use3.getOwner())) {
+      if (store.getMemref() == symVal) {
+        // Chain found! Now replace load->reduction->store
+        // with the OpenMP reduction operation.
+        mlir::OpBuilder::InsertPoint insertPtDel =
+            firOpBuilder.saveInsertionPoint();
+        firOpBuilder.setInsertionPoint(op);
+        if (op.getLhs() == loadVal) {
+          firOpBuilder.create<mlir::omp::ReductionOp>(op.getLoc(), op.getRhs(),
+                                                      symVal);
+        } else {
+          firOpBuilder.create<mlir::omp::ReductionOp>(op.getLoc(), op.getLhs(),
+                                                      symVal);
+        }
+        store.erase();
+        op.erase();
+        firOpBuilder.restoreInsertionPoint(insertPtDel);
       }
     }
   }
 }

flang/test/Lower/OpenMP/Todo/reduction-multiply.f90

-! RUN: %not_todo_cmd bbc -emit-fir -fopenmp -o - %s 2>&1 | FileCheck %s
-! RUN: %not_todo_cmd %flang_fc1 -emit-fir -fopenmp -o - %s 2>&1 | FileCheck %s
-
-! CHECK: not yet implemented: Reduction of some intrinsic operators is not supported
-subroutine reduction_multiply
-  integer :: x
-  !$omp parallel
-  !$omp do reduction(*:x)
-  do i=1, 100
-    x = x * i
-  end do
-  !$omp end do
-  !$omp end parallel
-  print *, x
-end subroutine

flang/test/Lower/OpenMP/reduction-multiply.f90

+! RUN: bbc -emit-fir -fopenmp %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-fir -fopenmp %s -o - | FileCheck %s
+
+!CHECK-LABEL: omp.reduction.declare
+!CHECK-SAME: @[[RED_I64_NAME:.*]] : i64 init {
+!CHECK: ^bb0(%{{.*}}: i64):
+!CHECK:  %[[C1_1:.*]] = arith.constant 1 : i64
+!CHECK:  omp.yield(%[[C1_1]] : i64)
+!CHECK: } combiner {
+!CHECK: ^bb0(%[[ARG0:.*]]: i64, %[[ARG1:.*]]: i64):
+!CHECK:  %[[RES:.*]] = arith.muli %[[ARG0]], %[[ARG1]] : i64
+!CHECK:  omp.yield(%[[RES]] : i64)
+!CHECK: }
+
+!CHECK-LABEL: omp.reduction.declare
+!CHECK-SAME: @[[RED_I32_NAME:.*]] : i32 init {
+!CHECK: ^bb0(%{{.*}}: i32):
+!CHECK:  %[[C1_1:.*]] = arith.constant 1 : i32
+!CHECK:  omp.yield(%[[C1_1]] : i32)
+!CHECK: } combiner {
+!CHECK: ^bb0(%[[ARG0:.*]]: i32, %[[ARG1:.*]]: i32):
+!CHECK:  %[[RES:.*]] = arith.muli %[[ARG0]], %[[ARG1]] : i32
+!CHECK:  omp.yield(%[[RES]] : i32)
+!CHECK: }
+
+!CHECK-LABEL: func.func @_QPsimple_reduction
+!CHECK:  %[[XREF:.*]] = fir.alloca i32 {bindc_name = "x", uniq_name = "_QFsimple_reductionEx"}
+!CHECK:  %[[C1_2:.*]] = arith.constant 1 : i32
+!CHECK:  fir.store %[[C1_2]] to %[[XREF]] : !fir.ref<i32>
+!CHECK:  omp.parallel
+!CHECK:    %[[I_PVT_REF:.*]] = fir.alloca i32 {adapt.valuebyref, pinned}
+!CHECK:    %[[C1_1:.*]] = arith.constant 1 : i32
+!CHECK:    %[[C10:.*]] = arith.constant 10 : i32
+!CHECK:    %[[C1_2:.*]] = arith.constant 1 : i32
+!CHECK:    omp.wsloop   reduction(@[[RED_I32_NAME]] -> %[[XREF]] : !fir.ref<i32>) for  (%[[IVAL:.*]]) : i32 = (%[[C1_1]]) to (%[[C10]]) inclusive step (%[[C1_2]])
+!CHECK:      fir.store %[[IVAL]] to %[[I_PVT_REF]] : !fir.ref<i32>
+!CHECK:      %[[I_PVT_VAL:.*]] = fir.load %[[I_PVT_REF]] : !fir.ref<i32>
+!CHECK:      omp.reduction %[[I_PVT_VAL]], %[[XREF]] : !fir.ref<i32>
+!CHECK:      omp.yield
+!CHECK:    omp.terminator
+!CHECK:  return
+
+subroutine simple_reduction
+  integer :: x
+  x = 1
+  !$omp parallel
+  !$omp do reduction(*:x)
+  do i=1, 10
+    x = x * i
+  end do
+  !$omp end do
+  !$omp end parallel
+end subroutine
+
+!CHECK-LABEL: func.func @_QPsimple_reduction_switch_order
+!CHECK:  %[[XREF:.*]] = fir.alloca i32 {bindc_name = "x", uniq_name = "_QFsimple_reduction_switch_orderEx"}
+!CHECK:  %[[C1_2:.*]] = arith.constant 1 : i32
+!CHECK:  fir.store %[[C1_2]] to %[[XREF]] : !fir.ref<i32>
+!CHECK:  omp.parallel
+!CHECK:    %[[I_PVT_REF:.*]] = fir.alloca i32 {adapt.valuebyref, pinned}
+!CHECK:    %[[C1_1:.*]] = arith.constant 1 : i32
+!CHECK:    %[[C10:.*]] = arith.constant 10 : i32
+!CHECK:    %[[C1_2:.*]] = arith.constant 1 : i32
+!CHECK:    omp.wsloop   reduction(@[[RED_I32_NAME]] -> %[[XREF]] : !fir.ref<i32>) for  (%[[IVAL:.*]]) : i32 = (%[[C1_1]]) to (%[[C10]]) inclusive step (%[[C1_2]])
+!CHECK:      fir.store %[[IVAL]] to %[[I_PVT_REF]] : !fir.ref<i32>
+!CHECK:      %[[I_PVT_VAL:.*]] = fir.load %[[I_PVT_REF]] : !fir.ref<i32>
+!CHECK:      omp.reduction %[[I_PVT_VAL]], %[[XREF]] : !fir.ref<i32>
+!CHECK:      omp.yield
+!CHECK:    omp.terminator
+!CHECK:  return
+
+subroutine simple_reduction_switch_order
+  integer :: x
+  x = 1
+  !$omp parallel
+  !$omp do reduction(*:x)
+  do i=1, 10
+  x = i * x
+  end do
+  !$omp end do
+  !$omp end parallel
+end subroutine
+
+!CHECK-LABEL: func.func @_QPmultiple_reductions_same_type
+!CHECK:  %[[XREF:.*]] = fir.alloca i32 {bindc_name = "x", uniq_name = "_QFmultiple_reductions_same_typeEx"}
+!CHECK:  %[[YREF:.*]] = fir.alloca i32 {bindc_name = "y", uniq_name = "_QFmultiple_reductions_same_typeEy"}
+!CHECK:  %[[ZREF:.*]] = fir.alloca i32 {bindc_name = "z", uniq_name = "_QFmultiple_reductions_same_typeEz"}
+!CHECK:  omp.parallel
+!CHECK:    %[[I_PVT_REF:.*]] = fir.alloca i32 {adapt.valuebyref, pinned}
+!CHECK:    omp.wsloop   reduction(@[[RED_I32_NAME]] -> %[[XREF]] : !fir.ref<i32>, @[[RED_I32_NAME]] -> %[[YREF]] : !fir.ref<i32>, @[[RED_I32_NAME]] -> %[[ZREF]] : !fir.ref<i32>) for  (%[[IVAL]]) : i32
+!CHECK:      fir.store %[[IVAL]] to %[[I_PVT_REF]] : !fir.ref<i32>
+!CHECK:      %[[I_PVT_VAL1:.*]] = fir.load %[[I_PVT_REF]] : !fir.ref<i32>
+!CHECK:      omp.reduction %[[I_PVT_VAL1]], %[[XREF]] : !fir.ref<i32>
+!CHECK:      %[[I_PVT_VAL2:.*]] = fir.load %[[I_PVT_REF]] : !fir.ref<i32>
+!CHECK:      omp.reduction %[[I_PVT_VAL2]], %[[YREF]] : !fir.ref<i32>
+!CHECK:      %[[I_PVT_VAL3:.*]] = fir.load %[[I_PVT_REF]] : !fir.ref<i32>
+!CHECK:      omp.reduction %[[I_PVT_VAL3]], %[[ZREF]] : !fir.ref<i32>
+!CHECK:      omp.yield
+!CHECK:    omp.terminator
+!CHECK:  return
+
+subroutine multiple_reductions_same_type
+  integer :: x,y,z
+  x = 1
+  y = 1
+  z = 1
+  !$omp parallel
+  !$omp do reduction(*:x,y,z)
+  do i=1, 10
+  x = x * i
+  y = y * i
+  z = z * i
+  end do
+  !$omp end do
+  !$omp end parallel
+end subroutine
+
+!CHECK-LABEL: func.func @_QPmultiple_reductions_different_type
+!CHECK:  %[[XREF:.*]] = fir.alloca i32 {bindc_name = "x", uniq_name = "_QFmultiple_reductions_different_typeEx"}
+!CHECK:  %[[YREF:.*]] = fir.alloca i64 {bindc_name = "y", uniq_name = "_QFmultiple_reductions_different_typeEy"}
+!CHECK:  omp.parallel
+!CHECK:    %[[I_PVT_REF:.*]] = fir.alloca i32 {adapt.valuebyref, pinned}
+!CHECK:    omp.wsloop   reduction(@[[RED_I32_NAME]] -> %[[XREF]] : !fir.ref<i32>, @[[RED_I64_NAME]] -> %[[YREF]] : !fir.ref<i64>) for  (%[[IVAL:.*]]) : i32
+!CHECK:      fir.store %[[IVAL]] to %[[I_PVT_REF]] : !fir.ref<i32>
+!CHECK:      %[[C2_32:.*]] = arith.constant 2 : i32
+!CHECK:      omp.reduction %[[C2_32]], %[[XREF]] : !fir.ref<i32>
+!CHECK:      %[[C2_64:.*]] = arith.constant 2 : i64
+!CHECK:      omp.reduction %[[C2_64]], %[[YREF]] : !fir.ref<i64>
+!CHECK:      omp.yield
+!CHECK:    omp.terminator
+!CHECK:  return
+
+subroutine multiple_reductions_different_type
+  integer :: x
+  integer(kind=8) :: y
+  !$omp parallel
+  !$omp do reduction(*:x,y)
+  do i=1, 10
+    x = x * 2_4
+    y = y * 2_8
+  end do
+  !$omp end do
+  !$omp end parallel
+end subroutine