package base:runtime
Source

⌘K
Ctrl+K
or
/

    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

    Declarations which are required by the compiler

    Descriptions of files

    There are a lot of files in this package and below is described roughly what kind of functionality is placed in different files:

    | File pattern | Description |----------------------|------------------------------------------------------| | core.odin | Contains the declarations that compiler will require to be present. Contains context-related declarations, Type_Info declarations and some other types used to implement the runtime and other packages. | | core_builtin*.odin | Contain @(builtin) declarations that can be used without importing the package. Most of them aren't required by the compiler | | default_*.odin | Contain default implementations for context allocators | | entry_*.odin | Contain OS-specific entry points | | os_specific_*.odin | Contain OS-specific utility procedures | | *internal*.odin | Contain implementations for internal procedures that can be called by the compiler |

    Implementing custom runtime

    For embedded and kernel development it might be required to re-implement parts of the base:runtime package. This can include changing the default printing procedures that handle console output when the program panics, custom entry-points, tailored for a specific platform or execution environment, or simply switching up implementations of some procedures.

    In case this is required, the following is suggested:

    1. Define $ODIN_ROOT environment variable to point to a directory within your project that contains the following directories: base/, core/ and vendor/. 2. Inside the $ODIN_ROOT/base subdirectory, implement the *necessary declarations*.

    What constitutes the necessary definitions is described below.

    Context-related

    The compiler will require these declarations as they concern the context variable.

    Maybe Source_Code_Location Context Allocator Random_Generator Logger __init_context

    Runtime initialization/cleanup

    These are not strictly required for compilation, but if global variables or @(init)/@(fini) blocks are used, these procedures need to be called inside the entry point.

    _startup_runtime _cleanup_runtime

    Type assertion check

    These procedures are called every time .(Type) expressions are used in order to check the union tag or the underlying type of any before returning the value of the underlying type. These are not required if -no-type-assert is specified.

    type_assertion_check type_assertion_check2 (takes in typeid)

    Bounds checking procedures

    These procedures are called every time index or slicing expression are used in order to perform bounds-checking before the actual operation. These are not required if the -no-bounds-check option is specified.

    bounds_check_error matrix_bounds_check_error slice_expr_error_hi slice_expr_error_lo_hi multi_pointer_slice_expr_error

    cstring calls

    If cstring or cstring16 types are used, these procedures are required.

    cstring_to_string cstring_len cstring16_to_string16 cstring16_len

    Comparison

    These procedures are required for comparison operators between strings and other compound types to function properly. If strings, structs nor unions are compared, only string_eq procedure is required.

    memory_equal memory_compare memory_compare_zero cstring_eq cstring16_eq cstring_ne cstring16_ne cstring_lt cstring16_lt cstring_gt cstring16_gt cstring_le cstring16_le cstring_ge cstring16_ge string_eq string16_eq string_ne string16_ne string_lt string16_lt string_gt string16_gt string_le string16_le string_ge string16_ge complex32_eq complex32_ne complex64_eq complex64_ne complex128_eq complex128_ne quaternion64_eq quaternion64_ne quaternion128_eq quaternion128_ne quaternion256_eq quaternion256_ne

    for-in string type

    These procedures are required to iterate strings using for ... in loop. If this kind of loop isn't used, these procedures aren't required.

    string_decode_rune string_decode_last_rune (for #reverse for)

    Required when RTTI is enabled (the vast majority of targets)

    These declarations are required unless the -no-rtti compiler option is specified. Note that in order to be useful, some other procedures need to be implemented. Those procedures aren't mentioned here as the compiler won't complain if they're missing.

    Type_Info type_table __type_info_of

    Hashing

    Required if maps are used

    default_hasher default_hasher_cstring default_hasher_string

    Pseudo-CRT required procedured due to LLVM but useful in general

    memset memcpy memove

    Procedures required by the LLVM backend if u128/i128 is used

    umodti3 udivti3 modti3 divti3 fixdfti fixunsdfti fixunsdfdi floattidf floattidf_unsigned truncsfhf2 truncdfhf2 gnu_h2f_ieee gnu_f2h_ieee extendhfsf2

    Procedures required by the LLVM backend if f16 is used (WASM only)

    __ashlti3 __multi3

    When -no-crt is defined (windows only)

    _tls_index _fltused

    Arithmetic

    quo_complex32 quo_complex64 quo_complex128

    mul_quaternion64 mul_quaternion128 mul_quaternion256

    quo_quaternion64 quo_quaternion128 quo_quaternion256

    abs_complex32 abs_complex64 abs_complex128

    abs_quaternion64 abs_quaternion128 abs_quaternion256

    Map specific calls

    map_seed_from_map_data __dynamic_map_check_grow (for static map calls) map_insert_hash_dynamic (for static map calls) __dynamic_map_get (for dynamic map calls) __dynamic_map_set (for dynamic map calls)

    Dynamic literals ([dynamic]T and map[K]V) (can be disabled with -no-dynamic-literals)

    __dynamic_array_reserve __dynamic_array_append __dynamic_map_reserve

    Objective-C specific

    objc_lookUpClass sel_registerName objc_allocateClassPair

    Other required declarations

    This is required without conditions.

    Load_Directory_File

    Index

    Types (104)
    Procedures (323)

    Types

    Allocator ¶
    Source

    Allocator :: struct {
	procedure: Allocator_Proc,
	data:      rawptr,
}
    Related Procedures With Parameters
    Related Procedures With Returns

    Allocator_Error ¶
    Source

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

    Allocator_Mode ¶
    Source

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

    Allocation Stuff

    Related Procedures With Parameters

    Allocator_Mode_Set ¶
    Source

    Allocator_Mode_Set :: distinct bit_set[Allocator_Mode]

    Allocator_Proc ¶
    Source

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

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

    Arena ¶
    Source

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

    NOTE: This is a growing arena that is only used for the default temp allocator. For your own growing arena needs, prefer Arena from core:mem/virtual.

    Related Procedures With Parameters

    Arena_Temp ¶
    Source

    Arena_Temp :: struct {
	arena: ^Arena,
	block: ^Memory_Block,
	used:  uint,
}
    Related Procedures With Parameters
    Related Procedures With Returns

    Assertion_Failure_Proc ¶
    Source

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

    Allocation Stuff

    Calling_Convention ¶
    Source

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

    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,
}
    Related Procedures With Returns

    DLL_Forward_Reason ¶
    Source

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

    Default_Random_State :: struct {
	state: u64,
	inc:   u64,
}
    Related Procedures With Parameters

    Default_Temp_Allocator ¶
    Source

    Default_Temp_Allocator :: struct {
	arena: Arena,
}
    Related Procedures With Parameters

    Equal_Proc ¶
    Source

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

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

    Hasher_Proc ¶
    Source

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

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

    Load_Directory_File ¶
    Source

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

    Used by the built-in directory #load_directory(path: string) -> []Load_Directory_File

    Logger ¶
    Source

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

    Logger_Level ¶
    Source

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

    Logger_Option ¶
    Source

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

    Logger_Options ¶
    Source

    Logger_Options :: bit_set[Logger_Option]

    Logger_Proc ¶
    Source

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

    Map_Cell ¶
    Source

    Map_Cell :: struct($T: typeid) #align (MAP_CACHE_LINE_SIZE) {
	… // See source for fields
}
     

    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.

    Related Procedures With Parameters
    Related Procedures With Returns

    Map_Cell_Info ¶
    Source

    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

    Related Procedures With Parameters

    Map_Hash ¶
    Source

    Map_Hash :: uintptr

    Map_Info ¶
    Source

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

    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

    Related Procedures With Parameters

    Maybe ¶
    Source

    Maybe :: union($T: typeid) {
	… // See source for fields
}

    Memory_Block ¶
    Source

    Memory_Block :: struct {
	prev:      ^Memory_Block,
	allocator: Allocator,
	base:      [^]u8,
	used:      uint,
	capacity:  uint,
}
    Related Procedures With Parameters
    Related Procedures With Returns

    Objc_Block ¶
    Source

    Objc_Block :: struct($T: typeid) {
	… // See source for fields
}
     

    Represents an Objective-C block with a given procedure signature T

    Odin_Arch_Type ¶
    Source

    Odin_Arch_Type :: .Odin_Arch_Type
     

    // Defined internally by the compiler Odin_Arch_Type :: enum int {

    Unknown,
