Change inferred casts to explicit casts.

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

diff --git a/include/llvm/Analysis/ScalarEvolutionExpander.h b/include/llvm/Analysis/ScalarEvolutionExpander.h
index 163d35761c9a9cf1b63249b6dd5b0f1e57ccf3c5..7f0f96f8fe33b87ad109005bf2a1834c9b222723 100644 (file)
--- a/include/llvm/Analysis/ScalarEvolutionExpander.h
+++ b/include/llvm/Analysis/ScalarEvolutionExpander.h
@@ -115,12 +115,18 @@ namespace llvm {
 
     Value *visitTruncateExpr(SCEVTruncateExpr *S) {
       Value *V = expand(S->getOperand());
-      return CastInst::createInferredCast(V, S->getType(), "tmp.", InsertPt);
+      Instruction::CastOps Opcode = (V->getType()->getPrimitiveSizeInBits() ==
+          S->getType()->getPrimitiveSizeInBits()) ? Instruction::BitCast :
+          Instruction::Trunc;
+      return CastInst::create(Opcode, V, S->getType(), "tmp.", InsertPt);
     }
 
     Value *visitZeroExtendExpr(SCEVZeroExtendExpr *S) {
       Value *V = expandInTy(S->getOperand(),S->getType()->getUnsignedVersion());
-      return CastInst::createInferredCast(V, S->getType(), "tmp.", InsertPt);
+      Instruction::CastOps Opcode = (V->getType()->getPrimitiveSizeInBits() ==
+          S->getType()->getPrimitiveSizeInBits()) ? Instruction::BitCast :
+          Instruction::ZExt;
+      return CastInst::create(Opcode, V, S->getType(), "tmp.", InsertPt);
     }
 
     Value *visitAddExpr(SCEVAddExpr *S) {

diff --git a/lib/Analysis/ConstantRange.cpp b/lib/Analysis/ConstantRange.cpp
index 3475c444dc83e2b8c1da5c1c399b597db5ebaf2c..309edb3f50bf0fac7d59495cbae0ac2a0d7de610 100644 (file)
--- a/lib/Analysis/ConstantRange.cpp
+++ b/lib/Analysis/ConstantRange.cpp
@@ -293,14 +293,9 @@ ConstantRange ConstantRange::zeroExtend(const Type *Ty) const {
 
   Constant *Lower = getLower();
   Constant *Upper = getUpper();
-  if (Lower->getType()->isInteger() && !Lower->getType()->isUnsigned()) {
-    // Ensure we are doing a ZERO extension even if the input range is signed.
-    Lower = ConstantExpr::getCast(Lower, Ty->getUnsignedVersion());
-    Upper = ConstantExpr::getCast(Upper, Ty->getUnsignedVersion());
-  }
 
-  return ConstantRange(ConstantExpr::getCast(Lower, Ty),
-                       ConstantExpr::getCast(Upper, Ty));
+  return ConstantRange(ConstantExpr::getCast(Instruction::ZExt, Lower, Ty),
+                       ConstantExpr::getCast(Instruction::ZExt, Upper, Ty));
 }
 
 /// truncate - Return a new range in the specified integer type, which must be
@@ -314,8 +309,9 @@ ConstantRange ConstantRange::truncate(const Type *Ty) const {
   if (isFullSet() || getSetSize() >= Size)
     return ConstantRange(getType());
 
-  return ConstantRange(ConstantExpr::getCast(getLower(), Ty),
-                       ConstantExpr::getCast(getUpper(), Ty));
+  return ConstantRange(
+      ConstantExpr::getCast(Instruction::Trunc, getLower(), Ty),
+      ConstantExpr::getCast(Instruction::Trunc, getUpper(), Ty));
 }
 
 

diff --git a/lib/Support/ConstantRange.cpp b/lib/Support/ConstantRange.cpp
index 3475c444dc83e2b8c1da5c1c399b597db5ebaf2c..309edb3f50bf0fac7d59495cbae0ac2a0d7de610 100644 (file)
--- a/lib/Support/ConstantRange.cpp
+++ b/lib/Support/ConstantRange.cpp
@@ -293,14 +293,9 @@ ConstantRange ConstantRange::zeroExtend(const Type *Ty) const {
 
   Constant *Lower = getLower();
   Constant *Upper = getUpper();
-  if (Lower->getType()->isInteger() && !Lower->getType()->isUnsigned()) {
-    // Ensure we are doing a ZERO extension even if the input range is signed.
-    Lower = ConstantExpr::getCast(Lower, Ty->getUnsignedVersion());
-    Upper = ConstantExpr::getCast(Upper, Ty->getUnsignedVersion());
-  }
 
-  return ConstantRange(ConstantExpr::getCast(Lower, Ty),
-                       ConstantExpr::getCast(Upper, Ty));
+  return ConstantRange(ConstantExpr::getCast(Instruction::ZExt, Lower, Ty),
+                       ConstantExpr::getCast(Instruction::ZExt, Upper, Ty));
 }
 
 /// truncate - Return a new range in the specified integer type, which must be
@@ -314,8 +309,9 @@ ConstantRange ConstantRange::truncate(const Type *Ty) const {
   if (isFullSet() || getSetSize() >= Size)
     return ConstantRange(getType());
 
-  return ConstantRange(ConstantExpr::getCast(getLower(), Ty),
-                       ConstantExpr::getCast(getUpper(), Ty));
+  return ConstantRange(
+      ConstantExpr::getCast(Instruction::Trunc, getLower(), Ty),
+      ConstantExpr::getCast(Instruction::Trunc, getUpper(), Ty));
 }
 
 

diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp
index 49bdca2c5e7ad32c5fd25d55135731773a6d9e75..ef929d7315920ce58de66615bf94b4a918550aba 100644 (file)
--- a/lib/VMCore/ConstantFold.cpp
+++ b/lib/VMCore/ConstantFold.cpp
@@ -777,7 +777,8 @@ static Constant *CastConstantPacked(ConstantPacked *CP,
         uint64_t V =
           DoubleToBits(cast<ConstantFP>(CP->getOperand(i))->getValue());
         Constant *C = ConstantInt::get(Type::ULongTy, V);
-        Result.push_back(ConstantExpr::getCast(C, DstEltTy));
+        Result.push_back(
+            ConstantExpr::getInferredCast(C, false, DstEltTy, false));
       }
       return ConstantPacked::get(Result);
     }
@@ -786,7 +787,8 @@ static Constant *CastConstantPacked(ConstantPacked *CP,
     for (unsigned i = 0; i != SrcNumElts; ++i) {
       uint32_t V = FloatToBits(cast<ConstantFP>(CP->getOperand(i))->getValue());
       Constant *C = ConstantInt::get(Type::UIntTy, V);
-      Result.push_back(ConstantExpr::getCast(C, DstEltTy));
+      Result.push_back(
+        ConstantExpr::getInferredCast(C, false, DstEltTy, false));
     }
     return ConstantPacked::get(Result);
   }
@@ -839,8 +841,7 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V,
   // do to try to simplify it.
   if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
     if (CE->isCast()) {
-      // Try hard to fold cast of cast because they are almost always
-      // eliminable.
+      // Try hard to fold cast of cast because they are often eliminable.
       if (unsigned newOpc = foldConstantCastPair(opc, CE, DestTy))
         return ConstantExpr::getCast(newOpc, CE->getOperand(0), DestTy);
     } else if (CE->getOpcode() == Instruction::GetElementPtr) {
@@ -853,6 +854,7 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V,
           break;
         }
       if (isAllNull)
+        // This is casting one pointer type to another, always BitCast
         return ConstantExpr::getCast(CE->getOperand(0), DestTy);
     }
   }
