The Tor Browser / file comparison
comparison: security/nss/lib/freebl/mpi/montmulf.h
security/nss/lib/freebl/mpi/montmulf.h
- changeset 0
- 6474c204b198
equal
deleted
inserted
replaced
| -1:000000000000 | 0:d04b8c777c8a |
|---|---|
| 1 /* This Source Code Form is subject to the terms of the Mozilla Public | |
| 2 * License, v. 2.0. If a copy of the MPL was not distributed with this | |
| 3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ | |
| 4 | |
| 5 /* The functions that are to be called from outside of the .s file have the | |
| 6 * following interfaces and array size requirements: | |
| 7 */ | |
| 8 | |
| 9 | |
| 10 void conv_i32_to_d32(double *d32, unsigned int *i32, int len); | |
| 11 | |
| 12 /* Converts an array of int's to an array of doubles, so that each double | |
| 13 * corresponds to an int. len is the number of items converted. | |
| 14 * Does not allocate the output array. | |
| 15 * The pointers d32 and i32 should point to arrays of size at least len | |
| 16 * (doubles and unsigned ints, respectively) | |
| 17 */ | |
| 18 | |
| 19 | |
| 20 void conv_i32_to_d16(double *d16, unsigned int *i32, int len); | |
| 21 | |
| 22 /* Converts an array of int's to an array of doubles so that each element | |
| 23 * of the int array is converted to a pair of doubles, the first one | |
| 24 * corresponding to the lower (least significant) 16 bits of the int and | |
| 25 * the second one corresponding to the upper (most significant) 16 bits of | |
| 26 * the 32-bit int. len is the number of ints converted. | |
| 27 * Does not allocate the output array. | |
| 28 * The pointer d16 should point to an array of doubles of size at least | |
| 29 * 2*len and i32 should point an array of ints of size at least len | |
| 30 */ | |
| 31 | |
| 32 | |
| 33 void conv_i32_to_d32_and_d16(double *d32, double *d16, | |
| 34 unsigned int *i32, int len); | |
| 35 | |
| 36 /* Does the above two conversions together, it is much faster than doing | |
| 37 * both of those in succession | |
| 38 */ | |
| 39 | |
| 40 | |
| 41 void mont_mulf_noconv(unsigned int *result, | |
| 42 double *dm1, double *dm2, double *dt, | |
| 43 double *dn, unsigned int *nint, | |
| 44 int nlen, double dn0); | |
| 45 | |
| 46 /* Does the Montgomery multiplication of the numbers stored in the arrays | |
| 47 * pointed to by dm1 and dm2, writing the result to the array pointed to by | |
| 48 * result. It uses the array pointed to by dt as a temporary work area. | |
| 49 * nint should point to the modulus in the array-of-integers representation, | |
| 50 * dn should point to its array-of-doubles as obtained as a result of the | |
| 51 * function call conv_i32_to_d32(dn, nint, nlen); | |
| 52 * nlen is the length of the array containing the modulus. | |
| 53 * The representation used for dm1 is the one that is a result of the function | |
| 54 * call conv_i32_to_d32(dm1, m1, nlen), the representation for dm2 is the | |
| 55 * result of the function call conv_i32_to_d16(dm2, m2, nlen). | |
| 56 * Note that m1 and m2 should both be of length nlen, so they should be | |
| 57 * padded with 0's if necessary before the conversion. The result comes in | |
| 58 * this form (int representation, padded with 0's). | |
| 59 * dn0 is the value of the 16 least significant bits of n0'. | |
| 60 * The function does not allocate memory for any of the arrays, so the | |
| 61 * pointers should point to arrays with the following minimal sizes: | |
| 62 * result - nlen+1 | |
| 63 * dm1 - nlen | |
| 64 * dm2 - 2*nlen+1 ( the +1 is necessary for technical reasons ) | |
| 65 * dt - 4*nlen+2 | |
| 66 * dn - nlen | |
| 67 * nint - nlen | |
| 68 * No two arrays should point to overlapping areas of memory. | |
| 69 */ |
