* sysdeps/i386/add_n.S: Wrap entry-point symbol in BP_SYM ().
[kopensolaris-gnu/glibc.git] / 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, 2000 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 #include "bp-sym.h"
30 #include "bp-asm.h"
31
32 #define PARMS   LINKAGE+4       /* space for 1 saved reg */
33 #define RTN     PARMS
34 #define DEST    RTN+RTN_SIZE
35 #define SRC     DEST+PTR_SIZE
36 #define LEN     SRC+PTR_SIZE
37
38         .text
39 ENTRY (BP_SYM (__stpncpy))
40         ENTER
41
42         pushl %esi
43
44         movl DEST(%esp), %eax
45         movl SRC(%esp), %esi
46         movl LEN(%esp), %ecx
47         CHECK_BOUNDS_LOW (%eax, DEST(%esp))
48         CHECK_BOUNDS_LOW (%esi, SRC(%esp))
49
50         subl %eax, %esi         /* magic: reduce number of loop variants
51                                    to one using addressing mode */
52         jmp L(1)                /* jump to loop "head" */
53
54         ALIGN(4)
55
56         /* Four times unfolded loop with two loop counters.  We get the
57            the third value (the source address) by using the index+base
58            addressing mode.  */
59 L(2):   movb (%eax,%esi), %dl   /* load current char */
60         movb %dl, (%eax)        /* and store it */
61         testb %dl, %dl          /* was it NUL? */
62         jz L(7)                 /* yes, then exit */
63
64         movb 1(%eax,%esi), %dl  /* load current char */
65         movb %dl, 1(%eax)       /* and store it */
66         testb %dl, %dl          /* was it NUL? */
67         jz L(6)                 /* yes, then exit */
68
69         movb 2(%eax,%esi), %dl  /* load current char */
70         movb %dl, 2(%eax)       /* and store it */
71         testb %dl, %dl          /* was it NUL? */
72         jz L(5)                 /* yes, then exit */
73
74         movb 3(%eax,%esi), %dl  /* load current char */
75         movb %dl, 3(%eax)       /* and store it */
76         testb %dl, %dl          /* was it NUL? */
77         jz L(4)                 /* yes, then exit */
78
79         addl $4, %eax           /* increment loop counter for full round */
80
81 L(1):   subl $4, %ecx           /* still more than 4 bytes allowed? */
82         jae L(2)                /* yes, then go to start of loop */
83
84         /* The maximal remaining 15 bytes are not processed in a loop.  */
85
86         addl $4, %ecx           /* correct above subtraction */
87         jz L(9)                 /* maximal allowed char reached => go to end */
88
89         movb (%eax,%esi), %dl   /* load current char */
90         movb %dl, (%eax)        /* and store it */
91         testb %dl, %dl          /* was it NUL? */
92         jz L(3)                 /* yes, then exit */
93
94         incl %eax               /* increment pointer */
95         decl %ecx               /* decrement length counter */
96         jz L(9)                 /* no more allowed => exit */
97
98         movb (%eax,%esi), %dl   /* load current char */
99         movb %dl, (%eax)        /* and store it */
100         testb %dl, %dl          /* was it NUL? */
101         jz L(3)                 /* yes, then exit */
102
103         incl %eax               /* increment pointer */
104         decl %ecx               /* decrement length counter */
105         jz L(9)                 /* no more allowed => exit */
106
107         movb (%eax,%esi), %dl   /* load current char */
108         movb %dl, (%eax)        /* and store it */
109         testb %dl, %dl          /* was it NUL? */
110         jz L(3)                 /* yes, then exit */
111
112         incl %eax               /* increment pointer */
113         jmp L(9)                /* we don't have to test for counter underflow
114                                    because we know we had a most 3 bytes
115                                    remaining => exit */
116
117         /* When coming from the main loop we have to adjust the pointer.  */
118 L(4):   decl %ecx               /* decrement counter */
119         incl %eax               /* increment pointer */
120
121 L(5):   decl %ecx               /* increment pointer */
122         incl %eax               /* increment pointer */
123
124 L(6):   decl %ecx               /* increment pointer */
125         incl %eax               /* increment pointer */
126 L(7):
127
128         addl $3, %ecx           /* correct pre-decrementation of counter
129                                    at the beginning of the loop; but why 3
130                                    and not 4?  Very simple, we have to count
131                                    the NUL char we already wrote.  */
132         jz L(9)                 /* counter is also 0 => exit */
133
134         /* We now have to fill the rest of the buffer with NUL.  This
135            is done in a tricky way.  Please note that the addressing mode
136            used below is not the same we used above.  Here we use the
137            %ecx register.  */
138 L(8):
139         movb $0, (%ecx,%eax)    /* store NUL char */
140 L(3):   decl %ecx               /* all bytes written? */
141         jnz L(8)                /* no, then again */
142
143 L(9):
144 #if __BOUNDED_POINTERS__
145         addl %eax, %esi         /* undo magic: %esi now points beyond end of SRC */
146         CHECK_BOUNDS_HIGH (%esi, SRC(%esp), jb)
147         CHECK_BOUNDS_HIGH (%eax, DEST(%esp), jb)
148         RETURN_BOUNDED_POINTER (DEST(%esp))
149 #endif
150         popl %esi               /* restore saved register content */
151
152         LEAVE
153         RET_PTR
154 END (BP_SYM (__stpncpy))
155
156 weak_alias (BP_SYM (__stpncpy), BP_SYM (stpncpy))