package core:runtime

Overview

This is the runtime code required by the compiler IMPORTANT NOTE(bill): Do not change the order of any of this data The compiler relies upon this _exact_ order

Naming Conventions: In general, Ada_Case for types and snake_case for values

Package Name: snake_case (but prefer single word) Import Name: snake_case (but prefer single word) Types: Ada_Case Enum Values: Ada_Case Procedures: snake_case Local Variables: snake_case Constant Variables: SCREAMING_SNAKE_CASE

IMPORTANT NOTE(bill): type_info_of cannot be used within a #shared_global_scope due to the internals of the compiler. This could change at a later date if the all these data structures are implemented within the compiler rather than in this "preload" file

Index

Types (72)
Procedures (265)

Types

Allocator ¶

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

Allocator_Error ¶

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

Allocator_Mode ¶

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

Allocation Stuff

Allocator_Mode_Set ¶

Allocator_Mode_Set :: distinct bit_set[Allocator_Mode]

Allocator_Proc ¶

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

Allocator_Query_Info ¶

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

Assertion_Failure_Proc ¶

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

Calling_Convention ¶

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, 
}
 

NOTE(bill): This must match the compiler's

Context ¶

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

DLL_Forward_Reason ¶

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

Default_Temp_Allocator ¶

Default_Temp_Allocator :: struct {
	data:               []u8,
	curr_offset:        int,
	prev_allocation:    rawptr,
	backup_allocator:   Allocator,
	leaked_allocations: [dynamic][]u8,
}

Equal_Proc ¶

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

Procedure type to test whether two values of the same type are equal

Hasher_Proc ¶

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

Procedure type to hash a value, default seed value is 0

Logger ¶

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

Logger_Level ¶

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

Logger_Option ¶

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

Logger_Options ¶

Logger_Options :: bit_set[Logger_Option]

Logger_Proc ¶

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

Map_Cell ¶

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

Map_Cell type that packs multiple T in such a way to ensure that each T stays aligned by align_of(T) and such that align_of(Map_Cell(T)) % MAP_CACHE_LINE_SIZE == 0

This means a value of type T will never straddle a cache-line.

When multiple Ts can fit in a single cache-line the data array will have more than one element. When it cannot, the data array will have one element and an array of Map_Cell(T) will be padded to stay a multiple of MAP_CACHE_LINE_SIZE.

We rely on the type system to do all the arithmetic and padding for us here.

The usual array[index] indexing for []T backed by a []Map_Cell(T) becomes a bit more involved as there now may be internal padding. The indexing now becomes

N :: len(Map_Cell(T){}.data) i := index / N j := index % N cell[i].data[j]

However, since len(Map_Cell(T){}.data) is a compile-time constant, there are some optimizations we can do to eliminate the need for any divisions as N will be bounded by [1, 64).

In the optimal case, len(Map_Cell(T){}.data) = 1 so the cell array can be treated as a regular array of T, which is the case for hashes.

Map_Cell_Info ¶

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,
}
 

So we can operate on a cell data structure at runtime without any type information, we have a simple table that stores some traits about the cell.

32-bytes on 64-bit 16-bytes on 32-bit

Map_Hash ¶

Map_Hash :: uintptr

Map_Info ¶

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: , seed: ) -> uintptr,
	// 8-bytes on 64-bit, 4-bytes on 32-bit
	key_equal:  proc "contextless" (lhs, rhs: ) -> bool,
}
 

When working with the type-erased structure at runtime we need information about the map to make working with it possible. This info structure stores that.

Map_Info and Map_Cell_Info are read only data structures and cannot be modified after creation

32-bytes on 64-bit 16-bytes on 32-bit

Maybe ¶

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

Odin_Arch_Type ¶

Odin_Arch_Type :: .Odin_Arch_Type
 

// Defined internally by the compiler

Odin_Arch_Type :: enum int {
	Unknown,
	amd64,
	i386,
	arm32,
	arm64,
	wasm32,
	wasm64,
}

Odin_Build_Mode_Type ¶

Odin_Build_Mode_Type :: .Odin_Build_Mode_Type
 

// Defined internally by the compiler

Odin_Build_Mode_Type :: enum int {
	Executable,
	Dynamic,
	Object,
	Assembly,
	LLVM_IR,
}

Odin_Endian_Type ¶

Odin_Endian_Type :: .Odin_Endian_Type
 

// Defined internally by the compiler

Odin_Endian_Type :: enum int {
	Unknown,
	Little,
	Big,
}

Odin_OS_Type ¶

Odin_OS_Type :: .Odin_OS_Type
 

// Defined internally by the compiler

Odin_OS_Type :: enum int {
	Unknown,
	Windows,
	Darwin,
	Linux,
	Essence,
	FreeBSD,
	OpenBSD,
	WASI,
	JS,
	Freestanding,
}

Platform_Endianness ¶

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

Raw_Any ¶

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

Raw_Cstring ¶

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

Raw_Dynamic_Array ¶

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

Raw_Map ¶

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:       int,
	// 8-bytes on 64-bits, 4-bytes on 32-bits
	allocator: Allocator,
}
 

The raw, type-erased representation of a map.

32-bytes on 64-bit 16-bytes on 32-bit

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

Raw_Slice ¶

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

Raw_Soa_Pointer ¶

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

Raw_String ¶

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

Source_Code_Location ¶

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

Type_Info_Any ¶

Type_Info_Any :: struct {}

Type_Info_Array ¶

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

Type_Info_Bit_Set ¶

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

Type_Info_Boolean ¶

Type_Info_Boolean :: struct {}

Type_Info_Complex ¶

Type_Info_Complex :: struct {}

Type_Info_Dynamic_Array ¶

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

Type_Info_Enum ¶

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

Type_Info_Enum_Value ¶

Type_Info_Enum_Value :: distinct i64

Type_Info_Enumerated_Array ¶

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 ¶

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

Type_Info_Flags ¶

Type_Info_Flags :: distinct bit_set[Type_Info_Flag; u32]

Type_Info_Float ¶

Type_Info_Float :: struct {
	endianness: Platform_Endianness,
}

Type_Info_Integer ¶

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

Type_Info_Map ¶

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

Type_Info_Matrix ¶

Type_Info_Matrix :: struct {
	elem:         ^Type_Info,
	elem_size:    int,
	elem_stride:  int,
	// elem_stride >= row_count
	row_count:    int,
	column_count: int,
}

Type_Info_Multi_Pointer ¶

Type_Info_Multi_Pointer :: struct {
	elem: ^Type_Info,
}

Type_Info_Named ¶

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

Variant Types

Type_Info_Pointer ¶

Type_Info_Pointer :: struct {
	elem: ^Type_Info,
}

Type_Info_Procedure ¶

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

Type_Info_Quaternion ¶

Type_Info_Quaternion :: struct {}

Type_Info_Relative_Pointer ¶

Type_Info_Relative_Pointer :: struct {
	pointer:      ^Type_Info,
	base_integer: ^Type_Info,
}

Type_Info_Relative_Slice ¶

Type_Info_Relative_Slice :: struct {
	slice:        ^Type_Info,
	base_integer: ^Type_Info,
}

Type_Info_Rune ¶

Type_Info_Rune :: struct {}

Type_Info_Simd_Vector ¶

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

Type_Info_Slice ¶

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

Type_Info_Soa_Pointer ¶

Type_Info_Soa_Pointer :: struct {
	elem: ^Type_Info,
}

Type_Info_String ¶

Type_Info_String :: struct {
	is_cstring: bool,
}

Type_Info_Struct ¶

Type_Info_Struct :: struct {
	types:         []^Type_Info,
	names:         []string,
	offsets:       []uintptr,
	usings:        []bool,
	tags:          []string,
	is_packed:     bool,
	is_raw_union:  bool,
	custom_align:  bool,
	equal:         Equal_Proc,
	// These are only set iff this structure is an SOA structure
	soa_kind:      Type_Info_Struct_Soa_Kind,
	soa_base_type: ^Type_Info,
	soa_len:       int,
}

Type_Info_Struct_Soa_Kind ¶

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

Type_Info_Tuple ¶

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

Type_Info_Type_Id ¶

Type_Info_Type_Id :: struct {}

Type_Info_Union ¶

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_Kind ¶

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, 
	Relative_Pointer, 
	Relative_Slice, 
	Matrix, 
}
 

NOTE(bill): This must match the compiler's

