[fir] Add fir.extract_value and fir.insert_value conversion

[clementval]

Summary

This patch add the conversion pattern for fir.extract_value
and fir.insert_value. fir.extract_value is lowered to llvm.extractvalue
anf fir.insert_value is lowered to llvm.insertvalue.
This patch also adds the type conversion for the BoxType and RecordType
needed to have some comprehensive tests.

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

[awarzynski]

Overall makes sense to me. I would love to see less auto - in quite a few places it replaces simple types like mlir::Type. I'm rather unfamiliar with this code-base (and MLIR) and it is easier for me to follow the logic when I see the actual type. Especially when translating between dialects (so moving from one namespace to some other namespace).

flang/lib/Optimizer/CodeGen/DescriptorModel.h

21–34

Could comments that apply to a whole file be moved to the top? Like here: https://github.com/llvm/llvm-project/blob/main/mlir/include/mlir/IR/AffineExpr.h#L7-L12

On a separate note - the TODO suggests that --target is unlikely to work correctly. I think that it would help to have this mentioned somewhere, e.g. in https://github.com/llvm/llvm-project/blob/main/flang/docs/RuntimeDescriptor.md. I know that that's not really part of up-streaming, but it might really limit our options in terms of testing.

116

120

The spec for F2018 (18.5.3) lists only 7 fields. Also, nothing is really checked here, is it? The comment probably needs updating.

flang/lib/Optimizer/CodeGen/TypeConverter.h

66

Why wrap this in a method as opposed to having a constant?

66–67

71

Isn't this just CFI_cdesc_t? I'm just confused by parts here.

144

Shouldn't the result be checked instead?

flang/test/Fir/convert-to-llvm.fir

117

134

Missing llvm.return? (for consistency with other tests)

153

Missing llvm.return? (for consistency with other tests)

166

Missing llvm.return? (for consistency with other tests)

[clementval]

Address review comment

[clementval]

flang/lib/Optimizer/CodeGen/DescriptorModel.h

21–34

As the todo mentioned, this will need some work to be done right. This will probably need someone to dig deeper into that.

120

This is actually a compile time check. if you remove on element or add one your build will fail. I don't think we are at F2018 yet.

flang/lib/Optimizer/CodeGen/TypeConverter.h

66

Since it's constexpr does it really matter?

71

There is more than just the 8 fields of the CFI_cdesc_t so it isn't really it so I guess parts or other name could work as well.

[mehdi_amini]

flang/lib/Optimizer/CodeGen/TypeConverter.h

193

That makes it a global mutable map, that seems unsafe to me in general.

Here it seems even worse: this is never re-initialized and so it creates coupling between the lifetime of a Context (and even a module) and the entire process. Am I missing something?

[clementval]

Review old map cache

[clementval]

flang/lib/Optimizer/CodeGen/TypeConverter.h

193

I believe we can get rid of this entirely since LLVMStructType::getIdentified is doing the caching here already. Probably an old artifact when it was not working as expected.
Thanks for pointing this out.

[clementval]

Rebase after couple of other conversion patches have landed

[mehdi_amini]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

230–235

(this is the canonical/generic way of handling constants)

237

Function isn't used?

flang/lib/Optimizer/CodeGen/TypeConverter.h

143

Is all the code related to the box type conversion coupled to the rest of this patch? I don't see where it is tested and it seems that the tests for fir.extract_value and fir.insert_value lowering aren't involving the box type?

[clementval]

Cleanup code after review comments

[clementval]

Rebase

flang/lib/Optimizer/CodeGen/CodeGen.cpp

237

Not needed anymore. Removed for now.

flang/lib/Optimizer/CodeGen/TypeConverter.h

143

It was in my plan to bring !fir.box conversion along in this patch but in order to test it well it requires to bring along some other code. It's better to do this in another revision focused on that. Remove the code in this patch for now.

[awarzynski]

flang/lib/Optimizer/CodeGen/DescriptorModel.h

21–34

Yup, that's fine, but I would really appreciate a note on that that can be found outside the code itself. And, that can be referred inside the code whenever such assumptions are made.

I've created https://llvm.org/PR52418 for this reason. Would you mind adding a link?

120

I don't think we are at F2018 yet.

