[turbofan] Add MachineType to LinkageLocation

src/compiler/wasm-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/register-configuration.h"
 
 #include "src/wasm/wasm-module.h"
 
 #include "src/compiler/linkage.h"
 
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 // TODO(titzer): this should not be in the WASM namespace.
 namespace wasm {
 
 using compiler::LocationSignature;
 using compiler::CallDescriptor;
 using compiler::LinkageLocation;
 
 namespace {
+
 MachineType MachineTypeFor(LocalType type) {
   switch (type) {
     case kAstI32:
       return MachineType::Int32();
     case kAstI64:
       return MachineType::Int64();
     case kAstF64:
       return MachineType::Float64();
     case kAstF32:
       return MachineType::Float32();
     case kAstS128:
       return MachineType::Simd128();
     default:
       UNREACHABLE();
       return MachineType::AnyTagged();
   }
 }
 
+// Platform-specific configuration for C calling convention.

[titzer, 2016/07/08 07:46:23]

Comment is wrong here.

[danno, 2016/07/08 15:22:10]

Done.

+LinkageLocation regloc(Register reg, MachineType type) {
+  return LinkageLocation::ForRegister(reg.code(), type);
+}
 
-// Platform-specific configuration for C calling convention.
-LinkageLocation regloc(Register reg) {
-  return LinkageLocation::ForRegister(reg.code());
+LinkageLocation regloc(DoubleRegister reg, MachineType type) {
+  return LinkageLocation::ForRegister(reg.code(), type);
+}
+
+LinkageLocation stackloc(int i, MachineType type) {
+  return LinkageLocation::ForCallerFrameSlot(i, type);
 }
 
 
-LinkageLocation regloc(DoubleRegister reg) {
-  return LinkageLocation::ForRegister(reg.code());
-}
-
-
-LinkageLocation stackloc(int i) {
-  return LinkageLocation::ForCallerFrameSlot(i);
-}
-
-
 #if V8_TARGET_ARCH_IA32
 // ===========================================================================
 // == ia32 ===================================================================
 // ===========================================================================
 #define GP_PARAM_REGISTERS eax, edx, ecx, ebx, esi
 #define GP_RETURN_REGISTERS eax, edx
 #define FP_PARAM_REGISTERS xmm1, xmm2, xmm3, xmm4, xmm5, xmm6
 #define FP_RETURN_REGISTERS xmm1, xmm2
 
 #elif V8_TARGET_ARCH_X64
@@ skipping 110 matching lines @@
       // Allocate a floating point register/stack location.
       if (fp_offset < fp_count) {
         DoubleRegister reg = fp_regs[fp_offset++];
 #if V8_TARGET_ARCH_ARM
         // Allocate floats using a double register, but modify the code to
         // reflect how ARM FP registers alias.
         // TODO(bbudge) Modify wasm linkage to allow use of all float regs.
         if (type == kAstF32) {
           int float_reg_code = reg.code() * 2;
           DCHECK(float_reg_code < RegisterConfiguration::kMaxFPRegisters);
-          return regloc(DoubleRegister::from_code(float_reg_code));
+          return regloc(DoubleRegister::from_code(float_reg_code),
+                        MachineTypeFor(type));
         }
 #endif
-        return regloc(reg);
+        return regloc(reg, MachineTypeFor(type));
       } else {
         int offset = -1 - stack_offset;
         stack_offset += Words(type);
-        return stackloc(offset);
+        return stackloc(offset, MachineTypeFor(type));
       }
     } else {
       // Allocate a general purpose register/stack location.
       if (gp_offset < gp_count) {
-        return regloc(gp_regs[gp_offset++]);
+        return regloc(gp_regs[gp_offset++], MachineTypeFor(type));
       } else {
         int offset = -1 - stack_offset;
         stack_offset += Words(type);
-        return stackloc(offset);
+        return stackloc(offset, MachineTypeFor(type));
       }
     }
   }
   bool IsFloatingPoint(LocalType type) {
     return type == kAstF32 || type == kAstF64;
   }
   int Words(LocalType type) {
     if (kPointerSize < 8 && (type == kAstI64 || type == kAstF64)) {
       return 2;
     }
@@ skipping 48 matching lines @@
 
   Allocator params(kGPParamRegisters, kGPParamRegistersCount, kFPParamRegisters,
                    kFPParamRegistersCount);
 
   return params;
 }
 
 // General code uses the above configuration data.
 CallDescriptor* ModuleEnv::GetWasmCallDescriptor(Zone* zone,
                                                  FunctionSig* fsig) {
-  MachineSignature::Builder msig(zone, fsig->return_count(),
-                                 fsig->parameter_count());
   LocationSignature::Builder locations(zone, fsig->return_count(),
                                        fsig->parameter_count());
 
   Allocator rets = GetReturnRegisters();
 
   // Add return location(s).
   const int return_count = static_cast<int>(locations.return_count_);
   for (int i = 0; i < return_count; i++) {
     LocalType ret = fsig->GetReturn(i);
-    msig.AddReturn(MachineTypeFor(ret));
     locations.AddReturn(rets.Next(ret));
   }
 
   Allocator params = GetParameterRegisters();
 
   // Add register and/or stack parameter(s).
   const int parameter_count = static_cast<int>(fsig->parameter_count());
   for (int i = 0; i < parameter_count; i++) {
     LocalType param = fsig->GetParam(i);
-    msig.AddParam(MachineTypeFor(param));
     locations.AddParam(params.Next(param));
   }
 
   const RegList kCalleeSaveRegisters = 0;
   const RegList kCalleeSaveFPRegisters = 0;
 
   // The target for WASM calls is always a code object.
   MachineType target_type = MachineType::AnyTagged();
-  LinkageLocation target_loc = LinkageLocation::ForAnyRegister();
+  LinkageLocation target_loc = LinkageLocation::ForAnyRegister(target_type);
 
   return new (zone) CallDescriptor(       // --
       CallDescriptor::kCallCodeObject,    // kind
       target_type,                        // target MachineType
       target_loc,                         // target location
-      msig.Build(),                       // machine_sig
       locations.Build(),                  // location_sig
       params.stack_offset,                // stack_parameter_count
       compiler::Operator::kNoProperties,  // properties
       kCalleeSaveRegisters,               // callee-saved registers
       kCalleeSaveFPRegisters,             // callee-saved fp regs
       CallDescriptor::kUseNativeStack,    // flags
       "wasm-call");
 }
 
 CallDescriptor* ModuleEnv::GetI32WasmCallDescriptor(
     Zone* zone, CallDescriptor* descriptor) {
-  const MachineSignature* signature = descriptor->GetMachineSignature();
-  size_t parameter_count = signature->parameter_count();
-  size_t return_count = signature->return_count();
-  for (size_t i = 0; i < signature->parameter_count(); i++) {
-    if (signature->GetParam(i) == MachineType::Int64()) {
+  size_t parameter_count = descriptor->ParameterCount();
+  size_t return_count = descriptor->ReturnCount();
+  for (size_t i = 0; i < descriptor->ParameterCount(); i++) {
+    if (descriptor->GetParameterType(i) == MachineType::Int64()) {
       // For each int64 input we get two int32 inputs.
       parameter_count++;
     }
   }
-  for (size_t i = 0; i < signature->return_count(); i++) {
-    if (signature->GetReturn(i) == MachineType::Int64()) {
+  for (size_t i = 0; i < descriptor->ReturnCount(); i++) {
+    if (descriptor->GetReturnType(i) == MachineType::Int64()) {
       // For each int64 return we get two int32 returns.
       return_count++;
     }
   }
-  if (parameter_count == signature->parameter_count() &&
-      return_count == signature->return_count()) {
+  if (parameter_count == descriptor->ParameterCount() &&
+      return_count == descriptor->ReturnCount()) {
     // If there is no int64 parameter or return value, we can just return the
     // original descriptor.
     return descriptor;
   }
 
-  MachineSignature::Builder msig(zone, return_count, parameter_count);
   LocationSignature::Builder locations(zone, return_count, parameter_count);
 
   Allocator rets = GetReturnRegisters();
 
-  for (size_t i = 0; i < signature->return_count(); i++) {
-    if (signature->GetReturn(i) == MachineType::Int64()) {
+  for (size_t i = 0; i < descriptor->ReturnCount(); i++) {
+    if (descriptor->GetReturnType(i) == MachineType::Int64()) {
       // For each int64 return we get two int32 returns.
-      msig.AddReturn(MachineType::Int32());
-      msig.AddReturn(MachineType::Int32());
       locations.AddReturn(rets.Next(MachineRepresentation::kWord32));
       locations.AddReturn(rets.Next(MachineRepresentation::kWord32));
     } else {
-      msig.AddReturn(signature->GetReturn(i));
-      locations.AddReturn(rets.Next(signature->GetReturn(i).representation()));
+      locations.AddReturn(
+          rets.Next(descriptor->GetReturnType(i).representation()));
     }
   }
 
   Allocator params = GetParameterRegisters();
 
-  for (size_t i = 0; i < signature->parameter_count(); i++) {
-    if (signature->GetParam(i) == MachineType::Int64()) {
+  for (size_t i = 0; i < descriptor->ParameterCount(); i++) {
+    if (descriptor->GetParameterType(i) == MachineType::Int64()) {
       // For each int64 input we get two int32 inputs.
-      msig.AddParam(MachineType::Int32());
-      msig.AddParam(MachineType::Int32());
       locations.AddParam(params.Next(MachineRepresentation::kWord32));
       locations.AddParam(params.Next(MachineRepresentation::kWord32));
     } else {
-      msig.AddParam(signature->GetParam(i));
-      locations.AddParam(params.Next(signature->GetParam(i).representation()));
+      locations.AddParam(
+          params.Next(descriptor->GetParameterType(i).representation()));
     }
   }
 
   return new (zone) CallDescriptor(          // --
       descriptor->kind(),                    // kind
       descriptor->GetInputType(0),           // target MachineType
       descriptor->GetInputLocation(0),       // target location
-      msig.Build(),                          // machine_sig
       locations.Build(),                     // location_sig
       params.stack_offset,                   // stack_parameter_count
       descriptor->properties(),              // properties
       descriptor->CalleeSavedRegisters(),    // callee-saved registers
       descriptor->CalleeSavedFPRegisters(),  // callee-saved fp regs
       descriptor->flags(),                   // flags
       descriptor->debug_name());
 
   return descriptor;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8