Factorize some code for determining which libcall to use.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@53713 91177308-0d34-0410-b5e6-96231b3b80d8

5 files changed, 231 insertions, 563 deletions

diff --git a/include/llvm/CodeGen/RuntimeLibcalls.h b/include/llvm/CodeGen/RuntimeLibcalls.h
index acbaa1a..89eed37 100644
--- a/include/llvm/CodeGen/RuntimeLibcalls.h
+++ b/include/llvm/CodeGen/RuntimeLibcalls.h
@@ -8,13 +8,15 @@
 //===----------------------------------------------------------------------===//
 //
 // This file defines the enum representing the list of runtime library calls
-// the backend may emit during code generation.
+// the backend may emit during code generation, and also some helper functions.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CODEGEN_RUNTIMELIBCALLS_H
 #define LLVM_CODEGEN_RUNTIMELIBCALLS_H
 
+#include "llvm/CodeGen/ValueTypes.h"
+
 namespace llvm {
 namespace RTLIB {
   /// RTLIB::Libcall enum - This enum defines all of the runtime library calls
@@ -168,6 +170,30 @@ namespace RTLIB {
 
     UNKNOWN_LIBCALL
   };
+
+  /// getFPEXT - Return the FPEXT_*_* value for the given types, or
+  /// UNKNOWN_LIBCALL if there is none.
+  Libcall getFPEXT(MVT OpVT, MVT RetVT);
+
+  /// getFPROUND - Return the FPROUND_*_* value for the given types, or
+  /// UNKNOWN_LIBCALL if there is none.
+  Libcall getFPROUND(MVT OpVT, MVT RetVT);
+
+  /// getFPTOSINT - Return the FPTOSINT_*_* value for the given types, or
+  /// UNKNOWN_LIBCALL if there is none.
+  Libcall getFPTOSINT(MVT OpVT, MVT RetVT);
+
+  /// getFPTOUINT - Return the FPTOUINT_*_* value for the given types, or
+  /// UNKNOWN_LIBCALL if there is none.
+  Libcall getFPTOUINT(MVT OpVT, MVT RetVT);
+
+  /// getSINTTOFP - Return the SINTTOFP_*_* value for the given types, or
+  /// UNKNOWN_LIBCALL if there is none.
+  Libcall getSINTTOFP(MVT OpVT, MVT RetVT);
+
+  /// getUINTTOFP - Return the UINTTOFP_*_* value for the given types, or
+  /// UNKNOWN_LIBCALL if there is none.
+  Libcall getUINTTOFP(MVT OpVT, MVT RetVT);
 }
 }
 
diff --git a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
index 4b9236d..4b02c54 100644
--- a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
+++ b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
@@ -3764,86 +3764,9 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) {
         break;
       }
       // Convert f32 / f64 to i32 / i64 / i128.
-      RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
-      switch (Node->getOpcode()) {
-      case ISD::FP_TO_SINT: {
-        if (VT == MVT::i32) {
-          if (OVT == MVT::f32)
-            LC = RTLIB::FPTOSINT_F32_I32;
-          else if (OVT == MVT::f64)
-            LC = RTLIB::FPTOSINT_F64_I32;
-          else if (OVT == MVT::f80)
-            LC = RTLIB::FPTOSINT_F80_I32;
-          else if (OVT == MVT::ppcf128)
-            LC = RTLIB::FPTOSINT_PPCF128_I32;
-          else
-            assert(0 && "Unexpected i32-to-fp conversion!");
-        } else if (VT == MVT::i64) {
-          if (OVT == MVT::f32)
-            LC = RTLIB::FPTOSINT_F32_I64;
-          else if (OVT == MVT::f64)
-            LC = RTLIB::FPTOSINT_F64_I64;
-          else if (OVT == MVT::f80)
-            LC = RTLIB::FPTOSINT_F80_I64;
-          else if (OVT == MVT::ppcf128)
-            LC = RTLIB::FPTOSINT_PPCF128_I64;
-          else
-            assert(0 && "Unexpected i64-to-fp conversion!");
-        } else if (VT == MVT::i128) {
-          if (OVT == MVT::f32)
-            LC = RTLIB::FPTOSINT_F32_I128;
-          else if (OVT == MVT::f64)
-            LC = RTLIB::FPTOSINT_F64_I128;
-          else if (OVT == MVT::f80)
-            LC = RTLIB::FPTOSINT_F80_I128;
-          else if (OVT == MVT::ppcf128)
-            LC = RTLIB::FPTOSINT_PPCF128_I128;
-          else
-            assert(0 && "Unexpected i128-to-fp conversion!");
-        } else {
-          assert(0 && "Unexpectd int-to-fp conversion!");
-        }
-        break;
-      }
-      case ISD::FP_TO_UINT: {
-        if (VT == MVT::i32) {
-          if (OVT == MVT::f32)
-            LC = RTLIB::FPTOUINT_F32_I32;
-          else if (OVT == MVT::f64)
-            LC = RTLIB::FPTOUINT_F64_I32;
-          else if (OVT == MVT::f80)
-            LC = RTLIB::FPTOUINT_F80_I32;
-          else
-            assert(0 && "Unexpected i32-to-fp conversion!");
-        } else if (VT == MVT::i64) {
-          if (OVT == MVT::f32)
-            LC = RTLIB::FPTOUINT_F32_I64;
-          else if (OVT == MVT::f64)
-            LC = RTLIB::FPTOUINT_F64_I64;
-          else if (OVT == MVT::f80)
-            LC = RTLIB::FPTOUINT_F80_I64;
-          else if (OVT == MVT::ppcf128)
-            LC = RTLIB::FPTOUINT_PPCF128_I64;
-          else
-            assert(0 && "Unexpected i64-to-fp conversion!");
-        } else if (VT == MVT::i128) {
-          if (OVT == MVT::f32)
-            LC = RTLIB::FPTOUINT_F32_I128;
-          else if (OVT == MVT::f64)
-            LC = RTLIB::FPTOUINT_F64_I128;
-          else if (OVT == MVT::f80)
-            LC = RTLIB::FPTOUINT_F80_I128;
-          else if (OVT == MVT::ppcf128)
-            LC = RTLIB::FPTOUINT_PPCF128_I128;
-          else
-            assert(0 && "Unexpected i128-to-fp conversion!");
-        } else {
-          assert(0 && "Unexpectd int-to-fp conversion!");
-        }
-        break;
-      }
-      default: assert(0 && "Unreachable!");
-      }
+      RTLIB::Libcall LC = (Node->getOpcode() == ISD::FP_TO_SINT) ?
+        RTLIB::getFPTOSINT(OVT, VT) : RTLIB::getFPTOUINT(OVT, VT);
+      assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unexpectd fp-to-int conversion!");
       SDOperand Dummy;
       Result = ExpandLibCall(LC, Node, false/*sign irrelevant*/, Dummy);
       break;
