jit/JITCall.cpp

   1 /*
   2  * Copyright (C) 2008 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "JIT.h"
  28
  29 #if ENABLE(JIT)
  30
  31 #include "CodeBlock.h"
  32 #include "JITInlineMethods.h"
  33 #include "JITStubCall.h"
  34 #include "JSArray.h"
  35 #include "JSFunction.h"
  36 #include "Interpreter.h"
  37 #include "ResultType.h"
  38 #include "SamplingTool.h"
  39
  40 #ifndef NDEBUG
  41 #include <stdio.h>
  42 #endif
  43
  44 using namespace std;
  45
  46 namespace JSC {
  47
  48 #if USE(JSVALUE32_64)
  49
  50 void JIT::compileOpCallInitializeCallFrame()
  51 {
  52     // regT0 holds callee, regT1 holds argCount
  53     store32(regT1, Address(callFrameRegister, RegisterFile::ArgumentCount * static_cast<int>(sizeof(Register))));
  54
  55     loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_data) + OBJECT_OFFSETOF(ScopeChain, m_node)), regT1); // scopeChain
  56
  57     emitStore(static_cast<unsigned>(RegisterFile::OptionalCalleeArguments), JSValue());
  58     storePtr(regT0, Address(callFrameRegister, RegisterFile::Callee * static_cast<int>(sizeof(Register)))); // callee
  59     storePtr(regT1, Address(callFrameRegister, RegisterFile::ScopeChain * static_cast<int>(sizeof(Register)))); // scopeChain
  60 }
  61
  62 void JIT::compileOpCallSetupArgs(Instruction* instruction)
  63 {
  64     int argCount = instruction[3].u.operand;
  65     int registerOffset = instruction[4].u.operand;
  66
  67     emitPutJITStubArg(regT1, regT0, 0);
  68     emitPutJITStubArgConstant(registerOffset, 1);
  69     emitPutJITStubArgConstant(argCount, 2);
  70 }
  71
  72 void JIT::compileOpConstructSetupArgs(Instruction* instruction)
  73 {
  74     int argCount = instruction[3].u.operand;
  75     int registerOffset = instruction[4].u.operand;
  76     int proto = instruction[5].u.operand;
  77     int thisRegister = instruction[6].u.operand;
  78
  79     emitPutJITStubArg(regT1, regT0, 0);
  80     emitPutJITStubArgConstant(registerOffset, 1);
  81     emitPutJITStubArgConstant(argCount, 2);
  82     emitPutJITStubArgFromVirtualRegister(proto, 3, regT2, regT3);
  83     emitPutJITStubArgConstant(thisRegister, 4);
  84 }
  85
  86 void JIT::compileOpCallVarargsSetupArgs(Instruction*)
  87 {
  88     emitPutJITStubArg(regT1, regT0, 0);
  89     emitPutJITStubArg(regT3, 1); // registerOffset
  90     emitPutJITStubArg(regT2, 2); // argCount
  91 }
  92
  93 void JIT::compileOpCallVarargs(Instruction* instruction)
  94 {
  95     int dst = instruction[1].u.operand;
  96     int callee = instruction[2].u.operand;
  97     int argCountRegister = instruction[3].u.operand;
  98     int registerOffset = instruction[4].u.operand;
  99
 100     emitLoad(callee, regT1, regT0);
 101     emitLoadPayload(argCountRegister, regT2); // argCount
 102     addPtr(Imm32(registerOffset), regT2, regT3); // registerOffset
 103
 104     compileOpCallVarargsSetupArgs(instruction);
 105
 106     emitJumpSlowCaseIfNotJSCell(callee, regT1);
 107     addSlowCase(branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsFunctionVPtr)));
 108
 109     // Speculatively roll the callframe, assuming argCount will match the arity.
 110     mul32(Imm32(sizeof(Register)), regT3, regT3);
 111     addPtr(callFrameRegister, regT3);
 112     storePtr(callFrameRegister, Address(regT3, RegisterFile::CallerFrame * static_cast<int>(sizeof(Register))));
 113     move(regT3, callFrameRegister);
 114
 115     move(regT2, regT1); // argCount
 116
 117     emitNakedCall(m_globalData->jitStubs->ctiVirtualCall());
 118
 119     emitStore(dst, regT1, regT0);
 120
 121     sampleCodeBlock(m_codeBlock);
 122 }
 123
 124 void JIT::compileOpCallVarargsSlowCase(Instruction* instruction, Vector<SlowCaseEntry>::iterator& iter)
 125 {
 126     int dst = instruction[1].u.operand;
 127     int callee = instruction[2].u.operand;
 128
 129     linkSlowCaseIfNotJSCell(iter, callee);
 130     linkSlowCase(iter);
 131
 132     JITStubCall stubCall(this, cti_op_call_NotJSFunction);
 133     stubCall.call(dst); // In the interpreter, the callee puts the return value in dst.
 134
 135     map(m_bytecodeIndex + OPCODE_LENGTH(op_call_varargs), dst, regT1, regT0);
 136     sampleCodeBlock(m_codeBlock);
 137 }
 138
 139 void JIT::emit_op_ret(Instruction* currentInstruction)
 140 {
 141     unsigned dst = currentInstruction[1].u.operand;
 142
 143     // We could JIT generate the deref, only calling out to C when the refcount hits zero.
 144     if (m_codeBlock->needsFullScopeChain())
 145         JITStubCall(this, cti_op_ret_scopeChain).call();
 146
 147     emitLoad(dst, regT1, regT0);
 148     emitGetFromCallFrameHeaderPtr(RegisterFile::ReturnPC, regT2);
 149     emitGetFromCallFrameHeaderPtr(RegisterFile::CallerFrame, callFrameRegister);
 150
 151     restoreReturnAddressBeforeReturn(regT2);
 152     ret();
 153 }
 154
 155 void JIT::emit_op_construct_verify(Instruction* currentInstruction)
 156 {
 157     unsigned dst = currentInstruction[1].u.operand;
 158
 159     emitLoad(dst, regT1, regT0);
 160     addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::CellTag)));
 161     loadPtr(Address(regT0, OBJECT_OFFSETOF(JSCell, m_structure)), regT2);
 162     addSlowCase(branch8(NotEqual, Address(regT2, OBJECT_OFFSETOF(Structure, m_typeInfo) + OBJECT_OFFSETOF(TypeInfo, m_type)), Imm32(ObjectType)));
 163 }
 164
 165 void JIT::emitSlow_op_construct_verify(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 166 {
 167     unsigned dst = currentInstruction[1].u.operand;
 168     unsigned src = currentInstruction[2].u.operand;
 169
 170     linkSlowCase(iter);
 171     linkSlowCase(iter);
 172     emitLoad(src, regT1, regT0);
 173     emitStore(dst, regT1, regT0);
 174 }
 175
 176 void JIT::emitSlow_op_call(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 177 {
 178     compileOpCallSlowCase(currentInstruction, iter, m_callLinkInfoIndex++, op_call);
 179 }
 180
 181 void JIT::emitSlow_op_call_eval(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 182 {
 183     compileOpCallSlowCase(currentInstruction, iter, m_callLinkInfoIndex++, op_call_eval);
 184 }
 185
 186 void JIT::emitSlow_op_call_varargs(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 187 {
 188     compileOpCallVarargsSlowCase(currentInstruction, iter);
 189 }
 190
 191 void JIT::emitSlow_op_construct(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
 192 {
 193     compileOpCallSlowCase(currentInstruction, iter, m_callLinkInfoIndex++, op_construct);
 194 }
 195
 196 void JIT::emit_op_call(Instruction* currentInstruction)
 197 {
 198     compileOpCall(op_call, currentInstruction, m_callLinkInfoIndex++);
 199 }
 200
 201 void JIT::emit_op_call_eval(Instruction* currentInstruction)
 202 {
 203     compileOpCall(op_call_eval, currentInstruction, m_callLinkInfoIndex++);
 204 }
 205
 206 void JIT::emit_op_load_varargs(Instruction* currentInstruction)
 207 {
 208     int argCountDst = currentInstruction[1].u.operand;
 209     int argsOffset = currentInstruction[2].u.operand;
 210
 211     JITStubCall stubCall(this, cti_op_load_varargs);
 212     stubCall.addArgument(Imm32(argsOffset));
 213     stubCall.call();
 214     // Stores a naked int32 in the register file.
 215     store32(returnValueRegister, Address(callFrameRegister, argCountDst * sizeof(Register)));
 216 }
 217
 218 void JIT::emit_op_call_varargs(Instruction* currentInstruction)
 219 {
 220     compileOpCallVarargs(currentInstruction);
 221 }
 222
 223 void JIT::emit_op_construct(Instruction* currentInstruction)
 224 {
 225     compileOpCall(op_construct, currentInstruction, m_callLinkInfoIndex++);
 226 }
 227
 228 #if !ENABLE(JIT_OPTIMIZE_CALL)
 229
 230 /* ------------------------------ BEGIN: !ENABLE(JIT_OPTIMIZE_CALL) ------------------------------ */
 231
 232 void JIT::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned)
 233 {
 234     int dst = instruction[1].u.operand;
 235     int callee = instruction[2].u.operand;
 236     int argCount = instruction[3].u.operand;
 237     int registerOffset = instruction[4].u.operand;
 238
 239     Jump wasEval;
 240     if (opcodeID == op_call_eval) {
 241         JITStubCall stubCall(this, cti_op_call_eval);
 242         stubCall.addArgument(callee);
 243         stubCall.addArgument(JIT::Imm32(registerOffset));
 244         stubCall.addArgument(JIT::Imm32(argCount));
 245         stubCall.call();
 246         wasEval = branch32(NotEqual, regT1, Imm32(JSValue::EmptyValueTag));
 247     }
 248
 249     emitLoad(callee, regT1, regT0);
 250
 251     if (opcodeID == op_call)
 252         compileOpCallSetupArgs(instruction);
 253     else if (opcodeID == op_construct)
 254         compileOpConstructSetupArgs(instruction);
 255
 256     emitJumpSlowCaseIfNotJSCell(callee, regT1);
 257     addSlowCase(branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsFunctionVPtr)));
 258
 259     // First, in the case of a construct, allocate the new object.
 260     if (opcodeID == op_construct) {
 261         JITStubCall(this, cti_op_construct_JSConstruct).call(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
 262         emitLoad(callee, regT1, regT0);
 263     }
 264
 265     // Speculatively roll the callframe, assuming argCount will match the arity.
 266     storePtr(callFrameRegister, Address(callFrameRegister, (RegisterFile::CallerFrame + registerOffset) * static_cast<int>(sizeof(Register))));
 267     addPtr(Imm32(registerOffset * static_cast<int>(sizeof(Register))), callFrameRegister);
 268     move(Imm32(argCount), regT1);
 269
 270     emitNakedCall(m_globalData->jitStubs.ctiVirtualCall());
 271
 272     if (opcodeID == op_call_eval)
 273         wasEval.link(this);
 274
 275     emitStore(dst, regT1, regT0);
 276
 277     sampleCodeBlock(m_codeBlock);
 278 }
 279
 280 void JIT::compileOpCallSlowCase(Instruction* instruction, Vector<SlowCaseEntry>::iterator& iter, unsigned, OpcodeID opcodeID)
 281 {
 282     int dst = instruction[1].u.operand;
 283     int callee = instruction[2].u.operand;
 284
 285     linkSlowCaseIfNotJSCell(iter, callee);
 286     linkSlowCase(iter);
 287
 288     JITStubCall stubCall(this, opcodeID == op_construct ? cti_op_construct_NotJSConstruct : cti_op_call_NotJSFunction);
 289     stubCall.call(dst); // In the interpreter, the callee puts the return value in dst.
 290
 291     sampleCodeBlock(m_codeBlock);
 292 }
 293
 294 #else // !ENABLE(JIT_OPTIMIZE_CALL)
 295
 296 /* ------------------------------ BEGIN: ENABLE(JIT_OPTIMIZE_CALL) ------------------------------ */
 297
 298 void JIT::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned callLinkInfoIndex)
 299 {
 300     int dst = instruction[1].u.operand;
 301     int callee = instruction[2].u.operand;
 302     int argCount = instruction[3].u.operand;
 303     int registerOffset = instruction[4].u.operand;
 304
 305     Jump wasEval;
 306     if (opcodeID == op_call_eval) {
 307         JITStubCall stubCall(this, cti_op_call_eval);
 308         stubCall.addArgument(callee);
 309         stubCall.addArgument(JIT::Imm32(registerOffset));
 310         stubCall.addArgument(JIT::Imm32(argCount));
 311         stubCall.call();
 312         wasEval = branch32(NotEqual, regT1, Imm32(JSValue::EmptyValueTag));
 313     }
 314
 315     emitLoad(callee, regT1, regT0);
 316
 317     DataLabelPtr addressOfLinkedFunctionCheck;
 318
 319     BEGIN_UNINTERRUPTED_SEQUENCE(sequenceOpCall);
 320
 321     Jump jumpToSlow = branchPtrWithPatch(NotEqual, regT0, addressOfLinkedFunctionCheck, ImmPtr(0));
 322
 323     END_UNINTERRUPTED_SEQUENCE(sequenceOpCall);
 324
 325     addSlowCase(jumpToSlow);
 326     ASSERT(differenceBetween(addressOfLinkedFunctionCheck, jumpToSlow) == patchOffsetOpCallCompareToJump);
 327     m_callStructureStubCompilationInfo[callLinkInfoIndex].hotPathBegin = addressOfLinkedFunctionCheck;
 328
 329     addSlowCase(branch32(NotEqual, regT1, Imm32(JSValue::CellTag)));
 330
 331     // The following is the fast case, only used whan a callee can be linked.
 332
 333     // In the case of OpConstruct, call out to a cti_ function to create the new object.
 334     if (opcodeID == op_construct) {
 335         int proto = instruction[5].u.operand;
 336         int thisRegister = instruction[6].u.operand;
 337
 338         JITStubCall stubCall(this, cti_op_construct_JSConstruct);
 339         stubCall.addArgument(regT1, regT0);
 340         stubCall.addArgument(Imm32(0)); // FIXME: Remove this unused JITStub argument.
 341         stubCall.addArgument(Imm32(0)); // FIXME: Remove this unused JITStub argument.
 342         stubCall.addArgument(proto);
 343         stubCall.call(thisRegister);
 344
 345         emitLoad(callee, regT1, regT0);
 346     }
 347
 348     // Fast version of stack frame initialization, directly relative to edi.
 349     // Note that this omits to set up RegisterFile::CodeBlock, which is set in the callee
 350     emitStore(registerOffset + RegisterFile::OptionalCalleeArguments, JSValue());
 351     emitStore(registerOffset + RegisterFile::Callee, regT1, regT0);
 352
 353     loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_data) + OBJECT_OFFSETOF(ScopeChain, m_node)), regT1); // newScopeChain
 354     store32(Imm32(argCount), Address(callFrameRegister, (registerOffset + RegisterFile::ArgumentCount) * static_cast<int>(sizeof(Register))));
 355     storePtr(callFrameRegister, Address(callFrameRegister, (registerOffset + RegisterFile::CallerFrame) * static_cast<int>(sizeof(Register))));
 356     storePtr(regT1, Address(callFrameRegister, (registerOffset + RegisterFile::ScopeChain) * static_cast<int>(sizeof(Register))));
 357     addPtr(Imm32(registerOffset * sizeof(Register)), callFrameRegister);
 358
 359     // Call to the callee
 360     m_callStructureStubCompilationInfo[callLinkInfoIndex].hotPathOther = emitNakedCall();
 361
 362     if (opcodeID == op_call_eval)
 363         wasEval.link(this);
 364
 365     // Put the return value in dst. In the interpreter, op_ret does this.
 366     emitStore(dst, regT1, regT0);
 367     map(m_bytecodeIndex + opcodeLengths[opcodeID], dst, regT1, regT0);
 368
 369     sampleCodeBlock(m_codeBlock);
 370 }
 371
 372 void JIT::compileOpCallSlowCase(Instruction* instruction, Vector<SlowCaseEntry>::iterator& iter, unsigned callLinkInfoIndex, OpcodeID opcodeID)
 373 {
 374     int dst = instruction[1].u.operand;
 375     int callee = instruction[2].u.operand;
 376     int argCount = instruction[3].u.operand;
 377     int registerOffset = instruction[4].u.operand;
 378
 379     linkSlowCase(iter);
 380     linkSlowCase(iter);
 381
 382     // The arguments have been set up on the hot path for op_call_eval
 383     if (opcodeID == op_call)
 384         compileOpCallSetupArgs(instruction);
 385     else if (opcodeID == op_construct)
 386         compileOpConstructSetupArgs(instruction);
 387
 388     // Fast check for JS function.
 389     Jump callLinkFailNotObject = branch32(NotEqual, regT1, Imm32(JSValue::CellTag));
 390     Jump callLinkFailNotJSFunction = branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsFunctionVPtr));
 391
 392     // First, in the case of a construct, allocate the new object.
 393     if (opcodeID == op_construct) {
 394         JITStubCall(this, cti_op_construct_JSConstruct).call(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
 395         emitLoad(callee, regT1, regT0);
 396     }
 397
 398     // Speculatively roll the callframe, assuming argCount will match the arity.
 399     storePtr(callFrameRegister, Address(callFrameRegister, (RegisterFile::CallerFrame + registerOffset) * static_cast<int>(sizeof(Register))));
 400     addPtr(Imm32(registerOffset * static_cast<int>(sizeof(Register))), callFrameRegister);
 401     move(Imm32(argCount), regT1);
 402
 403     m_callStructureStubCompilationInfo[callLinkInfoIndex].callReturnLocation = emitNakedCall(m_globalData->jitStubs->ctiVirtualCallLink());
 404
 405     // Put the return value in dst.
 406     emitStore(dst, regT1, regT0);;
 407     sampleCodeBlock(m_codeBlock);
 408
 409     // If not, we need an extra case in the if below!
 410     ASSERT(OPCODE_LENGTH(op_call) == OPCODE_LENGTH(op_call_eval));
 411
 412     // Done! - return back to the hot path.
 413     if (opcodeID == op_construct)
 414         emitJumpSlowToHot(jump(), OPCODE_LENGTH(op_construct));
 415     else
 416         emitJumpSlowToHot(jump(), OPCODE_LENGTH(op_call));
 417
 418     // This handles host functions
 419     callLinkFailNotObject.link(this);
 420     callLinkFailNotJSFunction.link(this);
 421     JITStubCall(this, opcodeID == op_construct ? cti_op_construct_NotJSConstruct : cti_op_call_NotJSFunction).call();
 422
 423     emitStore(dst, regT1, regT0);;
 424     sampleCodeBlock(m_codeBlock);
 425 }
 426
 427 /* ------------------------------ END: !ENABLE / ENABLE(JIT_OPTIMIZE_CALL) ------------------------------ */
 428
 429 #endif // !ENABLE(JIT_OPTIMIZE_CALL)
 430
 431 #else // USE(JSVALUE32_64)
 432
 433 void JIT::compileOpCallInitializeCallFrame()
 434 {
 435     store32(regT1, Address(callFrameRegister, RegisterFile::ArgumentCount * static_cast<int>(sizeof(Register))));
 436
 437     loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_data) + OBJECT_OFFSETOF(ScopeChain, m_node)), regT1); // newScopeChain
 438
 439     storePtr(ImmPtr(JSValue::encode(JSValue())), Address(callFrameRegister, RegisterFile::OptionalCalleeArguments * static_cast<int>(sizeof(Register))));
 440     storePtr(regT0, Address(callFrameRegister, RegisterFile::Callee * static_cast<int>(sizeof(Register))));
 441     storePtr(regT1, Address(callFrameRegister, RegisterFile::ScopeChain * static_cast<int>(sizeof(Register))));
 442 }
 443
 444 void JIT::compileOpCallSetupArgs(Instruction* instruction)
 445 {
 446     int argCount = instruction[3].u.operand;
 447     int registerOffset = instruction[4].u.operand;
 448
 449     // ecx holds func
 450     emitPutJITStubArg(regT0, 0);
 451     emitPutJITStubArgConstant(argCount, 2);
 452     emitPutJITStubArgConstant(registerOffset, 1);
 453 }
 454
 455 void JIT::compileOpCallVarargsSetupArgs(Instruction* instruction)
 456 {
 457     int registerOffset = instruction[4].u.operand;
 458
 459     // ecx holds func
 460     emitPutJITStubArg(regT0, 0);
 461     emitPutJITStubArg(regT1, 2);
 462     addPtr(Imm32(registerOffset), regT1, regT2);
 463     emitPutJITStubArg(regT2, 1);
 464 }
 465
 466 void JIT::compileOpConstructSetupArgs(Instruction* instruction)
 467 {
 468     int argCount = instruction[3].u.operand;
 469     int registerOffset = instruction[4].u.operand;
 470     int proto = instruction[5].u.operand;
 471     int thisRegister = instruction[6].u.operand;
 472
 473     // ecx holds func
 474     emitPutJITStubArg(regT0, 0);
 475     emitPutJITStubArgConstant(registerOffset, 1);
 476     emitPutJITStubArgConstant(argCount, 2);
 477     emitPutJITStubArgFromVirtualRegister(proto, 3, regT2);
 478     emitPutJITStubArgConstant(thisRegister, 4);
 479 }
 480
 481 void JIT::compileOpCallVarargs(Instruction* instruction)
 482 {
 483     int dst = instruction[1].u.operand;
 484     int callee = instruction[2].u.operand;
 485     int argCountRegister = instruction[3].u.operand;
 486
 487     emitGetVirtualRegister(argCountRegister, regT1);
 488     emitGetVirtualRegister(callee, regT0);
 489     compileOpCallVarargsSetupArgs(instruction);
 490
 491     // Check for JSFunctions.
 492     emitJumpSlowCaseIfNotJSCell(regT0);
 493     addSlowCase(branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsFunctionVPtr)));
 494
 495     // Speculatively roll the callframe, assuming argCount will match the arity.
 496     mul32(Imm32(sizeof(Register)), regT2, regT2);
 497     intptr_t offset = (intptr_t)sizeof(Register) * (intptr_t)RegisterFile::CallerFrame;
 498     addPtr(Imm32((int32_t)offset), regT2, regT3);
 499     addPtr(callFrameRegister, regT3);
 500     storePtr(callFrameRegister, regT3);
 501     addPtr(regT2, callFrameRegister);
 502     emitNakedCall(m_globalData->jitStubs->ctiVirtualCall());
 503
 504     // Put the return value in dst. In the interpreter, op_ret does this.
 505     emitPutVirtualRegister(dst);
 506
 507     sampleCodeBlock(m_codeBlock);
 508 }
 509
 510 void JIT::compileOpCallVarargsSlowCase(Instruction* instruction, Vector<SlowCaseEntry>::iterator& iter)
 511 {
 512     int dst = instruction[1].u.operand;
 513
 514     linkSlowCase(iter);
 515     linkSlowCase(iter);
 516     JITStubCall stubCall(this, cti_op_call_NotJSFunction);
 517     stubCall.call(dst); // In the interpreter, the callee puts the return value in dst.
 518
 519     sampleCodeBlock(m_codeBlock);
 520 }
 521
 522 #if !ENABLE(JIT_OPTIMIZE_CALL)
 523
 524 /* ------------------------------ BEGIN: !ENABLE(JIT_OPTIMIZE_CALL) ------------------------------ */
 525
 526 void JIT::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned)
 527 {
 528     int dst = instruction[1].u.operand;
 529     int callee = instruction[2].u.operand;
 530     int argCount = instruction[3].u.operand;
 531     int registerOffset = instruction[4].u.operand;
 532
 533     // Handle eval
 534     Jump wasEval;
 535     if (opcodeID == op_call_eval) {
 536         JITStubCall stubCall(this, cti_op_call_eval);
 537         stubCall.addArgument(callee, regT0);
 538         stubCall.addArgument(JIT::Imm32(registerOffset));
 539         stubCall.addArgument(JIT::Imm32(argCount));
 540         stubCall.call();
 541         wasEval = branchPtr(NotEqual, regT0, ImmPtr(JSValue::encode(JSValue())));
 542     }
 543
 544     emitGetVirtualRegister(callee, regT0);
 545     // The arguments have been set up on the hot path for op_call_eval
 546     if (opcodeID == op_call)
 547         compileOpCallSetupArgs(instruction);
 548     else if (opcodeID == op_construct)
 549         compileOpConstructSetupArgs(instruction);
 550
 551     // Check for JSFunctions.
 552     emitJumpSlowCaseIfNotJSCell(regT0);
 553     addSlowCase(branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsFunctionVPtr)));
 554
 555     // First, in the case of a construct, allocate the new object.
 556     if (opcodeID == op_construct) {
 557         JITStubCall(this, cti_op_construct_JSConstruct).call(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
 558         emitGetVirtualRegister(callee, regT0);
 559     }
 560
 561     // Speculatively roll the callframe, assuming argCount will match the arity.
 562     storePtr(callFrameRegister, Address(callFrameRegister, (RegisterFile::CallerFrame + registerOffset) * static_cast<int>(sizeof(Register))));
 563     addPtr(Imm32(registerOffset * static_cast<int>(sizeof(Register))), callFrameRegister);
 564     move(Imm32(argCount), regT1);
 565
 566     emitNakedCall(m_globalData->jitStubs.ctiVirtualCall());
 567
 568     if (opcodeID == op_call_eval)
 569         wasEval.link(this);
 570
 571     // Put the return value in dst. In the interpreter, op_ret does this.
 572     emitPutVirtualRegister(dst);
 573
 574     sampleCodeBlock(m_codeBlock);
 575 }
 576
 577 void JIT::compileOpCallSlowCase(Instruction* instruction, Vector<SlowCaseEntry>::iterator& iter, unsigned, OpcodeID opcodeID)
 578 {
 579     int dst = instruction[1].u.operand;
 580
 581     linkSlowCase(iter);
 582     linkSlowCase(iter);
 583     JITStubCall stubCall(this, opcodeID == op_construct ? cti_op_construct_NotJSConstruct : cti_op_call_NotJSFunction);
 584     stubCall.call(dst); // In the interpreter, the callee puts the return value in dst.
 585
 586     sampleCodeBlock(m_codeBlock);
 587 }
 588
 589 #else // !ENABLE(JIT_OPTIMIZE_CALL)
 590
 591 /* ------------------------------ BEGIN: ENABLE(JIT_OPTIMIZE_CALL) ------------------------------ */
 592
 593 void JIT::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned callLinkInfoIndex)
 594 {
 595     int dst = instruction[1].u.operand;
 596     int callee = instruction[2].u.operand;
 597     int argCount = instruction[3].u.operand;
 598     int registerOffset = instruction[4].u.operand;
 599
 600     // Handle eval
 601     Jump wasEval;
 602     if (opcodeID == op_call_eval) {
 603         JITStubCall stubCall(this, cti_op_call_eval);
 604         stubCall.addArgument(callee, regT0);
 605         stubCall.addArgument(JIT::Imm32(registerOffset));
 606         stubCall.addArgument(JIT::Imm32(argCount));
 607         stubCall.call();
 608         wasEval = branchPtr(NotEqual, regT0, ImmPtr(JSValue::encode(JSValue())));
 609     }
 610
 611     // This plants a check for a cached JSFunction value, so we can plant a fast link to the callee.
 612     // This deliberately leaves the callee in ecx, used when setting up the stack frame below
 613     emitGetVirtualRegister(callee, regT0);
 614     DataLabelPtr addressOfLinkedFunctionCheck;
 615
 616     BEGIN_UNINTERRUPTED_SEQUENCE(sequenceOpCall);
 617
 618     Jump jumpToSlow = branchPtrWithPatch(NotEqual, regT0, addressOfLinkedFunctionCheck, ImmPtr(JSValue::encode(JSValue())));
 619
 620     END_UNINTERRUPTED_SEQUENCE(sequenceOpCall);
 621
 622     addSlowCase(jumpToSlow);
 623     ASSERT_JIT_OFFSET(differenceBetween(addressOfLinkedFunctionCheck, jumpToSlow), patchOffsetOpCallCompareToJump);
 624     m_callStructureStubCompilationInfo[callLinkInfoIndex].hotPathBegin = addressOfLinkedFunctionCheck;
 625
 626     // The following is the fast case, only used whan a callee can be linked.
 627
 628     // In the case of OpConstruct, call out to a cti_ function to create the new object.
 629     if (opcodeID == op_construct) {
 630         int proto = instruction[5].u.operand;
 631         int thisRegister = instruction[6].u.operand;
 632
 633         emitPutJITStubArg(regT0, 0);
 634         emitPutJITStubArgFromVirtualRegister(proto, 3, regT2);
 635         JITStubCall stubCall(this, cti_op_construct_JSConstruct);
 636         stubCall.call(thisRegister);
 637         emitGetVirtualRegister(callee, regT0);
 638     }
 639
 640     // Fast version of stack frame initialization, directly relative to edi.
 641     // Note that this omits to set up RegisterFile::CodeBlock, which is set in the callee
 642     storePtr(ImmPtr(JSValue::encode(JSValue())), Address(callFrameRegister, (registerOffset + RegisterFile::OptionalCalleeArguments) * static_cast<int>(sizeof(Register))));
 643     storePtr(regT0, Address(callFrameRegister, (registerOffset + RegisterFile::Callee) * static_cast<int>(sizeof(Register))));
 644     loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_data) + OBJECT_OFFSETOF(ScopeChain, m_node)), regT1); // newScopeChain
 645     store32(Imm32(argCount), Address(callFrameRegister, (registerOffset + RegisterFile::ArgumentCount) * static_cast<int>(sizeof(Register))));
 646     storePtr(callFrameRegister, Address(callFrameRegister, (registerOffset + RegisterFile::CallerFrame) * static_cast<int>(sizeof(Register))));
 647     storePtr(regT1, Address(callFrameRegister, (registerOffset + RegisterFile::ScopeChain) * static_cast<int>(sizeof(Register))));
 648     addPtr(Imm32(registerOffset * sizeof(Register)), callFrameRegister);
 649
 650     // Call to the callee
 651     m_callStructureStubCompilationInfo[callLinkInfoIndex].hotPathOther = emitNakedCall();
 652
 653     if (opcodeID == op_call_eval)
 654         wasEval.link(this);
 655
 656     // Put the return value in dst. In the interpreter, op_ret does this.
 657     emitPutVirtualRegister(dst);
 658
 659     sampleCodeBlock(m_codeBlock);
 660 }
 661
 662 void JIT::compileOpCallSlowCase(Instruction* instruction, Vector<SlowCaseEntry>::iterator& iter, unsigned callLinkInfoIndex, OpcodeID opcodeID)
 663 {
 664     int dst = instruction[1].u.operand;
 665     int callee = instruction[2].u.operand;
 666     int argCount = instruction[3].u.operand;
 667     int registerOffset = instruction[4].u.operand;
 668
 669     linkSlowCase(iter);
 670
 671     // The arguments have been set up on the hot path for op_call_eval
 672     if (opcodeID == op_call)
 673         compileOpCallSetupArgs(instruction);
 674     else if (opcodeID == op_construct)
 675         compileOpConstructSetupArgs(instruction);
 676
 677     // Fast check for JS function.
 678     Jump callLinkFailNotObject = emitJumpIfNotJSCell(regT0);
 679     Jump callLinkFailNotJSFunction = branchPtr(NotEqual, Address(regT0), ImmPtr(m_globalData->jsFunctionVPtr));
 680
 681     // First, in the case of a construct, allocate the new object.
 682     if (opcodeID == op_construct) {
 683         JITStubCall(this, cti_op_construct_JSConstruct).call(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
 684         emitGetVirtualRegister(callee, regT0);
 685     }
 686
 687     // Speculatively roll the callframe, assuming argCount will match the arity.
 688     storePtr(callFrameRegister, Address(callFrameRegister, (RegisterFile::CallerFrame + registerOffset) * static_cast<int>(sizeof(Register))));
 689     addPtr(Imm32(registerOffset * static_cast<int>(sizeof(Register))), callFrameRegister);
 690     move(Imm32(argCount), regT1);
 691
 692     move(regT0, regT2);
 693
 694     m_callStructureStubCompilationInfo[callLinkInfoIndex].callReturnLocation = emitNakedCall(m_globalData->jitStubs->ctiVirtualCallLink());
 695
 696     // Put the return value in dst.
 697     emitPutVirtualRegister(dst);
 698     sampleCodeBlock(m_codeBlock);
 699
 700     // If not, we need an extra case in the if below!
 701     ASSERT(OPCODE_LENGTH(op_call) == OPCODE_LENGTH(op_call_eval));
 702
 703     // Done! - return back to the hot path.
 704     if (opcodeID == op_construct)
 705         emitJumpSlowToHot(jump(), OPCODE_LENGTH(op_construct));
 706     else
 707         emitJumpSlowToHot(jump(), OPCODE_LENGTH(op_call));
 708
 709     // This handles host functions
 710     callLinkFailNotObject.link(this);
 711     callLinkFailNotJSFunction.link(this);
 712     JITStubCall(this, opcodeID == op_construct ? cti_op_construct_NotJSConstruct : cti_op_call_NotJSFunction).call();
 713
 714     emitPutVirtualRegister(dst);
 715     sampleCodeBlock(m_codeBlock);
 716 }
 717
 718 /* ------------------------------ END: !ENABLE / ENABLE(JIT_OPTIMIZE_CALL) ------------------------------ */
 719
 720 #endif // !ENABLE(JIT_OPTIMIZE_CALL)
 721
 722 #endif // USE(JSVALUE32_64)
 723
 724 } // namespace JSC
 725
 726 #endif // ENABLE(JIT)