Changeset 159871 in webkit


Ignore:
Timestamp:
Nov 29, 2013 6:16:18 AM (10 years ago)
Author:
commit-queue@webkit.org
Message:

Merge arm and sh4 paths in nativeForGenerator and privateCompileCTINativeCall functions.
https://bugs.webkit.org/show_bug.cgi?id=124892

Patch by Julien Brianceau <jbriance@cisco.com> on 2013-11-29
Reviewed by Zoltan Herczeg.

  • assembler/MacroAssemblerSH4.h:

(JSC::MacroAssemblerSH4::call): Pick a scratch register instead of getting it as a
parameter. The sh4 port was the only one to have this call(Address, RegisterID) prototype.

  • jit/JITOpcodes32_64.cpp:

(JSC::JIT::privateCompileCTINativeCall): Use argumentGPRx and merge arm and sh4 paths.

  • jit/ThunkGenerators.cpp:

(JSC::nativeForGenerator): Use argumentGPRx and merge arm and sh4 paths.

Location:
trunk/Source/JavaScriptCore
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/JavaScriptCore/ChangeLog

    r159855 r159871  
     12013-11-29  Julien Brianceau  <jbriance@cisco.com>
     2
     3        Merge arm and sh4 paths in nativeForGenerator and privateCompileCTINativeCall functions.
     4        https://bugs.webkit.org/show_bug.cgi?id=124892
     5
     6        Reviewed by Zoltan Herczeg.
     7
     8        * assembler/MacroAssemblerSH4.h:
     9        (JSC::MacroAssemblerSH4::call): Pick a scratch register instead of getting it as a
     10        parameter. The sh4 port was the only one to have this call(Address, RegisterID) prototype.
     11        * jit/JITOpcodes32_64.cpp:
     12        (JSC::JIT::privateCompileCTINativeCall): Use argumentGPRx and merge arm and sh4 paths.
     13        * jit/ThunkGenerators.cpp:
     14        (JSC::nativeForGenerator): Use argumentGPRx and merge arm and sh4 paths.
     15
    1162013-11-28  Nadav Rotem  <nrotem@apple.com>
    217
  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerSH4.h

    r159629 r159871  
    23612361    }
    23622362
    2363     void call(Address address, RegisterID target)
    2364     {
     2363    void call(Address address)
     2364    {
     2365        RegisterID target = claimScratch();
    23652366        load32(address.base, address.offset, target);
    23662367        m_assembler.ensureSpace(m_assembler.maxInstructionSize + 2);
    23672368        m_assembler.branch(JSR_OPCODE, target);
    23682369        m_assembler.nop();
     2370        releaseScratch(target);
    23692371    }
    23702372
  • trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp

    r159091 r159871  
    7575    addPtr(TrustedImm32(16 - sizeof(void*)), stackPointerRegister);
    7676
    77 #elif CPU(ARM)
    78     // Load caller frame's scope chain into this callframe so that whatever we call can
    79     // get to its global data.
     77#elif CPU(ARM) || CPU(SH4)
     78    // Load caller frame's scope chain into this callframe so that whatever we call can get to its global data.
    8079    emitGetCallerFrameFromCallFrameHeaderPtr(regT2);
    8180    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT2);
     
    8584    emitPutReturnPCToCallFrameHeader(regT3);
    8685
    87     // Calling convention:      f(r0 == regT0, r1 == regT1, ...);
    88     // Host function signature: f(ExecState*);
    89     move(callFrameRegister, ARMRegisters::r0);
    90 
    91     emitGetFromCallFrameHeaderPtr(JSStack::Callee, ARMRegisters::r1);
     86    // Calling convention is f(argumentGPR0, argumentGPR1, ...).
     87    // Host function signature is f(ExecState*).
     88    move(callFrameRegister, argumentGPR0);
     89
     90    emitGetFromCallFrameHeaderPtr(JSStack::Callee, argumentGPR1);
    9291    move(regT2, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.
    93     loadPtr(Address(ARMRegisters::r1, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);
     92    loadPtr(Address(argumentGPR1, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);
    9493
    9594    // call the function
     
    9796
    9897    restoreReturnAddressBeforeReturn(regT3);
    99 
    10098#elif CPU(MIPS)
    10199    // Load caller frame's scope chain into this callframe so that whatever we call can
     
    128126    // Restore stack space
    129127    addPtr(TrustedImm32(16), stackPointerRegister);
    130 
    131     restoreReturnAddressBeforeReturn(regT3);
    132 #elif CPU(SH4)
    133     // Load caller frame's scope chain into this callframe so that whatever we call can
    134     // get to its global data.
    135     emitGetCallerFrameFromCallFrameHeaderPtr(regT2);
    136     emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT1, regT2);
    137     emitPutCellToCallFrameHeader(regT1, JSStack::ScopeChain);
    138 
    139     preserveReturnAddressAfterCall(regT3); // Callee preserved
    140     emitPutReturnPCToCallFrameHeader(regT3);
    141 
    142     // Calling convention: f(r0 == regT4, r1 == regT5, ...);
    143     // Host function signature: f(ExecState*);
    144     move(callFrameRegister, regT4);
    145 
    146     emitGetFromCallFrameHeaderPtr(JSStack::Callee, regT5);
    147     move(regT2, callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.
    148     loadPtr(Address(regT5, OBJECT_OFFSETOF(JSFunction, m_executable)), regT2);
    149 
    150     // call the function
    151     nativeCall = call();
    152128
    153129    restoreReturnAddressBeforeReturn(regT3);
  • trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp

    r159593 r159871  
    344344    jit.restoreReturnAddressBeforeReturn(JSInterfaceJIT::regT3);
    345345
    346 #elif CPU(ARM)
    347     // Load caller frame's scope chain into this callframe so that whatever we call can
    348     // get to its global data.
     346#elif CPU(ARM) || CPU(SH4)
     347    // Load caller frame's scope chain into this callframe so that whatever we call can get to its global data.
    349348    jit.emitGetCallerFrameFromCallFrameHeaderPtr(JSInterfaceJIT::regT2);
    350349    jit.emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, JSInterfaceJIT::regT1, JSInterfaceJIT::regT2);
     
    354353    jit.emitPutReturnPCToCallFrameHeader(JSInterfaceJIT::regT3);
    355354
    356     // Calling convention:      f(r0 == regT0, r1 == regT1, ...);
    357     // Host function signature: f(ExecState*);
    358     jit.move(JSInterfaceJIT::callFrameRegister, ARMRegisters::r0);
    359 
    360     jit.emitGetFromCallFrameHeaderPtr(JSStack::Callee, ARMRegisters::r1);
     355    // Calling convention is f(argumentGPR0, argumentGPR1, ...).
     356    // Host function signature is f(ExecState*).
     357    jit.move(JSInterfaceJIT::callFrameRegister, JSInterfaceJIT::argumentGPR0);
     358
     359    jit.emitGetFromCallFrameHeaderPtr(JSStack::Callee, JSInterfaceJIT::argumentGPR1);
    361360    jit.move(JSInterfaceJIT::regT2, JSInterfaceJIT::callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.
    362     jit.loadPtr(JSInterfaceJIT::Address(ARMRegisters::r1, JSFunction::offsetOfExecutable()), JSInterfaceJIT::regT2);
     361    jit.loadPtr(JSInterfaceJIT::Address(JSInterfaceJIT::argumentGPR1, JSFunction::offsetOfExecutable()), JSInterfaceJIT::regT2);
    363362    jit.call(JSInterfaceJIT::Address(JSInterfaceJIT::regT2, executableOffsetToFunction));
    364363
    365364    jit.restoreReturnAddressBeforeReturn(JSInterfaceJIT::regT3);
    366 
    367 #elif CPU(SH4)
    368     // Load caller frame's scope chain into this callframe so that whatever we call can
    369     // get to its global data.
    370     jit.emitGetCallerFrameFromCallFrameHeaderPtr(JSInterfaceJIT::regT2);
    371     jit.emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, JSInterfaceJIT::regT1, JSInterfaceJIT::regT2);
    372     jit.emitPutCellToCallFrameHeader(JSInterfaceJIT::regT1, JSStack::ScopeChain);
    373 
    374     jit.preserveReturnAddressAfterCall(JSInterfaceJIT::regT3); // Callee preserved
    375     jit.emitPutReturnPCToCallFrameHeader(JSInterfaceJIT::regT3);
    376 
    377     // Calling convention: f(r0 == regT4, r1 == regT5, ...);
    378     // Host function signature: f(ExecState*);
    379     jit.move(JSInterfaceJIT::callFrameRegister, JSInterfaceJIT::regT4);
    380 
    381     jit.emitGetFromCallFrameHeaderPtr(JSStack::Callee, JSInterfaceJIT::regT5);
    382     jit.move(JSInterfaceJIT::regT2, JSInterfaceJIT::callFrameRegister); // Eagerly restore caller frame register to avoid loading from stack.
    383     jit.loadPtr(JSInterfaceJIT::Address(JSInterfaceJIT::regT5, JSFunction::offsetOfExecutable()), JSInterfaceJIT::regT2);
    384 
    385     jit.call(JSInterfaceJIT::Address(JSInterfaceJIT::regT2, executableOffsetToFunction), JSInterfaceJIT::regT0);
    386     jit.restoreReturnAddressBeforeReturn(JSInterfaceJIT::regT3);
    387 
    388365#elif CPU(MIPS)
    389366    // Load caller frame's scope chain into this callframe so that whatever we call can
Note: See TracChangeset for help on using the changeset viewer.