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");
56 block->getIterator(),
getParent()->getBlocks(), getIterator());
61 assert(
getParent() &&
"Block has no parent");
72 while (currOp->getBlock() !=
this) {
91 for (
auto &op : *
this)
104 parentValidOpOrderPair.setInt(
false);
114 if (operations.empty() || std::next(operations.begin()) == operations.end())
118 for (
auto &i : *
this) {
121 if (prev && prev->orderIndex != Operation::kInvalidOrderIdx &&
122 prev->orderIndex >= i.orderIndex)
131 parentValidOpOrderPair.setInt(
true);
133 unsigned orderIndex = 0;
134 for (
auto &op : *
this)
135 op.orderIndex = (orderIndex += Operation::kOrderStride);
148 BlockArgument arg = BlockArgument::create(type,
this, arguments.size(), loc);
149 arguments.push_back(arg);
156 assert(types.size() == locs.size() &&
157 "incorrect number of block argument locations");
158 size_t initialSize = arguments.size();
159 arguments.reserve(initialSize + types.size());
161 for (
auto typeAndLoc : llvm::zip(types, locs))
162 addArgument(std::get<0>(typeAndLoc), std::get<1>(typeAndLoc));
163 return {arguments.data() + initialSize, arguments.data() + arguments.size()};
167 assert(index <= arguments.size() &&
"invalid insertion index");
169 auto arg = BlockArgument::create(type,
this, index, loc);
170 arguments.insert(arguments.begin() + index, arg);
175 arg.setArgNumber(index++);
183 "cannot insert arguments to blocks with predecessors");
188 assert(index < arguments.size());
189 arguments[index].destroy();
190 arguments.erase(arguments.begin() + index);
192 arg.setArgNumber(index++);
196 assert(start + num <= arguments.size());
197 for (
unsigned i = 0; i < num; ++i)
198 arguments[start + i].destroy();
199 arguments.erase(arguments.begin() + start, arguments.begin() + start + num);
201 arg.setArgNumber(start++);
210 auto firstDead = llvm::find_if(arguments, shouldEraseFn);
211 if (firstDead == arguments.end())
216 unsigned index = firstDead->getArgNumber();
217 firstDead->destroy();
220 for (
auto it = std::next(firstDead), e = arguments.end(); it != e; ++it) {
222 if (shouldEraseFn(*it)) {
225 it->setArgNumber(index++);
229 arguments.erase(firstDead, arguments.end());
268 auto *firstPred = *it;
270 return it ==
pred_end() ? firstPred :
nullptr;
281 auto *firstPred = *it;
282 for (++it; it != e; ++it)
283 if (*it != firstPred)
305 auto *newBB =
new Block();
310 newBB->getOperations().splice(newBB->end(),
getOperations(), splitBefore,
325 return I->getOperandNumber();
335 if (block->
empty() || llvm::hasSingleElement(*block->
getParent()))
352 if ((count = blocks.size()))
353 base = blocks.data();
361 if (
auto *operand = llvm::dyn_cast_if_present<BlockOperand *>(
object))
362 return {operand + index};
363 return {llvm::dyn_cast_if_present<Block *const *>(
object) + index};
367 Block *BlockRange::dereference_iterator(OwnerT
object, ptrdiff_t index) {
368 if (
const auto *operand = llvm::dyn_cast_if_present<BlockOperand *>(
object))
369 return operand[index].get();
370 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.