ARM: Implement inline conversion of heap numbers to int32 values for bitoperations.

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 385 matching lines @@
                            Register scratch1,
                            Register scratch2,
                            Label* not_number);
 
   // Loads the number from object into dst as a 32-bit integer if possible. If
   // the object cannot be converted to a 32-bit integer control continues at
   // the label not_int32. If VFP is supported double_scratch is used
   // but not scratch2.
   // Floating point value in the 32-bit integer range will be rounded
   // to an integer.
   static void LoadNumberAsInteger(MacroAssembler* masm,

[Søren Thygesen Gjesse, 2011/03/10 14:20:30]

Maybe this function should have a name that indicate that it will do the
truncate. Also the comment "Floating point value in the 32-bit integer range
will be rounded to an integer." is not totally accurate any more.

[Karl Klose, 2011/03/11 09:27:39]

Done. I renamed the function to ConvertNumberToInt32 and updated the comment,
including a reference to the specification.

                                   Register object,
                                   Register dst,
                                   Register heap_number_map,
                                   Register scratch1,
                                   Register scratch2,
+                                  Register scratch3,
                                   DwVfpRegister double_scratch,
                                   Label* not_int32);
 
   // Load the number from object into double_dst in the double format.
   // Control will jump to not_int32 if the value cannot be exactly represented
   // by a 32-bit integer.
   // Floating point value in the 32-bit integer range that are not exact integer
   // won't be loaded.
   static void LoadNumberAsInt32Double(MacroAssembler* masm,
                                       Register object,
@@ skipping 183 matching lines @@
   __ bind(&done);
 }
 
 
 void FloatingPointHelper::LoadNumberAsInteger(MacroAssembler* masm,
                                               Register object,
                                               Register dst,
                                               Register heap_number_map,
                                               Register scratch1,
                                               Register scratch2,
+                                              Register scratch3,
                                               DwVfpRegister double_scratch,
                                               Label* not_int32) {
   if (FLAG_debug_code) {
     __ AbortIfNotRootValue(heap_number_map,
                            Heap::kHeapNumberMapRootIndex,
                            "HeapNumberMap register clobbered.");
   }
-  Label is_smi, done;
+  Label is_smi;
+  Label done;
+  Label not_in_int32_range;
+
   __ JumpIfSmi(object, &is_smi);
   __ ldr(scratch1, FieldMemOperand(object, HeapNumber::kMapOffset));
   __ cmp(scratch1, heap_number_map);
   __ b(ne, not_int32);
   __ ConvertToInt32(
-      object, dst, scratch1, scratch2, double_scratch, not_int32);
+      object, dst, scratch1, scratch2, double_scratch, &not_in_int32_range);
   __ jmp(&done);