Constants

Byte ¶

Byte :: 1

DEFAULT_ALIGNMENT ¶

DEFAULT_ALIGNMENT :: 2 * align_of(rawptr)

DEFAULT_RESERVE_CAPACITY ¶

DEFAULT_RESERVE_CAPACITY :: 16

DEFAULT_TEMP_ALLOCATOR_BACKING_SIZE ¶

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

Gigabyte ¶

Gigabyte :: 1024 * Megabyte

HASH_MASK ¶

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

INITIAL_HASH_SEED ¶

INITIAL_HASH_SEED :: 0xcbf29ce484222325

Kilobyte ¶

Kilobyte :: 1024 * Byte

MAP_CACHE_LINE_LOG2 ¶

MAP_CACHE_LINE_LOG2 :: 6
 

This is safe to change. The log2 size of a cache-line. At minimum it has to be six though. Higher cache line sizes are permitted.

MAP_CACHE_LINE_SIZE ¶

MAP_CACHE_LINE_SIZE :: 1 << MAP_CACHE_LINE_LOG2
 

The size of a cache-line.

MAP_LOAD_FACTOR ¶

MAP_LOAD_FACTOR :: 75
 

With Robin Hood hashing a maximum load factor of 75% is ideal.

MAP_MIN_LOG2_CAPACITY ¶

MAP_MIN_LOG2_CAPACITY :: 6
 

Minimum log2 capacity.

Megabyte ¶

Megabyte :: 1024 * Kilobyte

RUNTIME_REQUIRE ¶

RUNTIME_REQUIRE :: true

TOMBSTONE_MASK ¶

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

Terabyte ¶

Terabyte :: 1024 * Gigabyte

Variables

args__ ¶

args__: []cstring

global_default_temp_allocator_data ¶

@(thread_local)
global_default_temp_allocator_data: Default_Temp_Allocator

type_table ¶

type_table: []Type_Info
 

NOTE(bill): only the ones that are needed (not all types) This will be set by the compiler

Procedures

abs_complex128 ¶

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

abs_complex32 ¶

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

abs_complex64 ¶

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

abs_f16 ¶

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

abs_f32 ¶

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

abs_f64 ¶

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

abs_quaternion128 ¶

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

abs_quaternion256 ¶

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

abs_quaternion64 ¶

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

align_forward_int ¶

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

align_forward_uintptr ¶

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

append_elem ¶

append_elem :: proc "odin" (array: ^$T/[dynamic]$, arg: $, loc := #caller_location) -> int {…}

append_elem_string ¶

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

append_elems ¶

append_elems :: proc "odin" (array: ^$T/[dynamic]$, args: ..$, loc := #caller_location) -> int {…}

append_nothing ¶

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

append_soa_elem ¶

append_soa_elem :: proc "odin" (array: ^$T/#soa[dynamic], arg: $, loc := #caller_location) {…}

append_soa_elems ¶

append_soa_elems :: proc "odin" (array: ^$T/#soa[dynamic], args: ..$, loc := #caller_location) {…}

append_string ¶

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

assert ¶

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

assign_at_elem ¶

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

assign_at_elem_string ¶

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

assign_at_elems ¶

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

bounds_check_error ¶

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

bounds_check_error_loc ¶

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

bounds_trap ¶

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

bswap_128 ¶

bswap_128 :: proc "contextless" (x: u128) -> u128 {…}

bswap_16 ¶

bswap_16 :: proc "contextless" (x: u16) -> u16 {…}

bswap_32 ¶

bswap_32 :: proc "contextless" (x: u32) -> u32 {…}

bswap_64 ¶

bswap_64 :: proc "contextless" (x: u64) -> u64 {…}

bswap_f16 ¶

bswap_f16 :: proc "contextless" (f: f16) -> f16 {…}

bswap_f32 ¶

bswap_f32 :: proc "contextless" (f: f32) -> f32 {…}

bswap_f64 ¶

bswap_f64 :: proc "contextless" (f: f64) -> f64 {…}

card ¶

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

clear_dynamic_array ¶

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

clear_map ¶

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

complex128_eq ¶

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

complex128_ne ¶

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

complex32_eq ¶

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

complex32_ne ¶

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

complex64_eq ¶

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

complex64_ne ¶

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

container_of ¶

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

copy_from_string ¶

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

copy_slice ¶

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

cstring_len ¶

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

cstring_to_string ¶

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

debug_trap ¶

debug_trap :: intrinsics.debug_trap

default_allocator ¶

default_allocator :: proc "odin" () -> Allocator {…}

default_allocator_proc ¶

default_allocator_proc :: proc "odin" (
	allocator_data:  rawptr, 
	mode:            Allocator_Mode, 
	size, alignment: int, 
	old_memory:      rawptr, 
	old_size:        int, 
) -> (data: []u8, err: Allocator_Error) {…}

default_assertion_failure_proc ¶

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

default_context ¶

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

default_hasher ¶

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

default_hasher_cstring ¶

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

default_hasher_string ¶

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

default_logger ¶

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

default_logger_proc ¶

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

default_temp_allocator ¶

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

default_temp_allocator_destroy ¶

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

default_temp_allocator_init ¶

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

default_temp_allocator_proc ¶

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

delete_cstring ¶

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

delete_dynamic_array ¶

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

delete_key ¶

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

delete_map ¶

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

delete_slice ¶

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

delete_soa_dynamic_array ¶

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

delete_soa_slice ¶

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

delete_string ¶

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

divmodti4 ¶

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

divti3 ¶

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

dynamic_array_expr_error ¶

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

dynamic_array_expr_error_loc ¶

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

encode_rune ¶

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

excl_bit_set ¶

excl_bit_set :: proc "odin" (s: ^$S/bit_set[$], other: $S/bit_set[$]) {…}

excl_elem ¶

excl_elem :: proc "odin" (s: ^$S/bit_set[$], elem: $) {…}

excl_elems ¶

excl_elems :: proc "odin" (s: ^$S/bit_set[$], elems: ..$) {…}

extendhfsf2 ¶

extendhfsf2 :: proc "cdecl" (value: u16) -> f32 {…}

fixdfti ¶

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

fixunsdfdi ¶

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

fixunsdfti ¶

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

floattidf ¶

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

floattidf_unsigned ¶

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

gnu_f2h_ieee ¶

gnu_f2h_ieee :: proc "cdecl" (value: f32) -> u16 {…}

gnu_h2f_ieee ¶

gnu_h2f_ieee :: proc "cdecl" (value: u16) -> f32 {…}

hermitian_adjoint ¶

hermitian_adjoint :: proc "contextless" (m: $M/matrix[0, 0]$) -> $M/matrix[0, 0]$ {…}

incl_bit_set ¶

incl_bit_set :: proc "odin" (s: ^$S/bit_set[$], other: $S/bit_set[$]) {…}

incl_elem ¶

incl_elem :: proc "odin" (s: ^$S/bit_set[$], elem: $) {…}

incl_elems ¶

incl_elems :: proc "odin" (s: ^$S/bit_set[$], elems: ..$) {…}

init_global_temporary_allocator ¶

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

inject_at_elem ¶

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

inject_at_elem_string ¶

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

inject_at_elems ¶

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

is_power_of_two_int ¶

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

is_power_of_two_uintptr ¶

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

make_aligned ¶

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

make_dynamic_array ¶

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

make_dynamic_array_error_loc ¶

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

make_dynamic_array_len ¶

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

make_dynamic_array_len_cap ¶

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

make_map ¶

make_map :: proc "odin" ($T: typeid/map[$]$, #any_int capacity: int = 1 << MAP_MIN_LOG2_CAPACITY, allocator := context.allocator, loc := #caller_location) -> T {…}

make_map_expr_error_loc ¶

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

make_multi_pointer ¶

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

make_slice ¶

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

make_slice_error_loc ¶

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

make_soa_aligned ¶

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

make_soa_dynamic_array ¶

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

make_soa_dynamic_array_len ¶

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

make_soa_dynamic_array_len_cap ¶

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

make_soa_slice ¶

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

map_alloc_dynamic ¶

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

map_cap ¶

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

map_cell_index_dynamic ¶

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

map_cell_index_dynamic_const ¶

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

map_cell_index_static ¶

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

map_cell_info ¶

map_cell_info :: intrinsics.type_map_cell_info
 

map_cell_info :: proc "contextless" ($T: typeid) -> ^Map_Cell_Info {...}

map_clear_dynamic ¶

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

map_data ¶

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

map_desired_position ¶

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

map_erase_dynamic ¶

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 ¶

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

map_free_dynamic ¶

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

map_get ¶

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

map_grow_dynamic ¶

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

map_hash_is_deleted ¶

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

map_hash_is_empty ¶

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

map_hash_is_valid ¶

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

map_info ¶

map_info :: intrinsics.type_map_info
 

The Map_Info structure is basically a pseudo-table of information for a given K and V pair. map_info :: proc "contextless" ($T: typeid/map[$K]$V) -> ^Map_Info {...}

map_insert ¶

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

map_insert_hash_dynamic ¶

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

map_kvh_data_dynamic ¶

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 ¶

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

map_kvh_data_values_dynamic ¶

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

map_len ¶

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

map_load_factor ¶

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

map_log2_cap ¶

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

map_lookup_dynamic ¶

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

map_probe_distance ¶

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

map_reserve_dynamic ¶

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

map_resize_threshold ¶

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

map_shrink_dynamic ¶

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

matrix1x1_adjugate ¶

matrix1x1_adjugate :: proc "contextless" (x: $M/matrix[1, 1]$) -> (y: $M/matrix[1, 1]$) {…}

matrix1x1_determinant ¶

matrix1x1_determinant :: proc "contextless" (m: $M/matrix[1, 1]$) -> (det: $) {…}

matrix1x1_inverse ¶

matrix1x1_inverse :: proc "contextless" (x: $M/matrix[1, 1]$) -> (y: $M/matrix[1, 1]$) {…}

matrix1x1_inverse_transpose ¶

matrix1x1_inverse_transpose :: proc "contextless" (x: $M/matrix[1, 1]$) -> (y: $M/matrix[1, 1]$) {…}

matrix2x2_adjugate ¶

matrix2x2_adjugate :: proc "contextless" (x: $M/matrix[2, 2]$) -> (y: $M/matrix[2, 2]$) {…}

matrix2x2_determinant ¶

matrix2x2_determinant :: proc "contextless" (m: $M/matrix[2, 2]$) -> (det: $) {…}

matrix2x2_inverse ¶

matrix2x2_inverse :: proc "contextless" (x: $M/matrix[2, 2]$) -> (y: $M/matrix[2, 2]$) {…}

matrix2x2_inverse_transpose ¶

matrix2x2_inverse_transpose :: proc "contextless" (x: $M/matrix[2, 2]$) -> (y: $M/matrix[2, 2]$) {…}

matrix3x3_adjugate ¶

matrix3x3_adjugate :: proc "contextless" (m: $M/matrix[3, 3]$) -> (y: $M/matrix[3, 3]$) {…}

matrix3x3_determinant ¶

matrix3x3_determinant :: proc "contextless" (m: $M/matrix[3, 3]$) -> (det: $) {…}

matrix3x3_inverse ¶

matrix3x3_inverse :: proc "contextless" (x: $M/matrix[3, 3]$) -> (y: $M/matrix[3, 3]$) {…}

matrix3x3_inverse_transpose ¶

matrix3x3_inverse_transpose :: proc "contextless" (x: $M/matrix[3, 3]$) -> (y: $M/matrix[3, 3]$) {…}

matrix4x4_adjugate ¶

matrix4x4_adjugate :: proc "contextless" (x: $A/matrix[4, 4]$) -> (y: $A/matrix[4, 4]$) {…}

matrix4x4_determinant ¶

matrix4x4_determinant :: proc "contextless" (m: $A/matrix[4, 4]$) -> (det: $) {…}

matrix4x4_inverse ¶

matrix4x4_inverse :: proc "contextless" (x: $A/matrix[4, 4]$) -> (y: $A/matrix[4, 4]$) {…}

matrix4x4_inverse_transpose ¶

matrix4x4_inverse_transpose :: proc "contextless" (x: $A/matrix[4, 4]$) -> (y: $A/matrix[4, 4]$) {…}

matrix_bounds_check_error ¶

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

matrix_minor ¶

matrix_minor :: proc "contextless" (m: $M/matrix[0, 0]$, row, column: int) -> (minor: $) {…}

matrix_trace ¶

matrix_trace :: proc "contextless" (m: $M/matrix[0, 0]$) -> (trace: $) {…}

max_f16 ¶

max_f16 :: proc "contextless" (a, b: f16) -> f16 {…}

max_f32 ¶

max_f32 :: proc "contextless" (a, b: f32) -> f32 {…}

max_f64 ¶

max_f64 :: proc "contextless" (a, b: f64) -> f64 {…}

mem_alloc ¶

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

mem_alloc_bytes ¶

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

mem_alloc_non_zeroed ¶

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

mem_copy ¶

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

mem_copy_non_overlapping ¶

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

mem_free ¶

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

mem_free_all ¶

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

mem_free_bytes ¶

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

mem_free_with_size ¶

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

mem_resize ¶

mem_resize :: proc "odin" (
	ptr:                rawptr, 
	old_size, new_size: int, 
	alignment:          int = DEFAULT_ALIGNMENT, 
	allocator := context.allocator, 
) -> ([]u8, Allocator_Error) {…}

mem_zero ¶

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

memory_compare ¶

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

memory_compare_zero ¶

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

memory_equal ¶

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

memset ¶

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

min_f16 ¶

min_f16 :: proc "contextless" (a, b: f16) -> f16 {…}

min_f32 ¶

min_f32 :: proc "contextless" (a, b: f32) -> f32 {…}

min_f64 ¶

min_f64 :: proc "contextless" (a, b: f64) -> f64 {…}

modti3 ¶

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

mul_quaternion128 ¶

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

mul_quaternion256 ¶

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

mul_quaternion64 ¶

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

multi_pointer_slice_expr_error ¶

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

multi_pointer_slice_handle_error ¶

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

new ¶

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

new_aligned ¶

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

new_clone ¶

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

nil_allocator ¶

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

nil_allocator_proc ¶

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

ordered_remove ¶

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

os_write ¶

os_write :: proc "contextless" (data: []u8) -> (int, _OS_Errno) {…}

panic ¶

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

pop ¶

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

pop_front ¶

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

pop_front_safe ¶

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

pop_safe ¶

pop_safe :: proc "odin" (array: ^$T/[dynamic]$) -> (res: $, ok: bool) {…}
print_byte :: proc "contextless" (b: u8) -> (int, _OS_Errno) {…}
print_caller_location :: proc "contextless" (using 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, _OS_Errno) {…}
print_string :: proc "contextless" (str: string) -> (int, _OS_Errno) {…}
print_strings :: proc "contextless" (args: ..string) -> (n: int, err: _OS_Errno) {…}
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) {…}

quaternion128_eq ¶

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

quaternion128_ne ¶

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

quaternion256_eq ¶

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

quaternion256_ne ¶

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

quaternion64_eq ¶

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

quaternion64_ne ¶

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

quo_complex128 ¶

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

quo_complex32 ¶

quo_complex32 :: proc "contextless" (n, m: complex32) -> complex32 {…}

quo_complex64 ¶

quo_complex64 :: proc "contextless" (n, m: complex64) -> complex64 {…}

quo_quaternion128 ¶

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

quo_quaternion256 ¶

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

quo_quaternion64 ¶

quo_quaternion64 :: proc "contextless" (q, r: quaternion64) -> quaternion64 {…}
raw_soa_footer_dynamic_array :: proc "odin" (array: ^$T/#soa[dynamic]) -> (footer: ^Raw_SOA_Footer_Dynamic_Array) {…}
raw_soa_footer_slice :: proc "odin" (array: ^$T/#soa[]) -> (footer: ^Raw_SOA_Footer_Slice) {…}

read_cycle_counter ¶

read_cycle_counter :: intrinsics.read_cycle_counter

remove_range ¶

remove_range :: proc "odin" (array: ^$T/[dynamic]$, lo, hi: int, loc := #caller_location) {…}

reserve_dynamic_array ¶

reserve_dynamic_array :: proc "odin" (array: ^$T/[dynamic]$, capacity: int, loc := #caller_location) -> bool {…}

reserve_map ¶

reserve_map :: proc "odin" (m: ^$T/map[$]$, capacity: int, loc := #caller_location) {…}

reserve_soa ¶

reserve_soa :: proc "odin" (array: ^$T/#soa[dynamic], capacity: int, loc := #caller_location) -> bool {…}

resize_dynamic_array ¶

resize_dynamic_array :: proc "odin" (array: ^$T/[dynamic]$, length: int, loc := #caller_location) -> bool {…}

resize_soa ¶

resize_soa :: proc "odin" (array: ^$T/#soa[dynamic], length: int, loc := #caller_location) -> bool {…}

shrink_dynamic_array ¶

shrink_dynamic_array :: proc "odin" (array: ^$T/[dynamic]$, new_cap: int = -1, loc := #caller_location) -> (did_shrink: bool) {…}
 

Shrinks the capacity of a dynamic array down to the current length, or the given capacity.

If `new_cap` is negative, then `len(array)` is used.

Returns false if `cap(array) < new_cap`, or the allocator report failure.

If `len(array) < new_cap`, then `len(array)` will be left unchanged.

shrink_map ¶

shrink_map :: proc "odin" (m: ^$T/map[$]$, loc := #caller_location) -> (did_shrink: bool) {…}

slice_expr_error_hi ¶

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

slice_expr_error_hi_loc ¶

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

slice_expr_error_lo_hi ¶

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

slice_expr_error_lo_hi_loc ¶

slice_expr_error_lo_hi_loc :: proc "contextless" (using loc := #caller_location, lo, hi: int, len: int) {…}

slice_handle_error ¶

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

string_cmp ¶

string_cmp :: proc "contextless" (a, b: string) -> int {…}

string_decode_rune ¶

string_decode_rune :: proc "contextless" (s: string) -> (rune, int) {…}

string_eq ¶

string_eq :: proc "contextless" (lhs, rhs: string) -> bool {…}

string_ge ¶

string_ge :: proc "contextless" (a, b: string) -> bool {…}

string_gt ¶

string_gt :: proc "contextless" (a, b: string) -> bool {…}

string_le ¶

string_le :: proc "contextless" (a, b: string) -> bool {…}

string_lt ¶

string_lt :: proc "contextless" (a, b: string) -> bool {…}

string_ne ¶

string_ne :: proc "contextless" (a, b: string) -> bool {…}

trap ¶

trap :: intrinsics.trap

truncdfhf2 ¶

truncdfhf2 :: proc "cdecl" (value: f64) -> u16 {…}

truncsfhf2 ¶

truncsfhf2 :: proc "cdecl" (value: f32) -> u16 {…}

type_assertion_check ¶

type_assertion_check :: proc "contextless" (
	ok:           bool, 
	file:         string, 
	line, column: i32, 
	from, 
) {…}

type_assertion_check2 ¶

type_assertion_check2 :: proc "contextless" (
	ok:           bool, 
	file:         string, 
	line, column: i32, 
	from, to:     typeid, 
) {…}

type_assertion_trap ¶

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

type_info_base ¶

type_info_base :: proc "contextless" (info: ^Type_Info) -> ^Type_Info {…}

type_info_base_without_enum ¶

type_info_base_without_enum :: type_info_core

type_info_core ¶

type_info_core :: proc "contextless" (info: ^Type_Info) -> ^Type_Info {…}

typeid_base ¶

typeid_base :: proc "contextless" (id: typeid) -> typeid {…}

typeid_base_without_enum ¶

typeid_base_without_enum :: typeid_core

typeid_core ¶

typeid_core :: proc "contextless" (id: typeid) -> typeid {…}

udivmod128 ¶

udivmod128 :: proc "cdecl" (a, b: u128, rem: ^u128) -> u128 {…}

udivmodti4 ¶

udivmodti4 :: proc "cdecl" (a, b: u128, rem: ^u128) -> u128 {…}

udivti3 ¶

udivti3 :: proc "cdecl" (a, b: u128) -> u128 {…}

umodti3 ¶

umodti3 :: proc "cdecl" (a, b: u128) -> u128 {…}

unimplemented ¶

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

unordered_remove ¶

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

Procedure Groups

free ¶

free :: proc{
	mem_free,
}

free_all ¶

free_all :: proc{
	mem_free_all,
}

Source Files

Generation Information

Generated with odin version dev-2023-01 (vendor "odin") Windows_amd64 @ 2023-01-15 21:08:15.353092500 +0000 UTC