[flang] Lower some coarray statements to their runtime functions

[clementval]

Summary

This patch adds the lowering of coarray statements to the runtime
functions. The runtime functions are currently not implemented.

This patch is part of the upstreaming effort from fir-dev branch.

[jeanPerier]

flang/lib/Lower/Runtime.cpp

31

Should we actually align this with the other TODO format here ("not yet implemented: runtime support ....") ?

[clementval]

flang/lib/Lower/Runtime.cpp

31

Yeah that would make sense since Pete recently worked on other TODOs. I'll update that.

[clementval]

Use same TODO

[jeanPerier]

Thanks

flang/lib/Lower/Bridge.cpp

for (auto &pointerObject : stmt.v) {
       fir::MutableBoxValue box = genExprMutableBox(loc, *expr);
       fir::factory::disassociateMutableBox(*builder, loc, box);
     }
   }
 
   //===--------------------------------------------------------------------===//
 
   void genFIR(const Fortran::parser::EventPostStmt &stmt) {
-    TODO(toLocation(), "EventPostStmt lowering");
+    genEventPostStatement(*this, stmt);
   }
 
   void genFIR(const Fortran::parser::EventWaitStmt &stmt) {
-    TODO(toLocation(), "EventWaitStmt lowering");
+    genEventWaitStatement(*this, stmt);
   }
 
   void genFIR(const Fortran::parser::FormTeamStmt &stmt) {
-    TODO(toLocation(), "FormTeamStmt lowering");
+    genFormTeamStatement(*this, getEval(), stmt);
   }
 
   void genFIR(const Fortran::parser::LockStmt &stmt) {
-    TODO(toLocation(), "LockStmt lowering");
+    genLockStatement(*this, stmt);
   }
 
   fir::ExtendedValue
   genInitializerExprValue(const Fortran::lower::SomeExpr &expr,
                           Fortran::lower::StatementContext &stmtCtx) {
     return Fortran::lower::createSomeInitializerExpression(
         toLocation(), *this, expr, localSymbols, stmtCtx);
   }
void genFIR(const Fortran::parser::PointerAssignmentStmt &stmt) {
     genAssignment(*stmt.typedAssignment->v);
   }
 
   void genFIR(const Fortran::parser::AssignmentStmt &stmt) {
     genAssignment(*stmt.typedAssignment->v);
   }
 
   void genFIR(const Fortran::parser::SyncAllStmt &stmt) {
-    TODO(toLocation(), "SyncAllStmt lowering");
+    genSyncAllStatement(*this, stmt);
   }
 
   void genFIR(const Fortran::parser::SyncImagesStmt &stmt) {
-    TODO(toLocation(), "SyncImagesStmt lowering");
+    genSyncImagesStatement(*this, stmt);
   }
 
   void genFIR(const Fortran::parser::SyncMemoryStmt &stmt) {
-    TODO(toLocation(), "SyncMemoryStmt lowering");
+    genSyncMemoryStatement(*this, stmt);
   }
 
   void genFIR(const Fortran::parser::SyncTeamStmt &stmt) {
-    TODO(toLocation(), "SyncTeamStmt lowering");
+    genSyncTeamStatement(*this, stmt);
   }
 
   void genFIR(const Fortran::parser::UnlockStmt &stmt) {
-    TODO(toLocation(), "UnlockStmt lowering");
+    genUnlockStatement(*this, stmt);
   }
 
   void genFIR(const Fortran::parser::AssignStmt &stmt) {
     const Fortran::semantics::Symbol &symbol =
         *std::get<Fortran::parser::Name>(stmt.t).symbol;
     mlir::Location loc = toLocation();
     mlir::Value labelValue = builder->createIntegerConstant(
         loc, genType(symbol), std::get<Fortran::parser::Label>(stmt.t));

flang/lib/Lower/Runtime.cpp

 
 #define DEBUG_TYPE "flang-lower-runtime"
 
 using namespace Fortran::runtime;
 
 /// Runtime calls that do not return to the caller indicate this condition by
 /// terminating the current basic block with an unreachable op.
 static void genUnreachable(fir::FirOpBuilder &builder, mlir::Location loc) {
   builder.create<fir::UnreachableOp>(loc);
   mlir::Block *newBlock =
       builder.getBlock()->splitBlock(builder.getInsertionPoint());
   builder.setInsertionPointToStart(newBlock);
 }
 
 //===----------------------------------------------------------------------===//
 // Misc. Fortran statements that lower to runtime calls
 //===----------------------------------------------------------------------===//
if (const auto &quiet =
     operands.push_back(builder.createIntegerConstant(
         loc, calleeType.getInput(operands.size()), 0));
   }
 
   builder.create<fir::CallOp>(loc, callee, operands);
   genUnreachable(builder, loc);
 }
 