@@ -1632,9 +1634,13 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C,
         // gep null, C is equal to C*sizeof(nullty).  If nullty is a known llvm
         // type, we can statically fold this.
         Constant *R = ConstantInt::get(Type::UIntTy, ElSize);
-        R = ConstantExpr::getCast(R, Idx0->getType());
-        R = ConstantExpr::getMul(R, Idx0);
-        return ConstantExpr::getCast(R, C->getType());
+        // We know R is unsigned, Idx0 is signed because it must be an index
+        // through a sequential type (gep pointer operand) which is always
+        // signed.
+        R = ConstantExpr::getInferredCast(R, false, Idx0->getType(), true);
+        R = ConstantExpr::getMul(R, Idx0); // signed multiply
+        // R is a signed integer, C is the GEP pointer so -> IntToPtr
+        return ConstantExpr::getCast(Instruction::IntToPtr, R, C->getType());
       }
     }
   }
@@ -1662,11 +1668,16 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C,
         // Otherwise it must be an array.
         if (!Idx0->isNullValue()) {
           const Type *IdxTy = Combined->getType();
-          if (IdxTy != Idx0->getType()) IdxTy = Type::LongTy;
-          Combined =
-            ConstantExpr::get(Instruction::Add,
-                              ConstantExpr::getCast(Idx0, IdxTy),
-                              ConstantExpr::getCast(Combined, IdxTy));
+          if (IdxTy != Idx0->getType()) {
+            Constant *C1 = ConstantExpr::getInferredCast(
+                Idx0, true, Type::LongTy, true);
+            Constant *C2 = ConstantExpr::getInferredCast(
+                Combined, true, Type::LongTy, true);
+            Combined = ConstantExpr::get(Instruction::Add, C1, C2);
+          } else {
+            Combined =
+              ConstantExpr::get(Instruction::Add, Idx0, Combined);
+          }
         }
 
         NewIndices.push_back(Combined);