ios: Enable -Wunused-functions.

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 172 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));
@@ skipping 103 matching lines @@
     *ptr = *start;
     *start++ = ch;
   }
   return buf;
 }
 
 }  // namespace internal
 
 }  // namespace debug
 }  // namespace base