Update README with a new port
[libffi.git] / src / mips / o32.S
1 /* -----------------------------------------------------------------------
2    o32.S - Copyright (c) 1996, 1998, 2005  Red Hat, Inc.
3    
4    MIPS Foreign Function Interface 
5
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:
13
14    The above copyright notice and this permission notice shall be included
15    in all copies or substantial portions of the Software.
16
17    THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
18    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
20    NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
21    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
22    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
24    DEALINGS IN THE SOFTWARE.
25    ----------------------------------------------------------------------- */
26
27 #define LIBFFI_ASM      
28 #include <fficonfig.h>
29 #include <ffi.h>
30
31 /* Only build this code if we are compiling for o32 */  
32
33 #if defined(FFI_MIPS_O32)
34         
35 #define callback a0
36 #define bytes    a2
37 #define flags    a3
38                 
39 #define SIZEOF_FRAME    (4 * FFI_SIZEOF_ARG + 2 * FFI_SIZEOF_ARG)
40 #define A3_OFF          (SIZEOF_FRAME + 3 * FFI_SIZEOF_ARG)
41 #define FP_OFF          (SIZEOF_FRAME - 2 * FFI_SIZEOF_ARG)
42 #define RA_OFF          (SIZEOF_FRAME - 1 * FFI_SIZEOF_ARG)
43
44         .abicalls
45         .text
46         .align  2
47         .globl  ffi_call_O32
48         .ent    ffi_call_O32
49 ffi_call_O32:   
50 $LFB0:
51         # Prologue
52         SUBU    $sp, SIZEOF_FRAME       # Frame size
53 $LCFI00:
54         REG_S   $fp, FP_OFF($sp)        # Save frame pointer
55 $LCFI01:
56         REG_S   ra, RA_OFF($sp)         # Save return address
57 $LCFI02:
58         move    $fp, $sp
59
60 $LCFI03:
61         move    t9, callback            # callback function pointer
62         REG_S   flags, A3_OFF($fp)      # flags
63
64         # Allocate at least 4 words in the argstack
65         LI      v0, 4 * FFI_SIZEOF_ARG
66         blt     bytes, v0, sixteen
67
68         ADDU    v0, bytes, 7    # make sure it is aligned 
69         and     v0, -8          # to an 8 byte boundry
70
71 sixteen:
72         SUBU    $sp, v0         # move the stack pointer to reflect the
73                                 # arg space
74
75         ADDU    a0, $sp, 4 * FFI_SIZEOF_ARG
76
77         jalr    t9
78         
79         REG_L   t0, A3_OFF($fp)         # load the flags word
80         SRL     t2, t0, 4               # shift our arg info
81         and     t0, ((1<<4)-1)          # mask out the return type
82                 
83         ADDU    $sp, 4 * FFI_SIZEOF_ARG         # adjust $sp to new args
84
85         bnez    t0, pass_d                      # make it quick for int
86         REG_L   a0, 0*FFI_SIZEOF_ARG($sp)       # just go ahead and load the
87         REG_L   a1, 1*FFI_SIZEOF_ARG($sp)       # four regs.
88         REG_L   a2, 2*FFI_SIZEOF_ARG($sp)
89         REG_L   a3, 3*FFI_SIZEOF_ARG($sp)
90         b       call_it
91
92 pass_d:
93         bne     t0, FFI_ARGS_D, pass_f
94         l.d     $f12, 0*FFI_SIZEOF_ARG($sp)     # load $fp regs from args
95         REG_L   a2,   2*FFI_SIZEOF_ARG($sp)     # passing a double
96         REG_L   a3,   3*FFI_SIZEOF_ARG($sp)
97         b       call_it
98
99 pass_f: 
100         bne     t0, FFI_ARGS_F, pass_d_d
101         l.s     $f12, 0*FFI_SIZEOF_ARG($sp)     # load $fp regs from args
102         REG_L   a1,   1*FFI_SIZEOF_ARG($sp)     # passing a float
103         REG_L   a2,   2*FFI_SIZEOF_ARG($sp)
104         REG_L   a3,   3*FFI_SIZEOF_ARG($sp)
105         b       call_it         
106
107 pass_d_d:               
108         bne     t0, FFI_ARGS_DD, pass_f_f
109         l.d     $f12, 0*FFI_SIZEOF_ARG($sp)     # load $fp regs from args
110         l.d     $f14, 2*FFI_SIZEOF_ARG($sp)     # passing two doubles
111         b       call_it
112
113 pass_f_f:       
114         bne     t0, FFI_ARGS_FF, pass_d_f
115         l.s     $f12, 0*FFI_SIZEOF_ARG($sp)     # load $fp regs from args
116         l.s     $f14, 1*FFI_SIZEOF_ARG($sp)     # passing two floats
117         REG_L   a2,   2*FFI_SIZEOF_ARG($sp)
118         REG_L   a3,   3*FFI_SIZEOF_ARG($sp)
119         b       call_it
120
121 pass_d_f:               
122         bne     t0, FFI_ARGS_DF, pass_f_d
123         l.d     $f12, 0*FFI_SIZEOF_ARG($sp)     # load $fp regs from args
124         l.s     $f14, 2*FFI_SIZEOF_ARG($sp)     # passing double and float
125         REG_L   a3,   3*FFI_SIZEOF_ARG($sp)
126         b       call_it
127
128 pass_f_d:               
129  # assume that the only other combination must be float then double
130  #      bne     t0, FFI_ARGS_F_D, call_it
131         l.s     $f12, 0*FFI_SIZEOF_ARG($sp)     # load $fp regs from args
132         l.d     $f14, 2*FFI_SIZEOF_ARG($sp)     # passing double and float
133
134 call_it:        
135         # Load the static chain pointer
136         REG_L   t7, SIZEOF_FRAME + 6*FFI_SIZEOF_ARG($fp)
137
138         # Load the function pointer
139         REG_L   t9, SIZEOF_FRAME + 5*FFI_SIZEOF_ARG($fp)
140
141         # If the return value pointer is NULL, assume no return value.
142         REG_L   t1, SIZEOF_FRAME + 4*FFI_SIZEOF_ARG($fp)
143         beqz    t1, noretval
144
145         bne     t2, FFI_TYPE_INT, retlonglong
146         jalr    t9
147         REG_L   t0, SIZEOF_FRAME + 4*FFI_SIZEOF_ARG($fp)
148         REG_S   v0, 0(t0)
149         b       epilogue
150
151 retlonglong:
152         # Really any 64-bit int, signed or not.
153         bne     t2, FFI_TYPE_UINT64, retfloat
154         jalr    t9
155         REG_L   t0, SIZEOF_FRAME + 4*FFI_SIZEOF_ARG($fp)
156         REG_S   v1, 4(t0)
157         REG_S   v0, 0(t0)
158         b       epilogue
159
160 retfloat:
161         bne     t2, FFI_TYPE_FLOAT, retdouble
162         jalr    t9
163         REG_L   t0, SIZEOF_FRAME + 4*FFI_SIZEOF_ARG($fp)
164         s.s     $f0, 0(t0)
165         b       epilogue
166
167 retdouble:      
168         bne     t2, FFI_TYPE_DOUBLE, noretval
169         jalr    t9
170         REG_L   t0, SIZEOF_FRAME + 4*FFI_SIZEOF_ARG($fp)
171         s.d     $f0, 0(t0)
172         b       epilogue
173         
174 noretval:       
175         jalr    t9
176         
177         # Epilogue
178 epilogue:       
179         move    $sp, $fp        
180         REG_L   $fp, FP_OFF($sp)        # Restore frame pointer
181         REG_L   ra, RA_OFF($sp)         # Restore return address
182         ADDU    $sp, SIZEOF_FRAME       # Fix stack pointer
183         j       ra
184
185 $LFE0:
186         .end    ffi_call_O32
187
188
189 /* ffi_closure_O32. Expects address of the passed-in ffi_closure
190         in t4 ($12). Stores any arguments passed in registers onto the
191         stack, then calls ffi_closure_mips_inner_O32, which
192         then decodes them.
193         
194         Stack layout:
195
196          3 - a3 save
197          2 - a2 save
198          1 - a1 save
199          0 - a0 save, original sp
200         -1 - ra save
201         -2 - fp save
202         -3 - $16 (s0) save
203         -4 - cprestore
204         -5 - return value high (v1)
205         -6 - return value low (v0)
206         -7 - f14 (le high, be low)
207         -8 - f14 (le low, be high)
208         -9 - f12 (le high, be low)
209        -10 - f12 (le low, be high)
210        -11 - Called function a5 save
211        -12 - Called function a4 save
212        -13 - Called function a3 save
213        -14 - Called function a2 save
214        -15 - Called function a1 save
215        -16 - Called function a0 save, our sp and fp point here
216          */
217         
218 #define SIZEOF_FRAME2   (16 * FFI_SIZEOF_ARG)
219 #define A3_OFF2         (SIZEOF_FRAME2 + 3 * FFI_SIZEOF_ARG)
220 #define A2_OFF2         (SIZEOF_FRAME2 + 2 * FFI_SIZEOF_ARG)
221 #define A1_OFF2         (SIZEOF_FRAME2 + 1 * FFI_SIZEOF_ARG)
222 #define A0_OFF2         (SIZEOF_FRAME2 + 0 * FFI_SIZEOF_ARG)
223 #define RA_OFF2         (SIZEOF_FRAME2 - 1 * FFI_SIZEOF_ARG)
224 #define FP_OFF2         (SIZEOF_FRAME2 - 2 * FFI_SIZEOF_ARG)
225 #define S0_OFF2         (SIZEOF_FRAME2 - 3 * FFI_SIZEOF_ARG)
226 #define GP_OFF2         (SIZEOF_FRAME2 - 4 * FFI_SIZEOF_ARG)
227 #define V1_OFF2         (SIZEOF_FRAME2 - 5 * FFI_SIZEOF_ARG)
228 #define V0_OFF2         (SIZEOF_FRAME2 - 6 * FFI_SIZEOF_ARG)
229 #define FA_1_1_OFF2     (SIZEOF_FRAME2 - 7 * FFI_SIZEOF_ARG)
230 #define FA_1_0_OFF2     (SIZEOF_FRAME2 - 8 * FFI_SIZEOF_ARG)
231 #define FA_0_1_OFF2     (SIZEOF_FRAME2 - 9 * FFI_SIZEOF_ARG)
232 #define FA_0_0_OFF2     (SIZEOF_FRAME2 - 10 * FFI_SIZEOF_ARG)
233 #define CALLED_A5_OFF2  (SIZEOF_FRAME2 - 11 * FFI_SIZEOF_ARG)
234 #define CALLED_A4_OFF2  (SIZEOF_FRAME2 - 12 * FFI_SIZEOF_ARG)
235
236         .text
237
238         .align  2
239         .globl  ffi_go_closure_O32
240         .ent    ffi_go_closure_O32
241 ffi_go_closure_O32:
242 $LFB1:
243         # Prologue
244         .frame  $fp, SIZEOF_FRAME2, ra
245         .set    noreorder
246         .cpload t9
247         .set    reorder
248         SUBU    $sp, SIZEOF_FRAME2
249         .cprestore GP_OFF2
250 $LCFI10:
251
252         REG_S   $16, S0_OFF2($sp)        # Save s0
253         REG_S   $fp, FP_OFF2($sp)        # Save frame pointer
254         REG_S   ra, RA_OFF2($sp)         # Save return address
255 $LCFI11:
256
257         move    $fp, $sp
258 $LCFI12:
259
260         REG_S   a0, A0_OFF2($fp)
261         REG_S   a1, A1_OFF2($fp)
262         REG_S   a2, A2_OFF2($fp)
263         REG_S   a3, A3_OFF2($fp)
264
265         # Load ABI enum to s0
266         REG_L   $16, 4($15)     # cif 
267         REG_L   $16, 0($16)     # abi is first member.
268
269         li      $13, 1          # FFI_O32
270         bne     $16, $13, 1f    # Skip fp save if FFI_O32_SOFT_FLOAT
271         
272         # Store all possible float/double registers.
273         s.d     $f12, FA_0_0_OFF2($fp)
274         s.d     $f14, FA_1_0_OFF2($fp)
275 1:
276         # prepare arguments for ffi_closure_mips_inner_O32
277         REG_L   a0, 4($15)       # cif 
278         REG_L   a1, 8($15)       # fun
279         move    a2, $15          # user_data = go closure
280         addu    a3, $fp, V0_OFF2 # rvalue
281
282         addu    t9, $fp, A0_OFF2 # ar
283         REG_S   t9, CALLED_A4_OFF2($fp)
284
285         addu    t9, $fp, FA_0_0_OFF2 #fpr
286         REG_S   t9, CALLED_A5_OFF2($fp)
287
288         b $do_closure
289
290 $LFE1:
291         .end ffi_go_closure_O32
292
293         .align  2
294         .globl  ffi_closure_O32
295         .ent    ffi_closure_O32
296 ffi_closure_O32:
297 $LFB2:
298         # Prologue
299         .frame  $fp, SIZEOF_FRAME2, ra
300         .set    noreorder
301         .cpload t9
302         .set    reorder
303         SUBU    $sp, SIZEOF_FRAME2
304         .cprestore GP_OFF2
305 $LCFI20:
306         REG_S   $16, S0_OFF2($sp)        # Save s0
307         REG_S   $fp, FP_OFF2($sp)        # Save frame pointer
308         REG_S   ra, RA_OFF2($sp)         # Save return address
309 $LCFI21:
310         move    $fp, $sp
311
312 $LCFI22:
313         # Store all possible argument registers. If there are more than
314         # four arguments, then they are stored above where we put a3.
315         REG_S   a0, A0_OFF2($fp)
316         REG_S   a1, A1_OFF2($fp)
317         REG_S   a2, A2_OFF2($fp)
318         REG_S   a3, A3_OFF2($fp)
319
320         # Load ABI enum to s0
321         REG_L   $16, 20($12)    # cif pointer follows tramp.
322         REG_L   $16, 0($16)     # abi is first member.
323
324         li      $13, 1          # FFI_O32
325         bne     $16, $13, 1f    # Skip fp save if FFI_O32_SOFT_FLOAT
326         
327         # Store all possible float/double registers.
328         s.d     $f12, FA_0_0_OFF2($fp)
329         s.d     $f14, FA_1_0_OFF2($fp)
330 1:      
331         # prepare arguments for ffi_closure_mips_inner_O32
332         REG_L   a0, 20($12)      # cif pointer follows tramp.
333         REG_L   a1, 24($12)      # fun
334         REG_L   a2, 28($12)      # user_data
335         addu    a3, $fp, V0_OFF2 # rvalue
336
337         addu    t9, $fp, A0_OFF2 # ar
338         REG_S   t9, CALLED_A4_OFF2($fp)
339
340         addu    t9, $fp, FA_0_0_OFF2 #fpr
341         REG_S   t9, CALLED_A5_OFF2($fp)
342
343 $do_closure:
344         la      t9, ffi_closure_mips_inner_O32
345         # Call ffi_closure_mips_inner_O32 to do the work.
346         jalr    t9
347
348         # Load the return value into the appropriate register.
349         move    $8, $2
350         li      $9, FFI_TYPE_VOID
351         beq     $8, $9, closure_done
352
353         li      $13, 1          # FFI_O32
354         bne     $16, $13, 1f    # Skip fp restore if FFI_O32_SOFT_FLOAT
355
356         li      $9, FFI_TYPE_FLOAT
357         l.s     $f0, V0_OFF2($fp)
358         beq     $8, $9, closure_done
359
360         li      $9, FFI_TYPE_DOUBLE
361         l.d     $f0, V0_OFF2($fp)
362         beq     $8, $9, closure_done
363 1:      
364         REG_L   $3, V1_OFF2($fp)
365         REG_L   $2, V0_OFF2($fp)
366
367 closure_done:
368         # Epilogue
369         move    $sp, $fp
370         REG_L   $16, S0_OFF2($sp)        # Restore s0
371         REG_L   $fp, FP_OFF2($sp)        # Restore frame pointer
372         REG_L   ra,  RA_OFF2($sp)        # Restore return address
373         ADDU    $sp, SIZEOF_FRAME2
374         j       ra
375 $LFE2:
376         .end    ffi_closure_O32
377
378 /* DWARF-2 unwind info. */
379
380         .section        .eh_frame,"a",@progbits
381 $Lframe0:
382         .4byte  $LECIE0-$LSCIE0  # Length of Common Information Entry
383 $LSCIE0:
384         .4byte  0x0      # CIE Identifier Tag
385         .byte   0x1      # CIE Version
386         .ascii "zR\0"    # CIE Augmentation
387         .uleb128 0x1     # CIE Code Alignment Factor
388         .sleb128 4       # CIE Data Alignment Factor
389         .byte   0x1f     # CIE RA Column
390         .uleb128 0x1     # Augmentation size
391         .byte   0x00     # FDE Encoding (absptr)
392         .byte   0xc      # DW_CFA_def_cfa
393         .uleb128 0x1d
394         .uleb128 0x0
395         .align  2
396 $LECIE0:
397
398 $LSFDE0:
399         .4byte  $LEFDE0-$LASFDE0         # FDE Length
400 $LASFDE0:
401         .4byte  $LASFDE0-$Lframe0        # FDE CIE offset
402         .4byte  $LFB0    # FDE initial location
403         .4byte  $LFE0-$LFB0      # FDE address range
404         .uleb128 0x0     # Augmentation size
405         .byte   0x4      # DW_CFA_advance_loc4
406         .4byte  $LCFI00-$LFB0
407         .byte   0xe      # DW_CFA_def_cfa_offset
408         .uleb128 0x18
409         .byte   0x4      # DW_CFA_advance_loc4
410         .4byte  $LCFI01-$LCFI00
411         .byte   0x11     # DW_CFA_offset_extended_sf
412         .uleb128 0x1e    # $fp
413         .sleb128 -2      # SIZEOF_FRAME2 - 2*FFI_SIZEOF_ARG($sp)
414         .byte   0x11     # DW_CFA_offset_extended_sf
415         .uleb128 0x1f    # $ra
416         .sleb128 -1      # SIZEOF_FRAME2 - 1*FFI_SIZEOF_ARG($sp)
417         .byte   0x4      # DW_CFA_advance_loc4
418         .4byte  $LCFI02-$LCFI01
419         .byte   0xc      # DW_CFA_def_cfa
420         .uleb128 0x1e
421         .uleb128 0x18
422         .align  2
423 $LEFDE0:
424
425 $LSFDE1:
426         .4byte  $LEFDE1-$LASFDE1         # FDE Length
427 $LASFDE1:
428         .4byte  $LASFDE1-$Lframe0        # FDE CIE offset
429         .4byte  $LFB1    # FDE initial location
430         .4byte  $LFE1-$LFB1      # FDE address range
431         .uleb128 0x0     # Augmentation size
432         .byte   0x4      # DW_CFA_advance_loc4
433         .4byte  $LCFI10-$LFB1
434         .byte   0xe      # DW_CFA_def_cfa_offset
435         .uleb128 SIZEOF_FRAME2
436         .byte   0x4      # DW_CFA_advance_loc4
437         .4byte  $LCFI11-$LCFI10
438         .byte   0x11     # DW_CFA_offset_extended_sf
439         .uleb128 0x10    # $16
440         .sleb128 -3      # SIZEOF_FRAME2 - 3*FFI_SIZEOF_ARG($sp)
441         .byte   0x11     # DW_CFA_offset_extended_sf
442         .uleb128 0x1e    # $fp
443         .sleb128 -2      # SIZEOF_FRAME2 - 2*FFI_SIZEOF_ARG($sp)
444         .byte   0x11     # DW_CFA_offset_extended_sf
445         .uleb128 0x1f    # $ra
446         .sleb128 -1      # SIZEOF_FRAME2 - 1*FFI_SIZEOF_ARG($sp)
447         .byte   0x4      # DW_CFA_advance_loc4
448         .4byte  $LCFI12-$LCFI11
449         .byte   0xc      # DW_CFA_def_cfa
450         .uleb128 0x1e
451         .uleb128 SIZEOF_FRAME2
452         .align  2
453 $LEFDE1:
454
455 $LSFDE2:
456         .4byte  $LEFDE2-$LASFDE2         # FDE Length
457 $LASFDE2:
458         .4byte  $LASFDE2-$Lframe0        # FDE CIE offset
459         .4byte  $LFB2    # FDE initial location
460         .4byte  $LFE2-$LFB2      # FDE address range
461         .uleb128 0x0     # Augmentation size
462         .byte   0x4      # DW_CFA_advance_loc4
463         .4byte  $LCFI20-$LFB2
464         .byte   0xe      # DW_CFA_def_cfa_offset
465         .uleb128 SIZEOF_FRAME2
466         .byte   0x4      # DW_CFA_advance_loc4
467         .4byte  $LCFI21-$LCFI20
468         .byte   0x11     # DW_CFA_offset_extended_sf
469         .uleb128 0x10    # $16
470         .sleb128 -3      # SIZEOF_FRAME2 - 3*FFI_SIZEOF_ARG($sp)
471         .byte   0x11     # DW_CFA_offset_extended_sf
472         .uleb128 0x1e    # $fp
473         .sleb128 -2      # SIZEOF_FRAME2 - 2*FFI_SIZEOF_ARG($sp)
474         .byte   0x11     # DW_CFA_offset_extended_sf
475         .uleb128 0x1f    # $ra
476         .sleb128 -1      # SIZEOF_FRAME2 - 1*FFI_SIZEOF_ARG($sp)
477         .byte   0x4      # DW_CFA_advance_loc4
478         .4byte  $LCFI22-$LCFI21
479         .byte   0xc      # DW_CFA_def_cfa
480         .uleb128 0x1e
481         .uleb128 SIZEOF_FRAME2
482         .align  2
483 $LEFDE2:
484
485 #endif