RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-12-13 14:46:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Patch 10 for long double. Doing constants right needs expanding ConstantFP

Browse Source 
to handle values bigger than double.  If we assume host==target and host
long double works correctly, this is not too bad, but we don't want to
have that limitation longterm.  I could implement accepting double
constants as long double or something like that, which would lead to
incorrect codegen with no errors; the more I think about that the worse
it seems.  Rather than do such a hack that would be backed out later,
I'm settling for giving reasonable error messages, for now.



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40974 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dale Johannesen 2007-08-09 22:51:36 +00:00
parent a3231ba237
commit ebbc95da49
3 changed files with 28 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lib/Bitcode/Reader/BitcodeReader.cpp
View File

@ -629,6 +629,10 @@ bool BitcodeReader::ParseConstants() {
V = ConstantFP::get(CurTy, BitsToFloat(Record[0]));
else if (CurTy == Type::DoubleTy)
V = ConstantFP::get(CurTy, BitsToDouble(Record[0]));
// FIXME: Make long double constants work.
else if (CurTy == Type::X86_FP80Ty ||
CurTy == Type::FP128Ty || CurTy == Type::PPC_FP128Ty)
assert(0 && "Long double constants not handled yet.");
else
V = UndefValue::get(CurTy);
break;

12
lib/Bitcode/Writer/BitcodeWriter.cpp
View File

@ -525,11 +525,17 @@ static void WriteConstants(unsigned FirstVal, unsigned LastVal,
}
} else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
Code = bitc::CST_CODE_FLOAT;
if (CFP->getType() == Type::FloatTy) {
const Type *Ty = CFP->getType();
if (Ty == Type::FloatTy) {
Record.push_back(FloatToBits((float)CFP->getValue()));
} else {
assert (CFP->getType() == Type::DoubleTy && "Unknown FP type!");
} else if (Ty == Type::DoubleTy) {
Record.push_back(DoubleToBits((double)CFP->getValue()));
// FIXME: make long double constants work.
} else if (Ty == Type::X86_FP80Ty ||
Ty == Type::FP128Ty || Ty == Type::PPC_FP128Ty) {
assert (0 && "Long double constants not handled yet.");
} else {
assert (0 && "Unknown FP type!");
}
} else if (isa<ConstantArray>(C) && cast<ConstantArray>(C)->isString()) {
// Emit constant strings specially.

19
lib/VMCore/Constants.cpp
View File

@ -108,6 +108,9 @@ Constant *Constant::getNullValue(const Type *Ty) {
return ConstantInt::get(Ty, 0);
case Type::FloatTyID:
case Type::DoubleTyID:
case Type::X86_FP80TyID:
case Type::PPC_FP128TyID:
case Type::FP128TyID:
return ConstantFP::get(Ty, 0.0);
case Type::PointerTyID:
return ConstantPointerNull::get(cast<PointerType>(Ty));
@ -288,12 +291,17 @@ ConstantFP *ConstantFP::get(const Type *Ty, double V) {
ConstantFP *&Slot = (*FloatConstants)[std::make_pair(IntVal, Ty)];
if (Slot) return Slot;
return Slot = new ConstantFP(Ty, (float)V);
} else {
assert(Ty == Type::DoubleTy);
} else if (Ty == Type::DoubleTy) {
uint64_t IntVal = DoubleToBits(V);
ConstantFP *&Slot = (*DoubleConstants)[std::make_pair(IntVal, Ty)];
if (Slot) return Slot;
return Slot = new ConstantFP(Ty, V);
// FIXME: Make long double constants work.
} else if (Ty == Type::X86_FP80Ty ||
Ty == Type::PPC_FP128Ty || Ty == Type::FP128Ty) {
assert(0 && "Long double constants not handled yet.");
} else {
assert(0 && "Unknown FP Type!");
}
}
@ -696,10 +704,13 @@ bool ConstantFP::isValueValidForType(const Type *Ty, double Val) {
default:
return false; // These can't be represented as floating point!
// TODO: Figure out how to test if a double can be cast to a float!
// TODO: Figure out how to test if we can use a shorter type instead!
case Type::FloatTyID:
case Type::DoubleTyID:
return true; // This is the largest type...
case Type::X86_FP80TyID:
case Type::PPC_FP128TyID:
case Type::FP128TyID:
return true;
}
}