34a35a8b24
Functions are always callable operations and thus every operation implementing the `FunctionOpInterface` also implements the `CallableOpInterface`. The only exception was the FuncOp in the toy example. To make implementation of the `FunctionOpInterface` easier, this commit lets `FunctionOpInterface` inherit from `CallableOpInterface` and merges some of their methods. More precisely, the `CallableOpInterface` has methods to get the argument and result attributes and a method to get the result types of the callable region. These methods are always implemented the same way as their analogues in `FunctionOpInterface` and thus this commit moves all the argument and result attribute handling methods to the callable interface as well as the methods to get the argument and result types. The `FuntionOpInterface` then does not have to declare them as well, but just inherits them from the `CallableOpInterface`. Adding the inheritance relation also required to move the `FunctionOpInterface` from the IR directory to the Interfaces directory since IR should not depend on Interfaces. Reviewed By: jpienaar, springerm Differential Revision: https://reviews.llvm.org/D157988
54 lines
1.7 KiB
C++
54 lines
1.7 KiB
C++
//===- LoopLikeInterface.cpp - Loop-like operations in MLIR ---------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "mlir/Interfaces/LoopLikeInterface.h"
|
|
#include "mlir/Interfaces/FunctionInterfaces.h"
|
|
#include "llvm/ADT/DenseSet.h"
|
|
|
|
using namespace mlir;
|
|
|
|
/// Include the definitions of the loop-like interfaces.
|
|
#include "mlir/Interfaces/LoopLikeInterface.cpp.inc"
|
|
|
|
bool LoopLikeOpInterface::blockIsInLoop(Block *block) {
|
|
Operation *parent = block->getParentOp();
|
|
|
|
// The block could be inside a loop-like operation
|
|
if (isa<LoopLikeOpInterface>(parent) ||
|
|
parent->getParentOfType<LoopLikeOpInterface>())
|
|
return true;
|
|
|
|
// This block might be nested inside another block, which is in a loop
|
|
if (!isa<FunctionOpInterface>(parent))
|
|
if (mlir::Block *parentBlock = parent->getBlock())
|
|
if (blockIsInLoop(parentBlock))
|
|
return true;
|
|
|
|
// Or the block could be inside a control flow graph loop:
|
|
// A block is in a control flow graph loop if it can reach itself in a graph
|
|
// traversal
|
|
DenseSet<Block *> visited;
|
|
SmallVector<Block *> stack;
|
|
stack.push_back(block);
|
|
while (!stack.empty()) {
|
|
Block *current = stack.pop_back_val();
|
|
auto [it, inserted] = visited.insert(current);
|
|
if (!inserted) {
|
|
// loop detected
|
|
if (current == block)
|
|
return true;
|
|
continue;
|
|
}
|
|
|
|
stack.reserve(stack.size() + current->getNumSuccessors());
|
|
for (Block *successor : current->getSuccessors())
|
|
stack.push_back(successor);
|
|
}
|
|
return false;
|
|
}
|