Quelle  chacha-neon-core.S   Sprache: Sparc

/*
 * ChaCha/HChaCha NEON helper functions
 *
 * Copyright (C) 2016 Linaro, Ltd. <ard.biesheuvel@linaro.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Based on:
 * ChaCha20 256-bit cipher algorithm, RFC7539, x64 SSE3 functions
 *
 * Copyright (C) 2015 Martin Willi
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

 /*
  * NEON doesn't have a rotate instruction.  The alternatives are, more or less:
  *
  * (a)  vshl.u32 + vsri.u32 (needs temporary register)
  * (b)  vshl.u32 + vshr.u32 + vorr (needs temporary register)
  * (c)  vrev32.16 (16-bit rotations only)
  * (d)  vtbl.8 + vtbl.8 (multiple of 8 bits rotations only,
  *  needs index vector)
  *
  * ChaCha has 16, 12, 8, and 7-bit rotations.  For the 12 and 7-bit rotations,
  * the only choices are (a) and (b).  We use (a) since it takes two-thirds the
  * cycles of (b) on both Cortex-A7 and Cortex-A53.
  *
  * For the 16-bit rotation, we use vrev32.16 since it's consistently fastest
  * and doesn't need a temporary register.
  *
  * For the 8-bit rotation, we use vtbl.8 + vtbl.8.  On Cortex-A7, this sequence
  * is twice as fast as (a), even when doing (a) on multiple registers
  * simultaneously to eliminate the stall between vshl and vsri.  Also, it
  * parallelizes better when temporary registers are scarce.
  *
  * A disadvantage is that on Cortex-A53, the vtbl sequence is the same speed as
  * (a), so the need to load the rotation table actually makes the vtbl method
  * slightly slower overall on that CPU (~1.3% slower ChaCha20).  Still, it
  * seems to be a good compromise to get a more significant speed boost on some
  * CPUs, e.g. ~4.8% faster ChaCha20 on Cortex-A7.
  */

#include <linux/linkage.h>
#include <asm/cache.h>

 .text
 .fpu  neon
 .align  5

/*
 * chacha_permute - permute one block
 *
 * Permute one 64-byte block where the state matrix is stored in the four NEON
 * registers q0-q3.  It performs matrix operations on four words in parallel,
 * but requires shuffling to rearrange the words after each round.
 *
 * The round count is given in r3.
 *
 * Clobbers: r3, ip, q4-q5
 */
chacha_permute:

 adr  ip, .Lrol8_table
 vld1.8  {d10}, [ip, :64]

.Ldoubleround:
 // x0 += x1, x3 = rotl32(x3 ^ x0, 16)
 vadd.i32 q0, q0, q1
 veor  q3, q3, q0
 vrev32.16 q3, q3

 // x2 += x3, x1 = rotl32(x1 ^ x2, 12)
 vadd.i32 q2, q2, q3
 veor  q4, q1, q2
 vshl.u32 q1, q4, #12
 vsri.u32 q1, q4, #20

 // x0 += x1, x3 = rotl32(x3 ^ x0, 8)
 vadd.i32 q0, q0, q1
 veor  q3, q3, q0
 vtbl.8  d6, {d6}, d10
 vtbl.8  d7, {d7}, d10

 // x2 += x3, x1 = rotl32(x1 ^ x2, 7)
 vadd.i32 q2, q2, q3
 veor  q4, q1, q2
 vshl.u32 q1, q4, #7
 vsri.u32 q1, q4, #25

 // x1 = shuffle32(x1, MASK(0, 3, 2, 1))
 vext.8  q1, q1, q1, #4
 // x2 = shuffle32(x2, MASK(1, 0, 3, 2))
 vext.8  q2, q2, q2, #8
 // x3 = shuffle32(x3, MASK(2, 1, 0, 3))
 vext.8  q3, q3, q3, #12

 // x0 += x1, x3 = rotl32(x3 ^ x0, 16)
 vadd.i32 q0, q0, q1
 veor  q3, q3, q0
 vrev32.16 q3, q3

 // x2 += x3, x1 = rotl32(x1 ^ x2, 12)
 vadd.i32 q2, q2, q3
 veor  q4, q1, q2
 vshl.u32 q1, q4, #12
 vsri.u32 q1, q4, #20

 // x0 += x1, x3 = rotl32(x3 ^ x0, 8)
 vadd.i32 q0, q0, q1
 veor  q3, q3, q0
 vtbl.8  d6, {d6}, d10
 vtbl.8  d7, {d7}, d10

 // x2 += x3, x1 = rotl32(x1 ^ x2, 7)
 vadd.i32 q2, q2, q3
 veor  q4, q1, q2
 vshl.u32 q1, q4, #7
 vsri.u32 q1, q4, #25

 // x1 = shuffle32(x1, MASK(2, 1, 0, 3))
 vext.8  q1, q1, q1, #12
 // x2 = shuffle32(x2, MASK(1, 0, 3, 2))
 vext.8  q2, q2, q2, #8
 // x3 = shuffle32(x3, MASK(0, 3, 2, 1))
 vext.8  q3, q3, q3, #4

 subs  r3, r3, #2
 bne  .Ldoubleround

 bx  lr
