RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-04-03 22:01:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Change stripAndComputeConstantOffsets to accept a NULL DataLayout pointer

Browse Source 
as well.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@174030 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dan Gohman 2013-01-31 02:50:36 +00:00
parent 819f9d6bf9
commit 3e3de565e9
1 changed files with 15 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
lib/Analysis/InstructionSimplify.cpp
View File

@ -667,11 +667,16 @@ Value *llvm::SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
/// This is very similar to GetPointerBaseWithConstantOffset except it doesn't /// This is very similar to GetPointerBaseWithConstantOffset except it doesn't
/// follow non-inbounds geps. This allows it to remain usable for icmp ult/etc. /// follow non-inbounds geps. This allows it to remain usable for icmp ult/etc.
/// folding. /// folding.
static Constant *stripAndComputeConstantOffsets(const DataLayout &TD, static Constant *stripAndComputeConstantOffsets(const DataLayout *TD,
Value *&V) { Value *&V) {
assert(V->getType()->isPointerTy()); assert(V->getType()->isPointerTy());
unsigned IntPtrWidth = TD.getPointerSizeInBits(); // Without DataLayout, just be conservative for now. Theoretically, more could
// be done in this case.
if (!TD)
return ConstantInt::get(IntegerType::get(V->getContext(), 64), 0);
unsigned IntPtrWidth = TD->getPointerSizeInBits();
APInt Offset = APInt::getNullValue(IntPtrWidth); APInt Offset = APInt::getNullValue(IntPtrWidth);
// Even though we don't look through PHI nodes, we could be called on an // Even though we don't look through PHI nodes, we could be called on an
@ -680,7 +685,7 @@ static Constant *stripAndComputeConstantOffsets(const DataLayout &TD,
Visited.insert(V); Visited.insert(V);
do { do {
if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) { if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
if (!GEP->isInBounds() || !GEP->accumulateConstantOffset(TD, Offset)) if (!GEP->isInBounds() || !GEP->accumulateConstantOffset(*TD, Offset))
break; break;
V = GEP->getPointerOperand(); V = GEP->getPointerOperand();
} else if (Operator::getOpcode(V) == Instruction::BitCast) { } else if (Operator::getOpcode(V) == Instruction::BitCast) {
@ -695,13 +700,13 @@ static Constant *stripAndComputeConstantOffsets(const DataLayout &TD,
assert(V->getType()->isPointerTy() && "Unexpected operand type!"); assert(V->getType()->isPointerTy() && "Unexpected operand type!");
} while (Visited.insert(V)); } while (Visited.insert(V));
Type *IntPtrTy = TD.getIntPtrType(V->getContext()); Type *IntPtrTy = TD->getIntPtrType(V->getContext());
return ConstantInt::get(IntPtrTy, Offset); return ConstantInt::get(IntPtrTy, Offset);
} }
/// \brief Compute the constant difference between two pointer values. /// \brief Compute the constant difference between two pointer values.
/// If the difference is not a constant, returns zero. /// If the difference is not a constant, returns zero.
static Constant *computePointerDifference(const DataLayout &TD, static Constant *computePointerDifference(const DataLayout *TD,
Value *LHS, Value *RHS) { Value *LHS, Value *RHS) {
Constant *LHSOffset = stripAndComputeConstantOffsets(TD, LHS); Constant *LHSOffset = stripAndComputeConstantOffsets(TD, LHS);
Constant *RHSOffset = stripAndComputeConstantOffsets(TD, RHS); Constant *RHSOffset = stripAndComputeConstantOffsets(TD, RHS);
@ -818,9 +823,9 @@ static Value *SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
return W; return W;
// Variations on GEP(base, I, ...) - GEP(base, i, ...) -> GEP(null, I-i, ...). // Variations on GEP(base, I, ...) - GEP(base, i, ...) -> GEP(null, I-i, ...).
if (Q.TD && match(Op0, m_PtrToInt(m_Value(X))) && if (match(Op0, m_PtrToInt(m_Value(X))) &&
match(Op1, m_PtrToInt(m_Value(Y)))) match(Op1, m_PtrToInt(m_Value(Y))))
if (Constant *Result = computePointerDifference(*Q.TD, X, Y)) if (Constant *Result = computePointerDifference(Q.TD, X, Y))
return ConstantExpr::getIntegerCast(Result, Op0->getType(), true); return ConstantExpr::getIntegerCast(Result, Op0->getType(), true);
// Mul distributes over Sub. Try some generic simplifications based on this. // Mul distributes over Sub. Try some generic simplifications based on this.
@ -1683,7 +1688,7 @@ static Value *ExtractEquivalentCondition(Value *V, CmpInst::Predicate Pred,
return 0; return 0;
} }
static Constant *computePointerICmp(const DataLayout &TD, static Constant *computePointerICmp(const DataLayout *TD,
CmpInst::Predicate Pred, CmpInst::Predicate Pred,
Value *LHS, Value *RHS) { Value *LHS, Value *RHS) {
// We can only fold certain predicates on pointer comparisons. // We can only fold certain predicates on pointer comparisons.
@ -2463,8 +2468,8 @@ static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
// Simplify comparisons of related pointers using a powerful, recursive // Simplify comparisons of related pointers using a powerful, recursive
// GEP-walk when we have target data available.. // GEP-walk when we have target data available..
if (Q.TD && LHS->getType()->isPointerTy()) if (LHS->getType()->isPointerTy())
if (Constant *C = computePointerICmp(*Q.TD, Pred, LHS, RHS)) if (Constant *C = computePointerICmp(Q.TD, Pred, LHS, RHS))
return C; return C;
if (GetElementPtrInst *GLHS = dyn_cast<GetElementPtrInst>(LHS)) { if (GetElementPtrInst *GLHS = dyn_cast<GetElementPtrInst>(LHS)) {