/*

** 2001 September 15

**

** The author disclaims copyright to this source code. In place of

** a legal notice, here is a blessing:

**

** May you do good and not evil.

** May you find forgiveness for yourself and forgive others.

** May you share freely, never taking more than you give.

**

*************************************************************************

**

** Memory allocation functions used throughout sqlite.

*/

#include "sqliteInt.h"

#include <stdarg.h>

/*

** Attempt to release up to n bytes of non-essential memory currently

** held by SQLite. An example of non-essential memory is memory used to

** cache database pages that are not currently in use.

*/

int sqlite3_release_memory(int n){

#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

return sqlite3PcacheReleaseMemory(n);

#else

/* IMPLEMENTATION-OF: R-34391-24921 The sqlite3_release_memory() routine

** is a no-op returning zero if SQLite is not compiled with

** SQLITE_ENABLE_MEMORY_MANAGEMENT. */

UNUSED_PARAMETER(n);

return 0;

#endif

}

/*

** Default value of the hard heap limit. 0 means "no limit".

*/

#ifndef SQLITE_MAX_MEMORY

# define SQLITE_MAX_MEMORY 0

#endif

/*

** State information local to the memory allocation subsystem.

*/

static SQLITE_WSD struct Mem0Global {

sqlite3_mutex *mutex; /* Mutex to serialize access */

sqlite3_int64 alarmThreshold; /* The soft heap limit */

sqlite3_int64 hardLimit; /* The hard upper bound on memory */

/*

** True if heap is nearly "full" where "full" is defined by the

** sqlite3_soft_heap_limit() setting.

*/

int nearlyFull;

} mem0 = { 0, SQLITE_MAX_MEMORY, SQLITE_MAX_MEMORY, 0 };

#define mem0 GLOBAL(struct Mem0Global, mem0)

/*

** Return the memory allocator mutex. sqlite3_status() needs it.

*/

sqlite3_mutex *sqlite3MallocMutex(void){

return mem0.mutex;

}

#ifndef SQLITE_OMIT_DEPRECATED

/*

** Deprecated external interface. It used to set an alarm callback

** that was invoked when memory usage grew too large. Now it is a

** no-op.

*/

int sqlite3_memory_alarm(

void(*xCallback)(void *pArg, sqlite3_int64 used,int N),

void *pArg,

sqlite3_int64 iThreshold

){

(void)xCallback;

(void)pArg;

(void)iThreshold;

return SQLITE_OK;

}

#endif

/*

** Set the soft heap-size limit for the library. An argument of

** zero disables the limit. A negative argument is a no-op used to

** obtain the return value.

**

** The return value is the value of the heap limit just before this

** interface was called.

**

** If the hard heap limit is enabled, then the soft heap limit cannot

** be disabled nor raised above the hard heap limit.

*/

sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 n){

sqlite3_int64 priorLimit;

sqlite3_int64 excess;

sqlite3_int64 nUsed;

#ifndef SQLITE_OMIT_AUTOINIT

int rc = sqlite3_initialize();

if( rc ) return -1;

#endif

sqlite3_mutex_enter(mem0.mutex);

priorLimit = mem0.alarmThreshold;

if( n<0 ){

sqlite3_mutex_leave(mem0.mutex);

return priorLimit;

}

if( mem0.hardLimit>0 && (n>mem0.hardLimit || n==0) ){

n = mem0.hardLimit;

}

mem0.alarmThreshold = n;

nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);

AtomicStore(&mem0.nearlyFull, n>0 && n<=nUsed);

sqlite3_mutex_leave(mem0.mutex);

excess = sqlite3_memory_used() - n;

if( excess>0 ) sqlite3_release_memory((int)(excess & 0x7fffffff));

return priorLimit;

}

void sqlite3_soft_heap_limit(int n){

if( n<0 ) n = 0;

sqlite3_soft_heap_limit64(n);

}

/*

** Set the hard heap-size limit for the library. An argument of zero

** disables the hard heap limit. A negative argument is a no-op used

** to obtain the return value without affecting the hard heap limit.

**

** The return value is the value of the hard heap limit just prior to

** calling this interface.

**

** Setting the hard heap limit will also activate the soft heap limit

** and constrain the soft heap limit to be no more than the hard heap

** limit.

*/

