libmp.h

#ifndef LIBMP_H

#define LIBMP_H

#include <stdint.h>

#include <avr/pgmspace.h>

#define R_NUM   "r24"

#define R_CARRY "r25"

#define mp_add(N, A, B)         mp_adc (N, A, B, 0)

#define mp_lsl(N, A)            mp_rol (N, A, 0)

#define mp_lsr(N, A)            mp_ror (N, A, 0)

#define MP_INLINE __inline__ __attribute__((__always_inline__))

typedef struct

{

    uint8_t mask;

    uint8_t offset;

} mp_msb_t;

extern void mp_adc_asm (void);

extern void mp_ror_asm (void);

extern void mp_rol_asm (void);

extern void mp_rol8_asm (void);

extern void mp_sub_asm (void);

extern void mp_cmp_asm (void);

extern void mp_add0_asm (void);

extern void mp_sub0_asm (void);

extern void mp_set0_asm (void);

extern void mp_and_asm (void);

extern void mp_com_asm (void);

extern void mp_msb_asm (void);

extern void mp_copy_asm (void);

extern void mp_push_digit_asm (void);

extern void mp_out_hex (uint8_t, uint8_t*);

extern void mp_out_bin (uint8_t, const uint8_t*);

extern void mp_out_dec (uint8_t, const uint8_t*, uint8_t);

extern void mp_from_string (uint8_t, uint8_t*, const char*);

extern uint8_t mp_pop_digit (uint8_t, uint8_t*, uint8_t);

extern void mp_udivmod (uint8_t, uint8_t*, uint8_t*);

extern void mp_udivmod_1 (uint8_t, uint8_t*, uint8_t*, uint8_t);

extern void mp_mod (uint8_t, uint8_t*, const uint8_t*);

extern void mp_add_m (uint8_t, uint8_t*, const uint8_t*, const uint8_t*);

extern void mp_mul_m (uint8_t, uint8_t*, const uint8_t*, const uint8_t*);

extern void mp_mul2_m (uint8_t, uint8_t*, const uint8_t*);

extern void mp_exp_m (uint8_t, uint8_t*, const uint8_t*, const uint8_t*);

static MP_INLINE

uint8_t mp_udivmod0 (uint8_t n, uint8_t *a, uint8_t divisor)

{

    return mp_pop_digit (n, a, divisor);

}

extern uint8_t mp_zero_p;

static MP_INLINE

void mp_copy_P (uint8_t n, uint8_t *a, const __flash uint8_t *b)

{

    struct S { uint8_t a[n]; };

    * (struct S*) a = * (const __flash struct S*) b;

}

static MP_INLINE

uint8_t mp_getbit (uint8_t *a, unsigned bit)

{

    uint8_t val = a[bit >> 3];

    uint8_t bit8 = bit & 7;

    val >>= bit8;

    val &= 1;

    return val;

}

static MP_INLINE

uint8_t mp_adc (uint8_t n, uint8_t *a, const uint8_t *b, uint8_t carry)

{

    register uint8_t rn asm (R_NUM) = n;

    register uint8_t *ra asm ("r26") = a;

    register const uint8_t *rb asm ("r30") = b;

    register uint8_t rcarry asm (R_CARRY) = carry;

    asm volatile ("%~call %x[f]"

        : "+r" (rcarry)

        : [f] "s" (mp_adc_asm), "r" (rn), "r" (ra), "r" (rb)

        : "memory");

    return rcarry;

}

static MP_INLINE

uint8_t mp_add0 (uint8_t n, uint8_t *a, int8_t val)

{

    register uint8_t rn asm (R_NUM) = n;

    register uint8_t *ra asm ("r26") = a;

    register int8_t rcarry asm ("r25") = val;

    asm volatile ("%~call %x[f]"

        : "+r" (rcarry)

        : [f] "s" (mp_add0_asm), "r" (rn), "r" (ra)

        : "memory");

    if (val < 0)

        rcarry ^= 1;

    return rcarry;

}

static MP_INLINE

uint8_t mp_rol8 (uint8_t n, uint8_t *a, uint8_t val)

{

    register uint8_t rn asm (R_NUM) = n;

    register uint8_t *ra asm ("r26") = a;

    register uint8_t rval asm ("r25") = val;

    asm volatile ("%~call %x[f]"

        : "+r" (rval)

        : [f] "s" (mp_rol8_asm), "r" (rn), "r" (ra)

        : "memory");

    return rval;

}

static MP_INLINE

uint8_t mp_and (uint8_t n, uint8_t *a, const uint8_t *b)

{

    register uint8_t rn asm (R_NUM) = n;

    register uint8_t *ra asm ("r26") = a;

    register const uint8_t *rb asm ("r30") = b;

    register uint8_t rnonzero_p asm ("r25");

    asm volatile ("%~call %x[f]"

        : "=r" (rnonzero_p)

        : [f] "s" (mp_and_asm), "r" (rn), "r" (ra), "r" (rb)

        : "memory");

    return rnonzero_p;

}

