Lines Matching refs:Node
18 using compiler::Node;
22 Node* AccessorAssembler::TryMonomorphicCase(Node* slot, Node* vector,
23 Node* receiver_map,
36 Node* offset =
38 Node* feedback = Load(MachineType::AnyTagged(), vector,
47 Node* handler =
56 void AccessorAssembler::HandlePolymorphicCase(Node* receiver_map,
57 Node* feedback, Label* if_handler,
69 Node* cached_map =
74 Node* handler = LoadFixedArrayElement(feedback, i * kEntrySize + 1);
82 Node* init = IntPtrConstant(unroll_count * kEntrySize);
83 Node* length = LoadAndUntagFixedArrayBaseLength(feedback);
86 [this, receiver_map, feedback, if_handler, var_handler](Node* index) {
87 Node* cached_map =
94 Node* handler = LoadFixedArrayElement(feedback, index, kPointerSize);
106 Node* receiver_map, Node* feedback, Label* if_handler,
114 Node* init = IntPtrConstant(0);
115 Node* length = LoadAndUntagFixedArrayBaseLength(feedback);
118 if_transition_handler, var_transition_map_cell](Node* index) {
119 Node* cached_map =
124 Node* maybe_transition_map_cell =
143 const LoadICParameters* p, Node* handler, Label* miss,
183 const LoadICParameters* p, Node* holder, Node* smi_handler, Label* miss,
188 Node* handler_word = SmiUntag(smi_handler);
189 Node* handler_kind = DecodeWord<LoadHandler::KindBits>(handler_word);
197 Node* intptr_index = TryToIntptr(p->name, miss);
198 Node* elements = LoadElements(holder);
199 Node* is_jsarray_condition =
201 Node* elements_kind =
222 Node* protector_cell = LoadRoot(Heap::kArrayProtectorRootIndex);
242 Node* offset = DecodeWord<LoadHandler::FieldOffsetBits>(handler_word);
259 Node* mutable_heap_number = LoadObjectField(holder, offset);
268 Node* properties = LoadProperties(holder);
269 Node* value = LoadObjectField(properties, offset);
285 Node* descriptors = LoadMapDescriptors(LoadMap(holder));
286 Node* descriptor =
291 Node* value = LoadFixedArrayElement(descriptors, descriptor);
306 const LoadICParameters* p, Node* handler, Variable* var_holder,
321 Node* validity_cell =
325 Node* cell_value = LoadObjectField(validity_cell, Cell::kValueOffset);
332 Node* smi_handler = LoadObjectField(handler, LoadHandler::kSmiHandlerOffset);
334 Node* handler_flags = SmiUntag(smi_handler);
349 Node* maybe_holder_cell =
367 Node* holder = LoadWeakCellValue(maybe_holder_cell);
386 Node* AccessorAssembler::EmitLoadICProtoArrayCheck(
387 const LoadICParameters* p, Node* handler, Node* handler_length,
388 Node* handler_flags, Label* miss,
402 Node* expected_native_context =
406 Node* native_context = LoadNativeContext(p->context);
412 Node* expected_token = LoadContextElement(expected_native_context,
414 Node* current_token =
421 [this, p, handler, miss](Node* current) {
422 Node* prototype_cell =
428 Node* maybe_holder_cell =
440 Node* holder = LoadWeakCellValue(maybe_holder_cell);
449 const LoadICParameters* pp, Node* handler, Label* miss,
453 Node* native_context = LoadNativeContext(p.context);
468 const StoreICParameters* p, Node* handler, Label* miss,
479 Node* holder = p->receiver;
480 Node* handler_word = SmiUntag(handler);
488 Node* handler_map = LoadMap(handler);
515 const StoreICParameters* p, Node* handler, Label* miss) {
517 Node* validity_cell = LoadObjectField(handler, Tuple2::kValue1Offset);
518 Node* cell_value = LoadObjectField(validity_cell, Cell::kValueOffset);
523 Node* code_handler = LoadObjectField(handler, Tuple2::kValue2Offset);
532 Node* handler, Label* miss) {
543 Node* validity_cell =
547 Node* cell_value = LoadObjectField(validity_cell, Cell::kValueOffset);
554 Node* smi_handler = LoadObjectField(handler, StoreHandler::kSmiHandlerOffset);
557 Node* maybe_transition_cell =
566 Node* transition = LoadWeakCellValue(maybe_transition_cell, miss);
573 Node* length = SmiUntag(maybe_transition_cell);
575 [this, p, handler, miss](Node* current) {
576 Node* prototype_cell =
582 Node* maybe_transition_cell =
584 Node* transition = LoadWeakCellValue(maybe_transition_cell, miss);
591 Node* holder = p->receiver;
592 Node* transition = var_transition.value();
593 Node* handler_word = SmiUntag(smi_handler);
597 Node* handler_kind = DecodeWord<StoreHandler::KindBits>(handler_word);
609 Node* value_index_in_descriptor =
611 Node* descriptors = LoadMapDescriptors(transition);
612 Node* constant =
622 void AccessorAssembler::HandleStoreICSmiHandlerCase(Node* handler_word,
623 Node* holder, Node* value,
624 Node* transition,
629 Node* handler_kind = DecodeWord<StoreHandler::KindBits>(handler_word);
653 Node* field_representation =
700 void AccessorAssembler::HandleStoreFieldAndReturn(Node* handler_word,
701 Node* holder,
703 Node* value, Node* transition,
706 Node* prepared_value = PrepareValueForStore(
746 Node* AccessorAssembler::PrepareValueForStore(Node* handler_word, Node* holder,
748 Node* transition, Node* value,
764 Node* value_index_in_descriptor =
766 Node* descriptors =
768 Node* maybe_field_type =
774 Node* field_type = LoadWeakCellValue(maybe_field_type, bailout);
788 void AccessorAssembler::ExtendPropertiesBackingStore(Node* object) {
789 Node* properties = LoadProperties(object);
790 Node* length = LoadFixedArrayBaseLength(properties);
795 Node* delta = IntPtrOrSmiConstant(JSObject::kFieldsAdded, mode);
796 Node* new_capacity = IntPtrOrSmiAdd(length, delta, mode);
811 Node* new_properties = AllocateFixedArray(kind, new_capacity, mode);
824 void AccessorAssembler::StoreNamedField(Node* handler_word, Node* object,
827 Node* value, bool transition_to_field,
830 Node* property_storage = object;
835 Node* offset = DecodeWord<StoreHandler::FieldOffsetBits>(handler_word);
839 Node* heap_number = AllocateHeapNumberWithValue(value, MUTABLE);
860 Node* current_value =
864 Node* current_value = LoadObjectField(property_storage, offset);
883 void AccessorAssembler::EmitFastElementsBoundsCheck(Node* object,
884 Node* elements,
885 Node* intptr_index,
886 Node* is_jsarray_condition,
906 Node* object, Node* elements, Node* elements_kind, Node* intptr_index,
907 Node* is_jsarray_condition, Label* if_hole, Label* rebox_double,
947 Node* element = LoadFixedArrayElement(elements, intptr_index);
963 Node* value = LoadFixedDoubleArrayElement(elements, intptr_index,
992 Node* index = EntryToIndex<SeededNumberDictionary>(var_entry.value());
993 Node* details =
995 Node* kind = DecodeWord32<PropertyDetails::KindField>(details);
1007 Node* buffer = LoadObjectField(object, JSArrayBufferView::kBufferOffset);
1011 Node* length =
1016 Node* external_pointer =
1019 Node* base_pointer =
1021 Node* backing_store =
1045 Node* element = Load(MachineType::Uint8(), backing_store, intptr_index);
1051 Node* element = Load(MachineType::Int8(), backing_store, intptr_index);
1057 Node* index = WordShl(intptr_index, IntPtrConstant(1));
1058 Node* element = Load(MachineType::Uint16(), backing_store, index);
1064 Node* index = WordShl(intptr_index, IntPtrConstant(1));
1065 Node* element = Load(MachineType::Int16(), backing_store, index);
1071 Node* index = WordShl(intptr_index, IntPtrConstant(2));
1072 Node* element = Load(MachineType::Uint32(), backing_store, index);
1078 Node* index = WordShl(intptr_index, IntPtrConstant(2));
1079 Node* element = Load(MachineType::Int32(), backing_store, index);
1085 Node* index = WordShl(intptr_index, IntPtrConstant(2));
1086 Node* element = Load(MachineType::Float32(), backing_store, index);
1093 Node* index = WordShl(intptr_index, IntPtrConstant(3));
1094 Node* element = Load(MachineType::Float64(), backing_store, index);
1101 void AccessorAssembler::CheckPrototype(Node* prototype_cell, Node* name,
1103 Node* maybe_prototype = LoadWeakCellValue(prototype_cell, miss);
1123 Node* value = LoadObjectField(maybe_prototype, PropertyCell::kValueOffset);
1131 void AccessorAssembler::NameDictionaryNegativeLookup(Node* object, Node* name,
1134 Node* properties = LoadProperties(object);
1143 void AccessorAssembler::GenericElementLoad(Node* receiver, Node* receiver_map,
1144 Node* instance_type, Node* index,
1156 Node* elements = LoadElements(receiver);
1157 Node* elements_kind = LoadMapElementsKind(receiver_map);
1158 Node* is_jsarray_condition =
1194 void AccessorAssembler::GenericPropertyLoad(Node* receiver, Node* receiver_map,
1195 Node* instance_type, Node* key,
1211 Node* properties = LoadProperties(receiver);
1212 Node* properties_map = LoadMap(properties);
1218 Node* bitfield3 = LoadMapBitField3(receiver_map);
1219 Node* descriptors = LoadMapDescriptors(receiver_map);
1275 Node* value = CallGetterIfAccessor(var_value.value(), var_details.value(),
1300 Node* proto = LoadMapPrototype(var_holder_map.value());
1302 Node* proto_map = LoadMap(proto);
1303 Node* proto_instance_type = LoadMapInstanceType(proto_map);
1335 Node* AccessorAssembler::StubCachePrimaryOffset(Node* name, Node* map) {
1339 Node* hash_field = LoadNameHashField(name);
1348 Node* map32 = TruncateWordToWord32(BitcastTaggedToWord(map));
1349 Node* hash = Int32Add(hash_field, map32);
1357 Node* AccessorAssembler::StubCacheSecondaryOffset(Node* name, Node* seed) {
1361 Node* name32 = TruncateWordToWord32(BitcastTaggedToWord(name));
1362 Node* hash = Int32Sub(TruncateWordToWord32(seed), name32);
1371 Node* entry_offset, Node* name,
1372 Node* map, Label* if_handler,
1391 Node* key_base =
1393 Node* entry_key = Load(MachineType::Pointer(), key_base, entry_offset);
1399 Node* entry_map =
1406 Node* handler = Load(MachineType::TaggedPointer(), key_base,
1414 void AccessorAssembler::TryProbeStubCache(StubCache* stub_cache, Node* receiver,
1415 Node* name, Label* if_handler,
1426 Node* receiver_map = LoadMap(receiver);
1429 Node* primary_offset = StubCachePrimaryOffset(name, receiver_map);
1436 Node* secondary_offset = StubCacheSecondaryOffset(name, primary_offset);
1457 Node* receiver_map = LoadReceiverMap(p->receiver);
1461 Node* feedback =
1494 const LoadICParameters* p, Node* handler,
1502 Node* smi_handler = LoadObjectField(handler, LoadHandler::kSmiHandlerOffset);
1503 Node* handler_flags = SmiUntag(smi_handler);
1505 Node* handler_length = LoadAndUntagFixedArrayBaseLength(handler);
1507 Node* holder =
1522 Node* vector, Node* slot, ExitPoint* exit_point, Label* try_handler,
1526 Node* weak_cell = LoadFixedArrayElement(vector, slot, 0, slot_mode);
1530 Node* property_cell = LoadWeakCellValue(weak_cell, try_handler);
1533 Node* value = LoadObjectField(property_cell, PropertyCell::kValueOffset);
1546 Node* handler =
1560 Node* native_context = LoadNativeContext(p->context);
1561 Node* receiver =
1599 Node* receiver_map = LoadReceiverMap(p->receiver);
1603 Node* feedback =
1636 Node* offset = ElementOffsetFromIndex(
1639 Node* array = Load(MachineType::AnyTagged(), p->vector, offset);
1657 Node* receiver = p->receiver;
1659 Node* receiver_map = LoadMap(receiver);
1660 Node* instance_type = LoadMapInstanceType(receiver_map);
1694 Node* receiver_map = LoadReceiverMap(p->receiver);
1698 Node* feedback =
1746 Node* receiver_map = LoadReceiverMap(p->receiver);
1750 Node* feedback =
1774 Node* handler = var_handler.value();
1784 Node* validity_cell = LoadObjectField(handler, Tuple2::kValue1Offset);
1785 Node* cell_value = LoadObjectField(validity_cell, Cell::kValueOffset);
1797 Node* code_handler = var_code_handler.value();
1800 Node* transition_map =
1828 Node* offset = ElementOffsetFromIndex(
1831 Node* array = Load(MachineType::AnyTagged(), p->vector, offset);
1849 Node* receiver = Parameter(Descriptor::kReceiver);
1850 Node* name = Parameter(Descriptor::kName);
1851 Node* slot = Parameter(Descriptor::kSlot);
1852 Node* vector = Parameter(Descriptor::kVector);
1853 Node* context = Parameter(Descriptor::kContext);
1862 Node* receiver = Parameter(Descriptor::kReceiver);
1863 Node* name = Parameter(Descriptor::kName);
1864 Node* slot = Parameter(Descriptor::kSlot);
1865 Node* context = Parameter(Descriptor::kContext);
1866 Node* vector = LoadFeedbackVectorForStub();
1876 Node* receiver = Parameter(Descriptor::kReceiver);
1877 Node* name = Parameter(Descriptor::kName);
1878 Node* slot = Parameter(Descriptor::kSlot);
1879 Node* vector = Parameter(Descriptor::kVector);
1880 Node* handler = Parameter(Descriptor::kHandler);
1881 Node* context = Parameter(Descriptor::kContext);
1890 Node* receiver = Parameter(Descriptor::kReceiver);
1891 Node* name = nullptr;
1892 Node* slot = nullptr;
1893 Node* vector = nullptr;
1894 Node* context = Parameter(Descriptor::kContext);
1906 Node* name = Parameter(Descriptor::kName);
1907 Node* slot = Parameter(Descriptor::kSlot);
1908 Node* vector = Parameter(Descriptor::kVector);
1909 Node* context = Parameter(Descriptor::kContext);
1918 Node* name = Parameter(Descriptor::kName);
1919 Node* slot = Parameter(Descriptor::kSlot);
1920 Node* context = Parameter(Descriptor::kContext);
1921 Node* vector = LoadFeedbackVectorForStub();
1930 Node* receiver = Parameter(Descriptor::kReceiver);
1931 Node* name = Parameter(Descriptor::kName);
1932 Node* slot = Parameter(Descriptor::kSlot);
1933 Node* vector = Parameter(Descriptor::kVector);
1934 Node* context = Parameter(Descriptor::kContext);
1943 Node* receiver = Parameter(Descriptor::kReceiver);
1944 Node* name = Parameter(Descriptor::kName);
1945 Node* slot = Parameter(Descriptor::kSlot);
1946 Node* context = Parameter(Descriptor::kContext);
1947 Node* vector = LoadFeedbackVectorForStub();
1956 Node* receiver = Parameter(Descriptor::kReceiver);
1957 Node* name = Parameter(Descriptor::kName);
1958 Node* slot = Parameter(Descriptor::kSlot);
1959 Node* vector = Parameter(Descriptor::kVector);
1960 Node* context = Parameter(Descriptor::kContext);
1969 Node* receiver = Parameter(Descriptor::kReceiver);
1970 Node* name = Parameter(Descriptor::kName);
1971 Node* value = Parameter(Descriptor::kValue);
1972 Node* slot = Parameter(Descriptor::kSlot);
1973 Node* vector = Parameter(Descriptor::kVector);
1974 Node* context = Parameter(Descriptor::kContext);
1983 Node* receiver = Parameter(Descriptor::kReceiver);
1984 Node* name = Parameter(Descriptor::kName);
1985 Node* value = Parameter(Descriptor::kValue);
1986 Node* slot = Parameter(Descriptor::kSlot);
1987 Node* context = Parameter(Descriptor::kContext);
1988 Node* vector = LoadFeedbackVectorForStub();
1997 Node* receiver = Parameter(Descriptor::kReceiver);
1998 Node* name = Parameter(Descriptor::kName);
1999 Node* value = Parameter(Descriptor::kValue);
2000 Node* slot = Parameter(Descriptor::kSlot);
2001 Node* vector = Parameter(Descriptor::kVector);
2002 Node* context = Parameter(Descriptor::kContext);
2012 Node* receiver = Parameter(Descriptor::kReceiver);
2013 Node* name = Parameter(Descriptor::kName);
2014 Node* value = Parameter(Descriptor::kValue);
2015 Node* slot = Parameter(Descriptor::kSlot);
2016 Node* context = Parameter(Descriptor::kContext);
2017 Node* vector = LoadFeedbackVectorForStub();
