big.c File Reference

#include <rz_util.h>

Go to the source code of this file.

Functions
static void	_lshift_one_bit (RzNumBig *a)
static void	_rshift_one_bit (RzNumBig *a)
static void	_lshift_word (RzNumBig *a, int nwords)
static void	_rshift_word (RzNumBig *a, int nwords)
static void	_r_big_zero_out (RzNumBig *n)
RZ_API RzNumBig *	rz_big_new (void)
RZ_API void	rz_big_free (RzNumBig *b)
RZ_API void	rz_big_init (RzNumBig *b)
RZ_API void	rz_big_fini (RzNumBig *b)
RZ_API void	rz_big_from_int (RzNumBig *b, st64 n)
static void	rz_big_from_unsigned (RzNumBig *b, ut64 v)
RZ_API st64	rz_big_to_int (RzNumBig *b)
RZ_API void	rz_big_from_hexstr (RzNumBig *n, const char *str)
RZ_API char *	rz_big_to_hexstr (RzNumBig *b)
RZ_API void	rz_big_assign (RzNumBig *dst, RzNumBig *src)
static void	rz_big_add_inner (RzNumBig *c, RzNumBig *a, RzNumBig *b)
static void	rz_big_sub_inner (RzNumBig *c, RzNumBig *a, RzNumBig *b)
RZ_API void	rz_big_add (RzNumBig *c, RzNumBig *a, RzNumBig *b)
RZ_API void	rz_big_sub (RzNumBig *c, RzNumBig *a, RzNumBig *b)
RZ_API void	rz_big_mul (RzNumBig *c, RzNumBig *a, RzNumBig *b)
RZ_API void	rz_big_div (RzNumBig *c, RzNumBig *a, RzNumBig *b)
RZ_API void	rz_big_mod (RzNumBig *c, RzNumBig *a, RzNumBig *b)
RZ_API void	rz_big_divmod (RzNumBig *c, RzNumBig *d, RzNumBig *a, RzNumBig *b)
RZ_API void	rz_big_and (RzNumBig *c, RzNumBig *a, RzNumBig *b)
RZ_API void	rz_big_or (RzNumBig *c, RzNumBig *a, RzNumBig *b)
RZ_API void	rz_big_xor (RzNumBig *c, RzNumBig *a, RzNumBig *b)
RZ_API void	rz_big_lshift (RzNumBig *b, RzNumBig *a, size_t nbits)
RZ_API void	rz_big_rshift (RzNumBig *b, RzNumBig *a, size_t nbits)
RZ_API int	rz_big_cmp (RzNumBig *a, RzNumBig *b)
RZ_API int	rz_big_is_zero (RzNumBig *a)
RZ_API void	rz_big_inc (RzNumBig *a)
RZ_API void	rz_big_dec (RzNumBig *a)
RZ_API void	rz_big_powm (RzNumBig *c, RzNumBig *a, RzNumBig *b, RzNumBig *m)
RZ_API void	rz_big_isqrt (RzNumBig *b, RzNumBig *a)

Function Documentation

_lshift_one_bit()

static void _lshift_one_bit ( RzNumBig *  a )

static

Definition at line 664 of file big.c.

                                         {
    rz_return_if_fail(a);
 
    int i;
    for (i = (RZ_BIG_ARRAY_SIZE - 1); i > 0; i--) {
        a->array[i] = (a->array[i] << 1) | (a->array[i - 1] >> ((8 * RZ_BIG_WORD_SIZE) - 1));
    }
    a->array[0] <<= 1;
}

References a, i, RZ_BIG_ARRAY_SIZE, RZ_BIG_WORD_SIZE, and rz_return_if_fail.

Referenced by rz_big_div().

_lshift_word()

static void _lshift_word ( RzNumBig *  a, int  nwords  )

static

Definition at line 649 of file big.c.

                                                  {
    rz_return_if_fail(a);
    rz_return_if_fail(nwords >= 0);
 
    int i;
    /* Shift whole words */
    for (i = (RZ_BIG_ARRAY_SIZE - 1); i >= nwords; i--) {
        a->array[i] = a->array[i - nwords];
    }
    /* Zero pad shifted words. */
    for (; i >= 0; i--) {
        a->array[i] = 0;
    }
}

References a, i, RZ_BIG_ARRAY_SIZE, and rz_return_if_fail.

Referenced by rz_big_lshift(), and rz_big_mul().

_r_big_zero_out()

static void _r_big_zero_out ( RzNumBig *  n )

static

Definition at line 684 of file big.c.

                                         {
    rz_return_if_fail(a);
 
    size_t i;
    for (i = 0; i < RZ_BIG_ARRAY_SIZE; i++) {
        a->array[i] = 0;
    }
    a->sign = 1; /* hack to avoid -0 */
}

References a, i, RZ_BIG_ARRAY_SIZE, and rz_return_if_fail.

Referenced by rz_big_div(), rz_big_fini(), rz_big_from_hexstr(), rz_big_from_int(), rz_big_from_unsigned(), rz_big_init(), rz_big_mul(), and rz_big_new().

_rshift_one_bit()

static void _rshift_one_bit ( RzNumBig *  a )

static

Definition at line 674 of file big.c.

                                         {
    rz_return_if_fail(a);
 
    int i;
    for (i = 0; i < (RZ_BIG_ARRAY_SIZE - 1); i++) {
        a->array[i] = (a->array[i] >> 1) | (a->array[i + 1] << ((8 * RZ_BIG_WORD_SIZE) - 1));
    }
    a->array[RZ_BIG_ARRAY_SIZE - 1] >>= 1;
}

References a, i, RZ_BIG_ARRAY_SIZE, RZ_BIG_WORD_SIZE, and rz_return_if_fail.

Referenced by rz_big_div(), rz_big_isqrt(), and rz_big_powm().

_rshift_word()

static void _rshift_word ( RzNumBig *  a, int  nwords  )

static

Definition at line 628 of file big.c.

                                                  {
    /* Naive method: */
    rz_return_if_fail(a);
    rz_return_if_fail(nwords >= 0);
 
    size_t i;
    if (nwords >= RZ_BIG_ARRAY_SIZE) {
        for (i = 0; i < RZ_BIG_ARRAY_SIZE; i++) {
            a->array[i] = 0;
        }
        return;
    }
 
    for (i = 0; i < RZ_BIG_ARRAY_SIZE - nwords; i++) {
        a->array[i] = a->array[i + nwords];
    }
    for (; i < RZ_BIG_ARRAY_SIZE; i++) {
        a->array[i] = 0;
    }
}

References a, i, RZ_BIG_ARRAY_SIZE, and rz_return_if_fail.

Referenced by rz_big_rshift().

rz_big_add()

RZ_API void rz_big_add	(	RzNumBig *	c,
		RzNumBig *	a,
		RzNumBig *	b
	)

Definition at line 242 of file big.c.

                                                              {
    rz_return_if_fail(a);
    rz_return_if_fail(b);
    rz_return_if_fail(c);
 
    if (a->sign >= 0 && b->sign >= 0) {
        rz_big_add_inner(c, a, b);
        c->sign = 1;
        return;
    }
    if (a->sign >= 0 && b->sign < 0) {
        rz_big_sub_inner(c, a, b);
        return;
    }
    if (a->sign < 0 && b->sign >= 0) {
        rz_big_sub_inner(c, b, a);
        return;
    }
    if (a->sign < 0 && b->sign < 0) {
        rz_big_add_inner(c, a, b);
        c->sign = -1;
        return;
    }
}

References a, b, c, rz_big_add_inner(), rz_big_sub_inner(), and rz_return_if_fail.

Referenced by rz_big_inc(), rz_big_isqrt(), and rz_big_mul().

rz_big_add_inner()

static void rz_big_add_inner ( RzNumBig *  c, RzNumBig *  a, RzNumBig *  b  )

static

Definition at line 207 of file big.c.

                                                                    {
    RZ_BIG_DTYPE_TMP tmp;
    int carry = 0;
    int i;
    for (i = 0; i < RZ_BIG_ARRAY_SIZE; i++) {
        tmp = (RZ_BIG_DTYPE_TMP)a->array[i] + b->array[i] + carry;
        carry = (tmp > RZ_BIG_MAX_VAL);
        c->array[i] = (tmp & RZ_BIG_MAX_VAL);
    }
}

References a, b, c, i, RZ_BIG_ARRAY_SIZE, RZ_BIG_DTYPE_TMP, RZ_BIG_MAX_VAL, and autogen_x86imm::tmp.

Referenced by rz_big_add(), and rz_big_sub().

rz_big_and()

RZ_API void rz_big_and	(	RzNumBig *	c,
		RzNumBig *	a,
		RzNumBig *	b
	)

Definition at line 424 of file big.c.

                                                              {
    rz_return_if_fail(a);
    rz_return_if_fail(b);
    rz_return_if_fail(c);
    rz_return_if_fail(a->sign > 0);
    rz_return_if_fail(b->sign > 0);
 
    int i;
    for (i = 0; i < RZ_BIG_ARRAY_SIZE; i++) {
        c->array[i] = (a->array[i] & b->array[i]);
    }
}

References a, b, c, i, RZ_BIG_ARRAY_SIZE, and rz_return_if_fail.

rz_big_assign()

RZ_API void rz_big_assign	(	RzNumBig *	dst,
		RzNumBig *	src
	)

Definition at line 200 of file big.c.

                                                        {
    rz_return_if_fail(dst);
    rz_return_if_fail(src);
 
    memcpy(dst, src, sizeof(RzNumBig));
}

