LLVM OpenMP* Runtime Library
kmp_debug.h
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 */