Whamcloud - gitweb
LU-6765 obdecho: don't copy lu_site
[fs/lustre-release.git] / libcfs / libcfs / linux / crc32-pclmul_asm.S
1 /* GPL HEADER START
2  *
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 only,
7  * as published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License version 2 for more details (a copy is included
13  * in the LICENSE file that accompanied this code).
14  *
15  * You should have received a copy of the GNU General Public License
16  * version 2 along with this program; If not, see http://www.gnu.org/licenses
17  *
18  * Please  visit http://www.xyratex.com/contact if you need additional
19  * information or have any questions.
20  *
21  * GPL HEADER END
22  */
23
24 /*
25  * Copyright 2012 Xyratex Technology Limited
26  *
27  * Using hardware provided PCLMULQDQ instruction to accelerate the CRC32
28  * calculation.
29  * CRC32 polynomial:0x04c11db7(BE)/0xEDB88320(LE)
30  * PCLMULQDQ is a new instruction in Intel SSE4.2, the reference can be found
31  * at:
32  * http://www.intel.com/products/processor/manuals/
33  * Intel(R) 64 and IA-32 Architectures Software Developer's Manual
34  * Volume 2B: Instruction Set Reference, N-Z
35  *
36  * Authors:     Gregory Prestas <Gregory_Prestas@us.xyratex.com>
37  *            Alexander Boyko <Alexander_Boyko@xyratex.com>
38  */
39
40 #define __ASSEMBLY__ 1
41 #include "inst.h"
42
43 .align 16
44 /*
45  * [x4*128+32 mod P(x) << 32)]'  << 1   = 0x154442bd4
46  * #define CONSTANT_R1  0x154442bd4LL
47  *
48  * [(x4*128-32 mod P(x) << 32)]' << 1   = 0x1c6e41596
49  * #define CONSTANT_R2  0x1c6e41596LL
50  */
51 .Lconstant_R2R1:
52         .octa 0x00000001c6e415960000000154442bd4
53 /*
54  * [(x128+32 mod P(x) << 32)]'   << 1   = 0x1751997d0
55  * #define CONSTANT_R3  0x1751997d0LL
56  *
57  * [(x128-32 mod P(x) << 32)]'   << 1   = 0x0ccaa009e
58  * #define CONSTANT_R4  0x0ccaa009eLL
59  */
60 .Lconstant_R4R3:
61         .octa 0x00000000ccaa009e00000001751997d0
62 /*
63  * [(x64 mod P(x) << 32)]'       << 1   = 0x163cd6124
64  * #define CONSTANT_R5  0x163cd6124LL
65  */
66 .Lconstant_R5:
67         .octa 0x00000000000000000000000163cd6124
68 .Lconstant_mask32:
69         .octa 0x000000000000000000000000FFFFFFFF
70 /*
71  * #define CRCPOLY_TRUE_LE_FULL 0x1DB710641LL
72  *
73  * Barrett Reduction constant (u64`) = u` = (x**64 / P(x))` = 0x1F7011641LL
74  * #define CONSTANT_RU  0x1F7011641LL
75  */
76 .Lconstant_RUpoly:
77         .octa 0x00000001F701164100000001DB710641
78
79 #define CONSTANT %xmm0
80
81 #ifdef __x86_64__
82 #define BUF     %rdi
83 #define LEN     %rsi
84 #define CRC     %edx
85 #else
86 #define BUF     %eax
87 #define LEN     %edx
88 #define CRC     %ecx
89 #endif
90
91 .text
92 /**
93  *      Calculate crc32
94  *      BUF - buffer (16 bytes aligned)
95  *      LEN - sizeof buffer (16 bytes aligned), LEN should be grater than 63
96  *      CRC - initial crc32
97  *      return %eax crc32
98  *      uint crc32_pclmul_le_16(unsigned char const *buffer,
99  *                           size_t len, uint crc32)
100  */
101 .globl crc32_pclmul_le_16
102 .align 4, 0x90
103 crc32_pclmul_le_16:/* buffer and buffer size are 16 bytes aligned */
104         movdqa  (BUF), %xmm1
105         movdqa  0x10(BUF), %xmm2
106         movdqa  0x20(BUF), %xmm3
107         movdqa  0x30(BUF), %xmm4
108         movd    CRC, CONSTANT
109         pxor    CONSTANT, %xmm1
110         sub     $0x40, LEN
111         add     $0x40, BUF
112 #ifndef __x86_64__
113         /* This is for position independed code(-fPIC) support for 32bit */
114         call    delta
115 delta:
116         pop     %ecx
117 #endif
118         cmp     $0x40, LEN
119         jb      less_64
120
121 #ifdef __x86_64__
122         movdqa .Lconstant_R2R1(%rip), CONSTANT
123 #else
124         movdqa .Lconstant_R2R1 - delta(%ecx), CONSTANT
125 #endif
126
127 loop_64:/*  64 bytes Full cache line folding */
128         prefetchnta    0x40(BUF)
129         movdqa  %xmm1, %xmm5
130         movdqa  %xmm2, %xmm6
131         movdqa  %xmm3, %xmm7
132 #ifdef __x86_64__
133         movdqa  %xmm4, %xmm8
134 #endif
135         PCLMULQDQ 00, CONSTANT, %xmm1
136         PCLMULQDQ 00, CONSTANT, %xmm2
137         PCLMULQDQ 00, CONSTANT, %xmm3
138 #ifdef __x86_64__
139         PCLMULQDQ 00, CONSTANT, %xmm4
140 #endif
141         PCLMULQDQ 0x11, CONSTANT, %xmm5
142         PCLMULQDQ 0x11, CONSTANT, %xmm6
143         PCLMULQDQ 0x11, CONSTANT, %xmm7
144 #ifdef __x86_64__
145         PCLMULQDQ 0x11, CONSTANT, %xmm8
146 #endif
147         pxor    %xmm5, %xmm1
148         pxor    %xmm6, %xmm2
149         pxor    %xmm7, %xmm3
150 #ifdef __x86_64__
151         pxor    %xmm8, %xmm4
152 #else
153         /* xmm8 unsupported for x32 */
154         movdqa  %xmm4, %xmm5
155         PCLMULQDQ 00, CONSTANT, %xmm4
156         PCLMULQDQ 0x11, CONSTANT, %xmm5
157         pxor    %xmm5, %xmm4
158 #endif
159
160         pxor    (BUF), %xmm1
161         pxor    0x10(BUF), %xmm2
162         pxor    0x20(BUF), %xmm3
163         pxor    0x30(BUF), %xmm4
164
165         sub     $0x40, LEN
166         add     $0x40, BUF
167         cmp     $0x40, LEN
168         jge     loop_64
169 less_64:/*  Folding cache line into 128bit */
170 #ifdef __x86_64__
171         movdqa  .Lconstant_R4R3(%rip), CONSTANT
172 #else
173         movdqa  .Lconstant_R4R3 - delta(%ecx), CONSTANT
174 #endif
175         prefetchnta     (BUF)
176
177         movdqa  %xmm1, %xmm5
178         PCLMULQDQ 0x00, CONSTANT, %xmm1
179         PCLMULQDQ 0x11, CONSTANT, %xmm5
180         pxor    %xmm5, %xmm1
181         pxor    %xmm2, %xmm1
182
183         movdqa  %xmm1, %xmm5
184         PCLMULQDQ 0x00, CONSTANT, %xmm1
185         PCLMULQDQ 0x11, CONSTANT, %xmm5
186         pxor    %xmm5, %xmm1
187         pxor    %xmm3, %xmm1
188
189         movdqa  %xmm1, %xmm5
190         PCLMULQDQ 0x00, CONSTANT, %xmm1
191         PCLMULQDQ 0x11, CONSTANT, %xmm5
192         pxor    %xmm5, %xmm1
193         pxor    %xmm4, %xmm1
194
195         cmp     $0x10, LEN
196         jb      fold_64
197 loop_16:/* Folding rest buffer into 128bit */
198         movdqa  %xmm1, %xmm5
199         PCLMULQDQ 0x00, CONSTANT, %xmm1
200         PCLMULQDQ 0x11, CONSTANT, %xmm5
201         pxor    %xmm5, %xmm1
202         pxor    (BUF), %xmm1
203         sub     $0x10, LEN
204         add     $0x10, BUF
205         cmp     $0x10, LEN
206         jge     loop_16
207
208 fold_64:
209         /* perform the last 64 bit fold, also adds 32 zeroes
210          * to the input stream */
211         PCLMULQDQ 0x01, %xmm1, CONSTANT /* R4 * xmm1.low */
212         psrldq  $0x08, %xmm1
213         pxor    CONSTANT, %xmm1
214
215         /* final 32-bit fold */
216         movdqa  %xmm1, %xmm2
217 #ifdef __x86_64__
218         movdqa  .Lconstant_R5(%rip), CONSTANT
219         movdqa  .Lconstant_mask32(%rip), %xmm3
220 #else
221         movdqa  .Lconstant_R5 - delta(%ecx), CONSTANT
222         movdqa  .Lconstant_mask32 - delta(%ecx), %xmm3
223 #endif
224         psrldq  $0x04, %xmm2
225         pand    %xmm3, %xmm1
226         PCLMULQDQ 0x00, CONSTANT, %xmm1
227         pxor    %xmm2, %xmm1
228
229         /* Finish up with the bit-reversed barrett reduction 64 ==> 32 bits */
230 #ifdef __x86_64__
231         movdqa  .Lconstant_RUpoly(%rip), CONSTANT
232 #else
233         movdqa  .Lconstant_RUpoly - delta(%ecx), CONSTANT
234 #endif
235         movdqa  %xmm1, %xmm2
236         pand    %xmm3, %xmm1
237         PCLMULQDQ 0x10, CONSTANT, %xmm1
238         pand    %xmm3, %xmm1
239         PCLMULQDQ 0x00, CONSTANT, %xmm1
240         pxor    %xmm2, %xmm1
241         PEXTRD  0x01, %xmm1, %eax
242
243         ret