Skip to content

Commit a0ba3b6

Browse files
jeanPeriergithub-actions[bot]
jeanPerier
authored and
github-actions[bot]
committed
Automerge: [flang] use DataLayout instead of GEP to compute element size (#140235)
Now that the datalayout is part of codegen, use that to generate type size constants in codegen instead of generating GEP.
2 parents 11cfc4e + 416b7df commit a0ba3b6

File tree

6 files changed

+48
-87
lines changed

6 files changed

+48
-87
lines changed

‎flang/include/flang/Optimizer/CodeGen/FIROpPatterns.h‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -173,6 +173,10 @@ class ConvertFIRToLLVMPattern : public mlir::ConvertToLLVMPattern {
173173
this->getTypeConverter());
174174
}
175175

176+
const mlir::DataLayout &getDataLayout() const {
177+
return lowerTy().getDataLayout();
178+
}
179+
176180
void attachTBAATag(mlir::LLVM::AliasAnalysisOpInterface op,
177181
mlir::Type baseFIRType, mlir::Type accessFIRType,
178182
mlir::LLVM::GEPOp gep) const {

‎flang/lib/Optimizer/CodeGen/CodeGen.cpp‎

Lines changed: 21 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -1043,33 +1043,23 @@ static mlir::SymbolRefAttr getMalloc(fir::AllocMemOp op,
10431043
static mlir::Value
10441044
computeElementDistance(mlir::Location loc, mlir::Type llvmObjectType,
10451045
mlir::Type idxTy,
1046-
mlir::ConversionPatternRewriter &rewriter) {
1047-
// Note that we cannot use something like
1048-
// mlir::LLVM::getPrimitiveTypeSizeInBits() for the element type here. For
1049-
// example, it returns 10 bytes for mlir::Float80Type for targets where it
1050-
// occupies 16 bytes. Proper solution is probably to use
1051-
// mlir::DataLayout::getTypeABIAlignment(), but DataLayout is not being set
1052-
// yet (see llvm-project#57230). For the time being use the '(intptr_t)((type
1053-
// *)0 + 1)' trick for all types. The generated instructions are optimized
1054-
// into constant by the first pass of InstCombine, so it should not be a
1055-
// performance issue.
1056-
auto llvmPtrTy = ::getLlvmPtrType(llvmObjectType.getContext());
1057-
auto nullPtr = rewriter.create<mlir::LLVM::ZeroOp>(loc, llvmPtrTy);
1058-
auto gep = rewriter.create<mlir::LLVM::GEPOp>(
1059-
loc, llvmPtrTy, llvmObjectType, nullPtr,
1060-
llvm::ArrayRef<mlir::LLVM::GEPArg>{1});
1061-
return rewriter.create<mlir::LLVM::PtrToIntOp>(loc, idxTy, gep);
1046+
mlir::ConversionPatternRewriter &rewriter,
1047+
const mlir::DataLayout &dataLayout) {
1048+
llvm::TypeSize size = dataLayout.getTypeSize(llvmObjectType);
1049+
unsigned short alignment = dataLayout.getTypeABIAlignment(llvmObjectType);
1050+
std::int64_t distance = llvm::alignTo(size, alignment);
1051+
return genConstantIndex(loc, idxTy, rewriter, distance);
10621052
}
10631053

10641054
/// Return value of the stride in bytes between adjacent elements
10651055
/// of LLVM type \p llTy. The result is returned as a value of
10661056
/// \p idxTy integer type.
10671057
static mlir::Value
10681058
genTypeStrideInBytes(mlir::Location loc, mlir::Type idxTy,
1069-
mlir::ConversionPatternRewriter &rewriter,
1070-
mlir::Type llTy) {
1059+
mlir::ConversionPatternRewriter &rewriter, mlir::Type llTy,
1060+
const mlir::DataLayout &dataLayout) {
10711061
// Create a pointer type and use computeElementDistance().
1072-
return computeElementDistance(loc, llTy, idxTy, rewriter);
1062+
return computeElementDistance(loc, llTy, idxTy, rewriter, dataLayout);
10731063
}
10741064

10751065
namespace {
@@ -1111,7 +1101,7 @@ struct AllocMemOpConversion : public fir::FIROpConversion<fir::AllocMemOp> {
11111101
mlir::Value genTypeSizeInBytes(mlir::Location loc, mlir::Type idxTy,
11121102
mlir::ConversionPatternRewriter &rewriter,
11131103
mlir::Type llTy) const {
1114-
return computeElementDistance(loc, llTy, idxTy, rewriter);
1104+
return computeElementDistance(loc, llTy, idxTy, rewriter, getDataLayout());
11151105
}
11161106
};
11171107
} // namespace
@@ -1323,8 +1313,8 @@ struct EmboxCommonConversion : public fir::FIROpConversion<OP> {
13231313
fir::CharacterType charTy,
13241314
mlir::ValueRange lenParams) const {
13251315
auto i64Ty = mlir::IntegerType::get(rewriter.getContext(), 64);
1326-
mlir::Value size =
1327-
genTypeStrideInBytes(loc, i64Ty, rewriter, this->convertType(charTy));
1316+
mlir::Value size = genTypeStrideInBytes(
1317+
loc, i64Ty, rewriter, this->convertType(charTy), this->getDataLayout());
13281318
if (charTy.hasConstantLen())
13291319
return size; // Length accounted for in the genTypeStrideInBytes GEP.
13301320
// Otherwise, multiply the single character size by the length.
@@ -1338,6 +1328,7 @@ struct EmboxCommonConversion : public fir::FIROpConversion<OP> {
13381328
std::tuple<mlir::Value, mlir::Value> getSizeAndTypeCode(
13391329
mlir::Location loc, mlir::ConversionPatternRewriter &rewriter,
13401330
mlir::Type boxEleTy, mlir::ValueRange lenParams = {}) const {
1331+
const mlir::DataLayout &dataLayout = this->getDataLayout();
13411332
auto i64Ty = mlir::IntegerType::get(rewriter.getContext(), 64);
13421333
if (auto eleTy = fir::dyn_cast_ptrEleTy(boxEleTy))
13431334
boxEleTy = eleTy;
@@ -1354,18 +1345,19 @@ struct EmboxCommonConversion : public fir::FIROpConversion<OP> {
13541345
mlir::dyn_cast<fir::LogicalType>(boxEleTy) || fir::isa_real(boxEleTy) ||
13551346
fir::isa_complex(boxEleTy))
13561347
return {genTypeStrideInBytes(loc, i64Ty, rewriter,
1357-
this->convertType(boxEleTy)),
1348+
this->convertType(boxEleTy), dataLayout),
13581349
typeCodeVal};
13591350
if (auto charTy = mlir::dyn_cast<fir::CharacterType>(boxEleTy))
13601351
return {getCharacterByteSize(loc, rewriter, charTy, lenParams),
13611352
typeCodeVal};
13621353
if (fir::isa_ref_type(boxEleTy)) {
13631354
auto ptrTy = ::getLlvmPtrType(rewriter.getContext());
1364-
return {genTypeStrideInBytes(loc, i64Ty, rewriter, ptrTy), typeCodeVal};
1355+
return {genTypeStrideInBytes(loc, i64Ty, rewriter, ptrTy, dataLayout),
1356+
typeCodeVal};
13651357
}
13661358
if (mlir::isa<fir::RecordType>(boxEleTy))
13671359
return {genTypeStrideInBytes(loc, i64Ty, rewriter,
1368-
this->convertType(boxEleTy)),
1360+
this->convertType(boxEleTy), dataLayout),
13691361
typeCodeVal};
13701362
fir::emitFatalError(loc, "unhandled type in fir.box code generation");
13711363
}
@@ -1909,8 +1901,8 @@ struct XEmboxOpConversion : public EmboxCommonConversion<fir::cg::XEmboxOp> {
19091901
if (hasSubcomp) {
19101902
// We have a subcomponent. The step value needs to be the number of
19111903
// bytes per element (which is a derived type).
1912-
prevDimByteStride =
1913-
genTypeStrideInBytes(loc, i64Ty, rewriter, convertType(seqEleTy));
1904+
prevDimByteStride = genTypeStrideInBytes(
1905+
loc, i64Ty, rewriter, convertType(seqEleTy), getDataLayout());
19141906
} else if (hasSubstr) {
19151907
// We have a substring. The step value needs to be the number of bytes
19161908
// per CHARACTER element.
@@ -3604,8 +3596,8 @@ struct CopyOpConversion : public fir::FIROpConversion<fir::CopyOp> {
36043596
mlir::Value llvmDestination = adaptor.getDestination();
36053597
mlir::Type i64Ty = mlir::IntegerType::get(rewriter.getContext(), 64);
36063598
mlir::Type copyTy = fir::unwrapRefType(copy.getSource().getType());
3607-
mlir::Value copySize =
3608-
genTypeStrideInBytes(loc, i64Ty, rewriter, convertType(copyTy));
3599+
mlir::Value copySize = genTypeStrideInBytes(
3600+
loc, i64Ty, rewriter, convertType(copyTy), getDataLayout());
36093601

36103602
mlir::LLVM::AliasAnalysisOpInterface newOp;
36113603
if (copy.getNoOverlap())

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

Lines changed: 14 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -216,9 +216,7 @@ func.func @test_alloc_and_freemem_one() {
216216
}
217217

218218
// CHECK-LABEL: llvm.func @test_alloc_and_freemem_one() {
219-
// CHECK-NEXT: %[[NULL:.*]] = llvm.mlir.zero : !llvm.ptr
220-
// CHECK-NEXT: %[[GEP:.*]] = llvm.getelementptr %[[NULL]][1]
221-
// CHECK-NEXT: %[[N:.*]] = llvm.ptrtoint %[[GEP]] : !llvm.ptr to i64
219+
// CHECK: %[[N:.*]] = llvm.mlir.constant(4 : i64) : i64
222220
// CHECK-NEXT: llvm.call @malloc(%[[N]])
223221
// CHECK: llvm.call @free(%{{.*}})
224222
// CHECK-NEXT: llvm.return
@@ -235,10 +233,8 @@ func.func @test_alloc_and_freemem_several() {
235233
}
236234

237235
// CHECK-LABEL: llvm.func @test_alloc_and_freemem_several() {
238-
// CHECK: [[NULL:%.*]] = llvm.mlir.zero : !llvm.ptr
239-
// CHECK: [[PTR:%.*]] = llvm.getelementptr [[NULL]][{{.*}}] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<100 x f32>
240-
// CHECK: [[N:%.*]] = llvm.ptrtoint [[PTR]] : !llvm.ptr to i64
241-
// CHECK: [[MALLOC:%.*]] = llvm.call @malloc([[N]])
236+
// CHECK: %[[N:.*]] = llvm.mlir.constant(400 : i64) : i64
237+
// CHECK: [[MALLOC:%.*]] = llvm.call @malloc(%[[N]])
242238
// CHECK: llvm.call @free([[MALLOC]])
243239
// CHECK: llvm.return
244240

@@ -251,9 +247,7 @@ func.func @test_with_shape(%ncols: index, %nrows: index) {
251247

252248
// CHECK-LABEL: llvm.func @test_with_shape
253249
// CHECK-SAME: %[[NCOLS:.*]]: i64, %[[NROWS:.*]]: i64
254-
// CHECK: %[[NULL:.*]] = llvm.mlir.zero : !llvm.ptr
255-
// CHECK: %[[GEP:.*]] = llvm.getelementptr %[[NULL]][1]
256-
// CHECK: %[[FOUR:.*]] = llvm.ptrtoint %[[GEP]] : !llvm.ptr to i64
250+
// CHECK: %[[FOUR:.*]] = llvm.mlir.constant(4 : i64) : i64
257251
// CHECK: %[[DIM1_SIZE:.*]] = llvm.mul %[[FOUR]], %[[NCOLS]] : i64
258252
// CHECK: %[[TOTAL_SIZE:.*]] = llvm.mul %[[DIM1_SIZE]], %[[NROWS]] : i64
259253
// CHECK: %[[MEM:.*]] = llvm.call @malloc(%[[TOTAL_SIZE]])
@@ -269,9 +263,7 @@ func.func @test_string_with_shape(%len: index, %nelems: index) {
269263

270264
// CHECK-LABEL: llvm.func @test_string_with_shape
271265
// CHECK-SAME: %[[LEN:.*]]: i64, %[[NELEMS:.*]]: i64)
272-
// CHECK: %[[NULL:.*]] = llvm.mlir.zero : !llvm.ptr
273-
// CHECK: %[[GEP:.*]] = llvm.getelementptr %[[NULL]][1]
274-
// CHECK: %[[ONE:.*]] = llvm.ptrtoint %[[GEP]] : !llvm.ptr to i64
266+
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i64) : i64
275267
// CHECK: %[[LEN_SIZE:.*]] = llvm.mul %[[ONE]], %[[LEN]] : i64
276268
// CHECK: %[[TOTAL_SIZE:.*]] = llvm.mul %[[LEN_SIZE]], %[[NELEMS]] : i64
277269
// CHECK: %[[MEM:.*]] = llvm.call @malloc(%[[TOTAL_SIZE]])
@@ -1654,9 +1646,7 @@ func.func @embox0(%arg0: !fir.ref<!fir.array<100xi32>>) {
16541646
// AMDGPU: %[[AA:.*]] = llvm.alloca %[[C1]] x !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})> {alignment = 8 : i64} : (i32) -> !llvm.ptr<5>
16551647
// AMDGPU: %[[ALLOCA:.*]] = llvm.addrspacecast %[[AA]] : !llvm.ptr<5> to !llvm.ptr
16561648
// CHECK: %[[TYPE_CODE:.*]] = llvm.mlir.constant(9 : i32) : i32
1657-
// CHECK: %[[NULL:.*]] = llvm.mlir.zero : !llvm.ptr
1658-
// CHECK: %[[GEP:.*]] = llvm.getelementptr %[[NULL]][1]
1659-
// CHECK: %[[I64_ELEM_SIZE:.*]] = llvm.ptrtoint %[[GEP]] : !llvm.ptr to i64
1649+
// CHECK: %[[I64_ELEM_SIZE:.*]] = llvm.mlir.constant(4 : i64) : i64
16601650
// CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
16611651
// CHECK: %[[DESC0:.*]] = llvm.insertvalue %[[I64_ELEM_SIZE]], %[[DESC]][1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>
16621652
// CHECK: %[[CFI_VERSION:.*]] = llvm.mlir.constant(20240719 : i32) : i32
@@ -1879,9 +1869,7 @@ func.func @xembox0(%arg0: !fir.ref<!fir.array<?xi32>>) {
18791869
// AMDGPU: %[[ALLOCA:.*]] = llvm.addrspacecast %[[AA]] : !llvm.ptr<5> to !llvm.ptr
18801870
// CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64
18811871
// CHECK: %[[TYPE:.*]] = llvm.mlir.constant(9 : i32) : i32
1882-
// CHECK: %[[NULL:.*]] = llvm.mlir.zero : !llvm.ptr
1883-
// CHECK: %[[GEP:.*]] = llvm.getelementptr %[[NULL]][1]
1884-
// CHECK: %[[ELEM_LEN_I64:.*]] = llvm.ptrtoint %[[GEP]] : !llvm.ptr to i64
1872+
// CHECK: %[[ELEM_LEN_I64:.*]] = llvm.mlir.constant(4 : i64) : i64
18851873
// CHECK: %[[BOX0:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>
18861874
// CHECK: %[[BOX1:.*]] = llvm.insertvalue %[[ELEM_LEN_I64]], %[[BOX0]][1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>
18871875
// CHECK: %[[VERSION:.*]] = llvm.mlir.constant(20240719 : i32) : i32
@@ -1933,9 +1921,7 @@ func.func @xembox0_i32(%arg0: !fir.ref<!fir.array<?xi32>>) {
19331921
// CHECK: %[[C0_I32:.*]] = llvm.mlir.constant(0 : i32) : i32
19341922
// CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64
19351923
// CHECK: %[[TYPE:.*]] = llvm.mlir.constant(9 : i32) : i32
1936-
// CHECK: %[[NULL:.*]] = llvm.mlir.zero : !llvm.ptr
1937-
// CHECK: %[[GEP:.*]] = llvm.getelementptr %[[NULL]][1]
1938-
// CHECK: %[[ELEM_LEN_I64:.*]] = llvm.ptrtoint %[[GEP]] : !llvm.ptr to i64
1924+
// CHECK: %[[ELEM_LEN_I64:.*]] = llvm.mlir.constant(4 : i64) : i64
19391925
// CHECK: %[[BOX0:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>
19401926
// CHECK: %[[BOX1:.*]] = llvm.insertvalue %[[ELEM_LEN_I64]], %[[BOX0]][1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>
19411927
// CHECK: %[[VERSION:.*]] = llvm.mlir.constant(20240719 : i32) : i32
@@ -1988,9 +1974,7 @@ func.func @xembox1(%arg0: !fir.ref<!fir.array<?x!fir.char<1, 10>>>) {
19881974

19891975
// CHECK-LABEL: llvm.func @xembox1(%{{.*}}: !llvm.ptr) {
19901976
// CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : i64) : i64
1991-
// CHECK: %[[NULL:.*]] = llvm.mlir.zero : !llvm.ptr
1992-
// CHECK: %[[GEP:.*]] = llvm.getelementptr %[[NULL]][1]
1993-
// CHECK: %[[ELEM_LEN_I64:.*]] = llvm.ptrtoint %[[GEP]] : !llvm.ptr to i64
1977+
// CHECK: %[[ELEM_LEN_I64:.*]] = llvm.mlir.constant(10 : i64) : i64
19941978
// CHECK: %{{.*}} = llvm.insertvalue %[[ELEM_LEN_I64]], %{{.*}}[1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>
19951979
// CHECK: %[[PREV_PTROFF:.*]] = llvm.mul %[[ELEM_LEN_I64]], %[[C0]] : i64
19961980

@@ -2042,9 +2026,7 @@ func.func private @_QPxb(!fir.box<!fir.array<?x?xf64>>)
20422026
// AMDGPU: %[[AR:.*]] = llvm.alloca %[[ARR_SIZE]] x f64 {bindc_name = "arr"} : (i64) -> !llvm.ptr<5>
20432027
// AMDGPU: %[[ARR:.*]] = llvm.addrspacecast %[[AR]] : !llvm.ptr<5> to !llvm.ptr
20442028
// CHECK: %[[TYPE_CODE:.*]] = llvm.mlir.constant(28 : i32) : i32
2045-
// CHECK: %[[NULL:.*]] = llvm.mlir.zero : !llvm.ptr
2046-
// CHECK: %[[GEP:.*]] = llvm.getelementptr %[[NULL]][1]
2047-
// CHECK: %[[ELEM_LEN_I64:.*]] = llvm.ptrtoint %[[GEP]] : !llvm.ptr to i64
2029+
// CHECK: %[[ELEM_LEN_I64:.*]] = llvm.mlir.constant(8 : i64) : i64
20482030
// CHECK: %[[BOX0:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)>
20492031
// CHECK: %[[BOX1:.*]] = llvm.insertvalue %[[ELEM_LEN_I64]], %[[BOX0]][1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<2 x array<3 x i64>>)>
20502032
// CHECK: %[[VERSION:.*]] = llvm.mlir.constant(20240719 : i32) : i32
@@ -2126,9 +2108,7 @@ func.func private @_QPtest_dt_callee(%arg0: !fir.box<!fir.array<?xi32>>)
21262108
// CHECK: %[[C10:.*]] = llvm.mlir.constant(10 : i64) : i64
21272109
// CHECK: %[[C2:.*]] = llvm.mlir.constant(2 : i64) : i64
21282110
// CHECK: %[[TYPE_CODE:.*]] = llvm.mlir.constant(9 : i32) : i32
2129-
// CHECK: %[[NULL:.*]] = llvm.mlir.zero : !llvm.ptr
2130-
// CHECK: %[[GEP:.*]] = llvm.getelementptr %[[NULL]][1]
2131-
// CHECK: %[[ELEM_LEN_I64:.*]] = llvm.ptrtoint %[[GEP]] : !llvm.ptr to i64
2111+
// CHECK: %[[ELEM_LEN_I64:.*]] = llvm.mlir.constant(4 : i64) : i64
21322112
// CHECK: %[[BOX0:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>
21332113
// CHECK: %[[BOX1:.*]] = llvm.insertvalue %[[ELEM_LEN_I64]], %[[BOX0]][1] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>
21342114
// CHECK: %[[VERSION:.*]] = llvm.mlir.constant(20240719 : i32) : i32
@@ -2146,9 +2126,7 @@ func.func private @_QPtest_dt_callee(%arg0: !fir.box<!fir.array<?xi32>>)
21462126
// CHECK: %[[BOX6:.*]] = llvm.insertvalue %[[F18ADDENDUM_I8]], %[[BOX5]][6] : !llvm.struct<(ptr, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, array<1 x array<3 x i64>>)>
21472127
// CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : i64) : i64
21482128
// CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : i64) : i64
2149-
// CHECK: %[[ELE_TYPE:.*]] = llvm.mlir.zero : !llvm.ptr
2150-
// CHECK: %[[GEP_DTYPE_SIZE:.*]] = llvm.getelementptr %[[ELE_TYPE]][1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"_QFtest_dt_sliceTt", (i32, i32)>
2151-
// CHECK: %[[PTRTOINT_DTYPE_SIZE:.*]] = llvm.ptrtoint %[[GEP_DTYPE_SIZE]] : !llvm.ptr to i64
2129+
// CHECK: %[[PTRTOINT_DTYPE_SIZE:.*]] = llvm.mlir.constant(8 : i64) : i64
21522130
// CHECK: %[[ADJUSTED_OFFSET:.*]] = llvm.sub %[[C1]], %[[ONE]] : i64
21532131
// CHECK: %[[EXT_SUB:.*]] = llvm.sub %[[C10]], %[[C1]] : i64
21542132
// CHECK: %[[EXT_ADD:.*]] = llvm.add %[[EXT_SUB]], %[[C2]] : i64
@@ -2429,9 +2407,7 @@ func.func @test_rebox_1(%arg0: !fir.box<!fir.array<?x?xf32>>) {
24292407
//CHECK: %[[SIX:.*]] = llvm.mlir.constant(6 : index) : i64
24302408
//CHECK: %[[EIGHTY:.*]] = llvm.mlir.constant(80 : index) : i64
24312409
//CHECK: %[[FLOAT_TYPE:.*]] = llvm.mlir.constant(27 : i32) : i32
2432-
//CHECK: %[[NULL:.*]] = llvm.mlir.zero : !llvm.ptr
2433-
//CHECK: %[[GEP:.*]] = llvm.getelementptr %[[NULL]][1]
2434-
//CHECK: %[[ELEM_SIZE_I64:.*]] = llvm.ptrtoint %[[GEP]] : !llvm.ptr to i64
2410+
//CHECK: %[[ELEM_SIZE_I64:.*]] = llvm.mlir.constant(4 : i64) : i64
24352411
//CHECK: %[[EXTRA_GEP:.*]] = llvm.getelementptr %[[ARG0]][0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<2 x array<3 x i64>>)>
24362412
//CHECK: %[[EXTRA:.*]] = llvm.load %[[EXTRA_GEP]] : !llvm.ptr -> i8
24372413
//CHECK: %[[RBOX:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>)>
@@ -2504,9 +2480,7 @@ func.func @foo(%arg0: !fir.box<!fir.array<?x!fir.type<t{i:i32,c:!fir.char<1,10>}
25042480
//CHECK: %[[COMPONENT_OFFSET_1:.*]] = llvm.mlir.constant(1 : i64) : i64
25052481
//CHECK: %[[ELEM_COUNT:.*]] = llvm.mlir.constant(7 : i64) : i64
25062482
//CHECK: %[[TYPE_CHAR:.*]] = llvm.mlir.constant(40 : i32) : i32
2507-
//CHECK: %[[NULL:.*]] = llvm.mlir.zero : !llvm.ptr
2508-
//CHECK: %[[GEP:.*]] = llvm.getelementptr %[[NULL]][1]
2509-
//CHECK: %[[CHAR_SIZE:.*]] = llvm.ptrtoint %[[GEP]] : !llvm.ptr to i64
2483+
//CHECK: %[[CHAR_SIZE:.*]] = llvm.mlir.constant(1 : i64) : i64
25102484
//CHECK: %[[ELEM_SIZE:.*]] = llvm.mul %[[CHAR_SIZE]], %[[ELEM_COUNT]]
25112485
//CHECK: %[[EXTRA_GEP:.*]] = llvm.getelementptr %[[ARG0]][0, 6] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, i64, i32, i8, i8, i8, i8, array<1 x array<3 x i64>>, ptr, array<1 x i64>)>
25122486
//CHECK: %[[EXTRA:.*]] = llvm.load %[[EXTRA_GEP]] : !llvm.ptr -> i8

‎flang/test/Fir/copy-codegen.fir‎

Lines changed: 4 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -12,10 +12,8 @@ func.func @test_copy_1(%arg0: !fir.ref<!t>, %arg1: !fir.ref<!t>) {
1212
// CHECK-LABEL: llvm.func @test_copy_1(
1313
// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !llvm.ptr,
1414
// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !llvm.ptr) {
15-
// CHECK: %[[VAL_2:.*]] = llvm.mlir.zero : !llvm.ptr
16-
// CHECK: %[[VAL_3:.*]] = llvm.getelementptr %[[VAL_2]][1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"sometype", (array<9 x i32>)>
17-
// CHECK: %[[VAL_4:.*]] = llvm.ptrtoint %[[VAL_3]] : !llvm.ptr to i64
18-
// CHECK: "llvm.intr.memcpy"(%[[VAL_1]], %[[VAL_0]], %[[VAL_4]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> ()
15+
// CHECK: %[[VAL_2:.*]] = llvm.mlir.constant(36 : i64) : i64
16+
// CHECK: "llvm.intr.memcpy"(%[[VAL_1]], %[[VAL_0]], %[[VAL_2]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> ()
1917
// CHECK: llvm.return
2018
// CHECK: }
2119

@@ -26,10 +24,8 @@ func.func @test_copy_2(%arg0: !fir.ref<!t>, %arg1: !fir.ref<!t>) {
2624
// CHECK-LABEL: llvm.func @test_copy_2(
2725
// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !llvm.ptr,
2826
// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !llvm.ptr) {
29-
// CHECK: %[[VAL_2:.*]] = llvm.mlir.zero : !llvm.ptr
30-
// CHECK: %[[VAL_3:.*]] = llvm.getelementptr %[[VAL_2]][1] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"sometype", (array<9 x i32>)>
31-
// CHECK: %[[VAL_4:.*]] = llvm.ptrtoint %[[VAL_3]] : !llvm.ptr to i64
32-
// CHECK: "llvm.intr.memmove"(%[[VAL_1]], %[[VAL_0]], %[[VAL_4]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> ()
27+
// CHECK: %[[VAL_2:.*]] = llvm.mlir.constant(36 : i64) : i64
28+
// CHECK: "llvm.intr.memmove"(%[[VAL_1]], %[[VAL_0]], %[[VAL_2]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> ()
3329
// CHECK: llvm.return
3430
// CHECK: }
3531
}

0 commit comments

Comments
 (0)