1/* 2 * Copyright 2006 The WebRTC Project Authors. All rights reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11#ifndef WEBRTC_BASE_CHECKS_H_ 12#define WEBRTC_BASE_CHECKS_H_ 13 14#include <sstream> 15#include <string> 16 17#ifdef WEBRTC_CHROMIUM_BUILD 18// Include logging.h in a Chromium build to enable the overrides mechanism for 19// using Chromium's macros. Otherwise, don't depend on logging.h. 20// TODO(ajm): Ideally, checks.h would be combined with logging.h, but 21// consolidation with system_wrappers/logging.h should happen first. 22#include "webrtc/base/logging.h" 23#endif 24#include "webrtc/typedefs.h" 25 26// The macros here print a message to stderr and abort under various 27// conditions. All will accept additional stream messages. For example: 28// DCHECK_EQ(foo, bar) << "I'm printed when foo != bar."; 29// 30// - CHECK(x) is an assertion that x is always true, and that if it isn't, it's 31// better to terminate the process than to continue. During development, the 32// reason that it's better to terminate might simply be that the error 33// handling code isn't in place yet; in production, the reason might be that 34// the author of the code truly believes that x will always be true, but that 35// she recognizes that if she is wrong, abrupt and unpleasant process 36// termination is still better than carrying on with the assumption violated. 37// 38// - DCHECK(x) is the same as CHECK(x)---an assertion that x is always 39// true---except that x will only be evaluated in debug builds; in production 40// builds, x is simply assumed to be true. This is useful if evaluating x is 41// expensive and the expected cost of failing to detect the violated 42// assumption is acceptable. You should not handle cases where a production 43// build fails to spot a violated condition, even those that would result in 44// crashes. If the code needs to cope with the error, make it cope, but don't 45// call DCHECK; if the condition really can't occur, but you'd sleep better 46// at night knowing that the process will suicide instead of carrying on in 47// case you were wrong, use CHECK instead of DCHECK. 48// 49// - CHECK_EQ, _NE, _GT, ..., and DCHECK_EQ, _NE, _GT, ... are specialized 50// variants of CHECK and DCHECK that print prettier messages if the condition 51// doesn't hold. Prefer them to raw CHECK and DCHECK. 52// 53// - FATAL() aborts unconditionally. 54 55namespace rtc { 56 57// The use of overrides/webrtc/base/logging.h in a Chromium build results in 58// redefined macro errors. Fortunately, Chromium's macros can be used as drop-in 59// replacements for the standalone versions. 60#ifndef WEBRTC_CHROMIUM_BUILD 61 62// Helper macro which avoids evaluating the arguments to a stream if 63// the condition doesn't hold. 64#define LAZY_STREAM(stream, condition) \ 65 !(condition) ? static_cast<void>(0) : rtc::FatalMessageVoidify() & (stream) 66 67// The actual stream used isn't important. 68#define EAT_STREAM_PARAMETERS \ 69 true ? static_cast<void>(0) \ 70 : rtc::FatalMessageVoidify() & rtc::FatalMessage("", 0).stream() 71 72// CHECK dies with a fatal error if condition is not true. It is *not* 73// controlled by NDEBUG, so the check will be executed regardless of 74// compilation mode. 75// 76// We make sure CHECK et al. always evaluates their arguments, as 77// doing CHECK(FunctionWithSideEffect()) is a common idiom. 78#define CHECK(condition) \ 79 LAZY_STREAM(rtc::FatalMessage(__FILE__, __LINE__).stream(), !(condition)) \ 80 << "Check failed: " #condition << std::endl << "# " 81 82// Helper macro for binary operators. 83// Don't use this macro directly in your code, use CHECK_EQ et al below. 84// 85// TODO(akalin): Rewrite this so that constructs like if (...) 86// CHECK_EQ(...) else { ... } work properly. 87#define CHECK_OP(name, op, val1, val2) \ 88 if (std::string* _result = \ 89 rtc::Check##name##Impl((val1), (val2), \ 90 #val1 " " #op " " #val2)) \ 91 rtc::FatalMessage(__FILE__, __LINE__, _result).stream() 92 93// Build the error message string. This is separate from the "Impl" 94// function template because it is not performance critical and so can 95// be out of line, while the "Impl" code should be inline. Caller 96// takes ownership of the returned string. 97template<class t1, class t2> 98std::string* MakeCheckOpString(const t1& v1, const t2& v2, const char* names) { 99 std::ostringstream ss; 100 ss << names << " (" << v1 << " vs. " << v2 << ")"; 101 std::string* msg = new std::string(ss.str()); 102 return msg; 103} 104 105// MSVC doesn't like complex extern templates and DLLs. 106#if !defined(COMPILER_MSVC) 107// Commonly used instantiations of MakeCheckOpString<>. Explicitly instantiated 108// in logging.cc. 109extern template std::string* MakeCheckOpString<int, int>( 110 const int&, const int&, const char* names); 111extern template 112std::string* MakeCheckOpString<unsigned long, unsigned long>( 113 const unsigned long&, const unsigned long&, const char* names); 114extern template 115std::string* MakeCheckOpString<unsigned long, unsigned int>( 116 const unsigned long&, const unsigned int&, const char* names); 117extern template 118std::string* MakeCheckOpString<unsigned int, unsigned long>( 119 const unsigned int&, const unsigned long&, const char* names); 120extern template 121std::string* MakeCheckOpString<std::string, std::string>( 122 const std::string&, const std::string&, const char* name); 123#endif 124 125// Helper functions for CHECK_OP macro. 126// The (int, int) specialization works around the issue that the compiler 127// will not instantiate the template version of the function on values of 128// unnamed enum type - see comment below. 129#define DEFINE_CHECK_OP_IMPL(name, op) \ 130 template <class t1, class t2> \ 131 inline std::string* Check##name##Impl(const t1& v1, const t2& v2, \ 132 const char* names) { \ 133 if (v1 op v2) return NULL; \ 134 else return rtc::MakeCheckOpString(v1, v2, names); \ 135 } \ 136 inline std::string* Check##name##Impl(int v1, int v2, const char* names) { \ 137 if (v1 op v2) return NULL; \ 138 else return rtc::MakeCheckOpString(v1, v2, names); \ 139 } 140DEFINE_CHECK_OP_IMPL(EQ, ==) 141DEFINE_CHECK_OP_IMPL(NE, !=) 142DEFINE_CHECK_OP_IMPL(LE, <=) 143DEFINE_CHECK_OP_IMPL(LT, < ) 144DEFINE_CHECK_OP_IMPL(GE, >=) 145DEFINE_CHECK_OP_IMPL(GT, > ) 146#undef DEFINE_CHECK_OP_IMPL 147 148#define CHECK_EQ(val1, val2) CHECK_OP(EQ, ==, val1, val2) 149#define CHECK_NE(val1, val2) CHECK_OP(NE, !=, val1, val2) 150#define CHECK_LE(val1, val2) CHECK_OP(LE, <=, val1, val2) 151#define CHECK_LT(val1, val2) CHECK_OP(LT, < , val1, val2) 152#define CHECK_GE(val1, val2) CHECK_OP(GE, >=, val1, val2) 153#define CHECK_GT(val1, val2) CHECK_OP(GT, > , val1, val2) 154 155// The DCHECK macro is equivalent to CHECK except that it only generates code in 156// debug builds. 157#if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)) 158#define DCHECK(condition) CHECK(condition) 159#define DCHECK_EQ(v1, v2) CHECK_EQ(v1, v2) 160#define DCHECK_NE(v1, v2) CHECK_NE(v1, v2) 161#define DCHECK_LE(v1, v2) CHECK_LE(v1, v2) 162#define DCHECK_LT(v1, v2) CHECK_LT(v1, v2) 163#define DCHECK_GE(v1, v2) CHECK_GE(v1, v2) 164#define DCHECK_GT(v1, v2) CHECK_GT(v1, v2) 165#else 166#define DCHECK(condition) EAT_STREAM_PARAMETERS 167#define DCHECK_EQ(v1, v2) EAT_STREAM_PARAMETERS 168#define DCHECK_NE(v1, v2) EAT_STREAM_PARAMETERS 169#define DCHECK_LE(v1, v2) EAT_STREAM_PARAMETERS 170#define DCHECK_LT(v1, v2) EAT_STREAM_PARAMETERS 171#define DCHECK_GE(v1, v2) EAT_STREAM_PARAMETERS 172#define DCHECK_GT(v1, v2) EAT_STREAM_PARAMETERS 173#endif 174 175// This is identical to LogMessageVoidify but in name. 176class FatalMessageVoidify { 177 public: 178 FatalMessageVoidify() { } 179 // This has to be an operator with a precedence lower than << but 180 // higher than ?: 181 void operator&(std::ostream&) { } 182}; 183 184#endif // WEBRTC_CHROMIUM_BUILD 185 186#define FATAL() rtc::FatalMessage(__FILE__, __LINE__).stream() 187// TODO(ajm): Consider adding NOTIMPLEMENTED and NOTREACHED macros when 188// base/logging.h and system_wrappers/logging.h are consolidated such that we 189// can match the Chromium behavior. 190 191// Like a stripped-down LogMessage from logging.h, except that it aborts. 192class FatalMessage { 193 public: 194 FatalMessage(const char* file, int line); 195 // Used for CHECK_EQ(), etc. Takes ownership of the given string. 196 FatalMessage(const char* file, int line, std::string* result); 197 NO_RETURN ~FatalMessage(); 198 199 std::ostream& stream() { return stream_; } 200 201 private: 202 void Init(const char* file, int line); 203 204 std::ostringstream stream_; 205}; 206 207} // namespace rtc 208 209#endif // WEBRTC_BASE_CHECKS_H_ 210