static MP_INLINE

void mp_com (uint8_t n, uint8_t *a)

{

    register uint8_t rn asm (R_NUM) = n;

    register uint8_t *ra asm ("r26") = a;

    asm volatile ("%~call %x[f]"

        :

        : [f] "s" (mp_com_asm), "r" (rn), "r" (ra)

        : "memory");

}

static MP_INLINE

void mp_neg (uint8_t n, uint8_t *a)

{

    mp_add0 (n, a, -1);

    mp_com (n, a);

}

static MP_INLINE

void mp_set0 (uint8_t n, uint8_t *a, int8_t val)

{

    register uint8_t rn asm (R_NUM) = n;

    register uint8_t *ra asm ("r26") = a;

    register uint8_t rval asm ("r25") = val;

    asm volatile ("%~call %x[f]"

        : "+r" (rval)

        : [f] "s" (mp_set0_asm), "r" (rn), "r" (ra)

        : "memory");

}

static MP_INLINE

uint8_t mp_ror (uint8_t n, uint8_t *a, uint8_t carry)

{

    register uint8_t rn asm (R_NUM) = n;

    register uint8_t *ra asm ("r26") = a;

    register uint8_t rcarry asm (R_CARRY) = carry;

    asm volatile ("%~call %x[f]"

        : "+r" (rcarry)

        : [f] "s" (mp_ror_asm), "r" (rn), "r" (ra)

        : "memory");

    return rcarry;

}

static MP_INLINE

uint8_t mp_rol (uint8_t n, uint8_t *a, uint8_t carry)

{

    register uint8_t rn asm (R_NUM) = n;

    register uint8_t *ra asm ("r26") = a;

    register uint8_t rcarry asm (R_CARRY) = carry;

    asm volatile ("%~call %x[f]"

        : "+r" (rcarry)

        : [f] "s" (mp_rol_asm), "r" (rn), "r" (ra)

        : "memory");

    return rcarry;

}

static MP_INLINE

void mp_sub (uint8_t n, uint8_t *a, const uint8_t *b)

{

    register uint8_t rn asm (R_NUM) = n;

    register uint8_t *ra asm ("r26") = a;

    register const uint8_t *rb asm ("r30") = b;

    asm volatile ("%~call %x[f]"

        :

        : [f] "s" (mp_sub_asm), "r" (rn), "r" (ra), "r" (rb)

        : "25", "memory");

}

static MP_INLINE

int8_t mp_cmp (uint8_t n, const uint8_t *a, const uint8_t *b, uint8_t signed_p)

{

    register uint8_t rn asm (R_NUM) = n;

    register const uint8_t *ra asm ("r26") = a;

    register const uint8_t *rb asm ("r30") = b;

    register uint8_t rs asm ("r25") = signed_p;

    asm volatile ("%~call %x[f]"

        : "+r" (rs), "+r" (ra), "+r" (rb)

        : [f] "s" (mp_cmp_asm), "r" (rn)

        );

    return rs;

}

static MP_INLINE

mp_msb_t mp_msb (uint8_t n, const uint8_t *a)

{

    register uint8_t rn asm (R_NUM) = n;

    register const uint8_t *ra asm ("r26") = a;

    register mp_msb_t rmsb asm ("r22");

    asm volatile ("%~call %x[f]"

        : "=r" (rmsb)

        : [f] "s" (mp_msb_asm), "r" (rn), "r" (ra)

        );

    return rmsb;

}

static MP_INLINE

uint8_t mp_push_digit (uint8_t n, uint8_t *a, uint8_t b, uint8_t d)

{

    register uint8_t rn asm (R_NUM) = n;

    register uint8_t *ra asm ("r26") = a;

    register uint8_t rb asm ("r22") = b;

    register uint8_t rd asm ("r25") = d;

    asm volatile ("%~call %x[f]"

        : "+r" (rd)

        : [f] "s" (mp_push_digit_asm), "r" (rn), "r" (ra), "r" (rb)

        : "memory");

    return rd;

}

static MP_INLINE

void mp_copy (uint8_t n, uint8_t *a, const uint8_t *b)

{

    register uint8_t rn asm (R_NUM) = n;

    register uint8_t *ra asm ("r26") = a;

    register const uint8_t *rb asm ("r30") = b;

    asm volatile ("%~call %x[f]"

        :

        : [f] "s" (mp_copy_asm), "r" (rn), "r" (ra), "r" (rb)

        : "memory");

}

static MP_INLINE

void mp_add0_m (uint8_t n, uint8_t *a, int8_t b, const uint8_t *m)

{

    uint8_t carry = mp_add0 (n, a, b);

    if (b >= 0)

    {

        if (carry || mp_cmp (n, a, m, 0) >= 0)

        {

            mp_sub (n, a, m);

        }

    }

    else if (carry)

    {

        mp_add (n, a, m);

    }

}

#endif