Fix call sites.
The method will be removed 2 weeks later.
Reviewed By: rriddle
Differential Revision: https://reviews.llvm.org/D97464
p << ", ";
p.printOperand(sh);
}
- p.printOptionalAttrDict(getAttrs(), {inType(), lenpName()});
+ p.printOptionalAttrDict((*this)->getAttrs(), {inType(), lenpName()});
}];
string extraAllocClassDeclaration = [{
let printer = [{
p << getOperationName() << ' ';
p.printOperand(memref());
- p.printOptionalAttrDict(getAttrs(), {});
+ p.printOptionalAttrDict((*this)->getAttrs(), {});
p << " : " << memref().getType();
}];
p.printOperand(value());
p << " to ";
p.printOperand(memref());
- p.printOptionalAttrDict(getAttrs(), {});
+ p.printOptionalAttrDict((*this)->getAttrs(), {});
p << " : " << memref().getType();
}];
/// strings, attributes, operands, types, etc.
static void print(mlir::OpAsmPrinter &printer, ConstantOp op) {
printer << "toy.constant ";
- printer.printOptionalAttrDict(op.getAttrs(), /*elidedAttrs=*/{"value"});
+ printer.printOptionalAttrDict(op->getAttrs(), /*elidedAttrs=*/{"value"});
printer << op.value();
}
/// strings, attributes, operands, types, etc.
static void print(mlir::OpAsmPrinter &printer, ConstantOp op) {
printer << "toy.constant ";
- printer.printOptionalAttrDict(op.getAttrs(), /*elidedAttrs=*/{"value"});
+ printer.printOptionalAttrDict(op->getAttrs(), /*elidedAttrs=*/{"value"});
printer << op.value();
}
void setLoc(Location loc) { state->setLoc(loc); }
/// Return all of the attributes on this operation.
- ArrayRef<NamedAttribute> getAttrs() { return state->getAttrs(); }
+ LLVM_ATTRIBUTE_DEPRECATED(
+ ArrayRef<NamedAttribute> getAttrs(),
+ "Use Operation::getAttrs() instead (replace '.' with '->').") {
+ return state->getAttrs();
+ }
/// A utility iterator that filters out non-dialect attributes.
using dialect_attr_iterator = Operation::dialect_attr_iterator;
return success();
}
rewriter.replaceOpWithNewOp<LLVM::ConstantOp>(constOp, dstType, operands,
- constOp.getAttrs());
+ constOp->getAttrs());
return success();
}
};
if (!dstType)
return failure();
rewriter.template replaceOpWithNewOp<LLVMOp>(operation, dstType, operands,
- operation.getAttrs());
+ operation->getAttrs());
return success();
}
};
ConversionPatternRewriter &rewriter) const override {
if (callOp.getNumResults() == 0) {
rewriter.replaceOpWithNewOp<LLVM::CallOp>(callOp, llvm::None, operands,
- callOp.getAttrs());
+ callOp->getAttrs());
return success();
}
// Function returns a single result.
auto dstType = typeConverter.convertType(callOp.getType(0));
rewriter.replaceOpWithNewOp<LLVM::CallOp>(callOp, dstType, operands,
- callOp.getAttrs());
+ callOp->getAttrs());
return success();
}
};
p << AffineApplyOp::getOperationName() << " " << op.mapAttr();
printDimAndSymbolList(op.operand_begin(), op.operand_end(),
op.getAffineMap().getNumDims(), p);
- p.printOptionalAttrDict(op.getAttrs(), /*elidedAttrs=*/{"map"});
+ p.printOptionalAttrDict(op->getAttrs(), /*elidedAttrs=*/{"map"});
}
static LogicalResult verify(AffineApplyOp op) {
p.printRegion(op.region(),
/*printEntryBlockArgs=*/false, printBlockTerminators);
- p.printOptionalAttrDict(op.getAttrs(),
+ p.printOptionalAttrDict(op->getAttrs(),
/*elidedAttrs=*/{op.getLowerBoundAttrName(),
op.getUpperBoundAttrName(),
op.getStepAttrName()});
}
// Print the attribute list.
- p.printOptionalAttrDict(op.getAttrs(),
+ p.printOptionalAttrDict(op->getAttrs(),
/*elidedAttrs=*/op.getConditionAttrName());
}
op->getAttrOfType<AffineMapAttr>(op.getMapAttrName()))
p.printAffineMapOfSSAIds(mapAttr, op.getMapOperands());
p << ']';
- p.printOptionalAttrDict(op.getAttrs(), /*elidedAttrs=*/{op.getMapAttrName()});
+ p.printOptionalAttrDict(op->getAttrs(),
+ /*elidedAttrs=*/{op.getMapAttrName()});
p << " : " << op.getMemRefType();
}
op->getAttrOfType<AffineMapAttr>(op.getMapAttrName()))
p.printAffineMapOfSSAIds(mapAttr, op.getMapOperands());
p << ']';
- p.printOptionalAttrDict(op.getAttrs(), /*elidedAttrs=*/{op.getMapAttrName()});
+ p.printOptionalAttrDict(op->getAttrs(),
+ /*elidedAttrs=*/{op.getMapAttrName()});
p << " : " << op.getMemRefType();
}
if (operands.size() != numDims)
p << '[' << operands.drop_front(numDims) << ']';
- p.printOptionalAttrDict(op.getAttrs(),
+ p.printOptionalAttrDict(op->getAttrs(),
/*elidedAttrs=*/{T::getMapAttrName()});
}
<< "locality<" << op.localityHint() << ">, "
<< (op.isDataCache() ? "data" : "instr");
p.printOptionalAttrDict(
- op.getAttrs(),
+ op->getAttrs(),
/*elidedAttrs=*/{op.getMapAttrName(), op.getLocalityHintAttrName(),
op.getIsDataCacheAttrName(), op.getIsWriteAttrName()});
p << " : " << op.getMemRefType();
p.printRegion(op.region(), /*printEntryBlockArgs=*/false,
/*printBlockTerminators=*/op.getNumResults());
p.printOptionalAttrDict(
- op.getAttrs(),
+ op->getAttrs(),
/*elidedAttrs=*/{AffineParallelOp::getReductionsAttrName(),
AffineParallelOp::getLowerBoundsMapAttrName(),
AffineParallelOp::getUpperBoundsMapAttrName(),
op->getAttrOfType<AffineMapAttr>(op.getMapAttrName()))
p.printAffineMapOfSSAIds(mapAttr, op.getMapOperands());
p << ']';
- p.printOptionalAttrDict(op.getAttrs(), /*elidedAttrs=*/{op.getMapAttrName()});
+ p.printOptionalAttrDict(op->getAttrs(),
+ /*elidedAttrs=*/{op.getMapAttrName()});
p << " : " << op.getMemRefType() << ", " << op.getType();
}
op->getAttrOfType<AffineMapAttr>(op.getMapAttrName()))
p.printAffineMapOfSSAIds(mapAttr, op.getMapOperands());
p << ']';
- p.printOptionalAttrDict(op.getAttrs(), /*elidedAttrs=*/{op.getMapAttrName()});
+ p.printOptionalAttrDict(op->getAttrs(),
+ /*elidedAttrs=*/{op.getMapAttrName()});
p << " : " << op.getMemRefType() << ", " << op.getValueToStore().getType();
}
// -> (!async.value<!return.type>, ...)
p.printOptionalArrowTypeList(op.getResultTypes().drop_front(1));
- p.printOptionalAttrDictWithKeyword(op.getAttrs(), {kOperandSegmentSizesAttr});
+ p.printOptionalAttrDictWithKeyword(op->getAttrs(),
+ {kOperandSegmentSizesAttr});
p.printRegion(op.body(), /*printEntryBlockArgs=*/false);
}
op.getThreadIds());
p.printRegion(op.body(), /*printEntryBlockArgs=*/false);
- p.printOptionalAttrDict(op.getAttrs());
+ p.printOptionalAttrDict(op->getAttrs());
}
// Parse the size assignment blocks for blocks and threads. These have the form
static void print(OpAsmPrinter &p, GPUModuleOp op) {
p << op.getOperationName() << ' ';
p.printSymbolName(op.getName());
- p.printOptionalAttrDictWithKeyword(op.getAttrs(),
+ p.printOptionalAttrDictWithKeyword(op->getAttrs(),
{SymbolTable::getSymbolAttrName()});
p.printRegion(op->getRegion(0), /*printEntryBlockArgs=*/false,
/*printBlockTerminators=*/false);
static void printICmpOp(OpAsmPrinter &p, ICmpOp &op) {
p << op.getOperationName() << " \"" << stringifyICmpPredicate(op.predicate())
<< "\" " << op.getOperand(0) << ", " << op.getOperand(1);
- p.printOptionalAttrDict(op.getAttrs(), {"predicate"});
+ p.printOptionalAttrDict(op->getAttrs(), {"predicate"});
p << " : " << op.lhs().getType();
}
static void printFCmpOp(OpAsmPrinter &p, FCmpOp &op) {
p << op.getOperationName() << " \"" << stringifyFCmpPredicate(op.predicate())
<< "\" " << op.getOperand(0) << ", " << op.getOperand(1);
- p.printOptionalAttrDict(processFMFAttr(op.getAttrs()), {"predicate"});
+ p.printOptionalAttrDict(processFMFAttr(op->getAttrs()), {"predicate"});
p << " : " << op.lhs().getType();
}
p << op.getOperationName() << ' ' << op.arraySize() << " x " << elemTy;
if (op.alignment().hasValue() && *op.alignment() != 0)
- p.printOptionalAttrDict(op.getAttrs());
+ p.printOptionalAttrDict(op->getAttrs());
else
- p.printOptionalAttrDict(op.getAttrs(), {"alignment"});
+ p.printOptionalAttrDict(op->getAttrs(), {"alignment"});
p << " : " << funcTy;
}
if (op.volatile_())
p << "volatile ";
p << op.addr();
- p.printOptionalAttrDict(op.getAttrs(), {kVolatileAttrName});
+ p.printOptionalAttrDict(op->getAttrs(), {kVolatileAttrName});
p << " : " << op.addr().getType();
}
if (op.volatile_())
p << "volatile ";
p << op.value() << ", " << op.addr();
- p.printOptionalAttrDict(op.getAttrs(), {kVolatileAttrName});
+ p.printOptionalAttrDict(op->getAttrs(), {kVolatileAttrName});
p << " : " << op.addr().getType();
}
p << " unwind ";
p.printSuccessorAndUseList(op.unwindDest(), op.unwindDestOperands());
- p.printOptionalAttrDict(op.getAttrs(),
+ p.printOptionalAttrDict(op->getAttrs(),
{InvokeOp::getOperandSegmentSizeAttr(), "callee"});
p << " : ";
p.printFunctionalType(
<< value.getType() << ") ";
}
- p.printOptionalAttrDict(op.getAttrs(), {"cleanup"});
+ p.printOptionalAttrDict(op->getAttrs(), {"cleanup"});
p << ": " << op.getType();
}
auto args = op.getOperands().drop_front(isDirect ? 0 : 1);
p << '(' << args << ')';
- p.printOptionalAttrDict(processFMFAttr(op.getAttrs()), {"callee"});
+ p.printOptionalAttrDict(processFMFAttr(op->getAttrs()), {"callee"});
// Reconstruct the function MLIR function type from operand and result types.
p << " : "
static void printExtractElementOp(OpAsmPrinter &p, ExtractElementOp &op) {
p << op.getOperationName() << ' ' << op.vector() << "[" << op.position()
<< " : " << op.position().getType() << "]";
- p.printOptionalAttrDict(op.getAttrs());
+ p.printOptionalAttrDict(op->getAttrs());
p << " : " << op.vector().getType();
}
static void printExtractValueOp(OpAsmPrinter &p, ExtractValueOp &op) {
p << op.getOperationName() << ' ' << op.container() << op.position();
- p.printOptionalAttrDict(op.getAttrs(), {"position"});
+ p.printOptionalAttrDict(op->getAttrs(), {"position"});
p << " : " << op.container().getType();
}
static void printInsertElementOp(OpAsmPrinter &p, InsertElementOp &op) {
p << op.getOperationName() << ' ' << op.value() << ", " << op.vector() << "["
<< op.position() << " : " << op.position().getType() << "]";
- p.printOptionalAttrDict(op.getAttrs());
+ p.printOptionalAttrDict(op->getAttrs());
p << " : " << op.vector().getType();
}
static void printInsertValueOp(OpAsmPrinter &p, InsertValueOp &op) {
p << op.getOperationName() << ' ' << op.value() << ", " << op.container()
<< op.position();
- p.printOptionalAttrDict(op.getAttrs(), {"position"});
+ p.printOptionalAttrDict(op->getAttrs(), {"position"});
p << " : " << op.container().getType();
}
static void printReturnOp(OpAsmPrinter &p, ReturnOp op) {
p << op.getOperationName();
- p.printOptionalAttrDict(op.getAttrs());
+ p.printOptionalAttrDict(op->getAttrs());
assert(op.getNumOperands() <= 1);
if (op.getNumOperands() == 0)
if (auto value = op.getValueOrNull())
p.printAttribute(value);
p << ')';
- p.printOptionalAttrDict(op.getAttrs(),
+ p.printOptionalAttrDict(op->getAttrs(),
{SymbolTable::getSymbolAttrName(), "type", "constant",
"value", getLinkageAttrName()});
static void printShuffleVectorOp(OpAsmPrinter &p, ShuffleVectorOp &op) {
p << op.getOperationName() << ' ' << op.v1() << ", " << op.v2() << " "
<< op.mask();
- p.printOptionalAttrDict(op.getAttrs(), {"mask"});
+ p.printOptionalAttrDict(op->getAttrs(), {"mask"});
p << " : " << op.v1().getType() << ", " << op.v2().getType();
}
p << op.getOperationName() << ' ' << stringifyAtomicBinOp(op.bin_op()) << ' '
<< op.ptr() << ", " << op.val() << ' '
<< stringifyAtomicOrdering(op.ordering()) << ' ';
- p.printOptionalAttrDict(op.getAttrs(), {"bin_op", "ordering"});
+ p.printOptionalAttrDict(op->getAttrs(), {"bin_op", "ordering"});
p << " : " << op.res().getType();
}
p << op.getOperationName() << ' ' << op.ptr() << ", " << op.cmp() << ", "
<< op.val() << ' ' << stringifyAtomicOrdering(op.success_ordering()) << ' '
<< stringifyAtomicOrdering(op.failure_ordering());
- p.printOptionalAttrDict(op.getAttrs(),
+ p.printOptionalAttrDict(op->getAttrs(),
{"success_ordering", "failure_ordering"});
p << " : " << op.val().getType();
}
llvm::StringSet<> genericAttrNamesSet;
genericAttrNamesSet.insert(genericAttrNames.begin(), genericAttrNames.end());
SmallVector<NamedAttribute, 8> genericAttrs;
- for (auto attr : op.getAttrs())
+ for (auto attr : op->getAttrs())
if (genericAttrNamesSet.count(attr.first.strref()) > 0)
genericAttrs.push_back(attr);
if (!genericAttrs.empty()) {
genericAttrNamesSet.insert(genericAttrNames.back());
bool hasExtraAttrs = false;
- for (NamedAttribute n : op.getAttrs()) {
+ for (NamedAttribute n : op->getAttrs()) {
if ((hasExtraAttrs = !genericAttrNamesSet.contains(n.first.strref())))
break;
}
if (hasExtraAttrs) {
p << " attrs = ";
- p.printOptionalAttrDict(op.getAttrs(), /*elidedAttrs=*/genericAttrNames);
+ p.printOptionalAttrDict(op->getAttrs(), /*elidedAttrs=*/genericAttrNames);
}
// Print region.
p << op.getOperationName();
if (op.getNumOperands() > 0)
p << ' ' << op.getOperands();
- p.printOptionalAttrDict(op.getAttrs());
+ p.printOptionalAttrDict(op->getAttrs());
if (op.getNumOperands() > 0)
p << " : " << op.getOperandTypes();
}
p.printRegion(op.region(), /*printEntryBlockArgs=*/false);
p.printOptionalAttrDict(
- op.getAttrs(), /*elidedAttrs=*/{TiledLoopOp::getOperandSegmentSizeAttr(),
- getIteratorTypesAttrName()});
+ op->getAttrs(), /*elidedAttrs=*/{TiledLoopOp::getOperandSegmentSizeAttr(),
+ getIteratorTypesAttrName()});
}
static ParseResult parseTiledLoopOp(OpAsmParser &parser,
template <typename NamedStructuredOpType>
static void printNamedStructuredOp(OpAsmPrinter &p, NamedStructuredOpType op) {
p << op.getOperationName();
- p.printOptionalAttrDict(op.getAttrs(),
+ p.printOptionalAttrDict(op->getAttrs(),
/*elidedAttrs=*/{"operand_segment_sizes"});
// Printing is shared with generic ops, except for the region and
/*printEntryBlockArgs=*/false,
/*printBlockTerminators=*/true);
printer.printOptionalAttrDictWithKeyword(
- op.getAttrs(), ParallelOp::getOperandSegmentSizeAttr());
+ op->getAttrs(), ParallelOp::getOperandSegmentSizeAttr());
}
//===----------------------------------------------------------------------===//
/*printBlockTerminators=*/true);
printer.printOptionalAttrDictWithKeyword(
- op.getAttrs(), {LoopOp::getExecutionMappingAttrName(),
- LoopOp::getOperandSegmentSizeAttr()});
+ op->getAttrs(), {LoopOp::getExecutionMappingAttrName(),
+ LoopOp::getOperandSegmentSizeAttr()});
}
static LogicalResult verifyLoopOp(acc::LoopOp loopOp) {
// Print the result type constraints of the operation.
if (!op.results().empty())
p << " -> " << op.types();
- p.printOptionalAttrDict(op.getAttrs(),
+ p.printOptionalAttrDict(op->getAttrs(),
{"attributeNames", "name", "operand_segment_sizes"});
}
static void print(OpAsmPrinter &p, CreateOperationOp op) {
p << "pdl_interp.create_operation ";
- p.printOptionalAttrDict(op.getAttrs(),
+ p.printOptionalAttrDict(op->getAttrs(),
{"attributeNames", "name", "operand_segment_sizes"});
p << '"' << op.name() << "\"(" << op.operands() << ')';
p.printRegion(op.region(),
/*printEntryBlockArgs=*/false,
/*printBlockTerminators=*/op.hasIterOperands());
- p.printOptionalAttrDict(op.getAttrs());
+ p.printOptionalAttrDict(op->getAttrs());
}
static ParseResult parseForOp(OpAsmParser &parser, OperationState &result) {
/*printBlockTerminators=*/printBlockTerminators);
}
- p.printOptionalAttrDict(op.getAttrs());
+ p.printOptionalAttrDict(op->getAttrs());
}
/// Given the region at `index`, or the parent operation if `index` is None,
p.printOptionalArrowTypeList(op.getResultTypes());
p.printRegion(op.region(), /*printEntryBlockArgs=*/false);
p.printOptionalAttrDict(
- op.getAttrs(), /*elidedAttrs=*/ParallelOp::getOperandSegmentSizeAttr());
+ op->getAttrs(), /*elidedAttrs=*/ParallelOp::getOperandSegmentSizeAttr());
}
Region &ParallelOp::getLoopBody() { return region(); }
p.printRegion(op.before(), /*printEntryBlockArgs=*/false);
p << " do";
p.printRegion(op.after());
- p.printOptionalAttrDictWithKeyword(op.getAttrs());
+ p.printOptionalAttrDictWithKeyword(op->getAttrs());
}
/// Verifies that two ranges of types match, i.e. have the same number of
spirv::PointerType::get(structType, ptrType.getStorageClass());
// Save all named attributes except "type" attribute.
- for (const auto &attr : op.getAttrs()) {
+ for (const auto &attr : op->getAttrs()) {
if (attr.first == "type") {
continue;
}
p.printRegion(op.doRegion(),
/*printEntryBlockArgs=*/false,
/*printBlockTerminators=*/yieldsResults);
- p.printOptionalAttrDict(op.getAttrs());
+ p.printOptionalAttrDict(op->getAttrs());
}
namespace {
static void print(OpAsmPrinter &p, ConstShapeOp &op) {
p << "shape.const_shape ";
- p.printOptionalAttrDict(op.getAttrs(), /*elidedAttrs=*/{"shape"});
+ p.printOptionalAttrDict(op->getAttrs(), /*elidedAttrs=*/{"shape"});
p << "[";
interleaveComma(op.shape().getValues<int64_t>(), p,
[&](int64_t i) { p << i; });
p << op.getOperationName() << ' ';
p.printSymbolName(op.getName());
p.printOptionalAttrDictWithKeyword(
- op.getAttrs(), {SymbolTable::getSymbolAttrName(), "mapping"});
+ op->getAttrs(), {SymbolTable::getSymbolAttrName(), "mapping"});
p.printRegion(op.getOperation()->getRegion(0), /*printEntryBlockArgs=*/false,
/*printBlockTerminators=*/false);
p << " mapping ";
<< ") : " << op.shape().getType();
p.printOptionalArrowTypeList(op.getResultTypes());
p.printRegion(op.region());
- p.printOptionalAttrDict(op.getAttrs());
+ p.printOptionalAttrDict(op->getAttrs());
}
#define GET_OP_CLASSES
p << op.getOperationName() << ' ' << op.memref() << "[" << op.indices()
<< "] : " << op.memref().getType();
p.printRegion(op.body());
- p.printOptionalAttrDict(op.getAttrs());
+ p.printOptionalAttrDict(op->getAttrs());
}
//===----------------------------------------------------------------------===//
static void print(OpAsmPrinter &p, ConstantOp &op) {
p << "constant ";
- p.printOptionalAttrDict(op.getAttrs(), /*elidedAttrs=*/{"value"});
+ p.printOptionalAttrDict(op->getAttrs(), /*elidedAttrs=*/{"value"});
- if (op.getAttrs().size() > 1)
+ if (op->getAttrs().size() > 1)
p << ' ';
p << op.getValue();
if (isStrided())
p << ", " << getStride() << ", " << getNumElementsPerStride();
- p.printOptionalAttrDict(getAttrs());
+ p.printOptionalAttrDict((*this)->getAttrs());
p << " : " << getSrcMemRef().getType() << ", " << getDstMemRef().getType()
<< ", " << getTagMemRef().getType();
}
void DmaWaitOp::print(OpAsmPrinter &p) {
p << "dma_wait " << getTagMemRef() << '[' << getTagIndices() << "], "
<< getNumElements();
- p.printOptionalAttrDict(getAttrs());
+ p.printOptionalAttrDict((*this)->getAttrs());
p << " : " << getTagMemRef().getType();
}
p << ", locality<" << op.localityHint();
p << ">, " << (op.isDataCache() ? "data" : "instr");
p.printOptionalAttrDict(
- op.getAttrs(),
+ op->getAttrs(),
/*elidedAttrs=*/{"localityHint", "isWrite", "isDataCache"});
p << " : " << op.getMemRefType();
}
static void print(OpAsmPrinter &p, SelectOp op) {
p << "select " << op.getOperands();
- p.printOptionalAttrDict(op.getAttrs());
+ p.printOptionalAttrDict(op->getAttrs());
p << " : ";
if (ShapedType condType = op.getCondition().getType().dyn_cast<ShapedType>())
p << condType << ", ";
// transpose $in $permutation attr-dict : type($in) `to` type(results)
static void print(OpAsmPrinter &p, TransposeOp op) {
p << "transpose " << op.in() << " " << op.permutation();
- p.printOptionalAttrDict(op.getAttrs(),
+ p.printOptionalAttrDict(op->getAttrs(),
{TransposeOp::getPermutationAttrName()});
p << " : " << op.in().getType() << " to " << op.getType();
}
p << op.getOperationName() << ' ' << op.getOperand(0) << '[';
p.printOperand(op.byte_shift());
p << "][" << op.sizes() << ']';
- p.printOptionalAttrDict(op.getAttrs());
+ p.printOptionalAttrDict(op->getAttrs());
p << " : " << op.getOperand(0).getType() << " to " << op.getType();
}
llvm::StringSet<> traitAttrsSet;
traitAttrsSet.insert(attrNames.begin(), attrNames.end());
SmallVector<NamedAttribute, 8> attrs;
- for (auto attr : op.getAttrs())
+ for (auto attr : op->getAttrs())
if (traitAttrsSet.count(attr.first.strref()) > 0)
attrs.push_back(attr);
if (op.masks().size() == 2)
p << ", " << op.masks();
- p.printOptionalAttrDict(op.getAttrs(), attrNames);
+ p.printOptionalAttrDict(op->getAttrs(), attrNames);
p << " : " << op.lhs().getType() << ", " << op.rhs().getType() << " into "
<< op.getResultType();
}
static void print(OpAsmPrinter &p, vector::ExtractOp op) {
p << op.getOperationName() << " " << op.vector() << op.position();
- p.printOptionalAttrDict(op.getAttrs(), {"position"});
+ p.printOptionalAttrDict(op->getAttrs(), {"position"});
p << " : " << op.vector().getType();
}
static void print(OpAsmPrinter &p, ShuffleOp op) {
p << op.getOperationName() << " " << op.v1() << ", " << op.v2() << " "
<< op.mask();
- p.printOptionalAttrDict(op.getAttrs(), {ShuffleOp::getMaskAttrName()});
+ p.printOptionalAttrDict(op->getAttrs(), {ShuffleOp::getMaskAttrName()});
p << " : " << op.v1().getType() << ", " << op.v2().getType();
}
p << op.getOperationName() << " " << op.lhs() << ", " << op.rhs();
if (!op.acc().empty()) {
p << ", " << op.acc();
- p.printOptionalAttrDict(op.getAttrs());
+ p.printOptionalAttrDict(op->getAttrs());
}
p << " : " << op.lhs().getType() << ", " << op.rhs().getType();
}
}
if (elideMasked)
elidedAttrs.push_back(op.getMaskedAttrName());
- p.printOptionalAttrDict(op.getAttrs(), elidedAttrs);
+ p.printOptionalAttrDict(op->getAttrs(), elidedAttrs);
}
static void print(OpAsmPrinter &p, TransferReadOp op) {
static void print(OpAsmPrinter &p, TupleOp op) {
p << op.getOperationName() << ' ';
p.printOperands(op.getOperands());
- p.printOptionalAttrDict(op.getAttrs());
+ p.printOptionalAttrDict(op->getAttrs());
p << " : ";
llvm::interleaveComma(op->getOperandTypes(), p);
}
static void print(OpAsmPrinter &p, TupleGetOp op) {
p << op.getOperationName() << ' ' << op.getOperand() << ", " << op.index();
- p.printOptionalAttrDict(op.getAttrs(),
+ p.printOptionalAttrDict(op->getAttrs(),
/*elidedAttrs=*/{TupleGetOp::getIndexAttrName()});
p << " : " << op.getOperand().getType();
}
void FuncOp::cloneInto(FuncOp dest, BlockAndValueMapping &mapper) {
// Add the attributes of this function to dest.
llvm::MapVector<Identifier, Attribute> newAttrs;
- for (auto &attr : dest.getAttrs())
+ for (const auto &attr : dest->getAttrs())
newAttrs.insert(attr);
- for (auto &attr : getAttrs())
+ for (const auto &attr : (*this)->getAttrs())
newAttrs.insert(attr);
dest->setAttrs(DictionaryAttr::get(getContext(), newAttrs.takeVector()));
static LogicalResult verify(ModuleOp op) {
// Check that none of the attributes are non-dialect attributes, except for
// the symbol related attributes.
- for (auto attr : op.getAttrs()) {
+ for (auto attr : op->getAttrs()) {
if (!attr.first.strref().contains('.') &&
!llvm::is_contained(
ArrayRef<StringRef>{mlir::SymbolTable::getSymbolAttrName(),