← Back to branch summary

~ubuntu-branches/ubuntu/utopic/nettle/utopic

« back to all changes in this revision

Viewing changes to x86_64/sha512-compress.asm

  • Committer: Package Import Robot
  • Author(s): Magnus Holmgren
  • Date: 2013-05-07 22:57:14 UTC
  • mfrom: (8.1.8 sid)
  • Revision ID: package-import@ubuntu.com-20130507225714-s331yr8ov53dtt17
Tags: 2.7-2
Tag some (ECC related) symbols that only exist on some architectures.

Show diffs side-by-side

added added

removed removed

Lines of Context:
x86_64/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
define(<STATE>, <%rdi>)
 
22
define(<INPUT>, <%rsi>)
 
23
define(<K>, <%rdx>)
 
24
define(<SA>, <%rax>)
 
25
define(<SB>, <%rbx>)
 
26
define(<SC>, <%rcx>)
 
27
define(<SD>, <%r8>)
 
28
define(<SE>, <%r9>)
 
29
define(<SF>, <%r10>)
 
30
define(<SG>, <%r11>)
 
31
define(<SH>, <%r12>)
 
32
define(<T0>, <%r13>)
 
33
define(<T1>, <%rdi>)    C Overlap STATE
 
34
define(<COUNT>, <%r14>)
 
35
define(<W>, <%r15>)
 
36
 
 
37
define(<EXPN>, <
 
38
        mov     OFFSET64($1)(%rsp), W
 
39
        mov     OFFSET64(eval(($1 + 14) % 16))(%rsp), T0
 
40
        mov     T0, T1
 
41
        shr     <$>6, T0
 
42
        rol     <$>3, T1
 
43
        xor     T1, T0
 
44
        rol     <$>42, T1
 
45
        xor     T1, T0
 
46
        add     T0, W
 
47
        mov     OFFSET64(eval(($1 + 1) % 16))(%rsp), T0
 
48
        mov     T0, T1
 
49
        shr     <$>7, T0
 
50
        rol     <$>56, T1
 
51
        xor     T1, T0
 
52
        rol     <$>7, T1
 
53
        xor     T1, T0
 
54
        add     T0, W
 
55
        add     OFFSET64(eval(($1 + 9) % 16))(%rsp), W
 
56
        mov     W, OFFSET64($1)(%rsp)
 
57
>)
 
58
 
 
59
C ROUND(A,B,C,D,E,F,G,H,K)
 
60
C
 
61
C H += S1(E) + Choice(E,F,G) + K + W
 
62
C D += H
 
63
C H += S0(A) + Majority(A,B,C)
 
64
C
 
65
C Where
 
66
C
 
67
C S1(E) = E<<<50 ^ E<<<46 ^ E<<<23
 
68
C S0(A) = A<<<36 ^ A<<<30 ^ A<<<25
 
69
C Choice (E, F, G) = G^(E&(F^G))
 
70
C Majority (A,B,C) = (A&B) + (C&(A^B))
 
71
 
 
72
define(<ROUND>, <
 
73
        mov     $5, T0
 
74
        mov     $5, T1
 
75
        rol     <$>23, T0
 
76
        rol     <$>46, T1
 
77
        xor     T0, T1
 
78
        rol     <$>27, T0
 
79
        xor     T0, T1
 
80
        add     W, $8
 
81
        add     T1, $8
 
82
        mov     $7, T0
 
83
        xor     $6, T0
 
84
        and     $5, T0
 
85
        xor     $7, T0
 
86
        add     OFFSET64($9)(K,COUNT,8), $8
 
87
        add     T0, $8
 
88
        add     $8, $4
 
89
 
 
90
        mov     $1, T0
 
91
        mov     $1, T1
 
92
        rol     <$>25, T0
 
93
        rol     <$>30, T1
 
94
        xor     T0, T1
 
95
        rol     <$>11, T0
 
96
        xor     T0, T1
 
97
        add     T1, $8
 
98
        mov     $1, T0
 
99
        mov     $1, T1
 
100
        and     $2, T0
 
101
        xor     $2, T1
 
102
        add     T0, $8
 
103
        and     $3, T1
 
104
        add     T1, $8
 
105
>)
 
106
 
 
107
define(<NOEXPN>, <
 
108
        mov     OFFSET64($1)(INPUT, COUNT, 8), W
 
109
        bswap   W
 
110
        mov     W, OFFSET64($1)(%rsp, COUNT, 8)
 
111
>)
 
112
 
 
113
        C void
 
114
        C _nettle_sha512_compress(uint64_t *state, const uint8_t *input, const uint64_t *k)
 
115
 
 
116
        .text
 
117
        ALIGN(16)
 
118
 
 
119
PROLOGUE(_nettle_sha512_compress)
 
120
        W64_ENTRY(3, 0)
 
121
 
 
122
        sub     $184, %rsp
 
123
        mov     %rbx, 128(%rsp)
 
124
        mov     STATE, 136(%rsp)        C Save state, to free a register
 
125
        mov     %rbp, 144(%rsp)
 
126
        mov     %r12, 152(%rsp)
 
127
        mov     %r13, 160(%rsp)
 
128
        mov     %r14, 168(%rsp)
 
129
        mov     %r15, 176(%rsp)
 
130
 
 
131
        mov     (STATE),   SA
 
132
        mov     8(STATE),  SB
 
133
        mov     16(STATE),  SC
 
134
        mov     24(STATE), SD
 
135
        mov     32(STATE), SE
 
136
        mov     40(STATE), SF
 
137
        mov     48(STATE), SG
 
138
        mov     56(STATE), SH
 
139
        xor     COUNT, COUNT
 
140
        ALIGN(16)
 
141
 
 
142
.Loop1:
 
143
        NOEXPN(0) ROUND(SA,SB,SC,SD,SE,SF,SG,SH,0)
 
144
        NOEXPN(1) ROUND(SH,SA,SB,SC,SD,SE,SF,SG,1)
 
145
        NOEXPN(2) ROUND(SG,SH,SA,SB,SC,SD,SE,SF,2)
 
146
        NOEXPN(3) ROUND(SF,SG,SH,SA,SB,SC,SD,SE,3)
 
147
        NOEXPN(4) ROUND(SE,SF,SG,SH,SA,SB,SC,SD,4)
 
148
        NOEXPN(5) ROUND(SD,SE,SF,SG,SH,SA,SB,SC,5)
 
149
        NOEXPN(6) ROUND(SC,SD,SE,SF,SG,SH,SA,SB,6)
 
150
        NOEXPN(7) ROUND(SB,SC,SD,SE,SF,SG,SH,SA,7)
 
151
        add     $8, COUNT
 
152
        cmp     $16, COUNT
 
153
        jne     .Loop1
 
154
 
 
155
.Loop2:
 
156
        EXPN( 0) ROUND(SA,SB,SC,SD,SE,SF,SG,SH,0)
 
157
        EXPN( 1) ROUND(SH,SA,SB,SC,SD,SE,SF,SG,1)
 
158
        EXPN( 2) ROUND(SG,SH,SA,SB,SC,SD,SE,SF,2)
 
159
        EXPN( 3) ROUND(SF,SG,SH,SA,SB,SC,SD,SE,3)
 
160
        EXPN( 4) ROUND(SE,SF,SG,SH,SA,SB,SC,SD,4)
 
161
        EXPN( 5) ROUND(SD,SE,SF,SG,SH,SA,SB,SC,5)
 
162
        EXPN( 6) ROUND(SC,SD,SE,SF,SG,SH,SA,SB,6)
 
163
        EXPN( 7) ROUND(SB,SC,SD,SE,SF,SG,SH,SA,7)
 
164
        EXPN( 8) ROUND(SA,SB,SC,SD,SE,SF,SG,SH,8)
 
165
        EXPN( 9) ROUND(SH,SA,SB,SC,SD,SE,SF,SG,9)
 
166
        EXPN(10) ROUND(SG,SH,SA,SB,SC,SD,SE,SF,10)
 
167
        EXPN(11) ROUND(SF,SG,SH,SA,SB,SC,SD,SE,11)
 
168
        EXPN(12) ROUND(SE,SF,SG,SH,SA,SB,SC,SD,12)
 
169
        EXPN(13) ROUND(SD,SE,SF,SG,SH,SA,SB,SC,13)
 
170
        EXPN(14) ROUND(SC,SD,SE,SF,SG,SH,SA,SB,14)
 
171
        EXPN(15) ROUND(SB,SC,SD,SE,SF,SG,SH,SA,15)
 
172
        add     $16, COUNT
 
173
        cmp     $80, COUNT
 
174
        jne     .Loop2
 
175
 
 
176
        mov     136(%rsp), STATE
 
177
 
 
178
        add     SA, (STATE)
 
179
        add     SB, 8(STATE)
 
180
        add     SC, 16(STATE)
 
181
        add     SD, 24(STATE)
 
182
        add     SE, 32(STATE)
 
183
        add     SF, 40(STATE)
 
184
        add     SG, 48(STATE)
 
185
        add     SH, 56(STATE)
 
186
 
 
187
        mov     128(%rsp), %rbx
 
188
        mov     144(%rsp), %rbp
 
189
        mov     152(%rsp), %r12
 
190
        mov     160(%rsp), %r13
 
191
        mov     168(%rsp),%r14
 
192
        mov     176(%rsp),%r15
 
193
 
 
194
        add     $184, %rsp
 
195
        W64_EXIT(3, 0)
 
196
        ret
 
197
EPILOGUE(_nettle_sha512_compress)