Debug exit code

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 <fcntl.h>
 #include <signal.h>
 #include <stddef.h>
@@ skipping 203 matching lines @@
   // NOTE: This code MUST be async-signal safe.
   // NO malloc or stdio is allowed here.
 
   // 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();
 
-  PrintToStderr("Received signal ");
+  PrintToStderr("Received SSSS signal ");
   char buf[1024] = { 0 };
   internal::itoa_r(signal, buf, sizeof(buf), 10, 0);
   PrintToStderr(buf);
+  PrintToStderr("\n");
   if (signal == SIGBUS) {
     if (info->si_code == BUS_ADRALN)
       PrintToStderr(" BUS_ADRALN ");
     else if (info->si_code == BUS_ADRERR)
       PrintToStderr(" BUS_ADRERR ");
     else if (info->si_code == BUS_OBJERR)
       PrintToStderr(" BUS_OBJERR ");
     else
       PrintToStderr(" <unknown> ");
   } else if (signal == SIGFPE) {
@@ skipping 51 matching lines @@
 #if defined(CFI_ENFORCEMENT)
   if (signal == SIGILL && info->si_code == ILL_ILLOPN) {
     PrintToStderr(
         "CFI: Most likely a control flow integrity violation; for more "
         "information see:\n");
     PrintToStderr(
         "https://www.chromium.org/developers/testing/control-flow-integrity\n");
   }
 #endif
 
+  PrintToStderr("Before stacktrace print\n");
   debug::StackTrace().Print();
+  PrintToStderr("After stacktrace print\n");
 
 #if defined(OS_LINUX)
 #if ARCH_CPU_X86_FAMILY
   ucontext_t* context = reinterpret_cast<ucontext_t*>(void_context);
   const struct {
     const char* label;
     greg_t value;
   } registers[] = {
 #if ARCH_CPU_32_BITS
     { "  gs: ", context->uc_mcontext.gregs[REG_GS] },
@@ skipping 57 matching lines @@
     if ((i + 1) % 4 == 0)
       PrintToStderr("\n");
   }
   PrintToStderr("\n");
 #endif  // ARCH_CPU_X86_FAMILY
 #endif  // defined(OS_LINUX)
 
   PrintToStderr("[end of stack trace]\n");
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
-  if (::signal(signal, SIG_DFL) == SIG_ERR)
+  if (::signal(signal, SIG_DFL) == SIG_ERR) {
+    PrintToStderr("::signal(signal, SIG_DFL)\n");
     _exit(1);
+  }
 #else
   // Non-Mac OSes should probably reraise the signal as well, but the Linux
   // sandbox tests break on CrOS devices.
   // https://code.google.com/p/chromium/issues/detail?id=551681
+  PrintToStderr("Before _exit(1)\n");
   _exit(1);
 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 }
 
 class PrintBacktraceOutputHandler : public BacktraceOutputHandler {
  public:
   PrintBacktraceOutputHandler() {}
 
   void HandleOutput(const char* output) override {
     // NOTE: This code MUST be async-signal safe (it's used by in-process
@@ skipping 283 matching lines @@
 };
 #endif  // USE_SYMBOLIZE
 
 }  // namespace
 
 bool EnableInProcessStackDumping() {
 #if defined(USE_SYMBOLIZE)
   SandboxSymbolizeHelper::GetInstance();
 #endif  // USE_SYMBOLIZE
 
+  fprintf(stderr, "EnableInProcessStackDumping\n");
+
   // When running in an application, our code typically expects SIGPIPE
   // to be ignored.  Therefore, when testing that same code, it should run
   // with SIGPIPE ignored as well.
   struct sigaction sigpipe_action;
   memset(&sigpipe_action, 0, sizeof(sigpipe_action));
   sigpipe_action.sa_handler = SIG_IGN;
   sigemptyset(&sigpipe_action.sa_mask);
   bool success = (sigaction(SIGPIPE, &sigpipe_action, NULL) == 0);
 
   // Avoid hangs during backtrace initialization, see above.
@@ skipping 109 matching lines @@
     *ptr = *start;
     *start++ = ch;
   }
   return buf;
 }
 
 }  // namespace internal
 
 }  // namespace debug
 }  // namespace base