6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-11-01 15:11:24 +00:00
Code Issues Projects Releases Wiki Activity

fix an IPSCCP bug I introduced when I changed IPSCCP to start working on

Browse Source 
functions that don't have local linkage.  Basically, we need to be more
careful about propagating argument information to functions whose results
we aren't tracking.  This fixes a miscompilation of 
LLVMCConfigurationEmitter.cpp when built with an llvm-gcc that has ipsccp
enabled.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@85923 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2009-11-03 19:24:51 +00:00
parent 954cb43c80
commit 2396cc37ae
2 changed files with 51 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
lib/Transforms/Scalar/SCCP.cpp
View File

@ -174,6 +174,9 @@ class SCCPSolver : public InstVisitor<SCCPSolver> {
/// that return multiple values.
DenseMap<std::pair<Function*, unsigned>, LatticeVal> TrackedMultipleRetVals;
/// TrackingIncomingArguments - This is the set of functions that are
SmallPtrSet<Function*, 16> TrackingIncomingArguments;
/// The reason for two worklists is that overdefined is the lowest state
/// on the lattice, and moving things to overdefined as fast as possible
/// makes SCCP converge much faster.
@ -235,6 +238,10 @@ public:
TrackedRetVals.insert(std::make_pair(F, LatticeVal()));
}
void AddArgumentTrackedFunction(Function *F) {
TrackingIncomingArguments.insert(F);
}
/// Solve - Solve for constants and executable blocks.
///
void Solve();
@ -1190,6 +1197,27 @@ CallOverdefined:
return markOverdefined(I);
}
// If this is a local function that doesn't have its address taken, mark its
// entry block executable and merge in the actual arguments to the call into
// the formal arguments of the function.
if (!TrackingIncomingArguments.empty() && TrackingIncomingArguments.count(F)){
MarkBlockExecutable(F->begin());
// Propagate information from this call site into the callee.
CallSite::arg_iterator CAI = CS.arg_begin();
for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end();
AI != E; ++AI, ++CAI) {
// If this argument is byval, and if the function is not readonly, there
// will be an implicit copy formed of the input aggregate.
if (AI->hasByValAttr() && !F->onlyReadsMemory()) {
markOverdefined(AI);
continue;
}
mergeInValue(AI, getValueState(*CAI));
}
}
// If this is a single/zero retval case, see if we're tracking the function.
DenseMap<Function*, LatticeVal>::iterator TFRVI = TrackedRetVals.find(F);
if (TFRVI != TrackedRetVals.end()) {
@ -1228,24 +1256,6 @@ CallOverdefined:
// common path above.
goto CallOverdefined;
}
// Finally, if this is the first call to the function hit, mark its entry
// block executable.
MarkBlockExecutable(F->begin());
// Propagate information from this call site into the callee.
CallSite::arg_iterator CAI = CS.arg_begin();
for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end();
AI != E; ++AI, ++CAI) {
// If this argument is byval, and if the function is not readonly, there
// will be an implicit copy formed of the input aggregate.
if (AI->hasByValAttr() && !F->onlyReadsMemory()) {
markOverdefined(AI);
continue;
}
mergeInValue(AI, getValueState(*CAI));
}
}
void SCCPSolver::Solve() {
@ -1656,8 +1666,10 @@ bool IPSCCP::runOnModule(Module &M) {
// If this function only has direct calls that we can see, we can track its
// arguments and return value aggressively, and can assume it is not called
// unless we see evidence to the contrary.
if (F->hasLocalLinkage() && !AddressIsTaken(F))
if (F->hasLocalLinkage() && !AddressIsTaken(F)) {
Solver.AddArgumentTrackedFunction(F);
continue;
}
// Assume the function is called.
Solver.MarkBlockExecutable(F->begin());

20
test/Transforms/SCCP/ipsccp-basic.ll
View File

@ -174,4 +174,24 @@ define i32 @test7b() {
; CHECK-NEXT: ret i32 36
}
;;======================== test8
define internal {} @test8a(i32 %A, i32* %P) {
store i32 %A, i32* %P
ret {} {}
; CHECK: @test8a
; CHECK-NEXT: store i32 5,
; CHECK-NEXT: ret
}
define void @test8b(i32* %P) {
%X = call {} @test8a(i32 5, i32* %P)
ret void
; CHECK: define void @test8b
; CHECK-NEXT: call {} @test8a
; CHECK-NEXT: ret void
}