[flang][CodeGen] Transform `fir.boxchar_len` to a sequence of LLVM MLIR

[awarzynski]

Summary

This patch extends the FIRToLLVMLowering pass in Flang by adding a
hook to transform fir.boxchar_len to a sequence of LLVM MLIR
instructions.

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: Eric Schweitz <[e-mail]>

[awarzynski]

IIUC, both forms are correct (based on the operation definition:

%0 = fir.boxchar_len %arg0 : (!fir.boxchar<4>) -> i64
%0 = fir.boxchar_len %arg0 : (!fir.boxchar<4>) -> i32

As the length inside !fir.boxchar will be either i32 or i64 (this depends on the target), !fir.boxchar may require an integer cast on the result. Please see the tests for examples.

@schweitz , could you confirm whether this is correct? There was no integer cast on fir-dev, but I added it here. But perhaps I'm missing something here?

[clementval]

In D113763#3127219, @awarzynski wrote:

IIUC, both forms are correct (based on the operation definition:

%0 = fir.boxchar_len %arg0 : (!fir.boxchar<4>) -> i64
%0 = fir.boxchar_len %arg0 : (!fir.boxchar<4>) -> i32

As the length inside !fir.boxchar will be either i32 or i64 (this depends on the target), !fir.boxchar may require an integer cast on the result. Please see the tests for examples.

@schweitz , could you confirm whether this is correct? There was no integer cast on fir-dev, but I added it here. But perhaps I'm missing something here?

Did you try to add the cast on fir-dev to see the impact on the tests we have there?

[awarzynski]

In D113763#3127243, @clementval wrote:

Did you try to add the cast on fir-dev to see the impact on the tests we have there?

Yes, all tests pass for me.

[awarzynski]

Rebase

[clementval]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1464

This line seems to be useless.

[schweitz]

In D113763#3127219, @awarzynski wrote:

IIUC, both forms are correct (based on the operation definition:

%0 = fir.boxchar_len %arg0 : (!fir.boxchar<4>) -> i64
%0 = fir.boxchar_len %arg0 : (!fir.boxchar<4>) -> i32

As the length inside !fir.boxchar will be either i32 or i64 (this depends on the target), !fir.boxchar may require an integer cast on the result. Please see the tests for examples.

@schweitz , could you confirm whether this is correct? There was no integer cast on fir-dev, but I added it here. But perhaps I'm missing something here?

fir.boxchar_len is polymorphic on the return type. Any integer type is fine and must be dealt with when generating LLVM IR.

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1464

Bad merge?

[awarzynski]

Remove unused code

[awarzynski]

clang-format

[awarzynski]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1464

I have deleted that line and reformatted this bit. Thanks for pointing this out!

[clementval]

LG

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1464

nit: maybe having a constexpr with a proper name could help here instead of 1 or maybe a small comment.

[awarzynski]

flang/lib/Optimizer/CodeGen/CodeGen.cpp

1464

That's a good point - I'll update before merging.

flang/lib/Optimizer/CodeGen/CodeGen.cpp

 genExtractValueWithIndex(mlir::Location loc, mlir::Value tuple, mlir::Type ty,
                          mlir::ConversionPatternRewriter &rewriter,
                          mlir::MLIRContext *ctx, int x) {
   auto cx = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(x));
   auto xty = ty.cast<mlir::LLVM::LLVMStructType>().getBody()[x];
   return rewriter.create<mlir::LLVM::ExtractValueOp>(loc, xty, tuple, cx);
 }
 
+/// Convert `!fir.boxchar_len` to  `!llvm.extractvalue` for the 2nd part of the
+/// boxchar.
+struct BoxCharLenOpConversion : public FIROpConversion<fir::BoxCharLenOp> {
+  using FIROpConversion::FIROpConversion;
+
+  mlir::LogicalResult
+  matchAndRewrite(fir::BoxCharLenOp boxCharLen, OpAdaptor adaptor,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    mlir::Value boxChar = adaptor.getOperands()[0];
+    mlir::Location loc = boxChar.getLoc();
+    auto *ctx = boxChar.getContext();
+
+    mlir::Type llvmStructTy = convertType(boxChar.getType());
+    mlir::Type returnValTy = boxCharLen.getResult().getType();
+        llvmStructTy.cast<mlir::LLVM::LLVMStructType>().getBody()[1];
+
+    mlir::LLVM::ExtractValueOp len =
+        genExtractValueWithIndex(loc, boxChar, boxChar.getType(), rewriter, ctx, 1);
+    mlir::Value lenAfterCast = integerCast(loc, rewriter, returnValTy, len);
+    rewriter.replaceOp(boxCharLen, lenAfterCast);
+
+    return success();
+  }
+};
+
 /// Convert `fir.unboxchar` into two `llvm.extractvalue` instructions. One for
 /// the character buffer and one for the buffer length.
 struct UnboxCharOpConversion : public FIROpConversion<fir::UnboxCharOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::UnboxCharOp unboxchar, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
if (!forcedTargetTriple.empty()) {
       fir::setTargetTriple(mod, forcedTargetTriple);
     }
 
     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, EmboxCharOpConversion,
-        ExtractValueOpConversion, HasValueOpConversion, GlobalOpConversion,
-        InsertOnRangeOpConversion, InsertValueOpConversion,
+        AllocaOpConversion, BoxAddrOpConversion, BoxCharLenOpConversion,
+        BoxDimsOpConversion, BoxEleSizeOpConversion, BoxIsAllocOpConversion,
+        BoxIsArrayOpConversion, BoxIsPtrOpConversion, BoxRankOpConversion,
+        CallOpConversion, ConvertOpConversion, DispatchOpConversion,
+        DispatchTableOpConversion, DTEntryOpConversion, DivcOpConversion,
+        EmboxCharOpConversion, ExtractValueOpConversion, HasValueOpConversion,
+        GlobalOpConversion, InsertOnRangeOpConversion, InsertValueOpConversion,
         IsPresentOpConversion, LoadOpConversion, NegcOpConversion,
         MulcOpConversion, SelectCaseOpConversion, SelectOpConversion,
         SelectRankOpConversion, SelectTypeOpConversion, StoreOpConversion,
         SubcOpConversion, UnboxCharOpConversion, UndefOpConversion,
         UnreachableOpConversion, ZeroOpConversion>(typeConverter);
     mlir::populateStdToLLVMConversionPatterns(typeConverter, pattern);
     mlir::arith::populateArithmeticToLLVMConversionPatterns(typeConverter,
                                                             pattern);

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

 // INT64-NEXT:  llvm.return
 
 // INT32-LABEL: llvm.func @unboxchar_i32
 // INT32-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i32>, i32)>
 // INT32:  %{{.*}} = llvm.extractvalue %[[box_char]][0 : i32] : !llvm.struct<(ptr<i32>, i32)>
 // INT32:  %[[len_unextended:.*]] = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i32>, i32)>
 // INT32:  %{{.*}} = llvm.sext %[[len_unextended]] : i32 to i64
 // INT32-NEXT:  llvm.return
+
+// -----
+
+// Test fir.boxchar_len
+
+func @boxchar_len_i8_i32(%arg0 : !fir.boxchar<1>) -> () {
+  fir.boxchar_len %arg0 : (!fir.boxchar<1>) -> i32
+  return
+}
+
+// INT64-LABEL: llvm.func @boxchar_len_i8_i32
+// INT64-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i8>, i64)>
+// INT64:  %[[len:.*]] = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i8>, i64)>
+// INT64: %{{.*}} = llvm.trunc %[[len]] : i64 to i32
+// INT64-NEXT:  llvm.return
+
+// INT32-LABEL: llvm.func @boxchar_len_i8_i32
+// INT32-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i8>, i32)>
+// INT32:  %{{.*}} = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i8>, i32)>
+// INT32-NOT:  llvm.trunc
+// INT32-NOT:  llvm.sext
+// INT32-NEXT:  llvm.return
+
+func @boxchar_len_i8_i64(%arg0 : !fir.boxchar<1>) -> () {
+  fir.boxchar_len %arg0 : (!fir.boxchar<1>) -> i64
+  return
+}
+
+// INT64-LABEL: llvm.func @boxchar_len_i8_i64
+// INT64-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i8>, i64)>
+// INT64:  %{{.*}} = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i8>, i64)>
+// INT64-NOT:  llvm.trunc
+// INT64-NOT:  llvm.sext
+// INT64-NEXT:  llvm.return
+
+// INT32-LABEL: llvm.func @boxchar_len_i8_i64
+// INT32-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i8>, i32)>
+// INT32:  %[[len:.*]] = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i8>, i32)>
+// INT32:  %{{.*}} = llvm.sext %0 : i32 to i64
+// INT32-NEXT:  llvm.return
+
+func @boxchar_len_i32_i32(%arg0 : !fir.boxchar<4>) -> () {
+  fir.boxchar_len %arg0 : (!fir.boxchar<4>) -> i32
+  return
+}
+
+// INT64-LABEL: llvm.func @boxchar_len_i32_i32
+// INT64-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i32>, i64)>
+// INT64:  %[[len:.*]] = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i32>, i64)>
+// INT64: %{{.*}} = llvm.trunc %[[len]] : i64 to i32
+// INT64-NEXT:  llvm.return
+
+// INT32-LABEL: llvm.func @boxchar_len_i32_i32
+// INT32-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i32>, i32)>
+// INT32:  %{{.*}} = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i32>, i32)>
+// INT32-NOT:  llvm.trunc
+// INT32-NOT:  llvm.sext
+// INT32-NEXT:  llvm.return
+
+func @boxchar_len_i32_i64(%arg0 : !fir.boxchar<4>) -> (i64) {
+  %0 = fir.boxchar_len %arg0 : (!fir.boxchar<4>) -> i64
+  return %0 : i64
+}
+
+// INT64-LABEL: llvm.func @boxchar_len_i32_i64
+// INT64-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i32>, i64)>
+// INT64:  %{{.*}} = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i32>, i64)>
+// INT64-NOT:  llvm.trunc
+// INT64-NOT:  llvm.sext
+// INT64-NEXT:  llvm.return
+
+// INT32-LABEL: llvm.func @boxchar_len_i32_i64
+// INT32-SAME: %[[box_char:.*]]: !llvm.struct<(ptr<i32>, i32)>
+// INT32:  %[[len:.*]] = llvm.extractvalue %[[box_char]][1 : i32] : !llvm.struct<(ptr<i32>, i32)>
+// INT32:  %{{.*}} = llvm.sext %0 : i32 to i64
+// INT32-NEXT:  llvm.return