[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

2316

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

2168

Nit: use NotifyMatchfailure

2194

Nit: Notifymatch failure

2292

Nit: remove auto?

2297

Nit: remove auto?

[clementval]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

26

Is this include needed? Can you use "?

200

Replace 0 with kAddrPosInBox

237–239

2159

2188

2234

[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.

200

Thanks!

237–239

Thanks!

2168

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

2165

Are we adding backquotes to error messages now? Why?

[awarzynski]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

2165

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

71

Is this actually used?

2249

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.

2296

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

1626

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

1634

1635

1638

1640

1654

1685

[awarzynski]

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

[awarzynski]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

71

Nope. Good catch, thanks!

2249

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

2296

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

2249

Please take a look again.

[rovka]

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

1668

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

1668

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

2326

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

2326

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

[awarzynski]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

2326

@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

2326

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

2326

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

2326

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

2315

Can you fix the clang-format here?

2336

format

[rovka]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

2294

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

2314

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

2294

Let me just mix 2.3 and 2.4 then.

2314

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.

2315

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

2328

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

1665

[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

1714

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

1714

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"
 
 #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, {kAddrPosInBox});
+  }
+
   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 {
+    using ConstOp = typename mlir::LLVM::ConstantOp;
+
+    mlir::Type idxTy = lowerTy().indexType();
+    ConstOp c0 = genConstantOffset(loc, rewriter, 0);
+    ConstOp cDimsIdx = genConstantOffset(loc, rewriter, kDimsPosInBox);
+    ConstOp dimValue = genConstantIndex(loc, idxTy, rewriter, dim);
+
+    return loadFromOffset(loc, box, c0, cDimsIdx, dimValue, kStridePosInDim,
+                          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 FieldIndexOpConversion : public FIROpConversion<fir::FieldIndexOp> {
 
   // NB: most field references should be resolved by this point
   mlir::LogicalResult
   matchAndRewrite(fir::FieldIndexOp field, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto recTy = field.on_type().cast<fir::RecordType>();
     unsigned index = recTy.getFieldIndex(field.field_id());
 
     if (!fir::hasDynamicSize(recTy)) {
       // Derived type has compile-time constant layout. Return index of the
       // component type in the parent type (to be used in GEP).
       rewriter.replaceOp(field, mlir::ValueRange{genConstantOffset(
                                     field.getLoc(), rewriter, index)});
       return success();
     }
 
     // Derived type has compile-time constant layout. Call the compiler
     // generated function to determine the byte offset of the field at runtime.
     // This returns a non-constant.
     FlatSymbolRefAttr symAttr = mlir::SymbolRefAttr::get(
         field.getContext(), getOffsetMethodName(recTy, field.field_id()));
     NamedAttribute callAttr = rewriter.getNamedAttr("callee", symAttr);
     NamedAttribute fieldAttr = rewriter.getNamedAttr(
         "field", mlir::IntegerAttr::get(lowerTy().indexType(), index));
     rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(
         field, lowerTy().offsetType(), adaptor.getOperands(),
         llvm::ArrayRef<mlir::NamedAttribute>{callAttr, fieldAttr});
     return success();
   }
 
   // Re-Construct the name of the compiler generated method that calculates the
   // offset
   inline static std::string getOffsetMethodName(fir::RecordType recTy,
                                                 llvm::StringRef field) {
     return recTy.getName().str() + "P." + field.str() + ".offset";
   }
 };
 
+/// 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 {
+    mlir::ValueRange 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 rewriter.notifyMatchFailure(
+          coor,
+          "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 rewriter.notifyMatchFailure(
+        coor, "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 boxObjTy = coor.getBaseType();
+    assert(boxObjTy.dyn_cast<fir::BoxType>() && "This is not a `fir.box`");
+
+    mlir::Value boxBaseAddr = operands[0];
+
+    // 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) {
+      mlir::Operation *coordinateDef = (*coor.coor().begin()).getDefiningOp();
+      if (isa_and_nonnull<fir::LenParamIndexOp>(coordinateDef)) {
+        TODO(loc,
+             "fir.coordinate_of - fir.len_param_index is not supported yet");
+      }
+    }
+
+    // 2. GENERAL CASE:
+    //   %box = ... : !fix.box<!fir.array<?xU>>
+    //   %idx = ... : index
+    //   %addr = coodinate_of %box, %idx : !fir.ref<U>
+    mlir::Type boxedObjTy = fir::dyn_cast_ptrOrBoxEleTy(boxObjTy);
+    mlir::Value objectBaseAddr =
+        loadBaseAddrFromBox(loc, getBaseAddrTypeFromBox(boxBaseAddr.getType()),
+                            boxBaseAddr, rewriter);
+    mlir::Type voidPtrTy = ::getVoidPtrType(coor.getContext());
+
+    // `fir.array`
+    if (auto arrTy = boxedObjTy.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 = boxedObjTy.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));
+        mlir::Value nxtOpnd = operands[i];
+        auto memObj = rewriter.create<mlir::LLVM::BitcastOp>(loc, seqRefTy,
+                                                             objectBaseAddr);
+        llvm::SmallVector<mlir::Value> args = {memObj, c0, nxtOpnd};
+        mlir::Type eleTy = seqTy.getType(getFieldNumber(seqTy, nxtOpnd));
+        mlir::Type llvmEleTy = lowerTy().convertType(eleTy);
+        auto gep = rewriter.create<mlir::LLVM::GEPOp>(
+            loc, mlir::LLVM::LLVMPointerType::get(llvmEleTy), 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");
+  }
+};
+
 } // 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 {
     mlir::OwningRewritePatternList pattern(context);
     pattern.insert<
         AbsentOpConversion, AddcOpConversion, AddrOfOpConversion,
         AllocaOpConversion, BoxAddrOpConversion, BoxCharLenOpConversion,
         BoxDimsOpConversion, BoxEleSizeOpConversion, BoxIsAllocOpConversion,
         BoxIsArrayOpConversion, BoxIsPtrOpConversion, BoxProcHostOpConversion,
         BoxRankOpConversion, BoxTypeDescOpConversion, CallOpConversion,
         CmpcOpConversion, ConstcOpConversion, ConvertOpConversion,
-        DispatchOpConversion, DispatchTableOpConversion, DTEntryOpConversion,
-        DivcOpConversion, EmboxOpConversion, EmboxCharOpConversion,
-        EmboxProcOpConversion, ExtractValueOpConversion, FieldIndexOpConversion,
-        FirEndOpConversion, HasValueOpConversion, GenTypeDescOpConversion,
-        GlobalLenOpConversion, GlobalOpConversion, InsertOnRangeOpConversion,
-        InsertValueOpConversion, IsPresentOpConversion,
-        LenParamIndexOpConversion, LoadOpConversion, NegcOpConversion,
-        NoReassocOpConversion, MulcOpConversion, SelectCaseOpConversion,
-        SelectOpConversion, SelectRankOpConversion, SelectTypeOpConversion,
-        ShapeOpConversion, ShapeShiftOpConversion, ShiftOpConversion,
-        SliceOpConversion, StoreOpConversion, StringLitOpConversion,
-        SubcOpConversion, UnboxCharOpConversion, UnboxProcOpConversion,
-        UndefOpConversion, UnreachableOpConversion, ZeroOpConversion>(
-        typeConverter);
+        CoordinateOpConversion, DispatchOpConversion, DispatchTableOpConversion,
+        DTEntryOpConversion, DivcOpConversion, EmboxOpConversion,
+        EmboxCharOpConversion, EmboxProcOpConversion, ExtractValueOpConversion,
+        FieldIndexOpConversion, FirEndOpConversion, HasValueOpConversion,
+        GenTypeDescOpConversion, GlobalLenOpConversion, GlobalOpConversion,
+        InsertOnRangeOpConversion, InsertValueOpConversion,
+        IsPresentOpConversion, LenParamIndexOpConversion, LoadOpConversion,
+        NegcOpConversion, NoReassocOpConversion, MulcOpConversion,
+        SelectCaseOpConversion, SelectOpConversion, SelectRankOpConversion,
+        SelectTypeOpConversion, ShapeOpConversion, ShapeShiftOpConversion,
+        ShiftOpConversion, SliceOpConversion, StoreOpConversion,
+        StringLitOpConversion, SubcOpConversion, UnboxCharOpConversion,
+        UnboxProcOpConversion, UndefOpConversion, UnreachableOpConversion,
+        ZeroOpConversion>(typeConverter);
     mlir::populateStdToLLVMConversionPatterns(typeConverter, pattern);
     mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter,
                                                             pattern);
     mlir::ConversionTarget target{*context};
     target.addLegalDialect<mlir::LLVM::LLVMDialect>();
 
     // required NOPs for applying a full conversion
     target.addLegalOp<mlir::ModuleOp>();

