18 #include "llvm/ADT/BitVector.h"
19 #include "llvm/Support/SHA1.h"
30 assign(attributes.begin(), attributes.end());
36 dictionarySorted.setPointerAndInt(attributes,
true);
46 std::optional<NamedAttribute> duplicate =
47 DictionaryAttr::findDuplicate(attrs, isSorted());
51 dictionarySorted.setPointerAndInt(
nullptr,
true);
57 DictionaryAttr::sortInPlace(attrs);
58 dictionarySorted.setPointerAndInt(
nullptr,
true);
60 if (!dictionarySorted.getPointer())
61 dictionarySorted.setPointer(DictionaryAttr::getWithSorted(context, attrs));
62 return llvm::cast<DictionaryAttr>(dictionarySorted.getPointer());
73 dictionarySorted.setPointerAndInt(
nullptr,
true);
78 dictionarySorted.setInt(attrs.empty() || attrs.back() < newAttribute);
79 dictionarySorted.setPointer(
nullptr);
80 attrs.push_back(newAttribute);
85 auto it = findAttr(*
this, name);
86 return it.second ? it.first->getValue() :
Attribute();
89 auto it = findAttr(*
this, name);
90 return it.second ? it.first->getValue() :
Attribute();
95 auto it = findAttr(*
this, name);
96 return it.second ? *it.first : std::optional<NamedAttribute>();
99 auto it = findAttr(*
this, name);
100 return it.second ? *it.first : std::optional<NamedAttribute>();
106 assert(value &&
"attributes may never be null");
110 auto it = findAttr(*
this, name);
114 Attribute oldValue = it.first->getValue();
115 if (it.first->getValue() != value) {
116 it.first->setValue(value);
119 dictionarySorted.setPointer(
nullptr);
126 it = findAttr(*
this, name.strref());
127 attrs.insert(it.first, {name, value});
129 dictionarySorted.setPointer(
nullptr);
134 assert(value &&
"attributes may never be null");
143 dictionarySorted.setPointer(
nullptr);
148 auto it = findAttr(*
this, name);
149 return it.second ? eraseImpl(it.first) :
Attribute();
153 auto it = findAttr(*
this, name);
154 return it.second ? eraseImpl(it.first) :
Attribute();
159 assign(rhs.begin(), rhs.end());
170 : location(location), name(name, location->
getContext()) {}
173 : location(location), name(name) {}
180 : location(location), name(name),
181 operands(operands.begin(), operands.end()),
182 types(types.begin(), types.end()),
183 attributes(attributes.begin(), attributes.end()),
184 successors(successors.begin(), successors.end()) {
185 for (std::unique_ptr<Region> &r :
regions)
186 this->regions.push_back(std::move(r));
194 operands, types, attributes, successors, regions) {}
198 propertiesDeleter(properties);
213 operands.append(newOperands.begin(), newOperands.end());
217 successors.append(newSuccessors.begin(), newSuccessors.end());
226 regions.push_back(std::move(region));
231 for (std::unique_ptr<Region> ®ion :
regions)
242 : isStorageDynamic(false), operandStorage(trailingOperands) {
243 numOperands = capacity = values.size();
244 for (
unsigned i = 0; i < numOperands; ++i)
245 new (&operandStorage[i])
OpOperand(owner, values[i]);
249 for (
auto &operand : getOperands())
250 operand.~OpOperand();
253 if (isStorageDynamic)
254 free(operandStorage);
261 for (
unsigned i = 0, e = values.size(); i != e; ++i)
262 storageOperands[i].set(values[i]);
271 unsigned newSize = operands.size();
272 if (newSize == length) {
274 for (
unsigned i = 0, e = length; i != e; ++i)
275 storageOperands[start + i].set(operands[i]);
280 if (newSize < length) {
281 eraseOperands(start + operands.size(), length - newSize);
282 setOperands(owner, start, newSize, operands);
286 auto storageOperands = resize(owner, size() + (newSize - length));
289 unsigned rotateSize = storageOperands.size() - (start + length);
290 auto rbegin = storageOperands.rbegin();
291 std::rotate(rbegin, std::next(rbegin, newSize - length), rbegin + rotateSize);
294 for (
unsigned i = 0, e = operands.size(); i != e; ++i)
295 storageOperands[start + i].set(operands[i]);
301 assert((start + length) <= operands.size());
302 numOperands -= length;
305 if (start != numOperands) {
306 auto *indexIt = std::next(operands.begin(), start);
307 std::rotate(indexIt, std::next(indexIt, length), operands.end());
309 for (
unsigned i = 0; i != length; ++i)
315 assert(eraseIndices.size() == operands.size());
318 int firstErasedIndice = eraseIndices.find_first();
319 if (firstErasedIndice == -1)
323 numOperands = firstErasedIndice;
324 for (
unsigned i = firstErasedIndice + 1, e = operands.size(); i < e; ++i)
325 if (!eraseIndices.test(i))
326 operands[numOperands++] = std::move(operands[i]);
327 for (
OpOperand &operand : operands.drop_front(numOperands))
328 operand.~OpOperand();
338 if (newSize <= numOperands) {
341 for (
unsigned i = newSize; i != numOperands; ++i)
343 numOperands = newSize;
344 return origOperands.take_front(newSize);
348 if (newSize <= capacity) {
349 OpOperand *opBegin = origOperands.data();
350 for (
unsigned e = newSize; numOperands != e; ++numOperands)
351 new (&opBegin[numOperands])
OpOperand(owner);
356 unsigned newCapacity =
357 std::max(
unsigned(llvm::NextPowerOf2(capacity + 2)), newSize);
363 std::uninitialized_move(origOperands.begin(), origOperands.end(),
364 newOperands.begin());
367 for (
auto &operand : origOperands)
368 operand.~OpOperand();
371 for (
unsigned e = newSize; numOperands != e; ++numOperands)
372 new (&newOperands[numOperands])
OpOperand(owner);
375 if (isStorageDynamic)
376 free(operandStorage);
379 operandStorage = newOperandStorage;
380 capacity = newCapacity;
381 isStorageDynamic =
true;
393 assert(!empty() &&
"range must not be empty");
394 return base->getOperandNumber();
411 const OwnerT &owner =
getBase();
414 std::accumulate(sizeData.begin(), sizeData.end(), 0));
417 OperandRange OperandRangeRange::dereference(
const OwnerT &
object,
420 uint32_t startIndex =
421 std::accumulate(sizeData.begin(), sizeData.begin() + index, 0);
422 return OperandRange(
object.first + startIndex, *(sizeData.begin() + index));
431 Operation *owner,
unsigned start,
unsigned length,
433 : owner(owner), start(start), length(length),
434 operandSegments(operandSegments.begin(), operandSegments.end()) {
435 assert((start + length) <= owner->
getNumOperands() &&
"invalid range");
443 opOperand.getOperandNumber(),
449 std::optional<OperandSegment> segment)
const {
450 assert((subStart + subLen) <= length &&
"invalid sub-range");
454 subSlice.operandSegments.push_back(*segment);
463 updateLength(length + values.size());
469 if (length != values.size())
470 updateLength(values.size());
485 assert((subStart + subLen) <= length &&
"invalid sub-range");
489 updateLength(length - subLen);
515 void MutableOperandRange::updateLength(
unsigned newLength) {
516 int32_t diff = int32_t(newLength) - int32_t(length);
521 auto attr = llvm::cast<DenseI32ArrayAttr>(segment.second.getValue());
523 segments[segment.first] += diff;
524 segment.second.setValue(
526 owner->
setAttr(segment.second.getName(), segment.second.getValue());
531 assert(index < length &&
"index is out of bounds");
549 OwnerT(operands, operandSegmentAttr), 0,
564 llvm::cast<DenseI32ArrayAttr>(
object.second.getValue());
565 uint32_t startIndex =
566 std::accumulate(sizeData.begin(), sizeData.begin() + index, 0);
567 return object.first.slice(
568 startIndex, *(sizeData.begin() + index),
599 : it(end ? results.end() : results.begin()), endIt(results.end()) {
602 skipOverResultsWithNoUsers();
608 if (use != (*it).use_end())
610 if (use == (*it).use_end()) {
612 skipOverResultsWithNoUsers();
617 void ResultRange::UseIterator::skipOverResultsWithNoUsers() {
618 while (it != endIt && (*it).use_empty())
626 use = (*it).use_begin();
651 if (
const auto *value = llvm::dyn_cast_if_present<const Value *>(owner))
652 return {value + index};
653 if (
auto *operand = llvm::dyn_cast_if_present<OpOperand *>(owner))
654 return {operand + index};
658 Value ValueRange::dereference_iterator(
const OwnerT &owner, ptrdiff_t index) {
659 if (
const auto *value = llvm::dyn_cast_if_present<const Value *>(owner))
661 if (
auto *operand = llvm::dyn_cast_if_present<OpOperand *>(owner))
662 return operand[index].get();
677 llvm::hash_code hash =
682 if (!(flags & Flags::IgnoreLocations))
683 hash = llvm::hash_combine(hash, op->
getLoc());
687 hash = llvm::hash_combine(hash, hashOperands(operand));
691 hash = llvm::hash_combine(hash, hashResults(result));
701 auto blocksEquivalent = [&](
Block &lBlock,
Block &rBlock) {
707 auto insertion = blocksMap.insert({&lBlock, &rBlock});
708 if (insertion.first->getSecond() != &rBlock)
712 llvm::zip(lBlock.
getArguments(), rBlock.getArguments())) {
713 Value curArg = std::get<0>(argPair);
714 Value otherArg = std::get<1>(argPair);
722 markEquivalent(curArg, otherArg);
728 markEquivalent, flags))
731 for (
auto successorsPair :
733 Block *curSuccessor = std::get<0>(successorsPair);
734 Block *otherSuccessor = std::get<1>(successorsPair);
735 auto insertion = blocksMap.insert({curSuccessor, otherSuccessor});
736 if (insertion.first->getSecond() != otherSuccessor)
741 return llvm::all_of_zip(lBlock, rBlock, opsEquivalent);
743 return llvm::all_of_zip(*lhs, *rhs, blocksEquivalent);
751 return success(lhsValue == rhsValue ||
752 equivalentValues.lookup(lhsValue) == rhsValue);
755 auto insertion = equivalentValues.insert({lhsResult, rhsResult});
759 assert(insertion.first->second == rhsResult &&
760 "inconsistent OperationEquivalence state");
802 Value curArg = std::get<0>(operandPair);
803 Value otherArg = std::get<1>(operandPair);
804 if (curArg == otherArg)
808 if (
failed(checkEquivalent(curArg, otherArg)))
814 Value curArg = std::get<0>(resultPair);
815 Value otherArg = std::get<1>(resultPair);
819 markEquivalent(curArg, otherArg);
825 &std::get<1>(regionPair), checkEquivalent,
826 markEquivalent, flags))
851 template <
typename T>
873 for (
Block &block : region) {
891 hash = hasher.result();
static Value getBase(Value v)
Looks through known "view-like" ops to find the base memref.
static MLIRContext * getContext(OpFoldResult val)
static void addDataToHash(llvm::SHA1 &hasher, const T &data)
static Value max(ImplicitLocOpBuilder &builder, Value value, Value bound)
Attributes are known-constant values of operations.
MLIRContext * getContext() const
Return the context this attribute belongs to.
This class represents an argument of a Block.
This class provides an abstraction over the different types of ranges over Blocks.
Block represents an ordered list of Operations.
unsigned getNumArguments()
BlockArgListType getArguments()
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...
const void * getAsOpaquePointer() const
Methods for supporting PointerLikeTypeTraits.
MLIRContext is the top-level object for a collection of MLIR operations.
This class represents a contiguous range of mutable operand ranges, e.g.
MutableOperandRange join() const
Flatten all of the sub ranges into a single contiguous mutable operand range.
MutableOperandRangeRange(const MutableOperandRange &operands, NamedAttribute operandSegmentAttr)
Construct a range given a parent set of operands, and an I32 tensor elements attribute containing the...
This class provides a mutable adaptor for a range of operands.
void assign(ValueRange values)
Assign this range to the given values.
MutableOperandRange slice(unsigned subStart, unsigned subLen, std::optional< OperandSegment > segment=std::nullopt) const
Slice this range into a sub range, with the additional operand segment.
MutableArrayRef< OpOperand >::iterator end() const
void erase(unsigned subStart, unsigned subLen=1)
Erase the operands within the given sub-range.
void append(ValueRange values)
Append the given values to the range.
void clear()
Clear this range and erase all of the operands.
MutableOperandRange(Operation *owner, unsigned start, unsigned length, ArrayRef< OperandSegment > operandSegments=std::nullopt)
Construct a new mutable range from the given operand, operand start index, and range length.
MutableArrayRef< OpOperand >::iterator begin() const
Iterators enumerate OpOperands.
std::pair< unsigned, NamedAttribute > OperandSegment
A pair of a named attribute corresponding to an operand segment attribute, and the index within that ...
MutableOperandRangeRange split(NamedAttribute segmentSizes) const
Split this range into a set of contiguous subranges using the given elements attribute,...
OpOperand & operator[](unsigned index) const
Returns the OpOperand at the given index.
NamedAttrList is array of NamedAttributes that tracks whether it is sorted and does some basic work t...
std::optional< NamedAttribute > getNamed(StringRef name) const
Return the specified named attribute if present, std::nullopt otherwise.
void assign(const_iterator inStart, const_iterator inEnd)
Replaces the attributes with new list of attributes.
SmallVectorImpl< NamedAttribute >::const_iterator const_iterator
ArrayRef< NamedAttribute > getAttrs() const
Return all of the attributes on this operation.
DictionaryAttr getDictionary(MLIRContext *context) const
Return a dictionary attribute for the underlying dictionary.
void push_back(NamedAttribute newAttribute)
Add an attribute with the specified name.
Attribute get(StringAttr name) const
Return the specified attribute if present, null otherwise.
Attribute erase(StringAttr name)
Erase the attribute with the given name from the list.
std::optional< NamedAttribute > findDuplicate() const
Returns an entry with a duplicate name the list, if it exists, else returns std::nullopt.
Attribute set(StringAttr name, Attribute value)
If the an attribute exists with the specified name, change it to the new value.
void append(StringRef name, Attribute attr)
Add an attribute with the specified name.
NamedAttrList & operator=(const SmallVectorImpl< NamedAttribute > &rhs)
NamedAttribute represents a combination of a name and an Attribute value.
This class represents an operand of an operation.
This is a value defined by a result of an operation.
This class represents a contiguous range of operand ranges, e.g.
OperandRangeRange(OperandRange operands, Attribute operandSegments)
Construct a range given a parent set of operands, and an I32 elements attribute containing the sizes ...
OperandRange join() const
Flatten all of the sub ranges into a single contiguous operand range.
This class implements the operand iterators for the Operation class.
unsigned getBeginOperandIndex() const
Return the operand index of the first element of this range.
OperandRangeRange split(DenseI32ArrayAttr segmentSizes) const
Split this range into a set of contiguous subranges using the given elements attribute,...
OperationFingerPrint(Operation *topOp)
bool compareOpProperties(OpaqueProperties lhs, OpaqueProperties rhs) const
Operation is the basic unit of execution within MLIR.
void insertOperands(unsigned index, ValueRange operands)
Insert the given operands into the operand list at the given 'index'.
OpOperand & getOpOperand(unsigned idx)
void setOperand(unsigned idx, Value value)
Block * getSuccessor(unsigned index)
unsigned getNumSuccessors()
void eraseOperands(unsigned idx, unsigned length=1)
Erase the operands starting at position idx and ending at position 'idx'+'length'.
std::enable_if_t< llvm::function_traits< std::decay_t< FnT > >::num_args==1, RetT > walk(FnT &&callback)
Walk the operation by calling the callback for each nested operation (including this one),...
unsigned getNumRegions()
Returns the number of regions held by this operation.
Location getLoc()
The source location the operation was defined or derived from.
unsigned getNumOperands()
Operation * getParentOp()
Returns the closest surrounding operation that contains this operation or nullptr if this is a top-le...
void setAttr(StringAttr name, Attribute value)
If the an attribute exists with the specified name, change it to the new value.
MutableArrayRef< Region > getRegions()
Returns the regions held by this operation.
OperationName getName()
The name of an operation is the key identifier for it.
DictionaryAttr getDiscardableAttrDictionary()
Return all of the discardable attributes on this operation as a DictionaryAttr.
LogicalResult setPropertiesFromAttribute(Attribute attr, function_ref< InFlightDiagnostic()> emitError)
Set the properties from the provided attribute.
MutableArrayRef< OpOperand > getOpOperands()
result_type_range getResultTypes()
operand_range getOperands()
Returns an iterator on the underlying Value's.
void setOperands(ValueRange operands)
Replace the current operands of this operation with the ones provided in 'operands'.
SuccessorRange getSuccessors()
result_range getResults()
llvm::hash_code hashProperties()
Compute a hash for the op properties (if any).
OpaqueProperties getPropertiesStorage()
Returns the properties storage.
unsigned getNumResults()
Return the number of results held by this operation.
This class contains a list of basic blocks and a link to the parent operation it is attached to.
This class implements a use iterator for a range of operation results.
UseIterator(ResultRange results, bool end=false)
Initialize the UseIterator.
UseIterator & operator++()
This class implements the result iterators for the Operation class.
use_range getUses() const
Returns a range of all uses of results within this range, which is useful for iterating over all uses...
use_iterator use_begin() const
user_range getUsers()
Returns a range of all users.
ValueUserIterator< use_iterator, OpOperand > user_iterator
ResultRange(OpResult result)
use_iterator use_end() const
std::enable_if_t<!std::is_convertible< ValuesT, Operation * >::value > replaceUsesWithIf(ValuesT &&values, function_ref< bool(OpOperand &)> shouldReplace)
Replace uses of results of this range with the provided 'values' if the given callback returns true.
std::enable_if_t<!std::is_convertible< ValuesT, Operation * >::value > replaceAllUsesWith(ValuesT &&values)
Replace all uses of results of this range with the provided 'values'.
user_iterator user_begin()
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...
This class provides an abstraction over the different types of ranges over Values.
PointerUnion< const Value *, OpOperand *, detail::OpResultImpl * > OwnerT
The type representing the owner of a ValueRange.
An iterator over the users of an IRObject.
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.
Location getLoc() const
Return the location of this value.
static DenseArrayAttrImpl get(MLIRContext *context, ArrayRef< int32_t > content)
Builder from ArrayRef<T>.
This class provides the implementation for an operation result.
void eraseOperands(unsigned start, unsigned length)
Erase the operands held by the storage within the given range.
void setOperands(Operation *owner, ValueRange values)
Replace the operands contained in the storage with the ones provided in 'values'.
OperandStorage(Operation *owner, OpOperand *trailingOperands, ValueRange values)
Include the generated interface declarations.
Include the generated interface declarations.
InFlightDiagnostic emitError(Location loc)
Utility method to emit an error message using this location.
LogicalResult success(bool isSuccess=true)
Utility function to generate a LogicalResult.
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
bool failed(LogicalResult result)
Utility function that returns true if the provided LogicalResult corresponds to a failure value.
LogicalResult checkEquivalent(Value lhsValue, Value rhsValue)
void markEquivalent(Value lhsResult, Value rhsResult)
DenseMap< Value, Value > equivalentValues
This class represents an efficient way to signal success or failure.
static bool isRegionEquivalentTo(Region *lhs, Region *rhs, function_ref< LogicalResult(Value, Value)> checkEquivalent, function_ref< void(Value, Value)> markEquivalent, OperationEquivalence::Flags flags)
Compare two regions (including their subregions) and return if they are equivalent.
static llvm::hash_code computeHash(Operation *op, function_ref< llvm::hash_code(Value)> hashOperands=[](Value v) { return hash_value(v);}, function_ref< llvm::hash_code(Value)> hashResults=[](Value v) { return hash_value(v);}, Flags flags=Flags::None)
Compute a hash for the given operation.
static bool isEquivalentTo(Operation *lhs, Operation *rhs, function_ref< LogicalResult(Value, Value)> checkEquivalent, function_ref< void(Value, Value)> markEquivalent=nullptr, Flags flags=Flags::None)
Compare two operations (including their regions) and return if they are equivalent.
This represents an operation in an abstracted form, suitable for use with the builder APIs.
void addRegions(MutableArrayRef< std::unique_ptr< Region >> regions)
Take ownership of a set of regions that should be attached to the Operation.
SmallVector< Block *, 1 > successors
Successors of this operation and their respective operands.
SmallVector< Value, 4 > operands
void addOperands(ValueRange newOperands)
void addSuccessors(Block *successor)
SmallVector< std::unique_ptr< Region >, 1 > regions
Regions that the op will hold.
OperationState(Location location, StringRef name)
Region * addRegion()
Create a region that should be attached to the operation.
LogicalResult setProperties(Operation *op, function_ref< InFlightDiagnostic()> emitError) const