Removed the dependency of the test RunComputedCodeObject from RawMachineAssemblerTester.

test/cctest/compiler/test-run-machops.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.
+// 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 <cmath>
 #include <functional>
 #include <limits>
 
 #include "src/base/bits.h"
 #include "src/base/utils/random-number-generator.h"
 #include "src/codegen.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/codegen-tester.h"
+#include "test/cctest/compiler/graph-builder-tester.h"
 #include "test/cctest/compiler/value-helper.h"
 
 using namespace v8::base;
 using namespace v8::internal;
 using namespace v8::internal::compiler;
 
 typedef RawMachineAssembler::Label MLabel;
 
 TEST(RunInt32Add) {
   RawMachineAssemblerTester<int32_t> m;
@@ skipping 5475 matching lines @@
   FOR_INT32_INPUTS(i) {
     input = *i;
     CHECK_EQ(11, m.Call());
     float expected = bit_cast<float>(input);
     CHECK_EQ(bit_cast<int32_t>(expected), bit_cast<int32_t>(output));
   }
 }
 
 
 TEST(RunComputedCodeObject) {
-  RawMachineAssemblerTester<int32_t> a;
+  GraphBuilderTester<int32_t> a;
   a.Return(a.Int32Constant(33));
-  CHECK_EQ(33, a.Call());
+  a.End();
+  Handle<Code> code_a = a.GetCode();
 
-  RawMachineAssemblerTester<int32_t> b;
+  GraphBuilderTester<int32_t> b;
   b.Return(b.Int32Constant(44));
-  CHECK_EQ(44, b.Call());
+  b.End();
+  Handle<Code> code_b = b.GetCode();
 
   RawMachineAssemblerTester<int32_t> r(kMachInt32);
   RawMachineAssembler::Label tlabel;
   RawMachineAssembler::Label flabel;
   RawMachineAssembler::Label merge;
   r.Branch(r.Parameter(0), &tlabel, &flabel);
   r.Bind(&tlabel);
-  Node* fa = r.HeapConstant(a.GetCode());
+  Node* fa = r.HeapConstant(code_a);
   r.Goto(&merge);
   r.Bind(&flabel);
-  Node* fb = r.HeapConstant(b.GetCode());
+  Node* fb = r.HeapConstant(code_b);
   r.Goto(&merge);
   r.Bind(&merge);
   Node* phi = r.Phi(kMachInt32, fa, fb);
 
   // TODO(titzer): all this descriptor hackery is just to call the above
   // functions as code objects instead of direct addresses.
   CSignature0<int32_t> sig;
   CallDescriptor* c = Linkage::GetSimplifiedCDescriptor(r.zone(), &sig);
   LinkageLocation ret[] = {c->GetReturnLocation(0)};
   Signature<LinkageLocation> loc(1, 0, ret);
   CallDescriptor* desc = new (r.zone()) CallDescriptor(  // --
       CallDescriptor::kCallCodeObject,                   // kind
       kMachAnyTagged,                                    // target_type
       c->GetInputLocation(0),                            // target_loc
       &sig,                                              // machine_sig
       &loc,                                              // location_sig
       0,                                                 // stack count
       Operator::kNoProperties,                           // properties
       c->CalleeSavedRegisters(),                         // callee saved
       c->CalleeSavedFPRegisters(),                       // callee saved FP
       CallDescriptor::kNoFlags,                          // flags
       "c-call-as-code");
   Node* call = r.AddNode(r.common()->Call(desc), phi);
   r.Return(call);
 
   CHECK_EQ(33, r.Call(1));
   CHECK_EQ(44, r.Call(0));
 }