[turbofan] Use proper parameter representation for stub calls.

src/compiler/linkage-impl.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_LINKAGE_IMPL_H_
 #define V8_COMPILER_LINKAGE_IMPL_H_
 
 #include "src/code-stubs.h"
 #include "src/compiler/osr.h"
 
@@ skipping 146 matching lines @@
 
     // Add return location.
     AddReturnLocations(&locations);
     types.AddReturn(kMachAnyTagged);
 
     // 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.GetEnvironmentParameterRegister(i);
+        Representation rep =
+            descriptor.GetEnvironmentParameterRepresentation(i);
         locations.AddParam(regloc(reg));
+        types.AddParam(reptyp(rep));
       } else {
         // The rest of the parameters go on the stack.
         int stack_slot = i - register_parameter_count - stack_parameter_count;
         locations.AddParam(stackloc(stack_slot));
+        types.AddParam(kMachAnyTagged);
       }
-      types.AddParam(kMachAnyTagged);
     }
     // Add context.
     locations.AddParam(regloc(LinkageTraits::ContextReg()));
     types.AddParam(kMachAnyTagged);
 
     // The target for stub calls is a code object.
     MachineType target_type = kMachAnyTagged;
     LinkageLocation target_loc = LinkageLocation::AnyRegister();
     return new (zone) CallDescriptor(     // --
         CallDescriptor::kCallCodeObject,  // kind
@@ skipping 41 matching lines @@
   }
 
   static LinkageLocation regloc(Register reg) {
     return LinkageLocation(Register::ToAllocationIndex(reg));
   }
 
   static LinkageLocation stackloc(int i) {
     DCHECK_LT(i, 0);
     return LinkageLocation(i);
   }
+
+  static MachineType reptyp(Representation representation) {
+    switch (representation.kind()) {
+      case Representation::kInteger8:
+        return kMachInt8;
+      case Representation::kUInteger8:
+        return kMachUint8;
+      case Representation::kInteger16:
+        return kMachInt16;
+      case Representation::kUInteger16:
+        return kMachUint16;
+      case Representation::kInteger32:
+        return kMachInt32;
+      case Representation::kSmi:
+      case Representation::kTagged:
+      case Representation::kHeapObject:
+        return kMachAnyTagged;
+      case Representation::kDouble:
+        return kMachFloat64;
+      case Representation::kExternal:
+        return kMachPtr;
+      case Representation::kNone:
+      case Representation::kNumRepresentations:
+        break;
+    }
+    UNREACHABLE();
+    return kMachNone;
+  }
 };
 
 
 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 >= first_stack_slot) {
     // Local variable stored in this (callee) stack.
     int spill_index =
         LinkageLocation::ANY_REGISTER + 1 + index - first_stack_slot;
     // TODO(titzer): bailout instead of crashing here.
     CHECK(spill_index <= LinkageLocation::MAX_STACK_SLOT);
     return LinkageLocation(spill_index);
   } 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);
   }
 }
 
-
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_LINKAGE_IMPL_H_