← Back to branch summary

~ubuntu-branches/ubuntu/vivid/golang/vivid

« back to all changes in this revision

Viewing changes to src/pkg/crypto/sha1/sha1block_386.s

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-08-20 14:06:23 UTC
  • mfrom: (14.1.23 saucy-proposed)
  • Revision ID: package-import@ubuntu.com-20130820140623-b414jfxi3m0qkmrq
Tags: 2:1.1.2-2ubuntu1
https://launchpad.net/bugs/1211749
https://launchpad.net/bugs/1202027
* Merge from Debian unstable (LP: #1211749, #1202027). Remaining changes:
  - 016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.
  - d/control,control.cross: Update Breaks/Replaces for Ubuntu
    versions to ensure smooth upgrades, regenerate control file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/crypto/sha1/sha1block_386.s
 
1
// Copyright 2013 The Go Authors.  All rights reserved.
 
2
// Use of this source code is governed by a BSD-style
 
3
// license that can be found in the LICENSE file.
 
4
 
 
5
// SHA1 block routine. See sha1block.go for Go equivalent.
 
6
//
 
7
// There are 80 rounds of 4 types:
 
8
//   - rounds 0-15 are type 1 and load data (ROUND1 macro).
 
9
//   - rounds 16-19 are type 1 and do not load data (ROUND1x macro).
 
10
//   - rounds 20-39 are type 2 and do not load data (ROUND2 macro).
 
11
//   - rounds 40-59 are type 3 and do not load data (ROUND3 macro).
 
12
//   - rounds 60-79 are type 4 and do not load data (ROUND4 macro).
 
13
//
 
14
// Each round loads or shuffles the data, then computes a per-round
 
15
// function of b, c, d, and then mixes the result into and rotates the
 
16
// five registers a, b, c, d, e holding the intermediate results.
 
17
//
 
18
// The register rotation is implemented by rotating the arguments to
 
19
// the round macros instead of by explicit move instructions.
 
20
 
 
21
// Like sha1block_amd64.s, but we keep the data and limit pointers on the stack.
 
22
// To free up the word pointer (R10 on amd64, DI here), we add it to e during
 
23
// LOAD/SHUFFLE instead of during MIX.
 
24
//
 
25
// The stack holds the intermediate word array - 16 uint32s - at 0(SP) up to 64(SP).
 
26
// The saved a, b, c, d, e (R11 through R15 on amd64) are at 64(SP) up to 84(SP).
 
27
// The saved limit pointer (DI on amd64) is at 84(SP).
 
28
// The saved data pointer (SI on amd64) is at 88(SP).
 
29
 
 
30
#define LOAD(index, e) \
 
31
        MOVL    88(SP), SI; \
 
32
        MOVL    (index*4)(SI), DI; \
 
33
        BSWAPL  DI; \
 
34
        MOVL    DI, (index*4)(SP); \
 
35
        ADDL    DI, e
 
36
 
 
37
#define SHUFFLE(index, e) \
 
38
        MOVL    (((index)&0xf)*4)(SP), DI; \
 
39
        XORL    (((index-3)&0xf)*4)(SP), DI; \
 
40
        XORL    (((index-8)&0xf)*4)(SP), DI; \
 
41
        XORL    (((index-14)&0xf)*4)(SP), DI; \
 
42
        ROLL    $1, DI; \
 
43
        MOVL    DI, (((index)&0xf)*4)(SP); \
 
44
        ADDL    DI, e
 
45
 
 
46
#define FUNC1(a, b, c, d, e) \
 
47
        MOVL    b, SI; \
 
48
        ANDL    c, SI; \
 
49
        MOVL    b, DI; \
 
50
        NOTL    DI; \
 
51
        ANDL    d, DI; \
 
52
        ORL     SI, DI
 
53
 
 
54
#define FUNC2(a, b, c, d, e) \
 
55
        MOVL    b, DI; \
 
56
        XORL    c, DI; \
 
57
        XORL    d, DI
 
58
 
 
59
#define FUNC3(a, b, c, d, e) \
 
60
        MOVL    b, SI; \
 
61
        ORL     c, SI; \
 
62
        ANDL    d, SI; \
 
63
        MOVL    b, DI; \
 
64
        ANDL    c, DI; \
 
65
        ORL     SI, DI
 
66
 
 
67
#define FUNC4 FUNC2
 
68
 
 
69
#define MIX(a, b, c, d, e, const) \
 
70
        ROLL    $30, b; \
 
71
        ADDL    DI, e; \
 
72
        MOVL    a, SI; \
 
73
        ROLL    $5, SI; \
 
74
        LEAL    const(e)(SI*1), e
 
75
 
 
76
#define ROUND1(a, b, c, d, e, index) \
 
77
        LOAD(index, e); \
 
78
        FUNC1(a, b, c, d, e); \
 
79
        MIX(a, b, c, d, e, 0x5A827999)
 
80
 
 
81
#define ROUND1x(a, b, c, d, e, index) \
 
82
        SHUFFLE(index, e); \
 
83
        FUNC1(a, b, c, d, e); \
 
84
        MIX(a, b, c, d, e, 0x5A827999)
 
85
 
 
86
#define ROUND2(a, b, c, d, e, index) \
 
87
        SHUFFLE(index, e); \
 
88
        FUNC2(a, b, c, d, e); \
 
89
        MIX(a, b, c, d, e, 0x6ED9EBA1)
 
90
 
 
91
#define ROUND3(a, b, c, d, e, index) \
 
92
        SHUFFLE(index, e); \
 
93
        FUNC3(a, b, c, d, e); \
 
94
        MIX(a, b, c, d, e, 0x8F1BBCDC)
 
95
 
 
96
#define ROUND4(a, b, c, d, e, index) \
 
97
        SHUFFLE(index, e); \
 
98
        FUNC4(a, b, c, d, e); \
 
99
        MIX(a, b, c, d, e, 0xCA62C1D6)
 
100
 
 
101
// func block(dig *digest, p []byte)
 
102
TEXT ·block(SB),7,$92-16
 
103
        MOVL    dig+0(FP),      BP
 
104
        MOVL    p+4(FP),        SI
 
105
        MOVL    p_len+8(FP),    DX
 
106
        SHRL    $6,             DX
 
107
        SHLL    $6,             DX
 
108
        
 
109
        LEAL    (SI)(DX*1),     DI
 
110
        MOVL    (0*4)(BP),      AX
 
111
        MOVL    (1*4)(BP),      BX
 
112
        MOVL    (2*4)(BP),      CX
 
113
        MOVL    (3*4)(BP),      DX
 
114
        MOVL    (4*4)(BP),      BP
 
115
 
 
116
        CMPL    SI,             DI
 
117
        JEQ     end
 
118
 
 
119
        MOVL    DI,     84(SP)
 
120
 
 
121
loop:
 
122
        MOVL    SI,     88(SP)
 
123
 
 
124
        MOVL    AX,     64(SP)
 
125
        MOVL    BX,     68(SP)
 
126
        MOVL    CX,     72(SP)
 
127
        MOVL    DX,     76(SP)
 
128
        MOVL    BP,     80(SP)
 
129
 
 
130
        ROUND1(AX, BX, CX, DX, BP, 0)
 
131
        ROUND1(BP, AX, BX, CX, DX, 1)
 
132
        ROUND1(DX, BP, AX, BX, CX, 2)
 
133
        ROUND1(CX, DX, BP, AX, BX, 3)
 
134
        ROUND1(BX, CX, DX, BP, AX, 4)
 
135
        ROUND1(AX, BX, CX, DX, BP, 5)
 
136
        ROUND1(BP, AX, BX, CX, DX, 6)
 
137
        ROUND1(DX, BP, AX, BX, CX, 7)
 
138
        ROUND1(CX, DX, BP, AX, BX, 8)
 
139
        ROUND1(BX, CX, DX, BP, AX, 9)
 
140
        ROUND1(AX, BX, CX, DX, BP, 10)
 
141
        ROUND1(BP, AX, BX, CX, DX, 11)
 
142
        ROUND1(DX, BP, AX, BX, CX, 12)
 
143
        ROUND1(CX, DX, BP, AX, BX, 13)
 
144
        ROUND1(BX, CX, DX, BP, AX, 14)
 
145
        ROUND1(AX, BX, CX, DX, BP, 15)
 
146
 
 
147
        ROUND1x(BP, AX, BX, CX, DX, 16)
 
148
        ROUND1x(DX, BP, AX, BX, CX, 17)
 
149
        ROUND1x(CX, DX, BP, AX, BX, 18)
 
150
        ROUND1x(BX, CX, DX, BP, AX, 19)
 
151
        
 
152
        ROUND2(AX, BX, CX, DX, BP, 20)
 
153
        ROUND2(BP, AX, BX, CX, DX, 21)
 
154
        ROUND2(DX, BP, AX, BX, CX, 22)
 
155
        ROUND2(CX, DX, BP, AX, BX, 23)
 
156
        ROUND2(BX, CX, DX, BP, AX, 24)
 
157
        ROUND2(AX, BX, CX, DX, BP, 25)
 
158
        ROUND2(BP, AX, BX, CX, DX, 26)
 
159
        ROUND2(DX, BP, AX, BX, CX, 27)
 
160
        ROUND2(CX, DX, BP, AX, BX, 28)
 
161
        ROUND2(BX, CX, DX, BP, AX, 29)
 
162
        ROUND2(AX, BX, CX, DX, BP, 30)
 
163
        ROUND2(BP, AX, BX, CX, DX, 31)
 
164
        ROUND2(DX, BP, AX, BX, CX, 32)
 
165
        ROUND2(CX, DX, BP, AX, BX, 33)
 
166
        ROUND2(BX, CX, DX, BP, AX, 34)
 
167
        ROUND2(AX, BX, CX, DX, BP, 35)
 
168
        ROUND2(BP, AX, BX, CX, DX, 36)
 
169
        ROUND2(DX, BP, AX, BX, CX, 37)
 
170
        ROUND2(CX, DX, BP, AX, BX, 38)
 
171
        ROUND2(BX, CX, DX, BP, AX, 39)
 
172
        
 
173
        ROUND3(AX, BX, CX, DX, BP, 40)
 
174
        ROUND3(BP, AX, BX, CX, DX, 41)
 
175
        ROUND3(DX, BP, AX, BX, CX, 42)
 
176
        ROUND3(CX, DX, BP, AX, BX, 43)
 
177
        ROUND3(BX, CX, DX, BP, AX, 44)
 
178
        ROUND3(AX, BX, CX, DX, BP, 45)
 
179
        ROUND3(BP, AX, BX, CX, DX, 46)
 
180
        ROUND3(DX, BP, AX, BX, CX, 47)
 
181
        ROUND3(CX, DX, BP, AX, BX, 48)
 
182
        ROUND3(BX, CX, DX, BP, AX, 49)
 
183
        ROUND3(AX, BX, CX, DX, BP, 50)
 
184
        ROUND3(BP, AX, BX, CX, DX, 51)
 
185
        ROUND3(DX, BP, AX, BX, CX, 52)
 
186
        ROUND3(CX, DX, BP, AX, BX, 53)
 
187
        ROUND3(BX, CX, DX, BP, AX, 54)
 
188
        ROUND3(AX, BX, CX, DX, BP, 55)
 
189
        ROUND3(BP, AX, BX, CX, DX, 56)
 
190
        ROUND3(DX, BP, AX, BX, CX, 57)
 
191
        ROUND3(CX, DX, BP, AX, BX, 58)
 
192
        ROUND3(BX, CX, DX, BP, AX, 59)
 
193
        
 
194
        ROUND4(AX, BX, CX, DX, BP, 60)
 
195
        ROUND4(BP, AX, BX, CX, DX, 61)
 
196
        ROUND4(DX, BP, AX, BX, CX, 62)
 
197
        ROUND4(CX, DX, BP, AX, BX, 63)
 
198
        ROUND4(BX, CX, DX, BP, AX, 64)
 
199
        ROUND4(AX, BX, CX, DX, BP, 65)
 
200
        ROUND4(BP, AX, BX, CX, DX, 66)
 
201
        ROUND4(DX, BP, AX, BX, CX, 67)
 
202
        ROUND4(CX, DX, BP, AX, BX, 68)
 
203
        ROUND4(BX, CX, DX, BP, AX, 69)
 
204
        ROUND4(AX, BX, CX, DX, BP, 70)
 
205
        ROUND4(BP, AX, BX, CX, DX, 71)
 
206
        ROUND4(DX, BP, AX, BX, CX, 72)
 
207
        ROUND4(CX, DX, BP, AX, BX, 73)
 
208
        ROUND4(BX, CX, DX, BP, AX, 74)
 
209
        ROUND4(AX, BX, CX, DX, BP, 75)
 
210
        ROUND4(BP, AX, BX, CX, DX, 76)
 
211
        ROUND4(DX, BP, AX, BX, CX, 77)
 
212
        ROUND4(CX, DX, BP, AX, BX, 78)
 
213
        ROUND4(BX, CX, DX, BP, AX, 79)
 
214
 
 
215
        ADDL    64(SP), AX
 
216
        ADDL    68(SP), BX
 
217
        ADDL    72(SP), CX
 
218
        ADDL    76(SP), DX
 
219
        ADDL    80(SP), BP
 
220
 
 
221
        MOVL    88(SP), SI
 
222
        ADDL    $64, SI
 
223
        CMPL    SI, 84(SP)
 
224
        JB      loop
 
225
 
 
226
end:
 
227
        MOVL    dig+0(FP), DI
 
228
        MOVL    AX, (0*4)(DI)
 
229
        MOVL    BX, (1*4)(DI)
 
230
        MOVL    CX, (2*4)(DI)
 
231
        MOVL    DX, (3*4)(DI)
 
232
        MOVL    BP, (4*4)(DI)
 
233
        RET