[interpreter] Introduce binary op bytecodes for Smi operand.

src/code-stubs.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/code-stubs.h"
 
 #include <sstream>
 
 #include "src/bootstrapper.h"
 #include "src/code-factory.h"
@@ skipping 864 matching lines @@
     Node* value = assembler->Float64Add(lhs_value, rhs_value);
     Node* result = assembler->ChangeFloat64ToTagged(value);
     var_result.Bind(result);
     assembler->Goto(&end);
   }
   assembler->Bind(&end);
   return var_result.value();
 }
 
 // static
+compiler::Node* AddSmiStub::Generate(CodeStubAssembler* assembler,
+                                     compiler::Node* left,
+                                     compiler::Node* right,
+                                     compiler::Node* context) {
+  typedef CodeStubAssembler::Label Label;
+  typedef compiler::Node Node;
+  typedef CodeStubAssembler::Variable Variable;
+
+  Variable var_result(assembler, MachineRepresentation::kTagged);
+  Label fastpath(assembler), slowpath(assembler, Label::kDeferred),
+      end(assembler);
+
+  // {right} is known to be a Smi.

[rmcilroy, 2016/07/04 12:35:32]

Maybe add some code under FLAG_debug_code which aborts if rhs isn't a SMI)?

[oth, 2016/07/04 14:56:24]

Done. CodeStubAssembler::Assert is conditional on DEBUG macro which seems
reasonable.

+  // Check if the {left} is a Smi take the fast path.
+  assembler->BranchIf(assembler->WordIsSmi(left), &fastpath, &slowpath);
+  assembler->Bind(&fastpath);
+  {
+    // Try fast Smi addition first.
+    Node* pair = assembler->SmiAddWithOverflow(left, right);
+    Node* overflow = assembler->Projection(1, pair);
+
+    // Check if the Smi additon overflowed.
+    Label if_notoverflow(assembler);
+    assembler->BranchIf(overflow, &slowpath, &if_notoverflow);
+    assembler->Bind(&if_notoverflow);
+    {
+      var_result.Bind(assembler->Projection(0, pair));
+      assembler->Goto(&end);
+    }
+  }
+  assembler->Bind(&slowpath);

[rmcilroy, 2016/07/04 12:35:32]

I wonder if it is worth doing the check for heap-number here too (and the
overflow addition) before going to the slow path, (i.e., the equivalent code as
is in IncStub). If we did that then we could possibly replace IncStub with
SubSmiStub(val, SmiConstant(-1)); and DecStub with SubSmiStub(val,
SmiConstant(1));

Just a thought, and don't want to block this CL if you've already considered
this.

[oth, 2016/07/04 14:56:24]

Yes, I tried this. For x64 the stub size increases from 227 bytes to 498 bytes
(compared to 1820 bytes for regular add). At least in Octane there's not a
discernible perf win from having this path. It's an easy change if you'd prefer
it to be present.

+  {
+    Callable callable = CodeFactory::Add(assembler->isolate());
+    var_result.Bind(assembler->CallStub(callable, context, left, right));
+    assembler->Goto(&end);
+  }
+  assembler->Bind(&end);
+  return var_result.value();
+}
+
+// static
 compiler::Node* SubtractStub::Generate(CodeStubAssembler* assembler,
                                        compiler::Node* left,
                                        compiler::Node* right,
                                        compiler::Node* context) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Variable Variable;
 
   // Shared entry for floating point subtraction.
   Label do_fsub(assembler), end(assembler);
@@ skipping 155 matching lines @@
     Node* rhs_value = var_fsub_rhs.value();
     Node* value = assembler->Float64Sub(lhs_value, rhs_value);
     var_result.Bind(assembler->ChangeFloat64ToTagged(value));
     assembler->Goto(&end);
   }
   assembler->Bind(&end);
   return var_result.value();
 }
 
 // static
