Lines Matching refs:Node
58 typedef compiler::Node Node;
92 Node* ParameterToWord(Node* value, ParameterMode mode) {
97 Node* WordToParameter(Node* value, ParameterMode mode) {
102 Node* ParameterToTagged(Node* value, ParameterMode mode) {
107 Node* TaggedToParameter(Node* value, ParameterMode mode) {
113 Node* OpName(Node* a, Node* b, ParameterMode mode) { \
135 Node* NoContextConstant();
136 #define HEAP_CONSTANT_ACCESSOR(rootName, name) Node* name##Constant();
140 #define HEAP_CONSTANT_TEST(rootName, name) Node* Is##name(Node* value);
144 Node* HashSeed();
145 Node* StaleRegisterConstant();
147 Node* IntPtrOrSmiConstant(int value, ParameterMode mode);
149 bool IsIntPtrOrSmiConstantZero(Node* test);
152 Node* IntPtrRoundUpToPowerOfTwo32(Node* value);
154 Node* IntPtrMax(Node* left, Node* right);
156 Node* IntPtrMin(Node* left, Node* right);
159 Node* Float64Ceil(Node* x);
160 Node* Float64Floor(Node* x);
161 Node* Float64Round(Node* x);
162 Node* Float64RoundToEven(Node* x);
163 Node* Float64Trunc(Node* x);
166 Node* SmiTag(Node* value);
168 Node* SmiUntag(Node* value);
171 Node* SmiToFloat64(Node* value);
172 Node* SmiFromWord(Node* value) { return SmiTag(value); }
173 Node* SmiFromWord32(Node* value);
174 Node* SmiToWord(Node* value) { return SmiUntag(value); }
175 Node* SmiToWord32(Node* value);
179 Node* SmiOpName(Node* a, Node* b) { \
189 Node* SmiShl(Node* a, int shift) {
193 Node* SmiShr(Node* a, int shift) {
199 Node* WordOrSmiShl(Node* a, int shift, ParameterMode mode) {
208 Node* WordOrSmiShr(Node* a, int shift, ParameterMode mode) {
218 Node* SmiOpName(Node* a, Node* b) { \
231 Node* SmiMax(Node* a, Node* b);
232 Node* SmiMin(Node* a, Node* b);
234 Node* SmiMod(Node* a, Node* b);
236 Node* SmiMul(Node* a, Node* b);
239 Node* NumberInc(Node* value);
240 void GotoIfNotNumber(Node* value, Label* is_not_number);
241 void GotoIfNumber(Node* value, Label* is_number);
244 Node* Allocate(Node* size, AllocationFlags flags = kNone);
245 Node* Allocate(int size, AllocationFlags flags = kNone);
246 Node* InnerAllocate(Node* previous, int offset);
247 Node* InnerAllocate(Node* previous, Node* offset);
248 Node* IsRegularHeapObjectSize(Node* size);
250 typedef std::function<Node*()> NodeGenerator;
255 Node* Select(Node* condition, const NodeGenerator& true_body,
258 Node* SelectConstant(Node* condition, Node* true_value, Node* false_value,
261 Node* SelectInt32Constant(Node* condition, int true_value, int false_value);
262 Node* SelectIntPtrConstant(Node* condition, int true_value, int false_value);
263 Node* SelectBooleanConstant(Node* condition);
264 Node* SelectTaggedConstant(Node* condition, Node* true_value,
265 Node* false_value);
266 Node* SelectSmiConstant(Node* condition, Smi* true_value, Smi* false_value);
267 Node* SelectSmiConstant(Node* condition, int true_value, Smi* false_value) {
270 Node* SelectSmiConstant(Node* condition, Smi* true_value, int false_value) {
273 Node* SelectSmiConstant(Node* condition, int true_value, int false_value) {
278 Node* TruncateWordToWord32(Node* value);
281 Node* TaggedIsSmi(Node* a);
282 Node* TaggedIsNotSmi(Node* a);
284 Node* TaggedIsPositiveSmi(Node* a);
286 Node* WordIsWordAligned(Node* word);
287 Node* WordIsPowerOfTwo(Node* value);
289 void BranchIfSmiEqual(Node* a, Node* b, Label* if_true, Label* if_false) {
293 void BranchIfSmiLessThan(Node* a, Node* b, Label* if_true, Label* if_false) {
297 void BranchIfSmiLessThanOrEqual(Node* a, Node* b, Label* if_true,
302 void BranchIfFloat64IsNaN(Node* value, Label* if_true, Label* if_false) {
308 void BranchIfToBooleanIsTrue(Node* value, Label* if_true, Label* if_false);
310 void BranchIfJSReceiver(Node* object, Label* if_true, Label* if_false);
311 void BranchIfJSObject(Node* object, Label* if_true, Label* if_false);
314 void BranchIfFastJSArray(Node* object, Node* context,
319 Node* LoadFromFrame(int offset, MachineType rep = MachineType::AnyTagged());
321 Node* LoadFromParentFrame(int offset,
325 Node* LoadBufferObject(Node* buffer, int offset,
328 Node* LoadObjectField(Node* object, int offset,
330 Node* LoadObjectField(Node* object, Node* offset,
333 Node* LoadAndUntagObjectField(Node* object, int offset);
335 Node* LoadAndUntagToWord32ObjectField(Node* object, int offset);
337 Node* LoadAndUntagSmi(Node* base, int index);
339 Node* LoadAndUntagToWord32Root(Heap::RootListIndex root_index);
342 Node* StoreAndTagSmi(Node* base, int offset, Node* value);
345 Node* LoadHeapNumberValue(Node* object);
347 Node* LoadMap(Node* object);
349 Node* LoadInstanceType(Node* object);
351 Node* HasInstanceType(Node* object, InstanceType type);
352 Node* DoesntHaveInstanceType(Node* object, InstanceType type);
354 Node* LoadProperties(Node* object);
356 Node* LoadElements(Node* object);
358 Node* LoadJSArrayLength(Node* array);
360 Node* LoadFixedArrayBaseLength(Node* array);
362 Node* LoadAndUntagFixedArrayBaseLength(Node* array);
364 Node* LoadMapBitField(Node* map);
366 Node* LoadMapBitField2(Node* map);
368 Node* LoadMapBitField3(Node* map);
370 Node* LoadMapInstanceType(Node* map);
372 Node* LoadMapElementsKind(Node* map);
374 Node* LoadMapDescriptors(Node* map);
376 Node* LoadMapPrototype(Node* map);
379 Node* LoadMapPrototypeInfo(Node* map, Label* if_has_no_proto_info);
381 Node* LoadMapInstanceSize(Node* map);
383 Node* LoadMapInobjectProperties(Node* map);
385 Node* LoadMapConstructorFunctionIndex(Node* map);
387 Node* LoadMapConstructor(Node* map);
393 Node* LoadSharedFunctionInfoSpecialField(Node* shared, int offset,
397 Node* IsDictionaryMap(Node* map);
400 Node* LoadNameHashField(Node* name);
404 Node* LoadNameHash(Node* name, Label* if_hash_not_computed = nullptr);
407 Node* LoadStringLength(Node* object);
409 Node* LoadJSValueValue(Node* object);
411 Node* LoadWeakCellValueUnchecked(Node* weak_cell);
412 Node* LoadWeakCellValue(Node* weak_cell, Label* if_cleared = nullptr);
415 Node* LoadFixedArrayElement(Node* object, Node* index,
418 Node* LoadFixedArrayElement(Node* object, int index,
424 Node* LoadAndUntagToWord32FixedArrayElement(
425 Node* object, Node* index, int additional_offset = 0,
428 Node* LoadFixedDoubleArrayElement(
429 Node* object, Node* index, MachineType machine_type,
437 Node* LoadDoubleWithHoleCheck(
438 Node* base, Node* offset, Label* if_hole,
440 Node* LoadFixedTypedArrayElement(
441 Node* data_pointer, Node* index_node, ElementsKind elements_kind,
445 Node* LoadContextElement(Node* context, int slot_index);
446 Node* LoadContextElement(Node* context, Node* slot_index);
447 Node* StoreContextElement(Node* context, int slot_index, Node* value);
448 Node* StoreContextElement(Node* context, Node* slot_index, Node* value);
449 Node* StoreContextElementNoWriteBarrier(Node* context, int slot_index,
450 Node* value);
451 Node* LoadNativeContext(Node* context);
453 Node* LoadJSArrayElementsMap(ElementsKind kind, Node* native_context);
456 Node* StoreHeapNumberValue(Node* object, Node* value);
458 Node* StoreObjectField(Node* object, int offset, Node* value);
459 Node* StoreObjectField(Node* object, Node* offset, Node* value);
460 Node* StoreObjectFieldNoWriteBarrier(
461 Node* object, int offset, Node* value,
463 Node* StoreObjectFieldNoWriteBarrier(
464 Node* object, Node* offset, Node* value,
467 Node* StoreMap(Node* object, Node* map);
468 Node* StoreMapNoWriteBarrier(Node* object,
470 Node* StoreMapNoWriteBarrier(Node* object, Node* map);
471 Node* StoreObjectFieldRoot(Node* object, int offset,
474 Node* StoreFixedArrayElement(
475 Node* object, int index, Node* value,
481 Node* StoreFixedArrayElement(
482 Node* object, Node* index, Node* value,
487 Node* StoreFixedDoubleArrayElement(
488 Node* object, Node* index, Node* value,
491 Node* BuildAppendJSArray(ElementsKind kind, Node* context, Node* array,
495 void StoreFieldsNoWriteBarrier(Node* start_address, Node* end_address,
496 Node* value);
499 Node* AllocateHeapNumber(MutableMode mode = IMMUTABLE);
501 Node* AllocateHeapNumberWithValue(Node* value, MutableMode mode = IMMUTABLE);
503 Node* AllocateSeqOneByteString(int length, AllocationFlags flags = kNone);
504 Node* AllocateSeqOneByteString(Node* context, Node* length,
508 Node* AllocateSeqTwoByteString(int length, AllocationFlags flags = kNone);
509 Node* AllocateSeqTwoByteString(Node* context, Node* length,
515 Node* AllocateSlicedOneByteString(Node* length, Node* parent, Node* offset);
518 Node* AllocateSlicedTwoByteString(Node* length, Node* parent, Node* offset);
523 Node* AllocateOneByteConsString(Node* length, Node* first, Node* second,
528 Node* AllocateTwoByteConsString(Node* length, Node* first, Node* second,
533 Node* NewConsString(Node* context, Node* length, Node* left, Node* right,
540 Node* AllocateRegExpResult(Node* context, Node* length, Node* index,
541 Node* input);
543 Node* AllocateNameDictionary(int capacity);
544 Node* AllocateNameDictionary(Node* capacity);
546 Node* AllocateJSObjectFromMap(Node* map, Node* properties = nullptr,
547 Node* elements = nullptr,
550 void InitializeJSObjectFromMap(Node* object, Node* map, Node* size,
551 Node* properties = nullptr,
552 Node* elements = nullptr);
554 void InitializeJSObjectBody(Node* object, Node* map, Node* size,
558 Node* AllocateUninitializedJSArrayWithoutElements(ElementsKind kind,
559 Node* array_map,
560 Node* length,
561 Node* allocation_site);
565 std::pair<Node*, Node*> AllocateUninitializedJSArrayWithElements(
566 ElementsKind kind, Node* array_map, Node* length, Node* allocation_site,
567 Node* capacity, ParameterMode capacity_mode = INTPTR_PARAMETERS);
570 Node* AllocateJSArray(ElementsKind kind, Node* array_map, Node* capacity,
571 Node* length, Node* allocation_site = nullptr,
574 Node* AllocateFixedArray(ElementsKind kind, Node* capacity,
579 Node* CreateArrayIterator(Node* array, Node* array_map, Node* array_type,
580 Node* context, IterationKind mode);
582 Node* AllocateJSArrayIterator(Node* array, Node* array_map, Node* map);
584 void FillFixedArrayWithValue(ElementsKind kind, Node* array, Node* from_index,
585 Node* to_index,
592 ElementsKind kind, Node* from_array, Node* to_array, Node* length,
602 ElementsKind from_kind, Node* from_array, ElementsKind to_kind,
603 Node* to_array, Node* element_count, Node* capacity,
615 void CopyStringCharacters(Node* from_string, Node* to_string,
616 Node* from_index, Node* to_index,
617 Node* character_count,
625 Node* LoadElementAndPrepareForStore(Node* array, Node* offset,
629 Node* CalculateNewElementsCapacity(Node* old_capacity,
634 Node* TryGrowElementsCapacity(Node* object, Node* elements, ElementsKind kind,
635 Node* key, Label* bailout);
640 Node* TryGrowElementsCapacity(Node* object, Node* elements, ElementsKind kind,
641 Node* key, Node* capacity, ParameterMode mode,
645 Node* GrowElementsCapacity(Node* object, Node* elements,
647 Node* capacity, Node* new_capacity,
651 void InitializeAllocationMemento(Node* base_allocation,
653 Node* allocation_site);
655 Node* TryTaggedToFloat64(Node* value, Label* if_valueisnotnumber);
656 Node* TruncateTaggedToFloat64(Node* context, Node* value);
657 Node* TruncateTaggedToWord32(Node* context, Node* value);
659 Node* TruncateHeapNumberValueToWord32(Node* object);
662 Node* ChangeFloat64ToTagged(Node* value);
663 Node* ChangeInt32ToTagged(Node* value);
664 Node* ChangeUint32ToTagged(Node* value);
665 Node* ChangeNumberToFloat64(Node* value);
670 Node* ToThisString(Node* context, Node* value, char const* method_name);
674 Node* ToThisValue(Node* context, Node* value, PrimitiveType primitive_type,
679 Node* ThrowIfNotInstanceType(Node* context, Node* value,
686 Node* InstanceTypeEqual(Node* instance_type, int type);
687 Node* IsSpecialReceiverMap(Node* map);
688 Node* IsSpecialReceiverInstanceType(Node* instance_type);
689 Node* IsStringInstanceType(Node* instance_type);
690 Node* IsString(Node* object);
691 Node* IsJSObject(Node* object);
692 Node* IsJSGlobalProxy(Node* object);
693 Node* IsJSReceiverInstanceType(Node* instance_type);
694 Node* IsJSReceiver(Node* object);
695 Node* IsJSReceiverMap(Node* map);
696 Node* IsMap(Node* object);
697 Node* IsCallableMap(Node* map);
698 Node* IsCallable(Node* object);
699 Node* IsBoolean(Node* object);
700 Node* IsHeapNumber(Node* object);
701 Node* IsName(Node* object);
702 Node* IsSymbol(Node* object);
703 Node* IsPrivateSymbol(Node* object);
704 Node* IsJSValue(Node* object);
705 Node* IsJSArray(Node* object);
706 Node* IsNativeContext(Node* object);
707 Node* IsWeakCell(Node* object);
708 Node* IsFixedDoubleArray(Node* object);
709 Node* IsHashTable(Node* object);
710 Node* IsDictionary(Node* object);
711 Node* IsUnseededNumberDictionary(Node* object);
712 Node* IsConstructorMap(Node* map);
713 Node* IsJSFunction(Node* object);
716 Node* IsFastElementsKind(Node* elements_kind);
717 Node* IsHoleyFastElementsKind(Node* elements_kind);
721 Node* StringCharCodeAt(Node* string, Node* index,
724 Node* StringFromCharCode(Node* code);
727 Node* SubString(Node* context, Node* string, Node* from, Node* to);
730 Node* StringAdd(Node* context, Node* first, Node* second,
740 Node* TryDerefExternalString(Node* const string, Node* const instance_type,
745 void MaybeDerefIndirectString(Variable* var_string, Node* instance_type,
749 void MaybeDerefIndirectStrings(Variable* var_left, Node* left_instance_type,
750 Variable* var_right, Node* right_instance_type,
753 Node* StringFromCodePoint(Node* codepoint, UnicodeEncoding encoding);
757 Node* StringToNumber(Node* context, Node* input);
758 Node* NumberToString(Node* context, Node* input);
760 Node* ToName(Node* context, Node* input);
762 Node* NonNumberToNumber(Node* context, Node* input);
764 Node* ToNumber(Node* context, Node* input);
769 compiler::Node* ToUint32(compiler::Node* context, compiler::Node* input);
772 Node* ToString(Node* context, Node* input);
775 Node* JSReceiverToPrimitive(Node* context, Node* input);
783 Node* ToInteger(Node* context, Node* input,
786 // Returns a node that contains a decoded (unsigned!) value of a bit
787 // field |T| in |word32|. Returns result as an uint32 node.
789 Node* DecodeWord32(Node* word32) {
793 // Returns a node that contains a decoded (unsigned!) value of a bit
794 // field |T| in |word|. Returns result as a word-size node.
796 Node* DecodeWord(Node* word) {
800 // Returns a node that contains a decoded (unsigned!) value of a bit
801 // field |T| in |word32|. Returns result as a word-size node.
803 Node* DecodeWordFromWord32(Node* word32) {
807 // Returns a node that contains a decoded (unsigned!) value of a bit
808 // field |T| in |word|. Returns result as an uint32 node.
810 Node* DecodeWord32FromWord(Node* word) {
814 // Decodes an unsigned (!) value from |word32| to an uint32 node.
815 Node* DecodeWord32(Node* word32, uint32_t shift, uint32_t mask);
817 // Decodes an unsigned (!) value from |word| to a word-size node.
818 Node* DecodeWord(Node* word, uint32_t shift, uint32_t mask);
822 Node* IsSetWord32(Node* word32) {
827 Node* IsSetWord32(Node* word32, uint32_t mask) {
834 Node* IsSetWord(Node* word) {
839 Node* IsSetWord(Node* word, uint32_t mask) {
845 Node* IsSetSmi(Node* smi, int untagged_mask) {
854 Node* IsClearWord32(Node* word32) {
859 Node* IsClearWord32(Node* word32, uint32_t mask) {
866 Node* IsClearWord(Node* word) {
871 Node* IsClearWord(Node* word, uint32_t mask) {
888 void TryToName(Node* key, Label* if_keyisindex, Variable* var_index,
895 Node* EntryToIndex(Node* entry, int field_index);
897 Node* EntryToIndex(Node* entry) {
904 Node* LoadDetailsByKeyIndex(Node* container, Node* key_index) {
915 Node* LoadValueByKeyIndex(Node* container, Node* key_index) {
925 void StoreDetailsByKeyIndex(Node* container, Node* key_index, Node* details) {
935 void StoreValueByKeyIndex(Node* container, Node* key_index, Node* value) {
944 Node* HashTableComputeCapacity(Node* at_least_space_for);
947 Node* GetNumberOfElements(Node* dictionary);
950 void SetNumberOfElements(Node* dictionary, Node* num_elements_smi);
953 Node* GetNumberOfDeletedElements(Node* dictionary);
956 Node* GetCapacity(Node* dictionary);
959 Node* GetNextEnumerationIndex(Node* dictionary);
962 void SetNextEnumerationIndex(Node* dictionary, Node* next_enum_index_smi);
971 void NameDictionaryLookup(Node* dictionary, Node* unique_name,
977 Node* ComputeIntegerHash(Node* key, Node* seed);
980 void NumberDictionaryLookup(Node* dictionary, Node* intptr_index,
985 void FindInsertionEntry(Node* dictionary, Node* key, Variable* var_key_index);
988 void InsertEntry(Node* dictionary, Node* key, Node* value, Node* index,
989 Node* enum_index);
992 void Add(Node* dictionary, Node* key, Node* value, Label* bailout);
995 void TryHasOwnProperty(Node* object, Node* map, Node* instance_type,
996 Node* unique_name, Label* if_found,
1002 void TryGetOwnProperty(Node* context, Node* receiver, Node* object, Node* map,
1003 Node* instance_type, Node* unique_name,
1007 Node* GetProperty(Node* context, Node* receiver, Handle<Name> name) {
1012 void LoadPropertyFromFastObject(Node* object, Node* map, Node* descriptors,
1013 Node* name_index, Variable* var_details,
1016 void LoadPropertyFromNameDictionary(Node* dictionary, Node* entry,
1020 void LoadPropertyFromGlobalDictionary(Node* dictionary, Node* entry,
1036 void TryLookupProperty(Node* object, Node* map, Node* instance_type,
1037 Node* unique_name, Label* if_found_fast,
1042 void TryLookupElement(Node* object, Node* map, Node* instance_type,
1043 Node* intptr_index, Label* if_found,
1049 typedef std::function<void(Node* receiver, Node* holder, Node* map,
1050 Node* instance_type, Node* key, Label* next_holder,
1060 void TryPrototypeChainLookup(Node* receiver, Node* key,
1067 Node* OrdinaryHasInstance(Node* context, Node* callable, Node* object);
1070 Node* LoadFeedbackVectorForStub();
1073 void UpdateFeedback(Node* feedback, Node* feedback_vector, Node* slot_id);
1075 Node* LoadReceiverMap(Node* receiver);
1078 Node* LoadKeyedSloppyArguments(Node* receiver, Node* key, Label* bailout) {
1083 void StoreKeyedSloppyArguments(Node* receiver, Node* key, Node* value,
1090 Node* LoadScriptContext(Node* context, int context_index);
1092 Node* Int32ToUint8Clamped(Node* int32_value);
1093 Node* Float64ToUint8Clamped(Node* float64_value);
1095 Node* PrepareValueForWriteToTypedArray(Node* key, ElementsKind elements_kind,
1099 void StoreElement(Node* elements, ElementsKind kind, Node* index, Node* value,
1102 void EmitElementStore(Node* object, Node* key, Node* value, bool is_jsarray,
1106 NodeNode* object, Node* elements, ElementsKind kind,
1107 Node* length, Node* key, ParameterMode mode,
1110 Node* CopyElementsOnWrite(Node* object, Node* elements, ElementsKind kind,
1111 Node* length, ParameterMode mode, Label* bailout);
1113 void TransitionElementsKind(Node* object, Node* map, ElementsKind from_kind,
1117 void TrapAllocationMemento(Node* object, Label* memento_found);
1119 Node* PageFromAddress(Node* address);
1122 Node* EnumLength(Node* map);
1126 void CheckEnumCache(Node* receiver, CodeStubAssembler::Label* use_cache,
1131 Node* CreateWeakCellInFeedbackVector(Node* feedback_vector, Node* slot,
1132 Node* value);
1135 Node* CreateAllocationSiteInFeedbackVector(Node* feedback_vector, Node* slot);
1139 typedef std::function<void(Node* index)> FastLoopBody;
1141 Node* BuildFastLoop(const VariableList& var_list, Node* start_index,
1142 Node* end_index, const FastLoopBody& body, int increment,
1146 Node* BuildFastLoop(Node* start_index, Node* end_index,
1156 typedef std::function<void(Node* fixed_array, Node* offset)>
1160 const CodeStubAssembler::VariableList& vars, Node* fixed_array,
1161 ElementsKind kind, Node* first_element_inclusive,
1162 Node* last_element_exclusive, const FastFixedArrayForEachBody& body,
1167 Node* fixed_array, ElementsKind kind, Node* first_element_inclusive,
1168 Node* last_element_exclusive, const FastFixedArrayForEachBody& body,
1176 Node* GetArrayAllocationSize(Node* element_count, ElementsKind kind,
1181 Node* GetFixedArrayAllocationSize(Node* element_count, ElementsKind kind,
1187 void GotoIfFixedArraySizeDoesntFitInNewSpace(Node* element_count,
1191 void InitializeFieldsWithRoot(Node* object, Node* start_offset,
1192 Node* end_offset, Heap::RootListIndex root);
1201 Node* RelationalComparison(RelationalComparisonMode mode, Node* lhs,
1202 Node* rhs, Node* context);
1205 Node* lhs, Node* rhs, Label* if_true,
1208 void GotoUnlessNumberLessThan(Node* lhs, Node* rhs, Label* if_false);
1212 Node* Equal(ResultMode mode, Node* lhs, Node* rhs, Node* context);
1214 Node* StrictEqual(ResultMode mode, Node* lhs, Node* rhs, Node* context);
1221 Node* SameValue(Node* lhs, Node* rhs, Node* context);
1223 Node* HasProperty(
1224 Node* object, Node* key, Node* context,
1226 Node* ForInFilter(Node* key, Node* object, Node* context);
1228 Node* ClassOf(Node* object);
1230 Node* Typeof(Node* value, Node* context);
1232 Node* GetSuperConstructor(Node* value, Node* context);
1234 Node* InstanceOf(Node* object, Node* callable, Node* context);
1237 Node* IsDebugActive();
1240 Node* IsDetachedBuffer(Node* buffer);
1242 Node* ElementOffsetFromIndex(Node* index, ElementsKind kind,
1245 Node* AllocateFunctionWithMapAndContext(Node* map, Node* shared_info,
1246 Node* context);
1249 Node* IsPromiseHookEnabledOrDebugIsActive();
1251 Node* AllocatePromiseReactionJobInfo(Node* value, Node* tasks,
1252 Node* deferred_promise,
1253 Node* deferred_on_resolve,
1254 Node* deferred_on_reject, Node* context);
1257 Node* MarkerIsFrameType(Node* marker_or_function,
1259 Node* MarkerIsNotFrameType(Node* marker_or_function,
1264 void Print(const char* prefix, Node* tagged_value);
1265 inline void Print(Node* tagged_value) { return Print(nullptr, tagged_value); }
1268 Node* MakeTypeError(MessageTemplate::Template message, Node* context,
1271 Node* const make_type_error = LoadContextElement(
1278 void DescriptorLookup(Node* unique_name, Node* descriptors, Node* bitfield3,
1281 void DescriptorLookupLinear(Node* unique_name, Node* descriptors, Node* nof,
1284 void DescriptorLookupBinary(Node* unique_name, Node* descriptors, Node* nof,
1288 Node* CallGetterIfAccessor(Node* value, Node* details, Node* context,
1289 Node* receiver, Label* if_bailout);
1291 Node* TryToIntptr(Node* key, Label* miss);
1293 void BranchIfPrototypesHaveNoElements(Node* receiver_map,
1302 Node* AllocateRawAligned(Node* size_in_bytes, AllocationFlags flags,
1303 Node* top_address, Node* limit_address);
1304 Node* AllocateRawUnaligned(Node* size_in_bytes, AllocationFlags flags,
1305 Node* top_adddress, Node* limit_address);
1308 Node* AllocateUninitializedJSArray(ElementsKind kind, Node* array_map,
1309 Node* length, Node* allocation_site,
1310 Node* size_in_bytes);
1312 Node* SmiShiftBitsConstant();
1316 Node* EmitKeyedSloppyArguments(Node* receiver, Node* key, Node* value,
1319 Node* AllocateSlicedString(Heap::RootListIndex map_root_index, Node* length,
1320 Node* parent, Node* offset);
1322 Node* AllocateConsString(Heap::RootListIndex map_root_index, Node* length,
1323 Node* first, Node* second, AllocationFlags flags);
1327 Node* DescriptorArrayNumberOfEntries(Node* descriptors);
1330 Node* DescriptorArrayToKeyIndex(Node* descriptor_number);
1333 Node* DescriptorArrayGetSortedKeyIndex(Node* descriptors,
1334 Node* descriptor_number);
1336 Node* DescriptorArrayGetKey(Node* descriptors, Node* descriptor_number);
1343 typedef compiler::Node Node;
1347 CodeStubArguments(CodeStubAssembler* assembler, Node* argc)
1350 CodeStubArguments(CodeStubAssembler* assembler, Node* argc, Node* fp,
1353 Node* GetReceiver() const;
1355 Node* AtIndexPtr(Node* index, CodeStubAssembler::ParameterMode mode =
1359 Node* AtIndex(Node* index, CodeStubAssembler::ParameterMode mode =
1362 Node* AtIndex(int index) const;
1364 Node* GetLength() const { return argc_; }
1366 typedef std::function<void(Node* arg)> ForEachBodyFunction;
1369 void ForEach(const ForEachBodyFunction& body, Node* first = nullptr,
1370 Node* last = nullptr, CodeStubAssembler::ParameterMode mode =
1378 const ForEachBodyFunction& body, Node* first = nullptr,
1379 Node* last = nullptr, CodeStubAssembler::ParameterMode mode =
1382 void PopAndReturn(Node* value);
1385 Node* GetArguments();
1389 Node* argc_;
1390 Node* arguments_;
1391 Node* fp_;
1403 compiler::Node* const argc = (csa)->Parameter(argc_index); \
