aboutsummaryrefslogtreecommitdiff
path: root/ports/sysdeps/ia64/memcmp.S
blob: 00118c5a4558dec42204c54e9c7e38d89ea59ad3 (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
/* Optimized version of the standard memcmp() function.
   This file is part of the GNU C Library.
   Copyright (C) 2000-2013 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, see
   <http://www.gnu.org/licenses/>.  */

/* 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 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)

weak_alias (memcmp, bcmp)
libc_hidden_builtin_def (memcmp)