ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-08-06 15:48:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

inline certain mem.* procedures

Browse Source
This commit is contained in:
gingerBill
2019-01-29 22:08:48 +00:00
parent 1aea59a0fc
commit 238a40321a
1 changed files with 19 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/mem/mem.odin
+19 -19
View File
@@ -9,7 +9,7 @@ swap :: proc{swap16, swap32, swap64};
set :: proc "contextless" (data: rawptr, value: byte, len: int) -> rawptr { set :: inline proc "contextless" (data: rawptr, value: byte, len: int) -> rawptr {
if data == nil do return nil; if data == nil do return nil;
if len < 0 do return data; if len < 0 do return data;
foreign _ { foreign _ {
@@ -24,20 +24,20 @@ set :: proc "contextless" (data: rawptr, value: byte, len: int) -> rawptr {
llvm_memset(data, byte(value), len, 1, false); llvm_memset(data, byte(value), len, 1, false);
return data; return data;
} }
zero :: proc "contextless" (data: rawptr, len: int) -> rawptr { zero :: inline proc "contextless" (data: rawptr, len: int) -> rawptr {
return set(data, 0, len); return set(data, 0, len);
} }
zero_item :: proc "contextless" (item: $P/^$T) { zero_item :: inline proc "contextless" (item: $P/^$T) {
set(item, 0, size_of(T)); set(item, 0, size_of(T));
} }
zero_slice :: proc "contextless" (data: $T/[]$E) { zero_slice :: inline proc "contextless" (data: $T/[]$E) {
if n := len(data); n > 0 { if n := len(data); n > 0 {
zero(&data[0], size_of(E)*n); zero(&data[0], size_of(E)*n);
} }
} }
copy :: proc "contextless" (dst, src: rawptr, len: int) -> rawptr { copy :: inline proc "contextless" (dst, src: rawptr, len: int) -> rawptr {
if src == nil do return dst; if src == nil do return dst;
// NOTE(bill): This _must_ be implemented like C's memmove // NOTE(bill): This _must_ be implemented like C's memmove
foreign _ { foreign _ {
@@ -52,7 +52,7 @@ copy :: proc "contextless" (dst, src: rawptr, len: int) -> rawptr {
llvm_memmove(dst, src, len, 1, false); llvm_memmove(dst, src, len, 1, false);
return dst; return dst;
} }
copy_non_overlapping :: proc "contextless" (dst, src: rawptr, len: int) -> rawptr { copy_non_overlapping :: inline proc "contextless" (dst, src: rawptr, len: int) -> rawptr {
if src == nil do return dst; if src == nil do return dst;
// NOTE(bill): This _must_ be implemented like C's memcpy // NOTE(bill): This _must_ be implemented like C's memcpy
foreign _ { foreign _ {
@@ -67,7 +67,7 @@ copy_non_overlapping :: proc "contextless" (dst, src: rawptr, len: int) -> rawpt
llvm_memcpy(dst, src, len, 1, false); llvm_memcpy(dst, src, len, 1, false);
return dst; return dst;
} }
compare :: proc "contextless" (a, b: []byte) -> int { compare :: inline proc "contextless" (a, b: []byte) -> int {
return compare_byte_ptrs(&a[0], &b[0], min(len(a), len(b))); return compare_byte_ptrs(&a[0], &b[0], min(len(a), len(b)));
} }
compare_byte_ptrs :: proc "contextless" (a, b: ^byte, n: int) -> int #no_bounds_check { compare_byte_ptrs :: proc "contextless" (a, b: ^byte, n: int) -> int #no_bounds_check {
@@ -112,29 +112,29 @@ compare_ptrs :: inline proc "contextless" (a, b: rawptr, n: int) -> int {
return compare_byte_ptrs((^byte)(a), (^byte)(b), n); return compare_byte_ptrs((^byte)(a), (^byte)(b), n);
} }
ptr_offset :: proc "contextless" (ptr: $P/^$T, n: int) -> P { ptr_offset :: inline proc "contextless" (ptr: $P/^$T, n: int) -> P {
new := int(uintptr(ptr)) + size_of(T)*n; new := int(uintptr(ptr)) + size_of(T)*n;
return P(uintptr(new)); return P(uintptr(new));
} }
ptr_sub :: proc "contextless" (a, b: $P/^$T) -> int { ptr_sub :: inline proc "contextless" (a, b: $P/^$T) -> int {
return (int(uintptr(a)) - int(uintptr(b)))/size_of(T); return (int(uintptr(a)) - int(uintptr(b)))/size_of(T);
} }
slice_ptr :: proc "contextless" (ptr: ^$T, len: int) -> []T { slice_ptr :: inline proc "contextless" (ptr: ^$T, len: int) -> []T {
assert(len >= 0); assert(len >= 0);
slice := Raw_Slice{data = ptr, len = len}; slice := Raw_Slice{data = ptr, len = len};
return transmute([]T)slice; return transmute([]T)slice;
} }
slice_to_bytes :: proc "contextless" (slice: $E/[]$T) -> []byte { slice_to_bytes :: inline proc "contextless" (slice: $E/[]$T) -> []byte {
s := transmute(Raw_Slice)slice; s := transmute(Raw_Slice)slice;
s.len *= size_of(T); s.len *= size_of(T);
return transmute([]byte)s; return transmute([]byte)s;
} }
buffer_from_slice :: proc(backing: $T/[]$E) -> [dynamic]E { buffer_from_slice :: inline proc(backing: $T/[]$E) -> [dynamic]E {
s := transmute(Raw_Slice)backing; s := transmute(Raw_Slice)backing;
d := Raw_Dynamic_Array{ d := Raw_Dynamic_Array{
data = s.data, data = s.data,
@@ -145,12 +145,12 @@ buffer_from_slice :: proc(backing: $T/[]$E) -> [dynamic]E {
return transmute([dynamic]E)d; return transmute([dynamic]E)d;
} }
ptr_to_bytes :: proc "contextless" (ptr: ^$T, len := 1) -> []byte { ptr_to_bytes :: inline proc "contextless" (ptr: ^$T, len := 1) -> []byte {
assert(len >= 0); assert(len >= 0);
return transmute([]byte)Raw_Slice{ptr, len*size_of(T)}; return transmute([]byte)Raw_Slice{ptr, len*size_of(T)};
} }
any_to_bytes :: proc "contextless" (val: any) -> []byte { any_to_bytes :: inline proc "contextless" (val: any) -> []byte {
ti := type_info_of(val.id); ti := type_info_of(val.id);
size := ti != nil ? ti.size : 0; size := ti != nil ? ti.size : 0;
return transmute([]byte)Raw_Slice{val.data, size}; return transmute([]byte)Raw_Slice{val.data, size};
@@ -162,7 +162,7 @@ megabytes :: inline proc "contextless" (x: int) -> int do return kilobytes(x) *
gigabytes :: inline proc "contextless" (x: int) -> int do return megabytes(x) * 1024; gigabytes :: inline proc "contextless" (x: int) -> int do return megabytes(x) * 1024;
terabytes :: inline proc "contextless" (x: int) -> int do return gigabytes(x) * 1024; terabytes :: inline proc "contextless" (x: int) -> int do return gigabytes(x) * 1024;
is_power_of_two :: proc(x: uintptr) -> bool { is_power_of_two :: inline proc(x: uintptr) -> bool {
if x <= 0 do return false; if x <= 0 do return false;
return (x & (x-1)) == 0; return (x & (x-1)) == 0;
} }
@@ -189,9 +189,9 @@ align_forward_uintptr :: proc(ptr, align: uintptr) -> uintptr {
AllocationHeader :: struct {size: int}; Allocation_Header :: struct {size: int};
allocation_header_fill :: proc(header: ^AllocationHeader, data: rawptr, size: int) { allocation_header_fill :: proc(header: ^Allocation_Header, data: rawptr, size: int) {
header.size = size; header.size = size;
ptr := cast(^uint)(ptr_offset(header, 1)); ptr := cast(^uint)(ptr_offset(header, 1));
n := ptr_sub(cast(^uint)data, ptr); n := ptr_sub(cast(^uint)data, ptr);
@@ -200,11 +200,11 @@ allocation_header_fill :: proc(header: ^AllocationHeader, data: rawptr, size: in
ptr_offset(ptr, i)^ = ~uint(0); ptr_offset(ptr, i)^ = ~uint(0);
} }
} }
allocation_header :: proc(data: rawptr) -> ^AllocationHeader { allocation_header :: proc(data: rawptr) -> ^Allocation_Header {
if data == nil do return nil; if data == nil do return nil;
p := cast(^uint)data; p := cast(^uint)data;
for ptr_offset(p, -1)^ == ~uint(0) do p = ptr_offset(p, -1); for ptr_offset(p, -1)^ == ~uint(0) do p = ptr_offset(p, -1);
return (^AllocationHeader)(ptr_offset(p, -1)); return (^Allocation_Header)(ptr_offset(p, -1));
} }