[flang][NFC] share Constant<SomeDerived> lowering

[jeanPerier]

Summary

A previous patch (https://reviews.llvm.org/D136955) already refactored
intrinsic constant lowering to place in its own file and allow using it from
both the current lowering and the new lowering to HLFIR.

This patch does the same for derived types. The core function
"genStructComponentInInitializer" is moved from ConvertExpr.cpp and
renamed "genInlinedStructureCtorLitImpl" into ConvertConstant.cpp
without significant logic change.

Then, genScalarLit, genArrayLit (and genInlinedArrayLit/genOutlinedArrayLit)
are updated to support derived types.

The core aspect of derived type constant lowering that differs between
the current lowering and the HLFIR update is the way
addresses/initial target descriptors are built when part of a derived
type constant. This part happens in ConvertVariable.cpp (since the
address of a variable is taken in an initializer and is left TODO).

The mangling of derived type global literal constant is fixed: it did not embed
the derived type name and could cause "conflicts" between unrelated
derived types containing the same data. However, the hash remains
unstable between two compilation of the same file. This is not a
correctness issue and would require a lot of work to hash the derived
type constant data without hashing some irrelevant (but not out of bound)
data in the compile time data structure that holds derived type
constants (Constant<SomeDerived>). This may have to be revisited later.

[PeteSteinfeld]

Aside from a few nits in comments, all builds and tests correctly and looks good.

flang/include/flang/Lower/Mangler.h

91

"is none trivial" should read "is a nontrivial".

93

"constructor" should read "constructors".

flang/lib/Lower/ConvertConstant.cpp

367

"value" should read "values"

[jeanPerier]

Fix typos in comments. Thanks for catching them Pete.

flang/include/flang/Lower/ConvertConstant.h

 #define FORTRAN_LOWER_CONVERTCONSTANT_H
 
 #include "flang/Evaluate/constant.h"
 #include "flang/Lower/Support/Utils.h"
 #include "flang/Optimizer/Builder/BoxValue.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 
 namespace Fortran::lower {
-template <typename T>
-class ConstantBuilder {};
+class AbstractConverter;
 
-/// Class to lower intrinsic evaluate::Constant to fir::ExtendedValue.
-template <common::TypeCategory TC, int KIND>
-class ConstantBuilder<evaluate::Type<TC, KIND>> {
+/// Class to lower evaluate::Constant to fir::ExtendedValue.
+template <typename T>
+class ConstantBuilder {
 public:
   /// Lower \p constant into a fir::ExtendedValue.
-  /// If \p outlineBigConstantsInReadOnlyMemory is set, character and array
-  /// constants will be lowered into read only memory fir.global, and the
-  /// resulting fir::ExtendedValue will contain the address of the fir.global.
-  /// This option should not be set if the constant is being lowered while the
-  /// builder is already in a fir.global body because fir.global initialization
-  /// body cannot contain code manipulating memory (e.g. fir.load/fir.store...).
-  static fir::ExtendedValue
-  gen(fir::FirOpBuilder &builder, mlir::Location loc,
-      const evaluate::Constant<evaluate::Type<TC, KIND>> &constant,
+  /// If \p outlineBigConstantsInReadOnlyMemory is set, character, derived
+  /// type, and array constants will be lowered into read only memory
+  /// fir.global, and the resulting fir::ExtendedValue will contain the address
+  /// of the fir.global. This option should not be set if the constant is being
+  /// lowered while the builder is already in a fir.global body because
+  /// fir.global initialization body cannot contain code manipulating memory
+  /// (e.g.  fir.load/fir.store...).
+  static fir::ExtendedValue gen(Fortran::lower::AbstractConverter &converter,
+                                mlir::Location loc,
+                                const evaluate::Constant<T> &constant,
                                 bool outlineBigConstantsInReadOnlyMemory);
 };
-
-template <common::TypeCategory TC, int KIND>
-using IntrinsicConstantBuilder = ConstantBuilder<evaluate::Type<TC, KIND>>;
-
 using namespace evaluate;
-FOR_EACH_INTRINSIC_KIND(extern template class ConstantBuilder, )
+FOR_EACH_SPECIFIC_TYPE(extern template class ConstantBuilder, )
+
+template <typename T>
+fir::ExtendedValue convertConstant(Fortran::lower::AbstractConverter &converter,
+                                   mlir::Location loc,
+                                   const evaluate::Constant<T> &constant,
+                                   bool outlineBigConstantsInReadOnlyMemory) {
+  return ConstantBuilder<T>::gen(converter, loc, constant,
+                                 outlineBigConstantsInReadOnlyMemory);
+}
 
 /// Create a fir.global array with a dense attribute containing the value of
 /// \p initExpr.
 /// Using a dense attribute allows faster MLIR compilation times compared to
 /// creating an initialization body for the initial value. However, a dense
 /// attribute can only be created if initExpr is a non-empty rank 1 numerical or
 /// logical Constant<T>. Otherwise, the value returned will be null.
 fir::GlobalOp tryCreatingDenseGlobal(fir::FirOpBuilder &builder,
                                      mlir::Location loc, mlir::Type symTy,
                                      llvm::StringRef globalName,
                                      mlir::StringAttr linkage, bool isConst,
                                      const Fortran::lower::SomeExpr &initExpr);
 
+/// Lower a StructureConstructor that must be lowered in read only data although
+/// it may not be wrapped into a Constant<T> (this may be the case for derived
+/// type descriptor compiler generated data that is not fully compliant with
+/// Fortran constant expression but can and must still be lowered into read only
+/// memory).
+fir::ExtendedValue
+genInlinedStructureCtorLit(Fortran::lower::AbstractConverter &converter,
+                           mlir::Location loc,
+                           const Fortran::evaluate::StructureConstructor &ctor);
+
 } // namespace Fortran::lower
 
 #endif // FORTRAN_LOWER_CONVERTCONSTANT_H

flang/include/flang/Lower/ConvertType.h

 
 /// Translate a Fortran::lower::pft::Variable to an mlir::Type.
 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);
 
+bool isDerivedTypeWithLenParameters(const semantics::Symbol &);
+
 template <typename T>
 class TypeBuilder {
 public:
   static mlir::Type genType(Fortran::lower::AbstractConverter &,
                             const Fortran::evaluate::FunctionRef<T> &);
 };
 using namespace evaluate;
 FOR_EACH_SPECIFIC_TYPE(extern template class TypeBuilder, )
 
 } // namespace lower
 } // namespace Fortran
 
 #endif // FORTRAN_LOWER_CONVERT_TYPE_H

