diff options
Diffstat (limited to 'deps/v8/src/builtins/builtins-collections-gen.cc')
| -rw-r--r-- | deps/v8/src/builtins/builtins-collections-gen.cc | 715 |
1 files changed, 402 insertions, 313 deletions
diff --git a/deps/v8/src/builtins/builtins-collections-gen.cc b/deps/v8/src/builtins/builtins-collections-gen.cc index dec4142c65..c0ca74a577 100644 --- a/deps/v8/src/builtins/builtins-collections-gen.cc +++ b/deps/v8/src/builtins/builtins-collections-gen.cc @@ -8,6 +8,7 @@ #include "src/builtins/builtins-iterator-gen.h" #include "src/builtins/builtins-utils-gen.h" #include "src/codegen/code-stub-assembler.h" +#include "src/execution/protectors.h" #include "src/heap/factory-inl.h" #include "src/heap/heap-inl.h" #include "src/objects/hash-table-inl.h" @@ -19,8 +20,6 @@ namespace internal { using compiler::Node; template <class T> -using TNode = compiler::TNode<T>; -template <class T> using TVariable = compiler::TypedCodeAssemblerVariable<T>; class BaseCollectionsAssembler : public CodeStubAssembler { @@ -81,8 +80,8 @@ class BaseCollectionsAssembler : public CodeStubAssembler { TNode<JSReceiver> new_target); // Allocates the backing store for a collection. - virtual TNode<Object> AllocateTable(Variant variant, TNode<Context> context, - TNode<IntPtrT> at_least_space_for) = 0; + virtual TNode<HeapObject> AllocateTable( + Variant variant, TNode<IntPtrT> at_least_space_for) = 0; // Main entry point for a collection constructor builtin. void GenerateConstructor(Variant variant, @@ -124,7 +123,7 @@ class BaseCollectionsAssembler : public CodeStubAssembler { TNode<IntPtrT> EstimatedInitialSize(TNode<Object> initial_entries, TNode<BoolT> is_fast_jsarray); - void GotoIfNotJSReceiver(Node* const obj, Label* if_not_receiver); + void GotoIfNotJSReceiver(TNode<Object> const obj, Label* if_not_receiver); // Determines whether the collection's prototype has been modified. TNode<BoolT> HasInitialCollectionPrototype(Variant variant, @@ -160,8 +159,8 @@ void BaseCollectionsAssembler::AddConstructorEntry( ? LoadKeyValuePairNoSideEffects(context, key_value, if_may_have_side_effects) : LoadKeyValuePair(context, key_value); - Node* key_n = pair.key; - Node* value_n = pair.value; + TNode<Object> key_n = pair.key; + TNode<Object> value_n = pair.value; CallJS(CodeFactory::Call(isolate()), context, add_function, collection, key_n, value_n); } else { @@ -183,7 +182,7 @@ void BaseCollectionsAssembler::AddConstructorEntries( Goto(&allocate_table); BIND(&allocate_table); { - TNode<Object> table = AllocateTable(variant, context, at_least_space_for); + TNode<HeapObject> table = AllocateTable(variant, at_least_space_for); StoreObjectField(collection, GetTableOffset(variant), table); GotoIf(IsNullOrUndefined(initial_entries), &exit); GotoIfInitialAddFunctionModified(variant, CAST(native_context), @@ -261,7 +260,7 @@ void BaseCollectionsAssembler::AddConstructorEntriesFromFastJSArray( &if_doubles); BIND(&if_smiorobjects); { - auto set_entry = [&](Node* index) { + auto set_entry = [&](TNode<IntPtrT> index) { TNode<Object> element = LoadAndNormalizeFixedArrayElement( CAST(elements), UncheckedCast<IntPtrT>(index)); AddConstructorEntry(variant, context, collection, add_func, element, @@ -272,8 +271,8 @@ void BaseCollectionsAssembler::AddConstructorEntriesFromFastJSArray( // elements, a fast loop is used. This assumes that adding an element // to the collection does not call user code that could mutate the elements // or collection. - BuildFastLoop(IntPtrConstant(0), length, set_entry, 1, - ParameterMode::INTPTR_PARAMETERS, IndexAdvanceMode::kPost); + BuildFastLoop<IntPtrT>(IntPtrConstant(0), length, set_entry, 1, + IndexAdvanceMode::kPost); Goto(&exit); } BIND(&if_doubles); @@ -288,13 +287,13 @@ void BaseCollectionsAssembler::AddConstructorEntriesFromFastJSArray( element); } else { DCHECK(variant == kSet || variant == kWeakSet); - auto set_entry = [&](Node* index) { + auto set_entry = [&](TNode<IntPtrT> index) { TNode<Object> entry = LoadAndNormalizeFixedDoubleArrayElement( elements, UncheckedCast<IntPtrT>(index)); AddConstructorEntry(variant, context, collection, add_func, entry); }; - BuildFastLoop(IntPtrConstant(0), length, set_entry, 1, - ParameterMode::INTPTR_PARAMETERS, IndexAdvanceMode::kPost); + BuildFastLoop<IntPtrT>(IntPtrConstant(0), length, set_entry, 1, + IndexAdvanceMode::kPost); Goto(&exit); } } @@ -523,10 +522,10 @@ TNode<IntPtrT> BaseCollectionsAssembler::EstimatedInitialSize( [=] { return IntPtrConstant(0); }); } -void BaseCollectionsAssembler::GotoIfNotJSReceiver(Node* const obj, +void BaseCollectionsAssembler::GotoIfNotJSReceiver(TNode<Object> const obj, Label* if_not_receiver) { GotoIf(TaggedIsSmi(obj), if_not_receiver); - GotoIfNot(IsJSReceiver(obj), if_not_receiver); + GotoIfNot(IsJSReceiver(CAST(obj)), if_not_receiver); } TNode<Map> BaseCollectionsAssembler::GetInitialCollectionPrototype( @@ -608,22 +607,24 @@ class CollectionsBuiltinsAssembler : public BaseCollectionsAssembler { protected: template <typename IteratorType> - Node* AllocateJSCollectionIterator(SloppyTNode<Context> context, - int map_index, Node* collection); - TNode<Object> AllocateTable(Variant variant, TNode<Context> context, - TNode<IntPtrT> at_least_space_for) override; - TNode<IntPtrT> GetHash(SloppyTNode<HeapObject> const key); - TNode<IntPtrT> CallGetHashRaw(SloppyTNode<HeapObject> const key); - TNode<Smi> CallGetOrCreateHashRaw(SloppyTNode<HeapObject> const key); + TNode<HeapObject> AllocateJSCollectionIterator( + const TNode<Context> context, int map_index, + const TNode<HeapObject> collection); + TNode<HeapObject> AllocateTable(Variant variant, + TNode<IntPtrT> at_least_space_for) override; + TNode<IntPtrT> GetHash(const TNode<HeapObject> key); + TNode<IntPtrT> CallGetHashRaw(const TNode<HeapObject> key); + TNode<Smi> CallGetOrCreateHashRaw(const TNode<HeapObject> key); // Transitions the iterator to the non obsolete backing store. // This is a NOP if the [table] is not obsolete. - using UpdateInTransition = - std::function<void(Node* const table, Node* const index)>; + template <typename TableType> + using UpdateInTransition = std::function<void(const TNode<TableType> table, + const TNode<IntPtrT> index)>; template <typename TableType> std::pair<TNode<TableType>, TNode<IntPtrT>> Transition( TNode<TableType> const table, TNode<IntPtrT> const index, - UpdateInTransition const& update_in_transition); + UpdateInTransition<TableType> const& update_in_transition); template <typename IteratorType, typename TableType> std::pair<TNode<TableType>, TNode<IntPtrT>> TransitionAndUpdate( TNode<IteratorType> const iterator); @@ -635,35 +636,33 @@ class CollectionsBuiltinsAssembler : public BaseCollectionsAssembler { // The {result} variable will contain the entry index if the key was found, // or the hash code otherwise. template <typename CollectionType> - void FindOrderedHashTableEntryForSmiKey(Node* table, - SloppyTNode<Smi> key_tagged, - Variable* result, Label* entry_found, - Label* not_found); - void SameValueZeroSmi(SloppyTNode<Smi> key_smi, - SloppyTNode<Object> candidate_key, Label* if_same, - Label* if_not_same); + void FindOrderedHashTableEntryForSmiKey(TNode<CollectionType> table, + TNode<Smi> key_tagged, + TVariable<IntPtrT>* result, + Label* entry_found, Label* not_found); + void SameValueZeroSmi(TNode<Smi> key_smi, TNode<Object> candidate_key, + Label* if_same, Label* if_not_same); // Specialization for heap numbers. // The {result} variable will contain the entry index if the key was found, // or the hash code otherwise. - void SameValueZeroHeapNumber(SloppyTNode<Float64T> key_float, - SloppyTNode<Object> candidate_key, - Label* if_same, Label* if_not_same); + void SameValueZeroHeapNumber(TNode<Float64T> key_float, + TNode<Object> candidate_key, Label* if_same, + Label* if_not_same); template <typename CollectionType> void FindOrderedHashTableEntryForHeapNumberKey( - SloppyTNode<Context> context, Node* table, - SloppyTNode<HeapNumber> key_heap_number, Variable* result, - Label* entry_found, Label* not_found); + TNode<CollectionType> table, TNode<HeapNumber> key_heap_number, + TVariable<IntPtrT>* result, Label* entry_found, Label* not_found); // Specialization for bigints. // The {result} variable will contain the entry index if the key was found, // or the hash code otherwise. - void SameValueZeroBigInt(Node* key, Node* candidate_key, Label* if_same, - Label* if_not_same); + void SameValueZeroBigInt(TNode<BigInt> key, TNode<Object> candidate_key, + Label* if_same, Label* if_not_same); template <typename CollectionType> - void FindOrderedHashTableEntryForBigIntKey(SloppyTNode<Context> context, - Node* table, Node* key, - Variable* result, + void FindOrderedHashTableEntryForBigIntKey(TNode<CollectionType> table, + TNode<BigInt> key_big_int, + TVariable<IntPtrT>* result, Label* entry_found, Label* not_found); @@ -671,14 +670,14 @@ class CollectionsBuiltinsAssembler : public BaseCollectionsAssembler { // The {result} variable will contain the entry index if the key was found, // or the hash code otherwise. template <typename CollectionType> - void FindOrderedHashTableEntryForStringKey( - SloppyTNode<Context> context, Node* table, SloppyTNode<String> key_tagged, - Variable* result, Label* entry_found, Label* not_found); - TNode<IntPtrT> ComputeStringHash(TNode<Context> context, - TNode<String> string_key); - void SameValueZeroString(SloppyTNode<Context> context, - SloppyTNode<String> key_string, - SloppyTNode<Object> candidate_key, Label* if_same, + void FindOrderedHashTableEntryForStringKey(TNode<CollectionType> table, + TNode<String> key_tagged, + TVariable<IntPtrT>* result, + Label* entry_found, + Label* not_found); + TNode<IntPtrT> ComputeStringHash(TNode<String> string_key); + void SameValueZeroString(TNode<String> key_string, + TNode<Object> candidate_key, Label* if_same, Label* if_not_same); // Specialization for non-strings, non-numbers. For those we only need @@ -687,26 +686,32 @@ class CollectionsBuiltinsAssembler : public BaseCollectionsAssembler { // or the hash code otherwise. If the hash-code has not been computed, it // should be Smi -1. template <typename CollectionType> - void FindOrderedHashTableEntryForOtherKey( - SloppyTNode<Context> context, Node* table, SloppyTNode<HeapObject> key, - Variable* result, Label* entry_found, Label* not_found); + void FindOrderedHashTableEntryForOtherKey(TNode<CollectionType> table, + TNode<HeapObject> key_heap_object, + TVariable<IntPtrT>* result, + Label* entry_found, + Label* not_found); template <typename CollectionType> - void TryLookupOrderedHashTableIndex(Node* const table, Node* const key, - Node* const context, Variable* result, + void TryLookupOrderedHashTableIndex(const TNode<CollectionType> table, + const TNode<Object> key, + TVariable<IntPtrT>* result, Label* if_entry_found, Label* if_not_found); - Node* NormalizeNumberKey(Node* key); + const TNode<Object> NormalizeNumberKey(const TNode<Object> key); void StoreOrderedHashMapNewEntry(TNode<OrderedHashMap> const table, - Node* const key, Node* const value, - Node* const hash, - Node* const number_of_buckets, - Node* const occupancy); + const TNode<Object> key, + const TNode<Object> value, + const TNode<IntPtrT> hash, + const TNode<IntPtrT> number_of_buckets, + const TNode<IntPtrT> occupancy); + void StoreOrderedHashSetNewEntry(TNode<OrderedHashSet> const table, - Node* const key, Node* const hash, - Node* const number_of_buckets, - Node* const occupancy); + const TNode<Object> key, + const TNode<IntPtrT> hash, + const TNode<IntPtrT> number_of_buckets, + const TNode<IntPtrT> occupancy); // Create a JSArray with PACKED_ELEMENTS kind from a Map.prototype.keys() or // Map.prototype.values() iterator. The iterator is assumed to satisfy @@ -727,11 +732,97 @@ class CollectionsBuiltinsAssembler : public BaseCollectionsAssembler { void BranchIfMapIteratorProtectorValid(Label* if_true, Label* if_false); void BranchIfSetIteratorProtectorValid(Label* if_true, Label* if_false); + + // Builds code that finds OrderedHashTable entry for a key with hash code + // {hash} with using the comparison code generated by {key_compare}. The code + // jumps to {entry_found} if the key is found, or to {not_found} if the key + // was not found. In the {entry_found} branch, the variable + // entry_start_position will be bound to the index of the entry (relative to + // OrderedHashTable::kHashTableStartIndex). + // + // The {CollectionType} template parameter stands for the particular instance + // of OrderedHashTable, it should be OrderedHashMap or OrderedHashSet. + template <typename CollectionType> + void FindOrderedHashTableEntry( + Node* table, Node* hash, + const std::function<void(TNode<Object>, Label*, Label*)>& key_compare, + Variable* entry_start_position, Label* entry_found, Label* not_found); }; +template <typename CollectionType> +void CollectionsBuiltinsAssembler::FindOrderedHashTableEntry( + Node* table, Node* hash, + const std::function<void(TNode<Object>, Label*, Label*)>& key_compare, + Variable* entry_start_position, Label* entry_found, Label* not_found) { + // Get the index of the bucket. + TNode<IntPtrT> const number_of_buckets = + SmiUntag(CAST(UnsafeLoadFixedArrayElement( + CAST(table), CollectionType::NumberOfBucketsIndex()))); + TNode<WordT> const bucket = + WordAnd(hash, IntPtrSub(number_of_buckets, IntPtrConstant(1))); + TNode<IntPtrT> const first_entry = SmiUntag(CAST(UnsafeLoadFixedArrayElement( + CAST(table), bucket, + CollectionType::HashTableStartIndex() * kTaggedSize))); + + // Walk the bucket chain. + TNode<IntPtrT> entry_start; + Label if_key_found(this); + { + TVARIABLE(IntPtrT, var_entry, first_entry); + Label loop(this, {&var_entry, entry_start_position}), + continue_next_entry(this); + Goto(&loop); + BIND(&loop); + + // If the entry index is the not-found sentinel, we are done. + GotoIf(IntPtrEqual(var_entry.value(), + IntPtrConstant(CollectionType::kNotFound)), + not_found); + + // Make sure the entry index is within range. + CSA_ASSERT( + this, + UintPtrLessThan( + var_entry.value(), + SmiUntag(SmiAdd( + CAST(UnsafeLoadFixedArrayElement( + CAST(table), CollectionType::NumberOfElementsIndex())), + CAST(UnsafeLoadFixedArrayElement( + CAST(table), + CollectionType::NumberOfDeletedElementsIndex())))))); + + // Compute the index of the entry relative to kHashTableStartIndex. + entry_start = + IntPtrAdd(IntPtrMul(var_entry.value(), + IntPtrConstant(CollectionType::kEntrySize)), + number_of_buckets); + + // Load the key from the entry. + TNode<Object> const candidate_key = UnsafeLoadFixedArrayElement( + CAST(table), entry_start, + CollectionType::HashTableStartIndex() * kTaggedSize); + + key_compare(candidate_key, &if_key_found, &continue_next_entry); + + BIND(&continue_next_entry); + // Load the index of the next entry in the bucket chain. + var_entry = SmiUntag(CAST(UnsafeLoadFixedArrayElement( + CAST(table), entry_start, + (CollectionType::HashTableStartIndex() + CollectionType::kChainOffset) * + kTaggedSize))); + + Goto(&loop); + } + + BIND(&if_key_found); + entry_start_position->Bind(entry_start); + Goto(entry_found); +} + template <typename IteratorType> -Node* CollectionsBuiltinsAssembler::AllocateJSCollectionIterator( - SloppyTNode<Context> context, int map_index, Node* collection) { +TNode<HeapObject> CollectionsBuiltinsAssembler::AllocateJSCollectionIterator( + TNode<Context> const context, int map_index, + TNode<HeapObject> const collection) { TNode<Object> const table = LoadObjectField(collection, JSCollection::kTableOffset); TNode<NativeContext> const native_context = LoadNativeContext(context); @@ -749,9 +840,8 @@ Node* CollectionsBuiltinsAssembler::AllocateJSCollectionIterator( return iterator; } -TNode<Object> CollectionsBuiltinsAssembler::AllocateTable( - Variant variant, TNode<Context> context, - TNode<IntPtrT> at_least_space_for) { +TNode<HeapObject> CollectionsBuiltinsAssembler::AllocateTable( + Variant variant, TNode<IntPtrT> at_least_space_for) { return CAST((variant == kMap || variant == kWeakMap) ? AllocateOrderedHashTable<OrderedHashMap>() : AllocateOrderedHashTable<OrderedHashSet>()); @@ -778,7 +868,7 @@ TF_BUILTIN(SetConstructor, CollectionsBuiltinsAssembler) { } TNode<Smi> CollectionsBuiltinsAssembler::CallGetOrCreateHashRaw( - SloppyTNode<HeapObject> const key) { + const TNode<HeapObject> key) { TNode<ExternalReference> const function_addr = ExternalConstant(ExternalReference::get_or_create_hash_raw()); TNode<ExternalReference> const isolate_ptr = @@ -787,15 +877,15 @@ TNode<Smi> CollectionsBuiltinsAssembler::CallGetOrCreateHashRaw( MachineType type_ptr = MachineType::Pointer(); MachineType type_tagged = MachineType::AnyTagged(); - Node* const result = CallCFunction(function_addr, type_tagged, - std::make_pair(type_ptr, isolate_ptr), - std::make_pair(type_tagged, key)); + TNode<Smi> result = CAST(CallCFunction(function_addr, type_tagged, + std::make_pair(type_ptr, isolate_ptr), + std::make_pair(type_tagged, key))); - return CAST(result); + return result; } TNode<IntPtrT> CollectionsBuiltinsAssembler::CallGetHashRaw( - SloppyTNode<HeapObject> const key) { + const TNode<HeapObject> key) { TNode<ExternalReference> const function_addr = ExternalConstant(ExternalReference::orderedhashmap_gethash_raw()); TNode<ExternalReference> const isolate_ptr = @@ -804,15 +894,15 @@ TNode<IntPtrT> CollectionsBuiltinsAssembler::CallGetHashRaw( MachineType type_ptr = MachineType::Pointer(); MachineType type_tagged = MachineType::AnyTagged(); - Node* const result = CallCFunction(function_addr, type_tagged, - std::make_pair(type_ptr, isolate_ptr), - std::make_pair(type_tagged, key)); + TNode<Smi> result = CAST(CallCFunction(function_addr, type_tagged, + std::make_pair(type_ptr, isolate_ptr), + std::make_pair(type_tagged, key))); return SmiUntag(result); } TNode<IntPtrT> CollectionsBuiltinsAssembler::GetHash( - SloppyTNode<HeapObject> const key) { + const TNode<HeapObject> key) { TVARIABLE(IntPtrT, var_hash); Label if_receiver(this), if_other(this), done(this); Branch(IsJSReceiver(key), &if_receiver, &if_other); @@ -833,9 +923,10 @@ TNode<IntPtrT> CollectionsBuiltinsAssembler::GetHash( return var_hash.value(); } -void CollectionsBuiltinsAssembler::SameValueZeroSmi( - SloppyTNode<Smi> key_smi, SloppyTNode<Object> candidate_key, Label* if_same, - Label* if_not_same) { +void CollectionsBuiltinsAssembler::SameValueZeroSmi(TNode<Smi> key_smi, + TNode<Object> candidate_key, + Label* if_same, + Label* if_not_same) { // If the key is the same, we are done. GotoIf(TaggedEqual(candidate_key, key_smi), if_same); @@ -862,7 +953,7 @@ void CollectionsBuiltinsAssembler::BranchIfMapIteratorProtectorValid( DCHECK(isolate()->heap()->map_iterator_protector().IsPropertyCell()); Branch( TaggedEqual(LoadObjectField(protector_cell, PropertyCell::kValueOffset), - SmiConstant(Isolate::kProtectorValid)), + SmiConstant(Protectors::kProtectorValid)), if_true, if_false); } @@ -921,7 +1012,7 @@ void CollectionsBuiltinsAssembler::BranchIfSetIteratorProtectorValid( DCHECK(isolate()->heap()->set_iterator_protector().IsPropertyCell()); Branch( TaggedEqual(LoadObjectField(protector_cell, PropertyCell::kValueOffset), - SmiConstant(Isolate::kProtectorValid)), + SmiConstant(Protectors::kProtectorValid)), if_true, if_false); } @@ -998,15 +1089,15 @@ TNode<JSArray> CollectionsBuiltinsAssembler::MapIteratorToList( TNode<Map> array_map = LoadJSArrayElementsMap(kind, LoadNativeContext(context)); TNode<JSArray> array = - AllocateJSArray(kind, array_map, size, SmiTag(size), nullptr, + AllocateJSArray(kind, array_map, size, SmiTag(size), {}, INTPTR_PARAMETERS, kAllowLargeObjectAllocation); TNode<FixedArray> elements = CAST(LoadElements(array)); const int first_element_offset = FixedArray::kHeaderSize - kHeapObjectTag; TNode<IntPtrT> first_to_element_offset = - ElementOffsetFromIndex(IntPtrConstant(0), kind, INTPTR_PARAMETERS, 0); - VARIABLE( - var_offset, MachineType::PointerRepresentation(), + ElementOffsetFromIndex(IntPtrConstant(0), kind, 0); + TVARIABLE( + IntPtrT, var_offset, IntPtrAdd(first_to_element_offset, IntPtrConstant(first_element_offset))); TVARIABLE(IntPtrT, var_index, index); VariableList vars({&var_index, &var_offset}, zone()); @@ -1053,8 +1144,7 @@ TNode<JSArray> CollectionsBuiltinsAssembler::MapIteratorToList( { // Increment the array offset and continue the loop to the next entry. var_index = cur_index; - var_offset.Bind( - IntPtrAdd(var_offset.value(), IntPtrConstant(kTaggedSize))); + var_offset = IntPtrAdd(var_offset.value(), IntPtrConstant(kTaggedSize)); Goto(&loop); } } @@ -1111,15 +1201,15 @@ TNode<JSArray> CollectionsBuiltinsAssembler::SetOrSetIteratorToList( TNode<Map> array_map = LoadJSArrayElementsMap(kind, LoadNativeContext(context)); TNode<JSArray> array = - AllocateJSArray(kind, array_map, size, SmiTag(size), nullptr, + AllocateJSArray(kind, array_map, size, SmiTag(size), {}, INTPTR_PARAMETERS, kAllowLargeObjectAllocation); TNode<FixedArray> elements = CAST(LoadElements(array)); const int first_element_offset = FixedArray::kHeaderSize - kHeapObjectTag; TNode<IntPtrT> first_to_element_offset = - ElementOffsetFromIndex(IntPtrConstant(0), kind, INTPTR_PARAMETERS, 0); - VARIABLE( - var_offset, MachineType::PointerRepresentation(), + ElementOffsetFromIndex(IntPtrConstant(0), kind, 0); + TVARIABLE( + IntPtrT, var_offset, IntPtrAdd(first_to_element_offset, IntPtrConstant(first_element_offset))); TVARIABLE(IntPtrT, var_index, IntPtrConstant(0)); Label done(this), finalize(this, {&var_index}), @@ -1139,7 +1229,7 @@ TNode<JSArray> CollectionsBuiltinsAssembler::SetOrSetIteratorToList( Store(elements, var_offset.value(), entry_key); var_index = cur_index; - var_offset.Bind(IntPtrAdd(var_offset.value(), IntPtrConstant(kTaggedSize))); + var_offset = IntPtrAdd(var_offset.value(), IntPtrConstant(kTaggedSize)); Goto(&loop); } @@ -1164,13 +1254,13 @@ TF_BUILTIN(SetOrSetIteratorToList, CollectionsBuiltinsAssembler) { template <typename CollectionType> void CollectionsBuiltinsAssembler::FindOrderedHashTableEntryForSmiKey( - Node* table, SloppyTNode<Smi> smi_key, Variable* result, Label* entry_found, - Label* not_found) { + TNode<CollectionType> table, TNode<Smi> smi_key, TVariable<IntPtrT>* result, + Label* entry_found, Label* not_found) { TNode<IntPtrT> const key_untagged = SmiUntag(smi_key); TNode<IntPtrT> const hash = ChangeInt32ToIntPtr(ComputeUnseededHash(key_untagged)); CSA_ASSERT(this, IntPtrGreaterThanOrEqual(hash, IntPtrConstant(0))); - result->Bind(hash); + *result = hash; FindOrderedHashTableEntry<CollectionType>( table, hash, [&](TNode<Object> other_key, Label* if_same, Label* if_not_same) { @@ -1181,28 +1271,26 @@ void CollectionsBuiltinsAssembler::FindOrderedHashTableEntryForSmiKey( template <typename CollectionType> void CollectionsBuiltinsAssembler::FindOrderedHashTableEntryForStringKey( - SloppyTNode<Context> context, Node* table, SloppyTNode<String> key_tagged, - Variable* result, Label* entry_found, Label* not_found) { - TNode<IntPtrT> const hash = ComputeStringHash(context, key_tagged); + TNode<CollectionType> table, TNode<String> key_tagged, + TVariable<IntPtrT>* result, Label* entry_found, Label* not_found) { + TNode<IntPtrT> const hash = ComputeStringHash(key_tagged); CSA_ASSERT(this, IntPtrGreaterThanOrEqual(hash, IntPtrConstant(0))); - result->Bind(hash); + *result = hash; FindOrderedHashTableEntry<CollectionType>( table, hash, [&](TNode<Object> other_key, Label* if_same, Label* if_not_same) { - SameValueZeroString(context, key_tagged, other_key, if_same, - if_not_same); + SameValueZeroString(key_tagged, other_key, if_same, if_not_same); }, result, entry_found, not_found); } template <typename CollectionType> void CollectionsBuiltinsAssembler::FindOrderedHashTableEntryForHeapNumberKey( - SloppyTNode<Context> context, Node* table, - SloppyTNode<HeapNumber> key_heap_number, Variable* result, - Label* entry_found, Label* not_found) { + TNode<CollectionType> table, TNode<HeapNumber> key_heap_number, + TVariable<IntPtrT>* result, Label* entry_found, Label* not_found) { TNode<IntPtrT> const hash = CallGetHashRaw(key_heap_number); CSA_ASSERT(this, IntPtrGreaterThanOrEqual(hash, IntPtrConstant(0))); - result->Bind(hash); + *result = hash; TNode<Float64T> const key_float = LoadHeapNumberValue(key_heap_number); FindOrderedHashTableEntry<CollectionType>( table, hash, @@ -1214,36 +1302,36 @@ void CollectionsBuiltinsAssembler::FindOrderedHashTableEntryForHeapNumberKey( template <typename CollectionType> void CollectionsBuiltinsAssembler::FindOrderedHashTableEntryForBigIntKey( - SloppyTNode<Context> context, Node* table, Node* key, Variable* result, - Label* entry_found, Label* not_found) { - TNode<IntPtrT> const hash = CallGetHashRaw(key); + TNode<CollectionType> table, TNode<BigInt> key_big_int, + TVariable<IntPtrT>* result, Label* entry_found, Label* not_found) { + TNode<IntPtrT> const hash = CallGetHashRaw(key_big_int); CSA_ASSERT(this, IntPtrGreaterThanOrEqual(hash, IntPtrConstant(0))); - result->Bind(hash); + *result = hash; FindOrderedHashTableEntry<CollectionType>( table, hash, [&](TNode<Object> other_key, Label* if_same, Label* if_not_same) { - SameValueZeroBigInt(key, other_key, if_same, if_not_same); + SameValueZeroBigInt(key_big_int, other_key, if_same, if_not_same); }, result, entry_found, not_found); } template <typename CollectionType> void CollectionsBuiltinsAssembler::FindOrderedHashTableEntryForOtherKey( - SloppyTNode<Context> context, Node* table, SloppyTNode<HeapObject> key, - Variable* result, Label* entry_found, Label* not_found) { - TNode<IntPtrT> const hash = GetHash(key); + TNode<CollectionType> table, TNode<HeapObject> key_heap_object, + TVariable<IntPtrT>* result, Label* entry_found, Label* not_found) { + TNode<IntPtrT> const hash = GetHash(key_heap_object); CSA_ASSERT(this, IntPtrGreaterThanOrEqual(hash, IntPtrConstant(0))); - result->Bind(hash); + *result = hash; FindOrderedHashTableEntry<CollectionType>( table, hash, [&](TNode<Object> other_key, Label* if_same, Label* if_not_same) { - Branch(TaggedEqual(key, other_key), if_same, if_not_same); + Branch(TaggedEqual(key_heap_object, other_key), if_same, if_not_same); }, result, entry_found, not_found); } TNode<IntPtrT> CollectionsBuiltinsAssembler::ComputeStringHash( - TNode<Context> context, TNode<String> string_key) { + TNode<String> string_key) { TVARIABLE(IntPtrT, var_result); Label hash_not_computed(this), done(this, &var_result); @@ -1261,25 +1349,23 @@ TNode<IntPtrT> CollectionsBuiltinsAssembler::ComputeStringHash( } void CollectionsBuiltinsAssembler::SameValueZeroString( - SloppyTNode<Context> context, SloppyTNode<String> key_string, - SloppyTNode<Object> candidate_key, Label* if_same, Label* if_not_same) { + TNode<String> key_string, TNode<Object> candidate_key, Label* if_same, + Label* if_not_same) { // If the candidate is not a string, the keys are not equal. GotoIf(TaggedIsSmi(candidate_key), if_not_same); GotoIfNot(IsString(CAST(candidate_key)), if_not_same); - Branch(TaggedEqual(CallBuiltin(Builtins::kStringEqual, context, key_string, - candidate_key), + Branch(TaggedEqual(CallBuiltin(Builtins::kStringEqual, NoContextConstant(), + key_string, candidate_key), TrueConstant()), if_same, if_not_same); } -void CollectionsBuiltinsAssembler::SameValueZeroBigInt(Node* key, - Node* candidate_key, - Label* if_same, - Label* if_not_same) { - CSA_ASSERT(this, IsBigInt(key)); +void CollectionsBuiltinsAssembler::SameValueZeroBigInt( + TNode<BigInt> key, TNode<Object> candidate_key, Label* if_same, + Label* if_not_same) { GotoIf(TaggedIsSmi(candidate_key), if_not_same); - GotoIfNot(IsBigInt(candidate_key), if_not_same); + GotoIfNot(IsBigInt(CAST(candidate_key)), if_not_same); Branch(TaggedEqual(CallRuntime(Runtime::kBigIntEqualToBigInt, NoContextConstant(), key, candidate_key), @@ -1288,8 +1374,8 @@ void CollectionsBuiltinsAssembler::SameValueZeroBigInt(Node* key, } void CollectionsBuiltinsAssembler::SameValueZeroHeapNumber( - SloppyTNode<Float64T> key_float, SloppyTNode<Object> candidate_key, - Label* if_same, Label* if_not_same) { + TNode<Float64T> key_float, TNode<Object> candidate_key, Label* if_same, + Label* if_not_same) { Label if_smi(this), if_keyisnan(this); GotoIf(TaggedIsSmi(candidate_key), &if_smi); @@ -1339,20 +1425,20 @@ TF_BUILTIN(OrderedHashTableHealIndex, CollectionsBuiltinsAssembler) { IntPtrConstant(OrderedHashMap::kClearedTableSentinel)), &return_zero); - VARIABLE(var_i, MachineType::PointerRepresentation(), IntPtrConstant(0)); - VARIABLE(var_index, MachineRepresentation::kTagged, index); + TVARIABLE(IntPtrT, var_i, IntPtrConstant(0)); + TVARIABLE(Smi, var_index, index); Label loop(this, {&var_i, &var_index}); Goto(&loop); BIND(&loop); { - Node* i = var_i.value(); + TNode<IntPtrT> i = var_i.value(); GotoIfNot(IntPtrLessThan(i, number_of_deleted_elements), &return_index); STATIC_ASSERT(OrderedHashMap::RemovedHolesIndex() == OrderedHashSet::RemovedHolesIndex()); TNode<Smi> removed_index = CAST(LoadFixedArrayElement( CAST(table), i, OrderedHashMap::RemovedHolesIndex() * kTaggedSize)); GotoIf(SmiGreaterThanOrEqual(removed_index, index), &return_index); - Decrement(&var_index, 1, SMI_PARAMETERS); + Decrement(&var_index); Increment(&var_i); Goto(&loop); } @@ -1368,7 +1454,7 @@ template <typename TableType> std::pair<TNode<TableType>, TNode<IntPtrT>> CollectionsBuiltinsAssembler::Transition( TNode<TableType> const table, TNode<IntPtrT> const index, - UpdateInTransition const& update_in_transition) { + UpdateInTransition<TableType> const& update_in_transition) { TVARIABLE(IntPtrT, var_index, index); TVARIABLE(TableType, var_table, table); Label if_done(this), if_transition(this, Label::kDeferred); @@ -1413,7 +1499,8 @@ CollectionsBuiltinsAssembler::TransitionAndUpdate( return Transition<TableType>( CAST(LoadObjectField(iterator, IteratorType::kTableOffset)), LoadAndUntagObjectField(iterator, IteratorType::kIndexOffset), - [this, iterator](Node* const table, Node* const index) { + [this, iterator](const TNode<TableType> table, + const TNode<IntPtrT> index) { // Update the {iterator} with the new state. StoreObjectField(iterator, IteratorType::kTableOffset, table); StoreObjectFieldNoWriteBarrier(iterator, IteratorType::kIndexOffset, @@ -1460,13 +1547,14 @@ CollectionsBuiltinsAssembler::NextSkipHoles(TNode<TableType> table, } TF_BUILTIN(MapPrototypeGet, CollectionsBuiltinsAssembler) { - Node* const receiver = Parameter(Descriptor::kReceiver); - Node* const key = Parameter(Descriptor::kKey); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver)); + const TNode<Object> key = CAST(Parameter(Descriptor::kKey)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); ThrowIfNotInstanceType(context, receiver, JS_MAP_TYPE, "Map.prototype.get"); - TNode<Object> const table = LoadObjectField(receiver, JSMap::kTableOffset); + TNode<Object> const table = + LoadObjectField<Object>(CAST(receiver), JSMap::kTableOffset); TNode<Smi> index = CAST( CallBuiltin(Builtins::kFindOrderedHashMapEntry, context, table, key)); @@ -1485,13 +1573,14 @@ TF_BUILTIN(MapPrototypeGet, CollectionsBuiltinsAssembler) { } TF_BUILTIN(MapPrototypeHas, CollectionsBuiltinsAssembler) { - Node* const receiver = Parameter(Descriptor::kReceiver); - Node* const key = Parameter(Descriptor::kKey); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver)); + const TNode<Object> key = CAST(Parameter(Descriptor::kKey)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); ThrowIfNotInstanceType(context, receiver, JS_MAP_TYPE, "Map.prototype.has"); - TNode<Object> const table = LoadObjectField(receiver, JSMap::kTableOffset); + TNode<Object> const table = + LoadObjectField(CAST(receiver), JSMap::kTableOffset); TNode<Smi> index = CAST( CallBuiltin(Builtins::kFindOrderedHashMapEntry, context, table, key)); @@ -1506,17 +1595,18 @@ TF_BUILTIN(MapPrototypeHas, CollectionsBuiltinsAssembler) { Return(FalseConstant()); } -Node* CollectionsBuiltinsAssembler::NormalizeNumberKey(Node* const key) { - VARIABLE(result, MachineRepresentation::kTagged, key); +const TNode<Object> CollectionsBuiltinsAssembler::NormalizeNumberKey( + const TNode<Object> key) { + TVARIABLE(Object, result, key); Label done(this); GotoIf(TaggedIsSmi(key), &done); - GotoIfNot(IsHeapNumber(key), &done); - TNode<Float64T> const number = LoadHeapNumberValue(key); + GotoIfNot(IsHeapNumber(CAST(key)), &done); + TNode<Float64T> const number = LoadHeapNumberValue(CAST(key)); GotoIfNot(Float64Equal(number, Float64Constant(0.0)), &done); // We know the value is zero, so we take the key to be Smi 0. // Another option would be to normalize to Smi here. - result.Bind(SmiConstant(0)); + result = SmiConstant(0); Goto(&done); BIND(&done); @@ -1524,25 +1614,23 @@ Node* CollectionsBuiltinsAssembler::NormalizeNumberKey(Node* const key) { } TF_BUILTIN(MapPrototypeSet, CollectionsBuiltinsAssembler) { - Node* const receiver = Parameter(Descriptor::kReceiver); - Node* key = Parameter(Descriptor::kKey); - Node* const value = Parameter(Descriptor::kValue); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver)); + TNode<Object> key = CAST(Parameter(Descriptor::kKey)); + const TNode<Object> value = CAST(Parameter(Descriptor::kValue)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); ThrowIfNotInstanceType(context, receiver, JS_MAP_TYPE, "Map.prototype.set"); key = NormalizeNumberKey(key); TNode<OrderedHashMap> const table = - CAST(LoadObjectField(receiver, JSMap::kTableOffset)); + LoadObjectField<OrderedHashMap>(CAST(receiver), JSMap::kTableOffset); - VARIABLE(entry_start_position_or_hash, MachineType::PointerRepresentation(), - IntPtrConstant(0)); + TVARIABLE(IntPtrT, entry_start_position_or_hash, IntPtrConstant(0)); Label entry_found(this), not_found(this); - TryLookupOrderedHashTableIndex<OrderedHashMap>(table, key, context, - &entry_start_position_or_hash, - &entry_found, ¬_found); + TryLookupOrderedHashTableIndex<OrderedHashMap>( + table, key, &entry_start_position_or_hash, &entry_found, ¬_found); BIND(&entry_found); // If we found the entry, we just store the value there. @@ -1561,18 +1649,18 @@ TF_BUILTIN(MapPrototypeSet, CollectionsBuiltinsAssembler) { &add_entry); // Otherwise, go to runtime to compute the hash code. - entry_start_position_or_hash.Bind(SmiUntag(CallGetOrCreateHashRaw(key))); + entry_start_position_or_hash = SmiUntag(CallGetOrCreateHashRaw(CAST(key))); Goto(&add_entry); } BIND(&add_entry); - VARIABLE(number_of_buckets, MachineType::PointerRepresentation()); - VARIABLE(occupancy, MachineType::PointerRepresentation()); + TVARIABLE(IntPtrT, number_of_buckets); + TVARIABLE(IntPtrT, occupancy); TVARIABLE(OrderedHashMap, table_var, table); { // Check we have enough space for the entry. - number_of_buckets.Bind(SmiUntag(CAST(UnsafeLoadFixedArrayElement( - table, OrderedHashMap::NumberOfBucketsIndex())))); + number_of_buckets = SmiUntag(CAST(UnsafeLoadFixedArrayElement( + table, OrderedHashMap::NumberOfBucketsIndex()))); STATIC_ASSERT(OrderedHashMap::kLoadFactor == 2); TNode<WordT> const capacity = WordShl(number_of_buckets.value(), 1); @@ -1580,20 +1668,21 @@ TF_BUILTIN(MapPrototypeSet, CollectionsBuiltinsAssembler) { CAST(LoadObjectField(table, OrderedHashMap::NumberOfElementsOffset()))); TNode<IntPtrT> const number_of_deleted = SmiUntag(CAST(LoadObjectField( table, OrderedHashMap::NumberOfDeletedElementsOffset()))); - occupancy.Bind(IntPtrAdd(number_of_elements, number_of_deleted)); + occupancy = IntPtrAdd(number_of_elements, number_of_deleted); GotoIf(IntPtrLessThan(occupancy.value(), capacity), &store_new_entry); // We do not have enough space, grow the table and reload the relevant // fields. CallRuntime(Runtime::kMapGrow, context, receiver); - table_var = CAST(LoadObjectField(receiver, JSMap::kTableOffset)); - number_of_buckets.Bind(SmiUntag(CAST(UnsafeLoadFixedArrayElement( - table_var.value(), OrderedHashMap::NumberOfBucketsIndex())))); + table_var = + LoadObjectField<OrderedHashMap>(CAST(receiver), JSMap::kTableOffset); + number_of_buckets = SmiUntag(CAST(UnsafeLoadFixedArrayElement( + table_var.value(), OrderedHashMap::NumberOfBucketsIndex()))); TNode<IntPtrT> const new_number_of_elements = SmiUntag(CAST(LoadObjectField( table_var.value(), OrderedHashMap::NumberOfElementsOffset()))); TNode<IntPtrT> const new_number_of_deleted = SmiUntag(CAST(LoadObjectField( table_var.value(), OrderedHashMap::NumberOfDeletedElementsOffset()))); - occupancy.Bind(IntPtrAdd(new_number_of_elements, new_number_of_deleted)); + occupancy = IntPtrAdd(new_number_of_elements, new_number_of_deleted); Goto(&store_new_entry); } BIND(&store_new_entry); @@ -1605,15 +1694,16 @@ TF_BUILTIN(MapPrototypeSet, CollectionsBuiltinsAssembler) { } void CollectionsBuiltinsAssembler::StoreOrderedHashMapNewEntry( - TNode<OrderedHashMap> const table, Node* const key, Node* const value, - Node* const hash, Node* const number_of_buckets, Node* const occupancy) { - TNode<WordT> const bucket = + TNode<OrderedHashMap> const table, const TNode<Object> key, + const TNode<Object> value, const TNode<IntPtrT> hash, + const TNode<IntPtrT> number_of_buckets, const TNode<IntPtrT> occupancy) { + TNode<IntPtrT> const bucket = WordAnd(hash, IntPtrSub(number_of_buckets, IntPtrConstant(1))); TNode<Smi> bucket_entry = CAST(UnsafeLoadFixedArrayElement( table, bucket, OrderedHashMap::HashTableStartIndex() * kTaggedSize)); // Store the entry elements. - TNode<WordT> const entry_start = IntPtrAdd( + TNode<IntPtrT> const entry_start = IntPtrAdd( IntPtrMul(occupancy, IntPtrConstant(OrderedHashMap::kEntrySize)), number_of_buckets); UnsafeStoreFixedArrayElement( @@ -1642,23 +1732,21 @@ void CollectionsBuiltinsAssembler::StoreOrderedHashMapNewEntry( } TF_BUILTIN(MapPrototypeDelete, CollectionsBuiltinsAssembler) { - Node* const receiver = Parameter(Descriptor::kReceiver); - Node* key = Parameter(Descriptor::kKey); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver)); + const TNode<Object> key = CAST(Parameter(Descriptor::kKey)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); ThrowIfNotInstanceType(context, receiver, JS_MAP_TYPE, "Map.prototype.delete"); TNode<OrderedHashMap> const table = - CAST(LoadObjectField(receiver, JSMap::kTableOffset)); + LoadObjectField<OrderedHashMap>(CAST(receiver), JSMap::kTableOffset); - VARIABLE(entry_start_position_or_hash, MachineType::PointerRepresentation(), - IntPtrConstant(0)); + TVARIABLE(IntPtrT, entry_start_position_or_hash, IntPtrConstant(0)); Label entry_found(this), not_found(this); - TryLookupOrderedHashTableIndex<OrderedHashMap>(table, key, context, - &entry_start_position_or_hash, - &entry_found, ¬_found); + TryLookupOrderedHashTableIndex<OrderedHashMap>( + table, key, &entry_start_position_or_hash, &entry_found, ¬_found); BIND(¬_found); Return(FalseConstant()); @@ -1703,24 +1791,22 @@ TF_BUILTIN(MapPrototypeDelete, CollectionsBuiltinsAssembler) { } TF_BUILTIN(SetPrototypeAdd, CollectionsBuiltinsAssembler) { - Node* const receiver = Parameter(Descriptor::kReceiver); - Node* key = Parameter(Descriptor::kKey); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver)); + TNode<Object> key = CAST(Parameter(Descriptor::kKey)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); ThrowIfNotInstanceType(context, receiver, JS_SET_TYPE, "Set.prototype.add"); key = NormalizeNumberKey(key); TNode<OrderedHashSet> const table = - CAST(LoadObjectField(receiver, JSMap::kTableOffset)); + LoadObjectField<OrderedHashSet>(CAST(receiver), JSMap::kTableOffset); - VARIABLE(entry_start_position_or_hash, MachineType::PointerRepresentation(), - IntPtrConstant(0)); + TVARIABLE(IntPtrT, entry_start_position_or_hash, IntPtrConstant(0)); Label entry_found(this), not_found(this); - TryLookupOrderedHashTableIndex<OrderedHashSet>(table, key, context, - &entry_start_position_or_hash, - &entry_found, ¬_found); + TryLookupOrderedHashTableIndex<OrderedHashSet>( + table, key, &entry_start_position_or_hash, &entry_found, ¬_found); BIND(&entry_found); // The entry was found, there is nothing to do. @@ -1735,18 +1821,18 @@ TF_BUILTIN(SetPrototypeAdd, CollectionsBuiltinsAssembler) { &add_entry); // Otherwise, go to runtime to compute the hash code. - entry_start_position_or_hash.Bind(SmiUntag(CallGetOrCreateHashRaw(key))); + entry_start_position_or_hash = SmiUntag(CallGetOrCreateHashRaw(CAST(key))); Goto(&add_entry); } BIND(&add_entry); - VARIABLE(number_of_buckets, MachineType::PointerRepresentation()); - VARIABLE(occupancy, MachineType::PointerRepresentation()); + TVARIABLE(IntPtrT, number_of_buckets); + TVARIABLE(IntPtrT, occupancy); TVARIABLE(OrderedHashSet, table_var, table); { // Check we have enough space for the entry. - number_of_buckets.Bind(SmiUntag(CAST(UnsafeLoadFixedArrayElement( - table, OrderedHashSet::NumberOfBucketsIndex())))); + number_of_buckets = SmiUntag(CAST(UnsafeLoadFixedArrayElement( + table, OrderedHashSet::NumberOfBucketsIndex()))); STATIC_ASSERT(OrderedHashSet::kLoadFactor == 2); TNode<WordT> const capacity = WordShl(number_of_buckets.value(), 1); @@ -1754,20 +1840,21 @@ TF_BUILTIN(SetPrototypeAdd, CollectionsBuiltinsAssembler) { CAST(LoadObjectField(table, OrderedHashSet::NumberOfElementsOffset()))); TNode<IntPtrT> const number_of_deleted = SmiUntag(CAST(LoadObjectField( table, OrderedHashSet::NumberOfDeletedElementsOffset()))); - occupancy.Bind(IntPtrAdd(number_of_elements, number_of_deleted)); + occupancy = IntPtrAdd(number_of_elements, number_of_deleted); GotoIf(IntPtrLessThan(occupancy.value(), capacity), &store_new_entry); // We do not have enough space, grow the table and reload the relevant // fields. CallRuntime(Runtime::kSetGrow, context, receiver); - table_var = CAST(LoadObjectField(receiver, JSMap::kTableOffset)); - number_of_buckets.Bind(SmiUntag(CAST(UnsafeLoadFixedArrayElement( - table_var.value(), OrderedHashSet::NumberOfBucketsIndex())))); + table_var = + LoadObjectField<OrderedHashSet>(CAST(receiver), JSMap::kTableOffset); + number_of_buckets = SmiUntag(CAST(UnsafeLoadFixedArrayElement( + table_var.value(), OrderedHashSet::NumberOfBucketsIndex()))); TNode<IntPtrT> const new_number_of_elements = SmiUntag(CAST(LoadObjectField( table_var.value(), OrderedHashSet::NumberOfElementsOffset()))); TNode<IntPtrT> const new_number_of_deleted = SmiUntag(CAST(LoadObjectField( table_var.value(), OrderedHashSet::NumberOfDeletedElementsOffset()))); - occupancy.Bind(IntPtrAdd(new_number_of_elements, new_number_of_deleted)); + occupancy = IntPtrAdd(new_number_of_elements, new_number_of_deleted); Goto(&store_new_entry); } BIND(&store_new_entry); @@ -1779,15 +1866,16 @@ TF_BUILTIN(SetPrototypeAdd, CollectionsBuiltinsAssembler) { } void CollectionsBuiltinsAssembler::StoreOrderedHashSetNewEntry( - TNode<OrderedHashSet> const table, Node* const key, Node* const hash, - Node* const number_of_buckets, Node* const occupancy) { - TNode<WordT> const bucket = + TNode<OrderedHashSet> const table, const TNode<Object> key, + const TNode<IntPtrT> hash, const TNode<IntPtrT> number_of_buckets, + const TNode<IntPtrT> occupancy) { + TNode<IntPtrT> const bucket = WordAnd(hash, IntPtrSub(number_of_buckets, IntPtrConstant(1))); TNode<Smi> bucket_entry = CAST(UnsafeLoadFixedArrayElement( table, bucket, OrderedHashSet::HashTableStartIndex() * kTaggedSize)); // Store the entry elements. - TNode<WordT> const entry_start = IntPtrAdd( + TNode<IntPtrT> const entry_start = IntPtrAdd( IntPtrMul(occupancy, IntPtrConstant(OrderedHashSet::kEntrySize)), number_of_buckets); UnsafeStoreFixedArrayElement( @@ -1812,23 +1900,21 @@ void CollectionsBuiltinsAssembler::StoreOrderedHashSetNewEntry( } TF_BUILTIN(SetPrototypeDelete, CollectionsBuiltinsAssembler) { - Node* const receiver = Parameter(Descriptor::kReceiver); - Node* key = Parameter(Descriptor::kKey); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver)); + const TNode<Object> key = CAST(Parameter(Descriptor::kKey)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); ThrowIfNotInstanceType(context, receiver, JS_SET_TYPE, "Set.prototype.delete"); TNode<OrderedHashSet> const table = - CAST(LoadObjectField(receiver, JSMap::kTableOffset)); + LoadObjectField<OrderedHashSet>(CAST(receiver), JSMap::kTableOffset); - VARIABLE(entry_start_position_or_hash, MachineType::PointerRepresentation(), - IntPtrConstant(0)); + TVARIABLE(IntPtrT, entry_start_position_or_hash, IntPtrConstant(0)); Label entry_found(this), not_found(this); - TryLookupOrderedHashTableIndex<OrderedHashSet>(table, key, context, - &entry_start_position_or_hash, - &entry_found, ¬_found); + TryLookupOrderedHashTableIndex<OrderedHashSet>( + table, key, &entry_start_position_or_hash, &entry_found, ¬_found); BIND(¬_found); Return(FalseConstant()); @@ -1869,29 +1955,30 @@ TF_BUILTIN(SetPrototypeDelete, CollectionsBuiltinsAssembler) { } TF_BUILTIN(MapPrototypeEntries, CollectionsBuiltinsAssembler) { - Node* const receiver = Parameter(Descriptor::kReceiver); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); ThrowIfNotInstanceType(context, receiver, JS_MAP_TYPE, "Map.prototype.entries"); Return(AllocateJSCollectionIterator<JSMapIterator>( - context, Context::MAP_KEY_VALUE_ITERATOR_MAP_INDEX, receiver)); + context, Context::MAP_KEY_VALUE_ITERATOR_MAP_INDEX, CAST(receiver))); } TF_BUILTIN(MapPrototypeGetSize, CollectionsBuiltinsAssembler) { - Node* const receiver = Parameter(Descriptor::kReceiver); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); ThrowIfNotInstanceType(context, receiver, JS_MAP_TYPE, "get Map.prototype.size"); TNode<OrderedHashMap> const table = - CAST(LoadObjectField(receiver, JSMap::kTableOffset)); + LoadObjectField<OrderedHashMap>(CAST(receiver), JSMap::kTableOffset); Return(LoadObjectField(table, OrderedHashMap::NumberOfElementsOffset())); } TF_BUILTIN(MapPrototypeForEach, CollectionsBuiltinsAssembler) { const char* const kMethodName = "Map.prototype.forEach"; - Node* const argc = Parameter(Descriptor::kJSActualArgumentsCount); - Node* const context = Parameter(Descriptor::kContext); - CodeStubArguments args(this, ChangeInt32ToIntPtr(argc)); + TNode<Int32T> argc = + UncheckedCast<Int32T>(Parameter(Descriptor::kJSActualArgumentsCount)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); + CodeStubArguments args(this, argc); TNode<Object> const receiver = args.GetReceiver(); TNode<Object> const callback = args.GetOptionalArgumentValue(0); TNode<Object> const this_arg = args.GetOptionalArgumentValue(1); @@ -1914,8 +2001,8 @@ TF_BUILTIN(MapPrototypeForEach, CollectionsBuiltinsAssembler) { // the {receiver} while we're iterating. TNode<IntPtrT> index = var_index.value(); TNode<OrderedHashMap> table = var_table.value(); - std::tie(table, index) = - Transition<OrderedHashMap>(table, index, [](Node*, Node*) {}); + std::tie(table, index) = Transition<OrderedHashMap>( + table, index, [](const TNode<OrderedHashMap>, const TNode<IntPtrT>) {}); // Read the next entry from the {table}, skipping holes. TNode<Object> entry_key; @@ -1951,31 +2038,32 @@ TF_BUILTIN(MapPrototypeForEach, CollectionsBuiltinsAssembler) { } TF_BUILTIN(MapPrototypeKeys, CollectionsBuiltinsAssembler) { - Node* const receiver = Parameter(Descriptor::kReceiver); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); ThrowIfNotInstanceType(context, receiver, JS_MAP_TYPE, "Map.prototype.keys"); Return(AllocateJSCollectionIterator<JSMapIterator>( - context, Context::MAP_KEY_ITERATOR_MAP_INDEX, receiver)); + context, Context::MAP_KEY_ITERATOR_MAP_INDEX, CAST(receiver))); } TF_BUILTIN(MapPrototypeValues, CollectionsBuiltinsAssembler) { - Node* const receiver = Parameter(Descriptor::kReceiver); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); ThrowIfNotInstanceType(context, receiver, JS_MAP_TYPE, "Map.prototype.values"); Return(AllocateJSCollectionIterator<JSMapIterator>( - context, Context::MAP_VALUE_ITERATOR_MAP_INDEX, receiver)); + context, Context::MAP_VALUE_ITERATOR_MAP_INDEX, CAST(receiver))); } TF_BUILTIN(MapIteratorPrototypeNext, CollectionsBuiltinsAssembler) { const char* const kMethodName = "Map Iterator.prototype.next"; - Node* const receiver = Parameter(Descriptor::kReceiver); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); // Ensure that the {receiver} is actually a JSMapIterator. Label if_receiver_valid(this), if_receiver_invalid(this, Label::kDeferred); GotoIf(TaggedIsSmi(receiver), &if_receiver_invalid); - TNode<Uint16T> const receiver_instance_type = LoadInstanceType(receiver); + TNode<Uint16T> const receiver_instance_type = + LoadInstanceType(CAST(receiver)); GotoIf( InstanceTypeEqual(receiver_instance_type, JS_MAP_KEY_VALUE_ITERATOR_TYPE), &if_receiver_valid); @@ -1989,8 +2077,8 @@ TF_BUILTIN(MapIteratorPrototypeNext, CollectionsBuiltinsAssembler) { BIND(&if_receiver_valid); // Check if the {receiver} is exhausted. - VARIABLE(var_done, MachineRepresentation::kTagged, TrueConstant()); - VARIABLE(var_value, MachineRepresentation::kTagged, UndefinedConstant()); + TVARIABLE(Oddball, var_done, TrueConstant()); + TVARIABLE(Object, var_value, UndefinedConstant()); Label return_value(this, {&var_done, &var_value}), return_entry(this), return_end(this, Label::kDeferred); @@ -2007,22 +2095,22 @@ TF_BUILTIN(MapIteratorPrototypeNext, CollectionsBuiltinsAssembler) { NextSkipHoles<OrderedHashMap>(table, index, &return_end); StoreObjectFieldNoWriteBarrier(receiver, JSMapIterator::kIndexOffset, SmiTag(index)); - var_value.Bind(entry_key); - var_done.Bind(FalseConstant()); + var_value = entry_key; + var_done = FalseConstant(); // Check how to return the {key} (depending on {receiver} type). GotoIf(InstanceTypeEqual(receiver_instance_type, JS_MAP_KEY_ITERATOR_TYPE), &return_value); - var_value.Bind(LoadFixedArrayElement( + var_value = LoadFixedArrayElement( table, entry_start_position, (OrderedHashMap::HashTableStartIndex() + OrderedHashMap::kValueOffset) * - kTaggedSize)); + kTaggedSize); Branch(InstanceTypeEqual(receiver_instance_type, JS_MAP_VALUE_ITERATOR_TYPE), &return_value, &return_entry); BIND(&return_entry); { - Node* result = + TNode<JSObject> result = AllocateJSIteratorResultForEntry(context, entry_key, var_value.value()); Return(result); } @@ -2043,23 +2131,22 @@ TF_BUILTIN(MapIteratorPrototypeNext, CollectionsBuiltinsAssembler) { } TF_BUILTIN(SetPrototypeHas, CollectionsBuiltinsAssembler) { - Node* const receiver = Parameter(Descriptor::kReceiver); - Node* const key = Parameter(Descriptor::kKey); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver)); + const TNode<Object> key = CAST(Parameter(Descriptor::kKey)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); ThrowIfNotInstanceType(context, receiver, JS_SET_TYPE, "Set.prototype.has"); - TNode<Object> const table = LoadObjectField(receiver, JSMap::kTableOffset); + TNode<Object> const table = + LoadObjectField(CAST(receiver), JSMap::kTableOffset); - VARIABLE(entry_start_position, MachineType::PointerRepresentation(), - IntPtrConstant(0)); - VARIABLE(result, MachineRepresentation::kTaggedSigned, IntPtrConstant(0)); + TVARIABLE(IntPtrT, entry_start_position, IntPtrConstant(0)); Label if_key_smi(this), if_key_string(this), if_key_heap_number(this), if_key_bigint(this), entry_found(this), not_found(this), done(this); GotoIf(TaggedIsSmi(key), &if_key_smi); - TNode<Map> key_map = LoadMap(key); + TNode<Map> key_map = LoadMap(CAST(key)); TNode<Uint16T> key_instance_type = LoadMapInstanceType(key_map); GotoIf(IsStringInstanceType(key_instance_type), &if_key_string); @@ -2067,30 +2154,34 @@ TF_BUILTIN(SetPrototypeHas, CollectionsBuiltinsAssembler) { GotoIf(IsBigIntInstanceType(key_instance_type), &if_key_bigint); FindOrderedHashTableEntryForOtherKey<OrderedHashSet>( - context, table, key, &entry_start_position, &entry_found, ¬_found); + CAST(table), CAST(key), &entry_start_position, &entry_found, ¬_found); BIND(&if_key_smi); { FindOrderedHashTableEntryForSmiKey<OrderedHashSet>( - table, key, &entry_start_position, &entry_found, ¬_found); + CAST(table), CAST(key), &entry_start_position, &entry_found, + ¬_found); } BIND(&if_key_string); { FindOrderedHashTableEntryForStringKey<OrderedHashSet>( - context, table, key, &entry_start_position, &entry_found, ¬_found); + CAST(table), CAST(key), &entry_start_position, &entry_found, + ¬_found); } BIND(&if_key_heap_number); { FindOrderedHashTableEntryForHeapNumberKey<OrderedHashSet>( - context, table, key, &entry_start_position, &entry_found, ¬_found); + CAST(table), CAST(key), &entry_start_position, &entry_found, + ¬_found); } BIND(&if_key_bigint); { FindOrderedHashTableEntryForBigIntKey<OrderedHashSet>( - context, table, key, &entry_start_position, &entry_found, ¬_found); + CAST(table), CAST(key), &entry_start_position, &entry_found, + ¬_found); } BIND(&entry_found); @@ -2101,29 +2192,30 @@ TF_BUILTIN(SetPrototypeHas, CollectionsBuiltinsAssembler) { } TF_BUILTIN(SetPrototypeEntries, CollectionsBuiltinsAssembler) { - Node* const receiver = Parameter(Descriptor::kReceiver); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); ThrowIfNotInstanceType(context, receiver, JS_SET_TYPE, "Set.prototype.entries"); Return(AllocateJSCollectionIterator<JSSetIterator>( - context, Context::SET_KEY_VALUE_ITERATOR_MAP_INDEX, receiver)); + context, Context::SET_KEY_VALUE_ITERATOR_MAP_INDEX, CAST(receiver))); } TF_BUILTIN(SetPrototypeGetSize, CollectionsBuiltinsAssembler) { - Node* const receiver = Parameter(Descriptor::kReceiver); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); ThrowIfNotInstanceType(context, receiver, JS_SET_TYPE, "get Set.prototype.size"); TNode<OrderedHashSet> const table = - CAST(LoadObjectField(receiver, JSSet::kTableOffset)); + LoadObjectField<OrderedHashSet>(CAST(receiver), JSSet::kTableOffset); Return(LoadObjectField(table, OrderedHashSet::NumberOfElementsOffset())); } TF_BUILTIN(SetPrototypeForEach, CollectionsBuiltinsAssembler) { const char* const kMethodName = "Set.prototype.forEach"; - Node* const argc = Parameter(Descriptor::kJSActualArgumentsCount); - Node* const context = Parameter(Descriptor::kContext); - CodeStubArguments args(this, ChangeInt32ToIntPtr(argc)); + TNode<Int32T> argc = + UncheckedCast<Int32T>(Parameter(Descriptor::kJSActualArgumentsCount)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); + CodeStubArguments args(this, argc); TNode<Object> const receiver = args.GetReceiver(); TNode<Object> const callback = args.GetOptionalArgumentValue(0); TNode<Object> const this_arg = args.GetOptionalArgumentValue(1); @@ -2146,12 +2238,12 @@ TF_BUILTIN(SetPrototypeForEach, CollectionsBuiltinsAssembler) { // the {receiver} while we're iterating. TNode<IntPtrT> index = var_index.value(); TNode<OrderedHashSet> table = var_table.value(); - std::tie(table, index) = - Transition<OrderedHashSet>(table, index, [](Node*, Node*) {}); + std::tie(table, index) = Transition<OrderedHashSet>( + table, index, [](const TNode<OrderedHashSet>, const TNode<IntPtrT>) {}); // Read the next entry from the {table}, skipping holes. - Node* entry_key; - Node* entry_start_position; + TNode<Object> entry_key; + TNode<IntPtrT> entry_start_position; std::tie(entry_key, entry_start_position, index) = NextSkipHoles<OrderedHashSet>(table, index, &done_loop); @@ -2176,23 +2268,24 @@ TF_BUILTIN(SetPrototypeForEach, CollectionsBuiltinsAssembler) { } TF_BUILTIN(SetPrototypeValues, CollectionsBuiltinsAssembler) { - Node* const receiver = Parameter(Descriptor::kReceiver); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); ThrowIfNotInstanceType(context, receiver, JS_SET_TYPE, "Set.prototype.values"); Return(AllocateJSCollectionIterator<JSSetIterator>( - context, Context::SET_VALUE_ITERATOR_MAP_INDEX, receiver)); + context, Context::SET_VALUE_ITERATOR_MAP_INDEX, CAST(receiver))); } TF_BUILTIN(SetIteratorPrototypeNext, CollectionsBuiltinsAssembler) { const char* const kMethodName = "Set Iterator.prototype.next"; - Node* const receiver = Parameter(Descriptor::kReceiver); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); // Ensure that the {receiver} is actually a JSSetIterator. Label if_receiver_valid(this), if_receiver_invalid(this, Label::kDeferred); GotoIf(TaggedIsSmi(receiver), &if_receiver_invalid); - TNode<Uint16T> const receiver_instance_type = LoadInstanceType(receiver); + TNode<Uint16T> const receiver_instance_type = + LoadInstanceType(CAST(receiver)); GotoIf(InstanceTypeEqual(receiver_instance_type, JS_SET_VALUE_ITERATOR_TYPE), &if_receiver_valid); Branch( @@ -2204,8 +2297,8 @@ TF_BUILTIN(SetIteratorPrototypeNext, CollectionsBuiltinsAssembler) { BIND(&if_receiver_valid); // Check if the {receiver} is exhausted. - VARIABLE(var_done, MachineRepresentation::kTagged, TrueConstant()); - VARIABLE(var_value, MachineRepresentation::kTagged, UndefinedConstant()); + TVARIABLE(Oddball, var_done, TrueConstant()); + TVARIABLE(Object, var_value, UndefinedConstant()); Label return_value(this, {&var_done, &var_value}), return_entry(this), return_end(this, Label::kDeferred); @@ -2216,14 +2309,14 @@ TF_BUILTIN(SetIteratorPrototypeNext, CollectionsBuiltinsAssembler) { TransitionAndUpdate<JSSetIterator, OrderedHashSet>(CAST(receiver)); // Read the next entry from the {table}, skipping holes. - Node* entry_key; - Node* entry_start_position; + TNode<Object> entry_key; + TNode<IntPtrT> entry_start_position; std::tie(entry_key, entry_start_position, index) = NextSkipHoles<OrderedHashSet>(table, index, &return_end); StoreObjectFieldNoWriteBarrier(receiver, JSSetIterator::kIndexOffset, SmiTag(index)); - var_value.Bind(entry_key); - var_done.Bind(FalseConstant()); + var_value = entry_key; + var_done = FalseConstant(); // Check how to return the {key} (depending on {receiver} type). Branch(InstanceTypeEqual(receiver_instance_type, JS_SET_VALUE_ITERATOR_TYPE), @@ -2231,8 +2324,8 @@ TF_BUILTIN(SetIteratorPrototypeNext, CollectionsBuiltinsAssembler) { BIND(&return_entry); { - Node* result = AllocateJSIteratorResultForEntry(context, var_value.value(), - var_value.value()); + TNode<JSObject> result = AllocateJSIteratorResultForEntry( + context, var_value.value(), var_value.value()); Return(result); } @@ -2253,14 +2346,14 @@ TF_BUILTIN(SetIteratorPrototypeNext, CollectionsBuiltinsAssembler) { template <typename CollectionType> void CollectionsBuiltinsAssembler::TryLookupOrderedHashTableIndex( - Node* const table, Node* const key, Node* const context, Variable* result, - Label* if_entry_found, Label* if_not_found) { + const TNode<CollectionType> table, const TNode<Object> key, + TVariable<IntPtrT>* result, Label* if_entry_found, Label* if_not_found) { Label if_key_smi(this), if_key_string(this), if_key_heap_number(this), if_key_bigint(this); GotoIf(TaggedIsSmi(key), &if_key_smi); - TNode<Map> key_map = LoadMap(key); + TNode<Map> key_map = LoadMap(CAST(key)); TNode<Uint16T> key_instance_type = LoadMapInstanceType(key_map); GotoIf(IsStringInstanceType(key_instance_type), &if_key_string); @@ -2268,44 +2361,42 @@ void CollectionsBuiltinsAssembler::TryLookupOrderedHashTableIndex( GotoIf(IsBigIntInstanceType(key_instance_type), &if_key_bigint); FindOrderedHashTableEntryForOtherKey<CollectionType>( - context, table, key, result, if_entry_found, if_not_found); + table, CAST(key), result, if_entry_found, if_not_found); BIND(&if_key_smi); { FindOrderedHashTableEntryForSmiKey<CollectionType>( - table, key, result, if_entry_found, if_not_found); + table, CAST(key), result, if_entry_found, if_not_found); } BIND(&if_key_string); { FindOrderedHashTableEntryForStringKey<CollectionType>( - context, table, key, result, if_entry_found, if_not_found); + table, CAST(key), result, if_entry_found, if_not_found); } BIND(&if_key_heap_number); { FindOrderedHashTableEntryForHeapNumberKey<CollectionType>( - context, table, key, result, if_entry_found, if_not_found); + table, CAST(key), result, if_entry_found, if_not_found); } BIND(&if_key_bigint); { FindOrderedHashTableEntryForBigIntKey<CollectionType>( - context, table, key, result, if_entry_found, if_not_found); + table, CAST(key), result, if_entry_found, if_not_found); } } TF_BUILTIN(FindOrderedHashMapEntry, CollectionsBuiltinsAssembler) { - Node* const table = Parameter(Descriptor::kTable); - Node* const key = Parameter(Descriptor::kKey); - Node* const context = Parameter(Descriptor::kContext); + const TNode<OrderedHashMap> table = CAST(Parameter(Descriptor::kTable)); + const TNode<Object> key = CAST(Parameter(Descriptor::kKey)); - VARIABLE(entry_start_position, MachineType::PointerRepresentation(), - IntPtrConstant(0)); + TVARIABLE(IntPtrT, entry_start_position, IntPtrConstant(0)); Label entry_found(this), not_found(this); TryLookupOrderedHashTableIndex<OrderedHashMap>( - table, key, context, &entry_start_position, &entry_found, ¬_found); + table, key, &entry_start_position, &entry_found, ¬_found); BIND(&entry_found); Return(SmiTag(entry_start_position.value())); @@ -2324,8 +2415,8 @@ class WeakCollectionsBuiltinsAssembler : public BaseCollectionsAssembler { TNode<Object> key, TNode<Object> value, TNode<IntPtrT> number_of_elements); - TNode<Object> AllocateTable(Variant variant, TNode<Context> context, - TNode<IntPtrT> at_least_space_for) override; + TNode<HeapObject> AllocateTable(Variant variant, + TNode<IntPtrT> at_least_space_for) override; // Generates and sets the identity for a JSRececiver. TNode<Smi> CreateIdentityHash(TNode<Object> receiver); @@ -2390,9 +2481,8 @@ void WeakCollectionsBuiltinsAssembler::AddEntry( SmiFromIntPtr(number_of_elements), SKIP_WRITE_BARRIER); } -TNode<Object> WeakCollectionsBuiltinsAssembler::AllocateTable( - Variant variant, TNode<Context> context, - TNode<IntPtrT> at_least_space_for) { +TNode<HeapObject> WeakCollectionsBuiltinsAssembler::AllocateTable( + Variant variant, TNode<IntPtrT> at_least_space_for) { // See HashTable::New(). CSA_ASSERT(this, IntPtrLessThanOrEqual(IntPtrConstant(0), at_least_space_for)); @@ -2446,8 +2536,7 @@ TNode<IntPtrT> WeakCollectionsBuiltinsAssembler::FindKeyIndex( TVARIABLE(IntPtrT, var_entry, WordAnd(key_hash, entry_mask)); TVARIABLE(IntPtrT, var_count, IntPtrConstant(0)); - Variable* loop_vars[] = {&var_count, &var_entry}; - Label loop(this, arraysize(loop_vars), loop_vars), if_found(this); + Label loop(this, {&var_count, &var_entry}), if_found(this); Goto(&loop); BIND(&loop); TNode<IntPtrT> key_index; @@ -2631,9 +2720,9 @@ TF_BUILTIN(WeakMapLookupHashIndex, WeakCollectionsBuiltinsAssembler) { } TF_BUILTIN(WeakMapGet, WeakCollectionsBuiltinsAssembler) { - Node* const receiver = Parameter(Descriptor::kReceiver); - Node* const key = Parameter(Descriptor::kKey); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver)); + const TNode<Object> key = CAST(Parameter(Descriptor::kKey)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); Label return_undefined(this); @@ -2653,9 +2742,9 @@ TF_BUILTIN(WeakMapGet, WeakCollectionsBuiltinsAssembler) { } TF_BUILTIN(WeakMapPrototypeHas, WeakCollectionsBuiltinsAssembler) { - Node* const receiver = Parameter(Descriptor::kReceiver); - Node* const key = Parameter(Descriptor::kKey); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver)); + const TNode<Object> key = CAST(Parameter(Descriptor::kKey)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); Label return_false(this); @@ -2817,9 +2906,9 @@ TF_BUILTIN(WeakSetPrototypeDelete, CodeStubAssembler) { } TF_BUILTIN(WeakSetPrototypeHas, WeakCollectionsBuiltinsAssembler) { - Node* const receiver = Parameter(Descriptor::kReceiver); - Node* const key = Parameter(Descriptor::kKey); - Node* const context = Parameter(Descriptor::kContext); + const TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver)); + const TNode<Object> key = CAST(Parameter(Descriptor::kKey)); + const TNode<Context> context = CAST(Parameter(Descriptor::kContext)); Label return_false(this); |