[flang][NFC] Make LEN parameters homogenous

[clementval]

Summary

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

Co-authored-by: Eric Schweitz <[e-mail]>

[jeanPerier]

flang/lib/Lower/Bridge.cpp

496

I think this was added recently in https://github.com/llvm/llvm-project/commit/27afb362b1e85dac21744b95ed9b48f7e9fd016c and should probably be kept (build bots are complaining in openmp copyin tests).

[clementval]

flang/lib/Lower/Bridge.cpp

496

My bad. I’ll revert that

[clementval]

Keep the setInsertionPointAfter

[jeanPerier]

LGTM

flang/include/flang/Lower/BoxAnalyzer.h

private:
 
   // Get the `SomeExpr` that describes the CHARACTER's LEN.
   llvm::Optional<Fortran::lower::SomeExpr>
   charLenVariable(const Fortran::semantics::Symbol &sym) {
     const Fortran::semantics::ParamValue &lenParam =
         sym.GetType()->characterTypeSpec().length();
     if (Fortran::semantics::MaybeIntExpr expr = lenParam.GetExplicit())
       return {Fortran::evaluate::AsGenericExpr(std::move(*expr))};
-    // For assumed length parameters, the length comes from the initialization
+    // For assumed LEN parameters, the length comes from the initialization
     // expression.
     if (sym.attrs().test(Fortran::semantics::Attr::PARAMETER))
       if (const auto *objectDetails =
               sym.GetUltimate()
                   .detailsIf<Fortran::semantics::ObjectEntityDetails>())
         if (objectDetails->init())
           if (const auto *charExpr = std::get_if<
                   Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter>>(

flang/include/flang/Optimizer/Builder/FIRBuilder.h

 llvm::SmallVector<mlir::Value>
 getNonDefaultLowerBounds(fir::FirOpBuilder &builder, mlir::Location loc,
                          const fir::ExtendedValue &exv);
 
 /// Return LEN parameters associated to \p exv that are not deferred (that are
 /// available without having to read any fir.box values). Empty if \p exv has no
 /// LEN parameters or if they are all deferred.
 llvm::SmallVector<mlir::Value>
-getNonDeferredLengthParams(const fir::ExtendedValue &exv);
+getNonDeferredLenParams(const fir::ExtendedValue &exv);
 
 //===----------------------------------------------------------------------===//
 // String literal helper helpers
 //===----------------------------------------------------------------------===//
 
 /// Create a !fir.char<1> string literal global and returns a fir::CharBoxValue
 /// with its address and length.
 fir::ExtendedValue createStringLiteral(fir::FirOpBuilder &, mlir::Location,

flang/include/flang/Optimizer/Builder/MutableBox.h

struct MutableBoxReallocation {
   mlir::Value wasReallocated;
   mlir::Value oldAddressWasAllocated;
 };
 
 MutableBoxReallocation genReallocIfNeeded(fir::FirOpBuilder &builder,
                                           mlir::Location loc,
                                           const fir::MutableBoxValue &box,
                                           mlir::ValueRange shape,
-                                          mlir::ValueRange lengthParams);
+                                          mlir::ValueRange lenParams);
 
 void finalizeRealloc(fir::FirOpBuilder &builder, mlir::Location loc,
                      const fir::MutableBoxValue &box, mlir::ValueRange lbounds,
                      bool takeLboundsIfRealloc,
                      const MutableBoxReallocation &realloc);
 
 /// Finalize a mutable box if it is allocated or associated. This includes both
 /// calling the finalizer, if any, and deallocating the storage.

flang/lib/Lower/Bridge.cpp

fir::ExtendedValue exv = hexv.match(
           // Allocate storage for a pointer/allocatble descriptor.
           // No shape/lengths to be passed to the alloca.
           return fir::MutableBoxValue(allocate({}, {}),
                                       box.nonDeferredLenParams(), {});
         },
         [&](const auto &) -> fir::ExtendedValue {
           mlir::Value temp =
               allocate(fir::factory::getExtents(loc, *builder, hexv),
-                       fir::getTypeParams(hexv));
+                       fir::factory::getTypeParams(loc, *builder, hexv));
           return fir::substBase(hexv, temp);
         });
 
     return bindIfNewSymbol(sym, exv);
   }
 
   void
   copyHostAssociateVar(const Fortran::semantics::Symbol &sym) override final {
     // 1) Fetch the original copy of the variable.
     assert(sym.has<Fortran::semantics::HostAssocDetails>() &&
            "No host-association found");
     const Fortran::semantics::Symbol &hsym = sym.GetUltimate();
     Fortran::lower::SymbolBox hsb = lookupOneLevelUpSymbol(hsym);
     assert(hsb && "Host symbol box not found");
     fir::ExtendedValue hexv = getExtendedValue(hsb);
 
     // 2) Fetch the copied one that will mask the original.
     Fortran::lower::SymbolBox sb = shallowLookupSymbol(sym);
     assert(sb && "Host-associated symbol box not found");
     assert(hsb.getAddr() != sb.getAddr() &&
            "Host and associated symbol boxes are the same");
     fir::ExtendedValue exv = getExtendedValue(sb);
 
     // 3) Perform the assignment.
     builder->setInsertionPointAfter(fir::getBase(exv).getDefiningOp());
-    mlir::Location loc = getCurrentLocation();
+    mlir::Location loc = genLocation(sym.name());
     mlir::Type symType = genType(sym);
     if (auto seqTy = symType.dyn_cast<fir::SequenceType>()) {
       Fortran::lower::StatementContext stmtCtx;
       Fortran::lower::createSomeArrayAssignment(*this, exv, hexv, localSymbols,
                                                 stmtCtx);
       stmtCtx.finalize();
     } else if (hexv.getBoxOf<fir::CharBoxValue>()) {
       fir::factory::CharacterExprHelper{*builder, loc}.createAssign(exv, hexv);

flang/lib/Lower/ConvertExpr.cpp

ExtValue genval(const Fortran::evaluate::ProcedureDesignator &proc) {
     }
     return funcPtr;
   }
   ExtValue genval(const Fortran::evaluate::NullPointer &) {
     return builder.createNullConstant(getLoc());
   }
 
   static bool
-  isDerivedTypeWithLengthParameters(const Fortran::semantics::Symbol &sym) {
+  isDerivedTypeWithLenParameters(const Fortran::semantics::Symbol &sym) {
     if (const Fortran::semantics::DeclTypeSpec *declTy = sym.GetType())
       if (const Fortran::semantics::DerivedTypeSpec *derived =
               declTy->AsDerived())
         return Fortran::semantics::CountLenParameters(*derived) > 0;
     return false;
   }
 
   static bool isBuiltinCPtr(const Fortran::semantics::Symbol &sym) {
for (const auto &[sym, expr] : ctor.values()) {
         mlir::Value initialTarget = Fortran::lower::genInitialDataTarget(
             converter, loc, componentTy, expr.value());
         res = builder.create<fir::InsertValueOp>(
             loc, recTy, res, initialTarget,
             builder.getArrayAttr(field.getAttributes()));
         continue;
       }
 
-      if (isDerivedTypeWithLengthParameters(sym))
+      if (isDerivedTypeWithLenParameters(sym))
         TODO(loc, "component with length parameters in structure constructor");
 
       if (isBuiltinCPtr(sym)) {
         // Builtin c_ptr and c_funptr have special handling because initial
         // value are handled for them as an extension.
         mlir::Value addr = fir::getBase(Fortran::lower::genExtAddrInInitializer(
             converter, loc, expr.value()));
         if (addr.getType() == componentTy) {
ExtValue genval(const Fortran::evaluate::StructureConstructor &ctor) {
     for (const auto &value : ctor.values()) {
       const Fortran::semantics::Symbol &sym = *value.first;
       const Fortran::lower::SomeExpr &expr = value.second.value();
       // Parent components need more work because they do not appear in the
       // fir.rec type.
       if (sym.test(Fortran::semantics::Symbol::Flag::ParentComp))
         TODO(loc, "parent component in structure constructor");
 
-      if (isDerivedTypeWithLengthParameters(sym))
+      if (isDerivedTypeWithLenParameters(sym))
         TODO(loc, "component with length parameters in structure constructor");
 
       llvm::StringRef name = toStringRef(sym.name());
       // FIXME: type parameters must come from the derived-type-spec
       mlir::Value field = builder.create<fir::FieldIndexOp>(
           loc, fieldTy, name, ty,
           /*typeParams=*/mlir::ValueRange{} /*TODO*/);
       mlir::Type coorTy = builder.getRefType(recTy.getType(name));
#define GENBIN(GenBinEvOp, GenBinTyCat, GenBinFirOp)                           \
   /// It preserves all the non default lower bounds/non deferred length
   /// parameter information.
   ExtValue lowerIntrinsicArgumentAsBox(const Fortran::lower::SomeExpr &expr) {
     mlir::Location loc = getLoc();
     ExtValue exv = genBoxArg(expr);
     mlir::Value box = builder.createBox(loc, exv);
     return fir::BoxValue(
         box, fir::factory::getNonDefaultLowerBounds(builder, loc, exv),
-        fir::factory::getNonDeferredLengthParams(exv));
+        fir::factory::getNonDeferredLenParams(exv));
   }
 
   /// Generate a call to a Fortran intrinsic or intrinsic module procedure.
   ExtValue genIntrinsicRef(
       const Fortran::evaluate::ProcedureRef &procRef,
       llvm::Optional<mlir::Type> resultType,
       llvm::Optional<const Fortran::evaluate::SpecificIntrinsic> intrinsic =
           llvm::None) {

flang/lib/Lower/ConvertVariable.cpp

static mlir::Value genScalarValue(Fortran::lower::AbstractConverter &converter,
                                   const Fortran::lower::SomeExpr &expr,
                                   Fortran::lower::SymMap &symMap,
                                   Fortran::lower::StatementContext &context) {
   // This does not use the AbstractConverter member function to override the
   // symbol mapping to be used expression lowering.
   return fir::getBase(Fortran::lower::createSomeExtendedExpression(
       loc, converter, expr, symMap, context));
 }
-
 /// Does this variable have a default initialization?
 static bool hasDefaultInitialization(const Fortran::semantics::Symbol &sym) {
   if (sym.has<Fortran::semantics::ObjectEntityDetails>() && sym.size())
     if (!Fortran::semantics::IsAllocatableOrPointer(sym))
       if (const Fortran::semantics::DeclTypeSpec *declTypeSpec = sym.GetType())
         if (const Fortran::semantics::DerivedTypeSpec *derivedTypeSpec =
                 declTypeSpec->AsDerived())
           return derivedTypeSpec->HasDefaultInitialization();
return sym.test(Fortran::semantics::Symbol::Flag::CompilerCreated) &&
          sym.test(Fortran::semantics::Symbol::Flag::ReadOnly);
 }
 
 static fir::GlobalOp defineGlobal(Fortran::lower::AbstractConverter &converter,
                                   const Fortran::lower::pft::Variable &var,
                                   llvm::StringRef globalName,
                                   mlir::StringAttr linkage);
 
+static mlir::Location genLocation(Fortran::lower::AbstractConverter &converter,
+                                  const Fortran::semantics::Symbol &sym) {
+  // Compiler generated name cannot be used as source location, their name
+  // is not pointing to the source files.
+  if (!sym.test(Fortran::semantics::Symbol::Flag::CompilerCreated))
+    return converter.genLocation(sym.name());
+  return converter.getCurrentLocation();
+}
+
 /// Create the global op declaration without any initializer
 static fir::GlobalOp declareGlobal(Fortran::lower::AbstractConverter &converter,
                                    const Fortran::lower::pft::Variable &var,
                                    llvm::StringRef globalName,
                                    mlir::StringAttr linkage) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   if (fir::GlobalOp global = builder.getNamedGlobal(globalName))
     return global;
   // Always define linkonce data since it may be optimized out from the module
   // that actually owns the variable if it does not refers to it.
   if (linkage == builder.createLinkOnceODRLinkage() ||
       linkage == builder.createLinkOnceLinkage())
     return defineGlobal(converter, var, globalName, linkage);
   const Fortran::semantics::Symbol &sym = var.getSymbol();
-  mlir::Location loc = converter.genLocation(sym.name());
+  mlir::Location loc = genLocation(converter, sym);
   // Resolve potential host and module association before checking that this
   // symbol is an object of a function pointer.
   const Fortran::semantics::Symbol &ultimate = sym.GetUltimate();
   if (!ultimate.has<Fortran::semantics::ObjectEntityDetails>() &&
       !Fortran::semantics::IsProcedurePointer(ultimate))
     mlir::emitError(loc, "processing global declaration: symbol '")
         << toStringRef(sym.name()) << "' has unexpected details\n";
   return builder.createGlobal(loc, converter.genType(var), globalName, linkage,

 
 /// Create the global op and its init if it has one
 static fir::GlobalOp defineGlobal(Fortran::lower::AbstractConverter &converter,
                                   const Fortran::lower::pft::Variable &var,
                                   llvm::StringRef globalName,
                                   mlir::StringAttr linkage) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   const Fortran::semantics::Symbol &sym = var.getSymbol();
-  mlir::Location loc = converter.genLocation(sym.name());
+  mlir::Location loc = genLocation(converter, sym);
   bool isConst = isConstant(sym);
   fir::GlobalOp global = builder.getNamedGlobal(globalName);
   mlir::Type symTy = converter.genType(var);
 
   if (global && globalIsInitialized(global))
     return global;
 
   if (Fortran::semantics::IsProcedurePointer(sym))

 /// 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 = converter.genLocation(sym.name());
+  mlir::Location loc = genLocation(converter, sym);
   fir::GlobalOp global = builder.getNamedGlobal(globalName);
   mlir::StringAttr linkage = getLinkageAttribute(builder, var);
   if (var.isModuleVariable()) {
     // 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);

 /// aggregate storage and lower its attributes.
 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 = converter.genLocation(sym.name());
+  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,

 /// entry point has already been mapped to an mlir block argument in
 /// mapDummiesAndResults.  Its mapping may be updated here.
 void Fortran::lower::mapSymbolAttributes(
     AbstractConverter &converter, const Fortran::lower::pft::Variable &var,
     Fortran::lower::SymMap &symMap, Fortran::lower::StatementContext &stmtCtx,
     mlir::Value preAlloc) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   const Fortran::semantics::Symbol &sym = var.getSymbol();
-  const mlir::Location loc = converter.genLocation(sym.name());
+  const mlir::Location loc = genLocation(converter, sym);
   mlir::IndexType idxTy = builder.getIndexType();
   const bool isDeclaredDummy = Fortran::semantics::IsDummy(sym);
   // An active dummy from the current entry point.
   const bool isDummy = isDeclaredDummy && symMap.lookupSymbol(sym).getAddr();
   // An unused dummy from another entry point.
   const bool isUnusedEntryDummy = isDeclaredDummy && !isDummy;
   const bool isResult = Fortran::semantics::IsFunctionResult(sym);
   const bool replace = isDummy || isResult;

flang/lib/Lower/HostAssociations.cpp

fir::factory::CharacterExprHelper charHelp(converter.getFirOpBuilder(),
                                                args.loc);
     std::pair<mlir::Value, mlir::Value> unboxchar =
         charHelp.createUnboxChar(args.valueInTuple);
     args.symMap.addCharSymbol(sym, unboxchar.first, unboxchar.second);
   }
 };
 
 /// Is \p sym a derived type entity with length parameters ?
-static bool
-isDerivedWithLengthParameters(const Fortran::semantics::Symbol &sym) {
+static bool isDerivedWithLenParameters(const Fortran::semantics::Symbol &sym) {
   if (const auto *declTy = sym.GetType())
     if (const auto *derived = declTy->AsDerived())
       return Fortran::semantics::CountLenParameters(*derived) != 0;
   return false;
 }
 
 /// Class defining how allocatable and pointers entities are captured in
 /// internal procedures. Allocatable and pointers are simply captured by placing
if (ba.isChar()) {
                     builder.create<fir::ResultOp>(loc, undef.getResult());
                   })
                   .getResults()[0];
           nonDeferredLenParams.push_back(len);
         } else {
           nonDeferredLenParams.push_back(readLength());
         }
       }
-    } else if (isDerivedWithLengthParameters(sym)) {
+    } else if (isDerivedWithLenParameters(sym)) {
       TODO(loc, "host associated derived type allocatable or pointer with "
                 "length parameters");
     }
     args.symMap.addSymbol(
         sym, fir::MutableBoxValue(args.valueInTuple, nonDeferredLenParams, {}));
   }
 };
 
canReadCapturedBoxValue(Fortran::lower::AbstractConverter &converter,
                           const Fortran::semantics::Symbol &sym) {
     bool isScalarOrContiguous =
         sym.Rank() == 0 || Fortran::evaluate::IsSimplyContiguous(
                                Fortran::evaluate::AsGenericExpr(sym).value(),
                                converter.getFoldingContext());
     const Fortran::semantics::DeclTypeSpec *type = sym.GetType();
     bool isPolymorphic = type && type->IsPolymorphic();
     return isScalarOrContiguous && !isPolymorphic &&
-           !isDerivedWithLengthParameters(sym);
+           !isDerivedWithLenParameters(sym);
   }
 };
 
 /// Dispatch \p visitor to the CapturedSymbols which is handling how host
 /// association is implemented for this kind of symbols. This ensures the same
 /// dispatch decision is taken when building the tuple type, when creating the
 /// tuple, and when instantiating host associated variables from it.
 template <typename T>
 typename T::Result
 walkCaptureCategories(T visitor, Fortran::lower::AbstractConverter &converter,
                       const Fortran::semantics::Symbol &sym) {
-  if (isDerivedWithLengthParameters(sym))
+  if (isDerivedWithLenParameters(sym))
     // Should be boxed.
     TODO(converter.genLocation(sym.name()),
          "host associated derived type with length parameters");
   Fortran::lower::BoxAnalyzer ba;
   // Do not analyze procedures, they may be subroutines with no types that would
   // crash the analysis.
   if (Fortran::semantics::IsProcedure(sym))
     return CapturedProcedure::visit(visitor, converter, sym, ba);

flang/lib/Optimizer/Builder/FIRBuilder.cpp

return exv.match(
       [&](const fir::MutableBoxValue &box) -> llvm::SmallVector<mlir::Value> {
         auto load = fir::factory::genMutableBoxRead(builder, loc, box);
         return fir::factory::getNonDefaultLowerBounds(builder, loc, load);
       },
       [&](const auto &) -> llvm::SmallVector<mlir::Value> { return {}; });
 }
 
 llvm::SmallVector<mlir::Value>
-fir::factory::getNonDeferredLengthParams(const fir::ExtendedValue &exv) {
+fir::factory::getNonDeferredLenParams(const fir::ExtendedValue &exv) {
   return exv.match(
       [&](const fir::CharArrayBoxValue &character)
           -> llvm::SmallVector<mlir::Value> { return {character.getLen()}; },
       [&](const fir::CharBoxValue &character)
           -> llvm::SmallVector<mlir::Value> { return {character.getLen()}; },
       [&](const fir::MutableBoxValue &box) -> llvm::SmallVector<mlir::Value> {
         return {box.nonDeferredLenParams().begin(),
                 box.nonDeferredLenParams().end()};

flang/lib/Optimizer/CodeGen/CodeGen.cpp

if (coor.subcomponent().empty()) {
         auto eleTy = fir::dyn_cast_ptrEleTy(coor.getType());
         assert(eleTy && "result must be a reference-like type");
         if (fir::characterWithDynamicLen(eleTy)) {
           assert(coor.lenParams().size() == 1);
           auto length = integerCast(loc, rewriter, idxTy,
                                     operands[coor.lenParamsOffset()]);
           offset =
               rewriter.create<mlir::LLVM::MulOp>(loc, idxTy, offset, length);
-
         } else {
           TODO(loc, "compute size of derived type with type parameters");
         }
       }
       // Cast the base address to a pointer to T.
       base = rewriter.create<mlir::LLVM::BitcastOp>(loc, ty, operands[0]);
     } else {
       // Operand #0 must have a pointer type. For subcomponent slicing, we