[fir] Add placeholder conversion pattern for disptach operations

[clementval]

Summary

fir.dispatch, fir.dispatch_table and fir.dt_entry are operations
for type-bound procedures. This patch just adds placeholder conversion
pattern that currently fails since F2003 is not implemented yet.

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

[kiranchandramohan]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

563

Micro Nit: Lower of -> Lower
or
Lowering of

Similarly for others.

[awarzynski]

Shall I do the same for fir.end? https://reviews.llvm.org/D113295

flang/lib/Optimizer/CodeGen/CodeGen.cpp

565

[nit] IMO, it would be helpful to mention F2003 in the notifyMatchFailure call. In fact, this comment can be replaced with with the message in notifyMatchFailure. That would be my preference. We tend to forget to update comments. Code forces us to update itself.

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

26

How about a diagnostic check for fir.dt_entry?

[clementval]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

565

I just removed the todo. I prefer not adding the Fortran standard in the op since it can conver several standard version. I think message not implemented yet is enough.

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

26

Not possible since fir.dt_entry cannot be standalone.

[clementval]

In D113662#3124167, @awarzynski wrote:

Shall I do the same for fir.end? https://reviews.llvm.org/D113295

I didn't really follow the fir.end discussion but my intuition is that fir.end is probably converted together with its parent operation.

[clementval]

Rebase

[awarzynski]

In D113662#3124234, @clementval wrote:

I didn't really follow the fir.end discussion but my intuition is that fir.end is probably converted together with its parent operation.

That's not what I saw in my experiments. Perhaps that's what we should aim for or something that we still need to port from fir-dev? Time will tell!

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

26

See https://reviews.llvm.org/D113665 ;-)

[clementval]

In D113662#3124276, @awarzynski wrote:

In D113662#3124234, @clementval wrote:

I didn't really follow the fir.end discussion but my intuition is that fir.end is probably converted together with its parent operation.

That's not what I saw in my experiments. Perhaps that's what we should aim for or something that we still need to port from fir-dev? Time will tell!

Of course since the parent operations are not converted yet.

flang/lib/Optimizer/CodeGen/CodeGen.cpp

if (isFloatingPointTy(fromTy)) {
         rewriter.replaceOpWithNewOp<mlir::LLVM::BitcastOp>(convert, toTy, op0);
         return mlir::success();
       }
     }
     return emitError(loc) << "cannot convert " << fromTy << " to " << toTy;
   }
 };
 
+/// Lower `fir.dispatch` operation. A virtual call to a method in a dispatch
+/// table.
+struct DispatchOpConversion : public FIROpConversion<fir::DispatchOp> {
+  using FIROpConversion::FIROpConversion;
+
+  mlir::LogicalResult
+  matchAndRewrite(fir::DispatchOp dispatch, OpAdaptor adaptor,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    return rewriter.notifyMatchFailure(
+        dispatch, "fir.dispatch codegen is not implemented yet");
+  }
+};
+
+/// Lower `fir.dispatch_table` operation. The dispatch table for a Fortran
+/// derived type.
+struct DispatchTableOpConversion
+    : public FIROpConversion<fir::DispatchTableOp> {
+  using FIROpConversion::FIROpConversion;
+
+  mlir::LogicalResult
+  matchAndRewrite(fir::DispatchTableOp dispTab, OpAdaptor adaptor,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    return rewriter.notifyMatchFailure(
+        dispTab, "fir.dispatch_table codegen is not implemented yet");
+  }
+};
+
+/// Lower `fir.dt_entry` operation. An entry in a dispatch table; binds a
+/// method-name to a function.
+struct DTEntryOpConversion : public FIROpConversion<fir::DTEntryOp> {
+  using FIROpConversion::FIROpConversion;
+
+  mlir::LogicalResult
+  matchAndRewrite(fir::DTEntryOp dtEnt, OpAdaptor adaptor,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    return rewriter.notifyMatchFailure(
+        dtEnt, "fir.dt_entry codegen is not implemented yet");
+  }
+};
+
 /// Lower `fir.has_value` operation to `llvm.return` operation.
 struct HasValueOpConversion : public FIROpConversion<fir::HasValueOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::HasValueOp op, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, adaptor.getOperands());
void runOnOperation() override final {
     auto *context = getModule().getContext();
     fir::LLVMTypeConverter typeConverter{getModule()};
     mlir::OwningRewritePatternList pattern(context);
     pattern.insert<
         AddcOpConversion, AddrOfOpConversion, AllocaOpConversion,
         BoxAddrOpConversion, BoxDimsOpConversion, BoxEleSizeOpConversion,
         BoxIsAllocOpConversion, BoxIsArrayOpConversion, BoxIsPtrOpConversion,
         BoxRankOpConversion, CallOpConversion, ConvertOpConversion,
+        DispatchOpConversion, DispatchTableOpConversion, DTEntryOpConversion,
         DivcOpConversion, ExtractValueOpConversion, HasValueOpConversion,
         GlobalOpConversion, InsertOnRangeOpConversion, InsertValueOpConversion,
         LoadOpConversion, NegcOpConversion, MulcOpConversion,
         SelectOpConversion, SelectRankOpConversion, StoreOpConversion,
         SubcOpConversion, UndefOpConversion, UnreachableOpConversion,
         ZeroOpConversion>(typeConverter);
     mlir::populateStdToLLVMConversionPatterns(typeConverter, pattern);
     mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter,

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

 // Test FIR to LLVM IR conversion invalid cases and diagnostics.
 
 // RUN: fir-opt --split-input-file --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" --verify-diagnostics %s
 
 func @zero_aggregate() {
   // expected-error@+1{{failed to legalize operation 'fir.zero_bits'}}
   %a = fir.zero_bits !fir.array<10xf32>
   return
 }
 
+// -----
+
+// Test that `fir.dispatch` fails to be legalized. Not implemented yet.
+
+func @dispatch(%arg0: !fir.box<!fir.type<derived3{f:f32}>>) {
+  // expected-error@+1{{failed to legalize operation 'fir.dispatch'}}
+  %0 = fir.dispatch "method"(%arg0) : (!fir.box<!fir.type<derived3{f:f32}>>) -> i32
+  return
+}
+
+// -----
+
+// Test that `fir.dispatch_table`/`fir.dt_entry` fails to be legalized.
+// Not implemented yet.
+
+// expected-error@+1{{failed to legalize operation 'fir.dispatch_table'}}
+fir.dispatch_table @dispatch_tbl {
+  fir.dt_entry "method", @method_impl
+}