[turbofan] Add MachineType 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/ast/scopes.h"
 #include "src/code-stubs.h"
 #include "src/compiler.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/frame.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/node.h"
 #include "src/compiler/osr.h"
 #include "src/compiler/pipeline.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 namespace {
-LinkageLocation regloc(Register reg) {
-  return LinkageLocation::ForRegister(reg.code());
+
+LinkageLocation regloc(Register reg, MachineType type) {
+  return LinkageLocation::ForRegister(reg.code(), type);
 }
 
-
 MachineType reptyp(Representation representation) {
   switch (representation.kind()) {
     case Representation::kInteger8:
       return MachineType::Int8();
     case Representation::kUInteger8:
       return MachineType::Uint8();
     case Representation::kInteger16:
       return MachineType::Int16();
     case Representation::kUInteger16:
       return MachineType::Uint16();
     case Representation::kInteger32:
       return MachineType::Int32();
     case Representation::kSmi:
     case Representation::kTagged:
     case Representation::kHeapObject:
       return MachineType::AnyTagged();
     case Representation::kDouble:
       return MachineType::Float64();
     case Representation::kExternal:
       return MachineType::Pointer();
     case Representation::kNone:
     case Representation::kNumRepresentations:
       break;
   }
   UNREACHABLE();
   return MachineType::None();
 }
+
 }  // namespace
 
 
 std::ostream& operator<<(std::ostream& os, const CallDescriptor::Kind& k) {
   switch (k) {
     case CallDescriptor::kCallCodeObject:
       os << "Code";
       break;
     case CallDescriptor::kCallJSFunction:
       os << "JS";
       break;
     case CallDescriptor::kCallAddress:
       os << "Addr";
       break;
   }
   return os;
 }
 
 
 std::ostream& operator<<(std::ostream& os, const CallDescriptor& d) {
   // TODO(svenpanne) Output properties etc. and be less cryptic.
   return os << d.kind() << ":" << d.debug_name() << ":r" << d.ReturnCount()
             << "s" << d.StackParameterCount() << "i" << d.InputCount() << "f"
             << d.FrameStateCount() << "t" << d.SupportsTailCalls();
 }
 
+MachineSignature* CallDescriptor::GetMachineSignature(Zone* zone) const {
+  size_t param_count = ParameterCount();
+  size_t return_count = ReturnCount();
+  MachineType* types = reinterpret_cast<MachineType*>(
+      zone->New(sizeof(MachineType*) * (param_count + return_count)));
+  int current = 0;
+  for (size_t i = 0; i < return_count; ++i) {
+    types[current++] = GetReturnType(i);
+  }
+  for (size_t i = 0; i < param_count; ++i) {
+    types[current++] = GetParameterType(i);
+  }
+  return new (zone) MachineSignature(return_count, param_count, types);
+}
 
 bool CallDescriptor::HasSameReturnLocationsAs(
     const CallDescriptor* other) const {
   if (ReturnCount() != other->ReturnCount()) return false;
   for (size_t i = 0; i < ReturnCount(); ++i) {
     if (GetReturnLocation(i) != other->GetReturnLocation(i)) return false;
   }
   return true;
 }
 
@@ skipping 124 matching lines @@
   const size_t num_args_count = 1;
   const size_t context_count = 1;
   const size_t parameter_count = function_count +
                                  static_cast<size_t>(js_parameter_count) +
                                  num_args_count + context_count;
 
   const Runtime::Function* function = Runtime::FunctionForId(function_id);
   const size_t return_count = static_cast<size_t>(function->result_size);
 
   LocationSignature::Builder locations(zone, return_count, parameter_count);
