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");
46 assert(!
getParent() &&
"already inserted into a block!");
47 assert(block->
getParent() &&
"cannot insert before a block without a parent");
54 assert(block->
getParent() &&
"cannot insert before a block without a parent");
66 assert(
getParent() &&
"Block has no parent");
77 while (currOp->getBlock() !=
this) {
96 for (
auto &op : *
this)
109 parentValidOpOrderPair.setInt(
false);
119 if (operations.empty() || std::next(operations.begin()) == operations.end())
123 for (
auto &i : *
this) {
126 if (prev && prev->orderIndex != Operation::kInvalidOrderIdx &&
127 prev->orderIndex >= i.orderIndex)
136 parentValidOpOrderPair.setInt(
true);
138 unsigned orderIndex = 0;
139 for (
auto &op : *
this)
140 op.orderIndex = (orderIndex += Operation::kOrderStride);
153 BlockArgument arg = BlockArgument::create(type,
this, arguments.size(), loc);
154 arguments.push_back(arg);
161 assert(types.size() == locs.size() &&
162 "incorrect number of block argument locations");
163 size_t initialSize = arguments.size();
164 arguments.reserve(initialSize + types.size());
166 for (
auto typeAndLoc : llvm::zip(types, locs))
167 addArgument(std::get<0>(typeAndLoc), std::get<1>(typeAndLoc));
168 return {arguments.data() + initialSize, arguments.data() + arguments.size()};
172 assert(index <= arguments.size() &&
"invalid insertion index");
174 auto arg = BlockArgument::create(type,
this, index, loc);
175 arguments.insert(arguments.begin() + index, arg);
180 arg.setArgNumber(index++);
188 "cannot insert arguments to blocks with predecessors");
193 assert(index < arguments.size());
194 arguments[index].destroy();
195 arguments.erase(arguments.begin() + index);
197 arg.setArgNumber(index++);
201 assert(start + num <= arguments.size());
202 for (
unsigned i = 0; i < num; ++i)
203 arguments[start + i].destroy();
204 arguments.erase(arguments.begin() + start, arguments.begin() + start + num);
206 arg.setArgNumber(start++);
215 auto firstDead = llvm::find_if(arguments, shouldEraseFn);
216 if (firstDead == arguments.end())
221 unsigned index = firstDead->getArgNumber();
222 firstDead->destroy();
225 for (
auto it = std::next(firstDead), e = arguments.end(); it != e; ++it) {
227 if (shouldEraseFn(*it)) {
230 it->setArgNumber(index++);
234 arguments.erase(firstDead, arguments.end());
273 auto *firstPred = *it;
275 return it ==
pred_end() ? firstPred :
nullptr;
286 auto *firstPred = *it;
287 for (++it; it != e; ++it)
288 if (*it != firstPred)
310 auto *newBB =
new Block();
315 newBB->getOperations().splice(newBB->end(),
getOperations(), splitBefore,
330 return I->getOperandNumber();
340 if (block->
empty() || llvm::hasSingleElement(*block->
getParent()))
357 if ((count = blocks.size()))
358 base = blocks.data();
366 if (
auto *operand = llvm::dyn_cast_if_present<BlockOperand *>(
object))
367 return {operand + index};
368 return {llvm::dyn_cast_if_present<Block *const *>(
object) + index};
372 Block *BlockRange::dereference_iterator(OwnerT
object, ptrdiff_t index) {
373 if (
const auto *operand = llvm::dyn_cast_if_present<BlockOperand *>(
object))
374 return operand[index].get();
375 return llvm::dyn_cast_if_present<Block *const *>(
object)[index];
static Value getBase(Value v)
Looks through known "view-like" ops to find the base memref.
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.
void insertAfter(Block *block)
Insert this block (which must not already be in a region) right after the specified block.
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()
bool mightHaveTerminator()
Check whether this block might have a terminator.
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...
This class provides the API for ops that are known to be terminators.
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...
bool mightHaveTrait()
Returns true if the operation might have the provided trait.
void dropAllDefinedValueUses()
Drop uses of all values defined by this operation or its nested regions.
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.
Include the generated interface declarations.