Initial project import

tools/v/vlib/builtin/backtraces.c.v

@@ -0,0 +1,116 @@
+module builtin
+
+// print_backtrace shows a backtrace of the current call stack on stdout.
+pub fn print_backtrace() {
+	// At the time of backtrace_symbols_fd call, the C stack would look something like this:
+	// * print_backtrace_skipping_top_frames
+	// * print_backtrace itself
+	// * the rest of the backtrace frames
+	// => top 2 frames should be skipped, since they will not be informative to the developer
+	$if !no_backtrace ? {
+		$if freestanding {
+			println(bare_backtrace())
+		} $else $if tinyc {
+			C.tcc_backtrace(c'Backtrace')
+		} $else $if use_libbacktrace ? {
+			$if openbsd {
+				print_backtrace_skipping_top_frames(2)
+			} $else {
+				// NOTE: TCC doesn't have the unwind library
+				print_libbacktrace(1)
+			}
+		} $else {
+			print_backtrace_skipping_top_frames(2)
+		}
+	}
+}
+
+// demangle_v_symbol converts a C-mangled V symbol name to a human-readable V name.
+// For example: `veb__run_T_main__App_main__Context` => `veb.run[main.App, main.Context]`
+@[direct_array_access]
+fn demangle_v_symbol(cname string) string {
+	mut name := cname
+	// Strip builtin__ prefix:
+	if name.starts_with('builtin__') {
+		name = name[9..]
+	}
+	// Replace pointer type encoding:
+	name = name.replace('__ptr__', '&')
+	// Split base name from generic parameters on `_T_`:
+	// C mangling: `base_T_type1_type2` where each type is prefixed with `_`
+	// and types may contain `__` for module separators.
+	t_pos := name.index('_T_') or { -1 }
+	if t_pos >= 0 {
+		base := name[..t_pos].replace('__', '.')
+		generic_suffix := name[t_pos + 3..]
+		// Split on single `_` that is not part of `__` (double underscore).
+		params := split_generic_params(generic_suffix)
+		mut demangled_params := []string{cap: params.len}
+		for param in params {
+			demangled_params << param.replace('__', '.')
+		}
+		return base + '[' + demangled_params.join(', ') + ']'
+	}
+	// No generics - just replace module separator:
+	name = name.replace('__', '.')
+	// `main.main` is V's internal C mangling, in V it's just `main`:
+	if name == 'main.main' {
+		return 'main'
+	}
+	return name
+}
+
+// split_generic_params splits a generic suffix like `main__App_main__Context`
+// into individual type parameters [`main__App`, `main__Context`].
+// Splits on single `_` but not `__` (double underscore used for module separators).
+@[direct_array_access]
+fn split_generic_params(s string) []string {
+	mut params := []string{}
+	mut start := 0
+	mut i := 0
+	for i < s.len {
+		if s[i] == `_` {
+			if i + 1 < s.len && s[i + 1] == `_` {
+				// Part of `__` (module separator), skip both.
+				i += 2
+			} else {
+				// Single `_` is a generic param separator.
+				if i > start {
+					params << s[start..i]
+				}
+				i++
+				start = i
+			}
+		} else {
+			i++
+		}
+	}
+	if start < s.len {
+		params << s[start..]
+	}
+	return params
+}
+
+// demangle_backtrace_sym demangles a V symbol within a Linux-style backtrace fragment.
+// Linux format: `./executable(symbol_name+0x1a4) `
+fn demangle_backtrace_sym(s string) string {
+	paren_start := s.index('(') or { return s }
+	plus_pos := s.index_after_('+', paren_start)
+	if plus_pos < 0 {
+		return s
+	}
+	symbol := s[paren_start + 1..plus_pos]
+	if symbol.len == 0 {
+		return s
+	}
+	return s[..paren_start + 1] + demangle_v_symbol(symbol) + s[plus_pos..]
+}
+
+fn eprint_space_padding(output string, max_len int) {
+	padding_len := max_len - output.len
+	if padding_len > 0 {
+		for _ in 0 .. padding_len {
+			eprint(' ')
+		}
+	}
+}