[MSP430] Do not use __mspabi_cmp[fd] for FP comparisons

[atrosinenko]

Summary

According to MSP430 EABI document, Section 6.2, the result of
__mspabi_cmp[fd] is undefined if either of its arguments is NaN.

See Sections 6.1 and 6.2 of MSP430 EABI document for details.

[atrosinenko]

Revert automatic formatting change.

[atrosinenko]

Hmm, this probably needs further investigations... On one hand, condition codes such as ISD::SETNE are explicit "Don't care operations: undefined if the input is a nan" - that is, exactly how the __mspabi_cmp[fd] are described in MSP430 EABI document. On the other hand, how a fully fledged comparison libcall can be specified then?

llvm/lib/Target/MSP430/MSP430ISelLowering.cpp

MSP430TargetLowering::MSP430TargetLowering(const TargetMachine &TM,
   setOperationAction(ISD::JumpTable,        MVT::i16,   Custom);
 
   // EABI Libcalls - EABI Section 6.2
   const struct {
     const RTLIB::Libcall Op;
     const char * const Name;
     const ISD::CondCode Cond;
   } LibraryCalls[] = {
       // Floating point conversions - EABI Table 6
-    { RTLIB::FPROUND_F64_F32,   "__mspabi_cvtdf",   ISD::SETCC_INVALID },
-    { RTLIB::FPEXT_F32_F64,     "__mspabi_cvtfd",   ISD::SETCC_INVALID },
+      {RTLIB::FPROUND_F64_F32, "__mspabi_cvtdf", ISD::SETCC_INVALID},
+      {RTLIB::FPEXT_F32_F64, "__mspabi_cvtfd", ISD::SETCC_INVALID},
       // The following is NOT implemented in libgcc
       //{ RTLIB::FPTOSINT_F64_I16,  "__mspabi_fixdi", ISD::SETCC_INVALID },
-    { RTLIB::FPTOSINT_F64_I32,  "__mspabi_fixdli",  ISD::SETCC_INVALID },
-    { RTLIB::FPTOSINT_F64_I64,  "__mspabi_fixdlli", ISD::SETCC_INVALID },
+      {RTLIB::FPTOSINT_F64_I32, "__mspabi_fixdli", ISD::SETCC_INVALID},
+      {RTLIB::FPTOSINT_F64_I64, "__mspabi_fixdlli", ISD::SETCC_INVALID},
       // The following is NOT implemented in libgcc
       //{ RTLIB::FPTOUINT_F64_I16,  "__mspabi_fixdu", ISD::SETCC_INVALID },
-    { RTLIB::FPTOUINT_F64_I32,  "__mspabi_fixdul",  ISD::SETCC_INVALID },
-    { RTLIB::FPTOUINT_F64_I64,  "__mspabi_fixdull", ISD::SETCC_INVALID },
+      {RTLIB::FPTOUINT_F64_I32, "__mspabi_fixdul", ISD::SETCC_INVALID},
+      {RTLIB::FPTOUINT_F64_I64, "__mspabi_fixdull", ISD::SETCC_INVALID},
       // The following is NOT implemented in libgcc
       //{ RTLIB::FPTOSINT_F32_I16,  "__mspabi_fixfi", ISD::SETCC_INVALID },
-    { RTLIB::FPTOSINT_F32_I32,  "__mspabi_fixfli",  ISD::SETCC_INVALID },
-    { RTLIB::FPTOSINT_F32_I64,  "__mspabi_fixflli", ISD::SETCC_INVALID },
+      {RTLIB::FPTOSINT_F32_I32, "__mspabi_fixfli", ISD::SETCC_INVALID},
+      {RTLIB::FPTOSINT_F32_I64, "__mspabi_fixflli", ISD::SETCC_INVALID},
       // The following is NOT implemented in libgcc
       //{ RTLIB::FPTOUINT_F32_I16,  "__mspabi_fixfu", ISD::SETCC_INVALID },
-    { RTLIB::FPTOUINT_F32_I32,  "__mspabi_fixful",  ISD::SETCC_INVALID },
-    { RTLIB::FPTOUINT_F32_I64,  "__mspabi_fixfull", ISD::SETCC_INVALID },
+      {RTLIB::FPTOUINT_F32_I32, "__mspabi_fixful", ISD::SETCC_INVALID},
+      {RTLIB::FPTOUINT_F32_I64, "__mspabi_fixfull", ISD::SETCC_INVALID},
       // TODO The following IS implemented in libgcc
       //{ RTLIB::SINTTOFP_I16_F64,  "__mspabi_fltid", ISD::SETCC_INVALID },
-    { RTLIB::SINTTOFP_I32_F64,  "__mspabi_fltlid",  ISD::SETCC_INVALID },
+      {RTLIB::SINTTOFP_I32_F64, "__mspabi_fltlid", ISD::SETCC_INVALID},
       // TODO The following IS implemented in libgcc but is not in the EABI
-    { RTLIB::SINTTOFP_I64_F64,  "__mspabi_fltllid", ISD::SETCC_INVALID },
+      {RTLIB::SINTTOFP_I64_F64, "__mspabi_fltllid", ISD::SETCC_INVALID},
       // TODO The following IS implemented in libgcc
       //{ RTLIB::UINTTOFP_I16_F64,  "__mspabi_fltud", ISD::SETCC_INVALID },
-    { RTLIB::UINTTOFP_I32_F64,  "__mspabi_fltuld",  ISD::SETCC_INVALID },
+      {RTLIB::UINTTOFP_I32_F64, "__mspabi_fltuld", ISD::SETCC_INVALID},
       // The following IS implemented in libgcc but is not in the EABI
-    { RTLIB::UINTTOFP_I64_F64,  "__mspabi_fltulld", ISD::SETCC_INVALID },
+      {RTLIB::UINTTOFP_I64_F64, "__mspabi_fltulld", ISD::SETCC_INVALID},
       // TODO The following IS implemented in libgcc
       //{ RTLIB::SINTTOFP_I16_F32,  "__mspabi_fltif", ISD::SETCC_INVALID },
-    { RTLIB::SINTTOFP_I32_F32,  "__mspabi_fltlif",  ISD::SETCC_INVALID },
+      {RTLIB::SINTTOFP_I32_F32, "__mspabi_fltlif", ISD::SETCC_INVALID},
       // TODO The following IS implemented in libgcc but is not in the EABI
-    { RTLIB::SINTTOFP_I64_F32,  "__mspabi_fltllif", ISD::SETCC_INVALID },
+      {RTLIB::SINTTOFP_I64_F32, "__mspabi_fltllif", ISD::SETCC_INVALID},
       // TODO The following IS implemented in libgcc
       //{ RTLIB::UINTTOFP_I16_F32,  "__mspabi_fltuf", ISD::SETCC_INVALID },
-    { RTLIB::UINTTOFP_I32_F32,  "__mspabi_fltulf",  ISD::SETCC_INVALID },
+      {RTLIB::UINTTOFP_I32_F32, "__mspabi_fltulf", ISD::SETCC_INVALID},
       // The following IS implemented in libgcc but is not in the EABI
-    { RTLIB::UINTTOFP_I64_F32,  "__mspabi_fltullf", ISD::SETCC_INVALID },
+      {RTLIB::UINTTOFP_I64_F32, "__mspabi_fltullf", ISD::SETCC_INVALID},
 
-    // Floating point comparisons - EABI Table 7
-    { RTLIB::OEQ_F64, "__mspabi_cmpd", ISD::SETEQ },
-    { RTLIB::UNE_F64, "__mspabi_cmpd", ISD::SETNE },
-    { RTLIB::OGE_F64, "__mspabi_cmpd", ISD::SETGE },
-    { RTLIB::OLT_F64, "__mspabi_cmpd", ISD::SETLT },
-    { RTLIB::OLE_F64, "__mspabi_cmpd", ISD::SETLE },
-    { RTLIB::OGT_F64, "__mspabi_cmpd", ISD::SETGT },
-    { RTLIB::OEQ_F32, "__mspabi_cmpf", ISD::SETEQ },
-    { RTLIB::UNE_F32, "__mspabi_cmpf", ISD::SETNE },
-    { RTLIB::OGE_F32, "__mspabi_cmpf", ISD::SETGE },
-    { RTLIB::OLT_F32, "__mspabi_cmpf", ISD::SETLT },
-    { RTLIB::OLE_F32, "__mspabi_cmpf", ISD::SETLE },
-    { RTLIB::OGT_F32, "__mspabi_cmpf", ISD::SETGT },
+      // NOT using __mspabi_cmp[fd] to compare floating point numbers because
+      // EABI Section 6.2 says the result is undefined if either argument is
+      // NaN.
+      // There are helpers with the traditional names in libgcc.
 
       // Floating point arithmetic - EABI Table 8
-    { RTLIB::ADD_F64,  "__mspabi_addd", ISD::SETCC_INVALID },
-    { RTLIB::ADD_F32,  "__mspabi_addf", ISD::SETCC_INVALID },
-    { RTLIB::DIV_F64,  "__mspabi_divd", ISD::SETCC_INVALID },
-    { RTLIB::DIV_F32,  "__mspabi_divf", ISD::SETCC_INVALID },
-    { RTLIB::MUL_F64,  "__mspabi_mpyd", ISD::SETCC_INVALID },
-    { RTLIB::MUL_F32,  "__mspabi_mpyf", ISD::SETCC_INVALID },
-    { RTLIB::SUB_F64,  "__mspabi_subd", ISD::SETCC_INVALID },
-    { RTLIB::SUB_F32,  "__mspabi_subf", ISD::SETCC_INVALID },
+      {RTLIB::ADD_F64, "__mspabi_addd", ISD::SETCC_INVALID},
+      {RTLIB::ADD_F32, "__mspabi_addf", ISD::SETCC_INVALID},
+      {RTLIB::DIV_F64, "__mspabi_divd", ISD::SETCC_INVALID},
+      {RTLIB::DIV_F32, "__mspabi_divf", ISD::SETCC_INVALID},
+      {RTLIB::MUL_F64, "__mspabi_mpyd", ISD::SETCC_INVALID},
+      {RTLIB::MUL_F32, "__mspabi_mpyf", ISD::SETCC_INVALID},
+      {RTLIB::SUB_F64, "__mspabi_subd", ISD::SETCC_INVALID},
+      {RTLIB::SUB_F32, "__mspabi_subf", ISD::SETCC_INVALID},
       // The following are NOT implemented in libgcc
       // { RTLIB::NEG_F64,  "__mspabi_negd", ISD::SETCC_INVALID },
       // { RTLIB::NEG_F32,  "__mspabi_negf", ISD::SETCC_INVALID },
 
       // Universal Integer Operations - EABI Table 9
-    { RTLIB::SDIV_I16,   "__mspabi_divi", ISD::SETCC_INVALID },
-    { RTLIB::SDIV_I32,   "__mspabi_divli", ISD::SETCC_INVALID },
-    { RTLIB::SDIV_I64,   "__mspabi_divlli", ISD::SETCC_INVALID },
-    { RTLIB::UDIV_I16,   "__mspabi_divu", ISD::SETCC_INVALID },
-    { RTLIB::UDIV_I32,   "__mspabi_divul", ISD::SETCC_INVALID },
-    { RTLIB::UDIV_I64,   "__mspabi_divull", ISD::SETCC_INVALID },
-    { RTLIB::SREM_I16,   "__mspabi_remi", ISD::SETCC_INVALID },
-    { RTLIB::SREM_I32,   "__mspabi_remli", ISD::SETCC_INVALID },
-    { RTLIB::SREM_I64,   "__mspabi_remlli", ISD::SETCC_INVALID },
-    { RTLIB::UREM_I16,   "__mspabi_remu", ISD::SETCC_INVALID },
-    { RTLIB::UREM_I32,   "__mspabi_remul", ISD::SETCC_INVALID },
-    { RTLIB::UREM_I64,   "__mspabi_remull", ISD::SETCC_INVALID },
+      {RTLIB::SDIV_I16, "__mspabi_divi", ISD::SETCC_INVALID},
+      {RTLIB::SDIV_I32, "__mspabi_divli", ISD::SETCC_INVALID},
+      {RTLIB::SDIV_I64, "__mspabi_divlli", ISD::SETCC_INVALID},
+      {RTLIB::UDIV_I16, "__mspabi_divu", ISD::SETCC_INVALID},
+      {RTLIB::UDIV_I32, "__mspabi_divul", ISD::SETCC_INVALID},
+      {RTLIB::UDIV_I64, "__mspabi_divull", ISD::SETCC_INVALID},
+      {RTLIB::SREM_I16, "__mspabi_remi", ISD::SETCC_INVALID},
+      {RTLIB::SREM_I32, "__mspabi_remli", ISD::SETCC_INVALID},
+      {RTLIB::SREM_I64, "__mspabi_remlli", ISD::SETCC_INVALID},
+      {RTLIB::UREM_I16, "__mspabi_remu", ISD::SETCC_INVALID},
+      {RTLIB::UREM_I32, "__mspabi_remul", ISD::SETCC_INVALID},
+      {RTLIB::UREM_I64, "__mspabi_remull", ISD::SETCC_INVALID},
 
       // Bitwise Operations - EABI Table 10
       // TODO: __mspabi_[srli/srai/slli] ARE implemented in libgcc
-    { RTLIB::SRL_I32,    "__mspabi_srll", ISD::SETCC_INVALID },
-    { RTLIB::SRA_I32,    "__mspabi_sral", ISD::SETCC_INVALID },
-    { RTLIB::SHL_I32,    "__mspabi_slll", ISD::SETCC_INVALID },
+      {RTLIB::SRL_I32, "__mspabi_srll", ISD::SETCC_INVALID},
+      {RTLIB::SRA_I32, "__mspabi_sral", ISD::SETCC_INVALID},
+      {RTLIB::SHL_I32, "__mspabi_slll", ISD::SETCC_INVALID},
       // __mspabi_[srlll/srall/sllll/rlli/rlll] are NOT implemented in libgcc
 
   };
 
   for (const auto &LC : LibraryCalls) {
     setLibcallName(LC.Op, LC.Name);
     if (LC.Cond != ISD::SETCC_INVALID)
       setCmpLibcallCC(LC.Op, LC.Cond);
   }
MSP430TargetLowering::MSP430TargetLowering(const TargetMachine &TM,
   setLibcallCallingConv(RTLIB::UDIV_I64, CallingConv::MSP430_BUILTIN);
   setLibcallCallingConv(RTLIB::UREM_I64, CallingConv::MSP430_BUILTIN);
   setLibcallCallingConv(RTLIB::SDIV_I64, CallingConv::MSP430_BUILTIN);
   setLibcallCallingConv(RTLIB::SREM_I64, CallingConv::MSP430_BUILTIN);
   setLibcallCallingConv(RTLIB::ADD_F64, CallingConv::MSP430_BUILTIN);
   setLibcallCallingConv(RTLIB::SUB_F64, CallingConv::MSP430_BUILTIN);
   setLibcallCallingConv(RTLIB::MUL_F64, CallingConv::MSP430_BUILTIN);
   setLibcallCallingConv(RTLIB::DIV_F64, CallingConv::MSP430_BUILTIN);
-  setLibcallCallingConv(RTLIB::OEQ_F64, CallingConv::MSP430_BUILTIN);
-  setLibcallCallingConv(RTLIB::UNE_F64, CallingConv::MSP430_BUILTIN);
-  setLibcallCallingConv(RTLIB::OGE_F64, CallingConv::MSP430_BUILTIN);
-  setLibcallCallingConv(RTLIB::OLT_F64, CallingConv::MSP430_BUILTIN);
-  setLibcallCallingConv(RTLIB::OLE_F64, CallingConv::MSP430_BUILTIN);
-  setLibcallCallingConv(RTLIB::OGT_F64, CallingConv::MSP430_BUILTIN);
   // TODO: __mspabi_srall, __mspabi_srlll, __mspabi_sllll
 
   setMinFunctionAlignment(Align(2));
   setPrefFunctionAlignment(Align(2));
 }
 
 SDValue MSP430TargetLowering::LowerOperation(SDValue Op,
                                              SelectionDAG &DAG) const {

llvm/test/CodeGen/MSP430/cmp-return-type.ll

 ; RUN: llc < %s | FileCheck %s
 
 target datalayout = "e-m:e-p:16:16-i32:16-i64:16-f32:16-f64:16-a:8-n8:16-S16"
 target triple = "msp430"
 
 define i16 @f(float %a, float %b) optsize {
   %cmp = fcmp une float %a, %b
   %conv = zext i1 %cmp to i16
-; CHECK-LABEL: call #__mspabi_cmpf
+; CHECK-LABEL: call #__nesf2
 ; CHECK-NOT:   r13
 ; CHECK-LABEL: mov r2
 
 ; This is quite fragile attempt to detect the return type:
 ; Correct:
-;        call    #__mspabi_cmpf
+;        call    #__nesf2
 ;        tst     r12
 ;        mov     r2, r13
 ; Incorrect:
-;        call    #__mspabi_cmpf
+;        call    #__nesf2
 ;        bis     r12, r13        <-- checking (R12:R13)
 ;        tst     r13
 ;        mov     r2, r13
 
   ret i16 %conv
 }

llvm/test/CodeGen/MSP430/libcalls.ll

; CHECK: call #__mspabi_fltullf
 
   ret float %1
 }
 
 define i1 @cmpd_oeq() #0 {
 entry:
 ; CHECK: cmpd_oeq:
 
-; CHECK: call #__mspabi_cmpd
+; CHECK: call #__eqdf2
   %0 = load volatile double, double* @g_double, align 8
   %1 = fcmp oeq double %0, 123.0
 
   ret i1 %1
 }
 
 define i1 @cmpd_une() #0 {
 entry:
 ; CHECK: cmpd_une:
 
