000001  /*
000002  ** 2001 September 15
000003  **
000004  ** The author disclaims copyright to this source code.  In place of
000005  ** a legal notice, here is a blessing:
000006  **
000007  **    May you do good and not evil.
000008  **    May you find forgiveness for yourself and forgive others.
000009  **    May you share freely, never taking more than you give.
000010  **
000011  *************************************************************************
000012  **
000013  ** Memory allocation functions used throughout sqlite.
000014  */
000015  #include "sqliteInt.h"
000016  #include <stdarg.h>
000017  
000018  /*
000019  ** Attempt to release up to n bytes of non-essential memory currently
000020  ** held by SQLite. An example of non-essential memory is memory used to
000021  ** cache database pages that are not currently in use.
000022  */
000023  int sqlite3_release_memory(int n){
000024  #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
000025    return sqlite3PcacheReleaseMemory(n);
000026  #else
000027    /* IMPLEMENTATION-OF: R-34391-24921 The sqlite3_release_memory() routine
000028    ** is a no-op returning zero if SQLite is not compiled with
000029    ** SQLITE_ENABLE_MEMORY_MANAGEMENT. */
000030    UNUSED_PARAMETER(n);
000031    return 0;
000032  #endif
000033  }
000034  
000035  /*
000036  ** Default value of the hard heap limit.  0 means "no limit".
000037  */
000038  #ifndef SQLITE_MAX_MEMORY
000039  # define SQLITE_MAX_MEMORY 0
000040  #endif
000041  
000042  /*
000043  ** State information local to the memory allocation subsystem.
000044  */
000045  static SQLITE_WSD struct Mem0Global {
000046    sqlite3_mutex *mutex;         /* Mutex to serialize access */
000047    sqlite3_int64 alarmThreshold; /* The soft heap limit */
000048    sqlite3_int64 hardLimit;      /* The hard upper bound on memory */
000049  
000050    /*
000051    ** True if heap is nearly "full" where "full" is defined by the
000052    ** sqlite3_soft_heap_limit() setting.
000053    */
000054    int nearlyFull;
000055  } mem0 = { 0, SQLITE_MAX_MEMORY, SQLITE_MAX_MEMORY, 0 };
000056  
000057  #define mem0 GLOBAL(struct Mem0Global, mem0)
000058  
000059  /*
000060  ** Return the memory allocator mutex. sqlite3_status() needs it.
000061  */
000062  sqlite3_mutex *sqlite3MallocMutex(void){
000063    return mem0.mutex;
000064  }
000065  
000066  #ifndef SQLITE_OMIT_DEPRECATED
000067  /*
000068  ** Deprecated external interface.  It used to set an alarm callback
000069  ** that was invoked when memory usage grew too large.  Now it is a
000070  ** no-op.
000071  */
000072  int sqlite3_memory_alarm(
000073    void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
000074    void *pArg,
000075    sqlite3_int64 iThreshold
000076  ){
000077    (void)xCallback;
000078    (void)pArg;
000079    (void)iThreshold;
000080    return SQLITE_OK;
000081  }
000082  #endif
000083  
000084  /*
000085  ** Set the soft heap-size limit for the library.  An argument of
000086  ** zero disables the limit.  A negative argument is a no-op used to
000087  ** obtain the return value.
000088  **
000089  ** The return value is the value of the heap limit just before this
000090  ** interface was called.
000091  **
000092  ** If the hard heap limit is enabled, then the soft heap limit cannot
000093  ** be disabled nor raised above the hard heap limit.
000094  */
000095  sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 n){
000096    sqlite3_int64 priorLimit;
000097    sqlite3_int64 excess;
000098    sqlite3_int64 nUsed;
000099  #ifndef SQLITE_OMIT_AUTOINIT
000100    int rc = sqlite3_initialize();
000101    if( rc ) return -1;
000102  #endif
000103    sqlite3_mutex_enter(mem0.mutex);
000104    priorLimit = mem0.alarmThreshold;
000105    if( n<0 ){
000106      sqlite3_mutex_leave(mem0.mutex);
000107      return priorLimit;
000108    }
000109    if( mem0.hardLimit>0 && (n>mem0.hardLimit || n==0) ){
000110      n = mem0.hardLimit;
000111    }
000112    mem0.alarmThreshold = n;
000113    nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
000114    mem0.nearlyFull = (n>0 && n<=nUsed);
000115    sqlite3_mutex_leave(mem0.mutex);
000116    excess = sqlite3_memory_used() - n;
000117    if( excess>0 ) sqlite3_release_memory((int)(excess & 0x7fffffff));
000118    return priorLimit;
000119  }
000120  void sqlite3_soft_heap_limit(int n){
000121    if( n<0 ) n = 0;
000122    sqlite3_soft_heap_limit64(n);
000123  }
000124  
000125  /*
000126  ** Set the hard heap-size limit for the library. An argument of zero
000127  ** disables the hard heap limit.  A negative argument is a no-op used
000128  ** to obtain the return value without affecting the hard heap limit.
000129  **
000130  ** The return value is the value of the hard heap limit just prior to
000131  ** calling this interface.
000132  **
000133  ** Setting the hard heap limit will also activate the soft heap limit
000134  ** and constrain the soft heap limit to be no more than the hard heap
000135  ** limit.
000136  */
000137  sqlite3_int64 sqlite3_hard_heap_limit64(sqlite3_int64 n){
000138    sqlite3_int64 priorLimit;
000139  #ifndef SQLITE_OMIT_AUTOINIT
000140    int rc = sqlite3_initialize();
000141    if( rc ) return -1;
000142  #endif
000143    sqlite3_mutex_enter(mem0.mutex);
000144    priorLimit = mem0.hardLimit;
000145    if( n>=0 ){
000146      mem0.hardLimit = n;
000147      if( n<mem0.alarmThreshold || mem0.alarmThreshold==0 ){
000148        mem0.alarmThreshold = n;
000149      }
000150    }
000151    sqlite3_mutex_leave(mem0.mutex);
000152    return priorLimit;
000153  }
000154  
000155  
000156  /*
000157  ** Initialize the memory allocation subsystem.
000158  */
000159  int sqlite3MallocInit(void){
000160    int rc;
000161    if( sqlite3GlobalConfig.m.xMalloc==0 ){
000162      sqlite3MemSetDefault();
000163    }
000164    memset(&mem0, 0, sizeof(mem0));
000165    mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
000166    if( sqlite3GlobalConfig.pPage==0 || sqlite3GlobalConfig.szPage<512
000167        || sqlite3GlobalConfig.nPage<=0 ){
000168      sqlite3GlobalConfig.pPage = 0;
000169      sqlite3GlobalConfig.szPage = 0;
000170    }
000171    rc = sqlite3GlobalConfig.m.xInit(sqlite3GlobalConfig.m.pAppData);
000172    if( rc!=SQLITE_OK ) memset(&mem0, 0, sizeof(mem0));
000173    return rc;
000174  }
000175  
000176  /*
000177  ** Return true if the heap is currently under memory pressure - in other
000178  ** words if the amount of heap used is close to the limit set by
000179  ** sqlite3_soft_heap_limit().
000180  */
000181  int sqlite3HeapNearlyFull(void){
000182    return mem0.nearlyFull;
000183  }
000184  
000185  /*
000186  ** Deinitialize the memory allocation subsystem.
000187  */
000188  void sqlite3MallocEnd(void){
000189    if( sqlite3GlobalConfig.m.xShutdown ){
000190      sqlite3GlobalConfig.m.xShutdown(sqlite3GlobalConfig.m.pAppData);
000191    }
000192    memset(&mem0, 0, sizeof(mem0));
000193  }
000194  
000195  /*
000196  ** Return the amount of memory currently checked out.
000197  */
000198  sqlite3_int64 sqlite3_memory_used(void){
000199    sqlite3_int64 res, mx;
000200    sqlite3_status64(SQLITE_STATUS_MEMORY_USED, &res, &mx, 0);
000201    return res;
000202  }
000203  
000204  /*
000205  ** Return the maximum amount of memory that has ever been
000206  ** checked out since either the beginning of this process
000207  ** or since the most recent reset.
000208  */
000209  sqlite3_int64 sqlite3_memory_highwater(int resetFlag){
000210    sqlite3_int64 res, mx;
000211    sqlite3_status64(SQLITE_STATUS_MEMORY_USED, &res, &mx, resetFlag);
000212    return mx;
000213  }
000214  
000215  /*
000216  ** Trigger the alarm 
000217  */
000218  static void sqlite3MallocAlarm(int nByte){
000219    if( mem0.alarmThreshold<=0 ) return;
000220    sqlite3_mutex_leave(mem0.mutex);
000221    sqlite3_release_memory(nByte);
000222    sqlite3_mutex_enter(mem0.mutex);
000223  }
000224  
000225  /*
000226  ** Do a memory allocation with statistics and alarms.  Assume the
000227  ** lock is already held.
000228  */
000229  static void mallocWithAlarm(int n, void **pp){
000230    void *p;
000231    int nFull;
000232    assert( sqlite3_mutex_held(mem0.mutex) );
000233    assert( n>0 );
000234  
000235    /* In Firefox (circa 2017-02-08), xRoundup() is remapped to an internal
000236    ** implementation of malloc_good_size(), which must be called in debug
000237    ** mode and specifically when the DMD "Dark Matter Detector" is enabled
000238    ** or else a crash results.  Hence, do not attempt to optimize out the
000239    ** following xRoundup() call. */
000240    nFull = sqlite3GlobalConfig.m.xRoundup(n);
000241  
000242    sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, n);
000243    if( mem0.alarmThreshold>0 ){
000244      sqlite3_int64 nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
000245      if( nUsed >= mem0.alarmThreshold - nFull ){
000246        mem0.nearlyFull = 1;
000247        sqlite3MallocAlarm(nFull);
000248        if( mem0.hardLimit ){
000249          nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
000250          if( nUsed >= mem0.hardLimit - nFull ){
000251            *pp = 0;
000252            return;
000253          }
000254        }
000255      }else{
000256        mem0.nearlyFull = 0;
000257      }
000258    }
000259    p = sqlite3GlobalConfig.m.xMalloc(nFull);
000260  #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
000261    if( p==0 && mem0.alarmThreshold>0 ){
000262      sqlite3MallocAlarm(nFull);
000263      p = sqlite3GlobalConfig.m.xMalloc(nFull);
000264    }
000265  #endif
000266    if( p ){
000267      nFull = sqlite3MallocSize(p);
000268      sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nFull);
000269      sqlite3StatusUp(SQLITE_STATUS_MALLOC_COUNT, 1);
000270    }
000271    *pp = p;
000272  }
000273  
000274  /*
000275  ** Allocate memory.  This routine is like sqlite3_malloc() except that it
000276  ** assumes the memory subsystem has already been initialized.
000277  */
000278  void *sqlite3Malloc(u64 n){
000279    void *p;
000280    if( n==0 || n>=0x7fffff00 ){
000281      /* A memory allocation of a number of bytes which is near the maximum
000282      ** signed integer value might cause an integer overflow inside of the
000283      ** xMalloc().  Hence we limit the maximum size to 0x7fffff00, giving
000284      ** 255 bytes of overhead.  SQLite itself will never use anything near
000285      ** this amount.  The only way to reach the limit is with sqlite3_malloc() */
000286      p = 0;
000287    }else if( sqlite3GlobalConfig.bMemstat ){
000288      sqlite3_mutex_enter(mem0.mutex);
000289      mallocWithAlarm((int)n, &p);
000290      sqlite3_mutex_leave(mem0.mutex);
000291    }else{
000292      p = sqlite3GlobalConfig.m.xMalloc((int)n);
000293    }
000294    assert( EIGHT_BYTE_ALIGNMENT(p) );  /* IMP: R-11148-40995 */
000295    return p;
000296  }
000297  
000298  /*
000299  ** This version of the memory allocation is for use by the application.
000300  ** First make sure the memory subsystem is initialized, then do the
000301  ** allocation.
000302  */
000303  void *sqlite3_malloc(int n){
000304  #ifndef SQLITE_OMIT_AUTOINIT
000305    if( sqlite3_initialize() ) return 0;
000306  #endif
000307    return n<=0 ? 0 : sqlite3Malloc(n);
000308  }
000309  void *sqlite3_malloc64(sqlite3_uint64 n){
000310  #ifndef SQLITE_OMIT_AUTOINIT
000311    if( sqlite3_initialize() ) return 0;
000312  #endif
000313    return sqlite3Malloc(n);
000314  }
000315  
000316  /*
000317  ** TRUE if p is a lookaside memory allocation from db
000318  */
000319  #ifndef SQLITE_OMIT_LOOKASIDE
000320  static int isLookaside(sqlite3 *db, void *p){
000321    return SQLITE_WITHIN(p, db->lookaside.pStart, db->lookaside.pEnd);
000322  }
000323  #else
000324  #define isLookaside(A,B) 0
000325  #endif
000326  
000327  /*
000328  ** Return the size of a memory allocation previously obtained from
000329  ** sqlite3Malloc() or sqlite3_malloc().
000330  */
000331  int sqlite3MallocSize(void *p){
000332    assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
000333    return sqlite3GlobalConfig.m.xSize(p);
000334  }
000335  int sqlite3DbMallocSize(sqlite3 *db, void *p){
000336    assert( p!=0 );
000337    if( db==0 || !isLookaside(db,p) ){
000338  #ifdef SQLITE_DEBUG
000339      if( db==0 ){
000340        assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
000341        assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
000342      }else{
000343        assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
000344        assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
000345      }
000346  #endif
000347      return sqlite3GlobalConfig.m.xSize(p);
000348    }else{
000349      assert( sqlite3_mutex_held(db->mutex) );
000350      return db->lookaside.szTrue;
000351    }
000352  }
000353  sqlite3_uint64 sqlite3_msize(void *p){
000354    assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
000355    assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
000356    return p ? sqlite3GlobalConfig.m.xSize(p) : 0;
000357  }
000358  
000359  /*
000360  ** Free memory previously obtained from sqlite3Malloc().
000361  */
000362  void sqlite3_free(void *p){
000363    if( p==0 ) return;  /* IMP: R-49053-54554 */
000364    assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
000365    assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
000366    if( sqlite3GlobalConfig.bMemstat ){
000367      sqlite3_mutex_enter(mem0.mutex);
000368      sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED, sqlite3MallocSize(p));
000369      sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1);
000370      sqlite3GlobalConfig.m.xFree(p);
000371      sqlite3_mutex_leave(mem0.mutex);
000372    }else{
000373      sqlite3GlobalConfig.m.xFree(p);
000374    }
000375  }
000376  
000377  /*
000378  ** Add the size of memory allocation "p" to the count in
000379  ** *db->pnBytesFreed.
000380  */
000381  static SQLITE_NOINLINE void measureAllocationSize(sqlite3 *db, void *p){
000382    *db->pnBytesFreed += sqlite3DbMallocSize(db,p);
000383  }
000384  
000385  /*
000386  ** Free memory that might be associated with a particular database
000387  ** connection.  Calling sqlite3DbFree(D,X) for X==0 is a harmless no-op.
000388  ** The sqlite3DbFreeNN(D,X) version requires that X be non-NULL.
000389  */
000390  void sqlite3DbFreeNN(sqlite3 *db, void *p){
000391    assert( db==0 || sqlite3_mutex_held(db->mutex) );
000392    assert( p!=0 );
000393    if( db ){
000394      if( db->pnBytesFreed ){
000395        measureAllocationSize(db, p);
000396        return;
000397      }
000398      if( isLookaside(db, p) ){
000399        LookasideSlot *pBuf = (LookasideSlot*)p;
000400  #ifdef SQLITE_DEBUG
000401        /* Trash all content in the buffer being freed */
000402        memset(p, 0xaa, db->lookaside.szTrue);
000403  #endif
000404        pBuf->pNext = db->lookaside.pFree;
000405        db->lookaside.pFree = pBuf;
000406        return;
000407      }
000408    }
000409    assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
000410    assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
000411    assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
000412    sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
000413    sqlite3_free(p);
000414  }
000415  void sqlite3DbFree(sqlite3 *db, void *p){
000416    assert( db==0 || sqlite3_mutex_held(db->mutex) );
000417    if( p ) sqlite3DbFreeNN(db, p);
000418  }
000419  
000420  /*
000421  ** Change the size of an existing memory allocation
000422  */
000423  void *sqlite3Realloc(void *pOld, u64 nBytes){
000424    int nOld, nNew, nDiff;
000425    void *pNew;
000426    assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) );
000427    assert( sqlite3MemdebugNoType(pOld, (u8)~MEMTYPE_HEAP) );
000428    if( pOld==0 ){
000429      return sqlite3Malloc(nBytes); /* IMP: R-04300-56712 */
000430    }
000431    if( nBytes==0 ){
000432      sqlite3_free(pOld); /* IMP: R-26507-47431 */
000433      return 0;
000434    }
000435    if( nBytes>=0x7fffff00 ){
000436      /* The 0x7ffff00 limit term is explained in comments on sqlite3Malloc() */
000437      return 0;
000438    }
000439    nOld = sqlite3MallocSize(pOld);
000440    /* IMPLEMENTATION-OF: R-46199-30249 SQLite guarantees that the second
000441    ** argument to xRealloc is always a value returned by a prior call to
000442    ** xRoundup. */
000443    nNew = sqlite3GlobalConfig.m.xRoundup((int)nBytes);
000444    if( nOld==nNew ){
000445      pNew = pOld;
000446    }else if( sqlite3GlobalConfig.bMemstat ){
000447      sqlite3_mutex_enter(mem0.mutex);
000448      sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, (int)nBytes);
000449      nDiff = nNew - nOld;
000450      if( nDiff>0 && sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED) >= 
000451            mem0.alarmThreshold-nDiff ){
000452        sqlite3MallocAlarm(nDiff);
000453      }
000454      pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
000455      if( pNew==0 && mem0.alarmThreshold>0 ){
000456        sqlite3MallocAlarm((int)nBytes);
000457        pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
000458      }
000459      if( pNew ){
000460        nNew = sqlite3MallocSize(pNew);
000461        sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nNew-nOld);
000462      }
000463      sqlite3_mutex_leave(mem0.mutex);
000464    }else{
000465      pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
000466    }
000467    assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-11148-40995 */
000468    return pNew;
000469  }
000470  
000471  /*
000472  ** The public interface to sqlite3Realloc.  Make sure that the memory
000473  ** subsystem is initialized prior to invoking sqliteRealloc.
000474  */
000475  void *sqlite3_realloc(void *pOld, int n){
000476  #ifndef SQLITE_OMIT_AUTOINIT
000477    if( sqlite3_initialize() ) return 0;
000478  #endif
000479    if( n<0 ) n = 0;  /* IMP: R-26507-47431 */
000480    return sqlite3Realloc(pOld, n);
000481  }
000482  void *sqlite3_realloc64(void *pOld, sqlite3_uint64 n){
000483  #ifndef SQLITE_OMIT_AUTOINIT
000484    if( sqlite3_initialize() ) return 0;
000485  #endif
000486    return sqlite3Realloc(pOld, n);
000487  }
000488  
000489  
000490  /*
000491  ** Allocate and zero memory.
000492  */ 
000493  void *sqlite3MallocZero(u64 n){
000494    void *p = sqlite3Malloc(n);
000495    if( p ){
000496      memset(p, 0, (size_t)n);
000497    }
000498    return p;
000499  }
000500  
000501  /*
000502  ** Allocate and zero memory.  If the allocation fails, make
000503  ** the mallocFailed flag in the connection pointer.
000504  */
000505  void *sqlite3DbMallocZero(sqlite3 *db, u64 n){
000506    void *p;
000507    testcase( db==0 );
000508    p = sqlite3DbMallocRaw(db, n);
000509    if( p ) memset(p, 0, (size_t)n);
000510    return p;
000511  }
000512  
000513  
000514  /* Finish the work of sqlite3DbMallocRawNN for the unusual and
000515  ** slower case when the allocation cannot be fulfilled using lookaside.
000516  */
000517  static SQLITE_NOINLINE void *dbMallocRawFinish(sqlite3 *db, u64 n){
000518    void *p;
000519    assert( db!=0 );
000520    p = sqlite3Malloc(n);
000521    if( !p ) sqlite3OomFault(db);
000522    sqlite3MemdebugSetType(p, 
000523           (db->lookaside.bDisable==0) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP);
000524    return p;
000525  }
000526  
000527  /*
000528  ** Allocate memory, either lookaside (if possible) or heap.  
000529  ** If the allocation fails, set the mallocFailed flag in
000530  ** the connection pointer.
000531  **
000532  ** If db!=0 and db->mallocFailed is true (indicating a prior malloc
000533  ** failure on the same database connection) then always return 0.
000534  ** Hence for a particular database connection, once malloc starts
000535  ** failing, it fails consistently until mallocFailed is reset.
000536  ** This is an important assumption.  There are many places in the
000537  ** code that do things like this:
000538  **
000539  **         int *a = (int*)sqlite3DbMallocRaw(db, 100);
000540  **         int *b = (int*)sqlite3DbMallocRaw(db, 200);
000541  **         if( b ) a[10] = 9;
000542  **
000543  ** In other words, if a subsequent malloc (ex: "b") worked, it is assumed
000544  ** that all prior mallocs (ex: "a") worked too.
000545  **
000546  ** The sqlite3MallocRawNN() variant guarantees that the "db" parameter is
000547  ** not a NULL pointer.
000548  */
000549  void *sqlite3DbMallocRaw(sqlite3 *db, u64 n){
000550    void *p;
000551    if( db ) return sqlite3DbMallocRawNN(db, n);
000552    p = sqlite3Malloc(n);
000553    sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
000554    return p;
000555  }
000556  void *sqlite3DbMallocRawNN(sqlite3 *db, u64 n){
000557  #ifndef SQLITE_OMIT_LOOKASIDE
000558    LookasideSlot *pBuf;
000559    assert( db!=0 );
000560    assert( sqlite3_mutex_held(db->mutex) );
000561    assert( db->pnBytesFreed==0 );
000562    if( n>db->lookaside.sz ){
000563      if( db->lookaside.bDisable ){
000564        return db->mallocFailed ? 0 : dbMallocRawFinish(db, n);
000565      }
000566      db->lookaside.anStat[1]++;
000567    }else if( (pBuf = db->lookaside.pFree)!=0 ){
000568      db->lookaside.pFree = pBuf->pNext;
000569      db->lookaside.anStat[0]++;
000570      return (void*)pBuf;
000571    }else if( (pBuf = db->lookaside.pInit)!=0 ){
000572      db->lookaside.pInit = pBuf->pNext;
000573      db->lookaside.anStat[0]++;
000574      return (void*)pBuf;
000575    }else{
000576      db->lookaside.anStat[2]++;
000577    }
000578  #else
000579    assert( db!=0 );
000580    assert( sqlite3_mutex_held(db->mutex) );
000581    assert( db->pnBytesFreed==0 );
000582    if( db->mallocFailed ){
000583      return 0;
000584    }
000585  #endif
000586    return dbMallocRawFinish(db, n);
000587  }
000588  
000589  /* Forward declaration */
000590  static SQLITE_NOINLINE void *dbReallocFinish(sqlite3 *db, void *p, u64 n);
000591  
000592  /*
000593  ** Resize the block of memory pointed to by p to n bytes. If the
000594  ** resize fails, set the mallocFailed flag in the connection object.
000595  */
000596  void *sqlite3DbRealloc(sqlite3 *db, void *p, u64 n){
000597    assert( db!=0 );
000598    if( p==0 ) return sqlite3DbMallocRawNN(db, n);
000599    assert( sqlite3_mutex_held(db->mutex) );
000600    if( isLookaside(db,p) && n<=db->lookaside.szTrue ) return p;
000601    return dbReallocFinish(db, p, n);
000602  }
000603  static SQLITE_NOINLINE void *dbReallocFinish(sqlite3 *db, void *p, u64 n){
000604    void *pNew = 0;
000605    assert( db!=0 );
000606    assert( p!=0 );
000607    if( db->mallocFailed==0 ){
000608      if( isLookaside(db, p) ){
000609        pNew = sqlite3DbMallocRawNN(db, n);
000610        if( pNew ){
000611          memcpy(pNew, p, db->lookaside.szTrue);
000612          sqlite3DbFree(db, p);
000613        }
000614      }else{
000615        assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
000616        assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
000617        sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
000618        pNew = sqlite3_realloc64(p, n);
000619        if( !pNew ){
000620          sqlite3OomFault(db);
000621        }
000622        sqlite3MemdebugSetType(pNew,
000623              (db->lookaside.bDisable==0 ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
000624      }
000625    }
000626    return pNew;
000627  }
000628  
000629  /*
000630  ** Attempt to reallocate p.  If the reallocation fails, then free p
000631  ** and set the mallocFailed flag in the database connection.
000632  */
000633  void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, u64 n){
000634    void *pNew;
000635    pNew = sqlite3DbRealloc(db, p, n);
000636    if( !pNew ){
000637      sqlite3DbFree(db, p);
000638    }
000639    return pNew;
000640  }
000641  
000642  /*
000643  ** Make a copy of a string in memory obtained from sqliteMalloc(). These 
000644  ** functions call sqlite3MallocRaw() directly instead of sqliteMalloc(). This
000645  ** is because when memory debugging is turned on, these two functions are 
000646  ** called via macros that record the current file and line number in the
000647  ** ThreadData structure.
000648  */
000649  char *sqlite3DbStrDup(sqlite3 *db, const char *z){
000650    char *zNew;
000651    size_t n;
000652    if( z==0 ){
000653      return 0;
000654    }
000655    n = strlen(z) + 1;
000656    zNew = sqlite3DbMallocRaw(db, n);
000657    if( zNew ){
000658      memcpy(zNew, z, n);
000659    }
000660    return zNew;
000661  }
000662  char *sqlite3DbStrNDup(sqlite3 *db, const char *z, u64 n){
000663    char *zNew;
000664    assert( db!=0 );
000665    if( z==0 ){
000666      return 0;
000667    }
000668    assert( (n&0x7fffffff)==n );
000669    zNew = sqlite3DbMallocRawNN(db, n+1);
000670    if( zNew ){
000671      memcpy(zNew, z, (size_t)n);
000672      zNew[n] = 0;
000673    }
000674    return zNew;
000675  }
000676  
000677  /*
000678  ** The text between zStart and zEnd represents a phrase within a larger
000679  ** SQL statement.  Make a copy of this phrase in space obtained form
000680  ** sqlite3DbMalloc().  Omit leading and trailing whitespace.
000681  */
000682  char *sqlite3DbSpanDup(sqlite3 *db, const char *zStart, const char *zEnd){
000683    int n;
000684    while( sqlite3Isspace(zStart[0]) ) zStart++;
000685    n = (int)(zEnd - zStart);
000686    while( ALWAYS(n>0) && sqlite3Isspace(zStart[n-1]) ) n--;
000687    return sqlite3DbStrNDup(db, zStart, n);
000688  }
000689  
000690  /*
000691  ** Free any prior content in *pz and replace it with a copy of zNew.
000692  */
000693  void sqlite3SetString(char **pz, sqlite3 *db, const char *zNew){
000694    sqlite3DbFree(db, *pz);
000695    *pz = sqlite3DbStrDup(db, zNew);
000696  }
000697  
000698  /*
000699  ** Call this routine to record the fact that an OOM (out-of-memory) error
000700  ** has happened.  This routine will set db->mallocFailed, and also
000701  ** temporarily disable the lookaside memory allocator and interrupt
000702  ** any running VDBEs.
000703  */
000704  void sqlite3OomFault(sqlite3 *db){
000705    if( db->mallocFailed==0 && db->bBenignMalloc==0 ){
000706      db->mallocFailed = 1;
000707      if( db->nVdbeExec>0 ){
000708        db->u1.isInterrupted = 1;
000709      }
000710      DisableLookaside;
000711      if( db->pParse ){
000712        db->pParse->rc = SQLITE_NOMEM_BKPT;
000713      }
000714    }
000715  }
000716  
000717  /*
000718  ** This routine reactivates the memory allocator and clears the
000719  ** db->mallocFailed flag as necessary.
000720  **
000721  ** The memory allocator is not restarted if there are running
000722  ** VDBEs.
000723  */
000724  void sqlite3OomClear(sqlite3 *db){
000725    if( db->mallocFailed && db->nVdbeExec==0 ){
000726      db->mallocFailed = 0;
000727      db->u1.isInterrupted = 0;
000728      assert( db->lookaside.bDisable>0 );
000729      EnableLookaside;
000730    }
000731  }
000732  
000733  /*
000734  ** Take actions at the end of an API call to indicate an OOM error
000735  */
000736  static SQLITE_NOINLINE int apiOomError(sqlite3 *db){
000737    sqlite3OomClear(db);
000738    sqlite3Error(db, SQLITE_NOMEM);
000739    return SQLITE_NOMEM_BKPT;
000740  }
000741  
000742  /*
000743  ** This function must be called before exiting any API function (i.e. 
000744  ** returning control to the user) that has called sqlite3_malloc or
000745  ** sqlite3_realloc.
000746  **
000747  ** The returned value is normally a copy of the second argument to this
000748  ** function. However, if a malloc() failure has occurred since the previous
000749  ** invocation SQLITE_NOMEM is returned instead. 
000750  **
000751  ** If an OOM as occurred, then the connection error-code (the value
000752  ** returned by sqlite3_errcode()) is set to SQLITE_NOMEM.
000753  */
000754  int sqlite3ApiExit(sqlite3* db, int rc){
000755    /* If the db handle must hold the connection handle mutex here.
000756    ** Otherwise the read (and possible write) of db->mallocFailed 
000757    ** is unsafe, as is the call to sqlite3Error().
000758    */
000759    assert( db!=0 );
000760    assert( sqlite3_mutex_held(db->mutex) );
000761    if( db->mallocFailed || rc==SQLITE_IOERR_NOMEM ){
000762      return apiOomError(db);
000763    }
000764    return rc & db->errMask;
000765  }