These are now automatically prepended.
// using `builder.create<ConstantOp>(...)`.
let builders = [
// Build a constant with a given constant tensor value.
- OpBuilder<"OpBuilder &builder, OperationState &state, "
- "DenseElementsAttr value", [{
- build(builder, state, value.getType(), value);
+ OpBuilder<"DenseElementsAttr value", [{
+ build($_builder, $_state, value.getType(), value);
}]>,
// Build a constant with a given constant floating-point value.
- OpBuilder<"OpBuilder &builder, OperationState &state, double value">
+ OpBuilder<"double value">
];
// Invoke a static verify method to verify this constant operation.
// Allow building an AddOp with from the two input operands.
let builders = [
- OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
+ OpBuilder<"Value lhs, Value rhs">
];
}
// Add custom build methods for the generic call operation.
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, "
- "StringRef callee, ArrayRef<Value> arguments">
+ OpBuilder<"StringRef callee, ArrayRef<Value> arguments">
];
}
// Allow building a MulOp with from the two input operands.
let builders = [
- OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
+ OpBuilder<"Value lhs, Value rhs">
];
}
let assemblyFormat = "($input^ `:` type($input))? attr-dict ";
// Allow building a ReturnOp with no return operand.
- let builders = [OpBuilder<
- "OpBuilder &b, OperationState &state", [{ build(b, state, llvm::None); }]
- >];
+ let builders = [
+ OpBuilder<"", [{ build($_builder, $_state, llvm::None); }]>
+ ];
// Provide extra utility definitions on the c++ operation class definition.
let extraClassDeclaration = [{
// Allow building a TransposeOp with from the input operand.
let builders = [
- OpBuilder<"OpBuilder &b, OperationState &state, Value input">
+ OpBuilder<"Value input">
];
// Invoke a static verify method to verify this transpose operation.
// using `builder.create<ConstantOp>(...)`.
let builders = [
// Build a constant with a given constant tensor value.
- OpBuilder<"OpBuilder &builder, OperationState &state, "
- "DenseElementsAttr value", [{
- build(builder, state, value.getType(), value);
+ OpBuilder<"DenseElementsAttr value", [{
+ build($_builder, $_state, value.getType(), value);
}]>,
// Build a constant with a given constant floating-point value.
- OpBuilder<"OpBuilder &builder, OperationState &state, double value">
+ OpBuilder<"double value">
];
// Invoke a static verify method to verify this constant operation.
// Allow building an AddOp with from the two input operands.
let builders = [
- OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
+ OpBuilder<"Value lhs, Value rhs">
];
}
// Add custom build methods for the generic call operation.
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, "
- "StringRef callee, ArrayRef<Value> arguments">
+ OpBuilder<"StringRef callee, ArrayRef<Value> arguments">
];
}
// Allow building a MulOp with from the two input operands.
let builders = [
- OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
+ OpBuilder<"Value lhs, Value rhs">
];
}
let assemblyFormat = "($input^ `:` type($input))? attr-dict ";
// Allow building a ReturnOp with no return operand.
- let builders = [OpBuilder<
- "OpBuilder &b, OperationState &state", [{ build(b, state, llvm::None); }]
- >];
+ let builders = [
+ OpBuilder<"", [{ build($_builder, $_state, llvm::None); }]>
+ ];
// Provide extra utility definitions on the c++ operation class definition.
let extraClassDeclaration = [{
// Allow building a TransposeOp with from the input operand.
let builders = [
- OpBuilder<"OpBuilder &b, OperationState &state, Value input">
+ OpBuilder<"Value input">
];
// Invoke a static verify method to verify this transpose operation.
// using `builder.create<ConstantOp>(...)`.
let builders = [
// Build a constant with a given constant tensor value.
- OpBuilder<"OpBuilder &builder, OperationState &state, "
- "DenseElementsAttr value", [{
- build(builder, state, value.getType(), value);
+ OpBuilder<"DenseElementsAttr value", [{
+ build($_builder, $_state, value.getType(), value);
}]>,
// Build a constant with a given constant floating-point value.
- OpBuilder<"OpBuilder &builder, OperationState &state, double value">
+ OpBuilder<"double value">
];
// Invoke a static verify method to verify this constant operation.
// Allow building an AddOp with from the two input operands.
let builders = [
- OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
+ OpBuilder<"Value lhs, Value rhs">
];
}
// Add custom build methods for the generic call operation.
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, "
- "StringRef callee, ArrayRef<Value> arguments">
+ OpBuilder<"StringRef callee, ArrayRef<Value> arguments">
];
}
// Allow building a MulOp with from the two input operands.
let builders = [
- OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
+ OpBuilder<"Value lhs, Value rhs">
];
}
let assemblyFormat = "($input^ `:` type($input))? attr-dict ";
// Allow building a ReturnOp with no return operand.
- let builders = [OpBuilder<
- "OpBuilder &b, OperationState &state", [{ build(b, state, llvm::None); }]
- >];
+ let builders = [
+ OpBuilder<"", [{ build($_builder, $_state, llvm::None); }]>
+ ];
// Provide extra utility definitions on the c++ operation class definition.
let extraClassDeclaration = [{
// Allow building a TransposeOp with from the input operand.
let builders = [
- OpBuilder<"OpBuilder &b, OperationState &state, Value input">
+ OpBuilder<"Value input">
];
// Invoke a static verify method to verify this transpose operation.
// using `builder.create<ConstantOp>(...)`.
let builders = [
// Build a constant with a given constant tensor value.
- OpBuilder<"OpBuilder &builder, OperationState &state, "
- "DenseElementsAttr value", [{
- build(builder, state, value.getType(), value);
+ OpBuilder<"DenseElementsAttr value", [{
+ build($_builder, $_state, value.getType(), value);
}]>,
// Build a constant with a given constant floating-point value.
- OpBuilder<"OpBuilder &builder, OperationState &state, double value">
+ OpBuilder<"double value">
];
// Invoke a static verify method to verify this constant operation.
// Allow building an AddOp with from the two input operands.
let builders = [
- OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
+ OpBuilder<"Value lhs, Value rhs">
];
}
// Add custom build methods for the generic call operation.
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, "
- "StringRef callee, ArrayRef<Value> arguments">
+ OpBuilder<"StringRef callee, ArrayRef<Value> arguments">
];
}
// Allow building a MulOp with from the two input operands.
let builders = [
- OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
+ OpBuilder<"Value lhs, Value rhs">
];
}
let assemblyFormat = "($input^ `:` type($input))? attr-dict ";
// Allow building a ReturnOp with no return operand.
- let builders = [OpBuilder<
- "OpBuilder &b, OperationState &state", [{ build(b, state, llvm::None); }]
- >];
+ let builders = [
+ OpBuilder<"", [{ build($_builder, $_state, llvm::None); }]>
+ ];
// Provide extra utility definitions on the c++ operation class definition.
let extraClassDeclaration = [{
// Allow building a TransposeOp with from the input operand.
let builders = [
- OpBuilder<"OpBuilder &b, OperationState &state, Value input">
+ OpBuilder<"Value input">
];
// Invoke a static verify method to verify this transpose operation.
// using `builder.create<ConstantOp>(...)`.
let builders = [
// Build a constant with a given constant tensor value.
- OpBuilder<"OpBuilder &builder, OperationState &state, "
- "DenseElementsAttr value", [{
- build(builder, state, value.getType(), value);
+ OpBuilder<"DenseElementsAttr value", [{
+ build($_builder, $_state, value.getType(), value);
}]>,
// Build a constant with a given constant floating-point value.
- OpBuilder<"OpBuilder &builder, OperationState &state, double value">
+ OpBuilder<"double value">
];
// Invoke a static verify method to verify this constant operation.
// Allow building an AddOp with from the two input operands.
let builders = [
- OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
+ OpBuilder<"Value lhs, Value rhs">
];
}
// Add custom build methods for the generic call operation.
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, "
- "StringRef callee, ArrayRef<Value> arguments">
+ OpBuilder<"StringRef callee, ArrayRef<Value> arguments">
];
}
// Allow building a MulOp with from the two input operands.
let builders = [
- OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
+ OpBuilder<"Value lhs, Value rhs">
];
}
let assemblyFormat = "($input^ `:` type($input))? attr-dict ";
// Allow building a ReturnOp with no return operand.
- let builders = [OpBuilder<
- "OpBuilder &b, OperationState &state", [{ build(b, state, llvm::None); }]
- >];
+ let builders = [
+ OpBuilder<"", [{ build($_builder, $_state, llvm::None); }]>
+ ];
// Provide extra utility definitions on the c++ operation class definition.
let extraClassDeclaration = [{
// Allow building a TransposeOp with from the input operand.
let builders = [
- OpBuilder<"OpBuilder &b, OperationState &state, Value input">
+ OpBuilder<"Value input">
];
// Invoke a static verify method to verify this transpose operation.
// using `builder.create<ConstantOp>(...)`.
let builders = [
// Build a constant with a given constant tensor value.
- OpBuilder<"OpBuilder &builder, OperationState &state, "
- "DenseElementsAttr value", [{
- build(builder, state, value.getType(), value);
+ OpBuilder<"DenseElementsAttr value", [{
+ build($_builder, $_state, value.getType(), value);
}]>,
// Build a constant with a given constant floating-point value.
- OpBuilder<"OpBuilder &builder, OperationState &state, double value">
+ OpBuilder<"double value">
];
// Invoke a static verify method to verify this constant operation.
// Allow building an AddOp with from the two input operands.
let builders = [
- OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
+ OpBuilder<"Value lhs, Value rhs">
];
}
// Add custom build methods for the generic call operation.
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, "
- "StringRef callee, ArrayRef<Value> arguments">
+ OpBuilder<"StringRef callee, ArrayRef<Value> arguments">
];
}
// Allow building a MulOp with from the two input operands.
let builders = [
- OpBuilder<"OpBuilder &b, OperationState &state, Value lhs, Value rhs">
+ OpBuilder<"Value lhs, Value rhs">
];
}
let assemblyFormat = "($input^ `:` type($input))? attr-dict ";
// Allow building a ReturnOp with no return operand.
- let builders = [OpBuilder<
- "OpBuilder &b, OperationState &state", [{ build(b, state, llvm::None); }]
- >];
+ let builders = [
+ OpBuilder<"", [{ build($_builder, $_state, llvm::None); }]>
+ ];
// Provide extra utility definitions on the c++ operation class definition.
let extraClassDeclaration = [{
// Allow building a StructAccessOp with just a struct value and an index.
let builders = [
- OpBuilder<"OpBuilder &b, OperationState &state, Value input, size_t index">
+ OpBuilder<"Value input, size_t index">
];
let verifier = [{ return ::verify(*this); }];
// Allow building a TransposeOp with from the input operand.
let builders = [
- OpBuilder<"OpBuilder &b, OperationState &state, Value input">
+ OpBuilder<"Value input">
];
// Invoke a static verify method to verify this transpose operation.
}];
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, StringRef name, "
+ OpBuilder<"StringRef name, "
"ValueRange args = {}, ArrayRef<Attribute> params = {}", [{
- build(builder, state, builder.getStringAttr(name), args,
- params.empty() ? ArrayAttr() : builder.getArrayAttr(params));
+ build($_builder, $_state, $_builder.getStringAttr(name), args,
+ params.empty() ? ArrayAttr() : $_builder.getArrayAttr(params));
}]>,
];
}
let assemblyFormat = "attr-dict (`:` $type^)? ($value^)?";
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, "
- "Value type = Value()", [{
- build(builder, state, builder.getType<AttributeType>(), type,
+ OpBuilder<"Value type = Value()", [{
+ build($_builder, $_state, $_builder.getType<AttributeType>(), type,
Attribute());
}]>,
- OpBuilder<"OpBuilder &builder, OperationState &state, Attribute attr", [{
- build(builder, state, builder.getType<AttributeType>(), Value(), attr);
+ OpBuilder<"Attribute attr", [{
+ build($_builder, $_state, $_builder.getType<AttributeType>(), Value(), attr);
}]>,
];
}
let assemblyFormat = "(`:` $type^)? attr-dict";
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state", [{
- build(builder, state, builder.getType<ValueType>(), Value());
+ OpBuilder<"", [{
+ build($_builder, $_state, $_builder.getType<ValueType>(), Value());
}]>,
];
}
let results = (outs PDL_Operation:$op,
Variadic<PDL_Value>:$results);
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, "
- "Optional<StringRef> name = llvm::None, "
+ OpBuilder<"Optional<StringRef> name = llvm::None, "
"ValueRange operandValues = llvm::None, "
"ArrayRef<StringRef> attrNames = llvm::None, "
"ValueRange attrValues = llvm::None, "
"ValueRange resultTypes = llvm::None", [{
- auto nameAttr = name ? StringAttr() : builder.getStringAttr(*name);
- build(builder, state, builder.getType<OperationType>(), {}, nameAttr,
- operandValues, attrValues, builder.getStrArrayAttr(attrNames),
+ auto nameAttr = name ? StringAttr() : $_builder.getStringAttr(*name);
+ build($_builder, $_state, $_builder.getType<OperationType>(), {}, nameAttr,
+ operandValues, attrValues, $_builder.getStrArrayAttr(attrNames),
resultTypes);
- state.types.append(resultTypes.size(), builder.getType<ValueType>());
+ $_state.types.append(resultTypes.size(), $_builder.getType<ValueType>());
}]>,
];
let extraClassDeclaration = [{
}];
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, "
- "Optional<StringRef> rootKind = llvm::None, "
+ OpBuilder<"Optional<StringRef> rootKind = llvm::None, "
"Optional<uint16_t> benefit = 1, "
"Optional<StringRef> name = llvm::None">,
];
let assemblyFormat = "attr-dict (`:` $type^)?";
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, Type ty = Type()", [{
- build(builder, state, builder.getType<AttributeType>(),
+ OpBuilder<"Type ty = Type()", [{
+ build($_builder, $_state, $_builder.getType<AttributeType>(),
ty ? TypeAttr::get(ty) : TypeAttr());
}]>,
];
let assemblyFormat = "$value attr-dict";
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, "
- "Attribute value", [{
- build(builder, state, builder.getType<pdl::AttributeType>(), value);
+ OpBuilder<"Attribute value", [{
+ build($_builder, $_state, $_builder.getType<pdl::AttributeType>(), value);
}]>];
}
let results = (outs PDL_Operation:$operation);
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, StringRef name, "
- "ValueRange types, ValueRange operands, ValueRange attributes, "
- "ArrayAttr attributeNames", [{
- build(builder, state, builder.getType<pdl::OperationType>(), name,
+ OpBuilder<"StringRef name, ValueRange types, ValueRange operands, "
+ "ValueRange attributes, ArrayAttr attributeNames", [{
+ build($_builder, $_state, $_builder.getType<pdl::OperationType>(), name,
operands, attributes, attributeNames, types);
}]>];
let parser = [{ return ::parseCreateOperationOp(parser, result); }];
let assemblyFormat = "$value attr-dict";
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, TypeAttr type", [{
- build(builder, state, builder.getType<pdl::TypeType>(), type);
+ OpBuilder<"TypeAttr type", [{
+ build($_builder, $_state, $_builder.getType<pdl::TypeType>(), type);
}]>
];
}
let assemblyFormat = "`of` $value attr-dict";
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, Value value", [{
- build(builder, state, builder.getType<pdl::TypeType>(), value);
+ OpBuilder<"Value value", [{
+ build($_builder, $_state, $_builder.getType<pdl::TypeType>(), value);
}]>
];
}
let assemblyFormat = "`of` $value attr-dict";
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, Value value", [{
- build(builder, state, builder.getType<pdl::TypeType>(), value);
+ OpBuilder<"Value value", [{
+ build($_builder, $_state, $_builder.getType<pdl::TypeType>(), value);
}]>
];
}
let assemblyFormat = "attr-dict";
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state", [{
- build(builder, state, builder.getType<pdl::TypeType>());
+ OpBuilder<"", [{
+ build($_builder, $_state, $_builder.getType<pdl::TypeType>());
}]>,
];
}
}];
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, Value attribute,"
- "ArrayRef<Attribute> caseValues,"
+ OpBuilder<"Value attribute, ArrayRef<Attribute> caseValues,"
"Block *defaultDest, ArrayRef<Block *> dests", [{
- build(builder, state, attribute, builder.getArrayAttr(caseValues),
+ build($_builder, $_state, attribute, $_builder.getArrayAttr(caseValues),
defaultDest, dests);
}]>];
}
}];
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, Value operation, "
- "ArrayRef<int32_t> counts, Block *defaultDest, "
- "ArrayRef<Block *> dests", [{
- build(builder, state, operation, builder.getI32VectorAttr(counts),
+ OpBuilder<"Value operation, ArrayRef<int32_t> counts, "
+ "Block *defaultDest, ArrayRef<Block *> dests", [{
+ build($_builder, $_state, operation, $_builder.getI32VectorAttr(counts),
defaultDest, dests);
}]>];
}
}];
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, Value operation, "
- "ArrayRef<OperationName> names, "
+ OpBuilder<"Value operation, ArrayRef<OperationName> names, "
"Block *defaultDest, ArrayRef<Block *> dests", [{
auto stringNames = llvm::to_vector<8>(llvm::map_range(names,
[](OperationName name) { return name.getStringRef(); }));
- build(builder, state, operation, builder.getStrArrayAttr(stringNames),
+ build($_builder, $_state, operation, $_builder.getStrArrayAttr(stringNames),
defaultDest, dests);
}]>,
];
}];
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, Value operation, "
- "ArrayRef<int32_t> counts, Block *defaultDest, "
+ OpBuilder<"Value operation, ArrayRef<int32_t> counts, Block *defaultDest, "
"ArrayRef<Block *> dests", [{
- build(builder, state, operation, builder.getI32VectorAttr(counts),
+ build($_builder, $_state, operation, $_builder.getI32VectorAttr(counts),
defaultDest, dests);
}]>];
}
}];
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, Value edge, "
- "TypeRange types, Block *defaultDest, ArrayRef<Block *> dests", [{
- build(builder, state, edge, builder.getTypeArrayAttr(types), defaultDest,
- dests);
+ OpBuilder<"Value edge, TypeRange types, Block *defaultDest, "
+ "ArrayRef<Block *> dests", [{
+ build($_builder, $_state, edge, $_builder.getTypeArrayAttr(types),
+ defaultDest, dests);
}]>,
];
let builders = [
OpBuilder<
- [{OpBuilder &builder, OperationState &state, Value pointer,
- ::mlir::spirv::Scope scope, ::mlir::spirv::MemorySemantics memory,
- Value value}],
- [{build(builder, state, value.getType(), pointer, scope, memory, value);}]
+ [{Value pointer, ::mlir::spirv::Scope scope,
+ ::mlir::spirv::MemorySemantics memory, Value value}],
+ [{build($_builder, $_state, value.getType(), pointer, scope, memory, value);}]
>
];
}
);
let builders = [
- OpBuilder<[{OpBuilder &builder, OperationState &state,
- Value composite, ArrayRef<int32_t> indices}]>
+ OpBuilder<[{Value composite, ArrayRef<int32_t> indices}]>
];
let hasFolder = 1;
let builders = [
OpBuilder<
- "OpBuilder &, OperationState &state, "
"Block *successor, ValueRange arguments = {}", [{
- state.addSuccessors(successor);
- state.addOperands(arguments);
+ $_state.addSuccessors(successor);
+ $_state.addOperands(arguments);
}]
>
];
let builders = [
OpBuilder<
- "OpBuilder &builder, OperationState &state, Value condition, "
+ "Value condition, "
"Block *trueBlock, ValueRange trueArguments, "
"Block *falseBlock, ValueRange falseArguments, "
"Optional<std::pair<uint32_t, uint32_t>> weights = {}",
ArrayAttr weightsAttr;
if (weights) {
weightsAttr =
- builder.getI32ArrayAttr({static_cast<int32_t>(weights->first),
+ $_builder.getI32ArrayAttr({static_cast<int32_t>(weights->first),
static_cast<int32_t>(weights->second)});
}
- build(builder, state, condition, trueArguments, falseArguments,
+ build($_builder, $_state, condition, trueArguments, falseArguments,
weightsAttr, trueBlock, falseBlock);
}]
>
let regions = (region AnyRegion:$body);
- let builders = [OpBuilder<"OpBuilder &builder, OperationState &state">];
+ let builders = [OpBuilder<"">];
let extraClassDeclaration = [{
// Returns the entry block.
let builders = [
OpBuilder<
- "OpBuilder &builder, OperationState &state, Value lhs, Value rhs",
- "::buildLogicalBinaryOp(builder, state, lhs, rhs);">
+ "Value lhs, Value rhs",
+ "::buildLogicalBinaryOp($_builder, $_state, lhs, rhs);">
];
}
SPV_SelectType:$result
);
- let builders = [OpBuilder<[{OpBuilder &builder, OperationState &state,
- Value cond, Value trueValue,
+ let builders = [OpBuilder<[{Value cond, Value trueValue,
Value falseValue}]>];
let assemblyFormat = [{
);
let builders = [
- OpBuilder<[{OpBuilder &builder, OperationState &state, spirv::Scope}]>
+ OpBuilder<[{spirv::Scope}]>
];
let assemblyFormat = "$execution_scope attr-dict `:` type($result)";
SPV_AnyPtr:$component_ptr
);
- let builders = [OpBuilder<[{OpBuilder &builder, OperationState &state,
- Value basePtr, ValueRange indices}]>];
+ let builders = [OpBuilder<[{Value basePtr, ValueRange indices}]>];
let hasCanonicalizer = 1;
}
let autogenSerialization = 0;
- let builders = [OpBuilder<[{OpBuilder &builder, OperationState &state,
- spirv::FuncOp function,
+ let builders = [OpBuilder<[{spirv::FuncOp function,
spirv::ExecutionMode executionMode,
ArrayRef<int32_t> params}]>];
}
let builders = [
OpBuilder<[{
- OpBuilder &builder, OperationState &state,
Value basePtr, IntegerAttr memory_access = {},
IntegerAttr alignment = {}
}]>
let results = (outs);
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, "
+ OpBuilder<
"Value ptr, Value value, ArrayRef<NamedAttribute> namedAttrs = {}", [{
- state.addOperands(ptr);
- state.addOperands(value);
- state.addAttributes(namedAttrs);
+ $_state.addOperands(ptr);
+ $_state.addOperands(value);
+ $_state.addAttributes(namedAttrs);
}]>
];
}
let autogenSerialization = 0;
- let builders = [OpBuilder<[{OpBuilder &builder, OperationState &state,
- spirv::GlobalVariableOp var}]>];
+ let builders = [OpBuilder<[{spirv::GlobalVariableOp var}]>];
let assemblyFormat = "$variable attr-dict `:` type($pointer)";
}
let autogenSerialization = 0;
- let builders = [OpBuilder<[{OpBuilder &builder, OperationState &state,
- spirv::ExecutionModel executionModel,
+ let builders = [OpBuilder<[{spirv::ExecutionModel executionModel,
spirv::FuncOp function,
ArrayRef<Attribute> interfaceVars}]>];
}
let verifier = [{ return success(); }];
let builders = [OpBuilder<[{
- OpBuilder &, OperationState &state,
StringRef name, FunctionType type,
spirv::FunctionControl control = spirv::FunctionControl::None,
ArrayRef<NamedAttribute> attrs = {}
let results = (outs);
let builders = [
- OpBuilder<"OpBuilder &builder, OperationState &state, "
+ OpBuilder<
"TypeAttr type, ArrayRef<NamedAttribute> namedAttrs", [{
- state.addAttribute("type", type);
- state.addAttributes(namedAttrs);
+ $_state.addAttribute("type", type);
+ $_state.addAttributes(namedAttrs);
}]>,
- OpBuilder<[{OpBuilder &builder, OperationState &state,
- Type type, StringRef name, unsigned descriptorSet,
+ OpBuilder<[{Type type, StringRef name, unsigned descriptorSet,
unsigned binding}]>,
- OpBuilder<[{OpBuilder &builder, OperationState &state,
- Type type, StringRef name, spirv::BuiltIn builtin}]>
+ OpBuilder<[{Type type, StringRef name, spirv::BuiltIn builtin}]>
];
let hasOpcode = 0;
let regions = (region SizedRegion<1>:$body);
let builders = [
- OpBuilder<[{OpBuilder &, OperationState &state,
- Optional<StringRef> name = llvm::None}]>,
- OpBuilder<[{OpBuilder &, OperationState &state,
- spirv::AddressingModel addressing_model,
+ OpBuilder<[{Optional<StringRef> name = llvm::None}]>,
+ OpBuilder<[{spirv::AddressingModel addressing_model,
spirv::MemoryModel memory_model,
Optional<StringRef> name = llvm::None}]>
];