text: /*
   * Copyright 2010-2017, Tarantool AUTHORS, please see AUTHORS file.
   *
   * Redistribution and use in source and binary forms, with or
   * without modification, are permitted provided that the following
   * conditions are met:
   *
   * 1. Redistributions of source code must retain the above
   *    copyright notice, this list of conditions and the
   *    following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above
   *    copyright notice, this list of conditions and the following
   *    disclaimer in the documentation and/or other materials
   *    provided with the distribution.
   *
   * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
   * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
   * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
   * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
   * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
   * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   */
  
  /*
   *
   * 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
  }
  
  /*
   * An instance of the following object records the location of
   * each unused scratch buffer.
   */
  typedef struct ScratchFreeslot {
  	struct ScratchFreeslot *pNext;	/* Next unused scratch buffer */
  } ScratchFreeslot;
  
  /*
   * 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 */
  
  	/*
  	 * Pointers to the end of sqlite3GlobalConfig.pScratch memory
  	 * (so that a range test can be used to determine if an allocation
  	 * being freed came from pScratch) and a pointer to the list of
  	 * unused scratch allocations.
  	 */
  	void *pScratchEnd;
  	ScratchFreeslot *pScratchFree;
  	u32 nScratchFree;
  
  	/*
  	 * True if heap is nearly "full" where "full" is defined by the
  	 * sqlite3_soft_heap_limit() setting.
  	 */
  	int nearlyFull;
  } mem0 = {
  0, 0, 0, 0, 0, 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. Passing a zero or
   * negative value indicates no 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;
  	}
  	mem0.alarmThreshold = n;
  	nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
  	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);
  }
  
  /*
   * Initialize the memory allocation subsystem.
   */
  int
  sqlite3MallocInit(void)
  {
  	int rc;
  	if (sqlite3GlobalConfig.m.xMalloc == 0) {
  		sqlite3MemSetDefault();
  	}
  	memset(&mem0, 0, sizeof(mem0));
  	mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
  	if (sqlite3GlobalConfig.pScratch && sqlite3GlobalConfig.szScratch >= 100
  	    && sqlite3GlobalConfig.nScratch > 0) {
  		int i, n, sz;
  		ScratchFreeslot *pSlot;
  		sz = ROUNDDOWN8(sqlite3GlobalConfig.szScratch);
  		sqlite3GlobalConfig.szScratch = sz;
  		pSlot = (ScratchFreeslot *) sqlite3GlobalConfig.pScratch;
  		n = sqlite3GlobalConfig.nScratch;
  		mem0.pScratchFree = pSlot;
  		mem0.nScratchFree = n;
  		for (i = 0; i < n - 1; i++) {
  			pSlot->pNext = (ScratchFreeslot *) (sz + (char *)pSlot);
  			pSlot = pSlot->pNext;
  		}
  		pSlot->pNext = 0;
  		mem0.pScratchEnd = (void *)&pSlot[1];
  	} else {
  		mem0.pScratchEnd = 0;
  		sqlite3GlobalConfig.pScratch = 0;
  		sqlite3GlobalConfig.szScratch = 0;
  		sqlite3GlobalConfig.nScratch = 0;
  	}
  	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));
  	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 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 int
  mallocWithAlarm(int n, void **pp)
  {
  	int nFull;
  	void *p;
  	assert(sqlite3_mutex_held(mem0.mutex));
  	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) {
  			mem0.nearlyFull = 1;
  			sqlite3MallocAlarm(nFull);
  		} else {
  			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;
  	return nFull;
  }
  
  /*
   * 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);
  }
  
  /*
   * Each thread may only have a single outstanding allocation from
   * xScratchMalloc().  We verify this constraint in the single-threaded
   * case by setting scratchAllocOut to 1 when an allocation
   * is outstanding clearing it when the allocation is freed.
   */
  #if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
  static int scratchAllocOut = 0;
  #endif
  
  /*
   * Allocate memory that is to be used and released right away.
   * This routine is similar to alloca() in that it is not intended
   * for situations where the memory might be held long-term.  This
   * routine is intended to get memory to old large transient data
   * structures that would not normally fit on the stack of an
   * embedded processor.
   */
  void *
  sqlite3ScratchMalloc(int n)
  {
  	void *p;
  	assert(n > 0);
  
  	sqlite3_mutex_enter(mem0.mutex);
  	sqlite3StatusHighwater(SQLITE_STATUS_SCRATCH_SIZE, n);
  	if (mem0.nScratchFree && sqlite3GlobalConfig.szScratch >= n) {
  		p = mem0.pScratchFree;
  		mem0.pScratchFree = mem0.pScratchFree->pNext;
  		mem0.nScratchFree--;
  		sqlite3StatusUp(SQLITE_STATUS_SCRATCH_USED, 1);
  		sqlite3_mutex_leave(mem0.mutex);
  	} else {
  		sqlite3_mutex_leave(mem0.mutex);
  		p = sqlite3Malloc(n);
  		if (sqlite3GlobalConfig.bMemstat && p) {
  			sqlite3_mutex_enter(mem0.mutex);
  			sqlite3StatusUp(SQLITE_STATUS_SCRATCH_OVERFLOW,
  					sqlite3MallocSize(p));
  			sqlite3_mutex_leave(mem0.mutex);
  		}
  		sqlite3MemdebugSetType(p, MEMTYPE_SCRATCH);
  	}
  	assert(sqlite3_mutex_notheld(mem0.mutex));
  
  #if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
  	/* EVIDENCE-OF: R-12970-05880 SQLite will not use more than one scratch
  	 * buffers per thread.
  	 *
  	 * This can only be checked in single-threaded mode.
  	 */
  	assert(scratchAllocOut == 0);
  	if (p)
  		scratchAllocOut++;
  #endif
  
  	return p;
  }
  
  void
  sqlite3ScratchFree(void *p)
  {
  	if (p) {
  
  #if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
  		/* Verify that no more than two scratch allocation per thread
  		 * is outstanding at one time.  (This is only checked in the
  		 * single-threaded case since checking in the multi-threaded case
  		 * would be much more complicated.)
  		 */
  		assert(scratchAllocOut >= 1 && scratchAllocOut <= 2);
  		scratchAllocOut--;
  #endif
  
  		if (SQLITE_WITHIN
  		    (p, sqlite3GlobalConfig.pScratch, mem0.pScratchEnd)) {
  			/* Release memory from the SQLITE_CONFIG_SCRATCH allocation */
  			ScratchFreeslot *pSlot;
  			pSlot = (ScratchFreeslot *) p;
  			sqlite3_mutex_enter(mem0.mutex);
  			pSlot->pNext = mem0.pScratchFree;
  			mem0.pScratchFree = pSlot;
  			mem0.nScratchFree++;
  			assert(mem0.nScratchFree <=
  			       (u32) sqlite3GlobalConfig.nScratch);
  			sqlite3StatusDown(SQLITE_STATUS_SCRATCH_USED, 1);
  			sqlite3_mutex_leave(mem0.mutex);
  		} else {
  			/* Release memory back to the heap */
  			assert(sqlite3MemdebugHasType(p, MEMTYPE_SCRATCH));
  			assert(sqlite3MemdebugNoType
  			       (p, (u8) ~ MEMTYPE_SCRATCH));
  			sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
  			if (sqlite3GlobalConfig.bMemstat) {
  				int iSize = sqlite3MallocSize(p);
  				sqlite3_mutex_enter(mem0.mutex);
  				sqlite3StatusDown
  				    (SQLITE_STATUS_SCRATCH_OVERFLOW, iSize);
  				sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED,
  						  iSize);
  				sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT,
  						  1);
  				sqlite3GlobalConfig.m.xFree(p);
  				sqlite3_mutex_leave(mem0.mutex);
  			} else {
  				sqlite3GlobalConfig.m.xFree(p);
  			}
  		}
  	}
  }
  
  /*
   * TRUE if p is a lookaside memory allocation from db
   */
  #ifndef SQLITE_OMIT_LOOKASIDE
  static int
  isLookaside(sqlite3 * db, 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(void *p)
  {
  	assert(sqlite3MemdebugHasType(p, MEMTYPE_HEAP));
  	return sqlite3GlobalConfig.m.xSize(p);
  }
  
  int
  sqlite3DbMallocSize(sqlite3 * db, void *p)
  {
  	assert(p != 0);
  	if (db == 0 || !isLookaside(db, p)) {
  #if SQLITE_DEBUG
  		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
  		return sqlite3GlobalConfig.m.xSize(p);
  	} else {
  		assert(sqlite3_mutex_held(db->mutex));
  		return db->lookaside.sz;
  	}
  }
  
  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.
   */
  void
  sqlite3DbFree(sqlite3 * db, void *p)
  {
  	assert(db == 0 || sqlite3_mutex_held(db->mutex));
  	if (p == 0)
  		return;
  	if (db) {
  		if (db->pnBytesFreed) {
  			measureAllocationSize(db, p);
  			return;
  		}
  		if (isLookaside(db, p)) {
  			LookasideSlot *pBuf = (LookasideSlot *) p;
  #if SQLITE_DEBUG
  			/* Trash all content in the buffer being freed */
  			memset(p, 0xaa, db->lookaside.sz);
  #endif
  			pBuf->pNext = db->lookaside.pFree;
  			db->lookaside.pFree = pBuf;
  			db->lookaside.nOut--;
  			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);
  }
  
  /*
   * 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_mutex_enter(mem0.mutex);
  		sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, (int)nBytes);
  		nDiff = nNew - nOld;
  		if (nDiff > 0
  		    && sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED) >=
  		    mem0.alarmThreshold - nDiff) {
  			sqlite3MallocAlarm(nDiff);
  		}
  		pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
  		if (pNew == 0 && mem0.alarmThreshold > 0) {
  			sqlite3MallocAlarm((int)nBytes);
  			pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
  		}
  		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 (db->lookaside.bDisable == 0) {
  		assert(db->mallocFailed == 0);
  		if (n > db->lookaside.sz) {
  			db->lookaside.anStat[1]++;
  		} else if ((pBuf = db->lookaside.pFree) == 0) {
  			db->lookaside.anStat[2]++;
  		} else {
  			db->lookaside.pFree = pBuf->pNext;
  			db->lookaside.nOut++;
  			db->lookaside.anStat[0]++;
  			if (db->lookaside.nOut > db->lookaside.mxOut) {
  				db->lookaside.mxOut = db->lookaside.nOut;
  			}
  			return (void *)pBuf;
  		}
  	} else if (db->mallocFailed) {
  		return 0;
  	}
  #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 (isLookaside(db, p) && n <= db->lookaside.sz)
  		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, db->lookaside.sz);
  				sqlite3DbFree(db, p);
  			}
  		} else {
  			assert(sqlite3MemdebugHasType
  			       (p, (MEMTYPE_LOOKASIDE | MEMTYPE_HEAP)));
  			assert(sqlite3MemdebugNoType
  			       (p, (u8) ~ (MEMTYPE_LOOKASIDE | MEMTYPE_HEAP)));
  			sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
  			pNew = sqlite3_realloc64(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);
  	if (z == 0) {
  		return 0;
  	}
  	assert((n & 0x7fffffff) == n);
  	zNew = sqlite3DbMallocRawNN(db, n + 1);
  	if (zNew) {
  		memcpy(zNew, z, (size_t) n);
  		zNew[n] = 0;
  	}
  	return zNew;
  }
  
  /*
   * Free any prior content in *pz and replace it with a copy of zNew.
   */
  void
  sqlite3SetString(char **pz, sqlite3 * db, const char *zNew)
  {
  	sqlite3DbFree(db, *pz);
  	*pz = sqlite3DbStrDup(db, zNew);
  }
  
  /*
   * 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.
   */
  void
  sqlite3OomFault(sqlite3 * db)
  {
  	if (db->mallocFailed == 0 && db->bBenignMalloc == 0) {
  		db->mallocFailed = 1;
  		if (db->nVdbeExec > 0) {
  			db->u1.isInterrupted = 1;
  		}
  		db->lookaside.bDisable++;
  	}
  }
  
  /*
   * 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;
  		db->u1.isInterrupted = 0;
  		assert(db->lookaside.bDisable > 0);
  		db->lookaside.bDisable--;
  	}
  }
  
  /*
   * Take actions at the end of an API call to indicate an OOM error
   */
  static SQLITE_NOINLINE int
  apiOomError(sqlite3 * db)
  {
  	sqlite3OomClear(db);
  	sqlite3Error(db, SQLITE_NOMEM);
  	return SQLITE_NOMEM_BKPT;
  }
  
  /*
   * 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 == SQLITE_IOERR_NOMEM) {
  		return apiOomError(db);
  	}
  	return rc & db->errMask;
  }
  