Changeset 159276 in webkit


Ignore:
Timestamp:
Nov 13, 2013 11:39:30 PM (10 years ago)
Author:
msaboff@apple.com
Message:

Change callToJavaScript thunk into an offline assembled stub
​https://bugs.webkit.org/show_bug.cgi?id=124251

Reviewed by Geoffrey Garen.

Changed callToJavaScript and throwNotCaught into stubs generated by the offline assembler.
Added popCalleeSaves and pushCalleeSaves pseudo ops to the offline assembler to handle
the saving and restoring of callee save registers. Fixed callFrameRegister differences
between arm traditional (r11) and arm Thumb2 (r7) in GPRInfo.h. Also fixed implementation
of pop & push in arm.rb.

Since the offline assembler and therefore the LLInt don't work on Windows, the Windows stubs
are handled as inline assembly in JITStubsX86.h and JITStubsMSVC64.asm.

  • dfg/DFGDriver.cpp:

(JSC::DFG::compileImpl):

  • jit/GPRInfo.h:

(JSC::GPRInfo::toIndex):
(JSC::GPRInfo::debugName):

  • jit/JITCode.cpp:

(JSC::JITCode::execute):

  • jit/JITExceptions.cpp:

(JSC::genericUnwind):

  • jit/JITStubs.h:
  • jit/JITStubsMSVC64.asm:
  • jit/JITStubsX86.h:
  • jit/ThunkGenerators.cpp:
  • jit/ThunkGenerators.h:
  • llint/LLIntThunks.h:
  • llint/LowLevelInterpreter.asm:
  • llint/LowLevelInterpreter32_64.asm:
  • llint/LowLevelInterpreter64.asm:
  • offlineasm/arm.rb:
  • offlineasm/arm64.rb:
  • offlineasm/instructions.rb:
  • offlineasm/mips.rb:
  • offlineasm/registers.rb:
  • offlineasm/sh4.rb:
  • offlineasm/x86.rb:
  • runtime/VM.cpp:

(JSC::VM::VM):

  • runtime/VM.h:
