Merge "Merge remote-tracking branch 'origin/5.9' into dev" into refs/staging/dev

5 files changed, 89 insertions, 80 deletions

diff --git a/src/qml/jit/qv4assembler.cpp b/src/qml/jit/qv4assembler.cpp
index 583719a3c7..d062f3bbb2 100644
--- a/src/qml/jit/qv4assembler.cpp
+++ b/src/qml/jit/qv4assembler.cpp
@@ -156,9 +156,6 @@ bool CompilationUnit::saveCodeToDisk(QIODevice *device, const CompiledData::Unit
 }
 
 template <typename TargetConfiguration>
-const typename Assembler<TargetConfiguration>::VoidType Assembler<TargetConfiguration>::Void;
-
-template <typename TargetConfiguration>
 Assembler<TargetConfiguration>::Assembler(QV4::Compiler::JSUnitGenerator *jsGenerator, IR::Function* function, QV4::ExecutableAllocator *executableAllocator)
     : _function(function)
     , _nextBlock(0)
@@ -324,21 +321,21 @@ typename Assembler<TargetConfiguration>::Pointer Assembler<TargetConfiguration>:
     loadPtr(Address(Assembler::ScratchRegister, targetStructureOffset(Heap::ExecutionContextData::baseOffset + offsetof(Heap::ExecutionContextData, compilationUnit))), Assembler::ScratchRegister);
     loadPtr(Address(Assembler::ScratchRegister, offsetof(CompiledData::CompilationUnitBase, runtimeStrings)), reg);
     const int id = _jsGenerator->registerString(string);
-    return Pointer(reg, id * sizeof(QV4::String*));
+    return Pointer(reg, id * RegisterSize);
 }
 
 template <typename TargetConfiguration>
 typename Assembler<TargetConfiguration>::Address Assembler<TargetConfiguration>::loadConstant(IR::Const *c, RegisterID baseReg)
 {
-    return loadConstant(convertToValue(c), baseReg);
+    return loadConstant(convertToValue<TargetPrimitive>(c), baseReg);
 }
 
 template <typename TargetConfiguration>
-typename Assembler<TargetConfiguration>::Address Assembler<TargetConfiguration>::loadConstant(const Primitive &v, RegisterID baseReg)
+typename Assembler<TargetConfiguration>::Address Assembler<TargetConfiguration>::loadConstant(const TargetPrimitive &v, RegisterID baseReg)
 {
     loadPtr(Address(Assembler::EngineRegister, targetStructureOffset(offsetof(QV4::EngineBase, current))), baseReg);
     loadPtr(Address(baseReg, targetStructureOffset(Heap::ExecutionContextData::baseOffset + offsetof(Heap::ExecutionContextData, constantTable))), baseReg);
-    const int index = _jsGenerator->registerConstant(v.asReturnedValue());
+    const int index = _jsGenerator->registerConstant(v.rawValue());
     return Address(baseReg, index * sizeof(QV4::Value));
 }
 
@@ -350,7 +347,7 @@ void Assembler<TargetConfiguration>::loadStringRef(RegisterID reg, const QString
 }
 
 template <typename TargetConfiguration>
-void Assembler<TargetConfiguration>::storeValue(QV4::Primitive value, IR::Expr *destination)
+void Assembler<TargetConfiguration>::storeValue(TargetPrimitive value, IR::Expr *destination)
 {
     WriteBarrier::Type barrier;
     Address addr = loadAddressForWriting(ScratchRegister, destination, &barrier);
@@ -449,19 +446,13 @@ typename Assembler<TargetConfiguration>::Jump Assembler<TargetConfiguration>::ge
 
     // check if it's an int32:
     Assembler::Jump isNoInt = branch32(Assembler::NotEqual, Assembler::ScratchRegister,
-                                            Assembler::TrustedImm32(Value::Integer_Type_Internal));
+                                       Assembler::TrustedImm32(quint32(ValueTypeInternal::Integer)));
     convertInt32ToDouble(toInt32Register(src, Assembler::ScratchRegister), dest);
     Assembler::Jump intDone = jump();
 
     // not an int, check if it's a double:
     isNoInt.link(this);
-#ifdef QV4_USE_64_BIT_VALUE_ENCODING
-    rshift32(TrustedImm32(Value::IsDoubleTag_Shift), ScratchRegister);
-    Assembler::Jump isNoDbl = branch32(RelationalCondition::Equal, JITTargetPlatform::ScratchRegister, TrustedImm32(0));
-#else
-    and32(Assembler::TrustedImm32(Value::NotDouble_Mask), Assembler::ScratchRegister);
-    Assembler::Jump isNoDbl = branch32(RelationalCondition::Equal, JITTargetPlatform::ScratchRegister, TrustedImm32(Value::NotDouble_Mask));
-#endif
+    Assembler::Jump isNoDbl = RegisterSizeDependentOps::checkIfTagRegisterIsDouble(this, ScratchRegister);
     toDoubleRegister(src, dest);
     intDone.link(this);
 
@@ -530,7 +521,7 @@ void Assembler<TargetConfiguration>::returnFromFunction(IR::Ret *s, RegisterInfo
     } else if (IR::Temp *t = s->expr->asTemp()) {
         RegisterSizeDependentOps::setFunctionReturnValueFromTemp(this, t);
     } else if (IR::Const *c = s->expr->asConst()) {
-        QV4::Primitive retVal = convertToValue(c);
+        auto retVal = convertToValue<TargetPrimitive>(c);
         RegisterSizeDependentOps::setFunctionReturnValueFromConst(this, retVal);
     } else {
         Q_UNREACHABLE();
@@ -547,7 +538,7 @@ void Assembler<TargetConfiguration>::returnFromFunction(IR::Ret *s, RegisterInfo
     ret();
 
     exceptionReturnLabel = label();
-    QV4::Primitive retVal = Primitive::undefinedValue();
+    auto retVal = TargetPrimitive::undefinedValue();
     RegisterSizeDependentOps::setFunctionReturnValueFromConst(this, retVal);
     jump(leaveStackFrame);
 }
diff --git a/src/qml/jit/qv4assembler_p.h b/src/qml/jit/qv4assembler_p.h
index 8aa9d81ba2..9e38696d7a 100644
--- a/src/qml/jit/qv4assembler_p.h
+++ b/src/qml/jit/qv4assembler_p.h
@@ -153,6 +153,8 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
     using TrustedImm64 = typename JITAssembler::TrustedImm64;
     using Jump = typename JITAssembler::Jump;
     using Label = typename JITAssembler::Label;
+    using ValueTypeInternal = Value::ValueTypeInternal_32;
+    using TargetPrimitive = TargetPrimitive32;
 
     static void emitSetGrayBit(JITAssembler *as, RegisterID base)
     {
@@ -212,9 +214,9 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
         as->storeDouble(source, ptr, barrier);
     }
 
-    static void storeValue(JITAssembler *as, QV4::Primitive value, Address destination, WriteBarrier::Type barrier)
+    static void storeValue(JITAssembler *as, TargetPrimitive value, Address destination, WriteBarrier::Type barrier)
     {
-        as->store32(TrustedImm32(value.int_32()), destination);
+        as->store32(TrustedImm32(value.value()), destination);
         destination.offset += 4;
         as->store32(TrustedImm32(value.tag()), destination);
         if (WriteBarrier::isRequired<WriteBarrier::Primitive>() && barrier == WriteBarrier::Barrier)
@@ -271,16 +273,16 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
                 Jump done = as->jump();
                 intRange.link(as);
                 as->move(srcReg, lowReg);
-                as->move(TrustedImm32(QV4::Value::Integer_Type_Internal), highReg);
+                as->move(TrustedImm32(quint32(QV4::Value::ValueTypeInternal_32::Integer)), highReg);
                 done.link(as);
             } break;
             case IR::SInt32Type:
                 as->move((RegisterID) t->index, lowReg);
-                as->move(TrustedImm32(QV4::Value::Integer_Type_Internal), highReg);
+                as->move(TrustedImm32(quint32(QV4::Value::ValueTypeInternal_32::Integer)), highReg);
                 break;
             case IR::BoolType:
                 as->move((RegisterID) t->index, lowReg);
-                as->move(TrustedImm32(QV4::Value::Boolean_Type_Internal), highReg);
+                as->move(TrustedImm32(quint32(QV4::Value::ValueTypeInternal_32::Boolean)), highReg);
                 break;
             default:
                 Q_UNREACHABLE();
@@ -293,9 +295,9 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
         }
     }
 
-    static void setFunctionReturnValueFromConst(JITAssembler *as, QV4::Primitive retVal)
+    static void setFunctionReturnValueFromConst(JITAssembler *as, TargetPrimitive retVal)
     {
-        as->move(TrustedImm32(retVal.int_32()), TargetPlatform::LowReturnValueRegister);
+        as->move(TrustedImm32(retVal.value()), TargetPlatform::LowReturnValueRegister);
         as->move(TrustedImm32(retVal.tag()), TargetPlatform::HighReturnValueRegister);
     }
 
