diff options
Diffstat (limited to 'sysdeps/powerpc/powerpc64/power6/memset.S')
| -rw-r--r-- | sysdeps/powerpc/powerpc64/power6/memset.S | 395 |
1 files changed, 0 insertions, 395 deletions
diff --git a/sysdeps/powerpc/powerpc64/power6/memset.S b/sysdeps/powerpc/powerpc64/power6/memset.S deleted file mode 100644 index aee1c8eabb..0000000000 --- a/sysdeps/powerpc/powerpc64/power6/memset.S +++ /dev/null @@ -1,395 +0,0 @@ -/* Optimized 64-bit memset implementation for POWER6. - Copyright (C) 1997-2017 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, see - <http://www.gnu.org/licenses/>. */ - -#include <sysdep.h> - -/* __ptr_t [r3] memset (__ptr_t s [r3], int c [r4], size_t n [r5])); - Returns 's'. - - The memset is done in three sizes: byte (8 bits), word (32 bits), - cache line (256 bits). There is a special case for setting cache lines - to 0, to take advantage of the dcbz instruction. */ - -#ifndef MEMSET -# define MEMSET memset -#endif - .machine power6 -EALIGN (MEMSET, 7, 0) - CALL_MCOUNT 3 - -#define rTMP r0 -#define rRTN r3 /* Initial value of 1st argument. */ -#define rMEMP0 r3 /* Original value of 1st arg. */ -#define rCHR r4 /* Char to set in each byte. */ -#define rLEN r5 /* Length of region to set. */ -#define rMEMP r6 /* Address at which we are storing. */ -#define rALIGN r7 /* Number of bytes we are setting now (when aligning). */ -#define rMEMP2 r8 -#define rMEMP3 r9 /* Alt mem pointer. */ -L(_memset): -/* Take care of case for size <= 4. */ - cmpldi cr1, rLEN, 8 - andi. rALIGN, rMEMP0, 7 - mr rMEMP, rMEMP0 - ble cr1, L(small) - -/* Align to doubleword boundary. */ - cmpldi cr5, rLEN, 31 - insrdi rCHR, rCHR, 8, 48 /* Replicate byte to halfword. */ - beq+ L(aligned2) - mtcrf 0x01, rMEMP0 - subfic rALIGN, rALIGN, 8 - cror 28,30,31 /* Detect odd word aligned. */ - add rMEMP, rMEMP, rALIGN - sub rLEN, rLEN, rALIGN - insrdi rCHR, rCHR, 16, 32 /* Replicate halfword to word. */ - bt 29, L(g4) -/* Process the even word of doubleword. */ - bf+ 31, L(g2) - stb rCHR, 0(rMEMP0) - bt 30, L(g4x) -L(g2): - sth rCHR, -6(rMEMP) -L(g4x): - stw rCHR, -4(rMEMP) - b L(aligned) -/* Process the odd word of doubleword. */ -L(g4): - bf 28, L(g4x) /* If false, word aligned on odd word. */ - bf+ 31, L(g0) - stb rCHR, 0(rMEMP0) - bt 30, L(aligned) -L(g0): - sth rCHR, -2(rMEMP) - -/* Handle the case of size < 31. */ -L(aligned2): - insrdi rCHR, rCHR, 16, 32 /* Replicate halfword to word. */ -L(aligned): - mtcrf 0x01, rLEN - ble cr5, L(medium) -/* Align to 32-byte boundary. */ - andi. rALIGN, rMEMP, 0x18 - subfic rALIGN, rALIGN, 0x20 - insrdi rCHR, rCHR, 32, 0 /* Replicate word to double word. */ - beq L(caligned) - mtcrf 0x01, rALIGN - add rMEMP, rMEMP, rALIGN - sub rLEN, rLEN, rALIGN - cmplwi cr1, rALIGN, 0x10 - mr rMEMP2, rMEMP - bf 28, L(a1) - stdu rCHR, -8(rMEMP2) -L(a1): blt cr1, L(a2) - std rCHR, -8(rMEMP2) - stdu rCHR, -16(rMEMP2) -L(a2): - -/* Now aligned to a 32 byte boundary. */ - .align 4 -L(caligned): - cmpldi cr1, rCHR, 0 - clrrdi. rALIGN, rLEN, 5 - mtcrf 0x01, rLEN - beq cr1, L(zloopstart) /* Special case for clearing memory using dcbz. */ - beq L(medium) /* We may not actually get to do a full line. */ - .align 4 -/* Storing a non-zero "c" value. We are aligned at a sector (32-byte) - boundary may not be at cache line (128-byte) boundary. */ -L(nzloopstart): -/* memset in 32-byte chunks until we get to a cache line boundary. - If rLEN is less than the distance to the next cache-line boundary use - cacheAligned1 code to finish the tail. */ - cmpldi cr1,rLEN,128 - - andi. rTMP,rMEMP,127 - blt cr1,L(cacheAligned1) - addi rMEMP3,rMEMP,32 - beq L(nzCacheAligned) - addi rLEN,rLEN,-32 - std rCHR,0(rMEMP) - std rCHR,8(rMEMP) - std rCHR,16(rMEMP) - addi rMEMP,rMEMP,32 - andi. rTMP,rMEMP3,127 - std rCHR,-8(rMEMP3) - - beq L(nzCacheAligned) - addi rLEN,rLEN,-32 - std rCHR,0(rMEMP3) - addi rMEMP,rMEMP,32 - std rCHR,8(rMEMP3) - andi. rTMP,rMEMP,127 - std rCHR,16(rMEMP3) - std rCHR,24(rMEMP3) - - beq L(nzCacheAligned) - addi rLEN,rLEN,-32 - std rCHR,32(rMEMP3) - addi rMEMP,rMEMP,32 - cmpldi cr1,rLEN,128 - std rCHR,40(rMEMP3) - cmpldi cr6,rLEN,256 - li rMEMP2,128 - std rCHR,48(rMEMP3) - std rCHR,56(rMEMP3) - blt cr1,L(cacheAligned1) - b L(nzCacheAligned128) - -/* Now we are aligned to the cache line and can use dcbtst. */ - .align 4 -L(nzCacheAligned): - cmpldi cr1,rLEN,128 - blt cr1,L(cacheAligned1) - b L(nzCacheAligned128) - .align 5 -L(nzCacheAligned128): - cmpldi cr1,rLEN,256 - addi rMEMP3,rMEMP,64 - std rCHR,0(rMEMP) - std rCHR,8(rMEMP) - std rCHR,16(rMEMP) - std rCHR,24(rMEMP) - std rCHR,32(rMEMP) - std rCHR,40(rMEMP) - std rCHR,48(rMEMP) - std rCHR,56(rMEMP) - addi rMEMP,rMEMP3,64 - addi rLEN,rLEN,-128 - std rCHR,0(rMEMP3) - std rCHR,8(rMEMP3) - std rCHR,16(rMEMP3) - std rCHR,24(rMEMP3) - std rCHR,32(rMEMP3) - std rCHR,40(rMEMP3) - std rCHR,48(rMEMP3) - std rCHR,56(rMEMP3) - bge cr1,L(nzCacheAligned128) - dcbtst 0,rMEMP - b L(cacheAligned1) - .align 5 -/* Storing a zero "c" value. We are aligned at a sector (32-byte) - boundary but may not be at cache line (128-byte) boundary. If the - remaining length spans a full cache line we can use the Data cache - block zero instruction. */ -L(zloopstart): -/* memset in 32-byte chunks until we get to a cache line boundary. - If rLEN is less than the distance to the next cache-line boundary use - cacheAligned1 code to finish the tail. */ - cmpldi cr1,rLEN,128 - beq L(medium) -L(getCacheAligned): - andi. rTMP,rMEMP,127 - nop - blt cr1,L(cacheAligned1) - addi rMEMP3,rMEMP,32 - beq L(cacheAligned) - addi rLEN,rLEN,-32 - std rCHR,0(rMEMP) - std rCHR,8(rMEMP) - std rCHR,16(rMEMP) - addi rMEMP,rMEMP,32 - andi. rTMP,rMEMP3,127 - std rCHR,-8(rMEMP3) -L(getCacheAligned2): - beq L(cacheAligned) - addi rLEN,rLEN,-32 - std rCHR,0(rMEMP3) - std rCHR,8(rMEMP3) - addi rMEMP,rMEMP,32 - andi. rTMP,rMEMP,127 - std rCHR,16(rMEMP3) - std rCHR,24(rMEMP3) -L(getCacheAligned3): - beq L(cacheAligned) - addi rLEN,rLEN,-32 - std rCHR,32(rMEMP3) - addi rMEMP,rMEMP,32 - cmpldi cr1,rLEN,128 - std rCHR,40(rMEMP3) - cmpldi cr6,rLEN,256 - li rMEMP2,128 - std rCHR,48(rMEMP3) - std rCHR,56(rMEMP3) - blt cr1,L(cacheAligned1) - blt cr6,L(cacheAligned128) - b L(cacheAlignedx) - -/* Now we are aligned to the cache line and can use dcbz. */ - .align 5 -L(cacheAligned): - cmpldi cr1,rLEN,128 - cmpldi cr6,rLEN,256 - blt cr1,L(cacheAligned1) - li rMEMP2,128 -L(cacheAlignedx): - cmpldi cr5,rLEN,640 - blt cr6,L(cacheAligned128) - bgt cr5,L(cacheAligned512) - cmpldi cr6,rLEN,512 - dcbz 0,rMEMP - cmpldi cr1,rLEN,384 - dcbz rMEMP2,rMEMP - addi rMEMP,rMEMP,256 - addi rLEN,rLEN,-256 - blt cr1,L(cacheAligned1) - blt cr6,L(cacheAligned128) - b L(cacheAligned256) - .align 5 -/* A simple loop for the longer (>640 bytes) lengths. This form limits - the branch miss-predicted to exactly 1 at loop exit.*/ -L(cacheAligned512): - cmpldi cr1,rLEN,128 - blt cr1,L(cacheAligned1) - dcbz 0,rMEMP - addi rLEN,rLEN,-128 - addi rMEMP,rMEMP,128 - b L(cacheAligned512) - .align 5 -L(cacheAligned256): - - cmpldi cr6,rLEN,512 - - dcbz 0,rMEMP - cmpldi cr1,rLEN,384 - dcbz rMEMP2,rMEMP - addi rMEMP,rMEMP,256 - addi rLEN,rLEN,-256 - - bge cr6,L(cacheAligned256) - - blt cr1,L(cacheAligned1) - .align 4 -L(cacheAligned128): - dcbz 0,rMEMP - addi rMEMP,rMEMP,128 - addi rLEN,rLEN,-128 - nop -L(cacheAligned1): - cmpldi cr1,rLEN,32 - blt cr1,L(handletail32) - addi rMEMP3,rMEMP,32 - addi rLEN,rLEN,-32 - std rCHR,0(rMEMP) - std rCHR,8(rMEMP) - std rCHR,16(rMEMP) - addi rMEMP,rMEMP,32 - cmpldi cr1,rLEN,32 - std rCHR,-8(rMEMP3) -L(cacheAligned2): - blt cr1,L(handletail32) - addi rLEN,rLEN,-32 - std rCHR,0(rMEMP3) - std rCHR,8(rMEMP3) - addi rMEMP,rMEMP,32 - cmpldi cr1,rLEN,32 - std rCHR,16(rMEMP3) - std rCHR,24(rMEMP3) - nop -L(cacheAligned3): - blt cr1,L(handletail32) - addi rMEMP,rMEMP,32 - addi rLEN,rLEN,-32 - std rCHR,32(rMEMP3) - std rCHR,40(rMEMP3) - std rCHR,48(rMEMP3) - std rCHR,56(rMEMP3) - -/* We are here because the length or remainder (rLEN) is less than the - cache line/sector size and does not justify aggressive loop unrolling. - So set up the preconditions for L(medium) and go there. */ - .align 3 -L(handletail32): - cmpldi cr1,rLEN,0 - beqlr cr1 - b L(medium) - - .align 5 -L(small): -/* Memset of 8 bytes or less. */ - cmpldi cr6, rLEN, 4 - cmpldi cr5, rLEN, 1 - ble cr6,L(le4) - subi rLEN, rLEN, 4 - stb rCHR,0(rMEMP) - stb rCHR,1(rMEMP) - stb rCHR,2(rMEMP) - stb rCHR,3(rMEMP) - addi rMEMP,rMEMP, 4 - cmpldi cr5, rLEN, 1 -L(le4): - cmpldi cr1, rLEN, 3 - bltlr cr5 - stb rCHR, 0(rMEMP) - beqlr cr5 - stb rCHR, 1(rMEMP) - bltlr cr1 - stb rCHR, 2(rMEMP) - beqlr cr1 - stb rCHR, 3(rMEMP) - blr - -/* Memset of 0-31 bytes. */ - .align 5 -L(medium): - insrdi rCHR, rCHR, 32, 0 /* Replicate word to double word. */ - cmpldi cr1, rLEN, 16 -L(medium_tail2): - add rMEMP, rMEMP, rLEN -L(medium_tail): - bt- 31, L(medium_31t) - bt- 30, L(medium_30t) -L(medium_30f): - bt 29, L(medium_29t) -L(medium_29f): - bge cr1, L(medium_27t) - bflr 28 - std rCHR, -8(rMEMP) - blr - -L(medium_31t): - stbu rCHR, -1(rMEMP) - bf- 30, L(medium_30f) -L(medium_30t): - sthu rCHR, -2(rMEMP) - bf- 29, L(medium_29f) -L(medium_29t): - stwu rCHR, -4(rMEMP) - blt cr1, L(medium_27f) -L(medium_27t): - std rCHR, -8(rMEMP) - stdu rCHR, -16(rMEMP) -L(medium_27f): - bflr 28 -L(medium_28t): - std rCHR, -8(rMEMP) - blr -END_GEN_TB (MEMSET,TB_TOCLESS) -libc_hidden_builtin_def (memset) - -/* Copied from bzero.S to prevent the linker from inserting a stub - between bzero and memset. */ -ENTRY (__bzero) - CALL_MCOUNT 3 - mr r5,r4 - li r4,0 - b L(_memset) -END (__bzero) -#ifndef __bzero -weak_alias (__bzero, bzero) -#endif |