Line data Source code
1 : /* mpi-div.c - MPI functions
2 : * Copyright (C) 1994, 1996, 1998, 2001, 2002,
3 : * 2003 Free Software Foundation, Inc.
4 : *
5 : * This file is part of Libgcrypt.
6 : *
7 : * Libgcrypt is free software; you can redistribute it and/or modify
8 : * it under the terms of the GNU Lesser General Public License as
9 : * published by the Free Software Foundation; either version 2.1 of
10 : * the License, or (at your option) any later version.
11 : *
12 : * Libgcrypt is distributed in the hope that it will be useful,
13 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : * GNU Lesser General Public License for more details.
16 : *
17 : * You should have received a copy of the GNU Lesser General Public
18 : * License along with this program; if not, write to the Free Software
19 : * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20 : *
21 : * Note: This code is heavily based on the GNU MP Library.
22 : * Actually it's the same code with only minor changes in the
23 : * way the data is stored; this is to support the abstraction
24 : * of an optional secure memory allocation which may be used
25 : * to avoid revealing of sensitive data due to paging etc.
26 : */
27 :
28 : #include <config.h>
29 : #include <stdio.h>
30 : #include <stdlib.h>
31 : #include "mpi-internal.h"
32 : #include "longlong.h"
33 : #include "g10lib.h"
34 :
35 :
36 : void
37 38016323 : _gcry_mpi_fdiv_r( gcry_mpi_t rem, gcry_mpi_t dividend, gcry_mpi_t divisor )
38 : {
39 38016323 : int divisor_sign = divisor->sign;
40 38016323 : gcry_mpi_t temp_divisor = NULL;
41 :
42 : /* We need the original value of the divisor after the remainder has been
43 : * preliminary calculated. We have to copy it to temporary space if it's
44 : * the same variable as REM. */
45 38016323 : if( rem == divisor ) {
46 9279 : temp_divisor = mpi_copy( divisor );
47 9279 : divisor = temp_divisor;
48 : }
49 :
50 38016323 : _gcry_mpi_tdiv_r( rem, dividend, divisor );
51 :
52 38016323 : if( ((divisor_sign?1:0) ^ (dividend->sign?1:0)) && rem->nlimbs )
53 46 : mpi_add (rem, rem, divisor);
54 :
55 38016323 : if( temp_divisor )
56 9279 : mpi_free(temp_divisor);
57 38016323 : }
58 :
59 :
60 :
61 : /****************
62 : * Division rounding the quotient towards -infinity.
63 : * The remainder gets the same sign as the denominator.
64 : * rem is optional
65 : */
66 :
67 : ulong
68 356044 : _gcry_mpi_fdiv_r_ui( gcry_mpi_t rem, gcry_mpi_t dividend, ulong divisor )
69 : {
70 : mpi_limb_t rlimb;
71 :
72 356044 : rlimb = _gcry_mpih_mod_1( dividend->d, dividend->nlimbs, divisor );
73 356044 : if( rlimb && dividend->sign )
74 0 : rlimb = divisor - rlimb;
75 :
76 356044 : if( rem ) {
77 0 : rem->d[0] = rlimb;
78 0 : rem->nlimbs = rlimb? 1:0;
79 : }
80 356044 : return rlimb;
81 : }
82 :
83 :
84 : void
85 191 : _gcry_mpi_fdiv_q( gcry_mpi_t quot, gcry_mpi_t dividend, gcry_mpi_t divisor )
86 : {
87 191 : gcry_mpi_t tmp = mpi_alloc( mpi_get_nlimbs(quot) );
88 191 : _gcry_mpi_fdiv_qr( quot, tmp, dividend, divisor);
89 191 : mpi_free(tmp);
90 191 : }
91 :
92 : void
93 191 : _gcry_mpi_fdiv_qr( gcry_mpi_t quot, gcry_mpi_t rem, gcry_mpi_t dividend, gcry_mpi_t divisor )
94 : {
95 191 : int divisor_sign = divisor->sign;
96 191 : gcry_mpi_t temp_divisor = NULL;
97 :
98 191 : if( quot == divisor || rem == divisor ) {
99 0 : temp_divisor = mpi_copy( divisor );
100 0 : divisor = temp_divisor;
101 : }
102 :
103 191 : _gcry_mpi_tdiv_qr( quot, rem, dividend, divisor );
104 :
105 191 : if( (divisor_sign ^ dividend->sign) && rem->nlimbs ) {
106 0 : mpi_sub_ui( quot, quot, 1 );
107 0 : mpi_add( rem, rem, divisor);
108 : }
109 :
110 191 : if( temp_divisor )
111 0 : mpi_free(temp_divisor);
112 191 : }
113 :
114 :
115 : /* If den == quot, den needs temporary storage.
116 : * If den == rem, den needs temporary storage.
117 : * If num == quot, num needs temporary storage.
118 : * If den has temporary storage, it can be normalized while being copied,
119 : * i.e no extra storage should be allocated.
120 : */
121 :
122 : void
123 38096396 : _gcry_mpi_tdiv_r( gcry_mpi_t rem, gcry_mpi_t num, gcry_mpi_t den)
124 : {
125 38096396 : _gcry_mpi_tdiv_qr(NULL, rem, num, den );
126 38096396 : }
127 :
128 : void
129 38096587 : _gcry_mpi_tdiv_qr( gcry_mpi_t quot, gcry_mpi_t rem, gcry_mpi_t num, gcry_mpi_t den)
130 : {
131 : mpi_ptr_t np, dp;
132 : mpi_ptr_t qp, rp;
133 38096587 : mpi_size_t nsize = num->nlimbs;
134 38096587 : mpi_size_t dsize = den->nlimbs;
135 : mpi_size_t qsize, rsize;
136 38096587 : mpi_size_t sign_remainder = num->sign;
137 38096587 : mpi_size_t sign_quotient = num->sign ^ den->sign;
138 : unsigned normalization_steps;
139 : mpi_limb_t q_limb;
140 : mpi_ptr_t marker[5];
141 : unsigned int marker_nlimbs[5];
142 38096587 : int markidx=0;
143 :
144 : /* Ensure space is enough for quotient and remainder.
145 : * We need space for an extra limb in the remainder, because it's
146 : * up-shifted (normalized) below. */
147 38096587 : rsize = nsize + 1;
148 38096587 : mpi_resize( rem, rsize);
149 :
150 38096587 : qsize = rsize - dsize; /* qsize cannot be bigger than this. */
151 38096587 : if( qsize <= 0 ) {
152 83194 : if( num != rem ) {
153 10437 : rem->nlimbs = num->nlimbs;
154 10437 : rem->sign = num->sign;
155 10437 : MPN_COPY(rem->d, num->d, nsize);
156 : }
157 83194 : if( quot ) {
158 : /* This needs to follow the assignment to rem, in case the
159 : * numerator and quotient are the same. */
160 0 : quot->nlimbs = 0;
161 0 : quot->sign = 0;
162 : }
163 214671 : return;
164 : }
165 :
166 38013393 : if( quot )
167 191 : mpi_resize( quot, qsize);
168 :
169 : /* Read pointers here, when reallocation is finished. */
170 38013393 : np = num->d;
171 38013393 : dp = den->d;
172 38013393 : rp = rem->d;
173 :
174 : /* Optimize division by a single-limb divisor. */
175 38013393 : if( dsize == 1 ) {
176 : mpi_limb_t rlimb;
177 48283 : if( quot ) {
178 66 : qp = quot->d;
179 66 : rlimb = _gcry_mpih_divmod_1( qp, np, nsize, dp[0] );
180 66 : qsize -= qp[qsize - 1] == 0;
181 66 : quot->nlimbs = qsize;
182 66 : quot->sign = sign_quotient;
183 : }
184 : else
185 48217 : rlimb = _gcry_mpih_mod_1( np, nsize, dp[0] );
186 48283 : rp[0] = rlimb;
187 48283 : rsize = rlimb != 0?1:0;
188 48283 : rem->nlimbs = rsize;
189 48283 : rem->sign = sign_remainder;
190 48283 : return;
191 : }
192 :
193 :
194 37965110 : if( quot ) {
195 125 : qp = quot->d;
196 : /* Make sure QP and NP point to different objects. Otherwise the
197 : * numerator would be gradually overwritten by the quotient limbs. */
198 125 : if(qp == np) { /* Copy NP object to temporary space. */
199 27 : marker_nlimbs[markidx] = nsize;
200 27 : np = marker[markidx++] = mpi_alloc_limb_space(nsize,
201 : mpi_is_secure(quot));
202 27 : MPN_COPY(np, qp, nsize);
203 : }
204 : }
205 : else /* Put quotient at top of remainder. */
206 37964985 : qp = rp + dsize;
207 :
208 37965110 : count_leading_zeros( normalization_steps, dp[dsize - 1] );
209 :
210 : /* Normalize the denominator, i.e. make its most significant bit set by
211 : * shifting it NORMALIZATION_STEPS bits to the left. Also shift the
212 : * numerator the same number of steps (to keep the quotient the same!).
213 : */
214 37965110 : if( normalization_steps ) {
215 : mpi_ptr_t tp;
216 : mpi_limb_t nlimb;
217 :
218 : /* Shift up the denominator setting the most significant bit of
219 : * the most significant word. Use temporary storage not to clobber
220 : * the original contents of the denominator. */
221 35925952 : marker_nlimbs[markidx] = dsize;
222 35925952 : tp = marker[markidx++] = mpi_alloc_limb_space(dsize,mpi_is_secure(den));
223 35925952 : _gcry_mpih_lshift( tp, dp, dsize, normalization_steps );
224 35925952 : dp = tp;
225 :
226 : /* Shift up the numerator, possibly introducing a new most
227 : * significant word. Move the shifted numerator in the remainder
228 : * meanwhile. */
229 35925952 : nlimb = _gcry_mpih_lshift(rp, np, nsize, normalization_steps);
230 35925952 : if( nlimb ) {
231 6011354 : rp[nsize] = nlimb;
232 6011354 : rsize = nsize + 1;
233 : }
234 : else
235 29914598 : rsize = nsize;
236 : }
237 : else {
238 : /* The denominator is already normalized, as required. Copy it to
239 : * temporary space if it overlaps with the quotient or remainder. */
240 2039158 : if( dp == rp || (quot && (dp == qp))) {
241 : mpi_ptr_t tp;
242 :
243 0 : marker_nlimbs[markidx] = dsize;
244 0 : tp = marker[markidx++] = mpi_alloc_limb_space(dsize,
245 : mpi_is_secure(den));
246 0 : MPN_COPY( tp, dp, dsize );
247 0 : dp = tp;
248 : }
249 :
250 : /* Move the numerator to the remainder. */
251 2039158 : if( rp != np )
252 1249 : MPN_COPY(rp, np, nsize);
253 :
254 2039158 : rsize = nsize;
255 : }
256 :
257 37965110 : q_limb = _gcry_mpih_divrem( qp, 0, rp, rsize, dp, dsize );
258 :
259 37965110 : if( quot ) {
260 125 : qsize = rsize - dsize;
261 125 : if(q_limb) {
262 0 : qp[qsize] = q_limb;
263 0 : qsize += 1;
264 : }
265 :
266 125 : quot->nlimbs = qsize;
267 125 : quot->sign = sign_quotient;
268 : }
269 :
270 37965110 : rsize = dsize;
271 37965110 : MPN_NORMALIZE (rp, rsize);
272 :
273 37965110 : if( normalization_steps && rsize ) {
274 35925568 : _gcry_mpih_rshift(rp, rp, rsize, normalization_steps);
275 35925568 : rsize -= rp[rsize - 1] == 0?1:0;
276 : }
277 :
278 37965110 : rem->nlimbs = rsize;
279 37965110 : rem->sign = sign_remainder;
280 111856199 : while( markidx )
281 : {
282 35925979 : markidx--;
283 35925979 : _gcry_mpi_free_limb_space (marker[markidx], marker_nlimbs[markidx]);
284 : }
285 : }
286 :
287 : void
288 619 : _gcry_mpi_tdiv_q_2exp( gcry_mpi_t w, gcry_mpi_t u, unsigned int count )
289 : {
290 : mpi_size_t usize, wsize;
291 : mpi_size_t limb_cnt;
292 :
293 619 : usize = u->nlimbs;
294 619 : limb_cnt = count / BITS_PER_MPI_LIMB;
295 619 : wsize = usize - limb_cnt;
296 619 : if( limb_cnt >= usize )
297 0 : w->nlimbs = 0;
298 : else {
299 : mpi_ptr_t wp;
300 : mpi_ptr_t up;
301 :
302 619 : RESIZE_IF_NEEDED( w, wsize );
303 619 : wp = w->d;
304 619 : up = u->d;
305 :
306 619 : count %= BITS_PER_MPI_LIMB;
307 619 : if( count ) {
308 619 : _gcry_mpih_rshift( wp, up + limb_cnt, wsize, count );
309 619 : wsize -= !wp[wsize - 1];
310 : }
311 : else {
312 0 : MPN_COPY_INCR( wp, up + limb_cnt, wsize);
313 : }
314 :
315 619 : w->nlimbs = wsize;
316 : }
317 619 : }
318 :
319 : /****************
320 : * Check whether dividend is divisible by divisor
321 : * (note: divisor must fit into a limb)
322 : */
323 : int
324 2657451 : _gcry_mpi_divisible_ui(gcry_mpi_t dividend, ulong divisor )
325 : {
326 2657451 : return !_gcry_mpih_mod_1( dividend->d, dividend->nlimbs, divisor );
327 : }
328 :
329 :
330 : void
331 2 : _gcry_mpi_div (gcry_mpi_t quot, gcry_mpi_t rem, gcry_mpi_t dividend,
332 : gcry_mpi_t divisor, int round)
333 : {
334 2 : if (!round)
335 : {
336 0 : if (!rem)
337 : {
338 0 : gcry_mpi_t tmp = mpi_alloc (mpi_get_nlimbs(quot));
339 0 : _gcry_mpi_tdiv_qr (quot, tmp, dividend, divisor);
340 0 : mpi_free (tmp);
341 : }
342 : else
343 0 : _gcry_mpi_tdiv_qr (quot, rem, dividend, divisor);
344 : }
345 2 : else if (round < 0)
346 : {
347 2 : if (!rem)
348 2 : _gcry_mpi_fdiv_q (quot, dividend, divisor);
349 0 : else if (!quot)
350 0 : _gcry_mpi_fdiv_r (rem, dividend, divisor);
351 : else
352 0 : _gcry_mpi_fdiv_qr (quot, rem, dividend, divisor);
353 : }
354 : else
355 0 : log_bug ("mpi rounding to ceiling not yet implemented\n");
356 2 : }
|
