6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-07-17 20:29:31 +00:00
Code Issues 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;
}
}