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 "qv4runtime_p.h"
5
6	#include <private/qqmlengine_p.h>
7	#include <private/qqmljavascriptexpression_p.h>
8	#include <private/qqmljsast_p.h>
9	#include <private/qqmltypewrapper_p.h>
10	#include <private/qqmlvaluetypewrapper_p.h>
11	#include <private/qv4argumentsobject_p.h>
12	#include <private/qv4engine_p.h>
13	#include <private/qv4function_p.h>
14	#include <private/qv4generatorobject_p.h>
15	#include <private/qv4global_p.h>
16	#include <private/qv4globalobject_p.h>
17	#include <private/qv4jscall_p.h>
18	#include <private/qv4lookup_p.h>
19	#include <private/qv4math_p.h>
20	#include <private/qv4object_p.h>
21	#include <private/qv4qmlcontext_p.h>
22	#include <private/qv4qobjectwrapper_p.h>
23	#include <private/qv4regexp_p.h>
24	#include <private/qv4regexpobject_p.h>
25	#include <private/qv4scopedvalue_p.h>
26	#include <private/qv4stackframe_p.h>
27	#include <private/qv4symbol_p.h>
28
29	#include <wtf/MathExtras.h>
30
31	#include <QtCore/private/qlocale_tools_p.h>
32	#include <QtCore/qdebug.h>
33
34	#ifdef QV4_COUNT_RUNTIME_FUNCTIONS
35	# include <QtCore/qbuffer.h>
36	#endif // QV4_COUNT_RUNTIME_FUNCTIONS
37
38	#include <cassert>
39	#include <cstdio>
40	#include <stdlib.h>
41
42	QT_BEGIN_NAMESPACE
43
44	Q_LOGGING_CATEGORY(lcCoercingTypeAssertion, "qt.qml.coercingTypeAssertion");
45
46	namespace QV4 {
47
48	#ifdef QV4_COUNT_RUNTIME_FUNCTIONS
49	struct RuntimeCounters::Data {
50	enum Type {
51	None = 0,
52	Undefined = 1,
53	Null = 2,
54	Boolean = 3,
55	Integer = 4,
56	Managed = 5,
57	Double = 7
58	};
59
60	static const char *pretty(Type t) {
61	switch (t) {
62	case None: return "";
63	case Undefined: return "Undefined";
64	case Null: return "Null";
65	case Boolean: return "Boolean";
66	case Integer: return "Integer";
67	case Managed: return "Managed";
68	case Double: return "Double";
69	default: return "Unknown";
70	}
71	}
72
73	static unsigned mangle(unsigned tag) {
74	switch (tag) {
75	case Value::Undefined_Type: return Undefined;
76	case Value::Null_Type: return Null;
77	case Value::Boolean_Type: return Boolean;
78	case Value::Integer_Type: return Integer;
79	case Value::Managed_Type: return Managed;
80	default: return Double;
81	}
82	}
83
84	static unsigned mangle(unsigned tag1, unsigned tag2) {
85	return (mangle(tag1) << 3) | mangle(tag2);
86	}
87
88	static void unmangle(unsigned signature, Type &tag1, Type &tag2) {
89	tag1 = Type((signature >> 3) & 7);
90	tag2 = Type(signature & 7);
91	}
92
93	typedef QVector<quint64> Counters;
94	QHash<const char *, Counters> counters;
95
96	inline void count(const char *func) {
97	QVector<quint64> &cnt = counters[func];
98	if (cnt.isEmpty())
99	cnt.resize(64);
100	cnt[0] += 1;
101	}
102
103	inline void count(const char *func, unsigned tag) {
104	QVector<quint64> &cnt = counters[func];
105	if (cnt.isEmpty())
106	cnt.resize(64);
107	cnt[mangle(tag)] += 1;
108	}
109
110	inline void count(const char *func, unsigned tag1, unsigned tag2) {
111	QVector<quint64> &cnt = counters[func];
112	if (cnt.isEmpty())
113	cnt.resize(64);
114	cnt[mangle(tag1, tag2)] += 1;
115	}
116
117	struct Line {
118	const char *func;
119	Type tag1, tag2;
120	quint64 count;
121
122	static bool less(const Line &line1, const Line &line2) {
123	return line1.count > line2.count;
124	}
125	};
126
127	void dump() const {
128	QBuffer buf;
129	buf.open(QIODevice::WriteOnly);
130	QTextStream outs(&buf);
131	QList<Line> lines;
132	for (auto it = counters.cbegin(), end = counters.cend(); it != end; ++it) {
133	const Counters &fCount = it.value();
134	for (int i = 0, ei = fCount.size(); i != ei; ++i) {
135	quint64 count = fCount[i];
136	if (!count)
137	continue;
138	Line line;
139	line.func = it.key();
140	unmangle(i, line.tag1, line.tag2);
141	line.count = count;
142	lines.append(line);
143	}
144	}
145	std::sort(lines.begin(), lines.end(), Line::less);
146	outs << lines.size() << " counters:" << endl;
147	for (const Line &line : std::as_const(lines))
148	outs << qSetFieldWidth(10) << line.count << qSetFieldWidth(0)
149	<< " | " << line.func
150	<< " | " << pretty(line.tag1)
151	<< " | " << pretty(line.tag2)
152	<< endl;
153	qDebug("%s", buf.data().constData());
154	}
155	};
156
157	RuntimeCounters *RuntimeCounters::instance = 0;
158	static RuntimeCounters runtimeCountersInstance;
159	RuntimeCounters::RuntimeCounters()
160	: d(new Data)
161	{
162	if (!instance)
163	instance = this;
164	}
165
166	RuntimeCounters::~RuntimeCounters()
167	{
168	d->dump();
169	delete d;
170	}
171
172	void RuntimeCounters::count(const char *func)
173	{
174	d->count(func);
175	}
176
177	void RuntimeCounters::count(const char *func, uint tag)
178	{
179	d->count(func, tag);
180	}
181
182	void RuntimeCounters::count(const char *func, uint tag1, uint tag2)
183	{
184	d->count(func, tag1, tag2);
185	}
186
187	#endif // QV4_COUNT_RUNTIME_FUNCTIONS
188
189	static QV4::Lookup *runtimeLookup(Function *f, uint i)
190	{
191	return f->executableCompilationUnit()->runtimeLookups + i;
192	}
193
194	void RuntimeHelpers::numberToString(QString *result, double num, int radix)
195	{
196	Q_ASSERT(result);
197
198	if (std::isnan(x: num)) {
199	*result = QStringLiteral("NaN");
200	return;
201	} else if (qt_is_inf(d: num)) {
202	*result = num < 0 ? QStringLiteral("-Infinity") : QStringLiteral("Infinity");
203	return;
204	}
205
206	if (radix == 10) {
207	// We cannot use our usual locale->toString(...) here, because EcmaScript has special rules
208	// about the longest permissible number, depending on if it's <0 or >0.
209	const int ecma_shortest_low = -6;
210	const int ecma_shortest_high = 21;
211
212	const QLatin1Char zero('0');
213	const QLatin1Char dot('.');
214
215	int decpt = 0;
216	int sign = 0;
217	*result = qdtoa(d: num, decpt: &decpt, sign: &sign);
218
219	if (decpt <= ecma_shortest_low || decpt > ecma_shortest_high) {
220	if (result->size() > 1)
221	result->insert(i: 1, c: dot);
222	result->append(c: QLatin1Char('e'));
223	if (decpt > 0)
224	result->append(c: QLatin1Char('+'));
225	result->append(s: QString::number(decpt - 1));
226	} else if (decpt <= 0) {
227	result->prepend(s: QLatin1String("0.") + QString(-decpt, zero));
228	} else if (decpt < result->size()) {
229	result->insert(i: decpt, c: dot);
230	} else {
231	result->append(s: QString(decpt - result->size(), zero));
232	}
233
234	if (sign && num)
235	result->prepend(c: QLatin1Char('-'));
236
237	return;
238	}
239
240	result->clear();
241	bool negative = false;
242
243	if (num < 0) {
244	negative = true;
245	num = -num;
246	}
247
248	double frac = num - ::floor(x: num);
249	num = Value::toInteger(d: num);
250
251	do {
252	char c = (char)::fmod(x: num, y: radix);
253	c = (c < 10) ? (c + '0') : (c - 10 + 'a');
254	result->prepend(c: QLatin1Char(c));
255	num = ::floor(x: num / radix);
256	} while (num != 0);
257
258	if (frac != 0) {
259	result->append(c: QLatin1Char('.'));
260	double magnitude = 1;
261	double next = frac;
262	do {
263	next *= radix;
264	const int floored = ::floor(x: next);
265	char c = char(floored);
266	c = (c < 10) ? (c + '0') : (c - 10 + 'a');
267	result->append(c: QLatin1Char(c));
268	magnitude /= radix;
269	frac -= double(floored) * magnitude;
270	next -= double(floored);
271
272	// The next digit still makes a difference
273	// if a value of "radix" for it would change frac.
274	// Otherwise we've reached the limit of numerical precision.
275	} while (frac > 0 && frac - magnitude != frac);
276	}
277
278	if (negative)
279	result->prepend(c: QLatin1Char('-'));
280	}
281
282	ReturnedValue Runtime::Closure::call(ExecutionEngine *engine, int functionId)
283	{
284	QV4::Function *clos = engine->currentStackFrame->v4Function->executableCompilationUnit()
285	->runtimeFunctions[functionId];
286	Q_ASSERT(clos);
287	ExecutionContext *current = engine->currentContext();
288	Scope s(engine);
289	QV4::ScopedObject closure(s);
290
291	if (clos->isGenerator())
292	closure = GeneratorFunction::create(scope: current, function: clos)->asReturnedValue();
293	else
294	closure = FunctionObject::createScriptFunction(scope: current, function: clos)->asReturnedValue();
295	// ### TODO: only keep reference to scripts if actually needed; see QTBUG-130795
296	Scoped<QV4::QmlContext> callingQmlContext(s, s.engine->qmlContext());
297	if (callingQmlContext) {
298	// ### TODO: It would be more efficient to use custom Function prototypes instead of setting a property
299	// ==> QTBUG-130798
300	Scoped<QV4::QQmlContextWrapper> qmlContextWrapper(s, callingQmlContext->d()->qml());
301	const QV4::QQmlContextWrapper *resource = qmlContextWrapper;
302	QQmlRefPointer<QQmlContextData> context = resource->getContext();
303	if (!context->importedScripts().isNullOrUndefined()) {
304	QV4::ScopedString name(s, engine->newString(s: QLatin1StringView("$importedScripts")));
305	QV4::ScopedObject scripts(s, context->importedScripts());
306	closure->insertMember(s: name, v: scripts, attributes: Attr_Invalid);
307	}
308	}
309	return closure.asReturnedValue();
310	}
311
312	Bool Runtime::DeleteProperty_NoThrow::call(ExecutionEngine *engine, const Value &base, const Value &index)
313	{
314	Scope scope(engine);
315	ScopedObject o(scope, base.toObject(e: engine));
316	if (scope.hasException())
317	return Encode::undefined();
318	Q_ASSERT(o);
319
320	ScopedPropertyKey key(scope, index.toPropertyKey(e: engine));
321	if (engine->hasException)
322	return false;
323	return o->deleteProperty(id: key);
324	}
325
326	ReturnedValue Runtime::DeleteProperty::call(ExecutionEngine *engine, QV4::Function *function, const QV4::Value &base, const QV4::Value &index)
327	{
328	if (!Runtime::DeleteProperty_NoThrow::call(engine, base, index)) {
329	if (function->isStrict())
330	engine->throwTypeError();
331	return Encode(false);
332	} else {
333	return Encode(true);
334	}
335	}
336
337	Bool Runtime::DeleteName_NoThrow::call(ExecutionEngine *engine, int nameIndex)
338	{
339	Scope scope(engine);
340	ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
341	return engine->currentContext()->deleteProperty(name);
342	}
343
344	ReturnedValue Runtime::DeleteName::call(ExecutionEngine *engine, Function *function, int name)
345	{
346	if (!Runtime::DeleteName_NoThrow::call(engine, nameIndex: name)) {
347	if (function->isStrict())
348	engine->throwTypeError();
349	return Encode(false);
350	} else {
351	return Encode(true);
352	}
353	}
354
355	static QV4::ReturnedValue doInstanceof(ExecutionEngine *engine, const Value &lval, const Value &rval)
356	{
357	// 11.8.6, 5: rval must be an Object
358	const Object *rhs = rval.as<Object>();
359	if (!rhs)
360	return engine->throwTypeError();
361
362	const FunctionObject *f = rhs->as<FunctionObject>();
363	// shortcut hasInstance evaluation. In this case we know that we are calling the regular hasInstance()
364	// method of the FunctionPrototype
365	if (f && f->d()->prototype() == engine->functionPrototype()->d() && !f->hasHasInstanceProperty())
366	return Object::checkedInstanceOf(engine, typeObject: f, var: lval);
367
368	Scope scope(engine);
369	ScopedValue hasInstance(scope, rhs->get(name: engine->symbol_hasInstance()));
370	if (hasInstance->isUndefined())
371	return Encode(rhs->instanceOf(var: lval));
372
373	FunctionObject *fHasInstance = hasInstance->as<FunctionObject>();
374	if (!fHasInstance)
375	return engine->throwTypeError();
376
377	return Encode(fHasInstance->call(thisObject: &rval, argv: &lval, argc: 1));
378	}
379
380	QV4::ReturnedValue Runtime::Instanceof::call(ExecutionEngine *engine, const Value &lval, const Value &rval)
381	{
382	Scope scope(engine);
383	ScopedValue result(scope, doInstanceof(engine, lval, rval));
384	return scope.hasException() ? Encode::undefined() : Encode(result->toBoolean());
385	}
386
387	QV4::ReturnedValue Runtime::As::call(ExecutionEngine *engine, const Value &lval, const Value &rval)
388	{
389	Scope scope(engine);
390	ScopedValue result(scope, doInstanceof(engine, lval, rval));
391
392	if (scope.hasException()) {
393	// "foo instanceof valueType" must not throw an exception.
394	// So this can only be an object type.
395	engine->catchException();
396	return Encode::null();
397	}
398
399	if (result->toBoolean())
400	return lval.asReturnedValue();
401	else if (result->isBoolean())
402	return Encode::null();
403
404	if (engine->callingQmlContext()->valueTypesAreAssertable())
405	return Encode::undefined();
406
407	// Try to convert the value type
408	Scoped<QQmlTypeWrapper> typeWrapper(scope, rval);
409	if (!typeWrapper)
410	return Encode::undefined();
411
412	const auto *stackFrame = engine->currentStackFrame;
413	if (lval.as<QQmlValueTypeWrapper>()) {
414	qCWarning(lcCoercingTypeAssertion).nospace().noquote()
415	<< stackFrame->source() << ':' << stackFrame->lineNumber() << ':'
416	<< " Coercing between incompatible value types mistakenly yields null rather than"
417	<< " undefined. Add 'pragma ValueTypeBehavior: Assertable' to prevent this.";
418	return Encode::null();
419	}
420
421	if (lval.as<QV4::QObjectWrapper>()) {
422	qCWarning(lcCoercingTypeAssertion).nospace().noquote()
423	<< stackFrame->source() << ':' << stackFrame->lineNumber() << ':'
424	<< " Coercing from instances of object types to value types mistakenly yields null"
425	<< " rather than undefined. Add 'pragma ValueTypeBehavior: Assertable' to prevent"
426	<< " this.";
427	return Encode::null();
428	}
429
430	result = coerce(engine, value: lval, qmlType: typeWrapper->d()->type(), isList: false);
431	if (result->isUndefined())
432	return Encode::undefined();
433
434	qCWarning(lcCoercingTypeAssertion).nospace().noquote()
435	<< stackFrame->source() << ':' << stackFrame->lineNumber() << ':'
436	<< " Coercing a value to " << typeWrapper->toQStringNoThrow()
437	<< " using a type assertion. This behavior is deprecated."
438	<< " Add 'pragma ValueTypeBehavior: Assertable' to prevent it.";
439	return result->asReturnedValue();
440	}
441
442	QV4::ReturnedValue Runtime::In::call(ExecutionEngine *engine, const Value &left, const Value &right)
443	{
444	Object *ro = right.objectValue();
445	if (!ro)
446	return engine->throwTypeError();
447	Scope scope(engine);
448	ScopedPropertyKey s(scope, left.toPropertyKey(e: engine));
449	if (scope.hasException())
450	return Encode::undefined();
451	bool r = ro->hasProperty(id: s);
452	return Encode(r);
453	}
454
455	double RuntimeHelpers::stringToNumber(const QString &string)
456	{
457	// The actual maximum valid length is certainly shorter, but due to the sheer number of
458	// different number formatting variants, we rather err on the side of caution here.
459	// For example, you can have up to 772 valid decimal digits left of the dot, as stated in the
460	// libdoubleconversion sources. The same maximum value would be represented by roughly 3.5 times
461	// as many binary digits.
462	const int excessiveLength = 16 * 1024;
463	if (string.size() > excessiveLength)
464	return qQNaN();
465
466	const QStringView s = QStringView(string).trimmed();
467	if (s.startsWith(c: QLatin1Char('0'))) {
468	int base = -1;
469	if (s.startsWith(s: QLatin1String("0x")) || s.startsWith(s: QLatin1String("0X")))
470	base = 16;
471	else if (s.startsWith(s: QLatin1String("0o")) || s.startsWith(s: QLatin1String("0O")))
472	base = 8;
473	else if (s.startsWith(s: QLatin1String("0b")) || s.startsWith(s: QLatin1String("0B")))
474	base = 2;
475	if (base > 0) {
476	bool ok = true;
477	qlonglong num;
478	num = s.mid(pos: 2).toLongLong(ok: &ok, base);
479	if (!ok)
480	return qQNaN();
481	return num;
482	}
483	}
484	bool ok = false;
485	QByteArray ba = s.toLatin1();
486	const char *begin = ba.constData();
487	const char *end = nullptr;
488	double d = qstrtod(s00: begin, se: &end, ok: &ok);
489	if (end - begin != ba.size()) {
490	if (ba == "Infinity" || ba == "+Infinity")
491	d = Q_INFINITY;
492	else if (ba == "-Infinity")
493	d = -Q_INFINITY;
494	else
495	d = std::numeric_limits<double>::quiet_NaN();
496	}
497	return d;
498	}
499
500	Heap::String *RuntimeHelpers::stringFromNumber(ExecutionEngine *engine, double number)
501	{
502	QString qstr;
503	RuntimeHelpers::numberToString(result: &qstr, num: number, radix: 10);
504	return engine->newString(s: qstr);
505	}
506
507	ReturnedValue RuntimeHelpers::objectDefaultValue(const Object *object, int typeHint)
508	{
509	ExecutionEngine *engine = object->internalClass()->engine;
510	if (engine->hasException)
511	return Encode::undefined();
512
513	String *hint;
514	switch (typeHint) {
515	case STRING_HINT:
516	hint = engine->id_string();
517	break;
518	case NUMBER_HINT:
519	hint = engine->id_number();
520	break;
521	default:
522	hint = engine->id_default();
523	break;
524	}
525
526	Scope scope(engine);
527	ScopedFunctionObject toPrimitive(scope, object->get(name: engine->symbol_toPrimitive()));
528	if (engine->hasException)
529	return Encode::undefined();
530	if (toPrimitive) {
531	ScopedValue result(scope, toPrimitive->call(thisObject: object, argv: hint, argc: 1));
532	if (engine->hasException)
533	return Encode::undefined();
534	if (!result->isPrimitive())
535	return engine->throwTypeError();
536	return result->asReturnedValue();
537	}
538
539	if (hint == engine->id_default())
540	hint = engine->id_number();
541	return ordinaryToPrimitive(engine, object, typeHint: hint);
542	}
543
544
545	ReturnedValue RuntimeHelpers::ordinaryToPrimitive(ExecutionEngine *engine, const Object *object, String *typeHint)
546	{
547	Q_ASSERT(!engine->hasException);
548
549	String *meth1 = engine->id_toString();
550	String *meth2 = engine->id_valueOf();
551
552	if (typeHint->propertyKey() == engine->id_number()->propertyKey()) {
553	qSwap(value1&: meth1, value2&: meth2);
554	} else {
555	Q_ASSERT(typeHint->propertyKey() == engine->id_string()->propertyKey());
556	}
557
558	Scope scope(engine);
559	ScopedValue result(scope);
560
561	ScopedValue conv(scope, object->get(name: meth1));
562	if (FunctionObject *o = conv->as<FunctionObject>()) {
563	result = o->call(thisObject: object, argv: nullptr, argc: 0);
564	if (engine->hasException)
565	return Encode::undefined();
566	if (result->isPrimitive())
567	return result->asReturnedValue();
568	}
569
570	if (engine->hasException)
571	return Encode::undefined();
572
573	conv = object->get(name: meth2);
574	if (FunctionObject *o = conv->as<FunctionObject>()) {
575	result = o->call(thisObject: object, argv: nullptr, argc: 0);
576	if (engine->hasException)
577	return Encode::undefined();
578	if (result->isPrimitive())
579	return result->asReturnedValue();
580	}
581
582	return engine->throwTypeError();
583	}
584
585
586	Heap::Object *RuntimeHelpers::convertToObject(ExecutionEngine *engine, const Value &value)
587	{
588	Q_ASSERT(!value.isObject());
589	switch (value.type()) {
590	case Value::Undefined_Type:
591	engine->throwTypeError(message: QLatin1String("Value is undefined and could not be converted to an object"));
592	return nullptr;
593	case Value::Null_Type:
594	engine->throwTypeError(message: QLatin1String("Value is null and could not be converted to an object"));
595	return nullptr;
596	case Value::Boolean_Type:
597	return engine->newBooleanObject(b: value.booleanValue());
598	case Value::Managed_Type:
599	Q_ASSERT(value.isStringOrSymbol());
600	if (!value.isString())
601	return engine->newSymbolObject(symbol: value.symbolValue());
602	return engine->newStringObject(string: value.stringValue());
603	case Value::Integer_Type:
604	default: // double
605	return engine->newNumberObject(value: value.asDouble());
606	}
607	}
608
609	Heap::String *RuntimeHelpers::convertToString(ExecutionEngine *engine, Value value, TypeHint hint)
610	{
611	redo:
612	switch (value.type()) {
613	case Value::Empty_Type:
614	Q_ASSERT(!"empty Value encountered");
615	Q_UNREACHABLE();
616	case Value::Undefined_Type:
617	return engine->id_undefined()->d();
618	case Value::Null_Type:
619	return engine->id_null()->d();
620	case Value::Boolean_Type:
621	if (value.booleanValue())
622	return engine->id_true()->d();
623	else
624	return engine->id_false()->d();
625	case Value::Managed_Type: {
626	if (value.isString())
627	return static_cast<const String &>(value).d();
628	if (value.isSymbol()) {
629	engine->throwTypeError(message: QLatin1String("Cannot convert a symbol to a string."));
630	return nullptr;
631	}
632	value = Value::fromReturnedValue(val: RuntimeHelpers::toPrimitive(value, typeHint: hint));
633	Q_ASSERT(value.isPrimitive());
634	if (value.isString())
635	return static_cast<const String &>(value).d();
636	goto redo;
637	}
638	case Value::Integer_Type:
639	return engine->newString(s: QString::number(value.int_32()));
640	default: // double
641	return RuntimeHelpers::stringFromNumber(engine, number: value.doubleValue());
642	} // switch
643	}
644
645	// This is slightly different from the method above, as
646	// the + operator requires a slightly different conversion
647	static Heap::String *convert_to_string_add(ExecutionEngine *engine, Value value)
648	{
649	return RuntimeHelpers::convertToString(engine, value, hint: PREFERREDTYPE_HINT);
650	}
651
652	QV4::ReturnedValue RuntimeHelpers::addHelper(ExecutionEngine *engine, const Value &left, const Value &right)
653	{
654	Scope scope(engine);
655
656	ScopedValue pleft(scope, RuntimeHelpers::toPrimitive(value: left, typeHint: PREFERREDTYPE_HINT));
657	ScopedValue pright(scope, RuntimeHelpers::toPrimitive(value: right, typeHint: PREFERREDTYPE_HINT));
658	String *sleft = pleft->stringValue();
659	String *sright = pright->stringValue();
660	if (sleft || sright) {
661	if (!sleft) {
662	pleft = convert_to_string_add(engine, value: pleft);
663	sleft = static_cast<String *>(pleft.ptr);
664	}
665	if (!sright) {
666	pright = convert_to_string_add(engine, value: pright);
667	sright = static_cast<String *>(pright.ptr);
668	}
669	if (engine->hasException)
670	return Encode::undefined();
671	if (!sleft->d()->length())
672	return sright->asReturnedValue();
673	if (!sright->d()->length())
674	return sleft->asReturnedValue();
675	MemoryManager *mm = engine->memoryManager;
676	return (mm->alloc<ComplexString>(args: sleft->d(), args: sright->d()))->asReturnedValue();
677	}
678	double x = RuntimeHelpers::toNumber(value: pleft);
679	double y = RuntimeHelpers::toNumber(value: pright);
680	return Encode(x + y);
681	}
682
683	ReturnedValue Runtime::GetTemplateObject::call(Function *function, int index)
684	{
685	return function->executableCompilationUnit()->templateObjectAt(index)->asReturnedValue();
686	}
687
688	void Runtime::StoreProperty::call(ExecutionEngine *engine, const Value &object, int nameIndex, const Value &value)
689	{
690	Scope scope(engine);
691	QV4::Function *v4Function = engine->currentStackFrame->v4Function;
692	ScopedString name(scope, v4Function->compilationUnit->runtimeStrings[nameIndex]);
693	ScopedObject o(scope, object);
694	if (!o) {
695	if (v4Function->isStrict()) {
696	engine->throwTypeError();
697	return;
698	}
699	o = object.toObject(e: engine);
700	}
701	if ((!o || !o->put(name, v: value)) && v4Function->isStrict())
702	engine->throwTypeError();
703	}
704
705	static Q_NEVER_INLINE ReturnedValue getElementIntFallback(ExecutionEngine *engine, const Value &object, uint idx)
706	{
707	Q_ASSERT(idx < UINT_MAX);
708	Scope scope(engine);
709
710	ScopedObject o(scope, object);
711	if (!o) {
712	if (const String *str = object.as<String>()) {
713	if (idx >= (uint)str->toQString().size()) {
714	return Encode::undefined();
715	}
716	const QString s = str->toQString().mid(position: idx, n: 1);
717	return scope.engine->newString(s)->asReturnedValue();
718	}
719
720	if (object.isNullOrUndefined()) {
721	QString message = QStringLiteral("Cannot read property '%1' of %2").arg(a: idx).arg(a: object.toQStringNoThrow());
722	return engine->throwTypeError(message);
723	}
724
725	o = RuntimeHelpers::convertToObject(engine: scope.engine, value: object);
726	Q_ASSERT(!!o); // can't fail as null/undefined is covered above
727	}
728
729	if (o->arrayData() && !o->arrayData()->attrs) {
730	ScopedValue v(scope, o->arrayData()->get(i: idx));
731	if (!v->isEmpty())
732	return v->asReturnedValue();
733	}
734
735	return o->get(idx);
736	}
737
738	static Q_NEVER_INLINE ReturnedValue getElementFallback(ExecutionEngine *engine, const Value &object, const Value &index)
739	{
740	Q_ASSERT(!index.isPositiveInt());
741
742	Scope scope(engine);
743
744	ScopedObject o(scope, object);
745	if (!o) {
746	if (object.isNullOrUndefined()) {
747	QString message = QStringLiteral("Cannot read property '%1' of %2").arg(a: index.toQStringNoThrow()).arg(a: object.toQStringNoThrow());
748	return engine->throwTypeError(message);
749	}
750
751	o = RuntimeHelpers::convertToObject(engine: scope.engine, value: object);
752	Q_ASSERT(!!o); // can't fail as null/undefined is covered above
753	}
754
755	ScopedPropertyKey name(scope, index.toPropertyKey(e: engine));
756	if (scope.hasException())
757	return Encode::undefined();
758	return o->get(id: name);
759	}
760
761	ReturnedValue Runtime::LoadElement::call(ExecutionEngine *engine, const Value &object, const Value &index)
762	{
763	if (index.isPositiveInt()) {
764	uint idx = static_cast<uint>(index.int_32());
765	if (Heap::Base *b = object.heapObject()) {
766	if (b->internalClass->vtable->isObject) {
767	Heap::Object *o = static_cast<Heap::Object *>(b);
768	if (o->arrayData && o->arrayData->type == Heap::ArrayData::Simple) {
769	Heap::SimpleArrayData *s = o->arrayData.cast<Heap::SimpleArrayData>();
770	if (idx < s->values.size)
771	if (!s->data(index: idx).isEmpty())
772	return s->data(index: idx).asReturnedValue();
773	}
774	}
775	}
776	return getElementIntFallback(engine, object, idx);
777	}
778
779	return getElementFallback(engine, object, index);
780	}
781
782	static Q_NEVER_INLINE bool setElementFallback(ExecutionEngine *engine, const Value &object, const Value &index, const Value &value)
783	{
784	Scope scope(engine);
785	ScopedObject o(scope, object);
786	if (!o) {
787	if (engine->currentStackFrame->v4Function->isStrict()) {
788	engine->throwTypeError();
789	return false;
790	}
791
792	o = object.toObject(e: engine);
793	}
794	if (engine->hasException)
795	return false;
796
797	if (index.isPositiveInt()) {
798	uint idx = static_cast<uint>(index.int_32());
799	if (o->d()->arrayData && o->d()->arrayData->type == Heap::ArrayData::Simple) {
800	Heap::SimpleArrayData *s = o->d()->arrayData.cast<Heap::SimpleArrayData>();
801	if (idx < s->values.size) {
802	s->setData(e: engine, index: idx, newVal: value);
803	return true;
804	}
805	}
806	return o->put(idx, v: value);
807	}
808
809	ScopedPropertyKey name(scope, index.toPropertyKey(e: engine));
810	if (engine->hasException)
811	return false;
812	return o->put(id: name, v: value);
813	}
814
815	void Runtime::StoreElement::call(ExecutionEngine *engine, const Value &object, const Value &index, const Value &value)
816	{
817	if (index.isPositiveInt()) {
818	uint idx = static_cast<uint>(index.int_32());
819	if (Heap::Base *b = object.heapObject()) {
820	if (b->internalClass->vtable->isObject) {
821	Heap::Object *o = static_cast<Heap::Object *>(b);
822	if (o->arrayData && o->arrayData->type == Heap::ArrayData::Simple) {
823	Heap::SimpleArrayData *s = o->arrayData.cast<Heap::SimpleArrayData>();
824	if (idx < s->values.size) {
825	s->setData(e: engine, index: idx, newVal: value);
826	return;
827	}
828	}
829	}
830	}
831	}
832
833	if (!setElementFallback(engine, object, index, value) && engine->currentStackFrame->v4Function->isStrict())
834	engine->throwTypeError();
835	}
836
837	ReturnedValue Runtime::GetIterator::call(ExecutionEngine *engine, const Value &in, int iterator)
838	{
839	Scope scope(engine);
840	ScopedObject o(scope, (Object *)nullptr);
841	if (!in.isNullOrUndefined())
842	o = in.toObject(e: engine);
843	if (engine->hasException)
844	return Encode::undefined();
845	if (iterator == static_cast<int>(QQmlJS::AST::ForEachType::Of)) {
846	if (!o)
847	return engine->throwTypeError();
848	ScopedFunctionObject f(scope, o->get(name: engine->symbol_iterator()));
849	if (!f)
850	return engine->throwTypeError();
851	JSCallData cData(o, nullptr, 0);
852	ScopedObject it(scope, f->call(data: cData));
853	if (engine->hasException)
854	return Encode::undefined();
855	if (!it)
856	return engine->throwTypeError();
857	return it->asReturnedValue();
858	}
859	return engine->newForInIteratorObject(o)->asReturnedValue();
860	}
861
862	ReturnedValue Runtime::IteratorNext::call(ExecutionEngine *engine, const Value &iterator, Value *value)
863	{
864	// if we throw an exception from here, return true, not undefined. This is to ensure iteratorDone is set to true
865	// and the stack unwinding won't close the iterator
866	Q_ASSERT(iterator.isObject());
867
868	Scope scope(engine);
869	ScopedFunctionObject f(scope, static_cast<const Object &>(iterator).get(name: engine->id_next()));
870	if (!f) {
871	engine->throwTypeError();
872	return Encode(true);
873	}
874	JSCallData cData(&iterator, nullptr, 0);
875	ScopedObject o(scope, f->call(data: cData));
876	if (scope.hasException())
877	return Encode(true);
878	if (!o) {
879	engine->throwTypeError();
880	return Encode(true);
881	}
882
883	ScopedValue d(scope, o->get(name: engine->id_done()));
884	if (scope.hasException())
885	return Encode(true);
886	bool done = d->toBoolean();
887	if (done) {
888	*value = Encode::undefined();
889	return Encode(true);
890	}
891
892	*value = o->get(name: engine->id_value());
893	if (scope.hasException())
894	return Encode(true);
895	return Encode(false);
896	}
897
898	ReturnedValue Runtime::IteratorNextForYieldStar::call(ExecutionEngine *engine, const Value &received, const Value &iterator, Value *object)
899	{
900	// the return value encodes how to continue the yield* iteration.
901	// true implies iteration is done, false for iteration to continue
902	// a return value of undefines is a special marker, that the iterator has been invoked with return()
903
904	Scope scope(engine);
905	Q_ASSERT(iterator.isObject());
906
907	const Value *arg = &received;
908	bool returnCalled = false;
909	FunctionObject *f = nullptr;
910	if (engine->hasException) {
911	if (engine->exceptionValue->isEmpty()) {
912	// generator called with return()
913	*engine->exceptionValue = Encode::undefined();
914	engine->hasException = false;
915
916	ScopedValue ret(scope, static_cast<const Object &>(iterator).get(name: engine->id_return()));
917	if (engine->hasException)
918	return Encode(true);
919	if (ret->isUndefined()) {
920	// propagate return()
921	return Encode::undefined();
922	}
923	returnCalled = true;
924	f = ret->as<FunctionObject>();
925	} else {
926	// generator called with throw
927	ScopedValue exceptionValue(scope, *engine->exceptionValue);
928	*engine->exceptionValue = Encode::undefined();
929	engine->hasException = false;
930
931	ScopedValue t(scope, static_cast<const Object &>(iterator).get(name: engine->id_throw()));
932	if (engine->hasException)
933	return Encode(true);
934	if (t->isUndefined()) {
935	// no throw method on the iterator
936	IteratorClose::call(engine, iterator);
937	if (!engine->hasException)
938	engine->throwTypeError();
939	return Encode(true);
940	}
941	f = t->as<FunctionObject>();
942	arg = exceptionValue;
943	}
944	} else {
945	// generator called with next()
946	ScopedFunctionObject next(scope, static_cast<const Object &>(iterator).get(name: engine->id_next()));
947	f = next->as<FunctionObject>();
948	}
949
950	if (!f) {
951	engine->throwTypeError();
952	return Encode(true);
953	}
954
955	ScopedObject o(scope, f->call(thisObject: &iterator, argv: arg, argc: 1));
956	if (scope.hasException())
957	return Encode(true);
958	if (!o) {
959	engine->throwTypeError();
960	return Encode(true);
961	}
962
963	ScopedValue d(scope, o->get(name: engine->id_done()));
964	if (scope.hasException())
965	return Encode(true);
966	bool done = d->toBoolean();
967	if (done) {
968	*object = o->get(name: engine->id_value());
969	return (returnCalled && !engine->hasException) ? Encode::undefined() : Encode(true);
970	}
971	*object = o;
972	return Encode(false);
973	}
974
975	ReturnedValue Runtime::IteratorClose::call(ExecutionEngine *engine, const Value &iterator)
976	{
977	Q_ASSERT(iterator.isObject());
978
979	Scope scope(engine);
980	ScopedValue e(scope);
981	bool hadException = engine->hasException;
982	if (hadException) {
983	e = *engine->exceptionValue;
984	engine->hasException = false;
985	}
986
987	auto originalCompletion = [=]() {
988	if (hadException) {
989	*engine->exceptionValue = e;
990	engine->hasException = hadException;
991	}
992	return Encode::undefined();
993	};
994
995	ScopedValue ret(scope, static_cast<const Object &>(iterator).get(name: engine->id_return()));
996	ScopedObject o(scope);
997	if (!ret->isUndefined()) {
998	FunctionObject *f = ret->as<FunctionObject>();
999	o = f->call(thisObject: &iterator, argv: nullptr, argc: 0);
1000	if (engine->hasException && !hadException)
1001	return Encode::undefined();
1002	}
1003	if (hadException || ret->isUndefined())
1004	return originalCompletion();
1005
1006	if (!o)
1007	return engine->throwTypeError();
1008
1009	return originalCompletion();
1010	}
1011
1012	ReturnedValue Runtime::DestructureRestElement::call(ExecutionEngine *engine, const Value &iterator)
1013	{
1014	Q_ASSERT(iterator.isObject());
1015
1016	Scope scope(engine);
1017	ScopedArrayObject array(scope, engine->newArrayObject());
1018	array->arrayCreate();
1019	uint index = 0;
1020	while (1) {
1021	ScopedValue n(scope);
1022	ScopedValue done(scope, IteratorNext::call(engine, iterator, value: n));
1023	if (engine->hasException)
1024	return Encode::undefined();
1025	Q_ASSERT(done->isBoolean());
1026	if (done->booleanValue())
1027	break;
1028	array->arraySet(index, value: n);
1029	++index;
1030	}
1031	return array->asReturnedValue();
1032	}
1033
1034	void Runtime::StoreNameSloppy::call(ExecutionEngine *engine, int nameIndex, const Value &value)
1035	{
1036	Scope scope(engine);
1037	ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
1038	ExecutionContext::Error e = engine->currentContext()->setProperty(name, value);
1039
1040	if (e == ExecutionContext::RangeError)
1041	engine->globalObject->put(name, v: value);
1042	}
1043
1044	void Runtime::StoreNameStrict::call(ExecutionEngine *engine, int nameIndex, const Value &value)
1045	{
1046	Scope scope(engine);
1047	ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
1048	ExecutionContext::Error e = engine->currentContext()->setProperty(name, value);
1049	if (e == ExecutionContext::TypeError)
1050	engine->throwTypeError();
1051	else if (e == ExecutionContext::RangeError)
1052	engine->throwReferenceError(value: name);
1053	}
1054
1055	ReturnedValue Runtime::LoadProperty::call(ExecutionEngine *engine, const Value &object, int nameIndex)
1056	{
1057	Scope scope(engine);
1058	ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
1059
1060	ScopedObject o(scope, object);
1061	if (o)
1062	return o->get(name);
1063
1064	if (object.isNullOrUndefined()) {
1065	QString message = QStringLiteral("Cannot read property '%1' of %2").arg(a: name->toQString()).arg(a: object.toQStringNoThrow());
1066	return engine->throwTypeError(message);
1067	}
1068
1069	o = RuntimeHelpers::convertToObject(engine: scope.engine, value: object);
1070	if (!o) // type error
1071	return Encode::undefined();
1072	return o->get(name);
1073	}
1074
1075	ReturnedValue Runtime::LoadName::call(ExecutionEngine *engine, int nameIndex)
1076	{
1077	Scope scope(engine);
1078	ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
1079	return engine->currentContext()->getProperty(name);
1080	}
1081
1082	static Object *getSuperBase(Scope &scope)
1083	{
1084	Scoped<JavaScriptFunctionObject> f(scope);
1085	ScopedObject homeObject(scope);
1086	if (scope.engine->currentStackFrame->isJSTypesFrame()) {
1087	JSTypesStackFrame *frame = static_cast<JSTypesStackFrame *>(
1088	scope.engine->currentStackFrame);
1089
1090	if (frame->jsFrame->thisObject.isEmpty()) {
1091	scope.engine->throwReferenceError(
1092	QStringLiteral("Missing call to super()."), fileName: QString(), lineNumber: 0, column: 0);
1093	return nullptr;
1094	}
1095
1096	f = Value::fromStaticValue(staticValue: frame->jsFrame->function);
1097	homeObject = f->getHomeObject();
1098	} else {
1099	Q_ASSERT(scope.engine->currentStackFrame->isMetaTypesFrame());
1100	MetaTypesStackFrame *frame = static_cast<MetaTypesStackFrame *>(
1101	scope.engine->currentStackFrame);
1102	if (frame->thisObject() == nullptr) {
1103	scope.engine->throwReferenceError(
1104	QStringLiteral("Missing call to super()."), fileName: QString(), lineNumber: 0, column: 0);
1105	return nullptr;
1106	}
1107	}
1108
1109	if (!homeObject) {
1110	ScopedContext ctx(scope, scope.engine->currentContext());
1111	Q_ASSERT(ctx);
1112	while (ctx) {
1113	if (CallContext *c = ctx->asCallContext()) {
1114	f = c->d()->function;
1115	QV4::Function *fn = f->function();
1116	if (fn && !fn->isArrowFunction() && fn->kind != Function::Eval)
1117	break;
1118	}
1119	ctx = ctx->d()->outer;
1120	}
1121	if (f)
1122	homeObject = f->getHomeObject();
1123	}
1124	if (!homeObject) {
1125	scope.engine->throwTypeError();
1126	return nullptr;
1127	}
1128	Q_ASSERT(homeObject);
1129	ScopedObject proto(scope, homeObject->getPrototypeOf());
1130	if (!proto) {
1131	scope.engine->throwTypeError();
1132	return nullptr;
1133	}
1134	return proto;
1135	}
1136
1137	ReturnedValue Runtime::LoadSuperProperty::call(ExecutionEngine *engine, const Value &property)
1138	{
1139	Scope scope(engine);
1140	Object *base = getSuperBase(scope);
1141	if (!base)
1142	return Encode::undefined();
1143	ScopedPropertyKey key(scope, property.toPropertyKey(e: engine));
1144	if (engine->hasException)
1145	return Encode::undefined();
1146
1147	if (scope.engine->currentStackFrame->isJSTypesFrame()) {
1148	JSTypesStackFrame *frame = static_cast<JSTypesStackFrame *>(
1149	scope.engine->currentStackFrame);
1150	return base->get(id: key, receiver: &(frame->jsFrame->thisObject.asValue<Value>()));
1151	} else {
1152	Q_ASSERT(scope.engine->currentStackFrame->isMetaTypesFrame());
1153	MetaTypesStackFrame *frame = static_cast<MetaTypesStackFrame *>(
1154	scope.engine->currentStackFrame);
1155	Scoped<QObjectWrapper> wrapper(scope, QObjectWrapper::wrap(engine, object: frame->thisObject()));
1156	return base->get(id: key, receiver: wrapper);
1157	}
1158	}
1159
1160	void Runtime::StoreSuperProperty::call(ExecutionEngine *engine, const Value &property, const Value &value)
1161	{
1162	Scope scope(engine);
1163	Object *base = getSuperBase(scope);
1164	if (!base)
1165	return;
1166	ScopedPropertyKey key(scope, property.toPropertyKey(e: engine));
1167	if (engine->hasException)
1168	return;
1169
1170	bool result;
1171	if (scope.engine->currentStackFrame->isJSTypesFrame()) {
1172	JSTypesStackFrame *frame = static_cast<JSTypesStackFrame *>(
1173	scope.engine->currentStackFrame);
1174	result = base->put(id: key, v: value, receiver: &(frame->jsFrame->thisObject.asValue<Value>()));
1175	} else {
1176	Q_ASSERT(scope.engine->currentStackFrame->isMetaTypesFrame());
1177	MetaTypesStackFrame *frame = static_cast<MetaTypesStackFrame *>(
1178	scope.engine->currentStackFrame);
1179	Scoped<QObjectWrapper> wrapper(scope, QObjectWrapper::wrap(engine, object: frame->thisObject()));
1180	result = base->put(id: key, v: value, receiver: wrapper);
1181	}
1182
1183	if (!result && engine->currentStackFrame->v4Function->isStrict())
1184	engine->throwTypeError();
1185	}
1186
1187	ReturnedValue Runtime::LoadGlobalLookup::call(ExecutionEngine *engine, Function *f, int index)
1188	{
1189	Lookup *l = runtimeLookup(f, i: index);
1190	return l->globalGetter(l, engine);
1191	}
1192
1193	ReturnedValue Runtime::LoadQmlContextPropertyLookup::call(ExecutionEngine *engine, uint index)
1194	{
1195	Lookup *l = runtimeLookup(f: engine->currentStackFrame->v4Function, i: index);
1196	return l->qmlContextPropertyGetter(l, engine, nullptr);
1197	}
1198
1199	ReturnedValue Runtime::GetLookup::call(ExecutionEngine *engine, Function *f, const Value &base, int index)
1200	{
1201	Lookup *l = runtimeLookup(f, i: index);
1202	return l->getter(l, engine, base);
1203	}
1204
1205	void Runtime::SetLookupSloppy::call(Function *f, const Value &base, int index, const Value &value)
1206	{
1207	ExecutionEngine *engine = f->internalClass->engine;
1208	QV4::Lookup *l = runtimeLookup(f, i: index);
1209	l->setter(l, engine, const_cast<Value &>(base), value);
1210	}
1211
1212	void Runtime::SetLookupStrict::call(Function *f, const Value &base, int index, const Value &value)
1213	{
1214	ExecutionEngine *engine = f->internalClass->engine;
1215	QV4::Lookup *l = runtimeLookup(f, i: index);
1216	if (!l->setter(l, engine, const_cast<Value &>(base), value))
1217	engine->throwTypeError();
1218	}
1219
1220	ReturnedValue Runtime::LoadSuperConstructor::call(ExecutionEngine *engine, const Value &t)
1221	{
1222	if (engine->currentStackFrame->isJSTypesFrame()) {
1223	JSTypesStackFrame *frame = static_cast<JSTypesStackFrame *>(engine->currentStackFrame);
1224	if (frame->thisObject() != Value::emptyValue().asReturnedValue()) {
1225	// ### TODO: fix line number
1226	return engine->throwReferenceError(
1227	QStringLiteral("super() already called."), fileName: QString(), lineNumber: 0, column: 0);
1228	}
1229	} else {
1230	Q_ASSERT(engine->currentStackFrame->isMetaTypesFrame());
1231	MetaTypesStackFrame *frame = static_cast<MetaTypesStackFrame *>(engine->currentStackFrame);
1232	if (frame->thisObject() != nullptr) {
1233	// ### TODO: fix line number
1234	return engine->throwReferenceError(
1235	QStringLiteral("super() already called."), fileName: QString(), lineNumber: 0, column: 0);
1236	}
1237	}
1238
1239	const FunctionObject *f = t.as<FunctionObject>();
1240	if (!f)
1241	return engine->throwTypeError();
1242	Heap::Object *c = static_cast<const Object &>(t).getPrototypeOf();
1243	if (!c->vtable()->callAsConstructor)
1244	return engine->throwTypeError();
1245	return c->asReturnedValue();
1246	}
1247
1248	uint RuntimeHelpers::equalHelper(const Value &x, const Value &y)
1249	{
1250	Q_ASSERT(x.type() != y.type() || (x.isManaged() && (x.isString() != y.isString())));
1251
1252	if (x.isNumber() && y.isNumber())
1253	return x.asDouble() == y.asDouble();
1254	if (x.isNull() && y.isUndefined()) {
1255	return true;
1256	} else if (x.isUndefined() && y.isNull()) {
1257	return true;
1258	} else if (x.isNumber() && y.isString()) {
1259	double dy = RuntimeHelpers::toNumber(value: y);
1260	return x.asDouble() == dy;
1261	} else if (x.isString() && y.isNumber()) {
1262	double dx = RuntimeHelpers::toNumber(value: x);
1263	return dx == y.asDouble();
1264	} else if (x.isBoolean()) {
1265	return Runtime::CompareEqual::call(Value::fromDouble(d: (double) x.booleanValue()), y);
1266	} else if (y.isBoolean()) {
1267	return Runtime::CompareEqual::call(x, Value::fromDouble(d: (double) y.booleanValue()));
1268	} else {
1269	Object *xo = x.objectValue();
1270	Object *yo = y.objectValue();
1271	if (yo && (x.isNumber() || x.isString())) {
1272	Scope scope(yo->engine());
1273	ScopedValue py(scope, RuntimeHelpers::objectDefaultValue(object: yo, typeHint: PREFERREDTYPE_HINT));
1274	return Runtime::CompareEqual::call(x, py);
1275	} else if (xo && (y.isNumber() || y.isString())) {
1276	Scope scope(xo->engine());
1277	ScopedValue px(scope, RuntimeHelpers::objectDefaultValue(object: xo, typeHint: PREFERREDTYPE_HINT));
1278	return Runtime::CompareEqual::call(px, y);
1279	}
1280	}
1281
1282	return false;
1283	}
1284
1285	Bool RuntimeHelpers::strictEqual(const Value &x, const Value &y)
1286	{
1287	TRACE2(x, y);
1288
1289	if (x.rawValue() == y.rawValue())
1290	// NaN != NaN
1291	return !x.isNaN();
1292
1293	if (x.isNumber())
1294	return y.isNumber() && x.asDouble() == y.asDouble();
1295	if (x.isManaged()) {
1296	return y.isManaged() && x.cast<Managed>()->isEqualTo(other: y.cast<Managed>());
1297	}
1298	return false;
1299	}
1300
1301	QV4::Bool Runtime::CompareGreaterThan::call(const Value &l, const Value &r)
1302	{
1303	TRACE2(l, r);
1304	if (l.isInteger() && r.isInteger())
1305	return l.integerValue() > r.integerValue();
1306	if (l.isNumber() && r.isNumber())
1307	return l.asDouble() > r.asDouble();
1308	String *sl = l.stringValue();
1309	String *sr = r.stringValue();
1310	if (sl && sr) {
1311	return sr->lessThan(other: sl);
1312	}
1313
1314	Object *ro = r.objectValue();
1315	Object *lo = l.objectValue();
1316	if (ro || lo) {
1317	QV4::ExecutionEngine *e = (lo ? lo : ro)->engine();
1318	QV4::Scope scope(e);
1319	QV4::ScopedValue pl(scope, lo ? RuntimeHelpers::objectDefaultValue(object: lo, typeHint: QV4::NUMBER_HINT) : l.asReturnedValue());
1320	QV4::ScopedValue pr(scope, ro ? RuntimeHelpers::objectDefaultValue(object: ro, typeHint: QV4::NUMBER_HINT) : r.asReturnedValue());
1321	return Runtime::CompareGreaterThan::call(l: pl, r: pr);
1322	}
1323
1324	double dl = RuntimeHelpers::toNumber(value: l);
1325	double dr = RuntimeHelpers::toNumber(value: r);
1326	return dl > dr;
1327	}
1328
1329	QV4::Bool Runtime::CompareLessThan::call(const Value &l, const Value &r)
1330	{
1331	TRACE2(l, r);
1332	if (l.isInteger() && r.isInteger())
1333	return l.integerValue() < r.integerValue();
1334	if (l.isNumber() && r.isNumber())
1335	return l.asDouble() < r.asDouble();
1336	String *sl = l.stringValue();
1337	String *sr = r.stringValue();
1338	if (sl && sr) {
1339	return sl->lessThan(other: sr);
1340	}
1341
1342	Object *ro = r.objectValue();
1343	Object *lo = l.objectValue();
1344	if (ro || lo) {
1345	QV4::ExecutionEngine *e = (lo ? lo : ro)->engine();
1346	QV4::Scope scope(e);
1347	QV4::ScopedValue pl(scope, lo ? RuntimeHelpers::objectDefaultValue(object: lo, typeHint: QV4::NUMBER_HINT) : l.asReturnedValue());
1348	QV4::ScopedValue pr(scope, ro ? RuntimeHelpers::objectDefaultValue(object: ro, typeHint: QV4::NUMBER_HINT) : r.asReturnedValue());
1349	return Runtime::CompareLessThan::call(l: pl, r: pr);
1350	}
1351
1352	double dl = RuntimeHelpers::toNumber(value: l);
1353	double dr = RuntimeHelpers::toNumber(value: r);
1354	return dl < dr;
1355	}
1356
1357	QV4::Bool Runtime::CompareGreaterEqual::call(const Value &l, const Value &r)
1358	{
1359	TRACE2(l, r);
1360	if (l.isInteger() && r.isInteger())
1361	return l.integerValue() >= r.integerValue();
1362	if (l.isNumber() && r.isNumber())
1363	return l.asDouble() >= r.asDouble();
1364	String *sl = l.stringValue();
1365	String *sr = r.stringValue();
1366	if (sl && sr) {
1367	return !sl->lessThan(other: sr);
1368	}
1369
1370	Object *ro = r.objectValue();
1371	Object *lo = l.objectValue();
1372	if (ro || lo) {
1373	QV4::ExecutionEngine *e = (lo ? lo : ro)->engine();
1374	QV4::Scope scope(e);
1375	QV4::ScopedValue pl(scope, lo ? RuntimeHelpers::objectDefaultValue(object: lo, typeHint: QV4::NUMBER_HINT) : l.asReturnedValue());
1376	QV4::ScopedValue pr(scope, ro ? RuntimeHelpers::objectDefaultValue(object: ro, typeHint: QV4::NUMBER_HINT) : r.asReturnedValue());
1377	return Runtime::CompareGreaterEqual::call(l: pl, r: pr);
1378	}
1379
1380	double dl = RuntimeHelpers::toNumber(value: l);
1381	double dr = RuntimeHelpers::toNumber(value: r);
1382	return dl >= dr;
1383	}
1384
1385	QV4::Bool Runtime::CompareLessEqual::call(const Value &l, const Value &r)
1386	{
1387	TRACE2(l, r);
1388	if (l.isInteger() && r.isInteger())
1389	return l.integerValue() <= r.integerValue();
1390	if (l.isNumber() && r.isNumber())
1391	return l.asDouble() <= r.asDouble();
1392	String *sl = l.stringValue();
1393	String *sr = r.stringValue();
1394	if (sl && sr) {
1395	return !sr->lessThan(other: sl);
1396	}
1397
1398	Object *ro = r.objectValue();
1399	Object *lo = l.objectValue();
1400	if (ro || lo) {
1401	QV4::ExecutionEngine *e = (lo ? lo : ro)->engine();
1402	QV4::Scope scope(e);
1403	QV4::ScopedValue pl(scope, lo ? RuntimeHelpers::objectDefaultValue(object: lo, typeHint: QV4::NUMBER_HINT) : l.asReturnedValue());
1404	QV4::ScopedValue pr(scope, ro ? RuntimeHelpers::objectDefaultValue(object: ro, typeHint: QV4::NUMBER_HINT) : r.asReturnedValue());
1405	return Runtime::CompareLessEqual::call(l: pl, r: pr);
1406	}
1407
1408	double dl = RuntimeHelpers::toNumber(value: l);
1409	double dr = RuntimeHelpers::toNumber(value: r);
1410	return dl <= dr;
1411	}
1412
1413	Bool Runtime::CompareInstanceof::call(ExecutionEngine *engine, const Value &left, const Value &right)
1414	{
1415	TRACE2(left, right);
1416
1417	Scope scope(engine);
1418	ScopedValue v(scope, Instanceof::call(engine, lval: left, rval: right));
1419	return v->booleanValue();
1420	}
1421
1422	uint Runtime::CompareIn::call(ExecutionEngine *engine, const Value &left, const Value &right)
1423	{
1424	TRACE2(left, right);
1425
1426	Scope scope(engine);
1427	ScopedValue v(scope, In::call(engine, left, right));
1428	return v->booleanValue();
1429	}
1430
1431	static ReturnedValue throwPropertyIsNotAFunctionTypeError(ExecutionEngine *engine, Value *thisObject, const QString &propertyName)
1432	{
1433	QString objectAsString = QStringLiteral("[null]");
1434	if (!thisObject->isUndefined())
1435	objectAsString = thisObject->toQStringNoThrow();
1436	QString msg = QStringLiteral("Property '%1' of object %2 is not a function")
1437	.arg(args: propertyName, args&: objectAsString);
1438	return engine->throwTypeError(message: msg);
1439	}
1440
1441	ReturnedValue Runtime::CallGlobalLookup::call(ExecutionEngine *engine, uint index, Value argv[], int argc)
1442	{
1443	Scope scope(engine);
1444	Lookup *l = runtimeLookup(f: engine->currentStackFrame->v4Function, i: index);
1445	Value function = Value::fromReturnedValue(val: l->globalGetter(l, engine));
1446	Value thisObject = Value::undefinedValue();
1447	if (!function.isFunctionObject()) {
1448	return throwPropertyIsNotAFunctionTypeError(engine, thisObject: &thisObject,
1449	propertyName: engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[l->nameIndex]->toQString());
1450	}
1451
1452	return checkedResult(v4: engine, result: static_cast<FunctionObject &>(function).call(
1453	thisObject: &thisObject, argv, argc));
1454	}
1455
1456	ReturnedValue Runtime::CallQmlContextPropertyLookup::call(ExecutionEngine *engine, uint index,
1457	Value *argv, int argc)
1458	{
1459	Scope scope(engine);
1460	ScopedValue thisObject(scope);
1461	Lookup *l = runtimeLookup(f: engine->currentStackFrame->v4Function, i: index);
1462	Value function = Value::fromReturnedValue(val: l->qmlContextPropertyGetter(l, engine, thisObject));
1463	if (!function.isFunctionObject()) {
1464	return throwPropertyIsNotAFunctionTypeError(engine, thisObject,
1465	propertyName: engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[l->nameIndex]->toQString());
1466	}
1467
1468	return checkedResult(v4: engine, result: static_cast<FunctionObject &>(function).call(
1469	thisObject, argv, argc));
1470	}
1471
1472	ReturnedValue Runtime::CallPossiblyDirectEval::call(ExecutionEngine *engine, Value *argv, int argc)
1473	{
1474	Scope scope(engine);
1475	ScopedValue thisObject(scope);
1476
1477	ScopedFunctionObject function(
1478	scope, engine->currentContext()->getPropertyAndBase(name: engine->id_eval(), base: thisObject));
1479	if (engine->hasException)
1480	return Encode::undefined();
1481
1482	if (!function)
1483	return throwPropertyIsNotAFunctionTypeError(engine, thisObject, propertyName: QLatin1String("eval"));
1484
1485	if (function->d() == engine->evalFunction()->d())
1486	return static_cast<EvalFunction *>(function.getPointer())->evalCall(thisObject, argv, argc, directCall: true);
1487
1488	return checkedResult(v4: engine, result: function->call(thisObject, argv, argc));
1489	}
1490
1491	ReturnedValue Runtime::CallName::call(ExecutionEngine *engine, int nameIndex, Value *argv, int argc)
1492	{
1493	Scope scope(engine);
1494	ScopedValue thisObject(scope);
1495	ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
1496
1497	ScopedFunctionObject f(scope, engine->currentContext()->getPropertyAndBase(name, base: thisObject));
1498	if (engine->hasException)
1499	return Encode::undefined();
1500
1501	if (!f) {
1502	return throwPropertyIsNotAFunctionTypeError(
1503	engine, thisObject, propertyName: engine->currentStackFrame->v4Function->compilationUnit
1504	->runtimeStrings[nameIndex]->toQString());
1505	}
1506
1507	return checkedResult(v4: engine, result: f->call(thisObject, argv, argc));
1508	}
1509
1510	ReturnedValue Runtime::CallProperty::call(ExecutionEngine *engine, const Value &baseRef, int nameIndex, Value *argv, int argc)
1511	{
1512	const Value *base = &baseRef;
1513	Scope scope(engine);
1514	ScopedString name(
1515	scope,
1516	engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
1517	ScopedObject lookupObject(scope, base);
1518
1519	if (!lookupObject) {
1520	Q_ASSERT(!base->isEmpty());
1521	if (base->isNullOrUndefined()) {
1522	QString message = QStringLiteral("Cannot call method '%1' of %2")
1523	.arg(args: name->toQString(), args: base->toQStringNoThrow());
1524	return engine->throwTypeError(message);
1525	}
1526
1527	if (base->isManaged()) {
1528	const Managed *m = static_cast<const Managed *>(base);
1529	lookupObject = m->internalClass()->prototype;
1530	Q_ASSERT(m->internalClass()->prototype);
1531	} else {
1532	lookupObject = RuntimeHelpers::convertToObject(engine, value: *base);
1533	if (engine->hasException) // type error
1534	return Encode::undefined();
1535	if (!engine->currentStackFrame->v4Function->isStrict())
1536	base = lookupObject;
1537	}
1538	}
1539
1540	ScopedFunctionObject f(scope, static_cast<Object *>(lookupObject)->get(name));
1541
1542	if (!f) {
1543	QString error = QStringLiteral("Property '%1' of object %2 is not a function")
1544	.arg(args: name->toQString(),
1545	args: base->toQStringNoThrow());
1546	return engine->throwTypeError(message: error);
1547	}
1548
1549	return checkedResult(v4: engine, result: f->call(thisObject: base, argv, argc));
1550	}
1551
1552	ReturnedValue Runtime::CallPropertyLookup::call(ExecutionEngine *engine, const Value &base, uint index, Value *argv, int argc)
1553	{
1554	Lookup *l = runtimeLookup(f: engine->currentStackFrame->v4Function, i: index);
1555	// ok to have the value on the stack here
1556	Value f = Value::fromReturnedValue(val: l->getter(l, engine, base));
1557
1558	if (Q_LIKELY(f.isFunctionObject()))
1559	return checkedResult(v4: engine, result: static_cast<FunctionObject &>(f).call(thisObject: &base, argv, argc));
1560
1561	if (QmlSignalHandler *handler = f.as<QmlSignalHandler>())
1562	return checkedResult(v4: engine, result: handler->call(thisObject: &base, argv, argc));
1563
1564	const QString message = QStringLiteral("Property '%1' of object %2 is not a function")
1565	.arg(a: engine->currentStackFrame->v4Function->compilationUnit
1566	->runtimeStrings[l->nameIndex]->toQString())
1567	.arg(a: base.toQStringNoThrow());
1568	return engine->throwTypeError(message);
1569	}
1570
1571	ReturnedValue Runtime::CallValue::call(ExecutionEngine *engine, const Value &func, Value *argv, int argc)
1572	{
1573	if (!func.isFunctionObject())
1574	return engine->throwTypeError(QStringLiteral("%1 is not a function").arg(a: func.toQStringNoThrow()));
1575	Value undef = Value::undefinedValue();
1576	return checkedResult(v4: engine, result: static_cast<const FunctionObject &>(func).call(
1577	thisObject: &undef, argv, argc));
1578	}
1579
1580	ReturnedValue Runtime::CallWithReceiver::call(ExecutionEngine *engine, const Value &func,
1581	const Value &thisObject, Value argv[], int argc)
1582	{
1583	if (!func.isFunctionObject())
1584	return engine->throwTypeError(QStringLiteral("%1 is not a function").arg(a: func.toQStringNoThrow()));
1585	return checkedResult(v4: engine, result: static_cast<const FunctionObject &>(func).call(
1586	thisObject: &thisObject, argv, argc));
1587	}
1588
1589	struct CallArgs {
1590	Value *argv;
1591	int argc;
1592	};
1593
1594	static CallArgs createSpreadArguments(Scope &scope, Value *argv, int argc)
1595	{
1596	ScopedValue it(scope);
1597	ScopedValue done(scope);
1598
1599	int argCount = 0;
1600
1601	Value *v = scope.alloc<Scope::Uninitialized>();
1602	Value *arguments = v;
1603	for (int i = 0; i < argc; ++i) {
1604	if (!argv[i].isEmpty()) {
1605	*v = argv[i];
1606	++argCount;
1607	v = scope.alloc<Scope::Uninitialized>();
1608	continue;
1609	}
1610	// spread element
1611	++i;
1612	it = Runtime::GetIterator::call(engine: scope.engine, in: argv[i], /* ForInIterator */ iterator: 1);
1613	if (scope.hasException())
1614	return { .argv: nullptr, .argc: 0 };
1615	while (1) {
1616	done = Runtime::IteratorNext::call(engine: scope.engine, iterator: it, value: v);
1617	if (scope.hasException())
1618	return { .argv: nullptr, .argc: 0 };
1619	Q_ASSERT(done->isBoolean());
1620	if (done->booleanValue())
1621	break;
1622	++argCount;
1623	constexpr auto safetyMargin = 100; // leave some space on the stack for actual work with the elements
1624	if (qint64(scope.engine->jsStackLimit - scope.engine->jsStackTop) < safetyMargin) {
1625	scope.engine->throwRangeError(message: QLatin1String("Too many elements in array to use it with the spread operator"));
1626	return { .argv: nullptr, .argc: 0 };
1627	}
1628	v = scope.alloc<Scope::Uninitialized>();
1629	}
1630	}
1631	return { .argv: arguments, .argc: argCount };
1632	}
1633
1634	ReturnedValue Runtime::CallWithSpread::call(ExecutionEngine *engine, const Value &function, const Value &thisObject, Value *argv, int argc)
1635	{
1636	Q_ASSERT(argc >= 1);
1637	if (!function.isFunctionObject())
1638	return engine->throwTypeError();
1639
1640	Scope scope(engine);
1641	CallArgs arguments = createSpreadArguments(scope, argv, argc);
1642	if (engine->hasException)
1643	return Encode::undefined();
1644
1645	return checkedResult(v4: engine, result: static_cast<const FunctionObject &>(function).call(
1646	thisObject: &thisObject, argv: arguments.argv, argc: arguments.argc));
1647	}
1648
1649	ReturnedValue Runtime::Construct::call(ExecutionEngine *engine, const Value &function, const Value &newTarget, Value *argv, int argc)
1650	{
1651	if (!function.isFunctionObject())
1652	return engine->throwTypeError();
1653
1654	return static_cast<const FunctionObject &>(function).callAsConstructor(argv, argc, newTarget: &newTarget);
1655	}
1656
1657	ReturnedValue Runtime::ConstructWithSpread::call(ExecutionEngine *engine, const Value &function, const Value &newTarget, Value *argv, int argc)
1658	{
1659	if (!function.isFunctionObject())
1660	return engine->throwTypeError();
1661
1662	Scope scope(engine);
1663	CallArgs arguments = createSpreadArguments(scope, argv, argc);
1664	if (engine->hasException)
1665	return Encode::undefined();
1666
1667	return static_cast<const FunctionObject &>(function).callAsConstructor(argv: arguments.argv, argc: arguments.argc, newTarget: &newTarget);
1668	}
1669
1670	ReturnedValue Runtime::TailCall::call(JSTypesStackFrame *frame, ExecutionEngine *engine)
1671	{
1672	// IMPORTANT! The JIT assumes that this method has the same amount (or less) arguments than
1673	// the jitted function, so it can safely do a tail call.
1674
1675	Value *tos = engine->jsStackTop;
1676	const Value &function = tos[StackOffsets::tailCall_function];
1677	const Value &thisObject = tos[StackOffsets::tailCall_thisObject];
1678	Value *argv = reinterpret_cast<Value *>(frame->jsFrame) + tos[StackOffsets::tailCall_argv].int_32();
1679	int argc = tos[StackOffsets::tailCall_argc].int_32();
1680	Q_ASSERT(argc >= 0);
1681
1682	const JavaScriptFunctionObject *jsfo = function.as<JavaScriptFunctionObject>();
1683	if (!jsfo) {
1684	if (const FunctionObject *fo = function.as<FunctionObject>())
1685	return checkedResult(v4: engine, result: fo->call(thisObject: &thisObject, argv, argc));
1686	return engine->throwTypeError();
1687	}
1688
1689	if (!frame->callerCanHandleTailCall() || !jsfo->canBeTailCalled() || engine->debugger()
1690	|| unsigned(argc) > jsfo->formalParameterCount()) {
1691	// Cannot tailcall, do a normal call:
1692	return checkedResult(v4: engine, result: jsfo->call(thisObject: &thisObject, argv, argc));
1693	}
1694
1695	memmove(dest: frame->jsFrame->args, src: argv, n: argc * sizeof(Value));
1696	frame->init(v4Function: jsfo->function(), argv: frame->jsFrame->argValues<Value>(), argc,
1697	callerCanHandleTailCall: frame->callerCanHandleTailCall());
1698	frame->setupJSFrame(stackSpace: frame->framePointer(), function: *jsfo, scope: jsfo->scope(), thisObject,
1699	newTarget: Primitive::undefinedValue());
1700	engine->jsStackTop = frame->framePointer() + frame->requiredJSStackFrameSize();
1701	frame->setPendingTailCall(true);
1702	return Encode::undefined();
1703	}
1704
1705	void Runtime::ThrowException::call(ExecutionEngine *engine, const Value &value)
1706	{
1707	if (!value.isEmpty())
1708	engine->throwError(value);
1709	}
1710
1711	ReturnedValue Runtime::TypeofValue::call(ExecutionEngine *engine, const Value &value)
1712	{
1713	Scope scope(engine);
1714	ScopedString res(scope);
1715	switch (value.type()) {
1716	case Value::Undefined_Type:
1717	res = engine->id_undefined();
1718	break;
1719	case Value::Null_Type:
1720	res = engine->id_object();
1721	break;
1722	case Value::Boolean_Type:
1723	res = engine->id_boolean();
1724	break;
1725	case Value::Managed_Type:
1726	if (value.isString())
1727	res = engine->id_string();
1728	else if (value.isSymbol())
1729	res = engine->id_symbol();
1730	else if (value.objectValue()->as<FunctionObject>())
1731	res = engine->id_function();
1732	else
1733	res = engine->id_object(); // ### implementation-defined
1734	break;
1735	default:
1736	res = engine->id_number();
1737	break;
1738	}
1739	return res.asReturnedValue();
1740	}
1741
1742	QV4::ReturnedValue Runtime::TypeofName::call(ExecutionEngine *engine, int nameIndex)
1743	{
1744	Scope scope(engine);
1745	ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
1746	ScopedValue prop(scope, engine->currentContext()->getProperty(name));
1747	// typeof doesn't throw. clear any possible exception
1748	scope.engine->hasException = false;
1749	return TypeofValue::call(engine, value: prop);
1750	}
1751
1752	void Runtime::PushCallContext::call(JSTypesStackFrame *frame)
1753	{
1754	frame->jsFrame->context = ExecutionContext::newCallContext(frame)->asReturnedValue();
1755	}
1756
1757	ReturnedValue Runtime::PushWithContext::call(ExecutionEngine *engine, const Value &acc)
1758	{
1759	Q_ASSERT(engine->currentStackFrame->isJSTypesFrame());
1760	CallData *jsFrame = static_cast<JSTypesStackFrame *>(engine->currentStackFrame)->jsFrame;
1761	Value &newAcc = jsFrame->accumulator.asValue<Value>();
1762	newAcc = Value::fromHeapObject(m: acc.toObject(e: engine));
1763	if (!engine->hasException) {
1764	Q_ASSERT(newAcc.isObject());
1765	const Object &obj = static_cast<const Object &>(newAcc);
1766	Value &context = jsFrame->context.asValue<Value>();
1767	auto ec = static_cast<const ExecutionContext *>(&context);
1768	context = ec->newWithContext(with: obj.d())->asReturnedValue();
1769	}
1770	return newAcc.asReturnedValue();
1771	}
1772
1773	void Runtime::PushCatchContext::call(ExecutionEngine *engine, int blockIndex, int exceptionVarNameIndex)
1774	{
1775	Q_ASSERT(engine->currentStackFrame->isJSTypesFrame());
1776	auto name = engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[exceptionVarNameIndex];
1777	static_cast<JSTypesStackFrame *>(engine->currentStackFrame)->jsFrame->context
1778	= ExecutionContext::newCatchContext(frame: engine->currentStackFrame, blockIndex, exceptionVarName: name)->asReturnedValue();
1779	}
1780
1781	void Runtime::PushBlockContext::call(ExecutionEngine *engine, int index)
1782	{
1783	Q_ASSERT(engine->currentStackFrame->isJSTypesFrame());
1784	static_cast<JSTypesStackFrame *>(engine->currentStackFrame)->jsFrame->context
1785	= ExecutionContext::newBlockContext(frame: engine->currentStackFrame, blockIndex: index)->asReturnedValue();
1786	}
1787
1788	void Runtime::CloneBlockContext::call(ExecutionEngine *engine)
1789	{
1790	Q_ASSERT(engine->currentStackFrame->isJSTypesFrame());
1791	auto frame = static_cast<JSTypesStackFrame *>(engine->currentStackFrame);
1792	auto context = static_cast<Heap::CallContext *>(
1793	Value::fromStaticValue(staticValue: frame->jsFrame->context).m());
1794	frame->jsFrame->context =
1795	ExecutionContext::cloneBlockContext(engine, callContext: context)->asReturnedValue();
1796	}
1797
1798	void Runtime::PushScriptContext::call(ExecutionEngine *engine, int index)
1799	{
1800	Q_ASSERT(engine->currentStackFrame->isJSTypesFrame());
1801	Q_ASSERT(engine->currentContext()->d()->type == Heap::ExecutionContext::Type_GlobalContext ||
1802	engine->currentContext()->d()->type == Heap::ExecutionContext::Type_QmlContext);
1803	ReturnedValue c = ExecutionContext::newBlockContext(frame: engine->currentStackFrame, blockIndex: index)->asReturnedValue();
1804	engine->setScriptContext(c);
1805	static_cast<JSTypesStackFrame *>(engine->currentStackFrame)->jsFrame->context = c;
1806	}
1807
1808	void Runtime::PopScriptContext::call(ExecutionEngine *engine)
1809	{
1810	Q_ASSERT(engine->currentStackFrame->isJSTypesFrame());
1811	ReturnedValue root = engine->rootContext()->asReturnedValue();
1812	engine->setScriptContext(root);
1813	static_cast<JSTypesStackFrame *>(engine->currentStackFrame)->jsFrame->context = root;
1814	}
1815
1816	void Runtime::ThrowReferenceError::call(ExecutionEngine *engine, int nameIndex)
1817	{
1818	Scope scope(engine);
1819	ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
1820	engine->throwReferenceError(value: name);
1821	}
1822
1823	void Runtime::ThrowOnNullOrUndefined::call(ExecutionEngine *engine, const Value &v)
1824	{
1825	if (v.isNullOrUndefined())
1826	engine->throwTypeError();
1827	}
1828
1829	void Runtime::MarkCustom::call(const Value &toBeMarked)
1830	{
1831	auto *h = toBeMarked.heapObject();
1832	if (!h)
1833	return;
1834	Q_ASSERT(h->internalClass);
1835	auto engine = h->internalClass->engine;
1836	Q_ASSERT(engine);
1837	// runtime function is only meant to be called while gc is ongoing
1838	Q_ASSERT(engine->isGCOngoing);
1839	QV4::WriteBarrier::markCustom(engine, markFunction: [&](QV4::MarkStack *ms) {
1840	h->mark(markStack: ms);
1841	});
1842	}
1843
1844	ReturnedValue Runtime::ConvertThisToObject::call(ExecutionEngine *engine, const Value &t)
1845	{
1846	if (!t.isObject()) {
1847	if (t.isNullOrUndefined()) {
1848	return engine->globalObject->asReturnedValue();
1849	} else {
1850	return t.toObject(e: engine)->asReturnedValue();
1851	}
1852	}
1853	return t.asReturnedValue();
1854	}
1855
1856	void Runtime::DeclareVar::call(ExecutionEngine *engine, Bool deletable, int nameIndex)
1857	{
1858	Scope scope(engine);
1859	ScopedString name(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[nameIndex]);
1860	engine->currentContext()->createMutableBinding(name, deletable);
1861	}
1862
1863	ReturnedValue Runtime::ArrayLiteral::call(ExecutionEngine *engine, Value *values, uint length)
1864	{
1865	return engine->newArrayObject(values, length)->asReturnedValue();
1866	}
1867
1868	ReturnedValue Runtime::ObjectLiteral::call(ExecutionEngine *engine, int classId, QV4::Value args[], int argc)
1869	{
1870	Scope scope(engine);
1871	Scoped<InternalClass> klass(scope, engine->currentStackFrame->v4Function->compilationUnit->runtimeClasses[classId]);
1872	ScopedObject o(scope, engine->newObject(internalClass: klass->d()));
1873
1874	Q_ASSERT(uint(argc) >= klass->d()->size);
1875
1876	for (uint i = 0; i < klass->d()->size; ++i)
1877	o->setProperty(index: i, v: *args++);
1878
1879	Q_ASSERT((argc - klass->d()->size) % 3 == 0);
1880	int additionalArgs = (argc - int(klass->d()->size))/3;
1881
1882	if (!additionalArgs)
1883	return o->asReturnedValue();
1884
1885	ScopedPropertyKey name(scope);
1886	ScopedProperty pd(scope);
1887	ScopedFunctionObject fn(scope);
1888	ScopedString fnName(scope);
1889	ScopedValue value(scope);
1890	for (int i = 0; i < additionalArgs; ++i) {
1891	Q_ASSERT(args->isInteger());
1892	ObjectLiteralArgument arg = ObjectLiteralArgument(args->integerValue());
1893	name = args[1].toPropertyKey(e: engine);
1894	value = args[2];
1895	if (engine->hasException)
1896	return Encode::undefined();
1897	if (arg != ObjectLiteralArgument::Value) {
1898	Q_ASSERT(args[2].isInteger());
1899	int functionId = args[2].integerValue();
1900	QV4::Function *clos = engine->currentStackFrame->v4Function->executableCompilationUnit()
1901	->runtimeFunctions[functionId];
1902	Q_ASSERT(clos);
1903
1904	PropertyKey::FunctionNamePrefix prefix = PropertyKey::None;
1905	if (arg == ObjectLiteralArgument::Getter)
1906	prefix = PropertyKey::Getter;
1907	else if (arg == ObjectLiteralArgument::Setter)
1908	prefix = PropertyKey::Setter;
1909	else
1910	arg = ObjectLiteralArgument::Value;
1911	fnName = name->asFunctionName(e: engine, prefix);
1912
1913	ExecutionContext *current = engine->currentContext();
1914	if (clos->isGenerator())
1915	value = MemberGeneratorFunction::create(scope: current, function: clos, homeObject: o, name: fnName)->asReturnedValue();
1916	else
1917	value = FunctionObject::createMemberFunction(scope: current, function: clos, homeObject: o, name: fnName)->asReturnedValue();
1918	} else if (args[2].isFunctionObject()) {
1919	fn = static_cast<const FunctionObject &>(args[2]);
1920
1921	fnName = name->asFunctionName(e: engine, prefix: PropertyKey::None);
1922	fn->setName(fnName);
1923	}
1924	Q_ASSERT(arg != ObjectLiteralArgument::Method);
1925	Q_ASSERT(arg == ObjectLiteralArgument::Value || value->isFunctionObject());
1926	if (arg == ObjectLiteralArgument::Value || arg == ObjectLiteralArgument::Getter) {
1927	pd->value = value;
1928	pd->set = Value::emptyValue();
1929	} else {
1930	pd->value = Value::emptyValue();
1931	pd->set = value;
1932	}
1933	bool ok = o->defineOwnProperty(id: name, p: pd, attrs: (arg == ObjectLiteralArgument::Value ? Attr_Data : Attr_Accessor));
1934	if (!ok)
1935	return engine->throwTypeError();
1936
1937	args += 3;
1938	}
1939	return o.asReturnedValue();
1940	}
1941
1942	ReturnedValue Runtime::CreateClass::call(ExecutionEngine *engine, int classIndex,
1943	const Value &superClass, Value computedNames[])
1944	{
1945	const QV4::ExecutableCompilationUnit *unit
1946	= engine->currentStackFrame->v4Function->executableCompilationUnit();
1947	const QV4::CompiledData::Class *cls = unit->unitData()->classAt(idx: classIndex);
1948
1949	Scope scope(engine);
1950	ScopedObject protoParent(scope, engine->objectPrototype());
1951	ScopedObject constructorParent(scope, engine->functionPrototype());
1952	if (!superClass.isEmpty()) {
1953	if (superClass.isNull()) {
1954	protoParent = Encode::null();
1955	} else {
1956	const FunctionObject *superFunction = superClass.as<FunctionObject>();
1957	// ### check that the heritage object is a constructor
1958	if (!superFunction || !superFunction->isConstructor())
1959	return engine->throwTypeError(QStringLiteral("The superclass is not a function object."));
1960	const FunctionObject *s = static_cast<const FunctionObject *>(&superClass);
1961	ScopedValue result(scope, s->get(name: scope.engine->id_prototype()));
1962	if (!result->isObject() && !result->isNull())
1963	return engine->throwTypeError(QStringLiteral("The value of the superclass's prototype property is not an object."));
1964	protoParent = *result;
1965	constructorParent = superClass;
1966	}
1967	}
1968
1969	ScopedObject proto(scope, engine->newObject());
1970	proto->setPrototypeUnchecked(protoParent);
1971	ExecutionContext *current = engine->currentContext();
1972
1973	ScopedFunctionObject constructor(scope);
1974	QV4::Function *f = cls->constructorFunction != UINT_MAX ? unit->runtimeFunctions[cls->constructorFunction] : nullptr;
1975	constructor = FunctionObject::createConstructorFunction(scope: current, function: f, homeObject: proto, isDerivedConstructor: !superClass.isEmpty())->asReturnedValue();
1976	constructor->setPrototypeUnchecked(constructorParent);
1977	Value argCount = Value::fromInt32(i: f ? f->nFormals : 0);
1978	constructor->defineReadonlyConfigurableProperty(name: scope.engine->id_length(), value: argCount);
1979	constructor->defineReadonlyConfigurableProperty(name: engine->id_prototype(), value: proto);
1980	proto->defineDefaultProperty(name: engine->id_constructor(), value: constructor);
1981
1982	ScopedString name(scope);
1983	if (cls->nameIndex != UINT_MAX) {
1984	name = unit->runtimeStrings[cls->nameIndex];
1985	constructor->defineReadonlyConfigurableProperty(name: engine->id_name(), value: name);
1986	}
1987
1988	ScopedObject receiver(scope, *constructor);
1989	ScopedPropertyKey propertyName(scope);
1990	ScopedFunctionObject function(scope);
1991	ScopedProperty property(scope);
1992	const CompiledData::Method *methods = cls->methodTable();
1993	for (uint i = 0; i < cls->nStaticMethods + cls->nMethods; ++i) {
1994	if (i == cls->nStaticMethods)
1995	receiver = proto;
1996	if (methods[i].name == UINT_MAX) {
1997	propertyName = computedNames->toPropertyKey(e: engine);
1998	if (propertyName == scope.engine->id_prototype()->propertyKey() && receiver->d() == constructor->d())
1999	return engine->throwTypeError(QStringLiteral("Cannot declare a static method named 'prototype'."));
2000	if (engine->hasException)
2001	return Encode::undefined();
2002	++computedNames;
2003	} else {
2004	name = unit->runtimeStrings[methods[i].name];
2005	propertyName = name->toPropertyKey();
2006	}
2007	QV4::Function *f = unit->runtimeFunctions[methods[i].function];
2008	Q_ASSERT(f);
2009	PropertyKey::FunctionNamePrefix prefix = PropertyKey::None;
2010	if (methods[i].type == CompiledData::Method::Getter)
2011	prefix = PropertyKey::Getter;
2012	else if (methods[i].type == CompiledData::Method::Setter)
2013	prefix = PropertyKey::Setter;
2014
2015	name = propertyName->asFunctionName(e: engine, prefix);
2016
2017	if (f->isGenerator())
2018	function = MemberGeneratorFunction::create(scope: current, function: f, homeObject: receiver, name);
2019	else
2020	function = FunctionObject::createMemberFunction(scope: current, function: f, homeObject: receiver, name);
2021	Q_ASSERT(function);
2022	PropertyAttributes attributes;
2023	switch (methods[i].type) {
2024	case CompiledData::Method::Getter:
2025	property->setGetter(function);
2026	property->set = Value::emptyValue();
2027	attributes = Attr_Accessor|Attr_NotEnumerable;
2028	break;
2029	case CompiledData::Method::Setter:
2030	property->value = Value::emptyValue();
2031	property->setSetter(function);
2032	attributes = Attr_Accessor|Attr_NotEnumerable;
2033	break;
2034	default: // Regular
2035	property->value = function;
2036	property->set = Value::emptyValue();
2037	attributes = Attr_Data|Attr_NotEnumerable;
2038	break;
2039	}
2040	receiver->defineOwnProperty(id: propertyName, p: property, attrs: attributes);
2041	}
2042
2043	return constructor->asReturnedValue();
2044	}
2045
2046	QV4::ReturnedValue Runtime::CreateMappedArgumentsObject::call(ExecutionEngine *engine)
2047	{
2048	Q_ASSERT(engine->currentContext()->d()->type == Heap::ExecutionContext::Type_CallContext);
2049	Heap::InternalClass *ic = engine->internalClasses(icType: EngineBase::Class_ArgumentsObject);
2050	return engine->memoryManager->allocObject<ArgumentsObject>(ic, args&: engine->currentStackFrame)->asReturnedValue();
2051	}
2052
2053	QV4::ReturnedValue Runtime::CreateUnmappedArgumentsObject::call(ExecutionEngine *engine)
2054	{
2055	Q_ASSERT(engine->currentStackFrame->isJSTypesFrame());
2056	Heap::InternalClass *ic = engine->internalClasses(icType: EngineBase::Class_StrictArgumentsObject);
2057	return engine->memoryManager->allocObject<StrictArgumentsObject>(
2058	ic, args: static_cast<JSTypesStackFrame *>(engine->currentStackFrame))->asReturnedValue();
2059	}
2060
2061	QV4::ReturnedValue Runtime::CreateRestParameter::call(ExecutionEngine *engine, int argIndex)
2062	{
2063	Q_ASSERT(engine->currentStackFrame->isJSTypesFrame());
2064	JSTypesStackFrame *frame = static_cast<JSTypesStackFrame *>(engine->currentStackFrame);
2065	const Value *values = frame->argv() + argIndex;
2066	int nValues = frame->argc() - argIndex;
2067	if (nValues <= 0)
2068	return engine->newArrayObject(count: 0)->asReturnedValue();
2069	return engine->newArrayObject(values, length: nValues)->asReturnedValue();
2070	}
2071
2072	ReturnedValue Runtime::RegexpLiteral::call(ExecutionEngine *engine, int id)
2073	{
2074	const auto val
2075	= engine->currentStackFrame->v4Function->compilationUnit->runtimeRegularExpressions[id];
2076	Heap::RegExpObject *ro = engine->newRegExpObject(re: Value::fromStaticValue(staticValue: val).as<RegExp>());
2077	return ro->asReturnedValue();
2078	}
2079
2080	ReturnedValue Runtime::ToObject::call(ExecutionEngine *engine, const Value &obj)
2081	{
2082	if (obj.isObject())
2083	return obj.asReturnedValue();
2084
2085	return obj.toObject(e: engine)->asReturnedValue();
2086	}
2087
2088	Bool Runtime::ToBoolean::call(const Value &obj)
2089	{
2090	return obj.toBoolean();
2091	}
2092
2093	ReturnedValue Runtime::ToNumber::call(ExecutionEngine *, const Value &v)
2094	{
2095	return Encode(v.toNumber());
2096	}
2097
2098	ReturnedValue Runtime::UMinus::call(const Value &value)
2099	{
2100	TRACE1(value);
2101
2102	// +0 != -0, so we need to convert to double when negating 0
2103	if (value.isInteger() && value.integerValue() &&
2104	value.integerValue() != std::numeric_limits<int>::min())
2105	return Encode(-value.integerValue());
2106	else {
2107	double n = RuntimeHelpers::toNumber(value);
2108	return Encode(-n);
2109	}
2110	}
2111
2112	// binary operators
2113
2114	ReturnedValue Runtime::Add::call(ExecutionEngine *engine, const Value &left, const Value &right)
2115	{
2116	TRACE2(left, right);
2117
2118	if (Q_LIKELY(left.integerCompatible() && right.integerCompatible()))
2119	return add_int32(a: left.integerValue(), b: right.integerValue());
2120	if (left.isNumber() && right.isNumber())
2121	return Value::fromDouble(d: left.asDouble() + right.asDouble()).asReturnedValue();
2122
2123	return RuntimeHelpers::addHelper(engine, left, right);
2124	}
2125
2126	ReturnedValue Runtime::Sub::call(const Value &left, const Value &right)
2127	{
2128	TRACE2(left, right);
2129
2130	if (Q_LIKELY(left.integerCompatible() && right.integerCompatible()))
2131	return sub_int32(a: left.integerValue(), b: right.integerValue());
2132
2133	double lval = left.isNumber() ? left.asDouble() : left.toNumberImpl();
2134	double rval = right.isNumber() ? right.asDouble() : right.toNumberImpl();
2135
2136	return Value::fromDouble(d: lval - rval).asReturnedValue();
2137	}
2138
2139	ReturnedValue Runtime::Mul::call(const Value &left, const Value &right)
2140	{
2141	TRACE2(left, right);
2142
2143	if (Q_LIKELY(left.integerCompatible() && right.integerCompatible()))
2144	return mul_int32(a: left.integerValue(), b: right.integerValue());
2145
2146	double lval = left.isNumber() ? left.asDouble() : left.toNumberImpl();
2147	double rval = right.isNumber() ? right.asDouble() : right.toNumberImpl();
2148
2149	return Value::fromDouble(d: lval * rval).asReturnedValue();
2150	}
2151
2152	ReturnedValue Runtime::Div::call(const Value &left, const Value &right)
2153	{
2154	TRACE2(left, right);
2155
2156	if (Value::integerCompatible(a: left, b: right)) {
2157	int lval = left.integerValue();
2158	int rval = right.integerValue();
2159	if (rval != 0 // division by zero should result in a NaN
2160	&& !(lval == std::numeric_limits<int>::min() && rval == -1) // doesn't fit in int
2161	&& (lval % rval == 0) // fractions can't be stored in an int
2162	&& !(lval == 0 && rval < 0)) // 0 / -something results in -0.0
2163	return Encode(int(lval / rval));
2164	else
2165	return Encode(double(lval) / rval);
2166	}
2167
2168	double lval = left.toNumber();
2169	double rval = right.toNumber();
2170	return Value::fromDouble(d: lval / rval).asReturnedValue();
2171	}
2172
2173	ReturnedValue Runtime::Mod::call(const Value &left, const Value &right)
2174	{
2175	TRACE2(left, right);
2176
2177	if (Value::integerCompatible(a: left, b: right) && left.integerValue() >= 0 && right.integerValue() > 0) {
2178	// special cases are handled by fmod, among them:
2179	// - arithmic execeptions for ints in c++, eg: INT_MIN % -1
2180	// - undefined behavior in c++, e.g.: anything % 0
2181	// - uncommon cases which would complicate the condition, e.g.: negative integers
2182	// (this makes sure that -1 % 1 == -0 by passing it to fmod)
2183	return Encode(left.integerValue() % right.integerValue());
2184	}
2185
2186	double lval = RuntimeHelpers::toNumber(value: left);
2187	double rval = RuntimeHelpers::toNumber(value: right);
2188	#ifdef fmod
2189	# undef fmod
2190	#endif
2191	return Value::fromDouble(d: std::fmod(x: lval, y: rval)).asReturnedValue();
2192	}
2193
2194	ReturnedValue Runtime::Exp::call(const Value &base, const Value &exp)
2195	{
2196	double b = base.toNumber();
2197	double e = exp.toNumber();
2198	return Encode(QQmlPrivate::jsExponentiate(base: b, exponent: e));
2199	}
2200
2201	ReturnedValue Runtime::BitAnd::call(const Value &left, const Value &right)
2202	{
2203	TRACE2(left, right);
2204
2205	int lval = left.toInt32();
2206	int rval = right.toInt32();
2207	return Encode((int)(lval & rval));
2208	}
2209
2210	ReturnedValue Runtime::BitOr::call(const Value &left, const Value &right)
2211	{
2212	TRACE2(left, right);
2213
2214	int lval = left.toInt32();
2215	int rval = right.toInt32();
2216	return Encode((int)(lval | rval));
2217	}
2218
2219	ReturnedValue Runtime::BitXor::call(const Value &left, const Value &right)
2220	{
2221	TRACE2(left, right);
2222
2223	int lval = left.toInt32();
2224	int rval = right.toInt32();
2225	return Encode((int)(lval ^ rval));
2226	}
2227
2228	ReturnedValue Runtime::Shl::call(const Value &left, const Value &right)
2229	{
2230	TRACE2(left, right);
2231
2232	int lval = left.toInt32();
2233	int rval = right.toInt32() & 0x1f;
2234	return Encode((int)(lval << rval));
2235	}
2236
2237	ReturnedValue Runtime::Shr::call(const Value &left, const Value &right)
2238	{
2239	TRACE2(left, right);
2240
2241	int lval = left.toInt32();
2242	unsigned rval = right.toUInt32() & 0x1f;
2243	return Encode((int)(lval >> rval));
2244	}
2245
2246	ReturnedValue Runtime::UShr::call(const Value &left, const Value &right)
2247	{
2248	TRACE2(left, right);
2249
2250	unsigned lval = left.toUInt32();
2251	unsigned rval = right.toUInt32() & 0x1f;
2252	uint res = lval >> rval;
2253
2254	return Encode(res);
2255	}
2256
2257	ReturnedValue Runtime::GreaterThan::call(const Value &left, const Value &right)
2258	{
2259	TRACE2(left, right);
2260
2261	bool r = CompareGreaterThan::call(l: left, r: right);
2262	return Encode(r);
2263	}
2264
2265	ReturnedValue Runtime::LessThan::call(const Value &left, const Value &right)
2266	{
2267	TRACE2(left, right);
2268
2269	bool r = CompareLessThan::call(l: left, r: right);
2270	return Encode(r);
2271	}
2272
2273	ReturnedValue Runtime::GreaterEqual::call(const Value &left, const Value &right)
2274	{
2275	TRACE2(left, right);
2276
2277	bool r = CompareGreaterEqual::call(l: left, r: right);
2278	return Encode(r);
2279	}
2280
2281	ReturnedValue Runtime::LessEqual::call(const Value &left, const Value &right)
2282	{
2283	TRACE2(left, right);
2284
2285	bool r = CompareLessEqual::call(l: left, r: right);
2286	return Encode(r);
2287	}
2288
2289	struct LazyScope
2290	{
2291	ExecutionEngine *engine = nullptr;
2292	Value *stackMark = nullptr;
2293	~LazyScope() {
2294	if (engine)
2295	engine->jsStackTop = stackMark;
2296	}
2297	template <typename T>
2298	void set(Value **scopedValue, T value, ExecutionEngine *e) {
2299	if (!engine) {
2300	engine = e;
2301	stackMark = engine->jsStackTop;
2302	}
2303	if (!*scopedValue)
2304	*scopedValue = e->jsAlloca(nValues: 1);
2305	**scopedValue = value;
2306	}
2307	};
2308
2309	Bool Runtime::CompareEqual::call(const Value &left, const Value &right)
2310	{
2311	TRACE2(left, right);
2312
2313	Value lhs = left;
2314	Value rhs = right;
2315
2316	LazyScope scope;
2317	Value *lhsGuard = nullptr;
2318	Value *rhsGuard = nullptr;
2319
2320	redo:
2321	if (lhs.asReturnedValue() == rhs.asReturnedValue())
2322	return !lhs.isNaN();
2323
2324	quint32 lt = lhs.quickType();
2325	quint32 rt = rhs.quickType();
2326
2327	// LHS: Check if managed
2328	if ((lt & (Value::ManagedMask >> Value::Tag_Shift)) == 0) {
2329	if (lhs.isUndefined())
2330	return rhs.isNullOrUndefined();
2331
2332	// RHS: Check if managed
2333	if ((rt & (Value::ManagedMask >> Value::Tag_Shift)) == 0) {
2334	if (rhs.isUndefined())
2335	return false;
2336
2337	Heap::Base *l = lhs.m();
2338	Heap::Base *r = rhs.m();
2339	Q_ASSERT(l);
2340	Q_ASSERT(r);
2341	if (l->internalClass->vtable->isStringOrSymbol == r->internalClass->vtable->isStringOrSymbol)
2342	return static_cast<QV4::Managed &>(lhs).isEqualTo(other: &static_cast<QV4::Managed &>(rhs));
2343	if (l->internalClass->vtable->isStringOrSymbol) {
2344	scope.set(scopedValue: &rhsGuard, value: RuntimeHelpers::objectDefaultValue(object: &static_cast<QV4::Object &>(rhs), typeHint: PREFERREDTYPE_HINT), e: r->internalClass->engine);
2345	rhs = rhsGuard->asReturnedValue();
2346	goto redo;
2347	} else {
2348	Q_ASSERT(r->internalClass->vtable->isStringOrSymbol);
2349	scope.set(scopedValue: &lhsGuard, value: RuntimeHelpers::objectDefaultValue(object: &static_cast<QV4::Object &>(lhs), typeHint: PREFERREDTYPE_HINT), e: l->internalClass->engine);
2350	lhs = lhsGuard->asReturnedValue();
2351	goto redo;
2352	}
2353	return false;
2354	}
2355
2356	lhs_managed_and_rhs_not:
2357	switch (rt) {
2358	case QV4::Value::QT_Empty:
2359	Q_UNREACHABLE();
2360	case QV4::Value::QT_Null:
2361	return false;
2362	case QV4::Value::QT_Bool:
2363	case QV4::Value::QT_Int:
2364	rhs = Value::fromDouble(d: rhs.int_32());
2365	Q_FALLTHROUGH();
2366	default: // double
2367	if (lhs.m()->internalClass->vtable->isStringOrSymbol) {
2368	return lhs.m()->internalClass->vtable->isString ? (RuntimeHelpers::toNumber(value: lhs) == rhs.doubleValue()) : false;
2369	} else {
2370	scope.set(scopedValue: &lhsGuard, value: RuntimeHelpers::objectDefaultValue(object: &static_cast<QV4::Object &>(lhs), typeHint: PREFERREDTYPE_HINT), e: lhs.m()->internalClass->engine);
2371	lhs = lhsGuard->asReturnedValue();
2372	}
2373	}
2374	goto redo;
2375	} else if ((rt & (Value::ManagedMask >> Value::Tag_Shift)) == 0) {
2376	if (rhs.isUndefined())
2377	return lhs.isNull(); // Can't be undefined
2378	qSwap(value1&: lhs, value2&: rhs);
2379	qSwap(value1&: lt, value2&: rt);
2380	goto lhs_managed_and_rhs_not;
2381	}
2382
2383	switch (lt) {
2384	case QV4::Value::QT_Empty:
2385	Q_UNREACHABLE();
2386	case QV4::Value::QT_Null:
2387	return rhs.isNull();
2388	case QV4::Value::QT_Bool:
2389	case QV4::Value::QT_Int:
2390	switch (rt) {
2391	case QV4::Value::QT_Empty:
2392	Q_UNREACHABLE();
2393	case QV4::Value::QT_Null:
2394	return false;
2395	case QV4::Value::QT_Bool:
2396	case QV4::Value::QT_Int:
2397	return lhs.int_32() == rhs.int_32();
2398	default: // double
2399	return lhs.int_32() == rhs.doubleValue();
2400	}
2401	default: // double
2402	switch (rt) {
2403	case QV4::Value::QT_Empty:
2404	Q_UNREACHABLE();
2405	case QV4::Value::QT_Null:
2406	return false;
2407	case QV4::Value::QT_Bool:
2408	case QV4::Value::QT_Int:
2409	return lhs.doubleValue() == rhs.int_32();
2410	default: // double
2411	return lhs.doubleValue() == rhs.doubleValue();
2412	}
2413	}
2414	}
2415
2416	ReturnedValue Runtime::Equal::call(const Value &left, const Value &right)
2417	{
2418	TRACE2(left, right);
2419
2420	bool r = CompareEqual::call(left, right);
2421	return Encode(r);
2422	}
2423
2424	ReturnedValue Runtime::NotEqual::call(const Value &left, const Value &right)
2425	{
2426	TRACE2(left, right);
2427
2428	bool r = !CompareEqual::call(left, right);
2429	return Encode(r);
2430	}
2431
2432	ReturnedValue Runtime::StrictEqual::call(const Value &left, const Value &right)
2433	{
2434	TRACE2(left, right);
2435
2436	bool r = RuntimeHelpers::strictEqual(x: left, y: right);
2437	return Encode(r);
2438	}
2439
2440	ReturnedValue Runtime::StrictNotEqual::call(const Value &left, const Value &right)
2441	{
2442	TRACE2(left, right);
2443
2444	bool r = ! RuntimeHelpers::strictEqual(x: left, y: right);
2445	return Encode(r);
2446	}
2447
2448	Bool Runtime::CompareNotEqual::call(const Value &left, const Value &right)
2449	{
2450	TRACE2(left, right);
2451
2452	return !Runtime::CompareEqual::call(left, right);
2453	}
2454
2455	Bool Runtime::CompareStrictEqual::call(const Value &left, const Value &right)
2456	{
2457	TRACE2(left, right);
2458
2459	return RuntimeHelpers::strictEqual(x: left, y: right);
2460	}
2461
2462	Bool Runtime::CompareStrictNotEqual::call(const Value &left, const Value &right)
2463	{
2464	TRACE2(left, right);
2465
2466	return ! RuntimeHelpers::strictEqual(x: left, y: right);
2467	}
2468
2469	template<typename Operation>
2470	static inline const void *symbol()
2471	{
2472	return reinterpret_cast<void *>(&Operation::call);
2473	}
2474
2475	QHash<const void *, const char *> Runtime::symbolTable()
2476	{
2477	static const QHash<const void *, const char *> symbols({
2478	#ifndef V4_BOOTSTRAP
2479	{symbol<CallGlobalLookup>(), "CallGlobalLookup" },
2480	{symbol<CallQmlContextPropertyLookup>(), "CallQmlContextPropertyLookup" },
2481	{symbol<CallName>(), "CallName" },
2482	{symbol<CallProperty>(), "CallProperty" },
2483	{symbol<CallPropertyLookup>(), "CallPropertyLookup" },
2484	{symbol<CallValue>(), "CallValue" },
2485	{symbol<CallWithReceiver>(), "CallWithReceiver" },
2486	{symbol<CallPossiblyDirectEval>(), "CallPossiblyDirectEval" },
2487	{symbol<CallWithSpread>(), "CallWithSpread" },
2488	{symbol<TailCall>(), "TailCall" },
2489
2490	{symbol<Construct>(), "Construct" },
2491	{symbol<ConstructWithSpread>(), "ConstructWithSpread" },
2492
2493	{symbol<StoreNameStrict>(), "StoreNameStrict" },
2494	{symbol<StoreNameSloppy>(), "StoreNameSloppy" },
2495	{symbol<StoreProperty>(), "StoreProperty" },
2496	{symbol<StoreElement>(), "StoreElement" },
2497	{symbol<LoadProperty>(), "LoadProperty" },
2498	{symbol<LoadName>(), "LoadName" },
2499	{symbol<LoadElement>(), "LoadElement" },
2500	{symbol<LoadSuperProperty>(), "LoadSuperProperty" },
2501	{symbol<StoreSuperProperty>(), "StoreSuperProperty" },
2502	{symbol<LoadSuperConstructor>(), "LoadSuperConstructor" },
2503	{symbol<LoadGlobalLookup>(), "LoadGlobalLookup" },
2504	{symbol<LoadQmlContextPropertyLookup>(), "LoadQmlContextPropertyLookup" },
2505	{symbol<GetLookup>(), "GetLookup" },
2506	{symbol<SetLookupStrict>(), "SetLookupStrict" },
2507	{symbol<SetLookupSloppy>(), "SetLookupSloppy" },
2508
2509	{symbol<TypeofValue>(), "TypeofValue" },
2510	{symbol<TypeofName>(), "TypeofName" },
2511
2512	{symbol<DeleteProperty_NoThrow>(), "DeleteProperty_NoThrow" },
2513	{symbol<DeleteProperty>(), "DeleteProperty" },
2514	{symbol<DeleteName_NoThrow>(), "DeleteName_NoThrow" },
2515	{symbol<DeleteName>(), "DeleteName" },
2516
2517	{symbol<ThrowException>(), "ThrowException" },
2518	{symbol<PushCallContext>(), "PushCallContext" },
2519	{symbol<PushWithContext>(), "PushWithContext" },
2520	{symbol<PushCatchContext>(), "PushCatchContext" },
2521	{symbol<PushBlockContext>(), "PushBlockContext" },
2522	{symbol<CloneBlockContext>(), "CloneBlockContext" },
2523	{symbol<PushScriptContext>(), "PushScriptContext" },
2524	{symbol<PopScriptContext>(), "PopScriptContext" },
2525	{symbol<ThrowReferenceError>(), "ThrowReferenceError" },
2526	{symbol<ThrowOnNullOrUndefined>(), "ThrowOnNullOrUndefined" },
2527
2528	{symbol<Closure>(), "Closure" },
2529
2530	{symbol<MarkCustom>(), "MarkCustom"},
2531
2532	{symbol<ConvertThisToObject>(), "ConvertThisToObject" },
2533	{symbol<DeclareVar>(), "DeclareVar" },
2534	{symbol<CreateMappedArgumentsObject>(), "CreateMappedArgumentsObject" },
2535	{symbol<CreateUnmappedArgumentsObject>(), "CreateUnmappedArgumentsObject" },
2536	{symbol<CreateRestParameter>(), "CreateRestParameter" },
2537
2538	{symbol<ArrayLiteral>(), "ArrayLiteral" },
2539	{symbol<ObjectLiteral>(), "ObjectLiteral" },
2540	{symbol<CreateClass>(), "CreateClass" },
2541
2542	{symbol<GetIterator>(), "GetIterator" },
2543	{symbol<IteratorNext>(), "IteratorNext" },
2544	{symbol<IteratorNextForYieldStar>(), "IteratorNextForYieldStar" },
2545	{symbol<IteratorClose>(), "IteratorClose" },
2546	{symbol<DestructureRestElement>(), "DestructureRestElement" },
2547
2548	{symbol<ToObject>(), "ToObject" },
2549	{symbol<ToBoolean>(), "ToBoolean" },
2550	{symbol<ToNumber>(), "ToNumber" },
2551
2552	{symbol<UMinus>(), "UMinus" },
2553
2554	{symbol<Instanceof>(), "Instanceof" },
2555	{symbol<As>(), "As" },
2556	{symbol<In>(), "In" },
2557	{symbol<Add>(), "Add" },
2558	{symbol<Sub>(), "Sub" },
2559	{symbol<Mul>(), "Mul" },
2560	{symbol<Div>(), "Div" },
2561	{symbol<Mod>(), "Mod" },
2562	{symbol<Exp>(), "Exp" },
2563	{symbol<BitAnd>(), "BitAnd" },
2564	{symbol<BitOr>(), "BitOr" },
2565	{symbol<BitXor>(), "BitXor" },
2566	{symbol<Shl>(), "Shl" },
2567	{symbol<Shr>(), "Shr" },
2568	{symbol<UShr>(), "UShr" },
2569	{symbol<GreaterThan>(), "GreaterThan" },
2570	{symbol<LessThan>(), "LessThan" },
2571	{symbol<GreaterEqual>(), "GreaterEqual" },
2572	{symbol<LessEqual>(), "LessEqual" },
2573	{symbol<Equal>(), "Equal" },
2574	{symbol<NotEqual>(), "NotEqual" },
2575	{symbol<StrictEqual>(), "StrictEqual" },
2576	{symbol<StrictNotEqual>(), "StrictNotEqual" },
2577
2578	{symbol<CompareGreaterThan>(), "CompareGreaterThan" },
2579	{symbol<CompareLessThan>(), "CompareLessThan" },
2580	{symbol<CompareGreaterEqual>(), "CompareGreaterEqual" },
2581	{symbol<CompareLessEqual>(), "CompareLessEqual" },
2582	{symbol<CompareEqual>(), "CompareEqual" },
2583	{symbol<CompareNotEqual>(), "CompareNotEqual" },
2584	{symbol<CompareStrictEqual>(), "CompareStrictEqual" },
2585	{symbol<CompareStrictNotEqual>(), "CompareStrictNotEqual" },
2586
2587	{symbol<CompareInstanceof>(), "CompareInstanceOf" },
2588	{symbol<CompareIn>(), "CompareIn" },
2589
2590	{symbol<RegexpLiteral>(), "RegexpLiteral" },
2591	{symbol<GetTemplateObject>(), "GetTemplateObject" }
2592	#endif
2593	});
2594
2595	return symbols;
2596	}
2597
2598	} // namespace QV4
2599
2600	QT_END_NAMESPACE
2601