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

数学计算

开发平台:

Unix_Linux

  1. dnl  x86 mpn_mul_basecase -- Multiply two limb vectors and store the result
  2. dnl  in a third limb vector.
  3. dnl  Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software
  4. dnl  Foundation, Inc.
  5. dnl
  6. dnl  This file is part of the GNU MP Library.
  7. dnl
  8. dnl  The GNU MP Library is free software; you can redistribute it and/or
  9. dnl  modify it under the terms of the GNU Lesser General Public License as
  10. dnl  published by the Free Software Foundation; either version 3 of the
  11. dnl  License, or (at your option) any later version.
  12. dnl
  13. dnl  The GNU MP Library is distributed in the hope that it will be useful,
  14. dnl  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. dnl  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16. dnl  Lesser General Public License for more details.
  17. dnl
  18. dnl  You should have received a copy of the GNU Lesser General Public License
  19. dnl  along with the GNU MP Library.  If not, see http://www.gnu.org/licenses/.
  20. include(`../config.m4')
  21. C     cycles/crossproduct
  22. C P5:     15
  23. C P6:      7.5
  24. C K6:     12.5
  25. C K7:      5.5
  26. C P4:     24
  27. C void mpn_mul_basecase (mp_ptr wp,
  28. C                        mp_srcptr xp, mp_size_t xsize,
  29. C                        mp_srcptr yp, mp_size_t ysize);
  30. C
  31. C This was written in a haste since the Pentium optimized code that was used
  32. C for all x86 machines was slow for the Pentium II.  This code would benefit
  33. C from some cleanup.
  34. C
  35. C To shave off some percentage of the run-time, one should make 4 variants
  36. C of the Louter loop, for the four different outcomes of un mod 4.  That
  37. C would avoid Loop0 altogether.  Code expansion would be > 4-fold for that
  38. C part of the function, but since it is not very large, that would be
  39. C acceptable.
  40. C
  41. C The mul loop (at L(oopM)) might need some tweaking.  It's current speed is
  42. C unknown.
  43. defframe(PARAM_YSIZE,20)
  44. defframe(PARAM_YP,   16)
  45. defframe(PARAM_XSIZE,12)
  46. defframe(PARAM_XP,   8)
  47. defframe(PARAM_WP,   4)
  48. defframe(VAR_MULTIPLIER, -4)
  49. defframe(VAR_COUNTER,    -8)
  50. deflit(VAR_STACK_SPACE,  8)
  51. TEXT
  52. ALIGN(8)
  53. PROLOGUE(mpn_mul_basecase)
  54. deflit(`FRAME',0)
  55. subl $VAR_STACK_SPACE,%esp
  56. pushl %esi
  57. pushl %ebp
  58. pushl %edi
  59. deflit(`FRAME',eval(VAR_STACK_SPACE+12))
  60. movl PARAM_XP,%esi
  61. movl PARAM_WP,%edi
  62. movl PARAM_YP,%ebp
  63. movl (%esi),%eax C load xp[0]
  64. mull (%ebp) C multiply by yp[0]
  65. movl %eax,(%edi) C store to wp[0]
  66. movl PARAM_XSIZE,%ecx C xsize
  67. decl %ecx C If xsize = 1, ysize = 1 too
  68. jz L(done)
  69. pushl %ebx
  70. FRAME_pushl()
  71. movl %edx,%ebx
  72. leal 4(%esi),%esi
  73. leal 4(%edi),%edi
  74. L(oopM):
  75. movl (%esi),%eax C load next limb at xp[j]
  76. leal 4(%esi),%esi
  77. mull (%ebp)
  78. addl %ebx,%eax
  79. movl %edx,%ebx
  80. adcl $0,%ebx
  81. movl %eax,(%edi)
  82. leal 4(%edi),%edi
  83. decl %ecx
  84. jnz L(oopM)
  85. movl %ebx,(%edi) C most significant limb of product
  86. addl $4,%edi C increment wp
  87. movl PARAM_XSIZE,%eax
  88. shll $2,%eax
  89. subl %eax,%edi
  90. subl %eax,%esi
  91. movl PARAM_YSIZE,%eax C ysize
  92. decl %eax
  93. jz L(skip)
  94. movl %eax,VAR_COUNTER C set index i to ysize
  95. L(outer):
  96. movl PARAM_YP,%ebp C yp
  97. addl $4,%ebp C make ebp point to next v limb
  98. movl %ebp,PARAM_YP
  99. movl (%ebp),%eax C copy y limb ...
  100. movl %eax,VAR_MULTIPLIER C ... to stack slot
  101. movl PARAM_XSIZE,%ecx
  102. xorl %ebx,%ebx
  103. andl $3,%ecx
  104. jz L(end0)
  105. L(oop0):
  106. movl (%esi),%eax
  107. mull VAR_MULTIPLIER
  108. leal 4(%esi),%esi
  109. addl %ebx,%eax
  110. movl $0,%ebx
  111. adcl %ebx,%edx
  112. addl %eax,(%edi)
  113. adcl %edx,%ebx C propagate carry into cylimb
  114. leal 4(%edi),%edi
  115. decl %ecx
  116. jnz L(oop0)
  117. L(end0):
  118. movl PARAM_XSIZE,%ecx
  119. shrl $2,%ecx
  120. jz L(endX)
  121. ALIGN(8)
  122. L(oopX):
  123. movl (%esi),%eax
  124. mull VAR_MULTIPLIER
  125. addl %eax,%ebx
  126. movl $0,%ebp
  127. adcl %edx,%ebp
  128. movl 4(%esi),%eax
  129. mull VAR_MULTIPLIER
  130. addl %ebx,(%edi)
  131. adcl %eax,%ebp C new lo + cylimb
  132. movl $0,%ebx
  133. adcl %edx,%ebx
  134. movl 8(%esi),%eax
  135. mull VAR_MULTIPLIER
  136. addl %ebp,4(%edi)
  137. adcl %eax,%ebx C new lo + cylimb
  138. movl $0,%ebp
  139. adcl %edx,%ebp
  140. movl 12(%esi),%eax
  141. mull VAR_MULTIPLIER
  142. addl %ebx,8(%edi)
  143. adcl %eax,%ebp C new lo + cylimb
  144. movl $0,%ebx
  145. adcl %edx,%ebx
  146. addl %ebp,12(%edi)
  147. adcl $0,%ebx C propagate carry into cylimb
  148. leal 16(%esi),%esi
  149. leal 16(%edi),%edi
  150. decl %ecx
  151. jnz L(oopX)
  152. L(endX):
  153. movl %ebx,(%edi)
  154. addl $4,%edi
  155. C we incremented wp and xp in the loop above; compensate
  156. movl PARAM_XSIZE,%eax
  157. shll $2,%eax
  158. subl %eax,%edi
  159. subl %eax,%esi
  160. movl VAR_COUNTER,%eax
  161. decl %eax
  162. movl %eax,VAR_COUNTER
  163. jnz L(outer)
  164. L(skip):
  165. popl %ebx
  166. popl %edi
  167. popl %ebp
  168. popl %esi
  169. addl $8,%esp
  170. ret
  171. L(done):
  172. movl %edx,4(%edi)    C store to wp[1]
  173. popl %edi
  174. popl %ebp
  175. popl %esi
  176. addl $8,%esp
  177. ret
  178. EPILOGUE()