arm/neon/sha512-compress.asm

   1 C nettle, low-level cryptographics library
   2 C
   3 C Copyright (C) 2013 Niels Möller
   4 C
   5 C The nettle library is free software; you can redistribute it and/or modify
   6 C it under the terms of the GNU Lesser General Public License as published by
   7 C the Free Software Foundation; either version 2.1 of the License, or (at your
   8 C option) any later version.
   9 C
  10 C The nettle library is distributed in the hope that it will be useful, but
  11 C WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12 C or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  13 C License for more details.
  14 C
  15 C You should have received a copy of the GNU Lesser General Public License
  16 C along with the nettle library; see the file COPYING.LIB.  If not, write to
  17 C the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  18 C MA 02111-1301, USA.
  19
  20         .file "sha512-compress.asm"
  21         .fpu    neon
  22
  23 define(<STATE>, <r0>)
  24 define(<INPUT>, <r1>)
  25 define(<K>, <r2>)
  26 define(<COUNT>, <r3>)
  27 define(<SHIFT>, <r12>)
  28
  29 define(<SA>, <d0>)
  30 define(<SB>, <d1>)
  31 define(<SC>, <d2>)
  32 define(<SD>, <d3>)
  33 define(<SE>, <d4>)
  34 define(<SF>, <d5>)
  35 define(<SG>, <d6>)
  36 define(<SH>, <d7>)
  37 define(<QSAB>, <q0>)
  38 define(<QSCD>, <q1>)
  39 define(<QSEF>, <q2>)
  40 define(<QSGH>, <q3>)
  41
  42 C d8-d15 are callee-save
  43 define(<DT0>, <d8>)
  44 define(<DT1>, <d9>)
  45 define(<QT01>, <q4>)
  46 define(<DT2>, <d10>)
  47 define(<DT3>, <d11>)
  48 define(<QT23>, <q5>)
  49 define(<DT4>, <d12>)
  50 define(<DT5>, <d13>)
  51 define(<QT45>, <q6>)
  52
  53 C Used only when reading the input, can overlap with state
  54 define(<DT6>, <d0>)
  55 define(<DT7>, <d1>)
  56 define(<QT67>, <q0>)
  57
  58 define(<DW0>, <d16>)
  59 define(<DW1>, <d17>)
  60 define(<DW2>, <d18>)
  61 define(<DW3>, <d19>)
  62 define(<DW4>, <d20>)
  63 define(<DW5>, <d21>)
  64 define(<DW6>, <d22>)
  65 define(<DW7>, <d23>)
  66 define(<DW8>, <d24>)
  67 define(<DW9>, <d25>)
  68 define(<DW10>, <d26>)
  69 define(<DW11>, <d27>)
  70 define(<DW12>, <d28>)
  71 define(<DW13>, <d29>)
  72 define(<DW14>, <d30>)
  73 define(<DW15>, <d31>)
  74 define(<QW0001>, <q8>)
  75 define(<QW0203>, <q9>)
  76 define(<QW0405>, <q10>)
  77 define(<QW0607>, <q11>)
  78 define(<QW0809>, <q12>)
  79 define(<QW1011>, <q13>)
  80 define(<QW1213>, <q14>)
  81 define(<QW1415>, <q15>)
  82
  83 define(<EXPAND_ME>, <$1>)
  84 define(<W>, <EXPAND_ME(<DW>eval(($1) % 16))>)
  85
  86 C If x = W(i+14), y = w(i+1), we xor in parallel
  87 C
  88 C       x << 45         y << 63
  89 C       x >> 19         y >> 1
  90 C       x << 3          y << 56
  91 C       x >> 61         y >> 8
  92 C  xor  x >> 6          y >> 7
  93 C  -----------------------------
  94 C       DT0             DT1
  95 define(<EXPN>, <
  96         vshl.i64        DT0, W($1+14), #45
  97         vshl.i64        DT1, W($1 + 1), #63
  98         vshr.u64        DT2, W($1+14), #19
  99         vshr.u64        DT3, W($1 + 1), #1
 100         vshl.i64        DT4, W($1+14), #3
 101         vshl.i64        DT5, W($1 + 1), #56
 102         veor.i64        QT01, QT01, QT23
 103         vshr.u64        DT2, W($1+14), #61
 104         vshr.u64        DT3, W($1 + 1), #8
 105         veor.i64        QT01, QT01, QT45
 106         vshr.u64        DT4, W($1+14), #6
 107         vshr.u64        DT5, W($1 + 1), #7
 108         veor.i64        QT01, QT01, QT23
 109         vadd.i64        W($1), W($1), W($1 + 9)
 110         veor.i64        QT01, QT01, QT45
 111         vadd.i64        W($1), W($1), DT0
 112         vadd.i64        W($1), W($1), DT1
 113 >)
 114
 115 C ROUND(A,B,C,D,E,F,G,H,i)
 116 C
 117 C H += S1(E) + Choice(E,F,G) + K + W
 118 C D += H
 119 C H += S0(A) + Majority(A,B,C)
 120 C
 121 C Where
 122 C
 123 C S1(E) = E<<<50 ^ E<<<46 ^ E<<<23
 124 C S0(A) = A<<<36 ^ A<<<30 ^ A<<<25
 125 C Choice (E, F, G) = G^(E&(F^G))
 126 C Majority (A,B,C) = (A&B) + (C&(A^B))
 127
 128 C Do S1 and S0 in parallel
 129 C
 130 C       e << 50         a << 36
 131 C       e >> 14         a >> 28
 132 C       e << 46         a << 30
 133 C       e >> 18         a >> 34
 134 C       e << 23         a << 25
 135 C  xor  e >> 41         a >> 39
 136 C  ----------------------------
 137 C       DT0             DT1
 138 define(<ROUND>, <
 139         vshl.i64        DT0, $5, #50
 140         vshl.i64        DT1, $1, #36
 141         vshr.u64        DT2, $5, #14
 142         vshr.u64        DT3, $1, #28
 143         vshl.i64        DT4, $5, #46
 144         vshl.i64        DT5, $1, #30
 145         veor            QT01, QT01, QT23
 146         vshr.u64        DT2, $5, #18
 147         vshr.u64        DT3, $1, #34
 148         veor            QT01, QT01, QT45
 149         vshl.i64        DT4, $5, #23
 150         vshl.i64        DT5, $1, #25
 151         veor            QT01, QT01, QT23
 152         vshr.u64        DT2, $5, #41
 153         vshr.u64        DT3, $1, #39
 154         veor            QT01, QT01, QT45
 155         veor            DT4, $6, $7
 156         veor            DT5, $1, $2
 157         vand            DT4, DT4, $5
 158         vand            DT5, DT5, $3
 159         veor            DT4, DT4, $7
 160         veor            QT01, QT01, QT23
 161         vand            DT2, $1, $2
 162         vldr            DT3, [K,#eval(8*$9)]
 163         vadd.i64        $8, $8, W($9)
 164         vadd.i64        QT01, QT01, QT45
 165         vadd.i64        $8, $8, DT3
 166         vadd.i64        $8, $8, DT0
 167         vadd.i64        DT1, DT1, DT2
 168         vadd.i64        $4, $4, $8
 169         vadd.i64        $8, $8, DT1
 170 >)
 171
 172         C void
 173         C _nettle_sha512_compress(uint64_t *state, const uint8_t *input, const uint64_t *k)
 174
 175         .text
 176         .align 2
 177
 178 PROLOGUE(_nettle_sha512_compress)
 179         vpush   {d8,d9,d10,d11,d12,d13}
 180
 181         ands    SHIFT, INPUT, #7
 182         and     INPUT, INPUT, #-8
 183         vld1.8  {DT5}, [INPUT :64]
 184         addne   INPUT, INPUT, #8
 185         addeq   SHIFT, SHIFT, #8
 186         lsl     SHIFT, SHIFT, #3
 187
 188         C Put right shift in DT0 and DT1, aka QT01
 189         neg     SHIFT, SHIFT
 190         vmov.i32        DT0, #0
 191         vmov.32         DT0[0], SHIFT
 192         vmov            DT1, DT0
 193         C Put left shift in DT2 and DT3, aka QT23
 194         add             SHIFT, SHIFT, #64
 195         vmov.i32        DT2, #0
 196         vmov.32         DT2[0], SHIFT
 197         vmov            DT3, DT2
 198         vshl.u64        DT5, DT5, DT0
 199
 200         C Set w[i] <-- w[i-1] >> RSHIFT + w[i] << LSHIFT
 201         vld1.8          {W(0),W(1),W(2),W(3)}, [INPUT :64]!
 202         vshl.u64        QT67, QW0001, QT01      C Right shift
 203         vshl.u64        QW0001, QW0001, QT23    C Left shift
 204         veor            W(0), W(0), DT5
 205         veor            W(1), W(1), DT6
 206         vrev64.8        QW0001, QW0001
 207         vshl.u64        QT45, QW0203, QT01      C Right shift
 208         vshl.u64        QW0203, QW0203, QT23    C Left shift
 209         veor            W(2), W(2), DT7
 210         veor            W(3), W(3), DT4
 211         vrev64.8        QW0203, QW0203
 212
 213         vld1.8          {W(4),W(5),W(6),W(7)}, [INPUT :64]!
 214         vshl.u64        QT67, QW0405, QT01      C Right shift
 215         vshl.u64        QW0405, QW0405, QT23    C Left shift
 216         veor            W(4), W(4), DT5
 217         veor            W(5), W(5), DT6
 218         vrev64.8        QW0405, QW0405
 219         vshl.u64        QT45, QW0607, QT01      C Right shift
 220         vshl.u64        QW0607, QW0607, QT23    C Left shift
 221         veor            W(6), W(6), DT7
 222         veor            W(7), W(7), DT4
 223         vrev64.8        QW0607, QW0607
 224
 225         vld1.8          {W(8),W(9),W(10),W(11)}, [INPUT :64]!
 226         vshl.u64        QT67, QW0809, QT01      C Right shift
 227         vshl.u64        QW0809, QW0809, QT23    C Left shift
 228         veor            W(8), W(8), DT5
 229         veor            W(9), W(9), DT6
 230         vrev64.8        QW0809, QW0809
 231         vshl.u64        QT45, QW1011, QT01      C Right shift
 232         vshl.u64        QW1011, QW1011, QT23    C Left shift
 233         veor            W(10), W(10), DT7
 234         veor            W(11), W(11), DT4
 235         vrev64.8        QW1011, QW1011
 236
 237         vld1.8          {W(12),W(13),W(14),W(15)}, [INPUT :64]!
 238         vshl.u64        QT67, QW1213, QT01      C Right shift
 239         vshl.u64        QW1213, QW1213, QT23    C Left shift
 240         veor            W(12), W(12), DT5
 241         veor            W(13), W(13), DT6
 242         vrev64.8        QW1213, QW1213
 243         vshl.u64        QT45, QW1415, QT01      C Right shift
 244         vshl.u64        QW1415, QW1415, QT23    C Left shift
 245         veor            W(14), W(14), DT7
 246         veor            W(15), W(15), DT4
 247         vrev64.8        QW1415, QW1415
 248
 249         vldm    STATE, {SA,SB,SC,SD,SE,SF,SG,SH}
 250
 251         ROUND(SA,SB,SC,SD,SE,SF,SG,SH, 0)
 252         ROUND(SH,SA,SB,SC,SD,SE,SF,SG, 1)
 253         ROUND(SG,SH,SA,SB,SC,SD,SE,SF, 2)
 254         ROUND(SF,SG,SH,SA,SB,SC,SD,SE, 3)
 255         ROUND(SE,SF,SG,SH,SA,SB,SC,SD, 4)
 256         ROUND(SD,SE,SF,SG,SH,SA,SB,SC, 5)
 257         ROUND(SC,SD,SE,SF,SG,SH,SA,SB, 6)
 258         ROUND(SB,SC,SD,SE,SF,SG,SH,SA, 7)
 259
 260         ROUND(SA,SB,SC,SD,SE,SF,SG,SH, 8)
 261         ROUND(SH,SA,SB,SC,SD,SE,SF,SG, 9)
 262         ROUND(SG,SH,SA,SB,SC,SD,SE,SF, 10)
 263         ROUND(SF,SG,SH,SA,SB,SC,SD,SE, 11)
 264         ROUND(SE,SF,SG,SH,SA,SB,SC,SD, 12)
 265         ROUND(SD,SE,SF,SG,SH,SA,SB,SC, 13)
 266         ROUND(SC,SD,SE,SF,SG,SH,SA,SB, 14)
 267         ROUND(SB,SC,SD,SE,SF,SG,SH,SA, 15)
 268
 269         add     K, K, #128
 270
 271         mov     COUNT, #4
 272 .Loop:
 273
 274         EXPN( 0) ROUND(SA,SB,SC,SD,SE,SF,SG,SH,  0)
 275         EXPN( 1) ROUND(SH,SA,SB,SC,SD,SE,SF,SG,  1)
 276         EXPN( 2) ROUND(SG,SH,SA,SB,SC,SD,SE,SF,  2)
 277         EXPN( 3) ROUND(SF,SG,SH,SA,SB,SC,SD,SE,  3)
 278         EXPN( 4) ROUND(SE,SF,SG,SH,SA,SB,SC,SD,  4)
 279         EXPN( 5) ROUND(SD,SE,SF,SG,SH,SA,SB,SC,  5)
 280         EXPN( 6) ROUND(SC,SD,SE,SF,SG,SH,SA,SB,  6)
 281         EXPN( 7) ROUND(SB,SC,SD,SE,SF,SG,SH,SA,  7)
 282         EXPN( 8) ROUND(SA,SB,SC,SD,SE,SF,SG,SH,  8)
 283         EXPN( 9) ROUND(SH,SA,SB,SC,SD,SE,SF,SG,  9)
 284         EXPN(10) ROUND(SG,SH,SA,SB,SC,SD,SE,SF, 10)
 285         EXPN(11) ROUND(SF,SG,SH,SA,SB,SC,SD,SE, 11)
 286         EXPN(12) ROUND(SE,SF,SG,SH,SA,SB,SC,SD, 12)
 287         EXPN(13) ROUND(SD,SE,SF,SG,SH,SA,SB,SC, 13)
 288         EXPN(14) ROUND(SC,SD,SE,SF,SG,SH,SA,SB, 14)
 289         subs    COUNT, COUNT, #1
 290         EXPN(15) ROUND(SB,SC,SD,SE,SF,SG,SH,SA, 15)
 291         add     K, K, #128
 292         bne     .Loop
 293
 294         vld1.64         {DW0, DW1, DW2, DW3}, [STATE]
 295         vadd.i64        QSAB, QSAB, QW0001
 296         vadd.i64        QSCD, QSCD, QW0203
 297         vst1.64         {SA,SB,SC,SD}, [STATE]!
 298         vld1.64         {DW0, DW1, DW2, DW3}, [STATE]
 299         vadd.i64        QSEF, QSEF, QW0001
 300         vadd.i64        QSGH, QSGH, QW0203
 301         vst1.64         {SE,SF,SG,SH}, [STATE]!
 302
 303         vpop    {d8,d9,d10,d11,d12,d13}
 304         bx      lr
 305 EPILOGUE(_nettle_sha512_compress)
 306
 307 divert(-1)
 308 define shastate
 309 p/x $d0.u64
 310 p/x $d1.u64
 311 p/x $d2.u64
 312 p/x $d3.u64
 313 p/x $d4.u64
 314 p/x $d5.u64
 315 p/x $d6.u64
 316 p/x $d7.u64
 317 end