[flang] Submodules

[vdonaldson]

Summary

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.

[PeteSteinfeld]

Aside from the one formatting nit, all builds and tests correctly and looks good.

flang/lib/Lower/PFTBuilder.cpp

1352

I'm getting a diff on this link when I run clang-format.

[vdonaldson]

flang/lib/Lower/PFTBuilder.cpp

1352

Should now be fixed, thanks

[vdonaldson]

https://reviews.llvm.org/D139892

[vdonaldson]

Build bots are flagging the code at PFTBuilder.cpp line 1788. I'm looking at the problem.

[vdonaldson]

In D139892#3993306, @vdonaldson wrote:

Build bots are flagging the code at PFTBuilder.cpp line 1788. I'm looking at the problem.

https://reviews.llvm.org/D139975

flang/include/flang/Lower/ConvertVariable.h

 // the fir::GlobalOp body at the fir::GlobalOp creation point rather than by
 // having genExtAddrInInitializer and genInitialDataTarget custom entry points
 // here to deal with this while lowering the initial expression value.
 
 /// Create initial-data-target fir.box in a global initializer region.
 /// This handles the local instantiation of the target variable.
 mlir::Value genInitialDataTarget(Fortran::lower::AbstractConverter &,
                                  mlir::Location, mlir::Type boxType,
-                                 const SomeExpr &initialTarget);
+                                 const SomeExpr &initialTarget,
+                                 bool couldBeInEquivalence = false);
 
 /// Call \p genInit to generate code inside \p global initializer region.
 void createGlobalInitialization(
     fir::FirOpBuilder &builder, fir::GlobalOp global,
     std::function<void(fir::FirOpBuilder &)> genInit);
 
 /// Generate address \p addr inside an initializer.
 fir::ExtendedValue

flang/include/flang/Lower/Mangler.h

 inline std::string mangleArrayLiteral(
     const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &x) {
   return mangleArrayLiteral(
       reinterpret_cast<const uint8_t *>(x.values().data()),
       x.values().size() * sizeof(x.values()[0]), x.shape(),
       Fortran::common::TypeCategory::Derived);
 }
 
+/// Return the compiler-generated name of a static namelist variable descriptor.
+std::string globalNamelistDescriptorName(const Fortran::semantics::Symbol &sym);
+
 } // namespace lower::mangle
 } // namespace Fortran
 
 #endif // FORTRAN_LOWER_MANGLER_H

flang/include/flang/Lower/PFTBuilder.h

 namespace Fortran::lower::pft {
 
 struct Evaluation;
 struct Program;
 struct ModuleLikeUnit;
 struct FunctionLikeUnit;
 
 using EvaluationList = std::list<Evaluation>;
-using LabelEvalMap = llvm::DenseMap<Fortran::parser::Label, Evaluation *>;
 
 /// Provide a variant like container that can hold references. It can hold
 /// constant or mutable references. It is used in the other classes to provide
 /// union of const references to parse-tree nodes.
 template <bool isConst, typename... A>
 class ReferenceVariantBase {
 public:
   template <typename B>
const semantics::Scope &getOwningScope() const {
       return getNamingSymbol().owner();
     }
     /// <offset, size> of the aggregate in its scope.
     Interval interval{};
     /// Symbol that gives its name to the aggregate. Always set by constructor.
     const semantics::Symbol *namingSymbol;
     /// Compiler generated symbol with the aggregate initial value if any.
     const semantics::Symbol *initialValueSymbol = nullptr;
-    /// Is this a global aggregate ?
+    /// Is this a global aggregate?
     bool isGlobalAggregate;
   };
 
   explicit Variable(const Fortran::semantics::Symbol &sym, bool global = false,
                     int depth = 0)
       : var{Nominal(&sym, depth, global)} {}
   explicit Variable(AggregateStore &&istore) : var{std::move(istore)} {}
 
bool isAggregateStore() const {
     return std::holds_alternative<AggregateStore>(var);
   }
 
   /// Is this variable a global?
   bool isGlobal() const {
     return std::visit([](const auto &x) { return x.isGlobal(); }, var);
   }
 
-  /// Is this a module variable ?
-  bool isModuleVariable() const {
+  /// Is this a module or submodule variable?
+  bool isModuleOrSubmoduleVariable() const {
     const semantics::Scope *scope = getOwningScope();
-    return scope && scope->IsModule();
+    return scope && scope->kind() == Fortran::semantics::Scope::Kind::Module;
   }
 
   const Fortran::semantics::Scope *getOwningScope() const {
     return std::visit(
         common::visitors{
             [](const Nominal &x) { return &x.symbol->GetUltimate().owner(); },
             [](const AggregateStore &agg) { return &agg.getOwningScope(); }},
         var);
struct Variable {
 
   /// An alias(er) is a variable that is part of a EQUIVALENCE that is allocated
   /// locally on the stack.
   bool isAlias() const {
     if (auto *s = std::get_if<Nominal>(&var))
       return s->aliaser;
     return false;
   }
-  std::size_t getAlias() const {
+  std::size_t getAliasOffset() const {
     if (auto *s = std::get_if<Nominal>(&var))
       return s->aliasOffset;
     return 0;
   }
   void setAlias(std::size_t offset) {
     if (auto *s = std::get_if<Nominal>(&var)) {
       s->aliaser = true;
       s->aliasOffset = offset;
struct Variable {
   }
 
   LLVM_DUMP_METHOD void dump() const;
 
 private:
   std::variant<Nominal, AggregateStore> var;
 };
 
+using VariableList = std::vector<Variable>;
+using ScopeVariableListMap =
+    std::map<const Fortran::semantics::Scope *, VariableList>;
+
+/// Find or create an ordered list of the equivalence sets and variables that
+/// appear in \p scope. The result is cached in \p map.
+const VariableList &getScopeVariableList(const Fortran::semantics::Scope &scope,
+                                         ScopeVariableListMap &map);
+
+/// Create an ordered list of the equivalence sets and variables that appear in
+/// \p scope. The result is not cached.
+VariableList getScopeVariableList(const Fortran::semantics::Scope &scope);
+
+/// Create an ordered list of the equivalence sets and variables that \p symbol
+/// depends on. \p symbol itself will be the last variable in the list.
+VariableList getDependentVariableList(const Fortran::semantics::Symbol &);
+
+void dump(VariableList &, std::string s = {}); // `s` is an optional dump label
+
 /// Function-like units may contain evaluations (executable statements) and
 /// nested function-like units (internal procedures and function statements).
 struct FunctionLikeUnit : public ProgramUnit {
   // wrapper statements for function-like syntactic structures
   using FunctionStatement =
       ReferenceVariant<parser::Statement<parser::ProgramStmt>,
                        parser::Statement<parser::EndProgramStmt>,
                        parser::Statement<parser::FunctionStmt>,
FunctionLikeUnit(
       const parser::SubroutineSubprogram &f, const PftNode &parent,
       const Fortran::semantics::SemanticsContext &semanticsContext);
   FunctionLikeUnit(
       const parser::SeparateModuleSubprogram &f, const PftNode &parent,
       const Fortran::semantics::SemanticsContext &semanticsContext);
   FunctionLikeUnit(FunctionLikeUnit &&) = default;
   FunctionLikeUnit(const FunctionLikeUnit &) = delete;
 
-  std::vector<Variable> getOrderedSymbolTable() { return varList[0]; }
-
   bool isMainProgram() const {
     return endStmt.isA<parser::Statement<parser::EndProgramStmt>>();
   }
 
   /// Get the starting source location for this function like unit
   parser::CharBlock getStartingSourceLoc() const;
 
   void setActiveEntry(int entryIndex) {
struct FunctionLikeUnit : public ProgramUnit {
   bool parentHasHostAssoc();
 
   /// Return the host associations for this function like unit. The list of host
   /// associations are kept in the host procedure.
   HostAssociations &getHostAssoc() { return hostAssociations; }
 
   LLVM_DUMP_METHOD void dump() const;
 
-  /// Anonymous programs do not have a begin statement
+  /// Get the function scope.
+  const Fortran::semantics::Scope &getScope() const { return *scope; }
+
+  /// Anonymous programs do not have a begin statement.
   std::optional<FunctionStatement> beginStmt;
   FunctionStatement endStmt;
+  const semantics::Scope *scope;
   EvaluationList evaluationList;
   LabelEvalMap labelEvaluationMap;
   SymbolLabelMap assignSymbolLabelMap;
   std::list<FunctionLikeUnit> nestedFunctions;
   /// <Symbol, Evaluation> pairs for each entry point.  The pair at index 0
   /// is the primary entry point; remaining pairs are alternate entry points.
   /// The primary entry point symbol is Null for an anonymous program.
   /// A named program symbol has MainProgramDetails.  Other symbols have
   /// SubprogramDetails.  Evaluations are filled in for alternate entries.
   llvm::SmallVector<std::pair<const semantics::Symbol *, Evaluation *>, 1>
       entryPointList{std::pair{nullptr, nullptr}};
   /// Current index into entryPointList.  Index 0 is the primary entry point.
   int activeEntry = 0;
   /// Primary result for function subprograms with alternate entries.  This
   /// is one of the largest result values, not necessarily the first one.
   const semantics::Symbol *primaryResult{nullptr};
   /// Terminal basic block (if any)
   mlir::Block *finalBlock{};
-  std::vector<std::vector<Variable>> varList;
   HostAssociations hostAssociations;
 };
 
 /// Module-like units contain a list of function-like units.
 struct ModuleLikeUnit : public ProgramUnit {
   // wrapper statements for module-like syntactic structures
   using ModuleStatement =
       ReferenceVariant<parser::Statement<parser::ModuleStmt>,
                        parser::Statement<parser::EndModuleStmt>,
                        parser::Statement<parser::SubmoduleStmt>,
                        parser::Statement<parser::EndSubmoduleStmt>>;
 
   ModuleLikeUnit(const parser::Module &m, const PftNode &parent);
   ModuleLikeUnit(const parser::Submodule &m, const PftNode &parent);
   ~ModuleLikeUnit() = default;
   ModuleLikeUnit(ModuleLikeUnit &&) = default;
   ModuleLikeUnit(const ModuleLikeUnit &) = delete;
 
   LLVM_DUMP_METHOD void dump() const;
 
-  std::vector<Variable> getOrderedSymbolTable() { return varList[0]; }
-
   /// Get the starting source location for this module like unit.
   parser::CharBlock getStartingSourceLoc() const;
 
   /// Get the module scope.
   const Fortran::semantics::Scope &getScope() const;
 
   ModuleStatement beginStmt;
   ModuleStatement endStmt;
   std::list<FunctionLikeUnit> nestedFunctions;
   EvaluationList evaluationList;
-  std::vector<std::vector<Variable>> varList;
 };
 
 /// Block data units contain the variables and data initializers for common
 /// blocks, etc.
 struct BlockDataUnit : public ProgramUnit {
   BlockDataUnit(const parser::BlockData &bd, const PftNode &parent,
                 const Fortran::semantics::SemanticsContext &semanticsContext);
   BlockDataUnit(BlockDataUnit &&) = default;
struct Program {
   Program(Program &&) = default;
   Program(const Program &) = delete;
 
   const std::list<Units> &getUnits() const { return units; }
   std::list<Units> &getUnits() { return units; }
   const semantics::CommonBlockList &getCommonBlocks() const {
     return commonBlocks;
   }
+  ScopeVariableListMap &getScopeVariableListMap() {
+    return scopeVariableListMap;
+  }
 
   /// LLVM dump method on a Program.
   LLVM_DUMP_METHOD void dump() const;
 
 private:
   std::list<Units> units;
   semantics::CommonBlockList commonBlocks;
+  ScopeVariableListMap scopeVariableListMap; // module and submodule scopes
 };
 
-/// Return the list of variables that appears in the specification expressions
-/// of a function result.
-std::vector<pft::Variable>
-buildFuncResultDependencyList(const Fortran::semantics::Symbol &);
-
 /// Helper to get location from FunctionLikeUnit/ModuleLikeUnit begin/end
 /// statements.
 template <typename T>
 static parser::CharBlock stmtSourceLoc(const T &stmt) {
   return stmt.visit(common::visitors{[](const auto &x) { return x.source; }});
 }
 
 /// Get the first PFT ancestor node that has type ParentType.
 template <typename ParentType, typename A>
 ParentType *getAncestor(A &node) {
   if (auto *seekedParent = node.parent.template getIf<ParentType>())
     return seekedParent;
   return node.parent.visit(common::visitors{
       [](Program &p) -> ParentType * { return nullptr; },
       [](auto &p) -> ParentType * { return getAncestor<ParentType>(p); }});
 }
 
+/// Get the "global" scopeVariableListMap, stored in the pft root node.
+template <typename A>
+ScopeVariableListMap &getScopeVariableListMap(A &node) {
+  Program *pftRoot = getAncestor<Program>(node);
+  assert(pftRoot && "pft must have a root");
+  return pftRoot->getScopeVariableListMap();
+}
+
 /// Call the provided \p callBack on all symbols that are referenced inside \p
 /// funit.
 void visitAllSymbols(const FunctionLikeUnit &funit,
                      std::function<void(const semantics::Symbol &)> callBack);
 
 /// Call the provided \p callBack on all symbols that are referenced inside \p
 /// eval region.
 void visitAllSymbols(const Evaluation &eval,

flang/lib/Lower/Bridge.cpp

#endif
   void genFIR(const Fortran::parser::EntryStmt &) {}           // nop
   void genFIR(const Fortran::parser::IfStmt &) {}              // nop
   void genFIR(const Fortran::parser::IfThenStmt &) {}          // nop
   void genFIR(const Fortran::parser::NonLabelDoStmt &) {}      // nop
   void genFIR(const Fortran::parser::OmpEndLoopDirective &) {} // nop
   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) {
     if (unstructuredContext) {
       // When transitioning from unstructured to structured code,
       // the structured code could be a target that starts a new block.
       maybeStartBlock(eval.isConstruct() && eval.lowerAsStructured()
                           ? eval.getFirstNestedEvaluation().block
void instantiateVar(const Fortran::lower::pft::Variable &var,
                       Fortran::lower::AggregateStoreMap &storeMap) {
     Fortran::lower::instantiateVariable(*this, var, localSymbols, storeMap);
     if (var.hasSymbol() &&
         var.getSymbol().test(
             Fortran::semantics::Symbol::Flag::OmpThreadprivate))
       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());
     assert(builder && "FirOpBuilder did not instantiate");
     builder->setFastMathFlags(bridge.getLoweringOptions().getMathOptions());
     builder->setInsertionPointToStart(&func.front());
     func.setVisibility(mlir::SymbolTable::Visibility::Public);
 
     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())
+
+    // 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);
         continue;
       }
       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);
           assert(hostBox && "host association is not in map");
           localSymbols.addSymbol(sym, hostBox.toExtendedValue());
           continue;
         }
       }
#endif
   }
 
   /// Conditionally switch code insertion to a new block.
   void maybeStartBlock(mlir::Block *newBlock) {
     if (newBlock)
       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())
       genExitRoutine();
     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{};
     localSymbols.clear();
   }
 
   /// Helper to generate GlobalOps when the builder is not positioned in any
   /// region block. This is required because the FirOpBuilder assumes it is
#endif
   void
   lowerCommonBlocks(const Fortran::semantics::CommonBlockList &commonBlocks) {
     createGlobalOutsideOfFunctionLowering(
         [&]() { Fortran::lower::defineCommonBlocks(*this, commonBlocks); });
   }
 
   /// 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) {
       funit.setActiveEntry(entryIndex);
       startNewFunction(funit); // the entry point for lowering this procedure
       for (Fortran::lower::pft::Evaluation &eval : funit.evaluationList)
         genFIR(eval);
       endNewFunction(funit);
     }
     funit.setActiveEntry(0);
     for (Fortran::lower::pft::FunctionLikeUnit &f : funit.nestedFunctions)
       lowerFunc(f); // internal procedure
   }
 
   /// Lower module variable definitions to fir::globalOp and OpenMP/OpenACC
   /// declarative construct.
   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)
           Fortran::lower::defineModuleVariable(*this, var);
       }
       for (auto &eval : mod.evaluationList)
         genFIR(eval);
     });

