GTTF: dump registers on crash on 64-bit Linux

base/debug/stack_trace_posix.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/debug/stack_trace.h"
 
 #include <errno.h>
 #include <execinfo.h>
 #include <fcntl.h>
 #include <signal.h>
@@ skipping 96 matching lines @@
  public:
   virtual void HandleOutput(const char* output) = 0;
 
  protected:
   virtual ~BacktraceOutputHandler() {}
 };
 
 void OutputPointer(void* pointer, BacktraceOutputHandler* handler) {
   char buf[1024] = { '\0' };
   handler->HandleOutput(" [0x");
-  internal::itoa_r(reinterpret_cast<intptr_t>(pointer), buf, sizeof(buf), 16);
+  internal::itoa_r(reinterpret_cast<intptr_t>(pointer),
+                   buf, sizeof(buf), 16, 12);
   handler->HandleOutput(buf);
   handler->HandleOutput("]");
 }
 
 void ProcessBacktrace(void *const *trace,
                       int size,
                       BacktraceOutputHandler* handler) {
   // NOTE: This code MUST be async-signal safe (it's used by in-process
   // stack dumping signal handler). NO malloc or stdio is allowed here.
 
 #if defined(USE_SYMBOLIZE)
   for (int i = 0; i < size; ++i) {
-    handler->HandleOutput("\t");
+    OutputPointer(trace[i], handler);

[jar (doing other things), 2013/01/09 19:04:25]

Why did you change the order of this in the output?  Does anyone use and parse
the current output?

[Paweł Hajdan Jr., 2013/01/09 19:08:25]

I'm not aware of anyone parsing this output, it's not designed for parsing, it's
not intended for parsing. The new order makes stack addresses aligned in the
output, possibly making it easier to see some regularities.

+    handler->HandleOutput(" ");
 
     char buf[1024] = { '\0' };
 
     // Subtract by one as return address of function may be in the next
     // function when a function is annotated as noreturn.
     void* address = static_cast<char*>(trace[i]) - 1;
     if (google::Symbolize(address, buf, sizeof(buf)))
       handler->HandleOutput(buf);
     else
       handler->HandleOutput("<unknown>");
 
-    OutputPointer(trace[i], handler);
     handler->HandleOutput("\n");
   }
 #else
   bool printed = false;
 
   // Below part is async-signal unsafe (uses malloc), so execute it only
   // when we are not executing the signal handler.
   if (in_signal_handler == 0) {
     scoped_ptr_malloc<char*> trace_symbols(backtrace_symbols(trace, size));
     if (trace_symbols.get()) {
@@ skipping 23 matching lines @@
 
   // Record the fact that we are in the signal handler now, so that the rest
   // of StackTrace can behave in an async-signal-safe manner.
   in_signal_handler = 1;
 
   if (BeingDebugged())
     BreakDebugger();
 
   char buf[1024] = "Received signal ";
   size_t buf_len = strlen(buf);
-  internal::itoa_r(signal, buf + buf_len, sizeof(buf) - buf_len, 10);
+  internal::itoa_r(signal, buf + buf_len, sizeof(buf) - buf_len, 10, 0);
   RAW_LOG(ERROR, buf);
 
   debug::StackTrace().PrintBacktrace();
 
-  // TODO(shess): Port to Linux.
-#if defined(OS_MACOSX)
+#if defined(OS_LINUX)
+  // TODO(phajdan.jr): Port to 32-bit.
+#if ARCH_CPU_X86_FAMILY && ARCH_CPU_64_BITS
+  const struct {
+    const char* label;
+    greg_t value;
+  } registers[] = {
+    { "  r8: ", context->uc_mcontext.gregs[REG_R8] },

[jar (doing other things), 2013/01/04 20:57:36]

Question: Are all these registers held intact during this execution of the
initializer?  Are you guaranteed that they won't be changed?

[Paweł Hajdan Jr., 2013/01/04 21:53:23]

See http://pubs.opengroup.org/onlinepubs/007904975/functions/sigaction.html .
The context we get as an argument is the context from time the signal was
caught, not the current context, which could have been obtained with just
getcontext(2).

+    { "  r9: ", context->uc_mcontext.gregs[REG_R9] },
+    { " r10: ", context->uc_mcontext.gregs[REG_R10] },
+    { " r11: ", context->uc_mcontext.gregs[REG_R11] },
+    { " r12: ", context->uc_mcontext.gregs[REG_R12] },
+    { " r13: ", context->uc_mcontext.gregs[REG_R13] },
+    { " r14: ", context->uc_mcontext.gregs[REG_R14] },
+    { " r15: ", context->uc_mcontext.gregs[REG_R15] },
+    { "  di: ", context->uc_mcontext.gregs[REG_RDI] },
+    { "  si: ", context->uc_mcontext.gregs[REG_RSI] },
+    { "  bp: ", context->uc_mcontext.gregs[REG_RBP] },
+    { "  bx: ", context->uc_mcontext.gregs[REG_RBX] },
+    { "  dx: ", context->uc_mcontext.gregs[REG_RDX] },
+    { "  ax: ", context->uc_mcontext.gregs[REG_RAX] },
+    { "  cx: ", context->uc_mcontext.gregs[REG_RCX] },
+    { "  sp: ", context->uc_mcontext.gregs[REG_RSP] },
+    { "  ip: ", context->uc_mcontext.gregs[REG_RIP] },
+    { " efl: ", context->uc_mcontext.gregs[REG_EFL] },
+    { " cgf: ", context->uc_mcontext.gregs[REG_CSGSFS] },
+    { " erf: ", context->uc_mcontext.gregs[REG_ERR] },
+    { " trp: ", context->uc_mcontext.gregs[REG_TRAPNO] },
+    { " msk: ", context->uc_mcontext.gregs[REG_OLDMASK] },
+    { " cr2: ", context->uc_mcontext.gregs[REG_CR2] },
+  };
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(registers); i++) {
+    HANDLE_EINTR(write(STDERR_FILENO,
+                       registers[i].label,
+                       strlen(registers[i].label)));
+    internal::itoa_r(registers[i].value, buf, sizeof(buf), 16, 16);
+    HANDLE_EINTR(write(STDERR_FILENO, buf, strlen(buf)));
+
+    if ((i + 1) % 4 == 0) {
+      HANDLE_EINTR(write(STDERR_FILENO, "\n", 1));
+    }
+  }
+  HANDLE_EINTR(write(STDERR_FILENO, "\n", 1));
+#endif
+#elif defined(OS_MACOSX)
   // TODO(shess): Port to 64-bit.
 #if ARCH_CPU_X86_FAMILY && ARCH_CPU_32_BITS
   size_t len;
 
   // NOTE: Even |snprintf()| is not on the approved list for signal
   // handlers, but buffered I/O is definitely not on the list due to
   // potential for |malloc()|.
   len = static_cast<size_t>(
       snprintf(buf, sizeof(buf),
                "ax: %x, bx: %x, cx: %x, dx: %x\n",
@@ skipping 137 matching lines @@
 }
 
 void StackTrace::OutputToStream(std::ostream* os) const {
   StreamBacktraceOutputHandler handler(os);
   ProcessBacktrace(trace_, count_, &handler);
 }
 
 namespace internal {
 
 // NOTE: code from sandbox/linux/seccomp-bpf/demo.cc.
-char *itoa_r(intptr_t i, char *buf, size_t sz, int base) {
+char *itoa_r(intptr_t i, char *buf, size_t sz, int base, size_t padding) {
   // Make sure we can write at least one NUL byte.
   size_t n = 1;
   if (n > sz)
     return NULL;
 
   if (base < 2 || base > 16) {
     buf[0] = '\000';
     return NULL;
   }
 
@@ skipping 19 matching lines @@
   do {
     // Make sure there is still enough space left in our output buffer.
     if (++n > sz) {
       buf[0] = '\000';
       return NULL;
     }
 
     // Output the next digit.
     *ptr++ = "0123456789abcdef"[j % base];
     j /= base;
-  } while (j);
+
+    if (padding > 0)
+      padding--;
+  } while (j > 0 || padding > 0);
 
   // Terminate the output with a NUL character.
   *ptr = '\000';
 
   // Conversion to ASCII actually resulted in the digits being in reverse
   // order. We can't easily generate them in forward order, as we can't tell
   // the number of characters needed until we are done converting.
   // So, now, we reverse the string (except for the possible "-" sign).
   while (--ptr > start) {
     char ch = *ptr;
     *ptr = *start;
     *start++ = ch;
   }
   return buf;
 }
 
 }  // namespace internal
 
 }  // namespace debug
 }  // namespace base