flang/include/flang/Lower/Mangler.h

 //===-- Lower/Mangler.h -- name mangling ------------------------*- 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/
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_MANGLER_H
 #define FORTRAN_LOWER_MANGLER_H
 
 #include "flang/Evaluate/expression.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "llvm/ADT/StringRef.h"
 #include <string>
 
 namespace fir {
 
 /// Returns a name suitable to define mlir functions for Fortran intrinsic
 /// Procedure. These names are guaranteed to not conflict with user defined

 
 /// Recover the bare name of the original symbol from an internal name.
 std::string demangleName(llvm::StringRef name);
 
 std::string
 mangleArrayLiteral(const uint8_t *addr, size_t size,
                    const Fortran::evaluate::ConstantSubscripts &shape,
                    Fortran::common::TypeCategory cat, int kind = 0,
-                   Fortran::common::ConstantSubscript charLen = -1);
+                   Fortran::common::ConstantSubscript charLen = -1,
+                   llvm::StringRef derivedName = {});
 
 template <Fortran::common::TypeCategory TC, int KIND>
 std::string mangleArrayLiteral(
+    mlir::Type,
     const Fortran::evaluate::Constant<Fortran::evaluate::Type<TC, KIND>> &x) {
   return mangleArrayLiteral(
       reinterpret_cast<const uint8_t *>(x.values().data()),
       x.values().size() * sizeof(x.values()[0]), x.shape(), TC, KIND);
 }
 
 template <int KIND>
 std::string
-mangleArrayLiteral(const Fortran::evaluate::Constant<Fortran::evaluate::Type<
+mangleArrayLiteral(mlir::Type,
+                   const Fortran::evaluate::Constant<Fortran::evaluate::Type<
                        Fortran::common::TypeCategory::Character, KIND>> &x) {
   return mangleArrayLiteral(
       reinterpret_cast<const uint8_t *>(x.values().data()),
       x.values().size() * sizeof(x.values()[0]), x.shape(),
       Fortran::common::TypeCategory::Character, KIND, x.LEN());
 }
 
+// FIXME: derived type mangling is safe but not reproducible between two
+// compilation of a same file because `values().data()` is a nontrivial compile
+// time data structure containing pointers and vectors. In particular, this
+// means that similar structure constructors are not "combined" into the same
+// global constant by lowering.
 inline std::string mangleArrayLiteral(
+    mlir::Type eleTy,
     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);
+      Fortran::common::TypeCategory::Derived, /*kind=*/0, /*charLen=*/-1,
+      eleTy.cast<fir::RecordType>().getName());
 }
 
 /// 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/lib/Lower/ConvertConstant.cpp

 //===-- ConvertConstant.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
 //
 //===----------------------------------------------------------------------===//
 //
 // Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Lower/ConvertConstant.h"
 #include "flang/Evaluate/expression.h"
+#include "flang/Lower/AbstractConverter.h"
+#include "flang/Lower/BuiltinModules.h"
 #include "flang/Lower/ConvertType.h"
+#include "flang/Lower/ConvertVariable.h"
 #include "flang/Lower/Mangler.h"
 #include "flang/Optimizer/Builder/Complex.h"
 #include "flang/Optimizer/Builder/Todo.h"
 
 /// Convert string, \p s, to an APFloat value. Recognize and handle Inf and
 /// NaN strings as well. \p s is assumed to not contain any spaces.
 static llvm::APFloat consAPFloat(const llvm::fltSemantics &fsem,
                                  llvm::StringRef s) {
fir::GlobalOp Fortran::lower::tryCreatingDenseGlobal(
     fir::FirOpBuilder &builder, mlir::Location loc, mlir::Type symTy,
     llvm::StringRef globalName, mlir::StringAttr linkage, bool isConst,
     const Fortran::lower::SomeExpr &initExpr) {
   return DenseGlobalBuilder::tryCreating(builder, loc, symTy, globalName,
                                          linkage, isConst, initExpr);
 }
 
 //===----------------------------------------------------------------------===//
-// Fortran::lower::IntrinsicConstantBuilder<TC, KIND>::gen
-// Lower an array constant to a fir::ExtendedValue.
+// Fortran::lower::convertConstant
+// Lower a constant to a fir::ExtendedValue.
 //===----------------------------------------------------------------------===//
 
 /// Generate a real constant with a value `value`.
 template <int KIND>
 static mlir::Value genRealConstant(fir::FirOpBuilder &builder,
                                    mlir::Location loc,
                                    const llvm::APFloat &value) {
   mlir::Type fltTy = Fortran::lower::convertReal(builder.getContext(), KIND);
global = builder.createGlobalConstant(
               createStringLitOp<KIND>(builder, loc, value, len);
           builder.create<fir::HasValueOp>(loc, str);
         },
         builder.createLinkOnceLinkage());
   return builder.create<fir::AddrOfOp>(loc, global.resultType(),
                                        global.getSymbol());
 }
 
