Skip to content

Commit 46f6df0

Browse files
maksleventalmakslevental
authored
[mlir][NFC] update flang/Optimizer/Transforms create APIs (11/n) (#149915)
See #147168 for more info.
1 parent a7d9365 commit 46f6df0

22 files changed

+517
-491
lines changed

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

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -137,9 +137,9 @@ class CallConversion : public mlir::OpRewritePattern<Op> {
137137
auto buffer = saveResult.getMemref();
138138
mlir::Value arg = buffer;
139139
if (mustEmboxResult(result.getType(), shouldBoxResult))
140-
arg = rewriter.create<fir::EmboxOp>(
141-
loc, argType, buffer, saveResult.getShape(), /*slice*/ mlir::Value{},
142-
saveResult.getTypeparams());
140+
arg = fir::EmboxOp::create(rewriter, loc, argType, buffer,
141+
saveResult.getShape(), /*slice*/ mlir::Value{},
142+
saveResult.getTypeparams());
143143

144144
llvm::SmallVector<mlir::Type> newResultTypes;
145145
bool isResultBuiltinCPtr = fir::isa_builtin_cptr_type(result.getType());
@@ -155,8 +155,8 @@ class CallConversion : public mlir::OpRewritePattern<Op> {
155155
if (!isResultBuiltinCPtr)
156156
newOperands.emplace_back(arg);
157157
newOperands.append(op.getOperands().begin(), op.getOperands().end());
158-
newOp = rewriter.create<fir::CallOp>(loc, *op.getCallee(),
159-
newResultTypes, newOperands);
158+
newOp = fir::CallOp::create(rewriter, loc, *op.getCallee(),
159+
newResultTypes, newOperands);
160160
} else {
161161
// Indirect calls.
162162
llvm::SmallVector<mlir::Type> newInputTypes;
@@ -169,13 +169,13 @@ class CallConversion : public mlir::OpRewritePattern<Op> {
169169

170170
llvm::SmallVector<mlir::Value> newOperands;
171171
newOperands.push_back(
172-
rewriter.create<fir::ConvertOp>(loc, newFuncTy, op.getOperand(0)));
172+
fir::ConvertOp::create(rewriter, loc, newFuncTy, op.getOperand(0)));
173173
if (!isResultBuiltinCPtr)
174174
newOperands.push_back(arg);
175175
newOperands.append(op.getOperands().begin() + 1,
176176
op.getOperands().end());
177-
newOp = rewriter.create<fir::CallOp>(loc, mlir::SymbolRefAttr{},
178-
newResultTypes, newOperands);
177+
newOp = fir::CallOp::create(rewriter, loc, mlir::SymbolRefAttr{},
178+
newResultTypes, newOperands);
179179
}
180180
}
181181

@@ -191,8 +191,8 @@ class CallConversion : public mlir::OpRewritePattern<Op> {
191191
passArgPos =
192192
rewriter.getI32IntegerAttr(*op.getPassArgPos() + passArgShift);
193193
// TODO: propagate argument and result attributes (need to be shifted).
194-
newOp = rewriter.create<fir::DispatchOp>(
195-
loc, newResultTypes, rewriter.getStringAttr(op.getMethod()),
194+
newOp = fir::DispatchOp::create(
195+
rewriter, loc, newResultTypes, rewriter.getStringAttr(op.getMethod()),
196196
op.getOperands()[0], newOperands, passArgPos,
197197
/*arg_attrs=*/nullptr, /*res_attrs=*/nullptr,
198198
op.getProcedureAttrsAttr());
@@ -280,7 +280,7 @@ processReturnLikeOp(OpTy ret, mlir::Value newArg,
280280
// register pass, this is possible for fir.box results, or fir.record
281281
// with no length parameters. Simply store the result in the result
282282
// storage. at the return point.
283-
rewriter.create<fir::StoreOp>(loc, resultValue, newArg);
283+
fir::StoreOp::create(rewriter, loc, resultValue, newArg);
284284
rewriter.replaceOpWithNewOp<OpTy>(ret);
285285
}
286286
// Delete result old local storage if unused.
@@ -337,8 +337,8 @@ class AddrOfOpConversion : public mlir::OpRewritePattern<fir::AddrOfOp> {
337337
newFuncTy = getCPtrFunctionType(oldFuncTy);
338338
else
339339
newFuncTy = getNewFunctionType(oldFuncTy, shouldBoxResult);
340-
auto newAddrOf = rewriter.create<fir::AddrOfOp>(addrOf.getLoc(), newFuncTy,
341-
addrOf.getSymbol());
340+
auto newAddrOf = fir::AddrOfOp::create(rewriter, addrOf.getLoc(), newFuncTy,
341+
addrOf.getSymbol());
342342
// Rather than converting all op a function pointer might transit through
343343
// (e.g calls, stores, loads, converts...), cast new type to the abstract
344344
// type. A conversion will be added when calling indirect calls of abstract
@@ -397,7 +397,7 @@ class AbstractResultOpt
397397
if (mustEmboxResult(resultType, shouldBoxResult)) {
398398
auto bufferType = fir::ReferenceType::get(resultType);
399399
rewriter.setInsertionPointToStart(&func.front());
400-
newArg = rewriter.create<fir::BoxAddrOp>(loc, bufferType, newArg);
400+
newArg = fir::BoxAddrOp::create(rewriter, loc, bufferType, newArg);
401401
}
402402
patterns.insert<ReturnOpConversion>(context, newArg);
403403
target.addDynamicallyLegalOp<mlir::func::ReturnOp>(

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

Lines changed: 7 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -60,9 +60,10 @@ class AffineLoadConversion
6060
if (!maybeExpandedMap)
6161
return failure();
6262

63-
auto coorOp = rewriter.create<fir::CoordinateOp>(
64-
op.getLoc(), fir::ReferenceType::get(op.getResult().getType()),
65-
adaptor.getMemref(), *maybeExpandedMap);
63+
auto coorOp = fir::CoordinateOp::create(
64+
rewriter, op.getLoc(),
65+
fir::ReferenceType::get(op.getResult().getType()), adaptor.getMemref(),
66+
*maybeExpandedMap);
6667

6768
rewriter.replaceOpWithNewOp<fir::LoadOp>(op, coorOp.getResult());
6869
return success();
@@ -83,8 +84,9 @@ class AffineStoreConversion
8384
if (!maybeExpandedMap)
8485
return failure();
8586

86-
auto coorOp = rewriter.create<fir::CoordinateOp>(
87-
op.getLoc(), fir::ReferenceType::get(op.getValueToStore().getType()),
87+
auto coorOp = fir::CoordinateOp::create(
88+
rewriter, op.getLoc(),
89+
fir::ReferenceType::get(op.getValueToStore().getType()),
8890
adaptor.getMemref(), *maybeExpandedMap);
8991
rewriter.replaceOpWithNewOp<fir::StoreOp>(op, adaptor.getValue(),
9092
coorOp.getResult());

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

Lines changed: 21 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -366,8 +366,9 @@ static mlir::Type coordinateArrayElement(fir::ArrayCoorOp op) {
366366
static void populateIndexArgs(fir::ArrayCoorOp acoOp, fir::ShapeOp shape,
367367
SmallVectorImpl<mlir::Value> &indexArgs,
368368
mlir::PatternRewriter &rewriter) {
369-
auto one = rewriter.create<mlir::arith::ConstantOp>(
370-
acoOp.getLoc(), rewriter.getIndexType(), rewriter.getIndexAttr(1));
369+
auto one = mlir::arith::ConstantOp::create(rewriter, acoOp.getLoc(),
370+
rewriter.getIndexType(),
371+
rewriter.getIndexAttr(1));
371372
auto extents = shape.getExtents();
372373
for (auto i = extents.begin(); i < extents.end(); i++) {
373374
indexArgs.push_back(one);
@@ -379,8 +380,9 @@ static void populateIndexArgs(fir::ArrayCoorOp acoOp, fir::ShapeOp shape,
379380
static void populateIndexArgs(fir::ArrayCoorOp acoOp, fir::ShapeShiftOp shape,
380381
SmallVectorImpl<mlir::Value> &indexArgs,
381382
mlir::PatternRewriter &rewriter) {
382-
auto one = rewriter.create<mlir::arith::ConstantOp>(
383-
acoOp.getLoc(), rewriter.getIndexType(), rewriter.getIndexAttr(1));
383+
auto one = mlir::arith::ConstantOp::create(rewriter, acoOp.getLoc(),
384+
rewriter.getIndexType(),
385+
rewriter.getIndexAttr(1));
384386
auto extents = shape.getPairs();
385387
for (auto i = extents.begin(); i < extents.end();) {
386388
indexArgs.push_back(*i++);
@@ -422,13 +424,13 @@ createAffineOps(mlir::Value arrayRef, mlir::PatternRewriter &rewriter) {
422424

423425
populateIndexArgs(acoOp, indexArgs, rewriter);
424426

425-
auto affineApply = rewriter.create<affine::AffineApplyOp>(
426-
acoOp.getLoc(), affineMap, indexArgs);
427+
auto affineApply = affine::AffineApplyOp::create(rewriter, acoOp.getLoc(),
428+
affineMap, indexArgs);
427429
auto arrayElementType = coordinateArrayElement(acoOp);
428430
auto newType =
429431
mlir::MemRefType::get({mlir::ShapedType::kDynamic}, arrayElementType);
430-
auto arrayConvert = rewriter.create<fir::ConvertOp>(acoOp.getLoc(), newType,
431-
acoOp.getMemref());
432+
auto arrayConvert = fir::ConvertOp::create(rewriter, acoOp.getLoc(), newType,
433+
acoOp.getMemref());
432434
return std::make_pair(affineApply, arrayConvert);
433435
}
434436

@@ -495,7 +497,7 @@ class AffineLoopConversion : public mlir::OpRewritePattern<fir::DoLoopOp> {
495497
affineFor.getRegionIterArgs());
496498
if (!results.empty()) {
497499
rewriter.setInsertionPointToEnd(affineFor.getBody());
498-
rewriter.create<affine::AffineYieldOp>(resultOp->getLoc(), results);
500+
affine::AffineYieldOp::create(rewriter, resultOp->getLoc(), results);
499501
}
500502
rewriter.finalizeOpModification(affineFor.getOperation());
501503

@@ -525,8 +527,8 @@ class AffineLoopConversion : public mlir::OpRewritePattern<fir::DoLoopOp> {
525527
std::pair<affine::AffineForOp, mlir::Value>
526528
positiveConstantStep(fir::DoLoopOp op, int64_t step,
527529
mlir::PatternRewriter &rewriter) const {
528-
auto affineFor = rewriter.create<affine::AffineForOp>(
529-
op.getLoc(), ValueRange(op.getLowerBound()),
530+
auto affineFor = affine::AffineForOp::create(
531+
rewriter, op.getLoc(), ValueRange(op.getLowerBound()),
530532
mlir::AffineMap::get(0, 1,
531533
mlir::getAffineSymbolExpr(0, op.getContext())),
532534
ValueRange(op.getUpperBound()),
@@ -543,24 +545,24 @@ class AffineLoopConversion : public mlir::OpRewritePattern<fir::DoLoopOp> {
543545
auto step = mlir::getAffineSymbolExpr(2, op.getContext());
544546
mlir::AffineMap upperBoundMap = mlir::AffineMap::get(
545547
0, 3, (upperBound - lowerBound + step).floorDiv(step));
546-
auto genericUpperBound = rewriter.create<affine::AffineApplyOp>(
547-
op.getLoc(), upperBoundMap,
548+
auto genericUpperBound = affine::AffineApplyOp::create(
549+
rewriter, op.getLoc(), upperBoundMap,
548550
ValueRange({op.getLowerBound(), op.getUpperBound(), op.getStep()}));
549551
auto actualIndexMap = mlir::AffineMap::get(
550552
1, 2,
551553
(lowerBound + mlir::getAffineDimExpr(0, op.getContext())) *
552554
mlir::getAffineSymbolExpr(1, op.getContext()));
553555

554-
auto affineFor = rewriter.create<affine::AffineForOp>(
555-
op.getLoc(), ValueRange(),
556+
auto affineFor = affine::AffineForOp::create(
557+
rewriter, op.getLoc(), ValueRange(),
556558
AffineMap::getConstantMap(0, op.getContext()),
557559
genericUpperBound.getResult(),
558560
mlir::AffineMap::get(0, 1,
559561
1 + mlir::getAffineSymbolExpr(0, op.getContext())),
560562
1, op.getIterOperands());
561563
rewriter.setInsertionPointToStart(affineFor.getBody());
562-
auto actualIndex = rewriter.create<affine::AffineApplyOp>(
563-
op.getLoc(), actualIndexMap,
564+
auto actualIndex = affine::AffineApplyOp::create(
565+
rewriter, op.getLoc(), actualIndexMap,
564566
ValueRange(
565567
{affineFor.getInductionVar(), op.getLowerBound(), op.getStep()}));
566568
return std::make_pair(affineFor, actualIndex.getResult());
@@ -588,8 +590,8 @@ class AffineIfConversion : public mlir::OpRewritePattern<fir::IfOp> {
588590
<< "AffineIfConversion: couldn't calculate affine condition\n";);
589591
return failure();
590592
}
591-
auto affineIf = rewriter.create<affine::AffineIfOp>(
592-
op.getLoc(), affineCondition.getIntegerSet(),
593+
auto affineIf = affine::AffineIfOp::create(
594+
rewriter, op.getLoc(), affineCondition.getIntegerSet(),
593595
affineCondition.getAffineArgs(), !op.getElseRegion().empty());
594596
rewriter.startOpModification(affineIf);
595597
affineIf.getThenBlock()->getOperations().splice(

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

Lines changed: 32 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -856,7 +856,7 @@ static bool getAdjustedExtents(mlir::Location loc,
856856
auto idxTy = rewriter.getIndexType();
857857
if (isAssumedSize(result)) {
858858
// Use slice information to compute the extent of the column.
859-
auto one = rewriter.create<mlir::arith::ConstantIndexOp>(loc, 1);
859+
auto one = mlir::arith::ConstantIndexOp::create(rewriter, loc, 1);
860860
mlir::Value size = one;
861861
if (mlir::Value sliceArg = arrLoad.getSlice()) {
862862
if (auto sliceOp =
@@ -896,14 +896,14 @@ static mlir::Value getOrReadExtentsAndShapeOp(
896896
mlir::cast<SequenceType>(dyn_cast_ptrOrBoxEleTy(boxTy)).getDimension();
897897
auto idxTy = rewriter.getIndexType();
898898
for (decltype(rank) dim = 0; dim < rank; ++dim) {
899-
auto dimVal = rewriter.create<mlir::arith::ConstantIndexOp>(loc, dim);
900-
auto dimInfo = rewriter.create<BoxDimsOp>(loc, idxTy, idxTy, idxTy,
901-
arrLoad.getMemref(), dimVal);
899+
auto dimVal = mlir::arith::ConstantIndexOp::create(rewriter, loc, dim);
900+
auto dimInfo = BoxDimsOp::create(rewriter, loc, idxTy, idxTy, idxTy,
901+
arrLoad.getMemref(), dimVal);
902902
result.emplace_back(dimInfo.getResult(1));
903903
}
904904
if (!arrLoad.getShape()) {
905905
auto shapeType = ShapeType::get(rewriter.getContext(), rank);
906-
return rewriter.create<ShapeOp>(loc, shapeType, result);
906+
return ShapeOp::create(rewriter, loc, shapeType, result);
907907
}
908908
auto shiftOp = arrLoad.getShape().getDefiningOp<ShiftOp>();
909909
auto shapeShiftType = ShapeShiftType::get(rewriter.getContext(), rank);
@@ -912,8 +912,8 @@ static mlir::Value getOrReadExtentsAndShapeOp(
912912
shapeShiftOperands.push_back(lb);
913913
shapeShiftOperands.push_back(extent);
914914
}
915-
return rewriter.create<ShapeShiftOp>(loc, shapeShiftType,
916-
shapeShiftOperands);
915+
return ShapeShiftOp::create(rewriter, loc, shapeShiftType,
916+
shapeShiftOperands);
917917
}
918918
copyUsingSlice =
919919
getAdjustedExtents(loc, rewriter, arrLoad, result, arrLoad.getShape());
@@ -952,13 +952,13 @@ static mlir::Value genCoorOp(mlir::PatternRewriter &rewriter,
952952
auto module = load->getParentOfType<mlir::ModuleOp>();
953953
FirOpBuilder builder(rewriter, module);
954954
auto typeparams = getTypeParamsIfRawData(loc, builder, load, alloc.getType());
955-
mlir::Value result = rewriter.create<ArrayCoorOp>(
956-
loc, eleTy, alloc, shape, slice,
955+
mlir::Value result = ArrayCoorOp::create(
956+
rewriter, loc, eleTy, alloc, shape, slice,
957957
llvm::ArrayRef<mlir::Value>{originated}.take_front(dimension),
958958
typeparams);
959959
if (dimension < originated.size())
960-
result = rewriter.create<fir::CoordinateOp>(
961-
loc, resTy, result,
960+
result = fir::CoordinateOp::create(
961+
rewriter, loc, resTy, result,
962962
llvm::ArrayRef<mlir::Value>{originated}.drop_front(dimension));
963963
return result;
964964
}
@@ -971,13 +971,13 @@ static mlir::Value getCharacterLen(mlir::Location loc, FirOpBuilder &builder,
971971
// The loaded array is an emboxed value. Get the CHARACTER length from
972972
// the box value.
973973
auto eleSzInBytes =
974-
builder.create<BoxEleSizeOp>(loc, charLenTy, load.getMemref());
974+
BoxEleSizeOp::create(builder, loc, charLenTy, load.getMemref());
975975
auto kindSize =
976976
builder.getKindMap().getCharacterBitsize(charTy.getFKind());
977977
auto kindByteSize =
978978
builder.createIntegerConstant(loc, charLenTy, kindSize / 8);
979-
return builder.create<mlir::arith::DivSIOp>(loc, eleSzInBytes,
980-
kindByteSize);
979+
return mlir::arith::DivSIOp::create(builder, loc, eleSzInBytes,
980+
kindByteSize);
981981
}
982982
// The loaded array is a (set of) unboxed values. If the CHARACTER's
983983
// length is not a constant, it must be provided as a type parameter to
@@ -1003,25 +1003,25 @@ void genArrayCopy(mlir::Location loc, mlir::PatternRewriter &rewriter,
10031003
auto idxTy = rewriter.getIndexType();
10041004
// Build loop nest from column to row.
10051005
for (auto sh : llvm::reverse(extents)) {
1006-
auto ubi = rewriter.create<ConvertOp>(loc, idxTy, sh);
1007-
auto zero = rewriter.create<mlir::arith::ConstantIndexOp>(loc, 0);
1008-
auto one = rewriter.create<mlir::arith::ConstantIndexOp>(loc, 1);
1009-
auto ub = rewriter.create<mlir::arith::SubIOp>(loc, idxTy, ubi, one);
1010-
auto loop = rewriter.create<DoLoopOp>(loc, zero, ub, one);
1006+
auto ubi = ConvertOp::create(rewriter, loc, idxTy, sh);
1007+
auto zero = mlir::arith::ConstantIndexOp::create(rewriter, loc, 0);
1008+
auto one = mlir::arith::ConstantIndexOp::create(rewriter, loc, 1);
1009+
auto ub = mlir::arith::SubIOp::create(rewriter, loc, idxTy, ubi, one);
1010+
auto loop = DoLoopOp::create(rewriter, loc, zero, ub, one);
10111011
rewriter.setInsertionPointToStart(loop.getBody());
10121012
indices.push_back(loop.getInductionVar());
10131013
}
10141014
// Reverse the indices so they are in column-major order.
10151015
std::reverse(indices.begin(), indices.end());
10161016
auto module = arrLoad->getParentOfType<mlir::ModuleOp>();
10171017
FirOpBuilder builder(rewriter, module);
1018-
auto fromAddr = rewriter.create<ArrayCoorOp>(
1019-
loc, getEleTy(src.getType()), src, shapeOp,
1018+
auto fromAddr = ArrayCoorOp::create(
1019+
rewriter, loc, getEleTy(src.getType()), src, shapeOp,
10201020
CopyIn && copyUsingSlice ? sliceOp : mlir::Value{},
10211021
factory::originateIndices(loc, rewriter, src.getType(), shapeOp, indices),
10221022
getTypeParamsIfRawData(loc, builder, arrLoad, src.getType()));
1023-
auto toAddr = rewriter.create<ArrayCoorOp>(
1024-
loc, getEleTy(dst.getType()), dst, shapeOp,
1023+
auto toAddr = ArrayCoorOp::create(
1024+
rewriter, loc, getEleTy(dst.getType()), dst, shapeOp,
10251025
!CopyIn && copyUsingSlice ? sliceOp : mlir::Value{},
10261026
factory::originateIndices(loc, rewriter, dst.getType(), shapeOp, indices),
10271027
getTypeParamsIfRawData(loc, builder, arrLoad, dst.getType()));
@@ -1093,15 +1093,16 @@ allocateArrayTemp(mlir::Location loc, mlir::PatternRewriter &rewriter,
10931093
findNonconstantExtents(baseType, extents);
10941094
llvm::SmallVector<mlir::Value> typeParams =
10951095
genArrayLoadTypeParameters(loc, rewriter, load);
1096-
mlir::Value allocmem = rewriter.create<AllocMemOp>(
1097-
loc, dyn_cast_ptrOrBoxEleTy(baseType), typeParams, nonconstantExtents);
1096+
mlir::Value allocmem =
1097+
AllocMemOp::create(rewriter, loc, dyn_cast_ptrOrBoxEleTy(baseType),
1098+
typeParams, nonconstantExtents);
10981099
mlir::Type eleType =
10991100
fir::unwrapSequenceType(fir::unwrapPassByRefType(baseType));
11001101
if (fir::isRecordWithAllocatableMember(eleType)) {
11011102
// The allocatable component descriptors need to be set to a clean
11021103
// deallocated status before anything is done with them.
1103-
mlir::Value box = rewriter.create<fir::EmboxOp>(
1104-
loc, fir::BoxType::get(allocmem.getType()), allocmem, shape,
1104+
mlir::Value box = fir::EmboxOp::create(
1105+
rewriter, loc, fir::BoxType::get(allocmem.getType()), allocmem, shape,
11051106
/*slice=*/mlir::Value{}, typeParams);
11061107
auto module = load->getParentOfType<mlir::ModuleOp>();
11071108
FirOpBuilder builder(rewriter, module);
@@ -1111,12 +1112,12 @@ allocateArrayTemp(mlir::Location loc, mlir::PatternRewriter &rewriter,
11111112
auto cleanup = [=](mlir::PatternRewriter &r) {
11121113
FirOpBuilder builder(r, module);
11131114
runtime::genDerivedTypeDestroy(builder, loc, box);
1114-
r.create<FreeMemOp>(loc, allocmem);
1115+
FreeMemOp::create(r, loc, allocmem);
11151116
};
11161117
return {allocmem, cleanup};
11171118
}
11181119
auto cleanup = [=](mlir::PatternRewriter &r) {
1119-
r.create<FreeMemOp>(loc, allocmem);
1120+
FreeMemOp::create(r, loc, allocmem);
11201121
};
11211122
return {allocmem, cleanup};
11221123
}
@@ -1257,7 +1258,7 @@ class ArrayUpdateConversion : public ArrayUpdateConversionBase<ArrayUpdateOp> {
12571258
if (auto inEleTy = dyn_cast_ptrEleTy(input.getType())) {
12581259
emitFatalError(loc, "array_update on references not supported");
12591260
} else {
1260-
rewriter.create<fir::StoreOp>(loc, input, coor);
1261+
fir::StoreOp::create(rewriter, loc, input, coor);
12611262
}
12621263
};
12631264
auto lhsEltRefType = toRefType(update.getMerge().getType());
@@ -1368,7 +1369,7 @@ class ArrayAmendConversion : public mlir::OpRewritePattern<ArrayAmendOp> {
13681369
auto *op = amend.getOperation();
13691370
rewriter.setInsertionPoint(op);
13701371
auto loc = amend.getLoc();
1371-
auto undef = rewriter.create<UndefOp>(loc, amend.getType());
1372+
auto undef = UndefOp::create(rewriter, loc, amend.getType());
13721373
rewriter.replaceOp(amend, undef.getResult());
13731374
return mlir::success();
13741375
}

0 commit comments

Comments
 (0)