Merge pull request #125 from elichai/manual-memory

Implement pre allocation context creation

depend/secp256k1/include/secp256k1.h

@@ -188,51 +188,6 @@ typedef int (*secp256k1_nonce_function)(
  */
 SECP256K1_API extern const secp256k1_context *secp256k1_context_no_precomp;
 
-/** Create a secp256k1 context object (in dynamically allocated memory).
- *
- * This function uses malloc to allocate memory. It is guaranteed that malloc is
- * called at most once for every call of this function. If you need to avoid dynamic
- * memory allocation entirely, see the functions in secp256k1_preallocated.h.
- *
- * Returns: a newly created context object.
- * In: flags: which parts of the context to initialize.
- *
- * See also secp256k1_context_randomize.
- */
-SECP256K1_API secp256k1_context* secp256k1_context_create(
- unsigned int flags
-) SECP256K1_WARN_UNUSED_RESULT;
-
-/** Copy a secp256k1 context object (into dynamically allocated memory).
- *
- * This function uses malloc to allocate memory. It is guaranteed that malloc is
- * called at most once for every call of this function. If you need to avoid dynamic
- * memory allocation entirely, see the functions in secp256k1_preallocated.h.
- *
- * Returns: a newly created context object.
- * Args: ctx: an existing context to copy (cannot be NULL)
- */
-SECP256K1_API secp256k1_context* secp256k1_context_clone(
- const secp256k1_context* ctx
-) SECP256K1_ARG_NONNULL(1) SECP256K1_WARN_UNUSED_RESULT;
-
-/** Destroy a secp256k1 context object (created in dynamically allocated memory).
- *
- * The context pointer may not be used afterwards.
- *
- * The context to destroy must have been created using secp256k1_context_create
- * or secp256k1_context_clone. If the context has instead been created using
- * secp256k1_context_preallocated_create or secp256k1_context_preallocated_clone, the
- * behaviour is undefined. In that case, secp256k1_context_preallocated_destroy must
- * be used instead.
- *
- * Args: ctx: an existing context to destroy, constructed using
- * secp256k1_context_create or secp256k1_context_clone
- */
-SECP256K1_API void secp256k1_context_destroy(
- secp256k1_context* ctx
-);
-
 /** Set a callback function to be called when an illegal argument is passed to
  * an API call. It will only trigger for violations that are mentioned
  * explicitly in the header.
@@ -301,28 +256,6 @@ SECP256K1_API void secp256k1_context_set_error_callback(
  const void* data
 ) SECP256K1_ARG_NONNULL(1);
 
-/** Create a secp256k1 scratch space object.
- *
- * Returns: a newly created scratch space.
- * Args: ctx: an existing context object (cannot be NULL)
- * In: size: amount of memory to be available as scratch space. Some extra
- * (<100 bytes) will be allocated for extra accounting.
- */
-SECP256K1_API SECP256K1_WARN_UNUSED_RESULT secp256k1_scratch_space* secp256k1_scratch_space_create(
- const secp256k1_context* ctx,
- size_t size
-) SECP256K1_ARG_NONNULL(1);
-
-/** Destroy a secp256k1 scratch space.
- *
- * The pointer may not be used afterwards.
- * Args: ctx: a secp256k1 context object.
- * scratch: space to destroy
- */
-SECP256K1_API void secp256k1_scratch_space_destroy(
- const secp256k1_context* ctx,
- secp256k1_scratch_space* scratch
-) SECP256K1_ARG_NONNULL(1);
 
 /** Parse a variable-length public key into the pubkey object.
  *

depend/secp256k1/src/scratch.h

@@ -21,9 +21,7 @@ typedef struct secp256k1_scratch_space_struct {
  size_t max_size;
 } secp256k1_scratch;
 
-static secp256k1_scratch* secp256k1_scratch_create(const secp256k1_callback* error_callback, size_t max_size);
 
-static void secp256k1_scratch_destroy(const secp256k1_callback* error_callback, secp256k1_scratch* scratch);
 
 /** Returns an opaque object used to "checkpoint" a scratch space. Used
  * with `secp256k1_scratch_apply_checkpoint` to undo allocations. */

depend/secp256k1/src/scratch_impl.h

@@ -10,31 +10,6 @@
 #include "util.h"
 #include "scratch.h"
 
-static secp256k1_scratch* secp256k1_scratch_create(const secp256k1_callback* error_callback, size_t size) {
- const size_t base_alloc = ((sizeof(secp256k1_scratch) + ALIGNMENT - 1) / ALIGNMENT) * ALIGNMENT;
- void *alloc = checked_malloc(error_callback, base_alloc + size);
- secp256k1_scratch* ret = (secp256k1_scratch *)alloc;
- if (ret != NULL) {
- memset(ret, 0, sizeof(*ret));
- memcpy(ret->magic, "scratch", 8);
- ret->data = (void *) ((char *) alloc + base_alloc);
- ret->max_size = size;
- }
- return ret;
-}
-
-static void secp256k1_scratch_destroy(const secp256k1_callback* error_callback, secp256k1_scratch* scratch) {
- if (scratch != NULL) {
- VERIFY_CHECK(scratch->alloc_size == 0); /* all checkpoints should be applied */
- if (memcmp(scratch->magic, "scratch", 8) != 0) {
- secp256k1_callback_call(error_callback, "invalid scratch space");
- return;
- }
- memset(scratch->magic, 0, sizeof(scratch->magic));
- free(scratch);
- }
-}
-
 static size_t secp256k1_scratch_checkpoint(const secp256k1_callback* error_callback, const secp256k1_scratch* scratch) {
  if (memcmp(scratch->magic, "scratch", 8) != 0) {
  secp256k1_callback_call(error_callback, "invalid scratch space");

depend/secp256k1/src/secp256k1.c

@@ -136,17 +136,6 @@ secp256k1_context* secp256k1_context_preallocated_create(void* prealloc, unsigne
  return (secp256k1_context*) ret;
 }
 
-secp256k1_context* secp256k1_context_create(unsigned int flags) {
- size_t const prealloc_size = secp256k1_context_preallocated_size(flags);
- secp256k1_context* ctx = (secp256k1_context*)checked_malloc(&default_error_callback, prealloc_size);
- if (EXPECT(secp256k1_context_preallocated_create(ctx, flags) == NULL, 0)) {
- free(ctx);
- return NULL;
- }
-
- return ctx;
-}
-
 secp256k1_context* secp256k1_context_preallocated_clone(const secp256k1_context* ctx, void* prealloc) {
  size_t prealloc_size;
  secp256k1_context* ret;
@@ -161,17 +150,6 @@ secp256k1_context* secp256k1_context_preallocated_clone(const secp256k1_context*
  return ret;
 }
 
-secp256k1_context* secp256k1_context_clone(const secp256k1_context* ctx) {
- secp256k1_context* ret;
- size_t prealloc_size;
-
- VERIFY_CHECK(ctx != NULL);
- prealloc_size = secp256k1_context_preallocated_clone_size(ctx);
- ret = (secp256k1_context*)checked_malloc(&ctx->error_callback, prealloc_size);
- ret = secp256k1_context_preallocated_clone(ctx, ret);
- return ret;
-}
-
 void secp256k1_context_preallocated_destroy(secp256k1_context* ctx) {
  ARG_CHECK_NO_RETURN(ctx != secp256k1_context_no_precomp);
  if (ctx != NULL) {
@@ -180,13 +158,6 @@ void secp256k1_context_preallocated_destroy(secp256k1_context* ctx) {
  }
 }
 
-void secp256k1_context_destroy(secp256k1_context* ctx) {
- if (ctx != NULL) {
- secp256k1_context_preallocated_destroy(ctx);
- free(ctx);
- }
-}
-
 void secp256k1_context_set_illegal_callback(secp256k1_context* ctx, void (*fun)(const char* message, void* data), const void* data) {
  ARG_CHECK_NO_RETURN(ctx != secp256k1_context_no_precomp);
  if (fun == NULL) {
@@ -205,16 +176,6 @@ void secp256k1_context_set_error_callback(secp256k1_context* ctx, void (*fun)(co
  ctx->error_callback.data = data;
 }
 
-secp256k1_scratch_space* secp256k1_scratch_space_create(const secp256k1_context* ctx, size_t max_size) {
- VERIFY_CHECK(ctx != NULL);
- return secp256k1_scratch_create(&ctx->error_callback, max_size);
-}
-
-void secp256k1_scratch_space_destroy(const secp256k1_context *ctx, secp256k1_scratch_space* scratch) {
- VERIFY_CHECK(ctx != NULL);
- secp256k1_scratch_destroy(&ctx->error_callback, scratch);
-}
-
 static int secp256k1_pubkey_load(const secp256k1_context* ctx, secp256k1_ge* ge, const secp256k1_pubkey* pubkey) {
  if (sizeof(secp256k1_ge_storage) == 64) {
  /* When the secp256k1_ge_storage type is exactly 64 byte, use its

depend/secp256k1/src/util.h

@@ -68,22 +68,6 @@ static SECP256K1_INLINE void secp256k1_callback_call(const secp256k1_callback *
 #define VERIFY_SETUP(stmt)
 #endif
 
-static SECP256K1_INLINE void *checked_malloc(const secp256k1_callback* cb, size_t size) {
- void *ret = malloc(size);
- if (ret == NULL) {
- secp256k1_callback_call(cb, "Out of memory");
- }
- return ret;
-}
-
-static SECP256K1_INLINE void *checked_realloc(const secp256k1_callback* cb, void *ptr, size_t size) {
- void *ret = realloc(ptr, size);
- if (ret == NULL) {
- secp256k1_callback_call(cb, "Out of memory");
- }
- return ret;
-}
-
 #if defined(__BIGGEST_ALIGNMENT__)
 #define ALIGNMENT __BIGGEST_ALIGNMENT__
 #else