VM/CTI.cpp

@@ALWAYS_INLINE X86Assembler::JmpSrc CTI::
312312 return call;
313313}
314314
315 ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCall(unsigned opcodeIndex, CTIHelper_j helper)
 315ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(unsigned opcodeIndex, CTIHelper_j helper)
316316{
317317#if ENABLE(SAMPLING_TOOL)
318318 m_jit.movl_i32m(1, &inCalledCode);
319319#endif
320320 m_jit.emitRestoreArgumentReference();
 321 emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
321322 X86Assembler::JmpSrc call = m_jit.emitCall();
322323 m_calls.append(CallRecord(call, helper, opcodeIndex));
323324#if ENABLE(SAMPLING_TOOL)

@@ALWAYS_INLINE X86Assembler::JmpSrc CTI::
327328 return call;
328329}
329330
330 ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCall(unsigned opcodeIndex, CTIHelper_p helper)
 331ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(unsigned opcodeIndex, CTIHelper_p helper)
331332{
332333#if ENABLE(SAMPLING_TOOL)
333334 m_jit.movl_i32m(1, &inCalledCode);
334335#endif
335336 m_jit.emitRestoreArgumentReference();
 337 emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
336338 X86Assembler::JmpSrc call = m_jit.emitCall();
337339 m_calls.append(CallRecord(call, helper, opcodeIndex));
338340#if ENABLE(SAMPLING_TOOL)

@@ALWAYS_INLINE X86Assembler::JmpSrc CTI::
342344 return call;
343345}
344346
345 ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCall(unsigned opcodeIndex, CTIHelper_b helper)
 347ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(unsigned opcodeIndex, CTIHelper_b helper)
346348{
347349#if ENABLE(SAMPLING_TOOL)
348350 m_jit.movl_i32m(1, &inCalledCode);
349351#endif
350352 m_jit.emitRestoreArgumentReference();
 353 emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
351354 X86Assembler::JmpSrc call = m_jit.emitCall();
352355 m_calls.append(CallRecord(call, helper, opcodeIndex));
353356#if ENABLE(SAMPLING_TOOL)

@@ALWAYS_INLINE X86Assembler::JmpSrc CTI::
357360 return call;
358361}
359362
360 ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCall(unsigned opcodeIndex, CTIHelper_v helper)
 363ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(unsigned opcodeIndex, CTIHelper_v helper)
361364{
362365#if ENABLE(SAMPLING_TOOL)
363366 m_jit.movl_i32m(1, &inCalledCode);
364367#endif
365368 m_jit.emitRestoreArgumentReference();
 369 emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
366370 X86Assembler::JmpSrc call = m_jit.emitCall();
367371 m_calls.append(CallRecord(call, helper, opcodeIndex));
368372#if ENABLE(SAMPLING_TOOL)

@@ALWAYS_INLINE X86Assembler::JmpSrc CTI::
372376 return call;
373377}
374378
375 ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCall(unsigned opcodeIndex, CTIHelper_s helper)
 379ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(unsigned opcodeIndex, CTIHelper_s helper)
376380{
377381#if ENABLE(SAMPLING_TOOL)
378382 m_jit.movl_i32m(1, &inCalledCode);
379383#endif
380384 m_jit.emitRestoreArgumentReference();
 385 emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
381386 X86Assembler::JmpSrc call = m_jit.emitCall();
382387 m_calls.append(CallRecord(call, helper, opcodeIndex));
383388#if ENABLE(SAMPLING_TOOL)

@@ALWAYS_INLINE X86Assembler::JmpSrc CTI::
387392 return call;
388393}
389394
390 ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCall(unsigned opcodeIndex, CTIHelper_2 helper)
 395ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(unsigned opcodeIndex, CTIHelper_2 helper)
391396{
392397#if ENABLE(SAMPLING_TOOL)
393398 m_jit.movl_i32m(1, &inCalledCode);
394399#endif
395400 m_jit.emitRestoreArgumentReference();
 401 emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
396402 X86Assembler::JmpSrc call = m_jit.emitCall();
397403 m_calls.append(CallRecord(call, helper, opcodeIndex));
398404#if ENABLE(SAMPLING_TOOL)

@@CTI::CTI(Machine* machine, CallFrame* ca
486492 case name: { \
487493 emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx); \
488494 emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx); \
489  emitCall(i, Machine::cti_##name); \
 495 emitCTICall(i, Machine::cti_##name); \
490496 emitPutResult(instruction[i + 1].u.operand); \
491497 i += 4; \
492498 break; \

@@CTI::CTI(Machine* machine, CallFrame* ca
495501#define CTI_COMPILE_UNARY_OP(name) \
496502 case name: { \
497503 emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx); \
498  emitCall(i, Machine::cti_##name); \
 504 emitCTICall(i, Machine::cti_##name); \
499505 emitPutResult(instruction[i + 1].u.operand); \
500506 i += 3; \
501507 break; \

@@void CTI::compileOpCall(Instruction* ins
553559 X86Assembler::JmpSrc wasEval;
554560 if (type == OpCallEval) {
555561 emitGetPutArg(callee, 0, X86::ecx);
556  emitCall(i, Machine::cti_op_call_eval);
 562 emitCTICall(i, Machine::cti_op_call_eval);
557563
558564 m_jit.cmpl_i32r(reinterpret_cast<unsigned>(JSImmediate::impossibleValue()), X86::eax);
559565 wasEval = m_jit.emitUnlinkedJne();

@@void CTI::compileOpCall(Instruction* ins
573579 m_jit.link(isNotObject, m_jit.label());
574580
575581 // This handles host functions
576  emitCall(i, ((type == OpConstruct) ? Machine::cti_op_construct_NotJSConstruct : Machine::cti_op_call_NotJSFunction));
 582 emitCTICall(i, ((type == OpConstruct) ? Machine::cti_op_construct_NotJSConstruct : Machine::cti_op_call_NotJSFunction));
577583
578584 X86Assembler::JmpSrc wasNotJSFunction = m_jit.emitUnlinkedJmp();
579585 m_jit.link(isJSFunction, m_jit.label());
580586
581587 // This handles JSFunctions
582  emitCall(i, (type == OpConstruct) ? Machine::cti_op_construct_JSConstruct : Machine::cti_op_call_JSFunction);
 588 emitCTICall(i, (type == OpConstruct) ? Machine::cti_op_construct_JSConstruct : Machine::cti_op_call_JSFunction);
583589
584590 compileOpCallInitializeCallFrame(callee, argCount);
585591

@@void CTI::compileOpCall(Instruction* ins
587593 m_jit.movl_mr(OBJECT_OFFSET(CodeBlock, ctiCode), X86::eax, X86::eax);
588594
589595 // Put the new value of 'callFrame' into edi and onto the stack, too.
590  emitPutCTIParam(X86::edx, CTI_ARGS_callFrame);
591596 m_jit.movl_rr(X86::edx, X86::edi);
592597
593598 // Check the ctiCode has been generated - if not, this is handled in a slow case.

@@void CTI::emitSlowScriptCheck(unsigned o
664669{
665670 m_jit.subl_i8r(1, X86::esi);
666671 X86Assembler::JmpSrc skipTimeout = m_jit.emitUnlinkedJne();
667  emitCall(opcodeIndex, Machine::cti_timeout_check);
 672 emitCTICall(opcodeIndex, Machine::cti_timeout_check);
668673
669674 emitGetCTIParam(CTI_ARGS_globalData, X86::ecx);
670675 m_jit.movl_mr(OBJECT_OFFSET(JSGlobalData, machine), X86::ecx, X86::ecx);

@@void CTI::compileBinaryArithOpSlowCase(O
891896 emitGetPutArg(src1, 0, X86::ecx);
892897 emitGetPutArg(src2, 4, X86::ecx);
893898 if (opcodeID == op_add)
894  emitCall(i, Machine::cti_op_add);
 899 emitCTICall(i, Machine::cti_op_add);
895900 else if (opcodeID == op_sub)
896  emitCall(i, Machine::cti_op_sub);
 901 emitCTICall(i, Machine::cti_op_sub);
897902 else {
898903 ASSERT(opcodeID == op_mul);
899  emitCall(i, Machine::cti_op_mul);
 904 emitCTICall(i, Machine::cti_op_mul);
900905 }
901906 emitPutResult(dst);
902907}

@@void CTI::privateCompileMainPass()
951956 else {
952957 emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
953958 emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx);
954  emitCall(i, Machine::cti_op_add);
 959 emitCTICall(i, Machine::cti_op_add);
955960 emitPutResult(instruction[i + 1].u.operand);
956961 }
957962 }

@@void CTI::privateCompileMainPass()
961966 }
962967 case op_end: {
963968 if (m_codeBlock->needsFullScopeChain)
964  emitCall(i, Machine::cti_op_end);
 969 emitCTICall(i, Machine::cti_op_end);
965970 emitGetArg(instruction[i + 1].u.operand, X86::eax);
966971#if ENABLE(SAMPLING_TOOL)
967972 m_jit.movl_i32m(-1, &currentOpcodeID);

@@void CTI::privateCompileMainPass()
10381043 break;
10391044 }
10401045 case op_new_object: {
1041  emitCall(i, Machine::cti_op_new_object);
 1046 emitCTICall(i, Machine::cti_op_new_object);
10421047 emitPutResult(instruction[i + 1].u.operand);
10431048 i += 2;
10441049 break;

@@void CTI::privateCompileMainPass()
11641169 emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
11651170 Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
11661171 emitPutArgConstant(reinterpret_cast<unsigned>(ident), 4);
1167  emitCall(i, Machine::cti_op_del_by_id);
 1172 emitCTICall(i, Machine::cti_op_del_by_id);
11681173 emitPutResult(instruction[i + 1].u.operand);
11691174 i += 4;
11701175 break;

@@void CTI::privateCompileMainPass()
12031208 case op_new_func: {
12041209 FuncDeclNode* func = (m_codeBlock->functions[instruction[i + 2].u.operand]).get();
12051210 emitPutArgConstant(reinterpret_cast<unsigned>(func), 0);
1206  emitCall(i, Machine::cti_op_new_func);
 1211 emitCTICall(i, Machine::cti_op_new_func);
12071212 emitPutResult(instruction[i + 1].u.operand);
12081213 i += 3;
12091214 break;

@@void CTI::privateCompileMainPass()
12571262 }
12581263 case op_tear_off_activation: {
12591264 emitGetPutArg(instruction[i + 1].u.operand, 0, X86::ecx);
1260  emitCall(i, Machine::cti_op_tear_off_activation);
 1265 emitCTICall(i, Machine::cti_op_tear_off_activation);
12611266 i += 2;
12621267 break;
12631268 }
12641269 case op_tear_off_arguments: {
1265  emitCall(i, Machine::cti_op_tear_off_arguments);
 1270 emitCTICall(i, Machine::cti_op_tear_off_arguments);
12661271 i += 1;
12671272 break;
12681273 }

@@void CTI::privateCompileMainPass()
12751280
12761281 // We could JIT generate the deref, only calling out to C when the refcount hits zero.
12771282 if (m_codeBlock->needsFullScopeChain)
1278  emitCall(i, Machine::cti_op_ret_scopeChain);
 1283 emitCTICall(i, Machine::cti_op_ret_scopeChain);
12791284
12801285 // Return the result in %eax.
12811286 emitGetArg(instruction[i + 1].u.operand, X86::eax);

@@void CTI::privateCompileMainPass()
12851290
12861291 // Restore our caller's "r".
12871292 emitGetArg(RegisterFile::CallerFrame, X86::edi);
1288  emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
12891293
12901294 // Return.
12911295 m_jit.pushl_r(X86::edx);

@@void CTI::privateCompileMainPass()
12931297
12941298 // Profiling hook
12951299 m_jit.link(profile, m_jit.label());
1296  emitCall(i, Machine::cti_op_ret_profiler);
 1300 emitCTICall(i, Machine::cti_op_ret_profiler);
12971301 m_jit.link(m_jit.emitUnlinkedJmp(), profiled);
12981302
12991303 i += 2;

@@void CTI::privateCompileMainPass()
13031307 m_jit.leal_mr(sizeof(Register) * instruction[i + 2].u.operand, X86::edi, X86::edx);
13041308 emitPutArg(X86::edx, 0);
13051309 emitPutArgConstant(instruction[i + 3].u.operand, 4);
1306  emitCall(i, Machine::cti_op_new_array);
 1310 emitCTICall(i, Machine::cti_op_new_array);
13071311 emitPutResult(instruction[i + 1].u.operand);
13081312 i += 4;
13091313 break;

@@void CTI::privateCompileMainPass()
13111315 case op_resolve: {
13121316 Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 2].u.operand]);
13131317 emitPutArgConstant(reinterpret_cast<unsigned>(ident), 0);
1314  emitCall(i, Machine::cti_op_resolve);
 1318 emitCTICall(i, Machine::cti_op_resolve);
13151319 emitPutResult(instruction[i + 1].u.operand);
13161320 i += 3;
13171321 break;

@@void CTI::privateCompileMainPass()
13621366 case op_resolve_func: {
13631367 Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
13641368 emitPutArgConstant(reinterpret_cast<unsigned>(ident), 0);
1365  emitCall(i, Machine::cti_op_resolve_func);
 1369 emitCTICall(i, Machine::cti_op_resolve_func);
13661370 emitPutResult(instruction[i + 1].u.operand);
13671371 emitPutResult(instruction[i + 2].u.operand, X86::edx);
13681372 i += 4;

@@void CTI::privateCompileMainPass()
14271431 case op_resolve_base: {
14281432 Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 2].u.operand]);
14291433 emitPutArgConstant(reinterpret_cast<unsigned>(ident), 0);
1430  emitCall(i, Machine::cti_op_resolve_base);
 1434 emitCTICall(i, Machine::cti_op_resolve_base);
14311435 emitPutResult(instruction[i + 1].u.operand);
14321436 i += 3;
14331437 break;
14341438 }
14351439 case op_negate: {
14361440 emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
1437  emitCall(i, Machine::cti_op_negate);
 1441 emitCTICall(i, Machine::cti_op_negate);
14381442 emitPutResult(instruction[i + 1].u.operand);
14391443 i += 3;
14401444 break;

@@void CTI::privateCompileMainPass()
14431447 Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 2].u.operand]);
14441448 emitPutArgConstant(reinterpret_cast<unsigned>(ident), 0);
14451449 emitPutArgConstant(instruction[i + 3].u.operand + m_codeBlock->needsFullScopeChain, 4);
1446  emitCall(i, Machine::cti_op_resolve_skip);
 1450 emitCTICall(i, Machine::cti_op_resolve_skip);
14471451 emitPutResult(instruction[i + 1].u.operand);
14481452 i += 4;
14491453 break;

@@void CTI::privateCompileMainPass()
14741478 emitPutArgConstant(globalObject, 0);
14751479 emitPutArgConstant(reinterpret_cast<unsigned>(ident), 4);
14761480 emitPutArgConstant(reinterpret_cast<unsigned>(instruction + i), 8);
1477  emitCall(i, Machine::cti_op_resolve_global);
 1481 emitCTICall(i, Machine::cti_op_resolve_global);
14781482 emitPutResult(instruction[i + 1].u.operand);
14791483 m_jit.link(end, m_jit.label());
14801484 i += 6;

@@void CTI::privateCompileMainPass()
16461650 case op_resolve_with_base: {
16471651 Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
16481652 emitPutArgConstant(reinterpret_cast<unsigned>(ident), 0);
1649  emitCall(i, Machine::cti_op_resolve_with_base);
 1653 emitCTICall(i, Machine::cti_op_resolve_with_base);
16501654 emitPutResult(instruction[i + 1].u.operand);
16511655 emitPutResult(instruction[i + 2].u.operand, X86::edx);
16521656 i += 4;

@@void CTI::privateCompileMainPass()
16551659 case op_new_func_exp: {
16561660 FuncExprNode* func = (m_codeBlock->functionExpressions[instruction[i + 2].u.operand]).get();
16571661 emitPutArgConstant(reinterpret_cast<unsigned>(func), 0);
1658  emitCall(i, Machine::cti_op_new_func_exp);
 1662 emitCTICall(i, Machine::cti_op_new_func_exp);
16591663 emitPutResult(instruction[i + 1].u.operand);
16601664 i += 3;
16611665 break;

@@void CTI::privateCompileMainPass()
17351739 case op_new_regexp: {
17361740 RegExp* regExp = m_codeBlock->regexps[instruction[i + 2].u.operand].get();
17371741 emitPutArgConstant(reinterpret_cast<unsigned>(regExp), 0);
1738  emitCall(i, Machine::cti_op_new_regexp);
 1742 emitCTICall(i, Machine::cti_op_new_regexp);
17391743 emitPutResult(instruction[i + 1].u.operand);
17401744 i += 3;
17411745 break;

@@void CTI::privateCompileMainPass()
17561760 }
17571761 case op_throw: {
17581762 emitGetPutArg(instruction[i + 1].u.operand, 0, X86::ecx);
1759  emitCall(i, Machine::cti_op_throw);
 1763 emitCTICall(i, Machine::cti_op_throw);
17601764 m_jit.addl_i8r(0x24, X86::esp);
17611765 m_jit.popl_r(X86::edi);
17621766 m_jit.popl_r(X86::esi);

@@void CTI::privateCompileMainPass()
17661770 }
17671771 case op_get_pnames: {
17681772 emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
1769  emitCall(i, Machine::cti_op_get_pnames);
 1773 emitCTICall(i, Machine::cti_op_get_pnames);
17701774 emitPutResult(instruction[i + 1].u.operand);
17711775 i += 3;
17721776 break;

@@void CTI::privateCompileMainPass()
17741778 case op_next_pname: {
17751779 emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
17761780 unsigned target = instruction[i + 3].u.operand;
1777  emitCall(i, Machine::cti_op_next_pname);
 1781 emitCTICall(i, Machine::cti_op_next_pname);
17781782 m_jit.testl_rr(X86::eax, X86::eax);
17791783 X86Assembler::JmpSrc endOfIter = m_jit.emitUnlinkedJe();
17801784 emitPutResult(instruction[i + 1].u.operand);

@@void CTI::privateCompileMainPass()
17851789 }
17861790 case op_push_scope: {
17871791 emitGetPutArg(instruction[i + 1].u.operand, 0, X86::ecx);
1788  emitCall(i, Machine::cti_op_push_scope);
 1792 emitCTICall(i, Machine::cti_op_push_scope);
17891793 i += 2;
17901794 break;
17911795 }
17921796 case op_pop_scope: {
1793  emitCall(i, Machine::cti_op_pop_scope);
 1797 emitCTICall(i, Machine::cti_op_pop_scope);
17941798 i += 1;
17951799 break;
17961800 }

@@void CTI::privateCompileMainPass()
18331837 case op_in: {
18341838 emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
18351839 emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx);
1836  emitCall(i, Machine::cti_op_in);
 1840 emitCTICall(i, Machine::cti_op_in);
18371841 emitPutResult(instruction[i + 1].u.operand);
18381842 i += 4;
18391843 break;

@@void CTI::privateCompileMainPass()
18421846 Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 2].u.operand]);
18431847 emitPutArgConstant(reinterpret_cast<unsigned>(ident), 0);
18441848 emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx);
1845  emitCall(i, Machine::cti_op_push_new_scope);
 1849 emitCTICall(i, Machine::cti_op_push_new_scope);
18461850 emitPutResult(instruction[i + 1].u.operand);
18471851 i += 4;
18481852 break;

@@void CTI::privateCompileMainPass()
18561860 case op_jmp_scopes: {
18571861 unsigned count = instruction[i + 1].u.operand;
18581862 emitPutArgConstant(count, 0);
1859  emitCall(i, Machine::cti_op_jmp_scopes);
 1863 emitCTICall(i, Machine::cti_op_jmp_scopes);
18601864 unsigned target = instruction[i + 2].u.operand;
18611865 m_jmpTable.append(JmpTable(m_jit.emitUnlinkedJmp(), i + 2 + target));
18621866 i += 3;

@@void CTI::privateCompileMainPass()
18661870 emitGetPutArg(instruction[i + 1].u.operand, 0, X86::ecx);
18671871 emitPutArgConstant(instruction[i + 2].u.operand, 4);
18681872 emitGetPutArg(instruction[i + 3].u.operand, 8, X86::ecx);
1869  emitCall(i, Machine::cti_op_put_by_index);
 1873 emitCTICall(i, Machine::cti_op_put_by_index);
18701874 i += 4;
18711875 break;
18721876 }

@@void CTI::privateCompileMainPass()
18821886
18831887 emitGetPutArg(scrutinee, 0, X86::ecx);
18841888 emitPutArgConstant(tableIndex, 4);
1885  emitCall(i, Machine::cti_op_switch_imm);
 1889 emitCTICall(i, Machine::cti_op_switch_imm);
18861890 m_jit.jmp_r(X86::eax);
18871891 i += 4;
18881892 break;

@@void CTI::privateCompileMainPass()
18991903
19001904 emitGetPutArg(scrutinee, 0, X86::ecx);
19011905 emitPutArgConstant(tableIndex, 4);
1902  emitCall(i, Machine::cti_op_switch_char);
 1906 emitCTICall(i, Machine::cti_op_switch_char);
19031907 m_jit.jmp_r(X86::eax);
19041908 i += 4;
19051909 break;

@@void CTI::privateCompileMainPass()
19151919
19161920 emitGetPutArg(scrutinee, 0, X86::ecx);
19171921 emitPutArgConstant(tableIndex, 4);
1918  emitCall(i, Machine::cti_op_switch_string);
 1922 emitCTICall(i, Machine::cti_op_switch_string);
19191923 m_jit.jmp_r(X86::eax);
19201924 i += 4;
19211925 break;

@@void CTI::privateCompileMainPass()
19231927 case op_del_by_val: {
19241928 emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
19251929 emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx);
1926  emitCall(i, Machine::cti_op_del_by_val);
 1930 emitCTICall(i, Machine::cti_op_del_by_val);
19271931 emitPutResult(instruction[i + 1].u.operand);
19281932 i += 4;
19291933 break;

@@void CTI::privateCompileMainPass()
19331937 Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 2].u.operand]);
19341938 emitPutArgConstant(reinterpret_cast<unsigned>(ident), 4);
19351939 emitGetPutArg(instruction[i + 3].u.operand, 8, X86::ecx);
1936  emitCall(i, Machine::cti_op_put_getter);
 1940 emitCTICall(i, Machine::cti_op_put_getter);
19371941 i += 4;
19381942 break;
19391943 }

@@void CTI::privateCompileMainPass()
19421946 Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 2].u.operand]);
19431947 emitPutArgConstant(reinterpret_cast<unsigned>(ident), 4);
19441948 emitGetPutArg(instruction[i + 3].u.operand, 8, X86::ecx);
1945  emitCall(i, Machine::cti_op_put_setter);
 1949 emitCTICall(i, Machine::cti_op_put_setter);
19461950 i += 4;
19471951 break;
19481952 }

@@void CTI::privateCompileMainPass()
19511955 emitPutArgConstant(instruction[i + 2].u.operand, 0);
19521956 emitPutArgConstant(reinterpret_cast<unsigned>(message), 4);
19531957 emitPutArgConstant(m_codeBlock->lineNumberForVPC(&instruction[i]), 8);
1954  emitCall(i, Machine::cti_op_new_error);
 1958 emitCTICall(i, Machine::cti_op_new_error);
19551959 emitPutResult(instruction[i + 1].u.operand);
19561960 i += 4;
19571961 break;

@@void CTI::privateCompileMainPass()
19601964 emitPutArgConstant(instruction[i + 1].u.operand, 0);
19611965 emitPutArgConstant(instruction[i + 2].u.operand, 4);
19621966 emitPutArgConstant(instruction[i + 3].u.operand, 8);
1963  emitCall(i, Machine::cti_op_debug);
 1967 emitCTICall(i, Machine::cti_op_debug);
19641968 i += 4;
19651969 break;
19661970 }

@@void CTI::privateCompileMainPass()
20432047 for (size_t j = 0; j < count; ++j)
20442048 emitInitRegister(j);
20452049
2046  emitCall(i, Machine::cti_op_push_activation);
 2050 emitCTICall(i, Machine::cti_op_push_activation);
20472051 emitPutResult(instruction[i + 1].u.operand);
20482052
20492053 i+= 2;
20502054 break;
20512055 }
20522056 case op_create_arguments: {
2053  emitCall(i, Machine::cti_op_create_arguments);
 2057 emitCTICall(i, Machine::cti_op_create_arguments);
20542058 i += 1;
20552059 break;
20562060 }

@@void CTI::privateCompileLinkPass()
20952099 m_jit.link(iter->from, m_jit.label()); \
20962100 emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx); \
20972101 emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx); \
2098  emitCall(i, Machine::cti_##name); \
 2102 emitCTICall(i, Machine::cti_##name); \
20992103 emitPutResult(instruction[i + 1].u.operand); \
21002104 i += 4; \
21012105 break; \

@@void CTI::privateCompileSlowCases()
21132117 m_jit.link(iter->from, m_jit.label());
21142118 m_jit.link((++iter)->from, m_jit.label());
21152119 emitPutArg(X86::eax, 0);
2116  emitCall(i, Machine::cti_op_convert_this);
 2120 emitCTICall(i, Machine::cti_op_convert_this);
21172121 emitPutResult(instruction[i + 1].u.operand);
21182122 i += 2;
21192123 break;

@@void CTI::privateCompileSlowCases()
21292133 m_jit.link(notImm, m_jit.label());
21302134 emitGetPutArg(src1, 0, X86::ecx);
21312135 emitPutArg(X86::edx, 4);
2132  emitCall(i, Machine::cti_op_add);
 2136 emitCTICall(i, Machine::cti_op_add);
21332137 emitPutResult(dst);
21342138 } else if (JSValue* value = getConstantImmediateNumericArg(src2)) {
21352139 X86Assembler::JmpSrc notImm = iter->from;

@@void CTI::privateCompileSlowCases()
21382142 m_jit.link(notImm, m_jit.label());
21392143 emitPutArg(X86::eax, 0);
21402144 emitGetPutArg(src2, 4, X86::ecx);
2141  emitCall(i, Machine::cti_op_add);
 2145 emitCTICall(i, Machine::cti_op_add);
21422146 emitPutResult(dst);
21432147 } else {
21442148 OperandTypes types = OperandTypes::fromInt(instruction[i + 4].u.operand);

@@void CTI::privateCompileSlowCases()
21622166 m_jit.link(notImm, m_jit.label());
21632167 emitPutArg(X86::eax, 0);
21642168 emitPutArg(X86::edx, 4);
2165  emitCall(i, Machine::cti_op_get_by_val);
 2169 emitCTICall(i, Machine::cti_op_get_by_val);
21662170 emitPutResult(instruction[i + 1].u.operand);
21672171 m_jit.link(m_jit.emitUnlinkedJmp(), m_labels[i + 4]);
21682172

@@void CTI::privateCompileSlowCases()
21922196 m_jit.link((++iter)->from, m_jit.label());
21932197 emitPutArg(X86::eax, 0);
21942198 emitPutArg(X86::ecx, 4);
2195  emitCall(i, Machine::cti_op_rshift);
 2199 emitCTICall(i, Machine::cti_op_rshift);
21962200 emitPutResult(instruction[i + 1].u.operand);
21972201 i += 4;
21982202 break;

@@void CTI::privateCompileSlowCases()
22072211 m_jit.link(notImm2, m_jit.label());
22082212 emitPutArg(X86::eax, 0);
22092213 emitPutArg(X86::ecx, 4);
2210  emitCall(i, Machine::cti_op_lshift);
 2214 emitCTICall(i, Machine::cti_op_lshift);
22112215 emitPutResult(instruction[i + 1].u.operand);
22122216 i += 4;
22132217 break;

@@void CTI::privateCompileSlowCases()
22212225 m_jit.link(iter->from, m_jit.label());
22222226 emitPutArg(X86::edx, 0);
22232227 emitGetPutArg(instruction[i + 2].u.operand, 4, X86::ecx);
2224  emitCall(i, Machine::cti_op_loop_if_less);
 2228 emitCTICall(i, Machine::cti_op_loop_if_less);
22252229 m_jit.testl_rr(X86::eax, X86::eax);
22262230 m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 3 + target]);
22272231 } else {

@@void CTI::privateCompileSlowCases()
22292233 m_jit.link((++iter)->from, m_jit.label());
22302234 emitPutArg(X86::eax, 0);
22312235 emitPutArg(X86::edx, 4);
2232  emitCall(i, Machine::cti_op_loop_if_less);
 2236 emitCTICall(i, Machine::cti_op_loop_if_less);
22332237 m_jit.testl_rr(X86::eax, X86::eax);
22342238 m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 3 + target]);
22352239 }

@@void CTI::privateCompileSlowCases()
22442248 emitPutArgConstant(reinterpret_cast<unsigned>(ident), 4);
22452249 emitPutArg(X86::eax, 0);
22462250 emitPutArg(X86::edx, 8);
2247  X86Assembler::JmpSrc call = emitCall(i, Machine::cti_op_put_by_id);
 2251 X86Assembler::JmpSrc call = emitCTICall(i, Machine::cti_op_put_by_id);
22482252
22492253 // Track the location of the call; this will be used to recover repatch information.
22502254 ASSERT(m_codeBlock->structureIDInstructions[structureIDInstructionIndex].opcodeIndex == i);

@@void CTI::privateCompileSlowCases()
22702274 emitPutArg(X86::eax, 0);
22712275 Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
22722276 emitPutArgConstant(reinterpret_cast<unsigned>(ident), 4);
2273  X86Assembler::JmpSrc call = emitCall(i, Machine::cti_op_get_by_id);
 2277 X86Assembler::JmpSrc call = emitCTICall(i, Machine::cti_op_get_by_id);
22742278 ASSERT(X86Assembler::getDifferenceBetweenLabels(coldPathBegin, call) == repatchOffsetGetByIdSlowCaseCall);
22752279 emitPutResult(instruction[i + 1].u.operand);
22762280

@@void CTI::privateCompileSlowCases()
22962300 m_jit.link(iter->from, m_jit.label());
22972301 emitPutArg(X86::edx, 0);
22982302 emitGetPutArg(instruction[i + 2].u.operand, 4, X86::ecx);
2299  emitCall(i, Machine::cti_op_loop_if_lesseq);
 2303 emitCTICall(i, Machine::cti_op_loop_if_lesseq);
23002304 m_jit.testl_rr(X86::eax, X86::eax);
23012305 m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 3 + target]);
23022306 } else {

@@void CTI::privateCompileSlowCases()
23042308 m_jit.link((++iter)->from, m_jit.label());
23052309 emitPutArg(X86::eax, 0);
23062310 emitPutArg(X86::edx, 4);
2307  emitCall(i, Machine::cti_op_loop_if_lesseq);
 2311 emitCTICall(i, Machine::cti_op_loop_if_lesseq);
23082312 m_jit.testl_rr(X86::eax, X86::eax);
23092313 m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 3 + target]);
23102314 }

@@void CTI::privateCompileSlowCases()
23182322 m_jit.subl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), X86::eax);
23192323 m_jit.link(notImm, m_jit.label());
23202324 emitPutArg(X86::eax, 0);
2321  emitCall(i, Machine::cti_op_pre_inc);
 2325 emitCTICall(i, Machine::cti_op_pre_inc);
23222326 emitPutResult(srcDst);
23232327 i += 2;
23242328 break;

@@void CTI::privateCompileSlowCases()
23342338 emitPutArg(X86::eax, 0);
23352339 emitPutArg(X86::edx, 4);
23362340 emitPutArg(X86::ecx, 8);
2337  emitCall(i, Machine::cti_op_put_by_val);
 2341 emitCTICall(i, Machine::cti_op_put_by_val);
23382342 m_jit.link(m_jit.emitUnlinkedJmp(), m_labels[i + 4]);
23392343
23402344 // slow cases for immediate int accesses to arrays

@@void CTI::privateCompileSlowCases()
23442348 emitPutArg(X86::eax, 0);
23452349 emitPutArg(X86::edx, 4);
23462350 emitPutArg(X86::ecx, 8);
2347  emitCall(i, Machine::cti_op_put_by_val_array);
 2351 emitCTICall(i, Machine::cti_op_put_by_val_array);
23482352
23492353 i += 4;
23502354 break;

@@void CTI::privateCompileSlowCases()
23542358
23552359 m_jit.link(iter->from, m_jit.label());
23562360 emitPutArg(X86::eax, 0);
2357  emitCall(i, Machine::cti_op_jtrue);
 2361 emitCTICall(i, Machine::cti_op_jtrue);
23582362 m_jit.testl_rr(X86::eax, X86::eax);
23592363 unsigned target = instruction[i + 2].u.operand;
23602364 m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 2 + target]);

@@void CTI::privateCompileSlowCases()
23682372 m_jit.addl_i8r(getDeTaggedConstantImmediate(JSImmediate::oneImmediate()), X86::eax);
23692373 m_jit.link(notImm, m_jit.label());
23702374 emitPutArg(X86::eax, 0);
2371  emitCall(i, Machine::cti_op_pre_dec);
 2375 emitCTICall(i, Machine::cti_op_pre_dec);
23722376 emitPutResult(srcDst);
23732377 i += 2;
23742378 break;

@@void CTI::privateCompileSlowCases()
23802384 m_jit.link(iter->from, m_jit.label());
23812385 emitPutArg(X86::edx, 0);
23822386 emitGetPutArg(instruction[i + 2].u.operand, 4, X86::ecx);
2383  emitCall(i, Machine::cti_op_jless);
 2387 emitCTICall(i, Machine::cti_op_jless);
23842388 m_jit.testl_rr(X86::eax, X86::eax);
23852389 m_jit.link(m_jit.emitUnlinkedJe(), m_labels[i + 3 + target]);
23862390 } else {

@@void CTI::privateCompileSlowCases()
23882392 m_jit.link((++iter)->from, m_jit.label());
23892393 emitPutArg(X86::eax, 0);
23902394 emitPutArg(X86::edx, 4);
2391  emitCall(i, Machine::cti_op_jless);
 2395 emitCTICall(i, Machine::cti_op_jless);
23922396 m_jit.testl_rr(X86::eax, X86::eax);
23932397 m_jit.link(m_jit.emitUnlinkedJe(), m_labels[i + 3 + target]);
23942398 }

@@void CTI::privateCompileSlowCases()
23992403 m_jit.link(iter->from, m_jit.label());
24002404 m_jit.xorl_i8r(JSImmediate::FullTagTypeBool, X86::eax);
24012405 emitPutArg(X86::eax, 0);
2402  emitCall(i, Machine::cti_op_not);
 2406 emitCTICall(i, Machine::cti_op_not);
24032407 emitPutResult(instruction[i + 1].u.operand);
24042408 i += 3;
24052409 break;

@@void CTI::privateCompileSlowCases()
24072411 case op_jfalse: {
24082412 m_jit.link(iter->from, m_jit.label());
24092413 emitPutArg(X86::eax, 0);
2410  emitCall(i, Machine::cti_op_jtrue);
 2414 emitCTICall(i, Machine::cti_op_jtrue);
24112415 m_jit.testl_rr(X86::eax, X86::eax);
24122416 unsigned target = instruction[i + 2].u.operand;
24132417 m_jit.link(m_jit.emitUnlinkedJe(), m_labels[i + 2 + target]); // inverted!

@@void CTI::privateCompileSlowCases()
24192423 m_jit.link(iter->from, m_jit.label());
24202424 m_jit.link((++iter)->from, m_jit.label());
24212425 emitPutArg(X86::eax, 0);
2422  emitCall(i, Machine::cti_op_post_inc);
 2426 emitCTICall(i, Machine::cti_op_post_inc);
24232427 emitPutResult(instruction[i + 1].u.operand);
24242428 emitPutResult(srcDst, X86::edx);
24252429 i += 3;

@@void CTI::privateCompileSlowCases()
24282432 case op_bitnot: {
24292433 m_jit.link(iter->from, m_jit.label());
24302434 emitPutArg(X86::eax, 0);
2431  emitCall(i, Machine::cti_op_bitnot);
 2435 emitCTICall(i, Machine::cti_op_bitnot);
24322436 emitPutResult(instruction[i + 1].u.operand);
24332437 i += 3;
24342438 break;

@@void CTI::privateCompileSlowCases()
24412445 m_jit.link(iter->from, m_jit.label());
24422446 emitGetPutArg(src1, 0, X86::ecx);
24432447 emitPutArg(X86::eax, 4);
2444  emitCall(i, Machine::cti_op_bitand);
 2448 emitCTICall(i, Machine::cti_op_bitand);
24452449 emitPutResult(dst);
24462450 } else if (getConstantImmediateNumericArg(src2)) {
24472451 m_jit.link(iter->from, m_jit.label());
24482452 emitPutArg(X86::eax, 0);
24492453 emitGetPutArg(src2, 4, X86::ecx);
2450  emitCall(i, Machine::cti_op_bitand);
 2454 emitCTICall(i, Machine::cti_op_bitand);
24512455 emitPutResult(dst);
24522456 } else {
24532457 m_jit.link(iter->from, m_jit.label());
24542458 emitGetPutArg(src1, 0, X86::ecx);
24552459 emitPutArg(X86::edx, 4);
2456  emitCall(i, Machine::cti_op_bitand);
 2460 emitCTICall(i, Machine::cti_op_bitand);
24572461 emitPutResult(dst);
24582462 }
24592463 i += 5;

@@void CTI::privateCompileSlowCases()
24622466 case op_jtrue: {
24632467 m_jit.link(iter->from, m_jit.label());
24642468 emitPutArg(X86::eax, 0);
2465  emitCall(i, Machine::cti_op_jtrue);
 2469 emitCTICall(i, Machine::cti_op_jtrue);
24662470 m_jit.testl_rr(X86::eax, X86::eax);
24672471 unsigned target = instruction[i + 2].u.operand;
24682472 m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 2 + target]);

@@void CTI::privateCompileSlowCases()
24742478 m_jit.link(iter->from, m_jit.label());
24752479 m_jit.link((++iter)->from, m_jit.label());
24762480 emitPutArg(X86::eax, 0);
2477  emitCall(i, Machine::cti_op_post_dec);
 2481 emitCTICall(i, Machine::cti_op_post_dec);
24782482 emitPutResult(instruction[i + 1].u.operand);
24792483 emitPutResult(srcDst, X86::edx);
24802484 i += 3;

@@void CTI::privateCompileSlowCases()
24842488 m_jit.link(iter->from, m_jit.label());
24852489 emitPutArg(X86::eax, 0);
24862490 emitPutArg(X86::edx, 4);
2487  emitCall(i, Machine::cti_op_bitxor);
 2491 emitCTICall(i, Machine::cti_op_bitxor);
24882492 emitPutResult(instruction[i + 1].u.operand);
24892493 i += 5;
24902494 break;

@@void CTI::privateCompileSlowCases()
24932497 m_jit.link(iter->from, m_jit.label());
24942498 emitPutArg(X86::eax, 0);
24952499 emitPutArg(X86::edx, 4);
2496  emitCall(i, Machine::cti_op_bitor);
 2500 emitCTICall(i, Machine::cti_op_bitor);
24972501 emitPutResult(instruction[i + 1].u.operand);
24982502 i += 5;
24992503 break;

@@void CTI::privateCompileSlowCases()
25022506 m_jit.link(iter->from, m_jit.label());
25032507 emitPutArg(X86::eax, 0);
25042508 emitPutArg(X86::edx, 4);
2505  emitCall(i, Machine::cti_op_eq);
 2509 emitCTICall(i, Machine::cti_op_eq);
25062510 emitPutResult(instruction[i + 1].u.operand);
25072511 i += 4;
25082512 break;

@@void CTI::privateCompileSlowCases()
25112515 m_jit.link(iter->from, m_jit.label());
25122516 emitPutArg(X86::eax, 0);
25132517 emitPutArg(X86::edx, 4);
2514  emitCall(i, Machine::cti_op_neq);
 2518 emitCTICall(i, Machine::cti_op_neq);
25152519 emitPutResult(instruction[i + 1].u.operand);
25162520 i += 4;
25172521 break;

@@void CTI::privateCompileSlowCases()
25232527 emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
25242528 emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx);
25252529 emitGetPutArg(instruction[i + 4].u.operand, 8, X86::ecx);
2526  emitCall(i, Machine::cti_op_instanceof);
 2530 emitCTICall(i, Machine::cti_op_instanceof);
25272531 emitPutResult(instruction[i + 1].u.operand);
25282532 i += 5;
25292533 break;

@@void CTI::privateCompileSlowCases()
25382542 m_jit.link(notImm2, m_jit.label());
25392543 emitPutArg(X86::eax, 0);
25402544 emitPutArg(X86::ecx, 4);
2541  emitCall(i, Machine::cti_op_mod);
 2545 emitCTICall(i, Machine::cti_op_mod);
25422546 emitPutResult(instruction[i + 1].u.operand);
25432547 i += 4;
25442548 break;

