[mirror_zfs.git] / lib / libspl / include / assert.h

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or https://opensource.org/licenses/CDDL-1.0.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include_next <assert.h>

#ifndef _LIBSPL_ASSERT_H
#define	_LIBSPL_ASSERT_H

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <sys/types.h>

/* Workaround for non-Clang compilers */
#ifndef __has_feature
#define	__has_feature(x) 0
#endif

/* We need to workaround libspl_set_assert_ok() that we have for zdb */
#if __has_feature(attribute_analyzer_noreturn) || defined(__COVERITY__)
#define	NORETURN	__attribute__((__noreturn__))
#else
#define	NORETURN
#endif

/* Set to non-zero to avoid abort()ing on an assertion failure */
extern void libspl_set_assert_ok(boolean_t val);

/* printf version of libspl_assert */
extern void libspl_assertf(const char *file, const char *func, int line,
    const char *format, ...) NORETURN __attribute__((format(printf, 4, 5)));

static inline int
libspl_assert(const char *buf, const char *file, const char *func, int line)
{
	libspl_assertf(file, func, line, "%s", buf);
	return (0);
}

#ifdef verify
#undef verify
#endif

#define	PANIC(fmt, a...)						\
	libspl_assertf(__FILE__, __FUNCTION__, __LINE__, fmt, ## a)

#define	VERIFY(cond)							\
	(void) ((!(cond)) &&						\
	    libspl_assert(#cond, __FILE__, __FUNCTION__, __LINE__))

#define	VERIFYF(cond, STR, ...)						\
do {									\
	if (!(cond))							\
		libspl_assertf(__FILE__, __FUNCTION__, __LINE__,	\
		    "%s " STR, #cond,					\
		    __VA_ARGS__);					\
} while (0)

#define	verify(cond)							\
	(void) ((!(cond)) &&						\
	    libspl_assert(#cond, __FILE__, __FUNCTION__, __LINE__))

#define	VERIFY3B(LEFT, OP, RIGHT)					\
do {									\
	const boolean_t __left = (boolean_t)(LEFT);			\
	const boolean_t __right = (boolean_t)(RIGHT);			\
	if (!(__left OP __right))					\
		libspl_assertf(__FILE__, __FUNCTION__, __LINE__,	\
		    "%s %s %s (0x%llx %s 0x%llx)", #LEFT, #OP, #RIGHT,	\
		    (u_longlong_t)__left, #OP, (u_longlong_t)__right);	\
} while (0)

#define	VERIFY3S(LEFT, OP, RIGHT)					\
do {									\
	const int64_t __left = (int64_t)(LEFT);				\
	const int64_t __right = (int64_t)(RIGHT);			\
	if (!(__left OP __right))					\
		libspl_assertf(__FILE__, __FUNCTION__, __LINE__,	\
		    "%s %s %s (0x%llx %s 0x%llx)", #LEFT, #OP, #RIGHT,	\
		    (u_longlong_t)__left, #OP, (u_longlong_t)__right);	\
} while (0)

#define	VERIFY3U(LEFT, OP, RIGHT)					\
do {									\
	const uint64_t __left = (uint64_t)(LEFT);			\
	const uint64_t __right = (uint64_t)(RIGHT);			\
	if (!(__left OP __right))					\
		libspl_assertf(__FILE__, __FUNCTION__, __LINE__,	\
		    "%s %s %s (0x%llx %s 0x%llx)", #LEFT, #OP, #RIGHT,	\
		    (u_longlong_t)__left, #OP, (u_longlong_t)__right);	\
} while (0)

#define	VERIFY3P(LEFT, OP, RIGHT)					\
do {									\
	const uintptr_t __left = (uintptr_t)(LEFT);			\
	const uintptr_t __right = (uintptr_t)(RIGHT);			\
	if (!(__left OP __right))					\
		libspl_assertf(__FILE__, __FUNCTION__, __LINE__,	\
		    "%s %s %s (%p %s %p)", #LEFT, #OP, #RIGHT,		\
		    (void *)__left, #OP, (void *)__right);		\
} while (0)

#define	VERIFY0(LEFT)							\
do {									\
	const uint64_t __left = (uint64_t)(LEFT);			\
	if (!(__left == 0))						\
		libspl_assertf(__FILE__, __FUNCTION__, __LINE__,	\
		    "%s == 0 (0x%llx == 0)", #LEFT,			\
		    (u_longlong_t)__left);				\
} while (0)

#define	VERIFY0P(LEFT)							\
do {									\
	const uintptr_t __left = (uintptr_t)(LEFT);			\
	if (!(__left == 0))						\
		libspl_assertf(__FILE__, __FUNCTION__, __LINE__,	\
		    "%s == 0 (%p == 0)", #LEFT,				\
		    (void *)__left);					\
} while (0)

/*
 * This is just here because cstyle gets upset about #LEFT
 * on a newline.
 */

/* BEGIN CSTYLED */
#define	VERIFY3BF(LEFT, OP, RIGHT, STR, ...)				\
do {									\
	const boolean_t __left = (boolean_t)(LEFT);			\
	const boolean_t __right = (boolean_t)(RIGHT);			\
	if (!(__left OP __right))					\
		libspl_assertf(__FILE__, __FUNCTION__, __LINE__,	\
		    "%s %s %s (0x%llx %s 0x%llx) " STR,			\
		    #LEFT, #OP, #RIGHT,					\
		    (u_longlong_t)__left, #OP, (u_longlong_t)__right,	\
		    __VA_ARGS__);					\
} while (0)

#define	VERIFY3SF(LEFT, OP, RIGHT, STR, ...)				\
do {									\
	const int64_t __left = (int64_t)(LEFT);				\
	const int64_t __right = (int64_t)(RIGHT);			\
	if (!(__left OP __right))					\
		libspl_assertf(__FILE__, __FUNCTION__, __LINE__,	\
		    "%s %s %s (0x%llx %s 0x%llx) " STR,			\
		    #LEFT, #OP, #RIGHT,					\
		    (u_longlong_t)__left, #OP, (u_longlong_t)__right,	\
		    __VA_ARGS__);					\
} while (0)

#define	VERIFY3UF(LEFT, OP, RIGHT, STR, ...)				\
do {									\
	const uint64_t __left = (uint64_t)(LEFT);			\
	const uint64_t __right = (uint64_t)(RIGHT);			\
	if (!(__left OP __right))					\
		libspl_assertf(__FILE__, __FUNCTION__, __LINE__,	\
		    "%s %s %s (0x%llx %s 0x%llx) " STR,			\
		    #LEFT, #OP, #RIGHT,					\
		    (u_longlong_t)__left, #OP, (u_longlong_t)__right,	\
		    __VA_ARGS__);					\
} while (0)

#define	VERIFY3PF(LEFT, OP, RIGHT, STR, ...)				\
do {									\
	const uintptr_t __left = (uintptr_t)(LEFT);			\
	const uintptr_t __right = (uintptr_t)(RIGHT);			\
	if (!(__left OP __right))					\
		libspl_assertf(__FILE__, __FUNCTION__, __LINE__,	\
		    "%s %s %s (0x%llx %s 0x%llx) " STR,			\
		    #LEFT, #OP, #RIGHT,					\
		    (u_longlong_t)__left, #OP, (u_longlong_t)__right,	\
		    __VA_ARGS__);					\
} while (0)
/* END CSTYLED */

#define	VERIFY0F(LEFT, STR, ...)					\
do {									\
	const uint64_t __left = (uint64_t)(LEFT);			\
	if (!(__left == 0))						\
		libspl_assertf(__FILE__, __FUNCTION__, __LINE__,	\
		    "%s == 0 (0x%llx == 0) " STR, #LEFT,		\
		    (u_longlong_t)__left, __VA_ARGS__);			\
} while (0)

#define	VERIFY0PF(LEFT, STR, ...)					\
do {									\
	const uintptr_t __left = (uintptr_t)(LEFT);			\
	if (!(__left == 0))						\
		libspl_assertf(__FILE__, __FUNCTION__, __LINE__,	\
		    "%s == 0 (%p == 0) " STR, #LEFT,			\
		    (u_longlong_t)__left, __VA_ARGS__);			\
} while (0)

#ifdef assert
#undef assert
#endif

#ifdef NDEBUG
#define	ASSERT3B(x, y, z)						\
	((void) sizeof ((uintptr_t)(x)), (void) sizeof ((uintptr_t)(z)))
#define	ASSERT3S(x, y, z)						\
	((void) sizeof ((uintptr_t)(x)), (void) sizeof ((uintptr_t)(z)))
#define	ASSERT3U(x, y, z)						\
	((void) sizeof ((uintptr_t)(x)), (void) sizeof ((uintptr_t)(z)))
#define	ASSERT3P(x, y, z)						\
	((void) sizeof ((uintptr_t)(x)), (void) sizeof ((uintptr_t)(z)))
#define	ASSERT0(x)		((void) sizeof ((uintptr_t)(x)))
#define	ASSERT0P(x)		((void) sizeof ((uintptr_t)(x)))
#define	ASSERT3BF(x, y, z, str, ...)	ASSERT3B(x, y, z)
#define	ASSERT3SF(x, y, z, str, ...)	ASSERT3S(x, y, z)
#define	ASSERT3UF(x, y, z, str, ...)	ASSERT3U(x, y, z)
#define	ASSERT3PF(x, y, z, str, ...)	ASSERT3P(x, y, z)
#define	ASSERT0P(x)		((void) sizeof ((uintptr_t)(x)))
#define	ASSERT0PF(x, str, ...)		ASSERT0P(x)
#define	ASSERT0F(x, str, ...)		ASSERT0(x)
#define	ASSERT(x)		((void) sizeof ((uintptr_t)(x)))
#define	ASSERTF(x, str, ...)	ASSERT(x)
#define	assert(x)		((void) sizeof ((uintptr_t)(x)))
#define	IMPLY(A, B)							\
	((void) sizeof ((uintptr_t)(A)), (void) sizeof ((uintptr_t)(B)))
#define	EQUIV(A, B)							\
	((void) sizeof ((uintptr_t)(A)), (void) sizeof ((uintptr_t)(B)))
#else
#define	ASSERT3B	VERIFY3B
#define	ASSERT3S	VERIFY3S
#define	ASSERT3U	VERIFY3U
#define	ASSERT3P	VERIFY3P
#define	ASSERT0		VERIFY0
#define	ASSERT0P	VERIFY0P
#define	ASSERT3BF	VERIFY3BF
#define	ASSERT3SF	VERIFY3SF
#define	ASSERT3UF	VERIFY3UF
#define	ASSERT3PF	VERIFY3PF
#define	ASSERT0PF	VERIFY0PF
#define	ASSERT0F	VERIFY0F
#define	ASSERT		VERIFY
#define	ASSERTF		VERIFYF
#define	assert		VERIFY
#define	IMPLY(A, B) \
	((void)(((!(A)) || (B)) || \
	    libspl_assert("(" #A ") implies (" #B ")", \
	    __FILE__, __FUNCTION__, __LINE__)))
#define	EQUIV(A, B) \
	((void)((!!(A) == !!(B)) || \
	    libspl_assert("(" #A ") is equivalent to (" #B ")", \
	    __FILE__, __FUNCTION__, __LINE__)))

#endif  /* NDEBUG */

#endif  /* _LIBSPL_ASSERT_H */
Commit	Line	Data
a26baf28 BB	1	/*
	2	* CDDL HEADER START
	3	*
	4	* The contents of this file are subject to the terms of the
	5	* Common Development and Distribution License, Version 1.0 only
	6	* (the "License"). You may not use this file except in compliance
	7	* with the License.
	8	*
	9	* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
1d3ba0bf	10	* or https://opensource.org/licenses/CDDL-1.0.
a26baf28 BB	11	* See the License for the specific language governing permissions
	12	* and limitations under the License.
	13	*
	14	* When distributing Covered Code, include this CDDL HEADER in each
	15	* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
	16	* If applicable, add the following below this CDDL HEADER, with the
	17	* fields enclosed by brackets "[]" replaced with your own identifying
	18	* information: Portions Copyright [yyyy] [name of copyright owner]
	19	*
	20	* CDDL HEADER END
	21	*/
	22	/*
	23	* Copyright 2007 Sun Microsystems, Inc. All rights reserved.
	24	* Use is subject to license terms.
	25	*/
	26
	27	#include_next <assert.h>
	28
	29	#ifndef _LIBSPL_ASSERT_H
d1d7e268	30	#define _LIBSPL_ASSERT_H
a26baf28 BB	31
	32	#include <stdio.h>
	33	#include <stdlib.h>
478e3ecf	34	#include <stdarg.h>
63652e15	35	#include <sys/types.h>
a26baf28	36
55d7afa4 RY	37	/* Workaround for non-Clang compilers */
	38	#ifndef __has_feature
	39	#define __has_feature(x) 0
	40	#endif
	41
	42	/* We need to workaround libspl_set_assert_ok() that we have for zdb */
	43	#if __has_feature(attribute_analyzer_noreturn) \|\| defined(__COVERITY__)
	44	#define NORETURN __attribute__((__noreturn__))
	45	#else
	46	#define NORETURN
	47	#endif
	48
b6437ea4	49	/* Set to non-zero to avoid abort()ing on an assertion failure */
63652e15	50	extern void libspl_set_assert_ok(boolean_t val);
b6437ea4 AS	51
	52	/* printf version of libspl_assert */
	53	extern void libspl_assertf(const char file, const char func, int line,
55d7afa4	54	const char *format, ...) NORETURN __attribute__((format(printf, 4, 5)));
7c1bf0cf	55
726c4a25 BB	56	static inline int
726c4a25 BB	57	libspl_assert(const char buf, const char file, const char *func, int line)
a26baf28	58	{
b6437ea4 AS	59	libspl_assertf(file, func, line, "%s", buf);
b6437ea4 AS	60	return (0);
682ce104 TH	61	}
682ce104 TH	62
726c4a25 BB	63	#ifdef verify
	64	#undef verify
	65	#endif
a26baf28	66
adcea23c AM	67	#define PANIC(fmt, a...) \
	68	libspl_assertf(__FILE__, __FUNCTION__, __LINE__, fmt, ## a)
	69
726c4a25 BB	70	#define VERIFY(cond) \
	71	(void) ((!(cond)) && \
	72	libspl_assert(#cond, __FILE__, __FUNCTION__, __LINE__))
e5e2a5a3 RE	73
	74	#define VERIFYF(cond, STR, ...) \
	75	do { \
	76	if (!(cond)) \
	77	libspl_assertf(__FILE__, __FUNCTION__, __LINE__, \
	78	"%s " STR, #cond, \
	79	__VA_ARGS__); \
	80	} while (0)
	81
726c4a25 BB	82	#define verify(cond) \
	83	(void) ((!(cond)) && \
	84	libspl_assert(#cond, __FILE__, __FUNCTION__, __LINE__))
a26baf28	85
6e8b2688	86	#define VERIFY3B(LEFT, OP, RIGHT) \
726c4a25	87	do { \
6e8b2688 PD	88	const boolean_t __left = (boolean_t)(LEFT); \
6e8b2688 PD	89	const boolean_t __right = (boolean_t)(RIGHT); \
682ce104 TH	90	if (!(__left OP __right)) \
682ce104 TH	91	libspl_assertf(__FILE__, __FUNCTION__, __LINE__, \
314be68a TC	92	"%s %s %s (0x%llx %s 0x%llx)", #LEFT, #OP, #RIGHT, \
314be68a TC	93	(u_longlong_t)__left, #OP, (u_longlong_t)__right); \
a26baf28	94	} while (0)
a26baf28	95
6e8b2688 PD	96	#define VERIFY3S(LEFT, OP, RIGHT) \
	97	do { \
	98	const int64_t __left = (int64_t)(LEFT); \
	99	const int64_t __right = (int64_t)(RIGHT); \
	100	if (!(__left OP __right)) \
	101	libspl_assertf(__FILE__, __FUNCTION__, __LINE__, \
	102	"%s %s %s (0x%llx %s 0x%llx)", #LEFT, #OP, #RIGHT, \
	103	(u_longlong_t)__left, #OP, (u_longlong_t)__right); \
	104	} while (0)
	105
	106	#define VERIFY3U(LEFT, OP, RIGHT) \
	107	do { \
	108	const uint64_t __left = (uint64_t)(LEFT); \
	109	const uint64_t __right = (uint64_t)(RIGHT); \
	110	if (!(__left OP __right)) \
	111	libspl_assertf(__FILE__, __FUNCTION__, __LINE__, \
	112	"%s %s %s (0x%llx %s 0x%llx)", #LEFT, #OP, #RIGHT, \
	113	(u_longlong_t)__left, #OP, (u_longlong_t)__right); \
	114	} while (0)
	115
	116	#define VERIFY3P(LEFT, OP, RIGHT) \
	117	do { \
	118	const uintptr_t __left = (uintptr_t)(LEFT); \
	119	const uintptr_t __right = (uintptr_t)(RIGHT); \
	120	if (!(__left OP __right)) \
	121	libspl_assertf(__FILE__, __FUNCTION__, __LINE__, \
01d9283a DES	122	"%s %s %s (%p %s %p)", #LEFT, #OP, #RIGHT, \
01d9283a DES	123	(void )__left, #OP, (void )__right); \
6e8b2688 PD	124	} while (0)
	125
	126	#define VERIFY0(LEFT) \
	127	do { \
	128	const uint64_t __left = (uint64_t)(LEFT); \
	129	if (!(__left == 0)) \
	130	libspl_assertf(__FILE__, __FUNCTION__, __LINE__, \
	131	"%s == 0 (0x%llx == 0)", #LEFT, \
	132	(u_longlong_t)__left); \
	133	} while (0)
a26baf28	134
506fe78c DES	135	#define VERIFY0P(LEFT) \
	136	do { \
	137	const uintptr_t __left = (uintptr_t)(LEFT); \
	138	if (!(__left == 0)) \
	139	libspl_assertf(__FILE__, __FUNCTION__, __LINE__, \
	140	"%s == 0 (%p == 0)", #LEFT, \
	141	(void *)__left); \
	142	} while (0)
	143
e5e2a5a3 RE	144	/*
	145	* This is just here because cstyle gets upset about #LEFT
	146	* on a newline.
	147	*/
	148
	149	/* BEGIN CSTYLED */
	150	#define VERIFY3BF(LEFT, OP, RIGHT, STR, ...) \
	151	do { \
	152	const boolean_t __left = (boolean_t)(LEFT); \
	153	const boolean_t __right = (boolean_t)(RIGHT); \
	154	if (!(__left OP __right)) \
	155	libspl_assertf(__FILE__, __FUNCTION__, __LINE__, \
	156	"%s %s %s (0x%llx %s 0x%llx) " STR, \
	157	#LEFT, #OP, #RIGHT, \
	158	(u_longlong_t)__left, #OP, (u_longlong_t)__right, \
	159	__VA_ARGS__); \
	160	} while (0)
	161
	162	#define VERIFY3SF(LEFT, OP, RIGHT, STR, ...) \
	163	do { \
	164	const int64_t __left = (int64_t)(LEFT); \
	165	const int64_t __right = (int64_t)(RIGHT); \
	166	if (!(__left OP __right)) \
	167	libspl_assertf(__FILE__, __FUNCTION__, __LINE__, \
	168	"%s %s %s (0x%llx %s 0x%llx) " STR, \
	169	#LEFT, #OP, #RIGHT, \
	170	(u_longlong_t)__left, #OP, (u_longlong_t)__right, \
	171	__VA_ARGS__); \
	172	} while (0)
	173
	174	#define VERIFY3UF(LEFT, OP, RIGHT, STR, ...) \
	175	do { \
	176	const uint64_t __left = (uint64_t)(LEFT); \
	177	const uint64_t __right = (uint64_t)(RIGHT); \
	178	if (!(__left OP __right)) \
	179	libspl_assertf(__FILE__, __FUNCTION__, __LINE__, \
	180	"%s %s %s (0x%llx %s 0x%llx) " STR, \
	181	#LEFT, #OP, #RIGHT, \
	182	(u_longlong_t)__left, #OP, (u_longlong_t)__right, \
	183	__VA_ARGS__); \
	184	} while (0)
	185
	186	#define VERIFY3PF(LEFT, OP, RIGHT, STR, ...) \
	187	do { \
	188	const uintptr_t __left = (uintptr_t)(LEFT); \
	189	const uintptr_t __right = (uintptr_t)(RIGHT); \
	190	if (!(__left OP __right)) \
	191	libspl_assertf(__FILE__, __FUNCTION__, __LINE__, \
	192	"%s %s %s (0x%llx %s 0x%llx) " STR, \
	193	#LEFT, #OP, #RIGHT, \
	194	(u_longlong_t)__left, #OP, (u_longlong_t)__right, \
	195	__VA_ARGS__); \
	196	} while (0)
	197	/* END CSTYLED */
	198
	199	#define VERIFY0F(LEFT, STR, ...) \
	200	do { \
	201	const uint64_t __left = (uint64_t)(LEFT); \
	202	if (!(__left == 0)) \
	203	libspl_assertf(__FILE__, __FUNCTION__, __LINE__, \
	204	"%s == 0 (0x%llx == 0) " STR, #LEFT, \
	205	(u_longlong_t)__left, __VA_ARGS__); \
	206	} while (0)
	207
208	#define VERIFY0PF(LEFT, STR, ...) \
209	do { \
210	const uintptr_t __left = (uintptr_t)(LEFT); \
211	if (!(__left == 0)) \
212	libspl_assertf(__FILE__, __FUNCTION__, __LINE__, \
213	"%s == 0 (%p == 0) " STR, #LEFT, \
214	(u_longlong_t)__left, __VA_ARGS__); \
215	} while (0)
216
726c4a25 BB	217	#ifdef assert
	218	#undef assert
	219	#endif
	220
a26baf28	221	#ifdef NDEBUG
a9e2788f AZ	222	#define ASSERT3B(x, y, z) \
	223	((void) sizeof ((uintptr_t)(x)), (void) sizeof ((uintptr_t)(z)))
	224	#define ASSERT3S(x, y, z) \
	225	((void) sizeof ((uintptr_t)(x)), (void) sizeof ((uintptr_t)(z)))
	226	#define ASSERT3U(x, y, z) \
	227	((void) sizeof ((uintptr_t)(x)), (void) sizeof ((uintptr_t)(z)))
	228	#define ASSERT3P(x, y, z) \
	229	((void) sizeof ((uintptr_t)(x)), (void) sizeof ((uintptr_t)(z)))
	230	#define ASSERT0(x) ((void) sizeof ((uintptr_t)(x)))
506fe78c	231	#define ASSERT0P(x) ((void) sizeof ((uintptr_t)(x)))
e5e2a5a3 RE	232	#define ASSERT3BF(x, y, z, str, ...) ASSERT3B(x, y, z)
	233	#define ASSERT3SF(x, y, z, str, ...) ASSERT3S(x, y, z)
	234	#define ASSERT3UF(x, y, z, str, ...) ASSERT3U(x, y, z)
	235	#define ASSERT3PF(x, y, z, str, ...) ASSERT3P(x, y, z)
	236	#define ASSERT0P(x) ((void) sizeof ((uintptr_t)(x)))
	237	#define ASSERT0PF(x, str, ...) ASSERT0P(x)
	238	#define ASSERT0F(x, str, ...) ASSERT0(x)
a9e2788f	239	#define ASSERT(x) ((void) sizeof ((uintptr_t)(x)))
e5e2a5a3	240	#define ASSERTF(x, str, ...) ASSERT(x)
a9e2788f AZ	241	#define assert(x) ((void) sizeof ((uintptr_t)(x)))
	242	#define IMPLY(A, B) \
	243	((void) sizeof ((uintptr_t)(A)), (void) sizeof ((uintptr_t)(B)))
	244	#define EQUIV(A, B) \
	245	((void) sizeof ((uintptr_t)(A)), (void) sizeof ((uintptr_t)(B)))
a26baf28	246	#else
6e8b2688 PD	247	#define ASSERT3B VERIFY3B
	248	#define ASSERT3S VERIFY3S
	249	#define ASSERT3U VERIFY3U
	250	#define ASSERT3P VERIFY3P
	251	#define ASSERT0 VERIFY0
506fe78c	252	#define ASSERT0P VERIFY0P
e5e2a5a3 RE	253	#define ASSERT3BF VERIFY3BF
	254	#define ASSERT3SF VERIFY3SF
	255	#define ASSERT3UF VERIFY3UF
	256	#define ASSERT3PF VERIFY3PF
	257	#define ASSERT0PF VERIFY0PF
	258	#define ASSERT0F VERIFY0F
6e8b2688	259	#define ASSERT VERIFY
e5e2a5a3	260	#define ASSERTF VERIFYF
6e8b2688	261	#define assert VERIFY
fa720217 BB	262	#define IMPLY(A, B) \
fa720217 BB	263	((void)(((!(A)) \|\| (B)) \|\| \
726c4a25 BB	264	libspl_assert("(" #A ") implies (" #B ")", \
726c4a25 BB	265	__FILE__, __FUNCTION__, __LINE__)))
fa720217 BB	266	#define EQUIV(A, B) \
fa720217 BB	267	((void)((!!(A) == !!(B)) \|\| \
726c4a25 BB	268	libspl_assert("(" #A ") is equivalent to (" #B ")", \
726c4a25 BB	269	__FILE__, __FUNCTION__, __LINE__)))
fa720217	270
a26baf28 BB	271	#endif /* NDEBUG */
	272
	273	#endif /* _LIBSPL_ASSERT_H */