1 /* -----------------------------------------------------------------------
2 n32.S - Copyright (c) 1996, 1998, 2005 Red Hat, Inc.
4 MIPS Foreign Function Interface
6 Permission is hereby granted, free of charge, to any person obtaining
7 a copy of this software and associated documentation files (the
8 ``Software''), to deal in the Software without restriction, including
9 without limitation the rights to use, copy, modify, merge, publish,
10 distribute, sublicense, and/or sell copies of the Software, and to
11 permit persons to whom the Software is furnished to do so, subject to
12 the following conditions:
14 The above copyright notice and this permission notice shall be included
15 in all copies or substantial portions of the Software.
17 THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
20 IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR
21 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
22 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23 OTHER DEALINGS IN THE SOFTWARE.
24 ----------------------------------------------------------------------- */
27 #include <fficonfig.h>
30 /* Only build this code if we are compiling for n32 */
32 #if defined(FFI_MIPS_N32)
40 #define SIZEOF_FRAME ( 8 * FFI_SIZEOF_ARG )
49 .frame $fp, SIZEOF_FRAME, ra
50 .mask 0xc0000000,-FFI_SIZEOF_ARG
54 SUBU $sp, SIZEOF_FRAME # Frame size
56 REG_S $fp, SIZEOF_FRAME - 2*FFI_SIZEOF_ARG($sp) # Save frame pointer
57 REG_S ra, SIZEOF_FRAME - 1*FFI_SIZEOF_ARG($sp) # Save return address
61 move t9, callback # callback function pointer
62 REG_S bytes, 2*FFI_SIZEOF_ARG($fp) # bytes
63 REG_S flags, 3*FFI_SIZEOF_ARG($fp) # flags
64 REG_S raddr, 4*FFI_SIZEOF_ARG($fp) # raddr
65 REG_S fn, 5*FFI_SIZEOF_ARG($fp) # fn
67 # Allocate at least 4 words in the argstack
69 bge bytes, 4 * FFI_SIZEOF_ARG, bigger
70 LI v0, 4 * FFI_SIZEOF_ARG
74 ADDU t4, v0, 2 * FFI_SIZEOF_ARG -1 # make sure it is aligned
75 and v0, t4, -2 * FFI_SIZEOF_ARG # to a proper boundry.
78 SUBU $sp, $sp, v0 # move the stack pointer to reflect the
81 move a0, $sp # 4 * FFI_SIZEOF_ARG
82 ADDU a3, $fp, 3 * FFI_SIZEOF_ARG
87 # Copy the stack pointer to t9
90 # Fix the stack if there are more than 8 64bit slots worth
93 # Load the number of bytes
94 REG_L t6, 2*FFI_SIZEOF_ARG($fp)
96 # Is it bigger than 8 * FFI_SIZEOF_ARG?
97 daddiu t8, t6, -(8 * FFI_SIZEOF_ARG)
104 REG_L t6, 3*FFI_SIZEOF_ARG($fp) # load the flags word into t6.
106 and t4, t6, ((1<<FFI_FLAG_BITS)-1)
108 REG_L a0, 0*FFI_SIZEOF_ARG(t9)
111 bne t4, FFI_TYPE_FLOAT, arg1_doublep
112 l.s $f12, 0*FFI_SIZEOF_ARG(t9)
115 l.d $f12, 0*FFI_SIZEOF_ARG(t9)
118 SRL t4, t6, 1*FFI_FLAG_BITS
119 and t4, ((1<<FFI_FLAG_BITS)-1)
121 REG_L a1, 1*FFI_SIZEOF_ARG(t9)
124 bne t4, FFI_TYPE_FLOAT, arg2_doublep
125 l.s $f13, 1*FFI_SIZEOF_ARG(t9)
128 l.d $f13, 1*FFI_SIZEOF_ARG(t9)
131 SRL t4, t6, 2*FFI_FLAG_BITS
132 and t4, ((1<<FFI_FLAG_BITS)-1)
134 REG_L a2, 2*FFI_SIZEOF_ARG(t9)
137 bne t4, FFI_TYPE_FLOAT, arg3_doublep
138 l.s $f14, 2*FFI_SIZEOF_ARG(t9)
141 l.d $f14, 2*FFI_SIZEOF_ARG(t9)
144 SRL t4, t6, 3*FFI_FLAG_BITS
145 and t4, ((1<<FFI_FLAG_BITS)-1)
147 REG_L a3, 3*FFI_SIZEOF_ARG(t9)
150 bne t4, FFI_TYPE_FLOAT, arg4_doublep
151 l.s $f15, 3*FFI_SIZEOF_ARG(t9)
154 l.d $f15, 3*FFI_SIZEOF_ARG(t9)
157 SRL t4, t6, 4*FFI_FLAG_BITS
158 and t4, ((1<<FFI_FLAG_BITS)-1)
160 REG_L a4, 4*FFI_SIZEOF_ARG(t9)
163 bne t4, FFI_TYPE_FLOAT, arg5_doublep
164 l.s $f16, 4*FFI_SIZEOF_ARG(t9)
167 l.d $f16, 4*FFI_SIZEOF_ARG(t9)
170 SRL t4, t6, 5*FFI_FLAG_BITS
171 and t4, ((1<<FFI_FLAG_BITS)-1)
173 REG_L a5, 5*FFI_SIZEOF_ARG(t9)
176 bne t4, FFI_TYPE_FLOAT, arg6_doublep
177 l.s $f17, 5*FFI_SIZEOF_ARG(t9)
180 l.d $f17, 5*FFI_SIZEOF_ARG(t9)
183 SRL t4, t6, 6*FFI_FLAG_BITS
184 and t4, ((1<<FFI_FLAG_BITS)-1)
186 REG_L a6, 6*FFI_SIZEOF_ARG(t9)
189 bne t4, FFI_TYPE_FLOAT, arg7_doublep
190 l.s $f18, 6*FFI_SIZEOF_ARG(t9)
193 l.d $f18, 6*FFI_SIZEOF_ARG(t9)
196 SRL t4, t6, 7*FFI_FLAG_BITS
197 and t4, ((1<<FFI_FLAG_BITS)-1)
199 REG_L a7, 7*FFI_SIZEOF_ARG(t9)
202 bne t4, FFI_TYPE_FLOAT, arg8_doublep
203 l.s $f19, 7*FFI_SIZEOF_ARG(t9)
206 l.d $f19, 7*FFI_SIZEOF_ARG(t9)
210 # Load the function pointer
211 REG_L t9, 5*FFI_SIZEOF_ARG($fp)
213 # If the return value pointer is NULL, assume no return value.
214 REG_L t5, 4*FFI_SIZEOF_ARG($fp)
217 # Shift the return type flag over
218 SRL t6, 8*FFI_FLAG_BITS
220 bne t6, FFI_TYPE_INT, retfloat
222 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
227 bne t6, FFI_TYPE_FLOAT, retdouble
229 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
234 bne t6, FFI_TYPE_DOUBLE, retstruct_d
236 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
241 bne t6, FFI_TYPE_STRUCT_D, retstruct_f
243 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
248 bne t6, FFI_TYPE_STRUCT_F, retstruct_d_d
250 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
255 bne t6, FFI_TYPE_STRUCT_DD, retstruct_f_f
257 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
263 bne t6, FFI_TYPE_STRUCT_FF, retstruct_d_f
265 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
271 bne t6, FFI_TYPE_STRUCT_DF, retstruct_f_d
273 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
279 bne t6, FFI_TYPE_STRUCT_FD, retstruct_small
281 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
287 bne t6, FFI_TYPE_STRUCT_SMALL, retstruct_small2
289 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
294 bne t6, FFI_TYPE_STRUCT_SMALL2, retstruct
296 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
308 REG_L $fp, SIZEOF_FRAME - 2*FFI_SIZEOF_ARG($sp) # Restore frame pointer
309 REG_L ra, SIZEOF_FRAME - 1*FFI_SIZEOF_ARG($sp) # Restore return address
310 ADDU $sp, SIZEOF_FRAME # Fix stack pointer
316 /* ffi_closure_N32. Expects address of the passed-in ffi_closure in t0
317 ($12). Stores any arguments passed in registers onto the stack,
318 then calls ffi_closure_mips_inner_N32, which then decodes
323 20 - Start of parameters, original sp
324 19 - Called function a7 save
325 18 - Called function a6 save
326 17 - Called function a5 save
327 16 - Called function a4 save
328 15 - Called function a3 save
329 14 - Called function a2 save
330 13 - Called function a1 save
331 12 - Called function a0 save
332 11 - Called function f19
333 10 - Called function f18
334 9 - Called function f17
335 8 - Called function f16
336 7 - Called function f15
337 6 - Called function f14
338 5 - Called function f13
339 4 - Called function f12
340 3 - return value high (v1 or $f2)
341 2 - return value low (v0 or $f0)
343 0 - gp save our sp points here
346 #define SIZEOF_FRAME2 (20 * FFI_SIZEOF_ARG)
348 #define A7_OFF2 (19 * FFI_SIZEOF_ARG)
349 #define A6_OFF2 (18 * FFI_SIZEOF_ARG)
350 #define A5_OFF2 (17 * FFI_SIZEOF_ARG)
351 #define A4_OFF2 (16 * FFI_SIZEOF_ARG)
352 #define A3_OFF2 (15 * FFI_SIZEOF_ARG)
353 #define A2_OFF2 (14 * FFI_SIZEOF_ARG)
354 #define A1_OFF2 (13 * FFI_SIZEOF_ARG)
355 #define A0_OFF2 (12 * FFI_SIZEOF_ARG)
357 #define F19_OFF2 (11 * FFI_SIZEOF_ARG)
358 #define F18_OFF2 (10 * FFI_SIZEOF_ARG)
359 #define F17_OFF2 (9 * FFI_SIZEOF_ARG)
360 #define F16_OFF2 (8 * FFI_SIZEOF_ARG)
361 #define F15_OFF2 (7 * FFI_SIZEOF_ARG)
362 #define F14_OFF2 (6 * FFI_SIZEOF_ARG)
363 #define F13_OFF2 (5 * FFI_SIZEOF_ARG)
364 #define F12_OFF2 (4 * FFI_SIZEOF_ARG)
366 #define V1_OFF2 (3 * FFI_SIZEOF_ARG)
367 #define V0_OFF2 (2 * FFI_SIZEOF_ARG)
369 #define RA_OFF2 (1 * FFI_SIZEOF_ARG)
370 #define GP_OFF2 (0 * FFI_SIZEOF_ARG)
373 .globl ffi_closure_N32
377 .frame $sp, SIZEOF_FRAME2, ra
378 .mask 0x90000000,-(SIZEOF_FRAME2 - RA_OFF2)
380 SUBU $sp, SIZEOF_FRAME2
382 .cpsetup t9, GP_OFF2, ffi_closure_N32
383 REG_S ra, RA_OFF2($sp) # Save return address
385 # Store all possible argument registers. If there are more than
386 # fit in registers, then they were stored on the stack.
387 REG_S a0, A0_OFF2($sp)
388 REG_S a1, A1_OFF2($sp)
389 REG_S a2, A2_OFF2($sp)
390 REG_S a3, A3_OFF2($sp)
391 REG_S a4, A4_OFF2($sp)
392 REG_S a5, A5_OFF2($sp)
393 REG_S a6, A6_OFF2($sp)
394 REG_S a7, A7_OFF2($sp)
396 # Store all possible float/double registers.
397 s.d $f12, F12_OFF2($sp)
398 s.d $f13, F13_OFF2($sp)
399 s.d $f14, F14_OFF2($sp)
400 s.d $f15, F15_OFF2($sp)
401 s.d $f16, F16_OFF2($sp)
402 s.d $f17, F17_OFF2($sp)
403 s.d $f18, F18_OFF2($sp)
404 s.d $f19, F19_OFF2($sp)
406 # Call ffi_closure_mips_inner_N32 to do the real work.
407 LA t9, ffi_closure_mips_inner_N32
408 move a0, $12 # Pointer to the ffi_closure
409 ADDU a1, $sp, V0_OFF2
410 ADDU a2, $sp, A0_OFF2
411 ADDU a3, $sp, F12_OFF2
414 # Return flags are in v0
415 bne v0, FFI_TYPE_INT, cls_retfloat
416 REG_L v0, V0_OFF2($sp)
420 bne v0, FFI_TYPE_FLOAT, cls_retdouble
421 l.s $f0, V0_OFF2($sp)
425 bne v0, FFI_TYPE_DOUBLE, cls_retstruct_d
426 l.d $f0, V0_OFF2($sp)
430 bne v0, FFI_TYPE_STRUCT_D, cls_retstruct_f
431 l.d $f0, V0_OFF2($sp)
435 bne v0, FFI_TYPE_STRUCT_F, cls_retstruct_d_d
436 l.s $f0, V0_OFF2($sp)
440 bne v0, FFI_TYPE_STRUCT_DD, cls_retstruct_f_f
441 l.d $f0, V0_OFF2($sp)
442 l.d $f2, V1_OFF2($sp)
446 bne v0, FFI_TYPE_STRUCT_FF, cls_retstruct_d_f
447 l.s $f0, V0_OFF2($sp)
448 l.s $f2, V1_OFF2($sp)
452 bne v0, FFI_TYPE_STRUCT_DF, cls_retstruct_f_d
453 l.d $f0, V0_OFF2($sp)
454 l.s $f2, V1_OFF2($sp)
458 bne v0, FFI_TYPE_STRUCT_FD, cls_retstruct_small2
459 l.s $f0, V0_OFF2($sp)
460 l.d $f2, V1_OFF2($sp)
463 cls_retstruct_small2:
464 REG_L v0, V0_OFF2($sp)
465 REG_L v1, V1_OFF2($sp)
469 REG_L ra, RA_OFF2($sp) # Restore return address
471 ADDU $sp, SIZEOF_FRAME2
476 .section .eh_frame,"aw",@progbits
478 .4byte .LECIE1-.LSCIE1 # length
481 .byte 0x1 # Version 1
482 .ascii "\000" # Augmentation
483 .uleb128 0x1 # Code alignment 1
484 .sleb128 -4 # Data alignment -4
485 .byte 0x1f # Return Address $31
486 .byte 0xc # DW_CFA_def_cfa
487 .uleb128 0x1d # in $sp
488 .uleb128 0x0 # offset 0
489 .align EH_FRAME_ALIGN
493 .4byte .LEFDE1-.LASFDE1 # length.
495 .4byte .LASFDE1-.Lframe1 # CIE_pointer.
496 FDE_ADDR_BYTES .LFB3 # initial_location.
497 FDE_ADDR_BYTES .LFE3-.LFB3 # address_range.
498 .byte 0x4 # DW_CFA_advance_loc4
499 .4byte .LCFI0-.LFB3 # to .LCFI0
500 .byte 0xe # DW_CFA_def_cfa_offset
501 .uleb128 SIZEOF_FRAME # adjust stack.by SIZEOF_FRAME
502 .byte 0x4 # DW_CFA_advance_loc4
503 .4byte .LCFI1-.LCFI0 # to .LCFI1
504 .byte 0x9e # DW_CFA_offset of $fp
505 .uleb128 2*FFI_SIZEOF_ARG/4 #
506 .byte 0x9f # DW_CFA_offset of ra
507 .uleb128 1*FFI_SIZEOF_ARG/4 #
508 .byte 0x4 # DW_CFA_advance_loc4
509 .4byte .LCFI3-.LCFI1 # to .LCFI3
510 .byte 0xd # DW_CFA_def_cfa_register
511 .uleb128 0x1e # in $fp
512 .align EH_FRAME_ALIGN
515 .4byte .LEFDE3-.LASFDE3 # length
517 .4byte .LASFDE3-.Lframe1 # CIE_pointer.
518 FDE_ADDR_BYTES .LFB2 # initial_location.
519 FDE_ADDR_BYTES .LFE2-.LFB2 # address_range.
520 .byte 0x4 # DW_CFA_advance_loc4
521 .4byte .LCFI5-.LFB2 # to .LCFI5
522 .byte 0xe # DW_CFA_def_cfa_offset
523 .uleb128 SIZEOF_FRAME2 # adjust stack.by SIZEOF_FRAME
524 .byte 0x4 # DW_CFA_advance_loc4
525 .4byte .LCFI6-.LCFI5 # to .LCFI6
526 .byte 0x9c # DW_CFA_offset of $gp ($28)
527 .uleb128 (SIZEOF_FRAME2 - GP_OFF2)/4
528 .byte 0x9f # DW_CFA_offset of ra ($31)
529 .uleb128 (SIZEOF_FRAME2 - RA_OFF2)/4
530 .align EH_FRAME_ALIGN