ENDPROC(chacha_permute)

ENTRY(chacha_block_xor_neon)
 // r0: Input state matrix, s
 // r1: 1 data block output, o
 // r2: 1 data block input, i
 // r3: nrounds
 push  {lr}

 // x0..3 = s0..3
 add  ip, r0, #0x20
 vld1.32  {q0-q1}, [r0]
 vld1.32  {q2-q3}, [ip]

 vmov  q8, q0
 vmov  q9, q1
 vmov  q10, q2
 vmov  q11, q3

 bl  chacha_permute

 add  ip, r2, #0x20
 vld1.8  {q4-q5}, [r2]
 vld1.8  {q6-q7}, [ip]

 // o0 = i0 ^ (x0 + s0)
 vadd.i32 q0, q0, q8
 veor  q0, q0, q4

 // o1 = i1 ^ (x1 + s1)
 vadd.i32 q1, q1, q9
 veor  q1, q1, q5

 // o2 = i2 ^ (x2 + s2)
 vadd.i32 q2, q2, q10
 veor  q2, q2, q6

 // o3 = i3 ^ (x3 + s3)
 vadd.i32 q3, q3, q11
 veor  q3, q3, q7

 add  ip, r1, #0x20
 vst1.8  {q0-q1}, [r1]
 vst1.8  {q2-q3}, [ip]

 pop  {pc}
ENDPROC(chacha_block_xor_neon)

ENTRY(hchacha_block_neon)
 // r0: Input state matrix, s
 // r1: output (8 32-bit words)
 // r2: nrounds
 push  {lr}

 vld1.32  {q0-q1}, [r0]!
 vld1.32  {q2-q3}, [r0]

 mov  r3, r2
 bl  chacha_permute

 vst1.32  {q0}, [r1]!
 vst1.32  {q3}, [r1]

 pop  {pc}
ENDPROC(hchacha_block_neon)

 .align  4
.Lctrinc: .word 0, 1, 2, 3
.Lrol8_table: .byte 3, 0, 1, 2, 7, 4, 5, 6

 .align  5