flang/lib/Lower/ConvertVariable.cpp

fir::ExtendedValue Fortran::lower::genExtAddrInInitializer(
   }
   return Fortran::lower::createInitializerAddress(loc, converter, addr,
                                                   globalOpSymMap, stmtCtx);
 }
 
 /// create initial-data-target fir.box in a global initializer region.
 mlir::Value Fortran::lower::genInitialDataTarget(
     Fortran::lower::AbstractConverter &converter, mlir::Location loc,
-    mlir::Type boxType, const Fortran::lower::SomeExpr &initialTarget) {
+    mlir::Type boxType, const Fortran::lower::SomeExpr &initialTarget,
+    bool couldBeInEquivalence) {
   Fortran::lower::SymMap globalOpSymMap;
   Fortran::lower::AggregateStoreMap storeMap;
   Fortran::lower::StatementContext stmtCtx;
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   if (Fortran::evaluate::UnwrapExpr<Fortran::evaluate::NullPointer>(
           initialTarget))
     return fir::factory::createUnallocatedBox(
         builder, loc, boxType,
         /*nonDeferredParams=*/std::nullopt);
   // Pointer initial data target, and NULL(mold).
   for (const auto &sym : Fortran::evaluate::CollectSymbols(initialTarget)) {
     // Length parameters processing will need care in global initializer
     // context.
     if (hasDerivedTypeWithLengthParameters(sym))
       TODO(loc, "initial-data-target with derived type length parameters");
-
     auto var = Fortran::lower::pft::Variable(sym, /*global=*/true);
+    if (couldBeInEquivalence) {
+      auto dependentVariableList =
+          Fortran::lower::pft::getDependentVariableList(sym);
+      for (Fortran::lower::pft::Variable var : dependentVariableList) {
+        if (!var.isAggregateStore())
+          break;
+        instantiateVariable(converter, var, globalOpSymMap, storeMap);
+      }
+      var = dependentVariableList.back();
+      assert(var.getSymbol().name() == sym->name() &&
+             "missing symbol in dependence list");
+    }
     Fortran::lower::instantiateVariable(converter, var, globalOpSymMap,
                                         storeMap);
   }
 
   // Handle NULL(mold) as a special case. Return an unallocated box of MOLD
   // type. The return box is correctly created as a fir.box<fir.ptr<T>> where
   // T is extracted from the MOLD argument.
   if (const Fortran::evaluate::ProcedureRef *procRef =

 getLinkageAttribute(fir::FirOpBuilder &builder,
                     const Fortran::lower::pft::Variable &var) {
   // Runtime type info for a same derived type is identical in each compilation
   // unit. It desired to avoid having to link against module that only define a
   // type. Therefore the runtime type info is generated everywhere it is needed
   // with `linkonce_odr` LLVM linkage.
   if (var.hasSymbol() && isRuntimeTypeInfoData(var.getSymbol()))
     return builder.createLinkOnceODRLinkage();
-  if (var.isModuleVariable())
+  if (var.isModuleOrSubmoduleVariable())
     return {}; // external linkage
   // Otherwise, the variable is owned by a procedure and must not be visible in
   // other compilation units.
   return builder.createInternalLinkage();
 }
 
 /// Instantiate a global variable. If it hasn't already been processed, add
 /// the global to the ModuleOp as a new uniqued symbol and initialize it with
 /// the correct value. It will be referenced on demand using `fir.addr_of`.
 static void instantiateGlobal(Fortran::lower::AbstractConverter &converter,
                               const Fortran::lower::pft::Variable &var,
                               Fortran::lower::SymMap &symMap) {
   const Fortran::semantics::Symbol &sym = var.getSymbol();
   assert(!var.isAlias() && "must be handled in instantiateAlias");
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   std::string globalName = Fortran::lower::mangle::mangleName(sym);
   mlir::Location loc = genLocation(converter, sym);
   fir::GlobalOp global = builder.getNamedGlobal(globalName);
   mlir::StringAttr linkage = getLinkageAttribute(builder, var);
-  if (var.isModuleVariable()) {
+  if (var.isModuleOrSubmoduleVariable()) {
     // A module global was or will be defined when lowering the module. Emit
     // only a declaration if the global does not exist at that point.
     global = declareGlobal(converter, var, globalName, linkage);
   } else {
     global = defineGlobal(converter, var, globalName, linkage);
   }
   auto addrOf = builder.create<fir::AddrOfOp>(loc, global.resultType(),
                                               global.getSymbol());

 }
 
 /// Retrieve the aggregate store instance of \p alias from an
 /// AggregateStoreMap.
 static mlir::Value
 getAggregateStore(Fortran::lower::AggregateStoreMap &storeMap,
                   const Fortran::lower::pft::Variable &alias) {
   Fortran::lower::AggregateStoreKey key = {alias.getOwningScope(),
-                                           alias.getAlias()};
+                                           alias.getAliasOffset()};
   auto iter = storeMap.find(key);
   assert(iter != storeMap.end());
   return iter->second;
 }
 
 /// Build the name for the storage of a global equivalence.
 static std::string mangleGlobalAggregateStore(
     const Fortran::lower::pft::Variable::AggregateStore &st) {
instantiateAggregateStore(Fortran::lower::AbstractConverter &converter,
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   mlir::IntegerType i8Ty = builder.getIntegerType(8);
   mlir::Location loc = converter.getCurrentLocation();
   std::string aggName = mangleGlobalAggregateStore(var.getAggregateStore());
   if (var.isGlobal()) {
     fir::GlobalOp global;
     auto &aggregate = var.getAggregateStore();
     mlir::StringAttr linkage = getLinkageAttribute(builder, var);
-    if (var.isModuleVariable()) {
+    if (var.isModuleOrSubmoduleVariable()) {
       // A module global was or will be defined when lowering the module. Emit
       // only a declaration if the global does not exist at that point.
       global = declareGlobalAggregateStore(converter, loc, aggregate, aggName,
                                            linkage);
     } else {
       global =
           defineGlobalAggregateStore(converter, aggregate, aggName, linkage);
     }
static void instantiateAlias(Fortran::lower::AbstractConverter &converter,
                              const Fortran::lower::pft::Variable &var,
                              Fortran::lower::SymMap &symMap,
                              Fortran::lower::AggregateStoreMap &storeMap) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   assert(var.isAlias());
   const Fortran::semantics::Symbol &sym = var.getSymbol();
   const mlir::Location loc = genLocation(converter, sym);
   mlir::IndexType idxTy = builder.getIndexType();
-  std::size_t aliasOffset = var.getAlias();
-  mlir::Value store = getAggregateStore(storeMap, var);
   mlir::IntegerType i8Ty = builder.getIntegerType(8);
   mlir::Type i8Ptr = builder.getRefType(i8Ty);
-  mlir::Value offset = builder.createIntegerConstant(
-      loc, idxTy, sym.GetUltimate().offset() - aliasOffset);
-  auto ptr = builder.create<fir::CoordinateOp>(loc, i8Ptr, store,
-                                               mlir::ValueRange{offset});
-  mlir::Value preAlloc =
-      castAliasToPointer(builder, loc, converter.genType(sym), ptr);
+  mlir::Type symType = converter.genType(sym);
+  std::size_t off = sym.GetUltimate().offset() - var.getAliasOffset();
+  mlir::Value storeAddr = getAggregateStore(storeMap, var);
+  mlir::Value offset = builder.createIntegerConstant(loc, idxTy, off);
+  mlir::Value bytePtr = builder.create<fir::CoordinateOp>(
+      loc, i8Ptr, storeAddr, mlir::ValueRange{offset});
+  mlir::Value typedPtr = castAliasToPointer(builder, loc, symType, bytePtr);
   Fortran::lower::StatementContext stmtCtx;
-  mapSymbolAttributes(converter, var, symMap, stmtCtx, preAlloc);
+  mapSymbolAttributes(converter, var, symMap, stmtCtx, typedPtr);
   // Default initialization is possible for equivalence members: see
   // F2018 19.5.3.4. Note that if several equivalenced entities have
   // default initialization, they must have the same type, and the standard
   // allows the storage to be default initialized several times (this has
   // no consequences other than wasting some execution time). For now,
   // do not try optimizing this to single default initializations of
   // the equivalenced storages. Keep lowering simple.
   if (mustBeDefaultInitializedAtRuntime(var))
void Fortran::lower::instantiateVariable(AbstractConverter &converter,
   if (var.hasSymbol()) {
     // Do not try to instantiate symbols twice, except for dummies and results,
     // that may have been mapped to the MLIR entry block arguments, and for
     // which the explicit specifications, if any, has not yet been lowered.
     const auto &sym = var.getSymbol();
     if (!IsDummy(sym) && !IsFunctionResult(sym) && symMap.lookupSymbol(sym))
       return;
   }
-  if (var.isAggregateStore()) {
+  LLVM_DEBUG(llvm::dbgs() << "instantiateVariable: "; var.dump());
+  if (var.isAggregateStore())
     instantiateAggregateStore(converter, var, storeMap);
-  } else if (const Fortran::semantics::Symbol *common =
-                 Fortran::semantics::FindCommonBlockContaining(
-                     var.getSymbol().GetUltimate())) {
+  else if (const Fortran::semantics::Symbol *common =
+                   var.getSymbol().GetUltimate()))
     instantiateCommon(converter, *common, var, symMap);
-  } else if (var.isAlias()) {
+  else if (var.isAlias())
     instantiateAlias(converter, var, symMap, storeMap);
-  } else if (var.isGlobal()) {
+  else if (var.isGlobal())
     instantiateGlobal(converter, var, symMap);
-  } else {
+  else
     instantiateLocal(converter, var, symMap);
-  }
-}
 
 void Fortran::lower::mapCallInterfaceSymbols(
     AbstractConverter &converter, const Fortran::lower::CallerInterface &caller,
     SymMap &symMap) {
   Fortran::lower::AggregateStoreMap storeMap;
   const Fortran::semantics::Symbol &result = caller.getResultSymbol();
   for (Fortran::lower::pft::Variable var :
-       Fortran::lower::pft::buildFuncResultDependencyList(result)) {
+       Fortran::lower::pft::getDependentVariableList(result)) {
     if (var.isAggregateStore()) {
       instantiateVariable(converter, var, symMap, storeMap);
-    } else {
-      const Fortran::semantics::Symbol &sym = var.getSymbol();
-      const auto *hostDetails =
-          sym.detailsIf<Fortran::semantics::HostAssocDetails>();
-      if (hostDetails && !var.isModuleVariable()) {
-        // The callee is an internal procedure `A` whose result properties
-        // depend on host variables. The caller may be the host, or another
-        // internal procedure `B` contained in the same host.  In the first
-        // case, the host symbol is obviously mapped, in the second case, it
-        // must also be mapped because
-        // HostAssociations::internalProcedureBindings that was called when
-        // lowering `B` will have mapped all host symbols of captured variables
-        // to the tuple argument containing the composite of all host associated
-        // variables, whether or not the host symbol is actually referred to in
-        // `B`. Hence it is possible to simply lookup the variable associated to
-        // the host symbol without having to go back to the tuple argument.
-        Fortran::lower::SymbolBox hostValue =
-            symMap.lookupSymbol(hostDetails->symbol());
-        assert(hostValue && "callee host symbol must be mapped on caller side");
-        symMap.addSymbol(sym, hostValue.toExtendedValue());
-        // The SymbolBox associated to the host symbols is complete, skip
-        // instantiateVariable that would try to allocate a new storage.
-        continue;
-      }
-      if (Fortran::semantics::IsDummy(sym) && sym.owner() == result.owner()) {
-        // Get the argument for the dummy argument symbols of the current call.
-        symMap.addSymbol(sym, caller.getArgumentValue(sym));
-        // All the properties of the dummy variable may not come from the actual
-        // argument, let instantiateVariable handle this.
-      }
-      // If this is neither a host associated or dummy symbol, it must be a
-      // module or common block variable to satisfy specification expression
-      // requirements in 10.1.11, instantiateVariable will get its address and
-      // properties.
-      instantiateVariable(converter, var, symMap, storeMap);
-    }
-  }
-}
+      continue;
+    }
+    if (&sym == &result)
+      continue;
+    if (hostDetails && !var.isModuleOrSubmoduleVariable()) {
 
 void Fortran::lower::createRuntimeTypeInfoGlobal(
     Fortran::lower::AbstractConverter &converter, mlir::Location loc,
     const Fortran::semantics::Symbol &typeInfoSym) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   std::string globalName = Fortran::lower::mangle::mangleName(typeInfoSym);
   auto var = Fortran::lower::pft::Variable(typeInfoSym, /*global=*/true);
   mlir::StringAttr linkage = getLinkageAttribute(builder, var);
   defineGlobal(converter, var, globalName, linkage);
 }

flang/lib/Lower/IO.cpp

 
 #include "flang/Lower/IO.h"
 #include "flang/Common/uint128.h"
 #include "flang/Evaluate/tools.h"
 #include "flang/Lower/Allocatable.h"
 #include "flang/Lower/Bridge.h"
 #include "flang/Lower/ConvertExpr.h"
 #include "flang/Lower/ConvertVariable.h"
+#include "flang/Lower/Mangler.h"
 #include "flang/Lower/PFTBuilder.h"
 #include "flang/Lower/Runtime.h"
 #include "flang/Lower/StatementContext.h"
 #include "flang/Lower/Support/Utils.h"
 #include "flang/Lower/VectorSubscripts.h"
 #include "flang/Optimizer/Builder/Character.h"
 #include "flang/Optimizer/Builder/Complex.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
fir::SequenceType listTy = fir::SequenceType::get(
       mlir::TupleType::get(context, {charRefTy, descRefTy}));
   mlir::TupleType groupTy = mlir::TupleType::get(
       context, {charRefTy, sizeTy, fir::ReferenceType::get(listTy)});
   auto stringAddress = [&](const Fortran::semantics::Symbol &symbol) {
     return fir::factory::createStringLiteral(builder, loc,
                                              symbol.name().ToString() + '\0');
   };
 
-  // Define object names, and static descriptors for global objects.
+  // Define variable names, and static descriptors for global variables.
   bool groupIsLocal = false;
   stringAddress(symbol);
   for (const Fortran::semantics::Symbol &s : details.objects()) {
     stringAddress(s);
     if (!Fortran::lower::symbolIsGlobal(s)) {
       groupIsLocal = true;
       continue;
     }
-    // We know we have a global item.  It it's not a pointer or allocatable,
-    // create a static pointer to it.
+    // A global pointer or allocatable variable has a descriptor for typical
+    // accesses. Variables in multiple namelist groups may already have one.
+    // Create descriptors for other cases.
     if (!IsAllocatableOrPointer(s)) {
-      std::string mangleName = converter.mangleName(s) + ".desc";
+      std::string mangleName =
+          Fortran::lower::mangle::globalNamelistDescriptorName(s);
       if (builder.getNamedGlobal(mangleName))
         continue;
       const auto expr = Fortran::evaluate::AsGenericExpr(s);
       fir::BoxType boxTy =
           fir::BoxType::get(fir::PointerType::get(converter.genType(s)));
       auto descFunc = [&](fir::FirOpBuilder &b) {
-        auto box =
-            Fortran::lower::genInitialDataTarget(converter, loc, boxTy, *expr);
+        auto box = Fortran::lower::genInitialDataTarget(
+            converter, loc, boxTy, *expr, /*couldBeInEquivalence=*/true);
         b.create<fir::HasValueOp>(loc, box);
       };
       builder.createGlobalConstant(loc, boxTy, mangleName, descFunc, linkOnce);
     }
   }
 
   // Define the list of Items.
   mlir::Value listAddr =
for (const Fortran::semantics::Symbol &s : details.objects()) {
       idx[0] = builder.getIntegerAttr(idxTy, n);
       idx[1] = zero;
       mlir::Value nameAddr =
           builder.createConvert(loc, charRefTy, fir::getBase(stringAddress(s)));
       list = builder.create<fir::InsertValueOp>(loc, listTy, list, nameAddr,
                                                 builder.getArrayAttr(idx));
       idx[1] = one;
       mlir::Value descAddr;
-      // Items that we created end in ".desc".
-      std::string suffix = IsAllocatableOrPointer(s) ? "" : ".desc";
-      if (auto desc =
-              builder.getNamedGlobal(converter.mangleName(s) + suffix)) {
+      if (auto desc = builder.getNamedGlobal(
+              Fortran::lower::mangle::globalNamelistDescriptorName(s))) {
         descAddr = builder.create<fir::AddrOfOp>(loc, desc.resultType(),
                                                  desc.getSymbol());
       } else if (Fortran::semantics::FindCommonBlockContaining(s) &&
                  IsAllocatableOrPointer(s)) {
         mlir::Type symType = converter.genType(s);
         const Fortran::semantics::Symbol *commonBlockSym =
             Fortran::semantics::FindCommonBlockContaining(s);
         std::string commonBlockName = converter.mangleName(*commonBlockSym);

flang/lib/Lower/Mangler.cpp

if (scope.kind() == Fortran::semantics::Scope::Kind::MainProgram)
     // Do not use the main program name, if any, because it may lead to name
     // collision with procedures with the same name in other compilation units
     // (technically illegal, but all compilers are able to compile and link
     // properly these programs).
     return llvm::StringRef("");
   return {};
 }
 
-static const Fortran::semantics::Symbol *
-findInterfaceIfSeperateMP(const Fortran::semantics::Symbol &symbol) {
-  const Fortran::semantics::Scope &scope = symbol.owner();
-  if (symbol.attrs().test(Fortran::semantics::Attr::MODULE) &&
-      scope.IsSubmodule()) {
-    // FIXME symbol from MpSubprogramStmt do not seem to have
-    // Attr::MODULE set.
-    const Fortran::semantics::Symbol *iface =
-        scope.parent().FindSymbol(symbol.name());
-    assert(iface && "Separate module procedure must be declared");
-    return iface;
-  }
-  return nullptr;
-}
-
 // Mangle the name of `symbol` to make it unique within FIR's symbol table using
 // the FIR name mangler, `mangler`
 std::string
 Fortran::lower::mangle::mangleName(const Fortran::semantics::Symbol &symbol,
                                    bool keepExternalInScope) {
   // Resolve host and module association before mangling
   const auto &ultimateSymbol = symbol.GetUltimate();
   auto symbolName = toStringRef(ultimateSymbol.name());
if (!Fortran::semantics::IsPointer(ultimateSymbol) &&
           Fortran::semantics::ProcedureDefinitionClass::Internal)
     return ultimateSymbol.name().ToString();
 
   return std::visit(
       Fortran::common::visitors{
           [&](const Fortran::semantics::MainProgramDetails &) {
             return fir::NameUniquer::doProgramEntry().str();
           },
-          [&](const Fortran::semantics::SubprogramDetails &) {
+          [&](const Fortran::semantics::SubprogramDetails &subpDetails) {
             // Mangle external procedure without any scope prefix.
             if (!keepExternalInScope &&
                 Fortran::semantics::IsExternal(ultimateSymbol))
               return fir::NameUniquer::doProcedure(std::nullopt, std::nullopt,
                                                    symbolName);
-            // Separate module subprograms must be mangled according to the
-            // scope where they were declared (the symbol we have is the
-            // definition).
+            // A separate module procedure must be mangled according to its
+            // declaration scope, not its definition scope.
             const Fortran::semantics::Symbol *interface = &ultimateSymbol;
-            if (const auto *mpIface = findInterfaceIfSeperateMP(ultimateSymbol))
-              interface = mpIface;
+            if (interface->attrs().test(Fortran::semantics::Attr::MODULE) &&
+                interface->owner().IsSubmodule() && !subpDetails.isInterface())
+              interface = subpDetails.moduleInterface();
+            assert(interface && "Separate module procedure must be declared");
             llvm::SmallVector<llvm::StringRef> modNames =
                 moduleNames(*interface);
             return fir::NameUniquer::doProcedure(modNames, hostName(*interface),
                                                  symbolName);
           },
           [&](const Fortran::semantics::ProcEntityDetails &) {
             // Mangle procedure pointers and dummy procedures as variables
             if (Fortran::semantics::IsPointer(ultimateSymbol) ||
std::string fir::mangleIntrinsicProcedure(llvm::StringRef intrinsic,
   name.append(intrinsic.str()).append(".");
   assert(funTy.getNumResults() == 1 && "only function mangling supported");
   name.append(typeToString(funTy.getResult(0)));
   unsigned e = funTy.getNumInputs();
   for (decltype(e) i = 0; i < e; ++i)
     name.append(".").append(typeToString(funTy.getInput(i)));
   return name;
 }
+
+std::string Fortran::lower::mangle::globalNamelistDescriptorName(
+    const Fortran::semantics::Symbol &sym) {
+  std::string name = mangleName(sym);
+  return IsAllocatableOrPointer(sym) ? name : name + ".desc"s;
+}

flang/lib/Lower/PFTBuilder.cpp

struct UnwrapStmt<parser::UnlabeledStatement<A>> {
   using Type = typename RemoveIndirectionHelper<A>::Type;
   constexpr UnwrapStmt(const parser::UnlabeledStatement<A> &a)
       : unwrapped{removeIndirection(a.statement)}, position{a.source} {}
   const Type &unwrapped;
   parser::CharBlock position;
   std::optional<parser::Label> label;
 };
 
+void dumpScope(const semantics::Scope *scope, int depth = -1);
+
 /// The instantiation of a parse tree visitor (Pre and Post) is extremely
 /// expensive in terms of compile and link time.  So one goal here is to
 /// limit the bridge to one such instantiation.
 class PFTBuilder {
 public:
   PFTBuilder(const semantics::SemanticsContext &semanticsContext)
       : pgm{std::make_unique<lower::pft::Program>(
             semanticsContext.GetCommonBlocks())},
if (pftParentStack.back().isA<lower::pft::Program>()) {
       return false;
     }
     return enterConstructOrDirective(directive);
   }
 
 private:
   /// Initialize a new module-like unit and make it the builder's focus.
   template <typename A>
-  bool enterModule(const A &func) {
+  bool enterModule(const A &mod) {
     Fortran::lower::pft::ModuleLikeUnit &unit =
-        addUnit(lower::pft::ModuleLikeUnit{func, pftParentStack.back()});
+        addUnit(lower::pft::ModuleLikeUnit{mod, pftParentStack.back()});
     functionList = &unit.nestedFunctions;
     pushEvaluationList(&unit.evaluationList);
     pftParentStack.emplace_back(unit);
+    LLVM_DEBUG(dumpScope(&unit.getScope()));
     return true;
   }
 
   void exitModule() {
     if (!evaluationListStack.empty())
       popEvaluationList();
     pftParentStack.pop_back();
     resetFunctionState();
bool enterFunction(const A &func,
     Fortran::lower::pft::FunctionLikeUnit &unit =
         addFunction(lower::pft::FunctionLikeUnit{func, pftParentStack.back(),
                                                  semanticsContext});
     labelEvaluationMap = &unit.labelEvaluationMap;
     assignSymbolLabelMap = &unit.assignSymbolLabelMap;
     functionList = &unit.nestedFunctions;
     pushEvaluationList(&unit.evaluationList);
     pftParentStack.emplace_back(unit);
+    LLVM_DEBUG(dumpScope(&unit.getScope()));
     return true;
   }
 
   void exitFunction() {
     rewriteIfGotos();
     endFunctionBody();
     analyzeBranches(nullptr, *evaluationListStack.back()); // add branch links
     processEntryPoints();
private:
   /// evaluationListStack is the current nested construct evaluationList state.
   std::vector<lower::pft::EvaluationList *> evaluationListStack{};
   llvm::DenseMap<parser::Label, lower::pft::Evaluation *> *labelEvaluationMap{};
   lower::pft::SymbolLabelMap *assignSymbolLabelMap{};
   std::map<std::string, lower::pft::Evaluation *> constructNameMap{};
   lower::pft::Evaluation *lastLexicalEvaluation{};
 };
 
+/// Dump all program scopes and symbols with addresses to disambiguate names.
+/// This is static, unchanging front end information, so dump it only once.
+void dumpScope(const semantics::Scope *scope, int depth) {
+  static int initialVisitCounter = 0;
+  if (depth < 0) {
+    if (++initialVisitCounter != 1)
+      return;
+    while (!scope->IsGlobal())
+      scope = &scope->parent();
+    LLVM_DEBUG(llvm::dbgs() << "Full program scope information.\n"
+                               "Addresses in angle brackets are scopes. "
+                               "Unbracketed addresses are symbols.\n");
+  }
+  static const std::string white{"                                      ++"};
+  std::string w = white.substr(0, depth * 2);
+  if (depth >= 0) {
+    LLVM_DEBUG(llvm::dbgs() << w << "<" << scope << "> ");
+    if (auto *sym{scope->symbol()}) {
+      LLVM_DEBUG(llvm::dbgs() << sym << " " << *sym << "\n");
+    } else {
+      if (scope->IsIntrinsicModules()) {
+        LLVM_DEBUG(llvm::dbgs() << "IntrinsicModules (no detail)\n");
+        return;
+      }
+      LLVM_DEBUG(llvm::dbgs() << "[anonymous]\n");
+    }
+  }
+  for (const auto &scp : scope->children())
+    if (!scp.symbol())
+      dumpScope(&scp, depth + 1);
+  for (auto iter = scope->begin(); iter != scope->end(); ++iter) {
+    common::Reference<semantics::Symbol> sym = iter->second;
+    if (auto scp = sym->scope())
+      dumpScope(scp, depth + 1);
+    else
+      LLVM_DEBUG(llvm::dbgs() << w + "  " << &*sym << "   " << *sym << "\n");
+  }
+}
+
 class PFTDumper {
 public:
   void dumpPFT(llvm::raw_ostream &outputStream,
                const lower::pft::Program &pft) {
     for (auto &unit : pft.getUnits()) {
       std::visit(common::visitors{
                      [&](const lower::pft::BlockDataUnit &unit) {
                        outputStream << getNodeIndex(unit) << " ";
if (!functionLikeUnit.nestedFunctions.empty()) {
       outputStream << "End Contains\n";
     }
     outputStream << "End " << unitKind << ' ' << name << "\n\n";
   }
 
   void dumpModuleLikeUnit(llvm::raw_ostream &outputStream,
                           const lower::pft::ModuleLikeUnit &moduleLikeUnit) {
     outputStream << getNodeIndex(moduleLikeUnit) << " ";
-    outputStream << "ModuleLike:\n";
+    llvm::StringRef unitKind;
+    llvm::StringRef name;
+    llvm::StringRef header;
+    moduleLikeUnit.beginStmt.visit(common::visitors{
+        [&](const parser::Statement<parser::ModuleStmt> &stmt) {
+          unitKind = "Module";
+          name = toStringRef(stmt.statement.v.source);
+          header = toStringRef(stmt.source);
+        },
+        [&](const parser::Statement<parser::SubmoduleStmt> &stmt) {
+          unitKind = "Submodule";
+          name = toStringRef(std::get<parser::Name>(stmt.statement.t).source);
+          header = toStringRef(stmt.source);
+        },
+        [&](const auto &) {
+          llvm_unreachable("not a valid module begin stmt");
+        },
+    });
+    outputStream << unitKind << ' ' << name << ": " << header << '\n';
     dumpEvaluationList(outputStream, moduleLikeUnit.evaluationList);
     outputStream << "Contains\n";
     for (const lower::pft::FunctionLikeUnit &func :
          moduleLikeUnit.nestedFunctions)
       dumpFunctionLikeUnit(outputStream, func);
-    outputStream << "End Contains\nEnd ModuleLike\n\n";
+    outputStream << "End Contains\nEnd " << unitKind << ' ' << name << "\n\n";
   }
 
   // Top level directives
   void dumpCompilerDirectiveUnit(
       llvm::raw_ostream &outputStream,
       const lower::pft::CompilerDirectiveUnit &directive) {
     outputStream << getNodeIndex(directive) << " ";
     outputStream << "CompilerDirective: !";

 
 /// Is the symbol `sym` a global?
 bool Fortran::lower::symbolIsGlobal(const semantics::Symbol &sym) {
   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
-/// depends upon. Otherwise this sort is stable and preserves the order of the
-/// symbol table, which is sorted by name.
-struct SymbolDependenceDepth {
-  explicit SymbolDependenceDepth(
-      std::vector<std::vector<lower::pft::Variable>> &vars)
-      : vars{vars} {}
+/// This helper class sorts the symbols in a scope such that a symbol will
+/// be placed after those it depends upon. Otherwise the sort is stable and
+/// preserves the order of the symbol table, which is sorted by name. This
+/// analysis may also be done for an individual symbol.
+struct SymbolDependenceAnalysis {
+  explicit SymbolDependenceAnalysis(const semantics::Scope &scope) {
+    analyzeEquivalenceSets(scope);
+    for (const auto &iter : scope)
+      analyze(iter.second.get());
+    finalize();
+  }
+  explicit SymbolDependenceAnalysis(const semantics::Symbol &symbol) {
+    analyzeEquivalenceSets(symbol.owner());
+    analyze(symbol);
+    finalize();
+  }
+  Fortran::lower::pft::VariableList getVariableList() {
+    return std::move(layeredVarList[0]);
+  }
 
-  void analyzeAliasesInCurrentScope(const semantics::Scope &scope) {
+private:
+  /// Analyze the equivalence sets defined in \p scope, plus the equivalence
+  /// sets in host module, submodule, and procedure scopes that may define
+  /// symbols referenced in \p scope. This analysis excludes equivalence sets
+  /// involving common blocks, which are handled elsewhere.
+  void analyzeEquivalenceSets(const semantics::Scope &scope) {
     // FIXME: When this function is called on the scope of an internal
     // procedure whose parent contains an EQUIVALENCE set and the internal
     // procedure uses variables from that EQUIVALENCE set, we end up creating
     // an AggregateStore for those variables unnecessarily.
-    //
-    /// If this is a function nested in a module no host associated
-    /// symbol are added to the function scope for module symbols used in this
-    /// scope. As a result, alias analysis in parent module scopes must be
-    /// preformed here.
-    const semantics::Scope *parentScope = &scope;
-    while (!parentScope->IsGlobal()) {
-      parentScope = &parentScope->parent();
-      if (parentScope->IsModule())
-        analyzeAliases(*parentScope);
-    }
+
+    // A function defined in a [sub]module has no explicit USE of its ancestor
+    // [sub]modules. Analyze those scopes here to accommodate references to
+    // symbols in them.
+    for (auto *scp = &scope.parent(); !scp->IsGlobal(); scp = &scp->parent())
+      if (scp->kind() == Fortran::semantics::Scope::Kind::Module)
+        analyzeLocalEquivalenceSets(*scp);
+    // Analyze local, USEd, and host procedure scope equivalences.
     for (const auto &iter : scope) {
       const semantics::Symbol &ultimate = iter.second.get().GetUltimate();
-      if (skipSymbol(ultimate))
-        continue;
-      analyzeAliases(ultimate.owner());
+      if (!skipSymbol(ultimate))
+        analyzeLocalEquivalenceSets(ultimate.owner());
     }
-    // add all aggregate stores to the front of the work list
+    // Add all aggregate stores to the front of the variable list.
     adjustSize(1);
     // The copy in the loop matters, 'stores' will still be used.
     for (auto st : stores)
-      vars[0].emplace_back(std::move(st));
+      layeredVarList[0].emplace_back(std::move(st));
   }
 
-  // Compute the offset of the last byte that resides in the symbol.
-  inline static std::size_t offsetWidth(const Fortran::semantics::Symbol &sym) {
-    std::size_t width = sym.offset();
-    if (std::size_t size = sym.size())
-      width += size - 1;
-    return width;
-  }
-
-  // Analyze the equivalence sets. This analysis need not be performed when the
-  // scope has no equivalence sets.
-  void analyzeAliases(const semantics::Scope &scope) {
+  /// Analyze the equivalence sets defined locally in \p scope that don't
+  /// involve common blocks.
+  void analyzeLocalEquivalenceSets(const semantics::Scope &scope) {
     if (scope.equivalenceSets().empty())
-      return;
-    // Don't analyze a scope if it has already been analyzed.
+      return; // no equivalence sets to analyze
     if (analyzedScopes.find(&scope) != analyzedScopes.end())
-      return;
+      return; // equivalence sets already analyzed
 
     analyzedScopes.insert(&scope);
     std::list<std::list<semantics::SymbolRef>> aggregates =
         Fortran::semantics::GetStorageAssociations(scope);
     for (std::list<semantics::SymbolRef> aggregate : aggregates) {
       const Fortran::semantics::Symbol *aggregateSym = nullptr;
       bool isGlobal = false;
       const semantics::Symbol &first = *aggregate.front();
-      // Skip aggregates related to common blocks as they will be handled by
-      // instantiateCommon and the aggregate store information will not be used.
-      // Additionally, the AggregateStoreKeys for common block related aggregate
-      // stores can collide with non common block ones, potentially resulting in
-      // incorrect stores being used.
+      // Exclude equivalence sets involving common blocks.
+      // Those are handled in instantiateCommon.
       if (lower::definedInCommonBlock(first))
         continue;
       std::size_t start = first.offset();
       std::size_t end = first.offset() + first.size();
       const Fortran::semantics::Symbol *namingSym = nullptr;
       for (semantics::SymbolRef symRef : aggregate) {
         const semantics::Symbol &sym = *symRef;
         aliasSyms.insert(&sym);
for (std::list<semantics::SymbolRef> aggregate : aggregates) {
       }
     }
   }
 
   // Recursively visit each symbol to determine the height of its dependence on
   // other symbols.
   int analyze(const semantics::Symbol &sym) {
     auto done = seen.insert(&sym);
-    LLVM_DEBUG(llvm::dbgs() << "analyze symbol: " << sym << '\n');
     if (!done.second)
       return 0;
+    LLVM_DEBUG(llvm::dbgs() << "analyze symbol " << &sym << " in <"
+                            << &sym.owner() << ">: " << sym << '\n');
     const bool isProcedurePointerOrDummy =
         semantics::IsProcedurePointer(sym) ||
         (semantics::IsProcedure(sym) && IsDummy(sym));
     // A procedure argument in a subprogram with multiple entry points might
-    // need a vars list entry to trigger creation of a symbol map entry in
-    // some cases.  Non-dummy procedures don't.
+    // need a layeredVarList entry to trigger creation of a symbol map entry
+    // in some cases.  Non-dummy procedures don't.
     if (semantics::IsProcedure(sym) && !isProcedurePointerOrDummy)
       return 0;
     semantics::Symbol ultimate = sym.GetUltimate();
     if (const auto *details =
             ultimate.detailsIf<semantics::NamelistDetails>()) {
       // handle namelist group symbols
       for (const semantics::SymbolRef &s : details->objects())
         analyze(s);
       return 0;
     }
     if (!ultimate.has<semantics::ObjectEntityDetails>() &&
         !isProcedurePointerOrDummy)
       return 0;
 
     if (sym.has<semantics::DerivedTypeDetails>())
       llvm_unreachable("not yet implemented - derived type analysis");
 
     // Symbol must be something lowering will have to allocate.
     int depth = 0;
-    // Analyze symbols appearing in object entity specification expression. This
-    // ensures these symbols will be instantiated before the current one.
+    // Analyze symbols appearing in object entity specification expressions.
+    // This ensures these symbols will be instantiated before the current one.
     // This is not done for object entities that are host associated because
-    // they must be instantiated from the value of the host symbols (the
-    // specification expressions should not be re-evaluated).
+    // they must be instantiated from the value of the host symbols.
+    // (The specification expressions should not be re-evaluated.)
     if (const auto *details = sym.detailsIf<semantics::ObjectEntityDetails>()) {
       const semantics::DeclTypeSpec *symTy = sym.GetType();
       assert(symTy && "symbol must have a type");
       // check CHARACTER's length
       if (symTy->category() == semantics::DeclTypeSpec::Character)
         if (auto e = symTy->characterTypeSpec().length().GetExplicit())
           for (const auto &s : evaluate::CollectSymbols(*e))
             depth = std::max(analyze(s) + 1, depth);
 
       auto doExplicit = [&](const auto &bound) {
         if (bound.isExplicit()) {
           semantics::SomeExpr e{*bound.GetExplicit()};
           for (const auto &s : evaluate::CollectSymbols(e))
             depth = std::max(analyze(s) + 1, depth);
         }
       };
-      // handle any symbols in array bound declarations
+      // Handle any symbols in array bound declarations.
       for (const semantics::ShapeSpec &subs : details->shape()) {
         doExplicit(subs.lbound());
         doExplicit(subs.ubound());
       }
-      // handle any symbols in coarray bound declarations
+      // Handle any symbols in coarray bound declarations.
       for (const semantics::ShapeSpec &subs : details->coshape()) {
         doExplicit(subs.lbound());
         doExplicit(subs.ubound());
       }
-      // handle any symbols in initialization expressions
+      // Handle any symbols in initialization expressions.
       if (auto e = details->init())
         for (const auto &s : evaluate::CollectSymbols(*e))
           depth = std::max(analyze(s) + 1, depth);
     }
     adjustSize(depth + 1);
     bool global = lower::symbolIsGlobal(sym);
-    vars[depth].emplace_back(sym, global, depth);
+    layeredVarList[depth].emplace_back(sym, global, depth);
     if (semantics::IsAllocatable(sym))
-      vars[depth].back().setHeapAlloc();
+      layeredVarList[depth].back().setHeapAlloc();
     if (semantics::IsPointer(sym))
-      vars[depth].back().setPointer();
+      layeredVarList[depth].back().setPointer();
     if (ultimate.attrs().test(semantics::Attr::TARGET))
-      vars[depth].back().setTarget();
+      layeredVarList[depth].back().setTarget();
 
     // If there are alias sets, then link the participating variables to their
     // aggregate stores when constructing the new variable on the list.
     if (lower::pft::Variable::AggregateStore *store = findStoreIfAlias(sym))
-      vars[depth].back().setAlias(store->getOffset());
+      layeredVarList[depth].back().setAlias(store->getOffset());
     return depth;
   }
 
-  /// Save the final list of variable allocations as a single vector and free
-  /// the rest.
-  void finalize() {
-    for (int i = 1, end = vars.size(); i < end; ++i)
-      vars[0].insert(vars[0].end(), vars[i].begin(), vars[i].end());
-    vars.resize(1);
+  /// Skip symbol in alias analysis.
+  bool skipSymbol(const semantics::Symbol &sym) {
+    // Common block equivalences are largely managed by the front end.
+    // Compiler generated symbols ('.' names) cannot be equivalenced.
+    // FIXME: Equivalence code generation may need to be revisited.
+    return !sym.has<semantics::ObjectEntityDetails>() ||
+           lower::definedInCommonBlock(sym) || sym.name()[0] == '.';
+  }
+
+  // Make sure the table is of appropriate size.
+  void adjustSize(std::size_t size) {
+    if (layeredVarList.size() < size)
+      layeredVarList.resize(size);
   }
 
   Fortran::lower::pft::Variable::AggregateStore *
   findStoreIfAlias(const Fortran::evaluate::Symbol &sym) {
     const semantics::Symbol &ultimate = sym.GetUltimate();
     const semantics::Scope &scope = ultimate.owner();
     // Expect the total number of EQUIVALENCE sets to be small for a typical
     // Fortran program.
     if (aliasSyms.find(&ultimate) != aliasSyms.end()) {
-      LLVM_DEBUG(llvm::dbgs() << "symbol: " << ultimate << '\n');
-      LLVM_DEBUG(llvm::dbgs() << "scope: " << scope << '\n');
+      LLVM_DEBUG(llvm::dbgs() << "found aggregate containing " << &ultimate
+                              << " " << ultimate.name() << " in <" << &scope
+                              << "> " << scope.GetName() << '\n');
       std::size_t off = ultimate.offset();
       std::size_t symSize = ultimate.size();
       for (lower::pft::Variable::AggregateStore &v : stores) {
         if (&v.getOwningScope() == &scope) {
           auto intervalOff = std::get<0>(v.interval);
           auto intervalSize = std::get<1>(v.interval);
           if (off >= intervalOff && off < intervalOff + intervalSize)
             return &v;
if (aliasSyms.find(&ultimate) != aliasSyms.end()) {
           }
           llvm::dbgs() << "}\n");
       // clang-format on
       llvm_unreachable("the store must be present");
     }
     return nullptr;
   }
 
-private:
-  /// Skip symbol in alias analysis.
-  bool skipSymbol(const semantics::Symbol &sym) {
-    // Common block equivalences are largely managed by the front end.
-    // Compiler generated symbols ('.' names) cannot be equivalenced.
-    // FIXME: Equivalence code generation may need to be revisited.
-    return !sym.has<semantics::ObjectEntityDetails>() ||
-           lower::definedInCommonBlock(sym) || sym.name()[0] == '.';
-  }
-
-  // Make sure the table is of appropriate size.
-  void adjustSize(std::size_t size) {
-    if (vars.size() < size)
-      vars.resize(size);
+  /// Flatten the result VariableList.
+  void finalize() {
+    for (int i = 1, end = layeredVarList.size(); i < end; ++i)
+      layeredVarList[0].insert(layeredVarList[0].end(),
+                               layeredVarList[i].begin(),
+                               layeredVarList[i].end());
   }
 
   llvm::SmallSet<const semantics::Symbol *, 32> seen;
-  std::vector<std::vector<lower::pft::Variable>> &vars;
+  std::vector<Fortran::lower::pft::VariableList> layeredVarList;
   llvm::SmallSet<const semantics::Symbol *, 32> aliasSyms;
-  /// Set of Scope that have been analyzed for aliases.
+  /// Set of scopes that have been analyzed for aliases.
   llvm::SmallSet<const semantics::Scope *, 4> analyzedScopes;
   std::vector<Fortran::lower::pft::Variable::AggregateStore> stores;
 };
 } // namespace
 
-static void processSymbolTable(
-    const semantics::Scope &scope,
-    std::vector<std::vector<Fortran::lower::pft::Variable>> &varList) {
-  SymbolDependenceDepth sdd{varList};
-  sdd.analyzeAliasesInCurrentScope(scope);
-  for (const auto &iter : scope)
-    sdd.analyze(iter.second.get());
-  sdd.finalize();
-}
-
 //===----------------------------------------------------------------------===//
 // FunctionLikeUnit implementation
 //===----------------------------------------------------------------------===//
 
 Fortran::lower::pft::FunctionLikeUnit::FunctionLikeUnit(
     const parser::MainProgram &func, const lower::pft::PftNode &parent,
     const semantics::SemanticsContext &semanticsContext)
     : ProgramUnit{func, parent}, endStmt{
                                      getFunctionStmt<parser::EndProgramStmt>(
                                          func)} {
   const auto &programStmt =
       std::get<std::optional<parser::Statement<parser::ProgramStmt>>>(func.t);
   if (programStmt.has_value()) {
     beginStmt = FunctionStatement(programStmt.value());
     const semantics::Symbol *symbol = getSymbol(*beginStmt);
     entryPointList[0].first = symbol;
-    processSymbolTable(*symbol->scope(), varList);
+    scope = symbol->scope();
   } else {
-    processSymbolTable(
-        semanticsContext.FindScope(
-            std::get<parser::Statement<parser::EndProgramStmt>>(func.t).source),
-        varList);
+    scope = &semanticsContext.FindScope(
+        std::get<parser::Statement<parser::EndProgramStmt>>(func.t).source);
   }
 }
 
 Fortran::lower::pft::FunctionLikeUnit::FunctionLikeUnit(
     const parser::FunctionSubprogram &func, const lower::pft::PftNode &parent,
     const semantics::SemanticsContext &)
     : ProgramUnit{func, parent},
       beginStmt{getFunctionStmt<parser::FunctionStmt>(func)},
       endStmt{getFunctionStmt<parser::EndFunctionStmt>(func)} {
   const semantics::Symbol *symbol = getSymbol(*beginStmt);
   entryPointList[0].first = symbol;
-  processSymbolTable(*symbol->scope(), varList);
+  scope = symbol->scope();
 }
 
 Fortran::lower::pft::FunctionLikeUnit::FunctionLikeUnit(
     const parser::SubroutineSubprogram &func, const lower::pft::PftNode &parent,
     const semantics::SemanticsContext &)
     : ProgramUnit{func, parent},
       beginStmt{getFunctionStmt<parser::SubroutineStmt>(func)},
       endStmt{getFunctionStmt<parser::EndSubroutineStmt>(func)} {
   const semantics::Symbol *symbol = getSymbol(*beginStmt);
   entryPointList[0].first = symbol;
-  processSymbolTable(*symbol->scope(), varList);
+  scope = symbol->scope();
 }
 
 Fortran::lower::pft::FunctionLikeUnit::FunctionLikeUnit(
     const parser::SeparateModuleSubprogram &func,
     const lower::pft::PftNode &parent, const semantics::SemanticsContext &)
     : ProgramUnit{func, parent},
       beginStmt{getFunctionStmt<parser::MpSubprogramStmt>(func)},
       endStmt{getFunctionStmt<parser::EndMpSubprogramStmt>(func)} {
   const semantics::Symbol *symbol = getSymbol(*beginStmt);
   entryPointList[0].first = symbol;
-  processSymbolTable(*symbol->scope(), varList);
+  scope = symbol->scope();
 }
 
 Fortran::lower::HostAssociations &
 Fortran::lower::pft::FunctionLikeUnit::parentHostAssoc() {
   if (auto *par = parent.getIf<FunctionLikeUnit>())
     return par->hostAssociations;
   llvm::report_fatal_error("parent is not a function");
 }

 
 //===----------------------------------------------------------------------===//
 // ModuleLikeUnit implementation
 //===----------------------------------------------------------------------===//
 
 Fortran::lower::pft::ModuleLikeUnit::ModuleLikeUnit(
     const parser::Module &m, const lower::pft::PftNode &parent)
     : ProgramUnit{m, parent}, beginStmt{getModuleStmt<parser::ModuleStmt>(m)},
-      endStmt{getModuleStmt<parser::EndModuleStmt>(m)} {
-  const semantics::Symbol *symbol = getSymbol(beginStmt);
-  processSymbolTable(*symbol->scope(), varList);
-}
+      endStmt{getModuleStmt<parser::EndModuleStmt>(m)} {}
 
 Fortran::lower::pft::ModuleLikeUnit::ModuleLikeUnit(
     const parser::Submodule &m, const lower::pft::PftNode &parent)
     : ProgramUnit{m, parent}, beginStmt{getModuleStmt<parser::SubmoduleStmt>(
                                   m)},
-      endStmt{getModuleStmt<parser::EndSubmoduleStmt>(m)} {
-  const semantics::Symbol *symbol = getSymbol(beginStmt);
-  processSymbolTable(*symbol->scope(), varList);
-}
+      endStmt{getModuleStmt<parser::EndSubmoduleStmt>(m)} {}
 
 parser::CharBlock
 Fortran::lower::pft::ModuleLikeUnit::getStartingSourceLoc() const {
   return stmtSourceLoc(beginStmt);
 }
 const Fortran::semantics::Scope &
 Fortran::lower::pft::ModuleLikeUnit::getScope() const {
   const Fortran::semantics::Symbol *symbol = getSymbol(beginStmt);

 }
 
 void Fortran::lower::pft::Evaluation::dump() const {
   PFTDumper{}.dumpEvaluation(llvm::errs(), *this);
 }
 
 void Fortran::lower::pft::Variable::dump() const {
   if (auto *s = std::get_if<Nominal>(&var)) {
-    llvm::errs() << "symbol: " << s->symbol->name();
+    llvm::errs() << s->symbol << " " << *s->symbol;
     llvm::errs() << " (depth: " << s->depth << ')';
     if (s->global)
       llvm::errs() << ", global";
     if (s->heapAlloc)
       llvm::errs() << ", allocatable";
     if (s->pointer)
       llvm::errs() << ", pointer";
     if (s->target)
if (auto *s = std::get_if<Nominal>(&var)) {
     if (s->initialValueSymbol)
       llvm::errs() << ", initial value: {" << *s->initialValueSymbol << "}";
   } else {
     llvm_unreachable("not a Variable");
   }
   llvm::errs() << '\n';
 }
 
+void Fortran::lower::pft::dump(Fortran::lower::pft::VariableList &variableList,
+                               std::string s) {
+  llvm::errs() << (s.empty() ? "VariableList" : s) << " " << &variableList
+               << " size=" << variableList.size() << "\n";
+  for (auto var : variableList) {
+    llvm::errs() << "  ";
+    var.dump();
+  }
+}
+
 void Fortran::lower::pft::FunctionLikeUnit::dump() const {
   PFTDumper{}.dumpFunctionLikeUnit(llvm::errs(), *this);
 }
 
 void Fortran::lower::pft::ModuleLikeUnit::dump() const {
   PFTDumper{}.dumpModuleLikeUnit(llvm::errs(), *this);
 }
 
 /// The BlockDataUnit dump is just the associated symbol table.
 void Fortran::lower::pft::BlockDataUnit::dump() const {
   llvm::errs() << "block data {\n" << symTab << "\n}\n";
 }
 
-std::vector<Fortran::lower::pft::Variable>
-Fortran::lower::pft::buildFuncResultDependencyList(
-    const Fortran::semantics::Symbol &symbol) {
-  std::vector<std::vector<pft::Variable>> variableList;
-  SymbolDependenceDepth sdd(variableList);
-  sdd.analyzeAliasesInCurrentScope(symbol.owner());
-  sdd.analyze(symbol);
-  sdd.finalize();
-  // Remove the pft::variable for the result itself, only its dependencies
-  // should be returned in the list.
-  assert(!variableList[0].empty() && "must at least contain the result");
-  assert(&variableList[0].back().getSymbol() == &symbol &&
-         "result sym should be last");
-  variableList[0].pop_back();
-  return variableList[0];
+/// Find or create an ordered list of equivalences and variables in \p scope.
+/// The result is cached in \p map.
+const lower::pft::VariableList &
+lower::pft::getScopeVariableList(const semantics::Scope &scope,
+                                 ScopeVariableListMap &map) {
+  LLVM_DEBUG(llvm::dbgs() << "\ngetScopeVariableList of [sub]module scope <"
+                          << &scope << "> " << scope.GetName() << "\n");
+  auto iter = map.find(&scope);
+  if (iter == map.end()) {
+    SymbolDependenceAnalysis sda(scope);
+    map.emplace(&scope, std::move(sda.getVariableList()));
+    iter = map.find(&scope);
+  }
+  return iter->second;
+}
+
+/// Create an ordered list of equivalences and variables in \p scope.
+/// The result is not cached.
+lower::pft::VariableList
+lower::pft::getScopeVariableList(const semantics::Scope &scope) {
+  LLVM_DEBUG(
+      llvm::dbgs() << "\ngetScopeVariableList of [sub]program|block scope <"
+                   << &scope << "> " << scope.GetName() << "\n");
+  SymbolDependenceAnalysis sda(scope);
+  return sda.getVariableList();
+}
+
+/// Create an ordered list of equivalences and variables that \p symbol
+/// depends on (no caching). Include \p symbol at the end of the list.
+lower::pft::VariableList
+lower::pft::getDependentVariableList(const semantics::Symbol &symbol) {
+  LLVM_DEBUG(llvm::dbgs() << "\ngetDependentVariableList of " << &symbol
+                          << " - " << symbol << "\n");
+  SymbolDependenceAnalysis sda(symbol);
+  return sda.getVariableList();
 }
 
 namespace {
 /// Helper class to find all the symbols referenced in a FunctionLikeUnit.
 /// It defines a parse tree visitor doing a deep visit in all nodes with
 /// symbols (including evaluate::Expr).
 struct SymbolVisitor {
   template <typename A>

flang/test/Lower/pre-fir-tree01.f90

 ! CHECK: BlockData
 block data
   integer, parameter :: n = 100
   integer, dimension(n) :: a, b, c
   common /arrays/ a, b, c
 end
 ! CHECK: End BlockData
 
-! CHECK: ModuleLike
+! CHECK: Module test_mod
 module test_mod
 interface
   ! check specification parts are not part of the PFT.
   ! CHECK-NOT: node
   module subroutine dump()
   end subroutine
 end interface
  integer :: xdim
! CHECK: EndFunctionStmt
     ! CHECK: Subroutine subfoo
     subroutine subfoo()
     ! CHECK: EndSubroutineStmt
     end subroutine
     ! CHECK: End Subroutine subfoo
   end function
   ! CHECK: End Function foo2
 end module
-! CHECK: End ModuleLike
+! CHECK: End Module test_mod
 
-! CHECK: ModuleLike
+! CHECK: Submodule test_mod_impl: submodule(test_mod) test_mod_impl
 submodule (test_mod) test_mod_impl
 contains
   ! CHECK: Subroutine foo
   subroutine foo()
   ! CHECK: EndSubroutineStmt
     contains
     ! CHECK: Subroutine subfoo
     subroutine subfoo()
11  format (2E16.4, I6)
     else
       ! CHECK: WriteStmt
       write (*, 11) "test: ", xdim, pressure
     ! CHECK: EndIfStmt
     end if
     ! CHECK: <<End IfConstruct>>
   end procedure
 end submodule
-! CHECK: End ModuleLike
+! CHECK: End Submodule test_mod_impl
 
 ! CHECK: BlockData
 block data named_block
  integer i, j, k
  common /indexes/ i, j, k
 end
 ! CHECK: End BlockData
 

flang/test/Lower/pre-fir-tree02.f90

22        call incr(l)
   ! CHECK: EndForallStmt
   end forall
   ! CHECK: <<End ForallConstruct>>
 
   ! CHECK: DeallocateStmt
   deallocate(x)
 end
 
-! CHECK: ModuleLike
+! CHECK: Module test
 module test
   !! When derived type processing is implemented, remove all instances of:
   !!  - !![disable]
   !!  -  COM: 
   !![disable]type :: a_type
   !![disable]  integer :: x
   !![disable]end type
   !![disable]type, extends(a_type) :: b_type

flang/test/Lower/pre-fir-tree06.f90

 ! RUN: %flang_fc1 -fdebug-pre-fir-tree -fopenmp %s | FileCheck %s
 
 ! Test structure of the Pre-FIR tree with OpenMP declarative construct
 
-! CHECK: ModuleLike
+! CHECK: Module m
 module m
   real, dimension(10) :: x
   ! CHECK-NEXT: OpenMPDeclarativeConstruct
   !$omp threadprivate(x)
 end
-! CHECK: End ModuleLike
+! CHECK: End Module m
 
-! CHECK: ModuleLike
+! CHECK: Module m2
 module m2
   integer, save :: i
   ! CHECK-NEXT: OpenMPDeclarativeConstruct
   !$omp threadprivate(i)
 contains
   subroutine sub()
     i = 1;
   end
   subroutine sub2()
     i = 2;
   end
 end
-! CHECK: End ModuleLike
+! CHECK: End Module m2
 
 ! CHECK: Program main
 program main
   real :: y
   ! CHECK-NEXT: OpenMPDeclarativeConstruct
   !$omp threadprivate(y)
 end
 ! CHECK: End Program main

flang/test/Lower/pre-fir-tree07.f90

 ! RUN: %flang_fc1 -fdebug-pre-fir-tree -fopenacc %s | FileCheck %s
 
 ! Test structure of the Pre-FIR tree with OpenACC declarative construct
 
-! CHECK: ModuleLike
+! CHECK: Module m: module m
 module m
   real, dimension(10) :: x
   ! CHECK-NEXT: OpenACCDeclarativeConstruct
   !$acc declare create(x)
 end
-! CHECK: End ModuleLike
-
+! CHECK: End Module m

flang/test/Lower/submodule.f90

+! RUN: bbc -emit-fir %s -o - | FileCheck %s
+
+module mm
+  integer :: vv = 20
+  interface
+    module function ff1(nn)
+      integer ff1(nn+1)
+    end function ff1
+    module function ff2(nn)
+      integer ff2(nn+2)
+    end function ff2
+    module function ff3(nn)
+      integer ff3(nn+3)
+    end function ff3
+  end interface
+end module mm
+
+submodule(mm) ss1
+  integer :: ww = 20
+  interface
+    module function fff(nn)
+      integer fff
+    end function fff
+  end interface
+contains
+  ! CHECK-LABEL: func @_QMmmPff2
+  ! CHECK:     %[[V_0:[0-9]+]] = fir.load %arg0 : !fir.ref<i32>
+  ! CHECK:     %[[V_1:[0-9]+]] = arith.addi %[[V_0]], %c2{{.*}} : i32
+  ! CHECK:     %[[V_2:[0-9]+]] = fir.convert %[[V_1]] : (i32) -> i64
+  ! CHECK:     %[[V_3:[0-9]+]] = fir.convert %[[V_2]] : (i64) -> index
+  ! CHECK:     %[[V_4:[0-9]+]] = arith.cmpi sgt, %[[V_3]], %c0{{.*}} : index
+  ! CHECK:     %[[V_5:[0-9]+]] = arith.select %[[V_4]], %[[V_3]], %c0{{.*}} : index
+  ! CHECK:     %[[V_6:[0-9]+]] = fir.alloca !fir.array<?xi32>, %[[V_5]] {bindc_name = "ff2", uniq_name = "_QMmmSss1Fff2Eff2"}
+  ! CHECK:     %[[V_7:[0-9]+]] = fir.shape %[[V_5]] : (index) -> !fir.shape<1>
+  ! CHECK:     %[[V_8:[0-9]+]] = fir.array_load %[[V_6]](%[[V_7]]) : (!fir.ref<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.array<?xi32>
+  ! CHECK:     %[[V_9:[0-9]+]] = fir.call @_QMmmSss1Pfff(%arg0) {{.*}} : (!fir.ref<i32>) -> i32
+  ! CHECK:     %[[V_10:[0-9]+]] = arith.subi %[[V_5]], %c1{{.*}} : index
+  ! CHECK:     %[[V_11:[0-9]+]] = fir.do_loop %arg1 = %c0{{.*}} to %[[V_10]] step %c1{{.*}} unordered iter_args(%arg2 = %[[V_8]]) -> (!fir.array<?xi32>) {
+  ! CHECK:       %[[V_13:[0-9]+]] = fir.array_update %arg2, %[[V_9]], %arg1 : (!fir.array<?xi32>, i32, index) -> !fir.array<?xi32>
+  ! CHECK:       fir.result %[[V_13]] : !fir.array<?xi32>
+  ! CHECK:     }
+  ! CHECK:     fir.array_merge_store %[[V_8]], %[[V_11]] to %[[V_6]] : !fir.array<?xi32>, !fir.array<?xi32>, !fir.ref<!fir.array<?xi32>>
+  ! CHECK:     %[[V_12:[0-9]+]] = fir.load %[[V_6]] : !fir.ref<!fir.array<?xi32>>
+  ! CHECK:     return %[[V_12]] : !fir.array<?xi32>
+  ! CHECK:   }
+  module procedure ff2
+    ff2 = fff(nn)
+  end procedure ff2
+end submodule ss1
+
+submodule(mm:ss1) ss2
+contains
+  ! CHECK-LABEL: func @_QMmmPff1
+  ! CHECK-DAG: %[[V_0:[0-9]+]] = fir.address_of(@_QMmmEvv) : !fir.ref<i32>
+  ! CHECK-DAG: %[[V_1:[0-9]+]] = fir.load %arg0 : !fir.ref<i32>
+  ! CHECK:     %[[V_2:[0-9]+]] = arith.addi %[[V_1]], %c1{{.*}} : i32
+  ! CHECK:     %[[V_3:[0-9]+]] = fir.convert %[[V_2]] : (i32) -> i64
+  ! CHECK:     %[[V_4:[0-9]+]] = fir.convert %[[V_3]] : (i64) -> index
+  ! CHECK:     %[[V_5:[0-9]+]] = arith.cmpi sgt, %[[V_4]], %c0{{.*}} : index
+  ! CHECK:     %[[V_6:[0-9]+]] = arith.select %[[V_5]], %[[V_4]], %c0{{.*}} : index
+  ! CHECK:     %[[V_7:[0-9]+]] = fir.alloca !fir.array<?xi32>, %[[V_6]] {bindc_name = "ff1", uniq_name = "_QMmmSss1Sss2Fff1Eff1"}
+  ! CHECK:     %[[V_8:[0-9]+]] = fir.shape %[[V_6]] : (index) -> !fir.shape<1>
+  ! CHECK:     %[[V_9:[0-9]+]] = fir.array_load %[[V_7]](%[[V_8]]) : (!fir.ref<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.array<?xi32>
+  ! CHECK:     %[[V_10:[0-9]+]] = fir.load %[[V_0]] : !fir.ref<i32>
+  ! CHECK:     %[[V_11:[0-9]+]] = arith.addi %[[V_10]], %c2{{.*}} : i32
+  ! CHECK:     %[[V_12:[0-9]+]] = arith.subi %[[V_6]], %c1{{.*}} : index
+  ! CHECK:     %[[V_13:[0-9]+]] = fir.do_loop %arg1 = %c0{{.*}} to %[[V_12]] step %c1{{.*}} unordered iter_args(%arg2 = %[[V_9]]) -> (!fir.array<?xi32>) {
+  ! CHECK:       %[[V_15:[0-9]+]] = fir.array_update %arg2, %[[V_11]], %arg1 : (!fir.array<?xi32>, i32, index) -> !fir.array<?xi32>
+  ! CHECK:       fir.result %[[V_15]] : !fir.array<?xi32>
+  ! CHECK:     }
+  ! CHECK:     fir.array_merge_store %[[V_9]], %[[V_13]] to %[[V_7]] : !fir.array<?xi32>, !fir.array<?xi32>, !fir.ref<!fir.array<?xi32>>
+  ! CHECK:     %[[V_14:[0-9]+]] = fir.load %[[V_7]] : !fir.ref<!fir.array<?xi32>>
+  ! CHECK:     return %[[V_14]] : !fir.array<?xi32>
+  ! CHECK:   }
+  module function ff1(nn)
+    integer ff1(nn+1)
+    ff1 = vv + 2
+  end function ff1
+
+  ! CHECK-LABEL: func @_QMmmSss1Pfff
+  ! CHECK-DAG: %[[V_0:[0-9]+]] = fir.address_of(@_QMmmSss1Eww) : !fir.ref<i32>
+  ! CHECK-DAG: %[[V_1:[0-9]+]] = fir.address_of(@_QMmmEvv) : !fir.ref<i32>
+  ! CHECK-DAG: %[[V_2:[0-9]+]] = fir.alloca i32 {bindc_name = "fff", uniq_name = "_QMmmSss1Sss2FfffEfff"}
+  ! CHECK-DAG: %[[V_3:[0-9]+]] = fir.load %[[V_1]] : !fir.ref<i32>
+  ! CHECK-DAG: %[[V_4:[0-9]+]] = fir.load %[[V_0]] : !fir.ref<i32>
+  ! CHECK:     %[[V_5:[0-9]+]] = arith.addi %[[V_3]], %[[V_4]] : i32
+  ! CHECK:     %[[V_6:[0-9]+]] = arith.addi %[[V_5]], %c4{{.*}} : i32
+  ! CHECK:     fir.store %[[V_6]] to %[[V_2]] : !fir.ref<i32>
+  ! CHECK:     %[[V_7:[0-9]+]] = fir.load %[[V_2]] : !fir.ref<i32>
+  ! CHECK:     return %[[V_7]] : i32
+  ! CHECK:   }
+  module procedure fff
+    fff = vv + ww + 4
+  end procedure fff
+end submodule ss2
+
+submodule(mm) sss
+contains
+  ! CHECK-LABEL: func @_QMmmPff3
+  ! CHECK-DAG: %[[V_0:[0-9]+]] = fir.address_of(@_QMmmEvv) : !fir.ref<i32>
+  ! CHECK-DAG: %[[V_1:[0-9]+]] = fir.load %arg0 : !fir.ref<i32>
+  ! CHECK:     %[[V_2:[0-9]+]] = arith.addi %[[V_1]], %c3{{.*}} : i32
+  ! CHECK:     %[[V_3:[0-9]+]] = fir.convert %[[V_2]] : (i32) -> i64
+  ! CHECK:     %[[V_4:[0-9]+]] = fir.convert %[[V_3]] : (i64) -> index
+  ! CHECK:     %[[V_5:[0-9]+]] = arith.cmpi sgt, %[[V_4]], %c0{{.*}} : index
+  ! CHECK:     %[[V_6:[0-9]+]] = arith.select %[[V_5]], %[[V_4]], %c0{{.*}} : index
+  ! CHECK:     %[[V_7:[0-9]+]] = fir.alloca !fir.array<?xi32>, %[[V_6]] {bindc_name = "ff3", uniq_name = "_QMmmSsssFff3Eff3"}
+  ! CHECK:     %[[V_8:[0-9]+]] = fir.shape %[[V_6]] : (index) -> !fir.shape<1>
+  ! CHECK:     %[[V_9:[0-9]+]] = fir.array_load %[[V_7]](%[[V_8]]) : (!fir.ref<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.array<?xi32>
+  ! CHECK-DAG: %[[V_10:[0-9]+]] = fir.load %arg0 : !fir.ref<i32>
+  ! CHECK-DAG: %[[V_11:[0-9]+]] = fir.load %[[V_0]] : !fir.ref<i32>
+  ! CHECK:     %[[V_12:[0-9]+]] = arith.muli %[[V_10]], %[[V_11]] : i32
+  ! CHECK:     %[[V_13:[0-9]+]] = arith.addi %[[V_12]], %c6{{.*}} : i32
+  ! CHECK:     %[[V_14:[0-9]+]] = arith.subi %[[V_6]], %c1{{.*}} : index
+  ! CHECK:     %[[V_15:[0-9]+]] = fir.do_loop %arg1 = %c0{{.*}} to %[[V_14]] step %c1{{.*}} unordered iter_args(%arg2 = %[[V_9]]) -> (!fir.array<?xi32>) {
+  ! CHECK:       %[[V_17:[0-9]+]] = fir.array_update %arg2, %[[V_13]], %arg1 : (!fir.array<?xi32>, i32, index) -> !fir.array<?xi32>
+  ! CHECK:       fir.result %[[V_17]] : !fir.array<?xi32>
+  ! CHECK:     }
+  ! CHECK:     fir.array_merge_store %[[V_9]], %[[V_15]] to %[[V_7]] : !fir.array<?xi32>, !fir.array<?xi32>, !fir.ref<!fir.array<?xi32>>
+  ! CHECK:     %[[V_16:[0-9]+]] = fir.load %[[V_7]] : !fir.ref<!fir.array<?xi32>>
+  ! CHECK:     return %[[V_16]] : !fir.array<?xi32>
+  ! CHECK:   }
+  module function ff3(nn)
+    integer ff3(nn+3)
+    ff3 = nn*vv + 6
+  end function ff3
+end submodule sss
+
+! CHECK-LABEL: func @_QQmain
+program pp
+  use mm
+  ! CHECK:     fir.call @_QMmmPff1(%{{[0-9]+}}) {{.*}} : (!fir.ref<i32>) -> !fir.array<?xi32>
+  print*, ff1(1) ! expect: 22 22
+  ! CHECK:     fir.call @_QMmmPff2(%{{[0-9]+}}) {{.*}} : (!fir.ref<i32>) -> !fir.array<?xi32>
+  print*, ff2(2) ! expect: 44 44 44 44
+  ! CHECK:     fir.call @_QMmmPff3(%{{[0-9]+}}) {{.*}} : (!fir.ref<i32>) -> !fir.array<?xi32>
+  print*, ff3(3) ! expect: 66 66 66 66 66 66
+end program pp