Mark where we need a write barrier in the JIT

Separate the loadAddress calls into loadAddressForReading
and loadAddressForWriting. In the second case, add an
out argument that specifies whether the write will need
a barrier.

Pass the write barrier type that is required for a store
down into the actual store methods.

Change-Id: I3f7634ab82d82f1b20dab331e083d1a662cd314e
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

6 files changed, 208 insertions, 152 deletions

diff --git a/src/qml/jit/qv4assembler.cpp b/src/qml/jit/qv4assembler.cpp
index 0b8be97ef5..59470aeea2 100644
--- a/src/qml/jit/qv4assembler.cpp
+++ b/src/qml/jit/qv4assembler.cpp
@@ -246,13 +246,16 @@ void Assembler<TargetConfiguration>::generateCJumpOnCompare(RelationalCondition
 }
 
 template <typename TargetConfiguration>
-typename Assembler<TargetConfiguration>::Pointer Assembler<TargetConfiguration>::loadAddress(RegisterID tmp, IR::Expr *e)
+typename Assembler<TargetConfiguration>::Pointer
+Assembler<TargetConfiguration>::loadAddressForWriting(RegisterID tmp, IR::Expr *e, WriteBarrier::Type *barrier)
 {
+    if (barrier)
+        *barrier = WriteBarrier::NoBarrier;
     IR::Temp *t = e->asTemp();
     if (t)
         return loadTempAddress(t);
     else
-        return loadArgLocalAddress(tmp, e->asArgLocal());
+        return loadArgLocalAddressForWriting(tmp, e->asArgLocal(), barrier);
 }
 
 template <typename TargetConfiguration>
@@ -265,7 +268,8 @@ typename Assembler<TargetConfiguration>::Pointer Assembler<TargetConfiguration>:
 }
 
 template <typename TargetConfiguration>
-typename Assembler<TargetConfiguration>::Pointer Assembler<TargetConfiguration>::loadArgLocalAddress(RegisterID baseReg, IR::ArgLocal *al)
+typename Assembler<TargetConfiguration>::Pointer
+Assembler<TargetConfiguration>::loadArgLocalAddressForWriting(RegisterID baseReg, IR::ArgLocal *al, WriteBarrier::Type *barrier)
 {
     int32_t offset = 0;
     int scope = al->scope;
@@ -291,6 +295,8 @@ typename Assembler<TargetConfiguration>::Pointer Assembler<TargetConfiguration>:
     default:
         Q_UNREACHABLE();
     }
+    if (barrier)
+        *barrier = _function->argLocalRequiresWriteBarrier(al) ? WriteBarrier::Barrier : WriteBarrier::NoBarrier;
     return Pointer(baseReg, offset);
 }
 
@@ -329,8 +335,9 @@ void Assembler<TargetConfiguration>::loadStringRef(RegisterID reg, const QString
 template <typename TargetConfiguration>
 void Assembler<TargetConfiguration>::storeValue(QV4::Primitive value, IR::Expr *destination)
 {
-    Address addr = loadAddress(ScratchRegister, destination);
-    storeValue(value, addr);
+    WriteBarrier::Type barrier;
+    Address addr = loadAddressForWriting(ScratchRegister, destination, &barrier);
+    storeValue(value, addr, barrier);
 }
 
 template <typename TargetConfiguration>
@@ -419,7 +426,7 @@ typename Assembler<TargetConfiguration>::Jump Assembler<TargetConfiguration>::ge
     // It's not a number type, so it cannot be in a register.
     Q_ASSERT(src->asArgLocal() || src->asTemp()->kind != IR::Temp::PhysicalRegister || src->type == IR::BoolType);
 
-    Assembler::Pointer tagAddr = loadAddress(Assembler::ScratchRegister, src);
+    Assembler::Pointer tagAddr = loadAddressForReading(Assembler::ScratchRegister, src);
     tagAddr.offset += 4;
     load32(tagAddr, Assembler::ScratchRegister);
 
diff --git a/src/qml/jit/qv4assembler_p.h b/src/qml/jit/qv4assembler_p.h
index 36e812afb3..6e95b29ca7 100644
--- a/src/qml/jit/qv4assembler_p.h
+++ b/src/qml/jit/qv4assembler_p.h
@@ -57,6 +57,7 @@
 #include "private/qv4value_p.h"
 #include "private/qv4context_p.h"
 #include "private/qv4engine_p.h"
+#include "private/qv4writebarrier_p.h"
 #include "qv4targetplatform_p.h"
 
 #include <config.h>
@@ -158,29 +159,33 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
         as->MacroAssembler::loadDouble(addr, dest);
     }
 
