src/compiler/linkage.h - v8/v8.git - Git at Google

 // 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_H_
 #define V8_COMPILER_LINKAGE_H_

 #include "src/base/compiler-specific.h"
 #include "src/base/flags.h"
 #include "src/compiler/frame.h"
 #include "src/compiler/operator.h"
 #include "src/globals.h"
 #include "src/interface-descriptors.h"
 #include "src/machine-type.h"
 #include "src/reglist.h"
 #include "src/runtime/runtime.h"
 #include "src/signature.h"
 #include "src/zone/zone.h"

 namespace v8 {
 namespace internal {

 class CallInterfaceDescriptor;
 class OptimizedCompilationInfo;

 namespace compiler {

 const RegList kNoCalleeSaved = 0;

 class Node;
 class OsrHelper;

 // Describes the location for a parameter or a return value to a call.
 class LinkageLocation {
  public:
   bool operator==(const LinkageLocation& other) const {
     return bit_field_ == other.bit_field_;
   }

   bool operator!=(const LinkageLocation& other) const {
     return !(*this == other);
   }

   static LinkageLocation ForAnyRegister(
       MachineType type = MachineType::None()) {
     return LinkageLocation(REGISTER, ANY_REGISTER, type);
   }

   static LinkageLocation ForRegister(int32_t reg,
                                      MachineType type = MachineType::None()) {
     DCHECK_LE(0, reg);
     return LinkageLocation(REGISTER, reg, type);
   }

   static LinkageLocation ForCallerFrameSlot(int32_t slot, MachineType type) {
     DCHECK_GT(0, slot);
     return LinkageLocation(STACK_SLOT, slot, type);
   }

   static LinkageLocation ForCalleeFrameSlot(int32_t slot, MachineType type) {
     // TODO(titzer): bailout instead of crashing here.
     DCHECK(slot >= 0 && slot < LinkageLocation::MAX_STACK_SLOT);
     return LinkageLocation(STACK_SLOT, slot, type);
   }

   static LinkageLocation ForSavedCallerReturnAddress() {
     return ForCalleeFrameSlot((StandardFrameConstants::kCallerPCOffset -
                                StandardFrameConstants::kCallerPCOffset) /
                                   kPointerSize,
                               MachineType::Pointer());
   }

   static LinkageLocation ForSavedCallerFramePtr() {
     return ForCalleeFrameSlot((StandardFrameConstants::kCallerPCOffset -
                                StandardFrameConstants::kCallerFPOffset) /
                                   kPointerSize,
                               MachineType::Pointer());
   }

   static LinkageLocation ForSavedCallerConstantPool() {
     DCHECK(V8_EMBEDDED_CONSTANT_POOL);
     return ForCalleeFrameSlot((StandardFrameConstants::kCallerPCOffset -
                                StandardFrameConstants::kConstantPoolOffset) /
                                   kPointerSize,
                               MachineType::AnyTagged());
   }

   static LinkageLocation ForSavedCallerFunction() {
     return ForCalleeFrameSlot((StandardFrameConstants::kCallerPCOffset -
                                StandardFrameConstants::kFunctionOffset) /
                                   kPointerSize,
                               MachineType::AnyTagged());
   }

   static LinkageLocation ConvertToTailCallerLocation(
       LinkageLocation caller_location, int stack_param_delta) {
     if (!caller_location.IsRegister()) {
       return LinkageLocation(STACK_SLOT,
                              caller_location.GetLocation() + stack_param_delta,
                              caller_location.GetType());
     }
     return caller_location;
   }

   MachineType GetType() const { return machine_type_; }

   int GetSize() const {
     return 1 << ElementSizeLog2Of(GetType().representation());
   }

   int GetSizeInPointers() const {
     // Round up
     return (GetSize() + kPointerSize - 1) / kPointerSize;
   }

   int32_t GetLocation() const {
     // We can't use LocationField::decode here because it doesn't work for
     // negative values!
     return static_cast<int32_t>(bit_field_ & LocationField::kMask) >>
            LocationField::kShift;
   }

   bool IsRegister() const { return TypeField::decode(bit_field_) == REGISTER; }
   bool IsAnyRegister() const {
     return IsRegister() && GetLocation() == ANY_REGISTER;
   }
   bool IsCallerFrameSlot() const { return !IsRegister() && GetLocation() < 0; }
   bool IsCalleeFrameSlot() const { return !IsRegister() && GetLocation() >= 0; }

   int32_t AsRegister() const {
     DCHECK(IsRegister());
     return GetLocation();
   }
   int32_t AsCallerFrameSlot() const {
     DCHECK(IsCallerFrameSlot());
     return GetLocation();
   }
   int32_t AsCalleeFrameSlot() const {
     DCHECK(IsCalleeFrameSlot());
     return GetLocation();
   }

  private:
   enum LocationType { REGISTER, STACK_SLOT };

   class TypeField : public BitField<LocationType, 0, 1> {};
   class LocationField : public BitField<int32_t, TypeField::kNext, 31> {};

   static constexpr int32_t ANY_REGISTER = -1;
   static constexpr int32_t MAX_STACK_SLOT = 32767;

   LinkageLocation(LocationType type, int32_t location,
                   MachineType machine_type) {
     bit_field_ = TypeField::encode(type) |
                  ((location << LocationField::kShift) & LocationField::kMask);
     machine_type_ = machine_type;
   }

   int32_t bit_field_;
   MachineType machine_type_;
 };

 typedef Signature<LinkageLocation> LocationSignature;

 // Describes a call to various parts of the compiler. Every call has the notion
 // of a "target", which is the first input to the call.
 class V8_EXPORT_PRIVATE CallDescriptor final
     : public NON_EXPORTED_BASE(ZoneObject) {
  public:
   // Describes the kind of this call, which determines the target.
   enum Kind {
     kCallCodeObject,   // target is a Code object
     kCallJSFunction,   // target is a JSFunction object
     kCallAddress,      // target is a machine pointer
     kCallWasmFunction  // target is a wasm function
   };

   enum Flag {
     kNoFlags = 0u,
     kNeedsFrameState = 1u << 0,
     kHasExceptionHandler = 1u << 1,
     kCanUseRoots = 1u << 2,
     // Causes the code generator to initialize the root register.
     kInitializeRootRegister = 1u << 3,
     // Does not ever try to allocate space on our heap.
     kNoAllocate = 1u << 4,
     // Push argument count as part of function prologue.
     kPushArgumentCount = 1u << 5,
     // Use retpoline for this call if indirect.
     kRetpoline = 1u << 6,
     // Use the kJavaScriptCallCodeStartRegister (fixed) register for the
     // indirect target address when calling.
     kFixedTargetRegister = 1u << 7
   };
   typedef base::Flags<Flag> Flags;

   CallDescriptor(Kind kind, MachineType target_type, LinkageLocation target_loc,
                  LocationSignature* location_sig, size_t stack_param_count,
                  Operator::Properties properties,
                  RegList callee_saved_registers,
                  RegList callee_saved_fp_registers, Flags flags,
                  const char* debug_name = "",
                  const RegList allocatable_registers = 0,
                  size_t stack_return_count = 0)
       : kind_(kind),
         target_type_(target_type),
         target_loc_(target_loc),
         location_sig_(location_sig),
         stack_param_count_(stack_param_count),
         stack_return_count_(stack_return_count),
         properties_(properties),
         callee_saved_registers_(callee_saved_registers),
         callee_saved_fp_registers_(callee_saved_fp_registers),
         allocatable_registers_(allocatable_registers),
         flags_(flags),
         debug_name_(debug_name) {}

   // Returns the kind of this call.
   Kind kind() const { return kind_; }

   // Returns {true} if this descriptor is a call to a C function.
   bool IsCFunctionCall() const { return kind_ == kCallAddress; }

   // Returns {true} if this descriptor is a call to a JSFunction.
   bool IsJSFunctionCall() const { return kind_ == kCallJSFunction; }

   // Returns {true} if this descriptor is a call to a WebAssembly function.
   bool IsWasmFunctionCall() const { return kind_ == kCallWasmFunction; }

   bool RequiresFrameAsIncoming() const {
     return IsCFunctionCall() || IsJSFunctionCall() || IsWasmFunctionCall();
   }

   // The number of return values from this call.
   size_t ReturnCount() const { return location_sig_->return_count(); }

   // The number of C parameters to this call.
   size_t ParameterCount() const { return location_sig_->parameter_count(); }

   // The number of stack parameters to the call.
   size_t StackParameterCount() const { return stack_param_count_; }

   // The number of stack return values from the call.
   size_t StackReturnCount() const { return stack_return_count_; }

   // The number of parameters to the JS function call.
   size_t JSParameterCount() const {
     DCHECK(IsJSFunctionCall());
     return stack_param_count_;
   }

   // The total number of inputs to this call, which includes the target,
   // receiver, context, etc.
   // TODO(titzer): this should input the framestate input too.
   size_t InputCount() const { return 1 + location_sig_->parameter_count(); }

   size_t FrameStateCount() const { return NeedsFrameState() ? 1 : 0; }

   Flags flags() const { return flags_; }

   bool NeedsFrameState() const { return flags() & kNeedsFrameState; }
   bool PushArgumentCount() const { return flags() & kPushArgumentCount; }
   bool InitializeRootRegister() const {
     return flags() & kInitializeRootRegister;
   }

   LinkageLocation GetReturnLocation(size_t index) const {
     return location_sig_->GetReturn(index);
   }

   LinkageLocation GetInputLocation(size_t index) const {
     if (index == 0) return target_loc_;
     return location_sig_->GetParam(index - 1);
   }

   MachineSignature* GetMachineSignature(Zone* zone) const;

   MachineType GetReturnType(size_t index) const {
     return location_sig_->GetReturn(index).GetType();
   }

   MachineType GetInputType(size_t index) const {
     if (index == 0) return target_type_;
     return location_sig_->GetParam(index - 1).GetType();
   }

   MachineType GetParameterType(size_t index) const {
     return location_sig_->GetParam(index).GetType();
   }

   // Operator properties describe how this call can be optimized, if at all.
   Operator::Properties properties() const { return properties_; }

   // Get the callee-saved registers, if any, across this call.
   RegList CalleeSavedRegisters() const { return callee_saved_registers_; }

   // Get the callee-saved FP registers, if any, across this call.
   RegList CalleeSavedFPRegisters() const { return callee_saved_fp_registers_; }

   const char* debug_name() const { return debug_name_; }

   bool UsesOnlyRegisters() const;

   bool HasSameReturnLocationsAs(const CallDescriptor* other) const;

   // Returns the first stack slot that is not used by the stack parameters.
   int GetFirstUnusedStackSlot() const;

   int GetStackParameterDelta(const CallDescriptor* tail_caller) const;

   bool CanTailCall(const Node* call) const;

   int CalculateFixedFrameSize() const;

   RegList AllocatableRegisters() const { return allocatable_registers_; }

   bool HasRestrictedAllocatableRegisters() const {
     return allocatable_registers_ != 0;
   }

   void set_save_fp_mode(SaveFPRegsMode mode) { save_fp_mode_ = mode; }

   SaveFPRegsMode get_save_fp_mode() const { return save_fp_mode_; }

  private:
   friend class Linkage;
   SaveFPRegsMode save_fp_mode_ = kSaveFPRegs;

   const Kind kind_;
   const MachineType target_type_;
   const LinkageLocation target_loc_;
   const LocationSignature* const location_sig_;
   const size_t stack_param_count_;
   const size_t stack_return_count_;
   const Operator::Properties properties_;
   const RegList callee_saved_registers_;
   const RegList callee_saved_fp_registers_;
   // Non-zero value means restricting the set of allocatable registers for
   // register allocator to use.
   const RegList allocatable_registers_;
   const Flags flags_;
   const char* const debug_name_;

   DISALLOW_COPY_AND_ASSIGN(CallDescriptor);
 };

 DEFINE_OPERATORS_FOR_FLAGS(CallDescriptor::Flags)

 std::ostream& operator<<(std::ostream& os, const CallDescriptor& d);
 V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
                                            const CallDescriptor::Kind& k);

 // Defines the linkage for a compilation, including the calling conventions
 // for incoming parameters and return value(s) as well as the outgoing calling
 // convention for any kind of call. Linkage is generally architecture-specific.
 //
 // Can be used to translate {arg_index} (i.e. index of the call node input) as
 // well as {param_index} (i.e. as stored in parameter nodes) into an operator
 // representing the architecture-specific location. The following call node
 // layouts are supported (where {n} is the number of value inputs):
 //
 //                        #0          #1     #2     [...]             #n
 // Call[CodeStub]         code,       arg 1, arg 2, [...],            context
 // Call[JSFunction]       function,   rcvr,  arg 1, [...], new, #arg, context
 // Call[Runtime]          CEntry,     arg 1, arg 2, [...], fun, #arg, context
 // Call[BytecodeDispatch] address,    arg 1, arg 2, [...]
 class V8_EXPORT_PRIVATE Linkage : public NON_EXPORTED_BASE(ZoneObject) {
  public:
   explicit Linkage(CallDescriptor* incoming) : incoming_(incoming) {}

   static CallDescriptor* ComputeIncoming(Zone* zone,
                                          OptimizedCompilationInfo* info);

   // The call descriptor for this compilation unit describes the locations
   // of incoming parameters and the outgoing return value(s).
   CallDescriptor* GetIncomingDescriptor() const { return incoming_; }
   static CallDescriptor* GetJSCallDescriptor(Zone* zone, bool is_osr,
                                              int parameter_count,
                                              CallDescriptor::Flags flags);

   static CallDescriptor* GetRuntimeCallDescriptor(
       Zone* zone, Runtime::FunctionId function, int js_parameter_count,
       Operator::Properties properties, CallDescriptor::Flags flags);

   static CallDescriptor* GetCEntryStubCallDescriptor(
       Zone* zone, int return_count, int js_parameter_count,
       const char* debug_name, Operator::Properties properties,
       CallDescriptor::Flags flags);

   static CallDescriptor* GetStubCallDescriptor(
       Zone* zone, const CallInterfaceDescriptor& descriptor,
       int stack_parameter_count, CallDescriptor::Flags flags,
       Operator::Properties properties = Operator::kNoProperties,
       StubCallMode stub_mode = StubCallMode::kCallOnHeapBuiltin);

   static CallDescriptor* GetBytecodeDispatchCallDescriptor(
       Zone* zone, const CallInterfaceDescriptor& descriptor,
       int stack_parameter_count);

   // Creates a call descriptor for simplified C calls that is appropriate
   // for the host platform. This simplified calling convention only supports
   // integers and pointers of one word size each, i.e. no floating point,
   // structs, pointers to members, etc.
   static CallDescriptor* GetSimplifiedCDescriptor(
       Zone* zone, const MachineSignature* sig,
       bool set_initialize_root_flag = false);

   // Get the location of an (incoming) parameter to this function.
   LinkageLocation GetParameterLocation(int index) const {
     return incoming_->GetInputLocation(index + 1);  // + 1 to skip target.
   }

   // Get the machine type of an (incoming) parameter to this function.
   MachineType GetParameterType(int index) const {
     return incoming_->GetInputType(index + 1);  // + 1 to skip target.
   }

   // Get the location where this function should place its return value.
   LinkageLocation GetReturnLocation(size_t index = 0) const {
     return incoming_->GetReturnLocation(index);
   }

   // Get the machine type of this function's return value.
   MachineType GetReturnType(size_t index = 0) const {
     return incoming_->GetReturnType(index);
   }

   bool ParameterHasSecondaryLocation(int index) const;
   LinkageLocation GetParameterSecondaryLocation(int index) const;

   static bool NeedsFrameStateInput(Runtime::FunctionId function);

   // Get the location where an incoming OSR value is stored.
   LinkageLocation GetOsrValueLocation(int index) const;

   // A special {Parameter} index for Stub Calls that represents context.
   static int GetStubCallContextParamIndex(int parameter_count) {
     return parameter_count + 0;  // Parameter (arity + 0) is special.
   }

   // A special {Parameter} index for JSCalls that represents the new target.
   static int GetJSCallNewTargetParamIndex(int parameter_count) {
     return parameter_count + 0;  // Parameter (arity + 0) is special.
   }

   // A special {Parameter} index for JSCalls that represents the argument count.
   static int GetJSCallArgCountParamIndex(int parameter_count) {
     return parameter_count + 1;  // Parameter (arity + 1) is special.
   }

   // A special {Parameter} index for JSCalls that represents the context.
   static int GetJSCallContextParamIndex(int parameter_count) {
     return parameter_count + 2;  // Parameter (arity + 2) is special.
   }

   // A special {Parameter} index for JSCalls that represents the closure.
   static const int kJSCallClosureParamIndex = -1;

   // A special {OsrValue} index to indicate the context spill slot.
   static const int kOsrContextSpillSlotIndex = -1;

   // A special {OsrValue} index to indicate the accumulator register.
   static const int kOsrAccumulatorRegisterIndex = -1;

  private:
   CallDescriptor* const incoming_;

   DISALLOW_COPY_AND_ASSIGN(Linkage);
 };

 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8

 #endif  // V8_COMPILER_LINKAGE_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_H_
	#define V8_COMPILER_LINKAGE_H_

	#include "src/base/compiler-specific.h"
	#include "src/base/flags.h"
	#include "src/compiler/frame.h"
	#include "src/compiler/operator.h"
	#include "src/globals.h"
	#include "src/interface-descriptors.h"
	#include "src/machine-type.h"
	#include "src/reglist.h"
	#include "src/runtime/runtime.h"
	#include "src/signature.h"
	#include "src/zone/zone.h"

	namespace v8 {
	namespace internal {

	class CallInterfaceDescriptor;
	class OptimizedCompilationInfo;

	namespace compiler {

	const RegList kNoCalleeSaved = 0;

	class Node;
	class OsrHelper;

	// Describes the location for a parameter or a return value to a call.
	class LinkageLocation {
	public:
	bool operator==(const LinkageLocation& other) const {
	return bit_field_ == other.bit_field_;
	}

	bool operator!=(const LinkageLocation& other) const {
	return !(*this == other);
	}

	static LinkageLocation ForAnyRegister(
	MachineType type = MachineType::None()) {
	return LinkageLocation(REGISTER, ANY_REGISTER, type);
	}

	static LinkageLocation ForRegister(int32_t reg,
	MachineType type = MachineType::None()) {
	DCHECK_LE(0, reg);
	return LinkageLocation(REGISTER, reg, type);
	}

	static LinkageLocation ForCallerFrameSlot(int32_t slot, MachineType type) {
	DCHECK_GT(0, slot);
	return LinkageLocation(STACK_SLOT, slot, type);
	}

	static LinkageLocation ForCalleeFrameSlot(int32_t slot, MachineType type) {
	// TODO(titzer): bailout instead of crashing here.
	DCHECK(slot >= 0 && slot < LinkageLocation::MAX_STACK_SLOT);
	return LinkageLocation(STACK_SLOT, slot, type);
	}

	static LinkageLocation ForSavedCallerReturnAddress() {
	return ForCalleeFrameSlot((StandardFrameConstants::kCallerPCOffset -
	StandardFrameConstants::kCallerPCOffset) /
	kPointerSize,
	MachineType::Pointer());
	}

	static LinkageLocation ForSavedCallerFramePtr() {
	return ForCalleeFrameSlot((StandardFrameConstants::kCallerPCOffset -
	StandardFrameConstants::kCallerFPOffset) /
	kPointerSize,
	MachineType::Pointer());
	}

	static LinkageLocation ForSavedCallerConstantPool() {
	DCHECK(V8_EMBEDDED_CONSTANT_POOL);
	return ForCalleeFrameSlot((StandardFrameConstants::kCallerPCOffset -
	StandardFrameConstants::kConstantPoolOffset) /
	kPointerSize,
	MachineType::AnyTagged());
	}

	static LinkageLocation ForSavedCallerFunction() {
	return ForCalleeFrameSlot((StandardFrameConstants::kCallerPCOffset -
	StandardFrameConstants::kFunctionOffset) /
	kPointerSize,
	MachineType::AnyTagged());
	}

	static LinkageLocation ConvertToTailCallerLocation(
	LinkageLocation caller_location, int stack_param_delta) {
	if (!caller_location.IsRegister()) {
	return LinkageLocation(STACK_SLOT,
	caller_location.GetLocation() + stack_param_delta,
	caller_location.GetType());
	}
	return caller_location;
	}

	MachineType GetType() const { return machine_type_; }

	int GetSize() const {
	return 1 << ElementSizeLog2Of(GetType().representation());
	}

	int GetSizeInPointers() const {
	// Round up
	return (GetSize() + kPointerSize - 1) / kPointerSize;
	}

	int32_t GetLocation() const {
	// We can't use LocationField::decode here because it doesn't work for
	// negative values!
	return static_cast<int32_t>(bit_field_ & LocationField::kMask) >>
	LocationField::kShift;
	}

	bool IsRegister() const { return TypeField::decode(bit_field_) == REGISTER; }
	bool IsAnyRegister() const {
	return IsRegister() && GetLocation() == ANY_REGISTER;
	}
	bool IsCallerFrameSlot() const { return !IsRegister() && GetLocation() < 0; }
	bool IsCalleeFrameSlot() const { return !IsRegister() && GetLocation() >= 0; }

	int32_t AsRegister() const {
	DCHECK(IsRegister());
	return GetLocation();
	}
	int32_t AsCallerFrameSlot() const {
	DCHECK(IsCallerFrameSlot());
	return GetLocation();
	}
	int32_t AsCalleeFrameSlot() const {
	DCHECK(IsCalleeFrameSlot());
	return GetLocation();
	}

	private:
	enum LocationType { REGISTER, STACK_SLOT };

	class TypeField : public BitField<LocationType, 0, 1> {};
	class LocationField : public BitField<int32_t, TypeField::kNext, 31> {};

	static constexpr int32_t ANY_REGISTER = -1;
	static constexpr int32_t MAX_STACK_SLOT = 32767;

	LinkageLocation(LocationType type, int32_t location,
	MachineType machine_type) {
	bit_field_ = TypeField::encode(type) \|
	((location << LocationField::kShift) & LocationField::kMask);
	machine_type_ = machine_type;
	}

	int32_t bit_field_;
	MachineType machine_type_;
	};

	typedef Signature<LinkageLocation> LocationSignature;

	// Describes a call to various parts of the compiler. Every call has the notion
	// of a "target", which is the first input to the call.
	class V8_EXPORT_PRIVATE CallDescriptor final
	: public NON_EXPORTED_BASE(ZoneObject) {
	public:
	// Describes the kind of this call, which determines the target.
	enum Kind {
	kCallCodeObject, // target is a Code object
	kCallJSFunction, // target is a JSFunction object
	kCallAddress, // target is a machine pointer
	kCallWasmFunction // target is a wasm function
	};

	enum Flag {
	kNoFlags = 0u,
	kNeedsFrameState = 1u << 0,
	kHasExceptionHandler = 1u << 1,
	kCanUseRoots = 1u << 2,
	// Causes the code generator to initialize the root register.
	kInitializeRootRegister = 1u << 3,
	// Does not ever try to allocate space on our heap.
	kNoAllocate = 1u << 4,
	// Push argument count as part of function prologue.
	kPushArgumentCount = 1u << 5,
	// Use retpoline for this call if indirect.
	kRetpoline = 1u << 6,
	// Use the kJavaScriptCallCodeStartRegister (fixed) register for the
	// indirect target address when calling.
	kFixedTargetRegister = 1u << 7
	};
	typedef base::Flags<Flag> Flags;

	CallDescriptor(Kind kind, MachineType target_type, LinkageLocation target_loc,
	LocationSignature* location_sig, size_t stack_param_count,
	Operator::Properties properties,
	RegList callee_saved_registers,
	RegList callee_saved_fp_registers, Flags flags,
	const char* debug_name = "",
	const RegList allocatable_registers = 0,
	size_t stack_return_count = 0)
	: kind_(kind),
	target_type_(target_type),
	target_loc_(target_loc),
	location_sig_(location_sig),
	stack_param_count_(stack_param_count),
	stack_return_count_(stack_return_count),
	properties_(properties),
	callee_saved_registers_(callee_saved_registers),
	callee_saved_fp_registers_(callee_saved_fp_registers),
	allocatable_registers_(allocatable_registers),
	flags_(flags),
	debug_name_(debug_name) {}

	// Returns the kind of this call.
	Kind kind() const { return kind_; }

	// Returns {true} if this descriptor is a call to a C function.
	bool IsCFunctionCall() const { return kind_ == kCallAddress; }

	// Returns {true} if this descriptor is a call to a JSFunction.
	bool IsJSFunctionCall() const { return kind_ == kCallJSFunction; }

	// Returns {true} if this descriptor is a call to a WebAssembly function.
	bool IsWasmFunctionCall() const { return kind_ == kCallWasmFunction; }

	bool RequiresFrameAsIncoming() const {
	return IsCFunctionCall() \|\| IsJSFunctionCall() \|\| IsWasmFunctionCall();
	}

	// The number of return values from this call.
	size_t ReturnCount() const { return location_sig_->return_count(); }

	// The number of C parameters to this call.
	size_t ParameterCount() const { return location_sig_->parameter_count(); }

	// The number of stack parameters to the call.
	size_t StackParameterCount() const { return stack_param_count_; }

	// The number of stack return values from the call.
	size_t StackReturnCount() const { return stack_return_count_; }

	// The number of parameters to the JS function call.
	size_t JSParameterCount() const {
	DCHECK(IsJSFunctionCall());
	return stack_param_count_;
	}

	// The total number of inputs to this call, which includes the target,
	// receiver, context, etc.
	// TODO(titzer): this should input the framestate input too.
	size_t InputCount() const { return 1 + location_sig_->parameter_count(); }

	size_t FrameStateCount() const { return NeedsFrameState() ? 1 : 0; }

	Flags flags() const { return flags_; }

	bool NeedsFrameState() const { return flags() & kNeedsFrameState; }
	bool PushArgumentCount() const { return flags() & kPushArgumentCount; }
	bool InitializeRootRegister() const {
	return flags() & kInitializeRootRegister;
	}

	LinkageLocation GetReturnLocation(size_t index) const {
	return location_sig_->GetReturn(index);
	}

	LinkageLocation GetInputLocation(size_t index) const {
	if (index == 0) return target_loc_;
	return location_sig_->GetParam(index - 1);
	}

	MachineSignature* GetMachineSignature(Zone* zone) const;

	MachineType GetReturnType(size_t index) const {
	return location_sig_->GetReturn(index).GetType();
	}

	MachineType GetInputType(size_t index) const {
	if (index == 0) return target_type_;
	return location_sig_->GetParam(index - 1).GetType();
	}

	MachineType GetParameterType(size_t index) const {
	return location_sig_->GetParam(index).GetType();
	}

	// Operator properties describe how this call can be optimized, if at all.
	Operator::Properties properties() const { return properties_; }

	// Get the callee-saved registers, if any, across this call.
	RegList CalleeSavedRegisters() const { return callee_saved_registers_; }

	// Get the callee-saved FP registers, if any, across this call.
	RegList CalleeSavedFPRegisters() const { return callee_saved_fp_registers_; }

	const char* debug_name() const { return debug_name_; }

	bool UsesOnlyRegisters() const;

	bool HasSameReturnLocationsAs(const CallDescriptor* other) const;

	// Returns the first stack slot that is not used by the stack parameters.
	int GetFirstUnusedStackSlot() const;

	int GetStackParameterDelta(const CallDescriptor* tail_caller) const;

	bool CanTailCall(const Node* call) const;

	int CalculateFixedFrameSize() const;

	RegList AllocatableRegisters() const { return allocatable_registers_; }

	bool HasRestrictedAllocatableRegisters() const {
	return allocatable_registers_ != 0;
	}

	void set_save_fp_mode(SaveFPRegsMode mode) { save_fp_mode_ = mode; }

	SaveFPRegsMode get_save_fp_mode() const { return save_fp_mode_; }

	private:
	friend class Linkage;
	SaveFPRegsMode save_fp_mode_ = kSaveFPRegs;

	const Kind kind_;
	const MachineType target_type_;
	const LinkageLocation target_loc_;
	const LocationSignature* const location_sig_;
	const size_t stack_param_count_;
	const size_t stack_return_count_;
	const Operator::Properties properties_;
	const RegList callee_saved_registers_;
	const RegList callee_saved_fp_registers_;
	// Non-zero value means restricting the set of allocatable registers for
	// register allocator to use.
	const RegList allocatable_registers_;
	const Flags flags_;
	const char* const debug_name_;

	DISALLOW_COPY_AND_ASSIGN(CallDescriptor);
	};

	DEFINE_OPERATORS_FOR_FLAGS(CallDescriptor::Flags)

	std::ostream& operator<<(std::ostream& os, const CallDescriptor& d);
	V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
	const CallDescriptor::Kind& k);

	// Defines the linkage for a compilation, including the calling conventions
	// for incoming parameters and return value(s) as well as the outgoing calling
	// convention for any kind of call. Linkage is generally architecture-specific.
	//
	// Can be used to translate {arg_index} (i.e. index of the call node input) as
	// well as {param_index} (i.e. as stored in parameter nodes) into an operator
	// representing the architecture-specific location. The following call node
	// layouts are supported (where {n} is the number of value inputs):
	//
	// #0 #1 #2 [...] #n
	// Call[CodeStub] code, arg 1, arg 2, [...], context
	// Call[JSFunction] function, rcvr, arg 1, [...], new, #arg, context
	// Call[Runtime] CEntry, arg 1, arg 2, [...], fun, #arg, context
	// Call[BytecodeDispatch] address, arg 1, arg 2, [...]
	class V8_EXPORT_PRIVATE Linkage : public NON_EXPORTED_BASE(ZoneObject) {
	public:
	explicit Linkage(CallDescriptor* incoming) : incoming_(incoming) {}

	static CallDescriptor* ComputeIncoming(Zone* zone,
	OptimizedCompilationInfo* info);

	// The call descriptor for this compilation unit describes the locations
	// of incoming parameters and the outgoing return value(s).
	CallDescriptor* GetIncomingDescriptor() const { return incoming_; }
	static CallDescriptor* GetJSCallDescriptor(Zone* zone, bool is_osr,
	int parameter_count,
	CallDescriptor::Flags flags);

	static CallDescriptor* GetRuntimeCallDescriptor(
	Zone* zone, Runtime::FunctionId function, int js_parameter_count,
	Operator::Properties properties, CallDescriptor::Flags flags);

	static CallDescriptor* GetCEntryStubCallDescriptor(
	Zone* zone, int return_count, int js_parameter_count,
	const char* debug_name, Operator::Properties properties,
	CallDescriptor::Flags flags);

	static CallDescriptor* GetStubCallDescriptor(
	Zone* zone, const CallInterfaceDescriptor& descriptor,
	int stack_parameter_count, CallDescriptor::Flags flags,
	Operator::Properties properties = Operator::kNoProperties,
	StubCallMode stub_mode = StubCallMode::kCallOnHeapBuiltin);

	static CallDescriptor* GetBytecodeDispatchCallDescriptor(
	Zone* zone, const CallInterfaceDescriptor& descriptor,
	int stack_parameter_count);

	// Creates a call descriptor for simplified C calls that is appropriate
	// for the host platform. This simplified calling convention only supports
	// integers and pointers of one word size each, i.e. no floating point,
	// structs, pointers to members, etc.
	static CallDescriptor* GetSimplifiedCDescriptor(
	Zone* zone, const MachineSignature* sig,
	bool set_initialize_root_flag = false);

	// Get the location of an (incoming) parameter to this function.
	LinkageLocation GetParameterLocation(int index) const {
	return incoming_->GetInputLocation(index + 1); // + 1 to skip target.
	}

	// Get the machine type of an (incoming) parameter to this function.
	MachineType GetParameterType(int index) const {
	return incoming_->GetInputType(index + 1); // + 1 to skip target.
	}

	// Get the location where this function should place its return value.
	LinkageLocation GetReturnLocation(size_t index = 0) const {
	return incoming_->GetReturnLocation(index);
	}

	// Get the machine type of this function's return value.
	MachineType GetReturnType(size_t index = 0) const {
	return incoming_->GetReturnType(index);
	}

	bool ParameterHasSecondaryLocation(int index) const;
	LinkageLocation GetParameterSecondaryLocation(int index) const;

	static bool NeedsFrameStateInput(Runtime::FunctionId function);

	// Get the location where an incoming OSR value is stored.
	LinkageLocation GetOsrValueLocation(int index) const;

	// A special {Parameter} index for Stub Calls that represents context.
	static int GetStubCallContextParamIndex(int parameter_count) {
	return parameter_count + 0; // Parameter (arity + 0) is special.
	}

	// A special {Parameter} index for JSCalls that represents the new target.
	static int GetJSCallNewTargetParamIndex(int parameter_count) {
	return parameter_count + 0; // Parameter (arity + 0) is special.
	}

	// A special {Parameter} index for JSCalls that represents the argument count.
	static int GetJSCallArgCountParamIndex(int parameter_count) {
	return parameter_count + 1; // Parameter (arity + 1) is special.
	}

	// A special {Parameter} index for JSCalls that represents the context.
	static int GetJSCallContextParamIndex(int parameter_count) {
	return parameter_count + 2; // Parameter (arity + 2) is special.
	}

	// A special {Parameter} index for JSCalls that represents the closure.
	static const int kJSCallClosureParamIndex = -1;

	// A special {OsrValue} index to indicate the context spill slot.
	static const int kOsrContextSpillSlotIndex = -1;

	// A special {OsrValue} index to indicate the accumulator register.
	static const int kOsrAccumulatorRegisterIndex = -1;

	private:
	CallDescriptor* const incoming_;

	DISALLOW_COPY_AND_ASSIGN(Linkage);
	};

	} // namespace compiler
	} // namespace internal
	} // namespace v8

	#endif // V8_COMPILER_LINKAGE_H_