Source/WTF/wtf/Assertions.h

   1 /*
   2  * Copyright (C) 2003, 2006, 2007 Apple Inc.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef WTF_Assertions_h
  27 #define WTF_Assertions_h
  28
  29 /*
  30    no namespaces because this file has to be includable from C and Objective-C
  31
  32    Note, this file uses many GCC extensions, but it should be compatible with
  33    C, Objective C, C++, and Objective C++.
  34
  35    For non-debug builds, everything is disabled by default.
  36    Defining any of the symbols explicitly prevents this from having any effect.
  37
  38    MSVC7 note: variadic macro support was added in MSVC8, so for now we disable
  39    those macros in MSVC7. For more info, see the MSDN document on variadic
  40    macros here:
  41
  42    http://msdn2.microsoft.com/en-us/library/ms177415(VS.80).aspx
  43 */
  44
  45 #include <wtf/Platform.h>
  46
  47 #include <stddef.h>
  48
  49 #if !COMPILER(MSVC)
  50 #include <inttypes.h>
  51 #endif
  52
  53 #ifdef NDEBUG
  54 /* Disable ASSERT* macros in release mode. */
  55 #define ASSERTIONS_DISABLED_DEFAULT 1
  56 #else
  57 #define ASSERTIONS_DISABLED_DEFAULT 0
  58 #endif
  59
  60 #if COMPILER(MSVC7_OR_LOWER)
  61 #define HAVE_VARIADIC_MACRO 0
  62 #else
  63 #define HAVE_VARIADIC_MACRO 1
  64 #endif
  65
  66 #ifndef BACKTRACE_DISABLED
  67 #define BACKTRACE_DISABLED ASSERTIONS_DISABLED_DEFAULT
  68 #endif
  69
  70 #ifndef ASSERT_DISABLED
  71 #define ASSERT_DISABLED ASSERTIONS_DISABLED_DEFAULT
  72 #endif
  73
  74 #ifndef ASSERT_MSG_DISABLED
  75 #if HAVE(VARIADIC_MACRO)
  76 #define ASSERT_MSG_DISABLED ASSERTIONS_DISABLED_DEFAULT
  77 #else
  78 #define ASSERT_MSG_DISABLED 1
  79 #endif
  80 #endif
  81
  82 #ifndef ASSERT_ARG_DISABLED
  83 #define ASSERT_ARG_DISABLED ASSERTIONS_DISABLED_DEFAULT
  84 #endif
  85
  86 #ifndef FATAL_DISABLED
  87 #if HAVE(VARIADIC_MACRO)
  88 #define FATAL_DISABLED ASSERTIONS_DISABLED_DEFAULT
  89 #else
  90 #define FATAL_DISABLED 1
  91 #endif
  92 #endif
  93
  94 #ifndef ERROR_DISABLED
  95 #if HAVE(VARIADIC_MACRO)
  96 #define ERROR_DISABLED ASSERTIONS_DISABLED_DEFAULT
  97 #else
  98 #define ERROR_DISABLED 1
  99 #endif
 100 #endif
 101
 102 #ifndef LOG_DISABLED
 103 #if HAVE(VARIADIC_MACRO)
 104 #define LOG_DISABLED ASSERTIONS_DISABLED_DEFAULT
 105 #else
 106 #define LOG_DISABLED 1
 107 #endif
 108 #endif
 109
 110 #if COMPILER(GCC)
 111 #define WTF_PRETTY_FUNCTION __PRETTY_FUNCTION__
 112 #else
 113 #define WTF_PRETTY_FUNCTION __FUNCTION__
 114 #endif
 115
 116 /* WTF logging functions can process %@ in the format string to log a NSObject* but the printf format attribute
 117    emits a warning when %@ is used in the format string.  Until <rdar://problem/5195437> is resolved we can't include
 118    the attribute when being used from Objective-C code in case it decides to use %@. */
 119 #if COMPILER(GCC) && !defined(__OBJC__)
 120 #define WTF_ATTRIBUTE_PRINTF(formatStringArgument, extraArguments) __attribute__((__format__(printf, formatStringArgument, extraArguments)))
 121 #else
 122 #define WTF_ATTRIBUTE_PRINTF(formatStringArgument, extraArguments)
 123 #endif
 124
 125 /* These helper functions are always declared, but not necessarily always defined if the corresponding function is disabled. */
 126
 127 #ifdef __cplusplus
 128 extern "C" {
 129 #endif
 130
 131 typedef enum { WTFLogChannelOff, WTFLogChannelOn } WTFLogChannelState;
 132
 133 typedef struct {
 134     unsigned mask;
 135     const char *defaultName;
 136     WTFLogChannelState state;
 137 } WTFLogChannel;
 138
 139 WTF_EXPORT_PRIVATE void WTFReportAssertionFailure(const char* file, int line, const char* function, const char* assertion);
 140 WTF_EXPORT_PRIVATE void WTFReportAssertionFailureWithMessage(const char* file, int line, const char* function, const char* assertion, const char* format, ...) WTF_ATTRIBUTE_PRINTF(5, 6);
 141 WTF_EXPORT_PRIVATE void WTFReportArgumentAssertionFailure(const char* file, int line, const char* function, const char* argName, const char* assertion);
 142 WTF_EXPORT_PRIVATE void WTFReportFatalError(const char* file, int line, const char* function, const char* format, ...) WTF_ATTRIBUTE_PRINTF(4, 5);
 143 WTF_EXPORT_PRIVATE void WTFReportError(const char* file, int line, const char* function, const char* format, ...) WTF_ATTRIBUTE_PRINTF(4, 5);
 144 WTF_EXPORT_PRIVATE void WTFLog(WTFLogChannel*, const char* format, ...) WTF_ATTRIBUTE_PRINTF(2, 3);
 145 WTF_EXPORT_PRIVATE void WTFLogVerbose(const char* file, int line, const char* function, WTFLogChannel*, const char* format, ...) WTF_ATTRIBUTE_PRINTF(5, 6);
 146 WTF_EXPORT_PRIVATE void WTFLogAlways(const char* format, ...) WTF_ATTRIBUTE_PRINTF(1, 2);
 147
 148 WTF_EXPORT_PRIVATE void WTFGetBacktrace(void** stack, int* size);
 149 WTF_EXPORT_PRIVATE void WTFReportBacktrace();
 150 WTF_EXPORT_PRIVATE void WTFPrintBacktrace(void** stack, int size);
 151
 152 typedef void (*WTFCrashHookFunction)();
 153 WTF_EXPORT_PRIVATE void WTFSetCrashHook(WTFCrashHookFunction);
 154 WTF_EXPORT_PRIVATE void WTFInvokeCrashHook();
 155
 156 #if ENABLE(TIZEN_DLOG_SUPPORT)
 157 WTF_EXPORT_PRIVATE void TizenLogError(int line, const char* function, const char* format, ...);
 158 WTF_EXPORT_PRIVATE void TizenLogInfo(int line, const char* function, const char* format, ...);
 159 #endif
 160
 161 #ifdef __cplusplus
 162 }
 163 #endif
 164
 165 /* CRASH() - Raises a fatal error resulting in program termination and triggering either the debugger or the crash reporter.
 166
 167    Use CRASH() in response to known, unrecoverable errors like out-of-memory.
 168    Macro is enabled in both debug and release mode.
 169    To test for unknown errors and verify assumptions, use ASSERT instead, to avoid impacting performance in release builds.
 170
 171    Signals are ignored by the crash reporter on OS X so we must do better.
 172 */
 173 #ifndef CRASH
 174 #if COMPILER(CLANG)
 175 #define CRASH() \
 176     (WTFReportBacktrace(), \
 177      WTFInvokeCrashHook(), \
 178      (*(int *)(uintptr_t)0xbbadbeef = 0), \
 179      __builtin_trap())
 180 #else
 181 #define CRASH() \
 182     (WTFReportBacktrace(), \
 183      WTFInvokeCrashHook(), \
 184      (*(int *)(uintptr_t)0xbbadbeef = 0), \
 185      ((void(*)())0)() /* More reliable, but doesn't say BBADBEEF */ \
 186     )
 187 #endif
 188 #endif
 189
 190 #if COMPILER(CLANG)
 191 #define NO_RETURN_DUE_TO_CRASH NO_RETURN
 192 #else
 193 #define NO_RETURN_DUE_TO_CRASH
 194 #endif
 195
 196
 197 /* BACKTRACE
 198
 199   Print a backtrace to the same location as ASSERT messages.
 200 */
 201
 202 #if BACKTRACE_DISABLED
 203
 204 #define BACKTRACE() ((void)0)
 205
 206 #else
 207
 208 #define BACKTRACE() do { \
 209     WTFReportBacktrace(); \
 210 } while(false)
 211
 212 #endif
 213
 214 /* ASSERT, ASSERT_NOT_REACHED, ASSERT_UNUSED
 215
 216   These macros are compiled out of release builds.
 217   Expressions inside them are evaluated in debug builds only.
 218 */
 219
 220 #if OS(WINCE) && !PLATFORM(TORCHMOBILE)
 221 /* FIXME: We include this here only to avoid a conflict with the ASSERT macro. */
 222 #include <windows.h>
 223 #undef min
 224 #undef max
 225 #undef ERROR
 226 #endif
 227
 228 #if OS(WINDOWS)
 229 /* FIXME: Change to use something other than ASSERT to avoid this conflict with the underlying platform */
 230 #undef ASSERT
 231 #endif
 232
 233 #if ASSERT_DISABLED
 234
 235 #define ASSERT(assertion) ((void)0)
 236 #define ASSERT_AT(assertion, file, line, function) ((void)0)
 237 #define ASSERT_NOT_REACHED() ((void)0)
 238 #define NO_RETURN_DUE_TO_ASSERT
 239
 240 #if COMPILER(INTEL) && !OS(WINDOWS) || COMPILER(RVCT)
 241 template<typename T>
 242 inline void assertUnused(T& x) { (void)x; }
 243 #define ASSERT_UNUSED(variable, assertion) (assertUnused(variable))
 244 #else
 245 #define ASSERT_UNUSED(variable, assertion) ((void)variable)
 246 #endif
 247
 248 #else
 249
 250 #define ASSERT(assertion) \
 251     (!(assertion) ? \
 252         (WTFReportAssertionFailure(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #assertion), \
 253          CRASH()) : \
 254         (void)0)
 255
 256 #define ASSERT_AT(assertion, file, line, function) \
 257     (!(assertion) ? \
 258         (WTFReportAssertionFailure(file, line, function, #assertion), \
 259          CRASH()) :                                                   \
 260         (void)0)
 261
 262 #define ASSERT_NOT_REACHED() do { \
 263     WTFReportAssertionFailure(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, 0); \
 264     CRASH(); \
 265 } while (0)
 266
 267 #define ASSERT_UNUSED(variable, assertion) ASSERT(assertion)
 268
 269 #define NO_RETURN_DUE_TO_ASSERT NO_RETURN_DUE_TO_CRASH
 270
 271 #endif
 272
 273 /* ASSERT_WITH_MESSAGE */
 274
 275 #if COMPILER(MSVC7_OR_LOWER)
 276 #define ASSERT_WITH_MESSAGE(assertion) ((void)0)
 277 #elif ASSERT_MSG_DISABLED
 278 #define ASSERT_WITH_MESSAGE(assertion, ...) ((void)0)
 279 #else
 280 #define ASSERT_WITH_MESSAGE(assertion, ...) do \
 281     if (!(assertion)) { \
 282         WTFReportAssertionFailureWithMessage(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #assertion, __VA_ARGS__); \
 283         CRASH(); \
 284     } \
 285 while (0)
 286 #endif
 287
 288 /* ASSERT_WITH_MESSAGE_UNUSED */
 289
 290 #if COMPILER(MSVC7_OR_LOWER)
 291 #define ASSERT_WITH_MESSAGE_UNUSED(variable, assertion) ((void)0)
 292 #elif ASSERT_MSG_DISABLED
 293 #if COMPILER(INTEL) && !OS(WINDOWS) || COMPILER(RVCT)
 294 template<typename T>
 295 inline void assertWithMessageUnused(T& x) { (void)x; }
 296 #define ASSERT_WITH_MESSAGE_UNUSED(variable, assertion, ...) (assertWithMessageUnused(variable))
 297 #else
 298 #define ASSERT_WITH_MESSAGE_UNUSED(variable, assertion, ...) ((void)variable)
 299 #endif
 300 #else
 301 #define ASSERT_WITH_MESSAGE_UNUSED(variable, assertion, ...) do \
 302     if (!(assertion)) { \
 303         WTFReportAssertionFailureWithMessage(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #assertion, __VA_ARGS__); \
 304         CRASH(); \
 305     } \
 306 while (0)
 307 #endif
 308
 309
 310 /* ASSERT_ARG */
 311
 312 #if ASSERT_ARG_DISABLED
 313
 314 #define ASSERT_ARG(argName, assertion) ((void)0)
 315
 316 #else
 317
 318 #define ASSERT_ARG(argName, assertion) do \
 319     if (!(assertion)) { \
 320         WTFReportArgumentAssertionFailure(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #argName, #assertion); \
 321         CRASH(); \
 322     } \
 323 while (0)
 324
 325 #endif
 326
 327 /* COMPILE_ASSERT */
 328 #ifndef COMPILE_ASSERT
 329 #if COMPILER_SUPPORTS(C_STATIC_ASSERT)
 330 #define COMPILE_ASSERT(exp, name) _Static_assert((exp), #name)
 331 #else
 332 #define COMPILE_ASSERT(exp, name) typedef int dummy##name [(exp) ? 1 : -1]
 333 #endif
 334 #endif
 335
 336 /* FATAL */
 337
 338 #if COMPILER(MSVC7_OR_LOWER)
 339 #define FATAL() ((void)0)
 340 #elif FATAL_DISABLED
 341 #define FATAL(...) ((void)0)
 342 #else
 343 #define FATAL(...) do { \
 344     WTFReportFatalError(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, __VA_ARGS__); \
 345     CRASH(); \
 346 } while (0)
 347 #endif
 348
 349 /* LOG_ERROR */
 350
 351 #if COMPILER(MSVC7_OR_LOWER)
 352 #define LOG_ERROR() ((void)0)
 353 #elif ERROR_DISABLED
 354 #define LOG_ERROR(...) ((void)0)
 355 #else
 356 #define LOG_ERROR(...) WTFReportError(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, __VA_ARGS__)
 357 #endif
 358
 359 /* LOG */
 360
 361 #if COMPILER(MSVC7_OR_LOWER)
 362 #define LOG() ((void)0)
 363 #elif LOG_DISABLED
 364 #define LOG(channel, ...) ((void)0)
 365 #else
 366 #if ENABLE(TIZEN_DLOG_SUPPORT)
 367 // Use below macros to print out WebKit debug log.
 368 #define TIZEN_LOGE(...) TizenLogError(__LINE__, WTF_PRETTY_FUNCTION, __VA_ARGS__);
 369 #define TIZEN_LOGI(...) TizenLogInfo(__LINE__, WTF_PRETTY_FUNCTION, __VA_ARGS__);
 370
 371 #define LOG(channel, ...) LOG_VERBOSE(channel, __VA_ARGS__)
 372 #else
 373 #define LOG(channel, ...) WTFLog(&JOIN_LOG_CHANNEL_WITH_PREFIX(LOG_CHANNEL_PREFIX, channel), __VA_ARGS__)
 374 #endif
 375 #define JOIN_LOG_CHANNEL_WITH_PREFIX(prefix, channel) JOIN_LOG_CHANNEL_WITH_PREFIX_LEVEL_2(prefix, channel)
 376 #define JOIN_LOG_CHANNEL_WITH_PREFIX_LEVEL_2(prefix, channel) prefix ## channel
 377 #endif
 378
 379 /* LOG_VERBOSE */
 380
 381 #if COMPILER(MSVC7_OR_LOWER)
 382 #define LOG_VERBOSE(channel) ((void)0)
 383 #elif LOG_DISABLED
 384 #define LOG_VERBOSE(channel, ...) ((void)0)
 385 #else
 386 #define LOG_VERBOSE(channel, ...) WTFLogVerbose(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, &JOIN_LOG_CHANNEL_WITH_PREFIX(LOG_CHANNEL_PREFIX, channel), __VA_ARGS__)
 387 #endif
 388
 389 /* UNREACHABLE_FOR_PLATFORM */
 390
 391 #if COMPILER(CLANG)
 392 // This would be a macro except that its use of #pragma works best around
 393 // a function. Hence it uses macro naming convention.
 394 #pragma clang diagnostic push
 395 #pragma clang diagnostic ignored "-Wmissing-noreturn"
 396 static inline void UNREACHABLE_FOR_PLATFORM()
 397 {
 398     ASSERT_NOT_REACHED();
 399 }
 400 #pragma clang diagnostic pop
 401 #else
 402 #define UNREACHABLE_FOR_PLATFORM() ASSERT_NOT_REACHED()
 403 #endif
 404
 405 #endif /* WTF_Assertions_h */