[flang] Fixes several bugs relating to initialization expressions. An (#1493)

[clementval]

Summary

Fixes several bugs relating to initialization expressions. An
initialization expression has no access to dynamic resources like the
stack or the heap. It must reduce to a relocatable expression that the
loader can complete at runtime.

Adds regression test.

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

Co-authored-by: Jean Perier <[e-mail]>
Co-authored-by: Eric Schweitz <[e-mail]>

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/lib/Lower/PFTBuilder.cpp

static llvm::cl::opt<bool> clDisableStructuredFir(
     llvm::cl::init(false), llvm::cl::Hidden);
 
 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 llvm::cl::opt<bool> mainProgramGlobals(
+    "main-program-globals",
+    llvm::cl::desc(
+        "Allocate all variables in the main program as global variables and "
+        "not on the stack regardless of type, kind, and rank."),
+    llvm::cl::init(/*2018 standard=*/false), llvm::cl::Hidden);
+
 using namespace Fortran;
 
 namespace {
 /// Helpers to unveil parser node inside Fortran::parser::Statement<>,
 /// Fortran::parser::UnlabeledStatement, and Fortran::common::Indirection<>
 template <typename A>
 struct RemoveIndirectionHelper {
   using Type = A;
if (p->isActionStmt() || p->isConstructStmt() || p->isEndStmt() ||
       for (std::size_t entryIndex = entryPointList.size() - 1;
            entryIndex && !entryPointList[entryIndex].second->lexicalSuccessor;
            --entryIndex)
         // Link to the entry's first executable statement.
         entryPointList[entryIndex].second->lexicalSuccessor = p;
     } else if (const auto *entryStmt = p->getIf<parser::EntryStmt>()) {
       const semantics::Symbol *sym =
           std::get<parser::Name>(entryStmt->t).symbol;
+      if (auto *details = sym->detailsIf<semantics::GenericDetails>())
+        sym = details->specific();
       assert(sym->has<semantics::SubprogramDetails>() &&
              "entry must be a subprogram");
       entryPointList.push_back(std::pair{sym, p});
     }
     if (p->label.has_value())
       labelEvaluationMap->try_emplace(*p->label, p);
     return evaluationListStack.back()->back();
   }
return parent.visit(common::visitors{
       [](auto &) -> lower::pft::FunctionLikeUnit * { return nullptr; },
   });
 }
 
 bool Fortran::lower::definedInCommonBlock(const semantics::Symbol &sym) {
   return semantics::FindCommonBlockContaining(sym);
 }
 
-static bool isReEntrant(const Fortran::semantics::Scope &scope) {
+static bool isReentrant(const Fortran::semantics::Scope &scope) {
   if (scope.kind() == Fortran::semantics::Scope::Kind::MainProgram)
     return false;
   if (scope.kind() == Fortran::semantics::Scope::Kind::Subprogram) {
     const Fortran::semantics::Symbol *sym = scope.symbol();
     assert(sym && "Subprogram scope must have a symbol");
     return sym->attrs().test(semantics::Attr::RECURSIVE) ||
            (!sym->attrs().test(semantics::Attr::NON_RECURSIVE) &&
             Fortran::lower::defaultRecursiveFunctionSetting());
   }
   if (scope.kind() == Fortran::semantics::Scope::Kind::Module)
     return false;
   return true;
 }
 
 /// Is the symbol `sym` a global?
 bool Fortran::lower::symbolIsGlobal(const semantics::Symbol &sym) {
   if (const auto *details = sym.detailsIf<semantics::ObjectEntityDetails>()) {
     if (details->init())
       return true;
-    if (!isReEntrant(sym.owner())) {
+    if (!isReentrant(sym.owner())) {
       // Turn array and character of non re-entrant programs (like the main
       // program) into global memory.
       if (const Fortran::semantics::DeclTypeSpec *symTy = sym.GetType())
         if (symTy->category() == semantics::DeclTypeSpec::Character)
           if (auto e = symTy->characterTypeSpec().length().GetExplicit())
             return true;
       if (!details->shape().empty() || !details->coshape().empty())
         return true;
     }
+    if (mainProgramGlobals &&
+        sym.owner().kind() == Fortran::semantics::Scope::Kind::MainProgram)
+      return true;
   }
   return semantics::IsSaved(sym) || lower::definedInCommonBlock(sym) ||
          semantics::IsNamedConstant(sym);
 }
 
 namespace {
 /// This helper class is for sorting the symbols in the symbol table. We want
 /// the symbols in an order such that a symbol will be visited after those it
void visitSymbol(const Fortran::semantics::Symbol &symbol) {
     if (Fortran::semantics::IsProcedure(symbol)) {
       if (auto dynamicType = Fortran::evaluate::DynamicType::From(symbol)) {
         // Visit result length specification expressions that are explicit.
         if (dynamicType->category() ==
             Fortran::common::TypeCategory::Character) {
           if (std::optional<Fortran::evaluate::ExtentExpr> length =
                   dynamicType->GetCharLength())
             visitExpr(*length);
-        } else if (dynamicType->category() == common::TypeCategory::Derived) {
-          const Fortran::semantics::DerivedTypeSpec &derivedTypeSpec =
-              dynamicType->GetDerivedTypeSpec();
-          for (const auto &[_, param] : derivedTypeSpec.parameters())
+        } else if (const Fortran::semantics::DerivedTypeSpec *derivedTypeSpec =
+                       Fortran::evaluate::GetDerivedTypeSpec(dynamicType)) {
+          for (const auto &[_, param] : derivedTypeSpec->parameters())
             if (const Fortran::semantics::MaybeIntExpr &expr =
                     param.GetExplicit())
               visitExpr(expr.value());
         }
       }
     }
   }