-    static void storeDouble(JITAssembler *as, FPRegisterID source, Address addr)
+    static void storeDouble(JITAssembler *as, FPRegisterID source, Address addr, WriteBarrier::Type barrier)
     {
+        Q_UNUSED(barrier);
         as->MacroAssembler::storeDouble(source, addr);
     }
 
     static void storeDouble(JITAssembler *as, FPRegisterID source, IR::Expr* target)
     {
-        Pointer ptr = as->loadAddress(TargetPlatform::ScratchRegister, target);
-        as->storeDouble(source, ptr);
+        WriteBarrier::Type barrier;
+        Pointer ptr = as->loadAddressForWriting(TargetPlatform::ScratchRegister, target, &barrier);
+        as->storeDouble(source, ptr, barrier);
     }
 
-    static void storeValue(JITAssembler *as, QV4::Primitive value, Address destination)
+    static void storeValue(JITAssembler *as, QV4::Primitive value, Address destination, WriteBarrier::Type barrier)
     {
+        Q_UNUSED(barrier);
         as->store32(TrustedImm32(value.int_32()), destination);
         destination.offset += 4;
         as->store32(TrustedImm32(value.tag()), destination);
     }
 
     template <typename Source, typename Destination>
-    static void copyValueViaRegisters(JITAssembler *as, Source source, Destination destination)
+    static void copyValueViaRegisters(JITAssembler *as, Source source, Destination destination, WriteBarrier::Type barrier)
     {
+        Q_UNUSED(barrier);
         as->loadDouble(source, TargetPlatform::FPGpr0);
-        as->storeDouble(TargetPlatform::FPGpr0, destination);
+        as->storeDouble(TargetPlatform::FPGpr0, destination, barrier);
     }
 
     static void loadDoubleConstant(JITAssembler *as, IR::Const *c, FPRegisterID target)
@@ -193,8 +198,9 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
         as->moveIntsToDouble(TargetPlatform::LowReturnValueRegister, TargetPlatform::HighReturnValueRegister, dest, TargetPlatform::FPGpr0);
     }
 
-    static void storeReturnValue(JITAssembler *as, const Pointer &dest)
+    static void storeReturnValue(JITAssembler *as, const Pointer &dest, WriteBarrier::Type barrier)
     {
+        Q_UNUSED(barrier);
         Address destination = dest;
         as->store32(TargetPlatform::LowReturnValueRegister, destination);
         destination.offset += 4;
@@ -234,7 +240,7 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
                 Q_UNREACHABLE();
             }
         } else {
-            Pointer addr = as->loadAddress(TargetPlatform::ScratchRegister, t);
+            Pointer addr = as->loadAddressForReading(TargetPlatform::ScratchRegister, t);
             as->load32(addr, lowReg);
             addr.offset += 4;
             as->load32(addr, highReg);
@@ -295,7 +301,7 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
                                   IR::BasicBlock *nextBlock, IR::BasicBlock *currentBlock,
                                   IR::BasicBlock *trueBlock, IR::BasicBlock *falseBlock)
     {
-        Pointer tagAddr = as->loadAddress(scratchRegister, right);
+        Pointer tagAddr = as->loadAddressForReading(scratchRegister, right);
         as->load32(tagAddr, tagRegister);
         Jump j = as->branch32(JITAssembler::invert(cond), tagRegister, TrustedImm32(0));
         as->addPatch(falseBlock, j);
@@ -312,7 +318,7 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
     {
         Q_ASSERT(source->type == IR::VarType);
         // load the tag:
-        Pointer addr = as->loadAddress(TargetPlatform::ScratchRegister, source);
+        Pointer addr = as->loadAddressForReading(TargetPlatform::ScratchRegister, source);
         Pointer tagAddr = addr;
         tagAddr.offset += 4;
         as->load32(tagAddr, TargetPlatform::ReturnValueRegister);
@@ -323,7 +329,9 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
         IR::Temp *targetTemp = target->asTemp();
         if (!targetTemp || targetTemp->kind == IR::Temp::StackSlot) {
             as->load32(addr, TargetPlatform::ReturnValueRegister);
-            Pointer targetAddr = as->loadAddress(TargetPlatform::ScratchRegister, target);
+            WriteBarrier::Type barrier;
+            Pointer targetAddr = as->loadAddressForWriting(TargetPlatform::ScratchRegister, target, &barrier);
+            Q_UNUSED(barrier);
             as->store32(TargetPlatform::ReturnValueRegister, targetAddr);
             targetAddr.offset += 4;
             as->store32(TrustedImm32(Value::Integer_Type_Internal), targetAddr);
@@ -335,14 +343,15 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
         // not an int:
         fallback.link(as);
         generateRuntimeCall(as, TargetPlatform::ReturnValueRegister, toInt,
-                            as->loadAddress(TargetPlatform::ScratchRegister, source));
+                            as->loadAddressForReading(TargetPlatform::ScratchRegister, source));
         as->storeInt32(TargetPlatform::ReturnValueRegister, target);
 
         intDone.link(as);
     }
 
-    static void loadManagedPointer(JITAssembler *as, RegisterID registerWithPtr, Pointer destAddr)
+    static void loadManagedPointer(JITAssembler *as, RegisterID registerWithPtr, Pointer destAddr, WriteBarrier::Type barrier)
     {
+        Q_UNUSED(barrier);
         as->store32(registerWithPtr, destAddr);
         destAddr.offset += 4;
         as->store32(TrustedImm32(QV4::Value::Managed_Type_Internal_32), destAddr);
@@ -391,8 +400,9 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
         as->move64ToDouble(TargetPlatform::ReturnValueRegister, dest);
     }
 
-    static void storeDouble(JITAssembler *as, FPRegisterID source, Address addr)
+    static void storeDouble(JITAssembler *as, FPRegisterID source, Address addr, WriteBarrier::Type barrier)
     {
+        Q_UNUSED(barrier);
         as->moveDoubleTo64(source, TargetPlatform::ReturnValueRegister);
         as->xor64(TargetPlatform::DoubleMaskRegister, TargetPlatform::ReturnValueRegister);
         as->store64(TargetPlatform::ReturnValueRegister, addr);
@@ -402,7 +412,9 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
     {
         as->moveDoubleTo64(source, TargetPlatform::ReturnValueRegister);
         as->xor64(TargetPlatform::DoubleMaskRegister, TargetPlatform::ReturnValueRegister);
-        Pointer ptr = as->loadAddress(TargetPlatform::ScratchRegister, target);
+        WriteBarrier::Type barrier;
+        Pointer ptr = as->loadAddressForWriting(TargetPlatform::ScratchRegister, target, &barrier);
+        Q_UNUSED(barrier);
         as->store64(TargetPlatform::ReturnValueRegister, ptr);
     }
 
@@ -412,8 +424,9 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
         as->move64ToDouble(TargetPlatform::ReturnValueRegister, dest);
     }
 
-    static void storeReturnValue(JITAssembler *as, const Pointer &dest)
+    static void storeReturnValue(JITAssembler *as, const Pointer &dest, WriteBarrier::Type barrier)
     {
+        Q_UNUSED(barrier);
         as->store64(TargetPlatform::ReturnValueRegister, dest);
     }
 
@@ -455,7 +468,7 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
                          TargetPlatform::ReturnValueRegister);
             }
         } else {
-            as->copyValue(TargetPlatform::ReturnValueRegister, t);
+            as->copyValue(TargetPlatform::ReturnValueRegister, t, WriteBarrier::NoBarrier);
         }
     }
 
