[turbofan] Remove bloated GraphBuilder base class.

test/cctest/compiler/graph-builder-tester.h

 // 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.
 
 #ifndef V8_CCTEST_COMPILER_GRAPH_BUILDER_TESTER_H_
 #define V8_CCTEST_COMPILER_GRAPH_BUILDER_TESTER_H_
 
 #include "src/v8.h"
 #include "test/cctest/cctest.h"
 
 #include "src/compiler/common-operator.h"
-#include "src/compiler/graph-builder.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/operator-properties.h"
 #include "src/compiler/pipeline.h"
 #include "src/compiler/simplified-operator.h"
 #include "test/cctest/compiler/call-tester.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
@@ skipping 11 matching lines @@
   Graph* main_graph_;
   CommonOperatorBuilder main_common_;
   MachineOperatorBuilder main_machine_;
   SimplifiedOperatorBuilder main_simplified_;
 };
 
 
 template <typename ReturnType>
 class GraphBuilderTester : public HandleAndZoneScope,
                            private GraphAndBuilders,
-                           public CallHelper<ReturnType>,
-                           public GraphBuilder {
+                           public CallHelper<ReturnType> {
  public:
   explicit GraphBuilderTester(MachineType p0 = kMachNone,
                               MachineType p1 = kMachNone,
                               MachineType p2 = kMachNone,
                               MachineType p3 = kMachNone,
                               MachineType p4 = kMachNone)
       : GraphAndBuilders(main_zone()),
         CallHelper<ReturnType>(
             main_isolate(),
             CSignature::New(main_zone(), MachineTypeForC<ReturnType>(), p0, p1,
                             p2, p3, p4)),
-        GraphBuilder(main_isolate(), main_graph_),
         effect_(NULL),
         return_(NULL),
         parameters_(main_zone()->template NewArray<Node*>(parameter_count())) {
     Begin(static_cast<int>(parameter_count()));
     InitParameters();
   }
   virtual ~GraphBuilderTester() {}
 
   void GenerateCode() { Generate(); }
   Node* Parameter(size_t index) {
     DCHECK(index < parameter_count());
     return parameters_[index];
   }
 
+  Isolate* isolate() { return main_isolate(); }
+  Graph* graph() const { return main_graph_; }
   Zone* zone() const { return graph()->zone(); }
-  Factory* factory() const { return isolate()->factory(); }
+  Factory* factory() { return isolate()->factory(); }
   CommonOperatorBuilder* common() { return &main_common_; }
   MachineOperatorBuilder* machine() { return &main_machine_; }
   SimplifiedOperatorBuilder* simplified() { return &main_simplified_; }
 
   // Initialize graph and builder.
   void Begin(int num_parameters) {
     DCHECK(graph()->start() == NULL);
     Node* start = graph()->NewNode(common()->Start(num_parameters + 3));
     graph()->SetStart(start);
     effect_ = start;
@@ skipping 99 matching lines @@
     return NewNode(simplified()->StoreField(access), object, value);
   }
   Node* LoadElement(const ElementAccess& access, Node* object, Node* index) {
     return NewNode(simplified()->LoadElement(access), object, index);
   }
   Node* StoreElement(const ElementAccess& access, Node* object, Node* index,
                      Node* value) {
     return NewNode(simplified()->StoreElement(access), object, index, value);
   }
 
+  Node* NewNode(const Operator* op) {
+    return MakeNode(op, 0, static_cast<Node**>(NULL));
+  }
+
+  Node* NewNode(const Operator* op, Node* n1) { return MakeNode(op, 1, &n1); }
+
+  Node* NewNode(const Operator* op, Node* n1, Node* n2) {
+    Node* buffer[] = {n1, n2};
+    return MakeNode(op, arraysize(buffer), buffer);
+  }
+
+  Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3) {
+    Node* buffer[] = {n1, n2, n3};
+    return MakeNode(op, arraysize(buffer), buffer);
+  }
+
+  Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3, Node* n4) {
+    Node* buffer[] = {n1, n2, n3, n4};
+    return MakeNode(op, arraysize(buffer), buffer);
+  }
+
+  Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3, Node* n4,
+                Node* n5) {
+    Node* buffer[] = {n1, n2, n3, n4, n5};
+    return MakeNode(op, arraysize(buffer), buffer);
+  }
+
+  Node* NewNode(const Operator* op, Node* n1, Node* n2, Node* n3, Node* n4,
+                Node* n5, Node* n6) {
+    Node* nodes[] = {n1, n2, n3, n4, n5, n6};
+    return MakeNode(op, arraysize(nodes), nodes);
+  }
+
+  Node* NewNode(const Operator* op, int value_input_count,
+                Node** value_inputs) {
+    return MakeNode(op, value_input_count, value_inputs);
+  }
+
  protected:
-  virtual Node* MakeNode(const Operator* op, int value_input_count,
-                         Node** value_inputs, bool incomplete) final {
+  Node* MakeNode(const Operator* op, int value_input_count,
+                 Node** value_inputs) {
     DCHECK(op->ValueInputCount() == value_input_count);
 
     DCHECK(!OperatorProperties::HasContextInput(op));
     DCHECK_EQ(0, OperatorProperties::GetFrameStateInputCount(op));
     bool has_control = op->ControlInputCount() == 1;
     bool has_effect = op->EffectInputCount() == 1;
 
     DCHECK(op->ControlInputCount() < 2);
     DCHECK(op->EffectInputCount() < 2);
 
     Node* result = NULL;
     if (!has_control && !has_effect) {
-      result =
-          graph()->NewNode(op, value_input_count, value_inputs, incomplete);
+      result = graph()->NewNode(op, value_input_count, value_inputs);
     } else {
       int input_count_with_deps = value_input_count;
       if (has_control) ++input_count_with_deps;
       if (has_effect) ++input_count_with_deps;
       Node** buffer = zone()->template NewArray<Node*>(input_count_with_deps);
       memcpy(buffer, value_inputs, kPointerSize * value_input_count);
       Node** current_input = buffer + value_input_count;
       if (has_effect) {
         *current_input++ = effect_;
       }
       if (has_control) {
         *current_input++ = graph()->start();
       }
-      result = graph()->NewNode(op, input_count_with_deps, buffer, incomplete);
+      result = graph()->NewNode(op, input_count_with_deps, buffer);
       if (has_effect) {
         effect_ = result;
       }
       // This graph builder does not support control flow.
       CHECK_EQ(0, op->ControlOutputCount());
     }
 
     return result;
   }
 
@@ skipping 22 matching lines @@
   Node* return_;
   Node** parameters_;
   MaybeHandle<Code> code_;
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_CCTEST_COMPILER_GRAPH_BUILDER_TESTER_H_