Lines Matching full:op
35 Operation *op =
42 op->setPropertiesFromAttribute(state.propertiesAttr,
44 assert(result.succeeded() && "invalid properties in op creation");
47 return op;
57 Operation *op =
62 op->getRegion(i).takeBody(*regions[i]);
63 return op;
118 Operation *op = ::new (rawMem) Operation(
122 assert((numSuccessors == 0 || op->mightHaveTrait<OpTrait::IsTerminator>()) &&
128 new (op->getInlineOpResult(i)) detail::InlineOpResult(*resultTypeIt, i);
130 new (op->getOutOfLineOpResult(i))
136 new (&op->getRegion(i)) Region(op);
140 new (&op->getOperandStorage()) detail::OperandStorage(
141 op, op->getTrailingObjects<OpOperand>(), operands);
145 auto blockOperands = op->getBlockOperands();
147 new (&blockOperands[i]) BlockOperand(op, successors[i]);
150 op->setAttrs(attributes);
152 return op;
491 void llvm::ilist_traits<::mlir::Operation>::deleteNode(Operation *op) {
492 op->destroy();
503 void llvm::ilist_traits<::mlir::Operation>::addNodeToList(Operation *op) {
504 assert(!op->getBlock() && "already in an operation block!");
505 op->block = getContainingBlock();
508 op->orderIndex = Operation::kInvalidOrderIdx;
513 void llvm::ilist_traits<::mlir::Operation>::removeNodeFromList(Operation *op) {
514 assert(op->block && "not already in an operation block!");
515 op->block = nullptr;
585 for (auto &op : getOpOperands())
586 op.drop();
612 /// the results of the given op.
613 static void checkFoldResultTypes(Operation *op,
618 for (auto [ofr, opResult] : llvm::zip_equal(results, op->getResults())) {
621 op->emitOpError() << "folder produced a value of incorrect type: "
631 /// Attempt to fold this operation using the Op's registered foldHook.
669 /// Emit an error with the op name prefixed, like "'dim' op " which is
672 return emitError() << "'" << getName() << "' op " << message;
771 void OpState::print(Operation *op, OpAsmPrinter &p, StringRef defaultDialect) {
772 if (auto printFn = op->getDialect()->getOperationPrinter(op)) {
773 printOpName(op, p, defaultDialect);
774 printFn(op, p);
776 p.printGenericOp(op);
782 void OpState::printOpName(Operation *op, OpAsmPrinter &p,
784 StringRef name = op->getName().getStringRef();
830 /// Emit an error with the op name prefixed, like "'dim' op " which is
849 // Op Trait implementations
853 OpTrait::impl::foldCommutative(Operation *op, ArrayRef<Attribute> operands,
856 if (op->getNumOperands() < 2)
859 OpOperand *operandsBegin = op->getOpOperands().begin();
863 auto *firstConstantIt = llvm::find_if_not(op->getOpOperands(), isNonConstant);
865 firstConstantIt, op->getOpOperands().end(), isNonConstant);
866 // Return success if the op was modified.
870 OpFoldResult OpTrait::impl::foldIdempotent(Operation *op) {
871 if (op->getNumOperands() == 1) {
872 auto *argumentOp = op->getOperand(0).getDefiningOp();
873 if (argumentOp && op->getName() == argumentOp->getName()) {
875 return op->getOperand(0);
877 } else if (op->getOperand(0) == op->getOperand(1)) {
878 return op->getOperand(0);
884 OpFoldResult OpTrait::impl::foldInvolution(Operation *op) {
885 auto *argumentOp = op->getOperand(0).getDefiningOp();
886 if (argumentOp && op->getName() == argumentOp->getName()) {
894 LogicalResult OpTrait::impl::verifyZeroOperands(Operation *op) {
895 if (op->getNumOperands() != 0)
896 return op->emitOpError() << "requires zero operands";
900 LogicalResult OpTrait::impl::verifyOneOperand(Operation *op) {
901 if (op->getNumOperands() != 1)
902 return op->emitOpError() << "requires a single operand";
906 LogicalResult OpTrait::impl::verifyNOperands(Operation *op,
908 if (op->getNumOperands() != numOperands) {
909 return op->emitOpError() << "expected " << numOperands
910 << " operands, but found " << op->getNumOperands();
915 LogicalResult OpTrait::impl::verifyAtLeastNOperands(Operation *op,
917 if (op->getNumOperands() < numOperands)
918 return op->emitOpError()
920 << op->getNumOperands();
936 LogicalResult OpTrait::impl::verifyIsIdempotent(Operation *op) {
944 LogicalResult OpTrait::impl::verifyIsInvolution(Operation *op) {
953 OpTrait::impl::verifyOperandsAreSignlessIntegerLike(Operation *op) {
954 for (auto opType : op->getOperandTypes()) {
957 return op->emitOpError() << "requires an integer or index type";
962 LogicalResult OpTrait::impl::verifyOperandsAreFloatLike(Operation *op) {
963 for (auto opType : op->getOperandTypes()) {
966 return op->emitOpError("requires a float type");
971 LogicalResult OpTrait::impl::verifySameTypeOperands(Operation *op) {
973 unsigned nOperands = op->getNumOperands();
977 auto type = op->getOperand(0).getType();
978 for (auto opType : llvm::drop_begin(op->getOperandTypes(), 1))
980 return op->emitOpError() << "requires all operands to have the same type";
984 LogicalResult OpTrait::impl::verifyZeroRegions(Operation *op) {
985 if (op->getNumRegions() != 0)
986 return op->emitOpError() << "requires zero regions";
990 LogicalResult OpTrait::impl::verifyOneRegion(Operation *op) {
991 if (op->getNumRegions() != 1)
992 return op->emitOpError() << "requires one region";
996 LogicalResult OpTrait::impl::verifyNRegions(Operation *op,
998 if (op->getNumRegions() != numRegions)
999 return op->emitOpError() << "expected " << numRegions << " regions";
1003 LogicalResult OpTrait::impl::verifyAtLeastNRegions(Operation *op,
1005 if (op->getNumRegions() < numRegions)
1006 return op->emitOpError() << "expected " << numRegions << " or more regions";
1010 LogicalResult OpTrait::impl::verifyZeroResults(Operation *op) {
1011 if (op->getNumResults() != 0)
1012 return op->emitOpError() << "requires zero results";
1016 LogicalResult OpTrait::impl::verifyOneResult(Operation *op) {
1017 if (op->getNumResults() != 1)
1018 return op->emitOpError() << "requires one result";
1022 LogicalResult OpTrait::impl::verifyNResults(Operation *op,
1024 if (op->getNumResults() != numOperands)
1025 return op->emitOpError() << "expected " << numOperands << " results";
1029 LogicalResult OpTrait::impl::verifyAtLeastNResults(Operation *op,
1031 if (op->getNumResults() < numOperands)
1032 return op->emitOpError()
1037 LogicalResult OpTrait::impl::verifySameOperandsShape(Operation *op) {
1038 if (failed(verifyAtLeastNOperands(op, 1)))
1041 if (failed(verifyCompatibleShapes(op->getOperandTypes())))
1042 return op->emitOpError() << "requires the same shape for all operands";
1047 LogicalResult OpTrait::impl::verifySameOperandsAndResultShape(Operation *op) {
1048 if (failed(verifyAtLeastNOperands(op, 1)) ||
1049 failed(verifyAtLeastNResults(op, 1)))
1052 SmallVector<Type, 8> types(op->getOperandTypes());
1053 types.append(llvm::to_vector<4>(op->getResultTypes()));
1056 return op->emitOpError()
1062 LogicalResult OpTrait::impl::verifySameOperandsElementType(Operation *op) {
1063 if (failed(verifyAtLeastNOperands(op, 1)))
1065 auto elementType = getElementTypeOrSelf(op->getOperand(0));
1067 for (auto operand : llvm::drop_begin(op->getOperands(), 1)) {
1069 return op->emitOpError("requires the same element type for all operands");
1076 OpTrait::impl::verifySameOperandsAndResultElementType(Operation *op) {
1077 if (failed(verifyAtLeastNOperands(op, 1)) ||
1078 failed(verifyAtLeastNResults(op, 1)))
1081 auto elementType = getElementTypeOrSelf(op->getResult(0));
1084 for (auto result : llvm::drop_begin(op->getResults(), 1)) {
1086 return op->emitOpError(
1091 for (auto operand : op->getOperands()) {
1093 return op->emitOpError(
1100 LogicalResult OpTrait::impl::verifySameOperandsAndResultType(Operation *op) {
1101 if (failed(verifyAtLeastNOperands(op, 1)) ||
1102 failed(verifyAtLeastNResults(op, 1)))
1105 auto type = op->getResult(0).getType();
1110 for (auto resultType : llvm::drop_begin(op->getResultTypes())) {
1113 return op->emitOpError()
1118 return op->emitOpError()
1121 for (auto opType : op->getOperandTypes()) {
1124 return op->emitOpError()
1129 return op->emitOpError()
1135 LogicalResult OpTrait::impl::verifySameOperandsAndResultRank(Operation *op) {
1136 if (failed(verifyAtLeastNOperands(op, 1)))
1149 llvm::make_filter_range(op->getOperandTypes(), hasRank);
1151 llvm::make_filter_range(op->getResultTypes(), hasRank);
1167 return op->emitOpError("operands don't have matching ranks");
1173 return op->emitOpError("result type has different rank than operands");
1180 LogicalResult OpTrait::impl::verifyIsTerminator(Operation *op) {
1181 Block *block = op->getBlock();
1183 if (!block || &block->back() != op)
1184 return op->emitOpError("must be the last operation in the parent block");
1188 static LogicalResult verifyTerminatorSuccessors(Operation *op) {
1189 auto *parent = op->getParentRegion();
1192 for (Block *succ : op->getSuccessors())
1194 return op->emitError("reference to block defined in another region");
1198 LogicalResult OpTrait::impl::verifyZeroSuccessors(Operation *op) {
1199 if (op->getNumSuccessors() != 0) {
1200 return op->emitOpError("requires 0 successors but found ")
1201 << op->getNumSuccessors();
1206 LogicalResult OpTrait::impl::verifyOneSuccessor(Operation *op) {
1207 if (op->getNumSuccessors() != 1) {
1208 return op->emitOpError("requires 1 successor but found ")
1209 << op->getNumSuccessors();
1211 return verifyTerminatorSuccessors(op);
1213 LogicalResult OpTrait::impl::verifyNSuccessors(Operation *op,
1215 if (op->getNumSuccessors() != numSuccessors) {
1216 return op->emitOpError("requires ")
1218 << op->getNumSuccessors();
1220 return verifyTerminatorSuccessors(op);
1222 LogicalResult OpTrait::impl::verifyAtLeastNSuccessors(Operation *op,
1224 if (op->getNumSuccessors() < numSuccessors) {
1225 return op->emitOpError("requires at least ")
1227 << op->getNumSuccessors();
1229 return verifyTerminatorSuccessors(op);
1232 LogicalResult OpTrait::impl::verifyResultsAreBoolLike(Operation *op) {
1233 for (auto resultType : op->getResultTypes()) {
1237 return op->emitOpError() << "requires a bool result type";
1243 LogicalResult OpTrait::impl::verifyResultsAreFloatLike(Operation *op) {
1244 for (auto resultType : op->getResultTypes())
1246 return op->emitOpError() << "requires a floating point type";
1252 OpTrait::impl::verifyResultsAreSignlessIntegerLike(Operation *op) {
1253 for (auto resultType : op->getResultTypes())
1255 return op->emitOpError() << "requires an integer or index type";
1259 LogicalResult OpTrait::impl::verifyValueSizeAttr(Operation *op,
1263 auto sizeAttr = op->getAttrOfType<DenseI32ArrayAttr>(attrName);
1265 return op->emitOpError("requires dense i32 array attribute '")
1270 return op->emitOpError("'")
1278 return op->emitOpError()
1285 LogicalResult OpTrait::impl::verifyOperandSizeAttr(Operation *op,
1287 return verifyValueSizeAttr(op, attrName, "operand", op->getNumOperands());
1290 LogicalResult OpTrait::impl::verifyResultSizeAttr(Operation *op,
1292 return verifyValueSizeAttr(op, attrName, "result", op->getNumResults());
1295 LogicalResult OpTrait::impl::verifyNoRegionArguments(Operation *op) {
1296 for (Region ®ion : op->getRegions()) {
1301 if (op->getNumRegions() > 1)
1302 return op->emitOpError("region #")
1304 return op->emitOpError("region should have no arguments");
1310 LogicalResult OpTrait::impl::verifyElementwise(Operation *op) {
1313 llvm::filter_to_vector<1>(op->getResultTypes(), isMappableType);
1315 llvm::filter_to_vector<2>(op->getOperandTypes(), isMappableType);
1317 // If the op only has scalar operand/result types, then we have nothing to
1323 return op->emitOpError("if a result is non-scalar, then at least one "
1329 return op->emitOpError("if an operand is non-scalar, then there must be at "
1332 if (resultMappableTypes.size() != op->getNumResults())
1333 return op->emitOpError(
1342 return op->emitOpError() << "all non-scalar operands/results must have the "
1364 for (Operation &op : pendingRegions.pop_back_val()->getOps()) {
1365 for (Value operand : op.getOperands()) {
1370 return op.emitError("operation's operand is unlinked");
1372 return op.emitOpError("using value defined outside the region")
1381 if (op.getNumRegions() &&
1382 !op.hasTrait<OpTrait::IsIsolatedFromAbove>()) {
1383 for (Region &subRegion : op.getRegions())
1393 bool OpTrait::hasElementwiseMappableTraits(Operation *op) {
1394 return op->hasTrait<Elementwise>() && op->hasTrait<Scalarizable>() &&
1395 op->hasTrait<Vectorizable>() && op->hasTrait<Tensorizable>();