[flang][codegen] Add a conversion for `fir.coordinate_of` - part 1

[awarzynski]

Summary

This patch extends the FIRToLLVMLowering pass in Flang by adding a
hook to transform fir.coordinate_of into a sequence of LLVM MLIR
instructions.

The following cases are currently supported:

1. the input object is a fir.complex (wrapped in e.g. fir.ref or fir.box)
2. the input object is wrapped in a fir.box (including e.g. fir.array).

Note that fir.complex wrapped in a fir.box falls under case 1. above
(i.e. it's a special case regardless of the wrapping type). Sequence
types are not yet supported (e.g. fir.array that is _not wrapped_ with
fir.box).

This is part of the upstreaming effort from the fir-dev branch in [1].

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

[awarzynski]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

2285

PLEASE SKIP THIS BLOCK

@rovka will send a separate patch for LenParamIndexOpConversion. I've only added it here to be able to test this.

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

400

I'll fix these trailing white-spaces in a separate patch and then rebase.

[awarzynski]

Rebase

[kiranchandramohan]

A few nit comments.

flang/lib/Optimizer/CodeGen/CodeGen.cpp

2137

Nit: use NotifyMatchfailure

2163

Nit: Notifymatch failure

2261

Nit: remove auto?

2266

Nit: remove auto?

[clementval]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

26

Is this include needed? Can you use "?

201

Replace 0 with kAddrPosInBox

238–240

2128

2157

2203

[awarzynski]

Address PR comments (remove auto, replace "magic numbers" with variables, switch to notifyMatchFailure in place of mlir::emitError)

[awarzynski]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

26

Is this include needed?

Yes, one of my plugins adds these whenever I switch from auto to a specific type. But this will be included by some other file anyway. I'll just remove it.

201

Thanks!

238–240

Thanks!

2137

Makes sense, but then we won't be able to check for this diagnostic in "convert-to-llvm-invalid.fir". I'm starting to think that we should --debug there. @clementval , what are your thoughts?

[schweitz]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

2134

Are we adding backquotes to error messages now? Why?

[awarzynski]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

2134

That's a typo, I must have worked on a project in which that's the preferred convention. #too-many-coding-styles. Let me fix this. Thanks for pointing it out!

[awarzynski]

Fix comments (remove back-ticks)

[awarzynski]

• Rebase.
• Mark the case for fir.len_param_index as a TODO (i.e. unimplemented). This is consistent with https://reviews.llvm.org/D114241.

[awarzynski]

Refine variable names (e.g. objectTy --> boxedObjTy)

[rovka]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

72

Is this actually used?

2176

Nit: I think you can flip this function around (i.e. check the preconditions first and have the bulk of the code outside of the ifs).
Also, I'm almost afraid to suggest this, but I think the unreachable can be replaced with an assert.

2223

Not saying it should be part of this patch, but is there a test for this somewhere? (I'd expect it in test/Fir/invalid.fir, but AFAICT there isn't anything there)

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

1567

Would be nice to also have a testcase with more than one index operand.

1575

1576

1579

1581

1595

1626

[awarzynski]

Refactor getIntValue, delete voidPtrTy, add a testcase with more than one index operand, fix typos

[awarzynski]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

72

Nope. Good catch, thanks!

2176

Thanks for the suggestions! Let me rewrite this. Stay tuned!

2223

Good catch, thanks! This is currently not being captured (so can't a test in "invalid.fir"). I'll take a look later and see whether I can implement a separate verifier for this. Probably in a separate patch.

[awarzynski]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

2176

Please take a look again.

[rovka]

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

1609

This is very fishy, are you sure this is supposed to work? I'm following up to SUBOBJECT_1_ADDR, IIUC that's the address of field_1. It seems very bizarre to then take this ptr<i32> and cast it to <ptr<struct<"derived_2">> and index into it again. I feel like this should be an error, i.e. the thing that the second index is indexing into should be another struct or array or something, not an i32. Am I misunderstanding the coordinate_of semantics?

[awarzynski]

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

1609

This is very fishy

Agreed. Thanks for catching this and apologies for not paying more intention when submitting last night. I think that we should be getting the following instead (might be easier to parse without the regex):

llvm.func @coordinate_box_derived_2(%arg0: !llvm.ptr<struct<(ptr<struct<"derived_2", (i32, i32)>>, i64, i32, i8, i8, i8, i8, ptr<i8>, array<1 x i64>)>>) {
  %0 = llvm.mlir.constant(0 : i32) : i32
  %1 = llvm.mlir.constant(1 : i32) : i32
  %2 = llvm.mlir.constant(0 : i32) : i32
  %3 = llvm.mlir.constant(0 : i32) : i32
  %4 = llvm.getelementptr %arg0[%2, %3] : (!llvm.ptr<struct<(ptr<struct<"derived_2", (i32, i32)>>, i64, i32, i8, i8, i8, i8, ptr<i8>, array<1 x i64>)>>, i32, i32) -> !llvm.ptr<ptr<struct<"derived_2", (i32, i32)>>>
  %5 = llvm.load %4 : !llvm.ptr<ptr<struct<"derived_2", (i32, i32)>>>
  %6 = llvm.mlir.constant(0 : i64) : i64
  %7 = llvm.getelementptr %5[%6, %0] : (!llvm.ptr<struct<"derived_2", (i32, i32)>>, i64, i32) -> !llvm.ptr<i32>
  %8 = llvm.getelementptr %5[%6, %1] : (!llvm.ptr<struct<"derived_2", (i32, i32)>>, i64, i32) -> !llvm.ptr<i32>
  %9 = llvm.bitcast %5 : !llvm.ptr<struct<"derived_2", (i32, i32)>> to !llvm.ptr<i32>
  llvm.return
}

Does it make sense? I'll send an updated patch shortly. It gets rid of quite a few redundant casts. Unless I misunderstood GEP again and they are actually needed :)

[awarzynski]

Remove redundant casts

[awarzynski]

Fix formatting

[rovka]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

2253

This still doesn't seem quite right. How are all these GEPs used? It seems you're just creating them, but then you're replacing the original coor with objectBaseAddr, so you're just going around the GEPs (i.e. the users of the coor will get objectBaseAddr instead of a GEP based on objectBaseAddr).

[clementval]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

2253

Please double check in fir-dev when you change code like that.

[awarzynski]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

2253

@rovka

Good point, thanks! Also, your comment made me realise that I misunderstood how fir.coordinate_of is meant to work for fir.type and fir.array. In particular, fir.type could contain fir.array and vice versa. This is catered for on fir-dev (see here ), but was incorrectly split into "orthogonal" cases by me in this patch. I will revert that and restore one big case for fir.type/fir.array instead.

And yes, this "rewrite" should replace the original OP with a GEP. In theory :) There's a bunch of bitcasts too as fir.array and fir.type cases are a bit different. So, ultimately, it might be an llvm.bitcast applied to a result of llvm.getelemenptr.

Please double check in fir-dev when you change code like that.

Checked, all good 👍🏻 !

[awarzynski]

Fix how fir.array and fir.type (embedded inside fir.box) are handled. In particular, make sure that fir.type inside fir.array and fir.array inside fir.type are supported.

Thanks @rovka for all the suggestions!

[clementval]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

2253

Looks like you are making substantial change from the original code you are upstreaming. Might be wise to submit those change first in fir-dev to be reviewed and test with more extensive tests.

[awarzynski]

Move one definition of a constant 0 (c0) so that the code generated here and on fir-dev are identical.

[awarzynski]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

2253

Might be wise to submit those change first in fir-dev to be reviewed

I appreciate that you are concerned about the delta between main and fir-dev, but the code generated here and on fir-dev is identical (I've just pushed a small change to make sure that this condition is met). The biggest difference are the tests - these will be as "new" on fir-dev as they are here.

I'd like us to finish reviewing these changes here rather than on fir-dev. This is more inclusive (AFAIK, everyone from fir-dev is active here, but not everyone from main visits fir-dev). Perhaps sending a patch with tests added here to fir-dev would be a good idea? The actual changes to CoordinateOpConversion would be sent later as a separate patch (i.e. as a "sync-up" patch). This way fir-dev developers can be confident that the changes introduced in main don't break the code. WDYT?

[clementval]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

2253

If you are confident that your change will not trigger a regression on fir-dev then fine for me. The change seems bigger than it really is. I was seeing something about fixing this conversion so I was just worried about what had to be fixed.

[clementval]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

2242

Can you fix the clang-format here?

2263

format

[rovka]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

2221

Are these really the only 4 cases? Is it possible to have any combination of arrays/deriveds inside of arrays/deriveds, e.g. fir.array<M x fir.type<d1{field1:fir.array<N x fir.array <10 x i32>>, field_2:fir.type<d2{i32, i32}>}>>? Maybe a more generic sentence would work better here

2241

So, IIUC, if you have coordinate_of on a fir.array<M x N x fir.array<P x i32>> with operands idx1, idx2, idx3, then you end up multiplying idx1 * stride(operands[0], 0), then idx2 * stride(operands[0], 1), then idx3 * stride(operands[0], 0). That sounds like you expect the same stride for the inner array as for the outer array. That doesn't seem right. Am I missing something?

Also, is it even possible to have an inner fir.array without a box? Or would you actually have fir.array<M x N x fir.box<fir.array<P x i32>>?

[awarzynski]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

2221

Let me just mix 2.3 and 2.4 then.

2241

That doesn't seem right. Am I missing something?

I'll double-check with @schweitz. IIUC, it's either a bug or an indication that this fir.box contains one of: !fir.array<!fir.derived<>> or !fir.derived<>.

Also, is it even possible to have an inner fir.array without a box? Or would you actually have fir.array<M x N x fir.box<fir.array<P x i32>>?

Well, there's fir::emitFatalError(loc, "unexpected type in coordinate_of"); towards the end of this method which is hit if the requested element inside the original fir.array or fir.type is neither ... fir.array nor fir.type.

2242

Yup, sorry about that! Still haven't figured why arc lint does nothing for me.

[awarzynski]

Added two more cases, fixed formatting

[awarzynski]

NOTE: The following discussion refers to the code from doRewriteBox.

I'm looking at the "GENERAL CASE" in doRewriteBox again, which is the trickiest one here. Let me summarise a bit. There are quite a few potential cases and I don't want to miss anything.

The following cases are IMO quite clear and already fully tested:

// 1. (`fir.array`)
%box = ... : !fix.box<!fir.array<?xU>>
%idx = ... : index
%resultAddr = coordinate_of %box, %idx : !fir.ref<U>

// 2 (`fir.derived`)
%box = ... : !fix.box<!fir.type<derived_type{field_1:i32}>>
%idx = ... : i32
%resultAddr = coordinate_of %box, %idx : !fir.ref<i32>

// 3 (`fir.derived` inside `fir.array`)
%box = ... : !fir.box<!fir.array<10 x !fir.type<derived_1{field_1:f32, field_2:f32}>>>
%idx1 = ... : index
%idx2 = ... : i32
%resultAddr = coordinate_of %box, %idx1, %idx2 : !fir.ref<f32>

I've also added a test for the following case, but I am realising that the generated code is not valid:

4. (`fir.array` inside `fir.derived`)
%box = ... : !fix.box<!fir.type<derived_type{field_1:!fir.array<10xf32>}>>
%idx1 = ... : i32
%idx2 = ... : index
%resultAddr = coordinate_of %box, %idx1, %idx2 : !fir.ref<f32>

It's not valid, because the stride is calculated as (@rovka, thanks for pointing this out!):

mlir::Value stride = loadStrideFromBox(loc, operands[0], index - i, rewriter);

i.e., it's always extracted from the outer box (%box in the snippet above). Making this code work correctly for 4. would require a design discussion. I think that's out-of-scope here. Instead, I'll add a new TODO for nested arrays and move the corresponding test to flang/test/Fir/Todo/. WDYT? Also, have I missed any cases?

[awarzynski]

Treat cases with nested arrays (e.g. fix.box<!fir.type<derived_type{field_1:!fir.array<10xf32>}>>) as a TODO. Rebase on top of main.

[awarzynski]

Revert the change in flang/unittests/Optimizer/Builder/Runtime/RuntimeCallTestBase.h (added by accident)

[awarzynski]

Switch from to arith.constant to !fir.field in tests. Otherwise, minor improvements.

[rovka]

LGTM, thanks for all the changes :)

flang/lib/Optimizer/CodeGen/CodeGen.cpp

2255

Microscopic nit: recTy would be more suggestive.

flang/test/Fir/Todo/cordinate_of_2.fir

8 ↗

(On Diff #391378)

Very small nit: Maybe also have a testcase with derived<derived<array, ...>, ...> ?

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

1606

[awarzynski]

Allow dynamically sized arrays inside !fir.box.

I mistakenly disallowed dynamically sized arrays earlier. However, IIUC, boxed arrays (and that's the only type of arrays dealt with in this patch) shouldn't require size when using fir.coordinate_of. In fact, !fir.box<!fir.array<? x i32>> should be no different to !fir.box<!fir.array<? x i32>> in this case. Updated accordingly. @rovka, could you take one final look?

Also rebased on top of main.

[awarzynski]

Address [nits] from @rovka

[rovka]

Seems fine, thanks.

In D114159#3175939, @awarzynski wrote:

Allow dynamically sized arrays inside !fir.box.

I mistakenly disallowed dynamically sized arrays earlier. However, IIUC, boxed arrays (and that's the only type of arrays dealt with in this patch) shouldn't require size when using fir.coordinate_of. In fact, !fir.box<!fir.array<? x i32>> should be no different to !fir.box<!fir.array<? x i32>> in this case.

I assume you mean !fir.ref<!fir.array<? x i32>> versus !fir.box<!fir.array<? x i32>> :)

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

1655

Do we still expect an error here?

[awarzynski]

In D114159#3182242, @rovka wrote:

Seems fine, thanks.

In D114159#3175939, @awarzynski wrote:

Allow dynamically sized arrays inside !fir.box.

I mistakenly disallowed dynamically sized arrays earlier. However, IIUC, boxed arrays (and that's the only type of arrays dealt with in this patch) shouldn't require size when using fir.coordinate_of. In fact, !fir.box<!fir.array<? x i32>> should be no different to !fir.box<!fir.array<? x i32>> in this case.

I assume you mean !fir.ref<!fir.array<? x i32>> versus !fir.box<!fir.array<? x i32>> :)

I meant that !fir.box<!fir.array<10 x i32>> and !fir.box<!fir.array<? x i32>> should be identical :) That was the source of confusion for me initially and it finally clicked when working on https://reviews.llvm.org/D115333. Basically, I thought that !fir.box<!fir.array<? x i32>> shouldn't work and that's why I added the extra check in doRewrite. However, since !fir.array is "boxed" (that's the only case considered here), this should be just fine and so I removed that check.

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

1655

This particular line was copied by mistake, sorry! It will be ignored as we don't use -verify-diagnostics in this file.

Instead, the code is correctly converted (see the expected output below).

[awarzynski]

Remove an out-of-date test check (this was copied earlier by accident)

[awarzynski]

Thank you all for reviewing! I'll merge this tomorrow if there are no new comments.

flang/lib/Optimizer/CodeGen/CodeGen.cpp

 #include "flang/Optimizer/Support/TypeCode.h"
 #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
 #include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/Pass/Pass.h"
 #include "llvm/ADT/ArrayRef.h"
+#include <mlir/IR/OperationSupport.h>
 
 #define DEBUG_TYPE "flang-codegen"
 
 // fir::LLVMTypeConverter for converting to LLVM IR dialect types.
 #include "TypeConverter.h"
 
 // TODO: This should really be recovered from the specified target.
 static constexpr unsigned defaultAlign = 8;

 
 static Block *createBlock(mlir::ConversionPatternRewriter &rewriter,
                           mlir::Block *insertBefore) {
   assert(insertBefore && "expected valid insertion block");
   return rewriter.createBlock(insertBefore->getParent(),
                               mlir::Region::iterator(insertBefore));
 }
 
+inline mlir::Type getVoidPtrType(mlir::MLIRContext *context) {
+  return mlir::LLVM::LLVMPointerType::get(mlir::IntegerType::get(context, 8));
+}
+
 namespace {
 /// FIR conversion pattern template
 template <typename FromOp>
 class FIROpConversion : public mlir::ConvertOpToLLVMPattern<FromOp> {
 public:
   explicit FIROpConversion(fir::LLVMTypeConverter &lowering)
       : mlir::ConvertOpToLLVMPattern<FromOp>(lowering) {}
 
 protected:
   mlir::Type convertType(mlir::Type ty) const {
     return lowerTy().convertType(ty);
   }
+  mlir::Type voidPtrTy() const {
+    return getVoidPtrType(&lowerTy().getContext());
+  }
 
   mlir::LLVM::ConstantOp
   genI32Constant(mlir::Location loc, mlir::ConversionPatternRewriter &rewriter,
                  int value) const {
     mlir::Type i32Ty = rewriter.getI32Type();
     mlir::IntegerAttr attr = rewriter.getI32IntegerAttr(value);
     return rewriter.create<mlir::LLVM::ConstantOp>(loc, i32Ty, attr);
   }
for (auto i : indexes) {
       } else {
         fir::emitFatalError(mlir::UnknownLoc::get(type.getContext()),
                             "request for invalid box element type");
       }
     }
     return type;
   }
 
+  // Return LLVM type of the base address given the LLVM type
+  // of the related descriptor (lowered fir.box type).
+  static mlir::Type getBaseAddrTypeFromBox(mlir::Type type) {
+    return getBoxEleTy(type, {0});
+  }
+
   template <typename... ARGS>
   mlir::LLVM::GEPOp genGEP(mlir::Location loc, mlir::Type ty,
                            mlir::ConversionPatternRewriter &rewriter,
                            mlir::Value base, ARGS... args) const {
     SmallVector<mlir::Value> cv{args...};
     return rewriter.create<mlir::LLVM::GEPOp>(loc, ty, base, cv);
   }
 
mlir::Value integerCast(mlir::Location loc,
     auto fromSize = mlir::LLVM::getPrimitiveTypeSizeInBits(valTy);
     if (toSize < fromSize)
       return rewriter.create<mlir::LLVM::TruncOp>(loc, ty, val);
     if (toSize > fromSize)
       return rewriter.create<mlir::LLVM::SExtOp>(loc, ty, val);
     return val;
   }
 
+  mlir::Value
+  loadStrideFromBox(mlir::Location loc, mlir::Value box, unsigned dim,
+                    mlir::ConversionPatternRewriter &rewriter) const {
+    auto idxTy = lowerTy().indexType();
+    auto c0 = genConstantOffset(loc, rewriter, 0);
+    auto c7 = genConstantOffset(loc, rewriter, 7);
+    auto dimValue = genConstantIndex(loc, idxTy, rewriter, dim);
+    return loadFromOffset(loc, box, c0, c7, dimValue, 2, idxTy, rewriter);
+  }
+
   fir::LLVMTypeConverter &lowerTy() const {
     return *static_cast<fir::LLVMTypeConverter *>(this->getTypeConverter());
   }
 };
 
 /// FIR conversion pattern template
 template <typename FromOp>
 class FIROpAndTypeConversion : public FIROpConversion<FromOp> {
struct UnboxProcOpConversion : public FIROpConversion<fir::UnboxProcOp> {
   mlir::LogicalResult
   matchAndRewrite(fir::UnboxProcOp unboxproc, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     return rewriter.notifyMatchFailure(
         unboxproc, "fir.unboxproc codegen is not implemented yet");
   }
 };
 
+/// Convert to (memory) reference to a reference to a subobject.
+/// The coordinate_of op is a Swiss army knife operation that can be used on
+/// (memory) references to records, arrays, complex, etc. as well as boxes.
+/// With unboxed arrays, there is the restriction that the array have a static
+/// shape in all but the last column.
+struct CoordinateOpConversion
+    : public FIROpAndTypeConversion<fir::CoordinateOp> {
+  using FIROpAndTypeConversion::FIROpAndTypeConversion;
+
+  mlir::LogicalResult
+  doRewrite(fir::CoordinateOp coor, mlir::Type ty, OpAdaptor adaptor,
+            mlir::ConversionPatternRewriter &rewriter) const override {
+    auto operands = adaptor.getOperands();
+
+    mlir::Location loc = coor.getLoc();
+    mlir::Value base = operands[0];
+    mlir::Type baseObjectTy = coor.getBaseType();
+    mlir::Type objectTy = fir::dyn_cast_ptrOrBoxEleTy(baseObjectTy);
+    assert(objectTy && "`fir.coordinate_of` expects a reference type");
+
+    if (fir::hasDynamicSize(fir::unwrapSequenceType(objectTy)))
+      return mlir::emitError(
+          loc,
+          "`fir.coordinate_of` with a dynamic element size is unsupported");
+
+    // Complex type - basically, extract the real or imaginary part
+    if (fir::isa_complex(objectTy)) {
+      mlir::LLVM::ConstantOp c0 =
+          genConstantIndex(loc, lowerTy().indexType(), rewriter, 0);
+      SmallVector<mlir::Value> offs = {c0, operands[1]};
+      mlir::Value gep = genGEP(loc, ty, rewriter, base, offs);
+      rewriter.replaceOp(coor, gep);
+      return success();
+    }
+
+    // Box type - get the base pointer from the box
+    if (auto boxTy = baseObjectTy.dyn_cast<fir::BoxType>()) {
+      doRewriteBox(coor, ty, operands, loc, rewriter);
+      return success();
+    }
+
+    // Sequence type (e.g. fir.array
+    if (auto arrTy = objectTy.dyn_cast<fir::SequenceType>()) {
+      doRewriteSequence(loc);
+      return success();
+    }
+
+    return mlir::emitError(
+        loc, "fir.coordinate_of base operand has unsupported type");
+  }
+
+  unsigned getFieldNumber(fir::RecordType ty, mlir::Value op) const {
+    return fir::hasDynamicSize(ty)
+               ? op.getDefiningOp()
+                     ->getAttrOfType<mlir::IntegerAttr>("field")
+                     .getInt()
+               : getIntValue(op);
+  }
+
+  int64_t getIntValue(mlir::Value val) const {
+    if (val) {
+      if (auto *defop = val.getDefiningOp()) {
+        if (auto constOp = dyn_cast<mlir::arith::ConstantIntOp>(defop))
+          return constOp.value();
+        if (auto llConstOp = dyn_cast<mlir::LLVM::ConstantOp>(defop))
+          if (auto attr = llConstOp.value().dyn_cast<mlir::IntegerAttr>())
+            return attr.getValue().getSExtValue();
+      }
+      fir::emitFatalError(val.getLoc(), "must be a constant");
+    }
+    llvm_unreachable("must not be null value");
+  }
+
+private:
+  void doRewriteBox(fir::CoordinateOp coor, mlir::Type ty,
+                    mlir::ValueRange operands, mlir::Location loc,
+                    mlir::ConversionPatternRewriter &rewriter) const {
+    mlir::Type baseObjectTy = coor.getBaseType();
+    mlir::Value boxBaseAddr = operands[0];
+
+    assert(baseObjectTy.dyn_cast<fir::BoxType>() && "This is not a `fir.box`");
+
+    // 1. SPECIAL CASE (uses `fir.len_param_index`):
+    //   %box = ... : !fir.box<!fir.type<derived{len1:i32}>>
+    //   %lenp = fir.len_param_index len1, !fir.type<derived{len1:i32}>
+    //   %addr = coordinate_of %box, %lenp
+    if (coor.getNumOperands() == 2) {
+      auto *coordinateDef = (*coor.coor().begin()).getDefiningOp();
+      if (isa_and_nonnull<fir::LenParamIndexOp>(coordinateDef)) {
+        // With the coordinate coming from `fir.len_param_index`, we know that
+        // the 2nd operand is a valid byte offset.
+        mlir::Value lenParam = operands[1];
+
+        auto baseAddrAsVoidPtr = rewriter.create<mlir::LLVM::BitcastOp>(
+            loc, voidPtrTy(), boxBaseAddr);
+        auto gep = genGEP(loc, ty, rewriter, baseAddrAsVoidPtr, lenParam);
+        rewriter.replaceOpWithNewOp<mlir::LLVM::BitcastOp>(coor, ty, gep);
+
+        return;
+      }
+    }
+
+    // 2. GENERAL CASE:
+    //   %box = ... : !fix.box<!fir.array<?xU>>
+    //   %idx = ... : index
+    //   %addr = coodinate_of %box, %idx : !fir.ref<U>
+    mlir::Type objectTy = fir::dyn_cast_ptrOrBoxEleTy(baseObjectTy);
+    mlir::Value objectBaseAddr =
+        loadBaseAddrFromBox(loc, getBaseAddrTypeFromBox(boxBaseAddr.getType()),
+                            boxBaseAddr, rewriter);
+    mlir::Type voidPtrTy = ::getVoidPtrType(coor.getContext());
+
+    // `fir.array`
+    if (auto arrTy = objectTy.dyn_cast<fir::SequenceType>()) {
+      unsigned dims = arrTy.getDimension();
+      assert(operands.size() - 1 == dims && "Wrong number of indices");
+      // Applies byte strides from the box. Ignore lower bound from box
+      // since fir.coordinate_of indexes are zero based. Lowering takes care
+      // of lower bound aspects. This both accounts for dynamically sized
+      // types and non contiguous arrays.
+      mlir::Type idxTy = lowerTy().indexType();
+      mlir::Value off = genConstantIndex(loc, idxTy, rewriter, 0);
+      for (unsigned dim = 0; dim < dims; ++dim) {
+        mlir::Value stride = loadStrideFromBox(loc, boxBaseAddr, dim, rewriter);
+        auto sc = rewriter.create<mlir::LLVM::MulOp>(loc, idxTy,
+                                                     operands[1 + dim], stride);
+        off = rewriter.create<mlir::LLVM::AddOp>(loc, idxTy, sc, off);
+      }
+      auto voidPtrBase = rewriter.create<mlir::LLVM::BitcastOp>(loc, voidPtrTy,
+                                                                objectBaseAddr);
+      SmallVector<mlir::Value> args{voidPtrBase, off};
+      objectBaseAddr = rewriter.create<mlir::LLVM::GEPOp>(loc, voidPtrTy, args);
+
+      rewriter.replaceOpWithNewOp<mlir::LLVM::BitcastOp>(coor, ty,
+                                                         objectBaseAddr);
+      return;
+    }
+
+    // `fir.type`
+    if (auto seqTy = objectTy.dyn_cast<fir::RecordType>()) {
+      mlir::LLVM::ConstantOp c0 =
+          genConstantIndex(loc, lowerTy().indexType(), rewriter, 0);
+      for (unsigned i = 1, last = operands.size(); i < last; ++i) {
+        auto seqRefTy =
+            mlir::LLVM::LLVMPointerType::get(lowerTy().convertType(seqTy));
+        auto nxtOpnd = operands[i];
+        auto memObj = rewriter.create<mlir::LLVM::BitcastOp>(loc, seqRefTy,
+                                                             objectBaseAddr);
+        llvm::SmallVector<mlir::Value> args = {memObj, c0, nxtOpnd};
+        objectTy = seqTy.getType(getFieldNumber(seqTy, nxtOpnd));
+        auto llvmCty = lowerTy().convertType(objectTy);
+        auto gep = rewriter.create<mlir::LLVM::GEPOp>(
+            loc, mlir::LLVM::LLVMPointerType::get(llvmCty), args);
+        objectBaseAddr =
+            rewriter.create<mlir::LLVM::BitcastOp>(loc, voidPtrTy, gep);
+      }
+
+      rewriter.replaceOpWithNewOp<mlir::LLVM::BitcastOp>(coor, ty,
+                                                         objectBaseAddr);
+      return;
+    }
+
+    fir::emitFatalError(loc, "unexpected type in coordinate_of");
+  }
+  void doRewriteSequence(mlir::Location loc) const {
+    TODO(loc, "`fir.coordinate_of` codegen for sequence types");
+  }
+};
+
+// ----> DELETEME
+struct LenParamIndexOpConversion
+    : public FIROpConversion<fir::LenParamIndexOp> {
+  using FIROpConversion::FIROpConversion;
+
+  // FIXME: this should be specialized by the runtime target
+  mlir::LogicalResult
+  matchAndRewrite(fir::LenParamIndexOp lenp, OpAdaptor adaptor,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    auto ity = lowerTy().indexType();
+    auto onty = lenp.getOnType();
+    // size of portable descriptor
+    const unsigned boxsize = 24; // FIXME
+    unsigned offset = boxsize;
+    // add the size of the rows of triples
+    if (auto arr = onty.dyn_cast<fir::SequenceType>())
+      offset += 3 * arr.getDimension();
+
+    // advance over some addendum fields
+    const unsigned addendumOffset{sizeof(void *) + sizeof(uint64_t)};
+    offset += addendumOffset;
+    // add the offset into the LENs
+    offset += 0; // FIXME
+    auto attr = rewriter.getI64IntegerAttr(offset);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::ConstantOp>(lenp, ity, attr);
+    return success();
+  }
+};
+// <---- DELETEME
+
 } // namespace
 
 namespace {
 /// Convert FIR dialect to LLVM dialect
 ///
 /// This pass lowers all FIR dialect operations to LLVM IR dialect. An
 /// MLIR pass is used to lower residual Std dialect to LLVM IR dialect.
 ///
void runOnOperation() override final {
     fir::LLVMTypeConverter typeConverter{getModule()};
     mlir::OwningRewritePatternList pattern(context);
     pattern.insert<
         AbsentOpConversion, AddcOpConversion, AddrOfOpConversion,
         AllocaOpConversion, BoxAddrOpConversion, BoxCharLenOpConversion,
         BoxDimsOpConversion, BoxEleSizeOpConversion, BoxIsAllocOpConversion,
         BoxIsArrayOpConversion, BoxIsPtrOpConversion, BoxProcHostOpConversion,
         BoxRankOpConversion, BoxTypeDescOpConversion, CallOpConversion,
+        CoordinateOpConversion, /*DELETEME*/ LenParamIndexOpConversion,
         CmpcOpConversion, ConstcOpConversion, ConvertOpConversion,
         DispatchOpConversion, DispatchTableOpConversion, DTEntryOpConversion,
         DivcOpConversion, EmboxOpConversion, EmboxCharOpConversion,
         EmboxProcOpConversion, ExtractValueOpConversion, FirEndOpConversion,
         HasValueOpConversion, GenTypeDescOpConversion, GlobalLenOpConversion,
         GlobalOpConversion, InsertOnRangeOpConversion, InsertValueOpConversion,
         IsPresentOpConversion, LoadOpConversion, NegcOpConversion,
         MulcOpConversion, SelectCaseOpConversion, SelectOpConversion,

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

 // At the moment these cannot be tested since the `fir.boxproc` type does not have a conversion.
 
 // -----
 
 // Test `fir.end` conversion failure. Not implemented yet.
 
 // expected-error@+1{{failed to legalize operation 'fir.end'}}
 "fir.end"() : () -> ()
+
+// -----
+
+func @bad_coordinate_of(%arg0: !fir.box<!fir.array<1x!fir.char<4,?>>>, %arg1: index) {
+// expected-error@+2{{`fir.coordinate_of` with a dynamic element size is unsupported}}
+// expected-error@+1{{failed to legalize operation 'fir.coordinate_of'}}
+  %p = fir.coordinate_of %arg0, %arg1 : (!fir.box<!fir.array<1x!fir.char<4,?>>>, index) -> !fir.ref<f32>
+  return
+}

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

 // result: (x + x') + i(y + y')
 
 func @fir_complex_add(%a: !fir.complex<16>, %b: !fir.complex<16>) -> !fir.complex<16> {
   %c = fir.addc %a, %b : !fir.complex<16>
   return %c : !fir.complex<16>
 }
 
 // CHECK-LABEL: llvm.func @fir_complex_add(
 // CHECK-SAME:                             %[[ARG0:.*]]: !llvm.struct<(f128, f128)>,
 // CHECK-SAME:                             %[[ARG1:.*]]: !llvm.struct<(f128, f128)>) -> !llvm.struct<(f128, f128)> {
 // CHECK:         %[[X0:.*]] = llvm.extractvalue %[[ARG0]][0 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         %[[Y0:.*]] = llvm.extractvalue %[[ARG0]][1 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         %[[X1:.*]] = llvm.extractvalue %[[ARG1]][0 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         %[[Y1:.*]] = llvm.extractvalue %[[ARG1]][1 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         %[[ADD_X0_X1:.*]] = llvm.fadd %[[X0]], %[[X1]]  : f128
 // CHECK:         %[[ADD_Y0_Y1:.*]] = llvm.fadd %[[Y0]], %[[Y1]]  : f128
 // CHECK:         %{{.*}} = llvm.mlir.undef : !llvm.struct<(f128, f128)>

 // CHECK:         %[[TYPE_CODE_I8:.*]] = llvm.trunc %[[TYPE_CODE]] : i32 to i8
 // CHECK:         %{{.*}} = llvm.insertvalue %[[TYPE_CODE_I8]], %{{.*}}[4 : i32] : !llvm.struct<(ptr<struct<"_QMtest_dinitTtseq", (i32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i{{.*}}>, array<1 x i{{.*}}>)>
 // CHECK:         %[[F18ADDENDUM:.*]] = llvm.mlir.constant(1 : i32) : i32
 // CHECK:         %[[F18ADDENDUM_I8:.*]] = llvm.trunc %[[F18ADDENDUM]] : i32 to i8
 // CHECK:         %{{.*}} = llvm.insertvalue %[[F18ADDENDUM_I8]], %18[6 : i32] : !llvm.struct<(ptr<struct<"_QMtest_dinitTtseq", (i32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i{{.*}}>, array<1 x i{{.*}}>)>
 // CHECK:         %[[TDESC:.*]] = llvm.mlir.addressof @_QMtest_dinitE.dt.tseq : !llvm.ptr<i8>
 // CHECK:         %[[TDESC_CAST:.*]] = llvm.bitcast %22 : !llvm.ptr<i8> to !llvm.ptr<i8>
 // CHECK:         %{{.*}} = llvm.insertvalue %[[TDESC_CAST]], %{{.*}}[7 : i32] : !llvm.struct<(ptr<struct<"_QMtest_dinitTtseq", (i32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i{{.*}}>, array<1 x i{{.*}}>)>
+
+// -----
+
+// Test `fir.coordinate_of` conversion
+
+// 1. COMPLEX TYPE (`fir.complex` is a special case)
+// Complex type wrapped in `fir.ref`
+func @coordinate_ref_complex(%arg0: !fir.ref<!fir.complex<16>>, %arg1: index) {
+  %p = fir.coordinate_of %arg0, %arg1 : (!fir.ref<!fir.complex<16>>, index) -> !fir.ref<f32>
+  return
+}
+// CHECK-LABEL: llvm.func @coordinate_ref_complex
+// CHECK-SAME:  %[[ARG0:.*]]: !llvm.ptr<struct<(f128, f128)>>
+// CHECK-SAME:  %[[COORDINATE:.*]]: i64) {
+// CHECK:    %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64
+// CHECK:    %{{.*}} = llvm.getelementptr %[[ARG0]][%[[C0]], %[[COORDINATE]]] : (!llvm.ptr<struct<(f128, f128)>>, i64, i64) -> !llvm.ptr<f32>
+// CHECK-NEXT:    llvm.return
+
+// Complex type wrapped in `fir.box`
+func @coordinate_box_complex(%arg0: !fir.box<!fir.complex<16>>, %arg1: index) {
+  %p = fir.coordinate_of %arg0, %arg1 : (!fir.box<!fir.complex<16>>, index) -> !fir.ref<f32>
+  return
+}
+// CHECK-LABEL: llvm.func @coordinate_box_complex
+// CHECK-SAME:  %[[BOX:.*]]: !llvm.ptr<struct<(ptr<struct<(f128, f128)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>
+// CHECK-SAME:  %[[COORDINATE:.*]]: i64) {
+// CHECK:    %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64
+// CHECK:    %{{.*}} = llvm.getelementptr %[[BOX]][%[[C0]], %[[COORDINATE]]] : (!llvm.ptr<struct<(ptr<struct<(f128, f128)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>, i64, i64) -> !llvm.ptr<f32>
+// CHECK-NEXT:    llvm.return
+
+// 2. BOX TYPE (objects wrapped in `fir.box`)
+// Derived type - basic case
+func @coordinate_box_derived(%arg0: !fir.box<!fir.type<derived_1{field_1:i32, field_2:i32}>>) {
+  %idx = arith.constant 1 : i32
+  %q = fir.coordinate_of %arg0, %idx : (!fir.box<!fir.type<derived_1{field_1:i32, field_2:i32}>>, i32) -> !fir.ref<i32>
+  return
+}
+// CHECK-LABEL: llvm.func @coordinate_box_derived
+// CHECK-SAME: %[[BOX:.*]]: !llvm.ptr<struct<(ptr<struct<"derived_1", (i32, i32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i8>, array<1 x i64>)>>)
+// CHECK:    %[[COORDINATE:.*]] = llvm.mlir.constant(1 : i32) : i32
+// CHECK:    %[[C0_1:.*]] = llvm.mlir.constant(0 : i32) : i32
+// CHECK:    %[[C0_2:.*]] = llvm.mlir.constant(0 : i32) : i32
+// CHECK:    %[[DERRIVED_ADDR:.*]] = llvm.getelementptr %[[BOX]][%[[C0_1]], %[[C0_2]]] : (!llvm.ptr<struct<(ptr<struct<"derived_1", (i32, i32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i8>, array<1 x i64>)>>, i32, i32) -> !llvm.ptr<ptr<struct<"derived_1", (i32, i32)>>>
+// CHECK:    %[[DERRIVED_VAL:.*]] = llvm.load %[[DERRIVED_ADDR]] : !llvm.ptr<ptr<struct<"derived_1", (i32, i32)>>>
+// CHECK:    %[[C0_3:.*]] = llvm.mlir.constant(0 : i64) : i64
+// FIXME: This cast seems redundant
+// CHECK:    %[[DERRIVED_CAST:.*]] = llvm.bitcast %[[DERRIVED_VAL]] : !llvm.ptr<struct<"derived_1", (i32, i32)>> to !llvm.ptr<struct<"derived_1", (i32, i32)>>
+// CHECK:    %[[SUBOBJECT_ADDR:.*]] = llvm.getelementptr %[[DERRIVED_CAST]][%[[C0_3]], %[[COORDINATE]]] : (!llvm.ptr<struct<"derived_1", (i32, i32)>>, i64, i32) -> !llvm.ptr<i32>
+// FIXMR: These casts seem redundant
+// CHECK:    %[[CAST_1:.*]] = llvm.bitcast %[[SUBOBJECT_ADDR]] : !llvm.ptr<i32> to !llvm.ptr<i8>
+// CHECK:    %{{.*}} = llvm.bitcast %[[CAST_1]] : !llvm.ptr<i8> to !llvm.ptr<i32>
+// CHECK-NEXT:    llvm.return
+
+// Derived type via `fir.len_param_index`
+func @coordinate_box_derived_with_fir_len(%arg0: !fir.box<!fir.type<derived_2{len1:i32}>>) {
+  %e = fir.len_param_index len1, !fir.type<derived_2{len1:i32}>
+  %q = fir.coordinate_of %arg0, %e : (!fir.box<!fir.type<derived_2{len1:i32}>>, !fir.len) -> !fir.ref<i32>
+  return
+}
+// CHECK-LABEL: llvm.func @coordinate_box_derived_with_fir_len
+// CHECK-SAME: %[[ARG0:.*]]: !llvm.ptr<struct<(ptr<struct<"derived_2", (i32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i8>, array<1 x i64>)>>)
+// TODO: Where is 40 coming from?
+// CHECK:    %[[C40:.*]] = llvm.mlir.constant(40 : i64) : i64
+// CHECK:    %[[ARG0_AS_VOID_PTR:.*]] = llvm.bitcast %[[ARG0]] : !llvm.ptr<struct<(ptr<struct<"derived_2", (i32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i8>, array<1 x i64>)>> to !llvm.ptr<i8>
+// CHECK:    %[[SUBOBJECT_ADDR:.*]] = llvm.getelementptr %[[ARG0_AS_VOID_PTR]][%[[C40]]] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i32>
+// FIXME: This cast seems redundant
+// CHECK:    %{{.*}} = llvm.bitcast %[[SUBOBJECT_ADDR]] : !llvm.ptr<i32> to !llvm.ptr<i32>
+// CHECK-NEXT:    llvm.return
+
+// 3. BOX TYPE - `fir.array` wrapped in `fir.box`
+// `fir.array` inside a `fir.box` (1d)
+func @coordinate_box_array_1d(%arg0: !fir.box<!fir.array<10 x f32>>, %arg1: index) {
+  %p = fir.coordinate_of %arg0, %arg1 : (!fir.box<!fir.array<10 x f32>>, index) -> !fir.ref<f32>
+  return
+}
+// CHECK-LABEL: llvm.func @coordinate_box_array_1d
+// CHECK-SAME:  %[[BOX:.*]]: !llvm.ptr<struct<(ptr<array<10 x f32>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>>
+// CHECK-SAME:  %[[COORDINATE:.*]]: i64
+// There's only one box here. It's index is `0`. Generate it.
+// CHECK-NEXT:  %[[BOX_IDX:.*]] = llvm.mlir.constant(0 : i32) : i32
+// CHECK-NEXT:  %[[BOX_1ST_ELEM_IDX:.*]] = llvm.mlir.constant(0 : i32) : i32
+// CHECK-NEXT:  %[[ARRAY_ADDR:.*]] = llvm.getelementptr %[[BOX]][%[[BOX_IDX]], %[[BOX_1ST_ELEM_IDX]]] : (!llvm.ptr<struct<(ptr<array<10 x f32>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>>, i32, i32) -> !llvm.ptr<ptr<array<10 x f32>>>
+// CHECK-NEXT:  %[[ARRAY_OBJECT:.*]] = llvm.load %[[ARRAY_ADDR]] : !llvm.ptr<ptr<array<10 x f32>>>
+// CHECK-NEXT:  %[[OFFSET_INIT:.*]] = llvm.mlir.constant(0 : i64) : i64
+// Same as [[BOX_IDX]], just recreated.
+// CHECK-NEXT:  %[[BOX_IDX_1:.*]] = llvm.mlir.constant(0 : i32) : i32
+// Index of the array that contains the CFI_dim_t objects
+// CHECK-NEXT:  %[[CFI_DIM_IDX:.*]] = llvm.mlir.constant(7 : i32) : i32
+// Index of the 1st CFI_dim_t object (corresonds the the 1st dimension)
+// CHECK-NEXT:  %[[DIM_1_IDX:.*]] = llvm.mlir.constant(0 : i64) : i64
+// Index of the memory stride within a CFI_dim_t object
+// CHECK-NEXT:  %[[DIM_1_MEM_STRIDE:.*]] = llvm.mlir.constant(2 : i32) : i32
+// CHECK-NEXT:  %[[DIM_1_MEM_STRIDE_ADDR:.*]] = llvm.getelementptr %[[BOX]][%[[BOX_IDX_1]], %[[CFI_DIM_IDX]], %[[DIM_1_IDX]], %[[DIM_1_MEM_STRIDE]]] : (!llvm.ptr<struct<(ptr<array<10 x f32>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>>, i32, i32, i64, i32) -> !llvm.ptr<i64>
+// CHECK-NEXT:  %[[DIM_1_MEM_STRIDE_VAL:.*]] = llvm.load %[[DIM_1_MEM_STRIDE_ADDR]] : !llvm.ptr<i64>
+// CHECK-NEXT:  %[[BYTE_OFFSET:.*]] = llvm.mul %[[COORDINATE]], %[[DIM_1_MEM_STRIDE_VAL]]  : i64
+// CHECK-NEXT:  %[[SUBOJECT_OFFSET:.*]] = llvm.add %[[BYTE_OFFSET]], %[[OFFSET_INIT]]  : i64
+// CHECK-NEXT:  %[[ARRAY_ADDR_AS_VOID_PTR:.*]] = llvm.bitcast %[[ARRAY_OBJECT]] : !llvm.ptr<array<10 x f32>> to !llvm.ptr<i8>
+// CHECK-NEXT:  %[[SUBOBJECT_ADDR:.*]] = llvm.getelementptr %[[ARRAY_ADDR_AS_VOID_PTR]][%[[SUBOJECT_OFFSET]]] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
+// CHECK-NEXT:  %[[RETURN_VAL:.*]] = llvm.bitcast %[[SUBOBJECT_ADDR]] : !llvm.ptr<i8> to !llvm.ptr<f32>
+// CHECK-NEXT:  llvm.return
+
+// `fir.array` inside a `fir.box` (2d)
+func @coordinate_box_array_2d(%arg0: !fir.box<!fir.array<10 x 10 x f32>>, %arg1: index, %arg2: index) {
+  %p = fir.coordinate_of %arg0, %arg1, %arg2 : (!fir.box<!fir.array<10 x 10 x f32>>, index, index) -> !fir.ref<f32>
+  return
+}
+// CHECK-LABEL: llvm.func @coordinate_box_array_2d
+// CHECK-SAME: %[[BOX:.*]]: !llvm.ptr<struct<(ptr<array<10 x array<10 x f32>>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)>>
+// CHECK-SAME: %[[COORDINATE_1:.*]]: i64, %[[COORDINATE_2:.*]]: i64)
+// There's only one box here. It's index is `0`. Generate it.
+// CHECK-NEXT:  %[[BOX_IDX:.*]] = llvm.mlir.constant(0 : i32) : i32
+// CHECK-NEXT:  %[[BOX_1ST_ELEM_IDX:.*]] = llvm.mlir.constant(0 : i32) : i32
+// CHECK-NEXT:  %[[ARRAY_ADDR:.*]] = llvm.getelementptr %[[BOX]][%[[BOX_IDX]], %[[BOX_1ST_ELEM_IDX]]] : (!llvm.ptr<struct<(ptr<array<10 x array<10 x f32>>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)>>, i32, i32) -> !llvm.ptr<ptr<array<10 x array<10 x f32>>>>
+// CHECK-NEXT:  %[[ARRAY_OBJECT:.*]] = llvm.load %[[ARRAY_ADDR]] : !llvm.ptr<ptr<array<10 x array<10 x f32>>>>
+// CHECK-NEXT:  %[[OFFSET_INIT:.*]] = llvm.mlir.constant(0 : i64) : i64
+// Same as [[BOX_IDX]], just recreated.
+// CHECK-NEXT:  %[[BOX_IDX_1:.*]] = llvm.mlir.constant(0 : i32) : i32
+// Index of the array that contains the CFI_dim_t objects
+// CHECK-NEXT:  %[[CFI_DIM_IDX:.*]] = llvm.mlir.constant(7 : i32) : i32
+// Index of the 1st CFI_dim_t object (corresonds the the 1st dimension)
+// CHECK-NEXT:  %[[DIM_1_IDX:.*]] = llvm.mlir.constant(0 : i64) : i64
+// Index of the memory stride within a CFI_dim_t object
+// CHECK-NEXT:  %[[DIM_1_MEM_STRIDE:.*]] = llvm.mlir.constant(2 : i32) : i32
+// CHECK-NEXT:  %[[DIM_1_MEM_STRIDE_ADDR:.*]] = llvm.getelementptr %[[BOX]][%[[BOX_IDX_1]], %[[CFI_DIM_IDX]], %[[DIM_1_IDX]], %[[DIM_1_MEM_STRIDE]]] : (!llvm.ptr<struct<(ptr<array<10 x array<10 x f32>>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)>>, i32, i32, i64, i32) -> !llvm.ptr<i64>
+// CHECK-NEXT:  %[[DIM_1_MEM_STRIDE_VAL:.*]] = llvm.load %[[DIM_1_MEM_STRIDE_ADDR]] : !llvm.ptr<i64>
+// CHECK-NEXT:  %[[BYTE_OFFSET_1:.*]] = llvm.mul %[[COORDINATE_1]], %[[DIM_1_MEM_STRIDE_VAL]]  : i64
+// CHECK-NEXT:  %[[SUBOBJECT_OFFSET_1:.*]] = llvm.add %[[BYTE_OFFSET]], %[[OFFSET_INIT]]  : i64
+// Same as [[BOX_IDX]], just recreated.
+// CHECK-NEXT:  %[[BOX_IDX_2:.*]] = llvm.mlir.constant(0 : i32) : i32
+// Index of the array that contains the CFI_dim_t objects (same as CFI_DIM_IDX, just recreated)
+// CHECK-NEXT:  %[[CFI_DIM_IDX_1:.*]] = llvm.mlir.constant(7 : i32) : i32
+// Index of the 1st CFI_dim_t object (corresonds the the 2nd dimension)
+// CHECK-NEXT:  %[[DIM_2_IDX:.*]] = llvm.mlir.constant(1 : i64) : i64
+// Index of the memory stride within a CFI_dim_t object
+// CHECK-NEXT:  %[[DIM_2_MEM_STRIDE:.*]] = llvm.mlir.constant(2 : i32) : i32
+// CHECK-NEXT:  %[[DIM_2_MEM_STRIDE_ADDR:.*]] = llvm.getelementptr %[[BOX]][%[[BOX_IDX_2]], %[[CFI_DIM_IDX_1]], %[[DIM_2_IDX]], %[[DIM_2_MEM_STRIDE]]] : (!llvm.ptr<struct<(ptr<array<10 x array<10 x f32>>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)>>, i32, i32, i64, i32) -> !llvm.ptr<i64>
+// CHECK-NEXT:  %[[DIM_2_MEM_STRIDE_VAL:.*]] = llvm.load %[[DIM_2_MEM_STRIDE_ADDR]] : !llvm.ptr<i64>
+// CHECK-NEXT:  %[[BYTE_OFFSET_2:.*]] = llvm.mul %[[COORDINATE_2]], %[[DIM_2_MEM_STRIDE_VAL]]  : i64
+// CHECK-NEXT:  %[[SUBOBJECT_OFFSET_2:.*]] = llvm.add %[[BYTE_OFFSET_2]], %[[SUBOBJECT_OFFSET_1]]  : i64
+// CHECK-NEXT:  %[[ARRAY_ADDR_AS_VOID_PTR:.*]] = llvm.bitcast %[[ARRAY_OBJECT]] : !llvm.ptr<array<10 x array<10 x f32>>> to !llvm.ptr<i8>
+// CHECK-NEXT:  %[[SUBOBJECT_ADDR:.*]] = llvm.getelementptr %[[ARRAY_ADDR_AS_VOID_PTR]][%[[SUBOBJECT_OFFSET_2]]] : (!llvm.ptr<i8>, i64) -> !llvm.ptr<i8>
+// CHECK-NEXT:  %[[RETURN_VAL:.*]] = llvm.bitcast %[[SUBOBJECT_ADDR]] : !llvm.ptr<i8> to !llvm.ptr<f32>
+// CHECK-NEXT:  llvm.return