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 (74)
Procedures (258)

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

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" (logger_data: rawptr, level: Logger_Level, text: string, options: bit_set[Logger_Option], location := #caller_location)

Map_Entry_Header ¶

Map_Entry_Header :: struct {
	hash: uintptr,
	next: Map_Index,
}

Map_Find_Result ¶

Map_Find_Result :: struct {
	hash_index:  Map_Index,
	entry_prev:  Map_Index,
	entry_index: Map_Index,
}

Map_Hash ¶

Map_Hash :: struct {
	hash:    uintptr,
	key_ptr: rawptr,
}
 

Temporary data structure for comparing hashes and keys

Map_Header ¶

Map_Header :: struct {
	m:     ^Raw_Map,
	table: Map_Header_Table,
}

Map_Header_Table ¶

Map_Header_Table :: struct {
	equal:        Equal_Proc,
	entry_size:   int,
	entry_align:  int,
	key_offset:   uintptr,
	key_size:     int,
	value_offset: uintptr,
	value_size:   int,
}

Map_Index ¶

Map_Index :: distinct uint

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 {
	hashes:  []Map_Index,
	entries: Raw_Dynamic_Array,
}
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($Key: typeid, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {}

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($Key: typeid, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {}

Type_Info_Complex ¶

Type_Info_Complex :: struct($Key: typeid, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {}

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,
	generated_struct: ^Type_Info,
	key_equal:        Equal_Proc,
	key_hasher:       Hasher_Proc,
}

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($Key: typeid, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {}

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($Key: typeid, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {}

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($Key: typeid, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {}

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

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, 1 << 22)

INITIAL_HASH_SEED ¶

INITIAL_HASH_SEED :: 0xcbf29ce484222325

INITIAL_MAP_CAP ¶

INITIAL_MAP_CAP :: 16

MAP_SENTINEL ¶

MAP_SENTINEL: Map_Index : ~Map_Index(0)

RUNTIME_REQUIRE ¶

RUNTIME_REQUIRE :: true

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, len, cap: 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" (x: f16) -> f16 {…}

bswap_f32 ¶

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

bswap_f64 ¶

bswap_f64 :: proc "contextless" (x: 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, 
) -> ([]u8, 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_hash ¶

default_hash :: proc "contextless" (data: []u8) -> uintptr {…}

default_hash_ptr ¶

default_hash_ptr :: proc "contextless" (data: rawptr, size: int) -> uintptr {…}

default_hash_string ¶

default_hash_string :: proc "contextless" (s: string) -> uintptr {…}

default_hasher1 ¶

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

default_hasher10 ¶

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

default_hasher11 ¶

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

default_hasher12 ¶

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

default_hasher13 ¶

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

default_hasher14 ¶

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

default_hasher15 ¶

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

default_hasher16 ¶

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

default_hasher2 ¶

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

default_hasher3 ¶

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

default_hasher4 ¶

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

default_hasher5 ¶

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

default_hasher6 ¶

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

default_hasher7 ¶

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

default_hasher8 ¶

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

default_hasher9 ¶

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

default_hasher_cstring ¶

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

default_hasher_n ¶

default_hasher_n :: proc "contextless" (data: rawptr, seed: uintptr, N: int) -> 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" (logger_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, 
) -> ([]u8, 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, 
	lo, hi:       int, 
) {…}

dynamic_array_expr_error_loc ¶

dynamic_array_expr_error_loc :: proc "contextless" (using loc := #caller_location, lo, hi: int, len: 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" (a: 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 cap: int = DEFAULT_RESERVE_CAPACITY, allocator := context.allocator, loc := #caller_location) -> T {…}

make_map_expr_error_loc ¶

make_map_expr_error_loc :: proc "contextless" (loc := #caller_location, len: 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_insert ¶

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

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" (m: $M/matrix[3, 3]$) -> (y: $M/matrix[3, 3]$) {…}

matrix3x3_inverse_transpose ¶

matrix3x3_inverse_transpose :: proc "contextless" (m: $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" (x, base: f16) -> f16 {…}

max_f32 ¶

max_f32 :: proc "contextless" (x, base: f32) -> f32 {…}

max_f64 ¶

max_f64 :: proc "contextless" (x, base: 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_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) -> 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" (x, base: f16) -> f16 {…}

min_f32 ¶

min_f32 :: proc "contextless" (x, base: f32) -> f32 {…}

min_f64 ¶

min_f64 :: proc "contextless" (x, base: 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, index, count: 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_array_data ¶

raw_array_data :: proc "contextless" (a: $P/^$V/[0]$) -> [^]$ {…}

raw_dynamic_array_data ¶

raw_dynamic_array_data :: proc "contextless" (s: $T/[dynamic]$) -> [^]$ {…}

raw_simd_data ¶

raw_simd_data :: proc "contextless" (a: $P/^$T/#simd[0]) -> [^]$ {…}

raw_slice_data ¶

raw_slice_data :: proc "contextless" (s: $T/[]$) -> [^]$ {…}
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) {…}

raw_string_data ¶

raw_string_data :: proc "contextless" (s: $S/string) -> [^]u8 {…}

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], length: int, loc := #caller_location) -> bool {…}

resize_dynamic_array ¶

resize_dynamic_array :: proc "odin" (array: ^$T/[dynamic]$, capacity: 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]$, capacity: int, loc := #caller_location) -> 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[$]$, new_cap: int = -1, loc := #caller_location) -> (did_shrink: bool) {…}

slice_expr_error_hi ¶

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

slice_expr_error_hi_loc ¶

slice_expr_error_hi_loc :: proc "contextless" (using loc := #caller_location, len, cap: 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" (lhs, rhs: string) -> bool {…}

string_gt ¶

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

string_le ¶

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

string_lt ¶

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

string_ne ¶

string_ne :: proc "contextless" (lhs, rhs: 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-2022-10 (vendor "odin") Windows_amd64 @ 2022-10-05 21:11:47.492418600 +0000 UTC