@@ -5412,41 +5335,11 @@ ExpandIntToFP(bool isSigned, MVT DestTy, SDOperand Source) {
     Source = DAG.getNode(ISD::BUILD_PAIR, SourceVT, SrcLo, SrcHi);
   }
 
-  RTLIB::Libcall LC;
-  if (SourceVT == MVT::i32) {
-    if (DestTy == MVT::f32)
-      LC = isSigned ? RTLIB::SINTTOFP_I32_F32 : RTLIB::UINTTOFP_I32_F32;
-    else {
-      assert(DestTy == MVT::f64 && "Unknown fp value type!");
-      LC = isSigned ? RTLIB::SINTTOFP_I32_F64 : RTLIB::UINTTOFP_I32_F64;
-    }
-  } else if (SourceVT == MVT::i64) {
-    if (DestTy == MVT::f32)
-      LC = RTLIB::SINTTOFP_I64_F32;
-    else if (DestTy == MVT::f64)
-      LC = RTLIB::SINTTOFP_I64_F64;
-    else if (DestTy == MVT::f80)
-      LC = RTLIB::SINTTOFP_I64_F80;
-    else {
-      assert(DestTy == MVT::ppcf128 && "Unknown fp value type!");
-      LC = RTLIB::SINTTOFP_I64_PPCF128;
-    }
-  } else if (SourceVT == MVT::i128) {
-    if (DestTy == MVT::f32)
-      LC = RTLIB::SINTTOFP_I128_F32;
-    else if (DestTy == MVT::f64)
-      LC = RTLIB::SINTTOFP_I128_F64;
-    else if (DestTy == MVT::f80)
-      LC = RTLIB::SINTTOFP_I128_F80;
-    else {
-      assert(DestTy == MVT::ppcf128 && "Unknown fp value type!");
-      LC = RTLIB::SINTTOFP_I128_PPCF128;
-    }
-  } else {
-    assert(0 && "Unknown int value type");
-  }
-  
-  assert(TLI.getLibcallName(LC) && "Don't know how to expand this SINT_TO_FP!");
+  RTLIB::Libcall LC = isSigned ?
+    RTLIB::getSINTTOFP(SourceVT, DestTy) :
+    RTLIB::getUINTTOFP(SourceVT, DestTy);
+  assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unknown int value type");
+
   Source = DAG.getNode(ISD::SINT_TO_FP, DestTy, Source);
   SDOperand HiPart;
   SDOperand Result = ExpandLibCall(LC, Source.Val, isSigned, HiPart);
@@ -6196,30 +6089,10 @@ void SelectionDAGLegalize::ExpandOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi){
       }
     }
 
-    RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
-    if (VT == MVT::i64) {
-      if (Node->getOperand(0).getValueType() == MVT::f32)
-        LC = RTLIB::FPTOSINT_F32_I64;
-      else if (Node->getOperand(0).getValueType() == MVT::f64)
-        LC = RTLIB::FPTOSINT_F64_I64;
-      else if (Node->getOperand(0).getValueType() == MVT::f80)
-        LC = RTLIB::FPTOSINT_F80_I64;
-      else if (Node->getOperand(0).getValueType() == MVT::ppcf128)
-        LC = RTLIB::FPTOSINT_PPCF128_I64;
-      Lo = ExpandLibCall(LC, Node, false/*sign irrelevant*/, Hi);
-    } else if (VT == MVT::i128) {
-      if (Node->getOperand(0).getValueType() == MVT::f32)
-        LC = RTLIB::FPTOSINT_F32_I128;
-      else if (Node->getOperand(0).getValueType() == MVT::f64)
-        LC = RTLIB::FPTOSINT_F64_I128;
-      else if (Node->getOperand(0).getValueType() == MVT::f80)
-        LC = RTLIB::FPTOSINT_F80_I128;
-      else if (Node->getOperand(0).getValueType() == MVT::ppcf128)
-        LC = RTLIB::FPTOSINT_PPCF128_I128;
-      Lo = ExpandLibCall(LC, Node, false/*sign irrelevant*/, Hi);
-    } else {
-      assert(0 && "Unexpected uint-to-fp conversion!");
-    }
+    RTLIB::Libcall LC = RTLIB::getFPTOSINT(Node->getOperand(0).getValueType(),
+                                           VT);
+    assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unexpected uint-to-fp conversion!");
+    Lo = ExpandLibCall(LC, Node, false/*sign irrelevant*/, Hi);
     break;
   }
 