amd64,
i386,
arm32,
arm64,
wasm32,
wasm64p32,
riscv64,

    }

    Odin_Arch_Types ¶
    Source

    Odin_Arch_Types :: bit_set[.Odin_Arch_Type]
    Related Constants

    Odin_Build_Mode_Type ¶
    Source

    Odin_Build_Mode_Type :: .Odin_Build_Mode_Type
     

    // Defined internally by the compiler Odin_Build_Mode_Type :: enum int {

    Executable,
Dynamic,
Static,
Object,
Assembly,
LLVM_IR,

    }

    Odin_Endian_Type ¶
    Source

    Odin_Endian_Type :: .Odin_Endian_Type
     

    // Defined internally by the compiler Odin_Endian_Type :: enum int {

    Unknown,
Little,
Big,

    }

    Odin_OS_Type ¶
    Source

    Odin_OS_Type :: .Odin_OS_Type
     

    // Defined internally by the compiler Odin_OS_Type :: enum int {

    Unknown,
Windows,
Darwin,
Linux,
Essence,
FreeBSD,
OpenBSD,
NetBSD,
Haiku,
WASI,
JS,
Orca,
Freestanding,

    }

    Odin_OS_Types ¶
    Source

    Odin_OS_Types :: bit_set[.Odin_OS_Type]
    Related Constants

    Odin_Optimization_Mode ¶
    Source

    Odin_Optimization_Mode :: .Odin_Optimization_Mode
     

    // Defined internally by the compiler Odin_Optimization_Mode :: enum int {

    None       = -1,
Minimal    =  0,
Size       =  1,
Speed      =  2,
Aggressive =  3,

    }

    ODIN_OPTIMIZATION_MODE // is a constant

    Odin_Platform_Subtarget_Type ¶
    Source

    Odin_Platform_Subtarget_Type :: .Odin_Platform_Subtarget_Type
     

    // Defined internally by the compiler Odin_Platform_Subtarget_Type :: enum int {

    Default,
iPhone,
iPhoneSimulator
Android,

    }

    Odin_Platform_Subtarget_Types ¶
    Source

    Odin_Platform_Subtarget_Types :: bit_set[.Odin_Platform_Subtarget_Type]

    Odin_Sanitizer_Flags ¶
    Source

    Odin_Sanitizer_Flags :: .Odin_Sanitizer_Flags
     

    // Defined internally by the compiler Odin_Sanitizer_Flag :: enum u32 {

    Address = 0,