ENTRY(chacha_4block_xor_neon)
 push  {r4, lr}
 mov  r4, sp   // preserve the stack pointer
 sub  ip, sp, #0x20  // allocate a 32 byte buffer
 bic  ip, ip, #0x1f  // aligned to 32 bytes
 mov  sp, ip

 // r0: Input state matrix, s
 // r1: 4 data blocks output, o
 // r2: 4 data blocks input, i
 // r3: nrounds

 //
 // This function encrypts four consecutive ChaCha blocks by loading
 // the state matrix in NEON registers four times. The algorithm performs
 // each operation on the corresponding word of each state matrix, hence
 // requires no word shuffling. The words are re-interleaved before the
 // final addition of the original state and the XORing step.
 //

 // x0..15[0-3] = s0..15[0-3]
 add  ip, r0, #0x20
 vld1.32  {q0-q1}, [r0]
 vld1.32  {q2-q3}, [ip]

 adr  lr, .Lctrinc
 vdup.32  q15, d7[1]
 vdup.32  q14, d7[0]
 vld1.32  {q4}, [lr, :128]
 vdup.32  q13, d6[1]
 vdup.32  q12, d6[0]
 vdup.32  q11, d5[1]
 vdup.32  q10, d5[0]
 vadd.u32 q12, q12, q4  // x12 += counter values 0-3
 vdup.32  q9, d4[1]
 vdup.32  q8, d4[0]
 vdup.32  q7, d3[1]
 vdup.32  q6, d3[0]
 vdup.32  q5, d2[1]
 vdup.32  q4, d2[0]
 vdup.32  q3, d1[1]
 vdup.32  q2, d1[0]
 vdup.32  q1, d0[1]
 vdup.32  q0, d0[0]

 adr  ip, .Lrol8_table
 b  1f

.Ldoubleround4:
 vld1.32  {q8-q9}, [sp, :256]
