1	// Copyright (C) 2017 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 <QBuffer>
5	#include <QFile>
6
7	#include "qv4engine_p.h"
8	#include "qv4baselineassembler_p.h"
9	#include "qv4assemblercommon_p.h"
10	#include <private/qv4function_p.h>
11	#include <private/qv4runtime_p.h>
12	#include <private/qv4stackframe_p.h>
13
14	#include <wtf/Vector.h>
15	#include <assembler/MacroAssembler.h>
16	#include <assembler/MacroAssemblerCodeRef.h>
17	#include <assembler/LinkBuffer.h>
18	#include <WTFStubs.h>
19
20	#undef ENABLE_ALL_ASSEMBLERS_FOR_REFACTORING_PURPOSES
21
22	#if QT_CONFIG(qml_jit)
23
24	QT_BEGIN_NAMESPACE
25	namespace QV4 {
26	namespace JIT {
27
28	#define ASM_GENERATE_RUNTIME_CALL(function, destination) \
29	pasm()->GENERATE_RUNTIME_CALL(function, destination)
30	#define callHelper(x) \
31	PlatformAssemblerCommon::callRuntimeUnchecked(reinterpret_cast<void *>(&x), #x)
32
33	const QV4::Value::ValueTypeInternal IntegerTag = QV4::Value::ValueTypeInternal::Integer;
34
35	static ReturnedValue toNumberHelper(ReturnedValue v)
36	{
37	return Encode(Value::fromReturnedValue(val: v).toNumber());
38	}
39
40	static ReturnedValue toInt32Helper(ReturnedValue v)
41	{
42	return Encode(Value::fromReturnedValue(val: v).toInt32());
43	}
44
45	#if QT_POINTER_SIZE == 8 || defined(ENABLE_ALL_ASSEMBLERS_FOR_REFACTORING_PURPOSES)
46	class PlatformAssembler64 : public PlatformAssemblerCommon
47	{
48	public:
49	PlatformAssembler64(const Value *constantTable)
50	: PlatformAssemblerCommon(constantTable)
51	{}
52
53	void callRuntime(const void *funcPtr, CallResultDestination dest)
54	{
55	PlatformAssemblerCommon::callRuntime(funcPtr);
56	if (dest == CallResultDestination::InAccumulator)
57	saveReturnValueInAccumulator();
58	else if (AccumulatorRegister == ReturnValueRegister)
59	loadUndefined();
60	}
61
62	void saveReturnValueInAccumulator()
63	{
64	move(src: ReturnValueRegister, dest: AccumulatorRegister);
65	}
66
67	void loadUndefined(RegisterID dest = AccumulatorRegister)
68	{
69	move(imm: TrustedImm64(0), dest);
70	}
71
72	void copyConst(int constIndex, Address dest)
73	{
74	//###
75	if (constant(idx: constIndex).isUndefined()) {
76	loadUndefined(dest: ScratchRegister);
77	} else {
78	load64(address: loadConstAddress(constIndex, baseReg: ScratchRegister), dest: ScratchRegister);
79	}
80	store64(src: ScratchRegister, address: dest);
81	}
82
83	void copyReg(Address src, Address dst)
84	{
85	load64(address: src, dest: ScratchRegister);
86	store64(src: ScratchRegister, address: dst);
87	}
88
89	void loadPointerFromValue(Address addr, RegisterID dest = AccumulatorRegister)
90	{
91	load64(address: addr, dest);
92	}
93
94	void loadAccumulator(Address addr)
95	{
96	load64(address: addr, dest: AccumulatorRegister);
97	}
98
99	void storeAccumulator(Address addr)
100	{
101	store64(src: AccumulatorRegister, address: addr);
102	}
103
104	void moveReg(Address sourceRegAddress, Address destRegAddress)
105	{
106	load64(address: sourceRegAddress, dest: ScratchRegister);
107	store64(src: ScratchRegister, address: destRegAddress);
108	}
109
110	void loadString(int stringId)
111	{
112	loadAccumulator(addr: loadStringAddress(stringId));
113	}
114
115	void loadValue(ReturnedValue value)
116	{
117	move(imm: TrustedImm64(value), dest: AccumulatorRegister);
118	}
119
120	void storeHeapObject(RegisterID source, Address addr)
121	{
122	store64(src: source, address: addr);
123	}
124
125	void generateCatchTrampoline()
126	{
127	PlatformAssemblerCommon::generateCatchTrampoline(loadUndefined: [this](){loadUndefined();});
128	}
129
130	void jumpNotUndefined(int offset)
131	{
132	auto jump = branch64(cond: NotEqual, left: AccumulatorRegister, right: TrustedImm64(0));
133	addJumpToOffset(jump, offset);
134	}
135
136	Jump jumpEmpty()
137	{
138	return branch64(cond: Equal, left: AccumulatorRegister, right: TrustedImm64(Value::emptyValue().asReturnedValue()));
139	}
140
141	Jump jumpNotEmpty()
142	{
143	return branch64(cond: NotEqual, left: AccumulatorRegister, right: TrustedImm64(Value::emptyValue().asReturnedValue()));
144	}
145
146	void toBoolean(std::function<void(RegisterID)> continuation)
147	{
148	urshift64(src: AccumulatorRegister, imm: TrustedImm32(Value::IsIntegerConvertible_Shift), dest: ScratchRegister);
149	auto needsConversion = branch32(
150	cond: NotEqual, left: TrustedImm32(Value::IsIntegerConvertible_Value), right: ScratchRegister);
151
152	continuation(AccumulatorRegister);
153	Jump done = jump();
154
155	// slow path:
156	needsConversion.link(masm: this);
157	push(src: AccumulatorRegister);
158	move(src: AccumulatorRegister, dest: registerForArg(arg: 0));
159	callHelper(Value::toBooleanImpl);
160	and32(imm: TrustedImm32(1), src: ReturnValueRegister, dest: ScratchRegister);
161	pop(dest: AccumulatorRegister);
162	continuation(ScratchRegister);
163
164	done.link(masm: this);
165	}
166
167	void toNumber()
168	{
169	move(imm: TrustedImm64(Value::NumberMask), dest: ScratchRegister);
170	and64(src: AccumulatorRegister, dest: ScratchRegister);
171	move(imm: TrustedImm64(Value::NumberDiscriminator), dest: ScratchRegister2);
172	auto isNumber = branch64(cond: GreaterThanOrEqual, left: ScratchRegister, right: ScratchRegister2);
173
174	move(src: AccumulatorRegister, dest: registerForArg(arg: 0));
175	callHelper(toNumberHelper);
176	saveReturnValueInAccumulator();
177
178	isNumber.link(masm: this);
179	}
180
181	// this converts both the lhs and the accumulator to int32
182	void toInt32LhsAcc(Address lhs, RegisterID lhsTarget)
183	{
184	load64(address: lhs, dest: lhsTarget);
185	urshift64(src: lhsTarget, imm: TrustedImm32(Value::QuickType_Shift), dest: ScratchRegister2);
186	auto lhsIsInt = branch32(cond: Equal, left: TrustedImm32(Value::QT_Int), right: ScratchRegister2);
187
188	const Address accumulatorStackAddress(JSStackFrameRegister,
189	offsetof(CallData, accumulator));
190	storeAccumulator(addr: accumulatorStackAddress);
191	move(src: lhsTarget, dest: registerForArg(arg: 0));
192	callHelper(toInt32Helper);
193	move(src: ReturnValueRegister, dest: lhsTarget);
194	loadAccumulator(addr: accumulatorStackAddress);
195
196	lhsIsInt.link(masm: this);
197	urshift64(src: AccumulatorRegister, imm: TrustedImm32(Value::QuickType_Shift), dest: ScratchRegister2);
198	auto isInt = branch32(cond: Equal, left: TrustedImm32(Value::QT_Int), right: ScratchRegister2);
199
200	pushAligned(reg: lhsTarget);
201	move(src: AccumulatorRegister, dest: registerForArg(arg: 0));
202	callHelper(toInt32Helper);
203	saveReturnValueInAccumulator();
204	popAligned(reg: lhsTarget);
205
206	isInt.link(masm: this);
207	}
208
209	void toInt32()
210	{
211	urshift64(src: AccumulatorRegister, imm: TrustedImm32(Value::QuickType_Shift), dest: ScratchRegister2);
212	auto isInt = branch32(cond: Equal, left: TrustedImm32(Value::QT_Int), right: ScratchRegister2);
213
214	move(src: AccumulatorRegister, dest: registerForArg(arg: 0));
215	callHelper(toInt32Helper);
216	saveReturnValueInAccumulator();
217
218	isInt.link(masm: this);
219	}
220
221	void regToInt32(Address srcReg, RegisterID targetReg)
222	{
223	load64(address: srcReg, dest: targetReg);
224	urshift64(src: targetReg, imm: TrustedImm32(Value::QuickType_Shift), dest: ScratchRegister2);
225	auto isInt = branch32(cond: Equal, left: TrustedImm32(Value::QT_Int), right: ScratchRegister2);
226
227	pushAligned(reg: AccumulatorRegister);
228	move(src: targetReg, dest: registerForArg(arg: 0));
229	callHelper(toInt32Helper);
230	move(src: ReturnValueRegister, dest: targetReg);
231	popAligned(reg: AccumulatorRegister);
232
233	isInt.link(masm: this);
234	}
235
236	void isNullOrUndefined()
237	{
238	move(src: AccumulatorRegister, dest: ScratchRegister);
239	compare64(cond: Equal, left: ScratchRegister, right: TrustedImm32(0), dest: AccumulatorRegister);
240	Jump isUndef = branch32(cond: NotEqual, left: TrustedImm32(0), right: AccumulatorRegister);
241
242	// not undefined
243	rshift64(imm: TrustedImm32(32), dest: ScratchRegister);
244	compare32(cond: Equal, left: ScratchRegister, right: TrustedImm32(int(QV4::Value::ValueTypeInternal::Null)),
245	dest: AccumulatorRegister);
246
247	isUndef.link(masm: this);
248	}
249
250	Jump isIntOrBool()
251	{
252	urshift64(src: AccumulatorRegister, imm: TrustedImm32(Value::IsIntegerOrBool_Shift), dest: ScratchRegister);
253	return branch32(cond: Equal, left: TrustedImm32(Value::IsIntegerOrBool_Value), right: ScratchRegister);
254	}
255
256	void jumpStrictEqualStackSlotInt(int lhs, int rhs, int offset)
257	{
258	Address lhsAddr(JSStackFrameRegister, lhs * int(sizeof(Value)));
259	load64(address: lhsAddr, dest: ScratchRegister);
260	Jump isUndef = branch64(cond: Equal, left: ScratchRegister, right: TrustedImm64(0));
261	Jump equal = branch32(cond: Equal, left: TrustedImm32(rhs), right: ScratchRegister);
262	addJumpToOffset(jump: equal, offset);
263	isUndef.link(masm: this);
264	}
265
266	void jumpStrictNotEqualStackSlotInt(int lhs, int rhs, int offset)
267	{
268	Address lhsAddr(JSStackFrameRegister, lhs * int(sizeof(Value)));
269	load64(address: lhsAddr, dest: ScratchRegister);
270	Jump isUndef = branch64(cond: Equal, left: ScratchRegister, right: TrustedImm64(0));
271	addJumpToOffset(jump: isUndef, offset);
272	Jump notEqual = branch32(cond: NotEqual, left: TrustedImm32(rhs), right: ScratchRegister);
273	addJumpToOffset(jump: notEqual, offset);
274	}
275
276	void setAccumulatorTag(QV4::Value::ValueTypeInternal tag, RegisterID sourceReg = NoRegister)
277	{
278	if (sourceReg == NoRegister)
279	or64(imm: TrustedImm64(int64_t(tag) << 32), dest: AccumulatorRegister);
280	else
281	or64(imm: TrustedImm64(int64_t(tag) << 32), src: sourceReg, dest: AccumulatorRegister);
282	}
283
284	void encodeDoubleIntoAccumulator(FPRegisterID src)
285	{
286	moveDoubleTo64(src, dest: AccumulatorRegister);
287	move(imm: TrustedImm64(Value::EncodeMask), dest: ScratchRegister);
288	xor64(src: ScratchRegister, dest: AccumulatorRegister);
289	}
290
291	void pushValueAligned(ReturnedValue v)
292	{
293	loadValue(value: v);
294	pushAligned(reg: AccumulatorRegister);
295	}
296
297	void popValueAligned()
298	{
299	addPtr(imm: TrustedImm32(2 * PointerSize), srcDest: StackPointerRegister);
300	}
301
302	Jump binopBothIntPath(Address lhsAddr, std::function<Jump(void)> fastPath)
303	{
304	urshift64(src: AccumulatorRegister, imm: TrustedImm32(32), dest: ScratchRegister);
305	Jump accNotInt = branch32(cond: NotEqual, left: TrustedImm32(int(IntegerTag)), right: ScratchRegister);
306	load64(address: lhsAddr, dest: ScratchRegister);
307	urshift64(src: ScratchRegister, imm: TrustedImm32(32), dest: ScratchRegister2);
308	Jump lhsNotInt = branch32(cond: NotEqual, left: TrustedImm32(int(IntegerTag)), right: ScratchRegister2);
309
310	// both integer
311	Jump failure = fastPath();
312	Jump done = jump();
313
314	// all other cases
315	if (failure.isSet())
316	failure.link(masm: this);
317	accNotInt.link(masm: this);
318	lhsNotInt.link(masm: this);
319
320	return done;
321	}
322
323	Jump unopIntPath(std::function<Jump(void)> fastPath)
324	{
325	urshift64(src: AccumulatorRegister, imm: TrustedImm32(Value::IsIntegerConvertible_Shift), dest: ScratchRegister);
326	Jump accNotIntConvertible = branch32(
327	cond: NotEqual, left: TrustedImm32(Value::IsIntegerConvertible_Value), right: ScratchRegister);
328
329	// both integer
330	Jump failure = fastPath();
331	Jump done = jump();
332
333	// all other cases
334	if (failure.isSet())
335	failure.link(masm: this);
336	accNotIntConvertible.link(masm: this);
337
338	return done;
339	}
340
341	void callWithAccumulatorByValueAsFirstArgument(std::function<void()> doCall)
342	{
343	passAsArg(src: AccumulatorRegister, arg: 0);
344	doCall();
345	}
346	};
347
348	typedef PlatformAssembler64 PlatformAssembler;
349	#endif
350
351	#if QT_POINTER_SIZE == 4 || defined(ENABLE_ALL_ASSEMBLERS_FOR_REFACTORING_PURPOSES)
352	class PlatformAssembler32 : public PlatformAssemblerCommon
353	{
354	public:
355	PlatformAssembler32(const Value *constantTable)
356	: PlatformAssemblerCommon(constantTable)
357	{}
358
359	void callRuntime(const void *funcPtr, CallResultDestination dest)
360	{
361	PlatformAssemblerCommon::callRuntime(funcPtr);
362	if (dest == CallResultDestination::InAccumulator)
363	saveReturnValueInAccumulator();
364	else if (AccumulatorRegisterValue == ReturnValueRegisterValue)
365	loadUndefined();
366	}
367
368	void saveReturnValueInAccumulator()
369	{
370	move(ReturnValueRegisterValue, AccumulatorRegisterValue);
371	move(ReturnValueRegisterTag, AccumulatorRegisterTag);
372	}
373
374	void loadUndefined()
375	{
376	move(TrustedImm32(0), AccumulatorRegisterValue);
377	move(TrustedImm32(0), AccumulatorRegisterTag);
378	}
379
380	void copyConst(int constIndex, Address destRegAddr)
381	{
382	//###
383	if (constant(constIndex).isUndefined()) {
384	move(TrustedImm32(0), ScratchRegister);
385	store32(ScratchRegister, destRegAddr);
386	destRegAddr.offset += 4;
387	store32(ScratchRegister, destRegAddr);
388	} else {
389	Address src = loadConstAddress(constIndex);
390	loadDouble(src, FPScratchRegister);
391	storeDouble(FPScratchRegister, destRegAddr);
392	}
393	}
394
395	void copyReg(Address src, Address dest)
396	{
397	loadDouble(src, FPScratchRegister);
398	storeDouble(FPScratchRegister, dest);
399	}
400
401	void loadPointerFromValue(Address addr, RegisterID dest = AccumulatorRegisterValue)
402	{
403	load32(addr, dest);
404	}
405
406	void loadAccumulator(Address src)
407	{
408	load32(src, AccumulatorRegisterValue);
409	src.offset += 4;
410	load32(src, AccumulatorRegisterTag);
411	}
412
413	void storeAccumulator(Address addr)
414	{
415	store32(AccumulatorRegisterValue, addr);
416	addr.offset += 4;
417	store32(AccumulatorRegisterTag, addr);
418	}
419
420	void moveReg(Address sourceRegAddress, Address destRegAddress)
421	{
422	load32(sourceRegAddress, ScratchRegister);
423	store32(ScratchRegister, destRegAddress);
424	sourceRegAddress.offset += 4;
425	destRegAddress.offset += 4;
426	load32(sourceRegAddress, ScratchRegister);
427	store32(ScratchRegister, destRegAddress);
428	}
429
430	void loadString(int stringId)
431	{
432	load32(loadStringAddress(stringId), AccumulatorRegisterValue);
433	move(TrustedImm32(0), AccumulatorRegisterTag);
434	}
435
436	void loadValue(ReturnedValue value)
437	{
438	move(TrustedImm32(Value::fromReturnedValue(value).value()), AccumulatorRegisterValue);
439	move(TrustedImm32(Value::fromReturnedValue(value).tag()), AccumulatorRegisterTag);
440	}
441
442	void storeHeapObject(RegisterID source, Address addr)
443	{
444	store32(source, addr);
445	addr.offset += 4;
446	store32(TrustedImm32(0), addr);
447	}
448
449
450	void generateCatchTrampoline()
451	{
452	PlatformAssemblerCommon::generateCatchTrampoline([this](){loadUndefined();});
453	}
454
455	void toNumber()
456	{
457	and32(TrustedImm32(Value::NumberMask >> Value::Tag_Shift),
458	AccumulatorRegisterTag, ScratchRegister);
459	auto isNumber = branch32(
460	GreaterThanOrEqual, ScratchRegister,
461	TrustedImm32(Value::NumberDiscriminator >> Value::Tag_Shift));
462
463
464	if (ArgInRegCount < 2) {
465	subPtr(TrustedImm32(2 * PointerSize), StackPointerRegister); // stack alignment
466	push(AccumulatorRegisterTag);
467	push(AccumulatorRegisterValue);
468	} else {
469	move(AccumulatorRegisterValue, registerForArg(0));
470	move(AccumulatorRegisterTag, registerForArg(1));
471	}
472	callHelper(toNumberHelper);
473	saveReturnValueInAccumulator();
474	if (ArgInRegCount < 2)
475	addPtr(TrustedImm32(4 * PointerSize), StackPointerRegister);
476
477	isNumber.link(this);
478	}
479
480	// this converts both the lhs and the accumulator to int32
481	void toInt32LhsAcc(Address lhs, RegisterID lhsTarget)
482	{
483	bool accumulatorNeedsSaving = AccumulatorRegisterValue == ReturnValueRegisterValue
484	|| AccumulatorRegisterTag == ReturnValueRegisterTag;
485	lhs.offset += 4;
486	load32(lhs, lhsTarget);
487	lhs.offset -= 4;
488	auto lhsIsNotInt = branch32(NotEqual, TrustedImm32(int(IntegerTag)), lhsTarget);
489	load32(lhs, lhsTarget);
490	auto lhsIsInt = jump();
491
492	lhsIsNotInt.link(this);
493
494	// Save accumulator from being garbage collected, no matter if we will reuse the register.
495	const Address accumulatorStackAddress(JSStackFrameRegister,
496	offsetof(CallData, accumulator));
497	storeAccumulator(accumulatorStackAddress);
498
499	if (ArgInRegCount < 2) {
500	subPtr(TrustedImm32(2 * PointerSize), StackPointerRegister);
501	push(lhsTarget);
502	load32(lhs, lhsTarget);
503	push(lhsTarget);
504	} else {
505	move(lhsTarget, registerForArg(1));
506	load32(lhs, registerForArg(0));
507	}
508	callHelper(toInt32Helper);
509	move(ReturnValueRegisterValue, lhsTarget);
510	if (ArgInRegCount < 2)
511	addPtr(TrustedImm32(4 * PointerSize), StackPointerRegister);
512
513	if (accumulatorNeedsSaving) // otherwise it's still the same
514	loadAccumulator(accumulatorStackAddress);
515
516	lhsIsInt.link(this);
517
518	auto rhsIsInt = branch32(Equal, TrustedImm32(int(IntegerTag)), AccumulatorRegisterTag);
519
520	pushAligned(lhsTarget);
521	if (ArgInRegCount < 2) {
522	subPtr(TrustedImm32(2 * PointerSize), StackPointerRegister);
523	push(AccumulatorRegisterTag);
524	push(AccumulatorRegisterValue);
525	} else {
526	move(AccumulatorRegisterValue, registerForArg(0));
527	move(AccumulatorRegisterTag, registerForArg(1));
528	}
529	callHelper(toInt32Helper);
530	saveReturnValueInAccumulator();
531	if (ArgInRegCount < 2)
532	addPtr(TrustedImm32(4 * PointerSize), StackPointerRegister);
533	popAligned(lhsTarget);
534
535	rhsIsInt.link(this);
536	}
537
538	void toInt32()
539	{
540	urshift32(AccumulatorRegisterTag, TrustedImm32(Value::QuickType_Shift - 32), ScratchRegister);
541	auto isInt = branch32(Equal, TrustedImm32(Value::QT_Int), ScratchRegister);
542
543	if (ArgInRegCount < 2) {
544	subPtr(TrustedImm32(2 * PointerSize), StackPointerRegister); // align the stack on a 16-byte boundary
545	push(AccumulatorRegisterTag);
546	push(AccumulatorRegisterValue);
547	} else {
548	move(AccumulatorRegisterValue, registerForArg(0));
549	move(AccumulatorRegisterTag, registerForArg(1));
550	}
551	callHelper(toInt32Helper);
552	saveReturnValueInAccumulator();
553	if (ArgInRegCount < 2)
554	addPtr(TrustedImm32(4 * PointerSize), StackPointerRegister);
555
556	isInt.link(this);
557	}
558
559	void regToInt32(Address srcReg, RegisterID targetReg)
560	{
561	bool accumulatorNeedsSaving = AccumulatorRegisterValue == ReturnValueRegisterValue
562	|| AccumulatorRegisterTag == ReturnValueRegisterTag;
563	if (accumulatorNeedsSaving) {
564	push(AccumulatorRegisterTag);
565	push(AccumulatorRegisterValue);
566	}
567	if (ArgInRegCount < 2) {
568	if (!accumulatorNeedsSaving)
569	subPtr(TrustedImm32(2 * PointerSize), StackPointerRegister);
570	srcReg.offset += 4;
571	load32(srcReg, targetReg);
572	push(targetReg);
573	srcReg.offset -= 4;
574	load32(srcReg, targetReg);
575	push(targetReg);
576	} else {
577	if (accumulatorNeedsSaving)
578	subPtr(TrustedImm32(2 * PointerSize), StackPointerRegister);
579	load32(srcReg, registerForArg(0));
580	srcReg.offset += 4;
581	load32(srcReg, registerForArg(1));
582	}
583	callHelper(toInt32Helper);
584	move(ReturnValueRegisterValue, targetReg);
585	if (accumulatorNeedsSaving) {
586	addPtr(TrustedImm32(2 * PointerSize), StackPointerRegister);
587	pop(AccumulatorRegisterValue);
588	pop(AccumulatorRegisterTag);
589	} else if (ArgInRegCount < 2) {
590	addPtr(TrustedImm32(4 * PointerSize), StackPointerRegister);
591	}
592	}
593
594	void isNullOrUndefined()
595	{
596	Jump notUndefOrPtr = branch32(NotEqual, TrustedImm32(0), AccumulatorRegisterTag);
597	compare32(Equal, AccumulatorRegisterValue, TrustedImm32(0), AccumulatorRegisterValue);
598	auto done = jump();
599
600	// not undefined or managed
601	notUndefOrPtr.link(this);
602	compare32(Equal, AccumulatorRegisterTag, TrustedImm32(int(QV4::Value::ValueTypeInternal::Null)),
603	AccumulatorRegisterValue);
604
605	done.link(this);
606	}
607
608	Jump isIntOrBool()
609	{
610	urshift32(AccumulatorRegisterTag, TrustedImm32(Value::IsIntegerOrBool_Shift - 32), ScratchRegister);
611	return branch32(Equal, TrustedImm32(Value::IsIntegerOrBool_Value), ScratchRegister);
612	}
613
614	void pushValue(ReturnedValue v)
615	{
616	push(TrustedImm32(v >> 32));
617	push(TrustedImm32(v));
618	}
619
620	void jumpNotUndefined(int offset)
621	{
622	move(AccumulatorRegisterTag, ScratchRegister);
623	or32(AccumulatorRegisterValue, ScratchRegister);
624	auto jump = branch32(NotEqual, ScratchRegister, TrustedImm32(0));
625	addJumpToOffset(jump, offset);
626	}
627
628	Jump jumpEmpty()
629	{
630	return branch32(Equal, AccumulatorRegisterTag, TrustedImm32(Value::emptyValue().asReturnedValue() >> 32));
631	}
632
633	Jump jumpNotEmpty()
634	{
635	return branch32(NotEqual, AccumulatorRegisterTag, TrustedImm32(Value::emptyValue().asReturnedValue() >> 32));
636	}
637
638	void toBoolean(std::function<void(RegisterID)> continuation)
639	{
640	urshift32(AccumulatorRegisterTag, TrustedImm32(Value::IsIntegerConvertible_Shift - 32),
641	ScratchRegister);
642	auto needsConversion = branch32(
643	NotEqual, TrustedImm32(Value::IsIntegerConvertible_Value), ScratchRegister);
644	continuation(AccumulatorRegisterValue);
645	Jump done = jump();
646
647	// slow path:
648	needsConversion.link(this);
649
650	bool accumulatorNeedsSaving = AccumulatorRegisterValue == ReturnValueRegisterValue
651	|| AccumulatorRegisterTag == ReturnValueRegisterTag;
652	if (accumulatorNeedsSaving) {
653	push(AccumulatorRegisterTag);
654	push(AccumulatorRegisterValue);
655	}
656
657	if (ArgInRegCount < 2) {
658	if (!accumulatorNeedsSaving)
659	subPtr(TrustedImm32(2 * PointerSize), StackPointerRegister);
660	push(AccumulatorRegisterTag);
661	push(AccumulatorRegisterValue);
662	} else {
663	if (accumulatorNeedsSaving)
664	subPtr(TrustedImm32(2 * PointerSize), StackPointerRegister);
665	move(AccumulatorRegisterValue, registerForArg(0));
666	move(AccumulatorRegisterTag, registerForArg(1));
667	}
668	callHelper(Value::toBooleanImpl);
669	and32(TrustedImm32(1), ReturnValueRegisterValue, ScratchRegister);
670	if (accumulatorNeedsSaving) {
671	addPtr(TrustedImm32(2 * PointerSize), StackPointerRegister);
672	pop(AccumulatorRegisterValue);
673	pop(AccumulatorRegisterTag);
674	} else if (ArgInRegCount < 2) {
675	addPtr(TrustedImm32(4 * PointerSize), StackPointerRegister);
676	}
677	continuation(ScratchRegister);
678
679	done.link(this);
680	}
681
682	void jumpStrictEqualStackSlotInt(int lhs, int rhs, int offset)
683	{
684	Address lhsAddr(JSStackFrameRegister, lhs * int(sizeof(Value)));
685	load32(lhsAddr, ScratchRegister);
686	Jump notEqInt = branch32(NotEqual, ScratchRegister, TrustedImm32(rhs));
687	Jump notEqUndefVal = branch32(NotEqual, ScratchRegister, TrustedImm32(0));
688	addJumpToOffset(notEqUndefVal, offset);
689	lhsAddr.offset += 4;
690	load32(lhsAddr, ScratchRegister);
691	Jump notEqUndefTag = branch32(NotEqual, ScratchRegister, TrustedImm32(0));
692	addJumpToOffset(notEqUndefTag, offset);
693	notEqInt.link(this);
694	}
695
696	void jumpStrictNotEqualStackSlotInt(int lhs, int rhs, int offset)
697	{
698	Address lhsAddr(JSStackFrameRegister, lhs * int(sizeof(Value)));
699	load32(lhsAddr, ScratchRegister);
700	Jump notEqual = branch32(NotEqual, TrustedImm32(rhs), ScratchRegister);
701	addJumpToOffset(notEqual, offset);
702	Jump notUndefValue = branch32(NotEqual, TrustedImm32(0), ScratchRegister);
703	lhsAddr.offset += 4;
704	load32(lhsAddr, ScratchRegister);
705	Jump equalUndef = branch32(Equal, TrustedImm32(0), ScratchRegister);
706	addJumpToOffset(equalUndef, offset);
707	notUndefValue.link(this);
708	}
709
710	void setAccumulatorTag(QV4::Value::ValueTypeInternal tag, RegisterID sourceReg = NoRegister)
711	{
712	if (sourceReg != NoRegister)
713	move(sourceReg, AccumulatorRegisterValue);
714	move(TrustedImm32(int(tag)), AccumulatorRegisterTag);
715	}
716
717	void encodeDoubleIntoAccumulator(FPRegisterID src)
718	{
719	moveDoubleToInts(src, AccumulatorRegisterValue, AccumulatorRegisterTag);
720	xor32(TrustedImm32(Value::EncodeMask >> 32), AccumulatorRegisterTag);
721	}
722
723	void pushValueAligned(ReturnedValue v)
724	{
725	pushValue(v);
726	}
727
728	void popValueAligned()
729	{
730	popValue();
731	}
732
733	Jump binopBothIntPath(Address lhsAddr, std::function<Jump(void)> fastPath)
734	{
735	Jump accNotInt = branch32(NotEqual, TrustedImm32(int(IntegerTag)), AccumulatorRegisterTag);
736	Address lhsAddrTag = lhsAddr; lhsAddrTag.offset += Value::tagOffset();
737	load32(lhsAddrTag, ScratchRegister);
738	Jump lhsNotInt = branch32(NotEqual, TrustedImm32(int(IntegerTag)), ScratchRegister);
739
740	// both integer
741	Address lhsAddrValue = lhsAddr; lhsAddrValue.offset += Value::valueOffset();
742	load32(lhsAddrValue, ScratchRegister);
743	Jump failure = fastPath();
744	Jump done = jump();
745
746	// all other cases
747	if (failure.isSet())
748	failure.link(this);
749	accNotInt.link(this);
750	lhsNotInt.link(this);
751
752	return done;
753	}
754
755	Jump unopIntPath(std::function<Jump(void)> fastPath)
756	{
757	Jump accNotInt = branch32(NotEqual, TrustedImm32(int(IntegerTag)), AccumulatorRegisterTag);
758
759	// both integer
760	Jump failure = fastPath();
761	Jump done = jump();
762
763	// all other cases
764	if (failure.isSet())
765	failure.link(this);
766	accNotInt.link(this);
767
768	return done;
769	}
770
771	void callWithAccumulatorByValueAsFirstArgument(std::function<void()> doCall)
772	{
773	if (ArgInRegCount < 2) {
774	subPtr(TrustedImm32(2 * PointerSize), StackPointerRegister);
775	push(AccumulatorRegisterTag);
776	push(AccumulatorRegisterValue);
777	} else {
778	move(AccumulatorRegisterValue, registerForArg(0));
779	move(AccumulatorRegisterTag, registerForArg(1));
780	}
781	doCall();
782	if (ArgInRegCount < 2)
783	addPtr(TrustedImm32(4 * PointerSize), StackPointerRegister);
784	}
785	};
786
787	typedef PlatformAssembler32 PlatformAssembler;
788	#endif
789
790	#define pasm() reinterpret_cast<PlatformAssembler *>(this->d)
791
792	typedef PlatformAssembler::TrustedImmPtr TrustedImmPtr;
793	typedef PlatformAssembler::TrustedImm32 TrustedImm32;
794	typedef PlatformAssembler::TrustedImm64 TrustedImm64;
795	typedef PlatformAssembler::Address Address;
796	typedef PlatformAssembler::RegisterID RegisterID;
797	typedef PlatformAssembler::FPRegisterID FPRegisterID;
798
799	static Address regAddr(int reg)
800	{
801	return Address(PlatformAssembler::JSStackFrameRegister, reg * int(sizeof(QV4::Value)));
802	}
803
804	BaselineAssembler::BaselineAssembler(const Value *constantTable)
805	: d(new PlatformAssembler(constantTable))
806	{
807	}
808
809	BaselineAssembler::~BaselineAssembler()
810	{
811	delete pasm();
812	}
813
814	void BaselineAssembler::generatePrologue()
815	{
816	pasm()->generateFunctionEntry();
817	}
818
819	void BaselineAssembler::generateEpilogue()
820	{
821	pasm()->generateCatchTrampoline();
822	}
823
824	void BaselineAssembler::link(Function *function)
825	{
826	pasm()->link(function, jitKind: "BaselineJIT");
827	}
828
829	void BaselineAssembler::addLabel(int offset)
830	{
831	pasm()->addLabelForOffset(offset);
832	}
833
834	void BaselineAssembler::loadConst(int constIndex)
835	{
836	//###
837	if (pasm()->constant(idx: constIndex).isUndefined()) {
838	pasm()->loadUndefined();
839	} else {
840	pasm()->loadAccumulator(pasm()->loadConstAddress(constIndex));
841	}
842	}
843
844	void BaselineAssembler::copyConst(int constIndex, int destReg)
845	{
846	pasm()->copyConst(constIndex, dest: regAddr(reg: destReg));
847	}
848
849	void BaselineAssembler::loadReg(int reg)
850	{
851	pasm()->loadAccumulator(addr: regAddr(reg));
852	}
853
854	void JIT::BaselineAssembler::moveReg(int sourceReg, int destReg)
855	{
856	pasm()->moveReg(sourceRegAddress: regAddr(reg: sourceReg), destRegAddress: regAddr(reg: destReg));
857	}
858
859	void BaselineAssembler::storeReg(int reg)
860	{
861	pasm()->storeAccumulator(addr: regAddr(reg));
862	}
863
864	void BaselineAssembler::loadLocal(int index, int level)
865	{
866	Heap::CallContext ctx;
867	Q_UNUSED(ctx);
868	pasm()->loadPointerFromValue(addr: regAddr(reg: CallData::Context), dest: PlatformAssembler::ScratchRegister);
869	while (level) {
870	pasm()->loadPtr(address: Address(PlatformAssembler::ScratchRegister, ctx.outer.offset), dest: PlatformAssembler::ScratchRegister);
871	--level;
872	}
873	pasm()->loadAccumulator(addr: Address(PlatformAssembler::ScratchRegister, ctx.locals.offset + offsetof(ValueArray<0>, values) + sizeof(Value)*index));
874	}
875
876	void BaselineAssembler::storeLocal(int index, int level)
877	{
878	Heap::CallContext ctx;
879	Q_UNUSED(ctx);
880	pasm()->loadPtr(address: regAddr(reg: CallData::Context), dest: PlatformAssembler::ScratchRegister);
881	while (level) {
882	pasm()->loadPtr(address: Address(PlatformAssembler::ScratchRegister, ctx.outer.offset), dest: PlatformAssembler::ScratchRegister);
883	--level;
884	}
885	pasm()->storeAccumulator(addr: Address(PlatformAssembler::ScratchRegister, ctx.locals.offset + offsetof(ValueArray<0>, values) + sizeof(Value)*index));
886	// check if we need a write barrier
887	auto skipBarrier = pasm()->branch8(
888	cond: PlatformAssembler::Equal,
889	left: PlatformAssembler::Address(PlatformAssembler::EngineRegister,
890	offsetof(EngineBase, isGCOngoing)),
891	right: TrustedImm32(0));
892	saveAccumulatorInFrame();
893	// if so, do a runtime call
894	pasm()->prepareCallWithArgCount(argc: 1);
895	pasm()->passAccumulatorAsArg(arg: 0);
896	pasm()->callRuntime(funcPtr: (void*)Runtime::MarkCustom::call, dest: CallResultDestination::Ignore);
897	loadAccumulatorFromFrame();
898	skipBarrier.link(pasm());
899
900	}
901
902	void BaselineAssembler::loadString(int stringId)
903	{
904	pasm()->loadString(stringId);
905	}
906
907	void BaselineAssembler::loadValue(ReturnedValue value)
908	{
909	pasm()->loadValue(value);
910	}
911
912	void BaselineAssembler::storeHeapObject(int reg)
913	{
914	pasm()->storeHeapObject(source: PlatformAssembler::ReturnValueRegisterValue, addr: regAddr(reg));
915	}
916
917	void BaselineAssembler::loadImport(int index)
918	{
919	Address addr = pasm()->loadCompilationUnitPtr(target: PlatformAssembler::ScratchRegister);
920	addr.offset = offsetof(QV4::CompilationUnitRuntimeData, imports);
921	pasm()->loadPtr(address: addr, dest: PlatformAssembler::ScratchRegister);
922	addr.offset = index * int(sizeof(QV4::Value*));
923	pasm()->loadPtr(address: addr, dest: PlatformAssembler::ScratchRegister);
924	pasm()->loadAccumulator(addr: Address(PlatformAssembler::ScratchRegister));
925	}
926
927	void BaselineAssembler::toNumber()
928	{
929	pasm()->toNumber();
930	}
931
932	void BaselineAssembler::uminus()
933	{
934	saveAccumulatorInFrame();
935	pasm()->prepareCallWithArgCount(argc: 1);
936	pasm()->passAccumulatorAsArg(arg: 0);
937	ASM_GENERATE_RUNTIME_CALL(UMinus, CallResultDestination::InAccumulator);
938	checkException();
939	}
940
941	void BaselineAssembler::ucompl()
942	{
943	pasm()->toInt32();
944	pasm()->xor32(imm: TrustedImm32(-1), dest: PlatformAssembler::AccumulatorRegisterValue);
945	pasm()->setAccumulatorTag(tag: IntegerTag);
946	}
947
948	static ReturnedValue incHelper(const Value v)
949	{
950	double d;
951	if (Q_LIKELY(v.isDouble()))
952	d = v.doubleValue();
953	else
954	d = v.toNumberImpl();
955	return Encode(d + 1.);
956	}
957
958	void BaselineAssembler::inc()
959	{
960	auto done = pasm()->unopIntPath(fastPath: [this](){
961	auto overflowed = pasm()->branchAdd32(cond: PlatformAssembler::Overflow,
962	src: PlatformAssembler::AccumulatorRegisterValue,
963	imm: TrustedImm32(1),
964	dest: PlatformAssembler::ScratchRegister);
965	pasm()->setAccumulatorTag(tag: IntegerTag, sourceReg: PlatformAssembler::ScratchRegister);
966	return overflowed;
967	});
968
969	// slow path:
970	pasm()->callWithAccumulatorByValueAsFirstArgument(doCall: [this]() {
971	pasm()->callHelper(incHelper);
972	pasm()->saveReturnValueInAccumulator();
973	});
974	checkException();
975
976	// done.
977	done.link(pasm());
978	}
979
980	static ReturnedValue decHelper(const Value v)
981	{
982	double d;
983	if (Q_LIKELY(v.isDouble()))
984	d = v.doubleValue();
985	else
986	d = v.toNumberImpl();
987	return Encode(d - 1.);
988	}
989
990	void BaselineAssembler::dec()
991	{
992	auto done = pasm()->unopIntPath(fastPath: [this](){
993	auto overflowed = pasm()->branchSub32(cond: PlatformAssembler::Overflow,
994	src1: PlatformAssembler::AccumulatorRegisterValue,
995	src2: TrustedImm32(1),
996	dest: PlatformAssembler::ScratchRegister);
997	pasm()->setAccumulatorTag(tag: IntegerTag, sourceReg: PlatformAssembler::ScratchRegister);
998	return overflowed;
999	});
1000
1001	// slow path:
1002	pasm()->callWithAccumulatorByValueAsFirstArgument(doCall: [this]() {
1003	pasm()->callHelper(decHelper);
1004	pasm()->saveReturnValueInAccumulator();
1005	});
1006	checkException();
1007
1008	// done.
1009	done.link(pasm());
1010	}
1011
1012	void BaselineAssembler::unot()
1013	{
1014	pasm()->toBoolean(continuation: [this](PlatformAssembler::RegisterID resultReg){
1015	pasm()->compare32(cond: PlatformAssembler::Equal, left: resultReg,
1016	right: TrustedImm32(0), dest: PlatformAssembler::AccumulatorRegisterValue);
1017	pasm()->setAccumulatorTag(tag: QV4::Value::ValueTypeInternal::Boolean);
1018	});
1019	}
1020
1021	void BaselineAssembler::add(int lhs)
1022	{
1023	auto done = pasm()->binopBothIntPath(lhsAddr: regAddr(reg: lhs), fastPath: [this](){
1024	auto overflowed = pasm()->branchAdd32(cond: PlatformAssembler::Overflow,
1025	src: PlatformAssembler::AccumulatorRegisterValue,
1026	dest: PlatformAssembler::ScratchRegister);
1027	pasm()->setAccumulatorTag(tag: IntegerTag,
1028	sourceReg: PlatformAssembler::ScratchRegister);
1029	return overflowed;
1030	});
1031
1032	// slow path:
1033	saveAccumulatorInFrame();
1034	pasm()->prepareCallWithArgCount(argc: 3);
1035	pasm()->passAccumulatorAsArg(arg: 2);
1036	pasm()->passJSSlotAsArg(reg: lhs, arg: 1);
1037	pasm()->passEngineAsArg(arg: 0);
1038	ASM_GENERATE_RUNTIME_CALL(Add, CallResultDestination::InAccumulator);
1039	checkException();
1040
1041	// done.
1042	done.link(pasm());
1043	}
1044
1045	void BaselineAssembler::bitAnd(int lhs)
1046	{
1047	PlatformAssembler::Address lhsAddr = regAddr(reg: lhs);
1048	pasm()->toInt32LhsAcc(lhs: lhsAddr, lhsTarget: PlatformAssembler::ScratchRegister);
1049	pasm()->and32(src: PlatformAssembler::ScratchRegister, dest: PlatformAssembler::AccumulatorRegisterValue);
1050	pasm()->setAccumulatorTag(tag: IntegerTag);
1051	}
1052
1053	void BaselineAssembler::bitOr(int lhs)
1054	{
1055	PlatformAssembler::Address lhsAddr = regAddr(reg: lhs);
1056	pasm()->toInt32LhsAcc(lhs: lhsAddr, lhsTarget: PlatformAssembler::ScratchRegister);
1057	pasm()->or32(src: PlatformAssembler::ScratchRegister, dest: PlatformAssembler::AccumulatorRegisterValue);
1058	pasm()->setAccumulatorTag(tag: IntegerTag);
1059	}
1060
1061	void BaselineAssembler::bitXor(int lhs)
1062	{
1063	PlatformAssembler::Address lhsAddr = regAddr(reg: lhs);
1064	pasm()->toInt32LhsAcc(lhs: lhsAddr, lhsTarget: PlatformAssembler::ScratchRegister);
1065	pasm()->xor32(src: PlatformAssembler::ScratchRegister, dest: PlatformAssembler::AccumulatorRegisterValue);
1066	pasm()->setAccumulatorTag(tag: IntegerTag);
1067	}
1068
1069	void BaselineAssembler::ushr(int lhs)
1070	{
1071	PlatformAssembler::Address lhsAddr = regAddr(reg: lhs);
1072	pasm()->toInt32LhsAcc(lhs: lhsAddr, lhsTarget: PlatformAssembler::ScratchRegister);
1073	pasm()->and32(imm: TrustedImm32(0x1f), dest: PlatformAssembler::AccumulatorRegisterValue);
1074	pasm()->urshift32(shift_amount: PlatformAssembler::AccumulatorRegisterValue, dest: PlatformAssembler::ScratchRegister);
1075	pasm()->move(src: PlatformAssembler::ScratchRegister, dest: PlatformAssembler::AccumulatorRegisterValue);
1076	auto doubleEncode = pasm()->branch32(cond: PlatformAssembler::LessThan,
1077	left: PlatformAssembler::AccumulatorRegisterValue,
1078	right: TrustedImm32(0));
1079	pasm()->setAccumulatorTag(tag: IntegerTag);
1080	auto done = pasm()->jump();
1081
1082	doubleEncode.link(pasm());
1083	pasm()->convertUInt32ToDouble(src: PlatformAssembler::AccumulatorRegisterValue,
1084	dest: PlatformAssembler::FPScratchRegister,
1085	PlatformAssembler::ScratchRegister);
1086	pasm()->encodeDoubleIntoAccumulator(src: PlatformAssembler::FPScratchRegister);
1087	done.link(pasm());
1088	}
1089
1090	void BaselineAssembler::shr(int lhs)
1091	{
1092	PlatformAssembler::Address lhsAddr = regAddr(reg: lhs);
1093	pasm()->toInt32LhsAcc(lhs: lhsAddr, lhsTarget: PlatformAssembler::ScratchRegister);
1094	pasm()->and32(imm: TrustedImm32(0x1f), dest: PlatformAssembler::AccumulatorRegisterValue);
1095	pasm()->rshift32(shift_amount: PlatformAssembler::AccumulatorRegisterValue, dest: PlatformAssembler::ScratchRegister);
1096	pasm()->move(src: PlatformAssembler::ScratchRegister, dest: PlatformAssembler::AccumulatorRegisterValue);
1097	pasm()->setAccumulatorTag(tag: IntegerTag);
1098	}
1099
1100	void BaselineAssembler::shl(int lhs)
1101	{
1102	PlatformAssembler::Address lhsAddr = regAddr(reg: lhs);
1103	pasm()->toInt32LhsAcc(lhs: lhsAddr, lhsTarget: PlatformAssembler::ScratchRegister);
1104	pasm()->and32(imm: TrustedImm32(0x1f), dest: PlatformAssembler::AccumulatorRegisterValue);
1105	pasm()->lshift32(shift_amount: PlatformAssembler::AccumulatorRegisterValue, dest: PlatformAssembler::ScratchRegister);
1106	pasm()->move(src: PlatformAssembler::ScratchRegister, dest: PlatformAssembler::AccumulatorRegisterValue);
1107	pasm()->setAccumulatorTag(tag: IntegerTag);
1108	}
1109
1110	void BaselineAssembler::bitAndConst(int rhs)
1111	{
1112	pasm()->toInt32();
1113	pasm()->and32(imm: TrustedImm32(rhs), dest: PlatformAssembler::AccumulatorRegisterValue);
1114	pasm()->setAccumulatorTag(tag: IntegerTag);
1115	}
1116
1117	void BaselineAssembler::bitOrConst(int rhs)
1118	{
1119	pasm()->toInt32();
1120	pasm()->or32(imm: TrustedImm32(rhs), dest: PlatformAssembler::AccumulatorRegisterValue);
1121	pasm()->setAccumulatorTag(tag: IntegerTag);
1122	}
1123
1124	void BaselineAssembler::bitXorConst(int rhs)
1125	{
1126	pasm()->toInt32();
1127	pasm()->xor32(imm: TrustedImm32(rhs), dest: PlatformAssembler::AccumulatorRegisterValue);
1128	pasm()->setAccumulatorTag(tag: IntegerTag);
1129	}
1130
1131	void BaselineAssembler::ushrConst(int rhs)
1132	{
1133	rhs &= 0x1f;
1134	pasm()->toInt32();
1135	if (rhs) {
1136	// a non zero shift will always give a number encodable as an int
1137	pasm()->urshift32(imm: TrustedImm32(rhs), dest: PlatformAssembler::AccumulatorRegisterValue);
1138	pasm()->setAccumulatorTag(tag: IntegerTag);
1139	} else {
1140	// shift with 0 can lead to a negative result
1141	auto doubleEncode = pasm()->branch32(cond: PlatformAssembler::LessThan,
1142	left: PlatformAssembler::AccumulatorRegisterValue,
1143	right: TrustedImm32(0));
1144	pasm()->setAccumulatorTag(tag: IntegerTag);
1145	auto done = pasm()->jump();
1146
1147	doubleEncode.link(pasm());
1148	pasm()->convertUInt32ToDouble(src: PlatformAssembler::AccumulatorRegisterValue,
1149	dest: PlatformAssembler::FPScratchRegister,
1150	PlatformAssembler::ScratchRegister);
1151	pasm()->encodeDoubleIntoAccumulator(src: PlatformAssembler::FPScratchRegister);
1152	done.link(pasm());
1153	}
1154	}
1155
1156	void BaselineAssembler::shrConst(int rhs)
1157	{
1158	rhs &= 0x1f;
1159	pasm()->toInt32();
1160	if (rhs)
1161	pasm()->rshift32(imm: TrustedImm32(rhs), dest: PlatformAssembler::AccumulatorRegisterValue);
1162	pasm()->setAccumulatorTag(tag: IntegerTag);
1163	}
1164
1165	void BaselineAssembler::shlConst(int rhs)
1166	{
1167	rhs &= 0x1f;
1168	pasm()->toInt32();
1169	if (rhs)
1170	pasm()->lshift32(imm: TrustedImm32(rhs), dest: PlatformAssembler::AccumulatorRegisterValue);
1171	pasm()->setAccumulatorTag(tag: IntegerTag);
1172	}
1173
1174	void BaselineAssembler::mul(int lhs)
1175	{
1176	auto done = pasm()->binopBothIntPath(lhsAddr: regAddr(reg: lhs), fastPath: [this](){
1177	auto overflowed = pasm()->branchMul32(cond: PlatformAssembler::Overflow,
1178	src: PlatformAssembler::AccumulatorRegisterValue,
1179	dest: PlatformAssembler::ScratchRegister);
1180	pasm()->setAccumulatorTag(tag: IntegerTag,
1181	sourceReg: PlatformAssembler::ScratchRegister);
1182	return overflowed;
1183	});
1184
1185	// slow path:
1186	saveAccumulatorInFrame();
1187	pasm()->prepareCallWithArgCount(argc: 2);
1188	pasm()->passAccumulatorAsArg(arg: 1);
1189	pasm()->passJSSlotAsArg(reg: lhs, arg: 0);
1190	ASM_GENERATE_RUNTIME_CALL(Mul, CallResultDestination::InAccumulator);
1191	checkException();
1192
1193	// done.
1194	done.link(pasm());
1195	}
1196
1197	void BaselineAssembler::div(int lhs)
1198	{
1199	saveAccumulatorInFrame();
1200	pasm()->prepareCallWithArgCount(argc: 2);
1201	pasm()->passAccumulatorAsArg(arg: 1);
1202	pasm()->passJSSlotAsArg(reg: lhs, arg: 0);
1203	ASM_GENERATE_RUNTIME_CALL(Div, CallResultDestination::InAccumulator);
1204	checkException();
1205	}
1206
1207	void BaselineAssembler::mod(int lhs)
1208	{
1209	saveAccumulatorInFrame();
1210	pasm()->prepareCallWithArgCount(argc: 2);
1211	pasm()->passAccumulatorAsArg(arg: 1);
1212	pasm()->passJSSlotAsArg(reg: lhs, arg: 0);
1213	ASM_GENERATE_RUNTIME_CALL(Mod, CallResultDestination::InAccumulator);
1214	checkException();
1215	}
1216
1217	void BaselineAssembler::sub(int lhs)
1218	{
1219	auto done = pasm()->binopBothIntPath(lhsAddr: regAddr(reg: lhs), fastPath: [this](){
1220	auto overflowed = pasm()->branchSub32(cond: PlatformAssembler::Overflow,
1221	src: PlatformAssembler::AccumulatorRegisterValue,
1222	dest: PlatformAssembler::ScratchRegister);
1223	pasm()->setAccumulatorTag(tag: IntegerTag,
1224	sourceReg: PlatformAssembler::ScratchRegister);
1225	return overflowed;
1226	});
1227
1228	// slow path:
1229	saveAccumulatorInFrame();
1230	pasm()->prepareCallWithArgCount(argc: 2);
1231	pasm()->passAccumulatorAsArg(arg: 1);
1232	pasm()->passJSSlotAsArg(reg: lhs, arg: 0);
1233	ASM_GENERATE_RUNTIME_CALL(Sub, CallResultDestination::InAccumulator);
1234	checkException();
1235
1236	// done.
1237	done.link(pasm());
1238	}
1239
1240	void BaselineAssembler::cmpeqNull()
1241	{
1242	pasm()->isNullOrUndefined();
1243	pasm()->setAccumulatorTag(tag: QV4::Value::ValueTypeInternal::Boolean);
1244	}
1245
1246	void BaselineAssembler::cmpneNull()
1247	{
1248	pasm()->isNullOrUndefined();
1249	pasm()->xor32(imm: TrustedImm32(1), dest: PlatformAssembler::AccumulatorRegisterValue);
1250	pasm()->setAccumulatorTag(tag: QV4::Value::ValueTypeInternal::Boolean);
1251	}
1252
1253	void BaselineAssembler::cmpeqInt(int lhs)
1254	{
1255	auto isIntOrBool = pasm()->isIntOrBool();
1256	saveAccumulatorInFrame();
1257	pasm()->pushValueAligned(v: Encode(lhs));
1258	if (PlatformAssembler::ArgInRegCount < 2)
1259	pasm()->push(src: PlatformAssembler::StackPointerRegister);
1260	else
1261	pasm()->move(src: PlatformAssembler::StackPointerRegister, pasm()->registerForArg(arg: 1));
1262	pasm()->pushAccumulatorAsArg(arg: 0);
1263	pasm()->callRuntimeUnchecked(funcPtr: (void*)Runtime::Equal::call);
1264	pasm()->saveReturnValueInAccumulator();
1265	if (PlatformAssembler::ArgInRegCount < 2)
1266	pasm()->addPtr(imm: TrustedImm32(2 * PlatformAssembler::PointerSize), srcDest: PlatformAssembler::StackPointerRegister);
1267	pasm()->popValueAligned();
1268	auto done = pasm()->jump();
1269	isIntOrBool.link(pasm());
1270	pasm()->compare32(cond: PlatformAssembler::Equal, left: PlatformAssembler::AccumulatorRegisterValue,
1271	right: TrustedImm32(lhs),
1272	dest: PlatformAssembler::AccumulatorRegisterValue);
1273	pasm()->setAccumulatorTag(tag: QV4::Value::ValueTypeInternal::Boolean);
1274	done.link(pasm());
1275	}
1276
1277	void BaselineAssembler::cmpneInt(int lhs)
1278	{
1279	auto isIntOrBool = pasm()->isIntOrBool();
1280	saveAccumulatorInFrame();
1281	pasm()->pushValueAligned(v: Encode(lhs));
1282	if (PlatformAssembler::ArgInRegCount < 2)
1283	pasm()->push(src: PlatformAssembler::StackPointerRegister);
1284	else
1285	pasm()->move(src: PlatformAssembler::StackPointerRegister, pasm()->registerForArg(arg: 1));
1286	pasm()->pushAccumulatorAsArg(arg: 0);
1287	pasm()->callRuntimeUnchecked(funcPtr: (void*)Runtime::NotEqual::call);
1288	pasm()->saveReturnValueInAccumulator();
1289	if (PlatformAssembler::ArgInRegCount < 2)
1290	pasm()->addPtr(imm: TrustedImm32(2 * PlatformAssembler::PointerSize), srcDest: PlatformAssembler::StackPointerRegister);
1291	pasm()->popValueAligned();
1292	auto done = pasm()->jump();
1293	isIntOrBool.link(pasm());
1294	pasm()->compare32(cond: PlatformAssembler::NotEqual, left: PlatformAssembler::AccumulatorRegisterValue,
1295	right: TrustedImm32(lhs),
1296	dest: PlatformAssembler::AccumulatorRegisterValue);
1297	pasm()->setAccumulatorTag(tag: QV4::Value::ValueTypeInternal::Boolean);
1298	done.link(pasm());
1299	}
1300
1301	void BaselineAssembler::cmp(int cond, CmpFunc function, int lhs)
1302	{
1303	auto c = static_cast<PlatformAssembler::RelationalCondition>(cond);
1304	auto done = pasm()->binopBothIntPath(lhsAddr: regAddr(reg: lhs), fastPath: [this, c](){
1305	pasm()->compare32(cond: c, left: PlatformAssembler::ScratchRegister,
1306	right: PlatformAssembler::AccumulatorRegisterValue,
1307	dest: PlatformAssembler::AccumulatorRegisterValue);
1308	return PlatformAssembler::Jump();
1309	});
1310
1311	// slow path:
1312	saveAccumulatorInFrame();
1313	pasm()->prepareCallWithArgCount(argc: 2);
1314	pasm()->passAccumulatorAsArg(arg: 1);
1315	pasm()->passJSSlotAsArg(reg: lhs, arg: 0);
1316
1317	callRuntime(funcPtr: reinterpret_cast<void*>(function), dest: CallResultDestination::InAccumulator);
1318	checkException();
1319
1320	// done.
1321	done.link(pasm());
1322	pasm()->setAccumulatorTag(tag: QV4::Value::ValueTypeInternal::Boolean);
1323	}
1324
1325	void BaselineAssembler::cmpeq(int lhs)
1326	{
1327	cmp(cond: PlatformAssembler::Equal, function: &Runtime::CompareEqual::call, lhs);
1328	}
1329
1330	void BaselineAssembler::cmpne(int lhs)
1331	{
1332	cmp(cond: PlatformAssembler::NotEqual, function: &Runtime::CompareNotEqual::call, lhs);
1333	}
1334
1335	void BaselineAssembler::cmpgt(int lhs)
1336	{
1337	cmp(cond: PlatformAssembler::GreaterThan, function: &Runtime::CompareGreaterThan::call, lhs);
1338	}
1339
1340	void BaselineAssembler::cmpge(int lhs)
1341	{
1342	cmp(cond: PlatformAssembler::GreaterThanOrEqual, function: &Runtime::CompareGreaterEqual::call, lhs);
1343	}
1344
1345	void BaselineAssembler::cmplt(int lhs)
1346	{
1347	cmp(cond: PlatformAssembler::LessThan, function: &Runtime::CompareLessThan::call, lhs);
1348	}
1349
1350	void BaselineAssembler::cmple(int lhs)
1351	{
1352	cmp(cond: PlatformAssembler::LessThanOrEqual, function: &Runtime::CompareLessEqual::call, lhs);
1353	}
1354
1355	void BaselineAssembler::cmpStrictEqual(int lhs)
1356	{
1357	cmp(cond: PlatformAssembler::Equal, function: &Runtime::CompareStrictEqual::call, lhs);
1358	}
1359
1360	void BaselineAssembler::cmpStrictNotEqual(int lhs)
1361	{
1362	cmp(cond: PlatformAssembler::NotEqual, function: &Runtime::CompareStrictNotEqual::call, lhs);
1363	}
1364
1365	int BaselineAssembler::jump(int offset)
1366	{
1367	pasm()->addJumpToOffset(pasm()->jump(), offset);
1368	return offset;
1369	}
1370
1371	int BaselineAssembler::jumpTrue(int offset)
1372	{
1373	pasm()->toBoolean(continuation: [this, offset](PlatformAssembler::RegisterID resultReg) {
1374	auto jump = pasm()->branch32(cond: PlatformAssembler::NotEqual, left: TrustedImm32(0), right: resultReg);
1375	pasm()->addJumpToOffset(jump, offset);
1376	});
1377	return offset;
1378	}
1379
1380	int BaselineAssembler::jumpFalse(int offset)
1381	{
1382	pasm()->toBoolean(continuation: [this, offset](PlatformAssembler::RegisterID resultReg) {
1383	auto jump = pasm()->branch32(cond: PlatformAssembler::Equal, left: TrustedImm32(0), right: resultReg);
1384	pasm()->addJumpToOffset(jump, offset);
1385	});
1386	return offset;
1387	}
1388
1389	int BaselineAssembler::jumpNoException(int offset)
1390	{
1391	auto jump = pasm()->branch32(
1392	cond: PlatformAssembler::Equal,
1393	left: PlatformAssembler::Address(PlatformAssembler::EngineRegister,
1394	offsetof(EngineBase, hasException)),
1395	right: TrustedImm32(0));
1396	pasm()->addJumpToOffset(jump, offset);
1397	return offset;
1398	}
1399
1400	int BaselineAssembler::jumpNotUndefined(int offset)
1401	{
1402	pasm()->jumpNotUndefined(offset);
1403	return offset;
1404	}
1405
1406	int BaselineAssembler::jumpEqNull(int offset)
1407	{
1408	saveAccumulatorInFrame();
1409	cmpeqNull();
1410
1411	pasm()->toBoolean(continuation: [this, offset](PlatformAssembler::RegisterID resultReg) {
1412	auto isFalse = pasm()->branch32(cond: PlatformAssembler::Equal, left: TrustedImm32(0), right: resultReg);
1413	loadValue(value: Encode::undefined());
1414	pasm()->addJumpToOffset(pasm()->jump(), offset);
1415	isFalse.link(pasm());
1416	loadAccumulatorFromFrame();
1417	});
1418
1419	return offset;
1420	}
1421
1422
1423	void BaselineAssembler::prepareCallWithArgCount(int argc)
1424	{
1425	pasm()->prepareCallWithArgCount(argc);
1426	}
1427
1428	void BaselineAssembler::storeInstructionPointer(int instructionOffset)
1429	{
1430	pasm()->storeInstructionPointer(instructionOffset);
1431	}
1432
1433	void BaselineAssembler::passAccumulatorAsArg(int arg)
1434	{
1435	pasm()->passAccumulatorAsArg(arg);
1436	}
1437
1438	void BaselineAssembler::passFunctionAsArg(int arg)
1439	{
1440	pasm()->passFunctionAsArg(arg);
1441	}
1442
1443	void BaselineAssembler::passEngineAsArg(int arg)
1444	{
1445	pasm()->passEngineAsArg(arg);
1446	}
1447
1448	void BaselineAssembler::passJSSlotAsArg(int reg, int arg)
1449	{
1450	pasm()->passJSSlotAsArg(reg, arg);
1451	}
1452
1453	void BaselineAssembler::passCppFrameAsArg(int arg)
1454	{
1455	pasm()->passCppFrameAsArg(arg);
1456	}
1457
1458	void BaselineAssembler::passInt32AsArg(int value, int arg)
1459	{
1460	pasm()->passInt32AsArg(value, arg);
1461	}
1462
1463	void BaselineAssembler::passPointerAsArg(void *ptr, int arg)
1464	{
1465	pasm()->passPointerAsArg(ptr, arg);
1466	}
1467
1468	void BaselineAssembler::callRuntime(const void *funcPtr, CallResultDestination dest)
1469	{
1470	pasm()->callRuntime(funcPtr, dest);
1471	}
1472
1473	void BaselineAssembler::saveAccumulatorInFrame()
1474	{
1475	pasm()->storeAccumulator(addr: PlatformAssembler::Address(PlatformAssembler::JSStackFrameRegister,
1476	offsetof(CallData, accumulator)));
1477	}
1478
1479	void BaselineAssembler::loadAccumulatorFromFrame()
1480	{
1481	pasm()->loadAccumulator(addr: PlatformAssembler::Address(PlatformAssembler::JSStackFrameRegister,
1482	offsetof(CallData, accumulator)));
1483	}
1484
1485	static ReturnedValue TheJitIs__Tail_Calling__ToTheRuntimeSoTheJitFrameIsMissing(JSTypesStackFrame *frame, ExecutionEngine *engine)
1486	{
1487	return Runtime::TailCall::call(frame, engine);
1488	}
1489
1490	void BaselineAssembler::jsTailCall(int func, int thisObject, int argc, int argv)
1491	{
1492	Address tos = pasm()->jsAlloca(slotCount: 4);
1493
1494	int32_t argcOffset = tos.offset + int32_t(sizeof(Value)) * Runtime::StackOffsets::tailCall_argc;
1495	int32_t argvOffset = tos.offset + int32_t(sizeof(Value)) * Runtime::StackOffsets::tailCall_argv;
1496	int32_t thisOffset = tos.offset + int32_t(sizeof(Value)) * Runtime::StackOffsets::tailCall_thisObject;
1497	int32_t funcOffset = tos.offset + int32_t(sizeof(Value)) * Runtime::StackOffsets::tailCall_function;
1498
1499	pasm()->storeInt32AsValue(srcInt: argc, destAddr: Address(tos.base, argcOffset));
1500	pasm()->storeInt32AsValue(srcInt: argv, destAddr: Address(tos.base, argvOffset));
1501	pasm()->moveReg(sourceRegAddress: regAddr(reg: thisObject), destRegAddress: Address(tos.base, thisOffset));
1502	pasm()->moveReg(sourceRegAddress: regAddr(reg: func), destRegAddress: Address(tos.base, funcOffset));
1503	pasm()->tailCallRuntime(
1504	funcPtr: reinterpret_cast<void *>(TheJitIs__Tail_Calling__ToTheRuntimeSoTheJitFrameIsMissing),
1505	functionName: "TheJitIs__Tail_Calling__ToTheRuntimeSoTheJitFrameIsMissing");
1506	}
1507
1508	void BaselineAssembler::checkException()
1509	{
1510	pasm()->checkException();
1511	}
1512
1513	void BaselineAssembler::gotoCatchException()
1514	{
1515	pasm()->addCatchyJump(pasm()->jump());
1516	}
1517
1518	void BaselineAssembler::getException()
1519	{
1520	Q_STATIC_ASSERT(sizeof(QV4::EngineBase::hasException) == 1);
1521
1522	Address hasExceptionAddr(PlatformAssembler::EngineRegister,
1523	offsetof(EngineBase, hasException));
1524	PlatformAssembler::Jump nope = pasm()->branch8(cond: PlatformAssembler::Equal,
1525	left: hasExceptionAddr,
1526	right: TrustedImm32(0));
1527	pasm()->loadPtr(address: Address(PlatformAssembler::EngineRegister,
1528	offsetof(EngineBase, exceptionValue)),
1529	dest: PlatformAssembler::ScratchRegister);
1530	pasm()->loadAccumulator(addr: Address(PlatformAssembler::ScratchRegister));
1531	pasm()->store8(imm: TrustedImm32(0), address: hasExceptionAddr);
1532	auto done = pasm()->jump();
1533	nope.link(pasm());
1534	pasm()->loadValue(value: Value::emptyValue().asReturnedValue());
1535
1536	done.link(pasm());
1537	}
1538
1539	void BaselineAssembler::setException()
1540	{
1541	auto noException = pasm()->jumpEmpty();
1542	Address addr(PlatformAssembler::EngineRegister, offsetof(EngineBase, exceptionValue));
1543	pasm()->loadPtr(address: addr, dest: PlatformAssembler::ScratchRegister);
1544	pasm()->storeAccumulator(addr: Address(PlatformAssembler::ScratchRegister));
1545	addr.offset = offsetof(EngineBase, hasException);
1546	Q_STATIC_ASSERT(sizeof(QV4::EngineBase::hasException) == 1);
1547	pasm()->store8(imm: TrustedImm32(1), address: addr);
1548	noException.link(pasm());
1549	}
1550
1551	int BaselineAssembler::setUnwindHandler(int offset)
1552	{
1553	auto l = pasm()->storePtrWithPatch(initialValue: TrustedImmPtr(nullptr), pasm()->exceptionHandlerAddress());
1554	pasm()->addEHTarget(label: l, offset);
1555	return offset;
1556	}
1557
1558
1559	void BaselineAssembler::clearUnwindHandler()
1560	{
1561	pasm()->storePtr(imm: TrustedImmPtr(nullptr), pasm()->exceptionHandlerAddress());
1562	}
1563
1564	void JIT::BaselineAssembler::unwindDispatch()
1565	{
1566	checkException();
1567	pasm()->load32(address: Address(PlatformAssembler::CppStackFrameRegister, offsetof(JSTypesStackFrame, unwindLevel)), dest: PlatformAssembler::ScratchRegister);
1568	auto noUnwind = pasm()->branch32(cond: PlatformAssembler::Equal, left: PlatformAssembler::ScratchRegister, right: TrustedImm32(0));
1569	pasm()->sub32(imm: TrustedImm32(1), dest: PlatformAssembler::ScratchRegister);
1570	pasm()->store32(src: PlatformAssembler::ScratchRegister, address: Address(PlatformAssembler::CppStackFrameRegister, offsetof(JSTypesStackFrame, unwindLevel)));
1571	auto jump = pasm()->branch32(cond: PlatformAssembler::Equal, left: PlatformAssembler::ScratchRegister, right: TrustedImm32(0));
1572	gotoCatchException();
1573	jump.link(pasm());
1574
1575	pasm()->loadPtr(address: Address(PlatformAssembler::CppStackFrameRegister, offsetof(JSTypesStackFrame, unwindLabel)), dest: PlatformAssembler::ScratchRegister);
1576	pasm()->jump(target: PlatformAssembler::ScratchRegister);
1577
1578	noUnwind.link(pasm());
1579	}
1580
1581	int JIT::BaselineAssembler::unwindToLabel(int level, int offset)
1582	{
1583	auto l = pasm()->storePtrWithPatch(initialValue: TrustedImmPtr(nullptr), address: Address(PlatformAssembler::CppStackFrameRegister, offsetof(JSTypesStackFrame, unwindLabel)));
1584	pasm()->addEHTarget(label: l, offset);
1585	pasm()->store32(imm: TrustedImm32(level), address: Address(PlatformAssembler::CppStackFrameRegister, offsetof(JSTypesStackFrame, unwindLevel)));
1586	gotoCatchException();
1587	return offset;
1588	}
1589
1590	void BaselineAssembler::pushCatchContext(int index, int name)
1591	{
1592	pasm()->prepareCallWithArgCount(argc: 3);
1593	pasm()->passInt32AsArg(value: name, arg: 2);
1594	pasm()->passInt32AsArg(value: index, arg: 1);
1595	pasm()->passEngineAsArg(arg: 0);
1596	ASM_GENERATE_RUNTIME_CALL(PushCatchContext, CallResultDestination::Ignore);
1597	}
1598
1599	void BaselineAssembler::popContext()
1600	{
1601	Heap::CallContext ctx;
1602	Q_UNUSED(ctx);
1603	pasm()->loadPointerFromValue(addr: regAddr(reg: CallData::Context), dest: PlatformAssembler::ScratchRegister);
1604	pasm()->loadPtr(address: Address(PlatformAssembler::ScratchRegister, ctx.outer.offset), dest: PlatformAssembler::ScratchRegister);
1605	pasm()->storeHeapObject(source: PlatformAssembler::ScratchRegister, addr: regAddr(reg: CallData::Context));
1606	}
1607
1608	void BaselineAssembler::deadTemporalZoneCheck(int offsetForSavedIP, int variableName)
1609	{
1610	auto valueIsAliveJump = pasm()->jumpNotEmpty();
1611	storeInstructionPointer(instructionOffset: offsetForSavedIP);
1612	prepareCallWithArgCount(argc: 2);
1613	passInt32AsArg(value: variableName, arg: 1);
1614	passEngineAsArg(arg: 0);
1615	ASM_GENERATE_RUNTIME_CALL(ThrowReferenceError, CallResultDestination::Ignore);
1616	gotoCatchException();
1617	valueIsAliveJump.link(pasm());
1618	}
1619
1620	void BaselineAssembler::ret()
1621	{
1622	pasm()->generateFunctionExit();
1623	}
1624
1625	} // JIT namespace
1626	} // QV4 namepsace
1627
1628	QT_END_NAMESPACE
1629
1630	#endif // QT_CONFIG(qml_jit)
1631