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());
68 dictionarySorted.setPointerAndInt(
nullptr,
true);
73 dictionarySorted.setInt(attrs.empty() || attrs.back() < newAttribute);
74 dictionarySorted.setPointer(
nullptr);
75 attrs.push_back(newAttribute);
80 auto it = findAttr(*
this, name);
81 return it.second ? it.first->getValue() :
Attribute();
84 auto it = findAttr(*
this, name);
85 return it.second ? it.first->getValue() :
Attribute();
90 auto it = findAttr(*
this, name);
91 return it.second ? *it.first : std::optional<NamedAttribute>();
94 auto it = findAttr(*
this, name);
95 return it.second ? *it.first : std::optional<NamedAttribute>();
101 assert(value &&
"attributes may never be null");
105 auto it = findAttr(*
this, name);
109 Attribute oldValue = it.first->getValue();
110 if (it.first->getValue() != value) {
111 it.first->setValue(value);
114 dictionarySorted.setPointer(
nullptr);
121 it = findAttr(*
this, name.strref());
122 attrs.insert(it.first, {name, value});
124 dictionarySorted.setPointer(
nullptr);
129 assert(value &&
"attributes may never be null");
138 dictionarySorted.setPointer(
nullptr);
143 auto it = findAttr(*
this, name);
144 return it.second ? eraseImpl(it.first) :
Attribute();
148 auto it = findAttr(*
this, name);
149 return it.second ? eraseImpl(it.first) :
Attribute();
154 assign(rhs.begin(), rhs.end());
165 : location(location), name(name, location->
getContext()) {}
168 : location(location), name(name) {}
175 : location(location), name(name),
176 operands(operands.begin(), operands.end()),
177 types(types.begin(), types.end()),
178 attributes(attributes.begin(), attributes.end()),
179 successors(successors.begin(), successors.end()) {
180 for (std::unique_ptr<Region> &r :
regions)
181 this->regions.push_back(std::move(r));
189 operands, types, attributes, successors, regions) {}
193 propertiesDeleter(properties);
208 operands.append(newOperands.begin(), newOperands.end());
212 successors.append(newSuccessors.begin(), newSuccessors.end());
221 regions.push_back(std::move(region));
226 for (std::unique_ptr<Region> ®ion :
regions)
237 : isStorageDynamic(false), operandStorage(trailingOperands) {
238 numOperands = capacity = values.size();
239 for (
unsigned i = 0; i < numOperands; ++i)
240 new (&operandStorage[i])
OpOperand(owner, values[i]);
244 for (
auto &operand : getOperands())
245 operand.~OpOperand();
248 if (isStorageDynamic)
249 free(operandStorage);
256 for (
unsigned i = 0, e = values.size(); i != e; ++i)
257 storageOperands[i].set(values[i]);
266 unsigned newSize = operands.size();
267 if (newSize == length) {
269 for (
unsigned i = 0, e = length; i != e; ++i)
270 storageOperands[start + i].set(operands[i]);
275 if (newSize < length) {
276 eraseOperands(start + operands.size(), length - newSize);
277 setOperands(owner, start, newSize, operands);
281 auto storageOperands = resize(owner, size() + (newSize - length));
284 unsigned rotateSize = storageOperands.size() - (start + length);
285 auto rbegin = storageOperands.rbegin();
286 std::rotate(rbegin, std::next(rbegin, newSize - length), rbegin + rotateSize);
289 for (
unsigned i = 0, e = operands.size(); i != e; ++i)
290 storageOperands[start + i].set(operands[i]);
296 assert((start + length) <= operands.size());
297 numOperands -= length;
300 if (start != numOperands) {
301 auto *indexIt = std::next(operands.begin(), start);
302 std::rotate(indexIt, std::next(indexIt, length), operands.end());
304 for (
unsigned i = 0; i != length; ++i)
310 assert(eraseIndices.size() == operands.size());
313 int firstErasedIndice = eraseIndices.find_first();
314 if (firstErasedIndice == -1)
318 numOperands = firstErasedIndice;
319 for (
unsigned i = firstErasedIndice + 1, e = operands.size(); i < e; ++i)
320 if (!eraseIndices.test(i))
321 operands[numOperands++] = std::move(operands[i]);
322 for (
OpOperand &operand : operands.drop_front(numOperands))
323 operand.~OpOperand();
333 if (newSize <= numOperands) {
336 for (
unsigned i = newSize; i != numOperands; ++i)
338 numOperands = newSize;
339 return origOperands.take_front(newSize);
343 if (newSize <= capacity) {
344 OpOperand *opBegin = origOperands.data();
345 for (
unsigned e = newSize; numOperands != e; ++numOperands)
346 new (&opBegin[numOperands])
OpOperand(owner);
351 unsigned newCapacity =
352 std::max(
unsigned(llvm::NextPowerOf2(capacity + 2)), newSize);
358 std::uninitialized_move(origOperands.begin(), origOperands.end(),
359 newOperands.begin());
362 for (
auto &operand : origOperands)
363 operand.~OpOperand();
366 for (
unsigned e = newSize; numOperands != e; ++numOperands)
367 new (&newOperands[numOperands])
OpOperand(owner);
370 if (isStorageDynamic)
371 free(operandStorage);
374 operandStorage = newOperandStorage;
375 capacity = newCapacity;
376 isStorageDynamic =
true;
388 assert(!empty() &&
"range must not be empty");
389 return base->getOperandNumber();
406 const OwnerT &owner =
getBase();
409 std::accumulate(sizeData.begin(), sizeData.end(), 0));
412 OperandRange OperandRangeRange::dereference(
const OwnerT &
object,
415 uint32_t startIndex =
416 std::accumulate(sizeData.begin(), sizeData.begin() + index, 0);
417 return OperandRange(
object.first + startIndex, *(sizeData.begin() + index));
426 Operation *owner,
unsigned start,
unsigned length,
428 : owner(owner), start(start), length(length),
429 operandSegments(operandSegments) {
430 assert((start + length) <= owner->
getNumOperands() &&
"invalid range");
438 opOperand.getOperandNumber(),
444 std::optional<OperandSegment> segment)
const {
445 assert((subStart + subLen) <= length &&
"invalid sub-range");
449 subSlice.operandSegments.push_back(*segment);
458 updateLength(length + values.size());
464 if (length != values.size())
465 updateLength(values.size());
480 assert((subStart + subLen) <= length &&
"invalid sub-range");
484 updateLength(length - subLen);
502 return getAsOperandRange();
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};
655 return cast<detail::OpResultImpl *>(owner)->getNextResultAtOffset(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();
663 return cast<detail::OpResultImpl *>(owner)->getNextResultAtOffset(index);
677 llvm::hash_code hash =
682 if (!(flags & Flags::IgnoreLocations))
683 hash = llvm::hash_combine(hash, op->
getLoc());
688 size_t operandHash = hashOperands(op->
getOperand(0));
689 for (
auto operand : op->
getOperands().drop_front())
690 operandHash += hashOperands(operand);
691 hash = llvm::hash_combine(hash, operandHash);
694 hash = llvm::hash_combine(hash, hashOperands(operand));
699 hash = llvm::hash_combine(hash, hashResults(result));
709 checkCommutativeEquivalent) {
711 auto blocksEquivalent = [&](
Block &lBlock,
Block &rBlock) {
717 auto insertion = blocksMap.insert({&lBlock, &rBlock});
718 if (insertion.first->getSecond() != &rBlock)
722 llvm::zip(lBlock.
getArguments(), rBlock.getArguments())) {
723 Value curArg = std::get<0>(argPair);
724 Value otherArg = std::get<1>(argPair);
732 markEquivalent(curArg, otherArg);
738 markEquivalent, flags,
739 checkCommutativeEquivalent))
742 for (
auto successorsPair :
744 Block *curSuccessor = std::get<0>(successorsPair);
745 Block *otherSuccessor = std::get<1>(successorsPair);
746 auto insertion = blocksMap.insert({curSuccessor, otherSuccessor});
747 if (insertion.first->getSecond() != otherSuccessor)
752 return llvm::all_of_zip(lBlock, rBlock, opsEquivalent);
754 return llvm::all_of_zip(*lhs, *rhs, blocksEquivalent);
762 return success(lhsValue == rhsValue ||
763 equivalentValues.lookup(lhsValue) == rhsValue);
768 if (lhsRange.size() != rhsRange.size())
772 auto lhsIt = lhsRange.begin();
773 auto rhsIt = rhsRange.begin();
774 for (; lhsIt != lhsRange.end(); ++lhsIt, ++rhsIt) {
775 if (failed(checkEquivalent(*lhsIt, *rhsIt)))
778 if (lhsIt == lhsRange.end())
786 llvm::sort(sortedValues, [](
Value a,
Value b) {
791 auto lhsSorted = sortValues({lhsIt, lhsRange.end()});
792 auto rhsSorted = sortValues({rhsIt, rhsRange.end()});
793 return success(lhsSorted == rhsSorted);
796 auto insertion = equivalentValues.insert({lhsResult, rhsResult});
800 assert(insertion.first->second == rhsResult &&
801 "inconsistent OperationEquivalence state");
811 [&](
Value lhsValue,
Value rhsValue) -> LogicalResult {
828 checkCommutativeEquivalent) {
846 if (checkCommutativeEquivalent &&
850 if (failed(checkCommutativeEquivalent(lhsRange, rhsRange)))
855 Value curArg = std::get<0>(operandPair);
856 Value otherArg = std::get<1>(operandPair);
857 if (curArg == otherArg)
861 if (failed(checkEquivalent(curArg, otherArg)))
868 Value curArg = std::get<0>(resultPair);
869 Value otherArg = std::get<1>(resultPair);
873 markEquivalent(curArg, otherArg);
879 &std::get<1>(regionPair), checkEquivalent,
880 markEquivalent, flags))
892 [&](
Value lhsValue,
Value rhsValue) -> LogicalResult {
908 template <
typename T>
915 bool includeNested) {
919 auto addOperationToHash = [&](
Operation *op) {
931 for (
Block &block : region) {
951 topOp->
walk(addOperationToHash);
953 addOperationToHash(topOp);
955 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.
OperandRange getAsOperandRange() const
Explicit conversion to an OperandRange.
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.
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 adds property that the operation is commutative.
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 includeNested=true)
bool compareOpProperties(OpaqueProperties lhs, OpaqueProperties rhs) const
Operation is the basic unit of execution within MLIR.
Value getOperand(unsigned idx)
bool hasTrait()
Returns true if the operation was registered with a particular trait, e.g.
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.
DictionaryAttr getRawDictionaryAttrs()
Return all attributes that are not stored as properties.
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.
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.
ValueRange(Arg &&arg LLVM_LIFETIME_BOUND)
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.
void * getAsOpaquePointer() const
Methods for supporting PointerLikeTypeTraits.
Location getLoc() const
Return the location of this value.
static DenseArrayAttrImpl get(MLIRContext *context, ArrayRef< int32_t > content)
Builder from ArrayRef<T>.
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)
The OpAsmOpInterface, see OpAsmInterface.td for more details.
Include the generated interface declarations.
InFlightDiagnostic emitError(Location loc)
Utility method to emit an error 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 checkEquivalent(Value lhsValue, Value rhsValue)
void markEquivalent(Value lhsResult, Value rhsResult)
LogicalResult checkCommutativeEquivalent(ValueRange lhsRange, ValueRange rhsRange)
DenseMap< Value, Value > equivalentValues
static bool isRegionEquivalentTo(Region *lhs, Region *rhs, function_ref< LogicalResult(Value, Value)> checkEquivalent, function_ref< void(Value, Value)> markEquivalent, OperationEquivalence::Flags flags, function_ref< LogicalResult(ValueRange, ValueRange)> checkCommutativeEquivalent=nullptr)
Compare two regions (including their subregions) and return if they are equivalent.
static bool isEquivalentTo(Operation *lhs, Operation *rhs, function_ref< LogicalResult(Value, Value)> checkEquivalent, function_ref< void(Value, Value)> markEquivalent=nullptr, Flags flags=Flags::None, function_ref< LogicalResult(ValueRange, ValueRange)> checkCommutativeEquivalent=nullptr)
Compare two operations (including their regions) 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.
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)
Adds a successor to the operation sate. successor must not be null.
SmallVector< std::unique_ptr< Region >, 1 > regions
Regions that the op will hold.
OperationState(Location location, StringRef name)
Attribute propertiesAttr
This Attribute is used to opaquely construct the properties of the operation.
Region * addRegion()
Create a region that should be attached to the operation.
LogicalResult setProperties(Operation *op, function_ref< InFlightDiagnostic()> emitError) const