x86_64/sha512-compress.asm

   1 C x86_64/sha512-compress.asm
   2
   3 ifelse(<
   4    Copyright (C) 2013 Niels Möller
   5
   6    This file is part of GNU Nettle.
   7
   8    GNU Nettle is free software: you can redistribute it and/or
   9    modify it under the terms of either:
  10
  11      * the GNU Lesser General Public License as published by the Free
  12        Software Foundation; either version 3 of the License, or (at your
  13        option) any later version.
  14
  15    or
  16
  17      * the GNU General Public License as published by the Free
  18        Software Foundation; either version 2 of the License, or (at your
  19        option) any later version.
  20
  21    or both in parallel, as here.
  22
  23    GNU Nettle is distributed in the hope that it will be useful,
  24    but WITHOUT ANY WARRANTY; without even the implied warranty of
  25    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  26    General Public License for more details.
  27
  28    You should have received copies of the GNU General Public License and
  29    the GNU Lesser General Public License along with this program.  If
  30    not, see http://www.gnu.org/licenses/.
  31 >)
  32
  33         .file "sha512-compress.asm"
  34 define(<STATE>, <%rdi>)
  35 define(<INPUT>, <%rsi>)
  36 define(<K>, <%rdx>)
  37 define(<SA>, <%rax>)
  38 define(<SB>, <%rbx>)
  39 define(<SC>, <%rcx>)
  40 define(<SD>, <%r8>)
  41 define(<SE>, <%r9>)
  42 define(<SF>, <%r10>)
  43 define(<SG>, <%r11>)
  44 define(<SH>, <%r12>)
  45 define(<T0>, <%r13>)
  46 define(<T1>, <%rdi>)    C Overlap STATE
  47 define(<COUNT>, <%r14>)
  48 define(<W>, <%r15>)
  49
  50 define(<EXPN>, <
  51         mov     OFFSET64($1)(%rsp), W
  52         mov     OFFSET64(eval(($1 + 14) % 16))(%rsp), T0
  53         mov     T0, T1
  54         shr     <$>6, T0
  55         rol     <$>3, T1
  56         xor     T1, T0
  57         rol     <$>42, T1
  58         xor     T1, T0
  59         add     T0, W
  60         mov     OFFSET64(eval(($1 + 1) % 16))(%rsp), T0
  61         mov     T0, T1
  62         shr     <$>7, T0
  63         rol     <$>56, T1
  64         xor     T1, T0
  65         rol     <$>7, T1
  66         xor     T1, T0
  67         add     T0, W
  68         add     OFFSET64(eval(($1 + 9) % 16))(%rsp), W
  69         mov     W, OFFSET64($1)(%rsp)
  70 >)
  71
  72 C ROUND(A,B,C,D,E,F,G,H,K)
  73 C
  74 C H += S1(E) + Choice(E,F,G) + K + W
  75 C D += H
  76 C H += S0(A) + Majority(A,B,C)
  77 C
  78 C Where
  79 C
  80 C S1(E) = E<<<50 ^ E<<<46 ^ E<<<23
  81 C S0(A) = A<<<36 ^ A<<<30 ^ A<<<25
  82 C Choice (E, F, G) = G^(E&(F^G))
  83 C Majority (A,B,C) = (A&B) + (C&(A^B))
  84
  85 define(<ROUND>, <
  86         mov     $5, T0
  87         mov     $5, T1
  88         rol     <$>23, T0
  89         rol     <$>46, T1
  90         xor     T0, T1
  91         rol     <$>27, T0
  92         xor     T0, T1
  93         add     W, $8
  94         add     T1, $8
  95         mov     $7, T0
  96         xor     $6, T0
  97         and     $5, T0
  98         xor     $7, T0
  99         add     OFFSET64($9)(K,COUNT,8), $8
 100         add     T0, $8
 101         add     $8, $4
 102
 103         mov     $1, T0
 104         mov     $1, T1
 105         rol     <$>25, T0
 106         rol     <$>30, T1
 107         xor     T0, T1
 108         rol     <$>11, T0
 109         xor     T0, T1
 110         add     T1, $8
 111         mov     $1, T0
 112         mov     $1, T1
 113         and     $2, T0
 114         xor     $2, T1
 115         add     T0, $8
 116         and     $3, T1
 117         add     T1, $8
 118 >)
 119
 120 define(<NOEXPN>, <
 121         mov     OFFSET64($1)(INPUT, COUNT, 8), W
 122         bswap   W
 123         mov     W, OFFSET64($1)(%rsp, COUNT, 8)
 124 >)
 125
 126         C void
 127         C _nettle_sha512_compress(uint64_t *state, const uint8_t *input, const uint64_t *k)
 128
 129         .text
 130         ALIGN(16)
 131
 132 PROLOGUE(_nettle_sha512_compress)
 133         W64_ENTRY(3, 0)
 134
 135         sub     $184, %rsp
 136         mov     %rbx, 128(%rsp)
 137         mov     STATE, 136(%rsp)        C Save state, to free a register
 138         mov     %rbp, 144(%rsp)
 139         mov     %r12, 152(%rsp)
 140         mov     %r13, 160(%rsp)
 141         mov     %r14, 168(%rsp)
 142         mov     %r15, 176(%rsp)
 143
 144         mov     (STATE),   SA
 145         mov     8(STATE),  SB
 146         mov     16(STATE),  SC
 147         mov     24(STATE), SD
 148         mov     32(STATE), SE
 149         mov     40(STATE), SF
 150         mov     48(STATE), SG
 151         mov     56(STATE), SH
 152         xor     COUNT, COUNT
 153         ALIGN(16)
 154
 155 .Loop1:
 156         NOEXPN(0) ROUND(SA,SB,SC,SD,SE,SF,SG,SH,0)
 157         NOEXPN(1) ROUND(SH,SA,SB,SC,SD,SE,SF,SG,1)
 158         NOEXPN(2) ROUND(SG,SH,SA,SB,SC,SD,SE,SF,2)
 159         NOEXPN(3) ROUND(SF,SG,SH,SA,SB,SC,SD,SE,3)
 160         NOEXPN(4) ROUND(SE,SF,SG,SH,SA,SB,SC,SD,4)
 161         NOEXPN(5) ROUND(SD,SE,SF,SG,SH,SA,SB,SC,5)
 162         NOEXPN(6) ROUND(SC,SD,SE,SF,SG,SH,SA,SB,6)
 163         NOEXPN(7) ROUND(SB,SC,SD,SE,SF,SG,SH,SA,7)
 164         add     $8, COUNT
 165         cmp     $16, COUNT
 166         jne     .Loop1
 167
 168 .Loop2:
 169         EXPN( 0) ROUND(SA,SB,SC,SD,SE,SF,SG,SH,0)
 170         EXPN( 1) ROUND(SH,SA,SB,SC,SD,SE,SF,SG,1)
 171         EXPN( 2) ROUND(SG,SH,SA,SB,SC,SD,SE,SF,2)
 172         EXPN( 3) ROUND(SF,SG,SH,SA,SB,SC,SD,SE,3)
 173         EXPN( 4) ROUND(SE,SF,SG,SH,SA,SB,SC,SD,4)
 174         EXPN( 5) ROUND(SD,SE,SF,SG,SH,SA,SB,SC,5)
 175         EXPN( 6) ROUND(SC,SD,SE,SF,SG,SH,SA,SB,6)
 176         EXPN( 7) ROUND(SB,SC,SD,SE,SF,SG,SH,SA,7)
 177         EXPN( 8) ROUND(SA,SB,SC,SD,SE,SF,SG,SH,8)
 178         EXPN( 9) ROUND(SH,SA,SB,SC,SD,SE,SF,SG,9)
 179         EXPN(10) ROUND(SG,SH,SA,SB,SC,SD,SE,SF,10)
 180         EXPN(11) ROUND(SF,SG,SH,SA,SB,SC,SD,SE,11)
 181         EXPN(12) ROUND(SE,SF,SG,SH,SA,SB,SC,SD,12)
 182         EXPN(13) ROUND(SD,SE,SF,SG,SH,SA,SB,SC,13)
 183         EXPN(14) ROUND(SC,SD,SE,SF,SG,SH,SA,SB,14)
 184         EXPN(15) ROUND(SB,SC,SD,SE,SF,SG,SH,SA,15)
 185         add     $16, COUNT
 186         cmp     $80, COUNT
 187         jne     .Loop2
 188
 189         mov     136(%rsp), STATE
 190
 191         add     SA, (STATE)
 192         add     SB, 8(STATE)
 193         add     SC, 16(STATE)
 194         add     SD, 24(STATE)
 195         add     SE, 32(STATE)
 196         add     SF, 40(STATE)
 197         add     SG, 48(STATE)
 198         add     SH, 56(STATE)
 199
 200         mov     128(%rsp), %rbx
 201         mov     144(%rsp), %rbp
 202         mov     152(%rsp), %r12
 203         mov     160(%rsp), %r13
 204         mov     168(%rsp),%r14
 205         mov     176(%rsp),%r15
 206
 207         add     $184, %rsp
 208         W64_EXIT(3, 0)
 209         ret
 210 EPILOGUE(_nettle_sha512_compress)