No, but this comes from the Fortran_2018 namespace, that's why I referred to the 2018 spec. This is all fine to, but 8 is a magic number here. Why do we check for 8 rather than 7 or 13 fields? Could add any sort of hint that would demystify this magic number?

flang/lib/Optimizer/CodeGen/TypeConverter.h

52

How about a test in "types-to-llvm.fir" for this conversion?

[clementval]

Add comments

flang/lib/Optimizer/CodeGen/TypeConverter.h

52

Type conversion is checked alongside op conversions.

[awarzynski]

Thank you for working on this and addressing my comments! LGTM

[clementval]

Rebase

[Meinersbur]

flang/lib/Optimizer/CodeGen/DescriptorModel.h

91

This breaks the windows build:

C:\Users\buildbot-worker\minipc-ryzen-win\flang-x86_64-windows\llvm-project\flang\lib\Optimizer\CodeGen\DescriptorModel.h(95): error C2766: explicit specialization; 'fir::TypeBuilderFunc (__cdecl *fir::getModel<__int64>(void))(mlir::MLIRContext *)' has already been defined
C:\Users\buildbot-worker\minipc-ryzen-win\flang-x86_64-windows\llvm-project\flang\lib\Optimizer\CodeGen\DescriptorModel.h(70): note: see previous definition of 'getModel'

CFI_index_t is a typedef of ptrdiff_t which is a 64 bit signed integer. That is, the same as getModel<long long> template specialization. Don't know why it works under Linux or why the Windows pre-merge check didn't run.

[clementval]

flang/lib/Optimizer/CodeGen/DescriptorModel.h

91

https://github.com/llvm/llvm-project/commit/d75ab7d548c020f37ed3391a0002b206336fe46e should fix the buildbot for the time being.

[Meinersbur]

flang/lib/Optimizer/CodeGen/DescriptorModel.h

91

Thanks, it successfully fixed the build: https://lab.llvm.org/buildbot/#/builders/172/builds/5311

[clementval]

flang/lib/Optimizer/CodeGen/DescriptorModel.h

91

@Meinersbur Removing this is actually making all other buildbots to fail. I reverted this patch until we can figure out what's happening.

[Meinersbur]

flang/lib/Optimizer/CodeGen/DescriptorModel.h

91

Which one failed? I cannot find one at e.g. https://lab.llvm.org/buildbot/#/builders/175

By LLVM policy, this should have been mentioned in the reverting commit.

[mehdi_amini]

flang/lib/Optimizer/CodeGen/DescriptorModel.h

91

On Linux ptrdiff is long : https://godbolt.org/z/fdacb8f7v

What if you replace this specialization with a specialization for long instead? This seems to be the one missing?

[Meinersbur]

flang/lib/Optimizer/CodeGen/DescriptorModel.h

91

Sounds right. In LLP64 (msvc), long is 32 bits, i.e. ptrdiff_tx could not be long. long is the only missing specialization for getModel (ignoring types smaller than int: short, char)

[awarzynski]

As a side note, I think that you can re-submit this patch without getExtendedDescFieldTypeModel, getDescFieldTypeModel and getModel methods. You can include them in https://reviews.llvm.org/D113288. IIUC.

flang/lib/Optimizer/CodeGen/CodeGen.cpp

if (ty.isa<mlir::LLVM::LLVMPointerType>()) {
       return rewriter.notifyMatchFailure(
           zero,
           "conversion of fir.zero with aggregate type not implemented yet");
     }
     return success();
   }
 };
 
