[Interpreter] Add support for cast operators to bytecode graph builder and

test/unittests/compiler/bytecode-graph-builder-unittest.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 <iostream>
 
 #include "src/compiler/bytecode-graph-builder.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph-visualizer.h"
 #include "src/compiler/instruction.h"
@@ skipping 10 matching lines @@
 
 using ::testing::_;
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 static const LanguageMode kLanguageModes[] = {LanguageMode::SLOPPY,
                                               LanguageMode::STRICT};
 
+static const Token::Value kBinaryOperators[] = {
+    Token::Value::BIT_OR, Token::Value::BIT_XOR, Token::Value::BIT_AND,
+    Token::Value::SHL,    Token::Value::SAR,     Token::Value::SHR,
+    Token::Value::ADD,    Token::Value::SUB,     Token::Value::MUL,
+    Token::Value::DIV,    Token::Value::MOD};
+
+static IrOpcode::Value getIrOpcode(Token::Value token) {
+  switch (token) {
+    case Token::Value::BIT_OR:
+      return IrOpcode::Value::kJSBitwiseOr;
+    case Token::Value::BIT_XOR:
+      return IrOpcode::Value::kJSBitwiseXor;
+    case Token::Value::BIT_AND:
+      return IrOpcode::Value::kJSBitwiseAnd;
+    case Token::Value::SHL:
+      return IrOpcode::Value::kJSShiftLeft;
+    case Token::Value::SAR:
+      return IrOpcode::Value::kJSShiftRight;
+    case Token::Value::SHR:
+      return IrOpcode::Value::kJSShiftRightLogical;
+    case Token::Value::ADD:
+      return IrOpcode::Value::kJSAdd;
+    case Token::Value::SUB:
+      return IrOpcode::Value::kJSSubtract;
+    case Token::Value::MUL:
+      return IrOpcode::Value::kJSMultiply;
+    case Token::Value::DIV:
+      return IrOpcode::Value::kJSDivide;
+    case Token::Value::MOD:
+      return IrOpcode::Value::kJSModulus;
+    default:
+      UNREACHABLE();
+      return static_cast<IrOpcode::Value>(-1);
+  }
+}
+
 Handle<TypeFeedbackVector> NewTypeFeedbackVector(Isolate* isolate,
                                                  FeedbackVectorSpec* spec) {
   Handle<TypeFeedbackMetadata> vector_metadata =
       TypeFeedbackMetadata::New(isolate, spec);
   return TypeFeedbackVector::New(isolate, vector_metadata);
 }
 
 
 class BytecodeGraphBuilderTest : public TestWithIsolateAndZone {
  public:
@@ skipping 226 matching lines @@
   array_builder.set_locals_count(1);
   array_builder.set_context_count(0);
   array_builder.set_parameter_count(3);
   array_builder.LoadAccumulatorWithRegister(array_builder.Parameter(1))
       .BinaryOperation(Token::Value::ADD, array_builder.Parameter(2),
                        Strength::WEAK)
       .StoreAccumulatorInRegister(interpreter::Register(0))
       .Return();
 
   Graph* graph = GetCompletedGraph(array_builder.ToBytecodeArray());
+  Node* start = graph->start();
   Node* end = graph->end();
   EXPECT_EQ(1, end->InputCount());
   Node* ret = end->InputAt(0);
   // NB binary operation is <reg> <op> <acc>. The register represents
   // the left-hand side, which is why parameters appear in opposite
   // order to construction via the builder.
-  EXPECT_THAT(ret, IsReturn(IsJSAdd(IsParameter(2), IsParameter(1)), _, _));
+  Matcher<Node*> js_add_node = IsJSBinaryOperation(
+      IrOpcode::kJSAdd, IsParameter(2), IsParameter(1), start, start);
+  EXPECT_THAT(ret, IsReturn(js_add_node, _, _));
 }
 
 
 TEST_F(BytecodeGraphBuilderTest, SimpleExpressionWithRegister) {
+  TRACED_FOREACH(Token::Value, token, kBinaryOperators) {
+    interpreter::BytecodeArrayBuilder array_builder(isolate(), zone());
+    static const int kLeft = -655371;
+    static const int kRight = +2000000;
+    array_builder.set_locals_count(1);
+    array_builder.set_context_count(0);
+    array_builder.set_parameter_count(1);
+    array_builder.LoadLiteral(Smi::FromInt(kLeft))
+        .StoreAccumulatorInRegister(interpreter::Register(0))
+        .LoadLiteral(Smi::FromInt(kRight))
+        .BinaryOperation(token, interpreter::Register(0), Strength::WEAK)
+        .Return();
+
+    Graph* graph = GetCompletedGraph(array_builder.ToBytecodeArray());
+    Node* end = graph->end();
+    EXPECT_EQ(1, end->InputCount());
+    Node* start = graph->start();
+    Node* ret = end->InputAt(0);
+    Matcher<Node*> compute_node =
+        IsJSBinaryOperation(getIrOpcode(token), IsNumberConstant(kLeft),
+                            IsNumberConstant(kRight), start, start);
+    EXPECT_THAT(ret, IsReturn(compute_node, _, _));
+  }
+}
+
+
+TEST_F(BytecodeGraphBuilderTest, ToBoolean) {
   interpreter::BytecodeArrayBuilder array_builder(isolate(), zone());
-  static const int kLeft = -655371;
-  static const int kRight = +2000000;
   array_builder.set_locals_count(1);
   array_builder.set_context_count(0);
-  array_builder.set_parameter_count(1);
-  array_builder.LoadLiteral(Smi::FromInt(kLeft))
-      .StoreAccumulatorInRegister(interpreter::Register(0))
-      .LoadLiteral(Smi::FromInt(kRight))
-      .BinaryOperation(Token::Value::ADD, interpreter::Register(0),
-                       Strength::WEAK)
+  array_builder.set_parameter_count(2);
+  array_builder.LoadAccumulatorWithRegister(array_builder.Parameter(1))
+      .CastAccumulatorToBoolean()
       .Return();
 
   Graph* graph = GetCompletedGraph(array_builder.ToBytecodeArray());
-  Node* end = graph->end();
-  EXPECT_EQ(1, end->InputCount());
-  Node* ret = end->InputAt(0);
-  EXPECT_THAT(
-      ret, IsReturn(IsJSAdd(IsNumberConstant(kLeft), IsNumberConstant(kRight)),
-                    _, _));
+  Node* ret = graph->end()->InputAt(0);
+  Node* start = graph->start();
+
+  Matcher<Node*> to_boolean_node = IsJSToBoolean(IsParameter(1), start);
+  EXPECT_THAT(ret, IsReturn(to_boolean_node, _, _));
 }
 
 