References dst, memcpy(), rz_return_if_fail, and src.

Referenced by rz_big_div(), rz_big_isqrt(), rz_big_lshift(), rz_big_mul(), rz_big_powm(), and rz_big_rshift().

rz_big_cmp()

RZ_API int rz_big_cmp	(	RzNumBig *	a,
		RzNumBig *	b
	)

Definition at line 511 of file big.c.

                                                {
    rz_return_val_if_fail(a, 0);
    rz_return_val_if_fail(b, 0);
 
    if (a->sign != b->sign)
        return a->sign > 0 ? 1 : -1;
 
    int i = RZ_BIG_ARRAY_SIZE;
    do {
        i -= 1; /* Decrement first, to start with last array element */
        if (a->array[i] > b->array[i]) {
            return 1 * a->sign;
        }
        if (a->array[i] < b->array[i]) {
            return -1 * a->sign;
        }
    } while (i != 0);
 
    return 0;
}

References a, b, i, RZ_BIG_ARRAY_SIZE, and rz_return_val_if_fail.

Referenced by rz_big_div(), rz_big_isqrt(), and rz_big_sub_inner().

rz_big_dec()

RZ_API void rz_big_dec

(

RzNumBig *

a

)

Definition at line 555 of file big.c.

                                    {
    rz_return_if_fail(a);
    RzNumBig *tmp = rz_big_new();
 
    rz_big_from_int(tmp, 1);
    rz_big_sub(a, a, tmp);
 
    rz_big_free(tmp);
}

References a, rz_big_free(), rz_big_from_int(), rz_big_new(), rz_big_sub(), rz_return_if_fail, and autogen_x86imm::tmp.

Referenced by rz_big_isqrt().

rz_big_div()

RZ_API void rz_big_div	(	RzNumBig *	c,
		RzNumBig *	a,
		RzNumBig *	b
	)

Definition at line 328 of file big.c.

                                                              {
    rz_return_if_fail(a);
    rz_return_if_fail(b);
    rz_return_if_fail(c);
    rz_return_if_fail(!rz_big_is_zero(b));
 
    RzNumBig *current = rz_big_new();
    RzNumBig *denom = rz_big_new();
    ;
    RzNumBig *tmp = rz_big_new();
    int sign = a->sign * b->sign;
 
    rz_big_from_int(current, 1); // int current = 1;
    rz_big_assign(denom, b); // denom = b
    denom->sign = 1;
    rz_big_assign(tmp, denom); // tmp = denom = b
    _lshift_one_bit(tmp); // tmp <= 1
 
    while (rz_big_cmp(tmp, a) != 1) { // while (tmp <= a)
        if ((denom->array[RZ_BIG_ARRAY_SIZE - 1] >> (RZ_BIG_WORD_SIZE * 8 - 1)) == 1) {
            break; // Reach the max value
        }
        _lshift_one_bit(tmp); // tmp <= 1
        _lshift_one_bit(denom); // denom <= 1
        _lshift_one_bit(current); // current <= 1
    }
 
    rz_big_assign(tmp, a); // tmp = a
    tmp->sign = 1;
    _r_big_zero_out(c); // int answer = 0;
 
    while (!rz_big_is_zero(current)) // while (current != 0)
    {
        if (rz_big_cmp(tmp, denom) != -1) //   if (dividend >= denom)
        {
            rz_big_sub(tmp, tmp, denom); //     dividend -= denom;
            rz_big_or(c, current, c); //     answer |= current;
        }
        _rshift_one_bit(current); //   current >>= 1;
        _rshift_one_bit(denom); //   denom >>= 1;
    } // return answer;
 
    c->sign = sign;
    if (rz_big_is_zero(c)) {
        c->sign = 1; // For -1 * 0 case
    }
    rz_big_free(current);
    rz_big_free(denom);
    rz_big_free(tmp);
}

References _lshift_one_bit(), _r_big_zero_out(), _rshift_one_bit(), a, rz_num_big_t::array, b, c, RZ_BIG_ARRAY_SIZE, rz_big_assign(), rz_big_cmp(), rz_big_free(), rz_big_from_int(), rz_big_is_zero(), rz_big_new(), rz_big_or(), rz_big_sub(), RZ_BIG_WORD_SIZE, rz_return_if_fail, rz_num_big_t::sign, and autogen_x86imm::tmp.

Referenced by rz_big_divmod().

rz_big_divmod()

RZ_API void rz_big_divmod	(	RzNumBig *	c,
		RzNumBig *	d,
		RzNumBig *	a,
		RzNumBig *	b
	)

