21 #include "llvm/ADT/SmallVector.h"
22 #include "llvm/Support/ErrorHandling.h"
35 create(state.location, state.name, state.types, state.operands,
36 state.attributes.getDictionary(state.getContext()),
37 state.properties, state.successors, state.regions);
38 if (LLVM_UNLIKELY(state.propertiesAttr)) {
39 assert(!state.properties);
40 LogicalResult result =
43 assert(result.succeeded() &&
"invalid properties in op creation");
55 unsigned numRegions = regions.size();
57 create(location, name, resultTypes, operands, std::move(attributes),
58 properties, successors, numRegions);
59 for (
unsigned i = 0; i < numRegions; ++i)
70 unsigned numRegions) {
74 return create(location, name, resultTypes, operands,
75 attributes.getDictionary(location.
getContext()), properties,
76 successors, numRegions);
83 DictionaryAttr attributes,
85 unsigned numRegions) {
86 assert(llvm::all_of(resultTypes, [](
Type t) {
return t; }) &&
87 "unexpected null result type");
90 unsigned numTrailingResults = OpResult::getNumTrailing(resultTypes.size());
91 unsigned numInlineResults = OpResult::getNumInline(resultTypes.size());
92 unsigned numSuccessors = successors.size();
93 unsigned numOperands = operands.size();
94 unsigned numResults = resultTypes.size();
99 bool needsOperandStorage =
108 needsOperandStorage ? 1 : 0, opPropertiesAllocSize, numSuccessors,
109 numRegions, numOperands);
110 size_t prefixByteSize = llvm::alignTo(
111 Operation::prefixAllocSize(numTrailingResults, numInlineResults),
113 char *mallocMem =
reinterpret_cast<char *
>(malloc(byteSize + prefixByteSize));
114 void *rawMem = mallocMem + prefixByteSize;
118 location, name, numResults, numSuccessors, numRegions,
119 opPropertiesAllocSize, attributes, properties, needsOperandStorage);
122 "unexpected successors in a non-terminator operation");
125 auto resultTypeIt = resultTypes.begin();
126 for (
unsigned i = 0; i < numInlineResults; ++i, ++resultTypeIt)
128 for (
unsigned i = 0; i < numTrailingResults; ++i, ++resultTypeIt) {
129 new (op->getOutOfLineOpResult(i))
134 for (
unsigned i = 0; i != numRegions; ++i)
138 if (needsOperandStorage) {
140 op, op->getTrailingObjects<
OpOperand>(), operands);
145 for (
unsigned i = 0; i != numSuccessors; ++i)
146 new (&blockOperands[i])
BlockOperand(op, successors[i]);
155 unsigned numSuccessors,
unsigned numRegions,
156 int fullPropertiesStorageSize, DictionaryAttr attributes,
158 : location(location), numResults(numResults), numSuccs(numSuccessors),
159 numRegions(numRegions), hasOperandStorage(hasOperandStorage),
160 propertiesStorageSize((fullPropertiesStorageSize + 7) / 8), name(name) {
161 assert(attributes &&
"unexpected null attribute dictionary");
162 assert(fullPropertiesStorageSize <= propertiesCapacity &&
163 "Properties size overflow");
166 llvm::report_fatal_error(
168 " created with unregistered dialect. If this is intended, please call "
169 "allowUnregisteredDialects() on the MLIRContext, or use "
170 "-allow-unregistered-dialect with the MLIR tool used.");
172 if (fullPropertiesStorageSize)
178 Operation::~Operation() {
179 assert(block ==
nullptr &&
"operation destroyed but still in a block");
184 emitOpError(
"operation destroyed but still has uses");
186 diag.attachNote(user->getLoc()) <<
"- use: " << *user <<
"\n";
188 llvm::report_fatal_error(
"operation destroyed but still has uses");
192 if (hasOperandStorage)
197 successor.~BlockOperand();
202 if (propertiesStorageSize)
210 char *rawMem =
reinterpret_cast<char *
>(
this) -
211 llvm::alignTo(prefixAllocSize(),
alignof(
Operation));
230 if (operand.get() == from)
237 if (LLVM_LIKELY(hasOperandStorage))
238 return getOperandStorage().
setOperands(
this, operands);
239 assert(operands.empty() &&
"setting operands without an operand storage");
248 "invalid operand range specified");
249 if (LLVM_LIKELY(hasOperandStorage))
250 return getOperandStorage().
setOperands(
this, start, length, operands);
251 assert(operands.empty() &&
"setting operands without an operand storage");
256 if (LLVM_LIKELY(hasOperandStorage))
258 assert(operands.empty() &&
"inserting operands without an operand storage");
269 if (
getContext()->shouldPrintOpOnDiagnostic()) {
271 .append(
"see current operation: ")
281 if (
getContext()->shouldPrintOpOnDiagnostic())
282 diag.attachNote(
getLoc()) <<
"see current operation: " << *
this;
290 if (
getContext()->shouldPrintOpOnDiagnostic())
291 diag.attachNote(
getLoc()) <<
"see current operation: " << *
this;
305 assert(newAttrs &&
"expected valid attribute dictionary");
310 discardableAttrs.reserve(newAttrs.size());
315 discardableAttrs.push_back(attr);
317 if (discardableAttrs.size() != newAttrs.size())
327 discardableAttrs.reserve(newAttrs.size());
332 discardableAttrs.push_back(attr);
350 if (LLVM_UNLIKELY(!info))
352 return info->getOpPropertiesAsAttribute(
this);
357 if (LLVM_UNLIKELY(!info)) {
361 return info->setOpPropertiesFromAttribute(
377 constexpr
unsigned Operation::kInvalidOrderIdx;
378 constexpr
unsigned Operation::kOrderStride;
386 assert(block &&
"Operations without parent blocks have no order.");
387 assert(other && other->block == block &&
388 "Expected other operation to have the same parent block.");
395 updateOrderIfNecessary();
396 other->updateOrderIfNecessary();
399 return orderIndex < other->orderIndex;
404 void Operation::updateOrderIfNecessary() {
405 assert(block &&
"expected valid parent");
408 if (hasValidOrder() || llvm::hasSingleElement(*block))
415 assert(blockFront != blockBack &&
"expected more than one operation");
418 if (
this == blockBack) {
420 if (!prevNode->hasValidOrder())
424 orderIndex = prevNode->orderIndex + kOrderStride;
430 if (
this == blockFront) {
432 if (!nextNode->hasValidOrder())
435 if (nextNode->orderIndex == 0)
440 if (nextNode->orderIndex <= kOrderStride)
441 orderIndex = (nextNode->orderIndex / 2);
443 orderIndex = kOrderStride;
449 Operation *prevNode = getPrevNode(), *nextNode = getNextNode();
450 if (!prevNode->hasValidOrder() || !nextNode->hasValidOrder())
452 unsigned prevOrder = prevNode->orderIndex, nextOrder = nextNode->orderIndex;
455 if (prevOrder + 1 == nextOrder)
457 orderIndex = prevOrder + ((nextOrder - prevOrder) / 2);
464 auto llvm::ilist_detail::SpecificNodeAccess<
465 typename llvm::ilist_detail::compute_node_options<
467 return NodeAccess::getNodePtr<OptionsT>(n);
470 auto llvm::ilist_detail::SpecificNodeAccess<
471 typename llvm::ilist_detail::compute_node_options<
473 ->
const node_type * {
474 return NodeAccess::getNodePtr<OptionsT>(n);
477 auto llvm::ilist_detail::SpecificNodeAccess<
478 typename llvm::ilist_detail::compute_node_options<
480 return NodeAccess::getValuePtr<OptionsT>(n);
483 auto llvm::ilist_detail::SpecificNodeAccess<
484 typename llvm::ilist_detail::compute_node_options<
487 return NodeAccess::getValuePtr<OptionsT>(n);
494 Block *llvm::ilist_traits<::mlir::Operation>::getContainingBlock() {
496 iplist<Operation> *anchor(
static_cast<iplist<Operation> *
>(
this));
497 return reinterpret_cast<Block *
>(
reinterpret_cast<char *
>(anchor) - offset);
503 assert(!op->
getBlock() &&
"already in an operation block!");
504 op->block = getContainingBlock();
507 op->orderIndex = Operation::kInvalidOrderIdx;
513 assert(op->block &&
"not already in an operation block!");
521 Block *curParent = getContainingBlock();
528 if (curParent == otherList.getContainingBlock())
532 for (; first != last; ++first)
533 first->block = curParent;
540 parent->getOperations().erase(
this);
548 parent->getOperations().remove(
this);
561 llvm::iplist<Operation>::iterator iterator) {
563 "cannot move an operation that isn't contained in a block");
577 llvm::iplist<Operation>::iterator iterator) {
578 assert(iterator != block->
end() &&
"cannot move after end of block");
590 region.dropAllReferences();
602 for (
auto &block : region)
619 for (
auto [ofr, opResult] : llvm::zip_equal(results, op->
getResults())) {
620 if (
auto value = dyn_cast<Value>(ofr)) {
621 if (value.getType() != opResult.getType()) {
622 op->
emitOpError() <<
"folder produced a value of incorrect type: "
624 <<
", expected: " << opResult.getType();
625 assert(
false &&
"incorrect fold result type");
637 if (succeeded(name.
foldHook(
this, operands, results))) {
653 LogicalResult status = interface->fold(
this, operands, results);
655 if (succeeded(status))
667 return fold(constants, results);
681 : cloneRegionsFlag(false), cloneOperandsFlag(false) {}
684 : cloneRegionsFlag(cloneRegions), cloneOperandsFlag(cloneOperands) {}
691 cloneRegionsFlag = enable;
696 cloneOperandsFlag = enable;
723 if (
options.shouldCloneOperands()) {
737 mapper.
map(
this, newOp);
740 if (
options.shouldCloneRegions()) {
741 for (
unsigned i = 0; i != numRegions; ++i)
766 return (*parseFn)(parser, result);
774 printOpName(op, p, defaultDialect);
784 StringRef defaultDialect) {
786 if (name.starts_with((defaultDialect +
".").str()) && name.count(
'.') == 1)
787 name = name.drop_front(defaultDialect.size() + 1);
807 auto dictAttr = dyn_cast_or_null<::mlir::DictionaryAttr>(properties);
808 if (dictAttr && !elidedProps.empty()) {
810 llvm::SmallDenseSet<StringRef> elidedAttrsSet(elidedProps.begin(),
814 return !elidedAttrsSet.contains(attr.
getName().strref());
816 if (!filteredAttrs.empty()) {
824 p <<
"<" << properties <<
">";
831 return getOperation()->emitError(message);
837 return getOperation()->emitOpError(message);
843 return getOperation()->emitWarning(message);
849 return getOperation()->emitRemark(message);
865 return !
static_cast<bool>(operands[std::distance(operandsBegin, &o)]);
867 auto *firstConstantIt = llvm::find_if_not(op->
getOpOperands(), isNonConstant);
868 auto *newConstantIt = std::stable_partition(
871 return success(firstConstantIt != newConstantIt);
877 if (argumentOp && op->
getName() == argumentOp->getName()) {
890 if (argumentOp && op->
getName() == argumentOp->getName()) {
900 return op->
emitOpError() <<
"requires zero operands";
906 return op->
emitOpError() <<
"requires a single operand";
911 unsigned numOperands) {
913 return op->
emitOpError() <<
"expected " << numOperands
920 unsigned numOperands) {
923 <<
"expected " << numOperands <<
" or more operands, but found "
931 if (
auto vec = llvm::dyn_cast<VectorType>(type))
932 return vec.getElementType();
935 if (
auto tensor = llvm::dyn_cast<TensorType>(type))
960 if (!type.isSignlessIntOrIndex())
961 return op->
emitOpError() <<
"requires an integer or index type";
969 if (!llvm::isa<FloatType>(type))
984 return op->
emitOpError() <<
"requires all operands to have the same type";
990 return op->
emitOpError() <<
"requires zero regions";
1001 unsigned numRegions) {
1003 return op->
emitOpError() <<
"expected " << numRegions <<
" regions";
1008 unsigned numRegions) {
1010 return op->
emitOpError() <<
"expected " << numRegions <<
" or more regions";
1016 return op->
emitOpError() <<
"requires zero results";
1022 return op->
emitOpError() <<
"requires one result";
1027 unsigned numOperands) {
1029 return op->
emitOpError() <<
"expected " << numOperands <<
" results";
1034 unsigned numOperands) {
1037 <<
"expected " << numOperands <<
" or more results";
1046 return op->
emitOpError() <<
"requires the same shape for all operands";
1061 <<
"requires the same shape for all operands and results";
1071 for (
auto operand : llvm::drop_begin(op->
getOperands(), 1)) {
1073 return op->
emitOpError(
"requires the same element type for all operands");
1088 for (
auto result : llvm::drop_begin(op->
getResults(), 1)) {
1091 "requires the same element type for all operands and results");
1098 "requires the same element type for all operands and results");
1112 if (
auto rankedType = dyn_cast<RankedTensorType>(type))
1113 encoding = rankedType.getEncoding();
1118 <<
"requires the same type for all operands and results";
1120 if (
auto rankedType = dyn_cast<RankedTensorType>(resultType);
1121 encoding != rankedType.getEncoding())
1123 <<
"requires the same encoding for all operands and results";
1129 <<
"requires the same type for all operands and results";
1131 if (
auto rankedType = dyn_cast<RankedTensorType>(opType);
1132 encoding != rankedType.getEncoding())
1134 <<
"requires the same encoding for all operands and results";
1145 auto hasRank = [](
const Type type) {
1146 if (
auto shapedType = dyn_cast<ShapedType>(type))
1147 return shapedType.hasRank();
1152 auto rankedOperandTypes =
1154 auto rankedResultTypes =
1158 if (rankedOperandTypes.empty() && rankedResultTypes.empty())
1162 auto getRank = [](
const Type type) {
1163 return cast<ShapedType>(type).getRank();
1166 auto rank = !rankedOperandTypes.empty() ? getRank(*rankedOperandTypes.begin())
1167 : getRank(*rankedResultTypes.begin());
1169 for (
const auto type : rankedOperandTypes) {
1170 if (rank != getRank(type)) {
1171 return op->
emitOpError(
"operands don't have matching ranks");
1175 for (
const auto type : rankedResultTypes) {
1176 if (rank != getRank(type)) {
1177 return op->
emitOpError(
"result type has different rank than operands");
1187 if (!block || &block->
back() != op)
1188 return op->
emitOpError(
"must be the last operation in the parent block");
1197 if (succ->getParent() != parent)
1198 return op->
emitError(
"reference to block defined in another region");
1204 return op->
emitOpError(
"requires 0 successors but found ")
1212 return op->
emitOpError(
"requires 1 successor but found ")
1218 unsigned numSuccessors) {
1221 << numSuccessors <<
" successors but found "
1227 unsigned numSuccessors) {
1230 << numSuccessors <<
" successors but found "
1239 bool isBoolType = elementType.isInteger(1);
1241 return op->
emitOpError() <<
"requires a bool result type";
1250 return op->
emitOpError() <<
"requires a floating point type";
1259 return op->
emitOpError() <<
"requires an integer or index type";
1265 StringRef valueGroupName,
1266 size_t expectedCount) {
1269 return op->
emitOpError(
"requires dense i32 array attribute '")
1273 if (llvm::any_of(sizes, [](int32_t element) {
return element < 0; }))
1275 << attrName <<
"' attribute cannot have negative elements";
1278 std::accumulate(sizes.begin(), sizes.end(), 0,
1279 [](
unsigned all, int32_t one) { return all + one; });
1281 if (totalCount != expectedCount)
1283 << valueGroupName <<
" count (" << expectedCount
1284 <<
") does not match with the total size (" << totalCount
1285 <<
") specified in attribute '" << attrName <<
"'";
1290 StringRef attrName) {
1295 StringRef attrName) {
1304 if (region.getNumArguments() != 0) {
1307 << region.getRegionNumber() <<
" should have no arguments";
1308 return op->
emitOpError(
"region should have no arguments");
1316 auto resultMappableTypes =
1318 auto operandMappableTypes =
1323 if (resultMappableTypes.empty() && operandMappableTypes.empty())
1326 if (!resultMappableTypes.empty() && operandMappableTypes.empty())
1327 return op->
emitOpError(
"if a result is non-scalar, then at least one "
1328 "operand must be non-scalar");
1330 assert(!operandMappableTypes.empty());
1332 if (resultMappableTypes.empty())
1333 return op->
emitOpError(
"if an operand is non-scalar, then there must be at "
1334 "least one non-scalar result");
1338 "if an operand is non-scalar, then all results must be non-scalar");
1341 llvm::concat<Type>(operandMappableTypes, resultMappableTypes));
1342 TypeID expectedBaseTy = types.front().getTypeID();
1343 if (!llvm::all_of(types,
1346 return op->
emitOpError() <<
"all non-scalar operands/results must have the "
1347 "same shape and base type";
1357 "Intended to check IsolatedFromAbove ops");
1363 for (
auto ®ion : isolatedOp->
getRegions()) {
1364 pendingRegions.push_back(®ion);
1367 while (!pendingRegions.empty()) {
1368 for (
Operation &op : pendingRegions.pop_back_val()->getOps()) {
1369 for (
Value operand : op.getOperands()) {
1372 auto *operandRegion = operand.getParentRegion();
1374 return op.emitError(
"operation's operand is unlinked");
1375 if (!region.isAncestor(operandRegion)) {
1376 return op.emitOpError(
"using value defined outside the region")
1377 .attachNote(isolatedOp->
getLoc())
1378 <<
"required by region isolation constraints";
1385 if (op.getNumRegions() &&
1387 for (
Region &subRegion : op.getRegions())
1388 pendingRegions.push_back(&subRegion);
1422 builder.
insert(buildTerminatorOp(builder, loc));
static LogicalResult verifyTerminatorSuccessors(Operation *op)
static Type getTensorOrVectorElementType(Type type)
If this is a vector type, or a tensor type, return the scalar element type that it is built around,...
static void checkFoldResultTypes(Operation *op, SmallVectorImpl< OpFoldResult > &results)
Assert that the folded results (in case of values) have the same type as the results of the given op.
static std::string diag(const llvm::Value &value)
static llvm::ManagedStatic< PassManagerOptions > options
virtual InFlightDiagnostic emitError(SMLoc loc, const Twine &message={})=0
Emit a diagnostic at the specified location and return failure.
virtual SMLoc getNameLoc() const =0
Return the location of the original name token.
virtual ParseResult parseOptionalLess()=0
Parse a '<' token if present.
virtual ParseResult parseGreater()=0
Parse a '>' token.
virtual ParseResult parseAttribute(Attribute &result, Type type={})=0
Parse an arbitrary attribute of a given type and return it in result.
virtual raw_ostream & getStream() const
Return the raw output stream used by this printer.
virtual void printNamedAttribute(NamedAttribute attr)
Print the given named attribute.
Attributes are known-constant values of operations.
A block operand represents an operand that holds a reference to a Block, e.g.
This class provides an abstraction over the different types of ranges over Blocks.
Block represents an ordered list of Operations.
void recomputeOpOrder()
Recomputes the ordering of child operations within the block.
bool isOpOrderValid()
Returns true if the ordering of the child operations is valid, false otherwise.
void dropAllDefinedValueUses()
This drops all uses of values defined in this block or in the blocks of nested regions wherever the u...
void invalidateOpOrder()
Invalidates the current ordering of operations.
OpListType & getOperations()
static OpListType Block::* getSublistAccess(Operation *)
Returns pointer to member of operation list.
This class is a general helper class for creating context-global objects like types,...
MLIRContext * getContext() const
Define a fold interface to allow for dialects to control specific aspects of the folding behavior for...
Dialects are groups of MLIR operations, types and attributes, as well as behavior associated with the...
virtual std::optional< ParseOpHook > getParseOperationHook(StringRef opName) const
Return the hook to parse an operation registered to this dialect, if any.
virtual llvm::unique_function< void(Operation *, OpAsmPrinter &printer)> getOperationPrinter(Operation *op) const
Print an operation registered to this dialect.
This is a utility class for mapping one set of IR entities to another.
auto lookupOrDefault(T from) const
Lookup a mapped value within the map.
void map(Value from, Value to)
Inserts a new mapping for 'from' to 'to'.
This class represents a diagnostic that is inflight and set to be reported.
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
MLIRContext * getContext() const
Return the context this location is uniqued in.
NamedAttrList is array of NamedAttributes that tracks whether it is sorted and does some basic work t...
DictionaryAttr getDictionary(MLIRContext *context) const
Return a dictionary attribute for the underlying dictionary.
NamedAttribute represents a combination of a name and an Attribute value.
StringAttr getName() const
Return the name of the attribute.
The OpAsmParser has methods for interacting with the asm parser: parsing things from it,...
This is a pure-virtual base class that exposes the asmprinter hooks necessary to implement a custom p...
virtual void printGenericOp(Operation *op, bool printOpName=true)=0
Print the entire operation with the default generic assembly form.
RAII guard to reset the insertion point of the builder when destroyed.
This class helps build Operations.
Block * createBlock(Region *parent, Region::iterator insertPt={}, TypeRange argTypes={}, ArrayRef< Location > locs={})
Add new block with 'argTypes' arguments and set the insertion point to the end of it.
void setInsertionPointToEnd(Block *block)
Sets the insertion point to the end of the specified block.
Operation * insert(Operation *op)
Insert the given operation at the current insertion point and return it.
This class represents a single result from folding an operation.
This class represents an operand of an operation.
Set of flags used to control the behavior of the various IR print methods (e.g.
static void genericPrintProperties(OpAsmPrinter &p, Attribute properties, ArrayRef< StringRef > elidedProps={})
Print the properties as a Attribute with names not included within 'elidedProps'.
static void printOpName(Operation *op, OpAsmPrinter &p, StringRef defaultDialect)
Print an operation name, eliding the dialect prefix if necessary.
InFlightDiagnostic emitError(const Twine &message={})
Emit an error about fatal conditions with this operation, reporting up to any diagnostic handlers tha...
InFlightDiagnostic emitOpError(const Twine &message={})
Emit an error with the op name prefixed, like "'dim' op " which is convenient for verifiers.
InFlightDiagnostic emitWarning(const Twine &message={})
Emit a warning about this operation, reporting up to any diagnostic handlers that may be listening.
static ParseResult genericParseProperties(OpAsmParser &parser, Attribute &result)
Parse properties as a Attribute.
static ParseResult parse(OpAsmParser &parser, OperationState &result)
Parse the custom form of an operation.
InFlightDiagnostic emitRemark(const Twine &message={})
Emit a remark about this operation, reporting up to any diagnostic handlers that may be listening.
void print(raw_ostream &os, OpPrintingFlags flags=std::nullopt)
Print the operation to the given stream.
This class provides the API for ops that are known to be isolated from above.
This class provides the API for ops that are known to be terminators.
This class provides the API for ops that are known to have no SSA operand.
Simple wrapper around a void* in order to express generically how to pass in op properties through AP...
void populateInherentAttrs(Operation *op, NamedAttrList &attrs) const
StringRef getStringRef() const
Return the name of this operation. This always succeeds.
void setInherentAttr(Operation *op, StringAttr name, Attribute value) const
bool hasTrait() const
Returns true if the operation was registered with a particular trait, e.g.
std::optional< Attribute > getInherentAttr(Operation *op, StringRef name) const
Lookup an inherent attribute by name, this method isn't recommended and may be removed in the future.
Dialect * getDialect() const
Return the dialect this operation is registered to if the dialect is loaded in the context,...
void initOpProperties(OpaqueProperties storage, OpaqueProperties init) const
Initialize the op properties.
llvm::hash_code hashOpProperties(OpaqueProperties properties) const
LogicalResult foldHook(Operation *op, ArrayRef< Attribute > operands, SmallVectorImpl< OpFoldResult > &results) const
This hook implements a generalized folder for this operation.
void populateDefaultAttrs(NamedAttrList &attrs) const
This hook implements the method to populate defaults attributes that are unset.
void destroyOpProperties(OpaqueProperties properties) const
This hooks destroy the op properties.
int getOpPropertyByteSize() const
This hooks return the number of bytes to allocate for the op properties.
void copyOpProperties(OpaqueProperties lhs, OpaqueProperties rhs) const
Class encompassing various options related to cloning an operation.
CloneOptions()
Default constructs an option with all flags set to false.
static CloneOptions all()
Returns an instance with all flags set to true.
CloneOptions & cloneRegions(bool enable=true)
Configures whether cloning should traverse into any of the regions of the operation.
CloneOptions & cloneOperands(bool enable=true)
Configures whether operation' operands should be cloned.
Operation is the basic unit of execution within MLIR.
void setInherentAttr(StringAttr name, Attribute value)
Set an inherent attribute by name.
void replaceUsesOfWith(Value from, Value to)
Replace any uses of 'from' with 'to' within this operation.
DictionaryAttr getAttrDictionary()
Return all of the attributes on this operation as a DictionaryAttr.
LogicalResult fold(ArrayRef< Attribute > operands, SmallVectorImpl< OpFoldResult > &results)
Attempt to fold this operation with the specified constant operand values.
bool use_empty()
Returns true if this operation has no uses.
Value getOperand(unsigned idx)
bool hasTrait()
Returns true if the operation was registered with a particular trait, e.g.
Operation * cloneWithoutRegions()
Create a partial copy of this operation without traversing into attached regions.
Dialect * getDialect()
Return the dialect this operation is associated with, or nullptr if the associated dialect is not loa...
void insertOperands(unsigned index, ValueRange operands)
Insert the given operands into the operand list at the given 'index'.
void dropAllUses()
Drop all uses of results of this operation.
AttrClass getAttrOfType(StringAttr name)
void setAttrs(DictionaryAttr newAttrs)
Set the attributes from a dictionary on this operation.
unsigned getNumSuccessors()
bool isBeforeInBlock(Operation *other)
Given an operation 'other' that is within the same parent block, return whether the current operation...
void dropAllReferences()
This drops all operand uses from this operation, which is an essential step in breaking cyclic depend...
InFlightDiagnostic emitWarning(const Twine &message={})
Emit a warning about this operation, reporting up to any diagnostic handlers that may be listening.
Operation * clone(IRMapping &mapper, CloneOptions options=CloneOptions::all())
Create a deep copy of this operation, remapping any operands that use values outside of the operation...
bool mightHaveTrait()
Returns true if the operation might have the provided trait.
OpResult getResult(unsigned idx)
Get the 'idx'th result of this operation.
std::optional< Attribute > getInherentAttr(StringRef name)
Access an inherent attribute by name: returns an empty optional if there is no inherent attribute wit...
MLIRContext * getContext()
Return the context this operation is associated with.
unsigned getNumRegions()
Returns the number of regions held by this operation.
std::optional< RegisteredOperationName > getRegisteredInfo()
If this operation has a registered operation description, return it.
Location getLoc()
The source location the operation was defined or derived from.
void dropAllDefinedValueUses()
Drop uses of all values defined by this operation or its nested regions.
unsigned getNumOperands()
static Operation * create(Location location, OperationName name, TypeRange resultTypes, ValueRange operands, NamedAttrList &&attributes, OpaqueProperties properties, BlockRange successors, unsigned numRegions)
Create a new Operation with the specific fields.
Attribute getPropertiesAsAttribute()
Return the properties converted to an attribute.
Operation * getParentOp()
Returns the closest surrounding operation that contains this operation or nullptr if this is a top-le...
InFlightDiagnostic emitError(const Twine &message={})
Emit an error about fatal conditions with this operation, reporting up to any diagnostic handlers tha...
Block * getBlock()
Returns the operation block that contains this operation.
Region & getRegion(unsigned index)
Returns the region held by this operation at position 'index'.
MutableArrayRef< Region > getRegions()
Returns the regions held by this operation.
void destroy()
Destroys this operation and its subclass data.
OperationName getName()
The name of an operation is the key identifier for it.
void remove()
Remove the operation from its parent block, but don't delete it.
LogicalResult setPropertiesFromAttribute(Attribute attr, function_ref< InFlightDiagnostic()> emitError)
Set the properties from the provided attribute.
MutableArrayRef< BlockOperand > getBlockOperands()
operand_type_range getOperandTypes()
MutableArrayRef< OpOperand > getOpOperands()
result_type_range getResultTypes()
operand_range getOperands()
Returns an iterator on the underlying Value's.
void setSuccessor(Block *block, unsigned index)
void moveBefore(Operation *existingOp)
Unlink this operation from its current block and insert it right before existingOp which may be in th...
void setOperands(ValueRange operands)
Replace the current operands of this operation with the ones provided in 'operands'.
user_range getUsers()
Returns a range of all users.
SuccessorRange getSuccessors()
Region * getParentRegion()
Returns the region to which the instruction belongs.
result_range getResults()
int getPropertiesStorageSize() const
Returns the properties storage size.
bool isProperAncestor(Operation *other)
Return true if this operation is a proper ancestor of the other operation.
InFlightDiagnostic emitRemark(const Twine &message={})
Emit a remark about this operation, reporting up to any diagnostic handlers that may be listening.
void moveAfter(Operation *existingOp)
Unlink this operation from its current block and insert it right after existingOp which may be in the...
llvm::hash_code hashProperties()
Compute a hash for the op properties (if any).
InFlightDiagnostic emitOpError(const Twine &message={})
Emit an error with the op name prefixed, like "'dim' op " which is convenient for verifiers.
OpaqueProperties getPropertiesStorage()
Returns the properties storage.
void erase()
Remove this operation from its parent block and delete it.
void copyProperties(OpaqueProperties rhs)
Copy properties from an existing other properties object.
unsigned getNumResults()
Return the number of results held by this operation.
This class provides an abstraction over the different types of ranges over Regions.
This class contains a list of basic blocks and a link to the parent operation it is attached to.
void cloneInto(Region *dest, IRMapping &mapper)
Clone the internal blocks from this region into dest.
void takeBody(Region &other)
Takes body of another region (that region will have no body after this operation completes).
This class provides an efficient unique identifier for a specific C++ type.
This class provides an abstraction over the various different ranges of value types.
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
TypeID getTypeID()
Return a unique identifier for the concrete type.
This class provides an abstraction over the different types of ranges over Values.
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
Type getType() const
Return the type of this value.
Operation * getDefiningOp() const
If this value is the result of an operation, return the operation that defines it.
This class handles the management of operation operands.
void setOperands(Operation *owner, ValueRange values)
Replace the operands contained in the storage with the ones provided in 'values'.
This class provides the implementation for an operation result whose index cannot be represented "inl...
OpFoldResult foldIdempotent(Operation *op)
LogicalResult verifyResultsAreFloatLike(Operation *op)
LogicalResult verifyAtLeastNResults(Operation *op, unsigned numOperands)
LogicalResult verifyIsIdempotent(Operation *op)
LogicalResult verifyOperandsAreSignlessIntegerLike(Operation *op)
LogicalResult verifyNOperands(Operation *op, unsigned numOperands)
LogicalResult verifyNoRegionArguments(Operation *op)
LogicalResult verifyResultsAreSignlessIntegerLike(Operation *op)
LogicalResult verifyIsInvolution(Operation *op)
LogicalResult verifyOperandsAreFloatLike(Operation *op)
LogicalResult foldCommutative(Operation *op, ArrayRef< Attribute > operands, SmallVectorImpl< OpFoldResult > &results)
LogicalResult verifyZeroRegions(Operation *op)
LogicalResult verifyNSuccessors(Operation *op, unsigned numSuccessors)
LogicalResult verifyOperandSizeAttr(Operation *op, StringRef sizeAttrName)
LogicalResult verifyAtLeastNRegions(Operation *op, unsigned numRegions)
LogicalResult verifyValueSizeAttr(Operation *op, StringRef attrName, StringRef valueGroupName, size_t expectedCount)
LogicalResult verifyZeroResults(Operation *op)
LogicalResult verifySameOperandsAndResultType(Operation *op)
LogicalResult verifySameOperandsShape(Operation *op)
LogicalResult verifyAtLeastNSuccessors(Operation *op, unsigned numSuccessors)
LogicalResult verifyIsTerminator(Operation *op)
LogicalResult verifyAtLeastNOperands(Operation *op, unsigned numOperands)
LogicalResult verifyZeroOperands(Operation *op)
LogicalResult verifyElementwise(Operation *op)
LogicalResult verifyOneRegion(Operation *op)
LogicalResult verifySameOperandsAndResultRank(Operation *op)
LogicalResult verifyOneOperand(Operation *op)
LogicalResult verifyIsIsolatedFromAbove(Operation *op)
Check for any values used by operations regions attached to the specified "IsIsolatedFromAbove" opera...
LogicalResult verifyZeroSuccessors(Operation *op)
LogicalResult verifySameOperandsElementType(Operation *op)
LogicalResult verifyOneSuccessor(Operation *op)
LogicalResult verifySameOperandsAndResultElementType(Operation *op)
OpFoldResult foldInvolution(Operation *op)
LogicalResult verifyResultsAreBoolLike(Operation *op)
LogicalResult verifyNResults(Operation *op, unsigned numOperands)
LogicalResult verifyResultSizeAttr(Operation *op, StringRef sizeAttrName)
LogicalResult verifyNRegions(Operation *op, unsigned numRegions)
LogicalResult verifyOneResult(Operation *op)
LogicalResult verifySameTypeOperands(Operation *op)
LogicalResult verifySameOperandsAndResultShape(Operation *op)
bool hasElementwiseMappableTraits(Operation *op)
Together, Elementwise, Scalarizable, Vectorizable, and Tensorizable provide an easy way for scalar op...
bool isMappableType(mlir::Type type)
Used to check whether the provided type implements the MappableType interface.
OpProperties
This is a "tag" used for mapping the properties storage in llvm::TrailingObjects.
void ensureRegionTerminator(Region ®ion, OpBuilder &builder, Location loc, function_ref< Operation *(OpBuilder &, Location)> buildTerminatorOp)
Insert an operation, generated by buildTerminatorOp, at the end of the region's only block if it does...
Include the generated interface declarations.
bool matchPattern(Value value, const Pattern &pattern)
Entry point for matching a pattern over a Value.
InFlightDiagnostic emitWarning(Location loc)
Utility method to emit a warning message using this location.
LogicalResult verifyCompatibleShapes(TypeRange types1, TypeRange types2)
Returns success if the given two arrays have the same number of elements and each pair wise entries h...
InFlightDiagnostic emitError(Location loc)
Utility method to emit an error message using this location.
Type getElementTypeOrSelf(Type type)
Return the element type or return the type itself.
InFlightDiagnostic emitRemark(Location loc)
Utility method to emit a remark message using this location.
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
LogicalResult verifyCompatibleShape(ArrayRef< int64_t > shape1, ArrayRef< int64_t > shape2)
Returns success if the given two shapes are compatible.
detail::constant_op_matcher m_Constant()
Matches a constant foldable operation.
void removeNodeFromList(Operation *op)
This is a trait method invoked when an operation is removed from a block.
void transferNodesFromList(ilist_traits< Operation > &otherList, op_iterator first, op_iterator last)
This is a trait method invoked when an operation is moved from one block to another.
void addNodeToList(Operation *op)
This is a trait method invoked when an operation is added to a block.
static void deleteNode(Operation *op)
simple_ilist< Operation >::iterator op_iterator
This trait tags element-wise ops on vectors or tensors.
This trait tags Elementwise operatons that can be systematically scalarized.
This trait tags Elementwise operatons that can be systematically tensorized.
This trait tags Elementwise operatons that can be systematically vectorized.
This represents an operation in an abstracted form, suitable for use with the builder APIs.
This class provides the implementation for an operation result whose index can be represented "inline...