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

数学计算

开发平台:

Unix_Linux

  1. dnl  SPARC mpn_add_n -- Add two limb vectors of the same length > 0 and store
  2. dnl  sum in a third limb vector.
  3. dnl  Copyright 1995, 1996, 2000 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 INPUT PARAMETERS
  17. define(res_ptr,%o0)
  18. define(s1_ptr,%o1)
  19. define(s2_ptr,%o2)
  20. define(n,%o3)
  21. ASM_START()
  22. PROLOGUE(mpn_add_n)
  23. xor s2_ptr,res_ptr,%g1
  24. andcc %g1,4,%g0
  25. bne L(1) C branch if alignment differs
  26. nop
  27. C **  V1a  **
  28. L(0): andcc res_ptr,4,%g0 C res_ptr unaligned? Side effect: cy=0
  29. be L(v1) C if no, branch
  30. nop
  31. C Add least significant limb separately to align res_ptr and s2_ptr
  32. ld [s1_ptr],%g4
  33. add s1_ptr,4,s1_ptr
  34. ld [s2_ptr],%g2
  35. add s2_ptr,4,s2_ptr
  36. add n,-1,n
  37. addcc %g4,%g2,%o4
  38. st %o4,[res_ptr]
  39. add res_ptr,4,res_ptr
  40. L(v1): addx %g0,%g0,%o4 C save cy in register
  41. cmp n,2 C if n < 2 ...
  42. bl L(end2) C ... branch to tail code
  43. subcc %g0,%o4,%g0 C restore cy
  44. ld [s1_ptr+0],%g4
  45. addcc n,-10,n
  46. ld [s1_ptr+4],%g1
  47. ldd [s2_ptr+0],%g2
  48. blt L(fin1)
  49. subcc %g0,%o4,%g0 C restore cy
  50. C Add blocks of 8 limbs until less than 8 limbs remain
  51. L(loop1):
  52. addxcc %g4,%g2,%o4
  53. ld [s1_ptr+8],%g4
  54. addxcc %g1,%g3,%o5
  55. ld [s1_ptr+12],%g1
  56. ldd [s2_ptr+8],%g2
  57. std %o4,[res_ptr+0]
  58. addxcc %g4,%g2,%o4
  59. ld [s1_ptr+16],%g4
  60. addxcc %g1,%g3,%o5
  61. ld [s1_ptr+20],%g1
  62. ldd [s2_ptr+16],%g2
  63. std %o4,[res_ptr+8]
  64. addxcc %g4,%g2,%o4
  65. ld [s1_ptr+24],%g4
  66. addxcc %g1,%g3,%o5
  67. ld [s1_ptr+28],%g1
  68. ldd [s2_ptr+24],%g2
  69. std %o4,[res_ptr+16]
  70. addxcc %g4,%g2,%o4
  71. ld [s1_ptr+32],%g4
  72. addxcc %g1,%g3,%o5
  73. ld [s1_ptr+36],%g1
  74. ldd [s2_ptr+32],%g2
  75. std %o4,[res_ptr+24]
  76. addx %g0,%g0,%o4 C save cy in register
  77. addcc n,-8,n
  78. add s1_ptr,32,s1_ptr
  79. add s2_ptr,32,s2_ptr
  80. add res_ptr,32,res_ptr
  81. bge L(loop1)
  82. subcc %g0,%o4,%g0 C restore cy
  83. L(fin1):
  84. addcc n,8-2,n
  85. blt L(end1)
  86. subcc %g0,%o4,%g0 C restore cy
  87. C Add blocks of 2 limbs until less than 2 limbs remain
  88. L(loope1):
  89. addxcc %g4,%g2,%o4
  90. ld [s1_ptr+8],%g4
  91. addxcc %g1,%g3,%o5
  92. ld [s1_ptr+12],%g1
  93. ldd [s2_ptr+8],%g2
  94. std %o4,[res_ptr+0]
  95. addx %g0,%g0,%o4 C save cy in register
  96. addcc n,-2,n
  97. add s1_ptr,8,s1_ptr
  98. add s2_ptr,8,s2_ptr
  99. add res_ptr,8,res_ptr
  100. bge L(loope1)
  101. subcc %g0,%o4,%g0 C restore cy
  102. L(end1):
  103. addxcc %g4,%g2,%o4
  104. addxcc %g1,%g3,%o5
  105. std %o4,[res_ptr+0]
  106. addx %g0,%g0,%o4 C save cy in register
  107. andcc n,1,%g0
  108. be L(ret1)
  109. subcc %g0,%o4,%g0 C restore cy
  110. C Add last limb
  111. ld [s1_ptr+8],%g4
  112. ld [s2_ptr+8],%g2
  113. addxcc %g4,%g2,%o4
  114. st %o4,[res_ptr+8]
  115. L(ret1):
  116. retl
  117. addx %g0,%g0,%o0 C return carry-out from most sign. limb
  118. L(1): xor s1_ptr,res_ptr,%g1
  119. andcc %g1,4,%g0
  120. bne L(2)
  121. nop
  122. C **  V1b  **
  123. mov s2_ptr,%g1
  124. mov s1_ptr,s2_ptr
  125. b L(0)
  126. mov %g1,s1_ptr
  127. C **  V2  **
  128. C If we come here, the alignment of s1_ptr and res_ptr as well as the
  129. C alignment of s2_ptr and res_ptr differ.  Since there are only two ways
  130. C things can be aligned (that we care about) we now know that the alignment
  131. C of s1_ptr and s2_ptr are the same.
  132. L(2): cmp n,1
  133. be L(jone)
  134. nop
  135. andcc s1_ptr,4,%g0 C s1_ptr unaligned? Side effect: cy=0
  136. be L(v2) C if no, branch
  137. nop
  138. C Add least significant limb separately to align s1_ptr and s2_ptr
  139. ld [s1_ptr],%g4
  140. add s1_ptr,4,s1_ptr
  141. ld [s2_ptr],%g2
  142. add s2_ptr,4,s2_ptr
  143. add n,-1,n
  144. addcc %g4,%g2,%o4
  145. st %o4,[res_ptr]
  146. add res_ptr,4,res_ptr
  147. L(v2): addx %g0,%g0,%o4 C save cy in register
  148. addcc n,-8,n
  149. blt L(fin2)
  150. subcc %g0,%o4,%g0 C restore cy
  151. C Add blocks of 8 limbs until less than 8 limbs remain
  152. L(loop2):
  153. ldd [s1_ptr+0],%g2
  154. ldd [s2_ptr+0],%o4
  155. addxcc %g2,%o4,%g2
  156. st %g2,[res_ptr+0]
  157. addxcc %g3,%o5,%g3
  158. st %g3,[res_ptr+4]
  159. ldd [s1_ptr+8],%g2
  160. ldd [s2_ptr+8],%o4
  161. addxcc %g2,%o4,%g2
  162. st %g2,[res_ptr+8]
  163. addxcc %g3,%o5,%g3
  164. st %g3,[res_ptr+12]
  165. ldd [s1_ptr+16],%g2
  166. ldd [s2_ptr+16],%o4
  167. addxcc %g2,%o4,%g2
  168. st %g2,[res_ptr+16]
  169. addxcc %g3,%o5,%g3
  170. st %g3,[res_ptr+20]
  171. ldd [s1_ptr+24],%g2
  172. ldd [s2_ptr+24],%o4
  173. addxcc %g2,%o4,%g2
  174. st %g2,[res_ptr+24]
  175. addxcc %g3,%o5,%g3
  176. st %g3,[res_ptr+28]
  177. addx %g0,%g0,%o4 C save cy in register
  178. addcc n,-8,n
  179. add s1_ptr,32,s1_ptr
  180. add s2_ptr,32,s2_ptr
  181. add res_ptr,32,res_ptr
  182. bge L(loop2)
  183. subcc %g0,%o4,%g0 C restore cy
  184. L(fin2):
  185. addcc n,8-2,n
  186. blt L(end2)
  187. subcc %g0,%o4,%g0 C restore cy
  188. L(loope2):
  189. ldd [s1_ptr+0],%g2
  190. ldd [s2_ptr+0],%o4
  191. addxcc %g2,%o4,%g2
  192. st %g2,[res_ptr+0]
  193. addxcc %g3,%o5,%g3
  194. st %g3,[res_ptr+4]
  195. addx %g0,%g0,%o4 C save cy in register
  196. addcc n,-2,n
  197. add s1_ptr,8,s1_ptr
  198. add s2_ptr,8,s2_ptr
  199. add res_ptr,8,res_ptr
  200. bge L(loope2)
  201. subcc %g0,%o4,%g0 C restore cy
  202. L(end2):
  203. andcc n,1,%g0
  204. be L(ret2)
  205. subcc %g0,%o4,%g0 C restore cy
  206. C Add last limb
  207. L(jone):
  208. ld [s1_ptr],%g4
  209. ld [s2_ptr],%g2
  210. addxcc %g4,%g2,%o4
  211. st %o4,[res_ptr]
  212. L(ret2):
  213. retl
  214. addx %g0,%g0,%o0 C return carry-out from most sign. limb
  215. EPILOGUE(mpn_add_n)