sqlite3_int64 sqlite3_hard_heap_limit64(sqlite3_int64 n){

sqlite3_int64 priorLimit;

#ifndef SQLITE_OMIT_AUTOINIT

int rc = sqlite3_initialize();

if( rc ) return -1;

#endif

sqlite3_mutex_enter(mem0.mutex);

priorLimit = mem0.hardLimit;

if( n>=0 ){

mem0.hardLimit = n;

if( n<mem0.alarmThreshold || mem0.alarmThreshold==0 ){

mem0.alarmThreshold = n;

}

}

sqlite3_mutex_leave(mem0.mutex);

return priorLimit;

}

/*

** Initialize the memory allocation subsystem.

*/

int sqlite3MallocInit(void){

int rc;

if( sqlite3GlobalConfig.m.xMalloc==0 ){

sqlite3MemSetDefault();

}

mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);

if( sqlite3GlobalConfig.pPage==0 || sqlite3GlobalConfig.szPage<512

|| sqlite3GlobalConfig.nPage<=0 ){

sqlite3GlobalConfig.pPage = 0;

sqlite3GlobalConfig.szPage = 0;

}

rc = sqlite3GlobalConfig.m.xInit(sqlite3GlobalConfig.m.pAppData);

if( rc!=SQLITE_OK ) memset(&mem0, 0, sizeof(mem0));

/* BEGIN SQLCIPHER */

#ifdef SQLITE_HAS_CODEC

/* install wrapping functions for memory management

that will wipe all memory allocated by SQLite

when freed */

if( rc==SQLITE_OK ) {

extern void sqlcipher_init_memmethods(void);

sqlcipher_init_memmethods();

}

#endif

/* END SQLCIPHER */

return rc;

}

/*

** Return true if the heap is currently under memory pressure - in other

** words if the amount of heap used is close to the limit set by

** sqlite3_soft_heap_limit().

*/

int sqlite3HeapNearlyFull(void){

return AtomicLoad(&mem0.nearlyFull);

}

/*

** Deinitialize the memory allocation subsystem.

*/

void sqlite3MallocEnd(void){

if( sqlite3GlobalConfig.m.xShutdown ){

sqlite3GlobalConfig.m.xShutdown(sqlite3GlobalConfig.m.pAppData);

}

memset(&mem0, 0, sizeof(mem0));

}

/*

** Return the amount of memory currently checked out.

*/

sqlite3_int64 sqlite3_memory_used(void){

sqlite3_int64 res, mx;

sqlite3_status64(SQLITE_STATUS_MEMORY_USED, &res, &mx, 0);

return res;

}

/*

** Return the maximum amount of memory that has ever been

** checked out since either the beginning of this process

** or since the most recent reset.

*/

sqlite3_int64 sqlite3_memory_highwater(int resetFlag){

sqlite3_int64 res, mx;

sqlite3_status64(SQLITE_STATUS_MEMORY_USED, &res, &mx, resetFlag);

return mx;

}

/*

** Trigger the alarm

*/

static void sqlite3MallocAlarm(int nByte){

if( mem0.alarmThreshold<=0 ) return;

sqlite3_mutex_leave(mem0.mutex);

sqlite3_release_memory(nByte);

sqlite3_mutex_enter(mem0.mutex);

}

/*

** Do a memory allocation with statistics and alarms. Assume the

** lock is already held.

*/

static void mallocWithAlarm(int n, void **pp){

void *p;

int nFull;

assert( sqlite3_mutex_held(mem0.mutex) );

assert( n>0 );

/* In Firefox (circa 2017-02-08), xRoundup() is remapped to an internal

** implementation of malloc_good_size(), which must be called in debug

** mode and specifically when the DMD "Dark Matter Detector" is enabled

** or else a crash results. Hence, do not attempt to optimize out the

** following xRoundup() call. */

nFull = sqlite3GlobalConfig.m.xRoundup(n);

sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, n);

