[flang] Handle module in lowering pass

[clementval]

Summary

This patch enables the lowering of basic modules and functions/subroutines
in modules.

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

[PeteSteinfeld]

Aside from the clang-format problem, all builds and tests correctly and looks good.

flang/lib/Lower/Bridge.cpp

90–99

With these changes, I'm getting differences after running clang-format.

[clementval]

flang/lib/Lower/Bridge.cpp

90–99

Ok I'll double check that. Thanks for the heads up.

[clementval]

Fix formatting

flang/include/flang/Lower/ConvertVariable.h

 
 /// Instantiate variable \p var and add it to \p symMap.
 /// The AbstractConverter builder must be set.
 /// The AbstractConverter own symbol mapping is not used during the
 /// instantiation and can be different form \p symMap.
 void instantiateVariable(AbstractConverter &, const pft::Variable &var,
                          SymMap &symMap, AggregateStoreMap &storeMap);
 
+/// Create a fir::GlobalOp given a module variable definition. This is intended
+/// to be used when lowering a module definition, not when lowering variables
+/// used from a module. For used variables instantiateVariable must directly be
+/// called.
+void defineModuleVariable(AbstractConverter &, const pft::Variable &var);
+
 /// Lower a symbol attributes given an optional storage \p and add it to the
 /// provided symbol map. If \preAlloc is not provided, a temporary storage will
 /// be allocated. This is a low level function that should only be used if
 /// instantiateVariable cannot be called.
 void mapSymbolAttributes(AbstractConverter &, const pft::Variable &, SymMap &,
                          StatementContext &, mlir::Value preAlloc = {});
 
 /// Instantiate the variables that appear in the specification expressions

flang/lib/Lower/Bridge.cpp

 #include "flang/Lower/Runtime.h"
 #include "flang/Lower/StatementContext.h"
 #include "flang/Lower/SymbolMap.h"
 #include "flang/Lower/Todo.h"
 #include "flang/Optimizer/Builder/BoxValue.h"
 #include "flang/Optimizer/Builder/Character.h"
 #include "flang/Optimizer/Builder/MutableBox.h"
 #include "flang/Optimizer/Support/FIRContext.h"
