Generalize FP constant shrinking optimization to apply to any vt

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

diff --git a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
index 89376222268698240a35b129963071dc3568e98f..dd1343590ad25cd2a1c2ec224fd0099488435e71 100644 (file)
--- a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
+++ b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
@@ -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: {

diff --git a/test/CodeGen/X86/shrink-fp-const2.ll b/test/CodeGen/X86/shrink-fp-const2.ll
new file mode 100644 (file)
index 0000000..7e48b1b
--- /dev/null
+++ b/test/CodeGen/X86/shrink-fp-const2.ll
@@ -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
+}
+