@@ -371,7 +373,7 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
 
         // check if it's an int32:
         Jump fallback = as->branch32(RelationalCondition::NotEqual, TargetPlatform::ReturnValueRegister,
-                                      TrustedImm32(Value::Integer_Type_Internal));
+                                     TrustedImm32(quint32(Value::ValueTypeInternal_32::Integer)));
         IR::Temp *targetTemp = target->asTemp();
         if (!targetTemp || targetTemp->kind == IR::Temp::StackSlot) {
             as->load32(addr, TargetPlatform::ReturnValueRegister);
@@ -379,7 +381,7 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
             Pointer targetAddr = as->loadAddressForWriting(TargetPlatform::ScratchRegister, target, &barrier);
             as->store32(TargetPlatform::ReturnValueRegister, targetAddr);
             targetAddr.offset += 4;
-            as->store32(TrustedImm32(Value::Integer_Type_Internal), targetAddr);
+            as->store32(TrustedImm32(quint32(Value::ValueTypeInternal_32::Integer)), targetAddr);
             if (WriteBarrier::isRequired<WriteBarrier::Primitive>() && barrier == WriteBarrier::Barrier)
                 emitWriteBarrier(as, targetAddr);
         } else {
@@ -424,6 +426,13 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
         Jump jump = as->branchSub32(ResultCondition::NonZero, TrustedImm32(1), TargetPlatform::ScratchRegister);
         jump.linkTo(loop, as);
     }
+
+    static Jump checkIfTagRegisterIsDouble(JITAssembler *as, RegisterID tagRegister)
+    {
+        as->and32(TrustedImm32(Value::NotDouble_Mask), tagRegister);
+        Jump isNoDbl = as->branch32(RelationalCondition::Equal, tagRegister, TrustedImm32(Value::NotDouble_Mask));
+        return isNoDbl;
+    }
 };
 
 template <typename JITAssembler, typename MacroAssembler, typename TargetPlatform>
@@ -440,6 +449,8 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
     using BranchTruncateType = typename JITAssembler::BranchTruncateType;
     using Jump = typename JITAssembler::Jump;
     using Label = typename JITAssembler::Label;
+    using ValueTypeInternal = Value::ValueTypeInternal_64;
+    using TargetPrimitive = TargetPrimitive64;
 
     static void emitSetGrayBit(JITAssembler *as, RegisterID base)
     {
@@ -536,7 +547,7 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
                 Jump done = as->jump();
                 intRange.link(as);
                 as->zeroExtend32ToPtr(srcReg, TargetPlatform::ReturnValueRegister);
-                quint64 tag = QV4::Value::Integer_Type_Internal;
+                quint64 tag = quint64(QV4::Value::ValueTypeInternal_64::Integer);
                 as->or64(TrustedImm64(tag << 32),
                          TargetPlatform::ReturnValueRegister);
                 done.link(as);
@@ -545,10 +556,10 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
                 quint64 tag;
                 switch (t->type) {
                 case IR::SInt32Type:
-                    tag = QV4::Value::Integer_Type_Internal;
+                    tag = quint64(QV4::Value::ValueTypeInternal_64::Integer);
                     break;
                 case IR::BoolType:
-                    tag = QV4::Value::Boolean_Type_Internal;
+                    tag = quint64(QV4::Value::ValueTypeInternal_64::Boolean);
                     break;
                 default:
                     tag = 31337; // bogus value
@@ -562,12 +573,12 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
         }
     }
 
-    static void setFunctionReturnValueFromConst(JITAssembler *as, QV4::Primitive retVal)
+    static void setFunctionReturnValueFromConst(JITAssembler *as, TargetPrimitive retVal)
     {
         as->move(TrustedImm64(retVal.rawValue()), TargetPlatform::ReturnValueRegister);
     }
 
-    static void storeValue(JITAssembler *as, QV4::Primitive value, Address destination, WriteBarrier::Type barrier)
+    static void storeValue(JITAssembler *as, TargetPrimitive value, Address destination, WriteBarrier::Type barrier)
     {
         as->store64(TrustedImm64(value.rawValue()), destination);
         if (WriteBarrier::isRequired<WriteBarrier::Unknown>() && barrier == WriteBarrier::Barrier)
@@ -606,7 +617,7 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
             Pointer addr = as->loadTempAddress(temp);
             as->load64(addr, dest);
         } else {
-            QV4::Value undefined = QV4::Primitive::undefinedValue();
+            auto undefined = TargetPrimitive::undefinedValue();
             as->move(TrustedImm64(undefined.rawValue()), dest);
         }
     }
