1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
// 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"
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;
std::string PrettyPrintChar(int ch) {
std::ostringstream oss;
switch (ch) {
#define CHAR_PRINT_CASE(ch) \
case ch: \
oss << #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)) {
oss << '\'' << ch << '\'';
} else {
oss << std::hex << "\\x" << static_cast<unsigned int>(ch);
}
}
return oss.str();
}
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 <> \
std::string PrintCheckOperand<type>(type ch) { \
return PrettyPrintChar(ch); \
} \
template <> \
std::string PrintCheckOperand<type*>(type * cstr) { \
return PrintCheckOperand<void*>(cstr); \
} \
template <> \
std::string PrintCheckOperand<const type*>(const type* cstr) { \
return PrintCheckOperand<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 std::string PrintCheckOperand<type>(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
} // 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);
}
|