+
+  __ bind(&not_in_int32_range);
+  if (CpuFeatures::IsSupported(VFP3)) {
+    CpuFeatures::Scope scope(VFP3);

[Søren Thygesen Gjesse, 2011/03/10 14:20:30]

Should we not support non-vfp here? VFP instructions are only used for loading
the two words of the float as far as I can see.

[Karl Klose, 2011/03/11 09:27:39]

Done, see comment below.

+    __ vldr(double_scratch, FieldMemOperand(object, HeapNumber::kValueOffset));

[Rodolph Perfetta, 2011/03/10 14:36:44]

Use Ldrd, it will be faster (no transfer VFP-ARM) and you don't need to require
VFP3.

[Karl Klose, 2011/03/11 09:27:39]

I decided to use two ldr instructions to avoid putting constraints on the
scratch registers. If this is a major performance issue, I can change it to
ldrd. 

This way the code is also safe for big-endian floating points, although that may
be less relevant.

Either way the function does not require VFP anymore. 

+    __ vmov(scratch1, scratch2, double_scratch);
+
+    // Register scratch1 contains mantissa word, scratch2 contains
+    // sign, exponent and mantissa.

[Rodolph Perfetta, 2011/03/10 14:36:44]

the and and mov could be rewritten as a Ubfx

[Karl Klose, 2011/03/11 09:27:39]

Done.

+    __ and_(dst, scratch2, Operand(HeapNumber::kExponentMask));
+    __ mov(dst, Operand(dst, LSR, HeapNumber::kExponentShift));
+    __ sub(dst, dst, Operand(1023));

[Søren Thygesen Gjesse, 2011/03/10 14:20:30]

1023 -> HeapNumber::kExponentBias

[Karl Klose, 2011/03/11 09:27:39]

Done.

+
+    Label normal_exponent;
+    // Express exponent as delta to 31.
+    // If the delta is larger than 53, all bits would be shifted
+    // away, which means that we can return 0.
+    __ sub(dst, dst, Operand(31));

[Søren Thygesen Gjesse, 2011/03/10 14:20:30]

You could combine this sub with the one before subtracting the bias.

[Karl Klose, 2011/03/11 09:27:39]

Done.

+    __ cmp(dst, Operand(53));

[Søren Thygesen Gjesse, 2011/03/10 14:20:30]

We have HeapNumber::kMantissaBits which is 52.

[Karl Klose, 2011/03/11 09:27:39]

Done.

+    __ b(&normal_exponent, lt);
+    __ mov(dst, Operand(0));
+    __ jmp(&done);
+
+    __ bind(&normal_exponent);
+    const int kShiftBase = HeapNumber::kNonMantissaBitsInTopWord - 1;
+    // Calculate shift.
+    __ add(scratch3, dst, Operand(kShiftBase));
+
+    // Put implicit 1 before the mantissa part in scratch2 and
+    // shift the mantissa bits to the correct position.
+    __ orr(scratch2,
+           scratch2,
+           Operand(1 << HeapNumber::kMantissaBitsInTopWord));
+
+    // Save sign.
+    Register sign = dst;
+    __ and_(sign, scratch2, Operand(HeapNumber::kSignMask));
+
+    //  Shift mantisssa bits in high word.
+    __ mov(scratch2, Operand(scratch2, LSL, scratch3));
+
+    // Replace the shifted bits with bits from the lower mantissa word.
+    Label pos_shift, neg_shift;
+    // scratch3 = 32 - scratch3.

[Rodolph Perfetta, 2011/03/10 14:36:44]

__ rsb(scratch3, scratch3, Operand(32), SetCC) can replace all the instruction
below

[Karl Klose, 2011/03/11 09:27:39]

Done.

+    __ mvn(scratch3, Operand(scratch3));
+    __ add(scratch3, scratch3, Operand(33));
+    __ cmp(scratch3, Operand(0));
+    __ b(&pos_shift, ge);
+
+    // Negate scratch3.

[Rodolph Perfetta, 2011/03/10 14:36:44]

__ rsb(scratch3, scratch3, Operand(0)) will neagete scratch3

[Karl Klose, 2011/03/11 09:27:39]

Done.

+    __ mvn(scratch3, Operand(scratch3));
+    __ add(scratch3, scratch3, Operand(1));
+    __ mov(scratch1, Operand(scratch1, LSL, scratch3));
+    __ jmp(&neg_shift);
+
+    __ bind(&pos_shift);
+    __ mov(scratch1, Operand(scratch1, LSR, scratch3));
+
+    __ bind(&neg_shift);

[Søren Thygesen Gjesse, 2011/03/10 14:20:30]

neg_shift -> shift_done?

[Karl Klose, 2011/03/11 09:27:39]

Done.

+    __ orr(scratch2, scratch2, Operand(scratch1));
+
+    // Restore sign if necessary.

[Rodolph Perfetta, 2011/03/10 14:36:44]

__ cmp(sign, Operand(0));

[Karl Klose, 2011/03/11 09:27:39]

Done.

+    __ tst(sign, sign);

[Rodolph Perfetta, 2011/03/10 14:36:44]

rsb again here.

[Karl Klose, 2011/03/11 09:27:39]

Done.

+    __ mvn(scratch2, Operand(scratch2), LeaveCC, ne);
+    __ add(scratch2, scratch2, Operand(1), LeaveCC, ne);
+    __ mov(dst, scratch2);
+    __ jmp(&done);
+  } else {
+    __ jmp(not_int32);
+  }
+
   __ bind(&is_smi);
   __ SmiUntag(dst, object);
   __ bind(&done);
 }
 
 
 void FloatingPointHelper::LoadNumberAsInt32Double(MacroAssembler* masm,
                                                   Register object,
                                                   Destination destination,
                                                   DwVfpRegister double_dst,
@@ skipping 2377 matching lines @@
 
 
 void TypeRecordingBinaryOpStub::GenerateFPOperation(MacroAssembler* masm,
                                                     bool smi_operands,
                                                     Label* not_numbers,
                                                     Label* gc_required) {
   Register left = r1;
   Register right = r0;
   Register scratch1 = r7;
   Register scratch2 = r9;
+  Register scratch3 = r4;
 
   ASSERT(smi_operands || (not_numbers != NULL));
   if (smi_operands && FLAG_debug_code) {
     __ AbortIfNotSmi(left);
     __ AbortIfNotSmi(right);
   }
 
   Register heap_number_map = r6;
   __ LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
 
@@ skipping 73 matching lines @@
         __ SmiUntag(r3, left);
         __ SmiUntag(r2, right);
       } else {
         // Convert operands to 32-bit integers. Right in r2 and left in r3.
         FloatingPointHelper::LoadNumberAsInteger(masm,
                                                  left,
                                                  r3,
                                                  heap_number_map,
                                                  scratch1,
                                                  scratch2,
+                                                 scratch3,
                                                  d0,
                                                  not_numbers);
         FloatingPointHelper::LoadNumberAsInteger(masm,
                                                  right,
                                                  r2,
                                                  heap_number_map,
                                                  scratch1,
                                                  scratch2,
+                                                 scratch3,
                                                  d0,
                                                  not_numbers);
       }
 
       Label result_not_a_smi;
       switch (op_) {
         case Token::BIT_OR:
           __ orr(r2, r3, Operand(r2));
           break;
         case Token::BIT_XOR:
@@ skipping 427 matching lines @@
     __ bind(&transition);
     GenerateTypeTransition(masm);
   }
 
   __ bind(&call_runtime);
   GenerateCallRuntime(masm);
 }
 
 
 void TypeRecordingBinaryOpStub::GenerateHeapNumberStub(MacroAssembler* masm) {
-  Label not_numbers, call_runtime;
+  Label call_runtime;
   ASSERT(operands_type_ == TRBinaryOpIC::HEAP_NUMBER);
 
-  GenerateFPOperation(masm, false, &not_numbers, &call_runtime);
-
-  __ bind(&not_numbers);
-  GenerateTypeTransition(masm);
+  GenerateFPOperation(masm, false, &call_runtime, &call_runtime);
 
   __ bind(&call_runtime);
   GenerateCallRuntime(masm);
 }
 
 
 void TypeRecordingBinaryOpStub::GenerateGeneric(MacroAssembler* masm) {
   Label call_runtime, call_string_add_or_runtime;
 
   GenerateSmiCode(masm, &call_runtime, ALLOW_HEAPNUMBER_RESULTS);
@@ skipping 3238 matching lines @@
   __ str(pc, MemOperand(sp, 0));
   __ Jump(target);  // Call the C++ function.
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM