Changed JSC::MacroAssembler to be a template

Change-Id: If6edb7ed0fac51e93b218eb45c01274a87b9e904
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

6 files changed, 64 insertions, 32 deletions

diff --git a/src/3rdparty/masm/assembler/MacroAssembler.h b/src/3rdparty/masm/assembler/MacroAssembler.h
index 1fbca4c55b..1d0fa0003e 100644
--- a/src/3rdparty/masm/assembler/MacroAssembler.h
+++ b/src/3rdparty/masm/assembler/MacroAssembler.h
@@ -68,6 +68,7 @@ typedef MacroAssemblerSH4 MacroAssemblerBase;
 
 namespace JSC {
 
+template <typename MacroAssemblerBase>
 class MacroAssembler : public MacroAssemblerBase {
 public:
     using DoubleCondition = typename MacroAssemblerBase::DoubleCondition;
@@ -96,6 +97,18 @@ public:
     using MacroAssemblerBase::jump;
     using MacroAssemblerBase::branch32;
     using MacroAssemblerBase::move;
+    using MacroAssemblerBase::store32;
+    using MacroAssemblerBase::add32;
+    using MacroAssemblerBase::xor32;
+    using MacroAssemblerBase::sub32;
+    using MacroAssemblerBase::load32;
+#if CPU(X86_64) || CPU(ARM64)
+    using MacroAssemblerBase::add64;
+    using MacroAssemblerBase::sub64;
+    using MacroAssemblerBase::xor64;
+    using MacroAssemblerBase::load64;
+    using MacroAssemblerBase::store64;
+#endif
 
 #if ENABLE(JIT_CONSTANT_BLINDING)
     using MacroAssemblerBase::add32;
@@ -344,7 +357,7 @@ public:
     static const unsigned BlindingModulus = 64;
     bool shouldConsiderBlinding()
     {
-        return !(random() & (BlindingModulus - 1));
+        return !(this->random() & (BlindingModulus - 1));
     }
 
     // Ptr methods
@@ -1468,6 +1481,22 @@ public:
 #endif
 };
 
+#if CPU(ARM_THUMB2)
+typedef MacroAssembler<MacroAssemblerARMv7> DefaultMacroAssembler;
+#elif CPU(ARM64)
+typedef MacroAssembler<MacroAssemblerARM64> DefaultMacroAssembler;
+#elif CPU(ARM_TRADITIONAL)
+typedef MacroAssembler<MacroAssemblerARM> DefaultMacroAssembler;
+#elif CPU(MIPS)
+typedef MacroAssembler<MacroAssemblerMIPS> DefaultMacroAssembler;
+#elif CPU(X86)
+typedef MacroAssembler<MacroAssemblerX86> DefaultMacroAssembler;
+#elif CPU(X86_64)
+typedef MacroAssembler<MacroAssemblerX86_64> DefaultMacroAssembler;
+#elif CPU(SH4)
+typedef JSC::MacroAssemblerSH4 DefaultMacroAssembler;
+#endif
+
 } // namespace JSC
 
 #else // ENABLE(ASSEMBLER)
diff --git a/src/3rdparty/masm/assembler/MacroAssemblerARMv7.h b/src/3rdparty/masm/assembler/MacroAssemblerARMv7.h
index 73833c0ceb..9f5a089a75 100644
--- a/src/3rdparty/masm/assembler/MacroAssemblerARMv7.h
+++ b/src/3rdparty/masm/assembler/MacroAssemblerARMv7.h
@@ -526,7 +526,9 @@ public:
     // operand objects to loads and store will be implicitly constructed if a
     // register is passed.
 
-private:
+    // internal function, but public because of "using load32;" in template sub-classes to pull
+    // in the other public overloads.
+
     void load32(ArmAddress address, RegisterID dest)
     {
         if (address.type == ArmAddress::HasIndex)
@@ -541,6 +543,7 @@ private:
         }
     }
 
