[turbofan] Add MachineType to LinkageLocation

test/unittests/compiler/linkage-tail-call-unittest.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/compiler/common-operator.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/node.h"
 #include "test/unittests/test-utils.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 namespace {
 
 MachineType kMachineTypes[] = {
     MachineType::AnyTagged(), MachineType::AnyTagged(),
     MachineType::AnyTagged(), MachineType::AnyTagged(),
     MachineType::AnyTagged(), MachineType::AnyTagged(),
     MachineType::AnyTagged(), MachineType::AnyTagged()};
 }
 
 class LinkageTailCall : public TestWithZone {
  protected:
   CallDescriptor* NewStandardCallDescriptor(LocationSignature* locations) {
     DCHECK(arraysize(kMachineTypes) >=
            locations->return_count() + locations->parameter_count());
-    MachineSignature* types = new (zone()) MachineSignature(
-        locations->return_count(), locations->parameter_count(), kMachineTypes);
-    return new (zone()) CallDescriptor(CallDescriptor::kCallCodeObject,
-                                       MachineType::AnyTagged(),
-                                       LinkageLocation::ForAnyRegister(),
-                                       types,      // machine_sig
-                                       locations,  // location_sig
-                                       0,          // js_parameter_count
-                                       Operator::kNoProperties,  // properties
-                                       0,                        // callee-saved
-                                       0,  // callee-saved fp
-                                       CallDescriptor::kNoFlags,  // flags,
-                                       "");
+    return new (zone()) CallDescriptor(
+        CallDescriptor::kCallCodeObject, MachineType::AnyTagged(),
+        LinkageLocation::ForAnyRegister(MachineType::Pointer()),
+        locations,                 // location_sig
+        0,                         // js_parameter_count
+        Operator::kNoProperties,   // properties
+        0,                         // callee-saved
+        0,                         // callee-saved fp
+        CallDescriptor::kNoFlags,  // flags,
+        "");
   }
 
   LinkageLocation StackLocation(int loc) {
-    return LinkageLocation::ForCallerFrameSlot(-loc);
+    return LinkageLocation::ForCallerFrameSlot(-loc, MachineType::Pointer());
   }
 
   LinkageLocation RegisterLocation(int loc) {
-    return LinkageLocation::ForRegister(loc);
+    return LinkageLocation::ForRegister(loc, MachineType::Pointer());
   }
 };
 
 
 TEST_F(LinkageTailCall, EmptyToEmpty) {
   LocationSignature locations(0, 0, nullptr);
   CallDescriptor* desc = NewStandardCallDescriptor(&locations);
   CommonOperatorBuilder common(zone());
   const Operator* op = common.Call(desc);
   Node* const node = Node::New(zone(), 1, op, 0, nullptr, false);
@@ skipping 283 matching lines @@
   Node* const node =
       Node::New(zone(), 1, op, arraysize(parameters), parameters, false);
   int stack_param_delta = 0;
   EXPECT_TRUE(desc1->CanTailCall(node, &stack_param_delta));
   EXPECT_EQ(1, stack_param_delta);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8