addmul_1.asm
上传用户:qaz666999
上传日期:2022-08-06
资源大小:2570k
文件大小:7k
源码类别:

数学计算

开发平台:

Unix_Linux

  1. dnl  SPARC v9 32-bit mpn_addmul_1 -- Multiply a limb vector with a limb and add
  2. dnl  the result to a second limb vector.
  3. dnl  Copyright 1998, 2000, 2001, 2003 Free Software Foundation, Inc.
  4. dnl  This file is part of the GNU MP Library.
  5. dnl  The GNU MP Library is free software; you can redistribute it and/or modify
  6. dnl  it under the terms of the GNU Lesser General Public License as published
  7. dnl  by the Free Software Foundation; either version 3 of the License, or (at
  8. dnl  your option) any later version.
  9. dnl  The GNU MP Library is distributed in the hope that it will be useful, but
  10. dnl  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  11. dnl  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  12. dnl  License for more details.
  13. dnl  You should have received a copy of the GNU Lesser General Public License
  14. dnl  along with the GNU MP Library.  If not, see http://www.gnu.org/licenses/.
  15. include(`../config.m4')
  16. C Algorithm: We use two floating-point multiplies per limb product, with the
  17. C invariant v operand split into two 16-bit pieces, and the u operand split
  18. C into 32-bit pieces.  We convert the two 48-bit products and transfer them to
  19. C the integer unit.
  20. C    cycles/limb
  21. C UltraSPARC 1&2:     6.5
  22. C UltraSPARC 3:       ?
  23. C Possible optimizations:
  24. C   1. Combine 32-bit memory operations into 64-bit operations.  Since we're
  25. C      memory bandwidth limited, this could save 1.5 cycles/limb.
  26. C   2. Unroll the inner loop.  Since we already use alternate temporary areas,
  27. C      it is very straightforward to unroll, using an exit branch midways.
  28. C      Unrolling would allow deeper scheduling which could improve speed for L2
  29. C      cache case.
  30. C   3. For mpn_mul_1: Use more alternating temp areas.  The std'es and ldx'es
  31. C      aren't sufficiently apart-scheduled with just two temp areas.
  32. C   4. Specialize for particular v values.  If its upper 16 bits are zero, we
  33. C      could save many operations.
  34. C INPUT PARAMETERS
  35. C rp i0
  36. C up i1
  37. C n i2
  38. C v i3
  39. define(`FSIZE',224)
  40. ASM_START()
  41. PROLOGUE(mpn_addmul_1)
  42. add %sp, -FSIZE, %sp
  43. sethi %hi(0xffff), %g1
  44. srl %o3, 16, %g2
  45. or %g1, %lo(0xffff), %g1
  46. and %o3, %g1, %g1
  47. stx %g1, [%sp+104]
  48. stx %g2, [%sp+112]
  49. ldd [%sp+104], %f6
  50. ldd [%sp+112], %f8
  51. fxtod %f6, %f6
  52. fxtod %f8, %f8
  53. ld [%sp+104], %f10 C zero f10
  54. mov 0, %g3 C cy = 0
  55. define(`fanop', `fitod %f18, %f0') C  A quasi nop running in the FA pipe
  56. add %sp, 160, %o5 C point in scratch area
  57. and %o5, -32, %o5 C align at 0 (mod 32) in scratch area
  58. subcc %o2, 1, %o2
  59. ld [%o1], %f11 C read up[i]
  60. add %o1, 4, %o1 C up++
  61. bne,pt %icc, .L_two_or_more
  62. fxtod %f10, %f2
  63. fmuld %f2, %f8, %f16
  64. fmuld %f2, %f6, %f4
  65. fdtox %f16, %f14
  66. fdtox %f4, %f12
  67. std %f14, [%o5+16]
  68. std %f12, [%o5+24]
  69. ldx [%o5+16], %g2 C p16
  70. ldx [%o5+24], %g1 C p0
  71. lduw [%o0], %g5 C read rp[i]
  72. b .L1
  73. add %o0, -16, %o0
  74. .align 16
  75. .L_two_or_more:
  76. subcc %o2, 1, %o2
  77. ld [%o1], %f11 C read up[i]
  78. fmuld %f2, %f8, %f16
  79. fmuld %f2, %f6, %f4
  80. add %o1, 4, %o1 C up++
  81. bne,pt %icc, .L_three_or_more
  82. fxtod %f10, %f2
  83. fdtox %f16, %f14
  84. fdtox %f4, %f12
  85. std %f14, [%o5+16]
  86. fmuld %f2, %f8, %f16
  87. std %f12, [%o5+24]
  88. fmuld %f2, %f6, %f4
  89. fdtox %f16, %f14
  90. fdtox %f4, %f12
  91. std %f14, [%o5+0]
  92. std %f12, [%o5+8]
  93. lduw [%o0], %g5 C read rp[i]
  94. ldx [%o5+16], %g2 C p16
  95. ldx [%o5+24], %g1 C p0
  96. b .L2
  97. add %o0, -12, %o0
  98. .align 16
  99. .L_three_or_more:
  100. subcc %o2, 1, %o2
  101. ld [%o1], %f11 C read up[i]
  102. fdtox %f16, %f14
  103. fdtox %f4, %f12
  104. std %f14, [%o5+16]
  105. fmuld %f2, %f8, %f16
  106. std %f12, [%o5+24]
  107. fmuld %f2, %f6, %f4
  108. add %o1, 4, %o1 C up++
  109. bne,pt %icc, .L_four_or_more
  110. fxtod %f10, %f2
  111. fdtox %f16, %f14
  112. fdtox %f4, %f12
  113. std %f14, [%o5+0]
  114. fmuld %f2, %f8, %f16
  115. std %f12, [%o5+8]
  116. fmuld %f2, %f6, %f4
  117. fdtox %f16, %f14
  118. ldx [%o5+16], %g2 C p16
  119. fdtox %f4, %f12
  120. ldx [%o5+24], %g1 C p0
  121. std %f14, [%o5+16]
  122. std %f12, [%o5+24]
  123. lduw [%o0], %g5 C read rp[i]
  124. b .L3
  125. add %o0, -8, %o0
  126. .align 16
  127. .L_four_or_more:
  128. subcc %o2, 1, %o2
  129. ld [%o1], %f11 C read up[i]
  130. fdtox %f16, %f14
  131. fdtox %f4, %f12
  132. std %f14, [%o5+0]
  133. fmuld %f2, %f8, %f16
  134. std %f12, [%o5+8]
  135. fmuld %f2, %f6, %f4
  136. add %o1, 4, %o1 C up++
  137. bne,pt %icc, .L_five_or_more
  138. fxtod %f10, %f2
  139. fdtox %f16, %f14
  140. ldx [%o5+16], %g2 C p16
  141. fdtox %f4, %f12
  142. ldx [%o5+24], %g1 C p0
  143. std %f14, [%o5+16]
  144. fmuld %f2, %f8, %f16
  145. std %f12, [%o5+24]
  146. fmuld %f2, %f6, %f4
  147. add %o1, 4, %o1 C up++
  148. lduw [%o0], %g5 C read rp[i]
  149. b .L4
  150. add %o0, -4, %o0
  151. .align 16
  152. .L_five_or_more:
  153. subcc %o2, 1, %o2
  154. ld [%o1], %f11 C read up[i]
  155. fdtox %f16, %f14
  156. ldx [%o5+16], %g2 C p16
  157. fdtox %f4, %f12
  158. ldx [%o5+24], %g1 C p0
  159. std %f14, [%o5+16]
  160. fmuld %f2, %f8, %f16
  161. std %f12, [%o5+24]
  162. fmuld %f2, %f6, %f4
  163. add %o1, 4, %o1 C up++
  164. lduw [%o0], %g5 C read rp[i]
  165. bne,pt %icc, .Loop
  166. fxtod %f10, %f2
  167. b,a .L5
  168. C BEGIN MAIN LOOP
  169. .align 16
  170. C -- 0
  171. .Loop: nop
  172. subcc %o2, 1, %o2
  173. ld [%o1], %f11 C read up[i]
  174. fdtox %f16, %f14
  175. C -- 1
  176. sllx %g2, 16, %g4 C (p16 << 16)
  177. add %o0, 4, %o0 C rp++
  178. ldx [%o5+0], %g2 C p16
  179. fdtox %f4, %f12
  180. C -- 2
  181. nop
  182. add %g1, %g4, %g4 C p = p0 + (p16 << 16)
  183. ldx [%o5+8], %g1 C p0
  184. fanop
  185. C -- 3
  186. nop
  187. add %g3, %g4, %g4 C p += cy
  188. std %f14, [%o5+0]
  189. fmuld %f2, %f8, %f16
  190. C -- 4
  191. nop
  192. add %g5, %g4, %g4 C p += rp[i]
  193. std %f12, [%o5+8]
  194. fmuld %f2, %f6, %f4
  195. C -- 5
  196. xor %o5, 16, %o5 C alternate scratch variables
  197. add %o1, 4, %o1 C up++
  198. stw %g4, [%o0-4]
  199. fanop
  200. C -- 6
  201. srlx %g4, 32, %g3 C new cy
  202. lduw [%o0], %g5 C read rp[i]
  203. bne,pt %icc, .Loop
  204. fxtod %f10, %f2
  205. C END MAIN LOOP
  206. .L5: fdtox %f16, %f14
  207. sllx %g2, 16, %g4 C (p16 << 16)
  208. ldx [%o5+0], %g2 C p16
  209. fdtox %f4, %f12
  210. add %g1, %g4, %g4 C p = p0 + (p16 << 16)
  211. ldx [%o5+8], %g1 C p0
  212. add %g4, %g3, %g4 C p += cy
  213. std %f14, [%o5+0]
  214. fmuld %f2, %f8, %f16
  215. add %g5, %g4, %g4 C p += rp[i]
  216. std %f12, [%o5+8]
  217. fmuld %f2, %f6, %f4
  218. xor %o5, 16, %o5
  219. stw %g4, [%o0+0]
  220. srlx %g4, 32, %g3 C new cy
  221. lduw [%o0+4], %g5 C read rp[i]
  222. .L4: fdtox %f16, %f14
  223. sllx %g2, 16, %g4 C (p16 << 16)
  224. ldx [%o5+0], %g2 C p16
  225. fdtox %f4, %f12
  226. add %g1, %g4, %g4 C p = p0 + (p16 << 16)
  227. ldx [%o5+8], %g1 C p0
  228. add %g3, %g4, %g4 C p += cy
  229. std %f14, [%o5+0]
  230. add %g5, %g4, %g4 C p += rp[i]
  231. std %f12, [%o5+8]
  232. xor %o5, 16, %o5
  233. stw %g4, [%o0+4]
  234. srlx %g4, 32, %g3 C new cy
  235. lduw [%o0+8], %g5 C read rp[i]
  236. .L3: sllx %g2, 16, %g4 C (p16 << 16)
  237. ldx [%o5+0], %g2 C p16
  238. add %g1, %g4, %g4 C p = p0 + (p16 << 16)
  239. ldx [%o5+8], %g1 C p0
  240. add %g3, %g4, %g4 C p += cy
  241. add %g5, %g4, %g4 C p += rp[i]
  242. xor %o5, 16, %o5
  243. stw %g4, [%o0+8]
  244. srlx %g4, 32, %g3 C new cy
  245. lduw [%o0+12], %g5 C read rp[i]
  246. .L2: sllx %g2, 16, %g4 C (p16 << 16)
  247. ldx [%o5+0], %g2 C p16
  248. add %g1, %g4, %g4 C p = p0 + (p16 << 16)
  249. ldx [%o5+8], %g1 C p0
  250. add %g3, %g4, %g4 C p += cy
  251. add %g5, %g4, %g4 C p += rp[i]
  252. stw %g4, [%o0+12]
  253. srlx %g4, 32, %g3 C new cy
  254. lduw [%o0+16], %g5 C read rp[i]
  255. .L1: sllx %g2, 16, %g4 C (p16 << 16)
  256. add %g1, %g4, %g4 C p = p0 + (p16 << 16)
  257. add %g3, %g4, %g4 C p += cy
  258. add %g5, %g4, %g4 C p += rp[i]
  259. stw %g4, [%o0+16]
  260. srlx %g4, 32, %g3 C new cy
  261. mov %g3, %o0
  262. retl
  263. sub %sp, -FSIZE, %sp
  264. EPILOGUE(mpn_addmul_1)