-  MachineSignature::Builder types(zone, return_count, parameter_count);
 
   // Add returns.
   if (locations.return_count_ > 0) {
-    locations.AddReturn(regloc(kReturnRegister0));
+    locations.AddReturn(regloc(kReturnRegister0, MachineType::AnyTagged()));
   }
   if (locations.return_count_ > 1) {
-    locations.AddReturn(regloc(kReturnRegister1));
+    locations.AddReturn(regloc(kReturnRegister1, MachineType::AnyTagged()));
   }
   if (locations.return_count_ > 2) {
-    locations.AddReturn(regloc(kReturnRegister2));
-  }
-  for (size_t i = 0; i < return_count; i++) {
-    types.AddReturn(MachineType::AnyTagged());
+    locations.AddReturn(regloc(kReturnRegister2, MachineType::AnyTagged()));
   }
 
   // All parameters to the runtime call go on the stack.
   for (int i = 0; i < js_parameter_count; i++) {
-    locations.AddParam(
-        LinkageLocation::ForCallerFrameSlot(i - js_parameter_count));
-    types.AddParam(MachineType::AnyTagged());
+    locations.AddParam(LinkageLocation::ForCallerFrameSlot(
+        i - js_parameter_count, MachineType::AnyTagged()));
   }
   // Add runtime function itself.
-  locations.AddParam(regloc(kRuntimeCallFunctionRegister));
-  types.AddParam(MachineType::AnyTagged());
+  locations.AddParam(
+      regloc(kRuntimeCallFunctionRegister, MachineType::AnyTagged()));
 
   // Add runtime call argument count.
-  locations.AddParam(regloc(kRuntimeCallArgCountRegister));
-  types.AddParam(MachineType::Pointer());
+  locations.AddParam(
+      regloc(kRuntimeCallArgCountRegister, MachineType::AnyTagged()));
 
   // Add context.
-  locations.AddParam(regloc(kContextRegister));
-  types.AddParam(MachineType::AnyTagged());
+  locations.AddParam(regloc(kContextRegister, MachineType::AnyTagged()));
 
   if (!Linkage::NeedsFrameStateInput(function_id)) {
     flags = static_cast<CallDescriptor::Flags>(
         flags & ~CallDescriptor::kNeedsFrameState);
   }
 
   // The target for runtime calls is a code object.
   MachineType target_type = MachineType::AnyTagged();
