AIX: Disable backtrace API call

src/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.
 
 // Slightly adapted for inclusion in V8.
 // Copyright 2016 the V8 project authors. All rights reserved.
 
 #include "src/base/debug/stack_trace.h"
 
 #include <errno.h>
@@ skipping 127 matching lines @@
 void ProcessBacktrace(void* const* trace, size_t 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.
   handler->HandleOutput("\n");
   handler->HandleOutput("==== C stack trace ===============================\n");
   handler->HandleOutput("\n");
 
   bool printed = false;
 
+// NOTE: backtrace_symbol API is not supported on AIX and there is no
+// equivalent user-mode API. For now disabling the call to the API

[rmcilroy, 2016/09/08 10:10:10]

No need for the comment (there are probably other platforms in a similar
situation and this comment will get stale when #ifdefing out other platforms).

+#if !V8_OS_AIX

[rmcilroy, 2016/09/08 10:10:10]

Could you instead ifdef out the whole of ProcessBacktrace and the calls to it
(similarly to how __ulibc__ is treated in the chromium version of the file:
https://cs.chromium.org/chromium/src/base/debug/stack_trace_posix.cc?type=cs&...

   // 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) {
     std::unique_ptr<char*, FreeDeleter> trace_symbols(
         backtrace_symbols(trace, static_cast<int>(size)));
     if (trace_symbols.get()) {
       for (size_t i = 0; i < size; ++i) {
         std::string trace_symbol = trace_symbols.get()[i];
         DemangleSymbols(&trace_symbol);
         handler->HandleOutput("    ");
         handler->HandleOutput(trace_symbol.c_str());
         handler->HandleOutput("\n");
       }
 
       printed = true;
     }
   }
+#endif
 
   if (!printed) {
     for (size_t i = 0; i < size; ++i) {
       handler->HandleOutput(" [");
       OutputPointer(trace[i], handler);
       handler->HandleOutput("]\n");
     }
   }
 }
 
@@ skipping 174 matching lines @@
   dump_stack_in_signal_handler = true;
 
   return success;
 }
 
 void DisableSignalStackDump() {
   dump_stack_in_signal_handler = false;
 }
 
 StackTrace::StackTrace() {
+// NOTE: backtrace API is not supported on AIX and there is no
+// equivalent user-mode API. For now disabling the call to the API

[rmcilroy, 2016/09/08 10:10:10]

No need for the comment

+#if V8_OS_AIX

[rmcilroy, 2016/09/08 10:10:10]

Could you make this #if !V8_OS_AIX and swap the branches around.

+  count_ = 0;
+#else
   // 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_ = static_cast<size_t>(backtrace(trace_, arraysize(trace_)));
+#endif
 }
 
 void StackTrace::Print() const {
   // 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.
 
   PrintBacktraceOutputHandler handler;
   ProcessBacktrace(trace_, count_, &handler);
 }
 
@@ skipping 62 matching lines @@
     *start++ = ch;
   }
   return buf;
 }
 
 }  // namespace internal
 
 }  // namespace debug
 }  // namespace base
 }  // namespace v8