src/third_party/sqlite/src/src/mem1.c

   1 /*
   2 ** 2007 August 14
   3 **
   4 ** The author disclaims copyright to this source code.  In place of
   5 ** a legal notice, here is a blessing:
   6 **
   7 **    May you do good and not evil.
   8 **    May you find forgiveness for yourself and forgive others.
   9 **    May you share freely, never taking more than you give.
  10 **
  11 *************************************************************************
  12 **
  13 ** This file contains low-level memory allocation drivers for when
  14 ** SQLite will use the standard C-library malloc/realloc/free interface
  15 ** to obtain the memory it needs.
  16 **
  17 ** This file contains implementations of the low-level memory allocation
  18 ** routines specified in the sqlite3_mem_methods object.
  19 */
  20 #include "sqliteInt.h"
  21
  22 /*
  23 ** This version of the memory allocator is the default.  It is
  24 ** used when no other memory allocator is specified using compile-time
  25 ** macros.
  26 */
  27 #ifdef SQLITE_SYSTEM_MALLOC
  28
  29 /*
  30 ** Like malloc(), but remember the size of the allocation
  31 ** so that we can find it later using sqlite3MemSize().
  32 **
  33 ** For this low-level routine, we are guaranteed that nByte>0 because
  34 ** cases of nByte<=0 will be intercepted and dealt with by higher level
  35 ** routines.
  36 */
  37 static void *sqlite3MemMalloc(int nByte){
  38   sqlite3_int64 *p;
  39   assert( nByte>0 );
  40   nByte = ROUND8(nByte);
  41   p = malloc( nByte+8 );
  42   if( p ){
  43     p[0] = nByte;
  44     p++;
  45   }else{
  46     testcase( sqlite3GlobalConfig.xLog!=0 );
  47     sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte);
  48   }
  49   return (void *)p;
  50 }
  51
  52 /*
  53 ** Like free() but works for allocations obtained from sqlite3MemMalloc()
  54 ** or sqlite3MemRealloc().
  55 **
  56 ** For this low-level routine, we already know that pPrior!=0 since
  57 ** cases where pPrior==0 will have been intecepted and dealt with
  58 ** by higher-level routines.
  59 */
  60 static void sqlite3MemFree(void *pPrior){
  61   sqlite3_int64 *p = (sqlite3_int64*)pPrior;
  62   assert( pPrior!=0 );
  63   p--;
  64   free(p);
  65 }
  66
  67 /*
  68 ** Report the allocated size of a prior return from xMalloc()
  69 ** or xRealloc().
  70 */
  71 static int sqlite3MemSize(void *pPrior){
  72   sqlite3_int64 *p;
  73   if( pPrior==0 ) return 0;
  74   p = (sqlite3_int64*)pPrior;
  75   p--;
  76   return (int)p[0];
  77 }
  78
  79 /*
  80 ** Like realloc().  Resize an allocation previously obtained from
  81 ** sqlite3MemMalloc().
  82 **
  83 ** For this low-level interface, we know that pPrior!=0.  Cases where
  84 ** pPrior==0 while have been intercepted by higher-level routine and
  85 ** redirected to xMalloc.  Similarly, we know that nByte>0 becauses
  86 ** cases where nByte<=0 will have been intercepted by higher-level
  87 ** routines and redirected to xFree.
  88 */
  89 static void *sqlite3MemRealloc(void *pPrior, int nByte){
  90   sqlite3_int64 *p = (sqlite3_int64*)pPrior;
  91   assert( pPrior!=0 && nByte>0 );
  92   assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */
  93   p--;
  94   p = realloc(p, nByte+8 );
  95   if( p ){
  96     p[0] = nByte;
  97     p++;
  98   }else{
  99     testcase( sqlite3GlobalConfig.xLog!=0 );
 100     sqlite3_log(SQLITE_NOMEM,
 101       "failed memory resize %u to %u bytes",
 102       sqlite3MemSize(pPrior), nByte);
 103   }
 104   return (void*)p;
 105 }
 106
 107 /*
 108 ** Round up a request size to the next valid allocation size.
 109 */
 110 static int sqlite3MemRoundup(int n){
 111   return ROUND8(n);
 112 }
 113
 114 /*
 115 ** Initialize this module.
 116 */
 117 static int sqlite3MemInit(void *NotUsed){
 118   UNUSED_PARAMETER(NotUsed);
 119   return SQLITE_OK;
 120 }
 121
 122 /*
 123 ** Deinitialize this module.
 124 */
 125 static void sqlite3MemShutdown(void *NotUsed){
 126   UNUSED_PARAMETER(NotUsed);
 127   return;
 128 }
 129
 130 /*
 131 ** This routine is the only routine in this file with external linkage.
 132 **
 133 ** Populate the low-level memory allocation function pointers in
 134 ** sqlite3GlobalConfig.m with pointers to the routines in this file.
 135 */
 136 void sqlite3MemSetDefault(void){
 137   static const sqlite3_mem_methods defaultMethods = {
 138      sqlite3MemMalloc,
 139      sqlite3MemFree,
 140      sqlite3MemRealloc,
 141      sqlite3MemSize,
 142      sqlite3MemRoundup,
 143      sqlite3MemInit,
 144      sqlite3MemShutdown,
 145      0
 146   };
 147   sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods);
 148 }
 149
 150 #endif /* SQLITE_SYSTEM_MALLOC */