sysdeps/i386/stpncpy.S

   1 /* copy no more then N bytes from SRC to DEST, returning the address of
   2    the terminating '\0' in DEST.
   3    For Intel 80x86, x>=3.
   4    Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
   5    This file is part of the GNU C Library.
   6    Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>
   7    Some bug fixes by Alan Modra <Alan@SPRI.Levels.UniSA.Edu.Au>
   8      - original wrote n+1 chars in some cases.
   9      - stpncpy() ought to behave like strncpy() ie. not null-terminate
  10        if limited by n.  glibc-1.09 stpncpy() does this.
  11
  12    The GNU C Library is free software; you can redistribute it and/or
  13    modify it under the terms of the GNU Library General Public License as
  14    published by the Free Software Foundation; either version 2 of the
  15    License, or (at your option) any later version.
  16
  17    The GNU C Library is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20    Library General Public License for more details.
  21
  22    You should have received a copy of the GNU Library General Public
  23    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  24    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  25    Boston, MA 02111-1307, USA.  */
  26
  27 #include <sysdep.h>
  28 #include "asm-syntax.h"
  29
  30 /*
  31    INPUT PARAMETERS:
  32    dest         (sp + 4)
  33    src          (sp + 8)
  34    maxlen       (sp + 12)
  35 */
  36
  37         .text
  38 ENTRY (__stpncpy)
  39
  40         pushl %esi
  41
  42         movl 8(%esp), %eax      /* load destination pointer */
  43         movl 12(%esp), %esi     /* load source pointer */
  44         movl 16(%esp), %ecx     /* load maximal length */
  45
  46         subl %eax, %esi         /* magic: reduce number of loop variants
  47                                    to one using addressing mode */
  48         jmp L(1)                /* jump to loop "head" */
  49
  50         ALIGN(4)
  51
  52         /* Four times unfolded loop with two loop counters.  We get the
  53            the third value (the source address) by using the index+base
  54            addressing mode.  */
  55 L(2):   movb (%eax,%esi), %dl   /* load current char */
  56         movb %dl, (%eax)        /* and store it */
  57         testb %dl, %dl          /* was it NUL? */
  58         jz L(7)                 /* yes, then exit */
  59
  60         movb 1(%eax,%esi), %dl  /* load current char */
  61         movb %dl, 1(%eax)       /* and store it */
  62         testb %dl, %dl          /* was it NUL? */
  63         jz L(6)                 /* yes, then exit */
  64
  65         movb 2(%eax,%esi), %dl  /* load current char */
  66         movb %dl, 2(%eax)       /* and store it */
  67         testb %dl, %dl          /* was it NUL? */
  68         jz L(5)                 /* yes, then exit */
  69
  70         movb 3(%eax,%esi), %dl  /* load current char */
  71         movb %dl, 3(%eax)       /* and store it */
  72         testb %dl, %dl          /* was it NUL? */
  73         jz L(4)                 /* yes, then exit */
  74
  75         addl $4, %eax           /* increment loop counter for full round */
  76
  77 L(1):   subl $4, %ecx           /* still more than 4 bytes allowed? */
  78         jae L(2)                /* yes, then go to start of loop */
  79
  80         /* The maximal remaining 15 bytes are not processed in a loop.  */
  81
  82         addl $4, %ecx           /* correct above subtraction */
  83         jz L(9)                 /* maximal allowed char reached => go to end */
  84
  85         movb (%eax,%esi), %dl   /* load current char */
  86         movb %dl, (%eax)        /* and store it */
  87         testb %dl, %dl          /* was it NUL? */
  88         jz L(3)                 /* yes, then exit */
  89
  90         incl %eax               /* increment pointer */
  91         decl %ecx               /* decrement length counter */
  92         jz L(9)                 /* no more allowed => exit */
  93
  94         movb (%eax,%esi), %dl   /* load current char */
  95         movb %dl, (%eax)        /* and store it */
  96         testb %dl, %dl          /* was it NUL? */
  97         jz L(3)                 /* yes, then exit */
  98
  99         incl %eax               /* increment pointer */
 100         decl %ecx               /* decrement length counter */
 101         jz L(9)                 /* no more allowed => exit */
 102
 103         movb (%eax,%esi), %dl   /* load current char */
 104         movb %dl, (%eax)        /* and store it */
 105         testb %dl, %dl          /* was it NUL? */
 106         jz L(3)                 /* yes, then exit */
 107
 108         incl %eax               /* increment pointer */
 109         jmp L(9)                /* we don't have to test for counter underflow
 110                                    because we know we had a most 3 bytes
 111                                    remaining => exit */
 112
 113         /* When coming from the main loop we have to adjust the pointer.  */
 114 L(4):   decl %ecx               /* decrement counter */
 115         incl %eax               /* increment pointer */
 116
 117 L(5):   decl %ecx               /* increment pointer */
 118         incl %eax               /* increment pointer */
 119
 120 L(6):   decl %ecx               /* increment pointer */
 121         incl %eax               /* increment pointer */
 122 L(7):
 123
 124         addl $3, %ecx           /* correct pre-decrementation of counter
 125                                    at the beginning of the loop; but why 3
 126                                    and not 4?  Very simple, we have to count
 127                                    the NUL char we already wrote.  */
 128         jz L(9)                 /* counter is also 0 => exit */
 129
 130         /* We now have to fill the rest of the buffer with NUL.  This
 131            is done in a tricky way.  Please note that the addressing mode
 132            used below is not the same we used above.  Here we use the
 133            %ecx register.  */
 134 L(8):
 135         movb $0, (%ecx,%eax)    /* store NUL char */
 136 L(3):   decl %ecx               /* all bytes written? */
 137         jnz L(8)                /* no, then again */
 138
 139 L(9):   popl %esi               /* restore saved register content */
 140
 141         ret
 142 END (__stpncpy)
 143
 144 weak_alias (__stpncpy, stpncpy)