/js/src/ctypes/libffi/src/x86/sysv.S

http://github.com/zpao/v8monkey · Assembly · 467 lines · 376 code · 45 blank · 46 comment · 8 complexity · e88ad4bddb3635845f6048bf3ba0f9b9 MD5 · raw file 

    

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

  2.    sysv.S - Copyright (c) 1996, 1998, 2001-2003, 2005, 2008, 2010  Red Hat, Inc.
    3. 

  3.    
    4. 

  4.    X86 Foreign Function Interface 
    5. 

    6. 

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

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

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

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

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

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

  12.    the following conditions:
    13. 

    14. 

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

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

    17. 

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

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

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

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

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

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

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

  24.    DEALINGS IN THE SOFTWARE.
    25. 

  25.    ----------------------------------------------------------------------- */
    26. 

  26. 

  27. #ifndef __x86_64__
    28. 

  28. 

  29. #define LIBFFI_ASM	
    30. 

  30. #include <fficonfig.h>
    31. 

  31. #include <ffi.h>
    32. 

  32. 

  33. .text
    34. 

  34. 

  35. .globl ffi_prep_args
    36. 

  36. 

  37. 	.align 4
    38. 

  38. .globl ffi_call_SYSV
    39. 

  39.         .type    ffi_call_SYSV,@function
    40. 

  40. 

  41. ffi_call_SYSV:
    42. 

  42. .LFB1:
    43. 

  43.         pushl %ebp
    44. 

  44. .LCFI0:
    45. 

  45.         movl  %esp,%ebp
    46. 

  46. .LCFI1:
    47. 

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

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

  49. 	subl  %ecx,%esp
    50. 

  50. 

  51.         /* Align the stack pointer to 16-bytes */
    52. 

  52.         andl  $0xfffffff0, %esp
    53. 

  53. 

  54. 	movl  %esp,%eax
    55. 

  55. 

  56. 	/* Place all of the ffi_prep_args in position  */
    57. 

  57. 	pushl 12(%ebp)
    58. 

  58. 	pushl %eax
    59. 

  59. 	call  *8(%ebp)
    60. 

  60. 

  61. 	/* Return stack to previous state and call the function  */
    62. 

  62. 	addl  $8,%esp	
    63. 

  63. 

  64. 	call  *28(%ebp)
    65. 

  65. 

  66. 	/* Load %ecx with the return type code  */
    67. 

  67. 	movl  20(%ebp),%ecx	
    68. 

  68. 

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

  70. 	pushl %esi
    71. 

  71. 

  72. 	/* If the return value pointer is NULL, assume no return value.  */
    73. 

  73. 	cmpl  $0,24(%ebp)
    74. 

  74. 	jne  0f
    75. 

  75. 

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

  77. 	   obliged to handle floating-point values.  */
    78. 

  78. 	cmpl  $FFI_TYPE_FLOAT,%ecx
    79. 

  79. 	jne   noretval
    80. 

  80. 	fstp  %st(0)
    81. 

  81. 

  82.         jmp   epilogue
    83. 

  83. 

  84. 0:
    85. 

  85. 	call  1f
    86. 

  86. 

  87. .Lstore_table:
    88. 

  88. 	.long	noretval-.Lstore_table	/* FFI_TYPE_VOID */
    89. 

  89. 	.long	retint-.Lstore_table	/* FFI_TYPE_INT */
    90. 

  90. 	.long	retfloat-.Lstore_table	/* FFI_TYPE_FLOAT */
    91. 

  91. 	.long	retdouble-.Lstore_table	/* FFI_TYPE_DOUBLE */
    92. 

  92. 	.long	retlongdouble-.Lstore_table	/* FFI_TYPE_LONGDOUBLE */
    93. 

  93. 	.long	retuint8-.Lstore_table	/* FFI_TYPE_UINT8 */
    94. 

  94. 	.long	retsint8-.Lstore_table	/* FFI_TYPE_SINT8 */
    95. 

  95. 	.long	retuint16-.Lstore_table	/* FFI_TYPE_UINT16 */
    96. 

  96. 	.long	retsint16-.Lstore_table	/* FFI_TYPE_SINT16 */
    97. 

  97. 	.long	retint-.Lstore_table	/* FFI_TYPE_UINT32 */
    98. 

  98. 	.long	retint-.Lstore_table	/* FFI_TYPE_SINT32 */
    99. 

  99. 	.long	retint64-.Lstore_table	/* FFI_TYPE_UINT64 */
    100. 

  100. 	.long	retint64-.Lstore_table	/* FFI_TYPE_SINT64 */
    101. 

  101. 	.long	retstruct-.Lstore_table	/* FFI_TYPE_STRUCT */
    102. 

  102. 	.long	retint-.Lstore_table	/* FFI_TYPE_POINTER */
    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. retint:
    152. 

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

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

  154. 	movl  %eax,0(%ecx)
    155. 

  155. 

  156. retstruct:
    157. 

  157. 	/* Nothing to do!  */
    158. 

  158. 

  159. noretval:
    160. 

  160. epilogue:
    161. 

  161.         popl %esi
    162. 

  162.         movl %ebp,%esp
    163. 

  163.         popl %ebp
    164. 

  164.         ret
    165. 

  165. .LFE1:
    166. 

  166. .ffi_call_SYSV_end:
    167. 

  167.         .size    ffi_call_SYSV,.ffi_call_SYSV_end-ffi_call_SYSV
    168. 

  168. 

  169. 	.align	4
    170. 

  170. FFI_HIDDEN (ffi_closure_SYSV)
    171. 

  171. .globl ffi_closure_SYSV
    172. 

  172. 	.type	ffi_closure_SYSV, @function
    173. 

  173. 

  174. ffi_closure_SYSV:
    175. 

  175. .LFB2:
    176. 

  176. 	pushl	%ebp
    177. 

  177. .LCFI2:
    178. 

  178. 	movl	%esp, %ebp
    179. 

  179. .LCFI3:
    180. 

  180. 	subl	$40, %esp
    181. 

  181. 	leal	-24(%ebp), %edx
    182. 

  182. 	movl	%edx, -12(%ebp)	/* resp */
    183. 

  183. 	leal	8(%ebp), %edx
    184. 

  184. 	movl	%edx, 4(%esp)	/* args = __builtin_dwarf_cfa () */
    185. 

  185. 	leal	-12(%ebp), %edx
    186. 

  186. 	movl	%edx, (%esp)	/* &resp */
    187. 

  187. #if defined HAVE_HIDDEN_VISIBILITY_ATTRIBUTE || !defined __PIC__
    188. 

  188. 	call	ffi_closure_SYSV_inner
    189. 

  189. #else
    190. 

  190. 	movl	%ebx, 8(%esp)
    191. 

  191. .LCFI7:
    192. 

  192. 	call	1f
    193. 

  193. 1:	popl	%ebx
    194. 

  194. 	addl	$_GLOBAL_OFFSET_TABLE_+[.-1b], %ebx
    195. 

  195. 	call	ffi_closure_SYSV_inner@PLT
    196. 

  196. 	movl	8(%esp), %ebx
    197. 

  197. #endif
    198. 

  198. 	movl	-12(%ebp), %ecx
    199. 

  199. 	cmpl	$FFI_TYPE_INT, %eax
    200. 

  200. 	je	.Lcls_retint
    201. 

  201. 

  202. 	/* Handle FFI_TYPE_UINT8, FFI_TYPE_SINT8, FFI_TYPE_UINT16,
    203. 

  203. 	   FFI_TYPE_SINT16, FFI_TYPE_UINT32, FFI_TYPE_SINT32.  */
    204. 

  204. 	cmpl	$FFI_TYPE_UINT64, %eax
    205. 

  205. 	jge	0f
    206. 

  206. 	cmpl	$FFI_TYPE_UINT8, %eax
    207. 

  207. 	jge	.Lcls_retint
    208. 

  208. 	
    209. 

  209. 0:	cmpl	$FFI_TYPE_FLOAT, %eax
    210. 

  210. 	je	.Lcls_retfloat
    211. 

  211. 	cmpl	$FFI_TYPE_DOUBLE, %eax
    212. 

  212. 	je	.Lcls_retdouble
    213. 

  213. 	cmpl	$FFI_TYPE_LONGDOUBLE, %eax
    214. 

  214. 	je	.Lcls_retldouble
    215. 

  215. 	cmpl	$FFI_TYPE_SINT64, %eax
    216. 

  216. 	je	.Lcls_retllong
    217. 

  217. 	cmpl	$FFI_TYPE_STRUCT, %eax
    218. 

  218. 	je	.Lcls_retstruct
    219. 

  219. .Lcls_epilogue:
    220. 

  220. 	movl	%ebp, %esp
    221. 

  221. 	popl	%ebp
    222. 

  222. 	ret
    223. 

  223. .Lcls_retint:
    224. 

  224. 	movl	(%ecx), %eax
    225. 

  225. 	jmp	.Lcls_epilogue
    226. 

  226. .Lcls_retfloat:
    227. 

  227. 	flds	(%ecx)
    228. 

  228. 	jmp	.Lcls_epilogue
    229. 

  229. .Lcls_retdouble:
    230. 

  230. 	fldl	(%ecx)
    231. 

  231. 	jmp	.Lcls_epilogue
    232. 

  232. .Lcls_retldouble:
    233. 

  233. 	fldt	(%ecx)
    234. 

  234. 	jmp	.Lcls_epilogue
    235. 

  235. .Lcls_retllong:
    236. 

  236. 	movl	(%ecx), %eax
    237. 

  237. 	movl	4(%ecx), %edx
    238. 

  238. 	jmp	.Lcls_epilogue
    239. 

  239. .Lcls_retstruct:
    240. 

  240. 	movl	%ebp, %esp
    241. 

  241. 	popl	%ebp
    242. 

  242. 	ret	$4
    243. 

  243. .LFE2:
    244. 

  244. 	.size	ffi_closure_SYSV, .-ffi_closure_SYSV
    245. 

  245. 

  246. #if !FFI_NO_RAW_API
    247. 

  247. 

  248. /* Precalculate for e.g. the Solaris 10/x86 assembler.  */
    249. 

  249. #if FFI_TRAMPOLINE_SIZE == 10
    250. 

  250. #define RAW_CLOSURE_CIF_OFFSET 12
    251. 

  251. #define RAW_CLOSURE_FUN_OFFSET 16
    252. 

  252. #define RAW_CLOSURE_USER_DATA_OFFSET 20
    253. 

  253. #elif FFI_TRAMPOLINE_SIZE == 24
    254. 

  254. #define RAW_CLOSURE_CIF_OFFSET 24
    255. 

  255. #define RAW_CLOSURE_FUN_OFFSET 28
    256. 

  256. #define RAW_CLOSURE_USER_DATA_OFFSET 32
    257. 

  257. #else
    258. 

  258. #define RAW_CLOSURE_CIF_OFFSET ((FFI_TRAMPOLINE_SIZE + 3) & ~3)
    259. 

  259. #define RAW_CLOSURE_FUN_OFFSET (RAW_CLOSURE_CIF_OFFSET + 4)
    260. 

  260. #define RAW_CLOSURE_USER_DATA_OFFSET (RAW_CLOSURE_FUN_OFFSET + 4)
    261. 

  261. #endif
    262. 

  262. #define CIF_FLAGS_OFFSET 20
    263. 

  263. 

  264. 	.align	4
    265. 

  265. FFI_HIDDEN (ffi_closure_raw_SYSV)
    266. 

  266. .globl ffi_closure_raw_SYSV
    267. 

  267. 	.type	ffi_closure_raw_SYSV, @function
    268. 

  268. 

  269. ffi_closure_raw_SYSV:
    270. 

  270. .LFB3:
    271. 

  271. 	pushl	%ebp
    272. 

  272. .LCFI4:
    273. 

  273. 	movl	%esp, %ebp
    274. 

  274. .LCFI5:
    275. 

  275. 	pushl	%esi
    276. 

  276. .LCFI6:
    277. 

  277. 	subl	$36, %esp
    278. 

  278. 	movl	RAW_CLOSURE_CIF_OFFSET(%eax), %esi	 /* closure->cif */
    279. 

  279. 	movl	RAW_CLOSURE_USER_DATA_OFFSET(%eax), %edx /* closure->user_data */
    280. 

  280. 	movl	%edx, 12(%esp)	/* user_data */
    281. 

  281. 	leal	8(%ebp), %edx	/* __builtin_dwarf_cfa () */
    282. 

  282. 	movl	%edx, 8(%esp)	/* raw_args */
    283. 

  283. 	leal	-24(%ebp), %edx
    284. 

  284. 	movl	%edx, 4(%esp)	/* &res */
    285. 

  285. 	movl	%esi, (%esp)	/* cif */
    286. 

  286. 	call	*RAW_CLOSURE_FUN_OFFSET(%eax)		 /* closure->fun */
    287. 

  287. 	movl	CIF_FLAGS_OFFSET(%esi), %eax		 /* rtype */
    288. 

  288. 	cmpl	$FFI_TYPE_INT, %eax
    289. 

  289. 	je	.Lrcls_retint
    290. 

  290. 

  291. 	/* Handle FFI_TYPE_UINT8, FFI_TYPE_SINT8, FFI_TYPE_UINT16,
    292. 

  292. 	   FFI_TYPE_SINT16, FFI_TYPE_UINT32, FFI_TYPE_SINT32.  */
    293. 

  293. 	cmpl	$FFI_TYPE_UINT64, %eax
    294. 

  294. 	jge	0f
    295. 

  295. 	cmpl	$FFI_TYPE_UINT8, %eax
    296. 

  296. 	jge	.Lrcls_retint
    297. 

  297. 0:
    298. 

  298. 	cmpl	$FFI_TYPE_FLOAT, %eax
    299. 

  299. 	je	.Lrcls_retfloat
    300. 

  300. 	cmpl	$FFI_TYPE_DOUBLE, %eax
    301. 

  301. 	je	.Lrcls_retdouble
    302. 

  302. 	cmpl	$FFI_TYPE_LONGDOUBLE, %eax
    303. 

  303. 	je	.Lrcls_retldouble
    304. 

  304. 	cmpl	$FFI_TYPE_SINT64, %eax
    305. 

  305. 	je	.Lrcls_retllong
    306. 

  306. .Lrcls_epilogue:
    307. 

  307. 	addl	$36, %esp
    308. 

  308. 	popl	%esi
    309. 

  309. 	popl	%ebp
    310. 

  310. 	ret
    311. 

  311. .Lrcls_retint:
    312. 

  312. 	movl	-24(%ebp), %eax
    313. 

  313. 	jmp	.Lrcls_epilogue
    314. 

  314. .Lrcls_retfloat:
    315. 

  315. 	flds	-24(%ebp)
    316. 

  316. 	jmp	.Lrcls_epilogue
    317. 

  317. .Lrcls_retdouble:
    318. 

  318. 	fldl	-24(%ebp)
    319. 

  319. 	jmp	.Lrcls_epilogue
    320. 

  320. .Lrcls_retldouble:
    321. 

  321. 	fldt	-24(%ebp)
    322. 

  322. 	jmp	.Lrcls_epilogue
    323. 

  323. .Lrcls_retllong:
    324. 

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

  325. 	movl	-20(%ebp), %edx
    326. 

  326. 	jmp	.Lrcls_epilogue
    327. 

  327. .LFE3:
    328. 

  328. 	.size	ffi_closure_raw_SYSV, .-ffi_closure_raw_SYSV
    329. 

  329. #endif
    330. 

  330. 

  331. 	.section	.eh_frame,EH_FRAME_FLAGS,@progbits
    332. 

  332. .Lframe1:
    333. 

  333. 	.long	.LECIE1-.LSCIE1	/* Length of Common Information Entry */
    334. 

  334. .LSCIE1:
    335. 

  335. 	.long	0x0	/* CIE Identifier Tag */
    336. 

  336. 	.byte	0x1	/* CIE Version */
    337. 

  337. #ifdef HAVE_AS_ASCII_PSEUDO_OP
    338. 

  338. #ifdef __PIC__
    339. 

  339. 	.ascii "zR\0"	/* CIE Augmentation */
    340. 

  340. #else
    341. 

  341. 	.ascii "\0"	/* CIE Augmentation */
    342. 

  342. #endif
    343. 

  343. #elif defined HAVE_AS_STRING_PSEUDO_OP
    344. 

  344. #ifdef __PIC__
    345. 

  345. 	.string "zR"	/* CIE Augmentation */
    346. 

  346. #else
    347. 

  347. 	.string ""	/* CIE Augmentation */
    348. 

  348. #endif
    349. 

  349. #else
    350. 

  350. #error missing .ascii/.string
    351. 

  351. #endif
    352. 

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

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

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

  355. #ifdef __PIC__
    356. 

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

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

  358. #endif
    359. 

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

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

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

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

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

  364. 	.align 4
    365. 

  365. .LECIE1:
    366. 

  366. .LSFDE1:
    367. 

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

  368. .LASFDE1:
    369. 

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

  370. #if defined __PIC__ && defined HAVE_AS_X86_PCREL
    371. 

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

  372. #elif defined __PIC__
    373. 

  373. 	.long	.LFB1@rel
    374. 

  374. #else
    375. 

  375. 	.long	.LFB1
    376. 

  376. #endif
    377. 

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

  378. #ifdef __PIC__
    379. 

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

  380. #endif
    381. 

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

  382. 	.long	.LCFI0-.LFB1
    383. 

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

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

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

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

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

  388. 	.long	.LCFI1-.LCFI0
    389. 

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

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

  391. 	.align 4
    392. 

  392. .LEFDE1:
    393. 

  393. .LSFDE2:
    394. 

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

  395. .LASFDE2:
    396. 

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

  397. #if defined __PIC__ && defined HAVE_AS_X86_PCREL
    398. 

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

  399. #elif defined __PIC__
    400. 

  400. 	.long	.LFB2@rel
    401. 

  401. #else
    402. 

  402. 	.long	.LFB2
    403. 

  403. #endif
    404. 

  404. 	.long	.LFE2-.LFB2	/* FDE address range */
    405. 

  405. #ifdef __PIC__
    406. 

  406. 	.byte	0x0	/* .uleb128 0x0; Augmentation size */
    407. 

  407. #endif
    408. 

  408. 	.byte	0x4	/* DW_CFA_advance_loc4 */
    409. 

  409. 	.long	.LCFI2-.LFB2
    410. 

  410. 	.byte	0xe	/* DW_CFA_def_cfa_offset */
    411. 

  411. 	.byte	0x8	/* .uleb128 0x8 */
    412. 

  412. 	.byte	0x85	/* DW_CFA_offset, column 0x5 */
    413. 

  413. 	.byte	0x2	/* .uleb128 0x2 */
    414. 

  414. 	.byte	0x4	/* DW_CFA_advance_loc4 */
    415. 

  415. 	.long	.LCFI3-.LCFI2
    416. 

  416. 	.byte	0xd	/* DW_CFA_def_cfa_register */
    417. 

  417. 	.byte	0x5	/* .uleb128 0x5 */
    418. 

  418. #if !defined HAVE_HIDDEN_VISIBILITY_ATTRIBUTE && defined __PIC__
    419. 

  419. 	.byte	0x4	/* DW_CFA_advance_loc4 */
    420. 

  420. 	.long	.LCFI7-.LCFI3
    421. 

  421. 	.byte	0x83	/* DW_CFA_offset, column 0x3 */
    422. 

  422. 	.byte	0xa	/* .uleb128 0xa */
    423. 

  423. #endif
    424. 

  424. 	.align 4
    425. 

  425. .LEFDE2:
    426. 

  426. 

  427. #if !FFI_NO_RAW_API
    428. 

  428. 

  429. .LSFDE3:
    430. 

  430. 	.long	.LEFDE3-.LASFDE3	/* FDE Length */
    431. 

  431. .LASFDE3:
    432. 

  432. 	.long	.LASFDE3-.Lframe1	/* FDE CIE offset */
    433. 

  433. #if defined __PIC__ && defined HAVE_AS_X86_PCREL
    434. 

  434. 	.long	.LFB3-.	/* FDE initial location */
    435. 

  435. #elif defined __PIC__
    436. 

  436. 	.long	.LFB3@rel
    437. 

  437. #else
    438. 

  438. 	.long	.LFB3
    439. 

  439. #endif
    440. 

  440. 	.long	.LFE3-.LFB3	/* FDE address range */
    441. 

  441. #ifdef __PIC__
    442. 

  442. 	.byte	0x0	/* .uleb128 0x0; Augmentation size */
    443. 

  443. #endif
    444. 

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

  445. 	.long	.LCFI4-.LFB3
    446. 

  446. 	.byte	0xe	/* DW_CFA_def_cfa_offset */
    447. 

  447. 	.byte	0x8	/* .uleb128 0x8 */
    448. 

  448. 	.byte	0x85	/* DW_CFA_offset, column 0x5 */
    449. 

  449. 	.byte	0x2	/* .uleb128 0x2 */
    450. 

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

  451. 	.long	.LCFI5-.LCFI4
    452. 

  452. 	.byte	0xd	/* DW_CFA_def_cfa_register */
    453. 

  453. 	.byte	0x5	/* .uleb128 0x5 */
    454. 

  454. 	.byte	0x4	/* DW_CFA_advance_loc4 */
    455. 

  455. 	.long	.LCFI6-.LCFI5
    456. 

  456. 	.byte	0x86	/* DW_CFA_offset, column 0x6 */
    457. 

  457. 	.byte	0x3	/* .uleb128 0x3 */
    458. 

  458. 	.align 4
    459. 

  459. .LEFDE3:
    460. 

  460. 

  461. #endif
    462. 

  462. 

  463. #endif /* ifndef __x86_64__ */
    464. 

  464. 

  465. #if defined __ELF__ && defined __linux__
    466. 

  466. 	.section	.note.GNU-stack,"",@progbits
    467. 

  467. #endif
    468.