Memory  = 1,
Thread  = 2,

    } Odin_Sanitizer_Flags :: distinct bit_set[Odin_Sanitizer_Flag; u32]

    ODIN_SANITIZER_FLAGS // is a constant

    Platform_Endianness ¶
    Source

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

    Random_Generator ¶
    Source

    Random_Generator :: struct {
	procedure: Random_Generator_Proc,
	data:      rawptr,
}
    Related Procedures With Parameters
    Related Procedures With Returns

    Random_Generator_Mode ¶
    Source

    Random_Generator_Mode :: enum int {
	Read, 
	Reset, 
	Query_Info, 
}
    Related Procedures With Parameters

    Random_Generator_Proc ¶
    Source

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

    Random_Generator_Query_Info ¶
    Source

    Random_Generator_Query_Info :: distinct bit_set[Random_Generator_Query_Info_Flag; u32]
    Related Procedures With Returns

    Random_Generator_Query_Info_Flag ¶
    Source

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

    Raw_Any ¶
    Source

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

    Raw_Complex128 ¶
    Source

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

    Raw_Complex32 ¶
    Source

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

    Raw_Complex64 ¶
    Source

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

    Raw_Cstring ¶
    Source

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

    Raw_Cstring16 ¶
    Source

    Raw_Cstring16 :: struct {
	data: [^]u16,
}

    Raw_Dynamic_Array ¶
    Source

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

    Raw_Map ¶
    Source

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

    The raw, type-erased representation of a map.

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

    Related Procedures With Parameters
    Related Procedures With Returns

    Raw_Quaternion128 ¶
    Source

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

    Raw_Quaternion128_Vector_Scalar ¶
    Source

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

    Raw_Quaternion256 ¶
    Source

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

    Raw_Quaternion256_Vector_Scalar ¶
    Source

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

    Raw_Quaternion64 ¶
    Source

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

    Raw_Quaternion64_Vector_Scalar ¶
    Source

    Raw_Quaternion64_Vector_Scalar :: struct {
	vector: [3]f16,
	scalar: f16,
}
    Raw_SOA_Footer_Dynamic_Array :: struct {
	len:       int,
	cap:       int,
	allocator: Allocator,
}
    Related Procedures With Returns
    Raw_SOA_Footer_Slice :: struct {
	len: int,
}
    Related Procedures With Returns

    Raw_Slice ¶
    Source

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

    Raw_Soa_Pointer ¶
    Source

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

    Raw_String ¶
    Source

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

    Raw_String16 ¶
    Source

    Raw_String16 :: struct {
	data: [^]u16,
	len:  int,
}

    Source_Code_Location ¶
    Source

    Source_Code_Location :: struct {
	file_path: string,
	line:      i32,
	column:    i32,
	procedure: string,
}
    Related Procedures With Parameters

    Thread_Local_Cleaner ¶
    Source

    Thread_Local_Cleaner :: union {
	Thread_Local_Cleaner_Odin, 
	Thread_Local_Cleaner_Contextless, 
}
    Related Procedures With Parameters

    Thread_Local_Cleaner_Contextless ¶
    Source

    Thread_Local_Cleaner_Contextless :: proc "contextless" ()

    Thread_Local_Cleaner_Odin ¶
    Source

    Thread_Local_Cleaner_Odin :: proc()

    Type_Info ¶
    Source

    Related Procedures With Parameters

    Type_Info_Any ¶
    Source

    Type_Info_Any :: struct {}

    Type_Info_Array ¶
    Source

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

    Type_Info_Bit_Field ¶
    Source

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

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

    Type_Info_Boolean ¶
    Source

    Type_Info_Boolean :: struct {}

    Type_Info_Complex ¶
    Source

    Type_Info_Complex :: struct {}

    Type_Info_Dynamic_Array ¶
    Source

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

    Type_Info_Enum ¶
    Source

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

    Type_Info_Enum_Value ¶
    Source

    Type_Info_Enum_Value :: distinct i64

    Type_Info_Enumerated_Array ¶
    Source

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

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

    Type_Info_Flags ¶
    Source

    Type_Info_Flags :: distinct bit_set[Type_Info_Flag; u32]

    Type_Info_Float ¶
    Source

    Type_Info_Float :: struct {
	endianness: Platform_Endianness,
}

    Type_Info_Integer ¶
    Source

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

    Type_Info_Map ¶
    Source

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

    Type_Info_Matrix ¶
    Source

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

    Type_Info_Multi_Pointer :: struct {
	elem: ^Type_Info,
}

    Type_Info_Named ¶
    Source

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

    Variant Types

    Type_Info_Parameters ¶
    Source

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

    Type_Info_Pointer ¶
    Source

    Type_Info_Pointer :: struct {
	elem: ^Type_Info,
}

    Type_Info_Procedure ¶
    Source

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

    Type_Info_Quaternion ¶
    Source

    Type_Info_Quaternion :: struct {}

    Type_Info_Rune ¶
    Source

    Type_Info_Rune :: struct {}

    Type_Info_Simd_Vector ¶
    Source

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

    Type_Info_Slice ¶
    Source

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

    Type_Info_Soa_Pointer ¶
    Source

    Type_Info_Soa_Pointer :: struct {
	elem: ^Type_Info,
}

    Type_Info_String ¶
    Source

    Type_Info_String :: struct {
	is_cstring: bool,
	encoding:   Type_Info_String_Encoding_Kind,
}

    Type_Info_String_Encoding_Kind ¶
    Source

    Type_Info_String_Encoding_Kind :: enum u8 {
	UTF_8  = 0, 
	UTF_16 = 1, 
}

    Type_Info_Struct ¶
    Source

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

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

    Type_Info_Struct_Flags ¶
    Source

    Type_Info_Struct_Flags :: distinct bit_set[Type_Info_Struct_Flag; u8]

    Type_Info_Struct_Soa_Kind ¶
    Source

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

    Type_Info_Type_Id ¶
    Source

    Type_Info_Type_Id :: struct {}

    Type_Info_Union ¶
    Source

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

    Constants

    ALL_ODIN_ARCH_TYPES ¶
    Source

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

    ALL_ODIN_OS_TYPES ¶
    Source

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

    Byte: int : 1

    DEFAULT_ALIGNMENT ¶
    Source

    DEFAULT_ALIGNMENT: int : 2 * align_of(rawptr)

    DEFAULT_ARENA_GROWING_MINIMUM_BLOCK_SIZE ¶
    Source

    DEFAULT_ARENA_GROWING_MINIMUM_BLOCK_SIZE :: uint(DEFAULT_TEMP_ALLOCATOR_BACKING_SIZE)

    DEFAULT_DYNAMIC_ARRAY_CAPACITY ¶
    Source

    DEFAULT_DYNAMIC_ARRAY_CAPACITY: int : 8

    DEFAULT_TEMP_ALLOCATOR_BACKING_SIZE ¶
    Source

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

    Exabyte ¶
    Source

    Exabyte: int : 1024 * Petabyte

    Gigabyte ¶
    Source

    Gigabyte: int : 1024 * Megabyte

    HASH_MASK ¶
    Source

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

    HAS_HARDWARE_SIMD ¶
    Source

    HAS_HARDWARE_SIMD: bool : false when (ODIN_ARCH == .amd64 || ODIN_ARCH == .i386) && !intrinsics.has_target_feature("sse2") else false when (ODIN_ARCH == .arm64 || ODIN_ARCH == .arm32) && !intrinsics.has_target_feature("neon") else false when (ODIN_ARCH == .wasm64p32 || ODIN_ARCH == .wasm32) && !intrinsics.has_target_feature("simd128") else false when (ODIN_ARCH == .riscv64) && !intrinsics.has_target_feature("v") else true

    INITIAL_HASH_SEED ¶
    Source

    INITIAL_HASH_SEED: int : 0xcbf29ce484222325

    Kilobyte ¶
    Source

    Kilobyte: int : 1024 * Byte

    MAP_CACHE_LINE_LOG2 ¶
    Source

    MAP_CACHE_LINE_LOG2: int : 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 ¶
    Source

    MAP_CACHE_LINE_SIZE: int : 1 << MAP_CACHE_LINE_LOG2
     

    The size of a cache-line.

    MAP_LOAD_FACTOR ¶
    Source

    MAP_LOAD_FACTOR: int : 75
     

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

    MAP_MIN_LOG2_CAPACITY ¶
    Source

    MAP_MIN_LOG2_CAPACITY: int : 3
     

    Minimum log2 capacity.

    Megabyte ¶
    Source

    Megabyte: int : 1024 * Kilobyte

    NO_DEFAULT_TEMP_ALLOCATOR ¶
    Source

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

    ODIN_PLATFORM_SUBTARGET_IOS ¶
    Source

    ODIN_PLATFORM_SUBTARGET_IOS: bool : ODIN_PLATFORM_SUBTARGET == .iPhone || ODIN_PLATFORM_SUBTARGET == .iPhoneSimulator

    Petabyte ¶
    Source

    Petabyte: int : 1024 * Terabyte

    RUNTIME_REQUIRE ¶
    Source

    RUNTIME_REQUIRE: bool : false
     

    !ODIN_TILDE

    TOMBSTONE_MASK ¶
    Source

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

    Terabyte ¶
    Source

    Terabyte: int : 1024 * Gigabyte

    Variables

    args__ ¶
    Source

    args__: []cstring

    dll_forward_reason ¶
    Source

    dll_forward_reason: DLL_Forward_Reason

    dll_instance ¶
    Source

    dll_instance: rawptr

    global_default_temp_allocator_data ¶
    Source

    @(thread_local)