+// Code shared between insert_value and extract_value Ops.
+struct ValueOpCommon {
+  static mlir::Attribute getValue(mlir::Value value) {
+    auto *defOp = value.getDefiningOp();
+    if (auto v = dyn_cast<mlir::LLVM::ConstantOp>(defOp))
+      return v.value();
+    if (auto v = dyn_cast<mlir::arith::ConstantOp>(defOp))
+      return v.value();
+    llvm_unreachable("must be a constant op");
+    return {};
+  }
+
+  // Translate the arguments pertaining to any multidimensional array to
+  // row-major order for LLVM-IR.
+  static void toRowMajor(SmallVectorImpl<mlir::Attribute> &attrs,
+                         mlir::Type ty) {
+    assert(ty && "type is null");
+    const auto end = attrs.size();
+    for (std::remove_const_t<decltype(end)> i = 0; i < end; ++i) {
+      if (auto seq = ty.dyn_cast<mlir::LLVM::LLVMArrayType>()) {
+        const auto dim = getDimension(seq);
+        if (dim > 1) {
+          auto ub = std::min(i + dim, end);
+          std::reverse(attrs.begin() + i, attrs.begin() + ub);
+          i += dim - 1;
+        }
+        ty = getArrayElementType(seq);
+      } else if (auto st = ty.dyn_cast<mlir::LLVM::LLVMStructType>()) {
+        ty = st.getBody()[attrs[i].cast<mlir::IntegerAttr>().getInt()];
+      } else {
+        llvm_unreachable("index into invalid type");
+      }
+    }
+  }
+
+  static llvm::SmallVector<mlir::Attribute>
+  collectIndices(mlir::ConversionPatternRewriter &rewriter,
+                 mlir::ArrayAttr arrAttr) {
+    llvm::SmallVector<mlir::Attribute> attrs;
+    for (auto i = arrAttr.begin(), e = arrAttr.end(); i != e; ++i) {
+      if (i->isa<mlir::IntegerAttr>()) {
+        attrs.push_back(*i);
+      } else {
+        auto fieldName = i->cast<mlir::StringAttr>().getValue();
+        ++i;
+        auto ty = i->cast<mlir::TypeAttr>().getValue();
+        auto index = ty.cast<fir::RecordType>().getFieldIndex(fieldName);
+        attrs.push_back(mlir::IntegerAttr::get(rewriter.getI32Type(), index));
+      }
+    }
+    return attrs;
+  }
+
+private:
+  static unsigned getDimension(mlir::LLVM::LLVMArrayType ty) {
+    unsigned result = 1;
+    for (auto eleTy = ty.getElementType().dyn_cast<mlir::LLVM::LLVMArrayType>();
+         eleTy;
+         eleTy = eleTy.getElementType().dyn_cast<mlir::LLVM::LLVMArrayType>())
+      ++result;
+    return result;
+  }
+
+  static mlir::Type getArrayElementType(mlir::LLVM::LLVMArrayType ty) {
+    auto eleTy = ty.getElementType();
+    while (auto arrTy = eleTy.dyn_cast<mlir::LLVM::LLVMArrayType>())
+      eleTy = arrTy.getElementType();
+    return eleTy;
+  }
+};
+
+/// Extract a subobject value from an ssa-value of aggregate type
+struct ExtractValueOpConversion
+    : public FIROpAndTypeConversion<fir::ExtractValueOp>,
+      public ValueOpCommon {
+  using FIROpAndTypeConversion::FIROpAndTypeConversion;
+
+  mlir::LogicalResult
+  doRewrite(fir::ExtractValueOp extractVal, mlir::Type ty, OpAdaptor adaptor,
+            mlir::ConversionPatternRewriter &rewriter) const override {
+    auto attrs = collectIndices(rewriter, extractVal.coor());
+    toRowMajor(attrs, adaptor.getOperands()[0].getType());
+    auto position = mlir::ArrayAttr::get(extractVal.getContext(), attrs);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::ExtractValueOp>(
+        extractVal, ty, adaptor.getOperands()[0], position);
+    return success();
+  }
+};
+
+/// InsertValue is the generalized instruction for the composition of new
+/// aggregate type values.
+struct InsertValueOpConversion
+    : public FIROpAndTypeConversion<fir::InsertValueOp>,
+      public ValueOpCommon {
+  using FIROpAndTypeConversion::FIROpAndTypeConversion;
+
+  mlir::LogicalResult
+  doRewrite(fir::InsertValueOp insertVal, mlir::Type ty, OpAdaptor adaptor,
+            mlir::ConversionPatternRewriter &rewriter) const override {
+    auto attrs = collectIndices(rewriter, insertVal.coor());
+    toRowMajor(attrs, adaptor.getOperands()[0].getType());
+    auto position = mlir::ArrayAttr::get(insertVal.getContext(), attrs);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(
+        insertVal, ty, adaptor.getOperands()[0], adaptor.getOperands()[1],
+        position);
+    return success();
+  }
+};
+
 /// InsertOnRange inserts a value into a sequence over a range of offsets.
 struct InsertOnRangeOpConversion
     : public FIROpAndTypeConversion<fir::InsertOnRangeOp> {
   using FIROpAndTypeConversion::FIROpAndTypeConversion;
 
   // Increments an array of subscripts in a row major fasion.
   void incrementSubscripts(const SmallVector<uint64_t> &dims,
                            SmallVector<uint64_t> &subscripts) const {

 class FIRToLLVMLowering : public fir::FIRToLLVMLoweringBase<FIRToLLVMLowering> {
 public:
   mlir::ModuleOp getModule() { return getOperation(); }
 
   void runOnOperation() override final {
     auto *context = getModule().getContext();
     fir::LLVMTypeConverter typeConverter{getModule()};
     mlir::OwningRewritePatternList pattern(context);
-    pattern.insert<AddrOfOpConversion, HasValueOpConversion, GlobalOpConversion,
-                   InsertOnRangeOpConversion, UndefOpConversion,
-                   UnreachableOpConversion, ZeroOpConversion>(typeConverter);
+    pattern.insert<
+        AddrOfOpConversion, ExtractValueOpConversion, HasValueOpConversion,
+        GlobalOpConversion, InsertOnRangeOpConversion, InsertValueOpConversion,
+        UndefOpConversion, UnreachableOpConversion, ZeroOpConversion>(
+        typeConverter);
     mlir::populateStdToLLVMConversionPatterns(typeConverter, pattern);
     mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter,
                                                             pattern);
     mlir::ConversionTarget target{*context};
     target.addLegalDialect<mlir::LLVM::LLVMDialect>();
 
     // required NOPs for applying a full conversion
     target.addLegalOp<mlir::ModuleOp>();

flang/lib/Optimizer/CodeGen/DescriptorModel.h

+//===-- DescriptorModel.h -- model of descriptors for codegen ---*- 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
+//
+//===----------------------------------------------------------------------===//
+// LLVM IR dialect models of C++ types.
+//
+// This supplies a set of model builders to decompose the C declaration of a
+// descriptor (as encoded in ISO_Fortran_binding.h and elsewhere) and
+// reconstruct that type in the LLVM IR dialect.
+//
+// TODO: It is understood that this is deeply incorrect as far as building a
+// portability layer for cross-compilation as these reflected types are those of
+// the build machine and not necessarily that of either the host or the target.
+// This assumption that build == host == target is actually pervasive across the
+// compiler.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef OPTIMIZER_DESCRIPTOR_MODEL_H
+#define OPTIMIZER_DESCRIPTOR_MODEL_H
+
+#include "flang/ISO_Fortran_binding.h"
+#include "flang/Runtime/descriptor.h"
+#include "mlir/Dialect/LLVMIR/LLVMTypes.h"
+#include "llvm/Support/ErrorHandling.h"
+#include <tuple>
+
+namespace fir {
+
+using TypeBuilderFunc = mlir::Type (*)(mlir::MLIRContext *);
+
+/// Get the LLVM IR dialect model for building a particular C++ type, `T`.
+template <typename T>
+TypeBuilderFunc getModel();
+
+template <>
+TypeBuilderFunc getModel<void *>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    return mlir::LLVM::LLVMPointerType::get(mlir::IntegerType::get(context, 8));
+  };
+}
+template <>
+TypeBuilderFunc getModel<unsigned>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    return mlir::IntegerType::get(context, sizeof(unsigned) * 8);
+  };
+}
+template <>
+TypeBuilderFunc getModel<int>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    return mlir::IntegerType::get(context, sizeof(int) * 8);
+  };
+}
+template <>
+TypeBuilderFunc getModel<unsigned long>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    return mlir::IntegerType::get(context, sizeof(unsigned long) * 8);
+  };
+}
+template <>
+TypeBuilderFunc getModel<unsigned long long>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    return mlir::IntegerType::get(context, sizeof(unsigned long long) * 8);
+  };
+}
+template <>
+TypeBuilderFunc getModel<long long>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    return mlir::IntegerType::get(context, sizeof(long long) * 8);
+  };
+}
+template <>
+TypeBuilderFunc getModel<Fortran::ISO::CFI_rank_t>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    return mlir::IntegerType::get(context,
+                                  sizeof(Fortran::ISO::CFI_rank_t) * 8);
+  };
+}
+template <>
+TypeBuilderFunc getModel<Fortran::ISO::CFI_type_t>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    return mlir::IntegerType::get(context,
+                                  sizeof(Fortran::ISO::CFI_type_t) * 8);
+  };
+}
+template <>
+TypeBuilderFunc getModel<Fortran::ISO::CFI_index_t>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    return mlir::IntegerType::get(context,
+                                  sizeof(Fortran::ISO::CFI_index_t) * 8);
+  };
+}
+template <>
+TypeBuilderFunc getModel<Fortran::ISO::CFI_dim_t>() {
+  return [](mlir::MLIRContext *context) -> mlir::Type {
+    auto indexTy = getModel<Fortran::ISO::CFI_index_t>()(context);
+    return mlir::LLVM::LLVMArrayType::get(indexTy, 3);
+  };
+}
+template <>
+TypeBuilderFunc
+getModel<Fortran::ISO::cfi_internal::FlexibleArray<Fortran::ISO::CFI_dim_t>>() {
+  return getModel<Fortran::ISO::CFI_dim_t>();
+}
+
+//===----------------------------------------------------------------------===//
+// Descriptor reflection
+//===----------------------------------------------------------------------===//
+
+/// Get the type model of the field number `Field` in an ISO CFI descriptor.
+template <int Field>
+static constexpr TypeBuilderFunc getDescFieldTypeModel() {
+  Fortran::ISO::Fortran_2018::CFI_cdesc_t dummyDesc{};
+  // check that the descriptor is exactly 8 fields
+  auto [a, b, c, d, e, f, g, h] = dummyDesc;
+  auto tup = std::tie(a, b, c, d, e, f, g, h);
+  auto field = std::get<Field>(tup);
+  return getModel<decltype(field)>();
+}
+
+/// An extended descriptor is defined by a class in runtime/descriptor.h. The
+/// three fields in the class are hard-coded here, unlike the reflection used on
+/// the ISO parts, which are a POD.
+template <int Field>
+static constexpr TypeBuilderFunc getExtendedDescFieldTypeModel() {
+  if constexpr (Field == 8) {
+    return getModel<void *>();
+  } else if constexpr (Field == 9) {
+    return getModel<Fortran::runtime::typeInfo::TypeParameterValue>();
+  } else {
+    llvm_unreachable("extended ISO descriptor only has 10 fields");
+  }
+}
+
+} // namespace fir
+
+#endif // OPTIMIZER_DESCRIPTOR_MODEL_H