if( mem0.alarmThreshold>0 ){

sqlite3_int64 nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);

if( nUsed >= mem0.alarmThreshold - nFull ){

AtomicStore(&mem0.nearlyFull, 1);

sqlite3MallocAlarm(nFull);

if( mem0.hardLimit ){

nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);

if( nUsed >= mem0.hardLimit - nFull ){

*pp = 0;

return;

}

}

}else{

AtomicStore(&mem0.nearlyFull, 0);

}

}

p = sqlite3GlobalConfig.m.xMalloc(nFull);

#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

if( p==0 && mem0.alarmThreshold>0 ){

sqlite3MallocAlarm(nFull);

p = sqlite3GlobalConfig.m.xMalloc(nFull);

}

#endif

if( p ){

nFull = sqlite3MallocSize(p);

sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nFull);

sqlite3StatusUp(SQLITE_STATUS_MALLOC_COUNT, 1);

}

*pp = p;

}

/*

** Allocate memory. This routine is like sqlite3_malloc() except that it

** assumes the memory subsystem has already been initialized.

*/

void *sqlite3Malloc(u64 n){

void *p;

if( n==0 || n>=0x7fffff00 ){

/* A memory allocation of a number of bytes which is near the maximum

** signed integer value might cause an integer overflow inside of the

** xMalloc(). Hence we limit the maximum size to 0x7fffff00, giving

** 255 bytes of overhead. SQLite itself will never use anything near

** this amount. The only way to reach the limit is with sqlite3_malloc() */

p = 0;

}else if( sqlite3GlobalConfig.bMemstat ){

sqlite3_mutex_enter(mem0.mutex);

mallocWithAlarm((int)n, &p);

sqlite3_mutex_leave(mem0.mutex);

}else{

p = sqlite3GlobalConfig.m.xMalloc((int)n);

}

assert( EIGHT_BYTE_ALIGNMENT(p) ); /* IMP: R-11148-40995 */

return p;

}

/*

** This version of the memory allocation is for use by the application.

** First make sure the memory subsystem is initialized, then do the

** allocation.

*/

void *sqlite3_malloc(int n){

#ifndef SQLITE_OMIT_AUTOINIT

if( sqlite3_initialize() ) return 0;

#endif

return n<=0 ? 0 : sqlite3Malloc(n);

}

void *sqlite3_malloc64(sqlite3_uint64 n){

#ifndef SQLITE_OMIT_AUTOINIT

if( sqlite3_initialize() ) return 0;

#endif

return sqlite3Malloc(n);

}

/*

** TRUE if p is a lookaside memory allocation from db

*/

#ifndef SQLITE_OMIT_LOOKASIDE

static int isLookaside(sqlite3 *db, const void *p){

return SQLITE_WITHIN(p, db->lookaside.pStart, db->lookaside.pEnd);

}

#else

#define isLookaside(A,B) 0

#endif

/*

** Return the size of a memory allocation previously obtained from

** sqlite3Malloc() or sqlite3_malloc().

*/

int sqlite3MallocSize(const void *p){

assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );

return sqlite3GlobalConfig.m.xSize((void*)p);

}

static int lookasideMallocSize(sqlite3 *db, const void *p){

#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE

return p<db->lookaside.pMiddle ? db->lookaside.szTrue : LOOKASIDE_SMALL;

#else

return db->lookaside.szTrue;

#endif

}

int sqlite3DbMallocSize(sqlite3 *db, const void *p){

assert( p!=0 );

#ifdef SQLITE_DEBUG

if( db==0 || !isLookaside(db,p) ){

if( db==0 ){

assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );

assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );

}else{

assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );

assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );

}

}

#endif

if( db ){

if( ((uptr)p)<(uptr)(db->lookaside.pEnd) ){

#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE

if( ((uptr)p)>=(uptr)(db->lookaside.pMiddle) ){

assert( sqlite3_mutex_held(db->mutex) );

return LOOKASIDE_SMALL;

}

#endif

if( ((uptr)p)>=(uptr)(db->lookaside.pStart) ){

assert( sqlite3_mutex_held(db->mutex) );

return db->lookaside.szTrue;

}

}

}

