github.com/prattmic/llgo-embedded@v0.0.0-20150820070356-41cfecea0e1e/third_party/gofrontend/libffi/src/mips/n32.S (about) 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