/Modules/_ctypes/libffi_osx/x86/x86-darwin.S

http://unladen-swallow.googlecode.com/ · Assembly · 418 lines · 333 code · 40 blank · 45 comment · 0 complexity · a14fafa0e7722d388cc39d15db9182fc MD5 · raw file 

    

  1. #ifdef __i386__
    2. 

  2. /* -----------------------------------------------------------------------
    3. 

  3.    darwin.S - Copyright (c) 1996, 1998, 2001, 2002, 2003  Red Hat, Inc.
    4. 

  4.    
    5. 

  5.    X86 Foreign Function Interface 
    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, EXPRESS
    19. 

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

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

  21.    IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR
    22. 

  22.    OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
    23. 

  23.    ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
    24. 

  24.    OTHER DEALINGS IN THE SOFTWARE.
    25. 

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

  26.   
    27. 

  27. /*
    28. 

  28.  * This file is based on sysv.S and then hacked up by Ronald who hasn't done
    29. 

  29.  * assembly programming in 8 years.
    30. 

  30.  */
    31. 

  31. 

  32. #ifndef __x86_64__
    33. 

  33. 

  34. #define LIBFFI_ASM	
    35. 

  35. #include <fficonfig.h>
    36. 

  36. #include <ffi.h>
    37. 

  37. 

  38. #ifdef PyObjC_STRICT_DEBUGGING
    39. 

  39.   /* XXX: Debugging of stack alignment, to be removed */
    40. 

  40. #define ASSERT_STACK_ALIGNED movdqa -16(%esp), %xmm0
    41. 

  41. #else
    42. 

  42. #define ASSERT_STACK_ALIGNED 
    43. 

  43. #endif
    44. 

  44. 

  45. .text
    46. 

  46. 

  47. .globl _ffi_prep_args
    48. 

  48. 

  49. 	.align 4
    50. 

  50. .globl _ffi_call_SYSV
    51. 

  51. 

  52. _ffi_call_SYSV:
    53. 

  53. LFB1:
    54. 

  54.         pushl %ebp
    55. 

  55. LCFI0:
    56. 

  56.         movl  %esp,%ebp
    57. 

  57. LCFI1:
    58. 

  58.         subl $8,%esp
    59. 

  59. 	/* Make room for all of the new args.  */
    60. 

  60. 	movl  16(%ebp),%ecx
    61. 

  61. 	subl  %ecx,%esp
    62. 

  62. 

  63. 	movl  %esp,%eax
    64. 

  64. 

  65. 	/* Place all of the ffi_prep_args in position  */
    66. 

  66. 	subl  $8,%esp
    67. 

  67. 	pushl 12(%ebp)
    68. 

  68. 	pushl %eax
    69. 

  69. 	call  *8(%ebp)
    70. 

  70. 

  71. 	/* Return stack to previous state and call the function  */
    72. 

  72. 	addl  $16,%esp	
    73. 

  73. 

  74. 	call  *28(%ebp)
    75. 

  75. 

  76. 	/* Remove the space we pushed for the args  */
    77. 

  77. 	movl  16(%ebp),%ecx
    78. 

  78. 	addl  %ecx,%esp
    79. 

  79. 

  80. 	/* Load %ecx with the return type code  */
    81. 

  81. 	movl  20(%ebp),%ecx	
    82. 

  82. 

  83. 	/* If the return value pointer is NULL, assume no return value.  */
    84. 

  84. 	cmpl  $0,24(%ebp)
    85. 

  85. 	jne   Lretint
    86. 

  86. 

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

  88. 	   obliged to handle floating-point values.  */
    89. 

  89. 	cmpl  $FFI_TYPE_FLOAT,%ecx
    90. 

  90. 	jne   Lnoretval
    91. 

  91. 	fstp  %st(0)
    92. 

  92. 

  93.     jmp   Lepilogue
    94. 

  94. 

  95. Lretint:
    96. 

  96. 	cmpl  $FFI_TYPE_INT,%ecx
    97. 

  97. 	jne   Lretfloat
    98. 

  98. 	/* Load %ecx with the pointer to storage for the return value  */
    99. 

  99. 	movl  24(%ebp),%ecx	
    100. 

  100. 	movl  %eax,0(%ecx)
    101. 

  101. 	jmp   Lepilogue
    102. 

  102. 

  103. Lretfloat:
    104. 

  104. 	cmpl  $FFI_TYPE_FLOAT,%ecx
    105. 

  105. 	jne   Lretdouble
    106. 

  106. 	/* Load %ecx with the pointer to storage for the return value  */
    107. 

  107. 	movl  24(%ebp),%ecx	
    108. 

  108. 	fstps (%ecx)
    109. 

  109. 	jmp   Lepilogue
    110. 

  110. 

  111. Lretdouble:
    112. 

  112. 	cmpl  $FFI_TYPE_DOUBLE,%ecx
    113. 

  113. 	jne   Lretlongdouble
    114. 

  114. 	/* Load %ecx with the pointer to storage for the return value  */
    115. 

  115. 	movl  24(%ebp),%ecx	
    116. 

  116. 	fstpl (%ecx)
    117. 

  117. 	jmp   Lepilogue
    118. 

  118. 

  119. Lretlongdouble:
    120. 

  120. 	cmpl  $FFI_TYPE_LONGDOUBLE,%ecx
    121. 

  121. 	jne   Lretint64
    122. 

  122. 	/* Load %ecx with the pointer to storage for the return value  */
    123. 

  123. 	movl  24(%ebp),%ecx	
    124. 

  124. 	fstpt (%ecx)
    125. 

  125. 	jmp   Lepilogue
    126. 

  126. 	
    127. 

  127. Lretint64:	
    128. 

  128. 	cmpl  $FFI_TYPE_SINT64,%ecx
    129. 

  129.     jne   Lretstruct1b
    130. 

  130. 	/* Load %ecx with the pointer to storage for the return value  */
    131. 

  131. 	movl  24(%ebp),%ecx	
    132. 

  132. 	movl  %eax,0(%ecx)
    133. 

  133. 	movl  %edx,4(%ecx)
    134. 

  134. 	jmp   Lepilogue
    135. 

  135. 	
    136. 

  136. Lretstruct1b:	
    137. 

  137. 	cmpl  $FFI_TYPE_SINT8,%ecx
    138. 

  138.     jne   Lretstruct2b
    139. 

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

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

  141. 	movb  %al,0(%ecx)
    142. 

  142. 	jmp   Lepilogue
    143. 

  143. 

  144. Lretstruct2b:	
    145. 

  145. 	cmpl  $FFI_TYPE_SINT16,%ecx
    146. 

  146.     jne   Lretstruct
    147. 

  147. 	/* Load %ecx with the pointer to storage for the return value  */
    148. 

  148. 	movl  24(%ebp),%ecx	
    149. 

  149. 	movw  %ax,0(%ecx)
    150. 

  150. 	jmp   Lepilogue
    151. 

  151. 

  152. Lretstruct:
    153. 

  153. 	cmpl  $FFI_TYPE_STRUCT,%ecx
    154. 

  154.      jne   Lnoretval
    155. 

  155. 	/* Nothing to do!  */
    156. 

  156.     addl $4,%esp
    157. 

  157.     popl %ebp
    158. 

  158.     ret
    159. 

  159. 

  160. Lnoretval:
    161. 

  161. Lepilogue:
    162. 

  162.         addl $8,%esp
    163. 

  163.         movl %ebp,%esp
    164. 

  164.         popl %ebp
    165. 

  165.         ret
    166. 

  166. LFE1:
    167. 

  167. .ffi_call_SYSV_end:
    168. 

  168. 

  169. 	.align	4
    170. 

  170. FFI_HIDDEN (ffi_closure_SYSV)
    171. 

  171. .globl _ffi_closure_SYSV
    172. 

  172. 

  173. _ffi_closure_SYSV:
    174. 

  174. LFB2:
    175. 

  175. 	pushl	%ebp
    176. 

  176. LCFI2:
    177. 

  177. 	movl	%esp, %ebp
    178. 

  178. LCFI3:
    179. 

  179. 	subl	$56, %esp
    180. 

  180. 	leal	-40(%ebp), %edx
    181. 

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

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

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

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

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

  186. 	movl	%ebx, 8(%esp)
    187. 

  187. LCFI7:
    188. 

  188. 	call	L_ffi_closure_SYSV_inner$stub
    189. 

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

  190. 	movl	-12(%ebp), %ecx
    191. 

  191. 	cmpl	$FFI_TYPE_INT, %eax
    192. 

  192. 	je	Lcls_retint
    193. 

  193. 	cmpl	$FFI_TYPE_FLOAT, %eax
    194. 

  194. 	je	Lcls_retfloat
    195. 

  195. 	cmpl	$FFI_TYPE_DOUBLE, %eax
    196. 

  196. 	je	Lcls_retdouble
    197. 

  197. 	cmpl	$FFI_TYPE_LONGDOUBLE, %eax
    198. 

  198. 	je	Lcls_retldouble
    199. 

  199. 	cmpl	$FFI_TYPE_SINT64, %eax
    200. 

  200. 	je	Lcls_retllong
    201. 

  201. 	cmpl	$FFI_TYPE_SINT8, %eax
    202. 

  202. 	je	Lcls_retstruct1
    203. 

  203. 	cmpl	$FFI_TYPE_SINT16, %eax
    204. 

  204. 	je	Lcls_retstruct2
    205. 

  205. 	cmpl	$FFI_TYPE_STRUCT, %eax
    206. 

  206. 	je	Lcls_retstruct
    207. 

  207. Lcls_epilogue:
    208. 

  208. 	movl	%ebp, %esp
    209. 

  209. 	popl	%ebp
    210. 

  210. 	ret
    211. 

  211. Lcls_retint:
    212. 

  212. 	movl	(%ecx), %eax
    213. 

  213. 	jmp	Lcls_epilogue
    214. 

  214. Lcls_retfloat:
    215. 

  215. 	flds	(%ecx)
    216. 

  216. 	jmp	Lcls_epilogue
    217. 

  217. Lcls_retdouble:
    218. 

  218. 	fldl	(%ecx)
    219. 

  219. 	jmp	Lcls_epilogue
    220. 

  220. Lcls_retldouble:
    221. 

  221. 	fldt	(%ecx)
    222. 

  222. 	jmp	Lcls_epilogue
    223. 

  223. Lcls_retllong:
    224. 

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

  225. 	movl	4(%ecx), %edx
    226. 

  226. 	jmp	Lcls_epilogue
    227. 

  227. Lcls_retstruct1:
    228. 

  228. 	movsbl	(%ecx), %eax
    229. 

  229. 	jmp	Lcls_epilogue
    230. 

  230. Lcls_retstruct2:
    231. 

  231. 	movswl	(%ecx), %eax
    232. 

  232. 	jmp	Lcls_epilogue
    233. 

  233. Lcls_retstruct:
    234. 

  234. 	lea -8(%ebp),%esp
    235. 

  235. 	movl	%ebp, %esp
    236. 

  236. 	popl	%ebp
    237. 

  237. 	ret $4
    238. 

  238. LFE2:
    239. 

  239. 

  240. #if !FFI_NO_RAW_API
    241. 

  241. 

  242. #define RAW_CLOSURE_CIF_OFFSET ((FFI_TRAMPOLINE_SIZE + 3) & ~3)
    243. 

  243. #define RAW_CLOSURE_FUN_OFFSET (RAW_CLOSURE_CIF_OFFSET + 4)
    244. 

  244. #define RAW_CLOSURE_USER_DATA_OFFSET (RAW_CLOSURE_FUN_OFFSET + 4)
    245. 

  245. #define CIF_FLAGS_OFFSET 20
    246. 

  246. 

  247. 	.align	4
    248. 

  248. FFI_HIDDEN (ffi_closure_raw_SYSV)
    249. 

  249. .globl _ffi_closure_raw_SYSV
    250. 

  250. 

  251. _ffi_closure_raw_SYSV:
    252. 

  252. LFB3:
    253. 

  253. 	pushl	%ebp
    254. 

  254. LCFI4:
    255. 

  255. 	movl	%esp, %ebp
    256. 

  256. LCFI5:
    257. 

  257. 	pushl	%esi
    258. 

  258. LCFI6:
    259. 

  259. 	subl	$36, %esp
    260. 

  260. 	movl	RAW_CLOSURE_CIF_OFFSET(%eax), %esi	 /* closure->cif */
    261. 

  261. 	movl	RAW_CLOSURE_USER_DATA_OFFSET(%eax), %edx /* closure->user_data */
    262. 

  262. 	movl	%edx, 12(%esp)	/* user_data */
    263. 

  263. 	leal	8(%ebp), %edx	/* __builtin_dwarf_cfa () */
    264. 

  264. 	movl	%edx, 8(%esp)	/* raw_args */
    265. 

  265. 	leal	-24(%ebp), %edx
    266. 

  266. 	movl	%edx, 4(%esp)	/* &res */
    267. 

  267. 	movl	%esi, (%esp)	/* cif */
    268. 

  268. 	call	*RAW_CLOSURE_FUN_OFFSET(%eax)		 /* closure->fun */
    269. 

  269. 	movl	CIF_FLAGS_OFFSET(%esi), %eax		 /* rtype */
    270. 

  270. 	cmpl	$FFI_TYPE_INT, %eax
    271. 

  271. 	je	Lrcls_retint
    272. 

  272. 	cmpl	$FFI_TYPE_FLOAT, %eax
    273. 

  273. 	je	Lrcls_retfloat
    274. 

  274. 	cmpl	$FFI_TYPE_DOUBLE, %eax
    275. 

  275. 	je	Lrcls_retdouble
    276. 

  276. 	cmpl	$FFI_TYPE_LONGDOUBLE, %eax
    277. 

  277. 	je	Lrcls_retldouble
    278. 

  278. 	cmpl	$FFI_TYPE_SINT64, %eax
    279. 

  279. 	je	Lrcls_retllong
    280. 

  280. Lrcls_epilogue:
    281. 

  281. 	addl	$36, %esp
    282. 

  282. 	popl	%esi
    283. 

  283. 	popl	%ebp
    284. 

  284. 	ret
    285. 

  285. Lrcls_retint:
    286. 

  286. 	movl	-24(%ebp), %eax
    287. 

  287. 	jmp	Lrcls_epilogue
    288. 

  288. Lrcls_retfloat:
    289. 

  289. 	flds	-24(%ebp)
    290. 

  290. 	jmp	Lrcls_epilogue
    291. 

  291. Lrcls_retdouble:
    292. 

  292. 	fldl	-24(%ebp)
    293. 

  293. 	jmp	Lrcls_epilogue
    294. 

  294. Lrcls_retldouble:
    295. 

  295. 	fldt	-24(%ebp)
    296. 

  296. 	jmp	Lrcls_epilogue
    297. 

  297. Lrcls_retllong:
    298. 

  298. 	movl	-24(%ebp), %eax
    299. 

  299. 	movl	-20(%ebp), %edx
    300. 

  300. 	jmp	Lrcls_epilogue
    301. 

  301. LFE3:
    302. 

  302. #endif
    303. 

  303. 

  304. .section __IMPORT,__jump_table,symbol_stubs,self_modifying_code+pure_instructions,5
    305. 

  305. L_ffi_closure_SYSV_inner$stub:
    306. 

  306. 	.indirect_symbol _ffi_closure_SYSV_inner
    307. 

  307. 	hlt ; hlt ; hlt ; hlt ; hlt
    308. 

  308. 

  309. 

  310. .section __TEXT,__eh_frame,coalesced,no_toc+strip_static_syms+live_support
    311. 

  311. EH_frame1:
    312. 

  312. 	.set	L$set$0,LECIE1-LSCIE1
    313. 

  313. 	.long	L$set$0
    314. 

  314. LSCIE1:
    315. 

  315. 	.long	0x0
    316. 

  316. 	.byte	0x1
    317. 

  317. 	.ascii "zR\0"
    318. 

  318. 	.byte	0x1
    319. 

  319. 	.byte	0x7c
    320. 

  320. 	.byte	0x8
    321. 

  321. 	.byte	0x1
    322. 

  322. 	.byte	0x10
    323. 

  323. 	.byte	0xc
    324. 

  324. 	.byte	0x5
    325. 

  325. 	.byte	0x4
    326. 

  326. 	.byte	0x88
    327. 

  327. 	.byte	0x1
    328. 

  328. 	.align 2
    329. 

  329. LECIE1:
    330. 

  330. .globl _ffi_call_SYSV.eh
    331. 

  331. _ffi_call_SYSV.eh:
    332. 

  332. LSFDE1:
    333. 

  333. 	.set	L$set$1,LEFDE1-LASFDE1
    334. 

  334. 	.long	L$set$1
    335. 

  335. LASFDE1:
    336. 

  336. 	.long	LASFDE1-EH_frame1
    337. 

  337. 	.long	LFB1-.
    338. 

  338. 	.set L$set$2,LFE1-LFB1
    339. 

  339. 	.long L$set$2
    340. 

  340. 	.byte	0x0
    341. 

  341. 	.byte	0x4
    342. 

  342. 	.set L$set$3,LCFI0-LFB1
    343. 

  343. 	.long L$set$3
    344. 

  344. 	.byte	0xe
    345. 

  345. 	.byte	0x8
    346. 

  346. 	.byte	0x84
    347. 

  347. 	.byte	0x2
    348. 

  348. 	.byte	0x4
    349. 

  349. 	.set L$set$4,LCFI1-LCFI0
    350. 

  350. 	.long L$set$4
    351. 

  351. 	.byte	0xd
    352. 

  352. 	.byte	0x4
    353. 

  353. 	.align 2
    354. 

  354. LEFDE1:
    355. 

  355. .globl _ffi_closure_SYSV.eh
    356. 

  356. _ffi_closure_SYSV.eh:
    357. 

  357. LSFDE2:
    358. 

  358. 	.set	L$set$5,LEFDE2-LASFDE2
    359. 

  359. 	.long	L$set$5
    360. 

  360. LASFDE2:
    361. 

  361. 	.long	LASFDE2-EH_frame1
    362. 

  362. 	.long	LFB2-.
    363. 

  363. 	.set L$set$6,LFE2-LFB2
    364. 

  364. 	.long L$set$6
    365. 

  365. 	.byte	0x0
    366. 

  366. 	.byte	0x4
    367. 

  367. 	.set L$set$7,LCFI2-LFB2
    368. 

  368. 	.long L$set$7
    369. 

  369. 	.byte	0xe
    370. 

  370. 	.byte	0x8
    371. 

  371. 	.byte	0x84
    372. 

  372. 	.byte	0x2
    373. 

  373. 	.byte	0x4
    374. 

  374. 	.set L$set$8,LCFI3-LCFI2
    375. 

  375. 	.long L$set$8
    376. 

  376. 	.byte	0xd
    377. 

  377. 	.byte	0x4
    378. 

  378. 	.align 2
    379. 

  379. LEFDE2:
    380. 

  380. 

  381. #if !FFI_NO_RAW_API
    382. 

  382. 

  383. .globl _ffi_closure_raw_SYSV.eh
    384. 

  384. _ffi_closure_raw_SYSV.eh:
    385. 

  385. LSFDE3:
    386. 

  386. 	.set	L$set$10,LEFDE3-LASFDE3
    387. 

  387. 	.long	L$set$10
    388. 

  388. LASFDE3:
    389. 

  389. 	.long	LASFDE3-EH_frame1
    390. 

  390. 	.long	LFB3-.
    391. 

  391. 	.set L$set$11,LFE3-LFB3
    392. 

  392. 	.long L$set$11
    393. 

  393. 	.byte	0x0
    394. 

  394. 	.byte	0x4
    395. 

  395. 	.set L$set$12,LCFI4-LFB3
    396. 

  396. 	.long L$set$12
    397. 

  397. 	.byte	0xe
    398. 

  398. 	.byte	0x8
    399. 

  399. 	.byte	0x84
    400. 

  400. 	.byte	0x2
    401. 

  401. 	.byte	0x4
    402. 

  402. 	.set L$set$13,LCFI5-LCFI4
    403. 

  403. 	.long L$set$13
    404. 

  404. 	.byte	0xd
    405. 

  405. 	.byte	0x4
    406. 

  406. 	.byte	0x4
    407. 

  407. 	.set L$set$14,LCFI6-LCFI5
    408. 

  408. 	.long L$set$14
    409. 

  409. 	.byte	0x85
    410. 

  410. 	.byte	0x3
    411. 

  411. 	.align 2
    412. 

  412. LEFDE3:
    413. 

  413. 

  414. #endif
    415. 

  415. 

  416. #endif /* ifndef __x86_64__ */
    417. 

  417. 

  418. #endif /* defined __i386__ */
    419.