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 16extern "C" PRINTF_FORMAT(3, 4) V8_NORETURN V8_BASE_EXPORT 17 void V8_Fatal(const char* file, int line, const char* format, ...); 18 19// The FATAL, UNREACHABLE and UNIMPLEMENTED macros are useful during 20// development, but they should not be relied on in the final product. 21#ifdef DEBUG 22#define FATAL(msg) \ 23 V8_Fatal(__FILE__, __LINE__, "%s", (msg)) 24#define UNIMPLEMENTED() \ 25 V8_Fatal(__FILE__, __LINE__, "unimplemented code") 26#define UNREACHABLE() \ 27 V8_Fatal(__FILE__, __LINE__, "unreachable code") 28#else 29#define FATAL(msg) \ 30 V8_Fatal("", 0, "%s", (msg)) 31#define UNIMPLEMENTED() \ 32 V8_Fatal("", 0, "unimplemented code") 33#define UNREACHABLE() V8_Fatal("", 0, "unreachable code") 34#endif 35 36 37namespace v8 { 38namespace base { 39 40// CHECK dies with a fatal error if condition is not true. It is *not* 41// controlled by DEBUG, so the check will be executed regardless of 42// compilation mode. 43// 44// We make sure CHECK et al. always evaluates their arguments, as 45// doing CHECK(FunctionWithSideEffect()) is a common idiom. 46#define CHECK(condition) \ 47 do { \ 48 if (V8_UNLIKELY(!(condition))) { \ 49 V8_Fatal(__FILE__, __LINE__, "Check failed: %s.", #condition); \ 50 } \ 51 } while (0) 52 53 54#ifdef DEBUG 55 56// Helper macro for binary operators. 57// Don't use this macro directly in your code, use CHECK_EQ et al below. 58#define CHECK_OP(name, op, lhs, rhs) \ 59 do { \ 60 if (std::string* _msg = ::v8::base::Check##name##Impl( \ 61 (lhs), (rhs), #lhs " " #op " " #rhs)) { \ 62 V8_Fatal(__FILE__, __LINE__, "Check failed: %s.", _msg->c_str()); \ 63 delete _msg; \ 64 } \ 65 } while (0) 66 67#else 68 69// Make all CHECK functions discard their log strings to reduce code 70// bloat for official release builds. 71 72#define CHECK_OP(name, op, lhs, rhs) CHECK((lhs)op(rhs)) 73 74#endif 75 76 77// Build the error message string. This is separate from the "Impl" 78// function template because it is not performance critical and so can 79// be out of line, while the "Impl" code should be inline. Caller 80// takes ownership of the returned string. 81template <typename Lhs, typename Rhs> 82std::string* MakeCheckOpString(Lhs const& lhs, Rhs const& rhs, 83 char const* msg) { 84 std::ostringstream ss; 85 ss << msg << " (" << lhs << " vs. " << rhs << ")"; 86 return new std::string(ss.str()); 87} 88 89// Commonly used instantiations of MakeCheckOpString<>. Explicitly instantiated 90// in logging.cc. 91#define DEFINE_MAKE_CHECK_OP_STRING(type) \ 92 extern template V8_BASE_EXPORT std::string* MakeCheckOpString<type, type>( \ 93 type const&, type const&, char const*); 94DEFINE_MAKE_CHECK_OP_STRING(int) 95DEFINE_MAKE_CHECK_OP_STRING(long) // NOLINT(runtime/int) 96DEFINE_MAKE_CHECK_OP_STRING(long long) // NOLINT(runtime/int) 97DEFINE_MAKE_CHECK_OP_STRING(unsigned int) 98DEFINE_MAKE_CHECK_OP_STRING(unsigned long) // NOLINT(runtime/int) 99DEFINE_MAKE_CHECK_OP_STRING(unsigned long long) // NOLINT(runtime/int) 100DEFINE_MAKE_CHECK_OP_STRING(char const*) 101DEFINE_MAKE_CHECK_OP_STRING(void const*) 102#undef DEFINE_MAKE_CHECK_OP_STRING 103 104 105// Helper functions for CHECK_OP macro. 106// The (int, int) specialization works around the issue that the compiler 107// will not instantiate the template version of the function on values of 108// unnamed enum type - see comment below. 109// The (float, float) and (double, double) instantiations are explicitly 110// externialized to ensure proper 32/64-bit comparisons on x86. 111#define DEFINE_CHECK_OP_IMPL(NAME, op) \ 112 template <typename Lhs, typename Rhs> \ 113 V8_INLINE std::string* Check##NAME##Impl(Lhs const& lhs, Rhs const& rhs, \ 114 char const* msg) { \ 115 return V8_LIKELY(lhs op rhs) ? nullptr : MakeCheckOpString(lhs, rhs, msg); \ 116 } \ 117 V8_INLINE std::string* Check##NAME##Impl(int lhs, int rhs, \ 118 char const* msg) { \ 119 return V8_LIKELY(lhs op rhs) ? nullptr : MakeCheckOpString(lhs, rhs, msg); \ 120 } \ 121 extern template V8_BASE_EXPORT std::string* Check##NAME##Impl<float, float>( \ 122 float const& lhs, float const& rhs, char const* msg); \ 123 extern template V8_BASE_EXPORT std::string* \ 124 Check##NAME##Impl<double, double>(double const& lhs, double const& rhs, \ 125 char const* msg); 126DEFINE_CHECK_OP_IMPL(EQ, ==) 127DEFINE_CHECK_OP_IMPL(NE, !=) 128DEFINE_CHECK_OP_IMPL(LE, <=) 129DEFINE_CHECK_OP_IMPL(LT, < ) 130DEFINE_CHECK_OP_IMPL(GE, >=) 131DEFINE_CHECK_OP_IMPL(GT, > ) 132#undef DEFINE_CHECK_OP_IMPL 133 134#define CHECK_EQ(lhs, rhs) CHECK_OP(EQ, ==, lhs, rhs) 135#define CHECK_NE(lhs, rhs) CHECK_OP(NE, !=, lhs, rhs) 136#define CHECK_LE(lhs, rhs) CHECK_OP(LE, <=, lhs, rhs) 137#define CHECK_LT(lhs, rhs) CHECK_OP(LT, <, lhs, rhs) 138#define CHECK_GE(lhs, rhs) CHECK_OP(GE, >=, lhs, rhs) 139#define CHECK_GT(lhs, rhs) CHECK_OP(GT, >, lhs, rhs) 140#define CHECK_NULL(val) CHECK((val) == nullptr) 141#define CHECK_NOT_NULL(val) CHECK((val) != nullptr) 142#define CHECK_IMPLIES(lhs, rhs) CHECK(!(lhs) || (rhs)) 143 144 145// Exposed for making debugging easier (to see where your function is being 146// called, just add a call to DumpBacktrace). 147void DumpBacktrace(); 148 149} // namespace base 150} // namespace v8 151 152 153// The DCHECK macro is equivalent to CHECK except that it only 154// generates code in debug builds. 155#ifdef DEBUG 156#define DCHECK(condition) CHECK(condition) 157#define DCHECK_EQ(v1, v2) CHECK_EQ(v1, v2) 158#define DCHECK_NE(v1, v2) CHECK_NE(v1, v2) 159#define DCHECK_GT(v1, v2) CHECK_GT(v1, v2) 160#define DCHECK_GE(v1, v2) CHECK_GE(v1, v2) 161#define DCHECK_LT(v1, v2) CHECK_LT(v1, v2) 162#define DCHECK_LE(v1, v2) CHECK_LE(v1, v2) 163#define DCHECK_NULL(val) CHECK_NULL(val) 164#define DCHECK_NOT_NULL(val) CHECK_NOT_NULL(val) 165#define DCHECK_IMPLIES(v1, v2) CHECK_IMPLIES(v1, v2) 166#else 167#define DCHECK(condition) ((void) 0) 168#define DCHECK_EQ(v1, v2) ((void) 0) 169#define DCHECK_NE(v1, v2) ((void) 0) 170#define DCHECK_GT(v1, v2) ((void) 0) 171#define DCHECK_GE(v1, v2) ((void) 0) 172#define DCHECK_LT(v1, v2) ((void) 0) 173#define DCHECK_LE(v1, v2) ((void) 0) 174#define DCHECK_NULL(val) ((void) 0) 175#define DCHECK_NOT_NULL(val) ((void) 0) 176#define DCHECK_IMPLIES(v1, v2) ((void) 0) 177#endif 178 179#endif // V8_BASE_LOGGING_H_ 180