1	// Copyright (C) 2016 The Qt Company Ltd.
2	// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4	#include "qv4typedarray_p.h"
5	#include "qv4arrayiterator_p.h"
6	#include "qv4arraybuffer_p.h"
7	#include "qv4symbol_p.h"
8	#include "qv4runtime_p.h"
9	#include <QtCore/qatomic.h>
10
11	#include <cmath>
12
13	using namespace QV4;
14
15	DEFINE_OBJECT_VTABLE(IntrinsicTypedArrayCtor);
16	DEFINE_OBJECT_VTABLE(IntrinsicTypedArrayPrototype);
17	DEFINE_OBJECT_VTABLE(TypedArrayCtor);
18	DEFINE_OBJECT_VTABLE(TypedArrayPrototype);
19	DEFINE_OBJECT_VTABLE(TypedArray);
20
21	Q_STATIC_ASSERT((int)ExecutionEngine::NTypedArrayTypes == (int)NTypedArrayTypes);
22
23	static inline int toInt32(Value v)
24	{
25	Q_ASSERT(v.isNumber());
26	if (v.isInteger())
27	return v.integerValue();
28	return QJSNumberCoercion::toInteger(d: v.doubleValue());
29	}
30
31	static inline double toDouble(Value v)
32	{
33	Q_ASSERT(v.isNumber());
34	if (v.isInteger())
35	return v.integerValue();
36	return v.doubleValue();
37	}
38
39	struct ClampedUInt8 {
40	quint8 c;
41	};
42
43	template <typename T>
44	ReturnedValue typeToValue(T t) {
45	return Encode(t);
46	}
47
48	template <>
49	ReturnedValue typeToValue(ClampedUInt8 t) {
50	return Encode(t.c);
51	}
52
53	template <typename T>
54	T valueToType(Value value)
55	{
56	Q_ASSERT(value.isNumber());
57	int n = toInt32(v: value);
58	return static_cast<T>(n);
59	}
60
61	template <>
62	ClampedUInt8 valueToType(Value value)
63	{
64	Q_ASSERT(value.isNumber());
65	if (value.isInteger())
66	return { .c: static_cast<quint8>(qBound(min: 0, val: value.integerValue(), max: 255)) };
67	Q_ASSERT(value.isDouble());
68	double d = value.doubleValue();
69	// ### is there a way to optimise this?
70	if (d <= 0 || std::isnan(x: d))
71	return { .c: 0 };
72	if (d >= 255)
73	return { .c: 255 };
74	double f = std::floor(x: d);
75	if (f + 0.5 < d)
76	return { .c: (quint8)(f + 1) };
77	if (d < f + 0.5)
78	return { .c: (quint8)(f) };
79	if (int(f) % 2)
80	// odd number
81	return { .c: (quint8)(f + 1) };
82	return { .c: (quint8)(f) };
83	}
84
85	template <>
86	float valueToType(Value value)
87	{
88	Q_ASSERT(value.isNumber());
89	double d = toDouble(v: value);
90	return static_cast<float>(d);
91	}
92
93	template <>
94	double valueToType(Value value)
95	{
96	Q_ASSERT(value.isNumber());
97	return toDouble(v: value);
98	}
99
100	template <typename T>
101	ReturnedValue read(const char *data) {
102	return typeToValue(*reinterpret_cast<const T *>(data));
103	}
104	template <typename T>
105	void write(char *data, Value value)
106	{
107	*reinterpret_cast<T *>(data) = valueToType<T>(value);
108	}
109
110	template <typename T>
111	ReturnedValue atomicAdd(char *data, Value v)
112	{
113	T value = valueToType<T>(v);
114	typename QAtomicOps<T>::Type *mem = reinterpret_cast<typename QAtomicOps<T>::Type *>(data);
115	value = QAtomicOps<T>::fetchAndAddOrdered(*mem, value);
116	return typeToValue(value);
117	}
118
119	template <typename T>
120	ReturnedValue atomicAnd(char *data, Value v)
121	{
122	T value = valueToType<T>(v);
123	typename QAtomicOps<T>::Type *mem = reinterpret_cast<typename QAtomicOps<T>::Type *>(data);
124	value = QAtomicOps<T>::fetchAndAndOrdered(*mem, value);
125	return typeToValue(value);
126	}
127
128	template <typename T>
129	ReturnedValue atomicExchange(char *data, Value v)
130	{
131	T value = valueToType<T>(v);
132	typename QAtomicOps<T>::Type *mem = reinterpret_cast<typename QAtomicOps<T>::Type *>(data);
133	value = QAtomicOps<T>::fetchAndStoreOrdered(*mem, value);
134	return typeToValue(value);
135	}
136
137	template <typename T>
138	ReturnedValue atomicOr(char *data, Value v)
139	{
140	T value = valueToType<T>(v);
141	typename QAtomicOps<T>::Type *mem = reinterpret_cast<typename QAtomicOps<T>::Type *>(data);
142	value = QAtomicOps<T>::fetchAndOrOrdered(*mem, value);
143	return typeToValue(value);
144	}
145
146	template <typename T>
147	ReturnedValue atomicSub(char *data, Value v)
148	{
149	T value = valueToType<T>(v);
150	typename QAtomicOps<T>::Type *mem = reinterpret_cast<typename QAtomicOps<T>::Type *>(data);
151	value = QAtomicOps<T>::fetchAndSubOrdered(*mem, value);
152	return typeToValue(value);
153	}
154
155	template <typename T>
156	ReturnedValue atomicXor(char *data, Value v)
157	{
158	T value = valueToType<T>(v);
159	typename QAtomicOps<T>::Type *mem = reinterpret_cast<typename QAtomicOps<T>::Type *>(data);
160	value = QAtomicOps<T>::fetchAndXorOrdered(*mem, value);
161	return typeToValue(value);
162	}
163
164	template <typename T>
165	ReturnedValue atomicCompareExchange(char *data, Value expected, Value v)
166	{
167	T value = valueToType<T>(v);
168	T exp = valueToType<T>(expected);
169	typename QAtomicOps<T>::Type *mem = reinterpret_cast<typename QAtomicOps<T>::Type *>(data);
170	T old;
171	QAtomicOps<T>::testAndSetOrdered(*mem, exp, value, &old);
172	return typeToValue(old);
173	}
174
175	template <typename T>
176	ReturnedValue atomicLoad(char *data)
177	{
178	typename QAtomicOps<T>::Type *mem = reinterpret_cast<typename QAtomicOps<T>::Type *>(data);
179	T val = QAtomicOps<T>::loadRelaxed(*mem);
180	return typeToValue(val);
181	}
182
183	template <typename T>
184	ReturnedValue atomicStore(char *data, Value v)
185	{
186	T value = valueToType<T>(v);
187	typename QAtomicOps<T>::Type *mem = reinterpret_cast<typename QAtomicOps<T>::Type *>(data);
188	QAtomicOps<T>::storeRelaxed(*mem, value);
189	return typeToValue(value);
190	}
191
192
193	template<typename T>
194	constexpr TypedArrayOperations TypedArrayOperations::create(const char *name)
195	{
196	return { sizeof(T),
197	name,
198	::read<T>,
199	::write<T>,
200	{ nullptr, nullptr, nullptr, nullptr, nullptr, nullptr },
201	nullptr,
202	nullptr,
203	nullptr
204	};
205	}
206
207	template<typename T>
208	constexpr TypedArrayOperations TypedArrayOperations::createWithAtomics(const char *name)
209	{
210	return { sizeof(T),
211	name,
212	::read<T>,
213	::write<T>,
214	{ ::atomicAdd<T>, ::atomicAnd<T>, ::atomicExchange<T>, ::atomicOr<T>, ::atomicSub<T>, ::atomicXor<T> },
215	::atomicCompareExchange<T>,
216	::atomicLoad<T>,
217	::atomicStore<T>
218	};
219	}
220
221	const TypedArrayOperations operations[NTypedArrayTypes] = {
222	#ifdef Q_ATOMIC_INT8_IS_SUPPORTED
223	TypedArrayOperations::createWithAtomics<qint8>(name: "Int8Array"),
224	TypedArrayOperations::createWithAtomics<quint8>(name: "Uint8Array"),
225	#else
226	TypedArrayOperations::create<qint8>("Int8Array"),
227	TypedArrayOperations::create<quint8>("Uint8Array"),
228	#endif
229	TypedArrayOperations::createWithAtomics<qint16>(name: "Int16Array"),
230	TypedArrayOperations::createWithAtomics<quint16>(name: "Uint16Array"),
231	TypedArrayOperations::createWithAtomics<qint32>(name: "Int32Array"),
232	TypedArrayOperations::createWithAtomics<quint32>(name: "Uint32Array"),
233	TypedArrayOperations::create<ClampedUInt8>(name: "Uint8ClampedArray"),
234	TypedArrayOperations::create<float>(name: "Float32Array"),
235	TypedArrayOperations::create<double>(name: "Float64Array")
236	};
237
238
239	void Heap::TypedArrayCtor::init(QV4::ExecutionEngine *engine, TypedArray::Type t)
240	{
241	Heap::FunctionObject::init(engine, name: QLatin1String(operations[t].name));
242	type = t;
243	}
244
245	ReturnedValue TypedArrayCtor::virtualCallAsConstructor(const FunctionObject *f, const Value *argv, int argc, const Value *newTarget)
246	{
247	Scope scope(f->engine());
248	const TypedArrayCtor *that = static_cast<const TypedArrayCtor *>(f);
249
250	auto updateProto = [=](Scope &scope, Scoped<TypedArray> &a) {
251	if (newTarget->heapObject() != f->heapObject() && newTarget->isFunctionObject()) {
252	const FunctionObject *nt = static_cast<const FunctionObject *>(newTarget);
253	ScopedObject o(scope, nt->protoProperty());
254	if (o)
255	a->setPrototypeOf(o);
256	}
257	};
258
259	if (!argc || !argv[0].isObject()) {
260	// ECMA 6 22.2.1.1
261	const double l = argc ? argv[0].toInteger() : 0;
262	if (scope.hasException())
263	return Encode::undefined();
264	if (l < 0 || l > std::numeric_limits<int>::max())
265	return scope.engine->throwRangeError(message: QLatin1String("Index out of range."));
266
267	const double byteLength = l * operations[that->d()->type].bytesPerElement;
268
269	// TODO: This is an artificial restriction due to the fact that we store the byteLength in
270	// uint below. We should allow up to INT_MAX elements of any size.
271	if (byteLength > std::numeric_limits<uint>::max())
272	return scope.engine->throwRangeError(message: QLatin1String("Index out of range."));
273
274	Scoped<ArrayBuffer> buffer(scope, scope.engine->newArrayBuffer(length: size_t(byteLength)));
275	if (scope.hasException())
276	return Encode::undefined();
277
278	Scoped<TypedArray> array(scope, TypedArray::create(e: scope.engine, t: that->d()->type));
279	array->d()->buffer.set(e: scope.engine, newVal: buffer->d());
280	array->d()->byteLength = byteLength;
281	array->d()->byteOffset = 0;
282
283	updateProto(scope, array);
284	return array.asReturnedValue();
285	}
286	Scoped<TypedArray> typedArray(scope, argc ? argv[0] : Value::undefinedValue());
287	if (!!typedArray) {
288	// ECMA 6 22.2.1.2
289	Scoped<ArrayBuffer> buffer(scope, typedArray->d()->buffer);
290	if (!buffer || buffer->hasDetachedArrayData())
291	return scope.engine->throwTypeError();
292	uint srcElementSize = typedArray->bytesPerElement();
293	uint destElementSize = operations[that->d()->type].bytesPerElement;
294	uint byteLength = typedArray->byteLength();
295	uint destByteLength = byteLength*destElementSize/srcElementSize;
296
297	Scoped<ArrayBuffer> newBuffer(scope, scope.engine->newArrayBuffer(length: destByteLength));
298	if (scope.hasException())
299	return Encode::undefined();
300
301	Scoped<TypedArray> array(scope, TypedArray::create(e: scope.engine, t: that->d()->type));
302	array->d()->buffer.set(e: scope.engine, newVal: newBuffer->d());
303	array->d()->byteLength = destByteLength;
304	array->d()->byteOffset = 0;
305
306	const char *src = buffer->constArrayData() + typedArray->byteOffset();
307	char *dest = newBuffer->arrayData();
308
309	// check if src and new type have the same size. In that case we can simply memcpy the data
310	if (srcElementSize == destElementSize) {
311	memcpy(dest: dest, src: src, n: byteLength);
312	} else {
313	// not same size, we need to loop
314	uint l = typedArray->length();
315	TypedArrayOperations::Read read = typedArray->d()->type->read;
316	TypedArrayOperations::Write write =array->d()->type->write;
317	for (uint i = 0; i < l; ++i) {
318	Value val;
319	val.setRawValue(read(src + i*srcElementSize));
320	write(dest + i*destElementSize, val);
321	}
322	}
323
324	updateProto(scope, array);
325	return array.asReturnedValue();
326	}
327	Scoped<ArrayBuffer> buffer(scope, argc ? argv[0] : Value::undefinedValue());
328	if (!!buffer) {
329	// ECMA 6 22.2.1.4
330
331	double dbyteOffset = argc > 1 ? argv[1].toInteger() : 0;
332
333	if (buffer->hasDetachedArrayData())
334	return scope.engine->throwTypeError();
335
336	uint byteOffset = (uint)dbyteOffset;
337	uint elementSize = operations[that->d()->type].bytesPerElement;
338	if (dbyteOffset < 0 || (byteOffset % elementSize) || dbyteOffset > buffer->arrayDataLength())
339	return scope.engine->throwRangeError(QStringLiteral("new TypedArray: invalid byteOffset"));
340
341	uint byteLength;
342	if (argc < 3 || argv[2].isUndefined()) {
343	byteLength = buffer->arrayDataLength() - byteOffset;
344	if (buffer->arrayDataLength() < byteOffset || byteLength % elementSize)
345	return scope.engine->throwRangeError(QStringLiteral("new TypedArray: invalid length"));
346	} else {
347	double l = qBound(min: 0., val: argv[2].toInteger(), max: (double)UINT_MAX);
348	if (scope.hasException())
349	return Encode::undefined();
350	if (buffer->hasDetachedArrayData())
351	return scope.engine->throwTypeError();
352	l *= elementSize;
353	if (buffer->arrayDataLength() - byteOffset < l)
354	return scope.engine->throwRangeError(QStringLiteral("new TypedArray: invalid length"));
355	byteLength = (uint)l;
356	}
357
358	Scoped<TypedArray> array(scope, TypedArray::create(e: scope.engine, t: that->d()->type));
359	array->d()->buffer.set(e: scope.engine, newVal: buffer->d());
360	array->d()->byteLength = byteLength;
361	array->d()->byteOffset = byteOffset;
362
363	updateProto(scope, array);
364	return array.asReturnedValue();
365	}
366
367	// ECMA 6 22.2.1.3
368
369	ScopedObject o(scope, argc ? argv[0] : Value::undefinedValue());
370	uint l = (uint) qBound(min: 0., val: ScopedValue(scope, o->get(name: scope.engine->id_length()))->toInteger(), max: (double)UINT_MAX);
371	if (scope.hasException())
372	return scope.engine->throwTypeError();
373
374	uint elementSize = operations[that->d()->type].bytesPerElement;
375	size_t bufferSize;
376	if (qMulOverflow(v1: size_t(l), v2: size_t(elementSize), r: &bufferSize))
377	return scope.engine->throwRangeError(message: QLatin1String("new TypedArray: invalid length"));
378	Scoped<ArrayBuffer> newBuffer(scope, scope.engine->newArrayBuffer(length: bufferSize));
379	if (scope.hasException())
380	return Encode::undefined();
381
382	Scoped<TypedArray> array(scope, TypedArray::create(e: scope.engine, t: that->d()->type));
383	array->d()->buffer.set(e: scope.engine, newVal: newBuffer->d());
384	array->d()->byteLength = l * elementSize;
385	array->d()->byteOffset = 0;
386
387	uint idx = 0;
388	char *b = newBuffer->arrayData();
389	ScopedValue val(scope);
390	while (idx < l) {
391	val = o->get(idx);
392	val = val->convertedToNumber();
393	if (scope.hasException())
394	return Encode::undefined();
395	array->d()->type->write(b, val);
396	if (scope.hasException())
397	return Encode::undefined();
398	++idx;
399	b += elementSize;
400	}
401
402	updateProto(scope, array);
403	return array.asReturnedValue();
404	}
405
406	ReturnedValue TypedArrayCtor::virtualCall(const FunctionObject *f, const Value *, const Value *, int)
407	{
408	return f->engine()->throwTypeError(QStringLiteral("calling a TypedArray constructor without new is invalid"));
409	}
410
411	void Heap::TypedArray::init(Type t)
412	{
413	Object::init();
414	type = operations + static_cast<int>(t);
415	arrayType = static_cast<int>(t);
416	}
417
418	Heap::TypedArray *TypedArray::create(ExecutionEngine *e, Heap::TypedArray::Type t)
419	{
420	Scope scope(e);
421	Scoped<InternalClass> ic(scope, e->newInternalClass(vtable: staticVTable(), prototype: e->typedArrayPrototype + static_cast<int>(t)));
422	return e->memoryManager->allocObject<TypedArray>(ic: ic->d(), args&: t);
423	}
424
425	ReturnedValue TypedArray::virtualGet(const Managed *m, PropertyKey id, const Value *receiver, bool *hasProperty)
426	{
427	const bool isArrayIndex = id.isArrayIndex();
428	if (!isArrayIndex && !id.isCanonicalNumericIndexString())
429	return Object::virtualGet(m, id, receiver, hasProperty);
430
431	Scope scope(static_cast<const Object *>(m)->engine());
432	Scoped<TypedArray> a(scope, static_cast<const TypedArray *>(m));
433	if (a->hasDetachedArrayData())
434	return scope.engine->throwTypeError();
435
436	if (!isArrayIndex || id.asArrayIndex() >= a->length()) {
437	if (hasProperty)
438	*hasProperty = false;
439	return Encode::undefined();
440	}
441
442	uint bytesPerElement = a->bytesPerElement();
443	uint byteOffset = a->byteOffset() + id.asArrayIndex() * bytesPerElement;
444	Q_ASSERT(byteOffset + bytesPerElement <= a->arrayDataLength());
445
446	if (hasProperty)
447	*hasProperty = true;
448	return a->d()->type->read(a->constArrayData() + byteOffset);
449	}
450
451	bool TypedArray::virtualHasProperty(const Managed *m, PropertyKey id)
452	{
453	const bool isArrayIndex = id.isArrayIndex();
454	if (!isArrayIndex && !id.isCanonicalNumericIndexString())
455	return Object::virtualHasProperty(m, id);
456
457	const TypedArray *a = static_cast<const TypedArray *>(m);
458	if (a->hasDetachedArrayData()) {
459	a->engine()->throwTypeError();
460	return false;
461	}
462	return isArrayIndex && id.asArrayIndex() < a->length();
463	}
464
465	PropertyAttributes TypedArray::virtualGetOwnProperty(const Managed *m, PropertyKey id, Property *p)
466	{
467	if (!id.isArrayIndex() && !id.isCanonicalNumericIndexString())
468	return Object::virtualGetOwnProperty(m, id, p);
469
470	bool hasProperty = false;
471	ReturnedValue v = virtualGet(m, id, receiver: m, hasProperty: &hasProperty);
472	if (p)
473	p->value = v;
474	return hasProperty ? Attr_NotConfigurable : PropertyAttributes();
475	}
476
477	bool TypedArray::virtualPut(Managed *m, PropertyKey id, const Value &value, Value *receiver)
478	{
479	const bool isArrayIndex = id.isArrayIndex();
480	if (!isArrayIndex && !id.isCanonicalNumericIndexString())
481	return Object::virtualPut(m, id, value, receiver);
482
483	ExecutionEngine *v4 = static_cast<Object *>(m)->engine();
484	if (v4->hasException)
485	return false;
486
487	Scope scope(v4);
488	Scoped<TypedArray> a(scope, static_cast<TypedArray *>(m));
489	if (a->hasDetachedArrayData())
490	return scope.engine->throwTypeError();
491
492	if (!isArrayIndex)
493	return false;
494
495	const uint index = id.asArrayIndex();
496	if (index >= a->length())
497	return false;
498
499	uint bytesPerElement = a->bytesPerElement();
500	uint byteOffset = a->byteOffset() + index * bytesPerElement;
501	Q_ASSERT(byteOffset + bytesPerElement <= a->arrayDataLength());
502
503	Value v = Value::fromReturnedValue(val: value.convertedToNumber());
504	if (scope.hasException() || a->hasDetachedArrayData())
505	return scope.engine->throwTypeError();
506	a->d()->type->write(a->arrayData() + byteOffset, v);
507	return true;
508	}
509
510	bool TypedArray::virtualDefineOwnProperty(Managed *m, PropertyKey id, const Property *p, PropertyAttributes attrs)
511	{
512	if (!id.isArrayIndex()) {
513	return !id.isCanonicalNumericIndexString()
514	&& Object::virtualDefineOwnProperty(m, id, p, attrs);
515	}
516
517	const uint index = id.asArrayIndex();
518	TypedArray *a = static_cast<TypedArray *>(m);
519	if (index >= a->length() || attrs.isAccessor())
520	return false;
521
522	if (attrs.hasConfigurable() && attrs.isConfigurable())
523	return false;
524	if (attrs.hasEnumerable() && !attrs.isEnumerable())
525	return false;
526	if (attrs.hasWritable() && !attrs.isWritable())
527	return false;
528	if (!p->value.isEmpty()) {
529	ExecutionEngine *engine = a->engine();
530
531	Value v = Value::fromReturnedValue(val: p->value.convertedToNumber());
532	if (engine->hasException || a->hasDetachedArrayData())
533	return engine->throwTypeError();
534	uint bytesPerElement = a->bytesPerElement();
535	uint byteOffset = a->byteOffset() + index * bytesPerElement;
536	Q_ASSERT(byteOffset + bytesPerElement <= a->arrayDataLength());
537	a->d()->type->write(a->arrayData() + byteOffset, v);
538	}
539	return true;
540	}
541
542	struct TypedArrayOwnPropertyKeyIterator : ObjectOwnPropertyKeyIterator
543	{
544	~TypedArrayOwnPropertyKeyIterator() override = default;
545	PropertyKey next(const Object *o, Property *pd = nullptr, PropertyAttributes *attrs = nullptr) override;
546
547	};
548
549	PropertyKey TypedArrayOwnPropertyKeyIterator::next(const Object *o, Property *pd, PropertyAttributes *attrs)
550	{
551	const TypedArray *a = static_cast<const TypedArray *>(o);
552	if (arrayIndex < a->length()) {
553	if (attrs)
554	*attrs = Attr_NotConfigurable;
555	PropertyKey id = PropertyKey::fromArrayIndex(idx: arrayIndex);
556	if (pd) {
557	bool hasProperty = false;
558	pd->value = TypedArray::virtualGet(m: a, id, receiver: a, hasProperty: &hasProperty);
559	}
560	++arrayIndex;
561	return id;
562	}
563
564	arrayIndex = UINT_MAX;
565	return ObjectOwnPropertyKeyIterator::next(o, pd, attrs);
566	}
567
568	OwnPropertyKeyIterator *TypedArray::virtualOwnPropertyKeys(const Object *m, Value *target)
569	{
570	*target = *m;
571	return new TypedArrayOwnPropertyKeyIterator();
572	}
573
574	void TypedArrayPrototype::init(ExecutionEngine *engine, TypedArrayCtor *ctor)
575	{
576	Scope scope(engine);
577	ScopedObject o(scope);
578
579	ctor->defineReadonlyConfigurableProperty(name: engine->id_length(), value: Value::fromInt32(i: 3));
580	ctor->defineReadonlyProperty(name: engine->id_prototype(), value: *this);
581	ctor->defineReadonlyProperty(QStringLiteral("BYTES_PER_ELEMENT"), value: Value::fromInt32(i: operations[static_cast<int>(ctor->d()->type)].bytesPerElement));
582	ctor->setPrototypeOf(engine->intrinsicTypedArrayCtor());
583
584	setPrototypeOf(engine->intrinsicTypedArrayPrototype());
585	defineDefaultProperty(name: engine->id_constructor(), value: (o = ctor));
586	defineReadonlyProperty(QStringLiteral("BYTES_PER_ELEMENT"), value: Value::fromInt32(i: operations[static_cast<int>(ctor->d()->type)].bytesPerElement));
587	}
588
589	ReturnedValue IntrinsicTypedArrayPrototype::method_get_buffer(const FunctionObject *b, const Value *thisObject, const Value *, int)
590	{
591	ExecutionEngine *v4 = b->engine();
592	const TypedArray *v = thisObject->as<TypedArray>();
593	if (!v)
594	return v4->throwTypeError();
595
596	return v->d()->buffer->asReturnedValue();
597	}
598
599	ReturnedValue IntrinsicTypedArrayPrototype::method_get_byteLength(const FunctionObject *b, const Value *thisObject, const Value *, int)
600	{
601	ExecutionEngine *v4 = b->engine();
602	const TypedArray *v = thisObject->as<TypedArray>();
603	if (!v)
604	return v4->throwTypeError();
605
606	if (v->hasDetachedArrayData())
607	return Encode(0);
608
609	return Encode(v->byteLength());
610	}
611
612	ReturnedValue IntrinsicTypedArrayPrototype::method_get_byteOffset(const FunctionObject *b, const Value *thisObject, const Value *, int)
613	{
614	ExecutionEngine *v4 = b->engine();
615	const TypedArray *v = thisObject->as<TypedArray>();
616	if (!v)
617	return v4->throwTypeError();
618
619	if (v->hasDetachedArrayData())
620	return Encode(0);
621
622	return Encode(v->byteOffset());
623	}
624
625	ReturnedValue IntrinsicTypedArrayPrototype::method_get_length(const FunctionObject *b, const Value *thisObject, const Value *, int)
626	{
627	ExecutionEngine *v4 = b->engine();
628	const TypedArray *v = thisObject->as<TypedArray>();
629	if (!v)
630	return v4->throwTypeError();
631
632	if (v->hasDetachedArrayData())
633	return Encode(0);
634
635	return Encode(v->length());
636	}
637
638	ReturnedValue IntrinsicTypedArrayPrototype::method_copyWithin(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc)
639	{
640	Scope scope(f);
641	Scoped<TypedArray> instance(scope, thisObject);
642	if (!instance || instance->hasDetachedArrayData())
643	return scope.engine->throwTypeError();
644
645	if (!argc)
646	return instance->asReturnedValue();
647
648	const double len = instance->length();
649	Q_ASSERT(std::isfinite(len));
650
651	const double target = argv[0].toInteger();
652
653	const double start = (argc > 1)
654	? argv[1].toInteger()
655	: 0;
656
657	const double end = (argc > 2 && !argv[2].isUndefined())
658	? argv[2].toInteger()
659	: len;
660
661	const double fin = end < 0
662	? std::max(a: len + end, b: 0.0)
663	: std::min(a: end, b: len);
664
665	const qsizetype from = start < 0
666	? std::max(a: len + start, b: 0.0)
667	: std::min(a: start, b: len);
668
669	const qsizetype to = target < 0
670	? std::max(a: len + target, b: 0.0)
671	: std::min(a: target, b: len);
672
673	const qsizetype count = std::min(a: fin - from, b: len - to);
674
675	if (count <= 0)
676	return instance->asReturnedValue();
677
678	if (from != to) {
679	int elementSize = instance->bytesPerElement();
680	char *data = instance->arrayData() + instance->byteOffset();
681	memmove(dest: data + to * elementSize, src: data + from * elementSize, n: count * elementSize);
682	}
683
684	return instance->asReturnedValue();
685	}
686
687	ReturnedValue IntrinsicTypedArrayPrototype::method_entries(const FunctionObject *b, const Value *thisObject, const Value *, int)
688	{
689	Scope scope(b);
690	Scoped<TypedArray> v(scope, thisObject);
691	if (!v || v->hasDetachedArrayData())
692	return scope.engine->throwTypeError();
693
694	Scoped<ArrayIteratorObject> ao(scope, scope.engine->newArrayIteratorObject(o: v));
695	ao->d()->iterationKind = IteratorKind::KeyValueIteratorKind;
696	return ao->asReturnedValue();
697	}
698
699	ReturnedValue IntrinsicTypedArrayPrototype::method_every(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
700	{
701	Scope scope(b);
702	Scoped<TypedArray> v(scope, thisObject);
703	if (!v || v->hasDetachedArrayData())
704	return scope.engine->throwTypeError();
705
706	uint len = v->length();
707
708	if (!argc || !argv->isFunctionObject())
709	THROW_TYPE_ERROR();
710	const FunctionObject *callback = static_cast<const FunctionObject *>(argv);
711
712	ScopedValue that(scope, argc > 1 ? argv[1] : Value::undefinedValue());
713	ScopedValue r(scope);
714	Value *arguments = scope.alloc(nValues: 3);
715
716	const char *data = v->constArrayData();
717	uint bytesPerElement = v->bytesPerElement();
718	uint byteOffset = v->byteOffset();
719
720	bool ok = true;
721	for (uint k = 0; ok && k < len; ++k) {
722	if (v->hasDetachedArrayData())
723	return scope.engine->throwTypeError();
724
725	arguments[0] = v->d()->type->read(data + byteOffset + k * bytesPerElement);
726
727	arguments[1] = Value::fromDouble(d: k);
728	arguments[2] = v;
729	r = callback->call(thisObject: that, argv: arguments, argc: 3);
730	CHECK_EXCEPTION();
731	ok = r->toBoolean();
732	}
733	return Encode(ok);
734	}
735
736	ReturnedValue IntrinsicTypedArrayPrototype::method_fill(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
737	{
738	Scope scope(b);
739	Scoped<TypedArray> v(scope, thisObject);
740	if (!v || v->hasDetachedArrayData())
741	return scope.engine->throwTypeError();
742
743	uint len = v->length();
744	double dlen = len;
745	double relativeStart = argc > 1 ? argv[1].toInteger() : 0.;
746	double relativeEnd = len;
747	if (argc > 2 && !argv[2].isUndefined())
748	relativeEnd = argv[2].toInteger();
749
750	uint k = 0;
751	uint fin = 0;
752
753	if (relativeStart < 0) {
754	k = static_cast<uint>(std::max(a: len+relativeStart, b: 0.));
755	} else {
756	k = static_cast<uint>(std::min(a: relativeStart, b: dlen));
757	}
758
759	if (relativeEnd < 0) {
760	fin = static_cast<uint>(std::max(a: len + relativeEnd, b: 0.));
761	} else {
762	fin = static_cast<uint>(std::min(a: relativeEnd, b: dlen));
763	}
764
765	if (scope.hasException() || v->hasDetachedArrayData())
766	return scope.engine->throwTypeError();
767
768	char *data = v->arrayData();
769	uint bytesPerElement = v->bytesPerElement();
770	uint byteOffset = v->byteOffset();
771
772	Value value;
773	if (!argc)
774	value.setDouble(std::numeric_limits<double>::quiet_NaN());
775	else if (argv[0].isNumber())
776	value = argv[0];
777	else
778	value.setDouble(argv[0].toNumber());
779
780	while (k < fin) {
781	v->d()->type->write(data + byteOffset + k * bytesPerElement, value);
782	k++;
783	}
784
785	return v.asReturnedValue();
786	}
787
788	static TypedArray *typedArraySpeciesCreate(Scope &scope, const TypedArray *instance, uint len)
789	{
790	const FunctionObject *constructor = instance->speciesConstructor(scope, defaultConstructor: scope.engine->typedArrayCtors + instance->d()->arrayType);
791	if (!constructor) {
792	scope.engine->throwTypeError();
793	return nullptr;
794	}
795
796	Value *arguments = scope.alloc(nValues: 1);
797	arguments[0] = Encode(len);
798	Scoped<TypedArray> a(scope, constructor->callAsConstructor(argv: arguments, argc: 1));
799	if (!a || a->hasDetachedArrayData() || a->length() < len) {
800	scope.engine->throwTypeError();
801	return nullptr;
802	}
803	return a;
804	}
805
806	ReturnedValue IntrinsicTypedArrayPrototype::method_filter(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
807	{
808	Scope scope(b);
809	Scoped<TypedArray> instance(scope, thisObject);
810	if (!instance || instance->hasDetachedArrayData())
811	return scope.engine->throwTypeError();
812
813	uint len = instance->length();
814
815	if (!argc || !argv->isFunctionObject())
816	THROW_TYPE_ERROR();
817	const FunctionObject *callback = static_cast<const FunctionObject *>(argv);
818
819	ScopedValue selected(scope);
820	ScopedValue that(scope, argc > 1 ? argv[1] : Value::undefinedValue());
821	Value *arguments = scope.alloc(nValues: 3);
822	Value *list = arguments;
823
824	uint to = 0;
825	for (uint k = 0; k < len; ++k) {
826	if (instance->hasDetachedArrayData())
827	return scope.engine->throwTypeError();
828	bool exists;
829	arguments[0] = instance->get(idx: k, hasProperty: &exists);
830	if (!exists)
831	continue;
832
833	arguments[1] = Value::fromDouble(d: k);
834	arguments[2] = instance;
835	selected = callback->call(thisObject: that, argv: arguments, argc: 3);
836	CHECK_EXCEPTION();
837	if (selected->toBoolean()) {
838	++arguments;
839	scope.alloc(nValues: 1);
840	++to;
841	}
842	}
843
844	TypedArray *a = typedArraySpeciesCreate(scope, instance, len: to);
845	if (!a)
846	return Encode::undefined();
847
848	for (uint i = 0; i < to; ++i)
849	a->put(idx: i, v: list[i]);
850
851	return a->asReturnedValue();
852	}
853
854	ReturnedValue IntrinsicTypedArrayPrototype::method_find(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
855	{
856	Scope scope(b);
857	Scoped<TypedArray> v(scope, thisObject);
858	if (!v || v->hasDetachedArrayData())
859	return scope.engine->throwTypeError();
860
861	uint len = v->length();
862
863	if (!argc || !argv[0].isFunctionObject())
864	THROW_TYPE_ERROR();
865	const FunctionObject *callback = static_cast<const FunctionObject *>(argv);
866
867	ScopedValue result(scope);
868	Value *arguments = scope.alloc(nValues: 3);
869
870	ScopedValue that(scope, argc > 1 ? argv[1] : Value::undefinedValue());
871
872	for (uint k = 0; k < len; ++k) {
873	if (v->hasDetachedArrayData())
874	return scope.engine->throwTypeError();
875	arguments[0] = v->get(idx: k);
876	CHECK_EXCEPTION();
877
878	arguments[1] = Value::fromDouble(d: k);
879	arguments[2] = v;
880	result = callback->call(thisObject: that, argv: arguments, argc: 3);
881
882	CHECK_EXCEPTION();
883	if (result->toBoolean())
884	return arguments[0].asReturnedValue();
885	}
886
887	RETURN_UNDEFINED();
888	}
889
890	ReturnedValue IntrinsicTypedArrayPrototype::method_findIndex(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
891	{
892	Scope scope(b);
893	Scoped<TypedArray> v(scope, thisObject);
894	if (!v || v->hasDetachedArrayData())
895	return scope.engine->throwTypeError();
896
897	uint len = v->length();
898
899	if (!argc || !argv[0].isFunctionObject())
900	THROW_TYPE_ERROR();
901	const FunctionObject *callback = static_cast<const FunctionObject *>(argv);
902
903	ScopedValue result(scope);
904	Value *arguments = scope.alloc(nValues: 3);
905
906	ScopedValue that(scope, argc > 1 ? argv[1] : Value::undefinedValue());
907
908	for (uint k = 0; k < len; ++k) {
909	if (v->hasDetachedArrayData())
910	return scope.engine->throwTypeError();
911	arguments[0] = v->get(idx: k);
912	CHECK_EXCEPTION();
913
914	arguments[1] = Value::fromDouble(d: k);
915	arguments[2] = v;
916	result = callback->call(thisObject: that, argv: arguments, argc: 3);
917
918	CHECK_EXCEPTION();
919	if (result->toBoolean())
920	return Encode(k);
921	}
922
923	return Encode(-1);
924	}
925
926	ReturnedValue IntrinsicTypedArrayPrototype::method_forEach(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
927	{
928	Scope scope(b);
929	Scoped<TypedArray> v(scope, thisObject);
930	if (!v || v->hasDetachedArrayData())
931	return scope.engine->throwTypeError();
932
933	uint len = v->length();
934
935	if (!argc || !argv->isFunctionObject())
936	THROW_TYPE_ERROR();
937	const FunctionObject *callback = static_cast<const FunctionObject *>(argv);
938
939	ScopedValue that(scope, argc > 1 ? argv[1] : Value::undefinedValue());
940	Value *arguments = scope.alloc(nValues: 3);
941
942	for (uint k = 0; k < len; ++k) {
943	if (v->hasDetachedArrayData())
944	return scope.engine->throwTypeError();
945	bool exists;
946	arguments[0] = v->get(idx: k, hasProperty: &exists);
947	if (!exists)
948	continue;
949
950	arguments[1] = Value::fromDouble(d: k);
951	arguments[2] = v;
952	callback->call(thisObject: that, argv: arguments, argc: 3);
953	}
954	RETURN_UNDEFINED();
955	}
956
957
958	ReturnedValue IntrinsicTypedArrayPrototype::method_includes(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
959	{
960	Scope scope(b);
961	Scoped<TypedArray> v(scope, thisObject);
962	if (!v || v->hasDetachedArrayData())
963	return scope.engine->throwTypeError();
964
965	uint len = v->length();
966	if (len == 0) {
967	return Encode(false);
968	}
969
970	double n = 0;
971	if (argc > 1 && !argv[1].isUndefined()) {
972	n = argv[1].toInteger();
973	}
974
975	double k = 0;
976	if (n >= 0) {
977	k = n;
978	} else {
979	k = len + n;
980	if (k < 0) {
981	k = 0;
982	}
983	}
984
985	while (k < len) {
986	ScopedValue val(scope, v->get(idx: k));
987	if (val->sameValueZero(other: argv[0])) {
988	return Encode(true);
989	}
990	k++;
991	}
992
993	return Encode(false);
994	}
995
996	ReturnedValue IntrinsicTypedArrayPrototype::method_indexOf(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
997	{
998	Scope scope(b);
999	Scoped<TypedArray> v(scope, thisObject);
1000	if (!v || v->hasDetachedArrayData())
1001	return scope.engine->throwTypeError();
1002
1003	uint len = v->length();
1004	if (!len)
1005	return Encode(-1);
1006
1007	ScopedValue searchValue(scope, argc ? argv[0] : Value::undefinedValue());
1008	uint fromIndex = 0;
1009
1010	if (argc >= 2) {
1011	double f = argv[1].toInteger();
1012	CHECK_EXCEPTION();
1013	if (f >= len)
1014	return Encode(-1);
1015	if (f < 0)
1016	f = qMax(a: len + f, b: 0.);
1017	fromIndex = (uint) f;
1018	}
1019
1020	if (v->isStringObject()) {
1021	ScopedValue value(scope);
1022	for (uint k = fromIndex; k < len; ++k) {
1023	bool exists;
1024	value = v->get(idx: k, hasProperty: &exists);
1025	if (exists && RuntimeHelpers::strictEqual(x: value, y: searchValue))
1026	return Encode(k);
1027	}
1028	return Encode(-1);
1029	}
1030
1031	ScopedValue value(scope);
1032
1033	for (uint i = fromIndex; i < len; ++i) {
1034	bool exists;
1035	value = v->get(idx: i, hasProperty: &exists);
1036	CHECK_EXCEPTION();
1037	if (exists && RuntimeHelpers::strictEqual(x: value, y: searchValue))
1038	return Encode(i);
1039	}
1040	return Encode(-1);
1041	}
1042
1043	ReturnedValue IntrinsicTypedArrayPrototype::method_join(
1044	const FunctionObject *functionObject, const Value *thisObject, const Value *argv, int argc)
1045	{
1046	Scope scope(functionObject);
1047	Scoped<TypedArray> typedArray(scope, thisObject);
1048	if (!typedArray || typedArray->hasDetachedArrayData())
1049	return scope.engine->throwTypeError();
1050
1051	// We cannot optimize the resolution of the argument away if length is 0.
1052	// It may have side effects.
1053	ScopedValue argument(scope, argc ? argv[0] : Value::undefinedValue());
1054	const QString separator = argument->isUndefined()
1055	? QStringLiteral(",")
1056	: argument->toQString();
1057
1058	const quint32 length = typedArray->length();
1059	if (!length)
1060	return Encode(scope.engine->newString());
1061
1062	QString result;
1063
1064	ScopedString name(scope, scope.engine->newString(QStringLiteral("0")));
1065	ScopedValue value(scope, typedArray->get(name));
1066	if (!value->isNullOrUndefined())
1067	result = value->toQString();
1068
1069	for (quint32 i = 1; i < length; ++i) {
1070	result += separator;
1071
1072	name = Value::fromDouble(d: i).toString(e: scope.engine);
1073	value = typedArray->get(name);
1074	CHECK_EXCEPTION();
1075
1076	if (!value->isNullOrUndefined())
1077	result += value->toQString();
1078	}
1079
1080	return Encode(scope.engine->newString(s: result));
1081	}
1082
1083	ReturnedValue IntrinsicTypedArrayPrototype::method_keys(const FunctionObject *b, const Value *thisObject, const Value *, int)
1084	{
1085	Scope scope(b);
1086	Scoped<TypedArray> v(scope, thisObject);
1087	if (!v || v->hasDetachedArrayData())
1088	return scope.engine->throwTypeError();
1089
1090	Scoped<ArrayIteratorObject> ao(scope, scope.engine->newArrayIteratorObject(o: v));
1091	ao->d()->iterationKind = IteratorKind::KeyIteratorKind;
1092	return ao->asReturnedValue();
1093	}
1094
1095
1096	ReturnedValue IntrinsicTypedArrayPrototype::method_lastIndexOf(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1097	{
1098	Scope scope(b);
1099	Scoped<TypedArray> instance(scope, thisObject);
1100	if (!instance || instance->hasDetachedArrayData())
1101	return scope.engine->throwTypeError();
1102
1103	uint len = instance->length();
1104	if (!len)
1105	return Encode(-1);
1106
1107	ScopedValue searchValue(scope);
1108	uint fromIndex = len;
1109
1110	if (argc >= 1)
1111	searchValue = argv[0];
1112	else
1113	searchValue = Value::undefinedValue();
1114
1115	if (argc >= 2) {
1116	double f = argv[1].toInteger();
1117	CHECK_EXCEPTION();
1118	if (f > 0)
1119	f = qMin(a: f, b: (double)(len - 1));
1120	else if (f < 0) {
1121	f = len + f;
1122	if (f < 0)
1123	return Encode(-1);
1124	}
1125	fromIndex = (uint) f + 1;
1126	}
1127
1128	ScopedValue value(scope);
1129	for (uint k = fromIndex; k > 0;) {
1130	--k;
1131	bool exists;
1132	value = instance->get(idx: k, hasProperty: &exists);
1133	if (exists && RuntimeHelpers::strictEqual(x: value, y: searchValue))
1134	return Encode(k);
1135	}
1136	return Encode(-1);
1137	}
1138
1139	ReturnedValue IntrinsicTypedArrayPrototype::method_map(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1140	{
1141	Scope scope(b);
1142	Scoped<TypedArray> instance(scope, thisObject);
1143	if (!instance || instance->hasDetachedArrayData())
1144	return scope.engine->throwTypeError();
1145
1146	uint len = instance->length();
1147
1148	if (!argc || !argv->isFunctionObject())
1149	THROW_TYPE_ERROR();
1150	const FunctionObject *callback = static_cast<const FunctionObject *>(argv);
1151
1152	TypedArray *a = typedArraySpeciesCreate(scope, instance, len);
1153	if (!a)
1154	return Encode::undefined();
1155
1156	ScopedValue v(scope);
1157	ScopedValue mapped(scope);
1158	ScopedValue that(scope, argc > 1 ? argv[1] : Value::undefinedValue());
1159	Value *arguments = scope.alloc(nValues: 3);
1160
1161	for (uint k = 0; k < len; ++k) {
1162	if (instance->hasDetachedArrayData())
1163	return scope.engine->throwTypeError();
1164	arguments[0] = instance->get(idx: k);
1165
1166	arguments[1] = Value::fromDouble(d: k);
1167	arguments[2] = instance;
1168	mapped = callback->call(thisObject: that, argv: arguments, argc: 3);
1169	CHECK_EXCEPTION();
1170	a->put(idx: k, v: mapped);
1171	}
1172	return a->asReturnedValue();
1173	}
1174
1175	ReturnedValue IntrinsicTypedArrayPrototype::method_reduce(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1176	{
1177	Scope scope(b);
1178	Scoped<TypedArray> instance(scope, thisObject);
1179	if (!instance || instance->hasDetachedArrayData())
1180	return scope.engine->throwTypeError();
1181
1182	uint len = instance->length();
1183
1184	if (!argc || !argv->isFunctionObject())
1185	THROW_TYPE_ERROR();
1186	const FunctionObject *callback = static_cast<const FunctionObject *>(argv);
1187
1188	uint k = 0;
1189	ScopedValue acc(scope);
1190	ScopedValue v(scope);
1191
1192	if (argc > 1) {
1193	acc = argv[1];
1194	} else {
1195	bool kPresent = false;
1196	while (k < len && !kPresent) {
1197	v = instance->get(idx: k, hasProperty: &kPresent);
1198	if (kPresent)
1199	acc = v;
1200	++k;
1201	}
1202	if (!kPresent)
1203	THROW_TYPE_ERROR();
1204	}
1205
1206	Value *arguments = scope.alloc(nValues: 4);
1207
1208	while (k < len) {
1209	if (instance->hasDetachedArrayData())
1210	return scope.engine->throwTypeError();
1211	bool kPresent;
1212	v = instance->get(idx: k, hasProperty: &kPresent);
1213	if (kPresent) {
1214	arguments[0] = acc;
1215	arguments[1] = v;
1216	arguments[2] = Value::fromDouble(d: k);
1217	arguments[3] = instance;
1218	acc = callback->call(thisObject: nullptr, argv: arguments, argc: 4);
1219	CHECK_EXCEPTION();
1220	}
1221	++k;
1222	}
1223	return acc->asReturnedValue();
1224	}
1225
1226	ReturnedValue IntrinsicTypedArrayPrototype::method_reduceRight(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1227	{
1228	Scope scope(b);
1229	Scoped<TypedArray> instance(scope, thisObject);
1230	if (!instance || instance->hasDetachedArrayData())
1231	return scope.engine->throwTypeError();
1232
1233	uint len = instance->length();
1234
1235	if (!argc || !argv->isFunctionObject())
1236	THROW_TYPE_ERROR();
1237	const FunctionObject *callback = static_cast<const FunctionObject *>(argv);
1238
1239	if (len == 0) {
1240	if (argc == 1)
1241	THROW_TYPE_ERROR();
1242	return argv[1].asReturnedValue();
1243	}
1244
1245	uint k = len;
1246	ScopedValue acc(scope);
1247	ScopedValue v(scope);
1248	if (argc > 1) {
1249	acc = argv[1];
1250	} else {
1251	bool kPresent = false;
1252	while (k > 0 && !kPresent) {
1253	v = instance->get(idx: k - 1, hasProperty: &kPresent);
1254	if (kPresent)
1255	acc = v;
1256	--k;
1257	}
1258	if (!kPresent)
1259	THROW_TYPE_ERROR();
1260	}
1261
1262	Value *arguments = scope.alloc(nValues: 4);
1263
1264	while (k > 0) {
1265	if (instance->hasDetachedArrayData())
1266	return scope.engine->throwTypeError();
1267	bool kPresent;
1268	v = instance->get(idx: k - 1, hasProperty: &kPresent);
1269	if (kPresent) {
1270	arguments[0] = acc;
1271	arguments[1] = v;
1272	arguments[2] = Value::fromDouble(d: k - 1);
1273	arguments[3] = instance;
1274	acc = callback->call(thisObject: nullptr, argv: arguments, argc: 4);
1275	CHECK_EXCEPTION();
1276	}
1277	--k;
1278	}
1279	return acc->asReturnedValue();
1280	}
1281
1282	ReturnedValue IntrinsicTypedArrayPrototype::method_reverse(const FunctionObject *b, const Value *thisObject, const Value *, int)
1283	{
1284	Scope scope(b);
1285	Scoped<TypedArray> instance(scope, thisObject);
1286	if (!instance || instance->hasDetachedArrayData())
1287	return scope.engine->throwTypeError();
1288
1289	uint length = instance->length();
1290
1291	int lo = 0, hi = length - 1;
1292
1293	ScopedValue lval(scope);
1294	ScopedValue hval(scope);
1295	for (; lo < hi; ++lo, --hi) {
1296	bool loExists, hiExists;
1297	lval = instance->get(idx: lo, hasProperty: &loExists);
1298	hval = instance->get(idx: hi, hasProperty: &hiExists);
1299	Q_ASSERT(hiExists && loExists);
1300	bool ok;
1301	ok = instance->put(idx: lo, v: hval);
1302	Q_ASSERT(ok);
1303	ok = instance->put(idx: hi, v: lval);
1304	Q_ASSERT(ok);
1305	}
1306	return instance->asReturnedValue();
1307	}
1308
1309	ReturnedValue IntrinsicTypedArrayPrototype::method_some(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1310	{
1311	Scope scope(b);
1312	Scoped<TypedArray> instance(scope, thisObject);
1313	if (!instance || instance->hasDetachedArrayData())
1314	return scope.engine->throwTypeError();
1315
1316	uint len = instance->length();
1317
1318	if (!argc || !argv->isFunctionObject())
1319	THROW_TYPE_ERROR();
1320	const FunctionObject *callback = static_cast<const FunctionObject *>(argv);
1321
1322	ScopedValue that(scope, argc > 1 ? argv[1] : Value::undefinedValue());
1323	ScopedValue result(scope);
1324	Value *arguments = scope.alloc(nValues: 3);
1325
1326	for (uint k = 0; k < len; ++k) {
1327	if (instance->hasDetachedArrayData())
1328	return scope.engine->throwTypeError();
1329	bool exists;
1330	arguments[0] = instance->get(idx: k, hasProperty: &exists);
1331	if (!exists)
1332	continue;
1333
1334	arguments[1] = Value::fromDouble(d: k);
1335	arguments[2] = instance;
1336	result = callback->call(thisObject: that, argv: arguments, argc: 3);
1337	CHECK_EXCEPTION();
1338	if (result->toBoolean())
1339	return Encode(true);
1340	}
1341	return Encode(false);
1342	}
1343
1344
1345	ReturnedValue IntrinsicTypedArrayPrototype::method_values(const FunctionObject *b, const Value *thisObject, const Value *, int)
1346	{
1347	Scope scope(b);
1348	Scoped<TypedArray> v(scope, thisObject);
1349	if (!v || v->hasDetachedArrayData())
1350	return scope.engine->throwTypeError();
1351
1352	Scoped<ArrayIteratorObject> ao(scope, scope.engine->newArrayIteratorObject(o: v));
1353	ao->d()->iterationKind = IteratorKind::ValueIteratorKind;
1354	return ao->asReturnedValue();
1355	}
1356
1357	ReturnedValue IntrinsicTypedArrayPrototype::method_set(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1358	{
1359	Scope scope(b);
1360	Scoped<TypedArray> a(scope, *thisObject);
1361	if (!a)
1362	return scope.engine->throwTypeError();
1363	Scoped<ArrayBuffer> buffer(scope, a->d()->buffer);
1364
1365	double doffset = argc >= 2 ? argv[1].toInteger() : 0;
1366	if (scope.hasException())
1367	RETURN_UNDEFINED();
1368	if (!buffer || buffer->hasDetachedArrayData())
1369	return scope.engine->throwTypeError();
1370
1371	if (doffset < 0 || doffset >= UINT_MAX)
1372	RETURN_RESULT(scope.engine->throwRangeError(QStringLiteral("TypedArray.set: out of range")));
1373	uint offset = (uint)doffset;
1374	uint elementSize = a->bytesPerElement();
1375
1376	Scoped<TypedArray> srcTypedArray(scope, argv[0]);
1377	if (!srcTypedArray) {
1378	// src is a regular object
1379	ScopedObject o(scope, argv[0].toObject(e: scope.engine));
1380	if (scope.hasException() || !o)
1381	return scope.engine->throwTypeError();
1382
1383	double len = ScopedValue(scope, o->get(name: scope.engine->id_length()))->toNumber();
1384	uint l = (uint)len;
1385	if (scope.hasException() || l != len)
1386	return scope.engine->throwTypeError();
1387
1388	const uint aLength = a->length();
1389	if (offset > aLength || l > aLength - offset)
1390	RETURN_RESULT(scope.engine->throwRangeError(QStringLiteral("TypedArray.set: out of range")));
1391
1392	uint idx = 0;
1393	if (buffer->hasDetachedArrayData())
1394	return scope.engine->throwTypeError();
1395	char *b = buffer->arrayData() + a->byteOffset() + offset*elementSize;
1396	ScopedValue val(scope);
1397	while (idx < l) {
1398	val = o->get(idx);
1399	if (scope.hasException())
1400	return Encode::undefined();
1401	val = val->convertedToNumber();
1402	if (scope.hasException() || buffer->hasDetachedArrayData())
1403	return scope.engine->throwTypeError();
1404	a->d()->type->write(b, val);
1405	if (scope.hasException())
1406	RETURN_UNDEFINED();
1407	++idx;
1408	b += elementSize;
1409	}
1410	RETURN_UNDEFINED();
1411	}
1412
1413	// src is a typed array
1414	Scoped<ArrayBuffer> srcBuffer(scope, srcTypedArray->d()->buffer);
1415	if (!srcBuffer || srcBuffer->hasDetachedArrayData())
1416	return scope.engine->throwTypeError();
1417
1418	uint l = srcTypedArray->length();
1419
1420	const uint aLength = a->length();
1421	if (offset > aLength || l > aLength - offset)
1422	RETURN_RESULT(scope.engine->throwRangeError(QStringLiteral("TypedArray.set: out of range")));
1423
1424	char *dest = buffer->arrayData() + a->byteOffset() + offset*elementSize;
1425	const char *src = srcBuffer->d()->constArrayData() + srcTypedArray->byteOffset();
1426	if (srcTypedArray->d()->type == a->d()->type) {
1427	// same type of typed arrays, use memmove (as srcbuffer and buffer could be the same)
1428	memmove(dest: dest, src: src, n: srcTypedArray->byteLength());
1429	RETURN_UNDEFINED();
1430	}
1431
1432	char *srcCopy = nullptr;
1433	if (buffer->d() == srcBuffer->d()) {
1434	// same buffer, need to take a temporary copy, to not run into problems
1435	srcCopy = new char[srcTypedArray->byteLength()];
1436	memcpy(dest: srcCopy, src: src, n: srcTypedArray->byteLength());
1437	src = srcCopy;
1438	}
1439
1440	// typed arrays of different kind, need to manually loop
1441	uint srcElementSize = srcTypedArray->bytesPerElement();
1442	TypedArrayOperations::Read read = srcTypedArray->d()->type->read;
1443	TypedArrayOperations::Write write = a->d()->type->write;
1444	for (uint i = 0; i < l; ++i) {
1445	Value val;
1446	val.setRawValue(read(src + i*srcElementSize));
1447	write(dest + i*elementSize, val);
1448	}
1449
1450	if (srcCopy)
1451	delete [] srcCopy;
1452
1453	RETURN_UNDEFINED();
1454	}
1455
1456	ReturnedValue IntrinsicTypedArrayPrototype::method_slice(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
1457	{
1458	Scope scope(b);
1459	Scoped<TypedArray> instance(scope, thisObject);
1460	if (!instance || instance->hasDetachedArrayData())
1461	return scope.engine->throwTypeError();
1462
1463	uint len = instance->length();
1464
1465	double s = (argc ? argv[0] : Value::undefinedValue()).toInteger();
1466	uint start;
1467	if (s < 0)
1468	start = (uint)qMax(a: len + s, b: 0.);
1469	else if (s > len)
1470	start = len;
1471	else
1472	start = (uint) s;
1473	uint end = len;
1474	if (argc > 1 && !argv[1].isUndefined()) {
1475	double e = argv[1].toInteger();
1476	if (e < 0)
1477	end = (uint)qMax(a: len + e, b: 0.);
1478	else if (e > len)
1479	end = len;
1480	else
1481	end = (uint) e;
1482	}
1483	uint count = start > end ? 0 : end - start;
1484
1485	TypedArray *a = typedArraySpeciesCreate(scope, instance, len: count);
1486	if (!a)
1487	return Encode::undefined();
1488
1489	ScopedValue v(scope);
1490	uint n = 0;
1491	for (uint i = start; i < end; ++i) {
1492	if (instance->hasDetachedArrayData())
1493	return scope.engine->throwTypeError();
1494	v = instance->get(idx: i);
1495	if (a->hasDetachedArrayData())
1496	return scope.engine->throwTypeError();
1497	a->put(idx: n, v);
1498	++n;
1499	}
1500	return a->asReturnedValue();
1501	}
1502
1503	ReturnedValue IntrinsicTypedArrayPrototype::method_subarray(const FunctionObject *builtin, const Value *thisObject, const Value *argv, int argc)
1504	{
1505	Scope scope(builtin);
1506	Scoped<TypedArray> a(scope, *thisObject);
1507
1508	if (!a)
1509	return scope.engine->throwTypeError();
1510
1511	Scoped<ArrayBuffer> buffer(scope, a->d()->buffer);
1512	Q_ASSERT(buffer);
1513
1514	int len = a->length();
1515	double b = argc > 0 ? argv[0].toInteger() : 0;
1516	if (b < 0)
1517	b = len + b;
1518	uint begin = (uint)qBound(min: 0., val: b, max: (double)len);
1519
1520	double e = argc < 2 || argv[1].isUndefined() ? len : argv[1].toInteger();
1521	if (e < 0)
1522	e = len + e;
1523	uint end = (uint)qBound(min: 0., val: e, max: (double)len);
1524	if (end < begin)
1525	end = begin;
1526
1527	if (scope.hasException())
1528	RETURN_UNDEFINED();
1529
1530	int newLen = end - begin;
1531
1532	ScopedFunctionObject constructor(scope, a->speciesConstructor(scope, defaultConstructor: scope.engine->typedArrayCtors + a->d()->arrayType));
1533	if (!constructor)
1534	return scope.engine->throwTypeError();
1535
1536	Value *arguments = scope.alloc(nValues: 3);
1537	arguments[0] = buffer;
1538	arguments[1] = Encode(a->byteOffset() + begin * a->bytesPerElement());
1539	arguments[2] = Encode(newLen);
1540	a = constructor->callAsConstructor(argv: arguments, argc: 3);
1541	if (!a || a->hasDetachedArrayData())
1542	return scope.engine->throwTypeError();
1543	return a->asReturnedValue();
1544	}
1545
1546	ReturnedValue IntrinsicTypedArrayPrototype::method_toLocaleString(const FunctionObject *b, const Value *thisObject, const Value *, int)
1547	{
1548	Scope scope(b);
1549	Scoped<TypedArray> instance(scope, thisObject);
1550	if (!instance || instance->hasDetachedArrayData())
1551	return scope.engine->throwTypeError();
1552
1553	uint len = instance->length();
1554	const QString separator = QStringLiteral(",");
1555
1556	QString R;
1557
1558	ScopedValue v(scope);
1559	ScopedString s(scope);
1560
1561	ScopedPropertyKey tolocaleString(scope, scope.engine->id_toLocaleString()->toPropertyKey());
1562	Q_ASSERT(!scope.engine->hasException);
1563
1564	for (uint k = 0; k < len; ++k) {
1565	if (instance->hasDetachedArrayData())
1566	return scope.engine->throwTypeError();
1567	if (k)
1568	R += separator;
1569
1570	v = instance->get(idx: k);
1571	Q_ASSERT(!v->isNullOrUndefined()); // typed array cannot hold null or undefined
1572
1573	ScopedObject valueAsObject(scope, v->toObject(e: scope.engine));
1574	Q_ASSERT(valueAsObject); // only null or undefined cannot be converted to object
1575
1576	ScopedFunctionObject function(scope, valueAsObject->get(id: tolocaleString));
1577	if (!function)
1578	return scope.engine->throwTypeError();
1579
1580	v = function->call(thisObject: valueAsObject, argv: nullptr, argc: 0);
1581	if (scope.hasException())
1582	return Encode::undefined();
1583
1584	s = v->toString(e: scope.engine);
1585	if (scope.hasException())
1586	return Encode::undefined();
1587
1588	R += s->toQString();
1589	}
1590	return scope.engine->newString(s: R)->asReturnedValue();
1591	}
1592
1593	ReturnedValue IntrinsicTypedArrayPrototype::method_get_toStringTag(const FunctionObject *, const Value *thisObject, const Value *, int)
1594	{
1595	const TypedArray *a = thisObject->as<TypedArray>();
1596	if (!a)
1597	return Encode::undefined();
1598
1599	return a->engine()->newString(s: QString::fromLatin1(ba: a->d()->type->name))->asReturnedValue();
1600	}
1601
1602	static bool validateTypedArray(const Object *o)
1603	{
1604	const TypedArray *a = o->as<TypedArray>();
1605	if (!a)
1606	return false;
1607	if (a->hasDetachedArrayData())
1608	return false;
1609	return true;
1610	}
1611
1612	ReturnedValue IntrinsicTypedArrayCtor::method_of(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc)
1613	{
1614	Scope scope(f);
1615	int len = argc;
1616	const Value *items = argv;
1617	const FunctionObject *C = thisObject->as<FunctionObject>();
1618	if (!C || !C->isConstructor())
1619	return scope.engine->throwTypeError();
1620
1621	Value lenValue = Value::fromInt32(i: len);
1622	ScopedObject newObj(scope, C->callAsConstructor(argv: &lenValue, argc: 1));
1623	if (scope.hasException())
1624	return Encode::undefined();
1625	if (!::validateTypedArray(o: newObj))
1626	return scope.engine->throwTypeError();
1627	TypedArray *a = newObj->as<TypedArray>();
1628	Q_ASSERT(a);
1629	if (a->length() < static_cast<uint>(len))
1630	return scope.engine->throwTypeError();
1631
1632	for (int k = 0; k < len; ++k) {
1633	newObj->put(id: PropertyKey::fromArrayIndex(idx: k), v: items[k]);
1634	}
1635	return newObj->asReturnedValue();
1636	}
1637
1638	ReturnedValue IntrinsicTypedArrayCtor::method_from(const FunctionObject *f, const Value *thisObject, const Value *argv, int argc)
1639	{
1640	Scope scope(f);
1641	ScopedObject itemsObject(scope, argv[0]);
1642	bool usingIterator = false;
1643
1644	ScopedFunctionObject mapfn(scope, Value::undefinedValue());
1645	Value *mapArguments = nullptr;
1646	if (argc > 1) {
1647	mapfn = ScopedFunctionObject(scope, argv[1]);
1648	if (!mapfn)
1649	return scope.engine->throwTypeError(message: QString::fromLatin1(ba: "%1 is not a function").arg(a: argv[1].toQStringNoThrow()));
1650	mapArguments = scope.alloc(nValues: 2);
1651	}
1652
1653	// Iterator validity check goes after map function validity has been checked.
1654	if (itemsObject) {
1655	// If the object claims to support iterators, then let's try use them.
1656	ScopedValue it(scope, itemsObject->get(name: scope.engine->symbol_iterator()));
1657	CHECK_EXCEPTION();
1658	if (!it->isNullOrUndefined()) {
1659	ScopedFunctionObject itfunc(scope, it);
1660	if (!itfunc)
1661	return scope.engine->throwTypeError();
1662	usingIterator = true;
1663	}
1664	}
1665
1666	ScopedValue thisArg(scope);
1667	if (argc > 2)
1668	thisArg = argv[2];
1669
1670	const FunctionObject *C = thisObject->as<FunctionObject>();
1671
1672	if (usingIterator) {
1673	// Item iteration supported, so let's go ahead and try use that.
1674	CHECK_EXCEPTION();
1675
1676	qint64 iterableLength = 0;
1677	Value *nextValue = scope.alloc(nValues: 1);
1678	ScopedValue done(scope);
1679
1680	ScopedObject lengthIterator(scope, Runtime::GetIterator::call(scope.engine, itemsObject, true));
1681	CHECK_EXCEPTION(); // symbol_iterator threw; whoops.
1682	if (!lengthIterator) {
1683	return scope.engine->throwTypeError(); // symbol_iterator wasn't an object.
1684	}
1685
1686	forever {
1687	// Here we calculate the length of the iterable range.
1688	if (iterableLength > (static_cast<qint64>(1) << 53) - 1) {
1689	ScopedValue error(scope, scope.engine->throwTypeError());
1690	return Runtime::IteratorClose::call(scope.engine, lengthIterator);
1691	}
1692	// Retrieve the next value. If the iteration ends, we're done here.
1693	done = Value::fromReturnedValue(val: Runtime::IteratorNext::call(scope.engine, lengthIterator, nextValue));
1694	if (scope.hasException())
1695	return Runtime::IteratorClose::call(scope.engine, lengthIterator);
1696	if (done->toBoolean()) {
1697	break;
1698	}
1699	iterableLength++;
1700	}
1701
1702	// Constructor validity check goes after we have calculated the length, because that calculation can throw
1703	// errors that are not type errors and at least the tests expect those rather than type errors.
1704	if (!C || !C->isConstructor())
1705	return scope.engine->throwTypeError();
1706
1707	ScopedObject iterator(scope, Runtime::GetIterator::call(scope.engine, itemsObject, true));
1708	CHECK_EXCEPTION(); // symbol_iterator can throw.
1709	if (!iterator) {
1710	return scope.engine->throwTypeError(); // symbol_iterator wasn't an object.
1711	}
1712
1713	ScopedObject a(scope, Value::undefinedValue());
1714	ScopedValue ctorArgument(scope, Value::fromReturnedValue(val: QV4::Encode(int(iterableLength))));
1715	a = C->callAsConstructor(argv: ctorArgument, argc: 1);
1716	CHECK_EXCEPTION();
1717
1718	// We check exceptions above, and only after doing so, check the array's validity after construction.
1719	if (!::validateTypedArray(o: a) || (a->getLength() < iterableLength))
1720	return scope.engine->throwTypeError();
1721
1722
1723	// The loop below traverses the iterator, and puts elements into the created array.
1724	ScopedValue mappedValue(scope, Value::undefinedValue());
1725	for (qint64 k = 0; k < iterableLength; ++k) {
1726	done = Value::fromReturnedValue(val: Runtime::IteratorNext::call(scope.engine, iterator, nextValue));
1727	if (scope.hasException())
1728	return Runtime::IteratorClose::call(scope.engine, iterator);
1729
1730	if (mapfn) {
1731	mapArguments[0] = *nextValue;
1732	mapArguments[1] = Value::fromDouble(d: k);
1733	mappedValue = mapfn->call(thisObject: thisArg, argv: mapArguments, argc: 2);
1734	if (scope.hasException())
1735	return Runtime::IteratorClose::call(scope.engine, iterator);
1736	} else {
1737	mappedValue = *nextValue;
1738	}
1739
1740	a->put(idx: k, v: mappedValue);
1741	if (scope.hasException())
1742	return Runtime::IteratorClose::call(scope.engine, iterator);
1743	}
1744	return a.asReturnedValue();
1745	} else {
1746	// Array-like fallback. We request elements by index, and put them into the created array.
1747	ScopedObject arrayLike(scope, argv[0].toObject(e: scope.engine));
1748	if (!arrayLike)
1749	return scope.engine->throwTypeError(message: QString::fromLatin1(ba: "Cannot convert %1 to object").arg(a: argv[0].toQStringNoThrow()));
1750
1751	int len = arrayLike->getLength();
1752	CHECK_EXCEPTION();
1753
1754	// Getting the length may throw, and must do so before we check the constructor validity.
1755	if (!C || !C->isConstructor())
1756	return scope.engine->throwTypeError();
1757
1758	ScopedObject a(scope, Value::undefinedValue());
1759	ScopedValue ctorArgument(scope, Value::fromReturnedValue(val: QV4::Encode(len)));
1760	a = C->callAsConstructor(argv: ctorArgument, argc: 1);
1761	CHECK_EXCEPTION();
1762
1763	// We check exceptions above, and only after doing so, check the array's validity after construction.
1764	if (!::validateTypedArray(o: a) || (a->getLength() < len))
1765	return scope.engine->throwTypeError();
1766
1767	ScopedValue mappedValue(scope, Value::undefinedValue());
1768	ScopedValue kValue(scope);
1769	for (int k = 0; k < len; ++k) {
1770	kValue = arrayLike->get(idx: k);
1771	CHECK_EXCEPTION();
1772
1773	if (mapfn) {
1774	mapArguments[0] = kValue;
1775	mapArguments[1] = Value::fromDouble(d: k);
1776	mappedValue = mapfn->call(thisObject: thisArg, argv: mapArguments, argc: 2);
1777	CHECK_EXCEPTION();
1778	} else {
1779	mappedValue = kValue;
1780	}
1781
1782	a->put(idx: k, v: mappedValue);
1783	CHECK_EXCEPTION();
1784	}
1785	return a.asReturnedValue();
1786	}
1787	}
1788
1789	void IntrinsicTypedArrayPrototype::init(ExecutionEngine *engine, IntrinsicTypedArrayCtor *ctor)
1790	{
1791	Scope scope(engine);
1792	ctor->defineReadonlyProperty(name: engine->id_prototype(), value: *this);
1793	ctor->defineReadonlyConfigurableProperty(name: engine->id_length(), value: Value::fromInt32(i: 0));
1794	ScopedString s(scope, engine->newString(QStringLiteral("TypedArray")));
1795	ctor->defineReadonlyConfigurableProperty(name: engine->id_name(), value: s);
1796	s = scope.engine->newString(QStringLiteral("of"));
1797	ctor->defineDefaultProperty(name: s, code: IntrinsicTypedArrayCtor::method_of);
1798	s = scope.engine->newString(QStringLiteral("from"));
1799	ctor->defineDefaultProperty(name: s, code: IntrinsicTypedArrayCtor::method_from, argumentCount: 1);
1800	ctor->addSymbolSpecies();
1801
1802	defineAccessorProperty(QStringLiteral("buffer"), getter: method_get_buffer, setter: nullptr);
1803	defineAccessorProperty(QStringLiteral("byteLength"), getter: method_get_byteLength, setter: nullptr);
1804	defineAccessorProperty(QStringLiteral("byteOffset"), getter: method_get_byteOffset, setter: nullptr);
1805	defineAccessorProperty(QStringLiteral("length"), getter: method_get_length, setter: nullptr);
1806
1807	defineDefaultProperty(QStringLiteral("copyWithin"), code: method_copyWithin, argumentCount: 2);
1808	defineDefaultProperty(QStringLiteral("entries"), code: method_entries, argumentCount: 0);
1809	defineDefaultProperty(QStringLiteral("every"), code: method_every, argumentCount: 1);
1810	defineDefaultProperty(QStringLiteral("fill"), code: method_fill, argumentCount: 1);
1811	defineDefaultProperty(QStringLiteral("filter"), code: method_filter, argumentCount: 1);
1812	defineDefaultProperty(QStringLiteral("find"), code: method_find, argumentCount: 1);
1813	defineDefaultProperty(QStringLiteral("findIndex"), code: method_findIndex, argumentCount: 1);
1814	defineDefaultProperty(QStringLiteral("forEach"), code: method_forEach, argumentCount: 1);
1815	defineDefaultProperty(QStringLiteral("includes"), code: method_includes, argumentCount: 1);
1816	defineDefaultProperty(QStringLiteral("indexOf"), code: method_indexOf, argumentCount: 1);
1817	defineDefaultProperty(QStringLiteral("join"), code: method_join, argumentCount: 1);
1818	defineDefaultProperty(QStringLiteral("keys"), code: method_keys, argumentCount: 0);
1819	defineDefaultProperty(QStringLiteral("lastIndexOf"), code: method_lastIndexOf, argumentCount: 1);
1820	defineDefaultProperty(QStringLiteral("map"), code: method_map, argumentCount: 1);
1821	defineDefaultProperty(QStringLiteral("reduce"), code: method_reduce, argumentCount: 1);
1822	defineDefaultProperty(QStringLiteral("reduceRight"), code: method_reduceRight, argumentCount: 1);
1823	defineDefaultProperty(QStringLiteral("reverse"), code: method_reverse, argumentCount: 0);
1824	defineDefaultProperty(QStringLiteral("some"), code: method_some, argumentCount: 1);
1825	defineDefaultProperty(QStringLiteral("set"), code: method_set, argumentCount: 1);
1826	defineDefaultProperty(QStringLiteral("slice"), code: method_slice, argumentCount: 2);
1827	defineDefaultProperty(QStringLiteral("subarray"), code: method_subarray, argumentCount: 2);
1828	defineDefaultProperty(name: engine->id_toLocaleString(), code: method_toLocaleString, argumentCount: 0);
1829	ScopedObject f(scope, engine->arrayPrototype()->get(name: engine->id_toString()));
1830	defineDefaultProperty(name: engine->id_toString(), value: f);
1831
1832	ScopedString valuesString(scope, engine->newIdentifier(QStringLiteral("values")));
1833	ScopedObject values(scope, FunctionObject::createBuiltinFunction(engine, nameOrSymbol: valuesString, code: method_values, argumentCount: 0));
1834	defineDefaultProperty(QStringLiteral("values"), value: values);
1835	defineDefaultProperty(name: engine->symbol_iterator(), value: values);
1836
1837	defineAccessorProperty(name: engine->symbol_toStringTag(), getter: method_get_toStringTag, setter: nullptr);
1838	}
1839