+// Helper to generate StructureConstructor component values.
+static fir::ExtendedValue
+genConstantValue(Fortran::lower::AbstractConverter &converter,
+                 mlir::Location loc,
+                 const Fortran::lower::SomeExpr &constantExpr);
+
+// Generate a StructureConstructor inlined (returns raw fir.type<T> value,
+// not the address of a global constant).
+static mlir::Value genInlinedStructureCtorLitImpl(
+    Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+    const Fortran::evaluate::StructureConstructor &ctor, mlir::Type type) {
+  fir::FirOpBuilder &builder = converter.getFirOpBuilder();
+  auto recTy = type.cast<fir::RecordType>();
+  auto fieldTy = fir::FieldType::get(type.getContext());
+  mlir::Value res = builder.create<fir::UndefOp>(loc, recTy);
+
+  for (const auto &[sym, expr] : ctor.values()) {
+    // 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");
+
+    llvm::StringRef name = toStringRef(sym->name());
+    mlir::Type componentTy = recTy.getType(name);
+    // FIXME: type parameters must come from the derived-type-spec
+    auto field = builder.create<fir::FieldIndexOp>(
+        loc, fieldTy, name, type,
+        /*typeParams=*/mlir::ValueRange{} /*TODO*/);
+
+    if (Fortran::semantics::IsAllocatable(sym))
+      TODO(loc, "allocatable component in structure constructor");
+
+    if (Fortran::semantics::IsPointer(sym)) {
+      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 (Fortran::lower::isDerivedTypeWithLenParameters(sym))
+      TODO(loc, "component with length parameters in structure constructor");
+
+    if (Fortran::semantics::IsBuiltinCPtr(sym)) {
+      // Builtin c_ptr and c_funptr have special handling because initial
+      // values are handled for them as an extension.
+      mlir::Value addr = fir::getBase(Fortran::lower::genExtAddrInInitializer(
+          converter, loc, expr.value()));
+      if (addr.getType() == componentTy) {
+        // Do nothing. The Ev::Expr was returned as a value that can be
+        // inserted directly to the component without an intermediary.
+      } else {
+        // The Ev::Expr returned is an initializer that is a pointer (e.g.,
+        // null) that must be inserted into an intermediate cptr record
+        // value's address field, which ought to be an intptr_t on the target.
+        assert((fir::isa_ref_type(addr.getType()) ||
+                addr.getType().isa<mlir::FunctionType>()) &&
+               "expect reference type for address field");
+        assert(fir::isa_derived(componentTy) &&
+               "expect C_PTR, C_FUNPTR to be a record");
+        auto cPtrRecTy = componentTy.cast<fir::RecordType>();
+        llvm::StringRef addrFieldName = Fortran::lower::builtin::cptrFieldName;
+        mlir::Type addrFieldTy = cPtrRecTy.getType(addrFieldName);
+        auto addrField = builder.create<fir::FieldIndexOp>(
+            loc, fieldTy, addrFieldName, componentTy,
+            /*typeParams=*/mlir::ValueRange{});
+        mlir::Value castAddr = builder.createConvert(loc, addrFieldTy, addr);
+        auto undef = builder.create<fir::UndefOp>(loc, componentTy);
+        addr = builder.create<fir::InsertValueOp>(
+            loc, componentTy, undef, castAddr,
+            builder.getArrayAttr(addrField.getAttributes()));
+      }
+      res = builder.create<fir::InsertValueOp>(
+          loc, recTy, res, addr, builder.getArrayAttr(field.getAttributes()));
+      continue;
+    }
+
+    mlir::Value val =
+        fir::getBase(genConstantValue(converter, loc, expr.value()));
+    assert(!fir::isa_ref_type(val.getType()) && "expecting a constant value");
+    mlir::Value castVal = builder.createConvert(loc, componentTy, val);
+    res = builder.create<fir::InsertValueOp>(
+        loc, recTy, res, castVal, builder.getArrayAttr(field.getAttributes()));
+  }
+  return res;
+}
+
+static mlir::Value genScalarLit(
+    Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+    const Fortran::evaluate::Scalar<Fortran::evaluate::SomeDerived> &value,
+    mlir::Type eleTy, bool outlineBigConstantsInReadOnlyMemory) {
+  if (!outlineBigConstantsInReadOnlyMemory)
+    return genInlinedStructureCtorLitImpl(converter, loc, value, eleTy);
+  fir::FirOpBuilder &builder = converter.getFirOpBuilder();
+  std::string globalName = Fortran::lower::mangle::mangleArrayLiteral(
+      eleTy,
+      Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived>(value));
+  fir::GlobalOp global = builder.getNamedGlobal(globalName);
+  if (!global) {
+    global = builder.createGlobalConstant(
+        loc, eleTy, globalName,
+        [&](fir::FirOpBuilder &builder) {
+          mlir::Value result =
+              genInlinedStructureCtorLitImpl(converter, loc, value, eleTy);
+          builder.create<fir::HasValueOp>(loc, result);
+        },
+        builder.createInternalLinkage());
+  }
+  return builder.create<fir::AddrOfOp>(loc, global.resultType(),
+                                       global.getSymbol());
+}
+
 /// Create an evaluate::Constant<T> array to a fir.array<> value
 /// built with a chain of fir.insert or fir.insert_on_range operations.
 /// This is intended to be called when building the body of a fir.global.
-template <Fortran::common::TypeCategory TC, int KIND>
-static mlir::Value genInlinedArrayLit(
-    fir::FirOpBuilder &builder, mlir::Location loc, mlir::Type arrayTy,
-    const Fortran::evaluate::Constant<Fortran::evaluate::Type<TC, KIND>> &con) {
+template <typename T>
+static mlir::Value
+genInlinedArrayLit(Fortran::lower::AbstractConverter &converter,
+                   mlir::Location loc, mlir::Type arrayTy,
+                   const Fortran::evaluate::Constant<T> &con) {
+  fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   mlir::IndexType idxTy = builder.getIndexType();
   Fortran::evaluate::ConstantSubscripts subscripts = con.lbounds();
   auto createIdx = [&]() {
     llvm::SmallVector<mlir::Attribute> idx;
     for (size_t i = 0; i < subscripts.size(); ++i)
       idx.push_back(
           builder.getIntegerAttr(idxTy, subscripts[i] - con.lbounds()[i]));
     return idx;
   };
   mlir::Value array = builder.create<fir::UndefOp>(loc, arrayTy);
   if (Fortran::evaluate::GetSize(con.shape()) == 0)
     return array;
-  if constexpr (TC == Fortran::common::TypeCategory::Character) {
+  if constexpr (T::category == Fortran::common::TypeCategory::Character) {
     do {
       mlir::Value elementVal =
-          genScalarLit<KIND>(builder, loc, con.At(subscripts), con.LEN(),
-                             /*outlineInReadOnlyMemory=*/false);
+          genScalarLit<T::kind>(builder, loc, con.At(subscripts), con.LEN(),
+                                /*outlineInReadOnlyMemory=*/false);
+      array = builder.create<fir::InsertValueOp>(
+          loc, arrayTy, array, elementVal, builder.getArrayAttr(createIdx()));
+    } while (con.IncrementSubscripts(subscripts));
+  } else if constexpr (T::category == Fortran::common::TypeCategory::Derived) {
+    do {
+      mlir::Type eleTy = arrayTy.cast<fir::SequenceType>().getEleTy();
+      mlir::Value elementVal =
+          genScalarLit(converter, loc, con.At(subscripts), eleTy,
       array = builder.create<fir::InsertValueOp>(
           loc, arrayTy, array, elementVal, builder.getArrayAttr(createIdx()));
     } while (con.IncrementSubscripts(subscripts));
   } else {
     llvm::SmallVector<mlir::Attribute> rangeStartIdx;
     uint64_t rangeSize = 0;
     mlir::Type eleTy = arrayTy.cast<fir::SequenceType>().getEleTy();
     do {
       auto getElementVal = [&]() {
-        return builder.createConvert(
-            loc, eleTy,
-            genScalarLit<TC, KIND>(builder, loc, con.At(subscripts)));
+        return builder.createConvert(loc, eleTy,
+                                     genScalarLit<T::category, T::kind>(
+                                         builder, loc, con.At(subscripts)));
       };
       Fortran::evaluate::ConstantSubscripts nextSubscripts = subscripts;
       bool nextIsSame = con.IncrementSubscripts(nextSubscripts) &&
                         con.At(subscripts) == con.At(nextSubscripts);
       if (!rangeSize && !nextIsSame) { // single (non-range) value
         array = builder.create<fir::InsertValueOp>(
             loc, arrayTy, array, getElementVal(),
             builder.getArrayAttr(createIdx()));
genInlinedArrayLit(Fortran::lower::AbstractConverter &converter,
   }
   return array;
 }
 
 /// Convert an evaluate::Constant<T> array into a fir.ref<fir.array<>> value
 /// that points to the storage of a fir.global in read only memory and is
 /// initialized with the value of the constant.
 /// This should not be called while generating the body of a fir.global.
-template <Fortran::common::TypeCategory TC, int KIND>
-static mlir::Value genOutlineArrayLit(
-    fir::FirOpBuilder &builder, mlir::Location loc, mlir::Type arrayTy,
-    const Fortran::evaluate::Constant<Fortran::evaluate::Type<TC, KIND>>
-        &constant) {
-  std::string globalName = Fortran::lower::mangle::mangleArrayLiteral(constant);
+template <typename T>
+static mlir::Value
+genOutlineArrayLit(Fortran::lower::AbstractConverter &converter,
+                   mlir::Location loc, mlir::Type arrayTy,
+                   const Fortran::evaluate::Constant<T> &constant) {
+  fir::FirOpBuilder &builder = converter.getFirOpBuilder();
+  mlir::Type eleTy = arrayTy.cast<fir::SequenceType>().getEleTy();
+  std::string globalName =
+      Fortran::lower::mangle::mangleArrayLiteral(eleTy, constant);
   fir::GlobalOp global = builder.getNamedGlobal(globalName);
   if (!global) {
     // Using a dense attribute for the initial value instead of creating an
     // intialization body speeds up MLIR/LLVM compilation, but this is not
     // always possible.
-    if constexpr (TC == Fortran::common::TypeCategory::Logical ||
-                  TC == Fortran::common::TypeCategory::Integer ||
-                  TC == Fortran::common::TypeCategory::Real) {
+    if constexpr (T::category == Fortran::common::TypeCategory::Logical ||
+                  T::category == Fortran::common::TypeCategory::Integer ||
+                  T::category == Fortran::common::TypeCategory::Real) {
       global = DenseGlobalBuilder::tryCreating(
           builder, loc, arrayTy, globalName, builder.createInternalLinkage(),
           true, constant);
     }
     if (!global)
       global = builder.createGlobalConstant(
           loc, arrayTy, globalName,
           [&](fir::FirOpBuilder &builder) {
             mlir::Value result =
-                genInlinedArrayLit(builder, loc, arrayTy, constant);
+                genInlinedArrayLit(converter, loc, arrayTy, constant);
             builder.create<fir::HasValueOp>(loc, result);
           },
           builder.createInternalLinkage());
   }
   return builder.create<fir::AddrOfOp>(loc, global.resultType(),
                                        global.getSymbol());
 }
 
 /// Convert an evaluate::Constant<T> array into an fir::ExtendedValue.
-template <Fortran::common::TypeCategory TC, int KIND>
-static fir::ExtendedValue genArrayLit(
-    fir::FirOpBuilder &builder, mlir::Location loc,
-    const Fortran::evaluate::Constant<Fortran::evaluate::Type<TC, KIND>> &con,
+template <typename T>
+static fir::ExtendedValue
+genArrayLit(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+            const Fortran::evaluate::Constant<T> &con,
             bool outlineInReadOnlyMemory) {
+  fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   Fortran::evaluate::ConstantSubscript size =
       Fortran::evaluate::GetSize(con.shape());
   if (size > std::numeric_limits<std::uint32_t>::max())
     // llvm::SmallVector has limited size
     TODO(loc, "Creation of very large array constants");
   fir::SequenceType::Shape shape(con.shape().begin(), con.shape().end());
   llvm::SmallVector<std::int64_t> typeParams;
-  if constexpr (TC == Fortran::common::TypeCategory::Character)
+  if constexpr (T::category == Fortran::common::TypeCategory::Character)
     typeParams.push_back(con.LEN());
-  mlir::Type eleTy =
-      Fortran::lower::getFIRType(builder.getContext(), TC, KIND, typeParams);
+  mlir::Type eleTy;
+  if constexpr (T::category == Fortran::common::TypeCategory::Derived)
+    eleTy = Fortran::lower::translateDerivedTypeToFIRType(
+        converter, con.GetType().GetDerivedTypeSpec());
+  else
+    eleTy = Fortran::lower::getFIRType(builder.getContext(), T::category,
+                                       T::kind, typeParams);
   auto arrayTy = fir::SequenceType::get(shape, eleTy);
   mlir::Value array = outlineInReadOnlyMemory
-                          ? genOutlineArrayLit(builder, loc, arrayTy, con)
-                          : genInlinedArrayLit(builder, loc, arrayTy, con);
+                          ? genOutlineArrayLit(converter, loc, arrayTy, con)
+                          : genInlinedArrayLit(converter, loc, arrayTy, con);
 
   mlir::IndexType idxTy = builder.getIndexType();
   llvm::SmallVector<mlir::Value> extents;
   for (auto extent : shape)
     extents.push_back(builder.createIntegerConstant(loc, idxTy, extent));
   // Convert  lower bounds if they are not all ones.
   llvm::SmallVector<mlir::Value> lbounds;
   if (llvm::any_of(con.lbounds(), [](auto lb) { return lb != 1; }))
     for (auto lb : con.lbounds())
       lbounds.push_back(builder.createIntegerConstant(loc, idxTy, lb));
 
-  if constexpr (TC == Fortran::common::TypeCategory::Character) {
+  if constexpr (T::category == Fortran::common::TypeCategory::Character) {
     mlir::Value len = builder.createIntegerConstant(loc, idxTy, con.LEN());
     return fir::CharArrayBoxValue{array, len, extents, lbounds};
   } else {
     return fir::ArrayBoxValue{array, extents, lbounds};
   }
 }
 
-template <Fortran::common::TypeCategory TC, int KIND>
-fir::ExtendedValue
-Fortran::lower::ConstantBuilder<Fortran::evaluate::Type<TC, KIND>>::gen(
-    fir::FirOpBuilder &builder, mlir::Location loc,
-    const Fortran::evaluate::Constant<Fortran::evaluate::Type<TC, KIND>>
-        &constant,
+template <typename T>
+fir::ExtendedValue Fortran::lower::ConstantBuilder<T>::gen(
+    Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+    const Fortran::evaluate::Constant<T> &constant,
     bool outlineBigConstantsInReadOnlyMemory) {
   if (constant.Rank() > 0)
-    return genArrayLit<TC, KIND>(builder, loc, constant,
-                                 outlineBigConstantsInReadOnlyMemory);
-  std::optional<Fortran::evaluate::Scalar<Fortran::evaluate::Type<TC, KIND>>>
-      opt = constant.GetScalarValue();
+    return genArrayLit(converter, loc, constant,
+  std::optional<Fortran::evaluate::Scalar<T>> opt = constant.GetScalarValue();
   assert(opt.has_value() && "constant has no value");
-  if constexpr (TC == Fortran::common::TypeCategory::Character) {
-    auto value = genScalarLit<KIND>(builder, loc, opt.value(), constant.LEN(),
-                                    outlineBigConstantsInReadOnlyMemory);
+  if constexpr (T::category == Fortran::common::TypeCategory::Character) {
+    fir::FirOpBuilder &builder = converter.getFirOpBuilder();
+    auto value =
+        genScalarLit<T::kind>(builder, loc, opt.value(), constant.LEN(),
     mlir::Value len = builder.createIntegerConstant(
         loc, builder.getCharacterLengthType(), constant.LEN());
     return fir::CharBoxValue{value, len};
+  } else if constexpr (T::category == Fortran::common::TypeCategory::Derived) {
+    mlir::Type eleTy = Fortran::lower::translateDerivedTypeToFIRType(
+        converter, opt->GetType().GetDerivedTypeSpec());
+    return genScalarLit(converter, loc, *opt, eleTy,
+                        outlineBigConstantsInReadOnlyMemory);
   } else {
-    return genScalarLit<TC, KIND>(builder, loc, opt.value());
-  }
+    return genScalarLit<T::category, T::kind>(converter.getFirOpBuilder(), loc,
+                                              opt.value());
+  }
+}
+
+static fir::ExtendedValue
+genConstantValue(Fortran::lower::AbstractConverter &converter,
+                 mlir::Location loc,
+                 const Fortran::evaluate::Expr<Fortran::evaluate::SomeDerived>
+                     &constantExpr) {
+  if (const auto *constant = std::get_if<
+          Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived>>(
+          &constantExpr.u))
+    return Fortran::lower::convertConstant(converter, loc, *constant,
+                                           /*outline=*/false);
+  if (const auto *structCtor =
+          std::get_if<Fortran::evaluate::StructureConstructor>(&constantExpr.u))
+    return Fortran::lower::genInlinedStructureCtorLit(converter, loc,
+                                                      *structCtor);
+  fir::emitFatalError(loc, "not a constant derived type expression");
+
+template <Fortran::common::TypeCategory TC, int KIND>
+static fir::ExtendedValue genConstantValue(
+    Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+    const Fortran::evaluate::Expr<Fortran::evaluate::Type<TC, KIND>>
+        &constantExpr) {
+  using T = Fortran::evaluate::Type<TC, KIND>;
+  if (const auto *constant =
+          std::get_if<Fortran::evaluate::Constant<T>>(&constantExpr.u))
+    return Fortran::lower::convertConstant(converter, loc, *constant,
+                                           /*outline=*/false);
+  fir::emitFatalError(loc, "not an evaluate::Constant<T>");
+}
+
+static fir::ExtendedValue
+genConstantValue(Fortran::lower::AbstractConverter &converter,
+                 mlir::Location loc,
+                 const Fortran::lower::SomeExpr &constantExpr) {
+  return std::visit(
+      [&](const auto &x) -> fir::ExtendedValue {
+        using T = std::decay_t<decltype(x)>;
+        if constexpr (Fortran::common::HasMember<
+                          T, Fortran::lower::CategoryExpression>) {
+          if constexpr (T::Result::category ==
+                        Fortran::common::TypeCategory::Derived) {
+            return genConstantValue(converter, loc, x);
+          } else {
+            return std::visit(
+                [&](const auto &preciseKind) {
+                  return genConstantValue(converter, loc, preciseKind);
+                },
+                x.u);
+          }
+        } else {
+          fir::emitFatalError(loc, "unexpected typeless constant value");
+        }
+      },
+      constantExpr.u);
+}
+
+fir::ExtendedValue Fortran::lower::genInlinedStructureCtorLit(
+    Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+    const Fortran::evaluate::StructureConstructor &ctor) {
+  mlir::Type type = Fortran::lower::translateDerivedTypeToFIRType(
+      converter, ctor.derivedTypeSpec());
+  return genInlinedStructureCtorLitImpl(converter, loc, ctor, type);
 }
 
 using namespace Fortran::evaluate;
-FOR_EACH_INTRINSIC_KIND(template class Fortran::lower::ConstantBuilder, )
+FOR_EACH_SPECIFIC_TYPE(template class Fortran::lower::ConstantBuilder, )

flang/lib/Lower/ConvertExpr.cpp

public:
   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;
   }
 
-  /// Lower structure constructor without a temporary. This can be used in
-  /// fir::GloablOp, and assumes that the structure component is a constant.
-  ExtValue genStructComponentInInitializer(
-      const Fortran::evaluate::StructureConstructor &ctor) {
-    mlir::Location loc = getLoc();
-    mlir::Type ty = translateSomeExprToFIRType(converter, toEvExpr(ctor));
-    auto recTy = ty.cast<fir::RecordType>();
-    auto fieldTy = fir::FieldType::get(ty.getContext());
-    mlir::Value res = builder.create<fir::UndefOp>(loc, recTy);
-
-    for (const auto &[sym, expr] : ctor.values()) {
-      // 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");
-
-      llvm::StringRef name = toStringRef(sym->name());
-      mlir::Type componentTy = recTy.getType(name);
-      // FIXME: type parameters must come from the derived-type-spec
-      auto field = builder.create<fir::FieldIndexOp>(
-          loc, fieldTy, name, ty,
-          /*typeParams=*/mlir::ValueRange{} /*TODO*/);
-
-      if (Fortran::semantics::IsAllocatable(sym))
-        TODO(loc, "allocatable component in structure constructor");
-
-      if (Fortran::semantics::IsPointer(sym)) {
-        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 (isDerivedTypeWithLenParameters(sym))
-        TODO(loc, "component with length parameters in structure constructor");
-
-      if (Fortran::semantics::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) {
-          // Do nothing. The Ev::Expr was returned as a value that can be
-          // inserted directly to the component without an intermediary.
-        } else {
-          // The Ev::Expr returned is an initializer that is a pointer (e.g.,
-          // null) that must be inserted into an intermediate cptr record
-          // value's address field, which ought to be an intptr_t on the target.
-          assert((fir::isa_ref_type(addr.getType()) ||
-                  addr.getType().isa<mlir::FunctionType>()) &&
-                 "expect reference type for address field");
-          assert(fir::isa_derived(componentTy) &&
-                 "expect C_PTR, C_FUNPTR to be a record");
-          auto cPtrRecTy = componentTy.cast<fir::RecordType>();
-          llvm::StringRef addrFieldName =
-              Fortran::lower::builtin::cptrFieldName;
-          mlir::Type addrFieldTy = cPtrRecTy.getType(addrFieldName);
-          auto addrField = builder.create<fir::FieldIndexOp>(
-              loc, fieldTy, addrFieldName, componentTy,
-              /*typeParams=*/mlir::ValueRange{});
-          mlir::Value castAddr = builder.createConvert(loc, addrFieldTy, addr);
-          auto undef = builder.create<fir::UndefOp>(loc, componentTy);
-          addr = builder.create<fir::InsertValueOp>(
-              loc, componentTy, undef, castAddr,
-              builder.getArrayAttr(addrField.getAttributes()));
-        }
-        res = builder.create<fir::InsertValueOp>(
-            loc, recTy, res, addr, builder.getArrayAttr(field.getAttributes()));
-        continue;
-      }
-
-      mlir::Value val = fir::getBase(genval(expr.value()));
-      assert(!fir::isa_ref_type(val.getType()) && "expecting a constant value");
-      mlir::Value castVal = builder.createConvert(loc, componentTy, val);
-      res = builder.create<fir::InsertValueOp>(
-          loc, recTy, res, castVal,
-          builder.getArrayAttr(field.getAttributes()));
-    }
-    return res;
-  }
-
   /// A structure constructor is lowered two ways. In an initializer context,
   /// the entire structure must be constant, so the aggregate value is
   /// constructed inline. This allows it to be the body of a GlobalOp.
   /// Otherwise, the structure constructor is in an expression. In that case, a
   /// temporary object is constructed in the stack frame of the procedure.
   ExtValue genval(const Fortran::evaluate::StructureConstructor &ctor) {
-    if (inInitializer)
-      return genStructComponentInInitializer(ctor);
     mlir::Location loc = getLoc();
+    if (inInitializer)
+      return Fortran::lower::genInlinedStructureCtorLit(converter, loc, ctor);
     mlir::Type ty = translateSomeExprToFIRType(converter, toEvExpr(ctor));
     auto recTy = ty.cast<fir::RecordType>();
     auto fieldTy = fir::FieldType::get(ty.getContext());
     mlir::Value res = builder.createTemporary(loc, recTy);
     mlir::Value box = builder.createBox(loc, fir::ExtendedValue{res});
     fir::runtime::genDerivedTypeInitialize(builder, loc, box);
 
     for (const auto &value : ctor.values()) {
case Fortran::evaluate::LogicalOperator::Neqv:
           mlir::arith::CmpIPredicate::ne, lhs, rhs);
     case Fortran::evaluate::LogicalOperator::Not:
       // lib/evaluate expression for .NOT. is Fortran::evaluate::Not<KIND>.
       llvm_unreachable(".NOT. is not a binary operator");
     }
     llvm_unreachable("unhandled logical operation");
   }
 
-  fir::ExtendedValue genArrayLit(
-      const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &con) {
-    mlir::Location loc = getLoc();
-    mlir::IndexType idxTy = builder.getIndexType();
-    Fortran::evaluate::ConstantSubscript size =
-        Fortran::evaluate::GetSize(con.shape());
-    fir::SequenceType::Shape shape(con.shape().begin(), con.shape().end());
-    mlir::Type eleTy = converter.genType(con.GetType().GetDerivedTypeSpec());
-    auto arrayTy = fir::SequenceType::get(shape, eleTy);
-    mlir::Value array = builder.create<fir::UndefOp>(loc, arrayTy);
-    llvm::SmallVector<mlir::Value> lbounds;
-    llvm::SmallVector<mlir::Value> extents;
-    for (auto [lb, extent] : llvm::zip(con.lbounds(), con.shape())) {
-      lbounds.push_back(builder.createIntegerConstant(loc, idxTy, lb - 1));
-      extents.push_back(builder.createIntegerConstant(loc, idxTy, extent));
-    }
-    if (size == 0)
-      return fir::ArrayBoxValue{array, extents, lbounds};
-    Fortran::evaluate::ConstantSubscripts subscripts = con.lbounds();
-    do {
-      mlir::Value derivedVal = fir::getBase(genval(con.At(subscripts)));
-      llvm::SmallVector<mlir::Attribute> idx;
-      for (auto [dim, lb] : llvm::zip(subscripts, con.lbounds()))
-        idx.push_back(builder.getIntegerAttr(idxTy, dim - lb));
-      array = builder.create<fir::InsertValueOp>(
-          loc, arrayTy, array, derivedVal, builder.getArrayAttr(idx));
-    } while (con.IncrementSubscripts(subscripts));
-    return fir::ArrayBoxValue{array, extents, lbounds};
-  }
-
   template <Fortran::common::TypeCategory TC, int KIND>
   ExtValue
   genval(const Fortran::evaluate::Constant<Fortran::evaluate::Type<TC, KIND>>
              &con) {
-    return Fortran::lower::IntrinsicConstantBuilder<TC, KIND>::gen(
-        builder, getLoc(), con,
+    return Fortran::lower::convertConstant(
+        converter, getLoc(), con,
         /*outlineBigConstantsInReadOnlyMemory=*/!inInitializer);
   }
 
   fir::ExtendedValue genval(
       const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &con) {
-    if (con.Rank() > 0)
-      return genArrayLit(con);
     if (auto ctor = con.GetScalarValue())
       return genval(*ctor);
-    fir::emitFatalError(getLoc(),
-                        "constant of derived type has no constructor");
+    return Fortran::lower::convertConstant(
+        converter, getLoc(), con,
+        /*outlineBigConstantsInReadOnlyMemory=*/false);
   }
 
   template <typename A>
   ExtValue genval(const Fortran::evaluate::ArrayConstructor<A> &) {
     fir::emitFatalError(getLoc(), "array constructor: should not reach here");
   }
 
   ExtValue gen(const Fortran::evaluate::ComplexPart &x) {
fir::CharBoxValue temp =
                 rhs);
     return [=](IterSpace iters) -> ExtValue {
       fir::factory::CharacterExprHelper(builder, getLoc())
           .createAssign(temp, lf(iters));
       return temp;
     };
   }
 
-  template <Fortran::common::TypeCategory TC, int KIND>
-  CC genarr(
-      const Fortran::evaluate::Constant<Fortran::evaluate::Type<TC, KIND>> &x) {
+  template <typename T>
+  CC genarr(const Fortran::evaluate::Constant<T> &x) {
     if (x.Rank() == 0)
       return genScalarAndForwardValue(x);
-    return genarr(Fortran::lower::IntrinsicConstantBuilder<TC, KIND>::gen(
-        builder, getLoc(), x,
+    return genarr(Fortran::lower::convertConstant(
+        converter, getLoc(), x,
         /*outlineBigConstantsInReadOnlyMemory=*/true));
   }
 
-  CC genarr(
-      const Fortran::evaluate::Constant<Fortran::evaluate::SomeDerived> &x) {
-    if (x.Rank() == 0)
-      return genScalarAndForwardValue(x);
-    mlir::Location loc = getLoc();
-    mlir::IndexType idxTy = builder.getIndexType();
-    mlir::Type arrTy = converter.genType(toEvExpr(x));
-    std::string globalName = Fortran::lower::mangle::mangleArrayLiteral(x);
-    fir::GlobalOp global = builder.getNamedGlobal(globalName);
-    if (!global) {
-      global = builder.createGlobalConstant(
-          loc, arrTy, globalName,
-          [&](fir::FirOpBuilder &builder) {
-            Fortran::lower::StatementContext stmtCtx(
-                /*cleanupProhibited=*/true);
-            fir::ExtendedValue result =
-                Fortran::lower::createSomeInitializerExpression(
-                    loc, converter, toEvExpr(x), symMap, stmtCtx);
-            mlir::Value castTo =
-                builder.createConvert(loc, arrTy, fir::getBase(result));
-            builder.create<fir::HasValueOp>(loc, castTo);
-          },
-          builder.createInternalLinkage());
-    }
-    auto addr = builder.create<fir::AddrOfOp>(getLoc(), global.resultType(),
-                                              global.getSymbol());
-    auto seqTy = global.getType().cast<fir::SequenceType>();
-    llvm::SmallVector<mlir::Value> extents;
-    for (auto extent : seqTy.getShape())
-      extents.push_back(builder.createIntegerConstant(loc, idxTy, extent));
-    if (auto charTy = seqTy.getEleTy().dyn_cast<fir::CharacterType>()) {
-      mlir::Value len = builder.createIntegerConstant(loc, builder.getI64Type(),
-                                                      charTy.getLen());
-      return genarr(fir::CharArrayBoxValue{addr, len, extents});
-    }
-    return genarr(fir::ArrayBoxValue{addr, extents});
-  }
-
   //===--------------------------------------------------------------------===//
   // A vector subscript expression may be wrapped with a cast to INTEGER*8.
   // Get rid of it here so the vector can be loaded. Add it back when
   // generating the elemental evaluation (inside the loop nest).
 
   static Fortran::lower::SomeExpr
   ignoreEvConvert(const Fortran::evaluate::Expr<Fortran::evaluate::Type<
                       Fortran::common::TypeCategory::Integer, 8>> &x) {

flang/lib/Lower/ConvertExprToHLFIR.cpp

auto result = Fortran::lower::convertCallToHLFIR(
         getLoc(), getConverter(), expr, resType, getSymMap(), getStmtCtx());
     assert(result.has_value());
     return *result;
   }
 
   template <typename T>
   hlfir::EntityWithAttributes gen(const Fortran::evaluate::Constant<T> &expr) {
     mlir::Location loc = getLoc();
-    if constexpr (std::is_same_v<T, Fortran::evaluate::SomeDerived>) {
-      TODO(loc, "lowering derived type constant to HLFIR");
-    } else {
-      fir::FirOpBuilder &builder = getBuilder();
-      fir::ExtendedValue exv =
-          Fortran::lower::IntrinsicConstantBuilder<T::category, T::kind>::gen(
-              builder, loc, expr, /*outlineBigConstantInReadOnlyMemory=*/true);
-      if (const auto *scalarBox = exv.getUnboxed())
-        if (fir::isa_trivial(scalarBox->getType()))
-          return hlfir::EntityWithAttributes(*scalarBox);
-      if (auto addressOf = fir::getBase(exv).getDefiningOp<fir::AddrOfOp>()) {
-        auto flags = fir::FortranVariableFlagsAttr::get(
-            builder.getContext(), fir::FortranVariableFlagsEnum::parameter);
-        return hlfir::genDeclare(
-            loc, builder, exv,
-            addressOf.getSymbol().getRootReference().getValue(), flags);
-      }
-      fir::emitFatalError(loc, "Constant<T> was lowered to unexpected format");
-    }
-  }
+    fir::ExtendedValue exv = Fortran::lower::convertConstant(
+        converter, loc, expr, /*outlineBigConstantInReadOnlyMemory=*/true);
 
   template <typename T>
   hlfir::EntityWithAttributes
   gen(const Fortran::evaluate::ArrayConstructor<T> &expr) {
     TODO(getLoc(), "lowering ArrayCtor to HLFIR");
   }
 
   template <typename D, typename R, typename O>

flang/lib/Lower/ConvertType.cpp

mlir::Type Fortran::lower::translateVariableToFIRType(
     const Fortran::lower::pft::Variable &var) {
   return TypeBuilderImpl{converter}.genVariableType(var);
 }
 
 mlir::Type Fortran::lower::convertReal(mlir::MLIRContext *context, int kind) {
   return genRealType(context, kind);
 }
 
+bool Fortran::lower::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;
+}
+
 template <typename T>
 mlir::Type Fortran::lower::TypeBuilder<T>::genType(
     Fortran::lower::AbstractConverter &converter,
     const Fortran::evaluate::FunctionRef<T> &funcRef) {
   return TypeBuilderImpl{converter}.genExprType(funcRef);
 }
 
 using namespace Fortran::evaluate;
 using namespace Fortran::common;
 FOR_EACH_SPECIFIC_TYPE(template class Fortran::lower::TypeBuilder, )

flang/lib/Lower/ConvertVariable.cpp

static mlir::Type unwrapElementType(mlir::Type type) {
   if (auto seqType = type.dyn_cast<fir::SequenceType>())
     type = seqType.getEleTy();
   return type;
 }
 
 fir::ExtendedValue Fortran::lower::genExtAddrInInitializer(
     Fortran::lower::AbstractConverter &converter, mlir::Location loc,
     const Fortran::lower::SomeExpr &addr) {
+  if (converter.getLoweringOptions().getLowerToHighLevelFIR())
+    TODO(loc, "generate initializer address in HLFIR");
   Fortran::lower::SymMap globalOpSymMap;
   Fortran::lower::AggregateStoreMap storeMap;
   Fortran::lower::StatementContext stmtCtx;
   if (const Fortran::semantics::Symbol *sym =
           Fortran::evaluate::GetFirstSymbol(addr)) {
     // 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);
     Fortran::lower::instantiateVariable(converter, var, globalOpSymMap,
                                         storeMap);
   }
   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,
     bool couldBeInEquivalence) {
+  if (converter.getLoweringOptions().getLowerToHighLevelFIR())
+    TODO(loc, "initial data target in HLFIR");
   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,

flang/lib/Lower/Mangler.cpp

std::string Fortran::lower::mangle::demangleName(llvm::StringRef name) {
   auto result = fir::NameUniquer::deconstruct(name);
   return result.second.name;
 }
 
 //===----------------------------------------------------------------------===//
 // Array Literals Mangling
 //===----------------------------------------------------------------------===//
 
-static std::string typeToString(Fortran::common::TypeCategory cat, int kind) {
+static std::string typeToString(Fortran::common::TypeCategory cat, int kind,
+                                llvm::StringRef derivedName) {
   switch (cat) {
   case Fortran::common::TypeCategory::Integer:
     return "i" + std::to_string(kind);
   case Fortran::common::TypeCategory::Real:
     return "r" + std::to_string(kind);
   case Fortran::common::TypeCategory::Complex:
     return "z" + std::to_string(kind);
   case Fortran::common::TypeCategory::Logical:
     return "l" + std::to_string(kind);
   case Fortran::common::TypeCategory::Character:
     return "c" + std::to_string(kind);
   case Fortran::common::TypeCategory::Derived:
-    // FIXME: Replace "DT" with the (fully qualified) type name.
-    return "dt.DT";
+    return derivedName.str();
   }
   llvm_unreachable("bad TypeCategory");
 }
 
 std::string Fortran::lower::mangle::mangleArrayLiteral(
     const uint8_t *addr, size_t size,
     const Fortran::evaluate::ConstantSubscripts &shape,
     Fortran::common::TypeCategory cat, int kind,
-    Fortran::common::ConstantSubscript charLen) {
+    Fortran::common::ConstantSubscript charLen, llvm::StringRef derivedName) {
   std::string typeId;
   for (Fortran::evaluate::ConstantSubscript extent : shape)
     typeId.append(std::to_string(extent)).append("x");
   if (charLen >= 0)
     typeId.append(std::to_string(charLen)).append("x");
-  typeId.append(typeToString(cat, kind));
+  typeId.append(typeToString(cat, kind, derivedName));
   std::string name =
       fir::NameUniquer::doGenerated("ro."s.append(typeId).append("."));
   if (!size)
     return name += "null";
   llvm::MD5 hashValue{};
   hashValue.update(llvm::ArrayRef<uint8_t>{addr, size});
   llvm::MD5::MD5Result hashResult;
   hashValue.final(hashResult);

flang/test/Lower/HLFIR/constant-derived.f90

+! Test lowering of Constant<SomeDerived>.
+! TODO: remove "-I nowhere" once derived type descriptor can be lowered.
+! RUN: bbc -hlfir -emit-fir -o - -I nowhere %s 2>&1 | FileCheck %s
+
+subroutine test_constant_scalar()
+  type myderived
+    integer :: i
+    integer :: j = 42
+    real :: x(2)
+    character(10) :: c
+  end type
+  print *, myderived(i=1, x=[2.,3.], c="hello")
+! CHECK-LABEL: func.func @_QPtest_constant_scalar() {
+! CHECK:  fir.address_of(@[[CST:_QQro._QFtest_constant_scalarTmyderived..*]])
+end subroutine
+
+! CHECK: fir.global internal @[[CST]] constant : !fir.type<[[DERIVED:_QFtest_constant_scalarTmyderived{i:i32,j:i32,x:!fir.array<2xf32>,c:!fir.char<1,10>}]]> {
+! CHECK:   %[[VAL_0:.*]] = fir.undefined !fir.type<[[DERIVED]]>
+! CHECK:   %[[VAL_1:.*]] = fir.field_index i, !fir.type<[[DERIVED]]>
+! CHECK:   %[[VAL_2:.*]] = arith.constant 1 : i32
+! CHECK:   %[[VAL_3:.*]] = fir.insert_value %[[VAL_0]], %[[VAL_2]], ["i", !fir.type<[[DERIVED]]>] : (!fir.type<[[DERIVED]]>, i32) -> !fir.type<[[DERIVED]]>
+! CHECK:   %[[VAL_4:.*]] = fir.field_index j, !fir.type<[[DERIVED]]>
+! CHECK:   %[[VAL_5:.*]] = arith.constant 42 : i32
+! CHECK:   %[[VAL_6:.*]] = fir.insert_value %[[VAL_3]], %[[VAL_5]], ["j", !fir.type<[[DERIVED]]>] : (!fir.type<[[DERIVED]]>, i32) -> !fir.type<[[DERIVED]]>
+! CHECK:   %[[VAL_7:.*]] = fir.field_index x, !fir.type<[[DERIVED]]>
+! CHECK:   %[[VAL_8:.*]] = fir.undefined !fir.array<2xf32>
+! CHECK:   %[[VAL_9:.*]] = arith.constant 2.000000e+00 : f32
+! CHECK:   %[[VAL_10:.*]] = fir.insert_value %[[VAL_8]], %[[VAL_9]], [0 : index] : (!fir.array<2xf32>, f32) -> !fir.array<2xf32>
+! CHECK:   %[[VAL_11:.*]] = arith.constant 3.000000e+00 : f32
+! CHECK:   %[[VAL_12:.*]] = fir.insert_value %[[VAL_10]], %[[VAL_11]], [1 : index] : (!fir.array<2xf32>, f32) -> !fir.array<2xf32>
+! CHECK:   %[[VAL_13:.*]] = arith.constant 2 : index
+! CHECK:   %[[VAL_14:.*]] = fir.insert_value %[[VAL_6]], %[[VAL_12]], ["x", !fir.type<[[DERIVED]]>] : (!fir.type<[[DERIVED]]>, !fir.array<2xf32>) -> !fir.type<[[DERIVED]]>
+! CHECK:   %[[VAL_15:.*]] = fir.field_index c, !fir.type<[[DERIVED]]>
+! CHECK:   %[[VAL_16:.*]] = fir.string_lit "hello     "(10) : !fir.char<1,10>
+! CHECK:   %[[VAL_17:.*]] = arith.constant 10 : index
+! CHECK:   %[[VAL_18:.*]] = fir.insert_value %[[VAL_14]], %[[VAL_16]], ["c", !fir.type<[[DERIVED]]>] : (!fir.type<[[DERIVED]]>, !fir.char<1,10>) -> !fir.type<[[DERIVED]]>
+! CHECK:   fir.has_value %[[VAL_18]] : !fir.type<[[DERIVED]]>
+! CHECK: }

flang/test/Lower/constant-literal-mangling.f90

+! Test the names created for globals holding constant literal values
+! RUN: bbc -emit-fir -o - %s | FileCheck %s
+
+type someType
+  integer :: i
+end type
+
+  print *, [42, 42]
+! CHECK: fir.address_of(@_QQro.2xi4.53fa91e04725d4ee6f22cf1e2d38428a)
+
+  print *, reshape([42, 42, 42, 42, 42, 42], [2,3])
+! CHECK: fir.address_of(@_QQro.2x3xi4.9af8c8182bab45c4e7888ec3623db3b6)
+
+  print *, [42_8, 42_8]
+! CHECK: fir.address_of(@_QQro.2xi8.3b1356831516d19b976038974b2673ac)
+
+  print *, [0.42, 0.42]
+! CHECK: fir.address_of(@_QQro.2xr4.3c5becae2e4426ad1615e253139ceff8)
+
+  print *, [0.42_8, 0.42_8]
+! CHECK: fir.address_of(@_QQro.2xr8.ebefec8f7537fbf54acc4530e75084e6)
+
+  print *, [.true.]
+! CHECK: fir.address_of(@_QQro.1xl4.4352d88a78aa39750bf70cd6f27bcaa5)
+
+  print *, [.true._8]
+! CHECK: fir.address_of(@_QQro.1xl8.33cdeccccebe80329f1fdbee7f5874cb)
+
+  print *, [(1., -1.), (-1., 1)]
+! CHECK: fir.address_of(@_QQro.2xz4.ac09ecb1abceb4f9cad4b1a50000074e)
+
+  print *, [(1._8, -1._8), (-1._8, 1._8)]
+! CHECK: fir.address_of(@_QQro.2xz8.a3652db37055e37d2cae8198ae4cd959)
+
+  print *, [someType(42), someType(43)]
+! CHECK: fir.address_of(@_QQro.2x_QFTsometype.
+! Note: the hash for derived types cannot clash with other constant in the same
+! compilation unit, but is unstable because it hashes some noise contained in
+! unused std::vector storage.
+end