type abort_handler[permalink] [source]

type abort_handler = fn(path: *str, line: u64, col: u64, msg: str) never;

Signature for abort handler function.

type chunk[permalink] [source]

type chunk = union {
	// TODO: track number of active allocations here
	padding: size,
	data: [*]u8,
};

A group of blocks that were allocated together.

type meta[permalink] [source]

type meta = struct {
	union {
		sz: size,
		next: uintptr,
	},
	user: [*]u8,
};

Metadata for a block.

type arch_jmp_buf[permalink] [source]

type arch_jmp_buf = [8]u64;

type jmp_buf[permalink] [source]

type jmp_buf = struct {
	__jb: arch_jmp_buf,
	__fl: size,
	__ss: [128 / size(size)]size,
};

type memory_heap[permalink] [source]

type memory_heap = struct {
	// Number of allocations currently in flight.
	cur_allocs: size,
	// Freelists for blocks up to 2048 bytes.
	bins: [9]nullable *meta,
	// The chunk to allocate from if there are no blocks available in the
	// right freelist.
	cur_chunk: (*chunk, size),
};

type slice[permalink] [source]

type slice = struct {
	data: nullable *opaque,
	length: size,
	capacity: size,
};

def EMPTY_HEAP[permalink] [source]

def EMPTY_HEAP = memory_heap {
	cur_allocs = 0,
	bins = [null...],
	cur_chunk = (null: *chunk, CHUNKSZ),
};

An empty memory heap, used to initialize a memory_heap for use with setheap.

let argc[permalink] [source]

let argc: size;

let argv[permalink] [source]

let argv: *[*]*u8;

let envp[permalink] [source]

let envp: *[*]nullable *u8;

fn fini[permalink] [source]

fn fini() void;

Run all global finalization functions.

fn free_[permalink] [source]

fn free_(p: nullable *opaque) void;

Frees an allocation returned by malloc. Freeing any other pointer, or freeing a pointer that's already been freed, will cause an abort.

fn getmeta[permalink] [source]

fn getmeta(p: *opaque) *meta;

Gets the metadata for a given allocation. The provided pointer must have been returned by malloc or realloc and must not have been freed.

fn init[permalink] [source]

fn init() void;

Run all global initialization functions.

fn malloc[permalink] [source]

fn malloc(n: size) nullable *opaque;

Allocates n bytes of memory and returns a pointer to them, or null if there is insufficient memory.

fn onabort[permalink] [source]

fn onabort(handler: *abort_handler) *abort_handler;

Sets a new global runtime abort handler, returning the previous handler.

fn realloc[permalink] [source]

fn realloc(p: nullable *opaque, n: size) nullable *opaque;

Changes the allocation size of a pointer to n bytes. If n is smaller than the prior allocation, it is truncated; otherwise the allocation is expanded and the values of the new bytes are undefined. May return a different pointer than the one given if there is insufficient space to expand the pointer in-place. Returns null if there is insufficient memory to support the request.

fn setheap[permalink] [source]

fn setheap(new_heap: *memory_heap) *memory_heap;

Switches the internal runtime allocator to a new memory heap. The caller should provision a memory_heap initialized to EMPTY_HEAP somehow (statically, or in a second memory_heap, or even on the stack if you're brave enough) and pass it to this function to enable it. Returns a pointer to the heap which was previously in use, should you wish to restore it later.

The caller is responsible for ensuring that any use of free() or delete() makes use of an object which was allocated (via alloc(), insert(), or append()) from the same heap.

This function is designed for debugging use, and exists in particular to satisfy the needs of debug::.

fn _abort[permalink] [source]

fn _abort(path: *str, line: u64, col: u64, msg: str) never;

fn abort_fixed[permalink] [source]

fn abort_fixed(path: *str, line: u64, col: u64, i: u64) void;

fn ensure[permalink] [source]

fn ensure(s: *slice, membsz: size) bool;

fn longjmp[permalink] [source]

fn longjmp(buf: *jmp_buf, n: int) never;

fn memcpy[permalink] [source]

fn memcpy(dest: *opaque, src: *opaque, n: size) void;

fn memmove[permalink] [source]

fn memmove(dest: *opaque, src: *opaque, n: size) void;

fn memset[permalink] [source]

fn memset(dest: *opaque, val: u8, n: size) void;

fn setjmp[permalink] [source]

fn setjmp(buf: *jmp_buf) int;

fn start_ha[permalink] [source]

fn start_ha() never;

fn start_linux[permalink] [source]

fn start_linux(iv: *[*]uintptr) never;

fn strcmp[permalink] [source]

fn strcmp(_a: str, _b: str) bool;

fn unensure[permalink] [source]

fn unensure(s: *slice, membsz: size) void;