@@ -619,7 +630,7 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
             Pointer addr = as->loadArgLocalAddressForReading(dest, al);
             as->load64(addr, dest);
         } else {
-            QV4::Value undefined = QV4::Primitive::undefinedValue();
+            auto undefined = TargetPrimitive::undefinedValue();
             as->move(TrustedImm64(undefined.rawValue()), dest);
         }
     }
@@ -628,7 +639,7 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
     {
         Q_UNUSED(argumentNumber);
 
-        QV4::Value v = convertToValue(c);
+        auto v = convertToValue<TargetPrimitive64>(c);
         as->move(TrustedImm64(v.rawValue()), dest);
     }
 
@@ -637,7 +648,7 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
         Q_UNUSED(argumentNumber);
 
         if (!expr) {
-            QV4::Value undefined = QV4::Primitive::undefinedValue();
+            auto undefined = TargetPrimitive::undefinedValue();
             as->move(TrustedImm64(undefined.rawValue()), dest);
         } else if (IR::Temp *t = expr->asTemp()){
             loadArgumentInRegister(as, t, dest, argumentNumber);
@@ -729,7 +740,7 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
             Pointer targetAddr = as->loadAddressForWriting(TargetPlatform::ScratchRegister, target, &barrier);
             as->store32(TargetPlatform::ReturnValueRegister, targetAddr);
             targetAddr.offset += 4;
-            as->store32(TrustedImm32(Value::Integer_Type_Internal), targetAddr);
+            as->store32(TrustedImm32(quint32(Value::ValueTypeInternal_64::Integer)), targetAddr);
             if (WriteBarrier::isRequired<WriteBarrier::Primitive>() && barrier == WriteBarrier::Barrier)
                 emitWriteBarrier(as, targetAddr);
         } else {
@@ -761,6 +772,13 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
         Jump jump = as->branchSub32(ResultCondition::NonZero, TrustedImm32(1), TargetPlatform::ScratchRegister);
         jump.linkTo(loop, as);
     }
+
+    static Jump checkIfTagRegisterIsDouble(JITAssembler *as, RegisterID tagRegister)
+    {
+        as->rshift32(TrustedImm32(Value::IsDoubleTag_Shift), tagRegister);
+        Jump isNoDbl = as->branch32(RelationalCondition::Equal, tagRegister, TrustedImm32(0));
+        return isNoDbl;
+    }
 };
 
 template <typename TargetConfiguration>
@@ -829,8 +847,6 @@ public:
         return (hostOffset * RegisterSize) / QT_POINTER_SIZE;
     }
 
-    using RegisterSizeDependentOps = RegisterSizeDependentAssembler<Assembler<TargetConfiguration>, MacroAssembler, JITTargetPlatform, RegisterSize>;
-
     struct LookupCall {
         Address addr;
         uint getterSetterOffset;
@@ -861,6 +877,10 @@ public:
         {}
     };
 
+    using RegisterSizeDependentOps = RegisterSizeDependentAssembler<Assembler<TargetConfiguration>, MacroAssembler, JITTargetPlatform, RegisterSize>;
+    using ValueTypeInternal = typename RegisterSizeDependentOps::ValueTypeInternal;
+    using TargetPrimitive = typename RegisterSizeDependentOps::TargetPrimitive;
+
     // V4 uses two stacks: one stack with QV4::Value items, which is checked by the garbage
     // collector, and one stack used by the native C/C++/ABI code. This C++ stack is not scanned
     // by the garbage collector, so if any JS object needs to be retained, it should be put on the
@@ -1090,7 +1110,7 @@ public:
     }
     Pointer loadStringAddress(RegisterID reg, const QString &string);
     Address loadConstant(IR::Const *c, RegisterID baseReg);
-    Address loadConstant(const Primitive &v, RegisterID baseReg);
+    Address loadConstant(const TargetPrimitive &v, RegisterID baseReg);
     void loadStringRef(RegisterID reg, const QString &string);
     Pointer stackSlotPointer(IR::Temp *t) const
     {
@@ -1365,12 +1385,12 @@ public:
             RegisterSizeDependentOps::emitWriteBarrier(this, dest);
     }
 
-    void storeValue(QV4::Primitive value, Address destination, WriteBarrier::Type barrier)
+    void storeValue(TargetPrimitive value, Address destination, WriteBarrier::Type barrier)
     {
         RegisterSizeDependentOps::storeValue(this, value, destination, barrier);
     }
 