@@ -464,18 +477,19 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
         as->move(TrustedImm64(retVal.rawValue()), TargetPlatform::ReturnValueRegister);
     }
 
-    static void storeValue(JITAssembler *as, QV4::Primitive value, Address destination)
+    static void storeValue(JITAssembler *as, QV4::Primitive value, Address destination, WriteBarrier::Type barrier)
     {
+        Q_UNUSED(barrier);
         as->store64(TrustedImm64(value.rawValue()), destination);
     }
 
     template <typename Source, typename Destination>
-    static void copyValueViaRegisters(JITAssembler *as, Source source, Destination destination)
+    static void copyValueViaRegisters(JITAssembler *as, Source source, Destination destination, WriteBarrier::Type barrier)
     {
         // Use ReturnValueRegister as "scratch" register because loadArgument
         // and storeArgument are functions that may need a scratch register themselves.
         loadArgumentInRegister(as, source, TargetPlatform::ReturnValueRegister, 0);
-        as->storeReturnValue(destination);
+        as->storeReturnValue(destination, barrier);
     }
 
     static void loadDoubleConstant(JITAssembler *as, IR::Const *c, FPRegisterID target)
@@ -511,7 +525,7 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
         Q_UNUSED(argumentNumber);
 
         if (al) {
-            Pointer addr = as->loadArgLocalAddress(dest, al);
+            Pointer addr = as->loadArgLocalAddressForReading(dest, al);
             as->load64(addr, dest);
         } else {
             QV4::Value undefined = QV4::Primitive::undefinedValue();
@@ -580,7 +594,7 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
                                   IR::BasicBlock *nextBlock,  IR::BasicBlock *currentBlock,
                                   IR::BasicBlock *trueBlock, IR::BasicBlock *falseBlock)
     {
-        Pointer addr = as->loadAddress(scratchRegister, right);
+        Pointer addr = as->loadAddressForReading(scratchRegister, right);
         as->load64(addr, tagRegister);
         const TrustedImm64 tag(0);
         generateCJumpOnCompare(as, cond, tagRegister, tag, nextBlock, currentBlock, trueBlock, falseBlock);
@@ -589,7 +603,7 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
     static void convertVarToSInt32(JITAssembler *as, IR::Expr *source, IR::Expr *target)
     {
         Q_ASSERT(source->type == IR::VarType);
-        Pointer addr = as->loadAddress(TargetPlatform::ScratchRegister, source);
+        Pointer addr = as->loadAddressForReading(TargetPlatform::ScratchRegister, source);
         as->load64(addr, TargetPlatform::ScratchRegister);
         as->move(TargetPlatform::ScratchRegister, TargetPlatform::ReturnValueRegister);
 
@@ -613,14 +627,16 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
         // not an int:
         fallback.link(as);
         generateRuntimeCall(as, TargetPlatform::ReturnValueRegister, toInt,
-                            as->loadAddress(TargetPlatform::ScratchRegister, source));
+                            as->loadAddressForReading(TargetPlatform::ScratchRegister, source));
 
 
         isIntConvertible.link(as);
         success.link(as);
         IR::Temp *targetTemp = target->asTemp();
         if (!targetTemp || targetTemp->kind == IR::Temp::StackSlot) {
-            Pointer targetAddr = as->loadAddress(TargetPlatform::ScratchRegister, target);
+            WriteBarrier::Type barrier;
+            Pointer targetAddr = as->loadAddressForWriting(TargetPlatform::ScratchRegister, target, &barrier);
+            Q_UNUSED(barrier);
             as->store32(TargetPlatform::ReturnValueRegister, targetAddr);
             targetAddr.offset += 4;
             as->store32(TrustedImm32(Value::Integer_Type_Internal), targetAddr);
@@ -629,8 +645,9 @@ struct RegisterSizeDependentAssembler<JITAssembler, MacroAssembler, TargetPlatfo
         }
     }
 
-    static void loadManagedPointer(JITAssembler *as, RegisterID registerWithPtr, Pointer destAddr)
+    static void loadManagedPointer(JITAssembler *as, RegisterID registerWithPtr, Pointer destAddr, WriteBarrier::Type barrier)
     {
+        Q_UNUSED(barrier);
         as->store64(registerWithPtr, destAddr);
     }
 
@@ -962,9 +979,16 @@ public:
     Jump branchDouble(bool invertCondition, IR::AluOp op, IR::Expr *left, IR::Expr *right);
     Jump branchInt32(bool invertCondition, IR::AluOp op, IR::Expr *left, IR::Expr *right);
 
-    Pointer loadAddress(RegisterID tmp, IR::Expr *t);
+    Pointer loadAddressForWriting(RegisterID tmp, IR::Expr *t, WriteBarrier::Type *barrier);
+    Pointer loadAddressForReading(RegisterID tmp, IR::Expr *t) {
+        return loadAddressForWriting(tmp, t, 0);
+    }
+
     Pointer loadTempAddress(IR::Temp *t);
-    Pointer loadArgLocalAddress(RegisterID baseReg, IR::ArgLocal *al);
+    Pointer loadArgLocalAddressForWriting(RegisterID baseReg, IR::ArgLocal *al, WriteBarrier::Type *barrier);
+    Pointer loadArgLocalAddressForReading(RegisterID baseReg, IR::ArgLocal *al) {
+        return loadArgLocalAddressForWriting(baseReg, al, 0);
+    }
     Pointer loadStringAddress(RegisterID reg, const QString &string);
     Address loadConstant(IR::Const *c, RegisterID baseReg);
     Address loadConstant(const Primitive &v, RegisterID baseReg);
@@ -986,16 +1010,16 @@ public:
                 Pointer addr(_stackLayout->savedRegPointer(argumentNumber));
                 switch (t->type) {
                 case IR::BoolType:
-                    storeBool((RegisterID) t->index, addr);
+                    storeBool((RegisterID) t->index, addr, WriteBarrier::NoBarrier);
                     break;
                 case IR::SInt32Type:
-                    storeInt32((RegisterID) t->index, addr);
+                    storeInt32((RegisterID) t->index, addr, WriteBarrier::NoBarrier);
                     break;
                 case IR::UInt32Type:
-                    storeUInt32((RegisterID) t->index, addr);
+                    storeUInt32((RegisterID) t->index, addr, WriteBarrier::NoBarrier);
                     break;
                 case IR::DoubleType:
-                    storeDouble((FPRegisterID) t->index, addr);
+                    storeDouble((FPRegisterID) t->index, addr, WriteBarrier::NoBarrier);
                     break;
                 default:
                     Q_UNIMPLEMENTED();
@@ -1026,7 +1050,7 @@ public:
         if (!temp.value) {
             RegisterSizeDependentOps::zeroRegister(this, dest);
         } else {
-            Pointer addr = toAddress(dest, temp.value, argumentNumber);
+            Pointer addr = toAddress(dest, temp.value, argumentNumber, 0);
             loadArgumentInRegister(addr, dest, argumentNumber);
         }
     }
@@ -1039,7 +1063,7 @@ public:
     void loadArgumentInRegister(Reference temp, RegisterID dest, int argumentNumber)
     {
         Q_ASSERT(temp.value);
-        Pointer addr = loadAddress(dest, temp.value);
+        Pointer addr = loadAddressForReading(dest, temp.value);
         loadArgumentInRegister(addr, dest, argumentNumber);
     }
 
@@ -1072,8 +1096,10 @@ public:
             move(imm32, dest);
     }
 
