Changeset 215592 in webkit


Ignore:
Timestamp:
Apr 20, 2017 4:55:45 PM (7 years ago)
Author:
mark.lam@apple.com
Message:

Update the MASM probe to only take 1 arg instead of 2 (in addition to the callback function).
​https://bugs.webkit.org/show_bug.cgi?id=171088

Reviewed by Michael Saboff and Saam Barati.

Experience shows that we never use the 2nd arg. So, let's remove it to reduce
the footprint at each probe site.

Also fix the MacroAssembler::print() function so that it is a no-op when
!ENABLE(MASM_PROBE). This will allow us to have print() statements in JIT code
without a lot of #if ENABLE(MASM_PROBE)s later.

  • assembler/AbstractMacroAssembler.h:
  • assembler/MacroAssembler.cpp:

(JSC::stdFunctionCallback):
(JSC::MacroAssembler::probe):

  • assembler/MacroAssembler.h:
  • assembler/MacroAssemblerARM.cpp:

(JSC::MacroAssemblerARM::probe):

  • assembler/MacroAssemblerARM.h:
  • assembler/MacroAssemblerARM64.cpp:

(JSC::MacroAssemblerARM64::probe):

  • assembler/MacroAssemblerARM64.h:
  • assembler/MacroAssemblerARMv7.cpp:

(JSC::MacroAssemblerARMv7::probe):

  • assembler/MacroAssemblerARMv7.h:
  • assembler/MacroAssemblerPrinter.cpp:

(JSC::MacroAssemblerPrinter::printCallback):

  • assembler/MacroAssemblerPrinter.h:

(JSC::MacroAssemblerPrinter::print):
(JSC::MacroAssembler::print):

  • assembler/MacroAssemblerX86Common.cpp:

(JSC::MacroAssemblerX86Common::probe):

  • assembler/MacroAssemblerX86Common.h:
