[Flang] Add the FIR LLVMPointer Type

[kiranchandramohan]

Summary

Add a fir.llvm_ptr type to allow any level of indirections

Currently, fir pointer types (fir.ref, fir.ptr, and fir.heap) carry
a special Fortran semantics, and cannot be freely combined/nested.

When implementing some features, lowering sometimes needs more liberty
regarding the number of indirection levels. Add a fir.llvm_ptr that has
no constraints.

Allow its usage in fir.coordinate_op, fir.load, and fir.store.

Convert the FIR LLVMPointer to an LLVMPointer in the LLVM dialect.

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

[clementval]

LG. Thanks Kiran! This was one of the remaining thing to be upstream from the dialect.

flang/lib/Optimizer/Dialect/FIRType.cpp

475

nit: Can we do this with assembly format directly?

[kiranchandramohan]

flang/lib/Optimizer/Dialect/FIRType.cpp

475

I gave this a try but was not successful. It could be because I used it incorrectly or because the support for all types is not yet available. @Mogball ?

Specifically, I made the following change to the definition of the type.

  let parameters = (ins "mlir::Type":$eleTy);

+ let assemblyFormat = "`<` $eleTy `>`";

I got the following errors.

tools/flang/include/flang/Optimizer/Dialect/FIROpsTypes.cpp.inc: In static member function ‘static mlir::Type fir::LLVMPointerType::parse(mlir::AsmParser&)’:
tools/flang/include/flang/Optimizer/Dialect/FIROpsTypes.cpp.inc:569:52: error: incomplete type ‘mlir::FieldParser<mlir::Type>’ used in nested name specifier
  569 |   _result_eleTy = ::mlir::FieldParser<mlir::Type>::parse(parser);
      |                                                    ^~~~~
tools/flang/include/flang/Optimizer/Dialect/FIROpsTypes.cpp.inc:578:29: error: no matching function for call to ‘fir::LLVMPointerType::get(mlir::MLIRContext*, mlir::Type&)’
  578 |     _result_eleTy.getValue());
      |                             ^
tools/flang/include/flang/Optimizer/Dialect/FIROpsTypes.cpp.inc:554:17: note: candidate: ‘static fir::LLVMPointerType fir::LLVMPointerType::get(mlir::Type)’
  554 | LLVMPointerType LLVMPointerType::get(mlir::Type elementType) {

[Mogball]

flang/lib/Optimizer/Dialect/FIRType.cpp

475

I forgot to add a template specialization for Types. Let me get that right now.

475

https://reviews.llvm.org/D113867

[kiranchandramohan]

flang/lib/Optimizer/Dialect/FIRType.cpp

475

Thanks, @Mogball that fixes the fieldparser issue. But I still get one more error about the get Function. Would you know what causes this?

tools/flang/include/flang/Optimizer/Dialect/FIROpsTypes.cpp.inc: In static member function ‘static mlir::Type fir::LLVMPointerType::parse(mlir::AsmParser&)’:
tools/flang/include/flang/Optimizer/Dialect/FIROpsTypes.cpp.inc:578:29: error: no matching function for call to ‘fir::LLVMPointerType::get(mlir::MLIRContext*, mlir::Type&)’
  578 |     _result_eleTy.getValue());
      |                             ^
tools/flang/include/flang/Optimizer/Dialect/FIROpsTypes.cpp.inc:554:17: note: candidate: ‘static fir::LLVMPointerType fir::LLVMPointerType::get(mlir::Type)’
  554 | LLVMPointerType LLVMPointerType::get(mlir::Type elementType) {
      |                 ^~~~~~~~~~~~~~~
tools/flang/include/flang/Optimizer/Dialect/FIROpsTypes.cpp.inc:554:17: note:   candidate expects 1 argument, 2 provided

If I comment out the additional argument (the context) then the error goes away.

[kiranchandramohan]

flang/lib/Optimizer/Dialect/FIRType.cpp

475

Please ignore, I think this is due to the builder being the following,

let builders = [
   TypeBuilderWithInferredContext<(ins "mlir::Type":$elementType), [{
     return Base::get(elementType.getContext(), elementType);
   }]>,
 ];

[kiranchandramohan]

Use the assembly format for creating the printer and parser
for the type.

[kiranchandramohan]

flang/lib/Optimizer/Dialect/FIRType.cpp

475

@clementval Done in flang/include/flang/Optimizer/Dialect/FIRTypes.td.

[clementval]

flang/lib/Optimizer/Dialect/FIRType.cpp

475

Thanks! can you just remove the two functions below before landing this?

[kiranchandramohan]

flang/lib/Optimizer/Dialect/FIRType.cpp

475

The functions below are for the FIR pointer type. I have not added the functions for the FIR LLVM Pointer type.

[clementval]

flang/lib/Optimizer/Dialect/FIRType.cpp

475

Sorry I didn't look correctly.

flang/include/flang/Optimizer/Dialect/FIROps.td

def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]> {
   }];
 
   let arguments = (ins
     AnyRefOrBox:$ref,
     Variadic<AnyCoordinateType>:$coor,
     TypeAttr:$baseType
   );
 
