[mlir][NFC] update mlir/Dialect create APIs (28/n) (llvm#150641)

See llvm#147168 for more info.

Author: makslevental

mlir/test/lib/Conversion/MathToVCIX/TestMathToVCIXConversion.cpp

@@ -69,25 +69,25 @@ struct MathCosToVCIX final : OpRewritePattern<math::CosOp> {
  if (legalType.isScalable())
  // Use arbitrary runtime vector length when vector type is scalable.
  // Proper conversion pass should take it from the IR.
- rvl = rewriter.create<arith::ConstantOp>(loc,
-  rewriter.getI64IntegerAttr(9));
+ rvl = arith::ConstantOp::create(rewriter, loc,
+ rewriter.getI64IntegerAttr(9));
  Value res;
  if (n == 1) {
- res = rewriter.create<vcix::BinaryImmOp>(loc, legalType, opcodeAttr, vec,
-  immAttr, rvl);
+ res = vcix::BinaryImmOp::create(rewriter, loc, legalType, opcodeAttr, vec,
+ immAttr, rvl);
  } else {
  const unsigned eltCount = legalType.getShape()[0];
  Type eltTy = legalType.getElementType();
- Value zero = rewriter.create<arith::ConstantOp>(
- loc, eltTy, rewriter.getZeroAttr(eltTy));
- res = rewriter.create<vector::BroadcastOp>(loc, opType, zero /*dummy*/);
+ Value zero = arith::ConstantOp::create(rewriter, loc, eltTy,
+   rewriter.getZeroAttr(eltTy));
+ res = vector::BroadcastOp::create(rewriter, loc, opType, zero /*dummy*/);
  for (unsigned i = 0; i < n; ++i) {
- Value extracted = rewriter.create<vector::ScalableExtractOp>(
- loc, legalType, vec, i * eltCount);
- Value v = rewriter.create<vcix::BinaryImmOp>(loc, legalType, opcodeAttr,
-   extracted, immAttr, rvl);
- res = rewriter.create<vector::ScalableInsertOp>(loc, v, res,
-  i * eltCount);
+ Value extracted = vector::ScalableExtractOp::create(
+ rewriter, loc, legalType, vec, i * eltCount);
+ Value v = vcix::BinaryImmOp::create(
+ rewriter, loc, legalType, opcodeAttr, extracted, immAttr, rvl);
+ res = vector::ScalableInsertOp::create(rewriter, loc, v, res,
+ i * eltCount);
  }
  }
  rewriter.replaceOp(op, res);
@@ -112,25 +112,25 @@ struct MathSinToVCIX final : OpRewritePattern<math::SinOp> {
  if (legalType.isScalable())
  // Use arbitrary runtime vector length when vector type is scalable.
  // Proper conversion pass should take it from the IR.
- rvl = rewriter.create<arith::ConstantOp>(loc,
-  rewriter.getI64IntegerAttr(9));
+ rvl = arith::ConstantOp::create(rewriter, loc,
+ rewriter.getI64IntegerAttr(9));
  Value res;
  if (n == 1) {
- res = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr, vec,
-  vec, rvl);
+ res = vcix::BinaryOp::create(rewriter, loc, legalType, opcodeAttr, vec,
+ vec, rvl);
  } else {
  const unsigned eltCount = legalType.getShape()[0];
  Type eltTy = legalType.getElementType();
- Value zero = rewriter.create<arith::ConstantOp>(
- loc, eltTy, rewriter.getZeroAttr(eltTy));
- res = rewriter.create<vector::BroadcastOp>(loc, opType, zero /*dummy*/);
+ Value zero = arith::ConstantOp::create(rewriter, loc, eltTy,
+   rewriter.getZeroAttr(eltTy));
+ res = vector::BroadcastOp::create(rewriter, loc, opType, zero /*dummy*/);
  for (unsigned i = 0; i < n; ++i) {
- Value extracted = rewriter.create<vector::ScalableExtractOp>(
- loc, legalType, vec, i * eltCount);
- Value v = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr,
-  extracted, extracted, rvl);
- res = rewriter.create<vector::ScalableInsertOp>(loc, v, res,
-  i * eltCount);
+ Value extracted = vector::ScalableExtractOp::create(
+ rewriter, loc, legalType, vec, i * eltCount);
+ Value v = vcix::BinaryOp::create(rewriter, loc, legalType, opcodeAttr,
+ extracted, extracted, rvl);
+ res = vector::ScalableInsertOp::create(rewriter, loc, v, res,
+ i * eltCount);
  }
  }
  rewriter.replaceOp(op, res);
@@ -152,28 +152,28 @@ struct MathTanToVCIX final : OpRewritePattern<math::TanOp> {
  Location loc = op.getLoc();
  Value vec = op.getOperand();
  Attribute opcodeAttr = rewriter.getI64IntegerAttr(0);
- Value zero = rewriter.create<arith::ConstantOp>(
- loc, eltTy, rewriter.getZeroAttr(eltTy));
+ Value zero = arith::ConstantOp::create(rewriter, loc, eltTy,
+   rewriter.getZeroAttr(eltTy));
  Value rvl = nullptr;
  if (legalType.isScalable())
  // Use arbitrary runtime vector length when vector type is scalable.
  // Proper conversion pass should take it from the IR.
- rvl = rewriter.create<arith::ConstantOp>(loc,
-  rewriter.getI64IntegerAttr(9));
+ rvl = arith::ConstantOp::create(rewriter, loc,
+ rewriter.getI64IntegerAttr(9));
  Value res;
  if (n == 1) {
- res = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr, vec,
-  zero, rvl);
+ res = vcix::BinaryOp::create(rewriter, loc, legalType, opcodeAttr, vec,
+ zero, rvl);
  } else {
  const unsigned eltCount = legalType.getShape()[0];
- res = rewriter.create<vector::BroadcastOp>(loc, opType, zero /*dummy*/);
+ res = vector::BroadcastOp::create(rewriter, loc, opType, zero /*dummy*/);
  for (unsigned i = 0; i < n; ++i) {
- Value extracted = rewriter.create<vector::ScalableExtractOp>(
- loc, legalType, vec, i * eltCount);
- Value v = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr,
-  extracted, zero, rvl);
- res = rewriter.create<vector::ScalableInsertOp>(loc, v, res,
-  i * eltCount);
+ Value extracted = vector::ScalableExtractOp::create(
+ rewriter, loc, legalType, vec, i * eltCount);
+ Value v = vcix::BinaryOp::create(rewriter, loc, legalType, opcodeAttr,
+ extracted, zero, rvl);
+ res = vector::ScalableInsertOp::create(rewriter, loc, v, res,
+ i * eltCount);
  }
  }
  rewriter.replaceOp(op, res);
