160 lines
4.7 KiB
Odin
160 lines
4.7 KiB
Odin
#+vet explicit-allocators
|
|
#+private file
|
|
package back
|
|
|
|
@require import "base:runtime"
|
|
|
|
@require import "core:strings"
|
|
@require import "core:sys/posix"
|
|
|
|
when !USE_FALLBACK {
|
|
|
|
foreign import system "system:System.framework"
|
|
|
|
// NOTE: CoreSymbolication is a private framework, Apple is allowed to break it and doesn't provide
|
|
// headers, although the API has as of my knowledge been the same in the past 10 years at least.
|
|
@(extra_linker_flags="-iframework /System/Library/PrivateFrameworks")
|
|
foreign import symbolication "system:CoreSymbolication.framework"
|
|
|
|
@(private="package")
|
|
_Trace_Entry :: rawptr
|
|
|
|
@(private="package")
|
|
_trace :: #force_no_inline proc(buf: Trace) -> (n: int) {
|
|
ctx: unw_context_t
|
|
cursor: unw_cursor_t
|
|
|
|
ret: i32
|
|
ret = unw_getcontext(&ctx)
|
|
assert(ret == 0)
|
|
ret = unw_init_local(&cursor, &ctx)
|
|
assert(ret == 0)
|
|
|
|
// Skip this function's frame and the caller.
|
|
if unw_step(&cursor) <= 0 { return }
|
|
|
|
pc: uintptr
|
|
for ; unw_step(&cursor) > 0 && n < len(buf); n += 1 {
|
|
ret = unw_get_reg(&cursor, .IP, &pc)
|
|
assert(ret == 0)
|
|
buf[n] = rawptr(pc)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
@(private="package")
|
|
_lines_destroy :: proc(lines: []Line, allocator: runtime.Allocator) {
|
|
for line in lines {
|
|
delete(line.location, allocator)
|
|
delete(line.symbol, allocator)
|
|
}
|
|
delete(lines, allocator)
|
|
}
|
|
|
|
@(private="package")
|
|
_lines :: proc(bt: Trace, allocator, _: runtime.Allocator) -> (out: []Line, err: Lines_Error) {
|
|
out = make([]Line, len(bt), allocator)
|
|
defer if err != nil { _lines_destroy(out, allocator) }
|
|
|
|
symbolicator := CSSymbolicatorCreateWithPid(posix.getpid())
|
|
defer CSRelease(symbolicator)
|
|
|
|
for &msg, i in out {
|
|
symbol := CSSymbolicatorGetSymbolWithAddressAtTime(symbolicator, uintptr(bt[i]), CSNow)
|
|
info := CSSymbolicatorGetSourceInfoWithAddressAtTime(symbolicator, uintptr(bt[i]), CSNow)
|
|
|
|
msg.symbol = strings.clone_from(CSSymbolGetName(symbol), allocator)
|
|
|
|
// No debug info.
|
|
if CSIsNull(info) {
|
|
owner := CSSymbolGetSymbolOwner(symbol)
|
|
msg.location = strings.clone_from(CSSymbolOwnerGetPath(owner), allocator)
|
|
} else {
|
|
path := string(CSSourceInfoGetPath(info))
|
|
location := strings.builder_make(allocator)
|
|
strings.write_string(&location, path)
|
|
when ODIN_ERROR_POS_STYLE == .Default {
|
|
strings.write_byte(&location, '(')
|
|
strings.write_int (&location, int(CSSourceInfoGetLineNumber(info)))
|
|
strings.write_byte(&location, ')')
|
|
} else when ODIN_ERROR_POS_STYLE == .Unix {
|
|
strings.write_byte(&location, ':')
|
|
strings.write_int (&location, int(CSSourceInfoGetLineNumber(info)))
|
|
} else {
|
|
#panic("unhandled ODIN_ERROR_POS_STYLE")
|
|
}
|
|
msg.location = strings.to_string(location)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
CSTypeRef :: struct {
|
|
csCppData: rawptr,
|
|
csCppObj: rawptr,
|
|
}
|
|
|
|
CSSymbolicatorRef :: distinct CSTypeRef
|
|
CSSymbolRef :: distinct CSTypeRef
|
|
CSSourceInfoRef :: distinct CSTypeRef
|
|
CSSymbolOwnerRef :: distinct CSTypeRef
|
|
|
|
CSNow :: 0x80000000
|
|
|
|
foreign symbolication {
|
|
@(link_name="CSIsNull")
|
|
_CSIsNull :: proc(ref: CSTypeRef) -> bool ---
|
|
@(link_name="CSRelease")
|
|
_CSRelease :: proc(ref: CSTypeRef) ---
|
|
|
|
CSSymbolicatorCreateWithPid :: proc(pid: posix.pid_t) -> CSSymbolicatorRef ---
|
|
|
|
CSSymbolicatorGetSymbolWithAddressAtTime :: proc(symbolicator: CSSymbolicatorRef, addr: uintptr, time: u64) -> CSSymbolRef ---
|
|
CSSymbolicatorGetSourceInfoWithAddressAtTime :: proc(symbolicator: CSSymbolicatorRef, adrr: uintptr, time: u64) -> CSSourceInfoRef ---
|
|
|
|
CSSymbolGetName :: proc(symbol: CSSymbolRef) -> cstring ---
|
|
CSSymbolGetSymbolOwner :: proc(symbol: CSSymbolRef) -> CSSymbolOwnerRef ---
|
|
|
|
CSSourceInfoGetPath :: proc(info: CSSourceInfoRef) -> cstring ---
|
|
CSSourceInfoGetLineNumber :: proc(info: CSSourceInfoRef) -> i32 ---
|
|
CSSourceInfoGetSymbol :: proc(info: CSSourceInfoRef) -> CSSymbolRef ---
|
|
|
|
CSSymbolOwnerGetPath :: proc(owner: CSSymbolOwnerRef) -> cstring ---
|
|
}
|
|
|
|
CSRelease :: #force_inline proc(ref: $T) {
|
|
_CSRelease(CSTypeRef(ref))
|
|
}
|
|
|
|
CSIsNull :: #force_inline proc(ref: $T) -> bool {
|
|
return _CSIsNull(CSTypeRef(ref))
|
|
}
|
|
|
|
// These could actually be smaller, but then we would have to define and check the size on each
|
|
// architecture, the sizes here are the largest they can be.
|
|
_LIBUNWIND_CONTEXT_SIZE :: 167
|
|
_LIBUNWIND_CURSOR_SIZE :: 204
|
|
|
|
unw_context_t :: struct {
|
|
data: [_LIBUNWIND_CONTEXT_SIZE]u64,
|
|
}
|
|
|
|
unw_cursor_t :: struct {
|
|
data: [_LIBUNWIND_CURSOR_SIZE]u64,
|
|
}
|
|
|
|
// Cross-platform registers, each architecture has additional registers but these are enough for us.
|
|
Register :: enum i32 {
|
|
SP = -2,
|
|
IP = -1,
|
|
}
|
|
|
|
foreign system {
|
|
unw_getcontext :: proc(ctx: ^unw_context_t) -> i32 ---
|
|
unw_init_local :: proc(cursor: ^unw_cursor_t, ctx: ^unw_context_t) -> i32 ---
|
|
unw_get_reg :: proc(cursor: ^unw_cursor_t, name: Register, reg: ^uintptr) -> i32 ---
|
|
unw_step :: proc(cursor: ^unw_cursor_t) -> i32 ---
|
|
}
|
|
|
|
}
|