#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"
if (SrcEltTy->getTypeID() == Type::DoubleTyID) {
for (unsigned i = 0; i != SrcNumElts; ++i) {
- uint64_t V =
- DoubleToBits(cast<ConstantFP>(CV->getOperand(i))->
- getValueAPF().convertToDouble());
+ 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 ));
}
assert(SrcEltTy->getTypeID() == Type::FloatTyID);
for (unsigned i = 0; i != SrcNumElts; ++i) {
- uint32_t V = FloatToBits(cast<ConstantFP>(CV->getOperand(i))->
- getValueAPF().convertToFloat());
+ 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));
}
case Instruction::FPTrunc:
case Instruction::FPExt:
if (const ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
- APFloat Val = FPC->getValueAPF();
- Val.convert(DestTy==Type::FloatTy ? APFloat::IEEEsingle :
- APFloat::IEEEdouble,
+ 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:
- if (const ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
- APFloat V = FPC->getValueAPF();
- bool isDouble = &V.getSemantics()==&APFloat::IEEEdouble;
- uint32_t DestBitWidth = cast<IntegerType>(DestTy)->getBitWidth();
- APInt Val(APIntOps::RoundDoubleToAPInt(isDouble ? V.convertToDouble() :
- (double)V.convertToFloat(), DestBitWidth));
- return ConstantInt::get(Val);
- }
- return 0; // Can't fold.
case Instruction::FPToSI:
if (const ConstantFP *FPC = dyn_cast<ConstantFP>(V)) {
APFloat V = FPC->getValueAPF();
- bool isDouble = &V.getSemantics()==&APFloat::IEEEdouble;
+ uint64_t x[2];
uint32_t DestBitWidth = cast<IntegerType>(DestTy)->getBitWidth();
- APInt Val(APIntOps::RoundDoubleToAPInt(isDouble ? V.convertToDouble() :
- (double)V.convertToFloat(), 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.
return 0; // Other pointer types cannot be casted
case Instruction::UIToFP:
if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
+ double d = CI->getValue().roundToDouble();
if (DestTy==Type::FloatTy)
- return ConstantFP::get(DestTy,
- APFloat((float)CI->getValue().roundToDouble()));
+ return ConstantFP::get(DestTy, APFloat((float)d));
+ else if (DestTy==Type::DoubleTy)
+ return ConstantFP::get(DestTy, APFloat(d));
else
- return ConstantFP::get(DestTy, APFloat(CI->getValue().roundToDouble()));
+ return 0; // FIXME do this for long double
}
return 0;
case Instruction::SIToFP:
double d = CI->getValue().signedRoundToDouble();
if (DestTy==Type::FloatTy)
return ConstantFP::get(DestTy, APFloat((float)d));
- else
+ else if (DestTy==Type::DoubleTy)
return ConstantFP::get(DestTy, APFloat(d));
+ else
+ return 0; // FIXME do this for long double
}
return 0;
case Instruction::ZExt:
return const_cast<Constant*>(V);
if (DestTy->isFloatingPoint()) {
- if (DestTy == Type::FloatTy)
- return ConstantFP::get(DestTy, APFloat(CI->getValue().bitsToFloat()));
- assert(DestTy == Type::DoubleTy && "Unknown FP type!");
- return ConstantFP::get(DestTy, APFloat(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;
if (const ConstantFP *FP = dyn_cast<ConstantFP>(V)) {
// FP -> Integral.
if (DestTy == Type::Int32Ty) {
- APInt Val(32, 0);
- return ConstantInt::get(Val.floatToBits(FP->
- getValueAPF().convertToFloat()));
+ 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->
- getValueAPF().convertToDouble()));
+ return ConstantInt::get(FP->getValueAPF().convertToAPInt());
}
}
return 0;
(void)C3V.multiply(C2V, APFloat::rmNearestTiesToEven);
return ConstantFP::get(CFP1->getType(), C3V);
case Instruction::FDiv:
- // FIXME better to look at the return code
- if (C2V.isZero())
- if (C1V.isZero())
- // IEEE 754, Section 7.1, #4
- return ConstantFP::get(CFP1->getType(), isDouble ?
- APFloat(std::numeric_limits<double>::quiet_NaN()) :
- APFloat(std::numeric_limits<float>::quiet_NaN()));
- else if (C2V.isNegZero() || C1V.isNegative())
- // IEEE 754, Section 7.2, negative infinity case
- return ConstantFP::get(CFP1->getType(), isDouble ?
- APFloat(-std::numeric_limits<double>::infinity()) :
- APFloat(-std::numeric_limits<float>::infinity()));
- else
- // IEEE 754, Section 7.2, positive infinity case
- return ConstantFP::get(CFP1->getType(), isDouble ?
- APFloat(std::numeric_limits<double>::infinity()) :
- APFloat(std::numeric_limits<float>::infinity()));
(void)C3V.divide(C2V, APFloat::rmNearestTiesToEven);
return ConstantFP::get(CFP1->getType(), C3V);
case Instruction::FRem:
// 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 {
// 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)
// 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)