~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/asm-generic/xor.h

Version: ~ [ linux-6.12-rc7 ] ~ [ linux-6.11.7 ] ~ [ linux-6.10.14 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.60 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.116 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.171 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.229 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.285 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.323 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.12 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

Diff markup

Differences between /include/asm-generic/xor.h (Version linux-6.12-rc7) and /include/asm-ppc/xor.h (Version linux-2.6.0)


  1 /* SPDX-License-Identifier: GPL-2.0-or-later * !!   1 #include <asm-generic/xor.h>
  2 /*                                             << 
  3  * include/asm-generic/xor.h                   << 
  4  *                                             << 
  5  * Generic optimized RAID-5 checksumming funct << 
  6  */                                            << 
  7                                                << 
  8 #include <linux/prefetch.h>                    << 
  9                                                << 
 10 static void                                    << 
 11 xor_8regs_2(unsigned long bytes, unsigned long << 
 12             const unsigned long * __restrict p << 
 13 {                                              << 
 14         long lines = bytes / (sizeof (long)) / << 
 15                                                << 
 16         do {                                   << 
 17                 p1[0] ^= p2[0];                << 
 18                 p1[1] ^= p2[1];                << 
 19                 p1[2] ^= p2[2];                << 
 20                 p1[3] ^= p2[3];                << 
 21                 p1[4] ^= p2[4];                << 
 22                 p1[5] ^= p2[5];                << 
 23                 p1[6] ^= p2[6];                << 
 24                 p1[7] ^= p2[7];                << 
 25                 p1 += 8;                       << 
 26                 p2 += 8;                       << 
 27         } while (--lines > 0);                 << 
 28 }                                              << 
 29                                                << 
 30 static void                                    << 
 31 xor_8regs_3(unsigned long bytes, unsigned long << 
 32             const unsigned long * __restrict p << 
 33             const unsigned long * __restrict p << 
 34 {                                              << 
 35         long lines = bytes / (sizeof (long)) / << 
 36                                                << 
 37         do {                                   << 
 38                 p1[0] ^= p2[0] ^ p3[0];        << 
 39                 p1[1] ^= p2[1] ^ p3[1];        << 
 40                 p1[2] ^= p2[2] ^ p3[2];        << 
 41                 p1[3] ^= p2[3] ^ p3[3];        << 
 42                 p1[4] ^= p2[4] ^ p3[4];        << 
 43                 p1[5] ^= p2[5] ^ p3[5];        << 
 44                 p1[6] ^= p2[6] ^ p3[6];        << 
 45                 p1[7] ^= p2[7] ^ p3[7];        << 
 46                 p1 += 8;                       << 
 47                 p2 += 8;                       << 
 48                 p3 += 8;                       << 
 49         } while (--lines > 0);                 << 
 50 }                                              << 
 51                                                << 
 52 static void                                    << 
 53 xor_8regs_4(unsigned long bytes, unsigned long << 
 54             const unsigned long * __restrict p << 
 55             const unsigned long * __restrict p << 
 56             const unsigned long * __restrict p << 
 57 {                                              << 
 58         long lines = bytes / (sizeof (long)) / << 
 59                                                << 
 60         do {                                   << 
 61                 p1[0] ^= p2[0] ^ p3[0] ^ p4[0] << 
 62                 p1[1] ^= p2[1] ^ p3[1] ^ p4[1] << 
 63                 p1[2] ^= p2[2] ^ p3[2] ^ p4[2] << 
 64                 p1[3] ^= p2[3] ^ p3[3] ^ p4[3] << 
 65                 p1[4] ^= p2[4] ^ p3[4] ^ p4[4] << 
 66                 p1[5] ^= p2[5] ^ p3[5] ^ p4[5] << 
 67                 p1[6] ^= p2[6] ^ p3[6] ^ p4[6] << 
 68                 p1[7] ^= p2[7] ^ p3[7] ^ p4[7] << 
 69                 p1 += 8;                       << 
 70                 p2 += 8;                       << 
 71                 p3 += 8;                       << 
 72                 p4 += 8;                       << 
 73         } while (--lines > 0);                 << 
 74 }                                              << 
 75                                                << 
 76 static void                                    << 
 77 xor_8regs_5(unsigned long bytes, unsigned long << 
 78             const unsigned long * __restrict p << 
 79             const unsigned long * __restrict p << 
 80             const unsigned long * __restrict p << 
 81             const unsigned long * __restrict p << 
 82 {                                              << 
 83         long lines = bytes / (sizeof (long)) / << 
 84                                                << 
 85         do {                                   << 
 86                 p1[0] ^= p2[0] ^ p3[0] ^ p4[0] << 
 87                 p1[1] ^= p2[1] ^ p3[1] ^ p4[1] << 
 88                 p1[2] ^= p2[2] ^ p3[2] ^ p4[2] << 
 89                 p1[3] ^= p2[3] ^ p3[3] ^ p4[3] << 
 90                 p1[4] ^= p2[4] ^ p3[4] ^ p4[4] << 
 91                 p1[5] ^= p2[5] ^ p3[5] ^ p4[5] << 
 92                 p1[6] ^= p2[6] ^ p3[6] ^ p4[6] << 
 93                 p1[7] ^= p2[7] ^ p3[7] ^ p4[7] << 
 94                 p1 += 8;                       << 
 95                 p2 += 8;                       << 
 96                 p3 += 8;                       << 
 97                 p4 += 8;                       << 
 98                 p5 += 8;                       << 
 99         } while (--lines > 0);                 << 
100 }                                              << 
101                                                << 
102 static void                                    << 
103 xor_32regs_2(unsigned long bytes, unsigned lon << 
104              const unsigned long * __restrict  << 
105 {                                              << 
106         long lines = bytes / (sizeof (long)) / << 
107                                                << 
108         do {                                   << 
109                 register long d0, d1, d2, d3,  << 
110                 d0 = p1[0];     /* Pull the st << 
111                 d1 = p1[1];     /*  ... in bur << 
112                 d2 = p1[2];                    << 
113                 d3 = p1[3];                    << 
114                 d4 = p1[4];                    << 
115                 d5 = p1[5];                    << 
116                 d6 = p1[6];                    << 
117                 d7 = p1[7];                    << 
118                 d0 ^= p2[0];                   << 
119                 d1 ^= p2[1];                   << 
120                 d2 ^= p2[2];                   << 
121                 d3 ^= p2[3];                   << 
122                 d4 ^= p2[4];                   << 
123                 d5 ^= p2[5];                   << 
124                 d6 ^= p2[6];                   << 
125                 d7 ^= p2[7];                   << 
126                 p1[0] = d0;     /* Store the r << 
127                 p1[1] = d1;                    << 
128                 p1[2] = d2;                    << 
129                 p1[3] = d3;                    << 
130                 p1[4] = d4;                    << 
131                 p1[5] = d5;                    << 
132                 p1[6] = d6;                    << 
133                 p1[7] = d7;                    << 
134                 p1 += 8;                       << 
135                 p2 += 8;                       << 
136         } while (--lines > 0);                 << 
137 }                                              << 
138                                                << 
139 static void                                    << 
140 xor_32regs_3(unsigned long bytes, unsigned lon << 
141              const unsigned long * __restrict  << 
142              const unsigned long * __restrict  << 
143 {                                              << 
144         long lines = bytes / (sizeof (long)) / << 
145                                                << 
146         do {                                   << 
147                 register long d0, d1, d2, d3,  << 
148                 d0 = p1[0];     /* Pull the st << 
149                 d1 = p1[1];     /*  ... in bur << 
150                 d2 = p1[2];                    << 
151                 d3 = p1[3];                    << 
152                 d4 = p1[4];                    << 
153                 d5 = p1[5];                    << 
154                 d6 = p1[6];                    << 
155                 d7 = p1[7];                    << 
156                 d0 ^= p2[0];                   << 
157                 d1 ^= p2[1];                   << 
158                 d2 ^= p2[2];                   << 
159                 d3 ^= p2[3];                   << 
160                 d4 ^= p2[4];                   << 
161                 d5 ^= p2[5];                   << 
162                 d6 ^= p2[6];                   << 
163                 d7 ^= p2[7];                   << 
164                 d0 ^= p3[0];                   << 
165                 d1 ^= p3[1];                   << 
166                 d2 ^= p3[2];                   << 
167                 d3 ^= p3[3];                   << 
168                 d4 ^= p3[4];                   << 
169                 d5 ^= p3[5];                   << 
170                 d6 ^= p3[6];                   << 
171                 d7 ^= p3[7];                   << 
172                 p1[0] = d0;     /* Store the r << 
173                 p1[1] = d1;                    << 
174                 p1[2] = d2;                    << 
175                 p1[3] = d3;                    << 
176                 p1[4] = d4;                    << 
177                 p1[5] = d5;                    << 
178                 p1[6] = d6;                    << 
179                 p1[7] = d7;                    << 
180                 p1 += 8;                       << 
181                 p2 += 8;                       << 
182                 p3 += 8;                       << 
183         } while (--lines > 0);                 << 
184 }                                              << 
185                                                << 
186 static void                                    << 
187 xor_32regs_4(unsigned long bytes, unsigned lon << 
188              const unsigned long * __restrict  << 
189              const unsigned long * __restrict  << 
190              const unsigned long * __restrict  << 
191 {                                              << 
192         long lines = bytes / (sizeof (long)) / << 
193                                                << 
194         do {                                   << 
195                 register long d0, d1, d2, d3,  << 
196                 d0 = p1[0];     /* Pull the st << 
197                 d1 = p1[1];     /*  ... in bur << 
198                 d2 = p1[2];                    << 
199                 d3 = p1[3];                    << 
200                 d4 = p1[4];                    << 
201                 d5 = p1[5];                    << 
202                 d6 = p1[6];                    << 
203                 d7 = p1[7];                    << 
204                 d0 ^= p2[0];                   << 
205                 d1 ^= p2[1];                   << 
206                 d2 ^= p2[2];                   << 
207                 d3 ^= p2[3];                   << 
208                 d4 ^= p2[4];                   << 
209                 d5 ^= p2[5];                   << 
210                 d6 ^= p2[6];                   << 
211                 d7 ^= p2[7];                   << 
212                 d0 ^= p3[0];                   << 
213                 d1 ^= p3[1];                   << 
214                 d2 ^= p3[2];                   << 
215                 d3 ^= p3[3];                   << 
216                 d4 ^= p3[4];                   << 
217                 d5 ^= p3[5];                   << 
218                 d6 ^= p3[6];                   << 
219                 d7 ^= p3[7];                   << 
220                 d0 ^= p4[0];                   << 
221                 d1 ^= p4[1];                   << 
222                 d2 ^= p4[2];                   << 
223                 d3 ^= p4[3];                   << 
224                 d4 ^= p4[4];                   << 
225                 d5 ^= p4[5];                   << 
226                 d6 ^= p4[6];                   << 
227                 d7 ^= p4[7];                   << 
228                 p1[0] = d0;     /* Store the r << 
229                 p1[1] = d1;                    << 
230                 p1[2] = d2;                    << 
231                 p1[3] = d3;                    << 
232                 p1[4] = d4;                    << 
233                 p1[5] = d5;                    << 
234                 p1[6] = d6;                    << 
235                 p1[7] = d7;                    << 
236                 p1 += 8;                       << 
237                 p2 += 8;                       << 
238                 p3 += 8;                       << 
239                 p4 += 8;                       << 
240         } while (--lines > 0);                 << 
241 }                                              << 
242                                                << 
243 static void                                    << 
244 xor_32regs_5(unsigned long bytes, unsigned lon << 
245              const unsigned long * __restrict  << 
246              const unsigned long * __restrict  << 
247              const unsigned long * __restrict  << 
248              const unsigned long * __restrict  << 
249 {                                              << 
250         long lines = bytes / (sizeof (long)) / << 
251                                                << 
252         do {                                   << 
253                 register long d0, d1, d2, d3,  << 
254                 d0 = p1[0];     /* Pull the st << 
255                 d1 = p1[1];     /*  ... in bur << 
256                 d2 = p1[2];                    << 
257                 d3 = p1[3];                    << 
258                 d4 = p1[4];                    << 
259                 d5 = p1[5];                    << 
260                 d6 = p1[6];                    << 
261                 d7 = p1[7];                    << 
262                 d0 ^= p2[0];                   << 
263                 d1 ^= p2[1];                   << 
264                 d2 ^= p2[2];                   << 
265                 d3 ^= p2[3];                   << 
266                 d4 ^= p2[4];                   << 
267                 d5 ^= p2[5];                   << 
268                 d6 ^= p2[6];                   << 
269                 d7 ^= p2[7];                   << 
270                 d0 ^= p3[0];                   << 
271                 d1 ^= p3[1];                   << 
272                 d2 ^= p3[2];                   << 
273                 d3 ^= p3[3];                   << 
274                 d4 ^= p3[4];                   << 
275                 d5 ^= p3[5];                   << 
276                 d6 ^= p3[6];                   << 
277                 d7 ^= p3[7];                   << 
278                 d0 ^= p4[0];                   << 
279                 d1 ^= p4[1];                   << 
280                 d2 ^= p4[2];                   << 
281                 d3 ^= p4[3];                   << 
282                 d4 ^= p4[4];                   << 
283                 d5 ^= p4[5];                   << 
284                 d6 ^= p4[6];                   << 
285                 d7 ^= p4[7];                   << 
286                 d0 ^= p5[0];                   << 
287                 d1 ^= p5[1];                   << 
288                 d2 ^= p5[2];                   << 
289                 d3 ^= p5[3];                   << 
290                 d4 ^= p5[4];                   << 
291                 d5 ^= p5[5];                   << 
292                 d6 ^= p5[6];                   << 
293                 d7 ^= p5[7];                   << 
294                 p1[0] = d0;     /* Store the r << 
295                 p1[1] = d1;                    << 
296                 p1[2] = d2;                    << 
297                 p1[3] = d3;                    << 
298                 p1[4] = d4;                    << 
299                 p1[5] = d5;                    << 
300                 p1[6] = d6;                    << 
301                 p1[7] = d7;                    << 
302                 p1 += 8;                       << 
303                 p2 += 8;                       << 
304                 p3 += 8;                       << 
305                 p4 += 8;                       << 
306                 p5 += 8;                       << 
307         } while (--lines > 0);                 << 
308 }                                              << 
309                                                << 
310 static void                                    << 
311 xor_8regs_p_2(unsigned long bytes, unsigned lo << 
312               const unsigned long * __restrict << 
313 {                                              << 
314         long lines = bytes / (sizeof (long)) / << 
315         prefetchw(p1);                         << 
316         prefetch(p2);                          << 
317                                                << 
318         do {                                   << 
319                 prefetchw(p1+8);               << 
320                 prefetch(p2+8);                << 
321  once_more:                                    << 
322                 p1[0] ^= p2[0];                << 
323                 p1[1] ^= p2[1];                << 
324                 p1[2] ^= p2[2];                << 
325                 p1[3] ^= p2[3];                << 
326                 p1[4] ^= p2[4];                << 
327                 p1[5] ^= p2[5];                << 
328                 p1[6] ^= p2[6];                << 
329                 p1[7] ^= p2[7];                << 
330                 p1 += 8;                       << 
331                 p2 += 8;                       << 
332         } while (--lines > 0);                 << 
333         if (lines == 0)                        << 
334                 goto once_more;                << 
335 }                                              << 
336                                                << 
337 static void                                    << 
338 xor_8regs_p_3(unsigned long bytes, unsigned lo << 
339               const unsigned long * __restrict << 
340               const unsigned long * __restrict << 
341 {                                              << 
342         long lines = bytes / (sizeof (long)) / << 
343         prefetchw(p1);                         << 
344         prefetch(p2);                          << 
345         prefetch(p3);                          << 
346                                                << 
347         do {                                   << 
348                 prefetchw(p1+8);               << 
349                 prefetch(p2+8);                << 
350                 prefetch(p3+8);                << 
351  once_more:                                    << 
352                 p1[0] ^= p2[0] ^ p3[0];        << 
353                 p1[1] ^= p2[1] ^ p3[1];        << 
354                 p1[2] ^= p2[2] ^ p3[2];        << 
355                 p1[3] ^= p2[3] ^ p3[3];        << 
356                 p1[4] ^= p2[4] ^ p3[4];        << 
357                 p1[5] ^= p2[5] ^ p3[5];        << 
358                 p1[6] ^= p2[6] ^ p3[6];        << 
359                 p1[7] ^= p2[7] ^ p3[7];        << 
360                 p1 += 8;                       << 
361                 p2 += 8;                       << 
362                 p3 += 8;                       << 
363         } while (--lines > 0);                 << 
364         if (lines == 0)                        << 
365                 goto once_more;                << 
366 }                                              << 
367                                                << 
368 static void                                    << 
369 xor_8regs_p_4(unsigned long bytes, unsigned lo << 
370               const unsigned long * __restrict << 
371               const unsigned long * __restrict << 
372               const unsigned long * __restrict << 
373 {                                              << 
374         long lines = bytes / (sizeof (long)) / << 
375                                                << 
376         prefetchw(p1);                         << 
377         prefetch(p2);                          << 
378         prefetch(p3);                          << 
379         prefetch(p4);                          << 
380                                                << 
381         do {                                   << 
382                 prefetchw(p1+8);               << 
383                 prefetch(p2+8);                << 
384                 prefetch(p3+8);                << 
385                 prefetch(p4+8);                << 
386  once_more:                                    << 
387                 p1[0] ^= p2[0] ^ p3[0] ^ p4[0] << 
388                 p1[1] ^= p2[1] ^ p3[1] ^ p4[1] << 
389                 p1[2] ^= p2[2] ^ p3[2] ^ p4[2] << 
390                 p1[3] ^= p2[3] ^ p3[3] ^ p4[3] << 
391                 p1[4] ^= p2[4] ^ p3[4] ^ p4[4] << 
392                 p1[5] ^= p2[5] ^ p3[5] ^ p4[5] << 
393                 p1[6] ^= p2[6] ^ p3[6] ^ p4[6] << 
394                 p1[7] ^= p2[7] ^ p3[7] ^ p4[7] << 
395                 p1 += 8;                       << 
396                 p2 += 8;                       << 
397                 p3 += 8;                       << 
398                 p4 += 8;                       << 
399         } while (--lines > 0);                 << 
400         if (lines == 0)                        << 
401                 goto once_more;                << 
402 }                                              << 
403                                                << 
404 static void                                    << 
405 xor_8regs_p_5(unsigned long bytes, unsigned lo << 
406               const unsigned long * __restrict << 
407               const unsigned long * __restrict << 
408               const unsigned long * __restrict << 
409               const unsigned long * __restrict << 
410 {                                              << 
411         long lines = bytes / (sizeof (long)) / << 
412                                                << 
413         prefetchw(p1);                         << 
414         prefetch(p2);                          << 
415         prefetch(p3);                          << 
416         prefetch(p4);                          << 
417         prefetch(p5);                          << 
418                                                << 
419         do {                                   << 
420                 prefetchw(p1+8);               << 
421                 prefetch(p2+8);                << 
422                 prefetch(p3+8);                << 
423                 prefetch(p4+8);                << 
424                 prefetch(p5+8);                << 
425  once_more:                                    << 
426                 p1[0] ^= p2[0] ^ p3[0] ^ p4[0] << 
427                 p1[1] ^= p2[1] ^ p3[1] ^ p4[1] << 
428                 p1[2] ^= p2[2] ^ p3[2] ^ p4[2] << 
429                 p1[3] ^= p2[3] ^ p3[3] ^ p4[3] << 
430                 p1[4] ^= p2[4] ^ p3[4] ^ p4[4] << 
431                 p1[5] ^= p2[5] ^ p3[5] ^ p4[5] << 
432                 p1[6] ^= p2[6] ^ p3[6] ^ p4[6] << 
433                 p1[7] ^= p2[7] ^ p3[7] ^ p4[7] << 
434                 p1 += 8;                       << 
435                 p2 += 8;                       << 
436                 p3 += 8;                       << 
437                 p4 += 8;                       << 
438                 p5 += 8;                       << 
439         } while (--lines > 0);                 << 
440         if (lines == 0)                        << 
441                 goto once_more;                << 
442 }                                              << 
443                                                << 
444 static void                                    << 
445 xor_32regs_p_2(unsigned long bytes, unsigned l << 
446                const unsigned long * __restric << 
447 {                                              << 
448         long lines = bytes / (sizeof (long)) / << 
449                                                << 
450         prefetchw(p1);                         << 
451         prefetch(p2);                          << 
452                                                << 
453         do {                                   << 
454                 register long d0, d1, d2, d3,  << 
455                                                << 
456                 prefetchw(p1+8);               << 
457                 prefetch(p2+8);                << 
458  once_more:                                    << 
459                 d0 = p1[0];     /* Pull the st << 
460                 d1 = p1[1];     /*  ... in bur << 
461                 d2 = p1[2];                    << 
462                 d3 = p1[3];                    << 
463                 d4 = p1[4];                    << 
464                 d5 = p1[5];                    << 
465                 d6 = p1[6];                    << 
466                 d7 = p1[7];                    << 
467                 d0 ^= p2[0];                   << 
468                 d1 ^= p2[1];                   << 
469                 d2 ^= p2[2];                   << 
470                 d3 ^= p2[3];                   << 
471                 d4 ^= p2[4];                   << 
472                 d5 ^= p2[5];                   << 
473                 d6 ^= p2[6];                   << 
474                 d7 ^= p2[7];                   << 
475                 p1[0] = d0;     /* Store the r << 
476                 p1[1] = d1;                    << 
477                 p1[2] = d2;                    << 
478                 p1[3] = d3;                    << 
479                 p1[4] = d4;                    << 
480                 p1[5] = d5;                    << 
481                 p1[6] = d6;                    << 
482                 p1[7] = d7;                    << 
483                 p1 += 8;                       << 
484                 p2 += 8;                       << 
485         } while (--lines > 0);                 << 
486         if (lines == 0)                        << 
487                 goto once_more;                << 
488 }                                              << 
489                                                << 
490 static void                                    << 
491 xor_32regs_p_3(unsigned long bytes, unsigned l << 
492                const unsigned long * __restric << 
493                const unsigned long * __restric << 
494 {                                              << 
495         long lines = bytes / (sizeof (long)) / << 
496                                                << 
497         prefetchw(p1);                         << 
498         prefetch(p2);                          << 
499         prefetch(p3);                          << 
500                                                << 
501         do {                                   << 
502                 register long d0, d1, d2, d3,  << 
503                                                << 
504                 prefetchw(p1+8);               << 
505                 prefetch(p2+8);                << 
506                 prefetch(p3+8);                << 
507  once_more:                                    << 
508                 d0 = p1[0];     /* Pull the st << 
509                 d1 = p1[1];     /*  ... in bur << 
510                 d2 = p1[2];                    << 
511                 d3 = p1[3];                    << 
512                 d4 = p1[4];                    << 
513                 d5 = p1[5];                    << 
514                 d6 = p1[6];                    << 
515                 d7 = p1[7];                    << 
516                 d0 ^= p2[0];                   << 
517                 d1 ^= p2[1];                   << 
518                 d2 ^= p2[2];                   << 
519                 d3 ^= p2[3];                   << 
520                 d4 ^= p2[4];                   << 
521                 d5 ^= p2[5];                   << 
522                 d6 ^= p2[6];                   << 
523                 d7 ^= p2[7];                   << 
524                 d0 ^= p3[0];                   << 
525                 d1 ^= p3[1];                   << 
526                 d2 ^= p3[2];                   << 
527                 d3 ^= p3[3];                   << 
528                 d4 ^= p3[4];                   << 
529                 d5 ^= p3[5];                   << 
530                 d6 ^= p3[6];                   << 
531                 d7 ^= p3[7];                   << 
532                 p1[0] = d0;     /* Store the r << 
533                 p1[1] = d1;                    << 
534                 p1[2] = d2;                    << 
535                 p1[3] = d3;                    << 
536                 p1[4] = d4;                    << 
537                 p1[5] = d5;                    << 
538                 p1[6] = d6;                    << 
539                 p1[7] = d7;                    << 
540                 p1 += 8;                       << 
541                 p2 += 8;                       << 
542                 p3 += 8;                       << 
543         } while (--lines > 0);                 << 
544         if (lines == 0)                        << 
545                 goto once_more;                << 
546 }                                              << 
547                                                << 
548 static void                                    << 
549 xor_32regs_p_4(unsigned long bytes, unsigned l << 
550                const unsigned long * __restric << 
551                const unsigned long * __restric << 
552                const unsigned long * __restric << 
553 {                                              << 
554         long lines = bytes / (sizeof (long)) / << 
555                                                << 
556         prefetchw(p1);                         << 
557         prefetch(p2);                          << 
558         prefetch(p3);                          << 
559         prefetch(p4);                          << 
560                                                << 
561         do {                                   << 
562                 register long d0, d1, d2, d3,  << 
563                                                << 
564                 prefetchw(p1+8);               << 
565                 prefetch(p2+8);                << 
566                 prefetch(p3+8);                << 
567                 prefetch(p4+8);                << 
568  once_more:                                    << 
569                 d0 = p1[0];     /* Pull the st << 
570                 d1 = p1[1];     /*  ... in bur << 
571                 d2 = p1[2];                    << 
572                 d3 = p1[3];                    << 
573                 d4 = p1[4];                    << 
574                 d5 = p1[5];                    << 
575                 d6 = p1[6];                    << 
576                 d7 = p1[7];                    << 
577                 d0 ^= p2[0];                   << 
578                 d1 ^= p2[1];                   << 
579                 d2 ^= p2[2];                   << 
580                 d3 ^= p2[3];                   << 
581                 d4 ^= p2[4];                   << 
582                 d5 ^= p2[5];                   << 
583                 d6 ^= p2[6];                   << 
584                 d7 ^= p2[7];                   << 
585                 d0 ^= p3[0];                   << 
586                 d1 ^= p3[1];                   << 
587                 d2 ^= p3[2];                   << 
588                 d3 ^= p3[3];                   << 
589                 d4 ^= p3[4];                   << 
590                 d5 ^= p3[5];                   << 
591                 d6 ^= p3[6];                   << 
592                 d7 ^= p3[7];                   << 
593                 d0 ^= p4[0];                   << 
594                 d1 ^= p4[1];                   << 
595                 d2 ^= p4[2];                   << 
596                 d3 ^= p4[3];                   << 
597                 d4 ^= p4[4];                   << 
598                 d5 ^= p4[5];                   << 
599                 d6 ^= p4[6];                   << 
600                 d7 ^= p4[7];                   << 
601                 p1[0] = d0;     /* Store the r << 
602                 p1[1] = d1;                    << 
603                 p1[2] = d2;                    << 
604                 p1[3] = d3;                    << 
605                 p1[4] = d4;                    << 
606                 p1[5] = d5;                    << 
607                 p1[6] = d6;                    << 
608                 p1[7] = d7;                    << 
609                 p1 += 8;                       << 
610                 p2 += 8;                       << 
611                 p3 += 8;                       << 
612                 p4 += 8;                       << 
613         } while (--lines > 0);                 << 
614         if (lines == 0)                        << 
615                 goto once_more;                << 
616 }                                              << 
617                                                << 
618 static void                                    << 
619 xor_32regs_p_5(unsigned long bytes, unsigned l << 
620                const unsigned long * __restric << 
621                const unsigned long * __restric << 
622                const unsigned long * __restric << 
623                const unsigned long * __restric << 
624 {                                              << 
625         long lines = bytes / (sizeof (long)) / << 
626                                                << 
627         prefetchw(p1);                         << 
628         prefetch(p2);                          << 
629         prefetch(p3);                          << 
630         prefetch(p4);                          << 
631         prefetch(p5);                          << 
632                                                << 
633         do {                                   << 
634                 register long d0, d1, d2, d3,  << 
635                                                << 
636                 prefetchw(p1+8);               << 
637                 prefetch(p2+8);                << 
638                 prefetch(p3+8);                << 
639                 prefetch(p4+8);                << 
640                 prefetch(p5+8);                << 
641  once_more:                                    << 
642                 d0 = p1[0];     /* Pull the st << 
643                 d1 = p1[1];     /*  ... in bur << 
644                 d2 = p1[2];                    << 
645                 d3 = p1[3];                    << 
646                 d4 = p1[4];                    << 
647                 d5 = p1[5];                    << 
648                 d6 = p1[6];                    << 
649                 d7 = p1[7];                    << 
650                 d0 ^= p2[0];                   << 
651                 d1 ^= p2[1];                   << 
652                 d2 ^= p2[2];                   << 
653                 d3 ^= p2[3];                   << 
654                 d4 ^= p2[4];                   << 
655                 d5 ^= p2[5];                   << 
656                 d6 ^= p2[6];                   << 
657                 d7 ^= p2[7];                   << 
658                 d0 ^= p3[0];                   << 
659                 d1 ^= p3[1];                   << 
660                 d2 ^= p3[2];                   << 
661                 d3 ^= p3[3];                   << 
662                 d4 ^= p3[4];                   << 
663                 d5 ^= p3[5];                   << 
664                 d6 ^= p3[6];                   << 
665                 d7 ^= p3[7];                   << 
666                 d0 ^= p4[0];                   << 
667                 d1 ^= p4[1];                   << 
668                 d2 ^= p4[2];                   << 
669                 d3 ^= p4[3];                   << 
670                 d4 ^= p4[4];                   << 
671                 d5 ^= p4[5];                   << 
672                 d6 ^= p4[6];                   << 
673                 d7 ^= p4[7];                   << 
674                 d0 ^= p5[0];                   << 
675                 d1 ^= p5[1];                   << 
676                 d2 ^= p5[2];                   << 
677                 d3 ^= p5[3];                   << 
678                 d4 ^= p5[4];                   << 
679                 d5 ^= p5[5];                   << 
680                 d6 ^= p5[6];                   << 
681                 d7 ^= p5[7];                   << 
682                 p1[0] = d0;     /* Store the r << 
683                 p1[1] = d1;                    << 
684                 p1[2] = d2;                    << 
685                 p1[3] = d3;                    << 
686                 p1[4] = d4;                    << 
687                 p1[5] = d5;                    << 
688                 p1[6] = d6;                    << 
689                 p1[7] = d7;                    << 
690                 p1 += 8;                       << 
691                 p2 += 8;                       << 
692                 p3 += 8;                       << 
693                 p4 += 8;                       << 
694                 p5 += 8;                       << 
695         } while (--lines > 0);                 << 
696         if (lines == 0)                        << 
697                 goto once_more;                << 
698 }                                              << 
699                                                << 
700 static struct xor_block_template xor_block_8re << 
701         .name = "8regs",                       << 
702         .do_2 = xor_8regs_2,                   << 
703         .do_3 = xor_8regs_3,                   << 
704         .do_4 = xor_8regs_4,                   << 
705         .do_5 = xor_8regs_5,                   << 
706 };                                             << 
707                                                << 
708 static struct xor_block_template xor_block_32r << 
709         .name = "32regs",                      << 
710         .do_2 = xor_32regs_2,                  << 
711         .do_3 = xor_32regs_3,                  << 
712         .do_4 = xor_32regs_4,                  << 
713         .do_5 = xor_32regs_5,                  << 
714 };                                             << 
715                                                << 
716 static struct xor_block_template xor_block_8re << 
717         .name = "8regs_prefetch",              << 
718         .do_2 = xor_8regs_p_2,                 << 
719         .do_3 = xor_8regs_p_3,                 << 
720         .do_4 = xor_8regs_p_4,                 << 
721         .do_5 = xor_8regs_p_5,                 << 
722 };                                             << 
723                                                << 
724 static struct xor_block_template xor_block_32r << 
725         .name = "32regs_prefetch",             << 
726         .do_2 = xor_32regs_p_2,                << 
727         .do_3 = xor_32regs_p_3,                << 
728         .do_4 = xor_32regs_p_4,                << 
729         .do_5 = xor_32regs_p_5,                << 
730 };                                             << 
731                                                << 
732 #define XOR_TRY_TEMPLATES                      << 
733         do {                                   << 
734                 xor_speed(&xor_block_8regs);   << 
735                 xor_speed(&xor_block_8regs_p); << 
736                 xor_speed(&xor_block_32regs);  << 
737                 xor_speed(&xor_block_32regs_p) << 
738         } while (0)                            << 
739                                                     2 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

sflogo.php