← Back to branch summary

~ubuntu-branches/ubuntu/lucid/exim4/lucid-updates

« back to all changes in this revision

Viewing changes to .pc/20_PDKIM-Upgrade-PolarSSL.diff/src/pdkim/bn_mul.h

  • Committer: Bazaar Package Importer
  • Author(s): Marc Deslauriers
  • Date: 2011-02-08 11:31:29 UTC
  • Revision ID: james.westby@ubuntu.com-20110208113129-ri8y5c2s6hurn80t
Tags: 4.71-3ubuntu1.1
https://launchpad.net/bugs/697934
https://launchpad.net/bugs/708023
https://launchpad.net/bugs/609620
https://launchpad.net/bugs/609620
* SECURITY UPDATE: local privilege escalation via alternate config file
  (LP: #697934)
  - debian/patches/80_CVE-2010-4345.patch: backport massive behaviour-
    altering changes from upstream git to fix issue.
  - debian/patches/81_CVE-2010-4345-docs.patch: backport documentation
    changes.
  - debian/patches/67_unnecessaryCopt.dpatch: Do not use exim's -C option
    in utility scripts. This would not work with ALT_CONFIG_PREFIX.
    Patch obtained from Debian's 4.69-9+lenny2.
  - Build with WHITELIST_D_MACROS=OUTGOING. After this security update,
    exim will not regain root privileges (usually necessary for local
    delivery) if the -D option was used. Macro identifiers listed in
    WHITELIST_D_MACROS are exempted from this restriction. mailscanner
    (4.79.11-2.2) uses -DOUTGOING.
  - Build with TRUSTED_CONFIG_LIST=/etc/exim4/trusted_configs. After this
    security update, exim will not re-gain root privileges (usually
    necessary for local delivery) if the -C option was used. This makes
    it impossible to start a fully functional damon with an alternate
    configuration file. /etc/exim4/trusted_configs (can) contain a list
    of filenames (one per line, full path given) to which this
    restriction does not apply.
  - debian/exim4-daemon-*.NEWS: Add description of changes. Thanks to
    Debian and Andreas Metzler for the text.
  - CVE-2010-4345
* SECURITY UPDATE: arbitrary file append via symlink attack (LP: #708023)
  - debian/patches/82_CVE-2011-0017.patch: check setuid and setgid return
    codes in src/exim.c, src/log.c.
  - CVE-2011-0017
* SECURITY UPDATE: denial of service and possible arbitrary code
  execution via hard link to another user's file (LP: #609620)
  - debian/patches/CVE-2010-2023.patch: check for links in
    src/transports/appendfile.c.
  - CVE-2010-2023
* SECURITY UPDATE: denial of service and possible arbitrary code
  execution via symlink on a lock file (LP: #609620)
  - debian/patches/CVE-2010-2024.patch: improve lock file handling in
    src/exim_lock.c, src/transports/appendfile.c.
  - CVE-2010-2024
* debian/rules: disable debconf-updatepo so the security update doesn't
  alter translations.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/20_PDKIM-Upgrade-PolarSSL.diff/src/pdkim/bn_mul.h
 
1
/**
 
2
 * \file bn_mul.h
 
3
 *
 
4
 *  Based on XySSL: Copyright (C) 2006-2008  Christophe Devine
 
5
 *
 
6
 *  Copyright (C) 2009  Paul Bakker <polarssl_maintainer at polarssl dot org>
 
7
 *
 
8
 *  This program is free software; you can redistribute it and/or modify
 
9
 *  it under the terms of the GNU General Public License as published by
 
10
 *  the Free Software Foundation; either version 2 of the License, or
 
11
 *  (at your option) any later version.
 
12
 *
 
13
 *  This program is distributed in the hope that it will be useful,
 
14
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
16
 *  GNU General Public License for more details.
 
17
 *
 
18
 *  You should have received a copy of the GNU General Public License along
 
19
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 
20
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
21
 */
 
22
/*
 
23
 *      Multiply source vector [s] with b, add result
 
24
 *       to destination vector [d] and set carry c.
 
25
 *
 
26
 *      Currently supports:
 
27
 *
 
28
 *         . IA-32 (386+)         . AMD64 / EM64T
 
29
 *         . IA-32 (SSE2)         . Motorola 68000
 
30
 *         . PowerPC, 32-bit      . MicroBlaze
 
31
 *         . PowerPC, 64-bit      . TriCore
 
32
 *         . SPARC v8             . ARM v3+
 
33
 *         . Alpha                . MIPS32
 
34
 *         . C, longlong          . C, generic
 
35
 */
 
36
 
 
37
/* $Cambridge: exim/exim-src/src/pdkim/bn_mul.h,v 1.2 2009/06/10 07:34:05 tom Exp $ */
 
38
 
 
39
#ifndef POLARSSL_BN_MUL_H
 
40
#define POLARSSL_BN_MUL_H
 
41
 
 
42
#if defined(POLARSSL_HAVE_ASM)
 
43
 
 
44
#if defined(__GNUC__)
 
45
#if defined(__i386__)
 
46
 
 
47
#define MULADDC_INIT                            \
 
48
    asm( "movl   %%ebx, %0      " : "=m" (t));  \
 
49
    asm( "movl   %0, %%esi      " :: "m" (s));  \
 
50
    asm( "movl   %0, %%edi      " :: "m" (d));  \
 
51
    asm( "movl   %0, %%ecx      " :: "m" (c));  \
 
52
    asm( "movl   %0, %%ebx      " :: "m" (b));
 
53
 
 
54
#define MULADDC_CORE                            \
 
55
    asm( "lodsl                 " );            \
 
56
    asm( "mull   %ebx           " );            \
 
57
    asm( "addl   %ecx,   %eax   " );            \
 
58
    asm( "adcl   $0,     %edx   " );            \
 
59
    asm( "addl   (%edi), %eax   " );            \
 
60
    asm( "adcl   $0,     %edx   " );            \
 
61
    asm( "movl   %edx,   %ecx   " );            \
 
62
    asm( "stosl                 " );
 
63
 
 
64
#if defined(POLARSSL_HAVE_SSE2)
 
65
 
 
66
#define MULADDC_HUIT                            \
 
67
    asm( "movd     %ecx,     %mm1     " );      \
 
68
    asm( "movd     %ebx,     %mm0     " );      \
 
69
    asm( "movd     (%edi),   %mm3     " );      \
 
70
    asm( "paddq    %mm3,     %mm1     " );      \
 
71
    asm( "movd     (%esi),   %mm2     " );      \
 
72
    asm( "pmuludq  %mm0,     %mm2     " );      \
 
73
    asm( "movd     4(%esi),  %mm4     " );      \
 
74
    asm( "pmuludq  %mm0,     %mm4     " );      \
 
75
    asm( "movd     8(%esi),  %mm6     " );      \
 
76
    asm( "pmuludq  %mm0,     %mm6     " );      \
 
77
    asm( "movd     12(%esi), %mm7     " );      \
 
78
    asm( "pmuludq  %mm0,     %mm7     " );      \
 
79
    asm( "paddq    %mm2,     %mm1     " );      \
 
80
    asm( "movd     4(%edi),  %mm3     " );      \
 
81
    asm( "paddq    %mm4,     %mm3     " );      \
 
82
    asm( "movd     8(%edi),  %mm5     " );      \
 
83
    asm( "paddq    %mm6,     %mm5     " );      \
 
84
    asm( "movd     12(%edi), %mm4     " );      \
 
85
    asm( "paddq    %mm4,     %mm7     " );      \
 
86
    asm( "movd     %mm1,     (%edi)   " );      \
 
87
    asm( "movd     16(%esi), %mm2     " );      \
 
88
    asm( "pmuludq  %mm0,     %mm2     " );      \
 
89
    asm( "psrlq    $32,      %mm1     " );      \
 
90
    asm( "movd     20(%esi), %mm4     " );      \
 
91
    asm( "pmuludq  %mm0,     %mm4     " );      \
 
92
    asm( "paddq    %mm3,     %mm1     " );      \
 
93
    asm( "movd     24(%esi), %mm6     " );      \
 
94
    asm( "pmuludq  %mm0,     %mm6     " );      \
 
95
    asm( "movd     %mm1,     4(%edi)  " );      \
 
96
    asm( "psrlq    $32,      %mm1     " );      \
 
97
    asm( "movd     28(%esi), %mm3     " );      \
 
98
    asm( "pmuludq  %mm0,     %mm3     " );      \
 
99
    asm( "paddq    %mm5,     %mm1     " );      \
 
100
    asm( "movd     16(%edi), %mm5     " );      \
 
101
    asm( "paddq    %mm5,     %mm2     " );      \
 
102
    asm( "movd     %mm1,     8(%edi)  " );      \
 
103
    asm( "psrlq    $32,      %mm1     " );      \
 
104
    asm( "paddq    %mm7,     %mm1     " );      \
 
105
    asm( "movd     20(%edi), %mm5     " );      \
 
106
    asm( "paddq    %mm5,     %mm4     " );      \
 
107
    asm( "movd     %mm1,     12(%edi) " );      \
 
108
    asm( "psrlq    $32,      %mm1     " );      \
 
109
    asm( "paddq    %mm2,     %mm1     " );      \
 
110
    asm( "movd     24(%edi), %mm5     " );      \
 
111
    asm( "paddq    %mm5,     %mm6     " );      \
 
112
    asm( "movd     %mm1,     16(%edi) " );      \
 
113
    asm( "psrlq    $32,      %mm1     " );      \
 
114
    asm( "paddq    %mm4,     %mm1     " );      \
 
115
    asm( "movd     28(%edi), %mm5     " );      \
 
116
    asm( "paddq    %mm5,     %mm3     " );      \
 
117
    asm( "movd     %mm1,     20(%edi) " );      \
 
118
    asm( "psrlq    $32,      %mm1     " );      \
 
119
    asm( "paddq    %mm6,     %mm1     " );      \
 
120
    asm( "movd     %mm1,     24(%edi) " );      \
 
121
    asm( "psrlq    $32,      %mm1     " );      \
 
122
    asm( "paddq    %mm3,     %mm1     " );      \
 
123
    asm( "movd     %mm1,     28(%edi) " );      \
 
124
    asm( "addl     $32,      %edi     " );      \
 
125
    asm( "addl     $32,      %esi     " );      \
 
126
    asm( "psrlq    $32,      %mm1     " );      \
 
127
    asm( "movd     %mm1,     %ecx     " );
 
128
 
 
129
#define MULADDC_STOP                            \
 
130
    asm( "emms                        " );      \
 
131
    asm( "movl   %0, %%ebx      " :: "m" (t));  \
 
132
    asm( "movl   %%ecx, %0      " : "=m" (c));  \
 
133
    asm( "movl   %%edi, %0      " : "=m" (d));  \
 
134
    asm( "movl   %%esi, %0      " : "=m" (s) :: \
 
135
    "eax", "ecx", "edx", "esi", "edi" );
 
136
 
 
137
#else
 
138
 
 
139
#define MULADDC_STOP                            \
 
140
    asm( "movl   %0, %%ebx      " :: "m" (t));  \
 
141
    asm( "movl   %%ecx, %0      " : "=m" (c));  \
 
142
    asm( "movl   %%edi, %0      " : "=m" (d));  \
 
143
    asm( "movl   %%esi, %0      " : "=m" (s) :: \
 
144
    "eax", "ecx", "edx", "esi", "edi" );
 
145
 
 
146
#endif /* SSE2 */
 
147
#endif /* i386 */
 
148
 
 
149
#if defined(__amd64__) || defined (__x86_64__)
 
150
 
 
151
#define MULADDC_INIT                            \
 
152
    asm( "movq   %0, %%rsi      " :: "m" (s));  \
 
153
    asm( "movq   %0, %%rdi      " :: "m" (d));  \
 
154
    asm( "movq   %0, %%rcx      " :: "m" (c));  \
 
155
    asm( "movq   %0, %%rbx      " :: "m" (b));  \
 
156
    asm( "xorq   %r8, %r8       " );
 
157
 
 
158
#define MULADDC_CORE                            \
 
159
    asm( "movq  (%rsi),%rax     " );            \
 
160
    asm( "mulq   %rbx           " );            \
 
161
    asm( "addq   $8,   %rsi     " );            \
 
162
    asm( "addq   %rcx, %rax     " );            \
 
163
    asm( "movq   %r8,  %rcx     " );            \
 
164
    asm( "adcq   $0,   %rdx     " );            \
 
165
    asm( "nop                   " );            \
 
166
    asm( "addq   %rax, (%rdi)   " );            \
 
167
    asm( "adcq   %rdx, %rcx     " );            \
 
168
    asm( "addq   $8,   %rdi     " );
 
169
 
 
170
#define MULADDC_STOP                            \
 
171
    asm( "movq   %%rcx, %0      " : "=m" (c));  \
 
172
    asm( "movq   %%rdi, %0      " : "=m" (d));  \
 
173
    asm( "movq   %%rsi, %0      " : "=m" (s) :: \
 
174
    "rax", "rcx", "rdx", "rbx", "rsi", "rdi", "r8" );
 
175
 
 
176
#endif /* AMD64 */
 
177
 
 
178
#if defined(__mc68020__) || defined(__mcpu32__)
 
179
 
 
180
#define MULADDC_INIT                            \
 
181
    asm( "movl   %0, %%a2       " :: "m" (s));  \
 
182
    asm( "movl   %0, %%a3       " :: "m" (d));  \
 
183
    asm( "movl   %0, %%d3       " :: "m" (c));  \
 
184
    asm( "movl   %0, %%d2       " :: "m" (b));  \
 
185
    asm( "moveq  #0, %d0        " );
 
186
 
 
187
#define MULADDC_CORE                            \
 
188
    asm( "movel  %a2@+, %d1     " );            \
 
189
    asm( "mulul  %d2, %d4:%d1   " );            \
 
190
    asm( "addl   %d3, %d1       " );            \
 
191
    asm( "addxl  %d0, %d4       " );            \
 
192
    asm( "moveq  #0,  %d3       " );            \
 
193
    asm( "addl   %d1, %a3@+     " );            \
 
194
    asm( "addxl  %d4, %d3       " );
 
195
 
 
196
#define MULADDC_STOP                            \
 
197
    asm( "movl   %%d3, %0       " : "=m" (c));  \
 
198
    asm( "movl   %%a3, %0       " : "=m" (d));  \
 
199
    asm( "movl   %%a2, %0       " : "=m" (s) :: \
 
200
    "d0", "d1", "d2", "d3", "d4", "a2", "a3" );
 
201
 
 
202
#define MULADDC_HUIT                            \
 
203
    asm( "movel  %a2@+, %d1     " );            \
 
204
    asm( "mulul  %d2, %d4:%d1   " );            \
 
205
    asm( "addxl  %d3, %d1       " );            \
 
206
    asm( "addxl  %d0, %d4       " );            \
 
207
    asm( "addl   %d1, %a3@+     " );            \
 
208
    asm( "movel  %a2@+, %d1     " );            \
 
209
    asm( "mulul  %d2, %d3:%d1   " );            \
 
210
    asm( "addxl  %d4, %d1       " );            \
 
211
    asm( "addxl  %d0, %d3       " );            \
 
212
    asm( "addl   %d1, %a3@+     " );            \
 
213
    asm( "movel  %a2@+, %d1     " );            \
 
214
    asm( "mulul  %d2, %d4:%d1   " );            \
 
215
    asm( "addxl  %d3, %d1       " );            \
 
216
    asm( "addxl  %d0, %d4       " );            \
 
217
    asm( "addl   %d1, %a3@+     " );            \
 
218
    asm( "movel  %a2@+, %d1     " );            \
 
219
    asm( "mulul  %d2, %d3:%d1   " );            \
 
220
    asm( "addxl  %d4, %d1       " );            \
 
221
    asm( "addxl  %d0, %d3       " );            \
 
222
    asm( "addl   %d1, %a3@+     " );            \
 
223
    asm( "movel  %a2@+, %d1     " );            \
 
224
    asm( "mulul  %d2, %d4:%d1   " );            \
 
225
    asm( "addxl  %d3, %d1       " );            \
 
226
    asm( "addxl  %d0, %d4       " );            \
 
227
    asm( "addl   %d1, %a3@+     " );            \
 
228
    asm( "movel  %a2@+, %d1     " );            \
 
229
    asm( "mulul  %d2, %d3:%d1   " );            \
 
230
    asm( "addxl  %d4, %d1       " );            \
 
231
    asm( "addxl  %d0, %d3       " );            \
 
232
    asm( "addl   %d1, %a3@+     " );            \
 
233
    asm( "movel  %a2@+, %d1     " );            \
 
234
    asm( "mulul  %d2, %d4:%d1   " );            \
 
235
    asm( "addxl  %d3, %d1       " );            \
 
236
    asm( "addxl  %d0, %d4       " );            \
 
237
    asm( "addl   %d1, %a3@+     " );            \
 
238
    asm( "movel  %a2@+, %d1     " );            \
 
239
    asm( "mulul  %d2, %d3:%d1   " );            \
 
240
    asm( "addxl  %d4, %d1       " );            \
 
241
    asm( "addxl  %d0, %d3       " );            \
 
242
    asm( "addl   %d1, %a3@+     " );            \
 
243
    asm( "addxl  %d0, %d3       " );
 
244
 
 
245
#endif /* MC68000 */
 
246
 
 
247
#if defined(__powerpc__)   || defined(__ppc__)
 
248
#if defined(__powerpc64__) || defined(__ppc64__)
 
249
 
 
250
#if defined(__MACH__) && defined(__APPLE__)
 
251
 
 
252
#define MULADDC_INIT                            \
 
253
    asm( "ld     r3, %0         " :: "m" (s));  \
 
254
    asm( "ld     r4, %0         " :: "m" (d));  \
 
255
    asm( "ld     r5, %0         " :: "m" (c));  \
 
256
    asm( "ld     r6, %0         " :: "m" (b));  \
 
257
    asm( "addi   r3, r3, -8     " );            \
 
258
    asm( "addi   r4, r4, -8     " );            \
 
259
    asm( "addic  r5, r5,  0     " );
 
260
 
 
261
#define MULADDC_CORE                            \
 
262
    asm( "ldu    r7, 8(r3)      " );            \
 
263
    asm( "mulld  r8, r7, r6     " );            \
 
264
    asm( "mulhdu r9, r7, r6     " );            \
 
265
    asm( "adde   r8, r8, r5     " );            \
 
266
    asm( "ld     r7, 8(r4)      " );            \
 
267
    asm( "addze  r5, r9         " );            \
 
268
    asm( "addc   r8, r8, r7     " );            \
 
269
    asm( "stdu   r8, 8(r4)      " );
 
270
 
 
271
#define MULADDC_STOP                            \
 
272
    asm( "addze  r5, r5         " );            \
 
273
    asm( "addi   r4, r4, 8      " );            \
 
274
    asm( "addi   r3, r3, 8      " );            \
 
275
    asm( "std    r5, %0         " : "=m" (c));  \
 
276
    asm( "std    r4, %0         " : "=m" (d));  \
 
277
    asm( "std    r3, %0         " : "=m" (s) :: \
 
278
    "r3", "r4", "r5", "r6", "r7", "r8", "r9" );
 
279
 
 
280
#else
 
281
 
 
282
#define MULADDC_INIT                            \
 
283
    asm( "ld     %%r3, %0       " :: "m" (s));  \
 
284
    asm( "ld     %%r4, %0       " :: "m" (d));  \
 
285
    asm( "ld     %%r5, %0       " :: "m" (c));  \
 
286
    asm( "ld     %%r6, %0       " :: "m" (b));  \
 
287
    asm( "addi   %r3, %r3, -8   " );            \
 
288
    asm( "addi   %r4, %r4, -8   " );            \
 
289
    asm( "addic  %r5, %r5,  0   " );
 
290
 
 
291
#define MULADDC_CORE                            \
 
292
    asm( "ldu    %r7, 8(%r3)    " );            \
 
293
    asm( "mulld  %r8, %r7, %r6  " );            \
 
294
    asm( "mulhdu %r9, %r7, %r6  " );            \
 
295
    asm( "adde   %r8, %r8, %r5  " );            \
 
296
    asm( "ld     %r7, 8(%r4)    " );            \
 
297
    asm( "addze  %r5, %r9       " );            \
 
298
    asm( "addc   %r8, %r8, %r7  " );            \
 
299
    asm( "stdu   %r8, 8(%r4)    " );
 
300
 
 
301
#define MULADDC_STOP                            \
 
302
    asm( "addze  %r5, %r5       " );            \
 
303
    asm( "addi   %r4, %r4, 8    " );            \
 
304
    asm( "addi   %r3, %r3, 8    " );            \
 
305
    asm( "std    %%r5, %0       " : "=m" (c));  \
 
306
    asm( "std    %%r4, %0       " : "=m" (d));  \
 
307
    asm( "std    %%r3, %0       " : "=m" (s) :: \
 
308
    "r3", "r4", "r5", "r6", "r7", "r8", "r9" );
 
309
 
 
310
#endif
 
311
 
 
312
#else /* PPC32 */
 
313
 
 
314
#if defined(__MACH__) && defined(__APPLE__)
 
315
 
 
316
#define MULADDC_INIT                            \
 
317
    asm( "lwz    r3, %0         " :: "m" (s));  \
 
318
    asm( "lwz    r4, %0         " :: "m" (d));  \
 
319
    asm( "lwz    r5, %0         " :: "m" (c));  \
 
320
    asm( "lwz    r6, %0         " :: "m" (b));  \
 
321
    asm( "addi   r3, r3, -4     " );            \
 
322
    asm( "addi   r4, r4, -4     " );            \
 
323
    asm( "addic  r5, r5,  0     " );
 
324
 
 
325
#define MULADDC_CORE                            \
 
326
    asm( "lwzu   r7, 4(r3)      " );            \
 
327
    asm( "mullw  r8, r7, r6     " );            \
 
328
    asm( "mulhwu r9, r7, r6     " );            \
 
329
    asm( "adde   r8, r8, r5     " );            \
 
330
    asm( "lwz    r7, 4(r4)      " );            \
 
331
    asm( "addze  r5, r9         " );            \
 
332
    asm( "addc   r8, r8, r7     " );            \
 
333
    asm( "stwu   r8, 4(r4)      " );
 
334
 
 
335
#define MULADDC_STOP                            \
 
336
    asm( "addze  r5, r5         " );            \
 
337
    asm( "addi   r4, r4, 4      " );            \
 
338
    asm( "addi   r3, r3, 4      " );            \
 
339
    asm( "stw    r5, %0         " : "=m" (c));  \
 
340
    asm( "stw    r4, %0         " : "=m" (d));  \
 
341
    asm( "stw    r3, %0         " : "=m" (s) :: \
 
342
    "r3", "r4", "r5", "r6", "r7", "r8", "r9" );
 
343
 
 
344
#else
 
345
 
 
346
#define MULADDC_INIT                            \
 
347
    asm( "lwz    %%r3, %0       " :: "m" (s));  \
 
348
    asm( "lwz    %%r4, %0       " :: "m" (d));  \
 
349
    asm( "lwz    %%r5, %0       " :: "m" (c));  \
 
350
    asm( "lwz    %%r6, %0       " :: "m" (b));  \
 
351
    asm( "addi   %r3, %r3, -4   " );            \
 
352
    asm( "addi   %r4, %r4, -4   " );            \
 
353
    asm( "addic  %r5, %r5,  0   " );
 
354
 
 
355
#define MULADDC_CORE                            \
 
356
    asm( "lwzu   %r7, 4(%r3)    " );            \
 
357
    asm( "mullw  %r8, %r7, %r6  " );            \
 
358
    asm( "mulhwu %r9, %r7, %r6  " );            \
 
359
    asm( "adde   %r8, %r8, %r5  " );            \
 
360
    asm( "lwz    %r7, 4(%r4)    " );            \
 
361
    asm( "addze  %r5, %r9       " );            \
 
362
    asm( "addc   %r8, %r8, %r7  " );            \
 
363
    asm( "stwu   %r8, 4(%r4)    " );
 
364
 
 
365
#define MULADDC_STOP                            \
 
366
    asm( "addze  %r5, %r5       " );            \
 
367
    asm( "addi   %r4, %r4, 4    " );            \
 
368
    asm( "addi   %r3, %r3, 4    " );            \
 
369
    asm( "stw    %%r5, %0       " : "=m" (c));  \
 
370
    asm( "stw    %%r4, %0       " : "=m" (d));  \
 
371
    asm( "stw    %%r3, %0       " : "=m" (s) :: \
 
372
    "r3", "r4", "r5", "r6", "r7", "r8", "r9" );
 
373
 
 
374
#endif
 
375
 
 
376
#endif /* PPC32 */
 
377
#endif /* PPC64 */
 
378
 
 
379
#if defined(__sparc__)
 
380
 
 
381
#define MULADDC_INIT                            \
 
382
    asm( "ld     %0, %%o0       " :: "m" (s));  \
 
383
    asm( "ld     %0, %%o1       " :: "m" (d));  \
 
384
    asm( "ld     %0, %%o2       " :: "m" (c));  \
 
385
    asm( "ld     %0, %%o3       " :: "m" (b));
 
386
 
 
387
#define MULADDC_CORE                            \
 
388
    asm( "ld    [%o0], %o4      " );            \
 
389
    asm( "inc      4,  %o0      " );            \
 
390
    asm( "ld    [%o1], %o5      " );            \
 
391
    asm( "umul   %o3,  %o4, %o4 " );            \
 
392
    asm( "addcc  %o4,  %o2, %o4 " );            \
 
393
    asm( "rd      %y,  %g1      " );            \
 
394
    asm( "addx   %g1,    0, %g1 " );            \
 
395
    asm( "addcc  %o4,  %o5, %o4 " );            \
 
396
    asm( "st     %o4, [%o1]     " );            \
 
397
    asm( "addx   %g1,    0, %o2 " );            \
 
398
    asm( "inc      4,  %o1      " );
 
399
 
 
400
#define MULADDC_STOP                            \
 
401
    asm( "st     %%o2, %0       " : "=m" (c));  \
 
402
    asm( "st     %%o1, %0       " : "=m" (d));  \
 
403
    asm( "st     %%o0, %0       " : "=m" (s) :: \
 
404
    "g1", "o0", "o1", "o2", "o3", "o4", "o5" );
 
405
 
 
406
#endif /* SPARCv8 */
 
407
 
 
408
#if defined(__microblaze__) || defined(microblaze)
 
409
 
 
410
#define MULADDC_INIT                            \
 
411
    asm( "lwi   r3,   %0        " :: "m" (s));  \
 
412
    asm( "lwi   r4,   %0        " :: "m" (d));  \
 
413
    asm( "lwi   r5,   %0        " :: "m" (c));  \
 
414
    asm( "lwi   r6,   %0        " :: "m" (b));  \
 
415
    asm( "andi  r7,   r6, 0xffff" );            \
 
416
    asm( "bsrli r6,   r6, 16    " );
 
417
 
 
418
#define MULADDC_CORE                            \
 
419
    asm( "lhui  r8,   r3,   0   " );            \
 
420
    asm( "addi  r3,   r3,   2   " );            \
 
421
    asm( "lhui  r9,   r3,   0   " );            \
 
422
    asm( "addi  r3,   r3,   2   " );            \
 
423
    asm( "mul   r10,  r9,  r6   " );            \
 
424
    asm( "mul   r11,  r8,  r7   " );            \
 
425
    asm( "mul   r12,  r9,  r7   " );            \
 
426
    asm( "mul   r13,  r8,  r6   " );            \
 
427
    asm( "bsrli  r8, r10,  16   " );            \
 
428
    asm( "bsrli  r9, r11,  16   " );            \
 
429
    asm( "add   r13, r13,  r8   " );            \
 
430
    asm( "add   r13, r13,  r9   " );            \
 
431
    asm( "bslli r10, r10,  16   " );            \
 
432
    asm( "bslli r11, r11,  16   " );            \
 
433
    asm( "add   r12, r12, r10   " );            \
 
434
    asm( "addc  r13, r13,  r0   " );            \
 
435
    asm( "add   r12, r12, r11   " );            \
 
436
    asm( "addc  r13, r13,  r0   " );            \
 
437
    asm( "lwi   r10,  r4,   0   " );            \
 
438
    asm( "add   r12, r12, r10   " );            \
 
439
    asm( "addc  r13, r13,  r0   " );            \
 
440
    asm( "add   r12, r12,  r5   " );            \
 
441
    asm( "addc   r5, r13,  r0   " );            \
 
442
    asm( "swi   r12,  r4,   0   " );            \
 
443
    asm( "addi   r4,  r4,   4   " );
 
444
 
 
445
#define MULADDC_STOP                            \
 
446
    asm( "swi   r5,   %0        " : "=m" (c));  \
 
447
    asm( "swi   r4,   %0        " : "=m" (d));  \
 
448
    asm( "swi   r3,   %0        " : "=m" (s) :: \
 
449
     "r3", "r4" , "r5" , "r6" , "r7" , "r8" ,   \
 
450
     "r9", "r10", "r11", "r12", "r13" );
 
451
 
 
452
#endif /* MicroBlaze */
 
453
 
 
454
#if defined(__tricore__)
 
455
 
 
456
#define MULADDC_INIT                            \
 
457
    asm( "ld.a   %%a2, %0       " :: "m" (s));  \
 
458
    asm( "ld.a   %%a3, %0       " :: "m" (d));  \
 
459
    asm( "ld.w   %%d4, %0       " :: "m" (c));  \
 
460
    asm( "ld.w   %%d1, %0       " :: "m" (b));  \
 
461
    asm( "xor    %d5, %d5       " );
 
462
 
 
463
#define MULADDC_CORE                            \
 
464
    asm( "ld.w   %d0,   [%a2+]      " );        \
 
465
    asm( "madd.u %e2, %e4, %d0, %d1 " );        \
 
466
    asm( "ld.w   %d0,   [%a3]       " );        \
 
467
    asm( "addx   %d2,    %d2,  %d0  " );        \
 
468
    asm( "addc   %d3,    %d3,    0  " );        \
 
469
    asm( "mov    %d4,    %d3        " );        \
 
470
    asm( "st.w  [%a3+],  %d2        " );
 
471
 
 
472
#define MULADDC_STOP                            \
 
473
    asm( "st.w   %0, %%d4       " : "=m" (c));  \
 
474
    asm( "st.a   %0, %%a3       " : "=m" (d));  \
 
475
    asm( "st.a   %0, %%a2       " : "=m" (s) :: \
 
476
    "d0", "d1", "e2", "d4", "a2", "a3" );
 
477
 
 
478
#endif /* TriCore */
 
479
 
 
480
#if defined(__arm__)
 
481
 
 
482
#define MULADDC_INIT                            \
 
483
    asm( "ldr    r0, %0         " :: "m" (s));  \
 
484
    asm( "ldr    r1, %0         " :: "m" (d));  \
 
485
    asm( "ldr    r2, %0         " :: "m" (c));  \
 
486
    asm( "ldr    r3, %0         " :: "m" (b));
 
487
 
 
488
#define MULADDC_CORE                            \
 
489
    asm( "ldr    r4, [r0], #4   " );            \
 
490
    asm( "mov    r5, #0         " );            \
 
491
    asm( "ldr    r6, [r1]       " );            \
 
492
    asm( "umlal  r2, r5, r3, r4 " );            \
 
493
    asm( "adds   r7, r6, r2     " );            \
 
494
    asm( "adc    r2, r5, #0     " );            \
 
495
    asm( "str    r7, [r1], #4   " );
 
496
 
 
497
#define MULADDC_STOP                            \
 
498
    asm( "str    r2, %0         " : "=m" (c));  \
 
499
    asm( "str    r1, %0         " : "=m" (d));  \
 
500
    asm( "str    r0, %0         " : "=m" (s) :: \
 
501
    "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7" );
 
502
 
 
503
#endif /* ARMv3 */
 
504
 
 
505
#if defined(__alpha__)
 
506
 
 
507
#define MULADDC_INIT                            \
 
508
    asm( "ldq    $1, %0         " :: "m" (s));  \
 
509
    asm( "ldq    $2, %0         " :: "m" (d));  \
 
510
    asm( "ldq    $3, %0         " :: "m" (c));  \
 
511
    asm( "ldq    $4, %0         " :: "m" (b));
 
512
 
 
513
#define MULADDC_CORE                            \
 
514
    asm( "ldq    $6,  0($1)     " );            \
 
515
    asm( "addq   $1,  8, $1     " );            \
 
516
    asm( "mulq   $6, $4, $7     " );            \
 
517
    asm( "umulh  $6, $4, $6     " );            \
 
518
    asm( "addq   $7, $3, $7     " );            \
 
519
    asm( "cmpult $7, $3, $3     " );            \
 
520
    asm( "ldq    $5,  0($2)     " );            \
 
521
    asm( "addq   $7, $5, $7     " );            \
 
522
    asm( "cmpult $7, $5, $5     " );            \
 
523
    asm( "stq    $7,  0($2)     " );            \
 
524
    asm( "addq   $2,  8, $2     " );            \
 
525
    asm( "addq   $6, $3, $3     " );            \
 
526
    asm( "addq   $5, $3, $3     " );
 
527
 
 
528
#define MULADDC_STOP                            \
 
529
    asm( "stq    $3, %0         " : "=m" (c));  \
 
530
    asm( "stq    $2, %0         " : "=m" (d));  \
 
531
    asm( "stq    $1, %0         " : "=m" (s) :: \
 
532
    "$1", "$2", "$3", "$4", "$5", "$6", "$7" );
 
533
 
 
534
#endif /* Alpha */
 
535
 
 
536
#if defined(__mips__)
 
537
 
 
538
#define MULADDC_INIT                            \
 
539
    asm( "lw     $10, %0        " :: "m" (s));  \
 
540
    asm( "lw     $11, %0        " :: "m" (d));  \
 
541
    asm( "lw     $12, %0        " :: "m" (c));  \
 
542
    asm( "lw     $13, %0        " :: "m" (b));
 
543
 
 
544
#define MULADDC_CORE                            \
 
545
    asm( "lw     $14, 0($10)    " );            \
 
546
    asm( "multu  $13, $14       " );            \
 
547
    asm( "addi   $10, $10, 4    " );            \
 
548
    asm( "mflo   $14            " );            \
 
549
    asm( "mfhi   $9             " );            \
 
550
    asm( "addu   $14, $12, $14  " );            \
 
551
    asm( "lw     $15, 0($11)    " );            \
 
552
    asm( "sltu   $12, $14, $12  " );            \
 
553
    asm( "addu   $15, $14, $15  " );            \
 
554
    asm( "sltu   $14, $15, $14  " );            \
 
555
    asm( "addu   $12, $12, $9   " );            \
 
556
    asm( "sw     $15, 0($11)    " );            \
 
557
    asm( "addu   $12, $12, $14  " );            \
 
558
    asm( "addi   $11, $11, 4    " );
 
559
 
 
560
#define MULADDC_STOP                            \
 
561
    asm( "sw     $12, %0        " : "=m" (c));  \
 
562
    asm( "sw     $11, %0        " : "=m" (d));  \
 
563
    asm( "sw     $10, %0        " : "=m" (s) :: \
 
564
    "$9", "$10", "$11", "$12", "$13", "$14", "$15" );
 
565
 
 
566
#endif /* MIPS */
 
567
#endif /* GNUC */
 
568
 
 
569
#if (defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)
 
570
 
 
571
#define MULADDC_INIT                            \
 
572
    __asm   mov     esi, s                      \
 
573
    __asm   mov     edi, d                      \
 
574
    __asm   mov     ecx, c                      \
 
575
    __asm   mov     ebx, b
 
576
 
 
577
#define MULADDC_CORE                            \
 
578
    __asm   lodsd                               \
 
579
    __asm   mul     ebx                         \
 
580
    __asm   add     eax, ecx                    \
 
581
    __asm   adc     edx, 0                      \
 
582
    __asm   add     eax, [edi]                  \
 
583
    __asm   adc     edx, 0                      \
 
584
    __asm   mov     ecx, edx                    \
 
585
    __asm   stosd
 
586
 
 
587
#if defined(POLARSSL_HAVE_SSE2)
 
588
 
 
589
#define EMIT __asm _emit
 
590
 
 
591
#define MULADDC_HUIT                            \
 
592
    EMIT 0x0F  EMIT 0x6E  EMIT 0xC9             \
 
593
    EMIT 0x0F  EMIT 0x6E  EMIT 0xC3             \
 
594
    EMIT 0x0F  EMIT 0x6E  EMIT 0x1F             \
 
595
    EMIT 0x0F  EMIT 0xD4  EMIT 0xCB             \
 
596
    EMIT 0x0F  EMIT 0x6E  EMIT 0x16             \
 
597
    EMIT 0x0F  EMIT 0xF4  EMIT 0xD0             \
 
598
    EMIT 0x0F  EMIT 0x6E  EMIT 0x66  EMIT 0x04  \
 
599
    EMIT 0x0F  EMIT 0xF4  EMIT 0xE0             \
 
600
    EMIT 0x0F  EMIT 0x6E  EMIT 0x76  EMIT 0x08  \
 
601
    EMIT 0x0F  EMIT 0xF4  EMIT 0xF0             \
 
602
    EMIT 0x0F  EMIT 0x6E  EMIT 0x7E  EMIT 0x0C  \
 
603
    EMIT 0x0F  EMIT 0xF4  EMIT 0xF8             \
 
604
    EMIT 0x0F  EMIT 0xD4  EMIT 0xCA             \
 
605
    EMIT 0x0F  EMIT 0x6E  EMIT 0x5F  EMIT 0x04  \
 
606
    EMIT 0x0F  EMIT 0xD4  EMIT 0xDC             \
 
607
    EMIT 0x0F  EMIT 0x6E  EMIT 0x6F  EMIT 0x08  \
 
608
    EMIT 0x0F  EMIT 0xD4  EMIT 0xEE             \
 
609
    EMIT 0x0F  EMIT 0x6E  EMIT 0x67  EMIT 0x0C  \
 
610
    EMIT 0x0F  EMIT 0xD4  EMIT 0xFC             \
 
611
    EMIT 0x0F  EMIT 0x7E  EMIT 0x0F             \
 
612
    EMIT 0x0F  EMIT 0x6E  EMIT 0x56  EMIT 0x10  \
 
613
    EMIT 0x0F  EMIT 0xF4  EMIT 0xD0             \
 
614
    EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
 
615
    EMIT 0x0F  EMIT 0x6E  EMIT 0x66  EMIT 0x14  \
 
616
    EMIT 0x0F  EMIT 0xF4  EMIT 0xE0             \
 
617
    EMIT 0x0F  EMIT 0xD4  EMIT 0xCB             \
 
618
    EMIT 0x0F  EMIT 0x6E  EMIT 0x76  EMIT 0x18  \
 
619
    EMIT 0x0F  EMIT 0xF4  EMIT 0xF0             \
 
620
    EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x04  \
 
621
    EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
 
622
    EMIT 0x0F  EMIT 0x6E  EMIT 0x5E  EMIT 0x1C  \
 
623
    EMIT 0x0F  EMIT 0xF4  EMIT 0xD8             \
 
624
    EMIT 0x0F  EMIT 0xD4  EMIT 0xCD             \
 
625
    EMIT 0x0F  EMIT 0x6E  EMIT 0x6F  EMIT 0x10  \
 
626
    EMIT 0x0F  EMIT 0xD4  EMIT 0xD5             \
 
627
    EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x08  \
 
628
    EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
 
629
    EMIT 0x0F  EMIT 0xD4  EMIT 0xCF             \
 
630
    EMIT 0x0F  EMIT 0x6E  EMIT 0x6F  EMIT 0x14  \
 
631
    EMIT 0x0F  EMIT 0xD4  EMIT 0xE5             \
 
632
    EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x0C  \
 
633
    EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
 
634
    EMIT 0x0F  EMIT 0xD4  EMIT 0xCA             \
 
635
    EMIT 0x0F  EMIT 0x6E  EMIT 0x6F  EMIT 0x18  \
 
636
    EMIT 0x0F  EMIT 0xD4  EMIT 0xF5             \
 
637
    EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x10  \
 
638
    EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
 
639
    EMIT 0x0F  EMIT 0xD4  EMIT 0xCC             \
 
640
    EMIT 0x0F  EMIT 0x6E  EMIT 0x6F  EMIT 0x1C  \
 
641
    EMIT 0x0F  EMIT 0xD4  EMIT 0xDD             \
 
642
    EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x14  \
 
643
    EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
 
644
    EMIT 0x0F  EMIT 0xD4  EMIT 0xCE             \
 
645
    EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x18  \
 
646
    EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
 
647
    EMIT 0x0F  EMIT 0xD4  EMIT 0xCB             \
 
648
    EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x1C  \
 
649
    EMIT 0x83  EMIT 0xC7  EMIT 0x20             \
 
650
    EMIT 0x83  EMIT 0xC6  EMIT 0x20             \
 
651
    EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
 
652
    EMIT 0x0F  EMIT 0x7E  EMIT 0xC9
 
653
 
 
654
#define MULADDC_STOP                            \
 
655
    EMIT 0x0F  EMIT 0x77                        \
 
656
    __asm   mov     c, ecx                      \
 
657
    __asm   mov     d, edi                      \
 
658
    __asm   mov     s, esi                      \
 
659
 
 
660
#else
 
661
 
 
662
#define MULADDC_STOP                            \
 
663
    __asm   mov     c, ecx                      \
 
664
    __asm   mov     d, edi                      \
 
665
    __asm   mov     s, esi                      \
 
666
 
 
667
#endif /* SSE2 */
 
668
#endif /* MSVC */
 
669
 
 
670
#endif /* POLARSSL_HAVE_ASM */
 
671
 
 
672
#if !defined(MULADDC_CORE)
 
673
#if defined(POLARSSL_HAVE_LONGLONG)
 
674
 
 
675
#define MULADDC_INIT                    \
 
676
{                                       \
 
677
    t_dbl r;                            \
 
678
    t_int r0, r1;
 
679
 
 
680
#define MULADDC_CORE                    \
 
681
    r   = *(s++) * (t_dbl) b;           \
 
682
    r0  = r;                            \
 
683
    r1  = r >> biL;                     \
 
684
    r0 += c;  r1 += (r0 <  c);          \
 
685
    r0 += *d; r1 += (r0 < *d);          \
 
686
    c = r1; *(d++) = r0;
 
687
 
 
688
#define MULADDC_STOP                    \
 
689
}
 
690
 
 
691
#else
 
692
#define MULADDC_INIT                    \
 
693
{                                       \
 
694
    t_int s0, s1, b0, b1;               \
 
695
    t_int r0, r1, rx, ry;               \
 
696
    b0 = ( b << biH ) >> biH;           \
 
697
    b1 = ( b >> biH );
 
698
 
 
699
#define MULADDC_CORE                    \
 
700
    s0 = ( *s << biH ) >> biH;          \
 
701
    s1 = ( *s >> biH ); s++;            \
 
702
    rx = s0 * b1; r0 = s0 * b0;         \
 
703
    ry = s1 * b0; r1 = s1 * b1;         \
 
704
    r1 += ( rx >> biH );                \
 
705
    r1 += ( ry >> biH );                \
 
706
    rx <<= biH; ry <<= biH;             \
 
707
    r0 += rx; r1 += (r0 < rx);          \
 
708
    r0 += ry; r1 += (r0 < ry);          \
 
709
    r0 +=  c; r1 += (r0 <  c);          \
 
710
    r0 += *d; r1 += (r0 < *d);          \
 
711
    c = r1; *(d++) = r0;
 
712
 
 
713
#define MULADDC_STOP                    \
 
714
}
 
715
 
 
716
#endif /* C (generic)  */
 
717
#endif /* C (longlong) */
 
718
 
 
719
#endif /* bn_mul.h */