[fir] Add fir.embox conversion

[clementval]

Summary

Convert a fir.embox operation to LLVM IR dialect.
A fir.embox is converted to a sequence of operation that
create, allocate if needed, and populate a descriptor.

Current limitiation: alignment is set by default but should be retrieved in the specific target.

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

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

[awarzynski]

I've only managed to skim through - will revisit next wekk.

1. I think that the overall readability of CodeGen.cpp could be improved if EmboxCommonConversion was separate from the other conversions (which tend to me compact and self-contained). Perhaps a dedicated file?
2. F18ADDENDUM - it would be great to avoid F18 (here and in other places). Perhaps FLANG_ADDENDUM?

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1384–1388

Why not inline this?

1498

1. Why?
2. Could you "inject" this comment into the assert?

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

1304

Where is 9 coming from? I couldn't find it.

1305

[clementval]

In D113756#3127807, @awarzynski wrote:

I've only managed to skim through - will revisit next wekk.

1. I think that the overall readability of CodeGen.cpp could be improved if EmboxCommonConversion was separate from the other conversions (which tend to me compact and self-contained). Perhaps a dedicated file?

I would prefer to do this kind of file/code restructuring after the upstreaming is done. EmboxCommonConversion is (will be) used by other conversion pattern here. We already have such common struct for ValueOpCommon.

[rovka]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1237

Do we really need op, or could we just replace all of this with

auto func = thisBlock->getParentOfType<mlir::LLVM::LLVMFuncOp>()

?

1263

Minor nit: I think comparing with nullptr is clearer than casting to bool (but I'm not sure what's idiomatic for FIR types).

1338

Is it possible to have more than 1 len param? I think this could use a comment on why we only care about the last one.

1397

This looks like it could easily get out of sync with lowering. Would it be difficult to move this logic somewhere common?

1414

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

1304

https://github.com/llvm/llvm-project/blob/4119da2f7c5fd21c03f6d50aa1d2af3527a9e90f/flang/include/flang/ISO_Fortran_binding.h#L56 ?

1324

1325

1351

I think we should have some tests in this style for various [elem_size, type_code] combinations, and especially char if possible.

[kiranchandramohan]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1237

I think such a function does not exist.

[clementval]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1237

@kiranchandramohan is right. Block does not have such function.

1498

If I'm not wrong embox with shape are first lowered to xembox op and then converted to LLVM IR.

2. done

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

1304

That's correct.

1305

Thanks for catching this.

[clementval]

Address comments

[clementval]

2. F18ADDENDUM - it would be great to avoid F18 (here and in other places). Perhaps FLANG_ADDENDUM?

The descriptor field is named f18Addendum. I think it's easier to follow if the name correspond to the name in code.

[awarzynski]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1220

DOXYGENME?

[nit] IIUC, lowering is used in Flang to refer to lowering from parse tree to FIR. This part is usually referred to as "code-gen". And this file deals with "conversions" specifically. Perhaps "lowering" --> "converting"? For the sake of consistency.

1230–1231

1233–1234

This isn't correct, is it?

1239

Why 1?

1245–1252

I think that this can be static, no?

1431

Perhaps a daft question, but what's the difference between "descriptor" and "descriptor prefix" here?

1460

genConstantOffset takes an int rather than bool.

Also, hasAddendum is not an offset, is it?. Similarly above (getCFIAttr does not generate an offset, does it). In general, based on the usage in this method, it seems that genConstantOffset should be renamed as genConstant.

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

1292

Could add a note explaining the origins of the indices within the descriptor?

1315

1316

1339

