Debian Codegraph @

src/powerpc/linux64_closure.S

raw
1 /* -----------------------------------------------------------------------
2 sysv.h - Copyright (c) 2003 Jakub Jelinek <[email protected]>
3 Copyright (c) 2008 Red Hat, Inc.
4
5 PowerPC64 Assembly glue.
6
7 Permission is hereby granted, free of charge, to any person obtaining
8 a copy of this software and associated documentation files (the
9 ``Software''), to deal in the Software without restriction, including
10 without limitation the rights to use, copy, modify, merge, publish,
11 distribute, sublicense, and/or sell copies of the Software, and to
12 permit persons to whom the Software is furnished to do so, subject to
13 the following conditions:
14
15 The above copyright notice and this permission notice shall be included
16 in all copies or substantial portions of the Software.
17
18 THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
19 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
21 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
22 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
23 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
25 DEALINGS IN THE SOFTWARE.
26 ----------------------------------------------------------------------- */
27 #define LIBFFI_ASM
28 #include <fficonfig.h>
29 #include <ffi.h>
30 #include "internal.h"
31
32 .file "linux64_closure.S"
33
34 .machine altivec
35
36 #ifdef POWERPC64
37 FFI_HIDDEN (ffi_closure_LINUX64)
38 .globl ffi_closure_LINUX64
39 .text
40 .cfi_startproc
41 # if _CALL_ELF == 2
42 ffi_closure_LINUX64:
43 # ifndef __PCREL__
44 addis %r2, %r12, .TOC.-ffi_closure_LINUX64@ha
45 addi %r2, %r2, .TOC.-ffi_closure_LINUX64@l
46 # endif
47 .localentry ffi_closure_LINUX64, . - ffi_closure_LINUX64
48 # else
49 .section ".opd","aw"
50 .align 3
51 ffi_closure_LINUX64:
52 # ifdef _CALL_LINUX
53 .quad .L.ffi_closure_LINUX64,.TOC.@tocbase,0
54 .type ffi_closure_LINUX64,@function
55 .text
56 .L.ffi_closure_LINUX64:
57 # else
58 FFI_HIDDEN (.ffi_closure_LINUX64)
59 .globl .ffi_closure_LINUX64
60 .quad .ffi_closure_LINUX64,.TOC.@tocbase,0
61 .size ffi_closure_LINUX64,24
62 .type .ffi_closure_LINUX64,@function
63 .text
64 .ffi_closure_LINUX64:
65 # endif
66 # endif
67
68 # if _CALL_ELF == 2
69 # ifdef __VEC__
70 # 32 byte special reg save area + 64 byte parm save area
71 # + 128 byte retval area + 13*8 fpr save area + 12*16 vec save area + round to 16
72 # define STACKFRAME 528
73 # else
74 # 32 byte special reg save area + 64 byte parm save area
75 # + 64 byte retval area + 13*8 fpr save area + round to 16
76 # define STACKFRAME 272
77 # endif
78 # define PARMSAVE 32
79 # define RETVAL PARMSAVE+64
80 # else
81 # 48 bytes special reg save area + 64 bytes parm save area
82 # + 16 bytes retval area + 13*8 bytes fpr save area + round to 16
83 # define STACKFRAME 240
84 # define PARMSAVE 48
85 # define RETVAL PARMSAVE+64
86 # endif
87
88 # if _CALL_ELF == 2
89 ld %r12, FFI_TRAMPOLINE_SIZE(%r11) # closure->cif
90 mflr %r0
91 lwz %r12, 28(%r12) # cif->flags
92 mtcrf 0x40, %r12
93 addi %r12, %r1, PARMSAVE
94 bt 7, 0f
95 # Our caller has not allocated a parameter save area.
96 # We need to allocate one here and use it to pass gprs to
97 # ffi_closure_helper_LINUX64.
98 addi %r12, %r1, -STACKFRAME+PARMSAVE
99 0:
100 # Save general regs into parm save area
101 std %r3, 0(%r12)
102 std %r4, 8(%r12)
103 std %r5, 16(%r12)
104 std %r6, 24(%r12)
105 std %r7, 32(%r12)
106 std %r8, 40(%r12)
107 std %r9, 48(%r12)
108 std %r10, 56(%r12)
109
110 # load up the pointer to the parm save area
111 mr %r7, %r12
112 # else
113 # copy r2 to r11 and load TOC into r2
114 mr %r11, %r2
115 ld %r2, 16(%r2)
116
117 mflr %r0
118 # Save general regs into parm save area
119 # This is the parameter save area set up by our caller.
120 std %r3, PARMSAVE+0(%r1)
121 std %r4, PARMSAVE+8(%r1)
122 std %r5, PARMSAVE+16(%r1)
123 std %r6, PARMSAVE+24(%r1)
124 std %r7, PARMSAVE+32(%r1)
125 std %r8, PARMSAVE+40(%r1)
126 std %r9, PARMSAVE+48(%r1)
127 std %r10, PARMSAVE+56(%r1)
128
129 # load up the pointer to the parm save area
130 addi %r7, %r1, PARMSAVE
131 # endif
132 std %r0, 16(%r1)
133
134 # closure->cif
135 ld %r3, FFI_TRAMPOLINE_SIZE(%r11)
136 # closure->fun
137 ld %r4, FFI_TRAMPOLINE_SIZE+8(%r11)
138 # closure->user_data
139 ld %r5, FFI_TRAMPOLINE_SIZE+16(%r11)
140
141 .Ldoclosure:
142 # next save fpr 1 to fpr 13
143 stfd %f1, -104+(0*8)(%r1)
144 stfd %f2, -104+(1*8)(%r1)
145 stfd %f3, -104+(2*8)(%r1)
146 stfd %f4, -104+(3*8)(%r1)
147 stfd %f5, -104+(4*8)(%r1)
148 stfd %f6, -104+(5*8)(%r1)
149 stfd %f7, -104+(6*8)(%r1)
150 stfd %f8, -104+(7*8)(%r1)
151 stfd %f9, -104+(8*8)(%r1)
152 stfd %f10, -104+(9*8)(%r1)
153 stfd %f11, -104+(10*8)(%r1)
154 stfd %f12, -104+(11*8)(%r1)
155 stfd %f13, -104+(12*8)(%r1)
156
157 # load up the pointer to the saved fpr registers
158 addi %r8, %r1, -104
159
160 # ifdef __VEC__
161 # load up the pointer to the saved vector registers
162 # 8 bytes padding for 16-byte alignment at -112(%r1)
163 addi %r9, %r8, -24
164 stvx %v13, 0, %r9
165 addi %r9, %r9, -16
166 stvx %v12, 0, %r9
167 addi %r9, %r9, -16
168 stvx %v11, 0, %r9
169 addi %r9, %r9, -16
170 stvx %v10, 0, %r9
171 addi %r9, %r9, -16
172 stvx %v9, 0, %r9
173 addi %r9, %r9, -16
174 stvx %v8, 0, %r9
175 addi %r9, %r9, -16
176 stvx %v7, 0, %r9
177 addi %r9, %r9, -16
178 stvx %v6, 0, %r9
179 addi %r9, %r9, -16
180 stvx %v5, 0, %r9
181 addi %r9, %r9, -16
182 stvx %v4, 0, %r9
183 addi %r9, %r9, -16
184 stvx %v3, 0, %r9
185 addi %r9, %r9, -16
186 stvx %v2, 0, %r9
187 # endif
188
189 # load up the pointer to the result storage
190 addi %r6, %r1, -STACKFRAME+RETVAL
191
192 stdu %r1, -STACKFRAME(%r1)
193 .cfi_def_cfa_offset STACKFRAME
194 .cfi_offset 65, 16
195
196 # make the call
197 # if defined _CALL_LINUX || _CALL_ELF == 2
198 # ifdef __PCREL__
199 bl ffi_closure_helper_LINUX64@notoc
200 .Lret:
201 # else
202 bl ffi_closure_helper_LINUX64
203 .Lret:
204 nop
205 # endif
206 # else
207 bl .ffi_closure_helper_LINUX64
208 .Lret:
209 nop
210 # endif
211
212 # now r3 contains the return type
213 # so use it to look up in a table
214 # so we know how to deal with each type
215
216 # look up the proper starting point in table
217 # by using return type as offset
218 ld %r0, STACKFRAME+16(%r1)
219 cmpldi %r3, FFI_V2_TYPE_SMALL_STRUCT
220 bge .Lsmall
221 mflr %r4 # move address of .Lret to r4
222 sldi %r3, %r3, 4 # now multiply return type by 16
223 addi %r4, %r4, .Lret_type0 - .Lret
224 add %r3, %r3, %r4 # add contents of table to table address
225 mtctr %r3
226 bctr # jump to it
227
228 # Each of the ret_typeX code fragments has to be exactly 16 bytes long
229 # (4 instructions). For cache effectiveness we align to a 16 byte boundary
230 # first.
231 .align 4
232
233 .Lret_type0:
234 # case FFI_TYPE_VOID
235 mtlr %r0
236 addi %r1, %r1, STACKFRAME
237 .cfi_def_cfa_offset 0
238 blr
239 .cfi_def_cfa_offset STACKFRAME
240 nop
241 # case FFI_TYPE_INT
242 # ifdef __LITTLE_ENDIAN__
243 lwa %r3, RETVAL+0(%r1)
244 # else
245 lwa %r3, RETVAL+4(%r1)
246 # endif
247 mtlr %r0
248 addi %r1, %r1, STACKFRAME
249 .cfi_def_cfa_offset 0
250 blr
251 .cfi_def_cfa_offset STACKFRAME
252 # case FFI_TYPE_FLOAT
253 lfs %f1, RETVAL+0(%r1)
254 mtlr %r0
255 addi %r1, %r1, STACKFRAME
256 .cfi_def_cfa_offset 0
257 blr
258 .cfi_def_cfa_offset STACKFRAME
259 # case FFI_TYPE_DOUBLE
260 lfd %f1, RETVAL+0(%r1)
261 mtlr %r0
262 addi %r1, %r1, STACKFRAME
263 .cfi_def_cfa_offset 0
264 blr
265 .cfi_def_cfa_offset STACKFRAME
266 # case FFI_TYPE_LONGDOUBLE
267 lfd %f1, RETVAL+0(%r1)
268 mtlr %r0
269 lfd %f2, RETVAL+8(%r1)
270 b .Lfinish
271 # case FFI_TYPE_UINT8
272 # ifdef __LITTLE_ENDIAN__
273 lbz %r3, RETVAL+0(%r1)
274 # else
275 lbz %r3, RETVAL+7(%r1)
276 # endif
277 mtlr %r0
278 addi %r1, %r1, STACKFRAME
279 .cfi_def_cfa_offset 0
280 blr
281 .cfi_def_cfa_offset STACKFRAME
282 # case FFI_TYPE_SINT8
283 # ifdef __LITTLE_ENDIAN__
284 lbz %r3, RETVAL+0(%r1)
285 # else
286 lbz %r3, RETVAL+7(%r1)
287 # endif
288 extsb %r3,%r3
289 mtlr %r0
290 b .Lfinish
291 # case FFI_TYPE_UINT16
292 # ifdef __LITTLE_ENDIAN__
293 lhz %r3, RETVAL+0(%r1)
294 # else
295 lhz %r3, RETVAL+6(%r1)
296 # endif
297 mtlr %r0
298 .Lfinish:
299 addi %r1, %r1, STACKFRAME
300 .cfi_def_cfa_offset 0
301 blr
302 .cfi_def_cfa_offset STACKFRAME
303 # case FFI_TYPE_SINT16
304 # ifdef __LITTLE_ENDIAN__
305 lha %r3, RETVAL+0(%r1)
306 # else
307 lha %r3, RETVAL+6(%r1)
308 # endif
309 mtlr %r0
310 addi %r1, %r1, STACKFRAME
311 .cfi_def_cfa_offset 0
312 blr
313 .cfi_def_cfa_offset STACKFRAME
314 # case FFI_TYPE_UINT32
315 # ifdef __LITTLE_ENDIAN__
316 lwz %r3, RETVAL+0(%r1)
317 # else
318 lwz %r3, RETVAL+4(%r1)
319 # endif
320 mtlr %r0
321 addi %r1, %r1, STACKFRAME
322 .cfi_def_cfa_offset 0
323 blr
324 .cfi_def_cfa_offset STACKFRAME
325 # case FFI_TYPE_SINT32
326 # ifdef __LITTLE_ENDIAN__
327 lwa %r3, RETVAL+0(%r1)
328 # else
329 lwa %r3, RETVAL+4(%r1)
330 # endif
331 mtlr %r0
332 addi %r1, %r1, STACKFRAME
333 .cfi_def_cfa_offset 0
334 blr
335 .cfi_def_cfa_offset STACKFRAME
336 # case FFI_TYPE_UINT64
337 ld %r3, RETVAL+0(%r1)
338 mtlr %r0
339 addi %r1, %r1, STACKFRAME
340 .cfi_def_cfa_offset 0
341 blr
342 .cfi_def_cfa_offset STACKFRAME
343 # case FFI_TYPE_SINT64
344 ld %r3, RETVAL+0(%r1)
345 mtlr %r0
346 addi %r1, %r1, STACKFRAME
347 .cfi_def_cfa_offset 0
348 blr
349 .cfi_def_cfa_offset STACKFRAME
350 # case FFI_TYPE_STRUCT
351 mtlr %r0
352 addi %r1, %r1, STACKFRAME
353 .cfi_def_cfa_offset 0
354 blr
355 .cfi_def_cfa_offset STACKFRAME
356 nop
357 # case FFI_TYPE_POINTER
358 ld %r3, RETVAL+0(%r1)
359 mtlr %r0
360 addi %r1, %r1, STACKFRAME
361 .cfi_def_cfa_offset 0
362 blr
363 .cfi_def_cfa_offset STACKFRAME
364 # case FFI_V2_TYPE_VECTOR
365 addi %r3, %r1, RETVAL
366 lvx %v2, 0, %r3
367 mtlr %r0
368 b .Lfinish
369 # case FFI_V2_TYPE_VECTOR_HOMOG
370 addi %r3, %r1, RETVAL
371 lvx %v2, 0, %r3
372 addi %r3, %r3, 16
373 b .Lmorevector
374 # case FFI_V2_TYPE_FLOAT_HOMOG
375 lfs %f1, RETVAL+0(%r1)
376 lfs %f2, RETVAL+4(%r1)
377 lfs %f3, RETVAL+8(%r1)
378 b .Lmorefloat
379 # case FFI_V2_TYPE_DOUBLE_HOMOG
380 lfd %f1, RETVAL+0(%r1)
381 lfd %f2, RETVAL+8(%r1)
382 lfd %f3, RETVAL+16(%r1)
383 lfd %f4, RETVAL+24(%r1)
384 mtlr %r0
385 lfd %f5, RETVAL+32(%r1)
386 lfd %f6, RETVAL+40(%r1)
387 lfd %f7, RETVAL+48(%r1)
388 lfd %f8, RETVAL+56(%r1)
389 addi %r1, %r1, STACKFRAME
390 .cfi_def_cfa_offset 0
391 blr
392 .cfi_def_cfa_offset STACKFRAME
393 .Lmorevector:
394 lvx %v3, 0, %r3
395 addi %r3, %r3, 16
396 lvx %v4, 0, %r3
397 addi %r3, %r3, 16
398 lvx %v5, 0, %r3
399 mtlr %r0
400 addi %r3, %r3, 16
401 lvx %v6, 0, %r3
402 addi %r3, %r3, 16
403 lvx %v7, 0, %r3
404 addi %r3, %r3, 16
405 lvx %v8, 0, %r3
406 addi %r3, %r3, 16
407 lvx %v9, 0, %r3
408 addi %r1, %r1, STACKFRAME
409 .cfi_def_cfa_offset 0
410 blr
411 .cfi_def_cfa_offset STACKFRAME
412 .Lmorefloat:
413 lfs %f4, RETVAL+12(%r1)
414 mtlr %r0
415 lfs %f5, RETVAL+16(%r1)
416 lfs %f6, RETVAL+20(%r1)
417 lfs %f7, RETVAL+24(%r1)
418 lfs %f8, RETVAL+28(%r1)
419 addi %r1, %r1, STACKFRAME
420 .cfi_def_cfa_offset 0
421 blr
422 .cfi_def_cfa_offset STACKFRAME
423 .Lsmall:
424 # ifdef __LITTLE_ENDIAN__
425 ld %r3,RETVAL+0(%r1)
426 mtlr %r0
427 ld %r4,RETVAL+8(%r1)
428 addi %r1, %r1, STACKFRAME
429 .cfi_def_cfa_offset 0
430 blr
431 # else
432 # A struct smaller than a dword is returned in the low bits of r3
433 # ie. right justified. Larger structs are passed left justified
434 # in r3 and r4. The return value area on the stack will have
435 # the structs as they are usually stored in memory.
436 cmpldi %r3, FFI_V2_TYPE_SMALL_STRUCT + 7 # size 8 bytes?
437 neg %r5, %r3
438 ld %r3,RETVAL+0(%r1)
439 blt .Lsmalldown
440 mtlr %r0
441 ld %r4,RETVAL+8(%r1)
442 addi %r1, %r1, STACKFRAME
443 .cfi_def_cfa_offset 0
444 blr
445 .cfi_def_cfa_offset STACKFRAME
446 .Lsmalldown:
447 addi %r5, %r5, FFI_V2_TYPE_SMALL_STRUCT + 7
448 mtlr %r0
449 sldi %r5, %r5, 3
450 addi %r1, %r1, STACKFRAME
451 .cfi_def_cfa_offset 0
452 srd %r3, %r3, %r5
453 blr
454 # endif
455
456 .cfi_endproc
457 # if _CALL_ELF == 2
458 .size ffi_closure_LINUX64,.-ffi_closure_LINUX64
459 # else
460 # ifdef _CALL_LINUX
461 .size ffi_closure_LINUX64,.-.L.ffi_closure_LINUX64
462 # else
463 .long 0
464 .byte 0,12,0,1,128,0,0,0
465 .size .ffi_closure_LINUX64,.-.ffi_closure_LINUX64
466 # endif
467 # endif
468
469
470 FFI_HIDDEN (ffi_go_closure_linux64)
471 .globl ffi_go_closure_linux64
472 .text
473 .cfi_startproc
474 # if _CALL_ELF == 2
475 ffi_go_closure_linux64:
476 # ifndef __PCREL__
477 addis %r2, %r12, .TOC.-ffi_go_closure_linux64@ha
478 addi %r2, %r2, .TOC.-ffi_go_closure_linux64@l
479 # endif
480 .localentry ffi_go_closure_linux64, . - ffi_go_closure_linux64
481 # else
482 .section ".opd","aw"
483 .align 3
484 ffi_go_closure_linux64:
485 # ifdef _CALL_LINUX
486 .quad .L.ffi_go_closure_linux64,.TOC.@tocbase,0
487 .type ffi_go_closure_linux64,@function
488 .text
489 .L.ffi_go_closure_linux64:
490 # else
491 FFI_HIDDEN (.ffi_go_closure_linux64)
492 .globl .ffi_go_closure_linux64
493 .quad .ffi_go_closure_linux64,.TOC.@tocbase,0
494 .size ffi_go_closure_linux64,24
495 .type .ffi_go_closure_linux64,@function
496 .text
497 .ffi_go_closure_linux64:
498 # endif
499 # endif
500
501 # if _CALL_ELF == 2
502 ld %r12, 8(%r11) # closure->cif
503 mflr %r0
504 lwz %r12, 28(%r12) # cif->flags
505 mtcrf 0x40, %r12
506 addi %r12, %r1, PARMSAVE
507 bt 7, 0f
508 # Our caller has not allocated a parameter save area.
509 # We need to allocate one here and use it to pass gprs to
510 # ffi_closure_helper_LINUX64.
511 addi %r12, %r1, -STACKFRAME+PARMSAVE
512 0:
513 # Save general regs into parm save area
514 std %r3, 0(%r12)
515 std %r4, 8(%r12)
516 std %r5, 16(%r12)
517 std %r6, 24(%r12)
518 std %r7, 32(%r12)
519 std %r8, 40(%r12)
520 std %r9, 48(%r12)
521 std %r10, 56(%r12)
522
523 # load up the pointer to the parm save area
524 mr %r7, %r12
525 # else
526 mflr %r0
527 # Save general regs into parm save area
528 # This is the parameter save area set up by our caller.
529 std %r3, PARMSAVE+0(%r1)
530 std %r4, PARMSAVE+8(%r1)
531 std %r5, PARMSAVE+16(%r1)
532 std %r6, PARMSAVE+24(%r1)
533 std %r7, PARMSAVE+32(%r1)
534 std %r8, PARMSAVE+40(%r1)
535 std %r9, PARMSAVE+48(%r1)
536 std %r10, PARMSAVE+56(%r1)
537
538 # load up the pointer to the parm save area
539 addi %r7, %r1, PARMSAVE
540 # endif
541 std %r0, 16(%r1)
542
543 # closure->cif
544 ld %r3, 8(%r11)
545 # closure->fun
546 ld %r4, 16(%r11)
547 # user_data
548 mr %r5, %r11
549 b .Ldoclosure
550
551 .cfi_endproc
552 # if _CALL_ELF == 2
553 .size ffi_go_closure_linux64,.-ffi_go_closure_linux64
554 # else
555 # ifdef _CALL_LINUX
556 .size ffi_go_closure_linux64,.-.L.ffi_go_closure_linux64
557 # else
558 .long 0
559 .byte 0,12,0,1,128,0,0,0
560 .size .ffi_go_closure_linux64,.-.ffi_go_closure_linux64
561 # endif
562 # endif
563
564 #ifdef FFI_EXEC_STATIC_TRAMP
565 .text
566 .align PPC_TRAMP_MAP_SHIFT
567 FFI_HIDDEN (trampoline_code_table)
568 .globl trampoline_code_table
569 # if _CALL_ELF == 2
570 .type trampoline_code_table,@function
571 trampoline_code_table:
572 .localentry trampoline_code_table,.-trampoline_code_table
573 # else
574 .section ".opd","aw"
575 .align 3
576 trampoline_code_table:
577 .quad .L.trampoline_code_table,.TOC.@tocbase,0
578 .type trampoline_code_table,@function
579 .text
580 .L.trampoline_code_table:
581 # endif
582 .rept PPC_TRAMP_MAP_SIZE / PPC_TRAMP_SIZE
583 #ifdef __PCREL__
584 pla %r2,PPC_TRAMP_MAP_SIZE
585 ld %r11,0(%r2)
586 ld %r12,8(%r2)
587 mtctr %r12
588 bctr
589 #else
590 mflr %r0
591 bcl 20,31,$+4
592 mflr %r11
593 addis %r11,%r11,PPC_TRAMP_MAP_SIZE@ha
594 mtlr %r0
595 ld %r12,(PPC_TRAMP_MAP_SIZE+0)@l(%r11)
596 mtctr %r12
597 ld %r11,(PPC_TRAMP_MAP_SIZE-8)@l(%r11)
598 bctr
599 nop
600 #endif
601 .endr
602 .align PPC_TRAMP_MAP_SHIFT
603 #if _CALL_ELF == 2
604 .size trampoline_code_table,.-trampoline_code_table
605 #else
606 .size trampoline_code_table,.-.L.trampoline_code_table
607 #endif
608 #endif /* FFI_EXEC_STATIC_TRAMP */
609 #endif /* POWERPC64 */
610
611 #if (defined __ELF__ && defined __linux__) || _CALL_ELF == 2
612 .section .note.GNU-stack,"",@progbits
613 #endif