[turbofan]: Add better encapsulation 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"
 
@@ skipping 10 matching lines @@
 
 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, kMachAnyTagged,
-                       LinkageLocation::AnyRegister(),
+                       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,
                        "");
   }
 
-  LinkageLocation StackLocation(int loc) { return LinkageLocation(-loc); }
+  LinkageLocation StackLocation(int loc) {
+    return LinkageLocation::ForCallerFrameSlot(-loc);
+  }
 
-  LinkageLocation RegisterLocation(int loc) { return LinkageLocation(loc); }
+  LinkageLocation RegisterLocation(int loc) {
+    return LinkageLocation::ForRegister(loc);
+  }
 };
 
 
 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);
   EXPECT_TRUE(desc->CanTailCall(node));
@@ skipping 256 matching lines @@
   Node* parameters[] = {p0, p1, p2, p3, p4};
   const Operator* op = common.Call(desc2);
   Node* const node =
       Node::New(zone(), 1, op, arraysize(parameters), parameters, false);
   EXPECT_FALSE(desc1->CanTailCall(node));
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8