This is the mail archive of the libc-alpha@sourceware.org mailing list for the glibc project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

PATCH: Optimized memset for x86-64


This is a rewrite of x86-64 memset driven by jump tables. It uses SSE
register move for Intel64 and 8byte register move for AMD64.


H.J.
-----
2007-10-15  H.J. Lu  <hongjiu.lu@intel.com>

	* sysdeps/x86_64/cacheinfo.c
	(__x86_64_preferred_memory_instruction): New.
	(init_cacheinfo): Initialize __x86_64_preferred_memory_instruction.

	* sysdeps/x86_64/memset.S: Rewrite.

--- sysdeps/x86_64/cacheinfo.c.memset	2007-10-15 09:13:52.000000000 -0700
+++ sysdeps/x86_64/cacheinfo.c	2007-10-15 09:17:07.000000000 -0700
@@ -407,6 +407,16 @@ long int __x86_64_shared_cache_size_half
 /* PREFETCHW support flag for use in memory and string routines.  */
 int __x86_64_prefetchw attribute_hidden;
 
+/* Instructions preferred for memory and string routines.
+
+  0: Regular instructions 
+  1: MMX instructions
+  2: SSE2 instructions
+  3: SSSE3 instructions
+
+  */
+int __x86_64_preferred_memory_instruction attribute_hidden;
+
 
 static void
 __attribute__((constructor))
@@ -444,6 +454,17 @@ init_cacheinfo (void)
           shared = handle_intel (_SC_LEVEL2_CACHE_SIZE, max_cpuid);
 	}
 
+      asm volatile ("cpuid"
+		    : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx)
+		    : "0" (1));
+
+      /* Intel prefers SSSE3 instructions for memory/string rountines
+	 if they are avaiable.  */
+      if ((ecx & 0x200))
+	__x86_64_preferred_memory_instruction = 3;
+      else
+	__x86_64_preferred_memory_instruction = 2;
+ 
       /* Figure out the number of logical threads that share the
 	 highest cache level.  */
       if (max_cpuid >= 4)
@@ -472,9 +493,6 @@ init_cacheinfo (void)
         {
 	intel_bug_no_cache_info:
 	  /* Assume that all logical threads share the highest cache level.  */
-          asm volatile ("cpuid"
-		        : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx)
-		        : "0" (1));
 
 	  threads = (ebx >> 16) & 0xff;
 	}
--- sysdeps/x86_64/memset.S.memset	2005-03-31 02:00:13.000000000 -0800
+++ sysdeps/x86_64/memset.S	2007-10-15 09:45:08.000000000 -0700
@@ -1,8 +1,7 @@
 /* memset/bzero -- set memory area to CH/0
    Optimized version for x86-64.
-   Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+   Copyright (C) 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
-   Contributed by Andreas Jaeger <aj@suse.de>.
 
    The GNU C Library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
@@ -19,6 +18,29 @@
    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307 USA.  */
 
+#if defined(NOT_IN_GLIBC)
+#if !defined(_RTN_NM_)
+#define _RTN_NM_ _memset
+#endif
+
+#if !defined(_EXT_NM_)
+#define _EXT_NM_ __intel_memcpy_mem_ops_method
+#endif
+
+#if !defined(PUSH_RODATA_SECTION)
+#define PUSH_RODATA_SECTION
+#endif
+
+#if !defined(POP_SECTION)
+#define POP_SECTION
+#endif
+
+#define L(lbl)  .L##lbl
+         .balign     16
+         .global    _RTN_NM_
+_RTN_NM_:
+
+#else
 #include <sysdep.h>
 #include "asm-syntax.h"
 #include "bp-sym.h"
@@ -27,113 +49,1229 @@
 /* BEWARE: `#ifdef memset' means that memset is redefined as `bzero' */
 #define BZERO_P (defined memset)
 
-/* This is somehow experimental and could made dependend on the cache
-   size.  */
-#define LARGE $120000
+#define PUSH_RODATA_SECTION	.pushsection .rodata
+#define POP_SECTION		.popsection
+
+/* It should be the largest cache size.  Since glibc reports half
+   of it, we need to left it shift by 1 before checking it.  */
+#define _EXT_SZ_ __x86_64_shared_cache_size_half
+
+/* Instructions preferred for memory and string routines.  */
+#define _EXT_NM_ __x86_64_preferred_memory_instruction
+
+	.text
 
-        .text
 #if !BZERO_P && defined PIC && !defined NOT_IN_libc
 ENTRY (__memset_chk)
 	cmpq	%rdx, %rcx
 	jb	HIDDEN_JUMPTARGET (__chk_fail)
 END (__memset_chk)
 #endif
+
 ENTRY (memset)
+#endif
+
 #if BZERO_P
 	mov	%rsi,%rdx	/* Adjust parameter.  */
 	xorl	%esi,%esi	/* Fill with 0s.  */
 #endif
-	cmp	$0x7,%rdx	/* Check for small length.  */
-	mov	%rdi,%rcx	/* Save ptr as return value.  */
-	jbe	7f
+	cmp    $0x1,%rdx
+	mov    %rdi,%rax # memset returns the dest address
+	jne    L(ck2)        
+	mov    %sil,(%rdi)
+	retq   $0x0
+L(ck2):                                    
+	mov    $0x101010101010101,%r9
+	mov    %rdx,%r8
+	movzbq %sil,%rdx
+	imul   %r9,%rdx
+L(now_dw_aligned):                         
+	cmp    $0x90,%r8
+	jg     L(ck_mem_ops_method) 
+L(now_dw_aligned_small):
+	lea    L(setPxQx)(%rip),%r11
+	add    %r8,%rdi
+#if !defined(PIC)
+	jmpq   *(%r11,%r8,8) # old scheme remained for nonPIC
+#else
+	movslq (%r11,%r8,4),%rcx
+	lea    (%rcx,%r11,1),%r11
+	jmpq   *%r11
+#endif
 
-#if BZERO_P
-	mov	%rsi,%r8	/* Just copy 0.  */
+L(Got0):                                   
+	retq   $0x0
+
+	PUSH_RODATA_SECTION
+	.balign     16
+#if !defined(PIC)
+L(setPxQx):
+	.quad       L(Got0),L(P1Q0),L(P2Q0),L(P3Q0),L(P4Q0),L(P5Q0),L(P6Q0),L(P7Q0) 
+	.quad       L(P0Q1),L(P1Q1),L(P2Q1),L(P3Q1),L(P4Q1),L(P5Q1),L(P6Q1),L(P7Q1) 
+	.quad       L(P0Q2),L(P1Q2),L(P2Q2),L(P3Q2),L(P4Q2),L(P5Q2),L(P6Q2),L(P7Q2) 
+	.quad       L(P0Q3),L(P1Q3),L(P2Q3),L(P3Q3),L(P4Q3),L(P5Q3),L(P6Q3),L(P7Q3) 
+	.quad       L(P0Q4),L(P1Q4),L(P2Q4),L(P3Q4),L(P4Q4),L(P5Q4),L(P6Q4),L(P7Q4) 
+	.quad       L(P0Q5),L(P1Q5),L(P2Q5),L(P3Q5),L(P4Q5),L(P5Q5),L(P6Q5),L(P7Q5) 
+	.quad       L(P0Q6),L(P1Q6),L(P2Q6),L(P3Q6),L(P4Q6),L(P5Q6),L(P6Q6),L(P7Q6) 
+	.quad       L(P0Q7),L(P1Q7),L(P2Q7),L(P3Q7),L(P4Q7),L(P5Q7),L(P6Q7),L(P7Q7) 
+	.quad       L(P0Q8),L(P1Q8),L(P2Q8),L(P3Q8),L(P4Q8),L(P5Q8),L(P6Q8),L(P7Q8) 
+	.quad       L(P0Q9),L(P1Q9),L(P2Q9),L(P3Q9),L(P4Q9),L(P5Q9),L(P6Q9),L(P7Q9) 
+	.quad       L(P0QA),L(P1QA),L(P2QA),L(P3QA),L(P4QA),L(P5QA),L(P6QA),L(P7QA) 
+	.quad       L(P0QB),L(P1QB),L(P2QB),L(P3QB),L(P4QB),L(P5QB),L(P6QB),L(P7QB) 
+	.quad       L(P0QC),L(P1QC),L(P2QC),L(P3QC),L(P4QC),L(P5QC),L(P6QC),L(P7QC) 
+	.quad       L(P0QD),L(P1QD),L(P2QD),L(P3QD),L(P4QD),L(P5QD),L(P6QD),L(P7QD) 
+	.quad       L(P0QE),L(P1QE),L(P2QE),L(P3QE),L(P4QE),L(P5QE),L(P6QE),L(P7QE) 
+	.quad       L(P0QF),L(P1QF),L(P2QF),L(P3QF),L(P4QF),L(P5QF),L(P6QF),L(P7QF) 
+	.quad       L(P0QG),L(P1QG),L(P2QG),L(P3QG),L(P4QG),L(P5QG),L(P6QG),L(P7QG) 
+	.quad       L(P0QH),L(P1QH),L(P2QH),L(P3QH),L(P4QH),L(P5QH),L(P6QH),L(P7QH) 
+	.quad       L(P0QI)
+#if defined(USE_EXTRA_TABLE)
+	.quad       L(P1QI),L(P2QI),L(P3QI),L(P4QI),L(P5QI),L(P6QI),L(P7QI) 
+#endif
 #else
