File Coverage

inc/matrixssl-3-9-3-open/crypto/math/pstm_mul_comba.c
Criterion Covered Total %
statement 35 42 83.3
branch 17 24 70.8
condition n/a
subroutine n/a
pod n/a
total 52 66 78.7


line stmt bran cond sub pod time code
1             /**
2             * @file pstm_mul_comba.c
3             * @version 950bba4 (HEAD -> master)
4             *
5             * Multiprecision multiplication with Comba technique.
6             */
7             /*
8             * Copyright (c) 2013-2017 INSIDE Secure Corporation
9             * Copyright (c) PeerSec Networks, 2002-2011
10             * All Rights Reserved
11             *
12             * The latest version of this code is available at http://www.matrixssl.org
13             *
14             * This software is open source; you can redistribute it and/or modify
15             * it under the terms of the GNU General Public License as published by
16             * the Free Software Foundation; either version 2 of the License, or
17             * (at your option) any later version.
18             *
19             * This General Public License does NOT permit incorporating this software
20             * into proprietary programs. If you are unable to comply with the GPL, a
21             * commercial license for this software may be purchased from INSIDE at
22             * http://www.insidesecure.com/
23             *
24             * This program is distributed in WITHOUT ANY WARRANTY; without even the
25             * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
26             * See the GNU General Public License for more details.
27             *
28             * You should have received a copy of the GNU General Public License
29             * along with this program; if not, write to the Free Software
30             * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
31             * http://www.gnu.org/copyleft/gpl.html
32             */
33             /******************************************************************************/
34              
35             #include "../cryptoImpl.h"
36              
37             #if defined(USE_MATRIX_RSA) || defined(USE_MATRIX_ECC) || defined(USE_MATRIX_DH)
38              
39             /******************************************************************************/
40             # if defined(PSTM_X86)
41             /* x86-32 optimized for 32 bit platforms. For 64 bit mode use X86_64 instead */
42             # if !defined(__GNUC__) || !defined(__i386__) || !defined(PSTM_32BIT)
43             # error "PSTM_X86 option requires GCC and 32 bit mode x86 processor"
44             # endif
45             /* #pragma message ("Using 32 bit x86 Assembly Optimizations") */
46              
47             /* anything you need at the start */
48             # define COMBA_START
49              
50             /* clear the chaining variables */
51             # define COMBA_CLEAR \
52             c0 = c1 = c2 = 0;
53              
54             /* forward the carry to the next digit */
55             # define COMBA_FORWARD \
56             do { c0 = c1; c1 = c2; c2 = 0; } while (0);
57              
58             /* store the first sum */
59             # define COMBA_STORE(x) \
60             x = c0;
61              
62             /* store the second sum [carry] */
63             # define COMBA_STORE2(x) \
64             x = c1;
65              
66             /* anything you need at the end */
67             # define COMBA_FINI
68              
69             /* this should multiply i and j */
70             # define MULADD(i, j) \
71             asm ( \
72             "movl %6,%%eax \n\t" \
73             "mull %7 \n\t" \
74             "addl %%eax,%0 \n\t" \
75             "adcl %%edx,%1 \n\t" \
76             "adcl $0,%2 \n\t" \
77             : "=r" (c0), "=r" (c1), "=r" (c2) : "0" (c0), "1" (c1), "2" (c2), "m" (i), "m" (j) : "%eax", "%edx", "cc");
78              
79             /******************************************************************************/
80             # elif defined(PSTM_X86_64)
81             /* x86-64 optimized */
82             # if !defined(__GNUC__) || !defined(__x86_64__) || !defined(PSTM_64BIT)
83             # error "PSTM_X86_64 option requires PSTM_64BIT, GCC and 64 bit mode x86 processor"
84             # endif
85             /* #pragma message ("Using 64 bit x86_64 Assembly Optimizations") */
86              
87             /* anything you need at the start */
88             # define COMBA_START
89              
90             /* clear the chaining variables */
91             # define COMBA_CLEAR \
92             c0 = c1 = c2 = 0;
93              
94             /* forward the carry to the next digit */
95             # define COMBA_FORWARD \
96             do { c0 = c1; c1 = c2; c2 = 0; } while (0);
97              
98             /* store the first sum */
99             # define COMBA_STORE(x) \
100             x = c0;
101              
102             /* store the second sum [carry] */
103             # define COMBA_STORE2(x) \
104             x = c1;
105              
106             /* anything you need at the end */
107             # define COMBA_FINI
108              
109             /* this should multiply i and j */
110             # define MULADD(i, j) \
111             asm ( \
112             "movq %6,%%rax \n\t" \
113             "mulq %7 \n\t" \
114             "addq %%rax,%0 \n\t" \
115             "adcq %%rdx,%1 \n\t" \
116             "adcq $0,%2 \n\t" \
117             : "=r" (c0), "=r" (c1), "=r" (c2) : "0" (c0), "1" (c1), "2" (c2), "g" (i), "g" (j) : "%rax", "%rdx", "cc");
118              
119             /******************************************************************************/
120             # elif defined(PSTM_ARM)
121             /* ARM code */
122             /* #pragma message ("Using 32 bit ARM Assembly Optimizations") */
123              
124             # define COMBA_START
125              
126             # define COMBA_CLEAR \
127             c0 = c1 = c2 = 0;
128              
129             # define COMBA_FORWARD \
130             do { c0 = c1; c1 = c2; c2 = 0; } while (0);
131              
132             # define COMBA_STORE(x) \
133             x = c0;
134              
135             # define COMBA_STORE2(x) \
136             x = c1;
137              
138             # define COMBA_FINI
139              
140             # define MULADD(i, j) \
141             asm ( \
142             " UMULL r0,r1,%6,%7 \n\t" \
143             " ADDS %0,%0,r0 \n\t" \
144             " ADCS %1,%1,r1 \n\t" \
145             " ADC %2,%2,#0 \n\t" \
146             : "=r" (c0), "=r" (c1), "=r" (c2) : "0" (c0), "1" (c1), "2" (c2), "r" (i), "r" (j) : "r0", "r1", "cc");
147              
148             /******************************************************************************/
149             # elif defined(PSTM_MIPS)
150             /* MIPS32 code */
151             /* #pragma message ("Using 32 bit MIPS Assembly Optimizations") */
152              
153             # define COMBA_START
154              
155             # define COMBA_CLEAR \
156             c0 = c1 = c2 = 0;
157              
158             # define COMBA_FORWARD \
159             do { c0 = c1; c1 = c2; c2 = 0; } while (0);
160              
161             # define COMBA_STORE(x) \
162             x = c0;
163              
164             # define COMBA_STORE2(x) \
165             x = c1;
166              
167             # define COMBA_FINI
168              
169             # define MULADD(i, j) \
170             asm ( \
171             " multu %6,%7 \n\t" \
172             " mflo $12 \n\t" \
173             " mfhi $13 \n\t" \
174             " addu %0,%0,$12 \n\t" \
175             " sltu $12,%0,$12 \n\t" \
176             " addu %1,%1,$13 \n\t" \
177             " sltu $13,%1,$13 \n\t" \
178             " addu %1,%1,$12 \n\t" \
179             " sltu $12,%1,$12 \n\t" \
180             " addu %2,%2,$13 \n\t" \
181             " addu %2,%2,$12 \n\t" \
182             : "=r" (c0), "=r" (c1), "=r" (c2) : "0" (c0), "1" (c1), "2" (c2), "r" (i), "r" (j) : "$12", "$13");
183              
184             /******************************************************************************/
185             # else
186              
187             # define COMBA_START
188              
189             # define COMBA_CLEAR \
190             c0 = c1 = c2 = 0;
191              
192             # define COMBA_FORWARD \
193             do { c0 = c1; c1 = c2; c2 = 0; } while (0);
194              
195             # define COMBA_STORE(x) \
196             x = c0;
197              
198             # define COMBA_STORE2(x) \
199             x = c1;
200              
201             # define COMBA_FINI
202              
203             # define MULADD(i, j) \
204             do { pstm_word t; \
205             t = (pstm_word) c0 + ((pstm_word) i) * ((pstm_word) j); c0 = (pstm_digit) t; \
206             t = (pstm_word) c1 + (t >> DIGIT_BIT); \
207             c1 = (pstm_digit) t; c2 += (pstm_digit) (t >> DIGIT_BIT); \
208             } while (0);
209              
210             # endif
211              
212             /******************************************************************************/
213             /* generic PxQ multiplier */
214 7407000           static int32_t pstm_mul_comba_gen(psPool_t *pool, const pstm_int *A,
215             const pstm_int *B, pstm_int *C,
216             pstm_digit *paD, psSize_t paDlen)
217             {
218             int16 paDfail, pa;
219             int32 ix, iy, iz, tx, ty;
220             pstm_digit c0, c1, c2, *tmpx, *tmpy, *dst;
221              
222             COMBA_START;
223 7407000           COMBA_CLEAR;
224              
225 7407000           paDfail = 0;
226             /* get size of output and trim */
227 7407000           pa = A->used + B->used;
228              
229             /*
230             If c is not large enough grow it and continue
231             */
232 7407000 100         if (C->alloc < pa)
233             {
234 13 50         if (pstm_grow(C, pa) != PSTM_OKAY)
235             {
236 0           return PS_MEM_FAIL;
237             }
238             }
239 7407000 100         if (paD != NULL)
240             {
241 7398280 50         if (paDlen < (sizeof(pstm_digit) * pa))
242             {
243 0           paDfail = 1; /* have a paD but it's not large enough */
244 0 0         if ((dst = psMalloc(pool, sizeof(pstm_digit) * pa)) == NULL)
245             {
246 0           return PS_MEM_FAIL;
247             }
248 0           memset(dst, 0x0, sizeof(pstm_digit) * pa);
249             }
250             else
251             {
252 7398280           dst = paD;
253 7398280           memset(dst, 0x0, paDlen);
254             }
255             }
256             else
257             {
258 8720 50         if ((dst = psMalloc(pool, sizeof(pstm_digit) * pa)) == NULL)
259             {
260 0           return PS_MEM_FAIL;
261             }
262 8720           memset(dst, 0x0, sizeof(pstm_digit) * pa);
263             }
264              
265 139911418 100         for (ix = 0; ix < pa; ix++)
266             {
267             /* get offsets into the two bignums */
268 132504418           ty = min(ix, B->used - 1);
269 132504418           tx = ix - ty;
270              
271             /* setup temp aliases */
272 132504418           tmpx = A->dp + tx;
273 132504418           tmpy = B->dp + ty;
274             /*
275             This is the number of times the loop will iterate, essentially it's
276             while (tx++ < a->used && ty-- >= 0) { ... }
277             */
278 132504418           iy = min(A->used - tx, ty + 1);
279              
280             /* execute loop */
281 132504418           COMBA_FORWARD;
282 726558950 100         for (iz = 0; iz < iy; ++iz)
283             {
284 594054532           MULADD(*tmpx++, *tmpy--);
285             }
286              
287             /* store term */
288 132504418           COMBA_STORE(dst[ix]);
289             }
290             COMBA_FINI;
291             /*
292             setup dest
293             */
294 7407000           iy = C->used;
295 7407000           C->used = pa;
296 7407000           C->sign = A->sign ^ B->sign;
297             {
298             pstm_digit *tmpc;
299 7407000           tmpc = C->dp;
300 139911418 100         for (ix = 0; ix < pa; ix++)
301             {
302 132504418           *tmpc++ = dst[ix];
303             }
304             /*
305             clear unused digits [that existed in the old copy of c]
306             */
307 7407000 50         for (; ix < iy; ix++)
308             {
309 0           *tmpc++ = 0;
310             }
311             }
312 7407000           pstm_clamp(C);
313              
314 7407000 100         if ((paD == NULL) || (paDfail == 1))
    50          
315             {
316 8720           psFree(dst, pool);
317             }
318              
319 7407000           return PS_SUCCESS;
320             }
321              
322             /******************************************************************************/
323             # ifdef USE_1024_KEY_SPEED_OPTIMIZATIONS
324             static int32_t pstm_mul_comba16(const pstm_int *A, const pstm_int *B, pstm_int *C)
325             {
326             pstm_digit c0, c1, c2, at[32];
327              
328             if (C->alloc < 32)
329             {
330             if (pstm_grow(C, 32) != PSTM_OKAY)
331             {
332             return PS_MEM_FAIL;
333             }
334             }
335             memcpy(at, A->dp, 16 * sizeof(pstm_digit));
336             memcpy(at + 16, B->dp, 16 * sizeof(pstm_digit));
337              
338             COMBA_START;
339              
340             COMBA_CLEAR;
341             /* 0 */
342             MULADD(at[0], at[16]);
343             COMBA_STORE(C->dp[0]);
344             /* 1 */
345             COMBA_FORWARD;
346             MULADD(at[0], at[17]); MULADD(at[1], at[16]);
347             COMBA_STORE(C->dp[1]);
348             /* 2 */
349             COMBA_FORWARD;
350             MULADD(at[0], at[18]); MULADD(at[1], at[17]); MULADD(at[2], at[16]);
351             COMBA_STORE(C->dp[2]);
352             /* 3 */
353             COMBA_FORWARD;
354             MULADD(at[0], at[19]); MULADD(at[1], at[18]); MULADD(at[2], at[17]); MULADD(at[3], at[16]);
355             COMBA_STORE(C->dp[3]);
356             /* 4 */
357             COMBA_FORWARD;
358             MULADD(at[0], at[20]); MULADD(at[1], at[19]); MULADD(at[2], at[18]); MULADD(at[3], at[17]); MULADD(at[4], at[16]);
359             COMBA_STORE(C->dp[4]);
360             /* 5 */
361             COMBA_FORWARD;
362             MULADD(at[0], at[21]); MULADD(at[1], at[20]); MULADD(at[2], at[19]); MULADD(at[3], at[18]); MULADD(at[4], at[17]); MULADD(at[5], at[16]);
363             COMBA_STORE(C->dp[5]);
364             /* 6 */
365             COMBA_FORWARD;
366             MULADD(at[0], at[22]); MULADD(at[1], at[21]); MULADD(at[2], at[20]); MULADD(at[3], at[19]); MULADD(at[4], at[18]); MULADD(at[5], at[17]); MULADD(at[6], at[16]);
367             COMBA_STORE(C->dp[6]);
368             /* 7 */
369             COMBA_FORWARD;
370             MULADD(at[0], at[23]); MULADD(at[1], at[22]); MULADD(at[2], at[21]); MULADD(at[3], at[20]); MULADD(at[4], at[19]); MULADD(at[5], at[18]); MULADD(at[6], at[17]); MULADD(at[7], at[16]);
371             COMBA_STORE(C->dp[7]);
372             /* 8 */
373             COMBA_FORWARD;
374             MULADD(at[0], at[24]); MULADD(at[1], at[23]); MULADD(at[2], at[22]); MULADD(at[3], at[21]); MULADD(at[4], at[20]); MULADD(at[5], at[19]); MULADD(at[6], at[18]); MULADD(at[7], at[17]); MULADD(at[8], at[16]);
375             COMBA_STORE(C->dp[8]);
376             /* 9 */
377             COMBA_FORWARD;
378             MULADD(at[0], at[25]); MULADD(at[1], at[24]); MULADD(at[2], at[23]); MULADD(at[3], at[22]); MULADD(at[4], at[21]); MULADD(at[5], at[20]); MULADD(at[6], at[19]); MULADD(at[7], at[18]); MULADD(at[8], at[17]); MULADD(at[9], at[16]);
379             COMBA_STORE(C->dp[9]);
380             /* 10 */
381             COMBA_FORWARD;
382             MULADD(at[0], at[26]); MULADD(at[1], at[25]); MULADD(at[2], at[24]); MULADD(at[3], at[23]); MULADD(at[4], at[22]); MULADD(at[5], at[21]); MULADD(at[6], at[20]); MULADD(at[7], at[19]); MULADD(at[8], at[18]); MULADD(at[9], at[17]); MULADD(at[10], at[16]);
383             COMBA_STORE(C->dp[10]);
384             /* 11 */
385             COMBA_FORWARD;
386             MULADD(at[0], at[27]); MULADD(at[1], at[26]); MULADD(at[2], at[25]); MULADD(at[3], at[24]); MULADD(at[4], at[23]); MULADD(at[5], at[22]); MULADD(at[6], at[21]); MULADD(at[7], at[20]); MULADD(at[8], at[19]); MULADD(at[9], at[18]); MULADD(at[10], at[17]); MULADD(at[11], at[16]);
387             COMBA_STORE(C->dp[11]);
388             /* 12 */
389             COMBA_FORWARD;
390             MULADD(at[0], at[28]); MULADD(at[1], at[27]); MULADD(at[2], at[26]); MULADD(at[3], at[25]); MULADD(at[4], at[24]); MULADD(at[5], at[23]); MULADD(at[6], at[22]); MULADD(at[7], at[21]); MULADD(at[8], at[20]); MULADD(at[9], at[19]); MULADD(at[10], at[18]); MULADD(at[11], at[17]); MULADD(at[12], at[16]);
391             COMBA_STORE(C->dp[12]);
392             /* 13 */
393             COMBA_FORWARD;
394             MULADD(at[0], at[29]); MULADD(at[1], at[28]); MULADD(at[2], at[27]); MULADD(at[3], at[26]); MULADD(at[4], at[25]); MULADD(at[5], at[24]); MULADD(at[6], at[23]); MULADD(at[7], at[22]); MULADD(at[8], at[21]); MULADD(at[9], at[20]); MULADD(at[10], at[19]); MULADD(at[11], at[18]); MULADD(at[12], at[17]); MULADD(at[13], at[16]);
395             COMBA_STORE(C->dp[13]);
396             /* 14 */
397             COMBA_FORWARD;
398             MULADD(at[0], at[30]); MULADD(at[1], at[29]); MULADD(at[2], at[28]); MULADD(at[3], at[27]); MULADD(at[4], at[26]); MULADD(at[5], at[25]); MULADD(at[6], at[24]); MULADD(at[7], at[23]); MULADD(at[8], at[22]); MULADD(at[9], at[21]); MULADD(at[10], at[20]); MULADD(at[11], at[19]); MULADD(at[12], at[18]); MULADD(at[13], at[17]); MULADD(at[14], at[16]);
399             COMBA_STORE(C->dp[14]);
400             /* 15 */
401             COMBA_FORWARD;
402             MULADD(at[0], at[31]); MULADD(at[1], at[30]); MULADD(at[2], at[29]); MULADD(at[3], at[28]); MULADD(at[4], at[27]); MULADD(at[5], at[26]); MULADD(at[6], at[25]); MULADD(at[7], at[24]); MULADD(at[8], at[23]); MULADD(at[9], at[22]); MULADD(at[10], at[21]); MULADD(at[11], at[20]); MULADD(at[12], at[19]); MULADD(at[13], at[18]); MULADD(at[14], at[17]); MULADD(at[15], at[16]);
403             COMBA_STORE(C->dp[15]);
404             /* 16 */
405             COMBA_FORWARD;
406             MULADD(at[1], at[31]); MULADD(at[2], at[30]); MULADD(at[3], at[29]); MULADD(at[4], at[28]); MULADD(at[5], at[27]); MULADD(at[6], at[26]); MULADD(at[7], at[25]); MULADD(at[8], at[24]); MULADD(at[9], at[23]); MULADD(at[10], at[22]); MULADD(at[11], at[21]); MULADD(at[12], at[20]); MULADD(at[13], at[19]); MULADD(at[14], at[18]); MULADD(at[15], at[17]);
407             COMBA_STORE(C->dp[16]);
408             /* 17 */
409             COMBA_FORWARD;
410             MULADD(at[2], at[31]); MULADD(at[3], at[30]); MULADD(at[4], at[29]); MULADD(at[5], at[28]); MULADD(at[6], at[27]); MULADD(at[7], at[26]); MULADD(at[8], at[25]); MULADD(at[9], at[24]); MULADD(at[10], at[23]); MULADD(at[11], at[22]); MULADD(at[12], at[21]); MULADD(at[13], at[20]); MULADD(at[14], at[19]); MULADD(at[15], at[18]);
411             COMBA_STORE(C->dp[17]);
412             /* 18 */
413             COMBA_FORWARD;
414             MULADD(at[3], at[31]); MULADD(at[4], at[30]); MULADD(at[5], at[29]); MULADD(at[6], at[28]); MULADD(at[7], at[27]); MULADD(at[8], at[26]); MULADD(at[9], at[25]); MULADD(at[10], at[24]); MULADD(at[11], at[23]); MULADD(at[12], at[22]); MULADD(at[13], at[21]); MULADD(at[14], at[20]); MULADD(at[15], at[19]);
415             COMBA_STORE(C->dp[18]);
416             /* 19 */
417             COMBA_FORWARD;
418             MULADD(at[4], at[31]); MULADD(at[5], at[30]); MULADD(at[6], at[29]); MULADD(at[7], at[28]); MULADD(at[8], at[27]); MULADD(at[9], at[26]); MULADD(at[10], at[25]); MULADD(at[11], at[24]); MULADD(at[12], at[23]); MULADD(at[13], at[22]); MULADD(at[14], at[21]); MULADD(at[15], at[20]);
419             COMBA_STORE(C->dp[19]);
420             /* 20 */
421             COMBA_FORWARD;
422             MULADD(at[5], at[31]); MULADD(at[6], at[30]); MULADD(at[7], at[29]); MULADD(at[8], at[28]); MULADD(at[9], at[27]); MULADD(at[10], at[26]); MULADD(at[11], at[25]); MULADD(at[12], at[24]); MULADD(at[13], at[23]); MULADD(at[14], at[22]); MULADD(at[15], at[21]);
423             COMBA_STORE(C->dp[20]);
424             /* 21 */
425             COMBA_FORWARD;
426             MULADD(at[6], at[31]); MULADD(at[7], at[30]); MULADD(at[8], at[29]); MULADD(at[9], at[28]); MULADD(at[10], at[27]); MULADD(at[11], at[26]); MULADD(at[12], at[25]); MULADD(at[13], at[24]); MULADD(at[14], at[23]); MULADD(at[15], at[22]);
427             COMBA_STORE(C->dp[21]);
428             /* 22 */
429             COMBA_FORWARD;
430             MULADD(at[7], at[31]); MULADD(at[8], at[30]); MULADD(at[9], at[29]); MULADD(at[10], at[28]); MULADD(at[11], at[27]); MULADD(at[12], at[26]); MULADD(at[13], at[25]); MULADD(at[14], at[24]); MULADD(at[15], at[23]);
431             COMBA_STORE(C->dp[22]);
432             /* 23 */
433             COMBA_FORWARD;
434             MULADD(at[8], at[31]); MULADD(at[9], at[30]); MULADD(at[10], at[29]); MULADD(at[11], at[28]); MULADD(at[12], at[27]); MULADD(at[13], at[26]); MULADD(at[14], at[25]); MULADD(at[15], at[24]);
435             COMBA_STORE(C->dp[23]);
436             /* 24 */
437             COMBA_FORWARD;
438             MULADD(at[9], at[31]); MULADD(at[10], at[30]); MULADD(at[11], at[29]); MULADD(at[12], at[28]); MULADD(at[13], at[27]); MULADD(at[14], at[26]); MULADD(at[15], at[25]);
439             COMBA_STORE(C->dp[24]);
440             /* 25 */
441             COMBA_FORWARD;
442             MULADD(at[10], at[31]); MULADD(at[11], at[30]); MULADD(at[12], at[29]); MULADD(at[13], at[28]); MULADD(at[14], at[27]); MULADD(at[15], at[26]);
443             COMBA_STORE(C->dp[25]);
444             /* 26 */
445             COMBA_FORWARD;
446             MULADD(at[11], at[31]); MULADD(at[12], at[30]); MULADD(at[13], at[29]); MULADD(at[14], at[28]); MULADD(at[15], at[27]);
447             COMBA_STORE(C->dp[26]);
448             /* 27 */
449             COMBA_FORWARD;
450             MULADD(at[12], at[31]); MULADD(at[13], at[30]); MULADD(at[14], at[29]); MULADD(at[15], at[28]);
451             COMBA_STORE(C->dp[27]);
452             /* 28 */
453             COMBA_FORWARD;
454             MULADD(at[13], at[31]); MULADD(at[14], at[30]); MULADD(at[15], at[29]);
455             COMBA_STORE(C->dp[28]);
456             /* 29 */
457             COMBA_FORWARD;
458             MULADD(at[14], at[31]); MULADD(at[15], at[30]);
459             COMBA_STORE(C->dp[29]);
460             /* 30 */
461             COMBA_FORWARD;
462             MULADD(at[15], at[31]);
463             COMBA_STORE(C->dp[30]);
464             COMBA_STORE2(C->dp[31]);
465             C->used = 32;
466             C->sign = A->sign ^ B->sign;
467             pstm_clamp(C);
468             COMBA_FINI;
469             return PSTM_OKAY;
470             }
471             # endif /* USE_1024_KEY_SPEED_OPTIMIZATIONS */
472              
473              
474             # ifdef USE_2048_KEY_SPEED_OPTIMIZATIONS
475             static int32_t pstm_mul_comba32(const pstm_int *A, const pstm_int *B, pstm_int *C)
476             {
477             pstm_digit c0, c1, c2, at[64];
478             int32 out_size;
479              
480             if (C->alloc < 64)
481             {
482             if (pstm_grow(C, 64) != PSTM_OKAY)
483             {
484             return PS_MEM_FAIL;
485             }
486             }
487              
488             out_size = A->used + B->used;
489             memcpy(at, A->dp, 32 * sizeof(pstm_digit));
490             memcpy(at + 32, B->dp, 32 * sizeof(pstm_digit));
491             COMBA_START;
492              
493             COMBA_CLEAR;
494             /* 0 */
495             MULADD(at[0], at[32]);
496             COMBA_STORE(C->dp[0]);
497             /* 1 */
498             COMBA_FORWARD;
499             MULADD(at[0], at[33]); MULADD(at[1], at[32]);
500             COMBA_STORE(C->dp[1]);
501             /* 2 */
502             COMBA_FORWARD;
503             MULADD(at[0], at[34]); MULADD(at[1], at[33]); MULADD(at[2], at[32]);
504             COMBA_STORE(C->dp[2]);
505             /* 3 */
506             COMBA_FORWARD;
507             MULADD(at[0], at[35]); MULADD(at[1], at[34]); MULADD(at[2], at[33]); MULADD(at[3], at[32]);
508             COMBA_STORE(C->dp[3]);
509             /* 4 */
510             COMBA_FORWARD;
511             MULADD(at[0], at[36]); MULADD(at[1], at[35]); MULADD(at[2], at[34]); MULADD(at[3], at[33]); MULADD(at[4], at[32]);
512             COMBA_STORE(C->dp[4]);
513             /* 5 */
514             COMBA_FORWARD;
515             MULADD(at[0], at[37]); MULADD(at[1], at[36]); MULADD(at[2], at[35]); MULADD(at[3], at[34]); MULADD(at[4], at[33]); MULADD(at[5], at[32]);
516             COMBA_STORE(C->dp[5]);
517             /* 6 */
518             COMBA_FORWARD;
519             MULADD(at[0], at[38]); MULADD(at[1], at[37]); MULADD(at[2], at[36]); MULADD(at[3], at[35]); MULADD(at[4], at[34]); MULADD(at[5], at[33]); MULADD(at[6], at[32]);
520             COMBA_STORE(C->dp[6]);
521             /* 7 */
522             COMBA_FORWARD;
523             MULADD(at[0], at[39]); MULADD(at[1], at[38]); MULADD(at[2], at[37]); MULADD(at[3], at[36]); MULADD(at[4], at[35]); MULADD(at[5], at[34]); MULADD(at[6], at[33]); MULADD(at[7], at[32]);
524             COMBA_STORE(C->dp[7]);
525             /* 8 */
526             COMBA_FORWARD;
527             MULADD(at[0], at[40]); MULADD(at[1], at[39]); MULADD(at[2], at[38]); MULADD(at[3], at[37]); MULADD(at[4], at[36]); MULADD(at[5], at[35]); MULADD(at[6], at[34]); MULADD(at[7], at[33]); MULADD(at[8], at[32]);
528             COMBA_STORE(C->dp[8]);
529             /* 9 */
530             COMBA_FORWARD;
531             MULADD(at[0], at[41]); MULADD(at[1], at[40]); MULADD(at[2], at[39]); MULADD(at[3], at[38]); MULADD(at[4], at[37]); MULADD(at[5], at[36]); MULADD(at[6], at[35]); MULADD(at[7], at[34]); MULADD(at[8], at[33]); MULADD(at[9], at[32]);
532             COMBA_STORE(C->dp[9]);
533             /* 10 */
534             COMBA_FORWARD;
535             MULADD(at[0], at[42]); MULADD(at[1], at[41]); MULADD(at[2], at[40]); MULADD(at[3], at[39]); MULADD(at[4], at[38]); MULADD(at[5], at[37]); MULADD(at[6], at[36]); MULADD(at[7], at[35]); MULADD(at[8], at[34]); MULADD(at[9], at[33]); MULADD(at[10], at[32]);
536             COMBA_STORE(C->dp[10]);
537             /* 11 */
538             COMBA_FORWARD;
539             MULADD(at[0], at[43]); MULADD(at[1], at[42]); MULADD(at[2], at[41]); MULADD(at[3], at[40]); MULADD(at[4], at[39]); MULADD(at[5], at[38]); MULADD(at[6], at[37]); MULADD(at[7], at[36]); MULADD(at[8], at[35]); MULADD(at[9], at[34]); MULADD(at[10], at[33]); MULADD(at[11], at[32]);
540             COMBA_STORE(C->dp[11]);
541             /* 12 */
542             COMBA_FORWARD;
543             MULADD(at[0], at[44]); MULADD(at[1], at[43]); MULADD(at[2], at[42]); MULADD(at[3], at[41]); MULADD(at[4], at[40]); MULADD(at[5], at[39]); MULADD(at[6], at[38]); MULADD(at[7], at[37]); MULADD(at[8], at[36]); MULADD(at[9], at[35]); MULADD(at[10], at[34]); MULADD(at[11], at[33]); MULADD(at[12], at[32]);
544             COMBA_STORE(C->dp[12]);
545             /* 13 */
546             COMBA_FORWARD;
547             MULADD(at[0], at[45]); MULADD(at[1], at[44]); MULADD(at[2], at[43]); MULADD(at[3], at[42]); MULADD(at[4], at[41]); MULADD(at[5], at[40]); MULADD(at[6], at[39]); MULADD(at[7], at[38]); MULADD(at[8], at[37]); MULADD(at[9], at[36]); MULADD(at[10], at[35]); MULADD(at[11], at[34]); MULADD(at[12], at[33]); MULADD(at[13], at[32]);
548             COMBA_STORE(C->dp[13]);
549             /* 14 */
550             COMBA_FORWARD;
551             MULADD(at[0], at[46]); MULADD(at[1], at[45]); MULADD(at[2], at[44]); MULADD(at[3], at[43]); MULADD(at[4], at[42]); MULADD(at[5], at[41]); MULADD(at[6], at[40]); MULADD(at[7], at[39]); MULADD(at[8], at[38]); MULADD(at[9], at[37]); MULADD(at[10], at[36]); MULADD(at[11], at[35]); MULADD(at[12], at[34]); MULADD(at[13], at[33]); MULADD(at[14], at[32]);
552             COMBA_STORE(C->dp[14]);
553             /* 15 */
554             COMBA_FORWARD;
555             MULADD(at[0], at[47]); MULADD(at[1], at[46]); MULADD(at[2], at[45]); MULADD(at[3], at[44]); MULADD(at[4], at[43]); MULADD(at[5], at[42]); MULADD(at[6], at[41]); MULADD(at[7], at[40]); MULADD(at[8], at[39]); MULADD(at[9], at[38]); MULADD(at[10], at[37]); MULADD(at[11], at[36]); MULADD(at[12], at[35]); MULADD(at[13], at[34]); MULADD(at[14], at[33]); MULADD(at[15], at[32]);
556             COMBA_STORE(C->dp[15]);
557             /* 16 */
558             COMBA_FORWARD;
559             MULADD(at[0], at[48]); MULADD(at[1], at[47]); MULADD(at[2], at[46]); MULADD(at[3], at[45]); MULADD(at[4], at[44]); MULADD(at[5], at[43]); MULADD(at[6], at[42]); MULADD(at[7], at[41]); MULADD(at[8], at[40]); MULADD(at[9], at[39]); MULADD(at[10], at[38]); MULADD(at[11], at[37]); MULADD(at[12], at[36]); MULADD(at[13], at[35]); MULADD(at[14], at[34]); MULADD(at[15], at[33]); MULADD(at[16], at[32]);
560             COMBA_STORE(C->dp[16]);
561             /* 17 */
562             COMBA_FORWARD;
563             MULADD(at[0], at[49]); MULADD(at[1], at[48]); MULADD(at[2], at[47]); MULADD(at[3], at[46]); MULADD(at[4], at[45]); MULADD(at[5], at[44]); MULADD(at[6], at[43]); MULADD(at[7], at[42]); MULADD(at[8], at[41]); MULADD(at[9], at[40]); MULADD(at[10], at[39]); MULADD(at[11], at[38]); MULADD(at[12], at[37]); MULADD(at[13], at[36]); MULADD(at[14], at[35]); MULADD(at[15], at[34]); MULADD(at[16], at[33]); MULADD(at[17], at[32]);
564             COMBA_STORE(C->dp[17]);
565             /* 18 */
566             COMBA_FORWARD;
567             MULADD(at[0], at[50]); MULADD(at[1], at[49]); MULADD(at[2], at[48]); MULADD(at[3], at[47]); MULADD(at[4], at[46]); MULADD(at[5], at[45]); MULADD(at[6], at[44]); MULADD(at[7], at[43]); MULADD(at[8], at[42]); MULADD(at[9], at[41]); MULADD(at[10], at[40]); MULADD(at[11], at[39]); MULADD(at[12], at[38]); MULADD(at[13], at[37]); MULADD(at[14], at[36]); MULADD(at[15], at[35]); MULADD(at[16], at[34]); MULADD(at[17], at[33]); MULADD(at[18], at[32]);
568             COMBA_STORE(C->dp[18]);
569             /* 19 */
570             COMBA_FORWARD;
571             MULADD(at[0], at[51]); MULADD(at[1], at[50]); MULADD(at[2], at[49]); MULADD(at[3], at[48]); MULADD(at[4], at[47]); MULADD(at[5], at[46]); MULADD(at[6], at[45]); MULADD(at[7], at[44]); MULADD(at[8], at[43]); MULADD(at[9], at[42]); MULADD(at[10], at[41]); MULADD(at[11], at[40]); MULADD(at[12], at[39]); MULADD(at[13], at[38]); MULADD(at[14], at[37]); MULADD(at[15], at[36]); MULADD(at[16], at[35]); MULADD(at[17], at[34]); MULADD(at[18], at[33]); MULADD(at[19], at[32]);
572             COMBA_STORE(C->dp[19]);
573             /* 20 */
574             COMBA_FORWARD;
575             MULADD(at[0], at[52]); MULADD(at[1], at[51]); MULADD(at[2], at[50]); MULADD(at[3], at[49]); MULADD(at[4], at[48]); MULADD(at[5], at[47]); MULADD(at[6], at[46]); MULADD(at[7], at[45]); MULADD(at[8], at[44]); MULADD(at[9], at[43]); MULADD(at[10], at[42]); MULADD(at[11], at[41]); MULADD(at[12], at[40]); MULADD(at[13], at[39]); MULADD(at[14], at[38]); MULADD(at[15], at[37]); MULADD(at[16], at[36]); MULADD(at[17], at[35]); MULADD(at[18], at[34]); MULADD(at[19], at[33]); MULADD(at[20], at[32]);
576             COMBA_STORE(C->dp[20]);
577             /* 21 */
578             COMBA_FORWARD;
579             MULADD(at[0], at[53]); MULADD(at[1], at[52]); MULADD(at[2], at[51]); MULADD(at[3], at[50]); MULADD(at[4], at[49]); MULADD(at[5], at[48]); MULADD(at[6], at[47]); MULADD(at[7], at[46]); MULADD(at[8], at[45]); MULADD(at[9], at[44]); MULADD(at[10], at[43]); MULADD(at[11], at[42]); MULADD(at[12], at[41]); MULADD(at[13], at[40]); MULADD(at[14], at[39]); MULADD(at[15], at[38]); MULADD(at[16], at[37]); MULADD(at[17], at[36]); MULADD(at[18], at[35]); MULADD(at[19], at[34]); MULADD(at[20], at[33]); MULADD(at[21], at[32]);
580             COMBA_STORE(C->dp[21]);
581             /* 22 */
582             COMBA_FORWARD;
583             MULADD(at[0], at[54]); MULADD(at[1], at[53]); MULADD(at[2], at[52]); MULADD(at[3], at[51]); MULADD(at[4], at[50]); MULADD(at[5], at[49]); MULADD(at[6], at[48]); MULADD(at[7], at[47]); MULADD(at[8], at[46]); MULADD(at[9], at[45]); MULADD(at[10], at[44]); MULADD(at[11], at[43]); MULADD(at[12], at[42]); MULADD(at[13], at[41]); MULADD(at[14], at[40]); MULADD(at[15], at[39]); MULADD(at[16], at[38]); MULADD(at[17], at[37]); MULADD(at[18], at[36]); MULADD(at[19], at[35]); MULADD(at[20], at[34]); MULADD(at[21], at[33]); MULADD(at[22], at[32]);
584             COMBA_STORE(C->dp[22]);
585             /* 23 */
586             COMBA_FORWARD;
587             MULADD(at[0], at[55]); MULADD(at[1], at[54]); MULADD(at[2], at[53]); MULADD(at[3], at[52]); MULADD(at[4], at[51]); MULADD(at[5], at[50]); MULADD(at[6], at[49]); MULADD(at[7], at[48]); MULADD(at[8], at[47]); MULADD(at[9], at[46]); MULADD(at[10], at[45]); MULADD(at[11], at[44]); MULADD(at[12], at[43]); MULADD(at[13], at[42]); MULADD(at[14], at[41]); MULADD(at[15], at[40]); MULADD(at[16], at[39]); MULADD(at[17], at[38]); MULADD(at[18], at[37]); MULADD(at[19], at[36]); MULADD(at[20], at[35]); MULADD(at[21], at[34]); MULADD(at[22], at[33]); MULADD(at[23], at[32]);
588             COMBA_STORE(C->dp[23]);
589             /* 24 */
590             COMBA_FORWARD;
591             MULADD(at[0], at[56]); MULADD(at[1], at[55]); MULADD(at[2], at[54]); MULADD(at[3], at[53]); MULADD(at[4], at[52]); MULADD(at[5], at[51]); MULADD(at[6], at[50]); MULADD(at[7], at[49]); MULADD(at[8], at[48]); MULADD(at[9], at[47]); MULADD(at[10], at[46]); MULADD(at[11], at[45]); MULADD(at[12], at[44]); MULADD(at[13], at[43]); MULADD(at[14], at[42]); MULADD(at[15], at[41]); MULADD(at[16], at[40]); MULADD(at[17], at[39]); MULADD(at[18], at[38]); MULADD(at[19], at[37]); MULADD(at[20], at[36]); MULADD(at[21], at[35]); MULADD(at[22], at[34]); MULADD(at[23], at[33]); MULADD(at[24], at[32]);
592             COMBA_STORE(C->dp[24]);
593             /* 25 */
594             COMBA_FORWARD;
595             MULADD(at[0], at[57]); MULADD(at[1], at[56]); MULADD(at[2], at[55]); MULADD(at[3], at[54]); MULADD(at[4], at[53]); MULADD(at[5], at[52]); MULADD(at[6], at[51]); MULADD(at[7], at[50]); MULADD(at[8], at[49]); MULADD(at[9], at[48]); MULADD(at[10], at[47]); MULADD(at[11], at[46]); MULADD(at[12], at[45]); MULADD(at[13], at[44]); MULADD(at[14], at[43]); MULADD(at[15], at[42]); MULADD(at[16], at[41]); MULADD(at[17], at[40]); MULADD(at[18], at[39]); MULADD(at[19], at[38]); MULADD(at[20], at[37]); MULADD(at[21], at[36]); MULADD(at[22], at[35]); MULADD(at[23], at[34]); MULADD(at[24], at[33]); MULADD(at[25], at[32]);
596             COMBA_STORE(C->dp[25]);
597             /* 26 */
598             COMBA_FORWARD;
599             MULADD(at[0], at[58]); MULADD(at[1], at[57]); MULADD(at[2], at[56]); MULADD(at[3], at[55]); MULADD(at[4], at[54]); MULADD(at[5], at[53]); MULADD(at[6], at[52]); MULADD(at[7], at[51]); MULADD(at[8], at[50]); MULADD(at[9], at[49]); MULADD(at[10], at[48]); MULADD(at[11], at[47]); MULADD(at[12], at[46]); MULADD(at[13], at[45]); MULADD(at[14], at[44]); MULADD(at[15], at[43]); MULADD(at[16], at[42]); MULADD(at[17], at[41]); MULADD(at[18], at[40]); MULADD(at[19], at[39]); MULADD(at[20], at[38]); MULADD(at[21], at[37]); MULADD(at[22], at[36]); MULADD(at[23], at[35]); MULADD(at[24], at[34]); MULADD(at[25], at[33]); MULADD(at[26], at[32]);
600             COMBA_STORE(C->dp[26]);
601             /* 27 */
602             COMBA_FORWARD;
603             MULADD(at[0], at[59]); MULADD(at[1], at[58]); MULADD(at[2], at[57]); MULADD(at[3], at[56]); MULADD(at[4], at[55]); MULADD(at[5], at[54]); MULADD(at[6], at[53]); MULADD(at[7], at[52]); MULADD(at[8], at[51]); MULADD(at[9], at[50]); MULADD(at[10], at[49]); MULADD(at[11], at[48]); MULADD(at[12], at[47]); MULADD(at[13], at[46]); MULADD(at[14], at[45]); MULADD(at[15], at[44]); MULADD(at[16], at[43]); MULADD(at[17], at[42]); MULADD(at[18], at[41]); MULADD(at[19], at[40]); MULADD(at[20], at[39]); MULADD(at[21], at[38]); MULADD(at[22], at[37]); MULADD(at[23], at[36]); MULADD(at[24], at[35]); MULADD(at[25], at[34]); MULADD(at[26], at[33]); MULADD(at[27], at[32]);
604             COMBA_STORE(C->dp[27]);
605             /* 28 */
606             COMBA_FORWARD;
607             MULADD(at[0], at[60]); MULADD(at[1], at[59]); MULADD(at[2], at[58]); MULADD(at[3], at[57]); MULADD(at[4], at[56]); MULADD(at[5], at[55]); MULADD(at[6], at[54]); MULADD(at[7], at[53]); MULADD(at[8], at[52]); MULADD(at[9], at[51]); MULADD(at[10], at[50]); MULADD(at[11], at[49]); MULADD(at[12], at[48]); MULADD(at[13], at[47]); MULADD(at[14], at[46]); MULADD(at[15], at[45]); MULADD(at[16], at[44]); MULADD(at[17], at[43]); MULADD(at[18], at[42]); MULADD(at[19], at[41]); MULADD(at[20], at[40]); MULADD(at[21], at[39]); MULADD(at[22], at[38]); MULADD(at[23], at[37]); MULADD(at[24], at[36]); MULADD(at[25], at[35]); MULADD(at[26], at[34]); MULADD(at[27], at[33]); MULADD(at[28], at[32]);
608             COMBA_STORE(C->dp[28]);
609             /* 29 */
610             COMBA_FORWARD;
611             MULADD(at[0], at[61]); MULADD(at[1], at[60]); MULADD(at[2], at[59]); MULADD(at[3], at[58]); MULADD(at[4], at[57]); MULADD(at[5], at[56]); MULADD(at[6], at[55]); MULADD(at[7], at[54]); MULADD(at[8], at[53]); MULADD(at[9], at[52]); MULADD(at[10], at[51]); MULADD(at[11], at[50]); MULADD(at[12], at[49]); MULADD(at[13], at[48]); MULADD(at[14], at[47]); MULADD(at[15], at[46]); MULADD(at[16], at[45]); MULADD(at[17], at[44]); MULADD(at[18], at[43]); MULADD(at[19], at[42]); MULADD(at[20], at[41]); MULADD(at[21], at[40]); MULADD(at[22], at[39]); MULADD(at[23], at[38]); MULADD(at[24], at[37]); MULADD(at[25], at[36]); MULADD(at[26], at[35]); MULADD(at[27], at[34]); MULADD(at[28], at[33]); MULADD(at[29], at[32]);
612             COMBA_STORE(C->dp[29]);
613             /* 30 */
614             COMBA_FORWARD;
615             MULADD(at[0], at[62]); MULADD(at[1], at[61]); MULADD(at[2], at[60]); MULADD(at[3], at[59]); MULADD(at[4], at[58]); MULADD(at[5], at[57]); MULADD(at[6], at[56]); MULADD(at[7], at[55]); MULADD(at[8], at[54]); MULADD(at[9], at[53]); MULADD(at[10], at[52]); MULADD(at[11], at[51]); MULADD(at[12], at[50]); MULADD(at[13], at[49]); MULADD(at[14], at[48]); MULADD(at[15], at[47]); MULADD(at[16], at[46]); MULADD(at[17], at[45]); MULADD(at[18], at[44]); MULADD(at[19], at[43]); MULADD(at[20], at[42]); MULADD(at[21], at[41]); MULADD(at[22], at[40]); MULADD(at[23], at[39]); MULADD(at[24], at[38]); MULADD(at[25], at[37]); MULADD(at[26], at[36]); MULADD(at[27], at[35]); MULADD(at[28], at[34]); MULADD(at[29], at[33]); MULADD(at[30], at[32]);
616             COMBA_STORE(C->dp[30]);
617             /* 31 */
618             COMBA_FORWARD;
619             MULADD(at[0], at[63]); MULADD(at[1], at[62]); MULADD(at[2], at[61]); MULADD(at[3], at[60]); MULADD(at[4], at[59]); MULADD(at[5], at[58]); MULADD(at[6], at[57]); MULADD(at[7], at[56]); MULADD(at[8], at[55]); MULADD(at[9], at[54]); MULADD(at[10], at[53]); MULADD(at[11], at[52]); MULADD(at[12], at[51]); MULADD(at[13], at[50]); MULADD(at[14], at[49]); MULADD(at[15], at[48]); MULADD(at[16], at[47]); MULADD(at[17], at[46]); MULADD(at[18], at[45]); MULADD(at[19], at[44]); MULADD(at[20], at[43]); MULADD(at[21], at[42]); MULADD(at[22], at[41]); MULADD(at[23], at[40]); MULADD(at[24], at[39]); MULADD(at[25], at[38]); MULADD(at[26], at[37]); MULADD(at[27], at[36]); MULADD(at[28], at[35]); MULADD(at[29], at[34]); MULADD(at[30], at[33]); MULADD(at[31], at[32]);
620             COMBA_STORE(C->dp[31]);
621             /* 32 */
622             COMBA_FORWARD;
623             MULADD(at[1], at[63]); MULADD(at[2], at[62]); MULADD(at[3], at[61]); MULADD(at[4], at[60]); MULADD(at[5], at[59]); MULADD(at[6], at[58]); MULADD(at[7], at[57]); MULADD(at[8], at[56]); MULADD(at[9], at[55]); MULADD(at[10], at[54]); MULADD(at[11], at[53]); MULADD(at[12], at[52]); MULADD(at[13], at[51]); MULADD(at[14], at[50]); MULADD(at[15], at[49]); MULADD(at[16], at[48]); MULADD(at[17], at[47]); MULADD(at[18], at[46]); MULADD(at[19], at[45]); MULADD(at[20], at[44]); MULADD(at[21], at[43]); MULADD(at[22], at[42]); MULADD(at[23], at[41]); MULADD(at[24], at[40]); MULADD(at[25], at[39]); MULADD(at[26], at[38]); MULADD(at[27], at[37]); MULADD(at[28], at[36]); MULADD(at[29], at[35]); MULADD(at[30], at[34]); MULADD(at[31], at[33]);
624             COMBA_STORE(C->dp[32]);
625             /* 33 */
626             COMBA_FORWARD;
627             MULADD(at[2], at[63]); MULADD(at[3], at[62]); MULADD(at[4], at[61]); MULADD(at[5], at[60]); MULADD(at[6], at[59]); MULADD(at[7], at[58]); MULADD(at[8], at[57]); MULADD(at[9], at[56]); MULADD(at[10], at[55]); MULADD(at[11], at[54]); MULADD(at[12], at[53]); MULADD(at[13], at[52]); MULADD(at[14], at[51]); MULADD(at[15], at[50]); MULADD(at[16], at[49]); MULADD(at[17], at[48]); MULADD(at[18], at[47]); MULADD(at[19], at[46]); MULADD(at[20], at[45]); MULADD(at[21], at[44]); MULADD(at[22], at[43]); MULADD(at[23], at[42]); MULADD(at[24], at[41]); MULADD(at[25], at[40]); MULADD(at[26], at[39]); MULADD(at[27], at[38]); MULADD(at[28], at[37]); MULADD(at[29], at[36]); MULADD(at[30], at[35]); MULADD(at[31], at[34]);
628             COMBA_STORE(C->dp[33]);
629             /* 34 */
630             COMBA_FORWARD;
631             MULADD(at[3], at[63]); MULADD(at[4], at[62]); MULADD(at[5], at[61]); MULADD(at[6], at[60]); MULADD(at[7], at[59]); MULADD(at[8], at[58]); MULADD(at[9], at[57]); MULADD(at[10], at[56]); MULADD(at[11], at[55]); MULADD(at[12], at[54]); MULADD(at[13], at[53]); MULADD(at[14], at[52]); MULADD(at[15], at[51]); MULADD(at[16], at[50]); MULADD(at[17], at[49]); MULADD(at[18], at[48]); MULADD(at[19], at[47]); MULADD(at[20], at[46]); MULADD(at[21], at[45]); MULADD(at[22], at[44]); MULADD(at[23], at[43]); MULADD(at[24], at[42]); MULADD(at[25], at[41]); MULADD(at[26], at[40]); MULADD(at[27], at[39]); MULADD(at[28], at[38]); MULADD(at[29], at[37]); MULADD(at[30], at[36]); MULADD(at[31], at[35]);
632             COMBA_STORE(C->dp[34]);
633             /* 35 */
634             COMBA_FORWARD;
635             MULADD(at[4], at[63]); MULADD(at[5], at[62]); MULADD(at[6], at[61]); MULADD(at[7], at[60]); MULADD(at[8], at[59]); MULADD(at[9], at[58]); MULADD(at[10], at[57]); MULADD(at[11], at[56]); MULADD(at[12], at[55]); MULADD(at[13], at[54]); MULADD(at[14], at[53]); MULADD(at[15], at[52]); MULADD(at[16], at[51]); MULADD(at[17], at[50]); MULADD(at[18], at[49]); MULADD(at[19], at[48]); MULADD(at[20], at[47]); MULADD(at[21], at[46]); MULADD(at[22], at[45]); MULADD(at[23], at[44]); MULADD(at[24], at[43]); MULADD(at[25], at[42]); MULADD(at[26], at[41]); MULADD(at[27], at[40]); MULADD(at[28], at[39]); MULADD(at[29], at[38]); MULADD(at[30], at[37]); MULADD(at[31], at[36]);
636             COMBA_STORE(C->dp[35]);
637             /* 36 */
638             COMBA_FORWARD;
639             MULADD(at[5], at[63]); MULADD(at[6], at[62]); MULADD(at[7], at[61]); MULADD(at[8], at[60]); MULADD(at[9], at[59]); MULADD(at[10], at[58]); MULADD(at[11], at[57]); MULADD(at[12], at[56]); MULADD(at[13], at[55]); MULADD(at[14], at[54]); MULADD(at[15], at[53]); MULADD(at[16], at[52]); MULADD(at[17], at[51]); MULADD(at[18], at[50]); MULADD(at[19], at[49]); MULADD(at[20], at[48]); MULADD(at[21], at[47]); MULADD(at[22], at[46]); MULADD(at[23], at[45]); MULADD(at[24], at[44]); MULADD(at[25], at[43]); MULADD(at[26], at[42]); MULADD(at[27], at[41]); MULADD(at[28], at[40]); MULADD(at[29], at[39]); MULADD(at[30], at[38]); MULADD(at[31], at[37]);
640             COMBA_STORE(C->dp[36]);
641             /* 37 */
642             COMBA_FORWARD;
643             MULADD(at[6], at[63]); MULADD(at[7], at[62]); MULADD(at[8], at[61]); MULADD(at[9], at[60]); MULADD(at[10], at[59]); MULADD(at[11], at[58]); MULADD(at[12], at[57]); MULADD(at[13], at[56]); MULADD(at[14], at[55]); MULADD(at[15], at[54]); MULADD(at[16], at[53]); MULADD(at[17], at[52]); MULADD(at[18], at[51]); MULADD(at[19], at[50]); MULADD(at[20], at[49]); MULADD(at[21], at[48]); MULADD(at[22], at[47]); MULADD(at[23], at[46]); MULADD(at[24], at[45]); MULADD(at[25], at[44]); MULADD(at[26], at[43]); MULADD(at[27], at[42]); MULADD(at[28], at[41]); MULADD(at[29], at[40]); MULADD(at[30], at[39]); MULADD(at[31], at[38]);
644             COMBA_STORE(C->dp[37]);
645             /* 38 */
646             COMBA_FORWARD;
647             MULADD(at[7], at[63]); MULADD(at[8], at[62]); MULADD(at[9], at[61]); MULADD(at[10], at[60]); MULADD(at[11], at[59]); MULADD(at[12], at[58]); MULADD(at[13], at[57]); MULADD(at[14], at[56]); MULADD(at[15], at[55]); MULADD(at[16], at[54]); MULADD(at[17], at[53]); MULADD(at[18], at[52]); MULADD(at[19], at[51]); MULADD(at[20], at[50]); MULADD(at[21], at[49]); MULADD(at[22], at[48]); MULADD(at[23], at[47]); MULADD(at[24], at[46]); MULADD(at[25], at[45]); MULADD(at[26], at[44]); MULADD(at[27], at[43]); MULADD(at[28], at[42]); MULADD(at[29], at[41]); MULADD(at[30], at[40]); MULADD(at[31], at[39]);
648             COMBA_STORE(C->dp[38]);
649              
650             /* early out at 40 digits, 40*32==1280, or two 640 bit operands */
651             if (out_size <= 40)
652             {
653             COMBA_STORE2(C->dp[39]); C->used = 40; C->sign = A->sign ^ B->sign; pstm_clamp(C); COMBA_FINI; return PSTM_OKAY;
654             }
655              
656             /* 39 */
657             COMBA_FORWARD;
658             MULADD(at[8], at[63]); MULADD(at[9], at[62]); MULADD(at[10], at[61]); MULADD(at[11], at[60]); MULADD(at[12], at[59]); MULADD(at[13], at[58]); MULADD(at[14], at[57]); MULADD(at[15], at[56]); MULADD(at[16], at[55]); MULADD(at[17], at[54]); MULADD(at[18], at[53]); MULADD(at[19], at[52]); MULADD(at[20], at[51]); MULADD(at[21], at[50]); MULADD(at[22], at[49]); MULADD(at[23], at[48]); MULADD(at[24], at[47]); MULADD(at[25], at[46]); MULADD(at[26], at[45]); MULADD(at[27], at[44]); MULADD(at[28], at[43]); MULADD(at[29], at[42]); MULADD(at[30], at[41]); MULADD(at[31], at[40]);
659             COMBA_STORE(C->dp[39]);
660             /* 40 */
661             COMBA_FORWARD;
662             MULADD(at[9], at[63]); MULADD(at[10], at[62]); MULADD(at[11], at[61]); MULADD(at[12], at[60]); MULADD(at[13], at[59]); MULADD(at[14], at[58]); MULADD(at[15], at[57]); MULADD(at[16], at[56]); MULADD(at[17], at[55]); MULADD(at[18], at[54]); MULADD(at[19], at[53]); MULADD(at[20], at[52]); MULADD(at[21], at[51]); MULADD(at[22], at[50]); MULADD(at[23], at[49]); MULADD(at[24], at[48]); MULADD(at[25], at[47]); MULADD(at[26], at[46]); MULADD(at[27], at[45]); MULADD(at[28], at[44]); MULADD(at[29], at[43]); MULADD(at[30], at[42]); MULADD(at[31], at[41]);
663             COMBA_STORE(C->dp[40]);
664             /* 41 */
665             COMBA_FORWARD;
666             MULADD(at[10], at[63]); MULADD(at[11], at[62]); MULADD(at[12], at[61]); MULADD(at[13], at[60]); MULADD(at[14], at[59]); MULADD(at[15], at[58]); MULADD(at[16], at[57]); MULADD(at[17], at[56]); MULADD(at[18], at[55]); MULADD(at[19], at[54]); MULADD(at[20], at[53]); MULADD(at[21], at[52]); MULADD(at[22], at[51]); MULADD(at[23], at[50]); MULADD(at[24], at[49]); MULADD(at[25], at[48]); MULADD(at[26], at[47]); MULADD(at[27], at[46]); MULADD(at[28], at[45]); MULADD(at[29], at[44]); MULADD(at[30], at[43]); MULADD(at[31], at[42]);
667             COMBA_STORE(C->dp[41]);
668             /* 42 */
669             COMBA_FORWARD;
670             MULADD(at[11], at[63]); MULADD(at[12], at[62]); MULADD(at[13], at[61]); MULADD(at[14], at[60]); MULADD(at[15], at[59]); MULADD(at[16], at[58]); MULADD(at[17], at[57]); MULADD(at[18], at[56]); MULADD(at[19], at[55]); MULADD(at[20], at[54]); MULADD(at[21], at[53]); MULADD(at[22], at[52]); MULADD(at[23], at[51]); MULADD(at[24], at[50]); MULADD(at[25], at[49]); MULADD(at[26], at[48]); MULADD(at[27], at[47]); MULADD(at[28], at[46]); MULADD(at[29], at[45]); MULADD(at[30], at[44]); MULADD(at[31], at[43]);
671             COMBA_STORE(C->dp[42]);
672             /* 43 */
673             COMBA_FORWARD;
674             MULADD(at[12], at[63]); MULADD(at[13], at[62]); MULADD(at[14], at[61]); MULADD(at[15], at[60]); MULADD(at[16], at[59]); MULADD(at[17], at[58]); MULADD(at[18], at[57]); MULADD(at[19], at[56]); MULADD(at[20], at[55]); MULADD(at[21], at[54]); MULADD(at[22], at[53]); MULADD(at[23], at[52]); MULADD(at[24], at[51]); MULADD(at[25], at[50]); MULADD(at[26], at[49]); MULADD(at[27], at[48]); MULADD(at[28], at[47]); MULADD(at[29], at[46]); MULADD(at[30], at[45]); MULADD(at[31], at[44]);
675             COMBA_STORE(C->dp[43]);
676             /* 44 */
677             COMBA_FORWARD;
678             MULADD(at[13], at[63]); MULADD(at[14], at[62]); MULADD(at[15], at[61]); MULADD(at[16], at[60]); MULADD(at[17], at[59]); MULADD(at[18], at[58]); MULADD(at[19], at[57]); MULADD(at[20], at[56]); MULADD(at[21], at[55]); MULADD(at[22], at[54]); MULADD(at[23], at[53]); MULADD(at[24], at[52]); MULADD(at[25], at[51]); MULADD(at[26], at[50]); MULADD(at[27], at[49]); MULADD(at[28], at[48]); MULADD(at[29], at[47]); MULADD(at[30], at[46]); MULADD(at[31], at[45]);
679             COMBA_STORE(C->dp[44]);
680             /* 45 */
681             COMBA_FORWARD;
682             MULADD(at[14], at[63]); MULADD(at[15], at[62]); MULADD(at[16], at[61]); MULADD(at[17], at[60]); MULADD(at[18], at[59]); MULADD(at[19], at[58]); MULADD(at[20], at[57]); MULADD(at[21], at[56]); MULADD(at[22], at[55]); MULADD(at[23], at[54]); MULADD(at[24], at[53]); MULADD(at[25], at[52]); MULADD(at[26], at[51]); MULADD(at[27], at[50]); MULADD(at[28], at[49]); MULADD(at[29], at[48]); MULADD(at[30], at[47]); MULADD(at[31], at[46]);
683             COMBA_STORE(C->dp[45]);
684             /* 46 */
685             COMBA_FORWARD;
686             MULADD(at[15], at[63]); MULADD(at[16], at[62]); MULADD(at[17], at[61]); MULADD(at[18], at[60]); MULADD(at[19], at[59]); MULADD(at[20], at[58]); MULADD(at[21], at[57]); MULADD(at[22], at[56]); MULADD(at[23], at[55]); MULADD(at[24], at[54]); MULADD(at[25], at[53]); MULADD(at[26], at[52]); MULADD(at[27], at[51]); MULADD(at[28], at[50]); MULADD(at[29], at[49]); MULADD(at[30], at[48]); MULADD(at[31], at[47]);
687             COMBA_STORE(C->dp[46]);
688              
689             /* early out at 48 digits, 48*32==1536, or two 768 bit operands */
690             if (out_size <= 48)
691             {
692             COMBA_STORE2(C->dp[47]); C->used = 48; C->sign = A->sign ^ B->sign; pstm_clamp(C); COMBA_FINI; return PSTM_OKAY;
693             }
694              
695             /* 47 */
696             COMBA_FORWARD;
697             MULADD(at[16], at[63]); MULADD(at[17], at[62]); MULADD(at[18], at[61]); MULADD(at[19], at[60]); MULADD(at[20], at[59]); MULADD(at[21], at[58]); MULADD(at[22], at[57]); MULADD(at[23], at[56]); MULADD(at[24], at[55]); MULADD(at[25], at[54]); MULADD(at[26], at[53]); MULADD(at[27], at[52]); MULADD(at[28], at[51]); MULADD(at[29], at[50]); MULADD(at[30], at[49]); MULADD(at[31], at[48]);
698             COMBA_STORE(C->dp[47]);
699             /* 48 */
700             COMBA_FORWARD;
701             MULADD(at[17], at[63]); MULADD(at[18], at[62]); MULADD(at[19], at[61]); MULADD(at[20], at[60]); MULADD(at[21], at[59]); MULADD(at[22], at[58]); MULADD(at[23], at[57]); MULADD(at[24], at[56]); MULADD(at[25], at[55]); MULADD(at[26], at[54]); MULADD(at[27], at[53]); MULADD(at[28], at[52]); MULADD(at[29], at[51]); MULADD(at[30], at[50]); MULADD(at[31], at[49]);
702             COMBA_STORE(C->dp[48]);
703             /* 49 */
704             COMBA_FORWARD;
705             MULADD(at[18], at[63]); MULADD(at[19], at[62]); MULADD(at[20], at[61]); MULADD(at[21], at[60]); MULADD(at[22], at[59]); MULADD(at[23], at[58]); MULADD(at[24], at[57]); MULADD(at[25], at[56]); MULADD(at[26], at[55]); MULADD(at[27], at[54]); MULADD(at[28], at[53]); MULADD(at[29], at[52]); MULADD(at[30], at[51]); MULADD(at[31], at[50]);
706             COMBA_STORE(C->dp[49]);
707             /* 50 */
708             COMBA_FORWARD;
709             MULADD(at[19], at[63]); MULADD(at[20], at[62]); MULADD(at[21], at[61]); MULADD(at[22], at[60]); MULADD(at[23], at[59]); MULADD(at[24], at[58]); MULADD(at[25], at[57]); MULADD(at[26], at[56]); MULADD(at[27], at[55]); MULADD(at[28], at[54]); MULADD(at[29], at[53]); MULADD(at[30], at[52]); MULADD(at[31], at[51]);
710             COMBA_STORE(C->dp[50]);
711             /* 51 */
712             COMBA_FORWARD;
713             MULADD(at[20], at[63]); MULADD(at[21], at[62]); MULADD(at[22], at[61]); MULADD(at[23], at[60]); MULADD(at[24], at[59]); MULADD(at[25], at[58]); MULADD(at[26], at[57]); MULADD(at[27], at[56]); MULADD(at[28], at[55]); MULADD(at[29], at[54]); MULADD(at[30], at[53]); MULADD(at[31], at[52]);
714             COMBA_STORE(C->dp[51]);
715             /* 52 */
716             COMBA_FORWARD;
717             MULADD(at[21], at[63]); MULADD(at[22], at[62]); MULADD(at[23], at[61]); MULADD(at[24], at[60]); MULADD(at[25], at[59]); MULADD(at[26], at[58]); MULADD(at[27], at[57]); MULADD(at[28], at[56]); MULADD(at[29], at[55]); MULADD(at[30], at[54]); MULADD(at[31], at[53]);
718             COMBA_STORE(C->dp[52]);
719             /* 53 */
720             COMBA_FORWARD;
721             MULADD(at[22], at[63]); MULADD(at[23], at[62]); MULADD(at[24], at[61]); MULADD(at[25], at[60]); MULADD(at[26], at[59]); MULADD(at[27], at[58]); MULADD(at[28], at[57]); MULADD(at[29], at[56]); MULADD(at[30], at[55]); MULADD(at[31], at[54]);
722             COMBA_STORE(C->dp[53]);
723             /* 54 */
724             COMBA_FORWARD;
725             MULADD(at[23], at[63]); MULADD(at[24], at[62]); MULADD(at[25], at[61]); MULADD(at[26], at[60]); MULADD(at[27], at[59]); MULADD(at[28], at[58]); MULADD(at[29], at[57]); MULADD(at[30], at[56]); MULADD(at[31], at[55]);
726             COMBA_STORE(C->dp[54]);
727              
728             /* early out at 56 digits, 56*32==1792, or two 896 bit operands */
729             if (out_size <= 56)
730             {
731             COMBA_STORE2(C->dp[55]); C->used = 56; C->sign = A->sign ^ B->sign; pstm_clamp(C); COMBA_FINI; return PSTM_OKAY;
732             }
733              
734             /* 55 */
735             COMBA_FORWARD;
736             MULADD(at[24], at[63]); MULADD(at[25], at[62]); MULADD(at[26], at[61]); MULADD(at[27], at[60]); MULADD(at[28], at[59]); MULADD(at[29], at[58]); MULADD(at[30], at[57]); MULADD(at[31], at[56]);
737             COMBA_STORE(C->dp[55]);
738             /* 56 */
739             COMBA_FORWARD;
740             MULADD(at[25], at[63]); MULADD(at[26], at[62]); MULADD(at[27], at[61]); MULADD(at[28], at[60]); MULADD(at[29], at[59]); MULADD(at[30], at[58]); MULADD(at[31], at[57]);
741             COMBA_STORE(C->dp[56]);
742             /* 57 */
743             COMBA_FORWARD;
744             MULADD(at[26], at[63]); MULADD(at[27], at[62]); MULADD(at[28], at[61]); MULADD(at[29], at[60]); MULADD(at[30], at[59]); MULADD(at[31], at[58]);
745             COMBA_STORE(C->dp[57]);
746             /* 58 */
747             COMBA_FORWARD;
748             MULADD(at[27], at[63]); MULADD(at[28], at[62]); MULADD(at[29], at[61]); MULADD(at[30], at[60]); MULADD(at[31], at[59]);
749             COMBA_STORE(C->dp[58]);
750             /* 59 */
751             COMBA_FORWARD;
752             MULADD(at[28], at[63]); MULADD(at[29], at[62]); MULADD(at[30], at[61]); MULADD(at[31], at[60]);
753             COMBA_STORE(C->dp[59]);
754             /* 60 */
755             COMBA_FORWARD;
756             MULADD(at[29], at[63]); MULADD(at[30], at[62]); MULADD(at[31], at[61]);
757             COMBA_STORE(C->dp[60]);
758             /* 61 */
759             COMBA_FORWARD;
760             MULADD(at[30], at[63]); MULADD(at[31], at[62]);
761             COMBA_STORE(C->dp[61]);
762             /* 62 */
763             COMBA_FORWARD;
764             MULADD(at[31], at[63]);
765             COMBA_STORE(C->dp[62]);
766             COMBA_STORE2(C->dp[63]);
767             C->used = 64;
768             C->sign = A->sign ^ B->sign;
769             pstm_clamp(C);
770             COMBA_FINI;
771             return PSTM_OKAY;
772             }
773             # endif /* USE_2048_KEY_SPEED_OPTIMIZATIONS */
774              
775             /******************************************************************************/
776              
777 7407000           int32 pstm_mul_comba(psPool_t *pool, const pstm_int *A, const pstm_int *B, pstm_int *C,
778             pstm_digit *paD, psSize_t paDlen)
779             {
780             # ifdef USE_1024_KEY_SPEED_OPTIMIZATIONS
781             if (A->used == 16 && B->used == 16)
782             {
783             return pstm_mul_comba16(A, B, C);
784             }
785             else
786             {
787             # ifdef USE_2048_KEY_SPEED_OPTIMIZATIONS
788             if (A->used == 32 && B->used == 32)
789             {
790             return pstm_mul_comba32(A, B, C);
791             }
792             # endif /* USE_2048_KEY_SPEED_OPTIMIZATIONS */
793             return pstm_mul_comba_gen(pool, A, B, C, paD, paDlen);
794             }
795             # else
796             # ifdef USE_2048_KEY_SPEED_OPTIMIZATIONS
797             if (A->used == 32 && B->used == 32)
798             {
799             return pstm_mul_comba32(A, B, C);
800             }
801             # endif /* USE_2048_KEY_SPEED_OPTIMIZATIONS */
802 7407000           return pstm_mul_comba_gen(pool, A, B, C, paD, paDlen);
803             # endif
804             }
805              
806             #endif /* defined(USE_MATRIX_RSA) || defined(USE_MATRIX_ECC) */
807              
808             /******************************************************************************/
809