flang/lib/Optimizer/CodeGen/TypeConverter.h

 //===-- TypeConverter.h -- type conversion ----------------------*- 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_OPTIMIZER_CODEGEN_TYPECONVERTER_H
 #define FORTRAN_OPTIMIZER_CODEGEN_TYPECONVERTER_H
 
+#include "DescriptorModel.h"
+#include "flang/Lower/Todo.h" // remove when TODO's are done
+#include "llvm/ADT/StringMap.h"
 #include "llvm/Support/Debug.h"
 
 namespace fir {
 
 /// FIR type converter
 /// This converts FIR types to LLVM types (for now)
 class LLVMTypeConverter : public mlir::LLVMTypeConverter {
 public:
   LLVMTypeConverter(mlir::ModuleOp module)
       : mlir::LLVMTypeConverter(module.getContext()) {
     LLVM_DEBUG(llvm::dbgs() << "FIR type converter\n");
 
     // Each conversion should return a value of type mlir::Type.
+    addConversion([&](BoxType box) { return convertBoxType(box); });
+    addConversion(
+        [&](fir::RecordType derived) { return convertRecordType(derived); });
     addConversion(
         [&](fir::ReferenceType ref) { return convertPointerLike(ref); });
     addConversion(
         [&](SequenceType sequence) { return convertSequenceType(sequence); });
+    addConversion([&](mlir::TupleType tuple) {
+      LLVM_DEBUG(llvm::dbgs() << "type convert: " << tuple << '\n');
+      llvm::SmallVector<mlir::Type> inMembers;
+      tuple.getFlattenedTypes(inMembers);
+      llvm::SmallVector<mlir::Type> members;
+      for (auto mem : inMembers) {
+        // Prevent fir.box from degenerating to a pointer to a descriptor in the
+        // context of a tuple type.
+        if (auto box = mem.dyn_cast<fir::BoxType>())
+          members.push_back(convertBoxTypeAsStruct(box));
+        else
+          members.push_back(convertType(mem).cast<mlir::Type>());
+      }
+      return mlir::LLVM::LLVMStructType::getLiteral(&getContext(), members,
+                                                    /*isPacked=*/false);
+    });
+  }
+
+  // Is an extended descriptor needed given the element type of a fir.box type ?
+  // Extended descriptors are required for derived types.
+  bool requiresExtendedDesc(mlir::Type boxElementType) {
+    auto eleTy = fir::unwrapSequenceType(boxElementType);
+    return eleTy.isa<fir::RecordType>();
+  }
+
+  // Magic value to indicate we do not know the rank of an entity, either
+  // because it is assumed rank or because we have not determined it yet.
+  static constexpr int unknownRank() { return -1; }
+
+  // This corresponds to the descriptor as defined ISO_Fortran_binding.h and the
+  // addendum defined in descriptor.h.
+  mlir::Type convertBoxType(BoxType box, int rank = unknownRank()) {
+    // (buffer*, ele-size, rank, type-descriptor, attribute, [dims])
+    SmallVector<mlir::Type> parts;
+    mlir::Type ele = box.getEleTy();
+    // remove fir.heap/fir.ref/fir.ptr
+    if (auto removeIndirection = fir::dyn_cast_ptrEleTy(ele))
+      ele = removeIndirection;
+    auto eleTy = convertType(ele);
+    // buffer*
+    if (ele.isa<SequenceType>() && eleTy.isa<mlir::LLVM::LLVMPointerType>())
+      parts.push_back(eleTy);
+    else
+      parts.push_back(mlir::LLVM::LLVMPointerType::get(eleTy));
+    parts.push_back(getDescFieldTypeModel<1>()(&getContext()));
+    parts.push_back(getDescFieldTypeModel<2>()(&getContext()));
+    parts.push_back(getDescFieldTypeModel<3>()(&getContext()));
+    parts.push_back(getDescFieldTypeModel<4>()(&getContext()));
+    parts.push_back(getDescFieldTypeModel<5>()(&getContext()));
+    parts.push_back(getDescFieldTypeModel<6>()(&getContext()));
+    if (rank == unknownRank()) {
+      if (auto seqTy = ele.dyn_cast<SequenceType>())
+        rank = seqTy.getDimension();
+      else
+        rank = 0;
+    }
+    if (rank > 0) {
+      auto rowTy = getDescFieldTypeModel<7>()(&getContext());
+      parts.push_back(mlir::LLVM::LLVMArrayType::get(rowTy, rank));
+    }
+    // opt-type-ptr: i8* (see fir.tdesc)
+    if (requiresExtendedDesc(ele)) {
+      parts.push_back(getExtendedDescFieldTypeModel<8>()(&getContext()));
+      auto rowTy = getExtendedDescFieldTypeModel<9>()(&getContext());
+      parts.push_back(mlir::LLVM::LLVMArrayType::get(rowTy, 1));
+      if (auto recTy = fir::unwrapSequenceType(ele).dyn_cast<fir::RecordType>())
+        if (recTy.getNumLenParams() > 0) {
+          // The descriptor design needs to be clarified regarding the number of
+          // length parameters in the addendum. Since it can change for
+          // polymorphic allocatables, it seems all length parameters cannot
+          // always possibly be placed in the addendum.
+          TODO_NOLOC("extended descriptor derived with length parameters");
+          unsigned numLenParams = recTy.getNumLenParams();
+          parts.push_back(mlir::LLVM::LLVMArrayType::get(rowTy, numLenParams));
+        }
+    }
+    return mlir::LLVM::LLVMPointerType::get(
+        mlir::LLVM::LLVMStructType::getLiteral(&getContext(), parts,
+                                               /*isPacked=*/false));
+  }
+  /// Convert fir.box type to the corresponding llvm struct type instead of a
+  /// pointer to this struct type.
+  mlir::Type convertBoxTypeAsStruct(BoxType box) {
+    return convertBoxType(box)
+        .cast<mlir::LLVM::LLVMPointerType>()
+        .getElementType();
+  }
+
+  // fir.type<name(p : TY'...){f : TY...}>  -->  llvm<"%name = { ty... }">
+  mlir::Type convertRecordType(fir::RecordType derived) {
+    auto name = derived.getName();
+    auto st = mlir::LLVM::LLVMStructType::getIdentified(&getContext(), name);
+    llvm::SmallVector<mlir::Type> members;
+    for (auto mem : derived.getTypeList()) {
+      // Prevent fir.box from degenerating to a pointer to a descriptor in the
+      // context of a record type.
+      if (auto box = mem.second.dyn_cast<fir::BoxType>())
+        members.push_back(convertBoxTypeAsStruct(box));
+      else
+        members.push_back(convertType(mem.second).cast<mlir::Type>());
+    }
+    if (mlir::succeeded(st.setBody(members, /*isPacked=*/false)))
+      return st;
+    return mlir::Type();
   }
 
   template <typename A>
   mlir::Type convertPointerLike(A &ty) {
     mlir::Type eleTy = ty.getEleTy();
     // A sequence type is a special case. A sequence of runtime size on its
     // interior dimensions lowers to a memory reference. In that case, we
     // degenerate the array and do not want a the type to become `T**` but
     // merely `T*`.
     if (auto seqTy = eleTy.dyn_cast<fir::SequenceType>()) {
if (constRows) {
       }
       if (seq.hasConstantShape())
         return baseTy;
     }
     return mlir::LLVM::LLVMPointerType::get(baseTy);
   }
 };
 
 } // namespace fir
 
 #endif // FORTRAN_OPTIMIZER_CODEGEN_TYPECONVERTER_H

