Kenji Arai / mbed-os_TYBLE16

Dependents:   TYBLE16_simple_data_logger TYBLE16_MP3_Air

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