// allocate.cpp - written and placed in the public domain by Jeffrey Walton

// The functions in allocate.h and allocate.cpp were originally in misc.h

// and misc.cpp. They were extracted in September 2019 to sidestep a circular

// dependency with misc.h and secblock.h.

#include "pch.h"

#include "config.h"

#ifndef CRYPTOPP_IMPORTS

#include "allocate.h"

#include "stdcpp.h"

#include "misc.h"

#include "trap.h"

// for memalign

#if defined(CRYPTOPP_MEMALIGN_AVAILABLE) || defined(CRYPTOPP_MM_MALLOC_AVAILABLE) || defined(QNX)

# include <malloc.h>

#endif

// for posix_memalign

#if defined(CRYPTOPP_POSIX_MEMALIGN_AVAILABLE)

# include <stdlib.h>

#endif

NAMESPACE_BEGIN(CryptoPP)

void CallNewHandler()

{

  std::new_handler newHandler = std::set_new_handler(NULLPTR);

  if (newHandler)

    std::set_new_handler(newHandler);

  if (newHandler)

    newHandler();

  else

    throw std::bad_alloc();

}

void * AlignedAllocate(size_t size)

{

  byte *p;

#if defined(CRYPTOPP_MM_MALLOC_AVAILABLE)

  while ((p = (byte *)_mm_malloc(size, 16)) == NULLPTR)

#elif defined(CRYPTOPP_MEMALIGN_AVAILABLE)

  while ((p = (byte *)memalign(16, size)) == NULLPTR)

#elif defined(CRYPTOPP_MALLOC_ALIGNMENT_IS_16)

  while ((p = (byte *)malloc(size)) == NULLPTR)

#elif defined(CRYPTOPP_POSIX_MEMALIGN_AVAILABLE)

  while (posix_memalign(reinterpret_cast<void**>(&p), 16, size) != 0)

#else

  while ((p = (byte *)malloc(size + 16)) == NULLPTR)

#endif

    CallNewHandler();

#ifdef CRYPTOPP_NO_ALIGNED_ALLOC

  size_t adjustment = 16-((size_t)p%16);

  CRYPTOPP_ASSERT(adjustment > 0);

  p += adjustment;

  p[-1] = (byte)adjustment;

#endif

  // If this assert fires then there are problems that need

  // to be fixed. Please open a bug report.

  CRYPTOPP_ASSERT(IsAlignedOn(p, 16));

  return p;

}

void AlignedDeallocate(void *p)

{

  // Guard pointer due to crash on AIX when CRYPTOPP_NO_ALIGNED_ALLOC

  // is in effect. The guard was previously in place in SecBlock,

  // but it was removed at f4d68353ca7c as part of GH #875.

  CRYPTOPP_ASSERT(p);

  if (p != NULLPTR)

  {

#ifdef CRYPTOPP_MM_MALLOC_AVAILABLE

    _mm_free(p);

#elif defined(CRYPTOPP_NO_ALIGNED_ALLOC)

    p = (byte *)p - ((byte *)p)[-1];

    free(p);

#else

    free(p);

#endif

  }

}

void * UnalignedAllocate(size_t size)

{

  void *p;

  while ((p = malloc(size)) == NULLPTR)

    CallNewHandler();

  return p;

}

void UnalignedDeallocate(void *p)

{

  free(p);

}

NAMESPACE_END

#endif  // CRYPTOPP_IMPORTS