[flang] [llvm] [Flang] Adding lowering for the allocation and deallocation of coarrays (PR #182110)

[Jean-Didier PAILLEUX via llvm-commits]

https://github.com/JDPailleux updated https://github.com/llvm/llvm-project/pull/182110

>From 3eff8564e9c9c1dee24b95f99bd9a308a7a21503 Mon Sep 17 00:00:00 2001
From: Jean-Didier Pailleux <jean-didier.pailleux at sipearl.com>
Date: Wed, 18 Feb 2026 17:18:30 +0100
Subject: [PATCH 01/13] [Flang] Adding lowering for the allocation and
 deallocation of coarrays

---
 flang-rt/lib/runtime/CMakeLists.txt           |   1 +
 flang-rt/lib/runtime/coarray.cpp              |  38 ++
 flang/include/flang/Lower/MultiImageFortran.h |  19 +
 .../flang/Optimizer/Builder/MIFCommon.h       |  26 ++
 .../flang/Optimizer/Dialect/MIF/MIFOps.td     |  56 +++
 .../Optimizer/Transforms/MIFOpConversion.h    |   4 +-
 flang/include/flang/Runtime/coarray.h         |  24 ++
 flang/lib/Lower/Allocatable.cpp               |  62 ++-
 flang/lib/Lower/ConvertVariable.cpp           |  31 ++
 flang/lib/Lower/MultiImageFortran.cpp         | 130 ++++++
 flang/lib/Optimizer/Builder/CMakeLists.txt    |   1 +
 flang/lib/Optimizer/Builder/MIFCommon.cpp     |  63 +++
 .../lib/Optimizer/Dialect/MIF/CMakeLists.txt  |   1 +
 flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp    |  63 +++
 .../Optimizer/Transforms/MIFOpConversion.cpp  | 398 +++++++++++++++++-
 flang/test/Fir/MIF/change_team.mlir           |  54 +--
 flang/test/Fir/MIF/coarray-alloc.mlir         | 157 +++++++
 flang/test/Fir/MIF/form_team.mlir             |  63 +--
 flang/test/Fir/MIF/get_team.mlir              | 100 ++---
 flang/test/Fir/MIF/sync_team.mlir             |  54 +--
 flang/test/Fir/MIF/team_number.mlir           |  36 +-
 flang/test/Lower/MIF/coarray_allocation.f90   |  63 +++
 22 files changed, 1276 insertions(+), 168 deletions(-)
 create mode 100644 flang-rt/lib/runtime/coarray.cpp
 create mode 100644 flang/include/flang/Optimizer/Builder/MIFCommon.h
 create mode 100644 flang/include/flang/Runtime/coarray.h
 create mode 100644 flang/lib/Optimizer/Builder/MIFCommon.cpp
 create mode 100644 flang/test/Fir/MIF/coarray-alloc.mlir
 create mode 100644 flang/test/Lower/MIF/coarray_allocation.f90

diff --git a/flang-rt/lib/runtime/CMakeLists.txt b/flang-rt/lib/runtime/CMakeLists.txt
index 787d0dbbfb5ca..ea1e671aaf5b7 100644
--- a/flang-rt/lib/runtime/CMakeLists.txt
+++ b/flang-rt/lib/runtime/CMakeLists.txt
@@ -23,6 +23,7 @@ set(supported_sources
   assign.cpp
   buffer.cpp
   character.cpp
+  coarray.cpp
   connection.cpp
   copy.cpp
   derived-api.cpp
diff --git a/flang-rt/lib/runtime/coarray.cpp b/flang-rt/lib/runtime/coarray.cpp
new file mode 100644
index 0000000000000..11589efc16b72
--- /dev/null
+++ b/flang-rt/lib/runtime/coarray.cpp
@@ -0,0 +1,38 @@
+//===-- runtime/coarray.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
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang/Runtime/coarray.h"
+#include "flang-rt/runtime/descriptor.h"
+#include "flang-rt/runtime/type-info.h"
+
+namespace Fortran::runtime {
+
+extern "C" {
+RT_EXT_API_GROUP_BEGIN
+
+void RTDEF(ComputeLastUcobound)(
+    int num_images, const Descriptor &lcobounds, const Descriptor &ucobounds) {
+  int corank = ucobounds.GetDimension(0).Extent();
+  int64_t *lcobounds_ptr = (int64_t *)lcobounds.raw().base_addr;
+  int64_t *ucobounds_ptr = (int64_t *)ucobounds.raw().base_addr;
+  int64_t index = 1;
+  for (int i = 0; i < corank - 1; i++) {
+    index *= ucobounds_ptr[i] - lcobounds_ptr[i] + 1;
+  }
+  if (corank == 1)
+    ucobounds_ptr[0] = num_images - lcobounds_ptr[0] + 1;
+  else if (index < num_images)
+    ucobounds_ptr[corank - 1] =
+        (num_images / index) + (num_images % index != 0);
+  else
+    ucobounds_ptr[corank - 1] = lcobounds_ptr[corank - 1];
+}
+
+RT_EXT_API_GROUP_END
+}
+} // namespace Fortran::runtime
diff --git a/flang/include/flang/Lower/MultiImageFortran.h b/flang/include/flang/Lower/MultiImageFortran.h
index 82d415a219ae9..f029133c046cd 100644
--- a/flang/include/flang/Lower/MultiImageFortran.h
+++ b/flang/include/flang/Lower/MultiImageFortran.h
@@ -59,6 +59,25 @@ void genEndChangeTeamStmt(AbstractConverter &, pft::Evaluation &eval,
 void genFormTeamStatement(AbstractConverter &, pft::Evaluation &eval,
                           const parser::FormTeamStmt &);
 
+//===----------------------------------------------------------------------===//
+// COARRAY utils
+//===----------------------------------------------------------------------===//
+
+mlir::DenseI64ArrayAttr genLowerCoBounds(AbstractConverter &converter,
+                                         mlir::Location loc,
+                                         const semantics::Symbol &sym);
+
+mlir::DenseI64ArrayAttr genUpperCoBounds(AbstractConverter &converter,
+                                         mlir::Location loc,
+                                         const semantics::Symbol &sym);
+
+mlir::Value genAllocateCoarray(
+    AbstractConverter &converter, mlir::Location loc,
+    const semantics::Symbol &sym, mlir::Value addr,
+    const std::optional<Fortran::parser::AllocateCoarraySpec> &allocSpec =
+        std::nullopt,
+    mlir::Value errMsg = {}, bool hasStat = false);
+
 //===----------------------------------------------------------------------===//
 // COARRAY expressions
 //===----------------------------------------------------------------------===//
diff --git a/flang/include/flang/Optimizer/Builder/MIFCommon.h b/flang/include/flang/Optimizer/Builder/MIFCommon.h
new file mode 100644
index 0000000000000..6339c3255d5d8
--- /dev/null
+++ b/flang/include/flang/Optimizer/Builder/MIFCommon.h
@@ -0,0 +1,26 @@
+//===-- MIFCommon.h -------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_OPTIMIZER_TRANSFORMS_MIFCOMMON_H_
+#define FORTRAN_OPTIMIZER_TRANSFORMS_MIFCOMMON_H_
+
+#include "flang/Lower/AbstractConverter.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/MIF/MIFOps.h"
+#include "flang/Runtime/coarray.h"
+#include "mlir/IR/BuiltinOps.h"
+
+static constexpr llvm::StringRef coarrayHandleSuffix = "_coarray_handle";
+
+namespace mif {
+
+std::string getFullUniqName(mlir::Value addr);
+
+} // namespace mif
+
+#endif // FORTRAN_OPTIMIZER_TRANSFORMS_MIFCOMMON_H_
diff --git a/flang/include/flang/Optimizer/Dialect/MIF/MIFOps.td b/flang/include/flang/Optimizer/Dialect/MIF/MIFOps.td
index 0d95123b0f9e5..5a432c04361d6 100644
--- a/flang/include/flang/Optimizer/Dialect/MIF/MIFOps.td
+++ b/flang/include/flang/Optimizer/Dialect/MIF/MIFOps.td
@@ -17,6 +17,7 @@
 include "flang/Optimizer/Dialect/MIF/MIFDialect.td"
 include "flang/Optimizer/Dialect/FIRTypes.td"
 include "flang/Optimizer/Dialect/FIRAttr.td"
+include "mlir/IR/BuiltinAttributes.td"
 
 class mif_Op<string mnemonic, list<Trait> traits>
     : Op<MIFDialect, mnemonic, traits>;
@@ -425,4 +426,59 @@ def mif_TeamNumberOp : mif_Op<"team_number", []> {
   }];
 }
 
+//===----------------------------------------------------------------------===//
+// Allocation and Deallocation
+//===----------------------------------------------------------------------===//
+
+def mif_AllocCoarrayOp
+    : mif_Op<"alloc_coarray", [AttrSizedOperandSegments,
+                               MemoryEffects<[MemAlloc<DefaultResource>]>]> {
+  let summary = "Perform the allocation of a coarray and provide a "
+                "corresponding coarray descriptor";
+
+  let description = [{
+    This operation allocates a coarray and provides the corresponding 
+    coarray descriptor. This call is collective over the current team.
+  }];
+
+  let arguments = (ins StrAttr:$uniq_name,
+      Arg<fir_ReferenceType, "", [MemRead, MemWrite]>:$box,
+      DenseI64ArrayAttr:$lcobounds, DenseI64ArrayAttr:$ucobounds,
+      Arg<Optional<AnyReferenceLike>, "", [MemWrite]>:$stat,
+      Arg<Optional<AnyRefOrBoxType>, "", [MemWrite]>:$errmsg);
+
+  let builders = [OpBuilder<(ins "mlir::Value":$box, "llvm::StringRef":$symName,
+                      "mlir::DenseI64ArrayAttr":$lcobounds,
+                      "mlir::DenseI64ArrayAttr":$ucobounds, "mlir::Value":$stat,
+                      "mlir::Value":$errmsg)>,
+                  OpBuilder<(ins "mlir::Value":$box, "llvm::StringRef":$symName,
+                      "mlir::DenseI64ArrayAttr":$lcobounds,
+                      "mlir::DenseI64ArrayAttr":$ucobounds)>];
+
+  let hasVerifier = 1;
+  let assemblyFormat = [{
+    $box 
+    (`stat` $stat^ )?
+    (`errmsg` $errmsg^ )? 
+    attr-dict `:` functional-type(operands, results)
+  }];
+}
+
+def mif_DeallocCoarrayOp
+    : mif_Op<"dealloc_coarray", [AttrSizedOperandSegments,
+                                 MemoryEffects<[MemFree<DefaultResource>]>]> {
+  let summary = "Perform the deallocation of a coarray";
+  let description = [{
+    This call releases memory allocated by `mif_AllocCoarrayOp` for a coarray.
+  }];
+  let arguments = (ins Arg<fir_ReferenceType, "", [MemFree]>:$coarray,
+      Arg<Optional<AnyReferenceLike>, "", [MemWrite]>:$stat,
+      Arg<Optional<AnyRefOrBoxType>, "", [MemWrite]>:$errmsg);
+
+  let assemblyFormat = [{
+    $coarray (`stat` $stat^ )?  (`errmsg` $errmsg^ )?
+    attr-dict `:` functional-type(operands, results)
+  }];
+}
+
 #endif // FORTRAN_DIALECT_MIF_MIF_OPS
diff --git a/flang/include/flang/Optimizer/Transforms/MIFOpConversion.h b/flang/include/flang/Optimizer/Transforms/MIFOpConversion.h
index 93c724748102c..6b9e71496e847 100644
--- a/flang/include/flang/Optimizer/Transforms/MIFOpConversion.h
+++ b/flang/include/flang/Optimizer/Transforms/MIFOpConversion.h
@@ -20,7 +20,9 @@ class LLVMTypeConverter;
 namespace mif {
 
 /// Patterns that convert MIF operations to runtime calls.
-void populateMIFOpConversionPatterns(mlir::RewritePatternSet &patterns);
+void populateMIFOpConversionPatterns(const fir::LLVMTypeConverter &converter,
+                                     mlir::DataLayout &dl,
+                                     mlir::RewritePatternSet &patterns);
 
 } // namespace mif
 
diff --git a/flang/include/flang/Runtime/coarray.h b/flang/include/flang/Runtime/coarray.h
new file mode 100644
index 0000000000000..4519179489147
--- /dev/null
+++ b/flang/include/flang/Runtime/coarray.h
@@ -0,0 +1,24 @@
+//===-- include/flang/Runtime/coarray.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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_RUNTIME_COARRAY_H
+#define FORTRAN_RUNTIME_COARRAY_H
+
+#include "flang/Runtime/descriptor-consts.h"
+#include "flang/Runtime/entry-names.h"
+
+namespace Fortran::runtime {
+// class Descriptor;
+extern "C" {
+
+void RTDECL(ComputeLastUcobound)(
+    int num_images, const Descriptor &lcobounds, const Descriptor &ucobounds);
+}
+} // namespace Fortran::runtime
+
+#endif // FORTRAN_RUNTIME_COARRAY_H
diff --git a/flang/lib/Lower/Allocatable.cpp b/flang/lib/Lower/Allocatable.cpp
index 1912027f8742d..839a54c651e23 100644
--- a/flang/lib/Lower/Allocatable.cpp
+++ b/flang/lib/Lower/Allocatable.cpp
@@ -18,6 +18,7 @@
 #include "flang/Lower/ConvertVariable.h"
 #include "flang/Lower/IterationSpace.h"
 #include "flang/Lower/Mangler.h"
+#include "flang/Lower/MultiImageFortran.h"
 #include "flang/Lower/OpenACC.h"
 #include "flang/Lower/PFTBuilder.h"
 #include "flang/Lower/Runtime.h"
@@ -29,6 +30,7 @@
 #include "flang/Optimizer/Dialect/CUF/CUFOps.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
+#include "flang/Optimizer/Dialect/MIF/MIFOps.h"
 #include "flang/Optimizer/HLFIR/HLFIROps.h"
 #include "flang/Optimizer/Support/FatalError.h"
 #include "flang/Optimizer/Support/InternalNames.h"
@@ -325,11 +327,12 @@ class AllocateStmtHelper {
   struct Allocation {
     const Fortran::parser::Allocation &alloc;
     const Fortran::semantics::DeclTypeSpec &type;
-    bool hasCoarraySpec() const {
+    const std::optional<Fortran::parser::AllocateCoarraySpec> &
+    getCoarraySpec() const {
       return std::get<std::optional<Fortran::parser::AllocateCoarraySpec>>(
-                 alloc.t)
-          .has_value();
+          alloc.t);
     }
+    bool hasCoarraySpec() const { return getCoarraySpec().has_value(); }
     const Fortran::parser::AllocateObject &getAllocObj() const {
       return std::get<Fortran::parser::AllocateObject>(alloc.t);
     }
@@ -478,6 +481,29 @@ class AllocateStmtHelper {
                             !box.isPointer();
     unsigned allocatorIdx = Fortran::lower::getAllocatorIdx(alloc.getSymbol());
 
+    const Fortran::lower::SomeExpr *expr =
+        Fortran::semantics::GetExpr(alloc.getAllocObj());
+    std::optional<Fortran::evaluate::DataRef> dataRef =
+        !expr ? std::nullopt : Fortran::evaluate::ExtractDataRef(expr);
+    bool isCoarrayAllocate = alloc.hasCoarraySpec();
+
+    if (isCoarrayAllocate) {
+      errorManager.genStatCheck(builder, loc);
+      genAllocateObjectInit(box, allocatorIdx);
+      Fortran::lower::StatementContext stmtCtx;
+      genSetType(alloc, box, loc);
+      genSetDeferredLengthParameters(alloc, box);
+      genAllocateObjectBounds(alloc, box);
+      mlir::Value stat;
+      stat = Fortran::lower::genAllocateCoarray(
+          converter, loc, alloc.getSymbol(), box.getAddr(),
+          alloc.getCoarraySpec(), errorManager.errMsgAddr);
+      fir::factory::syncMutableBoxFromIRBox(builder, loc, box);
+      postAllocationAction(alloc, box);
+      errorManager.assignStat(builder, loc, stat);
+      return;
+    }
+
     if (inlineAllocation &&
         ((isCudaAllocate && isCudaDeviceContext) || !isCudaAllocate)) {
       // Pointers must use PointerAllocate so that their deallocations
@@ -501,8 +527,6 @@ class AllocateStmtHelper {
     // Generate a sequence of runtime calls.
     errorManager.genStatCheck(builder, loc);
     genAllocateObjectInit(box, allocatorIdx);
-    if (alloc.hasCoarraySpec())
-      TODO(loc, "coarray: allocation of a coarray object");
     if (alloc.type.IsPolymorphic())
       genSetType(alloc, box, loc);
     genSetDeferredLengthParameters(alloc, box);
@@ -884,13 +908,32 @@ genDeallocate(fir::FirOpBuilder &builder,
               Fortran::lower::AbstractConverter &converter, mlir::Location loc,
               const fir::MutableBoxValue &box, ErrorManager &errorManager,
               mlir::Value declaredTypeDesc = {},
-              const Fortran::semantics::Symbol *symbol = nullptr) {
+              const Fortran::semantics::Symbol *symbol = nullptr,
+              const Fortran::lower::SomeExpr *allocExpr = nullptr) {
   bool isCudaSymbol = symbol && Fortran::semantics::HasCUDAAttr(*symbol);
   bool isCudaDeviceContext = cuf::isCUDADeviceContext(builder.getRegion());
   bool inlineDeallocation =
       !box.isDerived() && !box.isPolymorphic() && !box.hasAssumedRank() &&
       !box.isUnlimitedPolymorphic() && !errorManager.hasStatSpec() &&
       !useAllocateRuntime && !box.isPointer();
+
+  std::optional<Fortran::evaluate::DataRef> dataRef =
+      !allocExpr ? std::nullopt : Fortran::evaluate::ExtractDataRef(allocExpr);
+  bool isCoarraySymbol = symbol && Fortran::evaluate::IsCoarray(*symbol);
+
+  // Deallocate coarray
+  if (isCoarraySymbol) {
+    mlir::Value ret = builder.createTemporary(loc, builder.getI32Type());
+    mif::DeallocCoarrayOp::create(builder, loc, box.getAddr(), ret,
+                                  errorManager.errMsgAddr);
+    ret = fir::LoadOp::create(builder, loc, ret);
+    fir::factory::syncMutableBoxFromIRBox(builder, loc, box);
+    if (symbol)
+      postDeallocationAction(converter, builder, *symbol);
+    errorManager.assignStat(builder, loc, ret);
+    return ret;
+  }
+
   // Deallocate intrinsic types inline.
   if (inlineDeallocation &&
       ((isCudaSymbol && isCudaDeviceContext) || !isCudaSymbol)) {
@@ -975,6 +1018,8 @@ void Fortran::lower::genDeallocateStmt(
   for (const Fortran::parser::AllocateObject &allocateObject :
        std::get<std::list<Fortran::parser::AllocateObject>>(stmt.t)) {
     const Fortran::semantics::Symbol &symbol = unwrapSymbol(allocateObject);
+    const Fortran::lower::SomeExpr *allocExpr =
+        Fortran::semantics::GetExpr(allocateObject);
     fir::MutableBoxValue box =
         genMutableBoxValue(converter, loc, allocateObject);
     mlir::Value declaredTypeDesc = {};
@@ -987,8 +1032,9 @@ void Fortran::lower::genDeallocateStmt(
               Fortran::lower::getTypeDescAddr(converter, loc, *derivedTypeSpec);
         }
     }
-    mlir::Value beginOpValue = genDeallocate(
-        builder, converter, loc, box, errorManager, declaredTypeDesc, &symbol);
+    mlir::Value beginOpValue =
+        genDeallocate(builder, converter, loc, box, errorManager,
+                      declaredTypeDesc, &symbol, allocExpr);
     preDeallocationAction(converter, builder, beginOpValue, symbol);
   }
   builder.restoreInsertionPoint(insertPt);
diff --git a/flang/lib/Lower/ConvertVariable.cpp b/flang/lib/Lower/ConvertVariable.cpp
index 0ededb364bfea..2e308324d09ae 100644
--- a/flang/lib/Lower/ConvertVariable.cpp
+++ b/flang/lib/Lower/ConvertVariable.cpp
@@ -21,6 +21,7 @@
 #include "flang/Lower/ConvertExprToHLFIR.h"
 #include "flang/Lower/ConvertProcedureDesignator.h"
 #include "flang/Lower/Mangler.h"
+#include "flang/Lower/MultiImageFortran.h"
 #include "flang/Lower/PFTBuilder.h"
 #include "flang/Lower/StatementContext.h"
 #include "flang/Lower/Support/Utils.h"
@@ -36,6 +37,7 @@
 #include "flang/Optimizer/Dialect/FIRAttr.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/MIF/MIFOps.h"
 #include "flang/Optimizer/Dialect/Support/FIRContext.h"
 #include "flang/Optimizer/HLFIR/HLFIROps.h"
 #include "flang/Optimizer/Support/FatalError.h"
@@ -1132,6 +1134,23 @@ static void instantiateLocal(Fortran::lower::AbstractConverter &converter,
       });
     }
   }
+  if (Fortran::evaluate::IsCoarray(var.getSymbol()) &&
+      !Fortran::semantics::IsAllocatableOrPointer(var.getSymbol()) &&
+      !Fortran::semantics::IsDummy(var.getSymbol())) {
+    mlir::Location loc = converter.getCurrentLocation();
+    fir::ExtendedValue exv =
+        converter.getSymbolExtendedValue(var.getSymbol(), &symMap);
+    auto *sym = &var.getSymbol();
+    const Fortran::semantics::Scope &owner = sym->owner();
+    if (owner.kind() != Fortran::semantics::Scope::Kind::MainProgram) {
+      auto *converterPtr = &converter;
+      converter.getFctCtx().attachCleanup([converterPtr, builder, loc, exv]() {
+        mif::DeallocCoarrayOp::create(*builder, loc, fir::getBase(exv),
+                                      /*stat*/ mlir::Value{},
+                                      /*errmsg*/ mlir::Value{});
+      });
+    }
+  }
   if (std::optional<VariableCleanUp> cleanup =
           needDeallocationOrFinalization(var)) {
     auto *builder = &converter.getFirOpBuilder();
@@ -2186,6 +2205,11 @@ void Fortran::lower::mapSymbolAttributes(
   }
 
   if (isDummy) {
+    if (Fortran::evaluate::IsCoarray(sym))
+      // Operation in MIF dialect to create an alias of the coarray not
+      // yet supported (by using the procedure provided by PRIF).
+      TODO(loc, "coarray dummy argument not yet supported.");
+
     mlir::Value dummyArg = symMap.lookupSymbol(sym).getAddr();
     if (lowerToBoxValue(sym, dummyArg, converter)) {
       llvm::SmallVector<mlir::Value> lbounds;
@@ -2480,6 +2504,13 @@ void Fortran::lower::mapSymbolAttributes(
     }
   }
 
+  if (Fortran::evaluate::IsCoarray(sym)) {
+    Fortran::lower::genAllocateCoarray(converter, loc, sym, addr);
+    ::genDeclareSymbol(converter, symMap, sym, addr, len, extents, lbounds,
+                       replace);
+    return;
+  }
+
   // Allocate or extract raw address for the entity
   if (!addr) {
     if (arg) {
diff --git a/flang/lib/Lower/MultiImageFortran.cpp b/flang/lib/Lower/MultiImageFortran.cpp
index 4f5b6a500d24f..a498a10f3e74b 100644
--- a/flang/lib/Lower/MultiImageFortran.cpp
+++ b/flang/lib/Lower/MultiImageFortran.cpp
@@ -15,6 +15,7 @@
 #include "flang/Lower/AbstractConverter.h"
 #include "flang/Lower/SymbolMap.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
+#include "flang/Optimizer/Builder/MIFCommon.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Semantics/expression.h"
@@ -257,6 +258,135 @@ void Fortran::lower::genFormTeamStatement(
                           errMsgAddr);
 }
 
+//===----------------------------------------------------------------------===//
+// COARRAY utils
+//===----------------------------------------------------------------------===//
+
+mlir::DenseI64ArrayAttr
+Fortran::lower::genLowerCoBounds(Fortran::lower::AbstractConverter &converter,
+                                 mlir::Location loc,
+                                 const Fortran::semantics::Symbol &sym) {
+  fir::FirOpBuilder &builder = converter.getFirOpBuilder();
+  mlir::DenseI64ArrayAttr lcobounds;
+
+  if (Fortran::semantics::IsAllocatableOrObjectPointer(&sym))
+    return {};
+  if (const auto *object =
+          sym.GetUltimate()
+              .detailsIf<Fortran::semantics::ObjectEntityDetails>()) {
+    llvm::SmallVector<std::int64_t> lcbs;
+    for (const Fortran::semantics::ShapeSpec &cobounds : object->coshape()) {
+      if (auto lb = cobounds.lbound().GetExplicit()) {
+        if (auto constant = Fortran::evaluate::ToInt64(*lb))
+          lcbs.push_back(*constant);
+        else
+          lcbs.push_back(1); // default lcobounds
+      }
+    }
+    lcobounds = mlir::DenseI64ArrayAttr::get(builder.getContext(), lcbs);
+  }
+  return lcobounds;
+}
+
+mlir::DenseI64ArrayAttr
+Fortran::lower::genUpperCoBounds(Fortran::lower::AbstractConverter &converter,
+                                 mlir::Location loc,
+                                 const Fortran::semantics::Symbol &sym) {
+  fir::FirOpBuilder &builder = converter.getFirOpBuilder();
+  mlir::DenseI64ArrayAttr ucobounds;
+
+  if (Fortran::semantics::IsAllocatableOrObjectPointer(&sym))
+    return {};
+  if (const auto *object =
+          sym.GetUltimate()
+              .detailsIf<Fortran::semantics::ObjectEntityDetails>()) {
+    llvm::SmallVector<std::int64_t> ucbs;
+    for (const Fortran::semantics::ShapeSpec &cobounds : object->coshape()) {
+      if (cobounds.ubound().isStar()) {
+        ucbs.push_back(-1);
+      } else if (auto ub = cobounds.ubound().GetExplicit()) {
+        if (auto constant = Fortran::evaluate::ToInt64(*ub))
+          ucbs.push_back(*constant);
+        else {
+          if (auto lb = cobounds.lbound().GetExplicit()) {
+            if (auto constant2 = Fortran::evaluate::ToInt64(*lb))
+              ucbs.push_back(*constant2);
+            else
+              ucbs.push_back(1); // use lcobound as default value
+          }
+        }
+      }
+    }
+    ucobounds = mlir::DenseI64ArrayAttr::get(builder.getContext(), ucbs);
+  }
+  return ucobounds;
+}
+
+static std::tuple<mlir::DenseI64ArrayAttr, mlir::DenseI64ArrayAttr>
+genCoBoundsAttrs(Fortran::lower::AbstractConverter &converter,
+                 mlir::Location loc,
+                 const Fortran::parser::AllocateCoarraySpec &allocSpec) {
+  fir::FirOpBuilder &builder = converter.getFirOpBuilder();
+  llvm::SmallVector<std::int64_t> lcbs, ucbs;
+
+  const std::list<Fortran::parser::AllocateCoshapeSpec> &coshapeSpecs =
+      std::get<0>(allocSpec.t);
+  for (const Fortran::parser::AllocateCoshapeSpec &coshapeSpec : coshapeSpecs) {
+    std::int64_t lb;
+    if (const std::optional<Fortran::parser::BoundExpr> &lbExpr =
+            std::get<0>(coshapeSpec.t))
+      lb = *Fortran::evaluate::ToInt64(Fortran::semantics::GetExpr(*lbExpr));
+    else
+      lb = 1;
+    lcbs.push_back(lb);
+    ucbs.push_back(*Fortran::evaluate::ToInt64(
+        Fortran::semantics::GetExpr(std::get<1>(coshapeSpec.t))));
+  }
+
+  const std::optional<Fortran::parser::BoundExpr> &lastBound =
+      std::get<1>(allocSpec.t);
+  if (lastBound.has_value())
+    lcbs.push_back(
+        *Fortran::evaluate::ToInt64(Fortran::semantics::GetExpr(*lastBound)));
+  else
+    lcbs.push_back(1);
+  ucbs.push_back(-1);
+
+  mlir::DenseI64ArrayAttr lcobounds =
+      mlir::DenseI64ArrayAttr::get(builder.getContext(), lcbs);
+  mlir::DenseI64ArrayAttr ucobounds =
+      mlir::DenseI64ArrayAttr::get(builder.getContext(), ucbs);
+  return {lcobounds, ucobounds};
+}
+
+mlir::Value Fortran::lower::genAllocateCoarray(
+    Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+    const Fortran::semantics::Symbol &sym, mlir::Value addr,
+    const std::optional<Fortran::parser::AllocateCoarraySpec> &allocSpec,
+    mlir::Value errmsg, bool hasStat) {
+  converter.checkCoarrayEnabled();
+  fir::FirOpBuilder &builder = converter.getFirOpBuilder();
+
+  mlir::Value stat;
+  if (hasStat)
+    stat = builder.createTemporary(loc, builder.getI32Type());
+
+  mlir::DenseI64ArrayAttr lcobounds, ucobounds;
+  if (allocSpec.has_value()) {
+    std::tie(lcobounds, ucobounds) =
+        genCoBoundsAttrs(converter, loc, *allocSpec);
+  } else {
+    lcobounds = Fortran::lower::genLowerCoBounds(converter, loc, sym);
+    ucobounds = Fortran::lower::genUpperCoBounds(converter, loc, sym);
+  }
+  std::string uniqName = mif::getFullUniqName(addr);
+  if (uniqName.empty())
+    uniqName = converter.mangleName(sym);
+  mif::AllocCoarrayOp::create(builder, loc, addr, uniqName, lcobounds,
+                              ucobounds, stat, errmsg);
+  return stat;
+}
+
 //===----------------------------------------------------------------------===//
 // COARRAY expressions
 //===----------------------------------------------------------------------===//
diff --git a/flang/lib/Optimizer/Builder/CMakeLists.txt b/flang/lib/Optimizer/Builder/CMakeLists.txt
index d966c52b29c33..b9f7ae92281c6 100644
--- a/flang/lib/Optimizer/Builder/CMakeLists.txt
+++ b/flang/lib/Optimizer/Builder/CMakeLists.txt
@@ -12,6 +12,7 @@ add_flang_library(FIRBuilder
   HLFIRTools.cpp
   IntrinsicCall.cpp
   LowLevelIntrinsics.cpp
+  MIFCommon.cpp
   MutableBox.cpp
   PPCIntrinsicCall.cpp
   Runtime/Allocatable.cpp
diff --git a/flang/lib/Optimizer/Builder/MIFCommon.cpp b/flang/lib/Optimizer/Builder/MIFCommon.cpp
new file mode 100644
index 0000000000000..e92d4629609a0
--- /dev/null
+++ b/flang/lib/Optimizer/Builder/MIFCommon.cpp
@@ -0,0 +1,63 @@
+//===-- MIFCommon.cpp -------------------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang/Optimizer/Builder/MIFCommon.h"
+#include "flang/Optimizer/Builder/FIRBuilder.h"
+#include "flang/Optimizer/Dialect/MIF/MIFOps.h"
+#include "flang/Optimizer/Dialect/Support/KindMapping.h"
+#include "flang/Optimizer/HLFIR/HLFIROps.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "llvm/ADT/TypeSwitch.h"
+
+std::string mif::getFullUniqName(mlir::Value addr) {
+  mlir::Operation *op = addr.getDefiningOp();
+  if (auto designateOp = mlir::dyn_cast<hlfir::DesignateOp>(op)) {
+    if (designateOp.getComponent())
+      return getFullUniqName(designateOp.getMemref()) + "." +
+             designateOp.getComponent()->getValue().str();
+    return getFullUniqName(designateOp.getMemref());
+  } else if (auto declareOp = mlir::dyn_cast<hlfir::DeclareOp>(op))
+    return declareOp.getUniqName().getValue().str();
+  else if (auto declareOp = mlir::dyn_cast<fir::DeclareOp>(op))
+    return declareOp.getUniqName().getValue().str();
+  else if (auto load = mlir::dyn_cast<fir::LoadOp>(op))
+    return getFullUniqName(load.getMemref());
+  else if (auto ba = mlir::dyn_cast<fir::BoxAddrOp>(op))
+    return getFullUniqName(ba.getVal());
+  else if (auto rb = mlir::dyn_cast<fir::ReboxOp>(op))
+    return getFullUniqName(rb.getBox());
+  else if (auto eb = mlir::dyn_cast<fir::EmboxOp>(op))
+    return getFullUniqName(eb.getMemref());
+  else if (auto ebc = mlir::dyn_cast<fir::EmboxCharOp>(op))
+    return getFullUniqName(ebc.getMemref());
+  else if (auto c = mlir::dyn_cast<fir::CoordinateOp>(op)) {
+    if (c.getFieldIndicesAttr()) {
+      mlir::Type eleTy = fir::getFortranElementType(c.getRef().getType());
+      std::string uniqName = getFullUniqName(c.getRef());
+      for (auto index : c.getIndices()) {
+        llvm::TypeSwitch<fir::IntOrValue>(index)
+            .Case<mlir::IntegerAttr>([&](mlir::IntegerAttr intAttr) {
+              if (auto recordType = llvm::dyn_cast<fir::RecordType>(eleTy)) {
+                int fieldId = intAttr.getInt();
+                if (fieldId < static_cast<int>(recordType.getNumFields())) {
+                  auto nameAndType = recordType.getTypeList()[fieldId];
+                  auto rrr = getFullUniqName(c.getRef()) + "." +
+                             std::get<std::string>(nameAndType);
+                  uniqName += "." + std::get<std::string>(nameAndType);
+                }
+              }
+            })
+            .Case<mlir::Value>(
+                [&](mlir::Value v) { return getFullUniqName(v); });
+      }
+      return uniqName;
+    }
+    return getFullUniqName(c.getRef());
+  }
+  return "";
+}
diff --git a/flang/lib/Optimizer/Dialect/MIF/CMakeLists.txt b/flang/lib/Optimizer/Dialect/MIF/CMakeLists.txt
index d53937ebb49d4..15770dcef126b 100644
--- a/flang/lib/Optimizer/Dialect/MIF/CMakeLists.txt
+++ b/flang/lib/Optimizer/Dialect/MIF/CMakeLists.txt
@@ -8,6 +8,7 @@ add_flang_library(MIFDialect
   LINK_LIBS
   FIRDialect
   FIRDialectSupport
+  HLFIRDialect
 
   LINK_COMPONENTS
   AsmParser
diff --git a/flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp b/flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp
index 8b04226d4063d..9830d3c83a56f 100644
--- a/flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp
+++ b/flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp
@@ -9,11 +9,43 @@
 #include "flang/Optimizer/Dialect/MIF/MIFOps.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIRAttr.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Dialect/MIF/MIFDialect.h"
+#include "flang/Optimizer/HLFIR/HLFIROps.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
 #include "llvm/ADT/SmallVector.h"
+#include <tuple>
+
+// Function used to check if a type has POINTER or ALLOCATABLE component.
+// Currently an allocation of coarray with this kind of component are not yet
+// supported.
+static bool hasAllocatableOrPointerComponent(mlir::Type type) {
+  type = fir::unwrapPassByRefType(type);
+  if (fir::isa_box_type(type))
+    return hasAllocatableOrPointerComponent(type);
+  if (auto recType = mlir::dyn_cast<fir::RecordType>(type)) {
+    for (auto field : recType.getTypeList()) {
+      mlir::Type fieldType = fir::unwrapPassByRefType(field.second);
+      if (mlir::isa<fir::PointerType>(fieldType))
+        return true;
+      if (mlir::isa<fir::HeapType>(fieldType))
+        return true;
+      if (auto fieldRecType = mlir::dyn_cast<fir::RecordType>(fieldType))
+        return hasAllocatableOrPointerComponent(fieldRecType);
+      if (auto seqTy = mlir::dyn_cast<fir::SequenceType>(fieldType)) {
+        if (seqTy.hasUnknownShape() || seqTy.hasDynamicExtents())
+          return true;
+        mlir::Type eleTy = seqTy.getEleTy();
+        if (mlir::isa<fir::PointerType>(eleTy) ||
+            mlir::isa<fir::HeapType>(eleTy))
+          return true;
+      }
+    }
+  }
+  return false;
+}
 
 //===----------------------------------------------------------------------===//
 // NumImagesOp
@@ -202,5 +234,36 @@ static void printChangeTeamOpBody(mlir::OpAsmPrinter &p, mif::ChangeTeamOp op,
                 /*printBlockTerminators=*/true);
 }
 
+//===----------------------------------------------------------------------===//
+// AllocCoarrayOp
+//===----------------------------------------------------------------------===//
+
+void mif::AllocCoarrayOp::build(mlir::OpBuilder &builder,
+                                mlir::OperationState &result, mlir::Value box,
+                                llvm::StringRef symName,
+                                mlir::DenseI64ArrayAttr lcbs,
+                                mlir::DenseI64ArrayAttr ucbs, mlir::Value stat,
+                                mlir::Value errmsg) {
+  mlir::StringAttr nameAttr = builder.getStringAttr(symName);
+  build(builder, result, nameAttr, box, lcbs, ucbs, stat, errmsg);
+}
+
+void mif::AllocCoarrayOp::build(mlir::OpBuilder &builder,
+                                mlir::OperationState &result, mlir::Value box,
+                                llvm::StringRef symName,
+                                mlir::DenseI64ArrayAttr lcbs,
+                                mlir::DenseI64ArrayAttr ucbs) {
+  build(builder, result, symName, box, lcbs, ucbs, /*stat*/ mlir::Value{},
+        /*errmsg*/ mlir::Value{});
+}
+
+llvm::LogicalResult mif::AllocCoarrayOp::verify() {
+  if (hasAllocatableOrPointerComponent(getBox().getType()))
+    TODO(getLoc(),
+         "Derived type coarray with at least one ALLOCATABLE or POINTER "
+         "component");
+  return mlir::success();
+}
+
 #define GET_OP_CLASSES
 #include "flang/Optimizer/Dialect/MIF/MIFOps.cpp.inc"
diff --git a/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp b/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
index fed941c0afbe6..ed7b50e4a8208 100644
--- a/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
+++ b/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
@@ -7,6 +7,12 @@
 //===----------------------------------------------------------------------===//
 
 #include "flang/Optimizer/Transforms/MIFOpConversion.h"
+#include "flang/Lower/ConvertExpr.h"
+#include "flang/Optimizer/Builder/BoxValue.h"
+#include "flang/Optimizer/Builder/Character.h"
+#include "flang/Optimizer/Builder/MIFCommon.h"
+#include "flang/Optimizer/Builder/MutableBox.h"
+#include "flang/Optimizer/Builder/Runtime/Inquiry.h"
 #include "flang/Optimizer/Builder/Runtime/RTBuilder.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/CodeGen/TypeConverter.h"
@@ -16,6 +22,7 @@
 #include "flang/Optimizer/HLFIR/HLFIROps.h"
 #include "flang/Optimizer/Support/DataLayout.h"
 #include "flang/Optimizer/Support/InternalNames.h"
+#include "flang/Runtime/coarray.h"
 #include "flang/Runtime/stop.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/Transforms/DialectConversion.h"
@@ -47,6 +54,239 @@ static mlir::Type getPRIFErrmsgType(fir::FirOpBuilder &builder) {
       builder.getContext(), 1, fir::CharacterType::unknownLen()));
 }
 
+static mlir::Type
+genBoxedSequenceType(mlir::Type eleTy,
+                     std::optional<int64_t> rank = std::nullopt) {
+  if (rank.has_value())
+    return fir::BoxType::get(fir::SequenceType::get({rank.value()}, eleTy));
+  return fir::BoxType::get(
+      fir::SequenceType::get({fir::SequenceType::getUnknownExtent()}, eleTy));
+}
+
+static mlir::Type getCoarrayHandleType(fir::FirOpBuilder &builder,
+                                       mlir::Location loc) {
+  // Defining the coarray handle type
+  std::string handleDTName =
+      fir::NameUniquer::doType({"prif"}, {}, 0, "prif_coarray_handle", {});
+  fir::RecordType handleTy =
+      fir::RecordType::get(builder.getContext(), handleDTName);
+  mlir::Type infoTy =
+      fir::BoxType::get(fir::PointerType::get(builder.getNoneType()));
+  handleTy.finalize({}, {{"info", infoTy}});
+
+  // Checking if the type information was generated
+  fir::TypeInfoOp dt;
+  fir::RecordType parentType{};
+  mlir::OpBuilder::InsertPoint insertPointIfCreated;
+  std::tie(dt, insertPointIfCreated) =
+      builder.createTypeInfoOp(loc, handleTy, parentType);
+  if (insertPointIfCreated.isSet()) {
+    // fir.type_info wasn't built in a previous call.
+    dt->setAttr(dt.getNoInitAttrName(), builder.getUnitAttr());
+    dt->setAttr(dt.getNoDestroyAttrName(), builder.getUnitAttr());
+    dt->setAttr(dt.getNoFinalAttrName(), builder.getUnitAttr());
+    builder.restoreInsertionPoint(insertPointIfCreated);
+    // Create global op
+    // FIXME: replace handleTy by the Derived type that describe handleTy
+    std::string globalName =
+        fir::NameUniquer::getTypeDescriptorName(handleDTName);
+    auto linkage = builder.createLinkOnceODRLinkage();
+    builder.createGlobal(loc, handleTy, globalName, linkage);
+  }
+  return handleTy;
+}
+
+mlir::Value getCoarrayHandle(fir::FirOpBuilder &builder, mlir::Location loc,
+                             mlir::Value coarray) {
+  mlir::Type boxTy = fir::BoxType::get(builder.getNoneType());
+  std::string uniqName = mif::getFullUniqName(coarray);
+  if (!uniqName.empty()) {
+    std::string globalName = uniqName + coarrayHandleSuffix.str();
+    mlir::SymbolRefAttr symAttr =
+        mlir::SymbolRefAttr::get(builder.getContext(), globalName);
+    mlir::Value coarrayHandle =
+        fir::AddrOfOp::create(builder, loc, builder.getRefType(boxTy), symAttr);
+    return fir::LoadOp::create(builder, loc, coarrayHandle);
+  }
+
+  mlir::emitError(coarray.getLoc(),
+                  "Unable to locate the coarray handle for this argument.");
+}
+
+// Function to generate the PRIF runtime function call to retrieve
+// the number of images in the current team
+static mlir::Value getNumImages(fir::FirOpBuilder &builder,
+                                mlir::Location loc) {
+  mlir::Type i32Ty = builder.getI32Type();
+  mlir::Value result = builder.createTemporary(loc, i32Ty);
+  mlir::FunctionType ftype = mlir::FunctionType::get(
+      builder.getContext(),
+      /*inputs*/ {builder.getRefType(i32Ty)}, /*results*/ {});
+  mlir::func::FuncOp funcOp =
+      builder.createFunction(loc, getPRIFProcName("num_images"), ftype);
+  llvm::SmallVector<mlir::Value> args =
+      fir::runtime::createArguments(builder, loc, ftype, result);
+  fir::CallOp::create(builder, loc, funcOp, args);
+  return fir::LoadOp::create(builder, loc, result);
+}
+
+static std::pair<mlir::Value, mlir::Value>
+genCoBounds(fir::FirOpBuilder &builder, mlir::Location loc,
+            mif::AllocCoarrayOp op) {
+  mlir::Value ucobounds, lcobounds;
+  mlir::DenseI64ArrayAttr lcbsAttr = op.getLcoboundsAttr();
+  mlir::DenseI64ArrayAttr ucbsAttr = op.getUcoboundsAttr();
+
+  size_t corank = lcbsAttr.size();
+  mlir::Type i64Ty = builder.getI64Type();
+  mlir::Type addrType = builder.getRefType(i64Ty);
+  mlir::Type arrayType = fir::SequenceType::get(
+      {static_cast<fir::SequenceType::Extent>(corank)}, i64Ty);
+  lcobounds = builder.createTemporary(loc, arrayType);
+  ucobounds = builder.createTemporary(loc, arrayType);
+
+  for (size_t i = 0; i < corank; i++) {
+    auto index = builder.createIntegerConstant(loc, builder.getIndexType(), i);
+    // Lower cobounds
+    auto lcovalue = builder.createIntegerConstant(loc, i64Ty, lcbsAttr[i]);
+    auto lcoaddr =
+        fir::CoordinateOp::create(builder, loc, addrType, lcobounds, index);
+    fir::StoreOp::create(builder, loc, lcovalue, lcoaddr);
+
+    // Upper cobounds
+    auto ucovalue = builder.createIntegerConstant(loc, i64Ty, ucbsAttr[i]);
+    auto ucoaddr =
+        fir::CoordinateOp::create(builder, loc, addrType, ucobounds, index);
+    fir::StoreOp::create(builder, loc, ucovalue, ucoaddr);
+  }
+
+  lcobounds = builder.createBox(loc, lcobounds);
+  ucobounds = builder.createBox(loc, ucobounds);
+
+  // Computing last ucobound
+  mlir::func::FuncOp func =
+      fir::runtime::getRuntimeFunc<mkRTKey(ComputeLastUcobound)>(loc, builder);
+  mlir::Value numImages = getNumImages(builder, loc);
+  llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
+      builder, loc, func.getFunctionType(), numImages, lcobounds, ucobounds);
+  fir::CallOp::create(builder, loc, func, args);
+
+  return {lcobounds, ucobounds};
+}
+
+// Storing the coarray descriptor as a global variable
+void storeCoarrayHandle(fir::FirOpBuilder &builder, mlir::Location loc,
+                        mlir::Value coarrayHandle, std::string uniqName) {
+  std::string globalName = uniqName + coarrayHandleSuffix.str();
+  fir::GlobalOp global = builder.getNamedGlobal(globalName);
+  if (!global) {
+    global = builder.createGlobal(loc, coarrayHandle.getType(), globalName,
+                                  builder.createLinkOnceLinkage());
+    mlir::Region &region = global.getRegion();
+    region.push_back(new mlir::Block);
+    mlir::Block &block = region.back();
+    auto insertPt = builder.saveInsertionPoint();
+    builder.setInsertionPointToStart(&block);
+    auto box = fir::factory::createUnallocatedBox(builder, loc,
+                                                  coarrayHandle.getType(), {});
+    fir::HasValueOp::create(builder, loc, box);
+    builder.restoreInsertionPoint(insertPt);
+  }
+
+  mlir::SymbolRefAttr symAttr =
+      mlir::SymbolRefAttr::get(builder.getContext(), globalName);
+  auto addrOf = fir::AddrOfOp::create(
+      builder, loc, builder.getRefType(coarrayHandle.getType()), symAttr);
+  fir::StoreOp::create(builder, loc, coarrayHandle, addrOf);
+}
+
+static int computeElementByteSize(mlir::Location loc, mlir::Type type,
+                                  fir::KindMapping &kindMap,
+                                  bool emitErrorOnFailure = true) {
+  auto eleTy = fir::unwrapSequenceType(type);
+  if (auto t{mlir::dyn_cast<mlir::IntegerType>(eleTy)})
+    return t.getWidth() / 8;
+  if (auto t{mlir::dyn_cast<mlir::FloatType>(eleTy)})
+    return t.getWidth() / 8;
+  if (auto t{mlir::dyn_cast<fir::LogicalType>(eleTy)})
+    return kindMap.getLogicalBitsize(t.getFKind()) / 8;
+  if (auto t{mlir::dyn_cast<mlir::ComplexType>(eleTy)}) {
+    int elemSize =
+        mlir::cast<mlir::FloatType>(t.getElementType()).getWidth() / 8;
+    return 2 * elemSize;
+  }
+  if (auto t{mlir::dyn_cast<fir::CharacterType>(eleTy)})
+    return kindMap.getCharacterBitsize(t.getFKind()) / 8;
+  if (emitErrorOnFailure)
+    mlir::emitError(loc, "unsupported type");
+  return 0;
+}
+
+// Function used to compute the size in bytes of an entity. This function
+// is used during an allocation of a coarray (or a component of a coarray),
+// as it's a required argument in some PRIF procedures.
+static mlir::Value getSizeInBytes(fir::FirOpBuilder &builder,
+                                  mlir::Location loc, mlir::ModuleOp module,
+                                  mlir::DataLayout *dl,
+                                  const fir::LLVMTypeConverter *typeConverter,
+                                  mlir::Value box) {
+  fir::KindMapping kindMap{fir::getKindMapping(module)};
+  mlir::Type baseTy = fir::unwrapPassByRefType(box.getType());
+
+  mlir::Value sizeInBytes = builder.createTemporary(loc, builder.getI64Type());
+  mlir::Value bytes;
+  if (!mlir::dyn_cast_or_null<fir::BaseBoxType>(baseTy)) {
+    if (fir::isa_trivial(baseTy)) {
+      int width = computeElementByteSize(loc, baseTy, kindMap);
+      bytes = builder.createIntegerConstant(loc, builder.getI64Type(), width);
+    } else if (auto seqTy = mlir::dyn_cast_or_null<fir::SequenceType>(baseTy)) {
+      std::size_t size = 0;
+      if (fir::isa_derived(seqTy.getEleTy())) {
+        mlir::Type structTy = typeConverter->convertType(seqTy.getEleTy());
+        size = dl->getTypeSizeInBits(structTy) / 8;
+      } else {
+        size = computeElementByteSize(loc, seqTy.getEleTy(), kindMap);
+      }
+      mlir::Value width =
+          builder.createIntegerConstant(loc, builder.getI64Type(), size);
+      mlir::Value nbElem;
+      if (fir::sequenceWithNonConstantShape(seqTy)) {
+        // TODO: Not handle for now, but will be do it later.
+        mlir::emitError(loc,
+                        "unsupported sequence type with non constant shape");
+      } else {
+        nbElem = builder.createIntegerConstant(loc, builder.getI64Type(),
+                                               seqTy.getConstantArraySize());
+      }
+      bytes = mlir::arith::MulIOp::create(builder, loc, nbElem, width);
+    } else if (fir::isa_derived(baseTy)) {
+      mlir::Type structTy = typeConverter->convertType(baseTy);
+      std::size_t structSize = dl->getTypeSizeInBits(structTy) / 8;
+      bytes =
+          builder.createIntegerConstant(loc, builder.getI64Type(), structSize);
+    } else if (fir::isa_char(baseTy)) {
+      mlir::Type charTy = typeConverter->convertType(baseTy);
+      std::size_t charSize = dl->getTypeSizeInBits(charTy) / 8;
+      bytes =
+          builder.createIntegerConstant(loc, builder.getI64Type(), charSize);
+    } else {
+      mlir::emitError(loc, "unsupported type in mif allocation\n");
+    }
+  } else {
+    if (fir::isa_ref_type(box.getType()))
+      box = fir::LoadOp::create(builder, loc, box);
+    bytes = fir::BoxEleSizeOp::create(builder, loc, builder.getI64Type(), box);
+    auto boxTy = mlir::dyn_cast_or_null<fir::BaseBoxType>(baseTy);
+    if (fir::extractSequenceType(boxTy)) {
+      mlir::Value extent = builder.createConvert(
+          loc, builder.getI64Type(), fir::runtime::genSize(builder, loc, box));
+      bytes = mlir::arith::MulIOp::create(builder, loc, bytes, extent);
+    }
+  }
+  fir::StoreOp::create(builder, loc, bytes, sizeInBytes);
+  return sizeInBytes;
+}
+
 // Most PRIF functions take `errmsg` and `errmsg_alloc` as two optional
 // arguments of intent (out). One is allocatable, the other is not.
 // It is the responsibility of the compiler to ensure that the appropriate
@@ -805,6 +1045,122 @@ struct MIFTeamNumberOpConversion
   }
 };
 
+/// Convert mif.alloca_coarray operation to runtime call of
+/// 'prif_allocate_coarray'
+struct MIFAllocCoarrayOpConversion
+    : public mlir::OpRewritePattern<mif::AllocCoarrayOp> {
+  using OpRewritePattern::OpRewritePattern;
+
+  MIFAllocCoarrayOpConversion(mlir::MLIRContext *context, mlir::DataLayout *dl,
+                              const fir::LLVMTypeConverter *typeConverter)
+      : OpRewritePattern(context), dl{dl}, typeConverter{typeConverter} {}
+
+  mlir::LogicalResult
+  matchAndRewrite(mif::AllocCoarrayOp op,
+                  mlir::PatternRewriter &rewriter) const override {
+    auto mod = op->template getParentOfType<mlir::ModuleOp>();
+    fir::FirOpBuilder builder(rewriter, mod);
+    mlir::Location loc = op.getLoc();
+
+    mlir::Type i64Ty = builder.getI64Type();
+    mlir::Type ptrTy = fir::PointerType::get(builder.getNoneType());
+    mlir::Type boxTy = fir::BoxType::get(builder.getNoneType());
+    mlir::Type errmsgTy = getPRIFErrmsgType(builder);
+    mlir::Type coboundsTy = genBoxedSequenceType(i64Ty);
+    // Type of the procedure pointed by final_func will be the following :
+    mlir::Type procTypePtr = fir::BoxProcType::get(
+        builder.getContext(),
+        mlir::FunctionType::get(builder.getContext(),
+                                {boxTy, getPRIFStatType(builder), errmsgTy},
+                                {}));
+    mlir::FunctionType ftype = mlir::FunctionType::get(
+        builder.getContext(),
+        /*inputs*/
+        {coboundsTy, coboundsTy, builder.getRefType(i64Ty),
+         builder.getRefType(builder.getNoneType()), boxTy, ptrTy,
+         getPRIFStatType(builder), errmsgTy, errmsgTy},
+        /*results*/ {});
+    mlir::func::FuncOp funcOp =
+        builder.createFunction(loc, getPRIFProcName("allocate_coarray"), ftype);
+
+    // TODO: Handle final_func if needed
+    mlir::Value finalFunc = builder.createTemporary(loc, procTypePtr);
+    mlir::Value nullBoxProc =
+        fir::factory::createNullBoxProc(builder, loc, procTypePtr);
+    fir::StoreOp::create(builder, loc, nullBoxProc, finalFunc);
+    // Allocate instance of prif_coarray_handle type based on the PRIF
+    // specification.
+    mlir::Type handleTy = getCoarrayHandleType(builder, loc);
+    mlir::Value coarrayHandle =
+        builder.createBox(loc, builder.createTemporary(loc, handleTy));
+
+    mlir::Value allocMem = builder.createTemporary(loc, ptrTy);
+    mlir::Value addrCvt =
+        fir::ConvertOp::create(builder, loc, ptrTy, op.getBox());
+    fir::StoreOp::create(builder, loc, addrCvt, allocMem);
+
+    mlir::Value sizeInBytes =
+        getSizeInBytes(builder, loc, mod, dl, typeConverter, op.getBox());
+    auto [lcobounds, ucobounds] = genCoBounds(builder, loc, op);
+    mlir::Value stat = op.getStat();
+    if (!stat)
+      stat = fir::AbsentOp::create(builder, loc, getPRIFStatType(builder));
+    auto [errmsgArg, errmsgAllocArg] =
+        genErrmsgPRIF(builder, loc, op.getErrmsg());
+
+    llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
+        builder, loc, ftype, lcobounds, ucobounds, sizeInBytes, finalFunc,
+        coarrayHandle, allocMem, stat, errmsgArg, errmsgAllocArg);
+    fir::CallOp callOp = fir::CallOp::create(builder, loc, funcOp, args);
+
+    storeCoarrayHandle(builder, loc, coarrayHandle, op.getUniqName().str());
+
+    rewriter.replaceOp(op, callOp);
+    return mlir::success();
+  }
+
+private:
+  mlir::DataLayout *dl;
+  const fir::LLVMTypeConverter *typeConverter;
+};
+
+/// Convert mif.dealloca_coarray operation to runtime call of
+/// 'prif_deallocate_coarray'
+struct MIFDeallocCoarrayOpConversion
+    : public mlir::OpRewritePattern<mif::DeallocCoarrayOp> {
+  using OpRewritePattern::OpRewritePattern;
+
+  mlir::LogicalResult
+  matchAndRewrite(mif::DeallocCoarrayOp op,
+                  mlir::PatternRewriter &rewriter) const override {
+    auto mod = op->template getParentOfType<mlir::ModuleOp>();
+    fir::FirOpBuilder builder(rewriter, mod);
+    mlir::Location loc = op.getLoc();
+
+    mlir::Type errmsgTy = getPRIFErrmsgType(builder);
+    mlir::Type boxTy = fir::BoxType::get(builder.getNoneType());
+    mlir::FunctionType ftype = mlir::FunctionType::get(
+        builder.getContext(),
+        /*inputs*/
+        {boxTy, getPRIFStatType(builder), errmsgTy, errmsgTy},
+        /*results*/ {});
+    mlir::func::FuncOp funcOp = builder.createFunction(
+        loc, getPRIFProcName("deallocate_coarray"), ftype);
+
+    mlir::Value coarrayHandle = getCoarrayHandle(builder, loc, op.getCoarray());
+    mlir::Value stat = op.getStat();
+    if (!stat)
+      stat = fir::AbsentOp::create(builder, loc, getPRIFStatType(builder));
+    auto [errmsgArg, errmsgAllocArg] =
+        genErrmsgPRIF(builder, loc, op.getErrmsg());
+    llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
+        builder, loc, ftype, coarrayHandle, stat, errmsgArg, errmsgAllocArg);
+    fir::CallOp callOp = fir::CallOp::create(builder, loc, funcOp, args);
+    rewriter.replaceOp(op, callOp);
+    return mlir::success();
+  }
+};
+
 class MIFOpConversion : public fir::impl::MIFOpConversionBase<MIFOpConversion> {
 public:
   void runOnOperation() override {
@@ -812,7 +1168,24 @@ class MIFOpConversion : public fir::impl::MIFOpConversionBase<MIFOpConversion> {
     mlir::RewritePatternSet patterns(ctx);
     mlir::ConversionTarget target(*ctx);
 
-    mif::populateMIFOpConversionPatterns(patterns);
+    mlir::Operation *op = getOperation();
+    mlir::ModuleOp module = mlir::dyn_cast<mlir::ModuleOp>(op);
+    if (!module)
+      return signalPassFailure();
+    mlir::SymbolTable symtab(module);
+
+    std::optional<mlir::DataLayout> dl = fir::support::getOrSetMLIRDataLayout(
+        module, /*allowDefaultLayout=*/false);
+    if (!dl.has_value()) {
+      mlir::emitError(
+          module.getLoc(),
+          "data layout attribute is required to perform MIFOpConversion pass");
+      return signalPassFailure();
+    }
+
+    fir::LLVMTypeConverter typeConverter(module, /*applyTBAA=*/false,
+                                         /*forceUnifiedTBAATree=*/false, *dl);
+    mif::populateMIFOpConversionPatterns(typeConverter, *dl, patterns);
 
     target.addLegalDialect<fir::FIROpsDialect>();
     target.addLegalOp<mlir::ModuleOp>();
@@ -827,14 +1200,17 @@ class MIFOpConversion : public fir::impl::MIFOpConversionBase<MIFOpConversion> {
 };
 } // namespace
 
-void mif::populateMIFOpConversionPatterns(mlir::RewritePatternSet &patterns) {
-  patterns.insert<MIFInitOpConversion, MIFThisImageOpConversion,
-                  MIFNumImagesOpConversion, MIFSyncAllOpConversion,
-                  MIFSyncImagesOpConversion, MIFSyncMemoryOpConversion,
-                  MIFSyncTeamOpConversion, MIFCoBroadcastOpConversion,
-                  MIFCoMaxOpConversion, MIFCoMinOpConversion,
-                  MIFCoSumOpConversion, MIFFormTeamOpConversion,
-                  MIFChangeTeamOpConversion, MIFEndTeamOpConversion,
-                  MIFGetTeamOpConversion, MIFTeamNumberOpConversion>(
-      patterns.getContext());
+void mif::populateMIFOpConversionPatterns(
+    const fir::LLVMTypeConverter &converter, mlir::DataLayout &dl,
+    mlir::RewritePatternSet &patterns) {
+  patterns.insert<MIFAllocCoarrayOpConversion>(patterns.getContext(), &dl,
+                                               &converter);
+  patterns.insert<
+      MIFInitOpConversion, MIFThisImageOpConversion, MIFNumImagesOpConversion,
+      MIFSyncAllOpConversion, MIFSyncImagesOpConversion,
+      MIFSyncMemoryOpConversion, MIFSyncTeamOpConversion,
+      MIFCoBroadcastOpConversion, MIFCoMaxOpConversion, MIFCoMinOpConversion,
+      MIFCoSumOpConversion, MIFFormTeamOpConversion, MIFChangeTeamOpConversion,
+      MIFEndTeamOpConversion, MIFGetTeamOpConversion, MIFTeamNumberOpConversion,
+      MIFDeallocCoarrayOpConversion>(patterns.getContext());
 }
diff --git a/flang/test/Fir/MIF/change_team.mlir b/flang/test/Fir/MIF/change_team.mlir
index 1dbfee574cc51..2d7f4c682944d 100644
--- a/flang/test/Fir/MIF/change_team.mlir
+++ b/flang/test/Fir/MIF/change_team.mlir
@@ -1,32 +1,34 @@
 // RUN: fir-opt --mif-convert %s | FileCheck %s
 
-func.func @_QQmain() attributes {fir.bindc_name = "TEST_CHANGE_TEAM"} {
-  %0 = fir.dummy_scope : !fir.dscope
-  %c10 = arith.constant 10 : index
-  %1 = fir.alloca !fir.char<1,10> {bindc_name = "err", uniq_name = "_QFEerr"}
-  %2:2 = hlfir.declare %1 typeparams %c10 {uniq_name = "_QFEerr"} : (!fir.ref<!fir.char<1,10>>, index) -> (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,10>>)
-  %3 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFEi"}
-  %4:2 = hlfir.declare %3 {uniq_name = "_QFEi"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
-  %5 = fir.alloca i32 {bindc_name = "stat", uniq_name = "_QFEstat"}
-  %6:2 = hlfir.declare %5 {uniq_name = "_QFEstat"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
-  %7 = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}> {bindc_name = "team", uniq_name = "_QFEteam"}
-  %8:2 = hlfir.declare %7 {uniq_name = "_QFEteam"} : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
-  %9 = fir.address_of(@_QQ_QM__fortran_builtinsT__builtin_team_type.DerivedInit) : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  fir.copy %9 to %8#0 no_overlap : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  %10 = fir.embox %8#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  mif.change_team %10 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) {
-    %13 = fir.load %4#0 : !fir.ref<i32>
-    %c1_i32 = arith.constant 1 : i32
-    %14 = arith.addi %13, %c1_i32 : i32
-    hlfir.assign %14 to %4#0 : i32, !fir.ref<i32>
-    mif.end_team : () -> ()
+module attributes {dlti.dl_spec = #dlti.dl_spec<!llvm.ptr<270> = dense<32> : vector<4xi64>, !llvm.ptr<271> = dense<32> : vector<4xi64>, !llvm.ptr<272> = dense<64> : vector<4xi64>, i64 = dense<64> : vector<2xi64>, i128 = dense<128> : vector<2xi64>, f80 = dense<128> : vector<2xi64>, !llvm.ptr = dense<64> : vector<4xi64>, i1 = dense<8> : vector<2xi64>, i8 = dense<8> : vector<2xi64>, i16 = dense<16> : vector<2xi64>, i32 = dense<32> : vector<2xi64>, f16 = dense<16> : vector<2xi64>, f64 = dense<64> : vector<2xi64>, f128 = dense<128> : vector<2xi64>, "dlti.endianness" = "little", "dlti.mangling_mode" = "e", "dlti.legal_int_widths" = array<i32: 8, 16, 32, 64>, "dlti.stack_alignment" = 128 : i64>, fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128", llvm.ident = "flang version 22.0.0 (git at github.com:SiPearl/llvm-project.git 666e4313ebc03587f27774139ad8f780bac15c3e)", llvm.target_triple = "x86_64-unknown-linux-gnu"} {
+  func.func @_QQmain() attributes {fir.bindc_name = "TEST_CHANGE_TEAM"} {
+    %0 = fir.dummy_scope : !fir.dscope
+    %c10 = arith.constant 10 : index
+    %1 = fir.alloca !fir.char<1,10> {bindc_name = "err", uniq_name = "_QFEerr"}
+    %2:2 = hlfir.declare %1 typeparams %c10 {uniq_name = "_QFEerr"} : (!fir.ref<!fir.char<1,10>>, index) -> (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,10>>)
+    %3 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFEi"}
+    %4:2 = hlfir.declare %3 {uniq_name = "_QFEi"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+    %5 = fir.alloca i32 {bindc_name = "stat", uniq_name = "_QFEstat"}
+    %6:2 = hlfir.declare %5 {uniq_name = "_QFEstat"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+    %7 = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}> {bindc_name = "team", uniq_name = "_QFEteam"}
+    %8:2 = hlfir.declare %7 {uniq_name = "_QFEteam"} : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
+    %9 = fir.address_of(@_QQ_QM__fortran_builtinsT__builtin_team_type.DerivedInit) : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    fir.copy %9 to %8#0 no_overlap : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    %10 = fir.embox %8#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    mif.change_team %10 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) {
+      %13 = fir.load %4#0 : !fir.ref<i32>
+      %c1_i32 = arith.constant 1 : i32
+      %14 = arith.addi %13, %c1_i32 : i32
+      hlfir.assign %14 to %4#0 : i32, !fir.ref<i32>
+      mif.end_team : () -> ()
+    }
+    %11 = fir.embox %2#0 : (!fir.ref<!fir.char<1,10>>) -> !fir.box<!fir.char<1,10>>
+    %12 = fir.embox %8#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    mif.change_team %12 stat %6#0 errmsg %11 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<i32>, !fir.box<!fir.char<1,10>>) {
+      mif.end_team : () -> ()
+    }
+    return
   }
-  %11 = fir.embox %2#0 : (!fir.ref<!fir.char<1,10>>) -> !fir.box<!fir.char<1,10>>
-  %12 = fir.embox %8#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  mif.change_team %12 stat %6#0 errmsg %11 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<i32>, !fir.box<!fir.char<1,10>>) {
-    mif.end_team : () -> ()
-  }
-  return
 }
 
 // CHECK: %[[VAL_1:.*]] = fir.absent !fir.ref<i32>
diff --git a/flang/test/Fir/MIF/coarray-alloc.mlir b/flang/test/Fir/MIF/coarray-alloc.mlir
new file mode 100644
index 0000000000000..f85a2bd46d004
--- /dev/null
+++ b/flang/test/Fir/MIF/coarray-alloc.mlir
@@ -0,0 +1,157 @@
+// RUN: fir-opt --mif-convert %s | FileCheck %s
+
+module attributes {dlti.dl_spec = #dlti.dl_spec<!llvm.ptr<270> = dense<32> : vector<4xi64>, !llvm.ptr<271> = dense<32> : vector<4xi64>, !llvm.ptr<272> = dense<64> : vector<4xi64>, i64 = dense<64> : vector<2xi64>, i128 = dense<128> : vector<2xi64>, f80 = dense<128> : vector<2xi64>, !llvm.ptr = dense<64> : vector<4xi64>, i1 = dense<8> : vector<2xi64>, i8 = dense<8> : vector<2xi64>, i16 = dense<16> : vector<2xi64>, i32 = dense<32> : vector<2xi64>, f16 = dense<16> : vector<2xi64>, f64 = dense<64> : vector<2xi64>, f128 = dense<128> : vector<2xi64>, "dlti.endianness" = "little", "dlti.mangling_mode" = "e", "dlti.legal_int_widths" = array<i32: 8, 16, 32, 64>, "dlti.stack_alignment" = 128 : i64>, fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128", llvm.ident = "flang version 23.0.0 (git at github.com:SiPearl/llvm-project.git 19de25e93ebb883ee9ea006994d81c61a4817131)", llvm.target_triple = "x86_64-unknown-linux-gnu"} {
+// CHECK-LABEL: func.func @_QQmain
+  func.func @_QQmain() attributes {fir.bindc_name = "ALLOC_TEST"} {
+    %0 = fir.alloca i32
+    %1 = fir.alloca i32
+    %2 = fir.alloca i32
+    %3 = fir.alloca i32
+    %4 = fir.alloca i32
+    %5 = fir.alloca i32
+    %6 = fir.dummy_scope : !fir.dscope
+    %7 = fir.address_of(@_QFE.n.my_type2) : !fir.ref<!fir.char<1,8>>
+    %c8 = arith.constant 8 : index
+    %8:2 = hlfir.declare %7 typeparams %c8 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.my_type2"} : (!fir.ref<!fir.char<1,8>>, index) -> (!fir.ref<!fir.char<1,8>>, !fir.ref<!fir.char<1,8>>)
+    %9 = fir.address_of(@_QFE.n.co) : !fir.ref<!fir.char<1,2>>
+    %c2 = arith.constant 2 : index
+    %10:2 = hlfir.declare %9 typeparams %c2 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.co"} : (!fir.ref<!fir.char<1,2>>, index) -> (!fir.ref<!fir.char<1,2>>, !fir.ref<!fir.char<1,2>>)
+    %11 = fir.address_of(@_QFE.n.x) : !fir.ref<!fir.char<1>>
+    %c1 = arith.constant 1 : index
+    %12:2 = hlfir.declare %11 typeparams %c1 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.x"} : (!fir.ref<!fir.char<1>>, index) -> (!fir.ref<!fir.char<1>>, !fir.ref<!fir.char<1>>)
+    %13 = fir.address_of(@_QFE.n.y) : !fir.ref<!fir.char<1>>
+    %c1_0 = arith.constant 1 : index
+    %14:2 = hlfir.declare %13 typeparams %c1_0 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.y"} : (!fir.ref<!fir.char<1>>, index) -> (!fir.ref<!fir.char<1>>, !fir.ref<!fir.char<1>>)
+    %15 = fir.address_of(@_QFE.n.z) : !fir.ref<!fir.char<1>>
+    %c1_1 = arith.constant 1 : index
+    %16:2 = hlfir.declare %15 typeparams %c1_1 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.z"} : (!fir.ref<!fir.char<1>>, index) -> (!fir.ref<!fir.char<1>>, !fir.ref<!fir.char<1>>)
+    %17 = fir.address_of(@_QFE.n.w) : !fir.ref<!fir.char<1>>
+    %c1_2 = arith.constant 1 : index
+    %18:2 = hlfir.declare %17 typeparams %c1_2 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.w"} : (!fir.ref<!fir.char<1>>, index) -> (!fir.ref<!fir.char<1>>, !fir.ref<!fir.char<1>>)
+    %19 = fir.address_of(@_QFE.n.my_type) : !fir.ref<!fir.char<1,7>>
+    %c7 = arith.constant 7 : index
+    %20:2 = hlfir.declare %19 typeparams %c7 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.my_type"} : (!fir.ref<!fir.char<1,7>>, index) -> (!fir.ref<!fir.char<1,7>>, !fir.ref<!fir.char<1,7>>)
+    %21 = fir.address_of(@_QFE.n.my_type3) : !fir.ref<!fir.char<1,8>>
+    %c8_3 = arith.constant 8 : index
+    %22:2 = hlfir.declare %21 typeparams %c8_3 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.my_type3"} : (!fir.ref<!fir.char<1,8>>, index) -> (!fir.ref<!fir.char<1,8>>, !fir.ref<!fir.char<1,8>>)
+    %23 = fir.address_of(@_QFEa) : !fir.ref<i32>
+
+// CHECK: fir.call @_QMprifPprif_allocate_coarray({{.*}}) : (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>, !fir.ref<i64>, !fir.ref<none>, !fir.box<none>, !fir.ptr<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
+    mif.alloc_coarray %23 {lcobounds = array<i64: 1, 1>, ucobounds = array<i64: 2, -1>, uniq_name = "_QFEa"} : (!fir.ref<i32>) -> ()
+    %24:2 = hlfir.declare %23 {uniq_name = "_QFEa"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+    %25 = fir.address_of(@_QFEa2) : !fir.ref<!fir.box<!fir.heap<i32>>>
+    %26:2 = hlfir.declare %25 {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFEa2"} : (!fir.ref<!fir.box<!fir.heap<i32>>>) -> (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<!fir.box<!fir.heap<i32>>>)
+    %27 = fir.address_of(@_QFEb) : !fir.ref<f32>
+
+// CHECK: fir.call @_QMprifPprif_allocate_coarray({{.*}}) : (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>, !fir.ref<i64>, !fir.ref<none>, !fir.box<none>, !fir.ptr<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
+    mif.alloc_coarray %27 {lcobounds = array<i64: 3, 1, 1>, ucobounds = array<i64: 4, 5, -1>, uniq_name = "_QFEb"} : (!fir.ref<f32>) -> ()
+    %28:2 = hlfir.declare %27 {uniq_name = "_QFEb"} : (!fir.ref<f32>) -> (!fir.ref<f32>, !fir.ref<f32>)
+    %29 = fir.address_of(@_QFEb2) : !fir.ref<!fir.box<!fir.heap<f32>>>
+    %30:2 = hlfir.declare %29 {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFEb2"} : (!fir.ref<!fir.box<!fir.heap<f32>>>) -> (!fir.ref<!fir.box<!fir.heap<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>)
+    %31 = fir.address_of(@_QFEc) : !fir.ref<!fir.char<1,10>>
+    %c10 = arith.constant 10 : index
+
+// CHECK: fir.call @_QMprifPprif_allocate_coarray({{.*}}) : (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>, !fir.ref<i64>, !fir.ref<none>, !fir.box<none>, !fir.ptr<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
+    mif.alloc_coarray %31 {lcobounds = array<i64: 1>, ucobounds = array<i64: -1>, uniq_name = "_QFEc"} : (!fir.ref<!fir.char<1,10>>) -> ()
+    %32:2 = hlfir.declare %31 typeparams %c10 {uniq_name = "_QFEc"} : (!fir.ref<!fir.char<1,10>>, index) -> (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,10>>)
+    %33 = fir.address_of(@_QFEc2) : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>
+    %34:2 = hlfir.declare %33 {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFEc2"} : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>) -> (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>)
+    %35 = fir.address_of(@_QFEd) : !fir.ref<!fir.type<_QFTmy_type{x:i32,y:!fir.box<!fir.heap<!fir.array<?xi32>>>,z:!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>}>>
+    %36:2 = hlfir.declare %35 {uniq_name = "_QFEd"} : (!fir.ref<!fir.type<_QFTmy_type{x:i32,y:!fir.box<!fir.heap<!fir.array<?xi32>>>,z:!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>}>>) -> (!fir.ref<!fir.type<_QFTmy_type{x:i32,y:!fir.box<!fir.heap<!fir.array<?xi32>>>,z:!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>}>>, !fir.ref<!fir.type<_QFTmy_type{x:i32,y:!fir.box<!fir.heap<!fir.array<?xi32>>>,z:!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>}>>)
+    %37 = fir.address_of(@_QFEd2) : !fir.ref<!fir.type<_QFTmy_type3{w:!fir.box<!fir.heap<!fir.array<?xi32>>>}>>
+
+    %38:2 = hlfir.declare %37 {uniq_name = "_QFEd2"} : (!fir.ref<!fir.type<_QFTmy_type3{w:!fir.box<!fir.heap<!fir.array<?xi32>>>}>>) -> (!fir.ref<!fir.type<_QFTmy_type3{w:!fir.box<!fir.heap<!fir.array<?xi32>>>}>>, !fir.ref<!fir.type<_QFTmy_type3{w:!fir.box<!fir.heap<!fir.array<?xi32>>>}>>)
+    %39 = fir.address_of(@_QFE.c.my_type2) : !fir.ref<!fir.array<1x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>
+    %c0 = arith.constant 0 : index
+    %c1_4 = arith.constant 1 : index
+    %40 = fir.shape_shift %c0, %c1_4 : (index, index) -> !fir.shapeshift<1>
+    %41:2 = hlfir.declare %39(%40) {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.c.my_type2"} : (!fir.ref<!fir.array<1x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>, !fir.shapeshift<1>) -> (!fir.box<!fir.array<1x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>, !fir.ref<!fir.array<1x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>)
+    %42 = fir.address_of(@_QFE.c.my_type3) : !fir.ref<!fir.array<1x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>
+    %c0_5 = arith.constant 0 : index
+    %c1_6 = arith.constant 1 : index
+    %43 = fir.shape_shift %c0_5, %c1_6 : (index, index) -> !fir.shapeshift<1>
+    %44:2 = hlfir.declare %42(%43) {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.c.my_type3"} : (!fir.ref<!fir.array<1x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>, !fir.shapeshift<1>) -> (!fir.box<!fir.array<1x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>, !fir.ref<!fir.array<1x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>)
+    %45 = fir.address_of(@_QFE.dt.my_type) : !fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>
+    %46:2 = hlfir.declare %45 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.dt.my_type"} : (!fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>) -> (!fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>, !fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>)
+    %47 = fir.address_of(@_QFE.dt.my_type3) : !fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>
+    %48:2 = hlfir.declare %47 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.dt.my_type3"} : (!fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>) -> (!fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>, !fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>)
+    %49 = fir.address_of(@_QFE.dt.my_type2) : !fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>
+    %50:2 = hlfir.declare %49 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.dt.my_type2"} : (!fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>) -> (!fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>, !fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>)
+    %51 = fir.address_of(@_QFE.c.my_type) : !fir.ref<!fir.array<3x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>
+    %c0_7 = arith.constant 0 : index
+    %c3 = arith.constant 3 : index
+    %52 = fir.shape_shift %c0_7, %c3 : (index, index) -> !fir.shapeshift<1>
+    %53:2 = hlfir.declare %51(%52) {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.c.my_type"} : (!fir.ref<!fir.array<3x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>, !fir.shapeshift<1>) -> (!fir.box<!fir.array<3x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>, !fir.ref<!fir.array<3x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>)
+    %54 = fir.absent !fir.box<none>
+
+// CHECK: fir.call @_QMprifPprif_allocate_coarray({{.*}}) : (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>, !fir.ref<i64>, !fir.ref<none>, !fir.box<none>, !fir.ptr<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
+    mif.alloc_coarray %26#0 errmsg %54 {lcobounds = array<i64: 1, 1>, ucobounds = array<i64: 2, -1>, uniq_name = "_QFEa2"} : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.box<none>) -> ()
+    %55 = fir.absent !fir.box<none>
+
+// CHECK: fir.call @_QMprifPprif_allocate_coarray({{.*}}) : (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>, !fir.ref<i64>, !fir.ref<none>, !fir.box<none>, !fir.ptr<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
+    mif.alloc_coarray %30#0 errmsg %55 {lcobounds = array<i64: 3, 1, 1>, ucobounds = array<i64: 4, 5, -1>, uniq_name = "_QFEb2"} : (!fir.ref<!fir.box<!fir.heap<f32>>>, !fir.box<none>) -> ()
+    %c100_i32 = arith.constant 100 : i32
+    %56 = fir.absent !fir.box<none>
+    %c1_i32 = arith.constant 1 : i32
+    %c1_i32_8 = arith.constant 1 : i32
+    %c0_i32 = arith.constant 0 : i32
+    %57 = fir.convert %34#0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>) -> !fir.ref<!fir.box<none>>
+    %58 = fir.convert %c100_i32 : (i32) -> i64
+    fir.call @_FortranAAllocatableInitCharacterForAllocate(%57, %58, %c1_i32, %c1_i32_8, %c0_i32) fastmath<contract> : (!fir.ref<!fir.box<none>>, i64, i32, i32, i32) -> ()
+    %c1_9 = arith.constant 1 : index
+    %c5_i32 = arith.constant 5 : i32
+    %c0_i32_10 = arith.constant 0 : i32
+    %59 = fir.convert %34#0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>) -> !fir.ref<!fir.box<none>>
+    %60 = fir.convert %c1_9 : (index) -> i64
+    %61 = fir.convert %c5_i32 : (i32) -> i64
+    fir.call @_FortranAAllocatableSetBounds(%59, %c0_i32_10, %60, %61) fastmath<contract> : (!fir.ref<!fir.box<none>>, i32, i64, i64) -> ()
+
+// CHECK: fir.call @_QMprifPprif_allocate_coarray({{.*}}) : (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>, !fir.ref<i64>, !fir.ref<none>, !fir.box<none>, !fir.ptr<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
+    mif.alloc_coarray %34#0 errmsg %56 {lcobounds = array<i64: 1>, ucobounds = array<i64: -1>, uniq_name = "_QFEc2"} : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>, !fir.box<none>) -> ()
+    %62 = fir.absent !fir.box<none>
+    %63 = hlfir.designate %36#0{"z"}   : (!fir.ref<!fir.type<_QFTmy_type{x:i32,y:!fir.box<!fir.heap<!fir.array<?xi32>>>,z:!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>}>>) -> !fir.ref<!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>>
+    %64 = hlfir.designate %63{"co"}   {fortran_attrs = #fir.var_attrs<allocatable>} : (!fir.ref<!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>>) -> !fir.ref<!fir.box<!fir.heap<i32>>>
+
+// CHECK: fir.call @_QMprifPprif_allocate_coarray({{.*}}) : (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>, !fir.ref<i64>, !fir.ref<none>, !fir.box<none>, !fir.ptr<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
+    mif.alloc_coarray %64 errmsg %62 {lcobounds = array<i64: 1>, ucobounds = array<i64: -1>, uniq_name = "_QFEd.z.co"} : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.box<none>) -> ()
+    %65 = fir.absent !fir.box<none>
+    %66 = hlfir.designate %38#0{"w"}   {fortran_attrs = #fir.var_attrs<allocatable>} : (!fir.ref<!fir.type<_QFTmy_type3{w:!fir.box<!fir.heap<!fir.array<?xi32>>>}>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
+    %c1_11 = arith.constant 1 : index
+    %c100_i32_12 = arith.constant 100 : i32
+    %c0_i32_13 = arith.constant 0 : i32
+    %67 = fir.convert %66 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
+    %68 = fir.convert %c1_11 : (index) -> i64
+    %69 = fir.convert %c100_i32_12 : (i32) -> i64
+    fir.call @_FortranAAllocatableSetBounds(%67, %c0_i32_13, %68, %69) fastmath<contract> : (!fir.ref<!fir.box<none>>, i32, i64, i64) -> ()
+
+    %70 = fir.absent !fir.box<none>
+// CHECK: fir.call @_QMprifPprif_deallocate_coarray({{.*}}) : (!fir.box<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
+    mif.dealloc_coarray %26#0 stat %4 errmsg %70 : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<i32>, !fir.box<none>) -> ()
+
+// CHECK: fir.call @_QMprifPprif_deallocate_coarray({{.*}}) : (!fir.box<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
+    mif.dealloc_coarray %30#0 stat %3 errmsg %70 : (!fir.ref<!fir.box<!fir.heap<f32>>>, !fir.ref<i32>, !fir.box<none>) -> ()
+
+// CHECK: fir.call @_QMprifPprif_deallocate_coarray({{.*}}) : (!fir.box<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
+    mif.dealloc_coarray %34#0 stat %2 errmsg %70 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>, !fir.ref<i32>, !fir.box<none>) -> ()
+    %71 = fir.absent !fir.box<none>
+    %72 = hlfir.designate %36#0{"z"}   : (!fir.ref<!fir.type<_QFTmy_type{x:i32,y:!fir.box<!fir.heap<!fir.array<?xi32>>>,z:!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>}>>) -> !fir.ref<!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>>
+    %73 = hlfir.designate %72{"co"}   {fortran_attrs = #fir.var_attrs<allocatable>} : (!fir.ref<!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>>) -> !fir.ref<!fir.box<!fir.heap<i32>>>
+
+// CHECK: fir.call @_QMprifPprif_deallocate_coarray({{.*}}) : (!fir.box<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
+    mif.dealloc_coarray %73 stat %1 errmsg %71 : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<i32>, !fir.box<none>) -> ()
+    %74 = fir.absent !fir.box<none>
+    %75 = hlfir.designate %38#0{"w"}   {fortran_attrs = #fir.var_attrs<allocatable>} : (!fir.ref<!fir.type<_QFTmy_type3{w:!fir.box<!fir.heap<!fir.array<?xi32>>>}>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
+    return
+  }
+}
+
+
+// CHECK: fir.global linkonce_odr @_QMprifE.dt.prif_coarray_handle : !fir.type<_QMprifTprif_coarray_handle{info:!fir.box<!fir.ptr<none>>}>
+// CHECK: fir.global linkonce @_QFEa_coarray_handle : !fir.box<!fir.type<_QMprifTprif_coarray_handle{info:!fir.box<!fir.ptr<none>>}>>
+// CHECK: fir.global linkonce @_QFEb_coarray_handle : !fir.box<!fir.type<_QMprifTprif_coarray_handle{info:!fir.box<!fir.ptr<none>>}>>
+// CHECK: fir.global linkonce @_QFEc_coarray_handle : !fir.box<!fir.type<_QMprifTprif_coarray_handle{info:!fir.box<!fir.ptr<none>>}>>
+// CHECK: fir.global linkonce @_QFEa2_coarray_handle : !fir.box<!fir.type<_QMprifTprif_coarray_handle{info:!fir.box<!fir.ptr<none>>}>>
+// CHECK: fir.global linkonce @_QFEb2_coarray_handle : !fir.box<!fir.type<_QMprifTprif_coarray_handle{info:!fir.box<!fir.ptr<none>>}>>
+// CHECK: fir.global linkonce @_QFEc2_coarray_handle : !fir.box<!fir.type<_QMprifTprif_coarray_handle{info:!fir.box<!fir.ptr<none>>}>>
+// CHECK: fir.global linkonce @_QFEd.z.co_coarray_handle : !fir.box<!fir.type<_QMprifTprif_coarray_handle{info:!fir.box<!fir.ptr<none>>}>>
+
diff --git a/flang/test/Fir/MIF/form_team.mlir b/flang/test/Fir/MIF/form_team.mlir
index f7f957afb7cc0..6b170876d29f3 100644
--- a/flang/test/Fir/MIF/form_team.mlir
+++ b/flang/test/Fir/MIF/form_team.mlir
@@ -1,36 +1,39 @@
 // RUN: fir-opt --mif-convert %s | FileCheck %s
 
-func.func @_QQmain() attributes {fir.bindc_name = "TEST_FORM_TEAM"} {
-  %0 = fir.dummy_scope : !fir.dscope
-  %c10 = arith.constant 10 : index
-  %1 = fir.alloca !fir.char<1,10> {bindc_name = "err", uniq_name = "_QFEerr"}
-  %2:2 = hlfir.declare %1 typeparams %c10 {uniq_name = "_QFEerr"} : (!fir.ref<!fir.char<1,10>>, index) -> (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,10>>)
-  %3 = fir.alloca i32 {bindc_name = "stat", uniq_name = "_QFEstat"}
-  %4:2 = hlfir.declare %3 {uniq_name = "_QFEstat"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
-  %5 = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}> {bindc_name = "team", uniq_name = "_QFEteam"}
-  %6:2 = hlfir.declare %5 {uniq_name = "_QFEteam"} : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
-  %7 = fir.address_of(@_QQ_QM__fortran_builtinsT__builtin_team_type.DerivedInit) : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  fir.copy %7 to %6#0 no_overlap : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  %8 = fir.alloca i32 {bindc_name = "team_index", uniq_name = "_QFEteam_index"}
-  %9:2 = hlfir.declare %8 {uniq_name = "_QFEteam_index"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
-  %10 = fir.alloca i32 {bindc_name = "team_number", uniq_name = "_QFEteam_number"}
-  %11:2 = hlfir.declare %10 {uniq_name = "_QFEteam_number"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
-  %12 = fir.load %11#0 : !fir.ref<i32>
-  %13 = fir.embox %6#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  mif.form_team team_number %12 team_var %13 : (i32, !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> ()
-  %14 = fir.load %9#0 : !fir.ref<i32>
-  %15 = fir.load %11#0 : !fir.ref<i32>
-  %16 = fir.embox %6#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  mif.form_team team_number %15 team_var %16 new_index %14 : (i32, !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, i32) -> ()
-  %17 = fir.load %11#0 : !fir.ref<i32>
-  %18 = fir.embox %6#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  mif.form_team team_number %17 team_var %18 stat %4#0 : (i32, !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<i32>) -> ()
-  %19 = fir.embox %2#0 : (!fir.ref<!fir.char<1,10>>) -> !fir.box<!fir.char<1,10>>
-  %20 = fir.load %11#0 : !fir.ref<i32>
-  %21 = fir.embox %6#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  mif.form_team team_number %20 team_var %21 errmsg %19 : (i32, !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.box<!fir.char<1,10>>) -> ()
-  return
+module attributes {dlti.dl_spec = #dlti.dl_spec<!llvm.ptr<270> = dense<32> : vector<4xi64>, !llvm.ptr<271> = dense<32> : vector<4xi64>, !llvm.ptr<272> = dense<64> : vector<4xi64>, i64 = dense<64> : vector<2xi64>, i128 = dense<128> : vector<2xi64>, f80 = dense<128> : vector<2xi64>, !llvm.ptr = dense<64> : vector<4xi64>, i1 = dense<8> : vector<2xi64>, i8 = dense<8> : vector<2xi64>, i16 = dense<16> : vector<2xi64>, i32 = dense<32> : vector<2xi64>, f16 = dense<16> : vector<2xi64>, f64 = dense<64> : vector<2xi64>, f128 = dense<128> : vector<2xi64>, "dlti.endianness" = "little", "dlti.mangling_mode" = "e", "dlti.legal_int_widths" = array<i32: 8, 16, 32, 64>, "dlti.stack_alignment" = 128 : i64>, fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128", llvm.ident = "flang version 22.0.0 (git at github.com:SiPearl/llvm-project.git 666e4313ebc03587f27774139ad8f780bac15c3e)", llvm.target_triple = "x86_64-unknown-linux-gnu"} {
+  func.func @_QQmain() attributes {fir.bindc_name = "TEST_FORM_TEAM"} {
+    %0 = fir.dummy_scope : !fir.dscope
+    %c10 = arith.constant 10 : index
+    %1 = fir.alloca !fir.char<1,10> {bindc_name = "err", uniq_name = "_QFEerr"}
+    %2:2 = hlfir.declare %1 typeparams %c10 {uniq_name = "_QFEerr"} : (!fir.ref<!fir.char<1,10>>, index) -> (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,10>>)
+    %3 = fir.alloca i32 {bindc_name = "stat", uniq_name = "_QFEstat"}
+    %4:2 = hlfir.declare %3 {uniq_name = "_QFEstat"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+    %5 = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}> {bindc_name = "team", uniq_name = "_QFEteam"}
+    %6:2 = hlfir.declare %5 {uniq_name = "_QFEteam"} : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
+    %7 = fir.address_of(@_QQ_QM__fortran_builtinsT__builtin_team_type.DerivedInit) : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    fir.copy %7 to %6#0 no_overlap : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    %8 = fir.alloca i32 {bindc_name = "team_index", uniq_name = "_QFEteam_index"}
+    %9:2 = hlfir.declare %8 {uniq_name = "_QFEteam_index"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+    %10 = fir.alloca i32 {bindc_name = "team_number", uniq_name = "_QFEteam_number"}
+    %11:2 = hlfir.declare %10 {uniq_name = "_QFEteam_number"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+    %12 = fir.load %11#0 : !fir.ref<i32>
+    %13 = fir.embox %6#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    mif.form_team team_number %12 team_var %13 : (i32, !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> ()
+    %14 = fir.load %9#0 : !fir.ref<i32>
+    %15 = fir.load %11#0 : !fir.ref<i32>
+    %16 = fir.embox %6#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    mif.form_team team_number %15 team_var %16 new_index %14 : (i32, !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, i32) -> ()
+    %17 = fir.load %11#0 : !fir.ref<i32>
+    %18 = fir.embox %6#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    mif.form_team team_number %17 team_var %18 stat %4#0 : (i32, !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<i32>) -> ()
+    %19 = fir.embox %2#0 : (!fir.ref<!fir.char<1,10>>) -> !fir.box<!fir.char<1,10>>
+    %20 = fir.load %11#0 : !fir.ref<i32>
+    %21 = fir.embox %6#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    mif.form_team team_number %20 team_var %21 errmsg %19 : (i32, !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.box<!fir.char<1,10>>) -> ()
+    return
+  }
 }
+
 // CHECK: %[[VAL_1:.*]] = fir.absent !fir.ref<i32>
 // CHECK: %[[VAL_2:.*]] = fir.absent !fir.ref<i32>
 // CHECK: %[[VAL_3:.*]] = fir.absent !fir.box<!fir.char<1,?>>
diff --git a/flang/test/Fir/MIF/get_team.mlir b/flang/test/Fir/MIF/get_team.mlir
index 10799fa2292b6..80e84412e47a8 100644
--- a/flang/test/Fir/MIF/get_team.mlir
+++ b/flang/test/Fir/MIF/get_team.mlir
@@ -1,54 +1,56 @@
 // RUN: fir-opt --mif-convert %s | FileCheck %s
 
-func.func @_QQmain() attributes {fir.bindc_name = "TEST_FORM_TEAM"} {
-  %0 = fir.dummy_scope : !fir.dscope
-  %1 = fir.address_of(@_QMiso_fortran_envECcurrent_team) : !fir.ref<i32>
-  %2:2 = hlfir.declare %1 {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QMiso_fortran_envECcurrent_team"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
-  %3 = fir.address_of(@_QMiso_fortran_envECinitial_team) : !fir.ref<i32>
-  %4:2 = hlfir.declare %3 {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QMiso_fortran_envECinitial_team"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
-  %5 = fir.alloca i32 {bindc_name = "n", uniq_name = "_QFEn"}
-  %6:2 = hlfir.declare %5 {uniq_name = "_QFEn"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
-  %7 = fir.address_of(@_QMiso_fortran_envECparent_team) : !fir.ref<i32>
-  %8:2 = hlfir.declare %7 {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QMiso_fortran_envECparent_team"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
-  %9 = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}> {bindc_name = "result_team", uniq_name = "_QFEresult_team"}
-  %10:2 = hlfir.declare %9 {uniq_name = "_QFEresult_team"} : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
-  %11 = fir.address_of(@_QQ_QM__fortran_builtinsT__builtin_team_type.DerivedInit) : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  fir.copy %11 to %10#0 no_overlap : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  %12 = mif.get_team : () -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  %13:2 = hlfir.declare %12 {uniq_name = ".tmp.intrinsic_result"} : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
-  %false = arith.constant false
-  %14 = hlfir.as_expr %13#0 move %false : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, i1) -> !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  hlfir.assign %14 to %10#0 : !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  hlfir.destroy %14 : !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  %c-2_i32 = arith.constant -2 : i32
-  %15 = mif.get_team level %c-2_i32 : (i32) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  %16:2 = hlfir.declare %15 {uniq_name = ".tmp.intrinsic_result"} : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
-  %false_0 = arith.constant false
-  %17 = hlfir.as_expr %16#0 move %false_0 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, i1) -> !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  hlfir.assign %17 to %10#0 : !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  hlfir.destroy %17 : !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  %c-1_i32 = arith.constant -1 : i32
-  %18 = mif.get_team level %c-1_i32 : (i32) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  %19:2 = hlfir.declare %18 {uniq_name = ".tmp.intrinsic_result"} : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
-  %false_1 = arith.constant false
-  %20 = hlfir.as_expr %19#0 move %false_1 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, i1) -> !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  hlfir.assign %20 to %10#0 : !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  hlfir.destroy %20 : !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  %c-3_i32 = arith.constant -3 : i32
-  %21 = mif.get_team level %c-3_i32 : (i32) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  %22:2 = hlfir.declare %21 {uniq_name = ".tmp.intrinsic_result"} : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
-  %false_2 = arith.constant false
-  %23 = hlfir.as_expr %22#0 move %false_2 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, i1) -> !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  hlfir.assign %23 to %10#0 : !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  hlfir.destroy %23 : !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  %24 = fir.load %6#0 : !fir.ref<i32>
-  %25 = mif.get_team level %24 : (i32) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  %26:2 = hlfir.declare %25 {uniq_name = ".tmp.intrinsic_result"} : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
-  %false_3 = arith.constant false
-  %27 = hlfir.as_expr %26#0 move %false_3 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, i1) -> !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  hlfir.assign %27 to %10#0 : !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  hlfir.destroy %27 : !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  return
+module attributes {dlti.dl_spec = #dlti.dl_spec<!llvm.ptr<270> = dense<32> : vector<4xi64>, !llvm.ptr<271> = dense<32> : vector<4xi64>, !llvm.ptr<272> = dense<64> : vector<4xi64>, i64 = dense<64> : vector<2xi64>, i128 = dense<128> : vector<2xi64>, f80 = dense<128> : vector<2xi64>, !llvm.ptr = dense<64> : vector<4xi64>, i1 = dense<8> : vector<2xi64>, i8 = dense<8> : vector<2xi64>, i16 = dense<16> : vector<2xi64>, i32 = dense<32> : vector<2xi64>, f16 = dense<16> : vector<2xi64>, f64 = dense<64> : vector<2xi64>, f128 = dense<128> : vector<2xi64>, "dlti.endianness" = "little", "dlti.mangling_mode" = "e", "dlti.legal_int_widths" = array<i32: 8, 16, 32, 64>, "dlti.stack_alignment" = 128 : i64>, fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128", llvm.ident = "flang version 22.0.0 (git at github.com:SiPearl/llvm-project.git 666e4313ebc03587f27774139ad8f780bac15c3e)", llvm.target_triple = "x86_64-unknown-linux-gnu"} {
+  func.func @_QQmain() attributes {fir.bindc_name = "TEST_FORM_TEAM"} {
+    %0 = fir.dummy_scope : !fir.dscope
+    %1 = fir.address_of(@_QMiso_fortran_envECcurrent_team) : !fir.ref<i32>
+    %2:2 = hlfir.declare %1 {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QMiso_fortran_envECcurrent_team"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+    %3 = fir.address_of(@_QMiso_fortran_envECinitial_team) : !fir.ref<i32>
+    %4:2 = hlfir.declare %3 {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QMiso_fortran_envECinitial_team"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+    %5 = fir.alloca i32 {bindc_name = "n", uniq_name = "_QFEn"}
+    %6:2 = hlfir.declare %5 {uniq_name = "_QFEn"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+    %7 = fir.address_of(@_QMiso_fortran_envECparent_team) : !fir.ref<i32>
+    %8:2 = hlfir.declare %7 {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QMiso_fortran_envECparent_team"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+    %9 = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}> {bindc_name = "result_team", uniq_name = "_QFEresult_team"}
+    %10:2 = hlfir.declare %9 {uniq_name = "_QFEresult_team"} : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
+    %11 = fir.address_of(@_QQ_QM__fortran_builtinsT__builtin_team_type.DerivedInit) : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    fir.copy %11 to %10#0 no_overlap : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    %12 = mif.get_team : () -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    %13:2 = hlfir.declare %12 {uniq_name = ".tmp.intrinsic_result"} : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
+    %false = arith.constant false
+    %14 = hlfir.as_expr %13#0 move %false : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, i1) -> !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    hlfir.assign %14 to %10#0 : !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    hlfir.destroy %14 : !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    %c-2_i32 = arith.constant -2 : i32
+    %15 = mif.get_team level %c-2_i32 : (i32) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    %16:2 = hlfir.declare %15 {uniq_name = ".tmp.intrinsic_result"} : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
+    %false_0 = arith.constant false
+    %17 = hlfir.as_expr %16#0 move %false_0 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, i1) -> !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    hlfir.assign %17 to %10#0 : !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    hlfir.destroy %17 : !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    %c-1_i32 = arith.constant -1 : i32
+    %18 = mif.get_team level %c-1_i32 : (i32) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    %19:2 = hlfir.declare %18 {uniq_name = ".tmp.intrinsic_result"} : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
+    %false_1 = arith.constant false
+    %20 = hlfir.as_expr %19#0 move %false_1 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, i1) -> !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    hlfir.assign %20 to %10#0 : !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    hlfir.destroy %20 : !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    %c-3_i32 = arith.constant -3 : i32
+    %21 = mif.get_team level %c-3_i32 : (i32) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    %22:2 = hlfir.declare %21 {uniq_name = ".tmp.intrinsic_result"} : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
+    %false_2 = arith.constant false
+    %23 = hlfir.as_expr %22#0 move %false_2 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, i1) -> !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    hlfir.assign %23 to %10#0 : !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    hlfir.destroy %23 : !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    %24 = fir.load %6#0 : !fir.ref<i32>
+    %25 = mif.get_team level %24 : (i32) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    %26:2 = hlfir.declare %25 {uniq_name = ".tmp.intrinsic_result"} : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
+    %false_3 = arith.constant false
+    %27 = hlfir.as_expr %26#0 move %false_3 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, i1) -> !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    hlfir.assign %27 to %10#0 : !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    hlfir.destroy %27 : !hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    return
+  }
 }
 
 // CHECK: %[[VAL_1:.*]] = fir.absent !fir.ref<i32>
diff --git a/flang/test/Fir/MIF/sync_team.mlir b/flang/test/Fir/MIF/sync_team.mlir
index d7db171546fb5..c7e2c2c169694 100644
--- a/flang/test/Fir/MIF/sync_team.mlir
+++ b/flang/test/Fir/MIF/sync_team.mlir
@@ -1,31 +1,33 @@
 // RUN: fir-opt --mif-convert %s | FileCheck %s
 
-func.func @_QQmain() attributes {fir.bindc_name = "TEST_SYNC_TEAM"} {
-  %0 = fir.dummy_scope : !fir.dscope
-  %1 = fir.address_of(@_QFEerror_message) : !fir.ref<!fir.char<1,128>>
-  %c128 = arith.constant 128 : index
-  %2:2 = hlfir.declare %1 typeparams %c128 {uniq_name = "_QFEerror_message"} : (!fir.ref<!fir.char<1,128>>, index) -> (!fir.ref<!fir.char<1,128>>, !fir.ref<!fir.char<1,128>>)
-  %3 = fir.alloca i32 {bindc_name = "sync_status", uniq_name = "_QFEsync_status"}
-  %4:2 = hlfir.declare %3 {uniq_name = "_QFEsync_status"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
-  %5 = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}> {bindc_name = "team", uniq_name = "_QFEteam"}
-  %6:2 = hlfir.declare %5 {uniq_name = "_QFEteam"} : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
-  %7 = fir.address_of(@_QQ_QM__fortran_builtinsT__builtin_team_type.DerivedInit) : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  fir.copy %7 to %6#0 no_overlap : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  %8 = fir.embox %6#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  mif.sync_team %8 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> ()
-  %9 = fir.embox %6#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  mif.sync_team %9 stat %4#0 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<i32>) -> ()
-  %10 = fir.embox %6#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  %11 = fir.embox %2#0 : (!fir.ref<!fir.char<1,128>>) -> !fir.box<!fir.char<1,128>>
-  mif.sync_team %10 errmsg %11 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.box<!fir.char<1,128>>) -> ()
-  %12 = fir.embox %6#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  %13 = fir.embox %2#0 : (!fir.ref<!fir.char<1,128>>) -> !fir.box<!fir.char<1,128>>
-  mif.sync_team %12 stat %4#0 errmsg %13 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<i32>, !fir.box<!fir.char<1,128>>) -> ()
-  return
-}
-fir.global internal @_QFEerror_message : !fir.char<1,128> {
-  %0 = fir.zero_bits !fir.char<1,128>
-  fir.has_value %0 : !fir.char<1,128>
+module attributes {dlti.dl_spec = #dlti.dl_spec<!llvm.ptr<270> = dense<32> : vector<4xi64>, !llvm.ptr<271> = dense<32> : vector<4xi64>, !llvm.ptr<272> = dense<64> : vector<4xi64>, i64 = dense<64> : vector<2xi64>, i128 = dense<128> : vector<2xi64>, f80 = dense<128> : vector<2xi64>, !llvm.ptr = dense<64> : vector<4xi64>, i1 = dense<8> : vector<2xi64>, i8 = dense<8> : vector<2xi64>, i16 = dense<16> : vector<2xi64>, i32 = dense<32> : vector<2xi64>, f16 = dense<16> : vector<2xi64>, f64 = dense<64> : vector<2xi64>, f128 = dense<128> : vector<2xi64>, "dlti.endianness" = "little", "dlti.mangling_mode" = "e", "dlti.legal_int_widths" = array<i32: 8, 16, 32, 64>, "dlti.stack_alignment" = 128 : i64>, fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128", llvm.ident = "flang version 22.0.0 (git at github.com:SiPearl/llvm-project.git 666e4313ebc03587f27774139ad8f780bac15c3e)", llvm.target_triple = "x86_64-unknown-linux-gnu"} {
+  func.func @_QQmain() attributes {fir.bindc_name = "TEST_SYNC_TEAM"} {
+    %0 = fir.dummy_scope : !fir.dscope
+    %1 = fir.address_of(@_QFEerror_message) : !fir.ref<!fir.char<1,128>>
+    %c128 = arith.constant 128 : index
+    %2:2 = hlfir.declare %1 typeparams %c128 {uniq_name = "_QFEerror_message"} : (!fir.ref<!fir.char<1,128>>, index) -> (!fir.ref<!fir.char<1,128>>, !fir.ref<!fir.char<1,128>>)
+    %3 = fir.alloca i32 {bindc_name = "sync_status", uniq_name = "_QFEsync_status"}
+    %4:2 = hlfir.declare %3 {uniq_name = "_QFEsync_status"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+    %5 = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}> {bindc_name = "team", uniq_name = "_QFEteam"}
+    %6:2 = hlfir.declare %5 {uniq_name = "_QFEteam"} : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
+    %7 = fir.address_of(@_QQ_QM__fortran_builtinsT__builtin_team_type.DerivedInit) : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    fir.copy %7 to %6#0 no_overlap : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    %8 = fir.embox %6#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    mif.sync_team %8 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> ()
+    %9 = fir.embox %6#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    mif.sync_team %9 stat %4#0 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<i32>) -> ()
+    %10 = fir.embox %6#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    %11 = fir.embox %2#0 : (!fir.ref<!fir.char<1,128>>) -> !fir.box<!fir.char<1,128>>
+    mif.sync_team %10 errmsg %11 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.box<!fir.char<1,128>>) -> ()
+    %12 = fir.embox %6#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    %13 = fir.embox %2#0 : (!fir.ref<!fir.char<1,128>>) -> !fir.box<!fir.char<1,128>>
+    mif.sync_team %12 stat %4#0 errmsg %13 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<i32>, !fir.box<!fir.char<1,128>>) -> ()
+    return
+  }
+  fir.global internal @_QFEerror_message : !fir.char<1,128> {
+    %0 = fir.zero_bits !fir.char<1,128>
+    fir.has_value %0 : !fir.char<1,128>
+  }
 }
 
 // CHECK: %[[ERRMSG:.*]]:2 = hlfir.declare %[[E:.*]] typeparams %[[C_128:.*]] {uniq_name = "_QFEerror_message"} : (!fir.ref<!fir.char<1,128>>, index) -> (!fir.ref<!fir.char<1,128>>, !fir.ref<!fir.char<1,128>>)
diff --git a/flang/test/Fir/MIF/team_number.mlir b/flang/test/Fir/MIF/team_number.mlir
index 4dc766d2a9ff4..55e10448d2003 100644
--- a/flang/test/Fir/MIF/team_number.mlir
+++ b/flang/test/Fir/MIF/team_number.mlir
@@ -1,22 +1,24 @@
 // RUN: fir-opt --mif-convert %s | FileCheck %s
 
-func.func @_QQmain() attributes {fir.bindc_name = "TEST_TEAM_NUMBER"} {
-  %0 = fir.dummy_scope : !fir.dscope
-  %1 = fir.alloca i32 {bindc_name = "t", uniq_name = "_QFEt"}
-  %2:2 = hlfir.declare %1 {uniq_name = "_QFEt"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
-  %3 = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}> {bindc_name = "team", uniq_name = "_QFEteam"}
-  %4:2 = hlfir.declare %3 {uniq_name = "_QFEteam"} : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
-  %5 = fir.address_of(@_QQ_QM__fortran_builtinsT__builtin_team_type.DerivedInit) : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  fir.copy %5 to %4#0 no_overlap : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  %6 = fir.embox %4#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
-  %7 = mif.team_number team %6 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> i64
-  %8 = fir.convert %7 : (i64) -> i32
-  hlfir.assign %8 to %2#0 : i32, !fir.ref<i32>
-  %9 = mif.team_number : () -> i64
-  %10 = fir.convert %9 : (i64) -> i32
-  hlfir.assign %10 to %2#0 : i32, !fir.ref<i32>
-  return
-}
+module attributes {dlti.dl_spec = #dlti.dl_spec<!llvm.ptr<270> = dense<32> : vector<4xi64>, !llvm.ptr<271> = dense<32> : vector<4xi64>, !llvm.ptr<272> = dense<64> : vector<4xi64>, i64 = dense<64> : vector<2xi64>, i128 = dense<128> : vector<2xi64>, f80 = dense<128> : vector<2xi64>, !llvm.ptr = dense<64> : vector<4xi64>, i1 = dense<8> : vector<2xi64>, i8 = dense<8> : vector<2xi64>, i16 = dense<16> : vector<2xi64>, i32 = dense<32> : vector<2xi64>, f16 = dense<16> : vector<2xi64>, f64 = dense<64> : vector<2xi64>, f128 = dense<128> : vector<2xi64>, "dlti.endianness" = "little", "dlti.mangling_mode" = "e", "dlti.legal_int_widths" = array<i32: 8, 16, 32, 64>, "dlti.stack_alignment" = 128 : i64>, fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128", llvm.ident = "flang version 22.0.0 (git at github.com:SiPearl/llvm-project.git 666e4313ebc03587f27774139ad8f780bac15c3e)", llvm.target_triple = "x86_64-unknown-linux-gnu"} {
+  func.func @_QQmain() attributes {fir.bindc_name = "TEST_TEAM_NUMBER"} {
+    %0 = fir.dummy_scope : !fir.dscope
+    %1 = fir.alloca i32 {bindc_name = "t", uniq_name = "_QFEt"}
+    %2:2 = hlfir.declare %1 {uniq_name = "_QFEt"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+    %3 = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}> {bindc_name = "team", uniq_name = "_QFEteam"}
+    %4:2 = hlfir.declare %3 {uniq_name = "_QFEteam"} : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>)
+    %5 = fir.address_of(@_QQ_QM__fortran_builtinsT__builtin_team_type.DerivedInit) : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    fir.copy %5 to %4#0 no_overlap : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    %6 = fir.embox %4#0 : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> !fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>
+    %7 = mif.team_number team %6 : (!fir.box<!fir.type<_QM__fortran_builtinsT__builtin_team_type{_QM__fortran_builtinsT__builtin_team_type.__id:i64}>>) -> i64
+    %8 = fir.convert %7 : (i64) -> i32
+    hlfir.assign %8 to %2#0 : i32, !fir.ref<i32>
+    %9 = mif.team_number : () -> i64
+    %10 = fir.convert %9 : (i64) -> i32
+    hlfir.assign %10 to %2#0 : i32, !fir.ref<i32>
+    return
+  }
+  }
 
 // CHECK: %[[VAL_1:.*]] = fir.convert %[[TEAM:.*]] : ({{.*}}) -> !fir.box<none>
 // CHECK: fir.call @_QMprifPprif_team_number(%[[VAL_1]], %[[RESULT:.*]]) : (!fir.box<none>, !fir.ref<i64>) -> ()
diff --git a/flang/test/Lower/MIF/coarray_allocation.f90 b/flang/test/Lower/MIF/coarray_allocation.f90
new file mode 100644
index 0000000000000..4a449c3bf1292
--- /dev/null
+++ b/flang/test/Lower/MIF/coarray_allocation.f90
@@ -0,0 +1,63 @@
+! RUN: %flang_fc1 -emit-hlfir -fcoarray %s -o - | FileCheck %s
+
+program alloc_test
+  type :: my_type2
+    integer, allocatable :: co[:]
+  end type
+  
+  type :: my_type
+    integer :: x
+    integer, allocatable :: y(:)
+    type(my_type2) :: z
+  end type
+  
+  ! CHECK: %[[VAL_1:.*]] = fir.address_of(@_QFEa) : !fir.ref<i32>
+  ! CHECK: mif.alloc_coarray %[[VAL_1]] {lcobounds = array<i64: 1, 1>, ucobounds = array<i64: 2, -1>, uniq_name = "_QFEa"} : (!fir.ref<i32>) -> ()
+  
+  ! CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[ADDR_1:.*]] {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFEa2"} : (!fir.ref<!fir.box<!fir.heap<i32>>>) -> (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<!fir.box<!fir.heap<i32>>>)
+  
+  integer :: a[2, *]
+  ! CHECK: %[[VAL_2:.*]] = fir.address_of(@_QFEb) : !fir.ref<f32>
+  ! CHECK: mif.alloc_coarray %[[VAL_2]] {lcobounds = array<i64: 3, 1, 1>, ucobounds = array<i64: 4, 5, -1>, uniq_name = "_QFEb"} : (!fir.ref<f32>) -> ()
+  
+  ! CHECK: %[[VAL_5:.*]]:2 = hlfir.declare %[[ADDR_2:.*]] {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFEb2"} : (!fir.ref<!fir.box<!fir.heap<f32>>>) -> (!fir.ref<!fir.box<!fir.heap<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>)
+  
+  real :: b[3:4, 5, *]
+  ! CHECK: %[[VAL_3:.*]] = fir.address_of(@_QFEc) : !fir.ref<!fir.char<1,10>>
+  ! CHECK: mif.alloc_coarray %[[VAL_3]] {lcobounds = array<i64: 1>, ucobounds = array<i64: -1>, uniq_name = "_QFEc"} : (!fir.ref<!fir.char<1,10>>) -> ()
+  
+  ! CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[ADDR_3:.*]] {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFEc2"} : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>) -> (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>)
+  character(len=10) :: c[*]
+  type(my_type) :: d
+
+  real, allocatable :: b2[:,:,:]
+  character(len=:), allocatable :: c2(:)[:]
+  integer, allocatable :: a2[:,:]
+  
+  ! CHECK: %[[VAL_7:.*]] = fir.absent !fir.box<none>
+  ! CHECK: mif.alloc_coarray %[[VAL_4]]#0 errmsg %[[VAL_7]] {lcobounds = array<i64: 1, 1>, ucobounds = array<i64: 2, -1>, uniq_name = "_QFEa2"} : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.box<none>) -> ()
+  allocate(a2[2,*])
+  
+  ! CHECK: %[[VAL_8:.*]] = fir.absent !fir.box<none>
+  ! CHECK: mif.alloc_coarray %[[VAL_5]]#0 errmsg %[[VAL_8]] {lcobounds = array<i64: 3, 1, 1>, ucobounds = array<i64: 4, 5, -1>, uniq_name = "_QFEb2"} : (!fir.ref<!fir.box<!fir.heap<f32>>>, !fir.box<none>) -> ()
+  allocate(b2[3:4, 5, *])
+  
+  ! CHECK: %[[VAL_9:.*]] = fir.absent !fir.box<none>
+  ! CHECK: mif.alloc_coarray %[[VAL_6]]#0 errmsg %[[VAL_9]] {lcobounds = array<i64: 1>, ucobounds = array<i64: -1>, uniq_name = "_QFEc2"} : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>, !fir.box<none>) -> ()
+  allocate(character(100) :: c2(5)[*])
+  
+  ! CHECK: %[[VAL_10:.*]] = fir.absent !fir.box<none>
+  ! CHECK: %[[VAL_12:.*]] = hlfir.designate %[[VAL_11:.*]]{"co"}
+  ! CHECK:  mif.alloc_coarray %[[VAL_12]] errmsg %[[VAL_10]] {lcobounds = array<i64: 1>, ucobounds = array<i64: -1>, uniq_name = "_QFEd.z.co"} : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.box<none>) -> ()
+  allocate(d%z%co[*])
+
+  ! CHECK: mif.dealloc_coarray %[[VAL_4]]#0 stat %[[STAT:.*]] errmsg %[[ERRMSG:.*]] : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<i32>, !fir.box<none>) -> ()
+  ! CHECK: mif.dealloc_coarray %[[VAL_5]]#0 stat %[[STAT:.*]] errmsg %[[ERRMSG:.*]] : (!fir.ref<!fir.box<!fir.heap<f32>>>, !fir.ref<i32>, !fir.box<none>) -> ()
+  ! CHECK: mif.dealloc_coarray %[[VAL_6]]#0 stat %[[STAT:.*]] errmsg %[[ERRMSG:.*]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>, !fir.ref<i32>, !fir.box<none>) -> ()
+  deallocate(a2, b2, c2)
+  
+  ! CHECK: %[[VAL_14:.*]] = hlfir.designate %[[VAL_13:.*]]{"co"} {{.*}}
+  ! CHECK: mif.dealloc_coarray %[[VAL_14]] stat %[[STAT:.*]] errmsg %[[ERRMSG:.*]] : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<i32>, !fir.box<none>) -> ()
+  deallocate(d%z%co)
+  
+end program 

>From 5acb5b14086f4f61f007a6fc14a86e930bd1d247 Mon Sep 17 00:00:00 2001
From: Jean-Didier Pailleux <jean-didier.pailleux at sipearl.com>
Date: Thu, 19 Feb 2026 15:09:39 +0100
Subject: [PATCH 02/13] Fix CI werror + Fix ucobound computation + Improve
 hasAllocatableOrPointerCompoent

---
 flang-rt/lib/runtime/coarray.cpp                  |  9 ++++++++-
 flang/lib/Lower/ConvertVariable.cpp               |  3 +--
 flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp        | 15 +++------------
 .../lib/Optimizer/Transforms/MIFOpConversion.cpp  |  2 +-
 4 files changed, 13 insertions(+), 16 deletions(-)

diff --git a/flang-rt/lib/runtime/coarray.cpp b/flang-rt/lib/runtime/coarray.cpp
index 11589efc16b72..841cddc83a0ad 100644
--- a/flang-rt/lib/runtime/coarray.cpp
+++ b/flang-rt/lib/runtime/coarray.cpp
@@ -8,6 +8,7 @@
 
 #include "flang/Runtime/coarray.h"
 #include "flang-rt/runtime/descriptor.h"
+#include "flang-rt/runtime/terminator.h"
 #include "flang-rt/runtime/type-info.h"
 
 namespace Fortran::runtime {
@@ -18,6 +19,12 @@ RT_EXT_API_GROUP_BEGIN
 void RTDEF(ComputeLastUcobound)(
     int num_images, const Descriptor &lcobounds, const Descriptor &ucobounds) {
   int corank = ucobounds.GetDimension(0).Extent();
+  if (corank > 15)
+    Fortran::runtime::Terminator{}.Crash(
+        "Fortran runtime error: maximum corank for a coarray is 15, current "
+        "corank is %d.",
+        corank);
+
   int64_t *lcobounds_ptr = (int64_t *)lcobounds.raw().base_addr;
   int64_t *ucobounds_ptr = (int64_t *)ucobounds.raw().base_addr;
   int64_t index = 1;
@@ -25,7 +32,7 @@ void RTDEF(ComputeLastUcobound)(
     index *= ucobounds_ptr[i] - lcobounds_ptr[i] + 1;
   }
   if (corank == 1)
-    ucobounds_ptr[0] = num_images - lcobounds_ptr[0] + 1;
+    ucobounds_ptr[0] = lcobounds_ptr[0] + num_images;
   else if (index < num_images)
     ucobounds_ptr[corank - 1] =
         (num_images / index) + (num_images % index != 0);
diff --git a/flang/lib/Lower/ConvertVariable.cpp b/flang/lib/Lower/ConvertVariable.cpp
index 2e308324d09ae..26c2e67ee4015 100644
--- a/flang/lib/Lower/ConvertVariable.cpp
+++ b/flang/lib/Lower/ConvertVariable.cpp
@@ -1143,8 +1143,7 @@ static void instantiateLocal(Fortran::lower::AbstractConverter &converter,
     auto *sym = &var.getSymbol();
     const Fortran::semantics::Scope &owner = sym->owner();
     if (owner.kind() != Fortran::semantics::Scope::Kind::MainProgram) {
-      auto *converterPtr = &converter;
-      converter.getFctCtx().attachCleanup([converterPtr, builder, loc, exv]() {
+      converter.getFctCtx().attachCleanup([builder, loc, exv]() {
         mif::DeallocCoarrayOp::create(*builder, loc, fir::getBase(exv),
                                       /*stat*/ mlir::Value{},
                                       /*errmsg*/ mlir::Value{});
diff --git a/flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp b/flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp
index 9830d3c83a56f..241ecadc04252 100644
--- a/flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp
+++ b/flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp
@@ -27,21 +27,12 @@ static bool hasAllocatableOrPointerComponent(mlir::Type type) {
     return hasAllocatableOrPointerComponent(type);
   if (auto recType = mlir::dyn_cast<fir::RecordType>(type)) {
     for (auto field : recType.getTypeList()) {
-      mlir::Type fieldType = fir::unwrapPassByRefType(field.second);
-      if (mlir::isa<fir::PointerType>(fieldType))
-        return true;
-      if (mlir::isa<fir::HeapType>(fieldType))
+      mlir::Type fieldType = field.second;
+      if (fir::isAllocatableType(fieldType) || fir::isPointerType(fieldType) ||
+          fir::isAllocatableOrPointerArray(fieldType))
         return true;
       if (auto fieldRecType = mlir::dyn_cast<fir::RecordType>(fieldType))
         return hasAllocatableOrPointerComponent(fieldRecType);
-      if (auto seqTy = mlir::dyn_cast<fir::SequenceType>(fieldType)) {
-        if (seqTy.hasUnknownShape() || seqTy.hasDynamicExtents())
-          return true;
-        mlir::Type eleTy = seqTy.getEleTy();
-        if (mlir::isa<fir::PointerType>(eleTy) ||
-            mlir::isa<fir::HeapType>(eleTy))
-          return true;
-      }
     }
   }
   return false;
diff --git a/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp b/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
index ed7b50e4a8208..098c6b573f47c 100644
--- a/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
+++ b/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
@@ -108,9 +108,9 @@ mlir::Value getCoarrayHandle(fir::FirOpBuilder &builder, mlir::Location loc,
         fir::AddrOfOp::create(builder, loc, builder.getRefType(boxTy), symAttr);
     return fir::LoadOp::create(builder, loc, coarrayHandle);
   }
-
   mlir::emitError(coarray.getLoc(),
                   "Unable to locate the coarray handle for this argument.");
+  return mlir::Value{};
 }
 
 // Function to generate the PRIF runtime function call to retrieve

>From 3d6a6306c5cd826a2306fd17b1f65de34bcf866b Mon Sep 17 00:00:00 2001
From: Jean-Didier Pailleux <jean-didier.pailleux at sipearl.com>
Date: Tue, 3 Mar 2026 14:45:01 +0100
Subject: [PATCH 03/13] Update flang-rt/lib/runtime/coarray.cpp

    Co-authored-by: Dan Bonachea <dobonachea at lbl.gov>
---
 flang-rt/lib/runtime/coarray.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/flang-rt/lib/runtime/coarray.cpp b/flang-rt/lib/runtime/coarray.cpp
index 841cddc83a0ad..9821213a73703 100644
--- a/flang-rt/lib/runtime/coarray.cpp
+++ b/flang-rt/lib/runtime/coarray.cpp
@@ -32,10 +32,10 @@ void RTDEF(ComputeLastUcobound)(
     index *= ucobounds_ptr[i] - lcobounds_ptr[i] + 1;
   }
   if (corank == 1)
-    ucobounds_ptr[0] = lcobounds_ptr[0] + num_images;
+    ucobounds_ptr[0] = lcobounds_ptr[0] + num_images - 1;
   else if (index < num_images)
-    ucobounds_ptr[corank - 1] =
-        (num_images / index) + (num_images % index != 0);
+    ucobounds_ptr[corank - 1] = lcobounds_ptr[corank - 1] +
+        (num_images / index) + (num_images % index != 0) - 1;
   else
     ucobounds_ptr[corank - 1] = lcobounds_ptr[corank - 1];
 }

>From 212465b099ed54b9d53ae8db22f6ae2db2224bae Mon Sep 17 00:00:00 2001
From: Jean-Didier Pailleux <jean-didier.pailleux at sipearl.com>
Date: Tue, 10 Mar 2026 08:55:50 +0100
Subject: [PATCH 04/13] Applying feedback + Update mif::AllocCoarrayOp

- Handling optionnaly STAT during the deallocation
- Adding TODO for the finalization of a coarray
- Adding TODO on the cleanup of dummy argument (not yet supported in
  Flang)
- Handling non constant cobounds for the allocation (update of
  mif::AllocCoarrayOp the "cobounds" arguments).
- Updating tests
---
 flang-rt/lib/runtime/coarray.cpp              |  11 +-
 flang/include/flang/Lower/MultiImageFortran.h |  10 +-
 .../flang/Optimizer/Dialect/MIF/MIFOps.td     |  11 +-
 flang/include/flang/Runtime/coarray.h         |   4 +-
 flang/lib/Lower/Allocatable.cpp               |  69 ++--
 flang/lib/Lower/ConvertVariable.cpp           |  52 ++-
 flang/lib/Lower/MultiImageFortran.cpp         | 183 ++++++----
 flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp    |  25 +-
 .../Optimizer/Transforms/MIFOpConversion.cpp  |  54 +--
 flang/test/Fir/MIF/coarray-alloc.mlir         | 325 +++++++++++-------
 flang/test/Lower/MIF/coarray_allocation.f90   |  14 +-
 11 files changed, 441 insertions(+), 317 deletions(-)

diff --git a/flang-rt/lib/runtime/coarray.cpp b/flang-rt/lib/runtime/coarray.cpp
index 9821213a73703..e5498f5e92153 100644
--- a/flang-rt/lib/runtime/coarray.cpp
+++ b/flang-rt/lib/runtime/coarray.cpp
@@ -16,13 +16,14 @@ namespace Fortran::runtime {
 extern "C" {
 RT_EXT_API_GROUP_BEGIN
 
-void RTDEF(ComputeLastUcobound)(
-    int num_images, const Descriptor &lcobounds, const Descriptor &ucobounds) {
+void RTDEF(ComputeLastUcobound)(int num_images, const Descriptor &lcobounds,
+    const Descriptor &ucobounds, int rank) {
   int corank = ucobounds.GetDimension(0).Extent();
-  if (corank > 15)
+  if (corank + rank > 15)
     Fortran::runtime::Terminator{}.Crash(
-        "Fortran runtime error: maximum corank for a coarray is 15, current "
-        "corank is %d.",
+        "Fortran runtime error: maximum corank + rank for a coarray is 15, "
+        "current "
+        "corank is %d and rank is %d.",
         corank);
 
   int64_t *lcobounds_ptr = (int64_t *)lcobounds.raw().base_addr;
diff --git a/flang/include/flang/Lower/MultiImageFortran.h b/flang/include/flang/Lower/MultiImageFortran.h
index f029133c046cd..002f156c807f2 100644
--- a/flang/include/flang/Lower/MultiImageFortran.h
+++ b/flang/include/flang/Lower/MultiImageFortran.h
@@ -63,13 +63,11 @@ void genFormTeamStatement(AbstractConverter &, pft::Evaluation &eval,
 // COARRAY utils
 //===----------------------------------------------------------------------===//
 
-mlir::DenseI64ArrayAttr genLowerCoBounds(AbstractConverter &converter,
-                                         mlir::Location loc,
-                                         const semantics::Symbol &sym);
+mlir::Value genLowerCoBounds(AbstractConverter &converter, mlir::Location loc,
+                             const semantics::Symbol &sym);
 
-mlir::DenseI64ArrayAttr genUpperCoBounds(AbstractConverter &converter,
-                                         mlir::Location loc,
-                                         const semantics::Symbol &sym);
+mlir::Value genUpperCoBounds(AbstractConverter &converter, mlir::Location loc,
+                             const semantics::Symbol &sym);
 
 mlir::Value genAllocateCoarray(
     AbstractConverter &converter, mlir::Location loc,
diff --git a/flang/include/flang/Optimizer/Dialect/MIF/MIFOps.td b/flang/include/flang/Optimizer/Dialect/MIF/MIFOps.td
index 5a432c04361d6..dadf38ec5c9f2 100644
--- a/flang/include/flang/Optimizer/Dialect/MIF/MIFOps.td
+++ b/flang/include/flang/Optimizer/Dialect/MIF/MIFOps.td
@@ -443,21 +443,20 @@ def mif_AllocCoarrayOp
 
   let arguments = (ins StrAttr:$uniq_name,
       Arg<fir_ReferenceType, "", [MemRead, MemWrite]>:$box,
-      DenseI64ArrayAttr:$lcobounds, DenseI64ArrayAttr:$ucobounds,
+      AnyBoxedArray:$lcobounds, AnyBoxedArray:$ucobounds,
       Arg<Optional<AnyReferenceLike>, "", [MemWrite]>:$stat,
       Arg<Optional<AnyRefOrBoxType>, "", [MemWrite]>:$errmsg);
 
   let builders = [OpBuilder<(ins "mlir::Value":$box, "llvm::StringRef":$symName,
-                      "mlir::DenseI64ArrayAttr":$lcobounds,
-                      "mlir::DenseI64ArrayAttr":$ucobounds, "mlir::Value":$stat,
-                      "mlir::Value":$errmsg)>,
+                      "mlir::Value":$lcobounds, "mlir::Value":$ucobounds,
+                      "mlir::Value":$stat, "mlir::Value":$errmsg)>,
                   OpBuilder<(ins "mlir::Value":$box, "llvm::StringRef":$symName,
-                      "mlir::DenseI64ArrayAttr":$lcobounds,
-                      "mlir::DenseI64ArrayAttr":$ucobounds)>];
+                      "mlir::Value":$lcobounds, "mlir::Value":$ucobounds)>];
 
   let hasVerifier = 1;
   let assemblyFormat = [{
     $box 
+    `lcobounds` $lcobounds `ucobounds` $ucobounds 
     (`stat` $stat^ )?
     (`errmsg` $errmsg^ )? 
     attr-dict `:` functional-type(operands, results)
diff --git a/flang/include/flang/Runtime/coarray.h b/flang/include/flang/Runtime/coarray.h
index 4519179489147..0028a3d9827ef 100644
--- a/flang/include/flang/Runtime/coarray.h
+++ b/flang/include/flang/Runtime/coarray.h
@@ -16,8 +16,8 @@ namespace Fortran::runtime {
 // class Descriptor;
 extern "C" {
 
-void RTDECL(ComputeLastUcobound)(
-    int num_images, const Descriptor &lcobounds, const Descriptor &ucobounds);
+void RTDECL(ComputeLastUcobound)(int num_images, const Descriptor &lcobounds,
+    const Descriptor &ucobounds, int rank);
 }
 } // namespace Fortran::runtime
 
diff --git a/flang/lib/Lower/Allocatable.cpp b/flang/lib/Lower/Allocatable.cpp
index 839a54c651e23..8408cbe48f36c 100644
--- a/flang/lib/Lower/Allocatable.cpp
+++ b/flang/lib/Lower/Allocatable.cpp
@@ -481,30 +481,7 @@ class AllocateStmtHelper {
                             !box.isPointer();
     unsigned allocatorIdx = Fortran::lower::getAllocatorIdx(alloc.getSymbol());
 
-    const Fortran::lower::SomeExpr *expr =
-        Fortran::semantics::GetExpr(alloc.getAllocObj());
-    std::optional<Fortran::evaluate::DataRef> dataRef =
-        !expr ? std::nullopt : Fortran::evaluate::ExtractDataRef(expr);
-    bool isCoarrayAllocate = alloc.hasCoarraySpec();
-
-    if (isCoarrayAllocate) {
-      errorManager.genStatCheck(builder, loc);
-      genAllocateObjectInit(box, allocatorIdx);
-      Fortran::lower::StatementContext stmtCtx;
-      genSetType(alloc, box, loc);
-      genSetDeferredLengthParameters(alloc, box);
-      genAllocateObjectBounds(alloc, box);
-      mlir::Value stat;
-      stat = Fortran::lower::genAllocateCoarray(
-          converter, loc, alloc.getSymbol(), box.getAddr(),
-          alloc.getCoarraySpec(), errorManager.errMsgAddr);
-      fir::factory::syncMutableBoxFromIRBox(builder, loc, box);
-      postAllocationAction(alloc, box);
-      errorManager.assignStat(builder, loc, stat);
-      return;
-    }
-
-    if (inlineAllocation &&
+    if (inlineAllocation && !alloc.hasCoarraySpec() &&
         ((isCudaAllocate && isCudaDeviceContext) || !isCudaAllocate)) {
       // Pointers must use PointerAllocate so that their deallocations
       // can be validated.
@@ -532,7 +509,11 @@ class AllocateStmtHelper {
     genSetDeferredLengthParameters(alloc, box);
     genAllocateObjectBounds(alloc, box);
     mlir::Value stat;
-    if (!isCudaAllocate) {
+    if (alloc.hasCoarraySpec()) {
+      stat = Fortran::lower::genAllocateCoarray(
+          converter, loc, alloc.getSymbol(), box.getAddr(),
+          alloc.getCoarraySpec(), errorManager.errMsgAddr);
+    } else if (!isCudaAllocate) {
       stat = genRuntimeAllocate(builder, loc, box, errorManager);
       setPinnedToFalse();
     } else {
@@ -662,8 +643,6 @@ class AllocateStmtHelper {
     // Generate a sequence of runtime calls.
     errorManager.genStatCheck(builder, loc);
     genAllocateObjectInit(box, allocatorIdx);
-    if (alloc.hasCoarraySpec())
-      TODO(loc, "coarray: allocation of a coarray object");
     // Set length of the allocate object if it has. Otherwise, get the length
     // from source for the deferred length parameter.
     const bool isDeferredLengthCharacter =
@@ -677,7 +656,12 @@ class AllocateStmtHelper {
       genSetDeferredLengthParameters(alloc, box);
     genAllocateObjectBounds(alloc, box);
     mlir::Value stat;
-    if (Fortran::semantics::HasCUDAAttr(alloc.getSymbol()) || sourceIsDevice) {
+    if (alloc.hasCoarraySpec()) {
+      stat = Fortran::lower::genAllocateCoarray(
+          converter, loc, alloc.getSymbol(), box.getAddr(),
+          alloc.getCoarraySpec(), errorManager.errMsgAddr);
+    } else if (Fortran::semantics::HasCUDAAttr(alloc.getSymbol()) ||
+               sourceIsDevice) {
       stat =
           genCudaAllocate(builder, loc, box, errorManager, alloc.getSymbol());
     } else {
@@ -916,26 +900,10 @@ genDeallocate(fir::FirOpBuilder &builder,
       !box.isDerived() && !box.isPolymorphic() && !box.hasAssumedRank() &&
       !box.isUnlimitedPolymorphic() && !errorManager.hasStatSpec() &&
       !useAllocateRuntime && !box.isPointer();
-
-  std::optional<Fortran::evaluate::DataRef> dataRef =
-      !allocExpr ? std::nullopt : Fortran::evaluate::ExtractDataRef(allocExpr);
   bool isCoarraySymbol = symbol && Fortran::evaluate::IsCoarray(*symbol);
 
-  // Deallocate coarray
-  if (isCoarraySymbol) {
-    mlir::Value ret = builder.createTemporary(loc, builder.getI32Type());
-    mif::DeallocCoarrayOp::create(builder, loc, box.getAddr(), ret,
-                                  errorManager.errMsgAddr);
-    ret = fir::LoadOp::create(builder, loc, ret);
-    fir::factory::syncMutableBoxFromIRBox(builder, loc, box);
-    if (symbol)
-      postDeallocationAction(converter, builder, *symbol);
-    errorManager.assignStat(builder, loc, ret);
-    return ret;
-  }
-
   // Deallocate intrinsic types inline.
-  if (inlineDeallocation &&
+  if (inlineDeallocation && !isCoarraySymbol &&
       ((isCudaSymbol && isCudaDeviceContext) || !isCudaSymbol)) {
     // Pointers must use PointerDeallocate so that their deallocations
     // can be validated.
@@ -948,7 +916,16 @@ genDeallocate(fir::FirOpBuilder &builder,
   // with its descriptor before and after calls if needed.
   errorManager.genStatCheck(builder, loc);
   mlir::Value stat;
-  if (!isCudaSymbol)
+  if (isCoarraySymbol) {
+    stat = errorManager.hasStatSpec()
+               ? builder.createTemporary(loc, builder.getI32Type())
+               : fir::AbsentOp::create(
+                     builder, loc, builder.getRefType(builder.getI32Type()));
+    mif::DeallocCoarrayOp::create(builder, loc, box.getAddr(), stat,
+                                  errorManager.errMsgAddr);
+    if (errorManager.hasStatSpec())
+      stat = fir::LoadOp::create(builder, loc, stat);
+  } else if (!isCudaSymbol)
     stat =
         genRuntimeDeallocate(builder, loc, box, errorManager, declaredTypeDesc);
   else
diff --git a/flang/lib/Lower/ConvertVariable.cpp b/flang/lib/Lower/ConvertVariable.cpp
index 26c2e67ee4015..9d7efdfe3bf83 100644
--- a/flang/lib/Lower/ConvertVariable.cpp
+++ b/flang/lib/Lower/ConvertVariable.cpp
@@ -671,6 +671,33 @@ getLinkageAttribute(Fortran::lower::AbstractConverter &converter,
   return builder.createInternalLinkage();
 }
 
+static void
+genCleanupDeallocateCoarray(Fortran::lower::AbstractConverter &converter,
+                            const Fortran::lower::pft::Variable &var,
+                            Fortran::lower::SymMap &symMap) {
+  mlir::Location loc = converter.getCurrentLocation();
+  const Fortran::semantics::Symbol &sym = var.getSymbol();
+  if (hasFinalization(sym) || hasAllocatableDirectComponent(sym))
+    TODO(loc, "Coarray with finalization.");
+
+  auto *builder = &converter.getFirOpBuilder();
+  fir::ExtendedValue exv = converter.getSymbolExtendedValue(sym, &symMap);
+  if (!Fortran::semantics::IsDummy(var.getSymbol())) {
+    converter.getFctCtx().attachCleanup([builder, loc, exv]() {
+      mif::DeallocCoarrayOp::create(*builder, loc, fir::getBase(exv),
+                                    /*stat*/ mlir::Value{},
+                                    /*errmsg*/ mlir::Value{});
+    });
+  } else {
+    // PRIF provide prif_alias_destroy to delete an aliased descriptor
+    // for a coarray. This procedure does not deallocate or alter the
+    // orginal coarray but need to be called when we leave the scope
+    // for a dummy coarray argument.The MIF dialect will provide an
+    // operation to handle this case.
+    TODO(loc, "Cleanup of dummy coarray.");
+  }
+}
+
 /// Instantiate a global variable. If it hasn't already been processed, add
 /// the global to the ModuleOp as a new uniqued symbol and initialize it with
 /// the correct value. It will be referenced on demand using `fir.addr_of`.
@@ -703,6 +730,14 @@ static void instantiateGlobal(Fortran::lower::AbstractConverter &converter,
   mlir::Value cast = builder.createConvert(loc, varAddrType, addrOf);
   Fortran::lower::StatementContext stmtCtx;
   mapSymbolAttributes(converter, var, symMap, stmtCtx, cast);
+  // Local coarray must have the SAVE or ALLOCATABLE attribute and are
+  // never explicitly deallaocated or finalized (see 7.5.6.4).
+  // Otherwize, a coarray is global we will add an implicit deallocation
+  // for nonallocatable and nonpointer at the end of the scope.
+  if (Fortran::evaluate::IsCoarray(sym) &&
+      !Fortran::semantics::IsAllocatable(sym) &&
+      !Fortran::semantics::IsPointer(sym))
+    genCleanupDeallocateCoarray(converter, var, symMap);
 }
 
 bool needCUDAAlloc(const Fortran::semantics::Symbol &sym) {
@@ -1134,22 +1169,7 @@ static void instantiateLocal(Fortran::lower::AbstractConverter &converter,
       });
     }
   }
-  if (Fortran::evaluate::IsCoarray(var.getSymbol()) &&
-      !Fortran::semantics::IsAllocatableOrPointer(var.getSymbol()) &&
-      !Fortran::semantics::IsDummy(var.getSymbol())) {
-    mlir::Location loc = converter.getCurrentLocation();
-    fir::ExtendedValue exv =
-        converter.getSymbolExtendedValue(var.getSymbol(), &symMap);
-    auto *sym = &var.getSymbol();
-    const Fortran::semantics::Scope &owner = sym->owner();
-    if (owner.kind() != Fortran::semantics::Scope::Kind::MainProgram) {
-      converter.getFctCtx().attachCleanup([builder, loc, exv]() {
-        mif::DeallocCoarrayOp::create(*builder, loc, fir::getBase(exv),
-                                      /*stat*/ mlir::Value{},
-                                      /*errmsg*/ mlir::Value{});
-      });
-    }
-  }
+
   if (std::optional<VariableCleanUp> cleanup =
           needDeallocationOrFinalization(var)) {
     auto *builder = &converter.getFirOpBuilder();
diff --git a/flang/lib/Lower/MultiImageFortran.cpp b/flang/lib/Lower/MultiImageFortran.cpp
index a498a10f3e74b..cd028e5d67e20 100644
--- a/flang/lib/Lower/MultiImageFortran.cpp
+++ b/flang/lib/Lower/MultiImageFortran.cpp
@@ -13,6 +13,7 @@
 
 #include "flang/Lower/MultiImageFortran.h"
 #include "flang/Lower/AbstractConverter.h"
+#include "flang/Lower/Support/Utils.h"
 #include "flang/Lower/SymbolMap.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/MIFCommon.h"
@@ -262,100 +263,165 @@ void Fortran::lower::genFormTeamStatement(
 // COARRAY utils
 //===----------------------------------------------------------------------===//
 
-mlir::DenseI64ArrayAttr
+mlir::Value
 Fortran::lower::genLowerCoBounds(Fortran::lower::AbstractConverter &converter,
                                  mlir::Location loc,
                                  const Fortran::semantics::Symbol &sym) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
-  mlir::DenseI64ArrayAttr lcobounds;
+  Fortran::lower::StatementContext stmtCtx;
+  mlir::Type i64Ty = builder.getI64Type();
+  mlir::Type addrType = builder.getRefType(i64Ty);
+  mlir::Value one = builder.createIntegerConstant(loc, i64Ty, 1);
+  mlir::Value lcobounds;
 
   if (Fortran::semantics::IsAllocatableOrObjectPointer(&sym))
-    return {};
+    mlir::emitError(
+        loc,
+        "Unable to use genLowerCoBounds on ALLOCATABLE and POINTER symbol");
   if (const auto *object =
           sym.GetUltimate()
               .detailsIf<Fortran::semantics::ObjectEntityDetails>()) {
-    llvm::SmallVector<std::int64_t> lcbs;
-    for (const Fortran::semantics::ShapeSpec &cobounds : object->coshape()) {
-      if (auto lb = cobounds.lbound().GetExplicit()) {
-        if (auto constant = Fortran::evaluate::ToInt64(*lb))
-          lcbs.push_back(*constant);
-        else
-          lcbs.push_back(1); // default lcobounds
+    size_t corank = object->coshape().size();
+    mlir::Type arrayType = fir::SequenceType::get(
+        {static_cast<fir::SequenceType::Extent>(corank)}, i64Ty);
+    lcobounds = builder.createTemporary(loc, arrayType);
+    mlir::Value lcovalue = one; // default lcobounds
+    for (size_t i = 0; i < corank; i++) {
+      if (auto lb = object->coshape()[i].lbound().GetExplicit()) {
+        auto lbExpr = ignoreEvConvert(*lb);
+        lcovalue = fir::getBase(converter.genExprValue(loc, lbExpr, stmtCtx));
       }
+
+      if (lcovalue.getType() != i64Ty)
+        lcovalue = fir::ConvertOp::create(builder, loc, i64Ty, lcovalue);
+      mlir::Value index =
+          builder.createIntegerConstant(loc, builder.getIndexType(), i);
+      mlir::Value lcoaddr =
+          fir::CoordinateOp::create(builder, loc, addrType, lcobounds, index);
+      fir::StoreOp::create(builder, loc, lcovalue, lcoaddr);
     }
-    lcobounds = mlir::DenseI64ArrayAttr::get(builder.getContext(), lcbs);
+    lcobounds = builder.createBox(loc, lcobounds);
   }
   return lcobounds;
 }
 
-mlir::DenseI64ArrayAttr
+mlir::Value
 Fortran::lower::genUpperCoBounds(Fortran::lower::AbstractConverter &converter,
                                  mlir::Location loc,
                                  const Fortran::semantics::Symbol &sym) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
-  mlir::DenseI64ArrayAttr ucobounds;
+  Fortran::lower::StatementContext stmtCtx;
+  mlir::Type i64Ty = builder.getI64Type();
+  mlir::Type addrType = builder.getRefType(i64Ty);
+  mlir::Value one = builder.createIntegerConstant(loc, i64Ty, 1);
+  mlir::Value ucobounds;
 
   if (Fortran::semantics::IsAllocatableOrObjectPointer(&sym))
-    return {};
+    mlir::emitError(
+        loc,
+        "Unable to use genUpperCoBounds on ALLOCATABLE and POINTER symbol");
   if (const auto *object =
           sym.GetUltimate()
               .detailsIf<Fortran::semantics::ObjectEntityDetails>()) {
-    llvm::SmallVector<std::int64_t> ucbs;
-    for (const Fortran::semantics::ShapeSpec &cobounds : object->coshape()) {
-      if (cobounds.ubound().isStar()) {
-        ucbs.push_back(-1);
-      } else if (auto ub = cobounds.ubound().GetExplicit()) {
-        if (auto constant = Fortran::evaluate::ToInt64(*ub))
-          ucbs.push_back(*constant);
-        else {
-          if (auto lb = cobounds.lbound().GetExplicit()) {
-            if (auto constant2 = Fortran::evaluate::ToInt64(*lb))
-              ucbs.push_back(*constant2);
-            else
-              ucbs.push_back(1); // use lcobound as default value
-          }
-        }
+    size_t corank = object->coshape().size();
+    mlir::Type arrayType = fir::SequenceType::get(
+        {static_cast<fir::SequenceType::Extent>(corank)}, i64Ty);
+    ucobounds = builder.createTemporary(loc, arrayType);
+    mlir::Value ucovalue;
+    for (size_t i = 0; i < corank; i++) {
+      if (auto ub = object->coshape()[i].lbound().GetExplicit()) {
+        auto ubExpr = ignoreEvConvert(*ub);
+        ucovalue = fir::getBase(converter.genExprValue(loc, ubExpr, stmtCtx));
+      } else if (object->coshape()[i].ubound().isStar())
+        ucovalue = builder.createIntegerConstant(loc, i64Ty, -1);
+      else {
+        if (auto lb = object->coshape()[i].lbound().GetExplicit()) {
+          auto lbExpr = ignoreEvConvert(*lb);
+          ucovalue = fir::getBase(converter.genExprValue(
+              loc, lbExpr, stmtCtx)); // default value from lcobound
+        } else
+          ucovalue = one;
       }
+      if (ucovalue.getType() != i64Ty)
+        ucovalue = fir::ConvertOp::create(builder, loc, i64Ty, ucovalue);
+      mlir::Value index =
+          builder.createIntegerConstant(loc, builder.getIndexType(), i);
+      mlir::Value ucoaddr =
+          fir::CoordinateOp::create(builder, loc, addrType, ucobounds, index);
+      fir::StoreOp::create(builder, loc, ucovalue, ucoaddr);
     }
-    ucobounds = mlir::DenseI64ArrayAttr::get(builder.getContext(), ucbs);
+    ucobounds = builder.createBox(loc, ucobounds);
   }
   return ucobounds;
 }
 
-static std::tuple<mlir::DenseI64ArrayAttr, mlir::DenseI64ArrayAttr>
-genCoBoundsAttrs(Fortran::lower::AbstractConverter &converter,
-                 mlir::Location loc,
-                 const Fortran::parser::AllocateCoarraySpec &allocSpec) {
+static std::tuple<mlir::Value, mlir::Value>
+genCoBounds(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
+            const Fortran::parser::AllocateCoarraySpec &allocSpec) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
+  Fortran::lower::StatementContext stmtCtx;
   llvm::SmallVector<std::int64_t> lcbs, ucbs;
+  mlir::Type i64Ty = builder.getI64Type();
+  mlir::Type addrType = builder.getRefType(i64Ty);
+  mlir::Value one = builder.createIntegerConstant(loc, i64Ty, 1);
 
   const std::list<Fortran::parser::AllocateCoshapeSpec> &coshapeSpecs =
       std::get<0>(allocSpec.t);
+  size_t corank = coshapeSpecs.size() + 1;
+  mlir::Type arrayType = fir::SequenceType::get(
+      {static_cast<fir::SequenceType::Extent>(corank)}, i64Ty);
+  mlir::Value lcobounds = builder.createTemporary(loc, arrayType);
+  mlir::Value ucobounds = builder.createTemporary(loc, arrayType);
+  size_t i = 0;
   for (const Fortran::parser::AllocateCoshapeSpec &coshapeSpec : coshapeSpecs) {
-    std::int64_t lb;
-    if (const std::optional<Fortran::parser::BoundExpr> &lbExpr =
-            std::get<0>(coshapeSpec.t))
-      lb = *Fortran::evaluate::ToInt64(Fortran::semantics::GetExpr(*lbExpr));
-    else
-      lb = 1;
-    lcbs.push_back(lb);
-    ucbs.push_back(*Fortran::evaluate::ToInt64(
-        Fortran::semantics::GetExpr(std::get<1>(coshapeSpec.t))));
+    const std::optional<Fortran::parser::BoundExpr> &lbExpr =
+        std::get<0>(coshapeSpec.t);
+    const Fortran::parser::BoundExpr &ubExpr = std::get<1>(coshapeSpec.t);
+    mlir::Value lb = one;
+    if (lbExpr.has_value()) {
+      auto expr = Fortran::semantics::GetExpr(*lbExpr);
+      lb = fir::getBase(converter.genExprValue(loc, expr, stmtCtx));
+      if (lb.getType() != i64Ty)
+        lb = fir::ConvertOp::create(builder, loc, i64Ty, lb);
+    }
+
+    auto ube = Fortran::semantics::GetExpr(ubExpr);
+    mlir::Value ub = fir::getBase(converter.genExprValue(loc, ube, stmtCtx));
+    if (ub.getType() != i64Ty)
+      ub = fir::ConvertOp::create(builder, loc, i64Ty, ub);
+
+    mlir::Value index =
+        builder.createIntegerConstant(loc, builder.getIndexType(), i);
+    // Lcobound
+    mlir::Value lcoaddr =
+        fir::CoordinateOp::create(builder, loc, addrType, lcobounds, index);
+    fir::StoreOp::create(builder, loc, lb, lcoaddr);
+    // Ucobound
+    mlir::Value ucoaddr =
+        fir::CoordinateOp::create(builder, loc, addrType, ucobounds, index);
+    fir::StoreOp::create(builder, loc, ub, ucoaddr);
+    i++;
+  }
+  // Last cobound;
+  {
+    mlir::Value lb = one;
+    if (const std::optional<Fortran::parser::BoundExpr> &lastCobound =
+            std::get<1>(allocSpec.t)) {
+      auto expr = Fortran::semantics::GetExpr(*lastCobound);
+      lb = fir::getBase(converter.genExprValue(loc, expr, stmtCtx));
+    }
+    mlir::Value index =
+        builder.createIntegerConstant(loc, builder.getIndexType(), i);
+    mlir::Value lcoaddr =
+        fir::CoordinateOp::create(builder, loc, addrType, lcobounds, index);
+    mlir::Value ucoaddr =
+        fir::CoordinateOp::create(builder, loc, addrType, ucobounds, index);
+    fir::StoreOp::create(builder, loc, lb, lcoaddr);
+    fir::StoreOp::create(builder, loc, lb, ucoaddr);
   }
 
-  const std::optional<Fortran::parser::BoundExpr> &lastBound =
-      std::get<1>(allocSpec.t);
-  if (lastBound.has_value())
-    lcbs.push_back(
-        *Fortran::evaluate::ToInt64(Fortran::semantics::GetExpr(*lastBound)));
-  else
-    lcbs.push_back(1);
-  ucbs.push_back(-1);
-
-  mlir::DenseI64ArrayAttr lcobounds =
-      mlir::DenseI64ArrayAttr::get(builder.getContext(), lcbs);
-  mlir::DenseI64ArrayAttr ucobounds =
-      mlir::DenseI64ArrayAttr::get(builder.getContext(), ucbs);
+  lcobounds = builder.createBox(loc, lcobounds);
+  ucobounds = builder.createBox(loc, ucobounds);
   return {lcobounds, ucobounds};
 }
 
@@ -371,10 +437,9 @@ mlir::Value Fortran::lower::genAllocateCoarray(
   if (hasStat)
     stat = builder.createTemporary(loc, builder.getI32Type());
 
-  mlir::DenseI64ArrayAttr lcobounds, ucobounds;
+  mlir::Value lcobounds, ucobounds;
   if (allocSpec.has_value()) {
-    std::tie(lcobounds, ucobounds) =
-        genCoBoundsAttrs(converter, loc, *allocSpec);
+    std::tie(lcobounds, ucobounds) = genCoBounds(converter, loc, *allocSpec);
   } else {
     lcobounds = Fortran::lower::genLowerCoBounds(converter, loc, sym);
     ucobounds = Fortran::lower::genUpperCoBounds(converter, loc, sym);
diff --git a/flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp b/flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp
index 241ecadc04252..ebeba9aa51494 100644
--- a/flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp
+++ b/flang/lib/Optimizer/Dialect/MIF/MIFOps.cpp
@@ -231,9 +231,8 @@ static void printChangeTeamOpBody(mlir::OpAsmPrinter &p, mif::ChangeTeamOp op,
 
 void mif::AllocCoarrayOp::build(mlir::OpBuilder &builder,
                                 mlir::OperationState &result, mlir::Value box,
-                                llvm::StringRef symName,
-                                mlir::DenseI64ArrayAttr lcbs,
-                                mlir::DenseI64ArrayAttr ucbs, mlir::Value stat,
+                                llvm::StringRef symName, mlir::Value lcbs,
+                                mlir::Value ucbs, mlir::Value stat,
                                 mlir::Value errmsg) {
   mlir::StringAttr nameAttr = builder.getStringAttr(symName);
   build(builder, result, nameAttr, box, lcbs, ucbs, stat, errmsg);
@@ -241,9 +240,8 @@ void mif::AllocCoarrayOp::build(mlir::OpBuilder &builder,
 
 void mif::AllocCoarrayOp::build(mlir::OpBuilder &builder,
                                 mlir::OperationState &result, mlir::Value box,
-                                llvm::StringRef symName,
-                                mlir::DenseI64ArrayAttr lcbs,
-                                mlir::DenseI64ArrayAttr ucbs) {
+                                llvm::StringRef symName, mlir::Value lcbs,
+                                mlir::Value ucbs) {
   build(builder, result, symName, box, lcbs, ucbs, /*stat*/ mlir::Value{},
         /*errmsg*/ mlir::Value{});
 }
@@ -253,6 +251,21 @@ llvm::LogicalResult mif::AllocCoarrayOp::verify() {
     TODO(getLoc(),
          "Derived type coarray with at least one ALLOCATABLE or POINTER "
          "component");
+
+  fir::BoxType lcElemType =
+      mlir::dyn_cast<fir::BoxType>(getLcobounds().getType());
+  if (auto seqTy = mlir::dyn_cast<fir::SequenceType>(
+          lcElemType.getElementOrSequenceType()))
+    if (!seqTy.getElementType().isInteger(64))
+      return emitOpError("lcobounds need to be a boxed array of I64 elements.");
+
+  fir::BoxType ucElemType =
+      mlir::dyn_cast<fir::BoxType>(getUcobounds().getType());
+  if (auto seqTy = mlir::dyn_cast<fir::SequenceType>(
+          ucElemType.getElementOrSequenceType()))
+    if (!seqTy.getElementType().isInteger(64))
+      return emitOpError("ucobounds need to be a boxed array of I64 elements.");
+
   return mlir::success();
 }
 
diff --git a/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp b/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
index 098c6b573f47c..2355e87d73b0d 100644
--- a/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
+++ b/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
@@ -130,48 +130,13 @@ static mlir::Value getNumImages(fir::FirOpBuilder &builder,
   return fir::LoadOp::create(builder, loc, result);
 }
 
-static std::pair<mlir::Value, mlir::Value>
-genCoBounds(fir::FirOpBuilder &builder, mlir::Location loc,
-            mif::AllocCoarrayOp op) {
-  mlir::Value ucobounds, lcobounds;
-  mlir::DenseI64ArrayAttr lcbsAttr = op.getLcoboundsAttr();
-  mlir::DenseI64ArrayAttr ucbsAttr = op.getUcoboundsAttr();
-
-  size_t corank = lcbsAttr.size();
-  mlir::Type i64Ty = builder.getI64Type();
-  mlir::Type addrType = builder.getRefType(i64Ty);
-  mlir::Type arrayType = fir::SequenceType::get(
-      {static_cast<fir::SequenceType::Extent>(corank)}, i64Ty);
-  lcobounds = builder.createTemporary(loc, arrayType);
-  ucobounds = builder.createTemporary(loc, arrayType);
-
-  for (size_t i = 0; i < corank; i++) {
-    auto index = builder.createIntegerConstant(loc, builder.getIndexType(), i);
-    // Lower cobounds
-    auto lcovalue = builder.createIntegerConstant(loc, i64Ty, lcbsAttr[i]);
-    auto lcoaddr =
-        fir::CoordinateOp::create(builder, loc, addrType, lcobounds, index);
-    fir::StoreOp::create(builder, loc, lcovalue, lcoaddr);
-
-    // Upper cobounds
-    auto ucovalue = builder.createIntegerConstant(loc, i64Ty, ucbsAttr[i]);
-    auto ucoaddr =
-        fir::CoordinateOp::create(builder, loc, addrType, ucobounds, index);
-    fir::StoreOp::create(builder, loc, ucovalue, ucoaddr);
-  }
-
-  lcobounds = builder.createBox(loc, lcobounds);
-  ucobounds = builder.createBox(loc, ucobounds);
-
-  // Computing last ucobound
-  mlir::func::FuncOp func =
-      fir::runtime::getRuntimeFunc<mkRTKey(ComputeLastUcobound)>(loc, builder);
-  mlir::Value numImages = getNumImages(builder, loc);
-  llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
-      builder, loc, func.getFunctionType(), numImages, lcobounds, ucobounds);
-  fir::CallOp::create(builder, loc, func, args);
-
-  return {lcobounds, ucobounds};
+static mlir::Value getRank(fir::FirOpBuilder &builder, mlir::Location loc,
+                           mlir::Value v) {
+  mlir::Type argTy = fir::unwrapPassByRefType(fir::unwrapRefType(v.getType()));
+  unsigned rank = 0;
+  if (auto seqTy = mlir::dyn_cast<fir::SequenceType>(argTy))
+    rank = seqTy.getDimension();
+  return builder.createIntegerConstant(loc, builder.getI32Type(), rank);
 }
 
 // Storing the coarray descriptor as a global variable
@@ -1101,7 +1066,6 @@ struct MIFAllocCoarrayOpConversion
 
     mlir::Value sizeInBytes =
         getSizeInBytes(builder, loc, mod, dl, typeConverter, op.getBox());
-    auto [lcobounds, ucobounds] = genCoBounds(builder, loc, op);
     mlir::Value stat = op.getStat();
     if (!stat)
       stat = fir::AbsentOp::create(builder, loc, getPRIFStatType(builder));
@@ -1109,8 +1073,8 @@ struct MIFAllocCoarrayOpConversion
         genErrmsgPRIF(builder, loc, op.getErrmsg());
 
     llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
-        builder, loc, ftype, lcobounds, ucobounds, sizeInBytes, finalFunc,
-        coarrayHandle, allocMem, stat, errmsgArg, errmsgAllocArg);
+        builder, loc, ftype, op.getLcobounds(), op.getUcobounds(), sizeInBytes,
+        finalFunc, coarrayHandle, allocMem, stat, errmsgArg, errmsgAllocArg);
     fir::CallOp callOp = fir::CallOp::create(builder, loc, funcOp, args);
 
     storeCoarrayHandle(builder, loc, coarrayHandle, op.getUniqName().str());
diff --git a/flang/test/Fir/MIF/coarray-alloc.mlir b/flang/test/Fir/MIF/coarray-alloc.mlir
index f85a2bd46d004..7596ffc61a00f 100644
--- a/flang/test/Fir/MIF/coarray-alloc.mlir
+++ b/flang/test/Fir/MIF/coarray-alloc.mlir
@@ -1,151 +1,238 @@
 // RUN: fir-opt --mif-convert %s | FileCheck %s
 
-module attributes {dlti.dl_spec = #dlti.dl_spec<!llvm.ptr<270> = dense<32> : vector<4xi64>, !llvm.ptr<271> = dense<32> : vector<4xi64>, !llvm.ptr<272> = dense<64> : vector<4xi64>, i64 = dense<64> : vector<2xi64>, i128 = dense<128> : vector<2xi64>, f80 = dense<128> : vector<2xi64>, !llvm.ptr = dense<64> : vector<4xi64>, i1 = dense<8> : vector<2xi64>, i8 = dense<8> : vector<2xi64>, i16 = dense<16> : vector<2xi64>, i32 = dense<32> : vector<2xi64>, f16 = dense<16> : vector<2xi64>, f64 = dense<64> : vector<2xi64>, f128 = dense<128> : vector<2xi64>, "dlti.endianness" = "little", "dlti.mangling_mode" = "e", "dlti.legal_int_widths" = array<i32: 8, 16, 32, 64>, "dlti.stack_alignment" = 128 : i64>, fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128", llvm.ident = "flang version 23.0.0 (git at github.com:SiPearl/llvm-project.git 19de25e93ebb883ee9ea006994d81c61a4817131)", llvm.target_triple = "x86_64-unknown-linux-gnu"} {
-// CHECK-LABEL: func.func @_QQmain
+module attributes {dlti.dl_spec = #dlti.dl_spec<!llvm.ptr<270> = dense<32> : vector<4xi64>, !llvm.ptr<271> = dense<32> : vector<4xi64>, !llvm.ptr<272> = dense<64> : vector<4xi64>, i64 = dense<64> : vector<2xi64>, i128 = dense<128> : vector<2xi64>, f80 = dense<128> : vector<2xi64>, !llvm.ptr = dense<64> : vector<4xi64>, i1 = dense<8> : vector<2xi64>, i8 = dense<8> : vector<2xi64>, i16 = dense<16> : vector<2xi64>, i32 = dense<32> : vector<2xi64>, f16 = dense<16> : vector<2xi64>, f64 = dense<64> : vector<2xi64>, f128 = dense<128> : vector<2xi64>, "dlti.endianness" = "little", "dlti.mangling_mode" = "e", "dlti.legal_int_widths" = array<i32: 8, 16, 32, 64>, "dlti.stack_alignment" = 128 : i64>, fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.data_layout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128", llvm.ident = "flang version 23.0.0 (git at github.com:SiPearl/llvm-project.git 3d6a6306c5cd826a2306fd17b1f65de34bcf866b)", llvm.target_triple = "x86_64-unknown-linux-gnu"} {
   func.func @_QQmain() attributes {fir.bindc_name = "ALLOC_TEST"} {
-    %0 = fir.alloca i32
-    %1 = fir.alloca i32
-    %2 = fir.alloca i32
-    %3 = fir.alloca i32
-    %4 = fir.alloca i32
-    %5 = fir.alloca i32
-    %6 = fir.dummy_scope : !fir.dscope
-    %7 = fir.address_of(@_QFE.n.my_type2) : !fir.ref<!fir.char<1,8>>
+    %0 = fir.alloca !fir.array<1xi64>
+    %1 = fir.alloca !fir.array<1xi64>
+    %2 = fir.alloca !fir.array<1xi64>
+    %3 = fir.alloca !fir.array<1xi64>
+    %4 = fir.alloca !fir.array<3xi64>
+    %5 = fir.alloca !fir.array<3xi64>
+    %6 = fir.alloca !fir.array<2xi64>
+    %7 = fir.alloca !fir.array<2xi64>
+    %8 = fir.alloca !fir.array<1xi64>
+    %9 = fir.alloca !fir.array<1xi64>
+    %10 = fir.alloca !fir.array<3xi64>
+    %11 = fir.alloca !fir.array<3xi64>
+    %12 = fir.alloca !fir.array<2xi64>
+    %13 = fir.alloca !fir.array<2xi64>
+    %14 = fir.dummy_scope : !fir.dscope
+    %15 = fir.address_of(@_QFE.n.my_type2) : !fir.ref<!fir.char<1,8>>
     %c8 = arith.constant 8 : index
-    %8:2 = hlfir.declare %7 typeparams %c8 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.my_type2"} : (!fir.ref<!fir.char<1,8>>, index) -> (!fir.ref<!fir.char<1,8>>, !fir.ref<!fir.char<1,8>>)
-    %9 = fir.address_of(@_QFE.n.co) : !fir.ref<!fir.char<1,2>>
+    %16:2 = hlfir.declare %15 typeparams %c8 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.my_type2"} : (!fir.ref<!fir.char<1,8>>, index) -> (!fir.ref<!fir.char<1,8>>, !fir.ref<!fir.char<1,8>>)
+    %17 = fir.address_of(@_QFE.n.co) : !fir.ref<!fir.char<1,2>>
     %c2 = arith.constant 2 : index
-    %10:2 = hlfir.declare %9 typeparams %c2 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.co"} : (!fir.ref<!fir.char<1,2>>, index) -> (!fir.ref<!fir.char<1,2>>, !fir.ref<!fir.char<1,2>>)
-    %11 = fir.address_of(@_QFE.n.x) : !fir.ref<!fir.char<1>>
+    %18:2 = hlfir.declare %17 typeparams %c2 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.co"} : (!fir.ref<!fir.char<1,2>>, index) -> (!fir.ref<!fir.char<1,2>>, !fir.ref<!fir.char<1,2>>)
+    %19 = fir.address_of(@_QFE.n.x) : !fir.ref<!fir.char<1>>
     %c1 = arith.constant 1 : index
-    %12:2 = hlfir.declare %11 typeparams %c1 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.x"} : (!fir.ref<!fir.char<1>>, index) -> (!fir.ref<!fir.char<1>>, !fir.ref<!fir.char<1>>)
-    %13 = fir.address_of(@_QFE.n.y) : !fir.ref<!fir.char<1>>
+    %20:2 = hlfir.declare %19 typeparams %c1 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.x"} : (!fir.ref<!fir.char<1>>, index) -> (!fir.ref<!fir.char<1>>, !fir.ref<!fir.char<1>>)
+    %21 = fir.address_of(@_QFE.n.y) : !fir.ref<!fir.char<1>>
     %c1_0 = arith.constant 1 : index
-    %14:2 = hlfir.declare %13 typeparams %c1_0 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.y"} : (!fir.ref<!fir.char<1>>, index) -> (!fir.ref<!fir.char<1>>, !fir.ref<!fir.char<1>>)
-    %15 = fir.address_of(@_QFE.n.z) : !fir.ref<!fir.char<1>>
+    %22:2 = hlfir.declare %21 typeparams %c1_0 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.y"} : (!fir.ref<!fir.char<1>>, index) -> (!fir.ref<!fir.char<1>>, !fir.ref<!fir.char<1>>)
+    %23 = fir.address_of(@_QFE.n.z) : !fir.ref<!fir.char<1>>
     %c1_1 = arith.constant 1 : index
-    %16:2 = hlfir.declare %15 typeparams %c1_1 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.z"} : (!fir.ref<!fir.char<1>>, index) -> (!fir.ref<!fir.char<1>>, !fir.ref<!fir.char<1>>)
-    %17 = fir.address_of(@_QFE.n.w) : !fir.ref<!fir.char<1>>
-    %c1_2 = arith.constant 1 : index
-    %18:2 = hlfir.declare %17 typeparams %c1_2 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.w"} : (!fir.ref<!fir.char<1>>, index) -> (!fir.ref<!fir.char<1>>, !fir.ref<!fir.char<1>>)
-    %19 = fir.address_of(@_QFE.n.my_type) : !fir.ref<!fir.char<1,7>>
+    %24:2 = hlfir.declare %23 typeparams %c1_1 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.z"} : (!fir.ref<!fir.char<1>>, index) -> (!fir.ref<!fir.char<1>>, !fir.ref<!fir.char<1>>)
+    %25 = fir.address_of(@_QFE.n.my_type) : !fir.ref<!fir.char<1,7>>
     %c7 = arith.constant 7 : index
-    %20:2 = hlfir.declare %19 typeparams %c7 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.my_type"} : (!fir.ref<!fir.char<1,7>>, index) -> (!fir.ref<!fir.char<1,7>>, !fir.ref<!fir.char<1,7>>)
-    %21 = fir.address_of(@_QFE.n.my_type3) : !fir.ref<!fir.char<1,8>>
-    %c8_3 = arith.constant 8 : index
-    %22:2 = hlfir.declare %21 typeparams %c8_3 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.my_type3"} : (!fir.ref<!fir.char<1,8>>, index) -> (!fir.ref<!fir.char<1,8>>, !fir.ref<!fir.char<1,8>>)
-    %23 = fir.address_of(@_QFEa) : !fir.ref<i32>
-
+    %26:2 = hlfir.declare %25 typeparams %c7 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.n.my_type"} : (!fir.ref<!fir.char<1,7>>, index) -> (!fir.ref<!fir.char<1,7>>, !fir.ref<!fir.char<1,7>>)
+    %27 = fir.address_of(@_QFEa) : !fir.ref<i32>
+    %c1_i64 = arith.constant 1 : i64
+    %c0 = arith.constant 0 : index
+    %28 = fir.coordinate_of %13, %c0 : (!fir.ref<!fir.array<2xi64>>, index) -> !fir.ref<i64>
+    fir.store %c1_i64 to %28 : !fir.ref<i64>
+    %c1_i64_2 = arith.constant 1 : i64
+    %c1_3 = arith.constant 1 : index
+    %29 = fir.coordinate_of %13, %c1_3 : (!fir.ref<!fir.array<2xi64>>, index) -> !fir.ref<i64>
+    fir.store %c1_i64_2 to %29 : !fir.ref<i64>
+    %30 = fir.embox %13 : (!fir.ref<!fir.array<2xi64>>) -> !fir.box<!fir.array<2xi64>>
+    %c1_i64_4 = arith.constant 1 : i64
+    %c0_5 = arith.constant 0 : index
+    %31 = fir.coordinate_of %12, %c0_5 : (!fir.ref<!fir.array<2xi64>>, index) -> !fir.ref<i64>
+    fir.store %c1_i64_4 to %31 : !fir.ref<i64>
+    %c1_i64_6 = arith.constant 1 : i64
+    %c1_7 = arith.constant 1 : index
+    %32 = fir.coordinate_of %12, %c1_7 : (!fir.ref<!fir.array<2xi64>>, index) -> !fir.ref<i64>
+    fir.store %c1_i64_6 to %32 : !fir.ref<i64>
+    %33 = fir.embox %12 : (!fir.ref<!fir.array<2xi64>>) -> !fir.box<!fir.array<2xi64>>
 // CHECK: fir.call @_QMprifPprif_allocate_coarray({{.*}}) : (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>, !fir.ref<i64>, !fir.ref<none>, !fir.box<none>, !fir.ptr<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
-    mif.alloc_coarray %23 {lcobounds = array<i64: 1, 1>, ucobounds = array<i64: 2, -1>, uniq_name = "_QFEa"} : (!fir.ref<i32>) -> ()
-    %24:2 = hlfir.declare %23 {uniq_name = "_QFEa"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
-    %25 = fir.address_of(@_QFEa2) : !fir.ref<!fir.box<!fir.heap<i32>>>
-    %26:2 = hlfir.declare %25 {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFEa2"} : (!fir.ref<!fir.box<!fir.heap<i32>>>) -> (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<!fir.box<!fir.heap<i32>>>)
-    %27 = fir.address_of(@_QFEb) : !fir.ref<f32>
-
+    mif.alloc_coarray %27 lcobounds %30 ucobounds %33 {uniq_name = "_QFEa"} : (!fir.ref<i32>, !fir.box<!fir.array<2xi64>>, !fir.box<!fir.array<2xi64>>) -> ()
+    %34:2 = hlfir.declare %27 {uniq_name = "_QFEa"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+    %35 = fir.address_of(@_QFEa2) : !fir.ref<!fir.box<!fir.heap<i32>>>
+    %36:2 = hlfir.declare %35 {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFEa2"} : (!fir.ref<!fir.box<!fir.heap<i32>>>) -> (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<!fir.box<!fir.heap<i32>>>)
+    %37 = fir.address_of(@_QFEb) : !fir.ref<f32>
+    %c3_i64 = arith.constant 3 : i64
+    %c0_8 = arith.constant 0 : index
+    %38 = fir.coordinate_of %11, %c0_8 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+    fir.store %c3_i64 to %38 : !fir.ref<i64>
+    %c1_i64_9 = arith.constant 1 : i64
+    %c1_10 = arith.constant 1 : index
+    %39 = fir.coordinate_of %11, %c1_10 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+    fir.store %c1_i64_9 to %39 : !fir.ref<i64>
+    %c1_i64_11 = arith.constant 1 : i64
+    %c2_12 = arith.constant 2 : index
+    %40 = fir.coordinate_of %11, %c2_12 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+    fir.store %c1_i64_11 to %40 : !fir.ref<i64>
+    %41 = fir.embox %11 : (!fir.ref<!fir.array<3xi64>>) -> !fir.box<!fir.array<3xi64>>
+    %c3_i64_13 = arith.constant 3 : i64
+    %c0_14 = arith.constant 0 : index
+    %42 = fir.coordinate_of %10, %c0_14 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+    fir.store %c3_i64_13 to %42 : !fir.ref<i64>
+    %c1_i64_15 = arith.constant 1 : i64
+    %c1_16 = arith.constant 1 : index
+    %43 = fir.coordinate_of %10, %c1_16 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+    fir.store %c1_i64_15 to %43 : !fir.ref<i64>
+    %c1_i64_17 = arith.constant 1 : i64
+    %c2_18 = arith.constant 2 : index
+    %44 = fir.coordinate_of %10, %c2_18 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+    fir.store %c1_i64_17 to %44 : !fir.ref<i64>
+    %45 = fir.embox %10 : (!fir.ref<!fir.array<3xi64>>) -> !fir.box<!fir.array<3xi64>>
 // CHECK: fir.call @_QMprifPprif_allocate_coarray({{.*}}) : (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>, !fir.ref<i64>, !fir.ref<none>, !fir.box<none>, !fir.ptr<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
-    mif.alloc_coarray %27 {lcobounds = array<i64: 3, 1, 1>, ucobounds = array<i64: 4, 5, -1>, uniq_name = "_QFEb"} : (!fir.ref<f32>) -> ()
-    %28:2 = hlfir.declare %27 {uniq_name = "_QFEb"} : (!fir.ref<f32>) -> (!fir.ref<f32>, !fir.ref<f32>)
-    %29 = fir.address_of(@_QFEb2) : !fir.ref<!fir.box<!fir.heap<f32>>>
-    %30:2 = hlfir.declare %29 {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFEb2"} : (!fir.ref<!fir.box<!fir.heap<f32>>>) -> (!fir.ref<!fir.box<!fir.heap<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>)
-    %31 = fir.address_of(@_QFEc) : !fir.ref<!fir.char<1,10>>
+    mif.alloc_coarray %37 lcobounds %41 ucobounds %45 {uniq_name = "_QFEb"} : (!fir.ref<f32>, !fir.box<!fir.array<3xi64>>, !fir.box<!fir.array<3xi64>>) -> ()
+    %46:2 = hlfir.declare %37 {uniq_name = "_QFEb"} : (!fir.ref<f32>) -> (!fir.ref<f32>, !fir.ref<f32>)
+    %47 = fir.address_of(@_QFEb2) : !fir.ref<!fir.box<!fir.heap<f32>>>
+    %48:2 = hlfir.declare %47 {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFEb2"} : (!fir.ref<!fir.box<!fir.heap<f32>>>) -> (!fir.ref<!fir.box<!fir.heap<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>)
+    %49 = fir.address_of(@_QFEc) : !fir.ref<!fir.char<1,10>>
     %c10 = arith.constant 10 : index
-
+    %c1_i64_19 = arith.constant 1 : i64
+    %c0_20 = arith.constant 0 : index
+    %50 = fir.coordinate_of %9, %c0_20 : (!fir.ref<!fir.array<1xi64>>, index) -> !fir.ref<i64>
+    fir.store %c1_i64_19 to %50 : !fir.ref<i64>
+    %51 = fir.embox %9 : (!fir.ref<!fir.array<1xi64>>) -> !fir.box<!fir.array<1xi64>>
+    %c1_i64_21 = arith.constant 1 : i64
+    %c0_22 = arith.constant 0 : index
+    %52 = fir.coordinate_of %8, %c0_22 : (!fir.ref<!fir.array<1xi64>>, index) -> !fir.ref<i64>
+    fir.store %c1_i64_21 to %52 : !fir.ref<i64>
+    %53 = fir.embox %8 : (!fir.ref<!fir.array<1xi64>>) -> !fir.box<!fir.array<1xi64>>
 // CHECK: fir.call @_QMprifPprif_allocate_coarray({{.*}}) : (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>, !fir.ref<i64>, !fir.ref<none>, !fir.box<none>, !fir.ptr<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
-    mif.alloc_coarray %31 {lcobounds = array<i64: 1>, ucobounds = array<i64: -1>, uniq_name = "_QFEc"} : (!fir.ref<!fir.char<1,10>>) -> ()
-    %32:2 = hlfir.declare %31 typeparams %c10 {uniq_name = "_QFEc"} : (!fir.ref<!fir.char<1,10>>, index) -> (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,10>>)
-    %33 = fir.address_of(@_QFEc2) : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>
-    %34:2 = hlfir.declare %33 {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFEc2"} : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>) -> (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>)
-    %35 = fir.address_of(@_QFEd) : !fir.ref<!fir.type<_QFTmy_type{x:i32,y:!fir.box<!fir.heap<!fir.array<?xi32>>>,z:!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>}>>
-    %36:2 = hlfir.declare %35 {uniq_name = "_QFEd"} : (!fir.ref<!fir.type<_QFTmy_type{x:i32,y:!fir.box<!fir.heap<!fir.array<?xi32>>>,z:!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>}>>) -> (!fir.ref<!fir.type<_QFTmy_type{x:i32,y:!fir.box<!fir.heap<!fir.array<?xi32>>>,z:!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>}>>, !fir.ref<!fir.type<_QFTmy_type{x:i32,y:!fir.box<!fir.heap<!fir.array<?xi32>>>,z:!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>}>>)
-    %37 = fir.address_of(@_QFEd2) : !fir.ref<!fir.type<_QFTmy_type3{w:!fir.box<!fir.heap<!fir.array<?xi32>>>}>>
-
-    %38:2 = hlfir.declare %37 {uniq_name = "_QFEd2"} : (!fir.ref<!fir.type<_QFTmy_type3{w:!fir.box<!fir.heap<!fir.array<?xi32>>>}>>) -> (!fir.ref<!fir.type<_QFTmy_type3{w:!fir.box<!fir.heap<!fir.array<?xi32>>>}>>, !fir.ref<!fir.type<_QFTmy_type3{w:!fir.box<!fir.heap<!fir.array<?xi32>>>}>>)
-    %39 = fir.address_of(@_QFE.c.my_type2) : !fir.ref<!fir.array<1x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>
-    %c0 = arith.constant 0 : index
-    %c1_4 = arith.constant 1 : index
-    %40 = fir.shape_shift %c0, %c1_4 : (index, index) -> !fir.shapeshift<1>
-    %41:2 = hlfir.declare %39(%40) {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.c.my_type2"} : (!fir.ref<!fir.array<1x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>, !fir.shapeshift<1>) -> (!fir.box<!fir.array<1x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>, !fir.ref<!fir.array<1x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>)
-    %42 = fir.address_of(@_QFE.c.my_type3) : !fir.ref<!fir.array<1x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>
-    %c0_5 = arith.constant 0 : index
-    %c1_6 = arith.constant 1 : index
-    %43 = fir.shape_shift %c0_5, %c1_6 : (index, index) -> !fir.shapeshift<1>
-    %44:2 = hlfir.declare %42(%43) {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.c.my_type3"} : (!fir.ref<!fir.array<1x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>, !fir.shapeshift<1>) -> (!fir.box<!fir.array<1x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>, !fir.ref<!fir.array<1x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>)
-    %45 = fir.address_of(@_QFE.dt.my_type) : !fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>
-    %46:2 = hlfir.declare %45 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.dt.my_type"} : (!fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>) -> (!fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>, !fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>)
-    %47 = fir.address_of(@_QFE.dt.my_type3) : !fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>
-    %48:2 = hlfir.declare %47 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.dt.my_type3"} : (!fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>) -> (!fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>, !fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>)
-    %49 = fir.address_of(@_QFE.dt.my_type2) : !fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>
-    %50:2 = hlfir.declare %49 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.dt.my_type2"} : (!fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>) -> (!fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>, !fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>)
-    %51 = fir.address_of(@_QFE.c.my_type) : !fir.ref<!fir.array<3x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>
-    %c0_7 = arith.constant 0 : index
+    mif.alloc_coarray %49 lcobounds %51 ucobounds %53 {uniq_name = "_QFEc"} : (!fir.ref<!fir.char<1,10>>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<1xi64>>) -> ()
+    %54:2 = hlfir.declare %49 typeparams %c10 {uniq_name = "_QFEc"} : (!fir.ref<!fir.char<1,10>>, index) -> (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,10>>)
+    %55 = fir.address_of(@_QFEc2) : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>
+    %56:2 = hlfir.declare %55 {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFEc2"} : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>) -> (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>)
+    %57 = fir.address_of(@_QFEd) : !fir.ref<!fir.type<_QFTmy_type{x:i32,y:!fir.box<!fir.heap<!fir.array<?xi32>>>,z:!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>}>>
+    %58:2 = hlfir.declare %57 {uniq_name = "_QFEd"} : (!fir.ref<!fir.type<_QFTmy_type{x:i32,y:!fir.box<!fir.heap<!fir.array<?xi32>>>,z:!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>}>>) -> (!fir.ref<!fir.type<_QFTmy_type{x:i32,y:!fir.box<!fir.heap<!fir.array<?xi32>>>,z:!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>}>>, !fir.ref<!fir.type<_QFTmy_type{x:i32,y:!fir.box<!fir.heap<!fir.array<?xi32>>>,z:!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>}>>)
+    %59 = fir.address_of(@_QFE.c.my_type2) : !fir.ref<!fir.array<1x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>
+    %c0_23 = arith.constant 0 : index
+    %c1_24 = arith.constant 1 : index
+    %60 = fir.shape_shift %c0_23, %c1_24 : (index, index) -> !fir.shapeshift<1>
+    %61:2 = hlfir.declare %59(%60) {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.c.my_type2"} : (!fir.ref<!fir.array<1x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>, !fir.shapeshift<1>) -> (!fir.box<!fir.array<1x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>, !fir.ref<!fir.array<1x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>)
+    %62 = fir.address_of(@_QFE.dt.my_type) : !fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>
+    %63:2 = hlfir.declare %62 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.dt.my_type"} : (!fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>) -> (!fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>, !fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>)
+    %64 = fir.address_of(@_QFE.dt.my_type2) : !fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>
+    %65:2 = hlfir.declare %64 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.dt.my_type2"} : (!fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>) -> (!fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>, !fir.ref<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>)
+    %66 = fir.address_of(@_QFE.c.my_type) : !fir.ref<!fir.array<3x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>
+    %c0_25 = arith.constant 0 : index
     %c3 = arith.constant 3 : index
-    %52 = fir.shape_shift %c0_7, %c3 : (index, index) -> !fir.shapeshift<1>
-    %53:2 = hlfir.declare %51(%52) {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.c.my_type"} : (!fir.ref<!fir.array<3x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>, !fir.shapeshift<1>) -> (!fir.box<!fir.array<3x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>, !fir.ref<!fir.array<3x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>)
-    %54 = fir.absent !fir.box<none>
-
+    %67 = fir.shape_shift %c0_25, %c3 : (index, index) -> !fir.shapeshift<1>
+    %68:2 = hlfir.declare %66(%67) {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QFE.c.my_type"} : (!fir.ref<!fir.array<3x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>, !fir.shapeshift<1>) -> (!fir.box<!fir.array<3x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>, !fir.ref<!fir.array<3x!fir.type<_QM__fortran_type_infoTcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,genre:i8,category:i8,kind:i8,rank:i8,memoryspace:i8,__padding0:!fir.array<3xi8>,offset:i64,characterlen:!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>,derived:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype{binding:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTbinding{proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>}>>>>,name:!fir.box<!fir.ptr<!fir.char<1,?>>>,sizeinbytes:i64,uninstantiated:!fir.box<!fir.ptr<!fir.type<_QM__fortran_type_infoTderivedtype>>>,kindparameter:!fir.box<!fir.ptr<!fir.array<?xi64>>>,lenparameterkind:!fir.box<!fir.ptr<!fir.array<?xi8>>>,component:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTcomponent>>>>,procptr:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTprocptrcomponent{name:!fir.box<!fir.ptr<!fir.char<1,?>>>,offset:i64,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,special:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTspecialbinding{which:i8,isargdescriptorset:i8,istypebound:i8,specialcaseflag:i8,__padding0:!fir.array<4xi8>,proc:!fir.type<_QM__fortran_builtinsT__builtin_c_funptr{__address:i64}>}>>>>,specialbitset:i32,hasparent:i8,noinitializationneeded:i8,nodestructionneeded:i8,nofinalizationneeded:i8,nodefinedassignment:i8,__padding0:!fir.array<3xi8>}>>>,lenvalue:!fir.box<!fir.ptr<!fir.array<?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,bounds:!fir.box<!fir.ptr<!fir.array<?x?x!fir.type<_QM__fortran_type_infoTvalue{genre:i8,__padding0:!fir.array<7xi8>,value:i64}>>>>,initialization:!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>}>>>)
+    %69 = fir.absent !fir.box<none>
+    %c1_i64_26 = arith.constant 1 : i64
+    %c2_i32 = arith.constant 2 : i32
+    %70 = fir.convert %c2_i32 : (i32) -> i64
+    %c0_27 = arith.constant 0 : index
+    %71 = fir.coordinate_of %7, %c0_27 : (!fir.ref<!fir.array<2xi64>>, index) -> !fir.ref<i64>
+    fir.store %c1_i64_26 to %71 : !fir.ref<i64>
+    %72 = fir.coordinate_of %6, %c0_27 : (!fir.ref<!fir.array<2xi64>>, index) -> !fir.ref<i64>
+    fir.store %70 to %72 : !fir.ref<i64>
+    %c1_28 = arith.constant 1 : index
+    %73 = fir.coordinate_of %7, %c1_28 : (!fir.ref<!fir.array<2xi64>>, index) -> !fir.ref<i64>
+    %74 = fir.coordinate_of %6, %c1_28 : (!fir.ref<!fir.array<2xi64>>, index) -> !fir.ref<i64>
+    fir.store %c1_i64_26 to %73 : !fir.ref<i64>
+    fir.store %c1_i64_26 to %74 : !fir.ref<i64>
+    %75 = fir.embox %7 : (!fir.ref<!fir.array<2xi64>>) -> !fir.box<!fir.array<2xi64>>
+    %76 = fir.embox %6 : (!fir.ref<!fir.array<2xi64>>) -> !fir.box<!fir.array<2xi64>>
 // CHECK: fir.call @_QMprifPprif_allocate_coarray({{.*}}) : (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>, !fir.ref<i64>, !fir.ref<none>, !fir.box<none>, !fir.ptr<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
-    mif.alloc_coarray %26#0 errmsg %54 {lcobounds = array<i64: 1, 1>, ucobounds = array<i64: 2, -1>, uniq_name = "_QFEa2"} : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.box<none>) -> ()
-    %55 = fir.absent !fir.box<none>
-
+    mif.alloc_coarray %36#0 lcobounds %75 ucobounds %76 errmsg %69 {uniq_name = "_QFEa2"} : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.box<!fir.array<2xi64>>, !fir.box<!fir.array<2xi64>>, !fir.box<none>) -> ()
+    %77 = fir.absent !fir.box<none>
+    %c1_i64_29 = arith.constant 1 : i64
+    %c3_i32 = arith.constant 3 : i32
+    %78 = fir.convert %c3_i32 : (i32) -> i64
+    %c4_i32 = arith.constant 4 : i32
+    %79 = fir.convert %c4_i32 : (i32) -> i64
+    %c0_30 = arith.constant 0 : index
+    %80 = fir.coordinate_of %5, %c0_30 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+    fir.store %78 to %80 : !fir.ref<i64>
+    %81 = fir.coordinate_of %4, %c0_30 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+    fir.store %79 to %81 : !fir.ref<i64>
+    %c5_i32 = arith.constant 5 : i32
+    %82 = fir.convert %c5_i32 : (i32) -> i64
+    %c1_31 = arith.constant 1 : index
+    %83 = fir.coordinate_of %5, %c1_31 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+    fir.store %c1_i64_29 to %83 : !fir.ref<i64>
+    %84 = fir.coordinate_of %4, %c1_31 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+    fir.store %82 to %84 : !fir.ref<i64>
+    %c2_32 = arith.constant 2 : index
+    %85 = fir.coordinate_of %5, %c2_32 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+    %86 = fir.coordinate_of %4, %c2_32 : (!fir.ref<!fir.array<3xi64>>, index) -> !fir.ref<i64>
+    fir.store %c1_i64_29 to %85 : !fir.ref<i64>
+    fir.store %c1_i64_29 to %86 : !fir.ref<i64>
+    %87 = fir.embox %5 : (!fir.ref<!fir.array<3xi64>>) -> !fir.box<!fir.array<3xi64>>
+    %88 = fir.embox %4 : (!fir.ref<!fir.array<3xi64>>) -> !fir.box<!fir.array<3xi64>>
 // CHECK: fir.call @_QMprifPprif_allocate_coarray({{.*}}) : (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>, !fir.ref<i64>, !fir.ref<none>, !fir.box<none>, !fir.ptr<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
-    mif.alloc_coarray %30#0 errmsg %55 {lcobounds = array<i64: 3, 1, 1>, ucobounds = array<i64: 4, 5, -1>, uniq_name = "_QFEb2"} : (!fir.ref<!fir.box<!fir.heap<f32>>>, !fir.box<none>) -> ()
+    mif.alloc_coarray %48#0 lcobounds %87 ucobounds %88 errmsg %77 {uniq_name = "_QFEb2"} : (!fir.ref<!fir.box<!fir.heap<f32>>>, !fir.box<!fir.array<3xi64>>, !fir.box<!fir.array<3xi64>>, !fir.box<none>) -> ()
     %c100_i32 = arith.constant 100 : i32
-    %56 = fir.absent !fir.box<none>
+    %89 = fir.absent !fir.box<none>
     %c1_i32 = arith.constant 1 : i32
-    %c1_i32_8 = arith.constant 1 : i32
+    %c1_i32_33 = arith.constant 1 : i32
     %c0_i32 = arith.constant 0 : i32
-    %57 = fir.convert %34#0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>) -> !fir.ref<!fir.box<none>>
-    %58 = fir.convert %c100_i32 : (i32) -> i64
-    fir.call @_FortranAAllocatableInitCharacterForAllocate(%57, %58, %c1_i32, %c1_i32_8, %c0_i32) fastmath<contract> : (!fir.ref<!fir.box<none>>, i64, i32, i32, i32) -> ()
-    %c1_9 = arith.constant 1 : index
-    %c5_i32 = arith.constant 5 : i32
-    %c0_i32_10 = arith.constant 0 : i32
-    %59 = fir.convert %34#0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>) -> !fir.ref<!fir.box<none>>
-    %60 = fir.convert %c1_9 : (index) -> i64
-    %61 = fir.convert %c5_i32 : (i32) -> i64
-    fir.call @_FortranAAllocatableSetBounds(%59, %c0_i32_10, %60, %61) fastmath<contract> : (!fir.ref<!fir.box<none>>, i32, i64, i64) -> ()
-
+    %90 = fir.convert %56#0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>) -> !fir.ref<!fir.box<none>>
+    %91 = fir.convert %c100_i32 : (i32) -> i64
+    fir.call @_FortranAAllocatableInitCharacterForAllocate(%90, %91, %c1_i32, %c1_i32_33, %c0_i32) fastmath<contract> : (!fir.ref<!fir.box<none>>, i64, i32, i32, i32) -> ()
+    %c1_34 = arith.constant 1 : index
+    %c5_i32_35 = arith.constant 5 : i32
+    %c0_i32_36 = arith.constant 0 : i32
+    %92 = fir.convert %56#0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>) -> !fir.ref<!fir.box<none>>
+    %93 = fir.convert %c1_34 : (index) -> i64
+    %94 = fir.convert %c5_i32_35 : (i32) -> i64
+    fir.call @_FortranAAllocatableSetBounds(%92, %c0_i32_36, %93, %94) fastmath<contract> : (!fir.ref<!fir.box<none>>, i32, i64, i64) -> ()
+    %c1_i64_37 = arith.constant 1 : i64
+    %c0_38 = arith.constant 0 : index
+    %95 = fir.coordinate_of %3, %c0_38 : (!fir.ref<!fir.array<1xi64>>, index) -> !fir.ref<i64>
+    %96 = fir.coordinate_of %2, %c0_38 : (!fir.ref<!fir.array<1xi64>>, index) -> !fir.ref<i64>
+    fir.store %c1_i64_37 to %95 : !fir.ref<i64>
+    fir.store %c1_i64_37 to %96 : !fir.ref<i64>
+    %97 = fir.embox %3 : (!fir.ref<!fir.array<1xi64>>) -> !fir.box<!fir.array<1xi64>>
+    %98 = fir.embox %2 : (!fir.ref<!fir.array<1xi64>>) -> !fir.box<!fir.array<1xi64>>
 // CHECK: fir.call @_QMprifPprif_allocate_coarray({{.*}}) : (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>, !fir.ref<i64>, !fir.ref<none>, !fir.box<none>, !fir.ptr<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
-    mif.alloc_coarray %34#0 errmsg %56 {lcobounds = array<i64: 1>, ucobounds = array<i64: -1>, uniq_name = "_QFEc2"} : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>, !fir.box<none>) -> ()
-    %62 = fir.absent !fir.box<none>
-    %63 = hlfir.designate %36#0{"z"}   : (!fir.ref<!fir.type<_QFTmy_type{x:i32,y:!fir.box<!fir.heap<!fir.array<?xi32>>>,z:!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>}>>) -> !fir.ref<!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>>
-    %64 = hlfir.designate %63{"co"}   {fortran_attrs = #fir.var_attrs<allocatable>} : (!fir.ref<!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>>) -> !fir.ref<!fir.box<!fir.heap<i32>>>
-
+    mif.alloc_coarray %56#0 lcobounds %97 ucobounds %98 errmsg %89 {uniq_name = "_QFEc2"} : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<1xi64>>, !fir.box<none>) -> ()
+    %99 = fir.absent !fir.box<none>
+    %100 = hlfir.designate %58#0{"z"}   : (!fir.ref<!fir.type<_QFTmy_type{x:i32,y:!fir.box<!fir.heap<!fir.array<?xi32>>>,z:!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>}>>) -> !fir.ref<!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>>
+    %101 = hlfir.designate %100{"co"}   {fortran_attrs = #fir.var_attrs<allocatable>} : (!fir.ref<!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>>) -> !fir.ref<!fir.box<!fir.heap<i32>>>
+    %c1_i64_39 = arith.constant 1 : i64
+    %c0_40 = arith.constant 0 : index
+    %102 = fir.coordinate_of %1, %c0_40 : (!fir.ref<!fir.array<1xi64>>, index) -> !fir.ref<i64>
+    %103 = fir.coordinate_of %0, %c0_40 : (!fir.ref<!fir.array<1xi64>>, index) -> !fir.ref<i64>
+    fir.store %c1_i64_39 to %102 : !fir.ref<i64>
+    fir.store %c1_i64_39 to %103 : !fir.ref<i64>
+    %104 = fir.embox %1 : (!fir.ref<!fir.array<1xi64>>) -> !fir.box<!fir.array<1xi64>>
+    %105 = fir.embox %0 : (!fir.ref<!fir.array<1xi64>>) -> !fir.box<!fir.array<1xi64>>
 // CHECK: fir.call @_QMprifPprif_allocate_coarray({{.*}}) : (!fir.box<!fir.array<?xi64>>, !fir.box<!fir.array<?xi64>>, !fir.ref<i64>, !fir.ref<none>, !fir.box<none>, !fir.ptr<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
-    mif.alloc_coarray %64 errmsg %62 {lcobounds = array<i64: 1>, ucobounds = array<i64: -1>, uniq_name = "_QFEd.z.co"} : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.box<none>) -> ()
-    %65 = fir.absent !fir.box<none>
-    %66 = hlfir.designate %38#0{"w"}   {fortran_attrs = #fir.var_attrs<allocatable>} : (!fir.ref<!fir.type<_QFTmy_type3{w:!fir.box<!fir.heap<!fir.array<?xi32>>>}>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
-    %c1_11 = arith.constant 1 : index
-    %c100_i32_12 = arith.constant 100 : i32
-    %c0_i32_13 = arith.constant 0 : i32
-    %67 = fir.convert %66 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
-    %68 = fir.convert %c1_11 : (index) -> i64
-    %69 = fir.convert %c100_i32_12 : (i32) -> i64
-    fir.call @_FortranAAllocatableSetBounds(%67, %c0_i32_13, %68, %69) fastmath<contract> : (!fir.ref<!fir.box<none>>, i32, i64, i64) -> ()
-
-    %70 = fir.absent !fir.box<none>
+    mif.alloc_coarray %101 lcobounds %104 ucobounds %105 errmsg %99 {uniq_name = "_QFEd.z.co"} : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<1xi64>>, !fir.box<none>) -> ()
+    %106 = fir.absent !fir.box<none>
+    %107 = fir.absent !fir.ref<i32>
 // CHECK: fir.call @_QMprifPprif_deallocate_coarray({{.*}}) : (!fir.box<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
-    mif.dealloc_coarray %26#0 stat %4 errmsg %70 : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<i32>, !fir.box<none>) -> ()
-
+    mif.dealloc_coarray %36#0 stat %107 errmsg %106 : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<i32>, !fir.box<none>) -> ()
+    %108 = fir.absent !fir.ref<i32>
 // CHECK: fir.call @_QMprifPprif_deallocate_coarray({{.*}}) : (!fir.box<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
-    mif.dealloc_coarray %30#0 stat %3 errmsg %70 : (!fir.ref<!fir.box<!fir.heap<f32>>>, !fir.ref<i32>, !fir.box<none>) -> ()
-
+    mif.dealloc_coarray %48#0 stat %108 errmsg %106 : (!fir.ref<!fir.box<!fir.heap<f32>>>, !fir.ref<i32>, !fir.box<none>) -> ()
+    %109 = fir.absent !fir.ref<i32>
 // CHECK: fir.call @_QMprifPprif_deallocate_coarray({{.*}}) : (!fir.box<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
-    mif.dealloc_coarray %34#0 stat %2 errmsg %70 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>, !fir.ref<i32>, !fir.box<none>) -> ()
-    %71 = fir.absent !fir.box<none>
-    %72 = hlfir.designate %36#0{"z"}   : (!fir.ref<!fir.type<_QFTmy_type{x:i32,y:!fir.box<!fir.heap<!fir.array<?xi32>>>,z:!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>}>>) -> !fir.ref<!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>>
-    %73 = hlfir.designate %72{"co"}   {fortran_attrs = #fir.var_attrs<allocatable>} : (!fir.ref<!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>>) -> !fir.ref<!fir.box<!fir.heap<i32>>>
-
+    mif.dealloc_coarray %56#0 stat %109 errmsg %106 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>, !fir.ref<i32>, !fir.box<none>) -> ()
+    %110 = fir.absent !fir.box<none>
+    %111 = hlfir.designate %58#0{"z"}   : (!fir.ref<!fir.type<_QFTmy_type{x:i32,y:!fir.box<!fir.heap<!fir.array<?xi32>>>,z:!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>}>>) -> !fir.ref<!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>>
+    %112 = hlfir.designate %111{"co"}   {fortran_attrs = #fir.var_attrs<allocatable>} : (!fir.ref<!fir.type<_QFTmy_type2{co:!fir.box<!fir.heap<i32>>}>>) -> !fir.ref<!fir.box<!fir.heap<i32>>>
+    %113 = fir.absent !fir.ref<i32>
+// CHECK: fir.call @_QMprifPprif_deallocate_coarray({{.*}}) : (!fir.box<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
+    mif.dealloc_coarray %112 stat %113 errmsg %110 : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<i32>, !fir.box<none>) -> ()
+// CHECK: fir.call @_QMprifPprif_deallocate_coarray({{.*}}) : (!fir.box<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
+    mif.dealloc_coarray %54#0 : (!fir.ref<!fir.char<1,10>>) -> ()
 // CHECK: fir.call @_QMprifPprif_deallocate_coarray({{.*}}) : (!fir.box<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
-    mif.dealloc_coarray %73 stat %1 errmsg %71 : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<i32>, !fir.box<none>) -> ()
-    %74 = fir.absent !fir.box<none>
-    %75 = hlfir.designate %38#0{"w"}   {fortran_attrs = #fir.var_attrs<allocatable>} : (!fir.ref<!fir.type<_QFTmy_type3{w:!fir.box<!fir.heap<!fir.array<?xi32>>>}>>) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
+    mif.dealloc_coarray %46#0 : (!fir.ref<f32>) -> ()
+// CHECK: fir.call @_QMprifPprif_deallocate_coarray({{.*}}) : (!fir.box<none>, !fir.ref<i32>, !fir.box<!fir.char<1,?>>, !fir.box<!fir.char<1,?>>) -> ()
+    mif.dealloc_coarray %34#0 : (!fir.ref<i32>) -> ()
     return
   }
 }
 
-
 // CHECK: fir.global linkonce_odr @_QMprifE.dt.prif_coarray_handle : !fir.type<_QMprifTprif_coarray_handle{info:!fir.box<!fir.ptr<none>>}>
 // CHECK: fir.global linkonce @_QFEa_coarray_handle : !fir.box<!fir.type<_QMprifTprif_coarray_handle{info:!fir.box<!fir.ptr<none>>}>>
 // CHECK: fir.global linkonce @_QFEb_coarray_handle : !fir.box<!fir.type<_QMprifTprif_coarray_handle{info:!fir.box<!fir.ptr<none>>}>>
diff --git a/flang/test/Lower/MIF/coarray_allocation.f90 b/flang/test/Lower/MIF/coarray_allocation.f90
index 4a449c3bf1292..f0a3b2ea8591a 100644
--- a/flang/test/Lower/MIF/coarray_allocation.f90
+++ b/flang/test/Lower/MIF/coarray_allocation.f90
@@ -12,19 +12,19 @@ program alloc_test
   end type
   
   ! CHECK: %[[VAL_1:.*]] = fir.address_of(@_QFEa) : !fir.ref<i32>
-  ! CHECK: mif.alloc_coarray %[[VAL_1]] {lcobounds = array<i64: 1, 1>, ucobounds = array<i64: 2, -1>, uniq_name = "_QFEa"} : (!fir.ref<i32>) -> ()
+  ! CHECK: mif.alloc_coarray %[[VAL_1]] lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] {uniq_name = "_QFEa"} : (!fir.ref<i32>, !fir.box<!fir.array<2xi64>>, !fir.box<!fir.array<2xi64>>) -> ()
   
   ! CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[ADDR_1:.*]] {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFEa2"} : (!fir.ref<!fir.box<!fir.heap<i32>>>) -> (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<!fir.box<!fir.heap<i32>>>)
   
   integer :: a[2, *]
   ! CHECK: %[[VAL_2:.*]] = fir.address_of(@_QFEb) : !fir.ref<f32>
-  ! CHECK: mif.alloc_coarray %[[VAL_2]] {lcobounds = array<i64: 3, 1, 1>, ucobounds = array<i64: 4, 5, -1>, uniq_name = "_QFEb"} : (!fir.ref<f32>) -> ()
+  ! CHECK: mif.alloc_coarray %[[VAL_2]] lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] {uniq_name = "_QFEb"} : (!fir.ref<f32>, !fir.box<!fir.array<3xi64>>, !fir.box<!fir.array<3xi64>>) -> ()
   
   ! CHECK: %[[VAL_5:.*]]:2 = hlfir.declare %[[ADDR_2:.*]] {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFEb2"} : (!fir.ref<!fir.box<!fir.heap<f32>>>) -> (!fir.ref<!fir.box<!fir.heap<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>)
   
   real :: b[3:4, 5, *]
   ! CHECK: %[[VAL_3:.*]] = fir.address_of(@_QFEc) : !fir.ref<!fir.char<1,10>>
-  ! CHECK: mif.alloc_coarray %[[VAL_3]] {lcobounds = array<i64: 1>, ucobounds = array<i64: -1>, uniq_name = "_QFEc"} : (!fir.ref<!fir.char<1,10>>) -> ()
+  ! CHECK: mif.alloc_coarray %[[VAL_3]] lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] {uniq_name = "_QFEc"} : (!fir.ref<!fir.char<1,10>>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<1xi64>>) -> ()
   
   ! CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[ADDR_3:.*]] {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFEc2"} : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>) -> (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>)
   character(len=10) :: c[*]
@@ -35,20 +35,20 @@ program alloc_test
   integer, allocatable :: a2[:,:]
   
   ! CHECK: %[[VAL_7:.*]] = fir.absent !fir.box<none>
-  ! CHECK: mif.alloc_coarray %[[VAL_4]]#0 errmsg %[[VAL_7]] {lcobounds = array<i64: 1, 1>, ucobounds = array<i64: 2, -1>, uniq_name = "_QFEa2"} : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.box<none>) -> ()
+  ! CHECK: mif.alloc_coarray %[[VAL_4]]#0 lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] errmsg %[[VAL_7]] {uniq_name = "_QFEa2"} : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.box<!fir.array<2xi64>>, !fir.box<!fir.array<2xi64>>, !fir.box<none>) -> ()
   allocate(a2[2,*])
   
   ! CHECK: %[[VAL_8:.*]] = fir.absent !fir.box<none>
-  ! CHECK: mif.alloc_coarray %[[VAL_5]]#0 errmsg %[[VAL_8]] {lcobounds = array<i64: 3, 1, 1>, ucobounds = array<i64: 4, 5, -1>, uniq_name = "_QFEb2"} : (!fir.ref<!fir.box<!fir.heap<f32>>>, !fir.box<none>) -> ()
+  ! CHECK: mif.alloc_coarray %[[VAL_5]]#0 lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] errmsg %[[VAL_8]] {uniq_name = "_QFEb2"} : (!fir.ref<!fir.box<!fir.heap<f32>>>, !fir.box<!fir.array<3xi64>>, !fir.box<!fir.array<3xi64>>, !fir.box<none>) -> ()
   allocate(b2[3:4, 5, *])
   
   ! CHECK: %[[VAL_9:.*]] = fir.absent !fir.box<none>
-  ! CHECK: mif.alloc_coarray %[[VAL_6]]#0 errmsg %[[VAL_9]] {lcobounds = array<i64: 1>, ucobounds = array<i64: -1>, uniq_name = "_QFEc2"} : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>, !fir.box<none>) -> ()
+  ! CHECK: mif.alloc_coarray %[[VAL_6]]#0 lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] errmsg %[[VAL_9]] {uniq_name = "_QFEc2"} : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<1xi64>>, !fir.box<none>) -> ()
   allocate(character(100) :: c2(5)[*])
   
   ! CHECK: %[[VAL_10:.*]] = fir.absent !fir.box<none>
   ! CHECK: %[[VAL_12:.*]] = hlfir.designate %[[VAL_11:.*]]{"co"}
-  ! CHECK:  mif.alloc_coarray %[[VAL_12]] errmsg %[[VAL_10]] {lcobounds = array<i64: 1>, ucobounds = array<i64: -1>, uniq_name = "_QFEd.z.co"} : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.box<none>) -> ()
+  ! CHECK:  mif.alloc_coarray %[[VAL_12]] lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] errmsg %[[VAL_10]] {uniq_name = "_QFEd.z.co"} : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<1xi64>>, !fir.box<none>) -> ()
   allocate(d%z%co[*])
 
   ! CHECK: mif.dealloc_coarray %[[VAL_4]]#0 stat %[[STAT:.*]] errmsg %[[ERRMSG:.*]] : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<i32>, !fir.box<none>) -> ()

>From 404af78f66910bde4fe3589e0423d575600c12e9 Mon Sep 17 00:00:00 2001
From: Jean-Didier Pailleux <jean-didier.pailleux at sipearl.com>
Date: Tue, 10 Mar 2026 13:47:14 +0100
Subject: [PATCH 05/13] Add new test with coarray in a module and with SAVE
 attribute

---
 flang/test/Lower/MIF/coarray_allocation2.f90 | 74 ++++++++++++++++++++
 1 file changed, 74 insertions(+)
 create mode 100644 flang/test/Lower/MIF/coarray_allocation2.f90

diff --git a/flang/test/Lower/MIF/coarray_allocation2.f90 b/flang/test/Lower/MIF/coarray_allocation2.f90
new file mode 100644
index 0000000000000..5d692fc83b983
--- /dev/null
+++ b/flang/test/Lower/MIF/coarray_allocation2.f90
@@ -0,0 +1,74 @@
+! RUN: %flang_fc1 -emit-hlfir -fcoarray %s -o - | FileCheck %s
+
+! CHECK: fir.global @_QMtestEcount_i_test : i32
+module test
+  integer :: count_i_test[*]
+end module
+
+! CHECK-LABEL: func.func @_QPtest_save_coarray
+subroutine test_save_coarray()
+    use test
+    implicit none
+    integer, save :: count_i[*] = 0
+    
+    count_i = count_i + 1
+    count_i_test = count_i_test + 1
+
+    ! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.array<0xi64>
+    ! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.array<1xi64>
+    ! CHECK: %[[VAL_2:.*]] = fir.alloca !fir.array<0xi64>
+    ! CHECK: %[[VAL_3:.*]] = fir.alloca !fir.array<1xi64>
+    ! CHECK: %[[VAL_4:.*]] = fir.dummy_scope : !fir.dscope
+    ! CHECK: %[[VAL_5:.*]] = fir.address_of(@_QFtest_save_coarrayEcount_i) : !fir.ref<i32>
+    ! CHECK: %[[C1_I64:.*]] = arith.constant 1 : i64
+    ! CHECK: %[[C0:.*]] = arith.constant 0 : index
+    ! CHECK: %[[VAL_6:.*]] = fir.coordinate_of %[[VAL_3]], %[[C0]] : (!fir.ref<!fir.array<1xi64>>, index) -> !fir.ref<i64>
+    ! CHECK: fir.store %[[C1_I64]] to %[[VAL_6]] : !fir.ref<i64>
+    ! CHECK: %[[VAL_7:.*]] = fir.embox %[[VAL_3]] : (!fir.ref<!fir.array<1xi64>>) -> !fir.box<!fir.array<1xi64>>
+    ! CHECK: %[[VAL_8:.*]] = fir.embox %[[VAL_2]] : (!fir.ref<!fir.array<0xi64>>) -> !fir.box<!fir.array<0xi64>>
+    ! CHECK: mif.alloc_coarray %[[VAL_5]] lcobounds %[[VAL_7]] ucobounds %[[VAL_8]] {uniq_name = "_QFtest_save_coarrayEcount_i"} : (!fir.ref<i32>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<0xi64>>) -> ()
+    ! CHECK: %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_5]] {uniq_name = "_QFtest_save_coarrayEcount_i"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+    ! CHECK: %[[VAL_10:.*]] = fir.address_of(@_QMtestEcount_i_test) : !fir.ref<i32>
+    ! CHECK: %[[C1_I64_0:.*]] = arith.constant 1 : i64
+    ! CHECK: %[[C0_1:.*]] = arith.constant 0 : index
+    ! CHECK: %[[VAL_11:.*]] = fir.coordinate_of %[[VAL_1]], %[[C0_1]] : (!fir.ref<!fir.array<1xi64>>, index) -> !fir.ref<i64>
+    ! CHECK: fir.store %[[C1_I64_0]] to %[[VAL_11]] : !fir.ref<i64>
+    ! CHECK: %[[VAL_12:.*]] = fir.embox %[[VAL_1]] : (!fir.ref<!fir.array<1xi64>>) -> !fir.box<!fir.array<1xi64>>
+    ! CHECK: %[[VAL_13:.*]] = fir.embox %0 : (!fir.ref<!fir.array<0xi64>>) -> !fir.box<!fir.array<0xi64>>
+    ! CHECK: mif.alloc_coarray %[[VAL_10]] lcobounds %[[VAL_12]] ucobounds %[[VAL_13]] {uniq_name = "_QMtestEcount_i_test"} : (!fir.ref<i32>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<0xi64>>) -> ()
+    ! CHECK: %[[VAL_14:.*]]:2 = hlfir.declare %[[VAL_10]] {uniq_name = "_QMtestEcount_i_test"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+    ! CHECK: %[[VAL_15:.*]] = fir.load %[[VAL_9]]#0 : !fir.ref<i32>
+    ! CHECK: %[[C1_I32:.*]] = arith.constant 1 : i32
+    ! CHECK: %[[VAL_16:.*]] = arith.addi %[[VAL_15]], %[[C1_I32]] : i32
+    ! CHECK: hlfir.assign %[[VAL_16]] to %[[VAL_9]]#0 : i32, !fir.ref<i32>
+    ! CHECK: %[[VAL_17:.*]] = fir.load %[[VAL_14]]#0 : !fir.ref<i32>
+    ! CHECK: %[[C1_I32_2:.*]] = arith.constant 1 : i32
+    ! CHECK: %[[VAL_18:.*]] = arith.addi %[[VAL_17]], %[[C1_I32_2]] : i32
+    ! CHECK: hlfir.assign %[[VAL_18]] to %[[VAL_14]]#0 : i32, !fir.ref<i32>
+    ! CHECK: mif.dealloc_coarray %[[VAL_14]]#0 : (!fir.ref<i32>) -> ()
+    ! CHECK: mif.dealloc_coarray %[[VAL_9]]#0 : (!fir.ref<i32>) -> ()
+end subroutine test_save_coarray
+
+! CHECK-LABEL: func.func @_QQmain
+program main
+  use test
+  
+  call test_save_coarray()
+  ! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.array<0xi64>
+  ! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.array<1xi64>
+  ! CHECK: %[[VAL_2:.*]] = fir.dummy_scope : !fir.dscope
+  ! CHECK: %[[VAL_3:.*]] = fir.address_of(@_QMtestEcount_i_test) : !fir.ref<i32>
+  ! CHECK: %[[C1_I64:.*]] = arith.constant 1 : i64
+  ! CHECK: %[[C0:.*]] = arith.constant 0 : index
+  ! CHECK: %[[VAL_4:.*]] = fir.coordinate_of %[[VAL_1]], %[[C0]] : (!fir.ref<!fir.array<1xi64>>, index) -> !fir.ref<i64>
+  ! CHECK: fir.store %[[C1_I64]] to %[[VAL_4]] : !fir.ref<i64>
+  ! CHECK: %[[VAL_5:.*]] = fir.embox %[[VAL_1]] : (!fir.ref<!fir.array<1xi64>>) -> !fir.box<!fir.array<1xi64>>
+  ! CHECK: %[[VAL_6:.*]] = fir.embox %[[VAL_0]] : (!fir.ref<!fir.array<0xi64>>) -> !fir.box<!fir.array<0xi64>>
+  ! CHECK: mif.alloc_coarray %[[VAL_3]] lcobounds %[[VAL_5]] ucobounds %[[VAL_6]] {uniq_name = "_QMtestEcount_i_test"} : (!fir.ref<i32>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<0xi64>>) -> ()
+  ! CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_3]] {uniq_name = "_QMtestEcount_i_test"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+  ! CHECK: fir.call @_QPtest_save_coarray() fastmath<contract> : () -> ()
+  ! CHECK: mif.dealloc_coarray %[[VAL_7]]#0 : (!fir.ref<i32>) -> ()
+  ! CHECK: return
+
+end program main
+

>From 972d3a5b42ea76b5916b74640559d9fc093cbba5 Mon Sep 17 00:00:00 2001
From: Jean-Didier Pailleux <jean-didier.pailleux at sipearl.com>
Date: Tue, 10 Mar 2026 13:49:23 +0100
Subject: [PATCH 06/13] Remove useless ComputeLastUcobound + ucobound is now an
 array of size = SIZE(LCOBOUND)-1

---
 flang-rt/lib/runtime/CMakeLists.txt           |  1 -
 flang-rt/lib/runtime/coarray.cpp              | 46 -------------------
 .../flang/Optimizer/Builder/MIFCommon.h       |  1 -
 flang/include/flang/Runtime/coarray.h         | 24 ----------
 flang/lib/Lower/MultiImageFortran.cpp         | 18 ++++----
 .../Optimizer/Transforms/MIFOpConversion.cpp  |  1 -
 flang/test/Lower/MIF/coarray_allocation.f90   | 14 +++---
 7 files changed, 15 insertions(+), 90 deletions(-)
 delete mode 100644 flang-rt/lib/runtime/coarray.cpp
 delete mode 100644 flang/include/flang/Runtime/coarray.h

diff --git a/flang-rt/lib/runtime/CMakeLists.txt b/flang-rt/lib/runtime/CMakeLists.txt
index ea1e671aaf5b7..787d0dbbfb5ca 100644
--- a/flang-rt/lib/runtime/CMakeLists.txt
+++ b/flang-rt/lib/runtime/CMakeLists.txt
@@ -23,7 +23,6 @@ set(supported_sources
   assign.cpp
   buffer.cpp
   character.cpp
-  coarray.cpp
   connection.cpp
   copy.cpp
   derived-api.cpp
diff --git a/flang-rt/lib/runtime/coarray.cpp b/flang-rt/lib/runtime/coarray.cpp
deleted file mode 100644
index e5498f5e92153..0000000000000
--- a/flang-rt/lib/runtime/coarray.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//===-- runtime/coarray.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
-//
-//===----------------------------------------------------------------------===//
-
-#include "flang/Runtime/coarray.h"
-#include "flang-rt/runtime/descriptor.h"
-#include "flang-rt/runtime/terminator.h"
-#include "flang-rt/runtime/type-info.h"
-
-namespace Fortran::runtime {
-
-extern "C" {
-RT_EXT_API_GROUP_BEGIN
-
-void RTDEF(ComputeLastUcobound)(int num_images, const Descriptor &lcobounds,
-    const Descriptor &ucobounds, int rank) {
-  int corank = ucobounds.GetDimension(0).Extent();
-  if (corank + rank > 15)
-    Fortran::runtime::Terminator{}.Crash(
-        "Fortran runtime error: maximum corank + rank for a coarray is 15, "
-        "current "
-        "corank is %d and rank is %d.",
-        corank);
-
-  int64_t *lcobounds_ptr = (int64_t *)lcobounds.raw().base_addr;
-  int64_t *ucobounds_ptr = (int64_t *)ucobounds.raw().base_addr;
-  int64_t index = 1;
-  for (int i = 0; i < corank - 1; i++) {
-    index *= ucobounds_ptr[i] - lcobounds_ptr[i] + 1;
-  }
-  if (corank == 1)
-    ucobounds_ptr[0] = lcobounds_ptr[0] + num_images - 1;
-  else if (index < num_images)
-    ucobounds_ptr[corank - 1] = lcobounds_ptr[corank - 1] +
-        (num_images / index) + (num_images % index != 0) - 1;
-  else
-    ucobounds_ptr[corank - 1] = lcobounds_ptr[corank - 1];
-}
-
-RT_EXT_API_GROUP_END
-}
-} // namespace Fortran::runtime
diff --git a/flang/include/flang/Optimizer/Builder/MIFCommon.h b/flang/include/flang/Optimizer/Builder/MIFCommon.h
index 6339c3255d5d8..b8aa3e27bf629 100644
--- a/flang/include/flang/Optimizer/Builder/MIFCommon.h
+++ b/flang/include/flang/Optimizer/Builder/MIFCommon.h
@@ -12,7 +12,6 @@
 #include "flang/Lower/AbstractConverter.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/MIF/MIFOps.h"
-#include "flang/Runtime/coarray.h"
 #include "mlir/IR/BuiltinOps.h"
 
 static constexpr llvm::StringRef coarrayHandleSuffix = "_coarray_handle";
diff --git a/flang/include/flang/Runtime/coarray.h b/flang/include/flang/Runtime/coarray.h
deleted file mode 100644
index 0028a3d9827ef..0000000000000
--- a/flang/include/flang/Runtime/coarray.h
+++ /dev/null
@@ -1,24 +0,0 @@
-//===-- include/flang/Runtime/coarray.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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef FORTRAN_RUNTIME_COARRAY_H
-#define FORTRAN_RUNTIME_COARRAY_H
-
-#include "flang/Runtime/descriptor-consts.h"
-#include "flang/Runtime/entry-names.h"
-
-namespace Fortran::runtime {
-// class Descriptor;
-extern "C" {
-
-void RTDECL(ComputeLastUcobound)(int num_images, const Descriptor &lcobounds,
-    const Descriptor &ucobounds, int rank);
-}
-} // namespace Fortran::runtime
-
-#endif // FORTRAN_RUNTIME_COARRAY_H
diff --git a/flang/lib/Lower/MultiImageFortran.cpp b/flang/lib/Lower/MultiImageFortran.cpp
index cd028e5d67e20..b06cb785e872d 100644
--- a/flang/lib/Lower/MultiImageFortran.cpp
+++ b/flang/lib/Lower/MultiImageFortran.cpp
@@ -324,17 +324,16 @@ Fortran::lower::genUpperCoBounds(Fortran::lower::AbstractConverter &converter,
           sym.GetUltimate()
               .detailsIf<Fortran::semantics::ObjectEntityDetails>()) {
     size_t corank = object->coshape().size();
+    // PRIF take an array of size corank-1 for ucobound.
     mlir::Type arrayType = fir::SequenceType::get(
-        {static_cast<fir::SequenceType::Extent>(corank)}, i64Ty);
+        {static_cast<fir::SequenceType::Extent>(corank - 1)}, i64Ty);
     ucobounds = builder.createTemporary(loc, arrayType);
     mlir::Value ucovalue;
-    for (size_t i = 0; i < corank; i++) {
+    for (size_t i = 0; i < corank - 1; i++) {
       if (auto ub = object->coshape()[i].lbound().GetExplicit()) {
         auto ubExpr = ignoreEvConvert(*ub);
         ucovalue = fir::getBase(converter.genExprValue(loc, ubExpr, stmtCtx));
-      } else if (object->coshape()[i].ubound().isStar())
-        ucovalue = builder.createIntegerConstant(loc, i64Ty, -1);
-      else {
+      } else {
         if (auto lb = object->coshape()[i].lbound().GetExplicit()) {
           auto lbExpr = ignoreEvConvert(*lb);
           ucovalue = fir::getBase(converter.genExprValue(
@@ -371,7 +370,9 @@ genCoBounds(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
   mlir::Type arrayType = fir::SequenceType::get(
       {static_cast<fir::SequenceType::Extent>(corank)}, i64Ty);
   mlir::Value lcobounds = builder.createTemporary(loc, arrayType);
-  mlir::Value ucobounds = builder.createTemporary(loc, arrayType);
+  mlir::Type arrayType2 = fir::SequenceType::get(
+      {static_cast<fir::SequenceType::Extent>(corank - 1)}, i64Ty);
+  mlir::Value ucobounds = builder.createTemporary(loc, arrayType2);
   size_t i = 0;
   for (const Fortran::parser::AllocateCoshapeSpec &coshapeSpec : coshapeSpecs) {
     const std::optional<Fortran::parser::BoundExpr> &lbExpr =
@@ -402,7 +403,7 @@ genCoBounds(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
     fir::StoreOp::create(builder, loc, ub, ucoaddr);
     i++;
   }
-  // Last cobound;
+  // Last lcobound;
   {
     mlir::Value lb = one;
     if (const std::optional<Fortran::parser::BoundExpr> &lastCobound =
@@ -414,10 +415,7 @@ genCoBounds(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
         builder.createIntegerConstant(loc, builder.getIndexType(), i);
     mlir::Value lcoaddr =
         fir::CoordinateOp::create(builder, loc, addrType, lcobounds, index);
-    mlir::Value ucoaddr =
-        fir::CoordinateOp::create(builder, loc, addrType, ucobounds, index);
     fir::StoreOp::create(builder, loc, lb, lcoaddr);
-    fir::StoreOp::create(builder, loc, lb, ucoaddr);
   }
 
   lcobounds = builder.createBox(loc, lcobounds);
diff --git a/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp b/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
index 2355e87d73b0d..9e1100a563233 100644
--- a/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
+++ b/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
@@ -22,7 +22,6 @@
 #include "flang/Optimizer/HLFIR/HLFIROps.h"
 #include "flang/Optimizer/Support/DataLayout.h"
 #include "flang/Optimizer/Support/InternalNames.h"
-#include "flang/Runtime/coarray.h"
 #include "flang/Runtime/stop.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/Transforms/DialectConversion.h"
diff --git a/flang/test/Lower/MIF/coarray_allocation.f90 b/flang/test/Lower/MIF/coarray_allocation.f90
index f0a3b2ea8591a..64122aa21d582 100644
--- a/flang/test/Lower/MIF/coarray_allocation.f90
+++ b/flang/test/Lower/MIF/coarray_allocation.f90
@@ -12,19 +12,19 @@ program alloc_test
   end type
   
   ! CHECK: %[[VAL_1:.*]] = fir.address_of(@_QFEa) : !fir.ref<i32>
-  ! CHECK: mif.alloc_coarray %[[VAL_1]] lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] {uniq_name = "_QFEa"} : (!fir.ref<i32>, !fir.box<!fir.array<2xi64>>, !fir.box<!fir.array<2xi64>>) -> ()
+  ! CHECK: mif.alloc_coarray %[[VAL_1]] lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] {uniq_name = "_QFEa"} : (!fir.ref<i32>, !fir.box<!fir.array<2xi64>>, !fir.box<!fir.array<1xi64>>) -> ()
   
   ! CHECK: %[[VAL_4:.*]]:2 = hlfir.declare %[[ADDR_1:.*]] {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFEa2"} : (!fir.ref<!fir.box<!fir.heap<i32>>>) -> (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<!fir.box<!fir.heap<i32>>>)
   
   integer :: a[2, *]
   ! CHECK: %[[VAL_2:.*]] = fir.address_of(@_QFEb) : !fir.ref<f32>
-  ! CHECK: mif.alloc_coarray %[[VAL_2]] lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] {uniq_name = "_QFEb"} : (!fir.ref<f32>, !fir.box<!fir.array<3xi64>>, !fir.box<!fir.array<3xi64>>) -> ()
+  ! CHECK: mif.alloc_coarray %[[VAL_2]] lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] {uniq_name = "_QFEb"} : (!fir.ref<f32>, !fir.box<!fir.array<3xi64>>, !fir.box<!fir.array<2xi64>>) -> ()
   
   ! CHECK: %[[VAL_5:.*]]:2 = hlfir.declare %[[ADDR_2:.*]] {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFEb2"} : (!fir.ref<!fir.box<!fir.heap<f32>>>) -> (!fir.ref<!fir.box<!fir.heap<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>)
   
   real :: b[3:4, 5, *]
   ! CHECK: %[[VAL_3:.*]] = fir.address_of(@_QFEc) : !fir.ref<!fir.char<1,10>>
-  ! CHECK: mif.alloc_coarray %[[VAL_3]] lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] {uniq_name = "_QFEc"} : (!fir.ref<!fir.char<1,10>>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<1xi64>>) -> ()
+  ! CHECK: mif.alloc_coarray %[[VAL_3]] lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] {uniq_name = "_QFEc"} : (!fir.ref<!fir.char<1,10>>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<0xi64>>) -> ()
   
   ! CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[ADDR_3:.*]] {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFEc2"} : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>) -> (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>)
   character(len=10) :: c[*]
@@ -35,20 +35,20 @@ program alloc_test
   integer, allocatable :: a2[:,:]
   
   ! CHECK: %[[VAL_7:.*]] = fir.absent !fir.box<none>
-  ! CHECK: mif.alloc_coarray %[[VAL_4]]#0 lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] errmsg %[[VAL_7]] {uniq_name = "_QFEa2"} : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.box<!fir.array<2xi64>>, !fir.box<!fir.array<2xi64>>, !fir.box<none>) -> ()
+  ! CHECK: mif.alloc_coarray %[[VAL_4]]#0 lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] errmsg %[[VAL_7]] {uniq_name = "_QFEa2"} : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.box<!fir.array<2xi64>>, !fir.box<!fir.array<1xi64>>, !fir.box<none>) -> ()
   allocate(a2[2,*])
   
   ! CHECK: %[[VAL_8:.*]] = fir.absent !fir.box<none>
-  ! CHECK: mif.alloc_coarray %[[VAL_5]]#0 lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] errmsg %[[VAL_8]] {uniq_name = "_QFEb2"} : (!fir.ref<!fir.box<!fir.heap<f32>>>, !fir.box<!fir.array<3xi64>>, !fir.box<!fir.array<3xi64>>, !fir.box<none>) -> ()
+  ! CHECK: mif.alloc_coarray %[[VAL_5]]#0 lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] errmsg %[[VAL_8]] {uniq_name = "_QFEb2"} : (!fir.ref<!fir.box<!fir.heap<f32>>>, !fir.box<!fir.array<3xi64>>, !fir.box<!fir.array<2xi64>>, !fir.box<none>) -> ()
   allocate(b2[3:4, 5, *])
   
   ! CHECK: %[[VAL_9:.*]] = fir.absent !fir.box<none>
-  ! CHECK: mif.alloc_coarray %[[VAL_6]]#0 lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] errmsg %[[VAL_9]] {uniq_name = "_QFEc2"} : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<1xi64>>, !fir.box<none>) -> ()
+  ! CHECK: mif.alloc_coarray %[[VAL_6]]#0 lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] errmsg %[[VAL_9]] {uniq_name = "_QFEc2"} : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<0xi64>>, !fir.box<none>) -> ()
   allocate(character(100) :: c2(5)[*])
   
   ! CHECK: %[[VAL_10:.*]] = fir.absent !fir.box<none>
   ! CHECK: %[[VAL_12:.*]] = hlfir.designate %[[VAL_11:.*]]{"co"}
-  ! CHECK:  mif.alloc_coarray %[[VAL_12]] lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] errmsg %[[VAL_10]] {uniq_name = "_QFEd.z.co"} : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<1xi64>>, !fir.box<none>) -> ()
+  ! CHECK:  mif.alloc_coarray %[[VAL_12]] lcobounds %[[LCOBOUNDS:.*]] ucobounds %[[UCOBOUNDS:.*]] errmsg %[[VAL_10]] {uniq_name = "_QFEd.z.co"} : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<0xi64>>, !fir.box<none>) -> ()
   allocate(d%z%co[*])
 
   ! CHECK: mif.dealloc_coarray %[[VAL_4]]#0 stat %[[STAT:.*]] errmsg %[[ERRMSG:.*]] : (!fir.ref<!fir.box<!fir.heap<i32>>>, !fir.ref<i32>, !fir.box<none>) -> ()

>From b972698225a1f28f197adb29d02944a1f7d8d3a0 Mon Sep 17 00:00:00 2001
From: Jean-Didier Pailleux <jean-didier.pailleux at sipearl.com>
Date: Tue, 10 Mar 2026 14:16:02 +0100
Subject: [PATCH 07/13] Remove useless function in MIFOpConversion

---
 .../Optimizer/Transforms/MIFOpConversion.cpp  | 26 -------------------
 1 file changed, 26 deletions(-)

diff --git a/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp b/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
index 9e1100a563233..d711e653509b8 100644
--- a/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
+++ b/flang/lib/Optimizer/Transforms/MIFOpConversion.cpp
@@ -112,32 +112,6 @@ mlir::Value getCoarrayHandle(fir::FirOpBuilder &builder, mlir::Location loc,
   return mlir::Value{};
 }
 
-// Function to generate the PRIF runtime function call to retrieve
-// the number of images in the current team
-static mlir::Value getNumImages(fir::FirOpBuilder &builder,
-                                mlir::Location loc) {
-  mlir::Type i32Ty = builder.getI32Type();
-  mlir::Value result = builder.createTemporary(loc, i32Ty);
-  mlir::FunctionType ftype = mlir::FunctionType::get(
-      builder.getContext(),
-      /*inputs*/ {builder.getRefType(i32Ty)}, /*results*/ {});
-  mlir::func::FuncOp funcOp =
-      builder.createFunction(loc, getPRIFProcName("num_images"), ftype);
-  llvm::SmallVector<mlir::Value> args =
-      fir::runtime::createArguments(builder, loc, ftype, result);
-  fir::CallOp::create(builder, loc, funcOp, args);
-  return fir::LoadOp::create(builder, loc, result);
-}
-
-static mlir::Value getRank(fir::FirOpBuilder &builder, mlir::Location loc,
-                           mlir::Value v) {
-  mlir::Type argTy = fir::unwrapPassByRefType(fir::unwrapRefType(v.getType()));
-  unsigned rank = 0;
-  if (auto seqTy = mlir::dyn_cast<fir::SequenceType>(argTy))
-    rank = seqTy.getDimension();
-  return builder.createIntegerConstant(loc, builder.getI32Type(), rank);
-}
-
 // Storing the coarray descriptor as a global variable
 void storeCoarrayHandle(fir::FirOpBuilder &builder, mlir::Location loc,
                         mlir::Value coarrayHandle, std::string uniqName) {

>From 70f62391f5a3e2e75b17b2e22a2f3d67ddc33198 Mon Sep 17 00:00:00 2001
From: Jean-Didier Pailleux <jean-didier.pailleux at sipearl.com>
Date: Tue, 17 Mar 2026 13:04:58 +0100
Subject: [PATCH 08/13] Update and add more tests on the allocation + Update
 cleanupDeallocation

---
 flang/lib/Lower/ConvertVariable.cpp           |  47 +++++---
 flang/lib/Optimizer/Builder/IntrinsicCall.cpp |   1 +
 flang/test/Lower/MIF/coarray_allocation2.f90  | 111 +++++++-----------
 flang/test/Lower/MIF/coarray_allocation3.f90  |  29 +++++
 flang/test/Lower/MIF/coarray_allocation4.f90  |   8 ++
 5 files changed, 110 insertions(+), 86 deletions(-)
 create mode 100644 flang/test/Lower/MIF/coarray_allocation3.f90
 create mode 100644 flang/test/Lower/MIF/coarray_allocation4.f90

diff --git a/flang/lib/Lower/ConvertVariable.cpp b/flang/lib/Lower/ConvertVariable.cpp
index 9d7efdfe3bf83..b726022650169 100644
--- a/flang/lib/Lower/ConvertVariable.cpp
+++ b/flang/lib/Lower/ConvertVariable.cpp
@@ -677,25 +677,39 @@ genCleanupDeallocateCoarray(Fortran::lower::AbstractConverter &converter,
                             Fortran::lower::SymMap &symMap) {
   mlir::Location loc = converter.getCurrentLocation();
   const Fortran::semantics::Symbol &sym = var.getSymbol();
-  if (hasFinalization(sym) || hasAllocatableDirectComponent(sym))
-    TODO(loc, "Coarray with finalization.");
-
   auto *builder = &converter.getFirOpBuilder();
   fir::ExtendedValue exv = converter.getSymbolExtendedValue(sym, &symMap);
-  if (!Fortran::semantics::IsDummy(var.getSymbol())) {
-    converter.getFctCtx().attachCleanup([builder, loc, exv]() {
-      mif::DeallocCoarrayOp::create(*builder, loc, fir::getBase(exv),
-                                    /*stat*/ mlir::Value{},
-                                    /*errmsg*/ mlir::Value{});
-    });
-  } else {
+
+  // Local coarray must have the SAVE and/or ALLOCATABLE attributes.
+  // SAVE (no ALLOCATABLE): never automatically deallocated or finalized
+  // (see 7.5.6.4) ALLOCATABLE (no SAVE): automatically deallocated and
+  // finalized at scope exit ALLOCATABLE and SAVE: Not deallocated at scope exit
+  // (only via explicit DEALLOCATE or END TEAM)
+  if (Fortran::semantics::IsSaved(sym) &&
+      Fortran::semantics::IsFunctionResult(sym))
+    return;
+
+  if (hasFinalization(sym) || hasAllocatableDirectComponent(sym))
+    TODO(loc, "Coarray with an allocatable direct component and/or requiring "
+              "finalization.");
+
+  if (Fortran::semantics::IsDummy(sym)) {
     // PRIF provide prif_alias_destroy to delete an aliased descriptor
     // for a coarray. This procedure does not deallocate or alter the
     // orginal coarray but need to be called when we leave the scope
     // for a dummy coarray argument.The MIF dialect will provide an
     // operation to handle this case.
-    TODO(loc, "Cleanup of dummy coarray.");
+    TODO(loc, "Cleanup aliased coarray created for a dummy argument.");
   }
+
+  converter.getFctCtx().attachCleanup([&converter, builder, loc, exv, sym]() {
+    if (auto mutBox = exv.getBoxOf<fir::MutableBoxValue>())
+      Fortran::lower::genDeallocateIfAllocated(converter, *mutBox, loc);
+    else
+      mif::DeallocCoarrayOp::create(*builder, loc, fir::getBase(exv),
+                                    /*stat*/ mlir::Value{},
+                                    /*errmsg*/ mlir::Value{});
+  });
 }
 
 /// Instantiate a global variable. If it hasn't already been processed, add
@@ -730,13 +744,8 @@ static void instantiateGlobal(Fortran::lower::AbstractConverter &converter,
   mlir::Value cast = builder.createConvert(loc, varAddrType, addrOf);
   Fortran::lower::StatementContext stmtCtx;
   mapSymbolAttributes(converter, var, symMap, stmtCtx, cast);
-  // Local coarray must have the SAVE or ALLOCATABLE attribute and are
-  // never explicitly deallaocated or finalized (see 7.5.6.4).
-  // Otherwize, a coarray is global we will add an implicit deallocation
-  // for nonallocatable and nonpointer at the end of the scope.
-  if (Fortran::evaluate::IsCoarray(sym) &&
-      !Fortran::semantics::IsAllocatable(sym) &&
-      !Fortran::semantics::IsPointer(sym))
+
+  if (Fortran::evaluate::IsCoarray(sym))
     genCleanupDeallocateCoarray(converter, var, symMap);
 }
 
@@ -2524,6 +2533,8 @@ void Fortran::lower::mapSymbolAttributes(
   }
 
   if (Fortran::evaluate::IsCoarray(sym)) {
+    if (sym.attrs().test(Fortran::semantics::Attr::SAVE))
+      TODO(loc, "Coarray with explicit SAVE attribute.");
     Fortran::lower::genAllocateCoarray(converter, loc, sym, addr);
     ::genDeclareSymbol(converter, symMap, sym, addr, len, extents, lbounds,
                        replace);
diff --git a/flang/lib/Optimizer/Builder/IntrinsicCall.cpp b/flang/lib/Optimizer/Builder/IntrinsicCall.cpp
index d3c67395a08bd..10fc47a23417f 100644
--- a/flang/lib/Optimizer/Builder/IntrinsicCall.cpp
+++ b/flang/lib/Optimizer/Builder/IntrinsicCall.cpp
@@ -6811,6 +6811,7 @@ mlir::Value IntrinsicLibrary::genModulo(mlir::Type resultType,
 void IntrinsicLibrary::genMoveAlloc(llvm::ArrayRef<fir::ExtendedValue> args) {
   assert(args.size() == 4);
 
+  // TODO: Handling coarray deallocation.
   const fir::ExtendedValue &from = args[0];
   const fir::ExtendedValue &to = args[1];
   const fir::ExtendedValue &status = args[2];
diff --git a/flang/test/Lower/MIF/coarray_allocation2.f90 b/flang/test/Lower/MIF/coarray_allocation2.f90
index 5d692fc83b983..89000203925d8 100644
--- a/flang/test/Lower/MIF/coarray_allocation2.f90
+++ b/flang/test/Lower/MIF/coarray_allocation2.f90
@@ -1,74 +1,49 @@
 ! RUN: %flang_fc1 -emit-hlfir -fcoarray %s -o - | FileCheck %s
 
-! CHECK: fir.global @_QMtestEcount_i_test : i32
-module test
-  integer :: count_i_test[*]
-end module
-
-! CHECK-LABEL: func.func @_QPtest_save_coarray
-subroutine test_save_coarray()
-    use test
+subroutine test_coarray_cleanup()
     implicit none
-    integer, save :: count_i[*] = 0
+    real, allocatable :: n(:)[:]
     
-    count_i = count_i + 1
-    count_i_test = count_i_test + 1
-
-    ! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.array<0xi64>
-    ! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.array<1xi64>
-    ! CHECK: %[[VAL_2:.*]] = fir.alloca !fir.array<0xi64>
-    ! CHECK: %[[VAL_3:.*]] = fir.alloca !fir.array<1xi64>
-    ! CHECK: %[[VAL_4:.*]] = fir.dummy_scope : !fir.dscope
-    ! CHECK: %[[VAL_5:.*]] = fir.address_of(@_QFtest_save_coarrayEcount_i) : !fir.ref<i32>
-    ! CHECK: %[[C1_I64:.*]] = arith.constant 1 : i64
-    ! CHECK: %[[C0:.*]] = arith.constant 0 : index
-    ! CHECK: %[[VAL_6:.*]] = fir.coordinate_of %[[VAL_3]], %[[C0]] : (!fir.ref<!fir.array<1xi64>>, index) -> !fir.ref<i64>
-    ! CHECK: fir.store %[[C1_I64]] to %[[VAL_6]] : !fir.ref<i64>
-    ! CHECK: %[[VAL_7:.*]] = fir.embox %[[VAL_3]] : (!fir.ref<!fir.array<1xi64>>) -> !fir.box<!fir.array<1xi64>>
-    ! CHECK: %[[VAL_8:.*]] = fir.embox %[[VAL_2]] : (!fir.ref<!fir.array<0xi64>>) -> !fir.box<!fir.array<0xi64>>
-    ! CHECK: mif.alloc_coarray %[[VAL_5]] lcobounds %[[VAL_7]] ucobounds %[[VAL_8]] {uniq_name = "_QFtest_save_coarrayEcount_i"} : (!fir.ref<i32>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<0xi64>>) -> ()
-    ! CHECK: %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_5]] {uniq_name = "_QFtest_save_coarrayEcount_i"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
-    ! CHECK: %[[VAL_10:.*]] = fir.address_of(@_QMtestEcount_i_test) : !fir.ref<i32>
-    ! CHECK: %[[C1_I64_0:.*]] = arith.constant 1 : i64
-    ! CHECK: %[[C0_1:.*]] = arith.constant 0 : index
-    ! CHECK: %[[VAL_11:.*]] = fir.coordinate_of %[[VAL_1]], %[[C0_1]] : (!fir.ref<!fir.array<1xi64>>, index) -> !fir.ref<i64>
-    ! CHECK: fir.store %[[C1_I64_0]] to %[[VAL_11]] : !fir.ref<i64>
-    ! CHECK: %[[VAL_12:.*]] = fir.embox %[[VAL_1]] : (!fir.ref<!fir.array<1xi64>>) -> !fir.box<!fir.array<1xi64>>
-    ! CHECK: %[[VAL_13:.*]] = fir.embox %0 : (!fir.ref<!fir.array<0xi64>>) -> !fir.box<!fir.array<0xi64>>
-    ! CHECK: mif.alloc_coarray %[[VAL_10]] lcobounds %[[VAL_12]] ucobounds %[[VAL_13]] {uniq_name = "_QMtestEcount_i_test"} : (!fir.ref<i32>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<0xi64>>) -> ()
-    ! CHECK: %[[VAL_14:.*]]:2 = hlfir.declare %[[VAL_10]] {uniq_name = "_QMtestEcount_i_test"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
-    ! CHECK: %[[VAL_15:.*]] = fir.load %[[VAL_9]]#0 : !fir.ref<i32>
-    ! CHECK: %[[C1_I32:.*]] = arith.constant 1 : i32
-    ! CHECK: %[[VAL_16:.*]] = arith.addi %[[VAL_15]], %[[C1_I32]] : i32
-    ! CHECK: hlfir.assign %[[VAL_16]] to %[[VAL_9]]#0 : i32, !fir.ref<i32>
-    ! CHECK: %[[VAL_17:.*]] = fir.load %[[VAL_14]]#0 : !fir.ref<i32>
-    ! CHECK: %[[C1_I32_2:.*]] = arith.constant 1 : i32
-    ! CHECK: %[[VAL_18:.*]] = arith.addi %[[VAL_17]], %[[C1_I32_2]] : i32
-    ! CHECK: hlfir.assign %[[VAL_18]] to %[[VAL_14]]#0 : i32, !fir.ref<i32>
-    ! CHECK: mif.dealloc_coarray %[[VAL_14]]#0 : (!fir.ref<i32>) -> ()
-    ! CHECK: mif.dealloc_coarray %[[VAL_9]]#0 : (!fir.ref<i32>) -> ()
-end subroutine test_save_coarray
-
-! CHECK-LABEL: func.func @_QQmain
-program main
-  use test
-  
-  call test_save_coarray()
-  ! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.array<0xi64>
-  ! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.array<1xi64>
-  ! CHECK: %[[VAL_2:.*]] = fir.dummy_scope : !fir.dscope
-  ! CHECK: %[[VAL_3:.*]] = fir.address_of(@_QMtestEcount_i_test) : !fir.ref<i32>
-  ! CHECK: %[[C1_I64:.*]] = arith.constant 1 : i64
-  ! CHECK: %[[C0:.*]] = arith.constant 0 : index
-  ! CHECK: %[[VAL_4:.*]] = fir.coordinate_of %[[VAL_1]], %[[C0]] : (!fir.ref<!fir.array<1xi64>>, index) -> !fir.ref<i64>
-  ! CHECK: fir.store %[[C1_I64]] to %[[VAL_4]] : !fir.ref<i64>
-  ! CHECK: %[[VAL_5:.*]] = fir.embox %[[VAL_1]] : (!fir.ref<!fir.array<1xi64>>) -> !fir.box<!fir.array<1xi64>>
-  ! CHECK: %[[VAL_6:.*]] = fir.embox %[[VAL_0]] : (!fir.ref<!fir.array<0xi64>>) -> !fir.box<!fir.array<0xi64>>
-  ! CHECK: mif.alloc_coarray %[[VAL_3]] lcobounds %[[VAL_5]] ucobounds %[[VAL_6]] {uniq_name = "_QMtestEcount_i_test"} : (!fir.ref<i32>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<0xi64>>) -> ()
-  ! CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_3]] {uniq_name = "_QMtestEcount_i_test"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
-  ! CHECK: fir.call @_QPtest_save_coarray() fastmath<contract> : () -> ()
-  ! CHECK: mif.dealloc_coarray %[[VAL_7]]#0 : (!fir.ref<i32>) -> ()
-  ! CHECK: return
+    allocate(n(10)[*])
+    
+    sync all
+end subroutine test_coarray_cleanup
 
-end program main
+!CHECK:  %[[VAL_0:.*]] = fir.alloca !fir.array<0xi64>
+!CHECK:  %[[VAL_1:.*]] = fir.alloca !fir.array<1xi64>
+!CHECK:  %[[VAL_2:.*]] = fir.dummy_scope : !fir.dscope
+!CHECK:  %[[VAL_3:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xf32>>> {bindc_name = "n", uniq_name = "_QFtest_coarray_cleanupEn"}
+!CHECK:  %[[VAL_4:.*]] = fir.zero_bits !fir.heap<!fir.array<?xf32>>
+!CHECK:  %[[C0:.*]] = arith.constant 0 : index
+!CHECK:  %[[VAL_5:.*]] = fir.shape %[[C0]] : (index) -> !fir.shape<1>
+!CHECK:  %[[VAL_6:.*]] = fir.embox %[[VAL_4]](%[[VAL_5]]) : (!fir.heap<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xf32>>>
+!CHECK:  fir.store %[[VAL_6]] to %[[VAL_3]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
+!CHECK:  %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_3]] {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QFtest_coarray_cleanupEn"} : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>) -> (!fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>)
+!CHECK:  %[[VAL_8:.*]] = fir.absent !fir.box<none>
+!CHECK:  %[[C1:.*]] = arith.constant 1 : index
+!CHECK:  %[[C10_i32:.*]] = arith.constant 10 : i32
+!CHECK:  %[[C0_i32:.*]] = arith.constant 0 : i32
+!CHECK:  %[[VAL_9:.*]] = fir.convert %[[VAL_7]]#0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>) -> !fir.ref<!fir.box<none>>
+!CHECK:  %[[VAL_10:.*]] = fir.convert %[[C1]] : (index) -> i64
+!CHECK:  %[[VAL_11:.*]] = fir.convert %[[C10_i32]] : (i32) -> i64
+!CHECK:  fir.call @_FortranAAllocatableSetBounds(%[[VAL_9:.*]], %[[C0_i32]], %[[VAL_10]], %[[VAL_11]]) fastmath<contract> : (!fir.ref<!fir.box<none>>, i32, i64, i64) -> ()
+!CHECK:  %[[C1_i64:.*]] = arith.constant 1 : i64
+!CHECK:  %[[C0_0:.*]] = arith.constant 0 : index
+!CHECK:  %[[VAL_12:.*]] = fir.coordinate_of %[[VAL_1]], %[[C0_0]] : (!fir.ref<!fir.array<1xi64>>, index) -> !fir.ref<i64>
+!CHECK:  fir.store %[[C1_i64]] to %[[VAL_12]] : !fir.ref<i64>
+!CHECK:  %[[VAL_13:.*]] = fir.embox %[[VAL_1]] : (!fir.ref<!fir.array<1xi64>>) -> !fir.box<!fir.array<1xi64>>
+!CHECK:  %[[VAL_14:.*]] = fir.embox %[[VAL_0]] : (!fir.ref<!fir.array<0xi64>>) -> !fir.box<!fir.array<0xi64>>
+!CHECK:  mif.alloc_coarray %[[VAL_7]]#0 lcobounds %[[VAL_13]] ucobounds %[[VAL_14]] errmsg %[[VAL_8]] {uniq_name = "_QFtest_coarray_cleanupEn"} : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<0xi64>>, !fir.box<none>) -> ()
+!CHECK:  mif.sync_all : () -> ()
+!CHECK:  %[[VAL_15:.*]] = fir.load %[[VAL_7]]#0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
+!CHECK:  %[[VAL_16:.*]] = fir.box_addr %[[VAL_15]] : (!fir.box<!fir.heap<!fir.array<?xf32>>>) -> !fir.heap<!fir.array<?xf32>>
+!CHECK:  %[[VAL_17:.*]] = fir.convert %[[VAL_16]] : (!fir.heap<!fir.array<?xf32>>) -> i64
+!CHECK:  %[[C0_i64:.*]] = arith.constant 0 : i64
+!CHECK:  %[[VAL_18:.*]] = arith.cmpi ne, %[[VAL_17]], %[[C0_i64]] : i64
+!CHECK:  fir.if %[[VAL_18]] {
+!CHECK:    %[[VAL_19:.*]] = fir.absent !fir.box<none>
+!CHECK:    %[[VAL_20:.*]] = fir.absent !fir.ref<i32>
+!CHECK:    mif.dealloc_coarray %[[VAL_7]]#0 stat %[[VAL_20]] errmsg %[[VAL_19]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>, !fir.ref<i32>, !fir.box<none>) -> ()
+!CHECK:  }
+!CHECK:  return
 
diff --git a/flang/test/Lower/MIF/coarray_allocation3.f90 b/flang/test/Lower/MIF/coarray_allocation3.f90
new file mode 100644
index 0000000000000..328fc446c132a
--- /dev/null
+++ b/flang/test/Lower/MIF/coarray_allocation3.f90
@@ -0,0 +1,29 @@
+! RUN: not %flang_fc1 -emit-hlfir -fcoarray %s -o - 2>&1 | FileCheck %s
+
+!CHECK: not yet implemented: Coarray with an allocatable direct component and/or requiring finalization.
+
+module m_test
+    implicit none
+
+    type :: test_type
+        integer :: id
+        real, allocatable :: arr(:)
+    contains
+        final :: finalize_func
+    end type test_type
+
+contains
+
+    subroutine finalize_func(this)
+        type(test_type), intent(inout) :: this
+        if (allocated(this%arr)) deallocate(this%arr)
+    end subroutine finalize_func
+
+end module m_test
+
+program test_final_coarray
+    use m_test
+    implicit none
+    type(test_type), allocatable :: A[:]
+
+end program test_final_coarray
diff --git a/flang/test/Lower/MIF/coarray_allocation4.f90 b/flang/test/Lower/MIF/coarray_allocation4.f90
new file mode 100644
index 0000000000000..bd3de744a5d8b
--- /dev/null
+++ b/flang/test/Lower/MIF/coarray_allocation4.f90
@@ -0,0 +1,8 @@
+! RUN: not %flang_fc1 -emit-hlfir -fcoarray %s -o - 2>&1 | FileCheck %s
+
+!CHECK: not yet implemented: Coarray with explicit SAVE attribute.
+
+subroutine test_coarray_save()
+    implicit none
+    real, SAVE :: n[*]
+end subroutine test_coarray_save

>From 02ad30e175d97700ef8218a6c64e69c9bb9b0c30 Mon Sep 17 00:00:00 2001
From: Jean-Didier PAILLEUX <jean-di.pailleux at outlook.com>
Date: Fri, 20 Mar 2026 13:48:32 +0100
Subject: [PATCH 09/13] Update flang/lib/Lower/ConvertVariable.cpp

Co-authored-by: Dan Bonachea <dobonachea at lbl.gov>
---
 flang/lib/Lower/ConvertVariable.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/flang/lib/Lower/ConvertVariable.cpp b/flang/lib/Lower/ConvertVariable.cpp
index b726022650169..30607fc9190a6 100644
--- a/flang/lib/Lower/ConvertVariable.cpp
+++ b/flang/lib/Lower/ConvertVariable.cpp
@@ -687,6 +687,8 @@ genCleanupDeallocateCoarray(Fortran::lower::AbstractConverter &converter,
   // (only via explicit DEALLOCATE or END TEAM)
   if (Fortran::semantics::IsSaved(sym) &&
       Fortran::semantics::IsFunctionResult(sym))
+  if (Fortran::semantics::IsSaved(sym) ||
+      Fortran::semantics::IsFunctionResult(sym))
     return;
 
   if (hasFinalization(sym) || hasAllocatableDirectComponent(sym))

>From c4ff495f6da4b6191c187c53bcd900012ea20655 Mon Sep 17 00:00:00 2001
From: Jean-Didier PAILLEUX <jean-di.pailleux at outlook.com>
Date: Fri, 20 Mar 2026 13:54:09 +0100
Subject: [PATCH 10/13] Update flang/lib/Lower/ConvertVariable.cpp

Co-authored-by: Dan Bonachea <dobonachea at lbl.gov>
---
 flang/lib/Lower/ConvertVariable.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/flang/lib/Lower/ConvertVariable.cpp b/flang/lib/Lower/ConvertVariable.cpp
index 30607fc9190a6..7115cfece3521 100644
--- a/flang/lib/Lower/ConvertVariable.cpp
+++ b/flang/lib/Lower/ConvertVariable.cpp
@@ -684,7 +684,13 @@ genCleanupDeallocateCoarray(Fortran::lower::AbstractConverter &converter,
   // SAVE (no ALLOCATABLE): never automatically deallocated or finalized
   // (see 7.5.6.4) ALLOCATABLE (no SAVE): automatically deallocated and
   // finalized at scope exit ALLOCATABLE and SAVE: Not deallocated at scope exit
-  // (only via explicit DEALLOCATE or END TEAM)
+  // Local coarray must have the SAVE and/or ALLOCATABLE attributes:
+  // 1. SAVE (no ALLOCATABLE): never automatically deallocated or finalized
+  //    (see 7.5.6.4) 
+  // 2. ALLOCATABLE (no SAVE): automatically deallocated and
+  //    finalized at scope exit 
+  // 3. ALLOCATABLE and SAVE: Not deallocated at scope exit
+  //    (only via explicit DEALLOCATE or END TEAM)
   if (Fortran::semantics::IsSaved(sym) &&
       Fortran::semantics::IsFunctionResult(sym))
   if (Fortran::semantics::IsSaved(sym) ||

>From 0ef3054b871bd58447be991ef25382a5c66909c0 Mon Sep 17 00:00:00 2001
From: Jean-Didier Pailleux <jean-didier.pailleux at sipearl.com>
Date: Fri, 20 Mar 2026 16:04:32 +0100
Subject: [PATCH 11/13] Fix clang-format + replace deallocate in
 convertVariable.cpp by a fatal error

---
 flang/lib/Lower/ConvertVariable.cpp | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/flang/lib/Lower/ConvertVariable.cpp b/flang/lib/Lower/ConvertVariable.cpp
index 7115cfece3521..5990ba9962389 100644
--- a/flang/lib/Lower/ConvertVariable.cpp
+++ b/flang/lib/Lower/ConvertVariable.cpp
@@ -686,9 +686,9 @@ genCleanupDeallocateCoarray(Fortran::lower::AbstractConverter &converter,
   // finalized at scope exit ALLOCATABLE and SAVE: Not deallocated at scope exit
   // Local coarray must have the SAVE and/or ALLOCATABLE attributes:
   // 1. SAVE (no ALLOCATABLE): never automatically deallocated or finalized
-  //    (see 7.5.6.4) 
+  //    (see 7.5.6.4)
   // 2. ALLOCATABLE (no SAVE): automatically deallocated and
-  //    finalized at scope exit 
+  //    finalized at scope exit
   // 3. ALLOCATABLE and SAVE: Not deallocated at scope exit
   //    (only via explicit DEALLOCATE or END TEAM)
   if (Fortran::semantics::IsSaved(sym) &&
@@ -714,9 +714,8 @@ genCleanupDeallocateCoarray(Fortran::lower::AbstractConverter &converter,
     if (auto mutBox = exv.getBoxOf<fir::MutableBoxValue>())
       Fortran::lower::genDeallocateIfAllocated(converter, *mutBox, loc);
     else
-      mif::DeallocCoarrayOp::create(*builder, loc, fir::getBase(exv),
-                                    /*stat*/ mlir::Value{},
-                                    /*errmsg*/ mlir::Value{});
+      fir::emitFatalError(
+          loc, "Non-allocatable coarrays are never automatically deallocated");
   });
 }
 

>From 5643ea646fa9dcaeda435b5f213b724dc21e7b4d Mon Sep 17 00:00:00 2001
From: Jean-Didier Pailleux <jean-didier.pailleux at sipearl.com>
Date: Mon, 23 Mar 2026 12:59:54 +0100
Subject: [PATCH 12/13] Adding test with coarray declared in a module and used
 in Main + Update TODO messages

---
 flang/lib/Lower/ConvertVariable.cpp          | 20 ++++-----
 flang/test/Lower/MIF/coarray_allocation4.f90 |  2 +-
 flang/test/Lower/MIF/coarray_allocation5.f90 | 45 ++++++++++++++++++++
 3 files changed, 56 insertions(+), 11 deletions(-)
 create mode 100644 flang/test/Lower/MIF/coarray_allocation5.f90

diff --git a/flang/lib/Lower/ConvertVariable.cpp b/flang/lib/Lower/ConvertVariable.cpp
index 5990ba9962389..3f8bd51a33ab0 100644
--- a/flang/lib/Lower/ConvertVariable.cpp
+++ b/flang/lib/Lower/ConvertVariable.cpp
@@ -677,9 +677,12 @@ genCleanupDeallocateCoarray(Fortran::lower::AbstractConverter &converter,
                             Fortran::lower::SymMap &symMap) {
   mlir::Location loc = converter.getCurrentLocation();
   const Fortran::semantics::Symbol &sym = var.getSymbol();
-  auto *builder = &converter.getFirOpBuilder();
   fir::ExtendedValue exv = converter.getSymbolExtendedValue(sym, &symMap);
 
+  if (hasFinalization(sym) || hasAllocatableDirectComponent(sym))
+    TODO(loc, "Coarray with an allocatable direct component and/or requiring "
+              "finalization.");
+
   // Local coarray must have the SAVE and/or ALLOCATABLE attributes.
   // SAVE (no ALLOCATABLE): never automatically deallocated or finalized
   // (see 7.5.6.4) ALLOCATABLE (no SAVE): automatically deallocated and
@@ -691,16 +694,10 @@ genCleanupDeallocateCoarray(Fortran::lower::AbstractConverter &converter,
   //    finalized at scope exit
   // 3. ALLOCATABLE and SAVE: Not deallocated at scope exit
   //    (only via explicit DEALLOCATE or END TEAM)
-  if (Fortran::semantics::IsSaved(sym) &&
-      Fortran::semantics::IsFunctionResult(sym))
   if (Fortran::semantics::IsSaved(sym) ||
       Fortran::semantics::IsFunctionResult(sym))
     return;
 
-  if (hasFinalization(sym) || hasAllocatableDirectComponent(sym))
-    TODO(loc, "Coarray with an allocatable direct component and/or requiring "
-              "finalization.");
-
   if (Fortran::semantics::IsDummy(sym)) {
     // PRIF provide prif_alias_destroy to delete an aliased descriptor
     // for a coarray. This procedure does not deallocate or alter the
@@ -710,7 +707,7 @@ genCleanupDeallocateCoarray(Fortran::lower::AbstractConverter &converter,
     TODO(loc, "Cleanup aliased coarray created for a dummy argument.");
   }
 
-  converter.getFctCtx().attachCleanup([&converter, builder, loc, exv, sym]() {
+  converter.getFctCtx().attachCleanup([&converter, loc, exv, sym]() {
     if (auto mutBox = exv.getBoxOf<fir::MutableBoxValue>())
       Fortran::lower::genDeallocateIfAllocated(converter, *mutBox, loc);
     else
@@ -2540,8 +2537,11 @@ void Fortran::lower::mapSymbolAttributes(
   }
 
   if (Fortran::evaluate::IsCoarray(sym)) {
-    if (sym.attrs().test(Fortran::semantics::Attr::SAVE))
-      TODO(loc, "Coarray with explicit SAVE attribute.");
+    if (!Fortran::semantics::IsAllocatable(sym) &&
+        Fortran::semantics::IsSaved(sym) &&
+        sym.owner().kind() != Fortran::semantics::Scope::Kind::MainProgram)
+      TODO(loc, "non-ALLOCATABLE SAVE Coarray outside the main program.");
+    ;
     Fortran::lower::genAllocateCoarray(converter, loc, sym, addr);
     ::genDeclareSymbol(converter, symMap, sym, addr, len, extents, lbounds,
                        replace);
diff --git a/flang/test/Lower/MIF/coarray_allocation4.f90 b/flang/test/Lower/MIF/coarray_allocation4.f90
index bd3de744a5d8b..fe4741e099744 100644
--- a/flang/test/Lower/MIF/coarray_allocation4.f90
+++ b/flang/test/Lower/MIF/coarray_allocation4.f90
@@ -1,6 +1,6 @@
 ! RUN: not %flang_fc1 -emit-hlfir -fcoarray %s -o - 2>&1 | FileCheck %s
 
-!CHECK: not yet implemented: Coarray with explicit SAVE attribute.
+!CHECK: not yet implemented: non-ALLOCATABLE SAVE Coarray outside the main program.
 
 subroutine test_coarray_save()
     implicit none
diff --git a/flang/test/Lower/MIF/coarray_allocation5.f90 b/flang/test/Lower/MIF/coarray_allocation5.f90
new file mode 100644
index 0000000000000..602b17806c2a9
--- /dev/null
+++ b/flang/test/Lower/MIF/coarray_allocation5.f90
@@ -0,0 +1,45 @@
+! RUN: %flang_fc1 -emit-hlfir -fcoarray %s -o - | FileCheck %s
+
+module m_coarray_test
+    implicit none
+    real :: module_coarray[*]
+end module m_coarray_test
+
+program test_module_coarray
+    use m_coarray_test
+    implicit none
+    integer :: me
+
+    me = this_image()
+    module_coarray = real(me)
+
+end program test_module_coarray
+
+
+!CHECK: fir.global @_QMm_coarray_testEmodule_coarray : f32 {
+!CHECK:   %[[VAL_0:.*]] = fir.zero_bits f32
+!CHECK:   fir.has_value %[[VAL_0]] : f32
+!CHECK: }
+!CHECK: func.func @_QQmain() attributes {fir.bindc_name = "TEST_MODULE_COARRAY"} {
+!CHECK:   %[[VAL_0:.*]] = fir.alloca !fir.array<0xi64>
+!CHECK:   %[[VAL_1:.*]] = fir.alloca !fir.array<1xi64>
+!CHECK:   %[[VAL_2:.*]] = fir.dummy_scope : !fir.dscope
+!CHECK:   %[[VAL_3:.*]] = fir.alloca i32 {bindc_name = "me", uniq_name = "_QFEme"}
+!CHECK:   %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_3]] {uniq_name = "_QFEme"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
+!CHECK:   %[[VAL_5:.*]] = fir.address_of(@_QMm_coarray_testEmodule_coarray) : !fir.ref<f32>
+!CHECK:   %[[C1_I64:.*]] = arith.constant 1 : i64
+!CHECK:   %[[C0:.*]] = arith.constant 0 : index
+!CHECK:   %[[VAL_6:.*]] = fir.coordinate_of %[[VAL_1]], %[[C0]] : (!fir.ref<!fir.array<1xi64>>, index) -> !fir.ref<i64>
+!CHECK:   fir.store %[[C1_I64]] to %[[VAL_6]] : !fir.ref<i64>
+!CHECK:   %[[VAL_7:.*]] = fir.embox %[[VAL_1]] : (!fir.ref<!fir.array<1xi64>>) -> !fir.box<!fir.array<1xi64>>
+!CHECK:   %[[VAL_8:.*]] = fir.embox %[[VAL_0]] : (!fir.ref<!fir.array<0xi64>>) -> !fir.box<!fir.array<0xi64>>
+!CHECK:   mif.alloc_coarray %[[VAL_5]] lcobounds %[[VAL_7]] ucobounds %[[VAL_8]] {uniq_name = "_QMm_coarray_testEmodule_coarray"} : (!fir.ref<f32>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<0xi64>>) -> ()
+!CHECK:   %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_5]] {uniq_name = "_QMm_coarray_testEmodule_coarray"} : (!fir.ref<f32>) -> (!fir.ref<f32>, !fir.ref<f32>)
+!CHECK:   %[[VAL_10:.*]] = mif.this_image : () -> i32
+!CHECK:   hlfir.assign %[[VAL_10]] to %[[VAL_4]]#0 : i32, !fir.ref<i32>
+!CHECK:   %[[VAL_11:.*]] = fir.load %[[VAL_4]]#0 : !fir.ref<i32>
+!CHECK:   %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (i32) -> f32
+!CHECK:   hlfir.assign %[[VAL_12]] to %[[VAL_9]]#0 : f32, !fir.ref<f32>
+!CHECK:   return
+!CHECK: }
+

>From e73ccb98a613701471f756996f30ceae6a6bb94d Mon Sep 17 00:00:00 2001
From: Jean-Didier Pailleux <jean-didier.pailleux at sipearl.com>
Date: Wed, 1 Apr 2026 14:18:05 +0200
Subject: [PATCH 13/13] Adding TODO when defining NON-Allocatable SAVE coarray
 in module

---
 flang/lib/Lower/Bridge.cpp                   |  8 +++-
 flang/test/Lower/MIF/coarray_allocation5.f90 | 43 ++------------------
 2 files changed, 10 insertions(+), 41 deletions(-)

diff --git a/flang/lib/Lower/Bridge.cpp b/flang/lib/Lower/Bridge.cpp
index 6eedb089eac40..71112d13ce028 100644
--- a/flang/lib/Lower/Bridge.cpp
+++ b/flang/lib/Lower/Bridge.cpp
@@ -6855,8 +6855,14 @@ class FirConverter : public Fortran::lower::AbstractConverter {
         if (sym.name() == "numeric_storage_size" && owner.IsModule() &&
             DEREF(owner.symbol()).name() == "iso_fortran_env")
           continue;
-      }
 
+        if (Fortran::evaluate::IsCoarray(sym) &&
+            !Fortran::semantics::IsAllocatable(sym) &&
+            Fortran::semantics::IsSaved(sym)) {
+          mlir::Location loc = toLocation();
+          TODO(loc, "non-ALLOCATABLE SAVE Coarray outside the main program.");
+        }
+      }
       Fortran::lower::defineModuleVariable(*this, var);
     }
     for (auto &eval : mod.evaluationList)
diff --git a/flang/test/Lower/MIF/coarray_allocation5.f90 b/flang/test/Lower/MIF/coarray_allocation5.f90
index 602b17806c2a9..19fb71aa4edbd 100644
--- a/flang/test/Lower/MIF/coarray_allocation5.f90
+++ b/flang/test/Lower/MIF/coarray_allocation5.f90
@@ -1,45 +1,8 @@
-! RUN: %flang_fc1 -emit-hlfir -fcoarray %s -o - | FileCheck %s
+! RUN: not %flang_fc1 -emit-hlfir -fcoarray %s -o - 2>&1 | FileCheck %s
+
+!CHECK: not yet implemented: non-ALLOCATABLE SAVE Coarray outside the main program.
 
 module m_coarray_test
     implicit none
     real :: module_coarray[*]
 end module m_coarray_test
-
-program test_module_coarray
-    use m_coarray_test
-    implicit none
-    integer :: me
-
-    me = this_image()
-    module_coarray = real(me)
-
-end program test_module_coarray
-
-
-!CHECK: fir.global @_QMm_coarray_testEmodule_coarray : f32 {
-!CHECK:   %[[VAL_0:.*]] = fir.zero_bits f32
-!CHECK:   fir.has_value %[[VAL_0]] : f32
-!CHECK: }
-!CHECK: func.func @_QQmain() attributes {fir.bindc_name = "TEST_MODULE_COARRAY"} {
-!CHECK:   %[[VAL_0:.*]] = fir.alloca !fir.array<0xi64>
-!CHECK:   %[[VAL_1:.*]] = fir.alloca !fir.array<1xi64>
-!CHECK:   %[[VAL_2:.*]] = fir.dummy_scope : !fir.dscope
-!CHECK:   %[[VAL_3:.*]] = fir.alloca i32 {bindc_name = "me", uniq_name = "_QFEme"}
-!CHECK:   %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_3]] {uniq_name = "_QFEme"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
-!CHECK:   %[[VAL_5:.*]] = fir.address_of(@_QMm_coarray_testEmodule_coarray) : !fir.ref<f32>
-!CHECK:   %[[C1_I64:.*]] = arith.constant 1 : i64
-!CHECK:   %[[C0:.*]] = arith.constant 0 : index
-!CHECK:   %[[VAL_6:.*]] = fir.coordinate_of %[[VAL_1]], %[[C0]] : (!fir.ref<!fir.array<1xi64>>, index) -> !fir.ref<i64>
-!CHECK:   fir.store %[[C1_I64]] to %[[VAL_6]] : !fir.ref<i64>
-!CHECK:   %[[VAL_7:.*]] = fir.embox %[[VAL_1]] : (!fir.ref<!fir.array<1xi64>>) -> !fir.box<!fir.array<1xi64>>
-!CHECK:   %[[VAL_8:.*]] = fir.embox %[[VAL_0]] : (!fir.ref<!fir.array<0xi64>>) -> !fir.box<!fir.array<0xi64>>
-!CHECK:   mif.alloc_coarray %[[VAL_5]] lcobounds %[[VAL_7]] ucobounds %[[VAL_8]] {uniq_name = "_QMm_coarray_testEmodule_coarray"} : (!fir.ref<f32>, !fir.box<!fir.array<1xi64>>, !fir.box<!fir.array<0xi64>>) -> ()
-!CHECK:   %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_5]] {uniq_name = "_QMm_coarray_testEmodule_coarray"} : (!fir.ref<f32>) -> (!fir.ref<f32>, !fir.ref<f32>)
-!CHECK:   %[[VAL_10:.*]] = mif.this_image : () -> i32
-!CHECK:   hlfir.assign %[[VAL_10]] to %[[VAL_4]]#0 : i32, !fir.ref<i32>
-!CHECK:   %[[VAL_11:.*]] = fir.load %[[VAL_4]]#0 : !fir.ref<i32>
-!CHECK:   %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (i32) -> f32
-!CHECK:   hlfir.assign %[[VAL_12]] to %[[VAL_9]]#0 : f32, !fir.ref<f32>
-!CHECK:   return
-!CHECK: }
-