[turbofan] Next step towards shared operators.

test/cctest/compiler/test-js-typed-lowering.cc

 // Copyright 2014 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/v8.h"
 #include "test/cctest/cctest.h"
 
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/js-typed-lowering.h"
 #include "src/compiler/node-properties-inl.h"
@@ skipping 15 matching lines @@
         common(main_zone()),
         graph(main_zone()),
         typer(main_zone()),
         context_node(NULL) {
     typer.DecorateGraph(&graph);
     Node* s = graph.NewNode(common.Start(num_parameters));
     graph.SetStart(s);
   }
 
   Isolate* isolate;
-  Operator* binop;
-  Operator* unop;
+  const Operator* binop;
+  const Operator* unop;
   JSOperatorBuilder javascript;
   MachineOperatorBuilder machine;
   SimplifiedOperatorBuilder simplified;
   CommonOperatorBuilder common;
   Graph graph;
   Typer typer;
   Node* context_node;
 
   Node* Parameter(Type* t, int32_t index = 0) {
     Node* n = graph.NewNode(common.Parameter(index), graph.start());
@@ skipping 18 matching lines @@
     return context_node;
   }
 
   Node* control() { return start(); }
 
   void CheckPureBinop(IrOpcode::Value expected, Node* node) {
     CHECK_EQ(expected, node->opcode());
     CHECK_EQ(2, node->InputCount());  // should not have context, effect, etc.
   }
 
