Remove override mode from BinaryOpStub

src/x64/code-stubs-x64.cc

 // Copyright 2013 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 717 matching lines @@
     convert_undefined = FloatingPointHelper::CONVERT_UNDEFINED_TO_ZERO;
   }
   FloatingPointHelper::NumbersToSmis(masm, left, right, rbx, rdi, rcx,
                                      &smi_values, &fail, convert_undefined);
   __ jmp(&smi_values);
   __ bind(&fail);
 }
 
 
 static void BinaryOpStub_GenerateHeapResultAllocation(MacroAssembler* masm,
-                                                      Label* alloc_failure,
-                                                      OverwriteMode mode);
+                                                      Label* alloc_failure);
 
 
 static void BinaryOpStub_GenerateFloatingPointCode(MacroAssembler* masm,
                                                    Label* allocation_failure,
                                                    Label* non_numeric_failure,
-                                                   Token::Value op,
-                                                   OverwriteMode mode) {
+                                                   Token::Value op) {
   switch (op) {
     case Token::ADD:
     case Token::SUB:
     case Token::MUL:
     case Token::DIV: {
       FloatingPointHelper::LoadSSE2UnknownOperands(masm, non_numeric_failure);
 
       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();
       }
       BinaryOpStub_GenerateHeapResultAllocation(
-          masm, allocation_failure, mode);
+          masm, allocation_failure);
       __ movsd(FieldOperand(rax, HeapNumber::kValueOffset), xmm0);
       __ ret(0);
       break;
     }
     case Token::MOD: {
       // For MOD we jump to the allocation_failure label, to call runtime.
       __ jmp(allocation_failure);
       break;
     }
     case Token::BIT_OR:
@@ skipping 252 matching lines @@
   // or the right operand. For precise type feedback, patch the IC
   // again if this changes.
   if (left_type_ == BinaryOpIC::SMI) {
     BinaryOpStub_CheckSmiInput(masm, rdx, &not_number);
   }
   if (right_type_ == BinaryOpIC::SMI) {
     BinaryOpStub_CheckSmiInput(masm, rax, &not_number);
   }
 
   BinaryOpStub_GenerateFloatingPointCode(
-      masm, &gc_required, &not_number, op_, mode_);
+      masm, &gc_required, &not_number, op_);
 
   __ bind(&not_number);
   GenerateTypeTransition(masm);
 
   __ bind(&gc_required);
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     GenerateRegisterArgsPush(masm);
     GenerateCallRuntime(masm);
   }
   __ Ret();
 }
 
 
 void BinaryOpStub::GenerateGeneric(MacroAssembler* masm) {
   Label call_runtime, call_string_add_or_runtime;
 
   BinaryOpStub_GenerateSmiCode(
       masm, &call_runtime, ALLOW_HEAPNUMBER_RESULTS, op_);
 
   BinaryOpStub_GenerateFloatingPointCode(
-      masm, &call_runtime, &call_string_add_or_runtime, op_, mode_);
+      masm, &call_runtime, &call_string_add_or_runtime, op_);
 
   __ bind(&call_string_add_or_runtime);
   if (op_ == Token::ADD) {
     GenerateAddStrings(masm);
   }
 
   __ bind(&call_runtime);
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     GenerateRegisterArgsPush(masm);
     GenerateCallRuntime(masm);
   }
   __ Ret();
 }
 
 
 static void BinaryOpStub_GenerateHeapResultAllocation(MacroAssembler* masm,
-                                                      Label* alloc_failure,
-                                                      OverwriteMode mode) {
+                                                      Label* alloc_failure) {
   Label skip_allocation;
-  switch (mode) {
-    case OVERWRITE_LEFT: {
-      // If the argument in rdx is already an object, we skip the
-      // allocation of a heap number.
-      __ JumpIfNotSmi(rdx, &skip_allocation);
-      // Allocate a heap number for the result. Keep rax and rdx intact
-      // for the possible runtime call.
-      __ AllocateHeapNumber(rbx, rcx, alloc_failure);
-      // Now rdx can be overwritten losing one of the arguments as we are
-      // now done and will not need it any more.
-      __ movq(rdx, rbx);
-      __ bind(&skip_allocation);
-      // Use object in rdx as a result holder
-      __ movq(rax, rdx);
-      break;
-    }
-    case OVERWRITE_RIGHT:
-      // If the argument in rax is already an object, we skip the
-      // allocation of a heap number.
-      __ JumpIfNotSmi(rax, &skip_allocation);
-      // Fall through!
-    case NO_OVERWRITE:
-      // Allocate a heap number for the result. Keep rax and rdx intact
-      // for the possible runtime call.
-      __ AllocateHeapNumber(rbx, rcx, alloc_failure);
-      // Now rax can be overwritten losing one of the arguments as we are
-      // now done and will not need it any more.
-      __ movq(rax, rbx);
-      __ bind(&skip_allocation);
-      break;
-    default: UNREACHABLE();
-  }
+  // Allocate a heap number for the result. Keep rax and rdx intact
+  // for the possible runtime call.
+  __ AllocateHeapNumber(rbx, rcx, alloc_failure);
+  // Now rax can be overwritten losing one of the arguments as we are
+  // now done and will not need it any more.
+  __ movq(rax, rbx);
+  __ bind(&skip_allocation);
 }
 
 
 void BinaryOpStub::GenerateRegisterArgsPush(MacroAssembler* masm) {
   __ push(rdx);
   __ push(rax);
 }
 
 
 void TranscendentalCacheStub::Generate(MacroAssembler* masm) {
@@ skipping 5521 matching lines @@
   __ bind(&fast_elements_case);
   GenerateCase(masm, FAST_ELEMENTS);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64