21 #include "llvm/ADT/SmallVector.h"
22 #include "llvm/ADT/StringExtras.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);
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");
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) {
575 llvm::iplist<Operation>::iterator iterator) {
576 assert(iterator != block->
end() &&
"cannot move after end of block");
600 for (
auto &block : region)
626 return interface->fold(
this, operands, results);
635 return fold(constants, results);
649 : cloneRegionsFlag(false), cloneOperandsFlag(false) {}
652 : cloneRegionsFlag(cloneRegions), cloneOperandsFlag(cloneOperands) {}
659 cloneRegionsFlag = enable;
664 cloneOperandsFlag = enable;
691 if (
options.shouldCloneOperands()) {
705 mapper.
map(
this, newOp);
708 if (
options.shouldCloneRegions()) {
709 for (
unsigned i = 0; i != numRegions; ++i)
734 return (*parseFn)(parser, result);
742 printOpName(op, p, defaultDialect);
752 StringRef defaultDialect) {
754 if (name.startswith((defaultDialect +
".").str()) && name.count(
'.') == 1)
755 name = name.drop_front(defaultDialect.size() + 1);
770 p <<
"<" << properties <<
">";
776 return getOperation()->emitError(message);
782 return getOperation()->emitOpError(message);
788 return getOperation()->emitWarning(message);
794 return getOperation()->emitRemark(message);
810 return !
static_cast<bool>(operands[std::distance(operandsBegin, &o)]);
812 auto *firstConstantIt = llvm::find_if_not(op->
getOpOperands(), isNonConstant);
813 auto *newConstantIt = std::stable_partition(
816 return success(firstConstantIt != newConstantIt);
822 if (argumentOp && op->
getName() == argumentOp->getName()) {
835 if (argumentOp && op->
getName() == argumentOp->getName()) {
845 return op->
emitOpError() <<
"requires zero operands";
851 return op->
emitOpError() <<
"requires a single operand";
856 unsigned numOperands) {
858 return op->
emitOpError() <<
"expected " << numOperands
865 unsigned numOperands) {
868 <<
"expected " << numOperands <<
" or more operands, but found "
876 if (
auto vec = llvm::dyn_cast<VectorType>(type))
877 return vec.getElementType();
880 if (
auto tensor = llvm::dyn_cast<TensorType>(type))
905 if (!type.isSignlessIntOrIndex())
906 return op->
emitOpError() <<
"requires an integer or index type";
914 if (!llvm::isa<FloatType>(type))
929 return op->
emitOpError() <<
"requires all operands to have the same type";
935 return op->
emitOpError() <<
"requires zero regions";
946 unsigned numRegions) {
948 return op->
emitOpError() <<
"expected " << numRegions <<
" regions";
953 unsigned numRegions) {
955 return op->
emitOpError() <<
"expected " << numRegions <<
" or more regions";
961 return op->
emitOpError() <<
"requires zero results";
972 unsigned numOperands) {
974 return op->
emitOpError() <<
"expected " << numOperands <<
" results";
979 unsigned numOperands) {
982 <<
"expected " << numOperands <<
" or more results";
991 return op->
emitOpError() <<
"requires the same shape for all operands";
1006 <<
"requires the same shape for all operands and results";
1016 for (
auto operand : llvm::drop_begin(op->
getOperands(), 1)) {
1018 return op->
emitOpError(
"requires the same element type for all operands");
1033 for (
auto result : llvm::drop_begin(op->
getResults(), 1)) {
1036 "requires the same element type for all operands and results");
1043 "requires the same element type for all operands and results");
1057 if (
auto rankedType = dyn_cast<RankedTensorType>(type))
1058 encoding = rankedType.getEncoding();
1063 <<
"requires the same type for all operands and results";
1065 if (
auto rankedType = dyn_cast<RankedTensorType>(resultType);
1066 encoding != rankedType.getEncoding())
1068 <<
"requires the same encoding for all operands and results";
1074 <<
"requires the same type for all operands and results";
1076 if (
auto rankedType = dyn_cast<RankedTensorType>(opType);
1077 encoding != rankedType.getEncoding())
1079 <<
"requires the same encoding for all operands and results";
1090 auto hasRank = [](
const Type type) {
1091 if (
auto shaped_type = dyn_cast<ShapedType>(type))
1092 return shaped_type.hasRank();
1097 auto rankedOperandTypes =
1099 auto rankedResultTypes =
1103 if (rankedOperandTypes.empty() && rankedResultTypes.empty())
1107 auto getRank = [](
const Type type) {
1108 return type.cast<ShapedType>().getRank();
1111 auto rank = !rankedOperandTypes.empty() ? getRank(*rankedOperandTypes.begin())
1112 : getRank(*rankedResultTypes.begin());
1114 for (
const auto type : rankedOperandTypes) {
1115 if (rank != getRank(type)) {
1116 return op->
emitOpError(
"operands don't have matching ranks");
1120 for (
const auto type : rankedResultTypes) {
1121 if (rank != getRank(type)) {
1122 return op->
emitOpError(
"result type has different rank than operands");
1132 if (!block || &block->
back() != op)
1133 return op->
emitOpError(
"must be the last operation in the parent block");
1142 if (succ->getParent() != parent)
1143 return op->
emitError(
"reference to block defined in another region");
1149 return op->
emitOpError(
"requires 0 successors but found ")
1157 return op->
emitOpError(
"requires 1 successor but found ")
1163 unsigned numSuccessors) {
1166 << numSuccessors <<
" successors but found "
1172 unsigned numSuccessors) {
1175 << numSuccessors <<
" successors but found "
1184 bool isBoolType = elementType.isInteger(1);
1186 return op->
emitOpError() <<
"requires a bool result type";
1195 return op->
emitOpError() <<
"requires a floating point type";
1204 return op->
emitOpError() <<
"requires an integer or index type";
1210 StringRef valueGroupName,
1211 size_t expectedCount) {
1214 return op->
emitOpError(
"requires dense i32 array attribute '")
1218 if (llvm::any_of(sizes, [](int32_t element) {
return element < 0; }))
1220 << attrName <<
"' attribute cannot have negative elements";
1223 std::accumulate(sizes.begin(), sizes.end(), 0,
1224 [](
unsigned all, int32_t one) { return all + one; });
1226 if (totalCount != expectedCount)
1228 << valueGroupName <<
" count (" << expectedCount
1229 <<
") does not match with the total size (" << totalCount
1230 <<
") specified in attribute '" << attrName <<
"'";
1235 StringRef attrName) {
1240 StringRef attrName) {
1249 if (region.getNumArguments() != 0) {
1252 << region.getRegionNumber() <<
" should have no arguments";
1253 return op->
emitOpError(
"region should have no arguments");
1260 auto isMappableType = [](
Type type) {
1261 return llvm::isa<VectorType, TensorType>(type);
1263 auto resultMappableTypes = llvm::to_vector<1>(
1265 auto operandMappableTypes = llvm::to_vector<2>(
1270 if (resultMappableTypes.empty() && operandMappableTypes.empty())
1273 if (!resultMappableTypes.empty() && operandMappableTypes.empty())
1274 return op->
emitOpError(
"if a result is non-scalar, then at least one "
1275 "operand must be non-scalar");
1277 assert(!operandMappableTypes.empty());
1279 if (resultMappableTypes.empty())
1280 return op->
emitOpError(
"if an operand is non-scalar, then there must be at "
1281 "least one non-scalar result");
1285 "if an operand is non-scalar, then all results must be non-scalar");
1288 llvm::concat<Type>(operandMappableTypes, resultMappableTypes));
1289 TypeID expectedBaseTy = types.front().getTypeID();
1290 if (!llvm::all_of(types,
1293 return op->
emitOpError() <<
"all non-scalar operands/results must have the "
1294 "same shape and base type";
1304 "Intended to check IsolatedFromAbove ops");
1310 for (
auto ®ion : isolatedOp->
getRegions()) {
1311 pendingRegions.push_back(®ion);
1314 while (!pendingRegions.empty()) {
1315 for (
Operation &op : pendingRegions.pop_back_val()->getOps()) {
1319 auto *operandRegion = operand.getParentRegion();
1321 return op.
emitError(
"operation's operand is unlinked");
1322 if (!region.isAncestor(operandRegion)) {
1323 return op.
emitOpError(
"using value defined outside the region")
1325 <<
"required by region isolation constraints";
1335 pendingRegions.push_back(&subRegion);
1369 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 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 ParseResult parseLess()=0
Parse a '<' token.
virtual SMLoc getNameLoc() const =0
Return the location of the original name token.
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.
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.
Diagnostic & attachNote(std::optional< Location > noteLoc=std::nullopt)
Attaches a note to this diagnostic.
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.
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.
void setInsertionPointToEnd(Block *block)
Sets the insertion point to the end of the specified block.
Block * createBlock(Region *parent, Region::iterator insertPt={}, TypeRange argTypes=std::nullopt, ArrayRef< Location > locs=std::nullopt)
Add new block with 'argTypes' arguments and set the insertion point to the end of it.
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 printOpName(Operation *op, OpAsmPrinter &p, StringRef defaultDialect)
Print an operation name, eliding the dialect prefix if necessary.
static void genericPrintProperties(OpAsmPrinter &p, Attribute properties)
Print the properties as a Attribute.
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.
LogicalResult setPropertiesFromAttribute(Attribute attr, function_ref< InFlightDiagnostic &()> getDiag)
Set the properties from the provided attribute.
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.
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 represents success/failure for parsing-like operations that find it important to chain tog...
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...
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...
This header declares functions that assist transformations in the MemRef dialect.
bool matchPattern(Value value, const Pattern &pattern)
Entry point for matching a pattern over a Value.
LogicalResult failure(bool isFailure=true)
Utility function to generate a LogicalResult.
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.
bool succeeded(LogicalResult result)
Utility function that returns true if the provided LogicalResult corresponds to a success value.
LogicalResult success(bool isSuccess=true)
Utility function to generate a LogicalResult.
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.
bool failed(LogicalResult result)
Utility function that returns true if the provided LogicalResult corresponds to a failure value.
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 class represents an efficient way to signal success or failure.
bool succeeded() const
Returns true if the provided LogicalResult corresponds to a success value.
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...