[fir] Add fir.box_isarray, fir.box_isptr and fir.box_isalloc conversion.

[clementval]

Summary

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

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

[awarzynski]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

34–35

Why not use the macro directly?

289

[clementval]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

34–35

fir.box is an abstraction of a descriptor also we can get a compile time error in case the macro is not a uint.

[clementval]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

34–35

also it makes it homogenous with the fir.box field indexing added previously so the code is maybe easier to understand.

[awarzynski]

Makes sense, left a few minor comments/nits.

flang/lib/Optimizer/CodeGen/CodeGen.cpp

33

i.e. CFI_attribute_t?

34–35

we can get a compile time error in case the macro is not a uint

Any idea why wouldn't the original value be define as uint? That would make it easier for you here.

also it makes it homogenous with the fir.box field indexing added previously so the code is maybe easier to understand.

Agreed, this does help a lot!

I think that you are doing a great job and a massive favour to all of us here. I'm just thinking that perhaps stuff from "flang/ISO_Fortran_binding.h" should be wrapped in an enum class or something similar? Basically, sth to facilitate code re-use a bit better. WDYT?

125–127

DOXYGENME

IMHO, this comment is a bit unclear. How about:

Creates a sequence of instructions to load the box attribute from \p box and to check it against  \p maskValue. The final check is implemented as `(attribute && maskValue) != 0`.

Or something similar?

270–271

