← Back to branch summary

~ubuntu-branches/ubuntu/utopic/clamav/utopic-security

« back to all changes in this revision

Viewing changes to libclamav/tomsfastmath/sqr/fp_sqr_comba_24.c

  • Committer: Package Import Robot
  • Author(s): Scott Kitterman
  • Date: 2014-02-01 11:06:17 UTC
  • mfrom: (0.35.37 sid)
  • Revision ID: package-import@ubuntu.com-20140201110617-33h2xxk09dep0ui4
Tags: 0.98.1+dfsg-1ubuntu1
* Merge from Debian unstable.  Remaining changes:
  - Drop build-dep on electric-fence (in Universe)
  - Add apparmor profiles for clamd and freshclam along with maintainer
    script changes
  - Add autopkgtest

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/tomsfastmath/sqr/fp_sqr_comba_24.c
 
1
#define TFM_DEFINES
 
2
#include "fp_sqr_comba.c"
 
3
 
 
4
#ifdef TFM_SQR24
 
5
void fp_sqr_comba24(fp_int *A, fp_int *B)
 
6
{
 
7
   fp_digit *a, b[48], c0, c1, c2, sc0, sc1, sc2;
 
8
#ifdef TFM_ISO
 
9
   fp_word tt;
 
10
#endif
 
11
 
 
12
   a = A->dp;
 
13
   COMBA_START; 
 
14
 
 
15
   /* clear carries */
 
16
   CLEAR_CARRY;
 
17
 
 
18
   /* output 0 */
 
19
   SQRADD(a[0],a[0]);
 
20
   COMBA_STORE(b[0]);
 
21
 
 
22
   /* output 1 */
 
23
   CARRY_FORWARD;
 
24
   SQRADD2(a[0], a[1]); 
 
25
   COMBA_STORE(b[1]);
 
26
 
 
27
   /* output 2 */
 
28
   CARRY_FORWARD;
 
29
   SQRADD2(a[0], a[2]); SQRADD(a[1], a[1]); 
 
30
   COMBA_STORE(b[2]);
 
31
 
 
32
   /* output 3 */
 
33
   CARRY_FORWARD;
 
34
   SQRADD2(a[0], a[3]); SQRADD2(a[1], a[2]); 
 
35
   COMBA_STORE(b[3]);
 
36
 
 
37
   /* output 4 */
 
38
   CARRY_FORWARD;
 
39
   SQRADD2(a[0], a[4]); SQRADD2(a[1], a[3]); SQRADD(a[2], a[2]); 
 
40
   COMBA_STORE(b[4]);
 
41
 
 
42
   /* output 5 */
 
43
   CARRY_FORWARD;
 
44
   SQRADDSC(a[0], a[5]); SQRADDAC(a[1], a[4]); SQRADDAC(a[2], a[3]); SQRADDDB; 
 
45
   COMBA_STORE(b[5]);
 
46
 
 
47
   /* output 6 */
 
48
   CARRY_FORWARD;
 
49
   SQRADDSC(a[0], a[6]); SQRADDAC(a[1], a[5]); SQRADDAC(a[2], a[4]); SQRADDDB; SQRADD(a[3], a[3]); 
 
50
   COMBA_STORE(b[6]);
 
51
 
 
52
   /* output 7 */
 
53
   CARRY_FORWARD;
 
54
   SQRADDSC(a[0], a[7]); SQRADDAC(a[1], a[6]); SQRADDAC(a[2], a[5]); SQRADDAC(a[3], a[4]); SQRADDDB; 
 
55
   COMBA_STORE(b[7]);
 
56
 
 
57
   /* output 8 */
 
58
   CARRY_FORWARD;
 
59
   SQRADDSC(a[0], a[8]); SQRADDAC(a[1], a[7]); SQRADDAC(a[2], a[6]); SQRADDAC(a[3], a[5]); SQRADDDB; SQRADD(a[4], a[4]); 
 
60
   COMBA_STORE(b[8]);
 
61
 
 
62
   /* output 9 */
 
63
   CARRY_FORWARD;
 
64
   SQRADDSC(a[0], a[9]); SQRADDAC(a[1], a[8]); SQRADDAC(a[2], a[7]); SQRADDAC(a[3], a[6]); SQRADDAC(a[4], a[5]); SQRADDDB; 
 
65
   COMBA_STORE(b[9]);
 
66
 
 
67
   /* output 10 */
 
68
   CARRY_FORWARD;
 
69
   SQRADDSC(a[0], a[10]); SQRADDAC(a[1], a[9]); SQRADDAC(a[2], a[8]); SQRADDAC(a[3], a[7]); SQRADDAC(a[4], a[6]); SQRADDDB; SQRADD(a[5], a[5]); 
 
70
   COMBA_STORE(b[10]);
 
71
 
 
72
   /* output 11 */
 
73
   CARRY_FORWARD;
 
74
   SQRADDSC(a[0], a[11]); SQRADDAC(a[1], a[10]); SQRADDAC(a[2], a[9]); SQRADDAC(a[3], a[8]); SQRADDAC(a[4], a[7]); SQRADDAC(a[5], a[6]); SQRADDDB; 
 
75
   COMBA_STORE(b[11]);
 
76
 
 
77
   /* output 12 */
 
78
   CARRY_FORWARD;
 
79
   SQRADDSC(a[0], a[12]); SQRADDAC(a[1], a[11]); SQRADDAC(a[2], a[10]); SQRADDAC(a[3], a[9]); SQRADDAC(a[4], a[8]); SQRADDAC(a[5], a[7]); SQRADDDB; SQRADD(a[6], a[6]); 
 
80
   COMBA_STORE(b[12]);
 
81
 
 
82
   /* output 13 */
 
83
   CARRY_FORWARD;
 
84
   SQRADDSC(a[0], a[13]); SQRADDAC(a[1], a[12]); SQRADDAC(a[2], a[11]); SQRADDAC(a[3], a[10]); SQRADDAC(a[4], a[9]); SQRADDAC(a[5], a[8]); SQRADDAC(a[6], a[7]); SQRADDDB; 
 
85
   COMBA_STORE(b[13]);
 
86
 
 
87
   /* output 14 */
 
88
   CARRY_FORWARD;
 
89
   SQRADDSC(a[0], a[14]); SQRADDAC(a[1], a[13]); SQRADDAC(a[2], a[12]); SQRADDAC(a[3], a[11]); SQRADDAC(a[4], a[10]); SQRADDAC(a[5], a[9]); SQRADDAC(a[6], a[8]); SQRADDDB; SQRADD(a[7], a[7]); 
 
90
   COMBA_STORE(b[14]);
 
91
 
 
92
   /* output 15 */
 
93
   CARRY_FORWARD;
 
94
   SQRADDSC(a[0], a[15]); SQRADDAC(a[1], a[14]); SQRADDAC(a[2], a[13]); SQRADDAC(a[3], a[12]); SQRADDAC(a[4], a[11]); SQRADDAC(a[5], a[10]); SQRADDAC(a[6], a[9]); SQRADDAC(a[7], a[8]); SQRADDDB; 
 
95
   COMBA_STORE(b[15]);
 
96
 
 
97
   /* output 16 */
 
98
   CARRY_FORWARD;
 
99
   SQRADDSC(a[0], a[16]); SQRADDAC(a[1], a[15]); SQRADDAC(a[2], a[14]); SQRADDAC(a[3], a[13]); SQRADDAC(a[4], a[12]); SQRADDAC(a[5], a[11]); SQRADDAC(a[6], a[10]); SQRADDAC(a[7], a[9]); SQRADDDB; SQRADD(a[8], a[8]); 
 
100
   COMBA_STORE(b[16]);
 
101
 
 
102
   /* output 17 */
 
103
   CARRY_FORWARD;
 
104
   SQRADDSC(a[0], a[17]); SQRADDAC(a[1], a[16]); SQRADDAC(a[2], a[15]); SQRADDAC(a[3], a[14]); SQRADDAC(a[4], a[13]); SQRADDAC(a[5], a[12]); SQRADDAC(a[6], a[11]); SQRADDAC(a[7], a[10]); SQRADDAC(a[8], a[9]); SQRADDDB; 
 
105
   COMBA_STORE(b[17]);
 
106
 
 
107
   /* output 18 */
 
108
   CARRY_FORWARD;
 
109
   SQRADDSC(a[0], a[18]); SQRADDAC(a[1], a[17]); SQRADDAC(a[2], a[16]); SQRADDAC(a[3], a[15]); SQRADDAC(a[4], a[14]); SQRADDAC(a[5], a[13]); SQRADDAC(a[6], a[12]); SQRADDAC(a[7], a[11]); SQRADDAC(a[8], a[10]); SQRADDDB; SQRADD(a[9], a[9]); 
 
110
   COMBA_STORE(b[18]);
 
111
 
 
112
   /* output 19 */
 
113
   CARRY_FORWARD;
 
114
   SQRADDSC(a[0], a[19]); SQRADDAC(a[1], a[18]); SQRADDAC(a[2], a[17]); SQRADDAC(a[3], a[16]); SQRADDAC(a[4], a[15]); SQRADDAC(a[5], a[14]); SQRADDAC(a[6], a[13]); SQRADDAC(a[7], a[12]); SQRADDAC(a[8], a[11]); SQRADDAC(a[9], a[10]); SQRADDDB; 
 
115
   COMBA_STORE(b[19]);
 
116
 
 
117
   /* output 20 */
 
118
   CARRY_FORWARD;
 
119
   SQRADDSC(a[0], a[20]); SQRADDAC(a[1], a[19]); SQRADDAC(a[2], a[18]); SQRADDAC(a[3], a[17]); SQRADDAC(a[4], a[16]); SQRADDAC(a[5], a[15]); SQRADDAC(a[6], a[14]); SQRADDAC(a[7], a[13]); SQRADDAC(a[8], a[12]); SQRADDAC(a[9], a[11]); SQRADDDB; SQRADD(a[10], a[10]); 
 
120
   COMBA_STORE(b[20]);
 
121
 
 
122
   /* output 21 */
 
123
   CARRY_FORWARD;
 
124
   SQRADDSC(a[0], a[21]); SQRADDAC(a[1], a[20]); SQRADDAC(a[2], a[19]); SQRADDAC(a[3], a[18]); SQRADDAC(a[4], a[17]); SQRADDAC(a[5], a[16]); SQRADDAC(a[6], a[15]); SQRADDAC(a[7], a[14]); SQRADDAC(a[8], a[13]); SQRADDAC(a[9], a[12]); SQRADDAC(a[10], a[11]); SQRADDDB; 
 
125
   COMBA_STORE(b[21]);
 
126
 
 
127
   /* output 22 */
 
128
   CARRY_FORWARD;
 
129
   SQRADDSC(a[0], a[22]); SQRADDAC(a[1], a[21]); SQRADDAC(a[2], a[20]); SQRADDAC(a[3], a[19]); SQRADDAC(a[4], a[18]); SQRADDAC(a[5], a[17]); SQRADDAC(a[6], a[16]); SQRADDAC(a[7], a[15]); SQRADDAC(a[8], a[14]); SQRADDAC(a[9], a[13]); SQRADDAC(a[10], a[12]); SQRADDDB; SQRADD(a[11], a[11]); 
 
130
   COMBA_STORE(b[22]);
 
131
 
 
132
   /* output 23 */
 
133
   CARRY_FORWARD;
 
134
   SQRADDSC(a[0], a[23]); SQRADDAC(a[1], a[22]); SQRADDAC(a[2], a[21]); SQRADDAC(a[3], a[20]); SQRADDAC(a[4], a[19]); SQRADDAC(a[5], a[18]); SQRADDAC(a[6], a[17]); SQRADDAC(a[7], a[16]); SQRADDAC(a[8], a[15]); SQRADDAC(a[9], a[14]); SQRADDAC(a[10], a[13]); SQRADDAC(a[11], a[12]); SQRADDDB; 
 
135
   COMBA_STORE(b[23]);
 
136
 
 
137
   /* output 24 */
 
138
   CARRY_FORWARD;
 
139
   SQRADDSC(a[1], a[23]); SQRADDAC(a[2], a[22]); SQRADDAC(a[3], a[21]); SQRADDAC(a[4], a[20]); SQRADDAC(a[5], a[19]); SQRADDAC(a[6], a[18]); SQRADDAC(a[7], a[17]); SQRADDAC(a[8], a[16]); SQRADDAC(a[9], a[15]); SQRADDAC(a[10], a[14]); SQRADDAC(a[11], a[13]); SQRADDDB; SQRADD(a[12], a[12]); 
 
140
   COMBA_STORE(b[24]);
 
141
 
 
142
   /* output 25 */
 
143
   CARRY_FORWARD;
 
144
   SQRADDSC(a[2], a[23]); SQRADDAC(a[3], a[22]); SQRADDAC(a[4], a[21]); SQRADDAC(a[5], a[20]); SQRADDAC(a[6], a[19]); SQRADDAC(a[7], a[18]); SQRADDAC(a[8], a[17]); SQRADDAC(a[9], a[16]); SQRADDAC(a[10], a[15]); SQRADDAC(a[11], a[14]); SQRADDAC(a[12], a[13]); SQRADDDB; 
 
145
   COMBA_STORE(b[25]);
 
146
 
 
147
   /* output 26 */
 
148
   CARRY_FORWARD;
 
149
   SQRADDSC(a[3], a[23]); SQRADDAC(a[4], a[22]); SQRADDAC(a[5], a[21]); SQRADDAC(a[6], a[20]); SQRADDAC(a[7], a[19]); SQRADDAC(a[8], a[18]); SQRADDAC(a[9], a[17]); SQRADDAC(a[10], a[16]); SQRADDAC(a[11], a[15]); SQRADDAC(a[12], a[14]); SQRADDDB; SQRADD(a[13], a[13]); 
 
150
   COMBA_STORE(b[26]);
 
151
 
 
152
   /* output 27 */
 
153
   CARRY_FORWARD;
 
154
   SQRADDSC(a[4], a[23]); SQRADDAC(a[5], a[22]); SQRADDAC(a[6], a[21]); SQRADDAC(a[7], a[20]); SQRADDAC(a[8], a[19]); SQRADDAC(a[9], a[18]); SQRADDAC(a[10], a[17]); SQRADDAC(a[11], a[16]); SQRADDAC(a[12], a[15]); SQRADDAC(a[13], a[14]); SQRADDDB; 
 
155
   COMBA_STORE(b[27]);
 
156
 
 
157
   /* output 28 */
 
158
   CARRY_FORWARD;
 
159
   SQRADDSC(a[5], a[23]); SQRADDAC(a[6], a[22]); SQRADDAC(a[7], a[21]); SQRADDAC(a[8], a[20]); SQRADDAC(a[9], a[19]); SQRADDAC(a[10], a[18]); SQRADDAC(a[11], a[17]); SQRADDAC(a[12], a[16]); SQRADDAC(a[13], a[15]); SQRADDDB; SQRADD(a[14], a[14]); 
 
160
   COMBA_STORE(b[28]);
 
161
 
 
162
   /* output 29 */
 
163
   CARRY_FORWARD;
 
164
   SQRADDSC(a[6], a[23]); SQRADDAC(a[7], a[22]); SQRADDAC(a[8], a[21]); SQRADDAC(a[9], a[20]); SQRADDAC(a[10], a[19]); SQRADDAC(a[11], a[18]); SQRADDAC(a[12], a[17]); SQRADDAC(a[13], a[16]); SQRADDAC(a[14], a[15]); SQRADDDB; 
 
165
   COMBA_STORE(b[29]);
 
166
 
 
167
   /* output 30 */
 
168
   CARRY_FORWARD;
 
169
   SQRADDSC(a[7], a[23]); SQRADDAC(a[8], a[22]); SQRADDAC(a[9], a[21]); SQRADDAC(a[10], a[20]); SQRADDAC(a[11], a[19]); SQRADDAC(a[12], a[18]); SQRADDAC(a[13], a[17]); SQRADDAC(a[14], a[16]); SQRADDDB; SQRADD(a[15], a[15]); 
 
170
   COMBA_STORE(b[30]);
 
171
 
 
172
   /* output 31 */
 
173
   CARRY_FORWARD;
 
174
   SQRADDSC(a[8], a[23]); SQRADDAC(a[9], a[22]); SQRADDAC(a[10], a[21]); SQRADDAC(a[11], a[20]); SQRADDAC(a[12], a[19]); SQRADDAC(a[13], a[18]); SQRADDAC(a[14], a[17]); SQRADDAC(a[15], a[16]); SQRADDDB; 
 
175
   COMBA_STORE(b[31]);
 
176
 
 
177
   /* output 32 */
 
178
   CARRY_FORWARD;
 
179
   SQRADDSC(a[9], a[23]); SQRADDAC(a[10], a[22]); SQRADDAC(a[11], a[21]); SQRADDAC(a[12], a[20]); SQRADDAC(a[13], a[19]); SQRADDAC(a[14], a[18]); SQRADDAC(a[15], a[17]); SQRADDDB; SQRADD(a[16], a[16]); 
 
180
   COMBA_STORE(b[32]);
 
181
 
 
182
   /* output 33 */
 
183
   CARRY_FORWARD;
 
184
   SQRADDSC(a[10], a[23]); SQRADDAC(a[11], a[22]); SQRADDAC(a[12], a[21]); SQRADDAC(a[13], a[20]); SQRADDAC(a[14], a[19]); SQRADDAC(a[15], a[18]); SQRADDAC(a[16], a[17]); SQRADDDB; 
 
185
   COMBA_STORE(b[33]);
 
186
 
 
187
   /* output 34 */
 
188
   CARRY_FORWARD;
 
189
   SQRADDSC(a[11], a[23]); SQRADDAC(a[12], a[22]); SQRADDAC(a[13], a[21]); SQRADDAC(a[14], a[20]); SQRADDAC(a[15], a[19]); SQRADDAC(a[16], a[18]); SQRADDDB; SQRADD(a[17], a[17]); 
 
190
   COMBA_STORE(b[34]);
 
191
 
 
192
   /* output 35 */
 
193
   CARRY_FORWARD;
 
194
   SQRADDSC(a[12], a[23]); SQRADDAC(a[13], a[22]); SQRADDAC(a[14], a[21]); SQRADDAC(a[15], a[20]); SQRADDAC(a[16], a[19]); SQRADDAC(a[17], a[18]); SQRADDDB; 
 
195
   COMBA_STORE(b[35]);
 
196
 
 
197
   /* output 36 */
 
198
   CARRY_FORWARD;
 
199
   SQRADDSC(a[13], a[23]); SQRADDAC(a[14], a[22]); SQRADDAC(a[15], a[21]); SQRADDAC(a[16], a[20]); SQRADDAC(a[17], a[19]); SQRADDDB; SQRADD(a[18], a[18]); 
 
200
   COMBA_STORE(b[36]);
 
201
 
 
202
   /* output 37 */
 
203
   CARRY_FORWARD;
 
204
   SQRADDSC(a[14], a[23]); SQRADDAC(a[15], a[22]); SQRADDAC(a[16], a[21]); SQRADDAC(a[17], a[20]); SQRADDAC(a[18], a[19]); SQRADDDB; 
 
205
   COMBA_STORE(b[37]);
 
206
 
 
207
   /* output 38 */
 
208
   CARRY_FORWARD;
 
209
   SQRADDSC(a[15], a[23]); SQRADDAC(a[16], a[22]); SQRADDAC(a[17], a[21]); SQRADDAC(a[18], a[20]); SQRADDDB; SQRADD(a[19], a[19]); 
 
210
   COMBA_STORE(b[38]);
 
211
 
 
212
   /* output 39 */
 
213
   CARRY_FORWARD;
 
214
   SQRADDSC(a[16], a[23]); SQRADDAC(a[17], a[22]); SQRADDAC(a[18], a[21]); SQRADDAC(a[19], a[20]); SQRADDDB; 
 
215
   COMBA_STORE(b[39]);
 
216
 
 
217
   /* output 40 */
 
218
   CARRY_FORWARD;
 
219
   SQRADDSC(a[17], a[23]); SQRADDAC(a[18], a[22]); SQRADDAC(a[19], a[21]); SQRADDDB; SQRADD(a[20], a[20]); 
 
220
   COMBA_STORE(b[40]);
 
221
 
 
222
   /* output 41 */
 
223
   CARRY_FORWARD;
 
224
   SQRADDSC(a[18], a[23]); SQRADDAC(a[19], a[22]); SQRADDAC(a[20], a[21]); SQRADDDB; 
 
225
   COMBA_STORE(b[41]);
 
226
 
 
227
   /* output 42 */
 
228
   CARRY_FORWARD;
 
229
   SQRADD2(a[19], a[23]); SQRADD2(a[20], a[22]); SQRADD(a[21], a[21]); 
 
230
   COMBA_STORE(b[42]);
 
231
 
 
232
   /* output 43 */
 
233
   CARRY_FORWARD;
 
234
   SQRADD2(a[20], a[23]); SQRADD2(a[21], a[22]); 
 
235
   COMBA_STORE(b[43]);
 
236
 
 
237
   /* output 44 */
 
238
   CARRY_FORWARD;
 
239
   SQRADD2(a[21], a[23]); SQRADD(a[22], a[22]); 
 
240
   COMBA_STORE(b[44]);
 
241
 
 
242
   /* output 45 */
 
243
   CARRY_FORWARD;
 
244
   SQRADD2(a[22], a[23]); 
 
245
   COMBA_STORE(b[45]);
 
246
 
 
247
   /* output 46 */
 
248
   CARRY_FORWARD;
 
249
   SQRADD(a[23], a[23]); 
 
250
   COMBA_STORE(b[46]);
 
251
   COMBA_STORE2(b[47]);
 
252
   COMBA_FINI;
 
253
 
 
254
   B->used = 48;
 
255
   B->sign = FP_ZPOS;
 
256
   memcpy(B->dp, b, 48 * sizeof(fp_digit));
 
257
   fp_clamp(B);
 
258
}
 
259
#endif
 
260
 
 
261
 
 
262
/* $Source: /cvs/libtom/tomsfastmath/src/sqr/fp_sqr_comba_24.c,v $ */
 
263
/* $Revision: 1.2 $ */
 
264
/* $Date: 2007/02/17 03:39:01 $ */