Inline some Smi multiplications.

src/arm/codegen-arm.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 851 matching lines @@
           GenericBinaryOpStub stub(op, overwrite_mode, lhs, rhs, constant_rhs);
           frame_->SpillAll();
           frame_->CallStub(&stub, 0);
           done.Bind();
         }
         frame_->EmitPush(r0);
         break;
       } else {
         // Fall through!
       }
-    case Token::MUL:
     case Token::DIV:
     case Token::MOD:
     case Token::SHL:
     case Token::SHR:
     case Token::SAR: {
       Register rhs = frame_->PopToRegister();
       Register lhs = frame_->PopToRegister(rhs);  // Don't pop to rhs register.
       GenericBinaryOpStub stub(op, overwrite_mode, lhs, rhs, constant_rhs);
       frame_->SpillAll();
       frame_->CallStub(&stub, 0);
       frame_->EmitPush(r0);
       break;
     }
 
+    case Token::MUL: {
+      Register rhs = frame_->PopToRegister();
+      Register lhs = frame_->PopToRegister(rhs);
+      GenericBinaryOpStub stub(op, overwrite_mode, lhs, rhs, constant_rhs);
+      if (inline_smi) {
+        JumpTarget slow, done;
+        Register smi_test_reg = VirtualFrame::scratch0();
+        Register low = VirtualFrame::scratch1();
+        Register high = smi_test_reg;
+        // We need to know whether we are dealing with two positive Smis.  Set
+        // up smi_test_reg to tell us that.
+        __ orr(smi_test_reg, lhs, Operand(rhs));
+        __ tst(smi_test_reg, Operand(0x80000000 | kSmiTagMask));
+        smi_test_reg = no_reg;
+        slow.Branch(ne);
+        // Do multiplication
+        __ smull(low, high, lhs, rhs);
+        __ cmp(high, Operand(0));
+        // Remove double tag from answer.
+        __ mov(r0, Operand(low, LSR, kSmiTagSize), LeaveCC, eq);
+        done.Branch(eq);
+        slow.Bind();
+        frame_->SpillAll();
+        frame_->CallStub(&stub, 0);
+        done.Bind();
+      } else {
+        frame_->SpillAll();
+        frame_->CallStub(&stub, 0);
+      }
+      frame_->EmitPush(r0);
+      break;
+    }
+
     case Token::COMMA: {
       Register scratch = frame_->PopToRegister();
       // Simply discard left value.
       frame_->Drop();
       frame_->EmitPush(scratch);
       break;
     }
 
     default:
       // Other cases should have been handled before this point.
@@ skipping 132 matching lines @@
 
 
 void CodeGenerator::SmiOperation(Token::Value op,
                                  Handle<Object> value,
                                  bool reversed,
                                  OverwriteMode mode) {
   int int_value = Smi::cast(*value)->value();
 
   bool both_sides_are_smi = frame_->KnownSmiAt(0);
 
-  bool something_to_inline;
+  bool inline_op_with_constant_smi;
+  GenerateInlineSmi inline_generic_smi_code = GENERATE_INLINE_SMI;
   switch (op) {
     case Token::ADD:
     case Token::SUB:
     case Token::BIT_AND:
     case Token::BIT_OR:
     case Token::BIT_XOR: {
-      something_to_inline = true;
+      inline_op_with_constant_smi = true;
       break;
     }
     case Token::SHL: {
-      something_to_inline = (both_sides_are_smi || !reversed);
+      inline_op_with_constant_smi = (both_sides_are_smi || !reversed);
       break;
     }
     case Token::SHR:
     case Token::SAR: {
       if (reversed) {
-        something_to_inline = false;
+        inline_op_with_constant_smi = false;
       } else {
-        something_to_inline = true;
+        inline_op_with_constant_smi = true;
       }
       break;
     }
+    case Token::MUL: {
+      // Multiplying by negative small constants is too annoying because of the
+      // -0 issues.
+      inline_op_with_constant_smi = (int_value >= 2);
+      inline_generic_smi_code = inline_op_with_constant_smi ?
+                                GENERATE_INLINE_SMI :
+                                DONT_GENERATE_INLINE_SMI;
+      break;
+    }
     case Token::MOD: {
       if (reversed || int_value < 2 || !IsPowerOf2(int_value)) {
-        something_to_inline = false;
+        inline_op_with_constant_smi = false;
       } else {
-        something_to_inline = true;
-      }
-      break;
-    }
-    case Token::MUL: {
-      if (!IsEasyToMultiplyBy(int_value)) {
-        something_to_inline = false;
-      } else {
-        something_to_inline = true;
+        inline_op_with_constant_smi = true;
       }
       break;
     }
     default: {
-      something_to_inline = false;
+      inline_op_with_constant_smi = false;
       break;
     }
   }
 
-  if (!something_to_inline) {
+  if (!inline_op_with_constant_smi) {
     if (!reversed) {
       // Push the rhs onto the virtual frame by putting it in a TOS register.
       Register rhs = frame_->GetTOSRegister();
       __ mov(rhs, Operand(value));
       frame_->EmitPush(rhs, TypeInfo::Smi());
-      GenericBinaryOperation(op, mode, GENERATE_INLINE_SMI, int_value);
+      GenericBinaryOperation(op, mode, inline_generic_smi_code, int_value);
     } else {
       // Pop the rhs, then push lhs and rhs in the right order.  Only performs
       // at most one pop, the rest takes place in TOS registers.
       Register lhs = frame_->GetTOSRegister();    // Get reg for pushing.
       Register rhs = frame_->PopToRegister(lhs);  // Don't use lhs for this.
       __ mov(lhs, Operand(value));
       frame_->EmitPush(lhs, TypeInfo::Smi());
       TypeInfo t = both_sides_are_smi ? TypeInfo::Smi() : TypeInfo::Unknown();
       frame_->EmitPush(rhs, t);
-      GenericBinaryOperation(op, mode, GENERATE_INLINE_SMI, kUnknownIntValue);
+      GenericBinaryOperation(op, mode, inline_generic_smi_code, kUnknownIntValue);
     }
     return;
   }
 
   // We move the top of stack to a register (normally no move is invoved).
   Register tos = frame_->PopToRegister();
   switch (op) {
     case Token::ADD: {
       DeferredCode* deferred =
           new DeferredInlineSmiOperation(op, int_value, reversed, mode, tos);
@@ skipping 185 matching lines @@
       __ and_(tos, tos, Operand(mask));
       deferred->BindExit();
       // Mod of positive power of 2 Smi gives a Smi if the lhs is an integer.
       frame_->EmitPush(
           tos,
           both_sides_are_smi ? TypeInfo::Smi() : TypeInfo::Number());
       break;
     }
 
     case Token::MUL: {
-      ASSERT(IsEasyToMultiplyBy(int_value));
+      ASSERT(int_value > 0);
+
       DeferredCode* deferred =
           new DeferredInlineSmiOperation(op, int_value, reversed, mode, tos);
       unsigned max_smi_that_wont_overflow = Smi::kMaxValue / int_value;
       max_smi_that_wont_overflow <<= kSmiTagSize;
       unsigned mask = 0x80000000u;
       while ((mask & max_smi_that_wont_overflow) == 0) {
         mask |= mask >> 1;
       }
-      mask |= kSmiTagMask;
+      if (!both_sides_are_smi) mask |= kSmiTagMask;
       // This does a single mask that checks for a too high value in a
       // conservative way and for a non-Smi.  It also filters out negative
       // numbers, unfortunately, but since this code is inline we prefer
       // brevity to comprehensiveness.
       __ tst(tos, Operand(mask));
       deferred->Branch(ne);
-      MultiplyByKnownInt(masm_, tos, tos, int_value);
+
+      if (IsEasyToMultiplyBy(int_value)) {
+        MultiplyByKnownInt(masm_, tos, tos, int_value);
+      } else {
+        Register high = VirtualFrame::scratch0();
+        Register low = VirtualFrame::scratch1();
+        __ mov(ip, Operand(int_value));
+        // Multiplying a tagged with an untagged value gives a tagged
+        // result.
+        __ smull(tos, high, tos, ip);
+        // Remove double tag from answer and make its sign bit 0.
+      }
       deferred->BindExit();
       frame_->EmitPush(tos);
       break;
     }
 
     default:
       UNREACHABLE();
       break;
   }
 }
@@ skipping 9584 matching lines @@
   __ bind(&string_add_runtime);
   __ TailCallRuntime(Runtime::kStringAdd, 2, 1);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM