diff --git a/src/3rdparty/javascriptcore/JavaScriptCore/jit/JIT.cpp b/src/3rdparty/javascriptcore/JavaScriptCore/jit/JIT.cpp
index ea8434e..6cb66e5 100644
--- a/src/3rdparty/javascriptcore/JavaScriptCore/jit/JIT.cpp
+++ b/src/3rdparty/javascriptcore/JavaScriptCore/jit/JIT.cpp
@@ -97,7 +97,7 @@ JIT::JIT(JSGlobalData* globalData, CodeBlock* codeBlock)
 void JIT::emitTimeoutCheck()
 {
     Jump skipTimeout = branchSub32(NonZero, Imm32(1), timeoutCheckRegister);
-    JITStubCall stubCall(this, cti_timeout_check);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_timeout_check));
     stubCall.addArgument(regT1, regT0); // save last result registers.
     stubCall.call(timeoutCheckRegister);
     stubCall.getArgument(0, regT1, regT0); // reload last result registers.
@@ -107,7 +107,7 @@ void JIT::emitTimeoutCheck()
 void JIT::emitTimeoutCheck()
 {
     Jump skipTimeout = branchSub32(NonZero, Imm32(1), timeoutCheckRegister);
-    JITStubCall(this, cti_timeout_check).call(timeoutCheckRegister);
+    JITStubCall(this, JIT_STUB_NAME(cti_timeout_check)).call(timeoutCheckRegister);
     skipTimeout.link(this);
 
     killLastResultRegister();
@@ -121,7 +121,7 @@ void JIT::emitTimeoutCheck()
 #if USE(JSVALUE32_64)
 #define DEFINE_BINARY_OP(name) \
     case name: { \
-        JITStubCall stubCall(this, cti_##name); \
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_##name)); \
         stubCall.addArgument(currentInstruction[2].u.operand); \
         stubCall.addArgument(currentInstruction[3].u.operand); \
         stubCall.call(currentInstruction[1].u.operand); \
@@ -130,7 +130,7 @@ void JIT::emitTimeoutCheck()
 
 #define DEFINE_UNARY_OP(name) \
     case name: { \
-        JITStubCall stubCall(this, cti_##name); \
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_##name)); \
         stubCall.addArgument(currentInstruction[2].u.operand); \
         stubCall.call(currentInstruction[1].u.operand); \
         NEXT_OPCODE(name); \
@@ -140,7 +140,7 @@ void JIT::emitTimeoutCheck()
 
 #define DEFINE_BINARY_OP(name) \
     case name: { \
-        JITStubCall stubCall(this, cti_##name); \
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_##name)); \
         stubCall.addArgument(currentInstruction[2].u.operand, regT2); \
         stubCall.addArgument(currentInstruction[3].u.operand, regT2); \
         stubCall.call(currentInstruction[1].u.operand); \
@@ -149,7 +149,7 @@ void JIT::emitTimeoutCheck()
 
 #define DEFINE_UNARY_OP(name) \
     case name: { \
-        JITStubCall stubCall(this, cti_##name); \
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_##name)); \
         stubCall.addArgument(currentInstruction[2].u.operand, regT2); \
         stubCall.call(currentInstruction[1].u.operand); \
         NEXT_OPCODE(name); \
@@ -469,7 +469,7 @@ JITCode JIT::privateCompile()
     if (m_codeBlock->codeType() == FunctionCode) {
         slowRegisterFileCheck.link(this);
         m_bytecodeIndex = 0;
-        JITStubCall(this, cti_register_file_check).call();
+        JITStubCall(this, JIT_STUB_NAME(cti_register_file_check)).call();
 #ifndef NDEBUG
         m_bytecodeIndex = (unsigned)-1; // Reset this, in order to guard its use with ASSERTs.
 #endif
diff --git a/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITArithmetic.cpp b/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITArithmetic.cpp
index 7afc1f2..8fbfe26 100644
--- a/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITArithmetic.cpp
+++ b/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITArithmetic.cpp
@@ -80,7 +80,7 @@ void JIT::emitSlow_op_negate(Instruction* currentInstruction, Vector<SlowCaseEnt
     linkSlowCase(iter); // 0 check
     linkSlowCase(iter); // double check
 
-    JITStubCall stubCall(this, cti_op_negate);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_negate));
     stubCall.addArgument(regT1, regT0);
     stubCall.call(dst);
 }
@@ -141,7 +141,7 @@ void JIT::emitSlow_op_jnless(Instruction* currentInstruction, Vector<SlowCaseEnt
             linkSlowCase(iter); // double check
     }
 
-    JITStubCall stubCall(this, cti_op_jless);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_jless));
     stubCall.addArgument(op1);
     stubCall.addArgument(op2);
     stubCall.call();
@@ -204,7 +204,7 @@ void JIT::emitSlow_op_jnlesseq(Instruction* currentInstruction, Vector<SlowCaseE
             linkSlowCase(iter); // double check
     }
 
-    JITStubCall stubCall(this, cti_op_jlesseq);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_jlesseq));
     stubCall.addArgument(op1);
     stubCall.addArgument(op2);
     stubCall.call();
@@ -245,7 +245,7 @@ void JIT::emitSlow_op_lshift(Instruction* currentInstruction, Vector<SlowCaseEnt
         linkSlowCase(iter); // int32 check
     linkSlowCase(iter); // int32 check
 
-    JITStubCall stubCall(this, cti_op_lshift);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_lshift));
     stubCall.addArgument(op1);
     stubCall.addArgument(op2);
     stubCall.call(dst);
@@ -285,7 +285,7 @@ void JIT::emitSlow_op_rshift(Instruction* currentInstruction, Vector<SlowCaseEnt
         linkSlowCase(iter); // int32 check
     linkSlowCase(iter); // int32 check
 
-    JITStubCall stubCall(this, cti_op_rshift);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_rshift));
     stubCall.addArgument(op1);
     stubCall.addArgument(op2);
     stubCall.call(dst);
@@ -326,7 +326,7 @@ void JIT::emitSlow_op_bitand(Instruction* currentInstruction, Vector<SlowCaseEnt
         linkSlowCase(iter); // int32 check
     linkSlowCase(iter); // int32 check
 
-    JITStubCall stubCall(this, cti_op_bitand);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_bitand));
     stubCall.addArgument(op1);
     stubCall.addArgument(op2);
     stubCall.call(dst);
@@ -367,7 +367,7 @@ void JIT::emitSlow_op_bitor(Instruction* currentInstruction, Vector<SlowCaseEntr
         linkSlowCase(iter); // int32 check
     linkSlowCase(iter); // int32 check
 
-    JITStubCall stubCall(this, cti_op_bitor);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_bitor));
     stubCall.addArgument(op1);
     stubCall.addArgument(op2);
     stubCall.call(dst);
@@ -408,7 +408,7 @@ void JIT::emitSlow_op_bitxor(Instruction* currentInstruction, Vector<SlowCaseEnt
         linkSlowCase(iter); // int32 check
     linkSlowCase(iter); // int32 check
 
-    JITStubCall stubCall(this, cti_op_bitxor);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_bitxor));
     stubCall.addArgument(op1);
     stubCall.addArgument(op2);
     stubCall.call(dst);
@@ -434,7 +434,7 @@ void JIT::emitSlow_op_bitnot(Instruction* currentInstruction, Vector<SlowCaseEnt
 
     linkSlowCase(iter); // int32 check
 
-    JITStubCall stubCall(this, cti_op_bitnot);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_bitnot));
     stubCall.addArgument(regT1, regT0);
     stubCall.call(dst);
 }
@@ -467,7 +467,7 @@ void JIT::emitSlow_op_post_inc(Instruction* currentInstruction, Vector<SlowCaseE
     if (dst != srcDst)
         linkSlowCase(iter); // overflow check
 
-    JITStubCall stubCall(this, cti_op_post_inc);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_post_inc));
     stubCall.addArgument(srcDst);
     stubCall.addArgument(Imm32(srcDst));
     stubCall.call(dst);
@@ -501,7 +501,7 @@ void JIT::emitSlow_op_post_dec(Instruction* currentInstruction, Vector<SlowCaseE
     if (dst != srcDst)
         linkSlowCase(iter); // overflow check
 
-    JITStubCall stubCall(this, cti_op_post_dec);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_post_dec));
     stubCall.addArgument(srcDst);
     stubCall.addArgument(Imm32(srcDst));
     stubCall.call(dst);
@@ -527,7 +527,7 @@ void JIT::emitSlow_op_pre_inc(Instruction* currentInstruction, Vector<SlowCaseEn
     linkSlowCase(iter); // int32 check
     linkSlowCase(iter); // overflow check
 
-    JITStubCall stubCall(this, cti_op_pre_inc);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_pre_inc));
     stubCall.addArgument(srcDst);
     stubCall.call(srcDst);
 }
@@ -552,7 +552,7 @@ void JIT::emitSlow_op_pre_dec(Instruction* currentInstruction, Vector<SlowCaseEn
     linkSlowCase(iter); // int32 check
     linkSlowCase(iter); // overflow check
 
-    JITStubCall stubCall(this, cti_op_pre_dec);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_pre_dec));
     stubCall.addArgument(srcDst);
     stubCall.call(srcDst);
 }
@@ -567,7 +567,7 @@ void JIT::emit_op_add(Instruction* currentInstruction)
     OperandTypes types = OperandTypes::fromInt(currentInstruction[4].u.operand);
 
     if (!types.first().mightBeNumber() || !types.second().mightBeNumber()) {
-        JITStubCall stubCall(this, cti_op_add);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_add));
         stubCall.addArgument(op1);
         stubCall.addArgument(op2);
         stubCall.call(dst);
@@ -670,7 +670,7 @@ void JIT::emitSlow_op_add(Instruction* currentInstruction, Vector<SlowCaseEntry>
         }
     }
 
-    JITStubCall stubCall(this, cti_op_add);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_add));
     stubCall.addArgument(op1);
     stubCall.addArgument(op2);
     stubCall.call(dst);
@@ -769,7 +769,7 @@ void JIT::emitSlow_op_sub(Instruction* currentInstruction, Vector<SlowCaseEntry>
         }
     }
 
-    JITStubCall stubCall(this, cti_op_sub);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_sub));
     stubCall.addArgument(op1);
     stubCall.addArgument(op2);
     stubCall.call(dst);
@@ -964,7 +964,7 @@ void JIT::emitSlow_op_mul(Instruction* currentInstruction, Vector<SlowCaseEntry>
     }
 
     Label jitStubCall(this);
-    JITStubCall stubCall(this, cti_op_mul);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_mul));
     stubCall.addArgument(op1);
     stubCall.addArgument(op2);
     stubCall.call(dst);
@@ -1044,7 +1044,7 @@ void JIT::emitSlow_op_div(Instruction* currentInstruction, Vector<SlowCaseEntry>
         }
     }
 
-    JITStubCall stubCall(this, cti_op_div);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_div));
     stubCall.addArgument(op1);
     stubCall.addArgument(op2);
     stubCall.call(dst);
@@ -1110,7 +1110,7 @@ void JIT::emitSlow_op_mod(Instruction* currentInstruction, Vector<SlowCaseEntry>
         linkSlowCase(iter); // 0x80000000 check
     }
 
-    JITStubCall stubCall(this, cti_op_mod);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_mod));
     stubCall.addArgument(op1);
     stubCall.addArgument(op2);
     stubCall.call(dst);
@@ -1124,7 +1124,7 @@ void JIT::emit_op_mod(Instruction* currentInstruction)
     unsigned op1 = currentInstruction[2].u.operand;
     unsigned op2 = currentInstruction[3].u.operand;
 
-    JITStubCall stubCall(this, cti_op_mod);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_mod));
     stubCall.addArgument(op1);
     stubCall.addArgument(op2);
     stubCall.call(dst);
@@ -1186,7 +1186,7 @@ void JIT::emitSlow_op_lshift(Instruction* currentInstruction, Vector<SlowCaseEnt
     notImm1.link(this);
     notImm2.link(this);
 #endif
-    JITStubCall stubCall(this, cti_op_lshift);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_lshift));
     stubCall.addArgument(regT0);
     stubCall.addArgument(regT2);
     stubCall.call(result);
@@ -1259,7 +1259,7 @@ void JIT::emitSlow_op_rshift(Instruction* currentInstruction, Vector<SlowCaseEnt
     unsigned op1 = currentInstruction[2].u.operand;
     unsigned op2 = currentInstruction[3].u.operand;
 
-    JITStubCall stubCall(this, cti_op_rshift);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_rshift));
 
     if (isOperandConstantImmediateInt(op2)) {
         linkSlowCase(iter);
@@ -1378,7 +1378,7 @@ void JIT::emitSlow_op_jnless(Instruction* currentInstruction, Vector<SlowCaseEnt
 #endif
         }
 
-        JITStubCall stubCall(this, cti_op_jless);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_jless));
         stubCall.addArgument(regT0);
         stubCall.addArgument(op2, regT2);
         stubCall.call();
@@ -1419,7 +1419,7 @@ void JIT::emitSlow_op_jnless(Instruction* currentInstruction, Vector<SlowCaseEnt
 #endif
         }
 
-        JITStubCall stubCall(this, cti_op_jless);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_jless));
         stubCall.addArgument(op1, regT2);
         stubCall.addArgument(regT1);
         stubCall.call();
@@ -1471,7 +1471,7 @@ void JIT::emitSlow_op_jnless(Instruction* currentInstruction, Vector<SlowCaseEnt
         }
 
         linkSlowCase(iter);
-        JITStubCall stubCall(this, cti_op_jless);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_jless));
         stubCall.addArgument(regT0);
         stubCall.addArgument(regT1);
         stubCall.call();
@@ -1563,7 +1563,7 @@ void JIT::emitSlow_op_jnlesseq(Instruction* currentInstruction, Vector<SlowCaseE
 #endif
         }
 
-        JITStubCall stubCall(this, cti_op_jlesseq);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_jlesseq));
         stubCall.addArgument(regT0);
         stubCall.addArgument(op2, regT2);
         stubCall.call();
@@ -1604,7 +1604,7 @@ void JIT::emitSlow_op_jnlesseq(Instruction* currentInstruction, Vector<SlowCaseE
 #endif
         }
 
-        JITStubCall stubCall(this, cti_op_jlesseq);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_jlesseq));
         stubCall.addArgument(op1, regT2);
         stubCall.addArgument(regT1);
         stubCall.call();
@@ -1656,7 +1656,7 @@ void JIT::emitSlow_op_jnlesseq(Instruction* currentInstruction, Vector<SlowCaseE
         }
 
         linkSlowCase(iter);
-        JITStubCall stubCall(this, cti_op_jlesseq);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_jlesseq));
         stubCall.addArgument(regT0);
         stubCall.addArgument(regT1);
         stubCall.call();
@@ -1708,17 +1708,17 @@ void JIT::emitSlow_op_bitand(Instruction* currentInstruction, Vector<SlowCaseEnt
 
     linkSlowCase(iter);
     if (isOperandConstantImmediateInt(op1)) {
-        JITStubCall stubCall(this, cti_op_bitand);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_bitand));
         stubCall.addArgument(op1, regT2);
         stubCall.addArgument(regT0);
         stubCall.call(result);
     } else if (isOperandConstantImmediateInt(op2)) {
-        JITStubCall stubCall(this, cti_op_bitand);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_bitand));
         stubCall.addArgument(regT0);
         stubCall.addArgument(op2, regT2);
         stubCall.call(result);
     } else {
-        JITStubCall stubCall(this, cti_op_bitand);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_bitand));
         stubCall.addArgument(op1, regT2);
         stubCall.addArgument(regT1);
         stubCall.call(result);
@@ -1751,7 +1751,7 @@ void JIT::emitSlow_op_post_inc(Instruction* currentInstruction, Vector<SlowCaseE
 
     linkSlowCase(iter);
     linkSlowCase(iter);
-    JITStubCall stubCall(this, cti_op_post_inc);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_post_inc));
     stubCall.addArgument(regT0);
     stubCall.addArgument(Imm32(srcDst));
     stubCall.call(result);
@@ -1783,7 +1783,7 @@ void JIT::emitSlow_op_post_dec(Instruction* currentInstruction, Vector<SlowCaseE
 
     linkSlowCase(iter);
     linkSlowCase(iter);
-    JITStubCall stubCall(this, cti_op_post_dec);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_post_dec));
     stubCall.addArgument(regT0);
     stubCall.addArgument(Imm32(srcDst));
     stubCall.call(result);
@@ -1813,7 +1813,7 @@ void JIT::emitSlow_op_pre_inc(Instruction* currentInstruction, Vector<SlowCaseEn
     linkSlowCase(iter);
     emitGetVirtualRegister(srcDst, regT0);
     notImm.link(this);
-    JITStubCall stubCall(this, cti_op_pre_inc);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_pre_inc));
     stubCall.addArgument(regT0);
     stubCall.call(srcDst);
 }
@@ -1842,7 +1842,7 @@ void JIT::emitSlow_op_pre_dec(Instruction* currentInstruction, Vector<SlowCaseEn
     linkSlowCase(iter);
     emitGetVirtualRegister(srcDst, regT0);
     notImm.link(this);
-    JITStubCall stubCall(this, cti_op_pre_dec);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_pre_dec));
     stubCall.addArgument(regT0);
     stubCall.call(srcDst);
 }
@@ -1892,7 +1892,7 @@ void JIT::emitSlow_op_mod(Instruction* currentInstruction, Vector<SlowCaseEntry>
     notImm1.link(this);
     notImm2.link(this);
 #endif
-    JITStubCall stubCall(this, cti_op_mod);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_mod));
     stubCall.addArgument(X86Registers::eax);
     stubCall.addArgument(X86Registers::ecx);
     stubCall.call(result);
@@ -1906,7 +1906,7 @@ void JIT::emit_op_mod(Instruction* currentInstruction)
     unsigned op1 = currentInstruction[2].u.operand;
     unsigned op2 = currentInstruction[3].u.operand;
 
-    JITStubCall stubCall(this, cti_op_mod);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_mod));
     stubCall.addArgument(op1, regT2);
     stubCall.addArgument(op2, regT2);
     stubCall.call(result);
@@ -1964,7 +1964,7 @@ void JIT::compileBinaryArithOpSlowCase(OpcodeID opcodeID, Vector<SlowCaseEntry>:
     emitGetVirtualRegister(op1, regT0);
 
     Label stubFunctionCall(this);
-    JITStubCall stubCall(this, opcodeID == op_add ? cti_op_add : opcodeID == op_sub ? cti_op_sub : cti_op_mul);
+    JITStubCall stubCall(this, opcodeID == op_add ? JIT_STUB_NAME(cti_op_add) : opcodeID == op_sub ? JIT_STUB_NAME(cti_op_sub) : JIT_STUB_NAME(cti_op_mul));
     if (op1HasImmediateIntFastCase || op2HasImmediateIntFastCase) {
         emitGetVirtualRegister(op1, regT0);
         emitGetVirtualRegister(op2, regT1);
@@ -2039,7 +2039,7 @@ void JIT::emit_op_add(Instruction* currentInstruction)
     OperandTypes types = OperandTypes::fromInt(currentInstruction[4].u.operand);
 
     if (!types.first().mightBeNumber() || !types.second().mightBeNumber()) {
-        JITStubCall stubCall(this, cti_op_add);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_add));
         stubCall.addArgument(op1, regT2);
         stubCall.addArgument(op2, regT2);
         stubCall.call(result);
@@ -2205,7 +2205,7 @@ void JIT::emitSlow_op_div(Instruction* currentInstruction, Vector<SlowCaseEntry>
             linkSlowCase(iter);
     }
     // There is an extra slow case for (op1 * -N) or (-N * op2), to check for 0 since this should produce a result of -0.
-    JITStubCall stubCall(this, cti_op_div);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_div));
     stubCall.addArgument(op1, regT2);
     stubCall.addArgument(op2, regT2);
     stubCall.call(result);
@@ -2401,7 +2401,7 @@ void JIT::compileBinaryArithOpSlowCase(OpcodeID opcodeID, Vector<SlowCaseEntry>:
     if (opcodeID == op_mul)
         linkSlowCase(iter);
 
-    JITStubCall stubCall(this, opcodeID == op_add ? cti_op_add : opcodeID == op_sub ? cti_op_sub : cti_op_mul);
+    JITStubCall stubCall(this, opcodeID == op_add ? JIT_STUB_NAME(cti_op_add) : opcodeID == op_sub ? JIT_STUB_NAME(cti_op_sub) : JIT_STUB_NAME(cti_op_mul));
     stubCall.addArgument(src1, regT2);
     stubCall.addArgument(src2, regT2);
     stubCall.call(dst);
@@ -2415,7 +2415,7 @@ void JIT::emit_op_add(Instruction* currentInstruction)
     OperandTypes types = OperandTypes::fromInt(currentInstruction[4].u.operand);
 
     if (!types.first().mightBeNumber() || !types.second().mightBeNumber()) {
-        JITStubCall stubCall(this, cti_op_add);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_add));
         stubCall.addArgument(op1, regT2);
         stubCall.addArgument(op2, regT2);
         stubCall.call(result);
@@ -2454,7 +2454,7 @@ void JIT::emitSlow_op_add(Instruction* currentInstruction, Vector<SlowCaseEntry>
         linkSlowCase(iter);
         sub32(Imm32(getConstantOperandImmediateInt(op1) << JSImmediate::IntegerPayloadShift), regT0);
         notImm.link(this);
-        JITStubCall stubCall(this, cti_op_add);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_add));
         stubCall.addArgument(op1, regT2);
         stubCall.addArgument(regT0);
         stubCall.call(result);
@@ -2463,7 +2463,7 @@ void JIT::emitSlow_op_add(Instruction* currentInstruction, Vector<SlowCaseEntry>
         linkSlowCase(iter);
         sub32(Imm32(getConstantOperandImmediateInt(op2) << JSImmediate::IntegerPayloadShift), regT0);
         notImm.link(this);
-        JITStubCall stubCall(this, cti_op_add);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_add));
         stubCall.addArgument(regT0);
         stubCall.addArgument(op2, regT2);
         stubCall.call(result);
@@ -2513,7 +2513,7 @@ void JIT::emitSlow_op_mul(Instruction* currentInstruction, Vector<SlowCaseEntry>
         linkSlowCase(iter);
         linkSlowCase(iter);
         // There is an extra slow case for (op1 * -N) or (-N * op2), to check for 0 since this should produce a result of -0.
-        JITStubCall stubCall(this, cti_op_mul);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_mul));
         stubCall.addArgument(op1, regT2);
         stubCall.addArgument(op2, regT2);
         stubCall.call(result);
diff --git a/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITCall.cpp b/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITCall.cpp
index f4f6e62..3ad0e3a 100644
--- a/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITCall.cpp
+++ b/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITCall.cpp
@@ -129,7 +129,7 @@ void JIT::compileOpCallVarargsSlowCase(Instruction* instruction, Vector<SlowCase
     linkSlowCaseIfNotJSCell(iter, callee);
     linkSlowCase(iter);
 
-    JITStubCall stubCall(this, cti_op_call_NotJSFunction);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_call_NotJSFunction));
     stubCall.call(dst); // In the interpreter, the callee puts the return value in dst.
 
     map(m_bytecodeIndex + OPCODE_LENGTH(op_call_varargs), dst, regT1, regT0);
@@ -141,14 +141,14 @@ void JIT::emit_op_ret(Instruction* currentInstruction)
     unsigned dst = currentInstruction[1].u.operand;
 
 #ifdef QT_BUILD_SCRIPT_LIB
-    JITStubCall stubCall(this, cti_op_debug_return);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_debug_return));
     stubCall.addArgument(Imm32(dst));
     stubCall.call();
 #endif
 
     // We could JIT generate the deref, only calling out to C when the refcount hits zero.
     if (m_codeBlock->needsFullScopeChain())
-        JITStubCall(this, cti_op_ret_scopeChain).call();
+        JITStubCall(this, JIT_STUB_NAME(cti_op_ret_scopeChain)).call();
 
     emitLoad(dst, regT1, regT0);
     emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT2);
@@ -214,7 +214,7 @@ void JIT::emit_op_load_varargs(Instruction* currentInstruction)
     int argCountDst = currentInstruction[1].u.operand;
     int argsOffset = currentInstruction[2].u.operand;
 
-    JITStubCall stubCall(this, cti_op_load_varargs);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_load_varargs));
     stubCall.addArgument(Imm32(argsOffset));
     stubCall.call();
     // Stores a naked int32 in the register file.
@@ -244,7 +244,7 @@ void JIT::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned)
 
     Jump wasEval;
     if (opcodeID == op_call_eval) {
-        JITStubCall stubCall(this, cti_op_call_eval);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_call_eval));
         stubCall.addArgument(callee);
         stubCall.addArgument(JIT::Imm32(registerOffset));
         stubCall.addArgument(JIT::Imm32(argCount));
@@ -264,7 +264,7 @@ void JIT::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned)
 
     // First, in the case of a construct, allocate the new object.
     if (opcodeID == op_construct) {
-        JITStubCall(this, cti_op_construct_JSConstruct).call(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
+        JITStubCall(this, JIT_STUB_NAME(cti_op_construct_JSConstruct)).call(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
         emitLoad(callee, regT1, regT2);
     }
 
@@ -291,7 +291,7 @@ void JIT::compileOpCallSlowCase(Instruction* instruction, Vector<SlowCaseEntry>:
     linkSlowCaseIfNotJSCell(iter, callee);
     linkSlowCase(iter);
 
-    JITStubCall stubCall(this, opcodeID == op_construct ? cti_op_construct_NotJSConstruct : cti_op_call_NotJSFunction);
+    JITStubCall stubCall(this, opcodeID == op_construct ? JIT_STUB_NAME(cti_op_construct_NotJSConstruct) : JIT_STUB_NAME(cti_op_call_NotJSFunction));
     stubCall.call(dst); // In the interpreter, the callee puts the return value in dst.
 
     sampleCodeBlock(m_codeBlock);
@@ -310,7 +310,7 @@ void JIT::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned ca
 
     Jump wasEval;
     if (opcodeID == op_call_eval) {
-        JITStubCall stubCall(this, cti_op_call_eval);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_call_eval));
         stubCall.addArgument(callee);
         stubCall.addArgument(JIT::Imm32(registerOffset));
         stubCall.addArgument(JIT::Imm32(argCount));
@@ -335,7 +335,7 @@ void JIT::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned ca
         int proto = instruction[5].u.operand;
         int thisRegister = instruction[6].u.operand;
 
-        JITStubCall stubCall(this, cti_op_construct_JSConstruct);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_construct_JSConstruct));
         stubCall.addArgument(regT1, regT0);
         stubCall.addArgument(Imm32(0)); // FIXME: Remove this unused JITStub argument.
         stubCall.addArgument(Imm32(0)); // FIXME: Remove this unused JITStub argument.
@@ -391,7 +391,7 @@ void JIT::compileOpCallSlowCase(Instruction* instruction, Vector<SlowCaseEntry>:
 
     // First, in the case of a construct, allocate the new object.
     if (opcodeID == op_construct) {
-        JITStubCall(this, cti_op_construct_JSConstruct).call(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
+        JITStubCall(this, JIT_STUB_NAME(cti_op_construct_JSConstruct)).call(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
         emitLoad(callee, regT1, regT0);
     }
 
@@ -418,7 +418,7 @@ void JIT::compileOpCallSlowCase(Instruction* instruction, Vector<SlowCaseEntry>:
     // This handles host functions
     callLinkFailNotObject.link(this);
     callLinkFailNotJSFunction.link(this);
-    JITStubCall(this, opcodeID == op_construct ? cti_op_construct_NotJSConstruct : cti_op_call_NotJSFunction).call();
+    JITStubCall(this, opcodeID == op_construct ? JIT_STUB_NAME(cti_op_construct_NotJSConstruct) : JIT_STUB_NAME(cti_op_call_NotJSFunction)).call();
 
     emitStore(dst, regT1, regT0);;
     sampleCodeBlock(m_codeBlock);
@@ -513,7 +513,7 @@ void JIT::compileOpCallVarargsSlowCase(Instruction* instruction, Vector<SlowCase
     
     linkSlowCase(iter);
     linkSlowCase(iter);
-    JITStubCall stubCall(this, cti_op_call_NotJSFunction);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_call_NotJSFunction));
     stubCall.call(dst); // In the interpreter, the callee puts the return value in dst.
     
     sampleCodeBlock(m_codeBlock);
@@ -533,7 +533,7 @@ void JIT::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned)
     // Handle eval
     Jump wasEval;
     if (opcodeID == op_call_eval) {
-        JITStubCall stubCall(this, cti_op_call_eval);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_call_eval));
         stubCall.addArgument(callee, regT0);
         stubCall.addArgument(JIT::Imm32(registerOffset));
         stubCall.addArgument(JIT::Imm32(argCount));
@@ -554,7 +554,7 @@ void JIT::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned)
 
     // First, in the case of a construct, allocate the new object.
     if (opcodeID == op_construct) {
-        JITStubCall(this, cti_op_construct_JSConstruct).call(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
+        JITStubCall(this, JIT_STUB_NAME(cti_op_construct_JSConstruct)).call(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
         emitGetVirtualRegister(callee, regT0);
     }
 
@@ -580,7 +580,7 @@ void JIT::compileOpCallSlowCase(Instruction* instruction, Vector<SlowCaseEntry>:
 
     linkSlowCase(iter);
     linkSlowCase(iter);
-    JITStubCall stubCall(this, opcodeID == op_construct ? cti_op_construct_NotJSConstruct : cti_op_call_NotJSFunction);
+    JITStubCall stubCall(this, opcodeID == op_construct ? JIT_STUB_NAME(cti_op_construct_NotJSConstruct) : JIT_STUB_NAME(cti_op_call_NotJSFunction));
     stubCall.call(dst); // In the interpreter, the callee puts the return value in dst.
 
     sampleCodeBlock(m_codeBlock);
@@ -600,7 +600,7 @@ void JIT::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned ca
     // Handle eval
     Jump wasEval;
     if (opcodeID == op_call_eval) {
-        JITStubCall stubCall(this, cti_op_call_eval);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_call_eval));
         stubCall.addArgument(callee, regT0);
         stubCall.addArgument(JIT::Imm32(registerOffset));
         stubCall.addArgument(JIT::Imm32(argCount));
@@ -632,7 +632,7 @@ void JIT::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned ca
 
         emitPutJITStubArg(regT0, 0);
         emitPutJITStubArgFromVirtualRegister(proto, 3, regT2);
-        JITStubCall stubCall(this, cti_op_construct_JSConstruct);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_construct_JSConstruct));
         stubCall.call(thisRegister);
         emitGetVirtualRegister(callee, regT0);
     }
@@ -680,7 +680,7 @@ void JIT::compileOpCallSlowCase(Instruction* instruction, Vector<SlowCaseEntry>:
 
     // First, in the case of a construct, allocate the new object.
     if (opcodeID == op_construct) {
-        JITStubCall(this, cti_op_construct_JSConstruct).call(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
+        JITStubCall(this, JIT_STUB_NAME(cti_op_construct_JSConstruct)).call(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
         emitGetVirtualRegister(callee, regT0);
     }
 
@@ -709,7 +709,7 @@ void JIT::compileOpCallSlowCase(Instruction* instruction, Vector<SlowCaseEntry>:
     // This handles host functions
     callLinkFailNotObject.link(this);
     callLinkFailNotJSFunction.link(this);
-    JITStubCall(this, opcodeID == op_construct ? cti_op_construct_NotJSConstruct : cti_op_call_NotJSFunction).call();
+    JITStubCall(this, opcodeID == op_construct ? JIT_STUB_NAME(cti_op_construct_NotJSConstruct) : JIT_STUB_NAME(cti_op_call_NotJSFunction)).call();
 
     emitPutVirtualRegister(dst);
     sampleCodeBlock(m_codeBlock);
diff --git a/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITCode.h b/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITCode.h
index 69cf167..65a9f9f 100644
--- a/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITCode.h
+++ b/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITCode.h
@@ -76,7 +76,7 @@ namespace JSC {
         // Execute the code!
         inline JSValue execute(RegisterFile* registerFile, CallFrame* callFrame, JSGlobalData* globalData, JSValue* exception)
         {
-            return JSValue::decode(ctiTrampoline(m_ref.m_code.executableAddress(), registerFile, callFrame, exception, Profiler::enabledProfilerReference(), globalData));
+            return JSValue::decode(JIT_STUB_NAME(ctiTrampoline)(m_ref.m_code.executableAddress(), registerFile, callFrame, exception, Profiler::enabledProfilerReference(), globalData));
         }
 
         void* start()
diff --git a/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITOpcodes.cpp b/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITOpcodes.cpp
index b5f6597..e6b821d 100644
--- a/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITOpcodes.cpp
+++ b/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITOpcodes.cpp
@@ -267,7 +267,7 @@ void JIT::privateCompileCTIMachineTrampolines(RefPtr<ExecutablePool>* executable
     emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT1);
     move(ImmPtr(&globalData->exceptionLocation), regT2);
     storePtr(regT1, regT2);
-    move(ImmPtr(reinterpret_cast<void*>(ctiVMThrowTrampoline)), regT2);
+    move(ImmPtr(reinterpret_cast<void*>(JIT_STUB_NAME(ctiVMThrowTrampoline))), regT2);
     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
     poke(callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof (void*));
     restoreReturnAddressBeforeReturn(regT2);
@@ -289,16 +289,16 @@ void JIT::privateCompileCTIMachineTrampolines(RefPtr<ExecutablePool>* executable
     LinkBuffer patchBuffer(this, m_globalData->executableAllocator.poolForSize(m_assembler.size()));
 
 #if ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS)
-    patchBuffer.link(string_failureCases1Call, FunctionPtr(cti_op_get_by_id_string_fail));
-    patchBuffer.link(string_failureCases2Call, FunctionPtr(cti_op_get_by_id_string_fail));
-    patchBuffer.link(string_failureCases3Call, FunctionPtr(cti_op_get_by_id_string_fail));
+    patchBuffer.link(string_failureCases1Call, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_string_fail)));
+    patchBuffer.link(string_failureCases2Call, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_string_fail)));
+    patchBuffer.link(string_failureCases3Call, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_string_fail)));
 #endif
-    patchBuffer.link(callArityCheck1, FunctionPtr(cti_op_call_arityCheck));
-    patchBuffer.link(callJSFunction1, FunctionPtr(cti_op_call_JSFunction));
+    patchBuffer.link(callArityCheck1, FunctionPtr(JIT_STUB_NAME(cti_op_call_arityCheck)));
+    patchBuffer.link(callJSFunction1, FunctionPtr(JIT_STUB_NAME(cti_op_call_JSFunction)));
 #if ENABLE(JIT_OPTIMIZE_CALL)
-    patchBuffer.link(callArityCheck2, FunctionPtr(cti_op_call_arityCheck));
-    patchBuffer.link(callJSFunction2, FunctionPtr(cti_op_call_JSFunction));
-    patchBuffer.link(callLazyLinkCall, FunctionPtr(cti_vm_lazyLinkCall));
+    patchBuffer.link(callArityCheck2, FunctionPtr(JIT_STUB_NAME(cti_op_call_arityCheck)));
+    patchBuffer.link(callJSFunction2, FunctionPtr(JIT_STUB_NAME(cti_op_call_JSFunction)));
+    patchBuffer.link(callLazyLinkCall, FunctionPtr(JIT_STUB_NAME(cti_vm_lazyLinkCall)));
 #endif
 
     CodeRef finalCode = patchBuffer.finalizeCode();
@@ -335,7 +335,7 @@ void JIT::emit_op_mov(Instruction* currentInstruction)
 void JIT::emit_op_end(Instruction* currentInstruction)
 {
     if (m_codeBlock->needsFullScopeChain())
-        JITStubCall(this, cti_op_end).call();
+        JITStubCall(this, JIT_STUB_NAME(cti_op_end)).call();
     ASSERT(returnValueRegister != callFrameRegister);
     emitLoad(currentInstruction[1].u.operand, regT1, regT0);
     restoreReturnAddressBeforeReturn(Address(callFrameRegister, RegisterFile::ReturnPC * static_cast<int>(sizeof(Register))));
@@ -393,7 +393,7 @@ void JIT::emitSlow_op_loop_if_less(Instruction* currentInstruction, Vector<SlowC
         linkSlowCase(iter); // int32 check
     linkSlowCase(iter); // int32 check
 
-    JITStubCall stubCall(this, cti_op_loop_if_less);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_loop_if_less));
     stubCall.addArgument(op1);
     stubCall.addArgument(op2);
     stubCall.call();
@@ -438,7 +438,7 @@ void JIT::emitSlow_op_loop_if_lesseq(Instruction* currentInstruction, Vector<Slo
         linkSlowCase(iter); // int32 check
     linkSlowCase(iter); // int32 check
 
-    JITStubCall stubCall(this, cti_op_loop_if_lesseq);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_loop_if_lesseq));
     stubCall.addArgument(op1);
     stubCall.addArgument(op2);
     stubCall.call();
@@ -447,7 +447,7 @@ void JIT::emitSlow_op_loop_if_lesseq(Instruction* currentInstruction, Vector<Slo
 
 void JIT::emit_op_new_object(Instruction* currentInstruction)
 {
-    JITStubCall(this, cti_op_new_object).call(currentInstruction[1].u.operand);
+    JITStubCall(this, JIT_STUB_NAME(cti_op_new_object)).call(currentInstruction[1].u.operand);
 }
 
 void JIT::emit_op_instanceof(Instruction* currentInstruction)
@@ -518,7 +518,7 @@ void JIT::emitSlow_op_instanceof(Instruction* currentInstruction, Vector<SlowCas
     linkSlowCase(iter);
     linkSlowCase(iter);
 
-    JITStubCall stubCall(this, cti_op_instanceof);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_instanceof));
     stubCall.addArgument(value);
     stubCall.addArgument(baseVal);
     stubCall.addArgument(proto);
@@ -527,7 +527,7 @@ void JIT::emitSlow_op_instanceof(Instruction* currentInstruction, Vector<SlowCas
 
 void JIT::emit_op_new_func(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_new_func);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_new_func));
     stubCall.addArgument(ImmPtr(m_codeBlock->functionDecl(currentInstruction[2].u.operand)));
     stubCall.call(currentInstruction[1].u.operand);
 }
@@ -601,19 +601,19 @@ void JIT::emit_op_put_scoped_var(Instruction* currentInstruction)
 
 void JIT::emit_op_tear_off_activation(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_tear_off_activation);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_tear_off_activation));
     stubCall.addArgument(currentInstruction[1].u.operand);
     stubCall.call();
 }
 
 void JIT::emit_op_tear_off_arguments(Instruction*)
 {
-    JITStubCall(this, cti_op_tear_off_arguments).call();
+    JITStubCall(this, JIT_STUB_NAME(cti_op_tear_off_arguments)).call();
 }
 
 void JIT::emit_op_new_array(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_new_array);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_new_array));
     stubCall.addArgument(Imm32(currentInstruction[2].u.operand));
     stubCall.addArgument(Imm32(currentInstruction[3].u.operand));
     stubCall.call(currentInstruction[1].u.operand);
@@ -621,7 +621,7 @@ void JIT::emit_op_new_array(Instruction* currentInstruction)
 
 void JIT::emit_op_resolve(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_resolve);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_resolve));
     stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
     stubCall.call(currentInstruction[1].u.operand);
 }
@@ -648,14 +648,14 @@ void JIT::emitSlow_op_to_primitive(Instruction* currentInstruction, Vector<SlowC
 
     linkSlowCase(iter);
 
-    JITStubCall stubCall(this, cti_op_to_primitive);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_to_primitive));
     stubCall.addArgument(regT1, regT0);
     stubCall.call(dst);
 }
 
 void JIT::emit_op_strcat(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_strcat);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_strcat));
     stubCall.addArgument(Imm32(currentInstruction[2].u.operand));
     stubCall.addArgument(Imm32(currentInstruction[3].u.operand));
     stubCall.call(currentInstruction[1].u.operand);
@@ -689,7 +689,7 @@ void JIT::emitSlow_op_loop_if_true(Instruction* currentInstruction, Vector<SlowC
 
     linkSlowCase(iter);
 
-    JITStubCall stubCall(this, cti_op_jtrue);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_jtrue));
     stubCall.addArgument(cond);
     stubCall.call();
     emitJumpSlowToHot(branchTest32(NonZero, regT0), target + 2);
@@ -697,14 +697,14 @@ void JIT::emitSlow_op_loop_if_true(Instruction* currentInstruction, Vector<SlowC
 
 void JIT::emit_op_resolve_base(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_resolve_base);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_resolve_base));
     stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
     stubCall.call(currentInstruction[1].u.operand);
 }
 
 void JIT::emit_op_resolve_skip(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_resolve_skip);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_resolve_skip));
     stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
     stubCall.addArgument(Imm32(currentInstruction[3].u.operand + m_codeBlock->needsFullScopeChain()));
     stubCall.call(currentInstruction[1].u.operand);
@@ -744,7 +744,7 @@ void JIT::emitSlow_op_resolve_global(Instruction* currentInstruction, Vector<Slo
     unsigned currentIndex = m_globalResolveInfoIndex++;
 
     linkSlowCase(iter);
-    JITStubCall stubCall(this, cti_op_resolve_global);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_resolve_global));
     stubCall.addArgument(ImmPtr(globalObject));
     stubCall.addArgument(ImmPtr(ident));
     stubCall.addArgument(Imm32(currentIndex));
@@ -772,7 +772,7 @@ void JIT::emitSlow_op_not(Instruction* currentInstruction, Vector<SlowCaseEntry>
 
     linkSlowCase(iter);
 
-    JITStubCall stubCall(this, cti_op_not);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_not));
     stubCall.addArgument(src);
     stubCall.call(dst);
 }
@@ -812,7 +812,7 @@ void JIT::emitSlow_op_jfalse(Instruction* currentInstruction, Vector<SlowCaseEnt
     unsigned target = currentInstruction[2].u.operand;
 
     linkSlowCase(iter);
-    JITStubCall stubCall(this, cti_op_jtrue);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_jtrue));
     stubCall.addArgument(cond);
     stubCall.call();
     emitJumpSlowToHot(branchTest32(Zero, regT0), target + 2); // Inverted.
@@ -853,7 +853,7 @@ void JIT::emitSlow_op_jtrue(Instruction* currentInstruction, Vector<SlowCaseEntr
     unsigned target = currentInstruction[2].u.operand;
 
     linkSlowCase(iter);
-    JITStubCall stubCall(this, cti_op_jtrue);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_jtrue));
     stubCall.addArgument(cond);
     stubCall.call();
     emitJumpSlowToHot(branchTest32(NonZero, regT0), target + 2);
@@ -971,7 +971,7 @@ void JIT::emitSlow_op_eq(Instruction* currentInstruction, Vector<SlowCaseEntry>:
     genericCase.append(branchPtr(NotEqual, Address(regT2), ImmPtr(m_globalData->jsStringVPtr)));
 
     // String case.
-    JITStubCall stubCallEqStrings(this, cti_op_eq_strings);
+    JITStubCall stubCallEqStrings(this, JIT_STUB_NAME(cti_op_eq_strings));
     stubCallEqStrings.addArgument(regT0);
     stubCallEqStrings.addArgument(regT2);
     stubCallEqStrings.call();
@@ -980,7 +980,7 @@ void JIT::emitSlow_op_eq(Instruction* currentInstruction, Vector<SlowCaseEntry>:
     // Generic case.
     genericCase.append(getSlowCase(iter)); // doubles
     genericCase.link(this);
-    JITStubCall stubCallEq(this, cti_op_eq);
+    JITStubCall stubCallEq(this, JIT_STUB_NAME(cti_op_eq));
     stubCallEq.addArgument(op1);
     stubCallEq.addArgument(op2);
     stubCallEq.call(regT0);
@@ -1021,7 +1021,7 @@ void JIT::emitSlow_op_neq(Instruction* currentInstruction, Vector<SlowCaseEntry>
     genericCase.append(branchPtr(NotEqual, Address(regT2), ImmPtr(m_globalData->jsStringVPtr)));
 
     // String case.
-    JITStubCall stubCallEqStrings(this, cti_op_eq_strings);
+    JITStubCall stubCallEqStrings(this, JIT_STUB_NAME(cti_op_eq_strings));
     stubCallEqStrings.addArgument(regT0);
     stubCallEqStrings.addArgument(regT2);
     stubCallEqStrings.call(regT0);
@@ -1030,7 +1030,7 @@ void JIT::emitSlow_op_neq(Instruction* currentInstruction, Vector<SlowCaseEntry>
     // Generic case.
     genericCase.append(getSlowCase(iter)); // doubles
     genericCase.link(this);
-    JITStubCall stubCallEq(this, cti_op_eq);
+    JITStubCall stubCallEq(this, JIT_STUB_NAME(cti_op_eq));
     stubCallEq.addArgument(regT1, regT0);
     stubCallEq.addArgument(regT3, regT2);
     stubCallEq.call(regT0);
@@ -1081,7 +1081,7 @@ void JIT::emitSlow_op_stricteq(Instruction* currentInstruction, Vector<SlowCaseE
     linkSlowCase(iter);
     linkSlowCase(iter);
 
-    JITStubCall stubCall(this, cti_op_stricteq);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_stricteq));
     stubCall.addArgument(src1);
     stubCall.addArgument(src2);
     stubCall.call(dst);
@@ -1101,7 +1101,7 @@ void JIT::emitSlow_op_nstricteq(Instruction* currentInstruction, Vector<SlowCase
     linkSlowCase(iter);
     linkSlowCase(iter);
 
-    JITStubCall stubCall(this, cti_op_nstricteq);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_nstricteq));
     stubCall.addArgument(src1);
     stubCall.addArgument(src2);
     stubCall.call(dst);
@@ -1161,7 +1161,7 @@ void JIT::emit_op_neq_null(Instruction* currentInstruction)
 
 void JIT::emit_op_resolve_with_base(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_resolve_with_base);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_resolve_with_base));
     stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[3].u.operand)));
     stubCall.addArgument(Imm32(currentInstruction[1].u.operand));
     stubCall.call(currentInstruction[2].u.operand);
@@ -1169,14 +1169,14 @@ void JIT::emit_op_resolve_with_base(Instruction* currentInstruction)
 
 void JIT::emit_op_new_func_exp(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_new_func_exp);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_new_func_exp));
     stubCall.addArgument(ImmPtr(m_codeBlock->functionExpr(currentInstruction[2].u.operand)));
     stubCall.call(currentInstruction[1].u.operand);
 }
 
 void JIT::emit_op_new_regexp(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_new_regexp);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_new_regexp));
     stubCall.addArgument(ImmPtr(m_codeBlock->regexp(currentInstruction[2].u.operand)));
     stubCall.call(currentInstruction[1].u.operand);
 }
@@ -1184,7 +1184,7 @@ void JIT::emit_op_new_regexp(Instruction* currentInstruction)
 void JIT::emit_op_throw(Instruction* currentInstruction)
 {
     unsigned exception = currentInstruction[1].u.operand;
-    JITStubCall stubCall(this, cti_op_throw);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_throw));
     stubCall.addArgument(exception);
     stubCall.call();
 
@@ -1203,7 +1203,7 @@ void JIT::emit_op_next_pname(Instruction* currentInstruction)
 
     load32(Address(callFrameRegister, (iter * sizeof(Register))), regT0);
 
-    JITStubCall stubCall(this, cti_op_next_pname);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_next_pname));
     stubCall.addArgument(regT0);
     stubCall.call();
 
@@ -1216,14 +1216,14 @@ void JIT::emit_op_next_pname(Instruction* currentInstruction)
 
 void JIT::emit_op_push_scope(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_push_scope);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_push_scope));
     stubCall.addArgument(currentInstruction[1].u.operand);
     stubCall.call(currentInstruction[1].u.operand);
 }
 
 void JIT::emit_op_pop_scope(Instruction*)
 {
-    JITStubCall(this, cti_op_pop_scope).call();
+    JITStubCall(this, JIT_STUB_NAME(cti_op_pop_scope)).call();
 }
 
 void JIT::emit_op_to_jsnumber(Instruction* currentInstruction)
@@ -1248,14 +1248,14 @@ void JIT::emitSlow_op_to_jsnumber(Instruction* currentInstruction, Vector<SlowCa
 
     linkSlowCase(iter);
 
-    JITStubCall stubCall(this, cti_op_to_jsnumber);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_to_jsnumber));
     stubCall.addArgument(regT1, regT0);
     stubCall.call(dst);
 }
 
 void JIT::emit_op_push_new_scope(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_push_new_scope);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_push_new_scope));
     stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
     stubCall.addArgument(currentInstruction[3].u.operand);
     stubCall.call(currentInstruction[1].u.operand);
@@ -1275,7 +1275,7 @@ void JIT::emit_op_catch(Instruction* currentInstruction)
     emitStore(exception, regT1, regT0);
     map(m_bytecodeIndex + OPCODE_LENGTH(op_catch), exception, regT1, regT0);
 #ifdef QT_BUILD_SCRIPT_LIB
-    JITStubCall stubCall(this, cti_op_debug_catch);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_debug_catch));
     stubCall.addArgument(Imm32(currentInstruction[1].u.operand));
     stubCall.call();
 #endif
@@ -1283,7 +1283,7 @@ void JIT::emit_op_catch(Instruction* currentInstruction)
 
 void JIT::emit_op_jmp_scopes(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_jmp_scopes);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_jmp_scopes));
     stubCall.addArgument(Imm32(currentInstruction[1].u.operand));
     stubCall.call();
     addJump(jump(), currentInstruction[2].u.operand + 2);
@@ -1300,7 +1300,7 @@ void JIT::emit_op_switch_imm(Instruction* currentInstruction)
     m_switches.append(SwitchRecord(jumpTable, m_bytecodeIndex, defaultOffset, SwitchRecord::Immediate));
     jumpTable->ctiOffsets.grow(jumpTable->branchOffsets.size());
 
-    JITStubCall stubCall(this, cti_op_switch_imm);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_switch_imm));
     stubCall.addArgument(scrutinee);
     stubCall.addArgument(Imm32(tableIndex));
     stubCall.call();
@@ -1318,7 +1318,7 @@ void JIT::emit_op_switch_char(Instruction* currentInstruction)
     m_switches.append(SwitchRecord(jumpTable, m_bytecodeIndex, defaultOffset, SwitchRecord::Character));
     jumpTable->ctiOffsets.grow(jumpTable->branchOffsets.size());
 
-    JITStubCall stubCall(this, cti_op_switch_char);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_switch_char));
     stubCall.addArgument(scrutinee);
     stubCall.addArgument(Imm32(tableIndex));
     stubCall.call();
@@ -1335,7 +1335,7 @@ void JIT::emit_op_switch_string(Instruction* currentInstruction)
     StringJumpTable* jumpTable = &m_codeBlock->stringSwitchJumpTable(tableIndex);
     m_switches.append(SwitchRecord(jumpTable, m_bytecodeIndex, defaultOffset));
 
-    JITStubCall stubCall(this, cti_op_switch_string);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_switch_string));
     stubCall.addArgument(scrutinee);
     stubCall.addArgument(Imm32(tableIndex));
     stubCall.call();
@@ -1348,7 +1348,7 @@ void JIT::emit_op_new_error(Instruction* currentInstruction)
     unsigned type = currentInstruction[2].u.operand;
     unsigned message = currentInstruction[3].u.operand;
 
-    JITStubCall stubCall(this, cti_op_new_error);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_new_error));
     stubCall.addArgument(Imm32(type));
     stubCall.addArgument(m_codeBlock->getConstant(message));
     stubCall.addArgument(Imm32(m_bytecodeIndex));
@@ -1357,7 +1357,7 @@ void JIT::emit_op_new_error(Instruction* currentInstruction)
 
 void JIT::emit_op_debug(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_debug);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_debug));
     stubCall.addArgument(Imm32(currentInstruction[1].u.operand));
     stubCall.addArgument(Imm32(currentInstruction[2].u.operand));
     stubCall.addArgument(Imm32(currentInstruction[3].u.operand));
@@ -1379,7 +1379,7 @@ void JIT::emit_op_enter_with_activation(Instruction* currentInstruction)
 {
     emit_op_enter(currentInstruction);
 
-    JITStubCall(this, cti_op_push_activation).call(currentInstruction[1].u.operand);
+    JITStubCall(this, JIT_STUB_NAME(cti_op_push_activation)).call(currentInstruction[1].u.operand);
 }
 
 void JIT::emit_op_create_arguments(Instruction*)
@@ -1388,9 +1388,9 @@ void JIT::emit_op_create_arguments(Instruction*)
 
     // If we get here the arguments pointer is a null cell - i.e. arguments need lazy creation.
     if (m_codeBlock->m_numParameters == 1)
-        JITStubCall(this, cti_op_create_arguments_no_params).call();
+        JITStubCall(this, JIT_STUB_NAME(cti_op_create_arguments_no_params)).call();
     else
-        JITStubCall(this, cti_op_create_arguments).call();
+        JITStubCall(this, JIT_STUB_NAME(cti_op_create_arguments)).call();
 
     argsCreated.link(this);
 }
@@ -1421,7 +1421,7 @@ void JIT::emitSlow_op_convert_this(Instruction* currentInstruction, Vector<SlowC
     linkSlowCase(iter);
     linkSlowCase(iter);
 
-    JITStubCall stubCall(this, cti_op_convert_this);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_convert_this));
     stubCall.addArgument(regT1, regT0);
     stubCall.call(thisRegister);
 }
@@ -1431,7 +1431,7 @@ void JIT::emit_op_profile_will_call(Instruction* currentInstruction)
     peek(regT2, OBJECT_OFFSETOF(JITStackFrame, enabledProfilerReference) / sizeof (void*));
     Jump noProfiler = branchTestPtr(Zero, Address(regT2));
 
-    JITStubCall stubCall(this, cti_op_profile_will_call);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_profile_will_call));
     stubCall.addArgument(currentInstruction[1].u.operand);
     stubCall.call();
     noProfiler.link(this);
@@ -1442,7 +1442,7 @@ void JIT::emit_op_profile_did_call(Instruction* currentInstruction)
     peek(regT2, OBJECT_OFFSETOF(JITStackFrame, enabledProfilerReference) / sizeof (void*));
     Jump noProfiler = branchTestPtr(Zero, Address(regT2));
 
-    JITStubCall stubCall(this, cti_op_profile_did_call);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_profile_did_call));
     stubCall.addArgument(currentInstruction[1].u.operand);
     stubCall.call();
     noProfiler.link(this);
@@ -1755,7 +1755,7 @@ void JIT::privateCompileCTIMachineTrampolines(RefPtr<ExecutablePool>* executable
     emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT1);
     move(ImmPtr(&globalData->exceptionLocation), regT2);
     storePtr(regT1, regT2);
-    move(ImmPtr(reinterpret_cast<void*>(ctiVMThrowTrampoline)), regT2);
+    move(ImmPtr(reinterpret_cast<void*>(JIT_STUB_NAME(ctiVMThrowTrampoline))), regT2);
     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
     poke(callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof (void*));
     restoreReturnAddressBeforeReturn(regT2);
@@ -1772,16 +1772,16 @@ void JIT::privateCompileCTIMachineTrampolines(RefPtr<ExecutablePool>* executable
     LinkBuffer patchBuffer(this, m_globalData->executableAllocator.poolForSize(m_assembler.size()));
 
 #if ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS)
-    patchBuffer.link(string_failureCases1Call, FunctionPtr(cti_op_get_by_id_string_fail));
-    patchBuffer.link(string_failureCases2Call, FunctionPtr(cti_op_get_by_id_string_fail));
-    patchBuffer.link(string_failureCases3Call, FunctionPtr(cti_op_get_by_id_string_fail));
+    patchBuffer.link(string_failureCases1Call, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_string_fail)));
+    patchBuffer.link(string_failureCases2Call, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_string_fail)));
+    patchBuffer.link(string_failureCases3Call, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_string_fail)));
 #endif
-    patchBuffer.link(callArityCheck1, FunctionPtr(cti_op_call_arityCheck));
-    patchBuffer.link(callJSFunction1, FunctionPtr(cti_op_call_JSFunction));
+    patchBuffer.link(callArityCheck1, FunctionPtr(JIT_STUB_NAME(cti_op_call_arityCheck)));
+    patchBuffer.link(callJSFunction1, FunctionPtr(JIT_STUB_NAME(cti_op_call_JSFunction)));
 #if ENABLE(JIT_OPTIMIZE_CALL)
-    patchBuffer.link(callArityCheck2, FunctionPtr(cti_op_call_arityCheck));
-    patchBuffer.link(callJSFunction2, FunctionPtr(cti_op_call_JSFunction));
-    patchBuffer.link(callLazyLinkCall, FunctionPtr(cti_vm_lazyLinkCall));
+    patchBuffer.link(callArityCheck2, FunctionPtr(JIT_STUB_NAME(cti_op_call_arityCheck)));
+    patchBuffer.link(callJSFunction2, FunctionPtr(JIT_STUB_NAME(cti_op_call_JSFunction)));
+    patchBuffer.link(callLazyLinkCall, FunctionPtr(JIT_STUB_NAME(cti_vm_lazyLinkCall)));
 #endif
 
     CodeRef finalCode = patchBuffer.finalizeCode();
@@ -1821,7 +1821,7 @@ void JIT::emit_op_mov(Instruction* currentInstruction)
 void JIT::emit_op_end(Instruction* currentInstruction)
 {
     if (m_codeBlock->needsFullScopeChain())
-        JITStubCall(this, cti_op_end).call();
+        JITStubCall(this, JIT_STUB_NAME(cti_op_end)).call();
     ASSERT(returnValueRegister != callFrameRegister);
     emitGetVirtualRegister(currentInstruction[1].u.operand, returnValueRegister);
     restoreReturnAddressBeforeReturn(Address(callFrameRegister, RegisterFile::ReturnPC * static_cast<int>(sizeof(Register))));
@@ -1902,7 +1902,7 @@ void JIT::emit_op_loop_if_lesseq(Instruction* currentInstruction)
 
 void JIT::emit_op_new_object(Instruction* currentInstruction)
 {
-    JITStubCall(this, cti_op_new_object).call(currentInstruction[1].u.operand);
+    JITStubCall(this, JIT_STUB_NAME(cti_op_new_object)).call(currentInstruction[1].u.operand);
 }
 
 void JIT::emit_op_instanceof(Instruction* currentInstruction)
@@ -1956,7 +1956,7 @@ void JIT::emit_op_instanceof(Instruction* currentInstruction)
 
 void JIT::emit_op_new_func(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_new_func);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_new_func));
     stubCall.addArgument(ImmPtr(m_codeBlock->functionDecl(currentInstruction[2].u.operand)));
     stubCall.call(currentInstruction[1].u.operand);
 }
@@ -1976,7 +1976,7 @@ void JIT::emit_op_load_varargs(Instruction* currentInstruction)
     int argCountDst = currentInstruction[1].u.operand;
     int argsOffset = currentInstruction[2].u.operand;
 
-    JITStubCall stubCall(this, cti_op_load_varargs);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_load_varargs));
     stubCall.addArgument(Imm32(argsOffset));
     stubCall.call();
     // Stores a naked int32 in the register file.
@@ -2037,26 +2037,26 @@ void JIT::emit_op_put_scoped_var(Instruction* currentInstruction)
 
 void JIT::emit_op_tear_off_activation(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_tear_off_activation);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_tear_off_activation));
     stubCall.addArgument(currentInstruction[1].u.operand, regT2);
     stubCall.call();
 }
 
 void JIT::emit_op_tear_off_arguments(Instruction*)
 {
-    JITStubCall(this, cti_op_tear_off_arguments).call();
+    JITStubCall(this, JIT_STUB_NAME(cti_op_tear_off_arguments)).call();
 }
 
 void JIT::emit_op_ret(Instruction* currentInstruction)
 {
 #ifdef QT_BUILD_SCRIPT_LIB
-    JITStubCall stubCall(this, cti_op_debug_return);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_debug_return));
     stubCall.addArgument(Imm32(currentInstruction[1].u.operand));
     stubCall.call();
 #endif
     // We could JIT generate the deref, only calling out to C when the refcount hits zero.
     if (m_codeBlock->needsFullScopeChain())
-        JITStubCall(this, cti_op_ret_scopeChain).call();
+        JITStubCall(this, JIT_STUB_NAME(cti_op_ret_scopeChain)).call();
 
     ASSERT(callFrameRegister != regT1);
     ASSERT(regT1 != returnValueRegister);
@@ -2078,7 +2078,7 @@ void JIT::emit_op_ret(Instruction* currentInstruction)
 
 void JIT::emit_op_new_array(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_new_array);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_new_array));
     stubCall.addArgument(Imm32(currentInstruction[2].u.operand));
     stubCall.addArgument(Imm32(currentInstruction[3].u.operand));
     stubCall.call(currentInstruction[1].u.operand);
@@ -2086,7 +2086,7 @@ void JIT::emit_op_new_array(Instruction* currentInstruction)
 
 void JIT::emit_op_resolve(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_resolve);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_resolve));
     stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
     stubCall.call(currentInstruction[1].u.operand);
 }
@@ -2119,7 +2119,7 @@ void JIT::emit_op_to_primitive(Instruction* currentInstruction)
 
 void JIT::emit_op_strcat(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_strcat);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_strcat));
     stubCall.addArgument(Imm32(currentInstruction[2].u.operand));
     stubCall.addArgument(Imm32(currentInstruction[3].u.operand));
     stubCall.call(currentInstruction[1].u.operand);
@@ -2142,14 +2142,14 @@ void JIT::emit_op_loop_if_true(Instruction* currentInstruction)
 };
 void JIT::emit_op_resolve_base(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_resolve_base);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_resolve_base));
     stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
     stubCall.call(currentInstruction[1].u.operand);
 }
 
 void JIT::emit_op_resolve_skip(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_resolve_skip);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_resolve_skip));
     stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
     stubCall.addArgument(Imm32(currentInstruction[3].u.operand + m_codeBlock->needsFullScopeChain()));
     stubCall.call(currentInstruction[1].u.operand);
@@ -2180,7 +2180,7 @@ void JIT::emit_op_resolve_global(Instruction* currentInstruction)
 
     // Slow case
     noMatch.link(this);
-    JITStubCall stubCall(this, cti_op_resolve_global);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_resolve_global));
     stubCall.addArgument(ImmPtr(globalObject));
     stubCall.addArgument(ImmPtr(ident));
     stubCall.addArgument(Imm32(currentIndex));
@@ -2307,7 +2307,7 @@ void JIT::emit_op_bitnot(Instruction* currentInstruction)
 
 void JIT::emit_op_resolve_with_base(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_resolve_with_base);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_resolve_with_base));
     stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[3].u.operand)));
     stubCall.addArgument(Imm32(currentInstruction[1].u.operand));
     stubCall.call(currentInstruction[2].u.operand);
@@ -2315,7 +2315,7 @@ void JIT::emit_op_resolve_with_base(Instruction* currentInstruction)
 
 void JIT::emit_op_new_func_exp(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_new_func_exp);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_new_func_exp));
     stubCall.addArgument(ImmPtr(m_codeBlock->functionExpr(currentInstruction[2].u.operand)));
     stubCall.call(currentInstruction[1].u.operand);
 }
@@ -2357,7 +2357,7 @@ void JIT::emit_op_bitxor(Instruction* currentInstruction)
 
 void JIT::emit_op_new_regexp(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_new_regexp);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_new_regexp));
     stubCall.addArgument(ImmPtr(m_codeBlock->regexp(currentInstruction[2].u.operand)));
     stubCall.call(currentInstruction[1].u.operand);
 }
@@ -2372,7 +2372,7 @@ void JIT::emit_op_bitor(Instruction* currentInstruction)
 
 void JIT::emit_op_throw(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_throw);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_throw));
     stubCall.addArgument(currentInstruction[1].u.operand, regT2);
     stubCall.call();
     ASSERT(regT0 == returnValueRegister);
