Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > linux.kernel > #1705920 > unrolled thread

[PATCH v2 0/4] Update memcpy, memset etc. for M7/M8 architectures

Started byBabu Moger <babu.moger@oracle.com>
First post2017-08-08 02:00 +0200
Last post2017-08-10 23:40 +0200
Articles 5 — 2 participants

Back to article view | Back to linux.kernel

Contents

  [PATCH v2 0/4] Update memcpy, memset etc. for M7/M8 architectures Babu Moger <babu.moger@oracle.com> - 2017-08-08 02:00 +0200
    [PATCH v2 1/4] arch/sparc: Separate the exception handlers from NG4memcpy Babu Moger <babu.moger@oracle.com> - 2017-08-08 02:00 +0200
    [PATCH v2 4/4] arch/sparc: Add accurate exception reporting in M7memcpy Babu Moger <babu.moger@oracle.com> - 2017-08-08 02:00 +0200
    [PATCH v2 2/4] arch/sparc: Rename exception handlers Babu Moger <babu.moger@oracle.com> - 2017-08-08 02:00 +0200
    Re: [PATCH v2 0/4] Update memcpy, memset etc. for M7/M8  architectures David Miller <davem@davemloft.net> - 2017-08-10 23:40 +0200

#1705920 — [PATCH v2 0/4] Update memcpy, memset etc. for M7/M8 architectures

FromBabu Moger <babu.moger@oracle.com>
Date2017-08-08 02:00 +0200
Subject[PATCH v2 0/4] Update memcpy, memset etc. for M7/M8 architectures
Message-ID<uc06d-7Ai-3@gated-at.bofh.it>
This series of patches updates the memcpy, memset, copy_to_user, copy_from_user
etc for SPARC M7/M8 architecture.

New algorithm here takes advantage of the M7/M8 block init store ASIs, with much
more optimized way to improve the performance. More detail are in code comments.

Tested and compared the latency measured in ticks(NG4memcpy vs new M7memcpy).

1. Memset numbers(Aligned memset)

No.of bytes   NG4memset	   M7memset    	Delta ((B-A)/A)*100
	     (Avg.Ticks A) (Avg.Ticks B) (latency reduction)
  3		77		25		-67.53
  7		43		33		-23.25
  32		72		68		 -5.55
  128		164		44		-73.17
  256		335		68		-79.70
  512		511		220		-56.94
  1024		1552		627		-59.60
  2048		3515		1322		-62.38
  4096		6303		2472		-60.78
  8192		13118		4867		-62.89
  16384		26206		10371		-60.42
  32768		52501		18569		-64.63
  65536		100219		35899		-64.17


2. Memcpy numbers(Aligned memcpy)

No.of bytes   NG4memcpy	   M7memcpy    	Delta ((B-A)/A)*100
	     (Avg.Ticks A) (Avg.Ticks B) (latency reduction)
  3		20		19		-5
  7		29		27		-6.89
  32		30		28		-6.66
  128		89		69		-22.47
  256		142		143		 0.70
  512		341		283		-17.00
  1024		1588		655		-58.75
  2048		3553		1357		-61.80
  4096		7218		2590		-64.11
  8192		13701		5231		-61.82
  16384		28304		10716		-62.13
  32768		56516		22995		-59.31
  65536		115443		50840		-55.96

3. Memset numbers(un-aligned memset)

No.of bytes   NG4memset	   M7memset    	Delta ((B-A)/A)*100
	     (Avg.Ticks A) (Avg.Ticks B) (latency reduction)
  3		40		31		-22.5
  7		52		29		-44.2307692308
  32		89		86		-3.3707865169
  128		201		74		-63.184079602
  256		340		154		-54.7058823529
  512		961		335		-65.1404786681
  1024		1799		686		-61.8677042802
  2048		3575		1260		-64.7552447552
  4096		6560		2627		-59.9542682927
  8192		13161		6018		-54.273991338
  16384		26465		10439		-60.5554505951
  32768		52119		18649		-64.2184232238
  65536		101593		35724		-64.8361599717

4. Memcpy numbers(un-aligned memcpy)

No.of bytes   NG4memcpy	   M7memcpy    	Delta ((B-A)/A)*100
	     (Avg.Ticks A) (Avg.Ticks B) (latency reduction)
  3		26		19		-26.9230769231
  7		48		45		-6.25
  32		52		49		-5.7692307692
  128		284		334		17.6056338028
  256		430		482		12.0930232558
  512		646		690		6.8111455108
  1024		1051		1016		-3.3301617507
  2048		1787		1818		1.7347509793
  4096		3309		3376		2.0247809006
  8192		8151		7444		-8.673782358
  16384		34222		34556		0.9759803635
  32768		87851		95044		8.1877269468
  65536		158331		159572		0.7838010244

There is not much difference in numbers with Un-aligned copies
between NG4memcpy and M7memcpy because they both mostly use the
same algorithems.

v2:
 1. Fixed indentation issues found by David Miller
 2. Used ENTRY and ENDPROC for the labels in M7patch.S as suggested by David Miller
 3. Now M8 also will use M7memcpy. Also tested on M8 config.
 4. These patches are created on top of below M8 patches
    https://patchwork.ozlabs.org/patch/792661/
    https://patchwork.ozlabs.org/patch/792662/
    However, I did not see these patches in sparc-next tree. It may be in queue now.
    It is possible these patches might cause some build problems. It will resolve 
    once all M8 patches are in sparc-next tree.

v0: Initial version

Babu Moger (4):
  arch/sparc: Separate the exception handlers from NG4memcpy
  arch/sparc: Rename exception handlers
  arch/sparc: Optimized memcpy, memset, copy_to_user, copy_from_user
    for M7/M8
  arch/sparc: Add accurate exception reporting in M7memcpy

 arch/sparc/kernel/head_64.S       |   16 +-
 arch/sparc/lib/M7copy_from_user.S |   40 ++
 arch/sparc/lib/M7copy_to_user.S   |   51 ++
 arch/sparc/lib/M7memcpy.S         |  923 +++++++++++++++++++++++++++++++++++++
 arch/sparc/lib/M7memset.S         |  352 ++++++++++++++
 arch/sparc/lib/M7patch.S          |   51 ++
 arch/sparc/lib/Makefile           |    5 +
 arch/sparc/lib/Memcpy_utils.S     |  345 ++++++++++++++
 arch/sparc/lib/NG4memcpy.S        |  277 +++---------
 9 files changed, 1845 insertions(+), 215 deletions(-)
 create mode 100644 arch/sparc/lib/M7copy_from_user.S
 create mode 100644 arch/sparc/lib/M7copy_to_user.S
 create mode 100644 arch/sparc/lib/M7memcpy.S
 create mode 100644 arch/sparc/lib/M7memset.S
 create mode 100644 arch/sparc/lib/M7patch.S
 create mode 100644 arch/sparc/lib/Memcpy_utils.S

[toc] | [next] | [standalone]

#1705921 — [PATCH v2 1/4] arch/sparc: Separate the exception handlers from NG4memcpy

FromBabu Moger <babu.moger@oracle.com>
Date2017-08-08 02:00 +0200
Subject[PATCH v2 1/4] arch/sparc: Separate the exception handlers from NG4memcpy
Message-ID<uc06e-7Ai-7@gated-at.bofh.it>
In reply to#1705920
Separate the exception handlers from NG4memcpy so that it can be
used with new memcpy routines. Make a separate file for all these handlers.

Signed-off-by: Babu Moger <babu.moger@oracle.com>
---
 arch/sparc/lib/Makefile       |    2 +
 arch/sparc/lib/Memcpy_utils.S |  163 +++++++++++++++++++++++++++++++++++++++++
 arch/sparc/lib/NG4memcpy.S    |  149 -------------------------------------
 3 files changed, 165 insertions(+), 149 deletions(-)
 create mode 100644 arch/sparc/lib/Memcpy_utils.S

diff --git a/arch/sparc/lib/Makefile b/arch/sparc/lib/Makefile
index 07c03e7..37930c0 100644
--- a/arch/sparc/lib/Makefile
+++ b/arch/sparc/lib/Makefile
@@ -36,6 +36,8 @@ lib-$(CONFIG_SPARC64) +=  NG2patch.o
 lib-$(CONFIG_SPARC64) += NG4memcpy.o NG4copy_from_user.o NG4copy_to_user.o
 lib-$(CONFIG_SPARC64) +=  NG4patch.o NG4copy_page.o NG4clear_page.o NG4memset.o
 
+lib-$(CONFIG_SPARC64) += Memcpy_utils.o
+
 lib-$(CONFIG_SPARC64) += GENmemcpy.o GENcopy_from_user.o GENcopy_to_user.o
 lib-$(CONFIG_SPARC64) += GENpatch.o GENpage.o GENbzero.o
 
diff --git a/arch/sparc/lib/Memcpy_utils.S b/arch/sparc/lib/Memcpy_utils.S
new file mode 100644
index 0000000..f7a26e0
--- /dev/null
+++ b/arch/sparc/lib/Memcpy_utils.S
@@ -0,0 +1,163 @@
+#ifndef __ASM_MEMCPY_UTILS
+#define __ASM_MEMCPY_UTILS
+
+#include <linux/linkage.h>
+#include <asm/asi.h>
+#include <asm/visasm.h>
+
+ENTRY(__restore_asi_fp)
+	VISExitHalf
+	retl
+	 wr	%g0, ASI_AIUS, %asi
+ENDPROC(__restore_asi_fp)
+
+ENTRY(__restore_asi)
+	retl
+	 wr	%g0, ASI_AIUS, %asi
+ENDPROC(__restore_asi)
+
+ENTRY(NG4_retl_o2)
+	ba,pt	%xcc, __restore_asi
+	 mov	%o2, %o0
+ENDPROC(NG4_retl_o2)
+ENTRY(NG4_retl_o2_plus_1)
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 1, %o0
+ENDPROC(NG4_retl_o2_plus_1)
+ENTRY(NG4_retl_o2_plus_4)
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 4, %o0
+ENDPROC(NG4_retl_o2_plus_4)
+ENTRY(NG4_retl_o2_plus_o5)
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %o5, %o0
+ENDPROC(NG4_retl_o2_plus_o5)
+ENTRY(NG4_retl_o2_plus_o5_plus_4)
+	add	%o5, 4, %o5
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %o5, %o0
+ENDPROC(NG4_retl_o2_plus_o5_plus_4)
+ENTRY(NG4_retl_o2_plus_o5_plus_8)
+	add	%o5, 8, %o5
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %o5, %o0
+ENDPROC(NG4_retl_o2_plus_o5_plus_8)
+ENTRY(NG4_retl_o2_plus_o5_plus_16)
+	add	%o5, 16, %o5
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %o5, %o0
+ENDPROC(NG4_retl_o2_plus_o5_plus_16)
+ENTRY(NG4_retl_o2_plus_o5_plus_24)
+	add	%o5, 24, %o5
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %o5, %o0
+ENDPROC(NG4_retl_o2_plus_o5_plus_24)
+ENTRY(NG4_retl_o2_plus_o5_plus_32)
+	add	%o5, 32, %o5
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %o5, %o0
+ENDPROC(NG4_retl_o2_plus_o5_plus_32)
+ENTRY(NG4_retl_o2_plus_g1)
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %g1, %o0
+ENDPROC(NG4_retl_o2_plus_g1)
+ENTRY(NG4_retl_o2_plus_g1_plus_1)
+	add	%g1, 1, %g1
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %g1, %o0
+ENDPROC(NG4_retl_o2_plus_g1_plus_1)
+ENTRY(NG4_retl_o2_plus_g1_plus_8)
+	add	%g1, 8, %g1
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %g1, %o0
+ENDPROC(NG4_retl_o2_plus_g1_plus_8)
+ENTRY(NG4_retl_o2_plus_o4)
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %o4, %o0
+ENDPROC(NG4_retl_o2_plus_o4)
+ENTRY(NG4_retl_o2_plus_o4_plus_8)
+	add	%o4, 8, %o4
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %o4, %o0
+ENDPROC(NG4_retl_o2_plus_o4_plus_8)
+ENTRY(NG4_retl_o2_plus_o4_plus_16)
+	add	%o4, 16, %o4
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %o4, %o0
+ENDPROC(NG4_retl_o2_plus_o4_plus_16)
+ENTRY(NG4_retl_o2_plus_o4_plus_24)
+	add	%o4, 24, %o4
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %o4, %o0
+ENDPROC(NG4_retl_o2_plus_o4_plus_24)
+ENTRY(NG4_retl_o2_plus_o4_plus_32)
+	add	%o4, 32, %o4
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %o4, %o0
+ENDPROC(NG4_retl_o2_plus_o4_plus_32)
+ENTRY(NG4_retl_o2_plus_o4_plus_40)
+	add	%o4, 40, %o4
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %o4, %o0
+ENDPROC(NG4_retl_o2_plus_o4_plus_40)
+ENTRY(NG4_retl_o2_plus_o4_plus_48)
+	add	%o4, 48, %o4
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %o4, %o0
+ENDPROC(NG4_retl_o2_plus_o4_plus_48)
+ENTRY(NG4_retl_o2_plus_o4_plus_56)
+	add	%o4, 56, %o4
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %o4, %o0
+ENDPROC(NG4_retl_o2_plus_o4_plus_56)
+ENTRY(NG4_retl_o2_plus_o4_plus_64)
+	add	%o4, 64, %o4
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %o4, %o0
+ENDPROC(NG4_retl_o2_plus_o4_plus_64)
+ENTRY(NG4_retl_o2_plus_o4_fp)
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o4, %o0
+ENDPROC(NG4_retl_o2_plus_o4_fp)
+ENTRY(NG4_retl_o2_plus_o4_plus_8_fp)
+	add	%o4, 8, %o4
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o4, %o0
+ENDPROC(NG4_retl_o2_plus_o4_plus_8_fp)
+ENTRY(NG4_retl_o2_plus_o4_plus_16_fp)
+	add	%o4, 16, %o4
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o4, %o0
+ENDPROC(NG4_retl_o2_plus_o4_plus_16_fp)
+ENTRY(NG4_retl_o2_plus_o4_plus_24_fp)
+	add	%o4, 24, %o4
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o4, %o0
+ENDPROC(NG4_retl_o2_plus_o4_plus_24_fp)
+ENTRY(NG4_retl_o2_plus_o4_plus_32_fp)
+	add	%o4, 32, %o4
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o4, %o0
+ENDPROC(NG4_retl_o2_plus_o4_plus_32_fp)
+ENTRY(NG4_retl_o2_plus_o4_plus_40_fp)
+	add	%o4, 40, %o4
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o4, %o0
+ENDPROC(NG4_retl_o2_plus_o4_plus_40_fp)
+ENTRY(NG4_retl_o2_plus_o4_plus_48_fp)
+	add	%o4, 48, %o4
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o4, %o0
+ENDPROC(NG4_retl_o2_plus_o4_plus_48_fp)
+ENTRY(NG4_retl_o2_plus_o4_plus_56_fp)
+	add	%o4, 56, %o4
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o4, %o0
+ENDPROC(NG4_retl_o2_plus_o4_plus_56_fp)
+ENTRY(NG4_retl_o2_plus_o4_plus_64_fp)
+	add	%o4, 64, %o4
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o4, %o0
+ENDPROC(NG4_retl_o2_plus_o4_plus_64_fp)
+
+#endif
diff --git a/arch/sparc/lib/NG4memcpy.S b/arch/sparc/lib/NG4memcpy.S
index 78ea962..e20d654 100644
--- a/arch/sparc/lib/NG4memcpy.S
+++ b/arch/sparc/lib/NG4memcpy.S
@@ -94,155 +94,6 @@
 	.text
 #ifndef EX_RETVAL
 #define EX_RETVAL(x)	x
-__restore_asi_fp:
-	VISExitHalf
-__restore_asi:
-	retl
-	 wr	%g0, ASI_AIUS, %asi
-
-ENTRY(NG4_retl_o2)
-	ba,pt	%xcc, __restore_asi
-	 mov	%o2, %o0
-ENDPROC(NG4_retl_o2)
-ENTRY(NG4_retl_o2_plus_1)
-	ba,pt	%xcc, __restore_asi
-	 add	%o2, 1, %o0
-ENDPROC(NG4_retl_o2_plus_1)
-ENTRY(NG4_retl_o2_plus_4)
-	ba,pt	%xcc, __restore_asi
-	 add	%o2, 4, %o0
-ENDPROC(NG4_retl_o2_plus_4)
-ENTRY(NG4_retl_o2_plus_o5)
-	ba,pt	%xcc, __restore_asi
-	 add	%o2, %o5, %o0
-ENDPROC(NG4_retl_o2_plus_o5)
-ENTRY(NG4_retl_o2_plus_o5_plus_4)
-	add	%o5, 4, %o5
-	ba,pt	%xcc, __restore_asi
-	 add	%o2, %o5, %o0
-ENDPROC(NG4_retl_o2_plus_o5_plus_4)
-ENTRY(NG4_retl_o2_plus_o5_plus_8)
-	add	%o5, 8, %o5
-	ba,pt	%xcc, __restore_asi
-	 add	%o2, %o5, %o0
-ENDPROC(NG4_retl_o2_plus_o5_plus_8)
-ENTRY(NG4_retl_o2_plus_o5_plus_16)
-	add	%o5, 16, %o5
-	ba,pt	%xcc, __restore_asi
-	 add	%o2, %o5, %o0
-ENDPROC(NG4_retl_o2_plus_o5_plus_16)
-ENTRY(NG4_retl_o2_plus_o5_plus_24)
-	add	%o5, 24, %o5
-	ba,pt	%xcc, __restore_asi
-	 add	%o2, %o5, %o0
-ENDPROC(NG4_retl_o2_plus_o5_plus_24)
-ENTRY(NG4_retl_o2_plus_o5_plus_32)
-	add	%o5, 32, %o5
-	ba,pt	%xcc, __restore_asi
-	 add	%o2, %o5, %o0
-ENDPROC(NG4_retl_o2_plus_o5_plus_32)
-ENTRY(NG4_retl_o2_plus_g1)
-	ba,pt	%xcc, __restore_asi
-	 add	%o2, %g1, %o0
-ENDPROC(NG4_retl_o2_plus_g1)
-ENTRY(NG4_retl_o2_plus_g1_plus_1)
-	add	%g1, 1, %g1
-	ba,pt	%xcc, __restore_asi
-	 add	%o2, %g1, %o0
-ENDPROC(NG4_retl_o2_plus_g1_plus_1)
-ENTRY(NG4_retl_o2_plus_g1_plus_8)
-	add	%g1, 8, %g1
-	ba,pt	%xcc, __restore_asi
-	 add	%o2, %g1, %o0
-ENDPROC(NG4_retl_o2_plus_g1_plus_8)
-ENTRY(NG4_retl_o2_plus_o4)
-	ba,pt	%xcc, __restore_asi
-	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4)
-ENTRY(NG4_retl_o2_plus_o4_plus_8)
-	add	%o4, 8, %o4
-	ba,pt	%xcc, __restore_asi
-	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_8)
-ENTRY(NG4_retl_o2_plus_o4_plus_16)
-	add	%o4, 16, %o4
-	ba,pt	%xcc, __restore_asi
-	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_16)
-ENTRY(NG4_retl_o2_plus_o4_plus_24)
-	add	%o4, 24, %o4
-	ba,pt	%xcc, __restore_asi
-	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_24)
-ENTRY(NG4_retl_o2_plus_o4_plus_32)
-	add	%o4, 32, %o4
-	ba,pt	%xcc, __restore_asi
-	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_32)
-ENTRY(NG4_retl_o2_plus_o4_plus_40)
-	add	%o4, 40, %o4
-	ba,pt	%xcc, __restore_asi
-	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_40)
-ENTRY(NG4_retl_o2_plus_o4_plus_48)
-	add	%o4, 48, %o4
-	ba,pt	%xcc, __restore_asi
-	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_48)
-ENTRY(NG4_retl_o2_plus_o4_plus_56)
-	add	%o4, 56, %o4
-	ba,pt	%xcc, __restore_asi
-	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_56)
-ENTRY(NG4_retl_o2_plus_o4_plus_64)
-	add	%o4, 64, %o4
-	ba,pt	%xcc, __restore_asi
-	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_64)
-ENTRY(NG4_retl_o2_plus_o4_fp)
-	ba,pt	%xcc, __restore_asi_fp
-	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_fp)
-ENTRY(NG4_retl_o2_plus_o4_plus_8_fp)
-	add	%o4, 8, %o4
-	ba,pt	%xcc, __restore_asi_fp
-	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_8_fp)
-ENTRY(NG4_retl_o2_plus_o4_plus_16_fp)
-	add	%o4, 16, %o4
-	ba,pt	%xcc, __restore_asi_fp
-	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_16_fp)
-ENTRY(NG4_retl_o2_plus_o4_plus_24_fp)
-	add	%o4, 24, %o4
-	ba,pt	%xcc, __restore_asi_fp
-	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_24_fp)
-ENTRY(NG4_retl_o2_plus_o4_plus_32_fp)
-	add	%o4, 32, %o4
-	ba,pt	%xcc, __restore_asi_fp
-	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_32_fp)
-ENTRY(NG4_retl_o2_plus_o4_plus_40_fp)
-	add	%o4, 40, %o4
-	ba,pt	%xcc, __restore_asi_fp
-	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_40_fp)
-ENTRY(NG4_retl_o2_plus_o4_plus_48_fp)
-	add	%o4, 48, %o4
-	ba,pt	%xcc, __restore_asi_fp
-	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_48_fp)
-ENTRY(NG4_retl_o2_plus_o4_plus_56_fp)
-	add	%o4, 56, %o4
-	ba,pt	%xcc, __restore_asi_fp
-	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_56_fp)
-ENTRY(NG4_retl_o2_plus_o4_plus_64_fp)
-	add	%o4, 64, %o4
-	ba,pt	%xcc, __restore_asi_fp
-	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_64_fp)
 #endif
 	.align		64
 
-- 
1.7.1

[toc] | [prev] | [next] | [standalone]

#1705922 — [PATCH v2 4/4] arch/sparc: Add accurate exception reporting in M7memcpy

FromBabu Moger <babu.moger@oracle.com>
Date2017-08-08 02:00 +0200
Subject[PATCH v2 4/4] arch/sparc: Add accurate exception reporting in M7memcpy
Message-ID<uc06d-7Ai-1@gated-at.bofh.it>
In reply to#1705920
Add accurate exception reporting in M7memcpy

Signed-off-by: Babu Moger <babu.moger@oracle.com>
---
 arch/sparc/lib/M7copy_from_user.S |   11 +-
 arch/sparc/lib/M7copy_to_user.S   |   10 +-
 arch/sparc/lib/M7memcpy.S         |  396 ++++++++++++++++++------------------
 arch/sparc/lib/Memcpy_utils.S     |  182 +++++++++++++++++
 4 files changed, 390 insertions(+), 209 deletions(-)

diff --git a/arch/sparc/lib/M7copy_from_user.S b/arch/sparc/lib/M7copy_from_user.S
index d0689d7..66464b3 100644
--- a/arch/sparc/lib/M7copy_from_user.S
+++ b/arch/sparc/lib/M7copy_from_user.S
@@ -5,23 +5,22 @@
  */
 
 
-#define EX_LD(x)			\
+#define EX_LD(x, y)			\
 98:	x;				\
 	.section __ex_table,"a";	\
 	.align 4;			\
-	.word 98b, __restore_asi;	\
+	.word 98b, y;			\
 	.text;				\
 	.align 4;
 
-#define EX_LD_FP(x)			\
+#define EX_LD_FP(x, y)			\
 98:	x;				\
 	.section __ex_table,"a";	\
 	.align 4;			\
-	.word 98b, __restore_asi_fp;	\
+	.word 98b, y##_fp;		\
 	.text;				\
 	.align 4;
 
-
 #ifndef ASI_AIUS
 #define ASI_AIUS	0x11
 #endif
@@ -35,7 +34,7 @@
 	rd		%asi, %g1;			\
 	cmp		%g1, ASI_AIUS;			\
 	bne,pn		%icc, raw_copy_in_user;		\
-	nop
+	 nop
 #endif
 
 #include "M7memcpy.S"
diff --git a/arch/sparc/lib/M7copy_to_user.S b/arch/sparc/lib/M7copy_to_user.S
index d3be132..a60ac46 100644
--- a/arch/sparc/lib/M7copy_to_user.S
+++ b/arch/sparc/lib/M7copy_to_user.S
@@ -5,19 +5,19 @@
  */
 
 
-#define EX_ST(x)			\
+#define EX_ST(x, y)			\
 98:	x;				\
 	.section __ex_table,"a";	\
 	.align 4;			\
-	.word 98b, __restore_asi;	\
+	.word 98b, y;			\
 	.text;				\
 	.align 4;
 
-#define EX_ST_FP(x)			\
+#define EX_ST_FP(x, y)			\
 98:	x;				\
 	.section __ex_table,"a";	\
 	.align 4;			\
-	.word 98b, __restore_asi_fp;	\
+	.word 98b, y##_fp;		\
 	.text;				\
 	.align 4;
 
@@ -45,7 +45,7 @@
 	rd		%asi, %g1;			\
 	cmp		%g1, ASI_AIUS;			\
 	bne,pn		%icc, raw_copy_in_user;		\
-	nop
+	 nop
 #endif
 
 #include "M7memcpy.S"
diff --git a/arch/sparc/lib/M7memcpy.S b/arch/sparc/lib/M7memcpy.S
index 0a0421d..d016fc2 100644
--- a/arch/sparc/lib/M7memcpy.S
+++ b/arch/sparc/lib/M7memcpy.S
@@ -96,17 +96,17 @@
 #endif
 
 #ifndef EX_LD
-#define EX_LD(x)	x
+#define EX_LD(x,y)	x
 #endif
 #ifndef EX_LD_FP
-#define EX_LD_FP(x)	x
+#define EX_LD_FP(x,y)	x
 #endif
 
 #ifndef EX_ST
-#define EX_ST(x)	x
+#define EX_ST(x,y)	x
 #endif
 #ifndef EX_ST_FP
-#define EX_ST_FP(x)	x
+#define EX_ST_FP(x,y)	x
 #endif
 
 #ifndef EX_RETVAL
@@ -206,9 +206,9 @@ FUNC_NAME:
 	sub	%o1, %o0, %o1		! %o1 gets the difference
 7:					! dst aligning loop
 	add	%o1, %o0, %o4
-	EX_LD(LOAD(ldub, %o4, %o4))	! load one byte
+	EX_LD(LOAD(ldub, %o4, %o4), memcpy_retl_o2_plus_o5)	! load one byte
 	subcc	%o5, 1, %o5
-	EX_ST(STORE(stb, %o4, %o0))
+	EX_ST(STORE(stb, %o4, %o0), memcpy_retl_o2_plus_o5_plus_1)
 	bgu,pt	%ncc, 7b
 	 add	%o0, 1, %o0		! advance dst
 	add	%o1, %o0, %o1		! restore %o1
@@ -233,64 +233,64 @@ FUNC_NAME:
 	ble,pn	%ncc, .Lmedl63		! skip big loop if less than 64 bytes
 	 nop
 .Lmedl64:
-	EX_LD(LOAD(ldx, %o1, %o4))	! load
+	EX_LD(LOAD(ldx, %o1, %o4), memcpy_retl_o2_plus_63)	! load
 	subcc	%o2, 64, %o2		! decrement length count
-	EX_ST(STORE(stx, %o4, %o0))	! and store
-	EX_LD(LOAD(ldx, %o1+8, %o3))	! a block of 64 bytes
-	EX_ST(STORE(stx, %o3, %o0+8))
-	EX_LD(LOAD(ldx, %o1+16, %o4))
-	EX_ST(STORE(stx, %o4, %o0+16))
-	EX_LD(LOAD(ldx, %o1+24, %o3))
-	EX_ST(STORE(stx, %o3, %o0+24))
-	EX_LD(LOAD(ldx, %o1+32, %o4))	! load
-	EX_ST(STORE(stx, %o4, %o0+32))	! and store
-	EX_LD(LOAD(ldx, %o1+40, %o3))	! a block of 64 bytes
+	EX_ST(STORE(stx, %o4, %o0), memcpy_retl_o2_plus_63_64)	! and store
+	EX_LD(LOAD(ldx, %o1+8, %o3), memcpy_retl_o2_plus_63_56)	! a block of 64
+	EX_ST(STORE(stx, %o3, %o0+8), memcpy_retl_o2_plus_63_56)
+	EX_LD(LOAD(ldx, %o1+16, %o4), memcpy_retl_o2_plus_63_48)
+	EX_ST(STORE(stx, %o4, %o0+16), memcpy_retl_o2_plus_63_48)
+	EX_LD(LOAD(ldx, %o1+24, %o3), memcpy_retl_o2_plus_63_40)
+	EX_ST(STORE(stx, %o3, %o0+24), memcpy_retl_o2_plus_63_40)
+	EX_LD(LOAD(ldx, %o1+32, %o4), memcpy_retl_o2_plus_63_32)! load and store
+	EX_ST(STORE(stx, %o4, %o0+32), memcpy_retl_o2_plus_63_32)
+	EX_LD(LOAD(ldx, %o1+40, %o3), memcpy_retl_o2_plus_63_24)! a block of 64
 	add	%o1, 64, %o1		! increase src ptr by 64
-	EX_ST(STORE(stx, %o3, %o0+40))
-	EX_LD(LOAD(ldx, %o1-16, %o4))
+	EX_ST(STORE(stx, %o3, %o0+40), memcpy_retl_o2_plus_63_24)
+	EX_LD(LOAD(ldx, %o1-16, %o4), memcpy_retl_o2_plus_63_16)
 	add	%o0, 64, %o0		! increase dst ptr by 64
-	EX_ST(STORE(stx, %o4, %o0-16))
-	EX_LD(LOAD(ldx, %o1-8, %o3))
+	EX_ST(STORE(stx, %o4, %o0-16), memcpy_retl_o2_plus_63_16)
+	EX_LD(LOAD(ldx, %o1-8, %o3), memcpy_retl_o2_plus_63_8)
 	bgu,pt	%ncc, .Lmedl64		! repeat if at least 64 bytes left
-	 EX_ST(STORE(stx, %o3, %o0-8))
+	 EX_ST(STORE(stx, %o3, %o0-8), memcpy_retl_o2_plus_63_8)
 .Lmedl63:
 	addcc	%o2, 32, %o2		! adjust remaining count
 	ble,pt	%ncc, .Lmedl31		! to skip if 31 or fewer bytes left
 	 nop
-	EX_LD(LOAD(ldx, %o1, %o4))	! load
+	EX_LD(LOAD(ldx, %o1, %o4), memcpy_retl_o2_plus_31)	! load
 	sub	%o2, 32, %o2		! decrement length count
-	EX_ST(STORE(stx, %o4, %o0))	! and store
-	EX_LD(LOAD(ldx, %o1+8, %o3))	! a block of 32 bytes
+	EX_ST(STORE(stx, %o4, %o0), memcpy_retl_o2_plus_31_32)	! and store
+	EX_LD(LOAD(ldx, %o1+8, %o3), memcpy_retl_o2_plus_31_24)	! a block of 32
 	add	%o1, 32, %o1		! increase src ptr by 32
-	EX_ST(STORE(stx, %o3, %o0+8))
-	EX_LD(LOAD(ldx, %o1-16, %o4))
+	EX_ST(STORE(stx, %o3, %o0+8), memcpy_retl_o2_plus_31_24)
+	EX_LD(LOAD(ldx, %o1-16, %o4), memcpy_retl_o2_plus_31_16)
 	add	%o0, 32, %o0		! increase dst ptr by 32
-	EX_ST(STORE(stx, %o4, %o0-16))
-	EX_LD(LOAD(ldx, %o1-8, %o3))
-	EX_ST(STORE(stx, %o3, %o0-8))
+	EX_ST(STORE(stx, %o4, %o0-16), memcpy_retl_o2_plus_31_16)
+	EX_LD(LOAD(ldx, %o1-8, %o3), memcpy_retl_o2_plus_31_8)
+	EX_ST(STORE(stx, %o3, %o0-8), memcpy_retl_o2_plus_31_8)
 .Lmedl31:
 	addcc	%o2, 16, %o2		! adjust remaining count
 	ble,pt	%ncc, .Lmedl15		! skip if 15 or fewer bytes left
 	 nop				!
-	EX_LD(LOAD(ldx, %o1, %o4))
+	EX_LD(LOAD(ldx, %o1, %o4), memcpy_retl_o2_plus_15)
 	add	%o1, 16, %o1		! increase src ptr by 16
-	EX_ST(STORE(stx, %o4, %o0))
+	EX_ST(STORE(stx, %o4, %o0), memcpy_retl_o2_plus_15)
 	sub	%o2, 16, %o2		! decrease count by 16
-	EX_LD(LOAD(ldx, %o1-8, %o3))
+	EX_LD(LOAD(ldx, %o1-8, %o3), memcpy_retl_o2_plus_15_8)
 	add	%o0, 16, %o0		! increase dst ptr by 16
-	EX_ST(STORE(stx, %o3, %o0-8))
+	EX_ST(STORE(stx, %o3, %o0-8), memcpy_retl_o2_plus_15_8)
 .Lmedl15:
 	addcc	%o2, 15, %o2		! restore count
 	bz,pt	%ncc, .Lsmallx	! exit if finished
 	 cmp	%o2, 8
 	blt,pt	%ncc, .Lmedw7		! skip if 7 or fewer bytes left
 	 tst	%o2
-	EX_LD(LOAD(ldx, %o1, %o4))	! load 8 bytes
+	EX_LD(LOAD(ldx, %o1, %o4), memcpy_retl_o2)	! load 8 bytes
 	add	%o1, 8, %o1		! increase src ptr by 8
 	add	%o0, 8, %o0		! increase dst ptr by 8
 	subcc	%o2, 8, %o2		! decrease count by 8
 	bnz,pn	%ncc, .Lmedw7
-	EX_ST(STORE(stx, %o4, %o0-8))	! and store 8 bytes
+	 EX_ST(STORE(stx, %o4, %o0-8), memcpy_retl_o2_plus_8)	! and store 8
 	retl
 	 mov	EX_RETVAL(%g1), %o0	! restore %o0
 
@@ -318,30 +318,30 @@ FUNC_NAME:
 					! for end of loop
 	ble,pt	%ncc, .Lmedw31		! skip big loop if less than 16
 .Lmedw32:
-	EX_LD(LOAD(ld, %o1, %o4))	! move a block of 32 bytes
+	EX_LD(LOAD(ld, %o1, %o4), memcpy_retl_o2_plus_31)! move a block of 32
 	sllx	%o4, 32, %o5
-	EX_LD(LOAD(ld, %o1+4, %o4))
+	EX_LD(LOAD(ld, %o1+4, %o4), memcpy_retl_o2_plus_31)
 	or	%o4, %o5, %o5
-	EX_ST(STORE(stx, %o5, %o0))
+	EX_ST(STORE(stx, %o5, %o0), memcpy_retl_o2_plus_31)
 	subcc	%o2, 32, %o2		! decrement length count
-	EX_LD(LOAD(ld, %o1+8, %o4))
+	EX_LD(LOAD(ld, %o1+8, %o4), memcpy_retl_o2_plus_31_24)
 	sllx	%o4, 32, %o5
-	EX_LD(LOAD(ld, %o1+12, %o4))
+	EX_LD(LOAD(ld, %o1+12, %o4), memcpy_retl_o2_plus_31_24)
 	or	%o4, %o5, %o5
-	EX_ST(STORE(stx, %o5, %o0+8))
+	EX_ST(STORE(stx, %o5, %o0+8), memcpy_retl_o2_plus_31_24)
 	add	%o1, 32, %o1		! increase src ptr by 32
-	EX_LD(LOAD(ld, %o1-16, %o4))
+	EX_LD(LOAD(ld, %o1-16, %o4), memcpy_retl_o2_plus_31_16)
 	sllx	%o4, 32, %o5
-	EX_LD(LOAD(ld, %o1-12, %o4))
+	EX_LD(LOAD(ld, %o1-12, %o4), memcpy_retl_o2_plus_31_16)
 	or	%o4, %o5, %o5
-	EX_ST(STORE(stx, %o5, %o0+16))
+	EX_ST(STORE(stx, %o5, %o0+16), memcpy_retl_o2_plus_31_16)
 	add	%o0, 32, %o0		! increase dst ptr by 32
-	EX_LD(LOAD(ld, %o1-8, %o4))
+	EX_LD(LOAD(ld, %o1-8, %o4), memcpy_retl_o2_plus_31_8)
 	sllx	%o4, 32, %o5
-	EX_LD(LOAD(ld, %o1-4, %o4))
+	EX_LD(LOAD(ld, %o1-4, %o4), memcpy_retl_o2_plus_31_8)
 	or	%o4, %o5, %o5
 	bgu,pt	%ncc, .Lmedw32		! repeat if at least 32 bytes left
-	 EX_ST(STORE(stx, %o5, %o0-8))
+	 EX_ST(STORE(stx, %o5, %o0-8), memcpy_retl_o2_plus_31_8)
 .Lmedw31:
 	addcc	%o2, 31, %o2		! restore count
 
@@ -350,42 +350,42 @@ FUNC_NAME:
 	cmp	%o2, 16
 	blt,pt	%ncc, .Lmedw15
 	 nop
-	EX_LD(LOAD(ld, %o1, %o4))	! move a block of 16 bytes
+	EX_LD(LOAD(ld, %o1, %o4), memcpy_retl_o2)! move a block of 16 bytes
 	sllx	%o4, 32, %o5
 	subcc	%o2, 16, %o2		! decrement length count
-	EX_LD(LOAD(ld, %o1+4, %o4))
+	EX_LD(LOAD(ld, %o1+4, %o4), memcpy_retl_o2_plus_16)
 	or	%o4, %o5, %o5
-	EX_ST(STORE(stx, %o5, %o0))
+	EX_ST(STORE(stx, %o5, %o0), memcpy_retl_o2_plus_16)
 	add	%o1, 16, %o1		! increase src ptr by 16
-	EX_LD(LOAD(ld, %o1-8, %o4))
+	EX_LD(LOAD(ld, %o1-8, %o4), memcpy_retl_o2_plus_8)
 	add	%o0, 16, %o0		! increase dst ptr by 16
 	sllx	%o4, 32, %o5
-	EX_LD(LOAD(ld, %o1-4, %o4))
+	EX_LD(LOAD(ld, %o1-4, %o4), memcpy_retl_o2_plus_8)
 	or	%o4, %o5, %o5
-	EX_ST(STORE(stx, %o5, %o0-8))
+	EX_ST(STORE(stx, %o5, %o0-8), memcpy_retl_o2_plus_8)
 .Lmedw15:
 	bz,pt	%ncc, .Lsmallx	! exit if finished
 	 cmp	%o2, 8
 	blt,pn	%ncc, .Lmedw7		! skip if 7 or fewer bytes left
 	 tst	%o2
-	EX_LD(LOAD(ld, %o1, %o4))	! load 4 bytes
+	EX_LD(LOAD(ld, %o1, %o4), memcpy_retl_o2)	! load 4 bytes
 	subcc	%o2, 8, %o2		! decrease count by 8
-	EX_ST(STORE(stw, %o4, %o0))	! and store 4 bytes
+	EX_ST(STORE(stw, %o4, %o0), memcpy_retl_o2_plus_8)! and store 4 bytes
 	add	%o1, 8, %o1		! increase src ptr by 8
-	EX_LD(LOAD(ld, %o1-4, %o3))	! load 4 bytes
+	EX_LD(LOAD(ld, %o1-4, %o3), memcpy_retl_o2_plus_4)	! load 4 bytes
 	add	%o0, 8, %o0		! increase dst ptr by 8
-	EX_ST(STORE(stw, %o3, %o0-4))	! and store 4 bytes
+	EX_ST(STORE(stw, %o3, %o0-4), memcpy_retl_o2_plus_4)! and store 4 bytes
 	bz,pt	%ncc, .Lsmallx	! exit if finished
 .Lmedw7:				! count is ge 1, less than 8
 	cmp	%o2, 4			! check for 4 bytes left
 	blt,pn	%ncc, .Lsmallleft3	! skip if 3 or fewer bytes left
 	 nop				!
-	EX_LD(LOAD(ld, %o1, %o4))	! load 4 bytes
+	EX_LD(LOAD(ld, %o1, %o4), memcpy_retl_o2)	! load 4 bytes
 	add	%o1, 4, %o1		! increase src ptr by 4
 	add	%o0, 4, %o0		! increase dst ptr by 4
 	subcc	%o2, 4, %o2		! decrease count by 4
 	bnz	.Lsmallleft3
-	 EX_ST(STORE(stw, %o4, %o0-4))! and store 4 bytes
+	 EX_ST(STORE(stw, %o4, %o0-4), memcpy_retl_o2_plus_4)! and store 4 bytes
 	retl
 	 mov	EX_RETVAL(%g1), %o0
 
@@ -397,37 +397,37 @@ FUNC_NAME:
 	 andcc	%o0, 8, %o3		! odd long words to move?
 	brz,pt	%o3, .Laligned_to_16
 	 nop
-	EX_LD(LOAD(ldx, %o1, %o4))
+	EX_LD(LOAD(ldx, %o1, %o4), memcpy_retl_o2)
 	sub	%o2, 8, %o2
 	add	%o1, 8, %o1		! increment src ptr
 	add	%o0, 8, %o0		! increment dst ptr
-	EX_ST(STORE(stx, %o4, %o0-8))
+	EX_ST(STORE(stx, %o4, %o0-8), memcpy_retl_o2_plus_8)
 .Laligned_to_16:
 	andcc	%o0, 16, %o3		! pair of long words to move?
 	brz,pt	%o3, .Laligned_to_32
 	 nop
-	EX_LD(LOAD(ldx, %o1, %o4))
+	EX_LD(LOAD(ldx, %o1, %o4), memcpy_retl_o2)
 	sub	%o2, 16, %o2
-	EX_ST(STORE(stx, %o4, %o0))
+	EX_ST(STORE(stx, %o4, %o0), memcpy_retl_o2_plus_16)
 	add	%o1, 16, %o1		! increment src ptr
-	EX_LD(LOAD(ldx, %o1-8, %o4))
+	EX_LD(LOAD(ldx, %o1-8, %o4), memcpy_retl_o2_plus_8)
 	add	%o0, 16, %o0		! increment dst ptr
-	EX_ST(STORE(stx, %o4, %o0-8))
+	EX_ST(STORE(stx, %o4, %o0-8), memcpy_retl_o2_plus_8)
 .Laligned_to_32:
 	andcc	%o0, 32, %o3		! four long words to move?
 	brz,pt	%o3, .Laligned_to_64
 	 nop
-	EX_LD(LOAD(ldx, %o1, %o4))
+	EX_LD(LOAD(ldx, %o1, %o4), memcpy_retl_o2)
 	sub	%o2, 32, %o2
-	EX_ST(STORE(stx, %o4, %o0))
-	EX_LD(LOAD(ldx, %o1+8, %o4))
-	EX_ST(STORE(stx, %o4, %o0+8))
-	EX_LD(LOAD(ldx, %o1+16, %o4))
-	EX_ST(STORE(stx, %o4, %o0+16))
+	EX_ST(STORE(stx, %o4, %o0), memcpy_retl_o2_plus_32)
+	EX_LD(LOAD(ldx, %o1+8, %o4), memcpy_retl_o2_plus_24)
+	EX_ST(STORE(stx, %o4, %o0+8), memcpy_retl_o2_plus_24)
+	EX_LD(LOAD(ldx, %o1+16, %o4), memcpy_retl_o2_plus_16)
+	EX_ST(STORE(stx, %o4, %o0+16), memcpy_retl_o2_plus_16)
 	add	%o1, 32, %o1		! increment src ptr
-	EX_LD(LOAD(ldx, %o1-8, %o4))
+	EX_LD(LOAD(ldx, %o1-8, %o4), memcpy_retl_o2_plus_8)
 	add	%o0, 32, %o0		! increment dst ptr
-	EX_ST(STORE(stx, %o4, %o0-8))
+	EX_ST(STORE(stx, %o4, %o0-8), memcpy_retl_o2_plus_8)
 .Laligned_to_64:
 !
 !	Using block init store (BIS) instructions to avoid fetching cache
@@ -461,10 +461,10 @@ FUNC_NAME:
 .Lalign_loop_start:
 	prefetch [%o1 + (ALIGN_PRE * BLOCK_SIZE)], 21
 	subcc	%o3, 1, %o3
-	EX_LD(LOAD(ldx, %o1, %o4))
+	EX_LD(LOAD(ldx, %o1, %o4), memcpy_retl_o2_plus_o5)
 	add	%o1, 64, %o1
 	add	%o0, 8, %o0
-	EX_ST(STORE_INIT_MRU(%o4, %o0))
+	EX_ST(STORE_INIT_MRU(%o4, %o0), memcpy_retl_o2_plus_o5)
 	bgu	%ncc,.Lalign_loop_start
 	 add	%o0, 56, %o0
 
@@ -474,32 +474,32 @@ FUNC_NAME:
 	sub	%o0, %o4, %o0		! reset %o0
 
 .Lalign_loop_rest:
-	EX_LD(LOAD(ldx, %o1+8, %o4))
+	EX_LD(LOAD(ldx, %o1+8, %o4), memcpy_retl_o2_plus_o5)
 	add	%o0, 16, %o0
