1 /* -----------------------------------------------------------------------
2 o32.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 o32 */
32 #if defined(FFI_MIPS_O32)
38 #define SIZEOF_FRAME (4 * FFI_SIZEOF_ARG + 2 * FFI_SIZEOF_ARG)
39 #define A3_OFF (SIZEOF_FRAME + 3 * FFI_SIZEOF_ARG)
40 #define FP_OFF (SIZEOF_FRAME - 2 * FFI_SIZEOF_ARG)
41 #define RA_OFF (SIZEOF_FRAME - 1 * FFI_SIZEOF_ARG)
51 SUBU $sp, SIZEOF_FRAME # Frame size
53 REG_S $fp, FP_OFF($sp) # Save frame pointer
55 REG_S ra, RA_OFF($sp) # Save return address
60 move t9, callback # callback function pointer
61 REG_S flags, A3_OFF($fp) # flags
63 # Allocate at least 4 words in the argstack
64 LI v0, 4 * FFI_SIZEOF_ARG
65 blt bytes, v0, sixteen
67 ADDU v0, bytes, 7 # make sure it is aligned
68 and v0, -8 # to an 8 byte boundry
71 SUBU $sp, v0 # move the stack pointer to reflect the
74 ADDU a0, $sp, 4 * FFI_SIZEOF_ARG
78 REG_L t0, A3_OFF($fp) # load the flags word
79 SRL t2, t0, 4 # shift our arg info
80 and t0, ((1<<4)-1) # mask out the return type
82 ADDU $sp, 4 * FFI_SIZEOF_ARG # adjust $sp to new args
84 bnez t0, pass_d # make it quick for int
85 REG_L a0, 0*FFI_SIZEOF_ARG($sp) # just go ahead and load the
86 REG_L a1, 1*FFI_SIZEOF_ARG($sp) # four regs.
87 REG_L a2, 2*FFI_SIZEOF_ARG($sp)
88 REG_L a3, 3*FFI_SIZEOF_ARG($sp)
92 bne t0, FFI_ARGS_D, pass_f
93 l.d $f12, 0*FFI_SIZEOF_ARG($sp) # load $fp regs from args
94 REG_L a2, 2*FFI_SIZEOF_ARG($sp) # passing a double
95 REG_L a3, 3*FFI_SIZEOF_ARG($sp)
99 bne t0, FFI_ARGS_F, pass_d_d
100 l.s $f12, 0*FFI_SIZEOF_ARG($sp) # load $fp regs from args
101 REG_L a1, 1*FFI_SIZEOF_ARG($sp) # passing a float
102 REG_L a2, 2*FFI_SIZEOF_ARG($sp)
103 REG_L a3, 3*FFI_SIZEOF_ARG($sp)
107 bne t0, FFI_ARGS_DD, pass_f_f
108 l.d $f12, 0*FFI_SIZEOF_ARG($sp) # load $fp regs from args
109 l.d $f14, 2*FFI_SIZEOF_ARG($sp) # passing two doubles
113 bne t0, FFI_ARGS_FF, pass_d_f
114 l.s $f12, 0*FFI_SIZEOF_ARG($sp) # load $fp regs from args
115 l.s $f14, 1*FFI_SIZEOF_ARG($sp) # passing two floats
116 REG_L a2, 2*FFI_SIZEOF_ARG($sp)
117 REG_L a3, 3*FFI_SIZEOF_ARG($sp)
121 bne t0, FFI_ARGS_DF, pass_f_d
122 l.d $f12, 0*FFI_SIZEOF_ARG($sp) # load $fp regs from args
123 l.s $f14, 2*FFI_SIZEOF_ARG($sp) # passing double and float
124 REG_L a3, 3*FFI_SIZEOF_ARG($sp)
128 # assume that the only other combination must be float then double
129 # bne t0, FFI_ARGS_F_D, call_it
130 l.s $f12, 0*FFI_SIZEOF_ARG($sp) # load $fp regs from args
131 l.d $f14, 2*FFI_SIZEOF_ARG($sp) # passing double and float
134 # Load the function pointer
135 REG_L t9, SIZEOF_FRAME + 5*FFI_SIZEOF_ARG($fp)
137 # If the return value pointer is NULL, assume no return value.
138 REG_L t1, SIZEOF_FRAME + 4*FFI_SIZEOF_ARG($fp)
141 bne t2, FFI_TYPE_INT, retlonglong
143 REG_L t0, SIZEOF_FRAME + 4*FFI_SIZEOF_ARG($fp)
148 # Really any 64-bit int, signed or not.
149 bne t2, FFI_TYPE_UINT64, retfloat
151 REG_L t0, SIZEOF_FRAME + 4*FFI_SIZEOF_ARG($fp)
157 bne t2, FFI_TYPE_FLOAT, retdouble
159 REG_L t0, SIZEOF_FRAME + 4*FFI_SIZEOF_ARG($fp)
164 bne t2, FFI_TYPE_DOUBLE, noretval
166 REG_L t0, SIZEOF_FRAME + 4*FFI_SIZEOF_ARG($fp)
176 REG_L $fp, FP_OFF($sp) # Restore frame pointer
177 REG_L ra, RA_OFF($sp) # Restore return address
178 ADDU $sp, SIZEOF_FRAME # Fix stack pointer
185 /* ffi_closure_O32. Expects address of the passed-in ffi_closure
186 in t0. Stores any arguments passed in registers onto the
187 stack, then calls ffi_closure_mips_inner_O32, which
192 14 - Start of parameters, original sp
197 9 - return value high (v1)
198 8 - return value low (v0)
199 7 - f14 (le high, be low)
200 6 - f14 (le low, be high)
201 5 - f12 (le high, be low)
202 4 - f12 (le low, be high)
203 3 - Called function a3 save
204 2 - Called function a2 save
205 1 - Called function a1 save
206 0 - Called function a0 save our sp, fp point here
209 #define SIZEOF_FRAME2 (14 * FFI_SIZEOF_ARG)
210 #define A3_OFF2 (SIZEOF_FRAME2 + 3 * FFI_SIZEOF_ARG)
211 #define A2_OFF2 (SIZEOF_FRAME2 + 2 * FFI_SIZEOF_ARG)
212 #define A1_OFF2 (SIZEOF_FRAME2 + 1 * FFI_SIZEOF_ARG)
213 #define A0_OFF2 (SIZEOF_FRAME2 + 0 * FFI_SIZEOF_ARG)
214 #define RA_OFF2 (SIZEOF_FRAME2 - 1 * FFI_SIZEOF_ARG)
215 #define FP_OFF2 (SIZEOF_FRAME2 - 2 * FFI_SIZEOF_ARG)
216 #define S0_OFF2 (SIZEOF_FRAME2 - 3 * FFI_SIZEOF_ARG)
217 #define GP_OFF2 (SIZEOF_FRAME2 - 4 * FFI_SIZEOF_ARG)
218 #define V1_OFF2 (SIZEOF_FRAME2 - 5 * FFI_SIZEOF_ARG)
219 #define V0_OFF2 (SIZEOF_FRAME2 - 6 * FFI_SIZEOF_ARG)
220 #define FA_1_1_OFF2 (SIZEOF_FRAME2 - 7 * FFI_SIZEOF_ARG)
221 #define FA_1_0_OFF2 (SIZEOF_FRAME2 - 8 * FFI_SIZEOF_ARG)
222 #define FA_0_1_OFF2 (SIZEOF_FRAME2 - 9 * FFI_SIZEOF_ARG)
223 #define FA_0_0_OFF2 (SIZEOF_FRAME2 - 10 * FFI_SIZEOF_ARG)
227 .globl ffi_closure_O32
232 .frame $fp, SIZEOF_FRAME2, ra
236 SUBU $sp, SIZEOF_FRAME2
239 REG_S $16, S0_OFF2($sp) # Save s0
240 REG_S $fp, FP_OFF2($sp) # Save frame pointer
241 REG_S ra, RA_OFF2($sp) # Save return address
246 # Store all possible argument registers. If there are more than
247 # four arguments, then they are stored above where we put a3.
248 REG_S a0, A0_OFF2($fp)
249 REG_S a1, A1_OFF2($fp)
250 REG_S a2, A2_OFF2($fp)
251 REG_S a3, A3_OFF2($fp)
253 # Load ABI enum to s0
254 REG_L $16, 20($8) # cif pointer follows tramp.
255 REG_L $16, 0($16) # abi is first member.
258 bne $16, $13, 1f # Skip fp save if FFI_O32_SOFT_FLOAT
260 # Store all possible float/double registers.
261 s.d $f12, FA_0_0_OFF2($fp)
262 s.d $f14, FA_1_0_OFF2($fp)
264 # Call ffi_closure_mips_inner_O32 to do the work.
265 la t9, ffi_closure_mips_inner_O32
266 move a0, $8 # Pointer to the ffi_closure
267 addu a1, $fp, V0_OFF2
268 addu a2, $fp, A0_OFF2
269 addu a3, $fp, FA_0_0_OFF2
272 # Load the return value into the appropriate register.
275 beq $8, $9, closure_done
278 bne $16, $13, 1f # Skip fp restore if FFI_O32_SOFT_FLOAT
280 li $9, FFI_TYPE_FLOAT
281 l.s $f0, V0_OFF2($fp)
282 beq $8, $9, closure_done
284 li $9, FFI_TYPE_DOUBLE
285 l.d $f0, V0_OFF2($fp)
286 beq $8, $9, closure_done
288 REG_L $3, V1_OFF2($fp)
289 REG_L $2, V0_OFF2($fp)
294 REG_L $16, S0_OFF2($sp) # Restore s0
295 REG_L $fp, FP_OFF2($sp) # Restore frame pointer
296 REG_L ra, RA_OFF2($sp) # Restore return address
297 ADDU $sp, SIZEOF_FRAME2
302 /* DWARF-2 unwind info. */
304 .section .eh_frame,"a",@progbits
306 .4byte $LECIE0-$LSCIE0 # Length of Common Information Entry
308 .4byte 0x0 # CIE Identifier Tag
309 .byte 0x1 # CIE Version
310 .ascii "zR\0" # CIE Augmentation
311 .uleb128 0x1 # CIE Code Alignment Factor
312 .sleb128 4 # CIE Data Alignment Factor
313 .byte 0x1f # CIE RA Column
314 .uleb128 0x1 # Augmentation size
315 .byte 0x00 # FDE Encoding (absptr)
316 .byte 0xc # DW_CFA_def_cfa
322 .4byte $LEFDE0-$LASFDE0 # FDE Length
324 .4byte $LASFDE0-$Lframe0 # FDE CIE offset
325 .4byte $LFB0 # FDE initial location
326 .4byte $LFE0-$LFB0 # FDE address range
327 .uleb128 0x0 # Augmentation size
328 .byte 0x4 # DW_CFA_advance_loc4
330 .byte 0xe # DW_CFA_def_cfa_offset
332 .byte 0x4 # DW_CFA_advance_loc4
334 .byte 0x11 # DW_CFA_offset_extended_sf
336 .sleb128 -2 # SIZEOF_FRAME2 - 2*FFI_SIZEOF_ARG($sp)
337 .byte 0x11 # DW_CFA_offset_extended_sf
339 .sleb128 -1 # SIZEOF_FRAME2 - 1*FFI_SIZEOF_ARG($sp)
340 .byte 0x4 # DW_CFA_advance_loc4
342 .byte 0xc # DW_CFA_def_cfa
348 .4byte $LEFDE1-$LASFDE1 # FDE Length
350 .4byte $LASFDE1-$Lframe0 # FDE CIE offset
351 .4byte $LFB1 # FDE initial location
352 .4byte $LFE1-$LFB1 # FDE address range
353 .uleb128 0x0 # Augmentation size
354 .byte 0x4 # DW_CFA_advance_loc4
356 .byte 0xe # DW_CFA_def_cfa_offset
358 .byte 0x4 # DW_CFA_advance_loc4
360 .byte 0x11 # DW_CFA_offset_extended_sf
362 .sleb128 -3 # SIZEOF_FRAME2 - 3*FFI_SIZEOF_ARG($sp)
363 .byte 0x11 # DW_CFA_offset_extended_sf
365 .sleb128 -2 # SIZEOF_FRAME2 - 2*FFI_SIZEOF_ARG($sp)
366 .byte 0x11 # DW_CFA_offset_extended_sf
368 .sleb128 -1 # SIZEOF_FRAME2 - 1*FFI_SIZEOF_ARG($sp)
369 .byte 0x4 # DW_CFA_advance_loc4
371 .byte 0xc # DW_CFA_def_cfa