X64: Use allocation with no scratch registers to avoid push/pop.

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 5951 matching lines @@
   OverwriteMode mode_;
 };
 
 
 void DeferredInlineBinaryOperation::Generate() {
   Label done;
   if ((op_ == Token::ADD)
       || (op_ ==Token::SUB)
       || (op_ == Token::MUL)
       || (op_ == Token::DIV)) {
-    Label call_runtime, after_alloc_failure;
+    Label call_runtime;
     Label left_smi, right_smi, load_right, do_op;
     __ JumpIfSmi(left_, &left_smi);
     __ CompareRoot(FieldOperand(left_, HeapObject::kMapOffset),
                    Heap::kHeapNumberMapRootIndex);
     __ j(not_equal, &call_runtime);
     __ movsd(xmm0, FieldOperand(left_, HeapNumber::kValueOffset));
     if (mode_ == OVERWRITE_LEFT) {
       __ movq(dst_, left_);
     }
     __ jmp(&load_right);
 
     __ bind(&left_smi);
     __ SmiToInteger32(left_, left_);
     __ cvtlsi2sd(xmm0, left_);
     __ Integer32ToSmi(left_, left_);
     if (mode_ == OVERWRITE_LEFT) {
       Label alloc_failure;
-      __ push(left_);
-      __ AllocateHeapNumber(dst_, left_, &after_alloc_failure);
-      __ pop(left_);
+      __ AllocateHeapNumber(dst_, no_reg, &call_runtime);
     }
 
     __ bind(&load_right);
     __ JumpIfSmi(right_, &right_smi);
     __ CompareRoot(FieldOperand(right_, HeapObject::kMapOffset),
                    Heap::kHeapNumberMapRootIndex);
     __ j(not_equal, &call_runtime);
     __ movsd(xmm1, FieldOperand(right_, HeapNumber::kValueOffset));
     if (mode_ == OVERWRITE_RIGHT) {
       __ movq(dst_, right_);
     } else if (mode_ == NO_OVERWRITE) {
       Label alloc_failure;
-      __ push(left_);
-      __ AllocateHeapNumber(dst_, left_, &after_alloc_failure);
-      __ pop(left_);
+      __ AllocateHeapNumber(dst_, no_reg, &call_runtime);
     }
     __ jmp(&do_op);
 
     __ bind(&right_smi);
     __ SmiToInteger32(right_, right_);
     __ cvtlsi2sd(xmm1, right_);
     __ Integer32ToSmi(right_, right_);
     if (mode_ == OVERWRITE_RIGHT || mode_ == NO_OVERWRITE) {
       Label alloc_failure;
-      __ push(left_);
-      __ AllocateHeapNumber(dst_, left_, &after_alloc_failure);
-      __ pop(left_);
+      __ AllocateHeapNumber(dst_, no_reg, &call_runtime);
     }
 
     __ bind(&do_op);
     switch (op_) {
       case Token::ADD: __ addsd(xmm0, xmm1); break;
       case Token::SUB: __ subsd(xmm0, xmm1); break;
       case Token::MUL: __ mulsd(xmm0, xmm1); break;
       case Token::DIV: __ divsd(xmm0, xmm1); break;
       default: UNREACHABLE();
     }
     __ movsd(FieldOperand(dst_, HeapNumber::kValueOffset), xmm0);
     __ jmp(&done);
 
-    __ bind(&after_alloc_failure);
-    __ pop(left_);
     __ bind(&call_runtime);
   }
   GenericBinaryOpStub stub(op_, mode_, NO_SMI_CODE_IN_STUB);
   stub.GenerateCall(masm_, left_, right_);
   if (!dst_.is(rax)) __ movq(dst_, rax);
   __ bind(&done);
 }
 
 
 static TypeInfo CalculateTypeInfo(TypeInfo operands_type,
@@ skipping 4986 matching lines @@
   // Call the function from C++.
   return FUNCTION_CAST<ModuloFunction>(buffer);
 }
 
 #endif
 
 
 #undef __
 
 } }  // namespace v8::internal