ARM: Add subtract to the type recording binary operation stub.

src/arm/code-stubs-arm.cc

 // Copyright 2011 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 2415 matching lines @@
 
   OS::SNPrintF(Vector<char>(name_, kMaxNameLength),
                "TypeRecordingBinaryOpStub_%s_%s_%s",
                op_name,
                overwrite_name,
                TRBinaryOpIC::GetName(operands_type_));
   return name_;
 }
 
 
+void TypeRecordingBinaryOpStub::GenerateOptimisticSmiOperation(
+    MacroAssembler* masm) {
+  Register left = r1;
+  Register right = r0;
+
+  ASSERT(right.is(r0));
+
+  switch (op_) {
+    case Token::ADD:
+      __ add(right, left, Operand(right), SetCC); // Add optimistically.
+      __ Ret(vc);
+      __ sub(right, right, Operand(left));  // Revert optimistic add.
+      break;
+    case Token::SUB:
+      __ sub(right, left, Operand(right), SetCC);  // Subtract optimistically.
+      __ Ret(vc);
+      __ sub(right, left, Operand(right));  // Revert optimistic subtract.

[Alexandre, 2011/01/25 16:51:15]

Shouldn't it be an add(right, right, Operand(left)); ?

[Alexandre, 2011/01/25 16:54:45]

Sorry I messed up with these right and left.
On 2011/01/25 16:51:15, Alexandre wrote:

+      break;
+    default:
+      UNREACHABLE();
+  }
+}
+
+
+void TypeRecordingBinaryOpStub::GenerateVFPOperation(
+    MacroAssembler* masm) {
+  switch (op_) {
+    case Token::ADD:
+      __ vadd(d5, d6, d7);
+      break;
+    case Token::SUB:
+      __ vsub(d5, d6, d7);
+      break;
+    default:
+      UNREACHABLE();
+  }
+
+}
+
+
 // Generate the smi code. If the operation on smis are successful this return is
 // generated. If the result is not a smi and heap number allocation is not
 // requested the code falls through. If number allocation is requested but a
 // heap number cannot be allocated the code jumps to the lable gc_required.
 void TypeRecordingBinaryOpStub::GenerateSmiCode(MacroAssembler* masm,
     Label* gc_required,
     SmiCodeGenerateHeapNumberResults allow_heapnumber_results) {
   Label not_smis;
 
-  ASSERT(op_ == Token::ADD);
+  ASSERT(op_ == Token::ADD || op_ == Token::SUB);
 
   Register left = r1;
   Register right = r0;
   Register scratch1 = r7;
   Register scratch2 = r9;
 
   // Perform combined smi check on both operands.
   __ orr(scratch1, left, Operand(right));
   STATIC_ASSERT(kSmiTag == 0);
   __ tst(scratch1, Operand(kSmiTagMask));
   __ b(ne, &not_smis);
 
-  __ add(right, right, Operand(left), SetCC);  // Add optimistically.
-
-  // Return smi result if no overflow (r0 is the result).
-  ASSERT(right.is(r0));
-  __ Ret(vc);
-
-  // Result is not a smi. Revert the optimistic add.
-  __ sub(right, right, Operand(left));
+  GenerateOptimisticSmiOperation(masm);
 
   // If heap number results are possible generate the result in an allocated
   // heap number.
   if (allow_heapnumber_results == ALLOW_HEAPNUMBER_RESULTS) {
     FloatingPointHelper::Destination destination =
         CpuFeatures::IsSupported(VFP3) && Token::MOD != op_ ?
         FloatingPointHelper::kVFPRegisters :
         FloatingPointHelper::kCoreRegisters;
 
     Register heap_number_map = r6;
     __ LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
 
     // Allocate new heap number for result.
     Register heap_number = r5;
     __ AllocateHeapNumber(
         heap_number, scratch1, scratch2, heap_number_map, gc_required);
 
     // Load the smis.
     FloatingPointHelper::LoadSmis(masm, destination, scratch1, scratch2);
 
     // Calculate the result.
     if (destination == FloatingPointHelper::kVFPRegisters) {
       // Using VFP registers:
       // d6: Left value
       // d7: Right value
       CpuFeatures::Scope scope(VFP3);
-      __ vadd(d5, d6, d7);
+      GenerateVFPOperation(masm);
 
       __ sub(r0, heap_number, Operand(kHeapObjectTag));
       __ vstr(d5, r0, HeapNumber::kValueOffset);
       __ add(r0, r0, Operand(kHeapObjectTag));
       __ Ret();
     } else {
       // Using core registers:
       // r0: Left value (least significant part of mantissa).
       // r1: Left value (sign, exponent, top of mantissa).
       // r2: Right value (least significant part of mantissa).
@@ skipping 20 matching lines @@
       __ pop(pc);
     }
   }
   __ bind(&not_smis);
 }
 
 
 void TypeRecordingBinaryOpStub::GenerateSmiStub(MacroAssembler* masm) {
   Label not_smis, call_runtime;
 
-  ASSERT(op_ == Token::ADD);
+  ASSERT(op_ == Token::ADD || op_ == Token::SUB);
 
   if (result_type_ == TRBinaryOpIC::UNINITIALIZED ||
       result_type_ == TRBinaryOpIC::SMI) {
     // Only allow smi results.
     GenerateSmiCode(masm, NULL, NO_HEAPNUMBER_RESULTS);
   } else {
     // Allow heap number result and don't make a transition if a heap number
     // cannot be allocated.
     GenerateSmiCode(masm, &call_runtime, ALLOW_HEAPNUMBER_RESULTS);
   }
@@ skipping 11 matching lines @@
   ASSERT(operands_type_ == TRBinaryOpIC::STRING);
   ASSERT(op_ == Token::ADD);
   // Try to add arguments as strings, otherwise, transition to the generic
   // TRBinaryOpIC type.
   GenerateAddStrings(masm);
   GenerateTypeTransition(masm);
 }
 
 
 void TypeRecordingBinaryOpStub::GenerateInt32Stub(MacroAssembler* masm) {
-  ASSERT(op_ == Token::ADD);
+  ASSERT(op_ == Token::ADD || op_ == Token::SUB);
 
   ASSERT(operands_type_ == TRBinaryOpIC::INT32);
 
   GenerateTypeTransition(masm);
 }
 
 
 void TypeRecordingBinaryOpStub::GenerateHeapNumberStub(MacroAssembler* masm) {
-  ASSERT(op_ == Token::ADD);
+  ASSERT(op_ == Token::ADD || op_ == Token::SUB);
 
   Register scratch1 = r7;
   Register scratch2 = r9;
 
   Label not_number, call_runtime;
   ASSERT(operands_type_ == TRBinaryOpIC::HEAP_NUMBER);
 
   Register heap_number_map = r6;
   __ LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
 
   // Load left and right operands into d6 and d7 or r0/r1 and r2/r3 depending on
   // whether VFP3 is available.
   FloatingPointHelper::Destination destination =
       CpuFeatures::IsSupported(VFP3) ?
       FloatingPointHelper::kVFPRegisters :
       FloatingPointHelper::kCoreRegisters;
   FloatingPointHelper::LoadOperands(masm,
                                     destination,
                                     heap_number_map,
                                     scratch1,
                                     scratch2,
                                     &not_number);
   if (destination == FloatingPointHelper::kVFPRegisters) {
     // Use floating point instructions for the binary operation.
     CpuFeatures::Scope scope(VFP3);
-    __ vadd(d5, d6, d7);
+    GenerateVFPOperation(masm);
 
     // Get a heap number object for the result - might be left or right if one
     // of these are overwritable.
     GenerateHeapResultAllocation(
         masm, r4, heap_number_map, scratch1, scratch2, &call_runtime);
 
     // Fill the result into the allocated heap number and return.
     __ sub(r0, r4, Operand(kHeapObjectTag));
     __ vstr(d5, r0, HeapNumber::kValueOffset);
     __ add(r0, r0, Operand(kHeapObjectTag));
@@ skipping 33 matching lines @@
 
   __ bind(&not_number);
   GenerateTypeTransition(masm);
 
   __ bind(&call_runtime);
   GenerateCallRuntime(masm);
 }
 
 
 void TypeRecordingBinaryOpStub::GenerateGeneric(MacroAssembler* masm) {
-  ASSERT(op_ == Token::ADD);
+  ASSERT(op_ == Token::ADD || op_ == Token::SUB);
 
   Label call_runtime;
 
   GenerateSmiCode(masm, &call_runtime, ALLOW_HEAPNUMBER_RESULTS);
 
   // If all else fails, use the runtime system to get the correct
   // result.
   __ bind(&call_runtime);
 
   // Try to add strings before calling runtime.
@@ skipping 23 matching lines @@
   StringAddStub string_add_stub(NO_STRING_CHECK_IN_STUB);
   GenerateRegisterArgsPush(masm);
   __ TailCallStub(&string_add_stub);
 
   // At least one argument is not a string.
   __ bind(&call_runtime);
 }
 
 
 void TypeRecordingBinaryOpStub::GenerateCallRuntime(MacroAssembler* masm) {
+  GenerateRegisterArgsPush(masm);
   switch (op_) {
     case Token::ADD:
-      GenerateRegisterArgsPush(masm);
       __ InvokeBuiltin(Builtins::ADD, JUMP_JS);
       break;
+    case Token::SUB:
+      __ InvokeBuiltin(Builtins::SUB, JUMP_JS);
+      break;
     default:
       UNREACHABLE();
   }
 }
 
 
 void TypeRecordingBinaryOpStub::GenerateHeapResultAllocation(
     MacroAssembler* masm,
     Register result,
     Register heap_number_map,
@@ skipping 2907 matching lines @@
   __ pop(r1);
   __ Jump(r2);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM