summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 8c4980b)
raw | patch | inline | side by side (parent: 8c4980b)
author | Hans Wennborg <hans@hanshq.net> | |
Tue, 21 Oct 2014 23:49:52 +0000 (23:49 +0000) | ||
committer | Hans Wennborg <hans@hanshq.net> | |
Tue, 21 Oct 2014 23:49:52 +0000 (23:49 +0000) |
This seems to have caused PR21330.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@220349 91177308-0d34-0410-b5e6-96231b3b80d8
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@220349 91177308-0d34-0410-b5e6-96231b3b80d8
index 789176f5f314d5adc76a5977f7e2629614c3981a..d803bf407e64df8015252bf0264177e878c08c7a 100644 (file)
return Insert(Folder.CreateIntCast(VC, DestTy, isSigned), Name);
return Insert(CastInst::CreateIntegerCast(V, DestTy, isSigned), Name);
}
-
- Value *CreateBitOrPointerCast(Value *V, Type *DestTy,
- const Twine &Name = "") {
- if (V->getType() == DestTy)
- return V;
- if (V->getType()->isPointerTy() && DestTy->isIntegerTy())
- return CreatePtrToInt(V, DestTy, Name);
- if (V->getType()->isIntegerTy() && DestTy->isPointerTy())
- return CreateIntToPtr(V, DestTy, Name);
-
- return CreateBitCast(V, DestTy, Name);
- }
private:
// \brief Provided to resolve 'CreateIntCast(Ptr, Ptr, "...")', giving a
// compile time error, instead of converting the string to bool for the
index 118685778491dde067bb65244b4729cb7cf411e3..7e98fe18bb6decc96de0e0cfa56e3a290cebb270 100644 (file)
Instruction *InsertBefore = 0 ///< Place to insert the instruction
);
- /// @brief Create a BitCast, a PtrToInt, or an IntToPTr cast instruction.
- ///
- /// If the value is a pointer type and the destination an integer type,
- /// creates a PtrToInt cast. If the value is an integer type and the
- /// destination a pointer type, creates an IntToPtr cast. Otherwise, creates
- /// a bitcast.
- static CastInst *CreateBitOrPointerCast(
- Value *S, ///< The pointer value to be casted (operand 0)
- Type *Ty, ///< The type to which cast should be made
- const Twine &Name = "", ///< Name for the instruction
- Instruction *InsertBefore = 0 ///< Place to insert the instruction
- );
-
/// @brief Create a ZExt, BitCast, or Trunc for int -> int casts.
static CastInst *CreateIntegerCast(
Value *S, ///< The pointer value to be casted (operand 0)
Type *DestTy ///< The Type to which the value should be cast.
);
- /// @brief Check whether a bitcast, inttoptr, or ptrtoint cast between these
- /// types is valid and a no-op.
- ///
- /// This ensures that any pointer<->integer cast has enough bits in the
- /// integer and any other cast is a bitcast.
- static bool isBitOrNoopPointerCastable(
- Type *SrcTy, ///< The Type from which the value should be cast.
- Type *DestTy, ///< The Type to which the value should be cast.
- const DataLayout *Layout = 0 ///< Optional DataLayout.
- );
-
/// Returns the opcode necessary to cast Val into Ty using usual casting
/// rules.
/// @brief Infer the opcode for cast operand and type
diff --git a/lib/Analysis/Loads.cpp b/lib/Analysis/Loads.cpp
index 5042eb9777ac9fbb9dd1f550c69cdcb619a9d027..bb0d60e263e82621e0cf9a039642c2fe49a9dda8 100644 (file)
--- a/lib/Analysis/Loads.cpp
+++ b/lib/Analysis/Loads.cpp
Type *AccessTy = cast<PointerType>(Ptr->getType())->getElementType();
- // Try to get the DataLayout for this module. This may be null, in which case
- // the optimizations will be limited.
- const DataLayout *DL = ScanBB->getDataLayout();
-
- // Try to get the store size for the type.
- uint64_t AccessSize = DL ? DL->getTypeStoreSize(AccessTy)
- : AA ? AA->getTypeStoreSize(AccessTy) : 0;
+ // If we're using alias analysis to disambiguate get the size of *Ptr.
+ uint64_t AccessSize = AA ? AA->getTypeStoreSize(AccessTy) : 0;
Value *StrippedPtr = Ptr->stripPointerCasts();
if (LoadInst *LI = dyn_cast<LoadInst>(Inst))
if (AreEquivalentAddressValues(
LI->getPointerOperand()->stripPointerCasts(), StrippedPtr) &&
- CastInst::isBitOrNoopPointerCastable(LI->getType(), AccessTy, DL)) {
+ CastInst::isBitCastable(LI->getType(), AccessTy)) {
if (AATags)
LI->getAAMetadata(*AATags);
return LI;
// (This is true even if the store is volatile or atomic, although
// those cases are unlikely.)
if (AreEquivalentAddressValues(StorePtr, StrippedPtr) &&
- CastInst::isBitOrNoopPointerCastable(SI->getValueOperand()->getType(),
- AccessTy, DL)) {
+ CastInst::isBitCastable(SI->getValueOperand()->getType(), AccessTy)) {
if (AATags)
SI->getAAMetadata(*AATags);
return SI->getOperand(0);
index 9da0eb4a0d621e72c257530bc92d4b4ecda80aa5..1497aa885c531794dbeb110cb956d2e7191ac332 100644 (file)
--- a/lib/IR/Instructions.cpp
+++ b/lib/IR/Instructions.cpp
return Create(Instruction::BitCast, S, Ty, Name, InsertBefore);
}
-CastInst *CastInst::CreateBitOrPointerCast(Value *S, Type *Ty,
- const Twine &Name,
- Instruction *InsertBefore) {
- if (S->getType()->isPointerTy() && Ty->isIntegerTy())
- return Create(Instruction::PtrToInt, S, Ty, Name, InsertBefore);
- if (S->getType()->isIntegerTy() && Ty->isPointerTy())
- return Create(Instruction::IntToPtr, S, Ty, Name, InsertBefore);
-
- return Create(Instruction::BitCast, S, Ty, Name, InsertBefore);
-}
-
CastInst *CastInst::CreateIntegerCast(Value *C, Type *Ty,
bool isSigned, const Twine &Name,
Instruction *InsertBefore) {
return true;
}
-bool CastInst::isBitOrNoopPointerCastable(Type *SrcTy, Type *DestTy,
- const DataLayout *DL) {
- if (auto *PtrTy = dyn_cast<PointerType>(SrcTy))
- if (auto *IntTy = dyn_cast<IntegerType>(DestTy))
- return DL && IntTy->getBitWidth() >= DL->getPointerTypeSizeInBits(PtrTy);
- if (auto *PtrTy = dyn_cast<PointerType>(DestTy))
- if (auto *IntTy = dyn_cast<IntegerType>(SrcTy))
- return DL && IntTy->getBitWidth() >= DL->getPointerTypeSizeInBits(PtrTy);
-
- return isBitCastable(SrcTy, DestTy);
-}
-
// Provide a way to get a "cast" where the cast opcode is inferred from the
// types and size of the operand. This, basically, is a parallel of the
// logic in the castIsValid function below. This axiom should hold:
diff --git a/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp b/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
index c0df914cb669b6c4cc58bcb19a14d9efb17e1cd1..f3ac44cbd6bcc06075b07fb26682ec2391a0f102 100644 (file)
BasicBlock::iterator BBI = &LI;
if (Value *AvailableVal = FindAvailableLoadedValue(Op, LI.getParent(), BBI,6))
return ReplaceInstUsesWith(
- LI, Builder->CreateBitOrPointerCast(AvailableVal, LI.getType(),
- LI.getName() + ".cast"));
+ LI, Builder->CreateBitCast(AvailableVal, LI.getType()));
// load(gep null, ...) -> unreachable
if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(Op)) {
index c37a4c91c66a18c21124793b0ba08633b32273c2..25a8b0cdbd39f7bd2a99efb8a741c7acbfa6f7fb 100644 (file)
// only happen in dead loops.
if (AvailableVal == LI) AvailableVal = UndefValue::get(LI->getType());
if (AvailableVal->getType() != LI->getType())
- AvailableVal =
- CastInst::CreateBitOrPointerCast(AvailableVal, LI->getType(), "", LI);
+ AvailableVal = CastInst::Create(CastInst::BitCast, AvailableVal,
+ LI->getType(), "", LI);
LI->replaceAllUsesWith(AvailableVal);
LI->eraseFromParent();
return true;
// predecessor use the same bitcast.
Value *&PredV = I->second;
if (PredV->getType() != LI->getType())
- PredV = CastInst::CreateBitOrPointerCast(PredV, LI->getType(), "",
- P->getTerminator());
+ PredV = CastInst::Create(CastInst::BitCast, PredV, LI->getType(), "",
+ P->getTerminator());
PN->addIncoming(PredV, I->first);
}
index 9c8286b9b1b8f818fd04543631f5976159dd4b57..6cf9f0f6b4d692b696c2bb9e3868512922e380e0 100644 (file)
ret i32 %v
}
-declare void @scribble_on_i32(i32*)
+declare void @scribble_on_memory(i32*)
define i32 @test77(i1 %flag, i32* %x) {
; The load here must not be speculated around the select. One side of the
; load does.
; CHECK-LABEL: @test77(
; CHECK: %[[A:.*]] = alloca i32, align 1
-; CHECK: call void @scribble_on_i32(i32* %[[A]])
+; CHECK: call void @scribble_on_memory(i32* %[[A]])
; CHECK: store i32 0, i32* %x
; CHECK: %[[P:.*]] = select i1 %flag, i32* %[[A]], i32* %x
; CHECK: load i32* %[[P]]
%under_aligned = alloca i32, align 1
- call void @scribble_on_i32(i32* %under_aligned)
+ call void @scribble_on_memory(i32* %under_aligned)
store i32 0, i32* %x
%p = select i1 %flag, i32* %under_aligned, i32* %x
%v = load i32* %p
entry:
%x = alloca i32
%y = alloca i32
- call void @scribble_on_i32(i32* %x)
- call void @scribble_on_i32(i32* %y)
+ call void @scribble_on_memory(i32* %x)
+ call void @scribble_on_memory(i32* %y)
%tmp = load i32* %x
store i32 %tmp, i32* %y
%p = select i1 %flag, i32* %x, i32* %y
%y = alloca i32
%x1 = bitcast float* %x to i32*
%y1 = bitcast i32* %y to float*
- call void @scribble_on_i32(i32* %x1)
- call void @scribble_on_i32(i32* %y)
+ call void @scribble_on_memory(i32* %x1)
+ call void @scribble_on_memory(i32* %y)
%tmp = load i32* %x1
store i32 %tmp, i32* %y
%p = select i1 %flag, float* %x, float* %y1
%y = alloca i32
%x1 = bitcast float* %x to i32*
%y1 = bitcast i32* %y to float*
- call void @scribble_on_i32(i32* %x1)
- call void @scribble_on_i32(i32* %y)
+ call void @scribble_on_memory(i32* %x1)
+ call void @scribble_on_memory(i32* %y)
%tmp = load float* %x
store float %tmp, float* %y1
%p = select i1 %flag, i32* %x1, i32* %y
%v = load i32* %p
ret i32 %v
}
-
-declare void @scribble_on_i64(i64*)
-
-define i8* @test83(i1 %flag) {
-; Test that we can speculate the load around the select even though they use
-; differently typed pointers and requires inttoptr casts.
-; CHECK-LABEL: @test83(
-; CHECK: %[[X:.*]] = alloca i8*
-; CHECK-NEXT: %[[Y:.*]] = alloca i8*
-; CHECK: %[[V:.*]] = load i64* %[[X]]
-; CHECK-NEXT: %[[C1:.*]] = inttoptr i64 %[[V]] to i8*
-; CHECK-NEXT: store i8* %[[C1]], i8** %[[Y]]
-; CHECK-NEXT: %[[C2:.*]] = inttoptr i64 %[[V]] to i8*
-; CHECK-NEXT: %[[S:.*]] = select i1 %flag, i8* %[[C2]], i8* %[[C1]]
-; CHECK-NEXT: ret i8* %[[S]]
-entry:
- %x = alloca i8*
- %y = alloca i64
- %x1 = bitcast i8** %x to i64*
- %y1 = bitcast i64* %y to i8**
- call void @scribble_on_i64(i64* %x1)
- call void @scribble_on_i64(i64* %y)
- %tmp = load i64* %x1
- store i64 %tmp, i64* %y
- %p = select i1 %flag, i8** %x, i8** %y1
- %v = load i8** %p
- ret i8* %v
-}
-
-define i64 @test84(i1 %flag) {
-; Test that we can speculate the load around the select even though they use
-; differently typed pointers and requires a ptrtoint cast.
-; CHECK-LABEL: @test84(
-; CHECK: %[[X:.*]] = alloca i8*
-; CHECK-NEXT: %[[Y:.*]] = alloca i8*
-; CHECK: %[[V:.*]] = load i8** %[[X]]
-; CHECK-NEXT: store i8* %[[V]], i8** %[[Y]]
-; CHECK-NEXT: %[[C:.*]] = ptrtoint i8* %[[V]] to i64
-; CHECK-NEXT: ret i64 %[[C]]
-entry:
- %x = alloca i8*
- %y = alloca i64
- %x1 = bitcast i8** %x to i64*
- %y1 = bitcast i64* %y to i8**
- call void @scribble_on_i64(i64* %x1)
- call void @scribble_on_i64(i64* %y)
- %tmp = load i8** %x
- store i8* %tmp, i8** %y1
- %p = select i1 %flag, i64* %x1, i64* %y
- %v = load i64* %p
- ret i64 %v
-}