[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 },
     // 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 },
     // The following is NOT implemented in libgcc
     //{ RTLIB::FPTOUINT_F64_I16,  "__mspabi_fixdu", ISD::SETCC_INVALID },
const struct {
     // TODO The following IS implemented in libgcc but is not in the EABI
     { 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 },
     // The following IS implemented in libgcc but is not in the EABI
     { 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 },
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: