[flang][CodeGen] Transform `IsPresentOpConversion` and `AbsentOpConversion`

[awarzynski]

Summary

This patch extends the FIRToLLVMLowering pass in Flang by adding
hooks to transform fir.is_present and fir.absent to the LLVM dialect
of MLIR.

This is part of the upstreaming effort from the fir-dev branch in [1].

[1] https://github.com/flang-compiler/f18-llvm-project

Originally written by:
Co-authored-by: Jean Perier <[e-mail]>
Co-authored-by: Eric Schweitz <[e-mail]>

[clementval]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

25

Why is this suddenly needed? We have been creating LLVM ops until now without this extra include. Also it feels weird to not use quotes here.

218

Fine if you want to update auto usage from fir-dev here. getLoc() is most of the time used with auto even in MLIR code base.

Don't forget to sync back in fir-dev.

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

401

Can you split the test here //----- and update the comment accordingly? They is clearly two different ops tested here.

[awarzynski]

Rebased on top of main, added tests for fir.box, addressed comments from @clementval

flang/lib/Optimizer/CodeGen/CodeGen.cpp

25

It's not, sorry. Must have crept in when I was working on some other thing.

218

Don't forget to sync back in fir-dev.

I've made similar changes elsewhere as well. Let me send them to fie-dev as one bigger patch (to minimise the traffic). Shall I do it once all of the conversions in this file are complete?

[clementval]

LGTM

[clementval]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

218

If they are just typos/auto or stuff like that you can submit them later. If it's smth like rewriting a block of code or refactoring it's good if we don't loos track of the change.

[schweitz]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

210

Should we be writing doxygen comments?

1414

Different version of clang-format?

[awarzynski]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

210

Let me fix that!

1414

Not necessarily. IIRC, clang-format has no hard rules for where to break lines. But I couldn't find a definitive answer.

I use clang-format-13. Pre-commit CI seems happy. Shall we leave it like this?

[awarzynski]

Rebase and make sure that comments are in Doxygen format

[clementval]

LGTM

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1414

Looks fine now.

[schweitz]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1414

Looks like the random whitespace changes disappeared. Good.

Andrzej, we've found that using even slightly different builds of clang-format cause mysterious whitespace changes. It's not about any rule. It just happens.

[PeteSteinfeld]

I use the version of clang-format from llvm release 12, which is the latest released version.

[awarzynski]

In D113395#3124789, @PeteSteinfeld wrote:

I use the version of clang-format from llvm release 12, which is the latest released version.

https://llvm.org/
"4 October 2021: LLVM 13.0.0 is now available for download! "

Time for an update :)

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1414

different builds of clang-format cause mysterious whitespace changes.

I wish that my sight allowed me to spot such discrepancies! :)

flang/lib/Optimizer/CodeGen/CodeGen.cpp

 #include "flang/Optimizer/Dialect/FIROps.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"
 
 /// `fir.box` attribute values as defined for CFI_attribute_t in
 /// flang/ISO_Fortran_binding.h.
 static constexpr unsigned kAttrPointer = CFI_attribute_pointer;
matchAndRewrite(FromOp op, OpAdaptor adaptor,
     return doRewrite(op, ty, adaptor, rewriter);
   }
 
   virtual mlir::LogicalResult
   doRewrite(FromOp addr, mlir::Type ty, OpAdaptor adaptor,
             mlir::ConversionPatternRewriter &rewriter) const = 0;
 };
 
+/// Create value signaling an absent optional argument in a call, e.g.
+/// `fir.absent !fir.ref<i64>` -->  `llvm.mlir.null : !llvm.ptr<i64>`
+struct AbsentOpConversion : public FIROpConversion<fir::AbsentOp> {
+  using FIROpConversion::FIROpConversion;
+
+  mlir::LogicalResult
+  matchAndRewrite(fir::AbsentOp absent, OpAdaptor,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    mlir::Type ty = convertType(absent.getType());
+    mlir::Location loc = absent.getLoc();
+
+    if (absent.getType().isa<fir::BoxCharType>()) {
+      auto structTy = ty.cast<mlir::LLVM::LLVMStructType>();
+      assert(!structTy.isOpaque() && !structTy.getBody().empty());
+      auto undefStruct = rewriter.create<mlir::LLVM::UndefOp>(loc, ty);
+      auto nullField =
+          rewriter.create<mlir::LLVM::NullOp>(loc, structTy.getBody()[0]);
+      mlir::MLIRContext *ctx = absent.getContext();
+      auto c0 = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(0));
+      rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(
+          absent, ty, undefStruct, nullField, c0);
+    } else {
+      rewriter.replaceOpWithNewOp<mlir::LLVM::NullOp>(absent, ty);
+    }
+    return success();
+  }
+};
+
 // Lower `fir.address_of` operation to `llvm.address_of` operation.
 struct AddrOfOpConversion : public FIROpConversion<fir::AddrOfOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::AddrOfOp addr, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto ty = convertType(addr.getType());
