| //===- BCPoolAllocator.cpp: -----------------------------------------------===// |
| // |
| // The SAFECode Compiler |
| // |
| // This file was developed by the LLVM research group and is distributed under |
| // the University of Illinois Open Source License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This pool allocator registers objects into splay tree to perform memory |
| // access checking. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "PoolAllocator.h" |
| #include <cassert> |
| |
| /* #define DEBUG_OUTPUT */ |
| |
| class BCPoolAllocator { |
| public: |
| typedef PoolTy PoolT; |
| static void * poolalloc(PoolTy *Pool, unsigned NumBytes) { |
| void * ret = __barebone_poolalloc(Pool, NumBytes); |
| #if DEBUG_OUTPUT |
| fprintf(stderr, "Alloc Pool=%p ret=%p/%08x\n", Pool, ret, NumBytes); |
| fflush(stderr); |
| #endif |
| poolregister(Pool, ret, NumBytes); |
| return ret; |
| } |
| |
| static void * pool_alloca(PoolTy * Pool, unsigned int NumBytes) { |
| assert (0 && "Should be deprecated\n"); |
| void * ret = __barebone_pool_alloca(Pool, NumBytes); |
| poolregister(Pool, ret, NumBytes); |
| return ret; |
| } |
| |
| static void poolinit(PoolTy *Pool, unsigned NodeSize) { |
| __barebone_poolinit(Pool, NodeSize); |
| } |
| |
| static void pooldestroy(PoolTy *Pool) { |
| __barebone_pooldestroy(Pool); |
| #if DEBUG_OUTPUT |
| fprintf(stderr, "Destr Pool=%p\n", Pool); |
| fflush(stderr); |
| #endif |
| Pool->Objects.clear(); |
| } |
| |
| static void pool_init_runtime() { |
| // Disable dangling pointer checkings and rewriting of out of bound |
| // pointers |
| ::pool_init_runtime(0, 0, 1); |
| } |
| |
| static void poolfree(PoolTy *Pool, void *Node) { |
| __barebone_poolfree(Pool, Node); |
| #if DEBUG_OUTPUT |
| fprintf(stderr, "Free Pool=%p ret=%p\n", Pool, Node); |
| fflush(stderr); |
| #endif |
| poolunregister(Pool, Node); |
| } |
| }; |
| |
| |
| extern "C" { |
| void __sc_bc_pool_init_runtime(unsigned Dangling, |
| unsigned RewriteOOB, |
| unsigned Terminate) { |
| BCPoolAllocator::pool_init_runtime(); |
| } |
| |
| void __sc_bc_poolinit(PoolTy *Pool, unsigned NodeSize) { |
| #if DEBUG_OUTPUT |
| fprintf(stderr, "Init Pool=%p\n", Pool); |
| fflush(stderr); |
| #endif |
| BCPoolAllocator::poolinit(Pool, NodeSize); |
| } |
| |
| void __sc_bc_pooldestroy(PoolTy *Pool) { |
| #if DEBUG_OUTPUT |
| fprintf(stderr, "Destroy Pool=%p\n", Pool); |
| fflush(stderr); |
| #endif |
| BCPoolAllocator::pooldestroy(Pool); |
| } |
| |
| void * __sc_bc_poolalloc(PoolTy *Pool, unsigned NumBytes) { |
| return BCPoolAllocator::poolalloc(Pool, NumBytes); |
| } |
| |
| void __sc_bc_poolfree(PoolTy *Pool, void *Node) { |
| BCPoolAllocator::poolfree(Pool, Node); |
| } |
| |
| void * __sc_bc_poolrealloc(PoolTy *Pool, void *Node, unsigned NumBytes) { |
| return PoolAllocatorFacade<BCPoolAllocator>::realloc(Pool, Node, NumBytes); |
| } |
| |
| void * __sc_bc_poolcalloc(PoolTy *Pool, unsigned Number, unsigned NumBytes) { |
| return PoolAllocatorFacade<BCPoolAllocator>::calloc(Pool, Number, NumBytes); |
| } |
| |
| void * __sc_bc_poolstrdup(PoolTy *Pool, char *Node) { |
| return PoolAllocatorFacade<BCPoolAllocator>::strdup(Pool, Node); |
| } |
| |
| } |
| |