Lines Matching refs:Node
12 #include "src/compiler/node-matchers.h"
13 #include "src/compiler/node-properties.h"
14 #include "src/compiler/node.h"
45 Node* current_effect = nullptr; // New effect.
46 Node* current_control = nullptr; // New control.
47 Node* current_frame_state = nullptr; // New frame state.
71 Node* effect_phi;
74 PendingEffectPhi(Node* effect_phi, BasicBlock* block)
78 void UpdateEffectPhi(Node* node, BasicBlock* block,
82 DCHECK_EQ(IrOpcode::kEffectPhi, node->opcode());
83 DCHECK_EQ(static_cast<size_t>(node->op()->EffectInputCount()),
85 for (int i = 0; i < node->op()->EffectInputCount(); i++) {
86 Node* input = node->InputAt(i);
91 node->ReplaceInput(i, block_effect.current_effect);
98 Node* control = block->NodeAt(0);
101 // Do not rewire the end node.
104 // Update all inputs to the given control node with the correct control.
110 return; // We already re-wired the control inputs of this node.
113 Node* input = NodeProperties::GetControlInput(control, i);
133 void RemoveRegionNode(Node* node) {
134 DCHECK(IrOpcode::kFinishRegion == node->opcode() ||
135 IrOpcode::kBeginRegion == node->opcode());
136 // Update the value/context uses to the value input of the finish node and
138 for (Edge edge : node->use_edges()) {
141 edge.UpdateTo(NodeProperties::GetEffectInput(node));
145 edge.UpdateTo(node->InputAt(0));
148 node->Kill();
151 void TryCloneBranch(Node* node, BasicBlock* block, Graph* graph,
155 DCHECK_EQ(IrOpcode::kBranch, node->opcode());
158 // input graph as shown below and clones the Branch node for every predecessor
207 source_positions->GetSourcePosition(node));
208 Node* branch = node;
209 Node* cond = NodeProperties::GetValueInput(branch, 0);
211 Node* merge = NodeProperties::GetControlInput(branch);
220 for (Node* const use : merge->uses()) {
232 Node* control = NodeProperties::GetControlInput(edge.from());
243 Node** const inputs = graph->zone()->NewArray<Node*>(2 * input_count);
244 Node** const merge_true_inputs = &inputs[0];
245 Node** const merge_false_inputs = &inputs[input_count];
247 Node* cond1 = NodeProperties::GetValueInput(cond, index);
248 Node* control1 = NodeProperties::GetControlInput(merge, index);
249 Node* branch1 = graph->NewNode(common->Branch(hint), cond1, control1);
253 Node* const merge_true = matcher.IfTrue();
254 Node* const merge_false = matcher.IfFalse();
270 for (Node* const phi : phis) {
275 Node* phi_true = graph->NewNode(phi->op(), input_count + 1, inputs);
277 Node* phi_false = graph->NewNode(phi->op(), input_count + 1, inputs);
282 Node* control = NodeProperties::GetControlInput(edge.from());
316 // The control node should be the first.
317 Node* control = block->NodeAt(instr);
332 Node* effect = nullptr;
333 Node* terminate = nullptr;
335 Node* node = block->NodeAt(instr);
337 if (node->opcode() == IrOpcode::kEffectPhi) {
342 effect = node;
349 pending_effect_phis.push_back(PendingEffectPhi(node, block));
351 UpdateEffectPhi(node, block, &block_effects);
353 } else if (node->opcode() == IrOpcode::kPhi) {
355 } else if (node->opcode() == IrOpcode::kTerminate) {
357 terminate = node;
390 // to create an effect phi node.
397 // For loops, we update the effect phi node later to break cycles.
412 // Fixup the Terminate node.
422 Node* frame_state = nullptr;
439 Node* node = block->NodeAt(instr);
440 ProcessNode(node, &frame_state, &effect, &control);
490 void TryScheduleCallIfSuccess(Node* node, Node** control) {
491 // Schedule the call's IfSuccess node if there is no exception use.
492 if (!NodeProperties::IsExceptionalCall(node)) {
493 for (Edge edge : node->use_edges()) {
504 void EffectControlLinearizer::ProcessNode(Node* node, Node** frame_state,
505 Node** effect, Node** control) {
507 source_positions_->GetSourcePosition(node));
509 // If the node needs to be wired into the effect/control chain, do this
511 if (TryWireInStateEffect(node, *frame_state, effect, control)) {
515 // If the node has a visible effect, then there must be a checkpoint in the
519 !node->op()->HasProperty(Operator::kNoWrite)) {
525 if (node->opcode() == IrOpcode::kFinishRegion) {
528 // Update the value uses to the value input of the finish node and
530 return RemoveRegionNode(node);
532 if (node->opcode() == IrOpcode::kBeginRegion) {
537 region_observability_ = RegionObservabilityOf(node->op());
538 // Update the value uses to the value input of the finish node and
540 return RemoveRegionNode(node);
544 if (node->opcode() == IrOpcode::kCheckpoint) {
548 *frame_state = NodeProperties::GetFrameStateInput(node);
552 if (node->opcode() == IrOpcode::kIfSuccess) {
554 DCHECK_EQ(IrOpcode::kCall, node->InputAt(0)->opcode());
555 // The IfSuccess node should not belong to an exceptional call node
558 DCHECK(!NodeProperties::IsExceptionalCall(node->InputAt(0)));
562 // If the node takes an effect, replace with the current one.
563 if (node->op()->EffectInputCount() > 0) {
564 DCHECK_EQ(1, node->op()->EffectInputCount());
565 Node* input_effect = NodeProperties::GetEffectInput(node);
568 NodeProperties::ReplaceEffectInput(node, *effect);
571 // If the node produces an effect, update our current effect. (However,
573 if (node->op()->EffectOutputCount() > 0) {
574 DCHECK_EQ(1, node->op()->EffectOutputCount());
575 *effect = node;
578 // New effect chain is only started with a Start or ValueEffect node.
579 DCHECK(node->op()->EffectOutputCount() == 0 ||
580 node->opcode() == IrOpcode::kStart);
584 for (int i = 0; i < node->op()->ControlInputCount(); i++) {
585 NodeProperties::ReplaceControlInput(node, *control, i);
588 if (node->op()->ControlOutputCount() > 0) {
589 *control = node;
590 if (node->opcode() == IrOpcode::kCall) {
591 // Schedule the call's IfSuccess node (if there is no exception use).
592 TryScheduleCallIfSuccess(node, control);
597 bool EffectControlLinearizer::TryWireInStateEffect(Node* node,
598 Node* frame_state,
599 Node** effect,
600 Node** control) {
602 Node* result = nullptr;
603 switch (node->opcode()) {
605 result = LowerChangeBitToTagged(node);
608 result = LowerChangeInt31ToTaggedSigned(node);
611 result = LowerChangeInt32ToTagged(node);
614 result = LowerChangeUint32ToTagged(node);
617 result = LowerChangeFloat64ToTagged(node);
620 result = LowerChangeFloat64ToTaggedPointer(node);
623 result = LowerChangeTaggedSignedToInt32(node);
626 result = LowerChangeTaggedToBit(node);
629 result = LowerChangeTaggedToInt32(node);
632 result = LowerChangeTaggedToUint32(node);
635 result = LowerChangeTaggedToFloat64(node);
638 result = LowerChangeTaggedToTaggedSigned(node);
641 result = LowerTruncateTaggedToBit(node);
644 result = LowerTruncateTaggedToFloat64(node);
647 result = LowerCheckBounds(node, frame_state);
650 result = LowerCheckMaps(node, frame_state);
653 result = LowerCheckNumber(node, frame_state);
656 result = LowerCheckReceiver(node, frame_state);
659 result = LowerCheckString(node, frame_state);
662 result = LowerCheckInternalizedString(node, frame_state);
665 result = LowerCheckIf(node, frame_state);
668 result = LowerCheckedInt32Add(node, frame_state);
671 result = LowerCheckedInt32Sub(node, frame_state);
674 result = LowerCheckedInt32Div(node, frame_state);
677 result = LowerCheckedInt32Mod(node, frame_state);
680 result = LowerCheckedUint32Div(node, frame_state);
683 result = LowerCheckedUint32Mod(node, frame_state);
686 result = LowerCheckedInt32Mul(node, frame_state);
689 result = LowerCheckedInt32ToTaggedSigned(node, frame_state);
692 result = LowerCheckedUint32ToInt32(node, frame_state);
695 result = LowerCheckedUint32ToTaggedSigned(node, frame_state);
698 result = LowerCheckedFloat64ToInt32(node, frame_state);
701 result = LowerCheckedTaggedSignedToInt32(node, frame_state);
704 result = LowerCheckedTaggedToInt32(node, frame_state);
707 result = LowerCheckedTaggedToFloat64(node, frame_state);
710 result = LowerCheckedTaggedToTaggedSigned(node, frame_state);
713 result = LowerCheckedTaggedToTaggedPointer(node, frame_state);
716 result = LowerTruncateTaggedToWord32(node);
719 result = LowerCheckedTruncateTaggedToWord32(node, frame_state);
722 result = LowerObjectIsDetectableCallable(node);
725 result = LowerObjectIsNonCallable(node);
728 result = LowerObjectIsNumber(node);
731 result = LowerObjectIsReceiver(node);
734 result = LowerObjectIsSmi(node);
737 result = LowerObjectIsString(node);
740 result = LowerObjectIsUndetectable(node);
743 result = LowerNewRestParameterElements(node);
746 result = LowerNewUnmappedArgumentsElements(node);
749 result = LowerArrayBufferWasNeutered(node);
752 result = LowerStringFromCharCode(node);
755 result = LowerStringFromCodePoint(node);
758 result = LowerStringIndexOf(node);
761 result = LowerStringCharAt(node);
764 result = LowerStringCharCodeAt(node);
767 result = LowerStringEqual(node);
770 result = LowerStringLessThan(node);
773 result = LowerStringLessThanOrEqual(node);
776 result = LowerCheckFloat64Hole(node, frame_state);
779 result = LowerCheckTaggedHole(node, frame_state);
782 result = LowerConvertTaggedHoleToUndefined(node);
785 result = LowerPlainPrimitiveToNumber(node);
788 result = LowerPlainPrimitiveToWord32(node);
791 result = LowerPlainPrimitiveToFloat64(node);
794 result = LowerEnsureWritableFastElements(node);
797 result = LowerMaybeGrowFastElements(node, frame_state);
800 LowerTransitionElementsKind(node);
803 result = LowerLoadTypedElement(node);
806 LowerStoreTypedElement(node);
809 if (!LowerFloat64RoundUp(node).To(&result)) {
814 if (!LowerFloat64RoundDown(node).To(&result)) {
819 if (!LowerFloat64RoundTruncate(node).To(&result)) {
824 if (!LowerFloat64RoundTiesEven(node).To(&result)) {
833 NodeProperties::ReplaceUses(node, result, *effect, *control);
839 Node* EffectControlLinearizer::LowerChangeFloat64ToTagged(Node* node) {
840 Node* value = node->InputAt(0);
844 Node* EffectControlLinearizer::LowerChangeFloat64ToTaggedPointer(Node* node) {
845 Node* value = node->InputAt(0);
849 Node* EffectControlLinearizer::LowerChangeBitToTagged(Node* node) {
850 Node* value = node->InputAt(0);
865 Node* EffectControlLinearizer::LowerChangeInt31ToTaggedSigned(Node* node) {
866 Node* value = node->InputAt(0);
870 Node* EffectControlLinearizer::LowerChangeInt32ToTagged(Node* node) {
871 Node* value = node->InputAt(0);
880 Node* add = __ Int32AddWithOverflow(value, value);
881 Node* ovf = __ Projection(1, add);
886 Node* number = AllocateHeapNumberWithValue(__ ChangeInt32ToFloat64(value));
893 Node* EffectControlLinearizer::LowerChangeUint32ToTagged(Node* node) {
894 Node* value = node->InputAt(0);
899 Node* check = __ Uint32LessThanOrEqual(value, SmiMaxValueConstant());
904 Node* number = AllocateHeapNumberWithValue(__ ChangeUint32ToFloat64(value));
912 Node* EffectControlLinearizer::LowerChangeTaggedSignedToInt32(Node* node) {
913 Node* value = node->InputAt(0);
917 Node* EffectControlLinearizer::LowerChangeTaggedToBit(Node* node) {
918 Node* value = node->InputAt(0);
922 Node* EffectControlLinearizer::LowerTruncateTaggedToBit(Node* node) {
923 Node* value = node->InputAt(0);
929 Node* zero = __ Int32Constant(0);
930 Node* fzero = __ Float64Constant(0.0);
936 Node* check_smi = ObjectIsSmi(value);
943 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
946 Node* value_map_bitfield =
965 Node* value_value =
981 Node* EffectControlLinearizer::LowerChangeTaggedToInt32(Node* node) {
982 Node* value = node->InputAt(0);
987 Node* check = ObjectIsSmi(value);
993 Node* vfalse = __ LoadField(AccessBuilder::ForHeapNumberValue(), value);
1001 Node* EffectControlLinearizer::LowerChangeTaggedToUint32(Node* node) {
1002 Node* value = node->InputAt(0);
1007 Node* check = ObjectIsSmi(value);
1013 Node* vfalse = __ LoadField(AccessBuilder::ForHeapNumberValue(), value);
1021 Node* EffectControlLinearizer::LowerChangeTaggedToFloat64(Node* node) {
1022 return LowerTruncateTaggedToFloat64(node);
1025 Node* EffectControlLinearizer::LowerChangeTaggedToTaggedSigned(Node* node) {
1026 Node* value = node->InputAt(0);
1031 Node* check = ObjectIsSmi(value);
1037 Node* vfalse = __ LoadField(AccessBuilder::ForHeapNumberValue(), value);
1046 Node* EffectControlLinearizer::LowerTruncateTaggedToFloat64(Node* node) {
1047 Node* value = node->InputAt(0);
1052 Node* check = ObjectIsSmi(value);
1054 Node* vtrue = ChangeSmiToInt32(value);
1060 Node* vfalse = __ LoadField(AccessBuilder::ForHeapNumberValue(), value);
1067 Node* EffectControlLinearizer::LowerCheckBounds(Node* node, Node* frame_state) {
1068 Node* index = node->InputAt(0);
1069 Node* limit = node->InputAt(1);
1071 Node* check = __ Uint32LessThan(index, limit);
1076 Node* EffectControlLinearizer::LowerCheckMaps(Node* node, Node* frame_state) {
1077 CheckMapsParameters const& p = CheckMapsParametersOf(node->op());
1078 Node* value = node->InputAt(0);
1089 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1093 Node* map = __ HeapConstant(maps[i]);
1094 Node* check = __ WordEqual(value_map, map);
1107 Node* bitfield3 =
1109 Node* if_not_deprecated = __ WordEqual(
1119 Node* result =
1123 Node* check = ObjectIsSmi(result);
1133 Node* map = __ HeapConstant(maps[i]);
1134 Node* check = __ WordEqual(value_map, map);
1149 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1152 Node* map = __ HeapConstant(maps[i]);
1153 Node* check = __ WordEqual(value_map, map);
1166 Node* EffectControlLinearizer::LowerCheckNumber(Node* node, Node* frame_state) {
1167 Node* value = node->InputAt(0);
1172 Node* check0 = ObjectIsSmi(value);
1177 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1178 Node* check1 = __ WordEqual(value_map, __ HeapNumberMapConstant());
1186 Node* EffectControlLinearizer::LowerCheckReceiver(Node* node,
1187 Node* frame_state) {
1188 Node* value = node->InputAt(0);
1190 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1191 Node* value_instance_type =
1195 Node* check = __ Uint32LessThanOrEqual(
1202 Node* EffectControlLinearizer::LowerCheckString(Node* node, Node* frame_state) {
1203 Node* value = node->InputAt(0);
1205 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1206 Node* value_instance_type =
1209 Node* check = __ Uint32LessThan(value_instance_type,
1215 Node* EffectControlLinearizer::LowerCheckInternalizedString(Node* node,
1216 Node* frame_state) {
1217 Node* value = node->InputAt(0);
1219 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1220 Node* value_instance_type =
1223 Node* check = __ Word32Equal(
1232 Node* EffectControlLinearizer::LowerCheckIf(Node* node, Node* frame_state) {
1233 Node* value = node->InputAt(0);
1239 Node* EffectControlLinearizer::LowerCheckedInt32Add(Node* node,
1240 Node* frame_state) {
1241 Node* lhs = node->InputAt(0);
1242 Node* rhs = node->InputAt(1);
1244 Node* value = __ Int32AddWithOverflow(lhs, rhs);
1245 Node* check = __ Projection(1, value);
1250 Node* EffectControlLinearizer::LowerCheckedInt32Sub(Node* node,
1251 Node* frame_state) {
1252 Node* lhs = node->InputAt(0);
1253 Node* rhs = node->InputAt(1);
1255 Node* value = __ Int32SubWithOverflow(lhs, rhs);
1256 Node* check = __ Projection(1, value);
1261 Node* EffectControlLinearizer::LowerCheckedInt32Div(Node* node,
1262 Node* frame_state) {
1263 Node* lhs = node->InputAt(0);
1264 Node* rhs = node->InputAt(1);
1271 Node* zero = __ Int32Constant(0);
1274 Node* check0 = __ Int32LessThan(zero, rhs);
1284 Node* check = __ Word32Equal(rhs, zero);
1293 Node* minint = __ Int32Constant(std::numeric_limits<int32_t>::min());
1294 Node* check1 = graph()->NewNode(machine()->Word32Equal(), lhs, minint);
1300 Node* minusone = __ Int32Constant(-1);
1301 Node* is_minus_one = __ Word32Equal(rhs, minusone);
1311 Node* value = done.PhiAt(0);
1314 Node* check = __ Word32Equal(lhs, __ Int32Mul(rhs, value));
1320 Node* EffectControlLinearizer::LowerCheckedInt32Mod(Node* node,
1321 Node* frame_state) {
1339 Node* lhs = node->InputAt(0);
1340 Node* rhs = node->InputAt(1);
1348 Node* zero = __ Int32Constant(0);
1351 Node* check0 = __ Int32LessThanOrEqual(rhs, zero);
1359 Node* vtrue0 = __ Int32Sub(zero, rhs);
1362 Node* check = __ Word32Equal(vtrue0, zero);
1371 Node* check1 = __ Int32LessThan(lhs, zero);
1376 Node* one = __ Int32Constant(1);
1377 Node* msk = __ Int32Sub(rhs, one);
1380 Node* check2 = __ Word32Equal(__ Word32And(rhs, msk), zero);
1393 Node* vtrue1 = __ Int32Mod(lhs, rhs);
1396 Node* check = __ Word32Equal(vtrue1, zero);
1405 Node* EffectControlLinearizer::LowerCheckedUint32Div(Node* node,
1406 Node* frame_state) {
1407 Node* lhs = node->InputAt(0);
1408 Node* rhs = node->InputAt(1);
1410 Node* zero = __ Int32Constant(0);
1413 Node* check = __ Word32Equal(rhs, zero);
1417 Node* value = __ Uint32Div(lhs, rhs);
1425 Node* EffectControlLinearizer::LowerCheckedUint32Mod(Node* node,
1426 Node* frame_state) {
1427 Node* lhs = node->InputAt(0);
1428 Node* rhs = node->InputAt(1);
1430 Node* zero = __ Int32Constant(0);
1433 Node* check = __ Word32Equal(rhs, zero);
1440 Node* EffectControlLinearizer::LowerCheckedInt32Mul(Node* node,
1441 Node* frame_state) {
1442 CheckForMinusZeroMode mode = CheckMinusZeroModeOf(node->op());
1443 Node* lhs = node->InputAt(0);
1444 Node* rhs = node->InputAt(1);
1446 Node* projection = __ Int32MulWithOverflow(lhs, rhs);
1447 Node* check = __ Projection(1, projection);
1450 Node* value = __ Projection(0, projection);
1455 Node* zero = __ Int32Constant(0);
1456 Node* check_zero = __ Word32Equal(value, zero);
1462 Node* check_or = __ Int32LessThan(__ Word32Or(lhs, rhs), zero);
1472 Node* EffectControlLinearizer::LowerCheckedInt32ToTaggedSigned(
1473 Node* node, Node* frame_state) {
1475 Node* value = node->InputAt(0);
1477 Node* add = __ Int32AddWithOverflow(value, value);
1478 Node* check = __ Projection(1, add);
1483 Node* EffectControlLinearizer::LowerCheckedUint32ToInt32(Node* node,
1484 Node* frame_state) {
1485 Node* value = node->InputAt(0);
1486 Node* max_int = __ Int32Constant(std::numeric_limits<int32_t>::max());
1487 Node* is_safe = __ Uint32LessThanOrEqual(value, max_int);
1492 Node* EffectControlLinearizer::LowerCheckedUint32ToTaggedSigned(
1493 Node* node, Node* frame_state) {
1494 Node* value = node->InputAt(0);
1495 Node* check = __ Uint32LessThanOrEqual(value, SmiMaxValueConstant());
1500 Node* EffectControlLinearizer::BuildCheckedFloat64ToInt32(
1501 CheckForMinusZeroMode mode, Node* value, Node* frame_state) {
1502 Node* value32 = __ RoundFloat64ToInt32(value);
1503 Node* check_same = __ Float64Equal(value, __ ChangeInt32ToFloat64(value32));
1512 Node* check_zero = __ Word32Equal(value32, __ Int32Constant(0));
1518 Node* check_negative = __ Int32LessThan(__ Float64ExtractHighWord32(value),
1528 Node* EffectControlLinearizer::LowerCheckedFloat64ToInt32(Node* node,
1529 Node* frame_state) {
1530 CheckForMinusZeroMode mode = CheckMinusZeroModeOf(node->op());
1531 Node* value = node->InputAt(0);
1535 Node* EffectControlLinearizer::LowerCheckedTaggedSignedToInt32(
1536 Node* node, Node* frame_state) {
1537 Node* value = node->InputAt(0);
1538 Node* check = ObjectIsSmi(value);
1543 Node* EffectControlLinearizer::LowerCheckedTaggedToInt32(Node* node,
1544 Node* frame_state) {
1545 CheckForMinusZeroMode mode = CheckMinusZeroModeOf(node->op());
1546 Node* value = node->InputAt(0);
1551 Node* check = ObjectIsSmi(value);
1559 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1560 Node* check_map = __ WordEqual(value_map, __ HeapNumberMapConstant());
1563 Node* vfalse = __ LoadField(AccessBuilder::ForHeapNumberValue(), value);
1571 Node* EffectControlLinearizer::BuildCheckedHeapNumberOrOddballToFloat64(
1572 CheckTaggedInputMode mode, Node* value, Node* frame_state) {
1573 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1574 Node* check_number = __ WordEqual(value_map, __ HeapNumberMapConstant());
1587 Node* instance_type =
1589 Node* check_oddball =
1603 Node* EffectControlLinearizer::LowerCheckedTaggedToFloat64(Node* node,
1604 Node* frame_state) {
1605 CheckTaggedInputMode mode = CheckTaggedInputModeOf(node->op());
1606 Node* value = node->InputAt(0);
1611 Node* check = ObjectIsSmi(value);
1616 Node* number =
1621 Node* from_smi = ChangeSmiToInt32(value);
1629 Node* EffectControlLinearizer::LowerCheckedTaggedToTaggedSigned(
1630 Node* node, Node* frame_state) {
1631 Node* value = node->InputAt(0);
1633 Node* check = ObjectIsSmi(value);
1639 Node* EffectControlLinearizer::LowerCheckedTaggedToTaggedPointer(
1640 Node* node, Node* frame_state) {
1641 Node* value = node->InputAt(0);
1643 Node* check = ObjectIsSmi(value);
1648 Node* EffectControlLinearizer::LowerTruncateTaggedToWord32(Node* node) {
1649 Node* value = node->InputAt(0);
1654 Node* check = ObjectIsSmi(value);
1660 Node* vfalse = __ LoadField(AccessBuilder::ForHeapNumberValue(), value);
1668 Node* EffectControlLinearizer::LowerCheckedTruncateTaggedToWord32(
1669 Node* node, Node* frame_state) {
1670 Node* value = node->InputAt(0);
1675 Node* check = ObjectIsSmi(value);
1683 Node* number = BuildCheckedHeapNumberOrOddballToFloat64(
1692 Node* EffectControlLinearizer::LowerObjectIsDetectableCallable(Node* node) {
1693 Node* value = node->InputAt(0);
1698 Node* check = ObjectIsSmi(value);
1701 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1702 Node* value_bit_field =
1704 Node* vfalse = __ Word32Equal(
1718 Node* EffectControlLinearizer::LowerObjectIsNonCallable(Node* node) {
1719 Node* value = node->InputAt(0);
1724 Node* check0 = ObjectIsSmi(value);
1727 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1728 Node* value_instance_type =
1731 Node* check1 = __ Uint32LessThanOrEqual(
1735 Node* value_bit_field =
1737 Node* check2 = __ Word32Equal(
1749 Node* EffectControlLinearizer::LowerObjectIsNumber(Node* node) {
1750 Node* value = node->InputAt(0);
1756 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1766 Node* EffectControlLinearizer::LowerObjectIsReceiver(Node* node) {
1767 Node* value = node->InputAt(0);
1775 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1776 Node* value_instance_type =
1778 Node* result = __ Uint32LessThanOrEqual(
1789 Node* EffectControlLinearizer::LowerObjectIsSmi(Node* node) {
1790 Node* value = node->InputAt(0);
1794 Node* EffectControlLinearizer::LowerObjectIsString(Node* node) {
1795 Node* value = node->InputAt(0);
1800 Node* check = ObjectIsSmi(value);
1802 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1803 Node* value_instance_type =
1805 Node* vfalse = __ Uint32LessThan(value_instance_type,
1816 Node* EffectControlLinearizer::LowerObjectIsUndetectable(Node* node) {
1817 Node* value = node->InputAt(0);
1822 Node* check = ObjectIsSmi(value);
1825 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1826 Node* value_bit_field =
1828 Node* vfalse = __ Word32Equal(
1842 Node* EffectControlLinearizer::LowerNewRestParameterElements(Node* node) {
1843 int const formal_parameter_count = ParameterCountOf(node->op());
1846 Operator::Properties const properties = node->op()->properties();
1855 Node* EffectControlLinearizer::LowerNewUnmappedArgumentsElements(Node* node) {
1856 int const formal_parameter_count = ParameterCountOf(node->op());
1860 Operator::Properties const properties = node->op()->properties();
1869 Node* EffectControlLinearizer::LowerArrayBufferWasNeutered(Node* node) {
1870 Node* value = node->InputAt(0);
1872 Node* value_bit_field =
1882 Node* EffectControlLinearizer::LowerStringCharAt(Node* node) {
1883 Node* receiver = node->InputAt(0);
1884 Node* position = node->InputAt(1);
1895 Node* EffectControlLinearizer::LowerStringCharCodeAt(Node* node) {
1896 Node* receiver = node->InputAt(0);
1897 Node* position = node->InputAt(1);
1909 Node* EffectControlLinearizer::LowerStringFromCharCode(Node* node) {
1910 Node* value = node->InputAt(0);
1917 Node* code = __ Word32And(value, __ Int32Constant(String::kMaxUtf16CodeUnit));
1920 Node* check0 = __ Int32LessThanOrEqual(
1925 Node* cache = __ HeapConstant(factory()->single_character_string_cache());
1928 Node* index = machine()->Is32() ? code : __ ChangeUint32ToUint64(code);
1932 Node* entry =
1935 Node* check1 = __ WordEqual(entry, __ UndefinedConstant());
1948 Node* vtrue1 =
1958 Node* EffectControlLinearizer::LowerStringFromCodePoint(Node* node) {
1959 Node* value = node->InputAt(0);
1960 Node* code = value;
1968 Node* check0 = __ Uint32LessThanOrEqual(code, __ Uint32Constant(0xFFFF));
1973 Node* check1 = __ Uint32LessThanOrEqual(
1978 Node* cache = __ HeapConstant(factory()->single_character_string_cache());
1981 Node* index = machine()->Is32() ? code : __ ChangeUint32ToUint64(code);
1985 Node* entry =
1988 Node* check2 = __ WordEqual(entry, __ UndefinedConstant());
1997 Node* vtrue2 = __ Allocate(
2021 Node* vfalse1 = __ Allocate(
2041 switch (UnicodeEncodingOf(node->op())) {
2047 Node* lead_offset = __ Int32Constant(0xD800 - (0x10000 >> 10));
2050 Node* lead =
2054 Node* trail = __ Int32Add(__ Word32And(code, __ Int32Constant(0x3FF)),
2064 Node* vfalse0 = __ Allocate(NOT_TENURED,
2083 Node* EffectControlLinearizer::LowerStringIndexOf(Node* node) {
2084 Node* subject = node->InputAt(0);
2085 Node* search_string = node->InputAt(1);
2086 Node* position = node->InputAt(2);
2097 Node* EffectControlLinearizer::LowerStringComparison(Callable const& callable,
2098 Node* node) {
2099 Node* lhs = node->InputAt(0);
2100 Node* rhs = node->InputAt(1);
2110 Node* EffectControlLinearizer::LowerStringEqual(Node* node) {
2111 return LowerStringComparison(CodeFactory::StringEqual(isolate()), node);
2114 Node* EffectControlLinearizer::LowerStringLessThan(Node* node) {
2115 return LowerStringComparison(CodeFactory::StringLessThan(isolate()), node);
2118 Node* EffectControlLinearizer::LowerStringLessThanOrEqual(Node* node) {
2120 node);
2123 Node* EffectControlLinearizer::LowerCheckFloat64Hole(Node* node,
2124 Node* frame_state) {
2125 // If we reach this point w/o eliminating the {node} that's marked
2128 Node* value = node->InputAt(0);
2129 Node* check = __ Word32Equal(__ Float64ExtractHighWord32(value),
2135 Node* EffectControlLinearizer::LowerCheckTaggedHole(Node* node,
2136 Node* frame_state) {
2137 Node* value = node->InputAt(0);
2138 Node* check = __ WordEqual(value, __ TheHoleConstant());
2143 Node* EffectControlLinearizer::LowerConvertTaggedHoleToUndefined(Node* node) {
2144 Node* value = node->InputAt(0);
2149 Node* check = __ WordEqual(value, __ TheHoleConstant());
2160 Node* EffectControlLinearizer::AllocateHeapNumberWithValue(Node* value) {
2161 Node* result = __ Allocate(NOT_TENURED, __ Int32Constant(HeapNumber::kSize));
2167 Node* EffectControlLinearizer::ChangeInt32ToSmi(Node* value) {
2174 Node* EffectControlLinearizer::ChangeUint32ToSmi(Node* value) {
2181 Node* EffectControlLinearizer::ChangeSmiToInt32(Node* value) {
2189 Node* EffectControlLinearizer::ObjectIsSmi(Node* value) {
2194 Node* EffectControlLinearizer::SmiMaxValueConstant() {
2198 Node* EffectControlLinearizer::SmiShiftBitsConstant() {
2202 Node* EffectControlLinearizer::LowerPlainPrimitiveToNumber(Node* node) {
2203 Node* value = node->InputAt(0);
2207 Node* EffectControlLinearizer::LowerPlainPrimitiveToWord32(Node* node) {
2208 Node* value = node->InputAt(0);
2214 Node* check0 = ObjectIsSmi(value);
2219 Node* to_number = __ ToNumber(value);
2221 Node* check1 = ObjectIsSmi(to_number);
2223 Node* number = __ LoadField(AccessBuilder::ForHeapNumberValue(), to_number);
2233 Node* EffectControlLinearizer::LowerPlainPrimitiveToFloat64(Node* node) {
2234 Node* value = node->InputAt(0);
2240 Node* check0 = ObjectIsSmi(value);
2242 Node* from_smi = ChangeSmiToInt32(value);
2246 Node* to_number = __ ToNumber(value);
2247 Node* check1 = ObjectIsSmi(to_number);
2250 Node* number = __ LoadField(AccessBuilder::ForHeapNumberValue(), to_number);
2254 Node* number_from_smi = ChangeSmiToInt32(to_number);
2262 Node* EffectControlLinearizer::LowerEnsureWritableFastElements(Node* node) {
2263 Node* object = node->InputAt(0);
2264 Node* elements = node->InputAt(1);
2270 Node* elements_map = __ LoadField(AccessBuilder::ForMap(), elements);
2273 Node* check = __ WordEqual(elements_map, __ FixedArrayMapConstant());
2285 Node* result = __ Call(desc, __ HeapConstant(callable.code()), object,
2293 Node* EffectControlLinearizer::LowerMaybeGrowFastElements(Node* node,
2294 Node* frame_state) {
2295 GrowFastElementsFlags flags = GrowFastElementsFlagsOf(node->op());
2296 Node* object = node->InputAt(0);
2297 Node* elements = node->InputAt(1);
2298 Node* index = node->InputAt(2);
2299 Node* length = node->InputAt(3);
2306 Node* check0 = (flags & GrowFastElementsFlag::kHoleyElements)
2312 Node* elements_length =
2317 Node* check1 = __ Uint32LessThan(index, elements_length);
2332 Node* new_object = __ Call(desc, __ HeapConstant(callable.code()), object,
2347 Node* object_length =
2363 Node* check1 = __ Uint32LessThan(index, length);
2372 void EffectControlLinearizer::LowerTransitionElementsKind(Node* node) {
2373 ElementsTransition const transition = ElementsTransitionOf(node->op());
2374 Node* object = node->InputAt(0);
2379 Node* source_map = __ HeapConstant(transition.source());
2380 Node* target_map = __ HeapConstant(transition.target());
2383 Node* object_map = __ LoadField(AccessBuilder::ForMap(), object);
2386 Node* check = __ WordEqual(object_map, source_map);
2413 Node* EffectControlLinearizer::LowerLoadTypedElement(Node* node) {
2414 ExternalArrayType array_type = ExternalArrayTypeOf(node->op());
2415 Node* buffer = node->InputAt(0);
2416 Node* base = node->InputAt(1);
2417 Node* external = node->InputAt(2);
2418 Node* index = node->InputAt(3);
2427 Node* storage = NumberMatcher(base).Is(0) ? external : __ UnsafePointerAdd(
2435 void EffectControlLinearizer::LowerStoreTypedElement(Node* node) {
2436 ExternalArrayType array_type = ExternalArrayTypeOf(node->op());
2437 Node* buffer = node->InputAt(0);
2438 Node* base = node->InputAt(1);
2439 Node* external = node->InputAt(2);
2440 Node* index = node->InputAt(3);
2441 Node* value = node->InputAt(4);
2450 Node* storage = NumberMatcher(base).Is(0) ? external : __ UnsafePointerAdd(
2458 Maybe<Node*> EffectControlLinearizer::LowerFloat64RoundUp(Node* node) {
2461 return Nothing<Node*>();
2464 Node* const input = node->InputAt(0);
2496 Node* const zero = __ Float64Constant(0.0);
2497 Node* const two_52 = __ Float64Constant(4503599627370496.0E0);
2498 Node* const one = __ Float64Constant(1.0);
2500 Node* check0 = __ Float64LessThan(zero, input);
2503 Node* check1 = __ Float64LessThanOrEqual(two_52, input);
2506 Node* temp1 = __ Float64Sub(__ Float64Add(two_52, input), two_52);
2517 Node* check1 = __ Float64Equal(input, zero);
2520 Node* const minus_two_52 = __ Float64Constant(-4503599627370496.0E0);
2521 Node* check2 = __ Float64LessThanOrEqual(input, minus_two_52);
2525 Node* const minus_zero = __ Float64Constant(-0.0);
2526 Node* temp1 = __ Float64Sub(minus_zero, input);
2527 Node* temp2 = __ Float64Sub(__ Float64Add(two_52, temp1), two_52);
2528 Node* check3 = __ Float64LessThan(temp1, temp2);
2533 Node* temp3 = done_temp3.PhiAt(0);
2546 Node* EffectControlLinearizer::BuildFloat64RoundDown(Node* value) {
2547 Node* round_down = __ Float64RoundDown(value);
2552 Node* const input = value;
2586 Node* const zero = __ Float64Constant(0.0);
2587 Node* const two_52 = __ Float64Constant(4503599627370496.0E0);
2589 Node* check0 = __ Float64LessThan(zero, input);
2592 Node* check1 = __ Float64LessThanOrEqual(two_52, input);
2595 Node* const one = __ Float64Constant(1.0);
2596 Node* temp1 = __ Float64Sub(__ Float64Add(two_52, input), two_52);
2607 Node* check1 = __ Float64Equal(input, zero);
2610 Node* const minus_two_52 = __ Float64Constant(-4503599627370496.0E0);
2611 Node* check2 = __ Float64LessThanOrEqual(input, minus_two_52);
2615 Node* const minus_zero = __ Float64Constant(-0.0);
2616 Node* temp1 = __ Float64Sub(minus_zero, input);
2617 Node* temp2 = __ Float64Sub(__ Float64Add(two_52, temp1), two_52);
2618 Node* check3 = __ Float64LessThan(temp2, temp1);
2635 Maybe<Node*> EffectControlLinearizer::LowerFloat64RoundDown(Node* node) {
2638 return Nothing<Node*>();
2641 Node* const input = node->InputAt(0);
2645 Maybe<Node*> EffectControlLinearizer::LowerFloat64RoundTiesEven(Node* node) {
2648 return Nothing<Node*>();
2651 Node* const input = node->InputAt(0);
2671 Node* value = BuildFloat64RoundDown(input);
2672 Node* temp1 = __ Float64Sub(input, value);
2674 Node* const half = __ Float64Constant(0.5);
2675 Node* check0 = __ Float64LessThan(temp1, half);
2678 Node* const one = __ Float64Constant(1.0);
2679 Node* check1 = __ Float64LessThan(half, temp1);
2684 Node* temp2 = __ Float64Mod(value, __ Float64Constant(2.0));
2685 Node* check2 = __ Float64Equal(temp2, __ Float64Constant(0.0));
2693 Maybe<Node*> EffectControlLinearizer::LowerFloat64RoundTruncate(Node* node) {
2696 return Nothing<Node*>();
2699 Node* const input = node->InputAt(0);
2734 Node* const zero = __ Float64Constant(0.0);
2735 Node* const two_52 = __ Float64Constant(4503599627370496.0E0);
2736 Node* const one = __ Float64Constant(1.0);
2738 Node* check0 = __ Float64LessThan(zero, input);
2741 Node* check1 = __ Float64LessThanOrEqual(two_52, input);
2744 Node* temp1 = __ Float64Sub(__ Float64Add(two_52, input), two_52);
2755 Node
2758 Node* const minus_two_52 = __ Float64Constant(-4503599627370496.0E0);
2759 Node* check2 = __ Float64LessThanOrEqual(input, minus_two_52);
2763 Node* const minus_zero = __ Float64Constant(-0.0);
2764 Node* temp1 = __ Float64Sub(minus_zero, input);
2765 Node* temp2 = __ Float64Sub(__ Float64Add(two_52, temp1), two_52);
2766 Node* check3 = __ Float64LessThan(temp1, temp2);
2771 Node* temp3 = done_temp3.PhiAt(0);