+TEST_F(BytecodeGraphBuilderTest, ToName) {
+  interpreter::BytecodeArrayBuilder array_builder(isolate(), zone());
+  array_builder.set_locals_count(1);
+  array_builder.set_context_count(0);
+  array_builder.set_parameter_count(2);
+  array_builder.LoadAccumulatorWithRegister(array_builder.Parameter(1))
+      .CastAccumulatorToName()
+      .Return();
+
+  Graph* graph = GetCompletedGraph(array_builder.ToBytecodeArray());
+  Node* ret = graph->end()->InputAt(0);
+  Node* start = graph->start();
+
+  Matcher<Node*> to_name_node = IsJSToName(IsParameter(1), start, start);
+  EXPECT_THAT(ret, IsReturn(to_name_node, _, _));
+}
+
+
+TEST_F(BytecodeGraphBuilderTest, ToObject) {
+  interpreter::BytecodeArrayBuilder array_builder(isolate(), zone());
+  array_builder.set_locals_count(1);
+  array_builder.set_context_count(0);
+  array_builder.set_parameter_count(2);
+  array_builder.LoadAccumulatorWithRegister(array_builder.Parameter(1))
+      .CastAccumulatorToJSObject()
+      .Return();
+
+  Graph* graph = GetCompletedGraph(array_builder.ToBytecodeArray());
+  Node* ret = graph->end()->InputAt(0);
+  Node* start = graph->start();
+
+  Matcher<Node*> to_object_node = IsJSToObject(IsParameter(1), start, start);
+  EXPECT_THAT(ret, IsReturn(to_object_node, _, _));
+}
+
+
+TEST_F(BytecodeGraphBuilderTest, ToNumber) {
+  interpreter::BytecodeArrayBuilder array_builder(isolate(), zone());
+  array_builder.set_locals_count(1);
+  array_builder.set_context_count(0);
+  array_builder.set_parameter_count(2);
+  array_builder.LoadAccumulatorWithRegister(array_builder.Parameter(1))
+      .CastAccumulatorToNumber()
+      .Return();
+
+  Graph* graph = GetCompletedGraph(array_builder.ToBytecodeArray());
+  Node* ret = graph->end()->InputAt(0);
+  Node* start = graph->start();
+
+  Matcher<Node*> to_number_node = IsToNumber(IsParameter(1), _, start, start);
+  EXPECT_THAT(ret, IsReturn(to_number_node, _, _));
+}
+
+
 TEST_F(BytecodeGraphBuilderTest, NamedLoad) {
   const bool kWideBytecode[] = {false, true};
   TRACED_FOREACH(LanguageMode, language_mode, kLanguageModes) {
     TRACED_FOREACH(bool, wide_bytecode, kWideBytecode) {
       FeedbackVectorSpec feedback_spec(zone());
       if (wide_bytecode) {
         for (int i = 0; i < 128; i++) {
           feedback_spec.AddLoadICSlot();
         }
       }
@@ skipping 213 matching lines @@
   array_builder.set_parameter_count(2);
   array_builder.LoadAccumulatorWithRegister(array_builder.Parameter(1))
       .LogicalNot()
       .Return();
 
   FeedbackVectorSpec feedback_spec(zone());
   Handle<TypeFeedbackVector> vector =
       NewTypeFeedbackVector(isolate(), &feedback_spec);
   Graph* graph = GetCompletedGraph(array_builder.ToBytecodeArray(), vector);
 
+  Node* start = graph->start();
   Node* ret = graph->end()->InputAt(0);
-  EXPECT_THAT(ret, IsReturn(IsJSUnaryNot(IsParameter(1)), _, _));
+  EXPECT_THAT(ret, IsReturn(IsJSUnaryNot(IsParameter(1), start), _, _));
 }
 
 
 TEST_F(BytecodeGraphBuilderTest, TypeOf) {
   interpreter::BytecodeArrayBuilder array_builder(isolate(), zone());
   array_builder.set_locals_count(1);
   array_builder.set_context_count(0);
   array_builder.set_parameter_count(2);
   array_builder.LoadAccumulatorWithRegister(array_builder.Parameter(1))
       .TypeOf()
       .Return();
 
   FeedbackVectorSpec feedback_spec(zone());
   Handle<TypeFeedbackVector> vector =
       NewTypeFeedbackVector(isolate(), &feedback_spec);
   Graph* graph = GetCompletedGraph(array_builder.ToBytecodeArray(), vector);
 
+  Node* start = graph->start();
   Node* ret = graph->end()->InputAt(0);
-  EXPECT_THAT(ret, IsReturn(IsJSTypeOf(IsParameter(1)), _, _));
+  EXPECT_THAT(ret, IsReturn(IsJSTypeOf(IsParameter(1), start), _, _));
 }
 
 
 TEST_F(BytecodeGraphBuilderTest, Delete) {
   TRACED_FOREACH(LanguageMode, language_mode, kLanguageModes) {
     interpreter::BytecodeArrayBuilder array_builder(isolate(), zone());
     array_builder.set_locals_count(1);
     array_builder.set_context_count(0);
     array_builder.set_parameter_count(2);
     Handle<Name> name = GetName(isolate(), "val");
@@ skipping 228 matching lines @@
   construct_inputs.push_back(IsParameter(4));
   construct_inputs.push_back(IsParameter(1));
   Matcher<Node*> call_construct =
       IsJSCallConstruct(construct_inputs, start, start);
   EXPECT_THAT(ret, IsReturn(call_construct, call_construct, IsIfSuccess(_)));
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8