takashi kadono / Mbed OS Nucleo_446

Dependencies:   ssd1331

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers bn_mul.h Source File

bn_mul.h

Go to the documentation of this file.
00001 /**
00002  * \file bn_mul.h
00003  *
00004  * \brief Multi-precision integer library
00005  */
00006 /*
00007  *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
00008  *  SPDX-License-Identifier: Apache-2.0
00009  *
00010  *  Licensed under the Apache License, Version 2.0 (the "License"); you may
00011  *  not use this file except in compliance with the License.
00012  *  You may obtain a copy of the License at
00013  *
00014  *  http://www.apache.org/licenses/LICENSE-2.0
00015  *
00016  *  Unless required by applicable law or agreed to in writing, software
00017  *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
00018  *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00019  *  See the License for the specific language governing permissions and
00020  *  limitations under the License.
00021  *
00022  *  This file is part of mbed TLS (https://tls.mbed.org)
00023  */
00024 /*
00025  *      Multiply source vector [s] with b, add result
00026  *       to destination vector [d] and set carry c.
00027  *
00028  *      Currently supports:
00029  *
00030  *         . IA-32 (386+)         . AMD64 / EM64T
00031  *         . IA-32 (SSE2)         . Motorola 68000
00032  *         . PowerPC, 32-bit      . MicroBlaze
00033  *         . PowerPC, 64-bit      . TriCore
00034  *         . SPARC v8             . ARM v3+
00035  *         . Alpha                . MIPS32
00036  *         . C, longlong          . C, generic
00037  */
00038 #ifndef MBEDTLS_BN_MUL_H
00039 #define MBEDTLS_BN_MUL_H
00040 
00041 #include "bignum.h"
00042 
00043 #if defined(MBEDTLS_HAVE_ASM)
00044 
00045 #ifndef asm
00046 #define asm __asm
00047 #endif
00048 
00049 /* armcc5 --gnu defines __GNUC__ but doesn't support GNU's extended asm */
00050 #if defined(__GNUC__) && \
00051     ( !defined(__ARMCC_VERSION) || __ARMCC_VERSION >= 6000000 )
00052 
00053 /*
00054  * Disable use of the i386 assembly code below if option -O0, to disable all
00055  * compiler optimisations, is passed, detected with __OPTIMIZE__
00056  * This is done as the number of registers used in the assembly code doesn't
00057  * work with the -O0 option.
00058  */
00059 #if defined(__i386__) && defined(__OPTIMIZE__)
00060 
00061 #define MULADDC_INIT                        \
00062     asm(                                    \
00063         "movl   %%ebx, %0           \n\t"   \
00064         "movl   %5, %%esi           \n\t"   \
00065         "movl   %6, %%edi           \n\t"   \
00066         "movl   %7, %%ecx           \n\t"   \
00067         "movl   %8, %%ebx           \n\t"
00068 
00069 #define MULADDC_CORE                        \
00070         "lodsl                      \n\t"   \
00071         "mull   %%ebx               \n\t"   \
00072         "addl   %%ecx,   %%eax      \n\t"   \
00073         "adcl   $0,      %%edx      \n\t"   \
00074         "addl   (%%edi), %%eax      \n\t"   \
00075         "adcl   $0,      %%edx      \n\t"   \
00076         "movl   %%edx,   %%ecx      \n\t"   \
00077         "stosl                      \n\t"
00078 
00079 #if defined(MBEDTLS_HAVE_SSE2)
00080 
00081 #define MULADDC_HUIT                            \
00082         "movd     %%ecx,     %%mm1      \n\t"   \
00083         "movd     %%ebx,     %%mm0      \n\t"   \
00084         "movd     (%%edi),   %%mm3      \n\t"   \
00085         "paddq    %%mm3,     %%mm1      \n\t"   \
00086         "movd     (%%esi),   %%mm2      \n\t"   \
00087         "pmuludq  %%mm0,     %%mm2      \n\t"   \
00088         "movd     4(%%esi),  %%mm4      \n\t"   \
00089         "pmuludq  %%mm0,     %%mm4      \n\t"   \
00090         "movd     8(%%esi),  %%mm6      \n\t"   \
00091         "pmuludq  %%mm0,     %%mm6      \n\t"   \
00092         "movd     12(%%esi), %%mm7      \n\t"   \
00093         "pmuludq  %%mm0,     %%mm7      \n\t"   \
00094         "paddq    %%mm2,     %%mm1      \n\t"   \
00095         "movd     4(%%edi),  %%mm3      \n\t"   \
00096         "paddq    %%mm4,     %%mm3      \n\t"   \
00097         "movd     8(%%edi),  %%mm5      \n\t"   \
00098         "paddq    %%mm6,     %%mm5      \n\t"   \
00099         "movd     12(%%edi), %%mm4      \n\t"   \
00100         "paddq    %%mm4,     %%mm7      \n\t"   \
00101         "movd     %%mm1,     (%%edi)    \n\t"   \
00102         "movd     16(%%esi), %%mm2      \n\t"   \
00103         "pmuludq  %%mm0,     %%mm2      \n\t"   \
00104         "psrlq    $32,       %%mm1      \n\t"   \
00105         "movd     20(%%esi), %%mm4      \n\t"   \
00106         "pmuludq  %%mm0,     %%mm4      \n\t"   \
00107         "paddq    %%mm3,     %%mm1      \n\t"   \
00108         "movd     24(%%esi), %%mm6      \n\t"   \
00109         "pmuludq  %%mm0,     %%mm6      \n\t"   \
00110         "movd     %%mm1,     4(%%edi)   \n\t"   \
00111         "psrlq    $32,       %%mm1      \n\t"   \
00112         "movd     28(%%esi), %%mm3      \n\t"   \
00113         "pmuludq  %%mm0,     %%mm3      \n\t"   \
00114         "paddq    %%mm5,     %%mm1      \n\t"   \
00115         "movd     16(%%edi), %%mm5      \n\t"   \
00116         "paddq    %%mm5,     %%mm2      \n\t"   \
00117         "movd     %%mm1,     8(%%edi)   \n\t"   \
00118         "psrlq    $32,       %%mm1      \n\t"   \
00119         "paddq    %%mm7,     %%mm1      \n\t"   \
00120         "movd     20(%%edi), %%mm5      \n\t"   \
00121         "paddq    %%mm5,     %%mm4      \n\t"   \
00122         "movd     %%mm1,     12(%%edi)  \n\t"   \
00123         "psrlq    $32,       %%mm1      \n\t"   \
00124         "paddq    %%mm2,     %%mm1      \n\t"   \
00125         "movd     24(%%edi), %%mm5      \n\t"   \
00126         "paddq    %%mm5,     %%mm6      \n\t"   \
00127         "movd     %%mm1,     16(%%edi)  \n\t"   \
00128         "psrlq    $32,       %%mm1      \n\t"   \
00129         "paddq    %%mm4,     %%mm1      \n\t"   \
00130         "movd     28(%%edi), %%mm5      \n\t"   \
00131         "paddq    %%mm5,     %%mm3      \n\t"   \
00132         "movd     %%mm1,     20(%%edi)  \n\t"   \
00133         "psrlq    $32,       %%mm1      \n\t"   \
00134         "paddq    %%mm6,     %%mm1      \n\t"   \
00135         "movd     %%mm1,     24(%%edi)  \n\t"   \
00136         "psrlq    $32,       %%mm1      \n\t"   \
00137         "paddq    %%mm3,     %%mm1      \n\t"   \
00138         "movd     %%mm1,     28(%%edi)  \n\t"   \
00139         "addl     $32,       %%edi      \n\t"   \
00140         "addl     $32,       %%esi      \n\t"   \
00141         "psrlq    $32,       %%mm1      \n\t"   \
00142         "movd     %%mm1,     %%ecx      \n\t"
00143 
00144 #define MULADDC_STOP                    \
00145         "emms                   \n\t"   \
00146         "movl   %4, %%ebx       \n\t"   \
00147         "movl   %%ecx, %1       \n\t"   \
00148         "movl   %%edi, %2       \n\t"   \
00149         "movl   %%esi, %3       \n\t"   \
00150         : "=m" (t), "=m" (c), "=m" (d), "=m" (s)        \
00151         : "m" (t), "m" (s), "m" (d), "m" (c), "m" (b)   \
00152         : "eax", "ebx", "ecx", "edx", "esi", "edi"      \
00153     );
00154 
00155 #else
00156 
00157 #define MULADDC_STOP                    \
00158         "movl   %4, %%ebx       \n\t"   \
00159         "movl   %%ecx, %1       \n\t"   \
00160         "movl   %%edi, %2       \n\t"   \
00161         "movl   %%esi, %3       \n\t"   \
00162         : "=m" (t), "=m" (c), "=m" (d), "=m" (s)        \
00163         : "m" (t), "m" (s), "m" (d), "m" (c), "m" (b)   \
00164         : "eax", "ebx", "ecx", "edx", "esi", "edi"      \
00165     );
00166 #endif /* SSE2 */
00167 #endif /* i386 */
00168 
00169 #if defined(__amd64__) || defined (__x86_64__)
00170 
00171 #define MULADDC_INIT                        \
00172     asm(                                    \
00173         "xorq   %%r8, %%r8          \n\t"
00174 
00175 #define MULADDC_CORE                        \
00176         "movq   (%%rsi), %%rax      \n\t"   \
00177         "mulq   %%rbx               \n\t"   \
00178         "addq   $8,      %%rsi      \n\t"   \
00179         "addq   %%rcx,   %%rax      \n\t"   \
00180         "movq   %%r8,    %%rcx      \n\t"   \
00181         "adcq   $0,      %%rdx      \n\t"   \
00182         "nop                        \n\t"   \
00183         "addq   %%rax,   (%%rdi)    \n\t"   \
00184         "adcq   %%rdx,   %%rcx      \n\t"   \
00185         "addq   $8,      %%rdi      \n\t"
00186 
00187 #define MULADDC_STOP                        \
00188         : "+c" (c), "+D" (d), "+S" (s)      \
00189         : "b" (b)                           \
00190         : "rax", "rdx", "r8"                \
00191     );
00192 
00193 #endif /* AMD64 */
00194 
00195 #if defined(__mc68020__) || defined(__mcpu32__)
00196 
00197 #define MULADDC_INIT                    \
00198     asm(                                \
00199         "movl   %3, %%a2        \n\t"   \
00200         "movl   %4, %%a3        \n\t"   \
00201         "movl   %5, %%d3        \n\t"   \
00202         "movl   %6, %%d2        \n\t"   \
00203         "moveq  #0, %%d0        \n\t"
00204 
00205 #define MULADDC_CORE                    \
00206         "movel  %%a2@+, %%d1    \n\t"   \
00207         "mulul  %%d2, %%d4:%%d1 \n\t"   \
00208         "addl   %%d3, %%d1      \n\t"   \
00209         "addxl  %%d0, %%d4      \n\t"   \
00210         "moveq  #0,   %%d3      \n\t"   \
00211         "addl   %%d1, %%a3@+    \n\t"   \
00212         "addxl  %%d4, %%d3      \n\t"
00213 
00214 #define MULADDC_STOP                    \
00215         "movl   %%d3, %0        \n\t"   \
00216         "movl   %%a3, %1        \n\t"   \
00217         "movl   %%a2, %2        \n\t"   \
00218         : "=m" (c), "=m" (d), "=m" (s)              \
00219         : "m" (s), "m" (d), "m" (c), "m" (b)        \
00220         : "d0", "d1", "d2", "d3", "d4", "a2", "a3"  \
00221     );
00222 
00223 #define MULADDC_HUIT                        \
00224         "movel  %%a2@+,  %%d1       \n\t"   \
00225         "mulul  %%d2,    %%d4:%%d1  \n\t"   \
00226         "addxl  %%d3,    %%d1       \n\t"   \
00227         "addxl  %%d0,    %%d4       \n\t"   \
00228         "addl   %%d1,    %%a3@+     \n\t"   \
00229         "movel  %%a2@+,  %%d1       \n\t"   \
00230         "mulul  %%d2,    %%d3:%%d1  \n\t"   \
00231         "addxl  %%d4,    %%d1       \n\t"   \
00232         "addxl  %%d0,    %%d3       \n\t"   \
00233         "addl   %%d1,    %%a3@+     \n\t"   \
00234         "movel  %%a2@+,  %%d1       \n\t"   \
00235         "mulul  %%d2,    %%d4:%%d1  \n\t"   \
00236         "addxl  %%d3,    %%d1       \n\t"   \
00237         "addxl  %%d0,    %%d4       \n\t"   \
00238         "addl   %%d1,    %%a3@+     \n\t"   \
00239         "movel  %%a2@+,  %%d1       \n\t"   \
00240         "mulul  %%d2,    %%d3:%%d1  \n\t"   \
00241         "addxl  %%d4,    %%d1       \n\t"   \
00242         "addxl  %%d0,    %%d3       \n\t"   \
00243         "addl   %%d1,    %%a3@+     \n\t"   \
00244         "movel  %%a2@+,  %%d1       \n\t"   \
00245         "mulul  %%d2,    %%d4:%%d1  \n\t"   \
00246         "addxl  %%d3,    %%d1       \n\t"   \
00247         "addxl  %%d0,    %%d4       \n\t"   \
00248         "addl   %%d1,    %%a3@+     \n\t"   \
00249         "movel  %%a2@+,  %%d1       \n\t"   \
00250         "mulul  %%d2,    %%d3:%%d1  \n\t"   \
00251         "addxl  %%d4,    %%d1       \n\t"   \
00252         "addxl  %%d0,    %%d3       \n\t"   \
00253         "addl   %%d1,    %%a3@+     \n\t"   \
00254         "movel  %%a2@+,  %%d1       \n\t"   \
00255         "mulul  %%d2,    %%d4:%%d1  \n\t"   \
00256         "addxl  %%d3,    %%d1       \n\t"   \
00257         "addxl  %%d0,    %%d4       \n\t"   \
00258         "addl   %%d1,    %%a3@+     \n\t"   \
00259         "movel  %%a2@+,  %%d1       \n\t"   \
00260         "mulul  %%d2,    %%d3:%%d1  \n\t"   \
00261         "addxl  %%d4,    %%d1       \n\t"   \
00262         "addxl  %%d0,    %%d3       \n\t"   \
00263         "addl   %%d1,    %%a3@+     \n\t"   \
00264         "addxl  %%d0,    %%d3       \n\t"
00265 
00266 #endif /* MC68000 */
00267 
00268 #if defined(__powerpc64__) || defined(__ppc64__)
00269 
00270 #if defined(__MACH__) && defined(__APPLE__)
00271 
00272 #define MULADDC_INIT                        \
00273     asm(                                    \
00274         "ld     r3, %3              \n\t"   \
00275         "ld     r4, %4              \n\t"   \
00276         "ld     r5, %5              \n\t"   \
00277         "ld     r6, %6              \n\t"   \
00278         "addi   r3, r3, -8          \n\t"   \
00279         "addi   r4, r4, -8          \n\t"   \
00280         "addic  r5, r5,  0          \n\t"
00281 
00282 #define MULADDC_CORE                        \
00283         "ldu    r7, 8(r3)           \n\t"   \
00284         "mulld  r8, r7, r6          \n\t"   \
00285         "mulhdu r9, r7, r6          \n\t"   \
00286         "adde   r8, r8, r5          \n\t"   \
00287         "ld     r7, 8(r4)           \n\t"   \
00288         "addze  r5, r9              \n\t"   \
00289         "addc   r8, r8, r7          \n\t"   \
00290         "stdu   r8, 8(r4)           \n\t"
00291 
00292 #define MULADDC_STOP                        \
00293         "addze  r5, r5              \n\t"   \
00294         "addi   r4, r4, 8           \n\t"   \
00295         "addi   r3, r3, 8           \n\t"   \
00296         "std    r5, %0              \n\t"   \
00297         "std    r4, %1              \n\t"   \
00298         "std    r3, %2              \n\t"   \
00299         : "=m" (c), "=m" (d), "=m" (s)              \
00300         : "m" (s), "m" (d), "m" (c), "m" (b)        \
00301         : "r3", "r4", "r5", "r6", "r7", "r8", "r9"  \
00302     );
00303 
00304 
00305 #else /* __MACH__ && __APPLE__ */
00306 
00307 #define MULADDC_INIT                        \
00308     asm(                                    \
00309         "ld     %%r3, %3            \n\t"   \
00310         "ld     %%r4, %4            \n\t"   \
00311         "ld     %%r5, %5            \n\t"   \
00312         "ld     %%r6, %6            \n\t"   \
00313         "addi   %%r3, %%r3, -8      \n\t"   \
00314         "addi   %%r4, %%r4, -8      \n\t"   \
00315         "addic  %%r5, %%r5,  0      \n\t"
00316 
00317 #define MULADDC_CORE                        \
00318         "ldu    %%r7, 8(%%r3)       \n\t"   \
00319         "mulld  %%r8, %%r7, %%r6    \n\t"   \
00320         "mulhdu %%r9, %%r7, %%r6    \n\t"   \
00321         "adde   %%r8, %%r8, %%r5    \n\t"   \
00322         "ld     %%r7, 8(%%r4)       \n\t"   \
00323         "addze  %%r5, %%r9          \n\t"   \
00324         "addc   %%r8, %%r8, %%r7    \n\t"   \
00325         "stdu   %%r8, 8(%%r4)       \n\t"
00326 
00327 #define MULADDC_STOP                        \
00328         "addze  %%r5, %%r5          \n\t"   \
00329         "addi   %%r4, %%r4, 8       \n\t"   \
00330         "addi   %%r3, %%r3, 8       \n\t"   \
00331         "std    %%r5, %0            \n\t"   \
00332         "std    %%r4, %1            \n\t"   \
00333         "std    %%r3, %2            \n\t"   \
00334         : "=m" (c), "=m" (d), "=m" (s)              \
00335         : "m" (s), "m" (d), "m" (c), "m" (b)        \
00336         : "r3", "r4", "r5", "r6", "r7", "r8", "r9"  \
00337     );
00338 
00339 #endif /* __MACH__ && __APPLE__ */
00340 
00341 #elif defined(__powerpc__) || defined(__ppc__) /* end PPC64/begin PPC32  */
00342 
00343 #if defined(__MACH__) && defined(__APPLE__)
00344 
00345 #define MULADDC_INIT                    \
00346     asm(                                \
00347         "lwz    r3, %3          \n\t"   \
00348         "lwz    r4, %4          \n\t"   \
00349         "lwz    r5, %5          \n\t"   \
00350         "lwz    r6, %6          \n\t"   \
00351         "addi   r3, r3, -4      \n\t"   \
00352         "addi   r4, r4, -4      \n\t"   \
00353         "addic  r5, r5,  0      \n\t"
00354 
00355 #define MULADDC_CORE                    \
00356         "lwzu   r7, 4(r3)       \n\t"   \
00357         "mullw  r8, r7, r6      \n\t"   \
00358         "mulhwu r9, r7, r6      \n\t"   \
00359         "adde   r8, r8, r5      \n\t"   \
00360         "lwz    r7, 4(r4)       \n\t"   \
00361         "addze  r5, r9          \n\t"   \
00362         "addc   r8, r8, r7      \n\t"   \
00363         "stwu   r8, 4(r4)       \n\t"
00364 
00365 #define MULADDC_STOP                    \
00366         "addze  r5, r5          \n\t"   \
00367         "addi   r4, r4, 4       \n\t"   \
00368         "addi   r3, r3, 4       \n\t"   \
00369         "stw    r5, %0          \n\t"   \
00370         "stw    r4, %1          \n\t"   \
00371         "stw    r3, %2          \n\t"   \
00372         : "=m" (c), "=m" (d), "=m" (s)              \
00373         : "m" (s), "m" (d), "m" (c), "m" (b)        \
00374         : "r3", "r4", "r5", "r6", "r7", "r8", "r9"  \
00375     );
00376 
00377 #else /* __MACH__ && __APPLE__ */
00378 
00379 #define MULADDC_INIT                        \
00380     asm(                                    \
00381         "lwz    %%r3, %3            \n\t"   \
00382         "lwz    %%r4, %4            \n\t"   \
00383         "lwz    %%r5, %5            \n\t"   \
00384         "lwz    %%r6, %6            \n\t"   \
00385         "addi   %%r3, %%r3, -4      \n\t"   \
00386         "addi   %%r4, %%r4, -4      \n\t"   \
00387         "addic  %%r5, %%r5,  0      \n\t"
00388 
00389 #define MULADDC_CORE                        \
00390         "lwzu   %%r7, 4(%%r3)       \n\t"   \
00391         "mullw  %%r8, %%r7, %%r6    \n\t"   \
00392         "mulhwu %%r9, %%r7, %%r6    \n\t"   \
00393         "adde   %%r8, %%r8, %%r5    \n\t"   \
00394         "lwz    %%r7, 4(%%r4)       \n\t"   \
00395         "addze  %%r5, %%r9          \n\t"   \
00396         "addc   %%r8, %%r8, %%r7    \n\t"   \
00397         "stwu   %%r8, 4(%%r4)       \n\t"
00398 
00399 #define MULADDC_STOP                        \
00400         "addze  %%r5, %%r5          \n\t"   \
00401         "addi   %%r4, %%r4, 4       \n\t"   \
00402         "addi   %%r3, %%r3, 4       \n\t"   \
00403         "stw    %%r5, %0            \n\t"   \
00404         "stw    %%r4, %1            \n\t"   \
00405         "stw    %%r3, %2            \n\t"   \
00406         : "=m" (c), "=m" (d), "=m" (s)              \
00407         : "m" (s), "m" (d), "m" (c), "m" (b)        \
00408         : "r3", "r4", "r5", "r6", "r7", "r8", "r9"  \
00409     );
00410 
00411 #endif /* __MACH__ && __APPLE__ */
00412 
00413 #endif /* PPC32 */
00414 
00415 /*
00416  * The Sparc(64) assembly is reported to be broken.
00417  * Disable it for now, until we're able to fix it.
00418  */
00419 #if 0 && defined(__sparc__)
00420 #if defined(__sparc64__)
00421 
00422 #define MULADDC_INIT                                    \
00423     asm(                                                \
00424                 "ldx     %3, %%o0               \n\t"   \
00425                 "ldx     %4, %%o1               \n\t"   \
00426                 "ld      %5, %%o2               \n\t"   \
00427                 "ld      %6, %%o3               \n\t"
00428 
00429 #define MULADDC_CORE                                    \
00430                 "ld      [%%o0], %%o4           \n\t"   \
00431                 "inc     4, %%o0                \n\t"   \
00432                 "ld      [%%o1], %%o5           \n\t"   \
00433                 "umul    %%o3, %%o4, %%o4       \n\t"   \
00434                 "addcc   %%o4, %%o2, %%o4       \n\t"   \
00435                 "rd      %%y, %%g1              \n\t"   \
00436                 "addx    %%g1, 0, %%g1          \n\t"   \
00437                 "addcc   %%o4, %%o5, %%o4       \n\t"   \
00438                 "st      %%o4, [%%o1]           \n\t"   \
00439                 "addx    %%g1, 0, %%o2          \n\t"   \
00440                 "inc     4, %%o1                \n\t"
00441 
00442         #define MULADDC_STOP                            \
00443                 "st      %%o2, %0               \n\t"   \
00444                 "stx     %%o1, %1               \n\t"   \
00445                 "stx     %%o0, %2               \n\t"   \
00446         : "=m" (c), "=m" (d), "=m" (s)          \
00447         : "m" (s), "m" (d), "m" (c), "m" (b)    \
00448         : "g1", "o0", "o1", "o2", "o3", "o4",   \
00449           "o5"                                  \
00450         );
00451 
00452 #else /* __sparc64__ */
00453 
00454 #define MULADDC_INIT                                    \
00455     asm(                                                \
00456                 "ld      %3, %%o0               \n\t"   \
00457                 "ld      %4, %%o1               \n\t"   \
00458                 "ld      %5, %%o2               \n\t"   \
00459                 "ld      %6, %%o3               \n\t"
00460 
00461 #define MULADDC_CORE                                    \
00462                 "ld      [%%o0], %%o4           \n\t"   \
00463                 "inc     4, %%o0                \n\t"   \
00464                 "ld      [%%o1], %%o5           \n\t"   \
00465                 "umul    %%o3, %%o4, %%o4       \n\t"   \
00466                 "addcc   %%o4, %%o2, %%o4       \n\t"   \
00467                 "rd      %%y, %%g1              \n\t"   \
00468                 "addx    %%g1, 0, %%g1          \n\t"   \
00469                 "addcc   %%o4, %%o5, %%o4       \n\t"   \
00470                 "st      %%o4, [%%o1]           \n\t"   \
00471                 "addx    %%g1, 0, %%o2          \n\t"   \
00472                 "inc     4, %%o1                \n\t"
00473 
00474 #define MULADDC_STOP                                    \
00475                 "st      %%o2, %0               \n\t"   \
00476                 "st      %%o1, %1               \n\t"   \
00477                 "st      %%o0, %2               \n\t"   \
00478         : "=m" (c), "=m" (d), "=m" (s)          \
00479         : "m" (s), "m" (d), "m" (c), "m" (b)    \
00480         : "g1", "o0", "o1", "o2", "o3", "o4",   \
00481           "o5"                                  \
00482         );
00483 
00484 #endif /* __sparc64__ */
00485 #endif /* __sparc__ */
00486 
00487 #if defined(__microblaze__) || defined(microblaze)
00488 
00489 #define MULADDC_INIT                    \
00490     asm(                                \
00491         "lwi   r3,   %3         \n\t"   \
00492         "lwi   r4,   %4         \n\t"   \
00493         "lwi   r5,   %5         \n\t"   \
00494         "lwi   r6,   %6         \n\t"   \
00495         "andi  r7,   r6, 0xffff \n\t"   \
00496         "bsrli r6,   r6, 16     \n\t"
00497 
00498 #define MULADDC_CORE                    \
00499         "lhui  r8,   r3,   0    \n\t"   \
00500         "addi  r3,   r3,   2    \n\t"   \
00501         "lhui  r9,   r3,   0    \n\t"   \
00502         "addi  r3,   r3,   2    \n\t"   \
00503         "mul   r10,  r9,  r6    \n\t"   \
00504         "mul   r11,  r8,  r7    \n\t"   \
00505         "mul   r12,  r9,  r7    \n\t"   \
00506         "mul   r13,  r8,  r6    \n\t"   \
00507         "bsrli  r8, r10,  16    \n\t"   \
00508         "bsrli  r9, r11,  16    \n\t"   \
00509         "add   r13, r13,  r8    \n\t"   \
00510         "add   r13, r13,  r9    \n\t"   \
00511         "bslli r10, r10,  16    \n\t"   \
00512         "bslli r11, r11,  16    \n\t"   \
00513         "add   r12, r12, r10    \n\t"   \
00514         "addc  r13, r13,  r0    \n\t"   \
00515         "add   r12, r12, r11    \n\t"   \
00516         "addc  r13, r13,  r0    \n\t"   \
00517         "lwi   r10,  r4,   0    \n\t"   \
00518         "add   r12, r12, r10    \n\t"   \
00519         "addc  r13, r13,  r0    \n\t"   \
00520         "add   r12, r12,  r5    \n\t"   \
00521         "addc   r5, r13,  r0    \n\t"   \
00522         "swi   r12,  r4,   0    \n\t"   \
00523         "addi   r4,  r4,   4    \n\t"
00524 
00525 #define MULADDC_STOP                    \
00526         "swi   r5,   %0         \n\t"   \
00527         "swi   r4,   %1         \n\t"   \
00528         "swi   r3,   %2         \n\t"   \
00529         : "=m" (c), "=m" (d), "=m" (s)              \
00530         : "m" (s), "m" (d), "m" (c), "m" (b)        \
00531         : "r3", "r4", "r5", "r6", "r7", "r8",       \
00532           "r9", "r10", "r11", "r12", "r13"          \
00533     );
00534 
00535 #endif /* MicroBlaze */
00536 
00537 #if defined(__tricore__)
00538 
00539 #define MULADDC_INIT                            \
00540     asm(                                        \
00541         "ld.a   %%a2, %3                \n\t"   \
00542         "ld.a   %%a3, %4                \n\t"   \
00543         "ld.w   %%d4, %5                \n\t"   \
00544         "ld.w   %%d1, %6                \n\t"   \
00545         "xor    %%d5, %%d5              \n\t"
00546 
00547 #define MULADDC_CORE                            \
00548         "ld.w   %%d0,   [%%a2+]         \n\t"   \
00549         "madd.u %%e2, %%e4, %%d0, %%d1  \n\t"   \
00550         "ld.w   %%d0,   [%%a3]          \n\t"   \
00551         "addx   %%d2,    %%d2,  %%d0    \n\t"   \
00552         "addc   %%d3,    %%d3,    0     \n\t"   \
00553         "mov    %%d4,    %%d3           \n\t"   \
00554         "st.w  [%%a3+],  %%d2           \n\t"
00555 
00556 #define MULADDC_STOP                            \
00557         "st.w   %0, %%d4                \n\t"   \
00558         "st.a   %1, %%a3                \n\t"   \
00559         "st.a   %2, %%a2                \n\t"   \
00560         : "=m" (c), "=m" (d), "=m" (s)          \
00561         : "m" (s), "m" (d), "m" (c), "m" (b)    \
00562         : "d0", "d1", "e2", "d4", "a2", "a3"    \
00563     );
00564 
00565 #endif /* TriCore */
00566 
00567 /*
00568  * gcc -O0 by default uses r7 for the frame pointer, so it complains about our
00569  * use of r7 below, unless -fomit-frame-pointer is passed. Unfortunately,
00570  * passing that option is not easy when building with yotta.
00571  *
00572  * On the other hand, -fomit-frame-pointer is implied by any -Ox options with
00573  * x !=0, which we can detect using __OPTIMIZE__ (which is also defined by
00574  * clang and armcc5 under the same conditions).
00575  *
00576  * So, only use the optimized assembly below for optimized build, which avoids
00577  * the build error and is pretty reasonable anyway.
00578  */
00579 #if defined(__GNUC__) && !defined(__OPTIMIZE__)
00580 #define MULADDC_CANNOT_USE_R7
00581 #endif
00582 
00583 #if defined(__arm__) && !defined(MULADDC_CANNOT_USE_R7)
00584 
00585 #if defined(__thumb__) && !defined(__thumb2__)
00586 
00587 #define MULADDC_INIT                                    \
00588     asm(                                                \
00589             "ldr    r0, %3                      \n\t"   \
00590             "ldr    r1, %4                      \n\t"   \
00591             "ldr    r2, %5                      \n\t"   \
00592             "ldr    r3, %6                      \n\t"   \
00593             "lsr    r7, r3, #16                 \n\t"   \
00594             "mov    r9, r7                      \n\t"   \
00595             "lsl    r7, r3, #16                 \n\t"   \
00596             "lsr    r7, r7, #16                 \n\t"   \
00597             "mov    r8, r7                      \n\t"
00598 
00599 #define MULADDC_CORE                                    \
00600             "ldmia  r0!, {r6}                   \n\t"   \
00601             "lsr    r7, r6, #16                 \n\t"   \
00602             "lsl    r6, r6, #16                 \n\t"   \
00603             "lsr    r6, r6, #16                 \n\t"   \
00604             "mov    r4, r8                      \n\t"   \
00605             "mul    r4, r6                      \n\t"   \
00606             "mov    r3, r9                      \n\t"   \
00607             "mul    r6, r3                      \n\t"   \
00608             "mov    r5, r9                      \n\t"   \
00609             "mul    r5, r7                      \n\t"   \
00610             "mov    r3, r8                      \n\t"   \
00611             "mul    r7, r3                      \n\t"   \
00612             "lsr    r3, r6, #16                 \n\t"   \
00613             "add    r5, r5, r3                  \n\t"   \
00614             "lsr    r3, r7, #16                 \n\t"   \
00615             "add    r5, r5, r3                  \n\t"   \
00616             "add    r4, r4, r2                  \n\t"   \
00617             "mov    r2, #0                      \n\t"   \
00618             "adc    r5, r2                      \n\t"   \
00619             "lsl    r3, r6, #16                 \n\t"   \
00620             "add    r4, r4, r3                  \n\t"   \
00621             "adc    r5, r2                      \n\t"   \
00622             "lsl    r3, r7, #16                 \n\t"   \
00623             "add    r4, r4, r3                  \n\t"   \
00624             "adc    r5, r2                      \n\t"   \
00625             "ldr    r3, [r1]                    \n\t"   \
00626             "add    r4, r4, r3                  \n\t"   \
00627             "adc    r2, r5                      \n\t"   \
00628             "stmia  r1!, {r4}                   \n\t"
00629 
00630 #define MULADDC_STOP                                    \
00631             "str    r2, %0                      \n\t"   \
00632             "str    r1, %1                      \n\t"   \
00633             "str    r0, %2                      \n\t"   \
00634          : "=m" (c),  "=m" (d), "=m" (s)        \
00635          : "m" (s), "m" (d), "m" (c), "m" (b)   \
00636          : "r0", "r1", "r2", "r3", "r4", "r5",  \
00637            "r6", "r7", "r8", "r9", "cc"         \
00638          );
00639 
00640 #else
00641 
00642 #define MULADDC_INIT                                    \
00643     asm(                                                \
00644             "ldr    r0, %3                      \n\t"   \
00645             "ldr    r1, %4                      \n\t"   \
00646             "ldr    r2, %5                      \n\t"   \
00647             "ldr    r3, %6                      \n\t"
00648 
00649 #define MULADDC_CORE                                    \
00650             "ldr    r4, [r0], #4                \n\t"   \
00651             "mov    r5, #0                      \n\t"   \
00652             "ldr    r6, [r1]                    \n\t"   \
00653             "umlal  r2, r5, r3, r4              \n\t"   \
00654             "adds   r7, r6, r2                  \n\t"   \
00655             "adc    r2, r5, #0                  \n\t"   \
00656             "str    r7, [r1], #4                \n\t"
00657 
00658 #define MULADDC_STOP                                    \
00659             "str    r2, %0                      \n\t"   \
00660             "str    r1, %1                      \n\t"   \
00661             "str    r0, %2                      \n\t"   \
00662          : "=m" (c),  "=m" (d), "=m" (s)        \
00663          : "m" (s), "m" (d), "m" (c), "m" (b)   \
00664          : "r0", "r1", "r2", "r3", "r4", "r5",  \
00665            "r6", "r7", "cc"                     \
00666          );
00667 
00668 #endif /* Thumb */
00669 
00670 #endif /* ARMv3 */
00671 
00672 #if defined(__alpha__)
00673 
00674 #define MULADDC_INIT                    \
00675     asm(                                \
00676         "ldq    $1, %3          \n\t"   \
00677         "ldq    $2, %4          \n\t"   \
00678         "ldq    $3, %5          \n\t"   \
00679         "ldq    $4, %6          \n\t"
00680 
00681 #define MULADDC_CORE                    \
00682         "ldq    $6,  0($1)      \n\t"   \
00683         "addq   $1,  8, $1      \n\t"   \
00684         "mulq   $6, $4, $7      \n\t"   \
00685         "umulh  $6, $4, $6      \n\t"   \
00686         "addq   $7, $3, $7      \n\t"   \
00687         "cmpult $7, $3, $3      \n\t"   \
00688         "ldq    $5,  0($2)      \n\t"   \
00689         "addq   $7, $5, $7      \n\t"   \
00690         "cmpult $7, $5, $5      \n\t"   \
00691         "stq    $7,  0($2)      \n\t"   \
00692         "addq   $2,  8, $2      \n\t"   \
00693         "addq   $6, $3, $3      \n\t"   \
00694         "addq   $5, $3, $3      \n\t"
00695 
00696 #define MULADDC_STOP                                    \
00697         "stq    $3, %0          \n\t"   \
00698         "stq    $2, %1          \n\t"   \
00699         "stq    $1, %2          \n\t"   \
00700         : "=m" (c), "=m" (d), "=m" (s)              \
00701         : "m" (s), "m" (d), "m" (c), "m" (b)        \
00702         : "$1", "$2", "$3", "$4", "$5", "$6", "$7"  \
00703     );
00704 #endif /* Alpha */
00705 
00706 #if defined(__mips__) && !defined(__mips64)
00707 
00708 #define MULADDC_INIT                    \
00709     asm(                                \
00710         "lw     $10, %3         \n\t"   \
00711         "lw     $11, %4         \n\t"   \
00712         "lw     $12, %5         \n\t"   \
00713         "lw     $13, %6         \n\t"
00714 
00715 #define MULADDC_CORE                    \
00716         "lw     $14, 0($10)     \n\t"   \
00717         "multu  $13, $14        \n\t"   \
00718         "addi   $10, $10, 4     \n\t"   \
00719         "mflo   $14             \n\t"   \
00720         "mfhi   $9              \n\t"   \
00721         "addu   $14, $12, $14   \n\t"   \
00722         "lw     $15, 0($11)     \n\t"   \
00723         "sltu   $12, $14, $12   \n\t"   \
00724         "addu   $15, $14, $15   \n\t"   \
00725         "sltu   $14, $15, $14   \n\t"   \
00726         "addu   $12, $12, $9    \n\t"   \
00727         "sw     $15, 0($11)     \n\t"   \
00728         "addu   $12, $12, $14   \n\t"   \
00729         "addi   $11, $11, 4     \n\t"
00730 
00731 #define MULADDC_STOP                    \
00732         "sw     $12, %0         \n\t"   \
00733         "sw     $11, %1         \n\t"   \
00734         "sw     $10, %2         \n\t"   \
00735         : "=m" (c), "=m" (d), "=m" (s)                      \
00736         : "m" (s), "m" (d), "m" (c), "m" (b)                \
00737         : "$9", "$10", "$11", "$12", "$13", "$14", "$15"    \
00738     );
00739 
00740 #endif /* MIPS */
00741 #endif /* GNUC */
00742 
00743 #if (defined(_MSC_VER) && defined(_M_IX86)) || defined(__WATCOMC__)
00744 
00745 #define MULADDC_INIT                            \
00746     __asm   mov     esi, s                      \
00747     __asm   mov     edi, d                      \
00748     __asm   mov     ecx, c                      \
00749     __asm   mov     ebx, b
00750 
00751 #define MULADDC_CORE                            \
00752     __asm   lodsd                               \
00753     __asm   mul     ebx                         \
00754     __asm   add     eax, ecx                    \
00755     __asm   adc     edx, 0                      \
00756     __asm   add     eax, [edi]                  \
00757     __asm   adc     edx, 0                      \
00758     __asm   mov     ecx, edx                    \
00759     __asm   stosd
00760 
00761 #if defined(MBEDTLS_HAVE_SSE2)
00762 
00763 #define EMIT __asm _emit
00764 
00765 #define MULADDC_HUIT                            \
00766     EMIT 0x0F  EMIT 0x6E  EMIT 0xC9             \
00767     EMIT 0x0F  EMIT 0x6E  EMIT 0xC3             \
00768     EMIT 0x0F  EMIT 0x6E  EMIT 0x1F             \
00769     EMIT 0x0F  EMIT 0xD4  EMIT 0xCB             \
00770     EMIT 0x0F  EMIT 0x6E  EMIT 0x16             \
00771     EMIT 0x0F  EMIT 0xF4  EMIT 0xD0             \
00772     EMIT 0x0F  EMIT 0x6E  EMIT 0x66  EMIT 0x04  \
00773     EMIT 0x0F  EMIT 0xF4  EMIT 0xE0             \
00774     EMIT 0x0F  EMIT 0x6E  EMIT 0x76  EMIT 0x08  \
00775     EMIT 0x0F  EMIT 0xF4  EMIT 0xF0             \
00776     EMIT 0x0F  EMIT 0x6E  EMIT 0x7E  EMIT 0x0C  \
00777     EMIT 0x0F  EMIT 0xF4  EMIT 0xF8             \
00778     EMIT 0x0F  EMIT 0xD4  EMIT 0xCA             \
00779     EMIT 0x0F  EMIT 0x6E  EMIT 0x5F  EMIT 0x04  \
00780     EMIT 0x0F  EMIT 0xD4  EMIT 0xDC             \
00781     EMIT 0x0F  EMIT 0x6E  EMIT 0x6F  EMIT 0x08  \
00782     EMIT 0x0F  EMIT 0xD4  EMIT 0xEE             \
00783     EMIT 0x0F  EMIT 0x6E  EMIT 0x67  EMIT 0x0C  \
00784     EMIT 0x0F  EMIT 0xD4  EMIT 0xFC             \
00785     EMIT 0x0F  EMIT 0x7E  EMIT 0x0F             \
00786     EMIT 0x0F  EMIT 0x6E  EMIT 0x56  EMIT 0x10  \
00787     EMIT 0x0F  EMIT 0xF4  EMIT 0xD0             \
00788     EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
00789     EMIT 0x0F  EMIT 0x6E  EMIT 0x66  EMIT 0x14  \
00790     EMIT 0x0F  EMIT 0xF4  EMIT 0xE0             \
00791     EMIT 0x0F  EMIT 0xD4  EMIT 0xCB             \
00792     EMIT 0x0F  EMIT 0x6E  EMIT 0x76  EMIT 0x18  \
00793     EMIT 0x0F  EMIT 0xF4  EMIT 0xF0             \
00794     EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x04  \
00795     EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
00796     EMIT 0x0F  EMIT 0x6E  EMIT 0x5E  EMIT 0x1C  \
00797     EMIT 0x0F  EMIT 0xF4  EMIT 0xD8             \
00798     EMIT 0x0F  EMIT 0xD4  EMIT 0xCD             \
00799     EMIT 0x0F  EMIT 0x6E  EMIT 0x6F  EMIT 0x10  \
00800     EMIT 0x0F  EMIT 0xD4  EMIT 0xD5             \
00801     EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x08  \
00802     EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
00803     EMIT 0x0F  EMIT 0xD4  EMIT 0xCF             \
00804     EMIT 0x0F  EMIT 0x6E  EMIT 0x6F  EMIT 0x14  \
00805     EMIT 0x0F  EMIT 0xD4  EMIT 0xE5             \
00806     EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x0C  \
00807     EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
00808     EMIT 0x0F  EMIT 0xD4  EMIT 0xCA             \
00809     EMIT 0x0F  EMIT 0x6E  EMIT 0x6F  EMIT 0x18  \
00810     EMIT 0x0F  EMIT 0xD4  EMIT 0xF5             \
00811     EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x10  \
00812     EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
00813     EMIT 0x0F  EMIT 0xD4  EMIT 0xCC             \
00814     EMIT 0x0F  EMIT 0x6E  EMIT 0x6F  EMIT 0x1C  \
00815     EMIT 0x0F  EMIT 0xD4  EMIT 0xDD             \
00816     EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x14  \
00817     EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
00818     EMIT 0x0F  EMIT 0xD4  EMIT 0xCE             \
00819     EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x18  \
00820     EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
00821     EMIT 0x0F  EMIT 0xD4  EMIT 0xCB             \
00822     EMIT 0x0F  EMIT 0x7E  EMIT 0x4F  EMIT 0x1C  \
00823     EMIT 0x83  EMIT 0xC7  EMIT 0x20             \
00824     EMIT 0x83  EMIT 0xC6  EMIT 0x20             \
00825     EMIT 0x0F  EMIT 0x73  EMIT 0xD1  EMIT 0x20  \
00826     EMIT 0x0F  EMIT 0x7E  EMIT 0xC9
00827 
00828 #define MULADDC_STOP                            \
00829     EMIT 0x0F  EMIT 0x77                        \
00830     __asm   mov     c, ecx                      \
00831     __asm   mov     d, edi                      \
00832     __asm   mov     s, esi                      \
00833 
00834 #else
00835 
00836 #define MULADDC_STOP                            \
00837     __asm   mov     c, ecx                      \
00838     __asm   mov     d, edi                      \
00839     __asm   mov     s, esi                      \
00840 
00841 #endif /* SSE2 */
00842 #endif /* MSVC */
00843 
00844 #endif /* MBEDTLS_HAVE_ASM */
00845 
00846 #if !defined(MULADDC_CORE)
00847 #if defined(MBEDTLS_HAVE_UDBL)
00848 
00849 #define MULADDC_INIT                    \
00850 {                                       \
00851     mbedtls_t_udbl r;                           \
00852     mbedtls_mpi_uint r0, r1;
00853 
00854 #define MULADDC_CORE                    \
00855     r   = *(s++) * (mbedtls_t_udbl) b;          \
00856     r0  = (mbedtls_mpi_uint) r;                   \
00857     r1  = (mbedtls_mpi_uint)( r >> biL );         \
00858     r0 += c;  r1 += (r0 <  c);          \
00859     r0 += *d; r1 += (r0 < *d);          \
00860     c = r1; *(d++) = r0;
00861 
00862 #define MULADDC_STOP                    \
00863 }
00864 
00865 #else
00866 #define MULADDC_INIT                    \
00867 {                                       \
00868     mbedtls_mpi_uint s0, s1, b0, b1;              \
00869     mbedtls_mpi_uint r0, r1, rx, ry;              \
00870     b0 = ( b << biH ) >> biH;           \
00871     b1 = ( b >> biH );
00872 
00873 #define MULADDC_CORE                    \
00874     s0 = ( *s << biH ) >> biH;          \
00875     s1 = ( *s >> biH ); s++;            \
00876     rx = s0 * b1; r0 = s0 * b0;         \
00877     ry = s1 * b0; r1 = s1 * b1;         \
00878     r1 += ( rx >> biH );                \
00879     r1 += ( ry >> biH );                \
00880     rx <<= biH; ry <<= biH;             \
00881     r0 += rx; r1 += (r0 < rx);          \
00882     r0 += ry; r1 += (r0 < ry);          \
00883     r0 +=  c; r1 += (r0 <  c);          \
00884     r0 += *d; r1 += (r0 < *d);          \
00885     c = r1; *(d++) = r0;
00886 
00887 #define MULADDC_STOP                    \
00888 }
00889 
00890 #endif /* C (generic)  */
00891 #endif /* C (longlong) */
00892 
00893 #endif /* bn_mul.h */