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