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)
	Add a*b to the number defined by (c0,c1,c2). More...
#define	muladd_fast(a, b)
	Add a*b to the number defined by (c0,c1). More...
#define	muladd2(a, b)
	Add 2*a*b to the number defined by (c0,c1,c2). More...
#define	sumadd(a)
	Add a to the number defined by (c0,c1,c2). More...
#define	sumadd_fast(a)
	Add a to the number defined by (c0,c1). More...
#define	extract(n)
	Extract the lowest 32 bits of (c0,c1,c2) into n, and left shift the number 32 bits. More...
#define	extract_fast(n)
	Extract the lowest 32 bits of (c0,c1,c2) into n, and left shift the number 32 bits. More...

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.

Definition at line 334 of file scalar_8x32_impl.h.

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.

Definition at line 342 of file scalar_8x32_impl.h.

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)); \
}

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

c2 must never overflow.

Definition at line 266 of file scalar_8x32_impl.h.

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)); \
}

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

c2 must never overflow.

Definition at line 295 of file scalar_8x32_impl.h.

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); \
}

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

c1 must never overflow.

Definition at line 281 of file scalar_8x32_impl.h.

SECP256K1_N_0

#define SECP256K1_N_0   ((uint32_t)0xD0364141UL)

Definition at line 11 of file scalar_8x32_impl.h.

SECP256K1_N_1

#define SECP256K1_N_1   ((uint32_t)0xBFD25E8CUL)

Definition at line 12 of file scalar_8x32_impl.h.

SECP256K1_N_2

#define SECP256K1_N_2   ((uint32_t)0xAF48A03BUL)

Definition at line 13 of file scalar_8x32_impl.h.

SECP256K1_N_3

#define SECP256K1_N_3   ((uint32_t)0xBAAEDCE6UL)

Definition at line 14 of file scalar_8x32_impl.h.

SECP256K1_N_4

#define SECP256K1_N_4   ((uint32_t)0xFFFFFFFEUL)

Definition at line 15 of file scalar_8x32_impl.h.

SECP256K1_N_5

#define SECP256K1_N_5   ((uint32_t)0xFFFFFFFFUL)

Definition at line 16 of file scalar_8x32_impl.h.

SECP256K1_N_6

#define SECP256K1_N_6   ((uint32_t)0xFFFFFFFFUL)

Definition at line 17 of file scalar_8x32_impl.h.

SECP256K1_N_7

#define SECP256K1_N_7   ((uint32_t)0xFFFFFFFFUL)

Definition at line 18 of file scalar_8x32_impl.h.

SECP256K1_N_C_0

#define SECP256K1_N_C_0   (~SECP256K1_N_0 + 1)

Definition at line 21 of file scalar_8x32_impl.h.

SECP256K1_N_C_1

#define SECP256K1_N_C_1   (~SECP256K1_N_1)

Definition at line 22 of file scalar_8x32_impl.h.

SECP256K1_N_C_2

#define SECP256K1_N_C_2   (~SECP256K1_N_2)

Definition at line 23 of file scalar_8x32_impl.h.

SECP256K1_N_C_3

#define SECP256K1_N_C_3   (~SECP256K1_N_3)

Definition at line 24 of file scalar_8x32_impl.h.

SECP256K1_N_C_4

#define SECP256K1_N_C_4   (1)

Definition at line 25 of file scalar_8x32_impl.h.

SECP256K1_N_H_0

#define SECP256K1_N_H_0   ((uint32_t)0x681B20A0UL)

Definition at line 28 of file scalar_8x32_impl.h.

SECP256K1_N_H_1

#define SECP256K1_N_H_1   ((uint32_t)0xDFE92F46UL)

Definition at line 29 of file scalar_8x32_impl.h.

SECP256K1_N_H_2

#define SECP256K1_N_H_2   ((uint32_t)0x57A4501DUL)

Definition at line 30 of file scalar_8x32_impl.h.

SECP256K1_N_H_3

#define SECP256K1_N_H_3   ((uint32_t)0x5D576E73UL)

Definition at line 31 of file scalar_8x32_impl.h.

SECP256K1_N_H_4

#define SECP256K1_N_H_4   ((uint32_t)0xFFFFFFFFUL)

Definition at line 32 of file scalar_8x32_impl.h.

SECP256K1_N_H_5

#define SECP256K1_N_H_5   ((uint32_t)0xFFFFFFFFUL)

Definition at line 33 of file scalar_8x32_impl.h.

SECP256K1_N_H_6

#define SECP256K1_N_H_6   ((uint32_t)0xFFFFFFFFUL)

Definition at line 34 of file scalar_8x32_impl.h.

SECP256K1_N_H_7

#define SECP256K1_N_H_7   ((uint32_t)0x7FFFFFFFUL)

Definition at line 35 of file scalar_8x32_impl.h.

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.

Definition at line 317 of file scalar_8x32_impl.h.

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.

Definition at line 326 of file scalar_8x32_impl.h.