flang/lib/Optimizer/CodeGen/TypeConverter.h

 static constexpr unsigned kAddrPosInBox = 0;
 static constexpr unsigned kElemLenPosInBox = 1;
 static constexpr unsigned kVersionPosInBox = 2;
 static constexpr unsigned kRankPosInBox = 3;
 static constexpr unsigned kTypePosInBox = 4;
 static constexpr unsigned kAttributePosInBox = 5;
 static constexpr unsigned kF18AddendumPosInBox = 6;
 static constexpr unsigned kDimsPosInBox = 7;
+static constexpr unsigned kStridePosInDim = 2;
 static constexpr unsigned kOptTypePtrPosInBox = 8;
 static constexpr unsigned kOptRowTypePosInBox = 9;
 
 namespace fir {
 
 /// FIR type converter
 /// This converts FIR types to LLVM types (for now)
 class LLVMTypeConverter : public mlir::LLVMTypeConverter {

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@+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
+}
+
+// -----
+
+// Derived type via `fir.len_param_index`. As `fir.len_param_index` is not
+// implemented yet, that's the error that's currently being generated (this
+// error is generated before trying to convert `fir.coordinate_of`)
+func @coordinate_box_derived_with_fir_len(%arg0: !fir.box<!fir.type<derived_2{len1:i32}>>) {
+// expected-error@+1{{failed to legalize operation 'fir.len_param_index'}}
+  %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
+}

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-LABEL: llvm.func @no_reassoc(
 // CHECK-SAME:                        %[[ARG0:.*]]: !llvm.ptr<i32>) {
 // CHECK:         %[[C1:.*]] = llvm.mlir.constant(1 : i64) : i64
 // CHECK:         %[[ALLOC:.*]] = llvm.alloca %[[C1]] x i32 {in_type = i32, operand_segment_sizes = dense<0> : vector<2xi32>} : (i64) -> !llvm.ptr<i32>
 // CHECK:         %[[LOAD:.*]] = llvm.load %[[ARG0]] : !llvm.ptr<i32>
 // CHECK:         llvm.store %[[LOAD]], %[[ALLOC]] : !llvm.ptr<i32>
 // CHECK:         llvm.return
+
+// -----
+
+// 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
+
+// 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