[fir] Add fir.box type conversion

[clementval]

Summary

This patch add the !fir.box type conversion to llvm.
fir.box is converted to the descriptor as defined in the ISO_Fortran_binding.h
and the addendum defined in descriptor.h.

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

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/TypeConverter.h

75

78

Looking at https://github.com/llvm/llvm-project/blob/main/flang/include/flang/ISO_Fortran_binding.h#L125-L139, I think that this is incorrect/out-of-date. My suggestion is based on the current implementation in ISO_Fortran_binding.h.

79

or boxTypeParts or anything a bit more descriptive, pls

96

IIUC, everything that follows L96 sets up [dims], right? Definitely worth adding a comment.

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

31

Same suggestion for CHECK-LABEL/CHECK-SAME as in https://reviews.llvm.org/D113283

34

IIUC, we won't be able to check the actual type of i{{.*}} until https://bugs.llvm.org/show_bug.cgi?id=52418 is resolved. Could you add a comment?

[clementval]

Address review comments

[clementval]

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

34

These tests are meant to be target agnostic in this form. We will probably add new check lines with specific prefix when we will check these types.

[awarzynski]

LGTM, thank you for addressing my comments!

flang/lib/Optimizer/CodeGen/TypeConverter.h

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

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

 
 // Test reference types `!fir.ref`
 
 func private @foo0(%arg0: !fir.ref<i32>)
 // CHECK: !llvm.ptr<i32>
 func private @foo1(%arg0: !fir.ref<!fir.array<10xf32>>)
 // CHECK: !llvm.ptr<array<10 x f32>>
 
+// -----
+
+// Test box types `!fir.box`
+
+func private @foo0(%arg0: !fir.box<!fir.array<?xf32>>)
+// CHECK: !llvm.ptr<struct<(ptr<f32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i{{.*}}>>)>>
+
+func private @foo1(%arg0: !fir.box<!fir.array<10xf32>>)
+// CHECK: !llvm.ptr<struct<(ptr<array<10 x f32>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i{{.*}}>>)>>
+
+func private @foo2(%arg0: !fir.box<!fir.ref<i64>>)
+// CHECK: !llvm.ptr<struct<(ptr<i64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>
+
+func private @foo3(%arg0: !fir.box<!fir.type<derived{f:f32}>>)
+// CHECK: !llvm.ptr<struct<(ptr<struct<"derived", (f32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i{{.*}}>, array<1 x i{{.*}}>)>>