-	/* Populate 8 bit data to full 64-bit.  */
-	movabs	$0x0101010101010101,%r8
-	movzbl	%sil,%eax
-	imul	%rax,%r8
-#endif
-	test	$0x7,%edi	/* Check for alignment.  */
-	je	2f
-
-	.p2align 4
-1:	/* Align ptr to 8 byte.  */
-	mov	%sil,(%rcx)
-	dec	%rdx
-	inc	%rcx
-	test	$0x7,%ecx
-	jne	1b
-
-2:	/* Check for really large regions.  */
-	mov	%rdx,%rax
-	shr	$0x6,%rax
-	je	4f
-	cmp	LARGE, %rdx
-	jae	11f
-
-	.p2align 4
-3:	/* Copy 64 bytes.  */
-	mov	%r8,(%rcx)
-	mov	%r8,0x8(%rcx)
-	mov	%r8,0x10(%rcx)
-	mov	%r8,0x18(%rcx)
-	mov	%r8,0x20(%rcx)
-	mov	%r8,0x28(%rcx)
-	mov	%r8,0x30(%rcx)
-	mov	%r8,0x38(%rcx)
-	add	$0x40,%rcx
-	dec	%rax
-	jne	3b
-
-4:	/* Copy final bytes.  */
-	and	$0x3f,%edx
-	mov	%rdx,%rax
-	shr	$0x3,%rax
-	je	6f
-
-5:	/* First in chunks of 8 bytes.  */
-	mov	%r8,(%rcx)
-	add	$0x8,%rcx
-	dec	%rax
-	jne	5b
-6:
-	and	$0x7,%edx
-7:
-	test	%rdx,%rdx
-	je	9f
-8:	/* And finally as bytes (up to 7).  */
-	mov	%sil,(%rcx)
-	inc	%rcx
-	dec	%rdx
-	jne	8b
-9:
-#if BZERO_P
-	nop
+L(setPxQx):
+	.int       L(Got0)-L(setPxQx)
+	.int       L(P1Q0)-L(setPxQx)
+	.int       L(P2Q0)-L(setPxQx)
+	.int       L(P3Q0)-L(setPxQx)
+	.int       L(P4Q0)-L(setPxQx)
+	.int       L(P5Q0)-L(setPxQx)
+	.int       L(P6Q0)-L(setPxQx)
+	.int       L(P7Q0)-L(setPxQx) 
+
+	.int       L(P0Q1)-L(setPxQx)
+	.int       L(P1Q1)-L(setPxQx)
+	.int       L(P2Q1)-L(setPxQx)
+	.int       L(P3Q1)-L(setPxQx)
+	.int       L(P4Q1)-L(setPxQx)
+	.int       L(P5Q1)-L(setPxQx)
+	.int       L(P6Q1)-L(setPxQx)
+	.int       L(P7Q1)-L(setPxQx) 
+
+	.int       L(P0Q2)-L(setPxQx)
+	.int       L(P1Q2)-L(setPxQx)
+	.int       L(P2Q2)-L(setPxQx)
+	.int       L(P3Q2)-L(setPxQx)
+	.int       L(P4Q2)-L(setPxQx)
+	.int       L(P5Q2)-L(setPxQx)
+	.int       L(P6Q2)-L(setPxQx)
+	.int       L(P7Q2)-L(setPxQx) 
+
+	.int       L(P0Q3)-L(setPxQx)
+	.int       L(P1Q3)-L(setPxQx)
+	.int       L(P2Q3)-L(setPxQx)
+	.int       L(P3Q3)-L(setPxQx)
+	.int       L(P4Q3)-L(setPxQx)
+	.int       L(P5Q3)-L(setPxQx)
+	.int       L(P6Q3)-L(setPxQx)
+	.int       L(P7Q3)-L(setPxQx) 
+
+	.int       L(P0Q4)-L(setPxQx)
+	.int       L(P1Q4)-L(setPxQx)
+	.int       L(P2Q4)-L(setPxQx)
+	.int       L(P3Q4)-L(setPxQx)
+	.int       L(P4Q4)-L(setPxQx)
+	.int       L(P5Q4)-L(setPxQx)
+	.int       L(P6Q4)-L(setPxQx)
+	.int       L(P7Q4)-L(setPxQx) 
+
+	.int       L(P0Q5)-L(setPxQx)
+	.int       L(P1Q5)-L(setPxQx)
+	.int       L(P2Q5)-L(setPxQx)
+	.int       L(P3Q5)-L(setPxQx)
+	.int       L(P4Q5)-L(setPxQx)
+	.int       L(P5Q5)-L(setPxQx)
+	.int       L(P6Q5)-L(setPxQx)
+	.int       L(P7Q5)-L(setPxQx) 
+
+	.int       L(P0Q6)-L(setPxQx)
+	.int       L(P1Q6)-L(setPxQx)
+	.int       L(P2Q6)-L(setPxQx)
+	.int       L(P3Q6)-L(setPxQx)
+	.int       L(P4Q6)-L(setPxQx)
+	.int       L(P5Q6)-L(setPxQx)
+	.int       L(P6Q6)-L(setPxQx)
+	.int       L(P7Q6)-L(setPxQx) 
+
+	.int       L(P0Q7)-L(setPxQx)
+	.int       L(P1Q7)-L(setPxQx)
+	.int       L(P2Q7)-L(setPxQx)
+	.int       L(P3Q7)-L(setPxQx)
+	.int       L(P4Q7)-L(setPxQx)
+	.int       L(P5Q7)-L(setPxQx)
+	.int       L(P6Q7)-L(setPxQx)
+	.int       L(P7Q7)-L(setPxQx) 
+
+	.int       L(P0Q8)-L(setPxQx)
+	.int       L(P1Q8)-L(setPxQx)
+	.int       L(P2Q8)-L(setPxQx)
+	.int       L(P3Q8)-L(setPxQx)
+	.int       L(P4Q8)-L(setPxQx)
+	.int       L(P5Q8)-L(setPxQx)
+	.int       L(P6Q8)-L(setPxQx)
+	.int       L(P7Q8)-L(setPxQx) 
+
+	.int       L(P0Q9)-L(setPxQx)
+	.int       L(P1Q9)-L(setPxQx)
+	.int       L(P2Q9)-L(setPxQx)
+	.int       L(P3Q9)-L(setPxQx)
+	.int       L(P4Q9)-L(setPxQx)
+	.int       L(P5Q9)-L(setPxQx)
+	.int       L(P6Q9)-L(setPxQx)
+	.int       L(P7Q9)-L(setPxQx) 
+
+	.int       L(P0QA)-L(setPxQx)
+	.int       L(P1QA)-L(setPxQx)
+	.int       L(P2QA)-L(setPxQx)
+	.int       L(P3QA)-L(setPxQx)
+	.int       L(P4QA)-L(setPxQx)
+	.int       L(P5QA)-L(setPxQx)
+	.int       L(P6QA)-L(setPxQx)
+	.int       L(P7QA)-L(setPxQx) 
+
+	.int       L(P0QB)-L(setPxQx)
+	.int       L(P1QB)-L(setPxQx)
+	.int       L(P2QB)-L(setPxQx)
+	.int       L(P3QB)-L(setPxQx)
+	.int       L(P4QB)-L(setPxQx)
+	.int       L(P5QB)-L(setPxQx)
+	.int       L(P6QB)-L(setPxQx)
+	.int       L(P7QB)-L(setPxQx) 
+
+	.int       L(P0QC)-L(setPxQx)
+	.int       L(P1QC)-L(setPxQx)
+	.int       L(P2QC)-L(setPxQx)
+	.int       L(P3QC)-L(setPxQx)
+	.int       L(P4QC)-L(setPxQx)
+	.int       L(P5QC)-L(setPxQx)
+	.int       L(P6QC)-L(setPxQx)
+	.int       L(P7QC)-L(setPxQx) 
+
+	.int       L(P0QD)-L(setPxQx)
+	.int       L(P1QD)-L(setPxQx)
+	.int       L(P2QD)-L(setPxQx)
+	.int       L(P3QD)-L(setPxQx)
+	.int       L(P4QD)-L(setPxQx)
+	.int       L(P5QD)-L(setPxQx)
+	.int       L(P6QD)-L(setPxQx)
+	.int       L(P7QD)-L(setPxQx) 
+
+	.int       L(P0QE)-L(setPxQx)
+	.int       L(P1QE)-L(setPxQx)
+	.int       L(P2QE)-L(setPxQx)
+	.int       L(P3QE)-L(setPxQx)
+	.int       L(P4QE)-L(setPxQx)
+	.int       L(P5QE)-L(setPxQx)
+	.int       L(P6QE)-L(setPxQx)
+	.int       L(P7QE)-L(setPxQx) 
+
+	.int       L(P0QF)-L(setPxQx)
+	.int       L(P1QF)-L(setPxQx)
+	.int       L(P2QF)-L(setPxQx)
+	.int       L(P3QF)-L(setPxQx)
+	.int       L(P4QF)-L(setPxQx)
+	.int       L(P5QF)-L(setPxQx)
+	.int       L(P6QF)-L(setPxQx)
+	.int       L(P7QF)-L(setPxQx) 
+
+	.int       L(P0QG)-L(setPxQx)
+	.int       L(P1QG)-L(setPxQx)
+	.int       L(P2QG)-L(setPxQx)
+	.int       L(P3QG)-L(setPxQx)
+	.int       L(P4QG)-L(setPxQx)
+	.int       L(P5QG)-L(setPxQx)
+	.int       L(P6QG)-L(setPxQx)
+	.int       L(P7QG)-L(setPxQx) 
+
+	.int       L(P0QH)-L(setPxQx)
+	.int       L(P1QH)-L(setPxQx)
+	.int       L(P2QH)-L(setPxQx)
+	.int       L(P3QH)-L(setPxQx)
+	.int       L(P4QH)-L(setPxQx)
+	.int       L(P5QH)-L(setPxQx)
+	.int       L(P6QH)-L(setPxQx)
+	.int       L(P7QH)-L(setPxQx) 
+
+	.int       L(P0QI)-L(setPxQx)
+#if defined(USE_EXTRA_TABLE)
+	.int       L(P1QI)-L(setPxQx)
+	.int       L(P2QI)-L(setPxQx)
+	.int       L(P3QI)-L(setPxQx)
+	.int       L(P4QI)-L(setPxQx)
+	.int       L(P5QI)-L(setPxQx)
+	.int       L(P6QI)-L(setPxQx)
+	.int       L(P7QI)-L(setPxQx) 
+#endif
+#endif
+	POP_SECTION
+
+	.balign     16
+#if defined(USE_EXTRA_TABLE)
+L(P1QI): mov    %rdx,-0x91(%rdi)
+#endif
+L(P1QH): mov    %rdx,-0x89(%rdi)
+L(P1QG): mov    %rdx,-0x81(%rdi)
+#		   .balign     16
+L(P1QF): mov    %rdx,-0x79(%rdi)
+L(P1QE): mov    %rdx,-0x71(%rdi)
+L(P1QD): mov    %rdx,-0x69(%rdi)
+L(P1QC): mov    %rdx,-0x61(%rdi)
+L(P1QB): mov    %rdx,-0x59(%rdi)
+L(P1QA): mov    %rdx,-0x51(%rdi)
+L(P1Q9): mov    %rdx,-0x49(%rdi)
+L(P1Q8): mov    %rdx,-0x41(%rdi)
+L(P1Q7): mov    %rdx,-0x39(%rdi)
+L(P1Q6): mov    %rdx,-0x31(%rdi)
+L(P1Q5): mov    %rdx,-0x29(%rdi)
+L(P1Q4): mov    %rdx,-0x21(%rdi)
+L(P1Q3): mov    %rdx,-0x19(%rdi)
+L(P1Q2): mov    %rdx,-0x11(%rdi)
+L(P1Q1): mov    %rdx,-0x9(%rdi)
+L(P1Q0): mov    %dl,-0x1(%rdi)
+		retq   $0x0
+
+	.balign     16
+L(P0QI): mov    %rdx,-0x90(%rdi)
+L(P0QH): mov    %rdx,-0x88(%rdi)
+#		   .balign     16
+L(P0QG): mov    %rdx,-0x80(%rdi)
+L(P0QF): mov    %rdx,-0x78(%rdi)
+L(P0QE): mov    %rdx,-0x70(%rdi)
+L(P0QD): mov    %rdx,-0x68(%rdi)
+L(P0QC): mov    %rdx,-0x60(%rdi)
+L(P0QB): mov    %rdx,-0x58(%rdi)
+L(P0QA): mov    %rdx,-0x50(%rdi)
+L(P0Q9): mov    %rdx,-0x48(%rdi)
+L(P0Q8): mov    %rdx,-0x40(%rdi)
+L(P0Q7): mov    %rdx,-0x38(%rdi)
+L(P0Q6): mov    %rdx,-0x30(%rdi)
+L(P0Q5): mov    %rdx,-0x28(%rdi)
+L(P0Q4): mov    %rdx,-0x20(%rdi)
+L(P0Q3): mov    %rdx,-0x18(%rdi)
+L(P0Q2): mov    %rdx,-0x10(%rdi)
+L(P0Q1): mov    %rdx,-0x8(%rdi)
+L(P0Q0): retq   $0x0
+
+
+	.balign     16
+#if defined(USE_EXTRA_TABLE)
+L(P2QI): mov    %rdx,-0x92(%rdi)
+#endif
+L(P2QH): mov    %rdx,-0x8a(%rdi)
+L(P2QG): mov    %rdx,-0x82(%rdi)
+#		   .balign     16
+L(P2QF): mov    %rdx,-0x7a(%rdi)
+L(P2QE): mov    %rdx,-0x72(%rdi)
+L(P2QD): mov    %rdx,-0x6a(%rdi)
+L(P2QC): mov    %rdx,-0x62(%rdi)
+L(P2QB): mov    %rdx,-0x5a(%rdi)
+L(P2QA): mov    %rdx,-0x52(%rdi)
+L(P2Q9): mov    %rdx,-0x4a(%rdi)
+L(P2Q8): mov    %rdx,-0x42(%rdi)
+L(P2Q7): mov    %rdx,-0x3a(%rdi)
+L(P2Q6): mov    %rdx,-0x32(%rdi)
+L(P2Q5): mov    %rdx,-0x2a(%rdi)
+L(P2Q4): mov    %rdx,-0x22(%rdi)
+L(P2Q3): mov    %rdx,-0x1a(%rdi)
+L(P2Q2): mov    %rdx,-0x12(%rdi)
+L(P2Q1): mov    %rdx,-0xa(%rdi)
+L(P2Q0): mov    %dx,-0x2(%rdi)
+		retq   $0x0
+
+	.balign     16
+#if defined(USE_EXTRA_TABLE)
+L(P3QI): mov    %rdx,-0x93(%rdi)
+#endif
+L(P3QH): mov    %rdx,-0x8b(%rdi)
+L(P3QG): mov    %rdx,-0x83(%rdi)
+#		   .balign     16
+L(P3QF): mov    %rdx,-0x7b(%rdi)
+L(P3QE): mov    %rdx,-0x73(%rdi)
+L(P3QD): mov    %rdx,-0x6b(%rdi)
+L(P3QC): mov    %rdx,-0x63(%rdi)
+L(P3QB): mov    %rdx,-0x5b(%rdi)
+L(P3QA): mov    %rdx,-0x53(%rdi)
+L(P3Q9): mov    %rdx,-0x4b(%rdi)
+L(P3Q8): mov    %rdx,-0x43(%rdi)
+L(P3Q7): mov    %rdx,-0x3b(%rdi)
+L(P3Q6): mov    %rdx,-0x33(%rdi)
+L(P3Q5): mov    %rdx,-0x2b(%rdi)
+L(P3Q4): mov    %rdx,-0x23(%rdi)
+L(P3Q3): mov    %rdx,-0x1b(%rdi)
+L(P3Q2): mov    %rdx,-0x13(%rdi)
+L(P3Q1): mov    %rdx,-0xb(%rdi)
+L(P3Q0): mov    %dx,-0x3(%rdi)
+		mov    %dl,-0x1(%rdi)
+		retq   $0x0
+
+	.balign     16
+#if defined(USE_EXTRA_TABLE)
+L(P4QI): mov    %rdx,-0x94(%rdi)
+#endif
+L(P4QH): mov    %rdx,-0x8c(%rdi)
+L(P4QG): mov    %rdx,-0x84(%rdi)
+#		   .balign     16
+L(P4QF): mov    %rdx,-0x7c(%rdi)
+L(P4QE): mov    %rdx,-0x74(%rdi)
+L(P4QD): mov    %rdx,-0x6c(%rdi)
+L(P4QC): mov    %rdx,-0x64(%rdi)
+L(P4QB): mov    %rdx,-0x5c(%rdi)
+L(P4QA): mov    %rdx,-0x54(%rdi)
+L(P4Q9): mov    %rdx,-0x4c(%rdi)
+L(P4Q8): mov    %rdx,-0x44(%rdi)
+L(P4Q7): mov    %rdx,-0x3c(%rdi)
+L(P4Q6): mov    %rdx,-0x34(%rdi)
+L(P4Q5): mov    %rdx,-0x2c(%rdi)
+L(P4Q4): mov    %rdx,-0x24(%rdi)
+L(P4Q3): mov    %rdx,-0x1c(%rdi)
+L(P4Q2): mov    %rdx,-0x14(%rdi)
+L(P4Q1): mov    %rdx,-0xc(%rdi)
+L(P4Q0): mov    %edx,-0x4(%rdi)
+		retq   $0x0
+
+	.balign     16
+#if defined(USE_EXTRA_TABLE)
+L(P5QI): mov    %rdx,-0x95(%rdi)
+#endif
+L(P5QH): mov    %rdx,-0x8d(%rdi)
+L(P5QG): mov    %rdx,-0x85(%rdi)
+#		   .balign     16
+L(P5QF): mov    %rdx,-0x7d(%rdi)
+L(P5QE): mov    %rdx,-0x75(%rdi)
+L(P5QD): mov    %rdx,-0x6d(%rdi)
+L(P5QC): mov    %rdx,-0x65(%rdi)
+L(P5QB): mov    %rdx,-0x5d(%rdi)
+L(P5QA): mov    %rdx,-0x55(%rdi)
+L(P5Q9): mov    %rdx,-0x4d(%rdi)
+L(P5Q8): mov    %rdx,-0x45(%rdi)
+L(P5Q7): mov    %rdx,-0x3d(%rdi)
+L(P5Q6): mov    %rdx,-0x35(%rdi)
+L(P5Q5): mov    %rdx,-0x2d(%rdi)
+L(P5Q4): mov    %rdx,-0x25(%rdi)
+L(P5Q3): mov    %rdx,-0x1d(%rdi)
+L(P5Q2): mov    %rdx,-0x15(%rdi)
+L(P5Q1): mov    %rdx,-0xd(%rdi)
+L(P5Q0): mov    %edx,-0x5(%rdi)
+		mov    %dl,-0x1(%rdi)
+		retq   $0x0
+
+	.balign     16
+#if defined(USE_EXTRA_TABLE)
+L(P6QI): mov    %rdx,-0x96(%rdi)
+#endif
+L(P6QH): mov    %rdx,-0x8e(%rdi)
+L(P6QG): mov    %rdx,-0x86(%rdi)
+#		   .balign     16
+L(P6QF): mov    %rdx,-0x7e(%rdi)
+L(P6QE): mov    %rdx,-0x76(%rdi)
+L(P6QD): mov    %rdx,-0x6e(%rdi)
+L(P6QC): mov    %rdx,-0x66(%rdi)
+L(P6QB): mov    %rdx,-0x5e(%rdi)
+L(P6QA): mov    %rdx,-0x56(%rdi)
+L(P6Q9): mov    %rdx,-0x4e(%rdi)
+L(P6Q8): mov    %rdx,-0x46(%rdi)
+L(P6Q7): mov    %rdx,-0x3e(%rdi)
+L(P6Q6): mov    %rdx,-0x36(%rdi)
+L(P6Q5): mov    %rdx,-0x2e(%rdi)
+L(P6Q4): mov    %rdx,-0x26(%rdi)
+L(P6Q3): mov    %rdx,-0x1e(%rdi)
+L(P6Q2): mov    %rdx,-0x16(%rdi)
+L(P6Q1): mov    %rdx,-0xe(%rdi)
+L(P6Q0): mov    %edx,-0x6(%rdi)
+		mov    %dx,-0x2(%rdi)
+		retq   $0x0
+
+	.balign     16
+#if defined(USE_EXTRA_TABLE)
+L(P7QI): mov    %rdx,-0x97(%rdi)
+#endif
+L(P7QH): mov    %rdx,-0x8f(%rdi)
+L(P7QG): mov    %rdx,-0x87(%rdi)
+#		   .balign     16
+L(P7QF): mov    %rdx,-0x7f(%rdi)
+L(P7QE): mov    %rdx,-0x77(%rdi)
+L(P7QD): mov    %rdx,-0x6f(%rdi)
+L(P7QC): mov    %rdx,-0x67(%rdi)
+L(P7QB): mov    %rdx,-0x5f(%rdi)
+L(P7QA): mov    %rdx,-0x57(%rdi)
+L(P7Q9): mov    %rdx,-0x4f(%rdi)
+L(P7Q8): mov    %rdx,-0x47(%rdi)
+L(P7Q7): mov    %rdx,-0x3f(%rdi)
+L(P7Q6): mov    %rdx,-0x37(%rdi)
+L(P7Q5): mov    %rdx,-0x2f(%rdi)
+L(P7Q4): mov    %rdx,-0x27(%rdi)
+L(P7Q3): mov    %rdx,-0x1f(%rdi)
+L(P7Q2): mov    %rdx,-0x17(%rdi)
+L(P7Q1): mov    %rdx,-0xf(%rdi)
+L(P7Q0): mov    %edx,-0x7(%rdi)
+		mov    %dx,-0x3(%rdi)
+		mov    %dl,-0x1(%rdi)
+		retq   $0x0
+
+	.balign     16
+L(ck_mem_ops_method):                      
+
+# align to 16 byte boundary first
+	#test $0xf,%rdi
+	#jz L(aligned_now)
+	 lea    L(AliPxQx)(%rip),%r11
+	 mov    $0x10,%r10
+	 mov    %rdi,%r9
+	 and    $0xf,%r9
+	 sub    %r9,%r10
+	 and    $0xf,%r10
+	 add    %r10,%rdi
+	 sub    %r10,%r8
+#if !defined(PIC)
+	jmpq   *(%r11,%r10,8) # old scheme remained for nonPIC
+#else
+	movslq (%r11,%r10,4),%rcx
+	lea    (%rcx,%r11,1),%r11
+	jmpq   *%r11
+#endif
+
+	PUSH_RODATA_SECTION
+	.balign     16
+#if !defined(PIC)
+L(AliPxQx):
+	.quad       L(aligned_now),L(A1Q0),L(A2Q0),L(A3Q0),L(A4Q0),L(A5Q0),L(A6Q0),L(A7Q0)
+	.quad       L(A0Q1),L(A1Q1),L(A2Q1),L(A3Q1),L(A4Q1),L(A5Q1),L(A6Q1),L(A7Q1)
+#else
+L(AliPxQx):
+	.int       L(aligned_now)-L(AliPxQx)
+	.int       L(A1Q0)-L(AliPxQx)
+	.int       L(A2Q0)-L(AliPxQx)
+	.int       L(A3Q0)-L(AliPxQx)
+	.int       L(A4Q0)-L(AliPxQx)
+	.int       L(A5Q0)-L(AliPxQx)
+	.int       L(A6Q0)-L(AliPxQx)
+	.int       L(A7Q0)-L(AliPxQx)
+
+	.int       L(A0Q1)-L(AliPxQx)
+	.int       L(A1Q1)-L(AliPxQx)
+	.int       L(A2Q1)-L(AliPxQx)
+	.int       L(A3Q1)-L(AliPxQx)
+	.int       L(A4Q1)-L(AliPxQx)
+	.int       L(A5Q1)-L(AliPxQx)
+	.int       L(A6Q1)-L(AliPxQx)
+	.int       L(A7Q1)-L(AliPxQx)
+#endif
+	POP_SECTION
+
+	.balign     16
+L(A5Q1):    mov    %dl,-0xd(%rdi)
+L(A4Q1):    mov    %edx,-0xc(%rdi)
+L(A0Q1):    mov    %rdx,-0x8(%rdi)
+L(A0Q0):    jmp     L(aligned_now)
+
+	.balign     16
+L(A1Q1):   mov    %dl,-0x9(%rdi)
+	mov    %rdx,-0x8(%rdi)
+	jmp    L(aligned_now) 
+
+	.balign     16
+L(A1Q0):   mov    %dl,-0x1(%rdi)
+	jmp    L(aligned_now) 
+
+	.balign     16
+L(A3Q1):    mov    %dl,-0xb(%rdi)
+L(A2Q1):    mov    %dx,-0xa(%rdi)
+	mov    %rdx,-0x8(%rdi)
+	jmp    L(aligned_now) 
+
+	.balign     16
+L(A3Q0):    mov    %dl,-0x3(%rdi)
+L(A2Q0):    mov    %dx,-0x2(%rdi)
+	jmp    L(aligned_now) 
+
+	.balign     16
+L(A5Q0):    mov    %dl,-0x5(%rdi)
+L(A4Q0):    mov    %edx,-0x4(%rdi)
+	jmp    L(aligned_now) 
+
+	.balign     16
+L(A7Q1):    mov    %dl,-0xf(%rdi)
+L(A6Q1):    mov    %dx,-0xe(%rdi)
+	mov    %edx,-0xc(%rdi)
+	mov    %rdx,-0x8(%rdi)
+	jmp    L(aligned_now) 
+
+	.balign     16
+L(A7Q0):    mov    %dl,-0x7(%rdi)
+L(A6Q0):    mov    %dx,-0x6(%rdi)
+	mov    %edx,-0x4(%rdi)
+	jmp    L(aligned_now)
+
+	.balign     16
+L(aligned_now):
+
+	 cmpl   $0x1,_EXT_NM_(%rip)
+	 jle     L(Loop8byte_pre)    
+
+	 # fill RegXMM0 with the pattern
+	 movd   %rdx,%xmm0
+	 punpcklqdq %xmm0,%xmm0
+
+  #cmp ecx,256
+  #jmp L(byte32sse2)
+  #cmp ecx,512  ; 256 or 512 doesn't matter much. Changing to 256 would reduce code size
+  #cmp RegLen,128  ; 256 or 512 doesn't matter much. Changing to 256 would reduce code size
+
+	 lea    L(SSExDx)(%rip),%r9        # for later after the alignment
+	 cmp    $0xb0,%r8 # 176
+	 jge    L(byte32sse2_pre)   
+
+	 add    %r8,%rdi
+#if !defined(PIC)
+	 jmpq   *(%r9,%r8,8) # old scheme remained for nonPIC
 #else
