blob: c5cef5e35fdfbab7a52fc646bb168aec9d557956 [file] [log] [blame]
Ben Murdochb8a8cc12014-11-26 15:28:44 +00001// Copyright 2014 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef V8_COMPILER_LINKAGE_H_
6#define V8_COMPILER_LINKAGE_H_
7
8#include "src/base/flags.h"
9#include "src/code-stubs.h"
10#include "src/compiler/frame.h"
11#include "src/compiler/machine-type.h"
12#include "src/compiler/node.h"
13#include "src/compiler/operator.h"
14#include "src/zone.h"
15
16namespace v8 {
17namespace internal {
18namespace compiler {
19
20// Describes the location for a parameter or a return value to a call.
21class LinkageLocation {
22 public:
23 explicit LinkageLocation(int location) : location_(location) {}
24
25 static const int16_t ANY_REGISTER = 32767;
26
27 static LinkageLocation AnyRegister() { return LinkageLocation(ANY_REGISTER); }
28
29 private:
30 friend class CallDescriptor;
31 friend class OperandGenerator;
32 int16_t location_; // >= 0 implies register, otherwise stack slot.
33};
34
35typedef Signature<LinkageLocation> LocationSignature;
36
37// Describes a call to various parts of the compiler. Every call has the notion
38// of a "target", which is the first input to the call.
39class CallDescriptor FINAL : public ZoneObject {
40 public:
41 // Describes the kind of this call, which determines the target.
42 enum Kind {
43 kCallCodeObject, // target is a Code object
44 kCallJSFunction, // target is a JSFunction object
45 kCallAddress // target is a machine pointer
46 };
47
48 enum Flag {
49 // TODO(jarin) kLazyDeoptimization and kNeedsFrameState should be unified.
50 kNoFlags = 0u,
51 kNeedsFrameState = 1u << 0,
52 kPatchableCallSite = 1u << 1,
53 kNeedsNopAfterCall = 1u << 2,
54 kPatchableCallSiteWithNop = kPatchableCallSite | kNeedsNopAfterCall
55 };
56 typedef base::Flags<Flag> Flags;
57
58 CallDescriptor(Kind kind, MachineType target_type, LinkageLocation target_loc,
59 MachineSignature* machine_sig, LocationSignature* location_sig,
60 size_t js_param_count, Operator::Properties properties,
61 RegList callee_saved_registers, Flags flags,
62 const char* debug_name = "")
63 : kind_(kind),
64 target_type_(target_type),
65 target_loc_(target_loc),
66 machine_sig_(machine_sig),
67 location_sig_(location_sig),
68 js_param_count_(js_param_count),
69 properties_(properties),
70 callee_saved_registers_(callee_saved_registers),
71 flags_(flags),
72 debug_name_(debug_name) {
73 DCHECK(machine_sig->return_count() == location_sig->return_count());
74 DCHECK(machine_sig->parameter_count() == location_sig->parameter_count());
75 }
76
77 // Returns the kind of this call.
78 Kind kind() const { return kind_; }
79
80 // Returns {true} if this descriptor is a call to a JSFunction.
81 bool IsJSFunctionCall() const { return kind_ == kCallJSFunction; }
82
83 // The number of return values from this call.
84 size_t ReturnCount() const { return machine_sig_->return_count(); }
85
86 // The number of JavaScript parameters to this call, including the receiver
87 // object.
88 size_t JSParameterCount() const { return js_param_count_; }
89
90 // The total number of inputs to this call, which includes the target,
91 // receiver, context, etc.
92 // TODO(titzer): this should input the framestate input too.
93 size_t InputCount() const { return 1 + machine_sig_->parameter_count(); }
94
95 size_t FrameStateCount() const { return NeedsFrameState() ? 1 : 0; }
96
97 Flags flags() const { return flags_; }
98
99 bool NeedsFrameState() const { return flags() & kNeedsFrameState; }
100
101 LinkageLocation GetReturnLocation(size_t index) const {
102 return location_sig_->GetReturn(index);
103 }
104
105 LinkageLocation GetInputLocation(size_t index) const {
106 if (index == 0) return target_loc_;
107 return location_sig_->GetParam(index - 1);
108 }
109
110 const MachineSignature* GetMachineSignature() const { return machine_sig_; }
111
112 MachineType GetReturnType(size_t index) const {
113 return machine_sig_->GetReturn(index);
114 }
115
116 MachineType GetInputType(size_t index) const {
117 if (index == 0) return target_type_;
118 return machine_sig_->GetParam(index - 1);
119 }
120
121 // Operator properties describe how this call can be optimized, if at all.
122 Operator::Properties properties() const { return properties_; }
123
124 // Get the callee-saved registers, if any, across this call.
125 RegList CalleeSavedRegisters() const { return callee_saved_registers_; }
126
127 const char* debug_name() const { return debug_name_; }
128
129 private:
130 friend class Linkage;
131
132 Kind kind_;
133 MachineType target_type_;
134 LinkageLocation target_loc_;
135 MachineSignature* machine_sig_;
136 LocationSignature* location_sig_;
137 size_t js_param_count_;
138 Operator::Properties properties_;
139 RegList callee_saved_registers_;
140 Flags flags_;
141 const char* debug_name_;
142};
143
144DEFINE_OPERATORS_FOR_FLAGS(CallDescriptor::Flags)
145
146OStream& operator<<(OStream& os, const CallDescriptor& d);
147OStream& operator<<(OStream& os, const CallDescriptor::Kind& k);
148
149// Defines the linkage for a compilation, including the calling conventions
150// for incoming parameters and return value(s) as well as the outgoing calling
151// convention for any kind of call. Linkage is generally architecture-specific.
152//
153// Can be used to translate {arg_index} (i.e. index of the call node input) as
154// well as {param_index} (i.e. as stored in parameter nodes) into an operator
155// representing the architecture-specific location. The following call node
156// layouts are supported (where {n} is the number value inputs):
157//
158// #0 #1 #2 #3 [...] #n
159// Call[CodeStub] code, arg 1, arg 2, arg 3, [...], context
160// Call[JSFunction] function, rcvr, arg 1, arg 2, [...], context
161// Call[Runtime] CEntryStub, arg 1, arg 2, arg 3, [...], fun, #arg, context
162class Linkage : public ZoneObject {
163 public:
164 explicit Linkage(CompilationInfo* info);
165 explicit Linkage(CompilationInfo* info, CallDescriptor* incoming)
166 : info_(info), incoming_(incoming) {}
167
168 // The call descriptor for this compilation unit describes the locations
169 // of incoming parameters and the outgoing return value(s).
170 CallDescriptor* GetIncomingDescriptor() { return incoming_; }
171 CallDescriptor* GetJSCallDescriptor(int parameter_count);
172 static CallDescriptor* GetJSCallDescriptor(int parameter_count, Zone* zone);
173 CallDescriptor* GetRuntimeCallDescriptor(Runtime::FunctionId function,
174 int parameter_count,
175 Operator::Properties properties);
176 static CallDescriptor* GetRuntimeCallDescriptor(
177 Runtime::FunctionId function, int parameter_count,
178 Operator::Properties properties, Zone* zone);
179
180 CallDescriptor* GetStubCallDescriptor(
181 CallInterfaceDescriptor descriptor, int stack_parameter_count = 0,
182 CallDescriptor::Flags flags = CallDescriptor::kNoFlags);
183 static CallDescriptor* GetStubCallDescriptor(
184 CallInterfaceDescriptor descriptor, int stack_parameter_count,
185 CallDescriptor::Flags flags, Zone* zone);
186
187 // Creates a call descriptor for simplified C calls that is appropriate
188 // for the host platform. This simplified calling convention only supports
189 // integers and pointers of one word size each, i.e. no floating point,
190 // structs, pointers to members, etc.
191 static CallDescriptor* GetSimplifiedCDescriptor(Zone* zone,
192 MachineSignature* sig);
193
194 // Get the location of an (incoming) parameter to this function.
195 LinkageLocation GetParameterLocation(int index) {
196 return incoming_->GetInputLocation(index + 1); // + 1 to skip target.
197 }
198
199 // Get the machine type of an (incoming) parameter to this function.
200 MachineType GetParameterType(int index) {
201 return incoming_->GetInputType(index + 1); // + 1 to skip target.
202 }
203
204 // Get the location where this function should place its return value.
205 LinkageLocation GetReturnLocation() {
206 return incoming_->GetReturnLocation(0);
207 }
208
209 // Get the machine type of this function's return value.
210 MachineType GetReturnType() { return incoming_->GetReturnType(0); }
211
212 // Get the frame offset for a given spill slot. The location depends on the
213 // calling convention and the specific frame layout, and may thus be
214 // architecture-specific. Negative spill slots indicate arguments on the
215 // caller's frame. The {extra} parameter indicates an additional offset from
216 // the frame offset, e.g. to index into part of a double slot.
217 FrameOffset GetFrameOffset(int spill_slot, Frame* frame, int extra = 0);
218
219 CompilationInfo* info() const { return info_; }
220
221 static bool NeedsFrameState(Runtime::FunctionId function);
222
223 private:
224 CompilationInfo* info_;
225 CallDescriptor* incoming_;
226};
227
228} // namespace compiler
229} // namespace internal
230} // namespace v8
231
232#endif // V8_COMPILER_LINKAGE_H_