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