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