summaryrefslogtreecommitdiff
path: root/libc/string/ia64/memcmp.S
blob: a6465f2cde042f708a01018b8b50a6a05a821c77 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
/* Optimized version of the standard memcmp() function.
   This file is part of the GNU C Library.
   Copyright (C) 2000, 2001, 2004 Free Software Foundation, Inc.
   Contributed by Dan Pop <Dan.Pop@cern.ch>.

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

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

/* Return: the result of the comparison

   Inputs:
        in0:    dest (aka s1)
        in1:    src  (aka s2)
        in2:    byte count

   In this form, it assumes little endian mode.  For big endian mode, the
   the two shifts in .l2 must be inverted:

	shl	tmp1[0] = r[1 + MEMLAT], sh1   // tmp1 = w0 << sh1
	shr.u   tmp2[0] = r[0 + MEMLAT], sh2   // tmp2 = w1 >> sh2

   and all the mux1 instructions should be replaced by plain mov's.  */

#include <sysdep.h>
#undef ret

#define OP_T_THRES	16
#define OPSIZ		8
#define MEMLAT		2

#define start		r15
#define saved_pr	r17
#define saved_lc	r18
#define dest		r19
#define src		r20
#define len		r21
#define asrc		r22
#define tmp		r23
#define value1		r24
#define value2		r25
#define sh2		r28
#define	sh1		r29
#define loopcnt		r30

ENTRY(memcmp)
	.prologue
	alloc	r2 = ar.pfs, 3, 37, 0, 40

	.rotr	r[MEMLAT + 2], q[MEMLAT + 5], tmp1[4], tmp2[4], val[2]
	.rotp	p[MEMLAT + 4 + 1]

	mov	ret0 = r0		/* by default return value = 0 */
	.save pr, saved_pr
	mov	saved_pr = pr		/* save the predicate registers */
	.save ar.lc, saved_lc
        mov	saved_lc = ar.lc	/* save the loop counter */
	.body
	mov	dest = in0		/* dest */
	mov	src = in1		/* src */
	mov	len = in2		/* len */
	sub	tmp = r0, in0		/* tmp = -dest */
	;;
	and	loopcnt = 7, tmp		/* loopcnt = -dest % 8 */
	cmp.ge	p6, p0 = OP_T_THRES, len	/* is len <= OP_T_THRES */
(p6)	br.cond.spnt	.cmpfew			/* compare byte by byte */
	;;
	cmp.eq	p6, p0 = loopcnt, r0
(p6)	br.cond.sptk .dest_aligned
	sub	len = len, loopcnt	/* len -= -dest % 8 */
	adds	loopcnt = -1, loopcnt	/* --loopcnt */
	;;
	mov	ar.lc = loopcnt
.l1:					/* copy -dest % 8 bytes */
	ld1	value1 = [src], 1	/* value = *src++ */
	ld1	value2 = [dest], 1
	;;
	cmp.ne	p6, p0 = value1, value2
(p6)	br.cond.spnt .done
	br.cloop.dptk .l1
.dest_aligned:
	and	sh1 = 7, src		/* sh1 = src % 8 */
	and	tmp = -8, len		/* tmp = len & -OPSIZ */
	and	asrc = -8, src		/* asrc = src & -OPSIZ  -- align src */
	shr.u	loopcnt = len, 3	/* loopcnt = len / 8 */
	and	len = 7, len ;;		/* len = len % 8 */
	shl	sh1 = sh1, 3		/* sh1 = 8 * (src % 8) */
	adds	loopcnt = -1, loopcnt	/* --loopcnt */
	mov     pr.rot = 1 << 16 ;;	/* set rotating predicates */
	sub	sh2 = 64, sh1		/* sh2 = 64 - sh1 */
	mov	ar.lc = loopcnt		/* set LC */
	cmp.eq  p6, p0 = sh1, r0	/* is the src aligned? */
(p6)    br.cond.sptk .src_aligned
	add	src = src, tmp		/* src += len & -OPSIZ */
	mov	ar.ec = MEMLAT + 4 + 1	/* four more passes needed */
	ld8	r[1] = [asrc], 8 ;;	/* r[1] = w0 */
	.align	32

/* We enter this loop with p6 cleared by the above comparison */

.l2:
(p[0])		ld8	r[0] = [asrc], 8		/* r[0] = w1 */
(p[0])		ld8	q[0] = [dest], 8
(p[MEMLAT])	shr.u	tmp1[0] = r[1 + MEMLAT], sh1	/* tmp1 = w0 >> sh1 */
(p[MEMLAT])	shl	tmp2[0] = r[0 + MEMLAT], sh2	/* tmp2 = w1 << sh2 */
(p[MEMLAT+4])	cmp.ne	p6, p0 = q[MEMLAT + 4], val[1]
(p[MEMLAT+3])	or	val[0] = tmp1[3], tmp2[3]	/* val = tmp1 | tmp2 */
(p6)		br.cond.spnt .l2exit
		br.ctop.sptk    .l2
		br.cond.sptk .cmpfew
.l3exit:
	mux1	value1 = r[MEMLAT], @rev
	mux1	value2 = q[MEMLAT], @rev
	cmp.ne	p6, p0 = r0, r0	;;	/* clear p6 */
.l2exit:
(p6)	mux1	value1 = val[1], @rev
(p6)	mux1	value2 = q[MEMLAT + 4], @rev ;;
	cmp.ltu	p6, p7 = value2, value1 ;;
(p6)	mov	ret0 = -1
(p7)	mov	ret0 = 1
	mov     pr = saved_pr, -1	/* restore the predicate registers */
	mov	ar.lc = saved_lc	/* restore the loop counter */
	br.ret.sptk.many b0
.src_aligned:
	cmp.ne	p6, p0 = r0, r0		/* clear p6 */
	mov     ar.ec = MEMLAT + 1 ;;	/* set EC */
.l3:
(p[0])		ld8	r[0] = [src], 8
(p[0])		ld8	q[0] = [dest], 8
(p[MEMLAT])	cmp.ne	p6, p0 = r[MEMLAT], q[MEMLAT]
(p6)		br.cond.spnt .l3exit
		br.ctop.dptk .l3 ;;
.cmpfew:
	cmp.eq	p6, p0 = len, r0	/* is len == 0 ? */
	adds	len = -1, len		/* --len; */
(p6)	br.cond.spnt	.restore_and_exit ;;
	mov	ar.lc = len
.l4:
	ld1	value1 = [src], 1
	ld1	value2 = [dest], 1
	;;
	cmp.ne	p6, p0 = value1, value2
(p6)	br.cond.spnt	.done
	br.cloop.dptk	.l4 ;;
.done:
(p6)	sub	ret0 = value2, value1	/* don't execute it if falling thru */
.restore_and_exit:
	mov     pr = saved_pr, -1	/* restore the predicate registers */
	mov	ar.lc = saved_lc	/* restore the loop counter */
	br.ret.sptk.many b0
END(memcmp)
libc_hidden_def (memcmp)
#ifdef __UCLIBC_SUSV3_LEGACY__
strong_alias (memcmp, bcmp)
#endif