X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FConstantFold.cpp;h=8234900032cf51917f767bdff286ca2ef384b043;hb=ccf596a53e16ea221a9bf8b3874a7d6afa71f1f4;hp=a7662fd6a25e7819ad39a9ad14b7c2449647fcbd;hpb=daa10a46b2e94e95b3f479cc24ecbbd33fe94c87;p=oota-llvm.git

diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp
index a7662fd6a25..8234900032c 100644
--- a/lib/VMCore/ConstantFold.cpp
+++ b/lib/VMCore/ConstantFold.cpp
@@ -23,6 +23,7 @@
 #include "llvm/Instructions.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Function.h"
+#include "llvm/GlobalAlias.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/GetElementPtrTypeIterator.h"
@@ -68,7 +69,7 @@ static Constant *CastConstantVector(ConstantVector *CV,
         for (unsigned i = 0; i != SrcNumElts; ++i) {
           ConstantInt *CI = cast<ConstantInt>(CV->getOperand(i));
           double V = CI->getValue().bitsToDouble();
-          Result.push_back(ConstantFP::get(Type::DoubleTy, V));
+          Result.push_back(ConstantFP::get(Type::DoubleTy, APFloat(V)));
         }
         return ConstantVector::get(Result);
       }
@@ -76,7 +77,7 @@ static Constant *CastConstantVector(ConstantVector *CV,
       for (unsigned i = 0; i != SrcNumElts; ++i) {
         ConstantInt *CI = cast<ConstantInt>(CV->getOperand(i));
         float V = CI->getValue().bitsToFloat();
-        Result.push_back(ConstantFP::get(Type::FloatTy, V));
+        Result.push_back(ConstantFP::get(Type::FloatTy, APFloat(V)));
       }
       return ConstantVector::get(Result);
     }