1:
 // x0 += x4, x12 = rotl32(x12 ^ x0, 16)
 // x1 += x5, x13 = rotl32(x13 ^ x1, 16)
 // x2 += x6, x14 = rotl32(x14 ^ x2, 16)
 // x3 += x7, x15 = rotl32(x15 ^ x3, 16)
 vadd.i32 q0, q0, q4
 vadd.i32 q1, q1, q5
 vadd.i32 q2, q2, q6
 vadd.i32 q3, q3, q7

 veor  q12, q12, q0
 veor  q13, q13, q1
 veor  q14, q14, q2
 veor  q15, q15, q3

 vrev32.16 q12, q12
 vrev32.16 q13, q13
 vrev32.16 q14, q14
 vrev32.16 q15, q15

 // x8 += x12, x4 = rotl32(x4 ^ x8, 12)
 // x9 += x13, x5 = rotl32(x5 ^ x9, 12)
 // x10 += x14, x6 = rotl32(x6 ^ x10, 12)
 // x11 += x15, x7 = rotl32(x7 ^ x11, 12)
 vadd.i32 q8, q8, q12
 vadd.i32 q9, q9, q13
 vadd.i32 q10, q10, q14
 vadd.i32 q11, q11, q15

 vst1.32  {q8-q9}, [sp, :256]

 veor  q8, q4, q8
 veor  q9, q5, q9
 vshl.u32 q4, q8, #12
 vshl.u32 q5, q9, #12
 vsri.u32 q4, q8, #20
 vsri.u32 q5, q9, #20

 veor  q8, q6, q10
 veor  q9, q7, q11
 vshl.u32 q6, q8, #12
 vshl.u32 q7, q9, #12
 vsri.u32 q6, q8, #20
 vsri.u32 q7, q9, #20

 // x0 += x4, x12 = rotl32(x12 ^ x0, 8)
 // x1 += x5, x13 = rotl32(x13 ^ x1, 8)
 // x2 += x6, x14 = rotl32(x14 ^ x2, 8)
 // x3 += x7, x15 = rotl32(x15 ^ x3, 8)
 vld1.8  {d16}, [ip, :64]
 vadd.i32 q0, q0, q4
 vadd.i32 q1, q1, q5
 vadd.i32 q2, q2, q6
 vadd.i32 q3, q3, q7

 veor  q12, q12, q0
 veor  q13, q13, q1
 veor  q14, q14, q2
 veor  q15, q15, q3

 vtbl.8  d24, {d24}, d16
 vtbl.8  d25, {d25}, d16
 vtbl.8  d26, {d26}, d16
 vtbl.8  d27, {d27}, d16
 vtbl.8  d28, {d28}, d16
 vtbl.8  d29, {d29}, d16
 vtbl.8  d30, {d30}, d16
 vtbl.8  d31, {d31}, d16

 vld1.32  {q8-q9}, [sp, :256]

 // x8 += x12, x4 = rotl32(x4 ^ x8, 7)
 // x9 += x13, x5 = rotl32(x5 ^ x9, 7)
 // x10 += x14, x6 = rotl32(x6 ^ x10, 7)
 // x11 += x15, x7 = rotl32(x7 ^ x11, 7)
 vadd.i32 q8, q8, q12
 vadd.i32 q9, q9, q13
 vadd.i32 q10, q10, q14
 vadd.i32 q11, q11, q15

 vst1.32  {q8-q9}, [sp, :256]

 veor  q8, q4, q8
 veor  q9, q5, q9
 vshl.u32 q4, q8, #7
 vshl.u32 q5, q9, #7
 vsri.u32 q4, q8, #25
 vsri.u32 q5, q9, #25

 veor  q8, q6, q10
 veor  q9, q7, q11
 vshl.u32 q6, q8, #7
 vshl.u32 q7, q9, #7
 vsri.u32 q6, q8, #25
 vsri.u32 q7, q9, #25

 vld1.32  {q8-q9}, [sp, :256]

 // x0 += x5, x15 = rotl32(x15 ^ x0, 16)
 // x1 += x6, x12 = rotl32(x12 ^ x1, 16)
 // x2 += x7, x13 = rotl32(x13 ^ x2, 16)
 // x3 += x4, x14 = rotl32(x14 ^ x3, 16)
 vadd.i32 q0, q0, q5
 vadd.i32 q1, q1, q6
 vadd.i32 q2, q2, q7
 vadd.i32 q3, q3, q4

 veor  q15, q15, q0
 veor  q12, q12, q1
 veor  q13, q13, q2
 veor  q14, q14, q3

 vrev32.16 q15, q15
 vrev32.16 q12, q12
 vrev32.16 q13, q13
 vrev32.16 q14, q14

 // x10 += x15, x5 = rotl32(x5 ^ x10, 12)
 // x11 += x12, x6 = rotl32(x6 ^ x11, 12)
 // x8 += x13, x7 = rotl32(x7 ^ x8, 12)
 // x9 += x14, x4 = rotl32(x4 ^ x9, 12)
 vadd.i32 q10, q10, q15
 vadd.i32 q11, q11, q12
 vadd.i32 q8, q8, q13
 vadd.i32 q9, q9, q14

 vst1.32  {q8-q9}, [sp, :256]

 veor  q8, q7, q8
 veor  q9, q4, q9
 vshl.u32 q7, q8, #12
 vshl.u32 q4, q9, #12
 vsri.u32 q7, q8, #20
 vsri.u32 q4, q9, #20

 veor  q8, q5, q10
 veor  q9, q6, q11
 vshl.u32 q5, q8, #12
 vshl.u32 q6, q9, #12
 vsri.u32 q5, q8, #20
 vsri.u32 q6, q9, #20

 // x0 += x5, x15 = rotl32(x15 ^ x0, 8)
 // x1 += x6, x12 = rotl32(x12 ^ x1, 8)
 // x2 += x7, x13 = rotl32(x13 ^ x2, 8)
 // x3 += x4, x14 = rotl32(x14 ^ x3, 8)
 vld1.8  {d16}, [ip, :64]
 vadd.i32 q0, q0, q5
 vadd.i32 q1, q1, q6
 vadd.i32 q2, q2, q7
 vadd.i32 q3, q3, q4

 veor  q15, q15, q0
 veor  q12, q12, q1
 veor  q13, q13, q2
 veor  q14, q14, q3

 vtbl.8  d30, {d30}, d16
 vtbl.8  d31, {d31}, d16
 vtbl.8  d24, {d24}, d16
 vtbl.8  d25, {d25}, d16
 vtbl.8  d26, {d26}, d16
 vtbl.8  d27, {d27}, d16
 vtbl.8  d28, {d28}, d16
 vtbl.8  d29, {d29}, d16

 vld1.32  {q8-q9}, [sp, :256]

 // x10 += x15, x5 = rotl32(x5 ^ x10, 7)
 // x11 += x12, x6 = rotl32(x6 ^ x11, 7)
 // x8 += x13, x7 = rotl32(x7 ^ x8, 7)
 // x9 += x14, x4 = rotl32(x4 ^ x9, 7)
 vadd.i32 q10, q10, q15
 vadd.i32 q11, q11, q12
 vadd.i32 q8, q8, q13
 vadd.i32 q9, q9, q14

 vst1.32  {q8-q9}, [sp, :256]

 veor  q8, q7, q8
 veor  q9, q4, q9
 vshl.u32 q7, q8, #7
 vshl.u32 q4, q9, #7
 vsri.u32 q7, q8, #25
 vsri.u32 q4, q9, #25

 veor  q8, q5, q10
 veor  q9, q6, q11
 vshl.u32 q5, q8, #7
 vshl.u32 q6, q9, #7
 vsri.u32 q5, q8, #25
 vsri.u32 q6, q9, #25

 subs  r3, r3, #2
 bne  .Ldoubleround4

 // x0..7[0-3] are in q0-q7, x10..15[0-3] are in q10-q15.
 // x8..9[0-3] are on the stack.

 // Re-interleave the words in the first two rows of each block (x0..7).
 // Also add the counter values 0-3 to x12[0-3].
   vld1.32 {q8}, [lr, :128] // load counter values 0-3
 vzip.32  q0, q1   // => (0 1 0 1) (0 1 0 1)
 vzip.32  q2, q3   // => (2 3 2 3) (2 3 2 3)
 vzip.32  q4, q5   // => (4 5 4 5) (4 5 4 5)
 vzip.32  q6, q7   // => (6 7 6 7) (6 7 6 7)
   vadd.u32 q12, q8   // x12 += counter values 0-3
 vswp  d1, d4
 vswp  d3, d6
   vld1.32 {q8-q9}, [r0]! // load s0..7
 vswp  d9, d12
 vswp  d11, d14

 // Swap q1 and q4 so that we'll free up consecutive registers (q0-q1)
 // after XORing the first 32 bytes.
 vswp  q1, q4

 // First two rows of each block are (q0 q1) (q2 q6) (q4 q5) (q3 q7)

 // x0..3[0-3] += s0..3[0-3] (add orig state to 1st row of each block)
 vadd.u32 q0, q0, q8
 vadd.u32 q2, q2, q8
 vadd.u32 q4, q4, q8
 vadd.u32 q3, q3, q8

 // x4..7[0-3] += s4..7[0-3] (add orig state to 2nd row of each block)
 vadd.u32 q1, q1, q9
 vadd.u32 q6, q6, q9
 vadd.u32 q5, q5, q9
 vadd.u32 q7, q7, q9

 // XOR first 32 bytes using keystream from first two rows of first block
 vld1.8  {q8-q9}, [r2]!
 veor  q8, q8, q0
 veor  q9, q9, q1
 vst1.8  {q8-q9}, [r1]!

 // Re-interleave the words in the last two rows of each block (x8..15).
 vld1.32  {q8-q9}, [sp, :256]
   mov  sp, r4  // restore original stack pointer
   ldr  r4, [r4, #8] // load number of bytes
 vzip.32  q12, q13 // => (12 13 12 13) (12 13 12 13)
 vzip.32  q14, q15 // => (14 15 14 15) (14 15 14 15)
 vzip.32  q8, q9  // => (8 9 8 9) (8 9 8 9)
 vzip.32  q10, q11 // => (10 11 10 11) (10 11 10 11)
   vld1.32 {q0-q1}, [r0] // load s8..15
 vswp  d25, d28
 vswp  d27, d30
 vswp  d17, d20
 vswp  d19, d22

 // Last two rows of each block are (q8 q12) (q10 q14) (q9 q13) (q11 q15)

 // x8..11[0-3] += s8..11[0-3] (add orig state to 3rd row of each block)
 vadd.u32 q8,  q8,  q0
 vadd.u32 q10, q10, q0
 vadd.u32 q9,  q9,  q0
 vadd.u32 q11, q11, q0

 // x12..15[0-3] += s12..15[0-3] (add orig state to 4th row of each block)
 vadd.u32 q12, q12, q1
 vadd.u32 q14, q14, q1
 vadd.u32 q13, q13, q1
 vadd.u32 q15, q15, q1

 // XOR the rest of the data with the keystream

 vld1.8  {q0-q1}, [r2]!
 subs  r4, r4, #96
 veor  q0, q0, q8
 veor  q1, q1, q12
 ble  .Lle96
 vst1.8  {q0-q1}, [r1]!

 vld1.8  {q0-q1}, [r2]!
 subs  r4, r4, #32
 veor  q0, q0, q2
 veor  q1, q1, q6
 ble  .Lle128
 vst1.8  {q0-q1}, [r1]!

 vld1.8  {q0-q1}, [r2]!
 subs  r4, r4, #32
 veor  q0, q0, q10
 veor  q1, q1, q14
 ble  .Lle160
 vst1.8  {q0-q1}, [r1]!

 vld1.8  {q0-q1}, [r2]!
 subs  r4, r4, #32
 veor  q0, q0, q4
 veor  q1, q1, q5
 ble  .Lle192
 vst1.8  {q0-q1}, [r1]!

 vld1.8  {q0-q1}, [r2]!
 subs  r4, r4, #32
 veor  q0, q0, q9
 veor  q1, q1, q13
 ble  .Lle224
 vst1.8  {q0-q1}, [r1]!

 vld1.8  {q0-q1}, [r2]!
 subs  r4, r4, #32
 veor  q0, q0, q3
 veor  q1, q1, q7
 blt  .Llt256
.Lout:
 vst1.8  {q0-q1}, [r1]!

 vld1.8  {q0-q1}, [r2]
 veor  q0, q0, q11
 veor  q1, q1, q15
 vst1.8  {q0-q1}, [r1]

 pop  {r4, pc}

.Lle192:
 vmov  q4, q9
 vmov  q5, q13

.Lle160:
 // nothing to do

.Lfinalblock:
 // Process the final block if processing less than 4 full blocks.
 // Entered with 32 bytes of ChaCha cipher stream in q4-q5, and the
 // previous 32 byte output block that still needs to be written at
 // [r1] in q0-q1.
 beq  .Lfullblock

.Lpartialblock:
 adr  lr, .Lpermute + 32
 add  r2, r2, r4
 add  lr, lr, r4
 add  r4, r4, r1

 vld1.8  {q2-q3}, [lr]
 vld1.8  {q6-q7}, [r2]

 add  r4, r4, #32

 vtbl.8  d4, {q4-q5}, d4
 vtbl.8  d5, {q4-q5}, d5
 vtbl.8  d6, {q4-q5}, d6
 vtbl.8  d7, {q4-q5}, d7

 veor  q6, q6, q2
 veor  q7, q7, q3

 vst1.8  {q6-q7}, [r4] // overlapping stores
 vst1.8  {q0-q1}, [r1]
 pop  {r4, pc}

.Lfullblock:
 vmov  q11, q4
 vmov  q15, q5
 b  .Lout
.Lle96:
 vmov  q4, q2
 vmov  q5, q6
 b  .Lfinalblock
.Lle128:
 vmov  q4, q10
 vmov  q5, q14
 b  .Lfinalblock
.Lle224:
 vmov  q4, q3
 vmov  q5, q7
 b  .Lfinalblock
.Llt256:
 vmov  q4, q11
 vmov  q5, q15
 b  .Lpartialblock
ENDPROC(chacha_4block_xor_neon)

 .align  L1_CACHE_SHIFT
.Lpermute:
 .byte  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
 .byte  0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
 .byte  0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17
 .byte  0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
 .byte  0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
 .byte  0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
 .byte  0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17
 .byte  0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f