package base:runtime

Source

Allocator :: struct {
	procedure: Allocator_Proc,
	data:      rawptr,
}

Allocator_Error :: enum u8 {
	None                 = 0, 
	Out_Of_Memory        = 1, 
	Invalid_Pointer      = 2, 
	Invalid_Argument     = 3, 
	Mode_Not_Implemented = 4, 
}

Allocator_Mode :: enum u8 {
	Alloc, 
	Free, 
	Free_All, 
	Resize, 
	Query_Features, 
	Query_Info, 
	Alloc_Non_Zeroed, 
	Resize_Non_Zeroed, 
}

Allocator_Mode_Set :: distinct bit_set[Allocator_Mode]

Allocator_Proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, size, alignment: int, old_memory: rawptr, old_size: int, location := #caller_location) -> ([]u8, Allocator_Error)

Allocator_Query_Info :: struct {
	pointer:   rawptr,
	size:      Maybe($T=int),
	alignment: Maybe($T=int),
}

Arena :: struct {
	backing_allocator:  Allocator,
	curr_block:         ^Memory_Block,
	total_used:         uint,
	total_capacity:     uint,
	minimum_block_size: uint,
	temp_count:         uint,
}

Arena_Temp :: struct {
	arena: ^Arena,
	block: ^Memory_Block,
	used:  uint,
}

Assertion_Failure_Proc :: proc(prefix, message: string, loc: Source_Code_Location) -> !

Calling_Convention :: enum u8 {
	Invalid     = 0, 
	Odin        = 1, 
	Contextless = 2, 
	CDecl       = 3, 
	Std_Call    = 4, 
	Fast_Call   = 5, 
	None        = 6, 
	Naked       = 7, 
	Win64       = 9, 
	SysV        = 10, 
}

Context :: struct {
	allocator:              Allocator,
	temp_allocator:         Allocator,
	assertion_failure_proc: Assertion_Failure_Proc,
	logger:                 Logger,
	random_generator:       Random_Generator,
	user_ptr:               rawptr,
	user_index:             int,
	// Internal use only
	_internal:              rawptr,
}

DLL_Forward_Reason :: enum u32 {
	Process_Detach = 0, // About to unload DLL
	Process_Attach = 1, // Entry point
	Thread_Attach  = 2, 
	Thread_Detach  = 3, 
}

Default_Random_State :: struct {
	state: u64,
	inc:   u64,
}

Default_Temp_Allocator :: struct {
	arena: Arena,
}

Equal_Proc :: proc "contextless" (rawptr, rawptr) -> bool

Hasher_Proc :: proc "contextless" (data: rawptr, seed: uintptr = 0) -> uintptr

Load_Directory_File :: struct {
	name: string,
	data: []u8,
}

Logger :: struct {
	procedure:    Logger_Proc,
	data:         rawptr,
	lowest_level: Logger_Level,
	options:      bit_set[Logger_Option],
}

Logger_Level :: enum uint {
	Debug   = 0, 
	Info    = 10, 
	Warning = 20, 
	Error   = 30, 
	Fatal   = 40, 
}

Logger_Option :: enum int {
	Level, 
	Date, 
	Time, 
	Short_File_Path, 
	Long_File_Path, 
	Line, 
	Procedure, 
	Terminal_Color, 
	Thread_Id, 
}

Logger_Options :: bit_set[Logger_Option]

Logger_Proc :: proc(data: rawptr, level: Logger_Level, text: string, options: bit_set[Logger_Option], location := #caller_location)

Map_Cell :: struct($T: typeid) #align (MAP_CACHE_LINE_SIZE) {}

Map_Cell_Info :: struct {
	size_of_type:      uintptr,
	// 8-bytes on 64-bit, 4-bytes on 32-bits
	align_of_type:     uintptr,
	// 8-bytes on 64-bit, 4-bytes on 32-bits
	size_of_cell:      uintptr,
	// 8-bytes on 64-bit, 4-bytes on 32-bits
	elements_per_cell: uintptr,
}

Map_Hash :: uintptr

Map_Info :: struct {
	ks:         ^Map_Cell_Info,
	// 8-bytes on 64-bit, 4-bytes on 32-bit
	vs:         ^Map_Cell_Info,
	// 8-bytes on 64-bit, 4-bytes on 32-bit
	key_hasher: proc "contextless" (key: rawptr, seed: uintptr) -> uintptr,
	// 8-bytes on 64-bit, 4-bytes on 32-bit
	key_equal:  proc "contextless" (lhs, rhs: rawptr) -> bool,
}

Maybe :: union($T: typeid) {}

Memory_Block :: struct {
	prev:      ^Memory_Block,
	allocator: Allocator,
	base:      [^]u8,
	used:      uint,
	capacity:  uint,
}

Odin_Arch_Type :: .Odin_Arch_Type

Odin_Arch_Types :: bit_set[.Odin_Arch_Type]

Odin_Build_Mode_Type :: .Odin_Build_Mode_Type

Odin_Endian_Type :: .Odin_Endian_Type

Odin_OS_Type :: .Odin_OS_Type

Odin_OS_Types :: bit_set[.Odin_OS_Type]

Odin_Optimization_Mode :: .Odin_Optimization_Mode

Odin_Platform_Subtarget_Type :: .Odin_Platform_Subtarget_Type

Odin_Sanitizer_Flags :: .Odin_Sanitizer_Flags

Platform_Endianness :: enum u8 {
	Platform = 0, 
	Little   = 1, 
	Big      = 2, 
}

Random_Generator :: struct {
	procedure: Random_Generator_Proc,
	data:      rawptr,
}

Random_Generator_Mode :: enum int {
	Read, 
	Reset, 
	Query_Info, 
}

Random_Generator_Proc :: proc(data: rawptr, mode: Random_Generator_Mode, p: []u8)

Random_Generator_Query_Info :: distinct bit_set[Random_Generator_Query_Info_Flag; u32]

Random_Generator_Query_Info_Flag :: enum u32 {
	Cryptographic, 
	Uniform, 
	External_Entropy, 
	Resettable, 
}

Raw_Any :: struct {
	data: rawptr,
	id:   typeid,
}

Raw_Complex128 :: struct {
	real: f64,
	imag: f64,
}

Raw_Complex32 :: struct {
	real: f16,
	imag: f16,
}

Raw_Complex64 :: struct {
	real: f32,
	imag: f32,
}

Raw_Cstring :: struct {
	data: [^]u8,
}

Raw_Dynamic_Array :: struct {
	data:      rawptr,
	len:       int,
	cap:       int,
	allocator: Allocator,
}

Raw_Map :: struct {
	// A single allocation spanning all keys, values, and hashes.
	// {
	//   k: Map_Cell(K) * (capacity / ks_per_cell)
	//   v: Map_Cell(V) * (capacity / vs_per_cell)
	//   h: Map_Cell(H) * (capacity / hs_per_cell)
	// }
	// 
	// The data is allocated assuming 64-byte alignment, meaning the address is
	// always a multiple of 64. This means we have 6 bits of zeros in the pointer
	// to store the capacity. We can store a value as large as 2^6-1 or 63 in
	// there. This conveniently is the maximum log2 capacity we can have for a map
	// as Odin uses signed integers to represent capacity.
	// 
	// Since the hashes are backed by Map_Hash, which is just a 64-bit unsigned
	// integer, the cell structure for hashes is unnecessary because 64/8 is 8 and
	// requires no padding, meaning it can be indexed as a regular array of
	// Map_Hash directly, though for consistency sake it's written as if it were
	// an array of Map_Cell(Map_Hash).
	data:      uintptr,
	// 8-bytes on 64-bits, 4-bytes on 32-bits
	len:       uintptr,
	// 8-bytes on 64-bits, 4-bytes on 32-bits
	allocator: Allocator,
}

Raw_Quaternion128 :: struct {
	imag: f32,
	jmag: f32,
	kmag: f32,
	real: f32,
}

Raw_Quaternion128_Vector_Scalar :: struct {
	vector: [3]f32,
	scalar: f32,
}

Raw_Quaternion256 :: struct {
	imag: f64,
	jmag: f64,
	kmag: f64,
	real: f64,
}

Raw_Quaternion256_Vector_Scalar :: struct {
	vector: [3]f64,
	scalar: f64,
}

Raw_Quaternion64 :: struct {
	imag: f16,
	jmag: f16,
	kmag: f16,
	real: f16,
}

Raw_Quaternion64_Vector_Scalar :: struct {
	vector: [3]f16,
	scalar: f16,
}

Raw_SOA_Footer_Dynamic_Array :: struct {
	len:       int,
	cap:       int,
	allocator: Allocator,
}

Raw_SOA_Footer_Slice :: struct {
	len: int,
}

Raw_Slice :: struct {
	data: rawptr,
	len:  int,
}

Raw_Soa_Pointer :: struct {
	data:  rawptr,
	index: int,
}

Raw_String :: struct {
	data: [^]u8,
	len:  int,
}

Source_Code_Location :: struct {
	file_path: string,
	line:      i32,
	column:    i32,
	procedure: string,
}

Thread_Local_Cleaner :: proc()

Type_Info :: struct {
	size:    int,
	align:   int,
	flags:   Type_Info_Flags,
	id:      typeid,
	variant: union {
		Type_Info_Named, 
		Type_Info_Integer, 
		Type_Info_Rune, 
		Type_Info_Float, 
		Type_Info_Complex, 
		Type_Info_Quaternion, 
		Type_Info_String, 
		Type_Info_Boolean, 
		Type_Info_Any, 
		Type_Info_Type_Id, 
		Type_Info_Pointer, 
		Type_Info_Multi_Pointer, 
		Type_Info_Procedure, 
		Type_Info_Array, 
		Type_Info_Enumerated_Array, 
		Type_Info_Dynamic_Array, 
		Type_Info_Slice, 
		Type_Info_Parameters, 
		Type_Info_Struct, 
		Type_Info_Union, 
		Type_Info_Enum, 
		Type_Info_Map, 
		Type_Info_Bit_Set, 
		Type_Info_Simd_Vector, 
		Type_Info_Matrix, 
		Type_Info_Soa_Pointer, 
		Type_Info_Bit_Field, 
	},
}

Type_Info_Any :: struct {}

Type_Info_Array :: struct {
	elem:      ^Type_Info,
	elem_size: int,
	count:     int,
}

Type_Info_Bit_Field :: struct {
	backing_type: ^Type_Info,
	names:        [^]string `fmt:"v,field_count"`,
	types:        [^]^Type_Info `fmt:"v,field_count"`,
	bit_sizes:    [^]uintptr `fmt:"v,field_count"`,
	bit_offsets:  [^]uintptr `fmt:"v,field_count"`,
	tags:         [^]string `fmt:"v,field_count"`,
	field_count:  int,
}

Type_Info_Bit_Set :: struct {
	elem:       ^Type_Info,
	underlying: ^Type_Info,
	// Possibly nil
	lower:      i64,
	upper:      i64,
}

Type_Info_Boolean :: struct {}

Type_Info_Complex :: struct {}

Type_Info_Dynamic_Array :: struct {
	elem:      ^Type_Info,
	elem_size: int,
}

Type_Info_Enum :: struct {
	base:   ^Type_Info,
	names:  []string,
	values: []Type_Info_Enum_Value,
}

Type_Info_Enum_Value :: distinct i64

Type_Info_Enumerated_Array :: struct {
	elem:      ^Type_Info,
	index:     ^Type_Info,
	elem_size: int,
	count:     int,
	min_value: Type_Info_Enum_Value,
	max_value: Type_Info_Enum_Value,
	is_sparse: bool,
}

Type_Info_Flag :: enum u8 {
	Comparable     = 0, 
	Simple_Compare = 1, 
}

Type_Info_Flags :: distinct bit_set[Type_Info_Flag; u32]

Type_Info_Float :: struct {
	endianness: Platform_Endianness,
}

Type_Info_Integer :: struct {
	signed:     bool,
	endianness: Platform_Endianness,
}

Type_Info_Map :: struct {
	key:      ^Type_Info,
	value:    ^Type_Info,
	map_info: ^Map_Info,
}

Type_Info_Matrix :: struct {
	elem:         ^Type_Info,
	elem_size:    int,
	elem_stride:  int,
	// elem_stride >= row_count
	row_count:    int,
	column_count: int,
	// Total element count = column_count * elem_stride
	layout:       enum u8 {
		Column_Major, // array of column vectors
		Row_Major,    // array of row vectors
	},
}

Type_Info_Multi_Pointer :: struct {
	elem: ^Type_Info,
}

Type_Info_Named :: struct {
	name: string,
	base: ^Type_Info,
	pkg:  string,
	loc:  ^Source_Code_Location,
}

Type_Info_Parameters :: struct {
	// Only used for procedures parameters and results
	types: []^Type_Info,
	names: []string,
}

Type_Info_Pointer :: struct {
	elem: ^Type_Info,
}

Type_Info_Procedure :: struct {
	params:     ^Type_Info,
	// Type_Info_Parameters
	results:    ^Type_Info,
	// Type_Info_Parameters
	variadic:   bool,
	convention: Calling_Convention,
}

Type_Info_Quaternion :: struct {}

Type_Info_Rune :: struct {}

Type_Info_Simd_Vector :: struct {
	elem:      ^Type_Info,
	elem_size: int,
	count:     int,
}

Type_Info_Slice :: struct {
	elem:      ^Type_Info,
	elem_size: int,
}

Type_Info_Soa_Pointer :: struct {
	elem: ^Type_Info,
}

Type_Info_String :: struct {
	is_cstring: bool,
}

Type_Info_Struct :: struct {
	// Slice these with `field_count`
	types:         [^]^Type_Info `fmt:"v,field_count"`,
	names:         [^]string `fmt:"v,field_count"`,
	offsets:       [^]uintptr `fmt:"v,field_count"`,
	usings:        [^]bool `fmt:"v,field_count"`,
	tags:          [^]string `fmt:"v,field_count"`,
	field_count:   i32,
	flags:         Type_Info_Struct_Flags,
	// These are only set iff this structure is an SOA structure
	soa_kind:      Type_Info_Struct_Soa_Kind,
	soa_len:       i32,
	soa_base_type: ^Type_Info,
	equal:         Equal_Proc,
}

Type_Info_Struct_Flag :: enum u8 {
	packed    = 0, 
	raw_union = 1, 
	no_copy   = 2, 
	align     = 3, 
}

Type_Info_Struct_Flags :: distinct bit_set[Type_Info_Struct_Flag; u8]

Type_Info_Struct_Soa_Kind :: enum u8 {
	None    = 0, 
	Fixed   = 1, 
	Slice   = 2, 
	Dynamic = 3, 
}

Type_Info_Tuple :: Type_Info_Parameters

Type_Info_Type_Id :: struct {}

Type_Info_Union :: struct {
	variants:     []^Type_Info,
	tag_offset:   uintptr,
	tag_type:     ^Type_Info,
	equal:        Equal_Proc,
	// set only when the struct has .Comparable set but does not have .Simple_Compare set
	custom_align: bool,
	no_nil:       bool,
	shared_nil:   bool,
}

Typeid_Bit_Field :: distinct bit_field uintptr {
	index:    uintptr | 56,
	kind:     Typeid_Kind | 5,
	named:    bool | 1,
	special:  bool | 1,
	reserved: bool | 1,
}

Typeid_Kind :: enum u8 {
	Invalid, 
	Integer, 
	Rune, 
	Float, 
	Complex, 
	Quaternion, 
	String, 
	Boolean, 
	Any, 
	Type_Id, 
	Pointer, 
	Multi_Pointer, 
	Procedure, 
	Array, 
	Enumerated_Array, 
	Dynamic_Array, 
	Slice, 
	Tuple, 
	Struct, 
	Union, 
	Enum, 
	Map, 
	Bit_Set, 
	Simd_Vector, 
	Matrix, 
	Soa_Pointer, 
	Bit_Field, 
}

ALL_ODIN_ARCH_TYPES: bit_set[.Odin_Arch_Type] : Odin_Arch_Types{.amd64, .i386, .arm32, .arm64, .wasm32, .wasm64p32, .riscv64}

ALL_ODIN_OS_TYPES: bit_set[.Odin_OS_Type] : Odin_OS_Types{.Windows, .Darwin, .Linux, .Essence, .FreeBSD, .OpenBSD, .NetBSD, .Haiku, .WASI, .JS, .Orca, .Freestanding}

Byte :: 1

DEFAULT_ALIGNMENT :: 2 * align_of(rawptr)

DEFAULT_ARENA_GROWING_MINIMUM_BLOCK_SIZE :: uint(DEFAULT_TEMP_ALLOCATOR_BACKING_SIZE)

DEFAULT_DYNAMIC_ARRAY_CAPACITY :: 8

DEFAULT_TEMP_ALLOCATOR_BACKING_SIZE: int : #config(DEFAULT_TEMP_ALLOCATOR_BACKING_SIZE, 4 * Megabyte)

Exabyte :: 1024 * Petabyte

Gigabyte :: 1024 * Megabyte

HASH_MASK :: 1 << (8 * size_of(uintptr) - 1) - 1

INITIAL_HASH_SEED :: 0xcbf29ce484222325

Kilobyte :: 1024 * Byte

MAP_CACHE_LINE_LOG2 :: 6

MAP_CACHE_LINE_SIZE :: 1 << MAP_CACHE_LINE_LOG2

MAP_LOAD_FACTOR :: 75

MAP_MIN_LOG2_CAPACITY :: 3

Megabyte :: 1024 * Kilobyte

NO_DEFAULT_TEMP_ALLOCATOR: bool : ODIN_OS == .Freestanding || ODIN_DEFAULT_TO_NIL_ALLOCATOR

Petabyte :: 1024 * Terabyte

RUNTIME_REQUIRE :: false

TOMBSTONE_MASK :: 1 << (size_of(Map_Hash) * 8 - 1)

Terabyte :: 1024 * Gigabyte

args__: []cstring

dll_forward_reason: DLL_Forward_Reason

dll_instance: rawptr

@(thread_local)
global_default_temp_allocator_data: Default_Temp_Allocator

type_table: []^Type_Info

DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD :: proc(ignore: bool = false, loc := #caller_location) -> (Arena_Temp, Source_Code_Location) {…}

abs_complex128 :: proc "contextless" (x: complex128) -> f64 {…}

abs_complex32 :: proc "contextless" (x: complex32) -> f16 {…}

abs_complex64 :: proc "contextless" (x: complex64) -> f32 {…}

abs_quaternion128 :: proc "contextless" (x: quaternion128) -> f32 {…}

abs_quaternion256 :: proc "contextless" (x: quaternion256) -> f64 {…}

abs_quaternion64 :: proc "contextless" (x: quaternion64) -> f16 {…}

add_thread_local_cleaner :: proc "contextless" (p: Thread_Local_Cleaner) {…}

aeabi_d2h :: proc "c" (value: f64) -> f16 {…}

align_forward_int :: proc(ptr, align: int) -> int {…}

align_forward_uint :: proc(ptr, align: uint) -> uint {…}

align_forward_uintptr :: proc(ptr, align: uintptr) -> uintptr {…}

alloc_from_memory_block :: proc(block: ^Memory_Block, min_size, alignment: uint) -> (data: []u8, err: Allocator_Error) {…}

append_elem :: proc(array: ^$T/[dynamic]$T, #no_broadcast arg: $T, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_ok {…}

append_elem_string :: proc(array: ^$T/[dynamic]$E/u8, arg: $S/string, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_ok {…}

append_elems :: proc(array: ^$T/[dynamic]$T, .. #no_broadcast args: ..$T, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_ok {…}

append_nothing :: proc(array: ^$T/[dynamic]$T, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_ok {…}

append_soa_elem :: proc(array: ^$T/#soa[dynamic]$T, #no_broadcast arg: $T, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_ok {…}

append_soa_elems :: proc(array: ^$T/#soa[dynamic]$T, .. #no_broadcast args: ..$T, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_ok {…}

append_string :: proc(array: ^$T/[dynamic]$E/u8, .. args: ..string, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_ok {…}

arena_alloc :: proc(arena: ^Arena, size, alignment: uint, loc := #caller_location) -> (data: []u8, err: Allocator_Error) {…}

arena_allocator :: proc(arena: ^Arena) -> Allocator {…}

arena_allocator_proc :: proc(
	allocator_data:  rawptr, 
	mode:            Allocator_Mode, 
	size, alignment: int, 
	old_memory:      rawptr, 
	old_size:        int, 
	location := #caller_location, 
) -> (data: []u8, err: Allocator_Error) {…}

arena_check_temp :: proc(arena: ^Arena, loc := #caller_location) {…}

arena_destroy :: proc(arena: ^Arena, loc := #caller_location) {…}

arena_free_all :: proc(arena: ^Arena, loc := #caller_location) {…}

arena_free_last_memory_block :: proc(arena: ^Arena, loc := #caller_location) {…}

arena_init :: proc(arena: ^Arena, size: uint, backing_allocator: Allocator, loc := #caller_location) -> Allocator_Error {…}

arena_temp_begin :: proc(arena: ^Arena, loc := #caller_location) -> (temp: Arena_Temp) {…}

arena_temp_end :: proc(temp: Arena_Temp, loc := #caller_location) {…}

arena_temp_ignore :: proc(temp: Arena_Temp, loc := #caller_location) {…}

assert :: proc(condition: bool, message: string = "", loc := #caller_location) {…}

assert_contextless :: proc "contextless" (condition: bool, message: string = "", loc := #caller_location) {…}

assign_at_elem :: proc(array: ^$T/[dynamic]$T, #any_int index: int, #no_broadcast arg: $T, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #optional_ok {…}

assign_at_elem_string :: proc(array: ^$T/[dynamic]$E/u8, #any_int index: int, arg: string, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #optional_ok {…}

assign_at_elems :: proc(array: ^$T/[dynamic]$T, #any_int index: int, .. #no_broadcast args: ..$T, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #optional_ok {…}

bounds_check_error :: proc "contextless" (file: string, line, column: i32, index, count: int) {…}

bounds_check_error_loc :: proc "contextless" (loc := #caller_location, index, count: int) {…}

bounds_trap :: proc "contextless" () -> ! {…}

card :: proc "contextless" (s: $T/bit_set[$T]) -> int {…}

clear_dynamic_array :: proc "contextless" (array: ^$T/[dynamic]$T) {…}

clear_map :: proc "contextless" (m: ^$T/map[$T]$T) {…}

clear_soa_dynamic_array :: proc(array: ^$T/#soa[dynamic]$T) {…}

complex128_eq :: proc "contextless" (a, b: complex128) -> bool {…}

complex128_ne :: proc "contextless" (a, b: complex128) -> bool {…}

complex32_eq :: proc "contextless" (a, b: complex32) -> bool {…}

complex32_ne :: proc "contextless" (a, b: complex32) -> bool {…}

complex64_eq :: proc "contextless" (a, b: complex64) -> bool {…}

complex64_ne :: proc "contextless" (a, b: complex64) -> bool {…}

container_of :: proc "contextless" (ptr: $P/^$T, $T: typeid, $field_name: string = ) -> ^typeid {…}

copy_from_string :: proc "contextless" (dst: $T/[]$E/u8, src: $S/string) -> int {…}

copy_slice :: proc "contextless" (dst, src: $T/[]$T) -> int {…}

cstring_cmp :: proc "contextless" (lhs, rhs: cstring) -> int {…}

cstring_eq :: proc "contextless" (lhs, rhs: cstring) -> bool {…}

cstring_ge :: proc "contextless" (a, b: cstring) -> bool {…}

cstring_gt :: proc "contextless" (a, b: cstring) -> bool {…}

cstring_le :: proc "contextless" (a, b: cstring) -> bool {…}

cstring_len :: proc "contextless" (s: cstring) -> int {…}

cstring_lt :: proc "contextless" (a, b: cstring) -> bool {…}

cstring_ne :: proc "contextless" (a, b: cstring) -> bool {…}

cstring_to_string :: proc "contextless" (s: cstring) -> string {…}

debug_trap :: intrinsics.debug_trap

default_allocator :: heap_allocator

default_allocator_proc :: heap_allocator_proc

default_assertion_contextless_failure_proc :: proc "contextless" (prefix, message: string, loc: Source_Code_Location) -> ! {…}

default_assertion_failure_proc :: proc(prefix, message: string, loc: Source_Code_Location) -> ! {…}

default_context :: proc "contextless" () -> Context {…}

default_hasher :: proc "contextless" (data: rawptr, seed: uintptr, N: int) -> uintptr {…}

default_hasher_cstring :: proc "contextless" (data: rawptr, seed: uintptr = 0) -> uintptr {…}

default_hasher_string :: proc "contextless" (data: rawptr, seed: uintptr = 0) -> uintptr {…}

default_logger :: proc() -> Logger {…}

default_logger_proc :: proc(data: rawptr, level: Logger_Level, text: string, options: bit_set[Logger_Option], location := #caller_location) {…}

default_random_generator :: proc "contextless" (state: ^Default_Random_State = nil) -> Random_Generator {…}

default_random_generator_proc :: proc(data: rawptr, mode: Random_Generator_Mode, p: []u8) {…}

default_temp_allocator :: proc(allocator: ^Default_Temp_Allocator) -> Allocator {…}

default_temp_allocator_destroy :: proc(s: ^Default_Temp_Allocator) {…}

default_temp_allocator_init :: proc(s: ^Default_Temp_Allocator, size: int, backing_allocator := context.allocator) {…}

default_temp_allocator_proc :: proc(
	allocator_data:  rawptr, 
	mode:            Allocator_Mode, 
	size, alignment: int, 
	old_memory:      rawptr, 
	old_size:        int, 
	loc := #caller_location, 
) -> (data: []u8, err: Allocator_Error) {…}

default_temp_allocator_temp_begin :: proc(loc: Source_Code_Location) -> (temp: Arena_Temp) {…}

default_temp_allocator_temp_end :: proc(temp: Arena_Temp, loc := #caller_location) {…}

delete_cstring :: proc(str: cstring, allocator := context.allocator, loc := #caller_location) -> Allocator_Error {…}

delete_dynamic_array :: proc(array: $T/[dynamic]$T, loc := #caller_location) -> Allocator_Error {…}

delete_key :: proc(m: ^$T/map[$T]$T, key: $T) -> (deleted_key: $T, deleted_value: $T) {…}

delete_map :: proc(m: $T/map[$T]$T, loc := #caller_location) -> Allocator_Error {…}

delete_slice :: proc(array: $T/[]$T, allocator := context.allocator, loc := #caller_location) -> Allocator_Error {…}

delete_soa_dynamic_array :: proc(array: $T/#soa[dynamic]$T, loc := #caller_location) -> Allocator_Error {…}

delete_soa_slice :: proc(array: $T/#soa[]$T, allocator := context.allocator, loc := #caller_location) -> Allocator_Error {…}

delete_string :: proc(str: string, allocator := context.allocator, loc := #caller_location) -> Allocator_Error {…}

divmodti4 :: proc "c" (a, b: i128, rem: ^i128) -> i128 {…}

divti3 :: proc "c" (a, b: i128) -> i128 {…}

dynamic_array_expr_error :: proc "contextless" (
	file:         string, 
	line, column: i32, 
	low, high, 
	max:          int, 
) {…}

dynamic_array_expr_error_loc :: proc "contextless" (loc := #caller_location, low, high, max: int) {…}

encode_rune :: proc "contextless" (c: rune) -> ([4]u8, int) {…}

extendhfsf2 :: proc "c" (value: f16) -> f32 {…}

fixdfti :: proc "c" (a: u64) -> i128 {…}

fixunsdfdi :: proc "c" (a: f64) -> i128 {…}

fixunsdfti :: proc "c" (a: f64) -> u128 {…}

floattidf :: proc "c" (a: i128) -> f64 {…}

floattidf_unsigned :: proc "c" (a: u128) -> f64 {…}

gnu_f2h_ieee :: proc "c" (value: f32) -> f16 {…}

gnu_h2f_ieee :: proc "c" (value_: f16) -> f32 {…}

heap_alloc :: proc "contextless" (size: int, zero_memory: bool = true) -> rawptr {…}

heap_allocator :: proc() -> Allocator {…}

heap_allocator_proc :: proc(
	allocator_data:  rawptr, 
	mode:            Allocator_Mode, 
	size, alignment: int, 
	old_memory:      rawptr, 
	old_size:        int, 
	loc := #caller_location, 
) -> ([]u8, Allocator_Error) {…}

heap_free :: proc "contextless" (ptr: rawptr) {…}

heap_resize :: proc "contextless" (ptr: rawptr, new_size: int) -> rawptr {…}

init_global_temporary_allocator :: proc(size: int, backup_allocator := context.allocator) {…}

inject_at_elem :: proc(array: ^$T/[dynamic]$T, #any_int index: int, #no_broadcast arg: $T, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #optional_ok {…}

inject_at_elem_string :: proc(array: ^$T/[dynamic]$E/u8, #any_int index: int, arg: string, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #optional_ok {…}

inject_at_elems :: proc(array: ^$T/[dynamic]$T, #any_int index: int, .. #no_broadcast args: ..$T, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #optional_ok {…}

into_dynamic_soa :: proc(array: $T/#soa[]$T) -> #soa[dynamic]$T {…}

is_power_of_two_int :: proc "contextless" (x: int) -> bool {…}

is_power_of_two_uint :: proc "contextless" (x: uint) -> bool {…}

is_power_of_two_uintptr :: proc "contextless" (x: uintptr) -> bool {…}

make_aligned :: proc($T: typeid/[]T, #any_int len: int, alignment: int, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) #optional_ok {…}

make_dynamic_array :: proc($T: typeid/[dynamic]T, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) #optional_ok {…}

make_dynamic_array_error_loc :: proc "contextless" (loc := #caller_location, len, cap: int) {…}

make_dynamic_array_len :: proc($T: typeid/[dynamic]T, #any_int len: int, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) #optional_ok {…}

make_dynamic_array_len_cap :: proc($T: typeid/[dynamic]T, #any_int len: int, #any_int cap: int, allocator := context.allocator, loc := #caller_location) -> (array: T, err: Allocator_Error) #optional_ok {…}

make_map :: proc($T: typeid/map[T]T, allocator := context.allocator, loc := #caller_location) -> (m: T) {…}

make_map_cap :: proc($T: typeid/map[T]T, #any_int capacity: int, allocator := context.allocator, loc := #caller_location) -> (m: T, err: Allocator_Error) #optional_ok {…}

make_map_expr_error_loc :: proc "contextless" (loc := #caller_location, cap: int) {…}

make_multi_pointer :: proc($T: typeid/[^]T, #any_int len: int, allocator := context.allocator, loc := #caller_location) -> (mp: $/[^]T, err: Allocator_Error) #optional_ok {…}

make_slice :: proc($T: typeid/[]T, #any_int len: int, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) #optional_ok {…}

make_slice_error_loc :: proc "contextless" (loc := #caller_location, len: int) {…}

make_soa_aligned :: proc($T: typeid/#soa[]T, #any_int length, #any_int alignment: int, allocator := context.allocator, loc := #caller_location) -> (array: T, err: Allocator_Error) #optional_ok {…}

make_soa_dynamic_array :: proc($T: typeid/#soa[dynamic]T, allocator := context.allocator, loc := #caller_location) -> (array: T, err: Allocator_Error) #optional_ok {…}

make_soa_dynamic_array_len :: proc($T: typeid/#soa[dynamic]T, #any_int length: int, allocator := context.allocator, loc := #caller_location) -> (array: T, err: Allocator_Error) #optional_ok {…}

make_soa_dynamic_array_len_cap :: proc($T: typeid/#soa[dynamic]T, #any_int length, #any_int capacity: int, allocator := context.allocator, loc := #caller_location) -> (array: T, err: Allocator_Error) #optional_ok {…}

make_soa_slice :: proc($T: typeid/#soa[]T, #any_int length: int, allocator := context.allocator, loc := #caller_location) -> (array: T, err: Allocator_Error) #optional_ok {…}

map_alloc_dynamic :: proc(info: ^Map_Info, log2_capacity: uintptr, allocator := context.allocator, loc := #caller_location) -> (result: Raw_Map, err: Allocator_Error) {…}

map_cap :: proc "contextless" (m: Raw_Map) -> int {…}

map_cell_index_dynamic :: proc "contextless" (base: uintptr, #no_alias info: ^Map_Cell_Info, index: uintptr) -> uintptr {…}

map_cell_index_dynamic_const :: proc "contextless" (base: uintptr, #no_alias info: ^Map_Cell_Info, $INDEX: uintptr = ) -> uintptr {…}

map_cell_index_static :: proc "contextless" (cells: [^]Map_Cell($T), index: uintptr) -> ^$T {…}

map_cell_info :: intrinsics.type_map_cell_info

map_clear_dynamic :: proc "contextless" (#no_alias m: ^Raw_Map, #no_alias info: ^Map_Info) {…}

map_data :: proc "contextless" (m: Raw_Map) -> uintptr {…}

map_desired_position :: proc "contextless" (m: Raw_Map, hash: uintptr) -> uintptr {…}

map_erase_dynamic :: proc "contextless" (#no_alias m: ^Raw_Map, #no_alias info: ^Map_Info, k: uintptr) -> (old_k, old_v: uintptr, ok: bool) {…}

map_exists_dynamic :: proc "contextless" (m: Raw_Map, #no_alias info: ^Map_Info, k: uintptr) -> (ok: bool) {…}

map_free_dynamic :: proc(m: Raw_Map, info: ^Map_Info, loc := #caller_location) -> Allocator_Error {…}

map_get :: proc "contextless" (m: $T/map[$T]$T, key: $T) -> (stored_key: $T, stored_value: $T, ok: bool) {…}

map_grow_dynamic :: proc(#no_alias m: ^Raw_Map, #no_alias info: ^Map_Info, loc := #caller_location) -> Allocator_Error {…}

map_hash_is_deleted :: proc "contextless" (hash: uintptr) -> bool {…}

map_hash_is_empty :: proc "contextless" (hash: uintptr) -> bool {…}

map_hash_is_valid :: proc "contextless" (hash: uintptr) -> bool {…}

map_info :: intrinsics.type_map_info

map_insert :: proc(m: ^$T/map[$T]$T, key: $T, value: $T, loc := #caller_location) -> (ptr: ^$T) {…}

map_insert_hash_dynamic :: proc(#no_alias m: ^Raw_Map, #no_alias info: ^Map_Info, h: uintptr, ik: uintptr, iv: uintptr) -> (result: uintptr) {…}

map_kvh_data_dynamic :: proc "contextless" (m: Raw_Map, #no_alias info: ^Map_Info) -> (ks: uintptr, vs: uintptr, hs: [^]uintptr, sk: uintptr, sv: uintptr) {…}

map_kvh_data_static :: proc "contextless" (m: $T/map[$T]$T) -> (ks: [^]Map_Cell($T), vs: [^]Map_Cell($T), hs: [^]uintptr) {…}

map_kvh_data_values_dynamic :: proc "contextless" (m: Raw_Map, #no_alias info: ^Map_Info) -> (vs: uintptr) {…}

map_len :: proc "contextless" (m: Raw_Map) -> int {…}

map_load_factor :: proc "contextless" (log2_capacity: uintptr) -> uintptr {…}

map_log2_cap :: proc "contextless" (m: Raw_Map) -> uintptr {…}

map_lookup_dynamic :: proc "contextless" (m: Raw_Map, #no_alias info: ^Map_Info, k: uintptr) -> (index: uintptr, ok: bool) {…}

map_probe_distance :: proc "contextless" (m: Raw_Map, hash: uintptr, slot: uintptr) -> uintptr {…}

map_reserve_dynamic :: proc(#no_alias m: ^Raw_Map, #no_alias info: ^Map_Info, new_capacity: uintptr, loc := #caller_location) -> Allocator_Error {…}

map_resize_threshold :: proc "contextless" (m: Raw_Map) -> uintptr {…}

map_seed :: proc "contextless" (m: Raw_Map) -> uintptr {…}

map_seed_from_map_data :: proc "contextless" (data: uintptr) -> uintptr {…}

map_shrink_dynamic :: proc(#no_alias m: ^Raw_Map, #no_alias info: ^Map_Info, loc := #caller_location) -> (did_shrink: bool, err: Allocator_Error) {…}

map_total_allocation_size :: proc "contextless" (capacity: uintptr, info: ^Map_Info) -> uintptr {…}

map_total_allocation_size_from_value :: proc "contextless" (m: $T/map[$T]$T) -> uintptr {…}

map_upsert :: proc(m: ^$T/map[$T]$T, key: $T, value: $T, loc := #caller_location) -> (prev_key: $T, value_ptr: ^$T, found_previous: bool) {…}

matrix_bounds_check_error :: proc "contextless" (
	file:                               string, 
	line, column:                       i32, 
	row_index, column_index, row_count, 
	column_count:                       int, 
) {…}

mem_alloc :: proc(size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> ([]u8, Allocator_Error) {…}

mem_alloc_bytes :: proc(size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> ([]u8, Allocator_Error) {…}

mem_alloc_non_zeroed :: proc(size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> ([]u8, Allocator_Error) {…}

mem_copy :: proc "contextless" (dst, src: rawptr, len: int) -> rawptr {…}

mem_copy_non_overlapping :: proc "contextless" (dst, src: rawptr, len: int) -> rawptr {…}

mem_free :: proc(ptr: rawptr, allocator := context.allocator, loc := #caller_location) -> Allocator_Error {…}

mem_free_all :: proc(allocator := context.allocator, loc := #caller_location) -> (err: Allocator_Error) {…}

mem_free_bytes :: proc(bytes: []u8, allocator := context.allocator, loc := #caller_location) -> Allocator_Error {…}

mem_free_with_size :: proc(ptr: rawptr, byte_count: int, allocator := context.allocator, loc := #caller_location) -> Allocator_Error {…}

mem_resize :: proc(
	ptr:       rawptr, 
	old_size:  int, 
	new_size:  int, 
	alignment: int = DEFAULT_ALIGNMENT, 
	allocator := context.allocator, 
	loc := #caller_location, 
) -> (data: []u8, err: Allocator_Error) {…}

mem_zero :: proc "contextless" (data: rawptr, len: int) -> rawptr {…}

memory_block_alloc :: proc(allocator: Allocator, capacity: uint, alignment: uint, loc := #caller_location) -> (block: ^Memory_Block, err: Allocator_Error) {…}

memory_block_dealloc :: proc(block_to_free: ^Memory_Block, loc := #caller_location) {…}

memory_compare :: proc "contextless" (a, b: rawptr, n: int) -> int {…}

memory_compare_zero :: proc "contextless" (a: rawptr, n: int) -> int {…}

memory_equal :: proc "contextless" (x, y: rawptr, n: int) -> bool {…}

memset :: proc "c" (ptr: rawptr, val: i32, len: int) -> rawptr {…}

modti3 :: proc "c" (a, b: i128) -> i128 {…}

mul_quaternion128 :: proc "contextless" (q, r: quaternion128) -> quaternion128 {…}

mul_quaternion256 :: proc "contextless" (q, r: quaternion256) -> quaternion256 {…}

mul_quaternion64 :: proc "contextless" (q, r: quaternion64) -> quaternion64 {…}

multi_pointer_slice_expr_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int) {…}

multi_pointer_slice_handle_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int) -> ! {…}

new :: proc($T: typeid, allocator := context.allocator, loc := #caller_location) -> (^typeid, Allocator_Error) #optional_ok {…}

new_aligned :: proc($T: typeid, alignment: int, allocator := context.allocator, loc := #caller_location) -> (t: ^typeid, err: Allocator_Error) {…}

new_clone :: proc(data: $T, allocator := context.allocator, loc := #caller_location) -> (t: ^$T, err: Allocator_Error) #optional_ok {…}

nil_allocator :: proc() -> Allocator {…}

nil_allocator_proc :: proc(
	allocator_data:  rawptr, 
	mode:            Allocator_Mode, 
	size, alignment: int, 
	old_memory:      rawptr, 
	old_size:        int, 
	loc := #caller_location, 
) -> ([]u8, Allocator_Error) {…}

non_zero_append_elem :: proc(array: ^$T/[dynamic]$T, #no_broadcast arg: $T, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_ok {…}

non_zero_append_elem_string :: proc(array: ^$T/[dynamic]$E/u8, arg: $S/string, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_ok {…}

non_zero_append_elems :: proc(array: ^$T/[dynamic]$T, .. #no_broadcast args: ..$T, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_ok {…}

non_zero_append_soa_elem :: proc(array: ^$T/#soa[dynamic]$T, #no_broadcast arg: $T, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_ok {…}

non_zero_append_soa_elems :: proc(array: ^$T/#soa[dynamic]$T, .. #no_broadcast args: ..$T, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_ok {…}

non_zero_mem_resize :: proc(
	ptr:       rawptr, 
	old_size:  int, 
	new_size:  int, 
	alignment: int = DEFAULT_ALIGNMENT, 
	allocator := context.allocator, 
	loc := #caller_location, 
) -> (data: []u8, err: Allocator_Error) {…}

non_zero_reserve_dynamic_array :: proc(array: ^$T/[dynamic]$T, #any_int capacity: int, loc := #caller_location) -> Allocator_Error {…}

non_zero_reserve_soa :: proc(array: ^$T/#soa[dynamic]$T, #any_int capacity: int, loc := #caller_location) -> Allocator_Error {…}

non_zero_resize_dynamic_array :: proc(array: ^$T/[dynamic]$T, #any_int length: int, loc := #caller_location) -> Allocator_Error {…}

non_zero_resize_soa :: proc(array: ^$T/#soa[dynamic]$T, #any_int length: int, loc := #caller_location) -> Allocator_Error {…}

ordered_remove :: proc(array: ^$T/[dynamic]$T, #any_int index: int, loc := #caller_location) {…}

ordered_remove_soa :: proc(array: ^$T/#soa[dynamic]$T, #any_int index: int, loc := #caller_location) {…}

panic :: proc(message: string, loc := #caller_location) -> ! {…}

panic_allocator :: proc() -> Allocator {…}

panic_allocator_proc :: proc(
	allocator_data:  rawptr, 
	mode:            Allocator_Mode, 
	size, alignment: int, 
	old_memory:      rawptr, 
	old_size:        int, 
	loc := #caller_location, 
) -> ([]u8, Allocator_Error) {…}

panic_contextless :: proc "contextless" (message: string, loc := #caller_location) -> ! {…}

pop :: proc(array: ^$T/[dynamic]$T, loc := #caller_location) -> (res: $T) {…}

pop_front :: proc(array: ^$T/[dynamic]$T, loc := #caller_location) -> (res: $T) {…}

pop_front_safe :: proc "contextless" (array: ^$T/[dynamic]$T) -> (res: $T, ok: bool) {…}

pop_safe :: proc "contextless" (array: ^$T/[dynamic]$T) -> (res: $T, ok: bool) {…}

print_any_single :: proc "contextless" (arg: any) {…}

print_byte :: proc "contextless" (b: u8) -> (n: int) {…}

print_caller_location :: proc "contextless" (loc: Source_Code_Location) {…}

print_encoded_rune :: proc "contextless" (r: rune) {…}

print_i64 :: proc "contextless" (x: i64) {…}

print_int :: proc "contextless" (x: int) {…}

print_rune :: proc "contextless" (r: rune) -> int {…}

print_string :: proc "contextless" (str: string) -> (n: int) {…}

print_strings :: proc "contextless" (.. args: ..string) -> (n: int) {…}

print_type :: proc "contextless" (ti: ^Type_Info) {…}

print_typeid :: proc "contextless" (id: typeid) {…}

print_u64 :: proc "contextless" (x: u64) {…}

print_uint :: proc "contextless" (x: uint) {…}

print_uintptr :: proc "contextless" (x: uintptr) {…}

println_any :: proc "contextless" (.. args: ..any) {…}

quaternion128_eq :: proc "contextless" (a, b: quaternion128) -> bool {…}

quaternion128_ne :: proc "contextless" (a, b: quaternion128) -> bool {…}

quaternion256_eq :: proc "contextless" (a, b: quaternion256) -> bool {…}

quaternion256_ne :: proc "contextless" (a, b: quaternion256) -> bool {…}

quaternion64_eq :: proc "contextless" (a, b: quaternion64) -> bool {…}

quaternion64_ne :: proc "contextless" (a, b: quaternion64) -> bool {…}

quo_complex128 :: proc "contextless" (n, m: complex128) -> complex128 {…}