-	EX_ST(STORE_INIT_MRU(%o4, %o0))
-	EX_LD(LOAD(ldx, %o1+16, %o4))
+	EX_ST(STORE_INIT_MRU(%o4, %o0), memcpy_retl_o2_plus_o5)
+	EX_LD(LOAD(ldx, %o1+16, %o4), memcpy_retl_o2_plus_o5)
 	add	%o0, 8, %o0
-	EX_ST(STORE_INIT_MRU(%o4, %o0))
+	EX_ST(STORE_INIT_MRU(%o4, %o0), memcpy_retl_o2_plus_o5)
 	subcc	%o3, 1, %o3
-	EX_LD(LOAD(ldx, %o1+24, %o4))
+	EX_LD(LOAD(ldx, %o1+24, %o4), memcpy_retl_o2_plus_o5)
 	add	%o0, 8, %o0
-	EX_ST(STORE_INIT_MRU(%o4, %o0))
-	EX_LD(LOAD(ldx, %o1+32, %o4))
+	EX_ST(STORE_INIT_MRU(%o4, %o0), memcpy_retl_o2_plus_o5)
+	EX_LD(LOAD(ldx, %o1+32, %o4), memcpy_retl_o2_plus_o5)
 	add	%o0, 8, %o0
-	EX_ST(STORE_INIT_MRU(%o4, %o0))
-	EX_LD(LOAD(ldx, %o1+40, %o4))
+	EX_ST(STORE_INIT_MRU(%o4, %o0), memcpy_retl_o2_plus_o5)
+	EX_LD(LOAD(ldx, %o1+40, %o4), memcpy_retl_o2_plus_o5)
 	add	%o0, 8, %o0
-	EX_ST(STORE_INIT_MRU(%o4, %o0))
-	EX_LD(LOAD(ldx, %o1+48, %o4))
+	EX_ST(STORE_INIT_MRU(%o4, %o0), memcpy_retl_o2_plus_o5)
+	EX_LD(LOAD(ldx, %o1+48, %o4), memcpy_retl_o2_plus_o5)
 	add	%o1, 64, %o1
 	add	%o0, 8, %o0
-	EX_ST(STORE_INIT_MRU(%o4, %o0))
+	EX_ST(STORE_INIT_MRU(%o4, %o0), memcpy_retl_o2_plus_o5)
 	add	%o0, 8, %o0
-	EX_LD(LOAD(ldx, %o1-8, %o4))
+	EX_LD(LOAD(ldx, %o1-8, %o4), memcpy_retl_o2_plus_o5)
 	sub	%o5, 64, %o5
 	bgu	%ncc,.Lalign_loop_rest
 	! mark cache line as LRU
-	 EX_ST(STORE_INIT(%o4, %o0))
+	 EX_ST(STORE_INIT(%o4, %o0), memcpy_retl_o2_plus_o5_plus_64)
 
 	cmp	%o5, ST_CHUNK*64
 	bgu,pt	%ncc, .Lalign_loop_start
@@ -509,26 +509,26 @@ FUNC_NAME:
 	beq	.Lalign_done
 	 nop
 .Lalign_loop_fin:
-	EX_LD(LOAD(ldx, %o1, %o4))
-	EX_ST(STORE(stx, %o4, %o0+8))
-	EX_LD(LOAD(ldx, %o1+8, %o4))
-	EX_ST(STORE(stx, %o4, %o0+8+8))
-	EX_LD(LOAD(ldx, %o1+16, %o4))
-	EX_ST(STORE(stx, %o4, %o0+8+16))
+	EX_LD(LOAD(ldx, %o1, %o4), memcpy_retl_o2_plus_o5)
+	EX_ST(STORE(stx, %o4, %o0+8), memcpy_retl_o2_plus_o5)
+	EX_LD(LOAD(ldx, %o1+8, %o4), memcpy_retl_o2_plus_o5)
+	EX_ST(STORE(stx, %o4, %o0+8+8), memcpy_retl_o2_plus_o5)
+	EX_LD(LOAD(ldx, %o1+16, %o4), memcpy_retl_o2_plus_o5)
+	EX_ST(STORE(stx, %o4, %o0+8+16), memcpy_retl_o2_plus_o5)
 	subcc	%o5, 64, %o5
-	EX_LD(LOAD(ldx, %o1+24, %o4))
-	EX_ST(STORE(stx, %o4, %o0+8+24))
-	EX_LD(LOAD(ldx, %o1+32, %o4))
-	EX_ST(STORE(stx, %o4, %o0+8+32))
-	EX_LD(LOAD(ldx, %o1+40, %o4))
-	EX_ST(STORE(stx, %o4, %o0+8+40))
-	EX_LD(LOAD(ldx, %o1+48, %o4))
+	EX_LD(LOAD(ldx, %o1+24, %o4), memcpy_retl_o2_plus_o5_64)
+	EX_ST(STORE(stx, %o4, %o0+8+24), memcpy_retl_o2_plus_o5_64)
+	EX_LD(LOAD(ldx, %o1+32, %o4), memcpy_retl_o2_plus_o5_64)
+	EX_ST(STORE(stx, %o4, %o0+8+32), memcpy_retl_o2_plus_o5_64)
+	EX_LD(LOAD(ldx, %o1+40, %o4), memcpy_retl_o2_plus_o5_64)
+	EX_ST(STORE(stx, %o4, %o0+8+40), memcpy_retl_o2_plus_o5_64)
+	EX_LD(LOAD(ldx, %o1+48, %o4), memcpy_retl_o2_plus_o5_64)
 	add	%o1, 64, %o1
-	EX_ST(STORE(stx, %o4, %o0+8+48))
+	EX_ST(STORE(stx, %o4, %o0+8+48), memcpy_retl_o2_plus_o5_64)
 	add	%o0, 64, %o0
-	EX_LD(LOAD(ldx, %o1-8, %o4))
+	EX_LD(LOAD(ldx, %o1-8, %o4), memcpy_retl_o2_plus_o5_64)
 	bgu	%ncc,.Lalign_loop_fin
-	 EX_ST(STORE(stx, %o4, %o0))
+	 EX_ST(STORE(stx, %o4, %o0), memcpy_retl_o2_plus_o5_64)
 
 .Lalign_done:
 	add	%o0, 8, %o0		! restore %o0 from ASI alignment
@@ -563,34 +563,34 @@ FUNC_NAME:
 .Lunalign_adjust:
 	alignaddr %o1, %g0, %g0		! generate %gsr
 	add	%o1, %o5, %o1		! advance %o1 to after blocks
-	EX_LD_FP(LOAD(ldd, %o4, %f0))
+	EX_LD_FP(LOAD(ldd, %o4, %f0), memcpy_retl_o2_plus_o5)
 .Lunalign_loop:
-	EX_LD_FP(LOAD(ldd, %o4+8, %f2))
+	EX_LD_FP(LOAD(ldd, %o4+8, %f2), memcpy_retl_o2_plus_o5)
 	faligndata %f0, %f2, %f16
-	EX_LD_FP(LOAD(ldd, %o4+16, %f4))
+	EX_LD_FP(LOAD(ldd, %o4+16, %f4), memcpy_retl_o2_plus_o5)
 	subcc	%o5, BLOCK_SIZE, %o5
-	EX_ST_FP(STORE(std, %f16, %o0))
+	EX_ST_FP(STORE(std, %f16, %o0), memcpy_retl_o2_plus_o5_plus_64)
 	faligndata %f2, %f4, %f18
-	EX_LD_FP(LOAD(ldd, %o4+24, %f6))
-	EX_ST_FP(STORE(std, %f18, %o0+8))
+	EX_LD_FP(LOAD(ldd, %o4+24, %f6), memcpy_retl_o2_plus_o5_plus_56)
+	EX_ST_FP(STORE(std, %f18, %o0+8), memcpy_retl_o2_plus_o5_plus_56)
 	faligndata %f4, %f6, %f20
-	EX_LD_FP(LOAD(ldd, %o4+32, %f8))
-	EX_ST_FP(STORE(std, %f20, %o0+16))
+	EX_LD_FP(LOAD(ldd, %o4+32, %f8), memcpy_retl_o2_plus_o5_plus_48)
+	EX_ST_FP(STORE(std, %f20, %o0+16), memcpy_retl_o2_plus_o5_plus_48)
 	faligndata %f6, %f8, %f22
-	EX_LD_FP(LOAD(ldd, %o4+40, %f10))
-	EX_ST_FP(STORE(std, %f22, %o0+24))
+	EX_LD_FP(LOAD(ldd, %o4+40, %f10), memcpy_retl_o2_plus_o5_plus_40)
+	EX_ST_FP(STORE(std, %f22, %o0+24), memcpy_retl_o2_plus_o5_plus_40)
 	faligndata %f8, %f10, %f24
-	EX_LD_FP(LOAD(ldd, %o4+48, %f12))
-	EX_ST_FP(STORE(std, %f24, %o0+32))
+	EX_LD_FP(LOAD(ldd, %o4+48, %f12), memcpy_retl_o2_plus_o5_plus_32)
+	EX_ST_FP(STORE(std, %f24, %o0+32), memcpy_retl_o2_plus_o5_plus_32)
 	faligndata %f10, %f12, %f26
-	EX_LD_FP(LOAD(ldd, %o4+56, %f14))
+	EX_LD_FP(LOAD(ldd, %o4+56, %f14), memcpy_retl_o2_plus_o5_plus_24)
 	add	%o4, BLOCK_SIZE, %o4
-	EX_ST_FP(STORE(std, %f26, %o0+40))
+	EX_ST_FP(STORE(std, %f26, %o0+40), memcpy_retl_o2_plus_o5_plus_24)
 	faligndata %f12, %f14, %f28
-	EX_LD_FP(LOAD(ldd, %o4, %f0))
-	EX_ST_FP(STORE(std, %f28, %o0+48))
+	EX_LD_FP(LOAD(ldd, %o4, %f0), memcpy_retl_o2_plus_o5_plus_16)
+	EX_ST_FP(STORE(std, %f28, %o0+48), memcpy_retl_o2_plus_o5_plus_16)
 	faligndata %f14, %f0, %f30
-	EX_ST_FP(STORE(std, %f30, %o0+56))
+	EX_ST_FP(STORE(std, %f30, %o0+56), memcpy_retl_o2_plus_o5_plus_8)
 	add	%o0, BLOCK_SIZE, %o0
 	bgu,pt	%ncc, .Lunalign_loop
 	 prefetch [%o4 + (5 * BLOCK_SIZE)], 20
@@ -612,27 +612,27 @@ FUNC_NAME:
 	 nop
 	! Src is word aligned
 .Lunalignword:
-	EX_LD_FP(LOAD(ld, %o1, %o4))	! load 4 bytes
+	EX_LD_FP(LOAD(ld, %o1, %o4), memcpy_retl_o2_plus_o3)	! load 4 bytes
 	add	%o1, 8, %o1		! increase src ptr by 8
-	EX_ST_FP(STORE(stw, %o4, %o0))	! and store 4 bytes
+	EX_ST_FP(STORE(stw, %o4, %o0), memcpy_retl_o2_plus_o3)	! and store 4
 	subcc	%o3, 8, %o3		! decrease count by 8
-	EX_LD_FP(LOAD(ld, %o1-4, %o4))	! load 4 bytes
+	EX_LD_FP(LOAD(ld, %o1-4, %o4), memcpy_retl_o2_plus_o3_plus_4)! load 4
 	add	%o0, 8, %o0		! increase dst ptr by 8
 	bnz	%ncc, .Lunalignword
-	 EX_ST_FP(STORE(stw, %o4, %o0-4))! and store 4 bytes
+	 EX_ST_FP(STORE(stw, %o4, %o0-4), memcpy_retl_o2_plus_o3_plus_4)
 	ba	.Lunalignsrc
 	 nop
 
 	! Src is half-word aligned
 .Lunalignhalf:
-	EX_LD_FP(LOAD(lduh, %o1, %o4))	! load 2 bytes
+	EX_LD_FP(LOAD(lduh, %o1, %o4), memcpy_retl_o2_plus_o3)	! load 2 bytes
 	sllx	%o4, 32, %o5		! shift left
-	EX_LD_FP(LOAD(lduw, %o1+2, %o4))
+	EX_LD_FP(LOAD(lduw, %o1+2, %o4), memcpy_retl_o2_plus_o3)
 	or	%o4, %o5, %o5
 	sllx	%o5, 16, %o5
-	EX_LD_FP(LOAD(lduh, %o1+6, %o4))
+	EX_LD_FP(LOAD(lduh, %o1+6, %o4), memcpy_retl_o2_plus_o3)
 	or	%o4, %o5, %o5
-	EX_ST_FP(STORE(stx, %o5, %o0))
+	EX_ST_FP(STORE(stx, %o5, %o0), memcpy_retl_o2_plus_o3)
 	add	%o1, 8, %o1
 	subcc	%o3, 8, %o3
 	bnz	%ncc, .Lunalignhalf
@@ -644,21 +644,21 @@ FUNC_NAME:
 .Lunalignbyte:
 	sub	%o0, %o1, %o0		! share pointer advance
 .Lunalignbyte_loop:
-	EX_LD_FP(LOAD(ldub, %o1, %o4))
+	EX_LD_FP(LOAD(ldub, %o1, %o4), memcpy_retl_o2_plus_o3)
 	sllx	%o4, 56, %o5
-	EX_LD_FP(LOAD(lduh, %o1+1, %o4))
+	EX_LD_FP(LOAD(lduh, %o1+1, %o4), memcpy_retl_o2_plus_o3)
 	sllx	%o4, 40, %o4
 	or	%o4, %o5, %o5
-	EX_LD_FP(LOAD(lduh, %o1+3, %o4))
+	EX_LD_FP(LOAD(lduh, %o1+3, %o4), memcpy_retl_o2_plus_o3)
 	sllx	%o4, 24, %o4
 	or	%o4, %o5, %o5
-	EX_LD_FP(LOAD(lduh, %o1+5, %o4))
+	EX_LD_FP(LOAD(lduh, %o1+5, %o4), memcpy_retl_o2_plus_o3)
 	sllx	%o4,  8, %o4
 	or	%o4, %o5, %o5
-	EX_LD_FP(LOAD(ldub, %o1+7, %o4))
+	EX_LD_FP(LOAD(ldub, %o1+7, %o4), memcpy_retl_o2_plus_o3)
 	or	%o4, %o5, %o5
 	add	%o0, %o1, %o0
-	EX_ST_FP(STORE(stx, %o5, %o0))
+	EX_ST_FP(STORE(stx, %o5, %o0), memcpy_retl_o2_plus_o3)
 	sub	%o0, %o1, %o0
 	subcc	%o3, 8, %o3
 	bnz	%ncc, .Lunalignbyte_loop
@@ -676,36 +676,36 @@ FUNC_NAME:
 	alignaddr %o1, %g0, %g0		! generate %gsr
 	add	%o1, %o5, %o1		! advance %o1 to after blocks
 
-	EX_LD_FP(LOAD(ldd, %o4, %f14))
+	EX_LD_FP(LOAD(ldd, %o4, %f14), memcpy_retl_o2_plus_o5)
 	add	%o4, 8, %o4
 .Lunalign_sloop:
-	EX_LD_FP(LOAD(ldd, %o4, %f16))
+	EX_LD_FP(LOAD(ldd, %o4, %f16), memcpy_retl_o2_plus_o5)
 	faligndata %f14, %f16, %f0
-	EX_LD_FP(LOAD(ldd, %o4+8, %f18))
+	EX_LD_FP(LOAD(ldd, %o4+8, %f18), memcpy_retl_o2_plus_o5)
 	faligndata %f16, %f18, %f2
-	EX_LD_FP(LOAD(ldd, %o4+16, %f20))
+	EX_LD_FP(LOAD(ldd, %o4+16, %f20), memcpy_retl_o2_plus_o5)
 	faligndata %f18, %f20, %f4
-	EX_ST_FP(STORE(std, %f0, %o0))
+	EX_ST_FP(STORE(std, %f0, %o0), memcpy_retl_o2_plus_o5)
 	subcc	%o5, 64, %o5
-	EX_LD_FP(LOAD(ldd, %o4+24, %f22))
+	EX_LD_FP(LOAD(ldd, %o4+24, %f22), memcpy_retl_o2_plus_o5_plus_56)
 	faligndata %f20, %f22, %f6
-	EX_ST_FP(STORE(std, %f2, %o0+8))
-	EX_LD_FP(LOAD(ldd, %o4+32, %f24))
+	EX_ST_FP(STORE(std, %f2, %o0+8), memcpy_retl_o2_plus_o5_plus_56)
+	EX_LD_FP(LOAD(ldd, %o4+32, %f24), memcpy_retl_o2_plus_o5_plus_48)
 	faligndata %f22, %f24, %f8
-	EX_ST_FP(STORE(std, %f4, %o0+16))
-	EX_LD_FP(LOAD(ldd, %o4+40, %f26))
+	EX_ST_FP(STORE(std, %f4, %o0+16), memcpy_retl_o2_plus_o5_plus_48)
+	EX_LD_FP(LOAD(ldd, %o4+40, %f26), memcpy_retl_o2_plus_o5_plus_40)
 	faligndata %f24, %f26, %f10
-	EX_ST_FP(STORE(std, %f6, %o0+24))
-	EX_LD_FP(LOAD(ldd, %o4+48, %f28))
+	EX_ST_FP(STORE(std, %f6, %o0+24), memcpy_retl_o2_plus_o5_plus_40)
+	EX_LD_FP(LOAD(ldd, %o4+48, %f28), memcpy_retl_o2_plus_o5_plus_40)
 	faligndata %f26, %f28, %f12
-	EX_ST_FP(STORE(std, %f8, %o0+32))
+	EX_ST_FP(STORE(std, %f8, %o0+32), memcpy_retl_o2_plus_o5_plus_40)
 	add	%o4, 64, %o4
-	EX_LD_FP(LOAD(ldd, %o4-8, %f30))
+	EX_LD_FP(LOAD(ldd, %o4-8, %f30), memcpy_retl_o2_plus_o5_plus_40)
 	faligndata %f28, %f30, %f14
-	EX_ST_FP(STORE(std, %f10, %o0+40))
-	EX_ST_FP(STORE(std, %f12, %o0+48))
+	EX_ST_FP(STORE(std, %f10, %o0+40), memcpy_retl_o2_plus_o5_plus_40)
+	EX_ST_FP(STORE(std, %f12, %o0+48), memcpy_retl_o2_plus_o5_plus_40)
 	add	%o0, 64, %o0
-	EX_ST_FP(STORE(std, %f14, %o0-8))
+	EX_ST_FP(STORE(std, %f14, %o0-8), memcpy_retl_o2_plus_o5_plus_40)
 	fsrc2	%f30, %f14
 	bgu,pt	%ncc, .Lunalign_sloop
 	 prefetch [%o4 + (8 * BLOCK_SIZE)], 20
@@ -722,13 +722,13 @@ FUNC_NAME:
 	sub	%o5, 8, %o5		! insure we do not load past end of src
 	andn	%o1, 0x7, %o4		! %o4 has long word aligned src address
 	add	%o1, %o5, %o1		! advance %o1 to after multiple of 8
-	EX_LD_FP(LOAD(ldd, %o4, %f0))	! fetch partial word
+	EX_LD_FP(LOAD(ldd, %o4, %f0), memcpy_retl_o2_plus_o5)! fetch partialword
 .Lunalign_by8:
-	EX_LD_FP(LOAD(ldd, %o4+8, %f2))
+	EX_LD_FP(LOAD(ldd, %o4+8, %f2), memcpy_retl_o2_plus_o5)
 	add	%o4, 8, %o4
 	faligndata %f0, %f2, %f16
 	subcc	%o5, 8, %o5
-	EX_ST_FP(STORE(std, %f16, %o0))
+	EX_ST_FP(STORE(std, %f16, %o0), memcpy_retl_o2_plus_o5)
 	fsrc2	%f2, %f0
 	bgu,pt	%ncc, .Lunalign_by8
 	 add	%o0, 8, %o0
@@ -764,37 +764,37 @@ FUNC_NAME:
 	andncc	%o2, 0x20 - 1, %o5
 	be,pn	%ncc, 2f
 	 sub	%o2, %o5, %o2
-1:	EX_LD(LOAD(ldx, %o1 + 0x00, %o3))
-	EX_LD(LOAD(ldx, %o1 + 0x08, %g2))
-	EX_LD(LOAD(ldx, %o1 + 0x10, %g7))
-	EX_LD(LOAD(ldx, %o1 + 0x18, %o4))
+1:	EX_LD(LOAD(ldx, %o1 + 0x00, %o3), memcpy_retl_o2_plus_o5)
+	EX_LD(LOAD(ldx, %o1 + 0x08, %g2), memcpy_retl_o2_plus_o5)
+	EX_LD(LOAD(ldx, %o1 + 0x10, %g7), memcpy_retl_o2_plus_o5)
+	EX_LD(LOAD(ldx, %o1 + 0x18, %o4), memcpy_retl_o2_plus_o5)
 	add	%o1, 0x20, %o1
 	subcc	%o5, 0x20, %o5
-	EX_ST(STORE(stx, %o3, %o0 + 0x00))
-	EX_ST(STORE(stx, %g2, %o0 + 0x08))
-	EX_ST(STORE(stx, %g7, %o0 + 0x10))
-	EX_ST(STORE(stx, %o4, %o0 + 0x18))
+	EX_ST(STORE(stx, %o3, %o0 + 0x00), memcpy_retl_o2_plus_o5_plus_32)
+	EX_ST(STORE(stx, %g2, %o0 + 0x08), memcpy_retl_o2_plus_o5_plus_24)
+	EX_ST(STORE(stx, %g7, %o0 + 0x10), memcpy_retl_o2_plus_o5_plus_24)
+	EX_ST(STORE(stx, %o4, %o0 + 0x18), memcpy_retl_o2_plus_o5_plus_8)
 	bne,pt	%ncc, 1b
 	 add	%o0, 0x20, %o0
 2:	andcc	%o2, 0x18, %o5
 	be,pt	%ncc, 3f
 	 sub	%o2, %o5, %o2
-1:	EX_LD(LOAD(ldx, %o1 + 0x00, %o3))
+1:	EX_LD(LOAD(ldx, %o1 + 0x00, %o3), memcpy_retl_o2_plus_o5)
 	add	%o1, 0x08, %o1
 	add	%o0, 0x08, %o0
 	subcc	%o5, 0x08, %o5
 	bne,pt	%ncc, 1b
-	 EX_ST(STORE(stx, %o3, %o0 - 0x08))
+	 EX_ST(STORE(stx, %o3, %o0 - 0x08), memcpy_retl_o2_plus_o5_plus_8)
 3:	brz,pt	%o2, .Lexit_cp
 	 cmp	%o2, 0x04
 	bl,pn	%ncc, .Ltiny_cp
 	 nop
-	EX_LD(LOAD(lduw, %o1 + 0x00, %o3))
+	EX_LD(LOAD(lduw, %o1 + 0x00, %o3), memcpy_retl_o2)
 	add	%o1, 0x04, %o1
 	add	%o0, 0x04, %o0
 	subcc	%o2, 0x04, %o2
 	bne,pn	%ncc, .Ltiny_cp
-	 EX_ST(STORE(stw, %o3, %o0 - 0x04))
+	 EX_ST(STORE(stw, %o3, %o0 - 0x04), memcpy_retl_o2_plus_4)
 	ba,a,pt	%ncc, .Lexit_cp
 
 .Lmedium_unaligned_cp:
@@ -804,12 +804,12 @@ FUNC_NAME:
 	brz,pt	%o3, 2f
 	 sub	%o2, %o3, %o2
 
-1:	EX_LD(LOAD(ldub, %o1 + 0x00, %g2))
+1:	EX_LD(LOAD(ldub, %o1 + 0x00, %g2), memcpy_retl_o2_plus_g1)
 	add	%o1, 1, %o1
 	subcc	%o3, 1, %o3
 	add	%o0, 1, %o0
 	bne,pt	%ncc, 1b
-	 EX_ST(STORE(stb, %g2, %o0 - 0x01))
+	 EX_ST(STORE(stb, %g2, %o0 - 0x01), memcpy_retl_o2_plus_g1_plus_1)
 2:
 	and	%o1, 0x7, %o3
 	brz,pn	%o3, .Lmedium_noprefetch_cp
@@ -817,17 +817,17 @@ FUNC_NAME:
 	mov	64, %g2
 	sub	%g2, %o3, %g2
 	andn	%o1, 0x7, %o1
-	EX_LD(LOAD(ldx, %o1 + 0x00, %o4))
+	EX_LD(LOAD(ldx, %o1 + 0x00, %o4), memcpy_retl_o2)
 	sllx	%o4, %o3, %o4
 	andn	%o2, 0x08 - 1, %o5
 	sub	%o2, %o5, %o2
 
-1:	EX_LD(LOAD(ldx, %o1 + 0x08, %g3))
+1:	EX_LD(LOAD(ldx, %o1 + 0x08, %g3), memcpy_retl_o2_plus_o5)
 	add	%o1, 0x08, %o1
 	subcc	%o5, 0x08, %o5
 	srlx	%g3, %g2, %g7
 	or	%g7, %o4, %g7
-	EX_ST(STORE(stx, %g7, %o0 + 0x00))
+	EX_ST(STORE(stx, %g7, %o0 + 0x00), memcpy_retl_o2_plus_o5_plus_8)
 	add	%o0, 0x08, %o0
 	bne,pt	%ncc, 1b
 	 sllx	%g3, %o3, %o4
@@ -838,17 +838,17 @@ FUNC_NAME:
 	ba,pt	%ncc, .Lsmall_unaligned_cp
 
 .Ltiny_cp:
-	EX_LD(LOAD(ldub, %o1 + 0x00, %o3))
+	EX_LD(LOAD(ldub, %o1 + 0x00, %o3), memcpy_retl_o2)
 	subcc	%o2, 1, %o2
 	be,pn	%ncc, .Lexit_cp
-	 EX_ST(STORE(stb, %o3, %o0 + 0x00))
-	EX_LD(LOAD(ldub, %o1 + 0x01, %o3))
+	 EX_ST(STORE(stb, %o3, %o0 + 0x00), memcpy_retl_o2_plus_1)
+	EX_LD(LOAD(ldub, %o1 + 0x01, %o3), memcpy_retl_o2)
 	subcc	%o2, 1, %o2
 	be,pn	%ncc, .Lexit_cp
-	 EX_ST(STORE(stb, %o3, %o0 + 0x01))
-	EX_LD(LOAD(ldub, %o1 + 0x02, %o3))
+	 EX_ST(STORE(stb, %o3, %o0 + 0x01), memcpy_retl_o2_plus_1)
+	EX_LD(LOAD(ldub, %o1 + 0x02, %o3), memcpy_retl_o2)
 	ba,pt	%ncc, .Lexit_cp
-	 EX_ST(STORE(stb, %o3, %o0 + 0x02))
+	 EX_ST(STORE(stb, %o3, %o0 + 0x02), memcpy_retl_o2)
 
 .Lsmall_cp:
 	andcc	%g2, 0x3, %g0
@@ -856,23 +856,23 @@ FUNC_NAME:
 	 andn	%o2, 0x4 - 1, %o5
 	sub	%o2, %o5, %o2
 1:
-	EX_LD(LOAD(lduw, %o1 + 0x00, %o3))
+	EX_LD(LOAD(lduw, %o1 + 0x00, %o3), memcpy_retl_o2_plus_o5)
 	add	%o1, 0x04, %o1
 	subcc	%o5, 0x04, %o5
 	add	%o0, 0x04, %o0
 	bne,pt	%ncc, 1b
-	 EX_ST(STORE(stw, %o3, %o0 - 0x04))
+	 EX_ST(STORE(stw, %o3, %o0 - 0x04), memcpy_retl_o2_plus_o5_plus_4)
 	brz,pt	%o2, .Lexit_cp
 	 nop
 	ba,a,pt	%ncc, .Ltiny_cp
 
 .Lsmall_unaligned_cp:
-1:	EX_LD(LOAD(ldub, %o1 + 0x00, %o3))
+1:	EX_LD(LOAD(ldub, %o1 + 0x00, %o3), memcpy_retl_o2)
 	add	%o1, 1, %o1
 	add	%o0, 1, %o0
 	subcc	%o2, 1, %o2
 	bne,pt	%ncc, 1b
-	 EX_ST(STORE(stb, %o3, %o0 - 0x01))
+	 EX_ST(STORE(stb, %o3, %o0 - 0x01), memcpy_retl_o2_plus_1)
 	ba,a,pt	%ncc, .Lexit_cp
 
 .Lsmallrest:
@@ -883,31 +883,31 @@ FUNC_NAME:
 	 nop
 	sub	%o2, 3, %o2
 .Lsmallnotalign4:
-	EX_LD(LOAD(ldub, %o1, %o3))! read byte
+	EX_LD(LOAD(ldub, %o1, %o3), memcpy_retl_o2_plus_3)! read byte
 	subcc	%o2, 4, %o2		! reduce count by 4
-	EX_ST(STORE(stb, %o3, %o0))	! write byte
-	EX_LD(LOAD(ldub, %o1+1, %o3))! repeat for total of 4 bytes
+	EX_ST(STORE(stb, %o3, %o0), memcpy_retl_o2_plus_7)! write byte & repeat
+	EX_LD(LOAD(ldub, %o1+1, %o3), memcpy_retl_o2_plus_6)! for total of 4
 	add	%o1, 4, %o1		! advance SRC by 4
-	EX_ST(STORE(stb, %o3, %o0+1))
-	EX_LD(LOAD(ldub, %o1-2, %o3))
+	EX_ST(STORE(stb, %o3, %o0+1), memcpy_retl_o2_plus_6)
+	EX_LD(LOAD(ldub, %o1-2, %o3), memcpy_retl_o2_plus_5)
 	add	%o0, 4, %o0		! advance DST by 4
-	EX_ST(STORE(stb, %o3, %o0-2))
-	EX_LD(LOAD(ldub, %o1-1, %o3))
+	EX_ST(STORE(stb, %o3, %o0-2), memcpy_retl_o2_plus_5)
+	EX_LD(LOAD(ldub, %o1-1, %o3), memcpy_retl_o2_plus_4)
 	bgu,pt	%ncc, .Lsmallnotalign4	! loop til 3 or fewer bytes remain