@@ -195,30 +195,30 @@ struct MathLogToVCIX final : OpRewritePattern<math::LogOp> {
  Value vec = op.getOperand();
  Attribute opcodeAttr = rewriter.getI64IntegerAttr(0);
  Value rvl = nullptr;
- Value zeroInt = rewriter.create<arith::ConstantOp>(
- loc, rewriter.getI32Type(), rewriter.getI32IntegerAttr(0));
+ Value zeroInt = arith::ConstantOp::create(
+ rewriter, loc, rewriter.getI32Type(), rewriter.getI32IntegerAttr(0));
  if (legalType.isScalable())
  // Use arbitrary runtime vector length when vector type is scalable.
  // Proper conversion pass should take it from the IR.
- rvl = rewriter.create<arith::ConstantOp>(loc,
-  rewriter.getI64IntegerAttr(9));
+ rvl = arith::ConstantOp::create(rewriter, loc,
+ rewriter.getI64IntegerAttr(9));
  Value res;
  if (n == 1) {
- res = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr, vec,
-  zeroInt, rvl);
+ res = vcix::BinaryOp::create(rewriter, loc, legalType, opcodeAttr, vec,
+ zeroInt, rvl);
  } else {
  const unsigned eltCount = legalType.getShape()[0];
  Type eltTy = legalType.getElementType();
- Value zero = rewriter.create<arith::ConstantOp>(
- loc, eltTy, rewriter.getZeroAttr(eltTy));
- res = rewriter.create<vector::BroadcastOp>(loc, opType, zero /*dummy*/);
+ Value zero = arith::ConstantOp::create(rewriter, loc, eltTy,
+   rewriter.getZeroAttr(eltTy));
+ res = vector::BroadcastOp::create(rewriter, loc, opType, zero /*dummy*/);
  for (unsigned i = 0; i < n; ++i) {
- Value extracted = rewriter.create<vector::ScalableExtractOp>(
- loc, legalType, vec, i * eltCount);
- Value v = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr,
-  extracted, zeroInt, rvl);
- res = rewriter.create<vector::ScalableInsertOp>(loc, v, res,
-  i * eltCount);
+ Value extracted = vector::ScalableExtractOp::create(
+ rewriter, loc, legalType, vec, i * eltCount);
+ Value v = vcix::BinaryOp::create(rewriter, loc, legalType, opcodeAttr,
+ extracted, zeroInt, rvl);
+ res = vector::ScalableInsertOp::create(rewriter, loc, v, res,
+ i * eltCount);
  }
  }
  rewriter.replaceOp(op, res);

