140 lines
3.9 KiB
Odin
140 lines
3.9 KiB
Odin
#+vet explicit-allocators
|
|
#+private
|
|
package back
|
|
|
|
@require import "base:intrinsics"
|
|
@require import "base:runtime"
|
|
|
|
@require import "core:io"
|
|
@require import "core:strings"
|
|
@require import "core:sync"
|
|
@require import "core:unicode/utf16"
|
|
@require import win "core:sys/windows"
|
|
|
|
when !USE_FALLBACK {
|
|
|
|
SYMOPT_DEFERRED_LOADS :: 0x00000004
|
|
|
|
_Trace_Entry :: uintptr
|
|
|
|
_trace :: #force_no_inline proc(buf: Trace) -> (n: int) {
|
|
frame_count := win.RtlCaptureStackBackTrace(2, u32(len(buf)), ([^]rawptr)(raw_data(buf)), nil)
|
|
|
|
for &frame in buf[:frame_count] {
|
|
// NOTE: Return address is one after the call instruction so subtract a byte to
|
|
// end up back inside the call instruction which is needed for SymFromAddr.
|
|
frame -= 1
|
|
}
|
|
|
|
return int(frame_count)
|
|
}
|
|
|
|
_lines_destroy :: proc(lines: []Line, allocator: runtime.Allocator) {
|
|
for line in lines {
|
|
delete(line.location, allocator)
|
|
if line.symbol != "??" && line.symbol != "??OOM" {
|
|
delete(line.symbol, allocator)
|
|
}
|
|
}
|
|
delete(lines, allocator)
|
|
}
|
|
|
|
_lines :: proc(bt: Trace, allocator, temp_allocator: runtime.Allocator) -> (out: []Line, err: Lines_Error) {
|
|
// Debug info is needed, if we call with out-of-date debug symbols it will return out-of-date info, so better to short-circuit right away.
|
|
when !ODIN_DEBUG {
|
|
out = make([]Line, len(bt), allocator)
|
|
for &line, i in out {
|
|
line.symbol = "??"
|
|
|
|
location := strings.builder_make(allocator)
|
|
strings.write_string(&location, "0x")
|
|
strings.write_i64 (&location, i64(bt[i]), 16)
|
|
line.location = strings.to_string(location)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
out = make([]Line, len(bt), allocator)
|
|
defer if err != nil { _lines_destroy(out, allocator) }
|
|
|
|
process := win.GetCurrentProcess()
|
|
|
|
sync.guard(&_win32_dbghelp_mutex)
|
|
|
|
if !win.SymInitialize(process, nil, true) {
|
|
err = .Info_Not_Found
|
|
return
|
|
}
|
|
defer win.SymCleanup(process)
|
|
|
|
win.SymSetOptions(win.SYMOPT_LOAD_LINES|SYMOPT_DEFERRED_LOADS)
|
|
|
|
data: [size_of(win.SYMBOL_INFOW) + size_of([256]win.WCHAR)]byte
|
|
symbol := (^win.SYMBOL_INFOW)(&data[0])
|
|
// The value of SizeOfStruct must be the size of the whole struct,
|
|
// not just the size of the pointer
|
|
symbol.SizeOfStruct = size_of(symbol^)
|
|
symbol.MaxNameLen = 255
|
|
|
|
for &line, i in out {
|
|
if win.SymFromAddrW(process, win.DWORD64(bt[i]), nil, symbol) {
|
|
symbol, mem_err := win.wstring_to_utf8(cstring16(&symbol.Name[0]), int(symbol.NameLen), allocator)
|
|
if mem_err != nil {
|
|
line.symbol = "??OOM"
|
|
} else if symbol == "??" {
|
|
delete(symbol, allocator)
|
|
line.symbol = "??"
|
|
} else {
|
|
line.symbol = symbol
|
|
}
|
|
} else {
|
|
line.symbol = "??"
|
|
}
|
|
|
|
lineInfo: win.IMAGEHLP_LINE64
|
|
lineInfo.SizeOfStruct = size_of(lineInfo)
|
|
if win.SymGetLineFromAddrW64(process, win.DWORD64(bt[i]), &{}, &lineInfo) {
|
|
location := strings.builder_make(allocator)
|
|
write_string16(&location, string16(lineInfo.FileName))
|
|
when ODIN_ERROR_POS_STYLE == .Default {
|
|
strings.write_byte(&location, '(')
|
|
strings.write_int (&location, int(lineInfo.LineNumber))
|
|
strings.write_byte(&location, ')')
|
|
} else when ODIN_ERROR_POS_STYLE == .Unix {
|
|
strings.write_byte(&location, ':')
|
|
strings.write_int (&location, int(lineInfo.LineNumber))
|
|
} else {
|
|
#panic("unhandled ODIN_ERROR_POS_STYLE")
|
|
}
|
|
line.location = strings.to_string(location)
|
|
} else {
|
|
location := strings.builder_make(allocator)
|
|
strings.write_string(&location, "0x")
|
|
strings.write_i64 (&location, i64(bt[i]), 16)
|
|
line.location = strings.to_string(location)
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
write_string16 :: proc(b: ^strings.Builder, s: string16, loc := #caller_location) -> (n: int, err: io.Error) {
|
|
for i := 0; i < len(s); i += 1 {
|
|
r := rune(utf16.REPLACEMENT_CHAR)
|
|
|
|
switch c := s[i]; {
|
|
case c < utf16._surr1, utf16._surr3 <= c:
|
|
r = rune(c)
|
|
case utf16._surr1 <= c && c < utf16._surr2 && i+1 < len(s) &&
|
|
utf16._surr2 <= s[i+1] && s[i+1] < utf16._surr3:
|
|
r = utf16.decode_surrogate_pair(rune(c), rune(s[i+1]))
|
|
i += 1
|
|
}
|
|
|
|
n += strings.write_rune(b, rune(r)) or_return
|
|
}
|
|
return
|
|
}
|
|
|
|
}
|