[turbofan] JSGenericLowering mostly uses builtins instead of code stubs now

src/interpreter/interpreter.cc

 // Copyright 2015 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/interpreter/interpreter.h"
 
 #include <fstream>
 #include <memory>
 
 #include "src/ast/prettyprinter.h"
@@ skipping 913 matching lines @@
   Node* context = __ GetContext();
   Node* slot_index = __ BytecodeOperandIdx(1);
   Node* type_feedback_vector = __ LoadTypeFeedbackVector();
   Node* result = Generator::Generate(assembler, lhs, rhs, slot_index,
                                      type_feedback_vector, context);
   __ SetAccumulator(result);
   __ Dispatch();
 }
 
 template <class Generator>
-void Interpreter::DoCompareOpWithFeedback(InterpreterAssembler* assembler) {
+void Interpreter::DoCompareOpWithFeedback(InterpreterAssembler* assembler,
+                                          Generator generator) {
   Node* reg_index = __ BytecodeOperandReg(0);
   Node* lhs = __ LoadRegister(reg_index);
   Node* rhs = __ GetAccumulator();
   Node* context = __ GetContext();
   Node* slot_index = __ BytecodeOperandIdx(1);
   Node* type_feedback_vector = __ LoadTypeFeedbackVector();
 
   // TODO(interpreter): the only reason this check is here is because we
   // sometimes emit comparisons that shouldn't collect feedback (e.g.
   // try-finally blocks and generators), and we could get rid of this by
@@ skipping 47 matching lines @@
                     __ Int32Constant(CompareOperationFeedback::kSignedSmall)));
     __ Goto(&do_compare);
   }
 
   __ Bind(&do_compare);
   __ UpdateFeedback(var_type_feedback.value(), type_feedback_vector,
                     slot_index);
   __ Goto(&skip_feedback_update);
 
   __ Bind(&skip_feedback_update);
-  Node* result = Generator::Generate(assembler, lhs, rhs, context);
+  Node* result = generator(assembler, lhs, rhs, context);
   __ SetAccumulator(result);
   __ Dispatch();
 }
 
 // Add <src>
 //
 // Add register <src> to accumulator.
 void Interpreter::DoAdd(InterpreterAssembler* assembler) {
   DoBinaryOpWithFeedback<AddWithFeedbackStub>(assembler);
 }