+#include "flang/Optimizer/Support/InternalNames.h"
 #include "flang/Runtime/iostat.h"
 #include "flang/Semantics/tools.h"
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 

 public:
   explicit FirConverter(Fortran::lower::LoweringBridge &bridge)
       : bridge{bridge}, foldingContext{bridge.createFoldingContext()} {}
   virtual ~FirConverter() = default;
 
   /// Convert the PFT to FIR.
   void run(Fortran::lower::pft::Program &pft) {
     // Primary translation pass.
+    //  - Declare all functions that have definitions so that definition
+    //    signatures prevail over call site signatures.
+    //  - Define module variables and OpenMP/OpenACC declarative construct so
+    //    that they are available before lowering any function that may use
+    //    them.
     for (Fortran::lower::pft::Program::Units &u : pft.getUnits()) {
-      std::visit(
-          Fortran::common::visitors{
-              [&](Fortran::lower::pft::FunctionLikeUnit &f) { lowerFunc(f); },
-              [&](Fortran::lower::pft::ModuleLikeUnit &m) {},
+      std::visit(Fortran::common::visitors{
+                     [&](Fortran::lower::pft::FunctionLikeUnit &f) {
+                       declareFunction(f);
+                     },
+                     [&](Fortran::lower::pft::ModuleLikeUnit &m) {
+                       lowerModuleDeclScope(m);
+                       for (Fortran::lower::pft::FunctionLikeUnit &f :
+                            m.nestedFunctions)
+                         declareFunction(f);
+                     },
                      [&](Fortran::lower::pft::BlockDataUnit &b) {},
                      [&](Fortran::lower::pft::CompilerDirectiveUnit &d) {
                        setCurrentPosition(
                            d.get<Fortran::parser::CompilerDirective>().source);
                        mlir::emitWarning(toLocation(),
                                          "ignoring all compiler directives");
                      },
                  },
                  u);
     }
+
+    // Primary translation pass.
+    for (Fortran::lower::pft::Program::Units &u : pft.getUnits()) {
+      std::visit(
+          Fortran::common::visitors{
+              [&](Fortran::lower::pft::FunctionLikeUnit &f) { lowerFunc(f); },
+              [&](Fortran::lower::pft::ModuleLikeUnit &m) { lowerMod(m); },
+              [&](Fortran::lower::pft::BlockDataUnit &b) {},
+              [&](Fortran::lower::pft::CompilerDirectiveUnit &d) {},
+          },
+          u);
+    }
+  }
+
+  /// Declare a function.
+  void declareFunction(Fortran::lower::pft::FunctionLikeUnit &funit) {
+    setCurrentPosition(funit.getStartingSourceLoc());
+    for (int entryIndex = 0, last = funit.entryPointList.size();
+         entryIndex < last; ++entryIndex) {
+      funit.setActiveEntry(entryIndex);
+      // Calling CalleeInterface ctor will build a declaration mlir::FuncOp with
+      // no other side effects.
+      // TODO: when doing some compiler profiling on real apps, it may be worth
+      // to check it's better to save the CalleeInterface instead of recomputing
+      // it later when lowering the body. CalleeInterface ctor should be linear
+      // with the number of arguments, so it is not awful to do it that way for
+      // now, but the linear coefficient might be non negligible. Until
+      // measured, stick to the solution that impacts the code less.
+      Fortran::lower::CalleeInterface{funit, *this};
+    }
+    funit.setActiveEntry(0);
+
+    // Declare internal procedures
+    for (Fortran::lower::pft::FunctionLikeUnit &f : funit.nestedFunctions)
+      declareFunction(f);
   }
 
   //===--------------------------------------------------------------------===//
   // AbstractConverter overrides
   //===--------------------------------------------------------------------===//
 
   mlir::Value getSymbolAddress(Fortran::lower::SymbolRef sym) override final {
     return lookupSymbol(sym).getAddr();
for (int entryIndex = 0, last = funit.entryPointList.size();
         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) {
+    // FIXME: get rid of the bogus function context and instantiate the
+    // globals directly into the module.
+    MLIRContext *context = &getMLIRContext();
+    setCurrentPosition(mod.getStartingSourceLoc());
+    mlir::FuncOp func = fir::FirOpBuilder::createFunction(
+        mlir::UnknownLoc::get(context), getModuleOp(),
+        fir::NameUniquer::doGenerated("ModuleSham"),
+        mlir::FunctionType::get(context, llvm::None, llvm::None));
+    func.addEntryBlock();
+    builder = new fir::FirOpBuilder(func, bridge.getKindMap());
+    for (const Fortran::lower::pft::Variable &var :
+         mod.getOrderedSymbolTable()) {
+      // 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);
+    if (mlir::Region *region = func.getCallableRegion())
+      region->dropAllReferences();
+    func.erase();
+    delete builder;
+    builder = nullptr;
+  }
+
+  /// Lower functions contained in a module.
+  void lowerMod(Fortran::lower::pft::ModuleLikeUnit &mod) {
+    for (Fortran::lower::pft::FunctionLikeUnit &f : mod.nestedFunctions)
+      lowerFunc(f);
+  }
+
   mlir::Value hostAssocTupleValue() override final { return hostAssocTuple; }
 
 private:
   FirConverter() = delete;
   FirConverter(const FirConverter &) = delete;
   FirConverter &operator=(const FirConverter &) = delete;
 
   //===--------------------------------------------------------------------===//

flang/lib/Lower/ConvertVariable.cpp

ba.match(
       //===--------------------------------------------------------------===//
 
       [&](const Fortran::lower::BoxAnalyzer::None &) {
         mlir::emitError(loc, "symbol analysis failed on ")
             << toStringRef(sym.name());
       });
 }
 
+void Fortran::lower::defineModuleVariable(
+    AbstractConverter &converter, const Fortran::lower::pft::Variable &var) {
+  // Use empty linkage for module variables, which makes them available
+  // for use in another unit.
+  mlir::StringAttr externalLinkage;
+  if (!var.isGlobal())
+    fir::emitFatalError(converter.getCurrentLocation(),
+                        "attempting to lower module variable as local");
+  // Define aggregate storages for equivalenced objects.
+  if (var.isAggregateStore()) {
+    const mlir::Location loc = converter.genLocation(var.getSymbol().name());
+    TODO(loc, "defineModuleVariable aggregateStore");
+  }
+  const Fortran::semantics::Symbol &sym = var.getSymbol();
+  if (Fortran::semantics::FindCommonBlockContaining(var.getSymbol())) {
+    const mlir::Location loc = converter.genLocation(sym.name());
+    TODO(loc, "defineModuleVariable common block");
+  } else if (var.isAlias()) {
+    // Do nothing. Mapping will be done on user side.
+  } else {
+    std::string globalName = Fortran::lower::mangle::mangleName(sym);
+    defineGlobal(converter, var, globalName, externalLinkage);
+  }
+}
+
 void Fortran::lower::instantiateVariable(AbstractConverter &converter,
                                          const pft::Variable &var,
                                          SymMap &symMap,
                                          AggregateStoreMap &storeMap) {
   const Fortran::semantics::Symbol &sym = var.getSymbol();
   const mlir::Location loc = converter.genLocation(sym.name());
   if (var.isAggregateStore()) {
     TODO(loc, "instantiateVariable AggregateStore");

flang/test/Lower/allocatable-assignment.f90

 ! Test allocatable assignments
 ! RUN: bbc -emit-fir %s -o - | FileCheck %s
 
+module alloc_assign
+contains
+
 ! -----------------------------------------------------------------------------
 !            Test simple scalar RHS
 ! -----------------------------------------------------------------------------
 
-! CHECK-LABEL: func @_QPtest_simple_scalar(
+! CHECK-LABEL: func @_QMalloc_assignPtest_simple_scalar(
 ! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.heap<f32>>>{{.*}}) {
 subroutine test_simple_scalar(x)
   real, allocatable  :: x
 ! CHECK:  %[[VAL_1:.*]] = arith.constant 4.200000e+01 : f32
 ! CHECK:  %[[VAL_2:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<f32>>>
 ! CHECK:  %[[VAL_3:.*]] = fir.box_addr %[[VAL_2]] : (!fir.box<!fir.heap<f32>>) -> !fir.heap<f32>
 ! CHECK:  %[[VAL_4:.*]] = fir.convert %[[VAL_3]] : (!fir.heap<f32>) -> i64
 ! CHECK:  %[[VAL_5:.*]] = arith.constant 0 : i64

 ! CHECK:      fir.freemem %[[VAL_3]]
 ! CHECK:    }
 ! CHECK:    %[[VAL_15:.*]] = fir.embox %[[VAL_14]]#1 : (!fir.heap<f32>) -> !fir.box<!fir.heap<f32>>
 ! CHECK:    fir.store %[[VAL_15]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<f32>>>
 ! CHECK:  }
   x = 42.
 end subroutine
 
-! CHECK-LABEL: func @_QPtest_simple_local_scalar() {
+! CHECK-LABEL: func @_QMalloc_assignPtest_simple_local_scalar() {
 subroutine test_simple_local_scalar()
   real, allocatable  :: x
-! CHECK:  %[[VAL_1:.*]] = fir.alloca !fir.heap<f32> {uniq_name = "_QFtest_simple_local_scalarEx.addr"}
+! CHECK:  %[[VAL_1:.*]] = fir.alloca !fir.heap<f32> {uniq_name = "_QMalloc_assignFtest_simple_local_scalarEx.addr"}
 ! CHECK:  %[[VAL_2:.*]] = fir.zero_bits !fir.heap<f32>
 ! CHECK:  fir.store %[[VAL_2]] to %[[VAL_1]] : !fir.ref<!fir.heap<f32>>
 ! CHECK:  %[[VAL_3:.*]] = arith.constant 4.200000e+01 : f32
 ! CHECK:  %[[VAL_4:.*]] = fir.load %[[VAL_1]] : !fir.ref<!fir.heap<f32>>
 ! CHECK:  %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (!fir.heap<f32>) -> i64
 ! CHECK:  %[[VAL_6:.*]] = arith.constant 0 : i64
 ! CHECK:  %[[VAL_7:.*]] = arith.cmpi ne, %[[VAL_5]], %[[VAL_6]] : i64
 ! CHECK:  %[[VAL_8:.*]]:2 = fir.if %[[VAL_7]] -> (i1, !fir.heap<f32>) {

 ! CHECK:  fir.if %[[VAL_15]]#0 {
 ! CHECK:    fir.if %[[VAL_7]] {
 ! CHECK:      fir.freemem %[[VAL_4]]
 ! CHECK:    }
 ! CHECK:    fir.store %[[VAL_15]]#1 to %[[VAL_1]] : !fir.ref<!fir.heap<f32>>
 ! CHECK:  }
   x = 42.
 end subroutine
+
+end module