Location:
trunk/Source/JavaScriptCore
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r159261 r159276  
     12013-11-13  Michael Saboff  <msaboff@apple.com>
     2
     3        Change callToJavaScript thunk into an offline assembled stub
     4        https://bugs.webkit.org/show_bug.cgi?id=124251
     5
     6        Reviewed by Geoffrey Garen.
     7
     8        Changed callToJavaScript and throwNotCaught into stubs generated by the offline assembler.
     9        Added popCalleeSaves and pushCalleeSaves pseudo ops to the offline assembler to handle
     10        the saving and restoring of callee save registers.  Fixed callFrameRegister differences
     11        between arm traditional (r11) and arm Thumb2 (r7) in GPRInfo.h.  Also fixed implementation
     12        of pop & push in arm.rb.
     13
     14        Since the offline assembler and therefore the LLInt don't work on Windows, the Windows stubs
     15        are handled as inline assembly in JITStubsX86.h and JITStubsMSVC64.asm.
     16
     17        * dfg/DFGDriver.cpp:
     18        (JSC::DFG::compileImpl):
     19        * jit/GPRInfo.h:
     20        (JSC::GPRInfo::toIndex):
     21        (JSC::GPRInfo::debugName):
     22        * jit/JITCode.cpp:
     23        (JSC::JITCode::execute):
     24        * jit/JITExceptions.cpp:
     25        (JSC::genericUnwind):
     26        * jit/JITStubs.h:
     27        * jit/JITStubsMSVC64.asm:
     28        * jit/JITStubsX86.h:
     29        * jit/ThunkGenerators.cpp:
     30        * jit/ThunkGenerators.h:
     31        * llint/LLIntThunks.h:
     32        * llint/LowLevelInterpreter.asm:
     33        * llint/LowLevelInterpreter32_64.asm:
     34        * llint/LowLevelInterpreter64.asm:
     35        * offlineasm/arm.rb:
     36        * offlineasm/arm64.rb:
     37        * offlineasm/instructions.rb:
     38        * offlineasm/mips.rb:
     39        * offlineasm/registers.rb:
     40        * offlineasm/sh4.rb:
     41        * offlineasm/x86.rb:
     42        * runtime/VM.cpp:
     43        (JSC::VM::VM):
     44        * runtime/VM.h:
     45
    1462013-11-13  Andy Estes  <aestes@apple.com>
    247

  • trunk/Source/JavaScriptCore/dfg/DFGDriver.cpp

    r158751 r159276  
    7979    // Make sure that any stubs that the DFG is going to use are initialized. We want to
    8080    // make sure that all JIT code generation does finalization on the main thread.
    81     vm.getCTIStub(callToJavaScript);
    82     vm.getCTIStub(throwNotCaught);
    8381    vm.getCTIStub(osrExitGenerationThunkGenerator);
    8482    vm.getCTIStub(throwExceptionFromCallSlowPathGenerator);

  • trunk/Source/JavaScriptCore/jit/GPRInfo.h

    r159099 r159276  
    461461    static const GPRReg regT5 = ARMRegisters::r9;
    462462    static const GPRReg regT6 = ARMRegisters::r10;
    463     static const GPRReg regT7 = ARMRegisters::r5;
     463#if CPU(ARM_THUMB2)
     464    static const GPRReg regT7 = ARMRegisters::r11;
     465#else
     466    static const GPRReg regT7 = ARMRegisters::r7;
     467#endif
    464468    static const GPRReg regT8 = ARMRegisters::r3;
    465469    // These registers match the baseline JIT.
    … …  
    489493    {
    490494        ASSERT(reg != InvalidGPRReg);
    491         ASSERT(reg < 16);
    492         static const unsigned indexForRegister[16] = { 0, 1, 2, 8, 3, 7, InvalidIndex, InvalidIndex, 4, 5, 6, InvalidIndex, InvalidIndex, InvalidIndex, InvalidIndex, InvalidIndex };
     495        ASSERT(static_cast<int>(reg) < 16);
     496        static const unsigned indexForRegister[16] =
     497#if CPU(ARM_THUMB2)
     498            { 0, 1, 2, 8, 3, 9, InvalidIndex, InvalidIndex, 4, 5, 6, 7, InvalidIndex, InvalidIndex, InvalidIndex, InvalidIndex };
     499#else
     500            { 0, 1, 2, 8, 3, 9, InvalidIndex, 7, 4, 5, 6, InvalidIndex, InvalidIndex, InvalidIndex, InvalidIndex, InvalidIndex };
     501#endif
    493502        unsigned result = indexForRegister[reg];
    494503        ASSERT(result != InvalidIndex);
    … …  
    499508    {
    500509        ASSERT(reg != InvalidGPRReg);
    501         ASSERT(reg < 16);
     510        ASSERT(static_cast<int>(reg) < 16);
    502511        static const char* nameForRegister[16] = {
    503512            "r0", "r1", "r2", "r3",

  • trunk/Source/JavaScriptCore/jit/JITCode.cpp

    r158751 r159276  
    2727#include "JITCode.h"
    2828
     29#include "LLIntThunks.h"
    2930#include "Operations.h"
    30 #include "ThunkGenerators.h"
    3131#include <wtf/PrintStream.h>
    3232
    … …  
    4747    UNUSED_PARAM(stack);
    4848
    49     JSValue result = JSValue::decode(vm->callJavaScriptJITFunction(executableAddress(), callFrame));
     49    JSValue result = JSValue::decode(callToJavaScript(executableAddress(), callFrame));
    5050    return vm->exception() ? jsNull() : result;
    5151}

  • trunk/Source/JavaScriptCore/jit/JITExceptions.cpp

    r158751 r159276  
    3131#include "CodeBlock.h"
    3232#include "Interpreter.h"
     33#include "JITStubs.h"
    3334#include "JSCJSValue.h"
     35#include "LLIntThunks.h"
    3436#include "VM.h"
    3537#include "Operations.h"
    … …  
    5052        catchRoutine = ExecutableBase::catchRoutineFor(handler, catchPCForInterpreter);
    5153    } else
    52         catchRoutine = vm->getCTIStub(throwNotCaught).code().executableAddress();
     54        catchRoutine = FunctionPtr(LLInt::getCodePtr(returnFromJavaScript)).value();
    5355   
    5456    vm->callFrameForThrow = callFrame;

  • trunk/Source/JavaScriptCore/jit/JITStubs.h

    r158751 r159276  
    3131#define JITStubs_h
    3232
     33#include "JSCJSValue.h"
     34
    3335namespace JSC {
    3436
    3537#if ENABLE(JIT)
     38
     39#if OS(WINDOWS)
     40class ExecState;
     41
     42extern "C" {
     43    EncodedJSValue callToJavaScript(void*, ExecState*);
     44    void returnFromJavaScript();
     45}
     46#endif
    3647
    3748#if USE(MASM_PROBE)

  • trunk/Source/JavaScriptCore/jit/JITStubsMSVC64.asm

    r158751 r159276  
    2626EXTERN getHostCallReturnValueWithExecState : near
    2727
     28PUBLIC callToJavaScript
     29PUBLIC returnFromJavaScript
    2830PUBLIC getHostCallReturnValue
    2931
    3032_TEXT   SEGMENT
    3133
     34callToJavaScript PROC
     35    push rbp
     36    mov rbp, rax ; Save previous frame pointer
     37    mov rbp, rsp
     38    push r12
     39    push r13
     40    push r14
     41    push r15
     42    push rbx
     43
     44    ; JIT operations can use up to 6 args (4 in registers and 2 on the stack).
     45    ; In addition, X86_64 ABI specifies that the worse case stack alignment
     46    ; requirement is 32 bytes. Based on these factors, we need to pad the stack
     47    ; an additional 28h bytes.
     48    sub rsp, 28h
     49    mov rbp, rdx
     50    mov r11, qword ptr[rbp] ; Put the previous frame pointer in the sentinel call frame above us
     51    mov qword ptr[r11], rax
     52    mov r14, 0FFFF000000000000h
     53    mov r15, 0FFFF000000000002h
     54    call rcx
     55    add rsp, 28h
     56    pop rbx
     57    pop r15
     58    pop r14
     59    pop r13
     60    pop r12
     61    pop rbp
     62    ret
     63callToJavaScript ENDP
     64
     65returnFromJavaScript PROC
     66    add rsp, 28h
     67    pop rbx
     68    pop r15
     69    pop r14
     70    pop r13
     71    pop r12
     72    pop rbp
     73    ret
     74returnFromJavaScript ENDP
     75       
    3276getHostCallReturnValue PROC
    3377    sub r13, 40

  • trunk/Source/JavaScriptCore/jit/JITStubsX86.h

    r158751 r159276  
    201201#endif // COMPILER(GCC)
    202202
     203#if COMPILER(MSVC)
     204
     205extern "C" {
     206
     207    // FIXME: Since Windows doesn't use the LLInt, we have inline stubs here.
     208    // Until the LLInt is changed to support Windows, these stub needs to be updated.
     209    __declspec(naked) EncodedJSValue callToJavaScript(void* code, ExecState*)
     210    {
     211        __asm {
     212            push ebp;
     213            mov eax, ebp;
     214            mov ebp, esp;
     215            push esi;
     216            push edi;
     217            push ebx;
     218            sub esp, 0x1c;
     219            mov ebp, [esp + 0x34];
     220            mov ebx, [ebp];
     221            mov [ebx], eax;
     222            call [esp + 0x30];
     223            add esp, 0x1c;
     224            pop ebx;
     225            pop edi;
     226            pop esi;
     227            pop ebp;
     228            ret;
     229        }
     230    }
     231
     232    __declspec(naked) void returnFromJavaScript()
     233    {
     234        __asm {
     235            add esp, 0x1c;
     236            pop ebx;
     237            pop edi;
     238            pop esi;
     239            pop ebp;
     240            ret;
     241        }
     242    }
     243}
     244
     245#endif // COMPILER(MSVC)
     246
    203247} // namespace JSC
    204248

  • trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp

    r158925 r159276  
    5555    UNUSED_PARAM(pointerGPR);
    5656#endif
    57 }
    58 
    59 static void returnFromJavaScript(CCallHelpers& jit)
    60 {
    61 #if CPU(X86_64)
    62 #if OS(WINDOWS)
    63     // JIT operations can use up to 6 args (4 in registers and 2 on the stack).
    64     // In addition, X86_64 ABI specifies that the worse case stack alignment
    65     // requirement is 32 bytes. Based on these factors, we need to pad the stack
    66     // and additional 40 bytes.
    67 #   define EXTRA_STACK_SIZE              40
    68     jit.addPtr(CCallHelpers::TrustedImm32(8), X86Registers::esp);
    69 #else
    70     // We don't need extra stack space for out-going args, but we need to align the
    71     // stack to 32 byte alignment, therefore add 8 bytes to the stack.
    72 #   define EXTRA_STACK_SIZE              8
    73     jit.addPtr(CCallHelpers::TrustedImm32(EXTRA_STACK_SIZE), X86Registers::esp);
    74 #endif
    75 
    76     jit.pop(X86Registers::ebx);
    77     jit.pop(X86Registers::r15);
    78     jit.pop(X86Registers::r14);
    79     jit.pop(X86Registers::r13);
    80     jit.pop(X86Registers::r12);
    81     jit.pop(X86Registers::ebp);
    82 #elif CPU(X86)
    83     // JIT Operation can use up to 6 arguments right now. So, we need to
    84     // reserve space in this stack frame for the out-going args. To ensure that
    85     // the stack remains aligned on an 16 byte boundary, we round the padding up
    86     // by 28 bytes.
    87 #   define EXTRA_STACK_SIZE 28
    88 
    89     jit.addPtr(CCallHelpers::TrustedImm32(EXTRA_STACK_SIZE), X86Registers::esp);
    90 
    91     jit.pop(X86Registers::ebx);
    92     jit.pop(X86Registers::edi);
    93     jit.pop(X86Registers::esi);
    94     jit.pop(X86Registers::ebp);
    95 #elif CPU(ARM_TRADITIONAL)
    96     // JIT Operation can use up to 6 arguments right now. So, we need to
    97     // reserve space in this stack frame for the out-going args. We need to
    98     // add space for 16 more bytes.
    99 #   define EXTRA_STACK_SIZE              16
    100 
    101     jit.addPtr(CCallHelpers::TrustedImm32(EXTRA_STACK_SIZE), ARMRegisters::sp);
    102 
    103     jit.pop(ARMRegisters::lr);
    104     jit.pop(ARMRegisters::r11);
    105     jit.pop(ARMRegisters::r10);
    106     jit.pop(ARMRegisters::r9);
    107     jit.pop(ARMRegisters::r8);
    108     jit.pop(ARMRegisters::r6);
    109     jit.pop(ARMRegisters::r5);
    110     jit.pop(ARMRegisters::r4);
    111 #elif CPU(ARM_THUMB2)
    112     // JIT Operation can use up to 6 arguments right now. So, we need to
    113     // reserve space in this stack frame for the out-going args. To ensure that
    114     // the stack remains aligned on an 16 byte boundary, we round the padding up
    115     // by 28 bytes.
    116 #   define EXTRA_STACK_SIZE              28
    117 
    118     jit.addPtr(CCallHelpers::TrustedImm32(EXTRA_STACK_SIZE), ARMRegisters::sp);
    119     jit.pop(ARMRegisters::r11);
    120     jit.pop(ARMRegisters::r10);
    121     jit.pop(ARMRegisters::r9);
    122     jit.pop(ARMRegisters::r8);
    123     jit.pop(ARMRegisters::r7);
    124     jit.pop(ARMRegisters::r6);
    125     jit.pop(ARMRegisters::r5);
    126     jit.pop(ARMRegisters::r4);
    127     jit.pop(ARMRegisters::lr);
    128 #elif CPU(ARM64)
    129     jit.pop(ARM64Registers::x28);
    130     jit.pop(ARM64Registers::x27);
    131     jit.pop(ARM64Registers::x26);
    132     jit.pop(ARM64Registers::x25);
    133     jit.pop(ARM64Registers::x24);
    134     jit.pop(ARM64Registers::x23);
    135     jit.pop(ARM64Registers::x22);
    136     jit.pop(ARM64Registers::x21);
    137     jit.pop(ARM64Registers::x20);
    138     jit.pop(ARM64Registers::x19);
    139     jit.pop(ARM64Registers::lr);
    140 #elif CPU(MIPS)
    141 #   define PRESERVED_GP_OFFSET         60
    142 #   define PRESERVED_S0_OFFSET         64
    143 #   define PRESERVED_S1_OFFSET         68
    144 #   define PRESERVED_S2_OFFSET         72
    145 #   define PRESERVED_S3_OFFSET         76
    146 #   define PRESERVED_S4_OFFSET         80
    147 #   define PRESERVED_RETURN_ADDRESS_OFFSET 84
    148 #   define PRESERVED_FP_OFFSET         88
    149 #   define STACK_LENGTH               112
    150 
    151     jit.loadPtr(CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_S0_OFFSET), MIPSRegisters::s0);
    152     jit.loadPtr(CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_S1_OFFSET), MIPSRegisters::s1);
    153     jit.loadPtr(CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_S2_OFFSET), MIPSRegisters::s2);
    154     jit.loadPtr(CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_S3_OFFSET), MIPSRegisters::s3);
    155     jit.loadPtr(CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_S4_OFFSET), MIPSRegisters::s4);
    156     jit.loadPtr(CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_RETURN_ADDRESS_OFFSET), MIPSRegisters::ra);
    157     jit.loadPtr(CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_FP_OFFSET), MIPSRegisters::fp);
    158     jit.addPtr(CCallHelpers::TrustedImm32(STACK_LENGTH), MIPSRegisters::sp);
    159 #elif CPU(SH4)
    160 #   define EXTRA_STACK_SIZE 20
    161 
    162     jit.addPtr(CCallHelpers::TrustedImm32(EXTRA_STACK_SIZE), SH4Registers::sp);
    163     jit.pop(SH4Registers::r8);
    164     jit.pop(SH4Registers::r9);
    165     jit.pop(SH4Registers::r10);
    166     jit.pop(SH4Registers::r11);
    167     jit.pop(SH4Registers::r13);
    168     jit.pop(SH4Registers::pr);
    169     jit.pop(SH4Registers::fp);
    170 #endif
    171 
    172     jit.ret();
    173 }
    174 
    175 MacroAssemblerCodeRef callToJavaScript(VM* vm)
    176 {
    177     // The signature of the code generated is EncodedJSValue callToJavaScript(void* code, CallFrame*)
    178 
    179     CCallHelpers jit(vm);
    180 
    181 #if CPU(X86_64)
    182 #if OS(WINDOWS)
    183     // Dump register parameters to their home address
    184     jit.storePtr(X86Registers::r9, CCallHelpers::Address(X86Registers::esp, 0x20));
    185     jit.storePtr(X86Registers::r8, CCallHelpers::Address(X86Registers::esp, 0x18));
    186     jit.storePtr(X86Registers::edx, CCallHelpers::Address(X86Registers::esp, 0x10));
    187     jit.storePtr(X86Registers::ecx, CCallHelpers::Address(X86Registers::esp, 0x8));
    188 #endif // OS(WINDOWS)
    189     jit.push(X86Registers::ebp);
    190     jit.move(X86Registers::ebp, GPRInfo::nonArgGPR0);
    191     jit.move(X86Registers::esp, X86Registers::ebp);
    192     jit.push(X86Registers::r12);
    193     jit.push(X86Registers::r13);
    194     jit.push(X86Registers::r14);
    195     jit.push(X86Registers::r15);
    196     jit.push(X86Registers::ebx);
    197 
    198     jit.subPtr(CCallHelpers::TrustedImm32(EXTRA_STACK_SIZE), X86Registers::esp);
    199 
    200 #   define CALLFRAME_SRC_REG GPRInfo::argumentGPR1
    201 #   define PREVIOUS_CALLFRAME_REG GPRInfo::nonArgGPR0
    202 #elif CPU(X86)
    203     jit.push(X86Registers::ebp);
    204     jit.move(X86Registers::ebp, GPRInfo::nonArgGPR0);
    205     jit.move(X86Registers::esp, X86Registers::ebp);
    206     jit.push(X86Registers::esi);
    207     jit.push(X86Registers::edi);
    208     jit.push(X86Registers::ebx);
    209 
    210     jit.subPtr(CCallHelpers::TrustedImm32(EXTRA_STACK_SIZE), X86Registers::esp);
    211 
    212     jit.load32(CCallHelpers::Address(X86Registers::esp, EXTRA_STACK_SIZE + 24), GPRInfo::callFrameRegister);
    213 
    214 #   define CALLFRAME_SRC_REG GPRInfo::callFrameRegister
    215 #   define CALL_CODE jit.call(CCallHelpers::Address(X86Registers::esp, EXTRA_STACK_SIZE + 20))
    216 #   define PREVIOUS_CALLFRAME_REG GPRInfo::nonArgGPR0
    217 #elif CPU(ARM_TRADITIONAL)
    218     jit.push(ARMRegisters::r4);
    219     jit.push(ARMRegisters::r5);
    220     jit.push(ARMRegisters::r6);
    221     jit.push(ARMRegisters::r8);
    222     jit.push(ARMRegisters::r9);
    223     jit.push(ARMRegisters::r10);
    224     jit.push(ARMRegisters::r11);
    225     jit.push(ARMRegisters::lr);
    226     jit.move(ARMRegisters::r11, GPRInfo::nonArgGPR0);
    227     jit.subPtr(CCallHelpers::TrustedImm32(EXTRA_STACK_SIZE), ARMRegisters::sp);
    228 
    229 #   define CALLFRAME_SRC_REG GPRInfo::argumentGPR1
    230 #   define PREVIOUS_CALLFRAME_REG GPRInfo::nonArgGPR0
    231 #elif CPU(ARM_THUMB2)
    232     jit.push(ARMRegisters::lr);
    233     jit.push(ARMRegisters::r4);
    234     jit.push(ARMRegisters::r5);
    235     jit.push(ARMRegisters::r6);
    236     jit.push(ARMRegisters::r7);
    237     jit.push(ARMRegisters::r8);
    238     jit.push(ARMRegisters::r9);
    239     jit.push(ARMRegisters::r10);
    240     jit.push(ARMRegisters::r11);
    241     jit.move(ARMRegisters::r7, GPRInfo::nonArgGPR0);
    242     jit.subPtr(CCallHelpers::TrustedImm32(EXTRA_STACK_SIZE), ARMRegisters::sp);
    243 
    244 #   define CALLFRAME_SRC_REG GPRInfo::argumentGPR1
    245 #   define PREVIOUS_CALLFRAME_REG GPRInfo::nonArgGPR0
    246 #elif CPU(ARM64)
    247     jit.push(ARM64Registers::lr);
    248     jit.push(ARM64Registers::x19);
    249     jit.push(ARM64Registers::x20);
    250     jit.push(ARM64Registers::x21);
    251     jit.push(ARM64Registers::x22);
    252     jit.push(ARM64Registers::x23);
    253     jit.push(ARM64Registers::x24);
    254     jit.push(ARM64Registers::x25);
    255     jit.push(ARM64Registers::x26);
    256     jit.push(ARM64Registers::x27);
    257     jit.push(ARM64Registers::x28);
    258     jit.push(ARM64Registers::x29);
    259     jit.move(ARM64Registers::x29, GPRInfo::nonArgGPR0);
    260 
    261 #   define CALLFRAME_SRC_REG GPRInfo::argumentGPR1
    262 #   define PREVIOUS_CALLFRAME_REG GPRInfo::nonArgGPR0
    263 #elif CPU(MIPS)
    264     jit.subPtr(CCallHelpers::TrustedImm32(STACK_LENGTH), MIPSRegisters::sp);
    265     jit.storePtr(MIPSRegisters::fp, CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_FP_OFFSET));
    266     jit.storePtr(MIPSRegisters::ra, CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_RETURN_ADDRESS_OFFSET));
    267     jit.storePtr(MIPSRegisters::s4, CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_S4_OFFSET));
    268     jit.storePtr(MIPSRegisters::s3, CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_S3_OFFSET));
    269     jit.storePtr(MIPSRegisters::s2, CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_S2_OFFSET));
    270     jit.storePtr(MIPSRegisters::s1, CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_S1_OFFSET));
    271     jit.storePtr(MIPSRegisters::s0, CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_S0_OFFSET));
    272 #if WTF_MIPS_PIC
    273     jit.storePtr(MIPSRegisters::gp, CCallHelpers::Address(MIPSRegisters::sp, PRESERVED_GP_OFFSET));
    274 #endif
    275     jit.move(MIPSRegisters::fp, GPRInfo::nonArgGPR0);
    276 
    277 #   define CALLFRAME_SRC_REG GPRInfo::argumentGPR1
    278 #   define PREVIOUS_CALLFRAME_REG GPRInfo::nonArgGPR0
    279 #elif CPU(SH4)
    280     jit.push(SH4Registers::fp);
    281     jit.push(SH4Registers::pr);
    282     jit.push(SH4Registers::r13);
    283     jit.push(SH4Registers::r11);
    284     jit.push(SH4Registers::r10);
    285     jit.push(SH4Registers::r9);
    286     jit.push(SH4Registers::r8);
    287     jit.subPtr(CCallHelpers::TrustedImm32(EXTRA_STACK_SIZE), SH4Registers::sp);
    288     jit.move(SH4Registers::fp, GPRInfo::nonArgGPR0);
    289 
    290 #   define CALLFRAME_SRC_REG GPRInfo::argumentGPR1
    291 #   define PREVIOUS_CALLFRAME_REG GPRInfo::nonArgGPR0
    292 #endif
    293 
    294     if (CALLFRAME_SRC_REG != GPRInfo::callFrameRegister)
    295         jit.move(CALLFRAME_SRC_REG, GPRInfo::callFrameRegister);
    296     jit.loadPtr(CCallHelpers::Address(GPRInfo::callFrameRegister), GPRInfo::nonArgGPR1);
    297     jit.storePtr(PREVIOUS_CALLFRAME_REG, CCallHelpers::Address(GPRInfo::nonArgGPR1));
    298 
    299 #if USE(JSVALUE64)
    300     jit.move(CCallHelpers::TrustedImm64(0xffff000000000000L), GPRInfo::tagTypeNumberRegister);
    301     jit.move(CCallHelpers::TrustedImm64(0xffff000000000002L), GPRInfo::tagMaskRegister);
    302 #endif
    303 
    304 #if defined(CALL_CODE)
    305     CALL_CODE;
    306 #else
    307     jit.call(GPRInfo::argumentGPR0);
    308 #endif
    309 
    310 #undef CALLFRAME_SRC_REG
    311 #undef CALL_CODE
    312 #undef PREVIOUS_CALLFRAME_REG
    313 
    314     returnFromJavaScript(jit);
    315 
    316     LinkBuffer patchBuffer(*vm, &jit, GLOBAL_THUNK_ID);
    317     return FINALIZE_CODE(patchBuffer, ("Call to JavaScript thunk"));
    318 }
    319 
    320 MacroAssemblerCodeRef throwNotCaught(VM* vm)
    321 {
    322     CCallHelpers jit(vm);
    323 
    324     returnFromJavaScript(jit);
    325 
    326     LinkBuffer patchBuffer(*vm, &jit, GLOBAL_THUNK_ID);
    327     return FINALIZE_CODE(patchBuffer, ("Uncaught throw thunk"));
    32857}
    32958

  • trunk/Source/JavaScriptCore/jit/ThunkGenerators.h

    r158751 r159276  
    3131#if ENABLE(JIT)
    3232namespace JSC {
    33 
    34 MacroAssemblerCodeRef callToJavaScript(VM*);
    35 MacroAssemblerCodeRef throwNotCaught(VM*);
    3633
    3734MacroAssemblerCodeRef throwExceptionFromCallSlowPathGenerator(VM*);

  • trunk/Source/JavaScriptCore/llint/LLIntThunks.h

    r148696 r159276  
    3535namespace JSC {
    3636
     37class ExecState;
    3738class VM;
     39
     40extern "C" {
     41    EncodedJSValue callToJavaScript(void*, ExecState*);
     42    void returnFromJavaScript();
     43}
    3844
    3945namespace LLInt {

  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter.asm

    r158315 r159276  
    422422end
    423423
     424# stub to call into JavaScript
     425# EncodedJSValue callToJavaScript(void* code, Register* topOfStack)
     426# Note, if this stub or one of it's related macros is changed, make the
     427# equivalent changes in jit/JITStubsX86.h and/or jit/JITStubsMSVC64.asm
     428_callToJavaScript:
     429    doCallToJavaScript()
    424430
    425431# Indicate the beginning of LLInt.

  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm

    r158237 r159276  
    148148    move t0, PC
    149149    move t1, cfr
     150end
     151
     152macro functionPrologue(extraStackSpace)
     153    if X86
     154        push cfr
     155        move sp, cfr
     156    end
     157    pushCalleeSaves
     158    if ARM or ARMv7 or ARMv7_TRADITIONAL or MIPS
     159        push cfr
     160        push lr
     161    end
     162    subp extraStackSpace, sp
     163end
     164
     165macro functionEpilogue(extraStackSpace)
     166    addp extraStackSpace, sp
     167    if ARM or ARMv7 or ARMv7_TRADITIONAL or MIPS
     168        pop lr
     169        pop cfr
     170    end
     171    popCalleeSaves
     172    if X86
     173        pop cfr
     174    end
     175end
     176
     177macro doCallToJavaScript()
     178    if X86
     179        const extraStackSpace = 28
     180        const previousCFR = t0
     181        const entry = t5
     182        const newCallFrame = t4
     183    elsif ARM or ARMv7_TRADITIONAL
     184        const extraStackSpace = 16
     185        const previousCFR = t3 
     186        const entry = a0
     187        const newCallFrame = a1
     188    elsif ARMv7
     189        const extraStackSpace = 28
     190        const previousCFR = t3 
     191        const entry = a0
     192        const newCallFrame = a1
     193    elsif MIPS
     194        const extraStackSpace = 20
     195        const previousCFR = t2 
     196        const entry = a0
     197        const newCallFrame = a1
     198    elsif SH4
     199        const extraStackSpace = 20
     200        const previousCFR = t3 
     201        const entry = a0
     202        const newCallFrame = a1
     203    end
     204
     205    if X86
     206        move cfr, previousCFR
     207    end
     208    functionPrologue(extraStackSpace)
     209    if X86
     210        loadp extraStackSpace+20[sp], entry
     211        loadp extraStackSpace+24[sp], newCallFrame
     212    else
     213        move cfr, previousCFR
     214    end
     215
     216    move newCallFrame, cfr
     217    loadp [cfr], newCallFrame
     218    storep previousCFR, [newCallFrame]
     219    call entry
     220
     221_returnFromJavaScript:
     222    functionEpilogue(extraStackSpace)
     223    ret
    150224end
    151225

  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter64.asm

    r158237 r159276  
    8787        error
    8888    end
     89end
     90
     91macro functionPrologue(extraStackSpace)
     92    if X86_64
     93        push cfr
     94        move sp, cfr
     95    elsif ARM64
     96        push lr
     97    end
     98    pushCalleeSaves
     99    if X86_64
     100        subp extraStackSpace, sp
     101    elsif ARM64
     102        push cfr
     103    end
     104end
     105
     106macro functionEpilogue(extraStackSpace)
     107    if X86_64
     108        addp extraStackSpace, sp
     109    end
     110    popCalleeSaves
     111    if X86_64
     112        pop cfr
     113    elsif ARM64
     114        pop lr
     115    end
     116end
     117
     118macro doCallToJavaScript()
     119    if X86_64
     120        const extraStackSpace = 8
     121        const previousCFR = t0
     122        const entry = t5
     123        const newCallFrame = t4
     124    elsif ARM64
     125        const extraStackSpace = 0
     126        const previousCFR = t4 
     127        const entry = a0
     128        const newCallFrame = a1
     129    end
     130
     131    move cfr, previousCFR
     132    functionPrologue(extraStackSpace)
     133
     134    move newCallFrame, cfr
     135    loadp [cfr], newCallFrame
     136    storep previousCFR, [newCallFrame]
     137    move 0xffff000000000000, csr1
     138    addp 2, csr1, csr2
     139    call entry
     140
     141_returnFromJavaScript:
     142    functionEpilogue(extraStackSpace)
     143    ret
    89144end
    90145

  • trunk/Source/JavaScriptCore/offlineasm/arm.rb

    r158883 r159276  
    9898            "r4"
    9999        when "t4"
    100             "r10"
     100            "r8"
     101        when "t5"
     102            "r9"
    101103        when "cfr"
    102104            isARMv7 ?  "r7" : "r11"
    … …  
    452454            raise "ARM does not support this opcode yet, #{codeOrigin}"
    453455        when "pop"
    454             $asm.puts "pop #{operands[0].armOperand}"
     456            $asm.puts "pop { #{operands[0].armOperand} }"
    455457        when "push"
    456             $asm.puts "push #{operands[0].armOperand}"
     458            $asm.puts "push { #{operands[0].armOperand} }"
     459        when "popCalleeSaves"
     460            if isARMv7
     461                $asm.puts "pop {r4-r6, r8-r11}"               
     462            else
     463                $asm.puts "pop {r4-r10}"
     464            end
     465        when "pushCalleeSaves"
     466            if isARMv7
     467                $asm.puts "push {r4-r6, r8-r11}"
     468            else
     469                $asm.puts "push {r4-r10}"
     470            end
    457471        when "move"
    458472            if operands[0].immediate?

  • trunk/Source/JavaScriptCore/offlineasm/arm64.rb

    r158883 r159276  
    3939#  x0  => return value, cached result, first argument, t0, a0, r0
    4040#  x1  => t1, a1, r1
    41 #  x2  => t2
     41#  x2  => t2, a2
     42#  x3  => a3
    4243#  x9  => (nonArgGPR1 in baseline)
    4344# x10  => t4 (unused in baseline)
    … …  
    4849# x17  => scratch
    4950# x23  => t3
    50 # x25  => cfr
    51 # x26  => timeout check (i.e. not touched by LLInt)
    5251# x27  => csr1 (tagTypeNumber)
    5352# x28  => csr2 (tagMask)
     53# x29  => cfr
    5454#  sp  => sp
    5555#  lr  => lr
    … …  
    107107        when 't1', 'a1', 'r1'
    108108            arm64GPRName('x1', kind)
    109         when 't2'
     109        when 't2', 'a2'
    110110            arm64GPRName('x2', kind)
     111        when 'a3'
     112            arm64GPRName('x3', kind)
    111113        when 't3'
    112114            arm64GPRName('x23', kind)
    … …  
    568570        when "push"
    569571            emitARM64Unflipped("push", operands, :ptr)
     572        when "popCalleeSaves"
     573            emitARM64Unflipped("pop", "x28", :ptr)
     574            emitARM64Unflipped("pop", "x27", :ptr)
     575            emitARM64Unflipped("pop", "x26", :ptr)
     576            emitARM64Unflipped("pop", "x25", :ptr)
     577            emitARM64Unflipped("pop", "x24", :ptr)
     578            emitARM64Unflipped("pop", "x23", :ptr)
     579            emitARM64Unflipped("pop", "x22", :ptr)
     580            emitARM64Unflipped("pop", "x21", :ptr)
     581            emitARM64Unflipped("pop", "x20", :ptr)
     582            emitARM64Unflipped("pop", "x19", :ptr)
     583        when "pushCalleeSaves"
     584            emitARM64Unflipped("push", "x19", :ptr)
     585            emitARM64Unflipped("push", "x20", :ptr)
     586            emitARM64Unflipped("push", "x21", :ptr)
     587            emitARM64Unflipped("push", "x22", :ptr)
     588            emitARM64Unflipped("push", "x23", :ptr)
     589            emitARM64Unflipped("push", "x24", :ptr)
     590            emitARM64Unflipped("push", "x25", :ptr)
     591            emitARM64Unflipped("push", "x26", :ptr)
     592            emitARM64Unflipped("push", "x27", :ptr)
     593            emitARM64Unflipped("push", "x28", :ptr)
    570594        when "move"
    571595            if operands[0].immediate?

  • trunk/Source/JavaScriptCore/offlineasm/instructions.rb

    r157937 r159276  
    250250     "leai",
    251251     "leap",
     252     "pushCalleeSaves",
     253     "popCalleeSaves"
    252254    ]
    253255

  • trunk/Source/JavaScriptCore/offlineasm/mips.rb

    r158883 r159276  
    8383        when "a1"
    8484            "$a1"
     85        when "a2"
     86            "$a2"
     87        when "a3"
     88            "$a3"
    8589        when "r0", "t0"
    8690            "$v0"
    … …  
    793797            $asm.puts "addiu $sp, $sp, -4"
    794798            $asm.puts "sw #{operands[0].mipsOperand}, 0($sp)"
     799        when "popCalleeSaves"
     800            $asm.puts "lw $16, 0($sp)"
     801            $asm.puts "lw $17, 4($sp)"
     802            $asm.puts "lw $18, 8($sp)"
     803            $asm.puts "lw $19, 12($sp)"
     804            $asm.puts "lw $20, 16($sp)"
     805            $asm.puts "addiu $sp, $sp, 20"
     806        when "pushCalleeSaves"
     807            $asm.puts "addiu $sp, $sp, -20"
     808            $asm.puts "sw $20, 16($sp)"
     809            $asm.puts "sw $19, 12($sp)"
     810            $asm.puts "sw $18, 8($sp)"
     811            $asm.puts "sw $17, 4($sp)"
     812            $asm.puts "sw $16, 0($sp)"
    795813        when "move", "sxi2p", "zxi2p"
    796814            if operands[0].is_a? Immediate

  • trunk/Source/JavaScriptCore/offlineasm/registers.rb

    r122650 r159276  
    3131     "t3",
    3232     "t4",
     33     "t5",
    3334     "cfr",
    3435     "a0",
    3536     "a1",
     37     "a2",
     38     "a3",
    3639     "r0",
    3740     "r1",
    … …  
    4043     
    4144     # 64-bit only registers:
    42      "t5",
    43      "t6",  # r10
    44      "csr1",  # r14, tag type number register
    45      "csr2"   # r15, tag mask register
     45     "t6",
     46     "csr1",  # tag type number register
     47     "csr2"   # tag mask register
    4648    ]
    4749

  • trunk/Source/JavaScriptCore/offlineasm/sh4.rb

    r157452 r159276  
    6262        when "a1"
    6363            "r5"
     64        when "a2"
     65            "r6"
     66        when "a3"
     67            "r7"
    6468        when "t0"
    6569            "r0"
    … …  
    7175            "r10"
    7276        when "t4"
    73             "r6"
     77            "r4"
     78        when "t5"
     79            "r5"
    7480        when "cfr"
    7581            "r14"
    … …  
    906912        when "stspr"
    907913            $asm.puts "sts pr, #{sh4Operands(operands)}"
     914        when "popCalleeSaves"
     915            $asm.puts "mov.l @r15+, r8"
     916            $asm.puts "mov.l @r15+, r9"
     917            $asm.puts "mov.l @r15+, r10"
     918            $asm.puts "mov.l @r15+, r11"
     919            $asm.puts "mov.l @r15+, r13"
     920            $asm.puts "lds.l @r15+,pr"
     921            $asm.puts "mov.l @r15+, fp"
     922        when "pushCalleeSaves"
     923            $asm.puts "mov.l fp, @-r15"
     924            $asm.puts "sts.l pr, @-r15"
     925            $asm.puts "mov.l r13, @-r15"
     926            $asm.puts "mov.l r11, @-r15"
     927            $asm.puts "mov.l r10, @-r15"
     928            $asm.puts "mov.l r9, @-r15"
     929            $asm.puts "mov.l r8, @-r15"
    908930        when "break"
    909931            # This special opcode always generates an illegal instruction exception.

  • trunk/Source/JavaScriptCore/offlineasm/x86.rb

    r158883 r159276  
    7575    def supports8BitOnX86
    7676        case name
    77         when "t0", "a0", "r0", "t1", "a1", "r1", "t2", "t3"
     77        when "t0", "a0", "r0", "t1", "a1", "r1", "t2", "t3", "t4", "t5"
    7878            true
    7979        when "cfr", "ttnr", "tmr"
    8080            false
    81         when "t4", "t5"
     81        when "t6"
    8282            isX64
    8383        else
    … …  
    205205            end
    206206        when "t5"
    207             raise "Cannot use #{name} in 32-bit X86 at #{codeOriginString}" unless isX64
    208207            case kind
    209208            when :byte
    … …  
    214213                "%edi"
    215214            when :ptr
    216                 "%rdi"
     215                isX64 ? "%rdi" : "%edi"
    217216            when :quad
    218                 "%rdi"
     217                isX64 ? "%rdi" : raise
    219218            end
    220219        when "t6"
    … …  
    983982        when "push"
    984983            $asm.puts "push #{operands[0].x86Operand(:ptr)}"
     984        when "popCalleeSaves"
     985            if isX64
     986                $asm.puts "pop %rbx"
     987                $asm.puts "pop %r15"
     988                $asm.puts "pop %r14"
     989                $asm.puts "pop %r13"
     990                $asm.puts "pop %r12"
     991            else
     992                $asm.puts "pop %ebx"
     993                $asm.puts "pop %edi"
     994                $asm.puts "pop %esi"
     995            end
     996        when "pushCalleeSaves"
     997            if isX64
     998                $asm.puts "push %r12"
     999                $asm.puts "push %r13"
     1000                $asm.puts "push %r14"
     1001                $asm.puts "push %r15"
     1002                $asm.puts "push %rbx"
     1003            else
     1004                $asm.puts "push %esi"
     1005                $asm.puts "push %edi"
     1006                $asm.puts "push %ebx"
     1007            end
    9851008        when "move"
    9861009            handleMove

  • trunk/Source/JavaScriptCore/runtime/VM.cpp

    r158751 r159276  
    258258#if ENABLE(JIT)
    259259    jitStubs = adoptPtr(new JITThunks());
    260 
    261     callJavaScriptJITFunction = reinterpret_cast<CallJavaScriptJITFunction>(getCTIStub(callToJavaScript).code().executableAddress());
    262260#endif
    263261

  • trunk/Source/JavaScriptCore/runtime/VM.h

    r158751 r159276  
    330330        }
    331331        NativeExecutable* getHostFunction(NativeFunction, Intrinsic);
    332 
    333         typedef EncodedJSValue(*CallJavaScriptJITFunction)(void *, ExecState*);
    334 
    335         CallJavaScriptJITFunction callJavaScriptJITFunction;
    336332#endif
    337333#if ENABLE(FTL_JIT)
Note: See TracChangeset for help on using the changeset viewer.