[turbofan] Remove usage of Unique<T> from graph.

test/cctest/compiler/test-run-native-calls.cc

 // Copyright 2015 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/assembler.h"
 #include "src/codegen.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/machine-type.h"
 #include "src/compiler/raw-machine-assembler.h"
 
@@ skipping 250 matching lines @@
 Handle<Code> WrapWithCFunction(Handle<Code> inner, CallDescriptor* desc) {
   Zone zone;
   MachineSignature* msig =
       const_cast<MachineSignature*>(desc->GetMachineSignature());
   int param_count = static_cast<int>(msig->parameter_count());
   GraphAndBuilders caller(&zone);
   {
     GraphAndBuilders& b = caller;
     Node* start = b.graph()->NewNode(b.common()->Start(param_count + 3));
     b.graph()->SetStart(start);
-    Unique<HeapObject> unique = Unique<HeapObject>::CreateUninitialized(inner);
-    Node* target = b.graph()->NewNode(b.common()->HeapConstant(unique));
+    Node* target = b.graph()->NewNode(b.common()->HeapConstant(inner));
 
     // Add arguments to the call.
     Node** args = zone.NewArray<Node*>(param_count + 3);
     int index = 0;
     args[index++] = target;
     for (int i = 0; i < param_count; i++) {
       args[index] = b.graph()->NewNode(b.common()->Parameter(i), start);
       index++;
     }
     args[index++] = start;  // effect.
@@ skipping 155 matching lines @@
 
     {
       // constant mode.
       Handle<Code> wrapper = Handle<Code>::null();
       {
         // Wrap the above code with a callable function that passes constants.
         Zone zone;
         Graph graph(&zone);
         CallDescriptor* cdesc = Linkage::GetSimplifiedCDescriptor(&zone, &csig);
         RawMachineAssembler raw(isolate, &graph, cdesc);
-        Unique<HeapObject> unique =
-            Unique<HeapObject>::CreateUninitialized(inner);
-        Node* target = raw.HeapConstant(unique);
+        Node* target = raw.HeapConstant(inner);
         Node** args = zone.NewArray<Node*>(num_params);
         for (int i = 0; i < num_params; i++) {
           args[i] = io.MakeConstant(raw, io.input[i]);
         }
 
         Node* call = raw.CallN(desc, target, args);
         Node* store = io.StoreOutput(raw, call);
         USE(store);
         raw.Return(raw.Int32Constant(seed));
         wrapper =
@@ skipping 12 matching lines @@
     {
       // buffer mode.
       Handle<Code> wrapper = Handle<Code>::null();
       {
         // Wrap the above code with a callable function that loads from {input}.
         Zone zone;
         Graph graph(&zone);
         CallDescriptor* cdesc = Linkage::GetSimplifiedCDescriptor(&zone, &csig);
         RawMachineAssembler raw(isolate, &graph, cdesc);
         Node* base = raw.PointerConstant(io.input);
-        Unique<HeapObject> unique =
-            Unique<HeapObject>::CreateUninitialized(inner);
-        Node* target = raw.HeapConstant(unique);
+        Node* target = raw.HeapConstant(inner);
         Node** args = zone.NewArray<Node*>(kMaxParamCount);
         for (int i = 0; i < num_params; i++) {
           args[i] = io.LoadInput(raw, base, i);
         }
 
         Node* call = raw.CallN(desc, target, args);
         Node* store = io.StoreOutput(raw, call);
         USE(store);
         raw.Return(raw.Int32Constant(seed));
         wrapper = CompileGraph("Compute-wrapper", cdesc, &graph, raw.Export());
@@ skipping 76 matching lines @@
 
   CSignature0<int32_t> csig;
   Handle<Code> wrapper = Handle<Code>::null();
   {
     // Loads parameters from the input buffer and calls the above code.
     Zone zone;
     Graph graph(&zone);
     CallDescriptor* cdesc = Linkage::GetSimplifiedCDescriptor(&zone, &csig);
     RawMachineAssembler raw(isolate, &graph, cdesc);
     Node* base = raw.PointerConstant(input);
-    Unique<HeapObject> unique = Unique<HeapObject>::CreateUninitialized(inner);
-    Node* target = raw.HeapConstant(unique);
+    Node* target = raw.HeapConstant(inner);
     Node** args = zone.NewArray<Node*>(kNumParams);
     for (int i = 0; i < kNumParams; i++) {
       Node* offset = raw.Int32Constant(i * sizeof(int32_t));
       args[i] = raw.Load(kMachInt32, base, offset);
     }
 
     Node* call = raw.CallN(desc, target, args);
     raw.Return(call);
     wrapper =
         CompileGraph("CopyTwentyInt32-wrapper", cdesc, &graph, raw.Export());
@@ skipping 352 matching lines @@
     Graph graph(&zone);
     RawMachineAssembler raw(isolate, &graph, desc);
     raw.Return(raw.Parameter(which));
     inner = CompileGraph("Select-indirection", desc, &graph, raw.Export());
     CHECK(!inner.is_null());
     CHECK(inner->IsCode());
   }
 
   {
     // Build a call to the function that does the select.
-    Unique<HeapObject> unique = Unique<HeapObject>::CreateUninitialized(inner);
-    Node* target = raw.HeapConstant(unique);
+    Node* target = raw.HeapConstant(inner);
     Node** args = raw.zone()->NewArray<Node*>(num_params);
     for (int i = 0; i < num_params; i++) {
       args[i] = raw.Parameter(i);
     }
 
     Node* call = raw.CallN(desc, target, args);
     raw.Return(call);
   }
 }
 
@@ skipping 80 matching lines @@
       char bytes[kDoubleSize];
       char output[kDoubleSize];
       int expected_size = 0;
       CSignature0<int32_t> csig;
       {
         // Wrap the select code with a callable function that passes constants.
         Zone zone;
         Graph graph(&zone);
         CallDescriptor* cdesc = Linkage::GetSimplifiedCDescriptor(&zone, &csig);
         RawMachineAssembler raw(isolate, &graph, cdesc);
-        Unique<HeapObject> unique =
-            Unique<HeapObject>::CreateUninitialized(select);
-        Node* target = raw.HeapConstant(unique);
+        Node* target = raw.HeapConstant(select);
         Node** args = zone.NewArray<Node*>(num_params);
         int64_t constant = 0x0102030405060708;
         for (int i = 0; i < num_params; i++) {
           MachineType param_type = sig->GetParam(i);
           Node* konst = nullptr;
           if (param_type == kMachInt32) {
             int32_t value[] = {static_cast<int32_t>(constant)};
             konst = raw.Int32Constant(value[0]);
             if (i == which) memcpy(bytes, value, expected_size = 4);
           }
@@ skipping 34 matching lines @@
       }
     }
   }
 }
 
 
 TEST(MixedParams_0) { MixedParamTest(0); }
 TEST(MixedParams_1) { MixedParamTest(1); }
 TEST(MixedParams_2) { MixedParamTest(2); }
 TEST(MixedParams_3) { MixedParamTest(3); }