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 ** $Id: mem1.c,v 1.25 2008/07/25 08:49:00 danielk1977 Exp $ 21 */ 22 #include "sqliteInt.h" 23 24 /* 25 ** This version of the memory allocator is the default. It is 26 ** used when no other memory allocator is specified using compile-time 27 ** macros. 28 */ 29 #ifdef SQLITE_SYSTEM_MALLOC 30 31 /* 32 ** Like malloc(), but remember the size of the allocation 33 ** so that we can find it later using sqlite3MemSize(). 34 ** 35 ** For this low-level routine, we are guaranteed that nByte>0 because 36 ** cases of nByte<=0 will be intercepted and dealt with by higher level 37 ** routines. 38 */ 39 static void *sqlite3MemMalloc(int nByte){ 40 sqlite3_int64 *p; 41 assert( nByte>0 ); 42 nByte = (nByte+7)&~7; 43 p = malloc( nByte+8 ); 44 if( p ){ 45 p[0] = nByte; 46 p++; 47 } 48 return (void *)p; 49 } 50 51 /* 52 ** Like free() but works for allocations obtained from sqlite3MemMalloc() 53 ** or sqlite3MemRealloc(). 54 ** 55 ** For this low-level routine, we already know that pPrior!=0 since 56 ** cases where pPrior==0 will have been intecepted and dealt with 57 ** by higher-level routines. 58 */ 59 static void sqlite3MemFree(void *pPrior){ 60 sqlite3_int64 *p = (sqlite3_int64*)pPrior; 61 assert( pPrior!=0 ); 62 p--; 63 free(p); 64 } 65 66 /* 67 ** Like realloc(). Resize an allocation previously obtained from 68 ** sqlite3MemMalloc(). 69 ** 70 ** For this low-level interface, we know that pPrior!=0. Cases where 71 ** pPrior==0 while have been intercepted by higher-level routine and 72 ** redirected to xMalloc. Similarly, we know that nByte>0 becauses 73 ** cases where nByte<=0 will have been intercepted by higher-level 74 ** routines and redirected to xFree. 75 */ 76 static void *sqlite3MemRealloc(void *pPrior, int nByte){ 77 sqlite3_int64 *p = (sqlite3_int64*)pPrior; 78 assert( pPrior!=0 && nByte>0 ); 79 nByte = (nByte+7)&~7; 80 p = (sqlite3_int64*)pPrior; 81 p--; 82 p = realloc(p, nByte+8 ); 83 if( p ){ 84 p[0] = nByte; 85 p++; 86 } 87 return (void*)p; 88 } 89 90 /* 91 ** Report the allocated size of a prior return from xMalloc() 92 ** or xRealloc(). 93 */ 94 static int sqlite3MemSize(void *pPrior){ 95 sqlite3_int64 *p; 96 if( pPrior==0 ) return 0; 97 p = (sqlite3_int64*)pPrior; 98 p--; 99 return p[0]; 100 } 101 102 /* 103 ** Round up a request size to the next valid allocation size. 104 */ 105 static int sqlite3MemRoundup(int n){ 106 return (n+7) & ~7; 107 } 108 109 /* 110 ** Initialize this module. 111 */ 112 static int sqlite3MemInit(void *NotUsed){ 113 return SQLITE_OK; 114 } 115 116 /* 117 ** Deinitialize this module. 118 */ 119 static void sqlite3MemShutdown(void *NotUsed){ 120 return; 121 } 122 123 const sqlite3_mem_methods *sqlite3MemGetDefault(void){ 124 static const sqlite3_mem_methods defaultMethods = { 125 sqlite3MemMalloc, 126 sqlite3MemFree, 127 sqlite3MemRealloc, 128 sqlite3MemSize, 129 sqlite3MemRoundup, 130 sqlite3MemInit, 131 sqlite3MemShutdown, 132 0 133 }; 134 return &defaultMethods; 135 } 136 137 /* 138 ** This routine is the only routine in this file with external linkage. 139 ** 140 ** Populate the low-level memory allocation function pointers in 141 ** sqlite3Config.m with pointers to the routines in this file. 142 */ 143 void sqlite3MemSetDefault(void){ 144 sqlite3_config(SQLITE_CONFIG_MALLOC, sqlite3MemGetDefault()); 145 } 146 147 #endif /* SQLITE_SYSTEM_MALLOC */ 148