Bitcoin
Macros | Functions
scalar_8x32_impl.h File Reference

Go to the source code of this file.

Macros

#define SECP256K1_N_0   ((uint32_t)0xD0364141UL)
 
#define SECP256K1_N_1   ((uint32_t)0xBFD25E8CUL)
 
#define SECP256K1_N_2   ((uint32_t)0xAF48A03BUL)
 
#define SECP256K1_N_3   ((uint32_t)0xBAAEDCE6UL)
 
#define SECP256K1_N_4   ((uint32_t)0xFFFFFFFEUL)
 
#define SECP256K1_N_5   ((uint32_t)0xFFFFFFFFUL)
 
#define SECP256K1_N_6   ((uint32_t)0xFFFFFFFFUL)
 
#define SECP256K1_N_7   ((uint32_t)0xFFFFFFFFUL)
 
#define SECP256K1_N_C_0   (~SECP256K1_N_0 + 1)
 
#define SECP256K1_N_C_1   (~SECP256K1_N_1)
 
#define SECP256K1_N_C_2   (~SECP256K1_N_2)
 
#define SECP256K1_N_C_3   (~SECP256K1_N_3)
 
#define SECP256K1_N_C_4   (1)
 
#define SECP256K1_N_H_0   ((uint32_t)0x681B20A0UL)
 
#define SECP256K1_N_H_1   ((uint32_t)0xDFE92F46UL)
 
#define SECP256K1_N_H_2   ((uint32_t)0x57A4501DUL)
 
#define SECP256K1_N_H_3   ((uint32_t)0x5D576E73UL)
 
#define SECP256K1_N_H_4   ((uint32_t)0xFFFFFFFFUL)
 
#define SECP256K1_N_H_5   ((uint32_t)0xFFFFFFFFUL)
 
#define SECP256K1_N_H_6   ((uint32_t)0xFFFFFFFFUL)
 
#define SECP256K1_N_H_7   ((uint32_t)0x7FFFFFFFUL)
 
#define muladd(a, b)
 
#define muladd_fast(a, b)
 
#define muladd2(a, b)
 
#define sumadd(a)
 
#define sumadd_fast(a)
 
#define extract(n)
 
#define extract_fast(n)
 

Functions

static SECP256K1_INLINE void secp256k1_scalar_clear (secp256k1_scalar *r)
 
static SECP256K1_INLINE void secp256k1_scalar_set_int (secp256k1_scalar *r, unsigned int v)
 
static SECP256K1_INLINE unsigned int secp256k1_scalar_get_bits (const secp256k1_scalar *a, unsigned int offset, unsigned int count)
 
static SECP256K1_INLINE unsigned int secp256k1_scalar_get_bits_var (const secp256k1_scalar *a, unsigned int offset, unsigned int count)
 
static SECP256K1_INLINE int secp256k1_scalar_check_overflow (const secp256k1_scalar *a)
 
static SECP256K1_INLINE int secp256k1_scalar_reduce (secp256k1_scalar *r, uint32_t overflow)
 
static int secp256k1_scalar_add (secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b)
 
static void secp256k1_scalar_cadd_bit (secp256k1_scalar *r, unsigned int bit, int flag)
 
static void secp256k1_scalar_set_b32 (secp256k1_scalar *r, const unsigned char *b32, int *overflow)
 
static void secp256k1_scalar_get_b32 (unsigned char *bin, const secp256k1_scalar *a)
 
static SECP256K1_INLINE int secp256k1_scalar_is_zero (const secp256k1_scalar *a)
 
static void secp256k1_scalar_negate (secp256k1_scalar *r, const secp256k1_scalar *a)
 
static SECP256K1_INLINE int secp256k1_scalar_is_one (const secp256k1_scalar *a)
 
static int secp256k1_scalar_is_high (const secp256k1_scalar *a)
 
static int secp256k1_scalar_cond_negate (secp256k1_scalar *r, int flag)
 
static void secp256k1_scalar_reduce_512 (secp256k1_scalar *r, const uint32_t *l)
 
static void secp256k1_scalar_mul_512 (uint32_t *l, const secp256k1_scalar *a, const secp256k1_scalar *b)
 
static void secp256k1_scalar_sqr_512 (uint32_t *l, const secp256k1_scalar *a)
 
static void secp256k1_scalar_mul (secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b)
 
static int secp256k1_scalar_shr_int (secp256k1_scalar *r, int n)
 
static void secp256k1_scalar_sqr (secp256k1_scalar *r, const secp256k1_scalar *a)
 
static SECP256K1_INLINE int secp256k1_scalar_eq (const secp256k1_scalar *a, const secp256k1_scalar *b)
 
static SECP256K1_INLINE void secp256k1_scalar_mul_shift_var (secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b, unsigned int shift)
 

Macro Definition Documentation

◆ extract

#define extract (   n)
Value:
{ \
(n) = c0; \
c0 = c1; \
c1 = c2; \
c2 = 0; \
}

Extract the lowest 32 bits of (c0,c1,c2) into n, and left shift the number 32 bits.

◆ extract_fast

#define extract_fast (   n)
Value:
{ \
(n) = c0; \
c0 = c1; \
c1 = 0; \
VERIFY_CHECK(c2 == 0); \
}

Extract the lowest 32 bits of (c0,c1,c2) into n, and left shift the number 32 bits. c2 is required to be zero.

◆ muladd

#define muladd (   a,
  b 
)
Value:
{ \
uint32_t tl, th; \
{ \
uint64_t t = (uint64_t)a * b; \
th = t >> 32; /* at most 0xFFFFFFFE */ \
tl = t; \
} \
c0 += tl; /* overflow is handled on the next line */ \
th += (c0 < tl) ? 1 : 0; /* at most 0xFFFFFFFF */ \
c1 += th; /* overflow is handled on the next line */ \
c2 += (c1 < th) ? 1 : 0; /* never overflows by contract (verified in the next line) */ \
VERIFY_CHECK((c1 >= th) || (c2 != 0)); \
}
uint64_t
unsigned long long uint64_t
Definition: stdint.h:22

Add a*b to the number defined by (c0,c1,c2). c2 must never overflow.

◆ muladd2

#define muladd2 (   a,
  b 
)
Value:
{ \
uint32_t tl, th, th2, tl2; \
{ \
uint64_t t = (uint64_t)a * b; \
th = t >> 32; /* at most 0xFFFFFFFE */ \
tl = t; \
} \
th2 = th + th; /* at most 0xFFFFFFFE (in case th was 0x7FFFFFFF) */ \
c2 += (th2 < th) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
VERIFY_CHECK((th2 >= th) || (c2 != 0)); \
tl2 = tl + tl; /* at most 0xFFFFFFFE (in case the lowest 63 bits of tl were 0x7FFFFFFF) */ \
th2 += (tl2 < tl) ? 1 : 0; /* at most 0xFFFFFFFF */ \
c0 += tl2; /* overflow is handled on the next line */ \
th2 += (c0 < tl2) ? 1 : 0; /* second overflow is handled on the next line */ \
c2 += (c0 < tl2) & (th2 == 0); /* never overflows by contract (verified the next line) */ \
VERIFY_CHECK((c0 >= tl2) || (th2 != 0) || (c2 != 0)); \
c1 += th2; /* overflow is handled on the next line */ \
c2 += (c1 < th2) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
VERIFY_CHECK((c1 >= th2) || (c2 != 0)); \
}
uint64_t
unsigned long long uint64_t
Definition: stdint.h:22

Add 2*a*b to the number defined by (c0,c1,c2). c2 must never overflow.

◆ muladd_fast

#define muladd_fast (   a,
  b 
)
Value:
{ \
uint32_t tl, th; \
{ \
uint64_t t = (uint64_t)a * b; \
th = t >> 32; /* at most 0xFFFFFFFE */ \
tl = t; \
} \
c0 += tl; /* overflow is handled on the next line */ \
th += (c0 < tl) ? 1 : 0; /* at most 0xFFFFFFFF */ \
c1 += th; /* never overflows by contract (verified in the next line) */ \
VERIFY_CHECK(c1 >= th); \
}
uint64_t
unsigned long long uint64_t
Definition: stdint.h:22

