mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-19 02:52:53 +02:00
[SCCP] Follow up of rGbbab9f986c6d. NFC.
This addresses the linter messages, mainly the inconsistent capitalisation of member functions.
This commit is contained in:
Sjoerd Meijer
parent
5e200afae0
commit
57a62b68de
@ -11,8 +11,8 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef LLVM_TRANSFORMS_UTILS_SCCP_SOLVER_H
|
||||
#define LLVM_TRANSFORMS_UTILS_SCCP_SOLVER_H
|
||||
#ifndef LLVM_TRANSFORMS_UTILS_SCCPSOLVER_H
|
||||
#define LLVM_TRANSFORMS_UTILS_SCCPSOLVER_H
|
||||
|
||||
#include "llvm/ADT/MapVector.h"
|
||||
#include "llvm/Analysis/DomTreeUpdater.h"
|
||||
@ -53,25 +53,25 @@ public:
|
||||
|
||||
void addAnalysis(Function &F, AnalysisResultsForFn A);
|
||||
|
||||
/// MarkBlockExecutable - This method can be used by clients to mark all of
|
||||
/// markBlockExecutable - This method can be used by clients to mark all of
|
||||
/// the blocks that are known to be intrinsically live in the processed unit.
|
||||
/// This returns true if the block was not considered live before.
|
||||
bool MarkBlockExecutable(BasicBlock *BB);
|
||||
bool markBlockExecutable(BasicBlock *BB);
|
||||
|
||||
const PredicateBase *getPredicateInfoFor(Instruction *I);
|
||||
|
||||
DomTreeUpdater getDTU(Function &F);
|
||||
|
||||
/// TrackValueOfGlobalVariable - Clients can use this method to
|
||||
/// trackValueOfGlobalVariable - Clients can use this method to
|
||||
/// inform the SCCPSolver that it should track loads and stores to the
|
||||
/// specified global variable if it can. This is only legal to call if
|
||||
/// performing Interprocedural SCCP.
|
||||
void TrackValueOfGlobalVariable(GlobalVariable *GV);
|
||||
void trackValueOfGlobalVariable(GlobalVariable *GV);
|
||||
|
||||
/// AddTrackedFunction - If the SCCP solver is supposed to track calls into
|
||||
/// addTrackedFunction - If the SCCP solver is supposed to track calls into
|
||||
/// and out of the specified function (which cannot have its address taken),
|
||||
/// this method must be called.
|
||||
void AddTrackedFunction(Function *F);
|
||||
void addTrackedFunction(Function *F);
|
||||
|
||||
/// Add function to the list of functions whose return cannot be modified.
|
||||
void addToMustPreserveReturnsInFunctions(Function *F);
|
||||
@ -79,21 +79,21 @@ public:
|
||||
/// Returns true if the return of the given function cannot be modified.
|
||||
bool mustPreserveReturn(Function *F);
|
||||
|
||||
void AddArgumentTrackedFunction(Function *F);
|
||||
void addArgumentTrackedFunction(Function *F);
|
||||
|
||||
/// Returns true if the given function is in the solver's set of
|
||||
/// argument-tracked functions.
|
||||
bool isArgumentTrackedFunction(Function *F);
|
||||
|
||||
/// Solve - Solve for constants and executable blocks.
|
||||
void Solve();
|
||||
void solve();
|
||||
|
||||
/// ResolvedUndefsIn - While solving the dataflow for a function, we assume
|
||||
/// resolvedUndefsIn - While solving the dataflow for a function, we assume
|
||||
/// that branches on undef values cannot reach any of their successors.
|
||||
/// However, this is not a safe assumption. After we solve dataflow, this
|
||||
/// method should be use to handle this. If this returns true, the solver
|
||||
/// should be rerun.
|
||||
bool ResolvedUndefsIn(Function &F);
|
||||
bool resolvedUndefsIn(Function &F);
|
||||
|
||||
bool isBlockExecutable(BasicBlock *BB) const;
|
||||
|
||||
@ -134,4 +134,4 @@ public:
|
||||
|
||||
} // namespace llvm
|
||||
|
||||
#endif // LLVM_TRANSFORMS_UTILS_SCCP_SOLVER_H
|
||||
#endif // LLVM_TRANSFORMS_UTILS_SCCPSOLVER_H
|
||||
|
||||
@ -196,7 +196,7 @@ static bool runSCCP(Function &F, const DataLayout &DL,
|
||||
F.getContext());
|
||||
|
||||
// Mark the first block of the function as being executable.
|
||||
Solver.MarkBlockExecutable(&F.front());
|
||||
Solver.markBlockExecutable(&F.front());
|
||||
|
||||
// Mark all arguments to the function as being overdefined.
|
||||
for (Argument &AI : F.args())
|
||||
@ -205,9 +205,9 @@ static bool runSCCP(Function &F, const DataLayout &DL,
|
||||
// Solve for constants.
|
||||
bool ResolvedUndefs = true;
|
||||
while (ResolvedUndefs) {
|
||||
Solver.Solve();
|
||||
Solver.solve();
|
||||
LLVM_DEBUG(dbgs() << "RESOLVING UNDEFs\n");
|
||||
ResolvedUndefs = Solver.ResolvedUndefsIn(F);
|
||||
ResolvedUndefs = Solver.resolvedUndefsIn(F);
|
||||
}
|
||||
|
||||
bool MadeChanges = false;
|
||||
@ -427,17 +427,17 @@ bool llvm::runIPSCCP(
|
||||
// Determine if we can track the function's return values. If so, add the
|
||||
// function to the solver's set of return-tracked functions.
|
||||
if (canTrackReturnsInterprocedurally(&F))
|
||||
Solver.AddTrackedFunction(&F);
|
||||
Solver.addTrackedFunction(&F);
|
||||
|
||||
// Determine if we can track the function's arguments. If so, add the
|
||||
// function to the solver's set of argument-tracked functions.
|
||||
if (canTrackArgumentsInterprocedurally(&F)) {
|
||||
Solver.AddArgumentTrackedFunction(&F);
|
||||
Solver.addArgumentTrackedFunction(&F);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Assume the function is called.
|
||||
Solver.MarkBlockExecutable(&F.front());
|
||||
Solver.markBlockExecutable(&F.front());
|
||||
|
||||
// Assume nothing about the incoming arguments.
|
||||
for (Argument &AI : F.args())
|
||||
@ -450,21 +450,21 @@ bool llvm::runIPSCCP(
|
||||
for (GlobalVariable &G : M.globals()) {
|
||||
G.removeDeadConstantUsers();
|
||||
if (canTrackGlobalVariableInterprocedurally(&G))
|
||||
Solver.TrackValueOfGlobalVariable(&G);
|
||||
Solver.trackValueOfGlobalVariable(&G);
|
||||
}
|
||||
|
||||
// Solve for constants.
|
||||
bool ResolvedUndefs = true;
|
||||
Solver.Solve();
|
||||
Solver.solve();
|
||||
while (ResolvedUndefs) {
|
||||
LLVM_DEBUG(dbgs() << "RESOLVING UNDEFS\n");
|
||||
ResolvedUndefs = false;
|
||||
for (Function &F : M) {
|
||||
if (Solver.ResolvedUndefsIn(F))
|
||||
if (Solver.resolvedUndefsIn(F))
|
||||
ResolvedUndefs = true;
|
||||
}
|
||||
if (ResolvedUndefs)
|
||||
Solver.Solve();
|
||||
Solver.solve();
|
||||
}
|
||||
|
||||
bool MadeChanges = false;
|
||||
|
||||
@ -12,6 +12,7 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Transforms/Utils/SCCPSolver.h"
|
||||
#include "llvm/Analysis/ConstantFolding.h"
|
||||
#include "llvm/Analysis/InstructionSimplify.h"
|
||||
#include "llvm/Analysis/ValueTracking.h"
|
||||
@ -22,7 +23,6 @@
|
||||
#include "llvm/Support/ErrorHandling.h"
|
||||
#include "llvm/Support/raw_ostream.h"
|
||||
#include "llvm/Transforms/Utils/Local.h"
|
||||
#include "llvm/Transforms/Utils/SCCPSolver.h"
|
||||
#include <cassert>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
@ -231,7 +231,7 @@ private:
|
||||
// OperandChangedState - This method is invoked on all of the users of an
|
||||
// instruction that was just changed state somehow. Based on this
|
||||
// information, we need to update the specified user of this instruction.
|
||||
void OperandChangedState(Instruction *I) {
|
||||
void operandChangedState(Instruction *I) {
|
||||
if (BBExecutable.count(I->getParent())) // Inst is executable?
|
||||
visit(*I);
|
||||
}
|
||||
@ -256,7 +256,7 @@ private:
|
||||
} else {
|
||||
for (User *U : I->users())
|
||||
if (auto *UI = dyn_cast<Instruction>(U))
|
||||
OperandChangedState(UI);
|
||||
operandChangedState(UI);
|
||||
}
|
||||
|
||||
auto Iter = AdditionalUsers.find(I);
|
||||
@ -268,7 +268,7 @@ private:
|
||||
if (auto *UI = dyn_cast<Instruction>(U))
|
||||
ToNotify.push_back(UI);
|
||||
for (Instruction *UI : ToNotify)
|
||||
OperandChangedState(UI);
|
||||
operandChangedState(UI);
|
||||
}
|
||||
}
|
||||
void handleCallOverdefined(CallBase &CB);
|
||||
@ -334,7 +334,7 @@ public:
|
||||
AnalysisResults.insert({&F, std::move(A)});
|
||||
}
|
||||
|
||||
bool MarkBlockExecutable(BasicBlock *BB);
|
||||
bool markBlockExecutable(BasicBlock *BB);
|
||||
|
||||
const PredicateBase *getPredicateInfoFor(Instruction *I) {
|
||||
auto A = AnalysisResults.find(I->getParent()->getParent());
|
||||
@ -354,7 +354,7 @@ public:
|
||||
LLVMContext &Ctx)
|
||||
: DL(DL), GetTLI(GetTLI), Ctx(Ctx) {}
|
||||
|
||||
void TrackValueOfGlobalVariable(GlobalVariable *GV) {
|
||||
void trackValueOfGlobalVariable(GlobalVariable *GV) {
|
||||
// We only track the contents of scalar globals.
|
||||
if (GV->getValueType()->isSingleValueType()) {
|
||||
ValueLatticeElement &IV = TrackedGlobals[GV];
|
||||
@ -363,7 +363,7 @@ public:
|
||||
}
|
||||
}
|
||||
|
||||
void AddTrackedFunction(Function *F) {
|
||||
void addTrackedFunction(Function *F) {
|
||||
// Add an entry, F -> undef.
|
||||
if (auto *STy = dyn_cast<StructType>(F->getReturnType())) {
|
||||
MRVFunctionsTracked.insert(F);
|
||||
@ -382,7 +382,7 @@ public:
|
||||
return MustPreserveReturnsInFunctions.count(F);
|
||||
}
|
||||
|
||||
void AddArgumentTrackedFunction(Function *F) {
|
||||
void addArgumentTrackedFunction(Function *F) {
|
||||
TrackingIncomingArguments.insert(F);
|
||||
}
|
||||
|
||||
@ -390,9 +390,9 @@ public:
|
||||
return TrackingIncomingArguments.count(F);
|
||||
}
|
||||
|
||||
void Solve();
|
||||
void solve();
|
||||
|
||||
bool ResolvedUndefsIn(Function &F);
|
||||
bool resolvedUndefsIn(Function &F);
|
||||
|
||||
bool isBlockExecutable(BasicBlock *BB) const {
|
||||
return BBExecutable.count(BB);
|
||||
@ -451,7 +451,7 @@ public:
|
||||
|
||||
} // namespace llvm
|
||||
|
||||
bool SCCPInstVisitor::MarkBlockExecutable(BasicBlock *BB) {
|
||||
bool SCCPInstVisitor::markBlockExecutable(BasicBlock *BB) {
|
||||
if (!BBExecutable.insert(BB).second)
|
||||
return false;
|
||||
LLVM_DEBUG(dbgs() << "Marking Block Executable: " << BB->getName() << '\n');
|
||||
@ -508,7 +508,7 @@ Constant *SCCPInstVisitor::getConstant(const ValueLatticeElement &LV) const {
|
||||
return LV.getConstant();
|
||||
|
||||
if (LV.isConstantRange()) {
|
||||
auto &CR = LV.getConstantRange();
|
||||
const auto &CR = LV.getConstantRange();
|
||||
if (CR.getSingleElement())
|
||||
return ConstantInt::get(Ctx, *CR.getSingleElement());
|
||||
}
|
||||
@ -538,7 +538,7 @@ bool SCCPInstVisitor::markEdgeExecutable(BasicBlock *Source, BasicBlock *Dest) {
|
||||
if (!KnownFeasibleEdges.insert(Edge(Source, Dest)).second)
|
||||
return false; // This edge is already known to be executable!
|
||||
|
||||
if (!MarkBlockExecutable(Dest)) {
|
||||
if (!markBlockExecutable(Dest)) {
|
||||
// If the destination is already executable, we just made an *edge*
|
||||
// feasible that wasn't before. Revisit the PHI nodes in the block
|
||||
// because they have potentially new operands.
|
||||
@ -806,7 +806,7 @@ void SCCPInstVisitor::visitExtractValueInst(ExtractValueInst &EVI) {
|
||||
if (EVI.getType()->isStructTy())
|
||||
return (void)markOverdefined(&EVI);
|
||||
|
||||
// ResolvedUndefsIn might mark I as overdefined. Bail out, even if we would
|
||||
// resolvedUndefsIn might mark I as overdefined. Bail out, even if we would
|
||||
// discover a concrete value later.
|
||||
if (ValueState[&EVI].isOverdefined())
|
||||
return (void)markOverdefined(&EVI);
|
||||
@ -831,7 +831,7 @@ void SCCPInstVisitor::visitInsertValueInst(InsertValueInst &IVI) {
|
||||
if (!STy)
|
||||
return (void)markOverdefined(&IVI);
|
||||
|
||||
// ResolvedUndefsIn might mark I as overdefined. Bail out, even if we would
|
||||
// resolvedUndefsIn might mark I as overdefined. Bail out, even if we would
|
||||
// discover a concrete value later.
|
||||
if (isOverdefined(ValueState[&IVI]))
|
||||
return (void)markOverdefined(&IVI);
|
||||
@ -870,7 +870,7 @@ void SCCPInstVisitor::visitSelectInst(SelectInst &I) {
|
||||
if (I.getType()->isStructTy())
|
||||
return (void)markOverdefined(&I);
|
||||
|
||||
// ResolvedUndefsIn might mark I as overdefined. Bail out, even if we would
|
||||
// resolvedUndefsIn might mark I as overdefined. Bail out, even if we would
|
||||
// discover a concrete value later.
|
||||
if (ValueState[&I].isOverdefined())
|
||||
return (void)markOverdefined(&I);
|
||||
@ -902,7 +902,7 @@ void SCCPInstVisitor::visitUnaryOperator(Instruction &I) {
|
||||
ValueLatticeElement V0State = getValueState(I.getOperand(0));
|
||||
|
||||
ValueLatticeElement &IV = ValueState[&I];
|
||||
// ResolvedUndefsIn might mark I as overdefined. Bail out, even if we would
|
||||
// resolvedUndefsIn might mark I as overdefined. Bail out, even if we would
|
||||
// discover a concrete value later.
|
||||
if (isOverdefined(IV))
|
||||
return (void)markOverdefined(&I);
|
||||
@ -1087,7 +1087,7 @@ void SCCPInstVisitor::visitLoadInst(LoadInst &I) {
|
||||
if (I.getType()->isStructTy() || I.isVolatile())
|
||||
return (void)markOverdefined(&I);
|
||||
|
||||
// ResolvedUndefsIn might mark I as overdefined. Bail out, even if we would
|
||||
// resolvedUndefsIn might mark I as overdefined. Bail out, even if we would
|
||||
// discover a concrete value later.
|
||||
if (ValueState[&I].isOverdefined())
|
||||
return (void)markOverdefined(&I);
|
||||
@ -1190,7 +1190,7 @@ void SCCPInstVisitor::handleCallArguments(CallBase &CB) {
|
||||
// the formal arguments of the function.
|
||||
if (!TrackingIncomingArguments.empty() &&
|
||||
TrackingIncomingArguments.count(F)) {
|
||||
MarkBlockExecutable(&F->front());
|
||||
markBlockExecutable(&F->front());
|
||||
|
||||
// Propagate information from this call site into the callee.
|
||||
auto CAI = CB.arg_begin();
|
||||
@ -1225,7 +1225,7 @@ void SCCPInstVisitor::handleCallResult(CallBase &CB) {
|
||||
|
||||
Value *CopyOf = CB.getOperand(0);
|
||||
ValueLatticeElement CopyOfVal = getValueState(CopyOf);
|
||||
auto *PI = getPredicateInfoFor(&CB);
|
||||
const auto *PI = getPredicateInfoFor(&CB);
|
||||
assert(PI && "Missing predicate info for ssa.copy");
|
||||
|
||||
const Optional<PredicateConstraint> &Constraint = PI->getConstraint();
|
||||
@ -1347,7 +1347,7 @@ void SCCPInstVisitor::handleCallResult(CallBase &CB) {
|
||||
}
|
||||
}
|
||||
|
||||
void SCCPInstVisitor::Solve() {
|
||||
void SCCPInstVisitor::solve() {
|
||||
// Process the work lists until they are empty!
|
||||
while (!BBWorkList.empty() || !InstWorkList.empty() ||
|
||||
!OverdefinedInstWorkList.empty()) {
|
||||
@ -1398,7 +1398,7 @@ void SCCPInstVisitor::Solve() {
|
||||
}
|
||||
}
|
||||
|
||||
/// ResolvedUndefsIn - While solving the dataflow for a function, we assume
|
||||
/// resolvedUndefsIn - While solving the dataflow for a function, we assume
|
||||
/// that branches on undef values cannot reach any of their successors.
|
||||
/// However, this is not a safe assumption. After we solve dataflow, this
|
||||
/// method should be use to handle this. If this returns true, the solver
|
||||
@ -1414,7 +1414,7 @@ void SCCPInstVisitor::Solve() {
|
||||
///
|
||||
/// This scan also checks for values that use undefs. It conservatively marks
|
||||
/// them as overdefined.
|
||||
bool SCCPInstVisitor::ResolvedUndefsIn(Function &F) {
|
||||
bool SCCPInstVisitor::resolvedUndefsIn(Function &F) {
|
||||
bool MadeChange = false;
|
||||
for (BasicBlock &BB : F) {
|
||||
if (!BBExecutable.count(&BB))
|
||||
@ -1428,7 +1428,7 @@ bool SCCPInstVisitor::ResolvedUndefsIn(Function &F) {
|
||||
if (auto *STy = dyn_cast<StructType>(I.getType())) {
|
||||
// Only a few things that can be structs matter for undef.
|
||||
|
||||
// Tracked calls must never be marked overdefined in ResolvedUndefsIn.
|
||||
// Tracked calls must never be marked overdefined in resolvedUndefsIn.
|
||||
if (auto *CB = dyn_cast<CallBase>(&I))
|
||||
if (Function *F = CB->getCalledFunction())
|
||||
if (MRVFunctionsTracked.count(F))
|
||||
@ -1458,7 +1458,7 @@ bool SCCPInstVisitor::ResolvedUndefsIn(Function &F) {
|
||||
// 1. It could be tracked.
|
||||
// 2. It could be constant-foldable.
|
||||
// Because of the way we solve return values, tracked calls must
|
||||
// never be marked overdefined in ResolvedUndefsIn.
|
||||
// never be marked overdefined in resolvedUndefsIn.
|
||||
if (auto *CB = dyn_cast<CallBase>(&I))
|
||||
if (Function *F = CB->getCalledFunction())
|
||||
if (TrackedRetVals.count(F))
|
||||
@ -1580,8 +1580,8 @@ void SCCPSolver::addAnalysis(Function &F, AnalysisResultsForFn A) {
|
||||
return Visitor->addAnalysis(F, std::move(A));
|
||||
}
|
||||
|
||||
bool SCCPSolver::MarkBlockExecutable(BasicBlock *BB) {
|
||||
return Visitor->MarkBlockExecutable(BB);
|
||||
bool SCCPSolver::markBlockExecutable(BasicBlock *BB) {
|
||||
return Visitor->markBlockExecutable(BB);
|
||||
}
|
||||
|
||||
const PredicateBase *SCCPSolver::getPredicateInfoFor(Instruction *I) {
|
||||
@ -1590,12 +1590,12 @@ const PredicateBase *SCCPSolver::getPredicateInfoFor(Instruction *I) {
|
||||
|
||||
DomTreeUpdater SCCPSolver::getDTU(Function &F) { return Visitor->getDTU(F); }
|
||||
|
||||
void SCCPSolver::TrackValueOfGlobalVariable(GlobalVariable *GV) {
|
||||
Visitor->TrackValueOfGlobalVariable(GV);
|
||||
void SCCPSolver::trackValueOfGlobalVariable(GlobalVariable *GV) {
|
||||
Visitor->trackValueOfGlobalVariable(GV);
|
||||
}
|
||||
|
||||
void SCCPSolver::AddTrackedFunction(Function *F) {
|
||||
Visitor->AddTrackedFunction(F);
|
||||
void SCCPSolver::addTrackedFunction(Function *F) {
|
||||
Visitor->addTrackedFunction(F);
|
||||
}
|
||||
|
||||
void SCCPSolver::addToMustPreserveReturnsInFunctions(Function *F) {
|
||||
@ -1606,18 +1606,18 @@ bool SCCPSolver::mustPreserveReturn(Function *F) {
|
||||
return Visitor->mustPreserveReturn(F);
|
||||
}
|
||||
|
||||
void SCCPSolver::AddArgumentTrackedFunction(Function *F) {
|
||||
Visitor->AddArgumentTrackedFunction(F);
|
||||
void SCCPSolver::addArgumentTrackedFunction(Function *F) {
|
||||
Visitor->addArgumentTrackedFunction(F);
|
||||
}
|
||||
|
||||
bool SCCPSolver::isArgumentTrackedFunction(Function *F) {
|
||||
return Visitor->isArgumentTrackedFunction(F);
|
||||
}
|
||||
|
||||
void SCCPSolver::Solve() { Visitor->Solve(); }
|
||||
void SCCPSolver::solve() { Visitor->solve(); }
|
||||
|
||||
bool SCCPSolver::ResolvedUndefsIn(Function &F) {
|
||||
return Visitor->ResolvedUndefsIn(F);
|
||||
bool SCCPSolver::resolvedUndefsIn(Function &F) {
|
||||
return Visitor->resolvedUndefsIn(F);
|
||||
}
|
||||
|
||||
bool SCCPSolver::isBlockExecutable(BasicBlock *BB) const {
|
||||
|
||||
Loading…
Reference in New Issue
Block a user