Definition at line 395 of file big.c.

                                                                              {
    /*
    Puts a%b in d
    and a/b in c
 
    mod(a,b) = a - ((a / b) * b)
 
    example:
      mod(8, 3) = 8 - ((8 / 3) * 3) = 2
    */
    rz_return_if_fail(a);
    rz_return_if_fail(b);
    rz_return_if_fail(c);
    rz_return_if_fail(!rz_big_is_zero(b));
 
    RzNumBig *tmp = rz_big_new();
 
    /* c = (a / b) */
    rz_big_div(c, a, b);
 
    /* tmp = (c * b) */
    rz_big_mul(tmp, c, b);
 
    /* d = a - tmp */
    rz_big_sub(d, a, tmp);
 
    rz_big_free(tmp);
}

References a, b, c, d, rz_big_div(), rz_big_free(), rz_big_is_zero(), rz_big_mul(), rz_big_new(), rz_big_sub(), rz_return_if_fail, and autogen_x86imm::tmp.

Referenced by rz_big_mod().

rz_big_fini()

RZ_API void rz_big_fini

(

RzNumBig *

b

)

Definition at line 33 of file big.c.

                                     {
    _r_big_zero_out(b);
}

References _r_big_zero_out(), and b.

rz_big_free()

RZ_API void rz_big_free

(

RzNumBig *

b

)

Definition at line 25 of file big.c.

                                     {
    free(b);
}

References b, and free().

Referenced by rz_big_dec(), rz_big_div(), rz_big_divmod(), rz_big_inc(), rz_big_isqrt(), rz_big_mod(), rz_big_mul(), and rz_big_powm().

rz_big_from_hexstr()

RZ_API void rz_big_from_hexstr	(	RzNumBig *	n,
		const char *	str
	)

Definition at line 113 of file big.c.

                                                             {
    rz_return_if_fail(n);
    rz_return_if_fail(str);
    int nbytes = strlen(str);
 
    _r_big_zero_out(n);
 
    if (str[0] == '-') {
        n->sign = -1;
        str += 1;
        nbytes -= 1;
    }
 
    if (str[0] == '0' && str[1] == 'x') {
        str += 2;
        nbytes -= 2;
    }
    rz_return_if_fail(nbytes > 0);
 
    RZ_BIG_DTYPE tmp;
    int i = nbytes - (2 * RZ_BIG_WORD_SIZE); /* index into string */
    int j = 0; /* index into array */
 
    while (i >= 0) {
        tmp = 0;
        sscanf(&str[i], RZ_BIG_SSCANF_FORMAT_STR, &tmp);
        n->array[j] = tmp;
        i -= (2 * RZ_BIG_WORD_SIZE); /* step RZ_BIG_WORD_SIZE hex-byte(s) back in the string. */
        j += 1; /* step one element forward in the array. */
    }
 
    if (-2 * RZ_BIG_WORD_SIZE < i) {
        char buffer[2 * RZ_BIG_WORD_SIZE];
        memset(buffer, 0, sizeof(buffer));
        i += 2 * RZ_BIG_WORD_SIZE - 1;
        for (; i >= 0; i--) {
            buffer[i] = str[i];
        }
        tmp = 0;
        sscanf(buffer, RZ_BIG_SSCANF_FORMAT_STR, &tmp);
        n->array[j] = tmp;
    }
}

References _r_big_zero_out(), b, i, memset(), n, nbytes, RZ_BIG_DTYPE, RZ_BIG_SSCANF_FORMAT_STR, RZ_BIG_WORD_SIZE, rz_return_if_fail, rz_str_startswith(), cmd_descs_generate::str, and autogen_x86imm::tmp.

rz_big_from_int()

RZ_API void rz_big_from_int	(	RzNumBig *	b,
		st64	n
	)

Definition at line 37 of file big.c.

                                                 {
    rz_return_if_fail(b);
 
    _r_big_zero_out(b);
    b->sign = (n < 0) ? -1 : 1;
    RZ_BIG_DTYPE_TMP v = n * b->sign;
 
    /* Endianness issue if machine is not little-endian? */
#ifdef RZ_BIG_WORD_SIZE
#if (RZ_BIG_WORD_SIZE == 1)
    b->array[0] = (v & 0x000000ff);
    b->array[1] = (v & 0x0000ff00) >> 8;
    b->array[2] = (v & 0x00ff0000) >> 16;
    b->array[3] = (v & 0xff000000) >> 24;
#elif (RZ_BIG_WORD_SIZE == 2)
    b->array[0] = (v & 0x0000ffff);
    b->array[1] = (v & 0xffff0000) >> 16;
#elif (RZ_BIG_WORD_SIZE == 4)
    b->array[0] = v;
    RZ_BIG_DTYPE_TMP num_32 = 32;
    RZ_BIG_DTYPE_TMP tmp = v >> num_32;
    b->array[1] = tmp;
#endif
#endif
}

