1  /* Copyright (C) 1992-2023 Free Software Foundation, Inc.
       2     This file is part of the GNU C Library.
       3  
       4     The GNU C Library is free software; you can redistribute it and/or
       5     modify it under the terms of the GNU Lesser General Public
       6     License as published by the Free Software Foundation; either
       7     version 2.1 of the License, or (at your option) any later version.
       8  
       9     The GNU C Library is distributed in the hope that it will be useful,
      10     but WITHOUT ANY WARRANTY; without even the implied warranty of
      11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      12     Lesser General Public License for more details.
      13  
      14     You should have received a copy of the GNU Lesser General Public
      15     License along with the GNU C Library; if not, see
      16     <https://www.gnu.org/licenses/>.  */
      17  
      18  #define NO_MEMPCPY_STPCPY_REDIRECT
      19  #include <string.h>
      20  #include <stdint.h>
      21  #include <memcopy.h>
      22  #include <string-fzb.h>
      23  #include <string-misc.h>
      24  
      25  #undef __stpcpy
      26  #undef stpcpy
      27  
      28  #ifndef STPCPY
      29  # define STPCPY __stpcpy
      30  #endif
      31  
      32  static __always_inline char *
      33  write_byte_from_word (op_t *dest, op_t word)
      34  {
      35    char *d = (char *) dest;
      36    for (size_t i = 0; i < OPSIZ; i++, ++d)
      37      {
      38        char c = extractbyte (word, i);
      39        *d = c;
      40        if (c == '\0')
      41  	break;
      42      }
      43    return d;
      44  }
      45  
      46  static __always_inline char *
      47  stpcpy_aligned_loop (op_t *restrict dst, const op_t *restrict src)
      48  {
      49    op_t word;
      50    while (1)
      51      {
      52        word = *src++;
      53        if (has_zero (word))
      54  	break;
      55        *dst++ = word;
      56      }
      57  
      58    return write_byte_from_word (dst, word);
      59  }
      60  
      61  static __always_inline char *
      62  stpcpy_unaligned_loop (op_t *restrict dst, const op_t *restrict src,
      63  		       uintptr_t ofs)
      64  {
      65    op_t w2a = *src++;
      66    uintptr_t sh_1 = ofs * CHAR_BIT;
      67    uintptr_t sh_2 = OPSIZ * CHAR_BIT - sh_1;
      68  
      69    op_t w2 = MERGE (w2a, sh_1, (op_t)-1, sh_2);
      70    if (!has_zero (w2))
      71      {
      72        op_t w2b;
      73  
      74        /* Unaligned loop.  The invariant is that W2B, which is "ahead" of W1,
      75  	 does not contain end-of-string.  Therefore it is safe (and necessary)
      76  	 to read another word from each while we do not have a difference.  */
      77        while (1)
      78  	{
      79  	  w2b = *src++;
      80  	  w2 = MERGE (w2a, sh_1, w2b, sh_2);
      81  	  /* Check if there is zero on w2a.  */
      82  	  if (has_zero (w2))
      83  	    goto out;
      84  	  *dst++ = w2;
      85  	  if (has_zero (w2b))
      86  	    break;
      87  	  w2a = w2b;
      88  	}
      89  
      90        /* Align the final partial of P2.  */
      91        w2 = MERGE (w2b, sh_1, 0, sh_2);
      92      }
      93  
      94  out:
      95    return write_byte_from_word (dst, w2);
      96  }
      97  
      98  
      99  /* Copy SRC to DEST, returning the address of the terminating '\0' in DEST.  */
     100  char *
     101  STPCPY (char *dest, const char *src)
     102  {
     103    /* Copy just a few bytes to make DEST aligned.  */
     104    size_t len = (-(uintptr_t) dest) % OPSIZ;
     105    for (; len != 0; len--, ++dest)
     106      {
     107        char c = *src++;
     108        *dest = c;
     109        if (c == '\0')
     110  	return dest;
     111      }
     112  
     113    /* DEST is now aligned to op_t, SRC may or may not be.  */
     114    uintptr_t ofs = (uintptr_t) src % OPSIZ;
     115    return ofs == 0 ? stpcpy_aligned_loop ((op_t*) dest, (const op_t *) src)
     116  		  : stpcpy_unaligned_loop ((op_t*) dest,
     117  					   (const op_t *) (src - ofs) , ofs);
     118  }
     119  weak_alias (__stpcpy, stpcpy)
     120  libc_hidden_def (__stpcpy)
     121  libc_hidden_builtin_def (stpcpy)