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
  18 typedef struct {
  19     void (*fn)(const char *text, void* data);
  20     const void* data;
  21 } secp256k1_callback;
  22
  23 static SECP256K1_INLINE void secp256k1_callback_call(const secp256k1_callback * const cb, const char * const text) {
  24     cb->fn(text, (void*)cb->data);
  25 }
  26
  27 #ifdef DETERMINISTIC
  28 #define TEST_FAILURE(msg) do { \
  29     fprintf(stderr, "%s\n", msg); \
  30     abort(); \
  31 } while(0);
  32 #else
  33 #define TEST_FAILURE(msg) do { \
  34     fprintf(stderr, "%s:%d: %s\n", __FILE__, __LINE__, msg); \
  35     abort(); \
  36 } while(0)
  37 #endif
  38
  39 #if SECP256K1_GNUC_PREREQ(3, 0)
  40 #define EXPECT(x,c) __builtin_expect((x),(c))
  41 #else
  42 #define EXPECT(x,c) (x)
  43 #endif
  44
  45 #ifdef DETERMINISTIC
  46 #define CHECK(cond) do { \
  47     if (EXPECT(!(cond), 0)) { \
  48         TEST_FAILURE("test condition failed"); \
  49     } \
  50 } while(0)
  51 #else
  52 #define CHECK(cond) do { \
  53     if (EXPECT(!(cond), 0)) { \
  54         TEST_FAILURE("test condition failed: " #cond); \
  55     } \
  56 } while(0)
  57 #endif
  58
  59 /* Like assert(), but when VERIFY is defined, and side-effect safe. */
  60 #if defined(COVERAGE)
  61 #define VERIFY_CHECK(check)
  62 #define VERIFY_SETUP(stmt)
  63 #elif defined(VERIFY)
  64 #define VERIFY_CHECK CHECK
  65 #define VERIFY_SETUP(stmt) do { stmt; } while(0)
  66 #else
  67 #define VERIFY_CHECK(cond) do { (void)(cond); } while(0)
  68 #define VERIFY_SETUP(stmt)
  69 #endif
  70
  71 static SECP256K1_INLINE void *checked_malloc(const secp256k1_callback* cb, size_t size) {
  72     void *ret = malloc(size);
  73     if (ret == NULL) {
  74         secp256k1_callback_call(cb, "Out of memory");
  75     }
  76     return ret;
  77 }
  78
  79 static SECP256K1_INLINE void *checked_realloc(const secp256k1_callback* cb, void *ptr, size_t size) {
  80     void *ret = realloc(ptr, size);
  81     if (ret == NULL) {
  82         secp256k1_callback_call(cb, "Out of memory");
  83     }
  84     return ret;
  85 }
  86
  87 #if defined(__BIGGEST_ALIGNMENT__)
  88 #define ALIGNMENT __BIGGEST_ALIGNMENT__
  89 #else
  90 /* Using 16 bytes alignment because common architectures never have alignment
  91  * requirements above 8 for any of the types we care about. In addition we
  92  * leave some room because currently we don't care about a few bytes. */
  93 #define ALIGNMENT 16
  94 #endif
  95
  96 #define ROUND_TO_ALIGN(size) (((size + ALIGNMENT - 1) / ALIGNMENT) * ALIGNMENT)
  97
  98 /* Assume there is a contiguous memory object with bounds [base, base + max_size)
  99  * of which the memory range [base, *prealloc_ptr) is already allocated for usage,
 100  * where *prealloc_ptr is an aligned pointer. In that setting, this functions
 101  * reserves the subobject [*prealloc_ptr, *prealloc_ptr + alloc_size) of
 102  * alloc_size bytes by increasing *prealloc_ptr accordingly, taking into account
 103  * alignment requirements.
 104  *
 105  * The function returns an aligned pointer to the newly allocated subobject.
 106  *
 107  * This is useful for manual memory management: if we're simply given a block
 108  * [base, base + max_size), the caller can use this function to allocate memory
 109  * in this block and keep track of the current allocation state with *prealloc_ptr.
 110  *
 111  * It is VERIFY_CHECKed that there is enough space left in the memory object and
 112  * *prealloc_ptr is aligned relative to base.
 113  */
 114 static SECP256K1_INLINE void *manual_alloc(void** prealloc_ptr, size_t alloc_size, void* base, size_t max_size) {
 115     size_t aligned_alloc_size = ROUND_TO_ALIGN(alloc_size);
 116     void* ret;
 117     VERIFY_CHECK(prealloc_ptr != NULL);
 118     VERIFY_CHECK(*prealloc_ptr != NULL);
 119     VERIFY_CHECK(base != NULL);
 120     VERIFY_CHECK((unsigned char*)*prealloc_ptr >= (unsigned char*)base);
 121     VERIFY_CHECK(((unsigned char*)*prealloc_ptr - (unsigned char*)base) % ALIGNMENT == 0);
 122     VERIFY_CHECK((unsigned char*)*prealloc_ptr - (unsigned char*)base + aligned_alloc_size <= max_size);
 123     ret = *prealloc_ptr;
 124     *((unsigned char**)prealloc_ptr) += aligned_alloc_size;
 125     return ret;
 126 }
 127
 128 /* Macro for restrict, when available and not in a VERIFY build. */
 129 #if defined(SECP256K1_BUILD) && defined(VERIFY)
 130 # define SECP256K1_RESTRICT
 131 #else
 132 # if (!defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L) )
 133 #  if SECP256K1_GNUC_PREREQ(3,0)
 134 #   define SECP256K1_RESTRICT __restrict__
 135 #  elif (defined(_MSC_VER) && _MSC_VER >= 1400)
 136 #   define SECP256K1_RESTRICT __restrict
 137 #  else
 138 #   define SECP256K1_RESTRICT
 139 #  endif
 140 # else
 141 #  define SECP256K1_RESTRICT restrict
 142 # endif
 143 #endif
 144
 145 #if defined(_WIN32)
 146 # define I64FORMAT "I64d"
 147 # define I64uFORMAT "I64u"
 148 #else
 149 # define I64FORMAT "lld"
 150 # define I64uFORMAT "llu"
 151 #endif
 152
 153 #if defined(HAVE___INT128)
 154 # if defined(__GNUC__)
 155 #  define SECP256K1_GNUC_EXT __extension__
 156 # else
 157 #  define SECP256K1_GNUC_EXT
 158 # endif
 159 SECP256K1_GNUC_EXT typedef unsigned __int128 uint128_t;
 160 #endif
 161
 162 #endif /* SECP256K1_UTIL_H */