perf, x86: Add INSTRUCTION_DECODER config flag
[linux-3.10.git] / arch / x86 / lib / csum-copy_64.S
1 /*
2  * Copyright 2002,2003 Andi Kleen, SuSE Labs.
3  *      
4  * This file is subject to the terms and conditions of the GNU General Public
5  * License.  See the file COPYING in the main directory of this archive
6  * for more details. No warranty for anything given at all.
7  */
8 #include <linux/linkage.h>
9 #include <asm/dwarf2.h>
10 #include <asm/errno.h>
11
12 /*
13  * Checksum copy with exception handling.
14  * On exceptions src_err_ptr or dst_err_ptr is set to -EFAULT and the 
15  * destination is zeroed.
16  * 
17  * Input
18  * rdi  source
19  * rsi  destination
20  * edx  len (32bit)
21  * ecx  sum (32bit) 
22  * r8   src_err_ptr (int)
23  * r9   dst_err_ptr (int)
24  *
25  * Output
26  * eax  64bit sum. undefined in case of exception.
27  * 
28  * Wrappers need to take care of valid exception sum and zeroing.                
29  * They also should align source or destination to 8 bytes.
30  */
31
32         .macro source
33 10:
34         .section __ex_table,"a"
35         .align 8
36         .quad 10b,.Lbad_source
37         .previous
38         .endm
39                 
40         .macro dest
41 20:
42         .section __ex_table,"a"
43         .align 8
44         .quad 20b,.Lbad_dest
45         .previous
46         .endm
47                         
48         .macro ignore L=.Lignore
49 30:
50         .section __ex_table,"a"
51         .align 8
52         .quad 30b,\L
53         .previous
54         .endm
55         
56                                 
57 ENTRY(csum_partial_copy_generic)
58         CFI_STARTPROC
59         cmpl     $3*64,%edx
60         jle      .Lignore
61
62 .Lignore:               
63         subq  $7*8,%rsp
64         CFI_ADJUST_CFA_OFFSET 7*8
65         movq  %rbx,2*8(%rsp)
66         CFI_REL_OFFSET rbx, 2*8
67         movq  %r12,3*8(%rsp)
68         CFI_REL_OFFSET r12, 3*8
69         movq  %r14,4*8(%rsp)
70         CFI_REL_OFFSET r14, 4*8
71         movq  %r13,5*8(%rsp)
72         CFI_REL_OFFSET r13, 5*8
73         movq  %rbp,6*8(%rsp)
74         CFI_REL_OFFSET rbp, 6*8
75
76         movq  %r8,(%rsp)
77         movq  %r9,1*8(%rsp)
78         
79         movl  %ecx,%eax
80         movl  %edx,%ecx
81
82         xorl  %r9d,%r9d
83         movq  %rcx,%r12
84
85         shrq  $6,%r12
86         jz    .Lhandle_tail       /* < 64 */
87
88         clc
89         
90         /* main loop. clear in 64 byte blocks */
91         /* r9: zero, r8: temp2, rbx: temp1, rax: sum, rcx: saved length */
92         /* r11: temp3, rdx: temp4, r12 loopcnt */
93         /* r10: temp5, rbp: temp6, r14 temp7, r13 temp8 */
94         .p2align 4
95 .Lloop:
96         source
97         movq  (%rdi),%rbx
98         source
99         movq  8(%rdi),%r8
100         source
101         movq  16(%rdi),%r11
102         source
103         movq  24(%rdi),%rdx
104
105         source
106         movq  32(%rdi),%r10
107         source
108         movq  40(%rdi),%rbp
109         source
110         movq  48(%rdi),%r14
111         source
112         movq  56(%rdi),%r13
113                 
114         ignore 2f
115         prefetcht0 5*64(%rdi)
116 2:                                                      
117         adcq  %rbx,%rax
118         adcq  %r8,%rax
119         adcq  %r11,%rax
120         adcq  %rdx,%rax
121         adcq  %r10,%rax
122         adcq  %rbp,%rax
123         adcq  %r14,%rax
124         adcq  %r13,%rax
125
126         decl %r12d
127         
128         dest
129         movq %rbx,(%rsi)
130         dest
131         movq %r8,8(%rsi)
132         dest
133         movq %r11,16(%rsi)
134         dest
135         movq %rdx,24(%rsi)
136
137         dest
138         movq %r10,32(%rsi)
139         dest
140         movq %rbp,40(%rsi)
141         dest
142         movq %r14,48(%rsi)
143         dest
144         movq %r13,56(%rsi)
145         
146 3:
147         
148         leaq 64(%rdi),%rdi
149         leaq 64(%rsi),%rsi
150
151         jnz   .Lloop
152
153         adcq  %r9,%rax
154
155         /* do last upto 56 bytes */
156 .Lhandle_tail:
157         /* ecx: count */
158         movl %ecx,%r10d
159         andl $63,%ecx
160         shrl $3,%ecx
161         jz       .Lfold
162         clc
163         .p2align 4
164 .Lloop_8:       
165         source
166         movq (%rdi),%rbx
167         adcq %rbx,%rax
168         decl %ecx
169         dest
170         movq %rbx,(%rsi)
171         leaq 8(%rsi),%rsi /* preserve carry */
172         leaq 8(%rdi),%rdi
173         jnz     .Lloop_8
174         adcq %r9,%rax   /* add in carry */
175
176 .Lfold:
177         /* reduce checksum to 32bits */
178         movl %eax,%ebx
179         shrq $32,%rax
180         addl %ebx,%eax
181         adcl %r9d,%eax
182
183         /* do last upto 6 bytes */      
184 .Lhandle_7:
185         movl %r10d,%ecx
186         andl $7,%ecx
187         shrl $1,%ecx
188         jz   .Lhandle_1
189         movl $2,%edx
190         xorl %ebx,%ebx
191         clc  
192         .p2align 4
193 .Lloop_1:       
194         source
195         movw (%rdi),%bx
196         adcl %ebx,%eax
197         decl %ecx
198         dest
199         movw %bx,(%rsi)
200         leaq 2(%rdi),%rdi
201         leaq 2(%rsi),%rsi
202         jnz .Lloop_1
203         adcl %r9d,%eax  /* add in carry */
204         
205         /* handle last odd byte */
206 .Lhandle_1:
207         testl $1,%r10d
208         jz    .Lende
209         xorl  %ebx,%ebx
210         source
211         movb (%rdi),%bl
212         dest
213         movb %bl,(%rsi)
214         addl %ebx,%eax
215         adcl %r9d,%eax          /* carry */
216                         
217         CFI_REMEMBER_STATE
218 .Lende:
219         movq 2*8(%rsp),%rbx
220         CFI_RESTORE rbx
221         movq 3*8(%rsp),%r12
222         CFI_RESTORE r12
223         movq 4*8(%rsp),%r14
224         CFI_RESTORE r14
225         movq 5*8(%rsp),%r13
226         CFI_RESTORE r13
227         movq 6*8(%rsp),%rbp
228         CFI_RESTORE rbp
229         addq $7*8,%rsp
230         CFI_ADJUST_CFA_OFFSET -7*8
231         ret
232         CFI_RESTORE_STATE
233
234         /* Exception handlers. Very simple, zeroing is done in the wrappers */
235 .Lbad_source:
236         movq (%rsp),%rax
237         testq %rax,%rax
238         jz   .Lende
239         movl $-EFAULT,(%rax)
240         jmp  .Lende
241         
242 .Lbad_dest:
243         movq 8(%rsp),%rax
244         testq %rax,%rax
245         jz   .Lende     
246         movl $-EFAULT,(%rax)
247         jmp .Lende
248         CFI_ENDPROC
249 ENDPROC(csum_partial_copy_generic)