ARM: Add multiplication and modulus to the type recording binary operation st...

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 371 matching lines @@
                        Destination destination,
                        Register scratch1,
                        Register scratch2);
 
   // Loads objects from r0 and r1 (right and left in binary operations) into
   // floating point registers. Depending on the destination the values ends up
   // either d7 and d6 or in r2/r3 and r0/r1 respectively. If the destination is
   // floating point registers VFP3 must be supported. If core registers are
   // requested when VFP3 is supported d6 and d7 will still be scratched. If
   // either r0 or r1 is not a number (not smi and not heap number object) the
-  // not_number label is jumped to.
+  // not_number label is jumped to with r0 and r1 intact.
   static void LoadOperands(MacroAssembler* masm,
                            FloatingPointHelper::Destination destination,
                            Register heap_number_map,
                            Register scratch1,
                            Register scratch2,
                            Label* not_number);
  private:
   static void LoadNumber(MacroAssembler* masm,
                          FloatingPointHelper::Destination destination,
                          Register object,
                          DwVfpRegister dst,
                          Register dst1,
                          Register dst2,
                          Register heap_number_map,
                          Register scratch1,
                          Register scratch2,
                          Label* not_number);
 };
 
 
 void FloatingPointHelper::LoadSmis(MacroAssembler* masm,
                                    FloatingPointHelper::Destination destination,
                                    Register scratch1,
                                    Register scratch2) {
   if (CpuFeatures::IsSupported(VFP3)) {
     CpuFeatures::Scope scope(VFP3);
     __ mov(scratch1, Operand(r0, ASR, kSmiTagSize));
-    __ vmov(s15, scratch1);
-    __ vcvt_f64_s32(d7, s15);
+    __ vmov(d7.high(), scratch1);
+    __ vcvt_f64_s32(d7, d7.high());
     __ mov(scratch1, Operand(r1, ASR, kSmiTagSize));
-    __ vmov(s13, scratch1);
-    __ vcvt_f64_s32(d6, s13);
+    __ vmov(d6.high(), scratch1);
+    __ vcvt_f64_s32(d6, d6.high());
     if (destination == kCoreRegisters) {
       __ vmov(r2, r3, d7);
       __ vmov(r0, r1, d6);
     }
   } else {
     ASSERT(destination == kCoreRegisters);
     // Write Smi from r0 to r3 and r2 in double format.
     __ mov(scratch1, Operand(r0));
     ConvertToDoubleStub stub1(r3, r2, scratch1, scratch2);
     __ push(lr);
@@ skipping 34 matching lines @@
                                        Register heap_number_map,
                                        Register scratch1,
                                        Register scratch2,
                                        Label* not_number) {
   Label is_smi, done;
 
   __ JumpIfSmi(object, &is_smi);
   __ JumpIfNotHeapNumber(object, heap_number_map, scratch1, not_number);
 
   // Handle loading a double from a heap number.
-  if (CpuFeatures::IsSupported(VFP3)) {
+  if (CpuFeatures::IsSupported(VFP3) && destination == kVFPRegisters) {
     CpuFeatures::Scope scope(VFP3);
     // Load the double from tagged HeapNumber to double register.
     __ sub(scratch1, object, Operand(kHeapObjectTag));
     __ vldr(dst, scratch1, HeapNumber::kValueOffset);
   } else {
     ASSERT(destination == kCoreRegisters);
     // Load the double from heap number to dst1 and dst2 in double format.
     __ Ldrd(dst1, dst2, FieldMemOperand(object, HeapNumber::kValueOffset));
   }
   __ jmp(&done);
 
   // Handle loading a double from a smi.
   __ bind(&is_smi);
   if (CpuFeatures::IsSupported(VFP3)) {
     CpuFeatures::Scope scope(VFP3);
-    // Convert smi to double.
+    // Convert smi to double using VFP instructions.
     __ SmiUntag(scratch1, object);
     __ vmov(dst.high(), scratch1);
     __ vcvt_f64_s32(dst, dst.high());
     if (destination == kCoreRegisters) {
+      // Load the converted smi to dst1 and dst2 in double format.
       __ vmov(dst1, dst2, dst);
     }
   } else {
     ASSERT(destination == kCoreRegisters);
-    // Write Smi to dst1 and dst2 double format.
+    // Write smi to dst1 and dst2 double format.
     __ mov(scratch1, Operand(object));
     ConvertToDoubleStub stub(dst2, dst1, scratch1, scratch2);
     __ push(lr);
     __ Call(stub.GetCode(), RelocInfo::CODE_TARGET);
     __ pop(lr);
   }
 
   __ bind(&done);
 }
 
@@ skipping 1979 matching lines @@
       __ mov(right, Operand(scratch1), LeaveCC, ne);
       __ Ret(ne);
       // We need -0 if we were multiplying a negative number with 0 to get 0.
       // We know one of them was zero.
       __ add(scratch2, right, Operand(left), SetCC);
       __ mov(right, Operand(Smi::FromInt(0)), LeaveCC, pl);
       __ Ret(pl);  // Return smi 0 if the non-zero one was positive.
       // We fall through here if we multiplied a negative number with 0, because
       // that would mean we should produce -0.
       break;
+    case Token::DIV:
+      // Check for power of two on the right hand side.
+      __ JumpIfNotPowerOfTwoOrZero(right, scratch1, &not_smi_result);
+      // Check for positive and no remainder (scratch1 contains right - 1).
+      __ orr(scratch2, scratch1, Operand(0x80000000u));
+      __ tst(left, scratch2);
+      __ b(ne, &not_smi_result);
+
+      // Perform division by shifting.
+      __ CountLeadingZeros(scratch1, scratch1, scratch2);
+      __ rsb(scratch1, scratch1, Operand(31));
+      __ mov(right, Operand(left, LSR, scratch1));
+      __ Ret();
+      break;
+    case Token::MOD:
+      // Check for two positive smis.
+      __ orr(scratch1, left, Operand(right));
+      __ tst(scratch1, Operand(0x80000000u | kSmiTagMask));
+      __ b(ne, &not_smi_result);
+
+      // Check for power of two on the right hand side.
+      __ JumpIfNotPowerOfTwoOrZero(right, scratch1, &not_smi_result);
+
+      // Perform modulus by masking.
+      __ and_(right, left, Operand(scratch1));
+      __ Ret();
+      break;
     default:
       UNREACHABLE();
   }
   __ bind(&not_smi_result);
 }
 
 
 void TypeRecordingBinaryOpStub::GenerateVFPOperation(
     MacroAssembler* masm) {
   switch (op_) {
     case Token::ADD:
       __ vadd(d5, d6, d7);
       break;
     case Token::SUB:
       __ vsub(d5, d6, d7);
       break;
     case Token::MUL:
       __ vmul(d5, d6, d7);
       break;
+    case Token::DIV:
+      __ vdiv(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 || op_ == Token::SUB || op_ == Token::MUL);
+  ASSERT(op_ == Token::ADD ||
+         op_ == Token::SUB ||
+         op_ == Token::MUL ||
+         op_ == Token::DIV ||
+         op_ == Token::MOD);
 
   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);
 
+  // If the smi-smi operation results in a smi return is generated.
   GenerateSmiSmiOperation(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_ ?
+        CpuFeatures::IsSupported(VFP3) && op_ != Token::MOD ?
         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;
+    Register result = r5;
     __ AllocateHeapNumber(
-        heap_number, scratch1, scratch2, heap_number_map, gc_required);
+        result, 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);
       GenerateVFPOperation(masm);
 
-      __ sub(r0, heap_number, Operand(kHeapObjectTag));
+      __ sub(r0, result, 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).
       // r3: Right value (sign, exponent, top of mantissa).
 
       __ push(lr);  // For later.
       __ PrepareCallCFunction(4, scratch1);  // Two doubles are 4 arguments.
       // Call C routine that may not cause GC or other trouble. r5 is callee
       // save.
       __ CallCFunction(ExternalReference::double_fp_operation(op_), 4);
       // Store answer in the overwritable heap number.
 #if !defined(USE_ARM_EABI)
       // Double returned in fp coprocessor register 0 and 1, encoded as
       // register cr8.  Offsets must be divisible by 4 for coprocessor so we
       // need to substract the tag from r5.
-      __ sub(scratch1, heap_number, Operand(kHeapObjectTag));
+      __ sub(scratch1, result, Operand(kHeapObjectTag));
       __ stc(p1, cr8, MemOperand(scratch1, HeapNumber::kValueOffset));
 #else
       // Double returned in registers 0 and 1.
-      __ Strd(r0, r1, FieldMemOperand(heap_number, HeapNumber::kValueOffset));
+      __ Strd(r0, r1, FieldMemOperand(result, HeapNumber::kValueOffset));
 #endif
-      __ mov(r0, Operand(heap_number));
+      __ mov(r0, Operand(result));
       // And we are done.
       __ pop(pc);
     }
   }
   __ bind(&not_smis);
 }
 
 
 void TypeRecordingBinaryOpStub::GenerateSmiStub(MacroAssembler* masm) {
   Label not_smis, call_runtime;
 
-  ASSERT(op_ == Token::ADD || op_ == Token::SUB || op_ == Token::MUL);
+  ASSERT(op_ == Token::ADD ||
+         op_ == Token::SUB ||
+         op_ == Token::MUL ||
+         op_ == Token::DIV ||
+         op_ == Token::MOD);
 
   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 || op_ == Token::SUB || op_ == Token::MUL);
