Index: third_party/sqlite/sqlite-src-3170000/src/malloc.c |
diff --git a/third_party/sqlite/sqlite-src-3170000/src/malloc.c b/third_party/sqlite/sqlite-src-3170000/src/malloc.c |
new file mode 100644 |
index 0000000000000000000000000000000000000000..e7714aa103a46b226e1d41bc9e92571b0c07929e |
--- /dev/null |
+++ b/third_party/sqlite/sqlite-src-3170000/src/malloc.c |
@@ -0,0 +1,830 @@ |
+/* |
+** 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 |
+} |
+ |
+/* |
+** 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 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 ){ |
+ 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; |
+} |
+ |
+/* |
+** 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; |
+} |