/Modules/_ctypes/libffi/src/x86/freebsd.S

http://unladen-swallow.googlecode.com/ · Assembly · 458 lines · 366 code · 45 blank · 47 comment · 2 complexity · c125f62411b796c8f45d5dce944ea54b MD5 · raw file 

    

  1. /* -----------------------------------------------------------------------
    2. 

  2.    freebsd.S - Copyright (c) 1996, 1998, 2001, 2002, 2003, 2005  Red Hat, Inc.
    3. 

  3. 	       Copyright (c) 2008  Bjรถrn Kรถnig
    4. 

  4. 	
    5. 

  5.    X86 Foreign Function Interface for FreeBSD
    6. 

    7. 

  7.    Permission is hereby granted, free of charge, to any person obtaining
    8. 

  8.    a copy of this software and associated documentation files (the
    9. 

  9.    ``Software''), to deal in the Software without restriction, including
    10. 

  10.    without limitation the rights to use, copy, modify, merge, publish,
    11. 

  11.    distribute, sublicense, and/or sell copies of the Software, and to
    12. 

  12.    permit persons to whom the Software is furnished to do so, subject to
    13. 

  13.    the following conditions:
    14. 

    15. 

  15.    The above copyright notice and this permission notice shall be included
    16. 

  16.    in all copies or substantial portions of the Software.
    17. 

    18. 

  18.    THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
    19. 

  19.    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    20. 

  20.    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
    21. 

  21.    NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
    22. 

  22.    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
    23. 

  23.    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    24. 

  24.    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    25. 

  25.    DEALINGS IN THE SOFTWARE.
    26. 

  26. ----------------------------------------------------------------------- */
    27. 

  27. 

  28. #ifndef __x86_64__
    29. 

  29. 

  30. #define LIBFFI_ASM	
    31. 

  31. #include <fficonfig.h>
    32. 

  32. #include <ffi.h>
    33. 

  33. 

  34. .text
    35. 

  35. 

  36. .globl ffi_prep_args
    37. 

  37. 

  38. 	.align 4
    39. 

  39. .globl ffi_call_SYSV
    40. 

  40.         .type    ffi_call_SYSV,@function
    41. 

  41. 

  42. ffi_call_SYSV:
    43. 

  43. .LFB1:
    44. 

  44.         pushl %ebp
    45. 

  45. .LCFI0:
    46. 

  46.         movl  %esp,%ebp
    47. 

  47. .LCFI1:
    48. 

  48. 	/* Make room for all of the new args.  */
    49. 

  49. 	movl  16(%ebp),%ecx
    50. 

  50. 	subl  %ecx,%esp
    51. 

  51. 

  52. 	movl  %esp,%eax
    53. 

  53. 

  54. 	/* Place all of the ffi_prep_args in position  */
    55. 

  55. 	pushl 12(%ebp)
    56. 

  56. 	pushl %eax
    57. 

  57. 	call  *8(%ebp)
    58. 

  58. 

  59. 	/* Return stack to previous state and call the function  */
    60. 

  60. 	addl  $8,%esp	
    61. 

  61. 

  62. 	call  *28(%ebp)
    63. 

  63. 

  64. 	/* Load %ecx with the return type code  */
    65. 

  65. 	movl  20(%ebp),%ecx	
    66. 

  66. 

  67. 	/* Protect %esi.  We're going to pop it in the epilogue.  */
    68. 

  68. 	pushl %esi
    69. 

  69. 

  70. 	/* If the return value pointer is NULL, assume no return value.  */
    71. 

  71. 	cmpl  $0,24(%ebp)
    72. 

  72. 	jne  0f
    73. 

  73. 

  74. 	/* Even if there is no space for the return value, we are 
    75. 

  75. 	   obliged to handle floating-point values.  */
    76. 

  76. 	cmpl  $FFI_TYPE_FLOAT,%ecx
    77. 

  77. 	jne   noretval
    78. 

  78. 	fstp  %st(0)
    79. 

  79. 

  80.         jmp   epilogue
    81. 

  81. 

  82. 0:
    83. 

  83. 	call  1f
    84. 

  84. 

  85. .Lstore_table:
    86. 

  86. 	.long	noretval-.Lstore_table	/* FFI_TYPE_VOID */
    87. 

  87. 	.long	retint-.Lstore_table	/* FFI_TYPE_INT */
    88. 

  88. 	.long	retfloat-.Lstore_table	/* FFI_TYPE_FLOAT */
    89. 

  89. 	.long	retdouble-.Lstore_table	/* FFI_TYPE_DOUBLE */
    90. 

  90. 	.long	retlongdouble-.Lstore_table	/* FFI_TYPE_LONGDOUBLE */
    91. 

  91. 	.long	retuint8-.Lstore_table	/* FFI_TYPE_UINT8 */
    92. 

  92. 	.long	retsint8-.Lstore_table	/* FFI_TYPE_SINT8 */
    93. 

  93. 	.long	retuint16-.Lstore_table	/* FFI_TYPE_UINT16 */
    94. 

  94. 	.long	retsint16-.Lstore_table	/* FFI_TYPE_SINT16 */
    95. 

  95. 	.long	retint-.Lstore_table	/* FFI_TYPE_UINT32 */
    96. 

  96. 	.long	retint-.Lstore_table	/* FFI_TYPE_SINT32 */
    97. 

  97. 	.long	retint64-.Lstore_table	/* FFI_TYPE_UINT64 */
    98. 

  98. 	.long	retint64-.Lstore_table	/* FFI_TYPE_SINT64 */
    99. 

  99. 	.long	retstruct-.Lstore_table	/* FFI_TYPE_STRUCT */
    100. 

  100. 	.long	retint-.Lstore_table	/* FFI_TYPE_POINTER */
    101. 

  101. 	.long   retstruct1b-.Lstore_table	/* FFI_TYPE_SMALL_STRUCT_1B */
    102. 

  102. 	.long   retstruct2b-.Lstore_table	/* FFI_TYPE_SMALL_STRUCT_2B */
    103. 

  103. 

  104. 1:
    105. 

  105. 	pop  %esi
    106. 

  106. 	add  (%esi, %ecx, 4), %esi
    107. 

  107. 	jmp  *%esi
    108. 

  108. 

  109. 	/* Sign/zero extend as appropriate.  */
    110. 

  110. retsint8:
    111. 

  111. 	movsbl  %al, %eax
    112. 

  112. 	jmp  retint
    113. 

  113. 

  114. retsint16:
    115. 

  115. 	movswl  %ax, %eax
    116. 

  116. 	jmp  retint
    117. 

  117. 

  118. retuint8:
    119. 

  119. 	movzbl  %al, %eax
    120. 

  120. 	jmp  retint
    121. 

  121. 

  122. retuint16:
    123. 

  123. 	movzwl  %ax, %eax
    124. 

  124. 	jmp  retint
    125. 

  125. 

  126. retfloat:
    127. 

  127. 	/* Load %ecx with the pointer to storage for the return value  */
    128. 

  128. 	movl  24(%ebp),%ecx	
    129. 

  129. 	fstps (%ecx)
    130. 

  130. 	jmp   epilogue
    131. 

  131. 

  132. retdouble:
    133. 

  133. 	/* Load %ecx with the pointer to storage for the return value  */
    134. 

  134. 	movl  24(%ebp),%ecx	
    135. 

  135. 	fstpl (%ecx)
    136. 

  136. 	jmp   epilogue
    137. 

  137. 

  138. retlongdouble:
    139. 

  139. 	/* Load %ecx with the pointer to storage for the return value  */
    140. 

  140. 	movl  24(%ebp),%ecx	
    141. 

  141. 	fstpt (%ecx)
    142. 

  142. 	jmp   epilogue
    143. 

  143. 	
    144. 

  144. retint64:	
    145. 

  145. 	/* Load %ecx with the pointer to storage for the return value  */
    146. 

  146. 	movl  24(%ebp),%ecx	
    147. 

  147. 	movl  %eax,0(%ecx)
    148. 

  148. 	movl  %edx,4(%ecx)
    149. 

  149. 	jmp   epilogue
    150. 

  150. 	
    151. 

  151. retstruct1b:
    152. 

  152. 	/* Load %ecx with the pointer to storage for the return value  */
    153. 

  153. 	movl  24(%ebp),%ecx
    154. 

  154. 	movb  %al,0(%ecx)
    155. 

  155. 	jmp   epilogue
    156. 

  156. 

  157. retstruct2b:
    158. 

  158. 	/* Load %ecx with the pointer to storage for the return value  */
    159. 

  159. 	movl  24(%ebp),%ecx
    160. 

  160. 	movw  %ax,0(%ecx)
    161. 

  161. 	jmp   epilogue
    162. 

  162. 

  163. retint:
    164. 

  164. 	/* Load %ecx with the pointer to storage for the return value  */
    165. 

  165. 	movl  24(%ebp),%ecx	
    166. 

  166. 	movl  %eax,0(%ecx)
    167. 

  167. 

  168. retstruct:
    169. 

  169. 	/* Nothing to do!  */
    170. 

  170. 

  171. noretval:
    172. 

  172. epilogue:
    173. 

  173.         popl %esi
    174. 

  174.         movl %ebp,%esp
    175. 

  175.         popl %ebp
    176. 

  176.         ret
    177. 

  177. .LFE1:
    178. 

  178. .ffi_call_SYSV_end:
    179. 

  179.         .size    ffi_call_SYSV,.ffi_call_SYSV_end-ffi_call_SYSV
    180. 

  180. 

  181. 	.align	4
    182. 

  182. FFI_HIDDEN (ffi_closure_SYSV)
    183. 

  183. .globl ffi_closure_SYSV
    184. 

  184. 	.type	ffi_closure_SYSV, @function
    185. 

  185. 

  186. ffi_closure_SYSV:
    187. 

  187. .LFB2:
    188. 

  188. 	pushl	%ebp
    189. 

  189. .LCFI2:
    190. 

  190. 	movl	%esp, %ebp
    191. 

  191. .LCFI3:
    192. 

  192. 	subl	$40, %esp
    193. 

  193. 	leal	-24(%ebp), %edx
    194. 

  194. 	movl	%edx, -12(%ebp)	/* resp */
    195. 

  195. 	leal	8(%ebp), %edx
    196. 

  196. 	movl	%edx, 4(%esp)	/* args = __builtin_dwarf_cfa () */
    197. 

  197. 	leal	-12(%ebp), %edx
    198. 

  198. 	movl	%edx, (%esp)	/* &resp */
    199. 

  199. #if defined HAVE_HIDDEN_VISIBILITY_ATTRIBUTE || !defined __PIC__
    200. 

  200. 	call	ffi_closure_SYSV_inner
    201. 

  201. #else
    202. 

  202. 	movl	%ebx, 8(%esp)
    203. 

  203. .LCFI7:
    204. 

  204. 	call	1f
    205. 

  205. 1:	popl	%ebx
    206. 

  206. 	addl	$_GLOBAL_OFFSET_TABLE_+[.-1b], %ebx
    207. 

  207. 	call	ffi_closure_SYSV_inner@PLT
    208. 

  208. 	movl	8(%esp), %ebx
    209. 

  209. #endif
    210. 

  210. 	movl	-12(%ebp), %ecx
    211. 

  211. 	cmpl	$FFI_TYPE_INT, %eax
    212. 

  212. 	je	.Lcls_retint
    213. 

  213. 

  214. 	/* Handle FFI_TYPE_UINT8, FFI_TYPE_SINT8, FFI_TYPE_UINT16,
    215. 

  215. 	   FFI_TYPE_SINT16, FFI_TYPE_UINT32, FFI_TYPE_SINT32.  */
    216. 

  216. 	cmpl	$FFI_TYPE_UINT64, %eax
    217. 

  217. 	jge	0f
    218. 

  218. 	cmpl	$FFI_TYPE_UINT8, %eax
    219. 

  219. 	jge	.Lcls_retint
    220. 

  220. 	
    221. 

  221. 0:	cmpl	$FFI_TYPE_FLOAT, %eax
    222. 

  222. 	je	.Lcls_retfloat
    223. 

  223. 	cmpl	$FFI_TYPE_DOUBLE, %eax
    224. 

  224. 	je	.Lcls_retdouble
    225. 

  225. 	cmpl	$FFI_TYPE_LONGDOUBLE, %eax
    226. 

  226. 	je	.Lcls_retldouble
    227. 

  227. 	cmpl	$FFI_TYPE_SINT64, %eax
    228. 

  228. 	je	.Lcls_retllong
    229. 

  229. 	cmpl	$FFI_TYPE_SMALL_STRUCT_1B, %eax
    230. 

  230. 	je	.Lcls_retstruct1b
    231. 

  231. 	cmpl	$FFI_TYPE_SMALL_STRUCT_2B, %eax
    232. 

  232. 	je	.Lcls_retstruct2b
    233. 

  233. 	cmpl	$FFI_TYPE_STRUCT, %eax
    234. 

  234. 	je	.Lcls_retstruct
    235. 

  235. .Lcls_epilogue:
    236. 

  236. 	movl	%ebp, %esp
    237. 

  237. 	popl	%ebp
    238. 

  238. 	ret
    239. 

  239. .Lcls_retint:
    240. 

  240. 	movl	(%ecx), %eax
    241. 

  241. 	jmp	.Lcls_epilogue
    242. 

  242. .Lcls_retfloat:
    243. 

  243. 	flds	(%ecx)
    244. 

  244. 	jmp	.Lcls_epilogue
    245. 

  245. .Lcls_retdouble:
    246. 

  246. 	fldl	(%ecx)
    247. 

  247. 	jmp	.Lcls_epilogue
    248. 

  248. .Lcls_retldouble:
    249. 

  249. 	fldt	(%ecx)
    250. 

  250. 	jmp	.Lcls_epilogue
    251. 

  251. .Lcls_retllong:
    252. 

  252. 	movl	(%ecx), %eax
    253. 

  253. 	movl	4(%ecx), %edx
    254. 

  254. 	jmp	.Lcls_epilogue
    255. 

  255. .Lcls_retstruct1b:
    256. 

  256. 	movsbl	(%ecx), %eax
    257. 

  257. 	jmp	.Lcls_epilogue
    258. 

  258. .Lcls_retstruct2b:
    259. 

  259. 	movswl	(%ecx), %eax
    260. 

  260. 	jmp	.Lcls_epilogue
    261. 

  261. .Lcls_retstruct:
    262. 

  262. 	movl	%ebp, %esp
    263. 

  263. 	popl	%ebp
    264. 

  264. 	ret	$4
    265. 

  265. .LFE2:
    266. 

  266. 	.size	ffi_closure_SYSV, .-ffi_closure_SYSV
    267. 

  267. 

  268. #if !FFI_NO_RAW_API
    269. 

  269. 

  270. #define RAW_CLOSURE_CIF_OFFSET ((FFI_TRAMPOLINE_SIZE + 3) & ~3)
    271. 

  271. #define RAW_CLOSURE_FUN_OFFSET (RAW_CLOSURE_CIF_OFFSET + 4)
    272. 

  272. #define RAW_CLOSURE_USER_DATA_OFFSET (RAW_CLOSURE_FUN_OFFSET + 4)
    273. 

  273. #define CIF_FLAGS_OFFSET 20
    274. 

  274. 

  275. 	.align	4
    276. 

  276. FFI_HIDDEN (ffi_closure_raw_SYSV)
    277. 

  277. .globl ffi_closure_raw_SYSV
    278. 

  278. 	.type	ffi_closure_raw_SYSV, @function
    279. 

  279. 

  280. ffi_closure_raw_SYSV:
    281. 

  281. .LFB3:
    282. 

  282. 	pushl	%ebp
    283. 

  283. .LCFI4:
    284. 

  284. 	movl	%esp, %ebp
    285. 

  285. .LCFI5:
    286. 

  286. 	pushl	%esi
    287. 

  287. .LCFI6:
    288. 

  288. 	subl	$36, %esp
    289. 

  289. 	movl	RAW_CLOSURE_CIF_OFFSET(%eax), %esi	 /* closure->cif */
    290. 

  290. 	movl	RAW_CLOSURE_USER_DATA_OFFSET(%eax), %edx /* closure->user_data */
    291. 

  291. 	movl	%edx, 12(%esp)	/* user_data */
    292. 

  292. 	leal	8(%ebp), %edx	/* __builtin_dwarf_cfa () */
    293. 

  293. 	movl	%edx, 8(%esp)	/* raw_args */
    294. 

  294. 	leal	-24(%ebp), %edx
    295. 

  295. 	movl	%edx, 4(%esp)	/* &res */
    296. 

  296. 	movl	%esi, (%esp)	/* cif */
    297. 

  297. 	call	*RAW_CLOSURE_FUN_OFFSET(%eax)		 /* closure->fun */
    298. 

  298. 	movl	CIF_FLAGS_OFFSET(%esi), %eax		 /* rtype */
    299. 

  299. 	cmpl	$FFI_TYPE_INT, %eax
    300. 

  300. 	je	.Lrcls_retint
    301. 

  301. 

  302. 	/* Handle FFI_TYPE_UINT8, FFI_TYPE_SINT8, FFI_TYPE_UINT16,
    303. 

  303. 	   FFI_TYPE_SINT16, FFI_TYPE_UINT32, FFI_TYPE_SINT32.  */
    304. 

  304. 	cmpl	$FFI_TYPE_UINT64, %eax
    305. 

  305. 	jge	0f
    306. 

  306. 	cmpl	$FFI_TYPE_UINT8, %eax
    307. 

  307. 	jge	.Lrcls_retint
    308. 

  308. 0:
    309. 

  309. 	cmpl	$FFI_TYPE_FLOAT, %eax
    310. 

  310. 	je	.Lrcls_retfloat
    311. 

  311. 	cmpl	$FFI_TYPE_DOUBLE, %eax
    312. 

  312. 	je	.Lrcls_retdouble
    313. 

  313. 	cmpl	$FFI_TYPE_LONGDOUBLE, %eax
    314. 

  314. 	je	.Lrcls_retldouble
    315. 

  315. 	cmpl	$FFI_TYPE_SINT64, %eax
    316. 

  316. 	je	.Lrcls_retllong
    317. 

  317. .Lrcls_epilogue:
    318. 

  318. 	addl	$36, %esp
    319. 

  319. 	popl	%esi
    320. 

  320. 	popl	%ebp
    321. 

  321. 	ret
    322. 

  322. .Lrcls_retint:
    323. 

  323. 	movl	-24(%ebp), %eax
    324. 

  324. 	jmp	.Lrcls_epilogue
    325. 

  325. .Lrcls_retfloat:
    326. 

  326. 	flds	-24(%ebp)
    327. 

  327. 	jmp	.Lrcls_epilogue
    328. 

  328. .Lrcls_retdouble:
    329. 

  329. 	fldl	-24(%ebp)
    330. 

  330. 	jmp	.Lrcls_epilogue
    331. 

  331. .Lrcls_retldouble:
    332. 

  332. 	fldt	-24(%ebp)
    333. 

  333. 	jmp	.Lrcls_epilogue
    334. 

  334. .Lrcls_retllong:
    335. 

  335. 	movl	-24(%ebp), %eax
    336. 

  336. 	movl	-20(%ebp), %edx
    337. 

  337. 	jmp	.Lrcls_epilogue
    338. 

  338. .LFE3:
    339. 

  339. 	.size	ffi_closure_raw_SYSV, .-ffi_closure_raw_SYSV
    340. 

  340. #endif
    341. 

  341. 

  342. 	.section	.eh_frame,EH_FRAME_FLAGS,@progbits
    343. 

  343. .Lframe1:
    344. 

  344. 	.long	.LECIE1-.LSCIE1	/* Length of Common Information Entry */
    345. 

  345. .LSCIE1:
    346. 

  346. 	.long	0x0	/* CIE Identifier Tag */
    347. 

  347. 	.byte	0x1	/* CIE Version */
    348. 

  348. #ifdef __PIC__
    349. 

  349. 	.ascii "zR\0"	/* CIE Augmentation */
    350. 

  350. #else
    351. 

  351. 	.ascii "\0"	/* CIE Augmentation */
    352. 

  352. #endif
    353. 

  353. 	.byte	0x1	/* .uleb128 0x1; CIE Code Alignment Factor */
    354. 

  354. 	.byte	0x7c	/* .sleb128 -4; CIE Data Alignment Factor */
    355. 

  355. 	.byte	0x8	/* CIE RA Column */
    356. 

  356. #ifdef __PIC__
    357. 

  357. 	.byte	0x1	/* .uleb128 0x1; Augmentation size */
    358. 

  358. 	.byte	0x1b	/* FDE Encoding (pcrel sdata4) */
    359. 

  359. #endif
    360. 

  360. 	.byte	0xc	/* DW_CFA_def_cfa */
    361. 

  361. 	.byte	0x4	/* .uleb128 0x4 */
    362. 

  362. 	.byte	0x4	/* .uleb128 0x4 */
    363. 

  363. 	.byte	0x88	/* DW_CFA_offset, column 0x8 */
    364. 

  364. 	.byte	0x1	/* .uleb128 0x1 */
    365. 

  365. 	.align 4
    366. 

  366. .LECIE1:
    367. 

  367. .LSFDE1:
    368. 

  368. 	.long	.LEFDE1-.LASFDE1	/* FDE Length */
    369. 

  369. .LASFDE1:
    370. 

  370. 	.long	.LASFDE1-.Lframe1	/* FDE CIE offset */
    371. 

  371. #ifdef __PIC__
    372. 

  372. 	.long	.LFB1-.	/* FDE initial location */
    373. 

  373. #else
    374. 

  374. 	.long	.LFB1	/* FDE initial location */
    375. 

  375. #endif
    376. 

  376. 	.long	.LFE1-.LFB1	/* FDE address range */
    377. 

  377. #ifdef __PIC__
    378. 

  378. 	.byte	0x0	/* .uleb128 0x0; Augmentation size */
    379. 

  379. #endif
    380. 

  380. 	.byte	0x4	/* DW_CFA_advance_loc4 */
    381. 

  381. 	.long	.LCFI0-.LFB1
    382. 

  382. 	.byte	0xe	/* DW_CFA_def_cfa_offset */
    383. 

  383. 	.byte	0x8	/* .uleb128 0x8 */
    384. 

  384. 	.byte	0x85	/* DW_CFA_offset, column 0x5 */
    385. 

  385. 	.byte	0x2	/* .uleb128 0x2 */
    386. 

  386. 	.byte	0x4	/* DW_CFA_advance_loc4 */
    387. 

  387. 	.long	.LCFI1-.LCFI0
    388. 

  388. 	.byte	0xd	/* DW_CFA_def_cfa_register */
    389. 

  389. 	.byte	0x5	/* .uleb128 0x5 */
    390. 

  390. 	.align 4
    391. 

  391. .LEFDE1:
    392. 

  392. .LSFDE2:
    393. 

  393. 	.long	.LEFDE2-.LASFDE2	/* FDE Length */
    394. 

  394. .LASFDE2:
    395. 

  395. 	.long	.LASFDE2-.Lframe1	/* FDE CIE offset */
    396. 

  396. #ifdef __PIC__
    397. 

  397. 	.long	.LFB2-.	/* FDE initial location */
    398. 

  398. #else
    399. 

  399. 	.long	.LFB2
    400. 

  400. #endif
    401. 

  401. 	.long	.LFE2-.LFB2	/* FDE address range */
    402. 

  402. #ifdef __PIC__
    403. 

  403. 	.byte	0x0	/* .uleb128 0x0; Augmentation size */
    404. 

  404. #endif
    405. 

  405. 	.byte	0x4	/* DW_CFA_advance_loc4 */
    406. 

  406. 	.long	.LCFI2-.LFB2
    407. 

  407. 	.byte	0xe	/* DW_CFA_def_cfa_offset */
    408. 

  408. 	.byte	0x8	/* .uleb128 0x8 */
    409. 

  409. 	.byte	0x85	/* DW_CFA_offset, column 0x5 */
    410. 

  410. 	.byte	0x2	/* .uleb128 0x2 */
    411. 

  411. 	.byte	0x4	/* DW_CFA_advance_loc4 */
    412. 

  412. 	.long	.LCFI3-.LCFI2
    413. 

  413. 	.byte	0xd	/* DW_CFA_def_cfa_register */
    414. 

  414. 	.byte	0x5	/* .uleb128 0x5 */
    415. 

  415. #if !defined HAVE_HIDDEN_VISIBILITY_ATTRIBUTE && defined __PIC__
    416. 

  416. 	.byte	0x4	/* DW_CFA_advance_loc4 */
    417. 

  417. 	.long	.LCFI7-.LCFI3
    418. 

  418. 	.byte	0x83	/* DW_CFA_offset, column 0x3 */
    419. 

  419. 	.byte	0xa	/* .uleb128 0xa */
    420. 

  420. #endif
    421. 

  421. 	.align 4
    422. 

  422. .LEFDE2:
    423. 

  423. 

  424. #if !FFI_NO_RAW_API
    425. 

  425. 

  426. .LSFDE3:
    427. 

  427. 	.long	.LEFDE3-.LASFDE3	/* FDE Length */
    428. 

  428. .LASFDE3:
    429. 

  429. 	.long	.LASFDE3-.Lframe1	/* FDE CIE offset */
    430. 

  430. #ifdef __PIC__
    431. 

  431. 	.long	.LFB3-.	/* FDE initial location */
    432. 

  432. #else
    433. 

  433. 	.long	.LFB3
    434. 

  434. #endif
    435. 

  435. 	.long	.LFE3-.LFB3	/* FDE address range */
    436. 

  436. #ifdef __PIC__
    437. 

  437. 	.byte	0x0	/* .uleb128 0x0; Augmentation size */
    438. 

  438. #endif
    439. 

  439. 	.byte	0x4	/* DW_CFA_advance_loc4 */
    440. 

  440. 	.long	.LCFI4-.LFB3
    441. 

  441. 	.byte	0xe	/* DW_CFA_def_cfa_offset */
    442. 

  442. 	.byte	0x8	/* .uleb128 0x8 */
    443. 

  443. 	.byte	0x85	/* DW_CFA_offset, column 0x5 */
    444. 

  444. 	.byte	0x2	/* .uleb128 0x2 */
    445. 

  445. 	.byte	0x4	/* DW_CFA_advance_loc4 */
    446. 

  446. 	.long	.LCFI5-.LCFI4
    447. 

  447. 	.byte	0xd	/* DW_CFA_def_cfa_register */
    448. 

  448. 	.byte	0x5	/* .uleb128 0x5 */
    449. 

  449. 	.byte	0x4	/* DW_CFA_advance_loc4 */
    450. 

  450. 	.long	.LCFI6-.LCFI5
    451. 

  451. 	.byte	0x86	/* DW_CFA_offset, column 0x6 */
    452. 

  452. 	.byte	0x3	/* .uleb128 0x3 */
    453. 

  453. 	.align 4
    454. 

  454. .LEFDE3:
    455. 

  455. 

  456. #endif
    457. 

  457. 

  458. #endif /* ifndef __x86_64__ */
    459.