Update from main archive 961219
[kopensolaris-gnu/glibc.git] / sysdeps / i386 / stpncpy.S
1 /* stpncpy -- copy no more then N bytes from SRC to DEST, returning the
2               address of the terminating '\0' in DEST.
3    For Intel 80x86, x>=3.
4    Copyright (C) 1994, 1995, 1996 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 L1                  /* 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 L2:     movb (%eax,%esi), %dl   /* load current char */
56         movb %dl, (%eax)        /* and store it */
57         testb %dl, %dl          /* was it NUL? */
58         jz L7                   /* 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 L6                   /* 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 L5                   /* 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 L4                   /* yes, then exit */
74
75         addl $4, %eax           /* increment loop counter for full round */
76
77 L1:     subl $4, %ecx           /* still more than 4 bytes allowed? */
78         jae L2                  /* 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 L9                   /* 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 L3                   /* yes, then exit */
89
90         incl %eax               /* increment pointer */
91         decl %ecx               /* decrement length counter */
92         jz L9                   /* 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 L3                   /* yes, then exit */
98
99         incl %eax               /* increment pointer */
100         decl %ecx               /* decrement length counter */
101         jz L9                   /* 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 L3                   /* yes, then exit */
107
108         incl %eax               /* increment pointer */
109         jmp L9                  /* 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 L4:     decl %ecx               /* decrement counter */
115         incl %eax               /* increment pointer */
116
117 L5:     decl %ecx               /* increment pointer */
118         incl %eax               /* increment pointer */
119
120 L6:     decl %ecx               /* increment pointer */
121         incl %eax               /* increment pointer */
122 L7:
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 L9                   /* 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 L8:
135         movb $0, (%ecx,%eax)    /* store NUL char */
136 L3:     decl %ecx               /* all bytes written? */
137         jnz L8                  /* no, then again */
138
139 L9:     popl %esi               /* restore saved register content */
140
141         ret
142 END (__stpncpy)
143
144 weak_alias (__stpncpy, stpncpy)