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 typedef enum {
 158     TIZEN_DLOG_PRIORITY_ERROR,
 159     TIZEN_DLOG_PRIORITY_INFO,
 160     TIZEN_DLOG_PRIORITY_WARN,
 161     TIZEN_DLOG_PRIORITY_DEBUG
 162 } TizenDlogPriority;
 163
 164 WTF_EXPORT_PRIVATE void TizenLog(TizenDlogPriority priority, bool secureLog, int line, const char* function, const char* format, ...);
 165 WTF_EXPORT_PRIVATE void TizenConsoleMessage(TizenDlogPriority priority, const char* format, ...);
 166 #endif
 167
 168 #ifdef __cplusplus
 169 }
 170 #endif
 171
 172 /* CRASH() - Raises a fatal error resulting in program termination and triggering either the debugger or the crash reporter.
 173
 174    Use CRASH() in response to known, unrecoverable errors like out-of-memory.
 175    Macro is enabled in both debug and release mode.
 176    To test for unknown errors and verify assumptions, use ASSERT instead, to avoid impacting performance in release builds.
 177
 178    Signals are ignored by the crash reporter on OS X so we must do better.
 179 */
 180 #ifndef CRASH
 181 #if COMPILER(CLANG)
 182 #define CRASH() \
 183     (WTFReportBacktrace(), \
 184      WTFInvokeCrashHook(), \
 185      (*(int *)(uintptr_t)0xbbadbeef = 0), \
 186      __builtin_trap())
 187 #else
 188 #define CRASH() \
 189     (WTFReportBacktrace(), \
 190      WTFInvokeCrashHook(), \
 191      (*(int *)(uintptr_t)0xbbadbeef = 0), \
 192      ((void(*)())0)() /* More reliable, but doesn't say BBADBEEF */ \
 193     )
 194 #endif
 195 #endif
 196
 197 #if COMPILER(CLANG)
 198 #define NO_RETURN_DUE_TO_CRASH NO_RETURN
 199 #else
 200 #define NO_RETURN_DUE_TO_CRASH
 201 #endif
 202
 203
 204 /* BACKTRACE
 205
 206   Print a backtrace to the same location as ASSERT messages.
 207 */
 208
 209 #if BACKTRACE_DISABLED
 210
 211 #define BACKTRACE() ((void)0)
 212
 213 #else
 214
 215 #define BACKTRACE() do { \
 216     WTFReportBacktrace(); \
 217 } while(false)
 218
 219 #endif
 220
 221 /* ASSERT, ASSERT_NOT_REACHED, ASSERT_UNUSED
 222
 223   These macros are compiled out of release builds.
 224   Expressions inside them are evaluated in debug builds only.
 225 */
 226
 227 #if OS(WINCE) && !PLATFORM(TORCHMOBILE)
 228 /* FIXME: We include this here only to avoid a conflict with the ASSERT macro. */
 229 #include <windows.h>
 230 #undef min
 231 #undef max
 232 #undef ERROR
 233 #endif
 234
 235 #if OS(WINDOWS)
 236 /* FIXME: Change to use something other than ASSERT to avoid this conflict with the underlying platform */
 237 #undef ASSERT
 238 #endif
 239
 240 #if ASSERT_DISABLED
 241
 242 #define ASSERT(assertion) ((void)0)
 243 #define ASSERT_AT(assertion, file, line, function) ((void)0)
 244 #define ASSERT_NOT_REACHED() ((void)0)
 245 #define NO_RETURN_DUE_TO_ASSERT
 246
 247 #if COMPILER(INTEL) && !OS(WINDOWS) || COMPILER(RVCT)
 248 template<typename T>
 249 inline void assertUnused(T& x) { (void)x; }
 250 #define ASSERT_UNUSED(variable, assertion) (assertUnused(variable))
 251 #else
 252 #define ASSERT_UNUSED(variable, assertion) ((void)variable)
 253 #endif
 254
 255 #else
 256
 257 #define ASSERT(assertion) \
 258     (!(assertion) ? \
 259         (WTFReportAssertionFailure(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #assertion), \
 260          CRASH()) : \
 261         (void)0)
 262
 263 #define ASSERT_AT(assertion, file, line, function) \
 264     (!(assertion) ? \
 265         (WTFReportAssertionFailure(file, line, function, #assertion), \
 266          CRASH()) :                                                   \
 267         (void)0)
 268
 269 #define ASSERT_NOT_REACHED() do { \
 270     WTFReportAssertionFailure(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, 0); \
 271     CRASH(); \
 272 } while (0)
 273
 274 #define ASSERT_UNUSED(variable, assertion) ASSERT(assertion)
 275
 276 #define NO_RETURN_DUE_TO_ASSERT NO_RETURN_DUE_TO_CRASH
 277
 278 #endif
 279
 280 /* ASSERT_WITH_MESSAGE */
 281
 282 #if COMPILER(MSVC7_OR_LOWER)
 283 #define ASSERT_WITH_MESSAGE(assertion) ((void)0)
 284 #elif ASSERT_MSG_DISABLED
 285 #define ASSERT_WITH_MESSAGE(assertion, ...) ((void)0)
 286 #else
 287 #define ASSERT_WITH_MESSAGE(assertion, ...) do \
 288     if (!(assertion)) { \
 289         WTFReportAssertionFailureWithMessage(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #assertion, __VA_ARGS__); \
 290         CRASH(); \
 291     } \
 292 while (0)
 293 #endif
 294
 295 /* ASSERT_WITH_MESSAGE_UNUSED */
 296
 297 #if COMPILER(MSVC7_OR_LOWER)
 298 #define ASSERT_WITH_MESSAGE_UNUSED(variable, assertion) ((void)0)
 299 #elif ASSERT_MSG_DISABLED
 300 #if COMPILER(INTEL) && !OS(WINDOWS) || COMPILER(RVCT)
 301 template<typename T>
 302 inline void assertWithMessageUnused(T& x) { (void)x; }
 303 #define ASSERT_WITH_MESSAGE_UNUSED(variable, assertion, ...) (assertWithMessageUnused(variable))
 304 #else
 305 #define ASSERT_WITH_MESSAGE_UNUSED(variable, assertion, ...) ((void)variable)
 306 #endif
 307 #else
 308 #define ASSERT_WITH_MESSAGE_UNUSED(variable, assertion, ...) do \
 309     if (!(assertion)) { \
 310         WTFReportAssertionFailureWithMessage(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #assertion, __VA_ARGS__); \
 311         CRASH(); \
 312     } \
 313 while (0)
 314 #endif
 315
 316
 317 /* ASSERT_ARG */
 318
 319 #if ASSERT_ARG_DISABLED
 320
 321 #define ASSERT_ARG(argName, assertion) ((void)0)
 322
 323 #else
 324
 325 #define ASSERT_ARG(argName, assertion) do \
 326     if (!(assertion)) { \
 327         WTFReportArgumentAssertionFailure(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #argName, #assertion); \
 328         CRASH(); \
 329     } \
 330 while (0)
 331
 332 #endif
 333
 334 /* COMPILE_ASSERT */
 335 #ifndef COMPILE_ASSERT
 336 #if COMPILER_SUPPORTS(C_STATIC_ASSERT)
 337 #define COMPILE_ASSERT(exp, name) _Static_assert((exp), #name)
 338 #else
 339 #define COMPILE_ASSERT(exp, name) typedef int dummy##name [(exp) ? 1 : -1]
 340 #endif
 341 #endif
 342
 343 /* FATAL */
 344
 345 #if COMPILER(MSVC7_OR_LOWER)
 346 #define FATAL() ((void)0)
 347 #elif FATAL_DISABLED
 348 #define FATAL(...) ((void)0)
 349 #else
 350 #define FATAL(...) do { \
 351     WTFReportFatalError(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, __VA_ARGS__); \
 352     CRASH(); \
 353 } while (0)
 354 #endif
 355
 356 /* LOG_ERROR */
 357
 358 #if COMPILER(MSVC7_OR_LOWER)
 359 #define LOG_ERROR() ((void)0)
 360 #elif ERROR_DISABLED
 361 #define LOG_ERROR(...) ((void)0)
 362 #else
 363 #define LOG_ERROR(...) WTFReportError(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, __VA_ARGS__)
 364 #endif
 365
 366 /* LOG */
 367
 368 #if COMPILER(MSVC7_OR_LOWER)
 369 #define LOG() ((void)0)
 370 #elif LOG_DISABLED
 371 #define LOG(channel, ...) ((void)0)
 372 #else
 373 #if ENABLE(TIZEN_DLOG_SUPPORT)
 374 // Use below macros to print out WebKit debug log.
 375 #define TIZEN_LOGE(...) TizenLog(TIZEN_DLOG_PRIORITY_ERROR, false, __LINE__, WTF_PRETTY_FUNCTION, __VA_ARGS__);
 376 #define TIZEN_LOGI(...) TizenLog(TIZEN_DLOG_PRIORITY_INFO, false, __LINE__, WTF_PRETTY_FUNCTION, __VA_ARGS__);
 377
 378 // Use below macros to print out secure log.
 379 #define TIZEN_SECURE_LOGE(...) TizenLog(TIZEN_DLOG_PRIORITY_ERROR, true, __LINE__, WTF_PRETTY_FUNCTION, __VA_ARGS__);
 380 #define TIZEN_SECURE_LOGI(...) TizenLog(TIZEN_DLOG_PRIORITY_INFO, true, __LINE__, WTF_PRETTY_FUNCTION, __VA_ARGS__);
 381
 382 // Use below macros to print out ConsoleMessage.
 383 #define TIZEN_CONSOLEE(...) TizenConsoleMessage(TIZEN_DLOG_PRIORITY_ERROR, __VA_ARGS__);
 384 #define TIZEN_CONSOLEI(...) TizenConsoleMessage(TIZEN_DLOG_PRIORITY_INFO, __VA_ARGS__);
 385 #define TIZEN_CONSOLEW(...) TizenConsoleMessage(TIZEN_DLOG_PRIORITY_WARN, __VA_ARGS__);
 386 #define TIZEN_CONSOLED(...) TizenConsoleMessage(TIZEN_DLOG_PRIORITY_DEBUG, __VA_ARGS__);
 387
 388 #define LOG(channel, ...) LOG_VERBOSE(channel, __VA_ARGS__)
 389 #else
 390 #define LOG(channel, ...) WTFLog(&JOIN_LOG_CHANNEL_WITH_PREFIX(LOG_CHANNEL_PREFIX, channel), __VA_ARGS__)
 391 #endif
 392 #define JOIN_LOG_CHANNEL_WITH_PREFIX(prefix, channel) JOIN_LOG_CHANNEL_WITH_PREFIX_LEVEL_2(prefix, channel)
 393 #define JOIN_LOG_CHANNEL_WITH_PREFIX_LEVEL_2(prefix, channel) prefix ## channel
 394 #endif
 395
 396 /* LOG_VERBOSE */
 397
 398 #if COMPILER(MSVC7_OR_LOWER)
 399 #define LOG_VERBOSE(channel) ((void)0)
 400 #elif LOG_DISABLED
 401 #define LOG_VERBOSE(channel, ...) ((void)0)
 402 #else
 403 #define LOG_VERBOSE(channel, ...) WTFLogVerbose(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, &JOIN_LOG_CHANNEL_WITH_PREFIX(LOG_CHANNEL_PREFIX, channel), __VA_ARGS__)
 404 #endif
 405
 406 /* UNREACHABLE_FOR_PLATFORM */
 407
 408 #if COMPILER(CLANG)
 409 // This would be a macro except that its use of #pragma works best around
 410 // a function. Hence it uses macro naming convention.
 411 #pragma clang diagnostic push
 412 #pragma clang diagnostic ignored "-Wmissing-noreturn"
 413 static inline void UNREACHABLE_FOR_PLATFORM()
 414 {
 415     ASSERT_NOT_REACHED();
 416 }
 417 #pragma clang diagnostic pop
 418 #else
 419 #define UNREACHABLE_FOR_PLATFORM() ASSERT_NOT_REACHED()
 420 #endif
 421
 422 #endif /* WTF_Assertions_h */