[flang][OpenMP] Store list of expressions in InitializerT (#170923)

The INITIALIZER clause holds a stylized expression that can be
intiantiated with different types. Currently, the InitializerT class
only holds one expression, which happens to correspond to the first type
in the DECLARE_REDUCTION type list.

Change InitializerT to hold a list of expressions instead, one for each
type. Keep the lowering code unchanged by picking the first expression
from the list.

Author: kparzysz

flang/lib/Lower/OpenMP/ClauseProcessor.cpp

@@ -412,6 +412,7 @@ bool ClauseProcessor::processInitializer(
       }
       // Lower the expression/function call
       lower::StatementContext stmtCtx;
+      const semantics::SomeExpr &initExpr = clause->v.front();
       mlir::Value result = common::visit(
           common::visitors{
               [&](const evaluate::ProcedureRef &procRef) -> mlir::Value {
@@ -422,7 +423,7 @@ bool ClauseProcessor::processInitializer(
               },
               [&](const auto &expr) -> mlir::Value {
                 mlir::Value exprResult = fir::getBase(convertExprToValue(
-                    loc, converter, clause->v, symMap, stmtCtx));
+                    loc, converter, initExpr, symMap, stmtCtx));
                 // Conversion can either give a value or a refrence to a value,
                 // we need to return the reduction type, so an optional load may
                 // be generated.
@@ -432,7 +433,7 @@ bool ClauseProcessor::processInitializer(
                     exprResult = fir::LoadOp::create(builder, loc, exprResult);
                 return exprResult;
               }},
-          clause->v.u);
+          initExpr.u);
       stmtCtx.finalizeAndPop();
       return result;
     };

flang/lib/Lower/OpenMP/Clauses.cpp

@@ -982,21 +982,23 @@ Init make(const parser::OmpClause::Init &inp,
 Initializer make(const parser::OmpClause::Initializer &inp,
                  semantics::SemanticsContext &semaCtx) {
   const parser::OmpInitializerExpression &iexpr = inp.v.v;
-  const parser::OmpStylizedInstance &styleInstance = iexpr.v.front();
-  const parser::OmpStylizedInstance::Instance &instance =
-      std::get<parser::OmpStylizedInstance::Instance>(styleInstance.t);
-  if (const auto *as = std::get_if<parser::AssignmentStmt>(&instance.u)) {
-    auto &expr = std::get<parser::Expr>(as->t);
-    return Initializer{makeExpr(expr, semaCtx)};
-  } else if (const auto *call = std::get_if<parser::CallStmt>(&instance.u)) {
-    if (call->typedCall) {
+  Initializer initializer;
+  for (const parser::OmpStylizedInstance &styleInstance : iexpr.v) {
+    auto &instance =
+        std::get<parser::OmpStylizedInstance::Instance>(styleInstance.t);
+    if (const auto *as = std::get_if<parser::AssignmentStmt>(&instance.u)) {
+      auto &expr = std::get<parser::Expr>(as->t);
+      initializer.v.push_back(makeExpr(expr, semaCtx));
+    } else if (const auto *call = std::get_if<parser::CallStmt>(&instance.u)) {
+      assert(call->typedCall && "Expecting typedCall");
       const auto &procRef = *call->typedCall;
-      semantics::SomeExpr evalProcRef{procRef};
-      return Initializer{evalProcRef};
+      initializer.v.push_back(semantics::SomeExpr(procRef));
+    } else {
+      llvm_unreachable("Unexpected initializer");
     }
   }
 
-  llvm_unreachable("Unexpected initializer");
+  return initializer;
 }
 
 InReduction make(const parser::OmpClause::InReduction &inp,

llvm/include/llvm/Frontend/OpenMP/ClauseT.h

@@ -763,8 +763,9 @@ struct InitT {
 template <typename T, typename I, typename E> //
 struct InitializerT {
   using InitializerExpr = E;
+  using List = ListT<InitializerExpr>;
   using WrapperTrait = std::true_type;
-  InitializerExpr v;
+  List v;
 };
 
 // V5.2: [5.5.10] `in_reduction` clause