Perform type specialization when either source is float. Update destination value to boolean.

Author: nhat-nguyen

lib/Backend/GlobOpt.cpp

@@ -10473,6 +10473,7 @@ GlobOpt::TypeSpecializeFloatBinary(IR::Instr *instr, Value *src1Val, Value *src2
     bool skipSrc1 = false;
     bool skipSrc2 = false;
     bool skipDst = false;
+    bool convertDstToBool = false;
 
     if (!this->DoFloatTypeSpec())
     {
@@ -10544,6 +10545,19 @@ GlobOpt::TypeSpecializeFloatBinary(IR::Instr *instr, Value *src1Val, Value *src2
             skipDst = true;
             break;
 
+        case Js::OpCode::CmEq_A:
+        case Js::OpCode::CmSrEq_A:
+        case Js::OpCode::CmNeq_A:
+        case Js::OpCode::CmSrNeq_A:
+        case Js::OpCode::CmLe_A:
+        case Js::OpCode::CmLt_A:
+        case Js::OpCode::CmGe_A:
+        case Js::OpCode::CmGt_A:
+        {
+            convertDstToBool = true;
+            break;
+        }
+        
         default:
             return false;
         }
@@ -10589,13 +10603,19 @@ GlobOpt::TypeSpecializeFloatBinary(IR::Instr *instr, Value *src1Val, Value *src2
     if (!skipDst)
     {
         dst = instr->GetDst();
-
         if (dst)
         {
-            *pDstVal = CreateDstUntransferredValue(ValueType::Float, instr, src1Val, src2Val);
-
-            AssertMsg(dst->IsRegOpnd(), "What else?");
-            this->ToFloat64Dst(instr, dst->AsRegOpnd(), this->currentBlock);
+            if (convertDstToBool)
+            {
+                *pDstVal = CreateDstUntransferredValue(ValueType::Boolean, instr, src1Val, src2Val);
+                ToVarRegOpnd(dst->AsRegOpnd(), currentBlock);
+            }
+            else
+            {
+                *pDstVal = CreateDstUntransferredValue(ValueType::Float, instr, src1Val, src2Val);
+                AssertMsg(dst->IsRegOpnd(), "What else?");
+                this->ToFloat64Dst(instr, dst->AsRegOpnd(), this->currentBlock);
+            }
         }
     }
 

lib/Backend/LowerMDShared.cpp

@@ -2653,9 +2653,7 @@ void LowererMD::GenerateFastCmXx(IR::Instr *instr)
     bool isFloatSrc = src1->IsFloat();
     bool isInt64Src = src1->IsInt64();
     Assert(!isFloatSrc || src2->IsFloat());
-    Assert(!isFloatSrc || isIntDst);
     Assert(!isInt64Src || src2->IsInt64());
-    Assert(!isInt64Src || isIntDst);
     Assert(!isFloatSrc || AutoSystemInfo::Data.SSE2Available());
     IR::Opnd *opnd;
     IR::Instr *newInstr;
@@ -2684,16 +2682,18 @@ void LowererMD::GenerateFastCmXx(IR::Instr *instr)
         done = instr;
     }
 
+    bool isNegOpt = instr->m_opcode == Js::OpCode::CmNeq_A || instr->m_opcode == Js::OpCode::CmSrNeq_A;
     if (isIntDst)
     {
+        // Fast path for float src when destination is type specialized to int
         // reg = MOV 0 will get peeped to XOR reg, reg which sets the flags.
         // Put the MOV before the CMP, but use a tmp if dst == src1/src2
         if (dst->IsEqual(src1) || dst->IsEqual(src2))
         {
             tmp = IR::RegOpnd::New(dst->GetType(), this->m_func);
         }
         // dst = MOV 0
-        if (isFloatSrc && instr->m_opcode == Js::OpCode::CmNeq_A)
+        if (isFloatSrc && isNegOpt)
         {
             opnd = IR::IntConstOpnd::New(1, TyInt32, this->m_func);
         }
@@ -2703,6 +2703,20 @@ void LowererMD::GenerateFastCmXx(IR::Instr *instr)
         }
         m_lowerer->InsertMove(tmp, opnd, done);
     }
+    else if (isFloatSrc)
+    {
+        // Fast path for float src when destination is not type specialized to int
+        // Assign default value for destination in case either src is NaN
+        if (isNegOpt)
+        {
+            opnd = this->m_lowerer->LoadLibraryValueOpnd(instr, LibraryValue::ValueTrue);
+        }
+        else
+        {
+            opnd = this->m_lowerer->LoadLibraryValueOpnd(instr, LibraryValue::ValueFalse);
+        }
+        Lowerer::InsertMove(tmp, opnd, done);
+    }
 
     Js::OpCode cmpOp;
     if (isFloatSrc)
@@ -2744,11 +2758,13 @@ void LowererMD::GenerateFastCmXx(IR::Instr *instr)
     {
     case Js::OpCode::CmEq_I4:
     case Js::OpCode::CmEq_A:
+    case Js::OpCode::CmSrEq_A:
         useCC = isIntDst ? Js::OpCode::SETE : Js::OpCode::CMOVE;
         break;
 
     case Js::OpCode::CmNeq_I4:
     case Js::OpCode::CmNeq_A:
+    case Js::OpCode::CmSrNeq_A:
         useCC = isIntDst ? Js::OpCode::SETNE : Js::OpCode::CMOVNE;
         break;