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

数学计算

开发平台:

Unix_Linux

  1. dnl  x86 mpn_divrem_1 -- mpn by limb division extending to fractional quotient.
  2. dnl  Copyright 1999, 2000, 2001, 2002, 2003, 2007 Free Software Foundation,
  3. dnl  Inc.
  4. dnl
  5. dnl  This file is part of the GNU MP Library.
  6. dnl
  7. dnl  The GNU MP Library is free software; you can redistribute it and/or
  8. dnl  modify it under the terms of the GNU Lesser General Public License as
  9. dnl  published by the Free Software Foundation; either version 3 of the
  10. dnl  License, or (at your option) any later version.
  11. dnl
  12. dnl  The GNU MP Library is distributed in the hope that it will be useful,
  13. dnl  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. dnl  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15. dnl  Lesser General Public License for more details.
  16. dnl
  17. dnl  You should have received a copy of the GNU Lesser General Public License
  18. dnl  along with the GNU MP Library.  If not, see http://www.gnu.org/licenses/.
  19. include(`../config.m4')
  20. C       cycles/limb
  21. C 486   approx 43 maybe
  22. C P5        44
  23. C P6        39
  24. C P6MMX     39
  25. C K6        22
  26. C K7        42
  27. C P4        58
  28. C mp_limb_t mpn_divrem_1 (mp_ptr dst, mp_size_t xsize,
  29. C                         mp_srcptr src, mp_size_t size, mp_limb_t divisor);
  30. C mp_limb_t mpn_divrem_1c (mp_ptr dst, mp_size_t xsize,
  31. C                          mp_srcptr src, mp_size_t size, mp_limb_t divisor,
  32. C                          mp_limb_t carry);
  33. C
  34. C Divide src,size by divisor and store the quotient in dst+xsize,size.
  35. C Extend the division to fractional quotient limbs in dst,xsize.  Return the
  36. C remainder.  Either or both xsize and size can be 0.
  37. C
  38. C mpn_divrem_1c takes a carry parameter which is an initial high limb,
  39. C effectively one extra limb at the top of src,size.  Must have
  40. C carry<divisor.
  41. C
  42. C
  43. C Essentially the code is the same as the division based part of
  44. C mpn/generic/divrem_1.c, but has the advantage that we get the desired divl
  45. C instruction even when gcc is not being used (when longlong.h only has the
  46. C rather slow generic C udiv_qrnnd().
  47. C
  48. C A test is done to see if the high limb is less than the divisor, and if so
  49. C one less div is done.  A div is between 20 and 40 cycles on the various
  50. C x86s, so assuming high<divisor about half the time, then this test saves
  51. C half that amount.  The branch misprediction penalty on each chip is less
  52. C than half a div.
  53. C
  54. C
  55. C Notes for P5:
  56. C
  57. C It might be thought that moving the load down to pair with the store would
  58. C save 1 cycle, but that doesn't seem to happen in practice, and in any case
  59. C would be a mere 2.2% saving, so it's hardly worth bothering about.
  60. C
  61. C A mul-by-inverse might be a possibility for P5, as done in
  62. C mpn/x86/pentium/mod_1.asm.  The number of auxiliary instructions required
  63. C is a hinderance, but there could be a 10-15% speedup available.
  64. C
  65. C
  66. C Notes for K6:
  67. C
  68. C K6 has its own version of this code, using loop and paying attention to
  69. C cache line boundary crossings.  The target 20 c/l can be had with the
  70. C decl+jnz of the present code by pairing up the load and store in the
  71. C loops.  But it's considered easier not to introduce complexity just for
  72. C that, but instead let k6 have its own code.
  73. C
  74. defframe(PARAM_CARRY,  24)
  75. defframe(PARAM_DIVISOR,20)
  76. defframe(PARAM_SIZE,   16)
  77. defframe(PARAM_SRC,    12)
  78. defframe(PARAM_XSIZE,  8)
  79. defframe(PARAM_DST,    4)
  80. TEXT
  81. ALIGN(16)
  82. PROLOGUE(mpn_divrem_1c)
  83. deflit(`FRAME',0)
  84. movl PARAM_SIZE, %ecx
  85. pushl %edi FRAME_pushl()
  86. movl PARAM_SRC, %edi
  87. pushl %esi FRAME_pushl()
  88. movl PARAM_DIVISOR, %esi
  89. pushl %ebx FRAME_pushl()
  90. movl PARAM_DST, %ebx
  91. pushl %ebp FRAME_pushl()
  92. movl PARAM_XSIZE, %ebp
  93. orl %ecx, %ecx
  94. movl PARAM_CARRY, %edx
  95. jz L(fraction)
  96. leal -4(%ebx,%ebp,4), %ebx C dst one limb below integer part
  97. jmp L(integer_top)
  98. EPILOGUE()
  99. PROLOGUE(mpn_divrem_1)
  100. deflit(`FRAME',0)
  101. movl PARAM_SIZE, %ecx
  102. pushl %edi FRAME_pushl()
  103. movl PARAM_SRC, %edi
  104. pushl %esi FRAME_pushl()
  105. movl PARAM_DIVISOR, %esi
  106. orl %ecx,%ecx
  107. jz L(size_zero)
  108. pushl %ebx FRAME_pushl()
  109. movl -4(%edi,%ecx,4), %eax C src high limb
  110. xorl %edx, %edx
  111. movl PARAM_DST, %ebx
  112. pushl %ebp FRAME_pushl()
  113. movl PARAM_XSIZE, %ebp
  114. cmpl %esi, %eax
  115. leal -4(%ebx,%ebp,4), %ebx C dst one limb below integer part
  116. jae L(integer_entry)
  117. C high<divisor, so high of dst is zero, and avoid one div
  118. movl %edx, (%ebx,%ecx,4)
  119. decl %ecx
  120. movl %eax, %edx
  121. jz L(fraction)
  122. L(integer_top):
  123. C eax scratch (quotient)
  124. C ebx dst+4*xsize-4
  125. C ecx counter
  126. C edx scratch (remainder)
  127. C esi divisor
  128. C edi src
  129. C ebp xsize
  130. movl -4(%edi,%ecx,4), %eax
  131. L(integer_entry):
  132. divl %esi
  133. movl %eax, (%ebx,%ecx,4)
  134. decl %ecx
  135. jnz L(integer_top)
  136. L(fraction):
  137. orl %ebp, %ecx
  138. jz L(done)
  139. movl PARAM_DST, %ebx
  140. L(fraction_top):
  141. C eax scratch (quotient)
  142. C ebx dst
  143. C ecx counter
  144. C edx scratch (remainder)
  145. C esi divisor
  146. C edi
  147. C ebp
  148. xorl %eax, %eax
  149. divl %esi
  150. movl %eax, -4(%ebx,%ecx,4)
  151. decl %ecx
  152. jnz L(fraction_top)
  153. L(done):
  154. popl %ebp
  155. movl %edx, %eax
  156. popl %ebx
  157. popl %esi
  158. popl %edi
  159. ret
  160. L(size_zero):
  161. deflit(`FRAME',8)
  162. movl PARAM_XSIZE, %ecx
  163. xorl %eax, %eax
  164. movl PARAM_DST, %edi
  165. cld C better safe than sorry, see mpn/x86/README
  166. rep
  167. stosl
  168. popl %esi
  169. popl %edi
  170. ret
  171. EPILOGUE()