forked from OSchip/llvm-project
132 lines
5.3 KiB
C
132 lines
5.3 KiB
C
/*
|
|
* kmp_debug.h -- debug / assertion code for Assure library
|
|
*/
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is dual licensed under the MIT and the University of Illinois Open
|
|
// Source Licenses. See LICENSE.txt for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
#ifndef KMP_DEBUG_H
|
|
#define KMP_DEBUG_H
|
|
|
|
#include <stdarg.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif // __cplusplus
|
|
|
|
// -------------------------------------------------------------------------------------------------
|
|
// Build-time assertion.
|
|
// -------------------------------------------------------------------------------------------------
|
|
|
|
/*
|
|
Build-time assertion can do compile-time checking of data structure sizes, etc. This works by
|
|
declaring a negative-length array if the conditional expression evaluates to false. In that
|
|
case, the compiler issues a syntax error and stops the compilation. If the expression is
|
|
true, we get an extraneous static single character array in the scope of the macro.
|
|
|
|
Usage:
|
|
|
|
KMP_BUILD_ASSERT( sizeof( some_t ) <= 32 );
|
|
KMP_BUILD_ASSERT( offsetof( some_t, field ) % 8 == 0 );
|
|
|
|
Do not use _KMP_BUILD_ASSERT and __KMP_BUILD_ASSERT directly, it is working guts.
|
|
*/
|
|
|
|
#define __KMP_BUILD_ASSERT( expr, suffix ) typedef char __kmp_build_check_##suffix[ (expr) ? 1 : -1 ]
|
|
#define _KMP_BUILD_ASSERT( expr, suffix ) __KMP_BUILD_ASSERT( (expr), suffix )
|
|
#ifdef KMP_USE_ASSERT
|
|
#define KMP_BUILD_ASSERT( expr ) _KMP_BUILD_ASSERT( (expr), __LINE__ )
|
|
#else
|
|
#define KMP_BUILD_ASSERT( expr ) /* nothing to do */
|
|
#endif
|
|
|
|
// -------------------------------------------------------------------------------------------------
|
|
// Run-time assertions.
|
|
// -------------------------------------------------------------------------------------------------
|
|
|
|
extern void __kmp_dump_debug_buffer( void );
|
|
|
|
#ifdef KMP_USE_ASSERT
|
|
extern int __kmp_debug_assert( char const * expr, char const * file, int line );
|
|
#ifdef KMP_DEBUG
|
|
#define KMP_ASSERT( cond ) ( (cond) ? 0 : __kmp_debug_assert( #cond, __FILE__, __LINE__ ) )
|
|
#define KMP_ASSERT2( cond, msg ) ( (cond) ? 0 : __kmp_debug_assert( (msg), __FILE__, __LINE__ ) )
|
|
#define KMP_DEBUG_ASSERT( cond ) KMP_ASSERT( cond )
|
|
#define KMP_DEBUG_ASSERT2( cond, msg ) KMP_ASSERT2( cond, msg )
|
|
#else
|
|
// Do not expose condition in release build. Use "assertion failure".
|
|
#define KMP_ASSERT( cond ) ( (cond) ? 0 : __kmp_debug_assert( "assertion failure", __FILE__, __LINE__ ) )
|
|
#define KMP_ASSERT2( cond, msg ) KMP_ASSERT( cond )
|
|
#define KMP_DEBUG_ASSERT( cond ) 0
|
|
#define KMP_DEBUG_ASSERT2( cond, msg ) 0
|
|
#endif // KMP_DEBUG
|
|
#else
|
|
#define KMP_ASSERT( cond ) 0
|
|
#define KMP_ASSERT2( cond, msg ) 0
|
|
#define KMP_DEBUG_ASSERT( cond ) 0
|
|
#define KMP_DEBUG_ASSERT2( cond, msg ) 0
|
|
#endif // KMP_USE_ASSERT
|
|
|
|
#ifdef KMP_DEBUG
|
|
extern void __kmp_debug_printf_stdout( char const * format, ... );
|
|
#endif
|
|
extern void __kmp_debug_printf( char const * format, ... );
|
|
|
|
#ifdef KMP_DEBUG
|
|
|
|
extern int kmp_a_debug;
|
|
extern int kmp_b_debug;
|
|
extern int kmp_c_debug;
|
|
extern int kmp_d_debug;
|
|
extern int kmp_e_debug;
|
|
extern int kmp_f_debug;
|
|
extern int kmp_diag;
|
|
|
|
#define KA_TRACE(d,x) if (kmp_a_debug >= d) { __kmp_debug_printf x ; }
|
|
#define KB_TRACE(d,x) if (kmp_b_debug >= d) { __kmp_debug_printf x ; }
|
|
#define KC_TRACE(d,x) if (kmp_c_debug >= d) { __kmp_debug_printf x ; }
|
|
#define KD_TRACE(d,x) if (kmp_d_debug >= d) { __kmp_debug_printf x ; }
|
|
#define KE_TRACE(d,x) if (kmp_e_debug >= d) { __kmp_debug_printf x ; }
|
|
#define KF_TRACE(d,x) if (kmp_f_debug >= d) { __kmp_debug_printf x ; }
|
|
#define K_DIAG(d,x) {if (kmp_diag == d) { __kmp_debug_printf_stdout x ; } }
|
|
|
|
#define KA_DUMP(d,x) if (kmp_a_debug >= d) { int ks; __kmp_disable(&ks); (x) ; __kmp_enable(ks); }
|
|
#define KB_DUMP(d,x) if (kmp_b_debug >= d) { int ks; __kmp_disable(&ks); (x) ; __kmp_enable(ks); }
|
|
#define KC_DUMP(d,x) if (kmp_c_debug >= d) { int ks; __kmp_disable(&ks); (x) ; __kmp_enable(ks); }
|
|
#define KD_DUMP(d,x) if (kmp_d_debug >= d) { int ks; __kmp_disable(&ks); (x) ; __kmp_enable(ks); }
|
|
#define KE_DUMP(d,x) if (kmp_e_debug >= d) { int ks; __kmp_disable(&ks); (x) ; __kmp_enable(ks); }
|
|
#define KF_DUMP(d,x) if (kmp_f_debug >= d) { int ks; __kmp_disable(&ks); (x) ; __kmp_enable(ks); }
|
|
|
|
#else
|
|
|
|
#define KA_TRACE(d,x) /* nothing to do */
|
|
#define KB_TRACE(d,x) /* nothing to do */
|
|
#define KC_TRACE(d,x) /* nothing to do */
|
|
#define KD_TRACE(d,x) /* nothing to do */
|
|
#define KE_TRACE(d,x) /* nothing to do */
|
|
#define KF_TRACE(d,x) /* nothing to do */
|
|
#define K_DIAG(d,x) {}/* nothing to do */
|
|
|
|
#define KA_DUMP(d,x) /* nothing to do */
|
|
#define KB_DUMP(d,x) /* nothing to do */
|
|
#define KC_DUMP(d,x) /* nothing to do */
|
|
#define KD_DUMP(d,x) /* nothing to do */
|
|
#define KE_DUMP(d,x) /* nothing to do */
|
|
#define KF_DUMP(d,x) /* nothing to do */
|
|
|
|
#endif // KMP_DEBUG
|
|
|
|
#ifdef __cplusplus
|
|
} // extern "C"
|
|
#endif // __cplusplus
|
|
|
|
#endif /* KMP_DEBUG_H */
|