return sqlite3GlobalConfig.m.xSize((void*)p);

}

sqlite3_uint64 sqlite3_msize(void *p){

assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );

assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );

return p ? sqlite3GlobalConfig.m.xSize(p) : 0;

}

/*

** Free memory previously obtained from sqlite3Malloc().

*/

void sqlite3_free(void *p){

if( p==0 ) return; /* IMP: R-49053-54554 */

assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );

assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );

if( sqlite3GlobalConfig.bMemstat ){

sqlite3_mutex_enter(mem0.mutex);

sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED, sqlite3MallocSize(p));

sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1);

sqlite3GlobalConfig.m.xFree(p);

sqlite3_mutex_leave(mem0.mutex);

}else{

sqlite3GlobalConfig.m.xFree(p);

}

}

/*

** Add the size of memory allocation "p" to the count in

** *db->pnBytesFreed.

*/

static SQLITE_NOINLINE void measureAllocationSize(sqlite3 *db, void *p){

*db->pnBytesFreed += sqlite3DbMallocSize(db,p);

}

/*

** Free memory that might be associated with a particular database

** connection. Calling sqlite3DbFree(D,X) for X==0 is a harmless no-op.

** The sqlite3DbFreeNN(D,X) version requires that X be non-NULL.

*/

void sqlite3DbFreeNN(sqlite3 *db, void *p){

assert( db==0 || sqlite3_mutex_held(db->mutex) );

assert( p!=0 );

if( db ){

if( db->pnBytesFreed ){

measureAllocationSize(db, p);

return;

}

if( ((uptr)p)<(uptr)(db->lookaside.pEnd) ){

#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE

if( ((uptr)p)>=(uptr)(db->lookaside.pMiddle) ){

LookasideSlot *pBuf = (LookasideSlot*)p;

#ifdef SQLITE_DEBUG

memset(p, 0xaa, LOOKASIDE_SMALL); /* Trash freed content */

#endif

pBuf->pNext = db->lookaside.pSmallFree;

db->lookaside.pSmallFree = pBuf;

return;

}

#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */

if( ((uptr)p)>=(uptr)(db->lookaside.pStart) ){

LookasideSlot *pBuf = (LookasideSlot*)p;

#ifdef SQLITE_DEBUG

memset(p, 0xaa, db->lookaside.szTrue); /* Trash freed content */

#endif

pBuf->pNext = db->lookaside.pFree;

db->lookaside.pFree = pBuf;

return;

}

}

}

assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );

assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );

assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );

sqlite3MemdebugSetType(p, MEMTYPE_HEAP);

sqlite3_free(p);

}

void sqlite3DbFree(sqlite3 *db, void *p){

assert( db==0 || sqlite3_mutex_held(db->mutex) );

if( p ) sqlite3DbFreeNN(db, p);

}

/*

** Change the size of an existing memory allocation

*/

void *sqlite3Realloc(void *pOld, u64 nBytes){

int nOld, nNew, nDiff;

void *pNew;

assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) );

assert( sqlite3MemdebugNoType(pOld, (u8)~MEMTYPE_HEAP) );

if( pOld==0 ){

return sqlite3Malloc(nBytes); /* IMP: R-04300-56712 */

}

if( nBytes==0 ){

sqlite3_free(pOld); /* IMP: R-26507-47431 */

return 0;

}

if( nBytes>=0x7fffff00 ){

/* The 0x7ffff00 limit term is explained in comments on sqlite3Malloc() */

return 0;

}

nOld = sqlite3MallocSize(pOld);

/* IMPLEMENTATION-OF: R-46199-30249 SQLite guarantees that the second

** argument to xRealloc is always a value returned by a prior call to

** xRoundup. */

nNew = sqlite3GlobalConfig.m.xRoundup((int)nBytes);

if( nOld==nNew ){

pNew = pOld;

}else if( sqlite3GlobalConfig.bMemstat ){

sqlite3_int64 nUsed;

sqlite3_mutex_enter(mem0.mutex);

sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, (int)nBytes);

nDiff = nNew - nOld;

if( nDiff>0 && (nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED)) >=

mem0.alarmThreshold-nDiff ){

sqlite3MallocAlarm(nDiff);

if( mem0.hardLimit>0 && nUsed >= mem0.hardLimit - nDiff ){

sqlite3_mutex_leave(mem0.mutex);

return 0;

}

}

pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);

#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

if( pNew==0 && mem0.alarmThreshold>0 ){

sqlite3MallocAlarm((int)nBytes);

pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);

}

#endif

if( pNew ){

nNew = sqlite3MallocSize(pNew);

sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nNew-nOld);

}

sqlite3_mutex_leave(mem0.mutex);

}else{

pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);

}

assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-11148-40995 */

return pNew;

}

/*

** The public interface to sqlite3Realloc. Make sure that the memory

** subsystem is initialized prior to invoking sqliteRealloc.

*/

void *sqlite3_realloc(void *pOld, int n){

#ifndef SQLITE_OMIT_AUTOINIT

if( sqlite3_initialize() ) return 0;

#endif

if( n<0 ) n = 0; /* IMP: R-26507-47431 */

return sqlite3Realloc(pOld, n);

}

void *sqlite3_realloc64(void *pOld, sqlite3_uint64 n){

#ifndef SQLITE_OMIT_AUTOINIT

if( sqlite3_initialize() ) return 0;

#endif

return sqlite3Realloc(pOld, n);

}

/*

** Allocate and zero memory.

*/

void *sqlite3MallocZero(u64 n){

void *p = sqlite3Malloc(n);

if( p ){

memset(p, 0, (size_t)n);

}

return p;

}

/*

** Allocate and zero memory. If the allocation fails, make

** the mallocFailed flag in the connection pointer.

*/

void *sqlite3DbMallocZero(sqlite3 *db, u64 n){

void *p;

testcase( db==0 );

p = sqlite3DbMallocRaw(db, n);

if( p ) memset(p, 0, (size_t)n);

return p;

}

/* Finish the work of sqlite3DbMallocRawNN for the unusual and

** slower case when the allocation cannot be fulfilled using lookaside.

*/

static SQLITE_NOINLINE void *dbMallocRawFinish(sqlite3 *db, u64 n){

void *p;

assert( db!=0 );

p = sqlite3Malloc(n);

if( !p ) sqlite3OomFault(db);

sqlite3MemdebugSetType(p,

(db->lookaside.bDisable==0) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP);

return p;

}

/*

** Allocate memory, either lookaside (if possible) or heap.

** If the allocation fails, set the mallocFailed flag in

** the connection pointer.

**

** If db!=0 and db->mallocFailed is true (indicating a prior malloc

** failure on the same database connection) then always return 0.

** Hence for a particular database connection, once malloc starts

** failing, it fails consistently until mallocFailed is reset.

** This is an important assumption. There are many places in the

** code that do things like this:

**

** int *a = (int*)sqlite3DbMallocRaw(db, 100);

** int *b = (int*)sqlite3DbMallocRaw(db, 200);

** if( b ) a[10] = 9;

**

** In other words, if a subsequent malloc (ex: "b") worked, it is assumed

** that all prior mallocs (ex: "a") worked too.

**

** The sqlite3MallocRawNN() variant guarantees that the "db" parameter is

** not a NULL pointer.

*/

void *sqlite3DbMallocRaw(sqlite3 *db, u64 n){

void *p;

if( db ) return sqlite3DbMallocRawNN(db, n);

p = sqlite3Malloc(n);

sqlite3MemdebugSetType(p, MEMTYPE_HEAP);

return p;

}

