source: vendor/glibc/current/sysdeps/i386/stpncpy.S

/* copy no more then N bytes from SRC to DEST, returning the address of
   the terminating '\0' in DEST.
   For Intel 80x86, x>=3.
   Copyright (C) 1994-1997,2000,2002,2005 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>
   Some bug fixes by Alan Modra <Alan@SPRI.Levels.UniSA.Edu.Au>
     - original wrote n+1 chars in some cases.
     - stpncpy() ought to behave like strncpy() ie. not null-terminate
       if limited by n.  glibc-1.09 stpncpy() does this.

   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, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

#include <sysdep.h>
#include "asm-syntax.h"
#include "bp-sym.h"
#include "bp-asm.h"

#define PARMS   LINKAGE+4       /* space for 1 saved reg */
#define RTN     PARMS
#define DEST    RTN+RTN_SIZE
#define SRC     DEST+PTR_SIZE
#define LEN     SRC+PTR_SIZE

        .text
ENTRY (BP_SYM (__stpncpy))
        ENTER

        pushl %esi
        cfi_adjust_cfa_offset (4)

        movl DEST(%esp), %eax
        movl SRC(%esp), %esi
        cfi_rel_offset (esi, 0)
        movl LEN(%esp), %ecx
        CHECK_BOUNDS_LOW (%eax, DEST(%esp))
        CHECK_BOUNDS_LOW (%esi, SRC(%esp))

        subl %eax, %esi         /* magic: reduce number of loop variants
                                   to one using addressing mode */
        jmp L(1)                /* jump to loop "head" */

        ALIGN(4)

        /* Four times unfolded loop with two loop counters.  We get the
           the third value (the source address) by using the index+base
           addressing mode.  */
L(2):   movb (%eax,%esi), %dl   /* load current char */
        movb %dl, (%eax)        /* and store it */
        testb %dl, %dl          /* was it NUL? */
        jz L(7)                 /* yes, then exit */

        movb 1(%eax,%esi), %dl  /* load current char */
        movb %dl, 1(%eax)       /* and store it */
        testb %dl, %dl          /* was it NUL? */
        jz L(6)                 /* yes, then exit */

        movb 2(%eax,%esi), %dl  /* load current char */
        movb %dl, 2(%eax)       /* and store it */
        testb %dl, %dl          /* was it NUL? */
        jz L(5)                 /* yes, then exit */

        movb 3(%eax,%esi), %dl  /* load current char */
        movb %dl, 3(%eax)       /* and store it */
        testb %dl, %dl          /* was it NUL? */
        jz L(4)                 /* yes, then exit */

        addl $4, %eax           /* increment loop counter for full round */

L(1):   subl $4, %ecx           /* still more than 4 bytes allowed? */
        jae L(2)                /* yes, then go to start of loop */

        /* The maximal remaining 15 bytes are not processed in a loop.  */

        addl $4, %ecx           /* correct above subtraction */
        jz L(9)                 /* maximal allowed char reached => go to end */

        movb (%eax,%esi), %dl   /* load current char */
        movb %dl, (%eax)        /* and store it */
        testb %dl, %dl          /* was it NUL? */
        jz L(3)                 /* yes, then exit */

        incl %eax               /* increment pointer */
        decl %ecx               /* decrement length counter */
        jz L(9)                 /* no more allowed => exit */

        movb (%eax,%esi), %dl   /* load current char */
        movb %dl, (%eax)        /* and store it */
        testb %dl, %dl          /* was it NUL? */
        jz L(3)                 /* yes, then exit */

        incl %eax               /* increment pointer */
        decl %ecx               /* decrement length counter */
        jz L(9)                 /* no more allowed => exit */

        movb (%eax,%esi), %dl   /* load current char */
        movb %dl, (%eax)        /* and store it */
        testb %dl, %dl          /* was it NUL? */
        jz L(3)                 /* yes, then exit */

        incl %eax               /* increment pointer */
        jmp L(9)                /* we don't have to test for counter underflow
                                   because we know we had a most 3 bytes
                                   remaining => exit */

        /* When coming from the main loop we have to adjust the pointer.  */
L(4):   decl %ecx               /* decrement counter */
        incl %eax               /* increment pointer */

L(5):   decl %ecx               /* increment pointer */
        incl %eax               /* increment pointer */

L(6):   decl %ecx               /* increment pointer */
        incl %eax               /* increment pointer */
L(7):

        addl $3, %ecx           /* correct pre-decrementation of counter
                                   at the beginning of the loop; but why 3
                                   and not 4?  Very simple, we have to count
                                   the NUL char we already wrote.  */
        jz L(9)                 /* counter is also 0 => exit */

        /* We now have to fill the rest of the buffer with NUL.  This
           is done in a tricky way.  Please note that the addressing mode
           used below is not the same we used above.  Here we use the
           %ecx register.  */
L(8):
        movb $0, (%ecx,%eax)    /* store NUL char */
L(3):   decl %ecx               /* all bytes written? */
        jnz L(8)                /* no, then again */

L(9):
#if __BOUNDED_POINTERS__
        addl %eax, %esi         /* undo magic: %esi now points beyond end of SRC */
        CHECK_BOUNDS_HIGH (%esi, SRC(%esp), jbe)
        CHECK_BOUNDS_HIGH (%eax, DEST(%esp), jbe)
        RETURN_BOUNDED_POINTER (DEST(%esp))
#endif
        popl %esi               /* restore saved register content */
        cfi_adjust_cfa_offset (-4)
        cfi_restore (esi)

        LEAVE
        RET_PTR
END (BP_SYM (__stpncpy))

libc_hidden_def (BP_SYM (__stpncpy))
weak_alias (BP_SYM (__stpncpy), BP_SYM (stpncpy))