[flang] Submodules
A submodule is a program unit that may contain the implementions of procedures
declared in an ancestor module or submodule.
Processing for the equivalence groups and variables declared in a submodule
scope is similar to existing processing for the equivalence groups and
variables in module and procedure scopes. However, module and procedure scopes
are tied directly to code in the Pre-FIR Tree (PFT), whereas processing for a
submodule must have access to an ancestor module scope that is guaranteed
to be present in a .mod file, but is not guaranteed to be in the PFT. This
difference is accommodated by tying processing directly to a front end scope.
Function scopes that can be processed on the fly are done that way; the
resulting variable information is never stored. Module and submodule scopes
whose symbol information may be needed during lowering of any number of module
procedures are instead cached on first use, and reused as needed.
These changes are a direct extension of current code. All module and submodule
variables in scope are processed, whether referenced or not. A possible
alternative would be to instead process symbols only when first used. While
this could ultimately be beneficial, such an approach must account for the
presence of equivalence groups. That information is not currently available
for on-the-fly variable processing.
Some additional changes are needed to include submodules in places where
modules must be considered, and to include separate module procedures in
places where other subprogram variants are considered. There is also a fix
for a bug involving the use of variables in an equivalence group in a
namelist group, which also involves scope processing code.
diff --git a/flang/lib/Lower/Bridge.cpp b/flang/lib/Lower/Bridge.cpp
index 9623803..d2f6353 100644
--- a/flang/lib/Lower/Bridge.cpp
+++ b/flang/lib/Lower/Bridge.cpp
@@ -3079,10 +3079,6 @@
void genFIR(const Fortran::parser::SelectTypeStmt &) {} // nop
void genFIR(const Fortran::parser::TypeGuardStmt &) {} // nop
- void genFIR(const Fortran::parser::NamelistStmt &) {
- TODO(toLocation(), "NamelistStmt lowering");
- }
-
/// Generate FIR for the Evaluation `eval`.
void genFIR(Fortran::lower::pft::Evaluation &eval,
bool unstructuredContext = true) {
@@ -3204,9 +3200,13 @@
Fortran::lower::genThreadprivateOp(*this, var);
}
- /// Prepare to translate a new function
+ /// Start translation of a function.
void startNewFunction(Fortran::lower::pft::FunctionLikeUnit &funit) {
assert(!builder && "expected nullptr");
+ const Fortran::semantics::Scope &scope = funit.getScope();
+ LLVM_DEBUG(llvm::dbgs() << "\n[bridge - startNewFunction]";
+ if (auto *sym = scope.symbol()) llvm::dbgs() << " " << *sym;
+ llvm::dbgs() << "\n");
Fortran::lower::CalleeInterface callee(funit, *this);
mlir::func::FuncOp func = callee.addEntryBlockAndMapArguments();
builder = new fir::FirOpBuilder(func, bridge.getKindMap());
@@ -3217,33 +3217,36 @@
mapDummiesAndResults(funit, callee);
- // Note: not storing Variable references because getOrderedSymbolTable
- // below returns a temporary.
+ // Non-primary results of a function with multiple entry points.
+ // These result values share storage with the primary result.
llvm::SmallVector<Fortran::lower::pft::Variable> deferredFuncResultList;
- // Backup actual argument for entry character results
- // with different lengths. It needs to be added to the non
- // primary results symbol before mapSymbolAttributes is called.
+ // Backup actual argument for entry character results with different
+ // lengths. It needs to be added to the non-primary results symbol before
+ // mapSymbolAttributes is called.
Fortran::lower::SymbolBox resultArg;
if (std::optional<Fortran::lower::CalleeInterface::PassedEntity>
passedResult = callee.getPassedResult())
resultArg = lookupSymbol(passedResult->entity->get());
Fortran::lower::AggregateStoreMap storeMap;
- // The front-end is currently not adding module variables referenced
- // in a module procedure as host associated. As a result we need to
- // instantiate all module variables here if this is a module procedure.
- // It is likely that the front-end behavior should change here.
- // This also applies to internal procedures inside module procedures.
- if (auto *module = Fortran::lower::pft::getAncestor<
- Fortran::lower::pft::ModuleLikeUnit>(funit))
- for (const Fortran::lower::pft::Variable &var :
- module->getOrderedSymbolTable())
- instantiateVar(var, storeMap);
+ // Map all containing submodule and module equivalences and variables, in
+ // case they are referenced. It might be better to limit this to variables
+ // that are actually referenced, although that is more complicated when
+ // there are equivalenced variables.
+ auto &scopeVariableListMap =
+ Fortran::lower::pft::getScopeVariableListMap(funit);
+ for (auto *scp = &scope.parent(); !scp->IsGlobal(); scp = &scp->parent())
+ if (scp->kind() == Fortran::semantics::Scope::Kind::Module)
+ for (const auto &var : Fortran::lower::pft::getScopeVariableList(
+ *scp, scopeVariableListMap))
+ instantiateVar(var, storeMap);
+
+ // Map function equivalences and variables.
mlir::Value primaryFuncResultStorage;
for (const Fortran::lower::pft::Variable &var :
- funit.getOrderedSymbolTable()) {
+ Fortran::lower::pft::getScopeVariableList(scope)) {
// Always instantiate aggregate storage blocks.
if (var.isAggregateStore()) {
instantiateVar(var, storeMap);
@@ -3251,9 +3254,9 @@
}
const Fortran::semantics::Symbol &sym = var.getSymbol();
if (funit.parentHasHostAssoc()) {
- // Never instantitate host associated variables, as they are already
- // instantiated from an argument tuple. Instead, just bind the symbol to
- // the reference to the host variable, which must be in the map.
+ // Never instantiate host associated variables, as they are already
+ // instantiated from an argument tuple. Instead, just bind the symbol
+ // to the host variable, which must be in the map.
const Fortran::semantics::Symbol &ultimate = sym.GetUltimate();
if (funit.parentHostAssoc().isAssociated(ultimate)) {
Fortran::lower::SymbolBox hostBox = lookupSymbol(ultimate);
@@ -3379,7 +3382,7 @@
startBlock(newBlock);
}
- /// Emit return and cleanup after the function has been translated.
+ /// Finish translation of a function.
void endNewFunction(Fortran::lower::pft::FunctionLikeUnit &funit) {
setCurrentPosition(Fortran::lower::pft::stmtSourceLoc(funit.endStmt));
if (funit.isMainProgram())
@@ -3387,12 +3390,15 @@
else
genFIRProcedureExit(funit, funit.getSubprogramSymbol());
funit.finalBlock = nullptr;
- LLVM_DEBUG(llvm::dbgs() << "*** Lowering result:\n\n"
+ LLVM_DEBUG(llvm::dbgs() << "\n[bridge - endNewFunction";
+ if (auto *sym = funit.scope->symbol()) llvm::dbgs()
+ << " " << sym->name();
+ llvm::dbgs() << "] generated IR:\n\n"
<< *builder->getFunction() << '\n');
- // FIXME: Simplification should happen in a normal pass, not here.
+ // Eliminate dead code as a prerequisite to calling other IR passes.
+ // FIXME: This simplification should happen in a normal pass, not here.
mlir::IRRewriter rewriter(*builder);
- (void)mlir::simplifyRegions(rewriter,
- {builder->getRegion()}); // remove dead code
+ (void)mlir::simplifyRegions(rewriter, {builder->getRegion()});
delete builder;
builder = nullptr;
hostAssocTuple = mlir::Value{};
@@ -3446,14 +3452,6 @@
/// Lower a procedure (nest).
void lowerFunc(Fortran::lower::pft::FunctionLikeUnit &funit) {
- if (!funit.isMainProgram()) {
- const Fortran::semantics::Symbol &procSymbol =
- funit.getSubprogramSymbol();
- if (procSymbol.owner().IsSubmodule())
- TODO(toLocation(), "support for submodules");
- if (Fortran::semantics::IsSeparateModuleProcedureInterface(&procSymbol))
- TODO(toLocation(), "separate module procedure");
- }
setCurrentPosition(funit.getStartingSourceLoc());
for (int entryIndex = 0, last = funit.entryPointList.size();
entryIndex < last; ++entryIndex) {
@@ -3473,8 +3471,10 @@
void lowerModuleDeclScope(Fortran::lower::pft::ModuleLikeUnit &mod) {
setCurrentPosition(mod.getStartingSourceLoc());
createGlobalOutsideOfFunctionLowering([&]() {
- for (const Fortran::lower::pft::Variable &var :
- mod.getOrderedSymbolTable()) {
+ auto &scopeVariableListMap =
+ Fortran::lower::pft::getScopeVariableListMap(mod);
+ for (const auto &var : Fortran::lower::pft::getScopeVariableList(
+ mod.getScope(), scopeVariableListMap)) {
// Only define the variables owned by this module.
const Fortran::semantics::Scope *owningScope = var.getOwningScope();
if (!owningScope || mod.getScope() == *owningScope)