@@void CTI::privateCompileSlowCases()
25552559 // There is an extra slow case for (op1 * -N) or (-N * op2), to check for 0 since this should produce a result of -0.
25562560 emitGetPutArg(src1, 0, X86::ecx);
25572561 emitGetPutArg(src2, 4, X86::ecx);
2558  emitCall(i, Machine::cti_op_mul);
 2562 emitCTICall(i, Machine::cti_op_mul);
25592563 emitPutResult(dst);
25602564 } else if (src2Value && ((value = JSImmediate::intValue(src2Value)) > 0)) {
25612565 m_jit.link(iter->from, m_jit.label());
25622566 // There is an extra slow case for (op1 * -N) or (-N * op2), to check for 0 since this should produce a result of -0.
25632567 emitGetPutArg(src1, 0, X86::ecx);
25642568 emitGetPutArg(src2, 4, X86::ecx);
2565  emitCall(i, Machine::cti_op_mul);
 2569 emitCTICall(i, Machine::cti_op_mul);
25662570 emitPutResult(dst);
25672571 } else
25682572 compileBinaryArithOpSlowCase(op_mul, iter, dst, src1, src2, OperandTypes::fromInt(instruction[i + 4].u.operand), i);

@@void CTI::privateCompileSlowCases()
25762580 m_jit.link(iter->from, m_jit.label());
25772581
25782582 // We jump to this slow case if the ctiCode for the codeBlock has not yet been generated; compile it now.
2579  emitCall(i, Machine::cti_vm_compile);
 2583 emitCTICall(i, Machine::cti_vm_compile);
25802584 emitCall(i, X86::eax);
25812585
25822586 // Instead of checking for 0 we could initialize the CodeBlock::ctiCode to point to a trampoline that would trigger the translation.

@@void CTI::privateCompileSlowCases()
25912595 m_jit.link(iter->from, m_jit.label());
25922596
25932597 emitPutArg(X86::eax, 0);
2594  emitCall(i, Machine::cti_op_to_jsnumber);
 2598 emitCTICall(i, Machine::cti_op_to_jsnumber);
25952599
25962600 emitPutResult(instruction[i + 1].u.operand);
25972601 i += 3;

@@void CTI::privateCompile()
26312635
26322636 if (m_codeBlock->codeType == FunctionCode) {
26332637 m_jit.link(slowRegisterFileCheck, m_jit.label());
2634  emitCall(0, Machine::cti_register_file_check);
 2638 emitCTICall(0, Machine::cti_register_file_check);
26352639 X86Assembler::JmpSrc backToBody = m_jit.emitUnlinkedJmp();
26362640 m_jit.link(backToBody, afterRegisterFileCheck);
26372641 }
37647

VM/CTI.h

4444#define CTI_ARGS_exception 0x0F
4545#define CTI_ARGS_profilerReference 0x10
4646#define CTI_ARGS_globalData 0x11
47 #define ARG_registerFile ((RegisterFile*)(ARGS)[CTI_ARGS_registerFile])
4847#define ARG_callFrame ((CallFrame*)(ARGS)[CTI_ARGS_callFrame])
 48#define ARG_registerFile ((RegisterFile*)(ARGS)[CTI_ARGS_registerFile])
4949#define ARG_exception ((JSValue**)(ARGS)[CTI_ARGS_exception])
5050#define ARG_profilerReference ((Profiler**)(ARGS)[CTI_ARGS_profilerReference])
5151#define ARG_globalData ((JSGlobalData*)(ARGS)[CTI_ARGS_globalData])

@@namespace JSC {
253253 static const int repatchOffsetGetByIdBranchToSlowCase = 25;
254254 static const int repatchOffsetGetByIdPropertyMapOffset = 34;
255255#if ENABLE(SAMPLING_TOOL)
256  static const int repatchOffsetGetByIdSlowCaseCall = 27 + ctiArgumentInitSize;
 256 static const int repatchOffsetGetByIdSlowCaseCall = 27 + 4 + ctiArgumentInitSize;
257257#else
258  static const int repatchOffsetGetByIdSlowCaseCall = 17 + ctiArgumentInitSize;
 258 static const int repatchOffsetGetByIdSlowCaseCall = 17 + 4 + ctiArgumentInitSize;
259259#endif
260260
261261 public:

@@namespace JSC {
389389 void emitTagAsBoolImmediate(X86Assembler::RegisterID reg);
390390
391391 X86Assembler::JmpSrc emitCall(unsigned opcodeIndex, X86::RegisterID);
392  X86Assembler::JmpSrc emitCall(unsigned opcodeIndex, CTIHelper_j);
393  X86Assembler::JmpSrc emitCall(unsigned opcodeIndex, CTIHelper_p);
394  X86Assembler::JmpSrc emitCall(unsigned opcodeIndex, CTIHelper_v);
395  X86Assembler::JmpSrc emitCall(unsigned opcodeIndex, CTIHelper_s);
396  X86Assembler::JmpSrc emitCall(unsigned opcodeIndex, CTIHelper_b);
397  X86Assembler::JmpSrc emitCall(unsigned opcodeIndex, CTIHelper_2);
 392 X86Assembler::JmpSrc emitCTICall(unsigned opcodeIndex, CTIHelper_j);
 393 X86Assembler::JmpSrc emitCTICall(unsigned opcodeIndex, CTIHelper_p);
 394 X86Assembler::JmpSrc emitCTICall(unsigned opcodeIndex, CTIHelper_v);
 395 X86Assembler::JmpSrc emitCTICall(unsigned opcodeIndex, CTIHelper_s);
 396 X86Assembler::JmpSrc emitCTICall(unsigned opcodeIndex, CTIHelper_b);
 397 X86Assembler::JmpSrc emitCTICall(unsigned opcodeIndex, CTIHelper_2);
398398
399399 void emitGetVariableObjectRegister(X86Assembler::RegisterID variableObject, int index, X86Assembler::RegisterID dst);
400400 void emitPutVariableObjectRegister(X86Assembler::RegisterID src, X86Assembler::RegisterID variableObject, int index);
37645