[turbofan]: Add better encapsulation to LinkageLocation

src/compiler/linkage.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/code-stubs.h"
 #include "src/compiler.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/node.h"
 #include "src/compiler/pipeline.h"
@@ skipping 38 matching lines @@
     if (GetReturnLocation(i) != other->GetReturnLocation(i)) return false;
   }
   return true;
 }
 
 
 bool CallDescriptor::CanTailCall(const Node* node) const {
   // Determine the number of stack parameters passed in
   size_t stack_params = 0;
   for (size_t i = 0; i < InputCount(); ++i) {
-    if (!GetInputLocation(i).is_register()) {
+    if (!GetInputLocation(i).IsRegister()) {
       ++stack_params;
     }
   }
   // Ensure the input linkage contains the stack parameters in the right order
   size_t current_stack_param = 0;
   for (size_t i = 0; i < InputCount(); ++i) {
-    if (!GetInputLocation(i).is_register()) {
-      if (GetInputLocation(i) !=
-          LinkageLocation(static_cast<int>(current_stack_param) -
-                          static_cast<int>(stack_params))) {
+    if (!GetInputLocation(i).IsRegister()) {
+      if (GetInputLocation(i) != LinkageLocation::ForCallerFrameSlot(
+                                     static_cast<int>(current_stack_param) -
+                                     static_cast<int>(stack_params))) {
         return false;
       }
       ++current_stack_param;
     }
   }
   // Tail calling is currently allowed if return locations match and all
   // parameters are either in registers or on the stack but match exactly in
   // number and content.
   CallDescriptor const* other = OpParameter<CallDescriptor const*>(node);
   if (!HasSameReturnLocationsAs(other)) return false;
   size_t current_input = 0;
   size_t other_input = 0;
   while (true) {
     if (other_input >= other->InputCount()) {
       while (current_input < InputCount()) {
-        if (!GetInputLocation(current_input).is_register()) {
+        if (!GetInputLocation(current_input).IsRegister()) {
           return false;
         }
         ++current_input;
       }
       return true;
     }
     if (current_input >= InputCount()) {
       while (other_input < other->InputCount()) {
-        if (!other->GetInputLocation(other_input).is_register()) {
+        if (!other->GetInputLocation(other_input).IsRegister()) {
           return false;
         }
         ++other_input;
       }
       return true;
     }
-    if (GetInputLocation(current_input).is_register()) {
+    if (GetInputLocation(current_input).IsRegister()) {
       ++current_input;
       continue;
     }
-    if (other->GetInputLocation(other_input).is_register()) {
+    if (other->GetInputLocation(other_input).IsRegister()) {
       ++other_input;
       continue;
     }
     if (GetInputLocation(current_input) !=
         other->GetInputLocation(other_input)) {
       return false;
     }
     Node* input = node->InputAt(static_cast<int>(other_input));
     if (input->opcode() != IrOpcode::kParameter) {
       return false;
@@ skipping 115 matching lines @@
   // without a FrameState or will be lowered by JSIntrinsicLowering internally.
   const Runtime::Function* const f = Runtime::FunctionForId(function);
   if (f->intrinsic_type == Runtime::IntrinsicType::INLINE) return 0;
 
   return 1;
 }
 
 
 bool CallDescriptor::UsesOnlyRegisters() const {
   for (size_t i = 0; i < InputCount(); ++i) {
-    if (!GetInputLocation(i).is_register()) return false;
+    if (!GetInputLocation(i).IsRegister()) return false;
   }
   for (size_t i = 0; i < ReturnCount(); ++i) {
-    if (!GetReturnLocation(i).is_register()) return false;
+    if (!GetReturnLocation(i).IsRegister()) return false;
   }
   return true;
 }
 
 
 //==============================================================================
 // Provide unimplemented methods on unsupported architectures, to at least link.
 //==============================================================================
 #if !V8_TURBOFAN_BACKEND
 CallDescriptor* Linkage::GetJSCallDescriptor(Zone* zone, bool is_osr,
@@ skipping 24 matching lines @@
     Operator::Properties properties, MachineType return_type) {
   UNIMPLEMENTED();
   return NULL;
 }
 
 
 #endif  // !V8_TURBOFAN_BACKEND
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8