@@ -2385,7 +2385,7 @@ void JIT::emit_op_throw(Instruction* currentInstruction)
 
 void JIT::emit_op_next_pname(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_next_pname);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_next_pname));
     stubCall.addArgument(currentInstruction[2].u.operand, regT2);
     stubCall.call();
     Jump endOfIter = branchTestPtr(Zero, regT0);
@@ -2396,14 +2396,14 @@ void JIT::emit_op_next_pname(Instruction* currentInstruction)
 
 void JIT::emit_op_push_scope(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_push_scope);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_push_scope));
     stubCall.addArgument(currentInstruction[1].u.operand, regT2);
     stubCall.call(currentInstruction[1].u.operand);
 }
 
 void JIT::emit_op_pop_scope(Instruction*)
 {
-    JITStubCall(this, cti_op_pop_scope).call();
+    JITStubCall(this, JIT_STUB_NAME(cti_op_pop_scope)).call();
 }
 
 void JIT::compileOpStrictEq(Instruction* currentInstruction, CompileOpStrictEqType type)
@@ -2457,7 +2457,7 @@ void JIT::emit_op_to_jsnumber(Instruction* currentInstruction)
 
 void JIT::emit_op_push_new_scope(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_push_new_scope);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_push_new_scope));
     stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
     stubCall.addArgument(currentInstruction[3].u.operand, regT2);
     stubCall.call(currentInstruction[1].u.operand);
@@ -2469,7 +2469,7 @@ void JIT::emit_op_catch(Instruction* currentInstruction)
     peek(callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof (void*));
     emitPutVirtualRegister(currentInstruction[1].u.operand);
 #ifdef QT_BUILD_SCRIPT_LIB
-    JITStubCall stubCall(this, cti_op_debug_catch);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_debug_catch));
     stubCall.addArgument(Imm32(currentInstruction[1].u.operand));
     stubCall.call();
 #endif
@@ -2477,7 +2477,7 @@ void JIT::emit_op_catch(Instruction* currentInstruction)
 
 void JIT::emit_op_jmp_scopes(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_jmp_scopes);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_jmp_scopes));
     stubCall.addArgument(Imm32(currentInstruction[1].u.operand));
     stubCall.call();
     addJump(jump(), currentInstruction[2].u.operand + 2);
@@ -2495,7 +2495,7 @@ void JIT::emit_op_switch_imm(Instruction* currentInstruction)
     m_switches.append(SwitchRecord(jumpTable, m_bytecodeIndex, defaultOffset, SwitchRecord::Immediate));
     jumpTable->ctiOffsets.grow(jumpTable->branchOffsets.size());
 
-    JITStubCall stubCall(this, cti_op_switch_imm);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_switch_imm));
     stubCall.addArgument(scrutinee, regT2);
     stubCall.addArgument(Imm32(tableIndex));
     stubCall.call();
@@ -2513,7 +2513,7 @@ void JIT::emit_op_switch_char(Instruction* currentInstruction)
     m_switches.append(SwitchRecord(jumpTable, m_bytecodeIndex, defaultOffset, SwitchRecord::Character));
     jumpTable->ctiOffsets.grow(jumpTable->branchOffsets.size());
 
-    JITStubCall stubCall(this, cti_op_switch_char);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_switch_char));
     stubCall.addArgument(scrutinee, regT2);
     stubCall.addArgument(Imm32(tableIndex));
     stubCall.call();
@@ -2530,7 +2530,7 @@ void JIT::emit_op_switch_string(Instruction* currentInstruction)
     StringJumpTable* jumpTable = &m_codeBlock->stringSwitchJumpTable(tableIndex);
     m_switches.append(SwitchRecord(jumpTable, m_bytecodeIndex, defaultOffset));
 
-    JITStubCall stubCall(this, cti_op_switch_string);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_switch_string));
     stubCall.addArgument(scrutinee, regT2);
     stubCall.addArgument(Imm32(tableIndex));
     stubCall.call();
@@ -2539,7 +2539,7 @@ void JIT::emit_op_switch_string(Instruction* currentInstruction)
 
 void JIT::emit_op_new_error(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_new_error);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_new_error));
     stubCall.addArgument(Imm32(currentInstruction[2].u.operand));
     stubCall.addArgument(ImmPtr(JSValue::encode(m_codeBlock->getConstant(currentInstruction[3].u.operand))));
     stubCall.addArgument(Imm32(m_bytecodeIndex));
@@ -2548,7 +2548,7 @@ void JIT::emit_op_new_error(Instruction* currentInstruction)
 
 void JIT::emit_op_debug(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_debug);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_debug));
     stubCall.addArgument(Imm32(currentInstruction[1].u.operand));
     stubCall.addArgument(Imm32(currentInstruction[2].u.operand));
     stubCall.addArgument(Imm32(currentInstruction[3].u.operand));
@@ -2626,16 +2626,16 @@ void JIT::emit_op_enter_with_activation(Instruction* currentInstruction)
     for (size_t j = 0; j < count; ++j)
         emitInitRegister(j);
 
-    JITStubCall(this, cti_op_push_activation).call(currentInstruction[1].u.operand);
+    JITStubCall(this, JIT_STUB_NAME(cti_op_push_activation)).call(currentInstruction[1].u.operand);
 }
 
 void JIT::emit_op_create_arguments(Instruction*)
 {
     Jump argsCreated = branchTestPtr(NonZero, Address(callFrameRegister, sizeof(Register) * RegisterFile::ArgumentsRegister));
     if (m_codeBlock->m_numParameters == 1)
-        JITStubCall(this, cti_op_create_arguments_no_params).call();
+        JITStubCall(this, JIT_STUB_NAME(cti_op_create_arguments_no_params)).call();
     else
-        JITStubCall(this, cti_op_create_arguments).call();
+        JITStubCall(this, JIT_STUB_NAME(cti_op_create_arguments)).call();
     argsCreated.link(this);
 }
     
@@ -2659,7 +2659,7 @@ void JIT::emit_op_profile_will_call(Instruction* currentInstruction)
     peek(regT1, OBJECT_OFFSETOF(JITStackFrame, enabledProfilerReference) / sizeof (void*));
     Jump noProfiler = branchTestPtr(Zero, Address(regT1));
 
-    JITStubCall stubCall(this, cti_op_profile_will_call);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_profile_will_call));
     stubCall.addArgument(currentInstruction[1].u.operand, regT1);
     stubCall.call();
     noProfiler.link(this);
@@ -2671,7 +2671,7 @@ void JIT::emit_op_profile_did_call(Instruction* currentInstruction)
     peek(regT1, OBJECT_OFFSETOF(JITStackFrame, enabledProfilerReference) / sizeof (void*));
     Jump noProfiler = branchTestPtr(Zero, Address(regT1));
 
-    JITStubCall stubCall(this, cti_op_profile_did_call);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_profile_did_call));
     stubCall.addArgument(currentInstruction[1].u.operand, regT1);
     stubCall.call();
     noProfiler.link(this);
@@ -2684,7 +2684,7 @@ void JIT::emitSlow_op_convert_this(Instruction* currentInstruction, Vector<SlowC
 {
     linkSlowCase(iter);
     linkSlowCase(iter);
-    JITStubCall stubCall(this, cti_op_convert_this);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_convert_this));
     stubCall.addArgument(regT0);
     stubCall.call(currentInstruction[1].u.operand);
 }
@@ -2701,7 +2701,7 @@ void JIT::emitSlow_op_to_primitive(Instruction* currentInstruction, Vector<SlowC
 {
     linkSlowCase(iter);
 
-    JITStubCall stubCall(this, cti_op_to_primitive);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_to_primitive));
     stubCall.addArgument(regT0);
     stubCall.call(currentInstruction[1].u.operand);
 }
@@ -2718,7 +2718,7 @@ void JIT::emitSlow_op_get_by_val(Instruction* currentInstruction, Vector<SlowCas
     linkSlowCase(iter); // vector length check
     linkSlowCase(iter); // empty value
 
-    JITStubCall stubCall(this, cti_op_get_by_val);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_get_by_val));
     stubCall.addArgument(base, regT2);
     stubCall.addArgument(property, regT2);
     stubCall.call(dst);
@@ -2731,14 +2731,14 @@ void JIT::emitSlow_op_loop_if_less(Instruction* currentInstruction, Vector<SlowC
     unsigned target = currentInstruction[3].u.operand;
     if (isOperandConstantImmediateInt(op2)) {
         linkSlowCase(iter);
-        JITStubCall stubCall(this, cti_op_loop_if_less);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_loop_if_less));
         stubCall.addArgument(regT0);
         stubCall.addArgument(op2, regT2);
         stubCall.call();
         emitJumpSlowToHot(branchTest32(NonZero, regT0), target + 3);
     } else if (isOperandConstantImmediateInt(op1)) {
         linkSlowCase(iter);
-        JITStubCall stubCall(this, cti_op_loop_if_less);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_loop_if_less));
         stubCall.addArgument(op1, regT2);
         stubCall.addArgument(regT0);
         stubCall.call();
@@ -2746,7 +2746,7 @@ void JIT::emitSlow_op_loop_if_less(Instruction* currentInstruction, Vector<SlowC
     } else {
         linkSlowCase(iter);
         linkSlowCase(iter);
-        JITStubCall stubCall(this, cti_op_loop_if_less);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_loop_if_less));
         stubCall.addArgument(regT0);
         stubCall.addArgument(regT1);
         stubCall.call();
@@ -2760,7 +2760,7 @@ void JIT::emitSlow_op_loop_if_lesseq(Instruction* currentInstruction, Vector<Slo
     unsigned target = currentInstruction[3].u.operand;
     if (isOperandConstantImmediateInt(op2)) {
         linkSlowCase(iter);
-        JITStubCall stubCall(this, cti_op_loop_if_lesseq);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_loop_if_lesseq));
         stubCall.addArgument(regT0);
         stubCall.addArgument(currentInstruction[2].u.operand, regT2);
         stubCall.call();
@@ -2768,7 +2768,7 @@ void JIT::emitSlow_op_loop_if_lesseq(Instruction* currentInstruction, Vector<Slo
     } else {
         linkSlowCase(iter);
         linkSlowCase(iter);
-        JITStubCall stubCall(this, cti_op_loop_if_lesseq);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_loop_if_lesseq));
         stubCall.addArgument(regT0);
         stubCall.addArgument(regT1);
         stubCall.call();
@@ -2787,7 +2787,7 @@ void JIT::emitSlow_op_put_by_val(Instruction* currentInstruction, Vector<SlowCas
     linkSlowCase(iter); // base not array check
     linkSlowCase(iter); // in vector check
 
-    JITStubCall stubPutByValCall(this, cti_op_put_by_val);
+    JITStubCall stubPutByValCall(this, JIT_STUB_NAME(cti_op_put_by_val));
     stubPutByValCall.addArgument(regT0);
     stubPutByValCall.addArgument(property, regT2);
     stubPutByValCall.addArgument(value, regT2);
@@ -2797,7 +2797,7 @@ void JIT::emitSlow_op_put_by_val(Instruction* currentInstruction, Vector<SlowCas
 void JIT::emitSlow_op_loop_if_true(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 {
     linkSlowCase(iter);
-    JITStubCall stubCall(this, cti_op_jtrue);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_jtrue));
     stubCall.addArgument(regT0);
     stubCall.call();
     emitJumpSlowToHot(branchTest32(NonZero, regT0), currentInstruction[2].u.operand + 2);
@@ -2807,7 +2807,7 @@ void JIT::emitSlow_op_not(Instruction* currentInstruction, Vector<SlowCaseEntry>
 {
     linkSlowCase(iter);
     xorPtr(Imm32(static_cast<int32_t>(JSImmediate::FullTagTypeBool)), regT0);
-    JITStubCall stubCall(this, cti_op_not);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_not));
     stubCall.addArgument(regT0);
     stubCall.call(currentInstruction[1].u.operand);
 }
@@ -2815,7 +2815,7 @@ void JIT::emitSlow_op_not(Instruction* currentInstruction, Vector<SlowCaseEntry>
 void JIT::emitSlow_op_jfalse(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 {
     linkSlowCase(iter);
-    JITStubCall stubCall(this, cti_op_jtrue);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_jtrue));
     stubCall.addArgument(regT0);
     stubCall.call();
     emitJumpSlowToHot(branchTest32(Zero, regT0), currentInstruction[2].u.operand + 2); // inverted!
@@ -2824,7 +2824,7 @@ void JIT::emitSlow_op_jfalse(Instruction* currentInstruction, Vector<SlowCaseEnt
 void JIT::emitSlow_op_bitnot(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 {
     linkSlowCase(iter);
-    JITStubCall stubCall(this, cti_op_bitnot);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_bitnot));
     stubCall.addArgument(regT0);
     stubCall.call(currentInstruction[1].u.operand);
 }
@@ -2832,7 +2832,7 @@ void JIT::emitSlow_op_bitnot(Instruction* currentInstruction, Vector<SlowCaseEnt
 void JIT::emitSlow_op_jtrue(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 {
     linkSlowCase(iter);
-    JITStubCall stubCall(this, cti_op_jtrue);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_jtrue));
     stubCall.addArgument(regT0);
     stubCall.call();
     emitJumpSlowToHot(branchTest32(NonZero, regT0), currentInstruction[2].u.operand + 2);
@@ -2841,7 +2841,7 @@ void JIT::emitSlow_op_jtrue(Instruction* currentInstruction, Vector<SlowCaseEntr
 void JIT::emitSlow_op_bitxor(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 {
     linkSlowCase(iter);
-    JITStubCall stubCall(this, cti_op_bitxor);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_bitxor));
     stubCall.addArgument(regT0);
     stubCall.addArgument(regT1);
     stubCall.call(currentInstruction[1].u.operand);
@@ -2850,7 +2850,7 @@ void JIT::emitSlow_op_bitxor(Instruction* currentInstruction, Vector<SlowCaseEnt
 void JIT::emitSlow_op_bitor(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 {
     linkSlowCase(iter);
-    JITStubCall stubCall(this, cti_op_bitor);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_bitor));
     stubCall.addArgument(regT0);
     stubCall.addArgument(regT1);
     stubCall.call(currentInstruction[1].u.operand);
@@ -2859,7 +2859,7 @@ void JIT::emitSlow_op_bitor(Instruction* currentInstruction, Vector<SlowCaseEntr
 void JIT::emitSlow_op_eq(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 {
     linkSlowCase(iter);
-    JITStubCall stubCall(this, cti_op_eq);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_eq));
     stubCall.addArgument(regT0);
     stubCall.addArgument(regT1);
     stubCall.call();
@@ -2870,7 +2870,7 @@ void JIT::emitSlow_op_eq(Instruction* currentInstruction, Vector<SlowCaseEntry>:
 void JIT::emitSlow_op_neq(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 {
     linkSlowCase(iter);
-    JITStubCall stubCall(this, cti_op_eq);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_eq));
     stubCall.addArgument(regT0);
     stubCall.addArgument(regT1);
     stubCall.call();
@@ -2883,7 +2883,7 @@ void JIT::emitSlow_op_stricteq(Instruction* currentInstruction, Vector<SlowCaseE
 {
     linkSlowCase(iter);
     linkSlowCase(iter);
-    JITStubCall stubCall(this, cti_op_stricteq);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_stricteq));
     stubCall.addArgument(regT0);
     stubCall.addArgument(regT1);
     stubCall.call(currentInstruction[1].u.operand);
@@ -2893,7 +2893,7 @@ void JIT::emitSlow_op_nstricteq(Instruction* currentInstruction, Vector<SlowCase
 {
     linkSlowCase(iter);
     linkSlowCase(iter);
-    JITStubCall stubCall(this, cti_op_nstricteq);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_nstricteq));
     stubCall.addArgument(regT0);
     stubCall.addArgument(regT1);
     stubCall.call(currentInstruction[1].u.operand);
@@ -2906,7 +2906,7 @@ void JIT::emitSlow_op_instanceof(Instruction* currentInstruction, Vector<SlowCas
     linkSlowCase(iter);
     linkSlowCase(iter);
     linkSlowCase(iter);
-    JITStubCall stubCall(this, cti_op_instanceof);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_instanceof));
     stubCall.addArgument(currentInstruction[2].u.operand, regT2);
     stubCall.addArgument(currentInstruction[3].u.operand, regT2);
     stubCall.addArgument(currentInstruction[4].u.operand, regT2);
@@ -2938,7 +2938,7 @@ void JIT::emitSlow_op_to_jsnumber(Instruction* currentInstruction, Vector<SlowCa
     linkSlowCaseIfNotJSCell(iter, currentInstruction[2].u.operand);
     linkSlowCase(iter);
 
-    JITStubCall stubCall(this, cti_op_to_jsnumber);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_to_jsnumber));
     stubCall.addArgument(regT0);
     stubCall.call(currentInstruction[1].u.operand);
 }
diff --git a/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITPropertyAccess.cpp b/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITPropertyAccess.cpp
index 9edfd01..f397fe8 100644
--- a/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITPropertyAccess.cpp
+++ b/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITPropertyAccess.cpp
@@ -55,7 +55,7 @@ void JIT::emit_op_put_by_index(Instruction* currentInstruction)
     unsigned property = currentInstruction[2].u.operand;
     unsigned value = currentInstruction[3].u.operand;
 
-    JITStubCall stubCall(this, cti_op_put_by_index);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_put_by_index));
     stubCall.addArgument(base);
     stubCall.addArgument(Imm32(property));
     stubCall.addArgument(value);
@@ -68,7 +68,7 @@ void JIT::emit_op_put_getter(Instruction* currentInstruction)
     unsigned property = currentInstruction[2].u.operand;
     unsigned function = currentInstruction[3].u.operand;
 
-    JITStubCall stubCall(this, cti_op_put_getter);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_put_getter));
     stubCall.addArgument(base);
     stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(property)));
     stubCall.addArgument(function);
