6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-06 20:32:19 +00:00
Code Issues Projects Releases Wiki Activity

Use the APInt versions of the bit-wise conversions of float/double to int

Browse Source 
and back. While this is not strictly necessary, it does pave the way for
future changes in casting. It should now be possible to improve vector
casting to deal with un-equal fp/int sizes.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@34808 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Reid Spencer 2007-03-01 20:44:23 +00:00
parent 53ee4f9d40
commit 0d54b7df4f
1 changed files with 10 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
lib/VMCore/ConstantFold.cpp
View File

@ -66,16 +66,16 @@ static Constant *CastConstantVector(ConstantVector *CV,
assert(DstEltTy->isFloatingPoint());
if (DstEltTy->getTypeID() == Type::DoubleTyID) {
for (unsigned i = 0; i != SrcNumElts; ++i) {
double V =
BitsToDouble(cast<ConstantInt>(CV->getOperand(i))->getZExtValue());
ConstantInt *CI = cast<ConstantInt>(CV->getOperand(i));
double V = CI->getValue().bitsToDouble();
Result.push_back(ConstantFP::get(Type::DoubleTy, V));
}
return ConstantVector::get(Result);
}
assert(DstEltTy == Type::FloatTy && "Unknown fp type!");
for (unsigned i = 0; i != SrcNumElts; ++i) {
float V =
BitsToFloat(cast<ConstantInt>(CV->getOperand(i))->getZExtValue());
ConstantInt *CI = cast<ConstantInt>(CV->getOperand(i));
float V = CI->getValue().bitsToFloat();
Result.push_back(ConstantFP::get(Type::FloatTy, V));
}
return ConstantVector::get(Result);
@ -304,9 +304,9 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V,
if (DestTy->isFloatingPoint()) {
if (DestTy == Type::FloatTy)
return ConstantFP::get(DestTy, BitsToFloat(CI->getZExtValue()));
return ConstantFP::get(DestTy, CI->getValue().bitsToFloat());
assert(DestTy == Type::DoubleTy && "Unknown FP type!");
return ConstantFP::get(DestTy, BitsToDouble(CI->getZExtValue()));
return ConstantFP::get(DestTy, CI->getValue().bitsToDouble());
}
// Otherwise, can't fold this (packed?)
return 0;
@ -316,10 +316,12 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V,
if (const ConstantFP *FP = dyn_cast<ConstantFP>(V)) {
// FP -> Integral.
if (DestTy == Type::Int32Ty) {
return ConstantInt::get(DestTy, FloatToBits(FP->getValue()));
APInt Val(32, 0);
return ConstantInt::get(Val.floatToBits(FP->getValue()));
} else {
assert(DestTy == Type::Int64Ty && "only support f32/f64 for now!");
return ConstantInt::get(DestTy, DoubleToBits(FP->getValue()));
APInt Val(64, 0);
return ConstantInt::get(Val.doubleToBits(FP->getValue()));
}
}
return 0;