[Flang] Notify conversion failure for Proc ops, types

[kiranchandramohan]

Summary

Add the FIR to LLVM conversion patterns for the BoxProcHostOp, EmboxProcOp, and UnboxProcOp ops and the boxproc type. These are currently unimplemented. Implementation will come at a later time when support for Fortran 2003 procedure pointer feature is added.

Co-authored-by: Eric Schweitz <[e-mail]>

[rovka]

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

78 ↗

(On Diff #387194)

Why does this have to be ptr<ptr>? Isn't one level of indirection enough? (Sorry about the ignoramus question)

[kiranchandramohan]

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

78 ↗

(On Diff #387194)

That is a good question. I don't know the exact reason. I guess it is the following.

1. Boxes are always references. I think this is modelled by the outer ptr.
2. The Fortran construct it models is a procedure pointer and this is the inner ptr.

If we consider a function that takes in a procedure pointer as argument, I think in LLVM IR this would require one load to get the value corresponding to the procedure (captured by a procedure pointer) and then an indirect call to call the loaded procedure.

WDYT?

[schweitz]

fir.boxproc most likely needs some more work. I don't think it has been used, so it's more of a placeholder.

It is ultimately intended for creating thunks at runtime to implement function pointers. In Fortran, we can have "normal" function pointers and function pointers that must adjust to the calling context as the callee requires access to the host activation on the stack. The boxproc is an abstraction that lets one bind the function pointer and the pointer to the host's data.

I suspect that the intent was something like ptr<struct<ptr<func>, ptr<host-data>>>.

The codegen to build the thunk using the LLVM trampoline intrinsics (https://llvm.org/docs/LangRef.html#trampoline-intrinsics) should be completed here.

[kiranchandramohan]

The boxproc type and the related operations are not ready. Notify failures for these.

[clementval]

LG

[kiranchandramohan]

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

82

The test is failing here.

I think it is not possible to test unboxproc and boxprochost because they need a value of tupe fir.boxproc. Since the fir.boxproc type is not convertible it is not possible to provide such a value to unboxproc or boxprochost.

Also it seems the conversion is bailing out at the first error, so it is not possible to check multiple errors.

[kiranchandramohan]

Since the boxproc​ type has no conversion, it is not possible to test unboxproc​
and boxproc_host​ ops. Remove tests for these and add a comment.

[kiranchandramohan]

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

78 ↗

(On Diff #387194)

@rovka After further investigation and discussions we decided to notify failures for the boxproc type and the proc based ops. Is the patch OK now?

[rovka]

Yes, LGTM, thanks!

flang/lib/Optimizer/CodeGen/CodeGen.cpp

 //===-- CodeGen.cpp -- bridge to lower to LLVM ----------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
matchAndRewrite(fir::BoxRankOp boxrank, OpAdaptor adaptor,
     auto loc = boxrank.getLoc();
     mlir::Type ty = convertType(boxrank.getType());
     auto result = getValueFromBox(loc, a, ty, rewriter, kRankPosInBox);
     rewriter.replaceOp(boxrank, result);
     return success();
   }
 };
 
+/// Lower `fir.boxproc_host` operation. Extracts the host pointer from the
+/// boxproc.
+/// TODO: Part of supporting Fortran 2003 procedure pointers.
+struct BoxProcHostOpConversion : public FIROpConversion<fir::BoxProcHostOp> {
+  using FIROpConversion::FIROpConversion;
+
+  mlir::LogicalResult
+  matchAndRewrite(fir::BoxProcHostOp boxprochost, OpAdaptor adaptor,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    return rewriter.notifyMatchFailure(
+        boxprochost, "fir.boxproc_host codegen is not implemented yet");
+  }
+};
+
 // `fir.call` -> `llvm.call`
 struct CallOpConversion : public FIROpConversion<fir::CallOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::CallOp call, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     SmallVector<mlir::Type> resultTys;
struct DTEntryOpConversion : public FIROpConversion<fir::DTEntryOp> {
   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.emboxproc` operation. Creates a procedure box.
+/// TODO: Part of supporting Fortran 2003 procedure pointers.
+struct EmboxProcOpConversion : public FIROpConversion<fir::EmboxProcOp> {
+  using FIROpConversion::FIROpConversion;
+
+  mlir::LogicalResult
+  matchAndRewrite(fir::EmboxProcOp emboxproc, OpAdaptor adaptor,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    return rewriter.notifyMatchFailure(
+        emboxproc, "fir.emboxproc 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());
matchAndRewrite(fir::StoreOp store, OpAdaptor adaptor,
     } else {
       rewriter.replaceOpWithNewOp<mlir::LLVM::StoreOp>(
           store, adaptor.getOperands()[0], adaptor.getOperands()[1]);
     }
     return success();
   }
 };
 
+/// Lower `fir.unboxproc` operation. Unbox a procedure box value, yielding its
+/// components.
+/// TODO: Part of supporting Fortran 2003 procedure pointers.
+struct UnboxProcOpConversion : public FIROpConversion<fir::UnboxProcOp> {
+  using FIROpConversion::FIROpConversion;
+
+  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 LLVM IR dialect `undef`
 struct UndefOpConversion : public FIROpConversion<fir::UndefOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::UndefOp undef, OpAdaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<mlir::LLVM::UndefOp>(
void runOnOperation() override final {
 
     auto *context = getModule().getContext();
     fir::LLVMTypeConverter typeConverter{getModule()};
     mlir::OwningRewritePatternList pattern(context);
     pattern.insert<
         AbsentOpConversion, AddcOpConversion, AddrOfOpConversion,
         AllocaOpConversion, BoxAddrOpConversion, BoxDimsOpConversion,
         BoxEleSizeOpConversion, BoxIsAllocOpConversion, BoxIsArrayOpConversion,
-        BoxIsPtrOpConversion, BoxRankOpConversion, CallOpConversion,
-        ConvertOpConversion, DispatchOpConversion, DispatchTableOpConversion,
-        DTEntryOpConversion, DivcOpConversion, ExtractValueOpConversion,
-        HasValueOpConversion, GlobalOpConversion, InsertOnRangeOpConversion,
-        InsertValueOpConversion, IsPresentOpConversion, LoadOpConversion,
-        NegcOpConversion, MulcOpConversion, SelectCaseOpConversion,
-        SelectOpConversion, SelectRankOpConversion, StoreOpConversion,
-        SubcOpConversion, UndefOpConversion, UnreachableOpConversion,
+        BoxIsPtrOpConversion, BoxProcHostOpConversion, BoxRankOpConversion,
+        CallOpConversion, ConvertOpConversion, DispatchOpConversion,
+        DispatchTableOpConversion, DTEntryOpConversion, DivcOpConversion,
+        EmboxProcOpConversion, ExtractValueOpConversion, HasValueOpConversion,
+        GlobalOpConversion, InsertOnRangeOpConversion, InsertValueOpConversion,
+        IsPresentOpConversion, LoadOpConversion, NegcOpConversion,
+        MulcOpConversion, SelectCaseOpConversion, SelectOpConversion,
+        SelectRankOpConversion, StoreOpConversion, SubcOpConversion,
+        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

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)
     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([&](BoxCharType boxchar) {
       LLVM_DEBUG(llvm::dbgs() << "type convert: " << boxchar << '\n');
       return convertType(specifics->boxcharMemoryType(boxchar.getEleTy()));
     });
+    addConversion([&](BoxProcType boxproc) {
+      // TODO: Support for this type will be added later when the Fortran 2003
+      // procedure pointer feature is implemented.
+      return llvm::None;
+    });
     addConversion(
         [&](fir::CharacterType charTy) { return convertCharType(charTy); });
     addConversion([&](HeapType heap) { return convertPointerLike(heap); });
     addConversion([&](fir::IntegerType intTy) {
       return mlir::IntegerType::get(
           &getContext(), kindMapping.getIntegerBitsize(intTy.getFKind()));
     });
     addConversion([&](fir::LogicalType boolTy) {

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

^bb1:
   %c1_i32 = arith.constant 1 : i32
   br ^bb3
 ^bb2:
   %c2_i32 = arith.constant 2 : i32
   br ^bb3
 ^bb3:
   return
 }
+
+// -----
+
+// Test that the type `fir.boxproc` fails to be legalized.
+// Not implemented yet.
+
+// expected-error@+1{{failed to legalize operation 'builtin.func'}}
+func private @foo0(%arg0: !fir.boxproc<() -> ()>)
+
+// -----
+
+// Test that `fir.emboxproc` fails to be legalized.
+// Not implemented yet.
+
+func private @method_impl(i32)
+
+func @emboxproc_test() {
+  %host_vars = fir.alloca tuple<i32,f64>
+// expected-error@+1{{failed to legalize operation 'fir.emboxproc'}}
+  %bproc = fir.emboxproc @method_impl, %host_vars : ((i32) -> (), !fir.ref<tuple<i32,f64>>) -> !fir.boxproc<(i32) -> ()>
+  return
+}
+
+// -----
+
+// Test that `fir.unboxproc` fails to be legalized.
+// Not implemented yet.
+
+func @unboxproc_test() {
+  %bproc = fir.call @get_bproc() : () -> (!fir.boxproc<(i32) -> ()>)
+// expected-error@+1{{failed to legalize operation 'fir.unboxproc'}}
+  %ubproc:2 = fir.unboxproc %bproc : (!fir.boxproc<(i32) -> ()>) -> ((i32) -> (), !fir.ref<tuple<i32,f64>>)
+  return
+}
+
+// -----
+
+// Test that `fir.boxproc_host` fails to be legalized.
+// Not implemented yet.
+
+func @boxproc_host_test() {
+  %bproc = fir.call @get_bproc() : () -> (!fir.boxproc<(i32) -> ()>)
+// expected-error@+1{{failed to legalize operation 'fir.boxproc_host'}}
+  %host_tuple = fir.boxproc_host %bproc : (!fir.boxproc<(i32) -> ()>) -> (!fir.ref<tuple<i32,f64>>)
+  return
+}