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: de139337b8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'de139337b8'
${ noResults }
OpenBLAS/kernel/x86/zgemm3m_kernel_2x2_coppermi...

723 lines
14 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. #define STACK	16

  43. #define ARGS	16

  44. 

  45. #define J	 0 + STACK(%esp)

  46. #define BX	 4 + STACK(%esp)

  47. #define KK	 8 + STACK(%esp)

  48. #define KKK	12 + STACK(%esp)

  49. 

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

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

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

  53. #ifdef DOUBLE

  54. #define ALPHA_R	16 + STACK + ARGS(%esp)

  55. #define ALPHA_I	24 + STACK + ARGS(%esp)

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

  57. #define B	36 + STACK + ARGS(%esp)

  58. #define C	40 + STACK + ARGS(%esp)

  59. #define LDC	44 + STACK + ARGS(%esp)

  60. #else

  61. #define ALPHA_R	16 + STACK + ARGS(%esp)

  62. #define ALPHA_I	20 + STACK + ARGS(%esp)

  63. #define A	24 + STACK + ARGS(%esp)

  64. #define B	28 + STACK + ARGS(%esp)

  65. #define C	32 + STACK + ARGS(%esp)

  66. #define LDC	36 + STACK + ARGS(%esp)

  67. #endif

  68. 

  69. #define PREFETCH_OFFSET 48

  70. 

  71. #if defined(PENTIUM3) || defined(PENTIUMM)

  72. #define REP rep

  73. #else

  74. #define REP rep

  75. #endif

  76. 

  77. 	PROLOGUE

  78. 

  79. 	subl	$ARGS, %esp	# Generate Stack Frame

  80. 

  81. 	pushl	%ebp

  82. 	pushl	%edi

  83. 	pushl	%esi

  84. 	pushl	%ebx

  85. 

  86. 	PROFCODE

  87. 

  88. #if defined(TRMMKERNEL) && !defined(LEFT)

  89. 	movl	OFFSET, %eax

  90. 	negl	%eax

  91. 	movl	%eax, KK

  92. #endif

  93. 

  94. 	movl	N,   %eax		# j = (n >> 1)		# MEMORY

  95. 	movl	LDC, %ebp		# ldc			# MEMORY

  96. 	movl	B,   %ebx

  97. 

  98. 	sall	$ZBASE_SHIFT, %ebp

  99. 

  100. 	sarl	$1,  %eax

  101. 

  102. 	leal	0(%ecx) , %ecx		# NOP

  103. 	movl	%eax, J			# j = (n >> 1)		# MEMORY

  104. 	test	%eax, %eax

  105. 	je	.L8			# if !(n >> 1) goto .L8

  106. 	ALIGN_4

  107. 

  108. .L34:

  109. #if defined(TRMMKERNEL) && defined(LEFT)

  110. 	movl	OFFSET, %eax

  111. 	movl	%eax, KK

  112. #endif

  113. 

  114. 	movl	%ebx, BX

  115. 

  116. 	movl	M, %esi			# m			# MEMORY

  117. 	movl	A, %edx			# a			# MEMORY

  118. 	movl	C, %edi			# C			# MEMORY

  119. 	sarl	$1,   %esi		# i = (m >> 1)

  120. 	je	.L12

  121. 	ALIGN_4

  122. 

  123. .MainHead:

  124. #if !defined(TRMMKERNEL) || \

  125. 	(defined(TRMMKERNEL) &&  defined(LEFT) &&  defined(TRANSA)) || \

  126. 	(defined(TRMMKERNEL) && !defined(LEFT) && !defined(TRANSA))

  127. 	movl	%ebx, %ecx

  128. #else

  129. 	movl	KK,   %eax

  130. 	leal	(, %eax, SIZE), %eax

  131. 	leal	(%edx, %eax, 2), %edx

  132. 	leal	(%ebx, %eax, 2), %ecx

  133. #endif

  134. 

  135. #ifdef HAVE_SSE

  136. 	movl	BX, %eax

  137. 

  138. 	prefetcht2  0 * SIZE(%eax)

  139. 	prefetcht2  4 * SIZE(%eax)

  140. 

  141. #if   L2_SIZE > 262144

  142. 

  143. 	subl	$-8 * SIZE, BX

  144. 

  145. #elif L2_SIZE > 131072

  146. 

  147. 	prefetcht2  8 * SIZE(%eax)

  148. 	prefetcht2 12 * SIZE(%eax)

  149. 

  150. 

  151. 	subl	$-16 * SIZE, BX

  152. #else

  153. 	prefetcht2 16 * SIZE(%eax)

  154. 	prefetcht2 20 * SIZE(%eax)

  155. 	prefetcht2 24 * SIZE(%eax)

  156. 	prefetcht2 28 * SIZE(%eax)

  157. 

  158. 	subl	$-32 * SIZE, BX

  159. #endif

  160. #endif

  161. 

  162. 	fldz

  163. 	fldz

  164. 

  165. #ifndef TRMMKERNEL

  166. 	movl	K, %eax

  167. #elif (defined(LEFT) && !defined(TRANSA)) || (!defined(LEFT) && defined(TRANSA))

  168. 	movl	K, %eax

  169. 	subl	KK, %eax

  170. 	movl	%eax, KKK

  171. #else

  172. 	movl	KK, %eax

  173. #ifdef LEFT

  174. 	addl	$2, %eax

  175. #else

  176. 	addl	$2, %eax

  177. #endif

  178. 	movl	%eax, KKK

  179. #endif

  180. 	fldz

  181. 	fldz

  182. 

  183. 	FLD	 4 * SIZE(%ecx)		# b5

  184. 	FLD	 4 * SIZE(%edx)		# a5

  185. 	FLD	 0 * SIZE(%ecx)		# b1

  186. 	FLD	 0 * SIZE(%edx)		# a1

  187. 

  188. #if   defined(HAVE_3DNOW)

  189. 	prefetchw	2 * SIZE(%edi)

  190.  	prefetchw	2 * SIZE(%edi, %ebp, 1)

  191. #elif defined(HAVE_SSE)

  192. 	prefetchnta	2 * SIZE(%edi)

  193.  	prefetchnta	2 * SIZE(%edi, %ebp, 1)

  194. #endif

  195. 	sarl	$2, %eax

  196.  	je	.L16

  197. 	ALIGN_4

  198. 

  199. .MainLoop:

  200. #if defined(HAVE_3DNOW)

  201. 	prefetch	(PREFETCH_OFFSET) * SIZE(%ecx)

  202. 	nop

  203. #elif defined(HAVE_SSE)

  204. 	prefetchnta	(PREFETCH_OFFSET) * SIZE(%ecx)

  205. #ifdef CORE_KATMAI

  206. 	prefetcht0	(PREFETCH_OFFSET) * SIZE(%edx)

  207. #endif

  208. #endif

  209. 

  210. 	fmul	%st, %st(1)

  211. 	FMUL	 1 * SIZE(%ecx)

  212. 	fxch	%st(1)

  213. 	faddp	%st, %st(4)

  214. 	FLD	 0 * SIZE(%ecx)

  215. 	fxch	%st(1)

  216. 	faddp	%st, %st(5)

  217. 	FLD	 1 * SIZE(%edx)

  218. 	fmul	%st, %st(1)

  219. 	FMUL	 1 * SIZE(%ecx)

  220. 	fxch	%st(1)

  221. 	faddp	%st, %st(6)

  222. 	FLD	 2 * SIZE(%ecx)

  223. 	fxch	%st(1)

  224. 	faddp	%st, %st(7)

  225. 	FLD	 2 * SIZE(%edx)

  226. 

  227. 	fmul	%st, %st(1)

  228. 	FMUL	 3 * SIZE(%ecx)

  229. 	fxch	%st(1)

  230. 	faddp	%st, %st(4)

  231. 	FLD	 2 * SIZE(%ecx)

  232. 	fxch	%st(1)

  233. 	faddp	%st, %st(5)

  234. 	FLD	 3 * SIZE(%edx)

  235. 	fmul	%st, %st(1)

  236. 	FMUL	 3 * SIZE(%ecx)

  237. 	fxch	%st(1)

  238. 	faddp	%st, %st(6)

  239. 	FLD	 8 * SIZE(%ecx)

  240. 	fxch	%st(1)

  241. 	faddp	%st, %st(7)

  242. 	FLD	 8 * SIZE(%edx)

  243. 	fxch	%st(2)

  244. 

  245. #if !defined(HAVE_3DNOW) && defined(HAVE_SSE)  && defined(DOUBLE)

  246. 	prefetchnta	(PREFETCH_OFFSET + 4) * SIZE(%ecx)

  247. #ifdef CORE_KATMAI

  248. 	prefetcht0	(PREFETCH_OFFSET + 4) * SIZE(%edx)

  249. #endif

  250. #endif

  251. 

  252. 	fmul	%st, %st(3)

  253. 	FMUL	 5 * SIZE(%ecx)

  254. 	fxch	%st(3)

  255. 	faddp	%st, %st(4)

  256. 	FLD	 4 * SIZE(%ecx)

  257. 	fxch	%st(3)

  258. 	faddp	%st, %st(5)

  259. 	FLD	 5 * SIZE(%edx)

  260. 	fmul	%st, %st(3)

  261. 	FMUL	 5 * SIZE(%ecx)

  262. 	fxch	%st(3)

  263. 	faddp	%st, %st(6)

  264. 	FLD	 6 * SIZE(%ecx)

  265. 	fxch	%st(3)

  266. 	faddp	%st, %st(7)

  267. 	FLD	 6 * SIZE(%edx)

  268. 

  269. 	fmul	%st, %st(3)

  270. 	FMUL	 7 * SIZE(%ecx)

  271. 	fxch	%st(3)

  272. 	faddp	%st, %st(4)

  273. 	FLD	 6 * SIZE(%ecx)

  274. 	fxch	%st(3)

  275. 	faddp	%st, %st(5)

  276. 	FLD	 7 * SIZE(%edx)

  277. 	fmul	%st, %st(3)

  278. 	FMUL	 7 * SIZE(%ecx)

  279. 	fxch	%st(3)

  280. 	faddp	%st, %st(6)

  281. 	FLD	12 * SIZE(%ecx)

  282. 	fxch	%st(3)

  283. 	faddp	%st, %st(7)

  284. 	FLD	12 * SIZE(%edx)

  285. 	fxch	%st(2)

  286. 

  287. 	subl	$-8 * SIZE, %ecx

  288. 	subl	$-8 * SIZE, %edx

  289. 	decl	%eax			# l --

  290. 	jne	.MainLoop

  291. 	ALIGN_4

  292. 

  293. .L16:

  294. #ifndef TRMMKERNEL

  295. 	movl	K, %eax

  296. #else

  297. 	movl	KKK, %eax

  298. #endif

  299. 	and	$3,  %eax

  300. 	je	.L21

  301. 	ALIGN_4

  302. 

  303. .SubLoop:

  304. 	fmul	%st, %st(1)

  305. 	FMUL	 1 * SIZE(%ecx)

  306. 	fxch	%st(1)

  307. 	faddp	%st, %st(4)

  308. 	FLD	 0 * SIZE(%ecx)

  309. 	fxch	%st(1)

  310. 	faddp	%st, %st(5)

  311. 	FLD	 1 * SIZE(%edx)

  312. 	fmul	%st, %st(1)

  313. 	FMUL	 1 * SIZE(%ecx)

  314. 	fxch	%st(1)

  315. 	faddp	%st, %st(6)

  316. 	FLD	 2 * SIZE(%ecx)

  317. 	fxch	%st(1)

  318. 	faddp	%st, %st(7)

  319. 	FLD	 2 * SIZE(%edx)

  320. 

  321. 	addl	$2 * SIZE,%ecx

  322. 	addl	$2 * SIZE,%edx

  323. 	decl	%eax

  324. 	jne	 .SubLoop

  325. 	ALIGN_4

  326. 

  327. .L21:

  328. 	ffreep	%st(0)

  329. 	ffreep	%st(0)

  330. 	ffreep	%st(0)

  331. 	ffreep	%st(0)

  332. 

  333. 	FLD	ALPHA_I

  334. 	FLD	ALPHA_R

  335. 

  336. 	fld	%st(2)

  337. 	fmul	%st(1), %st

  338. 

  339. 	FLD	0 * SIZE(%edi)

  340. 	faddp	%st, %st(1)

  341. 	FST	0 * SIZE(%edi)

  342. 

  343. 	fld	%st(3)

  344. 	fmul	%st(1), %st

  345. 

  346. 	FLD	0 * SIZE(%edi, %ebp)

  347. 	faddp	%st, %st(1)

  348. 	FST	0 * SIZE(%edi, %ebp)

  349. 

  350. 	fld	%st(4)

  351. 	fmul	%st(1), %st

  352. 

  353. 	FLD	2 * SIZE(%edi)

  354. 	faddp	%st, %st(1)

  355. 	FST	2 * SIZE(%edi)

  356. 

  357. 	fmul	%st(5), %st

  358. 

  359. 	FLD	2 * SIZE(%edi, %ebp)

  360. 	faddp	%st, %st(1)

  361. 	FST	2 * SIZE(%edi, %ebp)

  362. 

  363. 	fmul	%st, %st(1)

  364. 	fmul	%st, %st(2)

  365. 	fmul	%st, %st(3)

  366. 	fmulp	%st, %st(4)

  367. 

  368. 	FLD	1 * SIZE(%edi)

  369. 	faddp	%st, %st(1)

  370. 	FST	1 * SIZE(%edi)

  371. 

  372. 	FLD	1 * SIZE(%edi, %ebp)

  373. 	faddp	%st, %st(1)

  374. 	FST	1 * SIZE(%edi, %ebp)

  375. 

  376. 	FLD	3 * SIZE(%edi)

  377. 	faddp	%st, %st(1)

  378. 	FST	3 * SIZE(%edi)

  379. 

  380. 	FLD	3 * SIZE(%edi, %ebp)

  381. 	faddp	%st, %st(1)

  382. 	FST	3 * SIZE(%edi, %ebp)

  383. 

  384. 	addl	$4 * SIZE, %edi

  385. 	rep

  386. 	decl	%esi			# i --

  387. 	rep

  388. 	jne	.MainHead

  389. 	ALIGN_4

  390. 

  391. .L12:

  392. 	movl	 M, %eax		# m			# MEMORY

  393. 	andl	$1, %eax

  394. 	je	.L27

  395. 

  396. #if !defined(TRMMKERNEL) || \

  397. 	(defined(TRMMKERNEL) &&  defined(LEFT) &&  defined(TRANSA)) || \

  398. 	(defined(TRMMKERNEL) && !defined(LEFT) && !defined(TRANSA))

  399. 	movl	%ebx, %ecx

  400. #else

  401. 	movl	KK,   %eax

  402. 	leal	(, %eax, SIZE), %eax

  403. 	leal	(%edx, %eax, 1), %edx

  404. 	leal	(%ebx, %eax, 2), %ecx

  405. #endif

  406. 	fldz

  407. 	fldz

  408. 

  409. 	FLD	0 * SIZE(%edx)		# temp1 = *(aoffset + 0)

  410. 

  411. #ifndef TRMMKERNEL

  412. 	movl	K, %eax

  413. #elif (defined(LEFT) && !defined(TRANSA)) || (!defined(LEFT) && defined(TRANSA))

  414. 	movl	K, %eax

  415. 	subl	KK, %eax

  416. 	movl	%eax, KKK

  417. #else

  418. 	movl	KK, %eax

  419. #ifdef LEFT

  420. 	addl	$1, %eax

  421. #else

  422. 	addl	$2, %eax

  423. #endif

  424. 	movl	%eax, KKK

  425. #endif

  426. 	sarl	$1,%eax			# k >> 1		# MEMORY

  427. 	je	 .L54

  428. 	ALIGN_4

  429. 

  430. .L55:

  431. 	FLD	0 * SIZE(%ecx)		# temp2 = *(boffset + 0)

  432. 	rep

  433. 	fmul	%st(1), %st

  434. 	faddp	%st, %st(2)

  435. 

  436. 	FMUL	1 * SIZE(%ecx)		# temp2 = *(boffset + 0)

  437. 	faddp	%st, %st(2)

  438. 	FLD	1 * SIZE(%edx)		# temp1 = *(aoffset + 0)

  439. 

  440. 	FLD	2 * SIZE(%ecx)		# temp2 = *(boffset + 0)

  441. 	rep

  442. 	fmul	%st(1), %st

  443. 	faddp	%st, %st(2)

  444. 

  445. 	FMUL	3 * SIZE(%ecx)		# temp2 = *(boffset + 0)

  446. 	faddp	%st, %st(2)

  447. 	FLD	2 * SIZE(%edx)		# temp1 = *(aoffset + 0)

  448. 

  449. 	addl	$2 * SIZE, %edx

  450. 	addl	$4 * SIZE, %ecx

  451. 	decl	%eax

  452. 	jne	.L55

  453. 	ALIGN_4

  454. 

  455. .L54:

  456. #ifndef TRMMKERNEL

  457. 	movl	K, %eax

  458. #else

  459. 	movl	KKK, %eax

  460. #endif

  461. 	andl	$1,%eax			# k & 1

  462. 	je	.L33

  463. 	ALIGN_4

  464. 

  465. 	FLD	0 * SIZE(%ecx)		# temp2 = *(boffset + 0)

  466. 	rep

  467. 	fmul	%st(1), %st

  468. 	faddp	%st, %st(2)

  469. 

  470. 	FMUL	1 * SIZE(%ecx)		# temp2 = *(boffset + 0)

  471. 	faddp	%st, %st(2)

  472. 	FLD	1 * SIZE(%edx)		# temp1 = *(aoffset + 0)

  473. 

  474. 	addl	$1 * SIZE, %edx

  475. 	addl	$2 * SIZE, %ecx

  476. 	ALIGN_4

  477. 

  478. .L33:

  479. 	ffreep	%st(0)

  480. 

  481. 	FLD	ALPHA_I

  482. 	FLD	ALPHA_R

  483. 

  484. 	fld	%st(2)

  485. 	fmul	%st(1), %st

  486. 

  487. 	FLD	0 * SIZE(%edi)

  488. 	faddp	%st, %st(1)

  489. 	FST	0 * SIZE(%edi)

  490. 

  491. 	fmul	%st(3), %st

  492. 

  493. 	FLD	0 * SIZE(%edi, %ebp)

  494. 	faddp	%st, %st(1)

  495. 	FST	0 * SIZE(%edi, %ebp)

  496. 

  497. 	fmul	%st, %st(1)

  498. 	fmulp	%st, %st(2)

  499. 

  500. 	FLD	1 * SIZE(%edi)

  501. 	faddp	%st, %st(1)

  502. 	FST	1 * SIZE(%edi)

  503. 

  504. 	FLD	1 * SIZE(%edi, %ebp)

  505. 	faddp	%st, %st(1)

  506. 	FST	1 * SIZE(%edi, %ebp)

  507. 	ALIGN_4

  508. 

  509. .L27:

  510. #if defined(TRMMKERNEL) && !defined(LEFT)

  511. 	addl	$2, KK

  512. #endif

  513. 

  514. 	lea	(, %ebp, 2), %eax

  515. 	addl	%eax, C			# C + 2 * ldc		# MEMORY

  516. 	movl	%ecx, %ebx		# b			# MEMORY

  517. 	decl	J			# j--			# MEMORY

  518. 	jne	.L34

  519. 	ALIGN_4

  520. 

  521. .L8:

  522. 	movl	N,  %eax		# n			# MEMORY

  523. 	andl	$1, %eax

  524. 	je	.End

  525. 

  526. #if defined(TRMMKERNEL) && defined(LEFT)

  527. 	movl	OFFSET, %eax

  528. 	movl	%eax, KK

  529. #endif

  530. 

  531. 	movl	C, %edi			# c			# MEMORY

  532. 	movl	A, %edx			# a			# MEMORY

  533. 

  534. 	movl	M,  %esi		# m			# MEMORY

  535. 	sarl	$1, %esi		# m >> 1

  536. 	je	.L36

  537. 	ALIGN_4

  538. 

  539. .L46:

  540. #if !defined(TRMMKERNEL) || \

  541. 	(defined(TRMMKERNEL) &&  defined(LEFT) &&  defined(TRANSA)) || \

  542. 	(defined(TRMMKERNEL) && !defined(LEFT) && !defined(TRANSA))

  543. 	movl	%ebx, %ecx

  544. #else

  545. 	movl	KK,   %eax

  546. 	leal	(, %eax, SIZE), %eax

  547. 	leal	(%edx, %eax, 2), %edx

  548. 	leal	(%ebx, %eax, 1), %ecx

  549. #endif

  550. 

  551. #ifndef TRMMKERNEL

  552. 	movl	K, %eax

  553. #elif (defined(LEFT) && !defined(TRANSA)) || (!defined(LEFT) && defined(TRANSA))

  554. 	movl	K, %eax

  555. 	subl	KK, %eax

  556. 	movl	%eax, KKK

  557. #else

  558. 	movl	KK, %eax

  559. #ifdef LEFT

  560. 	addl	$2, %eax

  561. #else

  562. 	addl	$1, %eax

  563. #endif

  564. 	movl	%eax, KKK

  565. #endif

  566. 	fldz

  567. 	sarl	$1, %eax

  568. 	fldz

  569. 	FLD	0 * SIZE(%ecx)		# temp1 = *(boffset + 0)

  570. 

  571. 	je	.L56

  572. 	ALIGN_4

  573. 

  574. .L57:

  575. 	FLD	0 * SIZE(%edx)		# temp2 = *(aoffset + 0)

  576. 	fmul	%st(1), %st

  577. 	faddp	%st, %st(2)

  578. 

  579. 	FMUL	1 * SIZE(%edx)		# temp2 = *(aoffset + 0)

  580. 	faddp	%st, %st(2)

  581. 	FLD	1 * SIZE(%ecx)		# temp1 = *(boffset + 0)

  582. 

  583. 	FLD	2 * SIZE(%edx)		# temp2 = *(aoffset + 0)

  584. 	fmul	%st(1), %st

  585. 	faddp	%st, %st(2)

  586. 

  587. 	FMUL	3 * SIZE(%edx)		# temp2 = *(aoffset + 0)

  588. 	faddp	%st, %st(2)

  589. 	FLD	2 * SIZE(%ecx)		# temp1 = *(boffset + 0)

  590. 

  591. 	addl	$4 * SIZE,%edx

  592. 	addl	$2 * SIZE,%ecx

  593. 	dec	%eax

  594. 	jne	.L57

  595. 	ALIGN_4

  596. 

  597. .L56:

  598. #ifndef TRMMKERNEL

  599. 	movl	K, %eax

  600. #else

  601. 	movl	KKK, %eax

  602. #endif

  603. 	andl	$1, %eax

  604. 	je	.L45

  605. 	ALIGN_4

  606. 

  607. 	FLD	0 * SIZE(%edx)		# temp2 = *(aoffset + 0)

  608. 	fmul	%st(1), %st

  609. 	faddp	%st, %st(2)

  610. 

  611. 	FMUL	1 * SIZE(%edx)		# temp2 = *(aoffset + 0)

  612. 	faddp	%st, %st(2)

  613. 	FLD	3 * SIZE(%ecx)		# temp1 = *(boffset + 0)

  614. 

  615. 	addl	$2 * SIZE,%edx

  616. 	addl	$1 * SIZE,%ecx

  617. 	ALIGN_4

  618. 

  619. .L45:

  620. 	ffreep	%st(0)

  621. 

  622. 	FLD	ALPHA_I

  623. 	FLD	ALPHA_R

  624. 

  625. 	fld	%st(2)

  626. 	fmul	%st(1), %st

  627. 

  628. 	FLD	0 * SIZE(%edi)

  629. 	faddp	%st, %st(1)

  630. 	FST	0 * SIZE(%edi)

  631. 

  632. 	fmul	%st(3), %st

  633. 

  634. 	FLD	2 * SIZE(%edi)

  635. 	faddp	%st, %st(1)

  636. 	FST	2 * SIZE(%edi)

  637. 

  638. 	fmul	%st, %st(1)

  639. 	fmulp	%st, %st(2)

  640. 

  641. 	FLD	1 * SIZE(%edi)

  642. 	faddp	%st, %st(1)

  643. 	FST	1 * SIZE(%edi)

  644. 

  645. 	FLD	3 * SIZE(%edi)

  646. 	faddp	%st, %st(1)

  647. 	FST	3 * SIZE(%edi)

  648. 

  649. 	addl	$4 * SIZE, %edi

  650. 

  651. 	decl	%esi			# i --

  652. 	jne	.L46

  653. 	ALIGN_4

  654. 

  655. .L36:

  656. 	movl	M,  %eax		# m			# MEMORY

  657. 	andl	$1, %eax		# m & 1

  658. 	je	.End

  659. 

  660. #if !defined(TRMMKERNEL) || \

  661. 	(defined(TRMMKERNEL) &&  defined(LEFT) &&  defined(TRANSA)) || \

  662. 	(defined(TRMMKERNEL) && !defined(LEFT) && !defined(TRANSA))

  663. 	movl	%ebx, %ecx

  664. #else

  665. 	movl	KK,   %eax

  666. 	leal	(, %eax, SIZE), %eax

  667. 	leal	(%edx, %eax, 1), %edx

  668. 	leal	(%ebx, %eax, 1), %ecx

  669. #endif

  670. 

  671. #ifndef TRMMKERNEL

  672. 	movl	K, %eax

  673. #elif (defined(LEFT) && !defined(TRANSA)) || (!defined(LEFT) && defined(TRANSA))

  674. 	movl	K, %eax

  675. 	subl	KK, %eax

  676. 	movl	%eax, KKK

  677. #else

  678. 	movl	KK, %eax

  679. #ifdef LEFT

  680. 	addl	$1, %eax

  681. #else

  682. 	addl	$1, %eax

  683. #endif

  684. 	movl	%eax, KKK

  685. #endif

  686. 	fldz

  687. 	ALIGN_3

  688. 

  689. .L51:

  690. 	FLD	(%edx)

  691. 	FMUL	(%ecx)

  692. 	addl	$1 * SIZE,%edx

  693. 	addl	$1 * SIZE,%ecx

  694. 	faddp	%st,%st(1)

  695. 	decl	%eax

  696. 	jne	.L51

  697. 

  698. 	FLD	ALPHA_I

  699. 	FLD	ALPHA_R

  700. 

  701. 	fmul	%st(2), %st

  702. 

  703. 	FLD	0 * SIZE(%edi)

  704. 	faddp	%st, %st(1)

  705. 	FST	0 * SIZE(%edi)

  706. 

  707. 	fmulp	%st, %st(1)

  708. 

  709. 	FLD	1 * SIZE(%edi)

  710. 	faddp	%st, %st(1)

  711. 	FST	1 * SIZE(%edi)

  712. 	ALIGN_4

  713. 

  714. .End:

  715. 	popl	%ebx

  716. 	popl	%esi

  717. 	popl	%edi

  718. 	popl	%ebp

  719. 	addl	$ARGS, %esp

  720. 	ret

  721. 

  722. 	EPILOGUE