+compiler::Node* SubtractSmiStub::Generate(CodeStubAssembler* assembler,
+                                          compiler::Node* left,
+                                          compiler::Node* right,
+                                          compiler::Node* context) {
+  typedef CodeStubAssembler::Label Label;
+  typedef compiler::Node Node;
+  typedef CodeStubAssembler::Variable Variable;
+
+  Variable var_result(assembler, MachineRepresentation::kTagged);
+  Label fastpath(assembler), slowpath(assembler, Label::kDeferred),
+      end(assembler);
+
+  // {right} is known to be a Smi.
+  // Check if the {left} is a Smi take the fast path.
+  assembler->BranchIf(assembler->WordIsSmi(left), &fastpath, &slowpath);
+  assembler->Bind(&fastpath);
+  {
+    // Try fast Smi subtraction first.
+    Node* pair = assembler->SmiSubWithOverflow(left, right);
+    Node* overflow = assembler->Projection(1, pair);
+
+    // Check if the Smi subtraction overflowed.
+    Label if_notoverflow(assembler);
+    assembler->BranchIf(overflow, &slowpath, &if_notoverflow);
+    assembler->Bind(&if_notoverflow);
+    {
+      var_result.Bind(assembler->Projection(0, pair));
+      assembler->Goto(&end);
+    }
+  }
+  assembler->Bind(&slowpath);
+  {
+    Callable callable = CodeFactory::Subtract(assembler->isolate());
+    var_result.Bind(assembler->CallStub(callable, context, left, right));
+    assembler->Goto(&end);
+  }
+  assembler->Bind(&end);
+  return var_result.value();
+}
+
+// static
 compiler::Node* MultiplyStub::Generate(CodeStubAssembler* assembler,
                                        compiler::Node* left,
                                        compiler::Node* right,
                                        compiler::Node* context) {
   using compiler::Node;
   typedef CodeStubAssembler::Label Label;
   typedef CodeStubAssembler::Variable Variable;
 
   // Shared entry point for floating point multiplication.
   Label do_fmul(assembler);
@@ skipping 516 matching lines @@
   Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
   Node* rhs_value = assembler->TruncateTaggedToWord32(context, right);
   Node* shift_count =
       assembler->Word32And(rhs_value, assembler->Int32Constant(0x1f));
   Node* value = assembler->Word32Shl(lhs_value, shift_count);
   Node* result = assembler->ChangeInt32ToTagged(value);
   return result;
 }
 
 // static
+compiler::Node* ShiftLeftSmiStub::Generate(CodeStubAssembler* assembler,
+                                           compiler::Node* left,
+                                           compiler::Node* right,
+                                           compiler::Node* context) {
+  using compiler::Node;
+
+  Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
+  Node* rhs_value = assembler->SmiToWord32(right);
+  Node* shift_count =
+      assembler->Word32And(rhs_value, assembler->Int32Constant(0x1f));
+  Node* value = assembler->Word32Shl(lhs_value, shift_count);
+  Node* result = assembler->ChangeInt32ToTagged(value);
+  return result;
+}
+
+// static
 compiler::Node* ShiftRightStub::Generate(CodeStubAssembler* assembler,
                                          compiler::Node* left,
                                          compiler::Node* right,
                                          compiler::Node* context) {
   using compiler::Node;
 
   Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
   Node* rhs_value = assembler->TruncateTaggedToWord32(context, right);
   Node* shift_count =
       assembler->Word32And(rhs_value, assembler->Int32Constant(0x1f));
   Node* value = assembler->Word32Sar(lhs_value, shift_count);
   Node* result = assembler->ChangeInt32ToTagged(value);
   return result;
 }
 
 // static
