Implement 64-bit MacroAssembler::probe support for Windows.
[WebKit-https.git] / Source / JavaScriptCore / assembler / MacroAssemblerX86Common.cpp
1 /*
2  * Copyright (C) 2013-2017 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(ASSEMBLER) && (CPU(X86) || CPU(X86_64))
29 #include "MacroAssembler.h"
30
31 #include "ProbeContext.h"
32 #include <wtf/InlineASM.h>
33
34 namespace JSC {
35
36 #if ENABLE(MASM_PROBE)
37
38 extern "C" void ctiMasmProbeTrampoline();
39
40 // The following are offsets for Probe::State fields accessed by the ctiMasmProbeTrampoline stub.
41
42 #if CPU(X86)
43 #define PTR_SIZE 4
44 #else // CPU(X86_64)
45 #define PTR_SIZE 8
46 #endif
47
48 #define PROBE_PROBE_FUNCTION_OFFSET (0 * PTR_SIZE)
49 #define PROBE_ARG_OFFSET (1 * PTR_SIZE)
50 #define PROBE_INIT_STACK_FUNCTION_OFFSET (2 * PTR_SIZE)
51 #define PROBE_INIT_STACK_ARG_OFFSET (3 * PTR_SIZE)
52
53 #define PROBE_FIRST_GPR_OFFSET (4 * PTR_SIZE)
54 #define PROBE_CPU_EAX_OFFSET (PROBE_FIRST_GPR_OFFSET + (0 * PTR_SIZE))
55 #define PROBE_CPU_ECX_OFFSET (PROBE_FIRST_GPR_OFFSET + (1 * PTR_SIZE))
56 #define PROBE_CPU_EDX_OFFSET (PROBE_FIRST_GPR_OFFSET + (2 * PTR_SIZE))
57 #define PROBE_CPU_EBX_OFFSET (PROBE_FIRST_GPR_OFFSET + (3 * PTR_SIZE))
58 #define PROBE_CPU_ESP_OFFSET (PROBE_FIRST_GPR_OFFSET + (4 * PTR_SIZE))
59 #define PROBE_CPU_EBP_OFFSET (PROBE_FIRST_GPR_OFFSET + (5 * PTR_SIZE))
60 #define PROBE_CPU_ESI_OFFSET (PROBE_FIRST_GPR_OFFSET + (6 * PTR_SIZE))
61 #define PROBE_CPU_EDI_OFFSET (PROBE_FIRST_GPR_OFFSET + (7 * PTR_SIZE))
62
63 #if CPU(X86)
64 #define PROBE_FIRST_SPR_OFFSET (PROBE_FIRST_GPR_OFFSET + (8 * PTR_SIZE))
65 #else // CPU(X86_64)
66 #define PROBE_CPU_R8_OFFSET (PROBE_FIRST_GPR_OFFSET + (8 * PTR_SIZE))
67 #define PROBE_CPU_R9_OFFSET (PROBE_FIRST_GPR_OFFSET + (9 * PTR_SIZE))
68 #define PROBE_CPU_R10_OFFSET (PROBE_FIRST_GPR_OFFSET + (10 * PTR_SIZE))
69 #define PROBE_CPU_R11_OFFSET (PROBE_FIRST_GPR_OFFSET + (11 * PTR_SIZE))
70 #define PROBE_CPU_R12_OFFSET (PROBE_FIRST_GPR_OFFSET + (12 * PTR_SIZE))
71 #define PROBE_CPU_R13_OFFSET (PROBE_FIRST_GPR_OFFSET + (13 * PTR_SIZE))
72 #define PROBE_CPU_R14_OFFSET (PROBE_FIRST_GPR_OFFSET + (14 * PTR_SIZE))
73 #define PROBE_CPU_R15_OFFSET (PROBE_FIRST_GPR_OFFSET + (15 * PTR_SIZE))
74 #define PROBE_FIRST_SPR_OFFSET (PROBE_FIRST_GPR_OFFSET + (16 * PTR_SIZE))
75 #endif // CPU(X86_64)
76
77 #define PROBE_CPU_EIP_OFFSET (PROBE_FIRST_SPR_OFFSET + (0 * PTR_SIZE))
78 #define PROBE_CPU_EFLAGS_OFFSET (PROBE_FIRST_SPR_OFFSET + (1 * PTR_SIZE))
79 #define PROBE_FIRST_XMM_OFFSET (PROBE_FIRST_SPR_OFFSET + (2 * PTR_SIZE))
80
81 #define XMM_SIZE 8
82 #define PROBE_CPU_XMM0_OFFSET (PROBE_FIRST_XMM_OFFSET + (0 * XMM_SIZE))
83 #define PROBE_CPU_XMM1_OFFSET (PROBE_FIRST_XMM_OFFSET + (1 * XMM_SIZE))
84 #define PROBE_CPU_XMM2_OFFSET (PROBE_FIRST_XMM_OFFSET + (2 * XMM_SIZE))
85 #define PROBE_CPU_XMM3_OFFSET (PROBE_FIRST_XMM_OFFSET + (3 * XMM_SIZE))
86 #define PROBE_CPU_XMM4_OFFSET (PROBE_FIRST_XMM_OFFSET + (4 * XMM_SIZE))
87 #define PROBE_CPU_XMM5_OFFSET (PROBE_FIRST_XMM_OFFSET + (5 * XMM_SIZE))
88 #define PROBE_CPU_XMM6_OFFSET (PROBE_FIRST_XMM_OFFSET + (6 * XMM_SIZE))
89 #define PROBE_CPU_XMM7_OFFSET (PROBE_FIRST_XMM_OFFSET + (7 * XMM_SIZE))
90
91 #if CPU(X86)
92 #define PROBE_SIZE (PROBE_CPU_XMM7_OFFSET + XMM_SIZE)
93 #else // CPU(X86_64)
94 #define PROBE_CPU_XMM8_OFFSET (PROBE_FIRST_XMM_OFFSET + (8 * XMM_SIZE))
95 #define PROBE_CPU_XMM9_OFFSET (PROBE_FIRST_XMM_OFFSET + (9 * XMM_SIZE))
96 #define PROBE_CPU_XMM10_OFFSET (PROBE_FIRST_XMM_OFFSET + (10 * XMM_SIZE))
97 #define PROBE_CPU_XMM11_OFFSET (PROBE_FIRST_XMM_OFFSET + (11 * XMM_SIZE))
98 #define PROBE_CPU_XMM12_OFFSET (PROBE_FIRST_XMM_OFFSET + (12 * XMM_SIZE))
99 #define PROBE_CPU_XMM13_OFFSET (PROBE_FIRST_XMM_OFFSET + (13 * XMM_SIZE))
100 #define PROBE_CPU_XMM14_OFFSET (PROBE_FIRST_XMM_OFFSET + (14 * XMM_SIZE))
101 #define PROBE_CPU_XMM15_OFFSET (PROBE_FIRST_XMM_OFFSET + (15 * XMM_SIZE))
102 #define PROBE_SIZE (PROBE_CPU_XMM15_OFFSET + XMM_SIZE)
103 #endif // CPU(X86_64)
104
105 #define PROBE_EXECUTOR_OFFSET PROBE_SIZE // Stash the executeProbe function pointer at the end of the ProbeContext.
106
107 // The outgoing record to be popped off the stack at the end consists of:
108 // eflags, eax, ecx, ebp, eip.
109 #define OUT_SIZE        (5 * PTR_SIZE)
110
111 // These ASSERTs remind you that if you change the layout of Probe::State,
112 // you need to change ctiMasmProbeTrampoline offsets above to match.
113 #define PROBE_OFFSETOF(x) offsetof(struct Probe::State, x)
114 #define PROBE_OFFSETOF_REG(x, reg) offsetof(struct Probe::State, x) + reg * sizeof((reinterpret_cast<Probe::State*>(0))->x[reg])
115 static_assert(PROBE_OFFSETOF(probeFunction) == PROBE_PROBE_FUNCTION_OFFSET, "Probe::State::probeFunction's offset matches ctiMasmProbeTrampoline");
116 static_assert(PROBE_OFFSETOF(arg) == PROBE_ARG_OFFSET, "Probe::State::arg's offset matches ctiMasmProbeTrampoline");
117 static_assert(PROBE_OFFSETOF(initializeStackFunction) == PROBE_INIT_STACK_FUNCTION_OFFSET, "Probe::State::initializeStackFunction's offset matches ctiMasmProbeTrampoline");
118 static_assert(PROBE_OFFSETOF(initializeStackArg) == PROBE_INIT_STACK_ARG_OFFSET, "Probe::State::initializeStackArg's offset matches ctiMasmProbeTrampoline");
119
120 static_assert(PROBE_OFFSETOF_REG(cpu.gprs, X86Registers::eax) == PROBE_CPU_EAX_OFFSET, "Probe::State::cpu.gprs[eax]'s offset matches ctiMasmProbeTrampoline");
121 static_assert(PROBE_OFFSETOF_REG(cpu.gprs, X86Registers::ecx) == PROBE_CPU_ECX_OFFSET, "Probe::State::cpu.gprs[ecx]'s offset matches ctiMasmProbeTrampoline");
122 static_assert(PROBE_OFFSETOF_REG(cpu.gprs, X86Registers::edx) == PROBE_CPU_EDX_OFFSET, "Probe::State::cpu.gprs[edx]'s offset matches ctiMasmProbeTrampoline");
123 static_assert(PROBE_OFFSETOF_REG(cpu.gprs, X86Registers::ebx) == PROBE_CPU_EBX_OFFSET, "Probe::State::cpu.gprs[ebx]'s offset matches ctiMasmProbeTrampoline");
124 static_assert(PROBE_OFFSETOF_REG(cpu.gprs, X86Registers::esp) == PROBE_CPU_ESP_OFFSET, "Probe::State::cpu.gprs[esp]'s offset matches ctiMasmProbeTrampoline");
125 static_assert(PROBE_OFFSETOF_REG(cpu.gprs, X86Registers::ebp) == PROBE_CPU_EBP_OFFSET, "Probe::State::cpu.gprs[ebp]'s offset matches ctiMasmProbeTrampoline");
126 static_assert(PROBE_OFFSETOF_REG(cpu.gprs, X86Registers::esi) == PROBE_CPU_ESI_OFFSET, "Probe::State::cpu.gprs[esi]'s offset matches ctiMasmProbeTrampoline");
127 static_assert(PROBE_OFFSETOF_REG(cpu.gprs, X86Registers::edi) == PROBE_CPU_EDI_OFFSET, "Probe::State::cpu.gprs[edi]'s offset matches ctiMasmProbeTrampoline");
128 static_assert(PROBE_OFFSETOF_REG(cpu.sprs, X86Registers::eip) == PROBE_CPU_EIP_OFFSET, "Probe::State::cpu.gprs[eip]'s offset matches ctiMasmProbeTrampoline");
129 static_assert(PROBE_OFFSETOF_REG(cpu.sprs, X86Registers::eflags) == PROBE_CPU_EFLAGS_OFFSET, "Probe::State::cpu.sprs[eflags]'s offset matches ctiMasmProbeTrampoline");
130
131 #if CPU(X86_64)
132 static_assert(PROBE_OFFSETOF_REG(cpu.gprs, X86Registers::r8) == PROBE_CPU_R8_OFFSET, "Probe::State::cpu.gprs[r8]'s offset matches ctiMasmProbeTrampoline");
133 static_assert(PROBE_OFFSETOF_REG(cpu.gprs, X86Registers::r9) == PROBE_CPU_R9_OFFSET, "Probe::State::cpu.gprs[r9]'s offset matches ctiMasmProbeTrampoline");
134 static_assert(PROBE_OFFSETOF_REG(cpu.gprs, X86Registers::r10) == PROBE_CPU_R10_OFFSET, "Probe::State::cpu.gprs[r10]'s offset matches ctiMasmProbeTrampoline");
135 static_assert(PROBE_OFFSETOF_REG(cpu.gprs, X86Registers::r11) == PROBE_CPU_R11_OFFSET, "Probe::State::cpu.gprs[r11]'s offset matches ctiMasmProbeTrampoline");
136 static_assert(PROBE_OFFSETOF_REG(cpu.gprs, X86Registers::r12) == PROBE_CPU_R12_OFFSET, "Probe::State::cpu.gprs[r12]'s offset matches ctiMasmProbeTrampoline");
137 static_assert(PROBE_OFFSETOF_REG(cpu.gprs, X86Registers::r13) == PROBE_CPU_R13_OFFSET, "Probe::State::cpu.gprs[r13]'s offset matches ctiMasmProbeTrampoline");
138 static_assert(PROBE_OFFSETOF_REG(cpu.gprs, X86Registers::r14) == PROBE_CPU_R14_OFFSET, "Probe::State::cpu.gprs[r14]'s offset matches ctiMasmProbeTrampoline");
139 static_assert(PROBE_OFFSETOF_REG(cpu.gprs, X86Registers::r15) == PROBE_CPU_R15_OFFSET, "Probe::State::cpu.gprs[r15]'s offset matches ctiMasmProbeTrampoline");
140 #endif // CPU(X86_64)
141
142 static_assert(!(PROBE_CPU_XMM0_OFFSET & 0x7), "Probe::State::cpu.fprs[xmm0]'s offset should be 8 byte aligned");
143
144 static_assert(PROBE_OFFSETOF_REG(cpu.fprs, X86Registers::xmm0) == PROBE_CPU_XMM0_OFFSET, "Probe::State::cpu.fprs[xmm0]'s offset matches ctiMasmProbeTrampoline");
145 static_assert(PROBE_OFFSETOF_REG(cpu.fprs, X86Registers::xmm1) == PROBE_CPU_XMM1_OFFSET, "Probe::State::cpu.fprs[xmm1]'s offset matches ctiMasmProbeTrampoline");
146 static_assert(PROBE_OFFSETOF_REG(cpu.fprs, X86Registers::xmm2) == PROBE_CPU_XMM2_OFFSET, "Probe::State::cpu.fprs[xmm2]'s offset matches ctiMasmProbeTrampoline");
147 static_assert(PROBE_OFFSETOF_REG(cpu.fprs, X86Registers::xmm3) == PROBE_CPU_XMM3_OFFSET, "Probe::State::cpu.fprs[xmm3]'s offset matches ctiMasmProbeTrampoline");
148 static_assert(PROBE_OFFSETOF_REG(cpu.fprs, X86Registers::xmm4) == PROBE_CPU_XMM4_OFFSET, "Probe::State::cpu.fprs[xmm4]'s offset matches ctiMasmProbeTrampoline");
149 static_assert(PROBE_OFFSETOF_REG(cpu.fprs, X86Registers::xmm5) == PROBE_CPU_XMM5_OFFSET, "Probe::State::cpu.fprs[xmm5]'s offset matches ctiMasmProbeTrampoline");
150 static_assert(PROBE_OFFSETOF_REG(cpu.fprs, X86Registers::xmm6) == PROBE_CPU_XMM6_OFFSET, "Probe::State::cpu.fprs[xmm6]'s offset matches ctiMasmProbeTrampoline");
151 static_assert(PROBE_OFFSETOF_REG(cpu.fprs, X86Registers::xmm7) == PROBE_CPU_XMM7_OFFSET, "Probe::State::cpu.fprs[xmm7]'s offset matches ctiMasmProbeTrampoline");
152
153 #if CPU(X86_64)
154 static_assert(PROBE_OFFSETOF_REG(cpu.fprs, X86Registers::xmm8) == PROBE_CPU_XMM8_OFFSET, "Probe::State::cpu.fprs[xmm8]'s offset matches ctiMasmProbeTrampoline");
155 static_assert(PROBE_OFFSETOF_REG(cpu.fprs, X86Registers::xmm9) == PROBE_CPU_XMM9_OFFSET, "Probe::State::cpu.fprs[xmm9]'s offset matches ctiMasmProbeTrampoline");
156 static_assert(PROBE_OFFSETOF_REG(cpu.fprs, X86Registers::xmm10) == PROBE_CPU_XMM10_OFFSET, "Probe::State::cpu.fprs[xmm10]'s offset matches ctiMasmProbeTrampoline");
157 static_assert(PROBE_OFFSETOF_REG(cpu.fprs, X86Registers::xmm11) == PROBE_CPU_XMM11_OFFSET, "Probe::State::cpu.fprs[xmm11]'s offset matches ctiMasmProbeTrampoline");
158 static_assert(PROBE_OFFSETOF_REG(cpu.fprs, X86Registers::xmm12) == PROBE_CPU_XMM12_OFFSET, "Probe::State::cpu.fprs[xmm12]'s offset matches ctiMasmProbeTrampoline");
159 static_assert(PROBE_OFFSETOF_REG(cpu.fprs, X86Registers::xmm13) == PROBE_CPU_XMM13_OFFSET, "Probe::State::cpu.fprs[xmm13]'s offset matches ctiMasmProbeTrampoline");
160 static_assert(PROBE_OFFSETOF_REG(cpu.fprs, X86Registers::xmm14) == PROBE_CPU_XMM14_OFFSET, "Probe::State::cpu.fprs[xmm14]'s offset matches ctiMasmProbeTrampoline");
161 static_assert(PROBE_OFFSETOF_REG(cpu.fprs, X86Registers::xmm15) == PROBE_CPU_XMM15_OFFSET, "Probe::State::cpu.fprs[xmm15]'s offset matches ctiMasmProbeTrampoline");
162 #endif // CPU(X86_64)
163
164 static_assert(sizeof(Probe::State) == PROBE_SIZE, "Probe::State::size's matches ctiMasmProbeTrampoline");
165 static_assert((PROBE_EXECUTOR_OFFSET + PTR_SIZE) <= (PROBE_SIZE + OUT_SIZE), "Must have room after ProbeContext to stash the probe handler");
166
167 #undef PROBE_OFFSETOF
168
169 #if CPU(X86)
170 #if COMPILER(GCC_OR_CLANG)
171 asm (
172     ".globl " SYMBOL_STRING(ctiMasmProbeTrampoline) "\n"
173     HIDE_SYMBOL(ctiMasmProbeTrampoline) "\n"
174     SYMBOL_STRING(ctiMasmProbeTrampoline) ":" "\n"
175
176     "pushfl" "\n"
177
178     // MacroAssemblerX86Common::probe() has already generated code to store some values.
179     // Together with the eflags pushed above, the top of stack now looks like
180     // this:
181     //     esp[0 * ptrSize]: eflags
182     //     esp[1 * ptrSize]: return address / saved eip
183     //     esp[2 * ptrSize]: saved ebx
184     //     esp[3 * ptrSize]: saved edx
185     //     esp[4 * ptrSize]: saved ecx
186     //     esp[5 * ptrSize]: saved eax
187     //
188     // Incoming registers contain:
189     //     ecx: Probe::executeProbe
190     //     edx: probe function
191     //     ebx: probe arg
192     //     eax: scratch (was ctiMasmProbeTrampoline)
193
194     "movl %esp, %eax" "\n"
195     "subl $" STRINGIZE_VALUE_OF(PROBE_SIZE + OUT_SIZE) ", %esp" "\n"
196
197     // The X86_64 ABI specifies that the worse case stack alignment requirement is 32 bytes.
198     "andl $~0x1f, %esp" "\n"
199
200     "movl %ebp, " STRINGIZE_VALUE_OF(PROBE_CPU_EBP_OFFSET) "(%esp)" "\n"
201     "movl %esp, %ebp" "\n" // Save the Probe::State*.
202
203     "movl %ecx, " STRINGIZE_VALUE_OF(PROBE_EXECUTOR_OFFSET) "(%ebp)" "\n"
204     "movl %edx, " STRINGIZE_VALUE_OF(PROBE_PROBE_FUNCTION_OFFSET) "(%ebp)" "\n"
205     "movl %ebx, " STRINGIZE_VALUE_OF(PROBE_ARG_OFFSET) "(%ebp)" "\n"
206     "movl %esi, " STRINGIZE_VALUE_OF(PROBE_CPU_ESI_OFFSET) "(%ebp)" "\n"
207     "movl %edi, " STRINGIZE_VALUE_OF(PROBE_CPU_EDI_OFFSET) "(%ebp)" "\n"
208
209     "movl 0 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%eax), %ecx" "\n"
210     "movl %ecx, " STRINGIZE_VALUE_OF(PROBE_CPU_EFLAGS_OFFSET) "(%ebp)" "\n"
211     "movl 1 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%eax), %ecx" "\n"
212     "movl %ecx, " STRINGIZE_VALUE_OF(PROBE_CPU_EIP_OFFSET) "(%ebp)" "\n"
213     "movl 2 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%eax), %ecx" "\n"
214     "movl %ecx, " STRINGIZE_VALUE_OF(PROBE_CPU_EBX_OFFSET) "(%ebp)" "\n"
215     "movl 3 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%eax), %ecx" "\n"
216     "movl %ecx, " STRINGIZE_VALUE_OF(PROBE_CPU_EDX_OFFSET) "(%ebp)" "\n"
217     "movl 4 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%eax), %ecx" "\n"
218     "movl %ecx, " STRINGIZE_VALUE_OF(PROBE_CPU_ECX_OFFSET) "(%ebp)" "\n"
219     "movl 5 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%eax), %ecx" "\n"
220     "movl %ecx, " STRINGIZE_VALUE_OF(PROBE_CPU_EAX_OFFSET) "(%ebp)" "\n"
221
222     "movl %eax, %ecx" "\n"
223     "addl $" STRINGIZE_VALUE_OF(6 * PTR_SIZE) ", %ecx" "\n"
224     "movl %ecx, " STRINGIZE_VALUE_OF(PROBE_CPU_ESP_OFFSET) "(%ebp)" "\n"
225
226     "movq %xmm0, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM0_OFFSET) "(%ebp)" "\n"
227     "movq %xmm1, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM1_OFFSET) "(%ebp)" "\n"
228     "movq %xmm2, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM2_OFFSET) "(%ebp)" "\n"
229     "movq %xmm3, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM3_OFFSET) "(%ebp)" "\n"
230     "movq %xmm4, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM4_OFFSET) "(%ebp)" "\n"
231     "movq %xmm5, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM5_OFFSET) "(%ebp)" "\n"
232     "movq %xmm6, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM6_OFFSET) "(%ebp)" "\n"
233     "movq %xmm7, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM7_OFFSET) "(%ebp)" "\n"
234
235     // Reserve stack space for the arg while maintaining the required stack
236     // pointer 32 byte alignment:
237     "subl $0x20, %esp" "\n"
238     "movl %ebp, 0(%esp)" "\n" // the Probe::State* arg.
239
240     "call *" STRINGIZE_VALUE_OF(PROBE_EXECUTOR_OFFSET) "(%ebp)" "\n"
241
242     // Make sure the Probe::State is entirely below the result stack pointer so
243     // that register values are still preserved when we call the initializeStack
244     // function.
245     "movl $" STRINGIZE_VALUE_OF(PROBE_SIZE + OUT_SIZE) ", %ecx" "\n"
246     "movl %ebp, %eax" "\n"
247     "movl " STRINGIZE_VALUE_OF(PROBE_CPU_ESP_OFFSET) "(%ebp), %edx" "\n"
248     "addl %ecx, %eax" "\n"
249     "cmpl %eax, %edx" "\n"
250     "jge " LOCAL_LABEL_STRING(ctiMasmProbeTrampolineProbeStateIsSafe) "\n"
251
252     // Allocate a safe place on the stack below the result stack pointer to stash the Probe::State.
253     "subl %ecx, %edx" "\n"
254     "andl $~0x1f, %edx" "\n" // Keep the stack pointer 32 bytes aligned.
255     "xorl %eax, %eax" "\n"
256     "movl %edx, %esp" "\n"
257
258     "movl $" STRINGIZE_VALUE_OF(PROBE_SIZE) ", %ecx" "\n"
259
260     // Copy the Probe::State to the safe place.
261     LOCAL_LABEL_STRING(ctiMasmProbeTrampolineCopyLoop) ":" "\n"
262     "movl (%ebp, %eax), %edx" "\n"
263     "movl %edx, (%esp, %eax)" "\n"
264     "addl $" STRINGIZE_VALUE_OF(PTR_SIZE) ", %eax" "\n"
265     "cmpl %eax, %ecx" "\n"
266     "jg " LOCAL_LABEL_STRING(ctiMasmProbeTrampolineCopyLoop) "\n"
267
268     "movl %esp, %ebp" "\n"
269
270     // Call initializeStackFunction if present.
271     LOCAL_LABEL_STRING(ctiMasmProbeTrampolineProbeStateIsSafe) ":" "\n"
272     "xorl %ecx, %ecx" "\n"
273     "addl " STRINGIZE_VALUE_OF(PROBE_INIT_STACK_FUNCTION_OFFSET) "(%ebp), %ecx" "\n"
274     "je " LOCAL_LABEL_STRING(ctiMasmProbeTrampolineRestoreRegisters) "\n"
275
276     // Reserve stack space for the arg while maintaining the required stack
277     // pointer 32 byte alignment:
278     "subl $0x20, %esp" "\n"
279     "movl %ebp, 0(%esp)" "\n" // the Probe::State* arg.
280     "call *%ecx" "\n"
281
282     LOCAL_LABEL_STRING(ctiMasmProbeTrampolineRestoreRegisters) ":" "\n"
283
284     // To enable probes to modify register state, we copy all registers
285     // out of the Probe::State before returning.
286
287     "movl " STRINGIZE_VALUE_OF(PROBE_CPU_EDX_OFFSET) "(%ebp), %edx" "\n"
288     "movl " STRINGIZE_VALUE_OF(PROBE_CPU_EBX_OFFSET) "(%ebp), %ebx" "\n"
289     "movl " STRINGIZE_VALUE_OF(PROBE_CPU_ESI_OFFSET) "(%ebp), %esi" "\n"
290     "movl " STRINGIZE_VALUE_OF(PROBE_CPU_EDI_OFFSET) "(%ebp), %edi" "\n"
291
292     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM0_OFFSET) "(%ebp), %xmm0" "\n"
293     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM1_OFFSET) "(%ebp), %xmm1" "\n"
294     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM2_OFFSET) "(%ebp), %xmm2" "\n"
295     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM3_OFFSET) "(%ebp), %xmm3" "\n"
296     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM4_OFFSET) "(%ebp), %xmm4" "\n"
297     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM5_OFFSET) "(%ebp), %xmm5" "\n"
298     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM6_OFFSET) "(%ebp), %xmm6" "\n"
299     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM7_OFFSET) "(%ebp), %xmm7" "\n"
300
301     // There are 6 more registers left to restore:
302     //     eax, ecx, ebp, esp, eip, and eflags.
303
304     // The restoration process at ctiMasmProbeTrampolineEnd below works by popping
305     // 5 words off the stack into eflags, eax, ecx, ebp, and eip. These 5 words need
306     // to be pushed on top of the final esp value so that just by popping the 5 words,
307     // we'll get the esp that the probe wants to set. Let's call this area (for storing
308     // these 5 words) the restore area.
309     "movl " STRINGIZE_VALUE_OF(PROBE_CPU_ESP_OFFSET) "(%ebp), %ecx" "\n"
310     "subl $5 * " STRINGIZE_VALUE_OF(PTR_SIZE) ", %ecx" "\n"
311
312     // ecx now points to the restore area.
313
314     // Copy remaining restore values from the Probe::State to the restore area.
315     // Note: We already ensured above that the Probe::State is in a safe location before
316     // calling the initializeStackFunction. The initializeStackFunction is not allowed to
317     // change the stack pointer again.
318     "movl " STRINGIZE_VALUE_OF(PROBE_CPU_EFLAGS_OFFSET) "(%ebp), %eax" "\n"
319     "movl %eax, 0 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%ecx)" "\n"
320     "movl " STRINGIZE_VALUE_OF(PROBE_CPU_EAX_OFFSET) "(%ebp), %eax" "\n"
321     "movl %eax, 1 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%ecx)" "\n"
322     "movl " STRINGIZE_VALUE_OF(PROBE_CPU_ECX_OFFSET) "(%ebp), %eax" "\n"
323     "movl %eax, 2 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%ecx)" "\n"
324     "movl " STRINGIZE_VALUE_OF(PROBE_CPU_EBP_OFFSET) "(%ebp), %eax" "\n"
325     "movl %eax, 3 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%ecx)" "\n"
326     "movl " STRINGIZE_VALUE_OF(PROBE_CPU_EIP_OFFSET) "(%ebp), %eax" "\n"
327     "movl %eax, 4 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%ecx)" "\n"
328     "movl %ecx, %esp" "\n"
329
330     // Do the remaining restoration by popping off the restore area.
331     "popfl" "\n"
332     "popl %eax" "\n"
333     "popl %ecx" "\n"
334     "popl %ebp" "\n"
335     "ret" "\n"
336 );
337 #endif
338
339 #if COMPILER(MSVC)
340 extern "C" __declspec(naked) void ctiMasmProbeTrampoline()
341 {
342     __asm {
343         pushfd;
344
345         // MacroAssemblerX86Common::probe() has already generated code to store some values.
346         // Together with the eflags pushed above, the top of stack now looks like
347         // this:
348         //     esp[0 * ptrSize]: eflags
349         //     esp[1 * ptrSize]: return address / saved eip
350         //     esp[2 * ptrSize]: saved ebx
351         //     esp[3 * ptrSize]: saved edx
352         //     esp[4 * ptrSize]: saved ecx
353         //     esp[5 * ptrSize]: saved eax
354         //
355         // Incoming registers contain:
356         //     ecx: Probe::executeProbe
357         //     edx: probe function
358         //     ebx: probe arg
359         //     eax: scratch (was ctiMasmProbeTrampoline)
360
361         mov eax, esp
362         sub esp, PROBE_SIZE + OUT_SIZE
363
364         // The X86_64 ABI specifies that the worse case stack alignment requirement is 32 bytes.
365         and esp, ~0x1f
366
367         mov [PROBE_CPU_EBP_OFFSET + esp], ebp
368         mov ebp, esp // Save the ProbeContext*.
369
370         mov [PROBE_EXECUTOR_OFFSET + ebp], ecx
371         mov [PROBE_PROBE_FUNCTION_OFFSET + ebp], edx
372         mov [PROBE_ARG_OFFSET + ebp], ebx
373         mov [PROBE_CPU_ESI_OFFSET + ebp], esi
374         mov [PROBE_CPU_EDI_OFFSET + ebp], edi
375
376         mov ecx, [0 * PTR_SIZE + eax]
377         mov [PROBE_CPU_EFLAGS_OFFSET + ebp], ecx
378         mov ecx, [1 * PTR_SIZE + eax]
379         mov [PROBE_CPU_EIP_OFFSET + ebp], ecx
380         mov ecx, [2 * PTR_SIZE + eax]
381         mov [PROBE_CPU_EBX_OFFSET + ebp], ecx
382         mov ecx, [3 * PTR_SIZE + eax]
383         mov [PROBE_CPU_EDX_OFFSET + ebp], ecx
384         mov ecx, [4 * PTR_SIZE + eax]
385         mov [PROBE_CPU_ECX_OFFSET + ebp], ecx
386         mov ecx, [5 * PTR_SIZE + eax]
387         mov [PROBE_CPU_EAX_OFFSET + ebp], ecx
388
389         mov ecx, eax
390         add ecx, 6 * PTR_SIZE
391         mov [PROBE_CPU_ESP_OFFSET + ebp], ecx
392
393         movq qword ptr[PROBE_CPU_XMM0_OFFSET + ebp], xmm0
394         movq qword ptr[PROBE_CPU_XMM1_OFFSET + ebp], xmm1
395         movq qword ptr[PROBE_CPU_XMM2_OFFSET + ebp], xmm2
396         movq qword ptr[PROBE_CPU_XMM3_OFFSET + ebp], xmm3
397         movq qword ptr[PROBE_CPU_XMM4_OFFSET + ebp], xmm4
398         movq qword ptr[PROBE_CPU_XMM5_OFFSET + ebp], xmm5
399         movq qword ptr[PROBE_CPU_XMM6_OFFSET + ebp], xmm6
400         movq qword ptr[PROBE_CPU_XMM7_OFFSET + ebp], xmm7
401
402         // Reserve stack space for the arg while maintaining the required stack
403         // pointer 32 byte alignment:
404         sub esp, 0x20
405         mov [0 + esp], ebp // the ProbeContext* arg.
406
407         call [PROBE_EXECUTOR_OFFSET + ebp]
408
409         // Make sure the ProbeContext is entirely below the result stack pointer so
410         // that register values are still preserved when we call the initializeStack
411         // function.
412         mov ecx, PROBE_SIZE + OUT_SIZE
413         mov eax, ebp
414         mov edx, [PROBE_CPU_ESP_OFFSET + ebp]
415         add eax, ecx
416         cmp edx, eax
417         jge ctiMasmProbeTrampolineProbeContextIsSafe
418
419         // Allocate a safe place on the stack below the result stack pointer to stash the ProbeContext.
420         sub edx, ecx
421         and edx, ~0x1f // Keep the stack pointer 32 bytes aligned.
422         xor eax, eax
423         mov esp, edx
424
425         mov ecx, PROBE_SIZE
426
427         // Copy the ProbeContext to the safe place.
428         ctiMasmProbeTrampolineCopyLoop :
429         mov edx, [ebp + eax]
430         mov [esp + eax], edx
431         add eax, PTR_SIZE
432         cmp ecx, eax
433         jg ctiMasmProbeTrampolineCopyLoop
434
435         mov ebp, esp
436
437         // Call initializeStackFunction if present.
438         ctiMasmProbeTrampolineProbeContextIsSafe :
439         xor ecx, ecx
440         add ecx, [PROBE_INIT_STACK_FUNCTION_OFFSET + ebp]
441         je ctiMasmProbeTrampolineRestoreRegisters
442
443         // Reserve stack space for the arg while maintaining the required stack
444         // pointer 32 byte alignment:
445         sub esp, 0x20
446         mov [0 + esp], ebp // the ProbeContext* arg.
447         call ecx
448
449         ctiMasmProbeTrampolineRestoreRegisters :
450
451         // To enable probes to modify register state, we copy all registers
452         // out of the ProbeContext before returning.
453
454         mov edx, [PROBE_CPU_EDX_OFFSET + ebp]
455         mov ebx, [PROBE_CPU_EBX_OFFSET + ebp]
456         mov esi, [PROBE_CPU_ESI_OFFSET + ebp]
457         mov edi, [PROBE_CPU_EDI_OFFSET + ebp]
458
459         movq xmm0, qword ptr[PROBE_CPU_XMM0_OFFSET + ebp]
460         movq xmm1, qword ptr[PROBE_CPU_XMM1_OFFSET + ebp]
461         movq xmm2, qword ptr[PROBE_CPU_XMM2_OFFSET + ebp]
462         movq xmm3, qword ptr[PROBE_CPU_XMM3_OFFSET + ebp]
463         movq xmm4, qword ptr[PROBE_CPU_XMM4_OFFSET + ebp]
464         movq xmm5, qword ptr[PROBE_CPU_XMM5_OFFSET + ebp]
465         movq xmm6, qword ptr[PROBE_CPU_XMM6_OFFSET + ebp]
466         movq xmm7, qword ptr[PROBE_CPU_XMM7_OFFSET + ebp]
467
468         // There are 6 more registers left to restore:
469         //     eax, ecx, ebp, esp, eip, and eflags.
470
471         // The restoration process at ctiMasmProbeTrampolineEnd below works by popping
472         // 5 words off the stack into eflags, eax, ecx, ebp, and eip. These 5 words need
473         // to be pushed on top of the final esp value so that just by popping the 5 words,
474         // we'll get the esp that the probe wants to set. Let's call this area (for storing
475         // these 5 words) the restore area.
476         mov ecx, [PROBE_CPU_ESP_OFFSET + ebp]
477         sub ecx, 5 * PTR_SIZE
478
479         // ecx now points to the restore area.
480
481         // Copy remaining restore values from the ProbeContext to the restore area.
482         // Note: We already ensured above that the ProbeContext is in a safe location before
483         // calling the initializeStackFunction. The initializeStackFunction is not allowed to
484         // change the stack pointer again.
485         mov eax, [PROBE_CPU_EFLAGS_OFFSET + ebp]
486         mov [0 * PTR_SIZE + ecx], eax
487         mov eax, [PROBE_CPU_EAX_OFFSET + ebp]
488         mov [1 * PTR_SIZE + ecx], eax
489         mov eax, [PROBE_CPU_ECX_OFFSET + ebp]
490         mov [2 * PTR_SIZE + ecx], eax
491         mov eax, [PROBE_CPU_EBP_OFFSET + ebp]
492         mov [3 * PTR_SIZE + ecx], eax
493         mov eax, [PROBE_CPU_EIP_OFFSET + ebp]
494         mov [4 * PTR_SIZE + ecx], eax
495         mov esp, ecx
496
497         // Do the remaining restoration by popping off the restore area.
498         popfd
499         pop eax
500         pop ecx
501         pop ebp
502         ret
503     }
504 }
505 #endif // COMPILER(MSVC)
506
507 #endif // CPU(X86)
508
509 #if CPU(X86_64)
510 #if COMPILER(GCC_OR_CLANG)
511 asm (
512     ".globl " SYMBOL_STRING(ctiMasmProbeTrampoline) "\n"
513     HIDE_SYMBOL(ctiMasmProbeTrampoline) "\n"
514     SYMBOL_STRING(ctiMasmProbeTrampoline) ":" "\n"
515
516     "pushfq" "\n"
517
518     // MacroAssemblerX86Common::probe() has already generated code to store some values.
519     // Together with the rflags pushed above, the top of stack now looks like this:
520     //     rsp[0 * ptrSize]: rflags
521     //     rsp[1 * ptrSize]: return address / saved rip
522     //     rsp[2 * ptrSize]: saved rbx
523     //     rsp[3 * ptrSize]: saved rdx
524     //     rsp[4 * ptrSize]: saved rcx
525     //     rsp[5 * ptrSize]: saved rax
526     //
527     // Incoming registers contain:
528     //     rcx: Probe::executeProbe
529     //     rdx: probe function
530     //     rbx: probe arg
531     //     rax: scratch (was ctiMasmProbeTrampoline)
532
533     "movq %rsp, %rax" "\n"
534     "subq $" STRINGIZE_VALUE_OF(PROBE_SIZE + OUT_SIZE) ", %rsp" "\n"
535
536     // The X86_64 ABI specifies that the worse case stack alignment requirement is 32 bytes.
537     "andq $~0x1f, %rsp" "\n"
538     // Since sp points to the Probe::State, we've ensured that it's protected from interrupts before we initialize it.
539
540     "movq %rbp, " STRINGIZE_VALUE_OF(PROBE_CPU_EBP_OFFSET) "(%rsp)" "\n"
541     "movq %rsp, %rbp" "\n" // Save the Probe::State*.
542
543     "movq %rcx, " STRINGIZE_VALUE_OF(PROBE_EXECUTOR_OFFSET) "(%rbp)" "\n"
544     "movq %rdx, " STRINGIZE_VALUE_OF(PROBE_PROBE_FUNCTION_OFFSET) "(%rbp)" "\n"
545     "movq %rbx, " STRINGIZE_VALUE_OF(PROBE_ARG_OFFSET) "(%rbp)" "\n"
546     "movq %rsi, " STRINGIZE_VALUE_OF(PROBE_CPU_ESI_OFFSET) "(%rbp)" "\n"
547     "movq %rdi, " STRINGIZE_VALUE_OF(PROBE_CPU_EDI_OFFSET) "(%rbp)" "\n"
548
549     "movq 0 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%rax), %rcx" "\n"
550     "movq %rcx, " STRINGIZE_VALUE_OF(PROBE_CPU_EFLAGS_OFFSET) "(%rbp)" "\n"
551     "movq 1 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%rax), %rcx" "\n"
552     "movq %rcx, " STRINGIZE_VALUE_OF(PROBE_CPU_EIP_OFFSET) "(%rbp)" "\n"
553     "movq 2 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%rax), %rcx" "\n"
554     "movq %rcx, " STRINGIZE_VALUE_OF(PROBE_CPU_EBX_OFFSET) "(%rbp)" "\n"
555     "movq 3 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%rax), %rcx" "\n"
556     "movq %rcx, " STRINGIZE_VALUE_OF(PROBE_CPU_EDX_OFFSET) "(%rbp)" "\n"
557     "movq 4 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%rax), %rcx" "\n"
558     "movq %rcx, " STRINGIZE_VALUE_OF(PROBE_CPU_ECX_OFFSET) "(%rbp)" "\n"
559     "movq 5 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%rax), %rcx" "\n"
560     "movq %rcx, " STRINGIZE_VALUE_OF(PROBE_CPU_EAX_OFFSET) "(%rbp)" "\n"
561
562     "movq %rax, %rcx" "\n"
563     "addq $" STRINGIZE_VALUE_OF(6 * PTR_SIZE) ", %rcx" "\n"
564     "movq %rcx, " STRINGIZE_VALUE_OF(PROBE_CPU_ESP_OFFSET) "(%rbp)" "\n"
565
566     "movq %r8, " STRINGIZE_VALUE_OF(PROBE_CPU_R8_OFFSET) "(%rbp)" "\n"
567     "movq %r9, " STRINGIZE_VALUE_OF(PROBE_CPU_R9_OFFSET) "(%rbp)" "\n"
568     "movq %r10, " STRINGIZE_VALUE_OF(PROBE_CPU_R10_OFFSET) "(%rbp)" "\n"
569     "movq %r11, " STRINGIZE_VALUE_OF(PROBE_CPU_R11_OFFSET) "(%rbp)" "\n"
570     "movq %r12, " STRINGIZE_VALUE_OF(PROBE_CPU_R12_OFFSET) "(%rbp)" "\n"
571     "movq %r13, " STRINGIZE_VALUE_OF(PROBE_CPU_R13_OFFSET) "(%rbp)" "\n"
572     "movq %r14, " STRINGIZE_VALUE_OF(PROBE_CPU_R14_OFFSET) "(%rbp)" "\n"
573     "movq %r15, " STRINGIZE_VALUE_OF(PROBE_CPU_R15_OFFSET) "(%rbp)" "\n"
574
575     "movq %xmm0, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM0_OFFSET) "(%rbp)" "\n"
576     "movq %xmm1, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM1_OFFSET) "(%rbp)" "\n"
577     "movq %xmm2, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM2_OFFSET) "(%rbp)" "\n"
578     "movq %xmm3, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM3_OFFSET) "(%rbp)" "\n"
579     "movq %xmm4, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM4_OFFSET) "(%rbp)" "\n"
580     "movq %xmm5, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM5_OFFSET) "(%rbp)" "\n"
581     "movq %xmm6, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM6_OFFSET) "(%rbp)" "\n"
582     "movq %xmm7, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM7_OFFSET) "(%rbp)" "\n"
583     "movq %xmm8, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM8_OFFSET) "(%rbp)" "\n"
584     "movq %xmm9, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM9_OFFSET) "(%rbp)" "\n"
585     "movq %xmm10, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM10_OFFSET) "(%rbp)" "\n"
586     "movq %xmm11, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM11_OFFSET) "(%rbp)" "\n"
587     "movq %xmm12, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM12_OFFSET) "(%rbp)" "\n"
588     "movq %xmm13, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM13_OFFSET) "(%rbp)" "\n"
589     "movq %xmm14, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM14_OFFSET) "(%rbp)" "\n"
590     "movq %xmm15, " STRINGIZE_VALUE_OF(PROBE_CPU_XMM15_OFFSET) "(%rbp)" "\n"
591
592     "movq %rbp, %rdi" "\n" // the Probe::State* arg.
593     "call *" STRINGIZE_VALUE_OF(PROBE_EXECUTOR_OFFSET) "(%rbp)" "\n"
594
595     // Make sure the Probe::State is entirely below the result stack pointer so
596     // that register values are still preserved when we call the initializeStack
597     // function.
598     "movq $" STRINGIZE_VALUE_OF(PROBE_SIZE + OUT_SIZE) ", %rcx" "\n"
599     "movq %rbp, %rax" "\n"
600     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_ESP_OFFSET) "(%rbp), %rdx" "\n"
601     "addq %rcx, %rax" "\n"
602     "cmpq %rax, %rdx" "\n"
603     "jge " LOCAL_LABEL_STRING(ctiMasmProbeTrampolineProbeStateIsSafe) "\n"
604
605     // Allocate a safe place on the stack below the result stack pointer to stash the Probe::State.
606     "subq %rcx, %rdx" "\n"
607     "andq $~0x1f, %rdx" "\n" // Keep the stack pointer 32 bytes aligned.
608     "xorq %rax, %rax" "\n"
609     "movq %rdx, %rsp" "\n"
610
611     "movq $" STRINGIZE_VALUE_OF(PROBE_SIZE) ", %rcx" "\n"
612
613     // Copy the Probe::State to the safe place.
614     LOCAL_LABEL_STRING(ctiMasmProbeTrampolineCopyLoop) ":" "\n"
615     "movq (%rbp, %rax), %rdx" "\n"
616     "movq %rdx, (%rsp, %rax)" "\n"
617     "addq $" STRINGIZE_VALUE_OF(PTR_SIZE) ", %rax" "\n"
618     "cmpq %rax, %rcx" "\n"
619     "jg " LOCAL_LABEL_STRING(ctiMasmProbeTrampolineCopyLoop) "\n"
620
621     "movq %rsp, %rbp" "\n"
622
623     // Call initializeStackFunction if present.
624     LOCAL_LABEL_STRING(ctiMasmProbeTrampolineProbeStateIsSafe) ":" "\n"
625     "xorq %rcx, %rcx" "\n"
626     "addq " STRINGIZE_VALUE_OF(PROBE_INIT_STACK_FUNCTION_OFFSET) "(%rbp), %rcx" "\n"
627     "je " LOCAL_LABEL_STRING(ctiMasmProbeTrampolineRestoreRegisters) "\n"
628
629     "movq %rbp, %rdi" "\n" // the Probe::State* arg.
630     "call *%rcx" "\n"
631
632     LOCAL_LABEL_STRING(ctiMasmProbeTrampolineRestoreRegisters) ":" "\n"
633
634     // To enable probes to modify register state, we copy all registers
635     // out of the Probe::State before returning.
636
637     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_EDX_OFFSET) "(%rbp), %rdx" "\n"
638     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_EBX_OFFSET) "(%rbp), %rbx" "\n"
639     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_ESI_OFFSET) "(%rbp), %rsi" "\n"
640     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_EDI_OFFSET) "(%rbp), %rdi" "\n"
641
642     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_R8_OFFSET) "(%rbp), %r8" "\n"
643     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_R9_OFFSET) "(%rbp), %r9" "\n"
644     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_R10_OFFSET) "(%rbp), %r10" "\n"
645     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_R11_OFFSET) "(%rbp), %r11" "\n"
646     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_R12_OFFSET) "(%rbp), %r12" "\n"
647     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_R13_OFFSET) "(%rbp), %r13" "\n"
648     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_R14_OFFSET) "(%rbp), %r14" "\n"
649     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_R15_OFFSET) "(%rbp), %r15" "\n"
650
651     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM0_OFFSET) "(%rbp), %xmm0" "\n"
652     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM1_OFFSET) "(%rbp), %xmm1" "\n"
653     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM2_OFFSET) "(%rbp), %xmm2" "\n"
654     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM3_OFFSET) "(%rbp), %xmm3" "\n"
655     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM4_OFFSET) "(%rbp), %xmm4" "\n"
656     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM5_OFFSET) "(%rbp), %xmm5" "\n"
657     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM6_OFFSET) "(%rbp), %xmm6" "\n"
658     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM7_OFFSET) "(%rbp), %xmm7" "\n"
659     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM8_OFFSET) "(%rbp), %xmm8" "\n"
660     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM9_OFFSET) "(%rbp), %xmm9" "\n"
661     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM10_OFFSET) "(%rbp), %xmm10" "\n"
662     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM11_OFFSET) "(%rbp), %xmm11" "\n"
663     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM12_OFFSET) "(%rbp), %xmm12" "\n"
664     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM13_OFFSET) "(%rbp), %xmm13" "\n"
665     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM14_OFFSET) "(%rbp), %xmm14" "\n"
666     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_XMM15_OFFSET) "(%rbp), %xmm15" "\n"
667
668     // There are 6 more registers left to restore:
669     //     rax, rcx, rbp, rsp, rip, and rflags.
670
671     // The restoration process at ctiMasmProbeTrampolineEnd below works by popping
672     // 5 words off the stack into rflags, rax, rcx, rbp, and rip. These 5 words need
673     // to be pushed on top of the final esp value so that just by popping the 5 words,
674     // we'll get the esp that the probe wants to set. Let's call this area (for storing
675     // these 5 words) the restore area.
676     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_ESP_OFFSET) "(%rbp), %rcx" "\n"
677     "subq $5 * " STRINGIZE_VALUE_OF(PTR_SIZE) ", %rcx" "\n"
678
679     // rcx now points to the restore area.
680
681     // Copy remaining restore values from the Probe::State to the restore area.
682     // Note: We already ensured above that the Probe::State is in a safe location before
683     // calling the initializeStackFunction. The initializeStackFunction is not allowed to
684     // change the stack pointer again.
685     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_EFLAGS_OFFSET) "(%rbp), %rax" "\n"
686     "movq %rax, 0 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%rcx)" "\n"
687     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_EAX_OFFSET) "(%rbp), %rax" "\n"
688     "movq %rax, 1 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%rcx)" "\n"
689     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_ECX_OFFSET) "(%rbp), %rax" "\n"
690     "movq %rax, 2 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%rcx)" "\n"
691     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_EBP_OFFSET) "(%rbp), %rax" "\n"
692     "movq %rax, 3 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%rcx)" "\n"
693     "movq " STRINGIZE_VALUE_OF(PROBE_CPU_EIP_OFFSET) "(%rbp), %rax" "\n"
694     "movq %rax, 4 * " STRINGIZE_VALUE_OF(PTR_SIZE) "(%rcx)" "\n"
695     "movq %rcx, %rsp" "\n"
696
697     // Do the remaining restoration by popping off the restore area.
698     "popfq" "\n"
699     "popq %rax" "\n"
700     "popq %rcx" "\n"
701     "popq %rbp" "\n"
702     "ret" "\n"
703 );
704 #endif // COMPILER(GCC_OR_CLANG)
705 #endif // CPU(X86_64)
706
707 // What code is emitted for the probe?
708 // ==================================
709 // We want to keep the size of the emitted probe invocation code as compact as
710 // possible to minimize the perturbation to the JIT generated code. However,
711 // we also need to preserve the CPU registers and set up the Probe::State to be
712 // passed to the user probe function.
713 //
714 // Hence, we do only the minimum here to preserve a scratch register (i.e. rax
715 // in this case) and the stack pointer (i.e. rsp), and pass the probe arguments.
716 // We'll let the ctiMasmProbeTrampoline handle the rest of the probe invocation
717 // work i.e. saving the CPUState (and setting up the Probe::State), calling the
718 // user probe function, and restoring the CPUState before returning to JIT
719 // generated code.
720 //
721 // What registers need to be saved?
722 // ===============================
723 // The registers are saved for 2 reasons:
724 // 1. To preserve their state in the JITted code. This means that all registers
725 //    that are not callee saved needs to be saved. We also need to save the
726 //    condition code registers because the probe can be inserted between a test
727 //    and a branch.
728 // 2. To allow the probe to inspect the values of the registers for debugging
729 //    purposes. This means all registers need to be saved.
730 //
731 // In summary, save everything. But for reasons stated above, we should do the
732 // minimum here and let ctiMasmProbeTrampoline do the heavy lifting to save the
733 // full set.
734 //
735 // What values are in the saved registers?
736 // ======================================
737 // Conceptually, the saved registers should contain values as if the probe
738 // is not present in the JIT generated code. Hence, they should contain values
739 // that are expected at the start of the instruction immediately following the
740 // probe.
741 //
742 // Specifically, the saved stack pointer register will point to the stack
743 // position before we push the Probe::State frame. The saved rip will point to
744 // the address of the instruction immediately following the probe. 
745
746 void MacroAssembler::probe(Probe::Function function, void* arg)
747 {
748     push(RegisterID::eax);
749     move(TrustedImmPtr(reinterpret_cast<void*>(ctiMasmProbeTrampoline)), RegisterID::eax);
750     push(RegisterID::ecx);
751     move(TrustedImmPtr(reinterpret_cast<void*>(Probe::executeProbe)), RegisterID::ecx);
752     push(RegisterID::edx);
753     move(TrustedImmPtr(reinterpret_cast<void*>(function)), RegisterID::edx);
754     push(RegisterID::ebx);
755     move(TrustedImmPtr(arg), RegisterID::ebx);
756     call(RegisterID::eax);
757 }
758 #endif // ENABLE(MASM_PROBE)
759
760 #if CPU(X86) && !OS(MAC_OS_X)
761 MacroAssemblerX86Common::SSE2CheckState MacroAssemblerX86Common::s_sse2CheckState = NotCheckedSSE2;
762 #endif
763
764 MacroAssemblerX86Common::CPUIDCheckState MacroAssemblerX86Common::s_sse4_1CheckState = CPUIDCheckState::NotChecked;
765 MacroAssemblerX86Common::CPUIDCheckState MacroAssemblerX86Common::s_avxCheckState = CPUIDCheckState::NotChecked;
766 MacroAssemblerX86Common::CPUIDCheckState MacroAssemblerX86Common::s_lzcntCheckState = CPUIDCheckState::NotChecked;
767 MacroAssemblerX86Common::CPUIDCheckState MacroAssemblerX86Common::s_bmi1CheckState = CPUIDCheckState::NotChecked;
768
769 } // namespace JSC
770
771 #endif // ENABLE(ASSEMBLER) && (CPU(X86) || CPU(X86_64))