mlir/test/lib/Dialect/Affine/TestReifyValueBounds.cpp

@@ -145,7 +145,7 @@ static LogicalResult testReifyValueBounds(FunctionOpInterface funcOp,
  if (reifiedScalable->map.getNumInputs() == 1) {
  // The only possible input to the bound is vscale.
  vscaleOperand.push_back(std::make_pair(
- rewriter.create<vector::VectorScaleOp>(loc), std::nullopt));
+ vector::VectorScaleOp::create(rewriter, loc), std::nullopt));
  }
  reified = affine::materializeComputedBound(
  rewriter, loc, reifiedScalable->map, vscaleOperand);
@@ -169,8 +169,9 @@ static LogicalResult testReifyValueBounds(FunctionOpInterface funcOp,
  rewriter.replaceOp(op, val);
  return WalkResult::skip();
  }
- Value constOp = rewriter.create<arith::ConstantIndexOp>(
- op->getLoc(), cast<IntegerAttr>(cast<Attribute>(*reified)).getInt());
+ Value constOp = arith::ConstantIndexOp::create(
+ rewriter, op->getLoc(),
+ cast<IntegerAttr>(cast<Attribute>(*reified)).getInt());
  rewriter.replaceOp(op, constOp);
  return WalkResult::skip();
  });

mlir/test/lib/Dialect/Arith/TestEmulateWideInt.cpp

@@ -60,7 +60,7 @@ struct TestEmulateWideIntPass
  // casts (and vice versa) and using it insted of `llvm.bitcast`.
  auto addBitcast = [](OpBuilder &builder, Type type, ValueRange inputs,
  Location loc) -> Value {
- auto cast = builder.create<LLVM::BitcastOp>(loc, type, inputs);
+ auto cast = LLVM::BitcastOp::create(builder, loc, type, inputs);
  return cast->getResult(0);
  };
  typeConverter.addSourceMaterialization(addBitcast);

mlir/test/lib/Dialect/Func/TestDecomposeCallGraphTypes.cpp

@@ -48,8 +48,8 @@ static SmallVector<Value> buildDecomposeTuple(OpBuilder &builder,
  }
  for (unsigned i = 0, e = tupleType.size(); i < e; ++i) {
  Type elementType = tupleType.getType(i);
- Value element = builder.create<test::GetTupleElementOp>(
- loc, elementType, tuple, builder.getI32IntegerAttr(i));
+ Value element = test::GetTupleElementOp::create(
+ builder, loc, elementType, tuple, builder.getI32IntegerAttr(i));
  decompose(element);
  }
  };
@@ -94,7 +94,7 @@ static Value buildMakeTupleOp(OpBuilder &builder, TupleType resultType,
  }
 
  // Assemble the tuple from the elements.
- return builder.create<test::MakeTupleOp>(loc, resultType, elements);
+ return test::MakeTupleOp::create(builder, loc, resultType, elements);
 }
 
 /// A pass for testing call graph type decomposition.

mlir/test/lib/Dialect/SCF/TestSCFUtils.cpp

