Fix bugs in simplified lowering relating to int32/uint32 signs.

test/cctest/compiler/test-scheduler.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/access-builder.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/generic-node-inl.h"
 #include "src/compiler/generic-node.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/graph-visualizer.h"
 #include "src/compiler/js-operator.h"
-#include "src/compiler/machine-operator.h"
 #include "src/compiler/node.h"
+#include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/compiler/schedule.h"
 #include "src/compiler/scheduler.h"
 #include "src/compiler/simplified-operator.h"
 #include "src/compiler/verifier.h"
+#include "test/cctest/cctest.h"
 
 using namespace v8::internal;
 using namespace v8::internal::compiler;
 
+Operator kIntAdd(IrOpcode::kInt32Add, Operator::kPure, "Int32Add", 2, 0, 0, 1,
+                 0, 0);
+
 // TODO(titzer): pull RPO tests out to their own file.
 static void CheckRPONumbers(BasicBlockVector* order, size_t expected,
                             bool loops_allowed) {
   CHECK(expected == order->size());
   for (int i = 0; i < static_cast<int>(order->size()); i++) {
     CHECK(order->at(i)->rpo_number() == i);
     if (!loops_allowed) {
       CHECK_EQ(NULL, order->at(i)->loop_end());
       CHECK_EQ(NULL, order->at(i)->loop_header());
     }
@@ skipping 1528 matching lines @@
   ComputeAndVerifySchedule(62, &graph);
 }
 
 
 TEST(BuildScheduleSimpleLoopWithCodeMotion) {
   HandleAndZoneScope scope;
   Isolate* isolate = scope.main_isolate();
   Graph graph(scope.main_zone());
   CommonOperatorBuilder common_builder(scope.main_zone());
   JSOperatorBuilder js_builder(scope.main_zone());
-  MachineOperatorBuilder machine_builder;
   const Operator* op;
 
   Handle<HeapObject> object =
       Handle<HeapObject>(isolate->heap()->undefined_value(), isolate);
   Unique<HeapObject> unique_constant =
       Unique<HeapObject>::CreateUninitialized(object);
 
   // Manually transcripted code for:
   // function turbo_fan_test(a, b, c) {
   //   while (a < b) {
@@ skipping 15 matching lines @@
   Node* n9 = graph.NewNode(op, nil, nil, nil);
   USE(n9);
   op = common_builder.Parameter(0);
   Node* n2 = graph.NewNode(op, n0);
   USE(n2);
   n9->ReplaceInput(0, n2);
   op = js_builder.Add();
   Node* n20 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n20);
   n20->ReplaceInput(0, n9);
-  op = machine_builder.Int32Add();
+  op = &kIntAdd;
   Node* n19 = graph.NewNode(op, nil, nil);
   USE(n19);
   op = common_builder.Phi(kMachAnyTagged, 2);
   Node* n10 = graph.NewNode(op, nil, nil, nil);
   USE(n10);
   op = common_builder.Parameter(0);
   Node* n3 = graph.NewNode(op, n0);
   USE(n3);
   n10->ReplaceInput(0, n3);
   n10->ReplaceInput(1, n10);
@@ skipping 103 matching lines @@
   graph.SetEnd(end);
 
   ComputeAndVerifySchedule(13, &graph);
 }
 
 
 TEST(FloatingDiamond2) {
   HandleAndZoneScope scope;
   Graph graph(scope.main_zone());
   CommonOperatorBuilder common(scope.main_zone());
-  MachineOperatorBuilder machine;
 
   Node* start = graph.NewNode(common.Start(2));
   graph.SetStart(start);
 
   Node* p0 = graph.NewNode(common.Parameter(0), start);
   Node* p1 = graph.NewNode(common.Parameter(1), start);
   Node* d1 = CreateDiamond(&graph, &common, p0);
   Node* d2 = CreateDiamond(&graph, &common, p1);
-  Node* add = graph.NewNode(machine.Int32Add(), d1, d2);
+  Node* add = graph.NewNode(&kIntAdd, d1, d2);
   Node* ret = graph.NewNode(common.Return(), add, start, start);
   Node* end = graph.NewNode(common.End(), ret, start);
 
   graph.SetEnd(end);
 
   ComputeAndVerifySchedule(24, &graph);
 }
 
 
 TEST(FloatingDiamond3) {
   HandleAndZoneScope scope;
   Graph graph(scope.main_zone());
   CommonOperatorBuilder common(scope.main_zone());
-  MachineOperatorBuilder machine;
 
   Node* start = graph.NewNode(common.Start(2));
   graph.SetStart(start);
 
   Node* p0 = graph.NewNode(common.Parameter(0), start);
   Node* p1 = graph.NewNode(common.Parameter(1), start);
   Node* d1 = CreateDiamond(&graph, &common, p0);
   Node* d2 = CreateDiamond(&graph, &common, p1);
-  Node* add = graph.NewNode(machine.Int32Add(), d1, d2);
+  Node* add = graph.NewNode(&kIntAdd, d1, d2);
   Node* d3 = CreateDiamond(&graph, &common, add);
   Node* ret = graph.NewNode(common.Return(), d3, start, start);
   Node* end = graph.NewNode(common.End(), ret, start);
 
   graph.SetEnd(end);
 
   ComputeAndVerifySchedule(33, &graph);
 }
 
 
 TEST(NestedFloatingDiamonds) {
   HandleAndZoneScope scope;
   Graph graph(scope.main_zone());
   CommonOperatorBuilder common(scope.main_zone());
   SimplifiedOperatorBuilder simplified(scope.main_zone());
-  MachineOperatorBuilder machine;
 
   Node* start = graph.NewNode(common.Start(2));
   graph.SetStart(start);
 
   Node* p0 = graph.NewNode(common.Parameter(0), start);
 
   Node* fv = graph.NewNode(common.Int32Constant(7));
   Node* br = graph.NewNode(common.Branch(), p0, graph.start());
   Node* t = graph.NewNode(common.IfTrue(), br);
   Node* f = graph.NewNode(common.IfFalse(), br);
@@ skipping 21 matching lines @@
 
   ComputeAndVerifySchedule(23, &graph);
 }
 
 
 TEST(NestedFloatingDiamondWithLoop) {
   HandleAndZoneScope scope;
   Graph graph(scope.main_zone());
   CommonOperatorBuilder common(scope.main_zone());
   SimplifiedOperatorBuilder simplified(scope.main_zone());
-  MachineOperatorBuilder machine;
 
   Node* start = graph.NewNode(common.Start(2));
   graph.SetStart(start);
 
   Node* p0 = graph.NewNode(common.Parameter(0), start);
 
   Node* fv = graph.NewNode(common.Int32Constant(7));
   Node* br = graph.NewNode(common.Branch(), p0, graph.start());
   Node* t = graph.NewNode(common.IfTrue(), br);
   Node* f = graph.NewNode(common.IfFalse(), br);
 
   Node* loop = graph.NewNode(common.Loop(2), f, start);
   Node* ind = graph.NewNode(common.Phi(kMachAnyTagged, 2), p0, p0, loop);
 
   // TODO(mstarzinger): Make scheduler deal with non-empty loops here.
-  // Node* add = graph.NewNode(machine.IntAdd(), ind, fv);
+  // Node* add = graph.NewNode(&kIntAdd, ind, fv);
 
   Node* br1 = graph.NewNode(common.Branch(), ind, loop);
   Node* t1 = graph.NewNode(common.IfTrue(), br1);
   Node* f1 = graph.NewNode(common.IfFalse(), br1);
 
   loop->ReplaceInput(1, t1);  // close loop.
   ind->ReplaceInput(1, ind);  // close induction variable.
 
   Node* m = graph.NewNode(common.Merge(2), t, f1);
   Node* phi = graph.NewNode(common.Phi(kMachAnyTagged, 2), fv, ind, m);
 
   Node* ret = graph.NewNode(common.Return(), phi, start, start);
   Node* end = graph.NewNode(common.End(), ret, start);
 
   graph.SetEnd(end);
 
   ComputeAndVerifySchedule(19, &graph);
 }
 
 
 TEST(LoopedFloatingDiamond1) {
   HandleAndZoneScope scope;
   Graph graph(scope.main_zone());
   CommonOperatorBuilder common(scope.main_zone());
   SimplifiedOperatorBuilder simplified(scope.main_zone());
-  MachineOperatorBuilder machine;
 
   Node* start = graph.NewNode(common.Start(2));
   graph.SetStart(start);
 
   Node* p0 = graph.NewNode(common.Parameter(0), start);
 
   Node* c = graph.NewNode(common.Int32Constant(7));
   Node* loop = graph.NewNode(common.Loop(2), start, start);
   Node* ind = graph.NewNode(common.Phi(kMachAnyTagged, 2), p0, p0, loop);
-  Node* add = graph.NewNode(machine.IntAdd(), ind, c);
+  Node* add = graph.NewNode(&kIntAdd, ind, c);
 
   Node* br = graph.NewNode(common.Branch(), add, loop);
   Node* t = graph.NewNode(common.IfTrue(), br);
   Node* f = graph.NewNode(common.IfFalse(), br);
 
   Node* br1 = graph.NewNode(common.Branch(), p0, graph.start());
   Node* t1 = graph.NewNode(common.IfTrue(), br1);
   Node* f1 = graph.NewNode(common.IfFalse(), br1);
   Node* m1 = graph.NewNode(common.Merge(2), t1, f1);
   Node* phi1 = graph.NewNode(common.Phi(kMachAnyTagged, 2), add, p0, m1);
 
   loop->ReplaceInput(1, t);    // close loop.
   ind->ReplaceInput(1, phi1);  // close induction variable.
 
   Node* ret = graph.NewNode(common.Return(), ind, start, f);
   Node* end = graph.NewNode(common.End(), ret, f);
 
   graph.SetEnd(end);
 
   ComputeAndVerifySchedule(20, &graph);
 }
 
 
 TEST(LoopedFloatingDiamond2) {
   HandleAndZoneScope scope;
   Graph graph(scope.main_zone());
   CommonOperatorBuilder common(scope.main_zone());
   SimplifiedOperatorBuilder simplified(scope.main_zone());
-  MachineOperatorBuilder machine;
 
   Node* start = graph.NewNode(common.Start(2));
   graph.SetStart(start);
 
   Node* p0 = graph.NewNode(common.Parameter(0), start);
 
   Node* c = graph.NewNode(common.Int32Constant(7));
   Node* loop = graph.NewNode(common.Loop(2), start, start);
   Node* ind = graph.NewNode(common.Phi(kMachAnyTagged, 2), p0, p0, loop);
 
   Node* br1 = graph.NewNode(common.Branch(), p0, graph.start());
   Node* t1 = graph.NewNode(common.IfTrue(), br1);
   Node* f1 = graph.NewNode(common.IfFalse(), br1);
   Node* m1 = graph.NewNode(common.Merge(2), t1, f1);
   Node* phi1 = graph.NewNode(common.Phi(kMachAnyTagged, 2), c, ind, m1);
 
-  Node* add = graph.NewNode(machine.IntAdd(), ind, phi1);
+  Node* add = graph.NewNode(&kIntAdd, ind, phi1);
 
   Node* br = graph.NewNode(common.Branch(), add, loop);
   Node* t = graph.NewNode(common.IfTrue(), br);
   Node* f = graph.NewNode(common.IfFalse(), br);
 
   loop->ReplaceInput(1, t);   // close loop.
   ind->ReplaceInput(1, add);  // close induction variable.
 
   Node* ret = graph.NewNode(common.Return(), ind, start, f);
   Node* end = graph.NewNode(common.End(), ret, f);
 
   graph.SetEnd(end);
 
   ComputeAndVerifySchedule(20, &graph);
 }
 
 
 TEST(PhisPushedDownToDifferentBranches) {
   HandleAndZoneScope scope;
   Graph graph(scope.main_zone());
   CommonOperatorBuilder common(scope.main_zone());
   SimplifiedOperatorBuilder simplified(scope.main_zone());
-  MachineOperatorBuilder machine;
 
   Node* start = graph.NewNode(common.Start(2));
   graph.SetStart(start);
 
   Node* p0 = graph.NewNode(common.Parameter(0), start);
   Node* p1 = graph.NewNode(common.Parameter(1), start);
 
   Node* v1 = graph.NewNode(common.Int32Constant(1));
   Node* v2 = graph.NewNode(common.Int32Constant(2));
   Node* v3 = graph.NewNode(common.Int32Constant(3));
@@ skipping 96 matching lines @@
   graph.SetEnd(end);
 
   Schedule* schedule = ComputeAndVerifySchedule(6, &graph);
   BasicBlock* block = schedule->block(loop);
   CHECK_NE(NULL, loop);
   CHECK_EQ(block, schedule->block(effect));
   CHECK_GE(block->rpo_number(), 0);
 }
 
 #endif