[thirdparty/glibc.git] / sysdeps / i386 / stpncpy.S

/* stpncpy -- 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, 1995, 1996 Free Software Foundation, Inc.
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.
This file is part of the GNU C Library.

The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 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
Library General Public License for more details.

You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB.  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"

/*
   INPUT PARAMETERS:
   dest		(sp + 4)
   src		(sp + 8)
   maxlen	(sp + 12)
*/

	.text
ENTRY (__stpncpy)

	pushl %esi

	movl 8(%esp), %eax	/* load destination pointer */
	movl 12(%esp), %esi	/* load source pointer */
	movl 16(%esp), %ecx	/* load maximal length */

	subl %eax, %esi		/* magic: reduce number of loop variants
				   to one using addressing mode */
	jmp L1			/* 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
	   adressing mode.  */
L2:	movb (%eax,%esi), %dl	/* load current char */
	movb %dl, (%eax)	/* and store it */
	testb %dl, %dl		/* was it NUL? */
	jz L7			/* 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 L6			/* 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 L5			/* 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 L4			/* yes, then exit */

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

L1:	subl $4, %ecx		/* still more than 4 bytes allowed? */
	jae L2			/* 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 L9			/* 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 L3			/* yes, then exit */

	incl %eax		/* increment pointer */
	decl %ecx		/* decrement length counter */
	jz L9			/* no more allowed => exit */

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

	incl %eax		/* increment pointer */
	decl %ecx		/* decrement length counter */
	jz L9			/* no more allowed => exit */

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

	incl %eax		/* increment pointer */
	jmp L9			/* 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.  */
L4:	decl %ecx		/* decrement counter */
	incl %eax		/* increment pointer */

L5:	decl %ecx		/* increment pointer */
	incl %eax		/* increment pointer */

L6:	decl %ecx		/* increment pointer */
	incl %eax		/* increment pointer */
L7:

	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 L9			/* 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 adressing mode
	   used below is not the same we used above.  Here we use the
	   %ecx register.  */
L8:
	movb $0, (%ecx,%eax)	/* store NUL char */
L3:	decl %ecx		/* all bytes written? */
	jnz L8			/* no, then again */

L9:	popl %esi		/* restore saved register content */

	ret
END (__stpncpy)

weak_alias (__stpncpy, stpncpy)
Commit	Line	Data
8f5ca04b RM	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.
cccda09f	4	Copyright (C) 1994, 1995, 1996 Free Software Foundation, Inc.
8f5ca04b RM	5	Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>
	6	Some bug fixes by Alan Modra <Alan@SPRI.Levels.UniSA.Edu.Au>
	7	- original wrote n+1 chars in some cases.
	8	- stpncpy() ought to behave like strncpy() ie. not null-terminate
	9	if limited by n. glibc-1.09 stpncpy() does this.
	10	This file is part of the GNU C Library.
	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
	24	not, 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	adressing 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 adressing 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
6ed0492f	142	END (__stpncpy)
8f5ca04b RM	143
8f5ca04b RM	144	weak_alias (__stpncpy, stpncpy)