[nit] This is the case just now, but might not be in the future. Also, the two implementations are independent (i.e. there's no code re-use). So I would delete this. Only the first sentence is key.

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

769

[nit] Perhaps add that it will load the rank and comparer it against 0?

788

[nit] Perhaps add that it will load the attribute and check it against the mask corresponding to CFI_attribute_allocatable?

799

Make this platform agnostic?

809

[nit] Perhaps add that it will load the attribute and check it against the mask corresponding to CFI_attribute_pointer?

820

Make this platform agnostic?

[clementval]

Address comments

[awarzynski]

LGTM, thank you for addressing my comments!

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

790

813

[clementval]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

34–35

we can get a compile time error in case the macro is not a uint

Any idea why wouldn't the original value be define as uint? That would make it easier for you here.

Who knows what people can do.

also it makes it homogenous with the fir.box field indexing added previously so the code is maybe easier to understand.

Agreed, this does help a lot!

I think that you are doing a great job and a massive favour to all of us here. I'm just thinking that perhaps stuff from "flang/ISO_Fortran_binding.h" should be wrapped in an enum class or something similar? Basically, sth to facilitate code re-use a bit better. WDYT?

This could be an improvement but it's not something that's in the scope of this patch and will likely require some effort in fir-dev first.

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
 //
 //===----------------------------------------------------------------------===//
 //
 // Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Optimizer/CodeGen/CodeGen.h"
 #include "PassDetail.h"
+#include "flang/ISO_Fortran_binding.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Support/FIRContext.h"
 #include "mlir/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.h"
 #include "mlir/Conversion/LLVMCommon/Pattern.h"
 #include "mlir/Conversion/LLVMCommon/TypeConverter.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 in flang/ISO_Fortran_binding.h.
+static constexpr unsigned kAttrPointer = CFI_attribute_pointer;
+static constexpr unsigned kAttrAllocatable = CFI_attribute_allocatable;
+
 namespace {
 /// FIR conversion pattern template
 template <typename FromOp>
 class FIROpConversion : public mlir::ConvertOpToLLVMPattern<FromOp> {
 public:
   explicit FIROpConversion(fir::LLVMTypeConverter &lowering)
       : mlir::ConvertOpToLLVMPattern<FromOp>(lowering) {}
 
 protected:
   mlir::Type convertType(mlir::Type ty) const {
     return lowerTy().convertType(ty);
   }
 
   mlir::LLVM::ConstantOp
   genConstantOffset(mlir::Location loc,
                     mlir::ConversionPatternRewriter &rewriter,
                     int offset) const {
     auto ity = lowerTy().offsetType();
     auto cattr = rewriter.getI32IntegerAttr(offset);
     return rewriter.create<mlir::LLVM::ConstantOp>(loc, ity, cattr);
   }
 
-  /// Construct code sequence to get the rank from a box.
-  mlir::Value getRankFromBox(mlir::Location loc, mlir::Value box,
+  /// Construct code sequence to extract the specifc value from a `fir.box`.
+  mlir::Value getValueFromBox(mlir::Location loc, mlir::Value box,
                               mlir::Type resultTy,
-                             mlir::ConversionPatternRewriter &rewriter) const {
+                              mlir::ConversionPatternRewriter &rewriter,
+                              unsigned boxValue) const {
     mlir::LLVM::ConstantOp c0 = genConstantOffset(loc, rewriter, 0);
-    mlir::LLVM::ConstantOp cRank =
-        genConstantOffset(loc, rewriter, kRankPosInBox);
+    mlir::LLVM::ConstantOp cValuePos =
+        genConstantOffset(loc, rewriter, boxValue);
     auto pty = mlir::LLVM::LLVMPointerType::get(resultTy);
     auto p = rewriter.create<mlir::LLVM::GEPOp>(
-        loc, pty, mlir::ValueRange{box, c0, cRank});
+        loc, pty, mlir::ValueRange{box, c0, cValuePos});
     return rewriter.create<mlir::LLVM::LoadOp>(loc, resultTy, p);
   }
 
   /// Method to construct code sequence to get the triple for dimension `dim`
   /// from a box.
   SmallVector<mlir::Value, 3>
   getDimsFromBox(mlir::Location loc, ArrayRef<mlir::Type> retTys,
                  mlir::Value box, mlir::Value dim,
loadElementSizeFromBox(mlir::Location loc, mlir::Type ty, mlir::Value box,
     mlir::LLVM::ConstantOp c0 = genConstantOffset(loc, rewriter, 0);
     mlir::LLVM::ConstantOp cElemLen =
         genConstantOffset(loc, rewriter, kElemLenPosInBox);
     auto pty = mlir::LLVM::LLVMPointerType::get(ty);
     mlir::LLVM::GEPOp p = genGEP(loc, pty, rewriter, box, c0, cElemLen);
     return rewriter.create<mlir::LLVM::LoadOp>(loc, ty, p);
   }
 
+  // Load the attribute from the `fir.box` and perform a logical `and` with the
+  // mask value. The value returned is the result the integer comparison (NE)
+  // between the logical `and` result and 0.
+  mlir::Value genBoxAttributeCheck(mlir::Location loc, mlir::Value box,
+                                   mlir::ConversionPatternRewriter &rewriter,
+                                   unsigned maskValue) const {
+    mlir::Type attrTy = rewriter.getI32Type();
+    mlir::Value attribute =
+        getValueFromBox(loc, box, attrTy, rewriter, kAttributePosInBox);
+    mlir::LLVM::ConstantOp attrMask =
+        genConstantOffset(loc, rewriter, maskValue);
+    auto maskRes =
+        rewriter.create<mlir::LLVM::AndOp>(loc, attrTy, attribute, attrMask);
+    mlir::LLVM::ConstantOp c0 = genConstantOffset(loc, rewriter, 0);
+    return rewriter.create<mlir::LLVM::ICmpOp>(
+        loc, mlir::LLVM::ICmpPredicate::ne, maskRes, c0);
+  }
+
   template <typename... ARGS>
   mlir::LLVM::GEPOp genGEP(mlir::Location loc, mlir::Type ty,
                            mlir::ConversionPatternRewriter &rewriter,
                            mlir::Value base, ARGS... args) const {
     SmallVector<mlir::Value> cv{args...};
     return rewriter.create<mlir::LLVM::GEPOp>(loc, ty, base, cv);
   }
 
struct BoxEleSizeOpConversion : public FIROpConversion<fir::BoxEleSizeOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::BoxEleSizeOp boxelesz, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     mlir::Value a = adaptor.getOperands()[0];
     auto loc = boxelesz.getLoc();
     auto ty = convertType(boxelesz.getType());
-    rewriter.replaceOp(boxelesz, loadElementSizeFromBox(loc, ty, a, rewriter));
+    auto elemSize = getValueFromBox(loc, a, ty, rewriter, kElemLenPosInBox);
+    rewriter.replaceOp(boxelesz, elemSize);
+    return success();
+  }
+};
+
+/// Lower `fir.box_isalloc` to a sequence of operations to determined if the
+/// boxed value was from an ALLOCATABLE entity.
+struct BoxIsAllocOpConversion : public FIROpConversion<fir::BoxIsAllocOp> {
+  using FIROpConversion::FIROpConversion;
+
+  mlir::LogicalResult
+  matchAndRewrite(fir::BoxIsAllocOp boxisalloc, OpAdaptor adaptor,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    mlir::Value box = adaptor.getOperands()[0];
+    auto loc = boxisalloc.getLoc();
+    mlir::Value check =
+        genBoxAttributeCheck(loc, box, rewriter, kAttrAllocatable);
+    rewriter.replaceOp(boxisalloc, check);
+    return success();
+  }
+};
+
+/// Lower `fir.box_isarray` to a sequence of operations to determined if the
+/// boxed is an array.
+/// It uses the same sequences as `fir.box_rank` to extract the rank value and
+/// compare it to 0.
+struct BoxIsArrayOpConversion : public FIROpConversion<fir::BoxIsArrayOp> {
+  using FIROpConversion::FIROpConversion;
+
+  mlir::LogicalResult
+  matchAndRewrite(fir::BoxIsArrayOp boxisarray, OpAdaptor adaptor,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    mlir::Value a = adaptor.getOperands()[0];
+    auto loc = boxisarray.getLoc();
+    auto rank =
+        getValueFromBox(loc, a, rewriter.getI32Type(), rewriter, kRankPosInBox);
+    auto c0 = genConstantOffset(loc, rewriter, 0);
+    rewriter.replaceOpWithNewOp<mlir::LLVM::ICmpOp>(
+        boxisarray, mlir::LLVM::ICmpPredicate::ne, rank, c0);
+    return success();
+  }
+};
+
+/// Lower `fir.box_isptr` to a sequence of operations to determined if the
+/// boxed value was from a POINTER entity.
+struct BoxIsPtrOpConversion : public FIROpConversion<fir::BoxIsPtrOp> {
+  using FIROpConversion::FIROpConversion;
+
+  mlir::LogicalResult
+  matchAndRewrite(fir::BoxIsPtrOp boxisptr, OpAdaptor adaptor,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    mlir::Value box = adaptor.getOperands()[0];
+    auto loc = boxisptr.getLoc();
+    mlir::Value check = genBoxAttributeCheck(loc, box, rewriter, kAttrPointer);
+    rewriter.replaceOp(boxisptr, check);
     return success();
   }
 };
 
 /// Lower `fir.box_rank` to the sequence of operation to extract the rank from
 /// the box.
 struct BoxRankOpConversion : public FIROpConversion<fir::BoxRankOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::BoxRankOp boxrank, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     mlir::Value a = adaptor.getOperands()[0];
     auto loc = boxrank.getLoc();
     mlir::Type ty = convertType(boxrank.getType());
-    auto result = getRankFromBox(loc, a, ty, rewriter);
+    auto result = getValueFromBox(loc, a, ty, rewriter, kRankPosInBox);
     rewriter.replaceOp(boxrank, result);
     return success();
   }
 };
 
 // `fir.call` -> `llvm.call`
 struct CallOpConversion : public FIROpConversion<fir::CallOp> {
   using FIROpConversion::FIROpConversion;
if (!forcedTargetTriple.empty()) {
       fir::setTargetTriple(mod, forcedTargetTriple);
     }
 
     auto *context = getModule().getContext();
     fir::LLVMTypeConverter typeConverter{getModule()};
     mlir::OwningRewritePatternList pattern(context);
     pattern.insert<
         AddcOpConversion, AddrOfOpConversion, BoxAddrOpConversion,
-        BoxDimsOpConversion, BoxEleSizeOpConversion, BoxRankOpConversion,
+        BoxDimsOpConversion, BoxEleSizeOpConversion, BoxIsAllocOpConversion,
+        BoxIsArrayOpConversion, BoxIsPtrOpConversion, BoxRankOpConversion,
         CallOpConversion, ConvertOpConversion, DivcOpConversion,
         ExtractValueOpConversion, HasValueOpConversion, GlobalOpConversion,
         InsertOnRangeOpConversion, InsertValueOpConversion, LoadOpConversion,
         NegcOpConversion, MulcOpConversion, SelectOpConversion,
         SelectRankOpConversion, StoreOpConversion, SubcOpConversion,
         UndefOpConversion, UnreachableOpConversion, ZeroOpConversion>(
         typeConverter);
     mlir::populateStdToLLVMConversionPatterns(typeConverter, pattern);

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

 
 // CHECK-LABEL: llvm.func @extract_elesize(
 // CHECK-SAME:                             %[[ARG0:.*]]: !llvm.ptr<struct<(ptr<f32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>) -> i32
 // CHECK:         %[[C0:.*]] = llvm.mlir.constant(0 : i32) : i32
 // CHECK:         %[[CELESIZE:.*]] = llvm.mlir.constant(1 : i32) : i32
 // CHECK:         %[[GEP:.*]] = llvm.getelementptr %[[ARG0]][%[[C0]], %[[CELESIZE]]] : (!llvm.ptr<struct<(ptr<f32>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>, i32, i32) -> !llvm.ptr<i32>
 // CHECK:         %[[ELE_SIZE:.*]] = llvm.load %[[GEP]] : !llvm.ptr<i32>
 // CHECK:         llvm.return %[[ELE_SIZE]] : i32
+
+// -----
+
+// Test `fir.box_isarray` conversion.
+
+func @box_isarray(%arg0: !fir.box<!fir.array<*:f64>>) -> i1 {
+  %0 = fir.box_isarray %arg0 : (!fir.box<!fir.array<*:f64>>) -> i1
+  return %0 : i1
+}
+
+// CHECK-LABEL: llvm.func @box_isarray(
+// CHECK-SAME:                         %[[ARG0:.*]]: !llvm.ptr<struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>) -> i1
+// CHECK:         %[[C0:.*]] = llvm.mlir.constant(0 : i32) : i32
+// CHECK:         %[[RANKPOS:.*]] = llvm.mlir.constant(3 : i32) : i32
+// CHECK:         %[[GEP:.*]] = llvm.getelementptr %[[ARG0]][%[[C0]], %[[RANKPOS]]] : (!llvm.ptr<struct<(ptr<f64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>, i32, i32) -> !llvm.ptr<i32> 
+// CHECK:         %[[RANK:.*]] = llvm.load %[[GEP]] : !llvm.ptr<i32>
+// CHECK:         %[[C0_ISARRAY:.*]] = llvm.mlir.constant(0 : i32) : i32
+// CHECK:         %[[IS_ARRAY:.*]] = llvm.icmp "ne" %[[RANK]], %[[C0_ISARRAY]] : i32
+// CHECK:         llvm.return %[[IS_ARRAY]] : i1
+
+// -----
+
+// Test `fir.box_isalloc` conversion.
+
+func @box_isalloc(%arg0: !fir.box<!fir.array<*:f64>>) -> i1 {
+  %0 = fir.box_isalloc %arg0 : (!fir.box<!fir.array<*:f64>>) -> i1
+  return %0 : i1
+}
+
+// CHECK-LABEL: llvm.func @box_isalloc(
+// CHECK-SAME:                         %[[ARG0:.*]]: !llvm.ptr<struct<(ptr<f64>, i64, i32, i8, i8, i8, i8)>>) -> i1
+// CHECK:         %[[C0:.*]] = llvm.mlir.constant(0 : i32) : i32
+// CHECK:         %[[ATTRPOS:.*]] = llvm.mlir.constant(5 : i32) : i32
+// CHECK:         %[[GEP:.*]] = llvm.getelementptr %[[ARG0]][%[[C0]], %[[ATTRPOS]]] : (!llvm.ptr<struct<(ptr<f64>, i64, i32, i8, i8, i8, i8)>>, i32, i32) -> !llvm.ptr<i32>
+// CHECK:         %[[ATTR:.*]] = llvm.load %[[GEP]] : !llvm.ptr<i32>
+// CHECK:         %[[ATTR_ISALLOC:.*]] = llvm.mlir.constant(2 : i32) : i32
+// CHECK:         %[[AND:.*]] = llvm.and %[[ATTR]], %[[ATTR_ISALLOC]]  : i32
+// CHECK:         %[[CMP_C0:.*]] = llvm.mlir.constant(0 : i32) : i32
+// CHECK:         %[[IS_ALLOC:.*]] = llvm.icmp "ne" %[[AND]], %[[CMP_C0]] : i32
+// CHECK:         llvm.return %[[IS_ALLOC]] : i1
+
+// -----
+
+// Test `fir.box_isptr` conversion.
+
+func @box_isptr(%arg0: !fir.box<!fir.array<*:f64>>) -> i1 {
+  %0 = fir.box_isptr %arg0 : (!fir.box<!fir.array<*:f64>>) -> i1
+  return %0 : i1
+}
+
+// CHECK-LABEL: llvm.func @box_isptr(
+// CHECK-SAME:                         %[[ARG0:.*]]: !llvm.ptr<struct<(ptr<f64>, i64, i32, i8, i8, i8, i8)>>) -> i1
+// CHECK:         %[[C0:.*]] = llvm.mlir.constant(0 : i32) : i32
+// CHECK:         %[[ATTRPOS:.*]] = llvm.mlir.constant(5 : i32) : i32
+// CHECK:         %[[GEP:.*]] = llvm.getelementptr %[[ARG0]][%[[C0]], %[[ATTRPOS]]] : (!llvm.ptr<struct<(ptr<f64>, i64, i32, i8, i8, i8, i8)>>, i32, i32) -> !llvm.ptr<i32>
+// CHECK:         %[[ATTR:.*]] = llvm.load %[[GEP]] : !llvm.ptr<i32>
+// CHECK:         %[[ATTR_ISALLOC:.*]] = llvm.mlir.constant(1 : i32) : i32
+// CHECK:         %[[AND:.*]] = llvm.and %[[ATTR]], %[[ATTR_ISALLOC]]  : i32
+// CHECK:         %[[CMP_C0:.*]] = llvm.mlir.constant(0 : i32) : i32
+// CHECK:         %[[IS_ALLOC:.*]] = llvm.icmp "ne" %[[AND]], %[[CMP_C0]] : i32
+// CHECK:         llvm.return %[[IS_ALLOC]] : i1