1/*
2 * Copyright (C) 2008, 2013, 2014 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
28#if ENABLE(JIT)
29#if USE(JSVALUE64)
30#include "JIT.h"
31
32#include "Arguments.h"
33#include "CodeBlock.h"
34#include "JITInlines.h"
35#include "JSArray.h"
36#include "JSFunction.h"
37#include "Interpreter.h"
38#include "JSCInlines.h"
39#include "LinkBuffer.h"
40#include "RepatchBuffer.h"
41#include "ResultType.h"
42#include "SamplingTool.h"
43#include "StackAlignment.h"
44#include "ThunkGenerators.h"
45#include <wtf/StringPrintStream.h>
46
47
48namespace JSC {
49
50void JIT::emitPutCallResult(Instruction* instruction)
51{
52    int dst = instruction[1].u.operand;
53    emitValueProfilingSite();
54    emitPutVirtualRegister(dst);
55}
56
57void JIT::compileLoadVarargs(Instruction* instruction)
58{
59    int thisValue = instruction[3].u.operand;
60    int arguments = instruction[4].u.operand;
61    int firstFreeRegister = instruction[5].u.operand;
62    int firstVarArgOffset = instruction[6].u.operand;
63
64    JumpList slowCase;
65    JumpList end;
66    bool canOptimize = m_codeBlock->usesArguments()
67        && arguments == m_codeBlock->argumentsRegister().offset()
68        && !m_codeBlock->symbolTable()->slowArguments();
69
70    if (canOptimize) {
71        emitGetVirtualRegister(arguments, regT0);
72        slowCase.append(branch64(NotEqual, regT0, TrustedImm64(JSValue::encode(JSValue()))));
73
74        emitGetFromCallFrameHeader32(JSStack::ArgumentCount, regT0);
75        if (firstVarArgOffset) {
76            Jump sufficientArguments = branch32(GreaterThan, regT0, TrustedImm32(firstVarArgOffset + 1));
77            move(TrustedImm32(1), regT0);
78            Jump endVarArgs = jump();
79            sufficientArguments.link(this);
80            sub32(TrustedImm32(firstVarArgOffset), regT0);
81            endVarArgs.link(this);
82        }
83        slowCase.append(branch32(Above, regT0, TrustedImm32(Arguments::MaxArguments + 1)));
84        // regT0: argumentCountIncludingThis
85        move(regT0, regT1);
86        add64(TrustedImm32(-firstFreeRegister + JSStack::CallFrameHeaderSize), regT1);
87        // regT1 now has the required frame size in Register units
88        // Round regT1 to next multiple of stackAlignmentRegisters()
89        add64(TrustedImm32(stackAlignmentRegisters() - 1), regT1);
90        and64(TrustedImm32(~(stackAlignmentRegisters() - 1)), regT1);
91
92        neg64(regT1);
93        lshift64(TrustedImm32(3), regT1);
94        addPtr(callFrameRegister, regT1);
95        // regT1: newCallFrame
96
97        slowCase.append(branchPtr(Above, AbsoluteAddress(m_vm->addressOfStackLimit()), regT1));
98
99        // Initialize ArgumentCount.
100        store32(regT0, Address(regT1, JSStack::ArgumentCount * static_cast<int>(sizeof(Register)) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload)));
101
102        // Initialize 'this'.
103        emitGetVirtualRegister(thisValue, regT2);
104        store64(regT2, Address(regT1, CallFrame::thisArgumentOffset() * static_cast<int>(sizeof(Register))));
105
106        // Copy arguments.
107        signExtend32ToPtr(regT0, regT0);
108        end.append(branchSub64(Zero, TrustedImm32(1), regT0));
109        // regT0: argumentCount
110
111        Label copyLoop = label();
112        load64(BaseIndex(callFrameRegister, regT0, TimesEight, (CallFrame::thisArgumentOffset() + firstVarArgOffset) * static_cast<int>(sizeof(Register))), regT2);
113        store64(regT2, BaseIndex(regT1, regT0, TimesEight, CallFrame::thisArgumentOffset() * static_cast<int>(sizeof(Register))));
114        branchSub64(NonZero, TrustedImm32(1), regT0).linkTo(copyLoop, this);
115
116        end.append(jump());
117    }
118
119    if (canOptimize)
120        slowCase.link(this);
121
122    emitGetVirtualRegister(arguments, regT1);
123    callOperation(operationSizeFrameForVarargs, regT1, firstFreeRegister, firstVarArgOffset);
124    move(returnValueGPR, stackPointerRegister);
125    emitGetVirtualRegister(thisValue, regT1);
126    emitGetVirtualRegister(arguments, regT2);
127    callOperation(operationLoadVarargs, returnValueGPR, regT1, regT2, firstVarArgOffset);
128    move(returnValueGPR, regT1);
129
130    if (canOptimize)
131        end.link(this);
132
133    addPtr(TrustedImm32(sizeof(CallerFrameAndPC)), regT1, stackPointerRegister);
134}
135
136void JIT::compileCallEval(Instruction* instruction)
137{
138    addPtr(TrustedImm32(-static_cast<ptrdiff_t>(sizeof(CallerFrameAndPC))), stackPointerRegister, regT1);
139    callOperationNoExceptionCheck(operationCallEval, regT1);
140
141    Jump noException = emitExceptionCheck(InvertedExceptionCheck);
142    addPtr(TrustedImm32(stackPointerOffsetFor(m_codeBlock) * sizeof(Register)), callFrameRegister, stackPointerRegister);
143    exceptionCheck(jump());
144
145    noException.link(this);
146    addSlowCase(branch64(Equal, regT0, TrustedImm64(JSValue::encode(JSValue()))));
147
148    addPtr(TrustedImm32(stackPointerOffsetFor(m_codeBlock) * sizeof(Register)), callFrameRegister, stackPointerRegister);
149    checkStackPointerAlignment();
150
151    sampleCodeBlock(m_codeBlock);
152
153    emitPutCallResult(instruction);
154}
155
156void JIT::compileCallEvalSlowCase(Instruction* instruction, Vector<SlowCaseEntry>::iterator& iter)
157{
158    linkSlowCase(iter);
159
160    load64(Address(stackPointerRegister, sizeof(Register) * JSStack::Callee - sizeof(CallerFrameAndPC)), regT0);
161    move(TrustedImmPtr(&CallLinkInfo::dummy()), regT2);
162    emitNakedCall(m_vm->getCTIStub(virtualCallThunkGenerator).code());
163    addPtr(TrustedImm32(stackPointerOffsetFor(m_codeBlock) * sizeof(Register)), callFrameRegister, stackPointerRegister);
164    checkStackPointerAlignment();
165
166    sampleCodeBlock(m_codeBlock);
167
168    emitPutCallResult(instruction);
169}
170
171void JIT::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned callLinkInfoIndex)
172{
173    int callee = instruction[2].u.operand;
174
175    /* Caller always:
176        - Updates callFrameRegister to callee callFrame.
177        - Initializes ArgumentCount; CallerFrame; Callee.
178
179       For a JS call:
180        - Caller initializes ScopeChain.
181        - Callee initializes ReturnPC; CodeBlock.
182        - Callee restores callFrameRegister before return.
183
184       For a non-JS call:
185        - Caller initializes ScopeChain; ReturnPC; CodeBlock.
186        - Caller restores callFrameRegister after return.
187    */
188    COMPILE_ASSERT(OPCODE_LENGTH(op_call) == OPCODE_LENGTH(op_construct), call_and_construct_opcodes_must_be_same_length);
189    COMPILE_ASSERT(OPCODE_LENGTH(op_call) == OPCODE_LENGTH(op_call_varargs), call_and_call_varargs_opcodes_must_be_same_length);
190    COMPILE_ASSERT(OPCODE_LENGTH(op_call) == OPCODE_LENGTH(op_construct_varargs), call_and_construct_varargs_opcodes_must_be_same_length);
191    if (opcodeID == op_call_varargs || opcodeID == op_construct_varargs)
192        compileLoadVarargs(instruction);
193    else {
194        int argCount = instruction[3].u.operand;
195        int registerOffset = -instruction[4].u.operand;
196
197        if (opcodeID == op_call && shouldEmitProfiling()) {
198            emitGetVirtualRegister(registerOffset + CallFrame::argumentOffsetIncludingThis(0), regT0);
199            Jump done = emitJumpIfNotJSCell(regT0);
200            load32(Address(regT0, JSCell::structureIDOffset()), regT0);
201            store32(regT0, instruction[OPCODE_LENGTH(op_call) - 2].u.arrayProfile->addressOfLastSeenStructureID());
202            done.link(this);
203        }
204
205        addPtr(TrustedImm32(registerOffset * sizeof(Register) + sizeof(CallerFrameAndPC)), callFrameRegister, stackPointerRegister);
206        store32(TrustedImm32(argCount), Address(stackPointerRegister, JSStack::ArgumentCount * static_cast<int>(sizeof(Register)) + PayloadOffset - sizeof(CallerFrameAndPC)));
207    } // SP holds newCallFrame + sizeof(CallerFrameAndPC), with ArgumentCount initialized.
208
209    uint32_t bytecodeOffset = instruction - m_codeBlock->instructions().begin();
210    uint32_t locationBits = CallFrame::Location::encodeAsBytecodeOffset(bytecodeOffset);
211    store32(TrustedImm32(locationBits), Address(callFrameRegister, JSStack::ArgumentCount * static_cast<int>(sizeof(Register)) + TagOffset));
212    emitGetVirtualRegister(callee, regT0); // regT0 holds callee.
213
214    store64(regT0, Address(stackPointerRegister, JSStack::Callee * static_cast<int>(sizeof(Register)) - sizeof(CallerFrameAndPC)));
215
216    if (opcodeID == op_call_eval) {
217        compileCallEval(instruction);
218        return;
219    }
220
221    DataLabelPtr addressOfLinkedFunctionCheck;
222    Jump slowCase = branchPtrWithPatch(NotEqual, regT0, addressOfLinkedFunctionCheck, TrustedImmPtr(0));
223    addSlowCase(slowCase);
224
225    ASSERT(m_callCompilationInfo.size() == callLinkInfoIndex);
226    CallLinkInfo* info = m_codeBlock->addCallLinkInfo();
227    info->callType = CallLinkInfo::callTypeFor(opcodeID);
228    info->codeOrigin = CodeOrigin(m_bytecodeOffset);
229    info->calleeGPR = regT0;
230    m_callCompilationInfo.append(CallCompilationInfo());
231    m_callCompilationInfo[callLinkInfoIndex].hotPathBegin = addressOfLinkedFunctionCheck;
232    m_callCompilationInfo[callLinkInfoIndex].callLinkInfo = info;
233
234    loadPtr(Address(regT0, OBJECT_OFFSETOF(JSFunction, m_scope)), regT2);
235    store64(regT2, Address(MacroAssembler::stackPointerRegister, JSStack::ScopeChain * sizeof(Register) - sizeof(CallerFrameAndPC)));
236
237    m_callCompilationInfo[callLinkInfoIndex].hotPathOther = emitNakedCall();
238
239    addPtr(TrustedImm32(stackPointerOffsetFor(m_codeBlock) * sizeof(Register)), callFrameRegister, stackPointerRegister);
240    checkStackPointerAlignment();
241
242    sampleCodeBlock(m_codeBlock);
243
244    emitPutCallResult(instruction);
245}
246
247void JIT::compileOpCallSlowCase(OpcodeID opcodeID, Instruction* instruction, Vector<SlowCaseEntry>::iterator& iter, unsigned callLinkInfoIndex)
248{
249    if (opcodeID == op_call_eval) {
250        compileCallEvalSlowCase(instruction, iter);
251        return;
252    }
253
254    linkSlowCase(iter);
255
256    ThunkGenerator generator = linkThunkGeneratorFor(
257        (opcodeID == op_construct || opcodeID == op_construct_varargs) ? CodeForConstruct : CodeForCall,
258        RegisterPreservationNotRequired);
259
260    move(TrustedImmPtr(m_callCompilationInfo[callLinkInfoIndex].callLinkInfo), regT2);
261    m_callCompilationInfo[callLinkInfoIndex].callReturnLocation = emitNakedCall(m_vm->getCTIStub(generator).code());
262
263    addPtr(TrustedImm32(stackPointerOffsetFor(m_codeBlock) * sizeof(Register)), callFrameRegister, stackPointerRegister);
264    checkStackPointerAlignment();
265
266    sampleCodeBlock(m_codeBlock);
267
268    emitPutCallResult(instruction);
269}
270
271void JIT::privateCompileClosureCall(CallLinkInfo* callLinkInfo, CodeBlock* calleeCodeBlock, Structure* expectedStructure, ExecutableBase* expectedExecutable, MacroAssemblerCodePtr codePtr)
272{
273    JumpList slowCases;
274
275    slowCases.append(branchTestPtr(NonZero, regT0, tagMaskRegister));
276    slowCases.append(branchStructure(NotEqual, Address(regT0, JSCell::structureIDOffset()), expectedStructure));
277    slowCases.append(branchPtr(NotEqual, Address(regT0, JSFunction::offsetOfExecutable()), TrustedImmPtr(expectedExecutable)));
278
279    loadPtr(Address(regT0, JSFunction::offsetOfScopeChain()), regT1);
280    emitPutToCallFrameHeader(regT1, JSStack::ScopeChain);
281
282    Call call = nearCall();
283    Jump done = jump();
284
285    slowCases.link(this);
286    move(TrustedImmPtr(callLinkInfo->callReturnLocation.executableAddress()), regT2);
287    restoreReturnAddressBeforeReturn(regT2);
288    Jump slow = jump();
289
290    LinkBuffer patchBuffer(*m_vm, *this, m_codeBlock);
291
292    patchBuffer.link(call, FunctionPtr(codePtr.executableAddress()));
293    patchBuffer.link(done, callLinkInfo->hotPathOther.labelAtOffset(0));
294    patchBuffer.link(slow, CodeLocationLabel(m_vm->getCTIStub(virtualCallThunkGenerator).code()));
295
296    RefPtr<ClosureCallStubRoutine> stubRoutine = adoptRef(new ClosureCallStubRoutine(
297        FINALIZE_CODE(
298            patchBuffer,
299            ("Baseline closure call stub for %s, return point %p, target %p (%s)",
300                toCString(*m_codeBlock).data(),
301                callLinkInfo->hotPathOther.labelAtOffset(0).executableAddress(),
302                codePtr.executableAddress(),
303                toCString(pointerDump(calleeCodeBlock)).data())),
304        *m_vm, m_codeBlock->ownerExecutable(), expectedStructure, expectedExecutable,
305        callLinkInfo->codeOrigin));
306
307    RepatchBuffer repatchBuffer(m_codeBlock);
308
309    repatchBuffer.replaceWithJump(
310        RepatchBuffer::startOfBranchPtrWithPatchOnRegister(callLinkInfo->hotPathBegin),
311        CodeLocationLabel(stubRoutine->code().code()));
312    repatchBuffer.relink(callLinkInfo->callReturnLocation, m_vm->getCTIStub(virtualCallThunkGenerator).code());
313
314    callLinkInfo->stub = stubRoutine.release();
315}
316
317void JIT::emit_op_call(Instruction* currentInstruction)
318{
319    compileOpCall(op_call, currentInstruction, m_callLinkInfoIndex++);
320}
321
322void JIT::emit_op_call_eval(Instruction* currentInstruction)
323{
324    compileOpCall(op_call_eval, currentInstruction, m_callLinkInfoIndex);
325}
326
327void JIT::emit_op_call_varargs(Instruction* currentInstruction)
328{
329    compileOpCall(op_call_varargs, currentInstruction, m_callLinkInfoIndex++);
330}
331
332void JIT::emit_op_construct_varargs(Instruction* currentInstruction)
333{
334    compileOpCall(op_construct_varargs, currentInstruction, m_callLinkInfoIndex++);
335}
336
337void JIT::emit_op_construct(Instruction* currentInstruction)
338{
339    compileOpCall(op_construct, currentInstruction, m_callLinkInfoIndex++);
340}
341
342void JIT::emitSlow_op_call(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
343{
344    compileOpCallSlowCase(op_call, currentInstruction, iter, m_callLinkInfoIndex++);
345}
346
347void JIT::emitSlow_op_call_eval(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
348{
349    compileOpCallSlowCase(op_call_eval, currentInstruction, iter, m_callLinkInfoIndex);
350}
351
352void JIT::emitSlow_op_call_varargs(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
353{
354    compileOpCallSlowCase(op_call_varargs, currentInstruction, iter, m_callLinkInfoIndex++);
355}
356
357void JIT::emitSlow_op_construct_varargs(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
358{
359    compileOpCallSlowCase(op_construct_varargs, currentInstruction, iter, m_callLinkInfoIndex++);
360}
361
362void JIT::emitSlow_op_construct(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
363{
364    compileOpCallSlowCase(op_construct, currentInstruction, iter, m_callLinkInfoIndex++);
365}
366
367} // namespace JSC
368
369#endif // USE(JSVALUE64)
370#endif // ENABLE(JIT)
371