+  ASSERT(op_ == Token::ADD ||
+         op_ == Token::SUB ||
+         op_ == Token::MUL ||
+         op_ == Token::DIV ||
+         op_ == Token::MOD);
 
   ASSERT(operands_type_ == TRBinaryOpIC::INT32);
 
   GenerateTypeTransition(masm);
 }
 
 
 void TypeRecordingBinaryOpStub::GenerateHeapNumberStub(MacroAssembler* masm) {
-  ASSERT(op_ == Token::ADD || op_ == Token::SUB || op_ == Token::MUL);
+  ASSERT(op_ == Token::ADD ||
+         op_ == Token::SUB ||
+         op_ == Token::MUL ||
+         op_ == Token::DIV ||
+         op_ == Token::MOD);
 
   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);
 
+  // Get a heap number object for the result - might be left or right if one
+  // of these are overwritable. Uses a callee-save register to keep the value
+  // across the C call which we might use below.
+  Register result = r5;
+  GenerateHeapResultAllocation(
+      masm, result, heap_number_map, scratch1, scratch2, &call_runtime);
+
   // 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) ?
+      CpuFeatures::IsSupported(VFP3) && op_ != Token::MOD ?
       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);
     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));
+    __ sub(r0, result, Operand(kHeapObjectTag));
     __ vstr(d5, r0, HeapNumber::kValueOffset);
     __ add(r0, r0, Operand(kHeapObjectTag));
     __ Ret();
 
   } else {
     // Call a C function for the binary operation.
     // r0/r1: Left operand
     // r2/r3: Right operand
 
-    // Get a heap number object for the result - might be left or right if one
-    // of these are overwritable. Uses a callee-save register to keep the value
-    // across the c call.
-    GenerateHeapResultAllocation(
-        masm, r4, heap_number_map, scratch1, scratch2, &call_runtime);
-
     __ push(lr);  // For returning later (no GC after this point).
     __ PrepareCallCFunction(4, scratch1);  // Two doubles count as 4 arguments.
-    // Call C routine that may not cause GC or other trouble. r4 is callee
-    // saved.
+    // Call C routine that may not cause GC or other trouble. result (r5) is
+    // callee saved.
     __ CallCFunction(ExternalReference::double_fp_operation(op_), 4);
-
     // Fill the result into the allocated heap number.
   #if !defined(USE_ARM_EABI)
     // Double returned in fp coprocessor register 0 and 1, encoded as
     // register cr8.  Offsets must be divisible by 4 for coprocessor so we
     // need to substract the tag from r5.
-    __ sub(scratch1, r4, Operand(kHeapObjectTag));
+    __ sub(scratch1, result, Operand(kHeapObjectTag));
     __ stc(p1, cr8, MemOperand(scratch1, HeapNumber::kValueOffset));
   #else
     // Double returned in registers 0 and 1.
-    __ Strd(r0, r1, FieldMemOperand(r4, HeapNumber::kValueOffset));
+    __ Strd(r0, r1, FieldMemOperand(result, HeapNumber::kValueOffset));
   #endif
-    __ mov(r0, Operand(r4));
+    __ mov(r0, Operand(result));
     __ pop(pc);  // Return to the pushed lr.
   }
 
   __ bind(&not_number);
   GenerateTypeTransition(masm);
 
   __ bind(&call_runtime);
   GenerateCallRuntime(masm);
 }
 
 
 void TypeRecordingBinaryOpStub::GenerateGeneric(MacroAssembler* masm) {
-  ASSERT(op_ == Token::ADD || op_ == Token::SUB || op_ == Token::MUL);
+  ASSERT(op_ == Token::ADD ||
+         op_ == Token::SUB ||
+         op_ == Token::MUL ||
+         op_ == Token::DIV ||
+         op_ == Token::MOD);
 
   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 38 matching lines @@
   switch (op_) {
     case Token::ADD:
       __ InvokeBuiltin(Builtins::ADD, JUMP_JS);
       break;
     case Token::SUB:
       __ InvokeBuiltin(Builtins::SUB, JUMP_JS);
       break;
     case Token::MUL:
       __ InvokeBuiltin(Builtins::MUL, JUMP_JS);
       break;
+    case Token::DIV:
+      __ InvokeBuiltin(Builtins::DIV, JUMP_JS);
+      break;
+    case Token::MOD:
+      __ InvokeBuiltin(Builtins::MOD, 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