6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-26 21:32:10 +00:00
Code Issues Projects Releases Wiki Activity

InstSimplify: stripAndComputeConstantOffsets can be called with vectors of pointers too.

Browse Source 
Prepare it for vectors of pointers and handle simple cases. We don't handle
complicated cases because accumulateConstantOffset bails on pointer vectors.
Fixes selfhost on i386.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@174179 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Benjamin Kramer 2013-02-01 15:21:10 +00:00
parent 84d3239889
commit d9f32c20da
2 changed files with 29 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
lib/Analysis/InstructionSimplify.cpp
View File

@ -667,9 +667,9 @@ Value *llvm::SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
/// This is very similar to GetPointerBaseWithConstantOffset except it doesn't
/// follow non-inbounds geps. This allows it to remain usable for icmp ult/etc.
/// folding.
static ConstantInt *stripAndComputeConstantOffsets(const DataLayout *TD,
static Constant *stripAndComputeConstantOffsets(const DataLayout *TD,
Value *&V) {
assert(V->getType()->isPointerTy());
assert(V->getType()->getScalarType()->isPointerTy());
// Without DataLayout, just be conservative for now. Theoretically, more could
// be done in this case.
@ -697,11 +697,16 @@ static ConstantInt *stripAndComputeConstantOffsets(const DataLayout *TD,
} else {
break;
}
assert(V->getType()->isPointerTy() && "Unexpected operand type!");
assert(V->getType()->getScalarType()->isPointerTy() &&
"Unexpected operand type!");
} while (Visited.insert(V));
Type *IntPtrTy = TD->getIntPtrType(V->getContext());
return cast<ConstantInt>(ConstantInt::get(IntPtrTy, Offset));
Constant *OffsetIntPtr = ConstantInt::get(IntPtrTy, Offset);
if (V->getType()->isVectorTy())
return ConstantVector::getSplat(V->getType()->getVectorNumElements(),
OffsetIntPtr);
return OffsetIntPtr;
}
/// \brief Compute the constant difference between two pointer values.
@ -1758,8 +1763,8 @@ static Constant *computePointerICmp(const DataLayout *TD,
// numerous hazards. AliasAnalysis and its utilities rely on special rules
// governing loads and stores which don't apply to icmps. Also, AliasAnalysis
// doesn't need to guarantee pointer inequality when it says NoAlias.
ConstantInt *LHSOffset = stripAndComputeConstantOffsets(TD, LHS);
ConstantInt *RHSOffset = stripAndComputeConstantOffsets(TD, RHS);
Constant *LHSOffset = stripAndComputeConstantOffsets(TD, LHS);
Constant *RHSOffset = stripAndComputeConstantOffsets(TD, RHS);
// If LHS and RHS are related via constant offsets to the same base
// value, we can replace it with an icmp which just compares the offsets.
@ -1799,11 +1804,14 @@ static Constant *computePointerICmp(const DataLayout *TD,
// address, due to canonicalization and constant folding.
if (isa<AllocaInst>(LHS) &&
(isa<AllocaInst>(RHS) || isa<GlobalVariable>(RHS))) {
ConstantInt *LHSOffsetCI = dyn_cast<ConstantInt>(LHSOffset);
ConstantInt *RHSOffsetCI = dyn_cast<ConstantInt>(RHSOffset);
uint64_t LHSSize, RHSSize;
if (getObjectSize(LHS, LHSSize, TD, TLI) &&
if (LHSOffsetCI && RHSOffsetCI &&
getObjectSize(LHS, LHSSize, TD, TLI) &&
getObjectSize(RHS, RHSSize, TD, TLI)) {
const APInt &LHSOffsetValue = LHSOffset->getValue();
const APInt &RHSOffsetValue = RHSOffset->getValue();
const APInt &LHSOffsetValue = LHSOffsetCI->getValue();
const APInt &RHSOffsetValue = RHSOffsetCI->getValue();
if (!LHSOffsetValue.isNegative() &&
!RHSOffsetValue.isNegative() &&
LHSOffsetValue.ult(LHSSize) &&

11
test/Transforms/InstSimplify/ptr_diff.ll
View File

@ -46,3 +46,14 @@ define i64 @ptrdiff3(i8* %ptr) {
%diff = sub i64 %last.int, %first.int
ret i64 %diff
}
define <4 x i32> @ptrdiff4(<4 x i8*> %arg) nounwind {
; Handle simple cases of vectors of pointers.
; CHECK: @ptrdiff4
; CHECK: ret <4 x i32> zeroinitializer
%p1 = ptrtoint <4 x i8*> %arg to <4 x i32>
%bc = bitcast <4 x i8*> %arg to <4 x i32*>
%p2 = ptrtoint <4 x i32*> %bc to <4 x i32>
%sub = sub <4 x i32> %p1, %p2
ret <4 x i32> %sub
}