• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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