-; CHECK: call #__mspabi_cmpd
+; CHECK: call #__nedf2
   %0 = load volatile double, double* @g_double, align 8
   %1 = fcmp une double %0, 123.0
 
   ret i1 %1
 }
 
 define i1 @cmpd_oge() #0 {
 entry:
 ; CHECK: cmpd_oge:
 
-; CHECK: call #__mspabi_cmpd
+; CHECK: call #__gedf2
   %0 = load volatile double, double* @g_double, align 8
   %1 = fcmp oge double %0, 123.0
 
   ret i1 %1
 }
 
 define i1 @cmpd_olt() #0 {
 entry:
 ; CHECK: cmpd_olt:
 
-; CHECK: call #__mspabi_cmpd
+; CHECK: call #__ltdf2
   %0 = load volatile double, double* @g_double, align 8
   %1 = fcmp olt double %0, 123.0
 
   ret i1 %1
 }
 
 define i1 @cmpd_ole() #0 {
 entry:
 ; CHECK: cmpd_ole:
 
-; CHECK: call #__mspabi_cmpd
+; CHECK: call #__ledf2
   %0 = load volatile double, double* @g_double, align 8
   %1 = fcmp ole double %0, 123.0
 
   ret i1 %1
 }
 
 define i1 @cmpd_ogt() #0 {
 entry:
 ; CHECK: cmpd_ogt:
 
