src/util.h

   1 /**********************************************************************
   2  * Copyright (c) 2013, 2014 Pieter Wuille                             *
   3  * Distributed under the MIT software license, see the accompanying   *
   4  * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
   5  **********************************************************************/
   6
   7 #ifndef SECP256K1_UTIL_H
   8 #define SECP256K1_UTIL_H
   9
  10 #if defined HAVE_CONFIG_H
  11 #include "libsecp256k1-config.h"
  12 #endif
  13
  14 #include <stdlib.h>
  15 #include <stdint.h>
  16 #include <stdio.h>
  17 #include <limits.h>
  18
  19 typedef struct {
  20     void (*fn)(const char *text, void* data);
  21     const void* data;
  22 } secp256k1_callback;
  23
  24 static SECP256K1_INLINE void secp256k1_callback_call(const secp256k1_callback * const cb, const char * const text) {
  25     cb->fn(text, (void*)cb->data);
  26 }
  27
  28 #ifdef DETERMINISTIC
  29 #define TEST_FAILURE(msg) do { \
  30     fprintf(stderr, "%s\n", msg); \
  31     abort(); \
  32 } while(0);
  33 #else
  34 #define TEST_FAILURE(msg) do { \
  35     fprintf(stderr, "%s:%d: %s\n", __FILE__, __LINE__, msg); \
  36     abort(); \
  37 } while(0)
  38 #endif
  39
  40 #if SECP256K1_GNUC_PREREQ(3, 0)
  41 #define EXPECT(x,c) __builtin_expect((x),(c))
  42 #else
  43 #define EXPECT(x,c) (x)
  44 #endif
  45
  46 #ifdef DETERMINISTIC
  47 #define CHECK(cond) do { \
  48     if (EXPECT(!(cond), 0)) { \
  49         TEST_FAILURE("test condition failed"); \
  50     } \
  51 } while(0)
  52 #else
  53 #define CHECK(cond) do { \
  54     if (EXPECT(!(cond), 0)) { \
  55         TEST_FAILURE("test condition failed: " #cond); \
  56     } \
  57 } while(0)
  58 #endif
  59
  60 /* Like assert(), but when VERIFY is defined, and side-effect safe. */
  61 #if defined(COVERAGE)
  62 #define VERIFY_CHECK(check)
  63 #define VERIFY_SETUP(stmt)
  64 #elif defined(VERIFY)
  65 #define VERIFY_CHECK CHECK
  66 #define VERIFY_SETUP(stmt) do { stmt; } while(0)
  67 #else
  68 #define VERIFY_CHECK(cond) do { (void)(cond); } while(0)
  69 #define VERIFY_SETUP(stmt)
  70 #endif
  71
  72 /* Define `VG_UNDEF` and `VG_CHECK` when VALGRIND is defined  */
  73 #if !defined(VG_CHECK)
  74 # if defined(VALGRIND)
  75 #  include <valgrind/memcheck.h>
  76 #  define VG_UNDEF(x,y) VALGRIND_MAKE_MEM_UNDEFINED((x),(y))
  77 #  define VG_CHECK(x,y) VALGRIND_CHECK_MEM_IS_DEFINED((x),(y))
  78 # else
  79 #  define VG_UNDEF(x,y)
  80 #  define VG_CHECK(x,y)
  81 # endif
  82 #endif
  83
  84 /* Like `VG_CHECK` but on VERIFY only */
  85 #if defined(VERIFY)
  86 #define VG_CHECK_VERIFY(x,y) VG_CHECK((x), (y))
  87 #else
  88 #define VG_CHECK_VERIFY(x,y)
  89 #endif
  90
  91 static SECP256K1_INLINE void *checked_malloc(const secp256k1_callback* cb, size_t size) {
  92     void *ret = malloc(size);
  93     if (ret == NULL) {
  94         secp256k1_callback_call(cb, "Out of memory");
  95     }
  96     return ret;
  97 }
  98
  99 static SECP256K1_INLINE void *checked_realloc(const secp256k1_callback* cb, void *ptr, size_t size) {
 100     void *ret = realloc(ptr, size);
 101     if (ret == NULL) {
 102         secp256k1_callback_call(cb, "Out of memory");
 103     }
 104     return ret;
 105 }
 106
 107 #if defined(__BIGGEST_ALIGNMENT__)
 108 #define ALIGNMENT __BIGGEST_ALIGNMENT__
 109 #else
 110 /* Using 16 bytes alignment because common architectures never have alignment
 111  * requirements above 8 for any of the types we care about. In addition we
 112  * leave some room because currently we don't care about a few bytes. */
 113 #define ALIGNMENT 16
 114 #endif
 115
 116 #define ROUND_TO_ALIGN(size) (((size + ALIGNMENT - 1) / ALIGNMENT) * ALIGNMENT)
 117
 118 /* Assume there is a contiguous memory object with bounds [base, base + max_size)
 119  * of which the memory range [base, *prealloc_ptr) is already allocated for usage,
 120  * where *prealloc_ptr is an aligned pointer. In that setting, this functions
 121  * reserves the subobject [*prealloc_ptr, *prealloc_ptr + alloc_size) of
 122  * alloc_size bytes by increasing *prealloc_ptr accordingly, taking into account
 123  * alignment requirements.
 124  *
 125  * The function returns an aligned pointer to the newly allocated subobject.
 126  *
 127  * This is useful for manual memory management: if we're simply given a block
 128  * [base, base + max_size), the caller can use this function to allocate memory
 129  * in this block and keep track of the current allocation state with *prealloc_ptr.
 130  *
 131  * It is VERIFY_CHECKed that there is enough space left in the memory object and
 132  * *prealloc_ptr is aligned relative to base.
 133  */
 134 static SECP256K1_INLINE void *manual_alloc(void** prealloc_ptr, size_t alloc_size, void* base, size_t max_size) {
 135     size_t aligned_alloc_size = ROUND_TO_ALIGN(alloc_size);
 136     void* ret;
 137     VERIFY_CHECK(prealloc_ptr != NULL);
 138     VERIFY_CHECK(*prealloc_ptr != NULL);
 139     VERIFY_CHECK(base != NULL);
 140     VERIFY_CHECK((unsigned char*)*prealloc_ptr >= (unsigned char*)base);
 141     VERIFY_CHECK(((unsigned char*)*prealloc_ptr - (unsigned char*)base) % ALIGNMENT == 0);
 142     VERIFY_CHECK((unsigned char*)*prealloc_ptr - (unsigned char*)base + aligned_alloc_size <= max_size);
 143     ret = *prealloc_ptr;
 144     *((unsigned char**)prealloc_ptr) += aligned_alloc_size;
 145     return ret;
 146 }
 147
 148 /* Macro for restrict, when available and not in a VERIFY build. */
 149 #if defined(SECP256K1_BUILD) && defined(VERIFY)
 150 # define SECP256K1_RESTRICT
 151 #else
 152 # if (!defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L) )
 153 #  if SECP256K1_GNUC_PREREQ(3,0)
 154 #   define SECP256K1_RESTRICT __restrict__
 155 #  elif (defined(_MSC_VER) && _MSC_VER >= 1400)
 156 #   define SECP256K1_RESTRICT __restrict
 157 #  else
 158 #   define SECP256K1_RESTRICT
 159 #  endif
 160 # else
 161 #  define SECP256K1_RESTRICT restrict
 162 # endif
 163 #endif
 164
 165 #if defined(_WIN32)
 166 # define I64FORMAT "I64d"
 167 # define I64uFORMAT "I64u"
 168 #else
 169 # define I64FORMAT "lld"
 170 # define I64uFORMAT "llu"
 171 #endif
 172
 173 #if defined(HAVE___INT128)
 174 # if defined(__GNUC__)
 175 #  define SECP256K1_GNUC_EXT __extension__
 176 # else
 177 #  define SECP256K1_GNUC_EXT
 178 # endif
 179 SECP256K1_GNUC_EXT typedef unsigned __int128 uint128_t;
 180 #endif
 181
 182 #if defined(__BYTE_ORDER__)
 183 # if defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ && !defined(SECP256K1_LITTLE_ENDIAN)
 184 #  define SECP256K1_LITTLE_ENDIAN
 185 # elif defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ && !defined(SECP256K1_BIG_ENDIAN)
 186 #  define SECP256K1_BIG_ENDIAN
 187 # endif
 188 #endif
 189 #if defined(_MSC_VER) && defined(_WIN32) && !defined(SECP256K1_LITTLE_ENDIAN)
 190 # define SECP256K1_LITTLE_ENDIAN
 191 #endif
 192 #if defined(SECP256K1_LITTLE_ENDIAN) == defined(SECP256K1_BIG_ENDIAN)
 193 # error Please make sure that either SECP256K1_LITTLE_ENDIAN or SECP256K1_BIG_ENDIAN is set, see src/util.h.
 194 #endif
 195
 196 /* Zero memory if flag == 1. Flag must be 0 or 1. Constant time. */
 197 static SECP256K1_INLINE void memczero(void *s, size_t len, int flag) {
 198     unsigned char *p = (unsigned char *)s;
 199     /* Access flag with a volatile-qualified lvalue.
 200        This prevents clang from figuring out (after inlining) that flag can
 201        take only be 0 or 1, which leads to variable time code. */
 202     volatile int vflag = flag;
 203     unsigned char mask = -(unsigned char) vflag;
 204     while (len) {
 205         *p &= ~mask;
 206         p++;
 207         len--;
 208     }
 209 }
 210
 211 /** If flag is true, set *r equal to *a; otherwise leave it. Constant-time.  Both *r and *a must be initialized and non-negative.*/
 212 static SECP256K1_INLINE void secp256k1_int_cmov(int *r, const int *a, int flag) {
 213     unsigned int mask0, mask1, r_masked, a_masked;
 214     /* Casting a negative int to unsigned and back to int is implementation defined behavior */
 215     VERIFY_CHECK(*r >= 0 && *a >= 0);
 216
 217     mask0 = (unsigned int)flag + ~0u;
 218     mask1 = ~mask0;
 219     r_masked = ((unsigned int)*r & mask0);
 220     a_masked = ((unsigned int)*a & mask1);
 221
 222     *r = (int)(r_masked | a_masked);
 223 }
 224
 225 #endif /* SECP256K1_UTIL_H */