Lines Matching refs:size
36 #define MPN_MUL_N_RECURSE(prodp, up, vp, size, tspace) \
38 if( (size) < KARATSUBA_THRESHOLD ) \
39 mul_n_basecase (prodp, up, vp, size); \
41 mul_n (prodp, up, vp, size, tspace); \
44 #define MPN_SQR_N_RECURSE(prodp, up, size, tspace) \
46 if ((size) < KARATSUBA_THRESHOLD) \
47 _gcry_mpih_sqr_n_basecase (prodp, up, size); \
49 _gcry_mpih_sqr_n (prodp, up, size, tspace); \
74 mpi_ptr_t vp, mpi_size_t size)
85 MPN_COPY( prodp, up, size );
87 MPN_ZERO( prodp, size );
91 cy = _gcry_mpih_mul_1( prodp, up, size, v_limb );
93 prodp[size] = cy;
98 for( i = 1; i < size; i++ ) {
103 cy = _gcry_mpih_add_n(prodp, prodp, up, size);
106 cy = _gcry_mpih_addmul_1(prodp, up, size, v_limb);
108 prodp[size] = cy;
118 mpi_size_t size, mpi_ptr_t tspace )
120 if( size & 1 ) {
121 /* The size is odd, and the code below doesn't handle that.
122 * Multiply the least significant (size - 1) limbs with a recursive
126 * code below behave as if the size were even, and let it check for
127 * odd size in the end. I.e., in essence move this code to the end.
131 mpi_size_t esize = size - 1; /* even size */
137 cy_limb = _gcry_mpih_addmul_1( prodp + esize, vp, size, up[esize] );
138 prodp[esize + size] = cy_limb;
156 mpi_size_t hsize = size >> 1;
165 MPN_MUL_N_RECURSE(prodp + size, up + hsize, vp + hsize, hsize, tspace);
190 MPN_MUL_N_RECURSE(tspace, prodp, prodp + hsize, hsize, tspace + size);
193 MPN_COPY (prodp + hsize, prodp + size, hsize);
194 cy = _gcry_mpih_add_n( prodp + size, prodp + size,
195 prodp + size + hsize, hsize);
199 cy -= _gcry_mpih_sub_n(prodp + hsize, prodp + hsize, tspace, size);
201 cy += _gcry_mpih_add_n(prodp + hsize, prodp + hsize, tspace, size);
209 MPN_MUL_N_RECURSE(tspace, up, vp, hsize, tspace + size);
213 cy += _gcry_mpih_add_n(prodp + hsize, prodp + hsize, tspace, size);
215 _gcry_mpih_add_1(prodp + hsize + size, prodp + hsize + size, hsize, cy);
220 _gcry_mpih_add_1(prodp + size, prodp + size, size, 1);
226 _gcry_mpih_sqr_n_basecase( mpi_ptr_t prodp, mpi_ptr_t up, mpi_size_t size )
237 MPN_COPY( prodp, up, size );
239 MPN_ZERO(prodp, size);
243 cy_limb = _gcry_mpih_mul_1( prodp, up, size, v_limb );
245 prodp[size] = cy_limb;
250 for( i=1; i < size; i++) {
255 cy_limb = _gcry_mpih_add_n(prodp, prodp, up, size);
258 cy_limb = _gcry_mpih_addmul_1(prodp, up, size, v_limb);
260 prodp[size] = cy_limb;
268 mpi_ptr_t up, mpi_size_t size, mpi_ptr_t tspace)
270 if( size & 1 ) {
271 /* The size is odd, and the code below doesn't handle that.
272 * Multiply the least significant (size - 1) limbs with a recursive
276 * code below behave as if the size were even, and let it check for
277 * odd size in the end. I.e., in essence move this code to the end.
281 mpi_size_t esize = size - 1; /* even size */
287 cy_limb = _gcry_mpih_addmul_1( prodp + esize, up, size, up[esize] );
289 prodp[esize + size] = cy_limb;
292 mpi_size_t hsize = size >> 1;
300 MPN_SQR_N_RECURSE(prodp + size, up + hsize, hsize, tspace);
313 MPN_SQR_N_RECURSE(tspace, prodp, hsize, tspace + size);
316 MPN_COPY(prodp + hsize, prodp + size, hsize);
317 cy = _gcry_mpih_add_n(prodp + size, prodp + size,
318 prodp + size + hsize, hsize);
321 cy -= _gcry_mpih_sub_n (prodp + hsize, prodp + hsize, tspace, size);
328 MPN_SQR_N_RECURSE (tspace, up, hsize, tspace + size);
331 cy += _gcry_mpih_add_n (prodp + hsize, prodp + hsize, tspace, size);
333 _gcry_mpih_add_1(prodp + hsize + size, prodp + hsize + size,
339 _gcry_mpih_add_1 (prodp + size, prodp + size, size, 1);
347 mpi_ptr_t up, mpi_ptr_t vp, mpi_size_t size)
352 if( size < KARATSUBA_THRESHOLD )
353 _gcry_mpih_sqr_n_basecase( prodp, up, size );
357 tspace = mpi_alloc_limb_space( 2 * size, secure );
358 _gcry_mpih_sqr_n( prodp, up, size, tspace );
359 _gcry_mpi_free_limb_space (tspace, 2 * size );
363 if( size < KARATSUBA_THRESHOLD )
364 mul_n_basecase( prodp, up, vp, size );
368 tspace = mpi_alloc_limb_space( 2 * size, secure );
369 mul_n (prodp, up, vp, size, tspace);
370 _gcry_mpi_free_limb_space (tspace, 2 * size );