flang/test/Fir/convert-to-llvm.fir

 // Test fir.zero_bits operation with LLVM ptr type
 
 func @zero_test_ptr() {
   %z = fir.zero_bits !llvm.ptr<f32>
   return
 }
 
 // CHECK: %{{.*}} = llvm.mlir.null : !llvm.ptr<f32>
 // CHECK-NOT: fir.zero_bits
 
 // -----
 
 // Test fir.zero_bits operation with integer type.
 
 func @zero_test_integer() {
   %z0 = fir.zero_bits i8
   %z1 = fir.zero_bits i16
   %z2 = fir.zero_bits i32
   %z3 = fir.zero_bits i64
   return
 }
 
 // CHECK: %{{.*}} = llvm.mlir.constant(0 : i8) : i8
 // CHECK: %{{.*}} = llvm.mlir.constant(0 : i16) : i16
 // CHECK: %{{.*}} = llvm.mlir.constant(0 : i32) : i32
 // CHECK: %{{.*}} = llvm.mlir.constant(0 : i64) : i64
 // CHECK-NOT: fir.zero_bits
 
 // -----
 
 // Test fir.zero_bits operation with floating points types.
 
 func @zero_test_float() {
   %z0 = fir.zero_bits f16
   %z1 = fir.zero_bits bf16
   %z2 = fir.zero_bits f32
   %z3 = fir.zero_bits f64
   %z4 = fir.zero_bits f80
   %z5 = fir.zero_bits f128
   return
 }
 
 // CHECK: %{{.*}} = llvm.mlir.constant(0.000000e+00 : f16) : f16
 // CHECK: %{{.*}} = llvm.mlir.constant(0.000000e+00 : bf16) : bf16
 // CHECK: %{{.*}} = llvm.mlir.constant(0.000000e+00 : f32) : f32
 // CHECK: %{{.*}} = llvm.mlir.constant(0.000000e+00 : f64) : f64
 // CHECK: %{{.*}} = llvm.mlir.constant(0.000000e+00 : f80) : f80
 // CHECK: %{{.*}} = llvm.mlir.constant(0.000000e+00 : f128) : f128
 // CHECK-NOT: fir.zero_bits
 
 // -----
 
 // Verify that fir.unreachable is transformed to llvm.unreachable
 
 // CHECK:  llvm.func @test_unreachable() {
 // CHECK-NEXT:    llvm.unreachable
 // CHECK-NEXT:  }
 
 func @test_unreachable() {
   fir.unreachable
 }