@@ -86,8 +87,8 @@ static Constant *CastConstantVector(ConstantVector *CV,
     
     if (SrcEltTy->getTypeID() == Type::DoubleTyID) {
       for (unsigned i = 0; i != SrcNumElts; ++i) {
-        uint64_t V =
-          DoubleToBits(cast<ConstantFP>(CV->getOperand(i))->getValue());
+        uint64_t V = cast<ConstantFP>(CV->getOperand(i))->
+                       getValueAPF().convertToAPInt().getZExtValue();
         Constant *C = ConstantInt::get(Type::Int64Ty, V);
         Result.push_back(ConstantExpr::getBitCast(C, DstEltTy ));
       }
@@ -96,7 +97,8 @@ static Constant *CastConstantVector(ConstantVector *CV,
 
     assert(SrcEltTy->getTypeID() == Type::FloatTyID);
     for (unsigned i = 0; i != SrcNumElts; ++i) {
-      uint32_t V = FloatToBits(cast<ConstantFP>(CV->getOperand(i))->getValue());
+      uint32_t V = (uint32_t)cast<ConstantFP>(CV->getOperand(i))->
+                               getValueAPF().convertToAPInt().getZExtValue();
       Constant *C = ConstantInt::get(Type::Int32Ty, V);
       Result.push_back(ConstantExpr::getBitCast(C, DstEltTy));
     }
@@ -175,20 +177,26 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V,
   switch (opc) {
   case Instruction::FPTrunc:
   case Instruction::FPExt:
-    if (const ConstantFP *FPC = dyn_cast<ConstantFP>(V))
-      return ConstantFP::get(DestTy, FPC->getValue());
-    return 0; // Can't fold.
-  case Instruction::FPToUI: 
     if (const ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
-      uint32_t DestBitWidth = cast<IntegerType>(DestTy)->getBitWidth();
-      APInt Val(APIntOps::RoundDoubleToAPInt(FPC->getValue(), DestBitWidth));
-      return ConstantInt::get(Val);
+      APFloat Val = FPC->getValueAPF();
+      Val.convert(DestTy == Type::FloatTy ? APFloat::IEEEsingle :
+                  DestTy == Type::DoubleTy ? APFloat::IEEEdouble :
+                  DestTy == Type::X86_FP80Ty ? APFloat::x87DoubleExtended :
+                  DestTy == Type::FP128Ty ? APFloat::IEEEquad :
+                  APFloat::Bogus,
+                  APFloat::rmNearestTiesToEven);
+      return ConstantFP::get(DestTy, Val);
     }
     return 0; // Can't fold.
+  case Instruction::FPToUI: 
   case Instruction::FPToSI:
     if (const ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
+      APFloat V = FPC->getValueAPF();
+      uint64_t x[2]; 
       uint32_t DestBitWidth = cast<IntegerType>(DestTy)->getBitWidth();
-      APInt Val(APIntOps::RoundDoubleToAPInt(FPC->getValue(), DestBitWidth));
+      (void) V.convertToInteger(x, DestBitWidth, opc==Instruction::FPToSI,
+                                APFloat::rmTowardZero);
+      APInt Val(DestBitWidth, 2, x);
       return ConstantInt::get(Val);
     }
     return 0; // Can't fold.
@@ -201,12 +209,18 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V,
       return ConstantInt::get(DestTy, 0);
     return 0;                   // Other pointer types cannot be casted
   case Instruction::UIToFP:
-    if (const ConstantInt *CI = dyn_cast<ConstantInt>(V))
-      return ConstantFP::get(DestTy, CI->getValue().roundToDouble());
-    return 0;
   case Instruction::SIToFP:
-    if (const ConstantInt *CI = dyn_cast<ConstantInt>(V))
-      return ConstantFP::get(DestTy, CI->getValue().signedRoundToDouble()); 
+    if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
+      APInt api = CI->getValue();
+      const uint64_t zero[] = {0, 0};
+      uint32_t BitWidth = cast<IntegerType>(SrcTy)->getBitWidth();
+      APFloat apf = APFloat(APInt(DestTy->getPrimitiveSizeInBits(),
+                                  2, zero));
+      (void)apf.convertFromZeroExtendedInteger(api.getRawData(), BitWidth, 
+                                   opc==Instruction::SIToFP,
+                                   APFloat::rmNearestTiesToEven);
+      return ConstantFP::get(DestTy, apf);
+    }
     return 0;
   case Instruction::ZExt:
     if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
@@ -308,10 +322,9 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V,
         return const_cast<Constant*>(V);
 
       if (DestTy->isFloatingPoint()) {
-        if (DestTy == Type::FloatTy)
-          return ConstantFP::get(DestTy, CI->getValue().bitsToFloat());
-        assert(DestTy == Type::DoubleTy && "Unknown FP type!");
-        return ConstantFP::get(DestTy, CI->getValue().bitsToDouble());
+        assert((DestTy == Type::DoubleTy || DestTy == Type::FloatTy) && 
+               "Unknown FP type!");
+        return ConstantFP::get(DestTy, APFloat(CI->getValue()));
       }
       // Otherwise, can't fold this (vector?)
       return 0;
@@ -321,12 +334,10 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V,
     if (const ConstantFP *FP = dyn_cast<ConstantFP>(V)) {
       // FP -> Integral.
       if (DestTy == Type::Int32Ty) {
-        APInt Val(32, 0);
-        return ConstantInt::get(Val.floatToBits(FP->getValue()));
+        return ConstantInt::get(FP->getValueAPF().convertToAPInt());
       } else {
         assert(DestTy == Type::Int64Ty && "only support f32/f64 for now!");
-        APInt Val(64, 0);
-        return ConstantInt::get(Val.doubleToBits(FP->getValue()));
+        return ConstantInt::get(FP->getValueAPF().convertToAPInt());
       }
     }
     return 0;
@@ -660,39 +671,33 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode,
     }
   } else if (const ConstantFP *CFP1 = dyn_cast<ConstantFP>(C1)) {
     if (const ConstantFP *CFP2 = dyn_cast<ConstantFP>(C2)) {
-      double C1Val = CFP1->getValue();
-      double C2Val = CFP2->getValue();
+      APFloat C1V = CFP1->getValueAPF();
+      APFloat C2V = CFP2->getValueAPF();
+      APFloat C3V = C1V;  // copy for modification
+      bool isDouble = CFP1->getType()==Type::DoubleTy;
       switch (Opcode) {
       default:                   
         break;
-      case Instruction::Add: 
-        return ConstantFP::get(CFP1->getType(), C1Val + C2Val);
+      case Instruction::Add:
+        (void)C3V.add(C2V, APFloat::rmNearestTiesToEven);
+        return ConstantFP::get(CFP1->getType(), C3V);
       case Instruction::Sub:     
-        return ConstantFP::get(CFP1->getType(), C1Val - C2Val);
-      case Instruction::Mul:     
-        return ConstantFP::get(CFP1->getType(), C1Val * C2Val);
+        (void)C3V.subtract(C2V, APFloat::rmNearestTiesToEven);
+        return ConstantFP::get(CFP1->getType(), C3V);
+      case Instruction::Mul:
+        (void)C3V.multiply(C2V, APFloat::rmNearestTiesToEven);
+        return ConstantFP::get(CFP1->getType(), C3V);
       case Instruction::FDiv:
-        if (CFP2->isExactlyValue(0.0) || CFP2->isExactlyValue(-0.0))
-          if (CFP1->isExactlyValue(0.0) || CFP1->isExactlyValue(-0.0))
-            // IEEE 754, Section 7.1, #4
-            return ConstantFP::get(CFP1->getType(),
-                                   std::numeric_limits<double>::quiet_NaN());
-          else if (CFP2->isExactlyValue(-0.0) || C1Val < 0.0)
-            // IEEE 754, Section 7.2, negative infinity case
-            return ConstantFP::get(CFP1->getType(),
-                                   -std::numeric_limits<double>::infinity());
-          else
-            // IEEE 754, Section 7.2, positive infinity case
-            return ConstantFP::get(CFP1->getType(),
-                                   std::numeric_limits<double>::infinity());
-        return ConstantFP::get(CFP1->getType(), C1Val / C2Val);
+        (void)C3V.divide(C2V, APFloat::rmNearestTiesToEven);
+        return ConstantFP::get(CFP1->getType(), C3V);
       case Instruction::FRem:
-        if (CFP2->isExactlyValue(0.0) || CFP2->isExactlyValue(-0.0))
+        if (C2V.isZero())
           // IEEE 754, Section 7.1, #5
-          return ConstantFP::get(CFP1->getType(), 
-                                 std::numeric_limits<double>::quiet_NaN());
-        return ConstantFP::get(CFP1->getType(), std::fmod(C1Val, C2Val));
-
+          return ConstantFP::get(CFP1->getType(), isDouble ?
+                            APFloat(std::numeric_limits<double>::quiet_NaN()) :
+                            APFloat(std::numeric_limits<float>::quiet_NaN()));
+        (void)C3V.mod(C2V, APFloat::rmNearestTiesToEven);
+        return ConstantFP::get(CFP1->getType(), C3V);
       }
     }
   } else if (const ConstantVector *CP1 = dyn_cast<ConstantVector>(C1)) {
@@ -915,12 +920,14 @@ static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1,
     // Now we know that the RHS is a GlobalValue or simple constant,
     // which (since the types must match) means that it's a ConstantPointerNull.
     if (const GlobalValue *CPR2 = dyn_cast<GlobalValue>(V2)) {
-      if (!CPR1->hasExternalWeakLinkage() || !CPR2->hasExternalWeakLinkage())
-        return ICmpInst::ICMP_NE;
+      // Don't try to decide equality of aliases.
+      if (!isa<GlobalAlias>(CPR1) && !isa<GlobalAlias>(CPR2))
+        if (!CPR1->hasExternalWeakLinkage() || !CPR2->hasExternalWeakLinkage())
+          return ICmpInst::ICMP_NE;
     } else {
-      // GlobalVals can never be null.
       assert(isa<ConstantPointerNull>(V2) && "Canonicalization guarantee!");
-      if (!CPR1->hasExternalWeakLinkage())
+      // GlobalVals can never be null.  Don't try to evaluate aliases.
+      if (!CPR1->hasExternalWeakLinkage() && !isa<GlobalAlias>(CPR1))
         return ICmpInst::ICMP_NE;
     }
   } else {
@@ -1091,7 +1098,8 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred,
   // icmp eq/ne(null,GV) -> false/true
   if (C1->isNullValue()) {
     if (const GlobalValue *GV = dyn_cast<GlobalValue>(C2))
-      if (!GV->hasExternalWeakLinkage()) // External weak GV can be null
+      // Don't try to evaluate aliases.  External weak GV can be null.
+      if (!isa<GlobalAlias>(GV) && !GV->hasExternalWeakLinkage())
         if (pred == ICmpInst::ICMP_EQ)
           return ConstantInt::getFalse();
         else if (pred == ICmpInst::ICMP_NE)
@@ -1099,7 +1107,8 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred,
   // icmp eq/ne(GV,null) -> false/true
   } else if (C2->isNullValue()) {
     if (const GlobalValue *GV = dyn_cast<GlobalValue>(C1))
-      if (!GV->hasExternalWeakLinkage()) // External weak GV can be null
+      // Don't try to evaluate aliases.  External weak GV can be null.
+      if (!isa<GlobalAlias>(GV) && !GV->hasExternalWeakLinkage())
         if (pred == ICmpInst::ICMP_EQ)
           return ConstantInt::getFalse();
         else if (pred == ICmpInst::ICMP_NE)
@@ -1123,52 +1132,47 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred,
     case ICmpInst::ICMP_UGE:return ConstantInt::get(Type::Int1Ty, V1.uge(V2));
     }
   } else if (isa<ConstantFP>(C1) && isa<ConstantFP>(C2)) {
-    double C1Val = cast<ConstantFP>(C1)->getValue();
-    double C2Val = cast<ConstantFP>(C2)->getValue();
+    APFloat C1V = cast<ConstantFP>(C1)->getValueAPF();
+    APFloat C2V = cast<ConstantFP>(C2)->getValueAPF();
+    APFloat::cmpResult R = C1V.compare(C2V);
     switch (pred) {
     default: assert(0 && "Invalid FCmp Predicate"); return 0;
     case FCmpInst::FCMP_FALSE: return ConstantInt::getFalse();
     case FCmpInst::FCMP_TRUE:  return ConstantInt::getTrue();
     case FCmpInst::FCMP_UNO:
-      return ConstantInt::get(Type::Int1Ty, C1Val != C1Val || C2Val != C2Val);
+      return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered);
     case FCmpInst::FCMP_ORD:
-      return ConstantInt::get(Type::Int1Ty, C1Val == C1Val && C2Val == C2Val);
+      return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpUnordered);
     case FCmpInst::FCMP_UEQ:
-      if (C1Val != C1Val || C2Val != C2Val)
-        return ConstantInt::getTrue();
-      /* FALL THROUGH */
+      return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered ||
+                                            R==APFloat::cmpEqual);
     case FCmpInst::FCMP_OEQ:   
