libcfs/libcfs/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 /* gcc 4.1.2 does not support pclmulqdq instruction
  41  * Use macro defenition from linux kernel 2.6.38  */
  42
  43 #define REG_NUM_INVALID 100
  44         .macro R32_NUM opd r32
  45         \opd = REG_NUM_INVALID
  46         .ifc \r32,%eax
  47         \opd = 0
  48         .endif
  49         .ifc \r32,%ecx
  50         \opd = 1
  51         .endif
  52         .ifc \r32,%edx
  53         \opd = 2
  54         .endif
  55         .ifc \r32,%ebx
  56         \opd = 3
  57         .endif
  58         .ifc \r32,%esp
  59         \opd = 4
  60         .endif
  61         .ifc \r32,%ebp
  62         \opd = 5
  63         .endif
  64         .ifc \r32,%esi
  65         \opd = 6
  66         .endif
  67         .ifc \r32,%edi
  68         \opd = 7
  69         .endif
  70         .endm
  71
  72         .macro XMM_NUM opd xmm
  73         \opd = REG_NUM_INVALID
  74         .ifc \xmm,%xmm0
  75         \opd = 0
  76         .endif
  77         .ifc \xmm,%xmm1
  78         \opd = 1
  79         .endif
  80         .ifc \xmm,%xmm2
  81         \opd = 2
  82         .endif
  83         .ifc \xmm,%xmm3
  84         \opd = 3
  85         .endif
  86         .ifc \xmm,%xmm4
  87         \opd = 4
  88         .endif
  89         .ifc \xmm,%xmm5
  90         \opd = 5
  91         .endif
  92         .ifc \xmm,%xmm6
  93         \opd = 6
  94         .endif
  95         .ifc \xmm,%xmm7
  96         \opd = 7
  97         .endif
  98         .ifc \xmm,%xmm8
  99         \opd = 8
 100         .endif
 101         .ifc \xmm,%xmm9
 102         \opd = 9
 103         .endif
 104         .ifc \xmm,%xmm10
 105         \opd = 10
 106         .endif
 107         .ifc \xmm,%xmm11
 108         \opd = 11
 109         .endif
 110         .ifc \xmm,%xmm12
 111         \opd = 12
 112         .endif
 113         .ifc \xmm,%xmm13
 114         \opd = 13
 115         .endif
 116         .ifc \xmm,%xmm14
 117         \opd = 14
 118         .endif
 119         .ifc \xmm,%xmm15
 120         \opd = 15
 121         .endif
 122         .endm
 123
 124         .macro PFX_OPD_SIZE
 125         .byte 0x66
 126         .endm
 127
 128         .macro PFX_REX opd1 opd2 W=0
 129         .if ((\opd1 | \opd2) & 8) || \W
 130         .byte 0x40 | ((\opd1 & 8) >> 3) | ((\opd2 & 8) >> 1) | (\W << 3)
 131         .endif
 132         .endm
 133
 134         .macro MODRM mod opd1 opd2
 135         .byte \mod | (\opd1 & 7) | ((\opd2 & 7) << 3)
 136         .endm
 137
 138         .macro PCLMULQDQ imm8 xmm1 xmm2
 139         XMM_NUM clmul_opd1 \xmm1
 140         XMM_NUM clmul_opd2 \xmm2
 141         PFX_OPD_SIZE
 142         PFX_REX clmul_opd1 clmul_opd2
 143         .byte 0x0f, 0x3a, 0x44
 144         MODRM 0xc0 clmul_opd1 clmul_opd2
 145         .byte \imm8
 146         .endm
 147
 148         .macro PEXTRD imm8 xmm1 reg1
 149         XMM_NUM extrd_opd2 \xmm1
 150         R32_NUM extrd_opd1 \reg1
 151         PFX_OPD_SIZE
 152         PFX_REX extrd_opd1 extrd_opd2
 153         .byte 0x0f, 0x3a, 0x16
 154         MODRM 0xc0 extrd_opd1 extrd_opd2
 155         .byte \imm8
 156         .endm
 157
 158 .align 16
 159 /*
 160  * [x4*128+32 mod P(x) << 32)]'  << 1   = 0x154442bd4
 161  * #define CONSTANT_R1  0x154442bd4LL
 162  *
 163  * [(x4*128-32 mod P(x) << 32)]' << 1   = 0x1c6e41596
 164  * #define CONSTANT_R2  0x1c6e41596LL
 165  */
 166 .Lconstant_R2R1:
 167         .octa 0x00000001c6e415960000000154442bd4
 168 /*
 169  * [(x128+32 mod P(x) << 32)]'   << 1   = 0x1751997d0
 170  * #define CONSTANT_R3  0x1751997d0LL
 171  *
 172  * [(x128-32 mod P(x) << 32)]'   << 1   = 0x0ccaa009e
 173  * #define CONSTANT_R4  0x0ccaa009eLL
 174  */
 175 .Lconstant_R4R3:
 176         .octa 0x00000000ccaa009e00000001751997d0
 177 /*
 178  * [(x64 mod P(x) << 32)]'       << 1   = 0x163cd6124
 179  * #define CONSTANT_R5  0x163cd6124LL
 180  */
 181 .Lconstant_R5:
 182         .octa 0x00000000000000000000000163cd6124
 183 .Lconstant_mask32:
 184         .octa 0x000000000000000000000000FFFFFFFF
 185 /*
 186  * #define CRCPOLY_TRUE_LE_FULL 0x1DB710641LL
 187  *
 188  * Barrett Reduction constant (u64`) = u` = (x**64 / P(x))` = 0x1F7011641LL
 189  * #define CONSTANT_RU  0x1F7011641LL
 190  */
 191 .Lconstant_RUpoly:
 192         .octa 0x00000001F701164100000001DB710641
 193
 194 #define CONSTANT %xmm0
 195
 196 #ifdef __x86_64__
 197 #define BUF     %rdi
 198 #define LEN     %rsi
 199 #define CRC     %edx
 200 #else
 201 #define BUF     %eax
 202 #define LEN     %edx
 203 #define CRC     %ecx
 204 #endif
 205
 206
 207
 208 .text
 209 /**
 210  *      Calculate crc32
 211  *      BUF - buffer (16 bytes aligned)
 212  *      LEN - sizeof buffer (16 bytes aligned), LEN should be grater than 63
 213  *      CRC - initial crc32
 214  *      return %eax crc32
 215  *      uint crc32_pclmul_le_16(unsigned char const *buffer,
 216  *                           size_t len, uint crc32)
 217  */
 218 .globl crc32_pclmul_le_16
 219 .align 4, 0x90
 220 crc32_pclmul_le_16:/* buffer and buffer size are 16 bytes aligned */
 221         movdqa  (BUF), %xmm1
 222         movdqa  0x10(BUF), %xmm2
 223         movdqa  0x20(BUF), %xmm3
 224         movdqa  0x30(BUF), %xmm4
 225         movd    CRC, CONSTANT
 226         pxor    CONSTANT, %xmm1
 227         sub     $0x40, LEN
 228         add     $0x40, BUF
 229 #ifndef __x86_64__
 230         /* This is for position independed code(-fPIC) support for 32bit */
 231         call    delta
 232 delta:
 233         pop     %ecx
 234 #endif
 235         cmp     $0x40, LEN
 236         jb      less_64
 237
 238 #ifdef __x86_64__
 239         movdqa .Lconstant_R2R1(%rip), CONSTANT
 240 #else
 241         movdqa .Lconstant_R2R1 - delta(%ecx), CONSTANT
 242 #endif
 243
 244 loop_64:/*  64 bytes Full cache line folding */
 245         prefetchnta    0x40(BUF)
 246         movdqa  %xmm1, %xmm5
 247         movdqa  %xmm2, %xmm6
 248         movdqa  %xmm3, %xmm7
 249 #ifdef __x86_64__
 250         movdqa  %xmm4, %xmm8
 251 #endif
 252         PCLMULQDQ 00, CONSTANT, %xmm1
 253         PCLMULQDQ 00, CONSTANT, %xmm2
 254         PCLMULQDQ 00, CONSTANT, %xmm3
 255 #ifdef __x86_64__
 256         PCLMULQDQ 00, CONSTANT, %xmm4
 257 #endif
 258         PCLMULQDQ 0x11, CONSTANT, %xmm5
 259         PCLMULQDQ 0x11, CONSTANT, %xmm6
 260         PCLMULQDQ 0x11, CONSTANT, %xmm7
 261 #ifdef __x86_64__
 262         PCLMULQDQ 0x11, CONSTANT, %xmm8
 263 #endif
 264         pxor    %xmm5, %xmm1
 265         pxor    %xmm6, %xmm2
 266         pxor    %xmm7, %xmm3
 267 #ifdef __x86_64__
 268         pxor    %xmm8, %xmm4
 269 #else
 270         /* xmm8 unsupported for x32 */
 271         movdqa  %xmm4, %xmm5
 272         PCLMULQDQ 00, CONSTANT, %xmm4
 273         PCLMULQDQ 0x11, CONSTANT, %xmm5
 274         pxor    %xmm5, %xmm4
 275 #endif
 276
 277         pxor    (BUF), %xmm1
 278         pxor    0x10(BUF), %xmm2
 279         pxor    0x20(BUF), %xmm3
 280         pxor    0x30(BUF), %xmm4
 281
 282         sub     $0x40, LEN
 283         add     $0x40, BUF
 284         cmp     $0x40, LEN
 285         jge     loop_64
 286 less_64:/*  Folding cache line into 128bit */
 287 #ifdef __x86_64__
 288         movdqa  .Lconstant_R4R3(%rip), CONSTANT
 289 #else
 290         movdqa  .Lconstant_R4R3 - delta(%ecx), CONSTANT
 291 #endif
 292         prefetchnta     (BUF)
 293
 294         movdqa  %xmm1, %xmm5
 295         PCLMULQDQ 0x00, CONSTANT, %xmm1
 296         PCLMULQDQ 0x11, CONSTANT, %xmm5
 297         pxor    %xmm5, %xmm1
 298         pxor    %xmm2, %xmm1
 299
 300         movdqa  %xmm1, %xmm5
 301         PCLMULQDQ 0x00, CONSTANT, %xmm1
 302         PCLMULQDQ 0x11, CONSTANT, %xmm5
 303         pxor    %xmm5, %xmm1
 304         pxor    %xmm3, %xmm1
 305
 306         movdqa  %xmm1, %xmm5
 307         PCLMULQDQ 0x00, CONSTANT, %xmm1
 308         PCLMULQDQ 0x11, CONSTANT, %xmm5
 309         pxor    %xmm5, %xmm1
 310         pxor    %xmm4, %xmm1
 311
 312         cmp     $0x10, LEN
 313         jb      fold_64
 314 loop_16:/* Folding rest buffer into 128bit */
 315         movdqa  %xmm1, %xmm5
 316         PCLMULQDQ 0x00, CONSTANT, %xmm1
 317         PCLMULQDQ 0x11, CONSTANT, %xmm5
 318         pxor    %xmm5, %xmm1
 319         pxor    (BUF), %xmm1
 320         sub     $0x10, LEN
 321         add     $0x10, BUF
 322         cmp     $0x10, LEN
 323         jge     loop_16
 324
 325 fold_64:
 326         /* perform the last 64 bit fold, also adds 32 zeroes
 327          * to the input stream */
 328         PCLMULQDQ 0x01, %xmm1, CONSTANT /* R4 * xmm1.low */
 329         psrldq  $0x08, %xmm1
 330         pxor    CONSTANT, %xmm1
 331
 332         /* final 32-bit fold */
 333         movdqa  %xmm1, %xmm2
 334 #ifdef __x86_64__
 335         movdqa  .Lconstant_R5(%rip), CONSTANT
 336         movdqa  .Lconstant_mask32(%rip), %xmm3
 337 #else
 338         movdqa  .Lconstant_R5 - delta(%ecx), CONSTANT
 339         movdqa  .Lconstant_mask32 - delta(%ecx), %xmm3
 340 #endif
 341         psrldq  $0x04, %xmm2
 342         pand    %xmm3, %xmm1
 343         PCLMULQDQ 0x00, CONSTANT, %xmm1
 344         pxor    %xmm2, %xmm1
 345
 346         /* Finish up with the bit-reversed barrett reduction 64 ==> 32 bits */
 347 #ifdef __x86_64__
 348         movdqa  .Lconstant_RUpoly(%rip), CONSTANT
 349 #else
 350         movdqa  .Lconstant_RUpoly - delta(%ecx), CONSTANT
 351 #endif
 352         movdqa  %xmm1, %xmm2
 353         pand    %xmm3, %xmm1
 354         PCLMULQDQ 0x10, CONSTANT, %xmm1
 355         pand    %xmm3, %xmm1
 356         PCLMULQDQ 0x00, CONSTANT, %xmm1
 357         pxor    %xmm2, %xmm1
 358         PEXTRD  0x01, %xmm1, %eax
 359
 360         ret