+compiler::Node* ShiftRightSmiStub::Generate(CodeStubAssembler* assembler,
+                                            compiler::Node* left,
+                                            compiler::Node* right,
+                                            compiler::Node* context) {
+  using compiler::Node;
+
+  Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
+  Node* rhs_value = assembler->SmiToWord32(right);
+  Node* shift_count =
+      assembler->Word32And(rhs_value, assembler->Int32Constant(0x1f));
+  Node* value = assembler->Word32Sar(lhs_value, shift_count);
+  Node* result = assembler->ChangeInt32ToTagged(value);
+  return result;
+}
+
+// static
 compiler::Node* ShiftRightLogicalStub::Generate(CodeStubAssembler* assembler,
                                                 compiler::Node* left,
                                                 compiler::Node* right,
                                                 compiler::Node* context) {
   using compiler::Node;
 
   Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
   Node* rhs_value = assembler->TruncateTaggedToWord32(context, right);
   Node* shift_count =
       assembler->Word32And(rhs_value, assembler->Int32Constant(0x1f));
@@ skipping 10 matching lines @@
   using compiler::Node;
 
   Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
   Node* rhs_value = assembler->TruncateTaggedToWord32(context, right);
   Node* value = assembler->Word32And(lhs_value, rhs_value);
   Node* result = assembler->ChangeInt32ToTagged(value);
   return result;
 }
 
 // static
+compiler::Node* BitwiseAndSmiStub::Generate(CodeStubAssembler* assembler,
+                                            compiler::Node* left,
+                                            compiler::Node* right,
+                                            compiler::Node* context) {
+  using compiler::Node;
+
+  Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
+  Node* rhs_value = assembler->SmiToWord32(right);
+  Node* value = assembler->Word32And(lhs_value, rhs_value);
+  Node* result = assembler->ChangeInt32ToTagged(value);
+  return result;
+}
+
+// static
 compiler::Node* BitwiseOrStub::Generate(CodeStubAssembler* assembler,
                                         compiler::Node* left,
                                         compiler::Node* right,
                                         compiler::Node* context) {
   using compiler::Node;
 
   Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
   Node* rhs_value = assembler->TruncateTaggedToWord32(context, right);
   Node* value = assembler->Word32Or(lhs_value, rhs_value);
   Node* result = assembler->ChangeInt32ToTagged(value);
   return result;
 }
 
 // static
+compiler::Node* BitwiseOrSmiStub::Generate(CodeStubAssembler* assembler,
+                                           compiler::Node* left,
+                                           compiler::Node* right,
+                                           compiler::Node* context) {
+  using compiler::Node;
+
+  Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
+  Node* rhs_value = assembler->SmiToWord32(right);
+  Node* value = assembler->Word32Or(lhs_value, rhs_value);
+  Node* result = assembler->ChangeInt32ToTagged(value);
+  return result;
+}
+
+// static
 compiler::Node* BitwiseXorStub::Generate(CodeStubAssembler* assembler,
                                          compiler::Node* left,
                                          compiler::Node* right,
                                          compiler::Node* context) {
   using compiler::Node;
 
   Node* lhs_value = assembler->TruncateTaggedToWord32(context, left);
   Node* rhs_value = assembler->TruncateTaggedToWord32(context, right);
   Node* value = assembler->Word32Xor(lhs_value, rhs_value);
   Node* result = assembler->ChangeInt32ToTagged(value);
@@ skipping 25 matching lines @@
     Label if_issmi(assembler), if_isnotsmi(assembler);
     assembler->Branch(assembler->WordIsSmi(value), &if_issmi, &if_isnotsmi);
 
     assembler->Bind(&if_issmi);
     {
       // Try fast Smi addition first.
       Node* one = assembler->SmiConstant(Smi::FromInt(1));
       Node* pair = assembler->SmiAddWithOverflow(value, one);
       Node* overflow = assembler->Projection(1, pair);
 
-      // Check if the Smi additon overflowed.
+      // Check if the Smi addition overflowed.
       Label if_overflow(assembler), if_notoverflow(assembler);
       assembler->Branch(overflow, &if_overflow, &if_notoverflow);
 
       assembler->Bind(&if_notoverflow);
       result_var.Bind(assembler->Projection(0, pair));
       assembler->Goto(&end);
 
       assembler->Bind(&if_overflow);
       {
         var_finc_value.Bind(assembler->SmiToFloat64(value));
@@ skipping 3148 matching lines @@
   if (type->Is(Type::UntaggedPointer())) {
     return Representation::External();
   }
 
   DCHECK(!type->Is(Type::Untagged()));
   return Representation::Tagged();
 }
 
 }  // namespace internal
 }  // namespace v8