6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-28 19:31:58 +00:00
Code Issues Projects Releases Wiki Activity

Generalize FP constant shrinking optimization to apply to any vt

Browse Source 
except ppc long double.  This allows us to shrink constant pool
entries for x86 long double constants, which in turn allows us to
use flds/fldl instead of fldt.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@47938 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2008-03-05 06:48:13 +00:00
parent aa2acbbbf0
commit ec4a5672f8
2 changed files with 32 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
View File

@ -44,6 +44,17 @@ static SDVTList makeVTList(const MVT::ValueType *VTs, unsigned NumVTs) {
return Res;
}
static const fltSemantics *MVTToAPFloatSemantics(MVT::ValueType VT) {
switch (VT) {
default: assert(0 && "Unknown FP format");
case MVT::f32: return &APFloat::IEEEsingle;
case MVT::f64: return &APFloat::IEEEdouble;
case MVT::f80: return &APFloat::x87DoubleExtended;
case MVT::f128: return &APFloat::IEEEquad;
case MVT::ppcf128: return &APFloat::PPCDoubleDouble;
}
}
SelectionDAG::DAGUpdateListener::~DAGUpdateListener() {}
//===----------------------------------------------------------------------===//
@ -60,28 +71,20 @@ bool ConstantFPSDNode::isExactlyValue(const APFloat& V) const {
bool ConstantFPSDNode::isValueValidForType(MVT::ValueType VT,
const APFloat& Val) {
assert(MVT::isFloatingPoint(VT) && "Can only convert between FP types");
// Anything can be extended to ppc long double.
if (VT == MVT::ppcf128)
return true;
// PPC long double cannot be shrunk to anything though.
if (&Val.getSemantics() == &APFloat::PPCDoubleDouble)
return false;
// convert modifies in place, so make a copy.
APFloat Val2 = APFloat(Val);
switch (VT) {
default:
return false; // These can't be represented as floating point!
// FIXME rounding mode needs to be more flexible
case MVT::f32:
return &Val2.getSemantics() == &APFloat::IEEEsingle ||
Val2.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven) ==
APFloat::opOK;
case MVT::f64:
return &Val2.getSemantics() == &APFloat::IEEEsingle ||
&Val2.getSemantics() == &APFloat::IEEEdouble ||
Val2.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven) ==
APFloat::opOK;
// TODO: Figure out how to test if we can use a shorter type instead!
case MVT::f80:
case MVT::f128:
case MVT::ppcf128:
return true;
}
return Val2.convert(*MVTToAPFloatSemantics(VT),
APFloat::rmNearestTiesToEven) == APFloat::opOK;
}
//===----------------------------------------------------------------------===//
@ -1786,12 +1789,8 @@ SDOperand SelectionDAG::getNode(unsigned Opcode, MVT::ValueType VT,
case ISD::FP_EXTEND:
// This can return overflow, underflow, or inexact; we don't care.
// FIXME need to be more flexible about rounding mode.
(void) V.convert(VT==MVT::f32 ? APFloat::IEEEsingle :
VT==MVT::f64 ? APFloat::IEEEdouble :
VT==MVT::f80 ? APFloat::x87DoubleExtended :
VT==MVT::f128 ? APFloat::IEEEquad :
APFloat::Bogus,
APFloat::rmNearestTiesToEven);
(void)V.convert(*MVTToAPFloatSemantics(VT),
APFloat::rmNearestTiesToEven);
return getConstantFP(V, VT);
case ISD::FP_TO_SINT:
case ISD::FP_TO_UINT: {

7
test/CodeGen/X86/shrink-fp-const2.ll Normal file
View File

@ -0,0 +1,7 @@
; RUN: llvm-as < %s | llc -march=x86 | grep flds
; This should be a flds, not fldt.
define x86_fp80 @test2() nounwind {
entry:
ret x86_fp80 0xK3FFFC000000000000000
}