+private:
     void load16(ArmAddress address, RegisterID dest)
     {
         if (address.type == ArmAddress::HasIndex)
diff --git a/src/3rdparty/masm/yarr/YarrJIT.cpp b/src/3rdparty/masm/yarr/YarrJIT.cpp
index c6f2cdb91f..e4f2d97759 100644
--- a/src/3rdparty/masm/yarr/YarrJIT.cpp
+++ b/src/3rdparty/masm/yarr/YarrJIT.cpp
@@ -39,7 +39,7 @@ using namespace WTF;
 namespace JSC { namespace Yarr {
 
 template<YarrJITCompileMode compileMode>
-class YarrGenerator : private MacroAssembler {
+class YarrGenerator : private DefaultMacroAssembler {
     friend void jitCompile(JSGlobalData*, YarrCodeBlock& jitObject, const String& pattern, unsigned& numSubpatterns, const char*& error, bool ignoreCase, bool multiline);
 
 #if CPU(ARM)
@@ -599,7 +599,7 @@ class YarrGenerator : private MacroAssembler {
         }
 
         // Called at the end of code generation to link all return addresses.
-        void linkDataLabels(LinkBuffer<JSC::MacroAssembler>& linkBuffer)
+        void linkDataLabels(LinkBuffer<JSC::DefaultMacroAssembler>& linkBuffer)
         {
             ASSERT(isEmpty());
             for (unsigned i = 0; i < m_backtrackRecords.size(); ++i)
@@ -2676,7 +2676,7 @@ public:
         backtrack();
 
         // Link & finalize the code.
-        LinkBuffer<JSC::MacroAssembler> linkBuffer(*globalData, this, REGEXP_CODE_ID);
+        LinkBuffer<JSC::DefaultMacroAssembler> linkBuffer(*globalData, this, REGEXP_CODE_ID);
         m_backtrackingState.linkDataLabels(linkBuffer);
 
         if (compileMode == MatchOnly) {
diff --git a/src/qml/jit/qv4assembler.cpp b/src/qml/jit/qv4assembler.cpp
index 6203349e96..0aacacfb42 100644
--- a/src/qml/jit/qv4assembler.cpp
+++ b/src/qml/jit/qv4assembler.cpp
@@ -346,7 +346,7 @@ void Assembler::enterStandardStackFrame(const RegisterInformation &regularRegist
     for (int i = 0, ei = fpRegistersToSave.size(); i < ei; ++i) {
         Q_ASSERT(fpRegistersToSave.at(i).isFloatingPoint());
         slotAddr.offset -= sizeof(double);
-        JSC::MacroAssembler::storeDouble(fpRegistersToSave.at(i).reg<FPRegisterID>(), slotAddr);
+        JSC::MacroAssembler<PlatformMacroAssembler>::storeDouble(fpRegistersToSave.at(i).reg<FPRegisterID>(), slotAddr);
     }
     for (int i = 0, ei = regularRegistersToSave.size(); i < ei; ++i) {
         Q_ASSERT(regularRegistersToSave.at(i).isRegularRegister());
@@ -368,7 +368,7 @@ void Assembler::leaveStandardStackFrame(const RegisterInformation &regularRegist
     }
     for (int i = fpRegistersToSave.size() - 1; i >= 0; --i) {
         Q_ASSERT(fpRegistersToSave.at(i).isFloatingPoint());
-        JSC::MacroAssembler::loadDouble(slotAddr, fpRegistersToSave.at(i).reg<FPRegisterID>());
+        JSC::MacroAssembler<PlatformMacroAssembler>::loadDouble(slotAddr, fpRegistersToSave.at(i).reg<FPRegisterID>());
         slotAddr.offset += sizeof(double);
     }
 
@@ -465,9 +465,9 @@ Assembler::Jump Assembler::branchDouble(bool invertCondition, IR::AluOp op,
         Q_UNREACHABLE();
     }
     if (invertCondition)
-        cond = JSC::MacroAssembler::invert(cond);
+        cond = JSC::MacroAssembler<PlatformMacroAssembler>::invert(cond);
 
-    return JSC::MacroAssembler::branchDouble(cond, toDoubleRegister(left, FPGpr0), toDoubleRegister(right, FPGpr1));
+    return JSC::MacroAssembler<PlatformMacroAssembler>::branchDouble(cond, toDoubleRegister(left, FPGpr0), toDoubleRegister(right, FPGpr1));
 }
 
 Assembler::Jump Assembler::branchInt32(bool invertCondition, IR::AluOp op, IR::Expr *left, IR::Expr *right)
@@ -486,11 +486,11 @@ Assembler::Jump Assembler::branchInt32(bool invertCondition, IR::AluOp op, IR::E
         Q_UNREACHABLE();
     }
     if (invertCondition)
-        cond = JSC::MacroAssembler::invert(cond);
+        cond = JSC::MacroAssembler<PlatformMacroAssembler>::invert(cond);
 
-    return JSC::MacroAssembler::branch32(cond,
-                                         toInt32Register(left, Assembler::ScratchRegister),
-                                         toInt32Register(right, Assembler::ReturnValueRegister));
+    return JSC::MacroAssembler<PlatformMacroAssembler>::branch32(cond,
+                                                                 toInt32Register(left, Assembler::ScratchRegister),
+                                                                 toInt32Register(right, Assembler::ReturnValueRegister));
 }
 
 void Assembler::setStackLayout(int maxArgCountForBuiltins, int regularRegistersToSave, int fpRegistersToSave)
@@ -577,7 +577,7 @@ JSC::MacroAssemblerCodeRef Assembler::link(int *codeSize)
     }
 
     JSC::JSGlobalData dummy(_executableAllocator);
-    JSC::LinkBuffer<JSC::MacroAssembler> linkBuffer(dummy, this, 0);
+    JSC::LinkBuffer<JSC::MacroAssembler<PlatformMacroAssembler>> linkBuffer(dummy, this, 0);
 
     for (const DataLabelPatch &p : qAsConst(_dataLabelPatches))
         linkBuffer.patch(p.dataLabel, linkBuffer.locationOf(p.target));
diff --git a/src/qml/jit/qv4assembler_p.h b/src/qml/jit/qv4assembler_p.h
index 290668e8af..e40609eea6 100644
--- a/src/qml/jit/qv4assembler_p.h
+++ b/src/qml/jit/qv4assembler_p.h
@@ -90,29 +90,29 @@ struct CompilationUnit : public QV4::CompiledData::CompilationUnit
 };
 
 #if CPU(ARM_THUMB2)
-typedef JSC::MacroAssemblerARMv7 PlatformAssembler;
+typedef JSC::MacroAssemblerARMv7 PlatformMacroAssembler;
 #elif CPU(ARM64)
-typedef JSC::MacroAssemblerARM64 PlatformAssembler;
+typedef JSC::MacroAssemblerARM64 PlatformMacroAssembler;
 #elif CPU(ARM_TRADITIONAL)
-typedef JSC::MacroAssemblerARM PlatformAssembler;
+typedef JSC::MacroAssemblerARM PlatformMacroAssembler;
 #elif CPU(MIPS)
-typedef JSC::MacroAssemblerMIPS PlatformAssembler;
+typedef JSC::MacroAssemblerMIPS PlatformMacroAssembler;
 #elif CPU(X86)
-typedef JSC::MacroAssemblerX86 PlatformAssembler;
+typedef JSC::MacroAssemblerX86 PlatformMacroAssembler;
 #elif CPU(X86_64)
-typedef JSC::MacroAssemblerX86_64 PlatformAssembler;
+typedef JSC::MacroAssemblerX86_64 PlatformMacroAssembler;
 #elif CPU(SH4)
-typedef JSC::MacroAssemblerSH4 PlatformAssembler;
+typedef JSC::MacroAssemblerSH4 PlatformMacroAssembler;
 #endif
 
-class Assembler : public JSC::MacroAssembler, public TargetPlatform<PlatformAssembler>
+class Assembler : public JSC::MacroAssembler<PlatformMacroAssembler>, public TargetPlatform<PlatformMacroAssembler>
 {
     Q_DISABLE_COPY(Assembler)
 
 public:
     Assembler(QV4::Compiler::JSUnitGenerator *jsGenerator, IR::Function* function, QV4::ExecutableAllocator *executableAllocator);
 
-    typedef JSC::MacroAssembler MacroAssembler;
+    using MacroAssembler = JSC::MacroAssembler<PlatformMacroAssembler>;
     using RegisterID = MacroAssembler::RegisterID;
     using FPRegisterID = MacroAssembler::FPRegisterID;
 
@@ -697,8 +697,8 @@ public:
         store64(ReturnValueRegister, addr);
     }
 #else
-    using JSC::MacroAssembler::loadDouble;
-    using JSC::MacroAssembler::storeDouble;
+    using JSC::MacroAssembler<PlatformMacroAssembler>::loadDouble;
+    using JSC::MacroAssembler<PlatformMacroAssembler>::storeDouble;
 #endif
 
     template <typename Result, typename Source>
@@ -711,8 +711,8 @@ public:
     {
         Q_ASSERT(!source->asTemp() || source->asTemp()->kind != IR::Temp::PhysicalRegister);
         Q_ASSERT(target.base != scratchRegister);
-        JSC::MacroAssembler::loadDouble(loadAddress(scratchRegister, source), FPGpr0);
-        JSC::MacroAssembler::storeDouble(FPGpr0, target);
+        JSC::MacroAssembler<PlatformMacroAssembler>::loadDouble(loadAddress(scratchRegister, source), FPGpr0);
+        JSC::MacroAssembler<PlatformMacroAssembler>::storeDouble(FPGpr0, target);
     }
 
     void storeValue(QV4::Primitive value, RegisterID destination)
@@ -1007,7 +1007,7 @@ public:
             move(TrustedImm64(i), ReturnValueRegister);
             move64ToDouble(ReturnValueRegister, target);
 #else
-            JSC::MacroAssembler::loadDouble(loadConstant(c, ScratchRegister), target);
+            JSC::MacroAssembler<PlatformMacroAssembler>::loadDouble(loadConstant(c, ScratchRegister), target);
 #endif
             return target;
         }
diff --git a/src/qml/jit/qv4isel_masm.cpp b/src/qml/jit/qv4isel_masm.cpp
index ae63da28a2..7a570d0b6b 100644
--- a/src/qml/jit/qv4isel_masm.cpp
+++ b/src/qml/jit/qv4isel_masm.cpp
@@ -735,10 +735,10 @@ void InstructionSelection::swapValues(IR::Expr *source, IR::Expr *target)
             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
-            _as->JSC::MacroAssembler::loadDouble(sAddr, JITTargetPlatform::FPGpr0);
-            _as->JSC::MacroAssembler::loadDouble(tAddr, Assembler::FPGpr1);
-            _as->JSC::MacroAssembler::storeDouble(Assembler::FPGpr1, sAddr);
-            _as->JSC::MacroAssembler::storeDouble(JITTargetPlatform::FPGpr0, tAddr);
+            _as->JSC::MacroAssembler<PlatformMacroAssembler>::loadDouble(sAddr, JITTargetPlatform::FPGpr0);
+            _as->JSC::MacroAssembler<PlatformMacroAssembler>::loadDouble(tAddr, JITTargetPlatform::FPGpr1);
+            _as->JSC::MacroAssembler<PlatformMacroAssembler>::storeDouble(JITTargetPlatform::FPGpr1, sAddr);
+            _as->JSC::MacroAssembler<PlatformMacroAssembler>::storeDouble(JITTargetPlatform::FPGpr0, tAddr);
             return;
         }
     }