4 changes: 2 additions & 2 deletions mlir/include/mlir/IR/Builders.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -327,7 +327,7 @@ class OpBuilder : public Builder {
template <typename OpTy, typename... Args>
OpTy create(Location location, Args &&... args) {
OperationState state(location, OpTy::getOperationName());
OpTy::build(this, state, std::forward<Args>(args)...);
OpTy::build(*this, state, std::forward<Args>(args)...);
auto *op = createOperation(state);
auto result = dyn_cast<OpTy>(op);
assert(result && "builder didn't return the right type");
Expand All @@ -343,7 +343,7 @@ class OpBuilder : public Builder {
// Create the operation without using 'createOperation' as we don't want to
// insert it yet.
OperationState state(location, OpTy::getOperationName());
OpTy::build(this, state, std::forward<Args>(args)...);
OpTy::build(*this, state, std::forward<Args>(args)...);
Operation *op = Operation::create(state);

// Fold the operation. If successful destroy it, otherwise insert it.
Expand Down
4 changes: 2 additions & 2 deletions mlir/include/mlir/IR/Function.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -50,9 +50,9 @@ class FuncOp
ArrayRef<NamedAttribute> attrs,
ArrayRef<NamedAttributeList> argAttrs);

static void build(Builder *builder, OperationState &result, StringRef name,
static void build(OpBuilder &builder, OperationState &result, StringRef name,
FunctionType type, ArrayRef<NamedAttribute> attrs);
static void build(Builder *builder, OperationState &result, StringRef name,
static void build(OpBuilder &builder, OperationState &result, StringRef name,
FunctionType type, ArrayRef<NamedAttribute> attrs,
ArrayRef<NamedAttributeList> argAttrs);

Expand Down
4 changes: 2 additions & 2 deletions mlir/include/mlir/IR/Module.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -39,7 +39,7 @@ class ModuleOp

static StringRef getOperationName() { return "module"; }

static void build(Builder *builder, OperationState &result,
static void build(OpBuilder &builder, OperationState &result,
Optional<StringRef> name = llvm::None);

/// Construct a module from the given location with an optional name.
Expand Down Expand Up @@ -117,7 +117,7 @@ class ModuleTerminatorOp
public:
using Op::Op;
static StringRef getOperationName() { return "module_terminator"; }
static void build(Builder *, OperationState &) {}
static void build(OpBuilder &, OperationState &) {}
};

/// This class acts as an owning reference to a module, and will automatically
Expand Down
6 changes: 3 additions & 3 deletions mlir/include/mlir/IR/OpBase.td
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1803,7 +1803,7 @@ def successor;
// The signature of the builder is always
//
// ```c++
// static void build(Builder *builder, OperationState &state,
// static void build(OpBuilder &builder, OperationState &state,
// <other-parameters>...) {
// <body>...
// }
Expand Down Expand Up @@ -1883,15 +1883,15 @@ class Op<Dialect dialect, string mnemonic, list<OpTrait> props = []> {
// following signatures:
//
// ```c++
// static void build(Builder *, OperationState &odsState,
// static void build(OpBuilder &, OperationState &odsState,
// Type <result0-name>, Type <result1-name>, ...,
// Value <arg0-name>, Value <arg1-name>, ...,
// Attribute <attr0-name>, Attribute <attr1-name>, ...);
// ```
// * where the attributes follow the same declaration order as in the op.
//
// ```c++
// static void build(Builder *, OperationState &odsState,
// static void build(OpBuilder &, OperationState &odsState,
// ArrayRef<Type> resultTypes,
// ArrayRef<Value> operands,
// ArrayRef<NamedAttribute> attributes);
Expand Down
14 changes: 8 additions & 6 deletions mlir/include/mlir/IR/OpDefinition.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -25,6 +25,7 @@

namespace mlir {
class Builder;
class OpBuilder;

namespace OpTrait {
template <typename ConcreteType> class OneResult;
Expand Down Expand Up @@ -77,14 +78,15 @@ namespace impl {
/// region's only block if it does not have a terminator already. If the region
/// is empty, insert a new block first. `buildTerminatorOp` should return the
/// terminator operation to insert.
void ensureRegionTerminator(Region &region, Location loc,
function_ref<Operation *()> buildTerminatorOp);
void ensureRegionTerminator(
Region &region, Location loc,
function_ref<Operation *(OpBuilder &)> buildTerminatorOp);
/// Templated version that fills the generates the provided operation type.
template <typename OpTy>
void ensureRegionTerminator(Region &region, Builder &builder, Location loc) {
ensureRegionTerminator(region, loc, [&] {
ensureRegionTerminator(region, loc, [&](OpBuilder &b) {
OperationState state(loc, OpTy::getOperationName());
OpTy::build(&builder, state);
OpTy::build(b, state);
return Operation::create(state);
});
}
Expand Down Expand Up @@ -1422,7 +1424,7 @@ namespace impl {
ParseResult parseOneResultOneOperandTypeOp(OpAsmParser &parser,
OperationState &result);

void buildBinaryOp(Builder *builder, OperationState &result, Value lhs,
void buildBinaryOp(OpBuilder &builder, OperationState &result, Value lhs,
Value rhs);
ParseResult parseOneResultSameOperandTypeOp(OpAsmParser &parser,
OperationState &result);
Expand All @@ -1436,7 +1438,7 @@ void printOneResultOp(Operation *op, OpAsmPrinter &p);
// These functions are out-of-line implementations of the methods in CastOp,
// which avoids them being template instantiated/duplicated.
namespace impl {
void buildCastOp(Builder *builder, OperationState &result, Value source,
void buildCastOp(OpBuilder &builder, OperationState &result, Value source,
Type destType);
ParseResult parseCastOp(OpAsmParser &parser, OperationState &result);
void printCastOp(Operation *op, OpAsmPrinter &p);
Expand Down
4 changes: 2 additions & 2 deletions mlir/include/mlir/IR/PatternMatch.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -218,7 +218,7 @@ class PatternRewriter : public OpBuilder {
template <typename OpTy, typename... Args>
OpTy create(Location location, Args... args) {
OperationState state(location, OpTy::getOperationName());
OpTy::build(this, state, args...);
OpTy::build(*this, state, args...);
auto *op = createOperation(state);
auto result = dyn_cast<OpTy>(op);
assert(result && "Builder didn't return the right type");
Expand All @@ -231,7 +231,7 @@ class PatternRewriter : public OpBuilder {
template <typename OpTy, typename... Args>
OpTy createChecked(Location location, Args... args) {
OperationState state(location, OpTy::getOperationName());
OpTy::build(this, state, args...);
OpTy::build(*this, state, args...);
auto *op = createOperation(state);

// If the Operation we produce is valid, return it.
Expand Down
2 changes: 1 addition & 1 deletion mlir/include/mlir/Transforms/FoldUtils.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -81,7 +81,7 @@ class OperationFolder {
// fold). Using create methods of the builder will insert the op, so not
// using it here.
OperationState state(location, OpTy::getOperationName());
OpTy::build(&builder, state, std::forward<Args>(args)...);
OpTy::build(builder, state, std::forward<Args>(args)...);
Operation *op = Operation::create(state);

if (failed(tryToFold(builder, op, results)) || op->getNumResults() == 0) {
Expand Down
12 changes: 6 additions & 6 deletions mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRV.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -164,7 +164,7 @@ LogicalResult SingleWorkgroupReduction::matchAndRewrite(

// Get the output element accessed by this reduction.
Value zero = spirv::ConstantOp::getZero(
typeConverter.getIndexType(rewriter.getContext()), loc, &rewriter);
typeConverter.getIndexType(rewriter.getContext()), loc, rewriter);
SmallVector<Value, 1> zeroIndices(originalOutputType.getRank(), zero);
Value outputElementPtr =
spirv::getElementPtr(typeConverter, originalOutputType, convertedOutput,
Expand All @@ -181,18 +181,18 @@ LogicalResult SingleWorkgroupReduction::matchAndRewrite(
Value condition = rewriter.create<spirv::GroupNonUniformElectOp>(
loc, spirv::Scope::Subgroup);

auto createAtomicOp = [&](OpBuilder *builder) {
auto createAtomicOp = [&](OpBuilder &builder) {
#define CREATE_ATOMIC_BIN_OP(opKind, spvOp) \
case linalg::RegionMatcher::BinaryOpKind::opKind: { \
builder->create<spirv::spvOp>(loc, outputElementPtr, spirv::Scope::Device, \
spirv::MemorySemantics::AcquireRelease, \
groupOperation); \
builder.create<spirv::spvOp>(loc, outputElementPtr, spirv::Scope::Device, \
spirv::MemorySemantics::AcquireRelease, \
groupOperation); \
} break
switch (*binaryOpKind) { CREATE_ATOMIC_BIN_OP(IAdd, AtomicIAddOp); }
#undef CREATE_ATOMIC_BIN_OP
};

spirv::SelectionOp::createIfThen(loc, condition, createAtomicOp, &rewriter);
spirv::SelectionOp::createIfThen(loc, condition, createAtomicOp, rewriter);

rewriter.eraseOp(genericOp);
return success();
Expand Down
68 changes: 34 additions & 34 deletions mlir/lib/Dialect/Affine/IR/AffineOps.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -920,7 +920,7 @@ static LogicalResult foldMemRefCast(Operation *op) {
//===----------------------------------------------------------------------===//

// TODO(b/133776335) Check that map operands are loop IVs or symbols.
void AffineDmaStartOp::build(Builder *builder, OperationState &result,
void AffineDmaStartOp::build(OpBuilder &builder, OperationState &result,
Value srcMemRef, AffineMap srcMap,
ValueRange srcIndices, Value destMemRef,
AffineMap dstMap, ValueRange destIndices,
Expand Down Expand Up @@ -1090,7 +1090,7 @@ LogicalResult AffineDmaStartOp::fold(ArrayRef<Attribute> cstOperands,
//===----------------------------------------------------------------------===//

// TODO(b/133776335) Check that map operands are loop IVs or symbols.
void AffineDmaWaitOp::build(Builder *builder, OperationState &result,
void AffineDmaWaitOp::build(OpBuilder &builder, OperationState &result,
Value tagMemRef, AffineMap tagMap,
ValueRange tagIndices, Value numElements) {
result.addOperands(tagMemRef);
Expand Down Expand Up @@ -1166,7 +1166,7 @@ LogicalResult AffineDmaWaitOp::fold(ArrayRef<Attribute> cstOperands,
// AffineForOp
//===----------------------------------------------------------------------===//

void AffineForOp::build(Builder *builder, OperationState &result,
void AffineForOp::build(OpBuilder &builder, OperationState &result,
ValueRange lbOperands, AffineMap lbMap,
ValueRange ubOperands, AffineMap ubMap, int64_t step) {
assert(((!lbMap && lbOperands.empty()) ||
Expand All @@ -1179,7 +1179,7 @@ void AffineForOp::build(Builder *builder, OperationState &result,

// Add an attribute for the step.
result.addAttribute(getStepAttrName(),
builder->getIntegerAttr(builder->getIndexType(), step));
builder.getIntegerAttr(builder.getIndexType(), step));

// Add the lower bound.
result.addAttribute(getLowerBoundAttrName(), AffineMapAttr::get(lbMap));
Expand All @@ -1193,15 +1193,15 @@ void AffineForOp::build(Builder *builder, OperationState &result,
// the loop induction variable.
Region *bodyRegion = result.addRegion();
Block *body = new Block();
body->addArgument(IndexType::get(builder->getContext()));
body->addArgument(IndexType::get(builder.getContext()));
bodyRegion->push_back(body);
ensureTerminator(*bodyRegion, *builder, result.location);
ensureTerminator(*bodyRegion, builder, result.location);
}

void AffineForOp::build(Builder *builder, OperationState &result, int64_t lb,
void AffineForOp::build(OpBuilder &builder, OperationState &result, int64_t lb,
int64_t ub, int64_t step) {
auto lbMap = AffineMap::getConstantMap(lb, builder->getContext());
auto ubMap = AffineMap::getConstantMap(ub, builder->getContext());
auto lbMap = AffineMap::getConstantMap(lb, builder.getContext());
auto ubMap = AffineMap::getConstantMap(ub, builder.getContext());
return build(builder, result, {}, lbMap, {}, ubMap, step);
}

Expand Down Expand Up @@ -1806,15 +1806,15 @@ void AffineIfOp::setConditional(IntegerSet set, ValueRange operands) {
getOperation()->setOperands(operands);
}

void AffineIfOp::build(Builder *builder, OperationState &result, IntegerSet set,
ValueRange args, bool withElseRegion) {
void AffineIfOp::build(OpBuilder &builder, OperationState &result,
IntegerSet set, ValueRange args, bool withElseRegion) {
result.addOperands(args);
result.addAttribute(getConditionAttrName(), IntegerSetAttr::get(set));
Region *thenRegion = result.addRegion();
Region *elseRegion = result.addRegion();
AffineIfOp::ensureTerminator(*thenRegion, *builder, result.location);
AffineIfOp::ensureTerminator(*thenRegion, builder, result.location);
if (withElseRegion)
AffineIfOp::ensureTerminator(*elseRegion, *builder, result.location);
AffineIfOp::ensureTerminator(*elseRegion, builder, result.location);
}

/// Canonicalize an affine if op's conditional (integer set + operands).
Expand Down Expand Up @@ -1845,7 +1845,7 @@ void AffineIfOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
// AffineLoadOp
//===----------------------------------------------------------------------===//

void AffineLoadOp::build(Builder *builder, OperationState &result,
void AffineLoadOp::build(OpBuilder &builder, OperationState &result,
AffineMap map, ValueRange operands) {
assert(operands.size() == 1 + map.getNumInputs() && "inconsistent operands");
result.addOperands(operands);
Expand All @@ -1855,8 +1855,8 @@ void AffineLoadOp::build(Builder *builder, OperationState &result,
result.types.push_back(memrefType.getElementType());
}

void AffineLoadOp::build(Builder *builder, OperationState &result, Value memref,
AffineMap map, ValueRange mapOperands) {
void AffineLoadOp::build(OpBuilder &builder, OperationState &result,
Value memref, AffineMap map, ValueRange mapOperands) {
assert(map.getNumInputs() == mapOperands.size() && "inconsistent index info");
result.addOperands(memref);
result.addOperands(mapOperands);
Expand All @@ -1865,14 +1865,14 @@ void AffineLoadOp::build(Builder *builder, OperationState &result, Value memref,
result.types.push_back(memrefType.getElementType());
}

void AffineLoadOp::build(Builder *builder, OperationState &result, Value memref,
ValueRange indices) {
void AffineLoadOp::build(OpBuilder &builder, OperationState &result,
Value memref, ValueRange indices) {
auto memrefType = memref.getType().cast<MemRefType>();
auto rank = memrefType.getRank();
// Create identity map for memrefs with at least one dimension or () -> ()
// for zero-dimensional memrefs.
auto map = rank ? builder->getMultiDimIdentityMap(rank)
: builder->getEmptyAffineMap();
auto map =
rank ? builder.getMultiDimIdentityMap(rank) : builder.getEmptyAffineMap();
build(builder, result, memref, map, indices);
}

Expand Down Expand Up @@ -1948,7 +1948,7 @@ OpFoldResult AffineLoadOp::fold(ArrayRef<Attribute> cstOperands) {
// AffineStoreOp
//===----------------------------------------------------------------------===//

void AffineStoreOp::build(Builder *builder, OperationState &result,
void AffineStoreOp::build(OpBuilder &builder, OperationState &result,
Value valueToStore, Value memref, AffineMap map,
ValueRange mapOperands) {
assert(map.getNumInputs() == mapOperands.size() && "inconsistent index info");
Expand All @@ -1959,15 +1959,15 @@ void AffineStoreOp::build(Builder *builder, OperationState &result,
}

// Use identity map.
void AffineStoreOp::build(Builder *builder, OperationState &result,
void AffineStoreOp::build(OpBuilder &builder, OperationState &result,
Value valueToStore, Value memref,
ValueRange indices) {
auto memrefType = memref.getType().cast<MemRefType>();
auto rank = memrefType.getRank();
// Create identity map for memrefs with at least one dimension or () -> ()
// for zero-dimensional memrefs.
auto map = rank ? builder->getMultiDimIdentityMap(rank)
: builder->getEmptyAffineMap();
auto map =
rank ? builder.getMultiDimIdentityMap(rank) : builder.getEmptyAffineMap();
build(builder, result, valueToStore, memref, map, indices);
}

Expand Down Expand Up @@ -2268,19 +2268,19 @@ LogicalResult AffinePrefetchOp::fold(ArrayRef<Attribute> cstOperands,
// AffineParallelOp
//===----------------------------------------------------------------------===//

void AffineParallelOp::build(Builder *builder, OperationState &result,
void AffineParallelOp::build(OpBuilder &builder, OperationState &result,
ArrayRef<int64_t> ranges) {
SmallVector<AffineExpr, 8> lbExprs(ranges.size(),
builder->getAffineConstantExpr(0));
auto lbMap = AffineMap::get(0, 0, lbExprs, builder->getContext());
builder.getAffineConstantExpr(0));
auto lbMap = AffineMap::get(0, 0, lbExprs, builder.getContext());
SmallVector<AffineExpr, 8> ubExprs;
for (int64_t range : ranges)
ubExprs.push_back(builder->getAffineConstantExpr(range));
auto ubMap = AffineMap::get(0, 0, ubExprs, builder->getContext());
ubExprs.push_back(builder.getAffineConstantExpr(range));
auto ubMap = AffineMap::get(0, 0, ubExprs, builder.getContext());
build(builder, result, lbMap, {}, ubMap, {});
}

void AffineParallelOp::build(Builder *builder, OperationState &result,
void AffineParallelOp::build(OpBuilder &builder, OperationState &result,
AffineMap lbMap, ValueRange lbArgs,
AffineMap ubMap, ValueRange ubArgs) {
auto numDims = lbMap.getNumResults();
Expand All @@ -2292,7 +2292,7 @@ void AffineParallelOp::build(Builder *builder, OperationState &result,
build(builder, result, lbMap, lbArgs, ubMap, ubArgs, steps);
}

void AffineParallelOp::build(Builder *builder, OperationState &result,
void AffineParallelOp::build(OpBuilder &builder, OperationState &result,
AffineMap lbMap, ValueRange lbArgs,
AffineMap ubMap, ValueRange ubArgs,
ArrayRef<int64_t> steps) {
Expand All @@ -2303,17 +2303,17 @@ void AffineParallelOp::build(Builder *builder, OperationState &result,
assert(numDims == steps.size() && "num dims and num steps mismatch");
result.addAttribute(getLowerBoundsMapAttrName(), AffineMapAttr::get(lbMap));
result.addAttribute(getUpperBoundsMapAttrName(), AffineMapAttr::get(ubMap));
result.addAttribute(getStepsAttrName(), builder->getI64ArrayAttr(steps));
result.addAttribute(getStepsAttrName(), builder.getI64ArrayAttr(steps));
result.addOperands(lbArgs);
result.addOperands(ubArgs);
// Create a region and a block for the body.
auto bodyRegion = result.addRegion();
auto body = new Block();
// Add all the block arguments.
for (unsigned i = 0; i < numDims; ++i)
body->addArgument(IndexType::get(builder->getContext()));
body->addArgument(IndexType::get(builder.getContext()));
bodyRegion->push_back(body);
ensureTerminator(*bodyRegion, *builder, result.location);
ensureTerminator(*bodyRegion, builder, result.location);
}

unsigned AffineParallelOp::getNumDims() { return steps().size(); }
Expand Down
34 changes: 17 additions & 17 deletions mlir/lib/Dialect/GPU/IR/GPUDialect.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -200,9 +200,9 @@ static ParseResult parseShuffleOp(OpAsmParser &parser, OperationState &state) {
// LaunchOp
//===----------------------------------------------------------------------===//

void LaunchOp::build(Builder *builder, OperationState &result, Value gridSizeX,
Value gridSizeY, Value gridSizeZ, Value blockSizeX,
Value blockSizeY, Value blockSizeZ) {
void LaunchOp::build(OpBuilder &builder, OperationState &result,
Value gridSizeX, Value gridSizeY, Value gridSizeZ,
Value blockSizeX, Value blockSizeY, Value blockSizeZ) {
// Add grid and block sizes as op operands, followed by the data operands.
result.addOperands(
{gridSizeX, gridSizeY, gridSizeZ, blockSizeX, blockSizeY, blockSizeZ});
Expand All @@ -213,7 +213,7 @@ void LaunchOp::build(Builder *builder, OperationState &result, Value gridSizeX,
Region *kernelRegion = result.addRegion();
Block *body = new Block();
body->addArguments(
std::vector<Type>(kNumConfigRegionAttributes, builder->getIndexType()));
std::vector<Type>(kNumConfigRegionAttributes, builder.getIndexType()));
kernelRegion->push_back(body);
}

Expand Down Expand Up @@ -388,7 +388,7 @@ static ParseResult parseLaunchOp(OpAsmParser &parser, OperationState &result) {
// LaunchFuncOp
//===----------------------------------------------------------------------===//

void LaunchFuncOp::build(Builder *builder, OperationState &result,
void LaunchFuncOp::build(OpBuilder &builder, OperationState &result,
GPUFuncOp kernelFunc, Value gridSizeX, Value gridSizeY,
Value gridSizeZ, Value blockSizeX, Value blockSizeY,
Value blockSizeZ, ValueRange kernelOperands) {
Expand All @@ -397,13 +397,12 @@ void LaunchFuncOp::build(Builder *builder, OperationState &result,
{gridSizeX, gridSizeY, gridSizeZ, blockSizeX, blockSizeY, blockSizeZ});
result.addOperands(kernelOperands);
auto kernelModule = kernelFunc.getParentOfType<GPUModuleOp>();
auto kernelSymbol = builder->getSymbolRefAttr(
kernelModule.getName(),
{builder->getSymbolRefAttr(kernelFunc.getName())});
auto kernelSymbol = builder.getSymbolRefAttr(
kernelModule.getName(), {builder.getSymbolRefAttr(kernelFunc.getName())});
result.addAttribute(getKernelAttrName(), kernelSymbol);
}

void LaunchFuncOp::build(Builder *builder, OperationState &result,
void LaunchFuncOp::build(OpBuilder &builder, OperationState &result,
GPUFuncOp kernelFunc, KernelDim3 gridSize,
KernelDim3 blockSize, ValueRange kernelOperands) {
build(builder, result, kernelFunc, gridSize.x, gridSize.y, gridSize.z,
Expand Down Expand Up @@ -476,15 +475,16 @@ Value GPUFuncOp::addWorkgroupAttribution(ArrayRef<int64_t> shape,
return attribution;
}

void GPUFuncOp::build(Builder *builder, OperationState &result, StringRef name,
FunctionType type, ArrayRef<Type> workgroupAttributions,
void GPUFuncOp::build(OpBuilder &builder, OperationState &result,
StringRef name, FunctionType type,
ArrayRef<Type> workgroupAttributions,
ArrayRef<Type> privateAttributions,
ArrayRef<NamedAttribute> attrs) {
result.addAttribute(SymbolTable::getSymbolAttrName(),
builder->getStringAttr(name));
builder.getStringAttr(name));
result.addAttribute(getTypeAttrName(), TypeAttr::get(type));
result.addAttribute(getNumWorkgroupAttributionsAttrName(),
builder->getI64IntegerAttr(workgroupAttributions.size()));
builder.getI64IntegerAttr(workgroupAttributions.size()));
result.addAttributes(attrs);
Region *body = result.addRegion();
Block *entryBlock = new Block;
Expand Down Expand Up @@ -742,11 +742,11 @@ static LogicalResult verify(gpu::ReturnOp returnOp) {
// GPUModuleOp
//===----------------------------------------------------------------------===//

void GPUModuleOp::build(Builder *builder, OperationState &result,
void GPUModuleOp::build(OpBuilder &builder, OperationState &result,
StringRef name) {
ensureTerminator(*result.addRegion(), *builder, result.location);
result.attributes.push_back(builder->getNamedAttr(
::mlir::SymbolTable::getSymbolAttrName(), builder->getStringAttr(name)));
ensureTerminator(*result.addRegion(), builder, result.location);
result.attributes.push_back(builder.getNamedAttr(
::mlir::SymbolTable::getSymbolAttrName(), builder.getStringAttr(name)));
}

static ParseResult parseGPUModuleOp(OpAsmParser &parser,
Expand Down
4 changes: 2 additions & 2 deletions mlir/lib/Dialect/GPU/Transforms/KernelOutlining.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -265,10 +265,10 @@ class GpuKernelOutliningPass
// prevent manual building of Ops with symbols in code using SymbolTables
// and then this needs to use the OpBuilder.
auto context = getOperation().getContext();
Builder builder(context);
OpBuilder builder(context);
OperationState state(kernelFunc.getLoc(),
gpu::GPUModuleOp::getOperationName());
gpu::GPUModuleOp::build(&builder, state, kernelFunc.getName());
gpu::GPUModuleOp::build(builder, state, kernelFunc.getName());
auto kernelModule = cast<gpu::GPUModuleOp>(Operation::create(state));
SymbolTable symbolTable(kernelModule);
symbolTable.insert(kernelFunc);
Expand Down
28 changes: 14 additions & 14 deletions mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -612,7 +612,7 @@ static ParseResult parseCallOp(OpAsmParser &parser, OperationState &result) {
//===----------------------------------------------------------------------===//
// Expects vector to be of wrapped LLVM vector type and position to be of
// wrapped LLVM i32 type.
void LLVM::ExtractElementOp::build(Builder *b, OperationState &result,
void LLVM::ExtractElementOp::build(OpBuilder &b, OperationState &result,
Value vector, Value position,
ArrayRef<NamedAttribute> attrs) {
auto wrappedVectorType = vector.getType().cast<LLVM::LLVMType>();
Expand Down Expand Up @@ -892,21 +892,21 @@ static LogicalResult verify(AddressOfOp op) {
/// the name of the attribute in ODS.
static StringRef getLinkageAttrName() { return "linkage"; }

void GlobalOp::build(Builder *builder, OperationState &result, LLVMType type,
void GlobalOp::build(OpBuilder &builder, OperationState &result, LLVMType type,
bool isConstant, Linkage linkage, StringRef name,
Attribute value, unsigned addrSpace,
ArrayRef<NamedAttribute> attrs) {
result.addAttribute(SymbolTable::getSymbolAttrName(),
builder->getStringAttr(name));
builder.getStringAttr(name));
result.addAttribute("type", TypeAttr::get(type));
if (isConstant)
result.addAttribute("constant", builder->getUnitAttr());
result.addAttribute("constant", builder.getUnitAttr());
if (value)
result.addAttribute("value", value);
result.addAttribute(getLinkageAttrName(), builder->getI64IntegerAttr(
static_cast<int64_t>(linkage)));
result.addAttribute(getLinkageAttrName(),
builder.getI64IntegerAttr(static_cast<int64_t>(linkage)));
if (addrSpace != 0)
result.addAttribute("addr_space", builder->getI32IntegerAttr(addrSpace));
result.addAttribute("addr_space", builder.getI32IntegerAttr(addrSpace));
result.attributes.append(attrs.begin(), attrs.end());
result.addRegion();
}
Expand Down Expand Up @@ -1106,8 +1106,8 @@ static LogicalResult verify(GlobalOp op) {
//===----------------------------------------------------------------------===//
// Expects vector to be of wrapped LLVM vector type and position to be of
// wrapped LLVM i32 type.
void LLVM::ShuffleVectorOp::build(Builder *b, OperationState &result, Value v1,
Value v2, ArrayAttr mask,
void LLVM::ShuffleVectorOp::build(OpBuilder &b, OperationState &result,
Value v1, Value v2, ArrayAttr mask,
ArrayRef<NamedAttribute> attrs) {
auto wrappedContainerType1 = v1.getType().cast<LLVM::LLVMType>();
auto vType = LLVMType::getVectorTy(
Expand Down Expand Up @@ -1170,16 +1170,16 @@ Block *LLVMFuncOp::addEntryBlock() {
return entry;
}

void LLVMFuncOp::build(Builder *builder, OperationState &result, StringRef name,
LLVMType type, LLVM::Linkage linkage,
void LLVMFuncOp::build(OpBuilder &builder, OperationState &result,
StringRef name, LLVMType type, LLVM::Linkage linkage,
ArrayRef<NamedAttribute> attrs,
ArrayRef<NamedAttributeList> argAttrs) {
result.addRegion();
result.addAttribute(SymbolTable::getSymbolAttrName(),
builder->getStringAttr(name));
builder.getStringAttr(name));
result.addAttribute("type", TypeAttr::get(type));
result.addAttribute(getLinkageAttrName(), builder->getI64IntegerAttr(
static_cast<int64_t>(linkage)));
result.addAttribute(getLinkageAttrName(),
builder.getI64IntegerAttr(static_cast<int64_t>(linkage)));
result.attributes.append(attrs.begin(), attrs.end());
if (argAttrs.empty())
return;
Expand Down
24 changes: 12 additions & 12 deletions mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -470,25 +470,25 @@ getSymbolLessAffineMaps(ArrayRef<ArrayRef<AffineExpr>> reassociation) {
}

void mlir::linalg::ReshapeOp::build(
Builder *b, OperationState &result, Value src,
OpBuilder &b, OperationState &result, Value src,
ArrayRef<ArrayRef<AffineExpr>> reassociation,
ArrayRef<NamedAttribute> attrs) {
auto maps = getSymbolLessAffineMaps(reassociation);
auto memRefType = src.getType().cast<MemRefType>();
auto resultType = computeReshapeCollapsedType(memRefType, maps);
build(b, result, resultType, src, attrs);
result.addAttribute(ReshapeOp::getReassociationAttrName(),
b->getAffineMapArrayAttr(maps));
b.getAffineMapArrayAttr(maps));
}

void mlir::linalg::ReshapeOp::build(
Builder *b, OperationState &result, Type resultType, Value src,
OpBuilder &b, OperationState &result, Type resultType, Value src,
ArrayRef<ArrayRef<AffineExpr>> reassociation,
ArrayRef<NamedAttribute> attrs) {
auto maps = getSymbolLessAffineMaps(reassociation);
build(b, result, resultType, src, attrs);
result.addAttribute(ReshapeOp::getReassociationAttrName(),
b->getAffineMapArrayAttr(maps));
b.getAffineMapArrayAttr(maps));
}

// Common verifier for reshape-like types. Fills `expandedType` and
Expand Down Expand Up @@ -572,25 +572,25 @@ computeTensorReshapeCollapsedType(RankedTensorType type,
}

void mlir::linalg::TensorReshapeOp::build(
Builder *b, OperationState &result, Value src,
OpBuilder &b, OperationState &result, Value src,
ArrayRef<ArrayRef<AffineExpr>> reassociation,
ArrayRef<NamedAttribute> attrs) {
auto maps = getSymbolLessAffineMaps(reassociation);
auto resultType = computeTensorReshapeCollapsedType(
src.getType().cast<RankedTensorType>(), maps);
build(b, result, resultType, src, attrs);
result.addAttribute(TensorReshapeOp::getReassociationAttrName(),
b->getAffineMapArrayAttr(maps));
b.getAffineMapArrayAttr(maps));
}

void mlir::linalg::TensorReshapeOp::build(
Builder *b, OperationState &result, Type resultType, Value src,
OpBuilder &b, OperationState &result, Type resultType, Value src,
ArrayRef<ArrayRef<AffineExpr>> reassociation,
ArrayRef<NamedAttribute> attrs) {
auto maps = getSymbolLessAffineMaps(reassociation);
build(b, result, resultType, src, attrs);
result.addAttribute(TensorReshapeOp::getReassociationAttrName(),
b->getAffineMapArrayAttr(maps));
b.getAffineMapArrayAttr(maps));
}

static LogicalResult verify(TensorReshapeOp op) {
Expand All @@ -611,7 +611,7 @@ static LogicalResult verify(TensorReshapeOp op) {
//===----------------------------------------------------------------------===//
// SliceOp
//===----------------------------------------------------------------------===//
void mlir::linalg::SliceOp::build(Builder *b, OperationState &result,
void mlir::linalg::SliceOp::build(OpBuilder &b, OperationState &result,
Value base, ValueRange indexings) {
result.addOperands(base);
result.addOperands(indexings);
Expand All @@ -629,7 +629,7 @@ void mlir::linalg::SliceOp::build(Builder *b, OperationState &result,
result.addTypes({MemRefType::Builder(memRefType)
.setShape(sizes)
.setAffineMaps(makeStridedLinearLayoutMap(
strides, offset, b->getContext()))});
strides, offset, b.getContext()))});
}

static void print(OpAsmPrinter &p, SliceOp op) {
Expand Down Expand Up @@ -688,7 +688,7 @@ Value SliceOp::getViewSource() { return view(); }
//===----------------------------------------------------------------------===//
// TransposeOp
//===----------------------------------------------------------------------===//
void mlir::linalg::TransposeOp::build(Builder *b, OperationState &result,
void mlir::linalg::TransposeOp::build(OpBuilder &b, OperationState &result,
Value view, AffineMapAttr permutation,
ArrayRef<NamedAttribute> attrs) {
auto permutationMap = permutation.getValue();
Expand All @@ -709,7 +709,7 @@ void mlir::linalg::TransposeOp::build(Builder *b, OperationState &result,
auto res = getStridesAndOffset(memRefType, strides, offset);
assert(succeeded(res) && strides.size() == static_cast<unsigned>(rank));
(void)res;
auto map = makeStridedLinearLayoutMap(strides, offset, b->getContext());
auto map = makeStridedLinearLayoutMap(strides, offset, b.getContext());
map = permutationMap ? map.compose(permutationMap) : map;
// Compute result type.
MemRefType resultType =
Expand Down
36 changes: 19 additions & 17 deletions mlir/lib/Dialect/LoopOps/LoopOps.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -39,17 +39,17 @@ LoopOpsDialect::LoopOpsDialect(MLIRContext *context)
// ForOp
//===----------------------------------------------------------------------===//

void ForOp::build(Builder *builder, OperationState &result, Value lb, Value ub,
Value step, ValueRange iterArgs) {
void ForOp::build(OpBuilder &builder, OperationState &result, Value lb,
Value ub, Value step, ValueRange iterArgs) {
result.addOperands({lb, ub, step});
result.addOperands(iterArgs);
for (Value v : iterArgs)
result.addTypes(v.getType());
Region *bodyRegion = result.addRegion();
bodyRegion->push_back(new Block());
if (iterArgs.empty())
ForOp::ensureTerminator(*bodyRegion, *builder, result.location);
bodyRegion->front().addArgument(builder->getIndexType());
ForOp::ensureTerminator(*bodyRegion, builder, result.location);
bodyRegion->front().addArgument(builder.getIndexType());
for (Value v : iterArgs)
bodyRegion->front().addArgument(v.getType());
}
Expand Down Expand Up @@ -233,26 +233,26 @@ void ForOp::getSuccessorRegions(Optional<unsigned> index,
// IfOp
//===----------------------------------------------------------------------===//

void IfOp::build(Builder *builder, OperationState &result, Value cond,
void IfOp::build(OpBuilder &builder, OperationState &result, Value cond,
bool withElseRegion) {
build(builder, result, /*resultTypes=*/llvm::None, cond, withElseRegion);
}

void IfOp::build(Builder *builder, OperationState &result,
void IfOp::build(OpBuilder &builder, OperationState &result,
TypeRange resultTypes, Value cond, bool withElseRegion) {
result.addOperands(cond);
result.addTypes(resultTypes);

Region *thenRegion = result.addRegion();
thenRegion->push_back(new Block());
if (resultTypes.empty())
IfOp::ensureTerminator(*thenRegion, *builder, result.location);
IfOp::ensureTerminator(*thenRegion, builder, result.location);

Region *elseRegion = result.addRegion();
if (withElseRegion) {
elseRegion->push_back(new Block());
if (resultTypes.empty())
IfOp::ensureTerminator(*elseRegion, *builder, result.location);
IfOp::ensureTerminator(*elseRegion, builder, result.location);
}
}

Expand Down Expand Up @@ -371,22 +371,23 @@ void IfOp::getSuccessorRegions(Optional<unsigned> index,
// ParallelOp
//===----------------------------------------------------------------------===//

void ParallelOp::build(Builder *builder, OperationState &result, ValueRange lbs,
ValueRange ubs, ValueRange steps, ValueRange initVals) {
void ParallelOp::build(OpBuilder &builder, OperationState &result,
ValueRange lbs, ValueRange ubs, ValueRange steps,
ValueRange initVals) {
result.addOperands(lbs);
result.addOperands(ubs);
result.addOperands(steps);
result.addOperands(initVals);
result.addAttribute(
ParallelOp::getOperandSegmentSizeAttr(),
builder->getI32VectorAttr({static_cast<int32_t>(lbs.size()),
static_cast<int32_t>(ubs.size()),
static_cast<int32_t>(steps.size()),
static_cast<int32_t>(initVals.size())}));
builder.getI32VectorAttr({static_cast<int32_t>(lbs.size()),
static_cast<int32_t>(ubs.size()),
static_cast<int32_t>(steps.size()),
static_cast<int32_t>(initVals.size())}));
Region *bodyRegion = result.addRegion();
ParallelOp::ensureTerminator(*bodyRegion, *builder, result.location);
ParallelOp::ensureTerminator(*bodyRegion, builder, result.location);
for (size_t i = 0, e = steps.size(); i < e; ++i)
bodyRegion->front().addArgument(builder->getIndexType());
bodyRegion->front().addArgument(builder.getIndexType());
for (Value init : initVals)
result.addTypes(init.getType());
}
Expand Down Expand Up @@ -554,7 +555,8 @@ ParallelOp mlir::loop::getParallelForInductionVarOwner(Value val) {
// ReduceOp
//===----------------------------------------------------------------------===//

void ReduceOp::build(Builder *builder, OperationState &result, Value operand) {
void ReduceOp::build(OpBuilder &builder, OperationState &result,
Value operand) {
auto type = operand.getType();
result.addOperands(operand);
Region *bodyRegion = result.addRegion();
Expand Down
2 changes: 1 addition & 1 deletion mlir/lib/Dialect/SPIRV/SPIRVLowering.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -596,7 +596,7 @@ spirv::AccessChainOp mlir::spirv::getElementPtr(
}
SmallVector<Value, 2> linearizedIndices;
// Add a '0' at the start to index into the struct.
auto zero = spirv::ConstantOp::getZero(indexType, loc, &builder);
auto zero = spirv::ConstantOp::getZero(indexType, loc, builder);
linearizedIndices.push_back(zero);
// If it is a zero-rank memref type, extract the element directly.
if (!ptrLoc) {
Expand Down
113 changes: 56 additions & 57 deletions mlir/lib/Dialect/SPIRV/SPIRVOps.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -788,7 +788,7 @@ static Type getElementPtrType(Type type, ValueRange indices, Location baseLoc) {
return spirv::PointerType::get(resultType, resultStorageClass);
}

void spirv::AccessChainOp::build(Builder *builder, OperationState &state,
void spirv::AccessChainOp::build(OpBuilder &builder, OperationState &state,
Value basePtr, ValueRange indices) {
auto type = getElementPtrType(basePtr.getType(), indices, state.location);
assert(type && "Unable to deduce return type based on basePtr and indices");
Expand Down Expand Up @@ -857,9 +857,9 @@ static LogicalResult verify(spirv::AccessChainOp accessChainOp) {
// spv._address_of
//===----------------------------------------------------------------------===//

void spirv::AddressOfOp::build(Builder *builder, OperationState &state,
void spirv::AddressOfOp::build(OpBuilder &builder, OperationState &state,
spirv::GlobalVariableOp var) {
build(builder, state, var.type(), builder->getSymbolRefAttr(var));
build(builder, state, var.type(), builder.getSymbolRefAttr(var));
}

static LogicalResult verify(spirv::AddressOfOp addressOfOp) {
Expand Down Expand Up @@ -1163,10 +1163,10 @@ static LogicalResult verify(spirv::CompositeConstructOp compositeConstructOp) {
// spv.CompositeExtractOp
//===----------------------------------------------------------------------===//

void spirv::CompositeExtractOp::build(Builder *builder, OperationState &state,
void spirv::CompositeExtractOp::build(OpBuilder &builder, OperationState &state,
Value composite,
ArrayRef<int32_t> indices) {
auto indexAttr = builder->getI32ArrayAttr(indices);
auto indexAttr = builder.getI32ArrayAttr(indices);
auto elementType =
getElementType(composite.getType(), indexAttr, state.location);
if (!elementType) {
Expand Down Expand Up @@ -1386,28 +1386,28 @@ bool spirv::ConstantOp::isBuildableWith(Type type) {
}

spirv::ConstantOp spirv::ConstantOp::getZero(Type type, Location loc,
OpBuilder *builder) {
OpBuilder &builder) {
if (auto intType = type.dyn_cast<IntegerType>()) {
unsigned width = intType.getWidth();
if (width == 1)
return builder->create<spirv::ConstantOp>(loc, type,
builder->getBoolAttr(false));
return builder->create<spirv::ConstantOp>(
loc, type, builder->getIntegerAttr(type, APInt(width, 0)));
return builder.create<spirv::ConstantOp>(loc, type,
builder.getBoolAttr(false));
return builder.create<spirv::ConstantOp>(
loc, type, builder.getIntegerAttr(type, APInt(width, 0)));
}

llvm_unreachable("unimplemented types for ConstantOp::getZero()");
}

spirv::ConstantOp spirv::ConstantOp::getOne(Type type, Location loc,
OpBuilder *builder) {
OpBuilder &builder) {
if (auto intType = type.dyn_cast<IntegerType>()) {
unsigned width = intType.getWidth();
if (width == 1)
return builder->create<spirv::ConstantOp>(loc, type,
builder->getBoolAttr(true));
return builder->create<spirv::ConstantOp>(
loc, type, builder->getIntegerAttr(type, APInt(width, 1)));
return builder.create<spirv::ConstantOp>(loc, type,
builder.getBoolAttr(true));
return builder.create<spirv::ConstantOp>(
loc, type, builder.getIntegerAttr(type, APInt(width, 1)));
}

llvm_unreachable("unimplemented types for ConstantOp::getOne()");
Expand All @@ -1417,14 +1417,14 @@ spirv::ConstantOp spirv::ConstantOp::getOne(Type type, Location loc,
// spv.EntryPoint
//===----------------------------------------------------------------------===//

void spirv::EntryPointOp::build(Builder *builder, OperationState &state,
void spirv::EntryPointOp::build(OpBuilder &builder, OperationState &state,
spirv::ExecutionModel executionModel,
spirv::FuncOp function,
ArrayRef<Attribute> interfaceVars) {
build(builder, state,
builder->getI32IntegerAttr(static_cast<int32_t>(executionModel)),
builder->getSymbolRefAttr(function),
builder->getArrayAttr(interfaceVars));
builder.getI32IntegerAttr(static_cast<int32_t>(executionModel)),
builder.getSymbolRefAttr(function),
builder.getArrayAttr(interfaceVars));
}

static ParseResult parseEntryPointOp(OpAsmParser &parser,
Expand Down Expand Up @@ -1479,13 +1479,13 @@ static LogicalResult verify(spirv::EntryPointOp entryPointOp) {
// spv.ExecutionMode
//===----------------------------------------------------------------------===//

void spirv::ExecutionModeOp::build(Builder *builder, OperationState &state,
void spirv::ExecutionModeOp::build(OpBuilder &builder, OperationState &state,
spirv::FuncOp function,
spirv::ExecutionMode executionMode,
ArrayRef<int32_t> params) {
build(builder, state, builder->getSymbolRefAttr(function),
builder->getI32IntegerAttr(static_cast<int32_t>(executionMode)),
builder->getI32ArrayAttr(params));
build(builder, state, builder.getSymbolRefAttr(function),
builder.getI32IntegerAttr(static_cast<int32_t>(executionMode)),
builder.getI32ArrayAttr(params));
}

static ParseResult parseExecutionModeOp(OpAsmParser &parser,
Expand Down Expand Up @@ -1632,16 +1632,15 @@ LogicalResult spirv::FuncOp::verifyBody() {
return failure(walkResult.wasInterrupted());
}

void spirv::FuncOp::build(Builder *builder, OperationState &state,
void spirv::FuncOp::build(OpBuilder &builder, OperationState &state,
StringRef name, FunctionType type,
spirv::FunctionControl control,
ArrayRef<NamedAttribute> attrs) {
state.addAttribute(SymbolTable::getSymbolAttrName(),
builder->getStringAttr(name));
builder.getStringAttr(name));
state.addAttribute(getTypeAttrName(), TypeAttr::get(type));
state.addAttribute(
spirv::attributeName<spirv::FunctionControl>(),
builder->getI32IntegerAttr(static_cast<uint32_t>(control)));
state.addAttribute(spirv::attributeName<spirv::FunctionControl>(),
builder.getI32IntegerAttr(static_cast<uint32_t>(control)));
state.attributes.append(attrs.begin(), attrs.end());
state.addRegion();
}
Expand Down Expand Up @@ -1725,27 +1724,27 @@ Operation::operand_range spirv::FunctionCallOp::getArgOperands() {
// spv.globalVariable
//===----------------------------------------------------------------------===//

void spirv::GlobalVariableOp::build(Builder *builder, OperationState &state,
void spirv::GlobalVariableOp::build(OpBuilder &builder, OperationState &state,
Type type, StringRef name,
unsigned descriptorSet, unsigned binding) {
build(builder, state, TypeAttr::get(type), builder->getStringAttr(name),
build(builder, state, TypeAttr::get(type), builder.getStringAttr(name),
nullptr);
state.addAttribute(
spirv::SPIRVDialect::getAttributeName(spirv::Decoration::DescriptorSet),
builder->getI32IntegerAttr(descriptorSet));
builder.getI32IntegerAttr(descriptorSet));
state.addAttribute(
spirv::SPIRVDialect::getAttributeName(spirv::Decoration::Binding),
builder->getI32IntegerAttr(binding));
builder.getI32IntegerAttr(binding));
}

void spirv::GlobalVariableOp::build(Builder *builder, OperationState &state,
void spirv::GlobalVariableOp::build(OpBuilder &builder, OperationState &state,
Type type, StringRef name,
spirv::BuiltIn builtin) {
build(builder, state, TypeAttr::get(type), builder->getStringAttr(name),
build(builder, state, TypeAttr::get(type), builder.getStringAttr(name),
nullptr);
state.addAttribute(
spirv::SPIRVDialect::getAttributeName(spirv::Decoration::BuiltIn),
builder->getStringAttr(spirv::stringifyBuiltIn(builtin)));
builder.getStringAttr(spirv::stringifyBuiltIn(builtin)));
}

static ParseResult parseGlobalVariableOp(OpAsmParser &parser,
Expand Down Expand Up @@ -1849,10 +1848,10 @@ static LogicalResult verify(spirv::GroupNonUniformBallotOp ballotOp) {
// spv.GroupNonUniformElectOp
//===----------------------------------------------------------------------===//

void spirv::GroupNonUniformElectOp::build(Builder *builder,
void spirv::GroupNonUniformElectOp::build(OpBuilder &builder,
OperationState &state,
spirv::Scope scope) {
build(builder, state, builder->getI1Type(), scope);
build(builder, state, builder.getI1Type(), scope);
}

static LogicalResult verify(spirv::GroupNonUniformElectOp groupOp) {
Expand All @@ -1868,7 +1867,7 @@ static LogicalResult verify(spirv::GroupNonUniformElectOp groupOp) {
// spv.LoadOp
//===----------------------------------------------------------------------===//

void spirv::LoadOp::build(Builder *builder, OperationState &state,
void spirv::LoadOp::build(OpBuilder &builder, OperationState &state,
Value basePtr, IntegerAttr memory_access,
IntegerAttr alignment) {
auto ptrType = basePtr.getType().cast<spirv::PointerType>();
Expand Down Expand Up @@ -1926,9 +1925,9 @@ static LogicalResult verify(spirv::LoadOp loadOp) {
// spv.loop
//===----------------------------------------------------------------------===//

void spirv::LoopOp::build(Builder *builder, OperationState &state) {
void spirv::LoopOp::build(OpBuilder &builder, OperationState &state) {
state.addAttribute("loop_control",
builder->getI32IntegerAttr(
builder.getI32IntegerAttr(
static_cast<uint32_t>(spirv::LoopControl::None)));
state.addRegion();
}
Expand Down Expand Up @@ -2104,19 +2103,19 @@ static LogicalResult verify(spirv::MergeOp mergeOp) {
// spv.module
//===----------------------------------------------------------------------===//

void spirv::ModuleOp::build(Builder *builder, OperationState &state) {
ensureTerminator(*state.addRegion(), *builder, state.location);
void spirv::ModuleOp::build(OpBuilder &builder, OperationState &state) {
ensureTerminator(*state.addRegion(), builder, state.location);
}

void spirv::ModuleOp::build(Builder *builder, OperationState &state,
void spirv::ModuleOp::build(OpBuilder &builder, OperationState &state,
spirv::AddressingModel addressing_model,
spirv::MemoryModel memory_model) {
state.addAttribute(
"addressing_model",
builder->getI32IntegerAttr(static_cast<int32_t>(addressing_model)));
state.addAttribute("memory_model", builder->getI32IntegerAttr(
builder.getI32IntegerAttr(static_cast<int32_t>(addressing_model)));
state.addAttribute("memory_model", builder.getI32IntegerAttr(
static_cast<int32_t>(memory_model)));
ensureTerminator(*state.addRegion(), *builder, state.location);
ensureTerminator(*state.addRegion(), builder, state.location);
}

static ParseResult parseModuleOp(OpAsmParser &parser, OperationState &state) {
Expand Down Expand Up @@ -2272,8 +2271,8 @@ static LogicalResult verify(spirv::ReturnValueOp retValOp) {
// spv.Select
//===----------------------------------------------------------------------===//

void spirv::SelectOp::build(Builder *builder, OperationState &state, Value cond,
Value trueValue, Value falseValue) {
void spirv::SelectOp::build(OpBuilder &builder, OperationState &state,
Value cond, Value trueValue, Value falseValue) {
build(builder, state, trueValue.getType(), cond, trueValue, falseValue);
}

Expand Down Expand Up @@ -2381,28 +2380,28 @@ void spirv::SelectionOp::addMergeBlock() {

spirv::SelectionOp spirv::SelectionOp::createIfThen(
Location loc, Value condition,
function_ref<void(OpBuilder *builder)> thenBody, OpBuilder *builder) {
auto selectionControl = builder->getI32IntegerAttr(
function_ref<void(OpBuilder &builder)> thenBody, OpBuilder &builder) {
auto selectionControl = builder.getI32IntegerAttr(
static_cast<uint32_t>(spirv::SelectionControl::None));
auto selectionOp = builder->create<spirv::SelectionOp>(loc, selectionControl);
auto selectionOp = builder.create<spirv::SelectionOp>(loc, selectionControl);

selectionOp.addMergeBlock();
Block *mergeBlock = selectionOp.getMergeBlock();
Block *thenBlock = nullptr;

// Build the "then" block.
{
OpBuilder::InsertionGuard guard(*builder);
thenBlock = builder->createBlock(mergeBlock);
OpBuilder::InsertionGuard guard(builder);
thenBlock = builder.createBlock(mergeBlock);
thenBody(builder);
builder->create<spirv::BranchOp>(loc, mergeBlock);
builder.create<spirv::BranchOp>(loc, mergeBlock);
}

// Build the header block.
{
OpBuilder::InsertionGuard guard(*builder);
builder->createBlock(thenBlock);
builder->create<spirv::BranchConditionalOp>(
OpBuilder::InsertionGuard guard(builder);
builder.createBlock(thenBlock);
builder.create<spirv::BranchConditionalOp>(
loc, condition, thenBlock,
/*trueArguments=*/ArrayRef<Value>(), mergeBlock,
/*falseArguments=*/ArrayRef<Value>());
Expand Down
4 changes: 2 additions & 2 deletions mlir/lib/Dialect/SPIRV/Serialization/Deserializer.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -521,9 +521,9 @@ Optional<spirv::ModuleOp> Deserializer::collect() { return module; }
//===----------------------------------------------------------------------===//

spirv::ModuleOp Deserializer::createModuleOp() {
Builder builder(context);
OpBuilder builder(context);
OperationState state(unknownLoc, spirv::ModuleOp::getOperationName());
spirv::ModuleOp::build(&builder, state);
spirv::ModuleOp::build(builder, state);
return cast<spirv::ModuleOp>(Operation::create(state));
}

Expand Down
2 changes: 1 addition & 1 deletion mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -194,7 +194,7 @@ LogicalResult ProcessInterfaceVarABI::matchAndRewrite(
if (argType.value().cast<spirv::SPIRVType>().isScalarOrVector()) {
auto indexType = SPIRVTypeConverter::getIndexType(funcOp.getContext());
auto zero =
spirv::ConstantOp::getZero(indexType, funcOp.getLoc(), &rewriter);
spirv::ConstantOp::getZero(indexType, funcOp.getLoc(), rewriter);
auto loadPtr = rewriter.create<spirv::AccessChainOp>(
funcOp.getLoc(), replacement, zero.constant());
replacement = rewriter.create<spirv::LoadOp>(funcOp.getLoc(), loadPtr);
Expand Down
52 changes: 24 additions & 28 deletions mlir/lib/Dialect/StandardOps/IR/Ops.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -484,7 +484,7 @@ static LogicalResult verify(AtomicRMWOp op) {
// GenericAtomicRMWOp
//===----------------------------------------------------------------------===//

void GenericAtomicRMWOp::build(Builder *builder, OperationState &result,
void GenericAtomicRMWOp::build(OpBuilder &builder, OperationState &result,
Value memref, ValueRange ivs) {
result.addOperands(memref);
result.addOperands(ivs);
Expand Down Expand Up @@ -775,13 +775,12 @@ static Type getI1SameShape(Type type) {
// CmpIOp
//===----------------------------------------------------------------------===//

static void buildCmpIOp(Builder *build, OperationState &result,
static void buildCmpIOp(OpBuilder &build, OperationState &result,
CmpIPredicate predicate, Value lhs, Value rhs) {
result.addOperands({lhs, rhs});
result.types.push_back(getI1SameShape(lhs.getType()));
result.addAttribute(
CmpIOp::getPredicateAttrName(),
build->getI64IntegerAttr(static_cast<int64_t>(predicate)));
result.addAttribute(CmpIOp::getPredicateAttrName(),
build.getI64IntegerAttr(static_cast<int64_t>(predicate)));
}

// Compute `lhs` `pred` `rhs`, where `pred` is one of the known integer
Expand Down Expand Up @@ -830,13 +829,12 @@ OpFoldResult CmpIOp::fold(ArrayRef<Attribute> operands) {
// CmpFOp
//===----------------------------------------------------------------------===//

static void buildCmpFOp(Builder *build, OperationState &result,
static void buildCmpFOp(OpBuilder &build, OperationState &result,
CmpFPredicate predicate, Value lhs, Value rhs) {
result.addOperands({lhs, rhs});
result.types.push_back(getI1SameShape(lhs.getType()));
result.addAttribute(
CmpFOp::getPredicateAttrName(),
build->getI64IntegerAttr(static_cast<int64_t>(predicate)));
result.addAttribute(CmpFOp::getPredicateAttrName(),
build.getI64IntegerAttr(static_cast<int64_t>(predicate)));
}

/// Compute `lhs` `pred` `rhs`, where `pred` is one of the known floating point
Expand Down Expand Up @@ -1180,9 +1178,9 @@ bool ConstantOp::isBuildableWith(Attribute value, Type type) {
value.isa<UnitAttr>();
}

void ConstantFloatOp::build(Builder *builder, OperationState &result,
void ConstantFloatOp::build(OpBuilder &builder, OperationState &result,
const APFloat &value, FloatType type) {
ConstantOp::build(builder, result, type, builder->getFloatAttr(type, value));
ConstantOp::build(builder, result, type, builder.getFloatAttr(type, value));
}

bool ConstantFloatOp::classof(Operation *op) {
Expand All @@ -1195,33 +1193,30 @@ bool ConstantIntOp::classof(Operation *op) {
op->getResult(0).getType().isSignlessInteger();
}

void ConstantIntOp::build(Builder *builder, OperationState &result,
void ConstantIntOp::build(OpBuilder &builder, OperationState &result,
int64_t value, unsigned width) {
Type type = builder->getIntegerType(width);
ConstantOp::build(builder, result, type,
builder->getIntegerAttr(type, value));
Type type = builder.getIntegerType(width);
ConstantOp::build(builder, result, type, builder.getIntegerAttr(type, value));
}

/// Build a constant int op producing an integer with the specified type,
/// which must be an integer type.
void ConstantIntOp::build(Builder *builder, OperationState &result,
void ConstantIntOp::build(OpBuilder &builder, OperationState &result,
int64_t value, Type type) {
assert(type.isSignlessInteger() &&
"ConstantIntOp can only have signless integer type");
ConstantOp::build(builder, result, type,
builder->getIntegerAttr(type, value));
ConstantOp::build(builder, result, type, builder.getIntegerAttr(type, value));
}

/// ConstantIndexOp only matches values whose result type is Index.
bool ConstantIndexOp::classof(Operation *op) {
return ConstantOp::classof(op) && op->getResult(0).getType().isIndex();
}

void ConstantIndexOp::build(Builder *builder, OperationState &result,
void ConstantIndexOp::build(OpBuilder &builder, OperationState &result,
int64_t value) {
Type type = builder->getIndexType();
ConstantOp::build(builder, result, type,
builder->getIntegerAttr(type, value));
Type type = builder.getIndexType();
ConstantOp::build(builder, result, type, builder.getIntegerAttr(type, value));
}

//===----------------------------------------------------------------------===//
Expand Down Expand Up @@ -1363,7 +1358,7 @@ OpFoldResult DimOp::fold(ArrayRef<Attribute> operands) {
// DmaStartOp
// ---------------------------------------------------------------------------

void DmaStartOp::build(Builder *builder, OperationState &result,
void DmaStartOp::build(OpBuilder &builder, OperationState &result,
Value srcMemRef, ValueRange srcIndices, Value destMemRef,
ValueRange destIndices, Value numElements,
Value tagMemRef, ValueRange tagIndices, Value stride,
Expand Down Expand Up @@ -1506,8 +1501,9 @@ LogicalResult DmaStartOp::fold(ArrayRef<Attribute> cstOperands,
// DmaWaitOp
// ---------------------------------------------------------------------------

void DmaWaitOp::build(Builder *builder, OperationState &result, Value tagMemRef,
ValueRange tagIndices, Value numElements) {
void DmaWaitOp::build(OpBuilder &builder, OperationState &result,
Value tagMemRef, ValueRange tagIndices,
Value numElements) {
result.addOperands(tagMemRef);
result.addOperands(tagIndices);
result.addOperands(numElements);
Expand Down Expand Up @@ -2157,7 +2153,7 @@ static Type inferSubViewResultType(MemRefType memRefType) {
.setAffineMaps(stridedLayout);
}

void mlir::SubViewOp::build(Builder *b, OperationState &result, Value source,
void mlir::SubViewOp::build(OpBuilder &b, OperationState &result, Value source,
ValueRange offsets, ValueRange sizes,
ValueRange strides, Type resultType,
ArrayRef<NamedAttribute> attrs) {
Expand All @@ -2167,8 +2163,8 @@ void mlir::SubViewOp::build(Builder *b, OperationState &result, Value source,
result.addAttributes(attrs);
}

void mlir::SubViewOp::build(Builder *b, OperationState &result, Type resultType,
Value source) {
void mlir::SubViewOp::build(OpBuilder &b, OperationState &result,
Type resultType, Value source) {
build(b, result, source, /*offsets=*/{}, /*sizes=*/{}, /*strides=*/{},
resultType);
}
Expand Down
43 changes: 22 additions & 21 deletions mlir/lib/Dialect/Vector/VectorOps.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -126,20 +126,20 @@ static void print(OpAsmPrinter &p, ReductionOp op) {
// ContractionOp
//===----------------------------------------------------------------------===//

void vector::ContractionOp::build(Builder *builder, OperationState &result,
void vector::ContractionOp::build(OpBuilder &builder, OperationState &result,
Value lhs, Value rhs, Value acc,
ArrayRef<ArrayRef<AffineExpr>> indexingExprs,
ArrayRef<StringRef> iteratorTypes) {
result.addOperands({lhs, rhs, acc});
result.addTypes(acc.getType());
result.addAttribute(getIndexingMapsAttrName(),
builder->getAffineMapArrayAttr(
builder.getAffineMapArrayAttr(
AffineMap::inferFromExprList(indexingExprs)));
result.addAttribute(getIteratorTypesAttrName(),
builder->getStrArrayAttr(iteratorTypes));
builder.getStrArrayAttr(iteratorTypes));
}

void vector::ContractionOp::build(Builder *builder, OperationState &result,
void vector::ContractionOp::build(OpBuilder &builder, OperationState &result,
Value lhs, Value rhs, Value acc,
ArrayAttr indexingMaps,
ArrayAttr iteratorTypes) {
Expand Down Expand Up @@ -461,10 +461,10 @@ static Type inferExtractOpResultType(VectorType vectorType,
vectorType.getElementType());
}

void vector::ExtractOp::build(Builder *builder, OperationState &result,
void vector::ExtractOp::build(OpBuilder &builder, OperationState &result,
Value source, ArrayRef<int64_t> position) {
result.addOperands(source);
auto positionAttr = getVectorSubscriptAttr(*builder, position);
auto positionAttr = getVectorSubscriptAttr(builder, position);
result.addTypes(inferExtractOpResultType(source.getType().cast<VectorType>(),
positionAttr));
result.addAttribute(getPositionAttrName(), positionAttr);
Expand Down Expand Up @@ -528,13 +528,13 @@ static LogicalResult verify(vector::ExtractOp op) {
// ExtractSlicesOp
//===----------------------------------------------------------------------===//

void ExtractSlicesOp::build(Builder *builder, OperationState &result,
void ExtractSlicesOp::build(OpBuilder &builder, OperationState &result,
TupleType tupleType, Value vector,
ArrayRef<int64_t> sizes,
ArrayRef<int64_t> strides) {
result.addOperands(vector);
auto sizesAttr = getVectorSubscriptAttr(*builder, sizes);
auto stridesAttr = getVectorSubscriptAttr(*builder, strides);
auto sizesAttr = getVectorSubscriptAttr(builder, sizes);
auto stridesAttr = getVectorSubscriptAttr(builder, strides);
result.addTypes(tupleType);
result.addAttribute(getSizesAttrName(), sizesAttr);
result.addAttribute(getStridesAttrName(), stridesAttr);
Expand Down Expand Up @@ -634,10 +634,10 @@ static LogicalResult verify(BroadcastOp op) {
// ShuffleOp
//===----------------------------------------------------------------------===//

void ShuffleOp::build(Builder *builder, OperationState &result, Value v1,
void ShuffleOp::build(OpBuilder &builder, OperationState &result, Value v1,
Value v2, ArrayRef<int64_t> mask) {
result.addOperands({v1, v2});
auto maskAttr = getVectorSubscriptAttr(*builder, mask);
auto maskAttr = getVectorSubscriptAttr(builder, mask);
result.addTypes(v1.getType());
result.addAttribute(getMaskAttrName(), maskAttr);
}
Expand Down Expand Up @@ -731,10 +731,10 @@ static LogicalResult verify(InsertElementOp op) {
// InsertOp
//===----------------------------------------------------------------------===//

void InsertOp::build(Builder *builder, OperationState &result, Value source,
void InsertOp::build(OpBuilder &builder, OperationState &result, Value source,
Value dest, ArrayRef<int64_t> position) {
result.addOperands({source, dest});
auto positionAttr = getVectorSubscriptAttr(*builder, position);
auto positionAttr = getVectorSubscriptAttr(builder, position);
result.addTypes(dest.getType());
result.addAttribute(getPositionAttrName(), positionAttr);
}
Expand Down Expand Up @@ -795,13 +795,13 @@ void InsertSlicesOp::getStrides(SmallVectorImpl<int64_t> &results) {
// InsertStridedSliceOp
//===----------------------------------------------------------------------===//

void InsertStridedSliceOp::build(Builder *builder, OperationState &result,
void InsertStridedSliceOp::build(OpBuilder &builder, OperationState &result,
Value source, Value dest,
ArrayRef<int64_t> offsets,
ArrayRef<int64_t> strides) {
result.addOperands({source, dest});
auto offsetsAttr = getVectorSubscriptAttr(*builder, offsets);
auto stridesAttr = getVectorSubscriptAttr(*builder, strides);
auto offsetsAttr = getVectorSubscriptAttr(builder, offsets);
auto stridesAttr = getVectorSubscriptAttr(builder, strides);
result.addTypes(dest.getType());
result.addAttribute(getOffsetsAttrName(), offsetsAttr);
result.addAttribute(getStridesAttrName(), stridesAttr);
Expand Down Expand Up @@ -1074,13 +1074,13 @@ static Type inferStridedSliceOpResultType(VectorType vectorType,
return VectorType::get(shape, vectorType.getElementType());
}

void StridedSliceOp::build(Builder *builder, OperationState &result,
void StridedSliceOp::build(OpBuilder &builder, OperationState &result,
Value source, ArrayRef<int64_t> offsets,
ArrayRef<int64_t> sizes, ArrayRef<int64_t> strides) {
result.addOperands(source);
auto offsetsAttr = getVectorSubscriptAttr(*builder, offsets);
auto sizesAttr = getVectorSubscriptAttr(*builder, sizes);
auto stridesAttr = getVectorSubscriptAttr(*builder, strides);
auto offsetsAttr = getVectorSubscriptAttr(builder, offsets);
auto sizesAttr = getVectorSubscriptAttr(builder, sizes);
auto stridesAttr = getVectorSubscriptAttr(builder, strides);
result.addTypes(
inferStridedSliceOpResultType(source.getType().cast<VectorType>(),
offsetsAttr, sizesAttr, stridesAttr));
Expand Down Expand Up @@ -1466,7 +1466,8 @@ static MemRefType inferVectorTypeCastResultType(MemRefType t) {
return MemRefType::get({}, VectorType::get(t.getShape(), t.getElementType()));
}

void TypeCastOp::build(Builder *builder, OperationState &result, Value source) {
void TypeCastOp::build(OpBuilder &builder, OperationState &result,
Value source) {
result.addOperands(source);
result.addTypes(
inferVectorTypeCastResultType(source.getType().cast<MemRefType>()));
Expand Down
10 changes: 5 additions & 5 deletions mlir/lib/IR/Function.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,8 +24,8 @@ using namespace mlir;
FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
ArrayRef<NamedAttribute> attrs) {
OperationState state(location, "func");
Builder builder(location->getContext());
FuncOp::build(&builder, state, name, type, attrs);
OpBuilder builder(location->getContext());
FuncOp::build(builder, state, name, type, attrs);
return cast<FuncOp>(Operation::create(state));
}
FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
Expand All @@ -41,16 +41,16 @@ FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
return func;
}

void FuncOp::build(Builder *builder, OperationState &result, StringRef name,
void FuncOp::build(OpBuilder &builder, OperationState &result, StringRef name,
FunctionType type, ArrayRef<NamedAttribute> attrs) {
result.addAttribute(SymbolTable::getSymbolAttrName(),
builder->getStringAttr(name));
builder.getStringAttr(name));
result.addAttribute(getTypeAttrName(), TypeAttr::get(type));
result.attributes.append(attrs.begin(), attrs.end());
result.addRegion();
}

void FuncOp::build(Builder *builder, OperationState &result, StringRef name,
void FuncOp::build(OpBuilder &builder, OperationState &result, StringRef name,
FunctionType type, ArrayRef<NamedAttribute> attrs,
ArrayRef<NamedAttributeList> argAttrs) {
build(builder, result, name, type, attrs);
Expand Down
12 changes: 6 additions & 6 deletions mlir/lib/IR/Module.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,19 +16,19 @@ using namespace mlir;
// Module Operation.
//===----------------------------------------------------------------------===//

void ModuleOp::build(Builder *builder, OperationState &result,
void ModuleOp::build(OpBuilder &builder, OperationState &result,
Optional<StringRef> name) {
ensureTerminator(*result.addRegion(), *builder, result.location);
ensureTerminator(*result.addRegion(), builder, result.location);
if (name)
result.attributes.push_back(builder->getNamedAttr(
mlir::SymbolTable::getSymbolAttrName(), builder->getStringAttr(*name)));
result.attributes.push_back(builder.getNamedAttr(
mlir::SymbolTable::getSymbolAttrName(), builder.getStringAttr(*name)));
}

/// Construct a module from the given context.
ModuleOp ModuleOp::create(Location loc, Optional<StringRef> name) {
OperationState state(loc, "module");
Builder builder(loc->getContext());
ModuleOp::build(&builder, state, name);
OpBuilder builder(loc->getContext());
ModuleOp::build(builder, state, name);
return cast<ModuleOp>(Operation::create(state));
}

Expand Down
9 changes: 5 additions & 4 deletions mlir/lib/IR/Operation.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -984,7 +984,7 @@ LogicalResult OpTrait::impl::verifyResultSizeAttr(Operation *op,
// These functions are out-of-line implementations of the methods in BinaryOp,
// which avoids them being template instantiated/duplicated.

void impl::buildBinaryOp(Builder *builder, OperationState &result, Value lhs,
void impl::buildBinaryOp(OpBuilder &builder, OperationState &result, Value lhs,
Value rhs) {
assert(lhs.getType() == rhs.getType());
result.addOperands({lhs, rhs});
Expand Down Expand Up @@ -1025,7 +1025,7 @@ void impl::printOneResultOp(Operation *op, OpAsmPrinter &p) {
// CastOp implementation
//===----------------------------------------------------------------------===//

void impl::buildCastOp(Builder *builder, OperationState &result, Value source,
void impl::buildCastOp(OpBuilder &builder, OperationState &result, Value source,
Type destType) {
result.addOperands(source);
result.addTypes(destType);
Expand Down Expand Up @@ -1066,15 +1066,16 @@ Value impl::foldCastOp(Operation *op) {
/// terminator operation to insert.
void impl::ensureRegionTerminator(
Region &region, Location loc,
function_ref<Operation *()> buildTerminatorOp) {
function_ref<Operation *(OpBuilder &)> buildTerminatorOp) {
if (region.empty())
region.push_back(new Block);

Block &block = region.back();
if (!block.empty() && block.back().isKnownTerminator())
return;

block.push_back(buildTerminatorOp());
OpBuilder builder(loc.getContext());
block.push_back(buildTerminatorOp(builder));
}

//===----------------------------------------------------------------------===//
Expand Down
14 changes: 7 additions & 7 deletions mlir/test/lib/Dialect/Test/TestOps.td
View file
Original file line number Diff line number Diff line change
Expand Up @@ -739,9 +739,9 @@ def OpSymbolBindingB : TEST_Op<"symbol_binding_b", []> {

let builders = [
OpBuilder<
"Builder *builder, OperationState &state, Value operand",
"OpBuilder &builder, OperationState &state, Value operand",
[{
state.types.assign({builder->getIntegerType(32)});
state.types.assign({builder.getIntegerType(32)});
state.addOperands({operand});
}]>
];
Expand Down Expand Up @@ -851,10 +851,10 @@ def TwoResultOp : TEST_Op<"two_result"> {

let builders = [
OpBuilder<
"Builder *builder, OperationState &state, IntegerAttr kind",
"OpBuilder &builder, OperationState &state, IntegerAttr kind",
[{
auto i32 = builder->getIntegerType(32);
auto f32 = builder->getF32Type();
auto i32 = builder.getIntegerType(32);
auto f32 = builder.getF32Type();
state.types.assign({i32, f32});
state.addAttribute("kind", kind);
}]>
Expand Down Expand Up @@ -1007,9 +1007,9 @@ def MixedVResultOp3 : TEST_Op<"mixed_variadic_out3",
// result type. So need to provide a builder not requiring result types.
let builders = [
OpBuilder<
"Builder *builder, OperationState &state, IntegerAttr count",
"OpBuilder &builder, OperationState &state, IntegerAttr count",
[{
auto i32Type = builder->getIntegerType(32);
auto i32Type = builder.getIntegerType(32);
state.addTypes(i32Type); // $output1
SmallVector<Type, 4> types(count.getInt(), i32Type);
state.addTypes(types); // $output2
Expand Down
2 changes: 1 addition & 1 deletion mlir/test/lib/Dialect/Test/TestPatterns.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -77,7 +77,7 @@ static void invokeCreateWithInferredReturnType(Operation *op) {
inferredReturnTypes))) {
OperationState state(location, OpTy::getOperationName());
// TODO(jpienaar): Expand to regions.
OpTy::build(&b, state, values, op->getAttrs());
OpTy::build(b, state, values, op->getAttrs());
(void)b.createOperation(state);
}
}
Expand Down
10 changes: 5 additions & 5 deletions mlir/test/mlir-tblgen/op-attribute.td
View file
Original file line number Diff line number Diff line change
Expand Up @@ -74,7 +74,7 @@ def AOp : NS_Op<"a_op", []> {

// DEF: void AOp::build(
// DEF: some-return-type aAttr, some-return-type bAttr, /*optional*/some-attr-kind cAttr
// DEF: odsState.addAttribute("aAttr", some-const-builder-call((*odsBuilder), aAttr));
// DEF: odsState.addAttribute("aAttr", some-const-builder-call(odsBuilder, aAttr));

// DEF: void AOp::build(
// DEF: ArrayRef<NamedAttribute> attributes
Expand Down Expand Up @@ -198,8 +198,8 @@ def DOp : NS_Op<"d_op", []> {
// DECL: static void build({{.*}}, APInt i32_attr, APFloat f64_attr, StringRef str_attr, bool bool_attr, ::SomeI32Enum enum_attr, APInt dv_i32_attr, APFloat dv_f64_attr, StringRef dv_str_attr = "abc", bool dv_bool_attr = true, ::SomeI32Enum dv_enum_attr = ::SomeI32Enum::case5)

// DEF-LABEL: DOp definitions
// DEF: odsState.addAttribute("str_attr", (*odsBuilder).getStringAttr(str_attr));
// DEF: odsState.addAttribute("dv_str_attr", (*odsBuilder).getStringAttr(dv_str_attr));
// DEF: odsState.addAttribute("str_attr", odsBuilder.getStringAttr(str_attr));
// DEF: odsState.addAttribute("dv_str_attr", odsBuilder.getStringAttr(dv_str_attr));

// Test derived type attr.
// ---
Expand Down Expand Up @@ -249,7 +249,7 @@ def MixOperandsAndAttrs : NS_Op<"mix_operands_and_attrs", []> {
// DEF-LABEL: MixOperandsAndAttrs definitions
// DEF-DAG: Value MixOperandsAndAttrs::operand()
// DEF-DAG: Value MixOperandsAndAttrs::otherArg()
// DEF-DAG: void MixOperandsAndAttrs::build(Builder *odsBuilder, OperationState &odsState, FloatAttr attr, Value operand, FloatAttr otherAttr, Value otherArg)
// DEF-DAG: void MixOperandsAndAttrs::build(OpBuilder &odsBuilder, OperationState &odsState, FloatAttr attr, Value operand, FloatAttr otherAttr, Value otherArg)
// DEF-DAG: APFloat MixOperandsAndAttrs::attr()
// DEF-DAG: APFloat MixOperandsAndAttrs::otherAttr()

Expand All @@ -264,7 +264,7 @@ def UnitAttrOp : NS_Op<"unit_attr_op", []> {
// DEF: bool UnitAttrOp::attr() {
// DEF: return {{.*}} != nullptr

// DEF: build(Builder *odsBuilder, OperationState &odsState, /*optional*/UnitAttr attr)
// DEF: build(OpBuilder &odsBuilder, OperationState &odsState, /*optional*/UnitAttr attr)


// Test elementAttr field of TypedArrayAttr.
Expand Down
8 changes: 4 additions & 4 deletions mlir/test/mlir-tblgen/op-decl.td
View file
Original file line number Diff line number Diff line change
Expand Up @@ -76,9 +76,9 @@ def NS_AOp : NS_Op<"a_op", [IsolatedFromAbove, IsolatedFromAbove]> {
// CHECK: FloatAttr attr2Attr()
// CHECK: Optional< APFloat > attr2();
// CHECK: static void build(Value val);
// CHECK: static void build(Builder *odsBuilder, OperationState &odsState, Type r, ArrayRef<Type> s, Value a, ValueRange b, IntegerAttr attr1, /*optional*/FloatAttr attr2, unsigned someRegionsCount)
// CHECK: static void build(Builder *odsBuilder, OperationState &odsState, Type r, ArrayRef<Type> s, Value a, ValueRange b, APInt attr1, /*optional*/FloatAttr attr2, unsigned someRegionsCount)
// CHECK: static void build(Builder *, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes, unsigned numRegions)
// CHECK: static void build(OpBuilder &odsBuilder, OperationState &odsState, Type r, ArrayRef<Type> s, Value a, ValueRange b, IntegerAttr attr1, /*optional*/FloatAttr attr2, unsigned someRegionsCount)
// CHECK: static void build(OpBuilder &odsBuilder, OperationState &odsState, Type r, ArrayRef<Type> s, Value a, ValueRange b, APInt attr1, /*optional*/FloatAttr attr2, unsigned someRegionsCount)
// CHECK: static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes, unsigned numRegions)
// CHECK: static ParseResult parse(OpAsmParser &parser, OperationState &result);
// CHECK: void print(OpAsmPrinter &p);
// CHECK: LogicalResult verify();
Expand Down Expand Up @@ -120,7 +120,7 @@ def NS_EOp : NS_Op<"op_with_optionals", []> {
// CHECK-LABEL: NS::EOp declarations
// CHECK: Value a();
// CHECK: Value b();
// CHECK: static void build(Builder *odsBuilder, OperationState &odsState, /*optional*/Type b, /*optional*/Value a)
// CHECK: static void build(OpBuilder &odsBuilder, OperationState &odsState, /*optional*/Type b, /*optional*/Value a)

// Check that default builders can be suppressed.
// ---
Expand Down
16 changes: 8 additions & 8 deletions mlir/test/mlir-tblgen/op-result.td
View file
Original file line number Diff line number Diff line change
Expand Up @@ -23,22 +23,22 @@ def OpB : NS_Op<"same_input_output_type_op", [SameOperandsAndResultType]> {
}

// CHECK-LABEL: OpB definitions
// CHECK: void OpB::build(Builder *odsBuilder, OperationState &odsState, Type y, Value x)
// CHECK: void OpB::build(OpBuilder &odsBuilder, OperationState &odsState, Type y, Value x)
// CHECK: odsState.addTypes(y);
// CHECK: void OpB::build(Builder *odsBuilder, OperationState &odsState, Value x)
// CHECK: void OpB::build(OpBuilder &odsBuilder, OperationState &odsState, Value x)
// CHECK: odsState.addTypes({x.getType()});

def OpC : NS_Op<"three_normal_result_op", []> {
let results = (outs I32:$x, /*unnamed*/I32, I32:$z);
}

// CHECK-LABEL: OpC definitions
// CHECK: void OpC::build(Builder *odsBuilder, OperationState &odsState, Type x, Type resultType1, Type z)
// CHECK: void OpC::build(OpBuilder &odsBuilder, OperationState &odsState, Type x, Type resultType1, Type z)
// CHECK-NEXT: odsState.addTypes(x)
// CHECK-NEXT: odsState.addTypes(resultType1)
// CHECK-NEXT: odsState.addTypes(z)

// CHECK: void OpC::build(Builder *odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes) {
// CHECK: void OpC::build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes) {
// CHECK-NEXT: assert(resultTypes.size() == 3u && "mismatched number of results");
// CHECK-NEXT: odsState.addTypes(resultTypes);

Expand All @@ -49,7 +49,7 @@ def OpD : NS_Op<"type_attr_as_result_type", [FirstAttrDerivedResultType]> {
}

// CHECK-LABEL: OpD definitions
// CHECK: void OpD::build(Builder *odsBuilder, OperationState &odsState, ValueRange operands, ArrayRef<NamedAttribute> attributes)
// CHECK: void OpD::build(OpBuilder &odsBuilder, OperationState &odsState, ValueRange operands, ArrayRef<NamedAttribute> attributes)
// CHECK: odsState.addTypes({attr.second.cast<TypeAttr>().getValue()});

def OpE : NS_Op<"value_attr_as_result_type", [FirstAttrDerivedResultType]> {
Expand All @@ -58,7 +58,7 @@ def OpE : NS_Op<"value_attr_as_result_type", [FirstAttrDerivedResultType]> {
}

// CHECK-LABEL: OpE definitions
// CHECK: void OpE::build(Builder *odsBuilder, OperationState &odsState, ValueRange operands, ArrayRef<NamedAttribute> attributes)
// CHECK: void OpE::build(OpBuilder &odsBuilder, OperationState &odsState, ValueRange operands, ArrayRef<NamedAttribute> attributes)
// CHECK: odsState.addTypes({attr.second.getType()});

def OpF : NS_Op<"one_variadic_result_op", []> {
Expand All @@ -77,7 +77,7 @@ def OpG : NS_Op<"one_normal_and_one_variadic_result_op", []> {

// CHECK-LABEL: OpG definitions

// CHECK: void OpG::build(Builder *odsBuilder, OperationState &odsState, Type x, ArrayRef<Type> y)
// CHECK: void OpG::build(OpBuilder &odsBuilder, OperationState &odsState, Type x, ArrayRef<Type> y)
// CHECK-NEXT: odsState.addTypes(x);
// CHECK-NEXT: odsState.addTypes(y);

Expand Down Expand Up @@ -109,5 +109,5 @@ def OpK : NS_Op<"only_input_is_variadic_with_same_value_type_op", [SameOperandsA
let results = (outs AnyTensor:$result);
}

// CHECK-LABEL: OpK::build(Builder *odsBuilder, OperationState &odsState, ValueRange input)
// CHECK-LABEL: OpK::build(OpBuilder &odsBuilder, OperationState &odsState, ValueRange input)
// CHECK: odsState.addTypes({input.front().getType()});
4 changes: 2 additions & 2 deletions mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-gen.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1467,13 +1467,13 @@ void TCParser::printODS(llvm::raw_ostream &os, StringRef cppOpName,
let results = (outs Variadic<AnyRankedTensor>:$output_tensors);
let regions = (region SizedRegion<1>:$region);
let builders = [OpBuilder<
"Builder *b, OperationState &result, TypeRange outputTypes, "
"OpBuilder &b, OperationState &result, TypeRange outputTypes, "
# "ValueRange views",
[{{
result.addOperands(views);
result.addTypes(outputTypes);
buildNamedStructuredOpRegion<{0}>(
*b, result, TypeRange(views), outputTypes);
b, result, TypeRange(views), outputTypes);
}]>
];
let parser = [{
Expand Down
18 changes: 9 additions & 9 deletions mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -743,7 +743,7 @@ void OpEmitter::genSeparateArgParamBuilder() {
// TODO(jpienaar): Expand to handle regions.
body << formatv(R"(
SmallVector<Type, 2> inferredReturnTypes;
if (succeeded({0}::inferReturnTypes(odsBuilder->getContext(),
if (succeeded({0}::inferReturnTypes(odsBuilder.getContext(),
{1}.location, {1}.operands, {1}.attributes,
/*regions=*/{{}, inferredReturnTypes)))
{1}.addTypes(inferredReturnTypes);
Expand Down Expand Up @@ -800,7 +800,7 @@ void OpEmitter::genUseOperandAsResultTypeCollectiveParamBuilder() {

// Signature
std::string params =
std::string("Builder *odsBuilder, OperationState &") + builderOpState +
std::string("OpBuilder &odsBuilder, OperationState &") + builderOpState +
", ValueRange operands, ArrayRef<NamedAttribute> attributes";
if (op.getNumVariadicRegions())
params += ", unsigned numRegions";
Expand Down Expand Up @@ -830,15 +830,15 @@ void OpEmitter::genUseOperandAsResultTypeCollectiveParamBuilder() {
void OpEmitter::genInferredTypeCollectiveParamBuilder() {
// TODO(jpienaar): Expand to support regions.
const char *params =
"Builder *odsBuilder, OperationState &{0}, "
"OpBuilder &odsBuilder, OperationState &{0}, "
"ValueRange operands, ArrayRef<NamedAttribute> attributes";
auto &m =
opClass.newMethod("void", "build", formatv(params, builderOpState).str(),
OpMethod::MP_Static);
auto &body = m.body();
body << formatv(R"(
SmallVector<Type, 2> inferredReturnTypes;
if (succeeded({0}::inferReturnTypes(odsBuilder->getContext(),
if (succeeded({0}::inferReturnTypes(odsBuilder.getContext(),
{1}.location, operands, attributes,
/*regions=*/{{}, inferredReturnTypes)))
build(odsBuilder, odsState, inferredReturnTypes, operands, attributes);
Expand Down Expand Up @@ -871,7 +871,7 @@ void OpEmitter::genUseOperandAsResultTypeSeparateParamBuilder() {

void OpEmitter::genUseAttrAsResultTypeBuilder() {
std::string params =
std::string("Builder *odsBuilder, OperationState &") + builderOpState +
std::string("OpBuilder &odsBuilder, OperationState &") + builderOpState +
", ValueRange operands, ArrayRef<NamedAttribute> attributes";
auto &m = opClass.newMethod("void", "build", params, OpMethod::MP_Static);
auto &body = m.body();
Expand Down Expand Up @@ -961,7 +961,7 @@ void OpEmitter::genCollectiveParamBuilder() {
int numVariadicOperands = op.getNumVariableLengthOperands();
int numNonVariadicOperands = numOperands - numVariadicOperands;
// Signature
std::string params = std::string("Builder *, OperationState &") +
std::string params = std::string("OpBuilder &, OperationState &") +
builderOpState +
", ArrayRef<Type> resultTypes, ValueRange operands, "
"ArrayRef<NamedAttribute> attributes";
Expand Down Expand Up @@ -1013,7 +1013,7 @@ void OpEmitter::buildParamList(std::string &paramList,
auto numResults = op.getNumResults();
resultTypeNames.reserve(numResults);

paramList = "Builder *odsBuilder, OperationState &";
paramList = "OpBuilder &odsBuilder, OperationState &";
paramList.append(builderOpState);

switch (typeParamKind) {
Expand Down Expand Up @@ -1151,7 +1151,7 @@ void OpEmitter::genCodeForAddingArgAndRegionForBuilder(OpMethodBody &body,
if (op.getTrait("OpTrait::AttrSizedOperandSegments")) {
body << " " << builderOpState
<< ".addAttribute(\"operand_segment_sizes\", "
"odsBuilder->getI32VectorAttr({";
"odsBuilder.getI32VectorAttr({";
interleaveComma(llvm::seq<int>(0, op.getNumOperands()), body, [&](int i) {
if (op.getOperand(i).isOptional())
body << "(" << getArgumentName(op, i) << " ? 1 : 0)";
Expand All @@ -1175,7 +1175,7 @@ void OpEmitter::genCodeForAddingArgAndRegionForBuilder(OpMethodBody &body,
// If this is a raw value, then we need to wrap it in an Attribute
// instance.
FmtContext fctx;
fctx.withBuilder("(*odsBuilder)");
fctx.withBuilder("odsBuilder");

std::string builderTemplate =
std::string(attr.getConstBuilderTemplate());
Expand Down
4 changes: 2 additions & 2 deletions mlir/unittests/Dialect/SPIRV/SerializationTest.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -38,7 +38,7 @@ class SerializationTest : public ::testing::Test {
SerializationTest() { createModuleOp(); }

void createModuleOp() {
Builder builder(&context);
OpBuilder builder(&context);
OperationState state(UnknownLoc::get(&context),
spirv::ModuleOp::getOperationName());
state.addAttribute("addressing_model",
Expand All @@ -51,7 +51,7 @@ class SerializationTest : public ::testing::Test {
spirv::VerCapExtAttr::get(
spirv::Version::V_1_0, ArrayRef<spirv::Capability>(),
ArrayRef<spirv::Extension>(), &context));
spirv::ModuleOp::build(&builder, state);
spirv::ModuleOp::build(builder, state);
module = cast<spirv::ModuleOp>(Operation::create(state));
}

Expand Down