Skip to content

Commit 58551fa

Browse files
vzakharivzakhari
authored
[flang] Inline fir.is_contiguous_box in some cases. (#133812)
Added inlining for `rank == 1` and `innermost` cases.
1 parent 65ad626 commit 58551fa

File tree

2 files changed

+132
-87
lines changed

2 files changed

+132
-87
lines changed

‎flang/lib/Optimizer/Transforms/SimplifyFIROperations.cpp

Lines changed: 41 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -75,27 +75,50 @@ mlir::LogicalResult IsContiguousBoxCoversion::matchAndRewrite(
7575
fir::IsContiguousBoxOp op, mlir::PatternRewriter &rewriter) const {
7676
mlir::Location loc = op.getLoc();
7777
fir::FirOpBuilder builder(rewriter, op.getOperation());
78-
// TODO: support preferInlineImplementation.
79-
bool doInline = options.preferInlineImplementation && false;
80-
if (!doInline) {
81-
// Generate Fortran runtime call.
82-
mlir::Value result;
83-
if (op.getInnermost()) {
84-
mlir::Value one =
85-
builder.createIntegerConstant(loc, builder.getI32Type(), 1);
86-
result =
87-
fir::runtime::genIsContiguousUpTo(builder, loc, op.getBox(), one);
88-
} else {
89-
result = fir::runtime::genIsContiguous(builder, loc, op.getBox());
78+
mlir::Value box = op.getBox();
79+
80+
if (options.preferInlineImplementation) {
81+
auto boxType = mlir::cast<fir::BaseBoxType>(box.getType());
82+
unsigned rank = fir::getBoxRank(boxType);
83+
84+
// If rank is one, or 'innermost' attribute is set and
85+
// it is not a scalar, then generate a simple comparison
86+
// for the leading dimension: (stride == elem_size || extent == 0).
87+
//
88+
// The scalar cases are supposed to be optimized by the canonicalization.
89+
if (rank == 1 || (op.getInnermost() && rank > 0)) {
90+
mlir::Type idxTy = builder.getIndexType();
91+
auto eleSize = builder.create<fir::BoxEleSizeOp>(loc, idxTy, box);
92+
mlir::Value zero = fir::factory::createZeroValue(builder, loc, idxTy);
93+
auto dimInfo =
94+
builder.create<fir::BoxDimsOp>(loc, idxTy, idxTy, idxTy, box, zero);
95+
mlir::Value stride = dimInfo.getByteStride();
96+
mlir::Value pred1 = builder.create<mlir::arith::CmpIOp>(
97+
loc, mlir::arith::CmpIPredicate::eq, eleSize, stride);
98+
mlir::Value extent = dimInfo.getExtent();
99+
mlir::Value pred2 = builder.create<mlir::arith::CmpIOp>(
100+
loc, mlir::arith::CmpIPredicate::eq, extent, zero);
101+
mlir::Value result =
102+
builder.create<mlir::arith::OrIOp>(loc, pred1, pred2);
103+
result = builder.createConvert(loc, op.getType(), result);
104+
rewriter.replaceOp(op, result);
105+
return mlir::success();
90106
}
91-
result = builder.createConvert(loc, op.getType(), result);
92-
rewriter.replaceOp(op, result);
93-
return mlir::success();
107+
// TODO: support arrays with multiple dimensions.
94108
}
95109

96-
// Generate inline implementation.
97-
TODO(loc, "inline IsContiguousBoxOp");
98-
return mlir::failure();
110+
// Generate Fortran runtime call.
111+
mlir::Value result;
112+
if (op.getInnermost()) {
113+
mlir::Value one =
114+
builder.createIntegerConstant(loc, builder.getI32Type(), 1);
115+
result = fir::runtime::genIsContiguousUpTo(builder, loc, box, one);
116+
} else {
117+
result = fir::runtime::genIsContiguous(builder, loc, box);
118+
}
119+
result = builder.createConvert(loc, op.getType(), result);
120+
rewriter.replaceOp(op, result);
121+
return mlir::success();
99122
}
100123

101124
/// Generate a call to Size runtime function or an inline

‎flang/test/Transforms/simplify-fir-operations.fir

Lines changed: 91 additions & 69 deletions
Original file line numberDiff line numberDiff line change
@@ -1,130 +1,152 @@
1-
// RUN: fir-opt --split-input-file --simplify-fir-operations %s | FileCheck %s
2-
3-
// -----
1+
// RUN: fir-opt --split-input-file --simplify-fir-operations %s | FileCheck --check-prefixes=ALL,NOOPT %s
2+
// RUN: fir-opt --split-input-file --simplify-fir-operations=prefer-inline-implementation=true %s | FileCheck --check-prefixes=ALL,OPT %s
43

54
func.func @test_none_innermost(%arg0: !fir.box<none>) -> i1 {
65
%0 = fir.is_contiguous_box %arg0 innermost : (!fir.box<none>) -> i1
76
return %0 : i1
87
}
9-
// CHECK-LABEL: func.func @test_none_innermost(
10-
// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>) -> i1 {
11-
// CHECK: %[[VAL_1:.*]] = arith.constant 1 : i32
12-
// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAIsContiguousUpTo(%[[VAL_0]], %[[VAL_1]]) : (!fir.box<none>, i32) -> i1
13-
// CHECK: return %[[VAL_2]] : i1
14-
// CHECK: }
8+
// ALL-LABEL: func.func @test_none_innermost(
9+
// ALL-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>) -> i1 {
10+
// ALL: %[[VAL_1:.*]] = arith.constant 1 : i32
11+
// ALL: %[[VAL_2:.*]] = fir.call @_FortranAIsContiguousUpTo(%[[VAL_0]], %[[VAL_1]]) : (!fir.box<none>, i32) -> i1
12+
// ALL: return %[[VAL_2]] : i1
1513

1614
// -----
1715

1816
func.func @test_none_whole(%arg0: !fir.box<none>) -> i1 {
1917
%0 = fir.is_contiguous_box %arg0 whole : (!fir.box<none>) -> i1
2018
return %0 : i1
2119
}
22-
// CHECK-LABEL: func.func @test_none_whole(
23-
// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>) -> i1 {
24-
// CHECK: %[[VAL_1:.*]] = fir.call @_FortranAIsContiguous(%[[VAL_0]]) : (!fir.box<none>) -> i1
25-
// CHECK: return %[[VAL_1]] : i1
26-
// CHECK: }
20+
// ALL-LABEL: func.func @test_none_whole(
21+
// ALL-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>) -> i1 {
22+
// ALL: %[[VAL_1:.*]] = fir.call @_FortranAIsContiguous(%[[VAL_0]]) : (!fir.box<none>) -> i1
23+
// ALL: return %[[VAL_1]] : i1
24+
// ALL: }
2725

2826
// -----
2927

3028
func.func @test_array_innermost(%arg0: !fir.box<!fir.array<?xf32>>) -> i1 {
3129
%0 = fir.is_contiguous_box %arg0 innermost : (!fir.box<!fir.array<?xf32>>) -> i1
3230
return %0 : i1
3331
}
34-
// CHECK-LABEL: func.func @test_array_innermost(
35-
// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<?xf32>>) -> i1 {
36-
// CHECK: %[[VAL_1:.*]] = arith.constant 1 : i32
37-
// CHECK: %[[VAL_2:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
38-
// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAIsContiguousUpTo(%[[VAL_2]], %[[VAL_1]]) : (!fir.box<none>, i32) -> i1
39-
// CHECK: return %[[VAL_3]] : i1
40-
// CHECK: }
32+
// ALL-LABEL: func.func @test_array_innermost(
33+
// ALL-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<?xf32>>) -> i1 {
34+
// NOOPT: %[[VAL_1:.*]] = arith.constant 1 : i32
35+
// NOOPT: %[[VAL_2:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
36+
// NOOPT: %[[VAL_3:.*]] = fir.call @_FortranAIsContiguousUpTo(%[[VAL_2]], %[[VAL_1]]) : (!fir.box<none>, i32) -> i1
37+
// NOOPT: return %[[VAL_3]] : i1
38+
// OPT: %[[VAL_1:.*]] = arith.constant 0 : index
39+
// OPT: %[[VAL_2:.*]] = fir.box_elesize %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> index
40+
// OPT: %[[VAL_3:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_1]] : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
41+
// OPT: %[[VAL_4:.*]] = arith.cmpi eq, %[[VAL_2]], %[[VAL_3]]#2 : index
42+
// OPT: %[[VAL_5:.*]] = arith.cmpi eq, %[[VAL_3]]#1, %[[VAL_1]] : index
43+
// OPT: %[[VAL_6:.*]] = arith.ori %[[VAL_4]], %[[VAL_5]] : i1
44+
// OPT: return %[[VAL_6]] : i1
4145

4246
// -----
4347

4448
func.func @test_array_whole(%arg0: !fir.box<!fir.array<?xf32>>) -> i1 {
4549
%0 = fir.is_contiguous_box %arg0 whole : (!fir.box<!fir.array<?xf32>>) -> i1
4650
return %0 : i1
4751
}
48-
// CHECK-LABEL: func.func @test_array_whole(
49-
// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<?xf32>>) -> i1 {
50-
// CHECK: %[[VAL_1:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
51-
// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAIsContiguous(%[[VAL_1]]) : (!fir.box<none>) -> i1
52-
// CHECK: return %[[VAL_2]] : i1
53-
// CHECK: }
52+
// ALL-LABEL: func.func @test_array_whole(
53+
// ALL-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<?xf32>>) -> i1 {
54+
// NOOPT: %[[VAL_1:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
55+
// NOOPT: %[[VAL_2:.*]] = fir.call @_FortranAIsContiguous(%[[VAL_1]]) : (!fir.box<none>) -> i1
56+
// NOOPT: return %[[VAL_2]] : i1
57+
// OPT: %[[VAL_1:.*]] = arith.constant 0 : index
58+
// OPT: %[[VAL_2:.*]] = fir.box_elesize %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> index
59+
// OPT: %[[VAL_3:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_1]] : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
60+
// OPT: %[[VAL_4:.*]] = arith.cmpi eq, %[[VAL_2]], %[[VAL_3]]#2 : index
61+
// OPT: %[[VAL_5:.*]] = arith.cmpi eq, %[[VAL_3]]#1, %[[VAL_1]] : index
62+
// OPT: %[[VAL_6:.*]] = arith.ori %[[VAL_4]], %[[VAL_5]] : i1
63+
// OPT: return %[[VAL_6]] : i1
5464

5565
// -----
5666

5767
func.func @test_assumed_rank_innermost(%arg0: !fir.box<!fir.array<*:f32>>) -> i1 {
5868
%0 = fir.is_contiguous_box %arg0 innermost : (!fir.box<!fir.array<*:f32>>) -> i1
5969
return %0 : i1
6070
}
61-
// CHECK-LABEL: func.func @test_assumed_rank_innermost(
62-
// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<*:f32>>) -> i1 {
63-
// CHECK: %[[VAL_1:.*]] = arith.constant 1 : i32
64-
// CHECK: %[[VAL_2:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<*:f32>>) -> !fir.box<none>
65-
// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAIsContiguousUpTo(%[[VAL_2]], %[[VAL_1]]) : (!fir.box<none>, i32) -> i1
66-
// CHECK: return %[[VAL_3]] : i1
67-
// CHECK: }
71+
// ALL-LABEL: func.func @test_assumed_rank_innermost(
72+
// ALL-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<*:f32>>) -> i1 {
73+
// ALL: %[[VAL_1:.*]] = arith.constant 1 : i32
74+
// ALL: %[[VAL_2:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<*:f32>>) -> !fir.box<none>
75+
// ALL: %[[VAL_3:.*]] = fir.call @_FortranAIsContiguousUpTo(%[[VAL_2]], %[[VAL_1]]) : (!fir.box<none>, i32) -> i1
76+
// ALL: return %[[VAL_3]] : i1
6877

6978
// -----
7079

7180
func.func @test_assumed_rank_whole(%arg0: !fir.box<!fir.array<*:f32>>) -> i1 {
7281
%0 = fir.is_contiguous_box %arg0 whole : (!fir.box<!fir.array<*:f32>>) -> i1
7382
return %0 : i1
7483
}
75-
// CHECK-LABEL: func.func @test_assumed_rank_whole(
76-
// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<*:f32>>) -> i1 {
77-
// CHECK: %[[VAL_1:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<*:f32>>) -> !fir.box<none>
78-
// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAIsContiguous(%[[VAL_1]]) : (!fir.box<none>) -> i1
79-
// CHECK: return %[[VAL_2]] : i1
80-
// CHECK: }
84+
// ALL-LABEL: func.func @test_assumed_rank_whole(
85+
// ALL-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<*:f32>>) -> i1 {
86+
// ALL: %[[VAL_1:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<*:f32>>) -> !fir.box<none>
87+
// ALL: %[[VAL_2:.*]] = fir.call @_FortranAIsContiguous(%[[VAL_1]]) : (!fir.box<none>) -> i1
88+
// ALL: return %[[VAL_2]] : i1
89+
// ALL: }
90+
91+
// -----
92+
93+
func.func @test_scalar_upoly(%arg0: !fir.class<none>) -> i1 {
94+
%0 = fir.is_contiguous_box %arg0 innermost : (!fir.class<none>) -> i1
95+
return %0 : i1
96+
}
97+
// ALL-LABEL: func.func @test_scalar_upoly(
98+
// ALL-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.class<none>) -> i1 {
99+
// ALL: %[[VAL_1:.*]] = arith.constant 1 : i32
100+
// ALL: %[[VAL_2:.*]] = fir.convert %[[VAL_0]] : (!fir.class<none>) -> !fir.box<none>
101+
// ALL: %[[VAL_3:.*]] = fir.call @_FortranAIsContiguousUpTo(%[[VAL_2]], %[[VAL_1]]) : (!fir.box<none>, i32) -> i1
102+
// ALL: return %[[VAL_3]] : i1
81103

82104
// -----
83105

84106
func.func @test_none(%arg0: !fir.box<none>) -> i16 {
85107
%0 = fir.box_total_elements %arg0 : (!fir.box<none>) -> i16
86108
return %0 : i16
87109
}
88-
// CHECK-LABEL: func.func @test_none(
89-
// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>) -> i16 {
90-
// CHECK: %[[VAL_3:.*]] = arith.constant {{.*}} : i32
91-
// CHECK: %[[VAL_1:.*]] = fir.address_of(@{{.*}}) : !fir.ref<!fir.char<1,{{.*}}>>
92-
// CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
93-
// CHECK: %[[VAL_5:.*]] = fir.call @_FortranASize(%[[VAL_0]], %[[VAL_4]], %[[VAL_3]]) : (!fir.box<none>, !fir.ref<i8>, i32) -> i64
94-
// CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (i64) -> i16
95-
// CHECK: return %[[VAL_6]] : i16
96-
// CHECK: }
110+
// ALL-LABEL: func.func @test_none(
111+
// ALL-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>) -> i16 {
112+
// ALL: %[[VAL_3:.*]] = arith.constant {{.*}} : i32
113+
// ALL: %[[VAL_1:.*]] = fir.address_of(@{{.*}}) : !fir.ref<!fir.char<1,{{.*}}>>
114+
// ALL: %[[VAL_4:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
115+
// ALL: %[[VAL_5:.*]] = fir.call @_FortranASize(%[[VAL_0]], %[[VAL_4]], %[[VAL_3]]) : (!fir.box<none>, !fir.ref<i8>, i32) -> i64
116+
// ALL: %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (i64) -> i16
117+
// ALL: return %[[VAL_6]] : i16
118+
// ALL: }
97119

98120
// -----
99121

100122
func.func @test_array(%arg0: !fir.box<!fir.array<?x?xf32>>) -> i32 {
101123
%0 = fir.box_total_elements %arg0 : (!fir.box<!fir.array<?x?xf32>>) -> i32
102124
return %0 : i32
103125
}
104-
// CHECK-LABEL: func.func @test_array(
105-
// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<?x?xf32>>) -> i32 {
106-
// CHECK: %[[VAL_3:.*]] = arith.constant {{.*}} : i32
107-
// CHECK: %[[VAL_1:.*]] = fir.address_of({{.*}}) : !fir.ref<!fir.char<1,{{.*}}>>
108-
// CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?x?xf32>>) -> !fir.box<none>
109-
// CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
110-
// CHECK: %[[VAL_6:.*]] = fir.call @_FortranASize(%[[VAL_4]], %[[VAL_5]], %[[VAL_3]]) : (!fir.box<none>, !fir.ref<i8>, i32) -> i64
111-
// CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_6]] : (i64) -> i32
112-
// CHECK: return %[[VAL_7]] : i32
113-
// CHECK: }
126+
// ALL-LABEL: func.func @test_array(
127+
// ALL-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<?x?xf32>>) -> i32 {
128+
// ALL: %[[VAL_3:.*]] = arith.constant {{.*}} : i32
129+
// ALL: %[[VAL_1:.*]] = fir.address_of({{.*}}) : !fir.ref<!fir.char<1,{{.*}}>>
130+
// ALL: %[[VAL_4:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?x?xf32>>) -> !fir.box<none>
131+
// ALL: %[[VAL_5:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
132+
// ALL: %[[VAL_6:.*]] = fir.call @_FortranASize(%[[VAL_4]], %[[VAL_5]], %[[VAL_3]]) : (!fir.box<none>, !fir.ref<i8>, i32) -> i64
133+
// ALL: %[[VAL_7:.*]] = fir.convert %[[VAL_6]] : (i64) -> i32
134+
// ALL: return %[[VAL_7]] : i32
135+
// ALL: }
114136

115137
// -----
116138

117139
func.func @test_assumed_rank(%arg0: !fir.box<!fir.array<*:f32>>) -> index {
118140
%0 = fir.box_total_elements %arg0 : (!fir.box<!fir.array<*:f32>>) -> index
119141
return %0 : index
120142
}
121-
// CHECK-LABEL: func.func @test_assumed_rank(
122-
// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<*:f32>>) -> index {
123-
// CHECK: %[[VAL_3:.*]] = arith.constant {{.*}} : i32
124-
// CHECK: %[[VAL_1:.*]] = fir.address_of({{.*}}) : !fir.ref<!fir.char<1,{{.*}}>>
125-
// CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<*:f32>>) -> !fir.box<none>
126-
// CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
127-
// CHECK: %[[VAL_6:.*]] = fir.call @_FortranASize(%[[VAL_4]], %[[VAL_5]], %[[VAL_3]]) : (!fir.box<none>, !fir.ref<i8>, i32) -> i64
128-
// CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_6]] : (i64) -> index
129-
// CHECK: return %[[VAL_7]] : index
130-
// CHECK: }
143+
// ALL-LABEL: func.func @test_assumed_rank(
144+
// ALL-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<*:f32>>) -> index {
145+
// ALL: %[[VAL_3:.*]] = arith.constant {{.*}} : i32
146+
// ALL: %[[VAL_1:.*]] = fir.address_of({{.*}}) : !fir.ref<!fir.char<1,{{.*}}>>
147+
// ALL: %[[VAL_4:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<*:f32>>) -> !fir.box<none>
148+
// ALL: %[[VAL_5:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
149+
// ALL: %[[VAL_6:.*]] = fir.call @_FortranASize(%[[VAL_4]], %[[VAL_5]], %[[VAL_3]]) : (!fir.box<none>, !fir.ref<i8>, i32) -> i64
150+
// ALL: %[[VAL_7:.*]] = fir.convert %[[VAL_6]] : (i64) -> index
151+
// ALL: return %[[VAL_7]] : index
152+
// ALL: }

0 commit comments

Comments
 (0)