1 //===- ReductionTest.cpp -- Reduction runtime builder unit tests ----------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "flang/Optimizer/Builder/Runtime/Reduction.h"
10 #include "RuntimeCallTestBase.h"
11 #include "gtest/gtest.h"
12
TEST_F(RuntimeCallTest,genAllTest)13 TEST_F(RuntimeCallTest, genAllTest) {
14 mlir::Location loc = firBuilder->getUnknownLoc();
15 mlir::Value undef = firBuilder->create<fir::UndefOp>(loc, seqTy10);
16 mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
17 mlir::Value all = fir::runtime::genAll(*firBuilder, loc, undef, dim);
18 checkCallOp(all.getDefiningOp(), "_FortranAAll", 2);
19 }
20
TEST_F(RuntimeCallTest,genAllDescriptorTest)21 TEST_F(RuntimeCallTest, genAllDescriptorTest) {
22 mlir::Location loc = firBuilder->getUnknownLoc();
23 mlir::Value result = firBuilder->create<fir::UndefOp>(loc, seqTy10);
24 mlir::Value mask = firBuilder->create<fir::UndefOp>(loc, seqTy10);
25 mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
26 fir::runtime::genAllDescriptor(*firBuilder, loc, result, mask, dim);
27 checkCallOpFromResultBox(result, "_FortranAAllDim", 3);
28 }
29
TEST_F(RuntimeCallTest,genAnyTest)30 TEST_F(RuntimeCallTest, genAnyTest) {
31 mlir::Location loc = firBuilder->getUnknownLoc();
32 mlir::Value undef = firBuilder->create<fir::UndefOp>(loc, seqTy10);
33 mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
34 mlir::Value any = fir::runtime::genAny(*firBuilder, loc, undef, dim);
35 checkCallOp(any.getDefiningOp(), "_FortranAAny", 2);
36 }
37
TEST_F(RuntimeCallTest,genAnyDescriptorTest)38 TEST_F(RuntimeCallTest, genAnyDescriptorTest) {
39 mlir::Location loc = firBuilder->getUnknownLoc();
40 mlir::Value result = firBuilder->create<fir::UndefOp>(loc, seqTy10);
41 mlir::Value mask = firBuilder->create<fir::UndefOp>(loc, seqTy10);
42 mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
43 fir::runtime::genAnyDescriptor(*firBuilder, loc, result, mask, dim);
44 checkCallOpFromResultBox(result, "_FortranAAnyDim", 3);
45 }
46
TEST_F(RuntimeCallTest,genCountTest)47 TEST_F(RuntimeCallTest, genCountTest) {
48 mlir::Location loc = firBuilder->getUnknownLoc();
49 mlir::Value undef = firBuilder->create<fir::UndefOp>(loc, seqTy10);
50 mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
51 mlir::Value count = fir::runtime::genCount(*firBuilder, loc, undef, dim);
52 checkCallOp(count.getDefiningOp(), "_FortranACount", 2);
53 }
54
TEST_F(RuntimeCallTest,genCountDimTest)55 TEST_F(RuntimeCallTest, genCountDimTest) {
56 mlir::Location loc = firBuilder->getUnknownLoc();
57 mlir::Value result = firBuilder->create<fir::UndefOp>(loc, seqTy10);
58 mlir::Value mask = firBuilder->create<fir::UndefOp>(loc, seqTy10);
59 mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
60 mlir::Value kind = firBuilder->createIntegerConstant(loc, i32Ty, 1);
61 fir::runtime::genCountDim(*firBuilder, loc, result, mask, dim, kind);
62 checkCallOpFromResultBox(result, "_FortranACountDim", 4);
63 }
64
testGenMaxVal(fir::FirOpBuilder & builder,mlir::Type eleTy,llvm::StringRef fctName)65 void testGenMaxVal(
66 fir::FirOpBuilder &builder, mlir::Type eleTy, llvm::StringRef fctName) {
67 mlir::Location loc = builder.getUnknownLoc();
68 mlir::Type seqTy =
69 fir::SequenceType::get(fir::SequenceType::Shape(1, 10), eleTy);
70 mlir::Type refSeqTy = fir::ReferenceType::get(seqTy);
71 mlir::Value undef = builder.create<fir::UndefOp>(loc, refSeqTy);
72 mlir::Value mask = builder.create<fir::UndefOp>(loc, seqTy);
73 mlir::Value max = fir::runtime::genMaxval(builder, loc, undef, mask);
74 checkCallOp(max.getDefiningOp(), fctName, 3);
75 }
76
TEST_F(RuntimeCallTest,genMaxValTest)77 TEST_F(RuntimeCallTest, genMaxValTest) {
78 testGenMaxVal(*firBuilder, f32Ty, "_FortranAMaxvalReal4");
79 testGenMaxVal(*firBuilder, f64Ty, "_FortranAMaxvalReal8");
80 testGenMaxVal(*firBuilder, f80Ty, "_FortranAMaxvalReal10");
81 testGenMaxVal(*firBuilder, f128Ty, "_FortranAMaxvalReal16");
82
83 testGenMaxVal(*firBuilder, i8Ty, "_FortranAMaxvalInteger1");
84 testGenMaxVal(*firBuilder, i16Ty, "_FortranAMaxvalInteger2");
85 testGenMaxVal(*firBuilder, i32Ty, "_FortranAMaxvalInteger4");
86 testGenMaxVal(*firBuilder, i64Ty, "_FortranAMaxvalInteger8");
87 testGenMaxVal(*firBuilder, i128Ty, "_FortranAMaxvalInteger16");
88 }
89
testGenMinVal(fir::FirOpBuilder & builder,mlir::Type eleTy,llvm::StringRef fctName)90 void testGenMinVal(
91 fir::FirOpBuilder &builder, mlir::Type eleTy, llvm::StringRef fctName) {
92 mlir::Location loc = builder.getUnknownLoc();
93 mlir::Type seqTy =
94 fir::SequenceType::get(fir::SequenceType::Shape(1, 10), eleTy);
95 mlir::Type refSeqTy = fir::ReferenceType::get(seqTy);
96 mlir::Value undef = builder.create<fir::UndefOp>(loc, refSeqTy);
97 mlir::Value mask = builder.create<fir::UndefOp>(loc, seqTy);
98 mlir::Value min = fir::runtime::genMinval(builder, loc, undef, mask);
99 checkCallOp(min.getDefiningOp(), fctName, 3);
100 }
101
TEST_F(RuntimeCallTest,genMinValTest)102 TEST_F(RuntimeCallTest, genMinValTest) {
103 testGenMinVal(*firBuilder, f32Ty, "_FortranAMinvalReal4");
104 testGenMinVal(*firBuilder, f64Ty, "_FortranAMinvalReal8");
105 testGenMinVal(*firBuilder, f80Ty, "_FortranAMinvalReal10");
106 testGenMinVal(*firBuilder, f128Ty, "_FortranAMinvalReal16");
107
108 testGenMinVal(*firBuilder, i8Ty, "_FortranAMinvalInteger1");
109 testGenMinVal(*firBuilder, i16Ty, "_FortranAMinvalInteger2");
110 testGenMinVal(*firBuilder, i32Ty, "_FortranAMinvalInteger4");
111 testGenMinVal(*firBuilder, i64Ty, "_FortranAMinvalInteger8");
112 testGenMinVal(*firBuilder, i128Ty, "_FortranAMinvalInteger16");
113 }
114
TEST_F(RuntimeCallTest,genParityTest)115 TEST_F(RuntimeCallTest, genParityTest) {
116 mlir::Location loc = firBuilder->getUnknownLoc();
117 mlir::Value undef = firBuilder->create<fir::UndefOp>(loc, seqTy10);
118 mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
119 mlir::Value parity = fir::runtime::genParity(*firBuilder, loc, undef, dim);
120 checkCallOp(parity.getDefiningOp(), "_FortranAParity", 2);
121 }
122
TEST_F(RuntimeCallTest,genParityDescriptorTest)123 TEST_F(RuntimeCallTest, genParityDescriptorTest) {
124 mlir::Location loc = firBuilder->getUnknownLoc();
125 mlir::Value result = firBuilder->create<fir::UndefOp>(loc, seqTy10);
126 mlir::Value mask = firBuilder->create<fir::UndefOp>(loc, seqTy10);
127 mlir::Value dim = firBuilder->createIntegerConstant(loc, i32Ty, 1);
128 fir::runtime::genParityDescriptor(*firBuilder, loc, result, mask, dim);
129 checkCallOpFromResultBox(result, "_FortranAParityDim", 3);
130 }
131
testGenSum(fir::FirOpBuilder & builder,mlir::Type eleTy,llvm::StringRef fctName)132 void testGenSum(
133 fir::FirOpBuilder &builder, mlir::Type eleTy, llvm::StringRef fctName) {
134 mlir::Location loc = builder.getUnknownLoc();
135 mlir::Type seqTy =
136 fir::SequenceType::get(fir::SequenceType::Shape(1, 10), eleTy);
137 mlir::Type refSeqTy = fir::ReferenceType::get(seqTy);
138 mlir::Value undef = builder.create<fir::UndefOp>(loc, refSeqTy);
139 mlir::Value mask = builder.create<fir::UndefOp>(loc, seqTy);
140 mlir::Value result = builder.create<fir::UndefOp>(loc, seqTy);
141 mlir::Value sum = fir::runtime::genSum(builder, loc, undef, mask, result);
142 if (fir::isa_complex(eleTy))
143 checkCallOpFromResultBox(result, fctName, 4);
144 else
145 checkCallOp(sum.getDefiningOp(), fctName, 3);
146 }
147
TEST_F(RuntimeCallTest,genSumTest)148 TEST_F(RuntimeCallTest, genSumTest) {
149 testGenSum(*firBuilder, f32Ty, "_FortranASumReal4");
150 testGenSum(*firBuilder, f64Ty, "_FortranASumReal8");
151 testGenSum(*firBuilder, f80Ty, "_FortranASumReal10");
152 testGenSum(*firBuilder, f128Ty, "_FortranASumReal16");
153 testGenSum(*firBuilder, i8Ty, "_FortranASumInteger1");
154 testGenSum(*firBuilder, i16Ty, "_FortranASumInteger2");
155 testGenSum(*firBuilder, i32Ty, "_FortranASumInteger4");
156 testGenSum(*firBuilder, i64Ty, "_FortranASumInteger8");
157 testGenSum(*firBuilder, i128Ty, "_FortranASumInteger16");
158 testGenSum(*firBuilder, c4Ty, "_FortranACppSumComplex4");
159 testGenSum(*firBuilder, c8Ty, "_FortranACppSumComplex8");
160 testGenSum(*firBuilder, c10Ty, "_FortranACppSumComplex10");
161 testGenSum(*firBuilder, c16Ty, "_FortranACppSumComplex16");
162 }
163
testGenProduct(fir::FirOpBuilder & builder,mlir::Type eleTy,llvm::StringRef fctName)164 void testGenProduct(
165 fir::FirOpBuilder &builder, mlir::Type eleTy, llvm::StringRef fctName) {
166 mlir::Location loc = builder.getUnknownLoc();
167 mlir::Type seqTy =
168 fir::SequenceType::get(fir::SequenceType::Shape(1, 10), eleTy);
169 mlir::Type refSeqTy = fir::ReferenceType::get(seqTy);
170 mlir::Value undef = builder.create<fir::UndefOp>(loc, refSeqTy);
171 mlir::Value mask = builder.create<fir::UndefOp>(loc, seqTy);
172 mlir::Value result = builder.create<fir::UndefOp>(loc, seqTy);
173 mlir::Value prod =
174 fir::runtime::genProduct(builder, loc, undef, mask, result);
175 if (fir::isa_complex(eleTy))
176 checkCallOpFromResultBox(result, fctName, 4);
177 else
178 checkCallOp(prod.getDefiningOp(), fctName, 3);
179 }
180
TEST_F(RuntimeCallTest,genProduct)181 TEST_F(RuntimeCallTest, genProduct) {
182 testGenProduct(*firBuilder, f32Ty, "_FortranAProductReal4");
183 testGenProduct(*firBuilder, f64Ty, "_FortranAProductReal8");
184 testGenProduct(*firBuilder, f80Ty, "_FortranAProductReal10");
185 testGenProduct(*firBuilder, f128Ty, "_FortranAProductReal16");
186 testGenProduct(*firBuilder, i8Ty, "_FortranAProductInteger1");
187 testGenProduct(*firBuilder, i16Ty, "_FortranAProductInteger2");
188 testGenProduct(*firBuilder, i32Ty, "_FortranAProductInteger4");
189 testGenProduct(*firBuilder, i64Ty, "_FortranAProductInteger8");
190 testGenProduct(*firBuilder, i128Ty, "_FortranAProductInteger16");
191 testGenProduct(*firBuilder, c4Ty, "_FortranACppProductComplex4");
192 testGenProduct(*firBuilder, c8Ty, "_FortranACppProductComplex8");
193 testGenProduct(*firBuilder, c10Ty, "_FortranACppProductComplex10");
194 testGenProduct(*firBuilder, c16Ty, "_FortranACppProductComplex16");
195 }
196
testGenDotProduct(fir::FirOpBuilder & builder,mlir::Type eleTy,llvm::StringRef fctName)197 void testGenDotProduct(
198 fir::FirOpBuilder &builder, mlir::Type eleTy, llvm::StringRef fctName) {
199 mlir::Location loc = builder.getUnknownLoc();
200 mlir::Type seqTy =
201 fir::SequenceType::get(fir::SequenceType::Shape(1, 10), eleTy);
202 mlir::Type refSeqTy = fir::ReferenceType::get(seqTy);
203 mlir::Value a = builder.create<fir::UndefOp>(loc, refSeqTy);
204 mlir::Value b = builder.create<fir::UndefOp>(loc, refSeqTy);
205 mlir::Value result =
206 builder.create<fir::UndefOp>(loc, fir::ReferenceType::get(eleTy));
207 mlir::Value prod = fir::runtime::genDotProduct(builder, loc, a, b, result);
208 if (fir::isa_complex(eleTy))
209 checkCallOpFromResultBox(result, fctName, 3);
210 else
211 checkCallOp(prod.getDefiningOp(), fctName, 2);
212 }
213
TEST_F(RuntimeCallTest,genDotProduct)214 TEST_F(RuntimeCallTest, genDotProduct) {
215 testGenDotProduct(*firBuilder, f32Ty, "_FortranADotProductReal4");
216 testGenDotProduct(*firBuilder, f64Ty, "_FortranADotProductReal8");
217 testGenDotProduct(*firBuilder, f80Ty, "_FortranADotProductReal10");
218 testGenDotProduct(*firBuilder, f128Ty, "_FortranADotProductReal16");
219 testGenDotProduct(*firBuilder, i8Ty, "_FortranADotProductInteger1");
220 testGenDotProduct(*firBuilder, i16Ty, "_FortranADotProductInteger2");
221 testGenDotProduct(*firBuilder, i32Ty, "_FortranADotProductInteger4");
222 testGenDotProduct(*firBuilder, i64Ty, "_FortranADotProductInteger8");
223 testGenDotProduct(*firBuilder, i128Ty, "_FortranADotProductInteger16");
224 testGenDotProduct(*firBuilder, c4Ty, "_FortranACppDotProductComplex4");
225 testGenDotProduct(*firBuilder, c8Ty, "_FortranACppDotProductComplex8");
226 testGenDotProduct(*firBuilder, c10Ty, "_FortranACppDotProductComplex10");
227 testGenDotProduct(*firBuilder, c16Ty, "_FortranACppDotProductComplex16");
228 }
229
checkGenMxxloc(fir::FirOpBuilder & builder,mlir::Type eleTy,void (* genFct)(fir::FirOpBuilder &,mlir::Location,mlir::Value,mlir::Value,mlir::Value,mlir::Value,mlir::Value),llvm::StringRef fctName,unsigned nbArgs)230 void checkGenMxxloc(fir::FirOpBuilder &builder, mlir::Type eleTy,
231 void (*genFct)(fir::FirOpBuilder &, mlir::Location, mlir::Value,
232 mlir::Value, mlir::Value, mlir::Value, mlir::Value),
233 llvm::StringRef fctName, unsigned nbArgs) {
234 mlir::Location loc = builder.getUnknownLoc();
235 mlir::Type i32Ty = builder.getI32Type();
236 mlir::Type seqTy =
237 fir::SequenceType::get(fir::SequenceType::Shape(1, 10), eleTy);
238 mlir::Type refSeqTy = fir::ReferenceType::get(seqTy);
239 mlir::Value a = builder.create<fir::UndefOp>(loc, refSeqTy);
240 mlir::Value result = builder.create<fir::UndefOp>(loc, seqTy);
241 mlir::Value mask = builder.create<fir::UndefOp>(loc, seqTy);
242 mlir::Value kind = builder.createIntegerConstant(loc, i32Ty, 1);
243 mlir::Value back = builder.createIntegerConstant(loc, i32Ty, 1);
244 genFct(builder, loc, result, a, mask, kind, back);
245 checkCallOpFromResultBox(result, fctName, nbArgs);
246 }
247
TEST_F(RuntimeCallTest,genMaxlocTest)248 TEST_F(RuntimeCallTest, genMaxlocTest) {
249 checkGenMxxloc(*firBuilder, char1Ty, fir::runtime::genMaxloc,
250 "_FortranAMaxlocCharacter", 5);
251 checkGenMxxloc(*firBuilder, char2Ty, fir::runtime::genMaxloc,
252 "_FortranAMaxlocCharacter", 5);
253 checkGenMxxloc(*firBuilder, char4Ty, fir::runtime::genMaxloc,
254 "_FortranAMaxlocCharacter", 5);
255 checkGenMxxloc(
256 *firBuilder, i8Ty, fir::runtime::genMaxloc, "_FortranAMaxlocInteger1", 5);
257 checkGenMxxloc(*firBuilder, i16Ty, fir::runtime::genMaxloc,
258 "_FortranAMaxlocInteger2", 5);
259 checkGenMxxloc(*firBuilder, i32Ty, fir::runtime::genMaxloc,
260 "_FortranAMaxlocInteger4", 5);
261 checkGenMxxloc(*firBuilder, i64Ty, fir::runtime::genMaxloc,
262 "_FortranAMaxlocInteger8", 5);
263 checkGenMxxloc(*firBuilder, i128Ty, fir::runtime::genMaxloc,
264 "_FortranAMaxlocInteger16", 5);
265 checkGenMxxloc(
266 *firBuilder, f32Ty, fir::runtime::genMaxloc, "_FortranAMaxlocReal4", 5);
267 checkGenMxxloc(
268 *firBuilder, f64Ty, fir::runtime::genMaxloc, "_FortranAMaxlocReal8", 5);
269 checkGenMxxloc(
270 *firBuilder, f80Ty, fir::runtime::genMaxloc, "_FortranAMaxlocReal10", 5);
271 checkGenMxxloc(
272 *firBuilder, f128Ty, fir::runtime::genMaxloc, "_FortranAMaxlocReal16", 5);
273 }
274
TEST_F(RuntimeCallTest,genMinlocTest)275 TEST_F(RuntimeCallTest, genMinlocTest) {
276 checkGenMxxloc(*firBuilder, char1Ty, fir::runtime::genMinloc,
277 "_FortranAMinlocCharacter", 5);
278 checkGenMxxloc(*firBuilder, char2Ty, fir::runtime::genMinloc,
279 "_FortranAMinlocCharacter", 5);
280 checkGenMxxloc(*firBuilder, char4Ty, fir::runtime::genMinloc,
281 "_FortranAMinlocCharacter", 5);
282 checkGenMxxloc(
283 *firBuilder, i8Ty, fir::runtime::genMinloc, "_FortranAMinlocInteger1", 5);
284 checkGenMxxloc(*firBuilder, i16Ty, fir::runtime::genMinloc,
285 "_FortranAMinlocInteger2", 5);
286 checkGenMxxloc(*firBuilder, i32Ty, fir::runtime::genMinloc,
287 "_FortranAMinlocInteger4", 5);
288 checkGenMxxloc(*firBuilder, i64Ty, fir::runtime::genMinloc,
289 "_FortranAMinlocInteger8", 5);
290 checkGenMxxloc(*firBuilder, i128Ty, fir::runtime::genMinloc,
291 "_FortranAMinlocInteger16", 5);
292 checkGenMxxloc(
293 *firBuilder, f32Ty, fir::runtime::genMinloc, "_FortranAMinlocReal4", 5);
294 checkGenMxxloc(
295 *firBuilder, f64Ty, fir::runtime::genMinloc, "_FortranAMinlocReal8", 5);
296 checkGenMxxloc(
297 *firBuilder, f80Ty, fir::runtime::genMinloc, "_FortranAMinlocReal10", 5);
298 checkGenMxxloc(
299 *firBuilder, f128Ty, fir::runtime::genMinloc, "_FortranAMinlocReal16", 5);
300 }
301
checkGenMxxlocDim(fir::FirOpBuilder & builder,void (* genFct)(fir::FirOpBuilder &,mlir::Location,mlir::Value,mlir::Value,mlir::Value,mlir::Value,mlir::Value,mlir::Value),llvm::StringRef fctName,unsigned nbArgs)302 void checkGenMxxlocDim(fir::FirOpBuilder &builder,
303 void (*genFct)(fir::FirOpBuilder &, mlir::Location, mlir::Value,
304 mlir::Value, mlir::Value, mlir::Value, mlir::Value, mlir::Value),
305 llvm::StringRef fctName, unsigned nbArgs) {
306 mlir::Location loc = builder.getUnknownLoc();
307 auto i32Ty = builder.getI32Type();
308 mlir::Type seqTy =
309 fir::SequenceType::get(fir::SequenceType::Shape(1, 10), i32Ty);
310 mlir::Type refSeqTy = fir::ReferenceType::get(seqTy);
311 mlir::Value a = builder.create<fir::UndefOp>(loc, refSeqTy);
312 mlir::Value result = builder.create<fir::UndefOp>(loc, seqTy);
313 mlir::Value mask = builder.create<fir::UndefOp>(loc, seqTy);
314 mlir::Value kind = builder.createIntegerConstant(loc, i32Ty, 1);
315 mlir::Value dim = builder.createIntegerConstant(loc, i32Ty, 1);
316 mlir::Value back = builder.createIntegerConstant(loc, i32Ty, 1);
317 genFct(builder, loc, result, a, dim, mask, kind, back);
318 checkCallOpFromResultBox(result, fctName, nbArgs);
319 }
320
TEST_F(RuntimeCallTest,genMaxlocDimTest)321 TEST_F(RuntimeCallTest, genMaxlocDimTest) {
322 checkGenMxxlocDim(
323 *firBuilder, fir::runtime::genMaxlocDim, "_FortranAMaxlocDim", 6);
324 }
325
TEST_F(RuntimeCallTest,genMinlocDimTest)326 TEST_F(RuntimeCallTest, genMinlocDimTest) {
327 checkGenMxxlocDim(
328 *firBuilder, fir::runtime::genMinlocDim, "_FortranAMinlocDim", 6);
329 }
330
checkGenMxxvalChar(fir::FirOpBuilder & builder,void (* genFct)(fir::FirOpBuilder &,mlir::Location,mlir::Value,mlir::Value,mlir::Value),llvm::StringRef fctName,unsigned nbArgs)331 void checkGenMxxvalChar(fir::FirOpBuilder &builder,
332 void (*genFct)(fir::FirOpBuilder &, mlir::Location, mlir::Value,
333 mlir::Value, mlir::Value),
334 llvm::StringRef fctName, unsigned nbArgs) {
335 mlir::Location loc = builder.getUnknownLoc();
336 auto i32Ty = builder.getI32Type();
337 mlir::Type seqTy =
338 fir::SequenceType::get(fir::SequenceType::Shape(1, 10), i32Ty);
339 mlir::Type refSeqTy = fir::ReferenceType::get(seqTy);
340 mlir::Value a = builder.create<fir::UndefOp>(loc, refSeqTy);
341 mlir::Value result = builder.create<fir::UndefOp>(loc, seqTy);
342 mlir::Value mask = builder.create<fir::UndefOp>(loc, seqTy);
343 genFct(builder, loc, result, a, mask);
344 checkCallOpFromResultBox(result, fctName, nbArgs);
345 }
346
TEST_F(RuntimeCallTest,genMaxvalCharTest)347 TEST_F(RuntimeCallTest, genMaxvalCharTest) {
348 checkGenMxxvalChar(
349 *firBuilder, fir::runtime::genMaxvalChar, "_FortranAMaxvalCharacter", 3);
350 }
351
TEST_F(RuntimeCallTest,genMinvalCharTest)352 TEST_F(RuntimeCallTest, genMinvalCharTest) {
353 checkGenMxxvalChar(
354 *firBuilder, fir::runtime::genMinvalChar, "_FortranAMinvalCharacter", 3);
355 }
356
checkGen4argsDim(fir::FirOpBuilder & builder,void (* genFct)(fir::FirOpBuilder &,mlir::Location,mlir::Value,mlir::Value,mlir::Value,mlir::Value),llvm::StringRef fctName,unsigned nbArgs)357 void checkGen4argsDim(fir::FirOpBuilder &builder,
358 void (*genFct)(fir::FirOpBuilder &, mlir::Location, mlir::Value,
359 mlir::Value, mlir::Value, mlir::Value),
360 llvm::StringRef fctName, unsigned nbArgs) {
361 mlir::Location loc = builder.getUnknownLoc();
362 auto i32Ty = builder.getI32Type();
363 mlir::Type seqTy =
364 fir::SequenceType::get(fir::SequenceType::Shape(1, 10), i32Ty);
365 mlir::Type refSeqTy = fir::ReferenceType::get(seqTy);
366 mlir::Value a = builder.create<fir::UndefOp>(loc, refSeqTy);
367 mlir::Value result = builder.create<fir::UndefOp>(loc, seqTy);
368 mlir::Value mask = builder.create<fir::UndefOp>(loc, seqTy);
369 mlir::Value dim = builder.createIntegerConstant(loc, i32Ty, 1);
370 genFct(builder, loc, result, a, dim, mask);
371 checkCallOpFromResultBox(result, fctName, nbArgs);
372 }
373
TEST_F(RuntimeCallTest,genMaxvalDimTest)374 TEST_F(RuntimeCallTest, genMaxvalDimTest) {
375 checkGen4argsDim(
376 *firBuilder, fir::runtime::genMaxvalDim, "_FortranAMaxvalDim", 4);
377 }
378
TEST_F(RuntimeCallTest,genMinvalDimTest)379 TEST_F(RuntimeCallTest, genMinvalDimTest) {
380 checkGen4argsDim(
381 *firBuilder, fir::runtime::genMinvalDim, "_FortranAMinvalDim", 4);
382 }
383
TEST_F(RuntimeCallTest,genProductDimTest)384 TEST_F(RuntimeCallTest, genProductDimTest) {
385 checkGen4argsDim(
386 *firBuilder, fir::runtime::genProductDim, "_FortranAProductDim", 4);
387 }
388
TEST_F(RuntimeCallTest,genSumDimTest)389 TEST_F(RuntimeCallTest, genSumDimTest) {
390 checkGen4argsDim(*firBuilder, fir::runtime::genSumDim, "_FortranASumDim", 4);
391 }
392