-; CHECK: call #__mspabi_cmpd
+; CHECK: call #__gtdf2
   %0 = load volatile double, double* @g_double, align 8
   %1 = fcmp ogt double %0, 123.0
 
   ret i1 %1
 }
 
 define i1 @cmpf_oeq() #0 {
 entry:
 ; CHECK: cmpf_oeq:
 
-; CHECK: call #__mspabi_cmpf
+; CHECK: call #__eqsf2
   %0 = load volatile float, float* @g_float, align 8
   %1 = fcmp oeq float %0, 123.0
 
   ret i1 %1
 }
 
 define i1 @cmpf_une() #0 {
 entry:
 ; CHECK: cmpf_une:
 
-; CHECK: call #__mspabi_cmpf
+; CHECK: call #__nesf2
   %0 = load volatile float, float* @g_float, align 8
   %1 = fcmp une float %0, 123.0
 
   ret i1 %1
 }
 
 define i1 @cmpf_oge() #0 {
 entry:
 ; CHECK: cmpf_oge:
 
-; CHECK: call #__mspabi_cmpf
+; CHECK: call #__gesf2
   %0 = load volatile float, float* @g_float, align 8
   %1 = fcmp oge float %0, 123.0
 
   ret i1 %1
 }
 
 define i1 @cmpf_olt() #0 {
 entry:
 ; CHECK: cmpf_olt:
 
-; CHECK: call #__mspabi_cmpf
+; CHECK: call #__ltsf2
   %0 = load volatile float, float* @g_float, align 8
   %1 = fcmp olt float %0, 123.0
 
   ret i1 %1
 }
 
 define i1 @cmpf_ole() #0 {
 entry:
 ; CHECK: cmpf_ole:
 
-; CHECK: call #__mspabi_cmpf
+; CHECK: call #__lesf2
   %0 = load volatile float, float* @g_float, align 8
   %1 = fcmp ole float %0, 123.0
 
   ret i1 %1
 }
 
 define i1 @cmpf_ogt() #0 {
 entry:
 ; CHECK: cmpf_ogt:
 
-; CHECK: call #__mspabi_cmpf
+; CHECK: call #__gtsf2
   %0 = load volatile float, float* @g_float, align 8
   %1 = fcmp ogt float %0, 123.0
 
   ret i1 %1
 }
 
 define double @addd() #0 {
 entry: