assert.h@ 105688

Last change on this file since 105688 was 104808, checked in by vboxsync, 6 months ago
iprt/assert.h: Added AssertLogRelReturnStmt & AssertLogRelReturnVoidStmt. bugref:10687
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 93.6 KB

Line
1	/** @file
2	* IPRT - Assertions.
3	*/
4
5	/*
6	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
7	*
8	* This file is part of VirtualBox base platform packages, as
9	* available from https://www.virtualbox.org.
10	*
11	* This program is free software; you can redistribute it and/or
12	* modify it under the terms of the GNU General Public License
13	* as published by the Free Software Foundation, in version 3 of the
14	* License.
15	*
16	* This program is distributed in the hope that it will be useful, but
17	* WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19	* General Public License for more details.
20	*
21	* You should have received a copy of the GNU General Public License
22	* along with this program; if not, see <https://www.gnu.org/licenses>.
23	*
24	* The contents of this file may alternatively be used under the terms
25	* of the Common Development and Distribution License Version 1.0
26	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
27	* in the VirtualBox distribution, in which case the provisions of the
28	* CDDL are applicable instead of those of the GPL.
29	*
30	* You may elect to license modified versions of this file under the
31	* terms and conditions of either the GPL or the CDDL or both.
32	*
33	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
34	*/
35
36	#ifndef IPRT_INCLUDED_assert_h
37	#define IPRT_INCLUDED_assert_h
38	#ifndef RT_WITHOUT_PRAGMA_ONCE
39	# pragma once
40	#endif
41
42	#include <iprt/cdefs.h>
43	#include <iprt/types.h>
44	#include <iprt/stdarg.h>
45	#include <iprt/assertcompile.h>
46
47	/** @defgroup grp_rt_assert Assert - Assertions
48	* @ingroup grp_rt
49	*
50	* Assertions are generally used to check preconditions and other
51	* assumptions. Sometimes it is also used to catch odd errors or errors
52	* that one would like to inspect in the debugger. They should not be
53	* used for errors that happen frequently.
54	*
55	* IPRT provides a host of assertion macros, so many that it can be a bit
56	* overwhelming at first. Don't despair, there is a system (surprise).
57	*
58	* First there are four families of assertions:
59	* - Assert - The normal strict build only assertions.
60	* - AssertLogRel - Calls LogRel() in non-strict builds, otherwise like Assert.
61	* - AssertRelease - Triggers in all builds.
62	* - AssertFatal - Triggers in all builds and cannot be continued.
63	*
64	* Then there are variations wrt to argument list and behavior on failure:
65	* - Msg - Custom RTStrPrintf-like message with the assertion message.
66	* - Return - Return the specific rc on failure.
67	* - ReturnVoid - Return (void) on failure.
68	* - Break - Break (out of switch/loop) on failure.
69	* - Stmt - Execute the specified statement(s) on failure.
70	* - RC - Assert RT_SUCCESS.
71	* - RCSuccess - Assert VINF_SUCCESS.
72	*
73	* @remarks As you might have noticed, the macros don't follow the
74	* coding guidelines wrt to macros supposedly being all uppercase
75	* and underscored. For various reasons they don't, and nobody
76	* has complained yet. Wonder why... :-)
77	*
78	* @remarks Each project has its own specific guidelines on how to use
79	* assertions, so the above is just trying to give you the general idea
80	* from the IPRT point of view.
81	*
82	* @{
83	*/
84
85	RT_C_DECLS_BEGIN
86
87	#if !defined(IPRT_WITHOUT_ASSERT_STACK) \
88	&& defined(IN_RING3) \
89	&& !defined(IN_RT_STATIC) /* try keep static binaries small */ \
90	&& (defined(RT_ARCH_AMD64) /\|\| defined(RT_ARCH_X86)/)
91	/** @def IPRT_WITH_ASSERT_STACK
92	* Indicates that we collect a callstack stack on assertion. */
93	# define IPRT_WITH_ASSERT_STACK
94	#endif
95
96	/**
97	* The 1st part of an assert message.
98	*
99	* @param pszExpr Expression. Can be NULL.
100	* @param uLine Location line number.
101	* @param pszFile Location file name.
102	* @param pszFunction Location function name.
103	*/
104	RTDECL(void) RTAssertMsg1(const char pszExpr, unsigned uLine, const char pszFile, const char *pszFunction);
105	/**
106	* Weak version of RTAssertMsg1 that can be overridden locally in a module to
107	* modify, redirect or otherwise mess with the assertion output.
108	*
109	* @copydoc RTAssertMsg1
110	*/
111	RTDECL(void) RTAssertMsg1Weak(const char pszExpr, unsigned uLine, const char pszFile, const char *pszFunction);
112
113	/**
114	* The 2nd (optional) part of an assert message.
115	*
116	* @param pszFormat Printf like format string.
117	* @param ... Arguments to that string.
118	*/
119	RTDECL(void) RTAssertMsg2(const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(1, 2);
120	/**
121	* Weak version of RTAssertMsg2 that forwards to RTAssertMsg2WeakV.
122	*
123	* There is not need to override this, check out RTAssertMsg2WeakV instead!
124	*
125	* @copydoc RTAssertMsg2
126	*/
127	RTDECL(void) RTAssertMsg2Weak(const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(1, 2);
128
129	/**
130	* The 2nd (optional) part of an assert message.
131	*
132	* @param pszFormat Printf like format string.
133	* @param va Arguments to that string.
134	*/
135	RTDECL(void) RTAssertMsg2V(const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(1, 0);
136	/**
137	* Weak version of RTAssertMsg2V that can be overridden locally in a module to
138	* modify, redirect or otherwise mess with the assertion output.
139	*
140	* @copydoc RTAssertMsg2V
141	*/
142	RTDECL(void) RTAssertMsg2WeakV(const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(1, 0);
143
144	/**
145	* Additional information which should be appended to the 2nd part of an
146	* assertion message.
147	*
148	* @param pszFormat Printf like format string.
149	* @param ... Arguments to that string.
150	*/
151	RTDECL(void) RTAssertMsg2Add(const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(1, 2);
152	/**
153	* Weak version of RTAssertMsg2Add that forwards to RTAssertMsg2AddWeakV.
154	*
155	* There is not need to override this, check out RTAssertMsg2AddWeakV instead!
156	*
157	* @copydoc RTAssertMsg2Add
158	*/
159	RTDECL(void) RTAssertMsg2AddWeak(const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(1, 2);
160
161	/**
162	* Additional information which should be appended to the 2nd part of an
163	* assertion message.
164	*
165	* @param pszFormat Printf like format string.
166	* @param va Arguments to that string.
167	*/
168	RTDECL(void) RTAssertMsg2AddV(const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(1, 0);
169	/**
170	* Weak version of RTAssertMsg2AddV that can be overridden locally in a module
171	* to modify, redirect or otherwise mess with the assertion output.
172	*
173	* @copydoc RTAssertMsg2AddV
174	*/
175	RTDECL(void) RTAssertMsg2AddWeakV(const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(1, 0);
176
177	#ifdef IN_RING0
178	/**
179	* Panics the system as the result of a fail assertion.
180	*/
181	RTR0DECL(void) RTR0AssertPanicSystem(void);
182	#endif /* IN_RING0 */
183
184	/**
185	* Overridable function that decides whether assertions executes the panic
186	* (breakpoint) or not.
187	*
188	* The generic implementation will return true.
189	*
190	* @returns true if the breakpoint should be hit, false if it should be ignored.
191	*
192	* @remark The RTDECL() makes this a bit difficult to override on Windows. So,
193	* you'll have to use RTASSERT_HAVE_SHOULD_PANIC or
194	* RTASSERT_HAVE_SHOULD_PANIC_PRIVATE there to control the kind of
195	* prototype.
196	*/
197	#if !defined(RTASSERT_HAVE_SHOULD_PANIC) && !defined(RTASSERT_HAVE_SHOULD_PANIC_PRIVATE)
198	RTDECL(bool) RTAssertShouldPanic(void);
199	#elif defined(RTASSERT_HAVE_SHOULD_PANIC_PRIVATE)
200	bool RTAssertShouldPanic(void);
201	#else
202	DECLEXPORT(bool) RTCALL RTAssertShouldPanic(void);
203	#endif
204
205	/**
206	* Controls whether the assertions should be quiet or noisy (default).
207	*
208	* @returns The old setting.
209	* @param fQuiet The new setting.
210	*/
211	RTDECL(bool) RTAssertSetQuiet(bool fQuiet);
212
213	/**
214	* Are assertions quiet or noisy?
215	*
216	* @returns True if they are quiet, false if noisy.
217	*/
218	RTDECL(bool) RTAssertAreQuiet(void);
219
220	/**
221	* Makes the assertions panic (default) or not.
222	*
223	* @returns The old setting.
224	* @param fPanic The new setting.
225	*/
226	RTDECL(bool) RTAssertSetMayPanic(bool fPanic);
227
228	/**
229	* Can assertion panic.
230	*
231	* @returns True if they can, false if not.
232	*/
233	RTDECL(bool) RTAssertMayPanic(void);
234
235
236	/** @name Globals for crash analysis
237	* @remarks This is the full potential set, it
238	* @{
239	*/
240	/** The last assertion message, 1st part. */
241	extern RTDATADECL(char) g_szRTAssertMsg1[1024];
242	/** The last assertion message, 2nd part. */
243	extern RTDATADECL(char) g_szRTAssertMsg2[4096];
244	#ifdef IPRT_WITH_ASSERT_STACK
245	/** The last assertion message, stack part. */
246	extern RTDATADECL(char) g_szRTAssertStack[4096];
247	#endif
248	/** The last assertion message, expression. */
249	extern RTDATADECL(const char * volatile) g_pszRTAssertExpr;
250	/** The last assertion message, file name. */
251	extern RTDATADECL(const char * volatile) g_pszRTAssertFile;
252	/** The last assertion message, line number. */
253	extern RTDATADECL(uint32_t volatile) g_u32RTAssertLine;
254	/** The last assertion message, function name. */
255	extern RTDATADECL(const char * volatile) g_pszRTAssertFunction;
256	/** @} */
257
258	RT_C_DECLS_END
259
260	/** @def RTAssertDebugBreak()
261	* Debugger breakpoint instruction.
262	*
263	* @remarks This macro does not depend on RT_STRICT.
264	*/
265	#define RTAssertDebugBreak() do { RT_BREAKPOINT(); } while (0)
266
267
268
269	/** @name Assertions
270	*
271	* These assertions will only trigger when RT_STRICT is defined. When it is
272	* undefined they will all be no-ops and generate no code.
273	*
274	* @{
275	*/
276
277
278	/** @def RTASSERT_QUIET
279	* This can be defined to shut up the messages for a file where this would be
280	* problematic because the message printing code path passes thru it.
281	* @internal */
282	#ifdef DOXYGEN_RUNNING
283	# define RTASSERT_QUIET
284	#endif
285	#if defined(RTASSERT_QUIET) && !defined(DOXYGEN_RUNNING)
286	# define RTAssertMsg1Weak(pszExpr, uLine, pszfile, pszFunction) \
287	do { } while (0)
288	# ifdef RT_COMPILER_SUPPORTS_VA_ARGS
289	# define RTAssertMsg2Weak(...) do { } while (0)
290	# else
291	# define RTAssertMsg2Weak if (1) {} else RTAssertMsg2Weak
292	# endif
293	#endif
294
295	/** @def RTAssertDoPanic
296	* Raises an assertion panic appropriate to the current context.
297	* @remarks This macro does not depend on RT_STRICT.
298	*/
299	#if defined(IN_RING0) \
300	&& (defined(RT_OS_DARWIN) \|\| defined(RT_OS_HAIKU) \|\| defined(RT_OS_SOLARIS))
301	# define RTAssertDoPanic() RTR0AssertPanicSystem()
302	#else
303	# define RTAssertDoPanic() RTAssertDebugBreak()
304	#endif
305
306	/** @def AssertBreakpoint()
307	* Assertion Breakpoint.
308	* @deprecated Use RTAssertPanic or RTAssertDebugBreak instead.
309	*/
310	#ifdef RT_STRICT
311	# define AssertBreakpoint() RTAssertDebugBreak()
312	#else
313	# define AssertBreakpoint() do { } while (0)
314	#endif
315
316	/** @def RTAssertPanic()
317	* If RT_STRICT is defined this macro will invoke RTAssertDoPanic if
318	* RTAssertShouldPanic returns true. If RT_STRICT isn't defined it won't do any
319	* thing.
320	*/
321	#if defined(RT_STRICT) && !defined(RTASSERT_DONT_PANIC)
322	# define RTAssertPanic() do { if (RTAssertShouldPanic()) RTAssertDoPanic(); } while (0)
323	#else
324	# define RTAssertPanic() do { } while (0)
325	#endif
326
327	/** @def Assert
328	* Assert that an expression is true. If false, hit breakpoint.
329	* @param expr Expression which should be true.
330	*/
331	#ifdef RT_STRICT
332	# define Assert(expr) \
333	do { \
334	if (RT_LIKELY(!!(expr))) \
335	{ /* likely */ } \
336	else \
337	{ \
338	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
339	RTAssertPanic(); \
340	} \
341	} while (0)
342	#else
343	# define Assert(expr) do { } while (0)
344	#endif
345
346
347	/** @def AssertStmt
348	* Assert that an expression is true. If false, hit breakpoint and execute the
349	* statement.
350	* @param expr Expression which should be true.
351	* @param stmt Statement to execute on failure.
352	*/
353	#ifdef RT_STRICT
354	# define AssertStmt(expr, stmt) \
355	do { \
356	if (RT_LIKELY(!!(expr))) \
357	{ /* likely */ } \
358	else \
359	{ \
360	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
361	RTAssertPanic(); \
362	stmt; \
363	} \
364	} while (0)
365	#else
366	# define AssertStmt(expr, stmt) \
367	do { \
368	if (RT_LIKELY(!!(expr))) \
369	{ /* likely */ } \
370	else \
371	{ \
372	stmt; \
373	} \
374	} while (0)
375	#endif
376
377
378	/** @def AssertReturn
379	* Assert that an expression is true and returns if it isn't.
380	* In RT_STRICT mode it will hit a breakpoint before returning.
381	*
382	* @param expr Expression which should be true.
383	* @param rc What is to be presented to return.
384	*/
385	#ifdef RT_STRICT
386	# define AssertReturn(expr, rc) \
387	do { \
388	if (RT_LIKELY(!!(expr))) \
389	{ /* likely */ } \
390	else \
391	{ \
392	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
393	RTAssertPanic(); \
394	return (rc); \
395	} \
396	} while (0)
397	#else
398	# define AssertReturn(expr, rc) \
399	do { \
400	if (RT_LIKELY(!!(expr))) \
401	{ /* likely */ } \
402	else \
403	return (rc); \
404	} while (0)
405	#endif
406
407	/** @def AssertReturnStmt
408	* Assert that an expression is true, if it isn't execute the given statement
409	* and return rc.
410	*
411	* In RT_STRICT mode it will hit a breakpoint before executing the statement and
412	* returning.
413	*
414	* @param expr Expression which should be true.
415	* @param stmt Statement to execute before returning on failure.
416	* @param rc What is to be presented to return.
417	*/
418	#ifdef RT_STRICT
419	# define AssertReturnStmt(expr, stmt, rc) \
420	do { \
421	if (RT_LIKELY(!!(expr))) \
422	{ /* likely */ } \
423	else \
424	{ \
425	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
426	RTAssertPanic(); \
427	stmt; \
428	return (rc); \
429	} \
430	} while (0)
431	#else
432	# define AssertReturnStmt(expr, stmt, rc) \
433	do { \
434	if (RT_LIKELY(!!(expr))) \
435	{ /* likely */ } \
436	else \
437	{ \
438	stmt; \
439	return (rc); \
440	} \
441	} while (0)
442	#endif
443
444	/** @def AssertReturnVoid
445	* Assert that an expression is true and returns if it isn't.
446	* In RT_STRICT mode it will hit a breakpoint before returning.
447	*
448	* @param expr Expression which should be true.
449	*/
450	#ifdef RT_STRICT
451	# define AssertReturnVoid(expr) \
452	do { \
453	if (RT_LIKELY(!!(expr))) \
454	{ /* likely */ } \
455	else \
456	{ \
457	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
458	RTAssertPanic(); \
459	return; \
460	} \
461	} while (0)
462	#else
463	# define AssertReturnVoid(expr) \
464	do { \
465	if (RT_LIKELY(!!(expr))) \
466	{ /* likely */ } \
467	else \
468	return; \
469	} while (0)
470	#endif
471
472	/** @def AssertReturnVoidStmt
473	* Assert that an expression is true, if it isn't execute the given statement
474	* and return.
475	*
476	* In RT_STRICT mode it will hit a breakpoint before returning.
477	*
478	* @param expr Expression which should be true.
479	* @param stmt Statement to execute before returning on failure.
480	*/
481	#ifdef RT_STRICT
482	# define AssertReturnVoidStmt(expr, stmt) \
483	do { \
484	if (RT_LIKELY(!!(expr))) \
485	{ /* likely */ } \
486	else \
487	{ \
488	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
489	RTAssertPanic(); \
490	stmt; \
491	return; \
492	} \
493	} while (0)
494	#else
495	# define AssertReturnVoidStmt(expr, stmt) \
496	do { \
497	if (RT_LIKELY(!!(expr))) \
498	{ /* likely */ } \
499	else \
500	{ \
501	stmt; \
502	return; \
503	} \
504	} while (0)
505	#endif
506
507
508	/** @def AssertBreak
509	* Assert that an expression is true and breaks if it isn't.
510	* In RT_STRICT mode it will hit a breakpoint before breaking.
511	*
512	* @param expr Expression which should be true.
513	*/
514	#ifdef RT_STRICT
515	# define AssertBreak(expr) \
516	if (RT_LIKELY(!!(expr))) \
517	{ /* likely */ } \
518	else if (1) \
519	{ \
520	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
521	RTAssertPanic(); \
522	break; \
523	} else \
524	break
525	#else
526	# define AssertBreak(expr) \
527	if (RT_LIKELY(!!(expr))) \
528	{ /* likely */ } \
529	else \
530	break
531	#endif
532
533	/** @def AssertBreakStmt
534	* Assert that an expression is true and breaks if it isn't.
535	* In RT_STRICT mode it will hit a breakpoint before doing break.
536	*
537	* @param expr Expression which should be true.
538	* @param stmt Statement to execute before break in case of a failed assertion.
539	*/
540	#ifdef RT_STRICT
541	# define AssertBreakStmt(expr, stmt) \
542	if (RT_LIKELY(!!(expr))) \
543	{ /* likely */ } \
544	else if (1) \
545	{ \
546	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
547	RTAssertPanic(); \
548	stmt; \
549	break; \
550	} else do {} while (0)
551	#else
552	# define AssertBreakStmt(expr, stmt) \
553	if (RT_LIKELY(!!(expr))) \
554	{ /* likely */ } \
555	else if (1) \
556	{ \
557	stmt; \
558	break; \
559	} else do {} while (0)
560	#endif
561
562	/** @def AssertContinue
563	* Assert that an expression is true and continue if it isn't.
564	* In RT_STRICT mode it will hit a breakpoint before continuing.
565	*
566	* @param expr Expression which should be true.
567	*/
568	#ifdef RT_STRICT
569	# define AssertContinue(expr) \
570	if (RT_LIKELY(!!(expr))) \
571	{ /* likely */ } \
572	else if (1) \
573	{ \
574	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
575	RTAssertPanic(); \
576	continue; \
577	} else do {} while (0)
578	#else
579	# define AssertContinue(expr) \
580	if (RT_LIKELY(!!(expr))) \
581	{ /* likely */ } \
582	else \
583	continue
584	#endif
585
586	/** @def AssertContinueStmt
587	* Assert that an expression is true and continue if it isn't.
588	* In RT_STRICT mode it will hit a breakpoint before continuing.
589	*
590	* @param expr Expression which should be true.
591	* @param stmt Statement to execute before contine in case of a failed assertion.
592	*/
593	#ifdef RT_STRICT
594	# define AssertContinueStmt(expr, stmt) \
595	if (RT_LIKELY(!!(expr))) \
596	{ /* likely */ } \
597	else if (1) \
598	{ \
599	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
600	RTAssertPanic(); \
601	stmt; \
602	continue; \
603	} else do {} while (0)
604	#else
605	# define AssertContinueStmt(expr, stmt) \
606	if (RT_LIKELY(!!(expr))) \
607	{ /* likely */ } \
608	else if (1) \
609	{ \
610	stmt; \
611	continue; \
612	} else do {} while (0)
613	#endif
614
615
616	/** @def AssertMsg
617	* Assert that an expression is true. If it's not print message and hit breakpoint.
618	* @param expr Expression which should be true.
619	* @param a printf argument list (in parenthesis).
620	*/
621	#ifdef RT_STRICT
622	# define AssertMsg(expr, a) \
623	do { \
624	if (RT_LIKELY(!!(expr))) \
625	{ /* likely */ } \
626	else \
627	{ \
628	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
629	RTAssertMsg2Weak a; \
630	RTAssertPanic(); \
631	} \
632	} while (0)
633	#else
634	# define AssertMsg(expr, a) do { } while (0)
635	#endif
636
637	/** @def AssertMsgStmt
638	* Assert that an expression is true. If it's not print message and hit
639	* breakpoint and execute the statement.
640	*
641	* @param expr Expression which should be true.
642	* @param a printf argument list (in parenthesis).
643	* @param stmt Statement to execute in case of a failed assertion.
644	*
645	* @remarks The expression and statement will be evaluated in all build types.
646	*/
647	#ifdef RT_STRICT
648	# define AssertMsgStmt(expr, a, stmt) \
649	do { \
650	if (RT_LIKELY(!!(expr))) \
651	{ /* likely */ } \
652	else \
653	{ \
654	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
655	RTAssertMsg2Weak a; \
656	RTAssertPanic(); \
657	stmt; \
658	} \
659	} while (0)
660	#else
661	# define AssertMsgStmt(expr, a, stmt) \
662	do { \
663	if (RT_LIKELY(!!(expr))) \
664	{ /* likely */ } \
665	else \
666	{ \
667	stmt; \
668	} \
669	} while (0)
670	#endif
671
672	/** @def AssertMsgReturn
673	* Assert that an expression is true and returns if it isn't.
674	* In RT_STRICT mode it will hit a breakpoint before returning.
675	*
676	* @param expr Expression which should be true.
677	* @param a printf argument list (in parenthesis).
678	* @param rc What is to be presented to return.
679	*/
680	#ifdef RT_STRICT
681	# define AssertMsgReturn(expr, a, rc) \
682	do { \
683	if (RT_LIKELY(!!(expr))) \
684	{ /* likely */ } \
685	else \
686	{ \
687	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
688	RTAssertMsg2Weak a; \
689	RTAssertPanic(); \
690	return (rc); \
691	} \
692	} while (0)
693	#else
694	# define AssertMsgReturn(expr, a, rc) \
695	do { \
696	if (RT_LIKELY(!!(expr))) \
697	{ /* likely */ } \
698	else \
699	return (rc); \
700	} while (0)
701	#endif
702
703	/** @def AssertMsgReturnStmt
704	* Assert that an expression is true, if it isn't execute the statement and
705	* return.
706	*
707	* In RT_STRICT mode it will hit a breakpoint before returning.
708	*
709	* @param expr Expression which should be true.
710	* @param a printf argument list (in parenthesis).
711	* @param stmt Statement to execute before returning in case of a failed
712	* assertion.
713	* @param rc What is to be presented to return.
714	*/
715	#ifdef RT_STRICT
716	# define AssertMsgReturnStmt(expr, a, stmt, rc) \
717	do { \
718	if (RT_LIKELY(!!(expr))) \
719	{ /* likely */ } \
720	else \
721	{ \
722	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
723	RTAssertMsg2Weak a; \
724	RTAssertPanic(); \
725	stmt; \
726	return (rc); \
727	} \
728	} while (0)
729	#else
730	# define AssertMsgReturnStmt(expr, a, stmt, rc) \
731	do { \
732	if (RT_LIKELY(!!(expr))) \
733	{ /* likely */ } \
734	else \
735	{ \
736	stmt; \
737	return (rc); \
738	} \
739	} while (0)
740	#endif
741
742	/** @def AssertMsgReturnVoid
743	* Assert that an expression is true and returns if it isn't.
744	* In RT_STRICT mode it will hit a breakpoint before returning.
745	*
746	* @param expr Expression which should be true.
747	* @param a printf argument list (in parenthesis).
748	*/
749	#ifdef RT_STRICT
750	# define AssertMsgReturnVoid(expr, a) \
751	do { \
752	if (RT_LIKELY(!!(expr))) \
753	{ /* likely */ } \
754	else \
755	{ \
756	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
757	RTAssertMsg2Weak a; \
758	RTAssertPanic(); \
759	return; \
760	} \
761	} while (0)
762	#else
763	# define AssertMsgReturnVoid(expr, a) \
764	do { \
765	if (RT_LIKELY(!!(expr))) \
766	{ /* likely */ } \
767	else \
768	return; \
769	} while (0)
770	#endif
771
772	/** @def AssertMsgReturnVoidStmt
773	* Assert that an expression is true, if it isn't execute the statement and
774	* return.
775	*
776	* In RT_STRICT mode it will hit a breakpoint before returning.
777	*
778	* @param expr Expression which should be true.
779	* @param a printf argument list (in parenthesis).
780	* @param stmt Statement to execute before return in case of a failed assertion.
781	*/
782	#ifdef RT_STRICT
783	# define AssertMsgReturnVoidStmt(expr, a, stmt) \
784	do { \
785	if (RT_LIKELY(!!(expr))) \
786	{ /* likely */ } \
787	else \
788	{ \
789	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
790	RTAssertMsg2Weak a; \
791	RTAssertPanic(); \
792	stmt; \
793	return; \
794	} \
795	} while (0)
796	#else
797	# define AssertMsgReturnVoidStmt(expr, a, stmt) \
798	do { \
799	if (RT_LIKELY(!!(expr))) \
800	{ /* likely */ } \
801	else \
802	{ \
803	stmt; \
804	return; \
805	} \
806	} while (0)
807	#endif
808
809
810	/** @def AssertMsgBreak
811	* Assert that an expression is true and breaks if it isn't.
812	* In RT_STRICT mode it will hit a breakpoint before returning.
813	*
814	* @param expr Expression which should be true.
815	* @param a printf argument list (in parenthesis).
816	*/
817	#ifdef RT_STRICT
818	# define AssertMsgBreak(expr, a) \
819	if (RT_LIKELY(!!(expr))) \
820	{ /* likely */ } \
821	else if (1) \
822	{ \
823	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
824	RTAssertMsg2Weak a; \
825	RTAssertPanic(); \
826	break; \
827	} else \
828	break
829	#else
830	# define AssertMsgBreak(expr, a) \
831	if (RT_LIKELY(!!(expr))) \
832	{ /* likely */ } \
833	else \
834	break
835	#endif
836
837	/** @def AssertMsgBreakStmt
838	* Assert that an expression is true and breaks if it isn't.
839	* In RT_STRICT mode it will hit a breakpoint before doing break.
840	*
841	* @param expr Expression which should be true.
842	* @param a printf argument list (in parenthesis).
843	* @param stmt Statement to execute before break in case of a failed assertion.
844	*/
845	#ifdef RT_STRICT
846	# define AssertMsgBreakStmt(expr, a, stmt) \
847	if (RT_LIKELY(!!(expr))) \
848	{ /* likely */ } \
849	else if (1) \
850	{ \
851	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
852	RTAssertMsg2Weak a; \
853	RTAssertPanic(); \
854	stmt; \
855	break; \
856	} else \
857	break
858	#else
859	# define AssertMsgBreakStmt(expr, a, stmt) \
860	if (RT_LIKELY(!!(expr))) \
861	{ /* likely */ } \
862	else if (1) \
863	{ \
864	stmt; \
865	break; \
866	} else \
867	break
868	#endif
869
870	/** @def AssertFailed
871	* An assertion failed, hit breakpoint.
872	*/
873	#ifdef RT_STRICT
874	# define AssertFailed() \
875	do { \
876	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
877	RTAssertPanic(); \
878	} while (0)
879	#else
880	# define AssertFailed() do { } while (0)
881	#endif
882
883	/** @def AssertFailedStmt
884	* An assertion failed, hit breakpoint and execute statement.
885	*/
886	#ifdef RT_STRICT
887	# define AssertFailedStmt(stmt) \
888	do { \
889	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
890	RTAssertPanic(); \
891	stmt; \
892	} while (0)
893	#else
894	# define AssertFailedStmt(stmt) do { stmt; } while (0)
895	#endif
896
897	/** @def AssertFailedReturn
898	* An assertion failed, hit breakpoint (RT_STRICT mode only) and return.
899	*
900	* @param rc The rc to return.
901	*/
902	#ifdef RT_STRICT
903	# define AssertFailedReturn(rc) \
904	do { \
905	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
906	RTAssertPanic(); \
907	return (rc); \
908	} while (0)
909	#else
910	# define AssertFailedReturn(rc) \
911	do { \
912	return (rc); \
913	} while (0)
914	#endif
915
916	/** @def AssertFailedReturnStmt
917	* An assertion failed, hit breakpoint (RT_STRICT mode only), execute a
918	* statement and return a value.
919	*
920	* @param stmt The statement to execute before returning.
921	* @param rc The value to return.
922	*/
923	#ifdef RT_STRICT
924	# define AssertFailedReturnStmt(stmt, rc) \
925	do { \
926	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
927	RTAssertPanic(); \
928	stmt; \
929	return (rc); \
930	} while (0)
931	#else
932	# define AssertFailedReturnStmt(stmt, rc) \
933	do { \
934	stmt; \
935	return (rc); \
936	} while (0)
937	#endif
938
939	/** @def AssertFailedReturnVoid
940	* An assertion failed, hit breakpoint (RT_STRICT mode only) and return.
941	*/
942	#ifdef RT_STRICT
943	# define AssertFailedReturnVoid() \
944	do { \
945	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
946	RTAssertPanic(); \
947	return; \
948	} while (0)
949	#else
950	# define AssertFailedReturnVoid() \
951	do { \
952	return; \
953	} while (0)
954	#endif
955
956	/** @def AssertFailedReturnVoidStmt
957	* An assertion failed, hit breakpoint (RT_STRICT mode only), execute a
958	* statement and return.
959	*
960	* @param stmt The statement to execute before returning.
961	*/
962	#ifdef RT_STRICT
963	# define AssertFailedReturnVoidStmt(stmt) \
964	do { \
965	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
966	RTAssertPanic(); \
967	stmt; \
968	return; \
969	} while (0)
970	#else
971	# define AssertFailedReturnVoidStmt(stmt) \
972	do { \
973	stmt; \
974	return; \
975	} while (0)
976	#endif
977
978
979	/** @def AssertFailedBreak
980	* An assertion failed, hit breakpoint (RT_STRICT mode only) and break.
981	*/
982	#ifdef RT_STRICT
983	# define AssertFailedBreak() \
984	if (1) { \
985	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
986	RTAssertPanic(); \
987	break; \
988	} else \
989	break
990	#else
991	# define AssertFailedBreak() \
992	if (1) \
993	break; \
994	else \
995	break
996	#endif
997
998	/** @def AssertFailedBreakStmt
999	* An assertion failed, hit breakpoint (RT_STRICT mode only), execute
1000	* the given statement and break.
1001	*
1002	* @param stmt Statement to execute before break.
1003	*/
1004	#ifdef RT_STRICT
1005	# define AssertFailedBreakStmt(stmt) \
1006	if (1) { \
1007	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1008	RTAssertPanic(); \
1009	stmt; \
1010	break; \
1011	} else \
1012	break
1013	#else
1014	# define AssertFailedBreakStmt(stmt) \
1015	if (1) { \
1016	stmt; \
1017	break; \
1018	} else \
1019	break
1020	#endif
1021
1022
1023	/** @def AssertMsgFailed
1024	* An assertion failed print a message and a hit breakpoint.
1025	*
1026	* @param a printf argument list (in parenthesis).
1027	*/
1028	#ifdef RT_STRICT
1029	# define AssertMsgFailed(a) \
1030	do { \
1031	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1032	RTAssertMsg2Weak a; \
1033	RTAssertPanic(); \
1034	} while (0)
1035	#else
1036	# define AssertMsgFailed(a) do { } while (0)
1037	#endif
1038
1039	/** @def AssertMsgFailedReturn
1040	* An assertion failed, hit breakpoint with message (RT_STRICT mode only) and return.
1041	*
1042	* @param a printf argument list (in parenthesis).
1043	* @param rc What is to be presented to return.
1044	*/
1045	#ifdef RT_STRICT
1046	# define AssertMsgFailedReturn(a, rc) \
1047	do { \
1048	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1049	RTAssertMsg2Weak a; \
1050	RTAssertPanic(); \
1051	return (rc); \
1052	} while (0)
1053	#else
1054	# define AssertMsgFailedReturn(a, rc) \
1055	do { \
1056	return (rc); \
1057	} while (0)
1058	#endif
1059
1060	/** @def AssertMsgFailedReturnVoid
1061	* An assertion failed, hit breakpoint with message (RT_STRICT mode only) and return.
1062	*
1063	* @param a printf argument list (in parenthesis).
1064	*/
1065	#ifdef RT_STRICT
1066	# define AssertMsgFailedReturnVoid(a) \
1067	do { \
1068	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1069	RTAssertMsg2Weak a; \
1070	RTAssertPanic(); \
1071	return; \
1072	} while (0)
1073	#else
1074	# define AssertMsgFailedReturnVoid(a) \
1075	do { \
1076	return; \
1077	} while (0)
1078	#endif
1079
1080
1081	/** @def AssertMsgFailedBreak
1082	* An assertion failed, hit breakpoint with message (RT_STRICT mode only) and break.
1083	*
1084	* @param a printf argument list (in parenthesis).
1085	*/
1086	#ifdef RT_STRICT
1087	# define AssertMsgFailedBreak(a) \
1088	if (1) { \
1089	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1090	RTAssertMsg2Weak a; \
1091	RTAssertPanic(); \
1092	break; \
1093	} else \
1094	break
1095	#else
1096	# define AssertMsgFailedBreak(a) \
1097	if (1) \
1098	break; \
1099	else \
1100	break
1101	#endif
1102
1103	/** @def AssertMsgFailedBreakStmt
1104	* An assertion failed, hit breakpoint (RT_STRICT mode only), execute
1105	* the given statement and break.
1106	*
1107	* @param a printf argument list (in parenthesis).
1108	* @param stmt Statement to execute before break.
1109	*/
1110	#ifdef RT_STRICT
1111	# define AssertMsgFailedBreakStmt(a, stmt) \
1112	if (1) { \
1113	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1114	RTAssertMsg2Weak a; \
1115	RTAssertPanic(); \
1116	stmt; \
1117	break; \
1118	} else \
1119	break
1120	#else
1121	# define AssertMsgFailedBreakStmt(a, stmt) \
1122	if (1) { \
1123	stmt; \
1124	break; \
1125	} else \
1126	break
1127	#endif
1128
1129	/** @} */
1130
1131
1132
1133	/** @name Release Log Assertions
1134	*
1135	* These assertions will work like normal strict assertion when RT_STRICT is
1136	* defined and LogRel statements when RT_STRICT is undefined. Typically used for
1137	* things which shouldn't go wrong, but when it does you'd like to know one way
1138	* or the other.
1139	*
1140	* @{
1141	*/
1142
1143	/** @def RTAssertLogRelMsg1
1144	* RTAssertMsg1Weak (strict builds) / LogRel wrapper (non-strict).
1145	*/
1146	#ifdef RT_STRICT
1147	# define RTAssertLogRelMsg1(pszExpr, iLine, pszFile, pszFunction) \
1148	RTAssertMsg1Weak(pszExpr, iLine, pszFile, pszFunction)
1149	#else
1150	# define RTAssertLogRelMsg1(pszExpr, iLine, pszFile, pszFunction) \
1151	LogRel(("AssertLogRel %s(%d) %s: %s\n",\
1152	(pszFile), (iLine), (pszFunction), (pszExpr) ))
1153	#endif
1154
1155	/** @def RTAssertLogRelMsg2
1156	* RTAssertMsg2Weak (strict builds) / LogRel wrapper (non-strict).
1157	*/
1158	#ifdef RT_STRICT
1159	# define RTAssertLogRelMsg2(a) RTAssertMsg2Weak a
1160	#else
1161	# define RTAssertLogRelMsg2(a) LogRel(a)
1162	#endif
1163
1164	/** @def AssertLogRel
1165	* Assert that an expression is true.
1166	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1167	*
1168	* @param expr Expression which should be true.
1169	*/
1170	#define AssertLogRel(expr) \
1171	do { \
1172	if (RT_LIKELY(!!(expr))) \
1173	{ /* likely */ } \
1174	else \
1175	{ \
1176	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1177	RTAssertPanic(); \
1178	} \
1179	} while (0)
1180
1181	/** @def AssertLogRelReturn
1182	* Assert that an expression is true, return \a rc if it isn't.
1183	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1184	*
1185	* @param expr Expression which should be true.
1186	* @param rc What is to be presented to return.
1187	*/
1188	#define AssertLogRelReturn(expr, rc) \
1189	do { \
1190	if (RT_LIKELY(!!(expr))) \
1191	{ /* likely */ } \
1192	else \
1193	{ \
1194	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1195	RTAssertPanic(); \
1196	return (rc); \
1197	} \
1198	} while (0)
1199
1200	/** @def AssertLogRelReturnStmt
1201	* Assert that an expression is true, execute \a stmt & return \a rc if it
1202	* isn't. Strict builds will hit a breakpoint, non-strict will only do LogRel.
1203	*
1204	* @param expr Expression which should be true.
1205	* @param stmt Statement to execute before break in case of a failed
1206	* assertion.
1207	* @param rc What is to be presented to return.
1208	*/
1209	#define AssertLogRelReturnStmt(expr, stmt, rc) \
1210	do { \
1211	if (RT_LIKELY(!!(expr))) \
1212	{ /* likely */ } \
1213	else \
1214	{ \
1215	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1216	RTAssertPanic(); \
1217	stmt; \
1218	return (rc); \
1219	} \
1220	} while (0)
1221
1222	/** @def AssertLogRelReturnVoid
1223	* Assert that an expression is true, return void if it isn't.
1224	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1225	*
1226	* @param expr Expression which should be true.
1227	*/
1228	#define AssertLogRelReturnVoid(expr) \
1229	do { \
1230	if (RT_LIKELY(!!(expr))) \
1231	{ /* likely */ } \
1232	else \
1233	{ \
1234	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1235	RTAssertPanic(); \
1236	return; \
1237	} \
1238	} while (0)
1239
1240	/** @def AssertLogRelReturnVoidStmt
1241	* Assert that an expression is true, execute \a stmt & return void if it isn't.
1242	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1243	*
1244	* @param expr Expression which should be true.
1245	* @param stmt Statement to execute before break in case of a failed
1246	* assertion.
1247	*/
1248	#define AssertLogRelReturnVoidStmt(expr, stmt) \
1249	do { \
1250	if (RT_LIKELY(!!(expr))) \
1251	{ /* likely */ } \
1252	else \
1253	{ \
1254	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1255	RTAssertPanic(); \
1256	stmt; \
1257	return; \
1258	} \
1259	} while (0)
1260
1261	/** @def AssertLogRelBreak
1262	* Assert that an expression is true, break if it isn't.
1263	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1264	*
1265	* @param expr Expression which should be true.
1266	*/
1267	#define AssertLogRelBreak(expr) \
1268	if (RT_LIKELY(!!(expr))) \
1269	{ /* likely */ } \
1270	else if (1) \
1271	{ \
1272	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1273	RTAssertPanic(); \
1274	break; \
1275	} \
1276	else \
1277	break
1278
1279	/** @def AssertLogRelBreakStmt
1280	* Assert that an expression is true, execute \a stmt and break if it isn't.
1281	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1282	*
1283	* @param expr Expression which should be true.
1284	* @param stmt Statement to execute before break in case of a failed assertion.
1285	*/
1286	#define AssertLogRelBreakStmt(expr, stmt) \
1287	if (RT_LIKELY(!!(expr))) \
1288	{ /* likely */ } \
1289	else if (1) \
1290	{ \
1291	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1292	RTAssertPanic(); \
1293	stmt; \
1294	break; \
1295	} else \
1296	break
1297
1298	/** @def AssertLogRelStmt
1299	* Assert that an expression is true, return \a rc if it isn't.
1300	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1301	*
1302	* @param expr Expression which should be true.
1303	* @param stmt Statement to execute in case of a failed assertion.
1304	*/
1305	#define AssertLogRelStmt(expr, stmt) \
1306	do { \
1307	if (RT_LIKELY(!!(expr))) \
1308	{ /* likely */ } \
1309	else \
1310	{ \
1311	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1312	RTAssertPanic(); \
1313	stmt; \
1314	} \
1315	} while (0)
1316
1317	/** @def AssertLogRelMsg
1318	* Assert that an expression is true.
1319	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1320	*
1321	* @param expr Expression which should be true.
1322	* @param a printf argument list (in parenthesis).
1323	*/
1324	#define AssertLogRelMsg(expr, a) \
1325	do { \
1326	if (RT_LIKELY(!!(expr))) \
1327	{ /* likely */ } \
1328	else\
1329	{ \
1330	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1331	RTAssertLogRelMsg2(a); \
1332	RTAssertPanic(); \
1333	} \
1334	} while (0)
1335
1336	/** @def AssertLogRelMsgStmt
1337	* Assert that an expression is true, execute \a stmt and break if it isn't
1338	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1339	*
1340	* @param expr Expression which should be true.
1341	* @param a printf argument list (in parenthesis).
1342	* @param stmt Statement to execute in case of a failed assertion.
1343	*/
1344	#define AssertLogRelMsgStmt(expr, a, stmt) \
1345	do { \
1346	if (RT_LIKELY(!!(expr))) \
1347	{ /* likely */ } \
1348	else\
1349	{ \
1350	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1351	RTAssertLogRelMsg2(a); \
1352	RTAssertPanic(); \
1353	stmt; \
1354	} \
1355	} while (0)
1356
1357	/** @def AssertLogRelMsgReturn
1358	* Assert that an expression is true, return \a rc if it isn't.
1359	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1360	*
1361	* @param expr Expression which should be true.
1362	* @param a printf argument list (in parenthesis).
1363	* @param rc What is to be presented to return.
1364	*/
1365	#define AssertLogRelMsgReturn(expr, a, rc) \
1366	do { \
1367	if (RT_LIKELY(!!(expr))) \
1368	{ /* likely */ } \
1369	else\
1370	{ \
1371	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1372	RTAssertLogRelMsg2(a); \
1373	RTAssertPanic(); \
1374	return (rc); \
1375	} \
1376	} while (0)
1377
1378	/** @def AssertLogRelMsgReturnStmt
1379	* Assert that an expression is true, execute @a stmt and return @a rcRet if it
1380	* isn't.
1381	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1382	*
1383	* @param expr Expression which should be true.
1384	* @param a printf argument list (in parenthesis).
1385	* @param stmt Statement to execute before returning in case of a failed
1386	* assertion.
1387	* @param rcRet What is to be presented to return.
1388	*/
1389	#define AssertLogRelMsgReturnStmt(expr, a, stmt, rcRet) \
1390	do { \
1391	if (RT_LIKELY(!!(expr))) \
1392	{ /* likely */ } \
1393	else\
1394	{ \
1395	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1396	RTAssertLogRelMsg2(a); \
1397	RTAssertPanic(); \
1398	stmt; \
1399	return (rcRet); \
1400	} \
1401	} while (0)
1402
1403	/** @def AssertLogRelMsgReturnVoid
1404	* Assert that an expression is true, return (void) if it isn't.
1405	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1406	*
1407	* @param expr Expression which should be true.
1408	* @param a printf argument list (in parenthesis).
1409	*/
1410	#define AssertLogRelMsgReturnVoid(expr, a) \
1411	do { \
1412	if (RT_LIKELY(!!(expr))) \
1413	{ /* likely */ } \
1414	else\
1415	{ \
1416	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1417	RTAssertLogRelMsg2(a); \
1418	RTAssertPanic(); \
1419	return; \
1420	} \
1421	} while (0)
1422
1423	/** @def AssertLogRelMsgBreak
1424	* Assert that an expression is true, break if it isn't.
1425	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1426	*
1427	* @param expr Expression which should be true.
1428	* @param a printf argument list (in parenthesis).
1429	*/
1430	#define AssertLogRelMsgBreak(expr, a) \
1431	if (RT_LIKELY(!!(expr))) \
1432	{ /* likely */ } \
1433	else if (1) \
1434	{ \
1435	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1436	RTAssertLogRelMsg2(a); \
1437	RTAssertPanic(); \
1438	break; \
1439	} \
1440	else \
1441	break
1442
1443	/** @def AssertLogRelMsgBreakStmt
1444	* Assert that an expression is true, execute \a stmt and break if it isn't.
1445	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1446	*
1447	* @param expr Expression which should be true.
1448	* @param a printf argument list (in parenthesis).
1449	* @param stmt Statement to execute before break in case of a failed assertion.
1450	*/
1451	#define AssertLogRelMsgBreakStmt(expr, a, stmt) \
1452	if (RT_LIKELY(!!(expr))) \
1453	{ /* likely */ } \
1454	else if (1) \
1455	{ \
1456	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1457	RTAssertLogRelMsg2(a); \
1458	RTAssertPanic(); \
1459	stmt; \
1460	break; \
1461	} else \
1462	break
1463
1464	/** @def AssertLogRelFailed
1465	* An assertion failed.
1466	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1467	*/
1468	#define AssertLogRelFailed() \
1469	do { \
1470	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1471	RTAssertPanic(); \
1472	} while (0)
1473
1474	/** @def AssertLogRelFailedReturn
1475	* An assertion failed.
1476	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1477	*
1478	* @param rc What is to be presented to return.
1479	*/
1480	#define AssertLogRelFailedReturn(rc) \
1481	do { \
1482	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1483	RTAssertPanic(); \
1484	return (rc); \
1485	} while (0)
1486
1487	/** @def AssertLogRelFailedReturnVoid
1488	* An assertion failed, hit a breakpoint and return.
1489	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1490	*/
1491	#define AssertLogRelFailedReturnVoid() \
1492	do { \
1493	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1494	RTAssertPanic(); \
1495	return; \
1496	} while (0)
1497
1498	/** @def AssertLogRelFailedBreak
1499	* An assertion failed, break.
1500	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1501	*/
1502	#define AssertLogRelFailedBreak() \
1503	if (1) \
1504	{ \
1505	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1506	RTAssertPanic(); \
1507	break; \
1508	} else \
1509	break
1510
1511	/** @def AssertLogRelFailedBreakStmt
1512	* An assertion failed, execute \a stmt and break.
1513	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1514	*
1515	* @param stmt Statement to execute before break.
1516	*/
1517	#define AssertLogRelFailedBreakStmt(stmt) \
1518	if (1) \
1519	{ \
1520	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1521	RTAssertPanic(); \
1522	stmt; \
1523	break; \
1524	} else \
1525	break
1526
1527	/** @def AssertLogRelMsgFailed
1528	* An assertion failed.
1529	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1530	*
1531	* @param a printf argument list (in parenthesis).
1532	*/
1533	#define AssertLogRelMsgFailed(a) \
1534	do { \
1535	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1536	RTAssertLogRelMsg2(a); \
1537	RTAssertPanic(); \
1538	} while (0)
1539
1540	/** @def AssertLogRelMsgFailedStmt
1541	* An assertion failed, execute @a stmt.
1542	*
1543	* Strict builds will hit a breakpoint, non-strict will only do LogRel. The
1544	* statement will be executed in regardless of build type.
1545	*
1546	* @param a printf argument list (in parenthesis).
1547	* @param stmt Statement to execute after raising/logging the assertion.
1548	*/
1549	#define AssertLogRelMsgFailedStmt(a, stmt) \
1550	do { \
1551	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1552	RTAssertLogRelMsg2(a); \
1553	RTAssertPanic(); \
1554	stmt; \
1555	} while (0)
1556
1557	/** @def AssertLogRelMsgFailedReturn
1558	* An assertion failed, return \a rc.
1559	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1560	*
1561	* @param a printf argument list (in parenthesis).
1562	* @param rc What is to be presented to return.
1563	*/
1564	#define AssertLogRelMsgFailedReturn(a, rc) \
1565	do { \
1566	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1567	RTAssertLogRelMsg2(a); \
1568	RTAssertPanic(); \
1569	return (rc); \
1570	} while (0)
1571
1572	/** @def AssertLogRelMsgFailedReturnStmt
1573	* An assertion failed, execute @a stmt and return @a rc.
1574	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1575	*
1576	* @param a printf argument list (in parenthesis).
1577	* @param stmt Statement to execute before returning in case of a failed
1578	* assertion.
1579	* @param rc What is to be presented to return.
1580	*/
1581	#define AssertLogRelMsgFailedReturnStmt(a, stmt, rc) \
1582	do { \
1583	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1584	RTAssertLogRelMsg2(a); \
1585	RTAssertPanic(); \
1586	stmt; \
1587	return (rc); \
1588	} while (0)
1589
1590	/** @def AssertLogRelMsgFailedReturnVoid
1591	* An assertion failed, return void.
1592	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1593	*
1594	* @param a printf argument list (in parenthesis).
1595	*/
1596	#define AssertLogRelMsgFailedReturnVoid(a) \
1597	do { \
1598	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1599	RTAssertLogRelMsg2(a); \
1600	RTAssertPanic(); \
1601	return; \
1602	} while (0)
1603
1604	/** @def AssertLogRelMsgFailedReturnVoidStmt
1605	* An assertion failed, execute @a stmt and return void.
1606	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1607	*
1608	* @param a printf argument list (in parenthesis).
1609	* @param stmt Statement to execute before returning in case of a failed
1610	* assertion.
1611	*/
1612	#define AssertLogRelMsgFailedReturnVoidStmt(a, stmt) \
1613	do { \
1614	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1615	RTAssertLogRelMsg2(a); \
1616	RTAssertPanic(); \
1617	stmt; \
1618	return; \
1619	} while (0)
1620
1621	/** @def AssertLogRelMsgFailedBreak
1622	* An assertion failed, break.
1623	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1624	*
1625	* @param a printf argument list (in parenthesis).
1626	*/
1627	#define AssertLogRelMsgFailedBreak(a) \
1628	if (1)\
1629	{ \
1630	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1631	RTAssertLogRelMsg2(a); \
1632	RTAssertPanic(); \
1633	break; \
1634	} else \
1635	break
1636
1637	/** @def AssertLogRelMsgFailedBreakStmt
1638	* An assertion failed, execute \a stmt and break.
1639	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1640	*
1641	* @param a printf argument list (in parenthesis).
1642	* @param stmt Statement to execute before break.
1643	*/
1644	#define AssertLogRelMsgFailedBreakStmt(a, stmt) \
1645	if (1) \
1646	{ \
1647	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1648	RTAssertLogRelMsg2(a); \
1649	RTAssertPanic(); \
1650	stmt; \
1651	break; \
1652	} else \
1653	break
1654
1655	/** @} */
1656
1657
1658
1659	/** @name Release Assertions
1660	*
1661	* These assertions are always enabled.
1662	* @{
1663	*/
1664
1665	/** @def RTAssertReleasePanic()
1666	* Invokes RTAssertShouldPanic and RTAssertDoPanic.
1667	*
1668	* It might seem odd that RTAssertShouldPanic is necessary when its result isn't
1669	* checked, but it's done since RTAssertShouldPanic is overrideable and might be
1670	* used to bail out before taking down the system (the VMMR0 case).
1671	*/
1672	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1673	# define RTAssertReleasePanic() do { RTAssertShouldPanic(); RTAssertDoPanic(); } while (0)
1674	#else
1675	# define RTAssertReleasePanic() do { } while (0)
1676	#endif
1677
1678
1679	/** @def AssertRelease
1680	* Assert that an expression is true. If it's not hit a breakpoint.
1681	*
1682	* @param expr Expression which should be true.
1683	*/
1684	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1685	# define AssertRelease(expr) \
1686	do { \
1687	if (RT_LIKELY(!!(expr))) \
1688	{ /* likely */ } \
1689	else \
1690	{ \
1691	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1692	RTAssertReleasePanic(); \
1693	} \
1694	} while (0)
1695	#else
1696	# define AssertRelease(expr) do { } while (0)
1697	#endif
1698
1699	/** @def AssertReleaseStmt
1700	* Assert that an expression is true. If false, hit breakpoint and execute the
1701	* statement.
1702	* @param expr Expression which should be true.
1703	* @param stmt Statement to execute on failure.
1704	*/
1705	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1706	# define AssertReleaseStmt(expr, stmt) \
1707	do { \
1708	if (RT_LIKELY(!!(expr))) \
1709	{ /* likely */ } \
1710	else \
1711	{ \
1712	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1713	RTAssertReleasePanic(); \
1714	stmt; \
1715	} \
1716	} while (0)
1717	#else
1718	# define AssertReleaseStmt(expr, stmt) \
1719	do { \
1720	if (RT_LIKELY(!!(expr))) \
1721	{ /* likely */ } \
1722	else \
1723	{ \
1724	stmt; \
1725	} \
1726	} while (0)
1727	#endif
1728
1729	/** @def AssertReleaseReturn
1730	* Assert that an expression is true, hit a breakpoint and return if it isn't.
1731	*
1732	* @param expr Expression which should be true.
1733	* @param rc What is to be presented to return.
1734	*/
1735	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1736	# define AssertReleaseReturn(expr, rc) \
1737	do { \
1738	if (RT_LIKELY(!!(expr))) \
1739	{ /* likely */ } \
1740	else \
1741	{ \
1742	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1743	RTAssertReleasePanic(); \
1744	return (rc); \
1745	} \
1746	} while (0)
1747	#else
1748	# define AssertReleaseReturn(expr, rc) \
1749	do { \
1750	if (RT_LIKELY(!!(expr))) \
1751	{ /* likely */ } \
1752	else \
1753	return (rc); \
1754	} while (0)
1755	#endif
1756
1757	/** @def AssertReleaseReturnVoid
1758	* Assert that an expression is true, hit a breakpoint and return if it isn't.
1759	*
1760	* @param expr Expression which should be true.
1761	*/
1762	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1763	# define AssertReleaseReturnVoid(expr) \
1764	do { \
1765	if (RT_LIKELY(!!(expr))) \
1766	{ /* likely */ } \
1767	else \
1768	{ \
1769	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1770	RTAssertReleasePanic(); \
1771	return; \
1772	} \
1773	} while (0)
1774	#else
1775	# define AssertReleaseReturnVoid(expr) \
1776	do { \
1777	if (RT_LIKELY(!!(expr))) \
1778	{ /* likely */ } \
1779	else \
1780	return; \
1781	} while (0)
1782	#endif
1783
1784
1785	/** @def AssertReleaseBreak
1786	* Assert that an expression is true, hit a breakpoint and break if it isn't.
1787	*
1788	* @param expr Expression which should be true.
1789	*/
1790	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1791	# define AssertReleaseBreak(expr) \
1792	if (RT_LIKELY(!!(expr))) \
1793	{ /* likely */ } \
1794	else if (1) \
1795	{ \
1796	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1797	RTAssertReleasePanic(); \
1798	break; \
1799	} else \
1800	break
1801	#else
1802	# define AssertReleaseBreak(expr) \
1803	if (RT_LIKELY(!!(expr))) \
1804	{ /* likely */ } \
1805	else \
1806	break
1807	#endif
1808
1809	/** @def AssertReleaseBreakStmt
1810	* Assert that an expression is true, hit a breakpoint and break if it isn't.
1811	*
1812	* @param expr Expression which should be true.
1813	* @param stmt Statement to execute before break in case of a failed assertion.
1814	*/
1815	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1816	# define AssertReleaseBreakStmt(expr, stmt) \
1817	if (RT_LIKELY(!!(expr))) \
1818	{ /* likely */ } \
1819	else if (1) \
1820	{ \
1821	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1822	RTAssertReleasePanic(); \
1823	stmt; \
1824	break; \
1825	} else \
1826	break
1827	#else
1828	# define AssertReleaseBreakStmt(expr, stmt) \
1829	if (RT_LIKELY(!!(expr))) \
1830	{ /* likely */ } \
1831	else if (1) \
1832	{ \
1833	stmt; \
1834	break; \
1835	} else \
1836	break
1837	#endif
1838
1839
1840	/** @def AssertReleaseMsg
1841	* Assert that an expression is true, print the message and hit a breakpoint if it isn't.
1842	*
1843	* @param expr Expression which should be true.
1844	* @param a printf argument list (in parenthesis).
1845	*/
1846	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1847	# define AssertReleaseMsg(expr, a) \
1848	do { \
1849	if (RT_LIKELY(!!(expr))) \
1850	{ /* likely */ } \
1851	else \
1852	{ \
1853	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1854	RTAssertMsg2Weak a; \
1855	RTAssertReleasePanic(); \
1856	} \
1857	} while (0)
1858	#else
1859	# define AssertReleaseMsg(expr, a) do { } while (0)
1860	#endif
1861
1862	/** @def AssertReleaseMsgReturn
1863	* Assert that an expression is true, print the message and hit a breakpoint and return if it isn't.
1864	*
1865	* @param expr Expression which should be true.
1866	* @param a printf argument list (in parenthesis).
1867	* @param rc What is to be presented to return.
1868	*/
1869	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1870	# define AssertReleaseMsgReturn(expr, a, rc) \
1871	do { \
1872	if (RT_LIKELY(!!(expr))) \
1873	{ /* likely */ } \
1874	else \
1875	{ \
1876	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1877	RTAssertMsg2Weak a; \
1878	RTAssertReleasePanic(); \
1879	return (rc); \
1880	} \
1881	} while (0)
1882	#else
1883	# define AssertReleaseMsgReturn(expr, a, rc) \
1884	do { \
1885	if (RT_LIKELY(!!(expr))) \
1886	{ /* likely */ } \
1887	else \
1888	return (rc); \
1889	} while (0)
1890	#endif
1891
1892	/** @def AssertReleaseMsgReturnVoid
1893	* Assert that an expression is true, print the message and hit a breakpoint and return if it isn't.
1894	*
1895	* @param expr Expression which should be true.
1896	* @param a printf argument list (in parenthesis).
1897	*/
1898	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1899	# define AssertReleaseMsgReturnVoid(expr, a) \
1900	do { \
1901	if (RT_LIKELY(!!(expr))) \
1902	{ /* likely */ } \
1903	else \
1904	{ \
1905	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1906	RTAssertMsg2Weak a; \
1907	RTAssertReleasePanic(); \
1908	return; \
1909	} \
1910	} while (0)
1911	#else
1912	# define AssertReleaseMsgReturnVoid(expr, a) \
1913	do { \
1914	if (RT_LIKELY(!!(expr))) \
1915	{ /* likely */ } \
1916	else \
1917	return; \
1918	} while (0)
1919	#endif
1920
1921
1922	/** @def AssertReleaseMsgBreak
1923	* Assert that an expression is true, print the message and hit a breakpoint and break if it isn't.
1924	*
1925	* @param expr Expression which should be true.
1926	* @param a printf argument list (in parenthesis).
1927	*/
1928	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1929	# define AssertReleaseMsgBreak(expr, a) \
1930	if (RT_LIKELY(!!(expr))) \
1931	{ /* likely */ } \
1932	else if (1) \
1933	{ \
1934	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1935	RTAssertMsg2Weak a; \
1936	RTAssertReleasePanic(); \
1937	break; \
1938	} else \
1939	break
1940	#else
1941	# define AssertReleaseMsgBreak(expr, a) \
1942	if (RT_LIKELY(!!(expr))) \
1943	{ /* likely */ } \
1944	else if (1) \
1945	break; \
1946	else \
1947	break
1948	#endif
1949
1950	/** @def AssertReleaseMsgBreakStmt
1951	* Assert that an expression is true, print the message and hit a breakpoint and break if it isn't.
1952	*
1953	* @param expr Expression which should be true.
1954	* @param a printf argument list (in parenthesis).
1955	* @param stmt Statement to execute before break in case of a failed assertion.
1956	*/
1957	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1958	# define AssertReleaseMsgBreakStmt(expr, a, stmt) \
1959	if (RT_LIKELY(!!(expr))) \
1960	{ /* likely */ } \
1961	else if (1) \
1962	{ \
1963	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1964	RTAssertMsg2Weak a; \
1965	RTAssertReleasePanic(); \
1966	stmt; \
1967	break; \
1968	} else \
1969	break
1970	#else
1971	# define AssertReleaseMsgBreakStmt(expr, a, stmt) \
1972	if (RT_LIKELY(!!(expr))) \
1973	{ /* likely */ } \
1974	else if (1) \
1975	{ \
1976	stmt; \
1977	break; \
1978	} else \
1979	break
1980	#endif
1981
1982
1983	/** @def AssertReleaseFailed
1984	* An assertion failed, hit a breakpoint.
1985	*/
1986	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
1987	# define AssertReleaseFailed() \
1988	do { \
1989	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
1990	RTAssertReleasePanic(); \
1991	} while (0)
1992	#else
1993	# define AssertReleaseFailed() do { } while (0)
1994	#endif
1995
1996	/** @def AssertReleaseFailedStmt
1997	* An assertion failed, hit breakpoint and execute statement.
1998	*/
1999	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
2000	# define AssertReleaseFailedStmt(stmt) \
2001	do { \
2002	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2003	RTAssertReleasePanic(); \
2004	stmt; \
2005	} while (0)
2006	#else
2007	# define AssertReleaseFailedStmt(stmt) do { stmt; } while (0)
2008	#endif
2009
2010	/** @def AssertReleaseFailedReturn
2011	* An assertion failed, hit a breakpoint and return.
2012	*
2013	* @param rc What is to be presented to return.
2014	*/
2015	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
2016	# define AssertReleaseFailedReturn(rc) \
2017	do { \
2018	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2019	RTAssertReleasePanic(); \
2020	return (rc); \
2021	} while (0)
2022	#else
2023	# define AssertReleaseFailedReturn(rc) \
2024	do { return (rc); } while (0)
2025	#endif
2026
2027	/** @def AssertReleaseFailedReturnVoid
2028	* An assertion failed, hit a breakpoint and return.
2029	*/
2030	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
2031	# define AssertReleaseFailedReturnVoid() \
2032	do { \
2033	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2034	RTAssertReleasePanic(); \
2035	return; \
2036	} while (0)
2037	#else
2038	# define AssertReleaseFailedReturnVoid() \
2039	do { return; } while (0)
2040	#endif
2041
2042	/** @def AssertReleaseFailedBreak
2043	* An assertion failed, hit a breakpoint and break.
2044	*/
2045	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
2046	# define AssertReleaseFailedBreak() \
2047	if (1) { \
2048	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2049	RTAssertReleasePanic(); \
2050	break; \
2051	} else \
2052	break
2053	#else
2054	# define AssertReleaseFailedBreak() \
2055	if (1) \
2056	break; \
2057	else \
2058	break
2059	#endif
2060
2061	/** @def AssertReleaseFailedBreakStmt
2062	* An assertion failed, hit a breakpoint and break.
2063	*
2064	* @param stmt Statement to execute before break.
2065	*/
2066	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
2067	# define AssertReleaseFailedBreakStmt(stmt) \
2068	if (1) { \
2069	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2070	RTAssertReleasePanic(); \
2071	stmt; \
2072	break; \
2073	} else \
2074	break
2075	#else
2076	# define AssertReleaseFailedBreakStmt(stmt) \
2077	if (1) { \
2078	stmt; \
2079	break; \
2080	} else \
2081	break
2082	#endif
2083
2084	/** @def AssertReleaseMsgFailed
2085	* An assertion failed, print a message and hit a breakpoint.
2086	*
2087	* @param a printf argument list (in parenthesis).
2088	*/
2089	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
2090	# define AssertReleaseMsgFailed(a) \
2091	do { \
2092	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2093	RTAssertMsg2Weak a; \
2094	RTAssertReleasePanic(); \
2095	} while (0)
2096	#else
2097	# define AssertReleaseMsgFailed(a) do { } while (0)
2098	#endif
2099
2100	/** @def AssertReleaseMsgFailedReturn
2101	* An assertion failed, print a message, hit a breakpoint and return.
2102	*
2103	* @param a printf argument list (in parenthesis).
2104	* @param rc What is to be presented to return.
2105	*/
2106	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
2107	# define AssertReleaseMsgFailedReturn(a, rc) \
2108	do { \
2109	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2110	RTAssertMsg2Weak a; \
2111	RTAssertReleasePanic(); \
2112	return (rc); \
2113	} while (0)
2114	#else
2115	# define AssertReleaseMsgFailedReturn(a, rc) \
2116	do { return (rc); } while (0)
2117	#endif
2118
2119	/** @def AssertReleaseMsgFailedReturnVoid
2120	* An assertion failed, print a message, hit a breakpoint and return.
2121	*
2122	* @param a printf argument list (in parenthesis).
2123	*/
2124	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
2125	# define AssertReleaseMsgFailedReturnVoid(a) \
2126	do { \
2127	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2128	RTAssertMsg2Weak a; \
2129	RTAssertReleasePanic(); \
2130	return; \
2131	} while (0)
2132	#else
2133	# define AssertReleaseMsgFailedReturnVoid(a) \
2134	do { return; } while (0)
2135	#endif
2136
2137
2138	/** @def AssertReleaseMsgFailedBreak
2139	* An assertion failed, print a message, hit a breakpoint and break.
2140	*
2141	* @param a printf argument list (in parenthesis).
2142	*/
2143	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
2144	# define AssertReleaseMsgFailedBreak(a) \
2145	if (1) { \
2146	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2147	RTAssertMsg2Weak a; \
2148	RTAssertReleasePanic(); \
2149	break; \
2150	} else \
2151	break
2152	#else
2153	# define AssertReleaseMsgFailedBreak(a) \
2154	if (1) \
2155	break; \
2156	else \
2157	break
2158	#endif
2159
2160	/** @def AssertReleaseMsgFailedBreakStmt
2161	* An assertion failed, print a message, hit a breakpoint and break.
2162	*
2163	* @param a printf argument list (in parenthesis).
2164	* @param stmt Statement to execute before break.
2165	*/
2166	#if defined(RT_STRICT) \|\| !defined(RTASSERT_NO_RELEASE_ASSERTIONS)
2167	# define AssertReleaseMsgFailedBreakStmt(a, stmt) \
2168	if (1) { \
2169	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2170	RTAssertMsg2Weak a; \
2171	RTAssertReleasePanic(); \
2172	stmt; \
2173	break; \
2174	} else \
2175	break
2176	#else
2177	# define AssertReleaseMsgFailedBreakStmt(a, stmt) \
2178	if (1) { \
2179	stmt; \
2180	break; \
2181	} else \
2182	break
2183	#endif
2184	/** @} */
2185
2186
2187
2188	/** @name Fatal Assertions
2189	* These are similar to release assertions except that you cannot ignore them in
2190	* any way, they will loop for ever if RTAssertDoPanic returns.
2191	*
2192	* @{
2193	*/
2194
2195	/** @def AssertFatal
2196	* Assert that an expression is true. If it's not hit a breakpoint (for ever).
2197	*
2198	* @param expr Expression which should be true.
2199	*/
2200	#define AssertFatal(expr) \
2201	do { \
2202	if (RT_LIKELY(!!(expr))) \
2203	{ /* likely */ } \
2204	else \
2205	for (;;) \
2206	{ \
2207	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2208	RTAssertReleasePanic(); \
2209	} \
2210	} while (0)
2211
2212	/** @def AssertFatalMsg
2213	* Assert that an expression is true, print the message and hit a breakpoint (for ever) if it isn't.
2214	*
2215	* @param expr Expression which should be true.
2216	* @param a printf argument list (in parenthesis).
2217	*/
2218	#define AssertFatalMsg(expr, a) \
2219	do { \
2220	if (RT_LIKELY(!!(expr))) \
2221	{ /* likely */ } \
2222	else \
2223	for (;;) \
2224	{ \
2225	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2226	RTAssertMsg2Weak a; \
2227	RTAssertReleasePanic(); \
2228	} \
2229	} while (0)
2230
2231	/** @def AssertFatalFailed
2232	* An assertion failed, hit a breakpoint (for ever).
2233	*/
2234	#define AssertFatalFailed() \
2235	do { \
2236	for (;;) \
2237	{ \
2238	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2239	RTAssertReleasePanic(); \
2240	} \
2241	} while (0)
2242
2243	/** @def AssertFatalMsgFailed
2244	* An assertion failed, print a message and hit a breakpoint (for ever).
2245	*
2246	* @param a printf argument list (in parenthesis).
2247	*/
2248	#define AssertFatalMsgFailed(a) \
2249	do { \
2250	for (;;) \
2251	{ \
2252	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, RT_GCC_EXTENSION __PRETTY_FUNCTION__); \
2253	RTAssertMsg2Weak a; \
2254	RTAssertReleasePanic(); \
2255	} \
2256	} while (0)
2257
2258	/** @} */
2259
2260
2261
2262	/** @name Convenience Assertions Macros
2263	* @{
2264	*/
2265
2266	/** @def AssertRC
2267	* Asserts a iprt status code successful.
2268	*
2269	* On failure it will print info about the rc and hit a breakpoint.
2270	*
2271	* @param rc iprt status code.
2272	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2273	*/
2274	#define AssertRC(rc) AssertMsgRC(rc, ("%Rra\n", (rc)))
2275
2276	/** @def AssertRCStmt
2277	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and execute
2278	* @a stmt if it isn't.
2279	*
2280	* @param rc iprt status code.
2281	* @param stmt Statement to execute before returning in case of a failed
2282	* assertion.
2283	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2284	*/
2285	#define AssertRCStmt(rc, stmt) AssertMsgRCStmt(rc, ("%Rra\n", (rc)), stmt)
2286
2287	/** @def AssertRCReturn
2288	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
2289	*
2290	* @param rc iprt status code.
2291	* @param rcRet What is to be presented to return.
2292	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2293	*/
2294	#define AssertRCReturn(rc, rcRet) AssertMsgRCReturn(rc, ("%Rra\n", (rc)), rcRet)
2295
2296	/** @def AssertRCReturnStmt
2297	* Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
2298	* @a stmt and returns @a rcRet if it isn't.
2299	*
2300	* @param rc iprt status code.
2301	* @param stmt Statement to execute before returning in case of a failed
2302	* assertion.
2303	* @param rcRet What is to be presented to return.
2304	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2305	*/
2306	#define AssertRCReturnStmt(rc, stmt, rcRet) AssertMsgRCReturnStmt(rc, ("%Rra\n", (rc)), stmt, rcRet)
2307
2308	/** @def AssertRCReturnVoid
2309	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
2310	*
2311	* @param rc iprt status code.
2312	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2313	*/
2314	#define AssertRCReturnVoid(rc) AssertMsgRCReturnVoid(rc, ("%Rra\n", (rc)))
2315
2316	/** @def AssertRCReturnVoidStmt
2317	* Asserts a iprt status code successful, bitch (RT_STRICT mode only), and
2318	* execute the given statement/return if it isn't.
2319	*
2320	* @param rc iprt status code.
2321	* @param stmt Statement to execute before returning on failure.
2322	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2323	*/
2324	#define AssertRCReturnVoidStmt(rc, stmt) AssertMsgRCReturnVoidStmt(rc, ("%Rra\n", (rc)), stmt)
2325
2326	/** @def AssertRCBreak
2327	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break if it isn't.
2328	*
2329	* @param rc iprt status code.
2330	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2331	*/
2332	#define AssertRCBreak(rc) AssertMsgRCBreak(rc, ("%Rra\n", (rc)))
2333
2334	/** @def AssertRCBreakStmt
2335	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break if it isn't.
2336	*
2337	* @param rc iprt status code.
2338	* @param stmt Statement to execute before break in case of a failed assertion.
2339	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2340	*/
2341	#define AssertRCBreakStmt(rc, stmt) AssertMsgRCBreakStmt(rc, ("%Rra\n", (rc)), stmt)
2342
2343	/** @def AssertMsgRC
2344	* Asserts a iprt status code successful.
2345	*
2346	* It prints a custom message and hits a breakpoint on FAILURE.
2347	*
2348	* @param rc iprt status code.
2349	* @param msg printf argument list (in parenthesis).
2350	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2351	*/
2352	#define AssertMsgRC(rc, msg) \
2353	do { AssertMsg(RT_SUCCESS_NP(rc), msg); NOREF(rc); } while (0)
2354
2355	/** @def AssertMsgRCStmt
2356	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and
2357	* execute @a stmt if it isn't.
2358	*
2359	* @param rc iprt status code.
2360	* @param msg printf argument list (in parenthesis).
2361	* @param stmt Statement to execute before returning in case of a failed
2362	* assertion.
2363	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2364	*/
2365	#define AssertMsgRCStmt(rc, msg, stmt) \
2366	do { AssertMsgStmt(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } while (0)
2367
2368	/** @def AssertMsgRCReturn
2369	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return
2370	* @a rcRet if it isn't.
2371	*
2372	* @param rc iprt status code.
2373	* @param msg printf argument list (in parenthesis).
2374	* @param rcRet What is to be presented to return.
2375	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2376	*/
2377	#define AssertMsgRCReturn(rc, msg, rcRet) \
2378	do { AssertMsgReturn(RT_SUCCESS_NP(rc), msg, rcRet); NOREF(rc); } while (0)
2379
2380	/** @def AssertMsgRCReturnStmt
2381	* Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
2382	* @a stmt and return @a rcRet if it isn't.
2383	*
2384	* @param rc iprt status code.
2385	* @param msg printf argument list (in parenthesis).
2386	* @param stmt Statement to execute before returning in case of a failed
2387	* assertion.
2388	* @param rcRet What is to be presented to return.
2389	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2390	*/
2391	#define AssertMsgRCReturnStmt(rc, msg, stmt, rcRet) \
2392	do { AssertMsgReturnStmt(RT_SUCCESS_NP(rc), msg, stmt, rcRet); NOREF(rc); } while (0)
2393
2394	/** @def AssertMsgRCReturnVoid
2395	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return
2396	* void if it isn't.
2397	*
2398	* @param rc iprt status code.
2399	* @param msg printf argument list (in parenthesis).
2400	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2401	*/
2402	#define AssertMsgRCReturnVoid(rc, msg) \
2403	do { AssertMsgReturnVoid(RT_SUCCESS_NP(rc), msg); NOREF(rc); } while (0)
2404
2405	/** @def AssertMsgRCReturnVoidStmt
2406	* Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
2407	* @a stmt and return void if it isn't.
2408	*
2409	* @param rc iprt status code.
2410	* @param msg printf argument list (in parenthesis).
2411	* @param stmt Statement to execute before break in case of a failed assertion.
2412	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2413	*/
2414	#define AssertMsgRCReturnVoidStmt(rc, msg, stmt) \
2415	do { AssertMsgReturnVoidStmt(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } while (0)
2416
2417	/** @def AssertMsgRCBreak
2418	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break
2419	* if it isn't.
2420	*
2421	* @param rc iprt status code.
2422	* @param msg printf argument list (in parenthesis).
2423	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2424	*/
2425	#define AssertMsgRCBreak(rc, msg) \
2426	if (1) { AssertMsgBreak(RT_SUCCESS(rc), msg); NOREF(rc); } else do {} while (0)
2427
2428	/** @def AssertMsgRCBreakStmt
2429	* Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
2430	* @a stmt and break if it isn't.
2431	*
2432	* @param rc iprt status code.
2433	* @param msg printf argument list (in parenthesis).
2434	* @param stmt Statement to execute before break in case of a failed assertion.
2435	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2436	*/
2437	#define AssertMsgRCBreakStmt(rc, msg, stmt) \
2438	if (1) { AssertMsgBreakStmt(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } else do {} while (0)
2439
2440	/** @def AssertRCSuccess
2441	* Asserts an iprt status code equals VINF_SUCCESS.
2442	*
2443	* On failure it will print info about the rc and hit a breakpoint.
2444	*
2445	* @param rc iprt status code.
2446	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2447	*/
2448	#define AssertRCSuccess(rc) do { AssertMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc))); NOREF(rc); } while (0)
2449
2450	/** @def AssertRCSuccessReturn
2451	* Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
2452	*
2453	* @param rc iprt status code.
2454	* @param rcRet What is to be presented to return.
2455	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2456	*/
2457	#define AssertRCSuccessReturn(rc, rcRet) AssertMsgReturn((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)
2458
2459	/** @def AssertRCSuccessReturnVoid
2460	* Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
2461	*
2462	* @param rc iprt status code.
2463	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2464	*/
2465	#define AssertRCSuccessReturnVoid(rc) AssertMsgReturnVoid((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2466
2467	/** @def AssertRCSuccessBreak
2468	* Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
2469	*
2470	* @param rc iprt status code.
2471	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2472	*/
2473	#define AssertRCSuccessBreak(rc) AssertMsgBreak((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2474
2475	/** @def AssertRCSuccessBreakStmt
2476	* Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
2477	*
2478	* @param rc iprt status code.
2479	* @param stmt Statement to execute before break in case of a failed assertion.
2480	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2481	*/
2482	#define AssertRCSuccessBreakStmt(rc, stmt) AssertMsgBreakStmt((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)
2483
2484
2485	/** @def AssertLogRelRC
2486	* Asserts a iprt status code successful.
2487	*
2488	* @param rc iprt status code.
2489	* @remark rc is referenced multiple times.
2490	*/
2491	#define AssertLogRelRC(rc) AssertLogRelMsgRC(rc, ("%Rra\n", (rc)))
2492
2493	/** @def AssertLogRelRCReturn
2494	* Asserts a iprt status code successful, returning \a rc if it isn't.
2495	*
2496	* @param rc iprt status code.
2497	* @param rcRet What is to be presented to return.
2498	* @remark rc is referenced multiple times.
2499	*/
2500	#define AssertLogRelRCReturn(rc, rcRet) AssertLogRelMsgRCReturn(rc, ("%Rra\n", (rc)), rcRet)
2501
2502	/** @def AssertLogRelRCReturnStmt
2503	* Asserts a iprt status code successful, executing \a stmt and returning \a rc
2504	* if it isn't.
2505	*
2506	* @param rc iprt status code.
2507	* @param stmt Statement to execute before returning in case of a failed
2508	* assertion.
2509	* @param rcRet What is to be presented to return.
2510	* @remark rc is referenced multiple times.
2511	*/
2512	#define AssertLogRelRCReturnStmt(rc, stmt, rcRet) AssertLogRelMsgRCReturnStmt(rc, ("%Rra\n", (rc)), stmt, rcRet)
2513
2514	/** @def AssertLogRelRCReturnVoid
2515	* Asserts a iprt status code successful, returning (void) if it isn't.
2516	*
2517	* @param rc iprt status code.
2518	* @remark rc is referenced multiple times.
2519	*/
2520	#define AssertLogRelRCReturnVoid(rc) AssertLogRelMsgRCReturnVoid(rc, ("%Rra\n", (rc)))
2521
2522	/** @def AssertLogRelRCBreak
2523	* Asserts a iprt status code successful, breaking if it isn't.
2524	*
2525	* @param rc iprt status code.
2526	* @remark rc is referenced multiple times.
2527	*/
2528	#define AssertLogRelRCBreak(rc) AssertLogRelMsgRCBreak(rc, ("%Rra\n", (rc)))
2529
2530	/** @def AssertLogRelRCBreakStmt
2531	* Asserts a iprt status code successful, execute \a statement and break if it isn't.
2532	*
2533	* @param rc iprt status code.
2534	* @param stmt Statement to execute before break in case of a failed assertion.
2535	* @remark rc is referenced multiple times.
2536	*/
2537	#define AssertLogRelRCBreakStmt(rc, stmt) AssertLogRelMsgRCBreakStmt(rc, ("%Rra\n", (rc)), stmt)
2538
2539	/** @def AssertLogRelMsgRC
2540	* Asserts a iprt status code successful.
2541	*
2542	* @param rc iprt status code.
2543	* @param msg printf argument list (in parenthesis).
2544	* @remark rc is referenced multiple times.
2545	*/
2546	#define AssertLogRelMsgRC(rc, msg) AssertLogRelMsg(RT_SUCCESS_NP(rc), msg)
2547
2548	/** @def AssertLogRelMsgRCReturn
2549	* Asserts a iprt status code successful.
2550	*
2551	* @param rc iprt status code.
2552	* @param msg printf argument list (in parenthesis).
2553	* @param rcRet What is to be presented to return.
2554	* @remark rc is referenced multiple times.
2555	*/
2556	#define AssertLogRelMsgRCReturn(rc, msg, rcRet) AssertLogRelMsgReturn(RT_SUCCESS_NP(rc), msg, rcRet)
2557
2558	/** @def AssertLogRelMsgRCReturnStmt
2559	* Asserts a iprt status code successful, execute \a stmt and return on
2560	* failure.
2561	*
2562	* @param rc iprt status code.
2563	* @param msg printf argument list (in parenthesis).
2564	* @param stmt Statement to execute before returning in case of a failed
2565	* assertion.
2566	* @param rcRet What is to be presented to return.
2567	* @remark rc is referenced multiple times.
2568	*/
2569	#define AssertLogRelMsgRCReturnStmt(rc, msg, stmt, rcRet) AssertLogRelMsgReturnStmt(RT_SUCCESS_NP(rc), msg, stmt, rcRet)
2570
2571	/** @def AssertLogRelMsgRCReturnVoid
2572	* Asserts a iprt status code successful.
2573	*
2574	* @param rc iprt status code.
2575	* @param msg printf argument list (in parenthesis).
2576	* @remark rc is referenced multiple times.
2577	*/
2578	#define AssertLogRelMsgRCReturnVoid(rc, msg) AssertLogRelMsgReturnVoid(RT_SUCCESS_NP(rc), msg)
2579
2580	/** @def AssertLogRelMsgRCBreak
2581	* Asserts a iprt status code successful.
2582	*
2583	* @param rc iprt status code.
2584	* @param msg printf argument list (in parenthesis).
2585	* @remark rc is referenced multiple times.
2586	*/
2587	#define AssertLogRelMsgRCBreak(rc, msg) AssertLogRelMsgBreak(RT_SUCCESS(rc), msg)
2588
2589	/** @def AssertLogRelMsgRCBreakStmt
2590	* Asserts a iprt status code successful, execute \a stmt and break if it isn't.
2591	*
2592	* @param rc iprt status code.
2593	* @param msg printf argument list (in parenthesis).
2594	* @param stmt Statement to execute before break in case of a failed assertion.
2595	* @remark rc is referenced multiple times.
2596	*/
2597	#define AssertLogRelMsgRCBreakStmt(rc, msg, stmt) AssertLogRelMsgBreakStmt(RT_SUCCESS_NP(rc), msg, stmt)
2598
2599	/** @def AssertLogRelRCSuccess
2600	* Asserts that an iprt status code equals VINF_SUCCESS.
2601	*
2602	* @param rc iprt status code.
2603	* @remark rc is referenced multiple times.
2604	*/
2605	#define AssertLogRelRCSuccess(rc) AssertLogRelMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2606
2607	/** @def AssertLogRelRCSuccessReturn
2608	* Asserts that an iprt status code equals VINF_SUCCESS.
2609	*
2610	* @param rc iprt status code.
2611	* @param rcRet What is to be presented to return.
2612	* @remark rc is referenced multiple times.
2613	*/
2614	#define AssertLogRelRCSuccessReturn(rc, rcRet) AssertLogRelMsgReturn((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)
2615
2616	/** @def AssertLogRelRCSuccessReturnVoid
2617	* Asserts that an iprt status code equals VINF_SUCCESS.
2618	*
2619	* @param rc iprt status code.
2620	* @remark rc is referenced multiple times.
2621	*/
2622	#define AssertLogRelRCSuccessReturnVoid(rc) AssertLogRelMsgReturnVoid((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2623
2624	/** @def AssertLogRelRCSuccessBreak
2625	* Asserts that an iprt status code equals VINF_SUCCESS.
2626	*
2627	* @param rc iprt status code.
2628	* @remark rc is referenced multiple times.
2629	*/
2630	#define AssertLogRelRCSuccessBreak(rc) AssertLogRelMsgBreak((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2631
2632	/** @def AssertLogRelRCSuccessBreakStmt
2633	* Asserts that an iprt status code equals VINF_SUCCESS.
2634	*
2635	* @param rc iprt status code.
2636	* @param stmt Statement to execute before break in case of a failed assertion.
2637	* @remark rc is referenced multiple times.
2638	*/
2639	#define AssertLogRelRCSuccessBreakStmt(rc, stmt) AssertLogRelMsgBreakStmt((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)
2640
2641
2642	/** @def AssertReleaseRC
2643	* Asserts a iprt status code successful.
2644	*
2645	* On failure information about the error will be printed and a breakpoint hit.
2646	*
2647	* @param rc iprt status code.
2648	* @remark rc is referenced multiple times.
2649	*/
2650	#define AssertReleaseRC(rc) AssertReleaseMsgRC(rc, ("%Rra\n", (rc)))
2651
2652	/** @def AssertReleaseRCReturn
2653	* Asserts a iprt status code successful, returning if it isn't.
2654	*
2655	* On failure information about the error will be printed, a breakpoint hit
2656	* and finally returning from the function if the breakpoint is somehow ignored.
2657	*
2658	* @param rc iprt status code.
2659	* @param rcRet What is to be presented to return.
2660	* @remark rc is referenced multiple times.
2661	*/
2662	#define AssertReleaseRCReturn(rc, rcRet) AssertReleaseMsgRCReturn(rc, ("%Rra\n", (rc)), rcRet)
2663
2664	/** @def AssertReleaseRCReturnVoid
2665	* Asserts a iprt status code successful, returning if it isn't.
2666	*
2667	* On failure information about the error will be printed, a breakpoint hit
2668	* and finally returning from the function if the breakpoint is somehow ignored.
2669	*
2670	* @param rc iprt status code.
2671	* @remark rc is referenced multiple times.
2672	*/
2673	#define AssertReleaseRCReturnVoid(rc) AssertReleaseMsgRCReturnVoid(rc, ("%Rra\n", (rc)))
2674
2675	/** @def AssertReleaseRCBreak
2676	* Asserts a iprt status code successful, breaking if it isn't.
2677	*
2678	* On failure information about the error will be printed, a breakpoint hit
2679	* and finally breaking the current statement if the breakpoint is somehow ignored.
2680	*
2681	* @param rc iprt status code.
2682	* @remark rc is referenced multiple times.
2683	*/
2684	#define AssertReleaseRCBreak(rc) AssertReleaseMsgRCBreak(rc, ("%Rra\n", (rc)))
2685
2686	/** @def AssertReleaseRCBreakStmt
2687	* Asserts a iprt status code successful, break if it isn't.
2688	*
2689	* On failure information about the error will be printed, a breakpoint hit
2690	* and finally the break statement will be issued if the breakpoint is somehow ignored.
2691	*
2692	* @param rc iprt status code.
2693	* @param stmt Statement to execute before break in case of a failed assertion.
2694	* @remark rc is referenced multiple times.
2695	*/
2696	#define AssertReleaseRCBreakStmt(rc, stmt) AssertReleaseMsgRCBreakStmt(rc, ("%Rra\n", (rc)), stmt)
2697
2698	/** @def AssertReleaseMsgRC
2699	* Asserts a iprt status code successful.
2700	*
2701	* On failure a custom message is printed and a breakpoint is hit.
2702	*
2703	* @param rc iprt status code.
2704	* @param msg printf argument list (in parenthesis).
2705	* @remark rc is referenced multiple times.
2706	*/
2707	#define AssertReleaseMsgRC(rc, msg) AssertReleaseMsg(RT_SUCCESS_NP(rc), msg)
2708
2709	/** @def AssertReleaseMsgRCReturn
2710	* Asserts a iprt status code successful.
2711	*
2712	* On failure a custom message is printed, a breakpoint is hit, and finally
2713	* returning from the function if the breakpoint is somehow ignored.
2714	*
2715	* @param rc iprt status code.
2716	* @param msg printf argument list (in parenthesis).
2717	* @param rcRet What is to be presented to return.
2718	* @remark rc is referenced multiple times.
2719	*/
2720	#define AssertReleaseMsgRCReturn(rc, msg, rcRet) AssertReleaseMsgReturn(RT_SUCCESS_NP(rc), msg, rcRet)
2721
2722	/** @def AssertReleaseMsgRCReturnVoid
2723	* Asserts a iprt status code successful.
2724	*
2725	* On failure a custom message is printed, a breakpoint is hit, and finally
2726	* returning from the function if the breakpoint is somehow ignored.
2727	*
2728	* @param rc iprt status code.
2729	* @param msg printf argument list (in parenthesis).
2730	* @remark rc is referenced multiple times.
2731	*/
2732	#define AssertReleaseMsgRCReturnVoid(rc, msg) AssertReleaseMsgReturnVoid(RT_SUCCESS_NP(rc), msg)
2733
2734	/** @def AssertReleaseMsgRCBreak
2735	* Asserts a iprt status code successful.
2736	*
2737	* On failure a custom message is printed, a breakpoint is hit, and finally
2738	* breaking the current status if the breakpoint is somehow ignored.
2739	*
2740	* @param rc iprt status code.
2741	* @param msg printf argument list (in parenthesis).
2742	* @remark rc is referenced multiple times.
2743	*/
2744	#define AssertReleaseMsgRCBreak(rc, msg) AssertReleaseMsgBreak(RT_SUCCESS(rc), msg)
2745
2746	/** @def AssertReleaseMsgRCBreakStmt
2747	* Asserts a iprt status code successful.
2748	*
2749	* On failure a custom message is printed, a breakpoint is hit, and finally
2750	* the break statement is issued if the breakpoint is somehow ignored.
2751	*
2752	* @param rc iprt status code.
2753	* @param msg printf argument list (in parenthesis).
2754	* @param stmt Statement to execute before break in case of a failed assertion.
2755	* @remark rc is referenced multiple times.
2756	*/
2757	#define AssertReleaseMsgRCBreakStmt(rc, msg, stmt) AssertReleaseMsgBreakStmt(RT_SUCCESS_NP(rc), msg, stmt)
2758
2759	/** @def AssertReleaseRCSuccess
2760	* Asserts that an iprt status code equals VINF_SUCCESS.
2761	*
2762	* On failure information about the error will be printed and a breakpoint hit.
2763	*
2764	* @param rc iprt status code.
2765	* @remark rc is referenced multiple times.
2766	*/
2767	#define AssertReleaseRCSuccess(rc) AssertReleaseMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2768
2769	/** @def AssertReleaseRCSuccessReturn
2770	* Asserts that an iprt status code equals VINF_SUCCESS.
2771	*
2772	* On failure information about the error will be printed, a breakpoint hit
2773	* and finally returning from the function if the breakpoint is somehow ignored.
2774	*
2775	* @param rc iprt status code.
2776	* @param rcRet What is to be presented to return.
2777	* @remark rc is referenced multiple times.
2778	*/
2779	#define AssertReleaseRCSuccessReturn(rc, rcRet) AssertReleaseMsgReturn((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)
2780
2781	/** @def AssertReleaseRCSuccessReturnVoid
2782	* Asserts that an iprt status code equals VINF_SUCCESS.
2783	*
2784	* On failure information about the error will be printed, a breakpoint hit
2785	* and finally returning from the function if the breakpoint is somehow ignored.
2786	*
2787	* @param rc iprt status code.
2788	* @remark rc is referenced multiple times.
2789	*/
2790	#define AssertReleaseRCSuccessReturnVoid(rc) AssertReleaseMsgReturnVoid((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2791
2792	/** @def AssertReleaseRCSuccessBreak
2793	* Asserts that an iprt status code equals VINF_SUCCESS.
2794	*
2795	* On failure information about the error will be printed, a breakpoint hit
2796	* and finally breaking the current statement if the breakpoint is somehow ignored.
2797	*
2798	* @param rc iprt status code.
2799	* @remark rc is referenced multiple times.
2800	*/
2801	#define AssertReleaseRCSuccessBreak(rc) AssertReleaseMsgBreak((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2802
2803	/** @def AssertReleaseRCSuccessBreakStmt
2804	* Asserts that an iprt status code equals VINF_SUCCESS.
2805	*
2806	* On failure information about the error will be printed, a breakpoint hit
2807	* and finally the break statement will be issued if the breakpoint is somehow ignored.
2808	*
2809	* @param rc iprt status code.
2810	* @param stmt Statement to execute before break in case of a failed assertion.
2811	* @remark rc is referenced multiple times.
2812	*/
2813	#define AssertReleaseRCSuccessBreakStmt(rc, stmt) AssertReleaseMsgBreakStmt((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)
2814
2815
2816	/** @def AssertFatalRC
2817	* Asserts a iprt status code successful.
2818	*
2819	* On failure information about the error will be printed and a breakpoint hit.
2820	*
2821	* @param rc iprt status code.
2822	* @remark rc is referenced multiple times.
2823	*/
2824	#define AssertFatalRC(rc) AssertFatalMsgRC(rc, ("%Rra\n", (rc)))
2825
2826	/** @def AssertReleaseMsgRC
2827	* Asserts a iprt status code successful.
2828	*
2829	* On failure a custom message is printed and a breakpoint is hit.
2830	*
2831	* @param rc iprt status code.
2832	* @param msg printf argument list (in parenthesis).
2833	* @remark rc is referenced multiple times.
2834	*/
2835	#define AssertFatalMsgRC(rc, msg) AssertFatalMsg(RT_SUCCESS_NP(rc), msg)
2836
2837	/** @def AssertFatalRCSuccess
2838	* Asserts that an iprt status code equals VINF_SUCCESS.
2839	*
2840	* On failure information about the error will be printed and a breakpoint hit.
2841	*
2842	* @param rc iprt status code.
2843	* @remark rc is referenced multiple times.
2844	*/
2845	#define AssertFatalRCSuccess(rc) AssertFatalMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2846
2847
2848	/** @def AssertPtr
2849	* Asserts that a pointer is valid.
2850	*
2851	* @param pv The pointer.
2852	*/
2853	#define AssertPtr(pv) AssertMsg(RT_VALID_PTR(pv), ("%p\n", (pv)))
2854
2855	/** @def AssertPtrReturn
2856	* Asserts that a pointer is valid.
2857	*
2858	* @param pv The pointer.
2859	* @param rcRet What is to be presented to return.
2860	*/
2861	#define AssertPtrReturn(pv, rcRet) AssertMsgReturn(RT_VALID_PTR(pv), ("%p\n", (pv)), rcRet)
2862
2863	/** @def AssertPtrReturnVoid
2864	* Asserts that a pointer is valid.
2865	*
2866	* @param pv The pointer.
2867	*/
2868	#define AssertPtrReturnVoid(pv) AssertMsgReturnVoid(RT_VALID_PTR(pv), ("%p\n", (pv)))
2869
2870	/** @def AssertPtrReturnStmt
2871	* Asserts that a pointer is valid.
2872	*
2873	* @param pv The pointer.
2874	* @param stmt Statement to execute before returninig in case of a failed
2875	* assertion.
2876	* @param rcRet What is to be presented to return.
2877	*/
2878	#define AssertPtrReturnStmt(pv, stmt, rcRet) AssertMsgReturnStmt(RT_VALID_PTR(pv), ("%p\n", (pv)), stmt, rcRet)
2879
2880	/** @def AssertPtrReturnVoidStmt
2881	* Asserts that a pointer is valid.
2882	*
2883	* @param pv The pointer.
2884	* @param stmt Statement to execute before returninig in case of a failed
2885	* assertion.
2886	*/
2887	#define AssertPtrReturnVoidStmt(pv, stmt) AssertMsgReturnVoid(RT_VALID_PTR(pv), ("%p\n", (pv)), stmt)
2888
2889	/** @def AssertPtrBreak
2890	* Asserts that a pointer is valid.
2891	*
2892	* @param pv The pointer.
2893	*/
2894	#define AssertPtrBreak(pv) AssertMsgBreak(RT_VALID_PTR(pv), ("%p\n", (pv)))
2895
2896	/** @def AssertPtrBreakStmt
2897	* Asserts that a pointer is valid.
2898	*
2899	* @param pv The pointer.
2900	* @param stmt Statement to execute before break in case of a failed assertion.
2901	*/
2902	#define AssertPtrBreakStmt(pv, stmt) AssertMsgBreakStmt(RT_VALID_PTR(pv), ("%p\n", (pv)), stmt)
2903
2904	/** @def AssertPtrNull
2905	* Asserts that a pointer is valid or NULL.
2906	*
2907	* @param pv The pointer.
2908	*/
2909	#define AssertPtrNull(pv) AssertMsg(RT_VALID_PTR(pv) \|\| (pv) == NULL, ("%p\n", (pv)))
2910
2911	/** @def AssertPtrNullReturn
2912	* Asserts that a pointer is valid or NULL.
2913	*
2914	* @param pv The pointer.
2915	* @param rcRet What is to be presented to return.
2916	*/
2917	#define AssertPtrNullReturn(pv, rcRet) AssertMsgReturn(RT_VALID_PTR(pv) \|\| (pv) == NULL, ("%p\n", (pv)), rcRet)
2918
2919	/** @def AssertPtrNullReturnVoid
2920	* Asserts that a pointer is valid or NULL.
2921	*
2922	* @param pv The pointer.
2923	*/
2924	#define AssertPtrNullReturnVoid(pv) AssertMsgReturnVoid(RT_VALID_PTR(pv) \|\| (pv) == NULL, ("%p\n", (pv)))
2925
2926	/** @def AssertPtrNullBreak
2927	* Asserts that a pointer is valid or NULL.
2928	*
2929	* @param pv The pointer.
2930	*/
2931	#define AssertPtrNullBreak(pv) AssertMsgBreak(RT_VALID_PTR(pv) \|\| (pv) == NULL, ("%p\n", (pv)))
2932
2933	/** @def AssertPtrNullBreakStmt
2934	* Asserts that a pointer is valid or NULL.
2935	*
2936	* @param pv The pointer.
2937	* @param stmt Statement to execute before break in case of a failed assertion.
2938	*/
2939	#define AssertPtrNullBreakStmt(pv, stmt) AssertMsgBreakStmt(RT_VALID_PTR(pv) \|\| (pv) == NULL, ("%p\n", (pv)), stmt)
2940
2941	/** @def AssertGCPhys32
2942	* Asserts that the high dword of a physical address is zero
2943	*
2944	* @param GCPhys The address (RTGCPHYS).
2945	*/
2946	#define AssertGCPhys32(GCPhys) AssertMsg(VALID_PHYS32(GCPhys), ("%RGp\n", (RTGCPHYS)(GCPhys)))
2947
2948	/** @def AssertGCPtr32
2949	* Asserts that the high dword of a physical address is zero
2950	*
2951	* @param GCPtr The address (RTGCPTR).
2952	*/
2953	#if GC_ARCH_BITS == 32
2954	# define AssertGCPtr32(GCPtr) do { } while (0)
2955	#else
2956	# define AssertGCPtr32(GCPtr) AssertMsg(!((GCPtr) & UINT64_C(0xffffffff00000000)), ("%RGv\n", GCPtr))
2957	#endif
2958
2959	/** @def AssertForEach
2960	* Equivalent to Assert for each value of the variable from the starting
2961	* value to the finishing one.
2962	*
2963	* @param var Name of the counter variable.
2964	* @param vartype Type of the counter variable.
2965	* @param first Lowest inclusive value of the counter variable.
2966	* This must be free from side effects.
2967	* @param end Highest exclusive value of the counter variable.
2968	* This must be free from side effects.
2969	* @param expr Expression which should be true for each value of @a var.
2970	*/
2971	#define AssertForEach(var, vartype, first, end, expr) \
2972	do { \
2973	vartype var; \
2974	Assert((first) == (first) && (end) == (end)); /* partial check for side effects */ \
2975	for (var = (first); var < (end); var++) \
2976	AssertMsg(expr, ("%s = %#RX64 (%RI64)", #var, (uint64_t)var, (int64_t)var)); \
2977	} while (0)
2978
2979	#ifdef RT_OS_WINDOWS
2980
2981	/** @def AssertNtStatus
2982	* Asserts that the NT_SUCCESS() returns true for the given NTSTATUS value.
2983	*
2984	* @param a_rcNt The NTSTATUS to check. Will be evaluated twice and
2985	* subjected to NOREF().
2986	* @sa AssertRC()
2987	*/
2988	# define AssertNtStatus(a_rcNt) \
2989	do { AssertMsg(NT_SUCCESS(a_rcNt), ("%#x\n", (a_rcNt))); NOREF(a_rcNt); } while (0)
2990
2991	/** @def AssertNtStatusSuccess
2992	* Asserts that the given NTSTATUS value equals STATUS_SUCCESS.
2993	*
2994	* @param a_rcNt The NTSTATUS to check. Will be evaluated twice and
2995	* subjected to NOREF().
2996	* @sa AssertRCSuccess()
2997	*/
2998	# define AssertNtStatusSuccess(a_rcNt) \
2999	do { AssertMsg((a_rcNt) == STATUS_SUCCESS, ("%#x\n", (a_rcNt))); NOREF(a_rcNt); } while (0)
3000
3001	#endif /* RT_OS_WINDOWS */
3002
3003	/** @} */
3004
3005	/** @} */
3006
3007	#endif /* !IPRT_INCLUDED_assert_h */
3008

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/include/iprt/assert.h@ 105688

Download in other formats: