| /* |
| * ChaCha/XChaCha 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 |
