IA32: Small assembler tweak for divsd->mulsd sequence

src/ia32/lithium-codegen-ia32.cc

 // Copyright 2012 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 2000 matching lines @@
       __ addsd(left, right);
       break;
     case Token::SUB:
       __ subsd(left, right);
       break;
     case Token::MUL:
       __ mulsd(left, right);
       break;
     case Token::DIV:
       __ divsd(left, right);
+      // Don't delete this mov. It may improve performance on some CPUs,
+      // when there is a mulsd depending on the result
+      {
+        bool has_dependent_mul = false;
+        HValue* value = instr->hydrogen_value();
+        for (HUseIterator it(value->uses()); !it.Done(); it.Advance()) {
+          HValue* use = it.value();
+          if (!use->IsMul()) continue;
+          LArithmeticD* lmul = NULL;
+          for (int i = use->block()->first_instruction_index();
+               i <= use->block()->last_instruction_index(); i++) {
+            LInstruction* luse = chunk_->instructions()->at(i);
+            if (luse->hydrogen_value() == use) {
+              ASSERT(luse->IsArithmeticD());
+              lmul = reinterpret_cast<LArithmeticD*>(luse);
+              ASSERT(lmul->op() == Token::MUL);
+              break;
+            }
+          }
+          if (lmul->left()->Equals(instr->left()) ||
+              lmul->right()->Equals(instr->left())) {
+            has_dependent_mul = true;
+            break;
+          }
+        }
+        if (has_dependent_mul) {
+          __ movaps(left, left);
+        }
+      }
       break;
     case Token::MOD: {
       // Pass two doubles as arguments on the stack.
       __ PrepareCallCFunction(4, eax);
       __ movdbl(Operand(esp, 0 * kDoubleSize), left);
       __ movdbl(Operand(esp, 1 * kDoubleSize), right);
       __ CallCFunction(
           ExternalReference::double_fp_operation(Token::MOD, isolate()),
           4);
 
@@ skipping 4712 matching lines @@
                               FixedArray::kHeaderSize - kPointerSize));
   __ bind(&done);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32