sysdeps/powerpc/powerpc32/memset.S

   1 /* Optimized memset implementation for PowerPC.
   2    Copyright (C) 1997-2013 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 #include <sysdep.h>
  20 #include <bp-sym.h>
  21 #include <bp-asm.h>
  22
  23 /* __ptr_t [r3] memset (__ptr_t s [r3], int c [r4], size_t n [r5]));
  24    Returns 's'.
  25
  26    The memset is done in four sizes: byte (8 bits), word (32 bits),
  27    32-byte blocks (256 bits) and __cache_line_size (128, 256, 1024 bits).
  28    There is a special case for setting whole cache lines to 0, which
  29    takes advantage of the dcbz instruction.  */
  30
  31         .section        ".text"
  32 EALIGN (BP_SYM (memset), 5, 1)
  33
  34 #define rTMP    r0
  35 #define rRTN    r3      /* initial value of 1st argument */
  36 #if __BOUNDED_POINTERS__
  37 # define rMEMP0 r4      /* original value of 1st arg */
  38 # define rCHR   r5      /* char to set in each byte */
  39 # define rLEN   r6      /* length of region to set */
  40 # define rMEMP  r10     /* address at which we are storing */
  41 #else
  42 # define rMEMP0 r3      /* original value of 1st arg */
  43 # define rCHR   r4      /* char to set in each byte */
  44 # define rLEN   r5      /* length of region to set */
  45 # define rMEMP  r6      /* address at which we are storing */
  46 #endif
  47 #define rALIGN  r7      /* number of bytes we are setting now (when aligning) */
  48 #define rMEMP2  r8
  49
  50 #define rPOS32  r7      /* constant +32 for clearing with dcbz */
  51 #define rNEG64  r8      /* constant -64 for clearing with dcbz */
  52 #define rNEG32  r9      /* constant -32 for clearing with dcbz */
  53
  54 #define rGOT    r9      /* Address of the Global Offset Table.  */
  55 #define rCLS    r8      /* Cache line size obtained from static.  */
  56 #define rCLM    r9      /* Cache line size mask to check for cache alignment.  */
  57
  58 #if __BOUNDED_POINTERS__
  59         cmplwi  cr1, rRTN, 0
  60         CHECK_BOUNDS_BOTH_WIDE (rMEMP0, rTMP, rTMP2, rLEN)
  61         beq     cr1, L(b0)
  62         STORE_RETURN_VALUE (rMEMP0)
  63         STORE_RETURN_BOUNDS (rTMP, rTMP2)
  64 L(b0):
  65 #endif
  66
  67 /* take care of case for size <= 4  */
  68         cmplwi  cr1, rLEN, 4
  69         andi.   rALIGN, rMEMP0, 3
  70         mr      rMEMP, rMEMP0
  71         ble-    cr1, L(small)
  72 /* align to word boundary  */
  73         cmplwi  cr5, rLEN, 31
  74         rlwimi  rCHR, rCHR, 8, 16, 23
  75         beq+    L(aligned)      /* 8th instruction from .align */
  76         mtcrf   0x01, rMEMP0
  77         subfic  rALIGN, rALIGN, 4
  78         add     rMEMP, rMEMP, rALIGN
  79         sub     rLEN, rLEN, rALIGN
  80         bf+     31, L(g0)
  81         stb     rCHR, 0(rMEMP0)
  82         bt      30, L(aligned)
  83 L(g0):  sth     rCHR, -2(rMEMP) /* 16th instruction from .align */
  84 /* take care of case for size < 31 */
  85 L(aligned):
  86         mtcrf   0x01, rLEN
  87         rlwimi  rCHR, rCHR, 16, 0, 15
  88         ble     cr5, L(medium)
  89 /* align to cache line boundary...  */
  90         andi.   rALIGN, rMEMP, 0x1C
  91         subfic  rALIGN, rALIGN, 0x20
  92         beq     L(caligned)
  93         mtcrf   0x01, rALIGN
  94         add     rMEMP, rMEMP, rALIGN
  95         sub     rLEN, rLEN, rALIGN
  96         cmplwi  cr1, rALIGN, 0x10
  97         mr      rMEMP2, rMEMP
  98         bf      28, L(a1)
  99         stw     rCHR, -4(rMEMP2)
 100         stwu    rCHR, -8(rMEMP2)
 101 L(a1):  blt     cr1, L(a2)
 102         stw     rCHR, -4(rMEMP2) /* 32nd instruction from .align */
 103         stw     rCHR, -8(rMEMP2)
 104         stw     rCHR, -12(rMEMP2)
 105         stwu    rCHR, -16(rMEMP2)
 106 L(a2):  bf      29, L(caligned)
 107         stw     rCHR, -4(rMEMP2)
 108 /* now aligned to a cache line.  */
 109 L(caligned):
 110         cmplwi  cr1, rCHR, 0
 111         clrrwi. rALIGN, rLEN, 5
 112         mtcrf   0x01, rLEN      /* 40th instruction from .align */
 113
 114 /* Check if we can use the special case for clearing memory using dcbz.
 115    This requires that we know the correct cache line size for this
 116    processor.  Getting the __cache_line_size may require establishing GOT
 117    addressability, so branch out of line to set this up.  */
 118         beq     cr1, L(checklinesize)
 119
 120 /* Store blocks of 32-bytes (256-bits) starting on a 32-byte boundary.
 121    Can't assume that rCHR is zero or that the cache line size is either
 122    32-bytes or even known.  */
 123 L(nondcbz):
 124         srwi    rTMP, rALIGN, 5
 125         mtctr   rTMP
 126         beq     L(medium)       /* we may not actually get to do a full line */
 127         clrlwi. rLEN, rLEN, 27
 128         add     rMEMP, rMEMP, rALIGN
 129         li      rNEG64, -0x40
 130         bdz     L(cloopdone)    /* 48th instruction from .align */
 131
 132 /* We can't use dcbz here as we don't know the cache line size.  We can
 133    use "data cache block touch for store", which is safe.  */
 134 L(c3):  dcbtst  rNEG64, rMEMP
 135         stw     rCHR, -4(rMEMP)
 136         stw     rCHR, -8(rMEMP)
 137         stw     rCHR, -12(rMEMP)
 138         stw     rCHR, -16(rMEMP)
 139         nop                     /* let 601 fetch last 4 instructions of loop */
 140         stw     rCHR, -20(rMEMP)
 141         stw     rCHR, -24(rMEMP) /* 56th instruction from .align */
 142         nop                     /* let 601 fetch first 8 instructions of loop */
 143         stw     rCHR, -28(rMEMP)
 144         stwu    rCHR, -32(rMEMP)
 145         bdnz    L(c3)
 146 L(cloopdone):
 147         stw     rCHR, -4(rMEMP)
 148         stw     rCHR, -8(rMEMP)
 149         stw     rCHR, -12(rMEMP)
 150         stw     rCHR, -16(rMEMP) /* 64th instruction from .align */
 151         stw     rCHR, -20(rMEMP)
 152         cmplwi  cr1, rLEN, 16
 153         stw     rCHR, -24(rMEMP)
 154         stw     rCHR, -28(rMEMP)
 155         stwu    rCHR, -32(rMEMP)
 156         beqlr
 157         add     rMEMP, rMEMP, rALIGN
 158         b       L(medium_tail2) /* 72nd instruction from .align */
 159
 160         .align  5
 161         nop
 162 /* Clear cache lines of memory in 128-byte chunks.
 163    This code is optimized for processors with 32-byte cache lines.
 164    It is further optimized for the 601 processor, which requires
 165    some care in how the code is aligned in the i-cache.  */
 166 L(zloopstart):
 167         clrlwi  rLEN, rLEN, 27
 168         mtcrf   0x02, rALIGN
 169         srwi.   rTMP, rALIGN, 7
 170         mtctr   rTMP
 171         li      rPOS32, 0x20
 172         li      rNEG64, -0x40
 173         cmplwi  cr1, rLEN, 16   /* 8 */
 174         bf      26, L(z0)
 175         dcbz    0, rMEMP
 176         addi    rMEMP, rMEMP, 0x20
 177 L(z0):  li      rNEG32, -0x20
 178         bf      25, L(z1)
 179         dcbz    0, rMEMP
 180         dcbz    rPOS32, rMEMP
 181         addi    rMEMP, rMEMP, 0x40 /* 16 */
 182 L(z1):  cmplwi  cr5, rLEN, 0
 183         beq     L(medium)
 184 L(zloop):
 185         dcbz    0, rMEMP
 186         dcbz    rPOS32, rMEMP
 187         addi    rMEMP, rMEMP, 0x80
 188         dcbz    rNEG64, rMEMP
 189         dcbz    rNEG32, rMEMP
 190         bdnz    L(zloop)
 191         beqlr   cr5
 192         b       L(medium_tail2)
 193
 194         .align  5
 195 L(small):
 196 /* Memset of 4 bytes or less.  */
 197         cmplwi  cr5, rLEN, 1
 198         cmplwi  cr1, rLEN, 3
 199         bltlr   cr5
 200         stb     rCHR, 0(rMEMP)
 201         beqlr   cr5
 202         nop
 203         stb     rCHR, 1(rMEMP)
 204         bltlr   cr1
 205         stb     rCHR, 2(rMEMP)
 206         beqlr   cr1
 207         nop
 208         stb     rCHR, 3(rMEMP)
 209         blr
 210
 211 /* Memset of 0-31 bytes.  */
 212         .align  5
 213 L(medium):
 214         cmplwi  cr1, rLEN, 16
 215 L(medium_tail2):
 216         add     rMEMP, rMEMP, rLEN
 217 L(medium_tail):
 218         bt-     31, L(medium_31t)
 219         bt-     30, L(medium_30t)
 220 L(medium_30f):
 221         bt-     29, L(medium_29t)
 222 L(medium_29f):
 223         bge-    cr1, L(medium_27t)
 224         bflr-   28
 225         stw     rCHR, -4(rMEMP) /* 8th instruction from .align */
 226         stw     rCHR, -8(rMEMP)
 227         blr
 228
 229 L(medium_31t):
 230         stbu    rCHR, -1(rMEMP)
 231         bf-     30, L(medium_30f)
 232 L(medium_30t):
 233         sthu    rCHR, -2(rMEMP)
 234         bf-     29, L(medium_29f)
 235 L(medium_29t):
 236         stwu    rCHR, -4(rMEMP)
 237         blt-    cr1, L(medium_27f) /* 16th instruction from .align */
 238 L(medium_27t):
 239         stw     rCHR, -4(rMEMP)
 240         stw     rCHR, -8(rMEMP)
 241         stw     rCHR, -12(rMEMP)
 242         stwu    rCHR, -16(rMEMP)
 243 L(medium_27f):
 244         bflr-   28
 245 L(medium_28t):
 246         stw     rCHR, -4(rMEMP)
 247         stw     rCHR, -8(rMEMP)
 248         blr
 249
 250 L(checklinesize):
 251 #ifdef SHARED
 252         mflr    rTMP
 253 /* If the remaining length is less the 32 bytes then don't bother getting
 254    the cache line size.  */
 255         beq     L(medium)
 256 /* Establishes GOT addressability so we can load __cache_line_size
 257    from static. This value was set from the aux vector during startup.  */
 258         SETUP_GOT_ACCESS(rGOT,got_label)
 259         addis   rGOT,rGOT,__cache_line_size-got_label@ha
 260         lwz     rCLS,__cache_line_size-got_label@l(rGOT)
 261         mtlr    rTMP
 262 #else
 263 /* Load __cache_line_size from static. This value was set from the
 264    aux vector during startup.  */
 265         lis     rCLS,__cache_line_size@ha
 266 /* If the remaining length is less the 32 bytes then don't bother getting
 267    the cache line size.  */
 268         beq     L(medium)
 269         lwz     rCLS,__cache_line_size@l(rCLS)
 270 #endif
 271
 272 /* If the cache line size was not set then goto to L(nondcbz), which is
 273    safe for any cache line size.  */
 274         cmplwi  cr1,rCLS,0
 275         beq     cr1,L(nondcbz)
 276
 277 /* If the cache line size is 32 bytes then goto to L(zloopstart),
 278    which is coded specifically for 32-byte lines (and 601).  */
 279         cmplwi  cr1,rCLS,32
 280         beq     cr1,L(zloopstart)
 281
 282 /* Now we know the cache line size and it is not 32-bytes.  However
 283    we may not yet be aligned to the cache line and may have a partial
 284    line to fill.  Touch it 1st to fetch the cache line.  */
 285         dcbtst  0,rMEMP
 286
 287         addi    rCLM,rCLS,-1
 288 L(getCacheAligned):
 289         cmplwi  cr1,rLEN,32
 290         and.    rTMP,rCLM,rMEMP
 291         blt     cr1,L(handletail32)
 292         beq     L(cacheAligned)
 293 /* We are not aligned to start of a cache line yet.  Store 32-byte
 294    of data and test again.  */
 295         addi    rMEMP,rMEMP,32
 296         addi    rLEN,rLEN,-32
 297         stw     rCHR,-32(rMEMP)
 298         stw     rCHR,-28(rMEMP)
 299         stw     rCHR,-24(rMEMP)
 300         stw     rCHR,-20(rMEMP)
 301         stw     rCHR,-16(rMEMP)
 302         stw     rCHR,-12(rMEMP)
 303         stw     rCHR,-8(rMEMP)
 304         stw     rCHR,-4(rMEMP)
 305         b       L(getCacheAligned)
 306
 307 /* Now we are aligned to the cache line and can use dcbz.  */
 308 L(cacheAligned):
 309         cmplw   cr1,rLEN,rCLS
 310         blt     cr1,L(handletail32)
 311         dcbz    0,rMEMP
 312         subf    rLEN,rCLS,rLEN
 313         add     rMEMP,rMEMP,rCLS
 314         b       L(cacheAligned)
 315
 316 /* We are here because; the cache line size was set, it was not
 317    32-bytes, and the remainder (rLEN) is now less than the actual cache
 318    line size.  Set up the preconditions for L(nondcbz) and go there to
 319    store the remaining bytes.  */
 320 L(handletail32):
 321         clrrwi. rALIGN, rLEN, 5
 322         b       L(nondcbz)
 323
 324 END (BP_SYM (memset))
 325 libc_hidden_builtin_def (memset)