@@ -81,7 +81,7 @@ void JIT::emit_op_put_setter(Instruction* currentInstruction)
     unsigned property = currentInstruction[2].u.operand;
     unsigned function = currentInstruction[3].u.operand;
 
-    JITStubCall stubCall(this, cti_op_put_setter);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_put_setter));
     stubCall.addArgument(base);
     stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(property)));
     stubCall.addArgument(function);
@@ -94,7 +94,7 @@ void JIT::emit_op_del_by_id(Instruction* currentInstruction)
     unsigned base = currentInstruction[2].u.operand;
     unsigned property = currentInstruction[3].u.operand;
 
-    JITStubCall stubCall(this, cti_op_del_by_id);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_del_by_id));
     stubCall.addArgument(base);
     stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(property)));
     stubCall.call(dst);
@@ -118,7 +118,7 @@ void JIT::emit_op_get_by_val(Instruction* currentInstruction)
     unsigned base = currentInstruction[2].u.operand;
     unsigned property = currentInstruction[3].u.operand;
 
-    JITStubCall stubCall(this, cti_op_get_by_val);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_get_by_val));
     stubCall.addArgument(base);
     stubCall.addArgument(property);
     stubCall.call(dst);
@@ -135,7 +135,7 @@ void JIT::emit_op_put_by_val(Instruction* currentInstruction)
     unsigned property = currentInstruction[2].u.operand;
     unsigned value = currentInstruction[3].u.operand;
 
-    JITStubCall stubCall(this, cti_op_put_by_val);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_put_by_val));
     stubCall.addArgument(base);
     stubCall.addArgument(property);
     stubCall.addArgument(value);
@@ -153,7 +153,7 @@ void JIT::emit_op_get_by_id(Instruction* currentInstruction)
     int base = currentInstruction[2].u.operand;
     int ident = currentInstruction[3].u.operand;
 
-    JITStubCall stubCall(this, cti_op_get_by_id_generic);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_get_by_id_generic));
     stubCall.addArgument(base);
     stubCall.addArgument(ImmPtr(&(m_codeBlock->identifier(ident))));
     stubCall.call(dst);
@@ -173,7 +173,7 @@ void JIT::emit_op_put_by_id(Instruction* currentInstruction)
     int ident = currentInstruction[2].u.operand;
     int value = currentInstruction[3].u.operand;
 
-    JITStubCall stubCall(this, cti_op_put_by_id_generic);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_put_by_id_generic));
     stubCall.addArgument(base);
     stubCall.addArgument(ImmPtr(&(m_codeBlock->identifier(ident))));
     stubCall.addArgument(value);
@@ -297,7 +297,7 @@ void JIT::emitSlow_op_get_by_val(Instruction* currentInstruction, Vector<SlowCas
     linkSlowCase(iter); // vector length check
     linkSlowCase(iter); // empty value
 
-    JITStubCall stubCall(this, cti_op_get_by_val);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_get_by_val));
     stubCall.addArgument(base);
     stubCall.addArgument(property);
     stubCall.call(dst);
@@ -348,7 +348,7 @@ void JIT::emitSlow_op_put_by_val(Instruction* currentInstruction, Vector<SlowCas
     linkSlowCase(iter); // base not array check
     linkSlowCase(iter); // in vector check
 
-    JITStubCall stubPutByValCall(this, cti_op_put_by_val);
+    JITStubCall stubPutByValCall(this, JIT_STUB_NAME(cti_op_put_by_val));
     stubPutByValCall.addArgument(base);
     stubPutByValCall.addArgument(property);
     stubPutByValCall.addArgument(value);
@@ -418,7 +418,7 @@ void JIT::compileGetByIdSlowCase(int dst, int base, Identifier* ident, Vector<Sl
 
     Label coldPathBegin(this);
 
-    JITStubCall stubCall(this, isMethodCheck ? cti_op_get_by_id_method_check : cti_op_get_by_id);
+    JITStubCall stubCall(this, isMethodCheck ? JIT_STUB_NAME(cti_op_get_by_id_method_check) : JIT_STUB_NAME(cti_op_get_by_id));
     stubCall.addArgument(regT1, regT0);
     stubCall.addArgument(ImmPtr(ident));
     Call call = stubCall.call(dst);
@@ -472,7 +472,7 @@ void JIT::emitSlow_op_put_by_id(Instruction* currentInstruction, Vector<SlowCase
     linkSlowCaseIfNotJSCell(iter, base);
     linkSlowCase(iter);
 
-    JITStubCall stubCall(this, cti_op_put_by_id);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_put_by_id));
     stubCall.addArgument(regT1, regT0);
     stubCall.addArgument(ImmPtr(&(m_codeBlock->identifier(ident))));
     stubCall.addArgument(regT3, regT2); 
@@ -546,7 +546,7 @@ void JIT::privateCompilePutByIdTransition(StructureStubInfo* stubInfo, Structure
         // remove the return address from the stack, to prevent the stack from becoming misaligned.
         preserveReturnAddressAfterCall(regT3);
  
-        JITStubCall stubCall(this, cti_op_put_by_id_transition_realloc);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_put_by_id_transition_realloc));
         stubCall.skipArgument(); // base
         stubCall.skipArgument(); // ident
         stubCall.skipArgument(); // value
@@ -576,11 +576,11 @@ void JIT::privateCompilePutByIdTransition(StructureStubInfo* stubInfo, Structure
 
     LinkBuffer patchBuffer(this, m_codeBlock->executablePool());
 
-    patchBuffer.link(failureCall, FunctionPtr(cti_op_put_by_id_fail));
+    patchBuffer.link(failureCall, FunctionPtr(JIT_STUB_NAME(cti_op_put_by_id_fail)));
 
     if (willNeedStorageRealloc) {
         ASSERT(m_calls.size() == 1);
-        patchBuffer.link(m_calls[0].from, FunctionPtr(cti_op_put_by_id_transition_realloc));
+        patchBuffer.link(m_calls[0].from, FunctionPtr(JIT_STUB_NAME(cti_op_put_by_id_transition_realloc)));
     }
     
     CodeLocationLabel entryLabel = patchBuffer.finalizeCodeAddendum();
@@ -595,7 +595,7 @@ void JIT::patchGetByIdSelf(CodeBlock* codeBlock, StructureStubInfo* stubInfo, St
 
     // We don't want to patch more than once - in future go to cti_op_get_by_id_generic.
     // Should probably go to JITStubs::cti_op_get_by_id_fail, but that doesn't do anything interesting right now.
-    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(cti_op_get_by_id_self_fail));
+    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_self_fail)));
 
     int offset = sizeof(JSValue) * cachedOffset;
 
@@ -628,7 +628,7 @@ void JIT::patchMethodCallProto(CodeBlock* codeBlock, MethodCallLinkInfo& methodC
     repatchBuffer.repatch(methodCallLinkInfo.structureLabel.dataLabelPtrAtOffset(patchOffsetMethodCheckProtoStruct), prototypeStructure);
     repatchBuffer.repatch(methodCallLinkInfo.structureLabel.dataLabelPtrAtOffset(patchOffsetMethodCheckPutFunction), callee);
 
-    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(cti_op_get_by_id));
+    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id)));
 }
 
 void JIT::patchPutByIdReplace(CodeBlock* codeBlock, StructureStubInfo* stubInfo, Structure* structure, size_t cachedOffset, ReturnAddressPtr returnAddress)
@@ -637,7 +637,7 @@ void JIT::patchPutByIdReplace(CodeBlock* codeBlock, StructureStubInfo* stubInfo,
 
     // We don't want to patch more than once - in future go to cti_op_put_by_id_generic.
     // Should probably go to cti_op_put_by_id_fail, but that doesn't do anything interesting right now.
-    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(cti_op_put_by_id_generic));
+    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(JIT_STUB_NAME(cti_op_put_by_id_generic)));
 
     int offset = sizeof(JSValue) * cachedOffset;
 
@@ -690,7 +690,7 @@ void JIT::privateCompilePatchGetArrayLength(ReturnAddressPtr returnAddress)
     repatchBuffer.relink(jumpLocation, entryLabel);
 
     // We don't want to patch more than once - in future go to cti_op_put_by_id_generic.
-    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(cti_op_get_by_id_array_fail));
+    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_array_fail)));
 }
 
 void JIT::privateCompileGetByIdProto(StructureStubInfo* stubInfo, Structure* structure, Structure* prototypeStructure, size_t cachedOffset, ReturnAddressPtr returnAddress, CallFrame* callFrame)
@@ -737,7 +737,7 @@ void JIT::privateCompileGetByIdProto(StructureStubInfo* stubInfo, Structure* str
     repatchBuffer.relink(jumpLocation, entryLabel);
 
     // We don't want to patch more than once - in future go to cti_op_put_by_id_generic.
-    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(cti_op_get_by_id_proto_list));
+    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_proto_list)));
 }
 
 
@@ -923,7 +923,7 @@ void JIT::privateCompileGetByIdChain(StructureStubInfo* stubInfo, Structure* str
     repatchBuffer.relink(jumpLocation, entryLabel);
 
     // We don't want to patch more than once - in future go to cti_op_put_by_id_generic.
-    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(cti_op_get_by_id_proto_list));
+    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_proto_list)));
 }
 
 /* ------------------------------ END: !ENABLE / ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS) ------------------------------ */
@@ -1004,7 +1004,7 @@ void JIT::emit_op_put_by_val(Instruction* currentInstruction)
 
 void JIT::emit_op_put_by_index(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_put_by_index);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_put_by_index));
     stubCall.addArgument(currentInstruction[1].u.operand, regT2);
     stubCall.addArgument(Imm32(currentInstruction[2].u.operand));
     stubCall.addArgument(currentInstruction[3].u.operand, regT2);
@@ -1013,7 +1013,7 @@ void JIT::emit_op_put_by_index(Instruction* currentInstruction)
 
 void JIT::emit_op_put_getter(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_put_getter);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_put_getter));
     stubCall.addArgument(currentInstruction[1].u.operand, regT2);
     stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
     stubCall.addArgument(currentInstruction[3].u.operand, regT2);
@@ -1022,7 +1022,7 @@ void JIT::emit_op_put_getter(Instruction* currentInstruction)
 
 void JIT::emit_op_put_setter(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_put_setter);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_put_setter));
     stubCall.addArgument(currentInstruction[1].u.operand, regT2);
     stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[2].u.operand)));
     stubCall.addArgument(currentInstruction[3].u.operand, regT2);
@@ -1031,7 +1031,7 @@ void JIT::emit_op_put_setter(Instruction* currentInstruction)
 
 void JIT::emit_op_del_by_id(Instruction* currentInstruction)
 {
-    JITStubCall stubCall(this, cti_op_del_by_id);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_del_by_id));
     stubCall.addArgument(currentInstruction[2].u.operand, regT2);
     stubCall.addArgument(ImmPtr(&m_codeBlock->identifier(currentInstruction[3].u.operand)));
     stubCall.call(currentInstruction[1].u.operand);
@@ -1056,7 +1056,7 @@ void JIT::emit_op_get_by_id(Instruction* currentInstruction)
     Identifier* ident = &(m_codeBlock->identifier(currentInstruction[3].u.operand));
 
     emitGetVirtualRegister(baseVReg, regT0);
-    JITStubCall stubCall(this, cti_op_get_by_id_generic);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_get_by_id_generic));
     stubCall.addArgument(regT0);
     stubCall.addArgument(ImmPtr(ident));
     stubCall.call(resultVReg);
@@ -1077,7 +1077,7 @@ void JIT::emit_op_put_by_id(Instruction* currentInstruction)
 
     emitGetVirtualRegisters(baseVReg, regT0, valueVReg, regT1);
 
-    JITStubCall stubCall(this, cti_op_put_by_id_generic);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_put_by_id_generic));
     stubCall.addArgument(regT0);
     stubCall.addArgument(ImmPtr(ident));
     stubCall.addArgument(regT1);
@@ -1240,7 +1240,7 @@ void JIT::compileGetByIdSlowCase(int resultVReg, int baseVReg, Identifier* ident
 #ifndef NDEBUG
     Label coldPathBegin(this);
 #endif
-    JITStubCall stubCall(this, isMethodCheck ? cti_op_get_by_id_method_check : cti_op_get_by_id);
+    JITStubCall stubCall(this, isMethodCheck ? JIT_STUB_NAME(cti_op_get_by_id_method_check) : JIT_STUB_NAME(cti_op_get_by_id));
     stubCall.addArgument(regT0);
     stubCall.addArgument(ImmPtr(ident));
     Call call = stubCall.call(resultVReg);
@@ -1303,7 +1303,7 @@ void JIT::emitSlow_op_put_by_id(Instruction* currentInstruction, Vector<SlowCase
     linkSlowCaseIfNotJSCell(iter, baseVReg);
     linkSlowCase(iter);
 
-    JITStubCall stubCall(this, cti_op_put_by_id);
+    JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_put_by_id));
     stubCall.addArgument(regT0);
     stubCall.addArgument(ImmPtr(ident));
     stubCall.addArgument(regT1);
@@ -1386,7 +1386,7 @@ void JIT::privateCompilePutByIdTransition(StructureStubInfo* stubInfo, Structure
         // remove the return address from the stack, to prevent the stack from becoming misaligned.
         preserveReturnAddressAfterCall(regT3);
  
-        JITStubCall stubCall(this, cti_op_put_by_id_transition_realloc);
+        JITStubCall stubCall(this, JIT_STUB_NAME(cti_op_put_by_id_transition_realloc));
         stubCall.skipArgument(); // base
         stubCall.skipArgument(); // ident
         stubCall.skipArgument(); // value
@@ -1416,11 +1416,11 @@ void JIT::privateCompilePutByIdTransition(StructureStubInfo* stubInfo, Structure
 
     LinkBuffer patchBuffer(this, m_codeBlock->executablePool());
 
-    patchBuffer.link(failureCall, FunctionPtr(cti_op_put_by_id_fail));
+    patchBuffer.link(failureCall, FunctionPtr(JIT_STUB_NAME(cti_op_put_by_id_fail)));
 
     if (willNeedStorageRealloc) {
         ASSERT(m_calls.size() == 1);
-        patchBuffer.link(m_calls[0].from, FunctionPtr(cti_op_put_by_id_transition_realloc));
+        patchBuffer.link(m_calls[0].from, FunctionPtr(JIT_STUB_NAME(cti_op_put_by_id_transition_realloc)));
     }
     
     CodeLocationLabel entryLabel = patchBuffer.finalizeCodeAddendum();
@@ -1435,7 +1435,7 @@ void JIT::patchGetByIdSelf(CodeBlock* codeBlock, StructureStubInfo* stubInfo, St
 
     // We don't want to patch more than once - in future go to cti_op_get_by_id_generic.
     // Should probably go to cti_op_get_by_id_fail, but that doesn't do anything interesting right now.
-    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(cti_op_get_by_id_self_fail));
+    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_self_fail)));
 
     int offset = sizeof(JSValue) * cachedOffset;
 
