LCOV - code coverage report
Current view: top level - mpi - mpi-add.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 104 114 91.2 %
Date: 2016-12-01 18:32:04 Functions: 6 6 100.0 %

          Line data    Source code
       1             : /* mpi-add.c  -  MPI functions
       2             :  * Copyright (C) 1994, 1996, 1998, 2001, 2002, 2003 Free Software Foundation, Inc.
       3             :  *
       4             :  * This file is part of Libgcrypt.
       5             :  *
       6             :  * Libgcrypt is free software; you can redistribute it and/or modify
       7             :  * it under the terms of the GNU Lesser General Public License as
       8             :  * published by the Free Software Foundation; either version 2.1 of
       9             :  * the License, or (at your option) any later version.
      10             :  *
      11             :  * Libgcrypt is distributed in the hope that it will be useful,
      12             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14             :  * GNU Lesser General Public License for more details.
      15             :  *
      16             :  * You should have received a copy of the GNU Lesser General Public
      17             :  * License along with this program; if not, write to the Free Software
      18             :  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
      19             :  *
      20             :  * Note: This code is heavily based on the GNU MP Library.
      21             :  *       Actually it's the same code with only minor changes in the
      22             :  *       way the data is stored; this is to support the abstraction
      23             :  *       of an optional secure memory allocation which may be used
      24             :  *       to avoid revealing of sensitive data due to paging etc.
      25             :  */
      26             : 
      27             : #include <config.h>
      28             : #include <stdio.h>
      29             : #include <stdlib.h>
      30             : 
      31             : #include "mpi-internal.h"
      32             : 
      33             : 
      34             : /****************
      35             :  * Add the unsigned integer V to the mpi-integer U and store the
      36             :  * result in W. U and V may be the same.
      37             :  */
      38             : void
      39       47600 : _gcry_mpi_add_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v )
      40             : {
      41             :     mpi_ptr_t wp, up;
      42             :     mpi_size_t usize, wsize;
      43             :     int usign, wsign;
      44             : 
      45       47600 :     usize = u->nlimbs;
      46       47600 :     usign = u->sign;
      47       47600 :     wsign = 0;
      48             : 
      49             :     /* If not space for W (and possible carry), increase space.  */
      50       47600 :     wsize = usize + 1;
      51       47600 :     if( w->alloced < wsize )
      52         706 :         mpi_resize(w, wsize);
      53             : 
      54             :     /* These must be after realloc (U may be the same as W).  */
      55       47600 :     up = u->d;
      56       47600 :     wp = w->d;
      57             : 
      58       47600 :     if( !usize ) {  /* simple */
      59           0 :         wp[0] = v;
      60           0 :         wsize = v? 1:0;
      61             :     }
      62       47600 :     else if( !usign ) {  /* mpi is not negative */
      63             :         mpi_limb_t cy;
      64       47599 :         cy = _gcry_mpih_add_1(wp, up, usize, v);
      65       47599 :         wp[usize] = cy;
      66       47599 :         wsize = usize + cy;
      67             :     }
      68             :     else {  /* The signs are different.  Need exact comparison to determine
      69             :              * which operand to subtract from which.  */
      70           1 :         if( usize == 1 && up[0] < v ) {
      71           0 :             wp[0] = v - up[0];
      72           0 :             wsize = 1;
      73             :         }
      74             :         else {
      75           1 :             _gcry_mpih_sub_1(wp, up, usize, v);
      76             :             /* Size can decrease with at most one limb. */
      77           1 :             wsize = usize - (wp[usize-1]==0);
      78           1 :             wsign = 1;
      79             :         }
      80             :     }
      81             : 
      82       47600 :     w->nlimbs = wsize;
      83       47600 :     w->sign   = wsign;
      84       47600 : }
      85             : 
      86             : 
      87             : void
      88    36034145 : _gcry_mpi_add(gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v)
      89             : {
      90             :     mpi_ptr_t wp, up, vp;
      91             :     mpi_size_t usize, vsize, wsize;
      92             :     int usign, vsign, wsign;
      93             : 
      94    36034145 :     if( u->nlimbs < v->nlimbs ) { /* Swap U and V. */
      95     1073521 :         usize = v->nlimbs;
      96     1073521 :         usign = v->sign;
      97     1073521 :         vsize = u->nlimbs;
      98     1073521 :         vsign = u->sign;
      99     1073521 :         wsize = usize + 1;
     100     1073521 :         RESIZE_IF_NEEDED(w, wsize);
     101             :         /* These must be after realloc (u or v may be the same as w).  */
     102     1073521 :         up    = v->d;
     103     1073521 :         vp    = u->d;
     104             :     }
     105             :     else {
     106    34960624 :         usize = u->nlimbs;
     107    34960624 :         usign = u->sign;
     108    34960624 :         vsize = v->nlimbs;
     109    34960624 :         vsign = v->sign;
     110    34960624 :         wsize = usize + 1;
     111    34960624 :         RESIZE_IF_NEEDED(w, wsize);
     112             :         /* These must be after realloc (u or v may be the same as w).  */
     113    34960624 :         up    = u->d;
     114    34960624 :         vp    = v->d;
     115             :     }
     116    36034145 :     wp = w->d;
     117    36034145 :     wsign = 0;
     118             : 
     119    36034145 :     if( !vsize ) {  /* simple */
     120       78631 :         MPN_COPY(wp, up, usize );
     121       78631 :         wsize = usize;
     122       78631 :         wsign = usign;
     123             :     }
     124    35955514 :     else if( usign != vsign ) { /* different sign */
     125             :         /* This test is right since USIZE >= VSIZE */
     126    25486252 :         if( usize != vsize ) {
     127     1044737 :             _gcry_mpih_sub(wp, up, usize, vp, vsize);
     128     1044737 :             wsize = usize;
     129     1044737 :             MPN_NORMALIZE(wp, wsize);
     130     1044737 :             wsign = usign;
     131             :         }
     132    24441515 :         else if( _gcry_mpih_cmp(up, vp, usize) < 0 ) {
     133    14194374 :             _gcry_mpih_sub_n(wp, vp, up, usize);
     134    14194374 :             wsize = usize;
     135    14194374 :             MPN_NORMALIZE(wp, wsize);
     136    14194374 :             if( !usign )
     137     7610551 :                 wsign = 1;
     138             :         }
     139             :         else {
     140    10247141 :             _gcry_mpih_sub_n(wp, up, vp, usize);
     141    10247141 :             wsize = usize;
     142    10247141 :             MPN_NORMALIZE(wp, wsize);
     143    10247141 :             if( usign )
     144       25570 :                 wsign = 1;
     145             :         }
     146             :     }
     147             :     else { /* U and V have same sign. Add them. */
     148    10469262 :         mpi_limb_t cy = _gcry_mpih_add(wp, up, usize, vp, vsize);
     149    10469262 :         wp[usize] = cy;
     150    10469262 :         wsize = usize + cy;
     151    10469262 :         if( usign )
     152       25582 :             wsign = 1;
     153             :     }
     154             : 
     155    36034145 :     w->nlimbs = wsize;
     156    36034145 :     w->sign = wsign;
     157    36034145 : }
     158             : 
     159             : 
     160             : /****************
     161             :  * Subtract the unsigned integer V from the mpi-integer U and store the
     162             :  * result in W.
     163             :  */
     164             : void
     165       18207 : _gcry_mpi_sub_ui(gcry_mpi_t w, gcry_mpi_t u, unsigned long v )
     166             : {
     167             :     mpi_ptr_t wp, up;
     168             :     mpi_size_t usize, wsize;
     169             :     int usign, wsign;
     170             : 
     171       18207 :     usize = u->nlimbs;
     172       18207 :     usign = u->sign;
     173       18207 :     wsign = 0;
     174             : 
     175             :     /* If not space for W (and possible carry), increase space.  */
     176       18207 :     wsize = usize + 1;
     177       18207 :     if( w->alloced < wsize )
     178        5176 :         mpi_resize(w, wsize);
     179             : 
     180             :     /* These must be after realloc (U may be the same as W).  */
     181       18207 :     up = u->d;
     182       18207 :     wp = w->d;
     183             : 
     184       18207 :     if( !usize ) {  /* simple */
     185           1 :         wp[0] = v;
     186           1 :         wsize = v? 1:0;
     187           1 :         wsign = 1;
     188             :     }
     189       18206 :     else if( usign ) {  /* mpi and v are negative */
     190             :         mpi_limb_t cy;
     191           0 :         cy = _gcry_mpih_add_1(wp, up, usize, v);
     192           0 :         wp[usize] = cy;
     193           0 :         wsize = usize + cy;
     194             :     }
     195             :     else {  /* The signs are different.  Need exact comparison to determine
     196             :              * which operand to subtract from which.  */
     197       18206 :         if( usize == 1 && up[0] < v ) {
     198           0 :             wp[0] = v - up[0];
     199           0 :             wsize = 1;
     200           0 :             wsign = 1;
     201             :         }
     202             :         else {
     203       18206 :             _gcry_mpih_sub_1(wp, up, usize, v);
     204             :             /* Size can decrease with at most one limb. */
     205       18206 :             wsize = usize - (wp[usize-1]==0);
     206             :         }
     207             :     }
     208             : 
     209       18207 :     w->nlimbs = wsize;
     210       18207 :     w->sign   = wsign;
     211       18207 : }
     212             : 
     213             : void
     214    18651783 : _gcry_mpi_sub(gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v)
     215             : {
     216    18651783 :   gcry_mpi_t vv = mpi_copy (v);
     217    18651783 :   vv->sign = ! vv->sign;
     218    18651783 :   mpi_add (w, u, vv);
     219    18651783 :   mpi_free (vv);
     220    18651783 : }
     221             : 
     222             : 
     223             : void
     224        1191 : _gcry_mpi_addm( gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m)
     225             : {
     226        1191 :   mpi_add (w, u, v);
     227        1191 :   mpi_mod (w, w, m);
     228        1191 : }
     229             : 
     230             : void
     231          46 : _gcry_mpi_subm( gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m)
     232             : {
     233          46 :   mpi_sub (w, u, v);
     234          46 :   mpi_mod (w, w, m);
     235          46 : }

Generated by: LCOV version 1.11