-    void storeValue(QV4::Primitive value, IR::Expr* temp);
+    void storeValue(TargetPrimitive value, IR::Expr* temp);
 
     void emitWriteBarrier(Address addr, WriteBarrier::Type barrier) {
         if (WriteBarrier::isRequired<WriteBarrier::Primitive>() && barrier == WriteBarrier::Barrier)
@@ -1404,13 +1424,7 @@ public:
         if (argumentNumber < RegisterArgumentCount)
             loadArgumentInRegister(value, registerForArgument(argumentNumber), argumentNumber);
         else
-#if OS(WINDOWS) && CPU(X86_64)
-            loadArgumentOnStack<argumentNumber>(value, argumentNumber);
-#elif CPU(MIPS) // Stack space for 4 arguments needs to be allocated for MIPS platforms.
-            loadArgumentOnStack<argumentNumber>(value, argumentNumber + 4);
-#else // Sanity:
-            loadArgumentOnStack<argumentNumber - RegisterArgumentCount>(value, argumentNumber);
-#endif
+            loadArgumentOnStack<argumentNumber - RegisterArgumentCount + (StackShadowSpace / RegisterSize)>(value, argumentNumber);
     }
 
     template <int argumentNumber>
@@ -1554,8 +1568,8 @@ public:
             Address tagAddr = addr;
             tagAddr.offset += 4;
 
-            QV4::Primitive v = convertToValue(c);
-            store32(TrustedImm32(v.int_32()), addr);
+            auto v = convertToValue<TargetPrimitive>(c);
+            store32(TrustedImm32(v.value()), addr);
             store32(TrustedImm32(v.tag()), tagAddr);
             return Pointer(addr);
         }
@@ -1571,7 +1585,7 @@ public:
     {
         store32(reg, addr);
         addr.offset += 4;
-        store32(TrustedImm32(QV4::Primitive::fromBoolean(0).tag()), addr);
+        store32(TrustedImm32(TargetPrimitive::fromBoolean(0).tag()), addr);
         if (WriteBarrier::isRequired<WriteBarrier::Primitive>() && barrier == WriteBarrier::Barrier)
             RegisterSizeDependentOps::emitWriteBarrier(this, addr);
     }
@@ -1618,7 +1632,7 @@ public:
     {
         store32(reg, addr);
         addr.offset += 4;
-        store32(TrustedImm32(QV4::Primitive::fromInt32(0).tag()), addr);
+        store32(TrustedImm32(TargetPrimitive::fromInt32(0).tag()), addr);
         if (WriteBarrier::isRequired<WriteBarrier::Primitive>() && barrier == WriteBarrier::Barrier)
             RegisterSizeDependentOps::emitWriteBarrier(this, addr);
     }
@@ -1687,7 +1701,7 @@ public:
     RegisterID toInt32Register(IR::Expr *e, RegisterID scratchReg)
     {
         if (IR::Const *c = e->asConst()) {
-            move(TrustedImm32(convertToValue(c).int_32()), scratchReg);
+            move(TrustedImm32(convertToValue<Primitive>(c).int_32()), scratchReg);
             return scratchReg;
         }
 
@@ -1726,11 +1740,11 @@ public:
         Pointer tagAddr = addr;
         tagAddr.offset += 4;
         load32(tagAddr, scratchReg);
-        Jump inIntRange = branch32(RelationalCondition::Equal, scratchReg, TrustedImm32(QV4::Value::Integer_Type_Internal));
+        Jump inIntRange = branch32(RelationalCondition::Equal, scratchReg, TrustedImm32(quint32(ValueTypeInternal::Integer)));
 
         // it's not in signed int range, so load it as a double, and truncate it down
         loadDouble(addr, FPGpr0);
-        Address inversionAddress = loadConstant(QV4::Primitive::fromDouble(double(INT_MAX) + 1), scratchReg);
+        Address inversionAddress = loadConstant(TargetPrimitive::fromDouble(double(INT_MAX) + 1), scratchReg);
         subDouble(inversionAddress, FPGpr0);
         Jump canNeverHappen = branchTruncateDoubleToUint32(FPGpr0, scratchReg);
         canNeverHappen.link(this);
@@ -1786,6 +1800,9 @@ private:
 };
 
 template <typename TargetConfiguration>