Could you explain "why" 1? (i.e. that's the value of CFI_attribute_pointer, right?).

1354

Why 2?

1362

1415

Why 1?

[clementval]

Address comments

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1220

We use Lower on at least 13 patterns in this file. Anyway I switched to conversion here. Not sure what do you want to "doxygen" here.

1233–1234

Why?

1239

Array size of 1

1431

Again, not the original author so just guessing. This is generating the first part of the descriptor (prefix) but not the last part with the dimensions and so on.

1460

I split this. genConstantOffset is used mainly for GEP op creation and get the offset type from the TypeConverter. For constant created for values, we will use a separate function that just creates integer constants.

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

1315

Thanks!

1316

Thanks!

[awarzynski]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1233–1234

 auto func = mlir::isa<mlir::LLVM::LLVMFuncOp>(op)
			                    ? mlir::cast<mlir::LLVM::LLVMFuncOp>(op)
			                    : op->getParentOfType<mlir::LLVM::LLVMFuncOp>();

To me this means:

• If this is a LLVMFuncOp, use it as the block for the newly inserted alloca.
• Otherwise, use the block corresponding to the parent LLVMFuncOp

The comment above this statement suggests otherwise. Or is it just me?

[clementval]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1233–1234

This is what the comment says.

auto op = rewriter.getInsertionBlock()->getParentOp(); might be placed under the comment so it's easier to understand. If you have a better way to describe this feel free to propose it.

[awarzynski]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1230–1236

OK, my bad, the comment refers to auto op = rewriter.getInsertionBlock()->getParentOp(); as well. I was only looking at the comment and the code that follows.

I think that op is a misleading name (I've just assumed that it's the operation currently being converted). I suggest updating to something more descriptive.

As for the comment itself - IMHO the bit that confused me (2nd and 3rd line) simply repeats what the code does and does not add much. I would delete it. The first sentence in the comment ("// Order to find the Op in whose entry block the alloca should be inserted.") can also be deleted if you rename func as something more descriptive, e.g. funcForInsertion or funcToInsertAllocaInto.

[kiranchandramohan]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1230–1236

Since this has become controversial, I think we can take this opportunity to convert this code into a function that returns the correct LLVM FUncOp for the alloca to be inserted.

getLLVMFuncToInsertAlloca

Something similar was suggested by @jeanPerier in the original PR.
https://github.com/flang-compiler/f18-llvm-project/pull/1066#pullrequestreview-760987822

[clementval]

Move code to find alloca insert func

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1230–1236

I think @kiranchandramohan is right. This is better in a separate function and should be easier to understand. I just updated the patch with this change.

[awarzynski]

Make sense, thanks for all the updates! It seems that genConstantOffset is still used to generate a lot of values that are not "offsets". Are you going to rename it? Otherwise, just a few minor things.

flang/include/flang/Optimizer/Support/TypeCode.h

29

[nit] I think that width would be more accurate (bits could mean the actual data too)

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1237

1. size is hard-coded to 1. Can you update the comment accordingly?
2. Could you document what the return value is?

1244

I thought that you would introduce another method to generate constant values? genConstantOffset is rather counter-intuitive here. genConstantVal would make more sense here.

1347–1361

[nit] Perhaps move above doInteger and other lambdas not needed for these 2 cases? Basically, this function is a bit dense and it's not obvious what the key cases are. Or add comments?

1402

What's this name of? Global descriptor, right?

1404

This checks for the global symbol in FIR?

1410

This checks for the global symbol in LLVM?

1443

[nit] I think that this value is first and foremost the constructed "descriptor". The fact that it's a "dest"ination when calling insertField is IMO just an implementation detail. Perhaps just add a comment that documents "what" this method produces? Otherwise, dest is a bit enigmatic.

1480–1481

[clementval]

flang/include/flang/Optimizer/Support/TypeCode.h

29

I changed it to bitwidth as it is reference in the top comment.

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1244

I did genI32Constant.

1347–1361

This actually trigger couple of regression. Adding comments is fine.

1402

name (once lowered) of the global for the corresponding type descriptor.

1404

Yes it looks in the fir.global ops that have not been converted yet.

1410

Yeah we check in the llvm global since it might have been converted already.

[clementval]

Rebase + address comments

[kiranchandramohan]

A few minor comments.

flang/lib/Optimizer/CodeGen/CodeGen.cpp

169

Nit: array|struct|vector

1523

Notify failure and testcase.

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

1392

Is the logical type missing?

[clementval]

Address more comments

[clementval]

Rebase

[kiranchandramohan]

LGTM. Please wait for @awarzynski.

[clementval]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1523

switch to notifyMatchFailure. Testcase cannot be added at this time because the TypeConverter will trigger a TODO before we can reach this point.

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

1392

Not really missing. I didn't add test for every possible typecode. Added one for logical.

[awarzynski]

LGTM, thanks for working on this!

[clementval]

Rebase

flang/include/flang/Optimizer/Dialect/FIRTypes.td

mlir::Type getType(unsigned index) {
       assert(index < getNumFields());
       return getTypeList()[index].second;
     }
     unsigned getNumFields() { return getTypeList().size(); }
     unsigned getNumLenParams() { return getLenParamList().size(); }
 
     void finalize(llvm::ArrayRef<TypePair> lenPList,
                   llvm::ArrayRef<TypePair> typeList);
     
+    std::string getLoweredName() const;
+
     detail::RecordTypeStorage const *uniqueKey() const;
   }];
 }
 
 def fir_ReferenceType : FIR_Type<"Reference", "ref"> {
   let summary = "Reference to an entity type";
 
   let description = [{

flang/include/flang/Optimizer/Support/TypeCode.h

+//===-- Optimizer/Support/TypeCode.h ----------------------------*- 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_SUPPORT_TYPECODE_H
+#define FORTRAN_OPTIMIZER_SUPPORT_TYPECODE_H
+
+#include "flang/ISO_Fortran_binding.h"
+#include "llvm/Support/ErrorHandling.h"
+
+namespace fir {
+
+//===----------------------------------------------------------------------===//
+// Translations of category and bitwidths to the type codes defined in flang's
+// ISO_Fortran_binding.h.
+//===----------------------------------------------------------------------===//
+
+inline int characterBitsToTypeCode(unsigned bitwidth) {
+  // clang-format off
+  switch (bitwidth) {
+  case 8:  return CFI_type_char;
+  case 16: return CFI_type_char16_t;
+  case 32: return CFI_type_char32_t;
+  default: llvm_unreachable("unsupported character size");
+  }
+  // clang-format on
+}
+
+inline int complexBitsToTypeCode(unsigned bitwidth) {
+  // clang-format off
+  switch (bitwidth) {
+  case 32:  return CFI_type_float_Complex;
+  case 64:  return CFI_type_double_Complex;
+  case 80:
+  case 128: return CFI_type_long_double_Complex;
+  default:  llvm_unreachable("unsupported complex size");
+  }
+  // clang-format on
+}
+
+inline int integerBitsToTypeCode(unsigned bitwidth) {
+  // clang-format off
+  switch (bitwidth) {
+  case 8:   return CFI_type_int8_t;
+  case 16:  return CFI_type_int16_t;
+  case 32:  return CFI_type_int32_t;
+  case 64:  return CFI_type_int64_t;
+  case 128: return CFI_type_int128_t;
+  default:  llvm_unreachable("unsupported integer size");
+  }
+  // clang-format on
+}
+
+inline int logicalBitsToTypeCode(unsigned bitwidth) {
+  // clang-format off
+  switch (bitwidth) {
+  case 8: return CFI_type_Bool;
+  case 16: return CFI_type_int_least16_t;
+  case 32: return CFI_type_int_least32_t;
+  case 64: return CFI_type_int_least64_t;
+  default: llvm_unreachable("unsupported logical size");
+  }
+  // clang-format on
+}
+
+inline int realBitsToTypeCode(unsigned bitwidth) {
+  // clang-format off
+  switch (bitwidth) {
+  case 32:  return CFI_type_float;
+  case 64:  return CFI_type_double;
+  case 80:
+  case 128: return CFI_type_long_double;
+  default:  llvm_unreachable("unsupported real size");
+  }
+  // clang-format on
+}
+
+static constexpr int derivedToTypeCode() { return CFI_type_struct; }
+
+} // namespace fir
+
+#endif // FORTRAN_OPTIMIZER_SUPPORT_TYPECODE_H

flang/lib/Optimizer/CodeGen/CodeGen.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Optimizer/CodeGen/CodeGen.h"
 #include "PassDetail.h"
 #include "flang/ISO_Fortran_binding.h"
 #include "flang/Optimizer/Dialect/FIRAttr.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Support/TypeCode.h"
 #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
 #include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/Pass/Pass.h"
 #include "llvm/ADT/ArrayRef.h"
 
 #define DEBUG_TYPE "flang-codegen"
 
 // fir::LLVMTypeConverter for converting to LLVM IR dialect types.
 #include "TypeConverter.h"
 
+// TODO: This should really be recovered from the specified target.
+static constexpr unsigned defaultAlign = 8;
+
 /// `fir.box` attribute values as defined for CFI_attribute_t in
 /// flang/ISO_Fortran_binding.h.
 static constexpr unsigned kAttrPointer = CFI_attribute_pointer;
 static constexpr unsigned kAttrAllocatable = CFI_attribute_allocatable;
 
 static mlir::LLVM::ConstantOp
 genConstantIndex(mlir::Location loc, mlir::Type ity,
                  mlir::ConversionPatternRewriter &rewriter,
explicit FIROpConversion(fir::LLVMTypeConverter &lowering)
       : mlir::ConvertOpToLLVMPattern<FromOp>(lowering) {}
 
 protected:
   mlir::Type convertType(mlir::Type ty) const {
     return lowerTy().convertType(ty);
   }
 
   mlir::LLVM::ConstantOp
+  genI32Constant(mlir::Location loc, mlir::ConversionPatternRewriter &rewriter,
+                 int value) const {
+    mlir::Type i32Ty = rewriter.getI32Type();
+    mlir::IntegerAttr attr = rewriter.getI32IntegerAttr(value);
+    return rewriter.create<mlir::LLVM::ConstantOp>(loc, i32Ty, attr);
+  }
+
+  mlir::LLVM::ConstantOp
   genConstantOffset(mlir::Location loc,
                     mlir::ConversionPatternRewriter &rewriter,
                     int offset) const {
-    auto ity = lowerTy().offsetType();
-    auto cattr = rewriter.getI32IntegerAttr(offset);
+    mlir::Type ity = lowerTy().offsetType();
+    mlir::IntegerAttr cattr = rewriter.getI32IntegerAttr(offset);
     return rewriter.create<mlir::LLVM::ConstantOp>(loc, ity, cattr);
   }
 
   /// Construct code sequence to extract the specifc value from a `fir.box`.
   mlir::Value getValueFromBox(mlir::Location loc, mlir::Value box,
                               mlir::Type resultTy,
                               mlir::ConversionPatternRewriter &rewriter,
                               unsigned boxValue) const {
mlir::LLVM::ConstantOp attrMask =
         genConstantOffset(loc, rewriter, maskValue);
     auto maskRes =
         rewriter.create<mlir::LLVM::AndOp>(loc, attrTy, attribute, attrMask);
     mlir::LLVM::ConstantOp c0 = genConstantOffset(loc, rewriter, 0);
     return rewriter.create<mlir::LLVM::ICmpOp>(
         loc, mlir::LLVM::ICmpPredicate::ne, maskRes, c0);
   }
 
+  // Get the element type given an LLVM type that is of the form
+  // [llvm.ptr](array|struct|vector)+ and the provided indexes.
+  static mlir::Type getBoxEleTy(mlir::Type type,
+                                llvm::ArrayRef<unsigned> indexes) {
+    if (auto t = type.dyn_cast<mlir::LLVM::LLVMPointerType>())
+      type = t.getElementType();
+    for (auto i : indexes) {
+      if (auto t = type.dyn_cast<mlir::LLVM::LLVMStructType>()) {
+        assert(!t.isOpaque() && i < t.getBody().size());
+        type = t.getBody()[i];
+      } else if (auto t = type.dyn_cast<mlir::LLVM::LLVMArrayType>()) {
+        type = t.getElementType();
+      } else if (auto t = type.dyn_cast<mlir::VectorType>()) {
+        type = t.getElementType();
+      } else {
+        fir::emitFatalError(mlir::UnknownLoc::get(type.getContext()),
+                            "request for invalid box element type");
+      }
+    }
+    return type;
+  }
+
   template <typename... ARGS>
   mlir::LLVM::GEPOp genGEP(mlir::Location loc, mlir::Type ty,
                            mlir::ConversionPatternRewriter &rewriter,
                            mlir::Value base, ARGS... args) const {
     SmallVector<mlir::Value> cv{args...};
     return rewriter.create<mlir::LLVM::GEPOp>(loc, ty, base, cv);
   }
 
if (ty.isa<mlir::LLVM::LLVMPointerType>()) {
       return rewriter.notifyMatchFailure(
           zero,
           "conversion of fir.zero with aggregate type not implemented yet");
     }
     return success();
   }
 };
 
+/// Common base class for embox to descriptor conversion.
+template <typename OP>
+struct EmboxCommonConversion : public FIROpConversion<OP> {
+  using FIROpConversion<OP>::FIROpConversion;
+
+  // Find the LLVMFuncOp in whose entry block the alloca should be inserted.
+  // The order to find the LLVMFuncOp is as follows:
+  // 1. The parent operation of the current block if it is a LLVMFuncOp.
+  // 2. The first ancestor that is a LLVMFuncOp.
+  mlir::LLVM::LLVMFuncOp
+  getFuncForAllocaInsert(mlir::ConversionPatternRewriter &rewriter) const {
+    mlir::Operation *parentOp = rewriter.getInsertionBlock()->getParentOp();
+    return mlir::isa<mlir::LLVM::LLVMFuncOp>(parentOp)
+               ? mlir::cast<mlir::LLVM::LLVMFuncOp>(parentOp)
+               : parentOp->getParentOfType<mlir::LLVM::LLVMFuncOp>();
+  }
+
+  // Generate an alloca of size 1 and type \p toTy.
+  mlir::LLVM::AllocaOp
+  genAllocaWithType(mlir::Location loc, mlir::Type toTy, unsigned alignment,
+                    mlir::ConversionPatternRewriter &rewriter) const {
+    auto thisPt = rewriter.saveInsertionPoint();
+    mlir::LLVM::LLVMFuncOp func = getFuncForAllocaInsert(rewriter);
+    rewriter.setInsertionPointToStart(&func.front());
+    auto size = this->genI32Constant(loc, rewriter, 1);
+    auto al = rewriter.create<mlir::LLVM::AllocaOp>(loc, toTy, size, alignment);
+    rewriter.restoreInsertionPoint(thisPt);
+    return al;
+  }
+
+  static int getCFIAttr(fir::BoxType boxTy) {
+    auto eleTy = boxTy.getEleTy();
+    if (eleTy.isa<fir::PointerType>())
+      return CFI_attribute_pointer;
+    if (eleTy.isa<fir::HeapType>())
+      return CFI_attribute_allocatable;
+    return CFI_attribute_other;
+  }
+
+  static fir::RecordType unwrapIfDerived(fir::BoxType boxTy) {
+    return fir::unwrapSequenceType(fir::dyn_cast_ptrOrBoxEleTy(boxTy))
+        .template dyn_cast<fir::RecordType>();
+  }
+  static bool isDerivedTypeWithLenParams(fir::BoxType boxTy) {
+    auto recTy = unwrapIfDerived(boxTy);
+    return recTy && recTy.getNumLenParams() > 0;
+  }
+  static bool isDerivedType(fir::BoxType boxTy) {
+    return unwrapIfDerived(boxTy) != nullptr;
+  }
+
+  // Get the element size and CFI type code of the boxed value.
+  std::tuple<mlir::Value, mlir::Value> getSizeAndTypeCode(
+      mlir::Location loc, mlir::ConversionPatternRewriter &rewriter,
+      mlir::Type boxEleTy, mlir::ValueRange lenParams = {}) const {
+    auto doInteger =
+        [&](unsigned width) -> std::tuple<mlir::Value, mlir::Value> {
+      int typeCode = fir::integerBitsToTypeCode(width);
+      return {this->genConstantOffset(loc, rewriter, width / 8),
+              this->genConstantOffset(loc, rewriter, typeCode)};
+    };
+    auto doLogical =
+        [&](unsigned width) -> std::tuple<mlir::Value, mlir::Value> {
+      int typeCode = fir::logicalBitsToTypeCode(width);
+      return {this->genConstantOffset(loc, rewriter, width / 8),
+              this->genConstantOffset(loc, rewriter, typeCode)};
+    };
+    auto doFloat = [&](unsigned width) -> std::tuple<mlir::Value, mlir::Value> {
+      int typeCode = fir::realBitsToTypeCode(width);
+      return {this->genConstantOffset(loc, rewriter, width / 8),
+              this->genConstantOffset(loc, rewriter, typeCode)};
+    };
+    auto doComplex =
+        [&](unsigned width) -> std::tuple<mlir::Value, mlir::Value> {
+      auto typeCode = fir::complexBitsToTypeCode(width);
+      return {this->genConstantOffset(loc, rewriter, width / 8 * 2),
+              this->genConstantOffset(loc, rewriter, typeCode)};
+    };
+    auto doCharacter =
+        [&](unsigned width,
+            mlir::Value len) -> std::tuple<mlir::Value, mlir::Value> {
+      auto typeCode = fir::characterBitsToTypeCode(width);
+      auto typeCodeVal = this->genConstantOffset(loc, rewriter, typeCode);
+      if (width == 8)
+        return {len, typeCodeVal};
+      auto byteWidth = this->genConstantOffset(loc, rewriter, width / 8);
+      auto i64Ty = mlir::IntegerType::get(&this->lowerTy().getContext(), 64);
+      auto size =
+          rewriter.create<mlir::LLVM::MulOp>(loc, i64Ty, byteWidth, len);
+      return {size, typeCodeVal};
+    };
+    auto getKindMap = [&]() -> fir::KindMapping & {
+      return this->lowerTy().getKindMap();
+    };
+    // Pointer-like types.
+    if (auto eleTy = fir::dyn_cast_ptrEleTy(boxEleTy))
+      boxEleTy = eleTy;
+    // Integer types.
+    if (fir::isa_integer(boxEleTy)) {
+      if (auto ty = boxEleTy.dyn_cast<mlir::IntegerType>())
+        return doInteger(ty.getWidth());
+      auto ty = boxEleTy.cast<fir::IntegerType>();
+      return doInteger(getKindMap().getIntegerBitsize(ty.getFKind()));
+    }
+    // Floating point types.
+    if (fir::isa_real(boxEleTy)) {
+      if (auto ty = boxEleTy.dyn_cast<mlir::FloatType>())
+        return doFloat(ty.getWidth());
+      auto ty = boxEleTy.cast<fir::RealType>();
+      return doFloat(getKindMap().getRealBitsize(ty.getFKind()));
+    }
+    // Complex types.
+    if (fir::isa_complex(boxEleTy)) {
+      if (auto ty = boxEleTy.dyn_cast<mlir::ComplexType>())
+        return doComplex(
+            ty.getElementType().cast<mlir::FloatType>().getWidth());
+      auto ty = boxEleTy.cast<fir::ComplexType>();
+      return doComplex(getKindMap().getRealBitsize(ty.getFKind()));
+    }
+    // Character types.
+    if (auto ty = boxEleTy.dyn_cast<fir::CharacterType>()) {
+      auto charWidth = getKindMap().getCharacterBitsize(ty.getFKind());
+      if (ty.getLen() != fir::CharacterType::unknownLen()) {
+        auto len = this->genConstantOffset(loc, rewriter, ty.getLen());
+        return doCharacter(charWidth, len);
+      }
+      assert(!lenParams.empty());
+      return doCharacter(charWidth, lenParams.back());
+    }
+    // Logical type.
+    if (auto ty = boxEleTy.dyn_cast<fir::LogicalType>())
+      return doLogical(getKindMap().getLogicalBitsize(ty.getFKind()));
+    // Array types.
+    if (auto seqTy = boxEleTy.dyn_cast<fir::SequenceType>())
+      return getSizeAndTypeCode(loc, rewriter, seqTy.getEleTy(), lenParams);
+    // Derived-type types.
+    if (boxEleTy.isa<fir::RecordType>()) {
+      auto ptrTy = mlir::LLVM::LLVMPointerType::get(
+          this->lowerTy().convertType(boxEleTy));
+      auto nullPtr = rewriter.create<mlir::LLVM::NullOp>(loc, ptrTy);
+      auto one =
+          genConstantIndex(loc, this->lowerTy().offsetType(), rewriter, 1);
+      auto gep = rewriter.create<mlir::LLVM::GEPOp>(
+          loc, ptrTy, mlir::ValueRange{nullPtr, one});
+      auto eleSize = rewriter.create<mlir::LLVM::PtrToIntOp>(
+          loc, this->lowerTy().indexType(), gep);
+      return {eleSize,
+              this->genConstantOffset(loc, rewriter, fir::derivedToTypeCode())};
+    }
+    // Reference type.
+    if (fir::isa_ref_type(boxEleTy)) {
+      // FIXME: use the target pointer size rather than sizeof(void*)
+      return {this->genConstantOffset(loc, rewriter, sizeof(void *)),
+              this->genConstantOffset(loc, rewriter, CFI_type_cptr)};
+    }
+    fir::emitFatalError(loc, "unhandled type in fir.box code generation");
+  }
+
+  /// Basic pattern to write a field in the descriptor
+  mlir::Value insertField(mlir::ConversionPatternRewriter &rewriter,
+                          mlir::Location loc, mlir::Value dest,
+                          ArrayRef<unsigned> fldIndexes, mlir::Value value,
+                          bool bitcast = false) const {
+    auto boxTy = dest.getType();
+    auto fldTy = this->getBoxEleTy(boxTy, fldIndexes);
+    if (bitcast)
+      value = rewriter.create<mlir::LLVM::BitcastOp>(loc, fldTy, value);
+    else
+      value = this->integerCast(loc, rewriter, fldTy, value);
+    SmallVector<mlir::Attribute, 2> attrs;
+    for (auto i : fldIndexes)
+      attrs.push_back(rewriter.getI32IntegerAttr(i));
+    auto indexesAttr = mlir::ArrayAttr::get(rewriter.getContext(), attrs);
+    return rewriter.create<mlir::LLVM::InsertValueOp>(loc, boxTy, dest, value,
+                                                      indexesAttr);
+  }
+
+  inline mlir::Value
+  insertBaseAddress(mlir::ConversionPatternRewriter &rewriter,
+                    mlir::Location loc, mlir::Value dest,
+                    mlir::Value base) const {
+    return insertField(rewriter, loc, dest, {0}, base, /*bitCast=*/true);
+  }
+
+  /// Get the address of the type descriptor global variable that was created by
+  /// lowering for derived type \p recType.
+  template <typename BOX>
+  mlir::Value
+  getTypeDescriptor(BOX box, mlir::ConversionPatternRewriter &rewriter,
+                    mlir::Location loc, fir::RecordType recType) const {
+    std::string name = recType.getLoweredName();
+    auto module = box->template getParentOfType<mlir::ModuleOp>();
+    if (auto global = module.template lookupSymbol<fir::GlobalOp>(name)) {
+      auto ty = mlir::LLVM::LLVMPointerType::get(
+          this->lowerTy().convertType(global.getType()));
+      return rewriter.create<mlir::LLVM::AddressOfOp>(loc, ty,
+                                                      global.sym_name());
+    }
+    if (auto global =
+            module.template lookupSymbol<mlir::LLVM::GlobalOp>(name)) {
+      // The global may have already been translated to LLVM.
+      auto ty = mlir::LLVM::LLVMPointerType::get(global.getType());
+      return rewriter.create<mlir::LLVM::AddressOfOp>(loc, ty,
+                                                      global.sym_name());
+    }
+    // The global does not exist in the current translation unit, but may be
+    // defined elsewhere (e.g., type defined in a module).
+    // For now, create a extern_weak symbol (will become nullptr if unresolved)
+    // to support generating code without the front-end generated symbols.
+    // These could be made available_externally to require the symbols to be
+    // defined elsewhere and to cause link-time failure otherwise.
+    auto i8Ty = rewriter.getIntegerType(8);
+    mlir::OpBuilder modBuilder(module.getBodyRegion());
+    // TODO: The symbol should be lowered to constant in lowering, they are read
+    // only.
+    modBuilder.create<mlir::LLVM::GlobalOp>(loc, i8Ty, /*isConstant=*/false,
+                                            mlir::LLVM::Linkage::ExternWeak,
+                                            name, mlir::Attribute{});
+    auto ty = mlir::LLVM::LLVMPointerType::get(i8Ty);
+    return rewriter.create<mlir::LLVM::AddressOfOp>(loc, ty, name);
+  }
+
+  template <typename BOX>
+  std::tuple<fir::BoxType, mlir::Value, mlir::Value>
+  consDescriptorPrefix(BOX box, mlir::ConversionPatternRewriter &rewriter,
+                       unsigned rank, mlir::ValueRange lenParams) const {
+    auto loc = box.getLoc();
+    auto boxTy = box.getType().template dyn_cast<fir::BoxType>();
+    auto convTy = this->lowerTy().convertBoxType(boxTy, rank);
+    auto llvmBoxPtrTy = convTy.template cast<mlir::LLVM::LLVMPointerType>();
+    auto llvmBoxTy = llvmBoxPtrTy.getElementType();
+    mlir::Value descriptor =
+        rewriter.create<mlir::LLVM::UndefOp>(loc, llvmBoxTy);
+
+    llvm::SmallVector<mlir::Value> typeparams = lenParams;
+    if constexpr (!std::is_same_v<BOX, fir::EmboxOp>) {
+      if (!box.substr().empty() && fir::hasDynamicSize(boxTy.getEleTy()))
+        typeparams.push_back(box.substr()[1]);
+    }
+
+    // Write each of the fields with the appropriate values
+    auto [eleSize, cfiTy] =
+        getSizeAndTypeCode(loc, rewriter, boxTy.getEleTy(), typeparams);
+    descriptor =
+        insertField(rewriter, loc, descriptor, {kElemLenPosInBox}, eleSize);
+    descriptor = insertField(rewriter, loc, descriptor, {kVersionPosInBox},
+                             this->genI32Constant(loc, rewriter, CFI_VERSION));
+    descriptor = insertField(rewriter, loc, descriptor, {kRankPosInBox},
+                             this->genI32Constant(loc, rewriter, rank));
+    descriptor = insertField(rewriter, loc, descriptor, {kTypePosInBox}, cfiTy);
+    descriptor =
+        insertField(rewriter, loc, descriptor, {kAttributePosInBox},
+                    this->genI32Constant(loc, rewriter, getCFIAttr(boxTy)));
+    const bool hasAddendum = isDerivedType(boxTy);
+    descriptor =
+        insertField(rewriter, loc, descriptor, {kF18AddendumPosInBox},
+                    this->genI32Constant(loc, rewriter, hasAddendum ? 1 : 0));
+
+    if (hasAddendum) {
+      auto isArray =
+          fir::dyn_cast_ptrOrBoxEleTy(boxTy).template isa<fir::SequenceType>();
+      unsigned typeDescFieldId = isArray ? kOptTypePtrPosInBox : kDimsPosInBox;
+      auto typeDesc =
+          getTypeDescriptor(box, rewriter, loc, unwrapIfDerived(boxTy));
+      descriptor =
+          insertField(rewriter, loc, descriptor, {typeDescFieldId}, typeDesc,
+                      /*bitCast=*/true);
+    }
+
+    return {boxTy, descriptor, eleSize};
+  }
+
+  /// If the embox is not in a globalOp body, allocate storage for the box;
+  /// store the value inside and return the generated alloca. Return the input
+  /// value otherwise.
+  mlir::Value
+  placeInMemoryIfNotGlobalInit(mlir::ConversionPatternRewriter &rewriter,
+                               mlir::Location loc, mlir::Value boxValue) const {
+    auto *thisBlock = rewriter.getInsertionBlock();
+    if (thisBlock && mlir::isa<mlir::LLVM::GlobalOp>(thisBlock->getParentOp()))
+      return boxValue;
+    auto boxPtrTy = mlir::LLVM::LLVMPointerType::get(boxValue.getType());
+    auto alloca = genAllocaWithType(loc, boxPtrTy, defaultAlign, rewriter);
+    rewriter.create<mlir::LLVM::StoreOp>(loc, boxValue, alloca);
+    return alloca;
+  }
+};
+
+/// Create a generic box on a memory reference. This conversions lowers the
+/// abstract box to the appropriate, initialized descriptor.
+struct EmboxOpConversion : public EmboxCommonConversion<fir::EmboxOp> {
+  using EmboxCommonConversion::EmboxCommonConversion;
+
+  mlir::LogicalResult
+  matchAndRewrite(fir::EmboxOp embox, OpAdaptor adaptor,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    assert(!embox.getShape() && "There should be no dims on this embox op");
+    auto [boxTy, dest, eleSize] =
+        consDescriptorPrefix(embox, rewriter, /*rank=*/0,
+                             /*lenParams=*/adaptor.getOperands().drop_front(1));
+    dest = insertBaseAddress(rewriter, embox.getLoc(), dest,
+                             adaptor.getOperands()[0]);
+    if (isDerivedTypeWithLenParams(boxTy))
+      return rewriter.notifyMatchFailure(
+          embox, "fir.embox codegen of derived with length parameters not "
+                 "implemented yet");
+    auto result = placeInMemoryIfNotGlobalInit(rewriter, embox.getLoc(), dest);
+    rewriter.replaceOp(embox, result);
+    return success();
+  }
+};
+
 // Code shared between insert_value and extract_value Ops.
 struct ValueOpCommon {
   // 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();
void runOnOperation() override final {
     pattern.insert<
         AbsentOpConversion, AddcOpConversion, AddrOfOpConversion,
         AllocaOpConversion, BoxAddrOpConversion, BoxCharLenOpConversion,
         BoxDimsOpConversion, BoxEleSizeOpConversion, BoxIsAllocOpConversion,
         BoxIsArrayOpConversion, BoxIsPtrOpConversion, BoxRankOpConversion,
         BoxTypeDescOpConversion, CallOpConversion, CmpcOpConversion,
         ConstcOpConversion, ConvertOpConversion, DispatchOpConversion,
         DispatchTableOpConversion, DTEntryOpConversion, DivcOpConversion,
-        EmboxCharOpConversion, ExtractValueOpConversion, HasValueOpConversion,
-        GenTypeDescOpConversion, GlobalLenOpConversion, GlobalOpConversion,
-        InsertOnRangeOpConversion, InsertValueOpConversion,
+        EmboxOpConversion, EmboxCharOpConversion, ExtractValueOpConversion,
+        HasValueOpConversion, GenTypeDescOpConversion, GlobalLenOpConversion,
+        GlobalOpConversion, InsertOnRangeOpConversion, InsertValueOpConversion,
         IsPresentOpConversion, LoadOpConversion, NegcOpConversion,
         MulcOpConversion, SelectCaseOpConversion, SelectOpConversion,
         SelectRankOpConversion, SelectTypeOpConversion, ShapeOpConversion,
         ShapeShiftOpConversion, ShiftOpConversion, SliceOpConversion,
         StoreOpConversion, StringLitOpConversion, SubcOpConversion,
         UnboxCharOpConversion, UndefOpConversion, UnreachableOpConversion,
         ZeroOpConversion>(typeConverter);
     mlir::populateStdToLLVMConversionPatterns(typeConverter, pattern);

flang/lib/Optimizer/Dialect/FIRType.cpp

 
 unsigned fir::RecordType::getFieldIndex(llvm::StringRef ident) {
   for (auto f : llvm::enumerate(getTypeList()))
     if (ident == f.value().first)
       return f.index();
   return std::numeric_limits<unsigned>::max();
 }
 
+std::string fir::RecordType::getLoweredName() const {
+  auto split = getName().split('T');
+  std::string name = (split.first + "E.dt." + split.second).str();
+  return name;
+}
+
 //===----------------------------------------------------------------------===//
 // ReferenceType
 //===----------------------------------------------------------------------===//
 
 // `ref` `<` type `>`
 mlir::Type fir::ReferenceType::parse(mlir::AsmParser &parser) {
   return parseTypeSingleton<fir::ReferenceType>(parser);
 }

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

 // CHECK-NEXT:  %[[ret_val:.*]] = llvm.call @is_present(%[[ptr]]) : (!llvm.ptr<i64>) -> i1
 // CHECK-NEXT:  llvm.return %[[ret_val]] : i1
 
 // -----
 
 // Test `fir.string_lit` conversion.
 
 func @string_lit0() {
   %1 = fir.string_lit "Hello, World!"(13) : !fir.char<1>
   return
 }
 
 // CHECK-LABEL: llvm.func @string_lit0
 // CHECK: %{{.*}} = llvm.mlir.constant("Hello, World!") : !llvm.array<13 x i8>
 
 func @string_lit1() {
   %2 = fir.string_lit [158, 2345](2) : !fir.char<2>
   return
 }
 
 // CHECK-LABEL: llvm.func @string_lit1
 // %{{.*}} = llvm.mlir.constant(dense<[158, 2345]> : vector<2xi16>) : !llvm.array<2 x i16>
 
 // -----
 
 // Test must be dead conversion.
 
 func @dead_shift() {
   %c0 = arith.constant 0 : index
   %0 = fir.shift %c0 : (index) -> !fir.shift<1>
   return
 }
 
 // CHECK-LABEL: llvm.func @dead_shift
 // CHECK-NOT: fir.shift
 // CHECK: %{{.*}} = llvm.mlir.constant(0 : index) : i{{.*}}
 // CHECK-NEXT: llvm.return
 
 func @dead_shape() {
   %c0 = arith.constant 0 : index
   %0 = fir.shape %c0 : (index) -> !fir.shape<1>
   return
 }
 
 // CHECK-LABEL: llvm.func @dead_shape
 // CHECK-NOT: fir.shape
 // CHECK: %{{.*}} = llvm.mlir.constant(0 : index) : i{{.*}}
 // CHECK-NEXT: llvm.return
 
 func @dead_shapeshift() {
   %c0 = arith.constant 0 : index
   %0 = fir.shape_shift %c0, %c0 : (index, index) -> !fir.shapeshift<1>
   return
 }
 
 // CHECK-LABEL: llvm.func @dead_shapeshift
 // CHECK-NOT: fir.shape_shift
 // CHECK: %{{.*}} = llvm.mlir.constant(0 : index) : i{{.*}}
 // CHECK-NEXT: llvm.return
 
 func @dead_slice() {
   %c0 = arith.constant 0 : index
   %0 = fir.slice %c0, %c0, %c0 : (index, index, index) -> !fir.slice<1>
   return
 }
 
 // CHECK-LABEL: llvm.func @dead_slice
 // CHECK-NOT: fir.slice
 // CHECK: %{{.*}} = llvm.mlir.constant(0 : index) : i{{.*}}
 // CHECK-NEXT: llvm.return
 
 // -----
 
 // Test `fir.box_tdesc` conversion.
 
 func @box_tdesc(%arg0: !fir.box<f64>) {
   %0 = fir.box_tdesc %arg0 : (!fir.box<f64>) -> !fir.tdesc<f64>
   return
 }
 
 // CHECK-LABEL: llvm.func @box_tdesc(
 // CHECK-SAME:                       %[[ARG0:.*]]: !llvm.ptr<struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>) {
 // CHECK:         %[[C0:.*]] = llvm.mlir.constant(0 : i32) : i32
 // CHECK:         %[[TYPE_POS:.*]] = llvm.mlir.constant(4 : i32) : i32
 // CHECK:         %[[GEP:.*]] = llvm.getelementptr %[[ARG0]][%[[C0]], %[[TYPE_POS]]] : (!llvm.ptr<struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>, i32, i32) -> !llvm.ptr<i8>
 // CHECK:         %[[LOAD:.*]] = llvm.load %[[GEP]] : !llvm.ptr<i{{.*}}>
 // CHECK:         %{{.*}} = llvm.inttoptr %[[LOAD]] : i{{.*}} to !llvm.ptr<i{{.*}}>
+
+// -----
+
+// Test `fir.embox` conversion.
+
+// Check basic creation of a descriptor and insertion of values.
+// The indices used to insert values into the descriptor correspond the 
+// position of the fields in the descriptor as defined in `CFI_cdesc_t` in
+// flang/ISO_Fortran_binding.h.
+
+func @embox0(%arg0: !fir.ref<!fir.array<100xi32>>) {
+  %0 = fir.embox %arg0() : (!fir.ref<!fir.array<100xi32>>) -> !fir.box<!fir.array<100xi32>>
+  return
+}
+
+// CHECK-LABEL: func @embox0(
+// CHECK-SAME:               %[[ARG0:.*]]: !llvm.ptr<array<100 x i32>>
+// CHECK:         %[[C1:.*]] = llvm.mlir.constant(1 : i32) : i32
+// CHECK:         %[[ALLOCA:.*]] = llvm.alloca %[[C1]] x !llvm.struct<(ptr<array<100 x i32>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> {alignment = 8 : i64} : (i32) -> !llvm.ptr<struct<(ptr<array<100 x i32>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>
+// CHECK:         %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<array<100 x i32>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
+// CHECK:         %[[ELEM_SIZE:.*]] = llvm.mlir.constant(4 : i32) : i32
+// CHECK:         %[[TYPE_CODE:.*]] = llvm.mlir.constant(9 : i32) : i32
+// CHECK:         %[[I64_ELEM_SIZE:.*]] = llvm.sext %[[ELEM_SIZE]] : i32 to i64
+// CHECK:         %[[DESC0:.*]] = llvm.insertvalue %[[I64_ELEM_SIZE]], %[[DESC]][1 : i32] : !llvm.struct<(ptr<array<100 x i32>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
+// CHECK:         %[[CFI_VERSION:.*]] = llvm.mlir.constant(20180515 : i32) : i32
+// CHECK:         %[[DESC1:.*]] = llvm.insertvalue %[[CFI_VERSION]], %[[DESC0]][2 : i32] : !llvm.struct<(ptr<array<100 x i32>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
+// CHECK:         %[[RANK:.*]] = llvm.mlir.constant(0 : i32) : i32
+// CHECK:         %[[RANK_I8:.*]] = llvm.trunc %[[RANK]] : i32 to i8
+// CHECK:         %[[DESC2:.*]] = llvm.insertvalue %[[RANK_I8]], %[[DESC1]][3 : i32] : !llvm.struct<(ptr<array<100 x i32>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
+// CHECK:         %[[TYPE_CODE_I8:.*]] = llvm.trunc %[[TYPE_CODE]] : i32 to i8
+// CHECK:         %[[DESC3:.*]] = llvm.insertvalue %[[TYPE_CODE_I8]], %[[DESC2]][4 : i32] : !llvm.struct<(ptr<array<100 x i32>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
+// CHECK:         %[[ATTR:.*]] = llvm.mlir.constant(0 : i32) : i32
+// CHECK:         %[[ATTR_I8:.*]] = llvm.trunc %[[ATTR]] : i32 to i8
+// CHECK:         %[[DESC4:.*]] = llvm.insertvalue %[[ATTR_I8]], %[[DESC3]][5 : i32] : !llvm.struct<(ptr<array<100 x i32>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
+// CHECK:         %[[F18ADDENDUM:.*]] = llvm.mlir.constant(0 : i32) : i32
+// CHECK:         %[[F18ADDENDUM_I8:.*]] = llvm.trunc %[[F18ADDENDUM]] : i32 to i8
+// CHECK:         %[[DESC5:.*]] = llvm.insertvalue %[[F18ADDENDUM_I8]], %[[DESC4]][6 : i32] : !llvm.struct<(ptr<array<100 x i32>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
+// CHECK:         %[[ADDR:.*]] = llvm.bitcast %[[ARG0]] : !llvm.ptr<array<100 x i32>> to !llvm.ptr<array<100 x i32>>
+// CHECK:         %[[DESC6:.*]] = llvm.insertvalue %[[ADDR]], %[[DESC5]][0 : i32] : !llvm.struct<(ptr<array<100 x i32>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
+// CHECK:         llvm.store %[[DESC6]], %[[ALLOCA]] : !llvm.ptr<struct<(ptr<array<100 x i32>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>
+
+// Check `fir.embox` in a `fir.global`. Descriptors created by `fir.embox` 
+// conversion are not generating `alloca` instructions. This test make sure of
+// that.
+
+fir.global @box_global : !fir.ref<!fir.array<?xi32>> {
+  %arr = fir.zero_bits !fir.ref<!fir.array<?xi32>>
+  %0 = arith.constant 0 : index
+  %3 = fir.embox %arr: (!fir.ref<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>
+  fir.has_value %arr : !fir.ref<!fir.array<?xi32>>
+}
+
+// CHECK-LABEL: llvm.mlir.global external @box_global
+// CHECK-NOT:     llvm.alloca
+
+// Check `fir.embox` conversion of a POINTER entity. Make sure that the
+// attribute in the descriptor is set to 1 (value of CFI_attribute_pointer
+// in flang/ISO_Fortran_binding.h).
+
+func @embox_pointer(%arg0: !fir.ref<i32>) {
+  %0 = fir.embox %arg0 : (!fir.ref<i32>) -> !fir.box<!fir.ptr<i32>>
+  return
+}
+
+// CHECK-LABEL: llvm.func @embox_pointer
+// Check 1st 1 constant to skip it.
+// CHECK: %{{.*}} = llvm.mlir.constant(1 : i32) : i32
+// CHECK: %[[CFI_ATTR_POINTER:.*]] = llvm.mlir.constant(1 : i32) : i32
+// CHECK: %[[ATTR_I8:.*]] = llvm.trunc %[[CFI_ATTR_POINTER]] : i32 to i8
+// CHECK: %{{.*}} = llvm.insertvalue %[[ATTR_I8]], %{{.*}}[5 : i32] : !llvm.struct<(ptr<i32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
+
+// Check `fir.embox` conversion of an ALLOCATABLE entity. Make sure that the
+// attribute in the descriptor is set to 2 (value of CFI_attribute_allocatable
+// in flang/ISO_Fortran_binding.h).
+
+func @embox_allocatable(%arg0: !fir.heap<!fir.array<?x!fir.char<1,10>>>) {
+  %0 = fir.embox %arg0 : (!fir.heap<!fir.array<?x!fir.char<1,10>>>) -> !fir.box<!fir.heap<!fir.array<?x!fir.char<1,10>>>>
+  return
+}
+
+// CHECK-LABEL: llvm.func @embox_allocatable
+// CHECK: %[[CFI_ATTR_ALLOCATABLE:.*]] = llvm.mlir.constant(2 : i32) : i32
+// CHECK: %[[ATTR_I8:.*]] = llvm.trunc %[[CFI_ATTR_ALLOCATABLE]] : i32 to i8
+// CHECK: %{{.*}} = llvm.insertvalue %[[ATTR_I8]], %{{.*}}[5 : i32] : !llvm.struct<(ptr<array<10 x i8>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
+
+// Check `fir.embox` conversion of a type code.
+
+func @embox_typecode0(%arg0: !fir.ref<i64>) {
+  %0 = fir.embox %arg0 : (!fir.ref<i64>) -> !fir.box<!fir.ptr<i64>>
+  return
+}
+
+// CHECK-LABEL: llvm.func @embox_typecode0
+// CHECK: %[[TYPE_CODE_I64:.*]] = llvm.mlir.constant(10 : i32) : i32
+// CHECK: %[[TYPE_CODE_I64_I8:.*]] = llvm.trunc %[[TYPE_CODE_I64]] : i32 to i8
+// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_I64_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr<i64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
+
+func @embox_typecode1(%arg0: !fir.ref<f32>) {
+  %0 = fir.embox %arg0 : (!fir.ref<f32>) -> !fir.box<!fir.ptr<f32>>
+  return
+}
+
+// CHECK-LABEL: llvm.func @embox_typecode1
+// CHECK: %[[TYPE_CODE_F32:.*]] = llvm.mlir.constant(25 : i32) : i32
+// CHECK: %[[TYPE_CODE_F32_I8:.*]] = llvm.trunc %[[TYPE_CODE_I64]] : i32 to i8
+// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_F32_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr<f32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
+
+func @embox_typecode2(%arg0: !fir.ref<f128>) {
+  %0 = fir.embox %arg0 : (!fir.ref<f128>) -> !fir.box<!fir.ptr<f128>>
+  return
+}
+
+// CHECK-LABEL: llvm.func @embox_typecode2
+// CHECK: %[[TYPE_CODE_F128:.*]] = llvm.mlir.constant(27 : i32) : i32
+// CHECK: %[[TYPE_CODE_F128_I8:.*]] = llvm.trunc %[[TYPE_CODE_F128]] : i32 to i8
+// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_F128_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr<f128>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
+
+func @embox_typecode3(%arg0: !fir.ref<!fir.complex<4>>) {
+  %0 = fir.embox %arg0 : (!fir.ref<!fir.complex<4>>) -> !fir.box<!fir.ptr<!fir.complex<4>>>
+  return
+}
+
+// CHECK-LABEL: llvm.func @embox_typecode3
+// CHECK: %[[TYPE_CODE_CPLX4:.*]] = llvm.mlir.constant(28 : i32) : i32
+// CHECK: %[[TYPE_CODE_CPLX4_I8:.*]] = llvm.trunc %[[TYPE_CODE_F128]] : i32 to i8
+// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_CPLX4_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr<struct<(f32, f32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
+
+func @embox_typecode4(%arg0: !fir.ref<!fir.logical<1>>) {
+  %0 = fir.embox %arg0 : (!fir.ref<!fir.logical<1>>) -> !fir.box<!fir.ptr<!fir.logical<1>>>
+  return
+}
+
+// CHECK-LABEL: llvm.func @embox_typecode4
+// CHECK: %[[TYPE_CODE_I64:.*]] = llvm.mlir.constant(31 : i32) : i32
+// CHECK: %[[TYPE_CODE_I64_I8:.*]] = llvm.trunc %[[TYPE_CODE_I64]] : i32 to i8
+// CHECK: %{{.*}} = llvm.insertvalue %[[TYPE_CODE_I64_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr<i8>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
+
+// -----
+
+// Test `fir.embox` conversion. This test creates a global so it needs to be
+// split from others.
+
+// Check descriptor for a derived type. Check that the f18Addendum flag is set
+// to 1 meaning the addendum is present (true) and the addendum values are
+// inserted.
+
+func @embox1(%arg0: !fir.ref<!fir.type<_QMtest_dinitTtseq{i:i32}>>) {
+  %0 = fir.embox %arg0() : (!fir.ref<!fir.type<_QMtest_dinitTtseq{i:i32}>>) -> !fir.box<!fir.type<_QMtest_dinitTtseq{i:i32}>>
+  return
+}
+
+// CHECK: llvm.mlir.global extern_weak @_QMtest_dinitE.dt.tseq() : i8
+// CHECK-LABEL: llvm.func @embox1
+// CHECK:         %[[TYPE_CODE:.*]] = llvm.mlir.constant(34 : i32) : i32
+// CHECK:         %[[TYPE_CODE_I8:.*]] = llvm.trunc %[[TYPE_CODE]] : i32 to i8
+// CHECK:         %{{.*}} = llvm.insertvalue %[[TYPE_CODE_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr<struct<"_QMtest_dinitTtseq", (i32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i{{.*}}>, array<1 x i{{.*}}>)>
+// CHECK:         %[[F18ADDENDUM:.*]] = llvm.mlir.constant(1 : i32) : i32
+// CHECK:         %[[F18ADDENDUM_I8:.*]] = llvm.trunc %[[F18ADDENDUM]] : i32 to i8
+// CHECK:         %{{.*}} = llvm.insertvalue %[[F18ADDENDUM_I8]], %18[6 : i32] : !llvm.struct<(ptr<struct<"_QMtest_dinitTtseq", (i32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i{{.*}}>, array<1 x i{{.*}}>)>
+// CHECK:         %[[TDESC:.*]] = llvm.mlir.addressof @_QMtest_dinitE.dt.tseq : !llvm.ptr<i8>
+// CHECK:         %[[TDESC_CAST:.*]] = llvm.bitcast %22 : !llvm.ptr<i8> to !llvm.ptr<i8>
+// CHECK:         %{{.*}} = llvm.insertvalue %[[TDESC_CAST]], %{{.*}}[7 : i32] : !llvm.struct<(ptr<struct<"_QMtest_dinitTtseq", (i32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i{{.*}}>, array<1 x i{{.*}}>)>