12 #include "llvm/ADT/BitVector.h"
20 assert(!
verifyOpOrder() &&
"Expected valid operation ordering.");
40 assert(!
getParent() &&
"already inserted into a block!");
41 assert(block->
getParent() &&
"cannot insert before a block without a parent");
48 assert(block->
getParent() &&
"cannot insert before a block without a parent");
50 block->getIterator(),
getParent()->getBlocks(), getIterator());
55 assert(
getParent() &&
"Block has no parent");
66 while (currOp->getBlock() !=
this) {
85 for (
auto &op : *
this)
86 op.dropAllDefinedValueUses();
98 parentValidOpOrderPair.setInt(
false);
108 if (operations.empty() || std::next(operations.begin()) == operations.end())
112 for (
auto &i : *
this) {
115 if (prev && prev->orderIndex != Operation::kInvalidOrderIdx &&
116 prev->orderIndex >= i.orderIndex)
125 parentValidOpOrderPair.setInt(
true);
127 unsigned orderIndex = 0;
128 for (
auto &op : *
this)
129 op.orderIndex = (orderIndex += Operation::kOrderStride);
142 BlockArgument arg = BlockArgument::create(type,
this, arguments.size(), loc);
143 arguments.push_back(arg);
150 assert(types.size() == locs.size() &&
151 "incorrect number of block argument locations");
152 size_t initialSize = arguments.size();
153 arguments.reserve(initialSize + types.size());
155 for (
auto typeAndLoc : llvm::zip(types, locs))
156 addArgument(std::get<0>(typeAndLoc), std::get<1>(typeAndLoc));
157 return {arguments.data() + initialSize, arguments.data() + arguments.size()};
161 assert(index <= arguments.size() &&
"invalid insertion index");
163 auto arg = BlockArgument::create(type,
this, index, loc);
164 arguments.insert(arguments.begin() + index, arg);
169 arg.setArgNumber(index++);
177 "cannot insert arguments to blocks with predecessors");
182 assert(index < arguments.size());
183 arguments[index].destroy();
184 arguments.erase(arguments.begin() + index);
186 arg.setArgNumber(index++);
190 assert(start + num <= arguments.size());
191 for (
unsigned i = 0; i < num; ++i)
192 arguments[start + i].destroy();
193 arguments.erase(arguments.begin() + start, arguments.begin() + start + num);
195 arg.setArgNumber(start++);
204 auto firstDead = llvm::find_if(arguments, shouldEraseFn);
205 if (firstDead == arguments.end())
210 unsigned index = firstDead->getArgNumber();
211 firstDead->destroy();
214 for (
auto it = std::next(firstDead), e = arguments.end(); it != e; ++it) {
216 if (shouldEraseFn(*it)) {
219 it->setArgNumber(index++);
223 arguments.erase(firstDead, arguments.end());
233 assert(!
empty() &&
back().mightHaveTrait<OpTrait::IsTerminator>());
257 auto *firstPred = *it;
259 return it ==
pred_end() ? firstPred :
nullptr;
270 auto *firstPred = *it;
271 for (++it; it != e; ++it)
272 if (*it != firstPred)
294 auto *newBB =
new Block();
299 newBB->getOperations().splice(newBB->end(),
getOperations(), splitBefore,
314 return I->getOperandNumber();
324 if (block->
empty() || llvm::hasSingleElement(*block->
getParent()))
341 if ((count = blocks.size()))
342 base = blocks.data();
346 :
BlockRange(successors.begin().getBase(), successors.size()) {}
350 if (
auto *operand =
object.dyn_cast<BlockOperand *>())
351 return {operand + index};
352 return {
object.dyn_cast<
Block *
const *>() + index};
356 Block *BlockRange::dereference_iterator(OwnerT
object, ptrdiff_t index) {
357 if (
const auto *operand =
object.dyn_cast<BlockOperand *>())
358 return operand[index].get();
359 return object.dyn_cast<
Block *
const *>()[index];
This class represents an argument of a Block.
unsigned getArgNumber() const
Returns the number of this argument.
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.
BlockRange(ArrayRef< Block * > blocks=std::nullopt)
Block represents an ordered list of Operations.
void recomputeOpOrder()
Recomputes the ordering of child operations within the block.
OpListType::iterator iterator
Operation * findAncestorOpInBlock(Operation &op)
Returns 'op' if 'op' lies in this block, or otherwise finds the ancestor operation of 'op' that lies ...
ValueTypeRange< BlockArgListType > getArgumentTypes()
Return a range containing the types of the arguments for this block.
unsigned getNumSuccessors()
void erase()
Unlink this Block from its parent region and delete it.
BlockArgument insertArgument(args_iterator it, Type type, Location loc)
Insert one value to the position in the argument list indicated by the given iterator.
iterator_range< args_iterator > addArguments(TypeRange types, ArrayRef< Location > locs)
Add one argument to the argument list for each type specified in the list.
Block * splitBlock(iterator splitBefore)
Split the block into two blocks before the specified operation or iterator.
Region * getParent() const
Provide a 'getParent' method for ilist_node_with_parent methods.
bool isOpOrderValid()
Returns true if the ordering of the child operations is valid, false otherwise.
pred_iterator pred_begin()
void dropAllDefinedValueUses()
This drops all uses of values defined in this block or in the blocks of nested regions wherever the u...
bool verifyOpOrder()
Verifies the current ordering of child operations matches the validOpOrder flag.
void invalidateOpOrder()
Invalidates the current ordering of operations.
Block * getSinglePredecessor()
If this block has exactly one predecessor, return it.
Operation * getTerminator()
Get the terminator operation of this block.
iterator_range< pred_iterator > getPredecessors()
BlockArgument addArgument(Type type, Location loc)
Add one value to the argument list.
void eraseArguments(unsigned start, unsigned num)
Erases 'num' arguments from the index 'start'.
OpListType & getOperations()
BlockArgListType getArguments()
Block * getUniquePredecessor()
If this block has a unique predecessor, i.e., all incoming edges originate from one block,...
void eraseArgument(unsigned index)
Erase the argument at 'index' and remove it from the argument list.
Block * getSuccessor(unsigned i)
bool isEntryBlock()
Return if this block is the entry block in the parent region.
void dropAllReferences()
This drops all operand uses from operations within this block, which is an essential step in breaking...
void insertBefore(Block *block)
Insert this block (which must not already be in a region) right before the specified block.
void moveBefore(Block *block)
Unlink this block from its current region and insert it right before the specific block.
Operation * getParentOp()
Returns the closest surrounding operation that contains this block.
BlockArgListType::iterator args_iterator
void dropAllUses()
Drop all uses of this object from their respective owners.
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
Operation is the basic unit of execution within MLIR.
Block * getSuccessor(unsigned index)
unsigned getNumSuccessors()
void dropAllReferences()
This drops all operand uses from this operation, which is an essential step in breaking cyclic depend...
Operation * getParentOp()
Returns the closest surrounding operation that contains this operation or nullptr if this is a top-le...
Block * getBlock()
Returns the operation block that contains this operation.
MutableArrayRef< BlockOperand > getBlockOperands()
unsigned getSuccessorIndex() const
Get the successor number in the predecessor terminator.
This class contains a list of basic blocks and a link to the parent operation it is attached to.
Operation * getParentOp()
Return the parent operation this region is attached to.
BlockListType & getBlocks()
BlockListType::iterator iterator
This class implements the successor iterators for Block.
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 implements iteration on the types of a given range of values.
Operation * getOwner() const
Return the owner of this operand.
This header declares functions that assit transformations in the MemRef dialect.