-    void storeReturnValue(RegisterID dest)
+    void storeReturnValue(RegisterID dest, WriteBarrier::Type barrier = WriteBarrier::NoBarrier)
     {
+        Q_UNUSED(barrier);
+        Q_ASSERT(barrier == WriteBarrier::NoBarrier);
         move(ReturnValueRegister, dest);
     }
 
@@ -1081,7 +1107,7 @@ public:
     {
         subPtr(TrustedImm32(sizeof(QV4::Value)), StackPointerRegister);
         Pointer tmp(StackPointerRegister, 0);
-        storeReturnValue(tmp);
+        storeReturnValue(tmp, WriteBarrier::NoBarrier);
         toUInt32Register(tmp, dest);
         addPtr(TrustedImm32(sizeof(QV4::Value)), StackPointerRegister);
     }
@@ -1091,9 +1117,9 @@ public:
         RegisterSizeDependentOps::storeReturnValue(this, dest);
     }
 
-    void storeReturnValue(const Pointer &dest)
+    void storeReturnValue(const Pointer &dest, WriteBarrier::Type barrier)
     {
-        RegisterSizeDependentOps::storeReturnValue(this, dest);
+        RegisterSizeDependentOps::storeReturnValue(this, dest, barrier);
     }
 
     void storeReturnValue(IR::Expr *target)
@@ -1101,22 +1127,19 @@ public:
         if (!target)
             return;
 
-        if (IR::Temp *temp = target->asTemp()) {
-            if (temp->kind == IR::Temp::PhysicalRegister) {
-                if (temp->type == IR::DoubleType)
-                    storeReturnValue((FPRegisterID) temp->index);
-                else if (temp->type == IR::UInt32Type)
-                    storeUInt32ReturnValue((RegisterID) temp->index);
-                else
-                    storeReturnValue((RegisterID) temp->index);
-                return;
-            } else {
-                Pointer addr = loadTempAddress(temp);
-                storeReturnValue(addr);
-            }
-        } else if (IR::ArgLocal *al = target->asArgLocal()) {
-            Pointer addr = loadArgLocalAddress(ScratchRegister, al);
-            storeReturnValue(addr);
+        IR::Temp *temp = target->asTemp();
+        if (temp && temp->kind == IR::Temp::PhysicalRegister) {
+            if (temp->type == IR::DoubleType)
+                storeReturnValue((FPRegisterID) temp->index);
+            else if (temp->type == IR::UInt32Type)
+                storeUInt32ReturnValue((RegisterID) temp->index);
+            else
+                storeReturnValue((RegisterID) temp->index);
+            return;
+        } else {
+            WriteBarrier::Type barrier;
+            Pointer addr = loadAddressForWriting(ScratchRegister, target, &barrier);
+            storeReturnValue(addr, barrier);
         }
     }
 
@@ -1153,7 +1176,7 @@ public:
     void loadArgumentOnStack(PointerToValue temp, int argumentNumber)
     {
         if (temp.value) {
-            Pointer ptr = toAddress(ScratchRegister, temp.value, argumentNumber);
+            Pointer ptr = toAddress(ScratchRegister, temp.value, argumentNumber, 0);
             loadArgumentOnStack<StackSlot>(ptr, argumentNumber);
         } else {
             RegisterSizeDependentOps::zeroStackSlot(this, StackSlot);
@@ -1173,7 +1196,7 @@ public:
     {
         Q_ASSERT (temp.value);
 
-        Pointer ptr = loadAddress(ScratchRegister, temp.value);
+        Pointer ptr = loadAddressForReading(ScratchRegister, temp.value);
         loadArgumentOnStack<StackSlot>(ptr, argumentNumber);
     }
 
@@ -1184,7 +1207,7 @@ public:
             moveDouble((FPRegisterID) sourceTemp->index, dest);
             return;
         }
-        Pointer ptr = loadAddress(ScratchRegister, source);
+        Pointer ptr = loadAddressForReading(ScratchRegister, source);
         loadDouble(ptr, dest);
     }
 
@@ -1203,30 +1226,43 @@ public:
         RegisterSizeDependentOps::loadDouble(this, addr, dest);
     }
 
-    void storeDouble(FPRegisterID source, Address addr)
+    void storeDouble(FPRegisterID source, Address addr, WriteBarrier::Type barrier)
     {
-        RegisterSizeDependentOps::storeDouble(this, source, addr);
+        RegisterSizeDependentOps::storeDouble(this, source, addr, barrier);
     }
 
     template <typename Result, typename Source>
-    void copyValue(Result result, Source source);
+    void copyValue(Result result, Source source, WriteBarrier::Type barrier);
     template <typename Result>
-    void copyValue(Result result, IR::Expr* source);
+    void copyValue(Result result, IR::Expr* source, WriteBarrier::Type barrier);
 
     // The scratch register is used to calculate the temp address for the source.