+
+// -----
+
+// Test fir.extract_value operation conversion with derived type.
+
+func @extract_derived_type() -> f32 {
+  %0 = fir.undefined !fir.type<derived{f:f32}>
+  %1 = fir.extract_value %0, ["f", !fir.type<derived{f:f32}>] : (!fir.type<derived{f:f32}>) -> f32
+  return %1 : f32
+}
+
+// CHECK-LABEL: llvm.func @extract_derived_type
+// CHECK:         %[[STRUCT:.*]] = llvm.mlir.undef : !llvm.struct<"derived", (f32)>
+// CHECK:         %[[VALUE:.*]] = llvm.extractvalue %[[STRUCT]][0 : i32] : !llvm.struct<"derived", (f32)>
+// CHECK:         llvm.return %[[VALUE]] : f32
+
+// -----
+
+// Test fir.extract_value operation conversion with a multi-dimensional array
+// of tuple.
+
+func @extract_array(%a : !fir.array<10x10xtuple<i32, f32>>) -> f32 {
+  %0 = fir.extract_value %a, [5 : index, 4 : index, 1 : index] : (!fir.array<10x10xtuple<i32, f32>>) -> f32
+  return %0 : f32
+}
+
+// CHECK-LABEL: llvm.func @extract_array(
+// CHECK-SAME:                           %[[ARR:.*]]: !llvm.array<10 x array<10 x struct<(i32, f32)>>>
+// CHECK:         %[[VALUE:.*]] = llvm.extractvalue %[[ARR]][4 : index, 5 : index, 1 : index] : !llvm.array<10 x array<10 x struct<(i32, f32)>>>
+// CHECK:         llvm.return %[[VALUE]] : f32
+
+// -----
+
+// Test fir.insert_value operation conversion with a multi-dimensional array
+// of tuple.
+
+func @extract_array(%a : !fir.array<10x10xtuple<i32, f32>>) {
+  %f = arith.constant 2.0 : f32
+  %i = arith.constant 1 : i32
+  %0 = fir.insert_value %a, %i, [5 : index, 4 : index, 0 : index] : (!fir.array<10x10xtuple<i32, f32>>, i32) -> !fir.array<10x10xtuple<i32, f32>>
+  %1 = fir.insert_value %a, %f, [5 : index, 4 : index, 1 : index] : (!fir.array<10x10xtuple<i32, f32>>, f32) -> !fir.array<10x10xtuple<i32, f32>>
+  return
+}
+
+// CHECK-LABEL: llvm.func @extract_array(
+// CHECK-SAME:                           %[[ARR:.*]]: !llvm.array<10 x array<10 x struct<(i32, f32)>>>
+// CHECK:         %{{.*}} = llvm.insertvalue %{{.*}}, %[[ARR]][4 : index, 5 : index, 0 : index] : !llvm.array<10 x array<10 x struct<(i32, f32)>>>
+// CHECK:         %{{.*}} = llvm.insertvalue %{{.*}}, %[[ARR]][4 : index, 5 : index, 1 : index] : !llvm.array<10 x array<10 x struct<(i32, f32)>>>
+// CHECK:         llvm.return
+
+// -----
+
+// Test fir.insert_value operation conversion with derived type.
+
+func @insert_tuple(%a : tuple<i32, f32>) {
+  %f = arith.constant 2.0 : f32
+  %1 = fir.insert_value %a, %f, [1 : index] : (tuple<i32, f32>, f32) -> tuple<i32, f32>
+  return
+}
+
+// CHECK-LABEL: func @insert_tuple(
+// CHECK-SAME:                     %[[TUPLE:.*]]: !llvm.struct<(i32, f32)>
+// CHECK:         %{{.*}} = llvm.insertvalue %{{.*}}, %[[TUPLE]][1 : index] : !llvm.struct<(i32, f32)>
+// CHECK:         llvm.return