[turbofan] Make string comparisons effectful.

test/cctest/compiler/test-simplified-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 <limits>
 
 #include "src/compiler/access-builder.h"
 #include "src/compiler/change-lowering.h"
 #include "src/compiler/control-builders.h"
 #include "src/compiler/graph-reducer.h"
@@ skipping 680 matching lines @@
     NodeProperties::SetType(p1, p1_type);
     NodeProperties::SetType(p2, p2_type);
   }
 
   void CheckLoweringBinop(IrOpcode::Value expected, const Operator* op) {
     Node* node = Return(graph()->NewNode(op, p0, p1));
     Lower();
     CHECK_EQ(expected, node->opcode());
   }
 
+  void CheckLoweringStringBinop(IrOpcode::Value expected, const Operator* op) {
+    Node* node = Return(
+        graph()->NewNode(op, p0, p1, graph()->start(), graph()->start()));
+    Lower();
+    CHECK_EQ(expected, node->opcode());
+  }
+
   void CheckLoweringTruncatedBinop(IrOpcode::Value expected, const Operator* op,
                                    const Operator* trunc) {
     Node* node = graph()->NewNode(op, p0, p1);
     Return(graph()->NewNode(trunc, node));
     Lower();
     CHECK_EQ(expected, node->opcode());
   }
 
   void Lower() {
     SourcePositionTable table(jsgraph.graph());
@@ skipping 455 matching lines @@
 
 TEST(LowerStringOps_to_call_and_compare) {
     // These tests need linkage for the calls.
     TestingGraph t(Type::String(), Type::String());
     IrOpcode::Value compare_eq =
         static_cast<IrOpcode::Value>(t.machine()->WordEqual()->opcode());
     IrOpcode::Value compare_lt =
         static_cast<IrOpcode::Value>(t.machine()->IntLessThan()->opcode());
     IrOpcode::Value compare_le = static_cast<IrOpcode::Value>(
         t.machine()->IntLessThanOrEqual()->opcode());
-    t.CheckLoweringBinop(compare_eq, t.simplified()->StringEqual());
-    t.CheckLoweringBinop(compare_lt, t.simplified()->StringLessThan());
-    t.CheckLoweringBinop(compare_le, t.simplified()->StringLessThanOrEqual());
+    t.CheckLoweringStringBinop(compare_eq, t.simplified()->StringEqual());
+    t.CheckLoweringStringBinop(compare_lt, t.simplified()->StringLessThan());
+    t.CheckLoweringStringBinop(compare_le,
+                               t.simplified()->StringLessThanOrEqual());
   }
 
 
 void CheckChangeInsertion(IrOpcode::Value expected, MachineType from,
                           MachineType to) {
   TestingGraph t(Type::Any());
   Node* in = t.ExampleWithOutput(from);
   Node* use = t.Use(in, to);
   t.Return(use);
   t.Lower();
@@ skipping 798 matching lines @@
     Type* phi_type = Type::Union(d.arg1, d.arg2, z);
     NodeProperties::SetType(phi, phi_type);
 
     Node* use = t.Use(phi, d.use);
     t.Return(use);
     t.Lower();
 
     CHECK_EQ(d.expected, OpParameter<MachineType>(phi));
   }
 }