1f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Use of this source code is governed by a BSD-style license that can be 3f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// found in the LICENSE file. 4f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 5f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Slightly adapted for inclusion in V8. 6f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Copyright 2016 the V8 project authors. All rights reserved. 7f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 8f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include "src/base/debug/stack_trace.h" 9f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 10f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <errno.h> 11f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <fcntl.h> 12f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <signal.h> 13f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <stddef.h> 14f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <stdint.h> 15f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <stdio.h> 16f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <stdlib.h> 17f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <sys/param.h> 18f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <sys/stat.h> 19f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <sys/types.h> 20f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <unistd.h> 21f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 22f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <map> 23f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <memory> 24f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <ostream> 25f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <string> 26f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <vector> 27f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 28f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if V8_LIBC_GLIBC || V8_LIBC_BSD || V8_LIBC_UCLIBC || V8_OS_SOLARIS 29f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#define HAVE_EXECINFO_H 1 30f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif 31f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 32f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if HAVE_EXECINFO_H 33f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <cxxabi.h> 34f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <execinfo.h> 35f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif 36f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if V8_OS_MACOSX 37f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include <AvailabilityMacros.h> 38f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif 39f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 40f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include "src/base/build_config.h" 41f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include "src/base/free_deleter.h" 42f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include "src/base/logging.h" 43f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#include "src/base/macros.h" 44f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 45f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochnamespace v8 { 46f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochnamespace base { 47f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochnamespace debug { 48f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 49f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochnamespace internal { 50f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 51f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// POSIX doesn't define any async-signal safe function for converting 52f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// an integer to ASCII. We'll have to define our own version. 53f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// itoa_r() converts a (signed) integer to ASCII. It returns "buf", if the 54f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// conversion was successful or NULL otherwise. It never writes more than "sz" 55f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// bytes. Output will be truncated as needed, and a NUL character is always 56f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// appended. 57f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochchar* itoa_r(intptr_t i, char* buf, size_t sz, int base, size_t padding); 58f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 59f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} // namespace internal 60f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 61f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochnamespace { 62f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 63f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochvolatile sig_atomic_t in_signal_handler = 0; 64f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochbool dump_stack_in_signal_handler = 1; 65f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 66f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// The prefix used for mangled symbols, per the Itanium C++ ABI: 67f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// http://www.codesourcery.com/cxx-abi/abi.html#mangling 68f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochconst char kMangledSymbolPrefix[] = "_Z"; 69f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 70f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Characters that can be used for symbols, generated by Ruby: 71f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// (('a'..'z').to_a+('A'..'Z').to_a+('0'..'9').to_a + ['_']).join 72f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochconst char kSymbolCharacters[] = 73f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"; 74f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 75f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// Demangles C++ symbols in the given text. Example: 76f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// 77f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// "out/Debug/base_unittests(_ZN10StackTraceC1Ev+0x20) [0x817778c]" 78f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// => 79f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// "out/Debug/base_unittests(StackTrace::StackTrace()+0x20) [0x817778c]" 80f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochvoid DemangleSymbols(std::string* text) { 81f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Note: code in this function is NOT async-signal safe (std::string uses 82f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // malloc internally). 83f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 84f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if HAVE_EXECINFO_H 85f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 86f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::string::size_type search_from = 0; 87f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch while (search_from < text->size()) { 88f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Look for the start of a mangled symbol, from search_from. 89f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::string::size_type mangled_start = 90f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch text->find(kMangledSymbolPrefix, search_from); 91f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (mangled_start == std::string::npos) { 92f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch break; // Mangled symbol not found. 93f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 94f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 95f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Look for the end of the mangled symbol. 96f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::string::size_type mangled_end = 97f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch text->find_first_not_of(kSymbolCharacters, mangled_start); 98f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (mangled_end == std::string::npos) { 99f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch mangled_end = text->size(); 100f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 101f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::string mangled_symbol = 102f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch text->substr(mangled_start, mangled_end - mangled_start); 103f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 104f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Try to demangle the mangled symbol candidate. 105f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch int status = 0; 106f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::unique_ptr<char, FreeDeleter> demangled_symbol( 107f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch abi::__cxa_demangle(mangled_symbol.c_str(), NULL, 0, &status)); 108f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (status == 0) { // Demangling is successful. 109f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Remove the mangled symbol. 110f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch text->erase(mangled_start, mangled_end - mangled_start); 111f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Insert the demangled symbol. 112f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch text->insert(mangled_start, demangled_symbol.get()); 113f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Next time, we'll start right after the demangled symbol we inserted. 114f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch search_from = mangled_start + strlen(demangled_symbol.get()); 115f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else { 116f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Failed to demangle. Retry after the "_Z" we just found. 117f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch search_from = mangled_start + 2; 118f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 119f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 120f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 121f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // HAVE_EXECINFO_H 122f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 123f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 124f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass BacktraceOutputHandler { 125f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 126f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual void HandleOutput(const char* output) = 0; 127f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 128f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch protected: 129f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch virtual ~BacktraceOutputHandler() {} 130f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 131f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 132f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochvoid OutputPointer(void* pointer, BacktraceOutputHandler* handler) { 133f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This should be more than enough to store a 64-bit number in hex: 134f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 16 hex digits + 1 for null-terminator. 135f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch char buf[17] = {'\0'}; 136f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch handler->HandleOutput("0x"); 137f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::itoa_r(reinterpret_cast<intptr_t>(pointer), buf, sizeof(buf), 16, 138f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 12); 139f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch handler->HandleOutput(buf); 140f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 141f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 142f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if HAVE_EXECINFO_H 143f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochvoid ProcessBacktrace(void* const* trace, size_t size, 144f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch BacktraceOutputHandler* handler) { 145f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // NOTE: This code MUST be async-signal safe (it's used by in-process 146f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // stack dumping signal handler). NO malloc or stdio is allowed here. 147f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch handler->HandleOutput("\n"); 148f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch handler->HandleOutput("==== C stack trace ===============================\n"); 149f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch handler->HandleOutput("\n"); 150f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 151f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool printed = false; 152f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 153f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Below part is async-signal unsafe (uses malloc), so execute it only 154f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // when we are not executing the signal handler. 155f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (in_signal_handler == 0) { 156f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::unique_ptr<char*, FreeDeleter> trace_symbols( 157f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch backtrace_symbols(trace, static_cast<int>(size))); 158f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (trace_symbols.get()) { 159f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (size_t i = 0; i < size; ++i) { 160f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::string trace_symbol = trace_symbols.get()[i]; 161f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DemangleSymbols(&trace_symbol); 162f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch handler->HandleOutput(" "); 163f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch handler->HandleOutput(trace_symbol.c_str()); 164f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch handler->HandleOutput("\n"); 165f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 166f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 167f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch printed = true; 168f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 169f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 170f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 171f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (!printed) { 172f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch for (size_t i = 0; i < size; ++i) { 173f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch handler->HandleOutput(" ["); 174f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch OutputPointer(trace[i], handler); 175f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch handler->HandleOutput("]\n"); 176f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 177f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 178f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 179f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif // HAVE_EXECINFO_H 180f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 181f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochvoid PrintToStderr(const char* output) { 182f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // NOTE: This code MUST be async-signal safe (it's used by in-process 183f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // stack dumping signal handler). NO malloc or stdio is allowed here. 184f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ssize_t return_val = write(STDERR_FILENO, output, strlen(output)); 185f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch USE(return_val); 186f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 187f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 188f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochvoid StackDumpSignalHandler(int signal, siginfo_t* info, void* void_context) { 189f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // NOTE: This code MUST be async-signal safe. 190f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // NO malloc or stdio is allowed here. 191f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 192f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Record the fact that we are in the signal handler now, so that the rest 193f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // of StackTrace can behave in an async-signal-safe manner. 194f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch in_signal_handler = 1; 195f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 196f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr("Received signal "); 197f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch char buf[1024] = {0}; 198f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::itoa_r(signal, buf, sizeof(buf), 10, 0); 199f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(buf); 200f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (signal == SIGBUS) { 201f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (info->si_code == BUS_ADRALN) 202f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" BUS_ADRALN "); 203f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else if (info->si_code == BUS_ADRERR) 204f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" BUS_ADRERR "); 205f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else if (info->si_code == BUS_OBJERR) 206f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" BUS_OBJERR "); 207f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else 208f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" <unknown> "); 209f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else if (signal == SIGFPE) { 210f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (info->si_code == FPE_FLTDIV) 211f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" FPE_FLTDIV "); 212f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else if (info->si_code == FPE_FLTINV) 213f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" FPE_FLTINV "); 214f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else if (info->si_code == FPE_FLTOVF) 215f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" FPE_FLTOVF "); 216f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else if (info->si_code == FPE_FLTRES) 217f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" FPE_FLTRES "); 218f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else if (info->si_code == FPE_FLTSUB) 219f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" FPE_FLTSUB "); 220f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else if (info->si_code == FPE_FLTUND) 221f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" FPE_FLTUND "); 222f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else if (info->si_code == FPE_INTDIV) 223f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" FPE_INTDIV "); 224f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else if (info->si_code == FPE_INTOVF) 225f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" FPE_INTOVF "); 226f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else 227f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" <unknown> "); 228f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else if (signal == SIGILL) { 229f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (info->si_code == ILL_BADSTK) 230f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" ILL_BADSTK "); 231f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else if (info->si_code == ILL_COPROC) 232f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" ILL_COPROC "); 233f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else if (info->si_code == ILL_ILLOPN) 234f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" ILL_ILLOPN "); 235f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else if (info->si_code == ILL_ILLADR) 236f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" ILL_ILLADR "); 237f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else if (info->si_code == ILL_ILLTRP) 238f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" ILL_ILLTRP "); 239f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else if (info->si_code == ILL_PRVOPC) 240f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" ILL_PRVOPC "); 241f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else if (info->si_code == ILL_PRVREG) 242f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" ILL_PRVREG "); 243f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else 244f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" <unknown> "); 245f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } else if (signal == SIGSEGV) { 246f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (info->si_code == SEGV_MAPERR) 247f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" SEGV_MAPERR "); 248f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else if (info->si_code == SEGV_ACCERR) 249f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" SEGV_ACCERR "); 250f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch else 251f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(" <unknown> "); 252f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 253f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (signal == SIGBUS || signal == SIGFPE || signal == SIGILL || 254f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch signal == SIGSEGV) { 255f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch internal::itoa_r(reinterpret_cast<intptr_t>(info->si_addr), buf, 256f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch sizeof(buf), 16, 12); 257f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(buf); 258f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 259f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr("\n"); 260f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (dump_stack_in_signal_handler) { 261f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch debug::StackTrace().Print(); 262f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr("[end of stack trace]\n"); 263f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 264f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 265f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (::signal(signal, SIG_DFL) == SIG_ERR) _exit(1); 266f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 267f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 268f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass PrintBacktraceOutputHandler : public BacktraceOutputHandler { 269f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 270f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintBacktraceOutputHandler() {} 271f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 272f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void HandleOutput(const char* output) override { 273f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // NOTE: This code MUST be async-signal safe (it's used by in-process 274f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // stack dumping signal handler). NO malloc or stdio is allowed here. 275f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintToStderr(output); 276f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 277f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 278f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 279f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DISALLOW_COPY_AND_ASSIGN(PrintBacktraceOutputHandler); 280f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 281f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 282f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochclass StreamBacktraceOutputHandler : public BacktraceOutputHandler { 283f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch public: 284f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch explicit StreamBacktraceOutputHandler(std::ostream* os) : os_(os) {} 285f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 286f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch void HandleOutput(const char* output) override { (*os_) << output; } 287f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 288f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch private: 289f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch std::ostream* os_; 290f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 291f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch DISALLOW_COPY_AND_ASSIGN(StreamBacktraceOutputHandler); 292f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch}; 293f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 294f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochvoid WarmUpBacktrace() { 295f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Warm up stack trace infrastructure. It turns out that on the first 296f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // call glibc initializes some internal data structures using pthread_once, 297f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // and even backtrace() can call malloc(), leading to hangs. 298f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 299f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Example stack trace snippet (with tcmalloc): 300f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // 301f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // #8 0x0000000000a173b5 in tc_malloc 302f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // at ./third_party/tcmalloc/chromium/src/debugallocation.cc:1161 303f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // #9 0x00007ffff7de7900 in _dl_map_object_deps at dl-deps.c:517 304f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // #10 0x00007ffff7ded8a9 in dl_open_worker at dl-open.c:262 305f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // #11 0x00007ffff7de9176 in _dl_catch_error at dl-error.c:178 306f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // #12 0x00007ffff7ded31a in _dl_open (file=0x7ffff625e298 "libgcc_s.so.1") 307f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // at dl-open.c:639 308f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // #13 0x00007ffff6215602 in do_dlopen at dl-libc.c:89 309f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // #14 0x00007ffff7de9176 in _dl_catch_error at dl-error.c:178 310f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // #15 0x00007ffff62156c4 in dlerror_run at dl-libc.c:48 311f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // #16 __GI___libc_dlopen_mode at dl-libc.c:165 312f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // #17 0x00007ffff61ef8f5 in init 313f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // at ../sysdeps/x86_64/../ia64/backtrace.c:53 314f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // #18 0x00007ffff6aad400 in pthread_once 315f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // at ../nptl/sysdeps/unix/sysv/linux/x86_64/pthread_once.S:104 316f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // #19 0x00007ffff61efa14 in __GI___backtrace 317f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // at ../sysdeps/x86_64/../ia64/backtrace.c:104 318f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // #20 0x0000000000752a54 in base::debug::StackTrace::StackTrace 319f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // at base/debug/stack_trace_posix.cc:175 320f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // #21 0x00000000007a4ae5 in 321f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // base::(anonymous namespace)::StackDumpSignalHandler 322f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // at base/process_util_posix.cc:172 323f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // #22 <signal handler called> 324f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StackTrace stack_trace; 325f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 326f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 327f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} // namespace 328f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 329f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochbool EnableInProcessStackDumping() { 330f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // When running in an application, our code typically expects SIGPIPE 331f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // to be ignored. Therefore, when testing that same code, it should run 332f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // with SIGPIPE ignored as well. 333f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch struct sigaction sigpipe_action; 334f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch memset(&sigpipe_action, 0, sizeof(sigpipe_action)); 335f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch sigpipe_action.sa_handler = SIG_IGN; 336f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch sigemptyset(&sigpipe_action.sa_mask); 337f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch bool success = (sigaction(SIGPIPE, &sigpipe_action, NULL) == 0); 338f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 339f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Avoid hangs during backtrace initialization, see above. 340f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch WarmUpBacktrace(); 341f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 342f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch struct sigaction action; 343f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch memset(&action, 0, sizeof(action)); 344f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch action.sa_flags = SA_RESETHAND | SA_SIGINFO; 345f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch action.sa_sigaction = &StackDumpSignalHandler; 346f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch sigemptyset(&action.sa_mask); 347f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 348f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch success &= (sigaction(SIGILL, &action, NULL) == 0); 349f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch success &= (sigaction(SIGABRT, &action, NULL) == 0); 350f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch success &= (sigaction(SIGFPE, &action, NULL) == 0); 351f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch success &= (sigaction(SIGBUS, &action, NULL) == 0); 352f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch success &= (sigaction(SIGSEGV, &action, NULL) == 0); 353f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch success &= (sigaction(SIGSYS, &action, NULL) == 0); 354f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 355f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch dump_stack_in_signal_handler = true; 356f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 357f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return success; 358f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 359f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 360f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochvoid DisableSignalStackDump() { 361f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch dump_stack_in_signal_handler = false; 362f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 363f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 364f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen MurdochStackTrace::StackTrace() { 365f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // NOTE: This code MUST be async-signal safe (it's used by in-process 366f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // stack dumping signal handler). NO malloc or stdio is allowed here. 367f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 368f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if HAVE_EXECINFO_H 369f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Though the backtrace API man page does not list any possible negative 370f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // return values, we take no chance. 371f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch count_ = static_cast<size_t>(backtrace(trace_, arraysize(trace_))); 372f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#else 373f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch count_ = 0; 374f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif 375f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 376f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 377f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochvoid StackTrace::Print() const { 378f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // NOTE: This code MUST be async-signal safe (it's used by in-process 379f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // stack dumping signal handler). NO malloc or stdio is allowed here. 380f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 381f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if HAVE_EXECINFO_H 382f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch PrintBacktraceOutputHandler handler; 383f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ProcessBacktrace(trace_, count_, &handler); 384f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif 385f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 386f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 387f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochvoid StackTrace::OutputToStream(std::ostream* os) const { 388f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#if HAVE_EXECINFO_H 389f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch StreamBacktraceOutputHandler handler(os); 390f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch ProcessBacktrace(trace_, count_, &handler); 391f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch#endif 392f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 393f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 394f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochnamespace internal { 395f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 396f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch// NOTE: code from sandbox/linux/seccomp-bpf/demo.cc. 397f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdochchar* itoa_r(intptr_t i, char* buf, size_t sz, int base, size_t padding) { 398f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Make sure we can write at least one NUL byte. 399f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch size_t n = 1; 400f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (n > sz) return NULL; 401f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 402f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (base < 2 || base > 16) { 403f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch buf[0] = '\000'; 404f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return NULL; 405f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 406f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 407f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch char* start = buf; 408f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 409f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch uintptr_t j = i; 410f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 411f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Handle negative numbers (only for base 10). 412f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (i < 0 && base == 10) { 413f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // This does "j = -i" while avoiding integer overflow. 414f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch j = static_cast<uintptr_t>(-(i + 1)) + 1; 415f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 416f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Make sure we can write the '-' character. 417f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (++n > sz) { 418f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch buf[0] = '\000'; 419f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return NULL; 420f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 421f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *start++ = '-'; 422f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 423f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 424f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Loop until we have converted the entire number. Output at least one 425f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // character (i.e. '0'). 426f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch char* ptr = start; 427f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch do { 428f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Make sure there is still enough space left in our output buffer. 429f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (++n > sz) { 430f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch buf[0] = '\000'; 431f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return NULL; 432f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 433f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 434f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Output the next digit. 435f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *ptr++ = "0123456789abcdef"[j % base]; 436f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch j /= base; 437f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 438f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch if (padding > 0) padding--; 439f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } while (j > 0 || padding > 0); 440f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 441f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Terminate the output with a NUL character. 442f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *ptr = '\000'; 443f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 444f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // Conversion to ASCII actually resulted in the digits being in reverse 445f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // order. We can't easily generate them in forward order, as we can't tell 446f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // the number of characters needed until we are done converting. 447f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch // So, now, we reverse the string (except for the possible "-" sign). 448f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch while (--ptr > start) { 449f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch char ch = *ptr; 450f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *ptr = *start; 451f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch *start++ = ch; 452f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch } 453f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch return buf; 454f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} 455f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 456f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} // namespace internal 457f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch 458f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} // namespace debug 459f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} // namespace base 460f91f0611dbaf29ca0f1d4aecb357ce243a19d2faBen Murdoch} // namespace v8 461