-	EX_ST(STORE(stb, %o3, %o0-1))
+	EX_ST(STORE(stb, %o3, %o0-1), memcpy_retl_o2_plus_4)
 	addcc	%o2, 3, %o2		! restore count
 	bz,pt	%ncc, .Lsmallx
 .Lsmallleft3:				! 1, 2, or 3 bytes remain
 	subcc	%o2, 1, %o2
-	EX_LD(LOAD(ldub, %o1, %o3))	! load one byte
+	EX_LD(LOAD(ldub, %o1, %o3), memcpy_retl_o2_plus_1)	! load one byte
 	bz,pt	%ncc, .Lsmallx
-	 EX_ST(STORE(stb, %o3, %o0))	! store one byte
-	EX_LD(LOAD(ldub, %o1+1, %o3))	! load second byte
+	EX_ST(STORE(stb, %o3, %o0), memcpy_retl_o2_plus_1)	! store one byte
+	EX_LD(LOAD(ldub, %o1+1, %o3), memcpy_retl_o2)	! load second byte
 	subcc	%o2, 1, %o2
 	bz,pt	%ncc, .Lsmallx
-	 EX_ST(STORE(stb, %o3, %o0+1))! store second byte
-	EX_LD(LOAD(ldub, %o1+2, %o3))	! load third byte
-	EX_ST(STORE(stb, %o3, %o0+2))	! store third byte
+	EX_ST(STORE(stb, %o3, %o0+1), memcpy_retl_o2_plus_1)! store second byte
+	EX_LD(LOAD(ldub, %o1+2, %o3), memcpy_retl_o2)	! load third byte
+	EX_ST(STORE(stb, %o3, %o0+2), memcpy_retl_o2)	! store third byte
 .Lsmallx:
 	retl
 	 mov	EX_RETVAL(%g1), %o0
diff --git a/arch/sparc/lib/Memcpy_utils.S b/arch/sparc/lib/Memcpy_utils.S
index bcc5d77..64fbac2 100644
--- a/arch/sparc/lib/Memcpy_utils.S
+++ b/arch/sparc/lib/Memcpy_utils.S
@@ -24,14 +24,128 @@ ENTRY(memcpy_retl_o2_plus_1)
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, 1, %o0
 ENDPROC(memcpy_retl_o2_plus_1)
+ENTRY(memcpy_retl_o2_plus_3)
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 3, %o0
+ENDPROC(memcpy_retl_o2_plus_3)
 ENTRY(memcpy_retl_o2_plus_4)
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, 4, %o0
 ENDPROC(memcpy_retl_o2_plus_4)
+ENTRY(memcpy_retl_o2_plus_5)
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 5, %o0
+ENDPROC(memcpy_retl_o2_plus_5)
+ENTRY(memcpy_retl_o2_plus_6)
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 6, %o0
+ENDPROC(memcpy_retl_o2_plus_6)
+ENTRY(memcpy_retl_o2_plus_7)
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 7, %o0
+ENDPROC(memcpy_retl_o2_plus_7)
+ENTRY(memcpy_retl_o2_plus_8)
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 8, %o0
+ENDPROC(memcpy_retl_o2_plus_8)
+ENTRY(memcpy_retl_o2_plus_15)
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 15, %o0
+ENDPROC(memcpy_retl_o2_plus_15)
+ENTRY(memcpy_retl_o2_plus_15_8)
+	 add	%o2, 15, %o2
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 8, %o0
+ENDPROC(memcpy_retl_o2_plus_15_8)
+ENTRY(memcpy_retl_o2_plus_16)
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 16, %o0
+ENDPROC(memcpy_retl_o2_plus_16)
+ENTRY(memcpy_retl_o2_plus_24)
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 24, %o0
+ENDPROC(memcpy_retl_o2_plus_24)
+ENTRY(memcpy_retl_o2_plus_31)
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 31, %o0
+ENDPROC(memcpy_retl_o2_plus_31)
+ENTRY(memcpy_retl_o2_plus_32)
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 32, %o0
+ENDPROC(memcpy_retl_o2_plus_32)
+ENTRY(memcpy_retl_o2_plus_31_32)
+	add	%o2, 31, %o2
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 32, %o0
+ENDPROC(memcpy_retl_o2_plus_31_32)
+ENTRY(memcpy_retl_o2_plus_31_24)
+	add	%o2, 31, %o2
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 24, %o0
+ENDPROC(memcpy_retl_o2_plus_31_24)
+ENTRY(memcpy_retl_o2_plus_31_16)
+	add	%o2, 31, %o2
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 16, %o0
+ENDPROC(memcpy_retl_o2_plus_31_16)
+ENTRY(memcpy_retl_o2_plus_31_8)
+	add	%o2, 31, %o2
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 8, %o0
+ENDPROC(memcpy_retl_o2_plus_31_8)
+ENTRY(memcpy_retl_o2_plus_63)
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 63, %o0
+ENDPROC(memcpy_retl_o2_plus_63)
+ENTRY(memcpy_retl_o2_plus_63_64)
+	 add	%o2, 63, %o2
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 64, %o0
+ENDPROC(memcpy_retl_o2_plus_63_64)
+ENTRY(memcpy_retl_o2_plus_63_56)
+	 add	%o2, 63, %o2
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 56, %o0
+ENDPROC(memcpy_retl_o2_plus_63_56)
+ENTRY(memcpy_retl_o2_plus_63_48)
+	 add	%o2, 63, %o2
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 48, %o0
+ENDPROC(memcpy_retl_o2_plus_63_48)
+ENTRY(memcpy_retl_o2_plus_63_40)
+	 add	%o2, 63, %o2
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 40, %o0
+ENDPROC(memcpy_retl_o2_plus_63_40)
+ENTRY(memcpy_retl_o2_plus_63_32)
+	 add	%o2, 63, %o2
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 32, %o0
+ENDPROC(memcpy_retl_o2_plus_63_32)
+ENTRY(memcpy_retl_o2_plus_63_24)
+	 add	%o2, 63, %o2
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 24, %o0
+ENDPROC(memcpy_retl_o2_plus_63_24)
+ENTRY(memcpy_retl_o2_plus_63_16)
+	 add	%o2, 63, %o2
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 16, %o0
+ENDPROC(memcpy_retl_o2_plus_63_16)
+ENTRY(memcpy_retl_o2_plus_63_8)
+	 add	%o2, 63, %o2
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, 8, %o0
+ENDPROC(memcpy_retl_o2_plus_63_8)
 ENTRY(memcpy_retl_o2_plus_o5)
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %o5, %o0
 ENDPROC(memcpy_retl_o2_plus_o5)
+ENTRY(memcpy_retl_o2_plus_o5_plus_1)
+	add	%o5, 1, %o5
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %o5, %o0
+ENDPROC(memcpy_retl_o2_plus_o5_plus_1)
 ENTRY(memcpy_retl_o2_plus_o5_plus_4)
 	add	%o5, 4, %o5
 	ba,pt	%xcc, __restore_asi
@@ -57,6 +171,11 @@ ENTRY(memcpy_retl_o2_plus_o5_plus_32)
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %o5, %o0
 ENDPROC(memcpy_retl_o2_plus_o5_plus_32)
+ENTRY(memcpy_retl_o2_plus_o5_64)
+	add	%o5, 32, %o5
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %o5, %o0
+ENDPROC(memcpy_retl_o2_plus_o5_64)
 ENTRY(memcpy_retl_o2_plus_g1)
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %g1, %o0
@@ -115,6 +234,25 @@ ENTRY(memcpy_retl_o2_plus_o4_plus_64)
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %o4, %o0
 ENDPROC(memcpy_retl_o2_plus_o4_plus_64)
+ENTRY(memcpy_retl_o2_plus_o5_plus_64)
+	add	%o5, 64, %o5
+	ba,pt	%xcc, __restore_asi
+	 add	%o2, %o5, %o0
+ENDPROC(memcpy_retl_o2_plus_o5_plus_64)
+ENTRY(memcpy_retl_o2_plus_o3_fp)
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o3, %o0
+ENDPROC(memcpy_retl_o2_plus_o3_fp)
+ENTRY(memcpy_retl_o2_plus_o3_plus_1_fp)
+	add	%o3, 1, %o3
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o3, %o0
+ENDPROC(memcpy_retl_o2_plus_o3_plus_1_fp)
+ENTRY(memcpy_retl_o2_plus_o3_plus_4_fp)
+	add	%o3, 4, %o3
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o3, %o0
+ENDPROC(memcpy_retl_o2_plus_o3_plus_4_fp)
 ENTRY(memcpy_retl_o2_plus_o4_fp)
 	ba,pt	%xcc, __restore_asi_fp
 	 add	%o2, %o4, %o0
@@ -159,5 +297,49 @@ ENTRY(memcpy_retl_o2_plus_o4_plus_64_fp)
 	ba,pt	%xcc, __restore_asi_fp
 	 add	%o2, %o4, %o0
 ENDPROC(memcpy_retl_o2_plus_o4_plus_64_fp)
+ENTRY(memcpy_retl_o2_plus_o5_fp)
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o5, %o0
+ENDPROC(memcpy_retl_o2_plus_o5_fp)
+ENTRY(memcpy_retl_o2_plus_o5_plus_64_fp)
+	add	%o5, 64, %o5
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o5, %o0
+ENDPROC(memcpy_retl_o2_plus_o5_plus_64_fp)
+ENTRY(memcpy_retl_o2_plus_o5_plus_56_fp)
+	add	%o5, 56, %o5
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o5, %o0
+ENDPROC(memcpy_retl_o2_plus_o5_plus_56_fp)
+ENTRY(memcpy_retl_o2_plus_o5_plus_48_fp)
+	add	%o5, 48, %o5
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o5, %o0
+ENDPROC(memcpy_retl_o2_plus_o5_plus_48_fp)
+ENTRY(memcpy_retl_o2_plus_o5_plus_40_fp)
+	add	%o5, 40, %o5
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o5, %o0
+ENDPROC(memcpy_retl_o2_plus_o5_plus_40_fp)
+ENTRY(memcpy_retl_o2_plus_o5_plus_32_fp)
+	add	%o5, 32, %o5
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o5, %o0
+ENDPROC(memcpy_retl_o2_plus_o5_plus_32_fp)
+ENTRY(memcpy_retl_o2_plus_o5_plus_24_fp)
+	add	%o5, 24, %o5
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o5, %o0
+ENDPROC(memcpy_retl_o2_plus_o5_plus_24_fp)
+ENTRY(memcpy_retl_o2_plus_o5_plus_16_fp)
+	add	%o5, 16, %o5
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o5, %o0
+ENDPROC(memcpy_retl_o2_plus_o5_plus_16_fp)
+ENTRY(memcpy_retl_o2_plus_o5_plus_8_fp)
+	add	%o5, 8, %o5
+	ba,pt	%xcc, __restore_asi_fp
+	 add	%o2, %o5, %o0
+ENDPROC(memcpy_retl_o2_plus_o5_plus_8_fp)
 
 #endif
-- 
1.7.1

[toc] | [prev] | [next] | [standalone]

#1705925 — [PATCH v2 2/4] arch/sparc: Rename exception handlers

FromBabu Moger <babu.moger@oracle.com>
Date2017-08-08 02:00 +0200
Subject[PATCH v2 2/4] arch/sparc: Rename exception handlers
Message-ID<uc06e-7Ai-19@gated-at.bofh.it>
In reply to#1705920
Rename exception handlers to memcpy_xxx as these
are going to be used by new memcpy routines and these
handlers are not exclusive to NG4memcpy anymore.

Signed-off-by: Babu Moger <babu.moger@oracle.com>
---
 arch/sparc/lib/Memcpy_utils.S |  120 +++++++++++++++++++-------------------
 arch/sparc/lib/NG4memcpy.S    |  128 ++++++++++++++++++++--------------------
 2 files changed, 124 insertions(+), 124 deletions(-)

diff --git a/arch/sparc/lib/Memcpy_utils.S b/arch/sparc/lib/Memcpy_utils.S
index f7a26e0..bcc5d77 100644
--- a/arch/sparc/lib/Memcpy_utils.S
+++ b/arch/sparc/lib/Memcpy_utils.S
@@ -16,148 +16,148 @@ ENTRY(__restore_asi)
 	 wr	%g0, ASI_AIUS, %asi
 ENDPROC(__restore_asi)
 
-ENTRY(NG4_retl_o2)
+ENTRY(memcpy_retl_o2)
 	ba,pt	%xcc, __restore_asi
 	 mov	%o2, %o0
