OSchip
/
OpenBLAS
Not watched
1
0
Fork 0
Code
Releases 66 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 57ed58cefe
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '57ed58cefe'
${ noResults }
OpenBLAS/kernel/x86/qgemv_t.S

586 lines
12 kB
Raw Blame History 

  1. /*********************************************************************/

  2. /* Copyright 2009, 2010 The University of Texas at Austin.           */

  3. /* All rights reserved.                                              */

  4. /*                                                                   */

  5. /* Redistribution and use in source and binary forms, with or        */

  6. /* without modification, are permitted provided that the following   */

  7. /* conditions are met:                                               */

  8. /*                                                                   */

  9. /*   1. Redistributions of source code must retain the above         */

  10. /*      copyright notice, this list of conditions and the following  */

  11. /*      disclaimer.                                                  */

  12. /*                                                                   */

  13. /*   2. Redistributions in binary form must reproduce the above      */

  14. /*      copyright notice, this list of conditions and the following  */

  15. /*      disclaimer in the documentation and/or other materials       */

  16. /*      provided with the distribution.                              */

  17. /*                                                                   */

  18. /*    THIS  SOFTWARE IS PROVIDED  BY THE  UNIVERSITY OF  TEXAS AT    */

  19. /*    AUSTIN  ``AS IS''  AND ANY  EXPRESS OR  IMPLIED WARRANTIES,    */

  20. /*    INCLUDING, BUT  NOT LIMITED  TO, THE IMPLIED  WARRANTIES OF    */

  21. /*    MERCHANTABILITY  AND FITNESS FOR  A PARTICULAR  PURPOSE ARE    */

  22. /*    DISCLAIMED.  IN  NO EVENT SHALL THE UNIVERSITY  OF TEXAS AT    */

  23. /*    AUSTIN OR CONTRIBUTORS BE  LIABLE FOR ANY DIRECT, INDIRECT,    */

  24. /*    INCIDENTAL,  SPECIAL, EXEMPLARY,  OR  CONSEQUENTIAL DAMAGES    */

  25. /*    (INCLUDING, BUT  NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE    */

  26. /*    GOODS  OR  SERVICES; LOSS  OF  USE,  DATA,  OR PROFITS;  OR    */

  27. /*    BUSINESS INTERRUPTION) HOWEVER CAUSED  AND ON ANY THEORY OF    */

  28. /*    LIABILITY, WHETHER  IN CONTRACT, STRICT  LIABILITY, OR TORT    */

  29. /*    (INCLUDING NEGLIGENCE OR OTHERWISE)  ARISING IN ANY WAY OUT    */

  30. /*    OF  THE  USE OF  THIS  SOFTWARE,  EVEN  IF ADVISED  OF  THE    */

  31. /*    POSSIBILITY OF SUCH DAMAGE.                                    */

  32. /*                                                                   */

  33. /* The views and conclusions contained in the software and           */

  34. /* documentation are those of the authors and should not be          */

  35. /* interpreted as representing official policies, either expressed   */

  36. /* or implied, of The University of Texas at Austin.                 */

  37. /*********************************************************************/

  38. 

  39. #define ASSEMBLER

  40. #include "common.h"

  41. 

  42. #ifdef PENTIUM

  43. #define P 88

  44. #endif

  45. 

  46. #ifndef P

  47. #define P 1000

  48. #endif

  49. 

  50. #define STACK	16

  51. #define ARGS	24

  52. 

  53. #define NLDA	  0 + STACK(%esp)

  54. #define XP	  4 + STACK(%esp)

  55. #define MIN_M	  8 + STACK(%esp)

  56. #define J	 12 + STACK(%esp)

  57. #define IS	 16 + STACK(%esp)

  58. 

  59. #define M	 4 + STACK + ARGS(%esp)

  60. #define N	 8 + STACK + ARGS(%esp)

  61. #define K	12 + STACK + ARGS(%esp)

  62. #define ALPHA	16 + STACK + ARGS(%esp)

  63. 

  64. #define A	32 + STACK + ARGS(%esp)

  65. #define LDA	36 + STACK + ARGS(%esp)

  66. #define X	40 + STACK + ARGS(%esp)

  67. #define INCX	44 + STACK + ARGS(%esp)

  68. #define Y	48 + STACK + ARGS(%esp)

  69. #define INCY	52 + STACK + ARGS(%esp)

  70. #define BUFFER	56 + STACK + ARGS(%esp)

  71. 

  72. 

  73. 	PROLOGUE

  74. 

  75. 	subl	$ARGS,	%esp

  76. 	pushl	%ebp

  77. 	pushl	%edi

  78. 	pushl	%esi

  79. 	pushl	%ebx

  80. 

  81. 	PROFCODE

  82. 

  83. 	FLD	ALPHA

  84. 

  85. 	movl	X, %edi			# X

  86. 

  87. 	movl	$0, IS

  88. 

  89. 	movl	M, %ebx

  90. 	movl	N, %eax

  91. 

  92. 	testl	%ebx, %ebx

  93. 	jle	.L79

  94. 	testl	%eax, %eax

  95. 	jle	.L79

  96. 

  97. 	movl	INCX, %esi

  98. 	sall	$BASE_SHIFT, %esi

  99. 	movl	%esi, INCX

  100. 

  101. 	movl	INCY, %esi

  102. 	sall	$BASE_SHIFT, %esi

  103. 	movl	%esi, INCY

  104. 

  105. 	movl	LDA,  %ebx

  106. 

  107. 	imull	%ebx, %eax

  108. 	movl	$P,   %esi

  109. 	subl	%eax, %esi

  110. 	sall	$BASE_SHIFT, %esi

  111. 	movl	%esi, NLDA

  112. 

  113. 	movl	%ebx, %esi

  114. 	sall	$BASE_SHIFT, %esi

  115. 	movl	%esi, LDA

  116. 	ALIGN_2

  117. 

  118. .L32:

  119. 	movl	IS,  %esi

  120. 

  121. 	movl	$P, %edx

  122. 	movl	M,    %eax

  123. 	subl	%esi, %eax

  124. 	cmpl	%edx, %eax

  125. #ifdef PENTIUM

  126. 	jle	.L33

  127. 	movl	%edx, %eax

  128. .L33:

  129. #else

  130. 	cmovg	%edx, %eax

  131. #endif

  132. 	movl	%eax, MIN_M

  133. 

  134. 	movl	IS, %ecx

  135. 	sall	$BASE_SHIFT, %ecx

  136. 	leal	(%edi,%ecx, 1), %ecx

  137. 	movl	INCX, %ebx

  138. 	movl	%ecx, XP

  139. 	cmpl	$SIZE, %ebx

  140. 	je	.L34

  141. 

  142. 	movl	BUFFER, %esi

  143. 	movl	MIN_M, %ecx

  144. 	movl	%esi, XP

  145. 	sarl	$2, %ecx

  146. 	jle	.L35

  147. 

  148. 	ALIGN_3

  149. 

  150. .L36:

  151. 	FLD	(%edi)

  152. 	addl	%ebx, %edi

  153. 	FST	0 * SIZE(%esi)

  154. 

  155. 	FLD	(%edi)

  156. 	addl	%ebx, %edi

  157. 	FST	1 * SIZE(%esi)

  158. 

  159. 	FLD	(%edi)

  160. 	addl	%ebx, %edi

  161. 	FST	2 * SIZE(%esi)

  162. 

  163. 	FLD	(%edi)

  164. 	addl	%ebx, %edi

  165. 	FST	3 * SIZE(%esi)

  166. 

  167. 	addl	$4 * SIZE, %esi

  168. 	decl	%ecx

  169. 	jg	.L36

  170. 	ALIGN_3

  171. 

  172. .L35:

  173. 	movl	MIN_M, %ecx

  174. 	andl	$3,%ecx

  175. 	jle	.L34

  176. 	ALIGN_2

  177. 

  178. .L42:

  179. 	FLD	(%edi)

  180. 	addl	%ebx,  %edi

  181. 	FST	(%esi)

  182. 	addl	$SIZE, %esi

  183. 	decl	%ecx

  184. 	jg	.L42

  185. 	ALIGN_3

  186. 

  187. /* Main Routine */

  188. 

  189. .L34:

  190. 	movl	Y, %ebp			# coffset = y

  191. 

  192. 	movl	N, %esi

  193. 	sarl	$2, %esi

  194. 	movl	%esi, J

  195. 	jle	.L47

  196. 	ALIGN_3

  197. 

  198. .L48:

  199. 	movl	A, %ebx				# a_offset = a

  200. 	fldz

  201. 	movl	LDA, %edx

  202. 	fldz

  203. 

  204. 	leal	(%ebx, %edx), %ecx		# a_offset2 = a + lda

  205. 	fldz

  206. 	leal	(%ebx, %edx, 4), %eax

  207. 	fldz

  208. 

  209. 	movl	%eax, A

  210. 	movl	XP, %esi

  211. 	FLD	(%esi)

  212. 

  213. 	movl	MIN_M, %eax

  214. 	sarl	$2,%eax

  215. 	jle	.L51

  216. 	ALIGN_3

  217. 

  218. #define PRESIZE 8

  219. 

  220. .L80:

  221. #ifdef PENTIUM3

  222. 	prefetcht0	PRESIZE * SIZE(%ebx, %edx, 2)

  223. 	FLD	0 * SIZE(%ebx)		# at   = *(a_offset  + 0 * lda)

  224. 	fmul	%st(1),%st		# at1 *= bt1

  225. 

  226. 	prefetcht0	PRESIZE * SIZE(%ecx)

  227. 	faddp	%st,%st(2)		# ct1 += at1

  228. 	FLD	0 * SIZE(%ecx)		# at1  = *(a_offset2 + 0 * lda)

  229. 

  230. 	prefetcht0	PRESIZE * SIZE(%ecx, %edx, 2)

  231. 	fmul	%st(1),%st		# at1 *= bt1

  232. 	faddp	%st,%st(3)		# ct2 += at1

  233. 

  234. 	prefetcht0	PRESIZE * SIZE(%ebx)

  235. 	FLD	0 * SIZE(%ebx, %edx, 2)	# at   = *(a_offset  + 2 * lda)

  236. 	fmul	%st(1),%st

  237. 

  238. 	faddp	%st,%st(4)

  239. 	FLD	0 * SIZE(%ecx, %edx, 2)	# at1  = *(a_offset2 + 2 * lda)

  240. 	fmulp	%st, %st(1)

  241. 

  242. 	faddp	%st,%st(4)

  243. 	FLD	1 * SIZE(%esi)

  244. 	FLD	1 * SIZE(%ebx)		# at   = *(a_offset  + 0 * lda)

  245. 

  246. 	fmul	%st(1),%st		# at1 *= bt1

  247. 	faddp	%st,%st(2)		# ct1 += at1

  248. 	FLD	1 * SIZE(%ecx)		# at1  = *(a_offset2 + 0 * lda)

  249. 

  250. 	fmul	%st(1),%st		# at1 *= bt1

  251. 	faddp	%st,%st(3)		# ct2 += at1

  252. 	FLD	1 * SIZE(%ebx, %edx, 2)	# at   = *(a_offset  + 2 * lda)

  253. 

  254. 	fmul	%st(1),%st

  255. 	faddp	%st,%st(4)

  256. 	FLD	1 * SIZE(%ecx, %edx, 2)	# at1  = *(a_offset2 + 2 * lda)

  257. 

  258. 	fmulp	%st, %st(1)

  259. 	faddp	%st,%st(4)

  260. 	FLD	2 * SIZE(%esi)

  261. 

  262. 	FLD	2 * SIZE(%ebx)		# at   = *(a_offset  + 0 * lda)

  263. 	fmul	%st(1),%st		# at1 *= bt1

  264. 	faddp	%st,%st(2)		# ct1 += at1

  265. 

  266. 	FLD	2 * SIZE(%ecx)		# at1  = *(a_offset2 + 0 * lda)

  267. 	fmul	%st(1),%st		# at1 *= bt1

  268. 	faddp	%st,%st(3)		# ct2 += at1

  269. 

  270. 	FLD	2 * SIZE(%ebx, %edx, 2)	# at   = *(a_offset  + 2 * lda)

  271. 	fmul	%st(1),%st

  272. 	faddp	%st,%st(4)

  273. 

  274. 	FLD	2 * SIZE(%ecx, %edx, 2)	# at1  = *(a_offset2 + 2 * lda)

  275. 	fmulp	%st, %st(1)

  276. 	faddp	%st,%st(4)

  277. 

  278. 	FLD	3 * SIZE(%esi)

  279. 	FLD	3 * SIZE(%ebx)		# at   = *(a_offset  + 0 * lda)

  280. 	fmul	%st(1),%st		# at1 *= bt1

  281. 

  282. 	faddp	%st,%st(2)		# ct1 += at1

  283. 	FLD	3 * SIZE(%ecx)		# at1  = *(a_offset2 + 0 * lda)

  284. 	fmul	%st(1),%st		# at1 *= bt1

  285. 

  286. 	faddp	%st,%st(3)		# ct2 += at1

  287. 	FLD	3 * SIZE(%ebx, %edx, 2)	# at   = *(a_offset  + 2 * lda)

  288. 	fmul	%st(1),%st

  289. 

  290. 	faddp	%st,%st(4)

  291. 	FLD	3 * SIZE(%ecx, %edx, 2)	# at1  = *(a_offset2 + 2 * lda)

  292. 	fmulp	%st, %st(1)

  293. 

  294. 	addl	$4 * SIZE, %ebx

  295. 	faddp	%st,%st(4)

  296. 	addl	$4 * SIZE, %ecx

  297. 

  298. 	FLD	4 * SIZE(%esi)

  299. 	addl	$4 * SIZE, %esi

  300. 

  301. #else

  302. 

  303. #if defined(HAS_PREFETCH)

  304.        prefetcht0	PRESIZE * SIZE(%ebx)

  305.        prefetcht0	PRESIZE * SIZE(%ebx, %edx, 2)

  306.        prefetcht0	PRESIZE * SIZE(%ecx)

  307.        prefetcht0	PRESIZE * SIZE(%ecx, %edx, 2)

  308. #endif

  309. 

  310. 	FLD	0 * SIZE(%ebx)		# at   = *(a_offset  + 0 * lda)

  311. 	fmul	%st(1),%st		# at1 *= bt1

  312. 	faddp	%st,%st(2)		# ct1 += at1

  313. 

  314. 	FLD	0 * SIZE(%ecx)		# at1  = *(a_offset2 + 0 * lda)

  315. 	fmul	%st(1),%st		# at1 *= bt1

  316. 	faddp	%st,%st(3)		# ct2 += at1

  317. 

  318. 	FLD	0 * SIZE(%ebx, %edx, 2)	# at   = *(a_offset  + 2 * lda)

  319. 	fmul	%st(1),%st

  320. 	faddp	%st,%st(4)

  321. 

  322. 	FLD	0 * SIZE(%ecx, %edx, 2)	# at1  = *(a_offset2 + 2 * lda)

  323. 	fmulp	%st, %st(1)

  324. 	faddp	%st,%st(4)

  325. 	FLD	1 * SIZE(%esi)

  326. 

  327. 	FLD	1 * SIZE(%ebx)		# at   = *(a_offset  + 0 * lda)

  328. 	fmul	%st(1),%st		# at1 *= bt1

  329. 	faddp	%st,%st(2)		# ct1 += at1

  330. 

  331. 	FLD	1 * SIZE(%ecx)		# at1  = *(a_offset2 + 0 * lda)

  332. 	fmul	%st(1),%st		# at1 *= bt1

  333. 	faddp	%st,%st(3)		# ct2 += at1

  334. 

  335. 	FLD	1 * SIZE(%ebx, %edx, 2)	# at   = *(a_offset  + 2 * lda)

  336. 	fmul	%st(1),%st

  337. 	faddp	%st,%st(4)

  338. 

  339. 	FLD	1 * SIZE(%ecx, %edx, 2)	# at1  = *(a_offset2 + 2 * lda)

  340. 	fmulp	%st, %st(1)

  341. 	faddp	%st,%st(4)

  342. 	FLD	2 * SIZE(%esi)

  343. 

  344. 	FLD	2 * SIZE(%ebx)		# at   = *(a_offset  + 0 * lda)

  345. 	fmul	%st(1),%st		# at1 *= bt1

  346. 	faddp	%st,%st(2)		# ct1 += at1

  347. 

  348. 	FLD	2 * SIZE(%ecx)		# at1  = *(a_offset2 + 0 * lda)

  349. 	fmul	%st(1),%st		# at1 *= bt1

  350. 	faddp	%st,%st(3)		# ct2 += at1

  351. 

  352. 	FLD	2 * SIZE(%ebx, %edx, 2)	# at   = *(a_offset  + 2 * lda)

  353. 	fmul	%st(1),%st

  354. 	faddp	%st,%st(4)

  355. 

  356. 	FLD	2 * SIZE(%ecx, %edx, 2)	# at1  = *(a_offset2 + 2 * lda)

  357. 	fmulp	%st, %st(1)

  358. 	faddp	%st,%st(4)

  359. 	FLD	3 * SIZE(%esi)

  360. 

  361. 	FLD	3 * SIZE(%ebx)		# at   = *(a_offset  + 0 * lda)

  362. 	fmul	%st(1),%st		# at1 *= bt1

  363. 	faddp	%st,%st(2)		# ct1 += at1

  364. 

  365. 	FLD	3 * SIZE(%ecx)		# at1  = *(a_offset2 + 0 * lda)

  366. 	fmul	%st(1),%st		# at1 *= bt1

  367. 	faddp	%st,%st(3)		# ct2 += at1

  368. 

  369. 	FLD	3 * SIZE(%ebx, %edx, 2)	# at   = *(a_offset  + 2 * lda)

  370. 	fmul	%st(1),%st

  371. 	faddp	%st,%st(4)

  372. 

  373. 	FLD	3 * SIZE(%ecx, %edx, 2)	# at1  = *(a_offset2 + 2 * lda)

  374. 	fmulp	%st, %st(1)

  375. 	faddp	%st,%st(4)

  376. 	FLD	4 * SIZE(%esi)

  377. 

  378. 	addl	$4 * SIZE, %ebx

  379. 	addl	$4 * SIZE, %ecx

  380. 	addl	$4 * SIZE, %esi

  381. #endif

  382. 

  383. 	decl	%eax

  384. 	jg	.L80

  385. 	ALIGN_3

  386. 

  387. .L51:

  388. 	movl	MIN_M, %eax

  389. 	andl	$3,    %eax

  390. 	je	.L81

  391. 	ALIGN_3

  392. 

  393. .L52:

  394. 

  395. 	FLD	(%ebx)			# at   = *(a_offset  + 0 * lda)

  396. 	fmul	%st(1),%st		# at1 *= bt1

  397. 	faddp	%st,%st(2)		# ct1 += at1

  398. 

  399. 	FLD	(%ecx)			# at1  = *(a_offset2 + 0 * lda)

  400. 	fmul	%st(1),%st		# at1 *= bt1

  401. 	faddp	%st,%st(3)		# ct2 += at1

  402. 

  403. 	FLD	(%ebx, %edx, 2)		# at   = *(a_offset  + 2 * lda)

  404. 	fmul	%st(1),%st

  405. 	faddp	%st,%st(4)

  406. 

  407. 	FLD	(%ecx, %edx, 2)		# at1  = *(a_offset2 + 2 * lda)

  408. 	fmulp	%st, %st(1)

  409. 	faddp	%st,%st(4)

  410. 	FLD	1 * SIZE(%esi)

  411. 

  412. 	addl	$SIZE, %ebx

  413. 	addl	$SIZE, %ecx

  414. 	addl	$SIZE, %esi

  415. 	decl	%eax

  416. 	jg	.L52

  417. 	ALIGN_3

  418. 

  419. .L81:

  420. 	ffreep	%st(0)

  421. 

  422. 	fxch	%st(4)

  423. 	fmul	%st, %st(4)

  424. 	fmul	%st, %st(1)

  425. 	fmul	%st, %st(2)

  426. 	fmul	%st, %st(3)

  427. 	fxch	%st(4)

  428. 

  429. 	movl	INCY, %eax

  430. 

  431. 	FLD	(%ebp)

  432. 	faddp	%st, %st(1)

  433. 	FST	(%ebp)

  434. 	addl	%eax, %ebp

  435. 

  436. 	FLD	(%ebp)

  437. 	faddp	%st, %st(1)

  438. 	FST	(%ebp)

  439. 	addl	%eax, %ebp

  440. 

  441. 	FLD	(%ebp)

  442. 	faddp	%st, %st(1)

  443. 	FST	(%ebp)

  444. 	addl	%eax, %ebp

  445. 

  446. 	FLD	(%ebp)

  447. 	faddp	%st, %st(1)

  448. 	FST	(%ebp)

  449. 	addl	%eax, %ebp

  450. 

  451. 	decl	J

  452. 	jg	.L48

  453. 	ALIGN_3

  454. 

  455. .L47:

  456. 	movl	N, %esi

  457. 	andl	$3,%esi

  458. 	movl	%esi, J

  459. 	jle	.L60

  460. 	ALIGN_2

  461. 

  462. .L61:

  463. 	movl	A, %ebx			# a_offset = a

  464. 	fldz				# ct1 = ZERO

  465. 	movl	LDA, %edx

  466. 	fldz				# ct1 = ZERO

  467. 

  468. 	addl	%ebx, %edx

  469. 	fldz				# ct1 = ZERO

  470. 	movl	%edx, A

  471. 	fldz				# ct1 = ZERO

  472. 

  473. 	movl	XP, %esi

  474. 

  475. 	movl	MIN_M, %eax

  476. 	sarl	$3,%eax

  477. 	jle	.L64

  478. 	ALIGN_3

  479. 

  480. .L65:

  481. #ifdef HAS_PREFETCH

  482.        prefetcht0	PRESIZE * 2 * SIZE(%ebx)

  483.        prefetcht0	PRESIZE * 2 * SIZE(%ebx)

  484. #endif

  485. 

  486. 	FLD	0 * SIZE(%esi)

  487. 	FLD	0 * SIZE(%ebx)

  488. 	fmulp	%st, %st(1)

  489. 	faddp	%st,%st(1)

  490. 

  491. 	FLD	1 * SIZE(%esi)

  492. 	FLD	1 * SIZE(%ebx)

  493. 	fmulp	%st, %st(1)

  494. 	faddp	%st,%st(2)

  495. 

  496. 	FLD	2 * SIZE(%esi)

  497. 	FLD	2 * SIZE(%ebx)

  498. 	fmulp	%st, %st(1)

  499. 	faddp	%st,%st(3)

  500. 

  501. 	FLD	3 * SIZE(%esi)

  502. 	FLD	3 * SIZE(%ebx)

  503. 	fmulp	%st, %st(1)

  504. 	faddp	%st,%st(4)

  505. 

  506. 	FLD	4 * SIZE(%esi)

  507. 	FLD	4 * SIZE(%ebx)

  508. 	fmulp	%st, %st(1)

  509. 	faddp	%st,%st(1)

  510. 

  511. 	FLD	5 * SIZE(%esi)

  512. 	FLD	5 * SIZE(%ebx)

  513. 	fmulp	%st, %st(1)

  514. 	faddp	%st,%st(2)

  515. 

  516. 	FLD	6 * SIZE(%esi)

  517. 	FLD	6 * SIZE(%ebx)

  518. 	fmulp	%st, %st(1)

  519. 	faddp	%st,%st(3)

  520. 

  521. 	FLD	7 * SIZE(%esi)

  522. 	FLD	7 * SIZE(%ebx)

  523. 	fmulp	%st, %st(1)

  524. 	faddp	%st,%st(4)

  525. 

  526. 	addl	$8 * SIZE, %esi

  527. 	addl	$8 * SIZE, %ebx

  528. 

  529. 	decl	%eax

  530. 	jg	.L65

  531. 	ALIGN_3

  532. 

  533. .L64:

  534. 	movl	MIN_M, %eax

  535. 	andl	$7, %eax

  536. 	jle	.L70

  537. 	ALIGN_3

  538. 

  539. .L71:

  540. 	FLD	(%esi)

  541. 	FLD	(%ebx)

  542. 	fmulp	%st, %st(1)

  543. 	faddp	%st,%st(1)

  544. 

  545. 	addl	$SIZE, %esi

  546. 	addl	$SIZE, %ebx

  547. 	decl	%eax

  548. 	jg	.L71

  549. 	ALIGN_3

  550. 

  551. .L70:

  552. 	faddp	%st, %st(1)

  553. 	faddp	%st, %st(1)

  554. 	faddp	%st, %st(1)

  555. 

  556. 	fmul	%st(1),%st

  557. 	FLD	(%ebp)

  558. 	faddp	%st, %st(1)

  559. 	FST	(%ebp)

  560. 	addl	INCY, %ebp

  561. 	decl	J

  562. 	jg	.L61

  563. 	ALIGN_3

  564. 

  565. .L60:

  566. 	movl	A, %ebx

  567. 	addl	NLDA, %ebx

  568. 	movl	%ebx, A

  569. 

  570. 	addl	$P,  IS

  571. 	movl	M, %esi

  572. 	cmpl	%esi, IS

  573. 	jl	.L32

  574. 	ALIGN_3

  575. 

  576. .L79:

  577. 	ffreep	%st(0)

  578. 	popl	%ebx

  579. 	popl	%esi

  580. 	popl	%edi

  581. 	popl	%ebp

  582. 	addl	$ARGS, %esp

  583. 	ret

  584. 

  585. 	EPILOGUE