global_default_temp_allocator_data: Default_Temp_Allocator

    type_table ¶
    Source

    type_table: []^Type_Info
     

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

    Procedures

    DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD ¶
    Source

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

    abs_complex128 ¶
    Source

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

    abs_complex32 ¶
    Source

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

    abs_complex64 ¶
    Source

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

    abs_quaternion128 ¶
    Source

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

    abs_quaternion256 ¶
    Source

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

    abs_quaternion64 ¶
    Source

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

    add_thread_local_cleaner ¶
    Source

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

    Add a procedure that will be run at the end of a thread for the purpose of deallocating state marked as thread_local.

    Intended to be called in an init procedure of a package with dynamically-allocated memory that is stored in thread_local variables.

    aeabi_d2h ¶
    Source

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

    align_forward_int ¶
    Source

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

    align_forward_uint ¶
    Source

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

    align_forward_uintptr ¶
    Source

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

    alloc_from_memory_block ¶
    Source

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

    append_elem ¶
    Source

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

    append_elem_string ¶
    Source

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

    append_elems ¶
    Source

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

    append_nothing ¶
    Source

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

    append_soa_elem ¶
    Source

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

    append_soa_elems ¶
    Source

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

    append_string ¶
    Source

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

    The append_string built-in procedure appends multiple strings to the end of a [dynamic]u8 like type

    arena_alloc ¶
    Source

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

    arena_allocator ¶
    Source

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

    arena_allocator_proc ¶
    Source

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

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

    arena_destroy ¶
    Source

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

    arena_free_all ¶
    Source

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

    arena_free_all will free all but the first memory block, and then reset the memory block

    arena_free_last_memory_block ¶
    Source

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

    arena_init ¶
    Source

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

    arena_init will initialize the arena with a usable block. This procedure is not necessary to use the Arena as the default zero as arena_alloc will set things up if necessary

    arena_temp_begin ¶
    Source

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

    arena_temp_end ¶
    Source

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

    arena_temp_ignore ¶
    Source

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

    Ignore the use of a arena_temp_begin entirely

    assert ¶
    Source

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

    assert_contextless ¶
    Source

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

    assign_at_elem ¶
    Source

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

    assign_at_elem_string ¶
    Source

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

    assign_at_elems ¶
    Source

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

    bounds_check_error ¶
    Source

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

    bounds_check_error_loc ¶
    Source

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

    bounds_trap ¶
    Source

    bounds_trap :: proc "contextless" () {…}

    card ¶
    Source

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

    clear_dynamic_array ¶
    Source

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

    clear_dynamic_array will set the length of a passed dynamic array to 0

    Note: Prefer the procedure group clear.

    clear_map ¶
    Source

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

    clear_map will set the length of a passed map to 0

    Note: Prefer the procedure group clear

    clear_soa_dynamic_array ¶
    Source

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

    complex128_eq ¶
    Source

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

    complex128_ne ¶
    Source

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

    complex32_eq ¶
    Source

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

    complex32_ne ¶
    Source

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

    complex64_eq ¶
    Source

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

    complex64_ne ¶
    Source

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

    container_of ¶
    Source

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

    Recovers the containing/parent struct from a pointer to one of its fields. Works by "walking back" to the struct's starting address using the offset between the field and the struct.

    Inputs:
    ptr: Pointer to the field of a container struct T: The type of the container struct field_name: The name of the field in the T struct

    Returns:
    A pointer to the container struct based on a pointer to a field in it

    Example: 
    package container_of
import "base:runtime"

Node :: struct {
	value: int,
	prev:  ^Node,
	next:  ^Node,
}