@@ -1467,7 +1467,7 @@ void JIT::patchMethodCallProto(CodeBlock* codeBlock, MethodCallLinkInfo& methodC
     repatchBuffer.repatch(methodCallLinkInfo.structureLabel.dataLabelPtrAtOffset(patchOffsetMethodCheckProtoStruct), prototypeStructure);
     repatchBuffer.repatch(methodCallLinkInfo.structureLabel.dataLabelPtrAtOffset(patchOffsetMethodCheckPutFunction), callee);
 
-    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(cti_op_get_by_id));
+    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id)));
 }
 
 void JIT::patchPutByIdReplace(CodeBlock* codeBlock, StructureStubInfo* stubInfo, Structure* structure, size_t cachedOffset, ReturnAddressPtr returnAddress)
@@ -1476,7 +1476,7 @@ void JIT::patchPutByIdReplace(CodeBlock* codeBlock, StructureStubInfo* stubInfo,
 
     // We don't want to patch more than once - in future go to cti_op_put_by_id_generic.
     // Should probably go to cti_op_put_by_id_fail, but that doesn't do anything interesting right now.
-    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(cti_op_put_by_id_generic));
+    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(JIT_STUB_NAME(cti_op_put_by_id_generic)));
 
     int offset = sizeof(JSValue) * cachedOffset;
 
@@ -1526,7 +1526,7 @@ void JIT::privateCompilePatchGetArrayLength(ReturnAddressPtr returnAddress)
     repatchBuffer.relink(jumpLocation, entryLabel);
 
     // We don't want to patch more than once - in future go to cti_op_put_by_id_generic.
-    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(cti_op_get_by_id_array_fail));
+    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_array_fail)));
 }
 
 void JIT::privateCompileGetByIdProto(StructureStubInfo* stubInfo, Structure* structure, Structure* prototypeStructure, size_t cachedOffset, ReturnAddressPtr returnAddress, CallFrame* callFrame)
@@ -1572,7 +1572,7 @@ void JIT::privateCompileGetByIdProto(StructureStubInfo* stubInfo, Structure* str
     repatchBuffer.relink(jumpLocation, entryLabel);
 
     // We don't want to patch more than once - in future go to cti_op_put_by_id_generic.
-    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(cti_op_get_by_id_proto_list));
+    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_proto_list)));
 }
 
 void JIT::privateCompileGetByIdSelfList(StructureStubInfo* stubInfo, PolymorphicAccessStructureList* polymorphicStructures, int currentIndex, Structure* structure, size_t cachedOffset)
@@ -1751,7 +1751,7 @@ void JIT::privateCompileGetByIdChain(StructureStubInfo* stubInfo, Structure* str
     repatchBuffer.relink(jumpLocation, entryLabel);
 
     // We don't want to patch more than once - in future go to cti_op_put_by_id_generic.
-    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(cti_op_get_by_id_proto_list));
+    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_proto_list)));
 }
 
 /* ------------------------------ END: !ENABLE / ENABLE(JIT_OPTIMIZE_PROPERTY_ACCESS) ------------------------------ */
diff --git a/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITStubs.cpp b/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITStubs.cpp
index 073b35a..0409bf7 100644
--- a/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITStubs.cpp
+++ b/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITStubs.cpp
@@ -67,6 +67,16 @@ using namespace std;
 
 namespace JSC {
 
+#if defined(JIT_STUB_PREFIX_STRING)
+#define JIT_STUB_SYMBOL_STRING(name) JIT_STUB_PREFIX_STRING "_" #name
+#else
+#if PLATFORM(DARWIN) || PLATFORM(WIN_OS)
+#define JIT_STUB_SYMBOL_STRING(name) "_" #name
+#else
+#define JIT_STUB_SYMBOL_STRING(name) #name
+#endif
+#endif
+
 #if PLATFORM(DARWIN) || PLATFORM(WIN_OS)
 #define SYMBOL_STRING(name) "_" #name
 #else
@@ -560,8 +570,8 @@ SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
 #elif COMPILER(GCC) && PLATFORM(ARM_TRADITIONAL)
 
 asm volatile (
-".globl " SYMBOL_STRING(ctiTrampoline) "\n"
-SYMBOL_STRING(ctiTrampoline) ":" "\n"
+".globl " JIT_STUB_SYMBOL_STRING(ctiTrampoline) "\n"
+JIT_STUB_SYMBOL_STRING(ctiTrampoline) ":" "\n"
     "stmdb sp!, {r1-r3}" "\n"
     "stmdb sp!, {r4-r8, lr}" "\n"
     "mov r6, pc" "\n"
@@ -583,17 +593,17 @@ SYMBOL_STRING(ctiTrampoline) ":" "\n"
 );
 
 asm volatile (
-".globl " SYMBOL_STRING(ctiVMThrowTrampoline) "\n"
-SYMBOL_STRING(ctiVMThrowTrampoline) ":" "\n"
+".globl " JIT_STUB_SYMBOL_STRING(ctiVMThrowTrampoline) "\n"
+JIT_STUB_SYMBOL_STRING(ctiVMThrowTrampoline) ":" "\n"
     "mov r0, sp" "\n"
     "mov lr, r6" "\n"
     "add r8, pc, #4" "\n"
     "str r8, [sp, #-4]!" "\n"
-    "b " SYMBOL_STRING(cti_vm_throw) "\n"
+    "b " JIT_STUB_SYMBOL_STRING(cti_vm_throw) "\n"
 
 // Both has the same return sequence
-".globl " SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
-SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
+".globl " JIT_STUB_SYMBOL_STRING(ctiOpThrowNotCaught) "\n"
+JIT_STUB_SYMBOL_STRING(ctiOpThrowNotCaught) ":" "\n"
     "add sp, sp, #32" "\n"
     "ldmia sp!, {r4-r8, lr}" "\n"
     "add sp, sp, #12" "\n"
@@ -707,7 +717,7 @@ NEVER_INLINE void JITThunks::tryCachePutByID(CallFrame* callFrame, CodeBlock* co
 
     // Uncacheable: give up.
     if (!slot.isCacheable()) {
-        ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(cti_op_put_by_id_generic));
+        ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(JIT_STUB_NAME(cti_op_put_by_id_generic)));
         return;
     }
     
@@ -715,13 +725,13 @@ NEVER_INLINE void JITThunks::tryCachePutByID(CallFrame* callFrame, CodeBlock* co
     Structure* structure = baseCell->structure();
 
     if (structure->isUncacheableDictionary()) {
-        ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(cti_op_put_by_id_generic));
+        ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(JIT_STUB_NAME(cti_op_put_by_id_generic)));
         return;
     }
 
     // If baseCell != base, then baseCell must be a proxy for another object.
     if (baseCell != slot.base()) {
-        ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(cti_op_put_by_id_generic));
+        ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(JIT_STUB_NAME(cti_op_put_by_id_generic)));
         return;
     }
 
@@ -731,7 +741,7 @@ NEVER_INLINE void JITThunks::tryCachePutByID(CallFrame* callFrame, CodeBlock* co
     if (slot.type() == PutPropertySlot::NewProperty) {
         StructureChain* prototypeChain = structure->prototypeChain(callFrame);
         if (!prototypeChain->isCacheable() || structure->isDictionary()) {
-            ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(cti_op_put_by_id_generic));
+            ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(JIT_STUB_NAME(cti_op_put_by_id_generic)));
             return;
         }
         stubInfo->initPutByIdTransition(structure->previousID(), structure, prototypeChain);
@@ -751,7 +761,7 @@ NEVER_INLINE void JITThunks::tryCacheGetByID(CallFrame* callFrame, CodeBlock* co
 
     // FIXME: Cache property access for immediates.
     if (!baseValue.isCell()) {
-        ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(cti_op_get_by_id_generic));
+        ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_generic)));
         return;
     }
     
@@ -771,7 +781,7 @@ NEVER_INLINE void JITThunks::tryCacheGetByID(CallFrame* callFrame, CodeBlock* co
 
     // Uncacheable: give up.
     if (!slot.isCacheable()) {
-        ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(cti_op_get_by_id_generic));
+        ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_generic)));
         return;
     }
 
@@ -779,7 +789,7 @@ NEVER_INLINE void JITThunks::tryCacheGetByID(CallFrame* callFrame, CodeBlock* co
     Structure* structure = baseCell->structure();
 
     if (structure->isUncacheableDictionary()) {
-        ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(cti_op_get_by_id_generic));
+        ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_generic)));
         return;
     }
 
@@ -817,7 +827,7 @@ NEVER_INLINE void JITThunks::tryCacheGetByID(CallFrame* callFrame, CodeBlock* co
 
     StructureChain* prototypeChain = structure->prototypeChain(callFrame);
     if (!prototypeChain->isCacheable()) {
-        ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(cti_op_get_by_id_generic));
+        ctiPatchCallByReturnAddress(codeBlock, returnAddress, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_generic)));
         return;
     }
     stubInfo->initGetByIdChain(structure, prototypeChain);
@@ -882,7 +892,7 @@ static NEVER_INLINE void returnToThrowTrampoline(JSGlobalData* globalData, Retur
 {
     ASSERT(globalData->exception);
     globalData->exceptionLocation = exceptionLocation;
-    returnAddressSlot = ReturnAddressPtr(FunctionPtr(ctiVMThrowTrampoline));
+    returnAddressSlot = ReturnAddressPtr(FunctionPtr(JIT_STUB_NAME(ctiVMThrowTrampoline)));
 }
 
 static NEVER_INLINE void throwStackOverflowError(CallFrame* callFrame, JSGlobalData* globalData, ReturnAddressPtr exceptionLocation, ReturnAddressPtr& returnAddressSlot)
@@ -939,7 +949,7 @@ static NEVER_INLINE void throwStackOverflowError(CallFrame* callFrame, JSGlobalD
     rtype JITStubThunked_##op(STUB_ARGS_DECLARATION) \
 
 #else
-#define DEFINE_STUB_FUNCTION(rtype, op) rtype JIT_STUB cti_##op(STUB_ARGS_DECLARATION)
+#define DEFINE_STUB_FUNCTION(rtype, op) rtype JIT_STUB JIT_STUB_NAME(cti_##op)(STUB_ARGS_DECLARATION)
 #endif
 
 DEFINE_STUB_FUNCTION(EncodedJSValue, op_convert_this)
@@ -1225,7 +1235,7 @@ DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_id_method_check)
     }
 
     // Revert the get_by_id op back to being a regular get_by_id - allow it to cache like normal, if it needs to.
-    ctiPatchCallByReturnAddress(codeBlock, STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_id));
+    ctiPatchCallByReturnAddress(codeBlock, STUB_RETURN_ADDRESS, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id)));
     return JSValue::encode(result);
 }
 
@@ -1289,9 +1299,9 @@ DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_id_self_fail)
         JIT::compileGetByIdSelfList(callFrame->scopeChain()->globalData, codeBlock, stubInfo, polymorphicStructureList, listIndex, asCell(baseValue)->structure(), slot.cachedOffset());
 
         if (listIndex == (POLYMORPHIC_LIST_CACHE_SIZE - 1))
-            ctiPatchCallByReturnAddress(codeBlock, STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_id_generic));
+            ctiPatchCallByReturnAddress(codeBlock, STUB_RETURN_ADDRESS, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_generic)));
     } else
-        ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_id_generic));
+        ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_generic)));
     return JSValue::encode(result);
 }
 
@@ -1337,7 +1347,7 @@ DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_id_proto_list)
     CHECK_FOR_EXCEPTION();
 
     if (!baseValue.isCell() || !slot.isCacheable() || asCell(baseValue)->structure()->isUncacheableDictionary()) {
-        ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_id_proto_fail));
+        ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_proto_fail)));
         return JSValue::encode(result);
     }
 
@@ -1349,7 +1359,7 @@ DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_id_proto_list)
     JSObject* slotBaseObject = asObject(slot.slotBase());
 
     if (slot.slotBase() == baseValue)
-        ctiPatchCallByReturnAddress(codeBlock, STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_id_proto_fail));
+        ctiPatchCallByReturnAddress(codeBlock, STUB_RETURN_ADDRESS, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_proto_fail)));
     else if (slot.slotBase() == asCell(baseValue)->structure()->prototypeForLookup(callFrame)) {
         // Since we're accessing a prototype in a loop, it's a good bet that it
         // should not be treated as a dictionary.
@@ -1362,11 +1372,11 @@ DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_id_proto_list)
         JIT::compileGetByIdProtoList(callFrame->scopeChain()->globalData, callFrame, codeBlock, stubInfo, prototypeStructureList, listIndex, structure, slotBaseObject->structure(), slot.cachedOffset());
 
         if (listIndex == (POLYMORPHIC_LIST_CACHE_SIZE - 1))
-            ctiPatchCallByReturnAddress(codeBlock, STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_id_proto_list_full));
+            ctiPatchCallByReturnAddress(codeBlock, STUB_RETURN_ADDRESS, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_proto_list_full)));
     } else if (size_t count = countPrototypeChainEntriesAndCheckForProxies(callFrame, baseValue, slot)) {
         StructureChain* protoChain = structure->prototypeChain(callFrame);
         if (!protoChain->isCacheable()) {
-            ctiPatchCallByReturnAddress(codeBlock, STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_id_proto_fail));
+            ctiPatchCallByReturnAddress(codeBlock, STUB_RETURN_ADDRESS, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_proto_fail)));
             return JSValue::encode(result);
         }
         
@@ -1375,9 +1385,9 @@ DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_id_proto_list)
         JIT::compileGetByIdChainList(callFrame->scopeChain()->globalData, callFrame, codeBlock, stubInfo, prototypeStructureList, listIndex, structure, protoChain, count, slot.cachedOffset());
 
         if (listIndex == (POLYMORPHIC_LIST_CACHE_SIZE - 1))
-            ctiPatchCallByReturnAddress(codeBlock, STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_id_proto_list_full));
+            ctiPatchCallByReturnAddress(codeBlock, STUB_RETURN_ADDRESS, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_proto_list_full)));
     } else
-        ctiPatchCallByReturnAddress(codeBlock, STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_id_proto_fail));
+        ctiPatchCallByReturnAddress(codeBlock, STUB_RETURN_ADDRESS, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_id_proto_fail)));
 
     return JSValue::encode(result);
 }
@@ -1839,11 +1849,11 @@ DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_val)
                 result = jsArray->JSArray::get(callFrame, i);
         } else if (isJSString(globalData, baseValue) && asString(baseValue)->canGetIndex(i)) {
             // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks.
-            ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_val_string));
+            ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_val_string)));
             result = asString(baseValue)->getIndex(stackFrame.globalData, i);
         } else if (isJSByteArray(globalData, baseValue) && asByteArray(baseValue)->canAccessIndex(i)) {
             // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks.
-            ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_val_byte_array));
+            ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_val_byte_array)));
             return JSValue::encode(asByteArray(baseValue)->getIndex(callFrame, i));
         } else
             result = baseValue.get(callFrame, i);
