poolalloc/include/poolalloc/Support/MallocAllocator.h

//===-- llvm/Support/MallocAllocator.h --------------------------*- C++ -*-===//
// 
//                     The LLVM Compiler Infrastructure
//
// 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 file defines MallocAllocator class, an STL compatible allocator which
// just uses malloc/free to get and release memory.  The default allocator uses
// the STL pool allocator runtime library, this explicitly avoids it.
//
// This file is used for variety of purposes, including the pool allocator
// project and testing, regardless of whether or not it's used directly in the
// LLVM code, so don't delete this from CVS if you think it's unused!
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_SUPPORT_MALLOCALLOCATOR_H
#define LLVM_SUPPORT_MALLOCALLOCATOR_H

#include <cstdlib>
#include <cstddef>
#include <memory>

namespace llvm {

template<typename T>
struct MallocAllocator {
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef T* pointer;
  typedef const T* const_pointer;
  typedef T& reference;
  typedef const T& const_reference;
  typedef T value_type;
  template <class U> struct rebind {
    typedef MallocAllocator<U> other;
  };

  template<typename R>
  MallocAllocator(const MallocAllocator<R> &) {}
  MallocAllocator() {}

  pointer address(reference x) const { return &x; }
  const_pointer address(const_reference x) const { return &x; }
  size_type max_size() const { return ~0 / sizeof(T); }
  
  static pointer allocate(size_t n, void* hint = 0) {
    return static_cast<pointer>(malloc(n*sizeof(T)));
  }

  static void deallocate(pointer p, size_t n) {
    free(static_cast<void*>(p));
  }

  void construct(pointer p, const T &val) {
    new(static_cast<void*>(p)) T(val);
  }
  void destroy(pointer p) {
    p->~T();
  }
};

template<typename T>
inline bool operator==(const MallocAllocator<T> &, const MallocAllocator<T> &) {
  return true;
}
template<typename T>
inline bool operator!=(const MallocAllocator<T>&, const MallocAllocator<T>&) {
  return false;
}
} // End llvm namespace

/*
 * This specialization was used for optimization earlier, but doesn't appear
 * to work with newer versions of GCC, Linux or otherwise.
 *
 * This can be re-enabled if desired, but by default, it won't be included.
 */ 
#if 0
namespace std {
  template<typename Type, typename Type2>
  struct _Alloc_traits<Type, ::llvm::MallocAllocator<Type2> > {
    static const bool _S_instanceless = true;
    typedef ::llvm::MallocAllocator<Type> base_alloc_type;
    typedef ::llvm::MallocAllocator<Type> _Alloc_type;
    typedef ::llvm::MallocAllocator<Type> allocator_type;
  };
}
#endif

#endif