main :: proc() {
	node: Node
	field_ptr := &node.next
	container_struct_ptr: ^Node = runtime.container_of(field_ptr, Node, "next")
	assert(container_struct_ptr == &node)
	assert(uintptr(field_ptr) - uintptr(container_struct_ptr) == size_of(node.value) + size_of(node.prev))
}
    Output: 
    ^Node

    copy_from_string ¶
    Source

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

    copy_from_string is a built-in procedure that copies elements from a source string src to a destination slice dst. The source and destination may overlap. Copy returns the number of elements copied, which will be the minimum of len(src) and len(dst).

    Prefer the procedure group copy.

    copy_from_string16 ¶
    Source

    copy_from_string16 :: proc "contextless" (dst: []u16, src: string16) -> int {…}
     

    copy_from_string16 is a built-in procedure that copies elements from a source string src to a destination slice dst. The source and destination may overlap. Copy returns the number of elements copied, which will be the minimum of len(src) and len(dst).

    Prefer the procedure group copy.

    copy_slice ¶
    Source

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

    copy_slice is a built-in procedure that copies elements from a source slice src to a destination slice dst. The source and destination may overlap. Copy returns the number of elements copied, which will be the minimum of len(src) and len(dst).

    Prefer the procedure group copy.

    cstring16_cmp ¶
    Source

    cstring16_cmp :: proc "contextless" (lhs, rhs: cstring16) -> int {…}

    cstring16_eq ¶
    Source

    cstring16_eq :: proc "contextless" (lhs, rhs: cstring16) -> bool {…}

    cstring16_ge ¶
    Source

    cstring16_ge :: proc "contextless" (a, b: cstring16) -> bool {…}

    cstring16_gt ¶
    Source

    cstring16_gt :: proc "contextless" (a, b: cstring16) -> bool {…}

    cstring16_le ¶
    Source

    cstring16_le :: proc "contextless" (a, b: cstring16) -> bool {…}

    cstring16_len ¶
    Source

    cstring16_len :: proc "contextless" (s: cstring16) -> int {…}

    cstring16_lt ¶
    Source

    cstring16_lt :: proc "contextless" (a, b: cstring16) -> bool {…}

    cstring16_ne ¶
    Source

    cstring16_ne :: proc "contextless" (a, b: cstring16) -> bool {…}

    cstring16_to_string16 ¶
    Source

    cstring16_to_string16 :: proc "contextless" (s: cstring16) -> string16 {…}

    cstring_cmp ¶
    Source

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

    cstring_eq ¶
    Source

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

    cstring_ge ¶
    Source

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

    cstring_gt ¶
    Source

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

    cstring_le ¶
    Source

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

    cstring_len ¶
    Source

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

    cstring_lt ¶
    Source

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

    cstring_ne ¶
    Source

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

    cstring_to_string ¶
    Source

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

    debug_trap ¶

    debug_trap :: intrinsics.debug_trap

    default_allocator ¶
    Source

    default_allocator :: heap_allocator

    default_allocator_proc ¶
    Source

    default_allocator_proc :: heap_allocator_proc

    default_assertion_contextless_failure_proc ¶
    Source

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

    default_assertion_failure_proc ¶
    Source

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

    default_context ¶
    Source

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

    default_hasher ¶
    Source

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

    default_hasher_complex128 ¶
    Source

    default_hasher_complex128 :: proc "contextless" (x, y: f64, seed: uintptr) -> uintptr {…}

    default_hasher_cstring ¶
    Source

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

    default_hasher_f64 ¶
    Source

    default_hasher_f64 :: proc "contextless" (f: f64, seed: uintptr) -> uintptr {…}

    default_hasher_quaternion256 ¶
    Source

    default_hasher_quaternion256 :: proc "contextless" (x, y, z, w: f64, seed: uintptr) -> uintptr {…}

    default_hasher_string ¶
    Source

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

    default_logger ¶
    Source

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

    default_logger_proc ¶
    Source

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

    default_random_generator ¶
    Source

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

    default_random_generator_proc ¶
    Source

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

    default_temp_allocator ¶
    Source

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

    default_temp_allocator_destroy ¶
    Source

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

    default_temp_allocator_init ¶
    Source

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

    default_temp_allocator_proc ¶
    Source

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

    default_temp_allocator_temp_begin :: proc(loc := #caller_location) -> (temp: Arena_Temp) {…}

    default_temp_allocator_temp_end ¶
    Source

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

    delete_cstring ¶
    Source

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

    delete_cstring will try to free the underlying data of the passed string, with the given allocator if the allocator supports this operation.

    Note: Prefer the procedure group delete.

    delete_cstring16 ¶
    Source

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

    delete_dynamic_array ¶
    Source

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

    delete_dynamic_array will try to free the underlying data of the passed dynamic array, with the given allocator if the allocator supports this operation.

    Note: Prefer the procedure group delete.

    delete_key ¶
    Source

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

    The delete_key built-in procedure deletes the element with the specified key (m[key]) from the map. If m is nil, or there is no such element, this procedure is a no-op

    delete_map ¶
    Source

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

    delete_map will try to free the underlying data of the passed map, with the given allocator if the allocator supports this operation.

    Note: Prefer the procedure group delete.

    delete_slice ¶
    Source

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

    delete_slice will try to free the underlying data of the passed sliced, with the given allocator if the allocator supports this operation.

    Note: Prefer the procedure group delete.

    delete_soa_dynamic_array ¶
    Source

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

    delete_soa_slice ¶
    Source

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

    delete_string ¶
    Source

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

    delete_string will try to free the underlying data of the passed string, with the given allocator if the allocator supports this operation.

    Note: Prefer the procedure group delete.

    delete_string16 ¶
    Source

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

    divmodti4 ¶
    Source

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

    divti3 ¶
    Source

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

    dynamic_array_expr_error ¶
    Source

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

    dynamic_array_expr_error_loc ¶
    Source

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

    encode_rune ¶
    Source

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

    ensure ¶
    Source

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

    Evaluates the condition and aborts the program iff the condition is false. This routine ignores ODIN_DISABLE_ASSERT, and will always execute.

    ensure_contextless ¶
    Source

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

    extendhfsf2 ¶
    Source

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

    fixdfti ¶
    Source

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

    fixunsdfdi ¶
    Source

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

    fixunsdfti ¶
    Source

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

    floattidf ¶
    Source

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

    floattidf_unsigned ¶
    Source

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

    gnu_f2h_ieee ¶
    Source

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

    gnu_h2f_ieee ¶
    Source

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

    heap_alloc ¶
    Source

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

    heap_allocator ¶
    Source

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

    heap_allocator_proc ¶
    Source

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

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

    heap_resize ¶
    Source

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

    init_global_temporary_allocator ¶
    Source

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

    inject_at_elem ¶
    Source

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

    inject_at_elem_string ¶
    Source

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

    inject_at_elems ¶
    Source

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

    into_dynamic_soa ¶
    Source

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

    Converts soa slice into a soa dynamic array without cloning or allocating memory

    is_power_of_two_int ¶
    Source

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

    is_power_of_two_uint ¶
    Source

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

    is_power_of_two_uintptr ¶
    Source

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

    make_aligned ¶
    Source

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

    make_dynamic_array ¶
    Source

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

    make_dynamic_array allocates and initializes a dynamic array. Like new, the first argument is a type, not a value. Unlike new, make's return value is the same as the type of its argument, not a pointer to it.

    Note: Prefer using the procedure group make.

    make_dynamic_array_error_loc ¶
    Source

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

    make_dynamic_array_len ¶
    Source

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

    make_dynamic_array_len allocates and initializes a dynamic array. Like new, the first argument is a type, not a value. Unlike new, make's return value is the same as the type of its argument, not a pointer to it.

    Note: Prefer using the procedure group make.

    make_dynamic_array_len_cap ¶
    Source

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

    make_dynamic_array_len_cap allocates and initializes a dynamic array. Like new, the first argument is a type, not a value. Unlike new, make's return value is the same as the type of its argument, not a pointer to it.

    Note: Prefer using the procedure group make.

    make_map ¶
    Source

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

    make_map initializes a map with an allocator. Like new, the first argument is a type, not a value. Unlike new, make's return value is the same as the type of its argument, not a pointer to it.

    Note: Prefer using the procedure group make.

    make_map_cap ¶
    Source

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

    make_map_cap initializes a map with an allocator and allocates space using capacity. Like new, the first argument is a type, not a value. Unlike new, make's return value is the same as the type of its argument, not a pointer to it.

    Note: Prefer using the procedure group make.

    make_map_expr_error_loc ¶
    Source

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

    make_multi_pointer ¶
    Source

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

    make_multi_pointer allocates and initializes a multi-pointer. Like new, the first argument is a type, not a value. Unlike new, make's return value is the same as the type of its argument, not a pointer to it.

    This is "similar" to doing raw_data(make([]E, len, allocator)).

    Note: Prefer using the procedure group make.

    make_slice ¶
    Source

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

    make_slice allocates and initializes a slice. Like new, the first argument is a type, not a value. Unlike new, make's return value is the same as the type of its argument, not a pointer to it.

    Note: Prefer using the procedure group make.

    make_slice_error_loc ¶
    Source

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

    make_soa_aligned ¶
    Source

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

    make_soa_dynamic_array ¶
    Source

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

    make_soa_dynamic_array_len ¶
    Source

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

    make_soa_dynamic_array_len_cap ¶
    Source

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

    make_soa_slice ¶
    Source

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

    map_alloc_dynamic ¶
    Source

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

    The only procedure which needs access to the context is the one which allocates the map.

    map_cap ¶
    Source

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

    cap() for map

    map_cell_index_dynamic ¶
    Source

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

    Same as the above procedure but at runtime with the cell Map_Cell_Info value.

    map_cell_index_dynamic_const ¶
    Source

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

    Same as above procedure but with compile-time constant index.

    map_cell_index_static ¶
    Source

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

    We always round the capacity to a power of two so this becomes [16]Foo, which works out to [4]Cell(Foo).

    The following compile-time procedure indexes such a [N]Cell(T) structure as if it were a flat array accounting for the internal padding introduced by the Cell structure.

    map_cell_info ¶

    map_cell_info :: intrinsics.type_map_cell_info
     

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

    map_clear_dynamic ¶
    Source

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

    map_data ¶
    Source

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

    Canonicalize the data by removing the tagged capacity stored in the lower six bits of the data uintptr.

    map_desired_position ¶
    Source

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

    Computes the desired position in the array. This is just index % capacity, but a procedure as there's some math involved here to recover the capacity.

    map_entry ¶
    Source

    map_entry :: proc(m: ^$T/map[$K]$V, key: $K, loc := #caller_location) -> (key_ptr: ^$K, value_ptr: ^$V, just_inserted: bool, err: Allocator_Error) {…}
     

    Retrieves a pointer to the key and value for a possibly just inserted entry into the map.

    If the key was not in the map m, an entry is inserted with the zero value and just_inserted will be true. Otherwise the existing entry is left untouched and pointers to its key and value are returned.

    If the map has to grow in order to insert the entry and the allocation fails, err is set and returned.

    If err is nil, key_ptr and value_ptr are valid pointers and will not be nil.

    WARN: User modification of the key pointed at by key_ptr should only be done if the new key is equal to (in hash) the old key. If that is not the case you will corrupt the map.

    map_erase_dynamic ¶
    Source

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

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

    map_free_dynamic ¶
    Source

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

    map_get ¶
    Source

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

    map_grow_dynamic ¶
    Source

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

    map_hash_is_deleted ¶
    Source

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

    map_hash_is_empty ¶
    Source

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

    Procedure to check if a slot is empty for a given hash. This is represented by the zero value to make the zero value useful. This is a procedure just for prose reasons.

    map_hash_is_valid ¶
    Source

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

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

    map_insert_hash_dynamic ¶
    Source

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

    map_insert_hash_dynamic_with_key ¶
    Source

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

    This procedure has to stack allocate storage to store local keys during the Robin Hood hashing technique where elements are swapped in the backing arrays to reduce variance. This swapping can only be done with memcpy since there is no type information.

    This procedure returns the address of the just inserted value, and will return 'nil' if there was no room to insert the entry

    map_kvh_data_dynamic ¶
    Source

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

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

    map_kvh_data_values_dynamic ¶
    Source

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

    map_len ¶
    Source

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

    len() for map

    map_load_factor ¶
    Source

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

    Query the load factor of the map. This is not actually configurable, but some math is needed to compute it. Compute it as a fixed point percentage to avoid floating point operations. This division can be optimized out by multiplying by the multiplicative inverse of 100.

    map_log2_cap ¶
    Source

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

    The data stores the log2 capacity in the lower six bits. This is primarily used in the implementation rather than map_cap since the check for data = 0 isn't necessary in the implementation. cap() on the otherhand needs to work when called on an empty map.

    map_lookup_dynamic ¶
    Source

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

    map_probe_distance ¶
    Source

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

    map_reserve_dynamic ¶
    Source

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

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

    map_seed ¶
    Source

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

    map_seed_from_map_data ¶
    Source

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

    splitmix for uintptr

    map_shrink_dynamic ¶
    Source

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

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

    map_total_allocation_size_from_value ¶
    Source

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

    map_upsert ¶
    Source

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

    Explicitly inserts a key and value into a map m, the same as map_insert, but the return values differ. prev_key will return the previous pointer of a key if it exists, check found_previous if was previously found value_ptr will return the pointer of the memory where the insertion happens, and nil if the map failed to resize found_previous will be true a previous key was found

    matrix_bounds_check_error ¶
    Source

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

    mem_alloc ¶
    Source

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

    mem_alloc_bytes ¶
    Source

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

    mem_alloc_non_zeroed ¶
    Source

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

    mem_copy ¶
    Source

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

    mem_copy_non_overlapping ¶
    Source

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

    mem_free ¶
    Source

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

    mem_free_all ¶
    Source

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

    mem_free_bytes ¶
    Source

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

    mem_free_with_size ¶
    Source

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

    mem_resize ¶
    Source

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

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

    memory_block_alloc ¶
    Source

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

    memory_block_dealloc ¶
    Source

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

    memory_compare ¶
    Source

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

    memory_compare_zero ¶
    Source

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

    memory_equal ¶
    Source

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

    memory_prefix_length ¶
    Source

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

    memset ¶
    Source

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

    modti3 ¶
    Source

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

    mul_quaternion128 ¶
    Source

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

    mul_quaternion256 ¶
    Source

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

    mul_quaternion64 ¶
    Source

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

    multi_pointer_slice_expr_error ¶
    Source

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

    multi_pointer_slice_handle_error ¶
    Source

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

    new ¶
    Source

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

    The new built-in procedure allocates memory. The first argument is a type, not a value, and the value return is a pointer to a newly allocated value of that type using the specified allocator, default is context.allocator

    new_aligned ¶
    Source

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

    new_clone ¶
    Source

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

    nil_allocator ¶
    Source

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

    nil_allocator_proc ¶
    Source

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

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

    non_zero_append_elem_string ¶
    Source

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

    non_zero_append_elems ¶
    Source

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

    non_zero_append_soa_elem ¶
    Source

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

    non_zero_append_soa_elems ¶
    Source

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

    non_zero_mem_resize ¶
    Source

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

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

    non_zero_reserve_soa ¶
    Source

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

    non_zero_resize_dynamic_array ¶
    Source

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

    non_zero_resize_soa ¶
    Source

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

    ordered_remove ¶
    Source

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

    ordered_remove removed the element at the specified index whilst keeping the order of the other elements.

    Note: This is an O(N) operation. Note: If the elements do not have to remain in their order, prefer unordered_remove. Note: If the index is out of bounds, this procedure will panic.

    ordered_remove_soa ¶
    Source

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

    ordered_remove_soa removed the element at the specified index whilst keeping the order of the other elements.

    Note: This is an O(N) operation. Note: If you the elements do not have to remain in their order, prefer unordered_remove_soa. Note: If the index is out of bounds, this procedure will panic.

    panic ¶
    Source

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

    panic_allocator ¶
    Source

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

    panic_allocator_proc ¶
    Source

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

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

    pop ¶
    Source

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

    pop will remove and return the end value of dynamic array array and reduces the length of array by 1.

    Note: If the dynamic array has no elements (len(array) == 0), this procedure will panic.

    pop_front ¶
    Source

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

    pop_front will remove and return the first value of dynamic array array and reduces the length of array by 1.

    Note: If the dynamic array as no elements (len(array) == 0), this procedure will panic.

    pop_front_safe ¶
    Source

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

    pop_front_safe trys to return and remove the first value of dynamic array array and reduces the length of array by 1. If the operation is not possible, it will return false.

    pop_safe ¶
    Source

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

    pop_safe trys to remove and return the end value of dynamic array array and reduces the length of array by 1. If the operation is not possible, it will return false.

    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: untyped rune) {…}
    print_i64 :: proc "contextless" (x: i64) {…}
    print_int :: proc "contextless" (x: int) {…}
    print_rune :: proc "contextless" (r: untyped 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 ¶
    Source

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

    quaternion128_eq ¶
    Source

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

    quaternion128_ne ¶
    Source

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

    quaternion256_eq ¶
    Source

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

    quaternion256_ne ¶
    Source

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

    quaternion64_eq ¶
    Source

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

    quaternion64_ne ¶
    Source

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

    quo_complex128 ¶
    Source

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

    quo_complex32 ¶
    Source

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

    quo_complex64 ¶
    Source

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

    quo_quaternion128 ¶
    Source

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

    quo_quaternion256 ¶
    Source

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

    quo_quaternion64 ¶
    Source

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

    random_generator_query_info ¶
    Source

    random_generator_query_info :: proc(rg: Random_Generator) -> (info: Random_Generator_Query_Info) {…}

    random_generator_read_bytes ¶
    Source

    random_generator_read_bytes :: proc(rg: Random_Generator, p: []u8) -> bool {…}

    random_generator_read_ptr ¶
    Source

    random_generator_read_ptr :: proc(rg: Random_Generator, p: rawptr, len: uint) -> bool {…}

    random_generator_reset_bytes ¶
    Source

    random_generator_reset_bytes :: proc(rg: Random_Generator, p: []u8) {…}

    random_generator_reset_u64 ¶
    Source

    random_generator_reset_u64 :: proc(rg: Random_Generator, p: u64) {…}
    raw_soa_footer_dynamic_array :: proc(array: ^$T/#soa[dynamic]$E) -> (footer: ^Raw_SOA_Footer_Dynamic_Array) {…}
    raw_soa_footer_slice :: proc(array: ^$T/#soa[]$E) -> (footer: ^Raw_SOA_Footer_Slice) {…}

    read_cycle_counter ¶

    read_cycle_counter :: intrinsics.read_cycle_counter

    remove_range ¶
    Source

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

    remove_range removes a range of elements specified by the range lo and hi, whilst keeping the order of the other elements.

    Note: This is an O(N) operation. Note: If the range is out of bounds, this procedure will panic.

    reserve_dynamic_array ¶
    Source

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

    reserve_map ¶
    Source

    reserve_map :: proc(m: ^$T/map[$K]$V, #any_int capacity: int, loc := #caller_location) -> Allocator_Error {…}
     

    reserve_map will try to reserve memory of a passed map to the requested element count (setting the cap).

    Note: Prefer the procedure group reserve

    reserve_soa ¶
    Source

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

    resize_dynamic_array ¶
    Source

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

    resize_dynamic_array will try to resize memory of a passed dynamic array or map to the requested element count (setting the len, and possibly cap).

    Note: Prefer the procedure group resize

    resize_soa ¶
    Source

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

    run_thread_local_cleaners ¶
    Source

    run_thread_local_cleaners :: proc() {…}
     

    Run all of the thread-local cleaner procedures.

    Intended to be called by the internals of a threading API at the end of a thread's lifetime.

    shrink_dynamic_array ¶
    Source

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

    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.

    Note: Prefer the procedure group shrink

    shrink_map ¶
    Source

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

    Shrinks the capacity of a map down to the current length.

    Note: Prefer the procedure group shrink

    slice_expr_error_hi ¶
    Source

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

    slice_expr_error_hi_loc ¶
    Source

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

    slice_expr_error_lo_hi ¶
    Source

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

    slice_expr_error_lo_hi_loc ¶
    Source

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

    slice_handle_error ¶
    Source

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

    stderr_write ¶
    Source

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

    string16_cmp ¶
    Source

    string16_cmp :: proc "contextless" (a, b: string16) -> int {…}

    string16_decode_last_rune ¶
    Source

    string16_decode_last_rune :: proc "contextless" (s: string16) -> (untyped rune, int) {…}

    string16_decode_rune ¶
    Source

    string16_decode_rune :: proc "contextless" (s: string16) -> (untyped rune, int) {…}

    string16_eq ¶
    Source

    string16_eq :: proc "contextless" (lhs, rhs: string16) -> bool {…}

    string16_ge ¶
    Source

    string16_ge :: proc "contextless" (a, b: string16) -> bool {…}

    string16_gt ¶
    Source

    string16_gt :: proc "contextless" (a, b: string16) -> bool {…}

    string16_le ¶
    Source

    string16_le :: proc "contextless" (a, b: string16) -> bool {…}

    string16_lt ¶
    Source

    string16_lt :: proc "contextless" (a, b: string16) -> bool {…}

    string16_ne ¶
    Source

    string16_ne :: proc "contextless" (a, b: string16) -> bool {…}

    string_cmp ¶
    Source

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

    string_decode_last_rune ¶
    Source

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

    string_decode_rune ¶
    Source

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

    string_eq ¶
    Source

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

    string_ge ¶
    Source

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

    string_gt ¶
    Source

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

    string_le ¶
    Source

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

    string_lt ¶
    Source

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

    string_ne ¶
    Source

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

    trap ¶

    trap :: intrinsics.trap

    truncdfhf2 ¶
    Source

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

    truncsfhf2 ¶
    Source

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

    type_assertion_check ¶
    Source

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

    type_assertion_check2 ¶
    Source

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

    type_assertion_trap ¶
    Source

    type_assertion_trap :: proc "contextless" () {…}

    type_info_base ¶
    Source

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

    type_info_base_without_enum ¶
    Source

    type_info_base_without_enum :: type_info_core

    type_info_core ¶
    Source

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

    typeid_base ¶
    Source

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

    typeid_base_without_enum ¶
    Source

    typeid_base_without_enum :: typeid_core

    typeid_core ¶
    Source

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

    udivmod128 ¶
    Source

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

    udivmodti4 ¶
    Source

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

    udivti3 ¶
    Source

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

    umodti3 ¶
    Source

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

    unimplemented ¶
    Source

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

    unimplemented_contextless ¶
    Source

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

    unordered_remove ¶
    Source

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

    unordered_remove removed the element at the specified index. It does so by replacing the current end value with the old value, and reducing the length of the dynamic array by 1.

    Note: This is an O(1) operation. Note: If you want the elements to remain in their order, use ordered_remove. Note: If the index is out of bounds, this procedure will panic.

    unordered_remove_soa ¶
    Source

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

    unordered_remove_soa removed the element at the specified index. It does so by replacing the current end value with the old value, and reducing the length of the dynamic array by 1.

    Note: This is an O(1) operation. Note: If you the elements to remain in their order, use ordered_remove_soa. Note: If the index is out of bounds, this procedure will panic.

    Procedure Groups

    align_forward ¶
    Source

    append ¶
    Source

     

    The append built-in procedure appends elements to the end of a dynamic array

    append_soa ¶
    Source

    append_soa :: proc{
	append_soa_elem,
	append_soa_elems,
}
     

    The append_soa built-in procedure appends elements to the end of an #soa dynamic array

    assign_at ¶
    Source

    clear ¶
    Source

     

    clear will set the length of a passed dynamic array or map to 0

    clear_soa ¶
    Source

    clear_soa :: proc{
	clear_soa_dynamic_array,
}

    copy ¶
    Source

     

    copy is a built-in procedure that copies elements from a source slice/string src to a destination slice dst. The source and destination may overlap. Copy returns the number of elements copied, which will be the minimum of len(src) and len(dst).

    delete ¶
    Source

     

    delete will try to free the underlying data of the passed built-in data structure (string, cstring, dynamic array, slice, or map), with the given allocator if the allocator supports this operation.

    Note: Prefer delete over the specific delete_* procedures where possible.

    delete_soa ¶
    Source

    delete_soa :: proc{
	delete_soa_slice,
	delete_soa_dynamic_array,
}

    free ¶
    Source

    free :: proc{
	mem_free,
}
     

    free will try to free the passed pointer, with the given allocator if the allocator supports this operation.

    free_all ¶
    Source

    free_all :: proc{
	mem_free_all,
}
     

    free_all will try to free/reset all of the memory of the given allocator if the allocator supports this operation.

    inject_at ¶
    Source

    is_power_of_two ¶
    Source

    make ¶
    Source

     

    make built-in procedure allocates and initializes a value of type slice, dynamic array, map, or multi-pointer (only).

    Similar to new, the first argument is a type, not a value. Unlike new, make's return type is the same as the type of its argument, not a pointer to it. Make uses the specified allocator, default is context.allocator.

    make_soa ¶
    Source

    non_zero_append ¶
    Source

    non_zero_reserve ¶
    Source

    non_zero_resize ¶
    Source

    non_zero_resize :: proc{
	non_zero_resize_dynamic_array,
	non_zero_resize_soa,
}

    reserve ¶
    Source

     

    reserve will try to reserve memory of a passed dynamic array or map to the requested element count (setting the cap).

    resize ¶
    Source

    resize :: proc{
	resize_dynamic_array,
	resize_soa,
}
     

    resize will try to resize memory of a passed dynamic array to the requested element count (setting the len, and possibly cap).

    shrink ¶
    Source

    shrink :: proc{
	shrink_dynamic_array,
	shrink_map,
}
     

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

    Source Files

    Generation Information

    Generated with odin version dev-2025-08 (vendor "odin") Windows_amd64 @ 2025-08-27 21:12:25.332117000 +0000 UTC