Revert "Teach the load analysis to allow finding available values which require"...

This seems to have caused PR21330.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@220349 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/IR/IRBuilder.h b/include/llvm/IR/IRBuilder.h
index 789176f5f314d5adc76a5977f7e2629614c3981a..d803bf407e64df8015252bf0264177e878c08c7a 100644 (file)
--- a/include/llvm/IR/IRBuilder.h
+++ b/include/llvm/IR/IRBuilder.h
@@ -1246,18 +1246,6 @@ public:
       return Insert(Folder.CreateIntCast(VC, DestTy, isSigned), Name);
     return Insert(CastInst::CreateIntegerCast(V, DestTy, isSigned), Name);
   }
       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
 private:
   // \brief Provided to resolve 'CreateIntCast(Ptr, Ptr, "...")', giving a
   // compile time error, instead of converting the string to bool for the

diff --git a/include/llvm/IR/InstrTypes.h b/include/llvm/IR/InstrTypes.h
index 118685778491dde067bb65244b4729cb7cf411e3..7e98fe18bb6decc96de0e0cfa56e3a290cebb270 100644 (file)
--- a/include/llvm/IR/InstrTypes.h
+++ b/include/llvm/IR/InstrTypes.h
@@ -490,19 +490,6 @@ public:
     Instruction *InsertBefore = 0 ///< Place to insert the instruction
   );
 
     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)
   /// @brief Create a ZExt, BitCast, or Trunc for int -> int casts.
   static CastInst *CreateIntegerCast(
     Value *S,                ///< The pointer value to be casted (operand 0)


@@ -565,17 +552,6 @@ public:
     Type *DestTy ///< The Type to which the value should be cast.
   );
 
     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
   /// 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
@@ -176,13 +176,8 @@ Value *llvm::FindAvailableLoadedValue(Value *Ptr, BasicBlock *ScanBB,
 
   Type *AccessTy = cast<PointerType>(Ptr->getType())->getElementType();
 
 
   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();
 
 
   Value *StrippedPtr = Ptr->stripPointerCasts();
 


@@ -207,7 +202,7 @@ Value *llvm::FindAvailableLoadedValue(Value *Ptr, BasicBlock *ScanBB,
     if (LoadInst *LI = dyn_cast<LoadInst>(Inst))
       if (AreEquivalentAddressValues(
               LI->getPointerOperand()->stripPointerCasts(), StrippedPtr) &&
     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;
         if (AATags)
           LI->getAAMetadata(*AATags);
         return LI;


@@ -219,8 +214,7 @@ Value *llvm::FindAvailableLoadedValue(Value *Ptr, BasicBlock *ScanBB,
       // (This is true even if the store is volatile or atomic, although
       // those cases are unlikely.)
       if (AreEquivalentAddressValues(StorePtr, StrippedPtr) &&
       // (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);
         if (AATags)
           SI->getAAMetadata(*AATags);
         return SI->getOperand(0);

diff --git a/lib/IR/Instructions.cpp b/lib/IR/Instructions.cpp
index 9da0eb4a0d621e72c257530bc92d4b4ecda80aa5..1497aa885c531794dbeb110cb956d2e7191ac332 100644 (file)
--- a/lib/IR/Instructions.cpp
+++ b/lib/IR/Instructions.cpp
@@ -2559,17 +2559,6 @@ CastInst *CastInst::CreatePointerBitCastOrAddrSpaceCast(
   return Create(Instruction::BitCast, S, Ty, Name, InsertBefore);
 }
 
   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) {
 CastInst *CastInst::CreateIntegerCast(Value *C, Type *Ty,
                                       bool isSigned, const Twine &Name,
                                       Instruction *InsertBefore) {


@@ -2727,18 +2716,6 @@ bool CastInst::isBitCastable(Type *SrcTy, Type *DestTy) {
   return true;
 }
 
   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:
 // 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)
--- a/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
+++ b/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
@@ -418,8 +418,7 @@ Instruction *InstCombiner::visitLoadInst(LoadInst &LI) {
   BasicBlock::iterator BBI = &LI;
   if (Value *AvailableVal = FindAvailableLoadedValue(Op, LI.getParent(), BBI,6))
     return ReplaceInstUsesWith(
   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)) {
 
   // load(gep null, ...) -> unreachable
   if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(Op)) {

diff --git a/lib/Transforms/Scalar/JumpThreading.cpp b/lib/Transforms/Scalar/JumpThreading.cpp
index c37a4c91c66a18c21124793b0ba08633b32273c2..25a8b0cdbd39f7bd2a99efb8a741c7acbfa6f7fb 100644 (file)
--- a/lib/Transforms/Scalar/JumpThreading.cpp
+++ b/lib/Transforms/Scalar/JumpThreading.cpp
@@ -902,8 +902,8 @@ bool JumpThreading::SimplifyPartiallyRedundantLoad(LoadInst *LI) {
     // only happen in dead loops.
     if (AvailableVal == LI) AvailableVal = UndefValue::get(LI->getType());
     if (AvailableVal->getType() != LI->getType())
     // 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;
     LI->replaceAllUsesWith(AvailableVal);
     LI->eraseFromParent();
     return true;


@@ -1040,8 +1040,8 @@ bool JumpThreading::SimplifyPartiallyRedundantLoad(LoadInst *LI) {
     // predecessor use the same bitcast.
     Value *&PredV = I->second;
     if (PredV->getType() != LI->getType())
     // 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);
   }
 
     PN->addIncoming(PredV, I->first);
   }

diff --git a/test/Transforms/InstCombine/select.ll b/test/Transforms/InstCombine/select.ll
index 9c8286b9b1b8f818fd04543631f5976159dd4b57..6cf9f0f6b4d692b696c2bb9e3868512922e380e0 100644 (file)
--- a/test/Transforms/InstCombine/select.ll
+++ b/test/Transforms/InstCombine/select.ll
@@ -1256,7 +1256,7 @@ define i32 @test76(i1 %flag, i32* %x) {
   ret i32 %v
 }
 
   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
 
 define i32 @test77(i1 %flag, i32* %x) {
 ; The load here must not be speculated around the select. One side of the


@@ -1264,13 +1264,13 @@ define i32 @test77(i1 %flag, i32* %x) {
 ; load does.
 ; CHECK-LABEL: @test77(
 ; CHECK: %[[A:.*]] = alloca i32, align 1
 ; 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
 ; 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
   store i32 0, i32* %x
   %p = select i1 %flag, i32* %under_aligned, i32* %x
   %v = load i32* %p


@@ -1327,8 +1327,8 @@ define i32 @test80(i1 %flag) {
 entry:
   %x = alloca i32
   %y = alloca i32
 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
   %tmp = load i32* %x
   store i32 %tmp, i32* %y
   %p = select i1 %flag, i32* %x, i32* %y


@@ -1351,8 +1351,8 @@ entry:
   %y = alloca i32
   %x1 = bitcast float* %x to i32*
   %y1 = bitcast i32* %y to float*
   %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
   %tmp = load i32* %x1
   store i32 %tmp, i32* %y
   %p = select i1 %flag, float* %x, float* %y1


@@ -1377,63 +1377,11 @@ entry:
   %y = alloca i32
   %x1 = bitcast float* %x to i32*
   %y1 = bitcast i32* %y to float*
   %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
 }
   %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
-}