src/compiler/wasm-linkage.cc - fp2-dev/platform/external/v8 - Gitiles

 // 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.
 LinkageLocation regloc(Register reg) {
   return LinkageLocation::ForRegister(reg.code());
 }


 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
 // ===========================================================================
 // == x64 ====================================================================
 // ===========================================================================
 #define GP_PARAM_REGISTERS rax, rdx, rcx, rbx, rsi, rdi
 #define GP_RETURN_REGISTERS rax, rdx
 #define FP_PARAM_REGISTERS xmm1, xmm2, xmm3, xmm4, xmm5, xmm6
 #define FP_RETURN_REGISTERS xmm1, xmm2

 #elif V8_TARGET_ARCH_X87
 // ===========================================================================
 // == x87 ====================================================================
 // ===========================================================================
 #define GP_PARAM_REGISTERS eax, edx, ecx, ebx, esi
 #define GP_RETURN_REGISTERS eax, edx
 #define FP_RETURN_REGISTERS stX_0

 #elif V8_TARGET_ARCH_ARM
 // ===========================================================================
 // == arm ====================================================================
 // ===========================================================================
 #define GP_PARAM_REGISTERS r0, r1, r2, r3
 #define GP_RETURN_REGISTERS r0, r1
 #define FP_PARAM_REGISTERS d0, d1, d2, d3, d4, d5, d6, d7
 #define FP_RETURN_REGISTERS d0, d1

 #elif V8_TARGET_ARCH_ARM64
 // ===========================================================================
 // == arm64 ====================================================================
 // ===========================================================================
 #define GP_PARAM_REGISTERS x0, x1, x2, x3, x4, x5, x6, x7
 #define GP_RETURN_REGISTERS x0, x1
 #define FP_PARAM_REGISTERS d0, d1, d2, d3, d4, d5, d6, d7
 #define FP_RETURN_REGISTERS d0, d1

 #elif V8_TARGET_ARCH_MIPS
 // ===========================================================================
 // == mips ===================================================================
 // ===========================================================================
 #define GP_PARAM_REGISTERS a0, a1, a2, a3
 #define GP_RETURN_REGISTERS v0, v1
 #define FP_PARAM_REGISTERS f2, f4, f6, f8, f10, f12, f14
 #define FP_RETURN_REGISTERS f2, f4

 #elif V8_TARGET_ARCH_MIPS64
 // ===========================================================================
 // == mips64 =================================================================
 // ===========================================================================
 #define GP_PARAM_REGISTERS a0, a1, a2, a3, a4, a5, a6, a7
 #define GP_RETURN_REGISTERS v0, v1
 #define FP_PARAM_REGISTERS f2, f4, f6, f8, f10, f12, f14
 #define FP_RETURN_REGISTERS f2, f4

 #elif V8_TARGET_ARCH_PPC || V8_TARGET_ARCH_PPC64
 // ===========================================================================
 // == ppc & ppc64 ============================================================
 // ===========================================================================
 #define GP_PARAM_REGISTERS r3, r4, r5, r6, r7, r8, r9, r10
 #define GP_RETURN_REGISTERS r3, r4
 #define FP_PARAM_REGISTERS d1, d2, d3, d4, d5, d6, d7, d8
 #define FP_RETURN_REGISTERS d1, d2

 #elif V8_TARGET_ARCH_S390X
 // ===========================================================================
 // == s390x ==================================================================
 // ===========================================================================
 #define GP_PARAM_REGISTERS r2, r3, r4, r5, r6
 #define GP_RETURN_REGISTERS r2
 #define FP_PARAM_REGISTERS d0, d2, d4, d6
 #define FP_RETURN_REGISTERS d0, d2, d4, d6

 #elif V8_TARGET_ARCH_S390
 // ===========================================================================
 // == s390 ===================================================================
 // ===========================================================================
 #define GP_PARAM_REGISTERS r2, r3, r4, r5, r6
 #define GP_RETURN_REGISTERS r2, r3
 #define FP_PARAM_REGISTERS d0, d2
 #define FP_RETURN_REGISTERS d0, d2

 #else
 // ===========================================================================
 // == unknown ================================================================
 // ===========================================================================
 // Don't define anything. We'll just always use the stack.
 #endif


 // Helper for allocating either an GP or FP reg, or the next stack slot.
 struct Allocator {
   Allocator(const Register* gp, int gpc, const DoubleRegister* fp, int fpc)
       : gp_count(gpc),
         gp_offset(0),
         gp_regs(gp),
         fp_count(fpc),
         fp_offset(0),
         fp_regs(fp),
         stack_offset(0) {}

   int gp_count;
   int gp_offset;
   const Register* gp_regs;

   int fp_count;
   int fp_offset;
   const DoubleRegister* fp_regs;

   int stack_offset;

   LinkageLocation Next(LocalType type) {
     if (IsFloatingPoint(type)) {
       // 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));
         }
 #endif
         return regloc(reg);
       } else {
         int offset = -1 - stack_offset;
         stack_offset += Words(type);
         return stackloc(offset);
       }
     } else {
       // Allocate a general purpose register/stack location.
       if (gp_offset < gp_count) {
         return regloc(gp_regs[gp_offset++]);
       } else {
         int offset = -1 - stack_offset;
         stack_offset += Words(type);
         return stackloc(offset);
       }
     }
   }
   bool IsFloatingPoint(LocalType type) {
     return type == kAstF32 || type == kAstF64;
   }
   int Words(LocalType type) {
     if (kPointerSize < 8 && (type == kAstI64 || type == kAstF64)) {
       return 2;
     }
     return 1;
   }
 };
 }  // namespace

 static Allocator GetReturnRegisters() {
 #ifdef GP_RETURN_REGISTERS
   static const Register kGPReturnRegisters[] = {GP_RETURN_REGISTERS};
   static const int kGPReturnRegistersCount =
       static_cast<int>(arraysize(kGPReturnRegisters));
 #else
   static const Register* kGPReturnRegisters = nullptr;
   static const int kGPReturnRegistersCount = 0;
 #endif

 #ifdef FP_RETURN_REGISTERS
   static const DoubleRegister kFPReturnRegisters[] = {FP_RETURN_REGISTERS};
   static const int kFPReturnRegistersCount =
       static_cast<int>(arraysize(kFPReturnRegisters));
 #else
   static const DoubleRegister* kFPReturnRegisters = nullptr;
   static const int kFPReturnRegistersCount = 0;
 #endif

   Allocator rets(kGPReturnRegisters, kGPReturnRegistersCount,
                  kFPReturnRegisters, kFPReturnRegistersCount);

   return rets;
 }

 static Allocator GetParameterRegisters() {
 #ifdef GP_PARAM_REGISTERS
   static const Register kGPParamRegisters[] = {GP_PARAM_REGISTERS};
   static const int kGPParamRegistersCount =
       static_cast<int>(arraysize(kGPParamRegisters));
 #else
   static const Register* kGPParamRegisters = nullptr;
   static const int kGPParamRegistersCount = 0;
 #endif

 #ifdef FP_PARAM_REGISTERS
   static const DoubleRegister kFPParamRegisters[] = {FP_PARAM_REGISTERS};
   static const int kFPParamRegistersCount =
       static_cast<int>(arraysize(kFPParamRegisters));
 #else
   static const DoubleRegister* kFPParamRegisters = nullptr;
   static const int kFPParamRegistersCount = 0;
 #endif

   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();

   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()) {
       // 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 each int64 return we get two int32 returns.
       return_count++;
     }
   }
   if (parameter_count == signature->parameter_count() &&
       return_count == signature->return_count()) {
     // 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 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()));
     }
   }

   Allocator params = GetParameterRegisters();

   for (size_t i = 0; i < signature->parameter_count(); i++) {
     if (signature->GetParam(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()));
     }
   }

   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
	// 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.
	LinkageLocation regloc(Register reg) {
	return LinkageLocation::ForRegister(reg.code());
	}


	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
	// ===========================================================================
	// == x64 ====================================================================
	// ===========================================================================
	#define GP_PARAM_REGISTERS rax, rdx, rcx, rbx, rsi, rdi
	#define GP_RETURN_REGISTERS rax, rdx
	#define FP_PARAM_REGISTERS xmm1, xmm2, xmm3, xmm4, xmm5, xmm6
	#define FP_RETURN_REGISTERS xmm1, xmm2

	#elif V8_TARGET_ARCH_X87
	// ===========================================================================
	// == x87 ====================================================================
	// ===========================================================================
	#define GP_PARAM_REGISTERS eax, edx, ecx, ebx, esi
	#define GP_RETURN_REGISTERS eax, edx
	#define FP_RETURN_REGISTERS stX_0

	#elif V8_TARGET_ARCH_ARM
	// ===========================================================================
	// == arm ====================================================================
	// ===========================================================================
	#define GP_PARAM_REGISTERS r0, r1, r2, r3
	#define GP_RETURN_REGISTERS r0, r1
	#define FP_PARAM_REGISTERS d0, d1, d2, d3, d4, d5, d6, d7
	#define FP_RETURN_REGISTERS d0, d1

	#elif V8_TARGET_ARCH_ARM64
	// ===========================================================================
	// == arm64 ====================================================================
	// ===========================================================================
	#define GP_PARAM_REGISTERS x0, x1, x2, x3, x4, x5, x6, x7
	#define GP_RETURN_REGISTERS x0, x1
	#define FP_PARAM_REGISTERS d0, d1, d2, d3, d4, d5, d6, d7
	#define FP_RETURN_REGISTERS d0, d1

	#elif V8_TARGET_ARCH_MIPS
	// ===========================================================================
	// == mips ===================================================================
	// ===========================================================================
	#define GP_PARAM_REGISTERS a0, a1, a2, a3
	#define GP_RETURN_REGISTERS v0, v1
	#define FP_PARAM_REGISTERS f2, f4, f6, f8, f10, f12, f14
	#define FP_RETURN_REGISTERS f2, f4

	#elif V8_TARGET_ARCH_MIPS64
	// ===========================================================================
	// == mips64 =================================================================
	// ===========================================================================
	#define GP_PARAM_REGISTERS a0, a1, a2, a3, a4, a5, a6, a7
	#define GP_RETURN_REGISTERS v0, v1
	#define FP_PARAM_REGISTERS f2, f4, f6, f8, f10, f12, f14
	#define FP_RETURN_REGISTERS f2, f4

	#elif V8_TARGET_ARCH_PPC \|\| V8_TARGET_ARCH_PPC64
	// ===========================================================================
	// == ppc & ppc64 ============================================================
	// ===========================================================================
	#define GP_PARAM_REGISTERS r3, r4, r5, r6, r7, r8, r9, r10
	#define GP_RETURN_REGISTERS r3, r4
	#define FP_PARAM_REGISTERS d1, d2, d3, d4, d5, d6, d7, d8
	#define FP_RETURN_REGISTERS d1, d2

	#elif V8_TARGET_ARCH_S390X
	// ===========================================================================
	// == s390x ==================================================================
	// ===========================================================================
	#define GP_PARAM_REGISTERS r2, r3, r4, r5, r6
	#define GP_RETURN_REGISTERS r2
	#define FP_PARAM_REGISTERS d0, d2, d4, d6
	#define FP_RETURN_REGISTERS d0, d2, d4, d6

	#elif V8_TARGET_ARCH_S390
	// ===========================================================================
	// == s390 ===================================================================
	// ===========================================================================
	#define GP_PARAM_REGISTERS r2, r3, r4, r5, r6
	#define GP_RETURN_REGISTERS r2, r3
	#define FP_PARAM_REGISTERS d0, d2
	#define FP_RETURN_REGISTERS d0, d2

	#else
	// ===========================================================================
	// == unknown ================================================================
	// ===========================================================================
	// Don't define anything. We'll just always use the stack.
	#endif


	// Helper for allocating either an GP or FP reg, or the next stack slot.
	struct Allocator {
	Allocator(const Register* gp, int gpc, const DoubleRegister* fp, int fpc)
	: gp_count(gpc),
	gp_offset(0),
	gp_regs(gp),
	fp_count(fpc),
	fp_offset(0),
	fp_regs(fp),
	stack_offset(0) {}

	int gp_count;
	int gp_offset;
	const Register* gp_regs;

	int fp_count;
	int fp_offset;
	const DoubleRegister* fp_regs;

	int stack_offset;

	LinkageLocation Next(LocalType type) {
	if (IsFloatingPoint(type)) {
	// 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));
	}
	#endif
	return regloc(reg);
	} else {
	int offset = -1 - stack_offset;
	stack_offset += Words(type);
	return stackloc(offset);
	}
	} else {
	// Allocate a general purpose register/stack location.
	if (gp_offset < gp_count) {
	return regloc(gp_regs[gp_offset++]);
	} else {
	int offset = -1 - stack_offset;
	stack_offset += Words(type);
	return stackloc(offset);
	}
	}
	}
	bool IsFloatingPoint(LocalType type) {
	return type == kAstF32 \|\| type == kAstF64;
	}
	int Words(LocalType type) {
	if (kPointerSize < 8 && (type == kAstI64 \|\| type == kAstF64)) {
	return 2;
	}
	return 1;
	}
	};
	} // namespace

	static Allocator GetReturnRegisters() {
	#ifdef GP_RETURN_REGISTERS
	static const Register kGPReturnRegisters[] = {GP_RETURN_REGISTERS};
	static const int kGPReturnRegistersCount =
	static_cast<int>(arraysize(kGPReturnRegisters));
	#else
	static const Register* kGPReturnRegisters = nullptr;
	static const int kGPReturnRegistersCount = 0;
	#endif

	#ifdef FP_RETURN_REGISTERS
	static const DoubleRegister kFPReturnRegisters[] = {FP_RETURN_REGISTERS};
	static const int kFPReturnRegistersCount =
	static_cast<int>(arraysize(kFPReturnRegisters));
	#else
	static const DoubleRegister* kFPReturnRegisters = nullptr;
	static const int kFPReturnRegistersCount = 0;
	#endif

	Allocator rets(kGPReturnRegisters, kGPReturnRegistersCount,
	kFPReturnRegisters, kFPReturnRegistersCount);

	return rets;
	}

	static Allocator GetParameterRegisters() {
	#ifdef GP_PARAM_REGISTERS
	static const Register kGPParamRegisters[] = {GP_PARAM_REGISTERS};
	static const int kGPParamRegistersCount =
	static_cast<int>(arraysize(kGPParamRegisters));
	#else
	static const Register* kGPParamRegisters = nullptr;
	static const int kGPParamRegistersCount = 0;
	#endif

	#ifdef FP_PARAM_REGISTERS
	static const DoubleRegister kFPParamRegisters[] = {FP_PARAM_REGISTERS};
	static const int kFPParamRegistersCount =
	static_cast<int>(arraysize(kFPParamRegisters));
	#else
	static const DoubleRegister* kFPParamRegisters = nullptr;
	static const int kFPParamRegistersCount = 0;
	#endif

	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();

	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()) {
	// 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 each int64 return we get two int32 returns.
	return_count++;
	}
	}
	if (parameter_count == signature->parameter_count() &&
	return_count == signature->return_count()) {
	// 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 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()));
	}
	}

	Allocator params = GetParameterRegisters();

	for (size_t i = 0; i < signature->parameter_count(); i++) {
	if (signature->GetParam(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()));
	}
	}

	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