References _r_big_zero_out(), b, n, RZ_BIG_DTYPE_TMP, rz_return_if_fail, autogen_x86imm::tmp, and v.

Referenced by rz_big_dec(), rz_big_div(), rz_big_inc(), and rz_big_powm().

rz_big_from_unsigned()

static void rz_big_from_unsigned ( RzNumBig *  b, ut64  v  )

static

Definition at line 63 of file big.c.

                                                      {
    rz_return_if_fail(b);
 
    _r_big_zero_out(b);
 
    /* Endianness issue if machine is not little-endian? */
#ifdef RZ_BIG_WORD_SIZE
#if (RZ_BIG_WORD_SIZE == 1)
    b->array[0] = (v & 0x000000ff);
    b->array[1] = (v & 0x0000ff00) >> 8;
    b->array[2] = (v & 0x00ff0000) >> 16;
    b->array[3] = (v & 0xff000000) >> 24;
#elif (RZ_BIG_WORD_SIZE == 2)
    b->array[0] = (v & 0x0000ffff);
    b->array[1] = (v & 0xffff0000) >> 16;
#elif (RZ_BIG_WORD_SIZE == 4)
    b->array[0] = v;
    RZ_BIG_DTYPE_TMP num_32 = 32;
    RZ_BIG_DTYPE_TMP tmp = v >> num_32;
    b->array[1] = tmp;
#endif
#endif
}

References _r_big_zero_out(), b, RZ_BIG_DTYPE_TMP, rz_return_if_fail, autogen_x86imm::tmp, and v.

Referenced by rz_big_mul().

rz_big_inc()

RZ_API void rz_big_inc

(

RzNumBig *

a

)

Definition at line 545 of file big.c.

                                    {
    rz_return_if_fail(a);
    RzNumBig *tmp = rz_big_new();
 
    rz_big_from_int(tmp, 1);
    rz_big_add(a, a, tmp);
 
    rz_big_free(tmp);
}

References a, rz_big_add(), rz_big_free(), rz_big_from_int(), rz_big_new(), rz_return_if_fail, and autogen_x86imm::tmp.

Referenced by rz_big_isqrt().

rz_big_init()

RZ_API void rz_big_init

(

RzNumBig *

b

)

Definition at line 29 of file big.c.

                                     {
    _r_big_zero_out(b);
}

References _r_big_zero_out(), and b.

rz_big_is_zero()

RZ_API int rz_big_is_zero

(

RzNumBig *

a

)

Definition at line 532 of file big.c.

                                       {
    rz_return_val_if_fail(a, -1);
 
    int i;
    for (i = 0; i < RZ_BIG_ARRAY_SIZE; i++) {
        if (a->array[i]) {
            return 0;
        }
    }
 
    return 1;
}

References a, i, RZ_BIG_ARRAY_SIZE, and rz_return_val_if_fail.

Referenced by rz_big_div(), rz_big_divmod(), rz_big_mod(), rz_big_mul(), and rz_big_powm().

rz_big_isqrt()

RZ_API void rz_big_isqrt	(	RzNumBig *	b,
		RzNumBig *	a
	)

Definition at line 593 of file big.c.

                                                   {
    rz_return_if_fail(a);
    rz_return_if_fail(b);
 
    RzNumBig *tmp = rz_big_new();
    RzNumBig *low = rz_big_new();
    RzNumBig *high = rz_big_new();
    RzNumBig *mid = rz_big_new();
 
    rz_big_assign(high, a);
    rz_big_rshift(mid, high, 1);
    rz_big_inc(mid);
 
    while (rz_big_cmp(high, low) > 0) {
        rz_big_mul(tmp, mid, mid);
        if (rz_big_cmp(tmp, a) > 0) {
            rz_big_assign(high, mid);
            rz_big_dec(high);
        } else {
            rz_big_assign(low, mid);
        }
        rz_big_sub(mid, high, low);
        _rshift_one_bit(mid);
        rz_big_add(mid, mid, low);
        rz_big_inc(mid);
    }
    rz_big_assign(b, low);
 
    rz_big_free(tmp);
    rz_big_free(low);
    rz_big_free(high);
    rz_big_free(mid);
}

References _rshift_one_bit(), a, b, c, rz_big_add(), rz_big_assign(), rz_big_cmp(), rz_big_dec(), rz_big_free(), rz_big_inc(), rz_big_mul(), rz_big_new(), rz_big_rshift(), rz_big_sub(), rz_return_if_fail, and autogen_x86imm::tmp.

rz_big_lshift()

RZ_API void rz_big_lshift	(	RzNumBig *	b,
		RzNumBig *	a,
		size_t	nbits
	)