-  LinkageLocation target_loc = LinkageLocation::ForAnyRegister();
+  LinkageLocation target_loc =
+      LinkageLocation::ForAnyRegister(MachineType::AnyTagged());
   return new (zone) CallDescriptor(     // --
       CallDescriptor::kCallCodeObject,  // kind
       target_type,                      // target MachineType
       target_loc,                       // target location
-      types.Build(),                    // machine_sig
       locations.Build(),                // location_sig
       js_parameter_count,               // stack_parameter_count
       properties,                       // properties
       kNoCalleeSaved,                   // callee-saved
       kNoCalleeSaved,                   // callee-saved fp
       flags,                            // flags
       function->name);                  // debug name
 }
 
 
 CallDescriptor* Linkage::GetJSCallDescriptor(Zone* zone, bool is_osr,
                                              int js_parameter_count,
                                              CallDescriptor::Flags flags) {
   const size_t return_count = 1;
   const size_t context_count = 1;
   const size_t new_target_count = 1;
   const size_t num_args_count = 1;
   const size_t parameter_count =
       js_parameter_count + new_target_count + num_args_count + context_count;
 
   LocationSignature::Builder locations(zone, return_count, parameter_count);
-  MachineSignature::Builder types(zone, return_count, parameter_count);
 
   // All JS calls have exactly one return value.
-  locations.AddReturn(regloc(kReturnRegister0));
-  types.AddReturn(MachineType::AnyTagged());
+  locations.AddReturn(regloc(kReturnRegister0, MachineType::AnyTagged()));
 
   // All parameters to JS calls go on the stack.
   for (int i = 0; i < js_parameter_count; i++) {
     int spill_slot_index = i - js_parameter_count;
-    locations.AddParam(LinkageLocation::ForCallerFrameSlot(spill_slot_index));
-    types.AddParam(MachineType::AnyTagged());
+    locations.AddParam(LinkageLocation::ForCallerFrameSlot(
+        spill_slot_index, MachineType::AnyTagged()));
   }
 
   // Add JavaScript call new target value.
-  locations.AddParam(regloc(kJavaScriptCallNewTargetRegister));
-  types.AddParam(MachineType::AnyTagged());
+  locations.AddParam(
+      regloc(kJavaScriptCallNewTargetRegister, MachineType::AnyTagged()));
 
   // Add JavaScript call argument count.
-  locations.AddParam(regloc(kJavaScriptCallArgCountRegister));
-  types.AddParam(MachineType::Int32());
+  locations.AddParam(
+      regloc(kJavaScriptCallArgCountRegister, MachineType::Int32()));
 
   // Add context.
-  locations.AddParam(regloc(kContextRegister));
-  types.AddParam(MachineType::AnyTagged());
+  locations.AddParam(regloc(kContextRegister, MachineType::AnyTagged()));
 
   // The target for JS function calls is the JSFunction object.
   MachineType target_type = MachineType::AnyTagged();
   // When entering into an OSR function from unoptimized code the JSFunction
   // is not in a register, but it is on the stack in the marker spill slot.
-  LinkageLocation target_loc = is_osr
-                                   ? LinkageLocation::ForSavedCallerFunction()
-                                   : regloc(kJSFunctionRegister);
+  LinkageLocation target_loc =
+      is_osr ? LinkageLocation::ForSavedCallerFunction()
+             : regloc(kJSFunctionRegister, MachineType::AnyTagged());
   return new (zone) CallDescriptor(     // --
       CallDescriptor::kCallJSFunction,  // kind
       target_type,                      // target MachineType
       target_loc,                       // target location
-      types.Build(),                    // machine_sig
       locations.Build(),                // location_sig
       js_parameter_count,               // stack_parameter_count
       Operator::kNoProperties,          // properties
       kNoCalleeSaved,                   // callee-saved
       kNoCalleeSaved,                   // callee-saved fp
       CallDescriptor::kCanUseRoots |    // flags
           flags,                        // flags
       "js-call");
 }
 
 // TODO(all): Add support for return representations/locations to
 // CallInterfaceDescriptor.
 // TODO(turbofan): cache call descriptors for code stub calls.
 CallDescriptor* Linkage::GetStubCallDescriptor(
     Isolate* isolate, Zone* zone, const CallInterfaceDescriptor& descriptor,
     int stack_parameter_count, CallDescriptor::Flags flags,
     Operator::Properties properties, MachineType return_type,
     size_t return_count) {
   const int register_parameter_count = descriptor.GetRegisterParameterCount();
   const int js_parameter_count =
       register_parameter_count + stack_parameter_count;
   const int context_count = 1;
   const size_t parameter_count =
       static_cast<size_t>(js_parameter_count + context_count);
 
   LocationSignature::Builder locations(zone, return_count, parameter_count);
-  MachineSignature::Builder types(zone, return_count, parameter_count);
 
   // Add returns.
   if (locations.return_count_ > 0) {
-    locations.AddReturn(regloc(kReturnRegister0));
+    locations.AddReturn(regloc(kReturnRegister0, return_type));
   }
   if (locations.return_count_ > 1) {
-    locations.AddReturn(regloc(kReturnRegister1));
+    locations.AddReturn(regloc(kReturnRegister1, return_type));
   }
   if (locations.return_count_ > 2) {
-    locations.AddReturn(regloc(kReturnRegister2));
-  }
-  for (size_t i = 0; i < return_count; i++) {
-    types.AddReturn(return_type);
+    locations.AddReturn(regloc(kReturnRegister2, return_type));
   }
 
   // Add parameters in registers and on the stack.
   for (int i = 0; i < js_parameter_count; i++) {
     if (i < register_parameter_count) {
       // The first parameters go in registers.
       Register reg = descriptor.GetRegisterParameter(i);
-      Representation rep =
-          RepresentationFromType(descriptor.GetParameterType(i));
-      locations.AddParam(regloc(reg));
-      types.AddParam(reptyp(rep));
+      MachineType type =
+          reptyp(RepresentationFromType(descriptor.GetParameterType(i)));
+      locations.AddParam(regloc(reg, type));
     } else {
       // The rest of the parameters go on the stack.
       int stack_slot = i - register_parameter_count - stack_parameter_count;
-      locations.AddParam(LinkageLocation::ForCallerFrameSlot(stack_slot));
-      types.AddParam(MachineType::AnyTagged());
+      locations.AddParam(LinkageLocation::ForCallerFrameSlot(
+          stack_slot, MachineType::AnyTagged()));
     }
   }
   // Add context.
-  locations.AddParam(regloc(kContextRegister));
-  types.AddParam(MachineType::AnyTagged());
+  locations.AddParam(regloc(kContextRegister, MachineType::AnyTagged()));
 
   // The target for stub calls is a code object.
   MachineType target_type = MachineType::AnyTagged();
-  LinkageLocation target_loc = LinkageLocation::ForAnyRegister();
+  LinkageLocation target_loc =
+      LinkageLocation::ForAnyRegister(MachineType::AnyTagged());
   return new (zone) CallDescriptor(     // --
       CallDescriptor::kCallCodeObject,  // kind
       target_type,                      // target MachineType
       target_loc,                       // target location
-      types.Build(),                    // machine_sig
       locations.Build(),                // location_sig
       stack_parameter_count,            // stack_parameter_count
       properties,                       // properties
       kNoCalleeSaved,                   // callee-saved registers
       kNoCalleeSaved,                   // callee-saved fp
       CallDescriptor::kCanUseRoots |    // flags
           flags,                        // flags
       descriptor.DebugName(isolate));
 }
 
 // static
 CallDescriptor* Linkage::GetAllocateCallDescriptor(Zone* zone) {
   LocationSignature::Builder locations(zone, 1, 1);
-  MachineSignature::Builder types(zone, 1, 1);
 
-  locations.AddParam(regloc(kAllocateSizeRegister));
-  types.AddParam(MachineType::Int32());
+  locations.AddParam(regloc(kAllocateSizeRegister, MachineType::Int32()));
 
-  locations.AddReturn(regloc(kReturnRegister0));
-  types.AddReturn(MachineType::AnyTagged());
+  locations.AddReturn(regloc(kReturnRegister0, MachineType::AnyTagged()));
 
   // The target for allocate calls is a code object.
   MachineType target_type = MachineType::AnyTagged();
-  LinkageLocation target_loc = LinkageLocation::ForAnyRegister();
+  LinkageLocation target_loc =
+      LinkageLocation::ForAnyRegister(MachineType::AnyTagged());
   return new (zone) CallDescriptor(     // --
       CallDescriptor::kCallCodeObject,  // kind
       target_type,                      // target MachineType
       target_loc,                       // target location
-      types.Build(),                    // machine_sig
       locations.Build(),                // location_sig
       0,                                // stack_parameter_count
       Operator::kNoThrow,               // properties
       kNoCalleeSaved,                   // callee-saved registers
       kNoCalleeSaved,                   // callee-saved fp
       CallDescriptor::kCanUseRoots,     // flags
       "Allocate");
 }
 
 // static
 CallDescriptor* Linkage::GetBytecodeDispatchCallDescriptor(
     Isolate* isolate, Zone* zone, const CallInterfaceDescriptor& descriptor,
     int stack_parameter_count) {
   const int register_parameter_count = descriptor.GetRegisterParameterCount();
   const int parameter_count = register_parameter_count + stack_parameter_count;
 
   LocationSignature::Builder locations(zone, 0, parameter_count);
-  MachineSignature::Builder types(zone, 0, parameter_count);
 
   // Add parameters in registers and on the stack.
   for (int i = 0; i < parameter_count; i++) {
     if (i < register_parameter_count) {
       // The first parameters go in registers.
       Register reg = descriptor.GetRegisterParameter(i);
-      Representation rep =
-          RepresentationFromType(descriptor.GetParameterType(i));
-      locations.AddParam(regloc(reg));
-      types.AddParam(reptyp(rep));
+      MachineType type =
+          reptyp(RepresentationFromType(descriptor.GetParameterType(i)));
+      locations.AddParam(regloc(reg, type));
     } else {
       // The rest of the parameters go on the stack.
       int stack_slot = i - register_parameter_count - stack_parameter_count;
-      locations.AddParam(LinkageLocation::ForCallerFrameSlot(stack_slot));
-      types.AddParam(MachineType::AnyTagged());
+      locations.AddParam(LinkageLocation::ForCallerFrameSlot(
+          stack_slot, MachineType::AnyTagged()));
     }
   }
 
   // The target for interpreter dispatches is a code entry address.
   MachineType target_type = MachineType::Pointer();
-  LinkageLocation target_loc = LinkageLocation::ForAnyRegister();
+  LinkageLocation target_loc = LinkageLocation::ForAnyRegister(target_type);
   return new (zone) CallDescriptor(            // --
       CallDescriptor::kCallAddress,            // kind
       target_type,                             // target MachineType
       target_loc,                              // target location
-      types.Build(),                           // machine_sig
       locations.Build(),                       // location_sig
       stack_parameter_count,                   // stack_parameter_count
       Operator::kNoProperties,                 // properties
       kNoCalleeSaved,                          // callee-saved registers
       kNoCalleeSaved,                          // callee-saved fp
       CallDescriptor::kCanUseRoots |           // flags
           CallDescriptor::kSupportsTailCalls,  // flags
       descriptor.DebugName(isolate));
 }
 
 LinkageLocation Linkage::GetOsrValueLocation(int index) const {
   CHECK(incoming_->IsJSFunctionCall());
   int parameter_count = static_cast<int>(incoming_->JSParameterCount() - 1);
   int first_stack_slot = OsrHelper::FirstStackSlotIndex(parameter_count);
 
   if (index == kOsrContextSpillSlotIndex) {
     // Context. Use the parameter location of the context spill slot.
     // Parameter (arity + 2) is special for the context of the function frame.
     // >> context_index = target + receiver + params + new_target + #args
     int context_index = 1 + 1 + parameter_count + 1 + 1;
     return incoming_->GetInputLocation(context_index);
   } else if (index >= first_stack_slot) {
     // Local variable stored in this (callee) stack.
     int spill_index =
         index - first_stack_slot + StandardFrameConstants::kFixedSlotCount;
-    return LinkageLocation::ForCalleeFrameSlot(spill_index);
+    return LinkageLocation::ForCalleeFrameSlot(spill_index,
+                                               MachineType::AnyTagged());
   } else {
     // Parameter. Use the assigned location from the incoming call descriptor.
     int parameter_index = 1 + index;  // skip index 0, which is the target.
     return incoming_->GetInputLocation(parameter_index);
   }
 }
 
 
 bool Linkage::ParameterHasSecondaryLocation(int index) const {
   if (!incoming_->IsJSFunctionCall()) return false;
   LinkageLocation loc = GetParameterLocation(index);
-  return (loc == regloc(kJSFunctionRegister) ||
-          loc == regloc(kContextRegister));
+  return (loc == regloc(kJSFunctionRegister, MachineType::AnyTagged()) ||
+          loc == regloc(kContextRegister, MachineType::AnyTagged()));
 }
 
 LinkageLocation Linkage::GetParameterSecondaryLocation(int index) const {
   DCHECK(ParameterHasSecondaryLocation(index));
   LinkageLocation loc = GetParameterLocation(index);
 
-  if (loc == regloc(kJSFunctionRegister)) {
-    return LinkageLocation::ForCalleeFrameSlot(Frame::kJSFunctionSlot);
+  if (loc == regloc(kJSFunctionRegister, MachineType::AnyTagged())) {
+    return LinkageLocation::ForCalleeFrameSlot(Frame::kJSFunctionSlot,
+                                               MachineType::AnyTagged());
   } else {
-    DCHECK(loc == regloc(kContextRegister));
-    return LinkageLocation::ForCalleeFrameSlot(Frame::kContextSlot);
+    DCHECK(loc == regloc(kContextRegister, MachineType::AnyTagged()));
+    return LinkageLocation::ForCalleeFrameSlot(Frame::kContextSlot,
+                                               MachineType::AnyTagged());
   }
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8