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

Add base:sanitizer package

Browse Source
This commit is contained in:
Lucas Perlind
2025-04-24 20:28:32 +10:00
parent 7502e7f2bc
commit 5c117bde6d
2 changed files with 73 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files
base/runtime/asan.odin → base/sanitizer/address.odin
+50 -48
View File
@@ -1,7 +1,9 @@
#+no-instrumentation #+no-instrumentation
package runtime package sanitizer
Asan_Death_Callback :: #type proc "c" (pc: rawptr, bp: rawptr, sp: rawptr, addr: rawptr, is_write: i32, access_size: uint) import "base:runtime"
Address_Death_Callback :: #type proc "c" (pc: rawptr, bp: rawptr, sp: rawptr, addr: rawptr, is_write: i32, access_size: uint)
@(private="file") @(private="file")
ASAN_ENABLED :: .Address in ODIN_SANITIZER_FLAGS ASAN_ENABLED :: .Address in ODIN_SANITIZER_FLAGS
@@ -11,7 +13,7 @@ ASAN_ENABLED :: .Address in ODIN_SANITIZER_FLAGS
foreign { foreign {
__asan_poison_memory_region :: proc(address: rawptr, size: uint) --- __asan_poison_memory_region :: proc(address: rawptr, size: uint) ---
__asan_unpoison_memory_region :: proc(address: rawptr, size: uint) --- __asan_unpoison_memory_region :: proc(address: rawptr, size: uint) ---
__sanitizer_set_death_callback :: proc(callback: Asan_Death_Callback) --- __sanitizer_set_death_callback :: proc(callback: Address_Death_Callback) ---
__asan_region_is_poisoned :: proc(begin: rawptr, size: uint) -> rawptr --- __asan_region_is_poisoned :: proc(begin: rawptr, size: uint) -> rawptr ---
__asan_address_is_poisoned :: proc(addr: rawptr) -> i32 --- __asan_address_is_poisoned :: proc(addr: rawptr) -> i32 ---
__asan_describe_address :: proc(addr: rawptr) --- __asan_describe_address :: proc(addr: rawptr) ---
@@ -34,79 +36,79 @@ foreign {
__asan_update_allocation_context :: proc(addr: rawptr) -> i32 --- __asan_update_allocation_context :: proc(addr: rawptr) -> i32 ---
} }
Asan_Access_Type :: enum { Address_Access_Type :: enum {
none, none,
read, read,
write, write,
} }
Asan_Located_Address_String :: struct { Address_Located_Address_String :: struct {
category: string, category: string,
name: string, name: string,
} }
Asan_Shadow_Mapping :: struct { Address_Shadow_Mapping :: struct {
scale: uint, scale: uint,
offset: uint, offset: uint,
} }
asan_poison_slice :: proc "contextless" (region: $T/[]$E) { address_poison_slice :: proc "contextless" (region: $T/[]$E) {
when ASAN_ENABLED { when ASAN_ENABLED {
__asan_poison_memory_region(raw_data(region), size_of(E) * len(region)) __asan_poison_memory_region(raw_data(region), size_of(E) * len(region))
} }
} }
asan_unpoison_slice :: proc "contextless" (region: $T/[]$E) { address_unpoison_slice :: proc "contextless" (region: $T/[]$E) {
when ASAN_ENABLED { when ASAN_ENABLED {
__asan_unpoison_memory_region(raw_data(region), size_of(E) * len(region)) __asan_unpoison_memory_region(raw_data(region), size_of(E) * len(region))
} }
} }
asan_poison_ptr :: proc "contextless" (ptr: ^$T) { address_poison_ptr :: proc "contextless" (ptr: ^$T) {
when ASAN_ENABLED { when ASAN_ENABLED {
__asan_poison_memory_region(ptr, size_of(T)) __asan_poison_memory_region(ptr, size_of(T))
} }
} }
asan_unpoison_ptr :: proc "contextless" (ptr: ^$T) { address_unpoison_ptr :: proc "contextless" (ptr: ^$T) {
when ASAN_ENABLED { when ASAN_ENABLED {
__asan_unpoison_memory_region(ptr, size_of(T)) __asan_unpoison_memory_region(ptr, size_of(T))
} }
} }
asan_poison_rawptr :: proc "contextless" (ptr: rawptr, len: int) { address_poison_rawptr :: proc "contextless" (ptr: rawptr, len: int) {
when ASAN_ENABLED { when ASAN_ENABLED {
assert_contextless(len >= 0) assert_contextless(len >= 0)
__asan_poison_memory_region(ptr, uint(len)) __asan_poison_memory_region(ptr, uint(len))
} }
} }
asan_unpoison_rawptr :: proc "contextless" (ptr: rawptr, len: int) { address_unpoison_rawptr :: proc "contextless" (ptr: rawptr, len: int) {
when ASAN_ENABLED { when ASAN_ENABLED {
assert_contextless(len >= 0) assert_contextless(len >= 0)
__asan_unpoison_memory_region(ptr, uint(len)) __asan_unpoison_memory_region(ptr, uint(len))
} }
} }
asan_poison :: proc { address_poison :: proc {
asan_poison_slice, address_poison_slice,
asan_poison_ptr, address_poison_ptr,
asan_poison_rawptr, address_poison_rawptr,
} }
asan_unpoison :: proc { address_unpoison :: proc {
asan_unpoison_slice, address_unpoison_slice,
asan_unpoison_ptr, address_unpoison_ptr,
asan_unpoison_rawptr, address_unpoison_rawptr,
} }
asan_set_death_callback :: proc "contextless" (callback: Asan_Death_Callback) { address_set_death_callback :: proc "contextless" (callback: Address_Death_Callback) {
when ASAN_ENABLED { when ASAN_ENABLED {
__sanitizer_set_death_callback(callback) __sanitizer_set_death_callback(callback)
} }
} }
asan_region_is_poisoned_slice :: proc "contextless" (region: []$T/$E) -> rawptr { address_region_is_poisoned_slice :: proc "contextless" (region: []$T/$E) -> rawptr {
when ASAN_ENABLED { when ASAN_ENABLED {
return __asan_region_is_poisoned(raw_data(region), size_of(E) * len(region)) return __asan_region_is_poisoned(raw_data(region), size_of(E) * len(region))
} else { } else {
@@ -114,7 +116,7 @@ asan_region_is_poisoned_slice :: proc "contextless" (region: []$T/$E) -> rawptr
} }
} }
asan_region_is_poisoned_ptr :: proc "contextless" (ptr: ^$T) -> rawptr { address_region_is_poisoned_ptr :: proc "contextless" (ptr: ^$T) -> rawptr {
when ASAN_ENABLED { when ASAN_ENABLED {
return __asan_region_is_poisoned(ptr, size_of(T)) return __asan_region_is_poisoned(ptr, size_of(T))
} else { } else {
@@ -122,7 +124,7 @@ asan_region_is_poisoned_ptr :: proc "contextless" (ptr: ^$T) -> rawptr {
} }
} }
asan_region_is_poisoned_rawptr :: proc "contextless" (region: rawptr, len: int) -> rawptr { address_region_is_poisoned_rawptr :: proc "contextless" (region: rawptr, len: int) -> rawptr {
when ASAN_ENABLED { when ASAN_ENABLED {
assert_contextless(len >= 0) assert_contextless(len >= 0)
return __asan_region_is_poisoned(region, uint(len)) return __asan_region_is_poisoned(region, uint(len))
@@ -131,13 +133,13 @@ asan_region_is_poisoned_rawptr :: proc "contextless" (region: rawptr, len: int)
} }
} }
asan_region_is_poisoned :: proc { address_region_is_poisoned :: proc {
asan_region_is_poisoned_slice, address_region_is_poisoned_slice,
asan_region_is_poisoned_ptr, address_region_is_poisoned_ptr,
asan_region_is_poisoned_rawptr, address_region_is_poisoned_rawptr,
} }
asan_address_is_poisoned :: proc "contextless" (address: rawptr) -> bool { address_address_is_poisoned :: proc "contextless" (address: rawptr) -> bool {
when ASAN_ENABLED { when ASAN_ENABLED {
return __asan_address_is_poisoned(address) != 0 return __asan_address_is_poisoned(address) != 0
} else { } else {
@@ -145,13 +147,13 @@ asan_address_is_poisoned :: proc "contextless" (address: rawptr) -> bool {
} }
} }
asan_describe_address :: proc "contextless" (address: rawptr) { address_describe_address :: proc "contextless" (address: rawptr) {
when ASAN_ENABLED { when ASAN_ENABLED {
__asan_describe_address(address) __asan_describe_address(address)
} }
} }
asan_report_present :: proc "contextless" () -> bool { address_report_present :: proc "contextless" () -> bool {
when ASAN_ENABLED { when ASAN_ENABLED {
return __asan_report_present() != 0 return __asan_report_present() != 0
} else { } else {
@@ -159,7 +161,7 @@ asan_report_present :: proc "contextless" () -> bool {
} }
} }
asan_get_report_pc :: proc "contextless" () -> rawptr { address_get_report_pc :: proc "contextless" () -> rawptr {
when ASAN_ENABLED { when ASAN_ENABLED {
return __asan_get_report_pc() return __asan_get_report_pc()
} else { } else {
@@ -167,7 +169,7 @@ asan_get_report_pc :: proc "contextless" () -> rawptr {
} }
} }
asan_get_report_bp :: proc "contextless" () -> rawptr { address_get_report_bp :: proc "contextless" () -> rawptr {
when ASAN_ENABLED { when ASAN_ENABLED {
return __asan_get_report_bp() return __asan_get_report_bp()
} else { } else {
@@ -175,7 +177,7 @@ asan_get_report_bp :: proc "contextless" () -> rawptr {
} }
} }
asan_get_report_sp :: proc "contextless" () -> rawptr { address_get_report_sp :: proc "contextless" () -> rawptr {
when ASAN_ENABLED { when ASAN_ENABLED {
return __asan_get_report_sp() return __asan_get_report_sp()
} else { } else {
@@ -183,7 +185,7 @@ asan_get_report_sp :: proc "contextless" () -> rawptr {
} }
} }
asan_get_report_address :: proc "contextless" () -> rawptr { address_get_report_address :: proc "contextless" () -> rawptr {
when ASAN_ENABLED { when ASAN_ENABLED {
return __asan_get_report_address() return __asan_get_report_address()
} else { } else {
@@ -191,7 +193,7 @@ asan_get_report_address :: proc "contextless" () -> rawptr {
} }
} }
asan_get_report_access_type :: proc "contextless" () -> Asan_Access_Type { address_get_report_access_type :: proc "contextless" () -> Address_Access_Type {
when ASAN_ENABLED { when ASAN_ENABLED {
return __asan_get_report_access_type() == 0 ? .read : .write return __asan_get_report_access_type() == 0 ? .read : .write
} else { } else {
@@ -199,7 +201,7 @@ asan_get_report_access_type :: proc "contextless" () -> Asan_Access_Type {
} }
} }
asan_get_report_access_size :: proc "contextless" () -> uint { address_get_report_access_size :: proc "contextless" () -> uint {
when ASAN_ENABLED { when ASAN_ENABLED {
return __asan_get_report_access_size() return __asan_get_report_access_size()
} else { } else {
@@ -207,7 +209,7 @@ asan_get_report_access_size :: proc "contextless" () -> uint {
} }
} }
asan_get_report_description :: proc "contextless" () -> string { address_get_report_description :: proc "contextless" () -> string {
when ASAN_ENABLED { when ASAN_ENABLED {
return string(__asan_get_report_description()) return string(__asan_get_report_description())
} else { } else {
@@ -215,7 +217,7 @@ asan_get_report_description :: proc "contextless" () -> string {
} }
} }
asan_locate_address :: proc (addr: rawptr, allocator: Allocator, string_alloc_size := 64) -> (Asan_Located_Address_String, []byte, Allocator_Error) { address_locate_address :: proc (addr: rawptr, allocator: runtime.Allocator, string_alloc_size := 64) -> (Address_Located_Address_String, []byte, runtime.Allocator_Error) {
when ASAN_ENABLED { when ASAN_ENABLED {
data, err := make([]byte, string_alloc_size, allocator) data, err := make([]byte, string_alloc_size, allocator)
if err != nil { if err != nil {
@@ -230,7 +232,7 @@ asan_locate_address :: proc (addr: rawptr, allocator: Allocator, string_alloc_si
} }
} }
asan_get_alloc_stack_trace :: proc (addr: rawptr, allocator: Allocator, stack_alloc_size := 32) -> ([]rawptr, int, Allocator_Error) { address_get_alloc_stack_trace :: proc (addr: rawptr, allocator: runtime.Allocator, stack_alloc_size := 32) -> ([]rawptr, int, runtime.Allocator_Error) {
when ASAN_ENABLED { when ASAN_ENABLED {
data, err := make([]rawptr, stack_alloc_size, allocator) data, err := make([]rawptr, stack_alloc_size, allocator)
if err != nil { if err != nil {
@@ -244,7 +246,7 @@ asan_get_alloc_stack_trace :: proc (addr: rawptr, allocator: Allocator, stack_al
} }
} }
asan_get_free_stack_trace :: proc (addr: rawptr, allocator: Allocator, stack_alloc_size := 32) -> ([]rawptr, int, Allocator_Error) { address_get_free_stack_trace :: proc (addr: rawptr, allocator: runtime.Allocator, stack_alloc_size := 32) -> ([]rawptr, int, runtime.Allocator_Error) {
when ASAN_ENABLED { when ASAN_ENABLED {
data, err := make([]rawptr, stack_alloc_size, allocator) data, err := make([]rawptr, stack_alloc_size, allocator)
if err != nil { if err != nil {
@@ -258,9 +260,9 @@ asan_get_free_stack_trace :: proc (addr: rawptr, allocator: Allocator, stack_all
} }
} }
asan_get_shadow_mapping :: proc "contextless" () -> Asan_Shadow_Mapping { address_get_shadow_mapping :: proc "contextless" () -> Address_Shadow_Mapping {
when ASAN_ENABLED { when ASAN_ENABLED {
result: Asan_Shadow_Mapping result: Address_Shadow_Mapping
__asan_get_shadow_mapping(&result.scale, &result.offset) __asan_get_shadow_mapping(&result.scale, &result.offset)
return result return result
} else { } else {
@@ -268,13 +270,13 @@ asan_get_shadow_mapping :: proc "contextless" () -> Asan_Shadow_Mapping {
} }
} }
asan_print_accumulated_stats :: proc "contextless" () { address_print_accumulated_stats :: proc "contextless" () {
when ASAN_ENABLED { when ASAN_ENABLED {
__asan_print_accumulated_stats() __asan_print_accumulated_stats()
} }
} }
asan_get_current_fake_stack :: proc "contextless" () -> rawptr { address_get_current_fake_stack :: proc "contextless" () -> rawptr {
when ASAN_ENABLED { when ASAN_ENABLED {
return __asan_get_current_fake_stack() return __asan_get_current_fake_stack()
} else { } else {
@@ -282,7 +284,7 @@ asan_get_current_fake_stack :: proc "contextless" () -> rawptr {
} }
} }
asan_is_in_fake_stack :: proc "contextless" (fake_stack: rawptr, addr: rawptr) -> ([]byte, bool) { address_is_in_fake_stack :: proc "contextless" (fake_stack: rawptr, addr: rawptr) -> ([]byte, bool) {
when ASAN_ENABLED { when ASAN_ENABLED {
begin: rawptr begin: rawptr
end: rawptr end: rawptr
@@ -295,13 +297,13 @@ asan_is_in_fake_stack :: proc "contextless" (fake_stack: rawptr, addr: rawptr) -
} }
} }
asan_handle_no_return :: proc "contextless" () { address_handle_no_return :: proc "contextless" () {
when ASAN_ENABLED { when ASAN_ENABLED {
__asan_handle_no_return() __asan_handle_no_return()
} }
} }
asan_update_allocation_context :: proc "contextless" (addr: rawptr) -> bool { address_update_allocation_context :: proc "contextless" (addr: rawptr) -> bool {
when ASAN_ENABLED { when ASAN_ENABLED {
return __asan_update_allocation_context(addr) != 0 return __asan_update_allocation_context(addr) != 0
} else { } else {
core/mem/allocators.odin
+23 -22
View File
@@ -2,6 +2,7 @@ package mem
import "base:intrinsics" import "base:intrinsics"
import "base:runtime" import "base:runtime"
import "base:sanitizer"
/* /*
Nil allocator. Nil allocator.
@@ -138,7 +139,7 @@ arena_init :: proc(a: ^Arena, data: []byte) {
a.offset = 0 a.offset = 0
a.peak_used = 0 a.peak_used = 0
a.temp_count = 0 a.temp_count = 0
runtime.asan_poison(a.data) sanitizer.address_poison(a.data)
} }
/* /*
@@ -226,7 +227,7 @@ arena_alloc_bytes_non_zeroed :: proc(
a.offset += total_size a.offset += total_size
a.peak_used = max(a.peak_used, a.offset) a.peak_used = max(a.peak_used, a.offset)
result := byte_slice(ptr, size) result := byte_slice(ptr, size)
runtime.asan_unpoison(result) sanitizer.address_unpoison(result)
return result, nil return result, nil
} }
@@ -235,7 +236,7 @@ Free all memory to an arena.
*/ */
arena_free_all :: proc(a: ^Arena) { arena_free_all :: proc(a: ^Arena) {
a.offset = 0 a.offset = 0
runtime.asan_poison(a.data) sanitizer.address_poison(a.data)
} }
arena_allocator_proc :: proc( arena_allocator_proc :: proc(
@@ -313,7 +314,7 @@ allocations *inside* the temporary memory region will be freed to the arena.
end_arena_temp_memory :: proc(tmp: Arena_Temp_Memory) { end_arena_temp_memory :: proc(tmp: Arena_Temp_Memory) {
assert(tmp.arena.offset >= tmp.prev_offset) assert(tmp.arena.offset >= tmp.prev_offset)
assert(tmp.arena.temp_count > 0) assert(tmp.arena.temp_count > 0)
runtime.asan_poison(tmp.arena.data[tmp.prev_offset:tmp.arena.offset]) sanitizer.address_poison(tmp.arena.data[tmp.prev_offset:tmp.arena.offset])
tmp.arena.offset = tmp.prev_offset tmp.arena.offset = tmp.prev_offset
tmp.arena.temp_count -= 1 tmp.arena.temp_count -= 1
} }
@@ -368,7 +369,7 @@ scratch_init :: proc(s: ^Scratch, size: int, backup_allocator := context.allocat
s.prev_allocation = nil s.prev_allocation = nil
s.backup_allocator = backup_allocator s.backup_allocator = backup_allocator
s.leaked_allocations.allocator = backup_allocator s.leaked_allocations.allocator = backup_allocator
runtime.asan_poison(s.data) sanitizer.address_poison(s.data)
return nil return nil
} }
@@ -383,7 +384,7 @@ scratch_destroy :: proc(s: ^Scratch) {
free_bytes(ptr, s.backup_allocator) free_bytes(ptr, s.backup_allocator)
} }
delete(s.leaked_allocations) delete(s.leaked_allocations)
runtime.asan_unpoison(s.data) sanitizer.address_unpoison(s.data)
delete(s.data, s.backup_allocator) delete(s.data, s.backup_allocator)
s^ = {} s^ = {}
} }
@@ -480,7 +481,7 @@ scratch_alloc_bytes_non_zeroed :: proc(
s.prev_allocation = rawptr(ptr) s.prev_allocation = rawptr(ptr)
s.curr_offset = int(offset) + size s.curr_offset = int(offset) + size
result := byte_slice(rawptr(ptr), size) result := byte_slice(rawptr(ptr), size)
runtime.asan_unpoison(result) sanitizer.address_unpoison(result)
return result, nil return result, nil
} else { } else {
a := s.backup_allocator a := s.backup_allocator
@@ -525,7 +526,7 @@ scratch_free :: proc(s: ^Scratch, ptr: rawptr, loc := #caller_location) -> Alloc
old_ptr := uintptr(ptr) old_ptr := uintptr(ptr)
if s.prev_allocation == ptr { if s.prev_allocation == ptr {
s.curr_offset = int(uintptr(s.prev_allocation) - start) s.curr_offset = int(uintptr(s.prev_allocation) - start)
runtime.asan_poison(s.data[s.curr_offset:]) sanitizer.address_poison(s.data[s.curr_offset:])
s.prev_allocation = nil s.prev_allocation = nil
return nil return nil
} }
@@ -556,7 +557,7 @@ scratch_free_all :: proc(s: ^Scratch, loc := #caller_location) {
free_bytes(ptr, s.backup_allocator, loc) free_bytes(ptr, s.backup_allocator, loc)
} }
clear(&s.leaked_allocations) clear(&s.leaked_allocations)
runtime.asan_poison(s.data) sanitizer.address_poison(s.data)
} }
/* /*
@@ -687,7 +688,7 @@ scratch_resize_bytes_non_zeroed :: proc(
if begin <= old_ptr && old_ptr < end && old_ptr+uintptr(size) < end { if begin <= old_ptr && old_ptr < end && old_ptr+uintptr(size) < end {
s.curr_offset = int(old_ptr-begin)+size s.curr_offset = int(old_ptr-begin)+size
result := byte_slice(old_memory, size) result := byte_slice(old_memory, size)
runtime.asan_unpoison(result) sanitizer.address_unpoison(result)
return result, nil return result, nil
} }
data, err := scratch_alloc_bytes_non_zeroed(s, size, alignment, loc) data, err := scratch_alloc_bytes_non_zeroed(s, size, alignment, loc)
@@ -789,7 +790,7 @@ stack_init :: proc(s: ^Stack, data: []byte) {
s.prev_offset = 0 s.prev_offset = 0
s.curr_offset = 0 s.curr_offset = 0
s.peak_used = 0 s.peak_used = 0
runtime.asan_poison(data) sanitizer.address_poison(data)
} }
/* /*
@@ -880,13 +881,13 @@ stack_alloc_bytes_non_zeroed :: proc(
s.curr_offset += padding s.curr_offset += padding
next_addr := curr_addr + uintptr(padding) next_addr := curr_addr + uintptr(padding)
header := (^Stack_Allocation_Header)(next_addr - size_of(Stack_Allocation_Header)) header := (^Stack_Allocation_Header)(next_addr - size_of(Stack_Allocation_Header))
runtime.asan_unpoison(header) sanitizer.address_unpoison(header)
header.padding = padding header.padding = padding
header.prev_offset = old_offset header.prev_offset = old_offset
s.curr_offset += size s.curr_offset += size
s.peak_used = max(s.peak_used, s.curr_offset) s.peak_used = max(s.peak_used, s.curr_offset)
result := byte_slice(rawptr(next_addr), size) result := byte_slice(rawptr(next_addr), size)
runtime.asan_unpoison(result) sanitizer.address_unpoison(result)
return result, nil return result, nil
} }
@@ -926,7 +927,7 @@ stack_free :: proc(
} }
s.prev_offset = header.prev_offset s.prev_offset = header.prev_offset
runtime.asan_poison(s.data[old_offset:s.curr_offset]) sanitizer.address_poison(s.data[old_offset:s.curr_offset])
s.curr_offset = old_offset s.curr_offset = old_offset
return nil return nil
@@ -938,7 +939,7 @@ Free all allocations to the stack.
stack_free_all :: proc(s: ^Stack, loc := #caller_location) { stack_free_all :: proc(s: ^Stack, loc := #caller_location) {
s.prev_offset = 0 s.prev_offset = 0
s.curr_offset = 0 s.curr_offset = 0
runtime.asan_poison(s.data) sanitizer.address_poison(s.data)
} }
/* /*
@@ -1099,7 +1100,7 @@ stack_resize_bytes_non_zeroed :: proc(
zero(rawptr(curr_addr + uintptr(diff)), diff) zero(rawptr(curr_addr + uintptr(diff)), diff)
} }
result := byte_slice(old_memory, size) result := byte_slice(old_memory, size)
runtime.asan_unpoison(result) sanitizer.address_unpoison(result)
return result, nil return result, nil
} }
@@ -1168,7 +1169,7 @@ small_stack_init :: proc(s: ^Small_Stack, data: []byte) {
s.data = data s.data = data
s.offset = 0 s.offset = 0
s.peak_used = 0 s.peak_used = 0
runtime.asan_poison(data) sanitizer.address_poison(data)
} }
/* /*
@@ -1277,12 +1278,12 @@ small_stack_alloc_bytes_non_zeroed :: proc(
s.offset += padding s.offset += padding
next_addr := curr_addr + uintptr(padding) next_addr := curr_addr + uintptr(padding)
header := (^Small_Stack_Allocation_Header)(next_addr - size_of(Small_Stack_Allocation_Header)) header := (^Small_Stack_Allocation_Header)(next_addr - size_of(Small_Stack_Allocation_Header))
runtime.asan_unpoison(header) sanitizer.address_unpoison(header)
header.padding = auto_cast padding header.padding = auto_cast padding
s.offset += size s.offset += size
s.peak_used = max(s.peak_used, s.offset) s.peak_used = max(s.peak_used, s.offset)
result := byte_slice(rawptr(next_addr), size) result := byte_slice(rawptr(next_addr), size)
runtime.asan_unpoison(result) sanitizer.address_unpoison(result)
return result, nil return result, nil
} }
@@ -1317,7 +1318,7 @@ small_stack_free :: proc(
} }
header := (^Small_Stack_Allocation_Header)(curr_addr - size_of(Small_Stack_Allocation_Header)) header := (^Small_Stack_Allocation_Header)(curr_addr - size_of(Small_Stack_Allocation_Header))
old_offset := int(curr_addr - uintptr(header.padding) - uintptr(raw_data(s.data))) old_offset := int(curr_addr - uintptr(header.padding) - uintptr(raw_data(s.data)))
runtime.asan_poison(s.data[old_offset:s.offset]) sanitizer.address_poison(s.data[old_offset:s.offset])
s.offset = old_offset s.offset = old_offset
return nil return nil
} }
@@ -1327,7 +1328,7 @@ Free all memory to small stack.
*/ */
small_stack_free_all :: proc(s: ^Small_Stack) { small_stack_free_all :: proc(s: ^Small_Stack) {
s.offset = 0 s.offset = 0
runtime.asan_poison(s.data) sanitizer.address_poison(s.data)
} }
/* /*
@@ -1473,7 +1474,7 @@ small_stack_resize_bytes_non_zeroed :: proc(
} }
if old_size == size { if old_size == size {
result := byte_slice(old_memory, size) result := byte_slice(old_memory, size)
runtime.asan_unpoison(result) sanitizer.address_unpoison(result)
return result, nil return result, nil
} }
data, err := small_stack_alloc_bytes_non_zeroed(s, size, alignment, loc) data, err := small_stack_alloc_bytes_non_zeroed(s, size, alignment, loc)