-    void memcopyValue(Pointer target, IR::Expr *source, RegisterID scratchRegister)
+    void memcopyValue(Pointer target, IR::Expr *source, RegisterID scratchRegister, WriteBarrier::Type barrier)
     {
         Q_ASSERT(!source->asTemp() || source->asTemp()->kind != IR::Temp::PhysicalRegister);
         Q_ASSERT(target.base != scratchRegister);
-        TargetConfiguration::MacroAssembler::loadDouble(loadAddress(scratchRegister, source), FPGpr0);
-        TargetConfiguration::MacroAssembler::storeDouble(FPGpr0, target);
+        loadRawValue(loadAddressForReading(scratchRegister, source), FPGpr0);
+        storeRawValue(FPGpr0, target, barrier);
     }
 
     // The scratch register is used to calculate the temp address for the source.
     void memcopyValue(IR::Expr *target, Pointer source, FPRegisterID fpScratchRegister, RegisterID scratchRegister)
     {
-        TargetConfiguration::MacroAssembler::loadDouble(source, fpScratchRegister);
-        TargetConfiguration::MacroAssembler::storeDouble(fpScratchRegister, loadAddress(scratchRegister, target));
+        loadRawValue(source, fpScratchRegister);
+        WriteBarrier::Type barrier;
+        Pointer dest = loadAddressForWriting(scratchRegister, target, &barrier);
+        storeRawValue(fpScratchRegister, dest, barrier);
+    }
+
+    void loadRawValue(Pointer source, FPRegisterID dest)
+    {
+        TargetConfiguration::MacroAssembler::loadDouble(source, dest);
+    }
+
+    void storeRawValue(FPRegisterID source, Pointer dest, WriteBarrier::Type barrier)
+    {
+        Q_UNUSED(barrier);
+        TargetConfiguration::MacroAssembler::storeDouble(source, dest);
     }
 
     void storeValue(QV4::Primitive value, RegisterID destination)
@@ -1236,9 +1272,9 @@ public:
         Q_UNREACHABLE();
     }
 
-    void storeValue(QV4::Primitive value, Address destination)
+    void storeValue(QV4::Primitive value, Address destination, WriteBarrier::Type barrier)
     {
-        RegisterSizeDependentOps::storeValue(this, value, destination);
+        RegisterSizeDependentOps::storeValue(this, value, destination, barrier);
     }
 
     void storeValue(QV4::Primitive value, IR::Expr* temp);
@@ -1411,8 +1447,10 @@ public:
         generateFunctionCallImp(needsExceptionCheck, r, functionName, function, arg1, VoidType(), VoidType(), VoidType(), VoidType(), VoidType());
     }
 
-    Pointer toAddress(RegisterID tmpReg, IR::Expr *e, int offset)
+    Pointer toAddress(RegisterID tmpReg, IR::Expr *e, int offset, WriteBarrier::Type *barrier)
     {
+        if (barrier)
+            *barrier = WriteBarrier::NoBarrier;
         if (IR::Const *c = e->asConst()) {
             Address addr = _stackLayout->savedRegPointer(offset);
             Address tagAddr = addr;
@@ -1428,11 +1466,12 @@ public:
             if (t->kind == IR::Temp::PhysicalRegister)
                 return Pointer(_stackLayout->savedRegPointer(offset));
 
-        return loadAddress(tmpReg, e);
+        return loadAddressForWriting(tmpReg, e, barrier);
     }
 
-    void storeBool(RegisterID reg, Pointer addr)
+    void storeBool(RegisterID reg, Pointer addr, WriteBarrier::Type barrier)
     {
+        Q_UNUSED(barrier);
         store32(reg, addr);
         addr.offset += 4;
         store32(TrustedImm32(QV4::Primitive::fromBoolean(0).tag()), addr);
@@ -1452,8 +1491,9 @@ public:
             }
         }
 
-        Pointer addr = loadAddress(ScratchRegister, target);
-        storeBool(reg, addr);
+        WriteBarrier::Type barrier;
+        Pointer addr = loadAddressForWriting(ScratchRegister, target, &barrier);
+        storeBool(reg, addr, barrier);
     }
 
     void storeBool(bool value, IR::Expr *target) {
@@ -1475,8 +1515,9 @@ public:
         move(src, dest);
     }
 
