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 ((cond) ? 0 : __kmp_debug_assert(#cond, __FILE__, __LINE__)) 39 #define KMP_ASSERT2(cond, msg) \ 40 ((cond) ? 0 : __kmp_debug_assert((msg), __FILE__, __LINE__)) 41 #define KMP_DEBUG_ASSERT(cond) KMP_ASSERT(cond) 42 #define KMP_DEBUG_ASSERT2(cond, msg) KMP_ASSERT2(cond, msg) 43 #else 44 // Do not expose condition in release build. Use "assertion failure". 45 #define KMP_ASSERT(cond) \ 46 ((cond) ? 0 : __kmp_debug_assert("assertion failure", __FILE__, __LINE__)) 47 #define KMP_ASSERT2(cond, msg) KMP_ASSERT(cond) 48 #define KMP_DEBUG_ASSERT(cond) 0 49 #define KMP_DEBUG_ASSERT2(cond, msg) 0 50 #endif // KMP_DEBUG 51 #else 52 #define KMP_ASSERT(cond) 0 53 #define KMP_ASSERT2(cond, msg) 0 54 #define KMP_DEBUG_ASSERT(cond) 0 55 #define KMP_DEBUG_ASSERT2(cond, msg) 0 56 #endif // KMP_USE_ASSERT 57 58 #ifdef KMP_DEBUG 59 extern void __kmp_debug_printf_stdout(char const *format, ...); 60 #endif 61 extern void __kmp_debug_printf(char const *format, ...); 62 63 #ifdef KMP_DEBUG 64 65 extern int kmp_a_debug; 66 extern int kmp_b_debug; 67 extern int kmp_c_debug; 68 extern int kmp_d_debug; 69 extern int kmp_e_debug; 70 extern int kmp_f_debug; 71 extern int kmp_diag; 72 73 #define KA_TRACE(d, x) \ 74 if (kmp_a_debug >= d) { \ 75 __kmp_debug_printf x; \ 76 } 77 #define KB_TRACE(d, x) \ 78 if (kmp_b_debug >= d) { \ 79 __kmp_debug_printf x; \ 80 } 81 #define KC_TRACE(d, x) \ 82 if (kmp_c_debug >= d) { \ 83 __kmp_debug_printf x; \ 84 } 85 #define KD_TRACE(d, x) \ 86 if (kmp_d_debug >= d) { \ 87 __kmp_debug_printf x; \ 88 } 89 #define KE_TRACE(d, x) \ 90 if (kmp_e_debug >= d) { \ 91 __kmp_debug_printf x; \ 92 } 93 #define KF_TRACE(d, x) \ 94 if (kmp_f_debug >= d) { \ 95 __kmp_debug_printf x; \ 96 } 97 #define K_DIAG(d, x) \ 98 { \ 99 if (kmp_diag == d) { \ 100 __kmp_debug_printf_stdout x; \ 101 } \ 102 } 103 104 #define KA_DUMP(d, x) \ 105 if (kmp_a_debug >= d) { \ 106 int ks; \ 107 __kmp_disable(&ks); \ 108 (x); \ 109 __kmp_enable(ks); \ 110 } 111 #define KB_DUMP(d, x) \ 112 if (kmp_b_debug >= d) { \ 113 int ks; \ 114 __kmp_disable(&ks); \ 115 (x); \ 116 __kmp_enable(ks); \ 117 } 118 #define KC_DUMP(d, x) \ 119 if (kmp_c_debug >= d) { \ 120 int ks; \ 121 __kmp_disable(&ks); \ 122 (x); \ 123 __kmp_enable(ks); \ 124 } 125 #define KD_DUMP(d, x) \ 126 if (kmp_d_debug >= d) { \ 127 int ks; \ 128 __kmp_disable(&ks); \ 129 (x); \ 130 __kmp_enable(ks); \ 131 } 132 #define KE_DUMP(d, x) \ 133 if (kmp_e_debug >= d) { \ 134 int ks; \ 135 __kmp_disable(&ks); \ 136 (x); \ 137 __kmp_enable(ks); \ 138 } 139 #define KF_DUMP(d, x) \ 140 if (kmp_f_debug >= d) { \ 141 int ks; \ 142 __kmp_disable(&ks); \ 143 (x); \ 144 __kmp_enable(ks); \ 145 } 146 147 #else 148 149 #define KA_TRACE(d, x) /* nothing to do */ 150 #define KB_TRACE(d, x) /* nothing to do */ 151 #define KC_TRACE(d, x) /* nothing to do */ 152 #define KD_TRACE(d, x) /* nothing to do */ 153 #define KE_TRACE(d, x) /* nothing to do */ 154 #define KF_TRACE(d, x) /* nothing to do */ 155 #define K_DIAG(d, x) \ 156 {} /* nothing to do */ 157 158 #define KA_DUMP(d, x) /* nothing to do */ 159 #define KB_DUMP(d, x) /* nothing to do */ 160 #define KC_DUMP(d, x) /* nothing to do */ 161 #define KD_DUMP(d, x) /* nothing to do */ 162 #define KE_DUMP(d, x) /* nothing to do */ 163 #define KF_DUMP(d, x) /* nothing to do */ 164 165 #endif // KMP_DEBUG 166 167 #ifdef __cplusplus 168 } // extern "C" 169 #endif // __cplusplus 170 171 #endif /* KMP_DEBUG_H */ 172