From b31bd11454fade731e5158b1aea40b133ae19926 Mon Sep 17 00:00:00 2001

From: Wilco Dijkstra <wdijkstr@arm.com>

Date: Thu, 2 Dec 2021 18:33:26 +0000

Subject: [PATCH] AArch64: Improve A64FX memcpy

v2 is a complete rewrite of the A64FX memcpy. Performance is improved

by streamlining the code, aligning all large copies and using a single

unrolled loop for all sizes. The code size for memcpy and memmove goes

down from 1796 bytes to 868 bytes. Performance is better in all cases:

bench-memcpy-random is 2.3% faster overall, bench-memcpy-large is ~33%

faster for large sizes, bench-memcpy-walk is 25% faster for small sizes

and 20% for the largest sizes. The geomean of all tests in bench-memcpy

is 5.1% faster, and total time is reduced by 4%.

Reviewed-by: Szabolcs Nagy <szabolcs.nagy@arm.com>

---

 sysdeps/aarch64/multiarch/memcpy_a64fx.S | 546 ++++++++++-------------

 1 file changed, 225 insertions(+), 321 deletions(-)

diff --git a/sysdeps/aarch64/multiarch/memcpy_a64fx.S b/sysdeps/aarch64/multiarch/memcpy_a64fx.S

index ae7464e09f..0b306925e6 100644

--- a/sysdeps/aarch64/multiarch/memcpy_a64fx.S

+++ b/sysdeps/aarch64/multiarch/memcpy_a64fx.S

@@ -28,20 +28,15 @@

  *

  */

-#define L2_SIZE		(8*1024*1024)/2	// L2 8MB/2

-#define CACHE_LINE_SIZE	256

-#define ZF_DIST		(CACHE_LINE_SIZE * 21)	// Zerofill distance

-#define dest		x0

-#define src		x1

-#define n		x2	// size

-#define tmp1		x3

-#define tmp2		x4

-#define tmp3		x5

-#define rest		x6

-#define dest_ptr	x7

-#define src_ptr		x8

-#define vector_length	x9

-#define cl_remainder	x10	// CACHE_LINE_SIZE remainder

+#define dstin	x0

+#define src	x1

+#define n	x2

+#define dst	x3

+#define dstend	x4

+#define srcend	x5

+#define tmp	x6

+#define vlen	x7

+#define vlen8	x8

 #if HAVE_AARCH64_SVE_ASM

 # if IS_IN (libc)

@@ -50,45 +45,37 @@

 	.arch armv8.2-a+sve

-	.macro dc_zva times

-	dc	zva, tmp1

-	add	tmp1, tmp1, CACHE_LINE_SIZE

-	.if \times-1

-	dc_zva "(\times-1)"

-	.endif

-	.endm

-

 	.macro ld1b_unroll8

-	ld1b	z0.b, p0/z, [src_ptr, #0, mul vl]

-	ld1b	z1.b, p0/z, [src_ptr, #1, mul vl]

-	ld1b	z2.b, p0/z, [src_ptr, #2, mul vl]

-	ld1b	z3.b, p0/z, [src_ptr, #3, mul vl]

-	ld1b	z4.b, p0/z, [src_ptr, #4, mul vl]

-	ld1b	z5.b, p0/z, [src_ptr, #5, mul vl]

-	ld1b	z6.b, p0/z, [src_ptr, #6, mul vl]

-	ld1b	z7.b, p0/z, [src_ptr, #7, mul vl]

+	ld1b	z0.b, p0/z, [src, 0, mul vl]

+	ld1b	z1.b, p0/z, [src, 1, mul vl]

+	ld1b	z2.b, p0/z, [src, 2, mul vl]

+	ld1b	z3.b, p0/z, [src, 3, mul vl]

+	ld1b	z4.b, p0/z, [src, 4, mul vl]

+	ld1b	z5.b, p0/z, [src, 5, mul vl]

+	ld1b	z6.b, p0/z, [src, 6, mul vl]

+	ld1b	z7.b, p0/z, [src, 7, mul vl]

 	.endm

 	.macro stld1b_unroll4a

-	st1b	z0.b, p0,   [dest_ptr, #0, mul vl]

-	st1b	z1.b, p0,   [dest_ptr, #1, mul vl]

-	ld1b	z0.b, p0/z, [src_ptr,  #0, mul vl]

-	ld1b	z1.b, p0/z, [src_ptr,  #1, mul vl]

-	st1b	z2.b, p0,   [dest_ptr, #2, mul vl]

-	st1b	z3.b, p0,   [dest_ptr, #3, mul vl]

-	ld1b	z2.b, p0/z, [src_ptr,  #2, mul vl]

-	ld1b	z3.b, p0/z, [src_ptr,  #3, mul vl]

+	st1b	z0.b, p0,   [dst, 0, mul vl]

+	st1b	z1.b, p0,   [dst, 1, mul vl]

+	ld1b	z0.b, p0/z, [src, 0, mul vl]

+	ld1b	z1.b, p0/z, [src, 1, mul vl]

+	st1b	z2.b, p0,   [dst, 2, mul vl]

+	st1b	z3.b, p0,   [dst, 3, mul vl]

+	ld1b	z2.b, p0/z, [src, 2, mul vl]

+	ld1b	z3.b, p0/z, [src, 3, mul vl]

 	.endm

 	.macro stld1b_unroll4b

-	st1b	z4.b, p0,   [dest_ptr, #4, mul vl]

-	st1b	z5.b, p0,   [dest_ptr, #5, mul vl]

-	ld1b	z4.b, p0/z, [src_ptr,  #4, mul vl]

-	ld1b	z5.b, p0/z, [src_ptr,  #5, mul vl]

-	st1b	z6.b, p0,   [dest_ptr, #6, mul vl]

-	st1b	z7.b, p0,   [dest_ptr, #7, mul vl]

-	ld1b	z6.b, p0/z, [src_ptr,  #6, mul vl]

-	ld1b	z7.b, p0/z, [src_ptr,  #7, mul vl]

+	st1b	z4.b, p0,   [dst, 4, mul vl]

+	st1b	z5.b, p0,   [dst, 5, mul vl]

+	ld1b	z4.b, p0/z, [src, 4, mul vl]

+	ld1b	z5.b, p0/z, [src, 5, mul vl]

+	st1b	z6.b, p0,   [dst, 6, mul vl]

+	st1b	z7.b, p0,   [dst, 7, mul vl]

+	ld1b	z6.b, p0/z, [src, 6, mul vl]

+	ld1b	z7.b, p0/z, [src, 7, mul vl]

 	.endm

 	.macro stld1b_unroll8

@@ -97,87 +84,18 @@

 	.endm

 	.macro st1b_unroll8

-	st1b	z0.b, p0, [dest_ptr, #0, mul vl]

-	st1b	z1.b, p0, [dest_ptr, #1, mul vl]

-	st1b	z2.b, p0, [dest_ptr, #2, mul vl]

-	st1b	z3.b, p0, [dest_ptr, #3, mul vl]

-	st1b	z4.b, p0, [dest_ptr, #4, mul vl]

-	st1b	z5.b, p0, [dest_ptr, #5, mul vl]

-	st1b	z6.b, p0, [dest_ptr, #6, mul vl]

-	st1b	z7.b, p0, [dest_ptr, #7, mul vl]

+	st1b	z0.b, p0, [dst, 0, mul vl]

+	st1b	z1.b, p0, [dst, 1, mul vl]

+	st1b	z2.b, p0, [dst, 2, mul vl]

+	st1b	z3.b, p0, [dst, 3, mul vl]

+	st1b	z4.b, p0, [dst, 4, mul vl]

+	st1b	z5.b, p0, [dst, 5, mul vl]

+	st1b	z6.b, p0, [dst, 6, mul vl]

+	st1b	z7.b, p0, [dst, 7, mul vl]

 	.endm

-	.macro shortcut_for_small_size exit

-	// if rest <= vector_length * 2

-	whilelo	p0.b, xzr, n

-	whilelo	p1.b, vector_length, n

-	b.last	1f

-	ld1b	z0.b, p0/z, [src, #0, mul vl]

-	ld1b	z1.b, p1/z, [src, #1, mul vl]

-	st1b	z0.b, p0, [dest, #0, mul vl]

-	st1b	z1.b, p1, [dest, #1, mul vl]

-	ret

-1:	// if rest > vector_length * 8

-	cmp	n, vector_length, lsl 3 // vector_length * 8

-	b.hi	\exit

-	// if rest <= vector_length * 4

-	lsl	tmp1, vector_length, 1  // vector_length * 2

-	whilelo	p2.b, tmp1, n

-	incb	tmp1

-	whilelo	p3.b, tmp1, n

-	b.last	1f

-	ld1b	z0.b, p0/z, [src, #0, mul vl]

-	ld1b	z1.b, p1/z, [src, #1, mul vl]

-	ld1b	z2.b, p2/z, [src, #2, mul vl]

-	ld1b	z3.b, p3/z, [src, #3, mul vl]

-	st1b	z0.b, p0, [dest, #0, mul vl]

-	st1b	z1.b, p1, [dest, #1, mul vl]

-	st1b	z2.b, p2, [dest, #2, mul vl]

-	st1b	z3.b, p3, [dest, #3, mul vl]

-	ret

-1:	// if rest <= vector_length * 8

-	lsl	tmp1, vector_length, 2  // vector_length * 4

-	whilelo	p4.b, tmp1, n

-	incb	tmp1

-	whilelo	p5.b, tmp1, n

-	b.last	1f

-	ld1b	z0.b, p0/z, [src, #0, mul vl]

-	ld1b	z1.b, p1/z, [src, #1, mul vl]

-	ld1b	z2.b, p2/z, [src, #2, mul vl]

-	ld1b	z3.b, p3/z, [src, #3, mul vl]

-	ld1b	z4.b, p4/z, [src, #4, mul vl]

-	ld1b	z5.b, p5/z, [src, #5, mul vl]

-	st1b	z0.b, p0, [dest, #0, mul vl]

-	st1b	z1.b, p1, [dest, #1, mul vl]

-	st1b	z2.b, p2, [dest, #2, mul vl]

-	st1b	z3.b, p3, [dest, #3, mul vl]

-	st1b	z4.b, p4, [dest, #4, mul vl]

-	st1b	z5.b, p5, [dest, #5, mul vl]

-	ret

-1:	lsl	tmp1, vector_length, 2	// vector_length * 4

-	incb	tmp1			// vector_length * 5

-	incb	tmp1			// vector_length * 6

-	whilelo	p6.b, tmp1, n

-	incb	tmp1

-	whilelo	p7.b, tmp1, n

-	ld1b	z0.b, p0/z, [src, #0, mul vl]

-	ld1b	z1.b, p1/z, [src, #1, mul vl]

-	ld1b	z2.b, p2/z, [src, #2, mul vl]

-	ld1b	z3.b, p3/z, [src, #3, mul vl]

-	ld1b	z4.b, p4/z, [src, #4, mul vl]

-	ld1b	z5.b, p5/z, [src, #5, mul vl]

-	ld1b	z6.b, p6/z, [src, #6, mul vl]

-	ld1b	z7.b, p7/z, [src, #7, mul vl]

-	st1b	z0.b, p0, [dest, #0, mul vl]

-	st1b	z1.b, p1, [dest, #1, mul vl]

-	st1b	z2.b, p2, [dest, #2, mul vl]

-	st1b	z3.b, p3, [dest, #3, mul vl]

-	st1b	z4.b, p4, [dest, #4, mul vl]

-	st1b	z5.b, p5, [dest, #5, mul vl]

-	st1b	z6.b, p6, [dest, #6, mul vl]

-	st1b	z7.b, p7, [dest, #7, mul vl]

-	ret

-	.endm

+#undef BTI_C

+#define BTI_C

 ENTRY (MEMCPY)

@@ -185,223 +103,209 @@ ENTRY (MEMCPY)

 	PTR_ARG (1)

 	SIZE_ARG (2)

-L(memcpy):

-	cntb	vector_length

-	// shortcut for less than vector_length * 8

-	// gives a free ptrue to p0.b for n >= vector_length

-	shortcut_for_small_size L(vl_agnostic)

-	// end of shortcut

-

-L(vl_agnostic): // VL Agnostic

-	mov	rest, n

-	mov	dest_ptr, dest

-	mov	src_ptr, src

-	// if rest >= L2_SIZE && vector_length == 64 then L(L2)

-	mov	tmp1, 64

-	cmp	rest, L2_SIZE

-	ccmp	vector_length, tmp1, 0, cs

-	b.eq	L(L2)

-

-L(unroll8): // unrolling and software pipeline

-	lsl	tmp1, vector_length, 3	// vector_length * 8

-	.p2align 3

-	cmp	 rest, tmp1

-	b.cc	L(last)

+	cntb	vlen

+	cmp	n, vlen, lsl 1

+	b.hi	L(copy_small)

+	whilelo	p1.b, vlen, n

+	whilelo	p0.b, xzr, n

+	ld1b	z0.b, p0/z, [src, 0, mul vl]

+	ld1b	z1.b, p1/z, [src, 1, mul vl]

+	st1b	z0.b, p0, [dstin, 0, mul vl]

+	st1b	z1.b, p1, [dstin, 1, mul vl]

+	ret

+

+	.p2align 4

+

+L(copy_small):

+	cmp	n, vlen, lsl 3

+	b.hi	L(copy_large)

+	add	dstend, dstin, n

+	add	srcend, src, n

+	cmp	n, vlen, lsl 2

+	b.hi	1f

+

+	/* Copy 2-4 vectors.  */

+	ptrue	p0.b

+	ld1b	z0.b, p0/z, [src, 0, mul vl]

+	ld1b	z1.b, p0/z, [src, 1, mul vl]

+	ld1b	z2.b, p0/z, [srcend, -2, mul vl]

+	ld1b	z3.b, p0/z, [srcend, -1, mul vl]

+	st1b	z0.b, p0, [dstin, 0, mul vl]

+	st1b	z1.b, p0, [dstin, 1, mul vl]

+	st1b	z2.b, p0, [dstend, -2, mul vl]

+	st1b	z3.b, p0, [dstend, -1, mul vl]

+	ret

+

+	.p2align 4

+	/* Copy 4-8 vectors.  */

+1:	ptrue	p0.b

+	ld1b	z0.b, p0/z, [src, 0, mul vl]

+	ld1b	z1.b, p0/z, [src, 1, mul vl]

+	ld1b	z2.b, p0/z, [src, 2, mul vl]

+	ld1b	z3.b, p0/z, [src, 3, mul vl]

+	ld1b	z4.b, p0/z, [srcend, -4, mul vl]

+	ld1b	z5.b, p0/z, [srcend, -3, mul vl]

+	ld1b	z6.b, p0/z, [srcend, -2, mul vl]

+	ld1b	z7.b, p0/z, [srcend, -1, mul vl]

+	st1b	z0.b, p0, [dstin, 0, mul vl]

+	st1b	z1.b, p0, [dstin, 1, mul vl]

+	st1b	z2.b, p0, [dstin, 2, mul vl]

+	st1b	z3.b, p0, [dstin, 3, mul vl]

+	st1b	z4.b, p0, [dstend, -4, mul vl]

+	st1b	z5.b, p0, [dstend, -3, mul vl]

+	st1b	z6.b, p0, [dstend, -2, mul vl]

+	st1b	z7.b, p0, [dstend, -1, mul vl]

+	ret

+

+	.p2align 4

+	/* At least 8 vectors - always align to vector length for

+	   higher and consistent write performance.  */

+L(copy_large):

+	sub	tmp, vlen, 1

+	and	tmp, dstin, tmp

+	sub	tmp, vlen, tmp

+	whilelo	p1.b, xzr, tmp

+	ld1b	z1.b, p1/z, [src]

+	st1b	z1.b, p1, [dstin]

+	add	dst, dstin, tmp

+	add	src, src, tmp

+	sub	n, n, tmp

+	ptrue	p0.b

+

+	lsl	vlen8, vlen, 3

+	subs	n, n, vlen8

+	b.ls	3f

 	ld1b_unroll8

-	add	src_ptr, src_ptr, tmp1

-	sub	rest, rest, tmp1

-	cmp	rest, tmp1

-	b.cc	2f

-	.p2align 3

+	add	src, src, vlen8

+	subs	n, n, vlen8

+	b.ls	2f

+

+	.p2align 4

+	/* 8x unrolled and software pipelined loop.  */

 1:	stld1b_unroll8

-	add	dest_ptr, dest_ptr, tmp1

-	add	src_ptr, src_ptr, tmp1

-	sub	rest, rest, tmp1

-	cmp	rest, tmp1

-	b.ge	1b

+	add	dst, dst, vlen8

+	add	src, src, vlen8

+	subs	n, n, vlen8

+	b.hi	1b

 2:	st1b_unroll8

-	add	dest_ptr, dest_ptr, tmp1

-

-	.p2align 3

-L(last):

-	whilelo	p0.b, xzr, rest

-	whilelo	p1.b, vector_length, rest

-	b.last	1f

-	ld1b	z0.b, p0/z, [src_ptr, #0, mul vl]

-	ld1b	z1.b, p1/z, [src_ptr, #1, mul vl]

-	st1b	z0.b, p0, [dest_ptr, #0, mul vl]

-	st1b	z1.b, p1, [dest_ptr, #1, mul vl]

-	ret

-1:	lsl	tmp1, vector_length, 1	// vector_length * 2

-	whilelo	p2.b, tmp1, rest

-	incb	tmp1

-	whilelo	p3.b, tmp1, rest

-	b.last	1f

-	ld1b	z0.b, p0/z, [src_ptr, #0, mul vl]

-	ld1b	z1.b, p1/z, [src_ptr, #1, mul vl]

-	ld1b	z2.b, p2/z, [src_ptr, #2, mul vl]

-	ld1b	z3.b, p3/z, [src_ptr, #3, mul vl]

-	st1b	z0.b, p0, [dest_ptr, #0, mul vl]

-	st1b	z1.b, p1, [dest_ptr, #1, mul vl]

-	st1b	z2.b, p2, [dest_ptr, #2, mul vl]

-	st1b	z3.b, p3, [dest_ptr, #3, mul vl]

+	add	dst, dst, vlen8

+3:	add	n, n, vlen8

+

+	/* Move last 0-8 vectors.  */

+L(last_bytes):

+	cmp	n, vlen, lsl 1

+	b.hi	1f

+	whilelo	p0.b, xzr, n

+	whilelo	p1.b, vlen, n

+	ld1b	z0.b, p0/z, [src, 0, mul vl]

+	ld1b	z1.b, p1/z, [src, 1, mul vl]

+	st1b	z0.b, p0, [dst, 0, mul vl]

+	st1b	z1.b, p1, [dst, 1, mul vl]

 	ret

-1:	lsl	tmp1, vector_length, 2	// vector_length * 4

-	whilelo	p4.b, tmp1, rest

-	incb	tmp1

-	whilelo	p5.b, tmp1, rest

-	incb	tmp1

-	whilelo	p6.b, tmp1, rest

-	incb	tmp1

-	whilelo	p7.b, tmp1, rest

-	ld1b	z0.b, p0/z, [src_ptr, #0, mul vl]

-	ld1b	z1.b, p1/z, [src_ptr, #1, mul vl]

-	ld1b	z2.b, p2/z, [src_ptr, #2, mul vl]

-	ld1b	z3.b, p3/z, [src_ptr, #3, mul vl]

-	ld1b	z4.b, p4/z, [src_ptr, #4, mul vl]

-	ld1b	z5.b, p5/z, [src_ptr, #5, mul vl]

-	ld1b	z6.b, p6/z, [src_ptr, #6, mul vl]

-	ld1b	z7.b, p7/z, [src_ptr, #7, mul vl]

-	st1b	z0.b, p0, [dest_ptr, #0, mul vl]

-	st1b	z1.b, p1, [dest_ptr, #1, mul vl]

-	st1b	z2.b, p2, [dest_ptr, #2, mul vl]

-	st1b	z3.b, p3, [dest_ptr, #3, mul vl]

-	st1b	z4.b, p4, [dest_ptr, #4, mul vl]

-	st1b	z5.b, p5, [dest_ptr, #5, mul vl]

-	st1b	z6.b, p6, [dest_ptr, #6, mul vl]

-	st1b	z7.b, p7, [dest_ptr, #7, mul vl]

+

+	.p2align 4

+

+1:	add	srcend, src, n

+	add	dstend, dst, n

+	ld1b	z0.b, p0/z, [src, 0, mul vl]

+	ld1b	z1.b, p0/z, [src, 1, mul vl]

+	ld1b	z2.b, p0/z, [srcend, -2, mul vl]

+	ld1b	z3.b, p0/z, [srcend, -1, mul vl]

+	cmp	n, vlen, lsl 2

+	b.hi	1f

+

+	st1b	z0.b, p0, [dst, 0, mul vl]

+	st1b	z1.b, p0, [dst, 1, mul vl]

+	st1b	z2.b, p0, [dstend, -2, mul vl]

+	st1b	z3.b, p0, [dstend, -1, mul vl]

 	ret

-L(L2):

-	// align dest address at CACHE_LINE_SIZE byte boundary

-	mov	tmp1, CACHE_LINE_SIZE

-	ands	tmp2, dest_ptr, CACHE_LINE_SIZE - 1

-	// if cl_remainder == 0

-	b.eq	L(L2_dc_zva)

-	sub	cl_remainder, tmp1, tmp2

-	// process remainder until the first CACHE_LINE_SIZE boundary

-	whilelo	p1.b, xzr, cl_remainder	// keep p0.b all true

-	whilelo	p2.b, vector_length, cl_remainder

-	b.last	1f

-	ld1b	z1.b, p1/z, [src_ptr, #0, mul vl]

-	ld1b	z2.b, p2/z, [src_ptr, #1, mul vl]

-	st1b	z1.b, p1, [dest_ptr, #0, mul vl]

-	st1b	z2.b, p2, [dest_ptr, #1, mul vl]

-	b	2f

-1:	lsl	tmp1, vector_length, 1	// vector_length * 2

-	whilelo	p3.b, tmp1, cl_remainder

-	incb	tmp1

-	whilelo	p4.b, tmp1, cl_remainder

-	ld1b	z1.b, p1/z, [src_ptr, #0, mul vl]

-	ld1b	z2.b, p2/z, [src_ptr, #1, mul vl]

-	ld1b	z3.b, p3/z, [src_ptr, #2, mul vl]

-	ld1b	z4.b, p4/z, [src_ptr, #3, mul vl]

-	st1b	z1.b, p1, [dest_ptr, #0, mul vl]

-	st1b	z2.b, p2, [dest_ptr, #1, mul vl]

-	st1b	z3.b, p3, [dest_ptr, #2, mul vl]

-	st1b	z4.b, p4, [dest_ptr, #3, mul vl]

-2:	add	dest_ptr, dest_ptr, cl_remainder

-	add	src_ptr, src_ptr, cl_remainder

-	sub	rest, rest, cl_remainder

-

-L(L2_dc_zva):

-	// zero fill

-	and	tmp1, dest, 0xffffffffffffff

-	and	tmp2, src, 0xffffffffffffff

-	subs	tmp1, tmp1, tmp2	// diff

-	b.ge	1f

-	neg	tmp1, tmp1

-1:	mov	tmp3, ZF_DIST + CACHE_LINE_SIZE * 2

-	cmp	tmp1, tmp3

-	b.lo	L(unroll8)

-	mov	tmp1, dest_ptr

-	dc_zva	(ZF_DIST / CACHE_LINE_SIZE) - 1

-	// unroll

-	ld1b_unroll8	// this line has to be after "b.lo L(unroll8)"

-	add	 src_ptr, src_ptr, CACHE_LINE_SIZE * 2

-	sub	 rest, rest, CACHE_LINE_SIZE * 2

-	mov	 tmp1, ZF_DIST

-	.p2align 3

-1:	stld1b_unroll4a

-	add	tmp2, dest_ptr, tmp1	// dest_ptr + ZF_DIST

-	dc	zva, tmp2

-	stld1b_unroll4b

-	add	tmp2, tmp2, CACHE_LINE_SIZE

-	dc	zva, tmp2

-	add	dest_ptr, dest_ptr, CACHE_LINE_SIZE * 2

-	add	src_ptr, src_ptr, CACHE_LINE_SIZE * 2

-	sub	rest, rest, CACHE_LINE_SIZE * 2

-	cmp	rest, tmp3	// ZF_DIST + CACHE_LINE_SIZE * 2

-	b.ge	1b

-	st1b_unroll8

-	add	dest_ptr, dest_ptr, CACHE_LINE_SIZE * 2

-	b	L(unroll8)

+1:	ld1b	z4.b, p0/z, [src, 2, mul vl]

+	ld1b	z5.b, p0/z, [src, 3, mul vl]

+	ld1b	z6.b, p0/z, [srcend, -4, mul vl]

+	ld1b	z7.b, p0/z, [srcend, -3, mul vl]

+	st1b	z0.b, p0, [dst, 0, mul vl]

+	st1b	z1.b, p0, [dst, 1, mul vl]

+	st1b	z4.b, p0, [dst, 2, mul vl]

+	st1b	z5.b, p0, [dst, 3, mul vl]

+	st1b	z6.b, p0, [dstend, -4, mul vl]

+	st1b	z7.b, p0, [dstend, -3, mul vl]

+	st1b	z2.b, p0, [dstend, -2, mul vl]

+	st1b	z3.b, p0, [dstend, -1, mul vl]

+	ret

 END (MEMCPY)

 libc_hidden_builtin_def (MEMCPY)

-ENTRY (MEMMOVE)

+ENTRY_ALIGN (MEMMOVE, 4)

 	PTR_ARG (0)

 	PTR_ARG (1)

 	SIZE_ARG (2)

-	// remove tag address

-	// dest has to be immutable because it is the return value

-	// src has to be immutable because it is used in L(bwd_last)

-	and	tmp2, dest, 0xffffffffffffff	// save dest_notag into tmp2

-	and	tmp3, src, 0xffffffffffffff	// save src_notag intp tmp3

-	cmp	n, 0

-	ccmp	tmp2, tmp3, 4, ne

-	b.ne	1f

+	/* Fast case for up to 2 vectors.  */

+	cntb	vlen

+	cmp	n, vlen, lsl 1

+	b.hi	1f

+	whilelo	p0.b, xzr, n

+	whilelo	p1.b, vlen, n

+	ld1b	z0.b, p0/z, [src, 0, mul vl]

+	ld1b	z1.b, p1/z, [src, 1, mul vl]

+	st1b	z0.b, p0, [dstin, 0, mul vl]

+	st1b	z1.b, p1, [dstin, 1, mul vl]

+L(full_overlap):

 	ret

-1:	cntb	vector_length

-	// shortcut for less than vector_length * 8

-	// gives a free ptrue to p0.b for n >= vector_length

-	// tmp2 and tmp3 should not be used in this macro to keep

-	// notag addresses

-	shortcut_for_small_size L(dispatch)

-	// end of shortcut

-

-L(dispatch):

-	// tmp2 = dest_notag, tmp3 = src_notag

-	// diff = dest_notag - src_notag

-	sub	tmp1, tmp2, tmp3

-	// if diff <= 0 || diff >= n then memcpy

-	cmp	tmp1, 0

-	ccmp	tmp1, n, 2, gt

-	b.cs	L(vl_agnostic)

-

-L(bwd_start):

-	mov	rest, n

-	add	dest_ptr, dest, n	// dest_end

-	add	src_ptr, src, n		// src_end

-

-L(bwd_unroll8): // unrolling and software pipeline

-	lsl	tmp1, vector_length, 3	// vector_length * 8

-	.p2align 3

-	cmp	rest, tmp1

-	b.cc	L(bwd_last)

-	sub	src_ptr, src_ptr, tmp1

+

+	.p2align 4

+	/* Check for overlapping moves. Return if there is a full overlap.

+	   Small moves up to 8 vectors use the overlap-safe copy_small code.

+	   Non-overlapping or overlapping moves with dst < src use memcpy.

+	   Overlapping moves with dst > src use a backward copy loop.  */

+1:	sub	tmp, dstin, src

+	ands	tmp, tmp, 0xffffffffffffff	/* Clear special tag bits.  */

+	b.eq	L(full_overlap)

+	cmp	n, vlen, lsl 3

+	b.ls	L(copy_small)

+	cmp	tmp, n

+	b.hs	L(copy_large)

+

+	/* Align to vector length.  */

+	add	dst, dstin, n

+	sub	tmp, vlen, 1

+	ands	tmp, dst, tmp

+	csel	tmp, tmp, vlen, ne

+	whilelo	p1.b, xzr, tmp

+	sub	n, n, tmp

+	ld1b	z1.b, p1/z, [src, n]

+	st1b	z1.b, p1, [dstin, n]

+	add	src, src, n

+	add	dst, dstin, n

+

+	ptrue	p0.b

+	lsl	vlen8, vlen, 3

+	subs	n, n, vlen8

+	b.ls	3f

+	sub	src, src, vlen8

 	ld1b_unroll8

-	sub	rest, rest, tmp1

-	cmp	rest, tmp1

-	b.cc	2f

-	.p2align 3

-1:	sub	src_ptr, src_ptr, tmp1

-	sub	dest_ptr, dest_ptr, tmp1

+	subs	n, n, vlen8

+	b.ls	2f

+

+	.p2align 4

+	/* 8x unrolled and software pipelined backward copy loop.  */

+1:	sub	src, src, vlen8

+	sub	dst, dst, vlen8

 	stld1b_unroll8

-	sub	rest, rest, tmp1

-	cmp	rest, tmp1

-	b.ge	1b

-2:	sub	dest_ptr, dest_ptr, tmp1

+	subs	n, n, vlen8

+	b.hi	1b

+2:	sub	dst, dst, vlen8

 	st1b_unroll8

+3:	add	n, n, vlen8

-L(bwd_last):

-	mov	dest_ptr, dest

-	mov	src_ptr, src

-	b	L(last)

+	/* Adjust src/dst for last 0-8 vectors.  */

+	sub	src, src, n

+	mov	dst, dstin

+	b	L(last_bytes)

 END (MEMMOVE)

 libc_hidden_builtin_def (MEMMOVE)

-- 

2.31.1