blob: c7ffdaa15df0a2fefe1b1c7e76212c3cb8967d5c [file] [log] [blame]
// Copyright 2006-2008 the V8 project 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 "src/base/logging.h"
#include <cctype>
#include <cstdarg>
#include <cstdio>
#include <cstdlib>
#include "src/base/debug/stack_trace.h"
#include "src/base/platform/platform.h"
#if defined(V8_OS_STARBOARD)
#include "src/poems.h"
#endif
namespace v8 {
namespace base {
namespace {
void DefaultDcheckHandler(const char* file, int line, const char* message);
void (*g_print_stack_trace)() = nullptr;
void (*g_dcheck_function)(const char*, int, const char*) = DefaultDcheckHandler;
void PrettyPrintChar(std::ostream& os, int ch) {
switch (ch) {
#define CHAR_PRINT_CASE(ch) \
case ch: \
os << #ch; \
break;
CHAR_PRINT_CASE('\0')
CHAR_PRINT_CASE('\'')
CHAR_PRINT_CASE('\\')
CHAR_PRINT_CASE('\a')
CHAR_PRINT_CASE('\b')
CHAR_PRINT_CASE('\f')
CHAR_PRINT_CASE('\n')
CHAR_PRINT_CASE('\r')
CHAR_PRINT_CASE('\t')
CHAR_PRINT_CASE('\v')
#undef CHAR_PRINT_CASE
default:
if (std::isprint(ch)) {
os << '\'' << ch << '\'';
} else {
auto flags = os.flags(std::ios_base::hex);
os << "\\x" << static_cast<unsigned int>(ch);
os.flags(flags);
}
}
}
void DefaultDcheckHandler(const char* file, int line, const char* message) {
#ifdef DEBUG
V8_Fatal(file, line, "Debug check failed: %s.", message);
#else
// This case happens only for unit tests.
V8_Fatal("Debug check failed: %s.", message);
#endif
}
} // namespace
void SetPrintStackTrace(void (*print_stack_trace)()) {
g_print_stack_trace = print_stack_trace;
}
void SetDcheckFunction(void (*dcheck_function)(const char*, int, const char*)) {
g_dcheck_function = dcheck_function ? dcheck_function : &DefaultDcheckHandler;
}
// Define specialization to pretty print characters (escaping non-printable
// characters) and to print c strings as pointers instead of strings.
#define DEFINE_PRINT_CHECK_OPERAND_CHAR(type) \
template <> \
void PrintCheckOperand<type>(std::ostream & os, type ch) { \
PrettyPrintChar(os, ch); \
} \
template <> \
void PrintCheckOperand<type*>(std::ostream & os, type * cstr) { \
os << static_cast<void*>(cstr); \
} \
template <> \
void PrintCheckOperand<const type*>(std::ostream & os, const type* cstr) { \
os << static_cast<const void*>(cstr); \
}
DEFINE_PRINT_CHECK_OPERAND_CHAR(char)
DEFINE_PRINT_CHECK_OPERAND_CHAR(signed char)
DEFINE_PRINT_CHECK_OPERAND_CHAR(unsigned char)
#undef DEFINE_PRINT_CHECK_OPERAND_CHAR
// Explicit instantiations for commonly used comparisons.
#define DEFINE_MAKE_CHECK_OP_STRING(type) \
template std::string* MakeCheckOpString<type, type>(type, type, \
char const*); \
template void PrintCheckOperand<type>(std::ostream&, type);
DEFINE_MAKE_CHECK_OP_STRING(int)
DEFINE_MAKE_CHECK_OP_STRING(long) // NOLINT(runtime/int)
DEFINE_MAKE_CHECK_OP_STRING(long long) // NOLINT(runtime/int)
DEFINE_MAKE_CHECK_OP_STRING(unsigned int)
DEFINE_MAKE_CHECK_OP_STRING(unsigned long) // NOLINT(runtime/int)
DEFINE_MAKE_CHECK_OP_STRING(unsigned long long) // NOLINT(runtime/int)
DEFINE_MAKE_CHECK_OP_STRING(void const*)
#undef DEFINE_MAKE_CHECK_OP_STRING
// Explicit instantiations for floating point checks.
#define DEFINE_CHECK_OP_IMPL(NAME) \
template std::string* Check##NAME##Impl<float, float>(float lhs, float rhs, \
char const* msg); \
template std::string* Check##NAME##Impl<double, double>( \
double lhs, double rhs, char const* msg);
DEFINE_CHECK_OP_IMPL(EQ)
DEFINE_CHECK_OP_IMPL(NE)
DEFINE_CHECK_OP_IMPL(LE)
DEFINE_CHECK_OP_IMPL(LT)
DEFINE_CHECK_OP_IMPL(GE)
DEFINE_CHECK_OP_IMPL(GT)
#undef DEFINE_CHECK_OP_IMPL
} // namespace base
} // namespace v8
namespace {
// FailureMessage is a stack allocated object which has a special marker field
// at the start and at the end. This makes it possible to retrieve the embedded
// message from the stack.
//
class FailureMessage {
public:
explicit FailureMessage(const char* format, va_list arguments) {
memset(&message_, 0, arraysize(message_));
v8::base::OS::VSNPrintF(&message_[0], arraysize(message_), format,
arguments);
}
static const uintptr_t kStartMarker = 0xdecade10;
static const uintptr_t kEndMarker = 0xdecade11;
static const int kMessageBufferSize = 512;
uintptr_t start_marker_ = kStartMarker;
char message_[kMessageBufferSize];
uintptr_t end_marker_ = kEndMarker;
};
} // namespace
#ifdef DEBUG
void V8_Fatal(const char* file, int line, const char* format, ...) {
#else
void V8_Fatal(const char* format, ...) {
const char* file = "";
int line = 0;
#endif
va_list arguments;
va_start(arguments, format);
// Format the error message into a stack object for later retrieveal by the
// crash processor.
FailureMessage message(format, arguments);
va_end(arguments);
fflush(stdout);
fflush(stderr);
// Print the formatted message to stdout without cropping the output.
v8::base::OS::PrintError("\n\n#\n# Fatal error in %s, line %d\n# ", file,
line);
// Print the error message.
va_start(arguments, format);
v8::base::OS::VPrintError(format, arguments);
va_end(arguments);
// Print the message object's address to force stack allocation.
v8::base::OS::PrintError("\n#\n#\n#\n#FailureMessage Object: %p", &message);
if (v8::base::g_print_stack_trace) v8::base::g_print_stack_trace();
fflush(stderr);
v8::base::OS::Abort();
}
#if !defined(DEBUG) && defined(OFFICIAL_BUILD)
void V8_FatalNoContext() {
v8::base::OS::PrintError("V8 CHECK or FATAL\n");
if (v8::base::g_print_stack_trace) v8::base::g_print_stack_trace();
fflush(stderr);
v8::base::OS::Abort();
}
#endif
void V8_Dcheck(const char* file, int line, const char* message) {
v8::base::g_dcheck_function(file, line, message);
}