review comments

Author: Eric

flang/include/flang/Lower/PFTBuilder.h

@@ -21,6 +21,8 @@
 #include "flang/Common/template.h"
 #include "flang/Lower/Utils.h"
 #include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/attr.h"
+#include "flang/Semantics/symbol.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace mlir {
@@ -32,9 +34,11 @@ namespace semantics {
 class SemanticsContext;
 class Scope;
 } // namespace semantics
+
 namespace lower {
 
 bool definedInCommonBlock(const semantics::Symbol &sym);
+bool defaultRecursiveFunctionSetting();
 
 namespace pft {
 
@@ -551,7 +555,13 @@ struct FunctionLikeUnit : public ProgramUnit {
   FunctionLikeUnit(FunctionLikeUnit &&) = default;
   FunctionLikeUnit(const FunctionLikeUnit &) = delete;
 
-  bool isRecursive() { return isMainProgram() ? false : recursiveFunction; }
+  bool isRecursive() const {
+    auto sym = getSubprogramSymbol();
+    return !isMainProgram() &&
+           (sym.attrs().test(semantics::Attr::RECURSIVE) ||
+            (!sym.attrs().test(semantics::Attr::NON_RECURSIVE) &&
+             defaultRecursiveFunctionSetting()));
+  }
 
   std::vector<Variable> getOrderedSymbolTable() { return varList[0]; }
 
@@ -618,7 +628,6 @@ 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/Bridge.cpp

@@ -1732,7 +1732,6 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     auto globalName = mangleName(sym);
     bool isConst = sym.attrs().test(Fortran::semantics::Attr::PARAMETER);
     auto loc = genLocation(sym.name());
-    auto idxTy = builder->getIndexType();
     // FIXME: name returned does not consider subprogram's scope, is not unique
     fir::GlobalOp global = builder->getNamedGlobal(globalName);
     if (global) {

flang/lib/Lower/PFTBuilder.cpp

@@ -23,17 +23,12 @@ 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 {
@@ -1286,17 +1281,6 @@ 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,
@@ -1305,8 +1289,6 @@ 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);
 }
@@ -1319,8 +1301,6 @@ 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);
 }
@@ -1331,8 +1311,7 @@ Fortran::lower::pft::FunctionLikeUnit::FunctionLikeUnit(
     const semantics::SemanticsContext &)
     : ProgramUnit{func, parent},
       beginStmt{getFunctionStmt<parser::MpSubprogramStmt>(func)},
-      endStmt{getFunctionStmt<parser::EndMpSubprogramStmt>(func)},
-      recursiveFunction{defaultRecursiveFunctionSetting()} {
+      endStmt{getFunctionStmt<parser::EndMpSubprogramStmt>(func)} {
   auto symbol = getSymbol(*beginStmt);
   entryPointList[0].first = symbol;
   processSymbolTable(*symbol->scope(), varList);
@@ -1371,6 +1350,14 @@ Fortran::lower::createPFT(const parser::Program &root,
   return walker.result();
 }
 
+// FIXME: FlangDriver
+// This option should be integrated with the real driver as the default of
+// RECURSIVE vs. NON_RECURSIVE may be changed by other command line options,
+// etc., etc.
+bool Fortran::lower::defaultRecursiveFunctionSetting() {
+  return !nonRecursiveProcedures;
+}
+
 void Fortran::lower::dumpPFT(llvm::raw_ostream &outputStream,
                              const lower::pft::Program &pft) {
   PFTDumper{}.dumpPFT(outputStream, pft);