RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-12-11 13:37:07 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Fix PR13412, a nasty miscompile due to the interleaved

Browse Source 
instsimplify+inline strategy.

The crux of the problem is that instsimplify was reasonably relying on
an invariant that is true within any single function, but is no longer
true mid-inline the way we use it. This invariant is that an argument
pointer != a local (alloca) pointer.

The fix is really light weight though, and allows instsimplify to be
resiliant to these situations: when checking the relation ships to
function arguments, ensure that the argumets come from the same
function. If they come from different functions, then none of these
assumptions hold. All credit to Benjamin Kramer for coming up with this
clever solution to the problem.

llvm-svn: 161410
This commit is contained in:
Chandler Carruth 2012-08-07 10:59:59 +00:00
parent 49d4e3f282
commit ca6b087618
2 changed files with 79 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
lib/Analysis/InstructionSimplify.cpp
View File

@ -1719,10 +1719,13 @@ static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
return ConstantInt::get(ITy, false);
// A local identified object (alloca or noalias call) can't equal any
// incoming argument, unless they're both null.
if (isa<Instruction>(LHSPtr) && isa<Argument>(RHSPtr) &&
Pred == CmpInst::ICMP_EQ)
return ConstantInt::get(ITy, false);
// incoming argument, unless they're both null or they belong to
// different functions. The latter happens during inlining.
if (Instruction *LHSInst = dyn_cast<Instruction>(LHSPtr))
if (Argument *RHSArg = dyn_cast<Argument>(RHSPtr))
if (LHSInst->getParent()->getParent() == RHSArg->getParent() &&
Pred == CmpInst::ICMP_EQ)
return ConstantInt::get(ITy, false);
}
// Assume that the constant null is on the right.
@ -1732,14 +1735,17 @@ static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
else if (Pred == CmpInst::ICMP_NE)
return ConstantInt::get(ITy, true);
}
} else if (isa<Argument>(LHSPtr)) {
} else if (Argument *LHSArg = dyn_cast<Argument>(LHSPtr)) {
RHSPtr = RHSPtr->stripInBoundsOffsets();
// An alloca can't be equal to an argument.
if (isa<AllocaInst>(RHSPtr)) {
if (Pred == CmpInst::ICMP_EQ)
return ConstantInt::get(ITy, false);
else if (Pred == CmpInst::ICMP_NE)
return ConstantInt::get(ITy, true);
// An alloca can't be equal to an argument unless they come from separate
// functions via inlining.
if (AllocaInst *RHSInst = dyn_cast<AllocaInst>(RHSPtr)) {
if (LHSArg->getParent() == RHSInst->getParent()->getParent()) {
if (Pred == CmpInst::ICMP_EQ)
return ConstantInt::get(ITy, false);
else if (Pred == CmpInst::ICMP_NE)
return ConstantInt::get(ITy, true);
}
}
}

62
test/Transforms/Inline/inline_constprop.ll
View File

@ -110,3 +110,65 @@ bb.merge:
bb.false:
ret i32 %sub
}
define i32 @PR13412.main() {
; This is a somewhat complicated three layer subprogram that was reported to
; compute the wrong value for a branch due to assuming that an argument
; mid-inline couldn't be equal to another pointer.
;
; After inlining, the branch should point directly to the exit block, not to
; the intermediate block.
; CHECK: @PR13412.main
; CHECK: br i1 true, label %[[TRUE_DEST:.*]], label %[[FALSE_DEST:.*]]
; CHECK: [[FALSE_DEST]]:
; CHECK-NEXT: call void @PR13412.fail()
; CHECK: [[TRUE_DEST]]:
; CHECK-NEXT: ret i32 0
entry:
%i1 = alloca i64
store i64 0, i64* %i1
%arraydecay = bitcast i64* %i1 to i32*
%call = call i1 @PR13412.first(i32* %arraydecay, i32* %arraydecay)
br i1 %call, label %cond.end, label %cond.false
cond.false:
call void @PR13412.fail()
br label %cond.end
cond.end:
ret i32 0
}
define internal i1 @PR13412.first(i32* %a, i32* %b) {
entry:
%call = call i32* @PR13412.second(i32* %a, i32* %b)
%cmp = icmp eq i32* %call, %b
ret i1 %cmp
}
declare void @PR13412.fail()
define internal i32* @PR13412.second(i32* %a, i32* %b) {
entry:
%sub.ptr.lhs.cast = ptrtoint i32* %b to i64
%sub.ptr.rhs.cast = ptrtoint i32* %a to i64
%sub.ptr.sub = sub i64 %sub.ptr.lhs.cast, %sub.ptr.rhs.cast
%sub.ptr.div = ashr exact i64 %sub.ptr.sub, 2
%cmp = icmp ugt i64 %sub.ptr.div, 1
br i1 %cmp, label %if.then, label %if.end3
if.then:
%0 = load i32* %a
%1 = load i32* %b
%cmp1 = icmp eq i32 %0, %1
br i1 %cmp1, label %return, label %if.end3
if.end3:
br label %return
return:
%retval.0 = phi i32* [ %b, %if.end3 ], [ %a, %if.then ]
ret i32* %retval.0
}