[turbofan] Add binary operation hints for javascript 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.
 
 // TODO(jochen): Remove this after the setting is turned on globally.
 #define V8_IMMINENT_DEPRECATION_WARNINGS
 
 #include "src/compilation-dependencies.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/js-typed-lowering.h"
@@ skipping 45 matching lines @@
   const Operator* binop;
   const Operator* unop;
   JSOperatorBuilder javascript;
   MachineOperatorBuilder machine;
   SimplifiedOperatorBuilder simplified;
   CommonOperatorBuilder common;
   CompilationDependencies deps;
   Graph graph;
   Typer typer;
   Node* context_node;
+  BinaryOperationHints const hints = BinaryOperationHints::Any();
 
   Node* Parameter(Type* t, int32_t index = 0) {
     Node* n = graph.NewNode(common.Parameter(index), graph.start());
     NodeProperties::SetType(n, t);
     return n;
   }
 
   Node* UndefinedConstant() {
     Handle<HeapObject> value = isolate->factory()->undefined_value();
     return graph.NewNode(common.HeapConstant(value));
@@ skipping 185 matching lines @@
   }
 }
 #endif
 
 
 TEST_WITH_STRONG(AddNumber1) {
   JSTypedLoweringTester R;
   for (size_t i = 0; i < arraysize(kNumberTypes); ++i) {
     Node* p0 = R.Parameter(kNumberTypes[i], 0);
     Node* p1 = R.Parameter(kNumberTypes[i], 1);
-    Node* add = R.Binop(R.javascript.Add(language_mode), p0, p1);
+    Node* add = R.Binop(
+        R.javascript.Add(language_mode, BinaryOperationHints::Any()), p0, p1);
     Node* r = R.reduce(add);
 
     R.CheckBinop(IrOpcode::kNumberAdd, r);
     CHECK_EQ(p0, r->InputAt(0));
     CHECK_EQ(p1, r->InputAt(1));
   }
 }
 
 
 TEST_WITH_STRONG(NumberBinops) {
   JSTypedLoweringTester R;
   const Operator* ops[] = {
-      R.javascript.Add(language_mode),      R.simplified.NumberAdd(),
-      R.javascript.Subtract(language_mode), R.simplified.NumberSubtract(),
-      R.javascript.Multiply(language_mode), R.simplified.NumberMultiply(),
-      R.javascript.Divide(language_mode),   R.simplified.NumberDivide(),
-      R.javascript.Modulus(language_mode),  R.simplified.NumberModulus(),
+      R.javascript.Add(language_mode, R.hints),
+      R.simplified.NumberAdd(),
+      R.javascript.Subtract(language_mode, R.hints),
+      R.simplified.NumberSubtract(),
+      R.javascript.Multiply(language_mode, R.hints),
+      R.simplified.NumberMultiply(),
+      R.javascript.Divide(language_mode, R.hints),
+      R.simplified.NumberDivide(),
+      R.javascript.Modulus(language_mode, R.hints),
+      R.simplified.NumberModulus(),
   };
 
   for (size_t i = 0; i < arraysize(kNumberTypes); ++i) {
     Node* p0 = R.Parameter(kNumberTypes[i], 0);
 
     for (size_t j = 0; j < arraysize(kNumberTypes); ++j) {
       Node* p1 = R.Parameter(kNumberTypes[j], 1);
 
       for (size_t k = 0; k < arraysize(ops); k += 2) {
         Node* add = R.Binop(ops[k], p0, p1);
@@ skipping 22 matching lines @@
   }
 }
 
 
 // A helper class for testing lowering of bitwise shift operators.
 class JSBitwiseShiftTypedLoweringTester : public JSTypedLoweringTester {
  public:
   explicit JSBitwiseShiftTypedLoweringTester(LanguageMode language_mode)
       : JSTypedLoweringTester(), language_mode_(language_mode) {
     int i = 0;
-    set(i++, javascript.ShiftLeft(language_mode_), true);
+    set(i++, javascript.ShiftLeft(language_mode_, hints), true);
     set(i++, simplified.NumberShiftLeft(), false);
-    set(i++, javascript.ShiftRight(language_mode_), true);
+    set(i++, javascript.ShiftRight(language_mode_, hints), true);
     set(i++, simplified.NumberShiftRight(), false);
-    set(i++, javascript.ShiftRightLogical(language_mode_), false);
+    set(i++, javascript.ShiftRightLogical(language_mode_, hints), false);
     set(i++, simplified.NumberShiftRightLogical(), false);
   }
   static const int kNumberOps = 6;
   const Operator* ops[kNumberOps];
   bool signedness[kNumberOps];
 
  private:
   LanguageMode language_mode_;
   void set(int idx, const Operator* op, bool s) {
     ops[idx] = op;
@@ skipping 33 matching lines @@
   }
 }
 
 
 // A helper class for testing lowering of bitwise operators.
 class JSBitwiseTypedLoweringTester : public JSTypedLoweringTester {
  public:
   explicit JSBitwiseTypedLoweringTester(LanguageMode language_mode)
       : JSTypedLoweringTester(), language_mode_(language_mode) {
     int i = 0;
-    set(i++, javascript.BitwiseOr(language_mode_), true);
+    set(i++, javascript.BitwiseOr(language_mode_, hints), true);
     set(i++, simplified.NumberBitwiseOr(), true);
-    set(i++, javascript.BitwiseXor(language_mode_), true);
+    set(i++, javascript.BitwiseXor(language_mode_, hints), true);
     set(i++, simplified.NumberBitwiseXor(), true);
-    set(i++, javascript.BitwiseAnd(language_mode_), true);
+    set(i++, javascript.BitwiseAnd(language_mode_, hints), true);
     set(i++, simplified.NumberBitwiseAnd(), true);
   }
   static const int kNumberOps = 6;
   const Operator* ops[kNumberOps];
   bool signedness[kNumberOps];
 
  private:
   LanguageMode language_mode_;
   void set(int idx, const Operator* op, bool s) {
     ops[idx] = op;
@@ skipping 329 matching lines @@
         break;
       case 1:
         DCHECK(OperatorProperties::GetFrameStateInputCount(
                    R.javascript.ToNumber()) == 1);
         effect_use = R.graph.NewNode(R.javascript.ToNumber(), ton, R.context(),
                                      frame_state, ton, R.start());
         break;
       case 2:
         effect_use = R.graph.NewNode(R.common.EffectPhi(1), ton, R.start());
       case 3:
-        effect_use = R.graph.NewNode(R.javascript.Add(language_mode), ton, ton,
-                                     R.context(), frame_state, frame_state, ton,
-                                     R.start());
+        effect_use = R.graph.NewNode(R.javascript.Add(language_mode, R.hints),
+                                     ton, ton, R.context(), frame_state,
+                                     frame_state, ton, R.start());
         break;
       case 4:
-        effect_use = R.graph.NewNode(R.javascript.Add(language_mode), p0, p0,
-                                     R.context(), frame_state, frame_state, ton,
-                                     R.start());
+        effect_use = R.graph.NewNode(R.javascript.Add(language_mode, R.hints),
+                                     p0, p0, R.context(), frame_state,
+                                     frame_state, ton, R.start());
         break;
       case 5:
         effect_use = R.graph.NewNode(R.common.Return(), p0, ton, R.start());
         break;
       case 6:
         effect_use = R.graph.NewNode(R.common.Return(), ton, ton, R.start());
     }
 
     R.CheckEffectInput(R.start(), ton);
     if (effect_use != NULL) R.CheckEffectInput(ton, effect_use);
@@ skipping 142 matching lines @@
 
   CheckEqualityReduction(&R, true, p0, p1, IrOpcode::kStringEqual);
   CheckEqualityReduction(&R, false, p0, p1, IrOpcode::kStringEqual);
 }
 
 
 TEST_WITH_STRONG(RemovePureNumberBinopEffects) {
   JSTypedLoweringTester R;
 
   const Operator* ops[] = {
-      R.javascript.Equal(),           R.simplified.NumberEqual(),
-      R.javascript.Add(language_mode),      R.simplified.NumberAdd(),
-      R.javascript.Subtract(language_mode), R.simplified.NumberSubtract(),
-      R.javascript.Multiply(language_mode), R.simplified.NumberMultiply(),
-      R.javascript.Divide(language_mode),   R.simplified.NumberDivide(),
-      R.javascript.Modulus(language_mode),  R.simplified.NumberModulus(),
-      R.javascript.LessThan(language_mode), R.simplified.NumberLessThan(),
+      R.javascript.Equal(),
+      R.simplified.NumberEqual(),
+      R.javascript.Add(language_mode, R.hints),
+      R.simplified.NumberAdd(),
+      R.javascript.Subtract(language_mode, R.hints),
+      R.simplified.NumberSubtract(),
+      R.javascript.Multiply(language_mode, R.hints),
+      R.simplified.NumberMultiply(),
+      R.javascript.Divide(language_mode, R.hints),
+      R.simplified.NumberDivide(),
+      R.javascript.Modulus(language_mode, R.hints),
+      R.simplified.NumberModulus(),
+      R.javascript.LessThan(language_mode),
+      R.simplified.NumberLessThan(),
       R.javascript.LessThanOrEqual(language_mode),
       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.CheckBinop(B.result->opcode(), B.result);
 
     B.CheckNoOp(0);
     B.CheckNoOp(1);
 
     B.CheckEffectsRemoved();
   }
 }
 
 
 TEST(OrderNumberBinopEffects1) {
   JSTypedLoweringTester R;
 
   const Operator* ops[] = {
-      R.javascript.Subtract(LanguageMode::SLOPPY),
+      R.javascript.Subtract(LanguageMode::SLOPPY, R.hints),
       R.simplified.NumberSubtract(),
-      R.javascript.Multiply(LanguageMode::SLOPPY),
+      R.javascript.Multiply(LanguageMode::SLOPPY, R.hints),
       R.simplified.NumberMultiply(),
-      R.javascript.Divide(LanguageMode::SLOPPY),
+      R.javascript.Divide(LanguageMode::SLOPPY, R.hints),
       R.simplified.NumberDivide(),
   };
 
   for (size_t j = 0; j < arraysize(ops); j += 2) {
     BinopEffectsTester B(ops[j], Type::Symbol(), Type::Symbol());
     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;
 
   const Operator* ops[] = {
-      R.javascript.Add(LanguageMode::SLOPPY),
+      R.javascript.Add(LanguageMode::SLOPPY, R.hints),
       R.simplified.NumberAdd(),
-      R.javascript.Subtract(LanguageMode::SLOPPY),
+      R.javascript.Subtract(LanguageMode::SLOPPY, R.hints),
       R.simplified.NumberSubtract(),
-      R.javascript.Multiply(LanguageMode::SLOPPY),
+      R.javascript.Multiply(LanguageMode::SLOPPY, R.hints),
       R.simplified.NumberMultiply(),
-      R.javascript.Divide(LanguageMode::SLOPPY),
+      R.javascript.Divide(LanguageMode::SLOPPY, R.hints),
       R.simplified.NumberDivide(),
   };
 
   for (size_t j = 0; j < arraysize(ops); j += 2) {
     BinopEffectsTester B(ops[j], Type::Number(), Type::Symbol());
 
     Node* i0 = B.CheckNoOp(0);
     Node* i1 = B.CheckConvertedInput(IrOpcode::kJSToNumber, 1, true);
 
     CHECK_EQ(B.p0, i0);
@@ skipping 278 matching lines @@
           CHECK_EQ(p1, r->InputAt(1));
         }
       }
     }
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8