Add a*b to the number defined by (c0,c1). c1 must never overflow.

◆ SECP256K1_N_0

#define SECP256K1_N_0   ((uint32_t)0xD0364141UL)

◆ SECP256K1_N_1

#define SECP256K1_N_1   ((uint32_t)0xBFD25E8CUL)

◆ SECP256K1_N_2

#define SECP256K1_N_2   ((uint32_t)0xAF48A03BUL)

◆ SECP256K1_N_3

#define SECP256K1_N_3   ((uint32_t)0xBAAEDCE6UL)

◆ SECP256K1_N_4

#define SECP256K1_N_4   ((uint32_t)0xFFFFFFFEUL)

◆ SECP256K1_N_5

#define SECP256K1_N_5   ((uint32_t)0xFFFFFFFFUL)

◆ SECP256K1_N_6

#define SECP256K1_N_6   ((uint32_t)0xFFFFFFFFUL)

◆ SECP256K1_N_7

#define SECP256K1_N_7   ((uint32_t)0xFFFFFFFFUL)

◆ SECP256K1_N_C_0

#define SECP256K1_N_C_0   (~SECP256K1_N_0 + 1)

◆ SECP256K1_N_C_1

#define SECP256K1_N_C_1   (~SECP256K1_N_1)

◆ SECP256K1_N_C_2

#define SECP256K1_N_C_2   (~SECP256K1_N_2)

◆ SECP256K1_N_C_3

#define SECP256K1_N_C_3   (~SECP256K1_N_3)

◆ SECP256K1_N_C_4

#define SECP256K1_N_C_4   (1)

◆ SECP256K1_N_H_0

#define SECP256K1_N_H_0   ((uint32_t)0x681B20A0UL)

◆ SECP256K1_N_H_1

#define SECP256K1_N_H_1   ((uint32_t)0xDFE92F46UL)

◆ SECP256K1_N_H_2

#define SECP256K1_N_H_2   ((uint32_t)0x57A4501DUL)

◆ SECP256K1_N_H_3

#define SECP256K1_N_H_3   ((uint32_t)0x5D576E73UL)

◆ SECP256K1_N_H_4

#define SECP256K1_N_H_4   ((uint32_t)0xFFFFFFFFUL)

◆ SECP256K1_N_H_5

#define SECP256K1_N_H_5   ((uint32_t)0xFFFFFFFFUL)

◆ SECP256K1_N_H_6

#define SECP256K1_N_H_6   ((uint32_t)0xFFFFFFFFUL)

◆ SECP256K1_N_H_7

#define SECP256K1_N_H_7   ((uint32_t)0x7FFFFFFFUL)

◆ sumadd

#define sumadd (   a)
Value:
{ \
unsigned int over; \
c0 += (a); /* overflow is handled on the next line */ \
over = (c0 < (a)) ? 1 : 0; \
c1 += over; /* overflow is handled on the next line */ \
c2 += (c1 < over) ? 1 : 0; /* never overflows by contract */ \
}

Add a to the number defined by (c0,c1,c2). c2 must never overflow.

◆ sumadd_fast

#define sumadd_fast (   a)
Value:
{ \
c0 += (a); /* overflow is handled on the next line */ \
c1 += (c0 < (a)) ? 1 : 0; /* never overflows by contract (verified the next line) */ \
VERIFY_CHECK((c1 != 0) | (c0 >= (a))); \
VERIFY_CHECK(c2 == 0); \
}

Add a to the number defined by (c0,c1). c1 must never overflow, c2 must be zero.

Function Documentation

◆ secp256k1_scalar_add()

static int secp256k1_scalar_add ( secp256k1_scalar *  r,
const secp256k1_scalar *  a,
const secp256k1_scalar *  b 
)
static

◆ secp256k1_scalar_cadd_bit()

