Revert "[flang] Attach proper storage to [hl]fir.declare in lowering. (llvm#155742)"

This reverts commit 83da8d0.

Author: ronlieb

flang/include/flang/Lower/AbstractConverter.h

@@ -108,21 +108,6 @@ class AbstractConverter {
   /// added or replaced at the inner-most level of the local symbol map.
   virtual void bindSymbol(SymbolRef sym, const fir::ExtendedValue &exval) = 0;
 
-  /// Binds the symbol's physical storage to a storage descriptor,
-  /// which is the base address of the storage and the offset
-  /// within the storage, where the symbol begins.
-  /// The symbol binding will be added or replaced at the innermost level
-  /// of the local symbol map.
-  virtual void
-  bindSymbolStorage(SymbolRef sym,
-                    Fortran::lower::SymMap::StorageDesc storage) = 0;
-
-  /// Returns the storage descriptor previously bound to this symbol.
-  /// If there is no bound storage, the descriptor will contain
-  /// nullptr base address.
-  virtual Fortran::lower::SymMap::StorageDesc
-  getSymbolStorage(SymbolRef sym) = 0;
-
   /// Override lowering of expression with pre-lowered values.
   /// Associate mlir::Value to evaluate::Expr. All subsequent call to
   /// genExprXXX() will replace any occurrence of an overridden

flang/include/flang/Lower/ConvertVariable.h

@@ -92,14 +92,10 @@ void defineCommonBlocks(
 /// The COMMON block is a global structure. \p commonValue is the base address
 /// of the COMMON block. As the offset from the symbol \p sym, generate the
 /// COMMON block member value (commonValue + offset) for the symbol.
-/// \p commonSize specifies the syze of the COMMON block in bytes.
-/// The size is used to represent a COMMON block reference as
-/// a !fir.ref<!fir.array<SIZExi8>>.
 mlir::Value genCommonBlockMember(AbstractConverter &converter,
                                  mlir::Location loc,
                                  const Fortran::semantics::Symbol &sym,
-                                 mlir::Value commonValue,
-                                 std::size_t commonSize);
+                                 mlir::Value commonValue);
 
 /// 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

flang/include/flang/Lower/SymbolMap.h

@@ -146,22 +146,14 @@ struct SymbolBox : public fir::details::matcher<SymbolBox> {
 class SymMap {
 public:
   using AcDoVar = llvm::StringRef;
-  /// Descriptor of a symbol's storage consists of the base address
-  /// of the storage and the offset within that storage.
-  using StorageDesc = std::pair<mlir::Value, std::uint64_t>;
 
   SymMap() { pushScope(); }
   SymMap(const SymMap &) = delete;
 
-  void pushScope() {
-    symbolMapStack.emplace_back();
-    storageMapStack.emplace_back();
-  }
+  void pushScope() { symbolMapStack.emplace_back(); }
   void popScope() {
     symbolMapStack.pop_back();
     assert(symbolMapStack.size() >= 1);
-    storageMapStack.pop_back();
-    assert(storageMapStack.size() >= 1);
   }
 
   /// Add an extended value to the symbol table.
@@ -295,8 +287,6 @@ class SymMap {
     symbolMapStack.emplace_back();
     assert(symbolMapStack.size() == 1);
     impliedDoStack.clear();
-    storageMapStack.clear();
-    storageMapStack.emplace_back();
   }
 
   friend llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
@@ -325,16 +315,6 @@ class SymMap {
     return std::nullopt;
   }
 
-  /// Register the symbol's storage at the innermost level
-  /// of the symbol table. If the storage is already registered,
-  /// it will be replaced.
-  void registerStorage(semantics::SymbolRef sym, StorageDesc storage);
-  /// Lookup the symbol's storage at the innermost level of the symbol table.
-  StorageDesc lookupStorage(semantics::SymbolRef sym);
-  StorageDesc lookupStorage(const semantics::Symbol *sym) {
-    return lookupStorage(*sym);
-  }
-
 private:
   /// Bind `box` to `symRef` in the symbol map.
   void makeSym(semantics::SymbolRef symRef, const SymbolBox &box,
@@ -352,10 +332,6 @@ class SymMap {
   // Implied DO induction variables are not represented as Se::Symbol in
   // Ev::Expr. Keep the variable markers in their own stack.
   llvm::SmallVector<std::pair<AcDoVar, mlir::Value>> impliedDoStack;
-
-  // A stack of maps between the symbols and their storage descriptors.
-  llvm::SmallVector<llvm::DenseMap<const semantics::Symbol *, StorageDesc>>
-      storageMapStack;
 };
 
 /// RAII wrapper for SymMap.

flang/include/flang/Optimizer/Builder/HLFIRTools.h

@@ -224,8 +224,7 @@ fir::FortranVariableOpInterface
 genDeclare(mlir::Location loc, fir::FirOpBuilder &builder,
            const fir::ExtendedValue &exv, llvm::StringRef name,
            fir::FortranVariableFlagsAttr flags,
-           mlir::Value dummyScope = nullptr, mlir::Value storage = nullptr,
-           std::uint64_t storageOffset = 0,
+           mlir::Value dummyScope = nullptr,
            cuf::DataAttributeAttr dataAttr = {});
 
 /// Generate an hlfir.associate to build a variable from an expression value.

flang/include/flang/Optimizer/HLFIR/HLFIROps.td

@@ -109,12 +109,10 @@ def hlfir_DeclareOp
     attr-dict `:` functional-type(operands, results)
   }];
 
-  let builders = [OpBuilder<(ins "mlir::Value":$memref,
-      "llvm::StringRef":$uniq_name, CArg<"mlir::Value", "{}">:$shape,
-      CArg<"mlir::ValueRange", "{}">:$typeparams,
+  let builders = [
+    OpBuilder<(ins "mlir::Value":$memref, "llvm::StringRef":$uniq_name,
+      CArg<"mlir::Value", "{}">:$shape, CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::Value", "{}">:$dummy_scope,
-      CArg<"mlir::Value", "{}">:$storage,
-      CArg<"std::uint64_t", "0">:$storage_offset,
       CArg<"fir::FortranVariableFlagsAttr", "{}">:$fortran_attrs,
       CArg<"cuf::DataAttributeAttr", "{}">:$data_attr)>];
 

flang/lib/Lower/Bridge.cpp

@@ -631,17 +631,6 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     addSymbol(sym, exval, /*forced=*/true);
   }
 
-  void bindSymbolStorage(
-      Fortran::lower::SymbolRef sym,
-      Fortran::lower::SymMap::StorageDesc storage) override final {
-    localSymbols.registerStorage(sym, std::move(storage));
-  }
-
-  Fortran::lower::SymMap::StorageDesc
-  getSymbolStorage(Fortran::lower::SymbolRef sym) override final {
-    return localSymbols.lookupStorage(sym);
-  }
-
   void
   overrideExprValues(const Fortran::lower::ExprToValueMap *map) override final {
     exprValueOverrides = map;

flang/lib/Lower/ConvertArrayConstructor.cpp

@@ -315,8 +315,9 @@ class RuntimeTempStrategy : public StrategyBase {
       mlir::Value tempStorage = builder.createHeapTemporary(
           loc, declaredType, tempName, extents, lengths);
       mlir::Value shape = builder.genShape(loc, extents);
-      declare = hlfir::DeclareOp::create(builder, loc, tempStorage, tempName,
-                                         shape, lengths);
+      declare = hlfir::DeclareOp::create(
+          builder, loc, tempStorage, tempName, shape, lengths,
+          /*dummy_scope=*/nullptr, fir::FortranVariableFlagsAttr{});
       initialBoxValue =
           builder.createBox(loc, boxType, declare->getOriginalBase(), shape,
                             /*slice=*/mlir::Value{}, lengths, /*tdesc=*/{});

flang/lib/Lower/ConvertExprToHLFIR.cpp

@@ -1813,8 +1813,10 @@ class HlfirBuilder {
     // Allocate scalar temporary that will be initialized
     // with the values specified by the constructor.
     mlir::Value storagePtr = builder.createTemporary(loc, recTy);
-    auto varOp = hlfir::EntityWithAttributes{
-        hlfir::DeclareOp::create(builder, loc, storagePtr, "ctor.temp")};
+    auto varOp = hlfir::EntityWithAttributes{hlfir::DeclareOp::create(
+        builder, loc, storagePtr, "ctor.temp", /*shape=*/nullptr,
+        /*typeparams=*/mlir::ValueRange{}, /*dummy_scope=*/nullptr,
+        fir::FortranVariableFlagsAttr{})};
 
     // Initialize any components that need initialization.
     mlir::Value box = builder.createBox(loc, fir::ExtendedValue{varOp});

flang/lib/Lower/ConvertVariable.cpp

@@ -1413,7 +1413,6 @@ static void instantiateAlias(Fortran::lower::AbstractConverter &converter,
   mlir::Value bytePtr = fir::CoordinateOp::create(
       builder, loc, i8Ptr, storeAddr, mlir::ValueRange{offset});
   mlir::Value typedPtr = castAliasToPointer(builder, loc, symType, bytePtr);
-  converter.bindSymbolStorage(sym, {storeAddr, off});
   Fortran::lower::StatementContext stmtCtx;
   mapSymbolAttributes(converter, var, symMap, stmtCtx, typedPtr);
   // Default initialization is possible for equivalence members: see
@@ -1656,15 +1655,13 @@ void Fortran::lower::defineCommonBlocks(
 
 mlir::Value Fortran::lower::genCommonBlockMember(
     Fortran::lower::AbstractConverter &converter, mlir::Location loc,
-    const Fortran::semantics::Symbol &sym, mlir::Value commonValue,
-    std::size_t commonSize) {
+    const Fortran::semantics::Symbol &sym, mlir::Value commonValue) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
 
   std::size_t byteOffset = sym.GetUltimate().offset();
   mlir::IntegerType i8Ty = builder.getIntegerType(8);
   mlir::Type i8Ptr = builder.getRefType(i8Ty);
-  fir::SequenceType::Shape shape(1, commonSize);
-  mlir::Type seqTy = builder.getRefType(fir::SequenceType::get(shape, i8Ty));
+  mlir::Type seqTy = builder.getRefType(builder.getVarLenSeqTy(i8Ty));
   mlir::Value base = builder.createConvert(loc, seqTy, commonValue);
 
   mlir::Value offs =
@@ -1673,8 +1670,6 @@ mlir::Value Fortran::lower::genCommonBlockMember(
                                                   mlir::ValueRange{offs});
   mlir::Type symType = converter.genType(sym);
 
-  converter.bindSymbolStorage(sym, {base, byteOffset});
-
   return Fortran::semantics::FindEquivalenceSet(sym) != nullptr
              ? castAliasToPointer(builder, loc, symType, varAddr)
              : builder.createConvert(loc, builder.getRefType(symType), varAddr);
@@ -1703,8 +1698,7 @@ static void instantiateCommon(Fortran::lower::AbstractConverter &converter,
     symMap.addSymbol(common, commonAddr);
   }
 
-  mlir::Value local =
-      genCommonBlockMember(converter, loc, varSym, commonAddr, common.size());
+  mlir::Value local = genCommonBlockMember(converter, loc, varSym, commonAddr);
   Fortran::lower::StatementContext stmtCtx;
   mapSymbolAttributes(converter, var, symMap, stmtCtx, local);
 }
@@ -1976,8 +1970,7 @@ static void genDeclareSymbol(Fortran::lower::AbstractConverter &converter,
       // Declare a local pointer variable.
       auto newBase = hlfir::DeclareOp::create(
           builder, loc, boxAlloc, name, /*shape=*/nullptr, lenParams,
-          /*dummy_scope=*/nullptr, /*storage=*/nullptr,
-          /*storage_offset=*/0, attributes);
+          /*dummy_scope=*/nullptr, attributes);
       mlir::Value nullAddr = builder.createNullConstant(
           loc, llvm::cast<fir::BaseBoxType>(ptrBoxType).getEleTy());
 
@@ -2007,10 +2000,9 @@ static void genDeclareSymbol(Fortran::lower::AbstractConverter &converter,
     mlir::Value dummyScope;
     if (converter.isRegisteredDummySymbol(sym))
       dummyScope = converter.dummyArgsScopeValue();
-    auto [storage, storageOffset] = converter.getSymbolStorage(sym);
-    auto newBase = hlfir::DeclareOp::create(
-        builder, loc, base, name, shapeOrShift, lenParams, dummyScope, storage,
-        storageOffset, attributes, dataAttr);
+    auto newBase =
+        hlfir::DeclareOp::create(builder, loc, base, name, shapeOrShift,
+                                 lenParams, dummyScope, attributes, dataAttr);
     symMap.addVariableDefinition(sym, newBase, force);
     return;
   }
@@ -2068,10 +2060,8 @@ void Fortran::lower::genDeclareSymbol(
       base = genPackArray(converter, sym, exv);
       dummyScope = converter.dummyArgsScopeValue();
     }
-    auto [storage, storageOffset] = converter.getSymbolStorage(sym);
-    hlfir::EntityWithAttributes declare =
-        hlfir::genDeclare(loc, builder, base, name, attributes, dummyScope,
-                          storage, storageOffset, dataAttr);
+    hlfir::EntityWithAttributes declare = hlfir::genDeclare(
+        loc, builder, base, name, attributes, dummyScope, dataAttr);
     symMap.addVariableDefinition(sym, declare.getIfVariableInterface(), force);
     return;
   }

flang/lib/Lower/OpenACC.cpp

@@ -1212,10 +1212,12 @@ mlir::acc::FirstprivateRecipeOp Fortran::lower::createOrGetFirstprivateRecipe(
 
     auto leftDeclOp = hlfir::DeclareOp::create(
         builder, loc, recipe.getCopyRegion().getArgument(0), llvm::StringRef{},
-        shape);
+        shape, llvm::ArrayRef<mlir::Value>{}, /*dummy_scope=*/nullptr,
+        fir::FortranVariableFlagsAttr{});
     auto rightDeclOp = hlfir::DeclareOp::create(
         builder, loc, recipe.getCopyRegion().getArgument(1), llvm::StringRef{},
-        shape);
+        shape, llvm::ArrayRef<mlir::Value>{}, /*dummy_scope=*/nullptr,
+        fir::FortranVariableFlagsAttr{});
 
     hlfir::DesignateOp::Subscripts triplets =
         getSubscriptsFromArgs(recipe.getCopyRegion().getArguments());
@@ -1521,10 +1523,14 @@ static void genCombiner(fir::FirOpBuilder &builder, mlir::Location loc,
       auto shape =
           genShapeFromBoundsOrArgs(loc, builder, seqTy, bounds,
                                    recipe.getCombinerRegion().getArguments());
-      auto v1DeclareOp = hlfir::DeclareOp::create(builder, loc, value1,
-                                                  llvm::StringRef{}, shape);
-      auto v2DeclareOp = hlfir::DeclareOp::create(builder, loc, value2,
-                                                  llvm::StringRef{}, shape);
+      auto v1DeclareOp = hlfir::DeclareOp::create(
+          builder, loc, value1, llvm::StringRef{}, shape,
+          llvm::ArrayRef<mlir::Value>{},
+          /*dummy_scope=*/nullptr, fir::FortranVariableFlagsAttr{});
+      auto v2DeclareOp = hlfir::DeclareOp::create(
+          builder, loc, value2, llvm::StringRef{}, shape,
+          llvm::ArrayRef<mlir::Value>{},
+          /*dummy_scope=*/nullptr, fir::FortranVariableFlagsAttr{});
       hlfir::DesignateOp::Subscripts triplets = getTripletsFromArgs(recipe);
 
       llvm::SmallVector<mlir::Value> lenParamsLeft;