@@ -6241,30 +6114,10 @@ void SelectionDAGLegalize::ExpandOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi){
       }
     }
 
-    RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
-    if (VT == MVT::i64) {
-      if (Node->getOperand(0).getValueType() == MVT::f32)
-        LC = RTLIB::FPTOUINT_F32_I64;
-      else if (Node->getOperand(0).getValueType() == MVT::f64)
-        LC = RTLIB::FPTOUINT_F64_I64;
-      else if (Node->getOperand(0).getValueType() == MVT::f80)
-        LC = RTLIB::FPTOUINT_F80_I64;
-      else if (Node->getOperand(0).getValueType() == MVT::ppcf128)
-        LC = RTLIB::FPTOUINT_PPCF128_I64;
-      Lo = ExpandLibCall(LC, Node, false/*sign irrelevant*/, Hi);
-    } else if (VT == MVT::i128) {
-      if (Node->getOperand(0).getValueType() == MVT::f32)
-        LC = RTLIB::FPTOUINT_F32_I128;
-      else if (Node->getOperand(0).getValueType() == MVT::f64)
-        LC = RTLIB::FPTOUINT_F64_I128;
-      else if (Node->getOperand(0).getValueType() == MVT::f80)
-        LC = RTLIB::FPTOUINT_F80_I128;
-      else if (Node->getOperand(0).getValueType() == MVT::ppcf128)
-        LC = RTLIB::FPTOUINT_PPCF128_I128;
-      Lo = ExpandLibCall(LC, Node, false/*sign irrelevant*/, Hi);
-    } else {
-      assert(0 && "Unexpected uint-to-fp conversion!");
-    }
+    RTLIB::Libcall LC = RTLIB::getFPTOUINT(Node->getOperand(0).getValueType(),
+                                           VT);
+    assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unexpected fp-to-uint conversion!");
+    Lo = ExpandLibCall(LC, Node, false/*sign irrelevant*/, Hi);
     break;
   }
 
@@ -6579,7 +6432,7 @@ void SelectionDAGLegalize::ExpandOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi){
                                         RTLIB::DIV_PPCF128),
                        Node, false, Hi);
     break;
