1 /* 2 * kmp_debug.h -- debug / assertion code for Assure library 3 */ 4 5 //===----------------------------------------------------------------------===// 6 // 7 // The LLVM Compiler Infrastructure 8 // 9 // This file is dual licensed under the MIT and the University of Illinois Open 10 // Source Licenses. See LICENSE.txt for details. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef KMP_DEBUG_H 15 #define KMP_DEBUG_H 16 17 #include <stdarg.h> 18 19 #ifdef __cplusplus 20 extern "C" { 21 #endif // __cplusplus 22 23 // ----------------------------------------------------------------------------- 24 // Build-time assertion. 25 26 // New C++11 style build assert 27 #define KMP_BUILD_ASSERT(expr) static_assert(expr, "Build condition error") 28 29 // ----------------------------------------------------------------------------- 30 // Run-time assertions. 31 32 extern void __kmp_dump_debug_buffer(void); 33 34 #ifdef KMP_USE_ASSERT 35 extern int __kmp_debug_assert(char const *expr, char const *file, int line); 36 #ifdef KMP_DEBUG 37 #define KMP_ASSERT(cond) \ 38 if (!(cond)) { \ 39 __kmp_debug_assert(#cond, __FILE__, __LINE__); \ 40 } 41 #define KMP_ASSERT2(cond, msg) \ 42 if (!(cond)) { \ 43 __kmp_debug_assert((msg), __FILE__, __LINE__); \ 44 } 45 #define KMP_DEBUG_ASSERT(cond) KMP_ASSERT(cond) 46 #define KMP_DEBUG_ASSERT2(cond, msg) KMP_ASSERT2(cond, msg) 47 #define KMP_DEBUG_USE_VAR(x) /* Nothing (it is used!) */ 48 #else 49 // Do not expose condition in release build. Use "assertion failure". 50 #define KMP_ASSERT(cond) \ 51 if (!(cond)) { \ 52 __kmp_debug_assert("assertion failure", __FILE__, __LINE__); \ 53 } 54 #define KMP_ASSERT2(cond, msg) KMP_ASSERT(cond) 55 #define KMP_DEBUG_ASSERT(cond) /* Nothing */ 56 #define KMP_DEBUG_ASSERT2(cond, msg) /* Nothing */ 57 #define KMP_DEBUG_USE_VAR(x) ((void)(x)) 58 #endif // KMP_DEBUG 59 #else 60 #define KMP_ASSERT(cond) /* Nothing */ 61 #define KMP_ASSERT2(cond, msg) /* Nothing */ 62 #define KMP_DEBUG_ASSERT(cond) /* Nothing */ 63 #define KMP_DEBUG_ASSERT2(cond, msg) /* Nothing */ 64 #define KMP_DEBUG_USE_VAR(x) ((void)(x)) 65 #endif // KMP_USE_ASSERT 66 67 #ifdef KMP_DEBUG 68 extern void __kmp_debug_printf_stdout(char const *format, ...); 69 #endif 70 extern void __kmp_debug_printf(char const *format, ...); 71 72 #ifdef KMP_DEBUG 73 74 extern int kmp_a_debug; 75 extern int kmp_b_debug; 76 extern int kmp_c_debug; 77 extern int kmp_d_debug; 78 extern int kmp_e_debug; 79 extern int kmp_f_debug; 80 extern int kmp_diag; 81 82 #define KA_TRACE(d, x) \ 83 if (kmp_a_debug >= d) { \ 84 __kmp_debug_printf x; \ 85 } 86 #define KB_TRACE(d, x) \ 87 if (kmp_b_debug >= d) { \ 88 __kmp_debug_printf x; \ 89 } 90 #define KC_TRACE(d, x) \ 91 if (kmp_c_debug >= d) { \ 92 __kmp_debug_printf x; \ 93 } 94 #define KD_TRACE(d, x) \ 95 if (kmp_d_debug >= d) { \ 96 __kmp_debug_printf x; \ 97 } 98 #define KE_TRACE(d, x) \ 99 if (kmp_e_debug >= d) { \ 100 __kmp_debug_printf x; \ 101 } 102 #define KF_TRACE(d, x) \ 103 if (kmp_f_debug >= d) { \ 104 __kmp_debug_printf x; \ 105 } 106 #define K_DIAG(d, x) \ 107 { \ 108 if (kmp_diag == d) { \ 109 __kmp_debug_printf_stdout x; \ 110 } \ 111 } 112 113 #define KA_DUMP(d, x) \ 114 if (kmp_a_debug >= d) { \ 115 int ks; \ 116 __kmp_disable(&ks); \ 117 (x); \ 118 __kmp_enable(ks); \ 119 } 120 #define KB_DUMP(d, x) \ 121 if (kmp_b_debug >= d) { \ 122 int ks; \ 123 __kmp_disable(&ks); \ 124 (x); \ 125 __kmp_enable(ks); \ 126 } 127 #define KC_DUMP(d, x) \ 128 if (kmp_c_debug >= d) { \ 129 int ks; \ 130 __kmp_disable(&ks); \ 131 (x); \ 132 __kmp_enable(ks); \ 133 } 134 #define KD_DUMP(d, x) \ 135 if (kmp_d_debug >= d) { \ 136 int ks; \ 137 __kmp_disable(&ks); \ 138 (x); \ 139 __kmp_enable(ks); \ 140 } 141 #define KE_DUMP(d, x) \ 142 if (kmp_e_debug >= d) { \ 143 int ks; \ 144 __kmp_disable(&ks); \ 145 (x); \ 146 __kmp_enable(ks); \ 147 } 148 #define KF_DUMP(d, x) \ 149 if (kmp_f_debug >= d) { \ 150 int ks; \ 151 __kmp_disable(&ks); \ 152 (x); \ 153 __kmp_enable(ks); \ 154 } 155 156 #else 157 158 #define KA_TRACE(d, x) /* nothing to do */ 159 #define KB_TRACE(d, x) /* nothing to do */ 160 #define KC_TRACE(d, x) /* nothing to do */ 161 #define KD_TRACE(d, x) /* nothing to do */ 162 #define KE_TRACE(d, x) /* nothing to do */ 163 #define KF_TRACE(d, x) /* nothing to do */ 164 #define K_DIAG(d, x) \ 165 {} /* nothing to do */ 166 167 #define KA_DUMP(d, x) /* nothing to do */ 168 #define KB_DUMP(d, x) /* nothing to do */ 169 #define KC_DUMP(d, x) /* nothing to do */ 170 #define KD_DUMP(d, x) /* nothing to do */ 171 #define KE_DUMP(d, x) /* nothing to do */ 172 #define KF_DUMP(d, x) /* nothing to do */ 173 174 #endif // KMP_DEBUG 175 176 #ifdef __cplusplus 177 } // extern "C" 178 #endif // __cplusplus 179 180 #endif /* KMP_DEBUG_H */ 181