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/code-factory.h"
6 #include "src/code-stubs.h"
7 #include "src/compiler/common-operator.h"
8 #include "src/compiler/js-generic-lowering.h"
9 #include "src/compiler/js-graph.h"
10 #include "src/compiler/machine-operator.h"
11 #include "src/compiler/node-matchers.h"
12 #include "src/compiler/node-properties.h"
13 #include "src/compiler/operator-properties.h"
14
15 namespace v8 {
16 namespace internal {
17 namespace compiler {
18
AdjustFrameStatesForCall(Node * node)19 static CallDescriptor::Flags AdjustFrameStatesForCall(Node* node) {
20 int count = OperatorProperties::GetFrameStateInputCount(node->op());
21 if (count > 1) {
22 int index = NodeProperties::FirstFrameStateIndex(node) + 1;
23 do {
24 node->RemoveInput(index);
25 } while (--count > 1);
26 }
27 return count > 0 ? CallDescriptor::kNeedsFrameState
28 : CallDescriptor::kNoFlags;
29 }
30
JSGenericLowering(JSGraph * jsgraph)31 JSGenericLowering::JSGenericLowering(JSGraph* jsgraph) : jsgraph_(jsgraph) {}
32
~JSGenericLowering()33 JSGenericLowering::~JSGenericLowering() {}
34
35
Reduce(Node * node)36 Reduction JSGenericLowering::Reduce(Node* node) {
37 switch (node->opcode()) {
38 #define DECLARE_CASE(x) \
39 case IrOpcode::k##x: \
40 Lower##x(node); \
41 break;
42 JS_OP_LIST(DECLARE_CASE)
43 #undef DECLARE_CASE
44 default:
45 // Nothing to see.
46 return NoChange();
47 }
48 return Changed(node);
49 }
50 #define REPLACE_RUNTIME_CALL(op, fun) \
51 void JSGenericLowering::Lower##op(Node* node) { \
52 ReplaceWithRuntimeCall(node, fun); \
53 }
REPLACE_RUNTIME_CALL(JSCreateWithContext,Runtime::kPushWithContext)54 REPLACE_RUNTIME_CALL(JSCreateWithContext, Runtime::kPushWithContext)
55 REPLACE_RUNTIME_CALL(JSCreateModuleContext, Runtime::kPushModuleContext)
56 REPLACE_RUNTIME_CALL(JSConvertReceiver, Runtime::kConvertReceiver)
57 #undef REPLACE_RUNTIME_CALL
58
59 #define REPLACE_STUB_CALL(Name) \
60 void JSGenericLowering::LowerJS##Name(Node* node) { \
61 CallDescriptor::Flags flags = AdjustFrameStatesForCall(node); \
62 Callable callable = CodeFactory::Name(isolate()); \
63 ReplaceWithStubCall(node, callable, flags); \
64 }
65 REPLACE_STUB_CALL(Add)
66 REPLACE_STUB_CALL(Subtract)
67 REPLACE_STUB_CALL(Multiply)
68 REPLACE_STUB_CALL(Divide)
69 REPLACE_STUB_CALL(Modulus)
70 REPLACE_STUB_CALL(BitwiseAnd)
71 REPLACE_STUB_CALL(BitwiseOr)
72 REPLACE_STUB_CALL(BitwiseXor)
73 REPLACE_STUB_CALL(ShiftLeft)
74 REPLACE_STUB_CALL(ShiftRight)
75 REPLACE_STUB_CALL(ShiftRightLogical)
76 REPLACE_STUB_CALL(LessThan)
77 REPLACE_STUB_CALL(LessThanOrEqual)
78 REPLACE_STUB_CALL(GreaterThan)
79 REPLACE_STUB_CALL(GreaterThanOrEqual)
80 REPLACE_STUB_CALL(HasProperty)
81 REPLACE_STUB_CALL(Equal)
82 REPLACE_STUB_CALL(NotEqual)
83 REPLACE_STUB_CALL(ToInteger)
84 REPLACE_STUB_CALL(ToLength)
85 REPLACE_STUB_CALL(ToNumber)
86 REPLACE_STUB_CALL(ToName)
87 REPLACE_STUB_CALL(ToObject)
88 REPLACE_STUB_CALL(ToString)
89 #undef REPLACE_STUB_CALL
90
91 void JSGenericLowering::ReplaceWithStubCall(Node* node, Callable callable,
92 CallDescriptor::Flags flags) {
93 ReplaceWithStubCall(node, callable, flags, node->op()->properties());
94 }
95
ReplaceWithStubCall(Node * node,Callable callable,CallDescriptor::Flags flags,Operator::Properties properties)96 void JSGenericLowering::ReplaceWithStubCall(Node* node, Callable callable,
97 CallDescriptor::Flags flags,
98 Operator::Properties properties) {
99 CallDescriptor* desc = Linkage::GetStubCallDescriptor(
100 isolate(), zone(), callable.descriptor(), 0, flags, properties);
101 Node* stub_code = jsgraph()->HeapConstant(callable.code());
102 node->InsertInput(zone(), 0, stub_code);
103 NodeProperties::ChangeOp(node, common()->Call(desc));
104 }
105
106
ReplaceWithRuntimeCall(Node * node,Runtime::FunctionId f,int nargs_override)107 void JSGenericLowering::ReplaceWithRuntimeCall(Node* node,
108 Runtime::FunctionId f,
109 int nargs_override) {
110 CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
111 Operator::Properties properties = node->op()->properties();
112 const Runtime::Function* fun = Runtime::FunctionForId(f);
113 int nargs = (nargs_override < 0) ? fun->nargs : nargs_override;
114 CallDescriptor* desc =
115 Linkage::GetRuntimeCallDescriptor(zone(), f, nargs, properties, flags);
116 Node* ref = jsgraph()->ExternalConstant(ExternalReference(f, isolate()));
117 Node* arity = jsgraph()->Int32Constant(nargs);
118 node->InsertInput(zone(), 0, jsgraph()->CEntryStubConstant(fun->result_size));
119 node->InsertInput(zone(), nargs + 1, ref);
120 node->InsertInput(zone(), nargs + 2, arity);
121 NodeProperties::ChangeOp(node, common()->Call(desc));
122 }
123
LowerJSStrictEqual(Node * node)124 void JSGenericLowering::LowerJSStrictEqual(Node* node) {
125 Callable callable = CodeFactory::StrictEqual(isolate());
126 node->AppendInput(zone(), graph()->start());
127 ReplaceWithStubCall(node, callable, CallDescriptor::kNoFlags,
128 Operator::kEliminatable);
129 }
130
LowerJSStrictNotEqual(Node * node)131 void JSGenericLowering::LowerJSStrictNotEqual(Node* node) {
132 Callable callable = CodeFactory::StrictNotEqual(isolate());
133 node->AppendInput(zone(), graph()->start());
134 ReplaceWithStubCall(node, callable, CallDescriptor::kNoFlags,
135 Operator::kEliminatable);
136 }
137
LowerJSToBoolean(Node * node)138 void JSGenericLowering::LowerJSToBoolean(Node* node) {
139 Callable callable = CodeFactory::ToBoolean(isolate());
140 node->AppendInput(zone(), graph()->start());
141 ReplaceWithStubCall(node, callable, CallDescriptor::kNoAllocate,
142 Operator::kEliminatable);
143 }
144
LowerJSTypeOf(Node * node)145 void JSGenericLowering::LowerJSTypeOf(Node* node) {
146 Callable callable = CodeFactory::Typeof(isolate());
147 node->AppendInput(zone(), graph()->start());
148 ReplaceWithStubCall(node, callable, CallDescriptor::kNoAllocate,
149 Operator::kEliminatable);
150 }
151
152
LowerJSLoadProperty(Node * node)153 void JSGenericLowering::LowerJSLoadProperty(Node* node) {
154 Node* closure = NodeProperties::GetValueInput(node, 2);
155 Node* effect = NodeProperties::GetEffectInput(node);
156 Node* control = NodeProperties::GetControlInput(node);
157 CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
158 const PropertyAccess& p = PropertyAccessOf(node->op());
159 Callable callable = CodeFactory::KeyedLoadICInOptimizedCode(isolate());
160 // Load the type feedback vector from the closure.
161 Node* literals = effect = graph()->NewNode(
162 machine()->Load(MachineType::AnyTagged()), closure,
163 jsgraph()->IntPtrConstant(JSFunction::kLiteralsOffset - kHeapObjectTag),
164 effect, control);
165 Node* vector = effect = graph()->NewNode(
166 machine()->Load(MachineType::AnyTagged()), literals,
167 jsgraph()->IntPtrConstant(LiteralsArray::kFeedbackVectorOffset -
168 kHeapObjectTag),
169 effect, control);
170 node->InsertInput(zone(), 2, jsgraph()->SmiConstant(p.feedback().index()));
171 node->ReplaceInput(3, vector);
172 node->ReplaceInput(6, effect);
173 ReplaceWithStubCall(node, callable, flags);
174 }
175
176
LowerJSLoadNamed(Node * node)177 void JSGenericLowering::LowerJSLoadNamed(Node* node) {
178 Node* closure = NodeProperties::GetValueInput(node, 1);
179 Node* effect = NodeProperties::GetEffectInput(node);
180 Node* control = NodeProperties::GetControlInput(node);
181 CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
182 NamedAccess const& p = NamedAccessOf(node->op());
183 Callable callable = CodeFactory::LoadICInOptimizedCode(isolate());
184 // Load the type feedback vector from the closure.
185 Node* literals = effect = graph()->NewNode(
186 machine()->Load(MachineType::AnyTagged()), closure,
187 jsgraph()->IntPtrConstant(JSFunction::kLiteralsOffset - kHeapObjectTag),
188 effect, control);
189 Node* vector = effect = graph()->NewNode(
190 machine()->Load(MachineType::AnyTagged()), literals,
191 jsgraph()->IntPtrConstant(LiteralsArray::kFeedbackVectorOffset -
192 kHeapObjectTag),
193 effect, control);
194 node->InsertInput(zone(), 1, jsgraph()->HeapConstant(p.name()));
195 node->InsertInput(zone(), 2, jsgraph()->SmiConstant(p.feedback().index()));
196 node->ReplaceInput(3, vector);
197 node->ReplaceInput(6, effect);
198 ReplaceWithStubCall(node, callable, flags);
199 }
200
201
LowerJSLoadGlobal(Node * node)202 void JSGenericLowering::LowerJSLoadGlobal(Node* node) {
203 Node* closure = NodeProperties::GetValueInput(node, 0);
204 Node* effect = NodeProperties::GetEffectInput(node);
205 Node* control = NodeProperties::GetControlInput(node);
206 CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
207 const LoadGlobalParameters& p = LoadGlobalParametersOf(node->op());
208 Callable callable =
209 CodeFactory::LoadGlobalICInOptimizedCode(isolate(), p.typeof_mode());
210 // Load the type feedback vector from the closure.
211 Node* literals = effect = graph()->NewNode(
212 machine()->Load(MachineType::AnyTagged()), closure,
213 jsgraph()->IntPtrConstant(JSFunction::kLiteralsOffset - kHeapObjectTag),
214 effect, control);
215 Node* vector = effect = graph()->NewNode(
216 machine()->Load(MachineType::AnyTagged()), literals,
217 jsgraph()->IntPtrConstant(LiteralsArray::kFeedbackVectorOffset -
218 kHeapObjectTag),
219 effect, control);
220 node->InsertInput(zone(), 0, jsgraph()->SmiConstant(p.feedback().index()));
221 node->ReplaceInput(1, vector);
222 node->ReplaceInput(4, effect);
223 ReplaceWithStubCall(node, callable, flags);
224 }
225
226
LowerJSStoreProperty(Node * node)227 void JSGenericLowering::LowerJSStoreProperty(Node* node) {
228 Node* closure = NodeProperties::GetValueInput(node, 3);
229 Node* effect = NodeProperties::GetEffectInput(node);
230 Node* control = NodeProperties::GetControlInput(node);
231 CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
232 PropertyAccess const& p = PropertyAccessOf(node->op());
233 LanguageMode language_mode = p.language_mode();
234 Callable callable =
235 CodeFactory::KeyedStoreICInOptimizedCode(isolate(), language_mode);
236 // Load the type feedback vector from the closure.
237 Node* literals = effect = graph()->NewNode(
238 machine()->Load(MachineType::AnyTagged()), closure,
239 jsgraph()->IntPtrConstant(JSFunction::kLiteralsOffset - kHeapObjectTag),
240 effect, control);
241 Node* vector = effect = graph()->NewNode(
242 machine()->Load(MachineType::AnyTagged()), literals,
243 jsgraph()->IntPtrConstant(LiteralsArray::kFeedbackVectorOffset -
244 kHeapObjectTag),
245 effect, control);
246 node->InsertInput(zone(), 3, jsgraph()->SmiConstant(p.feedback().index()));
247 node->ReplaceInput(4, vector);
248 node->ReplaceInput(7, effect);
249 ReplaceWithStubCall(node, callable, flags);
250 }
251
252
LowerJSStoreNamed(Node * node)253 void JSGenericLowering::LowerJSStoreNamed(Node* node) {
254 Node* closure = NodeProperties::GetValueInput(node, 2);
255 Node* effect = NodeProperties::GetEffectInput(node);
256 Node* control = NodeProperties::GetControlInput(node);
257 CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
258 NamedAccess const& p = NamedAccessOf(node->op());
259 Callable callable =
260 CodeFactory::StoreICInOptimizedCode(isolate(), p.language_mode());
261 // Load the type feedback vector from the closure.
262 Node* literals = effect = graph()->NewNode(
263 machine()->Load(MachineType::AnyTagged()), closure,
264 jsgraph()->IntPtrConstant(JSFunction::kLiteralsOffset - kHeapObjectTag),
265 effect, control);
266 Node* vector = effect = graph()->NewNode(
267 machine()->Load(MachineType::AnyTagged()), literals,
268 jsgraph()->IntPtrConstant(LiteralsArray::kFeedbackVectorOffset -
269 kHeapObjectTag),
270 effect, control);
271 node->InsertInput(zone(), 1, jsgraph()->HeapConstant(p.name()));
272 node->InsertInput(zone(), 3, jsgraph()->SmiConstant(p.feedback().index()));
273 node->ReplaceInput(4, vector);
274 node->ReplaceInput(7, effect);
275 ReplaceWithStubCall(node, callable, flags);
276 }
277
278
LowerJSStoreGlobal(Node * node)279 void JSGenericLowering::LowerJSStoreGlobal(Node* node) {
280 Node* closure = NodeProperties::GetValueInput(node, 1);
281 Node* context = NodeProperties::GetContextInput(node);
282 Node* effect = NodeProperties::GetEffectInput(node);
283 Node* control = NodeProperties::GetControlInput(node);
284 CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
285 const StoreGlobalParameters& p = StoreGlobalParametersOf(node->op());
286 Callable callable =
287 CodeFactory::StoreICInOptimizedCode(isolate(), p.language_mode());
288 // Load the type feedback vector from the closure.
289 Node* literals = effect = graph()->NewNode(
290 machine()->Load(MachineType::AnyTagged()), closure,
291 jsgraph()->IntPtrConstant(JSFunction::kLiteralsOffset - kHeapObjectTag),
292 effect, control);
293 Node* vector = effect = graph()->NewNode(
294 machine()->Load(MachineType::AnyTagged()), literals,
295 jsgraph()->IntPtrConstant(LiteralsArray::kFeedbackVectorOffset -
296 kHeapObjectTag),
297 effect, control);
298 // Load global object from the context.
299 Node* native_context = effect =
300 graph()->NewNode(machine()->Load(MachineType::AnyTagged()), context,
301 jsgraph()->IntPtrConstant(
302 Context::SlotOffset(Context::NATIVE_CONTEXT_INDEX)),
303 effect, control);
304 Node* global = effect = graph()->NewNode(
305 machine()->Load(MachineType::AnyTagged()), native_context,
306 jsgraph()->IntPtrConstant(Context::SlotOffset(Context::EXTENSION_INDEX)),
307 effect, control);
308 node->InsertInput(zone(), 0, global);
309 node->InsertInput(zone(), 1, jsgraph()->HeapConstant(p.name()));
310 node->InsertInput(zone(), 3, jsgraph()->SmiConstant(p.feedback().index()));
311 node->ReplaceInput(4, vector);
312 node->ReplaceInput(7, effect);
313 ReplaceWithStubCall(node, callable, flags);
314 }
315
316
LowerJSDeleteProperty(Node * node)317 void JSGenericLowering::LowerJSDeleteProperty(Node* node) {
318 LanguageMode language_mode = OpParameter<LanguageMode>(node);
319 ReplaceWithRuntimeCall(node, is_strict(language_mode)
320 ? Runtime::kDeleteProperty_Strict
321 : Runtime::kDeleteProperty_Sloppy);
322 }
323
324
LowerJSInstanceOf(Node * node)325 void JSGenericLowering::LowerJSInstanceOf(Node* node) {
326 CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
327 Callable callable = CodeFactory::InstanceOf(isolate());
328 ReplaceWithStubCall(node, callable, flags);
329 }
330
331
LowerJSLoadContext(Node * node)332 void JSGenericLowering::LowerJSLoadContext(Node* node) {
333 const ContextAccess& access = ContextAccessOf(node->op());
334 for (size_t i = 0; i < access.depth(); ++i) {
335 node->ReplaceInput(
336 0, graph()->NewNode(machine()->Load(MachineType::AnyTagged()),
337 NodeProperties::GetValueInput(node, 0),
338 jsgraph()->Int32Constant(
339 Context::SlotOffset(Context::PREVIOUS_INDEX)),
340 NodeProperties::GetEffectInput(node),
341 graph()->start()));
342 }
343 node->ReplaceInput(1, jsgraph()->Int32Constant(Context::SlotOffset(
344 static_cast<int>(access.index()))));
345 node->AppendInput(zone(), graph()->start());
346 NodeProperties::ChangeOp(node, machine()->Load(MachineType::AnyTagged()));
347 }
348
349
LowerJSStoreContext(Node * node)350 void JSGenericLowering::LowerJSStoreContext(Node* node) {
351 const ContextAccess& access = ContextAccessOf(node->op());
352 for (size_t i = 0; i < access.depth(); ++i) {
353 node->ReplaceInput(
354 0, graph()->NewNode(machine()->Load(MachineType::AnyTagged()),
355 NodeProperties::GetValueInput(node, 0),
356 jsgraph()->Int32Constant(
357 Context::SlotOffset(Context::PREVIOUS_INDEX)),
358 NodeProperties::GetEffectInput(node),
359 graph()->start()));
360 }
361 node->ReplaceInput(2, NodeProperties::GetValueInput(node, 1));
362 node->ReplaceInput(1, jsgraph()->Int32Constant(Context::SlotOffset(
363 static_cast<int>(access.index()))));
364 NodeProperties::ChangeOp(
365 node, machine()->Store(StoreRepresentation(MachineRepresentation::kTagged,
366 kFullWriteBarrier)));
367 }
368
369
LowerJSCreate(Node * node)370 void JSGenericLowering::LowerJSCreate(Node* node) {
371 CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
372 Callable callable = CodeFactory::FastNewObject(isolate());
373 ReplaceWithStubCall(node, callable, flags);
374 }
375
376
LowerJSCreateArguments(Node * node)377 void JSGenericLowering::LowerJSCreateArguments(Node* node) {
378 CreateArgumentsType const type = CreateArgumentsTypeOf(node->op());
379 switch (type) {
380 case CreateArgumentsType::kMappedArguments:
381 ReplaceWithRuntimeCall(node, Runtime::kNewSloppyArguments_Generic);
382 break;
383 case CreateArgumentsType::kUnmappedArguments:
384 ReplaceWithRuntimeCall(node, Runtime::kNewStrictArguments);
385 break;
386 case CreateArgumentsType::kRestParameter:
387 ReplaceWithRuntimeCall(node, Runtime::kNewRestParameter);
388 break;
389 }
390 }
391
392
LowerJSCreateArray(Node * node)393 void JSGenericLowering::LowerJSCreateArray(Node* node) {
394 CreateArrayParameters const& p = CreateArrayParametersOf(node->op());
395 int const arity = static_cast<int>(p.arity());
396 Handle<AllocationSite> const site = p.site();
397
398 // TODO(turbofan): We embed the AllocationSite from the Operator at this
399 // point, which we should not do once we want to both consume the feedback
400 // but at the same time shared the optimized code across native contexts,
401 // as the AllocationSite is associated with a single native context (it's
402 // stored in the type feedback vector after all). Once we go for cross
403 // context code generation, we should somehow find a way to get to the
404 // allocation site for the actual native context at runtime.
405 if (!site.is_null()) {
406 // Reduce {node} to the appropriate ArrayConstructorStub backend.
407 // Note that these stubs "behave" like JSFunctions, which means they
408 // expect a receiver on the stack, which they remove. We just push
409 // undefined for the receiver.
410 ElementsKind elements_kind = site->GetElementsKind();
411 AllocationSiteOverrideMode override_mode =
412 (AllocationSite::GetMode(elements_kind) == TRACK_ALLOCATION_SITE)
413 ? DISABLE_ALLOCATION_SITES
414 : DONT_OVERRIDE;
415 if (arity == 0) {
416 ArrayNoArgumentConstructorStub stub(isolate(), elements_kind,
417 override_mode);
418 CallDescriptor* desc = Linkage::GetStubCallDescriptor(
419 isolate(), graph()->zone(), stub.GetCallInterfaceDescriptor(), 1,
420 CallDescriptor::kNeedsFrameState);
421 node->ReplaceInput(0, jsgraph()->HeapConstant(stub.GetCode()));
422 node->InsertInput(graph()->zone(), 2, jsgraph()->HeapConstant(site));
423 node->InsertInput(graph()->zone(), 3, jsgraph()->Int32Constant(0));
424 node->InsertInput(graph()->zone(), 4, jsgraph()->UndefinedConstant());
425 NodeProperties::ChangeOp(node, common()->Call(desc));
426 } else if (arity == 1) {
427 // TODO(bmeurer): Optimize for the 0 length non-holey case?
428 ArraySingleArgumentConstructorStub stub(
429 isolate(), GetHoleyElementsKind(elements_kind), override_mode);
430 CallDescriptor* desc = Linkage::GetStubCallDescriptor(
431 isolate(), graph()->zone(), stub.GetCallInterfaceDescriptor(), 2,
432 CallDescriptor::kNeedsFrameState);
433 node->ReplaceInput(0, jsgraph()->HeapConstant(stub.GetCode()));
434 node->InsertInput(graph()->zone(), 2, jsgraph()->HeapConstant(site));
435 node->InsertInput(graph()->zone(), 3, jsgraph()->Int32Constant(1));
436 node->InsertInput(graph()->zone(), 4, jsgraph()->UndefinedConstant());
437 NodeProperties::ChangeOp(node, common()->Call(desc));
438 } else {
439 ArrayNArgumentsConstructorStub stub(isolate());
440 CallDescriptor* desc = Linkage::GetStubCallDescriptor(
441 isolate(), graph()->zone(), stub.GetCallInterfaceDescriptor(),
442 arity + 1, CallDescriptor::kNeedsFrameState);
443 node->ReplaceInput(0, jsgraph()->HeapConstant(stub.GetCode()));
444 node->InsertInput(graph()->zone(), 2, jsgraph()->HeapConstant(site));
445 node->InsertInput(graph()->zone(), 3, jsgraph()->Int32Constant(arity));
446 node->InsertInput(graph()->zone(), 4, jsgraph()->UndefinedConstant());
447 NodeProperties::ChangeOp(node, common()->Call(desc));
448 }
449 } else {
450 Node* new_target = node->InputAt(1);
451 Node* type_info = site.is_null() ? jsgraph()->UndefinedConstant()
452 : jsgraph()->HeapConstant(site);
453 node->RemoveInput(1);
454 node->InsertInput(zone(), 1 + arity, new_target);
455 node->InsertInput(zone(), 2 + arity, type_info);
456 ReplaceWithRuntimeCall(node, Runtime::kNewArray, arity + 3);
457 }
458 }
459
460
LowerJSCreateClosure(Node * node)461 void JSGenericLowering::LowerJSCreateClosure(Node* node) {
462 CreateClosureParameters const& p = CreateClosureParametersOf(node->op());
463 CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
464 Handle<SharedFunctionInfo> const shared_info = p.shared_info();
465 node->InsertInput(zone(), 0, jsgraph()->HeapConstant(shared_info));
466
467 // Use the FastNewClosureStub only for functions allocated in new space.
468 if (p.pretenure() == NOT_TENURED) {
469 Callable callable = CodeFactory::FastNewClosure(
470 isolate(), shared_info->language_mode(), shared_info->kind());
471 ReplaceWithStubCall(node, callable, flags);
472 } else {
473 ReplaceWithRuntimeCall(node, (p.pretenure() == TENURED)
474 ? Runtime::kNewClosure_Tenured
475 : Runtime::kNewClosure);
476 }
477 }
478
479
LowerJSCreateFunctionContext(Node * node)480 void JSGenericLowering::LowerJSCreateFunctionContext(Node* node) {
481 int const slot_count = OpParameter<int>(node->op());
482 CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
483
484 // Use the FastNewContextStub only for function contexts up maximum size.
485 if (slot_count <= FastNewContextStub::kMaximumSlots) {
486 Callable callable = CodeFactory::FastNewContext(isolate(), slot_count);
487 ReplaceWithStubCall(node, callable, flags);
488 } else {
489 ReplaceWithRuntimeCall(node, Runtime::kNewFunctionContext);
490 }
491 }
492
493
LowerJSCreateIterResultObject(Node * node)494 void JSGenericLowering::LowerJSCreateIterResultObject(Node* node) {
495 ReplaceWithRuntimeCall(node, Runtime::kCreateIterResultObject);
496 }
497
498
LowerJSCreateLiteralArray(Node * node)499 void JSGenericLowering::LowerJSCreateLiteralArray(Node* node) {
500 CreateLiteralParameters const& p = CreateLiteralParametersOf(node->op());
501 CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
502 node->InsertInput(zone(), 1, jsgraph()->SmiConstant(p.index()));
503 node->InsertInput(zone(), 2, jsgraph()->HeapConstant(p.constant()));
504
505 // Use the FastCloneShallowArrayStub only for shallow boilerplates up to the
506 // initial length limit for arrays with "fast" elements kind.
507 if ((p.flags() & ArrayLiteral::kShallowElements) != 0 &&
508 p.length() < JSArray::kInitialMaxFastElementArray) {
509 Callable callable = CodeFactory::FastCloneShallowArray(isolate());
510 ReplaceWithStubCall(node, callable, flags);
511 } else {
512 node->InsertInput(zone(), 3, jsgraph()->SmiConstant(p.flags()));
513 ReplaceWithRuntimeCall(node, Runtime::kCreateArrayLiteral);
514 }
515 }
516
517
LowerJSCreateLiteralObject(Node * node)518 void JSGenericLowering::LowerJSCreateLiteralObject(Node* node) {
519 CreateLiteralParameters const& p = CreateLiteralParametersOf(node->op());
520 CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
521 node->InsertInput(zone(), 1, jsgraph()->SmiConstant(p.index()));
522 node->InsertInput(zone(), 2, jsgraph()->HeapConstant(p.constant()));
523 node->InsertInput(zone(), 3, jsgraph()->SmiConstant(p.flags()));
524
525 // Use the FastCloneShallowObjectStub only for shallow boilerplates without
526 // elements up to the number of properties that the stubs can handle.
527 if ((p.flags() & ObjectLiteral::kShallowProperties) != 0 &&
528 p.length() <= FastCloneShallowObjectStub::kMaximumClonedProperties) {
529 Callable callable =
530 CodeFactory::FastCloneShallowObject(isolate(), p.length());
531 ReplaceWithStubCall(node, callable, flags);
532 } else {
533 ReplaceWithRuntimeCall(node, Runtime::kCreateObjectLiteral);
534 }
535 }
536
537
LowerJSCreateLiteralRegExp(Node * node)538 void JSGenericLowering::LowerJSCreateLiteralRegExp(Node* node) {
539 CreateLiteralParameters const& p = CreateLiteralParametersOf(node->op());
540 CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
541 Callable callable = CodeFactory::FastCloneRegExp(isolate());
542 Node* literal_index = jsgraph()->SmiConstant(p.index());
543 Node* literal_flags = jsgraph()->SmiConstant(p.flags());
544 Node* pattern = jsgraph()->HeapConstant(p.constant());
545 node->InsertInput(graph()->zone(), 1, literal_index);
546 node->InsertInput(graph()->zone(), 2, pattern);
547 node->InsertInput(graph()->zone(), 3, literal_flags);
548 ReplaceWithStubCall(node, callable, flags);
549 }
550
551
LowerJSCreateCatchContext(Node * node)552 void JSGenericLowering::LowerJSCreateCatchContext(Node* node) {
553 Handle<String> name = OpParameter<Handle<String>>(node);
554 node->InsertInput(zone(), 0, jsgraph()->HeapConstant(name));
555 ReplaceWithRuntimeCall(node, Runtime::kPushCatchContext);
556 }
557
558
LowerJSCreateBlockContext(Node * node)559 void JSGenericLowering::LowerJSCreateBlockContext(Node* node) {
560 Handle<ScopeInfo> scope_info = OpParameter<Handle<ScopeInfo>>(node);
561 node->InsertInput(zone(), 0, jsgraph()->HeapConstant(scope_info));
562 ReplaceWithRuntimeCall(node, Runtime::kPushBlockContext);
563 }
564
565
LowerJSCreateScriptContext(Node * node)566 void JSGenericLowering::LowerJSCreateScriptContext(Node* node) {
567 Handle<ScopeInfo> scope_info = OpParameter<Handle<ScopeInfo>>(node);
568 node->InsertInput(zone(), 1, jsgraph()->HeapConstant(scope_info));
569 ReplaceWithRuntimeCall(node, Runtime::kNewScriptContext);
570 }
571
572
LowerJSCallConstruct(Node * node)573 void JSGenericLowering::LowerJSCallConstruct(Node* node) {
574 CallConstructParameters const& p = CallConstructParametersOf(node->op());
575 int const arg_count = static_cast<int>(p.arity() - 2);
576 CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
577 Callable callable = CodeFactory::Construct(isolate());
578 CallDescriptor* desc = Linkage::GetStubCallDescriptor(
579 isolate(), zone(), callable.descriptor(), arg_count + 1, flags);
580 Node* stub_code = jsgraph()->HeapConstant(callable.code());
581 Node* stub_arity = jsgraph()->Int32Constant(arg_count);
582 Node* new_target = node->InputAt(arg_count + 1);
583 Node* receiver = jsgraph()->UndefinedConstant();
584 node->RemoveInput(arg_count + 1); // Drop new target.
585 node->InsertInput(zone(), 0, stub_code);
586 node->InsertInput(zone(), 2, new_target);
587 node->InsertInput(zone(), 3, stub_arity);
588 node->InsertInput(zone(), 4, receiver);
589 NodeProperties::ChangeOp(node, common()->Call(desc));
590 }
591
592
LowerJSCallFunction(Node * node)593 void JSGenericLowering::LowerJSCallFunction(Node* node) {
594 CallFunctionParameters const& p = CallFunctionParametersOf(node->op());
595 int const arg_count = static_cast<int>(p.arity() - 2);
596 ConvertReceiverMode const mode = p.convert_mode();
597 Callable callable = CodeFactory::Call(isolate(), mode);
598 CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
599 if (p.tail_call_mode() == TailCallMode::kAllow) {
600 flags |= CallDescriptor::kSupportsTailCalls;
601 }
602 CallDescriptor* desc = Linkage::GetStubCallDescriptor(
603 isolate(), zone(), callable.descriptor(), arg_count + 1, flags);
604 Node* stub_code = jsgraph()->HeapConstant(callable.code());
605 Node* stub_arity = jsgraph()->Int32Constant(arg_count);
606 node->InsertInput(zone(), 0, stub_code);
607 node->InsertInput(zone(), 2, stub_arity);
608 NodeProperties::ChangeOp(node, common()->Call(desc));
609 }
610
611
LowerJSCallRuntime(Node * node)612 void JSGenericLowering::LowerJSCallRuntime(Node* node) {
613 const CallRuntimeParameters& p = CallRuntimeParametersOf(node->op());
614 AdjustFrameStatesForCall(node);
615 ReplaceWithRuntimeCall(node, p.id(), static_cast<int>(p.arity()));
616 }
617
618
LowerJSForInDone(Node * node)619 void JSGenericLowering::LowerJSForInDone(Node* node) {
620 ReplaceWithRuntimeCall(node, Runtime::kForInDone);
621 }
622
623
LowerJSForInNext(Node * node)624 void JSGenericLowering::LowerJSForInNext(Node* node) {
625 ReplaceWithRuntimeCall(node, Runtime::kForInNext);
626 }
627
628
LowerJSForInPrepare(Node * node)629 void JSGenericLowering::LowerJSForInPrepare(Node* node) {
630 ReplaceWithRuntimeCall(node, Runtime::kForInPrepare);
631 }
632
633
LowerJSForInStep(Node * node)634 void JSGenericLowering::LowerJSForInStep(Node* node) {
635 ReplaceWithRuntimeCall(node, Runtime::kForInStep);
636 }
637
638
LowerJSLoadMessage(Node * node)639 void JSGenericLowering::LowerJSLoadMessage(Node* node) {
640 ExternalReference message_address =
641 ExternalReference::address_of_pending_message_obj(isolate());
642 node->RemoveInput(NodeProperties::FirstContextIndex(node));
643 node->InsertInput(zone(), 0, jsgraph()->ExternalConstant(message_address));
644 node->InsertInput(zone(), 1, jsgraph()->IntPtrConstant(0));
645 NodeProperties::ChangeOp(node, machine()->Load(MachineType::AnyTagged()));
646 }
647
648
LowerJSStoreMessage(Node * node)649 void JSGenericLowering::LowerJSStoreMessage(Node* node) {
650 ExternalReference message_address =
651 ExternalReference::address_of_pending_message_obj(isolate());
652 node->RemoveInput(NodeProperties::FirstContextIndex(node));
653 node->InsertInput(zone(), 0, jsgraph()->ExternalConstant(message_address));
654 node->InsertInput(zone(), 1, jsgraph()->IntPtrConstant(0));
655 StoreRepresentation representation(MachineRepresentation::kTagged,
656 kNoWriteBarrier);
657 NodeProperties::ChangeOp(node, machine()->Store(representation));
658 }
659
LowerJSGeneratorStore(Node * node)660 void JSGenericLowering::LowerJSGeneratorStore(Node* node) {
661 UNREACHABLE(); // Eliminated in typed lowering.
662 }
663
LowerJSGeneratorRestoreContinuation(Node * node)664 void JSGenericLowering::LowerJSGeneratorRestoreContinuation(Node* node) {
665 UNREACHABLE(); // Eliminated in typed lowering.
666 }
667
LowerJSGeneratorRestoreRegister(Node * node)668 void JSGenericLowering::LowerJSGeneratorRestoreRegister(Node* node) {
669 UNREACHABLE(); // Eliminated in typed lowering.
670 }
671
LowerJSStackCheck(Node * node)672 void JSGenericLowering::LowerJSStackCheck(Node* node) {
673 Node* effect = NodeProperties::GetEffectInput(node);
674 Node* control = NodeProperties::GetControlInput(node);
675
676 Node* limit = graph()->NewNode(
677 machine()->Load(MachineType::Pointer()),
678 jsgraph()->ExternalConstant(
679 ExternalReference::address_of_stack_limit(isolate())),
680 jsgraph()->IntPtrConstant(0), effect, control);
681 Node* pointer = graph()->NewNode(machine()->LoadStackPointer());
682
683 Node* check = graph()->NewNode(machine()->UintLessThan(), limit, pointer);
684 Node* branch =
685 graph()->NewNode(common()->Branch(BranchHint::kTrue), check, control);
686
687 Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
688 Node* etrue = effect;
689
690 Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
691 NodeProperties::ReplaceControlInput(node, if_false);
692 Node* efalse = node;
693
694 Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
695 Node* ephi = graph()->NewNode(common()->EffectPhi(2), etrue, efalse, merge);
696
697 // Wire the new diamond into the graph, {node} can still throw.
698 NodeProperties::ReplaceUses(node, node, ephi, node, node);
699 NodeProperties::ReplaceEffectInput(ephi, efalse, 1);
700
701 // TODO(mstarzinger): This iteration cuts out the IfSuccess projection from
702 // the node and places it inside the diamond. Come up with a helper method!
703 for (Node* use : node->uses()) {
704 if (use->opcode() == IrOpcode::kIfSuccess) {
705 use->ReplaceUses(merge);
706 merge->ReplaceInput(1, use);
707 }
708 }
709
710 // Turn the stack check into a runtime call.
711 ReplaceWithRuntimeCall(node, Runtime::kStackGuard);
712 }
713
714
zone() const715 Zone* JSGenericLowering::zone() const { return graph()->zone(); }
716
717
isolate() const718 Isolate* JSGenericLowering::isolate() const { return jsgraph()->isolate(); }
719
720
graph() const721 Graph* JSGenericLowering::graph() const { return jsgraph()->graph(); }
722
723
common() const724 CommonOperatorBuilder* JSGenericLowering::common() const {
725 return jsgraph()->common();
726 }
727
728
machine() const729 MachineOperatorBuilder* JSGenericLowering::machine() const {
730 return jsgraph()->machine();
731 }
732
733 } // namespace compiler
734 } // namespace internal
735 } // namespace v8
736