Definition at line 463 of file big.c.

                                                                  {
    rz_return_if_fail(a);
    rz_return_if_fail(b);
    rz_return_if_fail(a->sign > 0);
    rz_return_if_fail(b->sign > 0);
 
    rz_big_assign(b, a);
    /* Handle shift in multiples of word-size */
    const int nbits_pr_word = (RZ_BIG_WORD_SIZE * 8);
    int nwords = nbits / nbits_pr_word;
    if (nwords != 0) {
        _lshift_word(b, nwords);
        nbits -= (nwords * nbits_pr_word);
    }
 
    if (nbits != 0) {
        int i;
        for (i = (RZ_BIG_ARRAY_SIZE - 1); i > 0; i--) {
            b->array[i] = (b->array[i] << nbits) | (b->array[i - 1] >> ((8 * RZ_BIG_WORD_SIZE) - nbits));
        }
        b->array[i] <<= nbits;
    }
}

References _lshift_word(), a, b, c, i, RZ_BIG_ARRAY_SIZE, rz_big_assign(), RZ_BIG_WORD_SIZE, and rz_return_if_fail.

rz_big_mod()

RZ_API void rz_big_mod	(	RzNumBig *	c,
		RzNumBig *	a,
		RzNumBig *	b
	)

Definition at line 379 of file big.c.

                                                              {
    /*
    Take divmod and throw away div part
    */
    rz_return_if_fail(a);
    rz_return_if_fail(b);
    rz_return_if_fail(c);
    rz_return_if_fail(!rz_big_is_zero(b));
 
    RzNumBig *tmp = rz_big_new();
 
    rz_big_divmod(tmp, c, a, b);
 
    rz_big_free(tmp);
}

References a, b, c, rz_big_divmod(), rz_big_free(), rz_big_is_zero(), rz_big_new(), rz_return_if_fail, and autogen_x86imm::tmp.

Referenced by rz_big_powm().

rz_big_mul()

RZ_API void rz_big_mul	(	RzNumBig *	c,
		RzNumBig *	a,
		RzNumBig *	b
	)

Definition at line 292 of file big.c.

                                                              {
    rz_return_if_fail(a);
    rz_return_if_fail(b);
    rz_return_if_fail(c);
 
    RzNumBig *row = rz_big_new();
    RzNumBig *tmp = rz_big_new();
    RzNumBig *res = rz_big_new();
    int i, j;
 
    for (i = 0; i < RZ_BIG_ARRAY_SIZE; i++) {
        _r_big_zero_out(row);
 
        for (j = 0; j < RZ_BIG_ARRAY_SIZE; j++) {
            if (i + j < RZ_BIG_ARRAY_SIZE) {
                _r_big_zero_out(tmp);
                RZ_BIG_DTYPE_TMP intermediate = ((RZ_BIG_DTYPE_TMP)a->array[i] * (RZ_BIG_DTYPE_TMP)b->array[j]);
                rz_big_from_unsigned(tmp, intermediate);
                _lshift_word(tmp, i + j);
                rz_big_add(row, row, tmp);
            }
        }
        rz_big_add(res, row, res);
    }
 
    res->sign = a->sign * b->sign;
    if (rz_big_is_zero(res)) {
        res->sign = 1; // For -1 * 0 case
    }
    rz_big_assign(c, res);
 
    rz_big_free(row);
    rz_big_free(tmp);
    rz_big_free(res);
}

References _lshift_word(), _r_big_zero_out(), a, b, c, i, rz_big_add(), RZ_BIG_ARRAY_SIZE, rz_big_assign(), RZ_BIG_DTYPE_TMP, rz_big_free(), rz_big_from_unsigned(), rz_big_is_zero(), rz_big_new(), rz_return_if_fail, rz_num_big_t::sign, and autogen_x86imm::tmp.

Referenced by rz_big_divmod(), rz_big_isqrt(), and rz_big_powm().

rz_big_new()

RZ_API RzNumBig* rz_big_new

(

void

)

Definition at line 17 of file big.c.

                                  {
    RzNumBig *n = RZ_NEW(RzNumBig);
    if (n) {
        _r_big_zero_out(n);
    }
    return n;
}

References _r_big_zero_out(), n, and RZ_NEW.

Referenced by rz_big_dec(), rz_big_div(), rz_big_divmod(), rz_big_inc(), rz_big_isqrt(), rz_big_mod(), rz_big_mul(), and rz_big_powm().

rz_big_or()

RZ_API void rz_big_or	(	RzNumBig *	c,
		RzNumBig *	a,
		RzNumBig *	b
	)

Definition at line 437 of file big.c.

                                                             {
    rz_return_if_fail(a);
    rz_return_if_fail(b);
    rz_return_if_fail(c);
    rz_return_if_fail(a->sign > 0);
    rz_return_if_fail(b->sign > 0);
 
    int i;
    for (i = 0; i < RZ_BIG_ARRAY_SIZE; i++) {
        c->array[i] = (a->array[i] | b->array[i]);
    }
}

References a, b, c, i, RZ_BIG_ARRAY_SIZE, and rz_return_if_fail.

Referenced by rz_big_div().

rz_big_powm()

RZ_API void rz_big_powm	(	RzNumBig *	c,
		RzNumBig *	a,
		RzNumBig *	b,
		RzNumBig *	m
	)

Definition at line 565 of file big.c.

                                                                            {
    rz_return_if_fail(a);
    rz_return_if_fail(b);
    rz_return_if_fail(c);
    rz_return_if_fail(m);
 
    RzNumBig *bcopy = rz_big_new();
    RzNumBig *acopy = rz_big_new();
 
    rz_big_assign(bcopy, b);
    rz_big_assign(acopy, a);
    rz_big_mod(acopy, acopy, m);
    rz_big_from_int(c, 1);
 
    while (!rz_big_is_zero(bcopy)) {
        if (rz_big_to_int(bcopy) % 2 == 1) {
            rz_big_mul(c, c, acopy);
            rz_big_mod(c, c, m);
        }
        _rshift_one_bit(bcopy);
        rz_big_mul(acopy, acopy, acopy);
        rz_big_mod(acopy, acopy, m);
    }
 
    rz_big_free(bcopy);
    rz_big_free(acopy);
}

References _rshift_one_bit(), a, b, c, regress::m, rz_big_assign(), rz_big_free(), rz_big_from_int(), rz_big_is_zero(), rz_big_mod(), rz_big_mul(), rz_big_new(), rz_big_to_int(), and rz_return_if_fail.

rz_big_rshift()

RZ_API void rz_big_rshift	(	RzNumBig *	b,
		RzNumBig *	a,
		size_t	nbits
	)

Definition at line 487 of file big.c.

                                                                  {
    rz_return_if_fail(a);
    rz_return_if_fail(b);
    rz_return_if_fail(a->sign > 0);
    rz_return_if_fail(b->sign > 0);
 
    rz_big_assign(b, a);
    /* Handle shift in multiples of word-size */
    const int nbits_pr_word = (RZ_BIG_WORD_SIZE * 8);
    int nwords = nbits / nbits_pr_word;
    if (nwords != 0) {
        _rshift_word(b, nwords);
        nbits -= (nwords * nbits_pr_word);
    }
 
    if (nbits != 0) {
        int i;
        for (i = 0; i < (RZ_BIG_ARRAY_SIZE - 1); i++) {
            b->array[i] = (b->array[i] >> nbits) | (b->array[i + 1] << ((8 * RZ_BIG_WORD_SIZE) - nbits));
        }
        b->array[i] >>= nbits;
    }
}

References _rshift_word(), a, b, c, i, RZ_BIG_ARRAY_SIZE, rz_big_assign(), RZ_BIG_WORD_SIZE, and rz_return_if_fail.

Referenced by rz_big_isqrt().

rz_big_sub()

RZ_API void rz_big_sub	(	RzNumBig *	c,
		RzNumBig *	a,
		RzNumBig *	b
	)

Definition at line 267 of file big.c.

                                                              {
    rz_return_if_fail(a);
    rz_return_if_fail(b);
    rz_return_if_fail(c);
 
    if (a->sign >= 0 && b->sign >= 0) {
        rz_big_sub_inner(c, a, b);
        return;
    }
    if (a->sign >= 0 && b->sign < 0) {
        rz_big_add_inner(c, a, b);
        c->sign = 1;
        return;
    }
    if (a->sign < 0 && b->sign >= 0) {
        rz_big_add_inner(c, a, b);
        c->sign = -1;
        return;
    }
    if (a->sign < 0 && b->sign < 0) {
        rz_big_sub_inner(c, b, a);
        return;
    }
}

References a, b, c, rz_big_add_inner(), rz_big_sub_inner(), and rz_return_if_fail.

Referenced by rz_big_dec(), rz_big_div(), rz_big_divmod(), and rz_big_isqrt().

rz_big_sub_inner()

static void rz_big_sub_inner ( RzNumBig *  c, RzNumBig *  a, RzNumBig *  b  )

static

Definition at line 218 of file big.c.

                                                                    {
    RZ_BIG_DTYPE_TMP res;
    RzNumBig *tmp;
    RZ_BIG_DTYPE_TMP tmp1;
    RZ_BIG_DTYPE_TMP tmp2;
    int borrow = 0;
    int sign = rz_big_cmp(a, b);
    c->sign = (sign >= 0 ? 1 : -1);
    if (sign < 0) {
        tmp = a;
        a = b;
        b = tmp;
    }
    int i;
    for (i = 0; i < RZ_BIG_ARRAY_SIZE; i++) {
        tmp1 = (RZ_BIG_DTYPE_TMP)a->array[i] + (RZ_BIG_MAX_VAL + 1); /* + number_base */
        tmp2 = (RZ_BIG_DTYPE_TMP)b->array[i] + borrow;
 
        res = (tmp1 - tmp2);
        c->array[i] = (RZ_BIG_DTYPE)(res & RZ_BIG_MAX_VAL); /* "modulo number_base" == "% (number_base - 1)" if nu    mber_base is 2^N */
        borrow = (res <= RZ_BIG_MAX_VAL);
    }
}

