package back

Source

Line :: struct {
	location: string,
	symbol:   string,
}

Lines_Error :: enum int {
	None, 
	Parse_Address_Fail, 
	Addr2line_Unexpected_EOF, 
	Addr2line_Output_Error, 
	Addr2line_Unresolved, 
	Fork_Limited             = 11, 
	Out_Of_Memory            = 12, 
	Invalid_Fd               = 14, 
	Pipe_Process_Limited     = 24, 
	Pipe_System_Limited      = 23, 
	Fork_Not_Supported       = 38, 
	Info_Not_Found, 
}

Result_Type :: enum int {
	Both, 
	Leaks, 
	Bad_Frees, 
}

Trace :: []rawptr

Trace_Const :: struct {
	trace: [16]rawptr,
	len:   int,
}

Trace_Entry :: rawptr

Tracking_Allocator :: struct {
	backing:             runtime.Allocator,
	internals_allocator: runtime.Allocator,
	allocation_map:      map[rawptr]Tracking_Allocator_Entry,
	bad_free_array:      [dynamic]Tracking_Allocator_Bad_Free_Entry,
	mutex:               sync.Mutex,
	clear_on_free_all:   bool,
}

Tracking_Allocator_Bad_Free_Entry :: struct {
	memory:    rawptr,
	location:  runtime.Source_Code_Location,
	backtrace: Trace_Const,
}

Tracking_Allocator_Entry :: struct {
	memory:    rawptr,
	size:      int,
	alignment: int,
	mode:      runtime.Allocator_Mode,
	err:       runtime.Allocator_Error,
	location:  runtime.Source_Code_Location,
	backtrace: Trace_Const,
}

BACKTRACE_SIZE :: #config(BACKTRACE_SIZE, 16)

EAGAIN: linux.Errno : os.EAGAIN when ODIN_OS == .Linux || ODIN_OS == .Darwin else 5

EFAULT: linux.Errno : os.EFAULT when ODIN_OS == .Linux || ODIN_OS == .Darwin else 7

EMFILE: linux.Errno : os.EMFILE when ODIN_OS == .Linux || ODIN_OS == .Darwin else 8

ENFILE: linux.Errno : os.ENFILE when ODIN_OS == .Linux || ODIN_OS == .Darwin else 9

ENOMEM: linux.Errno : os.ENOMEM when ODIN_OS == .Linux || ODIN_OS == .Darwin else 6

ENOSYS: linux.Errno : os.ENOSYS when ODIN_OS == .Linux || ODIN_OS == .Darwin else 10

FORCE_FALLBACK :: #config(BACK_FORCE_FALLBACK, false)

OTHER_CUSTOM_INSTRUMENTATION :: #config(BACK_OTHER_CUSTOM_INSTRUMENTATION, false)

USE_FALLBACK :: FORCE_FALLBACK || (ODIN_OS != .Darwin && ODIN_OS != .Linux && ODIN_OS != .Windows)

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

lines_const :: proc(bt: Trace_Const, allocator := context.allocator) -> (out: []Line, err: Lines_Error) {…}

lines_destroy :: proc(lines: []Line, allocator := context.allocator) {…}

lines_n :: proc(bt: []rawptr, allocator := context.allocator) -> (out: []Line, err: Lines_Error) {…}

print :: proc(lines: []Line, padding: string = "    ", w: runtime.Maybe($T=Stream) = nil, no_temp_guard: bool = false) {…}

register_segfault_handler :: proc() {…}

trace :: proc() -> (bt: Trace_Const) {…}

trace_fill :: proc(buf: []rawptr) -> int {…}

trace_n :: proc(max_len: i32, allocator := context.allocator) -> []rawptr {…}

trace_n_destroy :: proc(b: []rawptr, allocator := context.allocator) {…}

tracking_allocator :: proc(data: ^Tracking_Allocator) -> runtime.Allocator {…}

tracking_allocator_clear :: proc(t: ^Tracking_Allocator) {…}

tracking_allocator_destroy :: proc(t: ^Tracking_Allocator) {…}

tracking_allocator_init :: proc(t: ^Tracking_Allocator, backing_allocator: runtime.Allocator, internals_allocator := context.allocator) {…}

tracking_allocator_print_results :: proc(t: ^Tracking_Allocator, type: Result_Type = .Both) {…}

tracking_allocator_proc :: proc(
	allocator_data:  rawptr, 
	mode:            runtime.Allocator_Mode, 
	size, alignment: int, 
	old_memory:      rawptr, 
	old_size:        int, 
	loc := #caller_location, 
) -> (result: []u8, err: runtime.Allocator_Error) {…}

lines :: proc{
	lines_n,
	lines_const,
}