Freestanding ELF stack traces

[tilkinsc]

I am pretty new to C3 and I was looking at it. I am currently in development of a hobby OS and I use elf binaries. I noticed that the ELF format does not have stack traces. In a freestanding environment that is totally understandable. However, I also have the power to drive whatever allocation is necessary for C3 to accomplish stack traces. Does anyone have any idea if C3 exposes anything I can integrate with for stack traces?

[Book-reader]

There are several ways you could do that.
You could hook into the default system of backtraces, but env::NATIVE_STACKTRACE, the constant which decides if backtraces should be used when panicking, is hardcoded to specific OSs in lib/std/core/builtin.c3 so unless you edit the stdlib in a few different places it'd be simpler to make your own panic function that prints the backtrace (if you want to get the same formatting as the stdlib you could use the Backtrace struct since it's what decides the format of each line of the backtrace with its .to_format method).

If you use the stdlib then at runtime you can do builtin::panic = &my_panic_fn to replace the panic function, and if you don't use the stdlib or want your panic function in a different place then you can create your own panic function like this:

module myos;
alias PanicFn = fn void(String message, String file, String function, uint line);

PanicFn panic = &default_panic;

fn void default_panic(String message, String file, String function, uint line)
{
    print("something went wrong!!");
    print_the_backtrace();
    $$trap(); // ud2 on x86_64
}
// you can also use a lambda if you don't intend to swap out & back the panic function at runtime:
PanicFn panic = fn (message, file, function, line)
{
   ...
};

then if you use a project.json you can add "panicfn": "myos::panic" and if you don't you can run c3c with --panicfn "myos::panic", and when anything panics it will call this function.

this is a general overview of the code for how backtraces are collected & printed on panic in the stdlib that you could look at for your own implementation, but you don't necessarily have to follow it:

Details

c3c/lib/std/core/builtin.c3

Line 255 in a9d93c9

PanicFn panic = &default_panic;

c3c/lib/std/core/builtin.c3

Lines 213 to 224 in a9d93c9

	fn void default_panic(String message, String file, String function, uint line) @if(env::NATIVE_STACKTRACE)
	{
	in_panic = true;
	$if $defined(io::stderr) && env::PANIC_MSG:
	if (!print_backtrace(message, 2))
	{
	io::eprintfn("\nERROR: '%s', in %s (%s:%d)", message, function, file, line);
	}
	$endif
	$$trap();
	}

c3c/lib/std/core/builtin.c3

Lines 176 to 211 in a9d93c9

	fn bool print_backtrace(String message, int backtraces_to_ignore, void *added_backtrace = null) @if (env::NATIVE_STACKTRACE) => @stack_mem(0x1100; Allocator smem)
	{
	void*[256] buffer;
	void*[] backtraces = backtrace::capture_current(&buffer);
	if (added_backtrace)
	{
	backtraces[++backtraces_to_ignore] = added_backtrace;
	}
	@stack_mem(4096; Allocator mem)
	{
	BacktraceList? backtrace = backtrace::symbolize_backtrace(mem, backtraces);
	if (catch backtrace) return false;
	if (backtrace.len() <= backtraces_to_ignore) return false;
	io::eprint("\nERROR: '");
	io::eprint(message);
	io::eprintn("'");
	foreach (i, &trace : backtrace)
	{
	if (i < backtraces_to_ignore) continue;
	String inline_suffix = trace.is_inline ? " [inline]" : "";
	if (trace.is_unknown())
	{
	io::eprintfn(" in ???%s", inline_suffix);
	continue;
	}
	if (trace.has_file())
	{
	io::eprintfn(" in %s (%s:%d) [%s]%s", trace.function, trace.file, trace.line, trace.object_file, inline_suffix);
	continue;
	}
	io::eprintfn(" in %s (source unavailable) [%s]%s", trace.function, trace.object_file, inline_suffix);
	}
	};
	return true;
	}

c3c/lib/std/os/backtrace.c3

Lines 73 to 86 in a9d93c9

	fn void*[] capture_current(void*[] buffer)
	{
	if (!buffer.len) return buffer[:0];
	$switch:
	$case env::POSIX:
	CInt len = posix::backtrace(buffer.ptr, buffer.len);
	return buffer[:len];
	$case env::WIN32:
	Win32_WORD len = win32::rtlCaptureStackBackTrace(0, buffer.len, buffer.ptr, null);
	return buffer[:len];
	$default:
	return buffer[:0];
	$endswitch
	}

c3c/lib/std/os/backtrace.c3

Line 90 in a9d93c9

alias symbolize_backtrace @if(env::LINUX) = linux::symbolize_backtrace;

c3c/lib/std/os/linux/linux.c3

Lines 300 to 317 in a9d93c9

	fn BacktraceList? symbolize_backtrace(Allocator allocator, void*[] backtrace)
	{
	BacktraceList list;
	list.init(allocator, backtrace.len);
	defer catch
	{
	foreach (trace : list)
	{
	trace.free();
	}
	list.free();
	}
	foreach (addr : backtrace)
	{
	backtrace_add_element(allocator, &list, addr)!;
	}
	return list;
	}

and then all of the other relevant backtrace collection for linux is in lib/std/os/linux/linux.c3.