quick_entrypoints_x86.S revision 966c3ae95d3c699ee9fbdbccc1acdaaf02325faf
1/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "asm_support_x86.S"
18
19// For x86, the CFA is esp+4, the address above the pushed return address on the stack.
20
21    /*
22     * Macro that sets up the callee save frame to conform with
23     * Runtime::CreateCalleeSaveMethod(kSaveAll)
24     */
25MACRO2(SETUP_SAVE_ALL_CALLEE_SAVE_FRAME, got_reg, temp_reg)
26    PUSH edi  // Save callee saves (ebx is saved/restored by the upcall)
27    PUSH esi
28    PUSH ebp
29    subl  MACRO_LITERAL(12), %esp  // Grow stack by 3 words.
30    CFI_ADJUST_CFA_OFFSET(12)
31    SETUP_GOT_NOSAVE RAW_VAR(got_reg, 0)
32    // Load Runtime::instance_ from GOT.
33    movl SYMBOL(_ZN3art7Runtime9instance_E)@GOT(REG_VAR(got_reg, 0)), REG_VAR(temp_reg, 1)
34    movl (REG_VAR(temp_reg, 1)), REG_VAR(temp_reg, 1)
35    // Push save all callee-save method.
36    pushl RUNTIME_SAVE_ALL_CALLEE_SAVE_FRAME_OFFSET(REG_VAR(temp_reg, 1))
37    CFI_ADJUST_CFA_OFFSET(4)
38    // Store esp as the top quick frame.
39    movl %esp, %fs:THREAD_TOP_QUICK_FRAME_OFFSET
40    // Ugly compile-time check, but we only have the preprocessor.
41    // Last +4: implicit return address pushed on stack when caller made call.
42#if (FRAME_SIZE_SAVE_ALL_CALLEE_SAVE != 3*4 + 16 + 4)
43#error "SAVE_ALL_CALLEE_SAVE_FRAME(X86) size not as expected."
44#endif
45END_MACRO
46
47    /*
48     * Macro that sets up the callee save frame to conform with
49     * Runtime::CreateCalleeSaveMethod(kRefsOnly)
50     */
51MACRO2(SETUP_REFS_ONLY_CALLEE_SAVE_FRAME, got_reg, temp_reg)
52    PUSH edi  // Save callee saves (ebx is saved/restored by the upcall)
53    PUSH esi
54    PUSH ebp
55    subl  MACRO_LITERAL(12), %esp  // Grow stack by 3 words.
56    CFI_ADJUST_CFA_OFFSET(12)
57    SETUP_GOT_NOSAVE VAR(got_reg, 0)
58    // Load Runtime::instance_ from GOT.
59    movl SYMBOL(_ZN3art7Runtime9instance_E)@GOT(REG_VAR(got_reg, 0)), REG_VAR(temp_reg, 1)
60    movl (REG_VAR(temp_reg, 1)), REG_VAR(temp_reg, 1)
61    // Push save all callee-save method.
62    pushl RUNTIME_REFS_ONLY_CALLEE_SAVE_FRAME_OFFSET(REG_VAR(temp_reg, 1))
63    CFI_ADJUST_CFA_OFFSET(4)
64    // Store esp as the top quick frame.
65    movl %esp, %fs:THREAD_TOP_QUICK_FRAME_OFFSET
66
67    // Ugly compile-time check, but we only have the preprocessor.
68    // Last +4: implicit return address pushed on stack when caller made call.
69#if (FRAME_SIZE_REFS_ONLY_CALLEE_SAVE != 3*4 + 16 + 4)
70#error "REFS_ONLY_CALLEE_SAVE_FRAME(X86) size not as expected."
71#endif
72END_MACRO
73
74MACRO0(RESTORE_REFS_ONLY_CALLEE_SAVE_FRAME)
75    addl MACRO_LITERAL(16), %esp  // Unwind stack up to saved values
76    CFI_ADJUST_CFA_OFFSET(-16)
77    POP ebp  // Restore callee saves (ebx is saved/restored by the upcall)
78    POP esi
79    POP edi
80END_MACRO
81
82    /*
83     * Macro that sets up the callee save frame to conform with
84     * Runtime::CreateCalleeSaveMethod(kRefsAndArgs)
85     */
86MACRO2(SETUP_REFS_AND_ARGS_CALLEE_SAVE_FRAME, got_reg, temp_reg)
87    PUSH edi  // Save callee saves
88    PUSH esi
89    PUSH ebp
90    PUSH ebx  // Save args
91    PUSH edx
92    PUSH ecx
93    // Create space for FPR args.
94    subl MACRO_LITERAL(4 * 8), %esp
95    CFI_ADJUST_CFA_OFFSET(4 * 8)
96    // Save FPRs.
97    movsd %xmm0, 0(%esp)
98    movsd %xmm1, 8(%esp)
99    movsd %xmm2, 16(%esp)
100    movsd %xmm3, 24(%esp)
101
102    SETUP_GOT_NOSAVE VAR(got_reg, 0)
103    // Load Runtime::instance_ from GOT.
104    movl SYMBOL(_ZN3art7Runtime9instance_E)@GOT(REG_VAR(got_reg, 0)), REG_VAR(temp_reg, 1)
105    movl (REG_VAR(temp_reg, 1)), REG_VAR(temp_reg, 1)
106    // Push save all callee-save method.
107    pushl RUNTIME_REFS_AND_ARGS_CALLEE_SAVE_FRAME_OFFSET(REG_VAR(temp_reg, 1))
108    CFI_ADJUST_CFA_OFFSET(4)
109    // Store esp as the stop quick frame.
110    movl %esp, %fs:THREAD_TOP_QUICK_FRAME_OFFSET
111
112    // Ugly compile-time check, but we only have the preprocessor.
113    // Last +4: implicit return address pushed on stack when caller made call.
114#if (FRAME_SIZE_REFS_AND_ARGS_CALLEE_SAVE != 7*4 + 4*8 + 4)
115#error "REFS_AND_ARGS_CALLEE_SAVE_FRAME(X86) size not as expected."
116#endif
117END_MACRO
118
119    /*
120     * Macro that sets up the callee save frame to conform with
121     * Runtime::CreateCalleeSaveMethod(kRefsAndArgs) where the method is passed in EAX.
122     */
123MACRO0(SETUP_REFS_AND_ARGS_CALLEE_SAVE_FRAME_WITH_METHOD_IN_EAX)
124    // Save callee and GPR args, mixed together to agree with core spills bitmap.
125    PUSH edi  // Save callee saves
126    PUSH esi
127    PUSH ebp
128    PUSH ebx  // Save args
129    PUSH edx
130    PUSH ecx
131
132    // Create space for FPR args.
133    subl MACRO_LITERAL(32), %esp
134    CFI_ADJUST_CFA_OFFSET(32)
135
136    // Save FPRs.
137    movsd %xmm0, 0(%esp)
138    movsd %xmm1, 8(%esp)
139    movsd %xmm2, 16(%esp)
140    movsd %xmm3, 24(%esp)
141
142    PUSH eax  // Store the ArtMethod reference at the bottom of the stack.
143    // Store esp as the stop quick frame.
144    movl %esp, %fs:THREAD_TOP_QUICK_FRAME_OFFSET
145END_MACRO
146
147MACRO0(RESTORE_REFS_AND_ARGS_CALLEE_SAVE_FRAME)
148    // Restore FPRs. EAX is still on the stack.
149    movsd 4(%esp), %xmm0
150    movsd 12(%esp), %xmm1
151    movsd 20(%esp), %xmm2
152    movsd 28(%esp), %xmm3
153
154    addl MACRO_LITERAL(36), %esp  // Remove FPRs and EAX.
155    CFI_ADJUST_CFA_OFFSET(-36)
156
157    POP ecx  // Restore args except eax
158    POP edx
159    POP ebx
160    POP ebp  // Restore callee saves
161    POP esi
162    POP edi
163END_MACRO
164
165// Restore register and jump to routine
166// Inputs:  EDI contains pointer to code.
167// Notes: Need to pop EAX too (restores Method*)
168MACRO0(RESTORE_REFS_AND_ARGS_CALLEE_SAVE_FRAME_AND_JUMP)
169    POP eax  // Restore Method*
170
171    // Restore FPRs.
172    movsd 0(%esp), %xmm0
173    movsd 8(%esp), %xmm1
174    movsd 16(%esp), %xmm2
175    movsd 24(%esp), %xmm3
176
177    addl MACRO_LITERAL(32), %esp  // Remove FPRs.
178    CFI_ADJUST_CFA_OFFSET(-32)
179
180    POP ecx  // Restore args except eax
181    POP edx
182    POP ebx
183    POP ebp  // Restore callee saves
184    POP esi
185    xchgl 0(%esp),%edi // restore EDI and place code pointer as only value on stack
186    ret
187END_MACRO
188
189    /*
190     * Macro that set calls through to artDeliverPendingExceptionFromCode, where the pending
191     * exception is Thread::Current()->exception_.
192     */
193MACRO0(DELIVER_PENDING_EXCEPTION)
194    SETUP_SAVE_ALL_CALLEE_SAVE_FRAME ebx, ebx  // save callee saves for throw
195    // Outgoing argument set up
196    subl  MACRO_LITERAL(12), %esp              // Alignment padding
197    CFI_ADJUST_CFA_OFFSET(12)
198    pushl %fs:THREAD_SELF_OFFSET               // pass Thread::Current()
199    CFI_ADJUST_CFA_OFFSET(4)
200    call SYMBOL(artDeliverPendingExceptionFromCode)  // artDeliverPendingExceptionFromCode(Thread*)
201    int3                                       // unreached
202END_MACRO
203
204MACRO2(NO_ARG_RUNTIME_EXCEPTION, c_name, cxx_name)
205    DEFINE_FUNCTION RAW_VAR(c_name, 0)
206    SETUP_SAVE_ALL_CALLEE_SAVE_FRAME  ebx, ebx  // save all registers as basis for long jump context
207    // Outgoing argument set up
208    subl  MACRO_LITERAL(12), %esp  // alignment padding
209    CFI_ADJUST_CFA_OFFSET(12)
210    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
211    CFI_ADJUST_CFA_OFFSET(4)
212    call VAR(cxx_name, 1)         // cxx_name(Thread*)
213    int3                          // unreached
214    END_FUNCTION RAW_VAR(c_name, 0)
215END_MACRO
216
217MACRO2(ONE_ARG_RUNTIME_EXCEPTION, c_name, cxx_name)
218    DEFINE_FUNCTION RAW_VAR(c_name, 0)
219    SETUP_SAVE_ALL_CALLEE_SAVE_FRAME ebx, ebx  // save all registers as basis for long jump context
220    mov %esp, %ecx
221    // Outgoing argument set up
222    subl  MACRO_LITERAL(8), %esp  // alignment padding
223    CFI_ADJUST_CFA_OFFSET(8)
224    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
225    CFI_ADJUST_CFA_OFFSET(4)
226    PUSH eax                      // pass arg1
227    call VAR(cxx_name, 1)         // cxx_name(arg1, Thread*)
228    int3                          // unreached
229    END_FUNCTION RAW_VAR(c_name, 0)
230END_MACRO
231
232MACRO2(TWO_ARG_RUNTIME_EXCEPTION, c_name, cxx_name)
233    DEFINE_FUNCTION RAW_VAR(c_name, 0)
234    SETUP_SAVE_ALL_CALLEE_SAVE_FRAME ebx, ebx  // save all registers as basis for long jump context
235    // Outgoing argument set up
236    PUSH eax                      // alignment padding
237    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
238    CFI_ADJUST_CFA_OFFSET(4)
239    PUSH ecx                      // pass arg2
240    PUSH eax                      // pass arg1
241    call VAR(cxx_name, 1)         // cxx_name(arg1, arg2, Thread*)
242    int3                          // unreached
243    END_FUNCTION RAW_VAR(c_name, 0)
244END_MACRO
245
246    /*
247     * Called by managed code to create and deliver a NullPointerException.
248     */
249NO_ARG_RUNTIME_EXCEPTION art_quick_throw_null_pointer_exception, artThrowNullPointerExceptionFromCode
250
251    /*
252     * Called by managed code to create and deliver an ArithmeticException.
253     */
254NO_ARG_RUNTIME_EXCEPTION art_quick_throw_div_zero, artThrowDivZeroFromCode
255
256    /*
257     * Called by managed code to create and deliver a StackOverflowError.
258     */
259NO_ARG_RUNTIME_EXCEPTION art_quick_throw_stack_overflow, artThrowStackOverflowFromCode
260
261    /*
262     * Called by managed code, saves callee saves and then calls artThrowException
263     * that will place a mock Method* at the bottom of the stack. Arg1 holds the exception.
264     */
265ONE_ARG_RUNTIME_EXCEPTION art_quick_deliver_exception, artDeliverExceptionFromCode
266
267    /*
268     * Called by managed code to create and deliver a NoSuchMethodError.
269     */
270ONE_ARG_RUNTIME_EXCEPTION art_quick_throw_no_such_method, artThrowNoSuchMethodFromCode
271
272    /*
273     * Called by managed code to create and deliver an ArrayIndexOutOfBoundsException. Arg1 holds
274     * index, arg2 holds limit.
275     */
276TWO_ARG_RUNTIME_EXCEPTION art_quick_throw_array_bounds, artThrowArrayBoundsFromCode
277
278    /*
279     * All generated callsites for interface invokes and invocation slow paths will load arguments
280     * as usual - except instead of loading arg0/r0 with the target Method*, arg0/r0 will contain
281     * the method_idx.  This wrapper will save arg1-arg3, load the caller's Method*, align the
282     * stack and call the appropriate C helper.
283     * NOTE: "this" is first visible argument of the target, and so can be found in arg1/r1.
284     *
285     * The helper will attempt to locate the target and return a 64-bit result in r0/r1 consisting
286     * of the target Method* in r0 and method->code_ in r1.
287     *
288     * If unsuccessful, the helper will return NULL/NULL. There will bea pending exception in the
289     * thread and we branch to another stub to deliver it.
290     *
291     * On success this wrapper will restore arguments and *jump* to the target, leaving the lr
292     * pointing back to the original caller.
293     */
294MACRO2(INVOKE_TRAMPOLINE, c_name, cxx_name)
295    DEFINE_FUNCTION RAW_VAR(c_name, 0)
296    SETUP_REFS_AND_ARGS_CALLEE_SAVE_FRAME ebx, ebx
297    movl %esp, %edx  // remember SP
298
299    // Outgoing argument set up
300    subl MACRO_LITERAL(12), %esp  // alignment padding
301    CFI_ADJUST_CFA_OFFSET(12)
302    PUSH edx                      // pass SP
303    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
304    CFI_ADJUST_CFA_OFFSET(4)
305    pushl 32+32(%edx)             // pass caller Method*
306    CFI_ADJUST_CFA_OFFSET(4)
307    PUSH ecx                      // pass arg2
308    PUSH eax                      // pass arg1
309    call VAR(cxx_name, 1)         // cxx_name(arg1, arg2, arg3, Thread*, SP)
310    movl %edx, %edi               // save code pointer in EDI
311    addl MACRO_LITERAL(36), %esp  // Pop arguments skip eax
312    CFI_ADJUST_CFA_OFFSET(-36)
313
314    // Restore FPRs.
315    movsd 0(%esp), %xmm0
316    movsd 8(%esp), %xmm1
317    movsd 16(%esp), %xmm2
318    movsd 24(%esp), %xmm3
319
320    // Remove space for FPR args.
321    addl MACRO_LITERAL(4 * 8), %esp
322    CFI_ADJUST_CFA_OFFSET(-4 * 8)
323
324    POP ecx  // Restore args except eax
325    POP edx
326    POP ebx
327    POP ebp  // Restore callee saves
328    POP esi
329    // Swap EDI callee save with code pointer.
330    xchgl %edi, (%esp)
331    testl %eax, %eax              // Branch forward if exception pending.
332    jz    1f
333    // Tail call to intended method.
334    ret
3351:
336    addl MACRO_LITERAL(4), %esp   // Pop code pointer off stack
337    CFI_ADJUST_CFA_OFFSET(-4)
338    DELIVER_PENDING_EXCEPTION
339    END_FUNCTION RAW_VAR(c_name, 0)
340END_MACRO
341
342INVOKE_TRAMPOLINE art_quick_invoke_interface_trampoline, artInvokeInterfaceTrampoline
343INVOKE_TRAMPOLINE art_quick_invoke_interface_trampoline_with_access_check, artInvokeInterfaceTrampolineWithAccessCheck
344
345INVOKE_TRAMPOLINE art_quick_invoke_static_trampoline_with_access_check, artInvokeStaticTrampolineWithAccessCheck
346INVOKE_TRAMPOLINE art_quick_invoke_direct_trampoline_with_access_check, artInvokeDirectTrampolineWithAccessCheck
347INVOKE_TRAMPOLINE art_quick_invoke_super_trampoline_with_access_check, artInvokeSuperTrampolineWithAccessCheck
348INVOKE_TRAMPOLINE art_quick_invoke_virtual_trampoline_with_access_check, artInvokeVirtualTrampolineWithAccessCheck
349
350    /*
351     * Helper for quick invocation stub to set up XMM registers.
352     * Increments shorty and arg_array and clobbers temp_char.
353     * Branches to finished if it encounters the end of the shorty.
354     */
355MACRO5(LOOP_OVER_SHORTY_LOADING_XMMS, xmm_reg, shorty, arg_array, temp_char, finished)
3561: // LOOP
357    movb (REG_VAR(shorty, 1)), REG_VAR(temp_char, 3)  // temp_char := *shorty
358    addl MACRO_LITERAL(1), REG_VAR(shorty, 1)         // shorty++
359    cmpb MACRO_LITERAL(0), REG_VAR(temp_char, 3)      // if (temp_char == '\0')
360    je RAW_VAR(finished, 4)                           //   goto finished
361    cmpb MACRO_LITERAL(68), REG_VAR(temp_char, 3)     // if (temp_char == 'D')
362    je 2f                                             //   goto FOUND_DOUBLE
363    cmpb MACRO_LITERAL(70), REG_VAR(temp_char, 3)     // if (temp_char == 'F')
364    je 3f                                             //   goto FOUND_FLOAT
365    addl MACRO_LITERAL(4), REG_VAR(arg_array, 2)      // arg_array++
366    //  Handle extra space in arg array taken by a long.
367    cmpb MACRO_LITERAL(74), REG_VAR(temp_char, 3)     // if (temp_char != 'J')
368    jne 1b                                            //   goto LOOP
369    addl MACRO_LITERAL(4), REG_VAR(arg_array, 2)      // arg_array++
370    jmp 1b                                            // goto LOOP
3712:  // FOUND_DOUBLE
372    movsd (REG_VAR(arg_array, 2)), REG_VAR(xmm_reg, 0)
373    addl MACRO_LITERAL(8), REG_VAR(arg_array, 2)      // arg_array+=2
374    jmp 4f
3753:  // FOUND_FLOAT
376    movss (REG_VAR(arg_array, 2)), REG_VAR(xmm_reg, 0)
377    addl MACRO_LITERAL(4), REG_VAR(arg_array, 2)      // arg_array++
3784:
379END_MACRO
380
381    /*
382     * Helper for quick invocation stub to set up GPR registers.
383     * Increments shorty and arg_array, and returns the current short character in
384     * temp_char. Branches to finished if it encounters the end of the shorty.
385     */
386MACRO4(SKIP_OVER_FLOATS, shorty, arg_array, temp_char, finished)
3871: // LOOP:
388    movb (REG_VAR(shorty, 0)), REG_VAR(temp_char, 2)  // temp_char := *shorty
389    addl MACRO_LITERAL(1), REG_VAR(shorty, 0)         // shorty++
390    cmpb MACRO_LITERAL(0), REG_VAR(temp_char, 2)      // if (temp_char == '\0')
391    je RAW_VAR(finished, 3)                           //   goto finished
392    cmpb MACRO_LITERAL(70), REG_VAR(temp_char, 2)     // if (temp_char == 'F')
393    je 3f                                             //   goto SKIP_FLOAT
394    cmpb MACRO_LITERAL(68), REG_VAR(temp_char, 2)     // if (temp_char == 'D')
395    je 4f                                             //   goto SKIP_DOUBLE
396    jmp 5f                                            // goto end
3973:  // SKIP_FLOAT
398    addl MACRO_LITERAL(4), REG_VAR(arg_array, 1)      // arg_array++
399    jmp 1b                                            // goto LOOP
4004:  // SKIP_DOUBLE
401    addl MACRO_LITERAL(8), REG_VAR(arg_array, 1)      // arg_array+=2
402    jmp 1b                                            // goto LOOP
4035:
404END_MACRO
405
406  /*
407     * Quick invocation stub (non-static).
408     * On entry:
409     *   [sp] = return address
410     *   [sp + 4] = method pointer
411     *   [sp + 8] = argument array or NULL for no argument methods
412     *   [sp + 12] = size of argument array in bytes
413     *   [sp + 16] = (managed) thread pointer
414     *   [sp + 20] = JValue* result
415     *   [sp + 24] = shorty
416     */
417DEFINE_FUNCTION art_quick_invoke_stub
418    // Save the non-volatiles.
419    PUSH ebp                      // save ebp
420    PUSH ebx                      // save ebx
421    PUSH esi                      // save esi
422    PUSH edi                      // save edi
423    // Set up argument XMM registers.
424    mov 24+16(%esp), %esi         // ESI := shorty + 1  ; ie skip return arg character.
425    addl LITERAL(1), %esi
426    mov 8+16(%esp), %edi          // EDI := arg_array + 4 ; ie skip this pointer.
427    addl LITERAL(4), %edi
428    // Clobbers ESI, EDI, EAX.
429    LOOP_OVER_SHORTY_LOADING_XMMS xmm0, esi, edi, al, .Lxmm_setup_finished
430    LOOP_OVER_SHORTY_LOADING_XMMS xmm1, esi, edi, al, .Lxmm_setup_finished
431    LOOP_OVER_SHORTY_LOADING_XMMS xmm2, esi, edi, al, .Lxmm_setup_finished
432    LOOP_OVER_SHORTY_LOADING_XMMS xmm3, esi, edi, al, .Lxmm_setup_finished
433    .balign 16
434.Lxmm_setup_finished:
435    mov %esp, %ebp                // copy value of stack pointer into base pointer
436    CFI_DEF_CFA_REGISTER(ebp)
437    mov 28(%ebp), %ebx            // get arg array size
438    // reserve space for return addr, method*, ebx, ebp, esi, and edi in frame
439    addl LITERAL(36), %ebx
440    // align frame size to 16 bytes
441    andl LITERAL(0xFFFFFFF0), %ebx
442    subl LITERAL(20), %ebx        // remove space for return address, ebx, ebp, esi and edi
443    subl %ebx, %esp               // reserve stack space for argument array
444
445    movl LITERAL(0), (%esp)       // store NULL for method*
446
447    // Copy arg array into stack.
448    movl 28(%ebp), %ecx           // ECX = size of args
449    movl 24(%ebp), %esi           // ESI = argument array
450    leal 4(%esp), %edi            // EDI = just after Method* in stack arguments
451    rep movsb                     // while (ecx--) { *edi++ = *esi++ }
452
453    mov 40(%ebp), %esi            // ESI := shorty + 1  ; ie skip return arg character.
454    addl LITERAL(1), %esi
455    mov 24(%ebp), %edi            // EDI := arg_array
456    mov 0(%edi), %ecx             // ECX := this pointer
457    addl LITERAL(4), %edi         // EDI := arg_array + 4 ; ie skip this pointer.
458
459    // Enumerate the possible cases for loading GPRS.
460    // edx (and maybe ebx):
461    SKIP_OVER_FLOATS esi, edi, al, .Lgpr_setup_finished
462    cmpb LITERAL(74), %al         // if (al == 'J') goto FOUND_LONG
463    je .LfirstLong
464    // Must be an integer value.
465    movl (%edi), %edx
466    addl LITERAL(4), %edi         // arg_array++
467
468    // Now check ebx
469    SKIP_OVER_FLOATS esi, edi, al, .Lgpr_setup_finished
470    // Must be first word of a long, or an integer.
471    movl (%edi), %ebx
472    jmp .Lgpr_setup_finished
473.LfirstLong:
474    movl (%edi), %edx
475    movl 4(%edi), %ebx
476    // Nothing left to load.
477.Lgpr_setup_finished:
478    mov 20(%ebp), %eax            // move method pointer into eax
479    call *MIRROR_ART_METHOD_QUICK_CODE_OFFSET_32(%eax) // call the method
480    mov %ebp, %esp                // restore stack pointer
481    CFI_DEF_CFA_REGISTER(esp)
482    POP edi                       // pop edi
483    POP esi                       // pop esi
484    POP ebx                       // pop ebx
485    POP ebp                       // pop ebp
486    mov 20(%esp), %ecx            // get result pointer
487    mov %eax, (%ecx)              // store the result assuming its a long, int or Object*
488    mov %edx, 4(%ecx)             // store the other half of the result
489    mov 24(%esp), %edx            // get the shorty
490    cmpb LITERAL(68), (%edx)      // test if result type char == 'D'
491    je .Lreturn_double_quick
492    cmpb LITERAL(70), (%edx)      // test if result type char == 'F'
493    je .Lreturn_float_quick
494    ret
495.Lreturn_double_quick:
496    movsd %xmm0, (%ecx)           // store the floating point result
497    ret
498.Lreturn_float_quick:
499    movss %xmm0, (%ecx)           // store the floating point result
500    ret
501END_FUNCTION art_quick_invoke_stub
502
503  /*
504     * Quick invocation stub (static).
505     * On entry:
506     *   [sp] = return address
507     *   [sp + 4] = method pointer
508     *   [sp + 8] = argument array or NULL for no argument methods
509     *   [sp + 12] = size of argument array in bytes
510     *   [sp + 16] = (managed) thread pointer
511     *   [sp + 20] = JValue* result
512     *   [sp + 24] = shorty
513     */
514DEFINE_FUNCTION art_quick_invoke_static_stub
515    // Save the non-volatiles.
516    PUSH ebp                      // save ebp
517    PUSH ebx                      // save ebx
518    PUSH esi                      // save esi
519    PUSH edi                      // save edi
520    // Set up argument XMM registers.
521    mov 24+16(%esp), %esi         // ESI := shorty + 1  ; ie skip return arg character.
522    addl LITERAL(1), %esi
523    mov 8+16(%esp), %edi          // EDI := arg_array
524    // Clobbers ESI, EDI, EAX.
525    LOOP_OVER_SHORTY_LOADING_XMMS xmm0, esi, edi, al, .Lxmm_setup_finished2
526    LOOP_OVER_SHORTY_LOADING_XMMS xmm1, esi, edi, al, .Lxmm_setup_finished2
527    LOOP_OVER_SHORTY_LOADING_XMMS xmm2, esi, edi, al, .Lxmm_setup_finished2
528    LOOP_OVER_SHORTY_LOADING_XMMS xmm3, esi, edi, al, .Lxmm_setup_finished2
529    .balign 16
530.Lxmm_setup_finished2:
531    mov %esp, %ebp                // copy value of stack pointer into base pointer
532    CFI_DEF_CFA_REGISTER(ebp)
533    mov 28(%ebp), %ebx            // get arg array size
534    // reserve space for return addr, method*, ebx, ebp, esi, and edi in frame
535    addl LITERAL(36), %ebx
536    // align frame size to 16 bytes
537    andl LITERAL(0xFFFFFFF0), %ebx
538    subl LITERAL(20), %ebx        // remove space for return address, ebx, ebp, esi and edi
539    subl %ebx, %esp               // reserve stack space for argument array
540
541    movl LITERAL(0), (%esp)       // store NULL for method*
542
543    // Copy arg array into stack.
544    movl 28(%ebp), %ecx           // ECX = size of args
545    movl 24(%ebp), %esi           // ESI = argument array
546    leal 4(%esp), %edi            // EDI = just after Method* in stack arguments
547    rep movsb                     // while (ecx--) { *edi++ = *esi++ }
548
549    mov 40(%ebp), %esi            // ESI := shorty + 1  ; ie skip return arg character.
550    addl LITERAL(1), %esi
551    mov 24(%ebp), %edi            // EDI := arg_array
552
553    // Enumerate the possible cases for loading GPRS.
554    // ecx (and maybe edx)
555    SKIP_OVER_FLOATS esi, edi, al, .Lgpr_setup_finished2
556    cmpb LITERAL(74), %al         // if (al == 'J') goto FOUND_LONG
557    je .LfirstLong2
558    // Must be an integer value.  Load into ECX.
559    movl (%edi), %ecx
560    addl LITERAL(4), %edi         // arg_array++
561
562    // Now check edx (and maybe ebx).
563    SKIP_OVER_FLOATS esi, edi, al, .Lgpr_setup_finished2
564    cmpb LITERAL(74), %al         // if (al == 'J') goto FOUND_LONG
565    je .LSecondLong2
566    // Must be an integer.  Load into EDX.
567    movl (%edi), %edx
568    addl LITERAL(4), %edi         // arg_array++
569
570    // Is there anything for ebx?
571    SKIP_OVER_FLOATS esi, edi, al, .Lgpr_setup_finished2
572    // First word of long or integer.  Load into EBX.
573    movl (%edi), %ebx
574    jmp .Lgpr_setup_finished2
575.LSecondLong2:
576    // EDX:EBX is long.  That is all.
577    movl (%edi), %edx
578    movl 4(%edi), %ebx
579    jmp .Lgpr_setup_finished2
580.LfirstLong2:
581    // ECX:EDX is a long
582    movl (%edi), %ecx
583    movl 4(%edi), %edx
584    addl LITERAL(8), %edi         // arg_array += 2
585
586    // Anything for EBX?
587    SKIP_OVER_FLOATS esi, edi, al, .Lgpr_setup_finished2
588    // First word of long or integer.  Load into EBX.
589    movl (%edi), %ebx
590    jmp .Lgpr_setup_finished2
591    // Nothing left to load.
592.Lgpr_setup_finished2:
593    mov 20(%ebp), %eax            // move method pointer into eax
594    call *MIRROR_ART_METHOD_QUICK_CODE_OFFSET_32(%eax) // call the method
595    mov %ebp, %esp                // restore stack pointer
596    CFI_DEF_CFA_REGISTER(esp)
597    POP edi                       // pop edi
598    POP esi                       // pop esi
599    POP ebx                       // pop ebx
600    POP ebp                       // pop ebp
601    mov 20(%esp), %ecx            // get result pointer
602    mov %eax, (%ecx)              // store the result assuming its a long, int or Object*
603    mov %edx, 4(%ecx)             // store the other half of the result
604    mov 24(%esp), %edx            // get the shorty
605    cmpb LITERAL(68), (%edx)      // test if result type char == 'D'
606    je .Lreturn_double_quick2
607    cmpb LITERAL(70), (%edx)      // test if result type char == 'F'
608    je .Lreturn_float_quick2
609    ret
610.Lreturn_double_quick2:
611    movsd %xmm0, (%ecx)           // store the floating point result
612    ret
613.Lreturn_float_quick2:
614    movss %xmm0, (%ecx)           // store the floating point result
615    ret
616END_FUNCTION art_quick_invoke_static_stub
617
618MACRO3(NO_ARG_DOWNCALL, c_name, cxx_name, return_macro)
619    DEFINE_FUNCTION RAW_VAR(c_name, 0)
620    SETUP_REFS_ONLY_CALLEE_SAVE_FRAME ebx, ebx  // save ref containing registers for GC
621    // Outgoing argument set up
622    subl MACRO_LITERAL(12), %esp  // push padding
623    CFI_ADJUST_CFA_OFFSET(12)
624    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
625    CFI_ADJUST_CFA_OFFSET(4)
626    call VAR(cxx_name, 1)         // cxx_name(Thread*)
627    addl MACRO_LITERAL(16), %esp  // pop arguments
628    CFI_ADJUST_CFA_OFFSET(-16)
629    RESTORE_REFS_ONLY_CALLEE_SAVE_FRAME  // restore frame up to return address
630    CALL_MACRO(return_macro, 2)   // return or deliver exception
631    END_FUNCTION RAW_VAR(c_name, 0)
632END_MACRO
633
634MACRO3(ONE_ARG_DOWNCALL, c_name, cxx_name, return_macro)
635    DEFINE_FUNCTION RAW_VAR(c_name, 0)
636    SETUP_REFS_ONLY_CALLEE_SAVE_FRAME  ebx, ebx  // save ref containing registers for GC
637    // Outgoing argument set up
638    subl MACRO_LITERAL(8), %esp   // push padding
639    CFI_ADJUST_CFA_OFFSET(8)
640    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
641    CFI_ADJUST_CFA_OFFSET(4)
642    PUSH eax                      // pass arg1
643    call VAR(cxx_name, 1)         // cxx_name(arg1, Thread*)
644    addl MACRO_LITERAL(16), %esp  // pop arguments
645    CFI_ADJUST_CFA_OFFSET(-16)
646    RESTORE_REFS_ONLY_CALLEE_SAVE_FRAME  // restore frame up to return address
647    CALL_MACRO(return_macro, 2)   // return or deliver exception
648    END_FUNCTION RAW_VAR(c_name, 0)
649END_MACRO
650
651MACRO3(TWO_ARG_DOWNCALL, c_name, cxx_name, return_macro)
652    DEFINE_FUNCTION RAW_VAR(c_name, 0)
653    SETUP_REFS_ONLY_CALLEE_SAVE_FRAME  ebx, ebx  // save ref containing registers for GC
654    // Outgoing argument set up
655    PUSH eax                      // push padding
656    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
657    CFI_ADJUST_CFA_OFFSET(4)
658    PUSH ecx                      // pass arg2
659    PUSH eax                      // pass arg1
660    call VAR(cxx_name, 1)         // cxx_name(arg1, arg2, Thread*)
661    addl MACRO_LITERAL(16), %esp  // pop arguments
662    CFI_ADJUST_CFA_OFFSET(-16)
663    RESTORE_REFS_ONLY_CALLEE_SAVE_FRAME  // restore frame up to return address
664    CALL_MACRO(return_macro, 2)   // return or deliver exception
665    END_FUNCTION RAW_VAR(c_name, 0)
666END_MACRO
667
668MACRO3(THREE_ARG_DOWNCALL, c_name, cxx_name, return_macro)
669    DEFINE_FUNCTION RAW_VAR(c_name, 0)
670    SETUP_REFS_ONLY_CALLEE_SAVE_FRAME  ebx, ebx  // save ref containing registers for GC
671    // Outgoing argument set up
672    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
673    CFI_ADJUST_CFA_OFFSET(4)
674    PUSH edx                      // pass arg3
675    PUSH ecx                      // pass arg2
676    PUSH eax                      // pass arg1
677    call VAR(cxx_name, 1)         // cxx_name(arg1, arg2, arg3, Thread*)
678    addl MACRO_LITERAL(16), %esp  // pop arguments
679    CFI_ADJUST_CFA_OFFSET(-16)
680    RESTORE_REFS_ONLY_CALLEE_SAVE_FRAME  // restore frame up to return address
681    CALL_MACRO(return_macro, 2)   // return or deliver exception
682    END_FUNCTION RAW_VAR(c_name, 0)
683END_MACRO
684
685MACRO3(ONE_ARG_REF_DOWNCALL, c_name, cxx_name, return_macro)
686    DEFINE_FUNCTION RAW_VAR(c_name, 0)
687    SETUP_REFS_ONLY_CALLEE_SAVE_FRAME  ebx, ebx // save ref containing registers for GC
688    // Outgoing argument set up
689    mov FRAME_SIZE_REFS_ONLY_CALLEE_SAVE(%esp), %ecx  // get referrer
690    PUSH eax                      // push padding
691    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
692    CFI_ADJUST_CFA_OFFSET(4)
693    PUSH ecx                      // pass referrer
694    PUSH eax                      // pass arg1
695    call VAR(cxx_name, 1)         // cxx_name(arg1, referrer, Thread*)
696    addl MACRO_LITERAL(16), %esp  // pop arguments
697    CFI_ADJUST_CFA_OFFSET(-16)
698    RESTORE_REFS_ONLY_CALLEE_SAVE_FRAME  // restore frame up to return address
699    CALL_MACRO(return_macro, 2)   // return or deliver exception
700    END_FUNCTION RAW_VAR(c_name, 0)
701END_MACRO
702
703MACRO3(TWO_ARG_REF_DOWNCALL, c_name, cxx_name, return_macro)
704    DEFINE_FUNCTION RAW_VAR(c_name, 0)
705    SETUP_REFS_ONLY_CALLEE_SAVE_FRAME ebx, ebx // save ref containing registers for GC
706    // Outgoing argument set up
707    mov FRAME_SIZE_REFS_ONLY_CALLEE_SAVE(%esp), %edx  // get referrer
708    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
709    CFI_ADJUST_CFA_OFFSET(4)
710    PUSH edx                      // pass referrer
711    PUSH ecx                      // pass arg2
712    PUSH eax                      // pass arg1
713    call VAR(cxx_name, 1)         // cxx_name(arg1, arg2, referrer, Thread*)
714    addl MACRO_LITERAL(16), %esp  // pop arguments
715    CFI_ADJUST_CFA_OFFSET(-16)
716    RESTORE_REFS_ONLY_CALLEE_SAVE_FRAME  // restore frame up to return address
717    CALL_MACRO(return_macro, 2)   // return or deliver exception
718    END_FUNCTION RAW_VAR(c_name, 0)
719END_MACRO
720
721MACRO3(THREE_ARG_REF_DOWNCALL, c_name, cxx_name, return_macro)
722    DEFINE_FUNCTION RAW_VAR(c_name, 0)
723    SETUP_REFS_ONLY_CALLEE_SAVE_FRAME ebx, ebx  // save ref containing registers for GC
724    // Outgoing argument set up
725    mov FRAME_SIZE_REFS_ONLY_CALLEE_SAVE(%esp), %ebx  // get referrer
726    subl MACRO_LITERAL(12), %esp  // alignment padding
727    CFI_ADJUST_CFA_OFFSET(12)
728    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
729    CFI_ADJUST_CFA_OFFSET(4)
730    PUSH ebx                      // pass referrer
731    PUSH edx                      // pass arg3
732    PUSH ecx                      // pass arg2
733    PUSH eax                      // pass arg1
734    call VAR(cxx_name, 1)         // cxx_name(arg1, arg2, arg3, referrer, Thread*)
735    addl LITERAL(32), %esp        // pop arguments
736    CFI_ADJUST_CFA_OFFSET(-32)
737    RESTORE_REFS_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
738    CALL_MACRO(return_macro, 2)   // return or deliver exception
739    END_FUNCTION RAW_VAR(c_name, 0)
740END_MACRO
741
742MACRO0(RETURN_IF_RESULT_IS_NON_ZERO)
743    testl %eax, %eax               // eax == 0 ?
744    jz  1f                         // if eax == 0 goto 1
745    ret                            // return
7461:                                 // deliver exception on current thread
747    DELIVER_PENDING_EXCEPTION
748END_MACRO
749
750MACRO0(RETURN_IF_EAX_ZERO)
751    testl %eax, %eax               // eax == 0 ?
752    jnz  1f                        // if eax != 0 goto 1
753    ret                            // return
7541:                                 // deliver exception on current thread
755    DELIVER_PENDING_EXCEPTION
756END_MACRO
757
758MACRO0(RETURN_OR_DELIVER_PENDING_EXCEPTION)
759    cmpl MACRO_LITERAL(0),%fs:THREAD_EXCEPTION_OFFSET // exception field == 0 ?
760    jne 1f                         // if exception field != 0 goto 1
761    ret                            // return
7621:                                 // deliver exception on current thread
763    DELIVER_PENDING_EXCEPTION
764END_MACRO
765
766// Generate the allocation entrypoints for each allocator.
767// TODO: use arch/quick_alloc_entrypoints.S. Currently we don't as we need to use concatenation
768// macros to work around differences between OS/X's as and binutils as (OS/X lacks named arguments
769// to macros and the VAR macro won't concatenate arguments properly), this also breaks having
770// multi-line macros that use each other (hence using 1 macro per newline below).
771#define GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT(c_suffix, cxx_suffix) \
772  TWO_ARG_DOWNCALL art_quick_alloc_object ## c_suffix, artAllocObjectFromCode ## cxx_suffix, RETURN_IF_RESULT_IS_NON_ZERO
773#define GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(c_suffix, cxx_suffix) \
774  TWO_ARG_DOWNCALL art_quick_alloc_object_resolved ## c_suffix, artAllocObjectFromCodeResolved ## cxx_suffix, RETURN_IF_RESULT_IS_NON_ZERO
775#define GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_INITIALIZED(c_suffix, cxx_suffix) \
776  TWO_ARG_DOWNCALL art_quick_alloc_object_initialized ## c_suffix, artAllocObjectFromCodeInitialized ## cxx_suffix, RETURN_IF_RESULT_IS_NON_ZERO
777#define GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_WITH_ACCESS_CHECK(c_suffix, cxx_suffix) \
778  TWO_ARG_DOWNCALL art_quick_alloc_object_with_access_check ## c_suffix, artAllocObjectFromCodeWithAccessCheck ## cxx_suffix, RETURN_IF_RESULT_IS_NON_ZERO
779#define GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY(c_suffix, cxx_suffix) \
780  THREE_ARG_DOWNCALL art_quick_alloc_array ## c_suffix, artAllocArrayFromCode ## cxx_suffix, RETURN_IF_RESULT_IS_NON_ZERO
781#define GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_RESOLVED(c_suffix, cxx_suffix) \
782  THREE_ARG_DOWNCALL art_quick_alloc_array_resolved ## c_suffix, artAllocArrayFromCodeResolved ## cxx_suffix, RETURN_IF_RESULT_IS_NON_ZERO
783#define GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_WITH_ACCESS_CHECK(c_suffix, cxx_suffix) \
784  THREE_ARG_DOWNCALL art_quick_alloc_array_with_access_check ## c_suffix, artAllocArrayFromCodeWithAccessCheck ## cxx_suffix, RETURN_IF_RESULT_IS_NON_ZERO
785#define GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY(c_suffix, cxx_suffix) \
786  THREE_ARG_DOWNCALL art_quick_check_and_alloc_array ## c_suffix, artCheckAndAllocArrayFromCode ## cxx_suffix, RETURN_IF_RESULT_IS_NON_ZERO
787#define GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY_WITH_ACCESS_CHECK(c_suffix, cxx_suffix) \
788  THREE_ARG_DOWNCALL art_quick_check_and_alloc_array_with_access_check ## c_suffix, artCheckAndAllocArrayFromCodeWithAccessCheck ## cxx_suffix, RETURN_IF_RESULT_IS_NON_ZERO
789
790GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT(_dlmalloc, DlMalloc)
791GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(_dlmalloc, DlMalloc)
792GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_INITIALIZED(_dlmalloc, DlMalloc)
793GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_WITH_ACCESS_CHECK(_dlmalloc, DlMalloc)
794GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY(_dlmalloc, DlMalloc)
795GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_RESOLVED(_dlmalloc, DlMalloc)
796GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_WITH_ACCESS_CHECK(_dlmalloc, DlMalloc)
797GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY(_dlmalloc, DlMalloc)
798GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY_WITH_ACCESS_CHECK(_dlmalloc, DlMalloc)
799
800GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT(_dlmalloc_instrumented, DlMallocInstrumented)
801GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(_dlmalloc_instrumented, DlMallocInstrumented)
802GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_INITIALIZED(_dlmalloc_instrumented, DlMallocInstrumented)
803GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_WITH_ACCESS_CHECK(_dlmalloc_instrumented, DlMallocInstrumented)
804GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY(_dlmalloc_instrumented, DlMallocInstrumented)
805GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_RESOLVED(_dlmalloc_instrumented, DlMallocInstrumented)
806GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_WITH_ACCESS_CHECK(_dlmalloc_instrumented, DlMallocInstrumented)
807GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY(_dlmalloc_instrumented, DlMallocInstrumented)
808GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY_WITH_ACCESS_CHECK(_dlmalloc_instrumented, DlMallocInstrumented)
809
810GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT(_rosalloc, RosAlloc)
811GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(_rosalloc, RosAlloc)
812GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_INITIALIZED(_rosalloc, RosAlloc)
813GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_WITH_ACCESS_CHECK(_rosalloc, RosAlloc)
814GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY(_rosalloc, RosAlloc)
815GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_RESOLVED(_rosalloc, RosAlloc)
816GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_WITH_ACCESS_CHECK(_rosalloc, RosAlloc)
817GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY(_rosalloc, RosAlloc)
818GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY_WITH_ACCESS_CHECK(_rosalloc, RosAlloc)
819
820GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT(_rosalloc_instrumented, RosAllocInstrumented)
821GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(_rosalloc_instrumented, RosAllocInstrumented)
822GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_INITIALIZED(_rosalloc_instrumented, RosAllocInstrumented)
823GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_WITH_ACCESS_CHECK(_rosalloc_instrumented, RosAllocInstrumented)
824GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY(_rosalloc_instrumented, RosAllocInstrumented)
825GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_RESOLVED(_rosalloc_instrumented, RosAllocInstrumented)
826GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_WITH_ACCESS_CHECK(_rosalloc_instrumented, RosAllocInstrumented)
827GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY(_rosalloc_instrumented, RosAllocInstrumented)
828GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY_WITH_ACCESS_CHECK(_rosalloc_instrumented, RosAllocInstrumented)
829
830GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT(_bump_pointer, BumpPointer)
831GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(_bump_pointer, BumpPointer)
832GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_INITIALIZED(_bump_pointer, BumpPointer)
833GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_WITH_ACCESS_CHECK(_bump_pointer, BumpPointer)
834GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY(_bump_pointer, BumpPointer)
835GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_RESOLVED(_bump_pointer, BumpPointer)
836GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_WITH_ACCESS_CHECK(_bump_pointer, BumpPointer)
837GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY(_bump_pointer, BumpPointer)
838GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY_WITH_ACCESS_CHECK(_bump_pointer, BumpPointer)
839
840GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT(_bump_pointer_instrumented, BumpPointerInstrumented)
841GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(_bump_pointer_instrumented, BumpPointerInstrumented)
842GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_INITIALIZED(_bump_pointer_instrumented, BumpPointerInstrumented)
843GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_WITH_ACCESS_CHECK(_bump_pointer_instrumented, BumpPointerInstrumented)
844GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY(_bump_pointer_instrumented, BumpPointerInstrumented)
845GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_RESOLVED(_bump_pointer_instrumented, BumpPointerInstrumented)
846GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_WITH_ACCESS_CHECK(_bump_pointer_instrumented, BumpPointerInstrumented)
847GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY(_bump_pointer_instrumented, BumpPointerInstrumented)
848GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY_WITH_ACCESS_CHECK(_bump_pointer_instrumented, BumpPointerInstrumented)
849
850GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT(_tlab, TLAB)
851GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(_tlab, TLAB)
852GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_INITIALIZED(_tlab, TLAB)
853GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_WITH_ACCESS_CHECK(_tlab, TLAB)
854GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY(_tlab, TLAB)
855GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_RESOLVED(_tlab, TLAB)
856GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_WITH_ACCESS_CHECK(_tlab, TLAB)
857GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY(_tlab, TLAB)
858GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY_WITH_ACCESS_CHECK(_tlab, TLAB)
859
860GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT(_tlab_instrumented, TLABInstrumented)
861GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(_tlab_instrumented, TLABInstrumented)
862GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_INITIALIZED(_tlab_instrumented, TLABInstrumented)
863GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_WITH_ACCESS_CHECK(_tlab_instrumented, TLABInstrumented)
864GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY(_tlab_instrumented, TLABInstrumented)
865GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_RESOLVED(_tlab_instrumented, TLABInstrumented)
866GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_WITH_ACCESS_CHECK(_tlab_instrumented, TLABInstrumented)
867GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY(_tlab_instrumented, TLABInstrumented)
868GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY_WITH_ACCESS_CHECK(_tlab_instrumented, TLABInstrumented)
869
870GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT(_region, Region)
871GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(_region, Region)
872GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_INITIALIZED(_region, Region)
873GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_WITH_ACCESS_CHECK(_region, Region)
874GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY(_region, Region)
875GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_RESOLVED(_region, Region)
876GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_WITH_ACCESS_CHECK(_region, Region)
877GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY(_region, Region)
878GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY_WITH_ACCESS_CHECK(_region, Region)
879
880GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT(_region_instrumented, RegionInstrumented)
881GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(_region_instrumented, RegionInstrumented)
882GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_INITIALIZED(_region_instrumented, RegionInstrumented)
883GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_WITH_ACCESS_CHECK(_region_instrumented, RegionInstrumented)
884GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY(_region_instrumented, RegionInstrumented)
885GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_RESOLVED(_region_instrumented, RegionInstrumented)
886GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_WITH_ACCESS_CHECK(_region_instrumented, RegionInstrumented)
887GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY(_region_instrumented, RegionInstrumented)
888GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY_WITH_ACCESS_CHECK(_region_instrumented, RegionInstrumented)
889
890GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT(_region_tlab, RegionTLAB)
891GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(_region_tlab, RegionTLAB)
892GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_INITIALIZED(_region_tlab, RegionTLAB)
893GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_WITH_ACCESS_CHECK(_region_tlab, RegionTLAB)
894GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY(_region_tlab, RegionTLAB)
895GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_RESOLVED(_region_tlab, RegionTLAB)
896GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_WITH_ACCESS_CHECK(_region_tlab, RegionTLAB)
897GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY(_region_tlab, RegionTLAB)
898GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY_WITH_ACCESS_CHECK(_region_tlab, RegionTLAB)
899
900GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT(_region_tlab_instrumented, RegionTLABInstrumented)
901GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(_region_tlab_instrumented, RegionTLABInstrumented)
902GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_INITIALIZED(_region_tlab_instrumented, RegionTLABInstrumented)
903GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_WITH_ACCESS_CHECK(_region_tlab_instrumented, RegionTLABInstrumented)
904GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY(_region_tlab_instrumented, RegionTLABInstrumented)
905GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_RESOLVED(_region_tlab_instrumented, RegionTLABInstrumented)
906GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_WITH_ACCESS_CHECK(_region_tlab_instrumented, RegionTLABInstrumented)
907GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY(_region_tlab_instrumented, RegionTLABInstrumented)
908GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY_WITH_ACCESS_CHECK(_region_tlab_instrumented, RegionTLABInstrumented)
909
910TWO_ARG_DOWNCALL art_quick_resolve_string, artResolveStringFromCode, RETURN_IF_RESULT_IS_NON_ZERO
911TWO_ARG_DOWNCALL art_quick_initialize_static_storage, artInitializeStaticStorageFromCode, RETURN_IF_RESULT_IS_NON_ZERO
912TWO_ARG_DOWNCALL art_quick_initialize_type, artInitializeTypeFromCode, RETURN_IF_RESULT_IS_NON_ZERO
913TWO_ARG_DOWNCALL art_quick_initialize_type_and_verify_access, artInitializeTypeAndVerifyAccessFromCode, RETURN_IF_RESULT_IS_NON_ZERO
914
915TWO_ARG_REF_DOWNCALL art_quick_handle_fill_data, artHandleFillArrayDataFromCode, RETURN_IF_EAX_ZERO
916
917DEFINE_FUNCTION art_quick_lock_object
918    testl %eax, %eax                      // null check object/eax
919    jz   .Lslow_lock
920.Lretry_lock:
921    movl MIRROR_OBJECT_LOCK_WORD_OFFSET(%eax), %ecx  // ecx := lock word
922    test LITERAL(0xC0000000), %ecx        // test the 2 high bits.
923    jne  .Lslow_lock                      // slow path if either of the two high bits are set.
924    movl %fs:THREAD_ID_OFFSET, %edx       // edx := thread id
925    test %ecx, %ecx
926    jnz  .Lalready_thin                   // lock word contains a thin lock
927    // unlocked case - %edx holds thread id with count of 0
928    movl %eax, %ecx                       // remember object in case of retry
929    xor  %eax, %eax                       // eax == 0 for comparison with lock word in cmpxchg
930    lock cmpxchg  %edx, MIRROR_OBJECT_LOCK_WORD_OFFSET(%ecx)
931    jnz  .Lcmpxchg_fail                   // cmpxchg failed retry
932    ret
933.Lcmpxchg_fail:
934    movl  %ecx, %eax                      // restore eax
935    jmp  .Lretry_lock
936.Lalready_thin:
937    cmpw %cx, %dx                         // do we hold the lock already?
938    jne  .Lslow_lock
939    addl LITERAL(65536), %ecx             // increment recursion count
940    test LITERAL(0xC0000000), %ecx        // overflowed if either of top two bits are set
941    jne  .Lslow_lock                      // count overflowed so go slow
942    // update lockword, cmpxchg not necessary as we hold lock
943    movl %ecx, MIRROR_OBJECT_LOCK_WORD_OFFSET(%eax)
944    ret
945.Lslow_lock:
946    SETUP_REFS_ONLY_CALLEE_SAVE_FRAME  ebx, ebx  // save ref containing registers for GC
947    // Outgoing argument set up
948    subl LITERAL(8), %esp         // alignment padding
949    CFI_ADJUST_CFA_OFFSET(8)
950    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
951    CFI_ADJUST_CFA_OFFSET(4)
952    PUSH eax                      // pass object
953    call SYMBOL(artLockObjectFromCode)  // artLockObjectFromCode(object, Thread*)
954    addl LITERAL(16), %esp  // pop arguments
955    CFI_ADJUST_CFA_OFFSET(-16)
956    RESTORE_REFS_ONLY_CALLEE_SAVE_FRAME  // restore frame up to return address
957    RETURN_IF_EAX_ZERO
958END_FUNCTION art_quick_lock_object
959
960DEFINE_FUNCTION art_quick_unlock_object
961    testl %eax, %eax                      // null check object/eax
962    jz   .Lslow_unlock
963    movl MIRROR_OBJECT_LOCK_WORD_OFFSET(%eax), %ecx  // ecx := lock word
964    movl %fs:THREAD_ID_OFFSET, %edx       // edx := thread id
965    test LITERAL(0xC0000000), %ecx
966    jnz  .Lslow_unlock                    // lock word contains a monitor
967    cmpw %cx, %dx                         // does the thread id match?
968    jne  .Lslow_unlock
969    cmpl LITERAL(65536), %ecx
970    jae  .Lrecursive_thin_unlock
971    movl LITERAL(0), MIRROR_OBJECT_LOCK_WORD_OFFSET(%eax)
972    ret
973.Lrecursive_thin_unlock:
974    subl LITERAL(65536), %ecx
975    mov  %ecx, MIRROR_OBJECT_LOCK_WORD_OFFSET(%eax)
976    ret
977.Lslow_unlock:
978    SETUP_REFS_ONLY_CALLEE_SAVE_FRAME  ebx, ebx  // save ref containing registers for GC
979    // Outgoing argument set up
980    subl LITERAL(8), %esp         // alignment padding
981    CFI_ADJUST_CFA_OFFSET(8)
982    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
983    CFI_ADJUST_CFA_OFFSET(4)
984    PUSH eax                      // pass object
985    call SYMBOL(artUnlockObjectFromCode)  // artUnlockObjectFromCode(object, Thread*)
986    addl LITERAL(16), %esp  // pop arguments
987    CFI_ADJUST_CFA_OFFSET(-16)
988    RESTORE_REFS_ONLY_CALLEE_SAVE_FRAME  // restore frame up to return address
989    RETURN_IF_EAX_ZERO
990END_FUNCTION art_quick_unlock_object
991
992DEFINE_FUNCTION art_quick_is_assignable
993    PUSH eax                     // alignment padding
994    PUSH ecx                     // pass arg2 - obj->klass
995    PUSH eax                     // pass arg1 - checked class
996    call SYMBOL(artIsAssignableFromCode)  // (Class* klass, Class* ref_klass)
997    addl LITERAL(12), %esp        // pop arguments
998    CFI_ADJUST_CFA_OFFSET(-12)
999    ret
1000END_FUNCTION art_quick_is_assignable
1001
1002DEFINE_FUNCTION art_quick_check_cast
1003    PUSH eax                     // alignment padding
1004    PUSH ecx                     // pass arg2 - obj->klass
1005    PUSH eax                     // pass arg1 - checked class
1006    call SYMBOL(artIsAssignableFromCode)  // (Class* klass, Class* ref_klass)
1007    testl %eax, %eax
1008    jz 1f                         // jump forward if not assignable
1009    addl LITERAL(12), %esp        // pop arguments
1010    CFI_ADJUST_CFA_OFFSET(-12)
1011    ret
10121:
1013    POP eax                       // pop arguments
1014    POP ecx
1015    addl LITERAL(4), %esp
1016    CFI_ADJUST_CFA_OFFSET(-12)
1017    SETUP_SAVE_ALL_CALLEE_SAVE_FRAME  ebx, ebx  // save all registers as basis for long jump context
1018    // Outgoing argument set up
1019    PUSH eax                      // alignment padding
1020    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
1021    CFI_ADJUST_CFA_OFFSET(4)
1022    PUSH ecx                      // pass arg2
1023    PUSH eax                      // pass arg1
1024    call SYMBOL(artThrowClassCastException) // (Class* a, Class* b, Thread*)
1025    int3                          // unreached
1026END_FUNCTION art_quick_check_cast
1027
1028    /*
1029     * Entry from managed code for array put operations of objects where the value being stored
1030     * needs to be checked for compatibility.
1031     * eax = array, ecx = index, edx = value
1032     */
1033DEFINE_FUNCTION art_quick_aput_obj_with_null_and_bound_check
1034    testl %eax, %eax
1035    jnz SYMBOL(art_quick_aput_obj_with_bound_check)
1036    jmp SYMBOL(art_quick_throw_null_pointer_exception)
1037END_FUNCTION art_quick_aput_obj_with_null_and_bound_check
1038
1039DEFINE_FUNCTION art_quick_aput_obj_with_bound_check
1040    movl MIRROR_ARRAY_LENGTH_OFFSET(%eax), %ebx
1041    cmpl %ebx, %ecx
1042    jb SYMBOL(art_quick_aput_obj)
1043    mov %ecx, %eax
1044    mov %ebx, %ecx
1045    jmp SYMBOL(art_quick_throw_array_bounds)
1046END_FUNCTION art_quick_aput_obj_with_bound_check
1047
1048DEFINE_FUNCTION art_quick_aput_obj
1049    test %edx, %edx              // store of null
1050    jz .Ldo_aput_null
1051    movl MIRROR_OBJECT_CLASS_OFFSET(%eax), %ebx
1052    movl MIRROR_CLASS_COMPONENT_TYPE_OFFSET(%ebx), %ebx
1053    // value's type == array's component type - trivial assignability
1054    cmpl MIRROR_OBJECT_CLASS_OFFSET(%edx), %ebx
1055    jne .Lcheck_assignability
1056.Ldo_aput:
1057    movl %edx, MIRROR_OBJECT_ARRAY_DATA_OFFSET(%eax, %ecx, 4)
1058    movl %fs:THREAD_CARD_TABLE_OFFSET, %edx
1059    shrl LITERAL(7), %eax
1060    movb %dl, (%edx, %eax)
1061    ret
1062.Ldo_aput_null:
1063    movl %edx, MIRROR_OBJECT_ARRAY_DATA_OFFSET(%eax, %ecx, 4)
1064    ret
1065.Lcheck_assignability:
1066    PUSH eax                     // save arguments
1067    PUSH ecx
1068    PUSH edx
1069    subl LITERAL(8), %esp        // alignment padding
1070    CFI_ADJUST_CFA_OFFSET(8)
1071    pushl MIRROR_OBJECT_CLASS_OFFSET(%edx)  // pass arg2 - type of the value to be stored
1072    CFI_ADJUST_CFA_OFFSET(4)
1073    PUSH ebx                     // pass arg1 - component type of the array
1074    call SYMBOL(artIsAssignableFromCode)  // (Class* a, Class* b)
1075    addl LITERAL(16), %esp       // pop arguments
1076    CFI_ADJUST_CFA_OFFSET(-16)
1077    testl %eax, %eax
1078    jz   .Lthrow_array_store_exception
1079    POP  edx
1080    POP  ecx
1081    POP  eax
1082    movl %edx, MIRROR_OBJECT_ARRAY_DATA_OFFSET(%eax, %ecx, 4)  // do the aput
1083    movl %fs:THREAD_CARD_TABLE_OFFSET, %edx
1084    shrl LITERAL(7), %eax
1085    movb %dl, (%edx, %eax)
1086    ret
1087.Lthrow_array_store_exception:
1088    POP  edx
1089    POP  ecx
1090    POP  eax
1091    SETUP_SAVE_ALL_CALLEE_SAVE_FRAME ebx, ebx // save all registers as basis for long jump context
1092    // Outgoing argument set up
1093    PUSH eax                      // alignment padding
1094    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
1095    CFI_ADJUST_CFA_OFFSET(4)
1096    PUSH edx                      // pass arg2 - value
1097    PUSH eax                      // pass arg1 - array
1098    call SYMBOL(artThrowArrayStoreException) // (array, value, Thread*)
1099    int3                          // unreached
1100END_FUNCTION art_quick_aput_obj
1101
1102DEFINE_FUNCTION art_quick_memcpy
1103    SETUP_GOT_NOSAVE ebx          // clobbers EBX
1104    PUSH edx                      // pass arg3
1105    PUSH ecx                      // pass arg2
1106    PUSH eax                      // pass arg1
1107    call PLT_SYMBOL(memcpy)       // (void*, const void*, size_t)
1108    addl LITERAL(12), %esp        // pop arguments
1109    CFI_ADJUST_CFA_OFFSET(-12)
1110    ret
1111END_FUNCTION art_quick_memcpy
1112
1113NO_ARG_DOWNCALL art_quick_test_suspend, artTestSuspendFromCode, ret
1114
1115DEFINE_FUNCTION art_quick_d2l
1116    subl LITERAL(12), %esp        // alignment padding, room for argument
1117    CFI_ADJUST_CFA_OFFSET(12)
1118    movsd %xmm0, 0(%esp)          // arg a
1119    call SYMBOL(art_d2l)          // (jdouble a)
1120    addl LITERAL(12), %esp        // pop arguments
1121    CFI_ADJUST_CFA_OFFSET(-12)
1122    ret
1123END_FUNCTION art_quick_d2l
1124
1125DEFINE_FUNCTION art_quick_f2l
1126    subl LITERAL(12), %esp        // alignment padding
1127    CFI_ADJUST_CFA_OFFSET(12)
1128    movss %xmm0, 0(%esp)          // arg a
1129    call SYMBOL(art_f2l)          // (jfloat a)
1130    addl LITERAL(12), %esp        // pop arguments
1131    CFI_ADJUST_CFA_OFFSET(-12)
1132    ret
1133END_FUNCTION art_quick_f2l
1134
1135DEFINE_FUNCTION art_quick_ldiv
1136    subl LITERAL(12), %esp       // alignment padding
1137    CFI_ADJUST_CFA_OFFSET(12)
1138    PUSH ebx                     // pass arg4 b.hi
1139    PUSH edx                     // pass arg3 b.lo
1140    PUSH ecx                     // pass arg2 a.hi
1141    PUSH eax                     // pass arg1 a.lo
1142    call SYMBOL(artLdiv)     // (jlong a, jlong b)
1143    addl LITERAL(28), %esp       // pop arguments
1144    CFI_ADJUST_CFA_OFFSET(-28)
1145    ret
1146END_FUNCTION art_quick_ldiv
1147
1148DEFINE_FUNCTION art_quick_lmod
1149    subl LITERAL(12), %esp       // alignment padding
1150    CFI_ADJUST_CFA_OFFSET(12)
1151    PUSH ebx                     // pass arg4 b.hi
1152    PUSH edx                     // pass arg3 b.lo
1153    PUSH ecx                     // pass arg2 a.hi
1154    PUSH eax                     // pass arg1 a.lo
1155    call SYMBOL(artLmod)     // (jlong a, jlong b)
1156    addl LITERAL(28), %esp       // pop arguments
1157    CFI_ADJUST_CFA_OFFSET(-28)
1158    ret
1159END_FUNCTION art_quick_lmod
1160
1161DEFINE_FUNCTION art_quick_lmul
1162    imul %eax, %ebx              // ebx = a.lo(eax) * b.hi(ebx)
1163    imul %edx, %ecx              // ecx = b.lo(edx) * a.hi(ecx)
1164    mul  %edx                    // edx:eax = a.lo(eax) * b.lo(edx)
1165    add  %ebx, %ecx
1166    add  %ecx, %edx              // edx += (a.lo * b.hi) + (b.lo * a.hi)
1167    ret
1168END_FUNCTION art_quick_lmul
1169
1170DEFINE_FUNCTION art_quick_lshl
1171    // ecx:eax << edx
1172    xchg %edx, %ecx
1173    shld %cl,%eax,%edx
1174    shl  %cl,%eax
1175    test LITERAL(32), %cl
1176    jz  1f
1177    mov %eax, %edx
1178    xor %eax, %eax
11791:
1180    ret
1181END_FUNCTION art_quick_lshl
1182
1183DEFINE_FUNCTION art_quick_lshr
1184    // ecx:eax >> edx
1185    xchg %edx, %ecx
1186    shrd %cl,%edx,%eax
1187    sar  %cl,%edx
1188    test LITERAL(32),%cl
1189    jz  1f
1190    mov %edx, %eax
1191    sar LITERAL(31), %edx
11921:
1193    ret
1194END_FUNCTION art_quick_lshr
1195
1196DEFINE_FUNCTION art_quick_lushr
1197    // ecx:eax >>> edx
1198    xchg %edx, %ecx
1199    shrd %cl,%edx,%eax
1200    shr  %cl,%edx
1201    test LITERAL(32),%cl
1202    jz  1f
1203    mov %edx, %eax
1204    xor %edx, %edx
12051:
1206    ret
1207END_FUNCTION art_quick_lushr
1208
1209ONE_ARG_REF_DOWNCALL art_quick_get_boolean_static, artGetBooleanStaticFromCode, RETURN_OR_DELIVER_PENDING_EXCEPTION
1210ONE_ARG_REF_DOWNCALL art_quick_get_byte_static, artGetByteStaticFromCode, RETURN_OR_DELIVER_PENDING_EXCEPTION
1211ONE_ARG_REF_DOWNCALL art_quick_get_char_static, artGetCharStaticFromCode, RETURN_OR_DELIVER_PENDING_EXCEPTION
1212ONE_ARG_REF_DOWNCALL art_quick_get_short_static, artGetShortStaticFromCode, RETURN_OR_DELIVER_PENDING_EXCEPTION
1213ONE_ARG_REF_DOWNCALL art_quick_get32_static, artGet32StaticFromCode, RETURN_OR_DELIVER_PENDING_EXCEPTION
1214ONE_ARG_REF_DOWNCALL art_quick_get64_static, artGet64StaticFromCode, RETURN_OR_DELIVER_PENDING_EXCEPTION
1215ONE_ARG_REF_DOWNCALL art_quick_get_obj_static, artGetObjStaticFromCode, RETURN_OR_DELIVER_PENDING_EXCEPTION
1216
1217TWO_ARG_REF_DOWNCALL art_quick_get_boolean_instance, artGetBooleanInstanceFromCode, RETURN_OR_DELIVER_PENDING_EXCEPTION
1218TWO_ARG_REF_DOWNCALL art_quick_get_byte_instance, artGetByteInstanceFromCode, RETURN_OR_DELIVER_PENDING_EXCEPTION
1219TWO_ARG_REF_DOWNCALL art_quick_get_char_instance, artGetCharInstanceFromCode, RETURN_OR_DELIVER_PENDING_EXCEPTION
1220TWO_ARG_REF_DOWNCALL art_quick_get_short_instance, artGetShortInstanceFromCode, RETURN_OR_DELIVER_PENDING_EXCEPTION
1221TWO_ARG_REF_DOWNCALL art_quick_get32_instance, artGet32InstanceFromCode, RETURN_OR_DELIVER_PENDING_EXCEPTION
1222TWO_ARG_REF_DOWNCALL art_quick_get64_instance, artGet64InstanceFromCode, RETURN_OR_DELIVER_PENDING_EXCEPTION
1223TWO_ARG_REF_DOWNCALL art_quick_get_obj_instance, artGetObjInstanceFromCode, RETURN_OR_DELIVER_PENDING_EXCEPTION
1224
1225TWO_ARG_REF_DOWNCALL art_quick_set8_static, artSet8StaticFromCode, RETURN_IF_EAX_ZERO
1226TWO_ARG_REF_DOWNCALL art_quick_set16_static, artSet16StaticFromCode, RETURN_IF_EAX_ZERO
1227TWO_ARG_REF_DOWNCALL art_quick_set32_static, artSet32StaticFromCode, RETURN_IF_EAX_ZERO
1228TWO_ARG_REF_DOWNCALL art_quick_set_obj_static, artSetObjStaticFromCode, RETURN_IF_EAX_ZERO
1229
1230THREE_ARG_REF_DOWNCALL art_quick_set8_instance, artSet8InstanceFromCode, RETURN_IF_EAX_ZERO
1231THREE_ARG_REF_DOWNCALL art_quick_set16_instance, artSet16InstanceFromCode, RETURN_IF_EAX_ZERO
1232THREE_ARG_REF_DOWNCALL art_quick_set32_instance, artSet32InstanceFromCode, RETURN_IF_EAX_ZERO
1233THREE_ARG_REF_DOWNCALL art_quick_set_obj_instance, artSetObjInstanceFromCode, RETURN_IF_EAX_ZERO
1234
1235// Call artSet64InstanceFromCode with 4 word size arguments and the referrer.
1236DEFINE_FUNCTION art_quick_set64_instance
1237    movd %ebx, %xmm0
1238    SETUP_REFS_ONLY_CALLEE_SAVE_FRAME ebx, ebx  // save ref containing registers for GC
1239    movd %xmm0, %ebx
1240    // Outgoing argument set up
1241    subl LITERAL(8), %esp         // alignment padding
1242    CFI_ADJUST_CFA_OFFSET(8)
1243    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
1244    CFI_ADJUST_CFA_OFFSET(4)
1245    pushl (FRAME_SIZE_REFS_ONLY_CALLEE_SAVE+12)(%esp)  // pass referrer
1246    CFI_ADJUST_CFA_OFFSET(4)
1247    PUSH ebx                      // pass high half of new_val
1248    PUSH edx                      // pass low half of new_val
1249    PUSH ecx                      // pass object
1250    PUSH eax                      // pass field_idx
1251    call SYMBOL(artSet64InstanceFromCode)  // (field_idx, Object*, new_val, referrer, Thread*)
1252    addl LITERAL(32), %esp        // pop arguments
1253    CFI_ADJUST_CFA_OFFSET(-32)
1254    RESTORE_REFS_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
1255    RETURN_IF_EAX_ZERO            // return or deliver exception
1256END_FUNCTION art_quick_set64_instance
1257
1258// Call artSet64StaticFromCode with 3 word size arguments plus with the referrer in the 2nd position
1259// so that new_val is aligned on even registers were we passing arguments in registers.
1260DEFINE_FUNCTION art_quick_set64_static
1261    SETUP_REFS_ONLY_CALLEE_SAVE_FRAME  ebx, ebx  // save ref containing registers for GC
1262    mov FRAME_SIZE_REFS_ONLY_CALLEE_SAVE(%esp), %ebx  // get referrer
1263    subl LITERAL(12), %esp        // alignment padding
1264    CFI_ADJUST_CFA_OFFSET(12)
1265    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
1266    CFI_ADJUST_CFA_OFFSET(4)
1267    PUSH edx                      // pass high half of new_val
1268    PUSH ecx                      // pass low half of new_val
1269    PUSH ebx                      // pass referrer
1270    PUSH eax                      // pass field_idx
1271    call SYMBOL(artSet64StaticFromCode)  // (field_idx, referrer, new_val, Thread*)
1272    addl LITERAL(32), %esp        // pop arguments
1273    CFI_ADJUST_CFA_OFFSET(-32)
1274    RESTORE_REFS_ONLY_CALLEE_SAVE_FRAME  // restore frame up to return address
1275    RETURN_IF_EAX_ZERO            // return or deliver exception
1276END_FUNCTION art_quick_set64_static
1277
1278DEFINE_FUNCTION art_quick_proxy_invoke_handler
1279    SETUP_REFS_AND_ARGS_CALLEE_SAVE_FRAME_WITH_METHOD_IN_EAX
1280    PUSH esp                      // pass SP
1281    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
1282    CFI_ADJUST_CFA_OFFSET(4)
1283    PUSH ecx                      // pass receiver
1284    PUSH eax                      // pass proxy method
1285    call SYMBOL(artQuickProxyInvokeHandler) // (proxy method, receiver, Thread*, SP)
1286    movd %eax, %xmm0              // place return value also into floating point return value
1287    movd %edx, %xmm1
1288    punpckldq %xmm1, %xmm0
1289    addl LITERAL(76), %esp        // pop arguments
1290    CFI_ADJUST_CFA_OFFSET(-76)
1291    RETURN_OR_DELIVER_PENDING_EXCEPTION    // return or deliver exception
1292END_FUNCTION art_quick_proxy_invoke_handler
1293
1294    /*
1295     * Called to resolve an imt conflict. xmm0 is a hidden argument that holds the target method's
1296     * dex method index.
1297     */
1298DEFINE_FUNCTION art_quick_imt_conflict_trampoline
1299    PUSH ecx
1300    movl 8(%esp), %eax            // load caller Method*
1301    movl MIRROR_ART_METHOD_DEX_CACHE_METHODS_OFFSET(%eax), %eax  // load dex_cache_resolved_methods
1302    movd %xmm7, %ecx              // get target method index stored in xmm0
1303    movl MIRROR_OBJECT_ARRAY_DATA_OFFSET(%eax, %ecx, 4), %eax  // load the target method
1304    POP ecx
1305    jmp SYMBOL(art_quick_invoke_interface_trampoline)
1306END_FUNCTION art_quick_imt_conflict_trampoline
1307
1308DEFINE_FUNCTION art_quick_resolution_trampoline
1309    SETUP_REFS_AND_ARGS_CALLEE_SAVE_FRAME ebx, ebx
1310    movl %esp, %edi
1311    PUSH EDI                      // pass SP. do not just PUSH ESP; that messes up unwinding
1312    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
1313    CFI_ADJUST_CFA_OFFSET(4)
1314    PUSH ecx                      // pass receiver
1315    PUSH eax                      // pass method
1316    call SYMBOL(artQuickResolutionTrampoline) // (Method* called, receiver, Thread*, SP)
1317    movl %eax, %edi               // remember code pointer in EDI
1318    addl LITERAL(16), %esp        // pop arguments
1319    test %eax, %eax               // if code pointer is NULL goto deliver pending exception
1320    jz 1f
1321    RESTORE_REFS_AND_ARGS_CALLEE_SAVE_FRAME_AND_JUMP
13221:
1323    RESTORE_REFS_AND_ARGS_CALLEE_SAVE_FRAME
1324    DELIVER_PENDING_EXCEPTION
1325END_FUNCTION art_quick_resolution_trampoline
1326
1327DEFINE_FUNCTION art_quick_generic_jni_trampoline
1328    SETUP_REFS_AND_ARGS_CALLEE_SAVE_FRAME_WITH_METHOD_IN_EAX
1329    movl %esp, %ebp                 // save SP at callee-save frame
1330    CFI_DEF_CFA_REGISTER(ebp)
1331    subl LITERAL(5120), %esp
1332    // prepare for artQuickGenericJniTrampoline call
1333    // (Thread*,  SP)
1334    //  (esp)    4(esp)   <= C calling convention
1335    //  fs:...    ebp     <= where they are
1336
1337    subl LITERAL(8), %esp         // Padding for 16B alignment.
1338    pushl %ebp                    // Pass SP (to ArtMethod).
1339    pushl %fs:THREAD_SELF_OFFSET  // Pass Thread::Current().
1340    call SYMBOL(artQuickGenericJniTrampoline)  // (Thread*, sp)
1341
1342    // The C call will have registered the complete save-frame on success.
1343    // The result of the call is:
1344    // eax: pointer to native code, 0 on error.
1345    // edx: pointer to the bottom of the used area of the alloca, can restore stack till there.
1346
1347    // Check for error = 0.
1348    test %eax, %eax
1349    jz .Lentry_error
1350
1351    // Release part of the alloca.
1352    movl %edx, %esp
1353
1354    // On x86 there are no registers passed, so nothing to pop here.
1355    // Native call.
1356    call *%eax
1357
1358    // result sign extension is handled in C code
1359    // prepare for artQuickGenericJniEndTrampoline call
1360    // (Thread*, result, result_f)
1361    //  (esp)    4(esp)  12(esp)    <= C calling convention
1362    //  fs:...  eax:edx   fp0      <= where they are
1363
1364    subl LITERAL(20), %esp         // Padding & pass float result.
1365    fstpl (%esp)
1366    pushl %edx                    // Pass int result.
1367    pushl %eax
1368    pushl %fs:THREAD_SELF_OFFSET  // Pass Thread::Current().
1369    call SYMBOL(artQuickGenericJniEndTrampoline)
1370
1371    // Tear down the alloca.
1372    movl %ebp, %esp
1373    CFI_DEF_CFA_REGISTER(esp)
1374
1375    // Pending exceptions possible.
1376    mov %fs:THREAD_EXCEPTION_OFFSET, %ebx
1377    testl %ebx, %ebx
1378    jnz .Lexception_in_native
1379
1380    // Tear down the callee-save frame.
1381    // Remove space for FPR args and EAX
1382    addl LITERAL(4 + 4 * 8), %esp
1383    CFI_ADJUST_CFA_OFFSET(-(4 + 4 * 8))
1384
1385    POP ecx
1386    addl LITERAL(4), %esp     // Avoid edx, as it may be part of the result.
1387    CFI_ADJUST_CFA_OFFSET(-4)
1388    POP ebx
1389    POP ebp  // Restore callee saves
1390    POP esi
1391    POP edi
1392    // Quick expects the return value to be in xmm0.
1393    movd %eax, %xmm0
1394    movd %edx, %xmm1
1395    punpckldq %xmm1, %xmm0
1396    ret
1397.Lentry_error:
1398    movl %ebp, %esp
1399    CFI_DEF_CFA_REGISTER(esp)
1400.Lexception_in_native:
1401    RESTORE_REFS_AND_ARGS_CALLEE_SAVE_FRAME
1402    DELIVER_PENDING_EXCEPTION
1403END_FUNCTION art_quick_generic_jni_trampoline
1404
1405DEFINE_FUNCTION art_quick_to_interpreter_bridge
1406    SETUP_REFS_AND_ARGS_CALLEE_SAVE_FRAME  ebx, ebx  // save frame
1407    mov %esp, %edx                // remember SP
1408    PUSH eax                      // alignment padding
1409    PUSH edx                      // pass SP
1410    pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
1411    CFI_ADJUST_CFA_OFFSET(4)
1412    PUSH eax                      // pass  method
1413    call SYMBOL(artQuickToInterpreterBridge)  // (method, Thread*, SP)
1414    addl LITERAL(16), %esp        // pop arguments
1415    CFI_ADJUST_CFA_OFFSET(-16)
1416
1417    // Return eax:edx in xmm0 also.
1418    movd %eax, %xmm0
1419    movd %edx, %xmm1
1420    punpckldq %xmm1, %xmm0
1421
1422    addl LITERAL(48), %esp        // Remove FPRs and EAX, ECX, EDX, EBX.
1423    CFI_ADJUST_CFA_OFFSET(-48)
1424
1425    POP ebp  // Restore callee saves
1426    POP esi
1427    POP edi
1428
1429    RETURN_OR_DELIVER_PENDING_EXCEPTION    // return or deliver exception
1430END_FUNCTION art_quick_to_interpreter_bridge
1431
1432    /*
1433     * Routine that intercepts method calls and returns.
1434     */
1435DEFINE_FUNCTION art_quick_instrumentation_entry
1436    SETUP_REFS_AND_ARGS_CALLEE_SAVE_FRAME ebx, edx
1437    PUSH eax                      // Save eax which will be clobbered by the callee-save method.
1438    subl LITERAL(12), %esp        // Align stack.
1439    CFI_ADJUST_CFA_OFFSET(12)
1440    pushl FRAME_SIZE_REFS_AND_ARGS_CALLEE_SAVE-4+16(%esp)  // Pass LR.
1441    CFI_ADJUST_CFA_OFFSET(4)
1442    pushl %fs:THREAD_SELF_OFFSET  // Pass Thread::Current().
1443    CFI_ADJUST_CFA_OFFSET(4)
1444    PUSH ecx                      // Pass receiver.
1445    PUSH eax                      // Pass Method*.
1446    call SYMBOL(artInstrumentationMethodEntryFromCode) // (Method*, Object*, Thread*, LR)
1447    addl LITERAL(28), %esp        // Pop arguments upto saved Method*.
1448    movl 60(%esp), %edi           // Restore edi.
1449    movl %eax, 60(%esp)           // Place code* over edi, just under return pc.
1450    movl SYMBOL(art_quick_instrumentation_exit)@GOT(%ebx), %ebx
1451    // Place instrumentation exit as return pc. ebx holds the GOT computed on entry.
1452    movl %ebx, 64(%esp)
1453    movl 0(%esp), %eax           // Restore eax.
1454    // Restore FPRs (extra 4 bytes of offset due to EAX push at top).
1455    movsd 8(%esp), %xmm0
1456    movsd 16(%esp), %xmm1
1457    movsd 24(%esp), %xmm2
1458    movsd 32(%esp), %xmm3
1459
1460    // Restore GPRs.
1461    movl 40(%esp), %ecx           // Restore ecx.
1462    movl 48(%esp), %edx           // Restore edx.
1463    movl 48(%esp), %ebx           // Restore ebx.
1464    movl 52(%esp), %ebp           // Restore ebp.
1465    movl 56(%esp), %esi           // Restore esi.
1466    addl LITERAL(60), %esp        // Wind stack back upto code*.
1467    ret                           // Call method (and pop).
1468END_FUNCTION art_quick_instrumentation_entry
1469
1470DEFINE_FUNCTION art_quick_instrumentation_exit
1471    pushl LITERAL(0)              // Push a fake return PC as there will be none on the stack.
1472    SETUP_REFS_ONLY_CALLEE_SAVE_FRAME ebx, ebx
1473    mov  %esp, %ecx               // Remember SP
1474    subl LITERAL(8), %esp         // Save float return value.
1475    CFI_ADJUST_CFA_OFFSET(8)
1476    movq %xmm0, (%esp)
1477    PUSH edx                      // Save gpr return value.
1478    PUSH eax
1479    subl LITERAL(16), %esp        // Align stack
1480    CFI_ADJUST_CFA_OFFSET(16)
1481    movq %xmm0, (%esp)            // Pass float return value.
1482    PUSH edx                      // Pass gpr return value.
1483    PUSH eax
1484    PUSH ecx                      // Pass SP.
1485    pushl %fs:THREAD_SELF_OFFSET  // Pass Thread::Current.
1486    CFI_ADJUST_CFA_OFFSET(4)
1487    call SYMBOL(artInstrumentationMethodExitFromCode)  // (Thread*, SP, gpr_result, fpr_result)
1488    mov   %eax, %ecx              // Move returned link register.
1489    addl LITERAL(32), %esp        // Pop arguments.
1490    CFI_ADJUST_CFA_OFFSET(-32)
1491    movl %edx, %ebx               // Move returned link register for deopt
1492                                  // (ebx is pretending to be our LR).
1493    POP eax                       // Restore gpr return value.
1494    POP edx
1495    movq (%esp), %xmm0            // Restore fpr return value.
1496    addl LITERAL(8), %esp
1497    CFI_ADJUST_CFA_OFFSET(-8)
1498    RESTORE_REFS_ONLY_CALLEE_SAVE_FRAME
1499    addl LITERAL(4), %esp         // Remove fake return pc.
1500    jmp   *%ecx                   // Return.
1501END_FUNCTION art_quick_instrumentation_exit
1502
1503    /*
1504     * Instrumentation has requested that we deoptimize into the interpreter. The deoptimization
1505     * will long jump to the upcall with a special exception of -1.
1506     */
1507DEFINE_FUNCTION art_quick_deoptimize
1508    pushl %ebx                    // Fake that we were called.
1509    SETUP_SAVE_ALL_CALLEE_SAVE_FRAME ebx, ebx
1510    subl LITERAL(12), %esp        // Align stack.
1511    CFI_ADJUST_CFA_OFFSET(12)
1512    pushl %fs:THREAD_SELF_OFFSET  // Pass Thread::Current().
1513    CFI_ADJUST_CFA_OFFSET(4)
1514    call SYMBOL(artDeoptimize)    // artDeoptimize(Thread*)
1515    int3                          // Unreachable.
1516END_FUNCTION art_quick_deoptimize
1517
1518    /*
1519     * String's compareTo.
1520     *
1521     * On entry:
1522     *    eax:   this string object (known non-null)
1523     *    ecx:   comp string object (known non-null)
1524     */
1525DEFINE_FUNCTION art_quick_string_compareto
1526    PUSH esi                    // push callee save reg
1527    PUSH edi                    // push callee save reg
1528    mov MIRROR_STRING_COUNT_OFFSET(%eax), %edx
1529    mov MIRROR_STRING_COUNT_OFFSET(%ecx), %ebx
1530    mov MIRROR_STRING_VALUE_OFFSET(%eax), %esi
1531    mov MIRROR_STRING_VALUE_OFFSET(%ecx), %edi
1532    mov MIRROR_STRING_OFFSET_OFFSET(%eax), %eax
1533    mov MIRROR_STRING_OFFSET_OFFSET(%ecx), %ecx
1534    /* Build pointers to the start of string data */
1535    lea  MIRROR_CHAR_ARRAY_DATA_OFFSET(%esi, %eax, 2), %esi
1536    lea  MIRROR_CHAR_ARRAY_DATA_OFFSET(%edi, %ecx, 2), %edi
1537    /* Calculate min length and count diff */
1538    mov   %edx, %ecx
1539    mov   %edx, %eax
1540    subl  %ebx, %eax
1541    cmovg %ebx, %ecx
1542    /*
1543     * At this point we have:
1544     *   eax: value to return if first part of strings are equal
1545     *   ecx: minimum among the lengths of the two strings
1546     *   esi: pointer to this string data
1547     *   edi: pointer to comp string data
1548     */
1549    jecxz .Lkeep_length
1550    repe cmpsw                    // find nonmatching chars in [%esi] and [%edi], up to length %ecx
1551    jne .Lnot_equal
1552.Lkeep_length:
1553    POP edi                       // pop callee save reg
1554    POP esi                       // pop callee save reg
1555    ret
1556    .balign 16
1557.Lnot_equal:
1558    movzwl  -2(%esi), %eax        // get last compared char from this string
1559    movzwl  -2(%edi), %ecx        // get last compared char from comp string
1560    subl  %ecx, %eax              // return the difference
1561    POP edi                       // pop callee save reg
1562    POP esi                       // pop callee save reg
1563    ret
1564END_FUNCTION art_quick_string_compareto
1565
1566// Return from a nested signal:
1567// Entry:
1568//  eax: address of jmp_buf in TLS
1569
1570DEFINE_FUNCTION art_nested_signal_return
1571    SETUP_GOT_NOSAVE ebx            // sets %ebx for call into PLT
1572    movl LITERAL(1), %ecx
1573    pushl %ecx                      // second arg to longjmp (1)
1574    pushl %eax                      // first arg to longjmp (jmp_buf)
1575    call PLT_SYMBOL(longjmp)
1576    int3                            // won't get here.
1577END_FUNCTION art_nested_signal_return
1578
1579    // TODO: implement these!
1580UNIMPLEMENTED art_quick_memcmp16
1581