libffi/src/mips/n32.S

   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