void *sqlite3DbMallocRawNN(sqlite3 *db, u64 n){

#ifndef SQLITE_OMIT_LOOKASIDE

LookasideSlot *pBuf;

assert( db!=0 );

assert( sqlite3_mutex_held(db->mutex) );

assert( db->pnBytesFreed==0 );

if( n>db->lookaside.sz ){

if( !db->lookaside.bDisable ){

db->lookaside.anStat[1]++;

}else if( db->mallocFailed ){

return 0;

}

return dbMallocRawFinish(db, n);

}

#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE

if( n<=LOOKASIDE_SMALL ){

if( (pBuf = db->lookaside.pSmallFree)!=0 ){

db->lookaside.pSmallFree = pBuf->pNext;

db->lookaside.anStat[0]++;

return (void*)pBuf;

}else if( (pBuf = db->lookaside.pSmallInit)!=0 ){

db->lookaside.pSmallInit = pBuf->pNext;

db->lookaside.anStat[0]++;

return (void*)pBuf;

}

}

#endif

if( (pBuf = db->lookaside.pFree)!=0 ){

db->lookaside.pFree = pBuf->pNext;

db->lookaside.anStat[0]++;

return (void*)pBuf;

}else if( (pBuf = db->lookaside.pInit)!=0 ){

db->lookaside.pInit = pBuf->pNext;

db->lookaside.anStat[0]++;

return (void*)pBuf;

}else{

db->lookaside.anStat[2]++;

}

#else

assert( db!=0 );

assert( sqlite3_mutex_held(db->mutex) );

assert( db->pnBytesFreed==0 );

if( db->mallocFailed ){

return 0;

}

#endif

return dbMallocRawFinish(db, n);

}

/* Forward declaration */

static SQLITE_NOINLINE void *dbReallocFinish(sqlite3 *db, void *p, u64 n);

/*

** Resize the block of memory pointed to by p to n bytes. If the

** resize fails, set the mallocFailed flag in the connection object.

*/

void *sqlite3DbRealloc(sqlite3 *db, void *p, u64 n){

assert( db!=0 );

if( p==0 ) return sqlite3DbMallocRawNN(db, n);

assert( sqlite3_mutex_held(db->mutex) );

if( ((uptr)p)<(uptr)db->lookaside.pEnd ){

#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE

if( ((uptr)p)>=(uptr)db->lookaside.pMiddle ){

if( n<=LOOKASIDE_SMALL ) return p;

}else

#endif

if( ((uptr)p)>=(uptr)db->lookaside.pStart ){

if( n<=db->lookaside.szTrue ) return p;

}

}

return dbReallocFinish(db, p, n);

}

static SQLITE_NOINLINE void *dbReallocFinish(sqlite3 *db, void *p, u64 n){

void *pNew = 0;

assert( db!=0 );

assert( p!=0 );

if( db->mallocFailed==0 ){

if( isLookaside(db, p) ){

pNew = sqlite3DbMallocRawNN(db, n);

if( pNew ){

memcpy(pNew, p, lookasideMallocSize(db, p));

sqlite3DbFree(db, p);

}

}else{

assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );

assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );

sqlite3MemdebugSetType(p, MEMTYPE_HEAP);

pNew = sqlite3Realloc(p, n);

if( !pNew ){

sqlite3OomFault(db);

}

sqlite3MemdebugSetType(pNew,

(db->lookaside.bDisable==0 ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));

}

}

return pNew;

}

/*

** Attempt to reallocate p. If the reallocation fails, then free p

** and set the mallocFailed flag in the database connection.

*/

void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, u64 n){

void *pNew;

pNew = sqlite3DbRealloc(db, p, n);

if( !pNew ){

sqlite3DbFree(db, p);

}

return pNew;

}

/*

** Make a copy of a string in memory obtained from sqliteMalloc(). These

** functions call sqlite3MallocRaw() directly instead of sqliteMalloc(). This

** is because when memory debugging is turned on, these two functions are

** called via macros that record the current file and line number in the

** ThreadData structure.

*/

char *sqlite3DbStrDup(sqlite3 *db, const char *z){

char *zNew;

size_t n;

if( z==0 ){

return 0;

}

n = strlen(z) + 1;

zNew = sqlite3DbMallocRaw(db, n);

if( zNew ){

memcpy(zNew, z, n);

}

return zNew;

}

