Lines Matching defs:node
27 #include "src/compiler/node-matchers.h"
63 JSCallReducerAssembler(JSCallReducer* reducer, Node* node)
70 node_(node),
74 InitializeEffectControl(NodeProperties::GetEffectInput(node),
75 NodeProperties::GetControlInput(node));
79 NodeProperties::IsExceptionalCall(node, &outermost_handler_);
289 // Emplace a copy of the call node into the graph at current effect/control.
322 // The IfException node is later merged into the outer graph.
690 IteratingArrayBuiltinReducerAssembler(JSCallReducer* reducer, Node* node)
691 : JSCallReducerAssembler(reducer, node) {
814 PromiseBuiltinReducerAssembler(JSCallReducer* reducer, Node* node,
816 : JSCallReducerAssembler(reducer, node), broker_(broker) {
817 DCHECK_EQ(IrOpcode::kJSConstruct, node->opcode());
907 JSCallReducer* reducer, Node* node,
912 : JSCallReducerAssembler(reducer, node),
920 DCHECK_EQ(IrOpcode::kJSCall, node->opcode());
922 InitializeEffectControl(effect, NodeProperties::GetControlInput(node));
2165 Node* node, Node* outer_frame_state, int parameter_count,
2184 params.push_back(node->InputAt(kReceiverInputIndex + i));
2192 node->InputAt(kTargetInputIndex),
2325 // Replace the Call node with the newly-produced subgraph.
2348 Reduction JSCallReducer::ReduceMathUnary(Node* node, const Operator* op) {
2349 JSCallNode n(node);
2356 ReplaceWithValue(node, value);
2360 JSCallReducerAssembler a(this, node);
2365 Reduction JSCallReducer::ReduceMathBinary(Node* node, const Operator* op) {
2366 JSCallNode n(node);
2373 ReplaceWithValue(node, value);
2377 JSCallReducerAssembler a(this, node);
2383 Reduction JSCallReducer::ReduceMathImul(Node* node) {
2384 JSCallNode n(node);
2391 ReplaceWithValue(node, value);
2410 ReplaceWithValue(node, value, effect);
2415 Reduction JSCallReducer::ReduceMathClz32(Node* node) {
2416 JSCallNode n(node);
2423 ReplaceWithValue(node, value);
2436 ReplaceWithValue(node, value, effect);
2442 Reduction JSCallReducer::ReduceMathMinMax(Node* node, const Operator* op,
2444 JSCallNode n(node);
2450 ReplaceWithValue(node, empty_value);
2453 Node* effect = NodeProperties::GetEffectInput(node);
2454 Node* control = NodeProperties::GetControlInput(node);
2468 ReplaceWithValue(node, value, effect);
2472 Reduction JSCallReducer::Reduce(Node* node) {
2473 switch (node->opcode()) {
2475 return ReduceJSConstruct(node);
2477 return ReduceJSConstructWithArrayLike(node);
2479 return ReduceJSConstructWithSpread(node);
2481 return ReduceJSCall(node);
2483 return ReduceJSCallWithArrayLike(node);
2485 return ReduceJSCallWithSpread(node);
2495 // nodes, even if they don't show up in the use list of the other node.
2497 for (Node* node : waitlist) {
2498 if (!node->IsDead()) {
2499 Reduction const reduction = Reduce(node);
2502 if (replacement != node) {
2503 Replace(node, replacement);
2511 Reduction JSCallReducer::ReduceArrayConstructor(Node* node) {
2512 JSCallNode n(node);
2516 // Turn the {node} into a {JSCreateArray} call.
2518 node->RemoveInput(n.FeedbackVectorIndex());
2519 NodeProperties::ReplaceValueInput(node, target, 0);
2520 NodeProperties::ReplaceValueInput(node, target, 1);
2521 NodeProperties::ChangeOp(node,
2523 return Changed(node);
2527 Reduction JSCallReducer::ReduceBooleanConstructor(Node* node) {
2528 // Replace the {node} with a proper {ToBoolean} operator.
2529 JSCallNode n(node);
2532 ReplaceWithValue(node, value);
2537 Reduction JSCallReducer::ReduceObjectConstructor(Node* node) {
2538 JSCallNode n(node);
2546 // Turn the {node} into a {JSToObject} call if we know that
2548 NodeProperties::ReplaceValueInputs(node, value);
2549 NodeProperties::ChangeOp(node, javascript()->ToObject());
2550 return Changed(node);
2553 ReplaceWithValue(node, value);
2560 Reduction JSCallReducer::ReduceFunctionPrototypeApply(Node* node) {
2561 JSCallNode n(node);
2575 node->ReplaceInput(n.TargetIndex(), n.receiver());
2576 node->ReplaceInput(n.ReceiverIndex(), jsgraph()->UndefinedConstant());
2581 node->RemoveInput(n.TargetIndex());
2584 // Change {node} to a {JSCall} and try to reduce further.
2586 node, javascript()->Call(JSCallNode::ArityForArgc(arity), p.frequency(),
2589 return Changed(node).FollowedBy(ReduceJSCall(node));
2605 // to expand this {node} to control-flow.
2608 node->ReplaceInput(n.TargetIndex(), target);
2609 node->ReplaceInput(n.ReceiverIndex(), this_argument);
2610 node->ReplaceInput(n.ArgumentIndex(0), arguments_list);
2611 while (arity-- > 1) node->RemoveInput(n.ArgumentIndex(1));
2613 // Morph the {node} to a {JSCallWithArrayLike}.
2615 node, javascript()->CallWithArrayLike(p.frequency(), p.feedback(),
2618 return Changed(node).FollowedBy(ReduceJSCallWithArrayLike(node));
2659 if (NodeProperties::IsExceptionalCall(node, &if_exception)) {
2685 ReplaceWithValue(node, value, effect, control);
2690 Reduction JSCallReducer::ReduceFunctionPrototypeBind(Node* node) {
2691 JSCallNode n(node);
2697 // Value inputs to the {node} are as follows:
2785 // Replace the {node} with a JSCreateBoundFunction.
2816 ReplaceWithValue(node, value, effect, control);
2821 Reduction JSCallReducer::ReduceFunctionPrototypeCall(Node* node) {
2822 JSCallNode n(node);
2828 // Change context of {node} to the Function.prototype.call context,
2840 NodeProperties::ReplaceContextInput(node, context);
2841 NodeProperties::ReplaceEffectInput(node, effect);
2843 // Remove the target from {node} and use the receiver as target instead, and
2851 node->ReplaceInput(n.TargetIndex(), n.receiver());
2852 node->ReplaceInput(n.ReceiverIndex(), jsgraph()->UndefinedConstant());
2856 node->RemoveInput(n.TargetIndex());
2860 node, javascript()->Call(JSCallNode::ArityForArgc(arity), p.frequency(),
2863 // Try to further reduce the JSCall {node}.
2864 return Changed(node).FollowedBy(ReduceJSCall(node));
2868 Reduction JSCallReducer::ReduceFunctionPrototypeHasInstance(Node* node) {
2869 JSCallNode n(node);
2882 // Morph this {node} into a JSOrdinaryHasInstance node.
2883 node->ReplaceInput(0, receiver);
2884 node->ReplaceInput(1, object);
2885 node->ReplaceInput(2, context);
2886 node->ReplaceInput(3, frame_state);
2887 node->ReplaceInput(4, effect);
2888 node->ReplaceInput(5, control);
2889 node->TrimInputCount(6);
2890 NodeProperties::ChangeOp(node, javascript()->OrdinaryHasInstance());
2891 return Changed(node);
2894 Reduction JSCallReducer::ReduceObjectGetPrototype(Node* node, Node* object) {
2895 Effect effect{NodeProperties::GetEffectInput(node)};
2924 ReplaceWithValue(node, value);
2929 Reduction JSCallReducer::ReduceObjectGetPrototypeOf(Node* node) {
2930 JSCallNode n(node);
2932 return ReduceObjectGetPrototype(node, object);
2936 Reduction JSCallReducer::ReduceObjectIs(Node* node) {
2937 JSCallNode n(node);
2941 ReplaceWithValue(node, value);
2946 Reduction JSCallReducer::ReduceObjectPrototypeGetProto(Node* node) {
2947 JSCallNode n(node);
2948 return ReduceObjectGetPrototype(node, n.receiver());
2952 Reduction JSCallReducer::ReduceObjectPrototypeHasOwnProperty(Node* node) {
2953 JSCallNode call_node(node);
2986 // We can constant-fold the {node} to True in this case, and insert
3018 ReplaceWithValue(node, value, effect, control);
3028 Reduction JSCallReducer::ReduceObjectPrototypeIsPrototypeOf(Node* node) {
3029 JSCallNode n(node);
3045 NodeProperties::ReplaceValueInput(node, value, n.TargetIndex());
3046 for (int i = node->op()->ValueInputCount(); i > 2; i--) {
3047 node->RemoveInput(2);
3049 NodeProperties::ChangeOp(node, javascript()->HasInPrototypeChain());
3050 return Changed(node);
3054 Reduction JSCallReducer::ReduceReflectApply(Node* node) {
3055 JSCallNode n(node);
3060 node->RemoveInput(n.ReceiverIndex());
3061 node->RemoveInput(n.TargetIndex());
3063 node->InsertInput(graph()->zone(), arity++, jsgraph()->UndefinedConstant());
3066 node->RemoveInput(arity);
3069 node, javascript()->CallWithArrayLike(p.frequency(), p.feedback(),
3072 return Changed(node).FollowedBy(ReduceJSCallWithArrayLike(node));
3076 Reduction JSCallReducer::ReduceReflectConstruct(Node* node) {
3077 JSCallNode n(node);
3086 node->RemoveInput(n.ReceiverIndex());
3087 node->RemoveInput(n.TargetIndex());
3093 node->InsertInput(graph()->zone(), arity++, jsgraph()->UndefinedConstant());
3096 node->RemoveInput(arity);
3102 node->ReplaceInput(JSConstructNode::TargetIndex(), arg_target);
3103 node->ReplaceInput(JSConstructNode::NewTargetIndex(), arg_new_target);
3104 node->ReplaceInput(JSConstructNode::ArgumentIndex(0), arg_argument_list);
3107 node, javascript()->ConstructWithArrayLike(p.frequency(), p.feedback()));
3108 return Changed(node).FollowedBy(ReduceJSConstructWithArrayLike(node));
3112 Reduction JSCallReducer::ReduceReflectGetPrototypeOf(Node* node) {
3113 JSCallNode n(node);
3115 return ReduceObjectGetPrototype(node, target);
3119 Reduction JSCallReducer::ReduceObjectCreate(Node* node) {
3120 JSCallNode n(node);
3129 node->ReplaceInput(0, prototype);
3130 node->ReplaceInput(1, context);
3131 node->ReplaceInput(2, frame_state);
3132 node->ReplaceInput(3, effect);
3133 node->ReplaceInput(4, control);
3134 node->TrimInputCount(5);
3135 NodeProperties::ChangeOp(node, javascript()->CreateObject());
3136 return Changed(node);
3140 Reduction JSCallReducer::ReduceReflectGet(Node* node) {
3141 JSCallNode n(node);
3187 if (NodeProperties::IsExceptionalCall(node, &on_exception)) {
3209 ReplaceWithValue(node, vtrue, etrue, if_true);
3214 Reduction JSCallReducer::ReduceReflectHas(Node* node) {
3215 JSCallNode n(node);
3253 if (NodeProperties::IsExceptionalCall(node, &on_exception)) {
3275 ReplaceWithValue(node, vtrue, etrue, if_true);
3323 IteratingArrayBuiltinHelper(Node* node, JSHeapBroker* broker,
3326 : receiver_(NodeProperties::GetValueInput(node, 1)),
3327 effect_(NodeProperties::GetEffectInput(node)),
3328 control_(NodeProperties::GetControlInput(node)),
3332 DCHECK_EQ(IrOpcode::kJSCall, node->opcode());
3333 const CallParameters& p = CallParametersOf(node->op());
3376 Node* node, const SharedFunctionInfoRef& shared) {
3377 IteratingArrayBuiltinHelper h(node, broker(), jsgraph(), dependencies());
3380 IteratingArrayBuiltinReducerAssembler a(this, node);
3388 Node* node, const SharedFunctionInfoRef& shared) {
3389 IteratingArrayBuiltinHelper h(node, broker(), jsgraph(), dependencies());
3392 IteratingArrayBuiltinReducerAssembler a(this, node);
3401 Node* node, const SharedFunctionInfoRef& shared) {
3402 IteratingArrayBuiltinHelper h(node, broker(), jsgraph(), dependencies());
3405 IteratingArrayBuiltinReducerAssembler a(this, node);
3413 Reduction JSCallReducer::ReduceArrayMap(Node* node,
3415 IteratingArrayBuiltinHelper h(node, broker(), jsgraph(), dependencies());
3423 IteratingArrayBuiltinReducerAssembler a(this, node);
3433 Node* node, const SharedFunctionInfoRef& shared) {
3434 IteratingArrayBuiltinHelper h(node, broker(), jsgraph(), dependencies());
3442 IteratingArrayBuiltinReducerAssembler a(this, node);
3451 Reduction JSCallReducer::ReduceArrayFind(Node* node,
3453 IteratingArrayBuiltinHelper h(node, broker(), jsgraph(), dependencies());
3456 IteratingArrayBuiltinReducerAssembler a(this, node);
3466 Node* node, const SharedFunctionInfoRef& shared) {
3467 IteratingArrayBuiltinHelper h(node, broker(), jsgraph(), dependencies());
3470 IteratingArrayBuiltinReducerAssembler a(this, node);
3479 Reduction JSCallReducer::ReduceArrayEvery(Node* node,
3481 IteratingArrayBuiltinHelper h(node, broker(), jsgraph(), dependencies());
3484 IteratingArrayBuiltinReducerAssembler a(this, node);
3495 Reduction JSCallReducer::ReduceArrayIncludes(Node* node) {
3496 IteratingArrayBuiltinHelper h(node, broker(), jsgraph(), dependencies());
3499 IteratingArrayBuiltinReducerAssembler a(this, node);
3509 Reduction JSCallReducer::ReduceArrayIndexOf(Node* node) {
3510 IteratingArrayBuiltinHelper h(node, broker(), jsgraph(), dependencies());
3513 IteratingArrayBuiltinReducerAssembler a(this, node);
3521 Reduction JSCallReducer::ReduceArraySome(Node* node,
3523 IteratingArrayBuiltinHelper h(node, broker(), jsgraph(), dependencies());
3526 IteratingArrayBuiltinReducerAssembler a(this, node);
3560 Node* node, const SharedFunctionInfoRef& shared) {
3563 JSCallNode n(node);
3593 DCHECK_LT(removal_index, static_cast<int>(node->InputCount()));
3594 node->RemoveInput(removal_index);
3601 node->InsertInput(graph()->zone(), insertion_index,
3606 NodeProperties::ChangeOp(node, op);
3607 return Changed(node);
3668 Node* node, const SharedFunctionInfoRef& shared) {
3669 JSCallNode n(node);
3813 node->RemoveInput(n.FeedbackVectorIndex());
3814 node->InsertInput(graph()->zone(), 0,
3816 node->ReplaceInput(1, jsgraph()->Constant(function_template_info));
3817 node->InsertInput(graph()->zone(), 2,
3819 node->ReplaceInput(3, receiver); // Update receiver input.
3820 node->ReplaceInput(6 + argc, effect); // Update effect input.
3821 NodeProperties::ChangeOp(node, common()->Call(call_descriptor));
3822 return Changed(node);
3842 FastApiCallReducerAssembler a(this, node, function_template_info,
3866 node->RemoveInput(n.FeedbackVectorIndex());
3867 node->InsertInput(graph()->zone(), 0,
3869 node->ReplaceInput(1, jsgraph()->ExternalConstant(function_reference));
3870 node->InsertInput(graph()->zone(), 2, jsgraph()->Constant(argc));
3871 node->InsertInput(graph()->zone(), 3,
3873 node->InsertInput(graph()->zone(), 4, holder);
3874 node->ReplaceInput(5, receiver); // Update receiver input.
3876 node->ReplaceInput(6 + argc + 1, continuation_frame_state);
3877 node->ReplaceInput(6 + argc + 2, effect);
3878 NodeProperties::ChangeOp(node, common()->Call(call_descriptor));
3879 return Changed(node);
3885 // explicitly checking that {node} is only used by {LoadField} or
3887 bool IsSafeArgumentsElements(Node* node) {
3888 for (Edge const edge : node->use_edges()) {
3899 bool IsCallOrConstructWithArrayLike(Node* node) {
3900 return node->opcode() == IrOpcode::kJSCallWithArrayLike ||
3901 node->opcode() == IrOpcode::kJSConstructWithArrayLike;
3905 bool IsCallOrConstructWithSpread(Node* node) {
3906 return node->opcode() == IrOpcode::kJSCallWithSpread ||
3907 node->opcode() == IrOpcode::kJSConstructWithSpread;
3910 bool IsCallWithArrayLikeOrSpread(Node* node) {
3911 return node->opcode() == IrOpcode::kJSCallWithArrayLike ||
3912 node->opcode() == IrOpcode::kJSCallWithSpread;
3966 bool ShouldUseCallICFeedback(Node* node) {
3967 HeapObjectMatcher m(node);
3975 Node* control = NodeProperties::GetControlInput(node);
3979 // Check if {node} is a Phi of nodes which shouldn't
3981 int const value_input_count = m.node()->op()->ValueInputCount();
3983 if (ShouldUseCallICFeedback(node->InputAt(n))) return true;
4009 Node* node, Node* arguments_list, int arraylike_or_spread_index,
4014 // Check if {node} is the only value user of {arguments_list} (except for
4072 // We cannot currently reduce the {node} to something better than what
4073 // it already is, but we might be able to do something about the {node}
4075 waitlist_.insert(node);
4080 // we can only optimize this in case the {node} was already inlined into
4099 // here if there's no side-effect between the {node} and the {arg_array}.
4102 Node* effect = NodeProperties::GetEffectInput(node);
4113 if (IsCallOrConstructWithSpread(node)) {
4117 // Remove the {arguments_list} input from the {node}.
4118 node->RemoveInput(arraylike_or_spread_index);
4134 if (IsCallWithArrayLikeOrSpread(node)) {
4143 node->RemoveInput(JSCallOrConstructNode::FeedbackVectorIndexForArgc(argc));
4144 NodeProperties::ChangeOp(node, op);
4145 return Changed(node);
4148 // we can only optimize this in case the {node} was already inlined into
4156 // Add the actual parameters to the {node}, skipping the receiver.
4160 DCHECK_NOT_NULL(it.node());
4161 node->InsertInput(graph()->zone(),
4162 JSCallOrConstructNode::ArgumentIndex(argc++), it.node());
4165 if (IsCallWithArrayLikeOrSpread(node)) {
4167 node, javascript()->Call(JSCallNode::ArityForArgc(argc), frequency,
4170 return Changed(node).FollowedBy(ReduceJSCall(node));
4173 node, javascript()->Construct(JSConstructNode::ArityForArgc(argc),
4179 CheckIfConstructor(node);
4180 return Changed(node).FollowedBy(ReduceJSConstruct(node));
4185 Node* node, int argument_count, int arraylike_or_spread_index,
4189 DCHECK(IsCallOrConstructWithArrayLike(node) ||
4190 IsCallOrConstructWithSpread(node));
4195 NodeProperties::GetValueInput(node, arraylike_or_spread_index);
4199 node, arguments_list, arraylike_or_spread_index, frequency,
4206 if (!IsCallWithArrayLikeOrSpread(node)) return NoChange();
4220 if (IsCallOrConstructWithSpread(node)) {
4225 if (generated_calls_with_array_like_or_spread_.count(node)) {
4228 JSCallReducerAssembler a(this, node);
4273 // Remove the {arguments_list} node which will be replaced by a sequence of
4275 node->RemoveInput(arraylike_or_spread_index);
4291 // Generate N element loads to replace the {arguments_list} node with a set
4319 node->InsertInput(graph()->zone(), arraylike_or_spread_index + i, load);
4323 node,
4327 NodeProperties::ReplaceEffectInput(node, effect);
4328 return Changed(node).FollowedBy(ReduceJSCall(node));
4339 Reduction JSCallReducer::ReduceJSCall(Node* node) {
4342 JSCallNode n(node);
4349 // Try to specialize JSCall {node}s with constant {target}s.
4361 return ReduceJSCall(node, function.shared());
4385 // Patch {node} to use [[BoundTargetFunction]] and [[BoundThis]].
4387 node, jsgraph()->Constant(function.bound_target_function()),
4389 NodeProperties::ReplaceValueInput(node, jsgraph()->Constant(bound_this),
4392 // Insert the [[BoundArguments]] for {node}.
4394 node->InsertInput(graph()->zone(), i + 2, args[i]);
4399 node,
4404 // Try to further reduce the JSCall {node}.
4405 return Changed(node).FollowedBy(ReduceJSCall(node));
4408 // Don't mess with other {node}s that have a constant {target}.
4421 return ReduceJSCall(node, params.shared_info(broker()));
4430 return ReduceJSCall(node, *shared);
4442 // Patch the {node} to use [[BoundTargetFunction]] and [[BoundThis]].
4443 NodeProperties::ReplaceValueInput(node, bound_target_function,
4445 NodeProperties::ReplaceValueInput(node, bound_this, n.ReceiverIndex());
4447 // Insert the [[BoundArguments]] for {node}.
4450 node->InsertInput(graph()->zone(), n.ArgumentIndex(i), value);
4454 // Update the JSCall operator on {node}.
4460 node,
4465 // Try to further reduce the JSCall {node}.
4466 return Changed(node).FollowedBy(ReduceJSCall(node));
4479 node, DeoptimizeReason::kInsufficientTypeFeedbackForCall);
4500 // Specialize the JSCall node to the {target_function}.
4501 NodeProperties::ReplaceValueInput(node, target_function, n.TargetIndex());
4502 NodeProperties::ReplaceEffectInput(node, effect);
4504 // Try to further reduce the JSCall {node}.
4505 return Changed(node).FollowedBy(ReduceJSCall(node));
4516 // Specialize the JSCall node to the {target_closure}.
4517 NodeProperties::ReplaceValueInput(node, target_closure, n.TargetIndex());
4518 NodeProperties::ReplaceEffectInput(node, effect);
4520 // Try to further reduce the JSCall {node}.
4521 return Changed(node).FollowedBy(ReduceJSCall(node));
4527 Reduction JSCallReducer::ReduceJSCall(Node* node,
4529 JSCallNode n(node);
4541 NodeProperties::ReplaceValueInputs(node, target);
4543 node, javascript()->CallRuntime(
4545 return Changed(node);
4554 return ReduceArrayConstructor(node);
4556 return ReduceBooleanConstructor(node);
4558 return ReduceFunctionPrototypeApply(node);
4560 return ReduceFunctionPrototypeBind(node);
4562 return ReduceFunctionPrototypeCall(node);
4564 return ReduceFunctionPrototypeHasInstance(node);
4566 return ReduceObjectConstructor(node);
4568 return ReduceObjectCreate(node);
4570 return ReduceObjectGetPrototypeOf(node);
4572 return ReduceObjectIs(node);
4574 return ReduceObjectPrototypeGetProto(node);
4576 return ReduceObjectPrototypeHasOwnProperty(node);
4578 return ReduceObjectPrototypeIsPrototypeOf(node);
4580 return ReduceReflectApply(node);
4582 return ReduceReflectConstruct(node);
4584 return ReduceReflectGet(node);
4586 return ReduceReflectGetPrototypeOf(node);
4588 return ReduceReflectHas(node);
4590 return ReduceArrayForEach(node, shared);
4592 return ReduceArrayMap(node, shared);
4594 return ReduceArrayFilter(node, shared);
4596 return ReduceArrayReduce(node, shared);
4598 return ReduceArrayReduceRight(node, shared);
4600 return ReduceArrayFind(node, shared);
4602 return ReduceArrayFindIndex(node, shared);
4604 return ReduceArrayEvery(node, shared);
4606 return ReduceArrayIndexOf(node);
4608 return ReduceArrayIncludes(node);
4610 return ReduceArraySome(node, shared);
4612 return ReduceArrayPrototypePush(node);
4614 return ReduceArrayPrototypePop(node);
4616 return ReduceArrayPrototypeShift(node);
4618 return ReduceArrayPrototypeSlice(node);
4620 return ReduceArrayIterator(node, ArrayIteratorKind::kArrayLike,
4623 return ReduceArrayIterator(node, ArrayIteratorKind::kArrayLike,
4626 return ReduceArrayIterator(node, ArrayIteratorKind::kArrayLike,
4629 return ReduceArrayIteratorPrototypeNext(node);
4631 return ReduceArrayIsArray(node);
4633 return ReduceArrayBufferIsView(node);
4636 node, JS_DATA_VIEW_TYPE,
4640 node, JS_DATA_VIEW_TYPE,
4643 return ReduceDataViewAccess(node, DataViewAccess::kGet,
4646 return ReduceDataViewAccess(node, DataViewAccess::kGet,
4649 return ReduceDataViewAccess(node, DataViewAccess::kGet,
4652 return ReduceDataViewAccess(node, DataViewAccess::kGet,
4655 return ReduceDataViewAccess(node, DataViewAccess::kGet,
4658 return ReduceDataViewAccess(node, DataViewAccess::kGet,
4661 return ReduceDataViewAccess(node, DataViewAccess::kGet,
4664 return ReduceDataViewAccess(node, DataViewAccess::kGet,
4667 return ReduceDataViewAccess(node, DataViewAccess::kSet,
4670 return ReduceDataViewAccess(node, DataViewAccess::kSet,
4673 return ReduceDataViewAccess(node, DataViewAccess::kSet,
4676 return ReduceDataViewAccess(node, DataViewAccess::kSet,
4679 return ReduceDataViewAccess(node, DataViewAccess::kSet,
4682 return ReduceDataViewAccess(node, DataViewAccess::kSet,
4685 return ReduceDataViewAccess(node, DataViewAccess::kSet,
4688 return ReduceDataViewAccess(node, DataViewAccess::kSet,
4692 node, JS_TYPED_ARRAY_TYPE,
4696 node, JS_TYPED_ARRAY_TYPE,
4700 node, JS_TYPED_ARRAY_TYPE, AccessBuilder::ForJSTypedArrayLength());
4702 return ReduceTypedArrayPrototypeToStringTag(node);
4704 return ReduceMathUnary(node, simplified()->NumberAbs());
4706 return ReduceMathUnary(node, simplified()->NumberAcos());
4708 return ReduceMathUnary(node, simplified()->NumberAcosh());
4710 return ReduceMathUnary(node, simplified()->NumberAsin());
4712 return ReduceMathUnary(node, simplified()->NumberAsinh());
4714 return ReduceMathUnary(node, simplified()->NumberAtan());
4716 return ReduceMathUnary(node, simplified()->NumberAtanh());
4718 return ReduceMathUnary(node, simplified()->NumberCbrt());
4720 return ReduceMathUnary(node, simplified()->NumberCeil());
4722 return ReduceMathUnary(node, simplified()->NumberCos());
4724 return ReduceMathUnary(node, simplified()->NumberCosh());
4726 return ReduceMathUnary(node, simplified()->NumberExp());
4728 return ReduceMathUnary(node, simplified()->NumberExpm1());
4730 return ReduceMathUnary(node, simplified()->NumberFloor());
4732 return ReduceMathUnary(node, simplified()->NumberFround());
4734 return ReduceMathUnary(node, simplified()->NumberLog());
4736 return ReduceMathUnary(node, simplified()->NumberLog1p());
4738 return ReduceMathUnary(node, simplified()->NumberLog10());
4740 return ReduceMathUnary(node, simplified()->NumberLog2());
4742 return ReduceMathUnary(node, simplified()->NumberRound());
4744 return ReduceMathUnary(node, simplified()->NumberSign());
4746 return ReduceMathUnary(node, simplified()->NumberSin());
4748 return ReduceMathUnary(node, simplified()->NumberSinh());
4750 return ReduceMathUnary(node, simplified()->NumberSqrt());
4752 return ReduceMathUnary(node, simplified()->NumberTan());
4754 return ReduceMathUnary(node, simplified()->NumberTanh());
4756 return ReduceMathUnary(node, simplified()->NumberTrunc());
4758 return ReduceMathBinary(node, simplified()->NumberAtan2());
4760 return ReduceMathBinary(node, simplified()->NumberPow());
4762 return ReduceMathClz32(node);
4764 return ReduceMathImul(node);
4766 return ReduceMathMinMax(node, simplified()->NumberMax(),
4769 return ReduceMathMinMax(node, simplified()->NumberMin(),
4772 return ReduceNumberIsFinite(node);
4774 return ReduceNumberIsInteger(node);
4776 return ReduceNumberIsSafeInteger(node);
4778 return ReduceNumberIsNaN(node);
4780 return ReduceNumberParseInt(node);
4782 return ReduceGlobalIsFinite(node);
4784 return ReduceGlobalIsNaN(node);
4786 return ReduceMapPrototypeGet(node);
4788 return ReduceMapPrototypeHas(node);
4790 return ReduceRegExpPrototypeTest(node);
4792 return ReduceReturnReceiver(node);
4795 node, StringIndexOfIncludesVariant::kIndexOf);
4798 node, StringIndexOfIncludesVariant::kIncludes);
4800 return ReduceStringPrototypeCharAt(node);
4803 node);
4806 node);
4808 return ReduceStringPrototypeSubstring(node);
4810 return ReduceStringPrototypeSlice(node);
4812 return ReduceStringPrototypeSubstr(node);
4814 return ReduceStringPrototypeStartsWith(node);
4817 return ReduceStringPrototypeToLowerCaseIntl(node);
4819 return ReduceStringPrototypeToUpperCaseIntl(node);
4822 return ReduceStringFromCharCode(node);
4824 return ReduceStringFromCodePoint(node);
4826 return ReduceStringPrototypeIterator(node);
4828 return ReduceStringPrototypeLocaleCompare(node);
4830 return ReduceStringIteratorPrototypeNext(node);
4832 return ReduceStringPrototypeConcat(node);
4834 return ReduceArrayIterator(node, ArrayIteratorKind::kTypedArray,
4837 return ReduceArrayIterator(node, ArrayIteratorKind::kTypedArray,
4840 return ReduceArrayIterator(node, ArrayIteratorKind::kTypedArray,
4843 return ReducePromisePrototypeCatch(node);
4845 return ReducePromisePrototypeFinally(node);
4847 return ReducePromisePrototypeThen(node);
4849 return ReducePromiseResolveTrampoline(node);
4851 return ReduceCollectionIteration(node, CollectionKind::kMap,
4854 return ReduceCollectionIteration(node, CollectionKind::kMap,
4857 return ReduceCollectionPrototypeSize(node, CollectionKind::kMap);
4859 return ReduceCollectionIteration(node, CollectionKind::kMap,
4863 node, OrderedHashMap::kEntrySize, factory()->empty_ordered_hash_map(),
4866 return ReduceCollectionIteration(node, CollectionKind::kSet,
4869 return ReduceCollectionPrototypeSize(node, CollectionKind::kSet);
4871 return ReduceCollectionIteration(node, CollectionKind::kSet,
4875 node, OrderedHashSet::kEntrySize, factory()->empty_ordered_hash_set(),
4878 return ReduceDatePrototypeGetTime(node);
4880 return ReduceDateNow(node);
4882 return ReduceNumberConstructor(node);
4885 return ReduceBigIntAsN(node, builtin);
4891 return ReduceCallApiFunction(node, shared);
4896 return ReduceCallWasmFunction(node, shared);
4955 bool TargetIsClassConstructor(Node* node, JSHeapBroker* broker) {
4956 Node* target = NodeProperties::GetValueInput(node, 0);
4981 Reduction JSCallReducer::ReduceJSCallWithArrayLike(Node* node) {
4982 JSCallWithArrayLikeNode n(node);
4987 if (TargetIsClassConstructor(node, broker())) {
4991 node, n.ArgumentCount(), n.LastArgumentIndex(), p.frequency(),
4996 Reduction JSCallReducer::ReduceJSCallWithSpread(Node* node) {
4997 JSCallWithSpreadNode n(node);
5002 if (TargetIsClassConstructor(node, broker())) {
5006 node, n.ArgumentCount(), n.LastArgumentIndex(), p.frequency(),
5011 Reduction JSCallReducer::ReduceJSConstruct(Node* node) {
5014 JSConstructNode n(node);
5027 node, DeoptimizeReason::kInsufficientTypeFeedbackForConstruct);
5047 // Turn the {node} into a {JSCreateArray} call.
5048 NodeProperties::ReplaceEffectInput(node, effect);
5050 node->ReplaceInput(n.NewTargetIndex(), array_function);
5051 node->RemoveInput(n.FeedbackVectorIndex());
5053 node, javascript()->CreateArray(arity,
5055 return Changed(node);
5068 // Specialize the JSConstruct node to the {new_target_feedback}.
5069 node->ReplaceInput(n.NewTargetIndex(), new_target_feedback);
5070 NodeProperties::ReplaceEffectInput(node, effect);
5072 node->ReplaceInput(n.TargetIndex(), new_target_feedback);
5075 // Try to further reduce the JSConstruct {node}.
5076 return Changed(node).FollowedBy(ReduceJSConstruct(node));
5080 // Try to specialize JSConstruct {node}s with constant {target}s.
5087 NodeProperties::ReplaceValueInputs(node, target);
5088 NodeProperties::ChangeOp(node,
5091 return Changed(node);
5115 // Turn the {node} into a {JSCreateArray} call.
5117 node->ReplaceInput(n.NewTargetIndex(), new_target);
5118 node->RemoveInput(n.FeedbackVectorIndex());
5120 node, javascript()->CreateArray(arity, base::nullopt));
5121 return Changed(node);
5125 // JSCreate and don't need to do any massaging of the {node}.
5127 node->RemoveInput(n.FeedbackVectorIndex());
5128 NodeProperties::ChangeOp(node, javascript()->Create());
5129 return Changed(node);
5139 node->RemoveInput(n.FeedbackVectorIndex());
5141 node->RemoveInput(n.ArgumentIndex(i));
5143 NodeProperties::ChangeOp(node, javascript()->Create());
5144 return Changed(node);
5149 return ReducePromiseConstructor(node);
5151 return ReduceTypedArrayConstructor(node, function.shared());
5174 // Patch {node} to use [[BoundTargetFunction]].
5175 node->ReplaceInput(n.TargetIndex(),
5178 // Patch {node} to use [[BoundTargetFunction]]
5181 node->ReplaceInput(n.NewTargetIndex(),
5184 node->ReplaceInput(
5193 // Insert the [[BoundArguments]] for {node}.
5195 node->InsertInput(graph()->zone(), n.ArgumentIndex(i), args[i]);
5199 // Update the JSConstruct operator on {node}.
5201 node, javascript()->Construct(JSConstructNode::ArityForArgc(arity),
5204 // Try to further reduce the JSConstruct {node}.
5205 return Changed(node).FollowedBy(ReduceJSConstruct(node));
5219 // Patch the {node} to use [[BoundTargetFunction]].
5220 node->ReplaceInput(n.TargetIndex(), bound_target_function);
5222 // Patch {node} to use [[BoundTargetFunction]]
5225 node->ReplaceInput(n.NewTargetIndex(), bound_target_function);
5227 node->ReplaceInput(
5235 // Insert the [[BoundArguments]] for {node}.
5238 node->InsertInput(graph()->zone(), n.ArgumentIndex(i), value);
5242 // Update the JSConstruct operator on {node}.
5244 node, javascript()->Construct(JSConstructNode::ArityForArgc(arity),
5247 // Try to further reduce the JSConstruct {node}.
5248 return Changed(node).FollowedBy(ReduceJSConstruct(node));
5257 Node* node, StringIndexOfIncludesVariant variant) {
5258 JSCallNode n(node);
5291 NodeProperties::ReplaceEffectInput(node, effect);
5292 RelaxEffectsAndControls(node);
5293 node->ReplaceInput(0, new_receiver);
5294 node->ReplaceInput(1, new_search_string);
5295 node->ReplaceInput(2, new_position);
5296 node->TrimInputCount(3);
5297 NodeProperties::ChangeOp(node, simplified()->StringIndexOf());
5300 return Changed(node);
5305 graph()->NewNode(simplified()->NumberEqual(), node,
5314 Reduction JSCallReducer::ReduceStringPrototypeSubstring(Node* node) {
5315 JSCallNode n(node);
5322 JSCallReducerAssembler a(this, node);
5328 Reduction JSCallReducer::ReduceStringPrototypeSlice(Node* node) {
5329 JSCallNode n(node);
5336 JSCallReducerAssembler a(this, node);
5342 Reduction JSCallReducer::ReduceStringPrototypeSubstr(Node* node) {
5343 JSCallNode n(node);
5439 ReplaceWithValue(node, result_string, effect, control);
5443 Reduction JSCallReducer::ReduceJSConstructWithArrayLike(Node* node) {
5444 JSConstructWithArrayLikeNode n(node);
5449 node, n.ArgumentCount(), arraylike_index, p.frequency(), p.feedback(),
5454 Reduction JSCallReducer::ReduceJSConstructWithSpread(Node* node) {
5455 JSConstructWithSpreadNode n(node);
5460 node, n.ArgumentCount(), spread_index, p.frequency(), p.feedback(),
5465 Reduction JSCallReducer::ReduceReturnReceiver(Node* node) {
5466 JSCallNode n(node);
5468 ReplaceWithValue(node, receiver);
5473 Node* node, DeoptimizeReason reason) {
5474 DCHECK(node->opcode() == IrOpcode::kJSCall ||
5475 node->opcode() == IrOpcode::kJSConstruct);
5478 Node* effect = NodeProperties::GetEffectInput(node);
5479 Node* control = NodeProperties::GetControlInput(node);
5481 NodeProperties::FindFrameStateBefore(node, jsgraph()->Dead());
5488 node->TrimInputCount(0);
5489 NodeProperties::ChangeOp(node, common()->Dead());
5490 return Changed(node);
5543 Reduction JSCallReducer::ReduceArrayPrototypePush(Node* node) {
5544 JSCallNode n(node);
5676 ReplaceWithValue(node, return_value, effect, control);
5681 Reduction JSCallReducer::ReduceArrayPrototypePop(Node* node) {
5682 JSCallNode n(node);
5820 ReplaceWithValue(node, value, effect, control);
5825 Reduction JSCallReducer::ReduceArrayPrototypeShift(Node* node) {
5826 JSCallNode n(node);
6007 Builtins::name(builtin), node->op()->properties(),
6062 ReplaceWithValue(node, value, effect, control);
6067 Reduction JSCallReducer::ReduceArrayPrototypeSlice(Node* node) {
6069 JSCallNode n(node);
6139 ReplaceWithValue(node, clone, effect, control);
6144 Reduction JSCallReducer::ReduceArrayIsArray(Node* node) {
6146 JSCallNode n(node);
6149 ReplaceWithValue(node, value);
6158 node->ReplaceInput(0, object);
6159 node->ReplaceInput(1, context);
6160 node->ReplaceInput(2, frame_state);
6161 node->ReplaceInput(3, effect);
6162 node->ReplaceInput(4, control);
6163 node->TrimInputCount(5);
6164 NodeProperties::ChangeOp(node, javascript()->ObjectIsArray());
6165 return Changed(node);
6168 Reduction JSCallReducer::ReduceArrayIterator(Node* node,
6171 JSCallNode n(node);
6193 CallParameters const& p = CallParametersOf(node->op());
6216 // Morph the {node} into a JSCreateArrayIterator with the given {kind}.
6217 RelaxControls(node);
6218 node->ReplaceInput(0, receiver);
6219 node->ReplaceInput(1, context);
6220 node->ReplaceInput(2, effect);
6221 node->ReplaceInput(3, control);
6222 node->TrimInputCount(4);
6223 NodeProperties::ChangeOp(node,
6225 return Changed(node);
6229 Reduction JSCallReducer::ReduceArrayIteratorPrototypeNext(Node* node) {
6230 JSCallNode n(node);
6469 ReplaceWithValue(node, value, effect, control);
6476 const Operator* string_access_operator, Node* node) {
6479 JSCallNode n(node);
6506 ReplaceWithValue(node, value, effect, control);
6512 Reduction JSCallReducer::ReduceStringPrototypeStartsWith(Node* node) {
6513 JSCallNode n(node);
6539 JSCallReducerAssembler a(this, node);
6547 JSCallReducerAssembler a(this, node);
6553 Reduction JSCallReducer::ReduceStringPrototypeCharAt(Node* node) {
6554 JSCallNode n(node);
6582 ReplaceWithValue(node, value, effect, control);
6588 Reduction JSCallReducer::ReduceStringPrototypeToLowerCaseIntl(Node* node) {
6589 JSCallNode n(node);
6600 NodeProperties::ReplaceEffectInput(node, effect);
6601 RelaxEffectsAndControls(node);
6602 node->ReplaceInput(0, receiver);
6603 node->TrimInputCount(1);
6604 NodeProperties::ChangeOp(node, simplified()->StringToLowerCaseIntl());
6605 NodeProperties::SetType(node, Type::String());
6606 return Changed(node);
6609 Reduction JSCallReducer::ReduceStringPrototypeToUpperCaseIntl(Node* node) {
6610 JSCallNode n(node);
6621 NodeProperties::ReplaceEffectInput(node, effect);
6622 RelaxEffectsAndControls(node);
6623 node->ReplaceInput(0, receiver);
6624 node->TrimInputCount(1);
6625 NodeProperties::ChangeOp(node, simplified()->StringToUpperCaseIntl());
6626 NodeProperties::SetType(node, Type::String());
6627 return Changed(node);
6633 Reduction JSCallReducer::ReduceStringFromCharCode(Node* node) {
6634 JSCallNode n(node);
6651 ReplaceWithValue(node, value, effect);
6658 Reduction JSCallReducer::ReduceStringFromCodePoint(Node* node) {
6659 JSCallNode n(node);
6677 ReplaceWithValue(node, value, effect);
6681 Reduction JSCallReducer::ReduceStringPrototypeIterator(Node* node) {
6682 JSCallNode n(node);
6687 Node* effect = NodeProperties::GetEffectInput(node);
6688 Node* control = NodeProperties::GetControlInput(node);
6694 ReplaceWithValue(node, iterator, effect, control);
6698 Reduction JSCallReducer::ReduceStringPrototypeLocaleCompare(Node* node) {
6700 JSCallNode n(node);
6747 node->RemoveInput(n.FeedbackVectorIndex());
6749 node->RemoveInput(n.ArgumentIndex(2));
6751 node->InsertInput(graph()->zone(), n.LastArgumentIndex() + 1,
6756 node->InsertInput(graph()->zone(), 0,
6758 NodeProperties::ChangeOp(node, common()->Call(call_descriptor));
6759 return Changed(node);
6765 Reduction JSCallReducer::ReduceStringIteratorPrototypeNext(Node* node) {
6766 JSCallNode n(node);
6829 ReplaceWithValue(node, value, effect, control);
6834 Reduction JSCallReducer::ReduceStringPrototypeConcat(Node* node) {
6835 JSCallNode n(node);
6849 ReplaceWithValue(node, receiver, effect, control);
6868 ReplaceWithValue(node, value, effect, control);
6872 Reduction JSCallReducer::ReducePromiseConstructor(Node* node) {
6873 PromiseBuiltinReducerAssembler a(this, node, broker());
6903 Reduction JSCallReducer::ReducePromisePrototypeCatch(Node* node) {
6904 JSCallNode n(node);
6923 // Massage the {node} to call "then" instead by first removing all inputs
6927 NodeProperties::ReplaceValueInput(node, target, 0);
6928 NodeProperties::ReplaceEffectInput(node, effect);
6929 for (; arity > 1; --arity) node->RemoveInput(3);
6931 node->InsertInput(graph()->zone(), 2, jsgraph()->UndefinedConstant());
6934 node, javascript()->Call(
6938 return Changed(node).FollowedBy(ReducePromisePrototypeThen(node));
6955 Reduction JSCallReducer::ReducePromisePrototypeFinally(Node* node) {
6956 JSCallNode n(node);
7054 // Massage the {node} to call "then" instead by first removing all inputs
7058 NodeProperties::ReplaceValueInput(node, target, n.TargetIndex());
7059 NodeProperties::ReplaceEffectInput(node, effect);
7060 NodeProperties::ReplaceControlInput(node, control);
7061 for (; arity > 2; --arity) node->RemoveInput(2);
7063 node->InsertInput(graph()->zone(), 2, then_finally);
7065 node->ReplaceInput(2, then_finally);
7066 node->ReplaceInput(3, catch_finally);
7068 node, javascript()->Call(
7072 return Changed(node).FollowedBy(ReducePromisePrototypeThen(node));
7075 Reduction JSCallReducer::ReducePromisePrototypeThen(Node* node) {
7076 JSCallNode n(node);
7135 ReplaceWithValue(node, promise, effect, control);
7140 Reduction JSCallReducer::ReducePromiseResolveTrampoline(Node* node) {
7141 JSCallNode n(node);
7155 // Morph the {node} into a JSPromiseResolve operation.
7156 node->ReplaceInput(0, receiver);
7157 node->ReplaceInput(1, value);
7158 node->ReplaceInput(2, context);
7159 node->ReplaceInput(3, frame_state);
7160 node->ReplaceInput(4, effect);
7161 node->ReplaceInput(5, control);
7162 node->TrimInputCount(6);
7163 NodeProperties::ChangeOp(node, javascript()->PromiseResolve());
7164 return Changed(node);
7169 Node* node, const SharedFunctionInfoRef& shared) {
7170 JSConstructNode n(node);
7186 node, frame_state, arity, BytecodeOffset::ConstructStubInvoke(),
7206 Reduction JSCallReducer::ReduceTypedArrayPrototypeToStringTag(Node* node) {
7207 Node* receiver = NodeProperties::GetValueInput(node, 1);
7208 Node* effect = NodeProperties::GetEffectInput(node);
7209 Node* control = NodeProperties::GetControlInput(node);
7273 ReplaceWithValue(node, value, effect, control);
7278 Reduction JSCallReducer::ReduceNumberIsFinite(Node* node) {
7279 JSCallNode n(node);
7282 ReplaceWithValue(node, value);
7287 ReplaceWithValue(node, value);
7292 Reduction JSCallReducer::ReduceNumberIsInteger(Node* node) {
7293 JSCallNode n(node);
7296 ReplaceWithValue(node, value);
7301 ReplaceWithValue(node, value);
7306 Reduction JSCallReducer::ReduceNumberIsSafeInteger(Node* node) {
7307 JSCallNode n(node);
7310 ReplaceWithValue(node, value);
7315 ReplaceWithValue(node, value);
7320 Reduction JSCallReducer::ReduceNumberIsNaN(Node* node) {
7321 JSCallNode n(node);
7324 ReplaceWithValue(node, value);
7329 ReplaceWithValue(node, value);
7333 Reduction JSCallReducer::ReduceMapPrototypeGet(Node* node) {
7335 JSCallNode n(node);
7337 Node* receiver = NodeProperties::GetValueInput(node, 1);
7338 Effect effect{NodeProperties::GetEffectInput(node)};
7339 Control control{NodeProperties::GetControlInput(node)};
7340 Node* key = NodeProperties::GetValueInput(node, 2);
7376 ReplaceWithValue(node, value, effect, control);
7380 Reduction JSCallReducer::ReduceMapPrototypeHas(Node* node) {
7382 JSCallNode n(node);
7384 Node* receiver = NodeProperties::GetValueInput(node, 1);
7385 Effect effect{NodeProperties::GetEffectInput(node)};
7386 Control control{NodeProperties::GetControlInput(node)};
7387 Node* key = NodeProperties::GetValueInput(node, 2);
7405 ReplaceWithValue(node, value, effect, control);
7424 Node* node, CollectionKind collection_kind, IterationKind iteration_kind) {
7425 DCHECK_EQ(IrOpcode::kJSCall, node->opcode());
7426 Node* receiver = NodeProperties::GetValueInput(node, 1);
7427 Node* context = NodeProperties::GetContextInput(node);
7428 Effect effect{NodeProperties::GetEffectInput(node)};
7429 Control control{NodeProperties::GetControlInput(node)};
7440 ReplaceWithValue(node, js_create_iterator, effect);
7445 Node* node, CollectionKind collection_kind) {
7446 DCHECK_EQ(IrOpcode::kJSCall, node->opcode());
7447 Node* receiver = NodeProperties::GetValueInput(node, 1);
7448 Effect effect{NodeProperties::GetEffectInput(node)};
7449 Control control{NodeProperties::GetControlInput(node)};
7464 ReplaceWithValue(node, value, effect, control);
7469 Node* node, int entry_size, Handle<HeapObject> empty_collection,
7472 JSCallNode n(node);
7589 // a dominating Allocate node for the allocation folding phase.
7757 ReplaceWithValue(node, iterator_result, effect, control);
7761 Reduction JSCallReducer::ReduceArrayBufferIsView(Node* node) {
7762 JSCallNode n(node);
7764 RelaxEffectsAndControls(node);
7765 node->ReplaceInput(0, value);
7766 node->TrimInputCount(1);
7767 NodeProperties::ChangeOp(node, simplified()->ObjectIsArrayBufferView());
7768 return Changed(node);
7772 Node* node, InstanceType instance_type, FieldAccess const& access) {
7773 Node* receiver = NodeProperties::GetValueInput(node, 1);
7774 Effect effect{NodeProperties::GetEffectInput(node)};
7775 Control control{NodeProperties::GetControlInput(node)};
7805 // deoptimization loops right now, since the JSCall {node} is usually
7813 ReplaceWithValue(node, value, effect, control);
7832 Reduction JSCallReducer::ReduceDataViewAccess(Node* node, DataViewAccess access,
7834 JSCallNode n(node);
7963 ReplaceWithValue(node, value, effect, control);
7968 Reduction JSCallReducer::ReduceGlobalIsFinite(Node* node) {
7969 JSCallNode n(node);
7976 ReplaceWithValue(node, value);
7989 ReplaceWithValue(node, value, effect);
7994 Reduction JSCallReducer::ReduceGlobalIsNaN(Node* node) {
7995 JSCallNode n(node);
8002 ReplaceWithValue(node, value);
8015 ReplaceWithValue(node, value, effect);
8020 Reduction JSCallReducer::ReduceDatePrototypeGetTime(Node* node) {
8021 Node* receiver = NodeProperties::GetValueInput(node, 1);
8022 Effect effect{NodeProperties::GetEffectInput(node)};
8023 Control control{NodeProperties::GetControlInput(node)};
8033 ReplaceWithValue(node, value, effect, control);
8038 Reduction JSCallReducer::ReduceDateNow(Node* node) {
8039 Node* effect = NodeProperties::GetEffectInput(node);
8040 Node* control = NodeProperties::GetControlInput(node);
8043 ReplaceWithValue(node, value, effect, control);
8048 Reduction JSCallReducer::ReduceNumberParseInt(Node* node) {
8049 JSCallNode n(node);
8052 ReplaceWithValue(node, value);
8062 node->ReplaceInput(0, object);
8063 node->ReplaceInput(1, radix);
8064 node->ReplaceInput(2, context);
8065 node->ReplaceInput(3, frame_state);
8066 node->ReplaceInput(4, effect);
8067 node->ReplaceInput(5, control);
8068 node->TrimInputCount(6);
8069 NodeProperties::ChangeOp(node, javascript()->ParseInt());
8070 return Changed(node);
8073 Reduction JSCallReducer::ReduceRegExpPrototypeTest(Node* node) {
8074 JSCallNode n(node);
8152 node->ReplaceInput(0, regexp);
8153 node->ReplaceInput(1, search_string);
8154 node->ReplaceInput(2, context);
8155 node->ReplaceInput(3, frame_state);
8156 node->ReplaceInput(4, effect);
8157 node->ReplaceInput(5, control);
8158 node->TrimInputCount(6);
8159 NodeProperties::ChangeOp(node, javascript()->RegExpTest());
8160 return Changed(node);
8164 Reduction JSCallReducer::ReduceNumberConstructor(Node* node) {
8165 JSCallNode n(node);
8184 NodeProperties::ReplaceValueInputs(node, value);
8185 NodeProperties::ChangeOp(node, javascript()->ToNumberConvertBigInt());
8186 NodeProperties::ReplaceFrameStateInput(node, continuation_frame_state);
8187 return Changed(node);
8190 Reduction JSCallReducer::ReduceBigIntAsN(Node* node, Builtin builtin) {
8196 JSCallNode n(node);
8219 ReplaceWithValue(node, value, effect);