Location:
trunk/Source/JavaScriptCore
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r215584 r215592  
     12017-04-20  Mark Lam  <mark.lam@apple.com>
     2
     3        Update the MASM probe to only take 1 arg instead of 2 (in addition to the callback function).
     4        https://bugs.webkit.org/show_bug.cgi?id=171088
     5
     6        Reviewed by Michael Saboff and Saam Barati.
     7
     8        Experience shows that we never use the 2nd arg.  So, let's remove it to reduce
     9        the footprint at each probe site.
     10
     11        Also fix the MacroAssembler::print() function so that it is a no-op when
     12        !ENABLE(MASM_PROBE).  This will allow us to have print() statements in JIT code
     13        without a lot of #if ENABLE(MASM_PROBE)s later.
     14
     15        * assembler/AbstractMacroAssembler.h:
     16        * assembler/MacroAssembler.cpp:
     17        (JSC::stdFunctionCallback):
     18        (JSC::MacroAssembler::probe):
     19        * assembler/MacroAssembler.h:
     20        * assembler/MacroAssemblerARM.cpp:
     21        (JSC::MacroAssemblerARM::probe):
     22        * assembler/MacroAssemblerARM.h:
     23        * assembler/MacroAssemblerARM64.cpp:
     24        (JSC::MacroAssemblerARM64::probe):
     25        * assembler/MacroAssemblerARM64.h:
     26        * assembler/MacroAssemblerARMv7.cpp:
     27        (JSC::MacroAssemblerARMv7::probe):
     28        * assembler/MacroAssemblerARMv7.h:
     29        * assembler/MacroAssemblerPrinter.cpp:
     30        (JSC::MacroAssemblerPrinter::printCallback):
     31        * assembler/MacroAssemblerPrinter.h:
     32        (JSC::MacroAssemblerPrinter::print):
     33        (JSC::MacroAssembler::print):
     34        * assembler/MacroAssemblerX86Common.cpp:
     35        (JSC::MacroAssemblerX86Common::probe):
     36        * assembler/MacroAssemblerX86Common.h:
     37
    1382017-04-20  Matt Baker  <mattbaker@apple.com>
    239

  • trunk/Source/JavaScriptCore/assembler/AbstractMacroAssembler.h

    r215565 r215592  
    923923    // This prototype is only provided here to document the interface.
    924924
    925     void probe(ProbeFunction, void* arg1, void* arg2);
     925    void probe(ProbeFunction, void* arg);
    926926
    927927#endif // ENABLE(MASM_PROBE)

  • trunk/Source/JavaScriptCore/assembler/MacroAssembler.cpp

    r215196 r215592  
    3838static void stdFunctionCallback(ProbeContext* context)
    3939{
    40     auto func = static_cast<const std::function<void(ProbeContext*)>*>(context->arg1);
     40    auto func = static_cast<const std::function<void(ProbeContext*)>*>(context->arg);
    4141    (*func)(context);
    4242}
    … …  
    4444void MacroAssembler::probe(std::function<void(ProbeContext*)> func)
    4545{
    46     probe(stdFunctionCallback, new std::function<void(ProbeContext*)>(func), 0);
     46    probe(stdFunctionCallback, new std::function<void(ProbeContext*)>(func));
    4747}
    4848#endif // ENABLE(MASM_PROBE)

  • trunk/Source/JavaScriptCore/assembler/MacroAssembler.h

    r215196 r215592  
    18141814    using MacroAssemblerBase::probe;
    18151815
     1816    void probe(std::function<void(ProbeContext*)>);
     1817#endif
     1818
    18161819    // Let's you print from your JIT generated code.
     1820    // This only works if ENABLE(MASM_PROBE). Otherwise, print() is a no-op.
    18171821    // See comments in MacroAssemblerPrinter.h for examples of how to use this.
    18181822    template<typename... Arguments>
    18191823    void print(Arguments... args);
    1820 
    1821     void probe(std::function<void (ProbeContext*)>);
    1822 #endif
    18231824};
    18241825
    … …  
    18301831
    18311832    ProbeFunction probeFunction;
    1832     void* arg1;
    1833     void* arg2;
     1833    void* arg;
    18341834    CPUState cpu;
    18351835

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.cpp

    r215196 r215592  
    108108#define PTR_SIZE 4
    109109#define PROBE_PROBE_FUNCTION_OFFSET (0 * PTR_SIZE)
    110 #define PROBE_ARG1_OFFSET (1 * PTR_SIZE)
    111 #define PROBE_ARG2_OFFSET (2 * PTR_SIZE)
    112 
    113 #define PROBE_FIRST_GPREG_OFFSET (4 * PTR_SIZE)
     110#define PROBE_ARG_OFFSET (1 * PTR_SIZE)
     111
     112#define PROBE_FIRST_GPREG_OFFSET (2 * PTR_SIZE)
    114113
    115114#define GPREG_SIZE 4
    … …  
    155154
    156155#define PROBE_SIZE (PROBE_FIRST_FPREG_OFFSET + (16 * FPREG_SIZE))
     156#define PROBE_ALIGNED_SIZE (PROBE_SIZE)
    157157
    158158// These ASSERTs remind you that if you change the layout of ProbeContext,
    … …  
    160160#define PROBE_OFFSETOF(x) offsetof(struct ProbeContext, x)
    161161COMPILE_ASSERT(PROBE_OFFSETOF(probeFunction) == PROBE_PROBE_FUNCTION_OFFSET, ProbeContext_probeFunction_offset_matches_ctiMasmProbeTrampoline);
    162 COMPILE_ASSERT(PROBE_OFFSETOF(arg1) == PROBE_ARG1_OFFSET, ProbeContext_arg1_offset_matches_ctiMasmProbeTrampoline);
    163 COMPILE_ASSERT(PROBE_OFFSETOF(arg2) == PROBE_ARG2_OFFSET, ProbeContext_arg2_offset_matches_ctiMasmProbeTrampoline);
     162COMPILE_ASSERT(PROBE_OFFSETOF(arg) == PROBE_ARG_OFFSET, ProbeContext_arg_offset_matches_ctiMasmProbeTrampoline);
     163
     164COMPILE_ASSERT(!(PROBE_CPU_R0_OFFSET & 0x3), ProbeContext_cpu_r0_offset_should_be_4_byte_aligned);
    164165
    165166COMPILE_ASSERT(PROBE_OFFSETOF(cpu.r0) == PROBE_CPU_R0_OFFSET, ProbeContext_cpu_r0_offset_matches_ctiMasmProbeTrampoline);
    … …  
    183184COMPILE_ASSERT(PROBE_OFFSETOF(cpu.fpscr) == PROBE_CPU_FPSCR_OFFSET, ProbeContext_cpu_fpscr_offset_matches_ctiMasmProbeTrampoline);
    184185
     186COMPILE_ASSERT(!(PROBE_CPU_D0_OFFSET & 0xf), ProbeContext_cpu_d0_offset_should_be_16_byte_aligned);
     187
    185188COMPILE_ASSERT(PROBE_OFFSETOF(cpu.d0) == PROBE_CPU_D0_OFFSET, ProbeContext_cpu_d0_offset_matches_ctiMasmProbeTrampoline);
    186189COMPILE_ASSERT(PROBE_OFFSETOF(cpu.d1) == PROBE_CPU_D1_OFFSET, ProbeContext_cpu_d1_offset_matches_ctiMasmProbeTrampoline);
    … …  
    199202COMPILE_ASSERT(PROBE_OFFSETOF(cpu.d14) == PROBE_CPU_D14_OFFSET, ProbeContext_cpu_d14_offset_matches_ctiMasmProbeTrampoline);
    200203COMPILE_ASSERT(PROBE_OFFSETOF(cpu.d15) == PROBE_CPU_D15_OFFSET, ProbeContext_cpu_d15_offset_matches_ctiMasmProbeTrampoline);
     204
    201205COMPILE_ASSERT(sizeof(ProbeContext) == PROBE_SIZE, ProbeContext_size_matches_ctiMasmProbeTrampoline);
     206COMPILE_ASSERT(!(PROBE_ALIGNED_SIZE & 0xf), ProbeContext_aligned_size_offset_should_be_16_byte_aligned);
    202207#undef PROBE_OFFSETOF
    203208
    … …  
    212217    // The top of stack now looks like this:
    213218    //     esp[0 * ptrSize]: probeFunction
    214     //     esp[1 * ptrSize]: arg1
    215     //     esp[2 * ptrSize]: arg2
    216     //     esp[3 * ptrSize]: saved r3 / S0
    217     //     esp[4 * ptrSize]: saved ip
    218     //     esp[5 * ptrSize]: saved lr
    219     //     esp[6 * ptrSize]: saved sp
     219    //     esp[1 * ptrSize]: arg
     220    //     esp[2 * ptrSize]: saved r3 / S0
     221    //     esp[3 * ptrSize]: saved ip
     222    //     esp[4 * ptrSize]: saved lr
     223    //     esp[5 * ptrSize]: saved sp
    220224
    221225    "mov       ip, sp" "\n"
    222226    "mov       r3, sp" "\n"
    223     "sub       r3, r3, #" STRINGIZE_VALUE_OF(PROBE_SIZE) "\n"
     227    "sub       r3, r3, #" STRINGIZE_VALUE_OF(PROBE_ALIGNED_SIZE) "\n"
    224228
    225229    // The ARM EABI specifies that the stack needs to be 16 byte aligned.
    … …  
    238242    "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_PROBE_FUNCTION_OFFSET) "]" "\n"
    239243    "ldr       lr, [ip, #1 * " STRINGIZE_VALUE_OF(PTR_SIZE) "]" "\n"
    240     "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_ARG1_OFFSET) "]" "\n"
     244    "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_ARG_OFFSET) "]" "\n"
    241245    "ldr       lr, [ip, #2 * " STRINGIZE_VALUE_OF(PTR_SIZE) "]" "\n"
    242     "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_ARG2_OFFSET) "]" "\n"
     246    "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_R3_OFFSET) "]" "\n"
    243247    "ldr       lr, [ip, #3 * " STRINGIZE_VALUE_OF(PTR_SIZE) "]" "\n"
    244     "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_R3_OFFSET) "]" "\n"
     248    "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_IP_OFFSET) "]" "\n"
    245249    "ldr       lr, [ip, #4 * " STRINGIZE_VALUE_OF(PTR_SIZE) "]" "\n"
    246     "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_IP_OFFSET) "]" "\n"
     250    "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_LR_OFFSET) "]" "\n"
    247251    "ldr       lr, [ip, #5 * " STRINGIZE_VALUE_OF(PTR_SIZE) "]" "\n"
    248     "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_LR_OFFSET) "]" "\n"
    249     "ldr       lr, [ip, #6 * " STRINGIZE_VALUE_OF(PTR_SIZE) "]" "\n"
    250252    "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_SP_OFFSET) "]" "\n"
    251253
    … …  
    348350#endif // COMPILER(GCC_OR_CLANG)
    349351
    350 void MacroAssemblerARM::probe(ProbeFunction function, void* arg1, void* arg2)
     352void MacroAssemblerARM::probe(ProbeFunction function, void* arg)
    351353{
    352354    push(RegisterID::sp);
    … …  
    355357    push(RegisterID::S0);
    356358    // The following uses RegisterID::S0. So, they must come after we push S0 above.
    357     push(trustedImm32FromPtr(arg2));
    358     push(trustedImm32FromPtr(arg1));
     359    push(trustedImm32FromPtr(arg));
    359360    push(trustedImm32FromPtr(function));
    360361

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.h

    r214220 r215592  
    15601560
    15611561#if ENABLE(MASM_PROBE)
    1562     void probe(ProbeFunction, void* arg1, void* arg2);
     1562    void probe(ProbeFunction, void* arg);
    15631563#endif // ENABLE(MASM_PROBE)
    15641564

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.cpp

    r215196 r215592  
    4545#define PTR_SIZE 8
    4646#define PROBE_PROBE_FUNCTION_OFFSET (0 * PTR_SIZE)
    47 #define PROBE_ARG1_OFFSET (1 * PTR_SIZE)
    48 #define PROBE_ARG2_OFFSET (2 * PTR_SIZE)
    49 
    50 #define PROBE_FIRST_GPREG_OFFSET (3 * PTR_SIZE)
     47#define PROBE_ARG_OFFSET (1 * PTR_SIZE)
     48
     49#define PROBE_FIRST_GPREG_OFFSET (2 * PTR_SIZE)
    5150
    5251#define GPREG_SIZE 8
    … …  
    126125#define SAVED_CALLER_SP PROBE_SIZE
    127126#define PROBE_SIZE_PLUS_SAVED_CALLER_SP (SAVED_CALLER_SP + PTR_SIZE)
     127#define PROBE_ALIGNED_SIZE (PROBE_SIZE_PLUS_SAVED_CALLER_SP)
    128128
    129129// These ASSERTs remind you that if you change the layout of ProbeContext,
    … …  
    131131#define PROBE_OFFSETOF(x) offsetof(struct ProbeContext, x)
    132132COMPILE_ASSERT(PROBE_OFFSETOF(probeFunction) == PROBE_PROBE_FUNCTION_OFFSET, ProbeContext_probeFunction_offset_matches_ctiMasmProbeTrampoline);
    133 COMPILE_ASSERT(PROBE_OFFSETOF(arg1) == PROBE_ARG1_OFFSET, ProbeContext_arg1_offset_matches_ctiMasmProbeTrampoline);
    134 COMPILE_ASSERT(PROBE_OFFSETOF(arg2) == PROBE_ARG2_OFFSET, ProbeContext_arg2_offset_matches_ctiMasmProbeTrampoline);
     133COMPILE_ASSERT(PROBE_OFFSETOF(arg) == PROBE_ARG_OFFSET, ProbeContext_arg_offset_matches_ctiMasmProbeTrampoline);
     134
     135COMPILE_ASSERT(!(PROBE_CPU_X0_OFFSET & 0x7), ProbeContext_cpu_r0_offset_should_be_8_byte_aligned);
    135136
    136137COMPILE_ASSERT(PROBE_OFFSETOF(cpu.x0) == PROBE_CPU_X0_OFFSET, ProbeContext_cpu_x0_offset_matches_ctiMasmProbeTrampoline);
    … …  
    172173COMPILE_ASSERT(PROBE_OFFSETOF(cpu.fpsr) == PROBE_CPU_FPSR_OFFSET, ProbeContext_cpu_fpsr_offset_matches_ctiMasmProbeTrampoline);
    173174
     175COMPILE_ASSERT(!(PROBE_CPU_Q0_OFFSET & 0x7), ProbeContext_cpu_q0_offset_should_be_8_byte_aligned);
     176
    174177COMPILE_ASSERT(PROBE_OFFSETOF(cpu.q0) == PROBE_CPU_Q0_OFFSET, ProbeContext_cpu_q0_offset_matches_ctiMasmProbeTrampoline);
    175178COMPILE_ASSERT(PROBE_OFFSETOF(cpu.q1) == PROBE_CPU_Q1_OFFSET, ProbeContext_cpu_q1_offset_matches_ctiMasmProbeTrampoline);
    … …  
    207210
    208211COMPILE_ASSERT(sizeof(ProbeContext) == PROBE_SIZE, ProbeContext_size_matches_ctiMasmProbeTrampoline);
     212COMPILE_ASSERT(!(PROBE_ALIGNED_SIZE & 0xf), ProbeContext_aligned_size_offset_should_be_16_byte_aligned);
    209213
    210214#undef PROBE_OFFSETOF
    … …  
    221225    //     sp[0 * ptrSize]: probeFunction
    222226    //     sp[1 * ptrSize]: arg1
    223     //     sp[2 * ptrSize]: arg2
    224     //     sp[3 * ptrSize]: address of arm64ProbeTrampoline()
    225     //     sp[4 * ptrSize]: saved x27
    226     //     sp[5 * ptrSize]: saved x28
    227     //     sp[6 * ptrSize]: saved lr
    228     //     sp[7 * ptrSize]: saved sp
     227    //     sp[2 * ptrSize]: address of arm64ProbeTrampoline()
     228    //     sp[3 * ptrSize]: saved x27
     229    //     sp[4 * ptrSize]: saved x28
     230    //     sp[5 * ptrSize]: saved lr
     231    //     sp[6 * ptrSize]: saved sp
    229232
    230233    "mov       x27, sp" "\n"
    231234    "mov       x28, sp" "\n"
    232235
    233     "sub       x28, x28, #" STRINGIZE_VALUE_OF(PROBE_SIZE_PLUS_SAVED_CALLER_SP) "\n"
     236    "sub       x28, x28, #" STRINGIZE_VALUE_OF(PROBE_ALIGNED_SIZE) "\n"
    234237
    235238    // The ARM EABI specifies that the stack needs to be 16 byte aligned.
    … …  
    267270    "str       x26, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_X26_OFFSET) "]" "\n"
    268271
     272    "ldr       x0, [x27, #3 * " STRINGIZE_VALUE_OF(PTR_SIZE) "]" "\n"
     273    "str       x0, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_X27_OFFSET) "]" "\n"
    269274    "ldr       x0, [x27, #4 * " STRINGIZE_VALUE_OF(PTR_SIZE) "]" "\n"
    270     "str       x0, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_X27_OFFSET) "]" "\n"
     275    "str       x0, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_X28_OFFSET) "]" "\n"
     276
     277    "str       fp, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_FP_OFFSET) "]" "\n"
     278
    271279    "ldr       x0, [x27, #5 * " STRINGIZE_VALUE_OF(PTR_SIZE) "]" "\n"
    272     "str       x0, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_X28_OFFSET) "]" "\n"
    273 
    274     "str       fp, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_FP_OFFSET) "]" "\n"
    275 
     280    "str       x0, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_LR_OFFSET) "]" "\n"
    276281    "ldr       x0, [x27, #6 * " STRINGIZE_VALUE_OF(PTR_SIZE) "]" "\n"
    277     "str       x0, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_LR_OFFSET) "]" "\n"
    278     "ldr       x0, [x27, #7 * " STRINGIZE_VALUE_OF(PTR_SIZE) "]" "\n"
    279282    "str       x0, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_SP_OFFSET) "]" "\n"
    280283
    … …  
    289292    "str       x0, [sp, #" STRINGIZE_VALUE_OF(PROBE_PROBE_FUNCTION_OFFSET) "]" "\n"
    290293    "ldr       x0, [x27, #1 * " STRINGIZE_VALUE_OF(PTR_SIZE) "]" "\n"
    291     "str       x0, [sp, #" STRINGIZE_VALUE_OF(PROBE_ARG1_OFFSET) "]" "\n"
    292     "ldr       x0, [x27, #2 * " STRINGIZE_VALUE_OF(PTR_SIZE) "]" "\n"
    293     "str       x0, [sp, #" STRINGIZE_VALUE_OF(PROBE_ARG2_OFFSET) "]" "\n"
     294    "str       x0, [sp, #" STRINGIZE_VALUE_OF(PROBE_ARG_OFFSET) "]" "\n"
    294295
    295296    "str       d0, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_Q0_OFFSET) "]" "\n"
    … …  
    472473}
    473474
    474 void MacroAssemblerARM64::probe(ProbeFunction function, void* arg1, void* arg2)
     475void MacroAssemblerARM64::probe(ProbeFunction function, void* arg)
    475476{
    476     sub64(TrustedImm32(8 * 8), sp);
    477 
    478     store64(x27, Address(sp, 4 * 8));
    479     store64(x28, Address(sp, 5 * 8));
    480     store64(lr, Address(sp, 6 * 8));
    481 
    482     add64(TrustedImm32(8 * 8), sp, x28);
    483     store64(x28, Address(sp, 7 * 8)); // Save original sp value.
     477    sub64(TrustedImm32(7 * 8), sp);
     478
     479    store64(x27, Address(sp, 3 * 8));
     480    store64(x28, Address(sp, 4 * 8));
     481    store64(lr, Address(sp, 5 * 8));
     482
     483    add64(TrustedImm32(7 * 8), sp, x28);
     484    store64(x28, Address(sp, 6 * 8)); // Save original sp value.
    484485
    485486    move(TrustedImmPtr(reinterpret_cast<void*>(function)), x28);
    486487    store64(x28, Address(sp));
    487     move(TrustedImmPtr(arg1), x28);
     488    move(TrustedImmPtr(arg), x28);
    488489    store64(x28, Address(sp, 1 * 8));
    489     move(TrustedImmPtr(arg2), x28);
     490    move(TrustedImmPtr(reinterpret_cast<void*>(arm64ProbeTrampoline)), x28);
    490491    store64(x28, Address(sp, 2 * 8));
    491     move(TrustedImmPtr(reinterpret_cast<void*>(arm64ProbeTrampoline)), x28);
    492     store64(x28, Address(sp, 3 * 8));
    493492
    494493    move(TrustedImmPtr(reinterpret_cast<void*>(ctiMasmProbeTrampoline)), x28);
    … …  
    497496    // ctiMasmProbeTrampoline should have restored every register except for
    498497    // lr and the sp.
    499     load64(Address(sp, 6 * 8), lr);
    500     add64(TrustedImm32(8 * 8), sp);
     498    load64(Address(sp, 5 * 8), lr);
     499    add64(TrustedImm32(7 * 8), sp);
    501500}
    502501#endif // ENABLE(MASM_PROBE)

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h

    r215565 r215592  
    37643764
    37653765#if ENABLE(MASM_PROBE)
    3766     void probe(ProbeFunction, void* arg1, void* arg2);
     3766    void probe(ProbeFunction, void* arg);
    37673767#endif // ENABLE(MASM_PROBE)
    37683768

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.cpp

    r215196 r215592  
    4444#define PTR_SIZE 4
    4545#define PROBE_PROBE_FUNCTION_OFFSET (0 * PTR_SIZE)
    46 #define PROBE_ARG1_OFFSET (1 * PTR_SIZE)
    47 #define PROBE_ARG2_OFFSET (2 * PTR_SIZE)
    48 
    49 #define PROBE_FIRST_GPREG_OFFSET (3 * PTR_SIZE)
     46#define PROBE_ARG_OFFSET (1 * PTR_SIZE)
     47
     48#define PROBE_FIRST_GPREG_OFFSET (2 * PTR_SIZE)
    5049
    5150#define GPREG_SIZE 4
    … …  
    106105#define PROBE_CPU_D31_OFFSET (PROBE_FIRST_FPREG_OFFSET + (31 * FPREG_SIZE))
    107106#define PROBE_SIZE (PROBE_FIRST_FPREG_OFFSET + (32 * FPREG_SIZE))
     107#define PROBE_ALIGNED_SIZE (PROBE_SIZE)
    108108
    109109// These ASSERTs remind you that if you change the layout of ProbeContext,
    … …  
    111111#define PROBE_OFFSETOF(x) offsetof(struct ProbeContext, x)
    112112COMPILE_ASSERT(PROBE_OFFSETOF(probeFunction) == PROBE_PROBE_FUNCTION_OFFSET, ProbeContext_probeFunction_offset_matches_ctiMasmProbeTrampoline);
    113 COMPILE_ASSERT(PROBE_OFFSETOF(arg1) == PROBE_ARG1_OFFSET, ProbeContext_arg1_offset_matches_ctiMasmProbeTrampoline);
    114 COMPILE_ASSERT(PROBE_OFFSETOF(arg2) == PROBE_ARG2_OFFSET, ProbeContext_arg2_offset_matches_ctiMasmProbeTrampoline);
     113COMPILE_ASSERT(PROBE_OFFSETOF(arg) == PROBE_ARG_OFFSET, ProbeContext_arg_offset_matches_ctiMasmProbeTrampoline);
     114
     115COMPILE_ASSERT(!(PROBE_CPU_R0_OFFSET & 0x3), ProbeContext_cpu_r0_offset_should_be_4_byte_aligned);
    115116
    116117COMPILE_ASSERT(PROBE_OFFSETOF(cpu.r0) == PROBE_CPU_R0_OFFSET, ProbeContext_cpu_r0_offset_matches_ctiMasmProbeTrampoline);
    … …  
    134135COMPILE_ASSERT(PROBE_OFFSETOF(cpu.fpscr) == PROBE_CPU_FPSCR_OFFSET, ProbeContext_cpu_fpscr_offset_matches_ctiMasmProbeTrampoline);
    135136
     137COMPILE_ASSERT(!(PROBE_CPU_D0_OFFSET & 0xf), ProbeContext_cpu_d0_offset_should_be_16_byte_aligned);
     138
    136139COMPILE_ASSERT(PROBE_OFFSETOF(cpu.d0) == PROBE_CPU_D0_OFFSET, ProbeContext_cpu_d0_offset_matches_ctiMasmProbeTrampoline);
    137140COMPILE_ASSERT(PROBE_OFFSETOF(cpu.d1) == PROBE_CPU_D1_OFFSET, ProbeContext_cpu_d1_offset_matches_ctiMasmProbeTrampoline);
    … …  
    169172
    170173COMPILE_ASSERT(sizeof(ProbeContext) == PROBE_SIZE, ProbeContext_size_matches_ctiMasmProbeTrampoline);
     174COMPILE_ASSERT(!(PROBE_ALIGNED_SIZE & 0xf), ProbeContext_aligned_size_offset_should_be_16_byte_aligned);
    171175
    172176#undef PROBE_OFFSETOF
    … …  
    184188    // The top of stack now looks like this:
    185189    //     esp[0 * ptrSize]: probeFunction
    186     //     esp[1 * ptrSize]: arg1
    187     //     esp[2 * ptrSize]: arg2
    188     //     esp[3 * ptrSize]: saved r0
    189     //     esp[4 * ptrSize]: saved ip
    190     //     esp[5 * ptrSize]: saved lr
    191     //     esp[6 * ptrSize]: saved sp
     190    //     esp[1 * ptrSize]: arg
     191    //     esp[2 * ptrSize]: saved r0
     192    //     esp[3 * ptrSize]: saved ip
     193    //     esp[4 * ptrSize]: saved lr
     194    //     esp[5 * ptrSize]: saved sp
    192195
    193196    "mov       ip, sp" "\n"
    194197    "mov       r0, sp" "\n"
    195     "sub       r0, r0, #" STRINGIZE_VALUE_OF(PROBE_SIZE) "\n"
     198    "sub       r0, r0, #" STRINGIZE_VALUE_OF(PROBE_ALIGNED_SIZE) "\n"
    196199
    197200    // The ARM EABI specifies that the stack needs to be 16 byte aligned.
    … …  
    210213    "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_PROBE_FUNCTION_OFFSET) "]" "\n"
    211214    "ldr       lr, [ip, #1 * " STRINGIZE_VALUE_OF(PTR_SIZE) "]" "\n"
    212     "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_ARG1_OFFSET) "]" "\n"
     215    "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_ARG_OFFSET) "]" "\n"
    213216    "ldr       lr, [ip, #2 * " STRINGIZE_VALUE_OF(PTR_SIZE) "]" "\n"
    214     "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_ARG2_OFFSET) "]" "\n"
     217    "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_R0_OFFSET) "]" "\n"
    215218    "ldr       lr, [ip, #3 * " STRINGIZE_VALUE_OF(PTR_SIZE) "]" "\n"
    216     "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_R0_OFFSET) "]" "\n"
     219    "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_IP_OFFSET) "]" "\n"
    217220    "ldr       lr, [ip, #4 * " STRINGIZE_VALUE_OF(PTR_SIZE) "]" "\n"
    218     "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_IP_OFFSET) "]" "\n"
     221    "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_LR_OFFSET) "]" "\n"
    219222    "ldr       lr, [ip, #5 * " STRINGIZE_VALUE_OF(PTR_SIZE) "]" "\n"
    220     "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_LR_OFFSET) "]" "\n"
    221     "ldr       lr, [ip, #6 * " STRINGIZE_VALUE_OF(PTR_SIZE) "]" "\n"
    222223    "str       lr, [sp, #" STRINGIZE_VALUE_OF(PROBE_CPU_SP_OFFSET) "]" "\n"
    223224
    … …  
    325326#endif // COMPILER(GCC_OR_CLANG)
    326327
    327 void MacroAssemblerARMv7::probe(ProbeFunction function, void* arg1, void* arg2)
     328void MacroAssemblerARMv7::probe(ProbeFunction function, void* arg)
    328329{
    329330    push(RegisterID::lr);
    … …  
    334335    push(RegisterID::r0);
    335336    // The following uses RegisterID::ip. So, they must come after we push ip above.
    336     push(trustedImm32FromPtr(arg2));
    337     push(trustedImm32FromPtr(arg1));
     337    push(trustedImm32FromPtr(arg));
    338338    push(trustedImm32FromPtr(function));
    339339

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h

    r213652 r215592  
    20172017
    20182018#if ENABLE(MASM_PROBE)
    2019     void probe(ProbeFunction, void* arg1, void* arg2);
     2019    void probe(ProbeFunction, void* arg);
    20202020#endif // ENABLE(MASM_PROBE)
    20212021

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerPrinter.cpp

    r215196 r215592  
    176176    typedef PrintArg Arg;
    177177    PrintArgsList& argsList =
    178     *reinterpret_cast<PrintArgsList*>(context->arg1);
     178    *reinterpret_cast<PrintArgsList*>(context->arg);
    179179    for (size_t i = 0; i < argsList.size(); i++) {
    180180        auto& arg = argsList[i];

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerPrinter.h

    r215196 r215592  
    2626#pragma once
    2727
     28#include "MacroAssembler.h"
     29
     30namespace JSC {
     31
    2832#if ENABLE(MASM_PROBE)
    29 
    30 #include "MacroAssembler.h"
    31 
    32 namespace JSC {
    33 
     33   
    3434// What is MacroAssembler::print()?
    3535// ===============================
    … …  
    168168        auto argsList = std::make_unique<PrintArgsList>();
    169169        appendPrintArg(argsList.get(), args...);
    170         masm->probe(printCallback, argsList.release(), 0);
     170        masm->probe(printCallback, argsList.release());
    171171    }
    172172   
    … …  
    297297void printMemory(MacroAssembler::CPUState&, const Memory&);
    298298
     299#else // ENABLE(MASM_PROBE)
     300
     301template<typename... Arguments>
     302void MacroAssembler::print(Arguments...) { }
     303
     304#endif // ENABLE(MASM_PROBE)
     305
    299306} // namespace JSC
    300 
    301 #endif // ENABLE(MASM_PROBE)

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.cpp

    r215196 r215592  
    4848
    4949#define PROBE_PROBE_FUNCTION_OFFSET (0 * PTR_SIZE)
    50 #define PROBE_ARG1_OFFSET (1 * PTR_SIZE)
    51 #define PROBE_ARG2_OFFSET (2 * PTR_SIZE)
    52 
    53 #define PROBE_FIRST_GPR_OFFSET (3 * PTR_SIZE)
     50#define PROBE_ARG_OFFSET (1 * PTR_SIZE)
     51
     52#define PROBE_FIRST_GPR_OFFSET (2 * PTR_SIZE)
    5453#define PROBE_CPU_EAX_OFFSET (PROBE_FIRST_GPR_OFFSET + (0 * PTR_SIZE))
    5554#define PROBE_CPU_ECX_OFFSET (PROBE_FIRST_GPR_OFFSET + (1 * PTR_SIZE))
    … …  
    9190#if CPU(X86)
    9291#define PROBE_SIZE (PROBE_CPU_XMM7_OFFSET + XMM_SIZE)
     92#define PROBE_ALIGNED_SIZE (PROBE_SIZE + (2 * XMM_SIZE))
    9393#else // CPU(X86_64)
    9494#define PROBE_CPU_XMM8_OFFSET (PROBE_FIRST_XMM_OFFSET + (8 * XMM_SIZE))
    … …  
    101101#define PROBE_CPU_XMM15_OFFSET (PROBE_FIRST_XMM_OFFSET + (15 * XMM_SIZE))
    102102#define PROBE_SIZE (PROBE_CPU_XMM15_OFFSET + XMM_SIZE)
     103#define PROBE_ALIGNED_SIZE (PROBE_SIZE + (4 * XMM_SIZE))
    103104#endif // CPU(X86_64)
    104105
    … …  
    107108#define PROBE_OFFSETOF(x) offsetof(struct ProbeContext, x)
    108109COMPILE_ASSERT(PROBE_OFFSETOF(probeFunction) == PROBE_PROBE_FUNCTION_OFFSET, ProbeContext_probeFunction_offset_matches_ctiMasmProbeTrampoline);
    109 COMPILE_ASSERT(PROBE_OFFSETOF(arg1) == PROBE_ARG1_OFFSET, ProbeContext_arg1_offset_matches_ctiMasmProbeTrampoline);
    110 COMPILE_ASSERT(PROBE_OFFSETOF(arg2) == PROBE_ARG2_OFFSET, ProbeContext_arg2_offset_matches_ctiMasmProbeTrampoline);
     110COMPILE_ASSERT(PROBE_OFFSETOF(arg) == PROBE_ARG_OFFSET, ProbeContext_arg_offset_matches_ctiMasmProbeTrampoline);
    111111
    112112COMPILE_ASSERT(PROBE_OFFSETOF(cpu.eax) == PROBE_CPU_EAX_OFFSET, ProbeContext_cpu_eax_offset_matches_ctiMasmProbeTrampoline);
    … …  
    132132#endif // CPU(X86_64)
    133133
     134COMPILE_ASSERT(!(PROBE_CPU_XMM0_OFFSET & 0x7), ProbeContext_cpu_xmm0_offset_should_be_8_byte_aligned);
     135
    134136COMPILE_ASSERT(PROBE_OFFSETOF(cpu.xmm0) == PROBE_CPU_XMM0_OFFSET, ProbeContext_cpu_xmm0_offset_matches_ctiMasmProbeTrampoline);
    135137COMPILE_ASSERT(PROBE_OFFSETOF(cpu.xmm1) == PROBE_CPU_XMM1_OFFSET, ProbeContext_cpu_xmm1_offset_matches_ctiMasmProbeTrampoline);
    … …  
    153155
    154156COMPILE_ASSERT(sizeof(ProbeContext) == PROBE_SIZE, ProbeContext_size_matches_ctiMasmProbeTrampoline);
     157COMPILE_ASSERT(!(PROBE_ALIGNED_SIZE & 0x1f), ProbeContext_aligned_size_offset_should_be_32_byte_aligned);
    155158
    156159#undef PROBE_OFFSETOF
    … …  
    171174    //     esp[2 * ptrSize]: probeFunction
    172175    //     esp[3 * ptrSize]: arg1
    173     //     esp[4 * ptrSize]: arg2
    174     //     esp[5 * ptrSize]: saved eax
    175     //     esp[6 * ptrSize]: saved esp
     176    //     esp[4 * ptrSize]: saved eax
     177    //     esp[5 * ptrSize]: saved esp
    176178
    177179    "movl %esp, %eax" "\n"
    178     "subl $" STRINGIZE_VALUE_OF(PROBE_SIZE) ", %esp" "\n"
     180    "subl $" STRINGIZE_VALUE_OF(PROBE_ALIGNED_SIZE) ", %esp" "\n"
    179181
    180182    // The X86_64 ABI specifies that the worse case stack alignment requirement
    … …  
    198200    "movl %ecx, " STRINGIZE_VALUE_OF(PROBE_PROBE_FUNCTION_OFFSET) "(%ebp)" "\n"
    199201    "movl 3 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%eax), %ecx" "\n"
    200     "movl %ecx, " STRINGIZE_VALUE_OF(PROBE_ARG1_OFFSET) "(%ebp)" "\n"
     202    "movl %ecx, " STRINGIZE_VALUE_OF(PROBE_ARG_OFFSET) "(%ebp)" "\n"
    201203    "movl 4 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%eax), %ecx" "\n"
    202     "movl %ecx, " STRINGIZE_VALUE_OF(PROBE_ARG2_OFFSET) "(%ebp)" "\n"
     204    "movl %ecx, " STRINGIZE_VALUE_OF(PROBE_CPU_EAX_OFFSET) "(%ebp)" "\n"
    203205    "movl 5 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%eax), %ecx" "\n"
    204     "movl %ecx, " STRINGIZE_VALUE_OF(PROBE_CPU_EAX_OFFSET) "(%ebp)" "\n"
    205     "movl 6 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%eax), %ecx" "\n"
    206206    "movl %ecx, " STRINGIZE_VALUE_OF(PROBE_CPU_ESP_OFFSET) "(%ebp)" "\n"
    207207
    … …  
    264264    // Locate the "safe area" at 2x sizeof(ProbeContext) below where the new
    265265    // rsp will be. This time we don't have to 32-byte align it because we're
    266     // not using to store any xmm regs.
     266    // not using this area to store any xmm regs.
    267267    "movl " STRINGIZE_VALUE_OF(PROBE_CPU_ESP_OFFSET) "(%ebp), %eax" "\n"
    268     "subl $2 * " STRINGIZE_VALUE_OF(PROBE_SIZE) ", %eax" "\n"
     268    "subl $2 * " STRINGIZE_VALUE_OF(PROBE_ALIGNED_SIZE) ", %eax" "\n"
    269269    "movl %eax, %esp" "\n"
    270270
    … …  
    324324    //     esp[2 * ptrSize]: probeFunction
    325325    //     esp[3 * ptrSize]: arg1
    326     //     esp[4 * ptrSize]: arg2
    327     //     esp[5 * ptrSize]: saved rax
    328     //     esp[6 * ptrSize]: saved rsp
     326    //     esp[4 * ptrSize]: saved rax
     327    //     esp[5 * ptrSize]: saved rsp
    329328
    330329    "movq %rsp, %rax" "\n"
    331     "subq $" STRINGIZE_VALUE_OF(PROBE_SIZE) ", %rsp" "\n"
     330    "subq $" STRINGIZE_VALUE_OF(PROBE_ALIGNED_SIZE) ", %rsp" "\n"
    332331
    333332    // The X86_64 ABI specifies that the worse case stack alignment requirement
    … …  
    351350    "movq %rcx, " STRINGIZE_VALUE_OF(PROBE_PROBE_FUNCTION_OFFSET) "(%rbp)" "\n"
    352351    "movq 3 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%rax), %rcx" "\n"
    353     "movq %rcx, " STRINGIZE_VALUE_OF(PROBE_ARG1_OFFSET) "(%rbp)" "\n"
     352    "movq %rcx, " STRINGIZE_VALUE_OF(PROBE_ARG_OFFSET) "(%rbp)" "\n"
    354353    "movq 4 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%rax), %rcx" "\n"
    355     "movq %rcx, " STRINGIZE_VALUE_OF(PROBE_ARG2_OFFSET) "(%rbp)" "\n"
     354    "movq %rcx, " STRINGIZE_VALUE_OF(PROBE_CPU_EAX_OFFSET) "(%rbp)" "\n"
    356355    "movq 5 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%rax), %rcx" "\n"
    357     "movq %rcx, " STRINGIZE_VALUE_OF(PROBE_CPU_EAX_OFFSET) "(%rbp)" "\n"
    358     "movq 6 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%rax), %rcx" "\n"
    359356    "movq %rcx, " STRINGIZE_VALUE_OF(PROBE_CPU_ESP_OFFSET) "(%rbp)" "\n"
    360357
    … …  
    449446    // not using to store any xmm regs.
    450447    "movq " STRINGIZE_VALUE_OF(PROBE_CPU_ESP_OFFSET) "(%rbp), %rax" "\n"
    451     "subq $2 * " STRINGIZE_VALUE_OF(PROBE_SIZE) ", %rax" "\n"
     448    "subq $2 * " STRINGIZE_VALUE_OF(PROBE_ALIGNED_SIZE) ", %rax" "\n"
    452449    "movq %rax, %rsp" "\n"
    453450
    … …  
    532529// the address of the instruction immediately following the probe.
    533530
    534 void MacroAssemblerX86Common::probe(ProbeFunction function, void* arg1, void* arg2)
     531void MacroAssemblerX86Common::probe(ProbeFunction function, void* arg)
    535532{
    536533    push(RegisterID::esp);
    537534    push(RegisterID::eax);
    538     move(TrustedImmPtr(arg2), RegisterID::eax);
    539     push(RegisterID::eax);
    540     move(TrustedImmPtr(arg1), RegisterID::eax);
     535    move(TrustedImmPtr(arg), RegisterID::eax);
    541536    push(RegisterID::eax);
    542537    move(TrustedImmPtr(reinterpret_cast<void*>(function)), RegisterID::eax);

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h

    r215565 r215592  
    39523952
    39533953#if ENABLE(MASM_PROBE)
    3954     void probe(ProbeFunction, void* arg1, void* arg2);
     3954    void probe(ProbeFunction, void* arg);
    39553955#endif // ENABLE(MASM_PROBE)
    39563956
Note: See TracChangeset for help on using the changeset viewer.