@@ -56,7 +56,7 @@ struct TestSCFForUtilsPass
  SmallVector<Value> newYieldValues;
  for (auto yieldVal : oldYieldValues) {
  newYieldValues.push_back(
- b.create<arith::AddFOp>(loc, yieldVal, yieldVal));
+ arith::AddFOp::create(b, loc, yieldVal, yieldVal));
  }
  return newYieldValues;
  };
@@ -160,13 +160,13 @@ struct TestSCFPipeliningPass
  Value pred) {
  Location loc = op->getLoc();
  auto ifOp =
- rewriter.create<scf::IfOp>(loc, op->getResultTypes(), pred, true);
+ scf::IfOp::create(rewriter, loc, op->getResultTypes(), pred, true);
  // True branch.
  rewriter.moveOpBefore(op, &ifOp.getThenRegion().front(),
  ifOp.getThenRegion().front().begin());
  rewriter.setInsertionPointAfter(op);
  if (op->getNumResults() > 0)
- rewriter.create<scf::YieldOp>(loc, op->getResults());
+ scf::YieldOp::create(rewriter, loc, op->getResults());
  // False branch.
  rewriter.setInsertionPointToStart(&ifOp.getElseRegion().front());
  SmallVector<Value> elseYieldOperands;
@@ -181,12 +181,12 @@ struct TestSCFPipeliningPass
  } else {
  // Default to assuming constant numeric values.
  for (Type type : op->getResultTypes()) {
- elseYieldOperands.push_back(rewriter.create<arith::ConstantOp>(
- loc, rewriter.getZeroAttr(type)));
+ elseYieldOperands.push_back(arith::ConstantOp::create(
+ rewriter, loc, rewriter.getZeroAttr(type)));
  }
  }
  if (op->getNumResults() > 0)
- rewriter.create<scf::YieldOp>(loc, elseYieldOperands);
+ scf::YieldOp::create(rewriter, loc, elseYieldOperands);
  return ifOp.getOperation();
  }
 

mlir/test/lib/Dialect/SCF/TestWhileOpBuilder.cpp

@@ -50,23 +50,23 @@ struct TestSCFWhileOpBuilderPass
  // Create a WhileOp with the same operands and result types.
  TypeRange resultTypes = whileOp->getResultTypes();
  ValueRange operands = whileOp->getOperands();
- builder.create<WhileOp>(
- loc, resultTypes, operands, /*beforeBuilder=*/
+ WhileOp::create(
+ builder, loc, resultTypes, operands, /*beforeBuilder=*/
  [&](OpBuilder &b, Location loc, ValueRange args) {
  // Just cast the before args into the right types for condition.
  ImplicitLocOpBuilder builder(loc, b);
  auto castOp =
- builder.create<UnrealizedConversionCastOp>(resultTypes, args);
- auto cmp = builder.create<ConstantIntOp>(/*value=*/1, /*width=*/1);
- builder.create<ConditionOp>(cmp, castOp->getResults());
+ UnrealizedConversionCastOp::create(builder, resultTypes, args);
+ auto cmp = ConstantIntOp::create(builder, /*value=*/1, /*width=*/1);
+ ConditionOp::create(builder, cmp, castOp->getResults());
  },
  /*afterBuilder=*/
  [&](OpBuilder &b, Location loc, ValueRange args) {
  // Just cast the after args into the right types for yield.
  ImplicitLocOpBuilder builder(loc, b);
- auto castOp = builder.create<UnrealizedConversionCastOp>(
- operands.getTypes(), args);
- builder.create<YieldOp>(castOp->getResults());
+ auto castOp = UnrealizedConversionCastOp::create(
+ builder, operands.getTypes(), args);
+ YieldOp::create(builder, castOp->getResults());
  });
  });
  }

mlir/test/lib/Dialect/Tensor/TestTensorTransforms.cpp

@@ -192,8 +192,8 @@ struct RewriteExtractSliceFromCollapseShapeBase
  // Create the destination tensor using the above values.
  Type elementType = op.getSourceType().getElementType();
  SmallVector<OpFoldResult> outputShape = reifiedShapes[0];
- Value dest = rewriter.create<tensor::EmptyOp>(op->getLoc(), outputShape,
-  elementType);
+ Value dest = tensor::EmptyOp::create(rewriter, op->getLoc(), outputShape,
+ elementType);
 
  // Calculate the parameters for the tile loop nest.
  FailureOr<tensor::ExtractSliceFromCollapseHelper> params =
