1 // 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 #include "src/ast/scopes.h"
6 #include "src/code-stubs.h"
7 #include "src/compiler.h"
8 #include "src/compiler/common-operator.h"
9 #include "src/compiler/frame.h"
10 #include "src/compiler/linkage.h"
11 #include "src/compiler/node.h"
12 #include "src/compiler/osr.h"
13 #include "src/compiler/pipeline.h"
14
15 namespace v8 {
16 namespace internal {
17 namespace compiler {
18
19 namespace {
regloc(Register reg)20 LinkageLocation regloc(Register reg) {
21 return LinkageLocation::ForRegister(reg.code());
22 }
23
24
reptyp(Representation representation)25 MachineType reptyp(Representation representation) {
26 switch (representation.kind()) {
27 case Representation::kInteger8:
28 return MachineType::Int8();
29 case Representation::kUInteger8:
30 return MachineType::Uint8();
31 case Representation::kInteger16:
32 return MachineType::Int16();
33 case Representation::kUInteger16:
34 return MachineType::Uint16();
35 case Representation::kInteger32:
36 return MachineType::Int32();
37 case Representation::kSmi:
38 case Representation::kTagged:
39 case Representation::kHeapObject:
40 return MachineType::AnyTagged();
41 case Representation::kDouble:
42 return MachineType::Float64();
43 case Representation::kExternal:
44 return MachineType::Pointer();
45 case Representation::kNone:
46 case Representation::kNumRepresentations:
47 break;
48 }
49 UNREACHABLE();
50 return MachineType::None();
51 }
52 } // namespace
53
54
operator <<(std::ostream & os,const CallDescriptor::Kind & k)55 std::ostream& operator<<(std::ostream& os, const CallDescriptor::Kind& k) {
56 switch (k) {
57 case CallDescriptor::kCallCodeObject:
58 os << "Code";
59 break;
60 case CallDescriptor::kCallJSFunction:
61 os << "JS";
62 break;
63 case CallDescriptor::kCallAddress:
64 os << "Addr";
65 break;
66 case CallDescriptor::kLazyBailout:
67 os << "LazyBail";
68 break;
69 }
70 return os;
71 }
72
73
operator <<(std::ostream & os,const CallDescriptor & d)74 std::ostream& operator<<(std::ostream& os, const CallDescriptor& d) {
75 // TODO(svenpanne) Output properties etc. and be less cryptic.
76 return os << d.kind() << ":" << d.debug_name() << ":r" << d.ReturnCount()
77 << "s" << d.StackParameterCount() << "i" << d.InputCount() << "f"
78 << d.FrameStateCount() << "t" << d.SupportsTailCalls();
79 }
80
81
HasSameReturnLocationsAs(const CallDescriptor * other) const82 bool CallDescriptor::HasSameReturnLocationsAs(
83 const CallDescriptor* other) const {
84 if (ReturnCount() != other->ReturnCount()) return false;
85 for (size_t i = 0; i < ReturnCount(); ++i) {
86 if (GetReturnLocation(i) != other->GetReturnLocation(i)) return false;
87 }
88 return true;
89 }
90
91
CanTailCall(const Node * node,int * stack_param_delta) const92 bool CallDescriptor::CanTailCall(const Node* node,
93 int* stack_param_delta) const {
94 CallDescriptor const* other = OpParameter<CallDescriptor const*>(node);
95 size_t current_input = 0;
96 size_t other_input = 0;
97 *stack_param_delta = 0;
98 bool more_other = true;
99 bool more_this = true;
100 while (more_other || more_this) {
101 if (other_input < other->InputCount()) {
102 if (!other->GetInputLocation(other_input).IsRegister()) {
103 (*stack_param_delta)--;
104 }
105 } else {
106 more_other = false;
107 }
108 if (current_input < InputCount()) {
109 if (!GetInputLocation(current_input).IsRegister()) {
110 (*stack_param_delta)++;
111 }
112 } else {
113 more_this = false;
114 }
115 ++current_input;
116 ++other_input;
117 }
118 return HasSameReturnLocationsAs(OpParameter<CallDescriptor const*>(node));
119 }
120
121
ComputeIncoming(Zone * zone,CompilationInfo * info)122 CallDescriptor* Linkage::ComputeIncoming(Zone* zone, CompilationInfo* info) {
123 if (info->code_stub() != nullptr) {
124 // Use the code stub interface descriptor.
125 CodeStub* stub = info->code_stub();
126 CallInterfaceDescriptor descriptor = stub->GetCallInterfaceDescriptor();
127 return GetStubCallDescriptor(
128 info->isolate(), zone, descriptor, stub->GetStackParameterCount(),
129 CallDescriptor::kNoFlags, Operator::kNoProperties);
130 }
131 if (info->has_literal()) {
132 // If we already have the function literal, use the number of parameters
133 // plus the receiver.
134 return GetJSCallDescriptor(zone, info->is_osr(),
135 1 + info->literal()->parameter_count(),
136 CallDescriptor::kNoFlags);
137 }
138 if (!info->closure().is_null()) {
139 // If we are compiling a JS function, use a JS call descriptor,
140 // plus the receiver.
141 SharedFunctionInfo* shared = info->closure()->shared();
142 return GetJSCallDescriptor(zone, info->is_osr(),
143 1 + shared->internal_formal_parameter_count(),
144 CallDescriptor::kNoFlags);
145 }
146 return nullptr; // TODO(titzer): ?
147 }
148
149
150 // static
FrameStateInputCount(Runtime::FunctionId function)151 int Linkage::FrameStateInputCount(Runtime::FunctionId function) {
152 // Most runtime functions need a FrameState. A few chosen ones that we know
153 // not to call into arbitrary JavaScript, not to throw, and not to deoptimize
154 // are blacklisted here and can be called without a FrameState.
155 switch (function) {
156 case Runtime::kAllocateInTargetSpace:
157 case Runtime::kCreateIterResultObject:
158 case Runtime::kDefineClassMethod: // TODO(jarin): Is it safe?
159 case Runtime::kDefineGetterPropertyUnchecked: // TODO(jarin): Is it safe?
160 case Runtime::kDefineSetterPropertyUnchecked: // TODO(jarin): Is it safe?
161 case Runtime::kFinalizeClassDefinition: // TODO(conradw): Is it safe?
162 case Runtime::kForInDone:
163 case Runtime::kForInStep:
164 case Runtime::kGetSuperConstructor:
165 case Runtime::kNewClosure:
166 case Runtime::kNewClosure_Tenured:
167 case Runtime::kNewFunctionContext:
168 case Runtime::kPushBlockContext:
169 case Runtime::kPushCatchContext:
170 case Runtime::kReThrow:
171 case Runtime::kStringCompare:
172 case Runtime::kStringEquals:
173 case Runtime::kToFastProperties: // TODO(jarin): Is it safe?
174 case Runtime::kTraceEnter:
175 case Runtime::kTraceExit:
176 return 0;
177 case Runtime::kInlineArguments:
178 case Runtime::kInlineArgumentsLength:
179 case Runtime::kInlineGetPrototype:
180 case Runtime::kInlineRegExpConstructResult:
181 case Runtime::kInlineRegExpExec:
182 case Runtime::kInlineSubString:
183 case Runtime::kInlineToInteger:
184 case Runtime::kInlineToLength:
185 case Runtime::kInlineToName:
186 case Runtime::kInlineToNumber:
187 case Runtime::kInlineToObject:
188 case Runtime::kInlineToPrimitive_Number:
189 case Runtime::kInlineToPrimitive_String:
190 case Runtime::kInlineToPrimitive:
191 case Runtime::kInlineToString:
192 return 1;
193 case Runtime::kInlineCall:
194 case Runtime::kInlineTailCall:
195 case Runtime::kInlineDeoptimizeNow:
196 case Runtime::kInlineThrowNotDateError:
197 return 2;
198 default:
199 break;
200 }
201
202 // Most inlined runtime functions (except the ones listed above) can be called
203 // without a FrameState or will be lowered by JSIntrinsicLowering internally.
204 const Runtime::Function* const f = Runtime::FunctionForId(function);
205 if (f->intrinsic_type == Runtime::IntrinsicType::INLINE) return 0;
206
207 return 1;
208 }
209
210
UsesOnlyRegisters() const211 bool CallDescriptor::UsesOnlyRegisters() const {
212 for (size_t i = 0; i < InputCount(); ++i) {
213 if (!GetInputLocation(i).IsRegister()) return false;
214 }
215 for (size_t i = 0; i < ReturnCount(); ++i) {
216 if (!GetReturnLocation(i).IsRegister()) return false;
217 }
218 return true;
219 }
220
221
GetRuntimeCallDescriptor(Zone * zone,Runtime::FunctionId function_id,int js_parameter_count,Operator::Properties properties,CallDescriptor::Flags flags)222 CallDescriptor* Linkage::GetRuntimeCallDescriptor(
223 Zone* zone, Runtime::FunctionId function_id, int js_parameter_count,
224 Operator::Properties properties, CallDescriptor::Flags flags) {
225 const size_t function_count = 1;
226 const size_t num_args_count = 1;
227 const size_t context_count = 1;
228 const size_t parameter_count = function_count +
229 static_cast<size_t>(js_parameter_count) +
230 num_args_count + context_count;
231
232 const Runtime::Function* function = Runtime::FunctionForId(function_id);
233 const size_t return_count = static_cast<size_t>(function->result_size);
234
235 LocationSignature::Builder locations(zone, return_count, parameter_count);
236 MachineSignature::Builder types(zone, return_count, parameter_count);
237
238 // Add returns.
239 if (locations.return_count_ > 0) {
240 locations.AddReturn(regloc(kReturnRegister0));
241 }
242 if (locations.return_count_ > 1) {
243 locations.AddReturn(regloc(kReturnRegister1));
244 }
245 for (size_t i = 0; i < return_count; i++) {
246 types.AddReturn(MachineType::AnyTagged());
247 }
248
249 // All parameters to the runtime call go on the stack.
250 for (int i = 0; i < js_parameter_count; i++) {
251 locations.AddParam(
252 LinkageLocation::ForCallerFrameSlot(i - js_parameter_count));
253 types.AddParam(MachineType::AnyTagged());
254 }
255 // Add runtime function itself.
256 locations.AddParam(regloc(kRuntimeCallFunctionRegister));
257 types.AddParam(MachineType::AnyTagged());
258
259 // Add runtime call argument count.
260 locations.AddParam(regloc(kRuntimeCallArgCountRegister));
261 types.AddParam(MachineType::Pointer());
262
263 // Add context.
264 locations.AddParam(regloc(kContextRegister));
265 types.AddParam(MachineType::AnyTagged());
266
267 if (Linkage::FrameStateInputCount(function_id) == 0) {
268 flags = static_cast<CallDescriptor::Flags>(
269 flags & ~CallDescriptor::kNeedsFrameState);
270 }
271
272 // The target for runtime calls is a code object.
273 MachineType target_type = MachineType::AnyTagged();
274 LinkageLocation target_loc = LinkageLocation::ForAnyRegister();
275 return new (zone) CallDescriptor( // --
276 CallDescriptor::kCallCodeObject, // kind
277 target_type, // target MachineType
278 target_loc, // target location
279 types.Build(), // machine_sig
280 locations.Build(), // location_sig
281 js_parameter_count, // stack_parameter_count
282 properties, // properties
283 kNoCalleeSaved, // callee-saved
284 kNoCalleeSaved, // callee-saved fp
285 flags, // flags
286 function->name); // debug name
287 }
288
289
GetLazyBailoutDescriptor(Zone * zone)290 CallDescriptor* Linkage::GetLazyBailoutDescriptor(Zone* zone) {
291 const size_t return_count = 0;
292 const size_t parameter_count = 0;
293
294 LocationSignature::Builder locations(zone, return_count, parameter_count);
295 MachineSignature::Builder types(zone, return_count, parameter_count);
296
297 // The target is ignored, but we need to give some values here.
298 MachineType target_type = MachineType::AnyTagged();
299 LinkageLocation target_loc = regloc(kJSFunctionRegister);
300 return new (zone) CallDescriptor( // --
301 CallDescriptor::kLazyBailout, // kind
302 target_type, // target MachineType
303 target_loc, // target location
304 types.Build(), // machine_sig
305 locations.Build(), // location_sig
306 0, // stack_parameter_count
307 Operator::kNoThrow, // properties
308 kNoCalleeSaved, // callee-saved
309 kNoCalleeSaved, // callee-saved fp
310 CallDescriptor::kNeedsFrameState, // flags
311 "lazy-bailout");
312 }
313
314
GetJSCallDescriptor(Zone * zone,bool is_osr,int js_parameter_count,CallDescriptor::Flags flags)315 CallDescriptor* Linkage::GetJSCallDescriptor(Zone* zone, bool is_osr,
316 int js_parameter_count,
317 CallDescriptor::Flags flags) {
318 const size_t return_count = 1;
319 const size_t context_count = 1;
320 const size_t new_target_count = 1;
321 const size_t num_args_count = 1;
322 const size_t parameter_count =
323 js_parameter_count + new_target_count + num_args_count + context_count;
324
325 LocationSignature::Builder locations(zone, return_count, parameter_count);
326 MachineSignature::Builder types(zone, return_count, parameter_count);
327
328 // All JS calls have exactly one return value.
329 locations.AddReturn(regloc(kReturnRegister0));
330 types.AddReturn(MachineType::AnyTagged());
331
332 // All parameters to JS calls go on the stack.
333 for (int i = 0; i < js_parameter_count; i++) {
334 int spill_slot_index = i - js_parameter_count;
335 locations.AddParam(LinkageLocation::ForCallerFrameSlot(spill_slot_index));
336 types.AddParam(MachineType::AnyTagged());
337 }
338
339 // Add JavaScript call new target value.
340 locations.AddParam(regloc(kJavaScriptCallNewTargetRegister));
341 types.AddParam(MachineType::AnyTagged());
342
343 // Add JavaScript call argument count.
344 locations.AddParam(regloc(kJavaScriptCallArgCountRegister));
345 types.AddParam(MachineType::Int32());
346
347 // Add context.
348 locations.AddParam(regloc(kContextRegister));
349 types.AddParam(MachineType::AnyTagged());
350
351 // The target for JS function calls is the JSFunction object.
352 MachineType target_type = MachineType::AnyTagged();
353 // TODO(titzer): When entering into an OSR function from unoptimized code,
354 // the JSFunction is not in a register, but it is on the stack in an
355 // unaddressable spill slot. We hack this in the OSR prologue. Fix.
356 LinkageLocation target_loc = regloc(kJSFunctionRegister);
357 return new (zone) CallDescriptor( // --
358 CallDescriptor::kCallJSFunction, // kind
359 target_type, // target MachineType
360 target_loc, // target location
361 types.Build(), // machine_sig
362 locations.Build(), // location_sig
363 js_parameter_count, // stack_parameter_count
364 Operator::kNoProperties, // properties
365 kNoCalleeSaved, // callee-saved
366 kNoCalleeSaved, // callee-saved fp
367 CallDescriptor::kCanUseRoots | // flags
368 flags, // flags
369 "js-call");
370 }
371
372
GetInterpreterDispatchDescriptor(Zone * zone)373 CallDescriptor* Linkage::GetInterpreterDispatchDescriptor(Zone* zone) {
374 MachineSignature::Builder types(zone, 0, 6);
375 LocationSignature::Builder locations(zone, 0, 6);
376
377 // Add registers for fixed parameters passed via interpreter dispatch.
378 STATIC_ASSERT(0 == Linkage::kInterpreterAccumulatorParameter);
379 types.AddParam(MachineType::AnyTagged());
380 locations.AddParam(regloc(kInterpreterAccumulatorRegister));
381
382 STATIC_ASSERT(1 == Linkage::kInterpreterRegisterFileParameter);
383 types.AddParam(MachineType::Pointer());
384 locations.AddParam(regloc(kInterpreterRegisterFileRegister));
385
386 STATIC_ASSERT(2 == Linkage::kInterpreterBytecodeOffsetParameter);
387 types.AddParam(MachineType::IntPtr());
388 locations.AddParam(regloc(kInterpreterBytecodeOffsetRegister));
389
390 STATIC_ASSERT(3 == Linkage::kInterpreterBytecodeArrayParameter);
391 types.AddParam(MachineType::AnyTagged());
392 locations.AddParam(regloc(kInterpreterBytecodeArrayRegister));
393
394 STATIC_ASSERT(4 == Linkage::kInterpreterDispatchTableParameter);
395 types.AddParam(MachineType::Pointer());
396 #if defined(V8_TARGET_ARCH_IA32) || defined(V8_TARGET_ARCH_X87)
397 // TODO(rmcilroy): Make the context param the one spilled to the stack once
398 // Turbofan supports modified stack arguments in tail calls.
399 locations.AddParam(
400 LinkageLocation::ForCallerFrameSlot(kInterpreterDispatchTableSpillSlot));
401 #else
402 locations.AddParam(regloc(kInterpreterDispatchTableRegister));
403 #endif
404
405 STATIC_ASSERT(5 == Linkage::kInterpreterContextParameter);
406 types.AddParam(MachineType::AnyTagged());
407 locations.AddParam(regloc(kContextRegister));
408
409 LinkageLocation target_loc = LinkageLocation::ForAnyRegister();
410 return new (zone) CallDescriptor( // --
411 CallDescriptor::kCallCodeObject, // kind
412 MachineType::None(), // target MachineType
413 target_loc, // target location
414 types.Build(), // machine_sig
415 locations.Build(), // location_sig
416 0, // stack_parameter_count
417 Operator::kNoProperties, // properties
418 kNoCalleeSaved, // callee-saved registers
419 kNoCalleeSaved, // callee-saved fp regs
420 CallDescriptor::kSupportsTailCalls | // flags
421 CallDescriptor::kCanUseRoots, // flags
422 "interpreter-dispatch");
423 }
424
425
426 // TODO(all): Add support for return representations/locations to
427 // CallInterfaceDescriptor.
428 // TODO(turbofan): cache call descriptors for code stub calls.
GetStubCallDescriptor(Isolate * isolate,Zone * zone,const CallInterfaceDescriptor & descriptor,int stack_parameter_count,CallDescriptor::Flags flags,Operator::Properties properties,MachineType return_type,size_t return_count)429 CallDescriptor* Linkage::GetStubCallDescriptor(
430 Isolate* isolate, Zone* zone, const CallInterfaceDescriptor& descriptor,
431 int stack_parameter_count, CallDescriptor::Flags flags,
432 Operator::Properties properties, MachineType return_type,
433 size_t return_count) {
434 const int register_parameter_count = descriptor.GetRegisterParameterCount();
435 const int js_parameter_count =
436 register_parameter_count + stack_parameter_count;
437 const int context_count = 1;
438 const size_t parameter_count =
439 static_cast<size_t>(js_parameter_count + context_count);
440
441 LocationSignature::Builder locations(zone, return_count, parameter_count);
442 MachineSignature::Builder types(zone, return_count, parameter_count);
443
444 // Add returns.
445 if (locations.return_count_ > 0) {
446 locations.AddReturn(regloc(kReturnRegister0));
447 }
448 if (locations.return_count_ > 1) {
449 locations.AddReturn(regloc(kReturnRegister1));
450 }
451 for (size_t i = 0; i < return_count; i++) {
452 types.AddReturn(return_type);
453 }
454
455 // Add parameters in registers and on the stack.
456 for (int i = 0; i < js_parameter_count; i++) {
457 if (i < register_parameter_count) {
458 // The first parameters go in registers.
459 Register reg = descriptor.GetRegisterParameter(i);
460 Representation rep =
461 RepresentationFromType(descriptor.GetParameterType(i));
462 locations.AddParam(regloc(reg));
463 types.AddParam(reptyp(rep));
464 } else {
465 // The rest of the parameters go on the stack.
466 int stack_slot = i - register_parameter_count - stack_parameter_count;
467 locations.AddParam(LinkageLocation::ForCallerFrameSlot(stack_slot));
468 types.AddParam(MachineType::AnyTagged());
469 }
470 }
471 // Add context.
472 locations.AddParam(regloc(kContextRegister));
473 types.AddParam(MachineType::AnyTagged());
474
475 // The target for stub calls is a code object.
476 MachineType target_type = MachineType::AnyTagged();
477 LinkageLocation target_loc = LinkageLocation::ForAnyRegister();
478 return new (zone) CallDescriptor( // --
479 CallDescriptor::kCallCodeObject, // kind
480 target_type, // target MachineType
481 target_loc, // target location
482 types.Build(), // machine_sig
483 locations.Build(), // location_sig
484 stack_parameter_count, // stack_parameter_count
485 properties, // properties
486 kNoCalleeSaved, // callee-saved registers
487 kNoCalleeSaved, // callee-saved fp
488 flags, // flags
489 descriptor.DebugName(isolate));
490 }
491
492
GetOsrValueLocation(int index) const493 LinkageLocation Linkage::GetOsrValueLocation(int index) const {
494 CHECK(incoming_->IsJSFunctionCall());
495 int parameter_count = static_cast<int>(incoming_->JSParameterCount() - 1);
496 int first_stack_slot = OsrHelper::FirstStackSlotIndex(parameter_count);
497
498 if (index == kOsrContextSpillSlotIndex) {
499 // Context. Use the parameter location of the context spill slot.
500 // Parameter (arity + 2) is special for the context of the function frame.
501 // >> context_index = target + receiver + params + new_target + #args
502 int context_index = 1 + 1 + parameter_count + 1 + 1;
503 return incoming_->GetInputLocation(context_index);
504 } else if (index >= first_stack_slot) {
505 // Local variable stored in this (callee) stack.
506 int spill_index =
507 index - first_stack_slot + StandardFrameConstants::kFixedSlotCount;
508 return LinkageLocation::ForCalleeFrameSlot(spill_index);
509 } else {
510 // Parameter. Use the assigned location from the incoming call descriptor.
511 int parameter_index = 1 + index; // skip index 0, which is the target.
512 return incoming_->GetInputLocation(parameter_index);
513 }
514 }
515
516
ParameterHasSecondaryLocation(int index) const517 bool Linkage::ParameterHasSecondaryLocation(int index) const {
518 if (incoming_->kind() != CallDescriptor::kCallJSFunction) return false;
519 LinkageLocation loc = GetParameterLocation(index);
520 return (loc == regloc(kJSFunctionRegister) ||
521 loc == regloc(kContextRegister));
522 }
523
GetParameterSecondaryLocation(int index) const524 LinkageLocation Linkage::GetParameterSecondaryLocation(int index) const {
525 DCHECK(ParameterHasSecondaryLocation(index));
526 LinkageLocation loc = GetParameterLocation(index);
527
528 if (loc == regloc(kJSFunctionRegister)) {
529 return LinkageLocation::ForCalleeFrameSlot(Frame::kJSFunctionSlot);
530 } else {
531 DCHECK(loc == regloc(kContextRegister));
532 return LinkageLocation::ForCalleeFrameSlot(Frame::kContextSlot);
533 }
534 }
535
536
537 } // namespace compiler
538 } // namespace internal
539 } // namespace v8
540