Upgrade all remaining code to free create functions. NFC. (#21902)
The builder create methods are deprecated:
https://mlir.llvm.org/deprecation/. See
https://discourse.llvm.org/t/psa-opty-create-now-with-100-more-tab-complete/87339.
The main benefit of free functions is better tab completion with
LSP/IDE.
This should take care of all the remaining uses of create methods.
diff --git a/compiler/plugins/target/ROCM/Dialect/ROCM/IR/ROCMAttrs.cpp b/compiler/plugins/target/ROCM/Dialect/ROCM/IR/ROCMAttrs.cpp
index b88dde6..d92a914 100644
--- a/compiler/plugins/target/ROCM/Dialect/ROCM/IR/ROCMAttrs.cpp
+++ b/compiler/plugins/target/ROCM/Dialect/ROCM/IR/ROCMAttrs.cpp
@@ -128,10 +128,10 @@
if (!sharedMemoryBytes) {
IREE::Codegen::NullPointerType nullPointerType =
IREE::Codegen::NullPointerType::get(rewriter.getContext());
- return rewriter.create<IREE::Codegen::NullPointerOp>(loc, nullPointerType);
+ return IREE::Codegen::NullPointerOp::create(rewriter, loc, nullPointerType);
}
auto allocOp =
- rewriter.create<bufferization::AllocTensorOp>(loc, tensorType, dynSizes);
+ bufferization::AllocTensorOp::create(rewriter, loc, tensorType, dynSizes);
Attribute sharedAddrSpace = gpu::AddressSpaceAttr::get(
rewriter.getContext(), gpu::GPUDialect::getWorkgroupAddressSpace());
allocOp.setMemorySpaceAttr(sharedAddrSpace);
@@ -403,10 +403,10 @@
Location loc = op->getLoc();
Type I32Type = rewriter.getI32Type();
auto castIndexToI32 = [&](Value val) {
- return rewriter.create<arith::IndexCastOp>(loc, I32Type, val);
+ return arith::IndexCastOp::create(rewriter, loc, I32Type, val);
};
auto constI32 = [&](int val) {
- return rewriter.create<arith::ConstantIntOp>(loc, I32Type, val);
+ return arith::ConstantIntOp::create(rewriter, loc, I32Type, val);
};
MLIRContext *context = rewriter.getContext();
std::optional<int64_t> maybeSharedMemoryBytes =
@@ -415,7 +415,7 @@
(!maybeSharedMemoryBytes) ? 0 : maybeSharedMemoryBytes.value();
Value sharedMemory = createSharedMemory(rewriter, loc, sharedMemoryBytes);
Value k = castIndexToI32(
- rewriter.create<tensor::DimOp>(op.getLoc(), op.getInputs()[0], 1));
+ tensor::DimOp::create(rewriter, op.getLoc(), op.getInputs()[0], 1));
Value intrinsicsM = constI32(mma.getIntrinsicsM());
Value subgroupsM = constI32(mma.getSubgroupsM());
Value intrinsicsN = constI32(mma.getIntrinsicsN());
diff --git a/compiler/src/iree/compiler/Bindings/Native/Transforms/ConvertStreamableOps.cpp b/compiler/src/iree/compiler/Bindings/Native/Transforms/ConvertStreamableOps.cpp
index 913b3fc..f9e367f 100644
--- a/compiler/src/iree/compiler/Bindings/Native/Transforms/ConvertStreamableOps.cpp
+++ b/compiler/src/iree/compiler/Bindings/Native/Transforms/ConvertStreamableOps.cpp
@@ -235,9 +235,9 @@
anyTiedOperands
? moduleBuilder.getIndexArrayAttr(streamableFunc.tiedOperands)
: ArrayAttr{};
- streamableFunc.funcOp = moduleBuilder.create<IREE::Flow::FuncOp>(
- funcOp.getLoc(), funcOp.getName(), functionType, tiedOperandsAttr,
- funcAttrs, funcArgAttrs, funcResAttrs);
+ streamableFunc.funcOp = IREE::Flow::FuncOp::create(
+ moduleBuilder, funcOp.getLoc(), funcOp.getName(), functionType,
+ tiedOperandsAttr, funcAttrs, funcArgAttrs, funcResAttrs);
// Swap out the symbol in the symbol table.
symbolTable.erase(funcOp);
@@ -266,8 +266,8 @@
// It should return the required number of dynamic dimensions.
SmallVector<Type> resultDimTypes(streamableFunc.requiredResultDims,
builder.getIndexType());
- auto calculateCallOp = builder.create<IREE::Util::CallOp>(
- callOp.getLoc(), resultDimTypes,
+ auto calculateCallOp = IREE::Util::CallOp::create(
+ builder, callOp.getLoc(), resultDimTypes,
streamableFunc.resultDimsFunc.getLeafReference().getValue(),
callOp.getOperands(), /*tied_operands=*/ArrayAttr{},
callOp.getArgAttrsAttr(), callOp.getResAttrsAttr());
@@ -302,8 +302,8 @@
}
// Replace the original func.call with the new flow.call.
- auto streamableCallOp = builder.create<IREE::Flow::CallOp>(
- callOp.getLoc(), callOp.getCalleeAttr(), callOp.getResultTypes(),
+ auto streamableCallOp = IREE::Flow::CallOp::create(
+ builder, callOp.getLoc(), callOp.getCalleeAttr(), callOp.getResultTypes(),
resultDims, callOp.getOperands(), argDims,
streamableFunc.funcOp.getTiedOperandsAttr());
streamableCallOp->setDialectAttrs(callOp->getDialectAttrs());
diff --git a/compiler/src/iree/compiler/Bindings/Native/Transforms/WrapEntryPoints.cpp b/compiler/src/iree/compiler/Bindings/Native/Transforms/WrapEntryPoints.cpp
index 3190e8e..476ddb7 100644
--- a/compiler/src/iree/compiler/Bindings/Native/Transforms/WrapEntryPoints.cpp
+++ b/compiler/src/iree/compiler/Bindings/Native/Transforms/WrapEntryPoints.cpp
@@ -185,14 +185,16 @@
// program and the tensors consumed by the import.
if (tensorArgs.empty()) {
// No tensors passed to the import - pass in an immediate signal.
- waitFence = entryBuilder.create<IREE::Util::NullOp>(
- importOp.getLoc(), entryBuilder.getType<IREE::HAL::FenceType>());
+ waitFence = IREE::Util::NullOp::create(
+ entryBuilder, importOp.getLoc(),
+ entryBuilder.getType<IREE::HAL::FenceType>());
} else {
- waitFence = entryBuilder.create<IREE::HAL::FenceCreateOp>(
- importOp.getLoc(), entryBuilder.getType<IREE::HAL::FenceType>(),
- device, IREE::HAL::FenceFlagBitfield::None);
- auto barrierOp = entryBuilder.create<IREE::HAL::TensorBarrierOp>(
- importOp.getLoc(), tensorArgs, waitFence);
+ waitFence = IREE::HAL::FenceCreateOp::create(
+ entryBuilder, importOp.getLoc(),
+ entryBuilder.getType<IREE::HAL::FenceType>(), device,
+ IREE::HAL::FenceFlagBitfield::None);
+ auto barrierOp = IREE::HAL::TensorBarrierOp::create(
+ entryBuilder, importOp.getLoc(), tensorArgs, waitFence);
for (auto [argIndex, readyArg] :
llvm::zip_equal(tensorArgIndices, barrierOp.getResults())) {
entryArgs[argIndex] = readyArg;
@@ -207,12 +209,14 @@
llvm::any_of(oldImportType.getResults(), llvm::IsaPred<TensorType>);
if (!haveTensorResults && !hasSideEffects) {
// No tensors returned from import - pass in an immediate signal.
- signalFence = entryBuilder.create<IREE::Util::NullOp>(
- importOp.getLoc(), entryBuilder.getType<IREE::HAL::FenceType>());
+ signalFence = IREE::Util::NullOp::create(
+ entryBuilder, importOp.getLoc(),
+ entryBuilder.getType<IREE::HAL::FenceType>());
} else {
- signalFence = entryBuilder.create<IREE::HAL::FenceCreateOp>(
- importOp.getLoc(), entryBuilder.getType<IREE::HAL::FenceType>(),
- device, IREE::HAL::FenceFlagBitfield::None);
+ signalFence = IREE::HAL::FenceCreateOp::create(
+ entryBuilder, importOp.getLoc(),
+ entryBuilder.getType<IREE::HAL::FenceType>(), device,
+ IREE::HAL::FenceFlagBitfield::None);
}
break;
}
@@ -231,8 +235,8 @@
// import.
auto encodingAttr =
importOp.getArgAttrOfType<TypeAttr>(argIndex, "iree.abi.encoding");
- auto tensorExportOp = entryBuilder.create<IREE::HAL::TensorExportOp>(
- arg.getLoc(), newType, arg,
+ auto tensorExportOp = IREE::HAL::TensorExportOp::create(
+ entryBuilder, arg.getLoc(), newType, arg,
fallback(encodingAttr, TypeAttr::get(oldType)),
/*name=*/nullptr,
fallback(importOp.getArgAttr(argIndex, "iree.abi.affinity"),
@@ -250,18 +254,18 @@
}
// Make the call with the updated types.
- auto callOp = entryBuilder.create<IREE::Util::CallOp>(importOp.getLoc(),
- importOp, arguments);
+ auto callOp = IREE::Util::CallOp::create(entryBuilder, importOp.getLoc(),
+ importOp, arguments);
// If the call has side-effects then we need to wait on its signal fence on
// the host. This is because they may have launched a thread of their own to
// perform work that we can't track.
if (hasSideEffects && signalFence) {
auto timeoutMillis =
- entryBuilder.create<arith::ConstantIntOp>(importOp.getLoc(), -1, 32);
- entryBuilder.create<IREE::HAL::FenceAwaitOp>(
- importOp.getLoc(), entryBuilder.getI32Type(), timeoutMillis,
- IREE::HAL::WaitFlagBitfield::None, signalFence);
+ arith::ConstantIntOp::create(entryBuilder, importOp.getLoc(), -1, 32);
+ IREE::HAL::FenceAwaitOp::create(
+ entryBuilder, importOp.getLoc(), entryBuilder.getI32Type(),
+ timeoutMillis, IREE::HAL::WaitFlagBitfield::None, signalFence);
}
// Marshal results.
@@ -278,8 +282,8 @@
resultIndex, "iree.abi.consume");
auto affinityAttr =
importOp.getResultAttr(resultIndex, "iree.abi.affinity");
- auto tensorImportOp = entryBuilder.create<IREE::HAL::TensorImportOp>(
- importOp.getLoc(), oldType, result,
+ auto tensorImportOp = IREE::HAL::TensorImportOp::create(
+ entryBuilder, importOp.getLoc(), oldType, result,
fallback(encodingAttr, TypeAttr::get(oldType)),
consumeAttr ? true : false, signalFence,
/*name=*/nullptr, fallback(affinityAttr, defaultAffinityAttr));
@@ -289,7 +293,7 @@
}
}
- entryBuilder.create<IREE::Util::ReturnOp>(importOp.getLoc(), results);
+ IREE::Util::ReturnOp::create(entryBuilder, importOp.getLoc(), results);
stripABIAttrs(importOp);
@@ -616,8 +620,8 @@
auto affinityAttr = exportOp.getArgAttr(argIndex, "iree.abi.affinity");
auto argName = inferArgumentName(entryBuilder.getContext(), argIndex,
exportOp.getArgAttrDict(argIndex));
- auto tensorImportOp = entryBuilder.create<IREE::HAL::TensorImportOp>(
- arg.getLoc(), oldType, arg,
+ auto tensorImportOp = IREE::HAL::TensorImportOp::create(
+ entryBuilder, arg.getLoc(), oldType, arg,
fallback(encodingAttr, TypeAttr::get(oldType)),
/*consume=*/consumeAttr ? true : false, waitFence, argName,
fallback(affinityAttr, defaultAffinityAttr));
@@ -628,8 +632,8 @@
}
// Make the call with the original types.
- auto callOp = entryBuilder.create<IREE::Util::CallOp>(exportOp.getLoc(),
- exportOp, arguments);
+ auto callOp = IREE::Util::CallOp::create(entryBuilder, exportOp.getLoc(),
+ exportOp, arguments);
auto asyncResults = llvm::to_vector(callOp.getResults());
// Alias results to storage buffers if provided.
@@ -641,8 +645,8 @@
auto source = asyncResults[resultIndex];
auto sourceDims = IREE::Util::buildDynamicDimsForValue(
exportOp.getLoc(), source, entryBuilder);
- auto aliasOp = entryBuilder.create<IREE::HAL::TensorAliasOp>(
- exportOp.getLoc(), source.getType(), source, sourceDims,
+ auto aliasOp = IREE::HAL::TensorAliasOp::create(
+ entryBuilder, exportOp.getLoc(), source.getType(), source, sourceDims,
resultStorages[resultIndex], waitFence,
fallback(exportOp.getResultAttr(resultIndex, "iree.abi.affinity"),
defaultAffinityAttr));
@@ -662,11 +666,11 @@
if (asyncTensors.empty()) {
// TODO(benvanik): maybe use a global timeline? global stores may not
// have completed by now in cases where the user wants to loop back.
- entryBuilder.create<IREE::HAL::FenceSignalOp>(exportOp.getLoc(),
- signalFence);
+ IREE::HAL::FenceSignalOp::create(entryBuilder, exportOp.getLoc(),
+ signalFence);
} else {
- auto barrierOp = entryBuilder.create<IREE::HAL::TensorBarrierOp>(
- exportOp.getLoc(), asyncTensors, signalFence);
+ auto barrierOp = IREE::HAL::TensorBarrierOp::create(
+ entryBuilder, exportOp.getLoc(), asyncTensors, signalFence);
asyncResults = llvm::to_vector(barrierOp.getResults());
}
}
@@ -686,8 +690,8 @@
exportOp.getResultAttrDict(resultIndex));
auto dynamicDims = IREE::Util::buildDynamicDimsForValue(
result.getLoc(), result, entryBuilder);
- auto tensorExportOp = entryBuilder.create<IREE::HAL::TensorExportOp>(
- result.getLoc(), newType, result,
+ auto tensorExportOp = IREE::HAL::TensorExportOp::create(
+ entryBuilder, result.getLoc(), newType, result,
fallback(encodingAttr, TypeAttr::get(result.getType())), dynamicDims,
resultName, fallback(affinityAttr, defaultAffinityAttr));
results.push_back(tensorExportOp);
@@ -698,7 +702,7 @@
stripABIAttrs(exportOp);
- entryBuilder.create<IREE::Util::ReturnOp>(exportOp.getLoc(), results);
+ IREE::Util::ReturnOp::create(entryBuilder, exportOp.getLoc(), results);
return wrapperOp;
}
diff --git a/compiler/src/iree/compiler/Bindings/TFLite/Transforms/WrapEntryPoints.cpp b/compiler/src/iree/compiler/Bindings/TFLite/Transforms/WrapEntryPoints.cpp
index 07740ac..74c8ac7 100644
--- a/compiler/src/iree/compiler/Bindings/TFLite/Transforms/WrapEntryPoints.cpp
+++ b/compiler/src/iree/compiler/Bindings/TFLite/Transforms/WrapEntryPoints.cpp
@@ -123,8 +123,8 @@
dynamicDims.tensorType = tensorType;
for (unsigned i = 0; i < tensorType.getRank(); ++i) {
if (tensorType.isDynamicDim(i)) {
- auto globalOp = moduleBuilder.create<IREE::Util::GlobalOp>(
- loc, (namePrefix + "_dim" + std::to_string(i)).str(),
+ auto globalOp = IREE::Util::GlobalOp::create(
+ moduleBuilder, loc, (namePrefix + "_dim" + std::to_string(i)).str(),
/*isMutable=*/true, moduleBuilder.getIndexType());
globalOp.setPrivate();
dynamicDims.globalOps.push_back(globalOp);
@@ -206,8 +206,8 @@
dirtyGlobalOp.createLoadOp(loc, entryBuilder).getLoadedGlobalValue();
auto *recalculateBlock = calcFuncOp.addBlock();
auto *returnBlock = calcFuncOp.addBlock();
- entryBuilder.create<mlir::cf::CondBranchOp>(loc, dirtyValue,
- recalculateBlock, returnBlock);
+ mlir::cf::CondBranchOp::create(entryBuilder, loc, dirtyValue,
+ recalculateBlock, returnBlock);
auto *followBlock = entryBlock.splitBlock(entryBuilder.getInsertionPoint());
auto bufferType = entryBuilder.getType<IREE::HAL::BufferType>();
@@ -225,9 +225,10 @@
auto inputPlaceholder =
recalculateBuilder.createOrFold<IREE::Util::NullOp>(loc, bufferType);
auto dynamicDims = inputDynamicDims.loadDynamicDims(recalculateBuilder);
- auto castOp = recalculateBuilder.create<IREE::HAL::TensorImportOp>(
- loc, inputValue.getType(), inputPlaceholder, inputValue.getType(),
- dynamicDims, /*consume=*/false, /*wait_fence=*/Value{},
+ auto castOp = IREE::HAL::TensorImportOp::create(
+ recalculateBuilder, loc, inputValue.getType(), inputPlaceholder,
+ inputValue.getType(), dynamicDims, /*consume=*/false,
+ /*wait_fence=*/Value{},
/*name=*/nullptr,
/*affinity=*/nullptr);
inputValue.replaceAllUsesWith(castOp.getTarget());
@@ -235,7 +236,7 @@
while (entryBlock.getNumArguments() > 0) {
entryBlock.eraseArgument(entryBlock.getNumArguments() - 1);
}
- recalculateBuilder.create<mlir::cf::BranchOp>(loc, followBlock);
+ mlir::cf::BranchOp::create(recalculateBuilder, loc, followBlock);
recalculateBlock->moveBefore(followBlock);
// Replace each exit from the function with a storage back to the shape
@@ -263,7 +264,7 @@
auto falseValue =
exitBuilder.createOrFold<arith::ConstantIntOp>(exitLoc, 0, 1);
dirtyGlobalOp.createStoreOp(exitLoc, falseValue, exitBuilder);
- exitBuilder.create<IREE::Util::ReturnOp>(exitLoc);
+ IREE::Util::ReturnOp::create(exitBuilder, exitLoc);
returnOp.erase();
}
@@ -283,7 +284,7 @@
auto *exitBlock = builder.createBlock(entryBlock->getParent(),
++Region::iterator(entryBlock));
if (caseCount == 0) {
- builder.create<mlir::cf::BranchOp>(loc, exitBlock);
+ mlir::cf::BranchOp::create(builder, loc, exitBlock);
return exitBlock;
}
SmallVector<Block *> compareBlocks;
@@ -293,20 +294,20 @@
caseBlocks.push_back(builder.createBlock(exitBlock));
}
builder.restoreInsertionPoint(ip);
- builder.create<mlir::cf::BranchOp>(loc, compareBlocks[0]);
+ mlir::cf::BranchOp::create(builder, loc, compareBlocks[0]);
for (size_t i = 0; i < caseCount; ++i) {
auto compareBuilder = OpBuilder::atBlockBegin(compareBlocks[i]);
auto caseValue =
compareBuilder.createOrFold<arith::ConstantIndexOp>(loc, i);
auto eqValue = compareBuilder.createOrFold<arith::CmpIOp>(
loc, arith::CmpIPredicate::eq, indexValue, caseValue);
- compareBuilder.create<mlir::cf::CondBranchOp>(
- loc, eqValue, caseBlocks[i],
+ mlir::cf::CondBranchOp::create(
+ compareBuilder, loc, eqValue, caseBlocks[i],
i < caseCount - 1 ? compareBlocks[i + 1] : exitBlock);
auto caseBuilder = OpBuilder::atBlockBegin(caseBlocks[i]);
caseGenerator(i, caseBuilder);
- caseBuilder.create<mlir::cf::BranchOp>(loc, exitBlock);
+ mlir::cf::BranchOp::create(caseBuilder, loc, exitBlock);
}
builder = OpBuilder::atBlockBegin(exitBlock);
return exitBlock;
@@ -316,8 +317,8 @@
void packShape(Location loc, const DynamicDims &dynamicDims, Value listValue,
OpBuilder &builder) {
auto shapeType = dynamicDims.tensorType;
- builder.create<IREE::Util::ListResizeOp>(
- loc, listValue,
+ IREE::Util::ListResizeOp::create(
+ builder, loc, listValue,
builder.createOrFold<arith::ConstantIndexOp>(loc, shapeType.getRank()));
unsigned dynamicDimIdx = 0;
for (unsigned i = 0; i < shapeType.getRank(); ++i) {
@@ -330,9 +331,9 @@
dimValue = builder.createOrFold<arith::ConstantIndexOp>(
loc, shapeType.getDimSize(i));
}
- builder.create<IREE::Util::ListSetOp>(
- loc, listValue, builder.createOrFold<arith::ConstantIndexOp>(loc, i),
- dimValue);
+ IREE::Util::ListSetOp::create(
+ builder, loc, listValue,
+ builder.createOrFold<arith::ConstantIndexOp>(loc, i), dimValue);
}
}
@@ -362,8 +363,8 @@
void createQueryInputShapeFunc(Location loc, StringRef namePrefix,
ArrayRef<DynamicDims> inputDynamicDims,
OpBuilder &moduleBuilder) {
- auto queryFuncOp = moduleBuilder.create<IREE::Util::FuncOp>(
- loc, namePrefix.str() + "_query_input_shape",
+ auto queryFuncOp = IREE::Util::FuncOp::create(
+ moduleBuilder, loc, namePrefix.str() + "_query_input_shape",
moduleBuilder.getFunctionType(/*inputs=*/
TypeRange{
moduleBuilder.getIndexType(),
@@ -384,7 +385,7 @@
entryBuilder);
auto exitBuilder = OpBuilder::atBlockBegin(exitBlock);
- exitBuilder.create<IREE::Util::ReturnOp>(loc);
+ IREE::Util::ReturnOp::create(exitBuilder, loc);
}
// Creates a function to resize |inputGlobalOps| and sets the |dirtyGlobalOp|
@@ -395,8 +396,8 @@
ArrayRef<DynamicDims> inputDynamicDims,
IREE::Util::GlobalOp dirtyGlobalOp,
OpBuilder &moduleBuilder) {
- auto resizeFuncOp = moduleBuilder.create<IREE::Util::FuncOp>(
- loc, namePrefix.str() + "_resize_input_shape",
+ auto resizeFuncOp = IREE::Util::FuncOp::create(
+ moduleBuilder, loc, namePrefix.str() + "_resize_input_shape",
moduleBuilder.getFunctionType(/*inputs=*/
TypeRange{
moduleBuilder.getIndexType(),
@@ -420,7 +421,7 @@
auto exitBuilder = OpBuilder::atBlockBegin(exitBlock);
auto trueValue = exitBuilder.createOrFold<arith::ConstantIntOp>(loc, 1, 1);
dirtyGlobalOp.createStoreOp(loc, trueValue, exitBuilder);
- exitBuilder.create<IREE::Util::ReturnOp>(loc);
+ IREE::Util::ReturnOp::create(exitBuilder, loc);
}
// Creates a function to query the |outputGlobalOps| at runtime by the
@@ -431,8 +432,8 @@
ArrayRef<DynamicDims> outputDynamicDims,
IREE::Util::FuncOp calculateShapeFuncOp,
OpBuilder &moduleBuilder) {
- auto queryFuncOp = moduleBuilder.create<IREE::Util::FuncOp>(
- loc, namePrefix.str() + "_query_output_shape",
+ auto queryFuncOp = IREE::Util::FuncOp::create(
+ moduleBuilder, loc, namePrefix.str() + "_query_output_shape",
moduleBuilder.getFunctionType(/*inputs=*/
TypeRange{
moduleBuilder.getIndexType(),
@@ -447,8 +448,8 @@
// Always call the recalculation function - it checks for whether it needs
// to run based on the dirty flag value.
- entryBuilder.create<IREE::Util::CallOp>(loc, calculateShapeFuncOp,
- ValueRange{});
+ IREE::Util::CallOp::create(entryBuilder, loc, calculateShapeFuncOp,
+ ValueRange{});
auto *exitBlock = buildSwitch(
loc, entryBlock->getArgument(0), outputDynamicDims.size(),
@@ -458,7 +459,7 @@
entryBuilder);
auto exitBuilder = OpBuilder::atBlockBegin(exitBlock);
- exitBuilder.create<IREE::Util::ReturnOp>(loc);
+ IREE::Util::ReturnOp::create(exitBuilder, loc);
}
// Creates the corresponding wrapper function for the given entry point.
@@ -487,8 +488,8 @@
auto wrapperFuncType =
moduleBuilder.getFunctionType(inputTypes, outputTypes);
- auto wrapperFuncOp = moduleBuilder.create<IREE::Util::FuncOp>(
- entryFuncOp.getLoc(), "_tflite_main", wrapperFuncType);
+ auto wrapperFuncOp = IREE::Util::FuncOp::create(
+ moduleBuilder, entryFuncOp.getLoc(), "_tflite_main", wrapperFuncType);
wrapperFuncOp.setPublic();
wrapperFuncOp.getOperation()->setAttr("iree.abi.stub",
moduleBuilder.getUnitAttr());
@@ -524,16 +525,16 @@
dynamicDims.push_back(globalOp.createLoadOp(arg.getLoc(), entryBuilder)
.getLoadedGlobalValue());
}
- callOperands.push_back(entryBuilder.create<IREE::HAL::TensorImportOp>(
- arg.getLoc(), inputDynamicDims.tensorType, arg,
+ callOperands.push_back(IREE::HAL::TensorImportOp::create(
+ entryBuilder, arg.getLoc(), inputDynamicDims.tensorType, arg,
TypeAttr::get(inputDynamicDims.tensorType), dynamicDims,
/*consume=*/UnitAttr{},
/*wait_fence=*/Value{},
/*name=*/nullptr,
/*affinity=*/nullptr));
}
- auto callOp = entryBuilder.create<IREE::Util::CallOp>(
- entryFuncOp.getLoc(), entryFuncOp, callOperands);
+ auto callOp = IREE::Util::CallOp::create(entryBuilder, entryFuncOp.getLoc(),
+ entryFuncOp, callOperands);
SmallVector<Value> callResults;
for (auto [result, outputDynamicDims] :
llvm::zip_equal(callOp.getResults(), outputDynamicDims)) {
@@ -541,12 +542,13 @@
for (unsigned i = 0; i < outputDynamicDims.tensorType.getRank(); ++i) {
if (outputDynamicDims.tensorType.isDynamicDim(i)) {
dynamicDims.push_back(
- entryBuilder.create<tensor::DimOp>(result.getLoc(), result, i));
+ tensor::DimOp::create(entryBuilder, result.getLoc(), result, i));
}
}
- callResults.push_back(entryBuilder.create<IREE::HAL::TensorExportOp>(
- result.getLoc(), bufferType, result, outputDynamicDims.tensorType,
- dynamicDims, /*name=*/nullptr, /*affinity=*/nullptr));
+ callResults.push_back(IREE::HAL::TensorExportOp::create(
+ entryBuilder, result.getLoc(), bufferType, result,
+ outputDynamicDims.tensorType, dynamicDims, /*name=*/nullptr,
+ /*affinity=*/nullptr));
for (auto [dynamicDim, globalOp] :
llvm::zip_equal(dynamicDims, outputDynamicDims.globalOps)) {
globalOp.createStoreOp(result.getLoc(), dynamicDim, entryBuilder);
@@ -556,11 +558,11 @@
// We recomputed the shapes of the outputs and can clear the dirty flag.
dirtyGlobalOp.createStoreOp(
entryFuncOp.getLoc(),
- entryBuilder.create<arith::ConstantIntOp>(entryFuncOp.getLoc(), 0, 1),
+ arith::ConstantIntOp::create(entryBuilder, entryFuncOp.getLoc(), 0, 1),
entryBuilder);
- entryBuilder.create<IREE::Util::ReturnOp>(entryFuncOp.getLoc(),
- callResults);
+ IREE::Util::ReturnOp::create(entryBuilder, entryFuncOp.getLoc(),
+ callResults);
}
void wrapEntryPoint(IREE::Util::FuncOp funcOp) {
@@ -577,8 +579,8 @@
// Create internal shape calculation function that updates output shapes if
// needed. This is only required if there are dynamic shapes.
- auto dirtyGlobalOp = moduleBuilder.create<IREE::Util::GlobalOp>(
- loc, namePrefix + "_shapes_dirty",
+ auto dirtyGlobalOp = IREE::Util::GlobalOp::create(
+ moduleBuilder, loc, namePrefix + "_shapes_dirty",
/*isMutable=*/true, moduleBuilder.getI1Type(),
moduleBuilder.getIntegerAttr(moduleBuilder.getI1Type(), 1));
dirtyGlobalOp.setPrivate();
diff --git a/compiler/src/iree/compiler/Codegen/LLVMGPU/LLVMGPUConfigureTensorLayouts.cpp b/compiler/src/iree/compiler/Codegen/LLVMGPU/LLVMGPUConfigureTensorLayouts.cpp
index c87c495..1741992 100644
--- a/compiler/src/iree/compiler/Codegen/LLVMGPU/LLVMGPUConfigureTensorLayouts.cpp
+++ b/compiler/src/iree/compiler/Codegen/LLVMGPU/LLVMGPUConfigureTensorLayouts.cpp
@@ -231,11 +231,11 @@
// Set layouts for lhs, rhs and acc.
rewriter.setInsertionPoint(contract);
auto layoutedLhs =
- rewriter.create<ToLayoutOp>(loc, lhs, aLayout, schedule.intrinsic);
+ ToLayoutOp::create(rewriter, loc, lhs, aLayout, schedule.intrinsic);
auto layoutedRhs =
- rewriter.create<ToLayoutOp>(loc, rhs, bLayout, schedule.intrinsic);
+ ToLayoutOp::create(rewriter, loc, rhs, bLayout, schedule.intrinsic);
auto layoutedAcc =
- rewriter.create<ToLayoutOp>(loc, acc, cLayout, schedule.intrinsic);
+ ToLayoutOp::create(rewriter, loc, acc, cLayout, schedule.intrinsic);
// Promote matmul lhs and rhs.
// TODO: This is a hack until layout analysis is improved. The layout analysis
@@ -258,8 +258,8 @@
// Set layout for result.
rewriter.setInsertionPointAfter(contract);
- auto toLayout = rewriter.create<ToLayoutOp>(loc, contract->getResult(0),
- cLayout, schedule.intrinsic);
+ auto toLayout = ToLayoutOp::create(rewriter, loc, contract->getResult(0),
+ cLayout, schedule.intrinsic);
rewriter.replaceAllUsesExcept(contract->getResult(0), toLayout.getResult(),
toLayout);
@@ -308,11 +308,11 @@
// Set layouts for lhs, rhs and acc.
rewriter.setInsertionPoint(conv);
auto layoutedLhs =
- rewriter.create<ToLayoutOp>(loc, lhs, aLayout, schedule.intrinsic);
+ ToLayoutOp::create(rewriter, loc, lhs, aLayout, schedule.intrinsic);
auto layoutedRhs =
- rewriter.create<ToLayoutOp>(loc, rhs, bLayout, schedule.intrinsic);
+ ToLayoutOp::create(rewriter, loc, rhs, bLayout, schedule.intrinsic);
auto layoutedAcc =
- rewriter.create<ToLayoutOp>(loc, acc, cLayout, schedule.intrinsic);
+ ToLayoutOp::create(rewriter, loc, acc, cLayout, schedule.intrinsic);
// Promote matmul lhs and rhs.
// TODO: This is a hack until layout analysis is improved. The layout analysis
@@ -335,8 +335,8 @@
// Set layout for result.
rewriter.setInsertionPointAfter(conv);
- auto toLayout = rewriter.create<ToLayoutOp>(loc, conv->getResult(0), cLayout,
- schedule.intrinsic);
+ auto toLayout = ToLayoutOp::create(rewriter, loc, conv->getResult(0), cLayout,
+ schedule.intrinsic);
rewriter.replaceAllUsesExcept(conv->getResult(0), toLayout.getResult(),
toLayout);
@@ -553,7 +553,7 @@
for (OpResult result : linalgOp->getResults()) {
VectorLayoutInterface resultLayout =
layout.apply(linalgOp.getIndexingMapMatchingResult(result));
- auto toLayout = rewriter.create<ToLayoutOp>(loc, result, resultLayout);
+ auto toLayout = ToLayoutOp::create(rewriter, loc, result, resultLayout);
rewriter.replaceAllUsesExcept(result, toLayout, toLayout);
}
@@ -728,7 +728,7 @@
for (OpResult result : candidate->getResults()) {
VectorLayoutInterface resultLayout =
layout.apply(candidate.getIndexingMapMatchingResult(result));
- auto toLayout = rewriter.create<ToLayoutOp>(loc, result, resultLayout);
+ auto toLayout = ToLayoutOp::create(rewriter, loc, result, resultLayout);
rewriter.replaceAllUsesExcept(result, toLayout, toLayout);
}
diff --git a/compiler/src/iree/compiler/ConstEval/JitGlobals.cpp b/compiler/src/iree/compiler/ConstEval/JitGlobals.cpp
index 1467e74..0a85c44 100644
--- a/compiler/src/iree/compiler/ConstEval/JitGlobals.cpp
+++ b/compiler/src/iree/compiler/ConstEval/JitGlobals.cpp
@@ -473,8 +473,8 @@
targetSymbolTable, moduleBuilder)))
return failure();
- auto funcOp = moduleBuilder.create<IREE::Util::FuncOp>(
- initializerOp.getLoc(), "jit_eval",
+ auto funcOp = IREE::Util::FuncOp::create(
+ moduleBuilder, initializerOp.getLoc(), "jit_eval",
moduleBuilder.getFunctionType({}, {}));
targetSymbolTable.insert(funcOp);
IRMapping unusedMapping;
@@ -489,7 +489,7 @@
private:
static ModuleOp createInnerModule(ModuleOp sourceModuleOp) {
OpBuilder builder = OpBuilder::atBlockEnd(sourceModuleOp.getBody());
- auto m = builder.create<ModuleOp>(sourceModuleOp.getLoc());
+ auto m = ModuleOp::create(builder, sourceModuleOp.getLoc());
m->setAttr("iree.consteval", builder.getUnitAttr());
return m;
}
@@ -583,7 +583,7 @@
// Rewrite the terminator and the function type.
entryBlock->getTerminator()->erase();
OpBuilder termBuilder = OpBuilder::atBlockEnd(entryBlock);
- termBuilder.create<IREE::Util::ReturnOp>(funcOp.getLoc(), returns);
+ IREE::Util::ReturnOp::create(termBuilder, funcOp.getLoc(), returns);
funcOp.setType(termBuilder.getFunctionType(argumentTypes, returnTypes));
jitFunctions.push_back(std::move(desc));
diff --git a/compiler/src/iree/compiler/DispatchCreation/BitcastUnsupportedElementTypes.cpp b/compiler/src/iree/compiler/DispatchCreation/BitcastUnsupportedElementTypes.cpp
index fe60670..d6779d4 100644
--- a/compiler/src/iree/compiler/DispatchCreation/BitcastUnsupportedElementTypes.cpp
+++ b/compiler/src/iree/compiler/DispatchCreation/BitcastUnsupportedElementTypes.cpp
@@ -63,10 +63,10 @@
rewriter.setInsertionPoint(load);
// Load in the new type -> bitcast back to the original type.
- auto newLoad = rewriter.create<IREE::TensorExt::DispatchTensorLoadOp>(
- load.getLoc(), targetType, arg, load.getSourceDims(), load.getOffsets(),
- load.getSizes(), load.getStrides(), load.getStaticOffsets(), newSizes,
- load.getStaticStrides());
+ auto newLoad = IREE::TensorExt::DispatchTensorLoadOp::create(
+ rewriter, load.getLoc(), targetType, arg, load.getSourceDims(),
+ load.getOffsets(), load.getSizes(), load.getStrides(),
+ load.getStaticOffsets(), newSizes, load.getStaticStrides());
rewriter.replaceOpWithNewOp<IREE::TensorExt::BitCastOp>(
load, originalType, newLoad, load.getSizes(), load.getSizes());
return success();
@@ -81,9 +81,9 @@
OpBuilder::InsertionGuard g(rewriter);
rewriter.setInsertionPoint(store);
- auto bitcast = rewriter.create<IREE::TensorExt::BitCastOp>(
- store.getLoc(), targetType, store.getValue(), store.getSizes(),
- store.getSizes());
+ auto bitcast = IREE::TensorExt::BitCastOp::create(
+ rewriter, store.getLoc(), targetType, store.getValue(),
+ store.getSizes(), store.getSizes());
// Bitcast to the target type -> store in the new type.
rewriter.replaceOpWithNewOp<IREE::TensorExt::DispatchTensorStoreOp>(
store, TypeRange{}, bitcast, arg, store.getTargetDims(),
@@ -136,9 +136,9 @@
rewriter.setInsertionPoint(workgroupsOp);
ValueRange sourceDims =
workgroupsOp.getOperandDynamicDims(operand.getOperandNumber());
- auto inputBitcast = rewriter.create<IREE::Flow::TensorBitCastOp>(
- workgroupsOp.getLoc(), castedTensorType, operand.get(), sourceDims,
- sourceDims);
+ auto inputBitcast = IREE::Flow::TensorBitCastOp::create(
+ rewriter, workgroupsOp.getLoc(), castedTensorType, operand.get(),
+ sourceDims, sourceDims);
operand.assign(inputBitcast);
blockArg.setType(castedDispatchType);
@@ -205,8 +205,8 @@
ValueRange dynamicDims =
workgroupsOp.getOperandDynamicDims(tiedOperand->getOperandNumber());
- auto inputBitcast = rewriter.create<IREE::Flow::TensorBitCastOp>(
- workgroupsOp.getLoc(), castedTensorType, tiedOperand->get(),
+ auto inputBitcast = IREE::Flow::TensorBitCastOp::create(
+ rewriter, workgroupsOp.getLoc(), castedTensorType, tiedOperand->get(),
dynamicDims, dynamicDims);
tiedOperand->assign(inputBitcast);
}
@@ -224,9 +224,9 @@
// Clone the op with new result types and steal the body.
rewriter.setInsertionPoint(workgroupsOp);
- auto newWorkgroupsOp = rewriter.create<IREE::Flow::DispatchWorkgroupsOp>(
- workgroupsOp->getLoc(), workgroupsOp.getWorkload(), newResultTypes,
- workgroupsOp.getResultDims(), workgroupsOp.getArguments(),
+ auto newWorkgroupsOp = IREE::Flow::DispatchWorkgroupsOp::create(
+ rewriter, workgroupsOp->getLoc(), workgroupsOp.getWorkload(),
+ newResultTypes, workgroupsOp.getResultDims(), workgroupsOp.getArguments(),
workgroupsOp.getArgumentDims(),
workgroupsOp.getTiedResultOperandIndices(), workgroupsOp->getAttrs());
newWorkgroupsOp->setDialectAttrs(workgroupsOp->getDialectAttrs());
@@ -246,9 +246,9 @@
auto originalType =
cast<RankedTensorType>(workgroupsOp.getResult(resultIndex).getType());
ValueRange dynamicDims = newWorkgroupsOp.getResultDynamicDims(resultIndex);
- replacements[resultIndex] = rewriter.create<IREE::Flow::TensorBitCastOp>(
- workgroupsOp.getLoc(), originalType, replacements[resultIndex],
- dynamicDims, dynamicDims);
+ replacements[resultIndex] = IREE::Flow::TensorBitCastOp::create(
+ rewriter, workgroupsOp.getLoc(), originalType,
+ replacements[resultIndex], dynamicDims, dynamicDims);
}
rewriter.replaceOp(workgroupsOp, replacements);
diff --git a/compiler/src/iree/compiler/DispatchCreation/BubbleUpExpandShapes.cpp b/compiler/src/iree/compiler/DispatchCreation/BubbleUpExpandShapes.cpp
index 27e4dda..59d7907 100644
--- a/compiler/src/iree/compiler/DispatchCreation/BubbleUpExpandShapes.cpp
+++ b/compiler/src/iree/compiler/DispatchCreation/BubbleUpExpandShapes.cpp
@@ -149,10 +149,10 @@
if (!fillOp)
return failure();
- auto newExtractOp = rewriter.create<tensor::ExtractSliceOp>(
- extractOp.getLoc(), extractOp.getType(), fillOp.getOutputs()[0],
- extractOp.getMixedOffsets(), extractOp.getMixedSizes(),
- extractOp.getMixedStrides());
+ auto newExtractOp = tensor::ExtractSliceOp::create(
+ rewriter, extractOp.getLoc(), extractOp.getType(),
+ fillOp.getOutputs()[0], extractOp.getMixedOffsets(),
+ extractOp.getMixedSizes(), extractOp.getMixedStrides());
rewriter.replaceOpWithNewOp<linalg::FillOp>(
extractOp, fillOp.getInputs(), ValueRange{newExtractOp.getResult()});
return success();
@@ -258,8 +258,8 @@
RankedTensorType::get(newExpandShape, expandedType.getElementType());
// The builder can't fail to infer the output_shape because none of
// the dynamic dimensions are expanded.
- auto newExpand = rewriter.create<tensor::ExpandShapeOp>(
- expandOp.getLoc(), newExpandType, extractOp.getSource(),
+ auto newExpand = tensor::ExpandShapeOp::create(
+ rewriter, expandOp.getLoc(), newExpandType, extractOp.getSource(),
newReassociation);
rewriter.replaceOpWithNewOp<tensor::ExtractSliceOp>(
@@ -363,13 +363,14 @@
auto newType =
RankedTensorType::get(staticOutputShape, inputType.getElementType());
Value newExpand;
- newExpand = rewriter.create<tensor::ExpandShapeOp>(
- expandOp.getLoc(), newType, input, reassoc, mixedOutputShape);
+ newExpand =
+ tensor::ExpandShapeOp::create(rewriter, expandOp.getLoc(), newType,
+ input, reassoc, mixedOutputShape);
newInputs.push_back(newExpand);
}
// Create new concat op on expanded inputs.
- auto newConcat = rewriter.create<tensor::ConcatOp>(concatOp.getLoc(),
- newConcatDim, newInputs);
+ auto newConcat = tensor::ConcatOp::create(rewriter, concatOp.getLoc(),
+ newConcatDim, newInputs);
rewriter.replaceOp(expandOp, newConcat.getResult());
return success();
}
diff --git a/compiler/src/iree/compiler/DispatchCreation/CollapseDimensions.cpp b/compiler/src/iree/compiler/DispatchCreation/CollapseDimensions.cpp
index 19e61e7..71b01d7 100644
--- a/compiler/src/iree/compiler/DispatchCreation/CollapseDimensions.cpp
+++ b/compiler/src/iree/compiler/DispatchCreation/CollapseDimensions.cpp
@@ -92,8 +92,8 @@
}
RankedTensorType resultType = sliceOp.getResultType();
- Value collapseOp = rewriter.create<tensor::CollapseShapeOp>(
- loc, sliceOp.getSource(), reassociation);
+ Value collapseOp = tensor::CollapseShapeOp::create(
+ rewriter, loc, sliceOp.getSource(), reassociation);
Value newSliceOp = tensor::ExtractSliceOp::create(
rewriter, loc, collapseOp, collapsedOffsets, collapsedSizes,
collapsedStrides);
@@ -867,8 +867,8 @@
}
// 5. Create the new dispatch op.
- auto newDispatchOp = rewriter.create<IREE::Flow::DispatchRegionOp>(
- loc, newReturnTypes, newDynamicDims, dispatchOp.getWorkload());
+ auto newDispatchOp = IREE::Flow::DispatchRegionOp::create(
+ rewriter, loc, newReturnTypes, newDynamicDims, dispatchOp.getWorkload());
// 5a. Move the body over, but replace the `flow.return` to use the new yield
// values.
@@ -908,8 +908,8 @@
SmallVector<OpFoldResult> outputShape =
mlir::getMixedValues(shapedType.getShape(), dynamicDims, rewriter);
- auto newExpandShapeOp = rewriter.create<tensor::ExpandShapeOp>(
- loc, origResult.getType(), returnValue,
+ auto newExpandShapeOp = tensor::ExpandShapeOp::create(
+ rewriter, loc, origResult.getType(), returnValue,
allReassociationIndicesRef.front(), outputShape);
allReassociationIndicesRef = allReassociationIndicesRef.drop_front();
rewriter.replaceAllUsesWith(origResult, newExpandShapeOp.getResult());
diff --git a/compiler/src/iree/compiler/DispatchCreation/ElementwiseOpFusion.cpp b/compiler/src/iree/compiler/DispatchCreation/ElementwiseOpFusion.cpp
index e4ada6c..9ebb891 100644
--- a/compiler/src/iree/compiler/DispatchCreation/ElementwiseOpFusion.cpp
+++ b/compiler/src/iree/compiler/DispatchCreation/ElementwiseOpFusion.cpp
@@ -96,8 +96,8 @@
});
SmallVector<Value, 4> indices = extractOp.getIndices();
indices = applyProjectedPermutation(indices, perm);
- auto newExtract = rewriter.create<tensor::ExtractOp>(
- extractOp.getLoc(), operand.get(), indices);
+ auto newExtract = tensor::ExtractOp::create(rewriter, extractOp.getLoc(),
+ operand.get(), indices);
extractOps.push_back(newExtract);
}
rewriter.cloneRegionBefore(producerOp.getRegion(), consumerOp.getRegion(),
diff --git a/compiler/src/iree/compiler/DispatchCreation/FoldUnitExtentDims.cpp b/compiler/src/iree/compiler/DispatchCreation/FoldUnitExtentDims.cpp
index 5ae7d7f..3b580ee 100644
--- a/compiler/src/iree/compiler/DispatchCreation/FoldUnitExtentDims.cpp
+++ b/compiler/src/iree/compiler/DispatchCreation/FoldUnitExtentDims.cpp
@@ -185,8 +185,8 @@
Value newExpanded = expandOp.getSrc();
if (!llvm::all_of(newExpandReassoc,
llvm::hasSingleElement<ReassociationIndicesRef>)) {
- newExpanded = rewriter.create<tensor::ExpandShapeOp>(
- expandOp.getLoc(),
+ newExpanded = tensor::ExpandShapeOp::create(
+ rewriter, expandOp.getLoc(),
RankedTensorType::get(newInterShape,
expandOp.getType().getElementType()),
expandOp.getSrc(), newExpandReassoc, newInterSizes);
@@ -195,9 +195,9 @@
Value result = newExpanded;
if (!llvm::all_of(newCollapseReassoc,
llvm::hasSingleElement<ReassociationIndicesRef>)) {
- result = rewriter.create<tensor::CollapseShapeOp>(
- collapseOp.getLoc(), collapseOp.getType(), newExpanded,
- newCollapseReassoc);
+ result = tensor::CollapseShapeOp::create(rewriter, collapseOp.getLoc(),
+ collapseOp.getType(),
+ newExpanded, newCollapseReassoc);
}
rewriter.replaceOp(collapseOp, result);
return success();
@@ -299,8 +299,8 @@
}
for (auto store : storeOps) {
rewriter.setInsertionPoint(store);
- Value collapse = rewriter.create<tensor::CollapseShapeOp>(
- store.getLoc(), newGlobalType, store->getOperand(0),
+ Value collapse = tensor::CollapseShapeOp::create(
+ rewriter, store.getLoc(), newGlobalType, store->getOperand(0),
expandShapeReInds.value());
auto newStore =
clone(rewriter, store, store->getResultTypes(), store->getOperands());
diff --git a/compiler/src/iree/compiler/DispatchCreation/FormScalarDispatches.cpp b/compiler/src/iree/compiler/DispatchCreation/FormScalarDispatches.cpp
index 8f746c6..678995a 100644
--- a/compiler/src/iree/compiler/DispatchCreation/FormScalarDispatches.cpp
+++ b/compiler/src/iree/compiler/DispatchCreation/FormScalarDispatches.cpp
@@ -285,10 +285,10 @@
Block *countBody = rewriter.createBlock(&countRegion, countRegion.begin());
OpBuilder::InsertionGuard g(rewriter);
rewriter.setInsertionPointToStart(countBody);
- auto one = rewriter.create<arith::ConstantIndexOp>(
- dispatchRegionOp.value()->getLoc(), 1);
- rewriter.create<IREE::Flow::ReturnOp>(dispatchRegionOp.value()->getLoc(),
- ValueRange{one, one, one});
+ auto one = arith::ConstantIndexOp::create(
+ rewriter, dispatchRegionOp.value()->getLoc(), 1);
+ IREE::Flow::ReturnOp::create(rewriter, dispatchRegionOp.value()->getLoc(),
+ ValueRange{one, one, one});
}
}
diff --git a/compiler/src/iree/compiler/DispatchCreation/FuseHorizontalContractions.cpp b/compiler/src/iree/compiler/DispatchCreation/FuseHorizontalContractions.cpp
index 45694cd..ed03dc8 100644
--- a/compiler/src/iree/compiler/DispatchCreation/FuseHorizontalContractions.cpp
+++ b/compiler/src/iree/compiler/DispatchCreation/FuseHorizontalContractions.cpp
@@ -424,8 +424,8 @@
SmallVector<AffineMap> fusedIndexingMaps = std::move(fusedInsIndexingMaps);
fusedIndexingMaps.append(fusedOutsIndexingMaps);
- auto fusedOp = rewriter.create<linalg::GenericOp>(
- loc, fusedResultTypes, fusedIns, fusedOuts, fusedIndexingMaps,
+ auto fusedOp = linalg::GenericOp::create(
+ rewriter, loc, fusedResultTypes, fusedIns, fusedOuts, fusedIndexingMaps,
fusedIteratorTypes, [](OpBuilder &, Location, ValueRange) {});
Block *fusedBody = fusedOp.getBlock();
@@ -461,7 +461,7 @@
}
OpBuilder::InsertionGuard g(rewriter);
rewriter.setInsertionPointToEnd(fusedBody);
- rewriter.create<linalg::YieldOp>(loc, yieldVals);
+ linalg::YieldOp::create(rewriter, loc, yieldVals);
unsigned resultsIndex = 0;
for (auto linalgOp : linalgOps) {
diff --git a/compiler/src/iree/compiler/DispatchCreation/HoistEncodingOps.cpp b/compiler/src/iree/compiler/DispatchCreation/HoistEncodingOps.cpp
index bcd9a62..12490fb 100644
--- a/compiler/src/iree/compiler/DispatchCreation/HoistEncodingOps.cpp
+++ b/compiler/src/iree/compiler/DispatchCreation/HoistEncodingOps.cpp
@@ -110,16 +110,16 @@
auto operandType = cast<RankedTensorType>(operand->get().getType());
auto resType = RankedTensorType::get(
operandType.getShape(), operandType.getElementType(), newEncoding);
- Value encodedInput = rewriter.create<IREE::Encoding::SetEncodingOp>(
- loc, resType, operand->get());
+ Value encodedInput = IREE::Encoding::SetEncodingOp::create(
+ rewriter, loc, resType, operand->get());
encodedOperands.push_back(encodedInput);
}
// Create encoded generic op.
SmallVector<OpFoldResult> mixedSizes =
tensor::getMixedSizes(rewriter, loc, encodingOp.getSource());
- Value encodedInit = rewriter.create<tensor::EmptyOp>(
- loc, mixedSizes, encodedType.getElementType(), encoding);
+ Value encodedInit = tensor::EmptyOp::create(
+ rewriter, loc, mixedSizes, encodedType.getElementType(), encoding);
encodedOperands.push_back(encodedInit);
auto encodedGenericOp =
clone(rewriter, genericOp, encodingOp.getResultType(), encodedOperands);
diff --git a/compiler/src/iree/compiler/DispatchCreation/MaterializeDefaultWorkgroupCountRegion.cpp b/compiler/src/iree/compiler/DispatchCreation/MaterializeDefaultWorkgroupCountRegion.cpp
index 4937b8e..1196a7e 100644
--- a/compiler/src/iree/compiler/DispatchCreation/MaterializeDefaultWorkgroupCountRegion.cpp
+++ b/compiler/src/iree/compiler/DispatchCreation/MaterializeDefaultWorkgroupCountRegion.cpp
@@ -72,8 +72,8 @@
OpBuilder::InsertionGuard g(rewriter);
rewriter.setInsertionPointToStart(block);
Operation *defaultCountOp =
- rewriter.create<IREE::TensorExt::DispatchWorkgroupCountFromSliceOp>(
- loc, block->getArguments());
+ IREE::TensorExt::DispatchWorkgroupCountFromSliceOp::create(
+ rewriter, loc, block->getArguments());
// Check for presence of `scf.forall` operations created by partial reduction
// tiling.
@@ -98,7 +98,7 @@
IREE::TensorExt::DispatchWorkgroupCountSplitReductionModifierOp>(
loc, defaultCountOp->getResults(), block->getArguments());
}
- rewriter.create<IREE::Flow::ReturnOp>(loc, defaultCountOp->getResults());
+ IREE::Flow::ReturnOp::create(rewriter, loc, defaultCountOp->getResults());
// Update the `workgroupsOp` region.
rewriter.modifyOpInPlace(workgroupsOp, [&]() {
@@ -117,9 +117,8 @@
if (!llvm::isa<IndexType>(operand.getType()))
continue;
BlockArgument arg = workgroupsOp.getInputBlockArgument(index);
- auto ordinalOp =
- rewriter.create<IREE::TensorExt::DispatchWorkloadOrdinalOp>(
- loc, arg, rewriter.getIndexAttr(ordinalNumber++));
+ auto ordinalOp = IREE::TensorExt::DispatchWorkloadOrdinalOp::create(
+ rewriter, loc, arg, rewriter.getIndexAttr(ordinalNumber++));
rewriter.replaceAllUsesExcept(arg, ordinalOp, ordinalOp);
}
});
diff --git a/compiler/src/iree/compiler/DispatchCreation/SetEncoding.cpp b/compiler/src/iree/compiler/DispatchCreation/SetEncoding.cpp
index 8da216b..3168b43 100644
--- a/compiler/src/iree/compiler/DispatchCreation/SetEncoding.cpp
+++ b/compiler/src/iree/compiler/DispatchCreation/SetEncoding.cpp
@@ -40,7 +40,8 @@
Attribute encodingAttr) {
auto resultType =
cast<RankedTensorType>(source.getType()).cloneWithEncoding(encodingAttr);
- return builder.create<IREE::Encoding::SetEncodingOp>(loc, resultType, source);
+ return IREE::Encoding::SetEncodingOp::create(builder, loc, resultType,
+ source);
};
static Value unsetEncoding(OpBuilder &builder, Location loc, Value source,
@@ -52,8 +53,8 @@
auto sourceType = cast<RankedTensorType>(source.getType());
auto unsetEncodingReturnType =
RankedTensorType::get(sourceType.getShape(), sourceType.getElementType());
- return builder.create<IREE::Encoding::UnsetEncodingOp>(
- loc, unsetEncodingReturnType, source, dynamicSizesVec);
+ return IREE::Encoding::UnsetEncodingOp::create(
+ builder, loc, unsetEncodingReturnType, source, dynamicSizesVec);
}
/// Given a LinalgOp and one of its OpOperands, return the element type,
@@ -255,9 +256,9 @@
Location loc = fillOp.getLoc();
SmallVector<OpFoldResult> dimValues =
tensor::getMixedSizes(rewriter, loc, fillOp.getOutputs()[0]);
- auto newEmptyOp = rewriter.create<tensor::EmptyOp>(
- loc, dimValues, encodingType.getElementType(),
- encodingType.getEncoding());
+ auto newEmptyOp = tensor::EmptyOp::create(rewriter, loc, dimValues,
+ encodingType.getElementType(),
+ encodingType.getEncoding());
rewriter.replaceOpWithNewOp<linalg::FillOp>(encodingOp, fillOp.getInputs(),
ValueRange{newEmptyOp});
return success();
@@ -330,9 +331,9 @@
llvm::append_range(newResultDynamicDims, operandDynamicDims);
}
- auto newDispatchOp = rewriter.create<IREE::Flow::DispatchRegionOp>(
- producerDispatch->getLoc(), newResultTypes, newResultDynamicDims,
- producerDispatch.getWorkload());
+ auto newDispatchOp = IREE::Flow::DispatchRegionOp::create(
+ rewriter, producerDispatch->getLoc(), newResultTypes,
+ newResultDynamicDims, producerDispatch.getWorkload());
// Move over the body of the old dispatch.
Region &newBody = newDispatchOp.getBody();
@@ -362,8 +363,8 @@
}
// Find the new value to yield.
Value newYieldedVal = map.lookup(operand);
- auto encodingOp = rewriter.create<IREE::Encoding::SetEncodingOp>(
- returnOp->getLoc(), newResultType, newYieldedVal);
+ auto encodingOp = IREE::Encoding::SetEncodingOp::create(
+ rewriter, returnOp->getLoc(), newResultType, newYieldedVal);
rewriter.modifyOpInPlace(
returnOp, [&]() { returnOp.setOperand(resultNumber, encodingOp); });
@@ -395,8 +396,8 @@
OpBuilder::InsertionGuard g2(rewriter);
rewriter.setInsertionPoint(op);
Type operandType = operand.get().getType();
- auto unsetEncodignOp = rewriter.create<IREE::Encoding::UnsetEncodingOp>(
- op->getLoc(), operandType, paddedVal->paddedValue,
+ auto unsetEncodignOp = IREE::Encoding::UnsetEncodingOp::create(
+ rewriter, op->getLoc(), operandType, paddedVal->paddedValue,
paddedVal->dynamicDims);
op->setOperand(operandNum, unsetEncodignOp.getResult());
});
diff --git a/compiler/src/iree/compiler/Reducer/Strategies/ReduceFlowDispatchResultBySplat.cpp b/compiler/src/iree/compiler/Reducer/Strategies/ReduceFlowDispatchResultBySplat.cpp
index 734fcb5..db81d92 100644
--- a/compiler/src/iree/compiler/Reducer/Strategies/ReduceFlowDispatchResultBySplat.cpp
+++ b/compiler/src/iree/compiler/Reducer/Strategies/ReduceFlowDispatchResultBySplat.cpp
@@ -53,8 +53,8 @@
for (auto dispatchOp : keepOps) {
builder.setInsertionPointAfter(dispatchOp);
for (Value result : dispatchOp.getResults()) {
- builder.create<IREE::Util::OptimizationBarrierOp>(dispatchOp.getLoc(),
- result);
+ IREE::Util::OptimizationBarrierOp::create(builder, dispatchOp.getLoc(),
+ result);
}
}
@@ -69,10 +69,10 @@
auto tensorType = cast<RankedTensorType>(result.getType());
auto elType = tensorType.getElementType();
auto zeroAttr = builder.getZeroAttr(elType);
- auto zero = builder.create<arith::ConstantOp>(result.getLoc(), zeroAttr);
+ auto zero = arith::ConstantOp::create(builder, result.getLoc(), zeroAttr);
- auto splat = builder.create<IREE::Flow::TensorSplatOp>(
- result.getLoc(), tensorType, zero, dynamicDims);
+ auto splat = IREE::Flow::TensorSplatOp::create(
+ builder, result.getLoc(), tensorType, zero, dynamicDims);
result.replaceAllUsesWith(splat);
}
diff --git a/compiler/src/iree/compiler/Reducer/Strategies/ReduceLinalgOnTensorsDelta.cpp b/compiler/src/iree/compiler/Reducer/Strategies/ReduceLinalgOnTensorsDelta.cpp
index 79578d0..5669c98 100644
--- a/compiler/src/iree/compiler/Reducer/Strategies/ReduceLinalgOnTensorsDelta.cpp
+++ b/compiler/src/iree/compiler/Reducer/Strategies/ReduceLinalgOnTensorsDelta.cpp
@@ -67,8 +67,8 @@
for (auto linalgOp : keepOps) {
builder.setInsertionPointAfter(linalgOp);
for (Value result : linalgOp->getResults()) {
- builder.create<IREE::Util::OptimizationBarrierOp>(linalgOp.getLoc(),
- result);
+ IREE::Util::OptimizationBarrierOp::create(builder, linalgOp.getLoc(),
+ result);
}
}
@@ -112,7 +112,7 @@
.getResult();
// Build linalg.fill for this out.
- newOut = builder.create<linalg::FillOp>(linalgOp.getLoc(), zero, init)
+ newOut = linalg::FillOp::create(builder, linalgOp.getLoc(), zero, init)
.getResult(0);
out.replaceAllUsesWith(newOut);
