#include "HalideRuntime.h"
#include "runtime_internal.h"

extern "C" {

extern void *malloc(size_t);
extern void free(void *);

// An implementation of aligned_alloc() that is layered on top of malloc()/free().
WEAK_INLINE void *halide_internal_aligned_alloc(size_t alignment, size_t size) {
    // Alignment must be a power of two and >= sizeof(void*)
    halide_debug_assert(nullptr, is_power_of_two(alignment) && alignment >= sizeof(void *));

    // Allocate enough space for aligning the pointer we return.
    //
    // Always round allocations up to alignment size,
    // so that all allocators follow the behavior of aligned_alloc() and
    // return aligned pointer *and* aligned length.
    const size_t aligned_size = align_up(size + alignment, alignment);

    void *orig = ::malloc(aligned_size);
    if (orig == nullptr) {
        // Will result in a failed assertion and a call to halide_error
        return nullptr;
    }

    // malloc() and friends must return a pointer aligned to at least
    // alignof(std::max_align_t); we can't reasonably check that in
    // the runtime, but we can realistically assume it's at least
    // 8-aligned.
    halide_debug_assert(nullptr, (((uintptr_t)orig) % 8) == 0);

    // We want to store the original pointer prior to the pointer we return.
    void *ptr = (void *)align_up((uintptr_t)orig + sizeof(void *), alignment);
    ((void **)ptr)[-1] = orig;
    return ptr;
}

WEAK_INLINE void halide_internal_aligned_free(void *ptr) {
    ::free(((void **)ptr)[-1]);
}

}  // extern "C"