1 files changed, 62 insertions, 54 deletions

diff --git a/src/qml/jit/qv4isel_masm.cpp b/src/qml/jit/qv4isel_masm.cpp
index 69d6951bb9..9841620481 100644
--- a/src/qml/jit/qv4isel_masm.cpp
+++ b/src/qml/jit/qv4isel_masm.cpp
@@ -132,8 +132,8 @@ void InstructionSelection<JITAssembler>::run(int functionIndex)
         for (IR::Stmt *s : _block->statements()) {
             if (s->location.isValid()) {
                 if (int(s->location.startLine) != lastLine) {
-                    _as->loadPtr(Address(JITTargetPlatform::EngineRegister, qOffsetOf(QV4::ExecutionEngine, current)), JITTargetPlatform::ScratchRegister);
-                    Address lineAddr(JITTargetPlatform::ScratchRegister, qOffsetOf(QV4::ExecutionContext::Data, lineNumber));
+                    _as->loadPtr(Address(JITTargetPlatform::EngineRegister, JITAssembler::targetStructureOffset(offsetof(QV4::EngineBase, current))), JITTargetPlatform::ScratchRegister);
+                    Address lineAddr(JITTargetPlatform::ScratchRegister, JITAssembler::targetStructureOffset(Heap::ExecutionContextData::baseOffset + offsetof(Heap::ExecutionContextData, lineNumber)));
                     _as->store32(TrustedImm32(s->location.startLine), lineAddr);
                     lastLine = s->location.startLine;
                 }
@@ -350,11 +350,11 @@ void InstructionSelection<JITAssembler>::callBuiltinDefineObjectLiteral(IR::Expr
         bool isData = it->expr->asConst()->value;
         it = it->next;
 
-        _as->copyValue(_as->stackLayout().argumentAddressForCall(argc++), it->expr);
+        _as->copyValue(_as->stackLayout().argumentAddressForCall(argc++), it->expr, WriteBarrier::NoBarrier);
 
         if (!isData) {
             it = it->next;
-            _as->copyValue(_as->stackLayout().argumentAddressForCall(argc++), it->expr);
+            _as->copyValue(_as->stackLayout().argumentAddressForCall(argc++), it->expr, WriteBarrier::NoBarrier);
         }
     }
 
@@ -376,10 +376,10 @@ void InstructionSelection<JITAssembler>::callBuiltinDefineObjectLiteral(IR::Expr
         ++arrayValueCount;
 
         // Index
-        _as->storeValue(QV4::Primitive::fromUInt32(index), _as->stackLayout().argumentAddressForCall(argc++));
+        _as->storeValue(QV4::Primitive::fromUInt32(index), _as->stackLayout().argumentAddressForCall(argc++), WriteBarrier::NoBarrier);
 
         // Value
-        _as->copyValue(_as->stackLayout().argumentAddressForCall(argc++), it->expr);
+        _as->copyValue(_as->stackLayout().argumentAddressForCall(argc++), it->expr, WriteBarrier::NoBarrier);
         it = it->next;
     }
 
@@ -400,14 +400,14 @@ void InstructionSelection<JITAssembler>::callBuiltinDefineObjectLiteral(IR::Expr
         ++arrayGetterSetterCount;
 
         // Index
-        _as->storeValue(QV4::Primitive::fromUInt32(index), _as->stackLayout().argumentAddressForCall(argc++));
+        _as->storeValue(QV4::Primitive::fromUInt32(index), _as->stackLayout().argumentAddressForCall(argc++), WriteBarrier::NoBarrier);
 
         // Getter
-        _as->copyValue(_as->stackLayout().argumentAddressForCall(argc++), it->expr);
+        _as->copyValue(_as->stackLayout().argumentAddressForCall(argc++), it->expr, WriteBarrier::NoBarrier);
         it = it->next;
 
         // Setter
-        _as->copyValue(_as->stackLayout().argumentAddressForCall(argc++), it->expr);
+        _as->copyValue(_as->stackLayout().argumentAddressForCall(argc++), it->expr, WriteBarrier::NoBarrier);
         it = it->next;
     }
 
@@ -447,9 +447,11 @@ void InstructionSelection<JITAssembler>::callValue(IR::Expr *value, IR::ExprList
 template <typename JITAssembler>
 void InstructionSelection<JITAssembler>::loadThisObject(IR::Expr *temp)
 {
-    _as->loadPtr(Address(JITTargetPlatform::EngineRegister, qOffsetOf(QV4::ExecutionEngine, current)), JITTargetPlatform::ScratchRegister);
-    _as->loadPtr(Address(JITTargetPlatform::ScratchRegister, qOffsetOf(ExecutionContext::Data, callData)), JITTargetPlatform::ScratchRegister);
-    _as->copyValue(temp, Address(JITTargetPlatform::ScratchRegister, qOffsetOf(CallData, thisObject)));
+    WriteBarrier::Type barrier;
+    Pointer addr = _as->loadAddressForWriting(JITTargetPlatform::ScratchRegister, temp, &barrier);
+    _as->loadPtr(Address(JITTargetPlatform::EngineRegister, JITAssembler::targetStructureOffset(offsetof(QV4::EngineBase, current))), JITTargetPlatform::ReturnValueRegister);
+    _as->loadPtr(Address(JITTargetPlatform::ReturnValueRegister,JITAssembler::targetStructureOffset(Heap::ExecutionContextData::baseOffset + offsetof(Heap::ExecutionContextData, callData))), JITTargetPlatform::ReturnValueRegister);
+    _as->copyValue(addr, Address(JITTargetPlatform::ReturnValueRegister, offsetof(CallData, thisObject)), barrier);
 }
 
 template <typename JITAssembler>
@@ -503,8 +505,9 @@ void InstructionSelection<JITAssembler>::loadString(const QString &str, IR::Expr
 {
     Pointer srcAddr = _as->loadStringAddress(JITTargetPlatform::ReturnValueRegister, str);
     _as->loadPtr(srcAddr, JITTargetPlatform::ReturnValueRegister);
-    Pointer destAddr = _as->loadAddress(JITTargetPlatform::ScratchRegister, target);
-    JITAssembler::RegisterSizeDependentOps::loadManagedPointer(_as, JITTargetPlatform::ReturnValueRegister, destAddr);
+    WriteBarrier::Type barrier;
+    Pointer destAddr = _as->loadAddressForWriting(JITTargetPlatform::ScratchRegister, target, &barrier);
+    JITAssembler::RegisterSizeDependentOps::loadManagedPointer(_as, JITTargetPlatform::ReturnValueRegister, destAddr, barrier);
 }
 
 template <typename JITAssembler>
@@ -519,7 +522,7 @@ void InstructionSelection<JITAssembler>::getActivationProperty(const IR::Name *n
 {
     if (useFastLookups && name->global) {
         uint index = registerGlobalGetterLookup(*name->id);
-        generateLookupCall(target, index, qOffsetOf(QV4::Lookup, globalGetter), JITTargetPlatform::EngineRegister, JITAssembler::Void);
+        generateLookupCall(target, index, offsetof(QV4::Lookup, globalGetter), JITTargetPlatform::EngineRegister, JITAssembler::Void);
         return;
     }
     generateRuntimeCall(_as, target, getActivationProperty, JITTargetPlatform::EngineRegister, StringToIndex(*name->id));
@@ -545,7 +548,7 @@ void InstructionSelection<JITAssembler>::getProperty(IR::Expr *base, const QStri
 {
     if (useFastLookups) {
         uint index = registerGetterLookup(name);
-        generateLookupCall(target, index, qOffsetOf(QV4::Lookup, getter), JITTargetPlatform::EngineRegister, PointerToValue(base), JITAssembler::Void);
+        generateLookupCall(target, index, offsetof(QV4::Lookup, getter), JITTargetPlatform::EngineRegister, PointerToValue(base), JITAssembler::Void);
     } else {
         generateRuntimeCall(_as, target, getProperty, JITTargetPlatform::EngineRegister,
                              PointerToValue(base), StringToIndex(name));
@@ -584,7 +587,7 @@ void InstructionSelection<JITAssembler>::setProperty(IR::Expr *source, IR::Expr
 {
     if (useFastLookups) {
         uint index = registerSetterLookup(targetName);
-        generateLookupCall(JITAssembler::Void, index, qOffsetOf(QV4::Lookup, setter),
+        generateLookupCall(JITAssembler::Void, index, offsetof(QV4::Lookup, setter),
                            JITTargetPlatform::EngineRegister,
                            PointerToValue(targetBase),
                            PointerToValue(source));
@@ -620,7 +623,8 @@ void InstructionSelection<JITAssembler>::getElement(IR::Expr *base, IR::Expr *in
 {
     if (useFastLookups) {
         uint lookup = registerIndexedGetterLookup();
-        generateLookupCall(target, lookup, qOffsetOf(QV4::Lookup, indexedGetter),
+        generateLookupCall(target, lookup, offsetof(QV4::Lookup, indexedGetter),
+                           JITTargetPlatform::EngineRegister,
                            PointerToValue(base),
                            PointerToValue(index));
         return;
@@ -635,7 +639,8 @@ void InstructionSelection<JITAssembler>::setElement(IR::Expr *source, IR::Expr *
 {
     if (useFastLookups) {
         uint lookup = registerIndexedSetterLookup();
-        generateLookupCall(JITAssembler::Void, lookup, qOffsetOf(QV4::Lookup, indexedSetter),
+        generateLookupCall(JITAssembler::Void, lookup, offsetof(QV4::Lookup, indexedSetter),
+                           JITTargetPlatform::EngineRegister,
                            PointerToValue(targetBase), PointerToValue(targetIndex),
                            PointerToValue(source));
         return;
@@ -711,8 +716,10 @@ void InstructionSelection<JITAssembler>::copyValue(IR::Expr *source, IR::Expr *t
         }
     }
 
+    WriteBarrier::Type barrier;
+    Pointer addr = _as->loadAddressForWriting(JITTargetPlatform::ReturnValueRegister, target, &barrier);
     // The target is not a physical register, nor is the source. So we can do a memory-to-memory copy:
-    _as->memcopyValue(_as->loadAddress(JITTargetPlatform::ReturnValueRegister, target), source, JITTargetPlatform::ScratchRegister);
+    _as->memcopyValue(addr, source, JITTargetPlatform::ScratchRegister, barrier);
 }
 
 template <typename JITAssembler>
@@ -739,14 +746,13 @@ void InstructionSelection<JITAssembler>::swapValues(IR::Expr *source, IR::Expr *
     } else if (!sourceTemp || sourceTemp->kind == IR::Temp::StackSlot) {
         if (!targetTemp || targetTemp->kind == IR::Temp::StackSlot) {
             // Note: a swap for two stack-slots can involve different types.
-            Pointer sAddr = _as->loadAddress(JITTargetPlatform::ScratchRegister, source);
-            Pointer tAddr = _as->loadAddress(JITTargetPlatform::ReturnValueRegister, target);
-            // use the implementation in JSC::MacroAssembler, as it doesn't do bit swizzling
-            auto platformAs = static_cast<typename JITAssembler::MacroAssembler*>(_as);
-            platformAs->loadDouble(sAddr, JITTargetPlatform::FPGpr0);
-            platformAs->loadDouble(tAddr, JITTargetPlatform::FPGpr1);
-            platformAs->storeDouble(JITTargetPlatform::FPGpr1, sAddr);
-            platformAs->storeDouble(JITTargetPlatform::FPGpr0, tAddr);
+            WriteBarrier::Type barrierForSource, barrierForTarget;
+            Pointer sAddr = _as->loadAddressForWriting(JITTargetPlatform::ScratchRegister, source, &barrierForSource);
+            Pointer tAddr = _as->loadAddressForWriting(JITTargetPlatform::ReturnValueRegister, target, &barrierForTarget);
+            _as->loadRawValue(sAddr, JITTargetPlatform::FPGpr0);
+            _as->loadRawValue(tAddr, JITTargetPlatform::FPGpr1);
+            _as->storeRawValue(JITTargetPlatform::FPGpr1, sAddr, barrierForSource);
+            _as->storeRawValue(JITTargetPlatform::FPGpr0, tAddr, barrierForTarget);
             return;
         }
     }
@@ -757,14 +763,15 @@ void InstructionSelection<JITAssembler>::swapValues(IR::Expr *source, IR::Expr *
     Q_ASSERT(memExpr);
     Q_ASSERT(regTemp);
 
-    Pointer addr = _as->loadAddress(JITTargetPlatform::ReturnValueRegister, memExpr);
+    WriteBarrier::Type barrier;
+    Pointer addr = _as->loadAddressForWriting(JITTargetPlatform::ReturnValueRegister, memExpr, &barrier);
     if (regTemp->type == IR::DoubleType) {
         _as->loadDouble(addr, JITTargetPlatform::FPGpr0);
-        _as->storeDouble((FPRegisterID) regTemp->index, addr);
+        _as->storeDouble((FPRegisterID) regTemp->index, addr, barrier);
         _as->moveDouble(JITTargetPlatform::FPGpr0, (FPRegisterID) regTemp->index);
     } else if (regTemp->type == IR::UInt32Type) {
         _as->toUInt32Register(addr, JITTargetPlatform::ScratchRegister);
-        _as->storeUInt32((RegisterID) regTemp->index, addr);
+        _as->storeUInt32((RegisterID) regTemp->index, addr, barrier);
         _as->move(JITTargetPlatform::ScratchRegister, (RegisterID) regTemp->index);
     } else {
         _as->load32(addr, JITTargetPlatform::ScratchRegister);
@@ -784,6 +791,7 @@ void InstructionSelection<JITAssembler>::swapValues(IR::Expr *source, IR::Expr *
                 Q_UNREACHABLE();
             }
             _as->store32(TrustedImm32(tag), addr);
+            _as->emitWriteBarrier(addr, barrier);
         }
         _as->move(JITTargetPlatform::ScratchRegister, (RegisterID) regTemp->index);
     }
@@ -791,12 +799,12 @@ void InstructionSelection<JITAssembler>::swapValues(IR::Expr *source, IR::Expr *
 
 #define setOp(op, opName, operation) \
     do { \
-        op = typename JITAssembler::RuntimeCall(qOffsetOf(QV4::Runtime, operation)); opName = "Runtime::" isel_stringIfy(operation); \
+        op = typename JITAssembler::RuntimeCall(QV4::Runtime::operation); opName = "Runtime::" isel_stringIfy(operation); \
         needsExceptionCheck = QV4::Runtime::Method_##operation##_NeedsExceptionCheck; \
     } while (0)
 #define setOpContext(op, opName, operation) \
     do { \
-        opContext = typename JITAssembler::RuntimeCall(qOffsetOf(QV4::Runtime, operation)); opName = "Runtime::" isel_stringIfy(operation); \
+        opContext = typename JITAssembler::RuntimeCall(QV4::Runtime::operation); opName = "Runtime::" isel_stringIfy(operation); \
         needsExceptionCheck = QV4::Runtime::Method_##operation##_NeedsExceptionCheck; \
     } while (0)
 
@@ -913,13 +921,13 @@ void InstructionSelection<JITAssembler>::convertTypeToDouble(IR::Expr *source, I
         convertUIntToDouble(source, target);
         break;
     case IR::UndefinedType:
-        _as->loadDouble(_as->loadAddress(JITTargetPlatform::ScratchRegister, source), JITTargetPlatform::FPGpr0);
+        _as->loadDouble(_as->loadAddressForReading(JITTargetPlatform::ScratchRegister, source), JITTargetPlatform::FPGpr0);
         _as->storeDouble(JITTargetPlatform::FPGpr0, target);
         break;
     case IR::StringType:
     case IR::VarType: {
         // load the tag:
-        Pointer tagAddr = _as->loadAddress(JITTargetPlatform::ScratchRegister, source);
+        Pointer tagAddr = _as->loadAddressForReading(JITTargetPlatform::ScratchRegister, source);
         tagAddr.offset += 4;
         _as->load32(tagAddr, JITTargetPlatform::ScratchRegister);
 
@@ -938,7 +946,7 @@ void InstructionSelection<JITAssembler>::convertTypeToDouble(IR::Expr *source, I
 
         // it is a double:
         isDbl.link(_as);
-        Pointer addr2 = _as->loadAddress(JITTargetPlatform::ScratchRegister, source);
+        Pointer addr2 = _as->loadAddressForReading(JITTargetPlatform::ScratchRegister, source);
         IR::Temp *targetTemp = target->asTemp();
         if (!targetTemp || targetTemp->kind == IR::Temp::StackSlot) {
             _as->memcopyValue(target, addr2, JITTargetPlatform::FPGpr0, JITTargetPlatform::ReturnValueRegister);
@@ -996,7 +1004,7 @@ void InstructionSelection<JITAssembler>::convertTypeToBool(IR::Expr *source, IR:
         _as->storeBool(JITTargetPlatform::ReturnValueRegister, target);
     case IR::VarType:
     default:
-        Pointer addr = _as->loadAddress(JITTargetPlatform::ScratchRegister, source);
+        Pointer addr = _as->loadAddressForReading(JITTargetPlatform::ScratchRegister, source);
         Pointer tagAddr = addr;
         tagAddr.offset += 4;
         _as->load32(tagAddr, JITTargetPlatform::ReturnValueRegister);
@@ -1061,7 +1069,7 @@ void InstructionSelection<JITAssembler>::convertTypeToSInt32(IR::Expr *source, I
     case IR::StringType:
     default:
         generateRuntimeCall(_as, JITTargetPlatform::ReturnValueRegister, toInt,
-                             _as->loadAddress(JITTargetPlatform::ScratchRegister, source));
+                             _as->loadAddressForReading(JITTargetPlatform::ScratchRegister, source));
         _as->storeInt32(JITTargetPlatform::ReturnValueRegister, target);
         break;
     } // switch (source->type)
@@ -1073,21 +1081,21 @@ void InstructionSelection<JITAssembler>::convertTypeToUInt32(IR::Expr *source, I
     switch (source->type) {
     case IR::VarType: {
         // load the tag:
-        Pointer tagAddr = _as->loadAddress(JITTargetPlatform::ScratchRegister, source);
+        Pointer tagAddr = _as->loadAddressForReading(JITTargetPlatform::ScratchRegister, source);
         tagAddr.offset += 4;
         _as->load32(tagAddr, JITTargetPlatform::ScratchRegister);
 
         // check if it's an int32:
         Jump isNoInt = _as->branch32(RelationalCondition::NotEqual, JITTargetPlatform::ScratchRegister,
                                                 TrustedImm32(Value::Integer_Type_Internal));
-        Pointer addr = _as->loadAddress(JITTargetPlatform::ScratchRegister, source);
+        Pointer addr = _as->loadAddressForReading(JITTargetPlatform::ScratchRegister, source);
         _as->storeUInt32(_as->toInt32Register(addr, JITTargetPlatform::ScratchRegister), target);
         Jump intDone = _as->jump();
 
         // not an int:
         isNoInt.link(_as);
         generateRuntimeCall(_as, JITTargetPlatform::ReturnValueRegister, toUInt,
-                             _as->loadAddress(JITTargetPlatform::ScratchRegister, source));
+                             _as->loadAddressForReading(JITTargetPlatform::ScratchRegister, source));
         _as->storeInt32(JITTargetPlatform::ReturnValueRegister, target);
 
         intDone.link(_as);
@@ -1192,7 +1200,7 @@ void InstructionSelection<JITAssembler>::visitCJump(IR::CJump *s)
             reg = JITTargetPlatform::ReturnValueRegister;
             _as->toInt32Register(t, reg);
         } else {
-            Address temp = _as->loadAddress(JITTargetPlatform::ScratchRegister, s->cond);
+            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));
@@ -1297,9 +1305,9 @@ int InstructionSelection<JITAssembler>::prepareVariableArguments(IR::ExprList* a
         Q_ASSERT(arg != 0);
         Pointer dst(_as->stackLayout().argumentAddressForCall(i));
         if (arg->asTemp() && arg->asTemp()->kind != IR::Temp::PhysicalRegister)
-            _as->memcopyValue(dst, arg->asTemp(), JITTargetPlatform::ScratchRegister);
+            _as->memcopyValue(dst, arg->asTemp(), JITTargetPlatform::ScratchRegister, WriteBarrier::NoBarrier);
         else
-            _as->copyValue(dst, arg);
+            _as->copyValue(dst, arg, WriteBarrier::NoBarrier);
     }
 
     return argc;
@@ -1313,15 +1321,15 @@ int InstructionSelection<JITAssembler>::prepareCallData(IR::ExprList* args, IR::
         ++argc;
     }
 
-    Pointer p = _as->stackLayout().callDataAddress(qOffsetOf(CallData, tag));
+    Pointer p = _as->stackLayout().callDataAddress(offsetof(CallData, tag));
     _as->store32(TrustedImm32(QV4::Value::Integer_Type_Internal), p);
-    p = _as->stackLayout().callDataAddress(qOffsetOf(CallData, argc));
+    p = _as->stackLayout().callDataAddress(offsetof(CallData, argc));
     _as->store32(TrustedImm32(argc), p);
-    p = _as->stackLayout().callDataAddress(qOffsetOf(CallData, thisObject));
+    p = _as->stackLayout().callDataAddress(offsetof(CallData, thisObject));
     if (!thisObject)
-        _as->storeValue(QV4::Primitive::undefinedValue(), p);
+        _as->storeValue(QV4::Primitive::undefinedValue(), p, WriteBarrier::NoBarrier);
     else
-        _as->copyValue(p, thisObject);
+        _as->copyValue(p, thisObject, WriteBarrier::NoBarrier);
 
     int i = 0;
     for (IR::ExprList *it = args; it; it = it->next, ++i) {
@@ -1329,9 +1337,9 @@ int InstructionSelection<JITAssembler>::prepareCallData(IR::ExprList* args, IR::
         Q_ASSERT(arg != 0);
         Pointer dst(_as->stackLayout().argumentAddressForCall(i));
         if (arg->asTemp() && arg->asTemp()->kind != IR::Temp::PhysicalRegister)
-            _as->memcopyValue(dst, arg->asTemp(), JITTargetPlatform::ScratchRegister);
+            _as->memcopyValue(dst, arg->asTemp(), JITTargetPlatform::ScratchRegister, WriteBarrier::NoBarrier);
         else
-            _as->copyValue(dst, arg);
+            _as->copyValue(dst, arg, WriteBarrier::NoBarrier);
     }
     return argc;
 }
@@ -1449,7 +1457,7 @@ bool InstructionSelection<JITAssembler>::visitCJumpStrictNull(IR::Binop *binop,
         return true;
     }
 
-    Pointer tagAddr = _as->loadAddress(JITTargetPlatform::ScratchRegister, varSrc);
+    Pointer tagAddr = _as->loadAddressForReading(JITTargetPlatform::ScratchRegister, varSrc);
     tagAddr.offset += 4;
     const RegisterID tagReg = JITTargetPlatform::ScratchRegister;
     _as->load32(tagAddr, tagReg);
@@ -1532,7 +1540,7 @@ bool InstructionSelection<JITAssembler>::visitCJumpStrictBool(IR::Binop *binop,
         return true;
     }
 
-    Pointer otherAddr = _as->loadAddress(JITTargetPlatform::ReturnValueRegister, otherSrc);
+    Pointer otherAddr = _as->loadAddressForReading(JITTargetPlatform::ReturnValueRegister, otherSrc);
     otherAddr.offset += 4; // tag address
 
     // check if the tag of the var operand is indicates 'boolean'
@@ -1581,7 +1589,7 @@ bool InstructionSelection<JITAssembler>::visitCJumpNullUndefined(IR::Type nullOr
         return true;
     }
 
-    Pointer tagAddr = _as->loadAddress(JITTargetPlatform::ScratchRegister, varSrc);
+    Pointer tagAddr = _as->loadAddressForReading(JITTargetPlatform::ScratchRegister, varSrc);
     tagAddr.offset += 4;
     const RegisterID tagReg = JITTargetPlatform::ReturnValueRegister;
     _as->load32(tagAddr, tagReg);