Line data Source code
1 : /* SPDX-License-Identifier: Apache-2.0
2 : * Copyright(c) 2021 Damjan Marion
3 : */
4 :
5 : #ifndef included_clib_memcpy_x86_64_h
6 : #define included_clib_memcpy_x86_64_h
7 : #ifdef __x86_64__
8 :
9 : #include <vppinfra/clib.h>
10 : #include <vppinfra/warnings.h>
11 : #include <stdio.h>
12 :
13 : /* clang-format off */
14 : WARN_OFF (stringop-overflow)
15 : /* clang-format on */
16 :
17 : static_always_inline void
18 136854510 : clib_memcpy1 (void *d, void *s)
19 : {
20 136854510 : *(u8 *) d = *(u8 *) s;
21 136854510 : }
22 :
23 : static_always_inline void
24 267098148 : clib_memcpy2 (void *d, void *s)
25 : {
26 267098148 : *(u16u *) d = *(u16u *) s;
27 267098148 : }
28 :
29 : static_always_inline void
30 242883048 : clib_memcpy4 (void *d, void *s)
31 : {
32 242883048 : *(u32u *) d = *(u32u *) s;
33 242883048 : }
34 :
35 : static_always_inline void
36 2353535115 : clib_memcpy8 (void *d, void *s)
37 : {
38 2353535115 : *(u64u *) d = *(u64u *) s;
39 2353535115 : }
40 :
41 : static_always_inline void
42 558140879 : clib_memcpy16 (void *d, void *s)
43 : {
44 : #ifdef CLIB_HAVE_VEC128
45 558140879 : *(u8x16u *) d = *(u8x16u *) s;
46 : #else
47 : clib_memcpy8 (d, s);
48 : clib_memcpy8 (d + 8, s + 8);
49 : #endif
50 558140879 : }
51 :
52 : #ifdef CLIB_HAVE_VEC256
53 : static_always_inline void
54 : clib_memcpy32 (void *d, void *s)
55 : {
56 : *(u8x32u *) d = *(u8x32u *) s;
57 : }
58 : #endif
59 :
60 : #ifdef CLIB_HAVE_VEC512
61 : static_always_inline void
62 : clib_memcpy64 (void *d, void *s)
63 : {
64 : *(u8x64u *) d = *(u8x64u *) s;
65 : }
66 : #endif
67 :
68 : static_always_inline void
69 : clib_memcpy_const_le32 (u8 *dst, u8 *src, size_t n)
70 : {
71 : switch (n)
72 : {
73 : case 1:
74 : clib_memcpy1 (dst, src);
75 : break;
76 : case 2:
77 : clib_memcpy2 (dst, src);
78 : break;
79 : case 3:
80 : clib_memcpy2 (dst, src);
81 : clib_memcpy1 (dst + 2, src + 2);
82 : break;
83 : case 4:
84 : clib_memcpy4 (dst, src);
85 : break;
86 : case 5:
87 : clib_memcpy4 (dst, src);
88 : clib_memcpy1 (dst + 4, src + 4);
89 : break;
90 : case 6:
91 : clib_memcpy4 (dst, src);
92 : clib_memcpy2 (dst + 4, src + 4);
93 : break;
94 : case 7:
95 : clib_memcpy4 (dst, src);
96 : clib_memcpy4 (dst + 3, src + 3);
97 : break;
98 : case 8:
99 : clib_memcpy8 (dst, src);
100 : break;
101 : case 9:
102 : clib_memcpy8 (dst, src);
103 : clib_memcpy1 (dst + 8, src + 8);
104 : break;
105 : case 10:
106 : clib_memcpy8 (dst, src);
107 : clib_memcpy2 (dst + 8, src + 8);
108 : break;
109 : case 11:
110 : case 12:
111 : clib_memcpy8 (dst, src);
112 : clib_memcpy4 (dst + n - 4, src + n - 4);
113 : break;
114 : case 13:
115 : case 14:
116 : case 15:
117 : clib_memcpy8 (dst, src);
118 : clib_memcpy8 (dst + n - 8, src + n - 8);
119 : break;
120 : case 16:
121 : clib_memcpy16 (dst, src);
122 : break;
123 : case 17:
124 : clib_memcpy16 (dst, src);
125 : clib_memcpy1 (dst + 16, src + 16);
126 : break;
127 : case 18:
128 : clib_memcpy16 (dst, src);
129 : clib_memcpy2 (dst + 16, src + 16);
130 : break;
131 : case 20:
132 : clib_memcpy16 (dst, src);
133 : clib_memcpy4 (dst + 16, src + 16);
134 : break;
135 : case 24:
136 : clib_memcpy16 (dst, src);
137 : clib_memcpy8 (dst + 16, src + 16);
138 : break;
139 : default:
140 : clib_memcpy16 (dst, src);
141 : clib_memcpy16 (dst + n - 16, src + n - 16);
142 : break;
143 : }
144 : }
145 :
146 : static_always_inline void
147 : clib_memcpy_const_le64 (u8 *dst, u8 *src, size_t n)
148 : {
149 : if (n < 32)
150 : {
151 : clib_memcpy_const_le32 (dst, src, n);
152 : return;
153 : }
154 :
155 : #if defined(CLIB_HAVE_VEC256)
156 : switch (n)
157 : {
158 : case 32:
159 : clib_memcpy32 (dst, src);
160 : break;
161 : case 33:
162 : clib_memcpy32 (dst, src);
163 : clib_memcpy1 (dst + 32, src + 32);
164 : break;
165 : case 34:
166 : clib_memcpy32 (dst, src);
167 : clib_memcpy2 (dst + 32, src + 32);
168 : break;
169 : case 36:
170 : clib_memcpy32 (dst, src);
171 : clib_memcpy4 (dst + 32, src + 32);
172 : break;
173 : case 40:
174 : clib_memcpy32 (dst, src);
175 : clib_memcpy8 (dst + 32, src + 32);
176 : break;
177 : case 48:
178 : clib_memcpy32 (dst, src);
179 : clib_memcpy16 (dst + 32, src + 32);
180 : break;
181 : default:
182 : clib_memcpy32 (dst, src);
183 : clib_memcpy32 (dst + n - 32, src + n - 32);
184 : break;
185 : }
186 : #else
187 : while (n > 31)
188 : {
189 : clib_memcpy16 (dst, src);
190 : clib_memcpy16 (dst + 16, src + 16);
191 : dst += 32;
192 : src += 32;
193 : n -= 32;
194 : }
195 : clib_memcpy_const_le32 (dst, src, n);
196 : #endif
197 : }
198 :
199 : static_always_inline void
200 : clib_memcpy_x86_64_const (u8 *dst, u8 *src, size_t n)
201 : {
202 : #if defined(CLIB_HAVE_VEC512)
203 : while (n > 128)
204 : {
205 : clib_memcpy64 (dst, src);
206 : dst += 64;
207 : src += 64;
208 : n -= 64;
209 : }
210 :
211 : if (n < 64)
212 : {
213 : clib_memcpy_const_le64 (dst, src, n);
214 : return;
215 : }
216 :
217 : switch (n)
218 : {
219 : case 64:
220 : clib_memcpy64 (dst, src);
221 : break;
222 : case 65:
223 : clib_memcpy64 (dst, src);
224 : clib_memcpy1 (dst + 64, src + 64);
225 : break;
226 : case 66:
227 : clib_memcpy64 (dst, src);
228 : clib_memcpy2 (dst + 64, src + 64);
229 : break;
230 : case 68:
231 : clib_memcpy64 (dst, src);
232 : clib_memcpy4 (dst + 64, src + 64);
233 : break;
234 : case 72:
235 : clib_memcpy64 (dst, src);
236 : clib_memcpy8 (dst + 64, src + 64);
237 : break;
238 : case 80:
239 : clib_memcpy64 (dst, src);
240 : clib_memcpy16 (dst + 64, src + 64);
241 : break;
242 : case 96:
243 : clib_memcpy64 (dst, src);
244 : clib_memcpy32 (dst + 64, src + 64);
245 : break;
246 : default:
247 : clib_memcpy64 (dst, src);
248 : clib_memcpy64 (dst + n - 64, src + n - 64);
249 : break;
250 : }
251 : #elif defined(CLIB_HAVE_VEC256)
252 : while (n > 64)
253 : {
254 : clib_memcpy32 (dst, src);
255 : dst += 32;
256 : src += 32;
257 : n -= 32;
258 : }
259 : clib_memcpy_const_le64 (dst, src, n);
260 : #else
261 : while (n > 32)
262 : {
263 : clib_memcpy16 (dst, src);
264 : dst += 16;
265 : src += 16;
266 : n -= 16;
267 : }
268 : clib_memcpy_const_le32 (dst, src, n);
269 : #endif
270 : }
271 :
272 : static_always_inline void *
273 2176216384 : clib_memcpy_x86_64 (void *restrict dst, const void *restrict src, size_t n)
274 : {
275 2176216384 : u8 *d = (u8 *) dst, *s = (u8 *) src;
276 :
277 2176216384 : if (n == 0)
278 6517501 : return dst;
279 :
280 : if (COMPILE_TIME_CONST (n))
281 : {
282 : if (n)
283 : clib_memcpy_x86_64_const (d, s, n);
284 : return dst;
285 : }
286 :
287 2169698885 : if (n <= 32)
288 : {
289 : #if defined(CLIB_HAVE_VEC256_MASK_LOAD_STORE)
290 127708937 : u32 mask = pow2_mask (n);
291 127708935 : u8x32_mask_store (u8x32_mask_load_zero (s, mask), d, mask);
292 : #else
293 1847677799 : if (PREDICT_TRUE (n >= 16))
294 : {
295 279071044 : clib_memcpy16 (d, s);
296 279071021 : clib_memcpy16 (d + n - 16, s + n - 16);
297 : }
298 1568606599 : else if (PREDICT_TRUE (n >= 8))
299 : {
300 1176767406 : clib_memcpy8 (d, s);
301 1176767405 : clib_memcpy8 (d + n - 8, s + n - 8);
302 : }
303 391845260 : else if (PREDICT_TRUE (n >= 4))
304 : {
305 121441674 : clib_memcpy4 (d, s);
306 121441674 : clib_memcpy4 (d + n - 4, s + n - 4);
307 : }
308 270402586 : else if (PREDICT_TRUE (n > 1))
309 : {
310 133548974 : clib_memcpy2 (d, s);
311 133548974 : clib_memcpy2 (d + n - 2, s + n - 2);
312 : }
313 : else
314 136854512 : clib_memcpy1 (d, s);
315 : #endif
316 : }
317 : #ifdef CLIB_HAVE_VEC512
318 : else
319 : {
320 : u8x64 v0, v1, v2, v3;
321 0 : u64 final_off, nr, off = 64;
322 :
323 0 : if (n <= 64)
324 : {
325 0 : n -= 32;
326 0 : u8x32_store_unaligned (u8x32_load_unaligned (s), d);
327 0 : u8x32_store_unaligned (u8x32_load_unaligned (s + n), d + n);
328 0 : return dst;
329 : }
330 :
331 0 : u8x64_store_unaligned (u8x64_load_unaligned (s), d);
332 :
333 0 : if (n <= 128)
334 0 : goto done2;
335 :
336 0 : if (n <= 192)
337 0 : goto one;
338 :
339 0 : if (n <= 512 + 64)
340 : {
341 0 : nr = round_pow2 (n - 128, 64);
342 0 : goto last;
343 : }
344 :
345 0 : off -= ((u64) d) & 0x3f;
346 0 : nr = round_pow2 (n - off - 64, 64);
347 0 : final_off = (nr & ~(u64) 0x1ff) + off;
348 :
349 0 : more:
350 0 : v0 = u8x64_load_unaligned (s + off + 0x000);
351 0 : v1 = u8x64_load_unaligned (s + off + 0x040);
352 0 : v2 = u8x64_load_unaligned (s + off + 0x080);
353 0 : v3 = u8x64_load_unaligned (s + off + 0x0c0);
354 0 : u8x64_store_unaligned (v0, d + off + 0x000);
355 0 : u8x64_store_unaligned (v1, d + off + 0x040);
356 0 : u8x64_store_unaligned (v2, d + off + 0x080);
357 0 : u8x64_store_unaligned (v3, d + off + 0x0c0);
358 0 : v0 = u8x64_load_unaligned (s + off + 0x100);
359 0 : v1 = u8x64_load_unaligned (s + off + 0x140);
360 0 : v2 = u8x64_load_unaligned (s + off + 0x180);
361 0 : v3 = u8x64_load_unaligned (s + off + 0x1c0);
362 0 : u8x64_store_unaligned (v0, d + off + 0x100);
363 0 : u8x64_store_unaligned (v1, d + off + 0x140);
364 0 : u8x64_store_unaligned (v2, d + off + 0x180);
365 0 : u8x64_store_unaligned (v3, d + off + 0x1c0);
366 0 : off += 512;
367 0 : if (off != final_off)
368 0 : goto more;
369 :
370 0 : if ((nr & 0x1ff) == 0)
371 0 : goto done2;
372 :
373 0 : last:
374 0 : if (PREDICT_TRUE (nr & 256))
375 : {
376 0 : v0 = u8x64_load_unaligned (s + off + 0x000);
377 0 : v1 = u8x64_load_unaligned (s + off + 0x040);
378 0 : v2 = u8x64_load_unaligned (s + off + 0x080);
379 0 : v3 = u8x64_load_unaligned (s + off + 0x0c0);
380 0 : u8x64_store_unaligned (v0, d + off + 0x000);
381 0 : u8x64_store_unaligned (v1, d + off + 0x040);
382 0 : u8x64_store_unaligned (v2, d + off + 0x080);
383 0 : u8x64_store_unaligned (v3, d + off + 0x0c0);
384 0 : off += 256;
385 : }
386 0 : if (PREDICT_TRUE (nr & 128))
387 : {
388 0 : v0 = u8x64_load_unaligned (s + off + 0x000);
389 0 : v1 = u8x64_load_unaligned (s + off + 0x040);
390 0 : u8x64_store_unaligned (v0, d + off + 0x000);
391 0 : u8x64_store_unaligned (v1, d + off + 0x040);
392 0 : off += 128;
393 : }
394 0 : if (PREDICT_TRUE (nr & 64))
395 : {
396 0 : one:
397 0 : u8x64_store_unaligned (u8x64_load_unaligned (s + off), d + off);
398 : }
399 0 : done2:
400 0 : u8x64_store_unaligned (u8x64_load_unaligned (s + n - 64), d + n - 64);
401 : }
402 0 : return dst;
403 : #elif defined(CLIB_HAVE_VEC256)
404 : else
405 : {
406 : u8x32 v0, v1, v2, v3;
407 87090489 : u64 final_off, nr, off = 32;
408 :
409 87090489 : u8x32_store_unaligned (u8x32_load_unaligned (s), d);
410 :
411 87090520 : if (n <= 64)
412 741456 : goto done2;
413 :
414 86349151 : if (n <= 96)
415 8838314 : goto one;
416 :
417 77510748 : if (n <= 256 + 32)
418 : {
419 471326 : nr = round_pow2 (n - 64, 32);
420 471326 : goto last;
421 : }
422 :
423 77039425 : off -= ((u64) d) & 0x1f;
424 77039425 : nr = round_pow2 (n - off - 32, 32);
425 77039425 : final_off = (nr & ~(u64) 0xff) + off;
426 :
427 615707220 : more:
428 615707220 : v0 = u8x32_load_unaligned (s + off + 0x00);
429 615707220 : v1 = u8x32_load_unaligned (s + off + 0x20);
430 615707220 : v2 = u8x32_load_unaligned (s + off + 0x40);
431 615707220 : v3 = u8x32_load_unaligned (s + off + 0x60);
432 615707220 : u8x32_store_unaligned (v0, d + off + 0x00);
433 615707220 : u8x32_store_unaligned (v1, d + off + 0x20);
434 615707220 : u8x32_store_unaligned (v2, d + off + 0x40);
435 615707220 : u8x32_store_unaligned (v3, d + off + 0x60);
436 615707220 : v0 = u8x32_load_unaligned (s + off + 0x80);
437 615707220 : v1 = u8x32_load_unaligned (s + off + 0xa0);
438 615707220 : v2 = u8x32_load_unaligned (s + off + 0xc0);
439 615707220 : v3 = u8x32_load_unaligned (s + off + 0xe0);
440 615707220 : u8x32_store_unaligned (v0, d + off + 0x80);
441 615707220 : u8x32_store_unaligned (v1, d + off + 0xa0);
442 615707220 : u8x32_store_unaligned (v2, d + off + 0xc0);
443 615707220 : u8x32_store_unaligned (v3, d + off + 0xe0);
444 615707220 : off += 256;
445 615707220 : if (off != final_off)
446 538667285 : goto more;
447 :
448 77039425 : if ((nr & 0xff) == 0)
449 2502041 : goto done2;
450 :
451 74537401 : last:
452 75008724 : if (PREDICT_TRUE (nr & 128))
453 : {
454 72934216 : v0 = u8x32_load_unaligned (s + off + 0x00);
455 72934216 : v1 = u8x32_load_unaligned (s + off + 0x20);
456 72934216 : v2 = u8x32_load_unaligned (s + off + 0x40);
457 72934216 : v3 = u8x32_load_unaligned (s + off + 0x60);
458 72934216 : u8x32_store_unaligned (v0, d + off + 0x00);
459 72934216 : u8x32_store_unaligned (v1, d + off + 0x20);
460 72934216 : u8x32_store_unaligned (v2, d + off + 0x40);
461 72934216 : u8x32_store_unaligned (v3, d + off + 0x60);
462 72934216 : off += 128;
463 : }
464 75008724 : if (PREDICT_TRUE (nr & 64))
465 : {
466 70979685 : v0 = u8x32_load_unaligned (s + off + 0x00);
467 70979684 : v1 = u8x32_load_unaligned (s + off + 0x20);
468 70979684 : u8x32_store_unaligned (v0, d + off + 0x00);
469 70979685 : u8x32_store_unaligned (v1, d + off + 0x20);
470 70979684 : off += 64;
471 : }
472 75008723 : if (PREDICT_TRUE (nr & 32))
473 : {
474 31551516 : one:
475 40389830 : u8x32_store_unaligned (u8x32_load_unaligned (s + off), d + off);
476 : }
477 43457262 : done2:
478 87090519 : u8x32_store_unaligned (u8x32_load_unaligned (s + n - 32), d + n - 32);
479 : }
480 214799507 : return dst;
481 : #elif defined(CLIB_HAVE_VEC128)
482 : else
483 : {
484 : u8x16 v0, v1, v2, v3;
485 107221637 : u64 final_off, nr, off = 32;
486 :
487 : if (0 && n > 389)
488 : {
489 : __builtin_memcpy (d, s, n);
490 : return dst;
491 : }
492 :
493 107221637 : u8x16_store_unaligned (u8x16_load_unaligned (s), d);
494 107207356 : u8x16_store_unaligned (u8x16_load_unaligned (s + 16), d + 16);
495 :
496 107331279 : if (n <= 48)
497 15822524 : goto done2;
498 :
499 91508743 : if (n <= 64)
500 9770297 : goto one;
501 :
502 81738453 : if (n <= 256 + 32)
503 : {
504 11078001 : nr = round_pow2 (n - 48, 16);
505 11078012 : goto last;
506 : }
507 :
508 70660441 : off -= ((u64) d) & 0x0f;
509 70660441 : nr = round_pow2 (n - off - 16, 16);
510 70672509 : final_off = (nr & ~(u64) 0xff) + off;
511 :
512 907188896 : more:
513 907188896 : v0 = u8x16_load_unaligned (s + off + 0x00);
514 907170626 : v1 = u8x16_load_unaligned (s + off + 0x10);
515 907164956 : v2 = u8x16_load_unaligned (s + off + 0x20);
516 907162296 : v3 = u8x16_load_unaligned (s + off + 0x30);
517 907161646 : u8x16_store_unaligned (v0, d + off + 0x00);
518 907163636 : u8x16_store_unaligned (v1, d + off + 0x10);
519 907168176 : u8x16_store_unaligned (v2, d + off + 0x20);
520 907168246 : u8x16_store_unaligned (v3, d + off + 0x30);
521 907169606 : v0 = u8x16_load_unaligned (s + off + 0x40);
522 907168246 : v1 = u8x16_load_unaligned (s + off + 0x50);
523 907167476 : v2 = u8x16_load_unaligned (s + off + 0x60);
524 907165726 : v3 = u8x16_load_unaligned (s + off + 0x70);
525 907163916 : u8x16_store_unaligned (v0, d + off + 0x40);
526 907163506 : u8x16_store_unaligned (v1, d + off + 0x50);
527 907160896 : u8x16_store_unaligned (v2, d + off + 0x60);
528 907158356 : u8x16_store_unaligned (v3, d + off + 0x70);
529 907157136 : v0 = u8x16_load_unaligned (s + off + 0x80);
530 907155686 : v1 = u8x16_load_unaligned (s + off + 0x90);
531 907155446 : v2 = u8x16_load_unaligned (s + off + 0xa0);
532 907155656 : v3 = u8x16_load_unaligned (s + off + 0xb0);
533 907155456 : u8x16_store_unaligned (v0, d + off + 0x80);
534 907156126 : u8x16_store_unaligned (v1, d + off + 0x90);
535 907156476 : u8x16_store_unaligned (v2, d + off + 0xa0);
536 907156916 : u8x16_store_unaligned (v3, d + off + 0xb0);
537 907158036 : v0 = u8x16_load_unaligned (s + off + 0xc0);
538 907156696 : v1 = u8x16_load_unaligned (s + off + 0xd0);
539 907154116 : v2 = u8x16_load_unaligned (s + off + 0xe0);
540 907151566 : v3 = u8x16_load_unaligned (s + off + 0xf0);
541 907148816 : u8x16_store_unaligned (v0, d + off + 0xc0);
542 907147836 : u8x16_store_unaligned (v1, d + off + 0xd0);
543 907145516 : u8x16_store_unaligned (v2, d + off + 0xe0);
544 907143576 : u8x16_store_unaligned (v3, d + off + 0xf0);
545 907175896 : off += 256;
546 907175896 : if (off != final_off)
547 836517056 : goto more;
548 :
549 70659479 : if ((nr & 0xff) == 0)
550 868922 : goto done2;
551 :
552 69790563 : last:
553 80868573 : if (PREDICT_TRUE (nr & 128))
554 : {
555 3856171 : v0 = u8x16_load_unaligned (s + off + 0x00);
556 3856171 : v1 = u8x16_load_unaligned (s + off + 0x10);
557 3856171 : v2 = u8x16_load_unaligned (s + off + 0x20);
558 3856171 : v3 = u8x16_load_unaligned (s + off + 0x30);
559 3856171 : u8x16_store_unaligned (v0, d + off + 0x00);
560 3856171 : u8x16_store_unaligned (v1, d + off + 0x10);
561 3856170 : u8x16_store_unaligned (v2, d + off + 0x20);
562 3856168 : u8x16_store_unaligned (v3, d + off + 0x30);
563 3856168 : v0 = u8x16_load_unaligned (s + off + 0x40);
564 3856168 : v1 = u8x16_load_unaligned (s + off + 0x50);
565 3856168 : v2 = u8x16_load_unaligned (s + off + 0x60);
566 3856170 : v3 = u8x16_load_unaligned (s + off + 0x70);
567 3856170 : u8x16_store_unaligned (v0, d + off + 0x40);
568 3856170 : u8x16_store_unaligned (v1, d + off + 0x50);
569 3856171 : u8x16_store_unaligned (v2, d + off + 0x60);
570 3856171 : u8x16_store_unaligned (v3, d + off + 0x70);
571 3856170 : off += 128;
572 : }
573 80868571 : if (PREDICT_TRUE (nr & 64))
574 : {
575 7375960 : v0 = u8x16_load_unaligned (s + off + 0x00);
576 7375850 : v1 = u8x16_load_unaligned (s + off + 0x10);
577 7375780 : v2 = u8x16_load_unaligned (s + off + 0x20);
578 7375770 : v3 = u8x16_load_unaligned (s + off + 0x30);
579 7375850 : u8x16_store_unaligned (v0, d + off + 0x00);
580 7375829 : u8x16_store_unaligned (v1, d + off + 0x10);
581 7375888 : u8x16_store_unaligned (v2, d + off + 0x20);
582 7375888 : u8x16_store_unaligned (v3, d + off + 0x30);
583 7375998 : off += 64;
584 : }
585 80868599 : if (PREDICT_TRUE (nr & 32))
586 : {
587 73976417 : v0 = u8x16_load_unaligned (s + off + 0x00);
588 73976399 : v1 = u8x16_load_unaligned (s + off + 0x10);
589 73976386 : u8x16_store_unaligned (v0, d + off + 0x00);
590 73976389 : u8x16_store_unaligned (v1, d + off + 0x10);
591 73976414 : off += 32;
592 : }
593 80868599 : if (PREDICT_TRUE (nr & 16))
594 : {
595 72919106 : one:
596 82689393 : u8x16_store_unaligned (u8x16_load_unaligned (s + off), d + off);
597 : }
598 7949498 : done2:
599 107327739 : u8x16_store_unaligned (u8x16_load_unaligned (s + n - 16), d + n - 16);
600 : }
601 1954941842 : return dst;
602 : #else
603 : __builtin_memcpy (dst, src, n);
604 : return dst;
605 : #endif
606 : }
607 :
608 : /* clang-format off */
609 : WARN_ON (stringop-overflow)
610 : /* clang-format on */
611 :
612 : #endif
613 : #endif
|