@@ skipping 500 matching lines @@
   __ Bind(&end);
   __ SetAccumulator(result.value());
   __ Dispatch();
 }
 
 // TypeOf
 //
 // Load the accumulator with the string representating type of the
 // object in the accumulator.
 void Interpreter::DoTypeOf(InterpreterAssembler* assembler) {
-  DoUnaryOp<TypeofStub>(assembler);
+  struct Generator {
+    static Node* Generate(InterpreterAssembler* assembler, Node* value,
+                          Node* context) {
+      return assembler->Typeof(value, context);
+    }
+  };
+  DoUnaryOp<Generator>(assembler);
 }
 
 void Interpreter::DoDelete(Runtime::FunctionId function_id,
                            InterpreterAssembler* assembler) {
   Node* reg_index = __ BytecodeOperandReg(0);
   Node* object = __ LoadRegister(reg_index);
   Node* key = __ GetAccumulator();
   Node* context = __ GetContext();
   Node* result = __ CallRuntime(function_id, context, object, key);
   __ SetAccumulator(result);
@@ skipping 157 matching lines @@
   Node* result = __ CallConstruct(constructor, context, new_target, first_arg,
                                   args_count, slot_id, type_feedback_vector);
   __ SetAccumulator(result);
   __ Dispatch();
 }
 
 // TestEqual <src>
 //
 // Test if the value in the <src> register equals the accumulator.
 void Interpreter::DoTestEqual(InterpreterAssembler* assembler) {
-  DoCompareOpWithFeedback<EqualStub>(assembler);
+  DoCompareOpWithFeedback(assembler, [](CodeStubAssembler* assembler, Node* lhs,
+                                        Node* rhs, Node* context) {
+    return assembler->Equal(CodeStubAssembler::kDontNegateResult, lhs, rhs,
+                            context);

[rmcilroy, 2016/10/05 17:20:52]

I'm not keen on this approach of building a generator that looks like the old
code-stub Generate function. How about just passing the appropriate AST Token
into DoCompareOpWithFeedback, and switch on the token to choose the right
assembler operator (similar to DoBitwiseBinaryOp)?

+  });
 }
 
 // TestNotEqual <src>
 //
 // Test if the value in the <src> register is not equal to the accumulator.
 void Interpreter::DoTestNotEqual(InterpreterAssembler* assembler) {
-  DoCompareOpWithFeedback<NotEqualStub>(assembler);
+  DoCompareOpWithFeedback(assembler, [](CodeStubAssembler* assembler, Node* lhs,
+                                        Node* rhs, Node* context) {
+    return assembler->Equal(CodeStubAssembler::kNegateResult, lhs, rhs,
+                            context);
+  });
 }
 
 // TestEqualStrict <src>
 //
 // Test if the value in the <src> register is strictly equal to the accumulator.
 void Interpreter::DoTestEqualStrict(InterpreterAssembler* assembler) {
-  DoCompareOpWithFeedback<StrictEqualStub>(assembler);
+  DoCompareOpWithFeedback(assembler, [](CodeStubAssembler* assembler, Node* lhs,
+                                        Node* rhs, Node* context) {
+    return assembler->StrictEqual(CodeStubAssembler::kDontNegateResult, lhs,
+                                  rhs, context);
+  });
 }
 
 // TestLessThan <src>
 //
 // Test if the value in the <src> register is less than the accumulator.
 void Interpreter::DoTestLessThan(InterpreterAssembler* assembler) {
-  DoCompareOpWithFeedback<LessThanStub>(assembler);
+  DoCompareOpWithFeedback(assembler, [](CodeStubAssembler* assembler, Node* lhs,
+                                        Node* rhs, Node* context) {
+    return assembler->RelationalComparison(CodeStubAssembler::kLessThan, lhs,
+                                           rhs, context);
+  });
 }
 
 // TestGreaterThan <src>
 //
 // Test if the value in the <src> register is greater than the accumulator.
 void Interpreter::DoTestGreaterThan(InterpreterAssembler* assembler) {
-  DoCompareOpWithFeedback<GreaterThanStub>(assembler);
+  DoCompareOpWithFeedback(assembler, [](CodeStubAssembler* assembler, Node* lhs,
+                                        Node* rhs, Node* context) {
+    return assembler->RelationalComparison(CodeStubAssembler::kGreaterThan, lhs,
+                                           rhs, context);
+  });
 }
 
 // TestLessThanOrEqual <src>
 //
 // Test if the value in the <src> register is less than or equal to the
 // accumulator.
 void Interpreter::DoTestLessThanOrEqual(InterpreterAssembler* assembler) {
-  DoCompareOpWithFeedback<LessThanOrEqualStub>(assembler);
+  DoCompareOpWithFeedback(assembler, [](CodeStubAssembler* assembler, Node* lhs,
+                                        Node* rhs, Node* context) {
+    return assembler->RelationalComparison(CodeStubAssembler::kLessThanOrEqual,
+                                           lhs, rhs, context);
+  });
 }
 
 // TestGreaterThanOrEqual <src>
 //
 // Test if the value in the <src> register is greater than or equal to the
 // accumulator.
 void Interpreter::DoTestGreaterThanOrEqual(InterpreterAssembler* assembler) {
-  DoCompareOpWithFeedback<GreaterThanOrEqualStub>(assembler);
+  DoCompareOpWithFeedback(assembler, [](CodeStubAssembler* assembler, Node* lhs,
+                                        Node* rhs, Node* context) {
+    return assembler->RelationalComparison(
+        CodeStubAssembler::kGreaterThanOrEqual, lhs, rhs, context);
+  });
 }
 
 // TestIn <src>
 //
 // Test if the object referenced by the register operand is a property of the
 // object referenced by the accumulator.
 void Interpreter::DoTestIn(InterpreterAssembler* assembler) {
-  DoBinaryOp<HasPropertyStub>(assembler);
+  struct Generator {
+    static Node* Generate(InterpreterAssembler* assembler, compiler::Node* key,
+                          compiler::Node* object, compiler::Node* context) {
+      return assembler->HasProperty(object, key, context,
+                                    Runtime::kHasProperty);
+    }
+  };
+  DoBinaryOp<Generator>(assembler);

[rmcilroy, 2016/10/05 17:20:52]

Ditto for DoBinaryOp (maybe these should be calling a function called
DoCompareOp (WithoutFeedback).

 }
 
 // TestInstanceOf <src>
 //
 // Test if the object referenced by the <src> register is an an instance of type
 // referenced by the accumulator.
 void Interpreter::DoTestInstanceOf(InterpreterAssembler* assembler) {
-  DoBinaryOp<InstanceOfStub>(assembler);
+  struct Generator {
+    static Node* Generate(InterpreterAssembler* assembler,
+                          compiler::Node* object, compiler::Node* callable,
+                          compiler::Node* context) {
+      return assembler->InstanceOf(object, callable, context);
+    }
+  };
+  DoBinaryOp<Generator>(assembler);
 }
 
 // Jump <imm>
 //
 // Jump by number of bytes represented by the immediate operand |imm|.
 void Interpreter::DoJump(InterpreterAssembler* assembler) {
   Node* relative_jump = __ BytecodeOperandImm(0);
   __ Jump(relative_jump);
 }
 
@@ skipping 826 matching lines @@
   __ StoreObjectField(generator, JSGeneratorObject::kContinuationOffset,
       __ SmiTag(new_state));
   __ SetAccumulator(old_state);
 
   __ Dispatch();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8