-  void CheckPureBinop(Operator* expected, Node* node) {
+  void CheckPureBinop(const Operator* expected, Node* node) {
     CHECK_EQ(expected->opcode(), node->op()->opcode());
     CHECK_EQ(2, node->InputCount());  // should not have context, effect, etc.
   }
 
-  Node* ReduceUnop(Operator* op, Type* input_type) {
+  Node* ReduceUnop(const Operator* op, Type* input_type) {
     return reduce(Unop(op, Parameter(input_type)));
   }
 
-  Node* ReduceBinop(Operator* op, Type* left_type, Type* right_type) {
+  Node* ReduceBinop(const Operator* op, Type* left_type, Type* right_type) {
     return reduce(Binop(op, Parameter(left_type, 0), Parameter(right_type, 1)));
   }
 
-  Node* Binop(Operator* op, Node* left, Node* right) {
+  Node* Binop(const Operator* op, Node* left, Node* right) {
     // JS binops also require context, effect, and control
     return graph.NewNode(op, left, right, context(), start(), control());
   }
 
-  Node* Unop(Operator* op, Node* input) {
+  Node* Unop(const Operator* op, Node* input) {
     // JS unops also require context, effect, and control
     return graph.NewNode(op, input, context(), start(), control());
   }
 
   Node* UseForEffect(Node* node) {
     // TODO(titzer): use EffectPhi after fixing EffectCount
     return graph.NewNode(javascript.ToNumber(), node, context(), node,
                          control());
   }
 
@@ skipping 94 matching lines @@
 
     R.CheckPureBinop(IrOpcode::kNumberAdd, r);
     CHECK_EQ(p0, r->InputAt(0));
     CHECK_EQ(p1, r->InputAt(1));
   }
 }
 
 
 TEST(NumberBinops) {
   JSTypedLoweringTester R;
-  Operator* ops[] = {
+  const Operator* ops[] = {
       R.javascript.Add(),      R.simplified.NumberAdd(),
       R.javascript.Subtract(), R.simplified.NumberSubtract(),
       R.javascript.Multiply(), R.simplified.NumberMultiply(),
       R.javascript.Divide(),   R.simplified.NumberDivide(),
       R.javascript.Modulus(),  R.simplified.NumberModulus(),
   };
 
   for (size_t i = 0; i < arraysize(kNumberTypes); ++i) {
     Node* p0 = R.Parameter(kNumberTypes[i], 0);
 
@@ skipping 26 matching lines @@
   } else {
     CHECK_EQ(NumberToI32(is_signed), new_input->opcode());
   }
 }
 
 
 // A helper class for testing lowering of bitwise shift operators.
 class JSBitwiseShiftTypedLoweringTester : public JSTypedLoweringTester {
  public:
   static const int kNumberOps = 6;
-  Operator* ops[kNumberOps];
+  const Operator* ops[kNumberOps];
   bool signedness[kNumberOps];
 
   JSBitwiseShiftTypedLoweringTester() {
     int i = 0;
     set(i++, javascript.ShiftLeft(), true);
     set(i++, machine.Word32Shl(), false);
     set(i++, javascript.ShiftRight(), true);
     set(i++, machine.Word32Sar(), false);
     set(i++, javascript.ShiftRightLogical(), false);
     set(i++, machine.Word32Shr(), false);
   }
 
  private:
-  void set(int idx, Operator* op, bool s) {
+  void set(int idx, const Operator* op, bool s) {
     ops[idx] = op;
     signedness[idx] = s;
   }
 };
 
 
 TEST(Int32BitwiseShifts) {
   JSBitwiseShiftTypedLoweringTester R;
 
   Type* types[] = {
@@ skipping 25 matching lines @@
       }
     }
   }
 }
 
 
 // A helper class for testing lowering of bitwise operators.
 class JSBitwiseTypedLoweringTester : public JSTypedLoweringTester {
  public:
   static const int kNumberOps = 6;
-  Operator* ops[kNumberOps];
+  const Operator* ops[kNumberOps];
   bool signedness[kNumberOps];
 
   JSBitwiseTypedLoweringTester() {
     int i = 0;
     set(i++, javascript.BitwiseOr(), true);
     set(i++, machine.Word32Or(), true);
     set(i++, javascript.BitwiseXor(), true);
     set(i++, machine.Word32Xor(), true);
     set(i++, javascript.BitwiseAnd(), true);
     set(i++, machine.Word32And(), true);
   }
 
  private:
-  void set(int idx, Operator* op, bool s) {
+  void set(int idx, const Operator* op, bool s) {
     ops[idx] = op;
     signedness[idx] = s;
   }
 };
 
 
 TEST(Int32BitwiseBinops) {
   JSBitwiseTypedLoweringTester R;
 
   Type* types[] = {
@@ skipping 18 matching lines @@
         CheckToI32(p0, r->InputAt(0), R.signedness[k]);
         CheckToI32(p1, r->InputAt(1), R.signedness[k + 1]);
       }
     }
   }
 }
 
 
 TEST(JSToNumber1) {
   JSTypedLoweringTester R;
-  Operator* ton = R.javascript.ToNumber();
+  const Operator* ton = R.javascript.ToNumber();
 
   for (size_t i = 0; i < arraysize(kNumberTypes); i++) {  // ToNumber(number)
     Node* r = R.ReduceUnop(ton, kNumberTypes[i]);
     CHECK_EQ(IrOpcode::kParameter, r->opcode());
   }
 
   {  // ToNumber(undefined)
     Node* r = R.ReduceUnop(ton, Type::Undefined());
     R.CheckNaN(r);
   }
@@ skipping 29 matching lines @@
     CHECK_EQ(n, add->InputAt(0));
     CHECK_EQ(r, add->InputAt(1));
     R.CheckEffectInput(R.start(), effect_use);
   }
 }
 
 
 TEST(JSToNumberOfConstant) {
   JSTypedLoweringTester R;
 
-  Operator* ops[] = {R.common.NumberConstant(0), R.common.NumberConstant(-1),
-                     R.common.NumberConstant(0.1), R.common.Int32Constant(1177),
-                     R.common.Float64Constant(0.99)};
+  const Operator* ops[] = {
+      R.common.NumberConstant(0), R.common.NumberConstant(-1),
+      R.common.NumberConstant(0.1), R.common.Int32Constant(1177),
+      R.common.Float64Constant(0.99)};
 
   for (size_t i = 0; i < arraysize(ops); i++) {
     Node* n = R.graph.NewNode(ops[i]);
     Node* convert = R.Unop(R.javascript.ToNumber(), n);
     Node* r = R.reduce(convert);
     // Note that either outcome below is correct. It only depends on whether
     // the types of constants are eagerly computed or only computed by the
     // typing pass.
     if (NodeProperties::GetBounds(n).upper->Is(Type::Number())) {
       // If number constants are eagerly typed, then reduction should
@@ skipping 16 matching lines @@
   for (size_t i = 0; i < arraysize(others); i++) {
     Type* t = Type::Union(Type::Number(), others[i], R.main_zone());
     Node* r = R.ReduceUnop(R.javascript.ToNumber(), t);
     CHECK_EQ(IrOpcode::kJSToNumber, r->opcode());
   }
 }
 
 
 TEST(JSToBoolean) {
   JSTypedLoweringTester R;
-  Operator* op = R.javascript.ToBoolean();
+  const Operator* op = R.javascript.ToBoolean();
 
   {  // ToBoolean(undefined)
     Node* r = R.ReduceUnop(op, Type::Undefined());
     R.CheckFalse(r);
   }
 
   {  // ToBoolean(null)
     Node* r = R.ReduceUnop(op, Type::Null());
     R.CheckFalse(r);
   }
@@ skipping 67 matching lines @@
 
 
 TEST(JSToString1) {
   JSTypedLoweringTester R;
 
   for (size_t i = 0; i < arraysize(kStringTypes); i++) {
     Node* r = R.ReduceUnop(R.javascript.ToString(), kStringTypes[i]);
     CHECK_EQ(IrOpcode::kParameter, r->opcode());
   }
 
-  Operator* op = R.javascript.ToString();
+  const Operator* op = R.javascript.ToString();
 
   {  // ToString(undefined) => "undefined"
     Node* r = R.ReduceUnop(op, Type::Undefined());
     R.CheckHandle(R.isolate->factory()->undefined_string(), r);
   }
 
   {  // ToString(null) => "null"
     Node* r = R.ReduceUnop(op, Type::Null());
     R.CheckHandle(R.isolate->factory()->null_string(), r);
   }
@@ skipping 46 matching lines @@
     CHECK_EQ(n, add->InputAt(0));
     CHECK_EQ(r, add->InputAt(1));
     R.CheckEffectInput(R.start(), effect_use);
   }
 }
 
 
 TEST(StringComparison) {
   JSTypedLoweringTester R;
 
-  Operator* ops[] = {
+  const Operator* ops[] = {
       R.javascript.LessThan(),           R.simplified.StringLessThan(),
       R.javascript.LessThanOrEqual(),    R.simplified.StringLessThanOrEqual(),
       R.javascript.GreaterThan(),        R.simplified.StringLessThan(),
       R.javascript.GreaterThanOrEqual(), R.simplified.StringLessThanOrEqual()};
 
   for (size_t i = 0; i < arraysize(kStringTypes); i++) {
     Node* p0 = R.Parameter(kStringTypes[i], 0);
     for (size_t j = 0; j < arraysize(kStringTypes); j++) {
       Node* p1 = R.Parameter(kStringTypes[j], 1);
 
@@ skipping 24 matching lines @@
     if (converted->opcode() == IrOpcode::kNumberConstant) return;
     CHECK_EQ(IrOpcode::kJSToNumber, converted->opcode());
     CHECK_EQ(val, converted->InputAt(0));
   }
 }
 
 
 TEST(NumberComparison) {
   JSTypedLoweringTester R;
 
-  Operator* ops[] = {
+  const Operator* ops[] = {
       R.javascript.LessThan(),           R.simplified.NumberLessThan(),
       R.javascript.LessThanOrEqual(),    R.simplified.NumberLessThanOrEqual(),
       R.javascript.GreaterThan(),        R.simplified.NumberLessThan(),
       R.javascript.GreaterThanOrEqual(), R.simplified.NumberLessThanOrEqual()};
 
   for (size_t i = 0; i < arraysize(kJSTypes); i++) {
     Type* t0 = kJSTypes[i];
     if (t0->Is(Type::String())) continue;  // skip Type::String
     Node* p0 = R.Parameter(t0, 0);
 
@@ skipping 79 matching lines @@
 
   // Check effect chain is correct.
   R.CheckEffectInput(R.start(), i0);
   R.CheckEffectInput(i0, i1);
   R.CheckEffectInput(i1, effect_use);
 }
 
 
 TEST(UnaryNot) {
   JSTypedLoweringTester R;
-  Operator* opnot = R.javascript.UnaryNot();
+  const Operator* opnot = R.javascript.UnaryNot();
 
   for (size_t i = 0; i < arraysize(kJSTypes); i++) {
     Node* orig = R.Unop(opnot, R.Parameter(kJSTypes[i]));
     Node* use = R.graph.NewNode(R.common.Return(), orig);
     Node* r = R.reduce(orig);
     // TODO(titzer): test will break if/when js-typed-lowering constant folds.
     CHECK_EQ(IrOpcode::kBooleanNot, use->InputAt(0)->opcode());
 
     if (r == orig && orig->opcode() == IrOpcode::kJSToBoolean) {
       // The original node was turned into a ToBoolean.
@@ skipping 56 matching lines @@
     }
   }
 
   CHECK_EQ(NULL, effect_use);  // should have done all cases above.
 }
 
 
 // Helper class for testing the reduction of a single binop.
 class BinopEffectsTester {
  public:
-  explicit BinopEffectsTester(Operator* op, Type* t0, Type* t1)
+  explicit BinopEffectsTester(const Operator* op, Type* t0, Type* t1)
       : R(),
         p0(R.Parameter(t0, 0)),
         p1(R.Parameter(t1, 1)),
         binop(R.Binop(op, p0, p1)),
         effect_use(R.graph.NewNode(R.common.EffectPhi(1), binop, R.start())) {
     // Effects should be ordered start -> binop -> effect_use
     R.CheckEffectInput(R.start(), binop);
     R.CheckEffectInput(binop, effect_use);
     result = R.reduce(binop);
   }
@@ skipping 108 matching lines @@
   Node* p1 = R.Parameter(Type::String());
 
   CheckEqualityReduction(&R, true, p0, p1, IrOpcode::kStringEqual);
   CheckEqualityReduction(&R, false, p0, p1, IrOpcode::kStringEqual);
 }
 
 
 TEST(RemovePureNumberBinopEffects) {
   JSTypedLoweringTester R;
 
-  Operator* ops[] = {
+  const Operator* ops[] = {
       R.javascript.Equal(),           R.simplified.NumberEqual(),
       R.javascript.Add(),             R.simplified.NumberAdd(),
       R.javascript.Subtract(),        R.simplified.NumberSubtract(),
       R.javascript.Multiply(),        R.simplified.NumberMultiply(),
       R.javascript.Divide(),          R.simplified.NumberDivide(),
       R.javascript.Modulus(),         R.simplified.NumberModulus(),
       R.javascript.LessThan(),        R.simplified.NumberLessThan(),
       R.javascript.LessThanOrEqual(), R.simplified.NumberLessThanOrEqual(),
   };
 
   for (size_t j = 0; j < arraysize(ops); j += 2) {
     BinopEffectsTester B(ops[j], Type::Number(), Type::Number());
     CHECK_EQ(ops[j + 1]->opcode(), B.result->op()->opcode());
 
     B.R.CheckPureBinop(B.result->opcode(), B.result);
 
     B.CheckNoOp(0);
     B.CheckNoOp(1);
 
     B.CheckEffectsRemoved();
   }
 }
 
 
 TEST(OrderNumberBinopEffects1) {
   JSTypedLoweringTester R;
 
-  Operator* ops[] = {
+  const Operator* ops[] = {
       R.javascript.Subtract(), R.simplified.NumberSubtract(),
       R.javascript.Multiply(), R.simplified.NumberMultiply(),
       R.javascript.Divide(),   R.simplified.NumberDivide(),
       R.javascript.Modulus(),  R.simplified.NumberModulus(),
   };
 
   for (size_t j = 0; j < arraysize(ops); j += 2) {
     BinopEffectsTester B(ops[j], Type::Object(), Type::String());
     CHECK_EQ(ops[j + 1]->opcode(), B.result->op()->opcode());
 
     Node* i0 = B.CheckConvertedInput(IrOpcode::kJSToNumber, 0, true);
     Node* i1 = B.CheckConvertedInput(IrOpcode::kJSToNumber, 1, true);
 
     CHECK_EQ(B.p0, i0->InputAt(0));
     CHECK_EQ(B.p1, i1->InputAt(0));
 
     // Effects should be ordered start -> i0 -> i1 -> effect_use
     B.CheckEffectOrdering(i0, i1);
   }
 }
 
 
 TEST(OrderNumberBinopEffects2) {
   JSTypedLoweringTester R;
 
-  Operator* ops[] = {
+  const Operator* ops[] = {
       R.javascript.Add(),      R.simplified.NumberAdd(),
       R.javascript.Subtract(), R.simplified.NumberSubtract(),
       R.javascript.Multiply(), R.simplified.NumberMultiply(),
       R.javascript.Divide(),   R.simplified.NumberDivide(),
       R.javascript.Modulus(),  R.simplified.NumberModulus(),
   };
 
   for (size_t j = 0; j < arraysize(ops); j += 2) {
     BinopEffectsTester B(ops[j], Type::Number(), Type::Object());
 
@@ skipping 18 matching lines @@
 
     // Effects should be ordered start -> i0 -> effect_use
     B.CheckEffectOrdering(i0);
   }
 }
 
 
 TEST(OrderCompareEffects) {
   JSTypedLoweringTester R;
 
-  Operator* ops[] = {
+  const Operator* ops[] = {
       R.javascript.GreaterThan(), R.simplified.NumberLessThan(),
       R.javascript.GreaterThanOrEqual(), R.simplified.NumberLessThanOrEqual(),
   };
 
   for (size_t j = 0; j < arraysize(ops); j += 2) {
     BinopEffectsTester B(ops[j], Type::Object(), Type::String());
     CHECK_EQ(ops[j + 1]->opcode(), B.result->op()->opcode());
 
     Node* i0 = B.CheckConvertedInput(IrOpcode::kJSToNumber, 0, true);
     Node* i1 = B.CheckConvertedInput(IrOpcode::kJSToNumber, 1, true);
@@ skipping 112 matching lines @@
     CHECK_EQ(B.p0, ii0->InputAt(0));
     CHECK_EQ(B.p1, ii1->InputAt(0));
 
     B.CheckEffectOrdering(ii0, ii1);
   }
 }
 
 
 TEST(UnaryNotEffects) {
   JSTypedLoweringTester R;
-  Operator* opnot = R.javascript.UnaryNot();
+  const Operator* opnot = R.javascript.UnaryNot();
 
   for (size_t i = 0; i < arraysize(kJSTypes); i++) {
     Node* p0 = R.Parameter(kJSTypes[i], 0);
     Node* orig = R.Unop(opnot, p0);
     Node* effect_use = R.UseForEffect(orig);
     Node* value_use = R.graph.NewNode(R.common.Return(), orig);
     Node* r = R.reduce(orig);
     // TODO(titzer): test will break if/when js-typed-lowering constant folds.
     CHECK_EQ(IrOpcode::kBooleanNot, value_use->InputAt(0)->opcode());
 
@@ skipping 91 matching lines @@
     CHECK_EQ(add_node, other_use->InputAt(0));
     CHECK_EQ(one, other_use->InputAt(1));
   }
 }
 
 
 TEST(Int32Comparisons) {
   JSTypedLoweringTester R;
 
   struct Entry {
-    Operator* js_op;
-    Operator* uint_op;
-    Operator* int_op;
-    Operator* num_op;
+    const Operator* js_op;
+    const Operator* uint_op;
+    const Operator* int_op;
+    const Operator* num_op;
     bool commute;
   };
 
   Entry ops[] = {
       {R.javascript.LessThan(), R.machine.Uint32LessThan(),
        R.machine.Int32LessThan(), R.simplified.NumberLessThan(), false},
       {R.javascript.LessThanOrEqual(), R.machine.Uint32LessThanOrEqual(),
        R.machine.Int32LessThanOrEqual(), R.simplified.NumberLessThanOrEqual(),
        false},
       {R.javascript.GreaterThan(), R.machine.Uint32LessThan(),
        R.machine.Int32LessThan(), R.simplified.NumberLessThan(), true},
       {R.javascript.GreaterThanOrEqual(), R.machine.Uint32LessThanOrEqual(),
        R.machine.Int32LessThanOrEqual(), R.simplified.NumberLessThanOrEqual(),
        true}};
 
   for (size_t o = 0; o < arraysize(ops); o++) {
     for (size_t i = 0; i < arraysize(kNumberTypes); i++) {
       Type* t0 = kNumberTypes[i];
       Node* p0 = R.Parameter(t0, 0);
 
       for (size_t j = 0; j < arraysize(kNumberTypes); j++) {
         Type* t1 = kNumberTypes[j];
         Node* p1 = R.Parameter(t1, 1);
 
         Node* cmp = R.Binop(ops[o].js_op, p0, p1);
         Node* r = R.reduce(cmp);
 
-        Operator* expected;
+        const Operator* expected;
         if (t0->Is(Type::Unsigned32()) && t1->Is(Type::Unsigned32())) {
           expected = ops[o].uint_op;
         } else if (t0->Is(Type::Signed32()) && t1->Is(Type::Signed32())) {
           expected = ops[o].int_op;
         } else {
           expected = ops[o].num_op;
         }
         R.CheckPureBinop(expected, r);
         if (ops[o].commute) {
           CHECK_EQ(p1, r->InputAt(0));
           CHECK_EQ(p0, r->InputAt(1));
         } else {
           CHECK_EQ(p0, r->InputAt(0));
           CHECK_EQ(p1, r->InputAt(1));
         }
       }
     }
   }
 }