Split out the target rewrite pass into its own source file.

Add the ability to test if a subprogram is recursive or not.

Author: Eric

flang/include/flang/Lower/PFTBuilder.h

@@ -70,6 +70,10 @@ class ReferenceVariantBase {
     return std::get<Ref<B>>(u).get();
   }
   template <typename B>
+  constexpr BaseType<B> &getStatement() const {
+    return std::get<Ref<parser::Statement<B>>>(u).get().statement;
+  }
+  template <typename B>
   constexpr BaseType<B> *getIf() const {
     auto *ptr = std::get_if<Ref<B>>(&u);
     return ptr ? &ptr->get() : nullptr;
@@ -547,6 +551,8 @@ struct FunctionLikeUnit : public ProgramUnit {
   FunctionLikeUnit(FunctionLikeUnit &&) = default;
   FunctionLikeUnit(const FunctionLikeUnit &) = delete;
 
+  bool isRecursive() { return isMainProgram() ? false : recursiveFunction; }
+
   std::vector<Variable> getOrderedSymbolTable() { return varList[0]; }
 
   bool isMainProgram() const {
@@ -574,6 +580,7 @@ struct FunctionLikeUnit : public ProgramUnit {
     assert(symbol && "not inside a procedure");
     return *symbol;
   }
+
   /// Return a pointer to the current entry point Evaluation.
   /// This is null for a primary entry point.
   Evaluation *getEntryEval() const {
@@ -611,6 +618,7 @@ struct FunctionLikeUnit : public ProgramUnit {
   /// Terminal basic block (if any)
   mlir::Block *finalBlock{};
   std::vector<std::vector<Variable>> varList;
+  bool recursiveFunction{};
 };
 
 /// Module-like units contain a list of function-like units.

flang/lib/Lower/PFTBuilder.cpp

@@ -23,6 +23,17 @@ static llvm::cl::opt<bool> clDisableStructuredFir(
     "no-structured-fir", llvm::cl::desc("disable generation of structured FIR"),
     llvm::cl::init(false), llvm::cl::Hidden);
 
+// FIXME: should be set with switch such as `--std=2018`.
+static llvm::cl::opt<bool> nonRecursiveProcedures(
+    "non-recursive-procedures",
+    llvm::cl::desc("Make procedures non-recursive by default. This was the "
+                   "default for all Fortran standards prior to 2018."),
+    llvm::cl::init(/*2018 standard=*/false));
+
+static bool defaultRecursiveFunctionSetting() {
+  return !nonRecursiveProcedures;
+}
+
 using namespace Fortran;
 
 namespace {
@@ -1275,6 +1286,17 @@ Fortran::lower::pft::FunctionLikeUnit::FunctionLikeUnit(
   }
 }
 
+template <typename A>
+static bool procedureIsRecursive(const A &stmt) {
+  for (const auto &p : std::get<std::list<parser::PrefixSpec>>(stmt.t)) {
+    if (std::holds_alternative<parser::PrefixSpec::Recursive>(p.u))
+      return true;
+    if (std::holds_alternative<parser::PrefixSpec::Non_Recursive>(p.u))
+      return false;
+  }
+  return defaultRecursiveFunctionSetting();
+}
+
 Fortran::lower::pft::FunctionLikeUnit::FunctionLikeUnit(
     const parser::FunctionSubprogram &func,
     const lower::pft::ParentVariant &parent,
@@ -1283,6 +1305,8 @@ Fortran::lower::pft::FunctionLikeUnit::FunctionLikeUnit(
       beginStmt{getFunctionStmt<parser::FunctionStmt>(func)},
       endStmt{getFunctionStmt<parser::EndFunctionStmt>(func)} {
   auto symbol = getSymbol(*beginStmt);
+  recursiveFunction =
+      procedureIsRecursive(beginStmt->getStatement<parser::FunctionStmt>());
   entryPointList[0].first = symbol;
   processSymbolTable(*symbol->scope(), varList);
 }
@@ -1295,6 +1319,8 @@ Fortran::lower::pft::FunctionLikeUnit::FunctionLikeUnit(
       beginStmt{getFunctionStmt<parser::SubroutineStmt>(func)},
       endStmt{getFunctionStmt<parser::EndSubroutineStmt>(func)} {
   auto symbol = getSymbol(*beginStmt);
+  recursiveFunction =
+      procedureIsRecursive(beginStmt->getStatement<parser::SubroutineStmt>());
   entryPointList[0].first = symbol;
   processSymbolTable(*symbol->scope(), varList);
 }
@@ -1305,7 +1331,8 @@ Fortran::lower::pft::FunctionLikeUnit::FunctionLikeUnit(
     const semantics::SemanticsContext &)
     : ProgramUnit{func, parent},
       beginStmt{getFunctionStmt<parser::MpSubprogramStmt>(func)},
-      endStmt{getFunctionStmt<parser::EndMpSubprogramStmt>(func)} {
+      endStmt{getFunctionStmt<parser::EndMpSubprogramStmt>(func)},
+      recursiveFunction{defaultRecursiveFunctionSetting()} {
   auto symbol = getSymbol(*beginStmt);
   entryPointList[0].first = symbol;
   processSymbolTable(*symbol->scope(), varList);