-  let results = (outs fir_ReferenceType);
+  let results = (outs RefOrLLVMPtr);
 
   let parser =  "return parseCoordinateCustom(parser, result);";
   let printer = "::print(p, *this);";
   let verifier = "return ::verify(*this);";
 
   let builders = [
     OpBuilder<(ins "mlir::Type":$resultType,
       "mlir::Value":$ref, "mlir::ValueRange":$coor),

flang/include/flang/Optimizer/Dialect/FIRType.h

 //===-- Optimizer/Dialect/FIRType.h -- FIR types ----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 /// Is `t` any of the Standard dialect types?
 bool isa_std_type(mlir::Type t);
 
 /// Is `t` any of the FIR dialect or Standard dialect types?
 bool isa_fir_or_std_type(mlir::Type t);
 
 /// Is `t` a FIR dialect type that implies a memory (de)reference?
 inline bool isa_ref_type(mlir::Type t) {
-  return t.isa<ReferenceType>() || t.isa<PointerType>() || t.isa<HeapType>();
+  return t.isa<ReferenceType>() || t.isa<PointerType>() || t.isa<HeapType>() ||
+         t.isa<fir::LLVMPointerType>();
 }
 
 /// Is `t` a boxed type?
 inline bool isa_box_type(mlir::Type t) {
   return t.isa<BoxType>() || t.isa<BoxCharType>() || t.isa<BoxProcType>();
 }
 
 /// Is `t` a type that is always trivially pass-by-reference? Specifically, this

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

def fir_LogicalType : FIR_Type<"Logical", "logical"> {
 
   let parameters = (ins "KindTy":$fKind);
 
   let extraClassDeclaration = [{
     using KindTy = unsigned;
   }];
 }
 
+def fir_LLVMPointerType : FIR_Type<"LLVMPointer", "llvm_ptr"> {
+  let summary = "Like LLVM pointer type";
+
+  let description = [{
+    A pointer type that does not have any of the constraints and semantics
+    of other FIR pointer types and that translates to llvm pointer types.
+    It is meant to implement indirection that cannot be expressed directly
+    in Fortran, but are needed to implement some Fortran features (e.g,
+    double indirections).
+  }];
+
+  let parameters = (ins "mlir::Type":$eleTy);
+
+  let assemblyFormat = "`<` $eleTy `>`";
+}
+
 def fir_PointerType : FIR_Type<"Pointer", "ptr"> {
   let summary = "Reference to a POINTER attribute type";
 
   let description = [{
     The type of entities with the POINTER attribute.  These pointers are
     explicitly distinguished to disallow the composition of multiple levels of
     indirection. For example, an ALLOCATABLE POINTER is invalid.
   }];

 // Fortran complex and the latter for C++ std::complex).
 def AnyCompositeLike : TypeConstraint<Or<[fir_RecordType.predicate,
     fir_SequenceType.predicate, fir_ComplexType.predicate, AnyComplex.predicate,
     fir_VectorType.predicate, IsTupleTypePred, fir_CharacterType.predicate]>,
     "any composite">;
 
 // Reference types
 def AnyReferenceLike : TypeConstraint<Or<[fir_ReferenceType.predicate,
-    fir_HeapType.predicate, fir_PointerType.predicate]>, "any reference">;
+    fir_HeapType.predicate, fir_PointerType.predicate,
+    fir_LLVMPointerType.predicate]>, "any reference">;
+
+def RefOrLLVMPtr : TypeConstraint<Or<[fir_ReferenceType.predicate,
+    fir_LLVMPointerType.predicate]>, "fir.ref or fir.llvm_ptr">;
 
 def AnyBoxLike : TypeConstraint<Or<[fir_BoxType.predicate,
     fir_BoxCharType.predicate, fir_BoxProcType.predicate]>, "any box">;
 
 def AnyRefOrBoxLike : TypeConstraint<Or<[AnyReferenceLike.predicate,
     AnyBoxLike.predicate]>,
     "any reference or box like">;
 def AnyRefOrBox : TypeConstraint<Or<[fir_ReferenceType.predicate,

flang/lib/Optimizer/CodeGen/TypeConverter.h

 //===-- TypeConverter.h -- type conversion ----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
LLVMTypeConverter(mlir::ModuleOp module)
     addConversion([&](fir::IntegerType intTy) {
       return mlir::IntegerType::get(
           &getContext(), kindMapping.getIntegerBitsize(intTy.getFKind()));
     });
     addConversion([&](fir::LogicalType boolTy) {
       return mlir::IntegerType::get(
           &getContext(), kindMapping.getLogicalBitsize(boolTy.getFKind()));
     });
+    addConversion([&](fir::LLVMPointerType pointer) {
+      return convertPointerLike(pointer);
+    });
     addConversion(
         [&](fir::PointerType pointer) { return convertPointerLike(pointer); });
     addConversion(
         [&](fir::RecordType derived) { return convertRecordType(derived); });
     addConversion([&](fir::FieldType field) {
       // Convert to i32 because of LLVM GEP indexing restriction.
       return mlir::IntegerType::get(field.getContext(), 32);
     });

flang/lib/Optimizer/Dialect/FIROps.cpp

 //===-- FIROps.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 }
 
 bool fir::ConvertOp::isFloatCompatible(mlir::Type ty) {
   return ty.isa<mlir::FloatType>() || ty.isa<fir::RealType>();
 }
 
 bool fir::ConvertOp::isPointerCompatible(mlir::Type ty) {
   return ty.isa<fir::ReferenceType>() || ty.isa<fir::PointerType>() ||
-         ty.isa<fir::HeapType>() || ty.isa<mlir::MemRefType>() ||
-         ty.isa<mlir::FunctionType>() || ty.isa<fir::TypeDescType>();
+         ty.isa<fir::HeapType>() || ty.isa<fir::LLVMPointerType>() ||
+         ty.isa<mlir::MemRefType>() || ty.isa<mlir::FunctionType>() ||
+         ty.isa<fir::TypeDescType>();
 }
 
 static mlir::LogicalResult verify(fir::ConvertOp &op) {
   auto inType = op.value().getType();
   auto outType = op.getType();
   if (inType == outType)
     return mlir::success();
   if ((op.isPointerCompatible(inType) && op.isPointerCompatible(outType)) ||
void fir::LoadOp::build(mlir::OpBuilder &builder, mlir::OperationState &result,
   if (!eleTy) {
     mlir::emitError(result.location, "not a memory reference type");
     return;
   }
   result.addOperands(refVal);
   result.addTypes(eleTy);
 }
 
-/// Get the element type of a reference like type; otherwise null
-static mlir::Type elementTypeOf(mlir::Type ref) {
-  return llvm::TypeSwitch<mlir::Type, mlir::Type>(ref)
-      .Case<ReferenceType, PointerType, HeapType>(
-          [](auto type) { return type.getEleTy(); })
-      .Default([](mlir::Type) { return mlir::Type{}; });
-}
-
 mlir::ParseResult fir::LoadOp::getElementOf(mlir::Type &ele, mlir::Type ref) {
-  if ((ele = elementTypeOf(ref)))
+  if ((ele = fir::dyn_cast_ptrEleTy(ref)))
     return mlir::success();
   return mlir::failure();
 }
 
 static mlir::ParseResult parseLoadOp(mlir::OpAsmParser &parser,
                                      mlir::OperationState &result) {
   mlir::Type type;
   mlir::OpAsmParser::OperandType oper;

flang/lib/Optimizer/Dialect/FIRType.cpp

 //===-- FIRType.cpp -------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
bool isa_fir_or_std_type(mlir::Type t) {
   if (auto funcType = t.dyn_cast<mlir::FunctionType>())
     return llvm::all_of(funcType.getInputs(), isa_fir_or_std_type) &&
            llvm::all_of(funcType.getResults(), isa_fir_or_std_type);
   return isa_fir_type(t) || isa_std_type(t);
 }
 
 mlir::Type dyn_cast_ptrEleTy(mlir::Type t) {
   return llvm::TypeSwitch<mlir::Type, mlir::Type>(t)
-      .Case<fir::ReferenceType, fir::PointerType, fir::HeapType>(
-          [](auto p) { return p.getEleTy(); })
+      .Case<fir::ReferenceType, fir::PointerType, fir::HeapType,
+            fir::LLVMPointerType>([](auto p) { return p.getEleTy(); })
       .Default([](mlir::Type) { return mlir::Type{}; });
 }
 
 mlir::Type dyn_cast_ptrOrBoxEleTy(mlir::Type t) {
   return llvm::TypeSwitch<mlir::Type, mlir::Type>(t)
-      .Case<fir::ReferenceType, fir::PointerType, fir::HeapType>(
-          [](auto p) { return p.getEleTy(); })
+      .Case<fir::ReferenceType, fir::PointerType, fir::HeapType,
+            fir::LLVMPointerType>([](auto p) { return p.getEleTy(); })
       .Case<fir::BoxType>([](auto p) {
         auto eleTy = p.getEleTy();
         if (auto ty = fir::dyn_cast_ptrEleTy(eleTy))
           return ty;
         return eleTy;
       })
       .Default([](mlir::Type) { return mlir::Type{}; });
 }
mlir::Type fir::LogicalType::parse(mlir::AsmParser &parser) {
   return parseKindSingleton<fir::LogicalType>(parser);
 }
 
 void fir::LogicalType::print(mlir::AsmPrinter &printer) const {
   printer << "<" << getFKind() << '>';
 }
 
 //===----------------------------------------------------------------------===//
 // PointerType
 //===----------------------------------------------------------------------===//
 
 // `ptr` `<` type `>`
 mlir::Type fir::PointerType::parse(mlir::AsmParser &parser) {
   return parseTypeSingleton<fir::PointerType>(parser);
 }
 
 void fir::PointerType::print(mlir::AsmPrinter &printer) const {

 
 //===----------------------------------------------------------------------===//
 // FIROpsDialect
 //===----------------------------------------------------------------------===//
 
 void FIROpsDialect::registerTypes() {
   addTypes<BoxType, BoxCharType, BoxProcType, CharacterType, fir::ComplexType,
            FieldType, HeapType, fir::IntegerType, LenType, LogicalType,
-           PointerType, RealType, RecordType, ReferenceType, SequenceType,
-           ShapeType, ShapeShiftType, ShiftType, SliceType, TypeDescType,
-           fir::VectorType>();
+           LLVMPointerType, PointerType, RealType, RecordType, ReferenceType,
+           SequenceType, ShapeType, ShapeShiftType, ShiftType, SliceType,
+           TypeDescType, fir::VectorType>();
 }

flang/test/Fir/fir-ops.fir

func @slice_substr() {
   %lb = arith.constant 0 : index
   %ub = arith.constant 42 : index
   %c1 = arith.constant 1 : index
   %offset = arith.constant 10 : index
   %0 = fir.slice %lb, %ub, %c1 substr %offset, %c1 : (index, index, index, index, index) -> !fir.slice<1>
   // CHECK: fir.slice %{{.*}}, %{{.*}}, %{{.*}} substr %{{.*}}, %{{.*}} : (index, index, index, index, index) -> !fir.slice<1>
   return
 }
+
+// Test load, store, coordinate_of with llvmptr type
+// CHECK-LABEL: llvm_ptr_load_store_coordinate
+// CHECK-SAME: (%[[ARG0:.*]]: !fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>>, %[[ARG1:.*]]: !fir.ref<!fir.box<!fir.ptr<f32>>>)
+func @llvm_ptr_load_store_coordinate(%arg0: !fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>>, %arg1: !fir.ref<!fir.box<!fir.ptr<f32>>>) -> !fir.ref<!fir.box<!fir.ptr<f32>>> {
+  // CHECK-NEXT: %[[C0:.*]] = arith.constant 0 : i32
+  %c0_i32 = arith.constant 0 : i32
+  // CHECK-NEXT: %[[LLVMPTR:.*]] = fir.coordinate_of %[[ARG0]], %[[C0]] : (!fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>>, i32) -> !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>
+  %0 = fir.coordinate_of %arg0, %c0_i32 : (!fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>>, i32) -> !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>
+  // CHECK-NEXT: fir.store %[[ARG1]] to %[[LLVMPTR]] : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>
+  fir.store %arg1 to %0 : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>
+  // CHECK-NEXT: fir.load %[[LLVMPTR]] : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>
+  %1 = fir.load %0 : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>
+  return %1 : !fir.ref<!fir.box<!fir.ptr<f32>>>
+}

flang/test/Fir/fir-types.fir

 func private @arr6() -> !fir.array<*:f32>
 func private @arr7() -> !fir.array<1x2x?x4x5x6x7x8x9xf32>
 
 // FIR pointer-like types
 // CHECK-LABEL: func private @mem1() -> !fir.ref<i32>
 // CHECK-LABEL: func private @mem2() -> !fir.ptr<i32>
 // CHECK-LABEL: func private @mem3() -> !fir.heap<i32>
 // CHECK-LABEL: func private @mem4() -> !fir.ref<() -> ()>
+// CHECK-LABEL: func private @mem5() -> !fir.llvm_ptr<!fir.ref<f32>>
+// CHECK-LABEL: func private @mem6() -> !fir.llvm_ptr<i8>
 func private @mem1() -> !fir.ref<i32>
 func private @mem2() -> !fir.ptr<i32>
 func private @mem3() -> !fir.heap<i32>
 func private @mem4() -> !fir.ref<() -> ()>
+func private @mem5() -> !fir.llvm_ptr<!fir.ref<f32>>
+func private @mem6() -> !fir.llvm_ptr<i8>
 
 // FIR box types (descriptors)
 // CHECK-LABEL: func private @box1() -> !fir.box<!fir.array<?xf32>>
 // CHECK-LABEL: func private @box2() -> !fir.boxchar<2>
 // CHECK-LABEL: func private @box3() -> !fir.boxproc<(i32, i32) -> i64>
 // CHECK-LABEL: func private @box4() -> !fir.box<none>
 // CHECK-LABEL: func private @box5() -> !fir.box<!fir.type<derived3{f:f32}>>
 func private @box1() -> !fir.box<!fir.array<?xf32>>

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

 // CHECK-SAME: i64
 
 func private @foo4(%arg0: !fir.logical<16>)
 // CHECK-LABEL: foo4
 // CHECK-SAME: i128
 
 // -----
 
+// Test `!fir.llvm_ptr` conversion.
+
+func private @foo0(%arg0: !fir.llvm_ptr<i8>)
+// CHECK-LABEL: foo0
+// CHECK-SAME: !llvm.ptr<i8>
+
+func private @foo1(%arg0: !fir.llvm_ptr<!fir.ref<f32>>)
+// CHECK-LABEL: foo1
+// CHECK-SAME: !llvm.ptr<ptr<f32>>
+
+func private @foo2(%arg0: !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<i32>>>>)
+// CHECK-LABEL: foo2
+// CHECK-SAME: !llvm.ptr<ptr<struct<(ptr<i32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>>
+
+func private @foo3(%arg0: !fir.llvm_ptr<!fir.ptr<f32>>)
+// CHECK-LABEL: foo3
+// CHECK-SAME: !llvm.ptr<ptr<f32>>
+
+// -----
+
 // Test `!fir.complex<KIND>` conversion.
 
 func private @foo0(%arg0: !fir.complex<2>)
 // CHECK-LABEL: foo0
 // CHECK-SAME: !llvm.struct<(f16, f16)>)
 
 func private @foo1(%arg0: !fir.complex<3>)
 // CHECK-LABEL: foo1