static void secp256k1_scalar_cadd_bit ( secp256k1_scalar *  r,
unsigned int  bit,
int  flag 
)
static

◆ secp256k1_scalar_check_overflow()

static SECP256K1_INLINE int secp256k1_scalar_check_overflow ( const secp256k1_scalar *  a)
static

◆ secp256k1_scalar_clear()

static SECP256K1_INLINE void secp256k1_scalar_clear ( secp256k1_scalar *  r)
static

◆ secp256k1_scalar_cond_negate()

static int secp256k1_scalar_cond_negate ( secp256k1_scalar *  r,
int  flag 
)
static

◆ secp256k1_scalar_eq()

static SECP256K1_INLINE int secp256k1_scalar_eq ( const secp256k1_scalar *  a,
const secp256k1_scalar *  b 
)
static

◆ secp256k1_scalar_get_b32()

static void secp256k1_scalar_get_b32 ( unsigned char *  bin,
const secp256k1_scalar *  a 
)
static

◆ secp256k1_scalar_get_bits()

static SECP256K1_INLINE unsigned int secp256k1_scalar_get_bits ( const secp256k1_scalar *  a,
unsigned int  offset,
unsigned int  count 
)
static

◆ secp256k1_scalar_get_bits_var()

static SECP256K1_INLINE unsigned int secp256k1_scalar_get_bits_var ( const secp256k1_scalar *  a,
unsigned int  offset,
unsigned int  count 
)
static

◆ secp256k1_scalar_is_high()

static int secp256k1_scalar_is_high ( const secp256k1_scalar *  a)
static

◆ secp256k1_scalar_is_one()

static SECP256K1_INLINE int secp256k1_scalar_is_one ( const secp256k1_scalar *  a)
static

◆ secp256k1_scalar_is_zero()

static SECP256K1_INLINE int secp256k1_scalar_is_zero ( const secp256k1_scalar *  a)
static

◆ secp256k1_scalar_mul()

static void secp256k1_scalar_mul ( secp256k1_scalar *  r,
const secp256k1_scalar *  a,
const secp256k1_scalar *  b 
)
static

◆ secp256k1_scalar_mul_512()

static void secp256k1_scalar_mul_512 ( uint32_t *  l,
const secp256k1_scalar *  a,
const secp256k1_scalar *  b 
)
static

◆ secp256k1_scalar_mul_shift_var()

static SECP256K1_INLINE void secp256k1_scalar_mul_shift_var ( secp256k1_scalar *  r,
const secp256k1_scalar *  a,
const secp256k1_scalar *  b,
unsigned int  shift 
)
static

◆ secp256k1_scalar_negate()

static void secp256k1_scalar_negate ( secp256k1_scalar *  r,
const secp256k1_scalar *  a 
)
static

◆ secp256k1_scalar_reduce()

static SECP256K1_INLINE int secp256k1_scalar_reduce ( secp256k1_scalar *  r,
uint32_t  overflow 
)
static

◆ secp256k1_scalar_reduce_512()

static void secp256k1_scalar_reduce_512 ( secp256k1_scalar *  r,
const uint32_t *  l 
)
static

◆ secp256k1_scalar_set_b32()

static void secp256k1_scalar_set_b32 ( secp256k1_scalar *  r,
const unsigned char *  b32,
int *  overflow 
)
static

◆ secp256k1_scalar_set_int()

static SECP256K1_INLINE void secp256k1_scalar_set_int ( secp256k1_scalar *  r,
unsigned int  v 
)
static

◆ secp256k1_scalar_shr_int()

static int secp256k1_scalar_shr_int ( secp256k1_scalar *  r,
int  n 
)
static

◆ secp256k1_scalar_sqr()

static void secp256k1_scalar_sqr ( secp256k1_scalar *  r,
const secp256k1_scalar *  a 
)
static

◆ secp256k1_scalar_sqr_512()

static void secp256k1_scalar_sqr_512 ( uint32_t *  l,
const secp256k1_scalar *  a 
)
static
Generated by   doxygen 1.8.15