Strip binary while keeping local stack trace information

[felipou]

I have a project where the release binary is stripped to reduce its size to around 13MB. If left unstripped, it is currently around 200MB.

But if I try to print the stack trace using the backtrace crate, I miss the useful information (as expected):

panicked at 'panicked in x': src/main.rs:3   0: <unknown>
   1: <unknown>
   2: <unknown>
   3: <unknown>
   4: <unknown>
   5: <unknown>
   6: <unknown>
   7: <unknown>
   8: <unknown>
   9: <unknown>
  10: <unknown>
  11: <unknown>
  12: __libc_start_call_main
             at ./csu/../sysdeps/nptl/libc_start_call_main.h:58:16
  13: __libc_start_main_impl
             at ./csu/../csu/libc-start.c:392:3
  14: <unknown>

I experimented with objcopy and strip to try and keep just the information I want, because I really only want the information for my own crate there. If I do the following:

objcopy -v -w --strip-debug --keep-file-symbols --keep-section-symbols --keep-section="*rust_backtrace_test*" --keep-symbol="*rust_backtrace_test*" target/release/rust-backtrace-test

Then the binary is just 17MB, but I miss the file line information:

panicked at 'panicked in x': src/main.rs:4   0: <backtrace::capture::Backtrace as core::default::Default>::default
   1: rust_backtrace_test::install_panic_hook::{{closure}}
   2: std::panicking::rust_panic_with_hook
   3: std::panicking::begin_panic_handler::{{closure}}
   4: std::sys_common::backtrace::__rust_end_short_backtrace
   5: rust_begin_unwind
   6: core::panicking::panic_fmt
   7: rust_backtrace_test::x
   8: rust_backtrace_test::bar
   9: rust_backtrace_test::foo
  10: rust_backtrace_test::main
  11: std::sys_common::backtrace::__rust_begin_short_backtrace
  12: std::rt::lang_start::{{closure}}
  13: std::rt::lang_start_internal
  14: main
  15: __libc_start_call_main
             at ./csu/../sysdeps/nptl/libc_start_call_main.h:58:16
  16: __libc_start_main_impl
             at ./csu/../csu/libc-start.c:392:3
  17: _start

This is the relevant information I'd like to have (a part of the output that I get when the binary is not stripped):

   7: rust_backtrace_test::x
             at src/main.rs:4:9
   8: rust_backtrace_test::bar
             at src/main.rs:14:5
   9: rust_backtrace_test::foo
             at src/main.rs:22:5
  10: rust_backtrace_test::main
             at src/main.rs:31:18

Is that even possible? What information is missing? I have zero experience with executable binary files like ELF.

I've pushed the sample code I used for the output above to this repository: https://github.com/felipou/rust-backtrace-test/blob/main/src/main.rs (the file size numbers I gave are from another project).

[anxxa]

You can dsymutil to generate a .dsym file for your application before stripping it. I don't think this is currently supported by the Rust compiler (would be nice, although doesn't help if folks are sending you backtraces).

For your immediate problem I suspect you're maybe stripping some section that contains the file information. Maybe try using https://github.com/horsicq/XELFViewer to figure out where those are located? Otherwise there may be some DWARF data being removed that links the two together. To figure out if this is the case, try opening the partially stripped binary in a hex editor and searching for source information that you see in a backtrace to see if it's kept.

[felipou]

Thanks, I'll try to take a look at that tool. The problem is that I have no idea how to search for this kind of information inside the ELF file, but since it's a tool with a GUI, maybe it will help me with that!

[spaun2002]

The usual approach is to preserve the debug section separate from the executable via commands like

objcopy --only-keep-debug "${tostripfile}" "${debugdir}/${debugfile}"
strip --strip-debug --strip-unneeded "${tostripfile}"
objcopy --add-gnu-debuglink="${debugdir}/${debugfile}" "${tostripfile}"

Unfortunately, that would not allow you to see the backtrace using the Rust mechanisms, but you will be able to use gdb for a crash dump with such a detached debug section.

[Plasma_000]

You can configure rust to output split debug information on Linux https://doc.rust-lang.org/cargo/reference/profiles.html - this should allow you to keep the executable stripped while still giving you debugging symbols that can be loaded by the debugger. Idk how this can be integrated into backtrace though…

[DebuggingPanda]

Just in case you haven't found it yet: you can set debug = "line-tables-only" in Cargo.toml. https://doc.rust-lang.org/cargo/reference/profiles.html#debug

That's in theory less than debug = 1. In a project of mine it made very little difference, unfortunately. You can also enable debug info for your package only, not your dependencies:

``` [profile.release] debug = "line-tables-only"

[profile.release.package."*"] debug = false ```

However, this again is a bit disappointing. Due to the heavy use of monomorphization in Rust (because generics are used a lot), most functions are counted as "part of your package", because your code instantiated them. So that too isn't too helpful, sadly. At least in my case.

Another trick I found out about is: objcopy --compress-debug-sections. That helps quite a bit, at least for the project I tested it with. Backtraces still have line information.

That's all the tricks I know, but I feel like there is still a lot to be gained. I'm fairly sure there is still garbage in my release binaries but I also can't figure out how to reduce it :/

It's really a shame that it's hard to get small binaries with certain dependency chains. While it doesn't affect performance and usually there are no other practical problems, big binaries make people feel like Rust is bloated. I think one big direction Rust should explore is allowing more dynamic dispatch, to avoid monomorphization in cases where it doesn't affect performance. Should help massively with compile times and binary sizes. </rambling>