-    void storeInt32(RegisterID reg, Pointer addr)
+    void storeInt32(RegisterID reg, Pointer addr, WriteBarrier::Type barrier)
     {
+        Q_UNUSED(barrier);
         store32(reg, addr);
         addr.offset += 4;
         store32(TrustedImm32(QV4::Primitive::fromInt32(0).tag()), addr);
@@ -1484,16 +1525,13 @@ public:
 
     void storeInt32(RegisterID reg, IR::Expr *target)
     {
-        if (IR::Temp *targetTemp = target->asTemp()) {
-            if (targetTemp->kind == IR::Temp::PhysicalRegister) {
-                move(reg, (RegisterID) targetTemp->index);
-            } else {
-                Pointer addr = loadTempAddress(targetTemp);
-                storeInt32(reg, addr);
-            }
-        } else if (IR::ArgLocal *al = target->asArgLocal()) {
-            Pointer addr = loadArgLocalAddress(ScratchRegister, al);
-            storeInt32(reg, addr);
+        IR::Temp *targetTemp = target->asTemp();
+        if (targetTemp && targetTemp->kind == IR::Temp::PhysicalRegister) {
+            move(reg, (RegisterID) targetTemp->index);
+        } else {
+            WriteBarrier::Type barrier;
+            Pointer addr = loadAddressForWriting(ScratchRegister, target, &barrier);
+            storeInt32(reg, addr, barrier);
         }
     }
 
@@ -1502,15 +1540,15 @@ public:
         move(src, dest);
     }
 
-    void storeUInt32(RegisterID reg, Pointer addr)
+    void storeUInt32(RegisterID reg, Pointer addr, WriteBarrier::Type barrier)
     {
         // The UInt32 representation in QV4::Value is really convoluted. See also toUInt32Register.
         Jump intRange = branch32(RelationalCondition::GreaterThanOrEqual, reg, TrustedImm32(0));
         convertUInt32ToDouble(reg, FPGpr0, ReturnValueRegister);
-        storeDouble(FPGpr0, addr);
+        storeDouble(FPGpr0, addr, barrier);
         Jump done = jump();
         intRange.link(this);
-        storeInt32(reg, addr);
+        storeInt32(reg, addr, barrier);
         done.link(this);
     }
 
@@ -1520,8 +1558,9 @@ public:
         if (targetTemp && targetTemp->kind == IR::Temp::PhysicalRegister) {
             move(reg, (RegisterID) targetTemp->index);
         } else {
-            Pointer addr = loadAddress(ScratchRegister, target);
-            storeUInt32(reg, addr);
+            WriteBarrier::Type barrier;
+            Pointer addr = loadAddressForWriting(ScratchRegister, target, &barrier);
+            storeUInt32(reg, addr, barrier);
         }
     }
 
@@ -1556,7 +1595,7 @@ public:
             if (t->kind == IR::Temp::PhysicalRegister)
                 return (RegisterID) t->index;
 
-        return toInt32Register(loadAddress(scratchReg, e), scratchReg);
+        return toInt32Register(loadAddressForReading(scratchReg, e), scratchReg);
     }
 
     RegisterID toInt32Register(Pointer addr, RegisterID scratchReg)
@@ -1576,7 +1615,7 @@ public:
             if (t->kind == IR::Temp::PhysicalRegister)
                 return (RegisterID) t->index;
 
-        return toUInt32Register(loadAddress(scratchReg, e), scratchReg);
+        return toUInt32Register(loadAddressForReading(scratchReg, e), scratchReg);
     }
 
     RegisterID toUInt32Register(Pointer addr, RegisterID scratchReg)
@@ -1648,31 +1687,31 @@ private:
 
 template <typename TargetConfiguration>
 template <typename Result, typename Source>
-void Assembler<TargetConfiguration>::copyValue(Result result, Source source)
+void Assembler<TargetConfiguration>::copyValue(Result result, Source source, WriteBarrier::Type barrier)
 {
-    RegisterSizeDependentOps::copyValueViaRegisters(this, source, result);
+    RegisterSizeDependentOps::copyValueViaRegisters(this, source, result, barrier);
 }
 
 template <typename TargetConfiguration>
 template <typename Result>
