/*
 * 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 */