References a, b, c, i, RZ_BIG_ARRAY_SIZE, rz_big_cmp(), RZ_BIG_DTYPE, RZ_BIG_DTYPE_TMP, RZ_BIG_MAX_VAL, and autogen_x86imm::tmp.

Referenced by rz_big_add(), and rz_big_sub().

rz_big_to_hexstr()

RZ_API char* rz_big_to_hexstr

(

RzNumBig *

b

)

Definition at line 157 of file big.c.

                                           {
    rz_return_val_if_fail(b, NULL);
 
    int j = RZ_BIG_ARRAY_SIZE - 1; /* index into array - reading "MSB" first -> big-endian */
    size_t i = 0; /* index into string representation. */
    size_t k = 0; /* Leading zero's amount */
    size_t z, last_z = 2 * RZ_BIG_WORD_SIZE;
 
    for (; b->array[j] == 0 && j >= 0; j--) {
    }
    if (j == -1) {
        return "0x0";
    }
 
    size_t size = 3 + 2 * RZ_BIG_WORD_SIZE * (j + 1) + ((b->sign > 0) ? 0 : 1);
    char *ret_str = calloc(size, sizeof(char));
    if (!ret_str) {
        return NULL;
    }
 
    if (b->sign < 0) {
        ret_str[i++] = '-';
    }
    ret_str[i++] = '0';
    ret_str[i++] = 'x';
 
    rz_snprintf(ret_str + i, RZ_BIG_FORMAT_STR_LEN, RZ_BIG_SPRINTF_FORMAT_STR, b->array[j--]);
    for (; ret_str[i + k] == '0' && k < 2 * RZ_BIG_WORD_SIZE; k++) {
    }
    for (z = k; ret_str[i + z] && z < last_z; z++) {
        ret_str[i + z - k] = ret_str[i + z];
    }
    i += z - k;
    ret_str[i] = '\x00'; // Truncate string for case(j < 0)
 
    for (; j >= 0; j--) {
        rz_snprintf(ret_str + i, RZ_BIG_FORMAT_STR_LEN, RZ_BIG_SPRINTF_FORMAT_STR, b->array[j]);
        i += 2 * RZ_BIG_WORD_SIZE;
    }
 
    return ret_str;
}

References b, calloc(), free(), i, k, NULL, RZ_BIG_ARRAY_SIZE, RZ_BIG_FORMAT_STR_LEN, RZ_BIG_SPRINTF_FORMAT_STR, RZ_BIG_WORD_SIZE, rz_return_val_if_fail, rz_snprintf(), rz_str_newf(), and autogen_x86imm::tmp.

rz_big_to_int()

RZ_API st64 rz_big_to_int

(

RzNumBig *

b

)

Definition at line 87 of file big.c.

                                       {
    rz_return_val_if_fail(b, 0);
 
    RZ_BIG_DTYPE_TMP ret = 0;
 
    /* Endianness issue if machine is not little-endian? */
#if (RZ_BIG_WORD_SIZE == 1)
    ret += b->array[0];
    ret += b->array[1] << 8;
    ret += b->array[2] << 16;
    ret += b->array[3] << 24;
#elif (RZ_BIG_WORD_SIZE == 2)
    ret += b->array[0];
    ret += b->array[1] << 16;
#elif (RZ_BIG_WORD_SIZE == 4)
    ret += b->array[1];
    ret <<= 32;
    ret += b->array[0];
#endif
 
    if (b->sign < 0) {
        return -ret;
    }
    return ret;
}

References b, RZ_BIG_DTYPE_TMP, and rz_return_val_if_fail.

Referenced by rz_big_powm().

rz_big_xor()

RZ_API void rz_big_xor	(	RzNumBig *	c,
		RzNumBig *	a,
		RzNumBig *	b
	)

Definition at line 450 of file big.c.

                                                              {
    rz_return_if_fail(a);
    rz_return_if_fail(b);
    rz_return_if_fail(c);
    rz_return_if_fail(a->sign > 0);
    rz_return_if_fail(b->sign > 0);
 
    int i;
    for (i = 0; i < RZ_BIG_ARRAY_SIZE; i++) {
        c->array[i] = (a->array[i] ^ b->array[i]);
    }
}

References a, b, c, i, RZ_BIG_ARRAY_SIZE, and rz_return_if_fail.