Port handling of heap numbers in deferred code for binary ops from...

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 4032 matching lines @@
   __ CompareRoot(FieldOperand(exponent.reg(), HeapObject::kMapOffset),
                  Heap::kHeapNumberMapRootIndex);
   call_runtime.Branch(not_equal);
   __ movsd(xmm1, FieldOperand(exponent.reg(), HeapNumber::kValueOffset));
   // Test if exponent is nan.
   __ ucomisd(xmm1, xmm1);
   call_runtime.Branch(parity_even);
 
   Label base_not_smi;
   Label handle_special_cases;
-  __ testl(base.reg(), Immediate(kSmiTagMask));
-  __ j(not_zero, &base_not_smi);
+  __ JumpIfNotSmi(base.reg(), &base_not_smi);
   __ SmiToInteger32(base.reg(), base.reg());
   __ cvtlsi2sd(xmm0, base.reg());
   __ jmp(&handle_special_cases);
   __ bind(&base_not_smi);
   __ CompareRoot(FieldOperand(base.reg(), HeapObject::kMapOffset),
                  Heap::kHeapNumberMapRootIndex);
   call_runtime.Branch(not_equal);
   __ movl(answer.reg(), FieldOperand(base.reg(), HeapNumber::kExponentOffset));
   __ andl(answer.reg(), Immediate(HeapNumber::kExponentMask));
   __ cmpl(answer.reg(), Immediate(HeapNumber::kExponentMask));
@@ skipping 1823 matching lines @@
  private:
   Token::Value op_;
   Register dst_;
   Register left_;
   Register right_;
   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 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_);

[Lasse Reichstein, 2010/04/29 12:36:40]

If you have a spare register here, you could convert left_ into an integer in
that and not have to convert it back afterwards.
This is X64 - it should be possible to allocate a register - or can't we because
this is deferred code?

[Mads Ager (chromium), 2010/05/03 08:47:09]

I can convert the smi into an integer in kScratchRegister and load it from
there. I don't think it will matter for performance since in that case we will
just transform two shifts into a move and a shift.

I have left it as is.

+    __ cvtlsi2sd(xmm0, left_);
+    __ Integer32ToSmi(left_, left_);
+    if (mode_ == OVERWRITE_LEFT) {
+      Label alloc_failure;
+      __ push(left_);
+      __ AllocateHeapNumber(dst_, left_, &after_alloc_failure);

[Lasse Reichstein, 2010/04/29 12:36:40]

I'll bet I can make a version of AllocateHeapNumber/AllocateInNewSpace that
doesn't use any scratch registers (except for kScratchRegister ofcourse).
That would save you from push/popping here - if you can't get a scratch register
somehow.

+      __ pop(left_);
+    }
+
+    __ 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_);
+    }
+    __ 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_);
+    }
+
+    __ 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,
                                   Token::Value op,
                                   const Result& right,
                                   const Result& left) {
   // Set TypeInfo of result according to the operation performed.
   // We rely on the fact that smis have a 32 bit payload on x64.
   STATIC_ASSERT(kSmiValueSize == 32);
@@ skipping 4966 matching lines @@
   // Call the function from C++.
   return FUNCTION_CAST<ModuloFunction>(buffer);
 }
 
 #endif
 
 
 #undef __
 
 } }  // namespace v8::internal