Use posix version of stack_trace on iOS

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 161 matching lines @@
   }
 #endif  // defined(USE_SYMBOLIZE)
 }
 
 void PrintToStderr(const char* output) {
   // 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.
   ignore_result(HANDLE_EINTR(write(STDERR_FILENO, output, strlen(output))));
 }
 
-#if !defined(OS_IOS)
 void StackDumpSignalHandler(int signal, siginfo_t* info, void* void_context) {
   // 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 ");
   char buf[1024] = { 0 };
   internal::itoa_r(signal, buf, sizeof(buf), 10, 0);
   PrintToStderr(buf);
+#if !defined(OS_IOS)
+  // NOTE: on iOS, info and void_context are incorrect. Ignore them.

[Mark Mentovai, 2014/01/15 19:14:06]

If you’ve got a reference (link?) to point to here, it’d be helpful. Also, if
you can determine whether it’s just broken for ARM and OK in the simulator, you
can refine the #ifdef.

   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 39 matching lines @@
       PrintToStderr(" SEGV_ACCERR ");
     else
       PrintToStderr(" <unknown> ");
   }
   if (signal == SIGBUS || signal == SIGFPE ||
       signal == SIGILL || signal == SIGSEGV) {
     internal::itoa_r(reinterpret_cast<intptr_t>(info->si_addr),
                      buf, sizeof(buf), 16, 12);
     PrintToStderr(buf);
   }
+  #endif  // !defined(OS_IOS)
   PrintToStderr("\n");
 
   debug::StackTrace().Print();
 
 #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;
@@ skipping 55 matching lines @@
     PrintToStderr(registers[i].label);
     internal::itoa_r(registers[i].value, buf, sizeof(buf),
                      16, kRegisterPadding);
     PrintToStderr(buf);
 
     if ((i + 1) % 4 == 0)
       PrintToStderr("\n");
   }
   PrintToStderr("\n");
 #endif
-#elif defined(OS_MACOSX)
+#elif defined(OS_MACOSX) && !defined(OS_IOS)

[Mark Mentovai, 2014/01/15 19:14:06]

You probably don’t need !defined(OS_IOS) here, because everything inside this is
limited to ARCH_CPU_X86_FAMILY && ARCH_CPU_32_BITS. You could change the next
line to “port to x86_64 and ARM (for iOS).”

Unless this won’t work at all in the simulator.

   // TODO(shess): Port to 64-bit.
 #if ARCH_CPU_X86_FAMILY && ARCH_CPU_32_BITS
   ucontext_t* context = reinterpret_cast<ucontext_t*>(void_context);
   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),
@@ skipping 19 matching lines @@
       snprintf(buf, sizeof(buf),
                "ip: %x, cs: %x, ds: %x, es: %x, fs: %x, gs: %x\n",
                context->uc_mcontext->__ss.__eip,
                context->uc_mcontext->__ss.__cs,
                context->uc_mcontext->__ss.__ds,
                context->uc_mcontext->__ss.__es,
                context->uc_mcontext->__ss.__fs,
                context->uc_mcontext->__ss.__gs));
   write(STDERR_FILENO, buf, std::min(len, sizeof(buf) - 1));
 #endif  // ARCH_CPU_32_BITS
-#endif  // defined(OS_MACOSX)
+#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
   _exit(1);
 }
-#endif  // !defined(OS_IOS)
 
 class PrintBacktraceOutputHandler : public BacktraceOutputHandler {
  public:
   PrintBacktraceOutputHandler() {}
 
   virtual void HandleOutput(const char* output) OVERRIDE {
     // 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.
     PrintToStderr(output);
   }
@@ skipping 10 matching lines @@
   virtual void HandleOutput(const char* output) OVERRIDE {
     (*os_) << output;
   }
 
  private:
   std::ostream* os_;
 
   DISALLOW_COPY_AND_ASSIGN(StreamBacktraceOutputHandler);
 };
 
-#if !defined(OS_IOS)
 void WarmUpBacktrace() {
   // Warm up stack trace infrastructure. It turns out that on the first
   // call glibc initializes some internal data structures using pthread_once,
   // and even backtrace() can call malloc(), leading to hangs.
   //
   // Example stack trace snippet (with tcmalloc):
   //
   // #8  0x0000000000a173b5 in tc_malloc
   //             at ./third_party/tcmalloc/chromium/src/debugallocation.cc:1161
   // #9  0x00007ffff7de7900 in _dl_map_object_deps at dl-deps.c:517
@@ skipping 12 matching lines @@
   // #19 0x00007ffff61efa14 in __GI___backtrace
   //             at ../sysdeps/x86_64/../ia64/backtrace.c:104
   // #20 0x0000000000752a54 in base::debug::StackTrace::StackTrace
   //             at base/debug/stack_trace_posix.cc:175
   // #21 0x00000000007a4ae5 in
   //             base::(anonymous namespace)::StackDumpSignalHandler
   //             at base/process_util_posix.cc:172
   // #22 <signal handler called>
   StackTrace stack_trace;
 }
-#endif  // !defined(OS_IOS)
 
 }  // namespace
 
-#if !defined(OS_IOS)
 bool EnableInProcessStackDumping() {
   // 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.
   WarmUpBacktrace();
 
   struct sigaction action;
   memset(&action, 0, sizeof(action));
   action.sa_flags = SA_RESETHAND | SA_SIGINFO;
   action.sa_sigaction = &StackDumpSignalHandler;
   sigemptyset(&action.sa_mask);
 
   success &= (sigaction(SIGILL, &action, NULL) == 0);
   success &= (sigaction(SIGABRT, &action, NULL) == 0);
   success &= (sigaction(SIGFPE, &action, NULL) == 0);
   success &= (sigaction(SIGBUS, &action, NULL) == 0);
   success &= (sigaction(SIGSEGV, &action, NULL) == 0);
   success &= (sigaction(SIGSYS, &action, NULL) == 0);
 
   return success;
 }
-#endif  // !defined(OS_IOS)
 
 StackTrace::StackTrace() {
   // 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.
 
   // Though the backtrace API man page does not list any possible negative
   // return values, we take no chance.
   count_ = std::max(backtrace(trace_, arraysize(trace_)), 0);
 }
 
@@ skipping 70 matching lines @@
     *ptr = *start;
     *start++ = ch;
   }
   return buf;
 }
 
 }  // namespace internal
 
 }  // namespace debug
 }  // namespace base