[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Commits] r18981 - in /fsf/trunk/ports: ./ sysdeps/alpha/ sysdeps/alpha/alphaev6/ sysdeps/alpha/fpu/ sysdeps/unix/alpha/



Author: eglibc
Date: Thu Jun  7 00:02:07 2012
New Revision: 18981

Log:
Import glibc-ports-mainline for 2012-06-07

Modified:
    fsf/trunk/ports/ChangeLog.alpha
    fsf/trunk/ports/sysdeps/alpha/_mcount.S
    fsf/trunk/ports/sysdeps/alpha/alphaev6/stxcpy.S
    fsf/trunk/ports/sysdeps/alpha/alphaev6/stxncpy.S
    fsf/trunk/ports/sysdeps/alpha/bzero.S
    fsf/trunk/ports/sysdeps/alpha/fpu/e_sqrt.c
    fsf/trunk/ports/sysdeps/alpha/memset.S
    fsf/trunk/ports/sysdeps/alpha/strncmp.S
    fsf/trunk/ports/sysdeps/alpha/stxcpy.S
    fsf/trunk/ports/sysdeps/alpha/stxncpy.S
    fsf/trunk/ports/sysdeps/unix/alpha/sysdep.h

Modified: fsf/trunk/ports/ChangeLog.alpha
==============================================================================
--- fsf/trunk/ports/ChangeLog.alpha (original)
+++ fsf/trunk/ports/ChangeLog.alpha Thu Jun  7 00:02:07 2012
@@ -1,3 +1,26 @@
+2012-06-06  Richard Henderson  <rth@xxxxxxxxxxx>
+
+	* sysdeps/alpha/strncmp.S: Bound count to LONG_MAX at startup.
+	Re-organize checks vs s2 end-of-count.
+
+	[BZ #13718]
+	* sysdeps/alpha/stxncmp.S: Bound count to LONG_MAX at startup.
+	* sysdeps/alpha/alphaev6/stxncmp.S: Likewise.
+
+	* sysdeps/alpha/fpu/e_sqrt.c: Include <math_private.h> before
+	redefining __ieee758_sqrt.
+
+	* sysdeps/alpha/alphaev6/stxcpy.S: Use cfi markup instead of
+	dual ecoff procedure descriptors.
+	* sysdeps/alpha/alphaev6/stxncpy.S: Likewise.
+	* sysdeps/alpha/bzero.S: Likewise.
+	* sysdeps/alpha/memset.S: Likewise.
+	* sysdeps/alpha/stxcpy.S: Likewise.
+	* sysdeps/alpha/stxncpy.S: Likewise.
+	* sysdeps/unix/alpha/sysdep.h (USEPV_PROF): New.
+
+	* sysdeps/alpha/_mcount.S: Move .prologue after stack alloc.
+
 2012-06-05  Richard Henderson  <rth@xxxxxxxxxxx>
 
 	* sysdeps/unix/sysv/linux/alpha/rt_sigaction.S: Use .cfi_signal_frame

Modified: fsf/trunk/ports/sysdeps/alpha/_mcount.S
==============================================================================
--- fsf/trunk/ports/sysdeps/alpha/_mcount.S (original)
+++ fsf/trunk/ports/sysdeps/alpha/_mcount.S Thu Jun  7 00:02:07 2012
@@ -38,9 +38,8 @@
 	.set	noreorder
 
 LEAF(_mcount, 0xb0)
+	subq	 sp, 0xb0, sp
 	.prologue 0
-
-	subq	 sp, 0xb0, sp
 	stq	 a0, 0x00(sp)
 	mov	 ra, a0		# a0 = caller-pc
 	stq	 a1, 0x08(sp)

Modified: fsf/trunk/ports/sysdeps/alpha/alphaev6/stxcpy.S
==============================================================================
--- fsf/trunk/ports/sysdeps/alpha/alphaev6/stxcpy.S (original)
+++ fsf/trunk/ports/sysdeps/alpha/alphaev6/stxcpy.S Thu Jun  7 00:02:07 2012
@@ -1,4 +1,4 @@
-/* Copyright (C) 2000 Free Software Foundation, Inc.
+/* Copyright (C) 2000-2012 Free Software Foundation, Inc.
    Contributed by Richard Henderson (rth@xxxxxxxx)
    EV6 optimized by Rick Gorton <rick.gorton@xxxxxxxxxxxxxxxxxxx>.
    This file is part of the GNU C Library.
@@ -41,24 +41,20 @@
 	.arch ev6
 	.set noat
 	.set noreorder
+
 	.text
-
-/* There is a problem with either gdb (as of 4.16) or gas (as of 2.7) that
-   doesn't like putting the entry point for a procedure somewhere in the
-   middle of the procedure descriptor.  Work around this by putting the
-   aligned copy in its own procedure descriptor */
-
-
-	.ent stxcpy_aligned
-	.align 4
-stxcpy_aligned:
-	.frame sp, 0, t9
-	.prologue 0
+	.type	__stxcpy, @function
+	.globl	__stxcpy
+	.usepv	__stxcpy, no
+
+	cfi_startproc
+	cfi_return_column (t9)
 
 	/* On entry to this basic block:
 	   t0 == the first destination word for masking back in
 	   t1 == the first source word.  */
-
+	.align 4
+stxcpy_aligned:
 	/* Create the 1st output word and detect 0's in the 1st input word.  */
 	lda	t2, -1		# E : build a mask against false zero
 	mskqh	t2, a1, t2	# U :   detection in the src word (stall)
@@ -115,15 +111,8 @@
 	nop
 	nop
 
-	.end stxcpy_aligned
-
 	.align 4
-	.ent __stxcpy
-	.globl __stxcpy
 __stxcpy:
-	.frame sp, 0, t9
-	.prologue 0
-
 	/* Are source and destination co-aligned?  */
 	xor	a0, a1, t0	# E :
 	unop			# E :
@@ -321,7 +310,5 @@
 	or	t0, t1, t1	# e1    : and put it there
 	stq_u	t1, 0(a0)	# .. e0 : (stall)
 	ret	(t9)		# e1    :
-	nop
-
-	.end __stxcpy
-
+
+	cfi_endproc

Modified: fsf/trunk/ports/sysdeps/alpha/alphaev6/stxncpy.S
==============================================================================
--- fsf/trunk/ports/sysdeps/alpha/alphaev6/stxncpy.S (original)
+++ fsf/trunk/ports/sysdeps/alpha/alphaev6/stxncpy.S Thu Jun  7 00:02:07 2012
@@ -1,4 +1,4 @@
-/* Copyright (C) 2000, 2002 Free Software Foundation, Inc.
+/* Copyright (C) 2000-2012 Free Software Foundation, Inc.
    Contributed by Richard Henderson (rth@xxxxxxxx)
    EV6 optimized by Rick Gorton <rick.gorton@xxxxxxxxxxxxxxxxxxx>.
    This file is part of the GNU C Library.
@@ -49,22 +49,19 @@
 	.set noat
 	.set noreorder
 
-/* There is a problem with either gdb (as of 4.16) or gas (as of 2.7) that
-   doesn't like putting the entry point for a procedure somewhere in the
-   middle of the procedure descriptor.  Work around this by putting the
-   aligned copy in its own procedure descriptor */
-
-
-	.ent stxncpy_aligned
-	.align 4
-stxncpy_aligned:
-	.frame sp, 0, t9, 0
-	.prologue 0
+	.text
+	.type	__stxncpy, @function
+	.globl	__stxncpy
+	.usepv	__stxncpy, no
+
+	cfi_startproc
+	cfi_return_column (t9)
 
 	/* On entry to this basic block:
 	   t0 == the first destination word for masking back in
 	   t1 == the first source word.  */
-
+	.align 4
+stxncpy_aligned:
 	/* Create the 1st output word and detect 0's in the 1st input word.  */
 	lda	t2, -1		# E : build a mask against false zero
 	mskqh	t2, a1, t2	# U :   detection in the src word (stall)
@@ -111,7 +108,6 @@
 	   On entry to this basic block we have:
 	   t0 == the source word containing the null
 	   t7 == the cmpbge mask that found it.  */
-
 $a_eos:
 	negq	t7, t8		# E : find low bit set
 	and	t7, t8, t8	# E : (stall)
@@ -144,38 +140,36 @@
 	nop
 	nop
 
-	.end stxncpy_aligned
-
-	.align 4
-	.ent __stxncpy
-	.globl __stxncpy
+	.align 4
 __stxncpy:
-	.frame sp, 0, t9, 0
-	.prologue 0
-
 	/* Are source and destination co-aligned?  */
+	lda	t2, -1		# E :
 	xor	a0, a1, t1	# E :
 	and	a0, 7, t0	# E : find dest misalignment
-	and	t1, 7, t1	# E : (stall)
-	addq	a2, t0, a2	# E : bias count by dest misalignment (stall)
-
-	subq	a2, 1, a2	# E :
+	nop			# E :
+
+	srl	t2, 1, t2	# U :
+	and	t1, 7, t1	# E :
+	cmovlt	a2, t2, a2	# E : bound count to LONG_MAX (stall)
+	nop			# E :
+
+	addq	a2, t0, a2	# E : bias count by dest misalignment
+	subq	a2, 1, a2	# E : (stall)
 	and	a2, 7, t2	# E : (stall)
-	srl	a2, 3, a2	# U : a2 = loop counter = (count - 1)/8 (stall)
-	addq	zero, 1, t10	# E :
-
+	lda	t10, 1		# E :
+
+	srl	a2, 3, a2	# U : a2 = loop counter = (count - 1)/8
 	sll	t10, t2, t10	# U : t10 = bitmask of last count byte
-	bne	t1, $unaligned	# U :
+	nop			# E :
+	bne	t1, $unaligned	# U : (stall)
+
 	/* We are co-aligned; take care of a partial first word.  */
 	ldq_u	t1, 0(a1)	# L : load first src word
 	addq	a1, 8, a1	# E :
-
-	beq	t0, stxncpy_aligned     # U : avoid loading dest word if not needed
+	beq	t0, stxncpy_aligned # U : avoid loading dest word if not needed
 	ldq_u	t0, 0(a0)	# L :
-	nop
-	nop
-
-	br	stxncpy_aligned	# .. e1 :
+
+	br	stxncpy_aligned	# U :
 	nop
 	nop
 	nop
@@ -231,7 +225,7 @@
 
 	extqh	t2, a1, t0	# U : position lo-bits of hi word (stall)
 	cmpbge	zero, t2, t7	# E :
-	nop			
+	nop
 	bne	t7, $u_eos	# U :
 
 	/* Unaligned copy main loop.  In order to avoid reading too much,
@@ -314,7 +308,7 @@
 1:	stq_u	t0, 0(a0)	# L :
 	ret	(t9)		# L0 : Latency=3
 
-        /* Got to end-of-count before end of string.  
+        /* Got to end-of-count before end of string.
            On entry to this basic block:
            t1 == the shifted high-order bits from the previous source word  */
 $u_eoc:
@@ -325,7 +319,7 @@
 
 	ldq_u	t2, 8(a1)	# L : load final src word
 	nop
-	extqh	t2, a1, t0	# U : extract low bits for last word (stall)	
+	extqh	t2, a1, t0	# U : extract low bits for last word (stall)
 	or	t1, t0, t1	# E : (stall)
 
 1:	cmpbge	zero, t1, t7	# E :
@@ -394,9 +388,5 @@
 	stq_u	t0, 0(a0)	# L : (stall)
 
 	ret	(t9)		# L0 : Latency=3
-	nop
-	nop
-	nop
-
-	.end __stxncpy
-
+
+	cfi_endproc

Modified: fsf/trunk/ports/sysdeps/alpha/bzero.S
==============================================================================
--- fsf/trunk/ports/sysdeps/alpha/bzero.S (original)
+++ fsf/trunk/ports/sysdeps/alpha/bzero.S Thu Jun  7 00:02:07 2012
@@ -36,23 +36,19 @@
 	.set noreorder
 
 	.text
+	.type	__bzero, @function
+	.globl	__bzero
+	.usepv	__bzero, USEPV_PROF
 
-/* There is a problem with either gdb (as of 4.16) or gas (as of 2.7) that
-   doesn't like putting the entry point for a procedure somewhere in the
-   middle of the procedure descriptor.  Work around this by putting the main
-   loop in its own procedure descriptor.  */
+	cfi_startproc
 
 	/* On entry to this basic block:
 	   t3 == loop counter
 	   t4 == bytes in partial final word
 	   a0 == possibly misaligned destination pointer  */
 
-	.ent bzero_loop
 	.align 3
 bzero_loop:
-	.frame sp, 0, ra, 0
-	.prologue 0
-
 	beq	t3, $tail	#
 	blbc	t3, 0f		# skip single store if count even
 
@@ -75,16 +71,11 @@
 	stq_u	t0, 0(a0)	#
 	ret			#
 
-	.end bzero_loop
-
-ENTRY(__bzero)
+__bzero:
 #ifdef PROF
 	ldgp	gp, 0(pv)
 	lda	AT, _mcount
 	jsr	AT, (AT), _mcount
-	.prologue 1
-#else
-	.prologue 0
 #endif
 
 	mov	a0, v0		# e0    : move return value in place
@@ -115,5 +106,5 @@
 
 $done:	ret
 
-	END(__bzero)
+	cfi_endproc
 weak_alias (__bzero, bzero)

Modified: fsf/trunk/ports/sysdeps/alpha/fpu/e_sqrt.c
==============================================================================
--- fsf/trunk/ports/sysdeps/alpha/fpu/e_sqrt.c (original)
+++ fsf/trunk/ports/sysdeps/alpha/fpu/e_sqrt.c Thu Jun  7 00:02:07 2012
@@ -16,7 +16,8 @@
    License along with the GNU C Library.  If not, see
    <http://www.gnu.org/licenses/>.  */
 
-#include <features.h>
+#include <math.h>
+#include <math_private.h>
 
 #if !defined(_IEEE_FP_INEXACT)
 

Modified: fsf/trunk/ports/sysdeps/alpha/memset.S
==============================================================================
--- fsf/trunk/ports/sysdeps/alpha/memset.S (original)
+++ fsf/trunk/ports/sysdeps/alpha/memset.S Thu Jun  7 00:02:07 2012
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996, 1997, 2003 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2012 Free Software Foundation, Inc.
    Contributed by Richard Henderson (rth@xxxxxxxx)
    This file is part of the GNU C Library.
 
@@ -37,11 +37,11 @@
 	.set noreorder
 
 	.text
+	.type	memset, @function
+	.globl	memset
+	.usepv	memset, USEPV_PROF
 
-/* There is a problem with either gdb (as of 4.16) or gas (as of 2.7) that
-   doesn't like putting the entry point for a procedure somewhere in the
-   middle of the procedure descriptor.  Work around this by putting the main
-   loop in its own procedure descriptor.  */
+	cfi_startproc
 
 	/* On entry to this basic block:
 	   t3 == loop counter
@@ -49,12 +49,8 @@
 	   a0 == possibly misaligned destination pointer
 	   a1 == replicated source character  */
 
-	.ent memset_loop
 	.align 3
 memset_loop:
-	.frame sp, 0, ra, 0
-	.prologue 0
-
 	beq	t3, $tail
 	blbc	t3, 0f		# skip single store if count even
 
@@ -80,19 +76,14 @@
 	stq_u	t0, 0(a0)	# e0    :
 	ret			# .. e1 :
 
-	.end memset_loop
-
-ENTRY(memset)
+memset:
 #ifdef PROF
 	ldgp	gp, 0(pv)
 	lda	AT, _mcount
 	jsr	AT, (AT), _mcount
-	.prologue 1
-#else
-	.prologue 0
 #endif
 
-	zapnot	a1, 1, a1	# e0    : zero extend input character
+	and	a1, 0xff, a1	# e0    : zero extend input character
 	mov	a0, v0		# .. e1 : move return value in place
 	sll	a1, 8, t0	# e0    : begin replicating the char
 	beq	a2, $done	# .. e1 : early exit for zero-length store
@@ -132,5 +123,5 @@
 
 $done:	ret
 
-	END(memset)
+	cfi_endproc
 libc_hidden_builtin_def (memset)

Modified: fsf/trunk/ports/sysdeps/alpha/strncmp.S
==============================================================================
--- fsf/trunk/ports/sysdeps/alpha/strncmp.S (original)
+++ fsf/trunk/ports/sysdeps/alpha/strncmp.S Thu Jun  7 00:02:07 2012
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996, 1997, 2003 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2012 Free Software Foundation, Inc.
    Contributed by Richard Henderson (rth@xxxxxxxx)
    This file is part of the GNU C Library.
 
@@ -22,6 +22,15 @@
 
 	.set noat
 	.set noreorder
+
+/* EV6 only predicts one branch per octaword.  We'll use these to push
+   subsequent branches back to the next bundle.  This will generally add
+   a fetch+decode cycle to older machines, so skip in that case.  */
+#ifdef __alpha_fix__
+# define ev6_unop	unop
+#else
+# define ev6_unop
+#endif
 
 	.text
 
@@ -35,128 +44,140 @@
 	.prologue 0
 #endif
 
-	xor	a0, a1, t2	# e0    : are s1 and s2 co-aligned?
-	beq	a2, $zerolength	# .. e1 :
-	ldq_u	t0, 0(a0)	# e0    : give cache time to catch up
-	ldq_u	t1, 0(a1)	# .. e1 :
-	and	t2, 7, t2	# e0    :
-	and	a0, 7, t4	# .. e1 : find s1 misalignment
-	lda	t3, -1		# e0    :
-	addq	a2, t4, a2	# .. e1 : bias count by s1 misalignment
-	and	a2, 7, t10	# e1    : ofs of last byte in last word
-	srl	a2, 3, a2	# .. e0 : remaining full words in count
-	and	a1, 7, t5	# e0    : find s2 misalignment
-	bne	t2, $unaligned	# .. e1 :
+	xor	a0, a1, t2	# are s1 and s2 co-aligned?
+	beq	a2, $zerolength
+	ldq_u	t0, 0(a0)	# load asap to give cache time to catch up
+	ldq_u	t1, 0(a1)
+	lda	t3, -1
+	and	t2, 7, t2
+	srl	t3, 1, t6
+	and	a0, 7, t4	# find s1 misalignment
+	and	a1, 7, t5	# find s2 misalignment
+	cmovlt	a2, t6, a2	# bound neg count to LONG_MAX
+	addq	a1, a2, a3	# s2+count
+	addq	a2, t4, a2	# bias count by s1 misalignment
+	and	a2, 7, t10	# ofs of last byte in s1 last word
+	srl	a2, 3, a2	# remaining full words in s1 count
+	bne	t2, $unaligned
 
 	/* On entry to this basic block:
 	   t0 == the first word of s1.
 	   t1 == the first word of s2.
 	   t3 == -1.  */
-
 $aligned:
-	mskqh	t3, a1, t3	# e0    : mask off leading garbage
-	nop			# .. e1 :
-	ornot	t1, t3, t1	# e0    :
-	ornot	t0, t3, t0	# .. e1 :
-	cmpbge	zero, t1, t7	# e0    : bits set iff null found
-	beq	a2, $eoc	# .. e1 : check end of count
-	unop			# e0    :
-	bne	t7, $eos	# .. e1 :
-	unop			# e0    :
-	beq	t10, $ant_loop	# .. e1 :
+	mskqh	t3, a1, t8	# mask off leading garbage
+	ornot	t1, t8, t1
+	ornot	t0, t8, t0
+	cmpbge	zero, t1, t7	# bits set iff null found
+	beq	a2, $eoc	# check end of count
+	bne	t7, $eos
+	beq	t10, $ant_loop
 
 	/* Aligned compare main loop.
 	   On entry to this basic block:
 	   t0 == an s1 word.
 	   t1 == an s2 word not containing a null.  */
 
+	.align 4
 $a_loop:
 	xor	t0, t1, t2	# e0	:
 	bne	t2, $wordcmp	# .. e1 (zdb)
 	ldq_u	t1, 8(a1)	# e0    :
 	ldq_u	t0, 8(a0)	# .. e1 :
+
 	subq	a2, 1, a2	# e0    :
 	addq	a1, 8, a1	# .. e1 :
 	addq	a0, 8, a0	# e0    :
 	beq	a2, $eoc	# .. e1 :
+
 	cmpbge	zero, t1, t7	# e0    :
 	beq	t7, $a_loop	# .. e1 :
-	unop			# e0    :
-	br	$eos		# .. e1 :
+
+	br	$eos
 
 	/* Alternate aligned compare loop, for when there's no trailing
 	   bytes on the count.  We have to avoid reading too much data.  */
+	.align 4
 $ant_loop:
 	xor	t0, t1, t2	# e0	:
+	ev6_unop
+	ev6_unop
 	bne	t2, $wordcmp	# .. e1 (zdb)
+
 	subq	a2, 1, a2	# e0    :
 	beq	a2, $zerolength	# .. e1 :
 	ldq_u	t1, 8(a1)	# e0    :
 	ldq_u	t0, 8(a0)	# .. e1 :
+
 	addq	a1, 8, a1	# e0    :
 	addq	a0, 8, a0	# .. e1 :
 	cmpbge	zero, t1, t7	# e0    :
 	beq	t7, $ant_loop	# .. e1 :
-	unop			# e0	:
-	br	$eos		# .. e1 :
+
+	br	$eos
 
 	/* The two strings are not co-aligned.  Align s1 and cope.  */
+	/* On entry to this basic block:
+	   t0 == the first word of s1.
+	   t1 == the first word of s2.
+	   t3 == -1.
+	   t4 == misalignment of s1.
+	   t5 == misalignment of s2.
+	  t10 == misalignment of s1 end.  */
+	.align	4
 $unaligned:
-	subq	a1, t4, a1	# e0	 :
-	unop			#        :
-
-	/* If s2 misalignment is larger than s2 misalignment, we need
+	/* If s1 misalignment is larger than s2 misalignment, we need
 	   extra startup checks to avoid SEGV.  */
-
-	cmplt	t4, t5, t8	# .. e1 :
-	beq	t8, $u_head	# e1    :
-
-	mskqh	t3, t5, t3	# e0    :
-	ornot	t1, t3, t3	# e0    :
-	cmpbge	zero, t3, t7	# e1    : is there a zero?
-	beq	t7, $u_head	# e1    :
-
-	/* We've found a zero in the first partial word of s2.  Align
-	   our current s1 and s2 words and compare what we've got.  */
-
-	extql	t1, t5, t1	# e0    :
-	lda	t3, -1		# .. e1 :
-	insql	t1, a0, t1	# e0    :
-	mskqh	t3, a0, t3	# e0    :
-	ornot	t1, t3, t1	# e0    :
-	ornot	t0, t3, t0	# .. e1 :
-	cmpbge	zero, t1, t7	# e0    : find that zero again
-	beq	a2, $eoc	# .. e1 : and finish up
-	br	$eos		# e1    :
-
-	.align 3
-$u_head:
+	subq	a1, t4, a1	# adjust s2 for s1 misalignment
+	cmpult	t4, t5, t9
+	subq	a3, 1, a3	# last byte of s2
+	bic	a1, 7, t8
+	mskqh	t3, t5, t7	# mask garbage in s2
+	subq	a3, t8, a3
+	ornot	t1, t7, t7
+	srl	a3, 3, a3	# remaining full words in s2 count
+	beq	t9, $u_head
+
+	/* Failing that, we need to look for both eos and eoc within the
+	   first word of s2.  If we find either, we can continue by
+	   pretending that the next word of s2 is all zeros.  */
+	lda	t2, 0		# next = zero
+	cmpeq	a3, 0, t8	# eoc in the first word of s2?
+	cmpbge	zero, t7, t7	# eos in the first word of s2?
+	or	t7, t8, t8
+	bne	t8, $u_head_nl
+
 	/* We know just enough now to be able to assemble the first
 	   full word of s2.  We can still find a zero at the end of it.
 
 	   On entry to this basic block:
 	   t0 == first word of s1
-	   t1 == first partial word of s2.  */
-
-	ldq_u	t2, 8(a1)	# e0    : load second partial s2 word
-	lda	t3, -1		# .. e1 : create leading garbage mask
-	extql	t1, a1, t1	# e0    : create first s2 word
-	mskqh	t3, a0, t3	# e0    :
-	extqh	t2, a1, t4	# e0    :
-	ornot	t0, t3, t0	# .. e1 : kill s1 garbage
-	or	t1, t4, t1	# e0    : s2 word now complete
-	ornot	t1, t3, t1	# e1    : kill s2 garbage
-	cmpbge	zero, t0, t7	# e0    : find zero in first s1 word
-	beq	a2, $eoc	# .. e1 :
-	lda	t3, -1		# e0    :
-	bne	t7, $eos	# .. e1 :
-	subq	a2, 1, a2	# e0    :
-	xor	t0, t1, t4	# .. e1 : compare aligned words
-	mskql	t3, a1, t3	# e0    : mask out s2[1] bits we have seen
-	bne	t4, $wordcmp	# .. e1 :
-	or	t2, t3, t3	# e0    :
-	cmpbge	zero, t3, t7	# e1    : find zero in high bits of s2[1]
-	bne	t7, $u_final	# e1    :
+	   t1 == first partial word of s2.
+	   t3 == -1.
+	   t10 == ofs of last byte in s1 last word.
+	   t11 == ofs of last byte in s2 last word.  */
+$u_head:
+	ldq_u	t2, 8(a1)	# load second partial s2 word
+	subq	a3, 1, a3
+$u_head_nl:
+	extql	t1, a1, t1	# create first s2 word
+	mskqh	t3, a0, t8
+	extqh	t2, a1, t4
+	ornot	t0, t8, t0	# kill s1 garbage
+	or	t1, t4, t1	# s2 word now complete
+	cmpbge	zero, t0, t7	# find eos in first s1 word
+	ornot	t1, t8, t1	# kill s2 garbage
+	beq	a2, $eoc
+	subq	a2, 1, a2
+	bne	t7, $eos
+	mskql	t3, a1, t8	# mask out s2[1] bits we have seen
+	xor	t0, t1, t4	# compare aligned words
+	or	t2, t8, t8
+	bne	t4, $wordcmp
+	cmpbge	zero, t8, t7	# eos in high bits of s2[1]?
+	cmpeq	a3, 0, t8	# eoc in s2[1]?
+	or	t7, t8, t7
+	bne	t7, $u_final
 
 	/* Unaligned copy main loop.  In order to avoid reading too much,
 	   the loop is structured to detect zeros in aligned words from s2.
@@ -166,43 +187,54 @@
 	   to run as fast as possible.
 
 	   On entry to this basic block:
-	   t2 == the unshifted low-bits from the next s2 word.  */
-
-	.align 3
+	   t2 == the unshifted low-bits from the next s2 word.
+	   t10 == ofs of last byte in s1 last word.
+	   t11 == ofs of last byte in s2 last word.  */
+	.align 4
 $u_loop:
 	extql	t2, a1, t3	# e0    :
 	ldq_u	t2, 16(a1)	# .. e1 : load next s2 high bits
 	ldq_u	t0, 8(a0)	# e0    : load next s1 word
 	addq	a1, 8, a1	# .. e1 :
+
 	addq	a0, 8, a0	# e0    :
-	nop			# .. e1 :
+	subq	a3, 1, a3	# .. e1 :
 	extqh	t2, a1, t1	# e0    :
-	cmpbge	zero, t0, t7	# .. e1 : find zero in current s1 word
+	cmpbge	zero, t0, t7	# .. e1 : eos in current s1 word
+
 	or	t1, t3, t1	# e0    :
-	beq	a2, $eoc	# .. e1 : check for end of count
+	beq	a2, $eoc	# .. e1 : eoc in current s1 word
 	subq	a2, 1, a2	# e0    :
+	cmpbge	zero, t2, t4	# .. e1 : eos in s2[1]
+
+	xor	t0, t1, t3	# e0    : compare the words
+	ev6_unop
+	ev6_unop
 	bne	t7, $eos	# .. e1 :
-	xor	t0, t1, t4	# e0    : compare the words
-	bne	t4, $wordcmp	# .. e1 (zdb)
-	cmpbge	zero, t2, t4	# e0    : find zero in next low bits
+
+	cmpeq	a3, 0, t5	# e0    : eoc in s2[1]
+	ev6_unop
+	ev6_unop
+	bne	t3, $wordcmp	# .. e1 :
+
+	or	t4, t5, t4	# e0    : eos or eoc in s2[1].
 	beq	t4, $u_loop	# .. e1 (zdb)
 
 	/* We've found a zero in the low bits of the last s2 word.  Get
 	   the next s1 word and align them.  */
+	.align 3
 $u_final:
-	ldq_u	t0, 8(a0)	# e1    :
-	extql	t2, a1, t1	# .. e0 :
-	cmpbge	zero, t1, t7	# e0    :
-	bne	a2, $eos	# .. e1 :
+	ldq_u	t0, 8(a0)
+	extql	t2, a1, t1
+	cmpbge	zero, t1, t7
+	bne	a2, $eos
 
 	/* We've hit end of count.  Zero everything after the count
 	   and compare whats left.  */
-
 	.align 3
 $eoc:
 	mskql	t0, t10, t0
 	mskql	t1, t10, t1
-	unop
 	cmpbge	zero, t1, t7
 
 	/* We've found a zero somewhere in a word we just read.
@@ -210,32 +242,31 @@
 	   t0 == s1 word
 	   t1 == s2 word
 	   t7 == cmpbge mask containing the zero.  */
-
+	.align 3
 $eos:
-	negq	t7, t6		# e0    : create bytemask of valid data
-	and	t6, t7, t8	# e1    :
-	subq	t8, 1, t6	# e0    :
-	or	t6, t8, t7	# e1    :
-	zapnot	t0, t7, t0	# e0    : kill the garbage
-	zapnot	t1, t7, t1	# .. e1 :
-	xor	t0, t1, v0	# e0    : and compare
-	beq	v0, $done	# .. e1 :
+	negq	t7, t6		# create bytemask of valid data
+	and	t6, t7, t8
+	subq	t8, 1, t6
+	or	t6, t8, t7
+	zapnot	t0, t7, t0	# kill the garbage
+	zapnot	t1, t7, t1
+	xor	t0, t1, v0	# ... and compare
+	beq	v0, $done
 
 	/* Here we have two differing co-aligned words in t0 & t1.
 	   Bytewise compare them and return (t0 > t1 ? 1 : -1).  */
 	.align 3
 $wordcmp:
-	cmpbge	t0, t1, t2	# e0    : comparison yields bit mask of ge
-	cmpbge	t1, t0, t3	# .. e1 :
-	xor	t2, t3, t0	# e0    : bits set iff t0/t1 bytes differ
-	negq	t0, t1		# e1    : clear all but least bit
-	and	t0, t1, t0	# e0    :
-	lda	v0, -1		# .. e1 :
-	and	t0, t2, t1	# e0    : was bit set in t0 > t1?
-	cmovne	t1, 1, v0	# .. e1 (zdb)
-
+	cmpbge	t0, t1, t2	# comparison yields bit mask of ge
+	cmpbge	t1, t0, t3
+	xor	t2, t3, t0	# bits set iff t0/t1 bytes differ
+	negq	t0, t1		# clear all but least bit
+	and	t0, t1, t0
+	lda	v0, -1
+	and	t0, t2, t1	# was bit set in t0 > t1?
+	cmovne	t1, 1, v0
 $done:
-	ret			# e1    :
+	ret
 
 	.align 3
 $zerolength:

Modified: fsf/trunk/ports/sysdeps/alpha/stxcpy.S
==============================================================================
--- fsf/trunk/ports/sysdeps/alpha/stxcpy.S (original)
+++ fsf/trunk/ports/sysdeps/alpha/stxcpy.S Thu Jun  7 00:02:07 2012
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2012 Free Software Foundation, Inc.
    Contributed by Richard Henderson (rth@xxxxxxxx)
    This file is part of the GNU C Library.
 
@@ -43,22 +43,18 @@
 	.set noreorder
 
 	.text
-
-/* There is a problem with either gdb (as of 4.16) or gas (as of 2.7) that
-   doesn't like putting the entry point for a procedure somewhere in the
-   middle of the procedure descriptor.  Work around this by putting the
-   aligned copy in its own procedure descriptor */
-
-	.ent stxcpy_aligned
-	.align 3
-stxcpy_aligned:
-	.frame sp, 0, t9
-	.prologue 0
+	.type	__stxcpy, @function
+	.globl	__stxcpy
+	.usepv	__stxcpy, no
+
+	cfi_startproc
+	cfi_return_column (t9)
 
 	/* On entry to this basic block:
 	   t0 == the first destination word for masking back in
 	   t1 == the first source word.  */
-
+	.align 3
+stxcpy_aligned:
 	/* Create the 1st output word and detect 0's in the 1st input word.  */
 	lda	t2, -1		# e1    : build a mask against false zero
 	mskqh	t2, a1, t2	# e0    :   detection in the src word
@@ -72,7 +68,6 @@
 	/* On entry to this basic block:
 	   t0 == the first destination word for masking back in
 	   t1 == a source word not containing a null.  */
-
 $a_loop:
 	stq_u	t1, 0(a0)	# e0    :
 	addq	a0, 8, a0	# .. e1 :
@@ -106,15 +101,8 @@
 1:	stq_u	t1, 0(a0)	# e0    :
 	ret	(t9)		# .. e1 :
 
-	.end stxcpy_aligned
-
-	.align 3
-	.ent __stxcpy
-	.globl __stxcpy
+	.align 3
 __stxcpy:
-	.frame sp, 0, t9
-	.prologue 0
-
 	/* Are source and destination co-aligned?  */
 	xor	a0, a1, t0	# e0    :
 	unop			#       :
@@ -303,4 +291,4 @@
 	stq_u	t1, 0(a0)	# .. e0 :
 	ret	(t9)
 
-	.end __stxcpy
+	cfi_endproc

Modified: fsf/trunk/ports/sysdeps/alpha/stxncpy.S
==============================================================================
--- fsf/trunk/ports/sysdeps/alpha/stxncpy.S (original)
+++ fsf/trunk/ports/sysdeps/alpha/stxncpy.S Thu Jun  7 00:02:07 2012
@@ -1,4 +1,4 @@
-/* Copyright (C) 1996, 1997, 2002 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2012 Free Software Foundation, Inc.
    Contributed by Richard Henderson (rth@xxxxxxxx)
    This file is part of the GNU C Library.
 
@@ -52,22 +52,18 @@
 	.set noreorder
 
 	.text
-
-/* There is a problem with either gdb (as of 4.16) or gas (as of 2.7) that
-   doesn't like putting the entry point for a procedure somewhere in the
-   middle of the procedure descriptor.  Work around this by putting the
-   aligned copy in its own procedure descriptor */
-
-	.ent stxncpy_aligned
-	.align 3
-stxncpy_aligned:
-	.frame sp, 0, t9, 0
-	.prologue 0
+	.type	__stxncpy, @function
+	.globl	__stxncpy
+	.usepv	__stxncpy, no
+
+	cfi_startproc
+	cfi_return_column (t9)
 
 	/* On entry to this basic block:
 	   t0 == the first destination word for masking back in
 	   t1 == the first source word.  */
-
+	.align 3
+stxncpy_aligned:
 	/* Create the 1st output word and detect 0's in the 1st input word.  */
 	lda	t2, -1		# e1    : build a mask against false zero
 	mskqh	t2, a1, t2	# e0    :   detection in the src word
@@ -81,7 +77,6 @@
 
 	/* On entry to this basic block:
 	   t0 == a source word not containing a null.  */
-
 $a_loop:
 	stq_u	t0, 0(a0)	# e0    :
 	addq	a0, 8, a0	# .. e1 :
@@ -98,7 +93,6 @@
 	   On entry to this basic block we have:
 	   t0 == the source word containing the null
 	   t7 == the cmpbge mask that found it.  */
-
 $a_eos:
 	negq	t7, t8		# e0    : find low bit set
 	and	t7, t8, t8	# e1 (stall)
@@ -126,26 +120,22 @@
 	or	t10, t7, t7
 	br	$a_eos
 
-	.end stxncpy_aligned
-
-	.align 3
-	.ent __stxncpy
-	.globl __stxncpy
+	.align 3
 __stxncpy:
-	.frame sp, 0, t9, 0
-	.prologue 0
-
 	/* Are source and destination co-aligned?  */
-	xor	a0, a1, t1	# e0    :
-	and	a0, 7, t0	# .. e1 : find dest misalignment
-	and	t1, 7, t1	# e0    :
-	addq	a2, t0, a2	# .. e1 : bias count by dest misalignment
-	subq	a2, 1, a2	# e0    :
-	and	a2, 7, t2	# e1    :
-	srl	a2, 3, a2	# e0    : a2 = loop counter = (count - 1)/8
-	addq	zero, 1, t10	# .. e1 :
-	sll	t10, t2, t10	# e0    : t10 = bitmask of last count byte
-	bne	t1, $unaligned	# .. e1 :
+	lda	t2, -1
+	xor	a0, a1, t1
+	srl	t2, 1, t2
+	and	a0, 7, t0		# find dest misalignment
+	cmovlt	a2, t2, a2		# bound neg count to LONG_MAX
+	and	t1, 7, t1
+	addq	a2, t0, a2		# bias count by dest misalignment
+	subq	a2, 1, a2
+	and	a2, 7, t2
+	srl	a2, 3, a2		# a2 = loop counter = (count - 1)/8
+	addq	zero, 1, t10
+	sll	t10, t2, t10		# t10 = bitmask of last count byte
+	bne	t1, $unaligned
 
 	/* We are co-aligned; take care of a partial first word.  */
 
@@ -359,4 +349,4 @@
 	stq_u	t0, 0(a0)	# e0    :
 	ret	(t9)		# .. e1 :
 
-	.end __stxncpy
+	cfi_endproc

Modified: fsf/trunk/ports/sysdeps/unix/alpha/sysdep.h
==============================================================================
--- fsf/trunk/ports/sysdeps/unix/alpha/sysdep.h (original)
+++ fsf/trunk/ports/sysdeps/unix/alpha/sysdep.h Thu Jun  7 00:02:07 2012
@@ -70,6 +70,12 @@
 	ldgp	gp,0(pv);			\
 	.prologue 1
 #endif /* PROF */
+
+#ifdef PROF
+# define USEPV_PROF	std
+#else
+# define USEPV_PROF	no
+#endif
 
 #if RTLD_PRIVATE_ERRNO
 # define SYSCALL_ERROR_LABEL	$syscall_error

_______________________________________________
Commits mailing list
Commits@xxxxxxxxxx
http://eglibc.org/cgi-bin/mailman/listinfo/commits