Debian Codegraph @

internal/xxh32/xxh32zero_arm.s

raw
1 // +build !noasm
2
3 #include "go_asm.h"
4 #include "textflag.h"
5
6 // Register allocation.
7 #define p R0
8 #define n R1
9 #define h R2
10 #define v1 R2 // Alias for h.
11 #define v2 R3
12 #define v3 R4
13 #define v4 R5
14 #define x1 R6
15 #define x2 R7
16 #define x3 R8
17 #define x4 R9
18
19 // We need the primes in registers. The 16-byte loop only uses prime{1,2}.
20 #define prime1r R11
21 #define prime2r R12
22 #define prime3r R3 // The rest can alias v{2-4}.
23 #define prime4r R4
24 #define prime5r R5
25
26 // Update round macros. These read from and increment p.
27
28 #define round16aligned \
29 MOVM.IA.W (p), [x1, x2, x3, x4] \
30 \
31 MULA x1, prime2r, v1, v1 \
32 MULA x2, prime2r, v2, v2 \
33 MULA x3, prime2r, v3, v3 \
34 MULA x4, prime2r, v4, v4 \
35 \
36 MOVW v1 @> 19, v1 \
37 MOVW v2 @> 19, v2 \
38 MOVW v3 @> 19, v3 \
39 MOVW v4 @> 19, v4 \
40 \
41 MUL prime1r, v1 \
42 MUL prime1r, v2 \
43 MUL prime1r, v3 \
44 MUL prime1r, v4 \
45
46 #define round16unaligned \
47 MOVBU.P 16(p), x1 \
48 MOVBU -15(p), x2 \
49 ORR x2 << 8, x1 \
50 MOVBU -14(p), x3 \
51 MOVBU -13(p), x4 \
52 ORR x4 << 8, x3 \
53 ORR x3 << 16, x1 \
54 \
55 MULA x1, prime2r, v1, v1 \
56 MOVW v1 @> 19, v1 \
57 MUL prime1r, v1 \
58 \
59 MOVBU -12(p), x1 \
60 MOVBU -11(p), x2 \
61 ORR x2 << 8, x1 \
62 MOVBU -10(p), x3 \
63 MOVBU -9(p), x4 \
64 ORR x4 << 8, x3 \
65 ORR x3 << 16, x1 \
66 \
67 MULA x1, prime2r, v2, v2 \
68 MOVW v2 @> 19, v2 \
69 MUL prime1r, v2 \
70 \
71 MOVBU -8(p), x1 \
72 MOVBU -7(p), x2 \
73 ORR x2 << 8, x1 \
74 MOVBU -6(p), x3 \
75 MOVBU -5(p), x4 \
76 ORR x4 << 8, x3 \
77 ORR x3 << 16, x1 \
78 \
79 MULA x1, prime2r, v3, v3 \
80 MOVW v3 @> 19, v3 \
81 MUL prime1r, v3 \
82 \
83 MOVBU -4(p), x1 \
84 MOVBU -3(p), x2 \
85 ORR x2 << 8, x1 \
86 MOVBU -2(p), x3 \
87 MOVBU -1(p), x4 \
88 ORR x4 << 8, x3 \
89 ORR x3 << 16, x1 \
90 \
91 MULA x1, prime2r, v4, v4 \
92 MOVW v4 @> 19, v4 \
93 MUL prime1r, v4 \
94
95
96 // func ChecksumZero([]byte) uint32
97 TEXT ·ChecksumZero(SB), NOFRAME|NOSPLIT, $-4-16
98 MOVW input_base+0(FP), p
99 MOVW input_len+4(FP), n
100
101 MOVW $const_prime1, prime1r
102 MOVW $const_prime2, prime2r
103
104 // Set up h for n < 16. It's tempting to say {ADD prime5, n, h}
105 // here, but that's a pseudo-op that generates a load through R11.
106 MOVW $const_prime5, prime5r
107 ADD prime5r, n, h
108 CMP $0, n
109 BEQ end
110
111 // We let n go negative so we can do comparisons with SUB.S
112 // instead of separate CMP.
113 SUB.S $16, n
114 BMI loop16done
115
116 ADD prime1r, prime2r, v1
117 MOVW prime2r, v2
118 MOVW $0, v3
119 RSB $0, prime1r, v4
120
121 TST $3, p
122 BNE loop16unaligned
123
124 loop16aligned:
125 SUB.S $16, n
126 round16aligned
127 BPL loop16aligned
128 B loop16finish
129
130 loop16unaligned:
131 SUB.S $16, n
132 round16unaligned
133 BPL loop16unaligned
134
135 loop16finish:
136 MOVW v1 @> 31, h
137 ADD v2 @> 25, h
138 ADD v3 @> 20, h
139 ADD v4 @> 14, h
140
141 // h += len(input) with v2 as temporary.
142 MOVW input_len+4(FP), v2
143 ADD v2, h
144
145 loop16done:
146 ADD $16, n // Restore number of bytes left.
147
148 SUB.S $4, n
149 MOVW $const_prime3, prime3r
150 BMI loop4done
151 MOVW $const_prime4, prime4r
152
153 TST $3, p
154 BNE loop4unaligned
155
156 loop4aligned:
157 SUB.S $4, n
158
159 MOVW.P 4(p), x1
160 MULA prime3r, x1, h, h
161 MOVW h @> 15, h
162 MUL prime4r, h
163
164 BPL loop4aligned
165 B loop4done
166
167 loop4unaligned:
168 SUB.S $4, n
169
170 MOVBU.P 4(p), x1
171 MOVBU -3(p), x2
172 ORR x2 << 8, x1
173 MOVBU -2(p), x3
174 ORR x3 << 16, x1
175 MOVBU -1(p), x4
176 ORR x4 << 24, x1
177
178 MULA prime3r, x1, h, h
179 MOVW h @> 15, h
180 MUL prime4r, h
181
182 BPL loop4unaligned
183
184 loop4done:
185 ADD.S $4, n // Restore number of bytes left.
186 BEQ end
187
188 MOVW $const_prime5, prime5r
189
190 loop1:
191 SUB.S $1, n
192
193 MOVBU.P 1(p), x1
194 MULA prime5r, x1, h, h
195 MOVW h @> 21, h
196 MUL prime1r, h
197
198 BNE loop1
199
200 end:
201 MOVW $const_prime3, prime3r
202 EOR h >> 15, h
203 MUL prime2r, h
204 EOR h >> 13, h
205 MUL prime3r, h
206 EOR h >> 16, h
207
208 MOVW h, ret+12(FP)
209 RET
210
211
212 // func update(v *[4]uint64, buf *[16]byte, p []byte)
213 TEXT ·update(SB), NOFRAME|NOSPLIT, $-4-20
214 MOVW v+0(FP), p
215 MOVM.IA (p), [v1, v2, v3, v4]
216
217 MOVW $const_prime1, prime1r
218 MOVW $const_prime2, prime2r
219
220 // Process buf, if not nil.
221 MOVW buf+4(FP), p
222 CMP $0, p
223 BEQ noBuffered
224
225 round16aligned
226
227 noBuffered:
228 MOVW input_base +8(FP), p
229 MOVW input_len +12(FP), n
230
231 SUB.S $16, n
232 BMI end
233
234 TST $3, p
235 BNE loop16unaligned
236
237 loop16aligned:
238 SUB.S $16, n
239 round16aligned
240 BPL loop16aligned
241 B end
242
243 loop16unaligned:
244 SUB.S $16, n
245 round16unaligned
246 BPL loop16unaligned
247
248 end:
249 MOVW v+0(FP), p
250 MOVM.IA [v1, v2, v3, v4], (p)
251 RET