mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-23 11:13:28 +01:00
055646cac9
moved before another instruction. Summary:Added an API to check if an instruction can be safely moved before another instruction. In future PRs, we will like to add support of moving instructions between blocks that are not control flow equivalent, and add other APIs to enhance usability, e.g. moving basic blocks, moving list of instructions... Loop Fusion will be its first user. When there is intervening code in between two loops, fusion is currently unable to fuse them. Loop Fusion can use this utility to check if the intervening code can be safely moved before or after the two loops, and move them, then it can successfully fuse them. Reviewer:kbarton,jdoerfert,Meinersbur,bmahjour,etiotto Reviewed By:bmahjour Subscribers:mgorny,hiraditya,llvm-commits Tag:LLVM Differential Revision:https://reviews.llvm.org/D70049
121 lines
3.4 KiB
C++
121 lines
3.4 KiB
C++
//=- llvm/Analysis/PostDominators.h - Post Dominator Calculation --*- C++ -*-=//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file exposes interfaces to post dominance information.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_ANALYSIS_POSTDOMINATORS_H
|
|
#define LLVM_ANALYSIS_POSTDOMINATORS_H
|
|
|
|
#include "llvm/ADT/DepthFirstIterator.h"
|
|
#include "llvm/IR/Dominators.h"
|
|
#include "llvm/IR/PassManager.h"
|
|
#include "llvm/Pass.h"
|
|
|
|
namespace llvm {
|
|
|
|
class Function;
|
|
class raw_ostream;
|
|
|
|
/// PostDominatorTree Class - Concrete subclass of DominatorTree that is used to
|
|
/// compute the post-dominator tree.
|
|
class PostDominatorTree : public PostDomTreeBase<BasicBlock> {
|
|
public:
|
|
using Base = PostDomTreeBase<BasicBlock>;
|
|
|
|
PostDominatorTree() = default;
|
|
explicit PostDominatorTree(Function &F) { recalculate(F); }
|
|
/// Handle invalidation explicitly.
|
|
bool invalidate(Function &F, const PreservedAnalyses &PA,
|
|
FunctionAnalysisManager::Invalidator &);
|
|
|
|
// Ensure base-class overloads are visible.
|
|
using Base::dominates;
|
|
|
|
/// Return true if \p I1 dominates \p I2. This checks if \p I2 comes before
|
|
/// \p I1 if they belongs to the same basic block.
|
|
bool dominates(const Instruction *I1, const Instruction *I2) const;
|
|
};
|
|
|
|
/// Analysis pass which computes a \c PostDominatorTree.
|
|
class PostDominatorTreeAnalysis
|
|
: public AnalysisInfoMixin<PostDominatorTreeAnalysis> {
|
|
friend AnalysisInfoMixin<PostDominatorTreeAnalysis>;
|
|
|
|
static AnalysisKey Key;
|
|
|
|
public:
|
|
/// Provide the result type for this analysis pass.
|
|
using Result = PostDominatorTree;
|
|
|
|
/// Run the analysis pass over a function and produce a post dominator
|
|
/// tree.
|
|
PostDominatorTree run(Function &F, FunctionAnalysisManager &);
|
|
};
|
|
|
|
/// Printer pass for the \c PostDominatorTree.
|
|
class PostDominatorTreePrinterPass
|
|
: public PassInfoMixin<PostDominatorTreePrinterPass> {
|
|
raw_ostream &OS;
|
|
|
|
public:
|
|
explicit PostDominatorTreePrinterPass(raw_ostream &OS);
|
|
|
|
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
|
|
};
|
|
|
|
struct PostDominatorTreeWrapperPass : public FunctionPass {
|
|
static char ID; // Pass identification, replacement for typeid
|
|
|
|
PostDominatorTree DT;
|
|
|
|
PostDominatorTreeWrapperPass();
|
|
|
|
PostDominatorTree &getPostDomTree() { return DT; }
|
|
const PostDominatorTree &getPostDomTree() const { return DT; }
|
|
|
|
bool runOnFunction(Function &F) override;
|
|
|
|
void verifyAnalysis() const override;
|
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
|
AU.setPreservesAll();
|
|
}
|
|
|
|
void releaseMemory() override {
|
|
DT.releaseMemory();
|
|
}
|
|
|
|
void print(raw_ostream &OS, const Module*) const override;
|
|
};
|
|
|
|
FunctionPass* createPostDomTree();
|
|
|
|
template <> struct GraphTraits<PostDominatorTree*>
|
|
: public GraphTraits<DomTreeNode*> {
|
|
static NodeRef getEntryNode(PostDominatorTree *DT) {
|
|
return DT->getRootNode();
|
|
}
|
|
|
|
static nodes_iterator nodes_begin(PostDominatorTree *N) {
|
|
if (getEntryNode(N))
|
|
return df_begin(getEntryNode(N));
|
|
else
|
|
return df_end(getEntryNode(N));
|
|
}
|
|
|
|
static nodes_iterator nodes_end(PostDominatorTree *N) {
|
|
return df_end(getEntryNode(N));
|
|
}
|
|
};
|
|
|
|
} // end namespace llvm
|
|
|
|
#endif // LLVM_ANALYSIS_POSTDOMINATORS_H
|