Convert Linkage to use MachineSignature.

src/compiler/instruction-selector-unittest.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_COMPILER_INSTRUCTION_SELECTOR_UNITTEST_H_
 #define V8_COMPILER_INSTRUCTION_SELECTOR_UNITTEST_H_
 
 #include <deque>
 #include <set>
 
@@ skipping 18 matching lines @@
   enum StreamBuilderMode {
     kAllInstructions,
     kTargetInstructions,
     kAllExceptNopInstructions
   };
 
   class StreamBuilder V8_FINAL : public RawMachineAssembler {
    public:
     StreamBuilder(InstructionSelectorTest* test, MachineType return_type)
         : RawMachineAssembler(new (test->zone()) Graph(test->zone()),
-                              CallDescriptorBuilder(test->zone(), return_type)),
+                              MakeMachineSignature(test->zone(), return_type)),
           test_(test) {}
     StreamBuilder(InstructionSelectorTest* test, MachineType return_type,
                   MachineType parameter0_type)
-        : RawMachineAssembler(new (test->zone()) Graph(test->zone()),
-                              CallDescriptorBuilder(test->zone(), return_type,
-                                                    parameter0_type)),
+        : RawMachineAssembler(
+              new (test->zone()) Graph(test->zone()),
+              MakeMachineSignature(test->zone(), return_type, parameter0_type)),
           test_(test) {}
     StreamBuilder(InstructionSelectorTest* test, MachineType return_type,
                   MachineType parameter0_type, MachineType parameter1_type)
         : RawMachineAssembler(
               new (test->zone()) Graph(test->zone()),
-              CallDescriptorBuilder(test->zone(), return_type, parameter0_type,
-                                    parameter1_type)),
+              MakeMachineSignature(test->zone(), return_type, parameter0_type,
+                                   parameter1_type)),
           test_(test) {}
     StreamBuilder(InstructionSelectorTest* test, MachineType return_type,
                   MachineType parameter0_type, MachineType parameter1_type,
                   MachineType parameter2_type)
         : RawMachineAssembler(
               new (test->zone()) Graph(test->zone()),
-              CallDescriptorBuilder(test->zone(), return_type, parameter0_type,
-                                    parameter1_type, parameter2_type)),
+              MakeMachineSignature(test->zone(), return_type, parameter0_type,
+                                   parameter1_type, parameter2_type)),
           test_(test) {}
 
     Stream Build(CpuFeature feature) {
       return Build(InstructionSelector::Features(feature));
     }
     Stream Build(CpuFeature feature1, CpuFeature feature2) {
       return Build(InstructionSelector::Features(feature1, feature2));
     }
     Stream Build(StreamBuilderMode mode = kTargetInstructions) {
       return Build(InstructionSelector::Features(), mode);
     }
     Stream Build(InstructionSelector::Features features,
                  StreamBuilderMode mode = kTargetInstructions);
 
    private:
-    MachineCallDescriptorBuilder* CallDescriptorBuilder(
-        Zone* zone, MachineType return_type) {
-      return new (zone) MachineCallDescriptorBuilder(return_type, 0, NULL);
+    MachineSignature* MakeMachineSignature(Zone* zone,
+                                           MachineType return_type) {
+      MachineSignature::Builder builder(zone, 1, 0);
+      builder.AddReturn(return_type);
+      return builder.Build();
     }
 
-    MachineCallDescriptorBuilder* CallDescriptorBuilder(
-        Zone* zone, MachineType return_type, MachineType parameter0_type) {
-      MachineType* parameter_types = zone->NewArray<MachineType>(1);
-      parameter_types[0] = parameter0_type;
-      return new (zone)
-          MachineCallDescriptorBuilder(return_type, 1, parameter_types);
+    MachineSignature* MakeMachineSignature(Zone* zone, MachineType return_type,
+                                           MachineType parameter0_type) {
+      MachineSignature::Builder builder(zone, 1, 1);
+      builder.AddReturn(return_type);
+      builder.AddParam(parameter0_type);
+      return builder.Build();
     }
 
-    MachineCallDescriptorBuilder* CallDescriptorBuilder(
-        Zone* zone, MachineType return_type, MachineType parameter0_type,
-        MachineType parameter1_type) {
-      MachineType* parameter_types = zone->NewArray<MachineType>(2);
-      parameter_types[0] = parameter0_type;
-      parameter_types[1] = parameter1_type;
-      return new (zone)
-          MachineCallDescriptorBuilder(return_type, 2, parameter_types);
+    MachineSignature* MakeMachineSignature(Zone* zone, MachineType return_type,
+                                           MachineType parameter0_type,
+                                           MachineType parameter1_type) {
+      MachineSignature::Builder builder(zone, 1, 2);
+      builder.AddReturn(return_type);
+      builder.AddParam(parameter0_type);
+      builder.AddParam(parameter1_type);
+      return builder.Build();
     }
 
-    MachineCallDescriptorBuilder* CallDescriptorBuilder(
-        Zone* zone, MachineType return_type, MachineType parameter0_type,
-        MachineType parameter1_type, MachineType parameter2_type) {
-      MachineType* parameter_types = zone->NewArray<MachineType>(3);
-      parameter_types[0] = parameter0_type;
-      parameter_types[1] = parameter1_type;
-      parameter_types[2] = parameter2_type;
-      return new (zone)
-          MachineCallDescriptorBuilder(return_type, 3, parameter_types);
+    MachineSignature* MakeMachineSignature(Zone* zone, MachineType return_type,
+                                           MachineType parameter0_type,
+                                           MachineType parameter1_type,
+                                           MachineType parameter2_type) {
+      MachineSignature::Builder builder(zone, 1, 3);
+      builder.AddReturn(return_type);
+      builder.AddParam(parameter0_type);
+      builder.AddParam(parameter1_type);
+      builder.AddParam(parameter2_type);
+      return builder.Build();
     }
 
    private:
     InstructionSelectorTest* test_;
   };
 
   class Stream V8_FINAL {
    public:
     size_t size() const { return instructions_.size(); }
     const Instruction* operator[](size_t index) const {
@@ skipping 75 matching lines @@
 template <typename T>
 class InstructionSelectorTestWithParam
     : public InstructionSelectorTest,
       public ::testing::WithParamInterface<T> {};
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INSTRUCTION_SELECTOR_UNITTEST_H_