assert.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2012-2020 Seagate Technology LLC and/or its Affiliates
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * For any questions about this software or licensing,
 * please email opensource@seagate.com or cortx-questions@seagate.com.
 *
 */


#pragma once

#ifndef __MOTR_LIB_ASSERT_H__
#define __MOTR_LIB_ASSERT_H__

#include <stddef.h>   /* NULL */
#include <stdarg.h>   /* va_list */

/*
 * Kernel and ansidecl.h define GCC_VERSION in an incompatible way. Use our own
 * definition in the ansidecl.h' format. Since Motr sources can include kernel
 * headers after assert.h, we don't want to re-define kernel's GCC_VERSION.
 * Therefore, name it as M0_GCC_VERSION.
 *
 * Trust GCC_VERSION < 10000, because it is definitely the ansidecl.h' format.
 * We define fake GCC_VERSION for gccxml to disable _Static_assert.
 */
#if defined(GCC_VERSION) && GCC_VERSION < 10000
#define M0_GCC_VERSION GCC_VERSION
#elif defined(__GNUC__) && defined(__GNUC_MINOR__)
#define M0_GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__)
#endif

/* this should be defined before target-specific assert.h is included */
#ifdef M0_NDEBUG
#define M0_ASSERT_OFF (1)
#else
#define M0_ASSERT_OFF (0)
#endif

#ifdef ENABLE_EXPENSIVE_CHECKS
#define M0_ASSERT_EX_ON (1)
#else
#define M0_ASSERT_EX_ON (0)
#endif

/*
 * likely() and unlikely() are defined here rather than in lib/misc.h to avoid
 * circular dependency.
 */
#ifndef likely
#define likely(x)   __builtin_expect(!!(x), 1)
#endif

#ifndef unlikely
#define unlikely(x) __builtin_expect(!!(x), 0)
#endif

struct m0_panic_ctx {
        const char                  *pc_expr;
        const char                  *pc_func;
        const char                  *pc_file;
        int                          pc_lineno;
        const char                  *pc_fmt;
};

void m0_panic(const struct m0_panic_ctx *ctx, ...)
        __attribute__((noreturn));

M0_INTERNAL void m0_panic_only(const struct m0_panic_ctx *ctx, ...)
        __attribute__((noreturn));

M0_INTERNAL void m0_arch_panic(const struct m0_panic_ctx *ctx, va_list ap)
        __attribute__((noreturn));

void m0_backtrace(void);
M0_INTERNAL void m0_arch_backtrace(void);

__attribute__ ((format (printf, 1, 2))) static inline void
printf_check(const char *fmt, ...)
{}

#define M0_ASSERT__INIT(msg, fmt, ...)                 \
        static const struct m0_panic_ctx __pctx = {    \
                msg, __func__, __FILE__, __LINE__, fmt \
        };                                             \
        printf_check(fmt, ##__VA_ARGS__);              \
        m0_assert_intercept()

#define M0_ASSERT_INFO(cond, fmt, ...)                       \
({                                                           \
        M0_ASSERT__INIT(#cond, fmt, ##__VA_ARGS__);          \
        (M0_ASSERT_OFF || likely(cond) ?                     \
                (void)0 : m0_panic(&__pctx, ##__VA_ARGS__)); \
})

#define M0_IMPOSSIBLE(fmt, ...)                                    \
({                                                                 \
        M0_ASSERT__INIT("Impossible", "Impossible happened! " fmt, \
                        ##__VA_ARGS__);                            \
        m0_panic(&__pctx, ##__VA_ARGS__);                          \
})

static inline void m0_assert_intercept(void) {;}

#define M0_ASSERT(cond)  M0_ASSERT_INFO((cond), NULL)

#define M0_ASSERT_EX(cond)              \
({                                      \
        if (M0_ASSERT_EX_ON)            \
                M0_ASSERT(cond);        \
})

#define M0_ASSERT_INFO_EX(cond, fmt, ...)                       \
({                                                              \
        if (M0_ASSERT_EX_ON)                                    \
                M0_ASSERT_INFO((cond), (fmt), ##__VA_ARGS__);   \
})

#define M0_PRE(cond) M0_ASSERT(cond)

#define M0_PRE_EX(cond) M0_ASSERT_EX(cond)

#define M0_POST(cond) M0_ASSERT(cond)

#define M0_POST_EX(cond) M0_ASSERT_EX(cond)

#define M0_INVARIANT_EX(cond) M0_ASSERT_EX(cond)

#define M0_CHECK_EX(cond) (!M0_ASSERT_EX_ON || (cond))

#define M0_CASSERT(cond) do { switch (1) {case 0: case !!(cond): ;} } while (0)

#if defined (__cplusplus) && __cplusplus >= 201103L
# define M0_BASSERT(cond) static_assert((cond), #cond)
#elif defined (M0_GCC_VERSION) && M0_GCC_VERSION >= 4006
# define M0_BASSERT(cond) _Static_assert((cond), #cond)
#else
# define M0_BASSERT(cond) extern char __static_assertion[(cond) ? 1 : -1]
#endif

M0_EXTERN const char *m0_failed_condition;

M0_INTERNAL void m0__assertion_hook(void);

#define _0C(exp)                                            \
({                                                          \
        bool __exp = (exp);                                 \
        if (!M0_ASSERT_OFF) {                               \
                if (__exp) {                                \
                        m0_failed_condition = NULL;         \
                } else {                                    \
                        if (m0_failed_condition == NULL)    \
                                m0_failed_condition = #exp; \
                        m0__assertion_hook();               \
                }                                           \
        }                                                   \
        __exp;                                              \
})

M0_INTERNAL void m0_debugger_invoke(void);

/* __MOTR_LIB_ASSERT_H__ */
#endif

/*
 *  Local variables:
 *  c-indentation-style: "K&R"
 *  c-basic-offset: 8
 *  tab-width: 8
 *  fill-column: 80
 *  scroll-step: 1
 *  End:
 */