gc-alloc.hh

#pragma once
 
#include <cstddef>
#include <cstring>
#include <list>
#include <map>
#include <new>
#include <string_view>
#include <vector>
 
#include "lix/libutil/checked-arithmetic.hh"
 
#if HAVE_BOEHMGC
#define GC_INCLUDE_NEW
#include <gc/gc.h>
#include <gc/gc_allocator.h>
#include <gc/gc_cpp.h>

#define LIX_GC_CALLOC(size) GC_MALLOC(size)

#define LIX_GC_STRDUP(str) GC_STRDUP(str)

#define LIX_GC_MALLOC_ATOMIC(size) GC_MALLOC_ATOMIC(size)
 
namespace nix
{
 
template<typename T>
using TraceableAllocator = traceable_allocator<T>;
 
}
 
#else
 
#include <cstdlib>

#define LIX_GC_CALLOC(size) calloc(size, 1)

#define LIX_GC_STRDUP(str) strdup(str)

#define LIX_GC_MALLOC_ATOMIC(size) malloc(size)
 
namespace nix
{
 
template<typename T>
using TraceableAllocator = std::allocator<T>;
 
}
 
#endif
 
namespace nix
{

template<typename KeyT, typename ValueT>
using GcMap = std::map<
    KeyT,
    ValueT,
    std::less<KeyT>,
    TraceableAllocator<std::pair<KeyT const, ValueT>>
>;

template<typename ItemT>
using GcVector = std::vector<ItemT, TraceableAllocator<ItemT>>;

template<typename ItemT>
using GcList = std::list<ItemT, TraceableAllocator<ItemT>>;
 
[[gnu::always_inline]]
inline void * gcAllocBytes(size_t n)
{
    // Note: various places expect the allocated memory to be zero.
    // Hence: calloc().
    void * ptr = LIX_GC_CALLOC(n);
    if (ptr == nullptr) {
        throw std::bad_alloc();
    }
 
    return ptr;
}

template<typename T>
[[gnu::always_inline]]
inline T * gcAllocType(size_t howMany = 1)
{
    // NOTE: size_t * size_t, which can definitely overflow.
    // Unsigned integer overflow is definitely a bug, but isn't undefined
    // behavior, so we can just check if we overflowed after the fact.
    // However, people can and do request zero sized allocations, so we need
    // to check that neither of our multiplicands were zero before complaining
    // about it.
    // NOLINTNEXTLINE(bugprone-sizeof-expression): yeah we only seem to alloc pointers with this. the calculation *is* correct though!
    auto checkedSz = checked::Checked<size_t>(howMany) * sizeof(T);
    size_t sz = checkedSz.valueWrapping();
    if (checkedSz.overflowed()) {
        // Congrats, you done did an overflow.
        throw std::bad_alloc();
    }
 
    return static_cast<T *>(gcAllocBytes(sz));
}

inline char * gcAllocString(size_t size)
{
    char * cstr = static_cast<char *>(LIX_GC_MALLOC_ATOMIC(size));
    if (cstr == nullptr) {
        throw std::bad_alloc();
    }
    return cstr;
}

char const * gcCopyStringIfNeeded(std::string_view toCopyFrom);
 
}