@@ -1875,7 +1885,7 @@ DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_val_string)
         else {
             result = baseValue.get(callFrame, i);
             if (!isJSString(globalData, baseValue))
-                ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_val));
+                ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_val)));
         }
     } else {
         Identifier property(callFrame, subscript.toString(callFrame));
@@ -1907,7 +1917,7 @@ DEFINE_STUB_FUNCTION(EncodedJSValue, op_get_by_val_byte_array)
 
         result = baseValue.get(callFrame, i);
         if (!isJSByteArray(globalData, baseValue))
-            ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(cti_op_get_by_val));
+            ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(JIT_STUB_NAME(cti_op_get_by_val)));
     } else {
         Identifier property(callFrame, subscript.toString(callFrame));
         result = baseValue.get(callFrame, property);
@@ -1956,7 +1966,7 @@ DEFINE_STUB_FUNCTION(void, op_put_by_val)
                 jsArray->JSArray::put(callFrame, i, value);
         } else if (isJSByteArray(globalData, baseValue) && asByteArray(baseValue)->canAccessIndex(i)) {
             JSByteArray* jsByteArray = asByteArray(baseValue);
-            ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(cti_op_put_by_val_byte_array));
+            ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(JIT_STUB_NAME(cti_op_put_by_val_byte_array)));
             // All fast byte array accesses are safe from exceptions so return immediately to avoid exception checks.
             if (value.isInt32()) {
                 jsByteArray->setIndex(i, value.asInt32());
@@ -2013,7 +2023,7 @@ DEFINE_STUB_FUNCTION(void, op_put_by_val_byte_array)
         }
 
         if (!isJSByteArray(globalData, baseValue))
-            ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(cti_op_put_by_val));
+            ctiPatchCallByReturnAddress(callFrame->codeBlock(), STUB_RETURN_ADDRESS, FunctionPtr(JIT_STUB_NAME(cti_op_put_by_val)));
         baseValue.put(callFrame, i, value);
     } else {
         Identifier property(callFrame, subscript.toString(callFrame));
@@ -2696,7 +2706,7 @@ DEFINE_STUB_FUNCTION(EncodedJSValue, op_throw)
 
     if (!handler) {
         *stackFrame.exception = exceptionValue;
-        STUB_SET_RETURN_ADDRESS(reinterpret_cast<void*>(ctiOpThrowNotCaught));
+        STUB_SET_RETURN_ADDRESS(reinterpret_cast<void*>(JIT_STUB_NAME(ctiOpThrowNotCaught)));
         return JSValue::encode(jsNull());
     }
 
diff --git a/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITStubs.h b/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITStubs.h
index 43975ff..4cc9972 100644
--- a/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITStubs.h
+++ b/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITStubs.h
@@ -204,6 +204,10 @@ namespace JSC {
     #endif
 #endif
 
+#if !defined(JIT_STUB_NAME)
+#define JIT_STUB_NAME(name) name
+#endif
+
 #if PLATFORM(X86_64)
     struct VoidPtrPair {
         void* first;
@@ -221,9 +225,9 @@ namespace JSC {
     #define RETURN_POINTER_PAIR(a,b) VoidPtrPairUnion pair = {{ a, b }}; return pair.i
 #endif
 
-    extern "C" void ctiVMThrowTrampoline();
-    extern "C" void ctiOpThrowNotCaught();
-    extern "C" EncodedJSValue ctiTrampoline(void* code, RegisterFile*, CallFrame*, JSValue* exception, Profiler**, JSGlobalData*);
+    extern "C" void JIT_STUB_NAME(ctiVMThrowTrampoline)();
+    extern "C" void JIT_STUB_NAME(ctiOpThrowNotCaught)();
+    extern "C" EncodedJSValue JIT_STUB_NAME(ctiTrampoline)(void* code, RegisterFile*, CallFrame*, JSValue* exception, Profiler**, JSGlobalData*);
 
     class JITThunks {
     public:
@@ -247,120 +251,120 @@ namespace JSC {
     };
 
 extern "C" {
-    EncodedJSValue JIT_STUB cti_op_add(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_bitand(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_bitnot(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_bitor(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_bitxor(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_call_NotJSFunction(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_call_eval(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_construct_NotJSConstruct(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_convert_this(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_del_by_id(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_del_by_val(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_div(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_get_by_id(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_get_by_id_array_fail(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_get_by_id_generic(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_get_by_id_method_check(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_get_by_id_proto_fail(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_get_by_id_proto_list(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_get_by_id_proto_list_full(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_get_by_id_self_fail(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_get_by_id_string_fail(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_get_by_val(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_get_by_val_byte_array(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_get_by_val_string(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_in(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_instanceof(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_is_boolean(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_is_function(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_is_number(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_is_object(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_is_string(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_is_undefined(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_less(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_lesseq(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_lshift(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_mod(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_mul(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_negate(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_next_pname(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_not(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_nstricteq(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_post_dec(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_post_inc(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_pre_dec(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_pre_inc(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_resolve(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_resolve_base(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_resolve_global(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_resolve_skip(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_resolve_with_base(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_rshift(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_strcat(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_stricteq(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_sub(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_throw(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_to_jsnumber(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_to_primitive(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_typeof(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_op_urshift(STUB_ARGS_DECLARATION);
-    EncodedJSValue JIT_STUB cti_vm_throw(STUB_ARGS_DECLARATION);
-    JSObject* JIT_STUB cti_op_construct_JSConstruct(STUB_ARGS_DECLARATION);
-    JSObject* JIT_STUB cti_op_new_array(STUB_ARGS_DECLARATION);
-    JSObject* JIT_STUB cti_op_new_error(STUB_ARGS_DECLARATION);
-    JSObject* JIT_STUB cti_op_new_func(STUB_ARGS_DECLARATION);
-    JSObject* JIT_STUB cti_op_new_func_exp(STUB_ARGS_DECLARATION);
-    JSObject* JIT_STUB cti_op_new_object(STUB_ARGS_DECLARATION);
-    JSObject* JIT_STUB cti_op_new_regexp(STUB_ARGS_DECLARATION);
-    JSObject* JIT_STUB cti_op_push_activation(STUB_ARGS_DECLARATION);
-    JSObject* JIT_STUB cti_op_push_new_scope(STUB_ARGS_DECLARATION);
-    JSObject* JIT_STUB cti_op_push_scope(STUB_ARGS_DECLARATION);
-    JSObject* JIT_STUB cti_op_put_by_id_transition_realloc(STUB_ARGS_DECLARATION);
-    JSPropertyNameIterator* JIT_STUB cti_op_get_pnames(STUB_ARGS_DECLARATION);
-    VoidPtrPair JIT_STUB cti_op_call_arityCheck(STUB_ARGS_DECLARATION);
-    int JIT_STUB cti_op_eq(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_add)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_bitand)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_bitnot)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_bitor)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_bitxor)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_call_NotJSFunction)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_call_eval)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_construct_NotJSConstruct)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_convert_this)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_del_by_id)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_del_by_val)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_div)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_get_by_id)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_get_by_id_array_fail)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_get_by_id_generic)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_get_by_id_method_check)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_get_by_id_proto_fail)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_get_by_id_proto_list)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_get_by_id_proto_list_full)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_get_by_id_self_fail)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_get_by_id_string_fail)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_get_by_val)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_get_by_val_byte_array)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_get_by_val_string)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_in)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_instanceof)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_is_boolean)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_is_function)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_is_number)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_is_object)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_is_string)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_is_undefined)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_less)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_lesseq)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_lshift)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_mod)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_mul)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_negate)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_next_pname)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_not)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_nstricteq)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_post_dec)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_post_inc)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_pre_dec)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_pre_inc)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_resolve)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_resolve_base)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_resolve_global)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_resolve_skip)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_resolve_with_base)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_rshift)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_strcat)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_stricteq)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_sub)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_throw)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_to_jsnumber)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_to_primitive)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_typeof)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_op_urshift)(STUB_ARGS_DECLARATION);
+    EncodedJSValue JIT_STUB JIT_STUB_NAME(cti_vm_throw)(STUB_ARGS_DECLARATION);
+    JSObject* JIT_STUB JIT_STUB_NAME(cti_op_construct_JSConstruct)(STUB_ARGS_DECLARATION);
+    JSObject* JIT_STUB JIT_STUB_NAME(cti_op_new_array)(STUB_ARGS_DECLARATION);
+    JSObject* JIT_STUB JIT_STUB_NAME(cti_op_new_error)(STUB_ARGS_DECLARATION);
+    JSObject* JIT_STUB JIT_STUB_NAME(cti_op_new_func)(STUB_ARGS_DECLARATION);
+    JSObject* JIT_STUB JIT_STUB_NAME(cti_op_new_func_exp)(STUB_ARGS_DECLARATION);
+    JSObject* JIT_STUB JIT_STUB_NAME(cti_op_new_object)(STUB_ARGS_DECLARATION);
+    JSObject* JIT_STUB JIT_STUB_NAME(cti_op_new_regexp)(STUB_ARGS_DECLARATION);
+    JSObject* JIT_STUB JIT_STUB_NAME(cti_op_push_activation)(STUB_ARGS_DECLARATION);
+    JSObject* JIT_STUB JIT_STUB_NAME(cti_op_push_new_scope)(STUB_ARGS_DECLARATION);
+    JSObject* JIT_STUB JIT_STUB_NAME(cti_op_push_scope)(STUB_ARGS_DECLARATION);
+    JSObject* JIT_STUB JIT_STUB_NAME(cti_op_put_by_id_transition_realloc)(STUB_ARGS_DECLARATION);
+    JSPropertyNameIterator* JIT_STUB JIT_STUB_NAME(cti_op_get_pnames)(STUB_ARGS_DECLARATION);
+    VoidPtrPair JIT_STUB JIT_STUB_NAME(cti_op_call_arityCheck)(STUB_ARGS_DECLARATION);
+    int JIT_STUB JIT_STUB_NAME(cti_op_eq)(STUB_ARGS_DECLARATION);
 #if USE(JSVALUE32_64)
-    int JIT_STUB cti_op_eq_strings(STUB_ARGS_DECLARATION);
+    int JIT_STUB JIT_STUB_NAME(cti_op_eq_strings)(STUB_ARGS_DECLARATION);
 #endif
-    int JIT_STUB cti_op_jless(STUB_ARGS_DECLARATION);
-    int JIT_STUB cti_op_jlesseq(STUB_ARGS_DECLARATION);
-    int JIT_STUB cti_op_jtrue(STUB_ARGS_DECLARATION);
-    int JIT_STUB cti_op_load_varargs(STUB_ARGS_DECLARATION);
-    int JIT_STUB cti_op_loop_if_less(STUB_ARGS_DECLARATION);
-    int JIT_STUB cti_op_loop_if_lesseq(STUB_ARGS_DECLARATION);
-    int JIT_STUB cti_op_loop_if_true(STUB_ARGS_DECLARATION);
-    int JIT_STUB cti_timeout_check(STUB_ARGS_DECLARATION);
-    void JIT_STUB cti_op_create_arguments(STUB_ARGS_DECLARATION);
-    void JIT_STUB cti_op_create_arguments_no_params(STUB_ARGS_DECLARATION);
-    void JIT_STUB cti_op_debug(STUB_ARGS_DECLARATION);
+    int JIT_STUB JIT_STUB_NAME(cti_op_jless)(STUB_ARGS_DECLARATION);
+    int JIT_STUB JIT_STUB_NAME(cti_op_jlesseq)(STUB_ARGS_DECLARATION);
+    int JIT_STUB JIT_STUB_NAME(cti_op_jtrue)(STUB_ARGS_DECLARATION);
+    int JIT_STUB JIT_STUB_NAME(cti_op_load_varargs)(STUB_ARGS_DECLARATION);
+    int JIT_STUB JIT_STUB_NAME(cti_op_loop_if_less)(STUB_ARGS_DECLARATION);
+    int JIT_STUB JIT_STUB_NAME(cti_op_loop_if_lesseq)(STUB_ARGS_DECLARATION);
+    int JIT_STUB JIT_STUB_NAME(cti_op_loop_if_true)(STUB_ARGS_DECLARATION);
+    int JIT_STUB JIT_STUB_NAME(cti_timeout_check)(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_create_arguments)(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_create_arguments_no_params)(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_debug)(STUB_ARGS_DECLARATION);
 #ifdef QT_BUILD_SCRIPT_LIB
-    void JIT_STUB cti_op_debug_catch(STUB_ARGS_DECLARATION);
-    void JIT_STUB cti_op_debug_return(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_debug_catch)(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_debug_return)(STUB_ARGS_DECLARATION);
 #endif
-    void JIT_STUB cti_op_end(STUB_ARGS_DECLARATION);
-    void JIT_STUB cti_op_jmp_scopes(STUB_ARGS_DECLARATION);
-    void JIT_STUB cti_op_pop_scope(STUB_ARGS_DECLARATION);
-    void JIT_STUB cti_op_profile_did_call(STUB_ARGS_DECLARATION);
-    void JIT_STUB cti_op_profile_will_call(STUB_ARGS_DECLARATION);
-    void JIT_STUB cti_op_put_by_id(STUB_ARGS_DECLARATION);
-    void JIT_STUB cti_op_put_by_id_fail(STUB_ARGS_DECLARATION);
-    void JIT_STUB cti_op_put_by_id_generic(STUB_ARGS_DECLARATION);
-    void JIT_STUB cti_op_put_by_index(STUB_ARGS_DECLARATION);
-    void JIT_STUB cti_op_put_by_val(STUB_ARGS_DECLARATION);
-    void JIT_STUB cti_op_put_by_val_byte_array(STUB_ARGS_DECLARATION);
-    void JIT_STUB cti_op_put_getter(STUB_ARGS_DECLARATION);
-    void JIT_STUB cti_op_put_setter(STUB_ARGS_DECLARATION);
-    void JIT_STUB cti_op_ret_scopeChain(STUB_ARGS_DECLARATION);
-    void JIT_STUB cti_op_tear_off_activation(STUB_ARGS_DECLARATION);
-    void JIT_STUB cti_op_tear_off_arguments(STUB_ARGS_DECLARATION);
-    void JIT_STUB cti_register_file_check(STUB_ARGS_DECLARATION);
-    void* JIT_STUB cti_op_call_JSFunction(STUB_ARGS_DECLARATION);
-    void* JIT_STUB cti_op_switch_char(STUB_ARGS_DECLARATION);
-    void* JIT_STUB cti_op_switch_imm(STUB_ARGS_DECLARATION);
-    void* JIT_STUB cti_op_switch_string(STUB_ARGS_DECLARATION);
-    void* JIT_STUB cti_vm_lazyLinkCall(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_end)(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_jmp_scopes)(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_pop_scope)(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_profile_did_call)(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_profile_will_call)(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_put_by_id)(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_put_by_id_fail)(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_put_by_id_generic)(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_put_by_index)(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_put_by_val)(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_put_by_val_byte_array)(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_put_getter)(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_put_setter)(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_ret_scopeChain)(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_tear_off_activation)(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_op_tear_off_arguments)(STUB_ARGS_DECLARATION);
+    void JIT_STUB JIT_STUB_NAME(cti_register_file_check)(STUB_ARGS_DECLARATION);
+    void* JIT_STUB JIT_STUB_NAME(cti_op_call_JSFunction)(STUB_ARGS_DECLARATION);
+    void* JIT_STUB JIT_STUB_NAME(cti_op_switch_char)(STUB_ARGS_DECLARATION);
+    void* JIT_STUB JIT_STUB_NAME(cti_op_switch_imm)(STUB_ARGS_DECLARATION);
+    void* JIT_STUB JIT_STUB_NAME(cti_op_switch_string)(STUB_ARGS_DECLARATION);
+    void* JIT_STUB JIT_STUB_NAME(cti_vm_lazyLinkCall)(STUB_ARGS_DECLARATION);
 } // extern "C"
 
 } // namespace JSC
diff --git a/src/script/script.pro b/src/script/script.pro
index 008c556..858c4ff 100644
--- a/src/script/script.pro
+++ b/src/script/script.pro
@@ -1,7 +1,10 @@
 TARGET     = QtScript
 QPRO_PWD   = $$PWD
 QT         = core
-DEFINES   += JSC=QTJSC jscyyparse=qtjscyyparse jscyylex=qtjscyylex jscyyerror=qtjscyyerror
+
+MYDEFINE = "\"JIT_STUB_NAME(name)=QTJSC_\\"$$LITERAL_HASH"\\"$$LITERAL_HASH"name\""
+DEFINES   += JSC=QTJSC jscyyparse=qtjscyyparse jscyylex=qtjscyylex jscyyerror=qtjscyyerror $$MYDEFINE JIT_STUB_PREFIX_STRING=\"\\\"QTJSC\\\"\"
+
 DEFINES   += QT_BUILD_SCRIPT_LIB
 DEFINES   += QT_NO_USING_NAMESPACE
 DEFINES   += QLALR_NO_QSCRIPTGRAMMAR_DEBUG_INFO
