Remove the comisd instruction from the ia32 and x64 assemblers. We...

src/x64/codegen-x64.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 4405 matching lines @@
   __ movsd(xmm1, xmm3);
   __ sqrtsd(xmm1, xmm1);
   __ jmp(&allocate_return);
 
   // Test for 0.5.
   __ bind(&not_minus_half);
   // Load xmm2 with 0.5.
   // Since xmm3 is 1 and xmm2 is -0.5 this is simply xmm2 + xmm3.
   __ addsd(xmm2, xmm3);
   // xmm2 now has 0.5.
-  __ comisd(xmm2, xmm1);
+  __ ucomisd(xmm2, xmm1);
   call_runtime.Branch(not_equal);
 
   // Calculates square root.
   __ movsd(xmm1, xmm0);
   __ sqrtsd(xmm1, xmm1);
 
   JumpTarget done;
   Label failure, success;
   __ bind(&allocate_return);
   // Make a copy of the frame to enable us to handle allocation
@@ skipping 2062 matching lines @@
                                                    ControlDestination* dest) {
   ASSERT(left_side->is_register());
   ASSERT(right_side->is_register());
 
   JumpTarget not_numbers;
   // Load left and right operand into registers xmm0 and xmm1 and compare.
   LoadComparisonOperand(masm_, left_side, xmm0, left_side, right_side,
                         &not_numbers);
   LoadComparisonOperand(masm_, right_side, xmm1, left_side, right_side,
                         &not_numbers);
-  __ comisd(xmm0, xmm1);
+  __ ucomisd(xmm0, xmm1);
   // Bail out if a NaN is involved.
   not_numbers.Branch(parity_even, left_side, right_side);
 
   // Split to destination targets based on comparison.
   left_side->Unuse();
   right_side->Unuse();
   dest->true_target()->Branch(DoubleCondition(cc));
   dest->false_target()->Jump();
 
   not_numbers.Bind(left_side, right_side);
@@ skipping 2376 matching lines @@
     __ movq(probe,
             FieldOperand(number_string_cache,
                          index,
                          times_1,
                          FixedArray::kHeaderSize));
     __ JumpIfSmi(probe, not_found);
     ASSERT(CpuFeatures::IsSupported(SSE2));
     CpuFeatures::Scope fscope(SSE2);
     __ movsd(xmm0, FieldOperand(object, HeapNumber::kValueOffset));
     __ movsd(xmm1, FieldOperand(probe, HeapNumber::kValueOffset));
-    __ comisd(xmm0, xmm1);
+    __ ucomisd(xmm0, xmm1);
     __ j(parity_even, not_found);  // Bail out if NaN is involved.
     __ j(not_equal, not_found);  // The cache did not contain this value.
     __ jmp(&load_result_from_cache);
   }
 
   __ bind(&is_smi);
   __ movq(scratch, object);
   __ SmiToInteger32(scratch, scratch);
   GenerateConvertHashCodeToIndex(masm, scratch, mask);
 
@@ skipping 186 matching lines @@
 
   // Generate the number comparison code.
   if (include_number_compare_) {
     Label non_number_comparison;
     Label unordered;
     FloatingPointHelper::LoadFloatOperand(masm, rdx, xmm0,
                                           &non_number_comparison);
     FloatingPointHelper::LoadFloatOperand(masm, rax, xmm1,
                                           &non_number_comparison);
 
-    __ comisd(xmm0, xmm1);
+    __ ucomisd(xmm0, xmm1);
 
     // Don't base result on EFLAGS when a NaN is involved.
     __ j(parity_even, &unordered);
     // Return a result of -1, 0, or 1, based on EFLAGS.
     __ movq(rax, Immediate(0));  // equal
     __ movq(rcx, Immediate(1));
     __ cmovq(above, rax, rcx);
     __ movq(rcx, Immediate(-1));
     __ cmovq(below, rax, rcx);
     __ ret(2 * kPointerSize);  // rax, rdx were pushed
@@ skipping 2820 matching lines @@
 }
 
 #endif
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64