[turbofan] Add MachineType to LinkageLocation

src/compiler/c-linkage.cc

 // Copyright 2015 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/assembler.h"
 #include "src/macro-assembler.h"
 
 #include "src/compiler/linkage.h"
 
 #include "src/zone.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);
 }
 
 
 // Platform-specific configuration for C calling convention.
 #if V8_TARGET_ARCH_IA32
 // ===========================================================================
 // == ia32 ===================================================================
 // ===========================================================================
 #define CALLEE_SAVE_REGISTERS esi.bit() | edi.bit() | ebx.bit()
 
@@ skipping 146 matching lines @@
   // This method should not be called on unknown architectures.
   V8_Fatal(__FILE__, __LINE__,
            "requested C call descriptor on unsupported architecture");
   return nullptr;
 #endif
 
   // Add return location(s).
   CHECK(locations.return_count_ <= 2);
 
   if (locations.return_count_ > 0) {
-    locations.AddReturn(regloc(kReturnRegister0));
+    locations.AddReturn(regloc(kReturnRegister0, msig->GetReturn(0)));
   }
   if (locations.return_count_ > 1) {
-    locations.AddReturn(regloc(kReturnRegister1));
+    locations.AddReturn(regloc(kReturnRegister1, msig->GetReturn(1)));
   }
 
   const int parameter_count = static_cast<int>(msig->parameter_count());
 
 #ifdef PARAM_REGISTERS
   static const Register kParamRegisters[] = {PARAM_REGISTERS};
   static const int kParamRegisterCount =
       static_cast<int>(arraysize(kParamRegisters));
 #else
   static const Register* kParamRegisters = nullptr;
   static const int kParamRegisterCount = 0;
 #endif
 
 #ifdef STACK_SHADOW_WORDS
   int stack_offset = STACK_SHADOW_WORDS;
 #else
   int stack_offset = 0;
 #endif
   // Add register and/or stack parameter(s).
   for (int i = 0; i < parameter_count; i++) {
     if (i < kParamRegisterCount) {
-      locations.AddParam(regloc(kParamRegisters[i]));
+      locations.AddParam(regloc(kParamRegisters[i], msig->GetParam(i)));
     } else {
-      locations.AddParam(
-          LinkageLocation::ForCallerFrameSlot(-1 - stack_offset));
+      locations.AddParam(LinkageLocation::ForCallerFrameSlot(
+          -1 - stack_offset, msig->GetParam(i)));
       stack_offset++;
     }
   }
 
 #ifdef CALLEE_SAVE_REGISTERS
   const RegList kCalleeSaveRegisters = CALLEE_SAVE_REGISTERS;
 #else
   const RegList kCalleeSaveRegisters = 0;
 #endif
 
 #ifdef CALLEE_SAVE_FP_REGISTERS
   const RegList kCalleeSaveFPRegisters = CALLEE_SAVE_FP_REGISTERS;
 #else
   const RegList kCalleeSaveFPRegisters = 0;
 #endif
 
   // The target for C calls is always an address (i.e. machine pointer).
   MachineType target_type = MachineType::Pointer();
-  LinkageLocation target_loc = LinkageLocation::ForAnyRegister();
+  LinkageLocation target_loc = LinkageLocation::ForAnyRegister(target_type);
   CallDescriptor::Flags flags = CallDescriptor::kUseNativeStack;
   if (set_initialize_root_flag) {
     flags |= CallDescriptor::kInitializeRootRegister;
   }
 
   return new (zone) CallDescriptor(  // --
       CallDescriptor::kCallAddress,  // kind
       target_type,                   // target MachineType
       target_loc,                    // target location
-      msig,                          // machine_sig
       locations.Build(),             // location_sig
       0,                             // stack_parameter_count
       Operator::kNoProperties,       // properties
       kCalleeSaveRegisters,          // callee-saved registers
       kCalleeSaveFPRegisters,        // callee-saved fp regs
       flags, "c-call");
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8