+const typename Assembler<TargetConfiguration>::VoidType Assembler<TargetConfiguration>::Void;
+
+template <typename TargetConfiguration>
 template <typename Result, typename Source>
 void Assembler<TargetConfiguration>::copyValue(Result result, Source source, WriteBarrier::Type barrier)
 {
@@ -1810,7 +1827,7 @@ void Assembler<TargetConfiguration>::copyValue(Result result, IR::Expr* source,
     } else if (source->asTemp() || source->asArgLocal()) {
         RegisterSizeDependentOps::copyValueViaRegisters(this, source, result, barrier);
     } else if (IR::Const *c = source->asConst()) {
-        QV4::Primitive v = convertToValue(c);
+        auto v = convertToValue<TargetPrimitive>(c);
         storeValue(v, result, barrier);
     } else {
         Q_UNREACHABLE();
diff --git a/src/qml/jit/qv4isel_masm.cpp b/src/qml/jit/qv4isel_masm.cpp
index 9841620481..599370f73d 100644
--- a/src/qml/jit/qv4isel_masm.cpp
+++ b/src/qml/jit/qv4isel_masm.cpp
@@ -256,7 +256,7 @@ void InstructionSelection<JITAssembler>::callBuiltinDeleteName(const QString &na
 template <typename JITAssembler>
 void InstructionSelection<JITAssembler>::callBuiltinDeleteValue(IR::Expr *result)
 {
-    _as->storeValue(Primitive::fromBoolean(false), result);
+    _as->storeValue(JITAssembler::TargetPrimitive::fromBoolean(false), result);
 }
 
 template <typename JITAssembler>
@@ -376,7 +376,7 @@ void InstructionSelection<JITAssembler>::callBuiltinDefineObjectLiteral(IR::Expr
         ++arrayValueCount;
 
         // Index
-        _as->storeValue(QV4::Primitive::fromUInt32(index), _as->stackLayout().argumentAddressForCall(argc++), WriteBarrier::NoBarrier);
+        _as->storeValue(JITAssembler::TargetPrimitive::fromUInt32(index), _as->stackLayout().argumentAddressForCall(argc++), WriteBarrier::NoBarrier);
 
         // Value
         _as->copyValue(_as->stackLayout().argumentAddressForCall(argc++), it->expr, WriteBarrier::NoBarrier);
@@ -400,7 +400,7 @@ void InstructionSelection<JITAssembler>::callBuiltinDefineObjectLiteral(IR::Expr
         ++arrayGetterSetterCount;
 
         // Index
-        _as->storeValue(QV4::Primitive::fromUInt32(index), _as->stackLayout().argumentAddressForCall(argc++), WriteBarrier::NoBarrier);
+        _as->storeValue(JITAssembler::TargetPrimitive::fromUInt32(index), _as->stackLayout().argumentAddressForCall(argc++), WriteBarrier::NoBarrier);
 
         // Getter
         _as->copyValue(_as->stackLayout().argumentAddressForCall(argc++), it->expr, WriteBarrier::NoBarrier);
@@ -488,7 +488,7 @@ void InstructionSelection<JITAssembler>::loadConst(IR::Const *sourceConst, IR::E
                 _as->toUInt32Register(sourceConst, (RegisterID) targetTemp->index);
             } else if (targetTemp->type == IR::BoolType) {
                 Q_ASSERT(sourceConst->type == IR::BoolType);
-                _as->move(TrustedImm32(convertToValue(sourceConst).int_32()),
+                _as->move(TrustedImm32(convertToValue<Primitive>(sourceConst).int_32()),
                           (RegisterID) targetTemp->index);
             } else {
                 Q_UNREACHABLE();
@@ -497,7 +497,7 @@ void InstructionSelection<JITAssembler>::loadConst(IR::Const *sourceConst, IR::E
         }
     }
 
-    _as->storeValue(convertToValue(sourceConst), target);
+    _as->storeValue(convertToValue<typename JITAssembler::TargetPrimitive>(sourceConst), target);
 }
 
 template <typename JITAssembler>
@@ -781,10 +781,10 @@ void InstructionSelection<JITAssembler>::swapValues(IR::Expr *source, IR::Expr *
             quint32 tag;
             switch (regTemp->type) {
             case IR::BoolType:
-                tag = QV4::Value::Boolean_Type_Internal;
+                tag = quint32(JITAssembler::ValueTypeInternal::Boolean);
                 break;
             case IR::SInt32Type:
-                tag = QV4::Value::Integer_Type_Internal;
+                tag = quint32(JITAssembler::ValueTypeInternal::Integer);
                 break;
             default:
                 tag = 31337; // bogus value
@@ -933,7 +933,7 @@ void InstructionSelection<JITAssembler>::convertTypeToDouble(IR::Expr *source, I
 
         // check if it's an int32:
         Jump isNoInt = _as->branch32(RelationalCondition::NotEqual, JITTargetPlatform::ScratchRegister,
-                                                TrustedImm32(Value::Integer_Type_Internal));
+                                     TrustedImm32(quint32(JITAssembler::ValueTypeInternal::Integer)));
         convertIntToDouble(source, target);
         Jump intDone = _as->jump();
 
@@ -1011,13 +1011,13 @@ void InstructionSelection<JITAssembler>::convertTypeToBool(IR::Expr *source, IR:
 
         // checkif it's a bool:
         Jump notBool = _as->branch32(RelationalCondition::NotEqual, JITTargetPlatform::ReturnValueRegister,
-                                                TrustedImm32(Value::Boolean_Type_Internal));
+                                     TrustedImm32(quint32(JITAssembler::ValueTypeInternal::Boolean)));
         _as->load32(addr, JITTargetPlatform::ReturnValueRegister);
         Jump boolDone = _as->jump();
         // check if it's an int32:
         notBool.link(_as);
         Jump fallback = _as->branch32(RelationalCondition::NotEqual, JITTargetPlatform::ReturnValueRegister,
-                                                 TrustedImm32(Value::Integer_Type_Internal));
+                                      TrustedImm32(quint32(JITAssembler::ValueTypeInternal::Integer)));
         _as->load32(addr, JITTargetPlatform::ReturnValueRegister);
         Jump isZero = _as->branch32(RelationalCondition::Equal, JITTargetPlatform::ReturnValueRegister,
                                                TrustedImm32(0));
@@ -1087,7 +1087,7 @@ void InstructionSelection<JITAssembler>::convertTypeToUInt32(IR::Expr *source, I
 
         // check if it's an int32:
         Jump isNoInt = _as->branch32(RelationalCondition::NotEqual, JITTargetPlatform::ScratchRegister,
-                                                TrustedImm32(Value::Integer_Type_Internal));
+                                     TrustedImm32(quint32(JITAssembler::ValueTypeInternal::Integer)));
         Pointer addr = _as->loadAddressForReading(JITTargetPlatform::ScratchRegister, source);
         _as->storeUInt32(_as->toInt32Register(addr, JITTargetPlatform::ScratchRegister), target);
         Jump intDone = _as->jump();
@@ -1203,7 +1203,8 @@ void InstructionSelection<JITAssembler>::visitCJump(IR::CJump *s)
             Address temp = _as->loadAddressForReading(JITTargetPlatform::ScratchRegister, s->cond);
             Address tag = temp;
             tag.offset += QV4::Value::tagOffset();
-            Jump booleanConversion = _as->branch32(RelationalCondition::NotEqual, tag, TrustedImm32(QV4::Value::Boolean_Type_Internal));
+            Jump booleanConversion = _as->branch32(RelationalCondition::NotEqual, tag,
+                                                   TrustedImm32(quint32(JITAssembler::ValueTypeInternal::Boolean)));
 
             Address data = temp;
             data.offset += QV4::Value::valueOffset();
@@ -1322,12 +1323,12 @@ int InstructionSelection<JITAssembler>::prepareCallData(IR::ExprList* args, IR::
     }
 
     Pointer p = _as->stackLayout().callDataAddress(offsetof(CallData, tag));
-    _as->store32(TrustedImm32(QV4::Value::Integer_Type_Internal), p);
+    _as->store32(TrustedImm32(quint32(JITAssembler::ValueTypeInternal::Integer)), p);
     p = _as->stackLayout().callDataAddress(offsetof(CallData, argc));
     _as->store32(TrustedImm32(argc), p);
     p = _as->stackLayout().callDataAddress(offsetof(CallData, thisObject));
     if (!thisObject)
-        _as->storeValue(QV4::Primitive::undefinedValue(), p, WriteBarrier::NoBarrier);
+        _as->storeValue(JITAssembler::TargetPrimitive::undefinedValue(), p, WriteBarrier::NoBarrier);
     else
         _as->copyValue(p, thisObject, WriteBarrier::NoBarrier);
 
@@ -1464,7 +1465,7 @@ bool InstructionSelection<JITAssembler>::visitCJumpStrictNull(IR::Binop *binop,
 
     RelationalCondition cond = binop->op == IR::OpStrictEqual ? RelationalCondition::Equal
                                                                          : RelationalCondition::NotEqual;
-    const TrustedImm32 tag(QV4::Value::Null_Type_Internal);
+    const TrustedImm32 tag{quint32(JITAssembler::ValueTypeInternal::Null)};
     _as->generateCJumpOnCompare(cond, tagReg, tag, _block, trueBlock, falseBlock);
     return true;
 }
@@ -1546,7 +1547,7 @@ bool InstructionSelection<JITAssembler>::visitCJumpStrictBool(IR::Binop *binop,
     // check if the tag of the var operand is indicates 'boolean'
     _as->load32(otherAddr, JITTargetPlatform::ScratchRegister);
     Jump noBool = _as->branch32(RelationalCondition::NotEqual, JITTargetPlatform::ScratchRegister,
-                                           TrustedImm32(QV4::Value::Boolean_Type_Internal));
+                                TrustedImm32(quint32(JITAssembler::ValueTypeInternal::Boolean)));
     if (binop->op == IR::OpStrictEqual)
         _as->addPatch(falseBlock, noBool);
     else
@@ -1596,7 +1597,7 @@ bool InstructionSelection<JITAssembler>::visitCJumpNullUndefined(IR::Type nullOr
 
     if (binop->op == IR::OpNotEqual)
         qSwap(trueBlock, falseBlock);
-    Jump isNull = _as->branch32(RelationalCondition::Equal, tagReg, TrustedImm32(int(QV4::Value::Null_Type_Internal)));
+    Jump isNull = _as->branch32(RelationalCondition::Equal, tagReg, TrustedImm32(quint32(JITAssembler::ValueTypeInternal::Null)));
     Jump isNotUndefinedTag = _as->branch32(RelationalCondition::NotEqual, tagReg, TrustedImm32(int(QV4::Value::Managed_Type_Internal)));
     tagAddr.offset -= 4;
     _as->load32(tagAddr, tagReg);
@@ -1648,18 +1649,18 @@ Q_QML_EXPORT QV4::EvalISelFactory *createISelForArchitecture(const QString &arch
     using ARMv7CrossAssembler = QV4::JIT::Assembler<AssemblerTargetConfiguration<JSC::MacroAssemblerARMv7, NoOperatingSystemSpecialization>>;
     using ARM64CrossAssembler = QV4::JIT::Assembler<AssemblerTargetConfiguration<JSC::MacroAssemblerARM64, NoOperatingSystemSpecialization>>;
 
-    if (architecture == QLatin1String("armv7"))
+    if (architecture == QLatin1String("arm"))
         return new ISelFactory<ARMv7CrossAssembler>;
-    else if (architecture == QLatin1String("armv8"))
+    else if (architecture == QLatin1String("arm64"))
         return new ISelFactory<ARM64CrossAssembler>;
 
     QString hostArch;
 #if CPU(ARM_THUMB2)
-    hostArch = QStringLiteral("armv7");
+    hostArch = QStringLiteral("arm");
 #elif CPU(MIPS)
     hostArch = QStringLiteral("mips");
 #elif CPU(X86)
-    hostArch = QStringLiteral("x86");
+    hostArch = QStringLiteral("i386");
 #elif CPU(X86_64)
     hostArch = QStringLiteral("x86_64");
 #endif
diff --git a/src/qml/jit/qv4isel_masm_p.h b/src/qml/jit/qv4isel_masm_p.h
index 0d02284539..7019a117a2 100644
--- a/src/qml/jit/qv4isel_masm_p.h
+++ b/src/qml/jit/qv4isel_masm_p.h
@@ -160,7 +160,7 @@ protected:
         // FramePointerRegister points to its old value on the stack, and above
         // it we have the return address, hence the need to step over two
         // values before reaching the first argument.
-        return Address(JITTargetPlatform::FramePointerRegister, (index + 2) * sizeof(void*));
+        return Address(JITTargetPlatform::FramePointerRegister, (index + 2) * JITTargetPlatform::RegisterSize);
     }
 
     Pointer baseAddressForCallArguments()
diff --git a/src/qml/jit/qv4targetplatform_p.h b/src/qml/jit/qv4targetplatform_p.h
index ce6156802d..6d788f4a93 100644
--- a/src/qml/jit/qv4targetplatform_p.h
+++ b/src/qml/jit/qv4targetplatform_p.h
@@ -405,7 +405,7 @@ public:
                 << RI(JSC::ARMRegisters::r9,  QStringLiteral("r9"),  RI::RegularRegister,       RI::CalleeSaved, RI::RegAlloc)
 #endif
                 << RI(JSC::ARMRegisters::r10, QStringLiteral("r10"), RI::RegularRegister,       RI::CalleeSaved, RI::Predefined)
-#if CPU(ARM_THUMB2) && !defined(V4_BOOTSTRAP)
+#if CPU(ARM_THUMB2) || defined(V4_BOOTSTRAP)
                 << RI(JSC::ARMRegisters::r11, QStringLiteral("r11"), RI::RegularRegister,       RI::CalleeSaved, RI::Predefined)
 #endif
                 << RI(JSC::ARMRegisters::d2,  QStringLiteral("d2"),  RI::FloatingPointRegister, RI::CallerSaved, RI::RegAlloc)