+void Fortran::lower::genFailImageStatement(
+    Fortran::lower::AbstractConverter &converter) {
+  fir::FirOpBuilder &builder = converter.getFirOpBuilder();
+  mlir::Location loc = converter.getCurrentLocation();
+  mlir::FuncOp callee =
+      fir::runtime::getRuntimeFunc<mkRTKey(FailImageStatement)>(loc, builder);
+  builder.create<fir::CallOp>(loc, callee, llvm::None);
+  genUnreachable(builder, loc);
+}
+
+void Fortran::lower::genEventPostStatement(
+    Fortran::lower::AbstractConverter &converter,
+    const Fortran::parser::EventPostStmt &) {
+  TODO(converter.getCurrentLocation(), "EVENT POST runtime");
+}
+
+void Fortran::lower::genEventWaitStatement(
+    Fortran::lower::AbstractConverter &converter,
+    const Fortran::parser::EventWaitStmt &) {
+  TODO(converter.getCurrentLocation(), "EVENT WAIT runtime");
+}
+
+void Fortran::lower::genLockStatement(
+    Fortran::lower::AbstractConverter &converter,
+    const Fortran::parser::LockStmt &) {
+  TODO(converter.getCurrentLocation(), "LOCK runtime");
+}
+
+void Fortran::lower::genUnlockStatement(
+    Fortran::lower::AbstractConverter &converter,
+    const Fortran::parser::UnlockStmt &) {
+  TODO(converter.getCurrentLocation(), "UNLOCK runtime");
+}
+
+void Fortran::lower::genSyncAllStatement(
+    Fortran::lower::AbstractConverter &converter,
+    const Fortran::parser::SyncAllStmt &) {
+  TODO(converter.getCurrentLocation(), "SYNC ALL runtime");
+}
+
+void Fortran::lower::genSyncImagesStatement(
+    Fortran::lower::AbstractConverter &converter,
+    const Fortran::parser::SyncImagesStmt &) {
+  TODO(converter.getCurrentLocation(), "SYNC IMAGES runtime");
+}
+
+void Fortran::lower::genSyncMemoryStatement(
+    Fortran::lower::AbstractConverter &converter,
+    const Fortran::parser::SyncMemoryStmt &) {
+  TODO(converter.getCurrentLocation(), "SYNC MEMORY runtime");
+}
+
+void Fortran::lower::genSyncTeamStatement(
+    Fortran::lower::AbstractConverter &converter,
+    const Fortran::parser::SyncTeamStmt &) {
+  TODO(converter.getCurrentLocation(), "SYNC TEAM runtime");
+}
+
 void Fortran::lower::genPauseStatement(
     Fortran::lower::AbstractConverter &converter,
     const Fortran::parser::PauseStmt &) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   mlir::Location loc = converter.getCurrentLocation();
   mlir::FuncOp callee =
       fir::runtime::getRuntimeFunc<mkRTKey(PauseStatement)>(loc, builder);
   builder.create<fir::CallOp>(loc, callee, llvm::None);