-	/* Load result (only if used as memset).  */
-	mov	%rdi,%rax	/* start address of destination is result */
+	 movslq    (%r9,%r8,4),%rcx
+	 lea    (%rcx,%r9,1),%r9
+	 jmpq   *%r9
 #endif
-	retq
 
-	.p2align 4
-11:	/* Copy 64 bytes without polluting the cache.  */
-	/* We could use	movntdq    %xmm0,(%rcx) here to further
-	   speed up for large cases but let's not use XMM registers.  */
-	movnti	%r8,(%rcx)
-	movnti  %r8,0x8(%rcx)
-	movnti  %r8,0x10(%rcx)
-	movnti  %r8,0x18(%rcx)
-	movnti  %r8,0x20(%rcx)
-	movnti  %r8,0x28(%rcx)
-	movnti  %r8,0x30(%rcx)
-	movnti  %r8,0x38(%rcx)
-	add	$0x40,%rcx
-	dec	%rax
-	jne	11b
-	jmp	4b
+L(SSE0QB):  movdqa %xmm0,-0xb0(%rdi)
+L(SSE0QA):  movdqa %xmm0,-0xa0(%rdi)
+L(SSE0Q9):  movdqa %xmm0,-0x90(%rdi)
+L(SSE0Q8):  movdqa %xmm0,-0x80(%rdi)
+L(SSE0Q7):  movdqa %xmm0,-0x70(%rdi)
+L(SSE0Q6):  movdqa %xmm0,-0x60(%rdi)
+L(SSE0Q5):  movdqa %xmm0,-0x50(%rdi)
+L(SSE0Q4):  movdqa %xmm0,-0x40(%rdi)
+L(SSE0Q3):  movdqa %xmm0,-0x30(%rdi)
+L(SSE0Q2):  movdqa %xmm0,-0x20(%rdi)
+L(SSE0Q1):  movdqa %xmm0,-0x10(%rdi)
+L(SSE0Q0):  retq   $0x0
+
+L(SSE1QB):  movdqa %xmm0,-0xb1(%rdi)
+L(SSE1QA):  movdqa %xmm0,-0xa1(%rdi)
+L(SSE1Q9):  movdqa %xmm0,-0x91(%rdi)
+L(SSE1Q8):  movdqa %xmm0,-0x81(%rdi)
+L(SSE1Q7):  movdqa %xmm0,-0x71(%rdi)
+L(SSE1Q6):  movdqa %xmm0,-0x61(%rdi)
+L(SSE1Q5):  movdqa %xmm0,-0x51(%rdi)
+L(SSE1Q4):  movdqa %xmm0,-0x41(%rdi)
+L(SSE1Q3):  movdqa %xmm0,-0x31(%rdi)
+L(SSE1Q2):  movdqa %xmm0,-0x21(%rdi)
+L(SSE1Q1):  movdqa %xmm0,-0x11(%rdi)
+L(SSE1Q0):  mov    %dl,-0x1(%rdi)
+	retq   $0x0
+
+L(SSE2QB):  movdqa %xmm0,-0xb2(%rdi)
+L(SSE2QA):  movdqa %xmm0,-0xa2(%rdi)
+L(SSE2Q9):  movdqa %xmm0,-0x92(%rdi)
+L(SSE2Q8):  movdqa %xmm0,-0x82(%rdi)
+L(SSE2Q7):  movdqa %xmm0,-0x72(%rdi)
+L(SSE2Q6):  movdqa %xmm0,-0x62(%rdi)
+L(SSE2Q5):  movdqa %xmm0,-0x52(%rdi)
+L(SSE2Q4):  movdqa %xmm0,-0x42(%rdi)
+L(SSE2Q3):  movdqa %xmm0,-0x32(%rdi)
+L(SSE2Q2):  movdqa %xmm0,-0x22(%rdi)
+L(SSE2Q1):  movdqa %xmm0,-0x12(%rdi)
+L(SSE2Q0):  mov    %dx,-0x2(%rdi)
+	retq   $0x0
+
+L(SSE3QB):  movdqa %xmm0,-0xb3(%rdi)
+L(SSE3QA):  movdqa %xmm0,-0xa3(%rdi)
+L(SSE3Q9):  movdqa %xmm0,-0x93(%rdi)
+L(SSE3Q8):  movdqa %xmm0,-0x83(%rdi)
+L(SSE3Q7):  movdqa %xmm0,-0x73(%rdi)
+L(SSE3Q6):  movdqa %xmm0,-0x63(%rdi)
+L(SSE3Q5):  movdqa %xmm0,-0x53(%rdi)
+L(SSE3Q4):  movdqa %xmm0,-0x43(%rdi)
+L(SSE3Q3):  movdqa %xmm0,-0x33(%rdi)
+L(SSE3Q2):  movdqa %xmm0,-0x23(%rdi)
+L(SSE3Q1):  movdqa %xmm0,-0x13(%rdi)
+L(SSE3Q0):  mov    %dx,-0x3(%rdi)
+	mov    %dl,-0x1(%rdi)
+	retq   $0x0
+
+L(SSE4QB):  movdqa %xmm0,-0xb4(%rdi)
+L(SSE4QA):  movdqa %xmm0,-0xa4(%rdi)
+L(SSE4Q9):  movdqa %xmm0,-0x94(%rdi)
+L(SSE4Q8):  movdqa %xmm0,-0x84(%rdi)
+L(SSE4Q7):  movdqa %xmm0,-0x74(%rdi)
+L(SSE4Q6):  movdqa %xmm0,-0x64(%rdi)
+L(SSE4Q5):  movdqa %xmm0,-0x54(%rdi)
+L(SSE4Q4):  movdqa %xmm0,-0x44(%rdi)
+L(SSE4Q3):  movdqa %xmm0,-0x34(%rdi)
+L(SSE4Q2):  movdqa %xmm0,-0x24(%rdi)
+L(SSE4Q1):  movdqa %xmm0,-0x14(%rdi)
+L(SSE4Q0):  mov    %edx,-0x4(%rdi)
+	retq   $0x0
+
+L(SSE5QB):  movdqa %xmm0,-0xb5(%rdi)
+L(SSE5QA):  movdqa %xmm0,-0xa5(%rdi)
+L(SSE5Q9):  movdqa %xmm0,-0x95(%rdi)
+L(SSE5Q8):  movdqa %xmm0,-0x85(%rdi)
+L(SSE5Q7):  movdqa %xmm0,-0x75(%rdi)
+L(SSE5Q6):  movdqa %xmm0,-0x65(%rdi)
+L(SSE5Q5):  movdqa %xmm0,-0x55(%rdi)
+L(SSE5Q4):  movdqa %xmm0,-0x45(%rdi)
+L(SSE5Q3):  movdqa %xmm0,-0x35(%rdi)
+L(SSE5Q2):  movdqa %xmm0,-0x25(%rdi)
+L(SSE5Q1):  movdqa %xmm0,-0x15(%rdi)
+L(SSE5Q0):  mov    %edx,-0x5(%rdi)
+	mov    %dl,-0x1(%rdi)
+	retq   $0x0
+
+L(SSE6QB):  movdqa %xmm0,-0xb6(%rdi)
+L(SSE6QA):  movdqa %xmm0,-0xa6(%rdi)
+L(SSE6Q9):  movdqa %xmm0,-0x96(%rdi)
+L(SSE6Q8):  movdqa %xmm0,-0x86(%rdi)
+L(SSE6Q7):  movdqa %xmm0,-0x76(%rdi)
+L(SSE6Q6):  movdqa %xmm0,-0x66(%rdi)
+L(SSE6Q5):  movdqa %xmm0,-0x56(%rdi)
+L(SSE6Q4):  movdqa %xmm0,-0x46(%rdi)
+L(SSE6Q3):  movdqa %xmm0,-0x36(%rdi)
+L(SSE6Q2):  movdqa %xmm0,-0x26(%rdi)
+L(SSE6Q1):  movdqa %xmm0,-0x16(%rdi)
+L(SSE6Q0):  mov    %edx,-0x6(%rdi)
+	mov    %dx,-0x2(%rdi)
+	retq   $0x0
+
+L(SSE7QB):  movdqa %xmm0,-0xb7(%rdi)
+L(SSE7QA):  movdqa %xmm0,-0xa7(%rdi)
+L(SSE7Q9):  movdqa %xmm0,-0x97(%rdi)
+L(SSE7Q8):  movdqa %xmm0,-0x87(%rdi)
+L(SSE7Q7):  movdqa %xmm0,-0x77(%rdi)
+L(SSE7Q6):  movdqa %xmm0,-0x67(%rdi)
+L(SSE7Q5):  movdqa %xmm0,-0x57(%rdi)
+L(SSE7Q4):  movdqa %xmm0,-0x47(%rdi)
+L(SSE7Q3):  movdqa %xmm0,-0x37(%rdi)
+L(SSE7Q2):  movdqa %xmm0,-0x27(%rdi)
+L(SSE7Q1):  movdqa %xmm0,-0x17(%rdi)
+L(SSE7Q0):  mov    %edx,-0x7(%rdi)
+	mov    %dx,-0x3(%rdi)
+	mov    %dl,-0x1(%rdi)
+	retq   $0x0
+
+L(SSE8QB):  movdqa %xmm0,-0xb8(%rdi)
+L(SSE8QA):  movdqa %xmm0,-0xa8(%rdi)
+L(SSE8Q9):  movdqa %xmm0,-0x98(%rdi)
+L(SSE8Q8):  movdqa %xmm0,-0x88(%rdi)
+L(SSE8Q7):  movdqa %xmm0,-0x78(%rdi)
+L(SSE8Q6):  movdqa %xmm0,-0x68(%rdi)
+L(SSE8Q5):  movdqa %xmm0,-0x58(%rdi)
+L(SSE8Q4):  movdqa %xmm0,-0x48(%rdi)
+L(SSE8Q3):  movdqa %xmm0,-0x38(%rdi)
+L(SSE8Q2):  movdqa %xmm0,-0x28(%rdi)
+L(SSE8Q1):  movdqa %xmm0,-0x18(%rdi)
+L(SSE8Q0):  mov    %rdx,-0x8(%rdi)
+	retq   $0x0
+
+L(SSE9QB):  movdqa %xmm0,-0xb9(%rdi)
+L(SSE9QA):  movdqa %xmm0,-0xa9(%rdi)
+L(SSE9Q9):  movdqa %xmm0,-0x99(%rdi)
+L(SSE9Q8):  movdqa %xmm0,-0x89(%rdi)
+L(SSE9Q7):  movdqa %xmm0,-0x79(%rdi)
+L(SSE9Q6):  movdqa %xmm0,-0x69(%rdi)
+L(SSE9Q5):  movdqa %xmm0,-0x59(%rdi)
+L(SSE9Q4):  movdqa %xmm0,-0x49(%rdi)
+L(SSE9Q3):  movdqa %xmm0,-0x39(%rdi)
+L(SSE9Q2):  movdqa %xmm0,-0x29(%rdi)
+L(SSE9Q1):  movdqa %xmm0,-0x19(%rdi)
+L(SSE9Q0):  mov    %rdx,-0x9(%rdi)
+	mov    %dl,-0x1(%rdi)
+	retq   $0x0
+
+L(SSE10QB): movdqa %xmm0,-0xba(%rdi)
+L(SSE10QA): movdqa %xmm0,-0xaa(%rdi)
+L(SSE10Q9): movdqa %xmm0,-0x9a(%rdi)
+L(SSE10Q8): movdqa %xmm0,-0x8a(%rdi)
+L(SSE10Q7): movdqa %xmm0,-0x7a(%rdi)
+L(SSE10Q6): movdqa %xmm0,-0x6a(%rdi)
+L(SSE10Q5): movdqa %xmm0,-0x5a(%rdi)
+L(SSE10Q4): movdqa %xmm0,-0x4a(%rdi)
+L(SSE10Q3): movdqa %xmm0,-0x3a(%rdi)
+L(SSE10Q2): movdqa %xmm0,-0x2a(%rdi)
+L(SSE10Q1): movdqa %xmm0,-0x1a(%rdi)
+L(SSE10Q0): mov    %rdx,-0xa(%rdi)
+	mov    %dx,-0x2(%rdi)
+	retq   $0x0
+
+L(SSE11QB): movdqa %xmm0,-0xbb(%rdi)
+L(SSE11QA): movdqa %xmm0,-0xab(%rdi)
+L(SSE11Q9): movdqa %xmm0,-0x9b(%rdi)
+L(SSE11Q8): movdqa %xmm0,-0x8b(%rdi)
+L(SSE11Q7): movdqa %xmm0,-0x7b(%rdi)
+L(SSE11Q6): movdqa %xmm0,-0x6b(%rdi)
+L(SSE11Q5): movdqa %xmm0,-0x5b(%rdi)
+L(SSE11Q4): movdqa %xmm0,-0x4b(%rdi)
+L(SSE11Q3): movdqa %xmm0,-0x3b(%rdi)
+L(SSE11Q2): movdqa %xmm0,-0x2b(%rdi)
+L(SSE11Q1): movdqa %xmm0,-0x1b(%rdi)
+L(SSE11Q0): mov    %rdx,-0xb(%rdi)
+	mov    %dx,-0x3(%rdi)
+	mov    %dl,-0x1(%rdi)
+	retq   $0x0
+
+L(SSE12QB): movdqa %xmm0,-0xbc(%rdi)
+L(SSE12QA): movdqa %xmm0,-0xac(%rdi)
+L(SSE12Q9): movdqa %xmm0,-0x9c(%rdi)
+L(SSE12Q8): movdqa %xmm0,-0x8c(%rdi)
+L(SSE12Q7): movdqa %xmm0,-0x7c(%rdi)
+L(SSE12Q6): movdqa %xmm0,-0x6c(%rdi)
+L(SSE12Q5): movdqa %xmm0,-0x5c(%rdi)
+L(SSE12Q4): movdqa %xmm0,-0x4c(%rdi)
+L(SSE12Q3): movdqa %xmm0,-0x3c(%rdi)
+L(SSE12Q2): movdqa %xmm0,-0x2c(%rdi)
+L(SSE12Q1): movdqa %xmm0,-0x1c(%rdi)
+L(SSE12Q0): mov    %rdx,-0xc(%rdi)
+	mov    %edx,-0x4(%rdi)
+	retq   $0x0
+
+L(SSE13QB): movdqa %xmm0,-0xbd(%rdi)
+L(SSE13QA): movdqa %xmm0,-0xad(%rdi)
+L(SSE13Q9): movdqa %xmm0,-0x9d(%rdi)
+L(SSE13Q8): movdqa %xmm0,-0x8d(%rdi)
+L(SSE13Q7): movdqa %xmm0,-0x7d(%rdi)
+L(SSE13Q6): movdqa %xmm0,-0x6d(%rdi)
+L(SSE13Q5): movdqa %xmm0,-0x5d(%rdi)
+L(SSE13Q4): movdqa %xmm0,-0x4d(%rdi)
+L(SSE13Q3): movdqa %xmm0,-0x3d(%rdi)
+L(SSE13Q2): movdqa %xmm0,-0x2d(%rdi)
+L(SSE13Q1): movdqa %xmm0,-0x1d(%rdi)
+L(SSE13Q0): mov    %rdx,-0xd(%rdi)
+	mov    %edx,-0x5(%rdi)
+	mov    %dl,-0x1(%rdi)
+	retq   $0x0
+
+L(SSE14QB): movdqa %xmm0,-0xbe(%rdi)
+L(SSE14QA): movdqa %xmm0,-0xae(%rdi)
+L(SSE14Q9): movdqa %xmm0,-0x9e(%rdi)
+L(SSE14Q8): movdqa %xmm0,-0x8e(%rdi)
+L(SSE14Q7): movdqa %xmm0,-0x7e(%rdi)
+L(SSE14Q6): movdqa %xmm0,-0x6e(%rdi)
+L(SSE14Q5): movdqa %xmm0,-0x5e(%rdi)
+L(SSE14Q4): movdqa %xmm0,-0x4e(%rdi)
+L(SSE14Q3): movdqa %xmm0,-0x3e(%rdi)
+L(SSE14Q2): movdqa %xmm0,-0x2e(%rdi)
+L(SSE14Q1): movdqa %xmm0,-0x1e(%rdi)
+L(SSE14Q0): mov    %rdx,-0xe(%rdi)
+	mov    %edx,-0x6(%rdi)
+	mov    %dx,-0x2(%rdi)
+	retq   $0x0
+
+L(SSE15QB): movdqa %xmm0,-0xbf(%rdi)
+L(SSE15QA): movdqa %xmm0,-0xaf(%rdi)
+L(SSE15Q9): movdqa %xmm0,-0x9f(%rdi)
+L(SSE15Q8): movdqa %xmm0,-0x8f(%rdi)
+L(SSE15Q7): movdqa %xmm0,-0x7f(%rdi)
+L(SSE15Q6): movdqa %xmm0,-0x6f(%rdi)
+L(SSE15Q5): movdqa %xmm0,-0x5f(%rdi)
+L(SSE15Q4): movdqa %xmm0,-0x4f(%rdi)
+L(SSE15Q3): movdqa %xmm0,-0x3f(%rdi)
+L(SSE15Q2): movdqa %xmm0,-0x2f(%rdi)
+L(SSE15Q1): movdqa %xmm0,-0x1f(%rdi)
+L(SSE15Q0): mov    %rdx,-0xf(%rdi)
+	mov    %edx,-0x7(%rdi)
+	mov    %dx,-0x3(%rdi)
+	mov    %dl,-0x1(%rdi)
+	retq   $0x0
+
+	.balign     16               
+L(byte32sse2_pre):                         
+
+#if !defined(NOT_IN_GLIBC)
+	mov    _EXT_SZ_(%rip),%r9d  # The largest cache size
+#else
+	mov    _EXT_SZ_(%rip),%r9  # The largest cache size
+	# Glibc reports half the cache size.
+	shl	%r9
+#endif
+	cmp    %r9,%r8
+	jg     L(sse2_nt_move_pre) 
+	#jmp    L(byte32sse2) 
+	.balign     16               
+L(byte32sse2):                             
+	lea    -0x80(%r8),%r8 # 128
+	cmp    $0x80,%r8   # 128
+	movdqa %xmm0,(%rdi)
+	movdqa %xmm0,0x10(%rdi)
+	movdqa %xmm0,0x20(%rdi)
+	movdqa %xmm0,0x30(%rdi)
+	movdqa %xmm0,0x40(%rdi)
+	movdqa %xmm0,0x50(%rdi)
+	movdqa %xmm0,0x60(%rdi)
+	movdqa %xmm0,0x70(%rdi)
+
+	lea    0x80(%rdi),%rdi
+	jge    L(byte32sse2) 
+	lea    L(SSExDx)(%rip),%r11
+	add    %r8,%rdi
+#if !defined(PIC)
+	jmpq   *(%r11,%r8,8) # old scheme remained for nonPIC
+#else
+	movslq    (%r11,%r8,4),%rcx
+	lea    (%rcx,%r11,1),%r11
+	jmpq   *%r11
+#endif
+
+	.balign     16               
+L(sse2_nt_move_pre):                       
+	cmp    $0x0,%r9
+	je     L(byte32sse2) 
+	jmp    L(sse2_nt_move) 
+
+	.balign     16               
+L(sse2_nt_move):                           
+	lea    -0x80(%r8),%r8
+	cmp    $0x80,%r8
+  
+	movntdq %xmm0,(%rdi)
+	movntdq %xmm0,0x10(%rdi)
+	movntdq %xmm0,0x20(%rdi)
+	movntdq %xmm0,0x30(%rdi)
+	movntdq %xmm0,0x40(%rdi)
+	movntdq %xmm0,0x50(%rdi)
+	movntdq %xmm0,0x60(%rdi)
+	movntdq %xmm0,0x70(%rdi)
+
+	lea    0x80(%rdi),%rdi
+	jge    L(sse2_nt_move) 
+	lea    L(SSExDx)(%rip),%r11
+	sfence 
+	add    %r8,%rdi
+#if !defined(PIC)
+	jmpq   *(%r11,%r8,8) # old scheme remained for nonPIC
+#else
+	movslq (%r11,%r8,4),%rcx
+	lea    (%rcx,%r11,1),%r11
+	jmpq   *%r11
+#endif
+
+	.balign     16               
+L(Loop8byte_pre):                          
+#if !defined(NOT_IN_GLIBC)
+	mov    _EXT_SZ_(%rip),%r9d        # ck largest cache size
+#else
+	mov    _EXT_SZ_(%rip),%r9        # ck largest cache size
+	# Glibc reports half the cache size.
+	shl	%r9
+#endif
 
