mirror of
https://github.com/shadps4-emu/ext-cryptopp.git
synced 2024-11-23 09:59:42 +00:00
105 lines
2.4 KiB
C++
105 lines
2.4 KiB
C++
// 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
|