Debian Codegraph @

src/ia64/unix.S

raw
1 /* -----------------------------------------------------------------------
2 unix.S - Copyright (c) 1998, 2008 Red Hat, Inc.
3 Copyright (c) 2000 Hewlett Packard Company
4
5 IA64/unix Foreign Function Interface
6
7 Primary author: Hans Boehm, HP Labs
8
9 Loosely modeled on Cygnus code for other platforms.
10
11 Permission is hereby granted, free of charge, to any person obtaining
12 a copy of this software and associated documentation files (the
13 ``Software''), to deal in the Software without restriction, including
14 without limitation the rights to use, copy, modify, merge, publish,
15 distribute, sublicense, and/or sell copies of the Software, and to
16 permit persons to whom the Software is furnished to do so, subject to
17 the following conditions:
18
19 The above copyright notice and this permission notice shall be included
20 in all copies or substantial portions of the Software.
21
22 THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
23 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
25 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
26 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
27 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
28 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
29 DEALINGS IN THE SOFTWARE.
30 ----------------------------------------------------------------------- */
31
32 #define LIBFFI_ASM
33 #include <fficonfig.h>
34 #include <ffi.h>
35 #include "ia64_flags.h"
36
37 .pred.safe_across_calls p1-p5,p16-p63
38 .text
39 /* HPUX assembler needs to see these symbols, otherwise compilation
40 fails */
41 #ifdef __hpux
42 .global memcpy
43 .global ffi_closure_unix_inner
44 #endif
45
46 /* int ffi_call_unix (struct ia64_args *stack, PTR64 rvalue,
47 void (*fn)(void), int flags);
48 */
49
50 .align 16
51 .global ffi_call_unix
52 .proc ffi_call_unix
53 ffi_call_unix:
54 .prologue
55 /* Bit o trickiness. We actually share a stack frame with ffi_call.
56 Rely on the fact that ffi_call uses a vframe and don't bother
57 tracking one here at all. */
58 .fframe 0
59 .save ar.pfs, r36 // loc0
60 alloc loc0 = ar.pfs, 4, 3, 8, 0
61 .save rp, loc1
62 mov loc1 = b0
63 .body
64 add r16 = 16, in0
65 mov loc2 = gp
66 mov r8 = in1
67 ;;
68
69 /* Load up all of the argument registers. */
70 ldf.fill f8 = [in0], 32
71 ldf.fill f9 = [r16], 32
72 ;;
73 ldf.fill f10 = [in0], 32
74 ldf.fill f11 = [r16], 32
75 ;;
76 ldf.fill f12 = [in0], 32
77 ldf.fill f13 = [r16], 32
78 ;;
79 ldf.fill f14 = [in0], 32
80 ldf.fill f15 = [r16], 24
81 ;;
82 ld8 out0 = [in0], 16
83 ld8 out1 = [r16], 16
84 ;;
85 ld8 out2 = [in0], 16
86 ld8 out3 = [r16], 16
87 ;;
88 ld8 out4 = [in0], 16
89 ld8 out5 = [r16], 16
90 ;;
91 ld8 out6 = [in0]
92 ld8 out7 = [r16]
93 ;;
94
95 /* Deallocate the register save area from the stack frame. */
96 mov sp = in0
97
98 /* Call the target function. */
99 ld8 r16 = [in2], 8
100 ;;
101 ld8 gp = [in2]
102 mov b6 = r16
103 br.call.sptk.many b0 = b6
104 ;;
105
106 /* Dispatch to handle return value. */
107 mov gp = loc2
108 zxt1 r16 = in3
109 ;;
110 mov ar.pfs = loc0
111 addl r18 = @ltoffx(.Lst_table), gp
112 ;;
113 /* default assembler on HP-UX does not support LDXMOV */
114 #ifdef __hpux
115 ld8 r18 = [r18]
116 #else
117 ld8.mov r18 = [r18], .Lst_table
118 #endif
119 mov b0 = loc1
120 ;;
121 shladd r18 = r16, 3, r18
122 ;;
123 ld8 r17 = [r18]
124 shr in3 = in3, 8
125 ;;
126 add r17 = r17, r18
127 ;;
128 mov b6 = r17
129 br b6
130 ;;
131
132 .Lst_void:
133 br.ret.sptk.many b0
134 ;;
135 .Lst_uint8:
136 zxt1 r8 = r8
137 ;;
138 st8 [in1] = r8
139 br.ret.sptk.many b0
140 ;;
141 .Lst_sint8:
142 sxt1 r8 = r8
143 ;;
144 st8 [in1] = r8
145 br.ret.sptk.many b0
146 ;;
147 .Lst_uint16:
148 zxt2 r8 = r8
149 ;;
150 st8 [in1] = r8
151 br.ret.sptk.many b0
152 ;;
153 .Lst_sint16:
154 sxt2 r8 = r8
155 ;;
156 st8 [in1] = r8
157 br.ret.sptk.many b0
158 ;;
159 .Lst_uint32:
160 zxt4 r8 = r8
161 ;;
162 st8 [in1] = r8
163 br.ret.sptk.many b0
164 ;;
165 .Lst_sint32:
166 sxt4 r8 = r8
167 ;;
168 st8 [in1] = r8
169 br.ret.sptk.many b0
170 ;;
171 .Lst_int64:
172 st8 [in1] = r8
173 br.ret.sptk.many b0
174 ;;
175 .Lst_float:
176 stfs [in1] = f8
177 br.ret.sptk.many b0
178 ;;
179 .Lst_double:
180 stfd [in1] = f8
181 br.ret.sptk.many b0
182 ;;
183 .Lst_ldouble:
184 stfe [in1] = f8
185 br.ret.sptk.many b0
186 ;;
187
188 .Lst_small_struct:
189 cmp.lt p6, p0 = 8, in3
190 cmp.lt p7, p0 = 16, in3
191 cmp.lt p8, p0 = 24, in3
192 ;;
193 add r16 = 8, sp
194 add r17 = 16, sp
195 add r18 = 24, sp
196 ;;
197 st8 [sp] = r8
198 (p6) st8 [r16] = r9
199 mov out0 = in1
200 (p7) st8 [r17] = r10
201 (p8) st8 [r18] = r11
202 mov out1 = sp
203 mov out2 = in3
204 ;;
205 // ia64 software calling convention requires
206 // top 16 bytes of stack to be scratch space
207 // PLT resolver uses that scratch space at
208 // 'memcpy' symbol reolution time
209 add sp = -16, sp
210 br.call.sptk.many b0 = memcpy#
211 ;;
212 mov ar.pfs = loc0
213 mov b0 = loc1
214 mov gp = loc2
215 br.ret.sptk.many b0
216
217 .Lst_hfa_float:
218 add r16 = 4, in1
219 cmp.lt p6, p0 = 4, in3
220 ;;
221 stfs [in1] = f8, 8
222 (p6) stfs [r16] = f9, 8
223 cmp.lt p7, p0 = 8, in3
224 cmp.lt p8, p0 = 12, in3
225 ;;
226 (p7) stfs [in1] = f10, 8
227 (p8) stfs [r16] = f11, 8
228 cmp.lt p9, p0 = 16, in3
229 cmp.lt p10, p0 = 20, in3
230 ;;
231 (p9) stfs [in1] = f12, 8
232 (p10) stfs [r16] = f13, 8
233 cmp.lt p6, p0 = 24, in3
234 cmp.lt p7, p0 = 28, in3
235 ;;
236 (p6) stfs [in1] = f14
237 (p7) stfs [r16] = f15
238 br.ret.sptk.many b0
239 ;;
240
241 .Lst_hfa_double:
242 add r16 = 8, in1
243 cmp.lt p6, p0 = 8, in3
244 ;;
245 stfd [in1] = f8, 16
246 (p6) stfd [r16] = f9, 16
247 cmp.lt p7, p0 = 16, in3
248 cmp.lt p8, p0 = 24, in3
249 ;;
250 (p7) stfd [in1] = f10, 16
251 (p8) stfd [r16] = f11, 16
252 cmp.lt p9, p0 = 32, in3
253 cmp.lt p10, p0 = 40, in3
254 ;;
255 (p9) stfd [in1] = f12, 16
256 (p10) stfd [r16] = f13, 16
257 cmp.lt p6, p0 = 48, in3
258 cmp.lt p7, p0 = 56, in3
259 ;;
260 (p6) stfd [in1] = f14
261 (p7) stfd [r16] = f15
262 br.ret.sptk.many b0
263 ;;
264
265 .Lst_hfa_ldouble:
266 add r16 = 16, in1
267 cmp.lt p6, p0 = 16, in3
268 ;;
269 stfe [in1] = f8, 32
270 (p6) stfe [r16] = f9, 32
271 cmp.lt p7, p0 = 32, in3
272 cmp.lt p8, p0 = 48, in3
273 ;;
274 (p7) stfe [in1] = f10, 32
275 (p8) stfe [r16] = f11, 32
276 cmp.lt p9, p0 = 64, in3
277 cmp.lt p10, p0 = 80, in3
278 ;;
279 (p9) stfe [in1] = f12, 32
280 (p10) stfe [r16] = f13, 32
281 cmp.lt p6, p0 = 96, in3
282 cmp.lt p7, p0 = 112, in3
283 ;;
284 (p6) stfe [in1] = f14
285 (p7) stfe [r16] = f15
286 br.ret.sptk.many b0
287 ;;
288
289 .endp ffi_call_unix
290
291 .align 16
292 .global ffi_closure_unix
293 .proc ffi_closure_unix
294
295 #define FRAME_SIZE (8*16 + 8*8 + 8*16)
296
297 ffi_closure_unix:
298 .prologue
299 .save ar.pfs, r40 // loc0
300 alloc loc0 = ar.pfs, 8, 4, 4, 0
301 .fframe FRAME_SIZE
302 add r12 = -FRAME_SIZE, r12
303 .save rp, loc1
304 mov loc1 = b0
305 .save ar.unat, loc2
306 mov loc2 = ar.unat
307 .body
308
309 /* Retrieve closure pointer and real gp. */
310 #ifdef _ILP32
311 addp4 out0 = 0, gp
312 addp4 gp = 16, gp
313 #else
314 mov out0 = gp
315 add gp = 16, gp
316 #endif
317 ;;
318 ld8 gp = [gp]
319
320 /* Spill all of the possible argument registers. */
321 add r16 = 16 + 8*16, sp
322 add r17 = 16 + 8*16 + 16, sp
323 ;;
324 stf.spill [r16] = f8, 32
325 stf.spill [r17] = f9, 32
326 mov loc3 = gp
327 ;;
328 stf.spill [r16] = f10, 32
329 stf.spill [r17] = f11, 32
330 ;;
331 stf.spill [r16] = f12, 32
332 stf.spill [r17] = f13, 32
333 ;;
334 stf.spill [r16] = f14, 32
335 stf.spill [r17] = f15, 24
336 ;;
337 .mem.offset 0, 0
338 st8.spill [r16] = in0, 16
339 .mem.offset 8, 0
340 st8.spill [r17] = in1, 16
341 add out1 = 16 + 8*16, sp
342 ;;
343 .mem.offset 0, 0
344 st8.spill [r16] = in2, 16
345 .mem.offset 8, 0
346 st8.spill [r17] = in3, 16
347 add out2 = 16, sp
348 ;;
349 .mem.offset 0, 0
350 st8.spill [r16] = in4, 16
351 .mem.offset 8, 0
352 st8.spill [r17] = in5, 16
353 mov out3 = r8
354 ;;
355 .mem.offset 0, 0
356 st8.spill [r16] = in6
357 .mem.offset 8, 0
358 st8.spill [r17] = in7
359
360 /* Invoke ffi_closure_unix_inner for the hard work. */
361 br.call.sptk.many b0 = ffi_closure_unix_inner
362 ;;
363
364 /* Dispatch to handle return value. */
365 mov gp = loc3
366 zxt1 r16 = r8
367 ;;
368 addl r18 = @ltoffx(.Lld_table), gp
369 mov ar.pfs = loc0
370 ;;
371 #ifdef __hpux
372 ld8 r18 = [r18]
373 #else
374 ld8.mov r18 = [r18], .Lst_table
375 #endif
376 mov b0 = loc1
377 ;;
378 shladd r18 = r16, 3, r18
379 mov ar.unat = loc2
380 ;;
381 ld8 r17 = [r18]
382 shr r8 = r8, 8
383 ;;
384 add r17 = r17, r18
385 add r16 = 16, sp
386 ;;
387 mov b6 = r17
388 br b6
389 ;;
390 .label_state 1
391
392 .Lld_void:
393 .restore sp
394 add sp = FRAME_SIZE, sp
395 br.ret.sptk.many b0
396 ;;
397 .Lld_int:
398 .body
399 .copy_state 1
400 ld8 r8 = [r16]
401 .restore sp
402 add sp = FRAME_SIZE, sp
403 br.ret.sptk.many b0
404 ;;
405 .Lld_float:
406 .body
407 .copy_state 1
408 ldfs f8 = [r16]
409 .restore sp
410 add sp = FRAME_SIZE, sp
411 br.ret.sptk.many b0
412 ;;
413 .Lld_double:
414 .body
415 .copy_state 1
416 ldfd f8 = [r16]
417 .restore sp
418 add sp = FRAME_SIZE, sp
419 br.ret.sptk.many b0
420 ;;
421 .Lld_ldouble:
422 .body
423 .copy_state 1
424 ldfe f8 = [r16]
425 .restore sp
426 add sp = FRAME_SIZE, sp
427 br.ret.sptk.many b0
428 ;;
429
430 .Lld_small_struct:
431 .body
432 .copy_state 1
433 add r17 = 8, r16
434 cmp.lt p6, p0 = 8, r8
435 cmp.lt p7, p0 = 16, r8
436 cmp.lt p8, p0 = 24, r8
437 ;;
438 ld8 r8 = [r16], 16
439 (p6) ld8 r9 = [r17], 16
440 ;;
441 (p7) ld8 r10 = [r16]
442 (p8) ld8 r11 = [r17]
443 .restore sp
444 add sp = FRAME_SIZE, sp
445 br.ret.sptk.many b0
446 ;;
447
448 .Lld_hfa_float:
449 .body
450 .copy_state 1
451 add r17 = 4, r16
452 cmp.lt p6, p0 = 4, r8
453 ;;
454 ldfs f8 = [r16], 8
455 (p6) ldfs f9 = [r17], 8
456 cmp.lt p7, p0 = 8, r8
457 cmp.lt p8, p0 = 12, r8
458 ;;
459 (p7) ldfs f10 = [r16], 8
460 (p8) ldfs f11 = [r17], 8
461 cmp.lt p9, p0 = 16, r8
462 cmp.lt p10, p0 = 20, r8
463 ;;
464 (p9) ldfs f12 = [r16], 8
465 (p10) ldfs f13 = [r17], 8
466 cmp.lt p6, p0 = 24, r8
467 cmp.lt p7, p0 = 28, r8
468 ;;
469 (p6) ldfs f14 = [r16]
470 (p7) ldfs f15 = [r17]
471 .restore sp
472 add sp = FRAME_SIZE, sp
473 br.ret.sptk.many b0
474 ;;
475
476 .Lld_hfa_double:
477 .body
478 .copy_state 1
479 add r17 = 8, r16
480 cmp.lt p6, p0 = 8, r8
481 ;;
482 ldfd f8 = [r16], 16
483 (p6) ldfd f9 = [r17], 16
484 cmp.lt p7, p0 = 16, r8
485 cmp.lt p8, p0 = 24, r8
486 ;;
487 (p7) ldfd f10 = [r16], 16
488 (p8) ldfd f11 = [r17], 16
489 cmp.lt p9, p0 = 32, r8
490 cmp.lt p10, p0 = 40, r8
491 ;;
492 (p9) ldfd f12 = [r16], 16
493 (p10) ldfd f13 = [r17], 16
494 cmp.lt p6, p0 = 48, r8
495 cmp.lt p7, p0 = 56, r8
496 ;;
497 (p6) ldfd f14 = [r16]
498 (p7) ldfd f15 = [r17]
499 .restore sp
500 add sp = FRAME_SIZE, sp
501 br.ret.sptk.many b0
502 ;;
503
504 .Lld_hfa_ldouble:
505 .body
506 .copy_state 1
507 add r17 = 16, r16
508 cmp.lt p6, p0 = 16, r8
509 ;;
510 ldfe f8 = [r16], 32
511 (p6) ldfe f9 = [r17], 32
512 cmp.lt p7, p0 = 32, r8
513 cmp.lt p8, p0 = 48, r8
514 ;;
515 (p7) ldfe f10 = [r16], 32
516 (p8) ldfe f11 = [r17], 32
517 cmp.lt p9, p0 = 64, r8
518 cmp.lt p10, p0 = 80, r8
519 ;;
520 (p9) ldfe f12 = [r16], 32
521 (p10) ldfe f13 = [r17], 32
522 cmp.lt p6, p0 = 96, r8
523 cmp.lt p7, p0 = 112, r8
524 ;;
525 (p6) ldfe f14 = [r16]
526 (p7) ldfe f15 = [r17]
527 .restore sp
528 add sp = FRAME_SIZE, sp
529 br.ret.sptk.many b0
530 ;;
531
532 .endp ffi_closure_unix
533 #ifdef __hpux
534 .rodata
535 #else
536 .section .rodata
537 #endif
538 .align 8
539 .Lst_table:
540 data8 @pcrel(.Lst_void) // FFI_TYPE_VOID
541 data8 @pcrel(.Lst_sint32) // FFI_TYPE_INT
542 data8 @pcrel(.Lst_float) // FFI_TYPE_FLOAT
543 data8 @pcrel(.Lst_double) // FFI_TYPE_DOUBLE
544 data8 @pcrel(.Lst_ldouble) // FFI_TYPE_LONGDOUBLE
545 data8 @pcrel(.Lst_uint8) // FFI_TYPE_UINT8
546 data8 @pcrel(.Lst_sint8) // FFI_TYPE_SINT8
547 data8 @pcrel(.Lst_uint16) // FFI_TYPE_UINT16
548 data8 @pcrel(.Lst_sint16) // FFI_TYPE_SINT16
549 data8 @pcrel(.Lst_uint32) // FFI_TYPE_UINT32
550 data8 @pcrel(.Lst_sint32) // FFI_TYPE_SINT32
551 data8 @pcrel(.Lst_int64) // FFI_TYPE_UINT64
552 data8 @pcrel(.Lst_int64) // FFI_TYPE_SINT64
553 data8 @pcrel(.Lst_void) // FFI_TYPE_STRUCT
554 data8 @pcrel(.Lst_int64) // FFI_TYPE_POINTER
555 data8 @pcrel(.Lst_void) // FFI_TYPE_COMPLEX (not implemented)
556 data8 @pcrel(.Lst_small_struct) // FFI_IA64_TYPE_SMALL_STRUCT
557 data8 @pcrel(.Lst_hfa_float) // FFI_IA64_TYPE_HFA_FLOAT
558 data8 @pcrel(.Lst_hfa_double) // FFI_IA64_TYPE_HFA_DOUBLE
559 data8 @pcrel(.Lst_hfa_ldouble) // FFI_IA64_TYPE_HFA_LDOUBLE
560
561 .Lld_table:
562 data8 @pcrel(.Lld_void) // FFI_TYPE_VOID
563 data8 @pcrel(.Lld_int) // FFI_TYPE_INT
564 data8 @pcrel(.Lld_float) // FFI_TYPE_FLOAT
565 data8 @pcrel(.Lld_double) // FFI_TYPE_DOUBLE
566 data8 @pcrel(.Lld_ldouble) // FFI_TYPE_LONGDOUBLE
567 data8 @pcrel(.Lld_int) // FFI_TYPE_UINT8
568 data8 @pcrel(.Lld_int) // FFI_TYPE_SINT8
569 data8 @pcrel(.Lld_int) // FFI_TYPE_UINT16
570 data8 @pcrel(.Lld_int) // FFI_TYPE_SINT16
571 data8 @pcrel(.Lld_int) // FFI_TYPE_UINT32
572 data8 @pcrel(.Lld_int) // FFI_TYPE_SINT32
573 data8 @pcrel(.Lld_int) // FFI_TYPE_UINT64
574 data8 @pcrel(.Lld_int) // FFI_TYPE_SINT64
575 data8 @pcrel(.Lld_void) // FFI_TYPE_STRUCT
576 data8 @pcrel(.Lld_int) // FFI_TYPE_POINTER
577 data8 @pcrel(.Lld_void) // FFI_TYPE_COMPLEX (not implemented)
578 data8 @pcrel(.Lld_small_struct) // FFI_IA64_TYPE_SMALL_STRUCT
579 data8 @pcrel(.Lld_hfa_float) // FFI_IA64_TYPE_HFA_FLOAT
580 data8 @pcrel(.Lld_hfa_double) // FFI_IA64_TYPE_HFA_DOUBLE
581 data8 @pcrel(.Lld_hfa_ldouble) // FFI_IA64_TYPE_HFA_LDOUBLE
582
583 #if defined __ELF__ && defined __linux__
584 .section .note.GNU-stack,"",@progbits
585 #endif