Lines Matching refs:Node
62 void UpdateEffectControlForNode(Node* node);
63 void ProcessNode(Node* node, Node** frame_state);
65 bool TryWireInStateEffect(Node* node, Node* frame_state);
66 Node* LowerChangeBitToTagged(Node* node);
67 Node* LowerChangeInt31ToTaggedSigned(Node* node);
68 Node* LowerChangeInt32ToTagged(Node* node);
69 Node* LowerChangeInt64ToTagged(Node* node);
70 Node* LowerChangeUint32ToTagged(Node* node);
71 Node* LowerChangeUint64ToTagged(Node* node);
72 Node* LowerChangeFloat64ToTagged(Node* node);
73 Node* LowerChangeFloat64ToTaggedPointer(Node* node);
74 Node* LowerChangeTaggedSignedToInt32(Node* node);
75 Node* LowerChangeTaggedSignedToInt64(Node* node);
76 Node* LowerChangeTaggedToBit(Node* node);
77 Node* LowerChangeTaggedToInt32(Node* node);
78 Node* LowerChangeTaggedToUint32(Node* node);
79 Node* LowerChangeTaggedToInt64(Node* node);
80 Node* LowerChangeTaggedToTaggedSigned(Node* node);
81 Node* LowerCheckInternalizedString(Node* node, Node* frame_state);
82 void LowerCheckMaps(Node* node, Node* frame_state);
83 Node* LowerCompareMaps(Node* node);
84 Node* LowerCheckNumber(Node* node, Node* frame_state);
85 Node* LowerCheckClosure(Node* node, Node* frame_state);
86 Node* LowerCheckReceiver(Node* node, Node* frame_state);
87 Node* LowerCheckReceiverOrNullOrUndefined(Node* node, Node* frame_state);
88 Node* LowerCheckString(Node* node, Node* frame_state);
89 Node* LowerCheckBigInt(Node* node, Node* frame_state);
90 Node* LowerCheckSymbol(Node* node, Node* frame_state);
91 void LowerCheckIf(Node* node, Node* frame_state);
92 Node* LowerCheckedInt32Add(Node* node, Node* frame_state);
93 Node* LowerCheckedInt32Sub(Node* node, Node* frame_state);
94 Node* LowerCheckedInt32Div(Node* node, Node* frame_state);
95 Node* LowerCheckedInt32Mod(Node* node, Node* frame_state);
96 Node* LowerCheckedUint32Div(Node* node, Node* frame_state);
97 Node* LowerCheckedUint32Mod(Node* node, Node* frame_state);
98 Node* LowerCheckedInt32Mul(Node* node, Node* frame_state);
99 Node* LowerCheckedInt32ToTaggedSigned(Node* node, Node* frame_state);
100 Node* LowerCheckedInt64ToInt32(Node* node, Node* frame_state);
101 Node* LowerCheckedInt64ToTaggedSigned(Node* node, Node* frame_state);
102 Node* LowerCheckedUint32Bounds(Node* node, Node* frame_state);
103 Node* LowerCheckedUint32ToInt32(Node* node, Node* frame_state);
104 Node* LowerCheckedUint32ToTaggedSigned(Node* node, Node* frame_state);
105 Node* LowerCheckedUint64Bounds(Node* node, Node* frame_state);
106 Node* LowerCheckedUint64ToInt32(Node* node, Node* frame_state);
107 Node* LowerCheckedUint64ToTaggedSigned(Node* node, Node* frame_state);
108 Node* LowerCheckedFloat64ToInt32(Node* node, Node* frame_state);
109 Node* LowerCheckedFloat64ToInt64(Node* node, Node* frame_state);
110 Node* LowerCheckedTaggedSignedToInt32(Node* node, Node* frame_state);
111 Node* LowerCheckedTaggedToArrayIndex(Node* node, Node* frame_state);
112 Node* LowerCheckedTaggedToInt32(Node* node, Node* frame_state);
113 Node* LowerCheckedTaggedToInt64(Node* node, Node* frame_state);
114 Node* LowerCheckedTaggedToFloat64(Node* node, Node* frame_state);
115 Node* LowerCheckedTaggedToTaggedSigned(Node* node, Node* frame_state);
116 Node* LowerCheckedTaggedToTaggedPointer(Node* node, Node* frame_state);
117 Node* LowerChangeInt64ToBigInt(Node* node);
118 Node* LowerChangeUint64ToBigInt(Node* node);
119 Node* LowerTruncateBigIntToWord64(Node* node);
120 Node* LowerChangeTaggedToFloat64(Node* node);
121 void TruncateTaggedPointerToBit(Node* node, GraphAssemblerLabel<1>* done);
122 Node* LowerTruncateTaggedToBit(Node* node);
123 Node* LowerTruncateTaggedPointerToBit(Node* node);
124 Node* LowerTruncateTaggedToFloat64(Node* node);
125 Node* LowerTruncateTaggedToWord32(Node* node);
126 Node* LowerCheckedTruncateTaggedToWord32(Node* node, Node* frame_state);
127 Node* LowerAllocate(Node* node);
128 Node* LowerNumberToString(Node* node);
129 Node* LowerObjectIsArrayBufferView(Node* node);
130 Node* LowerObjectIsBigInt(Node* node);
131 Node* LowerObjectIsCallable(Node* node);
132 Node* LowerObjectIsConstructor(Node* node);
133 Node* LowerObjectIsDetectableCallable(Node* node);
134 Node* LowerObjectIsMinusZero(Node* node);
135 Node* LowerNumberIsMinusZero(Node* node);
136 Node* LowerObjectIsNaN(Node* node);
137 Node* LowerNumberIsNaN(Node* node);
138 Node* LowerObjectIsNonCallable(Node* node);
139 Node* LowerObjectIsNumber(Node* node);
140 Node* LowerObjectIsReceiver(Node* node);
141 Node* LowerObjectIsSmi(Node* node);
142 Node* LowerObjectIsString(Node* node);
143 Node* LowerObjectIsSymbol(Node* node);
144 Node* LowerObjectIsUndetectable(Node* node);
145 Node* LowerNumberIsFloat64Hole(Node* node);
146 Node* LowerNumberIsFinite(Node* node);
147 Node* LowerObjectIsFiniteNumber(Node* node);
148 Node* LowerNumberIsInteger(Node* node);
149 Node* LowerObjectIsInteger(Node* node);
150 Node* LowerNumberIsSafeInteger(Node* node);
151 Node* LowerObjectIsSafeInteger(Node* node);
152 Node* LowerArgumentsLength(Node* node);
153 Node* LowerRestLength(Node* node);
154 Node* LowerNewDoubleElements(Node* node);
155 Node* LowerNewSmiOrObjectElements(Node* node);
156 Node* LowerNewArgumentsElements(Node* node);
157 Node* LowerNewConsString(Node* node);
158 Node* LowerSameValue(Node* node);
159 Node* LowerSameValueNumbersOnly(Node* node);
160 Node* LowerNumberSameValue(Node* node);
161 Node* LowerDeadValue(Node* node);
162 Node* LowerStringConcat(Node* node);
163 Node* LowerStringToNumber(Node* node);
164 Node* LowerStringCharCodeAt(Node* node);
165 Node* StringCharCodeAt(Node* receiver, Node* position);
166 Node* LowerStringCodePointAt(Node* node);
167 Node* LowerStringToLowerCaseIntl(Node* node);
168 Node* LowerStringToUpperCaseIntl(Node* node);
169 Node* LowerStringFromSingleCharCode(Node* node);
170 Node* LowerStringFromSingleCodePoint(Node* node);
171 Node* LowerStringIndexOf(Node* node);
172 Node* LowerStringSubstring(Node* node);
173 Node* LowerStringFromCodePointAt(Node* node);
174 Node* LowerStringLength(Node* node);
175 Node* LowerStringEqual(Node* node);
176 Node* LowerStringLessThan(Node* node);
177 Node* LowerStringLessThanOrEqual(Node* node);
178 Node* LowerBigIntAdd(Node* node, Node* frame_state);
179 Node* LowerBigIntSubtract(Node* node, Node* frame_state);
180 Node* LowerBigIntNegate(Node* node);
181 Node* LowerCheckFloat64Hole(Node* node, Node* frame_state);
182 Node* LowerCheckNotTaggedHole(Node* node, Node* frame_state);
183 Node* LowerConvertTaggedHoleToUndefined(Node* node);
184 void LowerCheckEqualsInternalizedString(Node* node, Node* frame_state);
185 void LowerCheckEqualsSymbol(Node* node, Node* frame_state);
186 Node* LowerTypeOf(Node* node);
187 Node* LowerToBoolean(Node* node);
188 Node* LowerPlainPrimitiveToNumber(Node* node);
189 Node* LowerPlainPrimitiveToWord32(Node* node);
190 Node* LowerPlainPrimitiveToFloat64(Node* node);
191 Node* LowerEnsureWritableFastElements(Node* node);
192 Node* LowerMaybeGrowFastElements(Node* node, Node* frame_state);
193 void LowerTransitionElementsKind(Node* node);
194 Node* LowerLoadFieldByIndex(Node* node);
195 Node* LowerLoadMessage(Node* node);
196 Node* AdaptFastCallTypedArrayArgument(Node* node,
199 Node* AdaptFastCallArgument(Node* node, CTypeInfo arg_type,
203 Node* target_address;
204 Node* argument;
207 Node* node, const FastApiCallFunctionVector& c_functions,
212 Node* WrapFastCall(const CallDescriptor* call_descriptor, int inputs_size,
213 Node** inputs, Node* target,
215 Node* stack_slot);
216 Node* GenerateSlowApiCall(Node* node);
217 Node* LowerFastApiCall(Node* node);
218 Node* LowerLoadTypedElement(Node* node);
219 Node* LowerLoadDataViewElement(Node* node);
220 Node* LowerLoadStackArgument(Node* node);
221 void LowerStoreMessage(Node* node);
222 void LowerStoreTypedElement(Node* node);
223 void LowerStoreDataViewElement(Node* node);
224 void LowerStoreSignedSmallElement(Node* node);
225 Node* LowerFindOrderedHashMapEntry(Node* node);
226 Node* LowerFindOrderedHashMapEntryForInt32Key(Node* node);
227 void LowerTransitionAndStoreElement(Node* node);
228 void LowerTransitionAndStoreNumberElement(Node* node);
229 void LowerTransitionAndStoreNonNumberElement(Node* node);
230 void LowerRuntimeAbort(Node* node);
231 Node* LowerAssertType(Node* node);
232 Node* LowerFoldConstant(Node* node);
233 Node* LowerConvertReceiver(Node* node);
234 Node* LowerDateNow(Node* node);
237 Maybe<Node*> LowerFloat64RoundUp(Node* node);
238 Maybe<Node*> LowerFloat64RoundDown(Node* node);
239 Maybe<Node*> LowerFloat64RoundTiesEven(Node* node);
240 Maybe<Node*> LowerFloat64RoundTruncate(Node* node);
242 Node* AllocateHeapNumberWithValue(Node* node);
243 Node* BuildCheckedFloat64ToInt32(CheckForMinusZeroMode mode,
244 const FeedbackSource& feedback, Node* value,
245 Node* frame_state);
246 Node* BuildCheckedFloat64ToInt64(CheckForMinusZeroMode mode,
247 const FeedbackSource& feedback, Node* value,
248 Node* frame_state);
249 Node* BuildCheckedFloat64ToIndex(const FeedbackSource& feedback, Node* value,
250 Node* frame_state);
251 Node* BuildCheckedHeapNumberOrOddballToFloat64(CheckTaggedInputMode mode,
253 Node* value,
254 Node* frame_state);
255 Node* BuildReverseBytes(ExternalArrayType type, Node* value);
256 Node* BuildFloat64RoundDown(Node* value);
257 Node* BuildFloat64RoundTruncate(Node* input);
259 void SmiTagOrOverflow(Node* value, GraphAssemblerLabel<VarCount>* if_overflow,
261 Node* SmiTagOrDeopt(Node* value, const CheckParameters& params,
262 Node* frame_state);
263 Node* BuildUint32Mod(Node* lhs, Node* rhs);
264 Node* ComputeUnseededHash(Node* value);
265 Node* LowerStringComparison(Callable const& callable, Node* node);
266 Node* IsElementsKindGreaterThan(Node* kind, ElementsKind reference_kind);
268 Node* BuildTypedArrayDataPointer(Node* base, Node* external);
271 Node* CallBuiltin(Builtin builtin, Operator::Properties properties, Args...);
273 Node* ChangeBitToTagged(Node* value);
274 Node* ChangeFloat64ToTagged(Node* value, CheckForMinusZeroMode mode);
275 Node* ChangeInt32ToSmi(Node* value);
281 Node* ChangeTaggedInt32ToSmi(Node* value);
282 Node* ChangeInt32ToIntPtr(Node* value);
283 Node* ChangeInt32ToTagged(Node* value);
284 Node* ChangeInt64ToSmi(Node* value);
285 Node* ChangeIntPtrToInt32(Node* value);
286 Node* ChangeIntPtrToSmi(Node* value);
287 Node* ChangeUint32ToUintPtr(Node* value);
288 Node* ChangeUint32ToSmi(Node* value);
289 Node* ChangeUint32ToTagged(Node* value);
290 Node* ChangeSmiToIntPtr(Node* value);
291 Node* ChangeSmiToInt32(Node* value);
292 Node* ChangeSmiToInt64(Node* value);
293 Node* ObjectIsSmi(Node* value);
294 Node* LoadFromSeqString(Node* receiver, Node* position, Node* is_one_byte);
295 Node* TruncateWordToInt32(Node* value);
296 Node* MakeWeakForComparison(Node* heap_object);
297 Node* BuildIsWeakReferenceTo(Node* maybe_object, Node* value);
298 Node* BuildIsClearedWeakReference(Node* maybe_object);
299 Node* BuildIsStrongReference(Node* value);
300 Node* BuildStrongReferenceFromWeakReference(Node* value);
301 Node* SmiMaxValueConstant();
302 Node* SmiShiftBitsConstant();
305 Node* BuildAllocateBigInt(Node* bitfield, Node* digit);
307 void TransitionElementsTo(Node* node, Node* array, ElementsKind from,
313 void MigrateInstanceOrDeopt(Node* value, Node* value_map, Node* frame_state,
318 void TryMigrateInstance(Node* value, Node* value_map);
348 Node* frame_state_zapper_; // For tracking down compiler::Node::New crashes.
354 Node* current_effect = nullptr; // New effect.
355 Node* current_control = nullptr; // New control.
356 Node* current_frame_state = nullptr; // New frame state.
380 Node* effect_phi;
383 PendingEffectPhi(Node* effect_phi, BasicBlock* block)
387 void UpdateEffectPhi(Node* node, BasicBlock* block,
395 Node* input = node->InputAt(i);
399 Node* effect = block_effect.current_effect;
408 Node* control = block->NodeAt(0);
423 Node* input = NodeProperties::GetControlInput(control, i);
434 void RemoveRenameNode(Node* node) {
453 void TryCloneBranch(Node* node, BasicBlock* block, Zone* temp_zone,
512 Node* branch = node;
513 Node* cond = NodeProperties::GetValueInput(branch, 0);
515 Node* merge = NodeProperties::GetControlInput(branch);
524 for (Node* const use : merge->uses()) {
536 Node* control = NodeProperties::GetControlInput(edge.from());
547 Node** const inputs = graph->zone()->NewArray<Node*>(2 * input_count);
548 Node** const merge_true_inputs = &inputs[0];
549 Node** const merge_false_inputs = &inputs[input_count];
551 Node* cond1 = NodeProperties::GetValueInput(cond, index);
552 Node* control1 = NodeProperties::GetControlInput(merge, index);
553 Node* branch1 = graph->NewNode(common->Branch(hint), cond1, control1);
557 Node* const merge_true = matcher.IfTrue();
558 Node* const merge_false = matcher.IfFalse();
574 for (Node* const phi : phis) {
579 Node* phi_true = graph->NewNode(phi->op(), input_count + 1, inputs);
581 Node* phi_false = graph->NewNode(phi->op(), input_count + 1, inputs);
586 Node* control = NodeProperties::GetControlInput(edge.from());
633 Node* control = *instr;
650 Node* effect_phi = nullptr;
651 Node* terminate = nullptr;
653 Node* node = *instr;
684 Node* effect = effect_phi;
742 Node* frame_state = nullptr;
762 Node* node = *instr;
815 void EffectControlLinearizer::UpdateEffectControlForNode(Node* node) {
832 void EffectControlLinearizer::ProcessNode(Node* node, Node** frame_state) {
916 bool EffectControlLinearizer::TryWireInStateEffect(Node* node,
917 Node* frame_state) {
918 Node* result = nullptr;
1400 Node* EffectControlLinearizer::LowerChangeFloat64ToTagged(Node* node) {
1402 Node* value = node->InputAt(0);
1406 Node* EffectControlLinearizer::ChangeFloat64ToTagged(
1407 Node* value, CheckForMinusZeroMode mode) {
1412 Node* value32 = __ RoundFloat64ToInt32(value);
1420 Node* zero = __ Int32Constant(0);
1439 Node* value_smi = ChangeInt32ToSmi(value32);
1448 Node* value_number = AllocateHeapNumberWithValue(value);
1456 Node* EffectControlLinearizer::LowerChangeFloat64ToTaggedPointer(Node* node) {
1457 Node* value = node->InputAt(0);
1461 Node* EffectControlLinearizer::LowerChangeBitToTagged(Node* node) {
1462 Node* value = node->InputAt(0);
1466 Node* EffectControlLinearizer::ChangeBitToTagged(Node* value) {
1480 Node* EffectControlLinearizer::LowerChangeInt31ToTaggedSigned(Node* node) {
1481 Node* value = node->InputAt(0);
1485 Node* EffectControlLinearizer::LowerChangeInt32ToTagged(Node* node) {
1486 Node* value = node->InputAt(0);
1490 Node* EffectControlLinearizer::ChangeInt32ToTagged(Node* value) {
1502 Node* number = AllocateHeapNumberWithValue(__ ChangeInt32ToFloat64(value));
1509 Node* EffectControlLinearizer::LowerChangeInt64ToTagged(Node* node) {
1510 Node* value = node->InputAt(0);
1515 Node* value32 = __ TruncateInt64ToInt32(value);
1520 Node* value_smi = ChangeInt64ToSmi(value);
1527 Node* number = AllocateHeapNumberWithValue(__ ChangeInt64ToFloat64(value));
1534 Node* EffectControlLinearizer::LowerChangeUint32ToTagged(Node* node) {
1535 Node* value = node->InputAt(0);
1539 Node* EffectControlLinearizer::ChangeUint32ToTagged(Node* value) {
1543 Node* check = __ Uint32LessThanOrEqual(value, SmiMaxValueConstant());
1548 Node* number = AllocateHeapNumberWithValue(__ ChangeUint32ToFloat64(value));
1556 Node* EffectControlLinearizer::LowerChangeUint64ToTagged(Node* node) {
1557 Node* value = node->InputAt(0);
1562 Node* check =
1568 Node* number = AllocateHeapNumberWithValue(__ ChangeInt64ToFloat64(value));
1576 Node* EffectControlLinearizer::LowerChangeTaggedSignedToInt32(Node* node) {
1577 Node* value = node->InputAt(0);
1581 Node* EffectControlLinearizer::LowerChangeTaggedSignedToInt64(Node* node) {
1582 Node* value = node->InputAt(0);
1586 Node* EffectControlLinearizer::LowerChangeTaggedToBit(Node* node) {
1587 Node* value = node->InputAt(0);
1592 Node* node, GraphAssemblerLabel<1>* done) {
1593 Node* value = node->InputAt(0);
1598 Node* zero = __ Int32Constant(0);
1599 Node* fzero = __ Float64Constant(0.0);
1608 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1612 Node* value_map_bitfield =
1635 Node* value_value =
1642 Node* bitfield = __ LoadField(AccessBuilder::ForBigIntBitfield(), value);
1643 Node* length_is_zero = __ Word32Equal(
1650 Node* EffectControlLinearizer::LowerTruncateTaggedToBit(Node* node) {
1654 Node* value = node->InputAt(0);
1670 Node* EffectControlLinearizer::LowerTruncateTaggedPointerToBit(Node* node) {
1679 Node* EffectControlLinearizer::LowerChangeTaggedToInt32(Node* node) {
1680 Node* value = node->InputAt(0);
1685 Node* check = ObjectIsSmi(value);
1692 Node* vfalse = __ LoadField(AccessBuilder::ForHeapNumberValue(), value);
1700 Node* EffectControlLinearizer::LowerChangeTaggedToUint32(Node* node) {
1701 Node* value = node->InputAt(0);
1706 Node* check = ObjectIsSmi(value);
1713 Node* vfalse = __ LoadField(AccessBuilder::ForHeapNumberValue(), value);
1721 Node* EffectControlLinearizer::LowerChangeTaggedToInt64(Node* node) {
1722 Node* value = node->InputAt(0);
1727 Node* check = ObjectIsSmi(value);
1734 Node* vfalse = __ LoadField(AccessBuilder::ForHeapNumberValue(), value);
1742 Node* EffectControlLinearizer::LowerChangeTaggedToFloat64(Node* node) {
1746 Node* EffectControlLinearizer::LowerChangeTaggedToTaggedSigned(Node* node) {
1747 Node* value = node->InputAt(0);
1752 Node* check = ObjectIsSmi(value);
1759 Node* vfalse = __ LoadField(AccessBuilder::ForHeapNumberValue(), value);
1768 Node* EffectControlLinearizer::LowerTruncateTaggedToFloat64(Node* node) {
1769 Node* value = node->InputAt(0);
1774 Node* check = ObjectIsSmi(value);
1776 Node* vtrue = ChangeSmiToInt32(value);
1783 Node* vfalse = __ LoadField(AccessBuilder::ForHeapNumberValue(), value);
1790 Node* EffectControlLinearizer::LowerCheckClosure(Node* node,
1791 Node* frame_state) {
1793 Node* value = node->InputAt(0);
1796 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1797 Node* value_instance_type =
1799 Node* check_instance_type = __ Uint32LessThanOrEqual(
1808 Node* value_cell =
1810 Node* check_cell = __ WordEqual(value_cell, __ HeapConstant(feedback_cell));
1817 Node* value, Node* value_map, Node* frame_state,
1820 Node* bitfield3 = __ LoadField(AccessBuilder::ForMapBitField3(), value_map);
1821 Node* is_not_deprecated = __ Word32Equal(
1830 Node* result = __ Call(call_descriptor, __ CEntryStubConstant(1), value,
1833 Node* check = ObjectIsSmi(result);
1838 void EffectControlLinearizer::LowerCheckMaps(Node* node, Node* frame_state) {
1840 Node* value = node->InputAt(0);
1850 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1854 Node* map = __ HeapConstant(maps[i]);
1855 Node* check = __ TaggedEqual(value_map, map);
1875 Node* map = __ HeapConstant(maps[i]);
1876 Node* check = __ TaggedEqual(value_map, map);
1893 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1896 Node* map = __ HeapConstant(maps[i]);
1897 Node* check = __ TaggedEqual(value_map, map);
1913 void EffectControlLinearizer::TryMigrateInstance(Node* value, Node* value_map) {
1916 Node* bitfield3 = __ LoadField(AccessBuilder::ForMapBitField3(), value_map);
1917 Node* is_not_deprecated = __ Word32Equal(
1933 Node* EffectControlLinearizer::LowerCompareMaps(Node* node) {
1936 Node* value = node->InputAt(0);
1941 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1944 Node* map = __ HeapConstant(maps[i]);
1945 Node* check = __ TaggedEqual(value_map, map);
1962 Node* EffectControlLinearizer::LowerCheckNumber(Node* node, Node* frame_state) {
1963 Node* value = node->InputAt(0);
1969 Node* check0 = ObjectIsSmi(value);
1974 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1975 Node* check1 = __ TaggedEqual(value_map, __ HeapNumberMapConstant());
1984 Node* EffectControlLinearizer::LowerCheckReceiver(Node* node,
1985 Node* frame_state) {
1986 Node* value = node->InputAt(0);
1988 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
1989 Node* value_instance_type =
1993 Node* check = __ Uint32LessThanOrEqual(
2000 Node* EffectControlLinearizer::LowerCheckReceiverOrNullOrUndefined(
2001 Node* node, Node* frame_state) {
2002 Node* value = node->InputAt(0);
2004 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
2005 Node* value_instance_type =
2011 Node* check0 = __ Uint32LessThanOrEqual(__ Uint32Constant(ODDBALL_TYPE),
2017 Node* check1 = __ TaggedEqual(value_map, __ BooleanMapConstant());
2023 Node* EffectControlLinearizer::LowerCheckSymbol(Node* node, Node* frame_state) {
2024 Node* value = node->InputAt(0);
2026 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
2028 Node* check =
2035 Node* EffectControlLinearizer::LowerCheckString(Node* node, Node* frame_state) {
2036 Node* value = node->InputAt(0);
2039 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
2040 Node* value_instance_type =
2043 Node* check = __ Uint32LessThan(value_instance_type,
2050 Node* EffectControlLinearizer::LowerCheckInternalizedString(Node* node,
2051 Node* frame_state) {
2052 Node* value = node->InputAt(0);
2054 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
2055 Node* value_instance_type =
2058 Node* check = __ Word32Equal(
2068 void EffectControlLinearizer::LowerCheckIf(Node* node, Node* frame_state) {
2069 Node* value = node->InputAt(0);
2074 Node* EffectControlLinearizer::LowerStringConcat(Node* node) {
2075 Node* lhs = node->InputAt(1);
2076 Node* rhs = node->InputAt(2);
2085 Node* value = __ Call(call_descriptor, __ HeapConstant(callable.code()), lhs,
2091 Node* EffectControlLinearizer::LowerCheckedInt32Add(Node* node,
2092 Node* frame_state) {
2093 Node* lhs = node->InputAt(0);
2094 Node* rhs = node->InputAt(1);
2096 Node* value = __ Int32AddWithOverflow(lhs, rhs);
2097 Node* check = __ Projection(1, value);
2103 Node* EffectControlLinearizer::LowerCheckedInt32Sub(Node* node,
2104 Node* frame_state) {
2105 Node* lhs = node->InputAt(0);
2106 Node* rhs = node->InputAt(1);
2108 Node* value = __ Int32SubWithOverflow(lhs, rhs);
2109 Node* check = __ Projection(1, value);
2115 Node* EffectControlLinearizer::LowerCheckedInt32Div(Node* node,
2116 Node* frame_state) {
2117 Node* lhs = node->InputAt(0);
2118 Node* rhs = node->InputAt(1);
2119 Node* zero = __ Int32Constant(0);
2130 Node* mask = __ Int32Constant(divisor - 1);
2131 Node* shift = __ Int32Constant(base::bits::WhichPowerOfTwo(divisor));
2132 Node* check = __ Word32Equal(__ Word32And(lhs, mask), zero);
2142 Node* check_rhs_positive = __ Int32LessThan(zero, rhs);
2157 Node* check_rhs_zero = __ Word32Equal(rhs, zero);
2162 Node* check_lhs_zero = __ Word32Equal(lhs, zero);
2168 Node* check_lhs_minint = __ Word32Equal(lhs, __ Int32Constant(kMinInt));
2174 Node* check_rhs_minusone = __ Word32Equal(rhs, __ Int32Constant(-1));
2190 Node* value = done.PhiAt(0);
2193 Node* check = __ Word32Equal(lhs, __ Int32Mul(value, rhs));
2203 Node* value, GraphAssemblerLabel<VarCount>* if_overflow,
2208 Node* add = __ Int32AddWithOverflow(value, value);
2209 Node* ovf = __ Projection(1, add);
2211 Node* value_smi = __ Projection(0, add);
2216 Node* EffectControlLinearizer::SmiTagOrDeopt(Node* value,
2218 Node* frame_state) {
2222 Node* add = __ Int32AddWithOverflow(value, value);
2223 Node* check = __ Projection(1, add);
2226 Node* result = __ Projection(0, add);
2230 Node* EffectControlLinearizer::BuildUint32Mod(Node* lhs, Node* rhs) {
2235 Node* one = __ Int32Constant(1);
2236 Node* msk = __ Int32Sub(rhs, one);
2256 Node* EffectControlLinearizer::LowerCheckedInt32Mod(Node* node,
2257 Node* frame_state) {
2282 Node* lhs = node->InputAt(0);
2283 Node* rhs = node->InputAt(1);
2291 Node* zero = __ Int32Constant(0);
2294 Node* check0 = __ Int32LessThanOrEqual(rhs, zero);
2302 Node* vtrue0 = __ Int32Sub(zero, rhs);
2325 Node* res = __ Uint32Mod(__ Int32Sub(zero, lhs), rhs);
2337 Node* EffectControlLinearizer::LowerCheckedUint32Div(Node* node,
2338 Node* frame_state) {
2339 Node* lhs = node->InputAt(0);
2340 Node* rhs = node->InputAt(1);
2341 Node* zero = __ Int32Constant(0);
2352 Node* mask = __ Uint32Constant(divisor - 1);
2353 Node* shift = __ Uint32Constant(base::bits::WhichPowerOfTwo(divisor));
2354 Node* check = __ Word32Equal(__ Word32And(lhs, mask), zero);
2360 Node* check = __ Word32Equal(rhs, zero);
2365 Node* value = __ Uint32Div(lhs, rhs);
2375 Node* EffectControlLinearizer::LowerCheckedUint32Mod(Node* node,
2376 Node* frame_state) {
2377 Node* lhs = node->InputAt(0);
2378 Node* rhs = node->InputAt(1);
2380 Node* zero = __ Int32Constant(0);
2383 Node* check = __ Word32Equal(rhs, zero);
2391 Node* EffectControlLinearizer::LowerCheckedInt32Mul(Node* node,
2392 Node* frame_state) {
2394 Node* lhs = node->InputAt(0);
2395 Node* rhs = node->InputAt(1);
2397 Node* projection = __ Int32MulWithOverflow(lhs, rhs);
2398 Node* check = __ Projection(1, projection);
2402 Node* value = __ Projection(0, projection);
2407 Node* zero = __ Int32Constant(0);
2408 Node* check_zero = __ Word32Equal(value, zero);
2414 Node* check_or = __ Int32LessThan(__ Word32Or(lhs, rhs), zero);
2425 Node* EffectControlLinearizer::LowerCheckedInt32ToTaggedSigned(
2426 Node* node, Node* frame_state) {
2428 Node* value = node->InputAt(0);
2433 Node* EffectControlLinearizer::LowerCheckedInt64ToInt32(Node* node,
2434 Node* frame_state) {
2435 Node* value = node->InputAt(0);
2438 Node* value32 = __ TruncateInt64ToInt32(value);
2439 Node* check = __ Word64Equal(__ ChangeInt32ToInt64(value32), value);
2445 Node* EffectControlLinearizer::LowerCheckedInt64ToTaggedSigned(
2446 Node* node, Node* frame_state) {
2447 Node* value = node->InputAt(0);
2450 Node* value32 = __ TruncateInt64ToInt32(value);
2451 Node* check = __ Word64Equal(__ ChangeInt32ToInt64(value32), value);
2462 Node* EffectControlLinearizer::LowerCheckedUint32Bounds(Node* node,
2463 Node* frame_state) {
2464 Node* index = node->InputAt(0);
2465 Node* limit = node->InputAt(1);
2468 Node* check = __ Uint32LessThan(index, limit);
2488 Node* EffectControlLinearizer::LowerCheckedUint32ToInt32(Node* node,
2489 Node* frame_state) {
2490 Node* value = node->InputAt(0);
2492 Node* unsafe = __ Int32LessThan(value, __ Int32Constant(0));
2498 Node* EffectControlLinearizer::LowerCheckedUint32ToTaggedSigned(
2499 Node* node, Node* frame_state) {
2500 Node* value = node->InputAt(0);
2502 Node* check = __ Uint32LessThanOrEqual(value, SmiMaxValueConstant());
2508 Node* EffectControlLinearizer::LowerCheckedUint64Bounds(Node* node,
2509 Node* frame_state) {
2510 Node* const index = node->InputAt(0);
2511 Node* const limit = node->InputAt(1);
2514 Node* check = __ Uint64LessThan(index, limit);
2533 Node* EffectControlLinearizer::LowerCheckedUint64ToInt32(Node* node,
2534 Node* frame_state) {
2535 Node* value = node->InputAt(0);
2538 Node* check = __ Uint64LessThanOrEqual(value, __ Int64Constant(kMaxInt));
2544 Node* EffectControlLinearizer::LowerCheckedUint64ToTaggedSigned(
2545 Node* node, Node* frame_state) {
2546 Node* value = node->InputAt(0);
2549 Node* check =
2556 Node* EffectControlLinearizer::BuildCheckedFloat64ToInt32(
2557 CheckForMinusZeroMode mode, const FeedbackSource& feedback, Node* value,
2558 Node* frame_state) {
2559 Node* value32 = __ RoundFloat64ToInt32(value);
2560 Node* check_same = __ Float64Equal(value, __ ChangeInt32ToFloat64(value32));
2569 Node* check_zero = __ Word32Equal(value32, __ Int32Constant(0));
2575 Node* check_negative = __ Int32LessThan(__ Float64ExtractHighWord32(value),
2586 Node* EffectControlLinearizer::BuildCheckedFloat64ToIndex(
2587 const FeedbackSource& feedback, Node* value, Node* frame_state) {
2589 Node* value64 =
2595 Node* check_same = __ Float64Equal(value, __ ChangeInt64ToFloat64(value64));
2598 Node* check_max =
2602 Node* check_min =
2608 Node* value32 = __ RoundFloat64ToInt32(value);
2609 Node* check_same = __ Float64Equal(value, __ ChangeInt32ToFloat64(value32));
2616 Node* EffectControlLinearizer::LowerCheckedFloat64ToInt32(Node* node,
2617 Node* frame_state) {
2620 Node* value = node->InputAt(0);
2625 Node* EffectControlLinearizer::BuildCheckedFloat64ToInt64(
2626 CheckForMinusZeroMode mode, const FeedbackSource& feedback, Node* value,
2627 Node* frame_state) {
2628 Node* value64 =
2630 Node* check_same = __ Float64Equal(value, __ ChangeInt64ToFloat64(value64));
2639 Node* check_zero = __ Word64Equal(value64, __ Int64Constant(0));
2645 Node* check_negative = __ Int32LessThan(__ Float64ExtractHighWord32(value),
2656 Node* EffectControlLinearizer::LowerCheckedFloat64ToInt64(Node* node,
2657 Node* frame_state) {
2660 Node* value = node->InputAt(0);
2665 Node* EffectControlLinearizer::LowerCheckedTaggedSignedToInt32(
2666 Node* node, Node* frame_state) {
2667 Node* value = node->InputAt(0);
2669 Node* check = ObjectIsSmi(value);
2675 Node* EffectControlLinearizer::LowerCheckedTaggedToArrayIndex(
2676 Node* node, Node* frame_state) {
2678 Node* value = node->InputAt(0);
2691 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
2692 Node* is_heap_number = __ TaggedEqual(value_map, __ HeapNumberMapConstant());
2695 Node* number = __ LoadField(AccessBuilder::ForHeapNumberValue(), value);
2701 Node* value_instance_type =
2703 Node* is_string = __ Uint32LessThan(value_instance_type,
2711 Node* string_to_array_index_function =
2715 Node* index = __ Call(common()->Call(call_descriptor),
2727 Node* EffectControlLinearizer::LowerCheckedTaggedToInt32(Node* node,
2728 Node* frame_state) {
2731 Node* value = node->InputAt(0);
2735 Node* check = ObjectIsSmi(value);
2743 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
2744 Node* check_map = __ TaggedEqual(value_map, __ HeapNumberMapConstant());
2747 Node* vfalse = __ LoadField(AccessBuilder::ForHeapNumberValue(), value);
2756 Node* EffectControlLinearizer::LowerCheckedTaggedToInt64(Node* node,
2757 Node* frame_state) {
2760 Node* value = node->InputAt(0);
2765 Node* check = ObjectIsSmi(value);
2773 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
2774 Node* check_map = __ TaggedEqual(value_map, __ HeapNumberMapConstant());
2777 Node* vfalse = __ LoadField(AccessBuilder::ForHeapNumberValue(), value);
2786 Node* EffectControlLinearizer::BuildCheckedHeapNumberOrOddballToFloat64(
2787 CheckTaggedInputMode mode, const FeedbackSource& feedback, Node* value,
2788 Node* frame_state) {
2789 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
2790 Node* check_number = __ TaggedEqual(value_map, __ HeapNumberMapConstant());
2817 Node* instance_type =
2819 Node* check_oddball =
2834 Node* EffectControlLinearizer::LowerCheckedTaggedToFloat64(Node* node,
2835 Node* frame_state) {
2838 Node* value = node->InputAt(0);
2843 Node* check = ObjectIsSmi(value);
2848 Node* number = BuildCheckedHeapNumberOrOddballToFloat64(
2853 Node* from_smi = ChangeSmiToInt32(value);
2861 Node* EffectControlLinearizer::LowerCheckedTaggedToTaggedSigned(
2862 Node* node, Node* frame_state) {
2863 Node* value = node->InputAt(0);
2866 Node* check = ObjectIsSmi(value);
2873 Node* EffectControlLinearizer::LowerCheckedTaggedToTaggedPointer(
2874 Node* node, Node* frame_state) {
2875 Node* value = node->InputAt(0);
2878 Node* check = ObjectIsSmi(value);
2884 Node* EffectControlLinearizer::LowerCheckBigInt(Node* node, Node* frame_state) {
2885 Node* value = node->InputAt(0);
2889 Node* smi_check = ObjectIsSmi(value);
2894 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
2895 Node* bi_check = __ TaggedEqual(value_map, __ BigIntMapConstant());
2902 Node* EffectControlLinearizer::LowerChangeInt64ToBigInt(Node* node) {
2906 Node* value = node->InputAt(0);
2913 Node* sign =
2915 Node* bitfield =
2920 Node* sign_mask = __ Word64Sar(value, __ Int64Constant(63));
2921 Node* absolute_value = __ Int64Sub(__ Word64Xor(value, sign_mask), sign_mask);
2928 Node* EffectControlLinearizer::LowerChangeUint64ToBigInt(Node* node) {
2932 Node* value = node->InputAt(0);
2945 Node* EffectControlLinearizer::LowerTruncateBigIntToWord64(Node* node) {
2952 Node* value = node->InputAt(0);
2954 Node* bitfield = __ LoadField(AccessBuilder::ForBigIntBitfield(), value);
2960 Node* lsd =
2962 Node* sign =
2975 Node* EffectControlLinearizer::LowerTruncateTaggedToWord32(Node* node) {
2976 Node* value = node->InputAt(0);
2981 Node* check = ObjectIsSmi(value);
2988 Node* vfalse = __ LoadField(AccessBuilder::ForHeapNumberValue(), value);
2996 Node* EffectControlLinearizer::LowerCheckedTruncateTaggedToWord32(
2997 Node* node, Node* frame_state) {
3000 Node* value = node->InputAt(0);
3005 Node* check = ObjectIsSmi(value);
3013 Node* number = BuildCheckedHeapNumberOrOddballToFloat64(
3022 Node* EffectControlLinearizer::LowerAllocate(Node* node) {
3023 Node* size = node->InputAt(0);
3025 Node* new_node = __ Allocate(allocation, size);
3029 Node* EffectControlLinearizer::LowerNumberToString(Node* node) {
3030 Node* argument = node->InputAt(0);
3043 Node* EffectControlLinearizer::LowerObjectIsArrayBufferView(Node* node) {
3044 Node* value = node->InputAt(0);
3049 Node* check = ObjectIsSmi(value);
3052 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
3053 Node* value_instance_type =
3055 Node* vfalse = __ Uint32LessThan(
3069 Node* EffectControlLinearizer::LowerObjectIsBigInt(Node* node) {
3070 Node* value = node->InputAt(0);
3075 Node* check = ObjectIsSmi(value);
3077 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
3078 Node* vfalse = __ TaggedEqual(value_map, __ BigIntMapConstant());
3088 Node* EffectControlLinearizer::LowerObjectIsCallable(Node* node) {
3089 Node* value = node->InputAt(0);
3094 Node* check = ObjectIsSmi(value);
3097 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
3098 Node* value_bit_field =
3100 Node* vfalse = __ Word32Equal(
3113 Node* EffectControlLinearizer::LowerObjectIsConstructor(Node* node) {
3114 Node* value = node->InputAt(0);
3119 Node* check = ObjectIsSmi(value);
3122 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
3123 Node* value_bit_field =
3125 Node* vfalse = __ Word32Equal(
3138 Node* EffectControlLinearizer::LowerObjectIsDetectableCallable(Node* node) {
3139 Node* value = node->InputAt(0);
3144 Node* check = ObjectIsSmi(value);
3147 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
3148 Node* value_bit_field =
3150 Node* vfalse = __ Word32Equal(
3164 Node* EffectControlLinearizer::LowerNumberIsFloat64Hole(Node* node) {
3165 Node* value = node->InputAt(0);
3166 Node* check = __ Word32Equal(__ Float64ExtractHighWord32(value),
3171 Node* EffectControlLinearizer::LowerNumberIsFinite(Node* node) {
3172 Node* number = node->InputAt(0);
3173 Node* diff = __ Float64Sub(number, number);
3174 Node* check = __ Float64Equal(diff, diff);
3178 Node* EffectControlLinearizer::LowerObjectIsFiniteNumber(Node* node) {
3179 Node* object = node->InputAt(0);
3180 Node* zero = __ Int32Constant(0);
3181 Node* one = __ Int32Constant(1);
3189 Node* value_map = __ LoadField(AccessBuilder::ForMap(), object);
3194 Node* value = __ LoadField(AccessBuilder::ForHeapNumberValue(), object);
3195 Node* diff = __ Float64Sub(value, value);
3196 Node* check = __ Float64Equal(diff, diff);
3203 Node* EffectControlLinearizer::LowerNumberIsInteger(Node* node) {
3204 Node* number = node->InputAt(0);
3205 Node* trunc = BuildFloat64RoundTruncate(number);
3206 Node* diff = __ Float64Sub(number, trunc);
3207 Node* check = __ Float64Equal(diff, __ Float64Constant(0));
3211 Node* EffectControlLinearizer::LowerObjectIsInteger(Node* node) {
3212 Node* object = node->InputAt(0);
3213 Node* zero = __ Int32Constant(0);
3214 Node* one = __ Int32Constant(1);
3222 Node* value_map = __ LoadField(AccessBuilder::ForMap(), object);
3227 Node* value = __ LoadField(AccessBuilder::ForHeapNumberValue(), object);
3228 Node* trunc = BuildFloat64RoundTruncate(value);
3229 Node* diff = __ Float64Sub(value, trunc);
3230 Node* check = __ Float64Equal(diff, __ Float64Constant(0));
3237 Node* EffectControlLinearizer::LowerNumberIsSafeInteger(Node* node) {
3238 Node* number = node->InputAt(0);
3239 Node* zero = __ Int32Constant(0);
3242 Node* trunc = BuildFloat64RoundTruncate(number);
3243 Node* diff = __ Float64Sub(number, trunc);
3244 Node* check = __ Float64Equal(diff, __ Float64Constant(0));
3246 Node* in_range = __ Float64LessThanOrEqual(
3254 Node* EffectControlLinearizer::LowerObjectIsSafeInteger(Node* node) {
3255 Node* object = node->InputAt(0);
3256 Node* zero = __ Int32Constant(0);
3257 Node* one = __ Int32Constant(1);
3265 Node* value_map = __ LoadField(AccessBuilder::ForMap(), object);
3270 Node* value = __ LoadField(AccessBuilder::ForHeapNumberValue(), object);
3271 Node* trunc = BuildFloat64RoundTruncate(value);
3272 Node* diff = __ Float64Sub(value, trunc);
3273 Node* check = __ Float64Equal(diff, __ Float64Constant(0));
3275 Node* in_range = __ Float64LessThanOrEqual(
3296 Node* EffectControlLinearizer::LowerObjectIsMinusZero(Node* node) {
3297 Node* value = node->InputAt(0);
3298 Node* zero = __ Int32Constant(0);
3306 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
3311 Node* value_value = __ LoadField(AccessBuilder::ForHeapNumberValue(), value);
3313 Node* value64 = __ BitcastFloat64ToInt64(value_value);
3316 Node* value_lo = __ Float64ExtractLowWord32(value_value);
3319 Node* value_hi = __ Float64ExtractHighWord32(value_value);
3328 Node* EffectControlLinearizer::LowerNumberIsMinusZero(Node* node) {
3329 Node* value = node->InputAt(0);
3332 Node* value64 = __ BitcastFloat64ToInt64(value);
3337 Node* value_lo = __ Float64ExtractLowWord32(value);
3340 Node* value_hi = __ Float64ExtractHighWord32(value);
3349 Node* EffectControlLinearizer::LowerObjectIsNaN(Node* node) {
3350 Node* value = node->InputAt(0);
3351 Node* zero = __ Int32Constant(0);
3359 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
3364 Node* value_value = __ LoadField(AccessBuilder::ForHeapNumberValue(), value);
3372 Node* EffectControlLinearizer::LowerNumberIsNaN(Node* node) {
3373 Node* number = node->InputAt(0);
3374 Node* diff = __ Float64Equal(number, number);
3375 Node* check = __ Word32Equal(diff, __ Int32Constant(0));
3379 Node* EffectControlLinearizer::LowerObjectIsNonCallable(Node* node) {
3380 Node* value = node->InputAt(0);
3385 Node* check0 = ObjectIsSmi(value);
3388 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
3389 Node* value_instance_type =
3392 Node* check1 = __ Uint32LessThanOrEqual(
3396 Node* value_bit_field =
3398 Node* check2 = __ Word32Equal(
3411 Node* EffectControlLinearizer::LowerObjectIsNumber(Node* node) {
3412 Node* value = node->InputAt(0);
3418 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
3428 Node* EffectControlLinearizer::LowerObjectIsReceiver(Node* node) {
3429 Node* value = node->InputAt(0);
3437 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
3438 Node* value_instance_type =
3440 Node* result = __ Uint32LessThanOrEqual(
3451 Node* EffectControlLinearizer::LowerObjectIsSmi(Node* node) {
3452 Node* value = node->InputAt(0);
3456 Node* EffectControlLinearizer::LowerObjectIsString(Node* node) {
3457 Node* value = node->InputAt(0);
3462 Node* check = ObjectIsSmi(value);
3464 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
3465 Node* value_instance_type =
3467 Node* vfalse = __ Uint32LessThan(value_instance_type,
3478 Node* EffectControlLinearizer::LowerObjectIsSymbol(Node* node) {
3479 Node* value = node->InputAt(0);
3484 Node* check = ObjectIsSmi(value);
3486 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
3487 Node* value_instance_type =
3489 Node* vfalse =
3500 Node* EffectControlLinearizer::LowerObjectIsUndetectable(Node* node) {
3501 Node* value = node->InputAt(0);
3506 Node* check = ObjectIsSmi(value);
3509 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
3510 Node* value_bit_field =
3512 Node* vfalse = __ Word32Equal(
3527 Node* EffectControlLinearizer::LowerTypeOf(Node* node) {
3528 Node* obj = node->InputAt(0);
3539 Node* EffectControlLinearizer::LowerToBoolean(Node* node) {
3540 Node* obj = node->InputAt(0);
3551 Node* EffectControlLinearizer::LowerArgumentsLength(Node* node) {
3552 Node* arguments_length = ChangeIntPtrToSmi(
3560 Node* EffectControlLinearizer::LowerRestLength(Node* node) {
3565 Node* frame = __ LoadFramePointer();
3567 Node* arguments_length = ChangeIntPtrToSmi(
3572 Node* rest_length =
3582 Node* EffectControlLinearizer::LowerNewDoubleElements(Node* node) {
3584 Node* length = node->InputAt(0);
3587 Node* zero_length = __ IntPtrEqual(length, __ IntPtrConstant(0));
3592 Node* size = __ IntAdd(__ WordShl(length, __ IntPtrConstant(kDoubleSizeLog2)),
3596 Node* result = __ Allocate(allocation, size);
3605 Node* the_hole =
3612 Node* index = loop.PhiAt(0);
3613 Node* check = __ UintLessThan(index, length);
3630 Node* EffectControlLinearizer::LowerNewSmiOrObjectElements(Node* node) {
3632 Node* length = node->InputAt(0);
3635 Node* zero_length = __ IntPtrEqual(length, __ IntPtrConstant(0));
3640 Node* size = __ IntAdd(__ WordShl(length, __ IntPtrConstant(kTaggedSizeLog2)),
3644 Node* result = __ Allocate(allocation, size);
3650 Node* the_hole = __ TheHoleConstant();
3656 Node* index = loop.PhiAt(0);
3657 Node* check = __ UintLessThan(index, length);
3675 Node* EffectControlLinearizer::LowerNewArgumentsElements(Node* node) {
3681 Node* frame = __ LoadFramePointer();
3682 Node* arguments_count = NodeProperties::GetValueInput(node, 0);
3704 Node* EffectControlLinearizer::LowerNewConsString(Node* node) {
3705 Node* length = node->InputAt(0);
3706 Node* first = node->InputAt(1);
3707 Node* second = node->InputAt(2);
3710 Node* first_map = __ LoadField(AccessBuilder::ForMap(), first);
3711 Node* first_instance_type =
3713 Node* second_map = __ LoadField(AccessBuilder::ForMap(), second);
3714 Node* second_instance_type =
3726 Node* instance_type = __ Word32And(first_instance_type, second_instance_type);
3727 Node* encoding =
3736 Node* result_map = done.PhiAt(0);
3739 Node* result =
3750 Node* EffectControlLinearizer::LowerSameValue(Node* node) {
3751 Node* lhs = node->InputAt(0);
3752 Node* rhs = node->InputAt(1);
3765 Node* EffectControlLinearizer::LowerSameValueNumbersOnly(Node* node) {
3766 Node* lhs = node->InputAt(0);
3767 Node* rhs = node->InputAt(1);
3780 Node* EffectControlLinearizer::LowerNumberSameValue(Node* node) {
3781 Node* lhs = node->InputAt(0);
3782 Node* rhs = node->InputAt(1);
3797 Node* lhs_hi = __ Float64ExtractHighWord32(lhs);
3798 Node* rhs_hi = __ Float64ExtractHighWord32(rhs);
3805 Node* EffectControlLinearizer::LowerDeadValue(Node* node) {
3806 Node* input = NodeProperties::GetValueInput(node, 0);
3812 Node* unreachable = __ UnreachableWithoutConnectToEnd();
3818 Node* EffectControlLinearizer::LowerStringToNumber(Node* node) {
3819 Node* string = node->InputAt(0);
3832 Node* EffectControlLinearizer::StringCharCodeAt(Node* receiver,
3833 Node* position) {
3846 Node* receiver_map = __ LoadField(AccessBuilder::ForMap(), receiver);
3847 Node* receiver_instance_type =
3849 Node* receiver_representation = __ Word32And(
3888 Node* receiver_is_onebyte = __ Word32Equal(
3893 Node* result = LoadFromSeqString(receiver, position, receiver_is_onebyte);
3899 Node* receiver_second =
3903 Node* receiver_first =
3910 Node* receiver_actual =
3924 Node* receiver_data = __ LoadField(
3937 Node* result = __ Load(MachineType::Uint8(), receiver_data, position);
3943 Node* result = __ Load(MachineType::Uint16(), receiver_data,
3951 Node* receiver_offset =
3953 Node* receiver_parent =
3965 Node* result = __ Call(call_descriptor, __ CEntryStubConstant(1),
3979 Node* EffectControlLinearizer::LowerStringCharCodeAt(Node* node) {
3980 Node* receiver = node->InputAt(0);
3981 Node* position = node->InputAt(1);
3985 Node* EffectControlLinearizer::LowerStringCodePointAt(Node* node) {
3986 Node* receiver = node->InputAt(0);
3987 Node* position = node->InputAt(1);
3990 Node* first_code_unit = StringCharCodeAt(receiver, position);
4001 Node* second_code_unit = StringCharCodeAt(receiver, next_index);
4016 Node* EffectControlLinearizer::LoadFromSeqString(Node* receiver, Node* position,
4017 Node* is_one_byte) {
4021 Node* two_byte_result = __ LoadElement(
4026 Node* one_byte_element = __ LoadElement(
4034 Node* EffectControlLinearizer::LowerStringFromSingleCharCode(Node* node) {
4035 Node* value = node->InputAt(0);
4036 Node* code = __ Word32And(value, __ Uint32Constant(0xFFFF));
4043 Node* check1 = __ Uint32LessThanOrEqual(
4048 Node* cache = __ HeapConstant(factory()->single_character_string_cache());
4051 Node* index = machine()->Is32() ? code : __ ChangeUint32ToUint64(code);
4055 Node* entry =
4058 Node* check2 = __ TaggedEqual(entry, __ UndefinedConstant());
4067 Node* vtrue2 =
4092 Node* vfalse1 =
4115 Node* EffectControlLinearizer::LowerStringToLowerCaseIntl(Node* node) {
4116 Node* receiver = node->InputAt(0);
4129 Node* EffectControlLinearizer::LowerStringToUpperCaseIntl(Node* node) {
4130 Node* receiver = node->InputAt(0);
4142 Node* EffectControlLinearizer::LowerStringToLowerCaseIntl(Node* node) {
4146 Node* EffectControlLinearizer::LowerStringToUpperCaseIntl(Node* node) {
4152 Node* EffectControlLinearizer::LowerStringFromSingleCodePoint(Node* node) {
4153 Node* value = node->InputAt(0);
4154 Node* code = value;
4162 Node* check0 = __ Uint32LessThanOrEqual(code, __ Uint32Constant(0xFFFF));
4167 Node* check1 = __ Uint32LessThanOrEqual(
4172 Node* cache = __ HeapConstant(factory()->single_character_string_cache());
4175 Node* index = machine()->Is32() ? code : __ ChangeUint32ToUint64(code);
4179 Node* entry =
4182 Node* check2 = __ TaggedEqual(entry, __ UndefinedConstant());
4191 Node* vtrue2 =
4216 Node* vfalse1 =
4238 Node* lead_offset = __ Int32Constant(0xD800 - (0x10000 >> 10));
4241 Node* lead =
4245 Node* trail = __ Int32Add(__ Word32And(code, __ Int32Constant(0x3FF)),
4256 Node* vfalse0 =
4277 Node* EffectControlLinearizer::LowerStringIndexOf(Node* node) {
4278 Node* subject = node->InputAt(0);
4279 Node* search_string = node->InputAt(1);
4280 Node* position = node->InputAt(2);
4292 Node* EffectControlLinearizer::LowerStringFromCodePointAt(Node* node) {
4293 Node* string = node->InputAt(0);
4294 Node* index = node->InputAt(1);
4307 Node* EffectControlLinearizer::LowerStringLength(Node* node) {
4308 Node* subject = node->InputAt(0);
4313 Node* EffectControlLinearizer::LowerStringComparison(Callable const& callable,
4314 Node* node) {
4315 Node* lhs = node->InputAt(0);
4316 Node* rhs = node->InputAt(1);
4327 Node* EffectControlLinearizer::LowerStringSubstring(Node* node) {
4328 Node* receiver = node->InputAt(0);
4329 Node* start = ChangeInt32ToIntPtr(node->InputAt(1));
4330 Node* end = ChangeInt32ToIntPtr(node->InputAt(2));
4343 Node* EffectControlLinearizer::LowerStringEqual(Node* node) {
4348 Node* EffectControlLinearizer::LowerStringLessThan(Node* node) {
4353 Node* EffectControlLinearizer::LowerStringLessThanOrEqual(Node* node) {
4358 Node* EffectControlLinearizer::LowerBigIntAdd(Node* node, Node* frame_state) {
4359 Node* lhs = node->InputAt(0);
4360 Node* rhs = node->InputAt(1);
4368 Node* value = __ Call(call_descriptor, __ HeapConstant(callable.code()), lhs,
4378 Node* EffectControlLinearizer::LowerBigIntSubtract(Node* node,
4379 Node* frame_state) {
4380 Node* lhs = node->InputAt(0);
4381 Node* rhs = node->InputAt(1);
4389 Node* value = __ Call(call_descriptor, __ HeapConstant(callable.code()), lhs,
4399 Node* EffectControlLinearizer::LowerBigIntNegate(Node* node) {
4406 Node* value = __ Call(call_descriptor, __ HeapConstant(callable.code()),
4412 Node* EffectControlLinearizer::LowerCheckFloat64Hole(Node* node,
4413 Node* frame_state) {
4419 Node* value = node->InputAt(0);
4431 Node* check = __ Word32Equal(__ Float64ExtractHighWord32(value),
4442 Node* EffectControlLinearizer::LowerCheckNotTaggedHole(Node* node,
4443 Node* frame_state) {
4444 Node* value = node->InputAt(0);
4445 Node* check = __ TaggedEqual(value, __ TheHoleConstant());
4451 Node* EffectControlLinearizer::LowerConvertTaggedHoleToUndefined(Node* node) {
4452 Node* value = node->InputAt(0);
4457 Node* check = __ TaggedEqual(value, __ TheHoleConstant());
4469 Node* node, Node* frame_state) {
4470 Node* exp = node->InputAt(0);
4471 Node* val = node->InputAt(1);
4486 Node* val_map = __ LoadField(AccessBuilder::ForMap(), val);
4487 Node* val_instance_type =
4515 Node* try_string_to_index_or_lookup_existing = __ ExternalConstant(
4517 Node* const isolate_ptr =
4521 Node* val_internalized =
4534 Node* val_actual =
4545 void EffectControlLinearizer::LowerCheckEqualsSymbol(Node* node,
4546 Node* frame_state) {
4547 Node* exp = node->InputAt(0);
4548 Node* val = node->InputAt(1);
4549 Node* check = __ TaggedEqual(exp, val);
4554 Node* EffectControlLinearizer::AllocateHeapNumberWithValue(Node* value) {
4555 Node* result =
4562 Node* EffectControlLinearizer::ChangeIntPtrToSmi(Node* value) {
4570 Node* EffectControlLinearizer::ChangeTaggedInt32ToSmi(Node* value) {
4578 Node* EffectControlLinearizer::ChangeInt32ToIntPtr(Node* value) {
4585 Node* EffectControlLinearizer::ChangeIntPtrToInt32(Node* value) {
4592 Node* EffectControlLinearizer::ChangeInt32ToSmi(Node* value) {
4600 Node* EffectControlLinearizer::ChangeInt64ToSmi(Node* value) {
4605 Node* EffectControlLinearizer::ChangeUint32ToUintPtr(Node* value) {
4612 Node* EffectControlLinearizer::ChangeUint32ToSmi(Node* value) {
4615 Node* smi_value = __ Word32Shl(value, SmiShiftBitsConstant());
4625 Node* EffectControlLinearizer::ChangeSmiToIntPtr(Node* value) {
4635 Node* EffectControlLinearizer::ChangeSmiToInt32(Node* value) {
4647 Node* EffectControlLinearizer::ChangeSmiToInt64(Node* value) {
4652 Node* EffectControlLinearizer::ObjectIsSmi(Node* value) {
4657 Node* EffectControlLinearizer::SmiMaxValueConstant() {
4661 Node* EffectControlLinearizer::SmiShiftBitsConstant() {
4668 Node* EffectControlLinearizer::LowerPlainPrimitiveToNumber(Node* node) {
4669 Node* value = node->InputAt(0);
4673 Node* EffectControlLinearizer::LowerPlainPrimitiveToWord32(Node* node) {
4674 Node* value = node->InputAt(0);
4680 Node* check0 = ObjectIsSmi(value);
4685 Node* to_number =
4688 Node* check1 = ObjectIsSmi(to_number);
4690 Node* number = __ LoadField(AccessBuilder::ForHeapNumberValue(), to_number);
4700 Node* EffectControlLinearizer::LowerPlainPrimitiveToFloat64(Node* node) {
4701 Node* value = node->InputAt(0);
4707 Node* check0 = ObjectIsSmi(value);
4709 Node* from_smi = ChangeSmiToInt32(value);
4713 Node* to_number =
4715 Node* check1 = ObjectIsSmi(to_number);
4718 Node* number = __ LoadField(AccessBuilder::ForHeapNumberValue(), to_number);
4722 Node* number_from_smi = ChangeSmiToInt32(to_number);
4730 Node* EffectControlLinearizer::LowerEnsureWritableFastElements(Node* node) {
4731 Node* object = node->InputAt(0);
4732 Node* elements = node->InputAt(1);
4738 Node* elements_map = __ LoadField(AccessBuilder::ForMap(), elements);
4741 Node* check = __ TaggedEqual(elements_map, __ FixedArrayMapConstant());
4755 Node* result = __ Call(call_descriptor, __ HeapConstant(callable.code()),
4763 Node* EffectControlLinearizer::LowerMaybeGrowFastElements(Node* node,
4764 Node* frame_state) {
4766 Node* object = node->InputAt(0);
4767 Node* elements = node->InputAt(1);
4768 Node* index = node->InputAt(2);
4769 Node* elements_length = node->InputAt(3);
4776 Node* check = __ Uint32LessThan(index, elements_length);
4792 Node* new_elements =
4805 void EffectControlLinearizer::LowerTransitionElementsKind(Node* node) {
4807 Node* object = node->InputAt(0);
4812 Node* source_map = __ HeapConstant(transition.source());
4813 Node* target_map = __ HeapConstant(transition.target());
4816 Node* object_map = __ LoadField(AccessBuilder::ForMap(), object);
4819 Node* check = __ TaggedEqual(object_map, source_map);
4846 Node* EffectControlLinearizer::LowerLoadMessage(Node* node) {
4847 Node* offset = node->InputAt(0);
4848 Node* object_pattern =
4853 void EffectControlLinearizer::LowerStoreMessage(Node* node) {
4854 Node* offset = node->InputAt(0);
4855 Node* object = node->InputAt(1);
4856 Node* object_pattern = __ BitcastTaggedToWord(object);
4860 Node* EffectControlLinearizer::AdaptFastCallTypedArrayArgument(
4861 Node* node, ElementsKind expected_elements_kind,
4863 Node* value_map = __ LoadField(AccessBuilder::ForMap(), node);
4864 Node* value_instance_type =
4866 Node* value_is_typed_array = __ Word32Equal(
4870 Node* bit_field2 = __ LoadField(AccessBuilder::ForMapBitField2(), value_map);
4871 Node* mask = __ Int32Constant(Map::Bits2::ElementsKindBits::kMask);
4872 Node* andit = __ Word32And(bit_field2, mask);
4873 Node* shift = __ Int32Constant(Map::Bits2::ElementsKindBits::kShift);
4874 Node* kind = __ Word32Shr(andit, shift);
4876 Node* value_is_expected_elements_kind =
4880 Node* buffer =
4882 Node* buffer_bit_field =
4886 Node* buffer_is_not_detached = __ Word32Equal(
4893 Node* buffer_is_not_shared = __ Word32Equal(
4901 Node* external_pointer =
4906 // for Chrome. Node and Electron both set this limit to 0. Setting
4909 Node* base_pointer =
4914 Node* data_ptr = BuildTypedArrayDataPointer(base_pointer, external_pointer);
4915 Node* length_in_bytes =
4932 Node* stack_slot = __ StackSlot(kSize, kAlign);
4947 Node* EffectControlLinearizer::AdaptFastCallArgument(
4948 Node* node, CTypeInfo arg_type, GraphAssemblerLabel<0>* if_error) {
4955 Node* stack_slot = __ StackSlot(kSize, kAlign);
4974 Node* value_is_smi = ObjectIsSmi(node);
4977 Node* stack_slot = __ StackSlot(kSize, kAlign);
4983 Node* value_map = __ LoadField(AccessBuilder::ForMap(), node);
4984 Node* value_instance_type =
4986 Node* value_is_js_array =
4994 Node* value_is_smi = ObjectIsSmi(node);
5009 Node* node, const FastApiCallFunctionVector& c_functions,
5025 Node* value_is_smi = ObjectIsSmi(node);
5035 Node* value_map = __ LoadField(AccessBuilder::ForMap(), node);
5036 Node* value_instance_type =
5038 Node* value_is_js_array = __ Word32Equal(
5044 Node* stack_slot = __ StackSlot(kSize, kAlign);
5050 Node* target_address = __ ExternalConstant(ExternalReference::Create(
5059 Node* stack_slot = AdaptFastCallTypedArrayArgument(
5064 Node* target_address = __ ExternalConstant(ExternalReference::Create(
5083 Node* EffectControlLinearizer::WrapFastCall(
5084 const CallDescriptor* call_descriptor, int inputs_size, Node** inputs,
5085 Node* target, const CFunctionInfo* c_signature, int c_arg_count,
5086 Node* stack_slot) {
5088 Node* target_address = __ ExternalConstant(
5095 Node* javascript_execution_assert = __ ExternalConstant(
5101 Node* old_scope_value =
5123 Node* call = __ Call(call_descriptor, inputs_size, inputs);
5137 Node* EffectControlLinearizer::GenerateSlowApiCall(Node* node) {
5143 Node** const slow_inputs = graph()->zone()->NewArray<Node*>(
5156 Node* slow_call_result = __ Call(
5162 Node* EffectControlLinearizer::LowerFastApiCall(Node* node) {
5177 Node* stack_slot = nullptr;
5263 Node** const inputs = graph()->zone()->NewArray<Node*>(
5283 Node* value = NodeProperties::GetValueInput(node, i);
5304 Node* c_call_result = WrapFastCall(
5308 Node* fast_call_result = nullptr;
5349 Node* load = __ Load(
5353 Node* is_zero = __ Word32Equal(load, __ Int32Constant(0));
5356 Node* true_constant = __ TrueConstant();
5366 Node* slow_call_result = GenerateSlowApiCall(node);
5374 Node* EffectControlLinearizer::LowerLoadFieldByIndex(Node* node) {
5375 Node* object = node->InputAt(0);
5376 Node* index = node->InputAt(1);
5377 Node* zero = __ IntPtrConstant(0);
5378 Node* one = __ IntPtrConstant(1);
5402 Node* offset =
5405 Node* field = __ Load(MachineType::AnyTagged(), object, offset);
5413 Node* properties = __ LoadField(
5415 Node* offset =
5420 Node* field = __ Load(MachineType::AnyTagged(), properties, offset);
5437 Node* offset =
5440 Node* field = __ Load(MachineType::AnyTagged(), object, offset);
5446 Node* properties = __ LoadField(
5448 Node* offset =
5453 Node* field = __ Load(MachineType::AnyTagged(), properties, offset);
5460 Node* field = loaded_field.PhiAt(0);
5465 Node* field_map = __ LoadField(AccessBuilder::ForMap(), field);
5469 Node* value = __ LoadField(AccessBuilder::ForHeapNumberValue(), field);
5475 Node* result = AllocateHeapNumberWithValue(done_double.PhiAt(0));
5483 Node* EffectControlLinearizer::BuildReverseBytes(ExternalArrayType type,
5484 Node* value) {
5492 Node* result = __ Word32ReverseBytes(value);
5498 Node* result = __ Word32ReverseBytes(value);
5508 Node* result = __ BitcastFloat32ToInt32(value);
5516 Node* result = __ BitcastFloat64ToInt64(value);
5521 Node* lo = __ Word32ReverseBytes(__ Float64ExtractLowWord32(value));
5522 Node* hi = __ Word32ReverseBytes(__ Float64ExtractHighWord32(value));
5523 Node* result = __ Float64Constant(0.0);
5536 Node* EffectControlLinearizer::LowerLoadDataViewElement(Node* node) {
5538 Node* object = node->InputAt(0);
5539 Node* storage = node->InputAt(1);
5540 Node* index = node->InputAt(2);
5541 Node* is_little_endian = node->InputAt(3);
5551 Node* value = __ LoadUnaligned(machine_type, storage, index);
5578 void EffectControlLinearizer::LowerStoreDataViewElement(Node* node) {
5580 Node* object = node->InputAt(0);
5581 Node* storage = node->InputAt(1);
5582 Node* index = node->InputAt(2);
5583 Node* value = node->InputAt(3);
5584 Node* is_little_endian = node->InputAt(4);
5622 Node* EffectControlLinearizer::BuildTypedArrayDataPointer(Node* base,
5623 Node* external) {
5640 Node* EffectControlLinearizer::LowerLoadTypedElement(Node* node) {
5642 Node* buffer = node->InputAt(0);
5643 Node* base = node->InputAt(1);
5644 Node* external = node->InputAt(2);
5645 Node* index = node->InputAt(3);
5651 Node* data_ptr = BuildTypedArrayDataPointer(base, external);
5658 Node* EffectControlLinearizer::LowerLoadStackArgument(Node* node) {
5659 Node* base = node->InputAt(0);
5660 Node* index = node->InputAt(1);
5662 Node* argument =
5668 void EffectControlLinearizer::LowerStoreTypedElement(Node* node) {
5670 Node* buffer = node->InputAt(0);
5671 Node* base = node->InputAt(1);
5672 Node* external = node->InputAt(2);
5673 Node* index = node->InputAt(3);
5674 Node* value = node->InputAt(4);
5680 Node* data_ptr = BuildTypedArrayDataPointer(base, external);
5687 void EffectControlLinearizer::TransitionElementsTo(Node* node, Node* array,
5695 Node* target_map = __ HeapConstant(target);
5711 Node* EffectControlLinearizer::IsElementsKindGreaterThan(
5712 Node* kind, ElementsKind reference_kind) {
5713 Node* ref_kind = __ Int32Constant(reference_kind);
5714 Node* ret = __ Int32LessThan(ref_kind, kind);
5718 void EffectControlLinearizer::LowerTransitionAndStoreElement(Node* node) {
5719 Node* array = node->InputAt(0);
5720 Node* index = node->InputAt(1);
5721 Node* value = node->InputAt(2);
5759 Node* map = __ LoadField(AccessBuilder::ForMap(), array);
5760 Node* kind;
5762 Node* bit_field2 = __ LoadField(AccessBuilder::ForMapBitField2(), map);
5763 Node* mask = __ Int32Constant(Map::Bits2::ElementsKindBits::kMask);
5764 Node* andit = __ Word32And(bit_field2, mask);
5765 Node* shift = __ Int32Constant(Map::Bits2::ElementsKindBits::kShift);
5784 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
5785 Node* heap_number_map = __ HeapNumberMapConstant();
5786 Node* check = __ TaggedEqual(value_map, heap_number_map);
5796 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
5797 Node* heap_number_map = __ HeapNumberMapConstant();
5798 Node* check = __ TaggedEqual(value_map, heap_number_map);
5823 Node* elements = __ LoadField(AccessBuilder::ForJSObjectElements(), array);
5840 Node* int_value = ChangeSmiToInt32(value);
5841 Node* float_value = __ ChangeInt32ToFloat64(int_value);
5848 Node* float_value =
5859 void EffectControlLinearizer::LowerTransitionAndStoreNumberElement(Node* node) {
5860 Node* array = node->InputAt(0);
5861 Node* index = node->InputAt(1);
5862 Node* value = node->InputAt(2); // This is a Float64, not tagged.
5877 Node* map = __ LoadField(AccessBuilder::ForMap(), array);
5878 Node* kind;
5880 Node* bit_field2 = __ LoadField(AccessBuilder::ForMapBitField2(), map);
5881 Node* mask = __ Int32Constant(Map::Bits2::ElementsKindBits::kMask);
5882 Node* andit = __ Word32And(bit_field2, mask);
5883 Node* shift = __ Int32Constant(Map::Bits2::ElementsKindBits::kShift);
5913 Node* elements = __ LoadField(AccessBuilder::ForJSObjectElements(), array);
5919 Node* node) {
5920 Node* array = node->InputAt(0);
5921 Node* index = node->InputAt(1);
5922 Node* value = node->InputAt(2);
5938 Node* map = __ LoadField(AccessBuilder::ForMap(), array);
5939 Node* kind;
5941 Node* bit_field2 = __ LoadField(AccessBuilder::ForMapBitField2(), map);
5942 Node* mask = __ Int32Constant(Map::Bits2::ElementsKindBits::kMask);
5943 Node* andit = __ Word32And(bit_field2, mask);
5944 Node* shift = __ Int32Constant(Map::Bits2::ElementsKindBits::kShift);
5975 Node* elements = __ LoadField(AccessBuilder::ForJSObjectElements(), array);
5986 void EffectControlLinearizer::LowerStoreSignedSmallElement(Node* node) {
5987 Node* array = node->InputAt(0);
5988 Node* index = node->InputAt(1);
5989 Node* value = node->InputAt(2); // int32
6005 Node* map = __ LoadField(AccessBuilder::ForMap(), array);
6006 Node* kind;
6008 Node* bit_field2 = __ LoadField(AccessBuilder::ForMapBitField2(), map);
6009 Node* mask = __ Int32Constant(Map::Bits2::ElementsKindBits::kMask);
6010 Node* andit = __ Word32And(bit_field2, mask);
6011 Node* shift = __ Int32Constant(Map::Bits2::ElementsKindBits::kShift);
6015 Node* elements = __ LoadField(AccessBuilder::ForJSObjectElements(), array);
6028 Node* smi_value = ChangeInt32ToSmi(value);
6035 Node* float_value = __ ChangeInt32ToFloat64(value);
6044 void EffectControlLinearizer::LowerRuntimeAbort(Node* node) {
6057 Node* EffectControlLinearizer::CallBuiltin(Builtin builtin,
6069 Node* EffectControlLinearizer::LowerAssertType(Node* node) {
6073 Node* const input = node->InputAt(0);
6074 Node* allocated_type;
6088 Node* EffectControlLinearizer::LowerFoldConstant(Node* node) {
6090 Node* original = node->InputAt(0);
6091 Node* constant = node->InputAt(1);
6097 Node* EffectControlLinearizer::LowerConvertReceiver(Node* node) {
6099 Node* value = node->InputAt(0);
6100 Node* global_proxy = node->InputAt(1);
6113 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
6114 Node* value_instance_type =
6116 Node* check = __ Uint32LessThan(
6129 Node* native_context = __ LoadField(
6131 Node* result = __ Call(call_descriptor, __ HeapConstant(callable.code()),
6146 Node* value_map = __ LoadField(AccessBuilder::ForMap(), value);
6147 Node* value_instance_type =
6149 Node* check = __ Uint32LessThan(
6166 Node* native_context = __ LoadField(
6168 Node* result = __ Call(call_descriptor, __ HeapConstant(callable.code()),
6184 Maybe<Node*> EffectControlLinearizer::LowerFloat64RoundUp(Node* node) {
6187 return Nothing<Node*>();
6190 Node* const input = node->InputAt(0);
6222 Node* const zero = __ Float64Constant(0.0);
6223 Node* const two_52 = __ Float64Constant(4503599627370496.0E0);
6224 Node* const one = __ Float64Constant(1.0);
6226 Node* check0 = __ Float64LessThan(zero, input);
6229 Node* check1 = __ Float64LessThanOrEqual(two_52, input);
6232 Node* temp1 = __ Float64Sub(__ Float64Add(two_52, input), two_52);
6243 Node* check1 = __ Float64Equal(input, zero);
6246 Node* const minus_two_52 = __ Float64Constant(-4503599627370496.0E0);
6247 Node* check2 = __ Float64LessThanOrEqual(input, minus_two_52);
6251 Node* const minus_zero = __ Float64Constant(-0.0);
6252 Node* temp1 = __ Float64Sub(minus_zero, input);
6253 Node* temp2 = __ Float64Sub(__ Float64Add(two_52, temp1), two_52);
6254 Node* check3 = __ Float64LessThan(temp1, temp2);
6259 Node* temp3 = done_temp3.PhiAt(0);
6272 Node* EffectControlLinearizer::BuildFloat64RoundDown(Node* value) {
6277 Node* const input = value;
6311 Node* const zero = __ Float64Constant(0.0);
6312 Node* const two_52 = __ Float64Constant(4503599627370496.0E0);
6314 Node* check0 = __ Float64LessThan(zero, input);
6317 Node* check1 = __ Float64LessThanOrEqual(two_52, input);
6320 Node* const one = __ Float64Constant(1.0);
6321 Node* temp1 = __ Float64Sub(__ Float64Add(two_52, input), two_52);
6332 Node* check1 = __ Float64Equal(input, zero);
6335 Node* const minus_two_52 = __ Float64Constant(-4503599627370496.0E0);
6336 Node* check2 = __ Float64LessThanOrEqual(input, minus_two_52);
6340 Node* const minus_zero = __ Float64Constant(-0.0);
6341 Node* temp1 = __ Float64Sub(minus_zero, input);
6342 Node* temp2 = __ Float64Sub(__ Float64Add(two_52, temp1), two_52);
6343 Node* check3 = __ Float64LessThan(temp2, temp1);
6360 Maybe<Node*> EffectControlLinearizer::LowerFloat64RoundDown(Node* node) {
6363 return Nothing<Node*>();
6366 Node* const input = node->InputAt(0);
6370 Maybe<Node*> EffectControlLinearizer::LowerFloat64RoundTiesEven(Node* node) {
6373 return Nothing<Node*>();
6376 Node* const input = node->InputAt(0);
6396 Node* value = BuildFloat64RoundDown(input);
6397 Node* temp1 = __ Float64Sub(input, value);
6399 Node* const half = __ Float64Constant(0.5);
6400 Node* check0 = __ Float64LessThan(temp1, half);
6403 Node* const one = __ Float64Constant(1.0);
6404 Node* check1 = __ Float64LessThan(half, temp1);
6409 Node* temp2 = __ Float64Mod(value, __ Float64Constant(2.0));
6410 Node* check2 = __ Float64Equal(temp2, __ Float64Constant(0.0));
6418 Node* EffectControlLinearizer::BuildFloat64RoundTruncate(Node* input) {
6455 Node* const zero = __ Float64Constant(0.0);
6456 Node* const two_52 = __ Float64Constant(4503599627370496.0E0);
6457 Node* const one = __ Float64Constant(1.0);
6459 Node* check0 = __ Float64LessThan(zero, input);
6462 Node* check1 = __ Float64LessThanOrEqual(two_52, input);
6465 Node* temp1 = __ Float64Sub(__ Float64Add(two_52, input), two_52);
6476 Node* check1 = __ Float64Equal(input, zero);
6479 Node* const minus_two_52 = __ Float64Constant(-4503599627370496.0E0);
6480 Node* check2 = __ Float64LessThanOrEqual(input, minus_two_52);
6484 Node* const minus_zero = __ Float64Constant(-0.0);
6485 Node* temp1 = __ Float64Sub(minus_zero, input);
6486 Node* temp2 = __ Float64Sub(__ Float64Add(two_52, temp1), two_52);
6487 Node* check3 = __ Float64LessThan(temp1, temp2);
6492 Node* temp3 = done_temp3.PhiAt(0);
6505 Maybe<Node*> EffectControlLinearizer::LowerFloat64RoundTruncate(Node* node) {
6508 return Nothing<Node*>();
6511 Node* const input = node->InputAt(0);
6515 Node* EffectControlLinearizer::LowerFindOrderedHashMapEntry(Node* node) {
6516 Node* table = NodeProperties::GetValueInput(node, 0);
6517 Node* key = NodeProperties::GetValueInput(node, 1);
6532 Node* EffectControlLinearizer::ComputeUnseededHash(Node* value) {
6545 Node* EffectControlLinearizer::LowerFindOrderedHashMapEntryForInt32Key(
6546 Node* node) {
6547 Node* table = NodeProperties::GetValueInput(node, 0);
6548 Node* key = NodeProperties::GetValueInput(node, 1);
6551 Node* hash = ChangeUint32ToUintPtr(ComputeUnseededHash(key));
6553 Node* number_of_buckets = ChangeSmiToIntPtr(__ LoadField(
6556 Node* first_entry = ChangeSmiToIntPtr(__ Load(
6567 Node* entry = loop.PhiAt(0);
6568 Node* check =
6575 Node* candidate_key = __ Load(
6603 Node* next_entry = ChangeSmiToIntPtr(__ Load(
6618 Node* EffectControlLinearizer::LowerDateNow(Node* node) {
6628 Node* EffectControlLinearizer::TruncateWordToInt32(Node* value) {
6635 Node* EffectControlLinearizer::BuildIsStrongReference(Node* value) {
6643 Node* EffectControlLinearizer::MakeWeakForComparison(Node* heap_object) {
6650 Node* EffectControlLinearizer::BuildStrongReferenceFromWeakReference(
6651 Node* maybe_object) {
6657 Node* EffectControlLinearizer::BuildIsWeakReferenceTo(Node* maybe_object,
6658 Node* value) {
6672 Node* EffectControlLinearizer::BuildIsClearedWeakReference(Node* maybe_object) {
6679 Node* EffectControlLinearizer::BuildAllocateBigInt(Node* bitfield,
6680 Node* digit) {
6686 Node* map = __ HeapConstant(factory()->bigint_map());
6688 Node* result = __ Allocate(AllocationType::kYoung,