-ENDPROC(NG4_retl_o2)
-ENTRY(NG4_retl_o2_plus_1)
+ENDPROC(memcpy_retl_o2)
+ENTRY(memcpy_retl_o2_plus_1)
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, 1, %o0
-ENDPROC(NG4_retl_o2_plus_1)
-ENTRY(NG4_retl_o2_plus_4)
+ENDPROC(memcpy_retl_o2_plus_1)
+ENTRY(memcpy_retl_o2_plus_4)
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, 4, %o0
-ENDPROC(NG4_retl_o2_plus_4)
-ENTRY(NG4_retl_o2_plus_o5)
+ENDPROC(memcpy_retl_o2_plus_4)
+ENTRY(memcpy_retl_o2_plus_o5)
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %o5, %o0
-ENDPROC(NG4_retl_o2_plus_o5)
-ENTRY(NG4_retl_o2_plus_o5_plus_4)
+ENDPROC(memcpy_retl_o2_plus_o5)
+ENTRY(memcpy_retl_o2_plus_o5_plus_4)
 	add	%o5, 4, %o5
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %o5, %o0
-ENDPROC(NG4_retl_o2_plus_o5_plus_4)
-ENTRY(NG4_retl_o2_plus_o5_plus_8)
+ENDPROC(memcpy_retl_o2_plus_o5_plus_4)
+ENTRY(memcpy_retl_o2_plus_o5_plus_8)
 	add	%o5, 8, %o5
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %o5, %o0
-ENDPROC(NG4_retl_o2_plus_o5_plus_8)
-ENTRY(NG4_retl_o2_plus_o5_plus_16)
+ENDPROC(memcpy_retl_o2_plus_o5_plus_8)
+ENTRY(memcpy_retl_o2_plus_o5_plus_16)
 	add	%o5, 16, %o5
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %o5, %o0
-ENDPROC(NG4_retl_o2_plus_o5_plus_16)
-ENTRY(NG4_retl_o2_plus_o5_plus_24)
+ENDPROC(memcpy_retl_o2_plus_o5_plus_16)
+ENTRY(memcpy_retl_o2_plus_o5_plus_24)
 	add	%o5, 24, %o5
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %o5, %o0
-ENDPROC(NG4_retl_o2_plus_o5_plus_24)
-ENTRY(NG4_retl_o2_plus_o5_plus_32)
+ENDPROC(memcpy_retl_o2_plus_o5_plus_24)
+ENTRY(memcpy_retl_o2_plus_o5_plus_32)
 	add	%o5, 32, %o5
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %o5, %o0
-ENDPROC(NG4_retl_o2_plus_o5_plus_32)
-ENTRY(NG4_retl_o2_plus_g1)
+ENDPROC(memcpy_retl_o2_plus_o5_plus_32)
+ENTRY(memcpy_retl_o2_plus_g1)
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %g1, %o0
-ENDPROC(NG4_retl_o2_plus_g1)
-ENTRY(NG4_retl_o2_plus_g1_plus_1)
+ENDPROC(memcpy_retl_o2_plus_g1)
+ENTRY(memcpy_retl_o2_plus_g1_plus_1)
 	add	%g1, 1, %g1
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %g1, %o0
-ENDPROC(NG4_retl_o2_plus_g1_plus_1)
-ENTRY(NG4_retl_o2_plus_g1_plus_8)
+ENDPROC(memcpy_retl_o2_plus_g1_plus_1)
+ENTRY(memcpy_retl_o2_plus_g1_plus_8)
 	add	%g1, 8, %g1
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %g1, %o0
-ENDPROC(NG4_retl_o2_plus_g1_plus_8)
-ENTRY(NG4_retl_o2_plus_o4)
+ENDPROC(memcpy_retl_o2_plus_g1_plus_8)
+ENTRY(memcpy_retl_o2_plus_o4)
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4)
-ENTRY(NG4_retl_o2_plus_o4_plus_8)
+ENDPROC(memcpy_retl_o2_plus_o4)
+ENTRY(memcpy_retl_o2_plus_o4_plus_8)
 	add	%o4, 8, %o4
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_8)
-ENTRY(NG4_retl_o2_plus_o4_plus_16)
+ENDPROC(memcpy_retl_o2_plus_o4_plus_8)
+ENTRY(memcpy_retl_o2_plus_o4_plus_16)
 	add	%o4, 16, %o4
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_16)
-ENTRY(NG4_retl_o2_plus_o4_plus_24)
+ENDPROC(memcpy_retl_o2_plus_o4_plus_16)
+ENTRY(memcpy_retl_o2_plus_o4_plus_24)
 	add	%o4, 24, %o4
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_24)
-ENTRY(NG4_retl_o2_plus_o4_plus_32)
+ENDPROC(memcpy_retl_o2_plus_o4_plus_24)
+ENTRY(memcpy_retl_o2_plus_o4_plus_32)
 	add	%o4, 32, %o4
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_32)
-ENTRY(NG4_retl_o2_plus_o4_plus_40)
+ENDPROC(memcpy_retl_o2_plus_o4_plus_32)
+ENTRY(memcpy_retl_o2_plus_o4_plus_40)
 	add	%o4, 40, %o4
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_40)
-ENTRY(NG4_retl_o2_plus_o4_plus_48)
+ENDPROC(memcpy_retl_o2_plus_o4_plus_40)
+ENTRY(memcpy_retl_o2_plus_o4_plus_48)
 	add	%o4, 48, %o4
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_48)
-ENTRY(NG4_retl_o2_plus_o4_plus_56)
+ENDPROC(memcpy_retl_o2_plus_o4_plus_48)
+ENTRY(memcpy_retl_o2_plus_o4_plus_56)
 	add	%o4, 56, %o4
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_56)
-ENTRY(NG4_retl_o2_plus_o4_plus_64)
+ENDPROC(memcpy_retl_o2_plus_o4_plus_56)
+ENTRY(memcpy_retl_o2_plus_o4_plus_64)
 	add	%o4, 64, %o4
 	ba,pt	%xcc, __restore_asi
 	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_64)
-ENTRY(NG4_retl_o2_plus_o4_fp)
+ENDPROC(memcpy_retl_o2_plus_o4_plus_64)
+ENTRY(memcpy_retl_o2_plus_o4_fp)
 	ba,pt	%xcc, __restore_asi_fp
 	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_fp)
-ENTRY(NG4_retl_o2_plus_o4_plus_8_fp)
+ENDPROC(memcpy_retl_o2_plus_o4_fp)
+ENTRY(memcpy_retl_o2_plus_o4_plus_8_fp)
 	add	%o4, 8, %o4
 	ba,pt	%xcc, __restore_asi_fp
 	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_8_fp)
-ENTRY(NG4_retl_o2_plus_o4_plus_16_fp)
+ENDPROC(memcpy_retl_o2_plus_o4_plus_8_fp)
+ENTRY(memcpy_retl_o2_plus_o4_plus_16_fp)
 	add	%o4, 16, %o4
 	ba,pt	%xcc, __restore_asi_fp
 	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_16_fp)
-ENTRY(NG4_retl_o2_plus_o4_plus_24_fp)
+ENDPROC(memcpy_retl_o2_plus_o4_plus_16_fp)
+ENTRY(memcpy_retl_o2_plus_o4_plus_24_fp)
 	add	%o4, 24, %o4
 	ba,pt	%xcc, __restore_asi_fp
 	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_24_fp)
-ENTRY(NG4_retl_o2_plus_o4_plus_32_fp)
+ENDPROC(memcpy_retl_o2_plus_o4_plus_24_fp)
+ENTRY(memcpy_retl_o2_plus_o4_plus_32_fp)
 	add	%o4, 32, %o4
 	ba,pt	%xcc, __restore_asi_fp
 	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_32_fp)
-ENTRY(NG4_retl_o2_plus_o4_plus_40_fp)
+ENDPROC(memcpy_retl_o2_plus_o4_plus_32_fp)
+ENTRY(memcpy_retl_o2_plus_o4_plus_40_fp)
 	add	%o4, 40, %o4
 	ba,pt	%xcc, __restore_asi_fp
 	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_40_fp)
-ENTRY(NG4_retl_o2_plus_o4_plus_48_fp)
+ENDPROC(memcpy_retl_o2_plus_o4_plus_40_fp)
+ENTRY(memcpy_retl_o2_plus_o4_plus_48_fp)
 	add	%o4, 48, %o4
 	ba,pt	%xcc, __restore_asi_fp
 	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_48_fp)
-ENTRY(NG4_retl_o2_plus_o4_plus_56_fp)
+ENDPROC(memcpy_retl_o2_plus_o4_plus_48_fp)
+ENTRY(memcpy_retl_o2_plus_o4_plus_56_fp)
 	add	%o4, 56, %o4
 	ba,pt	%xcc, __restore_asi_fp
 	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_56_fp)
-ENTRY(NG4_retl_o2_plus_o4_plus_64_fp)
+ENDPROC(memcpy_retl_o2_plus_o4_plus_56_fp)
+ENTRY(memcpy_retl_o2_plus_o4_plus_64_fp)
 	add	%o4, 64, %o4
 	ba,pt	%xcc, __restore_asi_fp
 	 add	%o2, %o4, %o0
-ENDPROC(NG4_retl_o2_plus_o4_plus_64_fp)
+ENDPROC(memcpy_retl_o2_plus_o4_plus_64_fp)
 
 #endif
diff --git a/arch/sparc/lib/NG4memcpy.S b/arch/sparc/lib/NG4memcpy.S
index e20d654..b5dacd1 100644
--- a/arch/sparc/lib/NG4memcpy.S
+++ b/arch/sparc/lib/NG4memcpy.S
@@ -126,12 +126,12 @@ FUNC_NAME:	/* %o0=dst, %o1=src, %o2=len */
 	 sub		%o2, %g1, %o2
 
 
-1:	EX_LD(LOAD(ldub, %o1 + 0x00, %g2), NG4_retl_o2_plus_g1)
+1:	EX_LD(LOAD(ldub, %o1 + 0x00, %g2), memcpy_retl_o2_plus_g1)
 	add		%o1, 1, %o1
 	subcc		%g1, 1, %g1
 	add		%o0, 1, %o0
 	bne,pt		%icc, 1b
