maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Remove the code which constant-folded ptrtoint(inttoptr(x)+c) to 

getelementptr. Despite only doing so in the case where x is a known
array object and c can be converted to an index within range, this
could still be invalid if c is actually the address of an object
allocated outside of LLVM. Also, SCEVExpander, the original motivation
for this code, has since been improved to avoid inttoptr+ptroint in
more cases.

llvm-svn: 96950
This commit is contained in:
Dan Gohman 2010-02-23 16:35:41 +00:00
parent 26a18ca97f
commit 8a0eb36d23
2 changed files with 5 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
llvm/lib/Analysis/ConstantFolding.cpp
View File

@ -783,44 +783,12 @@ Constant *llvm::ConstantFoldInstOperands(unsigned Opcode, const Type *DestTy,
// If the input is a ptrtoint, turn the pair into a ptr to ptr bitcast if
// the int size is >= the ptr size. This requires knowing the width of a
// pointer, so it can't be done in ConstantExpr::getCast.
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ops[0])) {
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ops[0]))
if (TD &&
TD->getPointerSizeInBits() <=
CE->getType()->getScalarSizeInBits()) {
if (CE->getOpcode() == Instruction::PtrToInt)
return FoldBitCast(CE->getOperand(0), DestTy, *TD);
// If there's a constant offset added to the integer value before
// it is casted back to a pointer, see if the expression can be
// converted into a GEP.
if (CE->getOpcode() == Instruction::Add)
if (ConstantInt *L = dyn_cast<ConstantInt>(CE->getOperand(1)))
if (ConstantExpr *R = dyn_cast<ConstantExpr>(CE->getOperand(0)))
if (R->getOpcode() == Instruction::PtrToInt)
if (GlobalVariable *GV =
dyn_cast<GlobalVariable>(R->getOperand(0))) {
const PointerType *GVTy = cast<PointerType>(GV->getType());
if (const ArrayType *AT =
dyn_cast<ArrayType>(GVTy->getElementType())) {
const Type *ElTy = AT->getElementType();
uint64_t AllocSize = TD->getTypeAllocSize(ElTy);
APInt PSA(L->getValue().getBitWidth(), AllocSize);
if (ElTy == cast<PointerType>(DestTy)->getElementType() &&
L->getValue().urem(PSA) == 0) {
APInt ElemIdx = L->getValue().udiv(PSA);
if (ElemIdx.ult(APInt(ElemIdx.getBitWidth(),
AT->getNumElements()))) {
Constant *Index[] = {
Constant::getNullValue(CE->getType()),
ConstantInt::get(ElTy->getContext(), ElemIdx)
};
return ConstantExpr::getGetElementPtr(GV, &Index[0], 2);
}
}
}
}
}
}
TD->getPointerSizeInBits() <= CE->getType()->getScalarSizeInBits() &&
CE->getOpcode() == Instruction::PtrToInt)
return FoldBitCast(CE->getOperand(0), DestTy, *TD);
return ConstantExpr::getCast(Opcode, Ops[0], DestTy);
case Instruction::Trunc:
case Instruction::ZExt:

27
llvm/test/Transforms/InstCombine/constant-fold-ptr-casts.ll
View File

@ -1,27 +0,0 @@
; RUN: opt < %s -instcombine -S | grep {ret i32 2143034560} | count 2
; Instcombine should be able to completely fold this code.
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i686-apple-darwin8"
@bar = constant [3 x i64] [i64 9220983451228067448, i64 9220983451228067449, i64 9220983450959631991], align 8
define i32 @foo() nounwind {
entry:
%tmp87.2 = load i64* inttoptr (i32 add (i32 16, i32 ptrtoint ([3 x i64]* @bar to i32)) to i64*), align 8
%t0 = bitcast i64 %tmp87.2 to double
%tmp9192.2 = fptrunc double %t0 to float
%t1 = bitcast float %tmp9192.2 to i32
ret i32 %t1
}
define i32 @goo() nounwind {
entry:
%tmp87.2 = load i64* inttoptr (i32 add (i32 ptrtoint ([3 x i64]* @bar to i32), i32 16) to i64*), align 8
%t0 = bitcast i64 %tmp87.2 to double
%tmp9192.2 = fptrunc double %t0 to float
%t1 = bitcast float %tmp9192.2 to i32
ret i32 %t1
}