OSDN Git Service

* src/pa/ffi.c (ffi_struct_type): Rename FFI_TYPE_SMALL_STRUCT1
[pf3gnuchains/gcc-fork.git] / libffi / src / pa / linux.S
1 /* -----------------------------------------------------------------------
2    linux.S - (c) 2003-2004 Randolph Chung <tausq@debian.org>
3
4    HPPA 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, 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    ----------------------------------------------------------------------- */
25
26 #define LIBFFI_ASM
27 #include <fficonfig.h>
28 #include <ffi.h>
29
30         .text
31         .level 1.1
32         .align 4
33
34         /* void ffi_call_LINUX(void (*)(char *, extended_cif *),
35                                extended_cif *ecif,
36                                unsigned bytes,
37                                unsigned flags,
38                                unsigned *rvalue,
39                                void (*fn)());
40          */
41
42         .export ffi_call_LINUX,code
43         .import ffi_prep_args_LINUX,code
44
45         .type ffi_call_LINUX, @function
46 .LFB1:
47 ffi_call_LINUX:
48         .proc
49         .callinfo FRAME=64,CALLS,SAVE_RP,SAVE_SP,ENTRY_GR=4
50         .entry
51         stw %rp, -20(%sp)
52         copy %r3, %r1
53 .LCFI11:
54
55         copy %sp, %r3
56 .LCFI12:
57
58         /* Setup the stack for calling prep_args...
59            We want the stack to look like this:
60
61            [ Previous stack                            ] <- %r3
62
63            [ 64-bytes register save area               ] <- %r4
64
65            [ Stack space for actual call, passed as    ] <- %arg0
66            [     arg0 to ffi_prep_args_LINUX           ]
67
68            [ Stack for calling prep_args               ] <- %sp
69          */
70
71         stwm %r1, 64(%sp)
72         stw %r4, 12(%r3)
73 .LCFI13:
74         copy %sp, %r4
75
76         addl %arg2, %r4, %arg0                  /* arg stack */
77         stw %arg3, -48(%r3)                     /* save flags; we need it later */
78
79         /* Call prep_args:
80            %arg0(stack) -- set up above
81            %arg1(ecif) -- same as incoming param
82            %arg2(bytes) -- same as incoming param */
83         bl ffi_prep_args_LINUX,%r2
84         ldo 64(%arg0), %sp
85         ldo -64(%sp), %sp
86
87         /* now %sp should point where %arg0 was pointing.  */
88
89         /* Load the arguments that should be passed in registers
90            The fp args were loaded by the prep_args function.  */
91         ldw -36(%sp), %arg0
92         ldw -40(%sp), %arg1
93         ldw -44(%sp), %arg2
94         ldw -48(%sp), %arg3
95
96         /* in case the function is going to return a structure
97            we need to give it a place to put the result.  */
98         ldw -52(%r3), %ret0                     /* %ret0 <- rvalue */
99         ldw -56(%r3), %r22                      /* %r22 <- function to call */
100         bl $$dyncall, %r31                      /* Call the user function */
101         copy %r31, %rp
102
103         /* Prepare to store the result; we need to recover flags and rvalue.  */
104         ldw -48(%r3), %r21                      /* r21 <- flags */
105         ldw -52(%r3), %r20                      /* r20 <- rvalue */
106
107         /* Store the result according to the return type.  */
108
109 checksmst3:
110         comib,<>,n FFI_TYPE_SMALL_STRUCT3, %r21, checksmst567
111         /* 3-byte structs are returned in ret0 as ??xxyyzz.  Shift
112            left 8 bits to write to the result structure.  */
113         zdep %ret0, 23, 24, %r22
114         b done
115         stw %r22, 0(%r20)
116
117 checksmst567:
118         /* 5-7 byte values are returned right justified:
119               ret0     ret1
120            5: ??????aa bbccddee
121            6: ????aabb ccddeeff
122            7: ??aabbcc ddeeffgg
123
124            To store this in the result, write the first 4 bytes into a temp
125            register using shrpw (t1 = aabbccdd), followed by a rotation of
126            ret1:
127
128               ret0     ret1        ret1
129            5: ??????aa bbccddee -> eebbccdd (rotate 8)
130            6: ????aabb ccddeeff -> eeffccdd (rotate 16)
131            7: ??aabbcc ddeeffgg -> eeffggdd (rotate 24)
132
133            then we write (t1, ret1) into the result.  */
134
135         addi,<> -FFI_TYPE_SMALL_STRUCT5,%r21,%r0
136         ldi 8, %r22
137         addi,<> -FFI_TYPE_SMALL_STRUCT6,%r21,%r0
138         ldi 16, %r22
139         addi,<> -FFI_TYPE_SMALL_STRUCT7,%r21,%r0
140         ldi 24, %r22
141
142         /* This relies on all the FFI_TYPE_*_STRUCT* defines being <0 */
143         cmpib,<=,n 0, %r21, checkint8
144         mtsar %r22
145
146         shrpw %ret0, %ret1, %sar, %ret0  /* ret0 = aabbccdd */
147         shrpw %ret1, %ret1, %sar, %ret1  /* rotate ret1 */
148         
149         stw %ret0, 0(%r20)
150         b done
151         stw %ret1, 4(%r20)
152
153 checkint8:
154         comib,<>,n FFI_TYPE_UINT8, %r21, checkint16
155         b done
156         stb %ret0, 0(%r20)
157
158 checkint16:
159         comib,<>,n FFI_TYPE_UINT16, %r21, checkint32
160         b done
161         sth %ret0, 0(%r20)
162
163 checkint32:
164         comib,<>,n FFI_TYPE_UINT32, %r21, checkint
165         b done
166         stw %ret0, 0(%r20)
167
168 checkint:
169         comib,<>,n FFI_TYPE_INT, %r21, checkll
170         b done
171         stw %ret0, 0(%r20)
172
173 checkll:
174         comib,<>,n FFI_TYPE_UINT64, %r21, checkdbl
175         stw %ret0, 0(%r20)
176         b done
177         stw %ret1, 4(%r20)
178
179 checkdbl:
180         comib,<>,n FFI_TYPE_DOUBLE, %r21, checkfloat
181         b done
182         fstd %fr4,0(%r20)
183
184 checkfloat:
185         comib,<>,n FFI_TYPE_FLOAT, %r21, done
186         fstw %fr4L,0(%r20)
187
188         /* structure returns are either handled by one of the
189            INT/UINT64 cases above, or, if passed by pointer,
190            is handled by the callee.  */
191
192 done:
193         /* all done, return */
194         copy %r4, %sp                           /* pop arg stack */
195         ldw 12(%r3), %r4
196         ldwm -64(%sp), %r3                      /* .. and pop stack */
197         ldw -20(%sp), %rp
198         bv %r0(%rp)
199         nop
200         .exit
201         .procend
202 .LFE1:
203
204         /* void ffi_closure_LINUX(void);
205            Called with closure argument in %r21 */
206         .export ffi_closure_LINUX,code
207         .import ffi_closure_inner_LINUX,code
208
209         .type ffi_closure_LINUX, @function
210 .LFB2:
211 ffi_closure_LINUX:
212         .proc
213         .callinfo FRAME=64,CALLS,SAVE_RP,SAVE_SP,ENTRY_GR=3
214         .entry
215
216         stw %rp, -20(%sp)
217 .LCFI20:
218         copy %r3, %r1
219 .LCFI21:
220         copy %sp, %r3
221 .LCFI22:
222         stwm %r1, 64(%sp)
223
224         /* Put arguments onto the stack and call ffi_closure_inner.  */
225         stw %arg0, -36(%r3)
226         stw %arg1, -40(%r3)
227         stw %arg2, -44(%r3)
228         stw %arg3, -48(%r3)
229
230         copy %r21, %arg0
231         bl ffi_closure_inner_LINUX, %r2
232         copy %r3, %arg1
233
234         ldwm -64(%sp), %r3
235         ldw -20(%sp), %rp
236         ldw -36(%sp), %ret0
237         bv %r0(%r2)
238         ldw -40(%sp), %ret1
239
240         .exit
241         .procend
242 .LFE2:
243
244         .section        ".eh_frame",EH_FRAME_FLAGS,@progbits
245 .Lframe1:
246         .word   .LECIE1-.LSCIE1 ;# Length of Common Information Entry
247 .LSCIE1:
248         .word   0x0     ;# CIE Identifier Tag
249         .byte   0x1     ;# CIE Version
250         .ascii "\0"     ;# CIE Augmentation
251         .uleb128 0x1    ;# CIE Code Alignment Factor
252         .sleb128 4      ;# CIE Data Alignment Factor
253         .byte   0x2     ;# CIE RA Column
254         .byte   0xc     ;# DW_CFA_def_cfa
255         .uleb128 0x1e
256         .uleb128 0x0
257         .align 4
258 .LECIE1:
259 .LSFDE1:
260         .word   .LEFDE1-.LASFDE1        ;# FDE Length
261 .LASFDE1:
262         .word   .LASFDE1-.Lframe1       ;# FDE CIE offset
263         .word   .LFB1   ;# FDE initial location
264         .word   .LFE1-.LFB1     ;# FDE address range
265
266         .byte   0x4     ;# DW_CFA_advance_loc4
267         .word   .LCFI11-.LFB1
268         .byte   0x83    ;# DW_CFA_offset, column 0x3
269         .uleb128 0x0
270         .byte   0x11    ;# DW_CFA_offset_extended_sf; save r2 at [r30-20]
271         .uleb128 0x2
272         .sleb128 -5
273
274         .byte   0x4     ;# DW_CFA_advance_loc4
275         .word   .LCFI12-.LCFI11
276         .byte   0xd     ;# DW_CFA_def_cfa_register = r3
277         .uleb128 0x3
278
279         .byte   0x4     ;# DW_CFA_advance_loc4
280         .word   .LCFI13-.LCFI12
281         .byte   0x84    ;# DW_CFA_offset, column 0x4
282         .uleb128 0x3
283
284         .align 4
285 .LEFDE1:
286
287 .LSFDE2:
288         .word   .LEFDE2-.LASFDE2        ;# FDE Length
289 .LASFDE2:
290         .word   .LASFDE2-.Lframe1       ;# FDE CIE offset
291         .word   .LFB2   ;# FDE initial location
292         .word   .LFE2-.LFB2     ;# FDE address range
293         .byte   0x4     ;# DW_CFA_advance_loc4
294         .word   .LCFI21-.LFB2
295         .byte   0x83    ;# DW_CFA_offset, column 0x3
296         .uleb128 0x0
297         .byte   0x11    ;# DW_CFA_offset_extended_sf
298         .uleb128 0x2
299         .sleb128 -5
300
301         .byte   0x4     ;# DW_CFA_advance_loc4
302         .word   .LCFI12-.LCFI11
303         .byte   0xd     ;# DW_CFA_def_cfa_register = r3
304         .uleb128 0x3
305
306         .align 4
307 .LEFDE2: