How to use absl::InstallFailureSignalHandler

[stonebrakert6]

Hi,
I am calling the function InstallFailureSignalHandler in the main function(in the first line itself)

int main(int argc, char* argv[]) {
   InstallFailureSignalHandler(argv[0]);
   ...

Here is the definition of InstallFailureSignalHandler

void InstallFailureSignalHandler(const char* app_name) {
  // Initialize the symbolizer to get a human-readable stack trace
  absl::InitializeSymbolizer(app_name);
  // Install the failure signal handlers
  absl::FailureSignalHandlerOptions options;
  absl::InstallFailureSignalHandler(options);
}

I am expecting to see a helpful backtrace(just like gdb/lldb does with the core dump file)
However, the stacktrace I am getting is lacking in information. My binary is build with -g and -fno-omit-frame-pointer. Here is the stacktrace I got

*** SIGSEGV received at time=1690370313 on cpu 15 ***
PC: @           0x64ad32  (unknown)  __strcpy_avx2
    @           0x463abc         64  absl::WriteFailureInfo()
    @           0x463798         96  absl::AbslFailureSignalHandler()
    @           0x5daed0  (unknown)  (unknown)
    @           0x3645ba        928  main
    @           0x5c1eda  (unknown)  __libc_start_call_main
Segmentation fault (core dumped)

Notice that I am not able to see the file name, function and line numbers.

and here is the backtrace using gdb's bt on the coredump

[Current thread is 1 (Thread 0x2eaf440 (LWP 113034))]
(gdb) bt
#0  0x000000000061a33c in pthread_kill ()
#1  0x00000000005dae56 in gsignal ()
#2  0x0000000000463a3f in absl::RaiseToDefaultHandler (signo=11) at external/com_google_absl/absl/debugging/failure_signal_handler.cc:74
#3  0x00000000004637e8 in absl::AbslFailureSignalHandler (signo=11, ucontext=0x7fbd5f569480) at external/com_google_absl/absl/debugging/failure_signal_handler.cc:394
#4  <signal handler called>
#5  0x000000000064ad32 in __strcpy_avx2 ()
#6  0x0000000000364d6d in badFunction (a=0x27e13fc08010 "hell") at main/main.cc:31
#7  0x00000000003645ba in main (argc=1, argv=0x7ffcec3204d8) at main/main.cc:46

My system is Ubuntu 22.04 and I am using clang-17. In the build file I am adding a dependency upon "@com_google_absl//absl/debugging:failure_signal_handler"

Am I using this tool correctly? Why I am not getting the full stacktrace(badFunction missing) and missing information?

[derekmauro]

I think there are two issues here.

The first issue is the file/line numbers. We don't currently have them. The signal handler needs to be async-signal-safe, and as far as a I know, we don't have an async-signal-safe way of getting them. gdb and friends don't have this restriction.

The second issue is that I think this is trying to walk the stack though glibc (the failure is in __strcpy_avx2). Your code may be compiled with -fno-omit-frame-pointer, but if you are using a system installed glibc, glibc itself may not be built with -fno-omit-frame-pointer. Without a frame pointer, you can't walk the stack any further. This is similar to the issue reported in #769.

[stonebrakert6]

Thanks @derekmauro. A couple of questions

1. I checked Envoy uses absl::GetStackTrace and absl::Symbolize and so does Chromium source code(correct me if I am wrong).
   So is the purpose of absl::InstallFailureSignalHandler() to automatically get stacktrace in case of failures(since internally it uses GetStackTrace and Symbolize), without the user having to write any signal handler?
   So the workflow is
   a) Install failure_handlers
   b) Get stack trace
   c) Run addr2line to get file and line numbers
   Is this understanding correct?

2. What is the third column?(frame size?)

3. Is there a tool/utility in abseil that takes stacktrace in the format output by FailureSignalHandler and uses addr2line to decode the file and line numbers? I know that Envoy has a stack_decode.py which internally uses addr2line.

I am able to run addr2line on the addresses and get the file and line number information.
llvm-addr2line -e a.out -f -C <list of addresses>. Do you think these are reasonable switches? What do you guys use?