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: 886cbaf4e4
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '886cbaf4e4'
${ noResults }
OpenBLAS/kernel/x86_64/gemm_kernel_4x2_atom.S

1386 lines
26 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 M	%rdi

  43. #define N	%rsi

  44. #define K	%rdx

  45. 

  46. #define A	%rcx

  47. #define B	%r8

  48. #define C	%r9

  49. #define LDC	%r10

  50. 

  51. #define I	%r11

  52. #define J	%r12

  53. #define AO	%r13

  54. #define BO	%r14

  55. #define	CO1	%r15

  56. #define CO2	%rbx

  57. #define BB	%rbp

  58. 

  59. #ifndef WINDOWS_ABI

  60. 

  61. #define STACKSIZE 128

  62. 

  63. #define OLD_LDC		 8 + STACKSIZE(%rsp)

  64. #define OLD_OFFSET	16 + STACKSIZE(%rsp)

  65. 

  66. #define ALPHA	 48(%rsp)

  67. #define OFFSET	 56(%rsp)

  68. #define KKK	 64(%rsp)

  69. #define KK	 72(%rsp)

  70. 

  71. #else

  72. 

  73. #define STACKSIZE 256

  74. 

  75. #define OLD_A		40 + STACKSIZE(%rsp)

  76. #define OLD_B		48 + STACKSIZE(%rsp)

  77. #define OLD_C		56 + STACKSIZE(%rsp)

  78. #define OLD_LDC		64 + STACKSIZE(%rsp)

  79. #define OLD_OFFSET	72 + STACKSIZE(%rsp)

  80. 

  81. #define ALPHA	 224(%rsp)

  82. #define OFFSET	 232(%rsp)

  83. #define KK	 240(%rsp)

  84. #define KKK	 248(%rsp)

  85. 

  86. #endif

  87. 

  88. #define PREFETCH     prefetcht0

  89. #define PREFETCHSIZE (8 * 8 + 3)

  90. 

  91. 	PROLOGUE

  92. 	PROFCODE

  93. 	

  94. 	subq	$STACKSIZE, %rsp

  95. 	movq	%rbx,  0(%rsp)

  96. 	movq	%rbp,  8(%rsp)

  97. 	movq	%r12, 16(%rsp)

  98. 	movq	%r13, 24(%rsp)

  99. 	movq	%r14, 32(%rsp)

  100. 	movq	%r15, 40(%rsp)

  101. 

  102. #ifdef WINDOWS_ABI

  103. 	movq	%rdi,    48(%rsp)

  104. 	movq	%rsi,    56(%rsp)

  105. 	movups	%xmm6,   64(%rsp)

  106. 	movups	%xmm7,   80(%rsp)

  107. 	movups	%xmm8,   96(%rsp)

  108. 	movups	%xmm9,  112(%rsp)

  109. 	movups	%xmm10, 128(%rsp)

  110. 	movups	%xmm11, 144(%rsp)

  111. 	movups	%xmm12, 160(%rsp)

  112. 	movups	%xmm13, 176(%rsp)

  113. 	movups	%xmm14, 192(%rsp)

  114. 	movups	%xmm15, 208(%rsp)

  115. 

  116. 	movq	ARG1,      M

  117. 	movq	ARG2,      N

  118. 	movq	ARG3,      K

  119. 	movq	OLD_A,     A

  120. 	movq	OLD_B,     B

  121. 	movq	OLD_C,     C

  122. 	movq	OLD_LDC,   LDC

  123. #ifdef TRMMKERNEL

  124. 	movsd	OLD_OFFSET, %xmm4

  125. #endif

  126. 	movaps	%xmm3, %xmm0

  127. 

  128. #else

  129. 	movq	OLD_LDC,   LDC

  130. #ifdef TRMMKERNEL

  131. 	movsd	OLD_OFFSET, %xmm4

  132. #endif

  133. 

  134. #endif

  135. 

  136. 	movsd	%xmm0, ALPHA

  137. 	

  138. #ifdef TRMMKERNEL

  139. 	movsd	%xmm4, OFFSET

  140. 	movsd	%xmm4, KK

  141. #ifndef LEFT

  142. 	negq	KK

  143. #endif	

  144. #endif

  145. 	

  146. 	leaq	(, LDC, SIZE), LDC

  147. 

  148. 	movq	N,  J

  149. 	sarq	$1, J

  150. 	jle	.L40

  151. 	ALIGN_4

  152. 	

  153. .L10:

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

  155. 	movq	OFFSET, %rax

  156. 	movq	%rax, KK

  157. #endif	

  158. 

  159. 	movq	C, CO1

  160. 	leaq	(C, LDC, 1), CO2

  161. 	leaq	(C, LDC, 2), C

  162. 

  163. 	movq	A, AO

  164. 

  165. 	movq	K, %rax

  166. 	salq	$BASE_SHIFT + 1, %rax

  167. 	leaq	(B, %rax), BB

  168. 	

  169. 	movq	M,  I

  170. 	sarq	$2, I

  171. 	jle	.L20

  172. 	ALIGN_4

  173. 

  174. .L11:

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

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

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

  178. 

  179. 	movq	B, BO

  180. #else

  181. 	movq	KK, %rax

  182. 	leaq	(, %rax, SIZE), %rax

  183. 	leaq	(AO, %rax, 4), AO

  184. 	leaq	(B,  %rax, 2), BO

  185. #endif	

  186. 

  187. 	prefetcht0	  0 * SIZE(BB)

  188. 	subq	   $-8 * SIZE, BB

  189. 

  190. 	movsd	 0 * SIZE(AO), %xmm0

  191. 	xorps	%xmm2,  %xmm2

  192. 	movsd	 1 * SIZE(AO), %xmm4

  193. 	xorps	%xmm5,  %xmm5

  194. 	movsd	 2 * SIZE(AO), %xmm5

  195. 	xorps	%xmm6,  %xmm6

  196. 	xorps	%xmm7,  %xmm7

  197. 

  198. 	movsd	 0 * SIZE(BO), %xmm1

  199. 	xorps	%xmm8,  %xmm8

  200. 	xorps	%xmm9,  %xmm9

  201. 	movsd	 1 * SIZE(BO), %xmm3

  202. 	xorps	%xmm10, %xmm10

  203. 	xorps	%xmm11, %xmm11

  204. 

  205. 	prefetcht0     3 * SIZE(CO1)

  206. 	xorps	%xmm12, %xmm12

  207. 	xorps	%xmm13, %xmm13

  208. 	prefetcht0     3 * SIZE(CO2)

  209. 	xorps	%xmm14, %xmm14

  210. 	xorps	%xmm15, %xmm15

  211. 

  212. #ifndef TRMMKERNEL

  213. 	movq	K, %rax

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

  215. 	movq	K, %rax

  216. 	subq	KK, %rax

  217. 	movq	%rax, KKK	

  218. #else

  219. 	movq	KK, %rax

  220. #ifdef LEFT

  221. 	addq	$4, %rax

  222. #else

  223. 	addq	$2, %rax

  224. #endif

  225. 	movq	%rax, KKK

  226. #endif

  227. 	sarq	$2, %rax

  228. 	je	.L15

  229. 	ALIGN_4

  230. 

  231. .L12:

  232. 	PREFETCH (PREFETCHSIZE + 0) * SIZE(AO)

  233. 	addsd	 %xmm2, %xmm13

  234. 	movaps	 %xmm0, %xmm2

  235. 	mulsd	 %xmm1, %xmm0

  236. 

  237. 	addsd	 %xmm7, %xmm14

  238. 	movsd	 3 * SIZE(AO), %xmm7

  239. 	mulsd	 %xmm3, %xmm2

  240.  

  241. 	addsd	 %xmm6, %xmm15

  242. 	movaps	 %xmm4, %xmm6

  243. 	mulsd	 %xmm1, %xmm4

  244. 

  245. 	addsd	 %xmm0, %xmm8

  246. 	movsd	 4 * SIZE(AO), %xmm0

  247. 	mulsd	 %xmm3, %xmm6

  248. 

  249. 	addsd	 %xmm2, %xmm9

  250. 	movaps	 %xmm5, %xmm2

  251. 	mulsd	 %xmm1, %xmm5

  252. 

  253. 	addsd	 %xmm4, %xmm10

  254. 	movsd	 5 * SIZE(AO), %xmm4

  255. 	mulsd	 %xmm3, %xmm2

  256. 

  257. 	addsd	 %xmm6, %xmm11

  258. 	movaps	 %xmm7, %xmm6

  259. 	mulsd	 %xmm1, %xmm7

  260. 	movsd	 2 * SIZE(BO), %xmm1

  261. 

  262. 	addsd	 %xmm5, %xmm12

  263. 	movsd	 6 * SIZE(AO), %xmm5

  264. 	mulsd	 %xmm3, %xmm6

  265. 	movsd	 3 * SIZE(BO), %xmm3

  266. 

  267. 	addsd	 %xmm2, %xmm13

  268. 	movaps	 %xmm0, %xmm2

  269. 	mulsd	 %xmm1, %xmm0

  270. 

  271. 	addsd	 %xmm7, %xmm14

  272. 	movsd	 7 * SIZE(AO), %xmm7

  273. 	mulsd	 %xmm3, %xmm2

  274. 

  275. 	addsd	 %xmm6, %xmm15

  276. 	movaps	 %xmm4, %xmm6

  277. 	mulsd	 %xmm1, %xmm4

  278. 

  279. 	addsd	 %xmm0, %xmm8

  280. 	movsd	 8 * SIZE(AO), %xmm0

  281. 	mulsd	 %xmm3, %xmm6

  282. 

  283. 	addsd	 %xmm2, %xmm9

  284. 	movaps	 %xmm5, %xmm2

  285. 	mulsd	 %xmm1, %xmm5

  286. 

  287. 	addsd	 %xmm4, %xmm10

  288. 	movsd	 9 * SIZE(AO), %xmm4

  289. 	mulsd	 %xmm3, %xmm2

  290. 

  291. 	addsd	 %xmm6, %xmm11

  292. 	movaps	 %xmm7, %xmm6

  293. 	mulsd	 %xmm1, %xmm7

  294. 	movsd	 4 * SIZE(BO), %xmm1

  295. 

  296. 	addsd	 %xmm5, %xmm12

  297. 	movsd	10 * SIZE(AO), %xmm5

  298. 	mulsd	 %xmm3, %xmm6

  299. 	movsd	 5 * SIZE(BO), %xmm3

  300. 

  301. 	addsd	 %xmm2, %xmm13

  302. 	PREFETCH (PREFETCHSIZE + 8) * SIZE(AO)

  303. 	movaps	 %xmm0, %xmm2

  304. 	mulsd	 %xmm1, %xmm0

  305. 

  306. 	addsd	 %xmm7, %xmm14

  307. 	movsd	11 * SIZE(AO), %xmm7

  308. 	mulsd	 %xmm3, %xmm2

  309. 

  310. 	addsd	 %xmm6, %xmm15

  311. 	movaps	 %xmm4, %xmm6

  312. 	mulsd	 %xmm1, %xmm4

  313. 

  314. 	addsd	 %xmm0, %xmm8

  315. 	movsd	12 * SIZE(AO), %xmm0

  316. 	mulsd	 %xmm3, %xmm6

  317. 

  318. 	addsd	 %xmm2, %xmm9

  319. 	movaps	 %xmm5, %xmm2

  320. 	mulsd	 %xmm1, %xmm5

  321. 

  322. 	addsd	 %xmm4, %xmm10

  323. 	movsd	13 * SIZE(AO), %xmm4

  324. 	mulsd	 %xmm3, %xmm2

  325. 

  326. 	addsd	 %xmm6, %xmm11

  327. 	movaps	 %xmm7, %xmm6

  328. 	mulsd	 %xmm1, %xmm7

  329. 	movsd	 6 * SIZE(BO), %xmm1

  330. 

  331. 	addsd	 %xmm5, %xmm12

  332. 	movsd	14 * SIZE(AO), %xmm5

  333. 	mulsd	 %xmm3, %xmm6

  334. 	movsd	 7 * SIZE(BO), %xmm3

  335. 

  336. 	addsd	 %xmm2, %xmm13

  337. 	movaps	 %xmm0, %xmm2

  338. 	mulsd	 %xmm1, %xmm0

  339. 

  340. 	addsd	 %xmm7, %xmm14

  341. 	movsd	15 * SIZE(AO), %xmm7

  342. 	mulsd	 %xmm3, %xmm2

  343. 	subq   $-16 * SIZE, AO

  344. 

  345. 	addsd	 %xmm6, %xmm15

  346. 	movaps	 %xmm4, %xmm6

  347. 	mulsd	 %xmm1, %xmm4

  348. 

  349. 	addsd	 %xmm0, %xmm8

  350. 	movsd	 0 * SIZE(AO), %xmm0

  351. 	mulsd	 %xmm3, %xmm6

  352. 

  353. 	addsd	 %xmm2, %xmm9

  354. 	movaps	 %xmm5, %xmm2

  355. 	mulsd	 %xmm1, %xmm5

  356. 	addq   $  8 * SIZE, BO

  357. 

  358. 	addsd	 %xmm4, %xmm10

  359. 	movsd	 1 * SIZE(AO), %xmm4

  360. 	mulsd	 %xmm3, %xmm2

  361. 	decq   %rax

  362. 

  363. 	addsd	 %xmm6, %xmm11

  364. 	movaps	 %xmm7, %xmm6

  365. 	mulsd	 %xmm1, %xmm7

  366. 	movsd	 0 * SIZE(BO), %xmm1

  367. 

  368. 	addsd	 %xmm5, %xmm12

  369. 	movsd	 2 * SIZE(AO), %xmm5

  370. 	mulsd	 %xmm3, %xmm6

  371. 	movsd	 1 * SIZE(BO), %xmm3

  372. 

  373. 	jne    .L12

  374. 	ALIGN_4

  375. 

  376. .L15:

  377. #ifndef TRMMKERNEL

  378. 	movq	K, %rax

  379. #else

  380. 	movq	KKK, %rax

  381. #endif

  382. 	andq	$3, %rax

  383. 	BRANCH

  384. 	BRANCH

  385. 	je	.L19

  386. 	ALIGN_4

  387. 

  388. .L16:

  389. 	addsd	 %xmm2, %xmm13

  390. 	movaps	 %xmm0, %xmm2

  391. 	mulsd	 %xmm1, %xmm0

  392. 

  393. 	addsd	 %xmm7, %xmm14

  394. 	movsd	 3 * SIZE(AO), %xmm7

  395. 	mulsd	 %xmm3, %xmm2

  396. 

  397. 	addsd	 %xmm6, %xmm15

  398. 	movaps	 %xmm4, %xmm6

  399. 	mulsd	 %xmm1, %xmm4

  400. 

  401. 	addsd	 %xmm0, %xmm8

  402. 	movsd	 4 * SIZE(AO), %xmm0

  403. 	mulsd	 %xmm3, %xmm6

  404. 

  405. 	addsd	 %xmm2, %xmm9

  406. 	movaps	 %xmm5, %xmm2

  407. 	mulsd	 %xmm1, %xmm5

  408. 

  409. 	addsd	 %xmm4, %xmm10

  410. 	movsd	 5 * SIZE(AO), %xmm4

  411. 	mulsd	 %xmm3, %xmm2

  412. 

  413. 	addsd	 %xmm6, %xmm11

  414. 	movaps	 %xmm7, %xmm6

  415. 	mulsd	 %xmm1, %xmm7

  416. 	movsd	 2 * SIZE(BO), %xmm1

  417. 

  418. 	addsd	 %xmm5, %xmm12

  419. 	movsd	 6 * SIZE(AO), %xmm5

  420. 	mulsd	 %xmm3, %xmm6

  421. 	movsd	 3 * SIZE(BO), %xmm3

  422. 

  423. 	addq	$4 * SIZE, AO

  424. 	addq	$2 * SIZE, BO

  425. 	decq	%rax

  426. 	BRANCH

  427. 	jg	.L16

  428. 	ALIGN_4

  429. 

  430. .L19:

  431. 	movsd	ALPHA, %xmm5

  432. 

  433. 	addsd	 %xmm2, %xmm13

  434. 	mulsd	%xmm5, %xmm8

  435. 	addsd	 %xmm7, %xmm14

  436. 	mulsd	%xmm5, %xmm10

  437. 	addsd	 %xmm6, %xmm15

  438. 	mulsd	%xmm5, %xmm12

  439. 	mulsd	%xmm5, %xmm14

  440. 

  441. 	mulsd	%xmm5, %xmm9

  442. 	mulsd	%xmm5, %xmm11

  443. 	mulsd	%xmm5, %xmm13

  444. 	mulsd	%xmm5, %xmm15

  445. 

  446. #if! defined(TRMMKERNEL) && !defined(BETAZERO)

  447. 	addsd	0 * SIZE(CO1), %xmm8

  448. 	addsd	1 * SIZE(CO1), %xmm10

  449. 	addsd	2 * SIZE(CO1), %xmm12

  450. 	addsd	3 * SIZE(CO1), %xmm14

  451. 

  452. 	addsd	0 * SIZE(CO2), %xmm9

  453. 	addsd	1 * SIZE(CO2), %xmm11

  454. 	addsd	2 * SIZE(CO2), %xmm13

  455. 	addsd	3 * SIZE(CO2), %xmm15

  456. #endif

  457. 

  458. 	movsd	%xmm8,  0 * SIZE(CO1)

  459. 	movsd	%xmm10, 1 * SIZE(CO1)

  460. 	movsd	%xmm12, 2 * SIZE(CO1)

  461. 	movsd	%xmm14, 3 * SIZE(CO1)

  462. 

  463. 	movsd	%xmm9,  0 * SIZE(CO2)

  464. 	movsd	%xmm11, 1 * SIZE(CO2)

  465. 	movsd	%xmm13, 2 * SIZE(CO2)

  466. 	movsd	%xmm15, 3 * SIZE(CO2)

  467. 

  468. #if (defined(TRMMKERNEL) &&  defined(LEFT) &&  defined(TRANSA)) || \

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

  470. 	movq	K, %rax

  471. 	subq	KKK, %rax

  472. 	leaq	(,%rax, SIZE), %rax

  473. 	leaq	(AO, %rax, 4), AO

  474. 	leaq	(BO, %rax, 2), BO

  475. #endif

  476. 

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

  478. 	addq	$4, KK

  479. #endif

  480. 

  481. 	addq	$4 * SIZE, CO1

  482. 	addq	$4 * SIZE, CO2

  483. 

  484. 	decq	I			# i --

  485. 	jg	.L11

  486. 	ALIGN_4

  487. 

  488. .L20:

  489. 	testq	$2, M

  490. 	jle	.L30

  491. 

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

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

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

  495. 

  496. 	movq	B, BO

  497. #else

  498. 	movq	KK, %rax

  499. 	leaq	(, %rax, SIZE), %rax

  500. 	leaq	(AO, %rax, 2), AO

  501. 	leaq	(B,  %rax, 2), BO

  502. #endif	

  503. 

  504. 	movsd	 0 * SIZE(AO), %xmm0

  505. 	xorps	%xmm2,  %xmm2

  506. 	movsd	 1 * SIZE(AO), %xmm4

  507. 	xorps	%xmm5,  %xmm5

  508. 	movsd	 2 * SIZE(AO), %xmm5

  509. 	xorps	%xmm6,  %xmm6

  510. 	movsd	 3 * SIZE(AO), %xmm7

  511. 

  512. 	movsd	 0 * SIZE(BO), %xmm1

  513. 	xorps	%xmm8,  %xmm8

  514. 	xorps	%xmm9,  %xmm9

  515. 	movsd	 1 * SIZE(BO), %xmm3

  516. 	xorps	%xmm10, %xmm10

  517. 	xorps	%xmm11, %xmm11

  518. 

  519. #ifndef TRMMKERNEL

  520. 	movq	K, %rax

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

  522. 	movq	K, %rax

  523. 	subq	KK, %rax

  524. 	movq	%rax, KKK	

  525. #else

  526. 	movq	KK, %rax

  527. #ifdef LEFT

  528. 	addq	$2, %rax

  529. #else

  530. 	addq	$2, %rax

  531. #endif

  532. 	movq	%rax, KKK

  533. #endif

  534. 

  535. 	sarq	$2, %rax

  536. 	je	.L25

  537. 	ALIGN_4

  538. 

  539. .L22:

  540. 	PREFETCH (PREFETCHSIZE + 0) * SIZE(AO)

  541. 	addsd	 %xmm2, %xmm9

  542. 	movaps	 %xmm0, %xmm2

  543. 	mulsd	 %xmm1, %xmm0

  544. 

  545. 	addsd	 %xmm6, %xmm11

  546. 	movaps	 %xmm4, %xmm6

  547. 	mulsd	 %xmm1, %xmm4

  548. 	movsd	 2 * SIZE(BO), %xmm1

  549. 

  550. 	addsd	 %xmm0, %xmm8

  551. 	movsd	 4 * SIZE(AO), %xmm0

  552. 	mulsd	 %xmm3, %xmm2

  553. 

  554. 	addsd	 %xmm4, %xmm10

  555. 	movsd	 5 * SIZE(AO), %xmm4

  556. 	mulsd	 %xmm3, %xmm6

  557. 	movsd	 3 * SIZE(BO), %xmm3

  558. 

  559. 	addsd	 %xmm2, %xmm9

  560. 	movaps	 %xmm5, %xmm2

  561. 	mulsd	 %xmm1, %xmm5

  562. 

  563. 	addsd	 %xmm6, %xmm11

  564. 	movaps	 %xmm7, %xmm6

  565. 	mulsd	 %xmm1, %xmm7

  566. 	movsd	 4 * SIZE(BO), %xmm1

  567. 

  568. 	addsd	 %xmm5, %xmm8

  569. 	movsd	 6 * SIZE(AO), %xmm5

  570. 	mulsd	 %xmm3, %xmm2

  571. 

  572. 	addsd	 %xmm7, %xmm10

  573. 	movsd	 7 * SIZE(AO), %xmm7

  574. 	mulsd	 %xmm3, %xmm6

  575. 	movsd	 5 * SIZE(BO), %xmm3

  576. 

  577. 	addsd	 %xmm2, %xmm9

  578. 	movaps	 %xmm0, %xmm2

  579. 	mulsd	 %xmm1, %xmm0

  580. 

  581. 	addsd	 %xmm6, %xmm11

  582. 	movaps	 %xmm4, %xmm6

  583. 	mulsd	 %xmm1, %xmm4

  584. 	movsd	 6 * SIZE(BO), %xmm1

  585. 

  586. 	addsd	 %xmm0, %xmm8

  587. 	movsd	 8 * SIZE(AO), %xmm0

  588. 	mulsd	 %xmm3, %xmm2

  589. 

  590. 	addsd	 %xmm4, %xmm10

  591. 	movsd	 9 * SIZE(AO), %xmm4

  592. 	mulsd	 %xmm3, %xmm6

  593. 	movsd	 7 * SIZE(BO), %xmm3

  594. 

  595. 	addsd	 %xmm2, %xmm9

  596. 	movaps	 %xmm5, %xmm2

  597. 	mulsd	 %xmm1, %xmm5

  598. 

  599. 	addsd	 %xmm6, %xmm11

  600. 	movaps	 %xmm7, %xmm6

  601. 	mulsd	 %xmm1, %xmm7

  602. 	movsd	 8 * SIZE(BO), %xmm1

  603. 

  604. 	addsd	 %xmm5, %xmm8

  605. 	movsd	10 * SIZE(AO), %xmm5

  606. 	mulsd	 %xmm3, %xmm2

  607. 

  608. 	addsd	 %xmm7, %xmm10

  609. 	movsd	11 * SIZE(AO), %xmm7

  610. 	mulsd	 %xmm3, %xmm6

  611. 	movsd	 9 * SIZE(BO), %xmm3

  612. 

  613. 	addq	$8 * SIZE, AO

  614. 	addq	$8 * SIZE, BO

  615. 

  616. 	decq	%rax

  617. 	jne    .L22

  618. 	ALIGN_4

  619. 

  620. .L25:

  621. #ifndef TRMMKERNEL

  622. 	movq	K, %rax

  623. #else

  624. 	movq	KKK, %rax

  625. #endif

  626. 	movsd	ALPHA, %xmm7

  627. 

  628. 	andq	$3, %rax

  629. 	BRANCH

  630. 	BRANCH

  631. 	je	.L29

  632. 	ALIGN_4

  633. 

  634. .L26:

  635. 	addsd	 %xmm2, %xmm9

  636. 	movaps	 %xmm0, %xmm2

  637. 	mulsd	 %xmm1, %xmm0

  638. 

  639. 	addsd	 %xmm6, %xmm11

  640. 	movaps	 %xmm4, %xmm6

  641. 	mulsd	 %xmm1, %xmm4

  642. 	movsd	 2 * SIZE(BO), %xmm1

  643. 

  644. 	mulsd	 %xmm3, %xmm2

  645. 	addsd	 %xmm0, %xmm8

  646. 	movsd	 2 * SIZE(AO), %xmm0

  647. 

  648. 	mulsd	 %xmm3, %xmm6

  649. 	movsd	 3 * SIZE(BO), %xmm3

  650. 	addsd	 %xmm4, %xmm10

  651. 	movsd	 3 * SIZE(AO), %xmm4

  652. 

  653. 	addq	$2 * SIZE, AO

  654. 	addq	$2 * SIZE, BO

  655. 	decq	%rax

  656. 	BRANCH

  657. 	jg	.L26

  658. 	ALIGN_4

  659. 

  660. .L29:

  661. 	addsd	 %xmm2, %xmm9

  662. 	mulsd	%xmm7, %xmm8

  663. 	addsd	 %xmm6, %xmm11

  664. 	mulsd	%xmm7, %xmm10

  665. 	mulsd	%xmm7, %xmm9

  666. 	mulsd	%xmm7, %xmm11

  667. 

  668. #if! defined(TRMMKERNEL) && !defined(BETAZERO)

  669. 	addsd	0 * SIZE(CO1), %xmm8

  670. 	addsd	1 * SIZE(CO1), %xmm10

  671. 

  672. 	addsd	0 * SIZE(CO2), %xmm9

  673. 	addsd	1 * SIZE(CO2), %xmm11

  674. #endif

  675. 

  676. 	movsd	%xmm8,  0 * SIZE(CO1)

  677. 	movsd	%xmm10, 1 * SIZE(CO1)

  678. 

  679. 	movsd	%xmm9,  0 * SIZE(CO2)

  680. 	movsd	%xmm11, 1 * SIZE(CO2)

  681. 

  682. #if (defined(TRMMKERNEL) &&  defined(LEFT) &&  defined(TRANSA)) || \

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

  684. 	movq	K, %rax

  685. 	subq	KKK, %rax

  686. 	leaq	(,%rax, SIZE), %rax

  687. 	leaq	(AO, %rax, 2), AO

  688. 	leaq	(BO, %rax, 2), BO

  689. #endif

  690. 

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

  692. 	addq	$2, KK

  693. #endif

  694. 

  695. 	addq	$2 * SIZE, CO1

  696. 	addq	$2 * SIZE, CO2

  697. 	ALIGN_4

  698. 

  699. .L30:

  700. 	testq	$1, M

  701. 	je	.L39

  702. 	ALIGN_4

  703. 

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

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

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

  707. 

  708. 	movq	B, BO

  709. #else

  710. 	movq	KK, %rax

  711. 	leaq	(, %rax, SIZE), %rax

  712. 	leaq	(AO, %rax, 1), AO

  713. 	leaq	(B,  %rax, 2), BO

  714. #endif	

  715. 

  716. 	movsd	 0 * SIZE(AO), %xmm0

  717. 	xorps	%xmm7,  %xmm7

  718. 	movsd	 1 * SIZE(AO), %xmm2

  719. 	xorps	%xmm5,  %xmm5

  720. 

  721. 	movsd	 0 * SIZE(BO), %xmm1

  722. 	xorps	%xmm8,  %xmm8

  723. 	xorps	%xmm9,  %xmm9

  724. 	movsd	 1 * SIZE(BO), %xmm3

  725. 

  726. #ifndef TRMMKERNEL

  727. 	movq	K, %rax

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

  729. 	movq	K, %rax

  730. 	subq	KK, %rax

  731. 	movq	%rax, KKK	

  732. #else

  733. 	movq	KK, %rax

  734. #ifdef LEFT

  735. 	addq	$1, %rax

  736. #else

  737. 	addq	$2, %rax

  738. #endif

  739. 	movq	%rax, KKK

  740. #endif

  741. 

  742. 	sarq	$2, %rax

  743. 	je	.L35

  744. 	ALIGN_4

  745. 

  746. .L32:

  747. 	addsd	 %xmm5, %xmm8

  748. 	movsd	 2 * SIZE(BO), %xmm5

  749. 	mulsd	 %xmm0, %xmm1

  750. 	PREFETCH (PREFETCHSIZE + 0) * SIZE(AO)

  751. 

  752. 	addsd	 %xmm7, %xmm9

  753. 	movsd	 3 * SIZE(BO), %xmm7

  754. 	mulsd	 %xmm0, %xmm3

  755. 	movsd	 2 * SIZE(AO), %xmm0

  756. 

  757. 	addsd	 %xmm1, %xmm8

  758. 	movsd	 4 * SIZE(BO), %xmm1

  759. 	mulsd	 %xmm2, %xmm5

  760. 

  761. 	addsd	 %xmm3, %xmm9

  762. 	movsd	 5 * SIZE(BO), %xmm3

  763. 	mulsd	 %xmm2, %xmm7

  764. 	movsd	 3 * SIZE(AO), %xmm2

  765. 

  766. 	addsd	 %xmm5, %xmm8

  767. 	movsd	 6 * SIZE(BO), %xmm5

  768. 	mulsd	 %xmm0, %xmm1

  769. 

  770. 	addsd	 %xmm7, %xmm9

  771. 	movsd	 7 * SIZE(BO), %xmm7

  772. 	mulsd	 %xmm0, %xmm3

  773. 	movsd	 4 * SIZE(AO), %xmm0

  774. 

  775. 	addsd	 %xmm1, %xmm8

  776. 	movsd	 8 * SIZE(BO), %xmm1

  777. 	mulsd	 %xmm2, %xmm5

  778. 

  779. 	addsd	 %xmm3, %xmm9

  780. 	movsd	 9 * SIZE(BO), %xmm3

  781. 	mulsd	 %xmm2, %xmm7

  782. 	movsd	 5 * SIZE(AO), %xmm2

  783. 

  784. 	addq	$4 * SIZE, AO

  785. 	addq	$8 * SIZE, BO

  786. 

  787. 	decq	%rax

  788. 	jne    .L32

  789. 	ALIGN_4

  790. 

  791. .L35:

  792. #ifndef TRMMKERNEL

  793. 	movq	K, %rax

  794. #else

  795. 	movq	KKK, %rax

  796. #endif

  797. 	addsd	 %xmm5, %xmm8

  798. 	addsd	 %xmm7, %xmm9

  799. 	movsd	ALPHA, %xmm7

  800. 

  801. 	andq	$3, %rax

  802. 	BRANCH

  803. 	BRANCH

  804. 	je	.L38

  805. 	ALIGN_4

  806. 

  807. .L36:

  808. 	mulsd	 %xmm0, %xmm1

  809. 	addq	$2 * SIZE, BO

  810. 	mulsd	 %xmm0, %xmm3

  811. 	movsd	 1 * SIZE(AO), %xmm0

  812. 

  813. 	addsd	 %xmm1, %xmm8

  814. 	movsd	 0 * SIZE(BO), %xmm1

  815. 	addsd	 %xmm3, %xmm9

  816. 	movsd	 1 * SIZE(BO), %xmm3

  817. 

  818. 	addq	$1 * SIZE, AO

  819. 	decq	%rax

  820. 	BRANCH

  821. 	jg	.L36

  822. 	ALIGN_4

  823. 

  824. .L38:

  825. 	mulsd	%xmm7, %xmm8

  826. 	mulsd	%xmm7, %xmm9

  827. 

  828. #if! defined(TRMMKERNEL) && !defined(BETAZERO)

  829. 	addsd	0 * SIZE(CO1), %xmm8

  830. 	addsd	0 * SIZE(CO2), %xmm9

  831. #endif

  832. 

  833. 	movsd	%xmm8,  0 * SIZE(CO1)

  834. 	movsd	%xmm9,  0 * SIZE(CO2)

  835. 

  836. #if (defined(TRMMKERNEL) &&  defined(LEFT) &&  defined(TRANSA)) || \

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

  838. 	movq	K, %rax

  839. 	subq	KKK, %rax

  840. 	leaq	(,%rax, SIZE), %rax

  841. 	leaq	(AO, %rax, 1), AO

  842. 	leaq	(BO, %rax, 2), BO

  843. #endif

  844. 

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

  846. 	addq	$1, KK

  847. #endif

  848. 	ALIGN_4

  849. 	

  850. .L39:

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

  852. 	addl	$2, KK

  853. #endif

  854. 

  855. 	movq	BO, B

  856. 	decq	J			# j --

  857. 	jg	.L10

  858. 	ALIGN_4

  859. 

  860. .L40:

  861. 	testq	$1, N

  862. 	je	.L999

  863. 

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

  865. 	movq	OFFSET, %rax

  866. 	movq	%rax, KK

  867. #endif	

  868. 

  869. 	movq	C, CO1

  870. 	addq	LDC, C

  871. 

  872. 	movq	A, AO

  873. 

  874. 	movq	M,  I

  875. 	sarq	$2, I

  876. 	jle	.L50

  877. 	ALIGN_4

  878. 

  879. .L41:

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

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

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

  883. 

  884. 	movq	B, BO

  885. #else

  886. 	movq	KK, %rax

  887. 	leaq	(, %rax, SIZE), %rax

  888. 	leaq	(AO, %rax, 4), AO

  889. 	leaq	(B,  %rax, 1), BO

  890. #endif	

  891. 

  892. 	movsd	 0 * SIZE(AO), %xmm0

  893. 	xorps	%xmm9,   %xmm9

  894. 	movsd	 1 * SIZE(AO), %xmm1

  895. 	xorps	%xmm11,  %xmm11

  896. 	movsd	 2 * SIZE(AO), %xmm2

  897. 	xorps	%xmm13,  %xmm13

  898. 	movsd	 3 * SIZE(AO), %xmm3

  899. 	xorps	%xmm15,  %xmm15

  900. 

  901. 	movsd	 0 * SIZE(BO), %xmm4

  902. 	xorps	%xmm8,  %xmm8

  903. 	movsd	 1 * SIZE(BO), %xmm5

  904. 	xorps	%xmm10, %xmm10

  905. 	prefetcht0     3 * SIZE(CO1)

  906. 	xorps	%xmm12, %xmm12

  907. 	xorps	%xmm14, %xmm14

  908. 

  909. #ifndef TRMMKERNEL

  910. 	movq	K, %rax

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

  912. 	movq	K, %rax

  913. 	subq	KK, %rax

  914. 	movq	%rax, KKK	

  915. #else

  916. 	movq	KK, %rax

  917. #ifdef LEFT

  918. 	addq	$4, %rax

  919. #else

  920. 	addq	$1, %rax

  921. #endif

  922. 	movq	%rax, KKK

  923. #endif

  924. 

  925. 	sarq	$2, %rax

  926. 	je	.L45

  927. 	ALIGN_4

  928. 

  929. .L42:

  930. 	addsd	 %xmm9,  %xmm8

  931. 	movsd	 4 * SIZE(AO), %xmm9

  932. 	mulsd	 %xmm4, %xmm0

  933. 	PREFETCH (PREFETCHSIZE + 0) * SIZE(AO)

  934. 

  935. 	addsd	 %xmm11, %xmm10

  936. 	movsd	 5 * SIZE(AO), %xmm11

  937. 	mulsd	 %xmm4, %xmm1

  938. 

  939. 	addsd	 %xmm13, %xmm12

  940. 	movsd	 6 * SIZE(AO), %xmm13

  941. 	mulsd	 %xmm4, %xmm2

  942. 

  943. 	addsd	 %xmm15, %xmm14

  944. 	movsd	 7 * SIZE(AO), %xmm15

  945. 	mulsd	 %xmm4, %xmm3

  946. 	movsd	 2 * SIZE(BO), %xmm4

  947. 

  948. 	addsd	 %xmm0, %xmm8

  949. 	movsd	 8 * SIZE(AO), %xmm0

  950. 	mulsd	 %xmm5, %xmm9

  951. 

  952. 	addsd	 %xmm1, %xmm10

  953. 	movsd	 9 * SIZE(AO), %xmm1

  954. 	mulsd	 %xmm5, %xmm11

  955. 

  956. 	addsd	 %xmm2, %xmm12

  957. 	movsd	10 * SIZE(AO), %xmm2

  958. 	mulsd	 %xmm5, %xmm13

  959. 

  960. 	addsd	 %xmm3, %xmm14

  961. 	movsd	11 * SIZE(AO), %xmm3

  962. 	mulsd	 %xmm5, %xmm15

  963. 	movsd	 3 * SIZE(BO), %xmm5

  964. 

  965. 	addsd	 %xmm9,  %xmm8

  966. 	movsd	12 * SIZE(AO), %xmm9

  967. 	mulsd	 %xmm4, %xmm0

  968. 	PREFETCH (PREFETCHSIZE + 8) * SIZE(AO)

  969. 

  970. 	addsd	 %xmm11, %xmm10

  971. 	movsd	13 * SIZE(AO), %xmm11

  972. 	mulsd	 %xmm4, %xmm1

  973. 

  974. 	addsd	 %xmm13, %xmm12

  975. 	movsd	14 * SIZE(AO), %xmm13

  976. 	mulsd	 %xmm4, %xmm2

  977. 

  978. 	addsd	 %xmm15, %xmm14

  979. 	movsd	15 * SIZE(AO), %xmm15

  980. 	mulsd	 %xmm4, %xmm3

  981. 	movsd	 4 * SIZE(BO), %xmm4

  982. 	subq	$-16 * SIZE, AO

  983. 

  984. 	addsd	 %xmm0, %xmm8

  985. 	movsd	 0 * SIZE(AO), %xmm0

  986. 	mulsd	 %xmm5, %xmm9

  987. 

  988. 	addsd	 %xmm1, %xmm10

  989. 	movsd	 1 * SIZE(AO), %xmm1

  990. 	mulsd	 %xmm5, %xmm11

  991. 	addq	$  4 * SIZE, BO

  992. 

  993. 	addsd	 %xmm2, %xmm12

  994. 	movsd	 2 * SIZE(AO), %xmm2

  995. 	mulsd	 %xmm5, %xmm13

  996. 	decq	%rax

  997. 

  998. 	addsd	 %xmm3, %xmm14

  999. 	movsd	 3 * SIZE(AO), %xmm3

  1000. 	mulsd	 %xmm5, %xmm15

  1001. 	movsd	 1 * SIZE(BO), %xmm5

  1002. 

  1003. 	jne    .L42

  1004. 	ALIGN_4

  1005. 

  1006. .L45:

  1007. #ifndef TRMMKERNEL

  1008. 	movq	K, %rax

  1009. #else

  1010. 	movq	KKK, %rax

  1011. #endif

  1012. 

  1013. 	movsd	ALPHA, %xmm7

  1014. 

  1015. 	addsd	 %xmm9,  %xmm8

  1016. 	addsd	 %xmm11, %xmm10

  1017. 	addsd	 %xmm13, %xmm12

  1018. 	addsd	 %xmm15, %xmm14

  1019. 

  1020. 	andq	$3, %rax

  1021. 	BRANCH

  1022. 	BRANCH

  1023. 	je	.L49

  1024. 	ALIGN_4

  1025. 

  1026. .L46:

  1027. 	mulsd	 %xmm4, %xmm0

  1028. 	mulsd	 %xmm4, %xmm1

  1029. 	mulsd	 %xmm4, %xmm2

  1030. 	mulsd	 %xmm4, %xmm3

  1031. 	movsd	 1 * SIZE(BO), %xmm4

  1032. 

  1033. 	addsd	 %xmm0, %xmm8

  1034. 	movsd	 4 * SIZE(AO), %xmm0

  1035. 	addsd	 %xmm1, %xmm10

  1036. 	movsd	 5 * SIZE(AO), %xmm1

  1037. 	addsd	 %xmm2, %xmm12

  1038. 	movsd	 6 * SIZE(AO), %xmm2

  1039. 	addsd	 %xmm3, %xmm14

  1040. 	movsd	 7 * SIZE(AO), %xmm3

  1041. 

  1042. 	addq	$4 * SIZE, AO

  1043. 	addq	$1 * SIZE, BO

  1044. 	decq	%rax

  1045. 	BRANCH

  1046. 	jg	.L46

  1047. 	ALIGN_4

  1048. 

  1049. .L49:

  1050. 	mulsd	%xmm7, %xmm8

  1051. 	mulsd	%xmm7, %xmm10

  1052. 	mulsd	%xmm7, %xmm12

  1053. 	mulsd	%xmm7, %xmm14

  1054. 

  1055. #if! defined(TRMMKERNEL) && !defined(BETAZERO)

  1056. 	addsd	0 * SIZE(CO1), %xmm8

  1057. 	addsd	1 * SIZE(CO1), %xmm10

  1058. 	addsd	2 * SIZE(CO1), %xmm12

  1059. 	addsd	3 * SIZE(CO1), %xmm14

  1060. #endif

  1061. 

  1062. 	movsd	%xmm8,  0 * SIZE(CO1)

  1063. 	movsd	%xmm10, 1 * SIZE(CO1)

  1064. 	movsd	%xmm12, 2 * SIZE(CO1)

  1065. 	movsd	%xmm14, 3 * SIZE(CO1)

  1066. 

  1067. #if (defined(TRMMKERNEL) &&  defined(LEFT) &&  defined(TRANSA)) || \

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

  1069. 	movq	K, %rax

  1070. 	subq	KKK, %rax

  1071. 	leaq	(,%rax, SIZE), %rax

  1072. 	leaq	(AO, %rax, 4), AO

  1073. 	leaq	(BO, %rax, 1), BO

  1074. #endif

  1075. 

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

  1077. 	addq	$4, KK

  1078. #endif

  1079. 

  1080. 	addq	$4 * SIZE, CO1

  1081. 

  1082. 	decq	I			# i --

  1083. 	jg	.L41

  1084. 	ALIGN_4

  1085. 

  1086. .L50:

  1087. 	testq	$2, M

  1088. 	jle	.L60

  1089. 

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

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

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

  1093. 

  1094. 	movq	B, BO

  1095. #else

  1096. 	movq	KK, %rax

  1097. 	leaq	(, %rax, SIZE), %rax

  1098. 	leaq	(AO, %rax, 2), AO

  1099. 	leaq	(B,  %rax, 1), BO

  1100. #endif	

  1101. 

  1102. 	movsd	 0 * SIZE(AO), %xmm0

  1103. 	xorps	%xmm2,   %xmm2

  1104. 	movsd	 1 * SIZE(AO), %xmm1

  1105. 	xorps	%xmm3,   %xmm3

  1106. 

  1107. 	movsd	 0 * SIZE(BO), %xmm4

  1108. 	xorps	%xmm8,  %xmm8

  1109. 	movsd	 1 * SIZE(BO), %xmm5

  1110. 	xorps	%xmm10, %xmm10

  1111. 

  1112. #ifndef TRMMKERNEL

  1113. 	movq	K, %rax

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

  1115. 	movq	K, %rax

  1116. 	subq	KK, %rax

  1117. 	movq	%rax, KKK	

  1118. #else

  1119. 	movq	KK, %rax

  1120. #ifdef LEFT

  1121. 	addq	$2, %rax

  1122. #else

  1123. 	addq	$1, %rax

  1124. #endif

  1125. 	movq	%rax, KKK

  1126. #endif

  1127. 

  1128. 	sarq	$2, %rax

  1129. 	je	.L55

  1130. 	ALIGN_4

  1131. 

  1132. .L52:

  1133. 	addsd	 %xmm2, %xmm8

  1134. 	movsd	 2 * SIZE(AO), %xmm2

  1135. 	mulsd	 %xmm4, %xmm0

  1136. 	PREFETCH (PREFETCHSIZE + 0) * SIZE(AO)

  1137. 

  1138. 	addsd	 %xmm3, %xmm10

  1139. 	movsd	 3 * SIZE(AO), %xmm3

  1140. 	mulsd	 %xmm4, %xmm1

  1141. 	movsd	 2 * SIZE(BO), %xmm4

  1142. 

  1143. 	addsd	 %xmm0, %xmm8

  1144. 	movsd	 4 * SIZE(AO), %xmm0

  1145. 	mulsd	 %xmm5, %xmm2

  1146. 	addq	$8 * SIZE, AO

  1147. 

  1148. 	addsd	 %xmm1, %xmm10

  1149. 	movsd	-3 * SIZE(AO), %xmm1

  1150. 	mulsd	 %xmm5, %xmm3

  1151. 	movsd	 3 * SIZE(BO), %xmm5

  1152. 

  1153. 	addsd	 %xmm2, %xmm8

  1154. 	movsd	-2 * SIZE(AO), %xmm2

  1155. 	mulsd	 %xmm4, %xmm0

  1156. 	addq	$4 * SIZE, BO

  1157. 

  1158. 	addsd	 %xmm3, %xmm10

  1159. 	movsd	-1 * SIZE(AO), %xmm3

  1160. 	mulsd	 %xmm4, %xmm1

  1161. 	movsd	 0 * SIZE(BO), %xmm4

  1162. 

  1163. 	addsd	 %xmm0, %xmm8

  1164. 	movsd	 0 * SIZE(AO), %xmm0

  1165. 	mulsd	 %xmm5, %xmm2

  1166. 	decq	%rax

  1167. 

  1168. 	addsd	 %xmm1, %xmm10

  1169. 	movsd	 1 * SIZE(AO), %xmm1

  1170. 	mulsd	 %xmm5, %xmm3

  1171. 	movsd	 1 * SIZE(BO), %xmm5

  1172. 

  1173. 	jne    .L52

  1174. 	ALIGN_4

  1175. 

  1176. .L55:

  1177. #ifndef TRMMKERNEL

  1178. 	movq	K, %rax

  1179. #else

  1180. 	movq	KKK, %rax

  1181. #endif

  1182. 	movsd	ALPHA, %xmm7

  1183. 

  1184. 	addsd	 %xmm2, %xmm8

  1185. 	addsd	 %xmm3, %xmm10

  1186. 

  1187. 	andq	$3, %rax

  1188. 	BRANCH

  1189. 	BRANCH

  1190. 	je	.L59

  1191. 	ALIGN_4

  1192. 

  1193. .L56:

  1194. 	mulsd	 %xmm4, %xmm0

  1195. 	mulsd	 %xmm4, %xmm1

  1196. 	movsd	 1 * SIZE(BO), %xmm4

  1197. 

  1198. 	addsd	 %xmm0, %xmm8

  1199. 	movsd	 2 * SIZE(AO), %xmm0

  1200. 	addsd	 %xmm1, %xmm10

  1201. 	movsd	 3 * SIZE(AO), %xmm1

  1202. 

  1203. 	addq	$2 * SIZE, AO

  1204. 	addq	$1 * SIZE, BO

  1205. 	decq	%rax

  1206. 	BRANCH

  1207. 	jg	.L56

  1208. 	ALIGN_4

  1209. 

  1210. .L59:

  1211. 	mulsd	%xmm7, %xmm8

  1212. 	mulsd	%xmm7, %xmm10

  1213. 

  1214. #if! defined(TRMMKERNEL) && !defined(BETAZERO)

  1215. 	addsd	0 * SIZE(CO1), %xmm8

  1216. 	addsd	1 * SIZE(CO1), %xmm10

  1217. #endif

  1218. 

  1219. 	movsd	%xmm8,  0 * SIZE(CO1)

  1220. 	movsd	%xmm10, 1 * SIZE(CO1)

  1221. 

  1222. #if (defined(TRMMKERNEL) &&  defined(LEFT) &&  defined(TRANSA)) || \

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

  1224. 	movq	K, %rax

  1225. 	subq	KKK, %rax

  1226. 	leaq	(,%rax, SIZE), %rax

  1227. 	leaq	(AO, %rax, 2), AO

  1228. 	leaq	(BO, %rax, 1), BO

  1229. #endif

  1230. 

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

  1232. 	addq	$2, KK

  1233. #endif

  1234. 

  1235. 	addq	$2 * SIZE, CO1

  1236. 	ALIGN_4

  1237. 

  1238. .L60:

  1239. 	testq	$1, M

  1240. 	je	.L999

  1241. 	ALIGN_4

  1242. 

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

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

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

  1246. 

  1247. 	movq	B, BO

  1248. #else

  1249. 	movq	KK, %rax

  1250. 	leaq	(, %rax, SIZE), %rax

  1251. 	leaq	(AO, %rax, 1), AO

  1252. 	leaq	(B,  %rax, 1), BO

  1253. #endif	

  1254. 

  1255. 	movsd	 0 * SIZE(AO), %xmm0

  1256. 	xorps	%xmm5,  %xmm5

  1257. 	movsd	 1 * SIZE(AO), %xmm2

  1258. 	xorps	%xmm7,  %xmm7

  1259. 

  1260. 	movsd	 0 * SIZE(BO), %xmm1

  1261. 	xorps	%xmm8,  %xmm8

  1262. 	movsd	 1 * SIZE(BO), %xmm3

  1263. 	xorps	%xmm9,  %xmm9

  1264. 	movsd	 2 * SIZE(AO), %xmm4

  1265. 	movsd	 3 * SIZE(AO), %xmm6

  1266. 

  1267. #ifndef TRMMKERNEL

  1268. 	movq	K, %rax

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

  1270. 	movq	K, %rax

  1271. 	subq	KK, %rax

  1272. 	movq	%rax, KKK	

  1273. #else

  1274. 	movq	KK, %rax

  1275. #ifdef LEFT

  1276. 	addq	$1, %rax

  1277. #else

  1278. 	addq	$1, %rax

  1279. #endif

  1280. 	movq	%rax, KKK

  1281. #endif

  1282. 

  1283. 	sarq	$2, %rax

  1284. 	je	.L65

  1285. 	ALIGN_4

  1286. 

  1287. .L62:

  1288. 	addsd	 %xmm5, %xmm8

  1289. 	movsd	 2 * SIZE(BO), %xmm5

  1290. 	mulsd	 %xmm0, %xmm1

  1291. 	movsd	 4 * SIZE(AO), %xmm0

  1292. 

  1293. 	addsd	 %xmm7, %xmm9

  1294. 	movsd	 3 * SIZE(BO), %xmm7

  1295. 	mulsd	 %xmm2, %xmm3

  1296. 	movsd	 5 * SIZE(AO), %xmm2

  1297. 

  1298. 	addsd	 %xmm1, %xmm8

  1299. 	movsd	 4 * SIZE(BO), %xmm1

  1300. 	mulsd	 %xmm4, %xmm5

  1301. 	movsd	 6 * SIZE(AO), %xmm4

  1302. 

  1303. 	addsd	 %xmm3, %xmm9

  1304. 	movsd	 5 * SIZE(BO), %xmm3

  1305. 	mulsd	 %xmm6, %xmm7

  1306. 	movsd	 7 * SIZE(AO), %xmm6

  1307. 

  1308. 	addq	$4 * SIZE, AO

  1309. 	addq	$4 * SIZE, BO

  1310. 

  1311. 	decq	%rax

  1312. 	jne    .L62

  1313. 

  1314. 	addsd	 %xmm5, %xmm8

  1315. 	addsd	 %xmm7, %xmm9

  1316. 	ALIGN_4

  1317. 

  1318. .L65:

  1319. #ifndef TRMMKERNEL

  1320. 	movq	K, %rax

  1321. #else

  1322. 	movq	KKK, %rax

  1323. #endif

  1324. 	movsd	ALPHA, %xmm7

  1325. 

  1326. 	andq	$3, %rax

  1327. 	BRANCH

  1328. 	BRANCH

  1329. 	je	.L68

  1330. 	ALIGN_4

  1331. 

  1332. .L66:

  1333. 	movsd	 0 * SIZE(AO), %xmm0

  1334. 	movsd	 0 * SIZE(BO), %xmm1

  1335. 

  1336. 	mulsd	 %xmm0, %xmm1

  1337. 	addsd	 %xmm1, %xmm8

  1338. 

  1339. 	addq	$1 * SIZE, AO

  1340. 	addq	$1 * SIZE, BO

  1341. 

  1342. 	decq	%rax

  1343. 	BRANCH

  1344. 	jg	.L66

  1345. 	ALIGN_4

  1346. 

  1347. .L68:

  1348. 	addsd	%xmm9, %xmm8

  1349. 

  1350. 	mulsd	%xmm7, %xmm8

  1351. 

  1352. #if! defined(TRMMKERNEL) && !defined(BETAZERO)

  1353. 	addsd	0 * SIZE(CO1), %xmm8

  1354. #endif

  1355. 

  1356. 	movsd	%xmm8,  0 * SIZE(CO1)

  1357. 	ALIGN_4

  1358. 	

  1359. .L999:

  1360. 	movq	  0(%rsp), %rbx

  1361. 	movq	  8(%rsp), %rbp

  1362. 	movq	 16(%rsp), %r12

  1363. 	movq	 24(%rsp), %r13

  1364. 	movq	 32(%rsp), %r14

  1365. 	movq	 40(%rsp), %r15

  1366. 

  1367. #ifdef WINDOWS_ABI

  1368. 	movq	 48(%rsp), %rdi

  1369. 	movq	 56(%rsp), %rsi

  1370. 	movups	 64(%rsp), %xmm6

  1371. 	movups	 80(%rsp), %xmm7

  1372. 	movups	 96(%rsp), %xmm8

  1373. 	movups	112(%rsp), %xmm9

  1374. 	movups	128(%rsp), %xmm10

  1375. 	movups	144(%rsp), %xmm11

  1376. 	movups	160(%rsp), %xmm12

  1377. 	movups	176(%rsp), %xmm13

  1378. 	movups	192(%rsp), %xmm14

  1379. 	movups	208(%rsp), %xmm15

  1380. #endif

  1381. 

  1382. 	addq	$STACKSIZE, %rsp

  1383. 	ret

  1384. 

  1385. 	EPILOGUE