char *sqlite3DbStrNDup(sqlite3 *db, const char *z, u64 n){

char *zNew;

assert( db!=0 );

assert( z!=0 || n==0 );

assert( (n&0x7fffffff)==n );

zNew = z ? sqlite3DbMallocRawNN(db, n+1) : 0;

if( zNew ){

memcpy(zNew, z, (size_t)n);

zNew[n] = 0;

}

return zNew;

}

/*

** The text between zStart and zEnd represents a phrase within a larger

** SQL statement. Make a copy of this phrase in space obtained form

** sqlite3DbMalloc(). Omit leading and trailing whitespace.

*/

char *sqlite3DbSpanDup(sqlite3 *db, const char *zStart, const char *zEnd){

int n;

while( sqlite3Isspace(zStart[0]) ) zStart++;

n = (int)(zEnd - zStart);

while( ALWAYS(n>0) && sqlite3Isspace(zStart[n-1]) ) n--;

return sqlite3DbStrNDup(db, zStart, n);

}

/*

** Free any prior content in *pz and replace it with a copy of zNew.

*/

void sqlite3SetString(char **pz, sqlite3 *db, const char *zNew){

char *z = sqlite3DbStrDup(db, zNew);

sqlite3DbFree(db, *pz);

*pz = z;

}

/*

** Call this routine to record the fact that an OOM (out-of-memory) error

** has happened. This routine will set db->mallocFailed, and also

** temporarily disable the lookaside memory allocator and interrupt

** any running VDBEs.

**

** Always return a NULL pointer so that this routine can be invoked using

**

** return sqlite3OomFault(db);

**

** and thereby avoid unnecessary stack frame allocations for the overwhelmingly

** common case where no OOM occurs.

*/

void *sqlite3OomFault(sqlite3 *db){

if( db->mallocFailed==0 && db->bBenignMalloc==0 ){

db->mallocFailed = 1;

if( db->nVdbeExec>0 ){

AtomicStore(&db->u1.isInterrupted, 1);

}

DisableLookaside;

if( db->pParse ){

Parse *pParse;

sqlite3ErrorMsg(db->pParse, "out of memory");

db->pParse->rc = SQLITE_NOMEM_BKPT;

for(pParse=db->pParse->pOuterParse; pParse; pParse = pParse->pOuterParse){

pParse->nErr++;

pParse->rc = SQLITE_NOMEM;

}

}

}

return 0;

}

/*

** This routine reactivates the memory allocator and clears the

** db->mallocFailed flag as necessary.

**

** The memory allocator is not restarted if there are running

** VDBEs.

*/

void sqlite3OomClear(sqlite3 *db){

if( db->mallocFailed && db->nVdbeExec==0 ){

db->mallocFailed = 0;

AtomicStore(&db->u1.isInterrupted, 0);

assert( db->lookaside.bDisable>0 );

EnableLookaside;

}

}

/*

** Take actions at the end of an API call to deal with error codes.

*/

static SQLITE_NOINLINE int apiHandleError(sqlite3 *db, int rc){

if( db->mallocFailed || rc==SQLITE_IOERR_NOMEM ){

sqlite3OomClear(db);

sqlite3Error(db, SQLITE_NOMEM);

return SQLITE_NOMEM_BKPT;

}

return rc & db->errMask;

}

/*

** This function must be called before exiting any API function (i.e.

** returning control to the user) that has called sqlite3_malloc or

** sqlite3_realloc.

**

** The returned value is normally a copy of the second argument to this

** function. However, if a malloc() failure has occurred since the previous

** invocation SQLITE_NOMEM is returned instead.

**

** If an OOM as occurred, then the connection error-code (the value

** returned by sqlite3_errcode()) is set to SQLITE_NOMEM.

*/

int sqlite3ApiExit(sqlite3* db, int rc){

/* If the db handle must hold the connection handle mutex here.

** Otherwise the read (and possible write) of db->mallocFailed

** is unsafe, as is the call to sqlite3Error().

*/

assert( db!=0 );

assert( sqlite3_mutex_held(db->mutex) );

if( db->mallocFailed || rc ){

return apiHandleError(db, rc);

}

return rc & db->errMask;

}