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();
@@ skipping 130 matching lines @@
     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)
-  // TODO(shess): Port to 64-bit.
+  // TODO(shess): Port to 64-bit, and ARM architecture (32 and 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),
                "ax: %x, bx: %x, cx: %x, dx: %x\n",
@@ skipping 21 matching lines @@
                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)
   _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