1 // Copyright 2012 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifndef V8_BASE_LOGGING_H_
6 #define V8_BASE_LOGGING_H_
7
8 #include <cstring>
9 #include <sstream>
10 #include <string>
11
12 #include "src/base/base-export.h"
13 #include "src/base/build_config.h"
14 #include "src/base/compiler-specific.h"
15 #include "src/base/template-utils.h"
16
17 [[noreturn]] PRINTF_FORMAT(3, 4) V8_BASE_EXPORT V8_NOINLINE
18 void V8_Fatal(const char* file, int line, const char* format, ...);
19
20 V8_BASE_EXPORT V8_NOINLINE void V8_Dcheck(const char* file, int line,
21 const char* message);
22
23 #ifdef DEBUG
24 #define FATAL(...) V8_Fatal(__FILE__, __LINE__, __VA_ARGS__)
25 #else
26 #define FATAL(...) V8_Fatal("", 0, __VA_ARGS__)
27 #endif
28 #define UNIMPLEMENTED() FATAL("unimplemented code")
29 #define UNREACHABLE() FATAL("unreachable code")
30
31 namespace v8 {
32 namespace base {
33
34 // Overwrite the default function that prints a stack trace.
35 V8_BASE_EXPORT void SetPrintStackTrace(void (*print_stack_trace_)());
36
37 // Override the default function that handles DCHECKs.
38 V8_BASE_EXPORT void SetDcheckFunction(void (*dcheck_Function)(const char*, int,
39 const char*));
40
41 // CHECK dies with a fatal error if condition is not true. It is *not*
42 // controlled by DEBUG, so the check will be executed regardless of
43 // compilation mode.
44 //
45 // We make sure CHECK et al. always evaluates their arguments, as
46 // doing CHECK(FunctionWithSideEffect()) is a common idiom.
47 #define CHECK_WITH_MSG(condition, message) \
48 do { \
49 if (V8_UNLIKELY(!(condition))) { \
50 FATAL("Check failed: %s.", message); \
51 } \
52 } while (0)
53 #define CHECK(condition) CHECK_WITH_MSG(condition, #condition)
54
55 #ifdef DEBUG
56
57 #define DCHECK_WITH_MSG(condition, message) \
58 do { \
59 if (V8_UNLIKELY(!(condition))) { \
60 V8_Dcheck(__FILE__, __LINE__, message); \
61 } \
62 } while (0)
63 #define DCHECK(condition) DCHECK_WITH_MSG(condition, #condition)
64
65 // Helper macro for binary operators.
66 // Don't use this macro directly in your code, use CHECK_EQ et al below.
67 #define CHECK_OP(name, op, lhs, rhs) \
68 do { \
69 if (std::string* _msg = ::v8::base::Check##name##Impl< \
70 typename ::v8::base::pass_value_or_ref<decltype(lhs)>::type, \
71 typename ::v8::base::pass_value_or_ref<decltype(rhs)>::type>( \
72 (lhs), (rhs), #lhs " " #op " " #rhs)) { \
73 FATAL("Check failed: %s.", _msg->c_str()); \
74 delete _msg; \
75 } \
76 } while (0)
77
78 #define DCHECK_OP(name, op, lhs, rhs) \
79 do { \
80 if (std::string* _msg = ::v8::base::Check##name##Impl< \
81 typename ::v8::base::pass_value_or_ref<decltype(lhs)>::type, \
82 typename ::v8::base::pass_value_or_ref<decltype(rhs)>::type>( \
83 (lhs), (rhs), #lhs " " #op " " #rhs)) { \
84 V8_Dcheck(__FILE__, __LINE__, _msg->c_str()); \
85 delete _msg; \
86 } \
87 } while (0)
88
89 #else
90
91 // Make all CHECK functions discard their log strings to reduce code
92 // bloat for official release builds.
93
94 #define CHECK_OP(name, op, lhs, rhs) \
95 do { \
96 bool _cmp = ::v8::base::Cmp##name##Impl< \
97 typename ::v8::base::pass_value_or_ref<decltype(lhs)>::type, \
98 typename ::v8::base::pass_value_or_ref<decltype(rhs)>::type>((lhs), \
99 (rhs)); \
100 CHECK_WITH_MSG(_cmp, #lhs " " #op " " #rhs); \
101 } while (0)
102
103 #define DCHECK_WITH_MSG(condition, msg) void(0);
104
105 #endif
106
107 // Define PrintCheckOperand<T> for each T which defines operator<< for ostream.
108 template <typename T>
109 typename std::enable_if<
110 !std::is_function<typename std::remove_pointer<T>::type>::value &&
111 has_output_operator<T>::value>::type
PrintCheckOperand(std::ostream & os,T val)112 PrintCheckOperand(std::ostream& os, T val) {
113 os << std::forward<T>(val);
114 }
115
116 // Provide an overload for functions and function pointers. Function pointers
117 // don't implicitly convert to void* but do implicitly convert to bool, so
118 // without this function pointers are always printed as 1 or 0. (MSVC isn't
119 // standards-conforming here and converts function pointers to regular
120 // pointers, so this is a no-op for MSVC.)
121 template <typename T>
122 typename std::enable_if<
123 std::is_function<typename std::remove_pointer<T>::type>::value>::type
PrintCheckOperand(std::ostream & os,T val)124 PrintCheckOperand(std::ostream& os, T val) {
125 os << reinterpret_cast<const void*>(val);
126 }
127
128 // Define PrintCheckOperand<T> for enums which have no operator<<.
129 template <typename T>
130 typename std::enable_if<std::is_enum<T>::value &&
131 !has_output_operator<T>::value>::type
PrintCheckOperand(std::ostream & os,T val)132 PrintCheckOperand(std::ostream& os, T val) {
133 using underlying_t = typename std::underlying_type<T>::type;
134 // 8-bit types are not printed as number, so extend them to 16 bit.
135 using int_t = typename std::conditional<
136 std::is_same<underlying_t, uint8_t>::value, uint16_t,
137 typename std::conditional<std::is_same<underlying_t, int8_t>::value,
138 int16_t, underlying_t>::type>::type;
139 PrintCheckOperand(os, static_cast<int_t>(static_cast<underlying_t>(val)));
140 }
141
142 // Define default PrintCheckOperand<T> for non-printable types.
143 template <typename T>
144 typename std::enable_if<!has_output_operator<T>::value &&
145 !std::is_enum<T>::value>::type
PrintCheckOperand(std::ostream & os,T val)146 PrintCheckOperand(std::ostream& os, T val) {
147 os << "<unprintable>";
148 }
149
150 // Define specializations for character types, defined in logging.cc.
151 #define DEFINE_PRINT_CHECK_OPERAND_CHAR(type) \
152 template <> \
153 V8_BASE_EXPORT void PrintCheckOperand<type>(std::ostream & os, type ch); \
154 template <> \
155 V8_BASE_EXPORT void PrintCheckOperand<type*>(std::ostream & os, \
156 type * cstr); \
157 template <> \
158 V8_BASE_EXPORT void PrintCheckOperand<const type*>(std::ostream & os, \
159 const type* cstr);
160
161 DEFINE_PRINT_CHECK_OPERAND_CHAR(char)
DEFINE_PRINT_CHECK_OPERAND_CHAR(signed char)162 DEFINE_PRINT_CHECK_OPERAND_CHAR(signed char)
163 DEFINE_PRINT_CHECK_OPERAND_CHAR(unsigned char)
164 #undef DEFINE_PRINT_CHECK_OPERAND_CHAR
165
166 // Build the error message string. This is separate from the "Impl"
167 // function template because it is not performance critical and so can
168 // be out of line, while the "Impl" code should be inline. Caller
169 // takes ownership of the returned string.
170 template <typename Lhs, typename Rhs>
171 std::string* MakeCheckOpString(Lhs lhs, Rhs rhs, char const* msg) {
172 std::ostringstream ss;
173 ss << msg << " (";
174 PrintCheckOperand<Lhs>(ss, lhs);
175 ss << " vs. ";
176 PrintCheckOperand<Rhs>(ss, rhs);
177 ss << ")";
178 return new std::string(ss.str());
179 }
180
181 // Commonly used instantiations of MakeCheckOpString<>. Explicitly instantiated
182 // in logging.cc.
183 #define EXPLICIT_CHECK_OP_INSTANTIATION(type) \
184 extern template V8_BASE_EXPORT std::string* MakeCheckOpString<type, type>( \
185 type, type, char const*); \
186 extern template V8_BASE_EXPORT void PrintCheckOperand<type>(std::ostream&, \
187 type);
188
189 EXPLICIT_CHECK_OP_INSTANTIATION(int)
190 EXPLICIT_CHECK_OP_INSTANTIATION(long) // NOLINT(runtime/int)
191 EXPLICIT_CHECK_OP_INSTANTIATION(long long) // NOLINT(runtime/int)
192 EXPLICIT_CHECK_OP_INSTANTIATION(unsigned int)
193 EXPLICIT_CHECK_OP_INSTANTIATION(unsigned long) // NOLINT(runtime/int)
194 EXPLICIT_CHECK_OP_INSTANTIATION(unsigned long long) // NOLINT(runtime/int)
195 EXPLICIT_CHECK_OP_INSTANTIATION(void const*)
196 #undef EXPLICIT_CHECK_OP_INSTANTIATION
197
198 // comparison_underlying_type provides the underlying integral type of an enum,
199 // or std::decay<T>::type if T is not an enum. Booleans are converted to
200 // "unsigned int", to allow "unsigned int == bool" comparisons.
201 template <typename T>
202 struct comparison_underlying_type {
203 // std::underlying_type must only be used with enum types, thus use this
204 // {Dummy} type if the given type is not an enum.
205 enum Dummy {};
206 using decay = typename std::decay<T>::type;
207 static constexpr bool is_enum = std::is_enum<decay>::value;
208 using underlying = typename std::underlying_type<
209 typename std::conditional<is_enum, decay, Dummy>::type>::type;
210 using type_or_bool =
211 typename std::conditional<is_enum, underlying, decay>::type;
212 using type =
213 typename std::conditional<std::is_same<type_or_bool, bool>::value,
214 unsigned int, type_or_bool>::type;
215 };
216 // Cast a value to its underlying type
217 #define MAKE_UNDERLYING(Type, value) \
218 static_cast<typename comparison_underlying_type<Type>::type>(value)
219
220 // is_signed_vs_unsigned::value is true if both types are integral, Lhs is
221 // signed, and Rhs is unsigned. False in all other cases.
222 template <typename Lhs, typename Rhs>
223 struct is_signed_vs_unsigned {
224 using lhs_underlying = typename comparison_underlying_type<Lhs>::type;
225 using rhs_underlying = typename comparison_underlying_type<Rhs>::type;
226 static constexpr bool value = std::is_integral<lhs_underlying>::value &&
227 std::is_integral<rhs_underlying>::value &&
228 std::is_signed<lhs_underlying>::value &&
229 std::is_unsigned<rhs_underlying>::value;
230 };
231 // Same thing, other way around: Lhs is unsigned, Rhs signed.
232 template <typename Lhs, typename Rhs>
233 struct is_unsigned_vs_signed : public is_signed_vs_unsigned<Rhs, Lhs> {};
234
235 // Specialize the compare functions for signed vs. unsigned comparisons.
236 // std::enable_if ensures that this template is only instantiable if both Lhs
237 // and Rhs are integral types, and their signedness does not match.
238 #define MAKE_UNSIGNED(Type, value) \
239 static_cast<typename std::make_unsigned< \
240 typename comparison_underlying_type<Type>::type>::type>(value)
241 #define DEFINE_SIGNED_MISMATCH_COMP(CHECK, NAME, IMPL) \
242 template <typename Lhs, typename Rhs> \
243 V8_INLINE typename std::enable_if<CHECK<Lhs, Rhs>::value, bool>::type \
244 Cmp##NAME##Impl(Lhs lhs, Rhs rhs) { \
245 return IMPL; \
246 }
247 DEFINE_SIGNED_MISMATCH_COMP(is_signed_vs_unsigned, EQ,
248 lhs >= 0 && MAKE_UNSIGNED(Lhs, lhs) ==
249 MAKE_UNDERLYING(Rhs, rhs))
250 DEFINE_SIGNED_MISMATCH_COMP(is_signed_vs_unsigned, LT,
251 lhs < 0 || MAKE_UNSIGNED(Lhs, lhs) <
252 MAKE_UNDERLYING(Rhs, rhs))
253 DEFINE_SIGNED_MISMATCH_COMP(is_signed_vs_unsigned, LE,
254 lhs <= 0 || MAKE_UNSIGNED(Lhs, lhs) <=
255 MAKE_UNDERLYING(Rhs, rhs))
256 DEFINE_SIGNED_MISMATCH_COMP(is_signed_vs_unsigned, NE, !CmpEQImpl(lhs, rhs))
257 DEFINE_SIGNED_MISMATCH_COMP(is_signed_vs_unsigned, GT, !CmpLEImpl(lhs, rhs))
258 DEFINE_SIGNED_MISMATCH_COMP(is_signed_vs_unsigned, GE, !CmpLTImpl(lhs, rhs))
259 DEFINE_SIGNED_MISMATCH_COMP(is_unsigned_vs_signed, EQ, CmpEQImpl(rhs, lhs))
260 DEFINE_SIGNED_MISMATCH_COMP(is_unsigned_vs_signed, NE, CmpNEImpl(rhs, lhs))
261 DEFINE_SIGNED_MISMATCH_COMP(is_unsigned_vs_signed, LT, CmpGTImpl(rhs, lhs))
262 DEFINE_SIGNED_MISMATCH_COMP(is_unsigned_vs_signed, LE, CmpGEImpl(rhs, lhs))
263 DEFINE_SIGNED_MISMATCH_COMP(is_unsigned_vs_signed, GT, CmpLTImpl(rhs, lhs))
264 DEFINE_SIGNED_MISMATCH_COMP(is_unsigned_vs_signed, GE, CmpLEImpl(rhs, lhs))
265 #undef MAKE_UNSIGNED
266 #undef DEFINE_SIGNED_MISMATCH_COMP
267
268 // Helper functions for CHECK_OP macro.
269 // The (float, float) and (double, double) instantiations are explicitly
270 // externalized to ensure proper 32/64-bit comparisons on x86.
271 // The Cmp##NAME##Impl function is only instantiable if one of the two types is
272 // not integral or their signedness matches (i.e. whenever no specialization is
273 // required, see above). Otherwise it is disabled by the enable_if construct,
274 // and the compiler will pick a specialization from above.
275 #define DEFINE_CHECK_OP_IMPL(NAME, op) \
276 template <typename Lhs, typename Rhs> \
277 V8_INLINE \
278 typename std::enable_if<!is_signed_vs_unsigned<Lhs, Rhs>::value && \
279 !is_unsigned_vs_signed<Lhs, Rhs>::value, \
280 bool>::type Cmp##NAME##Impl(Lhs lhs, Rhs rhs) { \
281 return lhs op rhs; \
282 } \
283 template <typename Lhs, typename Rhs> \
284 V8_INLINE std::string* Check##NAME##Impl(Lhs lhs, Rhs rhs, \
285 char const* msg) { \
286 using LhsPassT = typename pass_value_or_ref<Lhs>::type; \
287 using RhsPassT = typename pass_value_or_ref<Rhs>::type; \
288 bool cmp = Cmp##NAME##Impl<LhsPassT, RhsPassT>(lhs, rhs); \
289 return V8_LIKELY(cmp) \
290 ? nullptr \
291 : MakeCheckOpString<LhsPassT, RhsPassT>(lhs, rhs, msg); \
292 } \
293 extern template V8_BASE_EXPORT std::string* Check##NAME##Impl<float, float>( \
294 float lhs, float rhs, char const* msg); \
295 extern template V8_BASE_EXPORT std::string* \
296 Check##NAME##Impl<double, double>(double lhs, double rhs, \
297 char const* msg);
298 DEFINE_CHECK_OP_IMPL(EQ, ==)
299 DEFINE_CHECK_OP_IMPL(NE, !=)
300 DEFINE_CHECK_OP_IMPL(LE, <=)
301 DEFINE_CHECK_OP_IMPL(LT, < )
302 DEFINE_CHECK_OP_IMPL(GE, >=)
303 DEFINE_CHECK_OP_IMPL(GT, > )
304 #undef DEFINE_CHECK_OP_IMPL
305
306 #define CHECK_EQ(lhs, rhs) CHECK_OP(EQ, ==, lhs, rhs)
307 #define CHECK_NE(lhs, rhs) CHECK_OP(NE, !=, lhs, rhs)
308 #define CHECK_LE(lhs, rhs) CHECK_OP(LE, <=, lhs, rhs)
309 #define CHECK_LT(lhs, rhs) CHECK_OP(LT, <, lhs, rhs)
310 #define CHECK_GE(lhs, rhs) CHECK_OP(GE, >=, lhs, rhs)
311 #define CHECK_GT(lhs, rhs) CHECK_OP(GT, >, lhs, rhs)
312 #define CHECK_NULL(val) CHECK((val) == nullptr)
313 #define CHECK_NOT_NULL(val) CHECK((val) != nullptr)
314 #define CHECK_IMPLIES(lhs, rhs) \
315 CHECK_WITH_MSG(!(lhs) || (rhs), #lhs " implies " #rhs)
316
317 } // namespace base
318 } // namespace v8
319
320
321 // The DCHECK macro is equivalent to CHECK except that it only
322 // generates code in debug builds.
323 #ifdef DEBUG
324 #define DCHECK_EQ(lhs, rhs) DCHECK_OP(EQ, ==, lhs, rhs)
325 #define DCHECK_NE(lhs, rhs) DCHECK_OP(NE, !=, lhs, rhs)
326 #define DCHECK_GT(lhs, rhs) DCHECK_OP(GT, >, lhs, rhs)
327 #define DCHECK_GE(lhs, rhs) DCHECK_OP(GE, >=, lhs, rhs)
328 #define DCHECK_LT(lhs, rhs) DCHECK_OP(LT, <, lhs, rhs)
329 #define DCHECK_LE(lhs, rhs) DCHECK_OP(LE, <=, lhs, rhs)
330 #define DCHECK_NULL(val) DCHECK((val) == nullptr)
331 #define DCHECK_NOT_NULL(val) DCHECK((val) != nullptr)
332 #define DCHECK_IMPLIES(lhs, rhs) \
333 DCHECK_WITH_MSG(!(lhs) || (rhs), #lhs " implies " #rhs)
334 #else
335 #define DCHECK(condition) ((void) 0)
336 #define DCHECK_EQ(v1, v2) ((void) 0)
337 #define DCHECK_NE(v1, v2) ((void) 0)
338 #define DCHECK_GT(v1, v2) ((void) 0)
339 #define DCHECK_GE(v1, v2) ((void) 0)
340 #define DCHECK_LT(v1, v2) ((void) 0)
341 #define DCHECK_LE(v1, v2) ((void) 0)
342 #define DCHECK_NULL(val) ((void) 0)
343 #define DCHECK_NOT_NULL(val) ((void) 0)
344 #define DCHECK_IMPLIES(v1, v2) ((void) 0)
345 #endif
346
347 #endif // V8_BASE_LOGGING_H_
348