LLVM OpenMP* Runtime Library
kmp_debug.h
1 /*
2  * kmp_debug.h -- debug / assertion code for Assure library
3  */
4 
5 
6 //===----------------------------------------------------------------------===//
7 //
8 // The LLVM Compiler Infrastructure
9 //
10 // This file is dual licensed under the MIT and the University of Illinois Open
11 // Source Licenses. See LICENSE.txt for details.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 
16 #ifndef KMP_DEBUG_H
17 #define KMP_DEBUG_H
18 
19 #include <stdarg.h>
20 
21 #ifdef __cplusplus
22  extern "C" {
23 #endif // __cplusplus
24 
25 // -------------------------------------------------------------------------------------------------
26 // Build-time assertion.
27 // -------------------------------------------------------------------------------------------------
28 
29 /*
30  Build-time assertion can do compile-time checking of data structure sizes, etc. This works by
31  declaring a negative-length array if the conditional expression evaluates to false. In that
32  case, the compiler issues a syntax error and stops the compilation. If the expression is
33  true, we get an extraneous static single character array in the scope of the macro.
34 
35  Usage:
36 
37  KMP_BUILD_ASSERT( sizeof( some_t ) <= 32 );
38  KMP_BUILD_ASSERT( offsetof( some_t, field ) % 8 == 0 );
39 
40  Do not use _KMP_BUILD_ASSERT and __KMP_BUILD_ASSERT directly, it is working guts.
41 */
42 
43 #define __KMP_BUILD_ASSERT( expr, suffix ) typedef char __kmp_build_check_##suffix[ (expr) ? 1 : -1 ]
44 #define _KMP_BUILD_ASSERT( expr, suffix ) __KMP_BUILD_ASSERT( (expr), suffix )
45 #ifdef KMP_USE_ASSERT
46  #define KMP_BUILD_ASSERT( expr ) _KMP_BUILD_ASSERT( (expr), __LINE__ )
47 #else
48  #define KMP_BUILD_ASSERT( expr ) /* nothing to do */
49 #endif
50 
51 // -------------------------------------------------------------------------------------------------
52 // Run-time assertions.
53 // -------------------------------------------------------------------------------------------------
54 
55 extern void __kmp_dump_debug_buffer( void );
56 
57 #ifdef KMP_USE_ASSERT
58  extern int __kmp_debug_assert( char const * expr, char const * file, int line );
59  #ifdef KMP_DEBUG
60  #define KMP_ASSERT( cond ) ( (cond) ? 0 : __kmp_debug_assert( #cond, __FILE__, __LINE__ ) )
61  #define KMP_ASSERT2( cond, msg ) ( (cond) ? 0 : __kmp_debug_assert( (msg), __FILE__, __LINE__ ) )
62  #define KMP_DEBUG_ASSERT( cond ) KMP_ASSERT( cond )
63  #define KMP_DEBUG_ASSERT2( cond, msg ) KMP_ASSERT2( cond, msg )
64  #else
65  // Do not expose condition in release build. Use "assertion failure".
66  #define KMP_ASSERT( cond ) ( (cond) ? 0 : __kmp_debug_assert( "assertion failure", __FILE__, __LINE__ ) )
67  #define KMP_ASSERT2( cond, msg ) KMP_ASSERT( cond )
68  #define KMP_DEBUG_ASSERT( cond ) 0
69  #define KMP_DEBUG_ASSERT2( cond, msg ) 0
70  #endif // KMP_DEBUG
71 #else
72  #define KMP_ASSERT( cond ) 0
73  #define KMP_ASSERT2( cond, msg ) 0
74  #define KMP_DEBUG_ASSERT( cond ) 0
75  #define KMP_DEBUG_ASSERT2( cond, msg ) 0
76 #endif // KMP_USE_ASSERT
77 
78 #ifdef KMP_DEBUG
79  extern void __kmp_debug_printf_stdout( char const * format, ... );
80 #endif
81 extern void __kmp_debug_printf( char const * format, ... );
82 
83 #ifdef KMP_DEBUG
84 
85  extern int kmp_a_debug;
86  extern int kmp_b_debug;
87  extern int kmp_c_debug;
88  extern int kmp_d_debug;
89  extern int kmp_e_debug;
90  extern int kmp_f_debug;
91  extern int kmp_diag;
92 
93  #define KA_TRACE(d,x) if (kmp_a_debug >= d) { __kmp_debug_printf x ; }
94  #define KB_TRACE(d,x) if (kmp_b_debug >= d) { __kmp_debug_printf x ; }
95  #define KC_TRACE(d,x) if (kmp_c_debug >= d) { __kmp_debug_printf x ; }
96  #define KD_TRACE(d,x) if (kmp_d_debug >= d) { __kmp_debug_printf x ; }
97  #define KE_TRACE(d,x) if (kmp_e_debug >= d) { __kmp_debug_printf x ; }
98  #define KF_TRACE(d,x) if (kmp_f_debug >= d) { __kmp_debug_printf x ; }
99  #define K_DIAG(d,x) {if (kmp_diag == d) { __kmp_debug_printf_stdout x ; } }
100 
101  #define KA_DUMP(d,x) if (kmp_a_debug >= d) { int ks; __kmp_disable(&ks); (x) ; __kmp_enable(ks); }
102  #define KB_DUMP(d,x) if (kmp_b_debug >= d) { int ks; __kmp_disable(&ks); (x) ; __kmp_enable(ks); }
103  #define KC_DUMP(d,x) if (kmp_c_debug >= d) { int ks; __kmp_disable(&ks); (x) ; __kmp_enable(ks); }
104  #define KD_DUMP(d,x) if (kmp_d_debug >= d) { int ks; __kmp_disable(&ks); (x) ; __kmp_enable(ks); }
105  #define KE_DUMP(d,x) if (kmp_e_debug >= d) { int ks; __kmp_disable(&ks); (x) ; __kmp_enable(ks); }
106  #define KF_DUMP(d,x) if (kmp_f_debug >= d) { int ks; __kmp_disable(&ks); (x) ; __kmp_enable(ks); }
107 
108 #else
109 
110  #define KA_TRACE(d,x) /* nothing to do */
111  #define KB_TRACE(d,x) /* nothing to do */
112  #define KC_TRACE(d,x) /* nothing to do */
113  #define KD_TRACE(d,x) /* nothing to do */
114  #define KE_TRACE(d,x) /* nothing to do */
115  #define KF_TRACE(d,x) /* nothing to do */
116  #define K_DIAG(d,x) {}/* nothing to do */
117 
118  #define KA_DUMP(d,x) /* nothing to do */
119  #define KB_DUMP(d,x) /* nothing to do */
120  #define KC_DUMP(d,x) /* nothing to do */
121  #define KD_DUMP(d,x) /* nothing to do */
122  #define KE_DUMP(d,x) /* nothing to do */
123  #define KF_DUMP(d,x) /* nothing to do */
124 
125 #endif // KMP_DEBUG
126 
127 #ifdef __cplusplus
128  } // extern "C"
129 #endif // __cplusplus
130 
131 #endif /* KMP_DEBUG_H */