@@ -215,8 +215,8 @@ struct RewriteExtractSliceFromCollapseShapeUsingScfFor
  PatternRewriter &rewriter) const override {
  Location loc = op.getLoc();
  const unsigned numTiledDims = helper.getIterationSpaceSizes().size();
- auto zero = rewriter.create<arith::ConstantIndexOp>(loc, 0);
- auto one = rewriter.create<arith::ConstantIndexOp>(loc, 1);
+ auto zero = arith::ConstantIndexOp::create(rewriter, loc, 0);
+ auto one = arith::ConstantIndexOp::create(rewriter, loc, 1);
  SmallVector<Value> lbs(numTiledDims, zero);
  SmallVector<Value> steps(numTiledDims, one);
 
@@ -228,8 +228,8 @@ struct RewriteExtractSliceFromCollapseShapeUsingScfFor
  helper.emitLoopNestBody(nestedBuilder, loc, outputIvs);
 
  // Insert the slice into the destination.
- return {nestedBuilder.create<tensor::InsertSliceOp>(
- loc, tile, iterArgs[0], insertParams)};
+ return {tensor::InsertSliceOp::create(nestedBuilder, loc, tile,
+   iterArgs[0], insertParams)};
  });
  rewriter.replaceOp(op, nest.results);
 
@@ -245,8 +245,9 @@ struct RewriteExtractSliceFromCollapseShapeUsingScfForeach
  tensor::ExtractSliceFromCollapseHelper &helper,
  PatternRewriter &rewriter) const override {
  Location loc = op.getLoc();
- auto forallOp = rewriter.create<scf::ForallOp>(
- loc, /*numThreads=*/getAsOpFoldResult(helper.getIterationSpaceSizes()),
+ auto forallOp = scf::ForallOp::create(
+ rewriter, loc,
+ /*numThreads=*/getAsOpFoldResult(helper.getIterationSpaceSizes()),
  /*outputs=*/dest,
  /*mapping=*/std::nullopt,
  [&](OpBuilder &nestedBuilder, Location loc, ValueRange regionArgs) {
@@ -261,10 +262,10 @@ struct RewriteExtractSliceFromCollapseShapeUsingScfForeach
  auto [tile, insertParams] =
  helper.emitLoopNestBody(nestedBuilder, loc, outputIvs);
  // Insert the slice into the destination.
- auto term = nestedBuilder.create<scf::InParallelOp>(loc);
+ auto term = scf::InParallelOp::create(nestedBuilder, loc);
  nestedBuilder.setInsertionPointToStart(term.getBody());
- nestedBuilder.create<tensor::ParallelInsertSliceOp>(
- loc, tile, outputArgs[0], insertParams);
+ tensor::ParallelInsertSliceOp::create(nestedBuilder, loc, tile,
+   outputArgs[0], insertParams);
  });
  rewriter.replaceOp(op, forallOp->getResult(0));
  return success();
@@ -355,8 +356,8 @@ static LogicalResult testTrackingListenerReplacements(Operation *rootOp) {
  MLIRContext *context = rootOp->getContext();
  OpBuilder builder(context);
  OwningOpRef<transform::NamedSequenceOp> transformOp =
- builder.create<transform::NamedSequenceOp>(
- rootOp->getLoc(),
+ transform::NamedSequenceOp::create(
+ builder, rootOp->getLoc(),
  /*sym_name=*/"test_sequence",
  /*function_type=*/
  TypeAttr::get(FunctionType::get(context, TypeRange{}, TypeRange{})),

mlir/test/lib/Dialect/Test/TestDialect.cpp

@@ -346,7 +346,7 @@ TestDialect::~TestDialect() {
 
 Operation *TestDialect::materializeConstant(OpBuilder &builder, Attribute value,
  Type type, Location loc) {
- return builder.create<TestOpConstant>(loc, type, value);
+ return TestOpConstant::create(builder, loc, type, value);
 }
 
 void *TestDialect::getRegisteredInterfaceForOp(TypeID typeID,