-      return ConstantInt::get(Type::Int1Ty, C1Val == C2Val);
+      return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpEqual);
     case FCmpInst::FCMP_UNE:
-      if (C1Val != C1Val || C2Val != C2Val)
-        return ConstantInt::getTrue();
-      /* FALL THROUGH */
+      return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpEqual);
     case FCmpInst::FCMP_ONE:   
-      return ConstantInt::get(Type::Int1Ty, C1Val != C2Val);
+      return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan ||
+                                            R==APFloat::cmpGreaterThan);
     case FCmpInst::FCMP_ULT: 
-      if (C1Val != C1Val || C2Val != C2Val)
-        return ConstantInt::getTrue();
-      /* FALL THROUGH */
+      return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered ||
+                                            R==APFloat::cmpLessThan);
     case FCmpInst::FCMP_OLT:   
-      return ConstantInt::get(Type::Int1Ty, C1Val < C2Val);
+      return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan);
     case FCmpInst::FCMP_UGT:
-      if (C1Val != C1Val || C2Val != C2Val)
-        return ConstantInt::getTrue();
-      /* FALL THROUGH */
+      return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered ||
+                                            R==APFloat::cmpGreaterThan);
     case FCmpInst::FCMP_OGT:
-      return ConstantInt::get(Type::Int1Ty, C1Val > C2Val);
+      return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpGreaterThan);
     case FCmpInst::FCMP_ULE:
-      if (C1Val != C1Val || C2Val != C2Val)
-        return ConstantInt::getTrue();
-      /* FALL THROUGH */
+      return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpGreaterThan);
     case FCmpInst::FCMP_OLE: 
-      return ConstantInt::get(Type::Int1Ty, C1Val <= C2Val);
+      return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan ||
+                                            R==APFloat::cmpEqual);
     case FCmpInst::FCMP_UGE:
-      if (C1Val != C1Val || C2Val != C2Val)
-        return ConstantInt::getTrue();
-      /* FALL THROUGH */
+      return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpLessThan);
     case FCmpInst::FCMP_OGE: 
-      return ConstantInt::get(Type::Int1Ty, C1Val >= C2Val);
+      return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpGreaterThan ||
+                                            R==APFloat::cmpEqual);
     }
   } else if (const ConstantVector *CP1 = dyn_cast<ConstantVector>(C1)) {
     if (const ConstantVector *CP2 = dyn_cast<ConstantVector>(C2)) {
@@ -1350,7 +1354,7 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred,
 }
 
 Constant *llvm::ConstantFoldGetElementPtr(const Constant *C,
-                                          Constant* const *Idxs, 
+                                          Constant* const *Idxs,
                                           unsigned NumIdx) {
   if (NumIdx == 0 ||
       (NumIdx == 1 && Idxs[0]->isNullValue()))
@@ -1358,7 +1362,8 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C,
 
   if (isa<UndefValue>(C)) {
     const Type *Ty = GetElementPtrInst::getIndexedType(C->getType(),
-                                                       (Value**)Idxs, NumIdx,
+                                                       (Value **)Idxs,
+                                                       (Value **)Idxs+NumIdx,
                                                        true);
     assert(Ty != 0 && "Invalid indices for GEP!");
     return UndefValue::get(PointerType::get(Ty));
@@ -1374,7 +1379,8 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C,
       }
     if (isNull) {
       const Type *Ty = GetElementPtrInst::getIndexedType(C->getType(),
-                                                         (Value**)Idxs, NumIdx,
+                                                         (Value**)Idxs,
+                                                         (Value**)Idxs+NumIdx,
                                                          true);
       assert(Ty != 0 && "Invalid indices for GEP!");
       return ConstantPointerNull::get(PointerType::get(Ty));
@@ -1427,7 +1433,7 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C,
     //                        long 0, long 0)
     // To: int* getelementptr ([3 x int]* %X, long 0, long 0)
     //
-    if (CE->isCast() && NumIdx > 1 && Idx0->isNullValue())
+    if (CE->isCast() && NumIdx > 1 && Idx0->isNullValue()) {
       if (const PointerType *SPT =
           dyn_cast<PointerType>(CE->getOperand(0)->getType()))
         if (const ArrayType *SAT = dyn_cast<ArrayType>(SPT->getElementType()))
@@ -1436,6 +1442,28 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C,
             if (CAT->getElementType() == SAT->getElementType())
               return ConstantExpr::getGetElementPtr(
                       (Constant*)CE->getOperand(0), Idxs, NumIdx);
+    }
+    
+    // Fold: getelementptr (i8* inttoptr (i64 1 to i8*), i32 -1)
+    // Into: inttoptr (i64 0 to i8*)
+    // This happens with pointers to member functions in C++.
+    if (CE->getOpcode() == Instruction::IntToPtr && NumIdx == 1 &&
+        isa<ConstantInt>(CE->getOperand(0)) && isa<ConstantInt>(Idxs[0]) &&
+        cast<PointerType>(CE->getType())->getElementType() == Type::Int8Ty) {
+      Constant *Base = CE->getOperand(0);
+      Constant *Offset = Idxs[0];
+      
+      // Convert the smaller integer to the larger type.
+      if (Offset->getType()->getPrimitiveSizeInBits() < 
+          Base->getType()->getPrimitiveSizeInBits())
+        Offset = ConstantExpr::getSExt(Offset, Base->getType());
+      else if (Base->getType()->getPrimitiveSizeInBits() <
+               Offset->getType()->getPrimitiveSizeInBits())
+        Base = ConstantExpr::getZExt(Base, Base->getType());
+      
+      Base = ConstantExpr::getAdd(Base, Offset);
+      return ConstantExpr::getIntToPtr(Base, CE->getType());
+    }
   }
   return 0;
 }