-  case ISD::FP_EXTEND:
+  case ISD::FP_EXTEND: {
     if (VT == MVT::ppcf128) {
       assert(Node->getOperand(0).getValueType()==MVT::f32 ||
              Node->getOperand(0).getValueType()==MVT::f64);
@@ -6591,11 +6444,18 @@ void SelectionDAGLegalize::ExpandOp(SDOperand Op, SDOperand &Lo, SDOperand &Hi){
       Lo = DAG.getConstantFP(APFloat(APInt(64, 1, &zero)), MVT::f64);
       break;
     }
-    Lo = ExpandLibCall(RTLIB::FPEXT_F32_F64, Node, true, Hi);
+    RTLIB::Libcall LC = RTLIB::getFPEXT(Node->getOperand(0).getValueType(), VT);
+    assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_EXTEND!");
+    Lo = ExpandLibCall(LC, Node, true, Hi);
     break;
-  case ISD::FP_ROUND:
-    Lo = ExpandLibCall(RTLIB::FPROUND_F64_F32, Node, true, Hi);
+  }
+  case ISD::FP_ROUND: {
+    RTLIB::Libcall LC = RTLIB::getFPROUND(Node->getOperand(0).getValueType(),
+                                          VT);
+    assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_ROUND!");
+    Lo = ExpandLibCall(LC, Node, true, Hi);
     break;
+  }
   case ISD::FPOWI:
     Lo = ExpandLibCall(GetFPLibCall(VT, RTLIB::POWI_F32,
                                         RTLIB::POWI_F64,
diff --git a/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp b/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp
index 5d23f52..b1edae8 100644
--- a/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp
+++ b/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp
@@ -161,40 +161,16 @@ SDOperand DAGTypeLegalizer::SoftenFloatRes_FMUL(SDNode *N) {
 SDOperand DAGTypeLegalizer::SoftenFloatRes_FP_EXTEND(SDNode *N) {
   MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0));
   SDOperand Op = N->getOperand(0);
-
-  RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
-  switch (Op.getValueType().getSimpleVT()) {
-  default:
-    assert(false && "Unsupported FP_EXTEND!");
-  case MVT::f32:
-    switch (N->getValueType(0).getSimpleVT()) {
-    default:
-      assert(false && "Unsupported FP_EXTEND!");
-    case MVT::f64:
-      LC = RTLIB::FPEXT_F32_F64;
-    }
-  }
-
+  RTLIB::Libcall LC = RTLIB::getFPEXT(Op.getValueType(), N->getValueType(0));
+  assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_EXTEND!");
   return MakeLibCall(LC, NVT, &Op, 1, false);
 }
 
 SDOperand DAGTypeLegalizer::SoftenFloatRes_FP_ROUND(SDNode *N) {
   MVT NVT = TLI.getTypeToTransformTo(N->getValueType(0));
   SDOperand Op = N->getOperand(0);
-
-  RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
-  switch (Op.getValueType().getSimpleVT()) {
-  default:
-    assert(false && "Unsupported FP_ROUND!");
-  case MVT::f64:
-    switch (N->getValueType(0).getSimpleVT()) {
-    default:
-      assert(false && "Unsupported FP_ROUND!");
-    case MVT::f32:
-      LC = RTLIB::FPROUND_F64_F32;
-    }
-  }
-
+  RTLIB::Libcall LC = RTLIB::getFPROUND(Op.getValueType(), N->getValueType(0));
+  assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_ROUND!");
   return MakeLibCall(LC, NVT, &Op, 1, false);
 }
 
@@ -267,100 +243,16 @@ SDOperand DAGTypeLegalizer::SoftenFloatRes_SELECT_CC(SDNode *N) {
 SDOperand DAGTypeLegalizer::SoftenFloatRes_SINT_TO_FP(SDNode *N) {
   SDOperand Op = N->getOperand(0);
   MVT RVT = N->getValueType(0);
-
-  RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
-  switch (Op.getValueType().getSimpleVT()) {
-  case MVT::i32:
-    switch (RVT.getSimpleVT()) {
-    case MVT::f32:
-      LC = RTLIB::SINTTOFP_I32_F32;
-      break;
-    case MVT::f64:
-      LC = RTLIB::SINTTOFP_I32_F64;
-      break;
-    default:
-      break;
-    }
-    break;
-  case MVT::i64:
-    switch (RVT.getSimpleVT()) {
-    case MVT::f32:
-      LC = RTLIB::SINTTOFP_I64_F32;
-      break;
-    case MVT::f64:
-      LC = RTLIB::SINTTOFP_I64_F64;
-      break;
-    case MVT::f80:
-      LC = RTLIB::SINTTOFP_I64_F80;
-      break;
-    case MVT::ppcf128:
-      LC = RTLIB::SINTTOFP_I64_PPCF128;
-      break;
-    default:
-      break;
-    }
-    break;
-  case MVT::i128:
-    switch (RVT.getSimpleVT()) {
-    case MVT::f32:
-      LC = RTLIB::SINTTOFP_I128_F32;
-      break;
-    case MVT::f64:
-      LC = RTLIB::SINTTOFP_I128_F64;
-      break;
-    case MVT::f80:
-      LC = RTLIB::SINTTOFP_I128_F80;
-      break;
-    case MVT::ppcf128:
-      LC = RTLIB::SINTTOFP_I128_PPCF128;
-      break;
-    default:
-      break;
-    }
-    break;
-  default:
-    break;
-  }
+  RTLIB::Libcall LC = RTLIB::getSINTTOFP(Op.getValueType(), RVT);
   assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported SINT_TO_FP!");
-
   return MakeLibCall(LC, TLI.getTypeToTransformTo(RVT), &Op, 1, false);
 }
 
 SDOperand DAGTypeLegalizer::SoftenFloatRes_UINT_TO_FP(SDNode *N) {
   SDOperand Op = N->getOperand(0);
   MVT RVT = N->getValueType(0);
-
-  RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
-  switch (Op.getValueType().getSimpleVT()) {
-  case MVT::i32:
-    switch (RVT.getSimpleVT()) {
-    case MVT::f32:
-      LC = RTLIB::UINTTOFP_I32_F32;
-      break;
-    case MVT::f64:
-      LC = RTLIB::UINTTOFP_I32_F64;
-      break;
-    default:
-      break;
-    }
-    break;
-  case MVT::i64:
-    switch (RVT.getSimpleVT()) {
-    case MVT::f32:
-      LC = RTLIB::UINTTOFP_I64_F32;
-      break;
-    case MVT::f64:
-      LC = RTLIB::UINTTOFP_I64_F64;
-      break;
-    default:
-      break;
-    }
-    break;
-  default:
-    break;
-  }
+  RTLIB::Libcall LC = RTLIB::getUINTTOFP(Op.getValueType(), RVT);
   assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported UINT_TO_FP!");
-
   return MakeLibCall(LC, TLI.getTypeToTransformTo(RVT), &Op, 1, false);
 }
 
@@ -521,139 +413,17 @@ SDOperand DAGTypeLegalizer::SoftenFloatOp_BR_CC(SDNode *N) {
 }
 
 SDOperand DAGTypeLegalizer::SoftenFloatOp_FP_TO_SINT(SDNode *N) {
-  MVT SVT = N->getOperand(0).getValueType();
   MVT RVT = N->getValueType(0);
-
-  RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
-  switch (RVT.getSimpleVT()) {
-  case MVT::i32:
-    switch (SVT.getSimpleVT()) {
-    case MVT::f32:
-      LC = RTLIB::FPTOSINT_F32_I32;
-      break;
-    case MVT::f64:
-      LC = RTLIB::FPTOSINT_F64_I32;
-      break;
-    case MVT::f80:
-      LC = RTLIB::FPTOSINT_F80_I32;
-      break;
-    case MVT::ppcf128:
-      LC = RTLIB::FPTOSINT_PPCF128_I32;
-      break;
-    default:
-      break;
-    }
-    break;
-  case MVT::i64:
-    switch (SVT.getSimpleVT()) {
-    case MVT::f32:
-      LC = RTLIB::FPTOSINT_F32_I64;
-      break;
-    case MVT::f64:
-      LC = RTLIB::FPTOSINT_F64_I64;
-      break;
-    case MVT::f80:
-      LC = RTLIB::FPTOSINT_F80_I64;
-      break;
-    case MVT::ppcf128:
-      LC = RTLIB::FPTOSINT_PPCF128_I64;
-      break;
-    default:
-      break;
-    }
-    break;
-  case MVT::i128:
-    switch (SVT.getSimpleVT()) {
-    case MVT::f32:
-      LC = RTLIB::FPTOSINT_F32_I128;
-      break;
-    case MVT::f64:
-      LC = RTLIB::FPTOSINT_F64_I128;
-      break;
-    case MVT::f80:
-      LC = RTLIB::FPTOSINT_F80_I128;
-      break;
-    case MVT::ppcf128:
-      LC = RTLIB::FPTOSINT_PPCF128_I128;
-      break;
-    default:
-      break;
-    }
-    break;
-  default:
-    break;
-  }
+  RTLIB::Libcall LC = RTLIB::getFPTOSINT(N->getOperand(0).getValueType(), RVT);
   assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_SINT!");
-
   SDOperand Op = GetSoftenedFloat(N->getOperand(0));
   return MakeLibCall(LC, RVT, &Op, 1, false);
 }
 
 SDOperand DAGTypeLegalizer::SoftenFloatOp_FP_TO_UINT(SDNode *N) {
-  MVT SVT = N->getOperand(0).getValueType();
   MVT RVT = N->getValueType(0);
-
-  RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
-  switch (RVT.getSimpleVT()) {
-  case MVT::i32:
-    switch (SVT.getSimpleVT()) {
-    case MVT::f32:
-      LC = RTLIB::FPTOUINT_F32_I32;
-      break;
-    case MVT::f64:
-      LC = RTLIB::FPTOUINT_F64_I32;
-      break;
-    case MVT::f80:
-      LC = RTLIB::FPTOUINT_F80_I32;
-      break;
-    case MVT::ppcf128:
-      LC = RTLIB::FPTOUINT_PPCF128_I32;
-      break;
-    default:
-      break;
-    }
-    break;
-  case MVT::i64:
-    switch (SVT.getSimpleVT()) {
-    case MVT::f32:
-      LC = RTLIB::FPTOUINT_F32_I64;
-      break;
-    case MVT::f64:
-      LC = RTLIB::FPTOUINT_F64_I64;
-      break;
-    case MVT::f80:
-      LC = RTLIB::FPTOUINT_F80_I64;
-      break;
-    case MVT::ppcf128:
-      LC = RTLIB::FPTOUINT_PPCF128_I64;
-      break;
-    default:
-      break;
-    }
-    break;
-  case MVT::i128:
-    switch (SVT.getSimpleVT()) {
-    case MVT::f32:
-      LC = RTLIB::FPTOUINT_F32_I128;
-      break;
-    case MVT::f64:
-      LC = RTLIB::FPTOUINT_F64_I128;
-      break;
-    case MVT::f80:
-      LC = RTLIB::FPTOUINT_F80_I128;
-      break;
-    case MVT::ppcf128:
-      LC = RTLIB::FPTOUINT_PPCF128_I128;
-      break;
-    default:
-      break;
-    }
-    break;
-  default:
-    break;
-  }
+  RTLIB::Libcall LC = RTLIB::getFPTOUINT(N->getOperand(0).getValueType(), RVT);
   assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_UINT!");
-
   SDOperand Op = GetSoftenedFloat(N->getOperand(0));
   return MakeLibCall(LC, RVT, &Op, 1, false);
 }
@@ -1067,45 +837,16 @@ SDOperand DAGTypeLegalizer::ExpandFloatOp_FP_ROUND(SDNode *N) {
 }
 
 SDOperand DAGTypeLegalizer::ExpandFloatOp_FP_TO_SINT(SDNode *N) {
-  assert(N->getOperand(0).getValueType() == MVT::ppcf128 &&
-         "Unsupported FP_TO_SINT!");
-
-  RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
-  switch (N->getValueType(0).getSimpleVT()) {
-  default:
-    assert(false && "Unsupported FP_TO_SINT!");
-  case MVT::i32:
-    LC = RTLIB::FPTOSINT_PPCF128_I32;
-  case MVT::i64:
-    LC = RTLIB::FPTOSINT_PPCF128_I64;
-    break;
-  case MVT::i128:
-    LC = RTLIB::FPTOSINT_PPCF128_I64;
-    break;
-  }
-
-  return MakeLibCall(LC, N->getValueType(0), &N->getOperand(0), 1, false);
+  MVT RVT = N->getValueType(0);
+  RTLIB::Libcall LC = RTLIB::getFPTOSINT(N->getOperand(0).getValueType(), RVT);
+  assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_SINT!");
+  return MakeLibCall(LC, RVT, &N->getOperand(0), 1, false);
 }
 
 SDOperand DAGTypeLegalizer::ExpandFloatOp_FP_TO_UINT(SDNode *N) {
-  assert(N->getOperand(0).getValueType() == MVT::ppcf128 &&
-         "Unsupported FP_TO_UINT!");
-
-  RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
-  switch (N->getValueType(0).getSimpleVT()) {
-  default:
-    assert(false && "Unsupported FP_TO_UINT!");
-  case MVT::i32:
-    LC = RTLIB::FPTOUINT_PPCF128_I32;
-    break;
-  case MVT::i64:
-    LC = RTLIB::FPTOUINT_PPCF128_I64;
-    break;
-  case MVT::i128:
-    LC = RTLIB::FPTOUINT_PPCF128_I128;
-    break;
-  }
-
+  MVT RVT = N->getValueType(0);
+  RTLIB::Libcall LC = RTLIB::getFPTOUINT(N->getOperand(0).getValueType(), RVT);
+  assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_UINT!");
   return MakeLibCall(LC, N->getValueType(0), &N->getOperand(0), 1, false);
 }
 
diff --git a/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp b/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp
index fa0a0fd..8a30861 100644
--- a/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp
+++ b/lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp
@@ -1238,36 +1238,7 @@ void DAGTypeLegalizer::ExpandIntRes_FP_TO_SINT(SDNode *N, SDOperand &Lo,
                                                SDOperand &Hi) {
   MVT VT = N->getValueType(0);
   SDOperand Op = N->getOperand(0);
-  RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
-
-  if (VT == MVT::i32) {
-    if (Op.getValueType() == MVT::f32)
-      LC = RTLIB::FPTOSINT_F32_I32;
-    else if (Op.getValueType() == MVT::f64)
-      LC = RTLIB::FPTOSINT_F64_I32;
-    else if (Op.getValueType() == MVT::f80)
-      LC = RTLIB::FPTOSINT_F80_I32;
-    else if (Op.getValueType() == MVT::ppcf128)
-      LC = RTLIB::FPTOSINT_PPCF128_I32;
-  } else if (VT == MVT::i64) {
-    if (Op.getValueType() == MVT::f32)
-      LC = RTLIB::FPTOSINT_F32_I64;
-    else if (Op.getValueType() == MVT::f64)
-      LC = RTLIB::FPTOSINT_F64_I64;
-    else if (Op.getValueType() == MVT::f80)
-      LC = RTLIB::FPTOSINT_F80_I64;
-    else if (Op.getValueType() == MVT::ppcf128)
-      LC = RTLIB::FPTOSINT_PPCF128_I64;
-  } else if (VT == MVT::i128) {
-    if (Op.getValueType() == MVT::f32)
-      LC = RTLIB::FPTOSINT_F32_I128;
-    else if (Op.getValueType() == MVT::f64)
-      LC = RTLIB::FPTOSINT_F64_I128;
-    else if (Op.getValueType() == MVT::f80)
-      LC = RTLIB::FPTOSINT_F80_I128;
-    else if (Op.getValueType() == MVT::ppcf128)
-      LC = RTLIB::FPTOSINT_PPCF128_I128;
-  }
+  RTLIB::Libcall LC = RTLIB::getFPTOSINT(Op.getValueType(), VT);
   assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unexpected fp-to-sint conversion!");
   SplitInteger(MakeLibCall(LC, VT, &Op, 1, true/*sign irrelevant*/), Lo, Hi);
 }
@@ -1276,35 +1247,7 @@ void DAGTypeLegalizer::ExpandIntRes_FP_TO_UINT(SDNode *N, SDOperand &Lo,
                                                SDOperand &Hi) {
   MVT VT = N->getValueType(0);
   SDOperand Op = N->getOperand(0);
-  RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
-  if (VT == MVT::i32) {
-    if (Op.getValueType() == MVT::f32)
-      LC = RTLIB::FPTOUINT_F32_I32;
-    else if (Op.getValueType() == MVT::f64)
-      LC = RTLIB::FPTOUINT_F64_I32;
-    else if (Op.getValueType() == MVT::f80)
-      LC = RTLIB::FPTOUINT_F80_I32;
-    else if (Op.getValueType() == MVT::ppcf128)
-      LC = RTLIB::FPTOUINT_PPCF128_I32;
-  } else if (VT == MVT::i64) {
-    if (Op.getValueType() == MVT::f32)
-      LC = RTLIB::FPTOUINT_F32_I64;
-    else if (Op.getValueType() == MVT::f64)
-      LC = RTLIB::FPTOUINT_F64_I64;
-    else if (Op.getValueType() == MVT::f80)
-      LC = RTLIB::FPTOUINT_F80_I64;
-    else if (Op.getValueType() == MVT::ppcf128)
-      LC = RTLIB::FPTOUINT_PPCF128_I64;
-  } else if (VT == MVT::i128) {
-    if (Op.getValueType() == MVT::f32)
-      LC = RTLIB::FPTOUINT_F32_I128;
-    else if (Op.getValueType() == MVT::f64)
-      LC = RTLIB::FPTOUINT_F64_I128;
-    else if (Op.getValueType() == MVT::f80)
-      LC = RTLIB::FPTOUINT_F80_I128;
-    else if (Op.getValueType() == MVT::ppcf128)
-      LC = RTLIB::FPTOUINT_PPCF128_I128;
-  }
+  RTLIB::Libcall LC = RTLIB::getFPTOUINT(Op.getValueType(), VT);
   assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unexpected fp-to-uint conversion!");
   SplitInteger(MakeLibCall(LC, VT, &Op, 1, false/*sign irrelevant*/), Lo, Hi);
 }
@@ -1961,41 +1904,10 @@ SDOperand DAGTypeLegalizer::ExpandIntOp_SETCC(SDNode *N) {
 
 SDOperand DAGTypeLegalizer::ExpandIntOp_SINT_TO_FP(SDNode *N) {
   SDOperand Op = N->getOperand(0);
-  MVT SrcVT = Op.getValueType();
   MVT DstVT = N->getValueType(0);
-
-  RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
-  if (SrcVT == MVT::i32) {
-    if (DstVT == MVT::f32)
-      LC = RTLIB::SINTTOFP_I32_F32;
-    else if (DstVT == MVT::f64)
-      LC = RTLIB::SINTTOFP_I32_F64;
-    else if (DstVT == MVT::f80)
-      LC = RTLIB::SINTTOFP_I32_F80;
-    else if (DstVT == MVT::ppcf128)
-      LC = RTLIB::SINTTOFP_I32_PPCF128;
-  } else if (SrcVT == MVT::i64) {
-    if (DstVT == MVT::f32)
-      LC = RTLIB::SINTTOFP_I64_F32;
-    else if (DstVT == MVT::f64)
-      LC = RTLIB::SINTTOFP_I64_F64;
-    else if (DstVT == MVT::f80)
-      LC = RTLIB::SINTTOFP_I64_F80;
-    else if (DstVT == MVT::ppcf128)
-      LC = RTLIB::SINTTOFP_I64_PPCF128;
-  } else if (SrcVT == MVT::i128) {
-    if (DstVT == MVT::f32)
-      LC = RTLIB::SINTTOFP_I128_F32;
-    else if (DstVT == MVT::f64)
-      LC = RTLIB::SINTTOFP_I128_F64;
-    else if (DstVT == MVT::f80)
-      LC = RTLIB::SINTTOFP_I128_F80;
-    else if (DstVT == MVT::ppcf128)
-      LC = RTLIB::SINTTOFP_I128_PPCF128;
-  }
+  RTLIB::Libcall LC = RTLIB::getSINTTOFP(Op.getValueType(), DstVT);
   assert(LC != RTLIB::UNKNOWN_LIBCALL &&
          "Don't know how to expand this SINT_TO_FP!");
-
   return MakeLibCall(LC, DstVT, &Op, 1, true);
 }
 
@@ -2140,37 +2052,8 @@ SDOperand DAGTypeLegalizer::ExpandIntOp_UINT_TO_FP(SDNode *N) {
   }
 
   // Otherwise, use a libcall.
-  RTLIB::Libcall LC = RTLIB::UNKNOWN_LIBCALL;
-  if (SrcVT == MVT::i32) {
-    if (DstVT == MVT::f32)
-      LC = RTLIB::UINTTOFP_I32_F32;
-    else if (DstVT == MVT::f64)
-      LC = RTLIB::UINTTOFP_I32_F64;
-    else if (DstVT == MVT::f80)
-      LC = RTLIB::UINTTOFP_I32_F80;
-    else if (DstVT == MVT::ppcf128)
-      LC = RTLIB::UINTTOFP_I32_PPCF128;
-  } else if (SrcVT == MVT::i64) {
-    if (DstVT == MVT::f32)
-      LC = RTLIB::UINTTOFP_I64_F32;
-    else if (DstVT == MVT::f64)
-      LC = RTLIB::UINTTOFP_I64_F64;
-    else if (DstVT == MVT::f80)
-      LC = RTLIB::UINTTOFP_I64_F80;
-    else if (DstVT == MVT::ppcf128)
-      LC = RTLIB::UINTTOFP_I64_PPCF128;
-  } else if (SrcVT == MVT::i128) {
-    if (DstVT == MVT::f32)
-      LC = RTLIB::UINTTOFP_I128_F32;
-    else if (DstVT == MVT::f64)
-      LC = RTLIB::UINTTOFP_I128_F64;
-    else if (DstVT == MVT::f80)
-      LC = RTLIB::UINTTOFP_I128_F80;
-    else if (DstVT == MVT::ppcf128)
-      LC = RTLIB::UINTTOFP_I128_PPCF128;
-  }
+  RTLIB::Libcall LC = RTLIB::getUINTTOFP(SrcVT, DstVT);
   assert(LC != RTLIB::UNKNOWN_LIBCALL &&
          "Don't know how to expand this UINT_TO_FP!");
-
   return MakeLibCall(LC, DstVT, &Op, 1, true);
 }
diff --git a/lib/CodeGen/SelectionDAG/TargetLowering.cpp b/lib/CodeGen/SelectionDAG/TargetLowering.cpp
index 692158e..1fd9d95 100644
--- a/lib/CodeGen/SelectionDAG/TargetLowering.cpp
+++ b/lib/CodeGen/SelectionDAG/TargetLowering.cpp
@@ -163,6 +163,164 @@ static void InitLibcallNames(const char **Names) {
   Names[RTLIB::O_F64] = "__unorddf2";
 }
 
+/// getFPEXT - Return the FPEXT_*_* value for the given types, or
+/// UNKNOWN_LIBCALL if there is none.
+RTLIB::Libcall RTLIB::getFPEXT(MVT OpVT, MVT RetVT) {
+  if (OpVT == MVT::f32) {
+    if (RetVT == MVT::f64)
+      return FPEXT_F32_F64;
+  }
+  return UNKNOWN_LIBCALL;
+}
+
+/// getFPROUND - Return the FPROUND_*_* value for the given types, or
+/// UNKNOWN_LIBCALL if there is none.
+RTLIB::Libcall RTLIB::getFPROUND(MVT OpVT, MVT RetVT) {
+  if (OpVT == MVT::f64) {
+    if (RetVT == MVT::f32)
+      return FPROUND_F64_F32;
+  }
+  return UNKNOWN_LIBCALL;
+}
+
+/// getFPTOSINT - Return the FPTOSINT_*_* value for the given types, or
+/// UNKNOWN_LIBCALL if there is none.
+RTLIB::Libcall RTLIB::getFPTOSINT(MVT OpVT, MVT RetVT) {
+  if (OpVT == MVT::f32) {
+    if (RetVT == MVT::i32)
+      return FPTOSINT_F32_I32;
+    if (RetVT == MVT::i64)
+      return FPTOSINT_F32_I64;
+    if (RetVT == MVT::i128)
+      return FPTOSINT_F32_I128;
+  } else if (OpVT == MVT::f64) {
+    if (RetVT == MVT::i32)
+      return FPTOSINT_F64_I32;
+    if (RetVT == MVT::i64)
+      return FPTOSINT_F64_I64;
+    if (RetVT == MVT::i128)
+      return FPTOSINT_F64_I128;
+  } else if (OpVT == MVT::f80) {
+    if (RetVT == MVT::i32)
+      return FPTOSINT_F80_I32;
+    if (RetVT == MVT::i64)
+      return FPTOSINT_F80_I64;
+    if (RetVT == MVT::i128)
+      return FPTOSINT_F80_I128;
+  } else if (OpVT == MVT::ppcf128) {
+    if (RetVT == MVT::i32)
+      return FPTOSINT_PPCF128_I32;
+    if (RetVT == MVT::i64)
+      return FPTOSINT_PPCF128_I64;
+    if (RetVT == MVT::i128)
+      return FPTOSINT_PPCF128_I128;
+  }
+  return UNKNOWN_LIBCALL;
+}
+
+/// getFPTOUINT - Return the FPTOUINT_*_* value for the given types, or
+/// UNKNOWN_LIBCALL if there is none.
+RTLIB::Libcall RTLIB::getFPTOUINT(MVT OpVT, MVT RetVT) {
+  if (OpVT == MVT::f32) {
+    if (RetVT == MVT::i32)
+      return FPTOUINT_F32_I32;
+    if (RetVT == MVT::i64)
+      return FPTOUINT_F32_I64;
+    if (RetVT == MVT::i128)
+      return FPTOUINT_F32_I128;
+  } else if (OpVT == MVT::f64) {
+    if (RetVT == MVT::i32)
+      return FPTOUINT_F64_I32;
+    if (RetVT == MVT::i64)
+      return FPTOUINT_F64_I64;
+    if (RetVT == MVT::i128)
+      return FPTOUINT_F64_I128;
+  } else if (OpVT == MVT::f80) {
+    if (RetVT == MVT::i32)
+      return FPTOUINT_F80_I32;
+    if (RetVT == MVT::i64)
+      return FPTOUINT_F80_I64;
+    if (RetVT == MVT::i128)
+      return FPTOUINT_F80_I128;
+  } else if (OpVT == MVT::ppcf128) {
+    if (RetVT == MVT::i32)
+      return FPTOUINT_PPCF128_I32;
+    if (RetVT == MVT::i64)
+      return FPTOUINT_PPCF128_I64;
+    if (RetVT == MVT::i128)
+      return FPTOUINT_PPCF128_I128;
+  }
+  return UNKNOWN_LIBCALL;
+}
+
+/// getSINTTOFP - Return the SINTTOFP_*_* value for the given types, or
+/// UNKNOWN_LIBCALL if there is none.
+RTLIB::Libcall RTLIB::getSINTTOFP(MVT OpVT, MVT RetVT) {
+  if (OpVT == MVT::i32) {
+    if (RetVT == MVT::f32)
+      return SINTTOFP_I32_F32;
+    else if (RetVT == MVT::f64)
+      return SINTTOFP_I32_F64;
+    else if (RetVT == MVT::f80)
+      return SINTTOFP_I32_F80;
+    else if (RetVT == MVT::ppcf128)
+      return SINTTOFP_I32_PPCF128;
+  } else if (OpVT == MVT::i64) {
+    if (RetVT == MVT::f32)
+      return SINTTOFP_I64_F32;
+    else if (RetVT == MVT::f64)
+      return SINTTOFP_I64_F64;
+    else if (RetVT == MVT::f80)
+      return SINTTOFP_I64_F80;
+    else if (RetVT == MVT::ppcf128)
+      return SINTTOFP_I64_PPCF128;
+  } else if (OpVT == MVT::i128) {
+    if (RetVT == MVT::f32)
+      return SINTTOFP_I128_F32;
+    else if (RetVT == MVT::f64)
+      return SINTTOFP_I128_F64;
+    else if (RetVT == MVT::f80)
+      return SINTTOFP_I128_F80;
+    else if (RetVT == MVT::ppcf128)
+      return SINTTOFP_I128_PPCF128;
+  }
+  return UNKNOWN_LIBCALL;
+}
+
+/// getUINTTOFP - Return the UINTTOFP_*_* value for the given types, or
+/// UNKNOWN_LIBCALL if there is none.
+RTLIB::Libcall RTLIB::getUINTTOFP(MVT OpVT, MVT RetVT) {
+  if (OpVT == MVT::i32) {
+    if (RetVT == MVT::f32)
+      return UINTTOFP_I32_F32;
+    else if (RetVT == MVT::f64)
+      return UINTTOFP_I32_F64;
+    else if (RetVT == MVT::f80)
+      return UINTTOFP_I32_F80;
+    else if (RetVT == MVT::ppcf128)
+      return UINTTOFP_I32_PPCF128;
+  } else if (OpVT == MVT::i64) {
+    if (RetVT == MVT::f32)
+      return UINTTOFP_I64_F32;
+    else if (RetVT == MVT::f64)
+      return UINTTOFP_I64_F64;
+    else if (RetVT == MVT::f80)
+      return UINTTOFP_I64_F80;
+    else if (RetVT == MVT::ppcf128)
+      return UINTTOFP_I64_PPCF128;
+  } else if (OpVT == MVT::i128) {
+    if (RetVT == MVT::f32)
+      return UINTTOFP_I128_F32;
+    else if (RetVT == MVT::f64)
+      return UINTTOFP_I128_F64;
+    else if (RetVT == MVT::f80)
+      return UINTTOFP_I128_F80;
+    else if (RetVT == MVT::ppcf128)
+      return UINTTOFP_I128_PPCF128;
+  }
+  return UNKNOWN_LIBCALL;
+}
+
 /// InitCmpLibcallCCs - Set default comparison libcall CC.
 ///
 static void InitCmpLibcallCCs(ISD::CondCode *CCs) {