-	 EX_ST(STORE(stb, %g2, %o0 - 0x01), NG4_retl_o2_plus_g1_plus_1)
+	 EX_ST(STORE(stb, %g2, %o0 - 0x01), memcpy_retl_o2_plus_g1_plus_1)
 
 51:	LOAD(prefetch, %o1 + 0x040, #n_reads_strong)
 	LOAD(prefetch, %o1 + 0x080, #n_reads_strong)
@@ -156,43 +156,43 @@ FUNC_NAME:	/* %o0=dst, %o1=src, %o2=len */
 	brz,pt		%g1, .Llarge_aligned
 	 sub		%o2, %g1, %o2
 
-1:	EX_LD(LOAD(ldx, %o1 + 0x00, %g2), NG4_retl_o2_plus_g1)
+1:	EX_LD(LOAD(ldx, %o1 + 0x00, %g2), memcpy_retl_o2_plus_g1)
 	add		%o1, 8, %o1
 	subcc		%g1, 8, %g1
 	add		%o0, 8, %o0
 	bne,pt		%icc, 1b
-	 EX_ST(STORE(stx, %g2, %o0 - 0x08), NG4_retl_o2_plus_g1_plus_8)
+	 EX_ST(STORE(stx, %g2, %o0 - 0x08), memcpy_retl_o2_plus_g1_plus_8)
 
 .Llarge_aligned:
 	/* len >= 0x80 && src 8-byte aligned && dest 8-byte aligned */
 	andn		%o2, 0x3f, %o4
 	sub		%o2, %o4, %o2
 
-1:	EX_LD(LOAD(ldx, %o1 + 0x00, %g1), NG4_retl_o2_plus_o4)
+1:	EX_LD(LOAD(ldx, %o1 + 0x00, %g1), memcpy_retl_o2_plus_o4)
 	add		%o1, 0x40, %o1
-	EX_LD(LOAD(ldx, %o1 - 0x38, %g2), NG4_retl_o2_plus_o4)
+	EX_LD(LOAD(ldx, %o1 - 0x38, %g2), memcpy_retl_o2_plus_o4)
 	subcc		%o4, 0x40, %o4
-	EX_LD(LOAD(ldx, %o1 - 0x30, %g3), NG4_retl_o2_plus_o4_plus_64)
-	EX_LD(LOAD(ldx, %o1 - 0x28, GLOBAL_SPARE), NG4_retl_o2_plus_o4_plus_64)
-	EX_LD(LOAD(ldx, %o1 - 0x20, %o5), NG4_retl_o2_plus_o4_plus_64)
-	EX_ST(STORE_INIT(%g1, %o0), NG4_retl_o2_plus_o4_plus_64)
+	EX_LD(LOAD(ldx, %o1 - 0x30, %g3), memcpy_retl_o2_plus_o4_plus_64)
+	EX_LD(LOAD(ldx, %o1 - 0x28, GLOBAL_SPARE), memcpy_retl_o2_plus_o4_plus_64)
+	EX_LD(LOAD(ldx, %o1 - 0x20, %o5), memcpy_retl_o2_plus_o4_plus_64)
+	EX_ST(STORE_INIT(%g1, %o0), memcpy_retl_o2_plus_o4_plus_64)
 	add		%o0, 0x08, %o0
-	EX_ST(STORE_INIT(%g2, %o0), NG4_retl_o2_plus_o4_plus_56)
+	EX_ST(STORE_INIT(%g2, %o0), memcpy_retl_o2_plus_o4_plus_56)
 	add		%o0, 0x08, %o0
-	EX_LD(LOAD(ldx, %o1 - 0x18, %g2), NG4_retl_o2_plus_o4_plus_48)
-	EX_ST(STORE_INIT(%g3, %o0), NG4_retl_o2_plus_o4_plus_48)
+	EX_LD(LOAD(ldx, %o1 - 0x18, %g2), memcpy_retl_o2_plus_o4_plus_48)
+	EX_ST(STORE_INIT(%g3, %o0), memcpy_retl_o2_plus_o4_plus_48)
 	add		%o0, 0x08, %o0
-	EX_LD(LOAD(ldx, %o1 - 0x10, %g3), NG4_retl_o2_plus_o4_plus_40)
-	EX_ST(STORE_INIT(GLOBAL_SPARE, %o0), NG4_retl_o2_plus_o4_plus_40)
+	EX_LD(LOAD(ldx, %o1 - 0x10, %g3), memcpy_retl_o2_plus_o4_plus_40)
+	EX_ST(STORE_INIT(GLOBAL_SPARE, %o0), memcpy_retl_o2_plus_o4_plus_40)
 	add		%o0, 0x08, %o0
-	EX_LD(LOAD(ldx, %o1 - 0x08, GLOBAL_SPARE), NG4_retl_o2_plus_o4_plus_32)
-	EX_ST(STORE_INIT(%o5, %o0), NG4_retl_o2_plus_o4_plus_32)
+	EX_LD(LOAD(ldx, %o1 - 0x08, GLOBAL_SPARE), memcpy_retl_o2_plus_o4_plus_32)
+	EX_ST(STORE_INIT(%o5, %o0), memcpy_retl_o2_plus_o4_plus_32)
 	add		%o0, 0x08, %o0
-	EX_ST(STORE_INIT(%g2, %o0), NG4_retl_o2_plus_o4_plus_24)
+	EX_ST(STORE_INIT(%g2, %o0), memcpy_retl_o2_plus_o4_plus_24)
 	add		%o0, 0x08, %o0
-	EX_ST(STORE_INIT(%g3, %o0), NG4_retl_o2_plus_o4_plus_16)
+	EX_ST(STORE_INIT(%g3, %o0), memcpy_retl_o2_plus_o4_plus_16)
 	add		%o0, 0x08, %o0
-	EX_ST(STORE_INIT(GLOBAL_SPARE, %o0), NG4_retl_o2_plus_o4_plus_8)
+	EX_ST(STORE_INIT(GLOBAL_SPARE, %o0), memcpy_retl_o2_plus_o4_plus_8)
 	add		%o0, 0x08, %o0
 	bne,pt		%icc, 1b
 	 LOAD(prefetch, %o1 + 0x200, #n_reads_strong)
@@ -218,17 +218,17 @@ FUNC_NAME:	/* %o0=dst, %o1=src, %o2=len */
 	sub		%o2, %o4, %o2
 	alignaddr	%o1, %g0, %g1
 	add		%o1, %o4, %o1
-	EX_LD_FP(LOAD(ldd, %g1 + 0x00, %f0), NG4_retl_o2_plus_o4)
-1:	EX_LD_FP(LOAD(ldd, %g1 + 0x08, %f2), NG4_retl_o2_plus_o4)
+	EX_LD_FP(LOAD(ldd, %g1 + 0x00, %f0), memcpy_retl_o2_plus_o4)
+1:	EX_LD_FP(LOAD(ldd, %g1 + 0x08, %f2), memcpy_retl_o2_plus_o4)
 	subcc		%o4, 0x40, %o4
-	EX_LD_FP(LOAD(ldd, %g1 + 0x10, %f4), NG4_retl_o2_plus_o4_plus_64)
-	EX_LD_FP(LOAD(ldd, %g1 + 0x18, %f6), NG4_retl_o2_plus_o4_plus_64)
-	EX_LD_FP(LOAD(ldd, %g1 + 0x20, %f8), NG4_retl_o2_plus_o4_plus_64)
-	EX_LD_FP(LOAD(ldd, %g1 + 0x28, %f10), NG4_retl_o2_plus_o4_plus_64)
-	EX_LD_FP(LOAD(ldd, %g1 + 0x30, %f12), NG4_retl_o2_plus_o4_plus_64)
-	EX_LD_FP(LOAD(ldd, %g1 + 0x38, %f14), NG4_retl_o2_plus_o4_plus_64)
+	EX_LD_FP(LOAD(ldd, %g1 + 0x10, %f4), memcpy_retl_o2_plus_o4_plus_64)
+	EX_LD_FP(LOAD(ldd, %g1 + 0x18, %f6), memcpy_retl_o2_plus_o4_plus_64)
+	EX_LD_FP(LOAD(ldd, %g1 + 0x20, %f8), memcpy_retl_o2_plus_o4_plus_64)
+	EX_LD_FP(LOAD(ldd, %g1 + 0x28, %f10), memcpy_retl_o2_plus_o4_plus_64)
+	EX_LD_FP(LOAD(ldd, %g1 + 0x30, %f12), memcpy_retl_o2_plus_o4_plus_64)
+	EX_LD_FP(LOAD(ldd, %g1 + 0x38, %f14), memcpy_retl_o2_plus_o4_plus_64)
 	faligndata	%f0, %f2, %f16
-	EX_LD_FP(LOAD(ldd, %g1 + 0x40, %f0), NG4_retl_o2_plus_o4_plus_64)
+	EX_LD_FP(LOAD(ldd, %g1 + 0x40, %f0), memcpy_retl_o2_plus_o4_plus_64)
 	faligndata	%f2, %f4, %f18
 	add		%g1, 0x40, %g1
 	faligndata	%f4, %f6, %f20
@@ -237,14 +237,14 @@ FUNC_NAME:	/* %o0=dst, %o1=src, %o2=len */
 	faligndata	%f10, %f12, %f26
 	faligndata	%f12, %f14, %f28
 	faligndata	%f14, %f0, %f30
-	EX_ST_FP(STORE(std, %f16, %o0 + 0x00), NG4_retl_o2_plus_o4_plus_64)
-	EX_ST_FP(STORE(std, %f18, %o0 + 0x08), NG4_retl_o2_plus_o4_plus_56)
-	EX_ST_FP(STORE(std, %f20, %o0 + 0x10), NG4_retl_o2_plus_o4_plus_48)
-	EX_ST_FP(STORE(std, %f22, %o0 + 0x18), NG4_retl_o2_plus_o4_plus_40)
-	EX_ST_FP(STORE(std, %f24, %o0 + 0x20), NG4_retl_o2_plus_o4_plus_32)
-	EX_ST_FP(STORE(std, %f26, %o0 + 0x28), NG4_retl_o2_plus_o4_plus_24)
-	EX_ST_FP(STORE(std, %f28, %o0 + 0x30), NG4_retl_o2_plus_o4_plus_16)
-	EX_ST_FP(STORE(std, %f30, %o0 + 0x38), NG4_retl_o2_plus_o4_plus_8)
+	EX_ST_FP(STORE(std, %f16, %o0 + 0x00), memcpy_retl_o2_plus_o4_plus_64)
+	EX_ST_FP(STORE(std, %f18, %o0 + 0x08), memcpy_retl_o2_plus_o4_plus_56)
+	EX_ST_FP(STORE(std, %f20, %o0 + 0x10), memcpy_retl_o2_plus_o4_plus_48)
+	EX_ST_FP(STORE(std, %f22, %o0 + 0x18), memcpy_retl_o2_plus_o4_plus_40)
+	EX_ST_FP(STORE(std, %f24, %o0 + 0x20), memcpy_retl_o2_plus_o4_plus_32)
+	EX_ST_FP(STORE(std, %f26, %o0 + 0x28), memcpy_retl_o2_plus_o4_plus_24)
+	EX_ST_FP(STORE(std, %f28, %o0 + 0x30), memcpy_retl_o2_plus_o4_plus_16)
+	EX_ST_FP(STORE(std, %f30, %o0 + 0x38), memcpy_retl_o2_plus_o4_plus_8)
 	add		%o0, 0x40, %o0
 	bne,pt		%icc, 1b
 	 LOAD(prefetch, %g1 + 0x200, #n_reads_strong)
@@ -272,38 +272,38 @@ FUNC_NAME:	/* %o0=dst, %o1=src, %o2=len */
 	andncc		%o2, 0x20 - 1, %o5
 	be,pn		%icc, 2f
 	 sub		%o2, %o5, %o2
-1:	EX_LD(LOAD(ldx, %o1 + 0x00, %g1), NG4_retl_o2_plus_o5)
-	EX_LD(LOAD(ldx, %o1 + 0x08, %g2), NG4_retl_o2_plus_o5)
-	EX_LD(LOAD(ldx, %o1 + 0x10, GLOBAL_SPARE), NG4_retl_o2_plus_o5)
-	EX_LD(LOAD(ldx, %o1 + 0x18, %o4), NG4_retl_o2_plus_o5)
+1:	EX_LD(LOAD(ldx, %o1 + 0x00, %g1), memcpy_retl_o2_plus_o5)
+	EX_LD(LOAD(ldx, %o1 + 0x08, %g2), memcpy_retl_o2_plus_o5)
+	EX_LD(LOAD(ldx, %o1 + 0x10, GLOBAL_SPARE), memcpy_retl_o2_plus_o5)
+	EX_LD(LOAD(ldx, %o1 + 0x18, %o4), memcpy_retl_o2_plus_o5)
 	add		%o1, 0x20, %o1
 	subcc		%o5, 0x20, %o5
-	EX_ST(STORE(stx, %g1, %o0 + 0x00), NG4_retl_o2_plus_o5_plus_32)
-	EX_ST(STORE(stx, %g2, %o0 + 0x08), NG4_retl_o2_plus_o5_plus_24)
-	EX_ST(STORE(stx, GLOBAL_SPARE, %o0 + 0x10), NG4_retl_o2_plus_o5_plus_24)
-	EX_ST(STORE(stx, %o4, %o0 + 0x18), NG4_retl_o2_plus_o5_plus_8)
+	EX_ST(STORE(stx, %g1, %o0 + 0x00), memcpy_retl_o2_plus_o5_plus_32)
+	EX_ST(STORE(stx, %g2, %o0 + 0x08), memcpy_retl_o2_plus_o5_plus_24)
+	EX_ST(STORE(stx, GLOBAL_SPARE, %o0 + 0x10), memcpy_retl_o2_plus_o5_plus_24)
+	EX_ST(STORE(stx, %o4, %o0 + 0x18), memcpy_retl_o2_plus_o5_plus_8)
 	bne,pt		%icc, 1b
 	 add		%o0, 0x20, %o0
 2:	andcc		%o2, 0x18, %o5
 	be,pt		%icc, 3f
 	 sub		%o2, %o5, %o2
 
-1:	EX_LD(LOAD(ldx, %o1 + 0x00, %g1), NG4_retl_o2_plus_o5)
+1:	EX_LD(LOAD(ldx, %o1 + 0x00, %g1), memcpy_retl_o2_plus_o5)
 	add		%o1, 0x08, %o1
 	add		%o0, 0x08, %o0
 	subcc		%o5, 0x08, %o5
 	bne,pt		%icc, 1b
-	 EX_ST(STORE(stx, %g1, %o0 - 0x08), NG4_retl_o2_plus_o5_plus_8)
+	 EX_ST(STORE(stx, %g1, %o0 - 0x08), memcpy_retl_o2_plus_o5_plus_8)
 3:	brz,pt		%o2, .Lexit
 	 cmp		%o2, 0x04
 	bl,pn		%icc, .Ltiny
 	 nop
-	EX_LD(LOAD(lduw, %o1 + 0x00, %g1), NG4_retl_o2)
+	EX_LD(LOAD(lduw, %o1 + 0x00, %g1), memcpy_retl_o2)
 	add		%o1, 0x04, %o1
 	add		%o0, 0x04, %o0
 	subcc		%o2, 0x04, %o2
 	bne,pn		%icc, .Ltiny
-	 EX_ST(STORE(stw, %g1, %o0 - 0x04), NG4_retl_o2_plus_4)
+	 EX_ST(STORE(stw, %g1, %o0 - 0x04), memcpy_retl_o2_plus_4)
 	ba,a,pt		%icc, .Lexit
 .Lmedium_unaligned:
 	/* First get dest 8 byte aligned.  */
@@ -312,12 +312,12 @@ FUNC_NAME:	/* %o0=dst, %o1=src, %o2=len */
 	brz,pt		%g1, 2f
 	 sub		%o2, %g1, %o2
 
-1:	EX_LD(LOAD(ldub, %o1 + 0x00, %g2), NG4_retl_o2_plus_g1)
+1:	EX_LD(LOAD(ldub, %o1 + 0x00, %g2), memcpy_retl_o2_plus_g1)
 	add		%o1, 1, %o1
 	subcc		%g1, 1, %g1
 	add		%o0, 1, %o0
 	bne,pt		%icc, 1b
-	 EX_ST(STORE(stb, %g2, %o0 - 0x01), NG4_retl_o2_plus_g1_plus_1)
+	 EX_ST(STORE(stb, %g2, %o0 - 0x01), memcpy_retl_o2_plus_g1_plus_1)
 2:
 	and		%o1, 0x7, %g1
 	brz,pn		%g1, .Lmedium_noprefetch
@@ -325,16 +325,16 @@ FUNC_NAME:	/* %o0=dst, %o1=src, %o2=len */
 	mov		64, %g2
 	sub		%g2, %g1, %g2
 	andn		%o1, 0x7, %o1
-	EX_LD(LOAD(ldx, %o1 + 0x00, %o4), NG4_retl_o2)
+	EX_LD(LOAD(ldx, %o1 + 0x00, %o4), memcpy_retl_o2)
 	sllx		%o4, %g1, %o4
 	andn		%o2, 0x08 - 1, %o5
 	sub		%o2, %o5, %o2
-1:	EX_LD(LOAD(ldx, %o1 + 0x08, %g3), NG4_retl_o2_plus_o5)
+1:	EX_LD(LOAD(ldx, %o1 + 0x08, %g3), memcpy_retl_o2_plus_o5)
 	add		%o1, 0x08, %o1
 	subcc		%o5, 0x08, %o5
 	srlx		%g3, %g2, GLOBAL_SPARE
 	or		GLOBAL_SPARE, %o4, GLOBAL_SPARE
-	EX_ST(STORE(stx, GLOBAL_SPARE, %o0 + 0x00), NG4_retl_o2_plus_o5_plus_8)
+	EX_ST(STORE(stx, GLOBAL_SPARE, %o0 + 0x00), memcpy_retl_o2_plus_o5_plus_8)
 	add		%o0, 0x08, %o0
 	bne,pt		%icc, 1b
 	 sllx		%g3, %g1, %o4
@@ -345,17 +345,17 @@ FUNC_NAME:	/* %o0=dst, %o1=src, %o2=len */
 	ba,pt		%icc, .Lsmall_unaligned
 
 .Ltiny:
-	EX_LD(LOAD(ldub, %o1 + 0x00, %g1), NG4_retl_o2)
+	EX_LD(LOAD(ldub, %o1 + 0x00, %g1), memcpy_retl_o2)
 	subcc		%o2, 1, %o2
 	be,pn		%icc, .Lexit
-	 EX_ST(STORE(stb, %g1, %o0 + 0x00), NG4_retl_o2_plus_1)
-	EX_LD(LOAD(ldub, %o1 + 0x01, %g1), NG4_retl_o2)
+	 EX_ST(STORE(stb, %g1, %o0 + 0x00), memcpy_retl_o2_plus_1)
+	EX_LD(LOAD(ldub, %o1 + 0x01, %g1), memcpy_retl_o2)
 	subcc		%o2, 1, %o2
 	be,pn		%icc, .Lexit
-	 EX_ST(STORE(stb, %g1, %o0 + 0x01), NG4_retl_o2_plus_1)
-	EX_LD(LOAD(ldub, %o1 + 0x02, %g1), NG4_retl_o2)
+	 EX_ST(STORE(stb, %g1, %o0 + 0x01), memcpy_retl_o2_plus_1)
+	EX_LD(LOAD(ldub, %o1 + 0x02, %g1), memcpy_retl_o2)
 	ba,pt		%icc, .Lexit
-	 EX_ST(STORE(stb, %g1, %o0 + 0x02), NG4_retl_o2)
+	 EX_ST(STORE(stb, %g1, %o0 + 0x02), memcpy_retl_o2)
 
 .Lsmall:
 	andcc		%g2, 0x3, %g0
@@ -363,23 +363,23 @@ FUNC_NAME:	/* %o0=dst, %o1=src, %o2=len */
 	 andn		%o2, 0x4 - 1, %o5
 	sub		%o2, %o5, %o2
 1:
-	EX_LD(LOAD(lduw, %o1 + 0x00, %g1), NG4_retl_o2_plus_o5)
+	EX_LD(LOAD(lduw, %o1 + 0x00, %g1), memcpy_retl_o2_plus_o5)
 	add		%o1, 0x04, %o1
 	subcc		%o5, 0x04, %o5
 	add		%o0, 0x04, %o0
 	bne,pt		%icc, 1b
-	 EX_ST(STORE(stw, %g1, %o0 - 0x04), NG4_retl_o2_plus_o5_plus_4)
+	 EX_ST(STORE(stw, %g1, %o0 - 0x04), memcpy_retl_o2_plus_o5_plus_4)
 	brz,pt		%o2, .Lexit
 	 nop
 	ba,a,pt		%icc, .Ltiny
 
 .Lsmall_unaligned:
-1:	EX_LD(LOAD(ldub, %o1 + 0x00, %g1), NG4_retl_o2)
+1:	EX_LD(LOAD(ldub, %o1 + 0x00, %g1), memcpy_retl_o2)
 	add		%o1, 1, %o1
 	add		%o0, 1, %o0
 	subcc		%o2, 1, %o2
 	bne,pt		%icc, 1b
-	 EX_ST(STORE(stb, %g1, %o0 - 0x01), NG4_retl_o2_plus_1)
+	 EX_ST(STORE(stb, %g1, %o0 - 0x01), memcpy_retl_o2_plus_1)
 	ba,a,pt		%icc, .Lexit
 	 nop
 	.size		FUNC_NAME, .-FUNC_NAME
-- 
1.7.1

[toc] | [prev] | [next] | [standalone]

#1709035 — Re: [PATCH v2 0/4] Update memcpy, memset etc. for M7/M8 architectures

FromDavid Miller <davem@davemloft.net>
Date2017-08-10 23:40 +0200
SubjectRe: [PATCH v2 0/4] Update memcpy, memset etc. for M7/M8 architectures
Message-ID<ud3ln-31s-13@gated-at.bofh.it>
In reply to#1705920
From: Babu Moger <babu.moger@oracle.com>
Date: Mon,  7 Aug 2017 17:52:48 -0600

> This series of patches updates the memcpy, memset, copy_to_user,
> copy_from_user etc for SPARC M7/M8 architecture.

This doesn't build, you cannot assume the existence of "%ncc", it is a
recent addition.

Furthermore there is no need to ever use %ncc in v9 targetted code
anyways.

I'll fix that up, but this was a really disappointing build failure
to hit.

Meanwhile, two questions:

1) Is this also faster on T4 as well?  If it is, we can just get rid
   of the T4 routines and use this on those chips as well.

2) There has been a lot of discussion and consideration put into how
   a memcpy/memset routine might be really great for the local cpu
   but overall pessimize performance for other cpus either locally
   on the same core (contention for physical resources such as
   ports to the store buffer and/or L3 cache) or on other cores.

   Has any such study been done into these issues wrt. this new code?

[toc] | [prev] | [standalone]

Back to top | Article view | linux.kernel

csiph-web