![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to lshift.asm CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gmp / mpn / x86 / pentium / mmx|
Return to lshift.asm CVS log | Up to [local] / OpenXM_contrib / gmp / mpn / x86 / pentium / mmx |
1.1 ! maekawa 1: dnl Intel P5 mpn_lshift -- mpn left shift.
! 2: dnl
! 3: dnl P5: 1.75 cycles/limb.
! 4:
! 5:
! 6: dnl Copyright (C) 2000 Free Software Foundation, Inc.
! 7: dnl
! 8: dnl This file is part of the GNU MP Library.
! 9: dnl
! 10: dnl The GNU MP Library is free software; you can redistribute it and/or
! 11: dnl modify it under the terms of the GNU Lesser General Public License as
! 12: dnl published by the Free Software Foundation; either version 2.1 of the
! 13: dnl License, or (at your option) any later version.
! 14: dnl
! 15: dnl The GNU MP Library is distributed in the hope that it will be useful,
! 16: dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
! 17: dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
! 18: dnl Lesser General Public License for more details.
! 19: dnl
! 20: dnl You should have received a copy of the GNU Lesser General Public
! 21: dnl License along with the GNU MP Library; see the file COPYING.LIB. If
! 22: dnl not, write to the Free Software Foundation, Inc., 59 Temple Place -
! 23: dnl Suite 330, Boston, MA 02111-1307, USA.
! 24:
! 25:
! 26: include(`../config.m4')
! 27:
! 28:
! 29: C mp_limb_t mpn_lshift (mp_ptr dst, mp_srcptr src, mp_size_t size,
! 30: C unsigned shift);
! 31: C
! 32: C Shift src,size left by shift many bits and store the result in dst,size.
! 33: C Zeros are shifted in at the right. Return the bits shifted out at the
! 34: C left.
! 35: C
! 36: C The comments in mpn_rshift apply here too.
! 37:
! 38: defframe(PARAM_SHIFT,16)
! 39: defframe(PARAM_SIZE, 12)
! 40: defframe(PARAM_SRC, 8)
! 41: defframe(PARAM_DST, 4)
! 42: deflit(`FRAME',0)
! 43:
! 44: dnl minimum 5, because the unrolled loop can't handle less
! 45: deflit(UNROLL_THRESHOLD, 5)
! 46:
! 47: .text
! 48: ALIGN(8)
! 49:
! 50: PROLOGUE(mpn_lshift)
! 51:
! 52: pushl %ebx
! 53: pushl %edi
! 54: deflit(`FRAME',8)
! 55:
! 56: movl PARAM_SIZE, %eax
! 57: movl PARAM_DST, %edx
! 58:
! 59: movl PARAM_SRC, %ebx
! 60: movl PARAM_SHIFT, %ecx
! 61:
! 62: cmp $UNROLL_THRESHOLD, %eax
! 63: jae L(unroll)
! 64:
! 65: movl -4(%ebx,%eax,4), %edi C src high limb
! 66: decl %eax
! 67:
! 68: jnz L(simple)
! 69:
! 70: shldl( %cl, %edi, %eax) C eax was decremented to zero
! 71:
! 72: shll %cl, %edi
! 73:
! 74: movl %edi, (%edx) C dst low limb
! 75: popl %edi C risk of data cache bank clash
! 76:
! 77: popl %ebx
! 78:
! 79: ret
! 80:
! 81:
! 82: C -----------------------------------------------------------------------------
! 83: L(simple):
! 84: C eax size-1
! 85: C ebx src
! 86: C ecx shift
! 87: C edx dst
! 88: C esi
! 89: C edi
! 90: C ebp
! 91: deflit(`FRAME',8)
! 92:
! 93: movd (%ebx,%eax,4), %mm5 C src high limb
! 94:
! 95: movd %ecx, %mm6 C lshift
! 96: negl %ecx
! 97:
! 98: psllq %mm6, %mm5
! 99: addl $32, %ecx
! 100:
! 101: movd %ecx, %mm7
! 102: psrlq $32, %mm5 C retval
! 103:
! 104:
! 105: L(simple_top):
! 106: C eax counter, limbs, negative
! 107: C ebx src
! 108: C ecx
! 109: C edx dst
! 110: C esi
! 111: C edi
! 112: C
! 113: C mm0 scratch
! 114: C mm5 return value
! 115: C mm6 shift
! 116: C mm7 32-shift
! 117:
! 118: movq -4(%ebx,%eax,4), %mm0
! 119: decl %eax
! 120:
! 121: psrlq %mm7, %mm0
! 122:
! 123: C
! 124:
! 125: movd %mm0, 4(%edx,%eax,4)
! 126: jnz L(simple_top)
! 127:
! 128:
! 129: movd (%ebx), %mm0
! 130:
! 131: movd %mm5, %eax
! 132: psllq %mm6, %mm0
! 133:
! 134: popl %edi
! 135: popl %ebx
! 136:
! 137: movd %mm0, (%edx)
! 138:
! 139: emms
! 140:
! 141: ret
! 142:
! 143:
! 144: C -----------------------------------------------------------------------------
! 145: ALIGN(8)
! 146: L(unroll):
! 147: C eax size
! 148: C ebx src
! 149: C ecx shift
! 150: C edx dst
! 151: C esi
! 152: C edi
! 153: C ebp
! 154: deflit(`FRAME',8)
! 155:
! 156: movd -4(%ebx,%eax,4), %mm5 C src high limb
! 157: leal (%ebx,%eax,4), %edi
! 158:
! 159: movd %ecx, %mm6 C lshift
! 160: andl $4, %edi
! 161:
! 162: psllq %mm6, %mm5
! 163: jz L(start_src_aligned)
! 164:
! 165:
! 166: C src isn't aligned, process high limb separately (marked xxx) to
! 167: C make it so.
! 168: C
! 169: C source -8(ebx,%eax,4)
! 170: C |
! 171: C +-------+-------+-------+--
! 172: C | |
! 173: C +-------+-------+-------+--
! 174: C 0mod8 4mod8 0mod8
! 175: C
! 176: C dest
! 177: C -4(edx,%eax,4)
! 178: C |
! 179: C +-------+-------+--
! 180: C | xxx | |
! 181: C +-------+-------+--
! 182:
! 183: movq -8(%ebx,%eax,4), %mm0 C unaligned load
! 184:
! 185: psllq %mm6, %mm0
! 186: decl %eax
! 187:
! 188: psrlq $32, %mm0
! 189:
! 190: C
! 191:
! 192: movd %mm0, (%edx,%eax,4)
! 193: L(start_src_aligned):
! 194:
! 195: movq -8(%ebx,%eax,4), %mm1 C src high qword
! 196: leal (%edx,%eax,4), %edi
! 197:
! 198: andl $4, %edi
! 199: psrlq $32, %mm5 C return value
! 200:
! 201: movq -16(%ebx,%eax,4), %mm3 C src second highest qword
! 202: jz L(start_dst_aligned)
! 203:
! 204: C dst isn't aligned, subtract 4 to make it so, and pretend the shift
! 205: C is 32 bits extra. High limb of dst (marked xxx) handled here
! 206: C separately.
! 207: C
! 208: C source -8(ebx,%eax,4)
! 209: C |
! 210: C +-------+-------+--
! 211: C | mm1 |
! 212: C +-------+-------+--
! 213: C 0mod8 4mod8
! 214: C
! 215: C dest
! 216: C -4(edx,%eax,4)
! 217: C |
! 218: C +-------+-------+-------+--
! 219: C | xxx | |
! 220: C +-------+-------+-------+--
! 221: C 0mod8 4mod8 0mod8
! 222:
! 223: movq %mm1, %mm0
! 224: addl $32, %ecx C new shift
! 225:
! 226: psllq %mm6, %mm0
! 227:
! 228: movd %ecx, %mm6
! 229: psrlq $32, %mm0
! 230:
! 231: C wasted cycle here waiting for %mm0
! 232:
! 233: movd %mm0, -4(%edx,%eax,4)
! 234: subl $4, %edx
! 235: L(start_dst_aligned):
! 236:
! 237:
! 238: psllq %mm6, %mm1
! 239: negl %ecx C -shift
! 240:
! 241: addl $64, %ecx C 64-shift
! 242: movq %mm3, %mm2
! 243:
! 244: movd %ecx, %mm7
! 245: subl $8, %eax C size-8
! 246:
! 247: psrlq %mm7, %mm3
! 248:
! 249: por %mm1, %mm3 C mm3 ready to store
! 250: jc L(finish)
! 251:
! 252:
! 253: C The comments in mpn_rshift apply here too.
! 254:
! 255: ALIGN(8)
! 256: L(unroll_loop):
! 257: C eax counter, limbs
! 258: C ebx src
! 259: C ecx
! 260: C edx dst
! 261: C esi
! 262: C edi
! 263: C
! 264: C mm0
! 265: C mm1
! 266: C mm2 src qword from 48(%ebx,%eax,4)
! 267: C mm3 dst qword ready to store to 56(%edx,%eax,4)
! 268: C
! 269: C mm5 return value
! 270: C mm6 lshift
! 271: C mm7 rshift
! 272:
! 273: movq 8(%ebx,%eax,4), %mm0
! 274: psllq %mm6, %mm2
! 275:
! 276: movq %mm0, %mm1
! 277: psrlq %mm7, %mm0
! 278:
! 279: movq %mm3, 24(%edx,%eax,4) C prev
! 280: por %mm2, %mm0
! 281:
! 282: movq (%ebx,%eax,4), %mm3 C
! 283: psllq %mm6, %mm1 C
! 284:
! 285: movq %mm0, 16(%edx,%eax,4)
! 286: movq %mm3, %mm2 C
! 287:
! 288: psrlq %mm7, %mm3 C
! 289: subl $4, %eax
! 290:
! 291: por %mm1, %mm3 C
! 292: jnc L(unroll_loop)
! 293:
! 294:
! 295:
! 296: L(finish):
! 297: C eax -4 to -1 representing respectively 0 to 3 limbs remaining
! 298:
! 299: testb $2, %al
! 300:
! 301: jz L(finish_no_two)
! 302:
! 303: movq 8(%ebx,%eax,4), %mm0
! 304: psllq %mm6, %mm2
! 305:
! 306: movq %mm0, %mm1
! 307: psrlq %mm7, %mm0
! 308:
! 309: movq %mm3, 24(%edx,%eax,4) C prev
! 310: por %mm2, %mm0
! 311:
! 312: movq %mm1, %mm2
! 313: movq %mm0, %mm3
! 314:
! 315: subl $2, %eax
! 316: L(finish_no_two):
! 317:
! 318:
! 319: C eax -4 or -3 representing respectively 0 or 1 limbs remaining
! 320: C
! 321: C mm2 src prev qword, from 48(%ebx,%eax,4)
! 322: C mm3 dst qword, for 56(%edx,%eax,4)
! 323:
! 324: testb $1, %al
! 325: movd %mm5, %eax C retval
! 326:
! 327: popl %edi
! 328: jz L(finish_zero)
! 329:
! 330:
! 331: C One extra src limb, destination was aligned.
! 332: C
! 333: C source ebx
! 334: C --+---------------+-------+
! 335: C | mm2 | |
! 336: C --+---------------+-------+
! 337: C
! 338: C dest edx+12 edx+4 edx
! 339: C --+---------------+---------------+-------+
! 340: C | mm3 | | |
! 341: C --+---------------+---------------+-------+
! 342: C
! 343: C mm6 = shift
! 344: C mm7 = ecx = 64-shift
! 345:
! 346:
! 347: C One extra src limb, destination was unaligned.
! 348: C
! 349: C source ebx
! 350: C --+---------------+-------+
! 351: C | mm2 | |
! 352: C --+---------------+-------+
! 353: C
! 354: C dest edx+12 edx+4
! 355: C --+---------------+---------------+
! 356: C | mm3 | |
! 357: C --+---------------+---------------+
! 358: C
! 359: C mm6 = shift+32
! 360: C mm7 = ecx = 64-(shift+32)
! 361:
! 362:
! 363: C In both cases there's one extra limb of src to fetch and combine
! 364: C with mm2 to make a qword at 4(%edx), and in the aligned case
! 365: C there's an extra limb of dst to be formed from that extra src limb
! 366: C left shifted.
! 367:
! 368:
! 369: movd (%ebx), %mm0
! 370: psllq %mm6, %mm2
! 371:
! 372: movq %mm3, 12(%edx)
! 373: psllq $32, %mm0
! 374:
! 375: movq %mm0, %mm1
! 376: psrlq %mm7, %mm0
! 377:
! 378: por %mm2, %mm0
! 379: psllq %mm6, %mm1
! 380:
! 381: movq %mm0, 4(%edx)
! 382: psrlq $32, %mm1
! 383:
! 384: andl $32, %ecx
! 385: popl %ebx
! 386:
! 387: jz L(finish_one_unaligned)
! 388:
! 389: movd %mm1, (%edx)
! 390: L(finish_one_unaligned):
! 391:
! 392: emms
! 393:
! 394: ret
! 395:
! 396:
! 397: L(finish_zero):
! 398:
! 399: C No extra src limbs, destination was aligned.
! 400: C
! 401: C source ebx
! 402: C --+---------------+
! 403: C | mm2 |
! 404: C --+---------------+
! 405: C
! 406: C dest edx+8 edx
! 407: C --+---------------+---------------+
! 408: C | mm3 | |
! 409: C --+---------------+---------------+
! 410: C
! 411: C mm6 = shift
! 412: C mm7 = ecx = 64-shift
! 413:
! 414:
! 415: C No extra src limbs, destination was unaligned.
! 416: C
! 417: C source ebx
! 418: C --+---------------+
! 419: C | mm2 |
! 420: C --+---------------+
! 421: C
! 422: C dest edx+8 edx+4
! 423: C --+---------------+-------+
! 424: C | mm3 | |
! 425: C --+---------------+-------+
! 426: C
! 427: C mm6 = shift+32
! 428: C mm7 = ecx = 64-(shift+32)
! 429:
! 430:
! 431: C The movd for the unaligned case writes the same data to 4(%edx)
! 432: C that the movq does for the aligned case.
! 433:
! 434:
! 435: movq %mm3, 8(%edx)
! 436: andl $32, %ecx
! 437:
! 438: psllq %mm6, %mm2
! 439: jz L(finish_zero_unaligned)
! 440:
! 441: movq %mm2, (%edx)
! 442: L(finish_zero_unaligned):
! 443:
! 444: psrlq $32, %mm2
! 445: popl %ebx
! 446:
! 447: movd %mm5, %eax C retval
! 448:
! 449: movd %mm2, 4(%edx)
! 450:
! 451: emms
! 452:
! 453: ret
! 454:
! 455: EPILOGUE()