//! Arena allocation support for binary lowering fixtures.

/// Error returned when an arena cannot satisfy an allocation.
export union AllocError: Copy {
    /// The arena has insufficient storage.
    OutOfMemory,
}

/// Bump allocator backed by a byte slice.
export record Arena {
    /// Backing storage.
    data: *mut [u8],
    /// Current allocation offset in bytes.
    offset: u32,
}

/// Create an arena backed by `data`.
export fn new(data: *mut [u8]) -> Arena {
    return Arena { data, offset: 0 };
}

/// Reset the arena to its initial empty state.
export fn reset(arena: &mut Arena) {
    set arena.offset = 0;
}

/// Return the number of bytes committed in the arena.
export fn used(arena: &Arena) -> u32 {
    return arena.offset;
}

/// Allocate aligned storage without changing the arena after failure.
export unsafe fn alloc(arena: *unsafe mut Arena, size: u32, alignment: u32) -> *mut opaque throws (AllocError) {
    assert alignment > 0;
    assert size > 0;
    assert (alignment & (alignment - 1)) == 0;

    let capacity = arena.data.len;
    if arena.offset >= capacity {
        throw AllocError::OutOfMemory;
    }
    let address = &arena.data[0] as u64;
    let mask = (alignment - 1) as u64;
    let remainder = ((address & mask) + (arena.offset as u64 & mask)) & mask;
    let padding = ((alignment as u64 - remainder) & mask) as u32;
    let available = capacity - arena.offset;
    if padding > available or size > available - padding {
        throw AllocError::OutOfMemory;
    }
    let aligned = arena.offset + padding;
    let base: *mut u8 = &mut arena.data[aligned];
    set arena.offset = aligned + size;
    return base as *mut opaque;
}

/// Allocate raw storage that remains valid until the arena is reset.
export unsafe fn allocRaw(arena: &mut Arena, size: u32, alignment: u32) -> *unsafe mut opaque throws (AllocError) {
    let owner = try alloc(&mut *arena, size, alignment);
    let byte = owner as *mut u8;
    return &mut *byte as *unsafe mut opaque;
}

/// Allocate a raw slice that remains valid until the arena is reset.
export unsafe fn allocRawSlice(arena: &mut Arena, size: u32, alignment: u32, count: u32) -> *unsafe mut [opaque] throws (AllocError) {
    if count == 0 {
        return &mut [];
    }
    if size <> 0 and count > 4294967295 / size {
        throw AllocError::OutOfMemory;
    }
    let raw = try allocRaw(arena, size * count, alignment);
    return @sliceOf(raw, count);
}

/// Raw storage provider for allocation sessions.
export trait Alloc {
    /// Reserve one uninitialized object.
    unsafe fn (&mut Alloc) reserve(size: u32, alignment: u32) -> *unsafe mut opaque throws (AllocError);
    /// Reserve an uninitialized slice.
    unsafe fn (&mut Alloc) reserveSlice(itemSize: u32, itemAlignment: u32, count: u32) -> *unsafe mut [opaque] throws (AllocError);
}

instance Alloc for Arena {
    /// Reserve one uninitialized object in the arena.
    unsafe fn (arena: &mut Arena) reserve(size: u32, alignment: u32) -> *unsafe mut opaque throws (AllocError) {
        return try allocRaw(arena, size, alignment);
    }

    /// Reserve an uninitialized slice in the arena.
    unsafe fn (arena: &mut Arena) reserveSlice(size: u32, alignment: u32, count: u32) -> *unsafe mut [opaque] throws (AllocError) {
        return try allocRawSlice(arena, size, alignment, count);
    }
}