+L(top_8byte_loop):                         
+	cmp    %r9,%r8
+	jg     L(Loop8byte_nt_move_pre) 
+	#jmp    L(Loop8byte)  
+
+	.balign     16               
+L(Loop8byte):                              
+	lea    -0x80(%r8),%r8
+	cmp    $0x80,%r8   # 64
+	mov    %rdx,(%rdi)
+	mov    %rdx,0x8(%rdi)
+	mov    %rdx,0x10(%rdi)
+	mov    %rdx,0x18(%rdi)
+	mov    %rdx,0x20(%rdi)
+	mov    %rdx,0x28(%rdi)
+	mov    %rdx,0x30(%rdi)
+	mov    %rdx,0x38(%rdi)
+	mov    %rdx,0x40(%rdi)
+	mov    %rdx,0x48(%rdi)
+	mov    %rdx,0x50(%rdi)
+	mov    %rdx,0x58(%rdi)
+	mov    %rdx,0x60(%rdi)
+	mov    %rdx,0x68(%rdi)
+	mov    %rdx,0x70(%rdi)
+	mov    %rdx,0x78(%rdi)
+	lea    0x80(%rdi),%rdi
+	jg     L(Loop8byte)  
+	lea    (%rdi,%r8,1),%rdi
+	lea    L(setPxQx)(%rip),%r11
+#if !defined(PIC)
+	jmpq   *(%r11,%r8,8) # old scheme remained for nonPIC
+#else
+	movslq    (%r11,%r8,4),%rcx
+	lea    (%rcx,%r11,1),%r11
+	jmpq   *%r11
+#endif
+
+	.balign     16               
+L(Loop8byte_nt_move_pre):                  
+	cmp    $0x0,%r9
+	je     L(Loop8byte)  
+	jmp    L(Loop8byte_nt_move) 
+
+	.balign     16               
+L(Loop8byte_nt_move):                      
+	movnti %rdx,(%rdi)
+	movnti %rdx,0x8(%rdi)
+	lea    -0x40(%r8),%r8
+	movnti %rdx,0x10(%rdi)
+	movnti %rdx,0x18(%rdi)
+	movnti %rdx,0x20(%rdi)
+	cmp    $0x40,%r8  # 64
+	movnti %rdx,0x28(%rdi)
+	movnti %rdx,0x30(%rdi)
+	movnti %rdx,0x38(%rdi)
+	lea    0x40(%rdi),%rdi
+	jge    L(Loop8byte_nt_move) 
+	lea    L(setPxQx)(%rip),%r11
+	lea    (%rdi,%r8,1),%rdi
+	sfence 
+#if !defined(PIC)
+	jmpq   *(%r11,%r8,8) # old scheme remained for nonPIC
+#else
+	movslq    (%r11,%r8,4),%rcx
+	lea    (%rcx,%r11,1),%r11
+	jmpq   *%r11
+#endif
+
+	PUSH_RODATA_SECTION
+	.balign     16               
+#if !defined(PIC)
+L(SSExDx):
+	.quad       L(SSE0Q0),L(SSE1Q0),L(SSE2Q0), L(SSE3Q0), L(SSE4Q0), L(SSE5Q0), L(SSE6Q0), L(SSE7Q0) 
+	.quad       L(SSE8Q0),L(SSE9Q0),L(SSE10Q0),L(SSE11Q0),L(SSE12Q0),L(SSE13Q0),L(SSE14Q0),L(SSE15Q0) 
+	.quad       L(SSE0Q1),L(SSE1Q1),L(SSE2Q1), L(SSE3Q1), L(SSE4Q1), L(SSE5Q1), L(SSE6Q1), L(SSE7Q1) 
+	.quad       L(SSE8Q1),L(SSE9Q1),L(SSE10Q1),L(SSE11Q1),L(SSE12Q1),L(SSE13Q1),L(SSE14Q1),L(SSE15Q1) 
+	.quad       L(SSE0Q2),L(SSE1Q2),L(SSE2Q2), L(SSE3Q2), L(SSE4Q2), L(SSE5Q2), L(SSE6Q2), L(SSE7Q2) 
+	.quad       L(SSE8Q2),L(SSE9Q2),L(SSE10Q2),L(SSE11Q2),L(SSE12Q2),L(SSE13Q2),L(SSE14Q2),L(SSE15Q2) 
+	.quad       L(SSE0Q3),L(SSE1Q3),L(SSE2Q3), L(SSE3Q3), L(SSE4Q3), L(SSE5Q3), L(SSE6Q3), L(SSE7Q3) 
+	.quad       L(SSE8Q3),L(SSE9Q3),L(SSE10Q3),L(SSE11Q3),L(SSE12Q3),L(SSE13Q3),L(SSE14Q3),L(SSE15Q3) 
+	.quad       L(SSE0Q4),L(SSE1Q4),L(SSE2Q4), L(SSE3Q4), L(SSE4Q4), L(SSE5Q4), L(SSE6Q4), L(SSE7Q4) 
+	.quad       L(SSE8Q4),L(SSE9Q4),L(SSE10Q4),L(SSE11Q4),L(SSE12Q4),L(SSE13Q4),L(SSE14Q4),L(SSE15Q4) 
+	.quad       L(SSE0Q5),L(SSE1Q5),L(SSE2Q5), L(SSE3Q5), L(SSE4Q5), L(SSE5Q5), L(SSE6Q5), L(SSE7Q5) 
+	.quad       L(SSE8Q5),L(SSE9Q5),L(SSE10Q5),L(SSE11Q5),L(SSE12Q5),L(SSE13Q5),L(SSE14Q5),L(SSE15Q5) 
+	.quad       L(SSE0Q6),L(SSE1Q6),L(SSE2Q6), L(SSE3Q6), L(SSE4Q6), L(SSE5Q6), L(SSE6Q6), L(SSE7Q6) 
+	.quad       L(SSE8Q6),L(SSE9Q6),L(SSE10Q6),L(SSE11Q6),L(SSE12Q6),L(SSE13Q6),L(SSE14Q6),L(SSE15Q6) 
+	.quad       L(SSE0Q7),L(SSE1Q7),L(SSE2Q7), L(SSE3Q7), L(SSE4Q7), L(SSE5Q7), L(SSE6Q7), L(SSE7Q7) 
+	.quad       L(SSE8Q7),L(SSE9Q7),L(SSE10Q7),L(SSE11Q7),L(SSE12Q7),L(SSE13Q7),L(SSE14Q7),L(SSE15Q7) 
+	.quad       L(SSE0Q8),L(SSE1Q8),L(SSE2Q8), L(SSE3Q8), L(SSE4Q8), L(SSE5Q8), L(SSE6Q8), L(SSE7Q8) 
+	.quad       L(SSE8Q8),L(SSE9Q8),L(SSE10Q8),L(SSE11Q8),L(SSE12Q8),L(SSE13Q8),L(SSE14Q8),L(SSE15Q8) 
+	.quad       L(SSE0Q9),L(SSE1Q9),L(SSE2Q9), L(SSE3Q9), L(SSE4Q9), L(SSE5Q9), L(SSE6Q9), L(SSE7Q9) 
+	.quad       L(SSE8Q9),L(SSE9Q9),L(SSE10Q9),L(SSE11Q9),L(SSE12Q9),L(SSE13Q9),L(SSE14Q9),L(SSE15Q9) 
+	.quad       L(SSE0QA),L(SSE1QA),L(SSE2QA), L(SSE3QA), L(SSE4QA), L(SSE5QA), L(SSE6QA), L(SSE7QA) 
+	.quad       L(SSE8QA),L(SSE9QA),L(SSE10QA),L(SSE11QA),L(SSE12QA),L(SSE13QA),L(SSE14QA),L(SSE15QA) 
+	.quad       L(SSE0QB),L(SSE1QB),L(SSE2QB), L(SSE3QB), L(SSE4QB), L(SSE5QB), L(SSE6QB), L(SSE7QB) 
+	.quad       L(SSE8QB),L(SSE9QB),L(SSE10QB),L(SSE11QB),L(SSE12QB),L(SSE13QB),L(SSE14QB),L(SSE15QB) 
+#else
+L(SSExDx):
+	.int       L(SSE0Q0) -L(SSExDx)
+	.int       L(SSE1Q0) -L(SSExDx)
+	.int       L(SSE2Q0) -L(SSExDx)
+	.int       L(SSE3Q0) -L(SSExDx)
+	.int       L(SSE4Q0) -L(SSExDx)
+	.int       L(SSE5Q0) -L(SSExDx)
+	.int       L(SSE6Q0) -L(SSExDx)
+	.int       L(SSE7Q0) -L(SSExDx)
+
+	.int       L(SSE8Q0) -L(SSExDx)
+	.int       L(SSE9Q0) -L(SSExDx)
+	.int       L(SSE10Q0)-L(SSExDx)
+	.int       L(SSE11Q0)-L(SSExDx)
+	.int       L(SSE12Q0)-L(SSExDx)
+	.int       L(SSE13Q0)-L(SSExDx)
+	.int       L(SSE14Q0)-L(SSExDx)
+	.int       L(SSE15Q0)-L(SSExDx) 
+
+	.int       L(SSE0Q1) -L(SSExDx)
+	.int       L(SSE1Q1) -L(SSExDx)
+	.int       L(SSE2Q1) -L(SSExDx)
+	.int       L(SSE3Q1) -L(SSExDx)
+	.int       L(SSE4Q1) -L(SSExDx)
+	.int       L(SSE5Q1) -L(SSExDx)
+	.int       L(SSE6Q1) -L(SSExDx)
+	.int       L(SSE7Q1) -L(SSExDx)
+
+	.int       L(SSE8Q1) -L(SSExDx)
+	.int       L(SSE9Q1) -L(SSExDx)
+	.int       L(SSE10Q1)-L(SSExDx)
+	.int       L(SSE11Q1)-L(SSExDx)
+	.int       L(SSE12Q1)-L(SSExDx)
+	.int       L(SSE13Q1)-L(SSExDx)
+	.int       L(SSE14Q1)-L(SSExDx)
+	.int       L(SSE15Q1)-L(SSExDx) 
+
+	.int       L(SSE0Q2) -L(SSExDx)
+	.int       L(SSE1Q2) -L(SSExDx)
+	.int       L(SSE2Q2) -L(SSExDx)
+	.int       L(SSE3Q2) -L(SSExDx)
+	.int       L(SSE4Q2) -L(SSExDx)
+	.int       L(SSE5Q2) -L(SSExDx)
+	.int       L(SSE6Q2) -L(SSExDx)
+	.int       L(SSE7Q2) -L(SSExDx)
+
+	.int       L(SSE8Q2) -L(SSExDx)
+	.int       L(SSE9Q2) -L(SSExDx)
+	.int       L(SSE10Q2)-L(SSExDx)
+	.int       L(SSE11Q2)-L(SSExDx)
+	.int       L(SSE12Q2)-L(SSExDx)
+	.int       L(SSE13Q2)-L(SSExDx)
+	.int       L(SSE14Q2)-L(SSExDx)
+	.int       L(SSE15Q2)-L(SSExDx) 
+
+	.int       L(SSE0Q3) -L(SSExDx)
+	.int       L(SSE1Q3) -L(SSExDx)
+	.int       L(SSE2Q3) -L(SSExDx)
+	.int       L(SSE3Q3) -L(SSExDx)
+	.int       L(SSE4Q3) -L(SSExDx)
+	.int       L(SSE5Q3) -L(SSExDx)
+	.int       L(SSE6Q3) -L(SSExDx)
+	.int       L(SSE7Q3) -L(SSExDx)
+
+	.int       L(SSE8Q3) -L(SSExDx)
+	.int       L(SSE9Q3) -L(SSExDx)
+	.int       L(SSE10Q3)-L(SSExDx)
+	.int       L(SSE11Q3)-L(SSExDx)
+	.int       L(SSE12Q3)-L(SSExDx)
+	.int       L(SSE13Q3)-L(SSExDx)
+	.int       L(SSE14Q3)-L(SSExDx)
+	.int       L(SSE15Q3)-L(SSExDx) 
+
+	.int       L(SSE0Q4) -L(SSExDx)
+	.int       L(SSE1Q4) -L(SSExDx)
+	.int       L(SSE2Q4) -L(SSExDx)
+	.int       L(SSE3Q4) -L(SSExDx)
+	.int       L(SSE4Q4) -L(SSExDx)
+	.int       L(SSE5Q4) -L(SSExDx)
+	.int       L(SSE6Q4) -L(SSExDx)
+	.int       L(SSE7Q4) -L(SSExDx)
+
+	.int       L(SSE8Q4) -L(SSExDx)
+	.int       L(SSE9Q4) -L(SSExDx)
+	.int       L(SSE10Q4)-L(SSExDx)
+	.int       L(SSE11Q4)-L(SSExDx)
+	.int       L(SSE12Q4)-L(SSExDx)
+	.int       L(SSE13Q4)-L(SSExDx)
+	.int       L(SSE14Q4)-L(SSExDx)
+	.int       L(SSE15Q4)-L(SSExDx) 
+
+	.int       L(SSE0Q5) -L(SSExDx)
+	.int       L(SSE1Q5) -L(SSExDx)
+	.int       L(SSE2Q5) -L(SSExDx)
+	.int       L(SSE3Q5) -L(SSExDx)
+	.int       L(SSE4Q5) -L(SSExDx)
+	.int       L(SSE5Q5) -L(SSExDx)
+	.int       L(SSE6Q5) -L(SSExDx)
+	.int       L(SSE7Q5) -L(SSExDx)
+
+	.int       L(SSE8Q5) -L(SSExDx)
+	.int       L(SSE9Q5) -L(SSExDx)
+	.int       L(SSE10Q5)-L(SSExDx)
+	.int       L(SSE11Q5)-L(SSExDx)
+	.int       L(SSE12Q5)-L(SSExDx)
+	.int       L(SSE13Q5)-L(SSExDx)
+	.int       L(SSE14Q5)-L(SSExDx)
+	.int       L(SSE15Q5)-L(SSExDx) 
+
+	.int       L(SSE0Q6) -L(SSExDx)
+	.int       L(SSE1Q6) -L(SSExDx)
+	.int       L(SSE2Q6) -L(SSExDx)
+	.int       L(SSE3Q6) -L(SSExDx)
+	.int       L(SSE4Q6) -L(SSExDx)
+	.int       L(SSE5Q6) -L(SSExDx)
+	.int       L(SSE6Q6) -L(SSExDx)
+	.int       L(SSE7Q6) -L(SSExDx)
+
+	.int       L(SSE8Q6) -L(SSExDx)
+	.int       L(SSE9Q6) -L(SSExDx)
+	.int       L(SSE10Q6)-L(SSExDx)
+	.int       L(SSE11Q6)-L(SSExDx)
+	.int       L(SSE12Q6)-L(SSExDx)
+	.int       L(SSE13Q6)-L(SSExDx)
+	.int       L(SSE14Q6)-L(SSExDx)
+	.int       L(SSE15Q6)-L(SSExDx) 
+
+	.int       L(SSE0Q7) -L(SSExDx)
+	.int       L(SSE1Q7) -L(SSExDx)
+	.int       L(SSE2Q7) -L(SSExDx)
+	.int       L(SSE3Q7) -L(SSExDx)
+	.int       L(SSE4Q7) -L(SSExDx)
+	.int       L(SSE5Q7) -L(SSExDx)
+	.int       L(SSE6Q7) -L(SSExDx)
+	.int       L(SSE7Q7) -L(SSExDx)
+
+	.int       L(SSE8Q7) -L(SSExDx)
+	.int       L(SSE9Q7) -L(SSExDx)
+	.int       L(SSE10Q7)-L(SSExDx)
+	.int       L(SSE11Q7)-L(SSExDx)
+	.int       L(SSE12Q7)-L(SSExDx)
+	.int       L(SSE13Q7)-L(SSExDx)
+	.int       L(SSE14Q7)-L(SSExDx)
+	.int       L(SSE15Q7)-L(SSExDx) 
+
+	.int       L(SSE0Q8) -L(SSExDx)
+	.int       L(SSE1Q8) -L(SSExDx)
+	.int       L(SSE2Q8) -L(SSExDx)
+	.int       L(SSE3Q8) -L(SSExDx)
+	.int       L(SSE4Q8) -L(SSExDx)
+	.int       L(SSE5Q8) -L(SSExDx)
+	.int       L(SSE6Q8) -L(SSExDx)
+	.int       L(SSE7Q8) -L(SSExDx)
+
+	.int       L(SSE8Q8) -L(SSExDx)
+	.int       L(SSE9Q8) -L(SSExDx)
+	.int       L(SSE10Q8)-L(SSExDx)
+	.int       L(SSE11Q8)-L(SSExDx)
+	.int       L(SSE12Q8)-L(SSExDx)
+	.int       L(SSE13Q8)-L(SSExDx)
+	.int       L(SSE14Q8)-L(SSExDx)
+	.int       L(SSE15Q8)-L(SSExDx) 
+
+	.int       L(SSE0Q9) -L(SSExDx)
+	.int       L(SSE1Q9) -L(SSExDx)
+	.int       L(SSE2Q9) -L(SSExDx)
+	.int       L(SSE3Q9) -L(SSExDx)
+	.int       L(SSE4Q9) -L(SSExDx)
+	.int       L(SSE5Q9) -L(SSExDx)
+	.int       L(SSE6Q9) -L(SSExDx)
+	.int       L(SSE7Q9) -L(SSExDx)
+
+	.int       L(SSE8Q9) -L(SSExDx)
+	.int       L(SSE9Q9) -L(SSExDx)
+	.int       L(SSE10Q9)-L(SSExDx)
+	.int       L(SSE11Q9)-L(SSExDx)
+	.int       L(SSE12Q9)-L(SSExDx)
+	.int       L(SSE13Q9)-L(SSExDx)
+	.int       L(SSE14Q9)-L(SSExDx)
+	.int       L(SSE15Q9)-L(SSExDx) 
+
+	.int       L(SSE0QA) -L(SSExDx)
+	.int       L(SSE1QA) -L(SSExDx)
+	.int       L(SSE2QA) -L(SSExDx)
+	.int       L(SSE3QA) -L(SSExDx)
+	.int       L(SSE4QA) -L(SSExDx)
+	.int       L(SSE5QA) -L(SSExDx)
+	.int       L(SSE6QA) -L(SSExDx)
+	.int       L(SSE7QA) -L(SSExDx)
+
+	.int       L(SSE8QA) -L(SSExDx)
+	.int       L(SSE9QA) -L(SSExDx)
+	.int       L(SSE10QA)-L(SSExDx)
+	.int       L(SSE11QA)-L(SSExDx)
+	.int       L(SSE12QA)-L(SSExDx)
+	.int       L(SSE13QA)-L(SSExDx)
+	.int       L(SSE14QA)-L(SSExDx)
+	.int       L(SSE15QA)-L(SSExDx) 
+
+	.int       L(SSE0QB) -L(SSExDx)
+	.int       L(SSE1QB) -L(SSExDx)
+	.int       L(SSE2QB) -L(SSExDx)
+	.int       L(SSE3QB) -L(SSExDx)
+	.int       L(SSE4QB) -L(SSExDx)
+	.int       L(SSE5QB) -L(SSExDx)
+	.int       L(SSE6QB) -L(SSExDx)
+	.int       L(SSE7QB) -L(SSExDx)
+
+	.int       L(SSE8QB) -L(SSExDx)
+	.int       L(SSE9QB) -L(SSExDx)
+	.int       L(SSE10QB)-L(SSExDx)
+	.int       L(SSE11QB)-L(SSExDx)
+	.int       L(SSE12QB)-L(SSExDx)
+	.int       L(SSE13QB)-L(SSExDx)
+	.int       L(SSE14QB)-L(SSExDx)
+	.int       L(SSE15QB)-L(SSExDx) 
+#endif
+	POP_SECTION
+
+#if defined(NOT_IN_GLIBC)
+	.balign 16
+	.type _RTN_NM_,@function
+	.size _RTN_NM_,.-_RTN_NM_
+#else
 END (memset)
 #if !BZERO_P
 libc_hidden_builtin_def (memset)
@@ -144,3 +1282,4 @@ strong_alias (__memset_chk, __memset_zer
 	.section .gnu.warning.__memset_zero_constant_len_parameter
 	.string "memset used with constant zero length parameter; this could be due to transposed parameters"
 #endif
+#endif


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]