uint32_t f = flags(kRelaxedLoad);

f = FastIterableBits::update(f, value);

set_flags(f, kRelaxedStore);

FastIterableState if_value) {

uint32_t f = flags(kRelaxedLoad);

if (FastIterableBits::decode(f) == if_value) {

f = FastIterableBits::update(f, new_value);

set_flags(f, kRelaxedStore);

}

bool concurrent_search) {

DCHECK(IsUniqueName(name));

SLOW_DCHECK_IMPLIES(!concurrent_search, IsSortedNoDuplicates());

if (valid_descriptors == 0) {

return InternalIndex::NotFound();

}

if (valid_descriptors <= kMaxElementsForLinearSearch || concurrent_search) {

return LinearSearch(name, valid_descriptors);

}

return BinarySearch(name, valid_descriptors);

int valid_descriptors) {

// We have to binary search all descriptors, not just valid ones, since the

// binary search ordering is across all descriptors.

int end = number_of_descriptors();

// Binary search must not be used for small number of descriptors since

// the descriptor array is not sorted yet.

DCHECK_LT(kMaxElementsForLinearSearch, end);

uint32_t hash = name->hash();

// Find the first descriptor whose key's hash is greater-than-or-equal-to the

// search hash.

int number = *std::ranges::lower_bound(std::views::iota(0, end), hash,

std::less<>(), [&](int i) {

Tagged<Name> entry = GetSortedKey(i);

return entry->hash();

});

// There may have been hash collisions, so search for the name from the first

// index until the first non-matching hash.

for (; number < end; ++number) {

InternalIndex index(GetSortedKeyIndex(number));

Tagged<Name> entry = GetKey(index);

if (entry == name) {

// If we found the entry, but it's outside the owned descriptors of the

// caller, return not found.

if (index.as_int() >= valid_descriptors) {

return InternalIndex::NotFound();

}

return index;

}

if (entry->hash() != hash) {

return InternalIndex::NotFound();

}

}

return InternalIndex::NotFound();

int valid_descriptors) {

DCHECK_LE(valid_descriptors, number_of_descriptors());

for (int i = 0; i < valid_descriptors; ++i) {

InternalIndex index(i);

if (GetKey(index) == name) return index;

}

return InternalIndex::NotFound();

bool concurrent_search) {

DCHECK(IsUniqueName(name));

int number_of_own_descriptors = map->NumberOfOwnDescriptors();

if (number_of_own_descriptors == 0) return InternalIndex::NotFound();

return Search(name, number_of_own_descriptors, concurrent_search);

for (int desc_index = field_index; desc_index < valid_descriptors;

++desc_index) {

PropertyDetails details = GetDetails(InternalIndex(desc_index));

if (details.location() != PropertyLocation::kField) continue;

if (field_index == details.field_index()) {

return InternalIndex(desc_index);

}

DCHECK_LT(details.field_index(), field_index);

}

return InternalIndex::NotFound();

int number_of_own_descriptors = map->NumberOfOwnDescriptors();

if (number_of_own_descriptors == 0) return InternalIndex::NotFound();

return Search(field_index, number_of_own_descriptors);

Tagged<Name> name,

Tagged<Map> map) {

DCHECK(IsUniqueName(name));

int number_of_own_descriptors = map->NumberOfOwnDescriptors();

if (number_of_own_descriptors == 0) return InternalIndex::NotFound();

DescriptorLookupCache* cache = isolate->descriptor_lookup_cache();

int number = cache->Lookup(map, name);

if (number == DescriptorLookupCache::kAbsent) {

InternalIndex result = Search(name, number_of_own_descriptors);

number = result.is_found() ? result.as_int() : DescriptorArray::kNotFound;

cache->Update(map, name, number);

}

if (number == DescriptorArray::kNotFound) return InternalIndex::NotFound();

return InternalIndex(number);

static_assert(kEndOfStrongFieldsOffset == kStartOfWeakFieldsOffset,

"Weak and strong fields are continuous.");

static_assert(kEndOfWeakFieldsOffset == kHeaderSize,

"Weak fields extend up to the end of the header.");

return RawField(DescriptorArray::kStartOfStrongFieldsOffset);

// Allow descriptor == number_of_all_descriptors() for computing the slot

// address that comes after the last descriptor (for iterating).

DCHECK_LE(descriptor, number_of_all_descriptors());

return RawField(OffsetOfDescriptorAt(descriptor));

InternalIndex descriptor_number) const {

DCHECK_LT(descriptor_number.as_int(), number_of_descriptors());

int entry_offset = OffsetOfDescriptorAt(descriptor_number.as_int());

PtrComprCageBase cage_base = GetPtrComprCageBase(*this);

Tagged<Object> maybe_name =

EntryKeyField::Relaxed_Load(cage_base, *this, entry_offset);

bool is_initialized = !IsUndefined(maybe_name);

DCHECK_IMPLIES(is_initialized,

IsSmi(EntryDetailsField::Relaxed_Load(*this, entry_offset)));

return is_initialized;

InternalIndex descriptor_number) const {

DCHECK_LT(descriptor_number.as_int(), number_of_descriptors());

int entry_offset = OffsetOfDescriptorAt(descriptor_number.as_int());

return Cast<Name>(

EntryKeyField::Relaxed_Load(cage_base, *this, entry_offset));

Tagged<Name> key) {

DCHECK_LT(descriptor_number.as_int(), number_of_descriptors());

int entry_offset = OffsetOfDescriptorAt(descriptor_number.as_int());

EntryKeyField::Relaxed_Store(*this, entry_offset, key);

WRITE_BARRIER(*this, entry_offset + kEntryKeyOffset, key);

// Conservatively assume that the new key might break fast iteration.

// If the key was already known to be slow, it will stay slow.

set_fast_iterable_if(FastIterableState::kUnknown,

FastIterableState::kJsonFast);

InternalIndex descriptor_number) {

PtrComprCageBase cage_base = GetPtrComprCageBase(*this);

return Cast<Object>(GetStrongValue(cage_base, descriptor_number));

Tagged<MaybeObject> value) {

DCHECK_LT(descriptor_number.as_int(), number_of_descriptors());

int entry_offset = OffsetOfDescriptorAt(descriptor_number.as_int());

EntryValueField::Relaxed_Store(*this, entry_offset, value);

WRITE_BARRIER(*this, entry_offset + kEntryValueOffset, value);

InternalIndex descriptor_number) {

DCHECK_LT(descriptor_number.as_int(), number_of_descriptors());

int entry_offset = OffsetOfDescriptorAt(descriptor_number.as_int());

return EntryValueField::Relaxed_Load(cage_base, *this, entry_offset);

DCHECK_LT(descriptor_number.as_int(), number_of_descriptors());

int entry_offset = OffsetOfDescriptorAt(descriptor_number.as_int());

Tagged<Smi> details = EntryDetailsField::Relaxed_Load(*this, entry_offset);

return PropertyDetails(details);

PropertyDetails details) {

DCHECK_LT(descriptor_number.as_int(), number_of_descriptors());

int entry_offset = OffsetOfDescriptorAt(descriptor_number.as_int());

EntryDetailsField::Relaxed_Store(*this, entry_offset, details.AsSmi());

// Note: fast_iteration depends on PropertyDetails::location().

// However we don't reset it here as all path either go through SetKey(),

// which invalidates fast_iteration, or don't change the location

// (GeneralizeAllFields()).

InternalIndex descriptor_number) {

PtrComprCageBase cage_base = GetPtrComprCageBase(*this);

return GetFieldType(cage_base, descriptor_number);

PtrComprCageBase cage_base, InternalIndex descriptor_number) {

DCHECK_EQ(GetDetails(descriptor_number).location(), PropertyLocation::kField);

Tagged<MaybeObject> wrapped_type = GetValue(cage_base, descriptor_number);

return Map::UnwrapFieldType(wrapped_type);

Tagged<MaybeObject> value, PropertyDetails details) {

CHECK_LT(descriptor_number.as_int(), number_of_descriptors());

SetKey(descriptor_number, key);

SetDetails(descriptor_number, details);

SetValue(descriptor_number, value);

// Resetting the fast iterable state is bottlenecked in SetKey().

DCHECK_NE(fast_iterable(), FastIterableState::kJsonFast);

Tagged<Name> key = *desc->GetKey();

Tagged<MaybeObject> value = *desc->GetValue();

Set(descriptor_number, key, value, desc->GetDetails());

// Resetting the fast iterable state is bottlenecked in SetKey().

DCHECK_NE(fast_iterable(), FastIterableState::kJsonFast);

DisallowGarbageCollection no_gc;

int descriptor_number = number_of_descriptors();

int new_number_of_descriptors = descriptor_number + 1;

DCHECK_LE(new_number_of_descriptors, number_of_all_descriptors());

set_number_of_descriptors(new_number_of_descriptors);

Set(InternalIndex(descriptor_number), desc);

// Resetting the fast iterable state is bottlenecked in SetKey().

DCHECK_NE(fast_iterable(), FastIterableState::kJsonFast);

if (new_number_of_descriptors <= kMaxElementsForLinearSearch) {

// Ensure there are no name collisions.

CHECK_EQ(LinearSearch(*desc->GetKey(), descriptor_number),

InternalIndex::NotFound());

return;

} else if (new_number_of_descriptors == kMaxElementsForLinearSearch + 1) {

// Sort descriptors as we've just crossed the unsorted-sorted boundary.

SortImpl(new_number_of_descriptors);

uint32_t desc_hash = desc->GetKey()->hash();

CheckNameCollisionDuringInsertion(desc, desc_hash,

desc->GetSortedKeyIndex());

return;

}

uint32_t desc_hash = desc->GetKey()->hash();

// Hash value can't be zero, see String::ComputeAndSetHash()

uint32_t collision_hash = 0;

int insertion;

for (insertion = descriptor_number; insertion > 0; --insertion) {

Tagged<Name> key = GetSortedKey(insertion - 1);

collision_hash = key->hash();

if (collision_hash <= desc_hash) break;

SetSortedKey(insertion, GetSortedKeyIndex(insertion - 1));

}

SetSortedKey(insertion, descriptor_number);

if (V8_LIKELY(collision_hash != desc_hash)) return;

CheckNameCollisionDuringInsertion(desc, desc_hash, insertion);

const int len = number_of_descriptors();

// Sorting matters only for binary search.

if (len <= kMaxElementsForLinearSearch) return;

SortImpl(len);

int first_key = GetSortedKeyIndex(first);

SetSortedKey(first, GetSortedKeyIndex(second));

SetSortedKey(second, first_key);

unsigned gc_epoch, Tagged<DescriptorArray> array,

DescriptorIndex index_to_mark) {

const auto current_epoch = gc_epoch & Epoch::kMask;

while (true) {

const RawGCStateType raw_gc_state = array->raw_gc_state(kRelaxedLoad);

const auto epoch_from_state = Epoch::decode(raw_gc_state);

RawGCStateType new_raw_gc_state = 0;

if (current_epoch != epoch_from_state) {

// If the epochs do not match, then either the raw_gc_state is zero

// (freshly allocated descriptor array) or the epoch from value lags

// by 1.

DCHECK_IMPLIES(raw_gc_state != 0,

Epoch::decode(epoch_from_state + 1) == current_epoch);

new_raw_gc_state = NewState(current_epoch, 0, index_to_mark);

} else {

const DescriptorIndex already_marked = Marked::decode(raw_gc_state);

const DescriptorIndex delta = Delta::decode(raw_gc_state);

if ((already_marked + delta) >= index_to_mark) {

return false;

}

new_raw_gc_state = NewState(current_epoch, already_marked,

index_to_mark - already_marked);

}

if (SwapState(array, raw_gc_state, new_raw_gc_state)) {

return true;

}

}

unsigned gc_epoch, Tagged<DescriptorArray> array) {

const auto current_epoch = gc_epoch & Epoch::kMask;

while (true) {

const RawGCStateType raw_gc_state = array->raw_gc_state(kRelaxedLoad);

const DescriptorIndex marked = Marked::decode(raw_gc_state);

const DescriptorIndex delta = Delta::decode(raw_gc_state);

// We may encounter an array here that was merely pushed to the marker. In

// such a case, we process all descriptors (if we succeed). The cases to

// check are:

// 1. Epoch mismatch: Happens when descriptors survive a GC cycle.

// 2. Epoch matches but marked/delta is 0: Can happen when descriptors are

// newly allocated in the current cycle.

if (current_epoch != Epoch::decode(raw_gc_state) || (marked + delta) == 0) {

// In case number of descriptors is 0 and we reach the array through roots

// marking, mark also slack to get a proper transition from 0 marked to X

// marked. Otherwise, we would need to treat the state [0,0[ for marked

// and delta as valid state which leads to double-accounting through the

// marking barrier (when nof>1 in the barrier).

const int16_t number_of_descriptors =

array->number_of_descriptors() ? array->number_of_descriptors()

: array->number_of_all_descriptors();

DCHECK_GT(number_of_descriptors, 0);

if (SwapState(array, raw_gc_state,

NewState(current_epoch, number_of_descriptors, 0))) {

return {0, number_of_descriptors};

}

continue;

}

// The delta is 0, so everything has been processed. Return the marked

// indices.

if (delta == 0) {

return {marked, marked};

}

if (SwapState(array, raw_gc_state,

NewState(current_epoch, marked + delta, 0))) {

return {marked, marked + delta};

}

}