-void Assembler<TargetConfiguration>::copyValue(Result result, IR::Expr* source)
+void Assembler<TargetConfiguration>::copyValue(Result result, IR::Expr* source, WriteBarrier::Type barrier)
 {
     if (source->type == IR::BoolType) {
         RegisterID reg = toInt32Register(source, ScratchRegister);
-        storeBool(reg, result);
+        storeBool(reg, result, barrier);
     } else if (source->type == IR::SInt32Type) {
         RegisterID reg = toInt32Register(source, ScratchRegister);
-        storeInt32(reg, result);
+        storeInt32(reg, result, barrier);
     } else if (source->type == IR::UInt32Type) {
         RegisterID reg = toUInt32Register(source, ScratchRegister);
-        storeUInt32(reg, result);
+        storeUInt32(reg, result, barrier);
     } else if (source->type == IR::DoubleType) {
-        storeDouble(toDoubleRegister(source), result);
+        storeDouble(toDoubleRegister(source), result, barrier);
     } else if (source->asTemp() || source->asArgLocal()) {
-        RegisterSizeDependentOps::copyValueViaRegisters(this, source, result);
+        RegisterSizeDependentOps::copyValueViaRegisters(this, source, result, barrier);
     } else if (IR::Const *c = source->asConst()) {
         QV4::Primitive v = convertToValue(c);
-        storeValue(v, result);
+        storeValue(v, result, barrier);
     } else {
         Q_UNREACHABLE();
     }
diff --git a/src/qml/jit/qv4binop.cpp b/src/qml/jit/qv4binop.cpp
index 22067bbb13..0e180eb4cc 100644
--- a/src/qml/jit/qv4binop.cpp
+++ b/src/qml/jit/qv4binop.cpp
@@ -492,7 +492,7 @@ bool Binop<JITAssembler>::int32Binop(IR::Expr *leftSource, IR::Expr *rightSource
             return false;
         }
     } else if (inplaceOpWithAddress) { // All cases of X = X op [address-of-Y]
-        Pointer rhsAddr = as->loadAddress(JITAssembler::ScratchRegister, rightSource);
+        Pointer rhsAddr = as->loadAddressForReading(JITAssembler::ScratchRegister, rightSource);
         switch (op) {
         case IR::OpBitAnd: as->and32(rhsAddr, targetReg); break;
         case IR::OpBitOr:  as->or32 (rhsAddr, targetReg); break;
diff --git a/src/qml/jit/qv4isel_masm.cpp b/src/qml/jit/qv4isel_masm.cpp
index 6d3066aea1..f4bbedad43 100644
--- a/src/qml/jit/qv4isel_masm.cpp
+++ b/src/qml/jit/qv4isel_masm.cpp
@@ -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, qOffsetOf(QV4::ExecutionEngine, current)), JITTargetPlatform::ReturnValueRegister);
+    _as->loadPtr(Address(JITTargetPlatform::ReturnValueRegister, qOffsetOf(ExecutionContext::Data, callData)), JITTargetPlatform::ReturnValueRegister);
+    _as->copyValue(addr, Address(JITTargetPlatform::ReturnValueRegister, qOffsetOf(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>
@@ -713,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>
@@ -741,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;
         }
     }
@@ -759,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);
@@ -915,13 +920,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);
 
@@ -940,7 +945,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);
@@ -998,7 +1003,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);
@@ -1063,7 +1068,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)
@@ -1075,21 +1080,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);
@@ -1194,7 +1199,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));
@@ -1299,9 +1304,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;
@@ -1321,9 +1326,9 @@ int InstructionSelection<JITAssembler>::prepareCallData(IR::ExprList* args, IR::
     _as->store32(TrustedImm32(argc), p);
     p = _as->stackLayout().callDataAddress(qOffsetOf(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) {
@@ -1331,9 +1336,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;
 }
@@ -1451,7 +1456,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);
@@ -1534,7 +1539,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'
@@ -1583,7 +1588,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);
diff --git a/src/qml/jit/qv4isel_masm_p.h b/src/qml/jit/qv4isel_masm_p.h
index 5764c3946e..0d02284539 100644
--- a/src/qml/jit/qv4isel_masm_p.h
+++ b/src/qml/jit/qv4isel_masm_p.h
@@ -209,7 +209,7 @@ private:
                         _as->convertInt32ToDouble((RegisterID) sourceTemp->index,
                                                   (FPRegisterID) targetTemp->index);
                     } else {
-                        _as->convertInt32ToDouble(_as->loadAddress(JITTargetPlatform::ReturnValueRegister, sourceTemp),
+                        _as->convertInt32ToDouble(_as->loadAddressForReading(JITTargetPlatform::ReturnValueRegister, sourceTemp),
                                                   (FPRegisterID) targetTemp->index);
                     }
                 } else {
@@ -223,7 +223,7 @@ private:
 
         _as->convertInt32ToDouble(_as->toInt32Register(source, JITTargetPlatform::ScratchRegister),
                                   JITTargetPlatform::FPGpr0);
-        _as->storeDouble(JITTargetPlatform::FPGpr0, _as->loadAddress(JITTargetPlatform::ReturnValueRegister, target));
+        _as->storeDouble(JITTargetPlatform::FPGpr0, target);
     }
 
     void convertUIntToDouble(IR::Expr *source, IR::Expr *target)
@@ -240,7 +240,7 @@ private:
 
         _as->convertUInt32ToDouble(_as->toUInt32Register(source, tmpReg),
                                    JITTargetPlatform::FPGpr0, tmpReg);
-        _as->storeDouble(JITTargetPlatform::FPGpr0, _as->loadAddress(tmpReg, target));
+        _as->storeDouble(JITTargetPlatform::FPGpr0, target);
     }
 
     void convertIntToBool(IR::Expr *source, IR::Expr *target)
diff --git a/src/qml/memory/qv4writebarrier_p.h b/src/qml/memory/qv4writebarrier_p.h
index 1b4505c17f..c0f508f962 100644
--- a/src/qml/memory/qv4writebarrier_p.h
+++ b/src/qml/memory/qv4writebarrier_p.h
@@ -59,6 +59,11 @@ namespace QV4 {
 
 namespace WriteBarrier {
 
+enum Type {
+    NoBarrier,
+    Barrier
+};
+
 inline void write(QV4::ExecutionEngine *engine, QV4::Heap::Base *base, QV4::Value *slot, QV4::Value value)
 {
     Q_UNUSED(engine);