| 1 | /******************************************************************* |
|---|
| 2 | * File: omAlloc.h |
|---|
| 3 | * Purpose: declaration of public routines for omalloc |
|---|
| 4 | * Author: obachman@mathematik.uni-kl.de (Olaf Bachmann) |
|---|
| 5 | * Created: 11/99 |
|---|
| 6 | * Version: $Id: omAlloc.h,v 1.2 1999-11-26 17:57:52 obachman Exp $ |
|---|
| 7 | *******************************************************************/ |
|---|
| 8 | #ifndef OM_ALLOC_H |
|---|
| 9 | #define OM_ALLOC_H |
|---|
| 10 | |
|---|
| 11 | #ifndef OM_USE_EXTERNAL_MALLOC |
|---|
| 12 | /******************************************************************* |
|---|
| 13 | * forward type declarations |
|---|
| 14 | *******************************************************************/ |
|---|
| 15 | struct omBin_s; |
|---|
| 16 | struct omSpecBin_s; |
|---|
| 17 | typedef struct omBin_s omBin_t; |
|---|
| 18 | typedef struct omSpecBin_s omSpecBin_t; |
|---|
| 19 | typedef omBin_t* omBin; |
|---|
| 20 | typedef omSpecBin_t* omSpecBin; |
|---|
| 21 | |
|---|
| 22 | /******************************************************************* |
|---|
| 23 | * |
|---|
| 24 | * Alloc/Free Func |
|---|
| 25 | * |
|---|
| 26 | *******************************************************************/ |
|---|
| 27 | extern void* omFuncAllocBin(omBin bin); |
|---|
| 28 | extern void* omFuncAlloc0Bin(omBin bin); |
|---|
| 29 | extern void omFuncFreeBin(void* addr); |
|---|
| 30 | extern void omFuncPseudoFreeBin(void* addr); |
|---|
| 31 | |
|---|
| 32 | extern void* omFuncAllocBlock(size_t size); |
|---|
| 33 | extern void* omFuncAlloc0Block(size_t size); |
|---|
| 34 | extern void* omFuncReallocBlock(void* addr, size_t old_size, size_t new_size); |
|---|
| 35 | extern void* omFuncReallo0cBlock(void* addr, size_t old_size, size_t new_size); |
|---|
| 36 | extern void* omFuncAllocAlignedBlock(size_t size); |
|---|
| 37 | extern void* omFuncAlloc0AlignedBlock(size_t size); |
|---|
| 38 | extern void* omFuncReallocAlignedBlock(void* addr,size_t old_size,size_t new_size); |
|---|
| 39 | extern void* omFuncRealloc0AlignedBlock(void* addr,size_t old_size,size_t new_size); |
|---|
| 40 | extern void omFuncFreeBlock(void* addr, size_t size); |
|---|
| 41 | extern void* omFuncPseudoReallocBlock(void* addr, size_t old_size, size_t new_size); |
|---|
| 42 | extern void* omFuncPseudoReallo0cBlock(void* addr, size_t old_size, size_t new_size); |
|---|
| 43 | extern void* omFuncPseudoReallocAlignedBlock(void* addr,size_t old_size,size_t new_size); |
|---|
| 44 | extern void* omFuncPseudoRealloc0AlignedBlock(void* addr,size_t old_size,size_t new_size); |
|---|
| 45 | extern void omFuncPseudoFreeBlock(void* addr, size_t size); |
|---|
| 46 | |
|---|
| 47 | extern void* omFuncAllocChunk(size_t size); |
|---|
| 48 | extern void* omFuncAlloc0Chunk(size_t size); |
|---|
| 49 | extern void* omFuncAllocAlignedChunk(size_t size); |
|---|
| 50 | extern void* omFuncAlloc0AlignedChunk(size_t size); |
|---|
| 51 | extern void* omFuncReallocChunk(void* addr, size_t size); |
|---|
| 52 | extern void* omFuncReallocAlignedChunk(void* addr, size_t size); |
|---|
| 53 | extern void omFuncFreeChunk(void* addr); |
|---|
| 54 | extern void omFuncFreeAlignedChunk(void* addr); |
|---|
| 55 | extern void* omFuncPseudoReallocChunk(void* addr, size_t size); |
|---|
| 56 | extern void* omFuncPseudoReallocAlignedChunk(void* addr, size_t size); |
|---|
| 57 | extern void omFuncPseudoFreeChunk(void* addr); |
|---|
| 58 | extern void omFuncPseudoFreeAlignedChunk(void* addr); |
|---|
| 59 | |
|---|
| 60 | /******************************************************************* |
|---|
| 61 | * |
|---|
| 62 | * Alloc/Free Check |
|---|
| 63 | * |
|---|
| 64 | *******************************************************************/ |
|---|
| 65 | extern void* omCheckAllocBin(omBin bin, int level); |
|---|
| 66 | extern void* omCheckAlloc0Bin(omBin bin, int level); |
|---|
| 67 | extern void omCheckFreeBin(void* addr, int level); |
|---|
| 68 | extern void omCheckPseudoFreeBin(void* addr, int level); |
|---|
| 69 | |
|---|
| 70 | extern void* omCheckAllocBlock(size_t size, int level); |
|---|
| 71 | extern void* omCheckAlloc0Block(size_t size, int level); |
|---|
| 72 | extern void* omCheckReallocBlock(void* addr, size_t old_size, size_t new_size, int level); |
|---|
| 73 | extern void* omCheckReallo0cBlock(void* addr, size_t old_size, size_t new_size, int level); |
|---|
| 74 | extern void* omCheckAllocAlignedBlock(size_t size, int level); |
|---|
| 75 | extern void* omCheckAlloc0AlignedBlock(size_t size, int level); |
|---|
| 76 | extern void* omCheckReallocAlignedBlock(void* addr,size_t old_size,size_t new_size, int level); |
|---|
| 77 | extern void* omCheckRealloc0AlignedBlock(void* addr,size_t old_size,size_t new_size, int level); |
|---|
| 78 | extern void omCheckFreeBlock(void* addr, size_t size, int level); |
|---|
| 79 | extern void* omCheckPseudoReallocBlock(void* addr, size_t old_size, size_t new_size, int level); |
|---|
| 80 | extern void* omCheckPseudoReallo0cBlock(void* addr, size_t old_size, size_t new_size, int level); |
|---|
| 81 | extern void* omCheckPseudoReallocAlignedBlock(void* addr,size_t old_size,size_t new_size, int level); |
|---|
| 82 | extern void* omCheckPseudoRealloc0AlignedBlock(void* addr,size_t old_size,size_t new_size, int level); |
|---|
| 83 | extern void omCheckPseudoFreeBlock(void* addr, size_t size, int level); |
|---|
| 84 | |
|---|
| 85 | extern void* omCheckAllocChunk(size_t size, int level); |
|---|
| 86 | extern void* omCheckAlloc0Chunk(size_t size, int level); |
|---|
| 87 | extern void* omCheckAllocAlignedChunk(size_t size, int level); |
|---|
| 88 | extern void* omCheckAlloc0AlignedChunk(size_t size, int level); |
|---|
| 89 | extern void* omCheckReallocChunk(void* addr, size_t size, int level); |
|---|
| 90 | extern void* omCheckReallocAlignedChunk(void* addr, size_t size, int level); |
|---|
| 91 | extern void omCheckFreeChunk(void* addr, int level); |
|---|
| 92 | extern void omCheckFreeAlignedChunk(void* addr, int level); |
|---|
| 93 | extern void* omCheckPseudoReallocChunk(void* addr, size_t size, int level); |
|---|
| 94 | extern void* omCheckPseudoReallocAlignedChunk(void* addr, size_t size, int level); |
|---|
| 95 | extern void omCheckPseudoFreeChunk(void* addr, int level); |
|---|
| 96 | extern void omCheckPseudoFreeAlignedChunk(void* addr, int level); |
|---|
| 97 | |
|---|
| 98 | /* Check of addr/bins -- return NULL if ok, error message, otherwise */ |
|---|
| 99 | extern char* omCheckBinAddr(void* addr, int level); |
|---|
| 100 | extern char* omCheckBin(omBin bin, int level); |
|---|
| 101 | extern char* omCheckAllBins(int level); |
|---|
| 102 | extern char* omCheckBlockAddr(void* addr, size_t size, int level); |
|---|
| 103 | extern char* omCheckAlignedBlockAddr(void* addr, size_t size, int level); |
|---|
| 104 | extern char* omCheckChunkAddr(void* addr); |
|---|
| 105 | extern char* omCheckAlignedChunkAddr(void* addr); |
|---|
| 106 | |
|---|
| 107 | /* CheckReport of addr/bins -- return 1 if ok, otherwise print error and backtrace to stdout |
|---|
| 108 | and return 0 */ |
|---|
| 109 | extern int omCheckReportBinAddr(void* addr, int level); |
|---|
| 110 | extern int omCheckReportBin(omBin bin, int level); |
|---|
| 111 | extern int omCheckReportAllBins(int level); |
|---|
| 112 | extern int omCheckReportBlockAddr(void* addr, size_t size, int level); |
|---|
| 113 | extern int omCheckReportAlignedBlockAddr(void* addr, size_t size, int level); |
|---|
| 114 | extern int omCheckReportChunkAddr(void* addr); |
|---|
| 115 | extern int omCheckReportAlignedChunkAddr(void* addr); |
|---|
| 116 | |
|---|
| 117 | /******************************************************************* |
|---|
| 118 | * |
|---|
| 119 | * Alloc/Free Debug |
|---|
| 120 | * |
|---|
| 121 | *******************************************************************/ |
|---|
| 122 | extern void* omDebugAllocBin(omBin bin, int level); |
|---|
| 123 | extern void* omDebugAlloc0Bin(omBin bin, int level); |
|---|
| 124 | extern void omDebugFreeBin(void* addr, int level); |
|---|
| 125 | extern void omDebugPseudoFreeBin(void* addr, int level); |
|---|
| 126 | |
|---|
| 127 | extern void* omDebugAllocBlock(size_t size, int level); |
|---|
| 128 | extern void* omDebugAlloc0Block(size_t size, int level); |
|---|
| 129 | extern void* omDebugReallocBlock(void* addr, size_t old_size, size_t new_size, int level); |
|---|
| 130 | extern void* omDebugReallo0cBlock(void* addr, size_t old_size, size_t new_size, int level); |
|---|
| 131 | extern void* omDebugAllocAlignedBlock(size_t size, int level); |
|---|
| 132 | extern void* omDebugAlloc0AlignedBlock(size_t size, int level); |
|---|
| 133 | extern void* omDebugReallocAlignedBlock(void* addr,size_t old_size,size_t new_size, int level); |
|---|
| 134 | extern void* omDebugRealloc0AlignedBlock(void* addr,size_t old_size,size_t new_size, int level); |
|---|
| 135 | extern void omDebugFreeBlock(void* addr, size_t size, int level); |
|---|
| 136 | extern void* omDebugPseudoReallocBlock(void* addr, size_t old_size, size_t new_size, int level); |
|---|
| 137 | extern void* omDebugPseudoReallo0cBlock(void* addr, size_t old_size, size_t new_size, int level); |
|---|
| 138 | extern void* omDebugPseudoReallocAlignedBlock(void* addr,size_t old_size,size_t new_size, int level); |
|---|
| 139 | extern void* omDebugPseudoRealloc0AlignedBlock(void* addr,size_t old_size,size_t new_size, int level); |
|---|
| 140 | extern void omDebugPseudoFreeBlock(void* addr, size_t size, int level); |
|---|
| 141 | |
|---|
| 142 | extern void* omDebugAllocChunk(size_t size, int level); |
|---|
| 143 | extern void* omDebugAlloc0Chunk(size_t size, int level); |
|---|
| 144 | extern void* omDebugAllocAlignedChunk(size_t size, int level); |
|---|
| 145 | extern void* omDebugAlloc0AlignedChunk(size_t size, int level); |
|---|
| 146 | extern void* omDebugReallocChunk(void* addr, size_t size, int level); |
|---|
| 147 | extern void* omDebugReallocAlignedChunk(void* addr, size_t size, int level); |
|---|
| 148 | extern void omDebugFreeChunk(void* addr, int level); |
|---|
| 149 | extern void omDebugFreeAlignedChunk(void* addr, int level); |
|---|
| 150 | extern void* omDebugPseudoReallocChunk(void* addr, size_t size, int level); |
|---|
| 151 | extern void* omDebugPseudoReallocAlignedChunk(void* addr, size_t size, int level); |
|---|
| 152 | extern void omDebugPseudoFreeChunk(void* addr, int level); |
|---|
| 153 | extern void omDebugPseudoFreeAlignedChunk(void* addr, int level); |
|---|
| 154 | |
|---|
| 155 | /* Debug of addr/bins -- return NULL if ok, error message, otherwise */ |
|---|
| 156 | extern char* omDebugBinAddr(void* addr, int level); |
|---|
| 157 | extern char* omDebugBin(omBin bin, int level); |
|---|
| 158 | extern char* omDebugAllBins(int level); |
|---|
| 159 | extern char* omDebugBlockAddr(void* addr, size_t size, int level); |
|---|
| 160 | extern char* omDebugAlignedBlockAddr(void* addr, size_t size, int level); |
|---|
| 161 | extern char* omDebugChunkAddr(void* addr); |
|---|
| 162 | extern char* omDebugAlignedChunkAddr(void* addr); |
|---|
| 163 | |
|---|
| 164 | /* DebugReport of addr/bins -- return 1 if ok, otherwise print error and current stack |
|---|
| 165 | backtrace to stderr and return 0 */ |
|---|
| 166 | extern int omDebugReportBinAddr(void* addr, int level); |
|---|
| 167 | extern int omDebugReportBin(omBin bin, int level); |
|---|
| 168 | extern int omDebugReportAllBins(int level); |
|---|
| 169 | extern int omDebugReportBlockAddr(void* addr, size_t size, int level); |
|---|
| 170 | extern int omDebugReportAlignedBlockAddr(void* addr, size_t size, int level); |
|---|
| 171 | extern int omDebugReportChunkAddr(void* addr); |
|---|
| 172 | extern int omDebugReportAlignedChunkAddr(void* addr); |
|---|
| 173 | |
|---|
| 174 | /******************************************************************* |
|---|
| 175 | * |
|---|
| 176 | * om Alloc/Free Macro definitions |
|---|
| 177 | * |
|---|
| 178 | *******************************************************************/ |
|---|
| 179 | |
|---|
| 180 | #if definded(OM_DEBUG) && OM_DEBUG != 0 |
|---|
| 181 | /******************************************************************* |
|---|
| 182 | * Alloc/Free for Debug |
|---|
| 183 | *******************************************************************/ |
|---|
| 184 | |
|---|
| 185 | #define omTypeAllocBin(type, addr, bin) addr = (type) omDebugAllocBin(bin, OM_DEBUG) |
|---|
| 186 | #define omTypeAlloc0Bin(type, addr, bin) addr = (type) omDebugAlloc0Bin(bin, OM_DEBUG) |
|---|
| 187 | #define omAllocBin(bin) omDebugAllocBin(bin, OM_DEBUG) |
|---|
| 188 | #define omAlloc0Bin(bin) omDebugAlloc0Bin(bin, OM_DEBUG) |
|---|
| 189 | #if defined(OM_PSEUDO_FREE) && OM_PSEUDO_FREE != 0 |
|---|
| 190 | #define omFreeBin(addr) omDebugPseudoFreeBin(addr, OM_DEBUG) |
|---|
| 191 | #else |
|---|
| 192 | #define omFreeBin(addr) omDebugFreeBin(addr, OM_DEBUG) |
|---|
| 193 | #endif |
|---|
| 194 | |
|---|
| 195 | #define omTypeAllocBlock(type, addr, size) addr = (type) omDebugAllocBlock(size, OM_DEBUG) |
|---|
| 196 | #define omTypeAlloc0Block(type, addr, size) addr = (type) omDebugAlloc0Block(size, OM_DEBUG) |
|---|
| 197 | #define omAllocBlock(size) omDebugAllocBlock(size, OM_DEBUG) |
|---|
| 198 | #define omAlloc0Block(size) omDebugAlloc0Block(size, OM_DEBUG) |
|---|
| 199 | #define omTypeAllocAlignedBlock(type, addr, size) addr = (type) omDebugAllocAlignedBlock(size, OM_DEBUG) |
|---|
| 200 | #define omTypeAlloc0AlignedBlock(type, addr, size) addr = (type) omDebugAlloc0AlignedBlock(size, OM_DEBUG) |
|---|
| 201 | #define omAllocAlignedBlock(size) omDebugAllocAlignedBlock(size, OM_DEBUG) |
|---|
| 202 | #define omAlloc0AlignedBlock(size) omDebugAlloc0AlignedBlock(size, OM_DEBUG) |
|---|
| 203 | #if defined(OM_PSEUDO_FREE) && OM_PSEUDO_FREE != 0 |
|---|
| 204 | #define omReallocBlock(addr, old_size, new_size) omDebugPseudoReallocBlock(addr, old_size, new_size, OM_DEBUG) |
|---|
| 205 | #define omRealloc0Block(addr, old_size, new_size) omDebugPseudoRealloc0Block(addr, old_size, new_size, OM_DEBUG) |
|---|
| 206 | #define omReallocAlignedBlock(addr, old_size, new_size) omDebugPseudoReallocAlignedBlock(addr, old_size, new_size, OM_DEBUG) |
|---|
| 207 | #define omRealloc0AlignedBlock(addr, old_size, new_size) omDebugPseudoRealloc0AlignedBlock(addr, old_size, new_size, OM_DEBUG) |
|---|
| 208 | #define omFreeBlock(addr, size) omDebugPseudoFreeBlock(addr, size, OM_DEBUG) |
|---|
| 209 | #else |
|---|
| 210 | #define omReallocBlock(addr, old_size, new_size) omDebugReallocBlock(addr, old_size, new_size, OM_DEBUG) |
|---|
| 211 | #define omRealloc0Block(addr, old_size, new_size) omDebugRealloc0Block(addr, old_size, new_size, OM_DEBUG) |
|---|
| 212 | #define omReallocAlignedBlock(addr, old_size, new_size) omDebugReallocAlignedBlock(addr, old_size, new_size, OM_DEBUG) |
|---|
| 213 | #define omRealloc0AlignedBlock(addr, old_size, new_size) omDebugRealloc0AlignedBlock(addr, old_size, new_size, OM_DEBUG) |
|---|
| 214 | #define omFreeBlock(addr, size) omDebugFreeBlock(addr, size, OM_DEBUG) |
|---|
| 215 | #endif |
|---|
| 216 | |
|---|
| 217 | #define omTypeAllocChunk(type, addr, size) addr = (type) omDebugAllocChunk(size, OM_DEBUG) |
|---|
| 218 | #define omTypeAlloc0Chunk(type, addr, size) addr = (type) omDebugAlloc0Chunk(size, OM_DEBUG) |
|---|
| 219 | #define omAllocChunk(size) omDebugAllocChunk(size, OM_DEBUG) |
|---|
| 220 | #define omAlloc0Chunk(size) omDebugAlloc0Chunk(size, OM_DEBUG) |
|---|
| 221 | #define omTypeAllocAlignedChunk(type, addr, size) addr = (type) omDebugAllocAlignedChunk(size, OM_DEBUG) |
|---|
| 222 | #define omTypeAlloc0AlignedChunk(type, addr, size) addr = (type) omDebugAlloc0AlignedChunk(size, OM_DEBUG) |
|---|
| 223 | #define omAllocAlignedChunk(size) omDebugAllocAlignedChunk(size, OM_DEBUG) |
|---|
| 224 | #define omAlloc0AlignedChunk(size) omDebugAlloc0AlignedChunk(size, OM_DEBUG) |
|---|
| 225 | #if defined(OM_PSEUDO_FREE) && OM_PSEUDO_FREE != 0 |
|---|
| 226 | #define omReallocChunk(addr, new_size) omDebugPseudoReallocChunk(addr, new_size, OM_DEBUG) |
|---|
| 227 | #define omReallocAlignedChunk(addr, new_size) omDebugPseudoReallocAlignedChunk(addr, new_size, OM_DEBUG) |
|---|
| 228 | #define omFreeChunk(addr) omDebugPseudoFreeChunk(addr, OM_DEBUG) |
|---|
| 229 | #define omFreeAlignedChunk(addr) omDebugPseudoFreeAlignedChunk(addr, OM_DEBUG) |
|---|
| 230 | #else |
|---|
| 231 | #define omReallocChunk(addr, new_size) omDebugReallocChunk(addr, new_size, OM_DEBUG) |
|---|
| 232 | #define omReallocAlignedChunk(addr, new_size) omDebugReallocAlignedChunk(addr, new_size, OM_DEBUG) |
|---|
| 233 | #define omFreeChunk(addr) omDebugFreeChunk(addr, OM_DEBUG) |
|---|
| 234 | #define omFreeAlignedChunk(addr) omDebugFreeAlignedChunk(addr, OM_DEBUG) |
|---|
| 235 | #endif |
|---|
| 236 | |
|---|
| 237 | |
|---|
| 238 | #define omTestBinAddr(addr) omDebugBinAddr(addr, OM_DEBUG) |
|---|
| 239 | #define omTestBlockAddr(addr, size) omDebugBlockAddr(addr, size, OM_DEBUG) |
|---|
| 240 | #define omTestAlignedBlockAddr(addr, size) omDebugAlignedBlockAddr(addr, size, OM_DEBUG) |
|---|
| 241 | #define omTestChunkAddr(addr) omDebugBlockAddr(addr, size, OM_DEBUG) |
|---|
| 242 | #define omTestAlignedChunkAddr(addr) omDebugAlignedBlockAddr(addr, size, OM_DEBUG) |
|---|
| 243 | |
|---|
| 244 | #define omTestReportBinAddr(addr) omDebugReportBinAddr(addr, OM_DEBUG) |
|---|
| 245 | #define omTestReportBlockAddr(addr, size) omDebugReportBlockAddr(addr, size, OM_DEBUG) |
|---|
| 246 | #define omTestReportAlignedBlockAddr(addr, size) omDebugReportAlignedBlockAddr(addr, size, OM_DEBUG) |
|---|
| 247 | #define omTestReportChunkAddr(addr) omDebugReportBlockAddr(addr, size, OM_DEBUG) |
|---|
| 248 | #define omTestReportAlignedChunkAddr(addr) omDebugReportAlignedBlockAddr(addr, size, OM_DEBUG) |
|---|
| 249 | |
|---|
| 250 | #define omTestUsedAddrs() omDebugUsedAddrs(OM_DEBUG) |
|---|
| 251 | #define omTestFreeAddrs() omDebugFreeAddrs(OM_DEBUG) |
|---|
| 252 | #define omTestAllAddrs() omDebugAllAddrs(OM_DEBUG) |
|---|
| 253 | #define omTestReportUsedAddrs() omDebugReportUsedAddrs(OM_DEBUG) |
|---|
| 254 | #define omTestReportFreeAddrs() omDebugReportFreeAddrs(OM_DEBUG) |
|---|
| 255 | #define omTestReportAllAddrs() omDebugReportAllAddrs(OM_DEBUG) |
|---|
| 256 | |
|---|
| 257 | #elsif defined(OM_CHECK) && OM_CHECK != 0 |
|---|
| 258 | /******************************************************************* |
|---|
| 259 | * Alloc/Free for Check |
|---|
| 260 | *******************************************************************/ |
|---|
| 261 | |
|---|
| 262 | #define omTypeAllocBin(type, addr, bin) addr = (type) omCheckAllocBin(bin, OM_DEBUG) |
|---|
| 263 | #define omTypeAlloc0Bin(type, addr, bin) addr = (type) omCheckAlloc0Bin(bin, OM_DEBUG) |
|---|
| 264 | #define omAllocBin(bin) omCheckAllocBin(bin, OM_DEBUG) |
|---|
| 265 | #define omAlloc0Bin(bin) omCheckAlloc0Bin(bin, OM_DEBUG) |
|---|
| 266 | #if defined(OM_PSEUDO_FREE) && OM_PSEUDO_FREE != 0 |
|---|
| 267 | #define omFreeBin(addr) omCheckPseudoFreeBin(addr, OM_DEBUG) |
|---|
| 268 | #else |
|---|
| 269 | #define omFreeBin(addr) omCheckFreeBin(addr, OM_DEBUG) |
|---|
| 270 | #endif |
|---|
| 271 | |
|---|
| 272 | #define omTypeAllocBlock(type, addr, size) addr = (type) omCheckAllocBlock(size, OM_DEBUG) |
|---|
| 273 | #define omTypeAlloc0Block(type, addr, size) addr = (type) omCheckAlloc0Block(size, OM_DEBUG) |
|---|
| 274 | #define omAllocBlock(size) omCheckAllocBlock(size, OM_DEBUG) |
|---|
| 275 | #define omAlloc0Block(size) omCheckAlloc0Block(size, OM_DEBUG) |
|---|
| 276 | #define omTypeAllocAlignedBlock(type, addr, size) addr = (type) omCheckAllocAlignedBlock(size, OM_DEBUG) |
|---|
| 277 | #define omTypeAlloc0AlignedBlock(type, addr, size) addr = (type) omCheckAlloc0AlignedBlock(size, OM_DEBUG) |
|---|
| 278 | #define omAllocAlignedBlock(size) omCheckAllocAlignedBlock(size, OM_DEBUG) |
|---|
| 279 | #define omAlloc0AlignedBlock(size) omCheckAlloc0AlignedBlock(size, OM_DEBUG) |
|---|
| 280 | #if defined(OM_PSEUDO_FREE) && OM_PSEUDO_FREE != 0 |
|---|
| 281 | #define omReallocBlock(addr, old_size, new_size) omCheckPseudoReallocBlock(addr, old_size, new_size, OM_DEBUG) |
|---|
| 282 | #define omRealloc0Block(addr, old_size, new_size) omCheckPseudoRealloc0Block(addr, old_size, new_size, OM_DEBUG) |
|---|
| 283 | #define omReallocAlignedBlock(addr, old_size, new_size) omCheckPseudoReallocAlignedBlock(addr, old_size, new_size, OM_DEBUG) |
|---|
| 284 | #define omRealloc0AlignedBlock(addr, old_size, new_size) omCheckPseudoRealloc0AlignedBlock(addr, old_size, new_size, OM_DEBUG) |
|---|
| 285 | #define omFreeBlock(addr, size) omCheckPseudoFreeBlock(addr, size, OM_DEBUG) |
|---|
| 286 | #else |
|---|
| 287 | #define omReallocBlock(addr, old_size, new_size) omCheckReallocBlock(addr, old_size, new_size, OM_DEBUG) |
|---|
| 288 | #define omRealloc0Block(addr, old_size, new_size) omCheckRealloc0Block(addr, old_size, new_size, OM_DEBUG) |
|---|
| 289 | #define omReallocAlignedBlock(addr, old_size, new_size) omCheckReallocAlignedBlock(addr, old_size, new_size, OM_DEBUG) |
|---|
| 290 | #define omRealloc0AlignedBlock(addr, old_size, new_size) omCheckRealloc0AlignedBlock(addr, old_size, new_size, OM_DEBUG) |
|---|
| 291 | #define omFreeBlock(addr, size) omCheckFreeBlock(addr, size, OM_DEBUG) |
|---|
| 292 | #endif |
|---|
| 293 | |
|---|
| 294 | #define omTypeAllocChunk(type, addr, size) addr = (type) omCheckAllocChunk(size, OM_DEBUG) |
|---|
| 295 | #define omTypeAlloc0Chunk(type, addr, size) addr = (type) omCheckAlloc0Chunk(size, OM_DEBUG) |
|---|
| 296 | #define omAllocChunk(size) omCheckAllocChunk(size, OM_DEBUG) |
|---|
| 297 | #define omAlloc0Chunk(size) omCheckAlloc0Chunk(size, OM_DEBUG) |
|---|
| 298 | #define omTypeAllocAlignedChunk(type, addr, size) addr = (type) omCheckAllocAlignedChunk(size, OM_DEBUG) |
|---|
| 299 | #define omTypeAlloc0AlignedChunk(type, addr, size) addr = (type) omCheckAlloc0AlignedChunk(size, OM_DEBUG) |
|---|
| 300 | #define omAllocAlignedChunk(size) omCheckAllocAlignedChunk(size, OM_DEBUG) |
|---|
| 301 | #define omAlloc0AlignedChunk(size) omCheckAlloc0AlignedChunk(size, OM_DEBUG) |
|---|
| 302 | #if defined(OM_PSEUDO_FREE) && OM_PSEUDO_FREE != 0 |
|---|
| 303 | #define omReallocChunk(addr, new_size) omCheckPseudoReallocChunk(addr, new_size, OM_DEBUG) |
|---|
| 304 | #define omReallocAlignedChunk(addr, new_size) omCheckPseudoReallocAlignedChunk(addr, new_size, OM_DEBUG) |
|---|
| 305 | #define omFreeChunk(addr) omCheckPseudoFreeChunk(addr, OM_DEBUG) |
|---|
| 306 | #define omFreeAlignedChunk(addr) omCheckPseudoFreeAlignedChunk(addr, OM_DEBUG) |
|---|
| 307 | #else |
|---|
| 308 | #define omReallocChunk(addr, new_size) omCheckReallocChunk(addr, new_size, OM_DEBUG) |
|---|
| 309 | #define omReallocAlignedChunk(addr, new_size) omCheckReallocAlignedChunk(addr, new_size, OM_DEBUG) |
|---|
| 310 | #define omFreeChunk(addr) omCheckFreeChunk(addr, OM_DEBUG) |
|---|
| 311 | #define omFreeAlignedChunk(addr) omCheckFreeAlignedChunk(addr, OM_DEBUG) |
|---|
| 312 | #endif |
|---|
| 313 | |
|---|
| 314 | |
|---|
| 315 | #define omTestBinAddr(addr) omCheckBinAddr(addr, OM_DEBUG) |
|---|
| 316 | #define omTestBlockAddr(addr, size) omCheckBlockAddr(addr, size, OM_DEBUG) |
|---|
| 317 | #define omTestAlignedBlockAddr(addr, size) omCheckAlignedBlockAddr(addr, size, OM_DEBUG) |
|---|
| 318 | #define omTestChunkAddr(addr) omCheckBlockAddr(addr, size, OM_DEBUG) |
|---|
| 319 | #define omTestAlignedChunkAddr(addr) omCheckAlignedBlockAddr(addr, size, OM_DEBUG) |
|---|
| 320 | |
|---|
| 321 | #define omTestReportBinAddr(addr) omCheckReportBinAddr(addr, OM_DEBUG) |
|---|
| 322 | #define omTestReportBlockAddr(addr, size) omCheckReportBlockAddr(addr, size, OM_DEBUG) |
|---|
| 323 | #define omTestReportAlignedBlockAddr(addr, size) omCheckReportAlignedBlockAddr(addr, size, OM_DEBUG) |
|---|
| 324 | #define omTestReportChunkAddr(addr) omCheckReportBlockAddr(addr, size, OM_DEBUG) |
|---|
| 325 | #define omTestReportAlignedChunkAddr(addr) omCheckReportAlignedBlockAddr(addr, size, OM_DEBUG) |
|---|
| 326 | |
|---|
| 327 | #define omTestUsedAddrs() omCheckUsedAddrs(OM_DEBUG) |
|---|
| 328 | #define omTestFreeAddrs() omCheckFreeAddrs(OM_DEBUG) |
|---|
| 329 | #define omTestAllAddrs() omCheckAllAddrs(OM_DEBUG) |
|---|
| 330 | #define omTestReportUsedAddrs() omCheckReportUsedAddrs(OM_DEBUG) |
|---|
| 331 | #define omTestReportFreeAddrs() omCheckReportFreeAddrs(OM_DEBUG) |
|---|
| 332 | #define omTestReportAllAddrs() omCheckReportAllAddrs(OM_DEBUG) |
|---|
| 333 | |
|---|
| 334 | |
|---|
| 335 | #else |
|---|
| 336 | /******************************************************************* |
|---|
| 337 | * Alloc/Free -- the real thing |
|---|
| 338 | *******************************************************************/ |
|---|
| 339 | |
|---|
| 340 | #define omTypeAllocBin(type, addr, bin) __omTypeAllocBin(type, addr, bin) |
|---|
| 341 | #define omTypeAlloc0Bin(type, addr, bin) __omTypeAllocBin(type, addr, bin) |
|---|
| 342 | #define omAllocBin(bin) _omAllocBin(bin) |
|---|
| 343 | #define omAlloc0Bin(bin) _omAlloc0Bin(bin) |
|---|
| 344 | #if defined(OM_PSEUDO_FREE) && OM_PSEUDO_FREE != 0 |
|---|
| 345 | #define omFreeBin(addr) _omPseudoFreeBin(addr) |
|---|
| 346 | #else |
|---|
| 347 | #define omFreeBin(addr) __omFreeBin(addr) |
|---|
| 348 | #endif |
|---|
| 349 | |
|---|
| 350 | #define omTypeAllocBlock(type, addr, size) __omTypeAllocBlock(type, addr, size) |
|---|
| 351 | #define omTypeAlloc0Block(type, addr, size) __omTypeAlloc0Block(type, addr, size) |
|---|
| 352 | #define omAllocBlock(size) _omAllocBlock(size) |
|---|
| 353 | #define omAlloc0Block(size) _omAlloc0Block(size) |
|---|
| 354 | #define omTypeAllocAlignedBlock(type, addr, size) __omTypeAllocAlignedBlock(type, addr, size) |
|---|
| 355 | #define omTypeAlloc0AlignedBlock(type, addr, size) __omTypeAlloc0AlignedBlock(type, addr, size) |
|---|
| 356 | #define omAllocAlignedBlock(size) _omAllocAlignedBlock(size) |
|---|
| 357 | #define omAlloc0AlignedBlock(size) _omAlloc0AlignedBlock(size) |
|---|
| 358 | #if defined(OM_PSEUDO_FREE) && OM_PSEUDO_FREE != 0 |
|---|
| 359 | #define omReallocBlock(addr, old_size, new_size) _omPseudoReallocBlock(addr, old_size, new_size) |
|---|
| 360 | #define omRealloc0Block(addr, old_size, new_size) _omPseudoRealloc0Block(addr, old_size, new_size) |
|---|
| 361 | #define omReallocAlignedBlock(addr, old_size, new_size) _omPseudoReallocAlignedBlock(addr, old_size, new_size) |
|---|
| 362 | #define omRealloc0AlignedBlock(addr, old_size, new_size) _omPseudoRealloc0AlignedBlock(addr, old_size, new_size) |
|---|
| 363 | #define omFreeBlock(addr, size) _omPseudoFreeBlock(addr, size) |
|---|
| 364 | #else |
|---|
| 365 | #define omReallocBlock(addr, old_size, new_size) _omReallocBlock(addr, old_size, new_size) |
|---|
| 366 | #define omRealloc0Block(addr, old_size, new_size) _omRealloc0Block(addr, old_size, new_size) |
|---|
| 367 | #define omReallocAlignedBlock(addr, old_size, new_size) _omReallocAlignedBlock(addr, old_size, new_size) |
|---|
| 368 | #define omRealloc0AlignedBlock(addr, old_size, new_size) _omRealloc0AlignedBlock(addr, old_size, new_size) |
|---|
| 369 | #define omFreeBlock(addr, size) __FreeBlock(addr, size) |
|---|
| 370 | #endif |
|---|
| 371 | |
|---|
| 372 | #define omTypeAllocChunk(type, addr, size) __omAllocChunk(type, addr, size) |
|---|
| 373 | #define omTypeAlloc0Chunk(type, addr, size) __omAlloc0Chunk(type, addr, size) |
|---|
| 374 | #define omAllocChunk(size) _omAllocChunk(size) |
|---|
| 375 | #define omAlloc0Chunk(size) _omAlloc0Chunk(size) |
|---|
| 376 | #define omTypeAllocAlignedChunk(type, addr, size) __omTypeAllocAlignedChunk(type, addr, size) |
|---|
| 377 | #define omTypeAlloc0AlignedChunk(type, addr, size) __omTypeAlloc0AlignedChunk(type, addr, size) |
|---|
| 378 | #define omAllocAlignedChunk(size) _omAllocAlignedChunk(size) |
|---|
| 379 | #define omAlloc0AlignedChunk(size) _omAllocAlignedChunk(size) |
|---|
| 380 | #if defined(OM_PSEUDO_FREE) && OM_PSEUDO_FREE != 0 |
|---|
| 381 | #define omReallocChunk(addr, new_size) _omPseudoReallocChunk(addr, new_size) |
|---|
| 382 | #define omReallocAlignedChunk(addr, new_size) _omPseudoReallocAlignedChunk(addr, new_size) |
|---|
| 383 | #define omFreeChunk(addr) _omPseudoFreeChunk(addr) |
|---|
| 384 | #define omFreeAlignedChunk(addr) _omPseudoFreeAlignedChunk(addr) |
|---|
| 385 | #else |
|---|
| 386 | #define omReallocChunk(addr, new_size) _omReallocChunk(addr, new_size) |
|---|
| 387 | #define omReallocAlignedChunk(addr, new_size) _omReallocAlignedChunk(addr, new_size) |
|---|
| 388 | #define omFreeChunk(addr) _omFreeChunk(addr) |
|---|
| 389 | #define omFreeAlignedChunk(addr) _omFreeAlignedChunk(addr) |
|---|
| 390 | #endif |
|---|
| 391 | |
|---|
| 392 | |
|---|
| 393 | #define omTestBinAddr(addr) (NULL) |
|---|
| 394 | #define omTestBlockAddr(addr, size) (NULL) |
|---|
| 395 | #define omTestAlignedBlockAddr(addr, size) (NULL) |
|---|
| 396 | #define omTestChunkAddr(addr) (NULL) |
|---|
| 397 | #define omTestAlignedChunkAddr(addr) (NULL) |
|---|
| 398 | |
|---|
| 399 | #define omTestReportBinAddr(addr) (1) |
|---|
| 400 | #define omTestReportBlockAddr(addr, size) (1) |
|---|
| 401 | #define omTestReportAlignedBlockAddr(addr, size) (1) |
|---|
| 402 | #define omTestReportChunkAddr(addr) (1) |
|---|
| 403 | #define omTestReportAlignedChunkAddr(addr) (1) |
|---|
| 404 | |
|---|
| 405 | #define omTestUsedAddrs() (NULL) |
|---|
| 406 | #define omTestFreeAddrs() (NULL) |
|---|
| 407 | #define omTestAllAddrs() (NULL) |
|---|
| 408 | #define omTestReportUsedAddrs() (1) |
|---|
| 409 | #define omTestReportFreeAddrs() (1) |
|---|
| 410 | #define omTestReportAllAddrs() (1) |
|---|
| 411 | |
|---|
| 412 | #endif /* om Macro definitions */ |
|---|
| 413 | |
|---|
| 414 | /******************************************************************* |
|---|
| 415 | * |
|---|
| 416 | * Bin stuff |
|---|
| 417 | * |
|---|
| 418 | *******************************************************************/ |
|---|
| 419 | omBin omGetSpecBin(size_t size); |
|---|
| 420 | omBin omGetAlignedSpecBin(size_t size); |
|---|
| 421 | void omUnGetSpecBin(omBin *bin); |
|---|
| 422 | |
|---|
| 423 | unsigned long omGetNewStickyBinTag(omBin bin); |
|---|
| 424 | void omSetStickyBinTag(omBin bin, unsigned long sticky); |
|---|
| 425 | void omUnSetStickyBinTag(omBin bin, unsigned long sticky); |
|---|
| 426 | void omDeleteStickyBinTag(omBin bin, unsigned long sticky); |
|---|
| 427 | |
|---|
| 428 | unsigned long omGetNewStickyAllBinTag(); |
|---|
| 429 | void omSetStickyAllBinTag(omBin bin, unsigned long sticky); |
|---|
| 430 | void omUnSetStickyAllBinTag(omBin bin, unsigned long sticky); |
|---|
| 431 | void omDeleteStickyAllBinTag(omBin bin, unsigned long sticky); |
|---|
| 432 | |
|---|
| 433 | #include <stdio.h> |
|---|
| 434 | extern void omPrintBinStats(FILE* fd); |
|---|
| 435 | extern void omPrintBinStat(FILE * fd, omBin bin); |
|---|
| 436 | |
|---|
| 437 | |
|---|
| 438 | |
|---|
| 439 | #else /* OM_USE_EXTERNAL_MALLOC */ |
|---|
| 440 | |
|---|
| 441 | /******************************************************************* |
|---|
| 442 | * |
|---|
| 443 | * Alternative set of defines |
|---|
| 444 | * |
|---|
| 445 | *******************************************************************/ |
|---|
| 446 | typedef size_t omBin; |
|---|
| 447 | typedef size_t omSpecBin; |
|---|
| 448 | |
|---|
| 449 | #define omTypeAllocBin(type, addr, bin) addr = (type) malloc(bin) |
|---|
| 450 | #define omTypeAlloc0Bin(type, addr, bin) do {addr = (type) malloc(bin); memset(addr, 0, bin);} while(0) |
|---|
| 451 | #define omAllocBin(bin) malloc(bin) |
|---|
| 452 | #define omAlloc0Bin(bin) omAlternativeMalloc0(bin) |
|---|
| 453 | #define omFreeBin(addr) free(addr) |
|---|
| 454 | |
|---|
| 455 | #define omTypeAllocBlock(type, addr, size) addr = (type) malloc(size) |
|---|
| 456 | #define omTypeAlloc0Block(type, addr, size) do {addr = (type) malloc(size); memset(addr, 0, size);} while(0) |
|---|
| 457 | #define omAllocBlock(size) malloc(size) |
|---|
| 458 | #define omAlloc0Block(size) omAlternativeMalloc0(size) |
|---|
| 459 | #define omTypeAllocAlignedBlock(type, addr, size) addr = (type) malloc(size) |
|---|
| 460 | #define omTypeAlloc0AlignedBlock(type, addr, size) do {addr = (type) malloc(size); memset(addr, 0, size);} while(0) |
|---|
| 461 | #define omAllocAlignedBlock(size) malloc(size) |
|---|
| 462 | #define omAlloc0AlignedBlock(size) omAlternativeMalloc0(size) |
|---|
| 463 | #define omReallocBlock(addr, old_size, new_size) realloc(addr, new_size) |
|---|
| 464 | #define omRealloc0Block(addr, old_size, new_size) omAlternativeRealloc0Block(addr, old_size, new_size) |
|---|
| 465 | #define omReallocAlignedBlock(addr, old_size, new_size) realloc(addr, new_size) |
|---|
| 466 | #define omRealloc0AlignedBlock(addr, old_size, new_size) omAlternativeRealloc0Block(addr, old_size, new_size) |
|---|
| 467 | #define omFreeBlock(addr, size) free(addr) |
|---|
| 468 | |
|---|
| 469 | #define omTypeAllocChunk(type, addr, size) addr = (type) malloc(size) |
|---|
| 470 | #define omTypeAlloc0Chunk(type, addr, size) do {addr = (type) malloc(size); memset(addr, 0, size);} while(0) |
|---|
| 471 | #define omAllocChunk(size) malloc(size) |
|---|
| 472 | #define omAlloc0Chunk(size) omAlternativeMalloc0(size) |
|---|
| 473 | #define omTypeAllocAlignedChunk(type, addr, size) addr = (type) malloc(size) |
|---|
| 474 | #define omTypeAlloc0AlignedChunk(type, addr, size) do {addr = (type) malloc(size); memset(addr, 0, size);} while(0) |
|---|
| 475 | #define omAllocAlignedChunk(size) malloc(size) |
|---|
| 476 | #define omAlloc0AlignedChunk(size) omAlternativeMalloc0(size) |
|---|
| 477 | #define omReallocChunk(addr, new_size) realloc(addr, new_size) |
|---|
| 478 | #define omAlignedReallocChunk(addr, new_size) realloc(addr, new_size) |
|---|
| 479 | #define omFreeChunk(addr) free(addr) |
|---|
| 480 | #define omFreeAlignedChunk(addr) free(addr) |
|---|
| 481 | |
|---|
| 482 | |
|---|
| 483 | #define omTestBinAddr(addr) (NULL) |
|---|
| 484 | #define omTestBlockAddr(addr, size) (NULL) |
|---|
| 485 | #define omTestAlignedBlockAddr(addr, size) (NULL) |
|---|
| 486 | #define omTestChunkAddr(addr) (NULL) |
|---|
| 487 | #define omTestAlignedChunkAddr(addr) (NULL) |
|---|
| 488 | |
|---|
| 489 | #define omTestReportBinAddr(addr) (1) |
|---|
| 490 | #define omTestReportBlockAddr(addr, size) (1) |
|---|
| 491 | #define omTestReportAlignedBlockAddr(addr, size) (1) |
|---|
| 492 | #define omTestReportChunkAddr(addr) (1) |
|---|
| 493 | #define omTestReportAlignedChunkAddr(addr) (1) |
|---|
| 494 | |
|---|
| 495 | #define omTestUsedAddrs() (NULL) |
|---|
| 496 | #define omTestFreeAddrs() (NULL) |
|---|
| 497 | #define omTestAllAddrs() (NULL) |
|---|
| 498 | #define omTestReportUsedAddrs() (1) |
|---|
| 499 | #define omTestReportFreeAddrs() (1) |
|---|
| 500 | #define omTestReportAllAddrs() (1) |
|---|
| 501 | |
|---|
| 502 | #endif /* OM_USE_EXTERNAL_MALLOC */ |
|---|
| 503 | |
|---|
| 504 | #endif /* OM_ALLOC_H */ |
|---|
