Mercurial > hg > CbC > CbC_gcc

comparison libffi/src/mips/n32.S @ 111:04ced10e8804

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents
children
comparison
equal deleted inserted replaced
68:561a7518be6b 111:04ced10e8804
1 /* -----------------------------------------------------------------------
2 n32.S - Copyright (c) 1996, 1998, 2005, 2007, 2009, 2010 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 n32 */
32
33 #if defined(FFI_MIPS_N32)
34
35 #define callback a0
36 #define bytes a2
37 #define flags a3
38 #define raddr a4
39 #define fn a5
40
41 #define SIZEOF_FRAME ( 8 * FFI_SIZEOF_ARG )
42
43 #ifdef __GNUC__
44 .abicalls
45 #endif
46 .set mips4
47 .text
48 .align 2
49 .globl ffi_call_N32
50 .ent ffi_call_N32
51 ffi_call_N32:
52 .LFB3:
53 .frame $fp, SIZEOF_FRAME, ra
54 .mask 0xc0000000,-FFI_SIZEOF_ARG
55 .fmask 0x00000000,0
56
57 # Prologue
58 SUBU $sp, SIZEOF_FRAME # Frame size
59 .LCFI0:
60 REG_S $fp, SIZEOF_FRAME - 2*FFI_SIZEOF_ARG($sp) # Save frame pointer
61 REG_S ra, SIZEOF_FRAME - 1*FFI_SIZEOF_ARG($sp) # Save return address
62 .LCFI1:
63 move $fp, $sp
64 .LCFI3:
65 move t9, callback # callback function pointer
66 REG_S bytes, 2*FFI_SIZEOF_ARG($fp) # bytes
67 REG_S flags, 3*FFI_SIZEOF_ARG($fp) # flags
68 REG_S raddr, 4*FFI_SIZEOF_ARG($fp) # raddr
69 REG_S fn, 5*FFI_SIZEOF_ARG($fp) # fn
70
71 # Allocate at least 4 words in the argstack
72 move v0, bytes
73 bge bytes, 4 * FFI_SIZEOF_ARG, bigger
74 LI v0, 4 * FFI_SIZEOF_ARG
75 b sixteen
76
77 bigger:
78 ADDU t4, v0, 2 * FFI_SIZEOF_ARG -1 # make sure it is aligned
79 and v0, t4, -2 * FFI_SIZEOF_ARG # to a proper boundry.
80
81 sixteen:
82 SUBU $sp, $sp, v0 # move the stack pointer to reflect the
83 # arg space
84
85 move a0, $sp # 4 * FFI_SIZEOF_ARG
86 ADDU a3, $fp, 3 * FFI_SIZEOF_ARG
87
88 # Call ffi_prep_args
89 jal t9
90
91 # Copy the stack pointer to t9
92 move t9, $sp
93
94 # Fix the stack if there are more than 8 64bit slots worth
95 # of arguments.
96
97 # Load the number of bytes
98 REG_L t6, 2*FFI_SIZEOF_ARG($fp)
99
100 # Is it bigger than 8 * FFI_SIZEOF_ARG?
101 daddiu t8, t6, -(8 * FFI_SIZEOF_ARG)
102 bltz t8, loadregs
103
104 ADDU t9, t9, t8
105
106 loadregs:
107
108 REG_L t6, 3*FFI_SIZEOF_ARG($fp) # load the flags word into t6.
109
110 and t4, t6, ((1<<FFI_FLAG_BITS)-1)
111 REG_L a0, 0*FFI_SIZEOF_ARG(t9)
112 beqz t4, arg1_next
113 bne t4, FFI_TYPE_FLOAT, arg1_doublep
114 l.s $f12, 0*FFI_SIZEOF_ARG(t9)
115 b arg1_next
116 arg1_doublep:
117 l.d $f12, 0*FFI_SIZEOF_ARG(t9)
118 arg1_next:
119
120 SRL t4, t6, 1*FFI_FLAG_BITS
121 and t4, ((1<<FFI_FLAG_BITS)-1)
122 REG_L a1, 1*FFI_SIZEOF_ARG(t9)
123 beqz t4, arg2_next
124 bne t4, FFI_TYPE_FLOAT, arg2_doublep
125 l.s $f13, 1*FFI_SIZEOF_ARG(t9)
126 b arg2_next
127 arg2_doublep:
128 l.d $f13, 1*FFI_SIZEOF_ARG(t9)
129 arg2_next:
130
131 SRL t4, t6, 2*FFI_FLAG_BITS
132 and t4, ((1<<FFI_FLAG_BITS)-1)
133 REG_L a2, 2*FFI_SIZEOF_ARG(t9)
134 beqz t4, arg3_next
135 bne t4, FFI_TYPE_FLOAT, arg3_doublep
136 l.s $f14, 2*FFI_SIZEOF_ARG(t9)
137 b arg3_next
138 arg3_doublep:
139 l.d $f14, 2*FFI_SIZEOF_ARG(t9)
140 arg3_next:
141
142 SRL t4, t6, 3*FFI_FLAG_BITS
143 and t4, ((1<<FFI_FLAG_BITS)-1)
144 REG_L a3, 3*FFI_SIZEOF_ARG(t9)
145 beqz t4, arg4_next
146 bne t4, FFI_TYPE_FLOAT, arg4_doublep
147 l.s $f15, 3*FFI_SIZEOF_ARG(t9)
148 b arg4_next
149 arg4_doublep:
150 l.d $f15, 3*FFI_SIZEOF_ARG(t9)
151 arg4_next:
152
153 SRL t4, t6, 4*FFI_FLAG_BITS
154 and t4, ((1<<FFI_FLAG_BITS)-1)
155 REG_L a4, 4*FFI_SIZEOF_ARG(t9)
156 beqz t4, arg5_next
157 bne t4, FFI_TYPE_FLOAT, arg5_doublep
158 l.s $f16, 4*FFI_SIZEOF_ARG(t9)
159 b arg5_next
160 arg5_doublep:
161 l.d $f16, 4*FFI_SIZEOF_ARG(t9)
162 arg5_next:
163
164 SRL t4, t6, 5*FFI_FLAG_BITS
165 and t4, ((1<<FFI_FLAG_BITS)-1)
166 REG_L a5, 5*FFI_SIZEOF_ARG(t9)
167 beqz t4, arg6_next
168 bne t4, FFI_TYPE_FLOAT, arg6_doublep
169 l.s $f17, 5*FFI_SIZEOF_ARG(t9)
170 b arg6_next
171 arg6_doublep:
172 l.d $f17, 5*FFI_SIZEOF_ARG(t9)
173 arg6_next:
174
175 SRL t4, t6, 6*FFI_FLAG_BITS
176 and t4, ((1<<FFI_FLAG_BITS)-1)
177 REG_L a6, 6*FFI_SIZEOF_ARG(t9)
178 beqz t4, arg7_next
179 bne t4, FFI_TYPE_FLOAT, arg7_doublep
180 l.s $f18, 6*FFI_SIZEOF_ARG(t9)
181 b arg7_next
182 arg7_doublep:
183 l.d $f18, 6*FFI_SIZEOF_ARG(t9)
184 arg7_next:
185
186 SRL t4, t6, 7*FFI_FLAG_BITS
187 and t4, ((1<<FFI_FLAG_BITS)-1)
188 REG_L a7, 7*FFI_SIZEOF_ARG(t9)
189 beqz t4, arg8_next
190 bne t4, FFI_TYPE_FLOAT, arg8_doublep
191 l.s $f19, 7*FFI_SIZEOF_ARG(t9)
192 b arg8_next
193 arg8_doublep:
194 l.d $f19, 7*FFI_SIZEOF_ARG(t9)
195 arg8_next:
196
197 callit:
198 # Load the function pointer
199 REG_L t9, 5*FFI_SIZEOF_ARG($fp)
200
201 # If the return value pointer is NULL, assume no return value.
202 REG_L t5, 4*FFI_SIZEOF_ARG($fp)
203 beqz t5, noretval
204
205 # Shift the return type flag over
206 SRL t6, 8*FFI_FLAG_BITS
207
208 beq t6, FFI_TYPE_SINT32, retint
209 bne t6, FFI_TYPE_INT, retfloat
210 retint:
211 jal t9
212 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
213 REG_S v0, 0(t4)
214 b epilogue
215
216 retfloat:
217 bne t6, FFI_TYPE_FLOAT, retdouble
218 jal t9
219 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
220 s.s $f0, 0(t4)
221 b epilogue
222
223 retdouble:
224 bne t6, FFI_TYPE_DOUBLE, retstruct_d
225 jal t9
226 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
227 s.d $f0, 0(t4)
228 b epilogue
229
230 retstruct_d:
231 bne t6, FFI_TYPE_STRUCT_D, retstruct_f
232 jal t9
233 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
234 s.d $f0, 0(t4)
235 b epilogue
236
237 retstruct_f:
238 bne t6, FFI_TYPE_STRUCT_F, retstruct_d_d
239 jal t9
240 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
241 s.s $f0, 0(t4)
242 b epilogue
243
244 retstruct_d_d:
245 bne t6, FFI_TYPE_STRUCT_DD, retstruct_f_f
246 jal t9
247 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
248 s.d $f0, 0(t4)
249 s.d $f2, 8(t4)
250 b epilogue
251
252 retstruct_f_f:
253 bne t6, FFI_TYPE_STRUCT_FF, retstruct_d_f
254 jal t9
255 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
256 s.s $f0, 0(t4)
257 s.s $f2, 4(t4)
258 b epilogue
259
260 retstruct_d_f:
261 bne t6, FFI_TYPE_STRUCT_DF, retstruct_f_d
262 jal t9
263 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
264 s.d $f0, 0(t4)
265 s.s $f2, 8(t4)
266 b epilogue
267
268 retstruct_f_d:
269 bne t6, FFI_TYPE_STRUCT_FD, retstruct_d_soft
270 jal t9
271 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
272 s.s $f0, 0(t4)
273 s.d $f2, 8(t4)
274 b epilogue
275
276 retstruct_d_soft:
277 bne t6, FFI_TYPE_STRUCT_D_SOFT, retstruct_f_soft
278 jal t9
279 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
280 sd v0, 0(t4)
281 b epilogue
282
283 retstruct_f_soft:
284 bne t6, FFI_TYPE_STRUCT_F_SOFT, retstruct_d_d_soft
285 jal t9
286 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
287 sw v0, 0(t4)
288 b epilogue
289
290 retstruct_d_d_soft:
291 bne t6, FFI_TYPE_STRUCT_DD_SOFT, retstruct_f_f_soft
292 jal t9
293 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
294 sd v0, 0(t4)
295 sd v1, 8(t4)
296 b epilogue
297
298 retstruct_f_f_soft:
299 bne t6, FFI_TYPE_STRUCT_FF_SOFT, retstruct_d_f_soft
300 jal t9
301 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
302 sw v0, 0(t4)
303 sw v1, 4(t4)
304 b epilogue
305
306 retstruct_d_f_soft:
307 bne t6, FFI_TYPE_STRUCT_DF_SOFT, retstruct_f_d_soft
308 jal t9
309 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
310 sd v0, 0(t4)
311 sw v1, 8(t4)
312 b epilogue
313
314 retstruct_f_d_soft:
315 bne t6, FFI_TYPE_STRUCT_FD_SOFT, retstruct_small
316 jal t9
317 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
318 sw v0, 0(t4)
319 sd v1, 8(t4)
320 b epilogue
321
322 retstruct_small:
323 bne t6, FFI_TYPE_STRUCT_SMALL, retstruct_small2
324 jal t9
325 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
326 REG_S v0, 0(t4)
327 b epilogue
328
329 retstruct_small2:
330 bne t6, FFI_TYPE_STRUCT_SMALL2, retstruct
331 jal t9
332 REG_L t4, 4*FFI_SIZEOF_ARG($fp)
333 REG_S v0, 0(t4)
334 REG_S v1, 8(t4)
335 b epilogue
336
337 retstruct:
338 noretval:
339 jal t9
340
341 # Epilogue
342 epilogue:
343 move $sp, $fp
344 REG_L $fp, SIZEOF_FRAME - 2*FFI_SIZEOF_ARG($sp) # Restore frame pointer
345 REG_L ra, SIZEOF_FRAME - 1*FFI_SIZEOF_ARG($sp) # Restore return address
346 ADDU $sp, SIZEOF_FRAME # Fix stack pointer
347 j ra
348
349 .LFE3:
350 .end ffi_call_N32
351
352 /* ffi_closure_N32. Expects address of the passed-in ffi_closure in t0
353 ($12). Stores any arguments passed in registers onto the stack,
354 then calls ffi_closure_mips_inner_N32, which then decodes
355 them.
356
357 Stack layout:
358
359 20 - Start of parameters, original sp
360 19 - Called function a7 save
361 18 - Called function a6 save
362 17 - Called function a5 save
363 16 - Called function a4 save
364 15 - Called function a3 save
365 14 - Called function a2 save
366 13 - Called function a1 save
367 12 - Called function a0 save
368 11 - Called function f19
369 10 - Called function f18
370 9 - Called function f17
371 8 - Called function f16
372 7 - Called function f15
373 6 - Called function f14
374 5 - Called function f13
375 4 - Called function f12
376 3 - return value high (v1 or $f2)
377 2 - return value low (v0 or $f0)
378 1 - ra save
379 0 - gp save our sp points here
380 */
381
382 #define SIZEOF_FRAME2 (20 * FFI_SIZEOF_ARG)
383
384 #define A7_OFF2 (19 * FFI_SIZEOF_ARG)
385 #define A6_OFF2 (18 * FFI_SIZEOF_ARG)
386 #define A5_OFF2 (17 * FFI_SIZEOF_ARG)
387 #define A4_OFF2 (16 * FFI_SIZEOF_ARG)
388 #define A3_OFF2 (15 * FFI_SIZEOF_ARG)
389 #define A2_OFF2 (14 * FFI_SIZEOF_ARG)
390 #define A1_OFF2 (13 * FFI_SIZEOF_ARG)
391 #define A0_OFF2 (12 * FFI_SIZEOF_ARG)
392
393 #define F19_OFF2 (11 * FFI_SIZEOF_ARG)
394 #define F18_OFF2 (10 * FFI_SIZEOF_ARG)
395 #define F17_OFF2 (9 * FFI_SIZEOF_ARG)
396 #define F16_OFF2 (8 * FFI_SIZEOF_ARG)
397 #define F15_OFF2 (7 * FFI_SIZEOF_ARG)
398 #define F14_OFF2 (6 * FFI_SIZEOF_ARG)
399 #define F13_OFF2 (5 * FFI_SIZEOF_ARG)
400 #define F12_OFF2 (4 * FFI_SIZEOF_ARG)
401
402 #define V1_OFF2 (3 * FFI_SIZEOF_ARG)
403 #define V0_OFF2 (2 * FFI_SIZEOF_ARG)
404
405 #define RA_OFF2 (1 * FFI_SIZEOF_ARG)
406 #define GP_OFF2 (0 * FFI_SIZEOF_ARG)
407
408 .align 2
409 .globl ffi_closure_N32
410 .ent ffi_closure_N32
411 ffi_closure_N32:
412 .LFB2:
413 .frame $sp, SIZEOF_FRAME2, ra
414 .mask 0x90000000,-(SIZEOF_FRAME2 - RA_OFF2)
415 .fmask 0x00000000,0
416 SUBU $sp, SIZEOF_FRAME2
417 .LCFI5:
418 .cpsetup t9, GP_OFF2, ffi_closure_N32
419 REG_S ra, RA_OFF2($sp) # Save return address
420 .LCFI6:
421 # Store all possible argument registers. If there are more than
422 # fit in registers, then they were stored on the stack.
423 REG_S a0, A0_OFF2($sp)
424 REG_S a1, A1_OFF2($sp)
425 REG_S a2, A2_OFF2($sp)
426 REG_S a3, A3_OFF2($sp)
427 REG_S a4, A4_OFF2($sp)
428 REG_S a5, A5_OFF2($sp)
429 REG_S a6, A6_OFF2($sp)
430 REG_S a7, A7_OFF2($sp)
431
432 # Store all possible float/double registers.
433 s.d $f12, F12_OFF2($sp)
434 s.d $f13, F13_OFF2($sp)
435 s.d $f14, F14_OFF2($sp)
436 s.d $f15, F15_OFF2($sp)
437 s.d $f16, F16_OFF2($sp)
438 s.d $f17, F17_OFF2($sp)
439 s.d $f18, F18_OFF2($sp)
440 s.d $f19, F19_OFF2($sp)
441
442 # Call ffi_closure_mips_inner_N32 to do the real work.
443 LA t9, ffi_closure_mips_inner_N32
444 move a0, $12 # Pointer to the ffi_closure
445 ADDU a1, $sp, V0_OFF2
446 ADDU a2, $sp, A0_OFF2
447 ADDU a3, $sp, F12_OFF2
448 jalr t9
449
450 # Return flags are in v0
451 bne v0, FFI_TYPE_SINT32, cls_retint
452 lw v0, V0_OFF2($sp)
453 b cls_epilogue
454
455 cls_retint:
456 bne v0, FFI_TYPE_INT, cls_retfloat
457 REG_L v0, V0_OFF2($sp)
458 b cls_epilogue
459
460 cls_retfloat:
461 bne v0, FFI_TYPE_FLOAT, cls_retdouble
462 l.s $f0, V0_OFF2($sp)
463 b cls_epilogue
464
465 cls_retdouble:
466 bne v0, FFI_TYPE_DOUBLE, cls_retstruct_d
467 l.d $f0, V0_OFF2($sp)
468 b cls_epilogue
469
470 cls_retstruct_d:
471 bne v0, FFI_TYPE_STRUCT_D, cls_retstruct_f
472 l.d $f0, V0_OFF2($sp)
473 b cls_epilogue
474
475 cls_retstruct_f:
476 bne v0, FFI_TYPE_STRUCT_F, cls_retstruct_d_d
477 l.s $f0, V0_OFF2($sp)
478 b cls_epilogue
479
480 cls_retstruct_d_d:
481 bne v0, FFI_TYPE_STRUCT_DD, cls_retstruct_f_f
482 l.d $f0, V0_OFF2($sp)
483 l.d $f2, V1_OFF2($sp)
484 b cls_epilogue
485
486 cls_retstruct_f_f:
487 bne v0, FFI_TYPE_STRUCT_FF, cls_retstruct_d_f
488 l.s $f0, V0_OFF2($sp)
489 l.s $f2, V1_OFF2($sp)
490 b cls_epilogue
491
492 cls_retstruct_d_f:
493 bne v0, FFI_TYPE_STRUCT_DF, cls_retstruct_f_d
494 l.d $f0, V0_OFF2($sp)
495 l.s $f2, V1_OFF2($sp)
496 b cls_epilogue
497
498 cls_retstruct_f_d:
499 bne v0, FFI_TYPE_STRUCT_FD, cls_retstruct_small2
500 l.s $f0, V0_OFF2($sp)
501 l.d $f2, V1_OFF2($sp)
502 b cls_epilogue
503
504 cls_retstruct_small2:
505 REG_L v0, V0_OFF2($sp)
506 REG_L v1, V1_OFF2($sp)
507
508 # Epilogue
509 cls_epilogue:
510 REG_L ra, RA_OFF2($sp) # Restore return address
511 .cpreturn
512 ADDU $sp, SIZEOF_FRAME2
513 j ra
514 .LFE2:
515 .end ffi_closure_N32
516
517 #ifdef __GNUC__
518 .section .eh_frame,"aw",@progbits
519 .Lframe1:
520 .4byte .LECIE1-.LSCIE1 # length
521 .LSCIE1:
522 .4byte 0x0 # CIE
523 .byte 0x1 # Version 1
524 .ascii "\000" # Augmentation
525 .uleb128 0x1 # Code alignment 1
526 .sleb128 -4 # Data alignment -4
527 .byte 0x1f # Return Address $31
528 .byte 0xc # DW_CFA_def_cfa
529 .uleb128 0x1d # in $sp
530 .uleb128 0x0 # offset 0
531 .align EH_FRAME_ALIGN
532 .LECIE1:
533
534 .LSFDE1:
535 .4byte .LEFDE1-.LASFDE1 # length.
536 .LASFDE1:
537 .4byte .LASFDE1-.Lframe1 # CIE_pointer.
538 FDE_ADDR_BYTES .LFB3 # initial_location.
539 FDE_ADDR_BYTES .LFE3-.LFB3 # address_range.
540 .byte 0x4 # DW_CFA_advance_loc4
541 .4byte .LCFI0-.LFB3 # to .LCFI0
542 .byte 0xe # DW_CFA_def_cfa_offset
543 .uleb128 SIZEOF_FRAME # adjust stack.by SIZEOF_FRAME
544 .byte 0x4 # DW_CFA_advance_loc4
545 .4byte .LCFI1-.LCFI0 # to .LCFI1
546 .byte 0x9e # DW_CFA_offset of $fp
547 .uleb128 2*FFI_SIZEOF_ARG/4 #
548 .byte 0x9f # DW_CFA_offset of ra
549 .uleb128 1*FFI_SIZEOF_ARG/4 #
550 .byte 0x4 # DW_CFA_advance_loc4
551 .4byte .LCFI3-.LCFI1 # to .LCFI3
552 .byte 0xd # DW_CFA_def_cfa_register
553 .uleb128 0x1e # in $fp
554 .align EH_FRAME_ALIGN
555 .LEFDE1:
556 .LSFDE3:
557 .4byte .LEFDE3-.LASFDE3 # length
558 .LASFDE3:
559 .4byte .LASFDE3-.Lframe1 # CIE_pointer.
560 FDE_ADDR_BYTES .LFB2 # initial_location.
561 FDE_ADDR_BYTES .LFE2-.LFB2 # address_range.
562 .byte 0x4 # DW_CFA_advance_loc4
563 .4byte .LCFI5-.LFB2 # to .LCFI5
564 .byte 0xe # DW_CFA_def_cfa_offset
565 .uleb128 SIZEOF_FRAME2 # adjust stack.by SIZEOF_FRAME
566 .byte 0x4 # DW_CFA_advance_loc4
567 .4byte .LCFI6-.LCFI5 # to .LCFI6
568 .byte 0x9c # DW_CFA_offset of $gp ($28)
569 .uleb128 (SIZEOF_FRAME2 - GP_OFF2)/4
570 .byte 0x9f # DW_CFA_offset of ra ($31)
571 .uleb128 (SIZEOF_FRAME2 - RA_OFF2)/4
572 .align EH_FRAME_ALIGN
573 .LEFDE3:
574 #endif /* __GNUC__ */
575
576 #endif