[flang] Basic local variable lowering

[clementval]

Summary

This patch add lowering for simple local variable.

• The signatures in ConvertType.h have been simplified to take advantage of the AbstractConverter.
• The lowering make use of the allocateLocal from the FirOpBuilder.

This lowering is used in patch D118982

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

[clementval]

Remove test

[kiranchandramohan]

LGTM. Have suggested a few Nits.

flang/include/flang/Lower/ConvertVariable.h

30

Nit: AbstractConverter's

31

Nit: from

flang/lib/Lower/Bridge.cpp

218

Nit: what is a primaryResult?

flang/lib/Lower/ConvertExpr.cpp

47

Nit: Can this be skipped/TODOed for now? Also not clear to me why there is no load here.

49–51

Nit: Can this be skipped/TODOed for now? Also not clear to me why there is no load here.

52

Assuming this load is the one we require for the STOP test.

[clementval]

Address comments

[clementval]

flang/lib/Lower/Bridge.cpp

218

There are some information here: https://github.com/llvm/llvm-project/blob/f62a400cdf114ff97fee99d74234c889142a34e7/flang/include/flang/Lower/PFTBuilder.h#L653

flang/include/flang/Lower/ConvertType.h

 class Type;
 } // namespace evaluate
 
 namespace semantics {
 class Symbol;
 } // namespace semantics
 
 namespace lower {
+class AbstractConverter;
 namespace pft {
 struct Variable;
 }
 
 using SomeExpr = evaluate::Expr<evaluate::SomeType>;
 using SymbolRef = common::Reference<const semantics::Symbol>;
 
 /// Get a FIR type based on a category and kind.
 mlir::Type getFIRType(mlir::MLIRContext *ctxt, common::TypeCategory tc,
                       int kind);
 
 /// Get a FIR type based on a category.
-mlir::Type getFIRType(mlir::MLIRContext *ctxt,
-                      common::IntrinsicTypeDefaultKinds const &defaults,
+mlir::Type getFIRType(Fortran::lower::AbstractConverter &,
                       common::TypeCategory tc);
 
 /// Translate a Fortran::evaluate::DataRef to an mlir::Type.
-mlir::Type
-translateDataRefToFIRType(mlir::MLIRContext *ctxt,
-                          common::IntrinsicTypeDefaultKinds const &defaults,
+mlir::Type translateDataRefToFIRType(Fortran::lower::AbstractConverter &,
                                      const evaluate::DataRef &dataRef);
 
 /// Translate a SomeExpr to an mlir::Type.
-mlir::Type
-translateSomeExprToFIRType(mlir::MLIRContext *ctxt,
-                           common::IntrinsicTypeDefaultKinds const &defaults,
+mlir::Type translateSomeExprToFIRType(Fortran::lower::AbstractConverter &,
                                       const SomeExpr *expr);
 
 /// Translate a Fortran::semantics::Symbol to an mlir::Type.
-mlir::Type
-translateSymbolToFIRType(mlir::MLIRContext *ctxt,
-                         common::IntrinsicTypeDefaultKinds const &defaults,
+mlir::Type translateSymbolToFIRType(Fortran::lower::AbstractConverter &,
                                     const SymbolRef symbol);
 
 /// Translate a Fortran::lower::pft::Variable to an mlir::Type.
-mlir::Type
-translateVariableToFIRType(mlir::MLIRContext *ctxt,
-                           common::IntrinsicTypeDefaultKinds const &defaults,
+mlir::Type translateVariableToFIRType(Fortran::lower::AbstractConverter &,
                                       const pft::Variable &variable);
 
 /// Translate a REAL of KIND to the mlir::Type.
 mlir::Type convertReal(mlir::MLIRContext *ctxt, int KIND);
 
 // Given a ReferenceType of a base type, returns the ReferenceType to
 // the SequenceType of this base type.
 // The created SequenceType has one dimension of unknown extent.
 // This is useful to do pointer arithmetic using fir::CoordinateOp that requires
 // a memory reference to a sequence type.
 mlir::Type getSequenceRefType(mlir::Type referenceType);
 
 } // namespace lower
 } // namespace Fortran
 
 #endif // FORTRAN_LOWER_CONVERT_TYPE_H

flang/include/flang/Lower/ConvertVariable.h

+//===- Lower/ConvertVariable.h -- lowering of variables to FIR --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
+//
+//===----------------------------------------------------------------------===//
+///
+/// Instantiation of pft::Variable in FIR/MLIR.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_LOWER_CONVERT_VARIABLE_H
+#define FORTRAN_LOWER_CONVERT_VARIABLE_H
+
+namespace Fortran ::lower {
+class AbstractConverter;
+class SymMap;
+namespace pft {
+struct Variable;
+}
+
+/// 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);
+
+} // namespace Fortran::lower
+#endif // FORTRAN_LOWER_CONVERT_VARIABLE_H

flang/lib/Lower/Bridge.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Lower/Bridge.h"
 #include "flang/Evaluate/tools.h"
 #include "flang/Lower/CallInterface.h"
 #include "flang/Lower/ConvertExpr.h"
 #include "flang/Lower/ConvertType.h"
+#include "flang/Lower/ConvertVariable.h"
 #include "flang/Lower/Mangler.h"
 #include "flang/Lower/PFTBuilder.h"
 #include "flang/Lower/Runtime.h"
 #include "flang/Lower/SymbolMap.h"
 #include "flang/Lower/Todo.h"
 #include "flang/Optimizer/Support/FIRContext.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/RegionUtils.h"
public:
   mlir::Type genType(Fortran::common::TypeCategory tc) override final {
     TODO_NOLOC("Not implemented genType TypeCategory. Needed for more complex "
                "expression lowering");
   }
   mlir::Type genType(Fortran::common::TypeCategory tc,
                      int kind) override final {
     return Fortran::lower::getFIRType(&getMLIRContext(), tc, kind);
   }
-  mlir::Type genType(const Fortran::lower::pft::Variable &) override final {
-    TODO_NOLOC("Not implemented genType Variable. Needed for more complex "
-               "expression lowering");
+  mlir::Type genType(const Fortran::lower::pft::Variable &var) override final {
+    return Fortran::lower::translateVariableToFIRType(*this, var);
   }
 
   void setCurrentPosition(const Fortran::parser::CharBlock &position) {
     if (position != Fortran::parser::CharBlock{})
       currentPosition = position;
   }
 
   //===--------------------------------------------------------------------===//
void endNewFunction(Fortran::lower::pft::FunctionLikeUnit &funit) {
     funit.finalBlock = nullptr;
     LLVM_DEBUG(llvm::dbgs() << "*** Lowering result:\n\n"
                             << *builder->getFunction() << '\n');
     delete builder;
     builder = nullptr;
     localSymbols.clear();
   }
 
+  /// Instantiate variable \p var and add it to the symbol map.
+  /// See ConvertVariable.cpp.
+  void instantiateVar(const Fortran::lower::pft::Variable &var) {
+    Fortran::lower::instantiateVariable(*this, var, localSymbols);
+  }
+
   /// Prepare to translate a new function
   void startNewFunction(Fortran::lower::pft::FunctionLikeUnit &funit) {
     assert(!builder && "expected nullptr");
     Fortran::lower::CalleeInterface callee(funit, *this);
     mlir::FuncOp func = callee.addEntryBlockAndMapArguments();
     func.setVisibility(mlir::SymbolTable::Visibility::Public);
     builder = new fir::FirOpBuilder(func, bridge.getKindMap());
     assert(builder && "FirOpBuilder did not instantiate");
     builder->setInsertionPointToStart(&func.front());
+
+    for (const Fortran::lower::pft::Variable &var :
+         funit.getOrderedSymbolTable()) {
+      const Fortran::semantics::Symbol &sym = var.getSymbol();
+      if (!sym.IsFuncResult() || !funit.primaryResult)
+        instantiateVar(var);
+    }
   }
 
   /// Lower a procedure (nest).
   void lowerFunc(Fortran::lower::pft::FunctionLikeUnit &funit) {
     setCurrentPosition(funit.getStartingSourceLoc());
     for (int entryIndex = 0, last = funit.entryPointList.size();
          entryIndex < last; ++entryIndex) {
       funit.setActiveEntry(entryIndex);

flang/lib/Lower/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 add_flang_library(FortranLower
   Bridge.cpp
   CallInterface.cpp
   Coarray.cpp
   ConvertExpr.cpp
   ConvertType.cpp
+  ConvertVariable.cpp
   Mangler.cpp
   OpenACC.cpp
   OpenMP.cpp
   PFTBuilder.cpp
   Runtime.cpp
   SymbolMap.cpp
 
   DEPENDS

flang/lib/Lower/ConvertExpr.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Lower/ConvertExpr.h"
 #include "flang/Evaluate/fold.h"
 #include "flang/Evaluate/real.h"
 #include "flang/Evaluate/traverse.h"
 #include "flang/Lower/AbstractConverter.h"
+#include "flang/Lower/SymbolMap.h"
 #include "flang/Lower/Todo.h"
 #include "flang/Semantics/expression.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/tools.h"
 #include "flang/Semantics/type.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "flang-lower-expr"
 
 //===----------------------------------------------------------------------===//
 // The composition and structure of Fortran::evaluate::Expr is defined in
 // the various header files in include/flang/Evaluate. You are referred
 // there for more information on these data structures. Generally speaking,
 // these data structures are a strongly typed family of abstract data types
 // that, composed as trees, describe the syntax of Fortran expressions.
 //
 // This part of the bridge can traverse these tree structures and lower them
 // to the correct FIR representation in SSA form.
 //===----------------------------------------------------------------------===//
 
+/// Generate a load of a value from an address. Beware that this will lose
+/// any dynamic type information for polymorphic entities (note that unlimited
+/// polymorphic cannot be loaded and must not be provided here).
+static fir::ExtendedValue genLoad(fir::FirOpBuilder &builder,
+                                  mlir::Location loc,
+                                  const fir::ExtendedValue &addr) {
+  return addr.match(
+      [](const fir::CharBoxValue &box) -> fir::ExtendedValue { return box; },
+      [&](const fir::UnboxedValue &v) -> fir::ExtendedValue {
+        if (fir::unwrapRefType(fir::getBase(v).getType())
+                .isa<fir::RecordType>())
+          return v;
+        return builder.create<fir::LoadOp>(loc, fir::getBase(v));
+      },
+      [&](const fir::MutableBoxValue &box) -> fir::ExtendedValue {
+        TODO(loc, "genLoad for MutableBoxValue");
+      },
+      [&](const fir::BoxValue &box) -> fir::ExtendedValue {
+        TODO(loc, "genLoad for BoxValue");
+      },
+      [&](const auto &) -> fir::ExtendedValue {
+        fir::emitFatalError(
+            loc, "attempting to load whole array or procedure address");
+      });
+}
+
 namespace {
 
 /// Lowering of Fortran::evaluate::Expr<T> expressions
 class ScalarExprLowering {
 public:
   using ExtValue = fir::ExtendedValue;
 
   explicit ScalarExprLowering(mlir::Location loc,
-                              Fortran::lower::AbstractConverter &converter)
+                              Fortran::lower::AbstractConverter &converter,
+                              Fortran::lower::SymMap &symMap)
       : location{loc}, converter{converter},
-        builder{converter.getFirOpBuilder()} {}
+        builder{converter.getFirOpBuilder()}, symMap{symMap} {}
 
   mlir::Location getLoc() { return location; }
 
   /// Generate an integral constant of `value`
   template <int KIND>
   mlir::Value genIntegerConstant(mlir::MLIRContext *context,
                                  std::int64_t value) {
     mlir::Type type =
         converter.genType(Fortran::common::TypeCategory::Integer, KIND);
     return builder.createIntegerConstant(getLoc(), type, value);
   }
 
   /// Generate a logical/boolean constant of `value`
   mlir::Value genBoolConstant(bool value) {
     return builder.createBool(getLoc(), value);
   }
 
+  /// Returns a reference to a symbol or its box/boxChar descriptor if it has
+  /// one.
+  ExtValue gen(Fortran::semantics::SymbolRef sym) {
+    if (Fortran::lower::SymbolBox val = symMap.lookupSymbol(sym))
+      return val.match([&val](auto &) { return val.toExtendedValue(); });
+    LLVM_DEBUG(llvm::dbgs()
+               << "unknown symbol: " << sym << "\nmap: " << symMap << '\n');
+    fir::emitFatalError(getLoc(), "symbol is not mapped to any IR value");
+  }
+
+  ExtValue genLoad(const ExtValue &exv) {
+    return ::genLoad(builder, getLoc(), exv);
+  }
+
   ExtValue genval(Fortran::semantics::SymbolRef sym) {
-    TODO(getLoc(), "genval SymbolRef");
+    ExtValue var = gen(sym);
+    if (const fir::UnboxedValue *s = var.getUnboxed())
+      if (fir::isReferenceLike(s->getType()))
+        return genLoad(*s);
+    return var;
   }
 
   ExtValue genval(const Fortran::evaluate::BOZLiteralConstant &) {
     TODO(getLoc(), "genval BOZ");
   }
 
   /// Return indirection to function designated in ProcedureDesignator.
   /// The type of the function indirection is not guaranteed to match the one
#define GENBIN(GenBinEvOp, GenBinTyCat, GenBinFirOp)                           \
   }
 
   ExtValue genval(const Fortran::evaluate::CoarrayRef &coref) {
     TODO(getLoc(), "genval CoarrayRef");
   }
 
   template <typename A>
   ExtValue genval(const Fortran::evaluate::Designator<A> &des) {
-    TODO(getLoc(), "genval Designator<A>");
+    return std::visit([&](const auto &x) { return genval(x); }, des.u);
   }
 
   template <typename A>
   ExtValue genval(const Fortran::evaluate::FunctionRef<A> &funcRef) {
     TODO(getLoc(), "genval FunctionRef<A>");
   }
 
   ExtValue genval(const Fortran::evaluate::ProcedureRef &procRef) {
ExtValue genval(const Fortran::evaluate::Expr<Fortran::evaluate::Type<
                       Fortran::common::TypeCategory::Logical, KIND>> &exp) {
     return std::visit([&](const auto &e) { return genval(e); }, exp.u);
   }
 
 private:
   mlir::Location location;
   Fortran::lower::AbstractConverter &converter;
   fir::FirOpBuilder &builder;
+  Fortran::lower::SymMap &symMap;
 };
 } // namespace
 
 fir::ExtendedValue Fortran::lower::createSomeExtendedExpression(
     mlir::Location loc, Fortran::lower::AbstractConverter &converter,
-    const Fortran::lower::SomeExpr &expr, Fortran::lower::SymMap &) {
+    const Fortran::lower::SomeExpr &expr, Fortran::lower::SymMap &symMap) {
   LLVM_DEBUG(expr.AsFortran(llvm::dbgs() << "expr: ") << '\n');
-  return ScalarExprLowering{loc, converter}.genval(expr);
+  return ScalarExprLowering{loc, converter, symMap}.genval(expr);
 }

flang/lib/Lower/ConvertType.cpp

 //===-- ConvertType.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Lower/ConvertType.h"
+#include "flang/Lower/AbstractConverter.h"
 #include "flang/Lower/PFTBuilder.h"
 #include "flang/Lower/Utils.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Semantics/tools.h"
 #include "flang/Semantics/type.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 

 }
 
 namespace {
 
 /// Discover the type of an Fortran::evaluate::Expr<T> and convert it to an
 /// mlir::Type. The type returned may be an MLIR standard or FIR type.
 class TypeBuilder {
 public:
-  /// Constructor.
-  explicit TypeBuilder(
-      mlir::MLIRContext *context,
-      const Fortran::common::IntrinsicTypeDefaultKinds &defaults)
-      : context{context}, defaults{defaults} {}
+  TypeBuilder(Fortran::lower::AbstractConverter &converter)
+      : converter{converter}, context{&converter.getMLIRContext()} {}
 
   //===--------------------------------------------------------------------===//
   // Generate type entry points
   //===--------------------------------------------------------------------===//
 
   template <template <typename> typename A, Fortran::common::TypeCategory TC>
   mlir::Type gen(const A<Fortran::evaluate::SomeKind<TC>> &) {
     return genFIRType<TC>(context, defaultKind<TC>());
public:
   mlir::Type gen(const Fortran::evaluate::Expr<A> &expr) {
     return genVariant(expr);
   }
 
   mlir::Type gen(const Fortran::evaluate::DataRef &dref) {
     return genVariant(dref);
   }
 
-  mlir::Type gen(const Fortran::lower::pft::Variable &var) {
+  mlir::Type genVariableType(const Fortran::lower::pft::Variable &var) {
     return genSymbolHelper(var.getSymbol(), var.isHeapAlloc(), var.isPointer());
   }
 
   /// Type consing from a symbol. A symbol's type must be created from the type
   /// discovered by the front-end at runtime.
   mlir::Type gen(Fortran::semantics::SymbolRef symbol) {
     return genSymbolHelper(symbol);
   }
private:
   mlir::Type genVariant(const A &variant) {
     return std::visit([&](const auto &x) { return gen(x); }, variant.u);
   }
 
   template <Fortran::common::TypeCategory TC>
   int defaultKind() {
     return defaultKind(TC);
   }
-  int defaultKind(Fortran::common::TypeCategory TC) {
-    return defaults.GetDefaultKind(TC);
-  }
+  int defaultKind(Fortran::common::TypeCategory TC) { return 0; }
 
   fir::SequenceType::Shape seqShapeHelper(Fortran::semantics::SymbolRef symbol,
                                           fir::SequenceType::Shape &bounds) {
     auto &details = symbol->get<Fortran::semantics::ObjectEntityDetails>();
     const auto size = details.shape().size();
     for (auto &ss : details.shape()) {
       auto lb = ss.lbound();
       auto ub = ss.ubound();
private:
   }
 
   mlir::InFlightDiagnostic emitWarning(const llvm::Twine &message) {
     return mlir::emitWarning(mlir::UnknownLoc::get(context), message);
   }
 
   //===--------------------------------------------------------------------===//
 
+  Fortran::lower::AbstractConverter &converter;
   mlir::MLIRContext *context;
-  const Fortran::common::IntrinsicTypeDefaultKinds &defaults;
 };
 
 } // namespace
 
 template <int KIND>
 int getIntegerBits() {
   return Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer,
                                  KIND>::Scalar::bits;

 }
 
 mlir::Type Fortran::lower::getFIRType(mlir::MLIRContext *context,
                                       Fortran::common::TypeCategory tc,
                                       int kind) {
   return genFIRType(context, tc, kind);
 }
 
-mlir::Type Fortran::lower::getFIRType(
-    mlir::MLIRContext *context,
-    const Fortran::common::IntrinsicTypeDefaultKinds &defaults,
+mlir::Type
+Fortran::lower::getFIRType(Fortran::lower::AbstractConverter &converter,
                            Fortran::common::TypeCategory tc) {
-  return TypeBuilder{context, defaults}.genFIRTy(tc);
+  return TypeBuilder{converter}.genFIRTy(tc);
 }
 
 mlir::Type Fortran::lower::translateDataRefToFIRType(
-    mlir::MLIRContext *context,
-    const Fortran::common::IntrinsicTypeDefaultKinds &defaults,
+    Fortran::lower::AbstractConverter &converter,
     const Fortran::evaluate::DataRef &dataRef) {
-  return TypeBuilder{context, defaults}.gen(dataRef);
+  return TypeBuilder{converter}.gen(dataRef);
 }
 
 mlir::Type Fortran::lower::translateSomeExprToFIRType(
-    mlir::MLIRContext *context,
-    const Fortran::common::IntrinsicTypeDefaultKinds &defaults,
-    const SomeExpr *expr) {
-  return TypeBuilder{context, defaults}.gen(*expr);
+    Fortran::lower::AbstractConverter &converter, const SomeExpr *expr) {
+  return TypeBuilder{converter}.gen(*expr);
 }
 
 mlir::Type Fortran::lower::translateSymbolToFIRType(
-    mlir::MLIRContext *context,
-    const Fortran::common::IntrinsicTypeDefaultKinds &defaults,
-    const SymbolRef symbol) {
-  return TypeBuilder{context, defaults}.gen(symbol);
+    Fortran::lower::AbstractConverter &converter, const SymbolRef symbol) {
+  return TypeBuilder{converter}.gen(symbol);
 }
 
 mlir::Type Fortran::lower::translateVariableToFIRType(
-    mlir::MLIRContext *context,
-    const Fortran::common::IntrinsicTypeDefaultKinds &defaults,
+    Fortran::lower::AbstractConverter &converter,
     const Fortran::lower::pft::Variable &var) {
-  return TypeBuilder{context, defaults}.gen(var);
+  return TypeBuilder{converter}.genVariableType(var);
 }
 
 mlir::Type Fortran::lower::convertReal(mlir::MLIRContext *context, int kind) {
   return genFIRType<Fortran::common::TypeCategory::Real>(context, kind);
 }
 
 mlir::Type Fortran::lower::getSequenceRefType(mlir::Type refType) {
   auto type{refType.dyn_cast<fir::ReferenceType>()};
   assert(type && "expected a reference type");
   auto elementType{type.getEleTy()};
   fir::SequenceType::Shape shape{fir::SequenceType::getUnknownExtent()};
   return fir::ReferenceType::get(fir::SequenceType::get(shape, elementType));
 }

flang/lib/Lower/ConvertVariable.cpp

+//===-- ConvertVariable.cpp -- bridge to lower to MLIR --------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang/Lower/ConvertVariable.h"
+#include "flang/Lower/AbstractConverter.h"
+#include "flang/Lower/CallInterface.h"
+#include "flang/Lower/ConvertExpr.h"
+#include "flang/Lower/Mangler.h"
+#include "flang/Lower/PFTBuilder.h"
+#include "flang/Lower/Support/Utils.h"
+#include "flang/Lower/SymbolMap.h"
+#include "flang/Lower/Todo.h"
+#include "flang/Optimizer/Builder/Character.h"
+#include "flang/Optimizer/Builder/FIRBuilder.h"
+#include "flang/Optimizer/Builder/Runtime/Derived.h"
+#include "flang/Optimizer/Dialect/FIRAttr.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Support/FIRContext.h"
+#include "flang/Optimizer/Support/FatalError.h"
+#include "flang/Semantics/tools.h"
+#include "llvm/Support/Debug.h"
+
+#define DEBUG_TYPE "flang-lower-variable"
+
+//===----------------------------------------------------------------===//
+// Local variables instantiation (not for alias)
+//===----------------------------------------------------------------===//
+
+/// Create a stack slot for a local variable. Precondition: the insertion
+/// point of the builder must be in the entry block, which is currently being
+/// constructed.
+static mlir::Value createNewLocal(Fortran::lower::AbstractConverter &converter,
+                                  mlir::Location loc,
+                                  const Fortran::lower::pft::Variable &var,
+                                  mlir::Value preAlloc,
+                                  llvm::ArrayRef<mlir::Value> shape = {},
+                                  llvm::ArrayRef<mlir::Value> lenParams = {}) {
+  if (preAlloc)
+    return preAlloc;
+  fir::FirOpBuilder &builder = converter.getFirOpBuilder();
+  std::string nm = Fortran::lower::mangle::mangleName(var.getSymbol());
+  mlir::Type ty = converter.genType(var);
+  const Fortran::semantics::Symbol &ultimateSymbol =
+      var.getSymbol().GetUltimate();
+  llvm::StringRef symNm = toStringRef(ultimateSymbol.name());
+  bool isTarg = var.isTarget();
+  // Let the builder do all the heavy lifting.
+  return builder.allocateLocal(loc, ty, nm, symNm, shape, lenParams, isTarg);
+}
+
+/// Instantiate a local variable. Precondition: Each variable will be visited
+/// such that if its properties depend on other variables, the variables upon
+/// which its properties depend will already have been visited.
+static void instantiateLocal(Fortran::lower::AbstractConverter &converter,
+                             const Fortran::lower::pft::Variable &var,
+                             Fortran::lower::SymMap &symMap) {
+  assert(!var.isAlias());
+  const Fortran::semantics::Symbol &sym = var.getSymbol();
+  if (symMap.lookupSymbol(sym))
+    return;
+  const mlir::Location loc = converter.genLocation(sym.name());
+  mlir::Value local = createNewLocal(converter, loc, var, {});
+  symMap.addSymbol(sym, local);
+}
+
+void Fortran::lower::instantiateVariable(AbstractConverter &converter,
+                                         const pft::Variable &var,
+                                         SymMap &symMap) {
+  const Fortran::semantics::Symbol &sym = var.getSymbol();
+  const mlir::Location loc = converter.genLocation(sym.name());
+  if (var.isAggregateStore()) {
+    TODO(loc, "instantiateVariable AggregateStore");
+  } else if (Fortran::semantics::FindCommonBlockContaining(
+                 var.getSymbol().GetUltimate())) {
+    TODO(loc, "instantiateVariable Common");
+  } else if (var.isAlias()) {
+    TODO(loc, "instantiateVariable Alias");
+  } else if (var.isGlobal()) {
+    TODO(loc, "instantiateVariable Global");
+  } else {
+    instantiateLocal(converter, var, symMap);
+  }
+}