matchAndRewrite(fir::NegcOp neg, OpAdaptor adaptor,
     auto nrp = rewriter.create<mlir::LLVM::FNegOp>(loc, eleTy, rp);
     auto nip = rewriter.create<mlir::LLVM::FNegOp>(loc, eleTy, ip);
     auto r = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, o0, nrp, c0);
     rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(neg, ty, r, nip, c1);
     return success();
   }
 };
 
+/// `fir.is_present` -->
+/// ```
+///  %0 = llvm.mlir.constant(0 : i64)
+///  %1 = llvm.ptrtoint %0
+///  %2 = llvm.icmp "ne" %1, %0 : i64
+/// ```
+struct IsPresentOpConversion : public FIROpConversion<fir::IsPresentOp> {
+  using FIROpConversion::FIROpConversion;
+
+  mlir::LogicalResult
+  matchAndRewrite(fir::IsPresentOp isPresent, OpAdaptor adaptor,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    mlir::Type idxTy = lowerTy().indexType();
+    mlir::Location loc = isPresent.getLoc();
+    auto ptr = adaptor.getOperands()[0];
+
+    if (isPresent.val().getType().isa<fir::BoxCharType>()) {
+      auto structTy = ptr.getType().cast<mlir::LLVM::LLVMStructType>();
+      assert(!structTy.isOpaque() && !structTy.getBody().empty());
+
+      mlir::Type ty = structTy.getBody()[0];
+      mlir::MLIRContext *ctx = isPresent.getContext();
+      auto c0 = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(0));
+      ptr = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, ptr, c0);
+    }
+    mlir::LLVM::ConstantOp c0 =
+        genConstantIndex(isPresent.getLoc(), idxTy, rewriter, 0);
+    auto addr = rewriter.create<mlir::LLVM::PtrToIntOp>(loc, idxTy, ptr);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::ICmpOp>(
+        isPresent, mlir::LLVM::ICmpPredicate::ne, addr, c0);
+
+    return success();
+  }
+};
 } // 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.
 ///
 /// This pass is not complete yet. We are upstreaming it in small patches.
 class FIRToLLVMLowering : public fir::FIRToLLVMLoweringBase<FIRToLLVMLowering> {
 public:
   mlir::ModuleOp getModule() { return getOperation(); }
 
   void runOnOperation() override final {
     auto mod = getModule();
     if (!forcedTargetTriple.empty()) {
       fir::setTargetTriple(mod, forcedTargetTriple);
     }
 
     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,
-        SelectCaseOpConversion, SelectOpConversion, SelectRankOpConversion,
-        StoreOpConversion, SubcOpConversion, UndefOpConversion,
-        UnreachableOpConversion, ZeroOpConversion>(typeConverter);
+        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,
+        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/test/Fir/convert-to-llvm.fir

func @fir_complex_add(%a: !fir.complex<16>, %b: !fir.complex<16>) -> !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:         %{{.*}} = llvm.insertvalue %[[ADD_X0_X1]], %{{.*}}[0 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         %{{.*}} = llvm.insertvalue %[[ADD_Y0_Y1]], %{{.*}}[1 : i32] : !llvm.struct<(f128, f128)>
 // CHECK:         llvm.return %{{.*}} : !llvm.struct<(f128, f128)>
 

 // CHECK-LABEL: ^bb2:
 // CHECK:         llvm.br ^bb5
 // CHECK-LABEL: ^bb3:
 // CHECK:         llvm.br ^bb5
 // CHECK-LABEL: ^bb4:
 // CHECK:         llvm.br ^bb5
 // CHECK-LABEL: ^bb5:
 // CHECK:        llvm.return
+
+// -----
+
+// Test `fir.is_present`
+
+func @test_is_present_i64(%arg0: !fir.ref<i64>) -> () {
+  %0 = fir.is_present %arg0 : (!fir.ref<i64>) -> i1
+  return
+}
+
+// CHECK-LABEL: @test_is_present_i64
+// CHECK-SAME: (%[[arg:.*]]: !llvm.ptr<i64>)
+// CHECK-NEXT:  %[[constant:.*]] = llvm.mlir.constant(0 : i64) : i64
+// CHECK-NEXT:  %[[ptr:.*]] = llvm.ptrtoint %[[arg]] : !llvm.ptr<i64> to i64
+// CHECK-NEXT:  %{{.*}} = llvm.icmp "ne" %[[ptr]], %[[constant]] : i64
+// CHECK-NEXT:  llvm.return
+// CHECK-NEXT: }
+
+func @test_is_present_box(%arg0: !fir.box<!fir.ref<i64>>) -> () {
+  %0 = fir.is_present %arg0 : (!fir.box<!fir.ref<i64>>) -> i1
+  return
+}
+
+// CHECK-LABEL: @test_is_present_box
+// CHECK-SAME: (%[[arg:.*]]: !llvm.ptr<struct<(ptr<i64>, i64, i32, i8, i8, i8, i8)>>)
+// CHECK-NEXT: %[[constant:.*]] = llvm.mlir.constant(0 : i64) : i64
+// CHECK-NEXT: %[[ptr:.*]] = llvm.ptrtoint %[[arg]] : !llvm.ptr<struct<(ptr<i64>, i64, i32, i8, i8, i8, i8)>> to i64
+// CHECK-NEXT: %{{.*}} = llvm.icmp "ne" %[[ptr]], %[[constant]] : i64
+// CHECK-NEXT: llvm.return
+// CHECK-NEXT: }
+
+
+// -----
+
+// Test `fir.absent`
+
+func @test_absent_i64() -> () {
+  %0 = fir.absent !fir.ref<i64>
+  return
+}
+
+// CHECK-LABEL: @test_absent_i64
+// CHECK-NEXT:  %{{.*}} = llvm.mlir.null : !llvm.ptr<i64>
+// CHECK-NEXT:  llvm.return
+// CHECK-NEXT:  }
+
+func @test_absent_box() -> () {
+  %0 = fir.absent !fir.box<!fir.array<?xf32>>
+  return
+}
+// CHECK-LABEL: @test_absent_box
+// CHECK-NEXT:  %{{.*}} = llvm.mlir.null : !llvm.ptr<struct<(ptr<f32>, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>>
+// CHECK-NEXT:  llvm.return
+// CHECK-NEXT:  }
+
+// -----
+
+// This is a bit more comprehensive test for `fir.is_present` and `fir.absent`
+// when used together
+
+func @is_present(%arg0: !fir.ref<i64>) -> i1 {
+  %0 = fir.is_present %arg0 : (!fir.ref<i64>) -> i1
+  return %0 : i1
+}
+
+// CHECK-LABEL: @is_present
+// CHECK-SAME: (%[[arg:.*]]: !llvm.ptr<i64>) -> i1
+// CHECK-NEXT:  %[[constant:.*]] = llvm.mlir.constant(0 : i64) : i64
+// CHECK-NEXT:  %[[ptr:.*]] = llvm.ptrtoint %[[arg]] : !llvm.ptr<i64> to i64
+// CHECK-NEXT:  %[[ret_val:.*]] = llvm.icmp "ne" %[[ptr]], %[[constant]] : i64
+// CHECK-NEXT:  llvm.return %[[ret_val]] : i1
+// CHECK-NEXT: }
+
+func @absent() -> i1 {
+  %0 = fir.absent !fir.ref<i64>
+  %1 = fir.call @is_present(%0) : (!fir.ref<i64>) -> i1
+  return %1 : i1
+}
+
+// CHECK-LABEL: @absent
+// CHECK-SAME:  () -> i1
+// CHECK-NEXT:  %[[ptr:.*]] = llvm.mlir.null : !llvm.ptr<i64>
+// CHECK-NEXT:  %[[ret_val:.*]] = llvm.call @is_present(%[[ptr]]) : (!llvm.ptr<i64>) -> i1
+// CHECK-NEXT:  llvm.return %[[ret_val]] : i1