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

数学计算

开发平台:

Unix_Linux

  1. dnl  AMD64 mpn_mod_34lsub1 -- remainder modulo 2^48-1.
  2. dnl  Copyright 2000, 2001, 2002, 2004, 2005, 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 K8,K9:  1.0
  22. C K10:  1.12
  23. C P4:  3.25
  24. C P6-15 (Core2): 1.5
  25. C P6-28 (Atom):  2.5
  26. C INPUT PARAMETERS
  27. C up rdi
  28. C n rsi
  29. C mp_limb_t mpn_mod_34lsub1 (mp_srcptr up, mp_size_t n)
  30. C TODO
  31. C  * Apply the movzwl tricks to the x86/k7 code
  32. C  * Review feed-in and wind-down code.  In particular, try to avoid adc and
  33. C    sbb to placate Pentium4.
  34. C  * More unrolling and/or index addressing could bring time to under 1 c/l
  35. C    for Athlon64, approaching 0.67 c/l seems possible.
  36. C  * There are recurrencies on the carry registers (r8, r9, r10) that might
  37. C    be the limiting factor for the Pentium4 speed.  Splitting these into 6
  38. C    registers would help.
  39. C  * For ultimate Athlon64 performance, a sequence like this might be best.
  40. C    It should reach 0.5 c/l (limited by L1 cache bandwidth).
  41. C
  42. C add (%rdi), %rax
  43. C adc 8(%rdi), %rcx
  44. C adc 16(%rdi), %rdx
  45. C adc $0, %r8
  46. C add 24(%rdi), %rax
  47. C adc 32(%rdi), %rcx
  48. C adc 40(%rdi), %rdx
  49. C adc $0, %r8
  50. C ...
  51. ASM_START()
  52. TEXT
  53. ALIGN(32)
  54. PROLOGUE(mpn_mod_34lsub1)
  55. mov $0x0000FFFFFFFFFFFF, %r11
  56. sub $2, %rsi
  57. ja L(gt2)
  58. mov (%rdi), %rax
  59. nop
  60. jb L(1)
  61. mov 8(%rdi), %rsi
  62. mov %rax, %rdx
  63. shr $48, %rax C src[0] low
  64. and %r11, %rdx C src[0] high
  65. add %rdx, %rax
  66. mov %esi, %edx
  67. shr $32, %rsi C src[1] high
  68. add %rsi, %rax
  69. shl $16, %rdx C src[1] low
  70. add %rdx, %rax
  71. L(1): ret
  72. ALIGN(16)
  73. L(gt2): xor %eax, %eax
  74. xor %ecx, %ecx
  75. xor %edx, %edx
  76. xor %r8, %r8
  77. xor %r9, %r9
  78. xor %r10, %r10
  79. L(top): add (%rdi), %rax
  80. adc $0, %r10
  81. add 8(%rdi), %rcx
  82. adc $0, %r8
  83. add 16(%rdi), %rdx
  84. adc $0, %r9
  85. sub $3,%rsi
  86. jng L(end)
  87. add 24(%rdi), %rax
  88. adc $0, %r10
  89. add 32(%rdi), %rcx
  90. adc $0, %r8
  91. add 40(%rdi), %rdx
  92. lea 48(%rdi), %rdi
  93. adc $0, %r9
  94. sub $3,%rsi
  95. jg L(top)
  96. add $-24, %rdi
  97. L(end): add %r9, %rax
  98. adc %r10, %rcx
  99. adc %r8, %rdx
  100. inc %rsi
  101. mov $0x1, %r10d
  102. js L(combine)
  103. mov $0x10000, %r10d
  104. adc 24(%rdi), %rax
  105. dec %rsi
  106. js L(combine)
  107. adc 32(%rdi), %rcx
  108. mov $0x100000000, %r10
  109. L(combine):
  110. sbb %rsi, %rsi C carry
  111. mov %rax, %rdi C 0mod3
  112. shr $48, %rax C 0mod3 high
  113. and %r10, %rsi C carry masked
  114. and %r11, %rdi C 0mod3 low
  115. mov %ecx, %r10d C 1mod3
  116. add %rsi, %rax C apply carry
  117. shr $32, %rcx C 1mod3 high
  118. add %rdi, %rax C apply 0mod3 low
  119. movzwl %dx, %edi C 2mod3
  120. shl $16, %r10 C 1mod3 low
  121. add %rcx, %rax C apply 1mod3 high
  122. shr $16, %rdx C 2mod3 high
  123. add %r10, %rax C apply 1mod3 low
  124. shl $32, %rdi C 2mod3 low
  125. add %rdx, %rax C apply 2mod3 high
  126. add %rdi, %rax C apply 2mod3 low
  127. ret
  128. EPILOGUE()