Skip to content

V
V8
Commit 5d29947d authored by Jakob Kummerow's avatar Jakob Kummerow Committed by Commit Bot
Browse files
Options

Update elements.cc to use size_t for index/length 

Bug: v8:4153
Change-Id: I036b3f464a635414e050972cee2dffbf3b44cafd
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1918250
Commit-Queue: Jakob Kummerow <jkummerow@chromium.org>
Reviewed-by: 's avatarIgor Sheludko <ishell@chromium.org>
Cr-Commit-Position: refs/heads/master@{#65164}
parent 3fdfcb82
Hide whitespace changes
Inline Side-by-side
Showing with 238 additions and 296 deletions
src/builtins/builtins-typed-array.cc
View file @ 5d29947d
......@@ -154,9 +154,7 @@ BUILTIN(TypedArrayPrototypeFill) {
DCHECK_LE(end, len);
DCHECK_LE(count, len);
return ElementsAccessor::ForKind(kind)->Fill(array, obj_value,
static_cast<uint32_t>(start),
static_cast<uint32_t>(end));
return ElementsAccessor::ForKind(kind)->Fill(array, obj_value, start, end);
}
BUILTIN(TypedArrayPrototypeIncludes) {
......@@ -186,9 +184,8 @@ BUILTIN(TypedArrayPrototypeIncludes) {
Handle<Object> search_element = args.atOrUndefined(isolate, 1);
ElementsAccessor* elements = array->GetElementsAccessor();
Maybe<bool> result = elements->IncludesValue(isolate, array, search_element,
static_cast<uint32_t>(index),
static_cast<uint32_t>(len));
Maybe<bool> result =
elements->IncludesValue(isolate, array, search_element, index, len);
MAYBE_RETURN(result, ReadOnlyRoots(isolate).exception());
return *isolate->factory()->ToBoolean(result.FromJust());
}
......@@ -217,9 +214,8 @@ BUILTIN(TypedArrayPrototypeIndexOf) {
Handle<Object> search_element = args.atOrUndefined(isolate, 1);
ElementsAccessor* elements = array->GetElementsAccessor();
Maybe<int64_t> result = elements->IndexOfValue(isolate, array, search_element,
static_cast<uint32_t>(index),
static_cast<uint32_t>(len));
Maybe<int64_t> result =
elements->IndexOfValue(isolate, array, search_element, index, len);
MAYBE_RETURN(result, ReadOnlyRoots(isolate).exception());
return *isolate->factory()->NewNumberFromInt64(result.FromJust());
}
......@@ -252,8 +248,8 @@ BUILTIN(TypedArrayPrototypeLastIndexOf) {
Handle<Object> search_element = args.atOrUndefined(isolate, 1);
ElementsAccessor* elements = array->GetElementsAccessor();
Maybe<int64_t> result = elements->LastIndexOfValue(
array, search_element, static_cast<uint32_t>(index));
Maybe<int64_t> result =
elements->LastIndexOfValue(array, search_element, index);
MAYBE_RETURN(result, ReadOnlyRoots(isolate).exception());
return *isolate->factory()->NewNumberFromInt64(result.FromJust());
}
......
src/objects/elements.cc
View file @ 5d29947d
......@@ -468,10 +468,10 @@ void SortIndices(Isolate* isolate, Handle<FixedArray> indices,
}
Maybe<bool> IncludesValueSlowPath(Isolate* isolate, Handle<JSObject> receiver,
Handle<Object> value, uint32_t start_from,
uint32_t length) {
Handle<Object> value, size_t start_from,
size_t length) {
bool search_for_hole = value->IsUndefined(isolate);
for (uint32_t k = start_from; k < length; ++k) {
for (size_t k = start_from; k < length; ++k) {
LookupIterator it(isolate, receiver, k);
if (!it.IsFound()) {
if (search_for_hole) return Just(true);
......@@ -488,9 +488,9 @@ Maybe<bool> IncludesValueSlowPath(Isolate* isolate, Handle<JSObject> receiver,
}
Maybe<int64_t> IndexOfValueSlowPath(Isolate* isolate, Handle<JSObject> receiver,
Handle<Object> value, uint32_t start_from,
uint32_t length) {
for (uint32_t k = start_from; k < length; ++k) {
Handle<Object> value, size_t start_from,
size_t length) {
for (size_t k = start_from; k < length; ++k) {
LookupIterator it(isolate, receiver, k);
if (!it.IsFound()) {
continue;
......@@ -512,7 +512,7 @@ class InternalElementsAccessor : public ElementsAccessor {
public:
InternalIndex GetEntryForIndex(Isolate* isolate, JSObject holder,
FixedArrayBase backing_store,
uint32_t index) override = 0;
size_t index) override = 0;
PropertyDetails GetDetails(JSObject holder, InternalIndex entry) override = 0;
};
......@@ -571,27 +571,13 @@ class ElementsAccessorBase : public InternalElementsAccessor {
Subclass::ValidateImpl(holder);
}
static bool IsPackedImpl(JSObject holder, FixedArrayBase backing_store,
uint32_t start, uint32_t end) {
DisallowHeapAllocation no_gc;
if (IsFastPackedElementsKind(kind())) return true;
Isolate* isolate = holder.GetIsolate();
for (uint32_t i = start; i < end; i++) {
if (!Subclass::HasElementImpl(isolate, holder, i, backing_store,
ALL_PROPERTIES)) {
return false;
}
}
return true;
}
bool HasElement(JSObject holder, uint32_t index, FixedArrayBase backing_store,
PropertyFilter filter) final {
return Subclass::HasElementImpl(holder.GetIsolate(), holder, index,
backing_store, filter);
}
static bool HasElementImpl(Isolate* isolate, JSObject holder, uint32_t index,
static bool HasElementImpl(Isolate* isolate, JSObject holder, size_t index,
FixedArrayBase backing_store,
PropertyFilter filter = ALL_PROPERTIES) {
return Subclass::GetEntryForIndexImpl(isolate, holder, backing_store, index,
......@@ -628,8 +614,8 @@ class ElementsAccessorBase : public InternalElementsAccessor {
static Handle<Object> GetImpl(Isolate* isolate, FixedArrayBase backing_store,
InternalIndex entry) {
uint32_t index = GetIndexForEntryImpl(backing_store, entry);
return handle(BackingStore::cast(backing_store).get(index), isolate);
return handle(BackingStore::cast(backing_store).get(entry.as_int()),
isolate);
}
void Set(Handle<JSObject> holder, InternalIndex entry, Object value) final {
......@@ -752,7 +738,7 @@ class ElementsAccessorBase : public InternalElementsAccessor {
JSObject::ValidateElements(*array);
}
uint32_t NumberOfElements(JSObject receiver) final {
size_t NumberOfElements(JSObject receiver) final {
return Subclass::NumberOfElementsImpl(receiver, receiver.elements());
}
......@@ -761,7 +747,7 @@ class ElementsAccessorBase : public InternalElementsAccessor {
UNREACHABLE();
}
static uint32_t GetMaxIndex(JSObject receiver, FixedArrayBase elements) {
static size_t GetMaxIndex(JSObject receiver, FixedArrayBase elements) {
if (receiver.IsJSArray()) {
DCHECK(JSArray::cast(receiver).length().IsSmi());
return static_cast<uint32_t>(
......@@ -770,8 +756,8 @@ class ElementsAccessorBase : public InternalElementsAccessor {
return Subclass::GetCapacityImpl(receiver, elements);
}
static uint32_t GetMaxNumberOfEntries(JSObject receiver,
FixedArrayBase elements) {
static size_t GetMaxNumberOfEntries(JSObject receiver,
FixedArrayBase elements) {
return Subclass::GetMaxIndex(receiver, elements);
}
......@@ -976,14 +962,14 @@ class ElementsAccessorBase : public InternalElementsAccessor {
}
Object CopyElements(Handle<Object> source, Handle<JSObject> destination,
size_t length, uint32_t offset) final {
size_t length, size_t offset) final {
return Subclass::CopyElementsHandleImpl(source, destination, length,
offset);
}
static Object CopyElementsHandleImpl(Handle<Object> source,
Handle<JSObject> destination,
size_t length, uint32_t offset) {
size_t length, size_t offset) {
UNREACHABLE();
}
......@@ -1087,15 +1073,15 @@ class ElementsAccessorBase : public InternalElementsAccessor {
KeyAccumulator* keys) {
DCHECK_NE(DICTIONARY_ELEMENTS, kind());
// Non-dictionary elements can't have all-can-read accessors.
uint32_t length = Subclass::GetMaxIndex(*object, *backing_store);
size_t length = Subclass::GetMaxIndex(*object, *backing_store);
PropertyFilter filter = keys->filter();
Isolate* isolate = keys->isolate();
Factory* factory = isolate->factory();
for (uint32_t i = 0; i < length; i++) {
for (size_t i = 0; i < length; i++) {
if (Subclass::HasElementImpl(isolate, *object, i, *backing_store,
filter)) {
RETURN_FAILURE_IF_NOT_SUCCESSFUL(
keys->AddKey(factory->NewNumberFromUint(i)));
keys->AddKey(factory->NewNumberFromSize(i)));
}
}
return ExceptionStatus::kSuccess;
......@@ -1106,19 +1092,20 @@ class ElementsAccessorBase : public InternalElementsAccessor {
Handle<FixedArrayBase> backing_store, GetKeysConversion convert,
PropertyFilter filter, Handle<FixedArray> list, uint32_t* nof_indices,
uint32_t insertion_index = 0) {
uint32_t length = Subclass::GetMaxIndex(*object, *backing_store);
size_t length = Subclass::GetMaxIndex(*object, *backing_store);
uint32_t const kMaxStringTableEntries =
isolate->heap()->MaxNumberToStringCacheSize();
for (uint32_t i = 0; i < length; i++) {
for (size_t i = 0; i < length; i++) {
if (Subclass::HasElementImpl(isolate, *object, i, *backing_store,
filter)) {
if (convert == GetKeysConversion::kConvertToString) {
bool use_cache = i < kMaxStringTableEntries;
Handle<String> index_string =
isolate->factory()->Uint32ToString(i, use_cache);
isolate->factory()->SizeToString(i, use_cache);
list->set(insertion_index, *index_string);
} else {
list->set(insertion_index, Smi::FromInt(i));
Handle<Object> number = isolate->factory()->NewNumberFromSize(i);
list->set(insertion_index, *number);
}
insertion_index++;
}
......@@ -1141,19 +1128,19 @@ class ElementsAccessorBase : public InternalElementsAccessor {
PropertyFilter filter) {
Isolate* isolate = object->GetIsolate();
uint32_t nof_property_keys = keys->length();
uint32_t initial_list_length =
size_t initial_list_length =
Subclass::GetMaxNumberOfEntries(*object, *backing_store);
initial_list_length += nof_property_keys;
if (initial_list_length > FixedArray::kMaxLength ||
initial_list_length < nof_property_keys) {
if (initial_list_length > FixedArray::kMaxLength - nof_property_keys) {
return isolate->Throw<FixedArray>(isolate->factory()->NewRangeError(
MessageTemplate::kInvalidArrayLength));
}
initial_list_length += nof_property_keys;
// Collect the element indices into a new list.
MaybeHandle<FixedArray> raw_array =
isolate->factory()->TryNewFixedArray(initial_list_length);
DCHECK_LE(initial_list_length, std::numeric_limits<int>::max());
MaybeHandle<FixedArray> raw_array = isolate->factory()->TryNewFixedArray(
static_cast<int>(initial_list_length));
Handle<FixedArray> combined_keys;
// If we have a holey backing store try to precisely estimate the backing
......@@ -1169,7 +1156,9 @@ class ElementsAccessorBase : public InternalElementsAccessor {
Subclass::NumberOfElementsImpl(*object, *backing_store);
initial_list_length += nof_property_keys;
}
combined_keys = isolate->factory()->NewFixedArray(initial_list_length);
DCHECK_LE(initial_list_length, std::numeric_limits<int>::max());
combined_keys = isolate->factory()->NewFixedArray(
static_cast<int>(initial_list_length));
}
uint32_t nof_indices = 0;
......@@ -1223,30 +1212,30 @@ class ElementsAccessorBase : public InternalElementsAccessor {
return backing_store.length();
}
uint32_t GetCapacity(JSObject holder, FixedArrayBase backing_store) final {
size_t GetCapacity(JSObject holder, FixedArrayBase backing_store) final {
return Subclass::GetCapacityImpl(holder, backing_store);
}
static Object FillImpl(Handle<JSObject> receiver, Handle<Object> obj_value,
uint32_t start, uint32_t end) {
size_t start, size_t end) {
UNREACHABLE();
}
Object Fill(Handle<JSObject> receiver, Handle<Object> obj_value,
uint32_t start, uint32_t end) override {
Object Fill(Handle<JSObject> receiver, Handle<Object> obj_value, size_t start,
size_t end) override {
return Subclass::FillImpl(receiver, obj_value, start, end);
}
static Maybe<bool> IncludesValueImpl(Isolate* isolate,
Handle<JSObject> receiver,
Handle<Object> value,
uint32_t start_from, uint32_t length) {
Handle<Object> value, size_t start_from,
size_t length) {
return IncludesValueSlowPath(isolate, receiver, value, start_from, length);
}
Maybe<bool> IncludesValue(Isolate* isolate, Handle<JSObject> receiver,
Handle<Object> value, uint32_t start_from,
uint32_t length) final {
Handle<Object> value, size_t start_from,
size_t length) final {
return Subclass::IncludesValueImpl(isolate, receiver, value, start_from,
length);
}
......@@ -1254,26 +1243,26 @@ class ElementsAccessorBase : public InternalElementsAccessor {
static Maybe<int64_t> IndexOfValueImpl(Isolate* isolate,
Handle<JSObject> receiver,
Handle<Object> value,
uint32_t start_from, uint32_t length) {
size_t start_from, size_t length) {
return IndexOfValueSlowPath(isolate, receiver, value, start_from, length);
}
Maybe<int64_t> IndexOfValue(Isolate* isolate, Handle<JSObject> receiver,
Handle<Object> value, uint32_t start_from,
uint32_t length) final {
Handle<Object> value, size_t start_from,
size_t length) final {
return Subclass::IndexOfValueImpl(isolate, receiver, value, start_from,
length);
}
static Maybe<int64_t> LastIndexOfValueImpl(Handle<JSObject> receiver,
Handle<Object> value,
uint32_t start_from) {
size_t start_from) {
UNREACHABLE();
}
Maybe<int64_t> LastIndexOfValue(Handle<JSObject> receiver,
Handle<Object> value,
uint32_t start_from) final {
size_t start_from) final {
return Subclass::LastIndexOfValueImpl(receiver, value, start_from);
}
......@@ -1281,21 +1270,18 @@ class ElementsAccessorBase : public InternalElementsAccessor {
void Reverse(JSObject receiver) final { Subclass::ReverseImpl(receiver); }
static uint32_t GetIndexForEntryImpl(FixedArrayBase backing_store,
InternalIndex entry) {
return entry.as_uint32();
}
static InternalIndex GetEntryForIndexImpl(Isolate* isolate, JSObject holder,
FixedArrayBase backing_store,
uint32_t index,
size_t index,
PropertyFilter filter) {
DCHECK(IsFastElementsKind(kind()) ||
IsAnyNonextensibleElementsKind(kind()));
uint32_t length = Subclass::GetMaxIndex(holder, backing_store);
size_t length = Subclass::GetMaxIndex(holder, backing_store);
if (IsHoleyElementsKindForRead(kind())) {
return index < length && !BackingStore::cast(backing_store)
.is_the_hole(isolate, index)
DCHECK_IMPLIES(index < length, index <= std::numeric_limits<int>::max());
return index < length &&
!BackingStore::cast(backing_store)
.is_the_hole(isolate, static_cast<int>(index))
? InternalIndex(index)
: InternalIndex::NotFound();
} else {
......@@ -1305,7 +1291,7 @@ class ElementsAccessorBase : public InternalElementsAccessor {
InternalIndex GetEntryForIndex(Isolate* isolate, JSObject holder,
FixedArrayBase backing_store,
uint32_t index) final {
size_t index) final {
return Subclass::GetEntryForIndexImpl(isolate, holder, backing_store, index,
ALL_PROPERTIES);
}
......@@ -1501,22 +1487,14 @@ class DictionaryElementsAccessor
return !index.IsTheHole(isolate);
}
static uint32_t GetIndexForEntryImpl(FixedArrayBase store,
InternalIndex entry) {
DisallowHeapAllocation no_gc;
NumberDictionary dict = NumberDictionary::cast(store);
uint32_t result = 0;
CHECK(dict.KeyAt(entry).ToArrayIndex(&result));
return result;
}
static InternalIndex GetEntryForIndexImpl(Isolate* isolate, JSObject holder,
FixedArrayBase store,
uint32_t index,
FixedArrayBase store, size_t index,
PropertyFilter filter) {
DisallowHeapAllocation no_gc;
NumberDictionary dictionary = NumberDictionary::cast(store);
InternalIndex entry = dictionary.FindEntry(isolate, index);
DCHECK_LE(index, std::numeric_limits<uint32_t>::max());
InternalIndex entry =
dictionary.FindEntry(isolate, static_cast<uint32_t>(index));
if (entry.is_not_found()) return entry;
if (filter != ALL_PROPERTIES) {
......@@ -1628,8 +1606,8 @@ class DictionaryElementsAccessor
}
static bool IncludesValueFastPath(Isolate* isolate, Handle<JSObject> receiver,
Handle<Object> value, uint32_t start_from,
uint32_t length, Maybe<bool>* result) {
Handle<Object> value, size_t start_from,
size_t length, Maybe<bool>* result) {
DisallowHeapAllocation no_gc;
NumberDictionary dictionary = NumberDictionary::cast(receiver->elements());
Object the_hole = ReadOnlyRoots(isolate).the_hole_value();
......@@ -1664,8 +1642,8 @@ class DictionaryElementsAccessor
static Maybe<bool> IncludesValueImpl(Isolate* isolate,
Handle<JSObject> receiver,
Handle<Object> value,
uint32_t start_from, uint32_t length) {
Handle<Object> value, size_t start_from,
size_t length) {
DCHECK(JSObject::PrototypeHasNoElements(isolate, *receiver));
bool search_for_hole = value->IsUndefined(isolate);
......@@ -1680,11 +1658,12 @@ class DictionaryElementsAccessor
USE(original_elements_kind);
Handle<NumberDictionary> dictionary(
NumberDictionary::cast(receiver->elements()), isolate);
// Iterate through entire range, as accessing elements out of order is
// observable
for (uint32_t k = start_from; k < length; ++k) {
// Iterate through the entire range, as accessing elements out of order is
// observable.
for (size_t k = start_from; k < length; ++k) {
DCHECK_EQ(receiver->GetElementsKind(), original_elements_kind);
InternalIndex entry = dictionary->FindEntry(isolate, k);
InternalIndex entry =
dictionary->FindEntry(isolate, static_cast<uint32_t>(k));
if (entry.is_not_found()) {
if (search_for_hole) return Just(true);
continue;
......@@ -1745,7 +1724,7 @@ class DictionaryElementsAccessor
static Maybe<int64_t> IndexOfValueImpl(Isolate* isolate,
Handle<JSObject> receiver,
Handle<Object> value,
uint32_t start_from, uint32_t length) {
size_t start_from, size_t length) {
DCHECK(JSObject::PrototypeHasNoElements(isolate, *receiver));
ElementsKind original_elements_kind = receiver->GetElementsKind();
......@@ -1754,9 +1733,11 @@ class DictionaryElementsAccessor
NumberDictionary::cast(receiver->elements()), isolate);
// Iterate through entire range, as accessing elements out of order is
// observable.
for (uint32_t k = start_from; k < length; ++k) {
for (size_t k = start_from; k < length; ++k) {
DCHECK_EQ(receiver->GetElementsKind(), original_elements_kind);
InternalIndex entry = dictionary->FindEntry(isolate, k);
DCHECK_LE(k, std::numeric_limits<uint32_t>::max());
InternalIndex entry =
dictionary->FindEntry(isolate, static_cast<uint32_t>(k));
if (entry.is_not_found()) continue;
PropertyDetails details =
......@@ -2029,11 +2010,14 @@ class FastElementsAccessor : public ElementsAccessorBase<Subclass, KindTraits> {
static uint32_t NumberOfElementsImpl(JSObject receiver,
FixedArrayBase backing_store) {
uint32_t max_index = Subclass::GetMaxIndex(receiver, backing_store);
if (IsFastPackedElementsKind(Subclass::kind())) return max_index;
size_t max_index = Subclass::GetMaxIndex(receiver, backing_store);
DCHECK_LE(max_index, std::numeric_limits<uint32_t>::max());
if (IsFastPackedElementsKind(Subclass::kind())) {
return static_cast<uint32_t>(max_index);
}
Isolate* isolate = receiver.GetIsolate();
uint32_t count = 0;
for (uint32_t i = 0; i < max_index; i++) {
for (size_t i = 0; i < max_index; i++) {
if (Subclass::HasEntryImpl(isolate, backing_store, InternalIndex(i))) {
count++;
}
......@@ -2046,8 +2030,8 @@ class FastElementsAccessor : public ElementsAccessorBase<Subclass, KindTraits> {
AddKeyConversion convert) {
Isolate* isolate = accumulator->isolate();
Handle<FixedArrayBase> elements(receiver->elements(), isolate);
uint32_t length = Subclass::GetMaxNumberOfEntries(*receiver, *elements);
for (uint32_t i = 0; i < length; i++) {
size_t length = Subclass::GetMaxNumberOfEntries(*receiver, *elements);
for (size_t i = 0; i < length; i++) {
if (IsFastPackedElementsKind(KindTraits::Kind) ||
HasEntryImpl(isolate, *elements, InternalIndex(i))) {
RETURN_FAILURE_IF_NOT_SUCCESSFUL(accumulator->AddKey(
......@@ -2145,7 +2129,7 @@ class FastElementsAccessor : public ElementsAccessorBase<Subclass, KindTraits> {
}
static Object FillImpl(Handle<JSObject> receiver, Handle<Object> obj_value,
uint32_t start, uint32_t end) {
size_t start, size_t end) {
// Ensure indexes are within array bounds
DCHECK_LE(0, start);
DCHECK_LE(start, end);
......@@ -2156,15 +2140,15 @@ class FastElementsAccessor : public ElementsAccessorBase<Subclass, KindTraits> {
}
// Make sure we have enough space.
uint32_t capacity =
Subclass::GetCapacityImpl(*receiver, receiver->elements());
if (end > capacity) {
Subclass::GrowCapacityAndConvertImpl(receiver, end);
DCHECK_LE(end, std::numeric_limits<uint32_t>::max());
if (end > Subclass::GetCapacityImpl(*receiver, receiver->elements())) {
Subclass::GrowCapacityAndConvertImpl(receiver,
static_cast<uint32_t>(end));
CHECK_EQ(Subclass::kind(), receiver->GetElementsKind());
}
DCHECK_LE(end, Subclass::GetCapacityImpl(*receiver, receiver->elements()));
for (uint32_t index = start; index < end; ++index) {
for (size_t index = start; index < end; ++index) {
Subclass::SetImpl(receiver, InternalIndex(index), *obj_value);
}
return *receiver;
......@@ -2173,7 +2157,7 @@ class FastElementsAccessor : public ElementsAccessorBase<Subclass, KindTraits> {
static Maybe<bool> IncludesValueImpl(Isolate* isolate,
Handle<JSObject> receiver,
Handle<Object> search_value,
uint32_t start_from, uint32_t length) {
size_t start_from, size_t length) {
DCHECK(JSObject::PrototypeHasNoElements(isolate, *receiver));
DisallowHeapAllocation no_gc;
FixedArrayBase elements_base = receiver->elements();
......@@ -2184,7 +2168,7 @@ class FastElementsAccessor : public ElementsAccessorBase<Subclass, KindTraits> {
if (start_from >= length) return Just(false);
// Elements beyond the capacity of the backing store treated as undefined.
uint32_t elements_length = static_cast<uint32_t>(elements_base.length());
size_t elements_length = static_cast<size_t>(elements_base.length());
if (value == undefined && elements_length < length) return Just(true);
if (elements_length == 0) {
DCHECK_NE(value, undefined);
......@@ -2192,6 +2176,7 @@ class FastElementsAccessor : public ElementsAccessorBase<Subclass, KindTraits> {
}
length = std::min(elements_length, length);
DCHECK_LE(length, std::numeric_limits<int>::max());
if (!value.IsNumber()) {
if (value == undefined) {
......@@ -2201,10 +2186,10 @@ class FastElementsAccessor : public ElementsAccessorBase<Subclass, KindTraits> {
// JSArray::length.
if (IsSmiOrObjectElementsKind(Subclass::kind()) ||
IsAnyNonextensibleElementsKind(Subclass::kind())) {
auto elements = FixedArray::cast(receiver->elements());
FixedArray elements = FixedArray::cast(receiver->elements());
for (uint32_t k = start_from; k < length; ++k) {
Object element_k = elements.get(k);
for (size_t k = start_from; k < length; ++k) {
Object element_k = elements.get(static_cast<int>(k));
if (element_k == the_hole || element_k == undefined) {
return Just(true);
......@@ -2215,12 +2200,11 @@ class FastElementsAccessor : public ElementsAccessorBase<Subclass, KindTraits> {
// Search for The Hole in HOLEY_DOUBLE_ELEMENTS or
// PACKED_DOUBLE_ELEMENTS.
DCHECK(IsDoubleElementsKind(Subclass::kind()));
auto elements = FixedDoubleArray::cast(receiver->elements());
FixedDoubleArray elements =
FixedDoubleArray::cast(receiver->elements());
for (uint32_t k = start_from; k < length; ++k) {
if (elements.is_the_hole(k)) {
return Just(true);
}
for (size_t k = start_from; k < length; ++k) {
if (elements.is_the_hole(static_cast<int>(k))) return Just(true);
}
return Just(false);
}
......@@ -2236,14 +2220,11 @@ class FastElementsAccessor : public ElementsAccessorBase<Subclass, KindTraits> {
// PACKED_ELEMENTS or HOLEY_ELEMENTS.
DCHECK(IsObjectElementsKind(Subclass::kind()) ||
IsAnyNonextensibleElementsKind(Subclass::kind()));
auto elements = FixedArray::cast(receiver->elements());
for (uint32_t k = start_from; k < length; ++k) {
Object element_k = elements.get(k);
if (element_k == the_hole) {
continue;
}
FixedArray elements = FixedArray::cast(receiver->elements());
for (size_t k = start_from; k < length; ++k) {
Object element_k = elements.get(static_cast<int>(k));
if (element_k == the_hole) continue;
if (value.SameValueZero(element_k)) return Just(true);
}
return Just(false);
......@@ -2255,23 +2236,24 @@ class FastElementsAccessor : public ElementsAccessorBase<Subclass, KindTraits> {
// Search for non-NaN Number in PACKED_DOUBLE_ELEMENTS or
// HOLEY_DOUBLE_ELEMENTS --- Skip TheHole, and trust UCOMISD or
// similar operation for result.
auto elements = FixedDoubleArray::cast(receiver->elements());
FixedDoubleArray elements =
FixedDoubleArray::cast(receiver->elements());
for (uint32_t k = start_from; k < length; ++k) {
if (elements.is_the_hole(k)) {
continue;
for (size_t k = start_from; k < length; ++k) {
if (elements.is_the_hole(static_cast<int>(k))) continue;
if (elements.get_scalar(static_cast<int>(k)) == search_value) {
return Just(true);
}
if (elements.get_scalar(k) == search_value) return Just(true);
}
return Just(false);
} else {
// Search for non-NaN Number in PACKED_ELEMENTS, HOLEY_ELEMENTS,
// PACKED_SMI_ELEMENTS or HOLEY_SMI_ELEMENTS --- Skip non-Numbers,
// and trust UCOMISD or similar operation for result
auto elements = FixedArray::cast(receiver->elements());
FixedArray elements = FixedArray::cast(receiver->elements());
for (uint32_t k = start_from; k < length; ++k) {
Object element_k = elements.get(k);
for (size_t k = start_from; k < length; ++k) {
Object element_k = elements.get(static_cast<int>(k));
if (element_k.IsNumber() && element_k.Number() == search_value) {
return Just(true);
}
......@@ -2287,25 +2269,25 @@ class FastElementsAccessor : public ElementsAccessorBase<Subclass, KindTraits> {
// Search for NaN in PACKED_DOUBLE_ELEMENTS or
// HOLEY_DOUBLE_ELEMENTS --- Skip The Hole and trust
// std::isnan(elementK) for result
auto elements = FixedDoubleArray::cast(receiver->elements());
FixedDoubleArray elements =
FixedDoubleArray::cast(receiver->elements());
for (uint32_t k = start_from; k < length; ++k) {
if (elements.is_the_hole(k)) {
continue;
for (size_t k = start_from; k < length; ++k) {
if (elements.is_the_hole(static_cast<int>(k))) continue;
if (std::isnan(elements.get_scalar(static_cast<int>(k)))) {
return Just(true);
}
if (std::isnan(elements.get_scalar(k))) return Just(true);
}
return Just(false);
} else {
// Search for NaN in PACKED_ELEMENTS, HOLEY_ELEMENTS,
// PACKED_SMI_ELEMENTS or HOLEY_SMI_ELEMENTS. Return true if
// elementK->IsHeapNumber() && std::isnan(elementK->Number())
DCHECK(IsSmiOrObjectElementsKind(Subclass::kind()) ||
// Search for NaN in PACKED_ELEMENTS or HOLEY_ELEMENTS. Return true
// if elementK->IsHeapNumber() && std::isnan(elementK->Number())
DCHECK(IsObjectElementsKind(Subclass::kind()) ||
IsAnyNonextensibleElementsKind(Subclass::kind()));
auto elements = FixedArray::cast(receiver->elements());
FixedArray elements = FixedArray::cast(receiver->elements());
for (uint32_t k = start_from; k < length; ++k) {
if (elements.get(k).IsNaN()) return Just(true);
for (size_t k = start_from; k < length; ++k) {
if (elements.get(static_cast<int>(k)).IsNaN()) return Just(true);
}
return Just(false);
}
......@@ -2431,8 +2413,7 @@ class FastSmiOrObjectElementsAccessor
}
static Object GetRaw(FixedArray backing_store, InternalIndex entry) {
uint32_t index = Subclass::GetIndexForEntryImpl(backing_store, entry);
return backing_store.get(index);
return backing_store.get(entry.as_int());
}
// NOTE: this method violates the handlified function signature convention:
......@@ -2523,7 +2504,7 @@ class FastSmiOrObjectElementsAccessor
static Maybe<int64_t> IndexOfValueImpl(Isolate* isolate,
Handle<JSObject> receiver,
Handle<Object> search_value,
uint32_t start_from, uint32_t length) {
size_t start_from, size_t length) {
DCHECK(JSObject::PrototypeHasNoElements(isolate, *receiver));
DisallowHeapAllocation no_gc;
FixedArrayBase elements_base = receiver->elements();
......@@ -2531,7 +2512,7 @@ class FastSmiOrObjectElementsAccessor
if (start_from >= length) return Just<int64_t>(-1);
length = std::min(static_cast<uint32_t>(elements_base.length()), length);
length = std::min(static_cast<size_t>(elements_base.length()), length);
// Only FAST_{,HOLEY_}ELEMENTS can store non-numbers.
if (!value.IsNumber() && !IsObjectElementsKind(Subclass::kind()) &&
......@@ -2546,8 +2527,12 @@ class FastSmiOrObjectElementsAccessor
// elements->get(k) can return the hole, for which the StrictEquals will
// always fail.
FixedArray elements = FixedArray::cast(receiver->elements());
for (uint32_t k = start_from; k < length; ++k) {
if (value.StrictEquals(elements.get(k))) return Just<int64_t>(k);
STATIC_ASSERT(FixedArray::kMaxLength <=
std::numeric_limits<uint32_t>::max());
for (size_t k = start_from; k < length; ++k) {
if (value.StrictEquals(elements.get(static_cast<uint32_t>(k)))) {
return Just<int64_t>(k);
}
}
return Just<int64_t>(-1);
}
......@@ -2917,13 +2902,13 @@ class FastDoubleElementsAccessor
static Maybe<int64_t> IndexOfValueImpl(Isolate* isolate,
Handle<JSObject> receiver,
Handle<Object> search_value,
uint32_t start_from, uint32_t length) {
size_t start_from, size_t length) {
DCHECK(JSObject::PrototypeHasNoElements(isolate, *receiver));
DisallowHeapAllocation no_gc;
FixedArrayBase elements_base = receiver->elements();
Object value = *search_value;
length = std::min(static_cast<uint32_t>(elements_base.length()), length);
length = std::min(static_cast<size_t>(elements_base.length()), length);
if (start_from >= length) return Just<int64_t>(-1);
......@@ -2936,11 +2921,14 @@ class FastDoubleElementsAccessor
double numeric_search_value = value.Number();
FixedDoubleArray elements = FixedDoubleArray::cast(receiver->elements());
for (uint32_t k = start_from; k < length; ++k) {
if (elements.is_the_hole(k)) {
STATIC_ASSERT(FixedDoubleArray::kMaxLength <=
std::numeric_limits<int>::max());
for (size_t k = start_from; k < length; ++k) {
int k_int = static_cast<int>(k);
if (elements.is_the_hole(k_int)) {
continue;
}
if (elements.get_scalar(k) == numeric_search_value) {
if (elements.get_scalar(k_int) == numeric_search_value) {
return Just<int64_t>(k);
}
}
......@@ -3082,7 +3070,7 @@ class TypedElementsAccessor
return PropertyDetails(kData, DONT_DELETE, PropertyCellType::kNoCell);
}
static bool HasElementImpl(Isolate* isolate, JSObject holder, uint32_t index,
static bool HasElementImpl(Isolate* isolate, JSObject holder, size_t index,
FixedArrayBase backing_store,
PropertyFilter filter) {
return index < AccessorClass::GetCapacityImpl(holder, backing_store);
......@@ -3103,30 +3091,23 @@ class TypedElementsAccessor
UNREACHABLE();
}
static uint32_t GetIndexForEntryImpl(FixedArrayBase backing_store,
InternalIndex entry) {
return entry.as_uint32();
}
static InternalIndex GetEntryForIndexImpl(Isolate* isolate, JSObject holder,
FixedArrayBase backing_store,
uint32_t index,
size_t index,
PropertyFilter filter) {
return index < AccessorClass::GetCapacityImpl(holder, backing_store)
? InternalIndex(index)
: InternalIndex::NotFound();
}
static uint32_t GetCapacityImpl(JSObject holder,
FixedArrayBase backing_store) {
static size_t GetCapacityImpl(JSObject holder, FixedArrayBase backing_store) {
JSTypedArray typed_array = JSTypedArray::cast(holder);
if (typed_array.WasDetached()) return 0;
// TODO(bmeurer, v8:4153): We need to support arbitrary size_t here.
return static_cast<uint32_t>(typed_array.length());
return typed_array.length();
}
static uint32_t NumberOfElementsImpl(JSObject receiver,
FixedArrayBase backing_store) {
static size_t NumberOfElementsImpl(JSObject receiver,
FixedArrayBase backing_store) {
return AccessorClass::GetCapacityImpl(receiver, backing_store);
}
......@@ -3135,8 +3116,8 @@ class TypedElementsAccessor
AddKeyConversion convert) {
Isolate* isolate = receiver->GetIsolate();
Handle<FixedArrayBase> elements(receiver->elements(), isolate);
uint32_t length = AccessorClass::GetCapacityImpl(*receiver, *elements);
for (uint32_t i = 0; i < length; i++) {
size_t length = AccessorClass::GetCapacityImpl(*receiver, *elements);
for (size_t i = 0; i < length; i++) {
Handle<Object> value =
AccessorClass::GetInternalImpl(receiver, InternalIndex(i));
RETURN_FAILURE_IF_NOT_SUCCESSFUL(accumulator->AddKey(value, convert));
......@@ -3151,8 +3132,8 @@ class TypedElementsAccessor
int count = 0;
if ((filter & ONLY_CONFIGURABLE) == 0) {
Handle<FixedArrayBase> elements(object->elements(), isolate);
uint32_t length = AccessorClass::GetCapacityImpl(*object, *elements);
for (uint32_t index = 0; index < length; ++index) {
size_t length = AccessorClass::GetCapacityImpl(*object, *elements);
for (size_t index = 0; index < length; ++index) {
Handle<Object> value =
AccessorClass::GetInternalImpl(object, InternalIndex(index));
if (get_entries) {
......@@ -3166,10 +3147,9 @@ class TypedElementsAccessor
}
static Object FillImpl(Handle<JSObject> receiver, Handle<Object> value,
uint32_t start, uint32_t end) {
size_t start, size_t end) {
Handle<JSTypedArray> typed_array = Handle<JSTypedArray>::cast(receiver);
DCHECK(!typed_array->WasDetached());
DCHECK_LE(0, start);
DCHECK_LE(start, end);
DCHECK_LE(end, typed_array->length());
DisallowHeapAllocation no_gc;
......@@ -3187,8 +3167,8 @@ class TypedElementsAccessor
static Maybe<bool> IncludesValueImpl(Isolate* isolate,
Handle<JSObject> receiver,
Handle<Object> value,
uint32_t start_from, uint32_t length) {
Handle<Object> value, size_t start_from,
size_t length) {
DisallowHeapAllocation no_gc;
JSTypedArray typed_array = JSTypedArray::cast(*receiver);
......@@ -3205,8 +3185,7 @@ class TypedElementsAccessor
// Prototype has no elements, and not searching for the hole --- limit
// search to backing store length.
if (typed_array.length() < length) {
// TODO(bmeurer, v8:4153): Don't cast to uint32_t here.
length = static_cast<uint32_t>(typed_array.length());
length = typed_array.length();
}
ElementType typed_search_value;
......@@ -3226,7 +3205,7 @@ class TypedElementsAccessor
return Just(false);
}
if (std::isnan(search_value)) {
for (uint32_t k = start_from; k < length; ++k) {
for (size_t k = start_from; k < length; ++k) {
double elem_k =
static_cast<double>(AccessorClass::GetImpl(data_ptr, k));
if (std::isnan(elem_k)) return Just(true);
......@@ -3244,7 +3223,7 @@ class TypedElementsAccessor
}
}
for (uint32_t k = start_from; k < length; ++k) {
for (size_t k = start_from; k < length; ++k) {
ElementType elem_k = AccessorClass::GetImpl(data_ptr, k);
if (elem_k == typed_search_value) return Just(true);
}
......@@ -3254,7 +3233,7 @@ class TypedElementsAccessor
static Maybe<int64_t> IndexOfValueImpl(Isolate* isolate,
Handle<JSObject> receiver,
Handle<Object> value,
uint32_t start_from, uint32_t length) {
size_t start_from, size_t length) {
DisallowHeapAllocation no_gc;
JSTypedArray typed_array = JSTypedArray::cast(*receiver);
......@@ -3294,11 +3273,10 @@ class TypedElementsAccessor
// Prototype has no elements, and not searching for the hole --- limit
// search to backing store length.
if (typed_array.length() < length) {
// TODO(bmeurer, v8:4153): Don't cast to uint32_t here.
length = static_cast<uint32_t>(typed_array.length());
length = typed_array.length();
}
for (uint32_t k = start_from; k < length; ++k) {
for (size_t k = start_from; k < length; ++k) {
ElementType elem_k = AccessorClass::GetImpl(data_ptr, k);
if (elem_k == typed_search_value) return Just<int64_t>(k);
}
......@@ -3307,7 +3285,7 @@ class TypedElementsAccessor
static Maybe<int64_t> LastIndexOfValueImpl(Handle<JSObject> receiver,
Handle<Object> value,
uint32_t start_from) {
size_t start_from) {
DisallowHeapAllocation no_gc;
JSTypedArray typed_array = JSTypedArray::cast(*receiver);
......@@ -3345,7 +3323,7 @@ class TypedElementsAccessor
}
DCHECK_LT(start_from, typed_array.length());
uint32_t k = start_from;
size_t k = start_from;
do {
ElementType elem_k = AccessorClass::GetImpl(data_ptr, k);
if (elem_k == typed_search_value) return Just<int64_t>(k);
......@@ -3436,7 +3414,7 @@ class TypedElementsAccessor
static void CopyElementsFromTypedArray(JSTypedArray source,
JSTypedArray destination,
size_t length, uint32_t offset) {
size_t length, size_t offset) {
// The source is a typed array, so we know we don't need to do ToNumber
// side-effects, as the source elements will always be a number.
DisallowHeapAllocation no_gc;
......@@ -3522,7 +3500,7 @@ class TypedElementsAccessor
static bool TryCopyElementsFastNumber(Context context, JSArray source,
JSTypedArray destination, size_t length,
uint32_t offset) {
size_t offset) {
if (Kind == BIGINT64_ELEMENTS || Kind == BIGUINT64_ELEMENTS) return false;
Isolate* isolate = source.GetIsolate();
DisallowHeapAllocation no_gc;
......@@ -3602,24 +3580,13 @@ class TypedElementsAccessor
static Object CopyElementsHandleSlow(Handle<Object> source,
Handle<JSTypedArray> destination,
size_t length, uint32_t offset) {
size_t length, size_t offset) {
Isolate* isolate = destination->GetIsolate();
for (size_t i = 0; i < length; i++) {
Handle<Object> elem;
// TODO(4153): This if-branch will subsume its else-branch.
if (i <= JSArray::kMaxArrayIndex) {
LookupIterator it(isolate, source, static_cast<uint32_t>(i));
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, elem,
Object::GetProperty(&it));
} else {
char buffer[kDoubleToCStringMinBufferSize];
Vector<char> string(buffer, arraysize(buffer));
DoubleToCString(static_cast<double>(i), string);
Handle<Name> name = isolate->factory()->InternalizeUtf8String(string);
LookupIterator it(isolate, source, name);
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, elem,
Object::GetProperty(&it));
}
LookupIterator it(isolate, source, i);
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, elem,
Object::GetProperty(&it));
if (Kind == BIGINT64_ELEMENTS || Kind == BIGUINT64_ELEMENTS) {
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, elem,
BigInt::FromObject(isolate, elem));
......@@ -3648,7 +3615,7 @@ class TypedElementsAccessor
// that is required.
static Object CopyElementsHandleImpl(Handle<Object> source,
Handle<JSObject> destination,
size_t length, uint32_t offset) {
size_t length, size_t offset) {
Isolate* isolate = destination->GetIsolate();
Handle<JSTypedArray> destination_ta =
Handle<JSTypedArray>::cast(destination);
......@@ -3676,14 +3643,13 @@ class TypedElementsAccessor
// Fast cases for packed numbers kinds where we don't need to allocate.
Handle<JSArray> source_js_array = Handle<JSArray>::cast(source);
size_t current_length;
if (source_js_array->length().IsNumber() &&
TryNumberToSize(source_js_array->length(), &current_length)) {
if (length <= current_length) {
Handle<JSArray> source_array = Handle<JSArray>::cast(source);
if (TryCopyElementsFastNumber(isolate->context(), *source_array,
*destination_ta, length, offset)) {
return *isolate->factory()->undefined_value();
}
DCHECK(source_js_array->length().IsNumber());
if (TryNumberToSize(source_js_array->length(), &current_length) &&
length <= current_length) {
Handle<JSArray> source_array = Handle<JSArray>::cast(source);
if (TryCopyElementsFastNumber(isolate->context(), *source_array,
*destination_ta, length, offset)) {
return *isolate->factory()->undefined_value();
}
}
}
......@@ -3996,8 +3962,10 @@ class SloppyArgumentsElementsAccessor
SloppyArgumentsElements elements =
SloppyArgumentsElements::cast(backing_store);
FixedArrayBase arguments = elements.arguments();
return elements.parameter_map_length() +
ArgumentsAccessor::GetMaxNumberOfEntries(holder, arguments);
size_t max_entries =
ArgumentsAccessor::GetMaxNumberOfEntries(holder, arguments);
DCHECK_LE(max_entries, std::numeric_limits<uint32_t>::max());
return elements.parameter_map_length() + static_cast<uint32_t>(max_entries);
}
static uint32_t NumberOfElementsImpl(JSObject receiver,
......@@ -4035,8 +4003,8 @@ class SloppyArgumentsElementsAccessor
SloppyArgumentsElements elements =
SloppyArgumentsElements::cast(parameters);
uint32_t length = elements.parameter_map_length();
if (entry.as_uint32() < length) {
return HasParameterMapArg(isolate, elements, entry.as_uint32());
if (entry.raw_value() < length) {
return HasParameterMapArg(isolate, elements, entry.raw_value());
}
FixedArrayBase arguments = elements.arguments();
return ArgumentsAccessor::HasEntryImpl(isolate, arguments,
......@@ -4050,21 +4018,9 @@ class SloppyArgumentsElementsAccessor
return ArgumentsAccessor::HasAccessorsImpl(holder, arguments);
}
static uint32_t GetIndexForEntryImpl(FixedArrayBase parameters,
InternalIndex entry) {
SloppyArgumentsElements elements =
SloppyArgumentsElements::cast(parameters);
uint32_t length = elements.parameter_map_length();
uint32_t index = entry.as_uint32();
if (index < length) return index;
FixedArray arguments = elements.arguments();
return ArgumentsAccessor::GetIndexForEntryImpl(arguments,
entry.adjust_down(length));
}
static InternalIndex GetEntryForIndexImpl(Isolate* isolate, JSObject holder,
FixedArrayBase parameters,
uint32_t index,
size_t index,
PropertyFilter filter) {
SloppyArgumentsElements elements =
SloppyArgumentsElements::cast(parameters);
......@@ -4094,10 +4050,11 @@ class SloppyArgumentsElementsAccessor
static bool HasParameterMapArg(Isolate* isolate,
SloppyArgumentsElements elements,
uint32_t index) {
size_t index) {
uint32_t length = elements.parameter_map_length();
if (index >= length) return false;
return !elements.get_mapped_entry(index).IsTheHole(isolate);
return !elements.get_mapped_entry(static_cast<uint32_t>(index))
.IsTheHole(isolate);
}
static void DeleteImpl(Handle<JSObject> obj, InternalIndex entry) {
......@@ -4169,15 +4126,15 @@ class SloppyArgumentsElementsAccessor
static Maybe<bool> IncludesValueImpl(Isolate* isolate,
Handle<JSObject> object,
Handle<Object> value,
uint32_t start_from, uint32_t length) {
Handle<Object> value, size_t start_from,
size_t length) {
DCHECK(JSObject::PrototypeHasNoElements(isolate, *object));
Handle<Map> original_map(object->map(), isolate);
Handle<SloppyArgumentsElements> elements(
SloppyArgumentsElements::cast(object->elements()), isolate);
bool search_for_hole = value->IsUndefined(isolate);
for (uint32_t k = start_from; k < length; ++k) {
for (size_t k = start_from; k < length; ++k) {
DCHECK_EQ(object->map(), *original_map);
InternalIndex entry =
GetEntryForIndexImpl(isolate, *object, *elements, k, ALL_PROPERTIES);
......@@ -4212,13 +4169,13 @@ class SloppyArgumentsElementsAccessor
static Maybe<int64_t> IndexOfValueImpl(Isolate* isolate,
Handle<JSObject> object,
Handle<Object> value,
uint32_t start_from, uint32_t length) {
size_t start_from, size_t length) {
DCHECK(JSObject::PrototypeHasNoElements(isolate, *object));
Handle<Map> original_map(object->map(), isolate);
Handle<SloppyArgumentsElements> elements(
SloppyArgumentsElements::cast(object->elements()), isolate);
for (uint32_t k = start_from; k < length; ++k) {
for (size_t k = start_from; k < length; ++k) {
DCHECK_EQ(object->map(), *original_map);
InternalIndex entry =
GetEntryForIndexImpl(isolate, *object, *elements, k, ALL_PROPERTIES);
......@@ -4508,7 +4465,7 @@ class StringWrapperElementsAccessor
static InternalIndex GetEntryForIndexImpl(Isolate* isolate, JSObject holder,
FixedArrayBase backing_store,
uint32_t index,
size_t index,
PropertyFilter filter) {
uint32_t length = static_cast<uint32_t>(GetString(holder).length());
if (index < length) return InternalIndex(index);
......@@ -4769,12 +4726,10 @@ void CopyFastNumberJSArrayElementsToTypedArray(Address raw_context,
JSTypedArray destination = JSTypedArray::cast(Object(raw_destination));
switch (destination.GetElementsKind()) {
#define TYPED_ARRAYS_CASE(Type, type, TYPE, ctype) \
case TYPE##_ELEMENTS: \
/* TODO(v8:4153): handle huge offsets here. */ \
DCHECK_LE(offset, kMaxUInt32); \
CHECK(Type##ElementsAccessor::TryCopyElementsFastNumber( \
context, source, destination, length, static_cast<uint32_t>(offset))); \
#define TYPED_ARRAYS_CASE(Type, type, TYPE, ctype) \
case TYPE##_ELEMENTS: \
CHECK(Type##ElementsAccessor::TryCopyElementsFastNumber( \
context, source, destination, length, offset)); \
break;
TYPED_ARRAYS(TYPED_ARRAYS_CASE)
#undef TYPED_ARRAYS_CASE
......@@ -4790,12 +4745,10 @@ void CopyTypedArrayElementsToTypedArray(Address raw_source,
JSTypedArray destination = JSTypedArray::cast(Object(raw_destination));
switch (destination.GetElementsKind()) {
#define TYPED_ARRAYS_CASE(Type, type, TYPE, ctype) \
case TYPE##_ELEMENTS: \
/* TODO(v8:4153): handle huge offsets here. */ \
DCHECK_LE(offset, kMaxUInt32); \
Type##ElementsAccessor::CopyElementsFromTypedArray( \
source, destination, length, static_cast<uint32_t>(offset)); \
#define TYPED_ARRAYS_CASE(Type, type, TYPE, ctype) \
case TYPE##_ELEMENTS: \
Type##ElementsAccessor::CopyElementsFromTypedArray(source, destination, \
length, offset); \
break;
TYPED_ARRAYS(TYPED_ARRAYS_CASE)
#undef TYPED_ARRAYS_CASE
......
src/objects/elements.h
View file @ 5d29947d
......@@ -33,13 +33,13 @@ class ElementsAccessor {
virtual void Validate(JSObject obj) = 0;
// Returns true if a holder contains an element with the specified index
// without iterating up the prototype chain. The caller can optionally pass
// in the backing store to use for the check, which must be compatible with
// the ElementsKind of the ElementsAccessor. If backing_store is nullptr, the
// holder->elements() is used as the backing store. If a |filter| is
// specified the PropertyAttributes of the element at the given index
// are compared to the given |filter|. If they match/overlap the given
// index is ignored. Note that only Dictionary elements have custom
// without iterating up the prototype chain. The first version takes the
// backing store to use for the check, which must be compatible with the
// ElementsKind of the ElementsAccessor; the second version uses
// holder->elements() as the backing store. If a |filter| is specified,
// the PropertyAttributes of the element at the given index are compared
// to the given |filter|. If they match/overlap, the given index is ignored.
// Note that only Dictionary elements have custom
// PropertyAttributes associated, hence the |filter| argument is ignored for
// all but DICTIONARY_ELEMENTS and SLOW_SLOPPY_ARGUMENTS_ELEMENTS.
virtual bool HasElement(JSObject holder, uint32_t index,
......@@ -56,7 +56,7 @@ class ElementsAccessor {
virtual Handle<Object> Get(Handle<JSObject> holder, InternalIndex entry) = 0;
virtual bool HasAccessors(JSObject holder) = 0;
virtual uint32_t NumberOfElements(JSObject holder) = 0;
virtual size_t NumberOfElements(JSObject holder) = 0;
// Modifies the length data property as specified for JSArrays and resizes the
// underlying backing store accordingly. The method honors the semantics of
......@@ -126,28 +126,27 @@ class ElementsAccessor {
virtual Handle<NumberDictionary> Normalize(Handle<JSObject> object) = 0;
virtual uint32_t GetCapacity(JSObject holder,
FixedArrayBase backing_store) = 0;
virtual size_t GetCapacity(JSObject holder, FixedArrayBase backing_store) = 0;
virtual Object Fill(Handle<JSObject> receiver, Handle<Object> obj_value,
uint32_t start, uint32_t end) = 0;
size_t start, size_t end) = 0;
// Check an Object's own elements for an element (using SameValueZero
// semantics)
virtual Maybe<bool> IncludesValue(Isolate* isolate, Handle<JSObject> receiver,
Handle<Object> value, uint32_t start,
uint32_t length) = 0;
Handle<Object> value, size_t start,
size_t length) = 0;
// Check an Object's own elements for the index of an element (using SameValue
// semantics)
virtual Maybe<int64_t> IndexOfValue(Isolate* isolate,
Handle<JSObject> receiver,
Handle<Object> value, uint32_t start,
uint32_t length) = 0;
Handle<Object> value, size_t start,
size_t length) = 0;
virtual Maybe<int64_t> LastIndexOfValue(Handle<JSObject> receiver,
Handle<Object> value,
uint32_t start) = 0;
size_t start) = 0;
virtual void Reverse(JSObject receiver) = 0;
......@@ -157,7 +156,7 @@ class ElementsAccessor {
virtual Object CopyElements(Handle<Object> source,
Handle<JSObject> destination, size_t length,
uint32_t offset) = 0;
size_t offset) = 0;
virtual Handle<FixedArray> CreateListFromArrayLike(Isolate* isolate,
Handle<JSObject> object,
......@@ -180,7 +179,7 @@ class ElementsAccessor {
// the NumberDictionary.
virtual InternalIndex GetEntryForIndex(Isolate* isolate, JSObject holder,
FixedArrayBase backing_store,
uint32_t index) = 0;
size_t index) = 0;
virtual PropertyDetails GetDetails(JSObject holder, InternalIndex entry) = 0;
virtual void Reconfigure(Handle<JSObject> object,
......
src/objects/js-list-format.cc
View file @ 5d29947d
......@@ -256,11 +256,10 @@ Maybe<std::vector<icu::UnicodeString>> ToUnicodeStringArray(
// arrays here, so the loop below can construct an entry from the index.
DCHECK(array->HasFastElements(isolate));
auto* accessor = array->GetElementsAccessor();
uint32_t length = accessor->NumberOfElements(*array);
size_t length = accessor->NumberOfElements(*array);
std::vector<icu::UnicodeString> result;
for (uint32_t i = 0; i < length; i++) {
InternalIndex entry(i);
for (InternalIndex entry : InternalIndex::Range(length)) {
DCHECK(accessor->HasEntry(*array, entry));
Handle<Object> item = accessor->Get(array, entry);
DCHECK(item->IsString());
......
src/objects/js-objects.cc
View file @ 5d29947d
......@@ -1847,17 +1847,18 @@ V8_WARN_UNUSED_RESULT Maybe<bool> FastGetOwnValuesOrEntries(
Handle<DescriptorArray> descriptors(map->instance_descriptors(), isolate);
int number_of_own_descriptors = map->NumberOfOwnDescriptors();
int number_of_own_elements =
size_t number_of_own_elements =
object->GetElementsAccessor()->GetCapacity(*object, object->elements());
if (number_of_own_elements >
FixedArray::kMaxLength - number_of_own_descriptors) {
static_cast<size_t>(FixedArray::kMaxLength - number_of_own_descriptors)) {
isolate->Throw(*isolate->factory()->NewRangeError(
MessageTemplate::kInvalidArrayLength));
return Nothing<bool>();
}
// The static cast is safe after the range check right above.
Handle<FixedArray> values_or_entries = isolate->factory()->NewFixedArray(
number_of_own_descriptors + number_of_own_elements);
static_cast<int>(number_of_own_descriptors + number_of_own_elements));
int count = 0;
if (object->elements() != ReadOnlyRoots(isolate).empty_fixed_array()) {
......@@ -3667,8 +3668,9 @@ bool TestElementsIntegrityLevel(JSObject object, PropertyAttributes level) {
level);
}
if (IsTypedArrayElementsKind(kind)) {
if (level == FROZEN && JSArrayBufferView::cast(object).byte_length() > 0)
if (level == FROZEN && JSArrayBufferView::cast(object).byte_length() > 0) {
return false; // TypedArrays with elements can't be frozen.
}
return TestPropertiesIntegrityLevel(object, level);
}
if (IsFrozenElementsKind(kind)) return true;
......
src/objects/keys.cc
View file @ 5d29947d
......@@ -528,9 +528,8 @@ V8_WARN_UNUSED_RESULT ExceptionStatus FilterForEnumerableProperties(
DCHECK(result->IsJSArray() || result->HasSloppyArgumentsElements());
ElementsAccessor* accessor = result->GetElementsAccessor();
uint32_t length = accessor->GetCapacity(*result, result->elements());
for (uint32_t i = 0; i < length; i++) {
InternalIndex entry(i);
size_t length = accessor->GetCapacity(*result, result->elements());
for (InternalIndex entry : InternalIndex::Range(length)) {
if (!accessor->HasEntry(*result, entry)) continue;
// args are invalid after args.Call(), create a new one in every iteration.
......
src/objects/lookup.cc
View file @ 5d29947d
......@@ -1165,12 +1165,8 @@ LookupIterator::State LookupIterator::LookupInRegularHolder(
JSObject js_object = JSObject::cast(holder);
ElementsAccessor* accessor = js_object.GetElementsAccessor(isolate_);
FixedArrayBase backing_store = js_object.elements(isolate_);
// TODO(4153): Update elements.cc and drop the cast to uint32_t.
uint32_t index = index_ > std::numeric_limits<uint32_t>::max()
? std::numeric_limits<uint32_t>::max()
: static_cast<uint32_t>(index_);
number_ =
accessor->GetEntryForIndex(isolate_, js_object, backing_store, index);
accessor->GetEntryForIndex(isolate_, js_object, backing_store, index_);
if (number_.is_not_found()) {
return holder.IsJSTypedArray(isolate_) ? INTEGER_INDEXED_EXOTIC
: NOT_FOUND;
......
src/objects/objects-inl.h
View file @ 5d29947d
......@@ -1071,9 +1071,9 @@ static inline uint32_t ObjectAddressForHashing(Address object) {
return value & kPageAlignmentMask;
}
static inline Handle<Object> MakeEntryPair(Isolate* isolate, uint32_t index,
static inline Handle<Object> MakeEntryPair(Isolate* isolate, size_t index,
Handle<Object> value) {
Handle<Object> key = isolate->factory()->Uint32ToString(index);
Handle<Object> key = isolate->factory()->SizeToString(index);
Handle<FixedArray> entry_storage =
isolate->factory()->NewUninitializedFixedArray(2);
{
......
src/objects/objects.cc
View file @ 5d29947d
......@@ -966,6 +966,8 @@ MaybeHandle<FixedArray> CreateListFromArrayLikeFastPath(
length > static_cast<size_t>(FixedArray::kMaxLength)) {
return MaybeHandle<FixedArray>();
}
STATIC_ASSERT(FixedArray::kMaxLength <=
std::numeric_limits<uint32_t>::max());
return array->GetElementsAccessor()->CreateListFromArrayLike(
isolate, array, static_cast<uint32_t>(length));
}
......
src/runtime/runtime-array.cc
View file @ 5d29947d
......@@ -288,9 +288,8 @@ RUNTIME_FUNCTION(Runtime_ArrayIncludes_Slow) {
JSObject::PrototypeHasNoElements(isolate, JSObject::cast(*object))) {
Handle<JSObject> obj = Handle<JSObject>::cast(object);
ElementsAccessor* elements = obj->GetElementsAccessor();
Maybe<bool> result = elements->IncludesValue(isolate, obj, search_element,
static_cast<uint32_t>(index),
static_cast<uint32_t>(len));
Maybe<bool> result =
elements->IncludesValue(isolate, obj, search_element, index, len);
MAYBE_RETURN(result, ReadOnlyRoots(isolate).exception());
return *isolate->factory()->ToBoolean(result.FromJust());
}
......
src/runtime/runtime-typedarray.cc
View file @ 5d29947d
......@@ -166,12 +166,9 @@ RUNTIME_FUNCTION(Runtime_TypedArraySet) {
size_t offset;
CHECK(TryNumberToSize(*offset_obj, &offset));
DCHECK_LE(offset, kMaxUInt32);
ElementsAccessor* accessor = target->GetElementsAccessor();
// TODO(v8:4153): Support huge TypedArrays.
return accessor->CopyElements(source, target, length,
static_cast<uint32_t>(offset));
return accessor->CopyElements(source, target, length, offset);
}
} // namespace internal
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment